static void
driver_close_driver( CoreGraphicsDevice *device,
void *driver_data )
{
SH7722DriverData *sdrv = driver_data;
SH7722GfxSharedArea *shared = sdrv->gfx_shared;
(void) shared;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
D_INFO( "SH7722/BLT: %u starts, %u done, %u interrupts, %u wait_idle, %u wait_next, %u idle\n",
shared->num_starts, shared->num_done, shared->num_interrupts,
shared->num_wait_idle, shared->num_wait_next, shared->num_idle );
D_INFO( "SH7722/BLT: %u words, %u words/start, %u words/idle, %u starts/idle\n",
shared->num_words,
shared->num_words / shared->num_starts,
shared->num_words / shared->num_idle,
shared->num_starts / shared->num_idle );
/* Unmap shared area. */
munmap( (void*) sdrv->gfx_shared, direct_page_align( sizeof(SH7722GfxSharedArea) ) );
/* Close Drawing Engine device. */
close( sdrv->gfx_fd );
}
void
write_ppm( const char *filename,
unsigned long phys,
int pitch,
unsigned int width,
unsigned int height )
{
int i;
int fd;
int size;
void *mem;
FILE *file;
size = direct_page_align( pitch * height );
fd = open( "/dev/mem", O_RDWR );
if (fd < 0) {
D_PERROR( "SH7722/JPEG: Could not open /dev/mem!\n" );
return;
}
mem = mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, phys );
if (mem == MAP_FAILED) {
D_PERROR( "SH7722/JPEG: Could not map /dev/mem at 0x%08lx (length %d)!\n", phys, size );
close( fd );
return;
}
close( fd );
file = fopen( filename, "wb" );
if (!file) {
D_PERROR( "SH7722/JPEG: Could not open '%s' for writing!\n", filename );
munmap( mem, size );
return;
}
fprintf( file, "P6\n%d %d\n255\n", width, height );
for (i=0; i<height; i++) {
fwrite( mem, 3, width, file );
mem += pitch;
}
fclose( file );
munmap( mem, size );
}
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;
}
