static DFBResult
system_initialize( CoreDFB *core, void **data )
{
CoreScreen *core_screen;
D_ASSERT( dfb_vnc == NULL );
dfb_vnc = (DFBVNC*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBVNC) );
if (!dfb_vnc) {
D_ERROR( "DirectFB/VNC: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_vnc_core = core;
fusion_skirmish_init( &dfb_vnc->lock, "VNC System", dfb_core_world(core) );
fusion_call_init( &dfb_vnc->call, dfb_vnc_call_handler, NULL, dfb_core_world(core) );
core_screen = dfb_screens_register( NULL, NULL, &vncPrimaryScreenFuncs );
dfb_layers_register( core_screen, NULL, &vncPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "vnc", dfb_vnc );
*data = dfb_vnc;
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
char *driver;
CoreScreen *screen;
D_ASSERT( dfb_osx == NULL );
dfb_osx = (DFBOSX*) SHCALLOC( dfb_core_shmpool(dfb_osx_core), 1, sizeof(DFBOSX) );
if (!dfb_osx) {
D_ERROR( "DirectFB/OSX: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_osx_core = core;
/* Initialize OSX */
fusion_skirmish_init( &dfb_osx->lock, "OSX System", dfb_core_world(core) );
fusion_call_init( &dfb_osx->call, dfb_osx_call_handler, NULL, dfb_core_world(core) );
screen = dfb_screens_register( NULL, NULL, &osxPrimaryScreenFuncs );
dfb_layers_register( screen, NULL, &osxPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "OSX", dfb_osx );
*data = dfb_osx;
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
char *driver;
CoreScreen *screen;
D_ASSERT( dfb_sdl == NULL );
dfb_sdl = (DFBSDL*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBSDL) );
if (!dfb_sdl) {
D_ERROR( "DirectFB/SDL: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_sdl_core = core;
dfb_fbdev_read_modes(); /* use same mode list as a fake */
driver = getenv( "SDL_VIDEODRIVER" );
if (driver && !strcasecmp( driver, "directfb" )) {
D_INFO( "DirectFB/SDL: SDL_VIDEODRIVER is 'directfb', unsetting it.\n" );
unsetenv( "SDL_VIDEODRIVER" );
}
/* Initialize SDL */
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
D_ERROR( "DirectFB/SDL: Couldn't initialize SDL: %s\n", SDL_GetError() );
SHFREE( dfb_core_shmpool(core), dfb_sdl );
dfb_sdl = NULL;
return DFB_INIT;
}
fusion_skirmish_init( &dfb_sdl->lock, "SDL System", dfb_core_world(core) );
fusion_call_init( &dfb_sdl->call, dfb_sdl_call_handler, NULL, dfb_core_world(core) );
screen = dfb_screens_register( NULL, NULL, sdlPrimaryScreenFuncs );
dfb_layers_register( screen, NULL, sdlPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "sdl", dfb_sdl );
dfb_surface_pool_initialize( core, &sdlSurfacePoolFuncs, &dfb_sdl->sdl_pool );
*data = dfb_sdl;
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;
}
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;
}
static DFBResult
sharedInitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
DFBResult ret;
SharedPoolData *data = pool_data;
SharedPoolLocalData *local = pool_local;
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( ret_desc != NULL );
local->core = core;
local->world = dfb_core_world( core );
ret = fusion_shm_pool_create( local->world, "Surface Memory Pool", dfb_config->surface_shmpool_size,
fusion_config->debugshm, &data->shmpool );
if (ret)
return ret;
ret_desc->caps = CSPCAPS_VIRTUAL;
ret_desc->access[CSAID_CPU] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT | CSTF_SHARED | CSTF_INTERNAL;
ret_desc->priority = (dfb_system_caps() & CSCAPS_PREFER_SHM) ? CSPP_PREFERED : CSPP_DEFAULT;
if (dfb_system_caps() & CSCAPS_SYSMEM_EXTERNAL)
ret_desc->types |= CSTF_EXTERNAL;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "Shared Memory" );
return DFB_OK;
}
static DFBResult
init_bridge( CoreDFB *core,
CoreSurfacePoolBridge *bridge,
const SurfacePoolBridgeFuncs *funcs,
void *context )
{
DFBResult ret;
D_MAGIC_ASSERT( bridge, CoreSurfacePoolBridge );
D_ASSERT( funcs != NULL );
D_ASSERT( funcs->InitPoolBridge != NULL );
D_DEBUG_AT( Core_SurfPoolBridge, "%s( %p, %p )\n", __FUNCTION__, bridge, funcs );
if (funcs->PoolBridgeDataSize)
bridge->bridge_data_size = funcs->PoolBridgeDataSize();
if (funcs->PoolBridgeLocalDataSize)
bridge->bridge_local_data_size = funcs->PoolBridgeLocalDataSize();
if (funcs->PoolTransferDataSize)
bridge->transfer_data_size = funcs->PoolTransferDataSize();
/* Allocate shared bridge data. */
if (bridge->bridge_data_size) {
bridge->data = SHCALLOC( bridge->shmpool, 1, bridge->bridge_data_size );
if (!bridge->data)
return D_OOSHM();
}
/* Allocate local bridge data. */
if (bridge->bridge_local_data_size &&
!(bridge_locals[bridge->bridge_id] = D_CALLOC( 1, bridge->bridge_local_data_size )))
{
SHFREE( bridge->shmpool, bridge->data );
return D_OOM();
}
ret = funcs->InitPoolBridge( core, bridge, bridge->data, get_local(bridge), context, &bridge->desc );
if (ret) {
D_DERROR( ret, "Core/SurfacePoolBridge: Initializing '%s' failed!\n", bridge->desc.name );
if (bridge_locals[bridge->bridge_id]) {
D_FREE( bridge_locals[bridge->bridge_id] );
bridge_locals[bridge->bridge_id] = NULL;
}
if (bridge->data) {
SHFREE( bridge->shmpool, bridge->data );
bridge->data = NULL;
}
return ret;
}
fusion_skirmish_init2( &bridge->lock, bridge->desc.name, dfb_core_world(core), fusion_config->secure_fusion );
return DFB_OK;
}
DFBResult
ISaWManWM_Real::RegisterProcess(
SaWManProcessFlags flags,
s32 pid,
u32 fusion_id,
SaWManProcess **ret_process
)
{
D_DEBUG_AT( DirectFB_SaWMan, "%s()", __FUNCTION__ );
return (DFBResult) sawman_register_process( obj, flags, pid, fusion_id, dfb_core_world(core), ret_process );
}
static void
initialize_data( CoreDFB *core, WMData *data, WMShared *shared )
{
D_ASSERT( data != NULL );
/* Initialize local data. */
data->core = core;
data->world = dfb_core_world( core );
data->shared = shared;
data->module_abi = UNIQUE_WM_ABI_VERSION;
/* Set module callbacks. */
data->context_notify = context_notify;
data->window_notify = window_notify;
}
DFBResult
dfb_layer_region_create( CoreLayerContext *context,
CoreLayerRegion **ret_region )
{
CoreLayer *layer;
CoreLayerRegion *region;
D_ASSERT( context != NULL );
D_ASSERT( ret_region != NULL );
layer = dfb_layer_at( context->layer_id );
/* Create the object. */
region = dfb_core_create_layer_region( layer->core );
if (!region)
return DFB_FUSION;
/* Link the context into the structure. */
if (dfb_layer_context_link( ®ion->context, context )) {
fusion_object_destroy( ®ion->object );
return DFB_FUSION;
}
/* Initialize the lock. */
if (fusion_skirmish_init( ®ion->lock, "Layer Region", dfb_core_world(layer->core) )) {
dfb_layer_context_unlink( ®ion->context );
fusion_object_destroy( ®ion->object );
return DFB_FUSION;
}
/* Change global reaction lock. */
fusion_object_set_lock( ®ion->object, ®ion->lock );
region->state = CLRSF_FROZEN;
/* Activate the object. */
fusion_object_activate( ®ion->object );
/* Add the region to the context. */
dfb_layer_context_add_region( context, region );
/* Return the new region. */
*ret_region = region;
return DFB_OK;
}
DFBResult
ICore_Real::GetSurface( u32 surface_id,
CoreSurface **ret_surface )
{
DFBResult ret;
CoreSurface *surface;
char path[1000];
size_t path_length;
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Real::%s( %u )\n", __FUNCTION__, surface_id );
D_MAGIC_ASSERT( obj, CoreDFB );
if (fusion_config->secure_fusion) {
ret = (DFBResult) fusion_get_fusionee_path( dfb_core_world(core), Core_GetIdentity(), path, sizeof(path), &path_length );
if (ret)
return ret;
D_DEBUG_AT( DirectFB_CoreDFB, " -> '%s'\n", path );
}
ret = dfb_core_get_surface( core, surface_id, &surface );
if (ret)
return ret;
if (fusion_config->secure_fusion) {
ret = (DFBResult) fusion_object_has_access( &surface->object, path );
if (ret) {
D_DEBUG_AT( DirectFB_CoreDFB, " -> NO ACCESS!\n" );
dfb_surface_unref( surface );
return ret;
}
// FIXME: access to this object needs to be given for other places like using as a blitting source
surface->object.owner = Core_GetIdentity();
}
*ret_surface = surface;
return DFB_OK;
}
static DFBResult
dfb_clipboard_core_initialize( CoreDFB *core,
DFBClipboardCore *data,
DFBClipboardCoreShared *shared )
{
D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_initialize( %p, %p, %p )\n", core, data, shared );
D_ASSERT( data != NULL );
D_ASSERT( shared != NULL );
data->core = core;
data->shared = shared;
shared->shmpool = dfb_core_shmpool( core );
fusion_skirmish_init( &shared->lock, "Clipboard Core", dfb_core_world(core) );
D_MAGIC_SET( data, DFBClipboardCore );
D_MAGIC_SET( shared, DFBClipboardCoreShared );
return DFB_OK;
}
int
dfb_state_init( CardState *state, CoreDFB *core )
{
D_ASSERT( state != NULL );
memset( state, 0, sizeof(CardState) );
state->core = core;
state->fusion_id = fusion_id( dfb_core_world(core) );
state->modified = SMF_ALL;
state->src_blend = DSBF_SRCALPHA;
state->dst_blend = DSBF_INVSRCALPHA;
state->render_options = dfb_config->render_options;
state->matrix[0] = 0x10000;
state->matrix[1] = 0x00000;
state->matrix[2] = 0x00000;
state->matrix[3] = 0x00000;
state->matrix[4] = 0x10000;
state->matrix[5] = 0x00000;
state->matrix[6] = 0x00000;
state->matrix[7] = 0x00000;
state->matrix[8] = 0x10000;
state->affine_matrix = DFB_TRUE;
state->from = CSBR_FRONT;
state->to = CSBR_BACK;
direct_util_recursive_pthread_mutex_init( &state->lock );
direct_serial_init( &state->dst_serial );
direct_serial_init( &state->src_serial );
direct_serial_init( &state->src_mask_serial );
direct_serial_init( &state->src2_serial );
D_MAGIC_SET( state, CardState );
return 0;
}
static DFBResult
dfb_colorhash_core_initialize( CoreDFB *core,
DFBColorHashCore *data,
DFBColorHashCoreShared *shared )
{
D_DEBUG_AT( Core_ColorHash, "dfb_colorhash_core_initialize( %p, %p, %p )\n", core, data, shared );
D_ASSERT( data != NULL );
D_ASSERT( shared != NULL );
core_colorhash = data; /* FIXME */
data->core = core;
data->shared = shared;
shared->shmpool = dfb_core_shmpool( core );
fusion_skirmish_init( &shared->hash_lock, "Colorhash Core", dfb_core_world(core) );
D_MAGIC_SET( data, DFBColorHashCore );
D_MAGIC_SET( shared, DFBColorHashCoreShared );
return DFB_OK;
}
static DFBResult
driver_init_device( CoreGraphicsDevice *device,
GraphicsDeviceInfo *device_info,
void *driver_data,
void *device_data )
{
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = device_data;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
/* FIXME: Add a runtime option / config file. */
sdev->lcd_format = DSPF_RGB16;
/* Check format of LCD buffer. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
case DSPF_NV16:
break;
default:
return DFB_UNSUPPORTED;
}
if (sdev->sh772x == 7723)
memset( dfb_gfxcard_memory_virtual(device,0), 0, dfb_gfxcard_memory_length() );
/*
* Setup LCD buffer.
*/
#ifdef SH772X_FBDEV_SUPPORT
{
struct fb_fix_screeninfo fsi;
struct fb_var_screeninfo vsi;
int fbdev;
if ((fbdev = open("/dev/fb", O_RDONLY)) < 0) {
D_ERROR( "SH7722/Driver: Can't open fbdev to get LCDC info!\n" );
return DFB_FAILURE;
}
if (ioctl(fbdev, FBIOGET_FSCREENINFO, &fsi) < 0) {
D_ERROR( "SH7722/Driver: FBIOGET_FSCREEINFO failed.\n" );
close(fbdev);
return DFB_FAILURE;
}
if (ioctl(fbdev, FBIOGET_VSCREENINFO, &vsi) < 0) {
D_ERROR( "SH7722/Driver: FBIOGET_VSCREEINFO failed.\n" );
close(fbdev);
return DFB_FAILURE;
}
sdev->lcd_width = vsi.xres;
sdev->lcd_height = vsi.yres;
sdev->lcd_pitch = fsi.line_length;
sdev->lcd_size = fsi.smem_len;
sdev->lcd_offset = 0;
sdev->lcd_phys = fsi.smem_start;
#if 0
sdrv->lcd_virt = mmap(NULL, fsi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED,
fbdev, 0);
if (sdrv->lcd_virt == MAP_FAILED) {
D_PERROR( "SH7722/Driver: mapping fbdev failed.\n" );
close(fbdev);
return DFB_FAILURE;
}
/* Clear LCD buffer. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
memset( (void*) sdrv->lcd_virt, 0x00, sdev->lcd_height * sdev->lcd_pitch );
break;
case DSPF_NV16:
memset( (void*) sdrv->lcd_virt, 0x10, sdev->lcd_height * sdev->lcd_pitch );
memset( (void*) sdrv->lcd_virt + sdev->lcd_height * sdev->lcd_pitch, 0x80, sdev->lcd_height * sdev->lcd_pitch );
break;
default:
D_BUG( "unsupported format" );
return DFB_BUG;
}
#endif
close(fbdev);
}
#else
sdev->lcd_width = SH7722_LCD_WIDTH;
sdev->lcd_height = SH7722_LCD_HEIGHT;
sdev->lcd_pitch = (DFB_BYTES_PER_LINE( sdev->lcd_format, sdev->lcd_width ) + 0xf) & ~0xf;
sdev->lcd_size = DFB_PLANE_MULTIPLY( sdev->lcd_format, sdev->lcd_height ) * sdev->lcd_pitch;
sdev->lcd_offset = dfb_gfxcard_reserve_memory( device, sdev->lcd_size );
if (sdev->lcd_offset < 0) {
D_ERROR( "SH7722/Driver: Allocating %d bytes for the LCD buffer failed!\n", sdev->lcd_size );
return DFB_FAILURE;
}
sdev->lcd_phys = dfb_gfxcard_memory_physical( device, sdev->lcd_offset );
/* Get virtual addresses for LCD buffer in master here,
slaves do it in driver_init_driver(). */
sdrv->lcd_virt = dfb_gfxcard_memory_virtual( device, sdev->lcd_offset );
#endif
D_INFO( "SH7722/LCD: Allocated %dx%d %s Buffer (%d bytes) at 0x%08lx (%p)\n",
sdev->lcd_width, sdev->lcd_height, dfb_pixelformat_name(sdev->lcd_format),
sdev->lcd_size, sdev->lcd_phys, sdrv->lcd_virt );
D_ASSERT( ! (sdev->lcd_pitch & 0xf) );
D_ASSERT( ! (sdev->lcd_phys & 0xf) );
/*
* Initialize hardware.
*/
switch (sdev->sh772x) {
case 7722:
/* Reset the drawing engine. */
sh7722EngineReset( sdrv, sdev );
/* Fill in the device info. */
snprintf( device_info->name, DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "SH7722" );
snprintf( device_info->vendor, DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "Renesas" );
/* Set device limitations. */
device_info->limits.surface_byteoffset_alignment = 16;
device_info->limits.surface_bytepitch_alignment = 8;
/* Set device capabilities. */
device_info->caps.flags = CCF_CLIPPING | CCF_RENDEROPTS;
device_info->caps.accel = SH7722_SUPPORTED_DRAWINGFUNCTIONS |
SH7722_SUPPORTED_BLITTINGFUNCTIONS;
device_info->caps.drawing = SH7722_SUPPORTED_DRAWINGFLAGS;
device_info->caps.blitting = SH7722_SUPPORTED_BLITTINGFLAGS;
/* Change font format for acceleration. */
if (!dfb_config->software_only) {
dfb_config->font_format = DSPF_ARGB;
dfb_config->font_premult = false;
}
break;
case 7723:
/* Reset the drawing engine. */
sh7723EngineReset( sdrv, sdev );
/* Fill in the device info. */
snprintf( device_info->name, DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "SH7723" );
snprintf( device_info->vendor, DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "Renesas" );
/* Set device limitations. */
device_info->limits.surface_byteoffset_alignment = 512;
device_info->limits.surface_bytepitch_alignment = 64;
/* Set device capabilities. */
device_info->caps.flags = CCF_CLIPPING | CCF_RENDEROPTS;
device_info->caps.accel = SH7723_SUPPORTED_DRAWINGFUNCTIONS | \
SH7723_SUPPORTED_BLITTINGFUNCTIONS;
device_info->caps.drawing = SH7723_SUPPORTED_DRAWINGFLAGS;
device_info->caps.blitting = SH7723_SUPPORTED_BLITTINGFLAGS;
break;
default:
D_BUG( "unexpected device" );
return DFB_BUG;
}
/* Wait for idle BEU. */
while (SH7722_GETREG32( sdrv, BSTAR ) & 1);
/* Disable all inputs. */
SH7722_SETREG32( sdrv, BESTR, 0 );
/* Disable all multi windows. */
SH7722_SETREG32( sdrv, BMWCR0, SH7722_GETREG32( sdrv, BMWCR0 ) & ~0xf );
#ifndef SH772X_FBDEV_SUPPORT
/* Clear LCD buffer. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
memset( (void*) sdrv->lcd_virt, 0x00, sdev->lcd_height * sdev->lcd_pitch );
break;
case DSPF_NV16:
memset( (void*) sdrv->lcd_virt, 0x10, sdev->lcd_height * sdev->lcd_pitch );
memset( (void*) sdrv->lcd_virt + sdev->lcd_height * sdev->lcd_pitch, 0x80, sdev->lcd_height * sdev->lcd_pitch );
break;
default:
D_BUG( "unsupported format" );
return DFB_BUG;
}
#endif
/*
* TODO: Make LCD Buffer format and primary BEU format runtime configurable.
*/
/* Set output pixel format of the BEU. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
SH7722_SETREG32( sdrv, BPKFR, BPKFR_RY_RGB | WPCK_RGB16 );
break;
case DSPF_NV16:
SH7722_SETREG32( sdrv, BPKFR, BPKFR_RY_RGB | BPKFR_TE_ENABLED | CHDS_YCBCR422 );
SH7722_SETREG32( sdrv, BDACR, sdev->lcd_phys + sdev->lcd_height * sdev->lcd_pitch );
break;
default:
D_BUG( "unsupported format" );
return DFB_BUG;
}
SH7722_SETREG32( sdrv, BPROCR, 0x00000000 );
/* Have BEU render into LCD buffer. */
SH7722_SETREG32( sdrv, BBLCR1, MT_MEMORY );
SH7722_SETREG32( sdrv, BDAYR, sdev->lcd_phys & 0xfffffffc );
SH7722_SETREG32( sdrv, BDMWR, sdev->lcd_pitch & 0x0003fffc );
#ifndef SH772X_FBDEV_SUPPORT
/* Setup LCD controller to show the buffer. */
sh7722_lcd_setup( sdrv, sdev->lcd_width, sdev->lcd_height,
sdev->lcd_phys, sdev->lcd_pitch, sdev->lcd_format, false );
#endif
/* Initialize BEU lock. */
fusion_skirmish_init( &sdev->beu_lock, "BEU", dfb_core_world(sdrv->core) );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
DFBResult ret;
DFBX11 *x11;
DFBX11Shared *shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
x11 = D_CALLOC( 1, sizeof(DFBX11) );
if (!x11)
return D_OOM();
shared = SHCALLOC( dfb_core_shmpool( core ), 1, sizeof(DFBX11Shared) );
if (!shared) {
D_FREE( x11 );
return D_OOSHM();
}
/* we need the error handler to signal the error to us, so
use a global static */
shared_for_error_handler = shared;
XSetErrorHandler( error_handler );
/*
* Local init (master and slave)
*/
ret = InitLocal( x11, shared, core );
if (ret) {
SHFREE( dfb_core_shmpool( core ), shared );
D_FREE( x11 );
return ret;
}
/*
* Shared init (master only)
*/
shared->data_shmpool = dfb_core_shmpool_data( core );
shared->screen_size.w = x11->screenptr->width;
shared->screen_size.h = x11->screenptr->height;
fusion_skirmish_init( &shared->lock, "X11 System", dfb_core_world(core) );
fusion_call_init( &shared->call, call_handler, x11, dfb_core_world(core) );
/*
* Must be set before initializing the pools!
*/
*data = x11;
/*
* Master init
*/
dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &shared->x11image_pool );
#ifdef USE_GLX
dfb_surface_pool_initialize( core, &glxSurfacePoolFuncs, &shared->glx_pool );
#endif
if (dfb_config->video_length) {
shared->vpsmem_length = dfb_config->video_length;
dfb_surface_pool_initialize( core, &vpsmemSurfacePoolFuncs, &shared->vpsmem_pool );
}
#ifdef USE_GLX
dfb_surface_pool_bridge_initialize( core, &x11SurfacePoolBridgeFuncs, x11, &shared->x11_pool_bridge );
#endif
fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", shared );
return DFB_OK;
}
static DFBResult
driver_init_device( CoreGraphicsDevice *device,
GraphicsDeviceInfo *device_info,
void *driver_data,
void *device_data )
{
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = device_data;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
/* FIXME: Add a runtime option / config file. */
sdev->lcd_format = DSPF_RGB16;
/* Check format of LCD buffer. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
case DSPF_NV16:
break;
default:
return DFB_UNSUPPORTED;
}
/*
* Setup LCD buffer.
*/
sdev->lcd_width = SH7722_LCD_WIDTH;
sdev->lcd_height = SH7722_LCD_HEIGHT;
sdev->lcd_pitch = (DFB_BYTES_PER_LINE( sdev->lcd_format, sdev->lcd_width ) + 0xf) & ~0xf;
sdev->lcd_size = DFB_PLANE_MULTIPLY( sdev->lcd_format, sdev->lcd_height ) * sdev->lcd_pitch;
sdev->lcd_offset = dfb_gfxcard_reserve_memory( device, sdev->lcd_size );
if (sdev->lcd_offset < 0) {
D_ERROR( "SH7722/Driver: Allocating %d bytes for the LCD buffer failed!\n", sdev->lcd_size );
return DFB_FAILURE;
}
sdev->lcd_phys = dfb_gfxcard_memory_physical( device, sdev->lcd_offset );
/* Get virtual addresses for JPEG reload buffers in master here,
slaves do it in driver_init_driver(). */
sdrv->lcd_virt = dfb_gfxcard_memory_virtual( device, sdev->lcd_offset );
D_INFO( "SH7722/LCD: Allocated %dx%d %s Buffer (%d bytes) at 0x%08lx (%p)\n",
sdev->lcd_width, sdev->lcd_height, dfb_pixelformat_name(sdev->lcd_format),
sdev->lcd_size, sdev->lcd_phys, sdrv->lcd_virt );
D_ASSERT( ! (sdev->lcd_pitch & 0xf) );
D_ASSERT( ! (sdev->lcd_phys & 0xf) );
/*
* Setup JPEG reload buffers.
*/
sdev->jpeg_size = SH7722GFX_JPEG_RELOAD_SIZE * 2 + SH7722GFX_JPEG_LINEBUFFER_SIZE * 2;
sdev->jpeg_offset = dfb_gfxcard_reserve_memory( device, sdev->jpeg_size );
if (sdev->jpeg_offset < 0) {
D_ERROR( "SH7722/Driver: Allocating %d bytes for the JPEG reload and line buffers failed!\n", sdev->jpeg_size );
return DFB_FAILURE;
}
sdev->jpeg_phys = dfb_gfxcard_memory_physical( device, sdev->jpeg_offset );
sdev->jpeg_lb1 = sdev->jpeg_phys + SH7722GFX_JPEG_RELOAD_SIZE * 2;
sdev->jpeg_lb2 = sdev->jpeg_lb1 + SH7722GFX_JPEG_LINEBUFFER_SIZE;
/* Get virtual addresses for JPEG reload buffers in master here,
slaves do it in driver_init_driver(). */
sdrv->jpeg_virt = dfb_gfxcard_memory_virtual( device, sdev->jpeg_offset );
D_INFO( "SH7722/JPEG: Allocated reload and line buffers (%d bytes) at 0x%08lx (%p)\n",
sdev->jpeg_size, sdev->jpeg_phys, sdrv->jpeg_virt );
D_ASSERT( ! (sdev->jpeg_size & 0xff) );
D_ASSERT( ! (sdev->jpeg_phys & 0xf) );
/* Fill in the device info. */
snprintf( device_info->name, DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "SH7722" );
snprintf( device_info->vendor, DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "Renesas" );
/* Set device limitations. */
device_info->limits.surface_byteoffset_alignment = 16;
device_info->limits.surface_bytepitch_alignment = 8;
/* Set device capabilities. */
device_info->caps.flags = CCF_CLIPPING | CCF_RENDEROPTS;
device_info->caps.accel = SH7722_SUPPORTED_DRAWINGFUNCTIONS |
SH7722_SUPPORTED_BLITTINGFUNCTIONS;
device_info->caps.drawing = SH7722_SUPPORTED_DRAWINGFLAGS;
device_info->caps.blitting = SH7722_SUPPORTED_BLITTINGFLAGS;
/* Change font format for acceleration. */
if (!dfb_config->software_only) {
dfb_config->font_format = DSPF_ARGB;
dfb_config->font_premult = false;
}
/*
* Initialize hardware.
*/
/* Reset the drawing engine. */
sh7722EngineReset( sdrv, sdev );
/* Wait for idle BEU. */
while (SH7722_GETREG32( sdrv, BSTAR ) & 1);
/* Disable all inputs. */
SH7722_SETREG32( sdrv, BESTR, 0 );
/* Disable all multi windows. */
SH7722_SETREG32( sdrv, BMWCR0, SH7722_GETREG32( sdrv, BMWCR0 ) & ~0xf );
/* Clear LCD buffer. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
memset( (void*) sdrv->lcd_virt, 0x00, sdev->lcd_height * sdev->lcd_pitch );
break;
case DSPF_NV16:
memset( (void*) sdrv->lcd_virt, 0x10, sdev->lcd_height * sdev->lcd_pitch );
memset( (void*) sdrv->lcd_virt + sdev->lcd_height * sdev->lcd_pitch, 0x80, sdev->lcd_height * sdev->lcd_pitch );
break;
default:
D_BUG( "unsupported format" );
return DFB_BUG;
}
/*
* TODO: Make LCD Buffer format and primary BEU format runtime configurable.
*/
/* Set output pixel format of the BEU. */
switch (sdev->lcd_format) {
case DSPF_RGB16:
SH7722_SETREG32( sdrv, BPKFR, BPKFR_RY_RGB | WPCK_RGB16 );
break;
case DSPF_NV16:
SH7722_SETREG32( sdrv, BPKFR, BPKFR_RY_RGB | BPKFR_TE_ENABLED | CHDS_YCBCR422 );
SH7722_SETREG32( sdrv, BDACR, sdev->lcd_phys + sdev->lcd_height * sdev->lcd_pitch );
break;
default:
D_BUG( "unsupported format" );
return DFB_BUG;
}
SH7722_SETREG32( sdrv, BPROCR, 0x00000000 );
/* Have BEU render into LCD buffer. */
SH7722_SETREG32( sdrv, BBLCR1, MT_MEMORY );
SH7722_SETREG32( sdrv, BDAYR, sdev->lcd_phys & 0xfffffffc );
SH7722_SETREG32( sdrv, BDMWR, sdev->lcd_pitch & 0x0003fffc );
/* Setup LCD controller to show the buffer. */
sh7722_lcd_setup( sdrv, sdev->lcd_width, sdev->lcd_height,
sdev->lcd_phys, sdev->lcd_pitch, sdev->lcd_format, false );
/* Initialize BEU lock. */
fusion_skirmish_init( &sdev->beu_lock, "BEU", dfb_core_world(sdrv->core) );
/* Initialize JPEG lock. */
fusion_skirmish_init( &sdev->jpeg_lock, "JPEG", dfb_core_world(sdrv->core) );
return DFB_OK;
}
DFBResult
dfb_surface_create( CoreDFB *core,
const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type,
unsigned long resource_id,
CorePalette *palette,
CoreSurface **ret_surface )
{
DFBResult ret = DFB_BUG;
int i, data_size;
int buffers;
CoreSurface *surface;
char buf[64];
D_ASSERT( core != NULL );
D_FLAGS_ASSERT( type, CSTF_ALL );
D_MAGIC_ASSERT_IF( palette, CorePalette );
D_ASSERT( ret_surface != NULL );
D_DEBUG_AT( Core_Surface, "dfb_surface_create( %p, %p, %p )\n", core, config, ret_surface );
surface = dfb_core_create_surface( core );
if (!surface)
return DFB_FUSION;
surface->data = NULL;
if (config) {
D_FLAGS_ASSERT( config->flags, CSCONF_ALL );
surface->config.flags = config->flags;
if (config->flags & CSCONF_SIZE) {
D_DEBUG_AT( Core_Surface, " -> %dx%d\n", config->size.w, config->size.h );
surface->config.size = config->size;
}
if (config->flags & CSCONF_FORMAT) {
D_DEBUG_AT( Core_Surface, " -> %s\n", dfb_pixelformat_name( config->format ) );
surface->config.format = config->format;
}
if (config->flags & CSCONF_CAPS) {
D_DEBUG_AT( Core_Surface, " -> caps 0x%08x\n", config->caps );
if (config->caps & DSCAPS_ROTATED)
D_UNIMPLEMENTED();
surface->config.caps = config->caps & ~DSCAPS_ROTATED;
}
if (config->flags & CSCONF_PREALLOCATED) {
D_DEBUG_AT( Core_Surface, " -> prealloc %p [%d]\n",
config->preallocated[0].addr,
config->preallocated[0].pitch );
direct_memcpy( surface->config.preallocated, config->preallocated, sizeof(config->preallocated) );
surface->config.preallocated_pool_id = config->preallocated_pool_id;
type |= CSTF_PREALLOCATED;
}
}
if (surface->config.caps & DSCAPS_SYSTEMONLY)
surface->type = (type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (surface->config.caps & DSCAPS_VIDEOONLY)
surface->type = (type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (surface->config.caps & DSCAPS_SHARED)
surface->type |= CSTF_SHARED;
surface->resource_id = resource_id;
if (surface->config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (surface->config.caps & DSCAPS_DOUBLE)
buffers = 2;
else {
buffers = 1;
surface->config.caps &= ~DSCAPS_ROTATED;
}
surface->notifications = CSNF_ALL & ~CSNF_FLIP;
surface->alpha_ramp[0] = 0x00;
surface->alpha_ramp[1] = 0x55;
surface->alpha_ramp[2] = 0xaa;
surface->alpha_ramp[3] = 0xff;
if (surface->config.caps & DSCAPS_STATIC_ALLOC)
surface->config.min_size = surface->config.size;
surface->shmpool = dfb_core_shmpool( core );
direct_serial_init( &surface->serial );
snprintf( buf, sizeof(buf), "Surface %dx%d %s", surface->config.size.w,
surface->config.size.h, dfb_pixelformat_name(surface->config.format) );
fusion_ref_set_name( &surface->object.ref, buf );
fusion_skirmish_init2( &surface->lock, buf, dfb_core_world(core), fusion_config->secure_fusion );
// fusion_skirmish_add_permissions( &surface->lock, 0, FUSION_SKIRMISH_PERMIT_PREVAIL | FUSION_SKIRMISH_PERMIT_DISMISS );
D_MAGIC_SET( surface, CoreSurface );
if (dfb_config->warn.flags & DCWF_CREATE_SURFACE &&
dfb_config->warn.create_surface.min_size.w <= surface->config.size.w &&
dfb_config->warn.create_surface.min_size.h <= surface->config.size.h)
D_WARN( "create-surface %4dx%4d %6s, buffers %d, caps 0x%08x, type 0x%08x",
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name(surface->config.format),
buffers, surface->config.caps, surface->type );
if (palette) {
dfb_surface_set_palette( surface, palette );
}
else if (DFB_PIXELFORMAT_IS_INDEXED( surface->config.format )) {
ret = dfb_surface_init_palette( core, surface );
if (ret)
goto error;
}
/* Create the system driver specific surface data information */
data_size = dfb_system_surface_data_size();
if (data_size) {
surface->data = SHCALLOC( surface->shmpool, 1, data_size );
if (!surface->data) {
ret = D_OOSHM();
goto error;
}
}
dfb_system_surface_data_init(surface,surface->data);
dfb_surface_lock( surface );
/* Create the Surface Buffers. */
for (i=0; i<buffers; i++) {
ret = dfb_surface_buffer_create( core, surface, CSBF_NONE, &surface->buffers[i] );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
surface->num_buffers++;
dfb_surface_buffer_globalize( surface->buffers[i] );
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
dfb_surface_unlock( surface );
CoreSurface_Init_Dispatch( core, surface, &surface->call );
fusion_object_activate( &surface->object );
*ret_surface = surface;
return DFB_OK;
error:
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_decouple( surface->buffers[i] );
}
/* release the system driver specific surface data */
if (surface->data) {
dfb_system_surface_data_destroy( surface, surface->data );
SHFREE( surface->shmpool, surface->data );
surface->data = NULL;
}
fusion_skirmish_destroy( &surface->lock );
direct_serial_deinit( &surface->serial );
D_MAGIC_CLEAR( surface );
fusion_object_destroy( &surface->object );
return ret;
}
DFBResult
dfb_surface_create( CoreDFB *core,
const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type,
unsigned long resource_id,
CorePalette *palette,
CoreSurface **ret_surface )
{
DFBResult ret = DFB_BUG;
int i;
int buffers;
CoreSurface *surface;
char buf[64];
D_ASSERT( core != NULL );
D_FLAGS_ASSERT( type, CSTF_ALL );
D_MAGIC_ASSERT_IF( palette, CorePalette );
D_ASSERT( ret_surface != NULL );
D_DEBUG_AT( Core_Surface, "dfb_surface_create( %p, %p, %p )\n", core, config, ret_surface );
surface = dfb_core_create_surface( core );
if (!surface)
return DFB_FUSION;
if (config) {
D_FLAGS_ASSERT( config->flags, CSCONF_ALL );
surface->config.flags = config->flags;
if (config->flags & CSCONF_SIZE) {
D_DEBUG_AT( Core_Surface, " -> %dx%d\n", config->size.w, config->size.h );
surface->config.size = config->size;
}
if (config->flags & CSCONF_FORMAT) {
D_DEBUG_AT( Core_Surface, " -> %s\n", dfb_pixelformat_name( config->format ) );
surface->config.format = config->format;
}
if (config->flags & CSCONF_CAPS) {
D_DEBUG_AT( Core_Surface, " -> caps 0x%08x\n", config->caps );
surface->config.caps = config->caps;
}
if (config->flags & CSCONF_PREALLOCATED) {
D_DEBUG_AT( Core_Surface, " -> prealloc %p [%d]\n",
config->preallocated[0].addr,
config->preallocated[0].pitch );
direct_memcpy( surface->config.preallocated, config->preallocated, sizeof(config->preallocated) );
type |= CSTF_PREALLOCATED;
}
}
if (surface->config.caps & DSCAPS_SYSTEMONLY)
surface->type = (type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (surface->config.caps & DSCAPS_VIDEOONLY)
surface->type = (type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (surface->config.caps & DSCAPS_SHARED)
surface->type |= CSTF_SHARED;
surface->resource_id = resource_id;
if (surface->config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (surface->config.caps & DSCAPS_DOUBLE)
buffers = 2;
else
buffers = 1;
surface->notifications = CSNF_ALL & ~CSNF_FLIP;
surface->alpha_ramp[0] = 0x00;
surface->alpha_ramp[1] = 0x55;
surface->alpha_ramp[2] = 0xaa;
surface->alpha_ramp[3] = 0xff;
if (surface->config.caps & DSCAPS_STATIC_ALLOC)
surface->config.min_size = surface->config.size;
surface->shmpool = dfb_core_shmpool( core );
direct_serial_init( &surface->serial );
snprintf( buf, sizeof(buf), "Surface %dx%d %s", surface->config.size.w,
surface->config.size.h, dfb_pixelformat_name(surface->config.format) );
fusion_ref_set_name( &surface->object.ref, buf );
fusion_skirmish_init( &surface->lock, buf, dfb_core_world(core) );
fusion_object_set_lock( &surface->object, &surface->lock );
D_MAGIC_SET( surface, CoreSurface );
if (dfb_config->warn.flags & DCWF_CREATE_SURFACE &&
dfb_config->warn.create_surface.min_size.w <= surface->config.size.w &&
dfb_config->warn.create_surface.min_size.h <= surface->config.size.h)
D_WARN( "create-surface %4dx%4d %6s, buffers %d, caps 0x%08x, type 0x%08x",
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name(surface->config.format),
buffers, surface->config.caps, surface->type );
if (palette) {
dfb_surface_set_palette( surface, palette );
}
else if (DFB_PIXELFORMAT_IS_INDEXED( surface->config.format )) {
ret = dfb_surface_init_palette( core, surface );
if (ret)
goto error;
}
/* Create the Surface Buffers. */
for (i=0; i<buffers; i++) {
CoreSurfaceBuffer *buffer;
ret = dfb_surface_buffer_new( surface, CSBF_NONE, &buffer );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
surface->buffers[surface->num_buffers++] = buffer;
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
fusion_object_activate( &surface->object );
*ret_surface = surface;
return DFB_OK;
error:
D_MAGIC_CLEAR( surface );
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_destroy( surface->buffers[i] );
}
fusion_skirmish_destroy( &surface->lock );
direct_serial_deinit( &surface->serial );
fusion_object_destroy( &surface->object );
return ret;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
int i, n;
CoreScreen *screen;
D_ASSERT( dfb_x11 == NULL );
dfb_x11 = (DFBX11*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBX11) );
if (!dfb_x11) {
D_ERROR( "DirectFB/X11: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_x11_core = core;
fusion_skirmish_init( &dfb_x11->lock, "X11 System", dfb_core_world(core) );
fusion_call_init( &dfb_x11->call, call_handler, NULL, dfb_core_world(core) );
dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &dfb_x11->surface_pool );
screen = dfb_screens_register( NULL, NULL, &x11PrimaryScreenFuncs );
dfb_layers_register( screen, NULL, &x11PrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", dfb_x11 );
*data = dfb_x11;
XInitThreads();
dfb_x11->data_shmpool = dfb_core_shmpool_data( core );
dfb_x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!dfb_x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
dfb_x11->screenptr = DefaultScreenOfDisplay(dfb_x11->display);
dfb_x11->screennum = DefaultScreen(dfb_x11->display);
for (i=0; i<dfb_x11->screenptr->ndepths; i++) {
const Depth *depth = &dfb_x11->screenptr->depths[i];
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG( "X11/Visual: ID %02lu, depth %d, red 0x%06lx, green 0x%06lx, blue 0x%06lx, %d bits/rgb, %d entries\n",
visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
switch (depth->depth) {
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff) {
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
}
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f)
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f)
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
return DFB_OK;
}
