自学教程：C++ D_PERROR函数代码示例

static voidvt_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" );     }}

DFBResultdfb_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 voidleave_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 DFBResultMapMemAndReg( 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 voiddriver_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 );}

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

voidfusion_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 DFBResultosdSetRegion( 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 DFBResultosdInitLayer( 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;}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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