Changeset 570 for trunk

Timestamp:

Oct 5, 2018, 12:08:35 AM (6 years ago)

Author:

alain

Message:

Introduction of the soclib_mty driver for the TSAR-LETI architecture.

Location:

trunk/hal

Files:

• generic/hal_remote.h (modified) (4 diffs)
• generic/hal_uspace.h (modified) (1 diff)
• tsar_mips32/Makefile (modified) (3 diffs)
• tsar_mips32/core/hal_context.c (modified) (3 diffs)
• tsar_mips32/core/hal_drivers.c (modified) (8 diffs)
• tsar_mips32/core/hal_exception.c (modified) (5 diffs)
• tsar_mips32/core/hal_gpt.c (modified) (7 diffs)
• tsar_mips32/core/hal_macros.h (modified) (1 diff)
• tsar_mips32/core/hal_ppm.c (modified) (3 diffs)
• tsar_mips32/core/hal_remote.c (modified) (6 diffs)
• tsar_mips32/core/hal_special.c (modified) (10 diffs)
• tsar_mips32/core/hal_vmm.c (modified) (2 diffs)
• tsar_mips32/drivers/soclib_bdv.c (modified) (11 diffs)
• tsar_mips32/drivers/soclib_dma.c (modified) (6 diffs)
• tsar_mips32/drivers/soclib_hba.c (modified) (13 diffs)
• tsar_mips32/drivers/soclib_iob.c (modified) (7 diffs)
• tsar_mips32/drivers/soclib_mmc.c (modified) (6 diffs)
• tsar_mips32/drivers/soclib_mty.c (moved) (moved from trunk/hal/tsar_mips32/drivers/soclib_mtty.c) (15 diffs)
• tsar_mips32/drivers/soclib_mty.h (moved) (moved from trunk/hal/tsar_mips32/drivers/soclib_mtty.h) (4 diffs)
• tsar_mips32/drivers/soclib_nic.c (modified) (3 diffs)
• tsar_mips32/drivers/soclib_pic.c (modified) (14 diffs)
• tsar_mips32/drivers/soclib_tty.c (modified) (23 diffs)
• tsar_mips32/drivers/soclib_tty.h (modified) (5 diffs)
• tsar_mips32/kernel.ld (modified) (1 diff)
• x86_64/core/hal_remote.c (modified) (4 diffs)
• x86_64/drivers/ioc_ata.c (modified) (1 diff)
• x86_64/drivers/txt_rs232.c (modified) (3 diffs)

trunk/hal/generic/hal_remote.h

@@ -51 +51 @@
  * @ data    : value to be written
  ****************************************************************************************/
-void hal_remote_sw( xptr_t   xp,
+void hal_remote_s32( xptr_t   xp,
                     uint32_t data );
 
@@ -60 +60 @@
  * @ data    : value to be written
  ****************************************************************************************/
-void hal_remote_swd( xptr_t   xp,
+void hal_remote_s64( xptr_t   xp,
                      uint64_t data );
 
@@ -86 +86 @@
  * @ return read value
  ****************************************************************************************/
-uint32_t hal_remote_lw( xptr_t  xp );
+uint32_t hal_remote_l32( xptr_t  xp );
 
 /*****************************************************************************************
@@ -94 +94 @@
  * @ return read value
  ****************************************************************************************/
-uint64_t hal_remote_lwd( xptr_t  xp );
+uint64_t hal_remote_l64( xptr_t  xp );
 
 /*****************************************************************************************

trunk/hal/generic/hal_uspace.h

@@ -93 +93 @@
  * If the kernel uses physical addresses, it activates the MMU to access the user buffer.
  *****************************************************************************************
- * @ u_str     : string address in user space.
+ * @ string     : string in user space.
  * @ return length of the string.
  ****************************************************************************************/

trunk/hal/tsar_mips32/Makefile

@@ -17 +17 @@
 
 DRIVERS_OBJS = $(HAL_ARCH)/build/drivers/soclib_tty.o  \
-               $(HAL_ARCH)/build/drivers/soclib_mtty.o \
+               $(HAL_ARCH)/build/drivers/soclib_mty.o  \
                $(HAL_ARCH)/build/drivers/soclib_bdv.o  \
                $(HAL_ARCH)/build/drivers/soclib_hba.o  \
-               $(HAL_ARCH)/build/drivers/soclib_sdc.o  \
-               $(HAL_ARCH)/build/drivers/soclib_spi.o  \
-               $(HAL_ARCH)/build/drivers/soclib_mmc.o  \
                $(HAL_ARCH)/build/drivers/soclib_pic.o  \
                $(HAL_ARCH)/build/drivers/soclib_nic.o  \
                $(HAL_ARCH)/build/drivers/soclib_dma.o  \
+               $(HAL_ARCH)/build/drivers/soclib_mmc.o  \
                $(HAL_ARCH)/build/drivers/soclib_iob.o
 
@@ -45 +43 @@
                $(HAL_ARCH)/build/core/hal_user.o
 
-HAL_INCLUDE =     -I$(KERNEL) \
-                 -I$(HAL_ARCH)/drivers \
-                 -I$(HAL)/generic             \
-                 -I$(HAL_ARCH)/core    \
-                 -I../../tools/arch_info         \
-                 -I$(KERNEL)/kern \
-                 -I$(KERNEL)/mm   \
-                 -I$(KERNEL)/fs   \
-                 -I$(KERNEL)/syscalls   \
-                 -I$(SHARED_INCLUDE)  \
-                 -I$(KERNEL)/devices    \
-                 -I$(KERNEL)/libk \
+HAL_INCLUDE =    -I$(KERNEL)             \
+                 -I$(HAL_ARCH)/drivers   \
+                 -I$(HAL)/generic        \
+                 -I$(HAL_ARCH)/core      \
+                 -I../../tools/arch_info \
+                 -I$(KERNEL)/kern        \
+                 -I$(KERNEL)/mm          \
+                 -I$(KERNEL)/fs          \
+                 -I$(KERNEL)/syscalls    \
+                 -I$(SHARED_INCLUDE)     \
+                 -I$(KERNEL)/devices     \
+                 -I$(KERNEL)/libk        \
                  -I../../ # for hard_config.h (needed by soclib_sdc_driver for SYS_CLK)
 
@@ -78 +76 @@
                                 $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS)  -c -o $@ $<
+        $(DU) -D $@ > $@.txt
 
 ######################################

trunk/hal/tsar_mips32/core/hal_context.c

@@ -195 +195 @@
 
     // get ppn of remote child process page table
-    uint32_t    pt_ppn = hal_remote_lw( XPTR(child_cxy , &process->vmm.gpt.ppn) );
+    uint32_t    pt_ppn = hal_remote_l32( XPTR(child_cxy , &process->vmm.gpt.ppn) );
 
     // save CPU registers in local CPU context
@@ -245 +245 @@
     hal_cpu_context_init( thread );
 
-    // restore CPU registers ... and jump
+    // restore CPU registers ... and jump to user code
     hal_do_cpu_restore( (hal_cpu_context_t *)thread->cpu_context );
 
@@ -263 +263 @@
 
     // get relevant context slots values
-    uint32_t sp_29   = hal_remote_lw( XPTR( cxy , &ctx->sp_29   ) );
-    uint32_t ra_31   = hal_remote_lw( XPTR( cxy , &ctx->ra_31   ) );
-    uint32_t c0_sr   = hal_remote_lw( XPTR( cxy , &ctx->c0_sr   ) );
-    uint32_t c0_epc  = hal_remote_lw( XPTR( cxy , &ctx->c0_epc  ) );
-    uint32_t c0_th   = hal_remote_lw( XPTR( cxy , &ctx->c0_th   ) );
-    uint32_t c2_ptpr = hal_remote_lw( XPTR( cxy , &ctx->c2_ptpr ) );
-    uint32_t c2_mode = hal_remote_lw( XPTR( cxy , &ctx->c2_mode ) );
+    uint32_t sp_29   = hal_remote_l32( XPTR( cxy , &ctx->sp_29   ) );
+    uint32_t ra_31   = hal_remote_l32( XPTR( cxy , &ctx->ra_31   ) );
+    uint32_t c0_sr   = hal_remote_l32( XPTR( cxy , &ctx->c0_sr   ) );
+    uint32_t c0_epc  = hal_remote_l32( XPTR( cxy , &ctx->c0_epc  ) );
+    uint32_t c0_th   = hal_remote_l32( XPTR( cxy , &ctx->c0_th   ) );
+    uint32_t c2_ptpr = hal_remote_l32( XPTR( cxy , &ctx->c2_ptpr ) );
+    uint32_t c2_mode = hal_remote_l32( XPTR( cxy , &ctx->c2_mode ) );
     
     printk("\n***** CPU context for thread %x in process %x / cycle %d\n" 

trunk/hal/tsar_mips32/core/hal_drivers.c

@@ -26 +26 @@
 
 #include <soclib_tty.h>
-#include <soclib_mtty.h>
+#include <soclib_mty.h>
 #include <soclib_pic.h>
 #include <soclib_iob.h>
 #include <soclib_bdv.h>
 #include <soclib_hba.h>
-#include <soclib_sdc.h>
 #include <soclib_mmc.h>
 #include <soclib_nic.h>
@@ -51 +50 @@
                            uint32_t   impl )
 {
-    switch (impl) {
-    case IMPL_TXT_TTY : {
+    if( impl ==  IMPL_TXT_TTY )
+    {
         soclib_tty_init( txt );
-        break;
     }
-    case IMPL_TXT_MTY : {
-        soclib_mtty_init( txt );
-        break;
+    else if (impl == IMPL_TXT_MTY )
+    {
+        soclib_mty_init( txt );
     }
-    default : {
-        assert( false, "bad implementation" );
-    }
+    else
+    {
+        assert( false, "undefined implementation" );
     }
 }
@@ -74 +72 @@
                            uint32_t   impl )
 {
-    assert( (impl == IMPL_PIC_SCL), "bad implementation" );
+    assert( (impl == IMPL_PIC_SCL), "undefined implementation" );
 
         soclib_pic_init( pic );
@@ -97 +95 @@
                            uint32_t   impl )
 {
-        assert( (impl == IMPL_IOB_TSR), "bad implementation" );
+        assert( (impl == IMPL_IOB_TSR), "undefined implementation" );
 
         soclib_iob_init( iob );
@@ -126 +124 @@
                 soclib_hba_init( ioc );
         }
-        else if (impl == IMPL_IOC_SPI)
-    {
-                soclib_sdc_init( ioc );
-        }
+//      else if (impl == IMPL_IOC_SPI)
+//  {
+//              soclib_sdc_init( ioc );
+//      }
     else 
     {
@@ -144 +142 @@
                            uint32_t   impl )
 {
-        assert( (impl == IMPL_MMC_TSR), "bad implementation" );
+        assert( (impl == IMPL_MMC_TSR), "undefined implementation" );
  
     soclib_mmc_init( mmc );
@@ -157 +155 @@
                            uint32_t   impl )
 {
-        assert( (impl == IMPL_NIC_CBF), "bad implementation" );
+        assert( (impl == IMPL_NIC_CBF), "undefined implementation" );
  
     soclib_nic_init( nic );
@@ -170 +168 @@
                            uint32_t   impl )
 {
-        assert( (impl == IMPL_DMA_SCL), "bad implementation" );
+        assert( (impl == IMPL_DMA_SCL), "undefined implementation" );
  
     soclib_dma_init( dma );

trunk/hal/tsar_mips32/core/hal_exception.c

@@ -35 +35 @@
 #include <syscalls.h>
 #include <shared_syscalls.h>
-#include <remote_spinlock.h>
+#include <remote_busylock.h>
 #include <hal_kentry.h>
-
 #include <hal_exception.h>
 
@@ -340 +339 @@
                                 error_t    error )
 {
-    uint32_t    save_sr;
     core_t    * core    = this->core;
     process_t * process = this->process;
@@ -353 +351 @@
 
     // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    remote_busylock_acquire( lock_xp );
 
     if( error == EXCP_USER_ERROR )
@@ -366 +364 @@
     }
 
-        nolock_printk("local locks = %d / remote locks = %d / blocked_vector = %X\n\n",
-    this->local_locks, this->remote_locks, this->blocked );
+        nolock_printk("busylocks = %d / blocked_vector = %X / flags = %X\n\n",
+    this->busylocks, this->blocked, this->flags );
 
     nolock_printk("c0_cr   %X  c0_epc  %X  c0_sr  %X  c0_th  %X\n",
@@ -394 +392 @@
 
     // release the lock
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    remote_busylock_release( lock_xp );
 
 }  // end hal_exception_dump()

trunk/hal/tsar_mips32/core/hal_gpt.c

@@ -799 +799 @@
 
     // get src_pte1 
-    src_pte1 = hal_remote_lw( XPTR( src_cxy , &src_pt1[ix1] ) );
+    src_pte1 = hal_remote_l32( XPTR( src_cxy , &src_pt1[ix1] ) );
 
     // do nothing if src_pte1 not MAPPED or not SMALL
@@ -844 +844 @@
 
         // get attr and ppn from SRC_PT2
-        src_pte2_attr = hal_remote_lw( XPTR( src_cxy , &src_pt2[2 * ix2]     ) );
-        src_pte2_ppn  = hal_remote_lw( XPTR( src_cxy , &src_pt2[2 * ix2 + 1] ) );
+        src_pte2_attr = hal_remote_l32( XPTR( src_cxy , &src_pt2[2 * ix2]     ) );
+        src_pte2_ppn  = hal_remote_l32( XPTR( src_cxy , &src_pt2[2 * ix2 + 1] ) );
 
         // do nothing if src_pte2 not MAPPED
@@ -1001 +1001 @@
 
         // get PTE1 value
-        pte1 = hal_remote_lw( XPTR( gpt_cxy , &pt1[ix1] ) );
+        pte1 = hal_remote_l32( XPTR( gpt_cxy , &pt1[ix1] ) );
 
         // only MAPPED & SMALL PTEs are modified
@@ -1014 +1014 @@
   
             // get current PTE2 attributes
-            attr = hal_remote_lw( XPTR( gpt_cxy , &pt2[2*ix2] ) );
+            attr = hal_remote_l32( XPTR( gpt_cxy , &pt2[2*ix2] ) );
 
             // only MAPPED PTEs are modified        
@@ -1020 +1020 @@
             {
                 attr = (attr | TSAR_MMU_COW) & (~TSAR_MMU_WRITABLE);
-                hal_remote_sw( XPTR( gpt_cxy , &pt2[2*ix2] ) , attr );
+                hal_remote_s32( XPTR( gpt_cxy , &pt2[2*ix2] ) , attr );
             } 
         } 
@@ -1063 +1063 @@
 
     // get PTE1 value
-    pte1 = hal_remote_lw( XPTR( gpt_cxy , &pt1[ix1] ) );
+    pte1 = hal_remote_l32( XPTR( gpt_cxy , &pt1[ix1] ) );
 
     if( (pte1 & TSAR_MMU_MAPPED) == 0 ) return;
@@ -1073 +1073 @@
 
     // reset PTE2
-        hal_remote_sw( XPTR( gpt_cxy, &pt2[2 * ix2]     ) , 0 );
+        hal_remote_s32( XPTR( gpt_cxy, &pt2[2 * ix2]     ) , 0 );
         hal_fence();
 
     // set PTE2 in this order
-        hal_remote_sw( XPTR( gpt_cxy, &pt2[2 * ix2 + 1] ) , ppn );
+        hal_remote_s32( XPTR( gpt_cxy, &pt2[2 * ix2 + 1] ) , ppn );
         hal_fence();
-        hal_remote_sw( XPTR( gpt_cxy, &pt2[2 * ix2]     ) , tsar_attr );
+        hal_remote_s32( XPTR( gpt_cxy, &pt2[2 * ix2]     ) , tsar_attr );
         hal_fence();
 

trunk/hal/tsar_mips32/core/hal_macros.h

@@ -28 +28 @@
 //     User-side, hardware dependant, macros definition.
 //
-//   Any architecture specific implementation must implement thes macros.
+//   Any architecture specific implementation must implement these macros.
 //////////////////////////////////////////////////////////////////////////////////////////
 

trunk/hal/tsar_mips32/core/hal_ppm.c

@@ -27 +27 @@
 #include <hal_special.h>
 #include <printk.h>
-#include <spinlock.h>
+#include <busylock.h>
 #include <process.h>
 #include <ppm.h>
@@ -46 +46 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
+
 ///////////////////////////////////////////
 error_t  hal_ppm_init( boot_info_t * info )
@@ -59 +60 @@
 
         // initialize lock protecting the free_pages[] lists
-        spinlock_init( &ppm->free_lock );
+        busylock_init( &ppm->free_lock , LOCK_PPM_FREE );
 
         // initialize lock protecting the dirty_pages list
-        spinlock_init( &ppm->dirty_lock );
+        queuelock_init( &ppm->dirty_lock , LOCK_PPM_DIRTY );
 
         // initialize all free_pages[] lists as empty

trunk/hal/tsar_mips32/core/hal_remote.c

@@ -54 +54 @@
 
 /////////////////////////////////
-void hal_remote_sw( xptr_t    xp,
+void hal_remote_s32( xptr_t    xp,
                     uint32_t  data )
 {
@@ -80 +80 @@
 
 //////////////////////////////////
-void hal_remote_swd( xptr_t    xp,
+void hal_remote_s64( xptr_t    xp,
                      uint64_t  data )
 {
@@ -113 +113 @@
                      void *      pt )
 {
-    hal_remote_sw ( xp , (uint32_t)pt );
+    hal_remote_s32 ( xp , (uint32_t)pt );
 }
 
@@ -143 +143 @@
 
 ////////////////////////////////////
-uint32_t hal_remote_lw( xptr_t  xp )
+uint32_t hal_remote_l32( xptr_t  xp )
 {
         uint32_t data;
@@ -169 +169 @@
 
 /////////////////////////////////////
-uint64_t hal_remote_lwd( xptr_t  xp )
+uint64_t hal_remote_l64( xptr_t  xp )
 {
     uint32_t data_lsb;
@@ -200 +200 @@
 void * hal_remote_lpt( xptr_t    xp )
 {
-    return (void *)hal_remote_lw ( xp );
+    return (void *)hal_remote_l32 ( xp );
 }
 

trunk/hal/tsar_mips32/core/hal_special.c

@@ -32 +32 @@
 struct thread_s;
 
-//////////////////////////
+////////////////////////////////
 inline gid_t hal_get_gid( void )
 {
@@ -42 +42 @@
 }
 
-/////////////////////////////
+///////////////////////////////////
 inline reg_t hal_time_stamp( void )
 {
@@ -52 +52 @@
 }
 
-/////////////////////////
+///////////////////////////////
 inline reg_t hal_get_sr( void )
 {
@@ -62 +62 @@
 }
 
-/////////////////////////
+///////////////////////////////
 uint64_t hal_get_cycles( void )
 {
@@ -94 +94 @@
 }
 
-/////////////////////////////////////////////////
+///////////////////////////////////////////////////////
 inline struct thread_s * hal_get_current_thread( void )
 {
@@ -110 +110 @@
 }
 
-/////////////////////
+///////////////////////////
 void hal_fpu_enable( void )
 {
@@ -127 +127 @@
 }
 
-//////////////////////
+////////////////////////////
 void hal_fpu_disable( void )
 {
@@ -145 +145 @@
 }
 
-////////////////////////
+//////////////////////////////
 uint32_t hal_get_stack( void )
 {
@@ -168 +168 @@
 }
 
-////////////////////////////
+//////////////////////////////////
 uint32_t hal_get_bad_vaddr( void )
 {
@@ -201 +201 @@
 }
 
-////////////////
-void hal_fence( void )
+/////////////////////////////
+inline void hal_fence( void )
 {
         asm volatile ("sync");
 }
 
-////////////////
-void hal_rdbar( void )
+/////////////////////////////
+inline void hal_rdbar( void )
 {
         asm volatile( "" ::: "memory" );
 }
 
-/////////////////////
+///////////////////////////
 void hal_core_sleep( void )
 {

trunk/hal/tsar_mips32/core/hal_vmm.c

@@ -64 +64 @@
     }
 
-    // get lock protecting the VSL to found the "kentry" vseg
-    remote_rwlock_wr_lock( XPTR( local_cxy , &vmm->vsegs_lock ) );
+    // get extended pointer on lock protecting the VSL
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
 
-    // scan the VSL
+    // get VSL lock 
+    remote_rwlock_wr_acquire( lock_xp );
+
+    // scan the VSL to found the "kentry" vseg
     xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
     xptr_t         iter_xp;
     xptr_t         vseg_xp;
     vseg_t       * vseg;
-    bool_t         found = false; 
+    bool_t         found = false;
+ 
     XLIST_FOREACH( root_xp , iter_xp )
     {
@@ -87 +91 @@
     }
 
-    // release the lock protecting the VSL
-    remote_rwlock_wr_unlock( XPTR( local_cxy , &vmm->vsegs_lock ) );
+    // release the VSL lock
+    remote_rwlock_wr_release( lock_xp );
 
     if( found == false ) return error;

trunk/hal/tsar_mips32/drivers/soclib_bdv.c

@@ -28 +28 @@
 #include <printk.h>
 #include <thread.h>
-#include <spinlock.h>
 
 ///////////////////////////////////////
@@ -45 +44 @@
 
     // get block_size and block_count  
-        uint32_t block_size = hal_remote_lw( XPTR( bdv_cxy , bdv_ptr + BDV_BLOCK_SIZE_REG ) );
-        uint32_t block_count = hal_remote_lw( XPTR( bdv_cxy , bdv_ptr + BDV_SIZE_REG ) );
+        uint32_t block_size = hal_remote_l32( XPTR( bdv_cxy , bdv_ptr + BDV_BLOCK_SIZE_REG ) );
+        uint32_t block_count = hal_remote_l32( XPTR( bdv_cxy , bdv_ptr + BDV_SIZE_REG ) );
 
     // set IOC device descriptor extension
@@ -69 +68 @@
 
     // get command arguments and extended pointer on IOC device
-    cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
-    lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
-    count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
-    buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
-    ioc_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
+    cmd_type =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
+    lba      =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
+    count    =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
+    buf_xp   = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
+    ioc_xp   = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
 
 #if DEBUG_HAL_IOC_RX
@@ -94 +93 @@
 
     // get cluster and pointers for SOCLIB-BDV peripheral segment base
-    xptr_t     seg_xp  = (xptr_t)hal_remote_lwd( XPTR( ioc_cxy , &ioc_ptr->base ) );
+    xptr_t     seg_xp  = (xptr_t)hal_remote_l64( XPTR( ioc_cxy , &ioc_ptr->base ) );
     cxy_t      seg_cxy = GET_CXY( seg_xp );
     uint32_t * seg_ptr = GET_PTR( seg_xp );
@@ -108 +107 @@
 
     // set SOCLIB_BDV registers to start one I/O operation
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_IRQ_ENABLE_REG ) , 1       );
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_BUFFER_REG     ) , buf_lsb ); 
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_BUFFER_EXT_REG ) , buf_msb ); 
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_LBA_REG        ) , lba     );
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_COUNT_REG      ) , count   );
-    hal_remote_sw( XPTR( seg_cxy , seg_ptr + BDV_OP_REG         ) , op      );
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_IRQ_ENABLE_REG ) , 1       );
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_BUFFER_REG     ) , buf_lsb ); 
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_BUFFER_EXT_REG ) , buf_msb ); 
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_LBA_REG        ) , lba     );
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_COUNT_REG      ) , count   );
+    hal_remote_s32( XPTR( seg_cxy , seg_ptr + BDV_OP_REG         ) , op      );
 
     // waiting policy  depends on the command type
@@ -124 +123 @@
         while (1)
         {
-            status = hal_remote_lw( XPTR( seg_cxy , seg_ptr + BDV_STATUS_REG ) );
+            status = hal_remote_l32( XPTR( seg_cxy , seg_ptr + BDV_STATUS_REG ) );
 
             if( status == BDV_READ_SUCCESS ) // successfully completed
             {
-                hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
+                hal_remote_s32( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
                 break;
             }
@@ -137 +136 @@
             else                            // error reported
             {
-                hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
+                hal_remote_s32( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
                 break;
             }
@@ -174 +173 @@
     // get extended pointer on client thread
     xptr_t root = XPTR( local_cxy , &chdev->wait_root );
-    xptr_t client_xp = XLIST_FIRST_ELEMENT( root , thread_t , wait_list );
+    xptr_t client_xp = XLIST_FIRST( root , thread_t , wait_list );
 
     // get extended pointer on server thread
@@ -184 +183 @@
 
     // get command type
-    uint32_t   cmd_type = hal_remote_lw( XPTR( client_cxy , &client_ptr->ioc_cmd.type ) );
+    uint32_t   cmd_type = hal_remote_l32( XPTR( client_cxy , &client_ptr->ioc_cmd.type ) );
     
     // get SOCLIB_BDV device cluster and local pointer
@@ -191 +190 @@
 
     // get BDV status register and acknowledge IRQ
-        uint32_t status = hal_remote_lw( XPTR( bdv_cxy , bdv_ptr + BDV_STATUS_REG ) );   
+        uint32_t status = hal_remote_l32( XPTR( bdv_cxy , bdv_ptr + BDV_STATUS_REG ) );   
 
     if( cmd_type == IOC_READ )
@@ -223 +222 @@
 
     // set operation status in command
-    hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , error );
+    hal_remote_s32( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , error );
 
     // unblock server thread 

trunk/hal/tsar_mips32/drivers/soclib_dma.c

@@ -40 +40 @@
 
     // enable interrupts
-        hal_remote_sw( XPTR( dma_cxy , dma_ptr + DMA_IRQ_DISABLED ) , 0 );
+        hal_remote_s32( XPTR( dma_cxy , dma_ptr + DMA_IRQ_DISABLED ) , 0 );
 
 } // soclib_dma_init()
@@ -57 +57 @@
 
     // get command arguments and extended pointer on DMA device
-    dev_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.dev_xp ) );
-    dst_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.dst_xp ) );
-    src_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.src_xp ) );
-    size   =         hal_remote_lw ( XPTR( thread_cxy , &thread_ptr->dma_cmd.size   ) );
+    dev_xp = (xptr_t)hal_remote_l64( XPTR( thread_cxy , &thread_ptr->dma_cmd.dev_xp ) );
+    dst_xp = (xptr_t)hal_remote_l64( XPTR( thread_cxy , &thread_ptr->dma_cmd.dst_xp ) );
+    src_xp = (xptr_t)hal_remote_l64( XPTR( thread_cxy , &thread_ptr->dma_cmd.src_xp ) );
+    size   =         hal_remote_l32 ( XPTR( thread_cxy , &thread_ptr->dma_cmd.size   ) );
 
     // get DMA device cluster and local pointer
@@ -67 +67 @@
 
     // get extended pointer on SOCLIB-DMA peripheral
-    xptr_t     dma_xp = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->base ) );
+    xptr_t     dma_xp = hal_remote_l32( XPTR( dev_cxy , &dev_ptr->base ) );
 
     // get SOCLIB_DMA device cluster and local pointer
@@ -83 +83 @@
 
     // set SOCLIB_DMA registers to start tranfer operation
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_SRC     ) , src_lsb ); 
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_SRC_EXT ) , src_msb ); 
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_DST     ) , dst_lsb );
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_DST_EXT ) , dst_msb );
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_LEN     ) , size    );
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_SRC     ) , src_lsb ); 
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_SRC_EXT ) , src_msb ); 
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_DST     ) , dst_lsb );
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_DST_EXT ) , dst_msb );
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_LEN     ) , size    );
 
     // Block and deschedule server thread
@@ -100 +100 @@
     // get extended pointer on client thread
     xptr_t root      = XPTR( local_cxy , &chdev->wait_root );
-    xptr_t client_xp = XLIST_FIRST_ELEMENT( root , thread_t , wait_list );
+    xptr_t client_xp = XLIST_FIRST( root , thread_t , wait_list );
 
     // get extended pointer on server thread
@@ -117 +117 @@
 
     // get DMA status register 
-        uint32_t status = hal_remote_lw( XPTR( dma_cxy , base + DMA_LEN ) );   
+        uint32_t status = hal_remote_l32( XPTR( dma_cxy , base + DMA_LEN ) );   
 
     // acknowledge IRQ
-    hal_remote_sw( XPTR( dma_cxy , base + DMA_RESET ) , 0 );
+    hal_remote_s32( XPTR( dma_cxy , base + DMA_RESET ) , 0 );
 
     // set operation status in command
         error_t  error = ( status != DMA_SUCCESS ); 
-    hal_remote_sw( XPTR( client_cxy , &client_ptr->dma_cmd.error ) , error );
+    hal_remote_s32( XPTR( client_cxy , &client_ptr->dma_cmd.error ) , error );
 
     // unblock server thread 

trunk/hal/tsar_mips32/drivers/soclib_hba.c

@@ -27 +27 @@
 #include <dev_ioc.h>
 #include <soclib_hba.h>
-#include <spinlock.h>
 #include <thread.h>
 
@@ -51 +50 @@
 
 // spinlock protecting the command slot allocator
-__attribute__((section(".kdata")))
-spinlock_t         hba_lock;
+// __attribute__((section(".kdata")))
+// busylock_t         hba_lock;
 
 ///////////////////////////////////////
@@ -69 +68 @@
 
     // get block_size and block_count  
-        uint32_t block_size  = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_BLOCK_SIZE_REG ) );
-        uint32_t block_count = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_BLOCK_COUNT_REG ) );
+        uint32_t block_size  = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_BLOCK_SIZE_REG ) );
+        uint32_t block_count = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_BLOCK_COUNT_REG ) );
 
     // set device descriptor extension
@@ -77 +76 @@
 
     // activate HBA interrupts 
-    hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXIE_REG ) , 0x1 );
+    hal_remote_s32( XPTR( hba_cxy , hba_ptr + HBA_PXIE_REG ) , 0x1 );
 
         // reset SOCLIB_HBA driver global variable
@@ -107 +106 @@
 
     // get command arguments and extended pointer on IOC device
-    cmd_type  =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
-    lba       =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
-    count     =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
-    buf_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
-    dev_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
+    cmd_type  =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
+    lba       =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
+    count     =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
+    buf_xp    = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
+    dev_xp    = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
 
     // get IOC device cluster and local pointer
@@ -118 +117 @@
 
     // get cluster and pointers for SOCLIB-HBA peripheral segment base
-    xptr_t     hba_xp  = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
+    xptr_t     hba_xp  = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
     cxy_t      hba_cxy = GET_CXY( hba_xp );
     uint32_t * hba_ptr = GET_PTR( hba_xp );
@@ -181 +180 @@
  
             // set HBA_PXCI_REG to start transfer
-            hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) , 1<<cmd_id );
+            hal_remote_s32( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) , 1<<cmd_id );
 
             // exit the while 
@@ -204 +203 @@
         while(1)
         {
-            pxis     = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
-            pxci     = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );
+            pxis     = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
+            pxci     = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );
             error    = (pxis & 0x40000000) >> 30;
             fault_id = (pxis & 0x1F000000) >> 24;
@@ -217 +216 @@
                 if( error && (fault_id == cmd_id) ) 
                 {
-                    hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
+                    hal_remote_s32( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
                 }
                 else
                 {
-                    hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
+                    hal_remote_s32( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
                 }
 
@@ -243 +242 @@
     // get extended pointer on client thread
     xptr_t root      = XPTR( local_cxy , &chdev->wait_root );
-    xptr_t client_xp = XLIST_FIRST_ELEMENT( root , thread_t , wait_list );
+    xptr_t client_xp = XLIST_FIRST( root , thread_t , wait_list );
 
     // get client thread cluster and local pointer
@@ -254 +253 @@
 
     // get HBA_PXIS_REG and HBA_PXCI_REG current values
-    uint32_t current_pxis = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
-    uint32_t current_pxci = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );
+    uint32_t current_pxis = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
+    uint32_t current_pxci = hal_remote_l32( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );
 
     uint32_t  error    = (current_pxis & 0x40000000) >> 30;
@@ -273 +272 @@
             if( error && (iter == fault_id ) ) 
             {
-                hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 1 );
+                hal_remote_s32( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 1 );
             }
             else
             {
-                hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 0 );
+                hal_remote_s32( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 0 );
             }
 
@@ -286 +285 @@
 
     // reset HBA_PXIS_REG
-    hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) , 0 );
+    hal_remote_s32( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) , 0 );
 
 } // end soclib_hba_isr()

trunk/hal/tsar_mips32/drivers/soclib_iob.c

@@ -31 +31 @@
 {
     // desactivate IOMMU
-    hal_remote_sw( chdev->base + (IOB_IOMMU_ACTIVE<<2) , 0 );
+    hal_remote_s32( chdev->base + (IOB_IOMMU_ACTIVE<<2) , 0 );
 }
 
@@ -43 +43 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // set ACTIVE register
-    hal_remote_sw( base_xp + (IOB_IOMMU_ACTIVE<<2) , value );
+    hal_remote_s32( base_xp + (IOB_IOMMU_ACTIVE<<2) , value );
 }
 
@@ -58 +58 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // set PTPR register
-    hal_remote_sw( base_xp + (IOB_IOMMU_PTPR<<2) , value );
+    hal_remote_s32( base_xp + (IOB_IOMMU_PTPR<<2) , value );
 }
 
@@ -73 +73 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // invalidate TLB entry
-    hal_remote_sw( base_xp + (IOB_INVAL_PTE<<2) , vpn );
+    hal_remote_s32( base_xp + (IOB_INVAL_PTE<<2) , vpn );
 }
 
@@ -87 +87 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // get BVAR register
-    return hal_remote_lw( base_xp + (IOB_IOMMU_BVAR<<2) );
+    return hal_remote_l32( base_xp + (IOB_IOMMU_BVAR<<2) );
 }
 
@@ -101 +101 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // get BVAR register
-    return hal_remote_lw( base_xp + (IOB_IOMMU_SRCID<<2) );
+    return hal_remote_l32( base_xp + (IOB_IOMMU_SRCID<<2) );
 }
 
@@ -115 +115 @@
 
     // get extended pointer on SOCLIB_IOB base_xp segment
-    xptr_t base_xp = (xptr_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    xptr_t base_xp = (xptr_t)hal_remote_l64( XPTR( iob_cxy , &iob_ptr->base ) );
 
     // get BVAR register
-    return hal_remote_lw( base_xp + (IOB_IOMMU_ERROR<<2) );
+    return hal_remote_l32( base_xp + (IOB_IOMMU_ERROR<<2) );
 }
 

trunk/hal/tsar_mips32/drivers/soclib_mmc.c

@@ -27 +27 @@
 #include <dev_mmc.h>
 #include <soclib_mmc.h>
-#include <spinlock.h>
 #include <thread.h>
 #include <printk.h>
@@ -62 +61 @@
 
     // get command type and extended pointer on MMC device
-    type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->mmc_cmd.type   ) );
-    dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->mmc_cmd.dev_xp ) );
+    type   =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->mmc_cmd.type   ) );
+    dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->mmc_cmd.dev_xp ) );
 
     // get MMC device cluster and local pointer
@@ -70 +69 @@
 
     // get cluster and pointers for SOCLIB_MMC peripheral segment base
-    xptr_t     seg_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
+    xptr_t     seg_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
     cxy_t      seg_cxy = GET_CXY( seg_xp );
     uint32_t * seg_ptr = GET_PTR( seg_xp );
@@ -78 +77 @@
         // get buffer pointer and size
         buf_ptr  = hal_remote_lpt( XPTR( th_cxy , &th_ptr->mmc_cmd.buf_ptr ) );
-        buf_size = hal_remote_lw ( XPTR( th_cxy , &th_ptr->mmc_cmd.buf_size ) );
+        buf_size = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->mmc_cmd.buf_size ) );
 
         // set command type
@@ -86 +85 @@
 
         // set SOCLIB_MMC registers to start INVAL/SYNC operation
-        hal_remote_sw( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_ADDR_LO    ) , (uint32_t)buf_ptr );
-        hal_remote_sw( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_ADDR_HI    ) , (uint32_t)dev_cxy );
-        hal_remote_sw( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_BUF_LENGTH ) , buf_size ); 
-        hal_remote_sw( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_CMD_TYPE   ) , cc_cmd ); 
+        hal_remote_s32( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_ADDR_LO    ) , (uint32_t)buf_ptr );
+        hal_remote_s32( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_ADDR_HI    ) , (uint32_t)dev_cxy );
+        hal_remote_s32( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_BUF_LENGTH ) , buf_size ); 
+        hal_remote_s32( XPTR( seg_cxy , seg_ptr + SOCLIB_MMC_CMD_TYPE   ) , cc_cmd ); 
     }
     else  // (type == MMC_GET_ERROR) or (type == MMC_GET_ERROR) pr (type == MMC_GET_INSTRU )
@@ -95 +94 @@
         // get src/dst buffer local pointer and register index
         reg_ptr   = (uint32_t *)hal_remote_lpt( XPTR( th_cxy , &th_ptr->mmc_cmd.reg_ptr ) );
-        reg_index = hal_remote_lw( XPTR( th_cxy , &th_ptr->mmc_cmd.reg_index ) );
+        reg_index = hal_remote_l32( XPTR( th_cxy , &th_ptr->mmc_cmd.reg_index ) );
 
         // move register to/from local buffer 
         if( (type == MMC_GET_ERROR) || (type == MMC_GET_INSTRU) )
         {
-            *reg_ptr =  hal_remote_lw( XPTR( seg_cxy , seg_ptr + reg_index ) );
+            *reg_ptr =  hal_remote_l32( XPTR( seg_cxy , seg_ptr + reg_index ) );
         }
         else  // type == MMC_SET_ERROR
         {
-            hal_remote_sw( XPTR( seg_cxy , seg_ptr + reg_index ) , *reg_ptr );
+            hal_remote_s32( XPTR( seg_cxy , seg_ptr + reg_index ) , *reg_ptr );
         }
     }

trunk/hal/tsar_mips32/drivers/soclib_mty.c

@@ -1 +1 @@
 /*
- * soclib_mtty.c - soclib tty driver implementation.
+ * soclib_mty.c - soclib mty driver implementation.
  *
  * Author  Alain Greiner (2016,2017,2018)
@@ -26 +26 @@
 #include <dev_txt.h>
 #include <chdev.h>
-#include <soclib_mtty.h>
-#include <remote_spinlock.h>
+#include <soclib_mty.h>
 #include <thread.h>
 #include <printk.h>
 #include <hal_special.h>
 
-#if (DEBUG_SYS_READ & 1)
-extern uint32_t  enter_tty_cmd_read;
-extern uint32_t  exit_tty_cmd_read;
-
-extern uint32_t  enter_tty_isr_read;
-extern uint32_t  exit_tty_isr_read;
-#endif
-
-#if (DEBUG_SYS_WRITE & 1)
-extern uint32_t  enter_tty_cmd_write;
-extern uint32_t  exit_tty_cmd_write;
-
-extern uint32_t  enter_tty_isr_write;
-extern uint32_t  exit_tty_isr_write;
-#endif
-
 extern   chdev_directory_t    chdev_dir;  // allocated in the kernel_init.c file.
-extern   spinlock_t           txt0_lock;  // Initialized in kernel_init.c
+
 ////////////////////////////////////////////////////////////////////////////////////
-// These global variables implement the MTTY_RX  FIFOs (one per channel)
+// These global variables implement the MTY_RX  FIFOs (one per channel)
 ////////////////////////////////////////////////////////////////////////////////////
-
-__attribute__((section(".kdata")))
-mtty_fifo_t  mtty_rx_fifo[CONFIG_MAX_TXT_CHANNELS];
-
-__attribute__((section(".kdata")))
-mtty_fifo_t  mtty_tx_fifo[CONFIG_MAX_TXT_CHANNELS];
+// Implementation note:
+// We allocate - in each cluster - two arrays of FIFOs containing as many entries
+// as the total number of TXT channels, but all entries are not used in all
+// clusters: for a given cluster K, a given entry corresponding to a given channel
+// and a given direction is only used if the associated chdev is in cluster K.
+// With this policy, the driver can ignore the actual placement of chdevs.
+////////////////////////////////////////////////////////////////////////////////////
+
+__attribute__((section(".kdata")))
+mty_fifo_t  mty_rx_fifo[CONFIG_MAX_TXT_CHANNELS];
+
+__attribute__((section(".kdata")))
+mty_fifo_t  mty_tx_fifo[CONFIG_MAX_TXT_CHANNELS];
+
+////////////////////////////////////////////////////////////////////////////////////
+// These global variables define the physical channel RX and TX state,
+// as required by the virtual channels handling.
+////////////////////////////////////////////////////////////////////////////////////
+// Implementation note:
+// These state variables are required, because the ISR is called twice for each
+// character on the physical channel (for index and value), and does not the same
+// actions for index and value. They are also used to implement the round-robin
+// policy between TX_FIFOs.
+////////////////////////////////////////////////////////////////////////////////////
+
+__attribute__((section(".kdata")))
+bool_t      mty_rx_not_new;                // RX first byte if false
+
+__attribute__((section(".kdata")))
+uint32_t    mty_rx_channel;                // RX virtual channel index
+
+__attribute__((section(".kdata")))
+bool_t      mty_tx_not_new;                // TX first byte if false
+
+__attribute__((section(".kdata")))
+uint32_t    mty_tx_value;                  // TX character ascii value
+
+__attribute__((section(".kdata")))
+uint32_t    mty_tx_last;                   // TX last selected virtual channel
 
 ///////////////////////////////////////
-void soclib_mtty_init( chdev_t * chdev )
+void soclib_mty_init( chdev_t * chdev )
 {
     xptr_t reg_xp;
 
     // initialise function pointers in chdev
-    chdev->cmd = &soclib_mtty_cmd;
-    chdev->isr = &soclib_mtty_isr;
-    chdev->aux = &soclib_mtty_aux;
-
-    // get TTY channel and extended pointer on TTY peripheral base address
-    xptr_t   tty_xp  = chdev->base;
+    chdev->cmd = &soclib_mty_cmd;
+    chdev->isr = &soclib_mty_isr;
+    chdev->aux = &soclib_mty_aux;
+
+    // get MTY channel and extended pointer on MTY peripheral base address
+    xptr_t   mty_xp  = chdev->base;
     uint32_t channel = chdev->channel;
     bool_t   is_rx   = chdev->is_rx;
 
-    // get SOCLIB_TTY device cluster and local pointer
-    cxy_t      tty_cxy = GET_CXY( tty_xp );
-    uint32_t * tty_ptr = GET_PTR( tty_xp );
-
-    // enable interruptions for RX but not for TX
-    reg_xp = XPTR( tty_cxy , tty_ptr + MTTY_CONFIG );
-    hal_remote_sw( reg_xp , MTTY_CONFIG_RX_ENABLE );
+    // get SOCLIB_MTY device cluster and local pointer
+    cxy_t      mty_cxy = GET_CXY( mty_xp );
+    uint32_t * mty_ptr = GET_PTR( mty_xp );
+
+    // enable interruptions for RX 
+    reg_xp = XPTR( mty_cxy , mty_ptr + MTY_CONFIG );
+    hal_remote_s32( reg_xp , MTY_CONFIG_RX_ENABLE );
 
     // reset relevant FIFO
     if( is_rx )
     {
-        mtty_rx_fifo[channel].sts = 0;
-        mtty_rx_fifo[channel].ptr = 0;
-        mtty_rx_fifo[channel].ptw = 0;
+        mty_rx_fifo[channel].sts = 0;
+        mty_rx_fifo[channel].ptr = 0;
+        mty_rx_fifo[channel].ptw = 0;
     }
     else
     {
-        mtty_tx_fifo[channel].sts = 0;
-        mtty_tx_fifo[channel].ptr = 0;
-        mtty_tx_fifo[channel].ptw = 0;
+        mty_tx_fifo[channel].sts = 0;
+        mty_tx_fifo[channel].ptr = 0;
+        mty_tx_fifo[channel].ptw = 0;
     }
-}  // end soclib_mtty_init()
+}  // end soclib_mty_init()
 
 //////////////////////////////////////////////////////////////
-void __attribute__ ((noinline)) soclib_mtty_cmd( xptr_t th_xp )
+void __attribute__ ((noinline)) soclib_mty_cmd( xptr_t th_xp )
 {
-    mtty_fifo_t * fifo;     // MTTY_RX or MTTY_TX FIFO
+    mty_fifo_t * fifo;     // MTY_RX or MTY_TX FIFO
     char         byte;     // byte value
     uint32_t     done;     // number of bytes moved
@@ -110 +126 @@
 
     // get command arguments
-    uint32_t type     = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.type   ) );
-    xptr_t   buf_xp   = hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
-    uint32_t count    = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.count  ) );
+    uint32_t type     = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.type   ) );
+    xptr_t   buf_xp   = hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
+    uint32_t count    = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.count  ) );
     xptr_t   error_xp = XPTR( th_cxy , &th_ptr->txt_cmd.error );
 
-#if (DEBUG_SYS_READ & 1)
-if( type == TXT_READ) enter_tty_cmd_read = (uint32_t)hal_get_cycles();
-#endif
-
-#if (DEBUG_SYS_WRITE & 1)
-if( type == TXT_WRITE) enter_tty_cmd_write = (uint32_t)hal_get_cycles();
-#endif
-
     // get TXT device cluster and pointers
-    xptr_t     dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
+    xptr_t     dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
     cxy_t      dev_cxy = GET_CXY( dev_xp );
     chdev_t  * dev_ptr = GET_PTR( dev_xp );
 
-    // get cluster and pointers for SOCLIB_TTY peripheral base segment
-    xptr_t     tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
-    cxy_t      tty_cxy = GET_CXY( tty_xp );
-    uint32_t * tty_ptr = GET_PTR( tty_xp );
-
-    // get TTY channel index and channel base address
-    uint32_t   channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) );
-    uint32_t * base    = tty_ptr;
+    // get MTY channel index and channel base address
+    uint32_t   channel = hal_remote_l32( XPTR( dev_cxy , &dev_ptr->channel ) );
 
     ///////////////////////
-    if( type == TXT_WRITE )         // write bytes to MTTY_TX FIFO
-    {
-        fifo = &mtty_tx_fifo[channel];
+    if( type == TXT_WRITE )         // write bytes to MTY_TX FIFO
+    {
+        fifo = &mty_tx_fifo[channel];
 
         done = 0;
@@ -146 +148 @@
         while( done < count )
         {
-            if( fifo->sts < MTTY_FIFO_DEPTH )   // put one byte to FIFO if TX_FIFO not full
+            if( fifo->sts < MTY_FIFO_DEPTH )   // put one byte to FIFO if TX_FIFO not full
             {
                 // get one byte from command buffer
@@ -164 +166 @@
 
                 // update FIFO state
-                fifo->ptw = (fifo->ptw + 1) % MTTY_FIFO_DEPTH;
+                fifo->ptw = (fifo->ptw + 1) % MTY_FIFO_DEPTH;
                 hal_atomic_add( &fifo->sts , 1 );
 
                 // udate number of bytes moved
                 done++;
-
-                // enable TX_IRQ
-                //      vci_multi_tty devices never raise TX IRQs
-                //      so the following instructions are useless
-                //      and moreover they kernel panic
-                // xptr_t config_xp = XPTR( tty_cxy , base + MTTY_CONFIG );
-                // uint32_t old = hal_remote_lw( config_xp );
-                // uint32_t new = old | MTTY_CONFIG_TX_ENABLE;
-                // hal_remote_atomic_cas( config_xp , old , new );
-                // hal_remote_sw( XPTR( tty_cxy , base + MTTY_CONFIG ) , MTTY_CONFIG_TX_ENABLE );
             }
             else                                // block & deschedule if TX_FIFO full
@@ -186 +178 @@
 
                 // deschedule
-                sched_yield( "MTTY_TX_FIFO full" ); 
+                sched_yield( "MTY_TX_FIFO full" ); 
             }
         }
 
         // set error status in command and return
-        hal_remote_sw( error_xp , 0 );
+        hal_remote_s32( error_xp , 0 );
     }
     ///////////////////////////
-    else if( type == TXT_READ )       // read bytes from MTTY_RX FIFO   
-    {
-        fifo = &mtty_rx_fifo[channel];
+    else if( type == TXT_READ )       // read bytes from MTY_RX FIFO   
+    {
+        fifo = &mty_rx_fifo[channel];
 
         done = 0;
@@ -214 +206 @@
 #endif
                 // update FIFO state
-                fifo->ptr = (fifo->ptr + 1) % MTTY_FIFO_DEPTH;
+                fifo->ptr = (fifo->ptr + 1) % MTY_FIFO_DEPTH;
                 hal_atomic_add( &fifo->sts , -1 );
 
@@ -229 +221 @@
     
                 // deschedule
-                sched_yield( "MTTY_RX_FIFO empty" );
+                sched_yield( "MTY_RX_FIFO empty" );
             }
         }  // end while
 
         // set error status in command
-        hal_remote_sw( error_xp , 0 );
+        hal_remote_s32( error_xp , 0 );
     }
     else
@@ -241 +233 @@
     }
 
-#if (DEBUG_SYS_READ & 1)
-if( type == TXT_READ ) exit_tty_cmd_read = (uint32_t)hal_get_cycles();
-#endif
-
-#if (DEBUG_SYS_WRITE & 1)
-if( type == TXT_WRITE ) exit_tty_cmd_write = (uint32_t)hal_get_cycles();
-#endif
-
-}  // end soclib_mtty_cmd()
+}  // end soclib_mty_cmd()
 
 /////////////////////////////////////////////////////////////////
-void __attribute__ ((noinline)) soclib_mtty_isr( chdev_t * chdev )
+void __attribute__ ((noinline)) soclib_mty_isr( chdev_t * chdev )
 {
     thread_t   * server;            // pointer on TXT chdev server thread
     lid_t        server_lid;        // local index of core running the server thread
-    uint32_t     channel;           // TXT chdev channel
+    uint32_t     channel;           // TXT chdev channel (virtual channel index)
     bool_t       is_rx;             // TXT chdev direction
     char         byte;              // byte value
@@ -263 +247 @@
     process_t  * owner_ptr;         // local pointer on TXT owner process
     pid_t        owner_pid;         // TXT owner process identifier
-    mtty_fifo_t * fifo;              // pointer on MTTY_TX or MTTY_RX FIFO
-    cxy_t        tty_cxy;           // soclib_mtty cluster
-    uint32_t   * tty_ptr;           // soclib_mtty segment base address
-    uint32_t   * base;              // soclib_mtty channel base address
-    xptr_t       status_xp;         // extended pointer on MTTY_STATUS register
-    xptr_t       write_xp;          // extended pointer on MTTY_WRITE register
-    xptr_t       read_xp;           // extended pointer on MTTY_READ register
+    mty_fifo_t * fifo;              // pointer on MTY_TX or MTY_RX FIFO
+    cxy_t        mty_cxy;           // soclib_mty cluster
+    uint32_t   * mty_ptr;           // soclib_mty segment base address
+    xptr_t       status_xp;         // extended pointer on MTY_STATUS register
+    xptr_t       write_xp;          // extended pointer on MTY_WRITE register
+    xptr_t       read_xp;           // extended pointer on MTY_READ register
     xptr_t       parent_xp;         // extended pointer on parent process
     cxy_t        parent_cxy;        // parent process cluster
     process_t  * parent_ptr;        // local pointer on parent process
-    xptr_t       children_lock_xp;  // extended pointer on children processes lock
     thread_t   * parent_main_ptr;   // extended pointer on parent process main thread
     xptr_t       parent_main_xp;    // local pointer on parent process main thread
+    uint32_t     n;                 // index in loop
+    bool_t       found;
+
+#if DEBUG_HAL_TXT_RX
+uint32_t rx_cycle = (uint32_t)hal_get_cycles();
+#endif
+
+#if DEBUG_HAL_TXT_TX
+uint32_t tx_cycle = (uint32_t)hal_get_cycles();
+#endif
 
     // get TXT chdev channel, direction and server thread
-    channel    = chdev->channel;
     is_rx      = chdev->is_rx;
     server     = chdev->server;
     server_lid = server->core->lid;
 
-#if (DEBUG_SYS_READ & 1)
-if( is_rx ) enter_tty_isr_read = (uint32_t)hal_get_cycles();
-#endif
-
-#if (DEBUG_SYS_WRITE & 1)
-if( is_rx == 0 ) enter_tty_isr_write = (uint32_t)hal_get_cycles();
-#endif
-
-#if DEBUG_HAL_TXT_RX
-uint32_t rx_cycle = (uint32_t)hal_get_cycles();
-#endif
-
-#if DEBUG_HAL_TXT_TX
-uint32_t tx_cycle = (uint32_t)hal_get_cycles();
-#endif
-
-    // get SOCLIB_TTY peripheral cluster and local pointer
-    tty_cxy = GET_CXY( chdev->base );
-    tty_ptr = GET_PTR( chdev->base );
-
-    // get channel base address
-    base    = tty_ptr;
-
-    // get extended pointer on TTY registers
-    status_xp = XPTR( tty_cxy , base + MTTY_STATUS );
-    write_xp  = XPTR( tty_cxy , base + MTTY_WRITE );
-    read_xp   = XPTR( tty_cxy , base + MTTY_READ );
+    // get SOCLIB_MTY peripheral cluster and local pointer
+    mty_cxy = GET_CXY( chdev->base );
+    mty_ptr = GET_PTR( chdev->base );
+
+    // get extended pointer on MTY registers
+    status_xp = XPTR( mty_cxy , mty_ptr + MTY_STATUS );
+    write_xp  = XPTR( mty_cxy , mty_ptr + MTY_WRITE );
+    read_xp   = XPTR( mty_cxy , mty_ptr + MTY_READ );
 
     /////////////////////////// handle RX //////////////////////
     if( is_rx )
     {
-        fifo = &mtty_rx_fifo[channel];
-
-        // try to move bytes until MTTY_READ register empty
-        while( hal_remote_lw( status_xp ) & MTTY_STATUS_RX_FULL )   
+        // check one byte available in MTY_READ register
+        if( hal_remote_l32( status_xp ) & MTY_STATUS_RX_FULL )   
         {
-            // get one byte from MTTY_READ register & acknowledge RX_IRQ
+            // get one byte from MTY_READ register & acknowledge RX_IRQ
             byte = (char)hal_remote_lb( read_xp );
 
-            // Ignore Carriage Returns
-            if( byte == 0xD )
-            {
-                continue;
-            }
-
-            // This is the MTTY multiplexing
-            // When a extended ASCII char are received (typing Ctrl-Shift-U then 100+n for example on the terminal)
-            // Two characters are received : 0xFFFFFFc4 then 0xFFFFFF80 + n
-            // When this second char is received, it is considered a metachar that determines the tty dest number
-            // Thus, if you want to make tty 5 the new target, type Ctrl+Shift+U then 105
-            // Now all keystrokes IRQs will be handled by the server DEV thread
-            // associated to RX channel number 5
-            if( (byte & 0xFF) > 0x80 && (byte & 0xFF) <= 0x89 )
-            {
-                // Disable MTTY IRQ for the core owning
-                // the current channel's server DEV thread
-                dev_pic_disable_irq( server_lid, XPTR( local_cxy , chdev ) );
-                
-                int         tty_destnb  = (int)(byte & 0xFF) - 0x80;
-                chdev_t *   new_chdev   = chdev_dir.txt_rx[tty_destnb];
-                lid_t       new_lid     = new_chdev->server->core->lid;
-
-                // Bind MTTY IRQ to the core owning the new channel's server DEV thread
-                dev_pic_bind_irq( new_lid , new_chdev );                
-
-                // Enable MTTY IRQ for the core owning
-                // the new channel's server DEV thread
-                dev_pic_enable_irq( new_lid , XPTR( local_cxy , new_chdev ) );
-
-                channel    = new_chdev->channel;
-                is_rx      = new_chdev->is_rx;
-                server     = new_chdev->server;
-                server_lid = new_lid;
-                fifo = &mtty_rx_fifo[channel];
-                continue;
-            }
-
-            // filter special character ^Z  => block TXT owner process
-            if( byte == 0x1A ) 
-            {
+            // test physical RX channel state
+            if( mty_rx_not_new == false )      // get first byte (virtual channel index)
+            {
+                // register virtual channel index
+                mty_rx_channel = (uint32_t)byte;
+
+                // update physical RX channel state
+                mty_rx_not_new = true;
+            }
+            else                               // get second byte (character value)
+            {
+                // get virtual channel index registered
+                channel = mty_rx_channel;
+
+                // get destination TX_FIFO
+                fifo = &mty_rx_fifo[channel];
+
+                // filter special character ^Z  => block TXT owner process
+                if( byte == 0x1A ) 
+                {
 
 #if DEBUG_HAL_TXT_RX
@@ -368 +317 @@
 printk("\n[DBG] %s : read ^Z character from TXT%d\n", __FUNCTION__, channel );
 #endif
-                // get pointers on TXT owner process in owner cluster
-                owner_xp  = process_txt_get_owner( channel );
+                    // get pointers on TXT owner process in owner cluster
+                    owner_xp  = process_txt_get_owner( channel );
                
-                // check process exist
-                assert( (owner_xp != XPTR_NULL) , __FUNCTION__, 
-                "TXT owner process not found\n" );
-
-                // get relevant infos on TXT owner process
-                owner_cxy = GET_CXY( owner_xp );
-                owner_ptr = GET_PTR( owner_xp );
-                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
-
-                // block TXT owner process only if it is not the INIT process 
-                if( owner_pid != 1 )
+                    // check process exist
+                    assert( (owner_xp != XPTR_NULL) , __FUNCTION__, 
+                    "TXT owner process not found\n" );
+
+                    // get relevant infos on TXT owner process
+                    owner_cxy = GET_CXY( owner_xp );
+                    owner_ptr = GET_PTR( owner_xp );
+                    owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
+
+                    // block TXT owner process only if it is not the INIT process 
+                    if( owner_pid != 1 )
+                    {
+                        // get parent process descriptor pointers
+                        parent_xp = hal_remote_l64( XPTR( owner_cxy , 
+                                                    &owner_ptr->parent_xp ) );
+                        parent_cxy = GET_CXY( parent_xp );
+                        parent_ptr = GET_PTR( parent_xp );
+
+                        // get pointers on the parent process main thread
+                        parent_main_ptr = hal_remote_lpt( XPTR(parent_cxy,
+                                                          &parent_ptr->th_tbl[0])); 
+                        parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
+
+                        // transfer TXT ownership 
+                        process_txt_transfer_ownership( owner_xp );
+
+                        // block all threads in all clusters, but the main thread
+                        process_sigaction( owner_pid , BLOCK_ALL_THREADS );
+
+                        // block the main thread
+                        xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
+                        thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
+
+                        // atomically update owner process termination state
+                        hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
+                                              PROCESS_TERM_STOP );
+
+                        // take the children lock and unblock the parent process main thread 
+                        thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
+
+                        return;
+                    }
+                }
+
+                // filter special character ^C  => kill TXT owner process
+                if( byte == 0x03 )
                 {
-                    // get parent process descriptor pointers
-                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
-                    parent_cxy = GET_CXY( parent_xp );
-                    parent_ptr = GET_PTR( parent_xp );
-
-                    // get extended pointer on lock protecting children list in parent process
-                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock ); 
-
-                    // get pointers on the parent process main thread
-                    parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0])); 
-                    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
-
-                    // transfer TXT ownership 
-                    process_txt_transfer_ownership( owner_xp );
-
-                    // block all threads in all clusters, but the main thread
-                    process_sigaction( owner_pid , BLOCK_ALL_THREADS );
-
-                    // block the main thread
-                    xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
-                    thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
-
-                    // atomically update owner process termination state
-                    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
-                                          PROCESS_TERM_STOP );
-
-                    // take the children lock and unblock the parent process main thread 
-                    remote_spinlock_lock( children_lock_xp );
-                    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
-                    remote_spinlock_unlock( children_lock_xp );
-
-                    return;
-                }
-            }
-
-            // filter special character ^C  => kill TXT owner process
-            if( byte == 0x03 )
-            {
 
 #if DEBUG_HAL_TXT_RX
@@ -426 +372 @@
 printk("\n[DBG] %s : read ^C character from TXT%d\n", __FUNCTION__, channel );
 #endif
-                // get pointer on TXT owner process in owner cluster
-                owner_xp  = process_txt_get_owner( channel );
-
-                // check process exist
-                assert( (owner_xp != XPTR_NULL) , __FUNCTION__,
-                "TXT owner process not found\n" );
-
-                // get relevant infos on TXT owner process
-                owner_cxy = GET_CXY( owner_xp );
-                owner_ptr = GET_PTR( owner_xp );
-                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
-
-                // kill TXT owner process only if it is not the INIT process
-                if( owner_pid != 1 )
+                    // get pointer on TXT owner process in owner cluster
+                    owner_xp  = process_txt_get_owner( channel );
+
+                    // check process exist
+                    assert( (owner_xp != XPTR_NULL) , __FUNCTION__,
+                    "TXT owner process not found\n" );
+
+                    // get relevant infos on TXT owner process
+                    owner_cxy = GET_CXY( owner_xp );
+                    owner_ptr = GET_PTR( owner_xp );
+                    owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
+
+                    // kill TXT owner process only if it is not the INIT process
+                    if( owner_pid != 1 )
+                    {
+                        // get parent process descriptor pointers
+                        parent_xp  = hal_remote_l64( XPTR( owner_cxy,
+                                                     &owner_ptr->parent_xp ) );
+                        parent_cxy = GET_CXY( parent_xp );
+                        parent_ptr = GET_PTR( parent_xp );
+
+                        // get pointers on the parent process main thread
+                        parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy,
+                                                          &parent_ptr->th_tbl[0])); 
+                        parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
+
+                        // remove process from TXT list
+                        process_txt_detach( owner_xp );
+
+                        // mark for delete all thread in all clusters, but the main
+                        process_sigaction( owner_pid , DELETE_ALL_THREADS );
+                
+                        // block main thread
+                        xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
+                        thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
+
+                        // atomically update owner process termination state
+                        hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
+                                              PROCESS_TERM_KILL );
+
+                        // take the children lock and unblock the parent process main thread 
+                        thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
+
+                        return;
+                    }
+                }
+
+                // write byte in RX FIFO if not full / discard byte if full
+                if ( fifo->sts < MTY_FIFO_DEPTH )
                 {
-                    // get parent process descriptor pointers
-                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
-                    parent_cxy = GET_CXY( parent_xp );
-                    parent_ptr = GET_PTR( parent_xp );
-
-                    // get extended pointer on lock protecting children list in parent process
-                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock ); 
-
-                    // get pointers on the parent process main thread
-                    parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0])); 
-                    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
-
-                    // remove process from TXT list
-                    process_txt_detach( owner_xp );
-
-                    // mark for delete all thread in all clusters, but the main
-                    process_sigaction( owner_pid , DELETE_ALL_THREADS );
-                
-                    // block main thread
-                    xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
-                    thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
-
-                    // atomically update owner process termination state
-                    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
-                                          PROCESS_TERM_KILL );
-
-                    // take the children lock and unblock the parent process main thread 
-                    remote_spinlock_lock( children_lock_xp );
-                    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
-                    remote_spinlock_unlock( children_lock_xp );
-
-                    return;
-                }
-            }
-
-            // write byte in MTTY_RX FIFO if not full / discard byte if full
-            if ( fifo->sts < MTTY_FIFO_DEPTH )
-            {
 
 #if DEBUG_HAL_TXT_RX
@@ -485 +428 @@
 __FUNCTION__, byte, channel );
 #endif
-                // store byte into FIFO 
-                fifo->data[fifo->ptw] = (char)byte; 
-
-                // avoid race 
-                hal_fence();
-
-                // update RX_FIFO state
-                fifo->ptw = (fifo->ptw + 1) % MTTY_FIFO_DEPTH;
-                hal_atomic_add( &fifo->sts , 1 );
-
-                // unblock TXT_RX server thread 
-                thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
-
-                // send IPI to core running server thread
-                dev_pic_send_ipi( local_cxy , server_lid );
-            }
-            else
-            {
-                printk("\n[WARNING] %s : MTTY_RX_FIFO[%d] full => discard character <%x>\n",
-                __FUNCTION__, channel, (uint32_t)byte );
-            }
-        }  // end while MTTY_READ register full
-
+                    // store byte into FIFO 
+                    fifo->data[fifo->ptw] = (char)byte; 
+
+                    // avoid race 
+                    hal_fence();
+
+                    // update RX_FIFO state
+                    fifo->ptw = (fifo->ptw + 1) % MTY_FIFO_DEPTH;
+                    hal_atomic_add( &fifo->sts , 1 );
+
+                    // unblock TXT_RX server thread 
+                    thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
+
+                    // send IPI to core running server thread
+                    dev_pic_send_ipi( local_cxy , server_lid );
+                }
+                else
+                {
+                    printk("\n[WARNING] %s : MTY_RX_FIFO[%d] full => discard char <%x>\n",
+                    __FUNCTION__, channel, (uint32_t)byte );
+                }
+
+                // update physical RX channel state
+                mty_rx_not_new = true;
+
+            }  // end get character value
+        }  // end if byte available in MTY_READ register
     }  // end RX
 
@@ -513 +460 @@
     else
     {
-        fifo = &mtty_tx_fifo[channel];
-
-        // try to move bytes until TX_FIFO empty
-        while( fifo->sts > 0 )
+        // test physical TX channel state
+        if( mty_tx_not_new == false )      // send first byte (virtual channel index)
         {
-            // write one byte to MTTY_WRITE register if empty / exit loop if full
-            if( (hal_remote_lw( status_xp ) & MTTY_STATUS_TX_FULL) == 0 ) 
-            {
-                // get one byte from TX_FIFO
+            // scan the set of the TX_FIFO
+            for( n = 0 , found = false ; n < CONFIG_MAX_TXT_CHANNELS ; n++ )
+            {
+                // implement round-robin policy
+                channel = (n + mty_tx_last + 1) % CONFIG_MAX_TXT_CHANNELS;
+
+                // get pointer on TX_FIFO[channel]
+                fifo = &mty_tx_fifo[channel];
+
+                if( fifo->sts > 0 )
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            // get one byte from TX_FIFO if found and send channel index
+            if( found ) 
+            {
+                // get one byte from selected TX_FIFO
                 byte = fifo->data[fifo->ptr];
 
@@ -530 +491 @@
 #endif
                 // update TX_FIFO state
-                fifo->ptr = (fifo->ptr + 1) % MTTY_FIFO_DEPTH;
+                fifo->ptr = (fifo->ptr + 1) % MTY_FIFO_DEPTH;
                 hal_atomic_add( &fifo->sts , -1 );
 
-                // write byte to MTTY_WRITE register & acknowledge TX_IRQ
-                hal_remote_sb( write_xp , byte );
+                // update TX physical channel state
+                mty_tx_value   = (uint32_t)byte;
+                mty_tx_not_new = true;
+                mty_tx_last    = channel;
+
+                // write virtual channel index to TX_WRITE register
+                hal_remote_sb( write_xp , (uint8_t)channel );
+
+                // unblock TXT_TX server thread
+                thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
+
+                // send IPI to core running server thread
+                dev_pic_send_ipi( local_cxy , server_lid );
             }
         }
-
-        // disable TX_IRQ 
-        //      vci_multi_tty devices never raise TX IRQs
-        //      so the following instructions are useless
-        //      and moreover they kernel panic
-        // xptr_t config_xp = XPTR( tty_cxy , base + MTTY_CONFIG );
-        // uint32_t old = hal_remote_lw( config_xp );
-        // uint32_t new = old & ~(MTTY_CONFIG_TX_ENABLE);
-        // hal_remote_atomic_cas( config_xp , old , new );
-        // hal_remote_sw( XPTR( tty_cxy , base + MTTY_CONFIG ) , 0 );
-
-        // unblock TXT_TX server thread
-        thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
-
-        // send IPI to core running server thread
-        dev_pic_send_ipi( local_cxy , server_lid );
-
+        else                             // send second byte (character value) 
+        {
+            // write registered character value to TX_WRITE register
+            hal_remote_sb( write_xp , (uint8_t)mty_tx_value );
+
+            // update TX physical channel state
+            mty_tx_not_new = false;
+        }  // end if MTY_WRITE register empty
     }  // end TX
 
     hal_fence();
 
-#if (DEBUG_SYS_READ & 1)
-if( is_rx ) exit_tty_isr_read = (uint32_t)hal_get_cycles();
-#endif
-
-#if (DEBUG_SYS_WRITE & 1)
-if( is_rx == 0 ) exit_tty_isr_write = (uint32_t)hal_get_cycles();
-#endif
-
-}  // end soclib_mtty_isr()
+}  // end soclib_mty_isr()
 
 /////////////////////////////////////////////////////////////
-void __attribute__ ((noinline)) soclib_mtty_aux( void * args )
+void __attribute__ ((noinline)) soclib_mty_aux( void * args )
 {
-    xptr_t     dev_xp = ((txt_sync_args_t *)args)->dev_xp;
-    char     * buffer = ((txt_sync_args_t *)args)->buffer;
-    uint32_t   count  = ((txt_sync_args_t *)args)->count;
-    uint32_t   channel = ((txt_sync_args_t *)args)->channel;
+    uint32_t   i;
+
+    xptr_t       dev_xp  = ((txt_sync_args_t *)args)->dev_xp;
+    const char * buffer  = ((txt_sync_args_t *)args)->buffer;
+    uint32_t     count   = ((txt_sync_args_t *)args)->count;
+    uint32_t     channel = ((txt_sync_args_t *)args)->channel;
     
-    // get TXT0 chdev cluster and local pointer
+    // get chdev cluster and local pointer
     cxy_t     dev_cxy = GET_CXY( dev_xp );
-    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
-
-    // get extended pointer on TTY channel base address
-    xptr_t tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
-
-    // get TTY channel segment cluster and local pointer
-    cxy_t      tty_cxy = GET_CXY( tty_xp );
-    uint32_t * tty_ptr = (uint32_t *)GET_PTR( tty_xp );
-
-    // get extended pointers on MTTY_WRITE & MTTY_STATUS registers
-    xptr_t write_xp  = XPTR( tty_cxy , tty_ptr + MTTY_WRITE );
-    xptr_t status_xp = XPTR( tty_cxy , tty_ptr + MTTY_STATUS );
-
-    // loop on characters (busy waiting policy)
-    uint32_t   i;
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
+
+    // get extended pointer on MTY channel base address
+    xptr_t mty_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
+
+    // get MTY channel segment cluster and local pointer
+    cxy_t      mty_cxy = GET_CXY( mty_xp );
+    uint32_t * mty_ptr = GET_PTR( mty_xp );
+
+    // get extended pointers on MTY_WRITE & MTY_STATUS registers
+    xptr_t write_xp  = XPTR( mty_cxy , mty_ptr + MTY_WRITE );
+    xptr_t status_xp = XPTR( mty_cxy , mty_ptr + MTY_STATUS );
+
+    // loop on characters (two bytes per character)
     for( i = 0 ; i < count ; i++ )
     {
-        // This is the MTTY multiplexing
-        // Before each character, we send the destination (RX) TTY number for this char.
-        // The two bytes (dest number + char) must be sent consecutively,
-        // so to guarantee this atomicity, we use a lock to prevent other
-        // concurrent server DEV threads to write a byte in between our two bytes
-
-        // Send the destination TTY number
-        // HACK: Remove this on the Lety physical prototype.
-        // This 'if' is here so that the kernel messages in simulation are readable
-        bool_t empty = false;
-        if (channel > 0) {
-            // For examples, "Hello" would appear "0H0e0l0l0o" on the simulation terminal
-            do {
-                // get MTTY_STATUS
-                uint32_t status = hal_remote_lw( status_xp );
-                empty  = ( (status & MTTY_STATUS_TX_FULL) == 0 );
-
-                // transfer one byte if TX buffer empty
-                if ( empty ) {
-                    hal_remote_sb( write_xp , channel + '0' );
-                }
-            } while ( empty == false );
-        }
-
-        // Send the character
-        do {
-            // get MTTY_STATUS
-            uint32_t status = hal_remote_lw( status_xp );
-            empty  = ( (status & MTTY_STATUS_TX_FULL) == 0 );
-
-            // transfer one byte if TX buffer empty
-            if ( empty ) {
-                hal_remote_sb( write_xp , buffer[i] );
-            }
-        } while ( empty == false );
+        // write virtual channel index to MTY_WRITE register
+        hal_remote_sb( write_xp , (uint8_t)channel );
+
+        // write character value to MTY_WRITE register
+        hal_remote_sb( write_xp , buffer[i] );
     }
-}  // end soclib_mtty_aux()
-
-
-
+}  // end soclib_mty_aux()
+
+
+

trunk/hal/tsar_mips32/drivers/soclib_mty.h

@@ -1 +1 @@
 /*
- * soclib_multi_tty.c - soclib tty driver definition.
+ * soclib_mty.c - soclib_mty driver definition (used in TSAR-LETI architecture).
  *
- * Author  Alain Greiner (2016)
+ * Author  Alain Greiner (2016,2017,2018)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -24 +24 @@
 #include <dev_txt.h>
 #include <chdev.h>
-#include <spinlock.h>
 
 
 /****************************************************************************************
- * This driver supports the soclib_multi_tty component.
+ * This driver supports the "backup" TTY controler implemented in cluster 0
+ * of the TSAR-LETI architecture, that is actually an over-simplified version
+ * of the vci_tty_tsar component:
+ *
+ * 1) This hardware component handles only ONE TTY physical channel, that must 
+ *    be virtualized by the driver to support several kernel TXT devices.
+ * 2) For received characters, the hardware support one RX_IRQ, and one bit 
+ *    in the MTY_STATUS register to signal that the MTY_READ register is full. 
+ * 3) For transmitted characters, the hardware does NOT provide a TX_IRQ, 
+ *    and does NOT provide status information about the MTY_WRITE register,
+ *    but implement a low-level flow control mechanism: the response to the
+ *    VCI write request in MTY_WRITE register is blocked until this register
+ *    can be actually written...
+ *
  * It implements the generic TXT device API:
  * - transfer one single character from TTY to command "buffer" if to_mem is non-zero.
  * - transfer "count" characters from command "buffer" to TTY if "to_mem is zero.
+ *
+ * It handles asynchronous control characters (^C / ^Z), that are translated to signals
+ * transmited to the TXT owner process (foreground process).
+ *
+ * This driver implements one TX_FIFO for the transmited characters, writen by the "cmd"
+ * function, and read by the "isr" function).
+ * This driver implements one RX_FIFO for the received characters, writen by the "isr"
+ * function, and read by the "cmd" function).
+***************************************************************************************/
+
+/****************************************************************************************
+ *     SOCLIB_MTY registers offsets and masks
  ***************************************************************************************/
 
+#define MTY_WRITE              0
+#define MTY_STATUS             1
+#define MTY_READ               2
+#define MTY_CONFIG             3
+
 /****************************************************************************************
- *     SOCLIB_TTY registers offsets
+ * masks for MTY_STATUS and MTY_CONFIG registers
  ***************************************************************************************/
 
-#define MTTY_WRITE              0
-#define MTTY_STATUS             1
-#define MTTY_READ               2
-#define MTTY_CONFIG             3
+#define MTY_STATUS_RX_FULL     1          // TTY_READ_REG full if 1
 
-#define MTTY_SPAN               4  
+#define MTY_CONFIG_RX_ENABLE   1          // RX_IRQ enable if 1
 
 /****************************************************************************************
- * masks for TTY_STATUS_REG
+ * This structure is used for both the RX_FIFO and the TX_FIFO.
  ***************************************************************************************/
 
-#define MTTY_STATUS_RX_FULL     1       // TTY_READ_REG full if 1
-#define MTTY_STATUS_TX_FULL     2       // TTY_WRITE_REG full if 1
+#define MTY_FIFO_DEPTH  128
 
-/****************************************************************************************
- * masks for TTY_CONFIG_REG
- ***************************************************************************************/
-
-#define MTTY_CONFIG_RX_ENABLE   1       // TTY_RX IRQ enabled if 1
-#define MTTY_CONFIG_TX_ENABLE   2       // TTY_TX IRQ enabled if 1
-
-/****************************************************************************************
- * This Rstructure is used by the soclib_multi_tty_isr for the RX channel.
- ***************************************************************************************/
-
-#define MTTY_FIFO_DEPTH  128
-
-typedef struct mtty_fifo_s     // 32 bytes
+typedef struct mty_fifo_s 
 {
-    char          data[MTTY_FIFO_DEPTH];   // one char per slot
+    char          data[MTY_FIFO_DEPTH];   // one char per slot
     unsigned int  ptr;                    // next free slot index
     unsigned int  ptw;                    // next full slot index
     unsigned int  sts;                    // number of full slots
-} mtty_fifo_t;
- 
+}
+mty_fifo_t;
 
 /****************************************************************************************
- * This function masks both the TTY_RX and TTY_TX IRQs.
- * These IRQs are unmasked by the soclib_multi_tty_cmd() function.
+ * This function masks the TTY_RX IRQ.
  ****************************************************************************************
  * @ chdev     : pointer on the TXT chdev descriptor.
  ***************************************************************************************/
-void soclib_mtty_init( chdev_t * chdev );
+void soclib_mty_init( chdev_t * chdev );
 
 /****************************************************************************************
@@ -87 +98 @@
  * different chdevs (and consequently two diffeerent server threads) for the RX and TX
  * directions. The client thread is identified by the <thread_xp> argument.
- * Depending on the command type, it unmasks the relevant TTY_RX / TTY_TX IRQ,
- * and blocks the TXT device server thread on the THREAD_BLOCKED_DEV_ISR, as the data
- * transfer is done by the ISR.
+ * These functions are supposed to be called by the server thread associated at a
+ * given TXT channel for a given direction (TX or RX).
+ * Depending on the command type, it access the TX_FIFO or RX_FIFO, and blocks the TXT
+ * device server thread on the THREAD_BLOCKED_DEV_ISR, if the RX_FIFO is empty (for a
+ * READ), or if the TX_FIFO is full for a WRITE). 
+ * The actual transfer between the FIFOs and the TTY device registers is done by the ISR.
  * ****************************************************************************************
  * @ thread_xp : extended pointer on client thread descriptor.
  ***************************************************************************************/
-void soclib_mtty_cmd( xptr_t thread_xp );
+void soclib_mty_cmd( xptr_t thread_xp );
 
 /****************************************************************************************
  * This function implements the TXT_SYNC_WRITE command registered in the txt_aux_t
- * structure, using a busy waiting policy, without using the TTY IRQ.
+ * structure. As the MTY hardware component does not provide any status information,
+ * it relies on the "blocking write" mechanism to the MTY_REGISTER for flow-control. 
  * It is used by the kernel do display debug messages on TXT0 terminal, without
  * interference with another TXT access to another terminal done by the same thread.
@@ -103 +118 @@
  * @ thread_xp : pointer on the txt_aux_t structure containing the arguments.
  ***************************************************************************************/
-void soclib_mtty_aux( void * args );
+void soclib_mty_aux( void * args );
 
 /****************************************************************************************
- * This ISR is executed to handle both the TTY_TX_IRQ and the TTY_RX_IRQ, even if
- *   The RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is 1 in the
- *   TTY_STATUS register, when the TTY_RX_IRQ_ENABLE is non zero, indicating that
- *   the TTY_READ buffer is full and can be read.
- *   The TX_IRQ is activated as soon as the TTY_STATUS_TX_FULL bit is 0 in the
- *   TTY_STATUS register, when the TTY_TX_IRQ_ENABLE is non zero, indicating that
- *   the TTY_WRITE buffer is empty, and can be written.
- * WARNING : In ALMOS-MKH, the RX_IRQ is always enabled to catch the control signals,
- * but the TX_IRQ is dynamically enabled by the TXT_WRITE command, and disabled when
- * the command is completed.
+ * This ISR is executed to handle both TX and RX transfers:
+ * It is also in charge of multiplexing / demultiplexing the characters between
+ * one single physical channel, and several virtual channels.
+ * There is one couple of TX_FIFO / RX_FIFO per virtual channel, and each FIFO can be
+ * located in a different cluster (in the same cluster as the associated chdev).
  *
- * 1) The ISR first read the TTY_STATUS to get the current state of the TTY_READ and
- *   the TTY_WRITE buffers.
+ * For both TX and TX, a character on the physical channel is encoded as two bytes:
+ * The first byte contains the virtual channel index. The second byte contains 
+ * the ascii character value. 
  *
- * 2) It try to read the first command registered in the server thread queue associated 
- *    to the TTY channel
+ * - For RX, this ISR is called to move one character from the MTY_READ register to
+ *   the relevant RX_FIFO when the MTY_RX_IRQ is activated (when the MTY_STATUS_RX_FULL 
+ *   bit, and the MTY_CONFIG_RX_ENABLE bit are both set), indicating that the MTY_READ
+ *   register is full and can be read. As there is one single physical channel,
+ *   there is one single MTY_RX_IRQ, that is routed to one single core that dispatch
+ *   each received character to the relevant (likely remote) RX_FIFO.
+ *   This core is supposed to be located in the same cluster as the MTY peripheral.
+ *    
+ * - For TX, there is no TX_IRQ handled by the MTY controller, and no status bit.
+ *   Therefore, this ISR is called to move one character from one TX_FIFO to the
+ *   MTY_WRITE register at each TICK event, and relies on the "blocking write"
+ *   mechanism to the MTY_REGISTER for flow-control. 
+ *   As there is one single physical channel, this ISR is executed by one single core 
+ *   that scan the (likely remote) TX_FIFOs associated to all virtual channels, 
+ *   and transmit the first found character, with a round_robin policy between channels.
+ *   This core is supposed to be located in the same cluster as the MTY peripheral.
  *
- * 2) The ISR handles the RX when the TTY_READ buffer is full :
- *   . it read the available character from the TTY_READ buffer, and this
- *     acknowledges the RX_IRQ.
- *   . if it is a control character ( ^C / ^D / ^Z ) it translate it to the proper
- *     signal and execute the relevant sigaction for the foreground process.
- *   . if it is a normal character, it try to get the first command registered in the 
- *     server thread queue. If it is a TXT_READ, it returns this character to the 
- *     command buffer in the client thread.
- * 
- * 3) The ISR handles the TX when the TTY_WRITE buffer is empty and a TXT_WRITE
- *   . it try to get it copies the
- *     character to the command buffer, acknowledges the TTY_RX_IRQ, and unblock the 
- *     associated server thread.
-     
- *   . the control characters ^C / ^D / ^Z  are directly handled by the ISR and
- *     translated to the foreground process.
-
- * - the 
- the TXT_READ and TXT_WRITE commands.
- * It gets the command arguments from the first client thread in the TXT chdev queue:
- * - if TXT_READ, it transfers one byte from the TTY_READ_REG to the command buffer.
- *   It simply returns for retry if TTY_READ_REG is empty.
- * - if TXT_WRITE, it tries to transfer several bytes from the command buffer to the
- *   TTY_WRITE_REG. If the TTY_WRITE_REG is full, it updates the "count" and "buffer"
- *   command arguments and returns for retry.
- * When the I/O operation is completed, it sets the status field in the command, unblocks
- * the server thread, and unblocks the client thread.
+ * The RX_IRQ is always enabled to catch the control characters (^C / ^D / ^Z),
+ * that are not copied in the RX_FIFO, but directly analysed by the ISR
+ * and signaled to the TXT owner process (foreground process).
  ****************************************************************************************
  * @ chdev     : local pointer on TXT chdev descriptor.
  ***************************************************************************************/
-void soclib_mtty_isr( chdev_t * chdev );
+void soclib_mty_isr( chdev_t * chdev );
 

trunk/hal/tsar_mips32/drivers/soclib_nic.c

@@ -27 +27 @@
 #include <chdev.h>
 #include <dev_nic.h>
-#include <spinlock.h>
 #include <kmem.h>
 #include <printk.h>
@@ -49 +48 @@
 
     // initialize Soclib NIC global registers 
-    hal_remote_sw( XPTR( nic_cxy , nic_ptr + NIC_GLOBAL_SPAN + NIC_G_BC_ENABLE ) , 0 );
-    hal_remote_sw( XPTR( nic_cxy , nic_ptr + NIC_GLOBAL_SPAN + NIC_G_RUN       ) , 0 );
+    hal_remote_s32( XPTR( nic_cxy , nic_ptr + NIC_GLOBAL_SPAN + NIC_G_BC_ENABLE ) , 0 );
+    hal_remote_s32( XPTR( nic_cxy , nic_ptr + NIC_GLOBAL_SPAN + NIC_G_RUN       ) , 0 );
 
     // allocate memory for chbuf descriptor (one page)
@@ -296 +295 @@
 
     // read NIC channel status and acknowledge IRQ
-    uint32_t status = hal_remote_lw( XPTR( cxy_nic , offset ) );
+    uint32_t status = hal_remote_l32( XPTR( cxy_nic , offset ) );
 
     assert( status != 0, "Illegal address: \n" );

trunk/hal/tsar_mips32/drivers/soclib_pic.c

@@ -49 +49 @@
 //////////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////
+/////////////////////////////////////
 uint32_t soclib_pic_wti_alloc( void )
 {
@@ -68 +68 @@
 }  // end soclib_pic_wti_alloc()
 
-///////////////////////////////////////
+/////////////////////////////////////////////
 inline uint32_t * soclib_pic_xcu_base( void )
 {
@@ -111 +111 @@
 }
 
-/////////////////////////////
+///////////////////////////////////
 void soclib_pic_irq_handler( void )
 {
@@ -156 +156 @@
 
             // check RPC FIFO,  and activate or create a RPC thread
-            // condition is always true, but we use the ack value
-            // to avoid a GCC warning
-            if( ack + 1 ) rpc_check();
+            // (condition is always true, but we use the ack value to avoid a GCC warning)
+            if( ack + 1 ) sched_yield("IPI received");
         }
         ////////////////////////////////////////////////////////////////
@@ -267 +266 @@
         xptr_t iopic_seg_xp = XPTR( iopic_seg_cxy,
                                     iopic_seg_ptr + i*IOPIC_SPAN + IOPIC_MASK ); 
-        hal_remote_sw( iopic_seg_xp , 0 ); 
+        hal_remote_s32( iopic_seg_xp , 0 ); 
     }
 
@@ -358 +357 @@
 
     // get extended and local pointers on IOPIC  segment base
-    xptr_t     seg_pic_xp  = hal_remote_lwd( XPTR( pic_cxy , &pic_ptr->base ) );
+    xptr_t     seg_pic_xp  = hal_remote_l64( XPTR( pic_cxy , &pic_ptr->base ) );
     cxy_t      seg_pic_cxy = GET_CXY( seg_pic_xp );
     uint32_t * seg_pic_ptr = (uint32_t *)GET_PTR( seg_pic_xp );
@@ -399 +398 @@
         xptr_t   lsb_xp = XPTR( seg_pic_cxy , seg_pic_ptr+hwi_id*IOPIC_SPAN+IOPIC_ADDRESS );
         xptr_t   msb_xp = XPTR( seg_pic_cxy , seg_pic_ptr+hwi_id*IOPIC_SPAN+IOPIC_EXTEND );
-        hal_remote_sw( lsb_xp , lsb_wdata );
-        hal_remote_sw( msb_xp , msb_wdata );
+        hal_remote_s32( lsb_xp , lsb_wdata );
+        hal_remote_s32( msb_xp , msb_wdata );
 
         // enable IRQ in IOPIC
-        hal_remote_sw( XPTR( seg_pic_cxy , seg_pic_ptr+hwi_id*IOPIC_SPAN+IOPIC_MASK ), 1 );
+        hal_remote_s32( XPTR( seg_pic_cxy , seg_pic_ptr+hwi_id*IOPIC_SPAN+IOPIC_MASK ), 1 );
 
         // update the WTI interrupt vector for core[lid]
@@ -460 +459 @@
 
     // get the source chdev IRQ type and index
-    uint32_t irq_type = hal_remote_lw( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_type ) );
-    uint32_t irq_id   = hal_remote_lw( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_id ) );
+    uint32_t irq_type = hal_remote_l32( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_type ) );
+    uint32_t irq_id   = hal_remote_l32( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_id ) );
 
     if( irq_type == SOCLIB_TYPE_HWI )
@@ -467 +466 @@
         // enable this HWI in remote XCU controller 
         // in TSAR : XCU output [4*lid] is connected to core [lid]
-        hal_remote_sw( XPTR( src_chdev_cxy , 
+        hal_remote_s32( XPTR( src_chdev_cxy , 
                        &seg_xcu_ptr[ (XCU_MSK_HWI_ENABLE << 5) | (lid<<2) ] ) , (1 << irq_id) );
     }
@@ -474 +473 @@
         // enable this WTI in remote XCU controller 
         // in TSAR : XCU output [4*lid] is connected to core [lid]
-        hal_remote_sw( XPTR( src_chdev_cxy , 
+        hal_remote_s32( XPTR( src_chdev_cxy , 
                        &seg_xcu_ptr[ (XCU_MSK_WTI_ENABLE << 5) | (lid<<2) ] ) , (1 << irq_id) );
     }
@@ -495 +494 @@
 
     // get the source chdev IRQ type and index
-    uint32_t irq_type = hal_remote_lw( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_type ) );
-    uint32_t irq_id   = hal_remote_lw( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_id ) );
+    uint32_t irq_type = hal_remote_l32( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_type ) );
+    uint32_t irq_id   = hal_remote_l32( XPTR( src_chdev_cxy , &src_chdev_ptr->irq_id ) );
 
     if( irq_type == SOCLIB_TYPE_HWI )
@@ -502 +501 @@
         // enable this HWI in remote XCU controller
         // in TSAR : XCU output [4*lid] is connected to core [lid]
-        hal_remote_sw( XPTR( src_chdev_cxy , 
+        hal_remote_s32( XPTR( src_chdev_cxy , 
                        &seg_xcu_ptr[(XCU_MSK_HWI_DISABLE << 5) | (lid<<2) ] ) , (1 << irq_id) );
     }
@@ -509 +508 @@
         // enable this WTI in remote XCU controller 
         // in TSAR : XCU output [4*lid] is connected to core [lid]
-        hal_remote_sw( XPTR( src_chdev_cxy , 
+        hal_remote_s32( XPTR( src_chdev_cxy , 
                        &seg_xcu_ptr[(XCU_MSK_WTI_DISABLE << 5) | (lid<<2) ] ) , (1 << irq_id) );
     }
@@ -558 +557 @@
 
     // write to WTI mailbox[cxy][lid]
-    hal_remote_sw( XPTR( cxy , &base[(XCU_WTI_REG << 5) | lid ] ) , 0 );
+    hal_remote_s32( XPTR( cxy , &base[(XCU_WTI_REG << 5) | lid ] ) , 0 );
 }
 

trunk/hal/tsar_mips32/drivers/soclib_tty.c

@@ -6 +6 @@
  * Copyright (c)  UPMC Sorbonne Universites
  *
- * This file is part of ALMOS-MKH..
+ * This file is part of ALMOS-MKH.
  *
  * ALMOS-MKH. is free software; you can redistribute it and/or modify it
@@ -12 +12 @@
  * the Free Software Foundation; version 2.0 of the License.
  *
- * ALMOS-MKH. is distributed in the hope that it will be useful, but
+ * 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 PARTICULAR PURPOSE.  See the GNU
@@ -18 +18 @@
  *
  * You should have received a copy of the GNU General Public License
- * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
@@ -27 +27 @@
 #include <chdev.h>
 #include <soclib_tty.h>
-#include <remote_spinlock.h>
 #include <thread.h>
 #include <printk.h>
@@ -50 +49 @@
 ////////////////////////////////////////////////////////////////////////////////////
 // These global variables implement the TTY_RX  FIFOs (one per channel)
+////////////////////////////////////////////////////////////////////////////////////
+// Implementation note:
+// We allocate - in each cluster - two arrays of FIFOs containing as many entries
+// as the total number of TXT channels, but all entries are not used in all
+// clusters: for a given cluster K, a given entry corresponding to a given channel
+// and a given direction is only used if the associated chdev is in cluster K.
+// With this policy, the driver can ignore the actual placement of chdevs.
 ////////////////////////////////////////////////////////////////////////////////////
 
@@ -79 +85 @@
     // set TTY_RX_IRQ_ENABLE 
     reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_RX_IRQ_ENABLE );
-    hal_remote_sw( reg_xp , 1 );
+    hal_remote_s32( reg_xp , 1 );
 
     // reset TTY_TX_IRQ_ENABLE
     reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_TX_IRQ_ENABLE );
-    hal_remote_sw( reg_xp , 0 );
+    hal_remote_s32( reg_xp , 0 );
 
     // reset relevant FIFO
@@ -112 +118 @@
 
     // get command arguments
-    uint32_t type     = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.type   ) );
-    xptr_t   buf_xp   = hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
-    uint32_t count    = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.count  ) );
+    uint32_t type     = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.type   ) );
+    xptr_t   buf_xp   = hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
+    uint32_t count    = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.count  ) );
     xptr_t   error_xp = XPTR( th_cxy , &th_ptr->txt_cmd.error );
 
@@ -126 +132 @@
 
     // get TXT device cluster and pointers
-    xptr_t     dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
+    xptr_t     dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
     cxy_t      dev_cxy = GET_CXY( dev_xp );
     chdev_t  * dev_ptr = GET_PTR( dev_xp );
 
     // get cluster and pointers for SOCLIB_TTY peripheral base segment
-    xptr_t     tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
+    xptr_t     tty_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
     cxy_t      tty_cxy = GET_CXY( tty_xp );
     uint32_t * tty_ptr = GET_PTR( tty_xp );
 
     // get TTY channel index and channel base address
-    uint32_t   channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) );
+    uint32_t   channel = hal_remote_l32( XPTR( dev_cxy , &dev_ptr->channel ) );
     uint32_t * base    = tty_ptr + TTY_SPAN * channel;
 
@@ -173 +179 @@
 
                 // enable TX_IRQ 
-                hal_remote_sw( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 1 );
+                hal_remote_s32( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 1 );
             }
             else                                // block & deschedule if TX_FIFO full
@@ -186 +192 @@
 
         // set error status in command and return
-        hal_remote_sw( error_xp , 0 );
+        hal_remote_s32( error_xp , 0 );
     }
     ///////////////////////////
@@ -229 +235 @@
 
         // set error status in command
-        hal_remote_sw( error_xp , 0 );
+        hal_remote_s32( error_xp , 0 );
     }
     else
@@ -268 +274 @@
     cxy_t        parent_cxy;        // parent process cluster
     process_t  * parent_ptr;        // local pointer on parent process
-    xptr_t       children_lock_xp;  // extended pointer on children processes lock
     thread_t   * parent_main_ptr;   // extended pointer on parent process main thread
     xptr_t       parent_main_xp;    // local pointer on parent process main thread
@@ -312 +317 @@
 
         // try to move bytes until TTY_READ register empty
-        while( hal_remote_lw( status_xp ) & TTY_STATUS_RX_FULL )   
+        while( hal_remote_l32( status_xp ) & TTY_STATUS_RX_FULL )   
         {
             // get one byte from TTY_READ register & acknowledge RX_IRQ
@@ -335 +340 @@
                 owner_cxy = GET_CXY( owner_xp );
                 owner_ptr = GET_PTR( owner_xp );
-                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
+                owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
 
                 // block TXT owner process only if it is not the INIT process 
@@ -341 +346 @@
                 {
                     // get parent process descriptor pointers
-                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
+                    parent_xp  = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
                     parent_cxy = GET_CXY( parent_xp );
                     parent_ptr = GET_PTR( parent_xp );
-
-                    // get extended pointer on lock protecting children list in parent process
-                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock ); 
 
                     // get pointers on the parent process main thread
@@ -366 +368 @@
                                           PROCESS_TERM_STOP );
 
-                    // take the children lock and unblock the parent process main thread 
-                    remote_spinlock_lock( children_lock_xp );
+                    // unblock the parent process main thread 
                     thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
-                    remote_spinlock_unlock( children_lock_xp );
 
                     return;
@@ -393 +393 @@
                 owner_cxy = GET_CXY( owner_xp );
                 owner_ptr = GET_PTR( owner_xp );
-                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
+                owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
 
                 // kill TXT owner process only if it is not the INIT process
@@ -399 +399 @@
                 {
                     // get parent process descriptor pointers
-                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
+                    parent_xp  = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
                     parent_cxy = GET_CXY( parent_xp );
                     parent_ptr = GET_PTR( parent_xp );
-
-                    // get extended pointer on lock protecting children list in parent process
-                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock ); 
 
                     // get pointers on the parent process main thread
@@ -424 +421 @@
                                           PROCESS_TERM_KILL );
 
-                    // take the children lock and unblock the parent process main thread 
-                    remote_spinlock_lock( children_lock_xp );
+                    // unblock the parent process main thread 
                     thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
-                    remote_spinlock_unlock( children_lock_xp );
 
                     return;
@@ -479 +474 @@
         {
             // write one byte to TTY_WRITE register if empty / exit loop if full
-            if( (hal_remote_lw( status_xp ) & TTY_STATUS_TX_FULL) == 0 ) 
+            if( (hal_remote_l32( status_xp ) & TTY_STATUS_TX_FULL) == 0 ) 
             {
                 // get one byte from TX_FIFO
@@ -499 +494 @@
 
         // disable TX_IRQ 
-        hal_remote_sw( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 0 );
+        hal_remote_s32( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 0 );
 
         // unblock TXT_TX server thread
@@ -531 +526 @@
     uint32_t   i;
 
-    xptr_t     dev_xp = ((txt_sync_args_t *)args)->dev_xp;
-    char     * buffer = ((txt_sync_args_t *)args)->buffer;
-    uint32_t   count  = ((txt_sync_args_t *)args)->count;
+    xptr_t       dev_xp = ((txt_sync_args_t *)args)->dev_xp;
+    const char * buffer = ((txt_sync_args_t *)args)->buffer;
+    uint32_t     count  = ((txt_sync_args_t *)args)->count;
     
-    // get TXT0 chdev cluster and local pointer
+    // get chdev cluster and local pointer
     cxy_t     dev_cxy = GET_CXY( dev_xp );
-    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
 
     // get extended pointer on TTY channel base address
-    xptr_t tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) );
+    xptr_t tty_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
 
     // get TTY channel segment cluster and local pointer
     cxy_t      tty_cxy = GET_CXY( tty_xp );
-    uint32_t * tty_ptr = (uint32_t *)GET_PTR( tty_xp );
+    uint32_t * tty_ptr = GET_PTR( tty_xp );
 
     // get extended pointers on TTY_WRITE & TTY_STATUS registers
@@ -550 +545 @@
     xptr_t status_xp = XPTR( tty_cxy , tty_ptr + TTY_STATUS );
 
-    // loop on characters (busy waiting policy)
+    // loop on characters 
     for( i = 0 ; i < count ; i++ )
     {
+        // busy waiting policy on TTY_STATUS register
         do
         {
             // get TTY_STATUS
-            status = hal_remote_lw( status_xp );
+            status = hal_remote_l32( status_xp );
             empty  = ( (status & TTY_STATUS_TX_FULL) == 0 );
 

trunk/hal/tsar_mips32/drivers/soclib_tty.h

@@ -1 +1 @@
 /*
- * soclib_tty.c - soclib tty driver definition.
+ * soclib_tty.c - soclib_tty driver definition (used in the TSAR_IOB architecture).
  *
  * Author  Alain Greiner (2016,2017,2018)
@@ -24 +24 @@
 #include <dev_txt.h>
 #include <chdev.h>
-#include <spinlock.h>
 
 
 /****************************************************************************************
  * This driver supports the vci_tty_tsar component.
- * Regarding read/write request, it implements the generic TXT device API:
+ *
+ * 1) This hardware component handles several hardware channels, supporting directly
+ *    several kernel TXT channels.
+ * 2) For received characters, the hardware support one RX_IRQ, and one bit 
+ *    in the STATUS register to signal that the READ register is full. 
+ * 3) For transmitted characters, the hardware supports one RX_IRQ, and one bit
+ *    in STATUS register to signal that the WRITE register is empty.
+ * 
+ * It implements the generic TXT device API:
  * - transfer one single character from TTY to command "buffer" if to_mem is non-zero.
- * - transfer "count" characters from command "buffer" to TTY if "to_mem is zero.
+ * - transfer "count" characters from command "buffer" to TTY if to_mem is zero.
+ *
  * It handles asynchronous control characters (^C / ^Z), that are translated to signals
  * transmited to the TXT owner process (foreground process).
+ *
+ * This driver implements one TX_FIFO for the transmited characters, writen by the "cmd"
+ * function, and read by the "isr" function).
+ * This driver implements one RX_FIFO for the received characters, writen by the "isr"
+ * function, and read by the "cmd" function).
  ***************************************************************************************/
 
@@ -56 +69 @@
 
 /****************************************************************************************
- * This Rstructure is used by the soclib_tty_isr for the RX channel.
+ * This structure is used for both the RX_FIFO and the TX_FIFO.
  ***************************************************************************************/
 
 #define TTY_FIFO_DEPTH  128
 
-typedef struct tty_fifo_s     // 32 bytes
+typedef struct tty_fifo_s 
 {
     char          data[TTY_FIFO_DEPTH];   // one char per slot
@@ -67 +80 @@
     unsigned int  ptw;                    // next full slot index
     unsigned int  sts;                    // number of full slots
-} tty_fifo_t;
- 
+} 
+tty_fifo_t;
 
 /****************************************************************************************
@@ -83 +96 @@
  * different chdevs (and consequently two diffeerent server threads) for the RX and TX
  * directions. The client thread is identified by the <thread_xp> argument.
- * Depending on the command type, it unmasks the relevant TTY_RX / TTY_TX IRQ,
- * and blocks the TXT device server thread on the THREAD_BLOCKED_DEV_ISR, as the data
- * transfer is done by the ISR.
+ * These functions are supposed to be called by the server thread associated at a
+ * given TXT channel for a given direction (TX or RX).
+ * Depending on the command type, it access the TX_FIFO or RX_FIFO, and blocks the TXT
+ * device server thread on the THREAD_BLOCKED_DEV_ISR, if the RX_FIFO is empty (for a
+ * READ), or if the TX_FIFO is full for a WRITE). 
+ * The actual transfer between the FIFOs and the TTY device registers is done by the ISR.
  * ****************************************************************************************
  * @ thread_xp : extended pointer on client thread descriptor.

trunk/hal/tsar_mips32/kernel.ld

@@ -10 +10 @@
 /* Define the kernel code base addresses */
 
-seg_kcode_base  = 0x00808000;
-seg_kentry_base = 0x00804000;
+seg_kcode_base  = 0x00008000;
+seg_kentry_base = 0x00004000;
 
 /* Set the entry point (e_entry field in the "kernel.elf" file header) */

trunk/hal/x86_64/core/hal_remote.c

@@ -30 +30 @@
 }
 
-void hal_remote_sw(xptr_t xp, uint32_t data)
+void hal_remote_s32(xptr_t xp, uint32_t data)
 {
         *(uint32_t *)xp = data;
 }
 
-void hal_remote_swd(xptr_t xp, uint64_t data)
+void hal_remote_s64(xptr_t xp, uint64_t data)
 {
         *(uint64_t *)xp = data;
@@ -42 +42 @@
 void hal_remote_spt(xptr_t xp, void *pt)
 {
-        hal_remote_swd(xp, (uint64_t)pt);
+        hal_remote_s64(xp, (uint64_t)pt);
 }
 
@@ -50 +50 @@
 }
 
-uint32_t hal_remote_lw(xptr_t xp)
+uint32_t hal_remote_l32(xptr_t xp)
 {
         return *(uint32_t *)xp;
 }
 
-uint64_t hal_remote_lwd(xptr_t xp)
+uint64_t hal_remote_l64(xptr_t xp)
 {
         return *(uint64_t *)xp;
@@ -62 +62 @@
 void *hal_remote_lpt(xptr_t xp)
 {
-        return (void *)hal_remote_lwd(xp);
+        return (void *)hal_remote_l64(xp);
 }
 

trunk/hal/x86_64/drivers/ioc_ata.c

@@ -205 +205 @@
 
         // get command arguments and extended pointer on IOC device
-        cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
-        lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
-        count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
-        buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
+        cmd_type =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
+        lba      =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
+        count    =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
+        buf_xp   = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
 
         /* execute operation */

trunk/hal/x86_64/drivers/txt_rs232.c

@@ -46 +46 @@
 
         // get command type and extended pointer on TXT device
-        uint32_t type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.type ) );
-        xptr_t   dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
+        uint32_t type   =         hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.type ) );
+        xptr_t   dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
 
         // get TXT device cluster and local pointer
@@ -54 +54 @@
 
         // get TTY channel index
-        uint32_t   channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) );
+        uint32_t   channel = hal_remote_l32( XPTR( dev_cxy , &dev_ptr->channel ) );
 
         // for now, only channel zero
@@ -70 +70 @@
 
                 // get source buffer extended pointer & bytes count
-                uint32_t count  = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.count ) );
-                xptr_t   buf_xp = hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
+                uint32_t count  = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.count ) );
+                xptr_t   buf_xp = hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
 
                 // loop on characters