DFBResult
CoreGraphicsStateClient_DrawLines( CoreGraphicsStateClient *client,
const DFBRegion *lines,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( lines != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
// FIXME: will overwrite lines
dfb_gfxcard_drawlines( (DFBRegion*) lines, num, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_DRAWLINE, client->state );
ret = CoreGraphicsState_DrawLines( client->gfx_state, lines, num );
if (ret)
return ret;
}
return DFB_OK;
}
static DFBResult
dfb_rtd_set_video_mode( CoreDFB *core, CoreLayerRegionConfig *config )
{
int ret;
CoreLayerRegionConfig *tmp = NULL;
D_ASSERT( config != NULL );
if (dfb_core_is_master( core ))
return dfb_rtd_set_video_mode_handler( config );
if (!fusion_is_shared( dfb_core_world(core), config )) {
tmp = SHMALLOC( dfb_core_shmpool(core), sizeof(CoreLayerRegionConfig) );
if (!tmp)
return D_OOSHM();
direct_memcpy( tmp, config, sizeof(CoreLayerRegionConfig) );
}
fusion_call_execute( &dfb_rtd->call, FCEF_NONE, RTD_SET_VIDEO_MODE,
tmp ? tmp : config, &ret );
if (tmp)
SHFREE( dfb_core_shmpool(core), tmp );
return ret;
}
DFBResult
CoreGraphicsStateClient_TextureTriangles( CoreGraphicsStateClient *client,
const DFBVertex *vertices,
int num,
DFBTriangleFormation formation )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( vertices != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
// FIXME: may overwrite vertices
dfb_gfxcard_texture_triangles( (DFBVertex*) vertices, num, formation, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_TEXTRIANGLES, client->state );
ret = CoreGraphicsState_TextureTriangles( client->gfx_state, vertices, num, formation );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_Blit( CoreGraphicsStateClient *client,
const DFBRectangle *rects,
const DFBPoint *points,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( rects != NULL );
D_ASSERT( points != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
// FIXME: will overwrite rects, points
dfb_gfxcard_batchblit( (DFBRectangle*) rects, (DFBPoint*) points, num, client->state );
}
else {
DFBResult ret;
unsigned int i;
CoreGraphicsStateClient_Update( client, DFXL_BLIT, client->state );
for (i=0; i<num; i+=200) {
ret = CoreGraphicsState_Blit( client->gfx_state, &rects[i], &points[i], MIN(200, num-i) );
if (ret)
return ret;
}
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_TileBlit( CoreGraphicsStateClient *client,
const DFBRectangle *rects,
const DFBPoint *points1,
const DFBPoint *points2,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( rects != NULL );
D_ASSERT( points1 != NULL );
D_ASSERT( points2 != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
u32 i;
// FIXME: will overwrite rects, points
for (i=0; i<num; i++)
dfb_gfxcard_tileblit( (DFBRectangle*) &rects[i], points1[i].x, points1[i].y, points2[i].x, points2[i].y, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_BLIT, client->state );
ret = CoreGraphicsState_TileBlit( client->gfx_state, rects, points1, points2, num );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_Blit2( CoreGraphicsStateClient *client,
const DFBRectangle *rects,
const DFBPoint *points1,
const DFBPoint *points2,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( rects != NULL );
D_ASSERT( points1 != NULL );
D_ASSERT( points2 != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
// FIXME: will overwrite rects, points
dfb_gfxcard_batchblit2( (DFBRectangle*) rects, (DFBPoint*) points1, (DFBPoint*) points2, num, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_BLIT2, client->state );
ret = CoreGraphicsState_Blit2( client->gfx_state, rects, points1, points2, num );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_FillTrapezoids( CoreGraphicsStateClient *client,
const DFBTrapezoid *trapezoids,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( trapezoids != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
dfb_gfxcard_filltrapezoids( trapezoids, num, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_FILLTRAPEZOID, client->state );
ret = CoreGraphicsState_FillTrapezoids( client->gfx_state, trapezoids, num );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_FillSpans( CoreGraphicsStateClient *client,
int y,
const DFBSpan *spans,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( spans != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
// FIXME: may overwrite spans
dfb_gfxcard_fillspans( y, (DFBSpan*) spans, num, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_FILLRECTANGLE, client->state );
ret = CoreGraphicsState_FillSpans( client->gfx_state, y, spans, num );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_DrawRectangles( CoreGraphicsStateClient *client,
const DFBRectangle *rects,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( rects != NULL );
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
unsigned int i;
for (i=0; i<num; i++)
// FIXME: will overwrite rects
dfb_gfxcard_drawrectangle( (DFBRectangle*) &rects[i], client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_DRAWRECTANGLE, client->state );
ret = CoreGraphicsState_DrawRectangles( client->gfx_state, rects, num );
if (ret)
return ret;
}
return DFB_OK;
}
static DFBResult
dfb_rtd_update_screen( CoreDFB *core, DFBRegion *region )
{
int ret;
DFBRegion *tmp = NULL;
if (dfb_core_is_master( core ))
return dfb_rtd_update_screen_handler( region );
if (region) {
if (!fusion_is_shared( dfb_core_world(core), region )) {
tmp = SHMALLOC( dfb_core_shmpool(core), sizeof(DFBRegion) );
if (!tmp)
return D_OOSHM();
direct_memcpy( tmp, region, sizeof(DFBRegion) );
}
}
fusion_call_execute( &dfb_rtd->call, FCEF_NONE, RTD_UPDATE_SCREEN,
tmp ? tmp : region, &ret );
if (tmp)
SHFREE( dfb_core_shmpool(core), tmp );
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_StretchBlit( CoreGraphicsStateClient *client,
const DFBRectangle *srects,
const DFBRectangle *drects,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( srects != NULL );
D_ASSERT( drects != NULL );
if (num == 0)
return DFB_OK;
if (num != 1)
D_UNIMPLEMENTED();
if (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion) {
// FIXME: will overwrite rects
dfb_gfxcard_stretchblit( (DFBRectangle*) srects, (DFBRectangle*) drects, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_STRETCHBLIT, client->state );
ret = CoreGraphicsState_StretchBlit( client->gfx_state, srects, drects, num );
if (ret)
return ret;
}
return DFB_OK;
}
DFBResult
CoreGraphicsStateClient_FillRectangles( CoreGraphicsStateClient *client,
const DFBRectangle *rects,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( rects != NULL );
if (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion) {
dfb_gfxcard_fillrectangles( rects, num, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_FILLRECTANGLE, client->state );
ret = CoreGraphicsState_FillRectangles( client->gfx_state, rects, num );
if (ret)
return ret;
}
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
DirectResult ret;
VMWareDriverData *drv = driver_data;
if (!fusion_config->secure_fusion || dfb_core_is_master(core)) {
ret = direct_processor_init( &drv->processor, "Virtual2D", virtual2DFuncs, sizeof(Virtual2DPacket), drv, 0 );
if (ret)
return ret;
}
/* initialize function pointers */
funcs->EngineSync = vmwareEngineSync;
funcs->WaitSerial = vmwareWaitSerial;
funcs->GetSerial = vmwareGetSerial;
funcs->EngineReset = vmwareEngineReset;
funcs->EmitCommands = vmwareEmitCommands;
funcs->CheckState = vmwareCheckState;
funcs->SetState = vmwareSetState;
funcs->FillRectangle = vmwareFillRectangle;
funcs->Blit = vmwareBlit;
return DFB_OK;
}
static void
driver_close_driver( CoreGraphicsDevice *device,
void *driver_data )
{
VMWareDriverData *drv = driver_data;
if (!fusion_config->secure_fusion || dfb_core_is_master(core_dfb))
direct_processor_destroy( &drv->processor );
}
DFBResult
CoreGraphicsStateClient_StretchBlit( CoreGraphicsStateClient *client,
const DFBRectangle *srects,
const DFBRectangle *drects,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( srects != NULL );
D_ASSERT( drects != NULL );
if (num == 0)
return DFB_OK;
if (!dfb_config->call_nodirect && (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion)) {
if (num == 1 && srects[0].w == drects[0].w && srects[0].h == drects[0].h) {
DFBPoint point = { drects[0].x, drects[0].y };
// FIXME: will overwrite rects, points
dfb_gfxcard_batchblit( (DFBRectangle*) srects, &point, 1, client->state );
}
else {
// FIXME: will overwrite rects
dfb_gfxcard_batchstretchblit( (DFBRectangle*) srects, (DFBRectangle*) drects, num, client->state );
}
}
else {
DFBResult ret;
if (num == 1 && srects[0].w == drects[0].w && srects[0].h == drects[0].h) {
CoreGraphicsStateClient_Update( client, DFXL_BLIT, client->state );
DFBPoint point = { drects[0].x, drects[0].y };
ret = CoreGraphicsState_Blit( client->gfx_state, srects, &point, 1 );
if (ret)
return ret;
}
else {
CoreGraphicsStateClient_Update( client, DFXL_STRETCHBLIT, client->state );
ret = CoreGraphicsState_StretchBlit( client->gfx_state, srects, drects, num );
if (ret)
return ret;
}
}
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = device_data;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
/* Keep pointer to shared device data. */
sdrv->dev = device_data;
/* Keep core and device pointer. */
sdrv->core = core;
sdrv->device = device;
/* Open the drawing engine device. */
sdrv->gfx_fd = direct_try_open( "/dev/sh7722gfx", "/dev/misc/sh7722gfx", O_RDWR, true );
if (sdrv->gfx_fd < 0)
return DFB_INIT;
/* Map its shared data. */
sdrv->gfx_shared = mmap( NULL, direct_page_align( sizeof(SH7722GfxSharedArea) ),
PROT_READ | PROT_WRITE,
MAP_SHARED, sdrv->gfx_fd, 0 );
if (sdrv->gfx_shared == MAP_FAILED) {
D_PERROR( "SH7722/Driver: Could not map shared area!\n" );
close( sdrv->gfx_fd );
return DFB_INIT;
}
sdrv->mmio_base = dfb_gfxcard_map_mmio( device, 0, -1 );
if (!sdrv->mmio_base) {
D_PERROR( "SH7722/Driver: Could not map MMIO area!\n" );
munmap( (void*) sdrv->gfx_shared, direct_page_align( sizeof(SH7722GfxSharedArea) ) );
close( sdrv->gfx_fd );
return DFB_INIT;
}
/* Check the magic value. */
if (sdrv->gfx_shared->magic != SH7722GFX_SHARED_MAGIC) {
D_ERROR( "SH7722/Driver: Magic value 0x%08x doesn't match 0x%08x!\n",
sdrv->gfx_shared->magic, SH7722GFX_SHARED_MAGIC );
dfb_gfxcard_unmap_mmio( device, sdrv->mmio_base, -1 );
munmap( (void*) sdrv->gfx_shared, direct_page_align( sizeof(SH7722GfxSharedArea) ) );
close( sdrv->gfx_fd );
return DFB_INIT;
}
/* Get virtual addresses for LCD buffer and JPEG reload buffers in slaves here,
master does it in driver_init_device(). */
if (!dfb_core_is_master( core )) {
sdrv->lcd_virt = dfb_gfxcard_memory_virtual( device, sdev->lcd_offset );
sdrv->jpeg_virt = dfb_gfxcard_memory_virtual( device, sdev->jpeg_offset );
}
/* Initialize function table. */
funcs->EngineReset = sh7722EngineReset;
funcs->EngineSync = sh7722EngineSync;
funcs->EmitCommands = sh7722EmitCommands;
funcs->CheckState = sh7722CheckState;
funcs->SetState = sh7722SetState;
funcs->FillTriangle = sh7722FillTriangle;
funcs->Blit = sh7722Blit;
funcs->StretchBlit = sh7722StretchBlit;
funcs->FlushTextureCache = sh7722FlushTextureCache;
/* Register primary screen. */
sdrv->screen = dfb_screens_register( device, driver_data, &sh7722ScreenFuncs );
/* Register three input system layers. */
sdrv->input1 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
sdrv->input2 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
sdrv->input3 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
/* Register multi window layer. */
sdrv->multi = dfb_layers_register( sdrv->screen, driver_data, &sh7722MultiLayerFuncs );
return DFB_OK;
}
/*
* Programs have to call this to get the super interface
* which is needed to access other functions
*/
DFBResult
DirectFBCreate( IDirectFB **interface )
{
DFBResult ret;
IDirectFB *dfb;
CoreDFB *core_dfb;
if (!dfb_config) {
/* don't use D_ERROR() here, it uses dfb_config */
direct_log_printf( NULL, "(!) DirectFBCreate: DirectFBInit "
"has to be called before DirectFBCreate!\n" );
return DFB_INIT;
}
if (!interface)
return DFB_INVARG;
if (idirectfb_singleton) {
idirectfb_singleton->AddRef( idirectfb_singleton );
*interface = idirectfb_singleton;
return DFB_OK;
}
direct_initialize();
if ( !(direct_config->quiet & DMT_BANNER) && dfb_config->banner) {
direct_log_printf( NULL,
"\n"
" ~~~~~~~~~~~~~~~~~~~~~~~~~~| DirectFB " DIRECTFB_VERSION " |~~~~~~~~~~~~~~~~~~~~~~~~~~\n"
" (c) 2001-2009 The world wide DirectFB Open Source Community\n"
" (c) 2000-2004 Convergence (integrated media) GmbH\n"
" ----------------------------------------------------------------\n"
"\n" );
}
if (dfb_config->remote.host)
return CreateRemote( dfb_config->remote.host, dfb_config->remote.session, interface );
ret = dfb_core_create( &core_dfb );
if (ret)
return ret;
DIRECT_ALLOCATE_INTERFACE( dfb, IDirectFB );
ret = IDirectFB_Construct( dfb, core_dfb );
if (ret) {
dfb_core_destroy( core_dfb, false );
return ret;
}
if (dfb_core_is_master( core_dfb )) {
/* not fatal */
ret = dfb_wm_post_init( core_dfb );
if (ret)
D_DERROR( ret, "DirectFBCreate: Post initialization of WM failed!\n" );
dfb_core_activate( core_dfb );
}
*interface = idirectfb_singleton = dfb;
return DFB_OK;
}