Changeset 3

Timestamp:

Apr 26, 2017, 2:08:13 PM (7 years ago)

Author:

alain

Message:

Introduce dev_fbf, dev dma, dev_iob

Location:

trunk/kernel/devices

Files:

• dev_dma.c (added)
• dev_dma.h (added)
• dev_fbf.c (added)
• dev_fbf.h (added)
• dev_icu.c (modified) (15 diffs)
• dev_icu.h (modified) (10 diffs)
• dev_iob.c (moved) (moved from trunk/kernel/devices/dev_iox.c) (12 diffs)
• dev_iob.h (moved) (moved from trunk/kernel/devices/dev_iox.h) (6 diffs)
• dev_ioc.c (modified) (6 diffs)
• dev_ioc.h (modified) (3 diffs)
• dev_mmc.c (modified) (8 diffs)
• dev_mmc.h (modified) (2 diffs)
• dev_nic.c (modified) (8 diffs)
• dev_nic.h (modified) (3 diffs)
• dev_pic.c (modified) (6 diffs)
• dev_pic.h (modified) (4 diffs)
• dev_txt.c (modified) (5 diffs)
• dev_txt.h (modified) (5 diffs)

trunk/kernel/devices/dev_icu.c

@@ -24 +24 @@
 #include <hal_types.h>
 #include <hal_special.h>
-#include <device.h>
+#include <chdev.h>
 #include <thread.h>
 #include <cluster.h>
@@ -37 +37 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
-
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
-
-
-///////////////////////////////////
-void dev_icu_init( xptr_t   dev_xp,
-                   uint32_t hwi_nr,
-                   uint32_t wti_nr,
-                   uint32_t pti_nr )
-{
-    // get ICU device cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
-    if( dev_cxy != local_cxy )
-    {
-        printk("\n[PANIC] %s for cluster %x must be local\n",
-               __FUNCTION__ , local_cxy );
-        hal_core_sleep();
-    }
-
-    // set ICU device extension fields
-    dev_ptr->ext.icu.hwi_nr     = hwi_nr;
-    dev_ptr->ext.icu.wti_nr     = wti_nr;
-    dev_ptr->ext.icu.pti_nr     = pti_nr;
-    dev_ptr->ext.icu.wti_bitmap = 0;
-    spinlock_init( &dev_ptr->ext.icu.wti_lock );
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
+
+extern chdev_pic_input_t  chdev_pic_input;   // allocated in kernel_init.c
+
+/////////////////////////////////
+void dev_icu_init( chdev_t * icu,
+                   uint32_t  hwi_nr,
+                   uint32_t  wti_nr,
+                   uint32_t  pti_nr )
+{
+    // set ICU chdev extension fields
+    icu->ext.icu.hwi_nr     = hwi_nr;
+    icu->ext.icu.wti_nr     = wti_nr;
+    icu->ext.icu.pti_nr     = pti_nr;
+    icu->ext.icu.wti_bitmap = 0;
+    spinlock_init( &icu->ext.icu.wti_lock );
    
-    // get implementation index from ICU device descriptor
-    uint32_t impl = dev_ptr->impl;
-
-    // set field "name" in device descriptor
-    // and call the relevant driver init function
+    // get implementation
+    uint32_t impl = icu->impl;
+
+    // call the relevant driver init function
     if( impl == IMPL_ICU_XCU )
     {
-        memcpy( dev_ptr->name , "ICU_XCU" , 16 );
-
-        uint32_t     lid;
-        cluster_t  * cluster = LOCAL_CLUSTER;
-        for( lid = 0 ; lid < cluster->cores_nr ; lid++ )
+        uint32_t  lid;
+        for( lid = 0 ; lid < LOCAL_CLUSTER->cores_nr ; lid++ )
         {
-            soclib_xcu_init( dev_ptr , lid );
+            soclib_xcu_init( icu , lid );
         }
     }
     else
     {
-        printk("\n[PANIC] %s : undefined ICU implementation for cluste %x\n",
-               __FUNCTION__ , local_cxy );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "undefined ICU implementation" );
     }
 } // end dev_icu_init()
 
 /////////////////////////////////////////////////////////////////////////////////////
-// This static function check the irq_type / irq_index arguments for a remote ICU.
+// This static function check the irq_type / irq_index arguments.
 // It is called by the dev_icu_enable_irq() & dev_icu_disable_irq() functions.
-// returns 0 if OK / returns non zero if invalid arguments
 /////////////////////////////////////////////////////////////////////////////////////
-static inline void dev_icu_check_irq( xptr_t     icu_xp,
+static inline void dev_icu_check_irq( chdev_t  * icu,
                                       uint32_t   irq_type,
                                       uint32_t   irq_index )
 {
-    // get cluster and local pointer on remote ICU
-    cxy_t      icu_cxy = GET_CXY( icu_xp );
-    device_t * icu_ptr = (device_t *)GET_PTR( icu_xp );
-
     if( irq_type == HWI_TYPE ) 
     {
-        if( irq_index >= hal_remote_lw( XPTR( icu_cxy , &icu_ptr->ext.icu.hwi_nr ) ) )
-        {
-            printk("\n[PANIC] in %s : illegal HWI index = %d for ICU in cluster %x\n",
-                   __FUNCTION__ , irq_index , icu_cxy );
-            hal_core_sleep();
-        }
+        assert( (irq_index < icu->ext.icu.hwi_nr) , __FUNCTION__ , "illegal HWI" );
     }
     if( irq_type == WTI_TYPE )
     {
-        if( irq_index >= hal_remote_lw( XPTR( icu_cxy , &icu_ptr->ext.icu.wti_nr ) ) )
-        {
-            printk("\n[PANIC] in %s : illegal WTI index = %d for ICU in cluster %x\n",
-                   __FUNCTION__ , irq_index , icu_cxy );
-            hal_core_sleep();
-        }
+        assert( (irq_index < icu->ext.icu.wti_nr) , __FUNCTION__ , "illegal WTI" );
     }
     if( irq_type == PTI_TYPE )
     {
-        if( irq_index >= hal_remote_lw( XPTR( icu_cxy , &icu_ptr->ext.icu.pti_nr ) ) )
-        {
-            printk("\n[PANIC] in %s : illegal PTI index = %d for ICU in cluster %x\n",
-                   __FUNCTION__ , irq_index , icu_cxy );
-            hal_core_sleep();
-        }
-    }
-}  // end dev_icu check irq()
-
-////////////////////////////////////////////
-void dev_icu_enable_irq( cxy_t      icu_cxy,
-                         lid_t      lid,
+        assert( (irq_index < icu->ext.icu.pti_nr) , __FUNCTION__ , "illegal PTI" );
+    }
+}  // end dev_icu_check_irq()
+
+////////////////////////////////////////
+void dev_icu_enable_irq( lid_t      lid,
                          uint32_t   irq_type,
                          uint32_t   irq_index,
-                         xptr_t     src_dev_xp )
-{
-    // get extended pointer & local pointer on remote ICU device
-    xptr_t     icu_xp  = devices_dir.icu[icu_cxy];
-    device_t * icu_ptr = (device_t *)GET_PTR( icu_xp );
+                         chdev_t  * src_chdev )
+{
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
 
     // check IRQ type and index
-    dev_icu_check_irq( icu_xp , irq_type , irq_index );
+    dev_icu_check_irq( icu , irq_type , irq_index );
 
     // (1) call implementation specific ICU driver to enable IRQ
-    if( icu_ptr->impl == IMPL_ICU_XCU ) 
-    {
-        soclib_xcu_enable_irq( icu_xp , 1<<irq_index , irq_type , lid );
-    }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // (2) get selected remote core local pointer, and register
-    // source device xptr in relevant interrupt vector
-
-    core_t * core_ptr = hal_remote_lpt( XPTR( icu_cxy , &LOCAL_CLUSTER->core_tbl[lid] ) );
-    xptr_t   core_xp  = XPTR( icu_cxy , core_ptr );
-        core_set_irq_vector_entry( core_xp , irq_type , irq_index , src_dev_xp );
-
-    // (3) get extended pointer on source device, and 
-    // register IRQ type and index in source device descriptor
-
-    cxy_t      src_dev_cxy = GET_CXY( src_dev_xp );
-    device_t * src_dev_ptr = (device_t *)GET_PTR( src_dev_xp );
-
-    hal_remote_sw( XPTR( src_dev_cxy , &src_dev_ptr->irq_type ) , irq_type );
-    hal_remote_sw( XPTR( src_dev_cxy , &src_dev_ptr->irq_id   ) , irq_index );
+    if( icu->impl == IMPL_ICU_XCU ) 
+    {
+        soclib_xcu_enable_irq( icu , 1<<irq_index , irq_type , lid );
+    }
+
+    // (2) get selected core local pointer, and register
+    // source chdev pointer in relevant interrupt vector
+    core_t * core = &LOCAL_CLUSTER->core_tbl[lid];
+        core_set_irq_vector_entry( core , irq_type , irq_index , src_chdev );
+
+    // (3) register IRQ type and index in source chdev descriptor
+    src_chdev->irq_type = irq_type;
+    src_chdev->irq_id   = irq_index;
 
 }  // end dev_icu_enable_irq()
 
-/////////////////////////////////////////////
-void dev_icu_disable_irq( cxy_t      icu_cxy,
-                          lid_t      lid,
+/////////////////////////////////////////
+void dev_icu_disable_irq( lid_t      lid,
                           uint32_t   irq_type,
                           uint32_t   irq_index )
 {
-    // get extended pointer & local pointer on remote ICU device
-    xptr_t  icu_xp = devices_dir.icu[icu_cxy];
-    device_t * icu_ptr = (device_t *)GET_PTR( icu_xp );
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
 
     // check IRQ type and index
-    dev_icu_check_irq( icu_xp , irq_type , irq_index );
+    dev_icu_check_irq( icu , irq_type , irq_index );
 
     // (1) call the implementation specific ICU driver to disable IRQ 
-    if( icu_ptr->impl == IMPL_ICU_XCU ) 
-    {
-        soclib_xcu_disable_irq( icu_xp , 1<<irq_index , irq_type , lid );
-    }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
+    if( icu->impl == IMPL_ICU_XCU ) 
+    {
+        soclib_xcu_disable_irq( icu , 1<<irq_index , irq_type , lid );
     }
 
     // (2) get selected remote core local pointer, and remove
-    // the source device xptr from relevant interrupt vector
-
-    core_t * core_ptr = hal_remote_lpt( XPTR( icu_cxy , &LOCAL_CLUSTER->core_tbl[lid] ) );
-    xptr_t   core_xp  = XPTR( icu_cxy , core_ptr );
-        core_set_irq_vector_entry( core_xp , irq_type , irq_index , XPTR_NULL );
+    // the source chdev xptr from relevant interrupt vector
+
+    core_t * core = &LOCAL_CLUSTER->core_tbl[lid];
+        core_set_irq_vector_entry( core , irq_type , irq_index , NULL );
 
 } // end dev_icu_disable_irq()
@@ -212 +154 @@
                          uint32_t   period )
 {
-    // get pointer on local ICU device descriptor
-    core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
 
     // check PTI index
-    if( pti_index >= icu->ext.icu.pti_nr ) 
-    {
-        printk("\n[PANIC] in %s : illegal PTI index = %d\n", __FUNCTION__ , pti_index );
-        hal_core_sleep();
-    }
+    assert( (pti_index < icu->ext.icu.pti_nr) , __FUNCTION__ , "illegal PTI index" ); 
 
     // call the implementation specific driver ICU to set period 
@@ -233 +171 @@
 void dev_icu_ack_timer( uint32_t pti_index )
 {
-    // get pointer on local ICU device descriptor
-    core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
 
     // check PTI index
-    if( pti_index >= icu->ext.icu.pti_nr ) 
-    {
-        printk("\n[PANIC] in %s : illegal PTI index = %d\n", __FUNCTION__ , pti_index );
-        hal_core_sleep();
-    }
+    assert( (pti_index < icu->ext.icu.pti_nr) , __FUNCTION__ , "illegal PTI index" ); 
 
     // call the implementation specific driver ICU to acknowledge PTI IRQ
@@ -249 +183 @@
         soclib_xcu_ack_timer( icu , pti_index );
     }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
-    }
-
 }  // end dev_icu_ack_timer()
 
@@ -270 +198 @@
     uint32_t    y = cxy & ((1<<y_width)-1);
 
-    if( (x >= x_size) || (y >= y_size) )
-    {
-        hal_core_sleep("%s : illegal cluster identifier = %x\n", __FUNCTION__ , cxy );
-    } 
-    if( lid >= cores_nr )
-    {
-        hal_core_sleep("%s : illegal core local index = %d\n", __FUNCTION__ , lid );
-    } 
-
-    // get extended pointer on target ICU device
-    xptr_t icu_xp = devices_dir.icu[cxy];
+    assert( ((x < x_size) && (y < y_size)) , __FUNCTION__ , "illegal cluster identifier" );
+
+    assert( (lid < cores_nr) , __FUNCTION__ , "illegal core local index" );
+
+    // get extended pointer on target ICU chdev
+    xptr_t icu_xp = chdev_dir.icu[cxy];
 
      // get target ICU cluster and local pointer
-    cxy_t      cxy_icu = GET_CXY( icu_xp );
-    device_t * ptr_icu = (device_t *)GET_PTR( icu_xp );
-
-    // get driver implementation from target ICU device
-    uint32_t impl = hal_remote_lw( XPTR( cxy_icu , &ptr_icu->impl ) );   
+    cxy_t     icu_cxy = GET_CXY( icu_xp );
+    chdev_t * icu_ptr = (chdev_t *)GET_PTR( icu_xp );
+
+    // get implementation from remote ICU chdev
+    uint32_t impl = hal_remote_lw( XPTR( icu_cxy , &icu_ptr->impl ) );   
 
     // call the implementation specific ICU driver to send IPI
@@ -293 +216 @@
     {
         soclib_xcu_send_ipi( icu_xp , lid );
-    }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
     }
 }  // end dev_icu_send_ipi()
@@ -307 +225 @@
     uint32_t   wti_status;   // WTI index + 1  / no pending WTI if 0
     uint32_t   pti_status;   // PTI index + 1  / no pending PTI if 0
-    xptr_t     src_dev_xp;   // extended pointer on source device descriptor
-    cxy_t      src_dev_cxy;  // source device cluster
-    device_t * src_dev_ptr;  // source device local pointer
+    chdev_t  * src_chdev;    // pointer on source chdev descriptor
     uint32_t   index;        // IRQ index
 
-    // get pointer on local ICU device descriptor
     core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
+
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
 
     // call the implementation specific ICU driver  
@@ -322 +240 @@
         soclib_xcu_get_status( icu , core->lid , &hwi_status , &wti_status , &pti_status );
     }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
-    }
 
     // analyse ICU status and handle up to 3 pending IRQ (one WTI, one HWI, one PTI)
 
-    if( wti_status )          // pending WTI TODO what about IPIs ???  [AG]
+    if( wti_status )          // pending WTI 
         {
         index = wti_status - 1;
 
-        // get extended pointer on IRQ source device
-                src_dev_xp  = core->wti_vector[index];
-        src_dev_cxy = GET_CXY( src_dev_xp );
-        src_dev_ptr = (device_t *)GET_PTR( src_dev_xp );
-
-                if( src_dev_xp == XPTR_NULL )        // strange, but not fatal => disable IRQ
-                {
-            printk("\n[WARNING] in %s : no handler for WTI %d on core %d in cluster %x\n",
-                   __FUNCTION__ , index , core->lid , local_cxy );
-                core->spurious_irqs ++;
-            dev_icu_disable_irq( local_cxy , core->lid , WTI_TYPE , index ); 
-                }
-        else if( src_dev_cxy != local_cxy )  // WTI must be handled in device cluster
+        if( index < LOCAL_CLUSTER->cores_nr )   // it is an IPI
         {
-            printk("\n[PANIC] in %s : non local WTI %d on core %d in cluster %x\n",
-                   __FUNCTION__ , index , core->lid , local_cxy );
-            hal_core_sleep();
+            assert( (index == core->lid) , __FUNCTION__ , "illegal IPI index" );
+
+            // TODO acknowledge WTI [AG]
+
+            // TODO force scheduling [AG]
         }
-        else                                 // call relevant ISR
+        else                                    // it is an external device
         {
-                    icu_dmsg("\n[INFO] %s received WTI : index = %d for cpu %d in cluster %d\n",
-                     __FUNCTION__ , index , core->lid , local_cxy );
-
-                src_dev_ptr->isr( src_dev_ptr );
+            // get pointer on IRQ source chdev
+                    src_chdev = core->wti_vector[index];
+
+                    if( src_chdev == NULL )        // strange, but not fatal => disable IRQ
+                    {
+                printk("\n[WARNING] in %s : no handler for WTI %d on core %d in cluster %x\n",
+                       __FUNCTION__ , index , core->lid , local_cxy );
+                    core->spurious_irqs ++;
+                dev_icu_disable_irq( core->lid , WTI_TYPE , index ); 
+            }
+            else                                 // call relevant ISR
+            {
+                        icu_dmsg("\n[INFO] %s received WTI : index = %d for cpu %d in cluster %d\n",
+                         __FUNCTION__ , index , core->lid , local_cxy );
+
+                // call ISR
+                    src_chdev->isr( src_chdev );
+            }
         }
         }
@@ -365 +282 @@
         index = hwi_status - 1;
 
-        // get pointer on IRQ source device
-                src_dev_xp  = core->wti_vector[index];
-        src_dev_cxy = GET_CXY( src_dev_xp );
-        src_dev_ptr = (device_t *)GET_PTR( src_dev_xp );
-
-                if( src_dev_xp == XPTR_NULL )        // strange, but not fatal => disable IRQ
+        // get pointer on IRQ source chdev
+                src_chdev = core->hwi_vector[index];
+
+                if( src_chdev == NULL )        // strange, but not fatal => disable IRQ
                 {
             printk("\n[WARNING] in %s : no handler for HWI %d on core %d in cluster %x\n",
                    __FUNCTION__ , index , core->lid , local_cxy );
                 core->spurious_irqs ++;
-            dev_icu_disable_irq( local_cxy , core->lid , HWI_TYPE , index ); 
+            dev_icu_disable_irq( core->lid , HWI_TYPE , index ); 
                 }
-        else if( src_dev_cxy != local_cxy )  // HWI must be handled in device cluster
-        {
-            printk("\n[PANIC] in %s : non local HWI %d on core %d in cluster %x\n",
-                   __FUNCTION__ , index , core->lid , local_cxy );
-            hal_core_sleep();
-        }
         else                    // call relevant ISR
         {
@@ -388 +297 @@
                      __FUNCTION__ , index , core->lid , local_cxy );
 
-                    src_dev_ptr->isr( src_dev_ptr );
+            // call ISR
+                    src_chdev->isr( src_chdev );
         }
         }
@@ -402 +312 @@
         dev_icu_ack_timer( index );
 
-        // execute all actions related to TICK event
+        // TODO execute all actions related to TICK event
         core_clock( core );
         }
@@ -410 +320 @@
 uint32_t dev_icu_wti_alloc()
 {
-    // get pointer on local ICU device descriptor
-    core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
-
-    // get bitmap pointer, lock, and size
-    bitmap_t   * bitmap = &icu->ext.icu.wti_bitmap;
+    // get local pointer on local ICU chdev
+    xptr_t    icu_xp = chdev_dir.icu[local_cxy];
+    chdev_t * icu    = (chdev_t *)GET_PTR( icu_xp );
+
+    // get bitmap pointer, lock pointer, and size
+    uint32_t   * bitmap = &icu->ext.icu.wti_bitmap;
     spinlock_t * lock   = &icu->ext.icu.wti_lock;
     uint32_t     size   =  icu->ext.icu.wti_nr;
@@ -437 +347 @@
 void dev_icu_wti_release( uint32_t index )
 {
-    // get pointer on local ICU device descriptor
-    core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
+    // get pointer on local ICU chdev descriptor
+    xptr_t    icu_xp  = chdev_dir.icu[local_cxy];
+    chdev_t * icu_ptr = (chdev_t *)GET_PTR( icu_xp );
 
     // get bitmap pointer, lock, and size
-    bitmap_t   * bitmap = &icu->ext.icu.wti_bitmap;
-    spinlock_t * lock   = &icu->ext.icu.wti_lock;
-    uint32_t     size   =  icu->ext.icu.wti_nr;
+    bitmap_t   * bitmap = &icu_ptr->ext.icu.wti_bitmap;
+    spinlock_t * lock   = &icu_ptr->ext.icu.wti_lock;
+    uint32_t     size   =  icu_ptr->ext.icu.wti_nr;
 
     // check index
-    if( index >= size )
-    {
-        printk("\n[PANIC] in %s : illegal WTI index = %d on core %d in cluster %x\n",
-               __FUNCTION__ , index , core->lid , local_cxy );
-        hal_core_sleep();
-    }
+    assert( (index < size) , __FUNCTION__ , "illegal WTI index" );
 
     // get lock protecting WTI allocator
@@ -462 +367 @@
     // release lock
     spinlock_unlock( lock );
+
 }  // end dev_icu_wti_release()
 
-///////////////////////////////////////
-xptr_t dev_icu_wti_xptr( cxy_t     cxy,
-                         uint32_t  wti_id )
-{
-    uint32_t * ptr = NULL;    // local pointer on mailbox
-    
-    // get pointer on local ICU device descriptor
-    core_t   * core = CURRENT_CORE;
-    device_t * icu  = core->icu;
+//////////////////////////////////////////////
+uint32_t * dev_icu_wti_ptr( uint32_t  wti_id )
+{
+    uint32_t *  wti_ptr = NULL;
+
+    // get pointer on local ICU chdev descriptor
+    xptr_t    icu_xp  = chdev_dir.icu[local_cxy];
+    chdev_t * icu     = (chdev_t *)GET_PTR( icu_xp );
 
     // call implementation specific ICU driver
     if( icu->impl == IMPL_ICU_XCU )
     {
-        ptr = soclib_xcu_wti_ptr( icu , wti_id );   
-    }
-    else
-    {
-        printk("\n[PANIC] in %s : undefined ICU implementation" , __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // return extended pointer on mailbox
-    return XPTR( cxy , ptr );
-
+        wti_ptr = soclib_xcu_wti_ptr( icu , wti_id );   
+    }
+
+    return wti_ptr;
 }   // end dev_icu_wti_xptr()
 

trunk/kernel/devices/dev_icu.h

@@ -35 +35 @@
  * acting in all clusters containing cores. He is in charge of concentrating all IRQs
  * (interrupt requests) generated by peripherals to signal the completion of an I/O 
- * operation. Each IRQ should be routed to the core that started the I/O operation. 
+ * operation. Each IRQ is routed to the core that started the I/O operation. 
  * The ICU device must also help the kernel to select the ISR (Interrupt Service Routine)
  * that must be executed by the target core.
  *
- * This component can be implemented as a dedicated hardware, centralized or distributed
+ * This component can be implemented as a dedicated hardware component distributed
  * in all clusters, or emulated in software, as long as it implements the specified API.
  * For the TSAR architecture, this generic ICU device is implemented by the two hardware
  * components soclib_xicu and and soclib_iopic, and their associated drivers.
  *
- * ALMOS-MKH defines three types of IRQs, that are handled iby this ICU device:
+ * ALMOS-MKH defines three types of IRQs, that are handled by this ICU device:
  * - HWI : The HardWare Interrupts are generated by local internal peripherals.
  *   They are connected to the local ICU, to be routed to a given local core.
@@ -72 +72 @@
  * uses three interrupts vectors, implemented as three arrays (HWI/WTI/PTI),
  * stored in the core descriptor. Each entry in one interrupt vector array contains
- * an extended pointer on the device descriptor that is the "source" of the interrupt.
- * This device descriptor contains a link to the ISR to be executed.
+ * a pointer on the chdev descriptor that is the "source" of the interrupt.
+ * This chdev descriptor contains a link to the ISR to be executed.
  *
  * The ICU peripheral does not execute I/O operations, but is just acting as a 
- * dynamically configurable interrupt router for another I/O operation.
- * Therefore, ALMOS-MKH does not use the iCU device waiting queue, but calls directly 
+ * dynamically configurable interrupt router for other I/O operations.
+ * Therefore, ALMOS-MKH does not use the ICU device waiting queue, but calls directly 
  * the ICU driver blocking functions, using the device lock to get exclusive access to 
  * the ICU device state.
@@ -84 +84 @@
 /****  Forward declarations  ****/
 
-struct device_s;
+struct chdev_s;
 
 /*****************************************************************************************
@@ -127 +127 @@
 /*****************************************************************************************
  * This function makes two initialisations:
- * - It initialises the ICU specific fields of the device descriptor.
+ * - It initialises the ICU specific fields of the chdev descriptor.
  * - it initialises the implementation specific ICU hardware device and associated
  *   data structures if required.
- * It must be executed once in the cluster containing the ICU device descriptor.
- *****************************************************************************************
- * @ icu_xp     : extended pointer on ICU device descriptor.
- * @ hwi_nr     : number of HWI irqs.
- * @ wti_nr     : number of WTI irqs.
- * @ pti_nr     : number of PTI irqs.
- ****************************************************************************************/
-void dev_icu_init( xptr_t    icu_xp,
-                   uint32_t  hwi_nr,
-                   uint32_t  wti_nr,
-                   uint32_t  pti_nr );
-
-/*****************************************************************************************
- * This function enables the routing of a given IRQ, to a given core in a remote cluster.
- * This IRQ is identified by its type (HWI/WTI/PTI) and index in the remote ICU.
+ * It must be called by a local thread.
+ *****************************************************************************************
+ * @ icu     : pointer on ICU chdev descriptor.
+ * @ hwi_nr  : number of HWI irqs.
+ * @ wti_nr  : number of WTI irqs.
+ * @ pti_nr  : number of PTI irqs.
+ ****************************************************************************************/
+void dev_icu_init( struct chdev_s  * icu,
+                   uint32_t          hwi_nr,
+                   uint32_t          wti_nr,
+                   uint32_t          pti_nr );
+
+/*****************************************************************************************
+ * This function enables the routing of a given IRQ, to a given core in the local cluster.
+ * This IRQ is identified by its type (HWI/WTI/PTI) and index in the local ICU.
  * The target core is identified by its local index.
- * As it uses remote accesses, it can be executed by any thread in any cluster.
- * - It unmask the selected IRQ in the remote ICU. 
- * - It registers the extended pointer on the "source" device descriptor in the
+ * It must be called by a local thread.
+ * - It unmask the selected IRQ in the ICU. 
+ * - It registers the pointer on the "source" chdev descriptor in the
  *   relevant interrupt vector of the selected core.
- * - It register the IRQ type and index in the "source" device descriptor.
- *****************************************************************************************
- * @ cxy        : remote cluster identifier (can be the local custer).
- * @ lid        : local index of selected core in remote cluster.
+ * - It register the IRQ type and index in the "source" chdev descriptor.
+ *****************************************************************************************
+ * @ lid        : local index of selected core.
  * @ irq_type   : HWI/WTI/PTI.
- * @ irq_id     : IRQ index in remote ICU
- * @ src_dev_xp : extended pointer on device descriptor source of IRQ.
- ****************************************************************************************/
-void dev_icu_enable_irq( cxy_t      cxy,
-                         lid_t      lid,
-                         uint32_t   irq_type,
-                         uint32_t   irq_id,
-                         xptr_t     src_dev_xp );
-
-/*****************************************************************************************
- * This function disables one given IRQ for a given core in a remote cluster.
- * This IRQ is identified by its type (HWI/WTI/PTI) and index in the remote ICU.
+ * @ irq_id     : IRQ index in ICU
+ * @ chdev      : pointer on source chdev descriptor.
+ ****************************************************************************************/
+void dev_icu_enable_irq( lid_t             lid,
+                         uint32_t          irq_type,
+                         uint32_t          irq_id,
+                         struct chdev_s  * chdev );
+
+/*****************************************************************************************
+ * This function disables one given IRQ for a given core in the local cluster.
+ * This IRQ is identified by its type (HWI/WTI/PTI) and index in the local ICU.
  * The core is identified by its local index.
- * As it uses remote accesses, it can be executed by any thread in any cluster.
- * - It mask the selected IRQ in the remote ICU. 
- * - It removes the extended pointer on the "source" device descriptor from the
+ * It must be called by a local thread.
+ * - It mask the selected IRQ in the ICU. 
+ * - It removes the pointer on the "source" chdev descriptor from the
  *   relevant interrupt vector of the selected core.
- * - The IRQ type and index fields are not modified in the "source" device descriptor.
- *****************************************************************************************
- * @ cxy       : remote cluster identifier (can be the local custer).
+ * - The IRQ type and index fields are not modified in the "source" chdev descriptor.
+ *****************************************************************************************
  * @ lid       : local index of selected core in remote cluster.
  * @ irq_type  : HWI/WTI/PTI.
  * @ irq_id    : IRQ index.
  ****************************************************************************************/
-void dev_icu_disable_irq( cxy_t      cxy,
-                          lid_t      lid,
+void dev_icu_disable_irq( lid_t      lid,
                           uint32_t   irq_type,
                           uint32_t   irq_id );
@@ -187 +183 @@
  * This function set the period value for a timer identified by the PTI index,
  * in the local ICU device descriptor.
+ * It must be called by a local thread.
  *****************************************************************************************
  * @ pti_id    : PTI index.
@@ -197 +194 @@
  * This function acknowledge a PTI IRQ for a timer identified by the PTI index,
  * in the local ICU device descriptor.
+ * It must be called by a local thread.
  *****************************************************************************************
  * @ pti_id    : PTI index.
@@ -204 +202 @@
 /*****************************************************************************************
  * This function send an IPI (Inter Processor Interrupt) to a core identified by
- * its cluster identifier and local index. 
+ * its cluster identifier and local index.
+ * It can be called by any thread running in any cluster. 
  * This IPI force a context switch, and the handling of pending RPC(s).
  *****************************************************************************************
@@ -226 +225 @@
 
 /*****************************************************************************************
- * This function implements the WTI mailbox allocator. It is used by all I/O operations
- * for completion signaling.
+ * This function implements the WTI mailbox allocator for the local ICU.
+ * These mailbox are used by I/O operations for completion signaling.
+ * It must be called by a thread running in the cluster containing the target ICU.
  * If there is no mailbox available, the client thread must deschedule and retry later.
  * If N is the total number of WTI mailboxes in a cluster, and NC the number of cores,
@@ -240 +240 @@
 /*****************************************************************************************
  * This function releases a dynamically allocated WTI mailbox.
+ * It must be called by a thread running in the cluster containing the target ICU.
  * It does not access the hardware device.
  *****************************************************************************************
@@ -247 +248 @@
 
 /*****************************************************************************************
- * This function returns an extended pointer on a WTI mailbox identified by its
- * cluster identifier and local index in ICU.
- * WARNING: we assume that all ICU hardware devices have the same local base address.
- *****************************************************************************************
- * @ cxy      : mailbox cluster identifier
- * @ wti_id   : mailbox WTI index.
- * @ returns extended pointer on mailbox register.
- ****************************************************************************************/
-xptr_t  dev_icu_wti_xptr( cxy_t    cxy,
-                          uint32_t wti_id );
+ * This function returns a pointer on the WTI mailbox identified by its index
+ * in the local ICU device.
+ *****************************************************************************************
+ * @ wti_id   : WTI mailbox index.
+ * @ returns pointer on mailbox register.
+ ****************************************************************************************/
+uint32_t * dev_icu_wti_ptr( uint32_t wti_id );
 
 #endif  /* _DEV_ICU_H_ */

trunk/kernel/devices/dev_iob.c

@@ -1 +1 @@
 /*
- * dev_iox.c - IOX (bridge to external I/O) generic device API implementation.
+ * dev_iob.c - IOB (bridge to external I/O) generic device API implementation.
  *
  * Authors   Alain Greiner  (2017)
@@ -14 +14 @@
  * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTIOXLAR PURPOSE.  See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTIOBLAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
@@ -26 +26 @@
 #include <hal_special.h>
 #include <remote_spinlock.h>
-#include <device.h>
+#include <chdev.h>
 #include <printk.h>
 #include <soclib_iob.h>
-#include <dev_iox.h>
+#include <dev_iob.h>
 
-//////////////////////////////////
-void dev_iox_init( xptr_t dev_xp )
+////////////////////////////////////
+void dev_iob_init( chdev_t * chdev )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
-    // get implementation from device descriptor
-    uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
+    // get implementation 
+    uint32_t  impl = chdev->impl;
 
     // call driver init function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
-        soclib_iob_init( dev_xp );
+        soclib_iob_init( chdev );
     }
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "undefined IOB device implementation\n" );
     }
 }
 
 //////////////////////////////////////////
-void dev_iox_iommu_enable( xptr_t dev_xp )
+void dev_iob_iommu_enable( xptr_t dev_xp )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get IOB chdev descriptor cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
-    // get implementation from device descriptor
+    // get implementation from chdev descriptor
     uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
 
     // call driver function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
         remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
@@ -72 +67 @@
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s: undefined IOB device implementation\n", __FUNCTION__ );
         hal_core_sleep();
     }
@@ -78 +73 @@
 
 ///////////////////////////////////////////
-void dev_iox_iommu_disable( xptr_t dev_xp )
+void dev_iob_iommu_disable( xptr_t dev_xp )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get IOB chdev descriptor cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
-    // get implementation from device descriptor
+    // get implementation from chdev descriptor
     uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
 
     // call driver function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
         remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
@@ -96 +91 @@
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s: undefined IOB device implementation\n", __FUNCTION__ );
         hal_core_sleep();
     }
@@ -102 +97 @@
 
 ////////////////////////////////////////
-void dev_iox_set_ptpr( xptr_t    dev_xp,
+void dev_iob_set_ptpr( xptr_t    dev_xp,
                        uint32_t  wdata )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get IOB chdev descriptor cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
-    // get implementation from device descriptor
+    // get implementation from chdev descriptor
     uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
 
     // call driver function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
         remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
@@ -121 +116 @@
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s: undefined IOB device implementation\n", __FUNCTION__ );
         hal_core_sleep();
     }
@@ -127 +122 @@
                         
 ////////////////////////////////////////
-void dev_iox_inval_page( xptr_t  dev_xp,
+void dev_iob_inval_page( xptr_t  dev_xp,
                          vpn_t   vpn )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get IOB chdev descriptor cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
-    // get implementation from device descriptor
+    // get implementation from chdev descriptor
     uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
 
     // call driver function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
         remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
@@ -146 +141 @@
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s: undefined IOB device implementation\n", __FUNCTION__ );
         hal_core_sleep();
     }
@@ -152 +147 @@
 
 ///////////////////////////////////////////
-void dev_iox_get_status( xptr_t     dev_xp,
+void dev_iob_get_status( xptr_t     dev_xp,
                          uint32_t * error,
                          uint32_t * bvar,
                          uint32_t * srcid )
 {
-    // get IOX device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get IOB chdev descriptor cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
-    // get implementation from device descriptor
+    // get implementation from chdev descriptor
     uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
 
     // call driver function
-    if( impl == IMPL_IOX_IOB )
+    if( impl == IMPL_IOB_TSR )
     {
         remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
@@ -175 +170 @@
     else
     {
-        printk("\n[PANIC] in %s: undefined IOX device implementation\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s: undefined IOB device implementation\n", __FUNCTION__ );
         hal_core_sleep();
     }

trunk/kernel/devices/dev_iob.h

@@ -1 +1 @@
 /*
- * dev_iox.h - IOX (bridge to external I/O) generic device API.
+ * dev_iob.h - IOB (bridge to external I/O) generic device API.
  *
  * Authors   Alain Greiner  (2016)
@@ -14 +14 @@
  * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTIOXLAR PURPOSE.  See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTIOBLAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
@@ -22 +22 @@
  */
 
-#ifndef _DEV_IOX_H_
-#define _DEV_IOX_H_
+#ifndef _DEV_IOB_H_
+#define _DEV_IOB_H_
 
 #include <almos_config.h>
@@ -30 +30 @@
 
 /*****************************************************************************************
- *     Generic IOX (bridge to external IO peripherals) definition.
+ *     Generic IOB (bridge to external IO peripherals) definition.
  *
- * The IOX device is used to access external peripherals. It implements an IO-MMU service 
+ * The IOB device is used to access external peripherals. It implements an IO-MMU service 
  * for DMA transactions launched by DMA capable external peripherals.
- * This IOX peripheral is acting as a dynamically configurable bridge, used for others 
- * I/O operations. Therefore, ALMOS-MKH does not use the IOX device waiting queue,
- * and calls directly the IOX driver blocking functions, using the device lock to 
- * get exclusive access to the IOX bridge internal state.
+ * This IOB peripheral is acting as a dynamically configurable bridge, used for others 
+ * I/O operations. Therefore, ALMOS-MKH does not use the IOB device waiting queue,
+ * and calls directly the IOB driver blocking functions, using the device lock to 
+ * get exclusive access to the IOB bridge internal state.
  ****************************************************************************************/
  
+/****  Forward declarations  ****/
+
+struct chdev_s;
 
 /*****************************************************************************************
- * This enum defines the various implementations of the IOX generic device.
+ * This enum defines the various implementations of the IOB generic device.
  * This array must be kept consistent with the define in arch_info.h file
  ****************************************************************************************/
 
-enum iox_impl_e
+enum iob_impl_e
 {
-    IMPL_IOX_IOB =   0,         /* vci_iob component used in TSAR                       */
-    IMPL_IOX_I86 =   1,         /* TBD                                                  */
+    IMPL_IOB_TSR =   0,         /* vci_iob component used in TSAR                       */
+    IMPL_IOB_I86 =   1,         /* TBD                                                  */
 }
-iox_impl_t;
+iob_impl_t;
 
 /*****************************************************************************************
- * This function initializes the IOX device descriptor with IOMMU disabled.
+ * This function initializes the IOB device descriptor with IOMMU disabled.
  *****************************************************************************************
- * @ dev_xp     : extended pointer on IOX device descriptor.
+ * @ chdev      :  pointer on IOB chdev descriptor.
  ****************************************************************************************/
-void dev_iox_init( xptr_t dev_xp );
+void dev_iob_init( struct chdev_s * chdev );
 
 /*****************************************************************************************
- * This function activates the IOMMU for the IOX device identified by its
+ * This function activates the IOMMU for the IOB device identified by its
  * extended pointer.
  *****************************************************************************************
- * @ dev_xp   : extended pointer on IOX device descriptor.
+ * @ dev_xp   : extended pointer on IOB device descriptor.
  ****************************************************************************************/
-void dev_iox_iommu_enable( xptr_t dev_xp );
+void dev_iob_iommu_enable( xptr_t dev_xp );
 
 /*****************************************************************************************
- * This function desactivates the IO-MMU for the IOX device identified by its
+ * This function desactivates the IO-MMU for the IOB device identified by its
  * extended pointer.
  *****************************************************************************************
- * @ dev_xp   : extended pointer on IOX device descriptor.
+ * @ dev_xp   : extended pointer on IOB device descriptor.
  ****************************************************************************************/
-void dev_iox_iommu_disable( xptr_t dev_xp );
+void dev_iob_iommu_disable( xptr_t dev_xp );
 
 /*****************************************************************************************
  * This function set a new value in the IO-MMU PTPR register.
  *****************************************************************************************
- * @ dev_xp   : extended pointer on IOX device descriptor.
+ * @ dev_xp   : extended pointer on IOB device descriptor.
  * @ wdata    : value to be written in PTPR register.
  ****************************************************************************************/
-void dev_iox_set_ptpr( xptr_t    dev_xp,
+void dev_iob_set_ptpr( xptr_t    dev_xp,
                        uint32_t  wdata );
                         
@@ -88 +91 @@
  * This function invalidates an IOMMU TLB entry identified by its vpn.
  *****************************************************************************************
- * @ dev_xp   : extended pointer on IOX device descriptor.
+ * @ dev_xp   : extended pointer on IOB device descriptor.
  * @ vpn      : virtual page number in IO virtual space.
  ****************************************************************************************/
-void dev_iox_inval_page( xptr_t  dev_xp,
+void dev_iob_inval_page( xptr_t  dev_xp,
                          vpn_t   vpn );
 
@@ -97 +100 @@
  * This function return informations relative to an error reported by the IOMMU.
  *****************************************************************************************
- * @ dev_xp   : extended pointer on IOX device descriptor.
+ * @ dev_xp   : extended pointer on IOB device descriptor.
  * @ error    : [out] pointer on buffer for erro type.
  * @ bvar     : [out] pointer on buffer for bad virtual address.
  * @ srcid    : [out] pointer on buffer for faulty peripheral index.
  ****************************************************************************************/
-void dev_iox_get_status( xptr_t     dev_xp,
+void dev_iob_get_status( xptr_t     dev_xp,
                          uint32_t * error,
                          uint32_t * bvar,
                          uint32_t * srcid );
 
-#endif  /* _DEV_IOX_H_ */
+#endif  /* _DEV_IOB_H_ */

trunk/kernel/devices/dev_ioc.c

@@ -32 +32 @@
 #include <thread.h>
 #include <printk.h>
+#include <chdev.h>
 #include <dev_ioc.h>
 
@@ -38 +39 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
 
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
+extern chdev_pic_input_t  chdev_pic_input;   // allocated in kernel_init.c
 
-//////////////////////////////////
-void dev_ioc_init( xptr_t dev_xp )
+////////////////////////////////////
+void dev_ioc_init( chdev_t * chdev )
 {
-    // get IOC device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // the local ICU chdev must be initialized before the IOC chdev, because
+    // the IOC chdev initialisation requires allocation of a WTI from local ICU
+    xptr_t  icu_xp  = chdev_dir.icu[local_cxy];
+    assert( (icu_xp != XPTR_NULL) , __FUNCTION__ , "ICU not initialised before IOC" );
 
-    // get implementation from device descriptor
-    uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
+    // get implementation and channel from chdev descriptor
+    uint32_t  impl    = chdev->impl;
+    uint32_t  channel = chdev->channel;
 
-    // set driver specific fields in device descriptor
-    // and call driver init function
+    // set driver specific fields in chdev descriptor and call driver init function
     if( impl == IMPL_IOC_BDV )
     {
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_bdv_command );
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_bdv_isr );
-        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-                           XPTR( local_cxy , "IOC_BDV" ) , 16 );
-        soclib_bdv_init( dev_xp );
+        chdev->cmd = &soclib_bdv_cmd;
+        chdev->isr = &soclib_bdv_isr;
+        soclib_bdv_init( chdev );
     }
     else if( impl == IMPL_IOC_HBA )
     {
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_hba_command );
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_hba_isr );
-        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-                           XPTR( local_cxy , "IOC_HBA" ) , 16 );
-        soclib_hba_init( dev_xp );
+        chdev->cmd = &soclib_hba_command;
+        chdev->isr = &soclib_hba_isr;
+        soclib_hba_init( chdev );
     }
-//    else if( impl == IMPL_IOC_SDC )
-//    {
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_sdc_command );
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_sdc_isr );
-//        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-//                           XPTR( local_cxy , "IOC_SDC" ) , 16 );
-//        soclib_sdc_init( dev_xp );
-//    }
-//    else if( impl == IMPL_IOC_SPI )
-//    {
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_spi_command );
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_spi_isr );
-//        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-//                           XPTR( local_cxy , "IOC_SPI" ) , 16 );
-//        soclib_spi_init( dev_xp );
-//    }
-//    else if( impl == IMPL_IOC_RDK )
-//    {
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_rdk_command );
-//        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_rdk_isr );
-//        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-//                           XPTR( local_cxy , "IOC_RDK" ) , 16 );
-//        soclib_rdk_init( dev_xp );
-//    }
     else
     {
-        printk("\n[PANIC] in %s: undefined IOC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "undefined IOC device implementation" );
     }
 
+    // get a WTI mailbox from local ICU
+    uint32_t wti_id = dev_icu_wti_alloc();
+
+    assert( (wti_id != -1) , __FUNCTION__ , "cannot allocate WTI mailbox" );
+
+    // select a core
+    lid_t lid = cluster_select_local_core();
+
+    // enable WTI IRQ and update WTI interrupt vector
+    dev_icu_enable_irq( lid , WTI_TYPE , wti_id , chdev );
+
+    // link IOC IRQ to WTI mailbox in PIC component 
+    uint32_t irq_id = chdev_pic_input.ioc[channel];
+    dev_pic_bind_irq( irq_id , local_cxy , wti_id );
+
     // create server thread
-    thread_t * new_thread_ptr;
-    xptr_t     new_thread_xp;
+    thread_t * new_thread;
     error_t    error;
 
-    if( dev_cxy == local_cxy )         // device cluster is local
-    {
-        error = thread_kernel_create( &new_thread_ptr,
-                                      THREAD_DEV,
-                                      &dev_ioc_server,
-                                      dev_ptr,
-                                      cluster_select_local_core() ); 
+    error = thread_kernel_create( &new_thread,
+                                  THREAD_DEV,
+                                  &chdev_sequencial_server,
+                                  chdev,
+                                  lid ); 
+    assert( (error == 0) , __FUNCTION__ , "cannot create server thread" );
 
-        new_thread_xp = XPTR( local_cxy , new_thread_ptr );
-    }
-    else                                    // device cluster is remote
-    {
-        rpc_thread_kernel_create_client( dev_cxy,
-                                         THREAD_DEV,
-                                         &dev_ioc_server,
-                                         dev_ptr,
-                                         &new_thread_xp,
-                                         &error );
-
-        new_thread_ptr = (thread_t *)GET_PTR( new_thread_xp );
-    }
-    if( error )
-    {
-        printk("\n[PANIC] in %s : cannot create server thread\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // set "server" field in device descriptor
-    hal_remote_spt( XPTR( dev_cxy , &dev_ptr->server ) , new_thread_ptr );
+    // set "server" field in chdev descriptor
+    chdev->server = new_thread;
     
     // start server thread
-    thread_unblock( new_thread_xp , THREAD_BLOCKED_GLOBAL );
+    thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
  
 }  // end dev_ioc_init()
@@ -144 +111 @@
 // It builds and registers the command in the calling thread descriptor, after
 // translation of buffer virtual address to physical address. 
-// Then, it registers the calling thead in device waiting queue.
+// Then, it registers the calling thead in chdev waiting queue.
 // Finally it blocks on the THREAD_BLOCKED_DEV condition and deschedule.
 ////////////////////////////////////i/////////////////////////////////////////////
@@ -152 +119 @@
                                uint32_t  count )
 {
-    thread_t  * this      = CURRENT_THREAD;              // pointer on client thread
-    cxy_t       local_cxy = local_cxy;                   // client thread cluster
+    thread_t * this = CURRENT_THREAD;              // pointer on client thread
 
     error_t     error;
     paddr_t     buf_paddr;
-    bool_t      ident = CONFIG_KERNEL_IDENTITY;
 
     // Get buffer physical address
-    error = vmm_v2p_translate( ident , buffer , &buf_paddr );
+    error = vmm_v2p_translate( CONFIG_KERNEL_IDENTITY , buffer , &buf_paddr );
  
     if( error )  return EINVAL;
 
     ioc_dmsg("\n[INFO] in %s : thread %x in process %x"
-             " for lba = %x / vaddr = %x / paddr = %llx\n", 
+             " for lba = %x / vaddr = %x / paddr = %l / at cycle %d\n", 
              __FUNCTION__ , this->trdid , this->process->pid , 
-             lba , (uint32_t)buffer , buf_paddr );
+             lba , (uint32_t)buffer , buf_paddr , hal_time_stamp() );
 
 #if USE_IOB    // software L2/L3 cache coherence for memory buffer 
@@ -176 +141 @@
 #endif     // end software L2/L3 cache coherence
 
-    // get extended pointer on IOC device descriptor
-    xptr_t  dev_xp = devices_dir.ioc;
+    // get extended pointer on IOC chdev descriptor
+    xptr_t  dev_xp = chdev_dir.ioc[0];
 
-    if ( dev_xp == XPTR_NULL )
-    {
-        printk("\n[PANIC] in %s : undefined IOC device descriptor\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined IOC chdev descriptor" );
 
-    // get a free WTI mailbox  
-    uint32_t wti_id;
-    while( 1 )
-    {
-        wti_id = dev_icu_wti_alloc();
-        if( wti_id == -1 )  sched_yield();
-        else                break;
-    }
+    // register command in calling thread descriptor
+    this->command.ioc.dev_xp    = dev_xp;
+    this->command.ioc.to_mem    = to_mem;
+    this->command.ioc.buf_xp    = XPTR( local_cxy , buffer );
+    this->command.ioc.lba       = lba;
+    this->command.ioc.count     = count;
 
-    // enable WTI IRQ in local ICU and update WTI interrupt vector
-    dev_icu_enable_irq( local_cxy, CURRENT_CORE->lid , WTI_TYPE , wti_id , dev_xp );
-
-    // link IOC IRQ to WTI mailbox in PIC component 
-    uint32_t irq_id = devices_input_irq.ioc; 
-    dev_pic_bind_irq( irq_id , local_cxy , wti_id );
-
-    // store command in thread descriptor
-    this->dev.ioc.dev_xp    = dev_xp;
-    this->dev.ioc.to_mem    = to_mem;
-    this->dev.ioc.buf_xp    = XPTR( local_cxy , buffer );
-    this->dev.ioc.lba       = lba;
-    this->dev.ioc.count     = count;
-
-    // register client thread in waiting queue, activate server thread,
+    // register client thread in IOC chdev waiting queue, activate server thread,
     // block client thread on THREAD_BLOCKED_IO and deschedule.
     // it is re-activated by the ISR signaling IO operation completion.
-    device_register_command( dev_xp , this );
+    chdev_register_command( dev_xp , this );
 
-    // access PIC to unlink the IOC IRQ
-    dev_pic_unbind_irq( irq_id );
-
-    // disable WTI IRQ in ICU and update interrupt vector
-    dev_icu_disable_irq( local_cxy , CURRENT_CORE->lid , WTI_TYPE , wti_id );
-
-    // release  WTI mailbox
-    dev_icu_wti_release( wti_id );
-
-    ioc_dmsg("\n[INFO] in %s : thread %x in process %x completes / error = %d\n", 
-             __FUNCTION__ , this->trdid , this->process->pid , this->dev.ioc.error );
+    ioc_dmsg("\n[INFO] in %s : thread %x in process %x"
+             " completes / error = %d / at cycle %d\n", 
+             __FUNCTION__ , this->trdid , this->process->pid ,
+             this->dev.ioc.error , hal_time_stamp() );
 
     // return I/O operation status
-    return this->dev.ioc.error;  
+    return this->command.ioc.error;  
 
 }  // end dev_ioc_access()
@@ -245 +183 @@
     return dev_ioc_access( false , buffer , lba , count ); 
 }
-                        
-/////////////////////////////////////
-void dev_ioc_server( device_t * dev )
-{
-    xptr_t     client_xp;    // extended pointer on waiting thread
-    cxy_t      client_cxy;   // cluster of client thread
-    thread_t * client_ptr;   // local pointer on client thread
-    thread_t * server;       // local pointer on server thread
-    xptr_t     root_xp;      // extended pointer on device waiting queue root
-
-    server    = CURRENT_THREAD;
-
-    root_xp   = XPTR( local_cxy , &dev->wait_root );
-
-        // infinite loop handling commands registered in the IOC waiting queue
-    // TODO If we want to implement an "elevator" mecanism (i.e. sort all
-    // pending command on the LBA to optimize physical device accesses),
-    // it should be done in this loop...
-
-    while( 1 )
-    {
-        // get lock protecting queue
-        remote_spinlock_lock( XPTR( local_cxy , &dev->wait_lock ) );
-
-        // block and deschedule server thread if waiting queue empty 
-        if( xlist_is_empty( root_xp ) )
-        {
-            thread_block( server , THREAD_BLOCKED_DEV_QUEUE );
-            remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-            sched_yield();
-        }
-        else
-        {
-            remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-        } 
-
-        // get extended pointer on first client thread
-        client_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
-
-        // call driver command function to start I/O operation
-        dev->cmd( client_xp );
-        
-        // get client thread cluster and local pointer
-        client_cxy = GET_CXY( client_xp );
-        client_ptr = (thread_t *)GET_PTR( client_xp );
-
-        // remove the client thread from waiting queue
-        remote_spinlock_lock( XPTR( local_cxy , &dev->wait_lock ) );
-        xlist_unlink( XPTR( client_cxy , &client_ptr->wait_list ) );
-        remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-
-    }  // end while
-
-}  // end dev_ioc_server()

trunk/kernel/devices/dev_ioc.h

@@ -25 +25 @@
 #define _DEV_IOC_H
 
+#include <almos_config.h>
 #include <hal_types.h>
 
 /****  Forward declarations  ****/
 
-struct device_s;
+struct chdev_s;
 
 /*****************************************************************************************
@@ -104 +105 @@
 
 /******************************************************************************************
- * This function completes the IOC device descriptor initialisation,
+ * This function completes the IOC chdev descriptor initialisation,
  * namely the link with the implementation specific driver.
- * The func, impl, channel, is_rxt, base, and size fields must be previously initialised.
+ * The func, impl, channel, is_rx, base fields have been previously initialised.
  * It calls the specific driver initialisation function, to initialise the hardware
  * device and the specific data structures when required.
- * It creates the associated server thread.
- * It can be executed in another cluster than the cluster containing the device descriptor
- * or the hardware device itself.
+ * It creates the associated server thread and allocates a WTI from local ICU.
+ * It must de executed by a local thread.
  ******************************************************************************************
- * @ xp_dev     : extended pointer on IOC device descriptor.
+ * @ chdev     : local pointer on IOC chdev descriptor.
  *****************************************************************************************/
-void dev_ioc_init( xptr_t  xp_dev );
+void dev_ioc_init( struct chdev_s * chdev );
 
 /******************************************************************************************
@@ -149 +149 @@
                        uint32_t       count );
 
-/******************************************************************************************
- * This function is executed by the server thread associated to the IOC device descriptor. 
- * This thread is created and activated by the dev_ioc_init() function.
- * It executes an infinite loop to handle sequencially all commands registered 
- * by the client threads in the device waiting queue, calling the driver CMD function. 
- *  
- * - If the peripheral can only handle one single command, the driver block the server 
- *   thread on the THREAD_BLOCKED_DEV_ISR condition, waiting I/O operation conmpletion.
- *   The server thread must be reacticated by the driver ISR function.
- * - If the peripheral can handle several commands in parallel (AHCI is an example), the
- *   driver does not block the server thread (it is only descheduled if the number of
- *   commands exceeeds the max number of parallel commands supported by the peripheral.
- *
- * When the waiting queue is empty, the server thread blocks on the THREAD_BLOCKED_CMD
- * condition and deschedule. It is re-activated by a client thread registering a command.
- ******************************************************************************************
- * @ dev     : local pointer on IOC device descriptor.
- *****************************************************************************************/
-void dev_ioc_server( struct device_s * dev );
-
 #endif  /* _DEV_IOC_H */

trunk/kernel/devices/dev_mmc.c

@@ -26 +26 @@
 #include <soclib_mmc.h>
 #include <printk.h>
+#include <chdev.h>
 #include <thread.h>
 #include <dev_mmc.h>
@@ -33 +34 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
-
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
-
-//////////////////////////////////
-void dev_mmc_init( xptr_t dev_xp )
-{
-    // get MMC device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
+
+extern chdev_icu_input_t  chdev_icu_input;   // allocated in kernel_init.c
+
+////////////////////////////////////
+void dev_mmc_init( chdev_t * chdev )
+{
     // get implementation from device descriptor
-    uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
-
-    // set driver specific fields in device descriptor
-    // and call driver init function
+    uint32_t  impl = chdev->impl;
+
+    // set driver specific fields in device descriptor and call driver init function
     if( impl == IMPL_MMC_TSR )
     {
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_mmc_command );
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_mmc_isr );
-        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-                           XPTR( local_cxy , "MMC_TSR" ) , 16 );
-        soclib_mmc_init( dev_xp );
+        chdev->cmd = &soclib_mmc_cmd;
+        chdev->isr = &soclib_mmc_isr;
+        soclib_mmc_init( chdev );
     }
     else
     {
-        printk("\n[PANIC] in %s: undefined MMC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "undefined MMC device implementation" );
     }
 }  // end dev_mmc_init()
@@ -72 +65 @@
 {
     mmc_dmsg("\n[INFO] %s enters for thread %x in process %x : command = %d\n", 
-                 __FUNCTION__ , this->trdid , this->process->pid , this->dev.mmc.type );
+                 __FUNCTION__ , this->trdid , this->process->pid , this->command.mmc.type );
 
     // get extended pointer on MMC device
-    xptr_t  dev_xp  = this->dev.mmc.dev_xp;
-
-    if ( dev_xp == XPTR_NULL )
-    {
-        printk("\n[PANIC] in %s : undefined MMC device descriptor "
-               "in cluster %x for thread %x in process %x\n",
-               __FUNCTION__ , local_cxy , this->trdid , this->process->pid );
-        hal_core_sleep();
-    }
+    xptr_t  dev_xp  = this->command.mmc.dev_xp;
+
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined MMC device descriptor" );
 
     // get MMC device cluster identifier & local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
     // get driver command function pointer from MMC device descriptor
@@ -116 +103 @@
     cxy_t cxy = CXY_FROM_PADDR( buf_paddr );
 
-    if ( buf_paddr & (CONFIG_CACHE_LINE_SIZE -1) )
-    {
-        printk("\n[PANIC] in %s : buffer not aligned on cache line "
-               "for thread %x / target cluster %x\n",
-               __FUNCTION__ , this->trdid , cxy );
-        hal_core_sleep();
-    }
+    assert( ((buf_paddr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
+             "buffer not aligned on cache line" );
 
     // get extended pointer on MMC device descriptor
-    xptr_t  dev_xp = devices_dir.mmc[cxy];
-
-    // store command arguments in thread descriptor
-    this->dev.mmc.dev_xp    = dev_xp;
-    this->dev.mmc.type      = MMC_CC_INVAL;
-    this->dev.mmc.buf_paddr = buf_paddr;
-    this->dev.mmc.buf_size  = buf_size;
-
-    // execute operation
-    dev_mmc_access( this ); 
-
-    // return operation status
-    return this->dev.mmc.error;  
+    xptr_t  dev_xp = chdev_dir.mmc[cxy];
+
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = dev_xp;
+    this->command.mmc.type      = MMC_CC_INVAL;
+    this->command.mmc.buf_paddr = buf_paddr;
+    this->command.mmc.buf_size  = buf_size;
+
+    // execute operation
+    dev_mmc_access( this ); 
+
+    // return operation status
+    return this->command.mmc.error;  
 }  
 
@@ -150 +132 @@
     cxy_t cxy = CXY_FROM_PADDR( buf_paddr );
 
-    if ( buf_paddr & (CONFIG_CACHE_LINE_SIZE -1) )
-    {
-        printk("\n[PANIC] in %s : buffer not aligned on cache line "
-               "for thread %x / target cluster %x\n",
-               __FUNCTION__ , this->trdid , cxy );
-        hal_core_sleep();
-    }
-
-    // store command arguments in thread descriptor
-    this->dev.mmc.dev_xp    = devices_dir.mmc[cxy];
-    this->dev.mmc.type      = MMC_CC_SYNC;
-    this->dev.mmc.buf_paddr = buf_paddr;
-    this->dev.mmc.buf_size  = buf_size;
-
-    // execute operation
-    dev_mmc_access( this ); 
-
-    // return operation status
-    return this->dev.mmc.error;  
+    assert( ((buf_paddr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
+             "buffer not aligned on cache line" );
+
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = chdev_dir.mmc[cxy];
+    this->command.mmc.type      = MMC_CC_SYNC;
+    this->command.mmc.buf_paddr = buf_paddr;
+    this->command.mmc.buf_size  = buf_size;
+
+    // execute operation
+    dev_mmc_access( this ); 
+
+    // return operation status
+    return this->command.mmc.error;  
 }  
 
@@ -180 +157 @@
 
     // store command arguments in thread descriptor
-    this->dev.mmc.dev_xp    = devices_dir.mmc[cxy];
-    this->dev.mmc.type      = MMC_SET_ERROR;
-    this->dev.mmc.reg_index = index;
-    this->dev.mmc.reg_ptr   = &wdata;
-
-    // execute operation
-    dev_mmc_access( this ); 
-
-    // return operation status
-    return this->dev.mmc.error;  
+    this->command.mmc.dev_xp    = chdev_dir.mmc[cxy];
+    this->command.mmc.type      = MMC_SET_ERROR;
+    this->command.mmc.reg_index = index;
+    this->command.mmc.reg_ptr   = &wdata;
+
+    // execute operation
+    dev_mmc_access( this ); 
+
+    // return operation status
+    return this->command.mmc.error;  
 }
                         
@@ -201 +178 @@
 
     // store command arguments in thread descriptor
-    this->dev.mmc.dev_xp    = devices_dir.mmc[cxy];
-    this->dev.mmc.type      = MMC_GET_ERROR;
-    this->dev.mmc.reg_index = index;
-    this->dev.mmc.reg_ptr   = rdata;
-
-    // execute operation
-    dev_mmc_access( this ); 
-
-    // return operation status
-    return this->dev.mmc.error;  
+    this->command.mmc.dev_xp    = chdev_dir.mmc[cxy];
+    this->command.mmc.type      = MMC_GET_ERROR;
+    this->command.mmc.reg_index = index;
+    this->command.mmc.reg_ptr   = rdata;
+
+    // execute operation
+    dev_mmc_access( this ); 
+
+    // return operation status
+    return this->command.mmc.error;  
 }
                         
@@ -222 +199 @@
 
     // store command arguments in thread descriptor
-    this->dev.mmc.dev_xp    = devices_dir.mmc[cxy];
-    this->dev.mmc.type      = MMC_GET_INSTRU;
-    this->dev.mmc.reg_index = index;
-    this->dev.mmc.reg_ptr   = rdata;
-
-    // execute operation
-    dev_mmc_access( this ); 
-
-    // return operation status
-    return this->dev.mmc.error;  
+    this->command.mmc.dev_xp    = chdev_dir.mmc[cxy];
+    this->command.mmc.type      = MMC_GET_INSTRU;
+    this->command.mmc.reg_index = index;
+    this->command.mmc.reg_ptr   = rdata;
+
+    // execute operation
+    dev_mmc_access( this ); 
+
+    // return operation status
+    return this->command.mmc.error;  
 }
 

trunk/kernel/devices/dev_mmc.h

@@ -46 +46 @@
  * As these operations consume few cycles, and access conflicts are expected to be 
  * rare events, the calling threads use a busy waiting strategy to get the device
- * spinlock, do not register in the device waiting queue, and no server thread
+ * spinlock, but do not register in the device waiting queue, and no server thread
  * is used for this device.
  ****************************************************************************************/
  
+/****  Forward declarations  ****/
+
+struct chdev_s;
+
 /******************************************************************************************
  * This enum defines the various implementations of the generic MMC peripheral.
@@ -92 +96 @@
  * It must be executed once in any cluster containing an L2 cache.
  *****************************************************************************************
- * @ mmc_xp     : extended pointer on MMC device descriptor.
+ * @ chdev      : pointer on MMC device descriptor.
  ****************************************************************************************/
-void dev_mmc_init( xptr_t  mmc_xp );
+void dev_mmc_init( struct chdev_s * chdev );
 
 /*****************************************************************************************

trunk/kernel/devices/dev_nic.c

@@ -25 +25 @@
 #include <hal_special.h>
 #include <printk.h>
-#include <device.h>
+#include <chdev.h>
 #include <thread.h>
 #include <soclib_nic.h>
@@ -34 +34 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
-
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
-
-
-//////////////////////////////////
-void dev_nic_init( xptr_t dev_xp )
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
+
+extern chdev_pic_input_t  chdev_pic_input;   // allocated in kernel_init.c
+
+////////////////////////////////////
+void dev_nic_init( chdev_t * chdev )
 {
-    // get device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
-    // get "impl" , "channel" , "is_rx" fields from device descriptor
-    uint32_t  impl    = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
-    uint32_t  is_rx   = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->is_rx ) );
-    uint32_t  channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) );
-
-    // set driver specific fields in device descriptor
-    // and call driver init function
+    // the local ICU chdev must be initialized before the NIC chdev, because
+    // the NIC chdevs initialisation requires allocation of a WTI from local ICU
+    xptr_t  icu_xp  = chdev_dir.icu[local_cxy];
+    assert( (icu_xp != XPTR_NULL) , __FUNCTION__ , "ICU not initialised before NIC" );
+
+    // get "impl" , "channel" , "is_rx" fields from chdev descriptor
+    uint32_t  impl    = chdev->impl;
+    uint32_t  is_rx   = chdev->is_rx;
+    uint32_t  channel = chdev->channel;
+
+    // set driver specific fields in chdev descriptor and call driver init function
     if( impl == IMPL_NIC_SOC )
     {
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_nic_cmd );
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_nic_isr );
-        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-                           XPTR( local_cxy , "NIC_SOC" ) , 16 );
-        soclib_nic_init( dev_xp );
-    }
-//    else if( impl == IMPL_NIC_I86)
-//    {
-//        hal_remote_spt( XPTR( cxy , &ptr->cmd ) , &i86_nic_cmd );
-//        hal_remote_spt( XPTR( cxy , &ptr->isr ) , &i86_nic_isr );
-//        hal_remote_memcpy( XPTR( cxy , &ptr->name ),
-//                           XPTR( local_cxy , "NIC_I86" ) , 16 );
-//        i86_nic_init( dev );
-//    }
+        chdev->cmd = &soclib_nic_cmd;
+        chdev->isr = &soclib_nic_isr;
+        soclib_nic_init( chdev );
+    }
     else
     {
-        printk("\n[PANIC] in %s : undefined NIC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // get a free WTI mailbox for this NIC device
-    uint32_t wti_id;
-    if( dev_cxy == local_cxy )                       // NIC device cluster is local
-    {
-        wti_id = dev_icu_wti_alloc();
-    }
-    else                                             // NIC device cluster is remote
-    {
-        rpc_icu_wti_alloc_client( dev_cxy , &wti_id ); 
-    }
-
-    if( wti_id == -1 )
-    {
-        printk("\n[PANIC] in %s : cannot allocate WTI mailbox\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // enable WTI IRQ in remote ICU and update WTI interrupt vector
-    dev_icu_enable_irq( dev_cxy, 0 , WTI_TYPE , wti_id , dev_xp );
+        assert( false , __FUNCTION__ , "undefined NIC device implementation" );
+    }
+
+    // get a WTI mailbox from local ICU
+    uint32_t wti_id = dev_icu_wti_alloc();
+
+    assert( (wti_id != -1) , __FUNCTION__ , "cannot allocate WTI mailbox" );
+
+    // select a core
+    lid_t lid = cluster_select_local_core();
+
+    // enable WTI IRQ and update WTI interrupt vector
+    dev_icu_enable_irq( lid , WTI_TYPE , wti_id , chdev );
 
     // link NIC IRQ to WTI mailbox in PIC component 
     uint32_t irq_id; 
-    if( is_rx ) irq_id = devices_input_irq.nic_rx[channel];
-    else        irq_id = devices_input_irq.nic_tx[channel];
+    if( is_rx ) irq_id = chdev_pic_input.nic_rx[channel];
+    else        irq_id = chdev_pic_input.nic_tx[channel];
     dev_pic_bind_irq( irq_id , local_cxy , wti_id );
 
     // create server thread
-    thread_t * new_thread_ptr;
-    xptr_t     new_thread_xp;
+    thread_t * new_thread;
     error_t    error;
 
-    if( dev_cxy == local_cxy )                        // device cluster is local
-    {
-        error = thread_kernel_create( &new_thread_ptr,
-                                      THREAD_DEV,
-                                      &dev_ioc_server,
-                                      dev_ptr,
-                                      cluster_select_local_core() ); 
-
-        new_thread_xp = XPTR( local_cxy , new_thread_ptr );
-    }
-    else                                              // device cluster is remote
-    {
-        rpc_thread_kernel_create_client( dev_cxy,
-                                         THREAD_DEV,
-                                         &dev_ioc_server,
-                                         dev_ptr,
-                                         &new_thread_xp,
-                                         &error );
-
-        new_thread_ptr = (thread_t *)GET_PTR( new_thread_xp );
-    }
-    if( error )
-    {
-        printk("\n[PANIC] in %s : cannot create server thread\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // set "server" field in device descriptor
-    hal_remote_spt( XPTR( dev_cxy , &dev_ptr->server ) , new_thread_ptr );
+    error = thread_kernel_create( &new_thread,
+                                  THREAD_DEV,
+                                  &chdev_sequencial_server,
+                                  chdev,
+                                  lid ); 
+
+    assert( (error == 0) , __FUNCTION__ , "cannot create server thread" );
+
+    // set "server" field in chdev descriptor
+    chdev->server = new_thread;
     
     // start server thread
-    thread_unblock( new_thread_xp , THREAD_BLOCKED_GLOBAL );
+    thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
 
 }  // end dev_nic_init()
@@ -156 +115 @@
                  __FUNCTION__ , core->lid , local_cxy );
 
-    // get pointer on NIC-RX device descriptor
+    // get pointer on NIC-RX chdev descriptor
     uint32_t   channel = thread_ptr->dev_channel; 
-    xptr_t     dev_xp  = devices_dir.nic_rx[channel];
+    xptr_t     dev_xp  = chdev_dir.nic_rx[channel];
     cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
-    if ( dev_xp == XPTR_NULL )
-    {
-        printk("\n[PANIC] in %s : undefined NIC device descriptor\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    if ( dev_cxy != local_cxy )
-    {
-        printk("\n[PANIC] in %s : device descriptor must be local\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
+    chdev_t  * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined NIC chdev descriptor" );
+
+    assert( (dev_cxy == local_cxy) , __FUNCTION__ , " chdev must be local" );
 
     // initialize command in thread descriptor
-    thread_ptr->dev.nic.dev_xp = dev_xp;
+    thread_ptr->command.nic.dev_xp = dev_xp;
 
     // call driver to test readable
-    thread_ptr->dev.nic.cmd = NIC_CMD_READABLE;
-    dev_ptr->cmd( thread_xp );
-
-    // check error
-    error = thread_ptr->dev.nic.error;
+    thread_ptr->command.nic.cmd = NIC_CMD_READABLE;
+    dev_ptr->cmd( thread_xp );
+
+    // check error
+    error = thread_ptr->command.nic.error;
     if( error ) return error;
 
     // block and deschedule if queue non readable
-    if( thread_ptr->dev.nic.status == false )  
+    if( thread_ptr->command.nic.status == false )  
     {
         // get NIC-RX IRQ index and type
@@ -193 +144 @@
 
         // enable NIC-RX IRQ 
-        dev_icu_enable_irq( local_cxy , core->lid , irq_type , irq_id , dev_xp );
+        dev_icu_enable_irq( core->lid , irq_type , irq_id , dev_ptr );
 
         // block on THREAD_BLOCKED I/O condition and deschedule
@@ -200 +151 @@
 
         // disable NIC-RX channel IRQ 
-        dev_icu_disable_irq( local_cxy , core->lid , irq_type , irq_id );
+        dev_icu_disable_irq( core->lid , irq_type , irq_id );
     }
 
     // call driver for actual read 
-    thread_ptr->dev.nic.cmd     = NIC_CMD_READ;
-    thread_ptr->dev.nic.buffer  = pkd->buffer;
-    dev_ptr->cmd( thread_xp );
-
-    // check error
-    error = thread_ptr->dev.nic.error;
+    thread_ptr->command.nic.cmd     = NIC_CMD_READ;
+    thread_ptr->command.nic.buffer  = pkd->buffer;
+    dev_ptr->cmd( thread_xp );
+
+    // check error
+    error = thread_ptr->command.nic.error;
     if( error ) return error;
 
     // returns packet length   
-    pkd->length = thread_ptr->dev.nic.length;
+    pkd->length = thread_ptr->command.nic.length;
 
     nic_dmsg("\n[INFO] %s exit for NIC-RX thread on core %d in cluster %x\n", 
@@ -238 +189 @@
                  __FUNCTION__ , core->lid , local_cxy );
 
-    // get pointer on NIC-TX device descriptor
+    // get pointer on NIC-TX chdev descriptor
     uint32_t   channel = thread_ptr->dev_channel; 
-    xptr_t     dev_xp  = devices_dir.nic_tx[channel];
+    xptr_t     dev_xp  = chdev_dir.nic_tx[channel];
     cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
-
-    if ( dev_xp == XPTR_NULL )
-    {
-        printk("\n[PANIC] in %s : undefined NIC device descriptor\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    if ( dev_cxy != local_cxy )
-    {
-        printk("\n[PANIC] in %s : device descriptor must be local\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
+    chdev_t  * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+
+    assert ( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined NIC chdev descriptor" );
+
+    assert( (dev_cxy == local_cxy) , __FUNCTION__ , " chdev must be local" );
 
     // initialize command in thread descriptor
-    thread_ptr->dev.nic.dev_xp = dev_xp;
+    thread_ptr->command.nic.dev_xp = dev_xp;
 
     // call driver to test writable
-    thread_ptr->dev.nic.cmd    = NIC_CMD_WRITABLE;
-    dev_ptr->cmd( thread_xp );
-
-    // check error
-    error = thread_ptr->dev.nic.error;
+    thread_ptr->command.nic.cmd    = NIC_CMD_WRITABLE;
+    dev_ptr->cmd( thread_xp );
+
+    // check error
+    error = thread_ptr->command.nic.error;
     if( error ) return error;
 
     // block and deschedule if queue non writable
-    if( thread_ptr->dev.nic.status == false )  
+    if( thread_ptr->command.nic.status == false )  
     {
         // get NIC-TX IRQ index and type
@@ -275 +218 @@
 
         // enable NIC-TX IRQ 
-        dev_icu_enable_irq( local_cxy , core->lid , irq_type , irq_id , dev_xp );
+        dev_icu_enable_irq( core->lid , irq_type , irq_id , dev_ptr );
 
         // block on THREAD_BLOCKED I/O condition and deschedule
@@ -282 +225 @@
 
         // disable NIC-TX IRQ 
-        dev_icu_disable_irq( local_cxy , core->lid , irq_type , irq_id );
+        dev_icu_disable_irq( core->lid , irq_type , irq_id );
     }
 
     // call driver for actual write
-    thread_ptr->dev.nic.cmd    = NIC_CMD_WRITE;
-    thread_ptr->dev.nic.buffer = pkd->buffer;
-    thread_ptr->dev.nic.length = pkd->length;
-    dev_ptr->cmd( thread_xp );
-
-    // check error
-    error = thread_ptr->dev.nic.error;
+    thread_ptr->command.nic.cmd    = NIC_CMD_WRITE;
+    thread_ptr->command.nic.buffer = pkd->buffer;
+    thread_ptr->command.nic.length = pkd->length;
+    dev_ptr->cmd( thread_xp );
+
+    // check error
+    error = thread_ptr->command.nic.error;
     if( error ) return error;
 

trunk/kernel/devices/dev_nic.h

@@ -75 +75 @@
 /****  Forward declarations  ****/
 
-struct device_s;
+struct chdev_s;
 
 /******************************************************************************************
@@ -137 +137 @@
 
 /******************************************************************************************
- * This function completes the NIC-RX and NIC-TX devices descriptors initialisation.
- * The func, impl, channel, is_rx, base, and size have been previously initialised.
- * It calls the driver initialisation function.
- ******************************************************************************************
- * @ dev_xp     : extended pointer on NIC-RX or NIC-TX device descriptor.
- *****************************************************************************************/
-void dev_nic_init( xptr_t  dev_xp );
+ * This function completes the NIC-RX and NIC-TX chdev descriptors initialisation.
+ * namely the link with the implementation specific driver.
+ * The func, impl, channel, is_rx, base fields have been previously initialised.
+ * It calls the specific driver initialisation function, to initialise the hardware
+ * device and the specific data structures when required.
+ * It creates the associated server thread and allocates a WTI from local ICU.
+ * It must de executed by a local thread.
+ ******************************************************************************************
+ * @ chdev    : local pointer on NIC chdev descriptor.
+ *****************************************************************************************/
+void dev_nic_init( struct chdev_s * chdev );
 
 /******************************************************************************************
@@ -219 +223 @@
  * becomes non empty. 
  ******************************************************************************************
- * @ dev     : local pointer on NIC channel device descriptor.
- *****************************************************************************************/
-void dev_nic_server( struct device_s * dev );
+ * @ dev     : local pointer on NIC chdev descriptor.
+ *****************************************************************************************/
+void dev_nic_server( struct chdev_s * chdev );
 
 

trunk/kernel/devices/dev_pic.c

@@ -25 +25 @@
 #include <hal_special.h>
 #include <dev_icu.h>
-#include <device.h>
+#include <chdev.h>
 #include <memcpy.h>
 #include <printk.h>
@@ -35 +35 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
 
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
-
-
+extern chdev_pic_input_t  chdev_pic_input;   // allocated in kernel_init.c
 
 ///////////////////////////////////
-void dev_pic_init( xptr_t   dev_xp,
-                   uint32_t irq_nr )
+void dev_pic_init( chdev_t * chdev,
+                   uint32_t  irq_nr )
 {
-    // get PIC device cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // set PIC chdev extension field
+    chdev->ext.pic.irq_nr = irq_nr;
 
-    // set PIC device extension field
-    dev_ptr->ext.pic.irq_nr = irq_nr;
+    // get implementation 
+    uint32_t impl = chdev->impl;
 
-    // get implementation index from PIC device descriptor
-    uint32_t impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
-
-    // set the "name" field in PIC device descriptor
-    // and call the relevant driver init function
+    // call the relevant driver init function
     if( impl == IMPL_PIC_SOC )
     {
-        memcpy( dev_ptr->name , "PIC_TSR" , 16 );
-        soclib_pic_init( dev_xp );
+        soclib_pic_init( chdev );
     }
     else
     {
-        printk("PANIC in %s: illegal PIC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "illegal PIC device implementation" );
     }
 } // end dev_pic_init()
@@ -75 +66 @@
 {
     // get extended pointer on WTI mailbox
-    xptr_t wti_xp = dev_icu_wti_xptr( cxy , wti_id );
+    xptr_t wti_xp = XPTR( cxy , dev_icu_wti_ptr( wti_id ) );
 
-    // get extended pointer on PIC device from directory
-    xptr_t dev_xp = devices_dir.pic;
+    // get extended pointer on PIC chdev from directory
+    xptr_t dev_xp = chdev_dir.pic;
 
-    // get PIC device cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get PIC chdev cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
     // get implementation index and segment base 
@@ -92 +83 @@
         soclib_pic_bind_irq( dev_xp , irq_id , wti_xp );
     }
-    else
-    {
-        printk("PANIC in %s: illegal PIC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
 }  // end dev_pic_link_wti()
 
@@ -102 +88 @@
 void dev_pic_unbind_irq( uint32_t irq_id )
 {
-    // get extended pointer on PIC device from directory
-    xptr_t dev_xp = devices_dir.pic;
+    // get extended pointer on PIC chdev from directory
+    xptr_t dev_xp = chdev_dir.pic;
 
-    // get PIC device cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // get PIC chdev cluster and local pointer
+    cxy_t     dev_cxy = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
 
     // get implementation index 
@@ -117 +103 @@
         soclib_pic_unbind_irq( dev_xp , irq_id );
     }
-    else
-    {
-        printk("PANIC in %s: illegal PIC device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-   
 } // end dev_pic_disable_irq()
 

trunk/kernel/devices/dev_pic.h

@@ -39 +39 @@
  * in the PIC device extension.  
  * The "source" device for each input IRQ is also defined in the ''arch_info'' file,
- * and are stored in the ''devices_input_irq'' global variable in kernel initialization.
+ * and are stored in the ''chdev_input_irq'' global variable in kernel initialization.
  *
  * This external peripheral does not execute I/O operations, but is just acting as a 
@@ -48 +48 @@
  ****************************************************************************************/
  
+/****  Forward declarations  ****/
+
+struct chdev_s;
+
 /*****************************************************************************************
- * This defines the (implementation independant) extension for the generic ICU device.
+ * This defines the (implementation independant) extension for the PIC device.
  ****************************************************************************************/
 
@@ -72 +76 @@
 /*****************************************************************************************
  * This function makes two initialisations:
- * - It initializes the PIC specific fields of the device descriptor.
+ * - It initializes the PIC specific fields of the chdev descriptor.
  * - it initializes the implementation specific PIC hardware device.
  * It must be executed once in the kernel initialisation phase.
@@ -79 +83 @@
  * @ uint32_t   : actual number of input IRQs.
  ****************************************************************************************/
-void dev_pic_init( xptr_t   xp_dev,
-                   uint32_t irq_nr );
+void dev_pic_init( struct chdev_s * chdev,
+                   uint32_t         irq_nr );
 
 /*****************************************************************************************

trunk/kernel/devices/dev_txt.c

@@ -35 +35 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-extern devices_directory_t  devices_dir;         // allocated in kernel_init.c
+extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
 
-extern devices_input_irq_t  devices_input_irq;   // allocated in kernel_init.c
+extern chdev_pic_input_t  chdev_pic_input;   // allocated in kernel_init.c
 
-//////////////////////////////////
-void dev_txt_init( xptr_t  dev_xp )
+////////////////////////////////////
+void dev_txt_init( chdev_t * chdev )
 {
-    // get device descriptor cluster and local pointer
-    cxy_t      dev_cxy = GET_CXY( dev_xp );
-    device_t * dev_ptr = (device_t *)GET_PTR( dev_xp );
+    // the local ICU chdev must be initialized before the TXT chdev, because
+    // the TXT chdev initialisation requires allocation of a WTI from local ICU
+    xptr_t  icu_xp  = chdev_dir.icu[local_cxy];
+    assert( (icu_xp != XPTR_NULL) , __FUNCTION__ , "ICU not initialised before TXT" );
 
-    // get implementation index from device descriptor
-    uint32_t  impl = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->impl ) );
+    // get implementation and channel index
+    uint32_t  impl    = chdev->impl;
+    uint32_t  channel = chdev->channel;
 
-    // get channel index from device descriptor
-    // uint32_t  channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) );
-
-    // set fields "cmd", "isr", and "name" in device descriptor
-    // and call implementation specific init function
-
-    // TODO replace fixed "TXT_TTY" name by a channel indexed "TXT_TTY%d" name
-    // as soon as the sprintk() function is available
-
+    // set fields "cmd", "isr", and call driver init function
     if( impl == IMPL_TXT_TTY )
     {
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->cmd ) , &soclib_tty_command );
-        hal_remote_spt( XPTR( dev_cxy , &dev_ptr->isr ) , &soclib_tty_isr );
-        // sprintk( name , "TXT_TTY%d" , channel )
-        hal_remote_memcpy( XPTR( dev_cxy , &dev_ptr->name ),
-                           XPTR( local_cxy , "TXT_TTY" ) , 16 );
-        soclib_tty_init( dev_xp );
+        chdev->cmd = &soclib_tty_cmd;
+        chdev->isr = &soclib_tty_isr;
+        soclib_tty_init( chdev );
     }
     else
     {
-        printk("\n[PANIC] in %s: undefined TXT device implementation\n", __FUNCTION__ );
-        hal_core_sleep();
+        assert( false , __FUNCTION__ , "undefined TXT device implementation" );
     }
 
+    // get a WTI mailbox from local ICU
+    uint32_t wti_id = dev_icu_wti_alloc();
+
+    assert( (wti_id != -1) , __FUNCTION__ , "cannot allocate WTI mailbox" );
+
+    // select a core
+    lid_t lid = cluster_select_local_core();
+
+    // enable WTI IRQ and update WTI interrupt vector
+    dev_icu_enable_irq( lid , WTI_TYPE , wti_id , chdev );
+
+    // link IOC IRQ to WTI mailbox in PIC component 
+    uint32_t irq_id = chdev_pic_input.txt[channel];
+    dev_pic_bind_irq( irq_id , local_cxy , wti_id );
+
     // create server thread
-    xptr_t     new_thread_xp;
-    thread_t * new_thread_ptr;
+    thread_t * new_thread;
     error_t    error;
 
-    if( dev_cxy == local_cxy )         // device cluster is local
-    {
-        error = thread_kernel_create( &new_thread_ptr,
-                                      THREAD_DEV,
-                                      &dev_txt_server,
-                                      dev_ptr,
-                                      cluster_select_local_core() );
- 
-        new_thread_xp = XPTR( local_cxy , new_thread_ptr );
-    }
-    else                                        // device cluster is remote
-    {
-        rpc_thread_kernel_create_client( dev_cxy,
-                                         THREAD_DEV,
-                                         &dev_txt_server,
-                                         dev_ptr,
-                                         &new_thread_xp,
-                                         &error );
+    error = thread_kernel_create( &new_thread,
+                                  THREAD_DEV,
+                                  &chdev_sequencial_server,
+                                  chdev,
+                                  lid ); 
+    assert( (error == 0) , __FUNCTION__ , "cannot create server thread" );
 
-        new_thread_ptr = (thread_t *)GET_PTR( new_thread_xp );
-    }
-    if( error )
-    {
-        printk("\n[PANIC] in %s : cannot create server thread\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // initialises server field in device descriptor
-    hal_remote_spt( XPTR( dev_cxy , &dev_ptr->server ) , new_thread_ptr );
+    // set "server" field in chdev descriptor
+    chdev->server = new_thread;
     
     // start server thread
-    thread_unblock( new_thread_xp , THREAD_BLOCKED_GLOBAL );
+    thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
 
 } // end dev_txt_init()
@@ -115 +99 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-// This static function is called by dev_txt_read(), dev_txt_write(), and
-// dev_txt_sync_write() functions. 
-// For the TXT_READ and TXT_WRITE operation types:
-//  - it build the command, and registers it in the calling thread descriptor. 
-//  - then, it registers the calling thead in device waiting queue.
-//  - finally, it blocks on the THREAD_BLOCKED_DEV condition and deschedule.
-// For the TXT_SYNC_WRITE operation type:
-//  - it directly call the relevant driver, using a busy waiting policy.
+// This static function is called by dev_txt_read(), dev_txt_write() functions.
 ////////////////////////////////////i/////////////////////////////////////////////
 static error_t dev_txt_access( uint32_t   type,
@@ -135 +112 @@
 
     // check channel argument
-    if( channel >= CONFIG_MAX_TXT_CHANNELS )
-    {
-        printk("\n[PANIC] in %s : illegal channel index = %d\n", __FUNCTION__ , channel );
-        hal_core_sleep();
-    }
+    assert( (channel < CONFIG_MAX_TXT_CHANNELS) , __FUNCTION__ , "illegal channel index" );
 
-    // get extended pointer on remote TXT device descriptor
-    xptr_t  dev_xp = devices_dir.txt[channel];
+    // get extended pointer on remote TXT chdev descriptor
+    xptr_t  dev_xp = chdev_dir.txt[channel];
 
-    if ( dev_xp == XPTR_NULL )
-    {
-        printk("\n[PANIC] in %s : undefined TXT device descriptor for channel %d\n",
-               __FUNCTION__ , channel );
-        hal_core_sleep();
-    }
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined TXT chdev descriptor" );
 
     // register command in calling thread descriptor
-    this->dev.txt.dev_xp  = dev_xp;
-    this->dev.txt.type    = type;
-    this->dev.txt.buf_xp  = XPTR( local_cxy , buffer );
-    this->dev.txt.count   = count;
+    this->command.txt.dev_xp  = dev_xp;
+    this->command.txt.type    = type;
+    this->command.txt.buf_xp  = XPTR( local_cxy , buffer );
+    this->command.txt.count   = count;
 
+    // register client thread in waiting queue, activate server thread
+    // block client thread on THREAD_BLOCKED_IO and deschedule.
+    // it is re-activated by the ISR signaling IO operation completion.
+    chdev_register_command( dev_xp , this );
 
-    if( (type == TXT_READ) || (type == TXT_WRITE) )  // descheduling policy
-    {
-        // get a free WTI mailbox  
-        uint32_t wti_id;
-        while( 1 )
-        {
-            wti_id = dev_icu_wti_alloc();
-            if( wti_id == -1 )  sched_yield();
-            else                break;
-        }
-
-        // enable WTI IRQ in local ICU and update WTI interrupt vector
-        dev_icu_enable_irq( local_cxy , CURRENT_CORE->lid , WTI_TYPE , wti_id , dev_xp );
-
-        // link TXT IRQ to WTI mailbox in PIC component 
-        uint32_t irq_id = devices_input_irq.txt[channel];
-        dev_pic_bind_irq( irq_id , local_cxy , wti_id );
-
-        // register client thread in waiting queue, activate server thread
-        // block client thread on THREAD_BLOCKED_IO and deschedule.
-        // it is re-activated by the ISR signaling IO operation completion.
-        device_register_command( dev_xp , this );
-
-        // access PIC to unlink the IOC IRQ
-        dev_pic_unbind_irq( irq_id );
-
-        // disable WTI IRQ in ICU and update interrupt vector
-        dev_icu_disable_irq( local_cxy , CURRENT_CORE->lid , WTI_TYPE , wti_id );
-
-        // release  WTI mailbox
-        dev_icu_wti_release( wti_id );
-
-        txt_dmsg("\n[INFO] in %s : thread %x in process %x completes / error = %d\n", 
-                     __FUNCTION__ , this->trdid , this->process->pid , this->dev.txt.error );
-    }
-    else if( type == TXT_SYNC_WRITE )            // busy waiting policy
-    {
-        // get driver command function pointer from remote TXT device descriptor
-        cxy_t       dev_cxy = GET_CXY( dev_xp );
-        device_t  * dev_ptr = (device_t *)GET_PTR( dev_xp );
-        dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->cmd ) );
-
-        // take the TXT device lock, because the calling thread does NOT
-        // register in device waiting queue for this synchronous command,
-        // and has exclusive access to the terminal...
-        remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
- 
-        // call directly driver command 
-        cmd( XPTR( local_cxy , this ) );
-
-        // release the TXT device lock
-        remote_spinlock_unlock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
-    }    
+    txt_dmsg("\n[INFO] in %s : thread %x in process %x completes / error = %d\n", 
+             __FUNCTION__ , this->trdid , this->process->pid , this->command.txt.error );
 
     // return I/O operation status from calling thread descriptor
-    return this->dev.txt.error;  
+    return this->command.txt.error;  
 
 }  // end dev_txt_access()
@@ -225 +146 @@
 }
  
-///////////////////////////////////////////////
-error_t dev_txt_sync_write( uint32_t   channel,
-                            char     * buffer,
-                            uint32_t   count )
-{
-    return dev_txt_access( TXT_SYNC_WRITE , channel , buffer , count );
-}
- 
 /////////////////////////////////////////
 error_t dev_txt_read( uint32_t   channel,
@@ -240 +153 @@
 }
 
-/////////////////////////////////////
-void dev_txt_server( device_t * dev )
+///////////////////////////////////////////////
+error_t dev_txt_sync_write( uint32_t   channel,
+                            char     * buffer,
+                            uint32_t   count )
 {
-    xptr_t          client_xp;    // extended pointer on waiting thread
-    cxy_t           client_cxy;   // cluster of client thread
-    thread_t      * client_ptr;   // local pointer on client thread
-    thread_t      * server;       // local pointer on server thread
-    xptr_t          root_xp;      // extended pointer on device waiting queue root
+    // get pointer on calling thread 
+    thread_t * this = CURRENT_THREAD;
 
-    server = CURRENT_THREAD;
+    // get extended pointer on TXT[0] chdev 
+    xptr_t  dev_xp = chdev_dir.txt[channel];
 
-    root_xp = XPTR( local_cxy , &dev->wait_root );
+    // register command in calling thread 
+    this->command.txt.dev_xp  = dev_xp;
+    this->command.txt.type    = TXT_SYNC_WRITE;
+    this->command.txt.buf_xp  = XPTR( local_cxy , buffer );
+    this->command.txt.count   = count;
 
-        // infinite loop handling commands of threads 
-    // registered in the TXT waiting queue
-    while( 1 )
-    {
-        // get lock protecting queue
-        remote_spinlock_lock( XPTR( local_cxy , &dev->wait_lock ) );
+    // get driver command function 
+    cxy_t       dev_cxy = GET_CXY( dev_xp );
+    chdev_t   * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+    dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->cmd ) );
 
-        // block and deschedule server thread if waiting queue empty 
-        if( xlist_is_empty( root_xp ) )
-        {
-            thread_block( server , THREAD_BLOCKED_DEV_QUEUE );
-            remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-            sched_yield();
-        }
-        else
-        {
-            remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-        } 
+    // call directly driver command after taking chdev lock
+    remote_spinlock_lock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
+    cmd( XPTR( local_cxy , this ) );
+    remote_spinlock_unlock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
 
-        // get extended pointer on first client thread
-        client_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
+    // return I/O operation status from calling thread descriptor
+    return this->command.txt.error;
+  
+}  // end dev_txt_sync_write()
 
-        // call driver command function to start I/O operation
-        dev->cmd( client_xp );
-        
-        // get client thread cluster and local pointer
-        client_cxy = GET_CXY( client_xp );
-        client_ptr = (thread_t *)GET_PTR( client_xp );
-
-        // remove the client thread from waiting queue
-        remote_spinlock_lock( XPTR( local_cxy , &dev->wait_lock ) );
-        xlist_unlink( XPTR( client_cxy , &client_ptr->wait_list ) );
-        remote_spinlock_unlock( XPTR( local_cxy , &dev->wait_lock ) );
-
-    }  // end while
-
-}  // end dev_txt_server()
-

trunk/kernel/devices/dev_txt.h

@@ -30 +30 @@
 /****  Forward declarations  ****/
 
-struct device_s ;
+struct chdev_s ;
 
 /******************************************************************************************
@@ -79 +79 @@
 
 /******************************************************************************************
- * This function completes the TXT device descriptor initialisation,
+ * This function completes the TXT chdev descriptor initialisation,
  * namely the link with the implementation specific driver.
- * The func, impl, channel, is_rxt, base, and size fields must be previously initialised.
+ * The func, impl, channel, is_rxt, base fields have been previously initialised.
  * It calls the specific driver initialisation function, to initialise the hardware
  * device and the driver specific data structures when required.
- * It creates the associated server thread.
- * It can be executed in another cluster than cluster containing the device descriptor
- * or the hardware device itself.
+ * It creates the associated server thread and allocates a WTI from local ICU.
+ * It must de executed by a local thread.
  ******************************************************************************************
- * @ xp_dev     : extended pointer on TXT device descriptor.
+ * @ chdev     : local pointer on TXT device descriptor.
  *****************************************************************************************/
-void dev_txt_init( xptr_t xp_dev );
+void dev_txt_init( struct chdev_s * chdev );
 
 /******************************************************************************************
  * This blocking function read a single character from the terminal identified
  * by the "channel" argument. The corresponding request is actually registered in the
- * device pending requests queue, and the calling thread is descheduled, blocked until
+ * chdev requests queue, and the calling thread is descheduled, blocked until
  * transfer completion.
  * It must be called in the client cluster.
@@ -109 +108 @@
  * This blocking function writes a character string on the terminal identified
  * by the "channel" argument. The corresponding request is actually registered in the
- * device pending requests queue, and the calling thread is descheduled, blocked until
+ * chdev requests queue, and the calling thread is descheduled, blocked until
  * transfer completion.
  * It must be called in the client cluster.
@@ -123 +122 @@
 
  /***************************************************************************************
- * This low-level blocking function is used by the kernel to display one character on a 
+ * This low-level blocking function is used by the kernel to display one string on a 
  * given TXT channel without descheduling the calling thread,  without registering it 
  * in the TXT device waiting queue, and without using the TXT irq. 
@@ -136 +135 @@
                             uint32_t   count );
 
-/******************************************************************************************
- * This function is executed by the server thread associated to the TXT device descriptor.
- * This thread is created and lauched by the dev_txt_init() function, and is used
- * by the TXT_READ and TXT_WRITE operation types. It executes an infinite loop to handle
- * sequencially all commands registered by the client threads in the device waiting queue.
- *  
- * The driver CMD function is blocking, and returns only when the command is completed.
- * can use a busy waiting policy, or block the server thread on the THREAD_BLOCKED_IO_ISR
- * condition and deschedule, using the ISR to reactivate the server thread.
- *
- * When the waiting queue is empty, the server thread blocks on the THREAD_BLOCKED_IO_CMD
- * condition and deschedule. It is re-activated by a client thread registering a command.
- ******************************************************************************************
- * @ dev     : local pointer on device descriptor.
- *****************************************************************************************/
-void dev_txt_server( struct device_s * dev );
-
 
 #endif  /* _DEV_TXT_H_ */