static DFBResult
osdJoinPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data )
{
OSDPoolData *data = pool_data;
OSDPoolLocalData *local = pool_local;
DavinciDriverData *ddrv = dfb_gfxcard_get_driver_data();
DavinciDeviceData *ddev = dfb_gfxcard_get_device_data();
D_DEBUG_AT( OSD_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( data, OSDPoolData );
D_ASSERT( local != NULL );
(void) data;
local->core = core;
local->mem = ddrv->fb[OSD0].mem;
local->phys = ddev->fix[OSD0].smem_start;
D_MAGIC_SET( local, OSDPoolLocalData );
return DFB_OK;
}
static DFBResult
osdInitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
OSDPoolData *data = pool_data;
OSDPoolLocalData *local = pool_local;
DavinciDriverData *ddrv = dfb_gfxcard_get_driver_data();
DavinciDeviceData *ddev = dfb_gfxcard_get_device_data();
D_DEBUG_AT( OSD_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 );
ret_desc->caps = CSPCAPS_NONE;
ret_desc->access = CSAF_CPU_READ | CSAF_CPU_WRITE | CSAF_GPU_READ | CSAF_GPU_WRITE | CSAF_SHARED;
ret_desc->types = CSTF_LAYER | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_DEFAULT;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "OSD Pool" );
local->core = core;
local->mem = ddrv->fb[OSD0].mem;
local->phys = ddev->fix[OSD0].smem_start;
D_MAGIC_SET( data, OSDPoolData );
D_MAGIC_SET( local, OSDPoolLocalData );
return DFB_OK;
}
static DFBResult
stmfbdevUnlock (CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceAllocation *allocation,
void *alloc_data,
CoreSurfaceBufferLock *lock)
{
const STMfbdevPoolData * const data = pool_data;
const STMfbdevPoolLocalData * const local = pool_local;
const STMfbdevPoolAllocationData * const alloc = alloc_data;
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_MAGIC_ASSERT (data, STMfbdevPoolData);
D_MAGIC_ASSERT (local, STMfbdevPoolLocalData);
D_MAGIC_ASSERT (allocation, CoreSurfaceAllocation);
D_MAGIC_ASSERT (alloc, STMfbdevPoolAllocationData);
D_MAGIC_ASSERT (lock, CoreSurfaceBufferLock);
D_DEBUG_AT (STMfbdev_SurfLock, "%s (%p)\n", __FUNCTION__, lock->buffer);
(void) data;
(void) local;
(void) alloc;
#if D_DEBUG_ENABLED
{
/* heavy performance hit */
char *accessor = _accessor_str (lock->accessor);
char *access = _access_str (lock->access);
D_DEBUG_AT (STMfbdev_SurfLock, " -> by %s for %s\n", accessor, access);
free (access);
free (accessor);
}
#endif
#if STGFX_DRIVER == 2
if (unlikely (lock->buffer->format == DSPF_RGB32
&& lock->accessor != CSAID_GPU
&& lock->access & CSAF_WRITE))
{
/* if a non-GPU accessor did a write access to an RGB32 surface, we
should make sure the alpha is forced to 0xff, as the BDisp doesn't
support this format natively */
STGFX2DriverData * const stdrv = dfb_gfxcard_get_driver_data ();
STGFX2DeviceData * const stdev = dfb_gfxcard_get_device_data ();
DFBRectangle rect = { .x = 0, .y = 0,
.w = lock->buffer->surface->config.size.w,
.h = lock->buffer->surface->config.size.h };
D_DEBUG_AT (STMfbdev_SurfLock, " -> rgb32 write release!\n");
dfb_gfxcard_lock (GDLF_WAIT);
_bdisp_aq_RGB32_fixup (stdrv, stdev,
lock->phys, lock->pitch,
&rect);
dfb_gfxcard_unlock ();
}
#endif
return DFB_OK;
}
static DFBResult
stmfbdevAllocateBuffer (CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation *allocation,
void *alloc_data)
{
CoreSurface *surface;
STMfbdevPoolData * const data = pool_data;
STMfbdevPoolLocalData * const local = pool_local;
STMfbdevPoolAllocationData * const alloc = alloc_data;
DFBResult ret;
Chunk *chunk;
D_DEBUG_AT (STMfbdev_Surfaces, "%s (%p)\n", __FUNCTION__, buffer);
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_MAGIC_ASSERT (data, STMfbdevPoolData);
D_MAGIC_ASSERT (local, STMfbdevPoolLocalData);
D_MAGIC_ASSERT (buffer, CoreSurfaceBuffer);
D_MAGIC_ASSERT (allocation, CoreSurfaceAllocation);
surface = buffer->surface;
D_MAGIC_ASSERT (surface, CoreSurface);
ret = dfb_surfacemanager_allocate (local->core, data->manager, buffer,
allocation, &chunk);
if (ret)
return ret;
D_MAGIC_ASSERT (chunk, Chunk);
alloc->chunk = chunk;
D_DEBUG_AT (STMfbdev_Surfaces,
" -> offset 0x%.8x (%u), format: %s, pitch %d, size %d\n",
chunk->offset, chunk->offset,
dfb_pixelformat_name (buffer->format), chunk->pitch,
chunk->length);
allocation->size = chunk->length;
allocation->offset = chunk->offset;
#if STGFX_DRIVER == 2
if (unlikely (buffer->format == DSPF_RGB32))
{
/* for RGB32, we need to set the alpha to 0xff */
STGFX2DriverData * const stdrv = dfb_gfxcard_get_driver_data ();
STGFX2DeviceData * const stdev = dfb_gfxcard_get_device_data ();
DFBRectangle rect = { .x = 0, .y = 0,
.w = buffer->surface->config.size.w,
.h = buffer->surface->config.size.h };
D_WARN ("BDisp/Surfaces: RGB32 support is experimental and slow!");
if (dfb_system_type () != CORE_STMFBDEV)
D_WARN ("BDisp/Surfaces: RGB32 is only supported in STMfbdev system!");
D_DEBUG_AT (STMfbdev_Surfaces, " -> rgb32 allocation!\n");
dfb_gfxcard_lock (GDLF_WAIT);
_bdisp_aq_RGB32_init (stdrv, stdev,
data->physical + chunk->offset, chunk->pitch,
&rect);
dfb_gfxcard_unlock ();
}
#endif
D_MAGIC_SET (alloc, STMfbdevPoolAllocationData);
return DFB_OK;
}
