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; }