static DFBResult
system_leave( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
/*
* Slave deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_leave( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_leave( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_leave( shared->glx_pool );
if (shared->x11image_pool)
dfb_surface_pool_leave( shared->x11image_pool );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static DFBResult
stmfbdevJoinPool (CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data)
{
STMfbdevPoolData * const data = pool_data;
STMfbdevPoolLocalData * const local = pool_local;
STMfbdev * const stmfbdev = dfb_system_data ();
D_DEBUG_AT (STMfbdev_Surfaces, "%s()\n", __FUNCTION__);
D_ASSERT (core != NULL);
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_MAGIC_ASSERT (data, STMfbdevPoolData);
D_ASSERT (local != NULL);
D_MAGIC_ASSERT (stmfbdev, STMfbdev);
(void) data;
D_MAGIC_SET (local, STMfbdevPoolLocalData);
local->mem = stmfbdev->framebuffer_base;
D_ASSERT (local->mem != NULL);
local->core = core;
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
DFBX11 *x11 = dfb_system_data();
VDPAUDriverData *vdrv = driver_data;
vdrv->x11 = x11;
vdrv->vdp = &x11->vdp;
vdrv->display = x11->display;
vdrv->render_draw.blend_state.struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION;
vdrv->render_blit.blend_state.struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION;
/* initialize function pointers */
funcs->EngineSync = vdpauEngineSync;
funcs->EngineReset = vdpauEngineReset;
funcs->EmitCommands = vdpauEmitCommands;
funcs->CheckState = vdpauCheckState;
funcs->SetState = vdpauSetState;
funcs->FillRectangle = vdpauFillRectangle;
funcs->Blit = vdpauBlit;
funcs->StretchBlit = vdpauStretchBlit;
if (!dfb_config->software_only) {
dfb_config->font_format = DSPF_ARGB;
dfb_config->font_premult = true;
}
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
EP9XDriverData *ep9xdrv = (EP9XDriverData*) driver_data;
EP9XDeviceData *ep9xdev = (EP9XDeviceData*) device_data;
ep9xdrv->dfb_fbdev = dfb_system_data();
ioctl(ep9xdrv->dfb_fbdev->fd,FBIO_EP9X_GET_ADDR,&(ep9xdev->fb_addr));
funcs->CheckState = ep9xCheckState;
funcs->SetState = ep9xSetState;
funcs->EngineSync = ep9xEngineSync;
funcs->EngineReset = ep9xEngineReset;
funcs->FlushTextureCache = ep9xFlushTextureCache;
funcs->FillRectangle = ep9xFillRectangle;
funcs->DrawLine = ep9xDrawLine;
funcs->Blit = ep9xBlit;
return DFB_OK;
}
static DFBResult
uc_ovl_set_region( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreLayerRegionConfig *config,
CoreLayerRegionConfigFlags updated,
CoreSurface *surface,
CorePalette *palette,
CoreSurfaceBufferLock *lock )
{
UcDriverData* ucdrv = (UcDriverData*) driver_data;
UcOverlayData* ucovl = (UcOverlayData*) layer_data;
DFBRectangle win;
/* remember configuration */
ucovl->config = *config;
/* get new destination rectangle */
win = config->dest;
// Bounds checking
if ((win.x < -8192) || (win.x > 8192) ||
(win.y < -8192) || (win.y > 8192) ||
(win.w < 32) || (win.w > 4096) ||
(win.h < 32) || (win.h > 4096))
{
D_DEBUG("Layer size or position is out of bounds.");
return DFB_INVAREA;
}
ucovl->v1.isenabled = true;
ucovl->v1.win = win;
ucovl->v1.dst_key = config->dst_key;
ucovl->v1.dstkey_enabled = config->options & DLOP_DST_COLORKEY;
if (config->options & DLOP_OPACITY)
ucovl->v1.opacity = config->opacity;
else
ucovl->v1.opacity = 0xff;
// printf("uc_overlay: color-keying is %s\n",
// ucovl->v1.dstkey_enabled ? "enabled" : "disabled");
ucovl->deinterlace = config->options & DLOP_DEINTERLACING;
ucovl->surface = surface;
ucovl->lock = lock;
if (ucdrv->canfliponvsync) {
FBDev *dfb_fbdev = dfb_system_data();
int field_option = VIAFB_WAIT_FLIP; // wait for any pending flip
ioctl(dfb_fbdev->fd, FBIO_WAITFORVSYNC, &field_option);
}
return uc_ovl_update(ucdrv, ucovl, UC_OVL_CHANGE, surface, lock);
}
static DFBResult
system_shutdown( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
int i;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
//dfb_x11_eglimpl_unregister();
/*
* Master deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_destroy( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_destroy( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_destroy( shared->glx_pool );
if (shared->x11window_pool)
dfb_surface_pool_destroy( shared->x11window_pool );
if (shared->x11image_pool)
dfb_surface_pool_destroy( shared->x11image_pool );
/*
* Shared deinit (master only)
*/
fusion_call_destroy( &shared->call );
/* close remaining windows */
for( i=0; i<shared->outputs; i++ ) {
dfb_x11_close_window( x11, shared->output[i].xw );
}
SHFREE( dfb_core_shmpool( x11->core ), shared );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static void crtc2_wait_vsync( MatroxDriverData *mdrv )
{
int vdisplay = ((dfb_config->matrox_tv_std != DSETV_PAL) ? 480/2 : 576/2) + 1;
#ifdef FBIO_WAITFORVSYNC
static const int one = 1;
FBDev *dfb_fbdev = dfb_system_data();
if (ioctl( dfb_fbdev->fd, FBIO_WAITFORVSYNC, &one ))
#endif
while ((int)(mga_in32( mdrv->mmio_base, C2VCOUNT ) & 0x00000FFF) != vdisplay)
;
}
static void driver_close_driver(CoreGraphicsDevice *device,
void *driver_data)
{
SiSDriverData *drv = (SiSDriverData *)driver_data;
dfb_gfxcard_unmap_mmio(device, drv->mmio_base, -1);
if ((drv->has_auto_maximize) && (drv->auto_maximize)) {
FBDev *dfb_fbdev = dfb_system_data();
if (!dfb_fbdev)
return;
ioctl(dfb_fbdev->fd, drv->set_automaximize, &drv->auto_maximize);
}
}
/*
* Open the device, fill out information about it,
* allocate and fill private data, start input thread.
* Called during initialization, resuming or taking over mastership.
*/
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
SDLInputData *data;
DFBSDL *dfb_sdl = dfb_system_data();
fusion_skirmish_prevail( &dfb_sdl->lock );
SDL_EnableUNICODE( true );
SDL_EnableKeyRepeat( 250, 40 );
fusion_skirmish_dismiss( &dfb_sdl->lock );
/* set device name */
snprintf( info->desc.name,
DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "SDL Input" );
/* set device vendor */
snprintf( info->desc.vendor,
DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "SDL" );
/* set one of the primary input device IDs */
info->prefered_id = DIDID_KEYBOARD;
/* set type flags */
info->desc.type = DIDTF_JOYSTICK | DIDTF_KEYBOARD | DIDTF_MOUSE;
/* set capabilities */
info->desc.caps = DICAPS_ALL;
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(SDLInputData) );
data->device = device;
data->dfb_sdl = dfb_sdl;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, sdlEventThread, data, "SDL Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
/*
* Open the device, fill out information about it,
* allocate and fill private data, start input thread.
* Called during initialization, resuming or taking over mastership.
*/
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
X11InputData *data;
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
D_DEBUG_AT( X11_Input, "%s()\n", __FUNCTION__ );
fusion_skirmish_prevail( &shared->lock );
fusion_skirmish_dismiss( &shared->lock );
/* set device vendor and name */
snprintf( info->desc.vendor, DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "XServer" );
snprintf( info->desc.name, DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "X11 Input" );
/* set one of the primary input device IDs */
info->prefered_id = DIDID_KEYBOARD;
/* set type flags */
info->desc.type = DIDTF_JOYSTICK | DIDTF_KEYBOARD | DIDTF_MOUSE;
/* set capabilities */
info->desc.caps = DICAPS_ALL;
/* enable translation of fake raw hardware keycodes */
info->desc.min_keycode = 8;
info->desc.max_keycode = 255;
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(X11InputData) );
data->device = device;
data->x11 = x11;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, x11EventThread, data, "X11 Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
/*
* Master deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_destroy( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_destroy( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_destroy( shared->glx_pool );
if (shared->x11image_pool)
dfb_surface_pool_destroy( shared->x11image_pool );
/*
* Shared deinit (master only)
*/
fusion_call_destroy( &shared->call );
fusion_skirmish_prevail( &shared->lock );
if (shared->xw)
dfb_x11_close_window( x11, shared->xw );
fusion_skirmish_destroy( &shared->lock );
SHFREE( dfb_core_shmpool( x11->core ), shared );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static int
driver_probe( CoreGraphicsDevice *device )
{
switch (dfb_system_type()) {
case CORE_X11: {
int ee;
DFBX11 *x11 = dfb_system_data();
return glXQueryExtension( x11->display, &ee, &ee );
}
default:
break;
}
return 0;
}
static DFBResult
omapUpdateRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
const DFBRegion *update,
CoreSurfaceBufferLock *lock )
{
FBDev *dfb_fbdev = dfb_system_data();
struct omapfb_update_window window;
DFBRectangle rect;
dfb_rectangle_from_region( &rect, update );
D_DEBUG_AT( omap, "Update rectangle %d %d %dx%d\n",
rect.x, rect.y, rect.w, rect.h );
if (rect.x & 1)
rect.w++;
if (rect.y & 1)
rect.h++;
window.x = rect.x & ~1;
window.y = rect.y & ~1;
window.width = (rect.w + 1) & ~1;
window.height = (rect.h + 1) & ~1;
window.out_x = window.x;
window.out_y = window.y;
window.out_width = window.width;
window.out_height = window.height;
window.format = 0;
D_DEBUG_AT( omap, "Update window %d %d %dx%d\n",
window.x, window.y, window.width, window.height );
if (ioctl( dfb_fbdev->fd, OMAPFB_UPDATE_WINDOW, &window ))
D_DEBUG_AT( omap, "Can't update window -> %s\n", strerror( errno ) );
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
int i;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
/*
* Master deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_destroy( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_destroy( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_destroy( shared->glx_pool );
if (shared->x11image_pool)
dfb_surface_pool_destroy( shared->x11image_pool );
/*
* Shared deinit (master only)
*/
fusion_call_destroy( &shared->call );
fusion_skirmish_prevail( &shared->lock );
/* close remaining windows */
for( i=0; i<dfb_layer_num(); i++ ) {
CoreLayer *layer;
X11LayerData *lds;
layer = dfb_layer_at( i );
lds = layer->layer_data;
if( lds->xw ) {
dfb_x11_close_window( x11, lds->xw );
lds->xw = 0;
shared->window_count--;
}
}
fusion_skirmish_destroy( &shared->lock );
SHFREE( dfb_core_shmpool( x11->core ), shared );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static DFBResult driver_init_driver(CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core)
{
SiSDriverData *drv = (SiSDriverData *)driver_data;
FBDev *dfb_fbdev;
struct sisfb_info *fbinfo;
u32 fbinfo_size;
u32 zero = 0;
(void)device_data;
dfb_fbdev = dfb_system_data();
if (!dfb_fbdev)
return DFB_IO;
if (ioctl(dfb_fbdev->fd, SISFB_GET_INFO_SIZE, &fbinfo_size) == 0) {
fbinfo = D_MALLOC(fbinfo_size);
drv->get_info = SISFB_GET_INFO | (fbinfo_size << 16);
drv->get_automaximize = SISFB_GET_AUTOMAXIMIZE;
drv->set_automaximize = SISFB_SET_AUTOMAXIMIZE;
}
else {
fbinfo = D_MALLOC(sizeof(struct sisfb_info));
drv->get_info = SISFB_GET_INFO_OLD;
drv->get_automaximize = SISFB_GET_AUTOMAXIMIZE_OLD;
drv->set_automaximize = SISFB_SET_AUTOMAXIMIZE_OLD;
}
if (fbinfo == NULL)
return DFB_NOSYSTEMMEMORY;
if (ioctl(dfb_fbdev->fd, drv->get_info, fbinfo) == -1) {
D_FREE(fbinfo);
return DFB_IO;
}
check_sisfb_version(drv, fbinfo);
D_FREE(fbinfo);
if (drv->has_auto_maximize) {
if (ioctl(dfb_fbdev->fd, drv->get_automaximize, &drv->auto_maximize))
return DFB_IO;
if (drv->auto_maximize)
if (ioctl(dfb_fbdev->fd, drv->set_automaximize, &zero))
return DFB_IO;
}
drv->mmio_base = dfb_gfxcard_map_mmio(device, 0, -1);
if (!drv->mmio_base)
return DFB_IO;
/* base functions */
funcs->EngineSync = sis_engine_sync;
funcs->CheckState = sis_check_state;
funcs->SetState = sis_set_state;
/* drawing functions */
funcs->FillRectangle = sis_fill_rectangle;
funcs->DrawRectangle = sis_draw_rectangle;
funcs->DrawLine = sis_draw_line;
/* blitting functions */
funcs->Blit = sis_blit;
funcs->StretchBlit = sis_stretchblit;
/* allocate buffer for stretchBlit with colorkey */
drv->buffer_offset = dfb_gfxcard_reserve_memory( device, 1024*768*4 );
return DFB_OK;
}
static DFBResult
driver_init_device( CoreGraphicsDevice *device,
GraphicsDeviceInfo *device_info,
void *driver_data,
void *device_data )
{
GLDeviceData *gdev = (GLDeviceData*) device_data;
const char *renderer;
Display *display;
XVisualInfo *visual;
GLXContext context;
DFBX11 *x11;
int attr[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
None
};
D_DEBUG_AT( GL_Driver, "%s()\n", __FUNCTION__ );
XSetErrorHandler( error_handler );
error_code = 0;
x11 = dfb_system_data();
display = x11->display;
visual = glXChooseVisual( display, DefaultScreen(display), attr );
if (!visual || error_code) {
D_ERROR( "GL/Driver: Could not find a suitable visual!\n" );
return DFB_INIT;
}
context = glXCreateContext( display, visual, NULL, GL_TRUE );
if (!context || error_code) {
D_ERROR( "GL/Driver: Could not create a context!\n" );
return DFB_INIT;
}
glXMakeCurrent( display, RootWindowOfScreen(DefaultScreenOfDisplay(display)), context );
if( error_code )
return DFB_INIT;
renderer = (const char*) glGetString( GL_RENDERER );
glXMakeCurrent( display, None, NULL );
/* fill device info */
snprintf( device_info->vendor, DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "OpenGL Acceleration -" );
snprintf( device_info->name, DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "%s", renderer ?: "Unknown" );
glXDestroyContext( display, context );
/* device limitations */
device_info->limits.surface_byteoffset_alignment = 8;
device_info->limits.surface_bytepitch_alignment = 8;
device_info->caps.flags = CCF_CLIPPING | CCF_RENDEROPTS;
device_info->caps.accel = GL_SUPPORTED_DRAWINGFUNCTIONS |
GL_SUPPORTED_BLITTINGFUNCTIONS;
device_info->caps.drawing = GL_SUPPORTED_DRAWINGFLAGS;
device_info->caps.blitting = GL_SUPPORTED_BLITTINGFLAGS;
gdev->supported_blittingflags = GL_SUPPORTED_BLITTINGFLAGS;
return DFB_OK;
}
static DFBResult
uc_ovl_flip_region( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
DFBSurfaceFlipFlags flags,
CoreSurfaceBufferLock *lock )
{
//printf("Entering %s ... \n", __PRETTY_FUNCTION__);
UcDriverData* ucdrv = (UcDriverData*) driver_data;
UcOverlayData* ucovl = (UcOverlayData*) layer_data;
DFBResult ret;
FBDev *dfb_fbdev = dfb_system_data();
dfb_surface_flip(surface, false);
ucovl->field = 0;
ucovl->lock = lock;
if (ucdrv->canfliponvsync)
{
if (ucovl->config.options & DLOP_FIELD_PARITY)
{
struct fb_flip flip;
int field_option;
field_option = VIAFB_WAIT_FLIP; // ensure last pending flip complete
ioctl(dfb_fbdev->fd, FBIO_WAITFORVSYNC, &field_option);
flip.device = VIAFB_FLIP_V1;
flip.field = ucovl->config.parity;
flip.count = 0; // until we implement this
uc_ovl_map_buffer(surface->config.format,
lock->offset,
ucovl->v1.ox, ucovl->v1.oy, surface->config.size.w, surface->config.size.h,
lock->pitch, 0,
&flip.offset[0], &flip.offset[1], &flip.offset[2]);
ioctl(dfb_fbdev->fd, FBIO_FLIPONVSYNC, &flip);
}
else
{
ret = uc_ovl_update(ucdrv, ucovl, UC_OVL_FLIP, surface, lock);
if (ret)
return ret;
}
}
else
{
if (ucovl->config.options & DLOP_FIELD_PARITY)
{
int field_option;
if (ucovl->config.parity == 0) // top field first?
field_option = VIAFB_WAIT_BOTTOMFIELD;
else
field_option = VIAFB_WAIT_TOPFIELD;
ioctl(dfb_fbdev->fd, FBIO_WAITFORVSYNC, &field_option);
// that actually waits for VBLANK so we need a further delay
// to be sure the field has started and that the flip will
// take effect on the next field
usleep(2500);
}
ret = uc_ovl_update(ucdrv, ucovl, UC_OVL_FLIP, surface, lock);
if (ret)
return ret;
}
if (flags & DSFLIP_WAIT)
dfb_layer_wait_vsync(layer);
return DFB_OK;
}
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
int fd;
struct termios ts;
KeyboardData *data;
if (dfb_system_type() == CORE_FBDEV && dfb_config->vt) {
FBDev *dfb_fbdev = dfb_system_data();
fd = dup( dfb_fbdev->vt->fd );
if (fd < 0) {
D_PERROR( "DirectFB/Keyboard: Could not dup() file descriptor of TTY!\n" );
return DFB_INIT;
}
/* put keyboard into medium raw mode */
if (ioctl( fd, KDSKBMODE, K_MEDIUMRAW ) < 0) {
D_PERROR( "DirectFB/Keyboard: K_MEDIUMRAW failed!\n" );
return DFB_INIT;
}
}
else {
fd = open( "/dev/tty0", O_RDWR | O_NOCTTY );
if (fd < 0) {
D_PERROR( "DirectFB/Keyboard: Could not open() /dev/tty0!\n" );
return DFB_INIT;
}
}
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(KeyboardData) );
data->device = device;
data->vt_fd = fd;
tcgetattr( data->vt_fd, &data->old_ts );
ts = data->old_ts;
ts.c_cc[VTIME] = 0;
ts.c_cc[VMIN] = 1;
ts.c_lflag &= ~(ICANON|ECHO|ISIG);
ts.c_iflag = 0;
tcsetattr( data->vt_fd, TCSAFLUSH, &ts );
tcsetpgrp( data->vt_fd, getpgrp() );
/* fill device info structure */
snprintf( info->desc.name,
DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "Keyboard" );
snprintf( info->desc.vendor,
DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "Unknown" );
/* claim to be the primary keyboard */
info->prefered_id = DIDID_KEYBOARD;
/* classify as a keyboard able to produce key events */
info->desc.type = DIDTF_KEYBOARD;
info->desc.caps = DICAPS_KEYS;
/* enable translation of raw hardware keycodes */
info->desc.min_keycode = 0;
info->desc.max_keycode = 127;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, keyboardEventThread, data, "Keyboard Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
static DFBResult
stmfbdevInitPool (CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc)
{
DFBResult ret;
STMfbdevPoolData * const data = pool_data;
STMfbdevPoolLocalData * const local = pool_local;
STMfbdev * const stmfbdev = dfb_system_data ();
unsigned int video_len;
D_DEBUG_AT (STMfbdev_Surfaces, "%s()\n", __FUNCTION__);
D_ASSERT (core != NULL);
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_ASSERT (data != NULL);
D_ASSERT (local != NULL);
D_ASSERT (ret_desc != NULL);
(void) local;
D_MAGIC_ASSERT (stmfbdev, STMfbdev);
D_MAGIC_ASSERT (stmfbdev->shared, STMfbdevSharedData);
D_MAGIC_SET (data, STMfbdevPoolData);
snprintf (ret_desc->name,
DFB_SURFACE_POOL_DESC_NAME_LENGTH, "STMfb Memory");
/* the gfxdriver might have reserved video memory - in which case we have to
make sure that the reserved memory is not seen/used by the surface
manager */
video_len = dfb_gfxcard_memory_length ();
D_INFO ("BDisp/Surfaces: using %ukB of video memory (%d bytes reserved)!\n",
video_len / 1024, stmfbdev->shared->fix.smem_len - video_len);
ret = dfb_surfacemanager_create (core, video_len, &data->manager);
if (ret)
return ret;
data->physical = stmfbdev->shared->fix.smem_start;
ret_desc->caps = CSPCAPS_PHYSICAL | CSPCAPS_VIRTUAL;
ret_desc->access[CSAID_CPU] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->access[CSAID_GPU] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->types = (0
| CSTF_LAYER
| CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT
| CSTF_SHARED | CSTF_EXTERNAL
);
ret_desc->priority = CSPP_DEFAULT;
ret_desc->size = video_len;
/* other accelerators */
ret_desc->access[CSAID_ACCEL0] = CSAF_READ | CSAF_WRITE;
ret_desc->access[CSAID_ACCEL1] = CSAF_READ | CSAF_WRITE;
ret_desc->access[CSAID_ACCEL2] = CSAF_READ | CSAF_WRITE;
ret_desc->access[CSAID_ACCEL3] = CSAF_READ | CSAF_WRITE;
ret_desc->access[CSAID_ACCEL4] = CSAF_READ | CSAF_WRITE;
ret_desc->access[CSAID_ACCEL5] = CSAF_READ | CSAF_WRITE;
/* For hardware layers */
ret_desc->access[CSAID_LAYER0] = CSAF_READ;
ret_desc->access[CSAID_LAYER1] = CSAF_READ;
ret_desc->access[CSAID_LAYER2] = CSAF_READ;
ret_desc->access[CSAID_LAYER3] = CSAF_READ;
ret_desc->access[CSAID_LAYER4] = CSAF_READ;
ret_desc->access[CSAID_LAYER5] = CSAF_READ;
ret_desc->access[CSAID_LAYER6] = CSAF_READ;
ret_desc->access[CSAID_LAYER7] = CSAF_READ;
ret_desc->access[CSAID_LAYER8] = CSAF_READ;
ret_desc->access[CSAID_LAYER9] = CSAF_READ;
ret_desc->access[CSAID_LAYER10] = CSAF_READ;
ret_desc->access[CSAID_LAYER11] = CSAF_READ;
ret_desc->access[CSAID_LAYER12] = CSAF_READ;
ret_desc->access[CSAID_LAYER13] = CSAF_READ;
ret_desc->access[CSAID_LAYER14] = CSAF_READ;
ret_desc->access[CSAID_LAYER15] = CSAF_READ;
ret = stmfbdevJoinPool (core, pool, pool_data, pool_local, system_data);
if (ret)
{
stmfbdevDestroyPool (pool, pool_data, pool_local);
return ret;
}
return DFB_OK;
}
