static void vt_set_fb( int vt, int fb ) { struct fb_con2fbmap c2m; struct stat sbf; D_DEBUG_AT( VT, "%s( %d, %d )\n", __FUNCTION__, vt, fb ); if (fstat( dfb_fbdev->fd, &sbf )) { D_PERROR( "DirectFB/FBDev/vt: Could not fstat fb device!\n" ); return; } if (fb >= 0) c2m.framebuffer = fb; else c2m.framebuffer = (sbf.st_rdev & 0xFF) >> 5; c2m.console = vt; if (ioctl( dfb_fbdev->fd, FBIOPUT_CON2FBMAP, &c2m ) < 0) { D_PERROR( "DirectFB/FBDev/vt: " "FBIOPUT_CON2FBMAP failed!\n" ); } }
DFBResult dfb_vt_detach( bool force ) { D_DEBUG_AT( VT, "%s()\n", __FUNCTION__ ); if (dfb_config->vt_switch || force) { int fd; struct vt_stat vt_state; fd = open( "/dev/tty", O_RDONLY | O_NOCTTY ); if (fd < 0) { if (errno == ENXIO) return DFB_OK; D_PERROR( "DirectFB/VT: Opening /dev/tty failed!\n" ); return errno2result( errno ); } if (ioctl( fd, VT_GETSTATE, &vt_state )) { close( fd ); return DFB_OK; } if (ioctl( fd, TIOCNOTTY )) { D_PERROR( "DirectFB/VT: TIOCNOTTY on /dev/tty failed\n" ); close( fd ); return errno2result( errno ); } close( fd ); } return DFB_OK; }
static void leave_pool( FusionSHM *shm, FusionSHMPool *pool, FusionSHMPoolShared *shared ) { FusionWorld *world; D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )\n", __FUNCTION__, shm, pool, shared ); D_MAGIC_ASSERT( shm, FusionSHM ); D_MAGIC_ASSERT( pool, FusionSHMPool ); D_MAGIC_ASSERT( shared, FusionSHMPoolShared ); world = shm->world; D_MAGIC_ASSERT( world, FusionWorld ); if (munmap( shared->addr_base, shared->max_size )) D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!\n", pool->filename ); if (pool->fd != -1 && close( pool->fd )) D_PERROR( "Fusion/SHM: Could not close shared memory file '%s'!\n", pool->filename ); pool->attached = false; D_FREE( pool->filename ); D_MAGIC_CLEAR( pool ); }
static DFBResult MapMemAndReg( DevMemData *data, unsigned long mem_phys, unsigned int mem_length, unsigned long reg_phys, unsigned int reg_length ) { int fd; fd = open( DEV_MEM, O_RDWR | O_SYNC ); if (fd < 0) { D_PERROR( "System/DevMem: Opening '%s' failed!\n", DEV_MEM ); return DFB_INIT; } data->mem = mmap( NULL, mem_length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mem_phys ); if (data->mem == MAP_FAILED) { D_PERROR( "System/DevMem: Mapping %d bytes at 0x%08lx via '%s' failed!\n", mem_length, mem_phys, DEV_MEM ); return DFB_INIT; } if (reg_phys && reg_length) { data->reg = mmap( NULL, reg_length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, reg_phys ); if (data->reg == MAP_FAILED) { D_PERROR( "System/DevMem: Mapping %d bytes at 0x%08lx via '%s' failed!\n", reg_length, reg_phys, DEV_MEM ); munmap( data->mem, mem_length ); close( fd ); return DFB_INIT; } } close( fd ); return DFB_OK; }
static void driver_close_device( void *driver_data ) { KeyboardData *data = (KeyboardData*) driver_data; /* stop input thread */ direct_thread_cancel( data->thread ); direct_thread_join( data->thread ); direct_thread_destroy( data->thread ); if (tcsetattr( data->vt_fd, TCSAFLUSH, &data->old_ts ) < 0) D_PERROR("DirectFB/keyboard: tcsetattr for original values failed!\n"); if (dfb_system_type() == CORE_FBDEV && dfb_config->vt) { if (ioctl( data->vt_fd, KDSKBMODE, K_XLATE ) < 0) D_PERROR("DirectFB/keyboard: Could not set mode to XLATE!\n"); if (ioctl( data->vt_fd, KDSETMODE, KD_TEXT ) < 0) D_PERROR("DirectFB/keyboard: Could not set terminal mode to text!\n"); } close( data->vt_fd ); /* free private data */ D_FREE( data ); }
DirectResult fusion_ref_up (FusionRef *ref, bool global) { D_ASSERT( ref != NULL ); D_DEBUG_AT( Fusion_Ref, "fusion_ref_up( %p [%d]%s )\n", ref, ref->multi.id, global ? " GLOBAL" : "" ); while (ioctl (_fusion_fd( ref->multi.shared ), global ? FUSION_REF_UP_GLOBAL : FUSION_REF_UP, &ref->multi.id)) { switch (errno) { case EINTR: continue; case EAGAIN: return DR_LOCKED; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } if (global) D_PERROR ("FUSION_REF_UP_GLOBAL"); else D_PERROR ("FUSION_REF_UP"); return DR_FAILURE; } D_DEBUG_AT( Fusion_Ref, " -> %d references now\n", ioctl( _fusion_fd( ref->multi.shared ), FUSION_REF_STAT, &ref->multi.id ) ); return DR_OK; }
static DirectResult init_udp( DirectLog *log, const char *hostport ) { DirectResult ret; int fd; struct addrinfo *addr; ret = parse_host_addr( hostport, &addr ); if (ret) return ret; fd = socket( addr->ai_family, SOCK_DGRAM, 0 ); if (fd < 0) { ret = errno2result( errno ); D_PERROR( "Direct/Log: Could not create a UDP socket!\n" ); freeaddrinfo( addr ); return ret; } ret = connect( fd, addr->ai_addr, addr->ai_addrlen ); freeaddrinfo( addr ); if (ret) { ret = errno2result( errno ); D_PERROR( "Direct/Log: Could not connect UDP socket to '%s'!\n", hostport ); close( fd ); return ret; } log->fd = fd; return DR_OK; }
void fusion_exit( bool emergency ) { int foo; FusionSendMessage msg; D_ASSERT( fusion_refs > 0 ); /* decrement local reference counter */ if (--fusion_refs) return; if (!emergency) { /* Wake up the read loop thread. */ msg.fusion_id = _fusion_id; msg.msg_id = 0; msg.msg_data = &foo; msg.msg_size = sizeof(foo); while (ioctl( _fusion_fd, FUSION_SEND_MESSAGE, &msg ) < 0) { if (errno != EINTR) { D_PERROR ("FUSION_SEND_MESSAGE"); break; } } /* Wait for its termination. */ direct_thread_join( read_loop ); } direct_thread_destroy( read_loop ); direct_signal_handler_remove( signal_handler ); /* Master has to deinitialize shared data. */ if (_fusion_id == 1) { fusion_skirmish_destroy( &_fusion_shared->reactor_globals ); fusion_skirmish_destroy( &_fusion_shared->arenas_lock ); } _fusion_shared = NULL; /* Deinitialize or leave shared memory. */ __shmalloc_exit( _fusion_id == 1, true ); /* Reset local dispatch nodes. */ _fusion_reactor_free_all(); _fusion_id = 0; if (close( _fusion_fd )) D_PERROR( "Fusion/Exit: closing the fusion device failed!\n" ); _fusion_fd = -1; direct_shutdown(); }
static DFBResult osdSetRegion( CoreLayer *layer, void *driver_data, void *layer_data, void *region_data, CoreLayerRegionConfig *config, CoreLayerRegionConfigFlags updated, CoreSurface *surface, CorePalette *palette, CoreSurfaceBufferLock *lock ) { int ret; DavinciDriverData *ddrv = driver_data; DavinciDeviceData *ddev = ddrv->ddev; DavinciOSDLayerData *dosd = layer_data; D_DEBUG_AT( Davinci_OSD, "%s()\n", __FUNCTION__ ); D_ASSERT( ddrv != NULL ); D_ASSERT( ddev != NULL ); D_ASSERT( dosd != NULL ); ret = ioctl( ddrv->fb[OSD0].fd, FBIO_ENABLE_DISABLE_WIN, 0 ); if (ret) D_PERROR( "Davinci/OSD: FBIO_ENABLE_DISABLE_WIN (fb%d - %d)!\n", OSD0, 0 ); ret = ioctl( ddrv->fb[OSD1].fd, FBIO_ENABLE_DISABLE_WIN, 0 ); if (ret) D_PERROR( "Davinci/OSD: FBIO_ENABLE_DISABLE_WIN (fb%d - %d)!\n", OSD1, 0 ); ioctl( ddrv->fb[OSD0].fd, FBIO_WAITFORVSYNC ); /* Update blend parameters? */ if (updated & (CLRCF_OPTIONS | CLRCF_OPACITY | CLRCF_SRCKEY | CLRCF_FORMAT)) { vpbe_blink_option_t blink = {0}; vpbe_bitmap_blend_params_t blend = {0}; D_DEBUG_AT( Davinci_OSD, " -> %s\n", dfb_pixelformat_name( config->format ) ); if (config->options & DLOP_SRC_COLORKEY) { blend.enable_colorkeying = 1; blend.colorkey = dfb_color_to_pixel( DSPF_RGB16, config->src_key.r, config->src_key.g, config->src_key.b ); D_DEBUG_AT( Davinci_OSD, " -> color key 0x%02x (%02x %02x %02x)\n", blend.colorkey, config->src_key.r, config->src_key.g, config->src_key.b ); } else if (config->options & DLOP_OPACITY) { blend.bf = config->opacity >> 5; D_DEBUG_AT( Davinci_OSD, " -> opacity %d/7\n", blend.bf ); }
static DFBResult osdInitLayer( CoreLayer *layer, void *driver_data, void *layer_data, DFBDisplayLayerDescription *description, DFBDisplayLayerConfig *config, DFBColorAdjustment *adjustment ) { int ret; DavinciDriverData *ddrv = driver_data; DavinciOSDLayerData *dosd = layer_data; D_DEBUG_AT( Davinci_OSD, "%s()\n", __FUNCTION__ ); ret = ioctl( ddrv->fb[OSD0].fd, FBIOGET_VSCREENINFO, &dosd->var0 ); if (ret) { D_PERROR( "Davinci/OSD: FBIOGET_VSCREENINFO (fb%d) failed!\n", OSD0 ); return DFB_INIT; } ret = ioctl( ddrv->fb[OSD1].fd, FBIOGET_VSCREENINFO, &dosd->var1 ); if (ret) { D_PERROR( "Davinci/OSD: FBIOGET_VSCREENINFO (fb%d) failed!\n", OSD1 ); return DFB_INIT; } ret = ioctl( ddrv->fb[OSD0].fd, FBIO_ENABLE_DISABLE_WIN, 0 ); if (ret) D_OSDERROR( "Davinci/OSD: FBIO_ENABLE_DISABLE_WIN (fb%d - %d)!\n", OSD0, 0 ); ret = ioctl( ddrv->fb[OSD1].fd, FBIO_ENABLE_DISABLE_WIN, 0 ); if (ret) D_OSDERROR( "Davinci/OSD: FBIO_ENABLE_DISABLE_WIN (fb%d - %d)!\n", OSD1, 0 ); /* set capabilities and type */ description->caps = DLCAPS_SURFACE | DLCAPS_ALPHACHANNEL | DLCAPS_OPACITY | DLCAPS_SCREEN_POSITION | DLCAPS_SRC_COLORKEY; description->type = DLTF_GRAPHICS; /* set name */ snprintf( description->name, DFB_DISPLAY_LAYER_DESC_NAME_LENGTH, "TI Davinci OSD" ); /* fill out the default configuration */ config->flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE | DLCONF_OPTIONS; config->width = 640; config->height = 480; config->pixelformat = DSPF_RGB16; config->buffermode = DLBM_FRONTONLY; config->options = DLOP_ALPHACHANNEL; return DFB_OK; }
static void * vt_thread( DirectThread *thread, void *arg ) { D_DEBUG_AT( VT, "%s( %p, %p )\n", __FUNCTION__, thread, arg ); pthread_mutex_lock( &dfb_vt->lock ); while (true) { direct_thread_testcancel( thread ); D_DEBUG_AT( VT, "...%s (signal %d)\n", __FUNCTION__, dfb_vt->vt_sig); switch (dfb_vt->vt_sig) { default: D_BUG( "unexpected vt_sig" ); /* fall through */ case -1: pthread_cond_wait( &dfb_vt->wait, &dfb_vt->lock ); continue; case SIG_SWITCH_FROM: if (dfb_core_suspend( dfb_fbdev->core ) == DFB_OK) { if (ioctl( dfb_vt->fd, VT_RELDISP, VT_ACKACQ ) < 0) D_PERROR( "DirectFB/fbdev/vt: VT_RELDISP failed\n" ); } break; case SIG_SWITCH_TO: if (dfb_core_resume( dfb_fbdev->core ) == DFB_OK) { if (ioctl( dfb_vt->fd, VT_RELDISP, VT_ACKACQ ) < 0) D_PERROR( "DirectFB/fbdev/vt: VT_RELDISP failed\n" ); if (dfb_config->kd_graphics) { if (ioctl( dfb_vt->fd, KDSETMODE, KD_GRAPHICS ) < 0) D_PERROR( "DirectFB/fbdev/vt: KD_GRAPHICS failed!\n" ); } } break; } dfb_vt->vt_sig = -1; pthread_cond_signal( &dfb_vt->wait ); } return NULL; }
DirectResult voodoo_play_get_broadcast( VoodooPlayAddress **ret_addr, size_t *ret_num ) { DirectResult ret = DR_OK; VoodooPlayAddress *addr; // Get local host name char szHostName[128] = ""; if (gethostname(szHostName, sizeof(szHostName))) { ret = errno2result( errno ); D_PERROR( "Voodoo/Win32: gethostname() failed!\n" ); return ret; } // Get local IP addresses struct hostent *pHost = 0; pHost = gethostbyname(szHostName); if (!pHost) { ret = errno2result( errno ); D_PERROR( "Voodoo/Win32: gethostbyname('%s') failed!\n", szHostName ); return ret; } size_t iCnt, iTotal = 0; for (iCnt = 0; pHost->h_addr_list[iCnt]; ++iCnt) iTotal++; addr = D_CALLOC( iTotal, sizeof(VoodooPlayAddress) ); if (!addr) return D_OOM(); for (iCnt = 0; pHost->h_addr_list[iCnt]; ++iCnt) { struct sockaddr_in SocketAddress; memcpy(&SocketAddress.sin_addr, pHost->h_addr_list[iCnt], pHost->h_length); voodoo_play_from_inet_addr( &addr[iCnt], SocketAddress.sin_addr.s_addr ); } *ret_addr = addr; *ret_num = iTotal; return DR_OK; }
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 ); }
DirectResult fusion_ref_set_name (FusionRef *ref, const char *name) { FusionEntryInfo info; D_ASSERT( ref != NULL ); D_ASSERT( name != NULL ); info.type = FT_REF; info.id = ref->multi.id; direct_snputs( info.name, name, sizeof(info.name) ); while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_ENTRY_SET_INFO, &info)) { switch (errno) { case EINTR: continue; case EAGAIN: return DR_LOCKED; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_ENTRY_SET_NAME"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_destroy (FusionRef *ref) { D_ASSERT( ref != NULL ); D_DEBUG_AT( Fusion_Ref, "fusion_ref_destroy( %p [%d] )\n", ref, ref->multi.id ); fusion_world_flush_calls( _fusion_world( ref->multi.shared ), 1 ); while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_DESTROY, &ref->multi.id)) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_DESTROY"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_inherit (FusionRef *ref, FusionRef *from) { FusionRefInherit inherit; D_ASSERT( ref != NULL ); D_ASSERT( from != NULL ); inherit.id = ref->multi.id; inherit.from = from->multi.id; while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_INHERIT, &inherit)) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_INHERIT"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_watch (FusionRef *ref, FusionCall *call, int call_arg) { FusionRefWatch watch; D_ASSERT( ref != NULL ); D_ASSERT( call != NULL ); watch.id = ref->multi.id; watch.call_id = call->call_id; watch.call_arg = call_arg; while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_WATCH, &watch)) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_WATCH"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_zero_trylock (FusionRef *ref) { D_ASSERT( ref != NULL ); while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_ZERO_TRYLOCK, &ref->multi.id)) { switch (errno) { case EINTR: continue; case ETOOMANYREFS: return DR_BUSY; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_ZERO_TRYLOCK"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_stat (FusionRef *ref, int *refs) { int val; D_ASSERT( ref != NULL ); D_ASSERT( refs != NULL ); while ((val = ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_STAT, &ref->multi.id)) < 0) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_STAT"); return DR_FAILURE; } *refs = val; return DR_OK; }
DirectResult fusion_ref_throw (FusionRef *ref, FusionID catcher) { FusionRefThrow throw_; D_ASSERT( ref != NULL ); if (ref->multi.id == fusion_config->trace_ref) { D_INFO( "Fusion/Ref: 0x%08x throw\n", ref->multi.id ); direct_trace_print_stack( NULL ); } throw_.id = ref->multi.id; throw_.catcher = catcher; while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_THROW, &throw_)) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_THROW"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_ref_catch (FusionRef *ref) { D_ASSERT( ref != NULL ); if (ref->multi.id == fusion_config->trace_ref) { D_INFO( "Fusion/Ref: 0x%08x catch\n", ref->multi.id ); direct_trace_print_stack( NULL ); } while (ioctl (_fusion_fd( ref->multi.shared ), FUSION_REF_CATCH, &ref->multi.id)) { switch (errno) { case EINTR: continue; case EINVAL: D_ERROR ("Fusion/Reference: invalid reference\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_REF_CATCH"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_call_add_permissions( FusionCall *call, FusionID fusion_id, FusionCallPermissions call_permissions ) { FusionEntryPermissions permissions; permissions.type = FT_CALL; permissions.id = call->call_id; permissions.fusion_id = fusion_id; permissions.permissions = 0; if (call_permissions & FUSION_CALL_PERMIT_EXECUTE) { FUSION_ENTRY_PERMISSIONS_ADD( permissions.permissions, FUSION_CALL_EXECUTE ); FUSION_ENTRY_PERMISSIONS_ADD( permissions.permissions, FUSION_CALL_EXECUTE2 ); FUSION_ENTRY_PERMISSIONS_ADD( permissions.permissions, FUSION_CALL_EXECUTE3 ); } while (ioctl( _fusion_fd( call->shared ), FUSION_ENTRY_ADD_PERMISSIONS, &permissions ) < 0) { if (errno != EINTR) { D_PERROR( "Fusion/Call: FUSION_ENTRY_ADD_PERMISSIONS( id %d ) failed!\n", call->call_id ); return DR_FAILURE; } } return DR_OK; }
DirectResult fusion_call_destroy (FusionCall *call) { D_DEBUG_AT( Fusion_Call, "%s( %p )\n", __FUNCTION__, call ); D_ASSERT( call != NULL ); D_ASSERT( call->handler != NULL || call->handler3 != NULL ); if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call->handler ) ); while (ioctl (_fusion_fd( call->shared ), FUSION_CALL_DESTROY, &call->call_id)) { switch (errno) { case EINTR: continue; case EINVAL: //FIXME: kernel module destroys calls from exiting process already D_ERROR ("Fusion/Call: invalid call\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_CALL_DESTROY"); return DR_FAILURE; } call->handler = NULL; return DR_OK; }
DirectResult fusion_call_set_quota( FusionCall *call, FusionID fusion_id, unsigned int limit ) { FusionCallSetQuota set_quota; D_DEBUG_AT( Fusion_Call, "%s( %p, fusion_id %lu, limit %u )\n", __FUNCTION__, call, fusion_id, limit ); D_ASSERT( call != NULL ); set_quota.call_id = call->call_id; set_quota.fusion_id = fusion_id; set_quota.limit = limit; while (ioctl (_fusion_fd( call->shared ), FUSION_CALL_SET_QUOTA, &set_quota)) { switch (errno) { case EINTR: continue; default: break; } D_PERROR ("FUSION_CALL_SET_QUOTA"); return DR_FAILURE; } return DR_OK; }
DirectResult fusion_call_get_owner( FusionCall *call, FusionID *ret_fusion_id ) { FusionCallGetOwner get_owner; D_DEBUG_AT( Fusion_Call, "%s( %p )\n", __FUNCTION__, call ); D_ASSERT( call != NULL ); D_ASSERT( ret_fusion_id != NULL ); get_owner.call_id = call->call_id; while (ioctl (_fusion_fd( call->shared ), FUSION_CALL_GET_OWNER, &get_owner)) { switch (errno) { case EINTR: continue; default: break; } D_PERROR ("FUSION_CALL_GET_OWNER"); return DR_FAILURE; } *ret_fusion_id = get_owner.fusion_id; return DR_OK; }
/* * Input thread reading from device. * Generates events on incoming data. */ static void* dreamboxremoteEventThread( DirectThread *thread, void *driver_data ) { DreamboxremoteData *data = (DreamboxremoteData*) driver_data; int readlen; u16 rccode; DFBInputEvent evt; while ((readlen = read( data->fd, &rccode, 2 )) == 2) { direct_thread_testcancel( thread ); /* translate rccode to DirectFB keycode */ evt.key_symbol = dreamboxremote_parse_rccode( rccode ); if (evt.key_symbol != DIKS_NULL) { /* set event type and dispatch*/ evt.type = DIET_KEYPRESS; evt.flags = DIEF_KEYSYMBOL; dfb_input_dispatch( data->device, &evt ); /* set event type and dispatch*/ evt.type = DIET_KEYRELEASE; evt.flags = DIEF_KEYSYMBOL; dfb_input_dispatch( data->device, &evt ); } } if (readlen <= 0 && errno != EINTR) D_PERROR ("dreamboxremote thread died\n"); return NULL; }
DFBResult pxa3xxEngineSync( void *drv, void *dev ) { DFBResult ret = DFB_OK; PXA3XXDriverData *pdrv = drv; PXA3XXGfxSharedArea *shared = pdrv->gfx_shared; D_DEBUG_AT( PXA3XX_BLT, "%s()\n", __FUNCTION__ ); DUMP_INFO(); while (shared->hw_running && ioctl( pdrv->gfx_fd, PXA3XX_GCU_IOCTL_WAIT_IDLE ) < 0) { if (errno == EINTR) continue; ret = errno2result( errno ); D_PERROR( "PXA3XX/BLT: PXA3XX_GCU_IOCTL_WAIT_IDLE failed!\n" ); direct_log_printf( NULL, " -> %srunning, hw %d-%d, next %d-%d - %svalid\n", \ pdrv->gfx_shared->hw_running ? "" : "not ", \ pdrv->gfx_shared->hw_start, \ pdrv->gfx_shared->hw_end, \ pdrv->gfx_shared->next_start, \ pdrv->gfx_shared->next_end, \ pdrv->gfx_shared->next_valid ? "" : "not " ); break; } if (ret == DFB_OK) { D_ASSERT( !shared->hw_running ); } return ret; }
DirectResult fusion_property_lease (FusionProperty *property) { D_ASSERT( property != NULL ); while (ioctl (_fusion_fd( property->multi.shared ), FUSION_PROPERTY_LEASE, &property->multi.id)) { switch (errno) { case EINTR: continue; case EAGAIN: return DR_BUSY; case EINVAL: D_ERROR ("Fusion/Property: invalid property\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_PROPERTY_LEASE"); return DR_FAILURE; } return DR_OK; }
static void joystick_handle_event( JoystickData *data, struct js_event jse ) { DFBInputEvent event; switch (jse.type) { case JS_EVENT_BUTTON: event.type = (jse.value ? DIET_BUTTONPRESS : DIET_BUTTONRELEASE); event.flags = DIEF_NONE; /* button is always valid */ event.button = jse.number; break; case JS_EVENT_AXIS: event.type = DIET_AXISMOTION; event.flags = DIEF_AXISABS; event.axis = jse.number; event.axisabs = jse.value; break; case JS_EVENT_INIT: case JS_EVENT_INIT | JS_EVENT_BUTTON: case JS_EVENT_INIT | JS_EVENT_AXIS: D_ONCE( "Joystick sends JS_EVENT_INIT events, " \ "make sure it has been calibrated using 'jscal -c'\n"); return; break; default: D_PERROR ("unknown joystick event type\n"); return; } dfb_input_dispatch( data->device, &event ); }
DirectResult fusion_call_set_name( FusionCall *call, const char *name ) { FusionEntryInfo info; D_ASSERT( call != NULL ); D_ASSERT( name != NULL ); info.type = FT_CALL; info.id = call->call_id; direct_snputs( info.name, name, sizeof(info.name) ); while (ioctl (_fusion_fd( call->shared ), FUSION_ENTRY_SET_INFO, &info)) { perror("FUSION_ENTRY_SET_INFO"); switch (errno) { case EINTR: continue; case EAGAIN: return DR_LOCKED; case EINVAL: D_ERROR ("Fusion/Call: invalid call\n"); return DR_DESTROYED; default: break; } D_PERROR ("FUSION_ENTRY_SET_NAME"); return DR_FAILURE; } return DR_OK; }