Changeset 295 for soft/giet_vm/giet_drivers

soft/giet_vm/giet_drivers/bdv_driver.c

-                      r289
+                      r295
 // a single channel, block oriented, external storage contrÃŽler.
 //
+// It can exist only one block-device controler in the architecture.
+//
+// The _bdv_read() and _bdv_write() functions use the _bdv_access() function,
+// that is always blocking, but can be called in 4 modes:
+//
+// - In BOOT_PA mode, the _bdv_access() function uses a polling policy on the
+//   IOC_STATUS register to detect transfer completion, as hardware interrupts
+//   are not activated. This mode is used by the boot code to load the map.bin
+//   file into memory.
+//
+// - In BOOT_VA mode, the _bdv_access() function uses a polling policy on
+//   IOC_STATUS register to detect transfer completion. This mode is used by
+//   the boot code to load the various .elf files into memory.
+//
+// - In KERNEL mode, the _bdv_access() function uses a descheduling strategy:
+// The _bdv_read() and _bdv_write() functions are always blocking.
+// They can be called in 3 modes:
+//
+// - In BOOT mode, these functions use a polling policy on the BDV STATUS
+//   register to detect transfer completion, as interrupts are not activated.
+//   This mode is used by the boot code to load the map.bin file into memory
+//   (before MMU activation), or to load the .elf files (after MMU activation).
+//
+// - In KERNEL mode, these functions use a descheduling strategy:
 //   The ISR executed when transfer completes should restart the calling task.
 //   There is no checking of user access right to the memory buffer. This mode
 //   must be used to access IOC, for an "open" system call.
 //
 // - In USER mode, the _bdv_access() function uses a descheduling strategy:
+//   There is no checking of user access right to the memory buffer.
+//   This mode must be used, for an "open" system call.
+//
+// - In USER mode, these functions use a descheduling strategy:
 //   The ISR executed when transfer completes should restart the calling task,
 //   The user access right to the memory buffer must be checked.
 //   This mode must be used to access IOC, for a "read/write" system call.
+//   This mode must be used for a "read/write" system call.
 //
 // As the BDV component can be used by several programs running in parallel,
 // the _ioc_lock variable guaranties exclusive access to the device.  The
+// the _bdv_lock variable guaranties exclusive access to the device.  The
 // _bdv_read() and _bdv_write() functions use atomic LL/SC to get the lock.
 //
 …
 //   if the IOMMU is not activated.
 // An error code is returned if these conditions are not verified.
+///////////////////////////////////////////////////////////////////////////////////
+// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file.
+//
+// The "seg_ioc_base" must be defined in giet_vsegs.ld file.
+///////////////////////////////////////////////////////////////////////////////////
+// Implementation notes:
+//
+// 1. In order to share code, the two _bdv_read() and _bdv_write() functions
+//    call the same _bdv_access() function.
+//
+// 2. All accesses to BDV registers are done by the two
+//    _bdv_set_register() and _bdv_get_register() low-level functions,
+//    that are handling virtual / physical extended addressing.
 ///////////////////////////////////////////////////////////////////////////////////
 #include <giet_config.h>
+#include <bdv_driver.h>
+#include <xcu_driver.h>
 #include <ioc_driver.h>
-#include <bdv_driver.h>
 #include <utils.h>
 #include <tty_driver.h>
 …
 ///////////////////////////////////////////////////////////////////////////////
+//      _bdv_access()
+// BDV global variables
+///////////////////////////////////////////////////////////////////////////////
+#define in_unckdata __attribute__((section (".unckdata")))
+in_unckdata unsigned int          _bdv_lock = 0;
+in_unckdata volatile unsigned int _bdv_status = 0;
+in_unckdata volatile unsigned int _bdv_gtid;
+///////////////////////////////////////////////////////////////////////////////
+// This low_level function returns the value contained in register (index).
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_get_register( unsigned int index )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_ioc_base + index;
+    return _io_extended_read( vaddr );
+}
+///////////////////////////////////////////////////////////////////////////////
+// This low-level function set a new value in register (index).
+///////////////////////////////////////////////////////////////////////////////
+void _bdv_set_register( unsigned int index,
+                        unsigned int value )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_ioc_base + index;
+    _io_extended_write( vaddr, value );
+}
+///////////////////////////////////////////////////////////////////////////////
 // This function transfer data between a memory buffer and the block device.
 // The buffer lentgth is (count*block_size) bytes.
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
+static unsigned int _bdv_access( unsigned int to_mem,
+                                 unsigned int mode,
+                                 unsigned int lba,
+                                 paddr_t buf_paddr,
+                                 unsigned int count)
+{
+#if GIET_DEBUG_IOC_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[IOC DEBUG] Enter _bdv_access() at cycle ");
+_putd( _get_proctime() );
+_puts(" for processor ");
+_putd( _get_procid() );
+_puts("\n - mode    = ");
+_putd( mode );
+_puts("\n - paddr   = ");
+_putx( buf_paddr );
+_puts("\n - sectors = ");
+_putd( count );
+_puts("\n - lba     = ");
+_putx( lba );
+_puts("\n");
+_tty_release_lock( 0 );
+static unsigned int _bdv_access( unsigned int       to_mem,
+                                 unsigned int       mode,
+                                 unsigned int       lba,
+                                 unsigned long long buf_paddr,
+                                 unsigned int       count)
+{
+#if GIET_DEBUG_BDV_DRIVER
+unsigned int procid  = _get_procid();
+unsigned int cxy     = procid / NB_PROCS_MAX;
+unsigned int lpid    = procid % NB_PROCS_MAX;
+unsigned int x       = cxy >> Y_WIDTH;
+unsigned int y       = cxy & ((1<<Y_WIDTH) - 1);
+_printf("\n[BDV DEBUG] Processor[%d,%d,%d] enters _bdv_access() at cycle %d\n"
+        " - mode    = %d\n"
+        " - paddr   = %l\n"
+        " - sectors = %x\n"
+        " - lba     = %x\n",
+        x, y, lpid, _get_proctime(), mode, buf_paddr, count, lba );
 #endif
+    volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base ;
+    unsigned int error = 0;
+    // get the lock protecting IOC
+    _get_lock(&_ioc_lock);
+    // set the _ioc_status polling variable
+    _ioc_status = BLOCK_DEVICE_BUSY;
+    ioc_address[BLOCK_DEVICE_BUFFER]     = (unsigned int)buf_paddr;
+    ioc_address[BLOCK_DEVICE_BUFFER_EXT] = (unsigned int)(buf_paddr>>32);
+    ioc_address[BLOCK_DEVICE_COUNT]      = count;
+    ioc_address[BLOCK_DEVICE_LBA]        = lba;
+    // There are two policies for transfer completion
+        // detection, depending on the mode argument:
+    if ( (mode == IOC_BOOT_PA_MODE) ||    // We poll directly the IOC_STATUS register
+         (mode == IOC_BOOT_VA_MODE) )     // as IRQs are masked.
+    unsigned int       error = 0;
+    // get the lock protecting BDV
+    _get_lock(&_bdv_lock);
+    // set device registers
+    _bdv_set_register( BLOCK_DEVICE_BUFFER    , (unsigned int)buf_paddr );
+    _bdv_set_register( BLOCK_DEVICE_BUFFER_EXT, (unsigned int)(buf_paddr>>32) );
+    _bdv_set_register( BLOCK_DEVICE_COUNT     , count );
+    _bdv_set_register( BLOCK_DEVICE_LBA       , lba );
+    // In BOOT mode, we launch transfer, and poll the BDV_STATUS
+    // register because IRQs are masked.
+    if ( mode == IOC_BOOT_MODE )
+    {
         // Launch transfert
         if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE;
         else             ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ;
+        if (to_mem == 0) _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_WRITE );
+        else             _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_READ );
         unsigned int status;
         do
+        {
+            if ( _bdv_get_status( 0, &status ) ) return 1;
+#if GIET_DEBUG_IOC_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[IOC DEBUG] _bdv_access() : ... waiting on IOC_STATUS register ...\n");
+_tty_release_lock( 0 );
+            status = _bdv_get_register( BLOCK_DEVICE_STATUS );
+#if GIET_DEBUG_BDV_DRIVER
+_printf("\n[BDV DEBUG] _bdv_access() : ... waiting on BDV_STATUS register ...\n");
 #endif
+        }
 …
                (status != BLOCK_DEVICE_READ_ERROR)    &&
                (status != BLOCK_DEVICE_WRITE_SUCCESS) &&
                (status != BLOCK_DEVICE_WRITE_ERROR)   );
+               (status != BLOCK_DEVICE_WRITE_ERROR)   );      // busy waiting
         // analyse status
 …
         // release lock
         _release_lock(&_ioc_lock);
+        _release_lock(&_bdv_lock);
+    }
+    else                           // in USER or KERNEL mode, we deschedule the task.
+                                   // When the task is rescheduled by the ISR, we reset
+                                   // the _ioc_status variable, and release the lock
+    // in USER or KERNEL mode, we deschedule the task.
+    // When the task is rescheduled, we check the _bdv_status variable,
+    // and release the lock.
+    // We need a critical section, because we must reset the RUN bit
+        // before to launch the transfer, and we don't want to be descheduled
+        // between these two operations.
+    else
+    {
+        // We need a critical section, because we must reset the RUN bit
+                // before to launch the transfer, and we want to avoid to be descheduled
+                // between these two operations.
+        // Enter critical section
+        _it_disable();
+        unsigned int save_sr;
+        unsigned int ltid = _get_current_task_id();
+        unsigned int gpid = _get_procid();
+        // activates BDV interrupts
+        _bdv_set_register( BLOCK_DEVICE_IRQ_ENABLE, 1 );
+        // set the _bdv_status variable
+        _bdv_status = BLOCK_DEVICE_BUSY;
+        // enters critical section
+        _it_disable( &save_sr );
+        // set _ioc_gtid and reset runnable
+        unsigned int ltid = _get_proc_task_id();
+        unsigned int pid = _get_procid();
+        _ioc_gtid = (pid<<16) + ltid;
+        _set_task_slot( pid, ltid, CTX_RUN_ID, 0 );
+        // set _bdv_gtid and reset runnable
+        _bdv_gtid = (gpid<<16) + ltid;
+        _set_task_slot( gpid, ltid, CTX_RUN_ID, 0 );
         // Launch transfert
         if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE;
         else             ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ;
+        // launch transfer
+        if (to_mem == 0) _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_WRITE );
+        else             _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_READ  );
         // deschedule task
         _ctx_switch();
+        // restore SR
+        _it_restore( &save_sr );
         // analyse status
         error = ( (_ioc_status == BLOCK_DEVICE_READ_ERROR) ||
                   (_ioc_status == BLOCK_DEVICE_WRITE_ERROR) );
         // reset _ioc_status and release lock
         _ioc_status = BLOCK_DEVICE_IDLE;
         _release_lock(&_ioc_lock);
+        error = ( (_bdv_status == BLOCK_DEVICE_READ_ERROR) ||
+                  (_bdv_status == BLOCK_DEVICE_WRITE_ERROR) );
+        // reset _bdv_status and release lock
+        _bdv_status = BLOCK_DEVICE_IDLE;
+        _release_lock(&_bdv_lock);
+    }
+#if GIET_DEBUG_IOC_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[IOC DEBUG] _bdv_access completed at cycle ");
+_putd( _get_proctime() );
+_puts(" for processor ");
+_putd( _get_procid() );
+_puts(" : error = ");
+_putd( (unsigned int)error );
+_puts("\n");
+_tty_release_lock( 0 );
+#if GIET_DEBUG_BDV_DRIVER
+_printf("\n[BDV DEBUG] Processor[%d,%d,%d] exit _bdv_access() at cycle %d\n",
+        x, y, lpid, _get_proctime() );
 #endif
 …
 ///////////////////////////////////////////////////////////////////////////////
+//       _bdv_init()
+// This function cheks block size, and activates the IOC interrupts.
+// This function cheks block size, and desactivates the interrupts.
 // Return 0 for success, > 0 if error
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_init( unsigned int channel )
+{
+    volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base ;
+    if ( ioc_address[BLOCK_DEVICE_BLOCK_SIZE] != 512 )
+unsigned int _bdv_init()
+{
+    if ( _bdv_get_register( BLOCK_DEVICE_BLOCK_SIZE ) != 512 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _bdv_init() : block size must be 512 bytes\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _bdv_init() : block size must be 512 bytes\n");
         return 1;
+    }
+    if ( channel != 0 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _bdv_init() : illegal channel\n");
+        _tty_release_lock( 0 );
+        return 1;
+    }
+    ioc_address[BLOCK_DEVICE_IRQ_ENABLE] = 1;
+    _bdv_set_register( BLOCK_DEVICE_IRQ_ENABLE, 0 );
     return 0;
+}
 ///////////////////////////////////////////////////////////////////////////////
-//     _bdv_read()
 // Transfer data from the block device to a memory buffer.
 // - mode     : BOOT / KERNEL / USER
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
 unsigned int _bdv_read( unsigned int mode,
                         unsigned int lba,
                         paddr_t      buffer,
                         unsigned int count)
+unsigned int _bdv_read( unsigned int       mode,
+                        unsigned int       lba,
+                        unsigned long long buffer,
+                        unsigned int       count)
+{
     return _bdv_access( 1,        // read access
 …
 ///////////////////////////////////////////////////////////////////////////////
-//     _bdv_write()
 // Transfer data from a memory buffer to the block device.
 // - mode     : BOOT / KERNEL / USER
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
 unsigned int _bdv_write( unsigned int mode,
                          unsigned int lba,
                          paddr_t  buffer,
                          unsigned int count )
+unsigned int _bdv_write( unsigned int       mode,
+                         unsigned int       lba,
+                         unsigned long long buffer,
+                         unsigned int       count )
+{
     return _bdv_access( 0,        // write access
 …
 ///////////////////////////////////////////////////////////////////////////////
+//     _bdv_get_status()
+// This function returns in the status variable, the transfert status, and
+// acknowledge the IRQ if the IOC controler is not busy.
+// Returns 0 if success, > 0 if error
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_get_status( unsigned int  channel,
+                              unsigned int* status )
+{
+    if ( channel != 0 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _bdv_get_status() : illegal channel\n");
+        _tty_release_lock( 0 );
+        return 1;
+    }
+    // get IOC base address
+    volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base;
+    *status = ioc_address[BLOCK_DEVICE_STATUS];
+    return 0;
+}
+///////////////////////////////////////////////////////////////////////////////
+//     _bdv_get_block_size()
+// This function returns the block_size with which the IOC has been configured.
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_get_block_size()
+{
+    // get IOC base address
+    volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base;
+    return  ioc_address[BLOCK_DEVICE_BLOCK_SIZE];
+// Returns device status.
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_get_status()
+{
+    return _bdv_get_register( BLOCK_DEVICE_STATUS );
+}
+///////////////////////////////////////////////////////////////////////////////
+// Returns block size.
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _bdv_get_block_size()
+{
+    return _bdv_get_register( BLOCK_DEVICE_BLOCK_SIZE );
+}
+///////////////////////////////////////////////////////////////////////////////////
+// This ISR save the status, acknowledge the IRQ,
+// and activates the task waiting on IO transfer.
+// It can be an HWI or a SWI.
+//
+// TODO the _set_task_slot access should be replaced by an atomic LL/SC
+//      when the CTX_RUN bool will be replaced by a bit_vector.
+///////////////////////////////////////////////////////////////////////////////////
+void _bdv_isr( unsigned int irq_type,   // HWI / WTI
+               unsigned int irq_id,     // index returned by ICU
+               unsigned int channel )   // unused
+{
+    unsigned int procid     = _get_procid();
+    unsigned int cluster_xy = procid / NB_PROCS_MAX;
+    unsigned int lpid       = procid % NB_PROCS_MAX;
+    // acknowledge WTI in local XCU if required
+    unsigned int value;
+    if ( irq_type == IRQ_TYPE_WTI ) _xcu_get_wti_value( cluster_xy, irq_id, &value );
+    // save status in _bdv_status variable and reset IRQ
+    _bdv_status = _bdv_get_register( BLOCK_DEVICE_STATUS );
+    // identify task waiting on BDV
+    unsigned int rprocid    = _bdv_gtid>>16;
+    unsigned int ltid       = _bdv_gtid & 0xFFFF;
+    unsigned int remote_xy  = rprocid / NB_PROCS_MAX;
+#if GIET_DEBUG_IRQS  // we don't take the TTY lock to avoid deadlock
+unsigned int x              = cluster_xy >> Y_WIDTH;
+unsigned int y              = cluster_xy & ((1<<Y_WIDTH)-1);
+unsigned int rx             = remote_xy >> Y_WIDTH;
+unsigned int ry             = remote_xy & ((1<<Y_WIDTH)-1);
+unsigned int rlpid          = rprocid % NB_PROCS_MAX;
+_puts("\n[IRQS DEBUG] Processor[");
+_putd(x );
+_puts(",");
+_putd(y );
+_puts(",");
+_putd(lpid );
+_puts("] enters _bdv_isr() at cycle ");
+_putd(_get_proctime() );
+_puts("\n  for task ");
+_putd(ltid );
+_puts(" running on processor[");
+_putd(rx );
+_puts(",");
+_putd(ry );
+_puts(",");
+_putd(rlpid );
+_puts(" / bdv status = ");
+_putx(_bdv_status );
+_puts("\n");
+#endif
+    // re-activates sleeping task
+    _set_task_slot( rprocid,     // global processor index
+                    ltid,        // local task index on processor
+                    CTX_RUN_ID,  // CTX_RUN slot
+);         // running
+    // requires a context switch for remote processor running the waiting task
+    _xcu_send_wti( remote_xy,    // cluster index
+                   lpid,         // local processor index
+);          // don't force context switch if not idle
+}

soft/giet_vm/giet_drivers/bdv_driver.h

-                      r289
+                      r295
 ///////////////////////////////////////////////////////////////////////////////////
+#ifndef _GIET_BDV_DRIVERS_H_
+#define _GIET_BDV_DRIVERS_H_
+#include <mapping_info.h>
+#ifndef _GIET_BDV_DRIVER_H_
+#define _GIET_BDV_DRIVER_H_
 ///////////////////////////////////////////////////////////////////////////////////
 // BDV access functions and variables (vci_block_device)
+// BDV global variables
 ///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _bdv_init( unsigned int channel );
+extern unsigned int          _bdv_lock;    // BDV is a shared ressource
+extern volatile unsigned int _bdv_status;  // required for IRQ signaling
+extern volatile unsigned int _bdv_gtid;    // descheduled task id = gpid<<16 + ltid
+extern unsigned int _bdv_write( unsigned int mode,
+                                unsigned int lba,
+                                paddr_t      buffer,
+                                unsigned int count );
+///////////////////////////////////////////////////////////////////////////////////
+// BDV registers, operations and status values
+///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _bdv_read(  unsigned int mode,
+                                unsigned int lba,
+                                paddr_t      buffer,
+                                unsigned int count );
+enum BDV_registers
+{
+    BLOCK_DEVICE_BUFFER,
+    BLOCK_DEVICE_LBA,
+    BLOCK_DEVICE_COUNT,
+    BLOCK_DEVICE_OP,
+    BLOCK_DEVICE_STATUS,
+    BLOCK_DEVICE_IRQ_ENABLE,
+    BLOCK_DEVICE_SIZE,
+    BLOCK_DEVICE_BLOCK_SIZE,
+    BLOCK_DEVICE_BUFFER_EXT,
+};
+extern unsigned int _bdv_get_status( unsigned int  channel,
+                                     unsigned int* status );
+enum BDV_operations
+{
+    BLOCK_DEVICE_NOOP,
+    BLOCK_DEVICE_READ,
+    BLOCK_DEVICE_WRITE,
+};
+enum BDV_status
+{
+    BLOCK_DEVICE_IDLE,
+    BLOCK_DEVICE_BUSY,
+    BLOCK_DEVICE_READ_SUCCESS,
+    BLOCK_DEVICE_WRITE_SUCCESS,
+    BLOCK_DEVICE_READ_ERROR,
+    BLOCK_DEVICE_WRITE_ERROR,
+    BLOCK_DEVICE_ERROR,
+};
+///////////////////////////////////////////////////////////////////////////////////
+// BDV access functions (vci_block_device)
+///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _bdv_init();
+extern unsigned int _bdv_write( unsigned int       mode,
+                                unsigned int       lba,
+                                unsigned long long buffer,
+                                unsigned int       count );
+extern unsigned int _bdv_read(  unsigned int       mode,
+                                unsigned int       lba,
+                                unsigned long long buffer,
+                                unsigned int       count );
+extern unsigned int _bdv_get_status();
 extern unsigned int _bdv_get_block_size();
+extern void _bdv_isr( unsigned irq_type,
+                      unsigned irq_id,
+                      unsigned channel );
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/giet_drivers/cma_driver.h

-                      r258
+                      r295
 };
+///////////////////////////////////////////////////////////////////////////////////
+// CMA (vci_chbuf_dma) low-level access functions
+///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _cma_get_register( unsigned int channel,
+                                       unsigned int index );
+extern void _cma_set_register( unsigned int channel,
+                               unsigned int index,
+                               unsigned int value );
+extern void _cma_isr( unsigned int irq_type,
+                      unsigned int irq_id,
+                      unsigned int channel );
+///////////////////////////////////////////////////////////////////////////////////
 #endif

soft/giet_vm/giet_drivers/dma_driver.c

-                      r267
+                      r295
     unsigned int procid    = _get_procid();
     unsigned int cluster_xy = procid/NB_PROCS_MAX;
+    unsigned int x          = cluster_xy >> Y_WIDTH;
+    unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
     unsigned int channel_id = procid%NB_PROCS_MAX;
 …
 #if GIET_DEBUG_DMA_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[DMA DEBUG] Enter _dma_copy() at cycle ");
+_putd( _get_proctime() );
+_puts("\n - vspace_id  = ");
+_putx( vspace_id );
+_puts("\n - cluster_xy = ");
+_putx( cluster_xy );
+_puts("\n - channel_id = ");
+_putx( channel_id );
+_puts("\n - dest       = ");
+_putx( (unsigned int)dest );
+_puts("\n - source     = ");
+_putx( (unsigned int)source );
+_puts("\n - bytes      = ");
+_putd( size );
+_tty_release_lock( 0 );
+unsigned int x          = cluster_xy >> Y_WIDTH;
+unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
+_printf("\n[DMA DEBUG] Processor[%d,%d,%d] enters _dma_copy() at cycle %d\n"
+        " - vspace_id  = %d\n"
+        " - cluster_xy = %x\n"
+        " - channel_id = %d\n"
+        " - dest       = %x\n"
+        " - source     = %x\n"
+        " - bytes      = %x\n",
+        x, y, channel_id, _get_proctime(), vspace_id, cluster_xy,
+        (unsigned int)dest, (unsigned int)source, size );
 #endif
 …
          (size & 0x3) )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _dma_copy() : buffer unaligned\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _dma_copy() : buffer unaligned\n");
         _exit();
+    }
 …
     if ( ko )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _dma_copy() : source buffer unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _dma_copy() : source buffer unmapped\n");
         _exit();
+    }
 …
     if ( ko )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _dma_copy() : dest buffer unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _dma_copy() : dest buffer unmapped\n");
         _exit();
+    }
 …
 #if GIET_DEBUG_DMA_DRIVER
+_tty_get_lock( 0 );
+_puts("\n - src_paddr  = ");
+_putl( src_paddr );
+_puts("\n - dst_paddr  = ");
+_putl( dst_paddr );
+_puts("\n");
+_tty_release_lock( 0 );
+_printf(" - src_paddr  = %llx\n"
+        " - dst_paddr  = %llx\n",
+        src_paddr, dst_paddr );
 #endif
 …
     if ( ko )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _dma_copy() : cannot start transfer\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _dma_copy() : cannot start transfer\n");
         _exit();
+    }
 …
 #if GIET_DEBUG_DMA_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[DMA DEBUG] _dma_copy() : ... waiting on DMA_STATUS register ...\n");
+_tty_release_lock( 0 );
+_printf("\n[DMA DEBUG] _dma_copy() : ... waiting on DMA_STATUS register ...\n");
 #endif
 …
     if( status != DMA_SUCCESS )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _dma_copy() : DMA_STATUS error = ");
+        _putd( status );
+        _puts("\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _dma_copy() : DMA_STATUS = %x\n", status );
         _exit();
+    }
 …
 #if GIET_DEBUG_DMA_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[DMA DEBUG] _dma_copy() completed at cycle ");
+_putd( _get_proctime() );
+_puts("\n");
+_tty_release_lock( 0 );
+_printf("\n[DMA DEBUG] _dma_copy() completed at cycle %d\n", _get_proctime() );
 #endif
 #else // NB_DMA_CHANNELS == 0
+    _tty_get_lock( 0 );
+    _puts("\n[GIET ERROR] in _dma_copy() : NB_DMA_CHANNELS = 0 !\n");
+    _tty_release_lock( 0 );
+    _printf("\n[GIET ERROR] in _dma_copy() : NB_DMA_CHANNELS = 0 !\n");
     _exit();
 #endif

soft/giet_vm/giet_drivers/fbf_driver.c

-                      r275
+                      r295
 // The fbf_driver.c and fbf_driver.h files are part ot the GIET-VM kernel.
 // This driver supports the SoCLib vci_framebuffer component.
-//
-// It can exist only one frame buffer in the architecture.
 //
 // There exist two methods to access the VciFrameBuffer device:
 …
                             unsigned int length)
+{
+    char* fb_address = (char *)&seg_fbf_base + offset;
+    _memcpy( fb_address, buffer, length);
+    char* fbf_address = (char *)&seg_fbf_base + offset;
+    _memcpy( fbf_address, buffer, length);
     return 0;
+}
 …
                             unsigned int   length)
+{
+    char* fb_address = (char *)&seg_fbf_base + offset;
+    _memcpy( buffer, fb_address, length);
+    char* fbf_address = (char *)&seg_fbf_base + offset;
+    _memcpy( buffer, fbf_address, length);
     return 0;
+}
 …
     if ( channel_id >= NB_CMA_CHANNELS )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : CMA channel index too large\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : CMA channel index too large\n");
         return 1;
+    }
 …
     if ( sizeof(fb_cma_channel_t) != 32 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel size\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel size\n");
         return 1;
+    }
 …
     if ( (unsigned int)(&_fb_cma_channel[channel_id]) & 0x1F )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel alignment\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel alignment\n");
         return 1;
+    }
 …
     if ( ((unsigned int)vbase0 & 0x3) || ((unsigned int)vbase1 & 0x3) || (length & 0x3) )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer not word aligned\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer not word aligned\n");
         return 1;
+    }
 …
     if (ko)
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : frame buffer unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : frame buffer unmapped\n");
         return 1;
+    }
 …
     if (ko)
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 0 unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer 0 unmapped\n");
         return 1;
+    }
     if ((flags & PTE_U) == 0)
+    {
+        _tty_get_lock( 0 );
+        _puts("[GIET ERROR] in _fb_cma_init() : user buffer 0 not in user space\n");
+        _tty_release_lock( 0 );
+        _printf("[GIET ERROR] in _fb_cma_init() : user buffer 0 not in user space\n");
         return 1;
+    }
 …
     if (ko)
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 1 unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer 1 unmapped\n");
         return 1;
+    }
     if ((flags & PTE_U) == 0)
+    {
+        _tty_get_lock( 0 );
+        _puts("[GIET ERROR] in _fb_cma_init() : user buffer 1 not in user space\n");
+        _tty_release_lock( 0 );
+        _printf("[GIET ERROR] in _fb_cma_init() : user buffer 1 not in user space\n");
         return 1;
+    }
 …
     if (ko)
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _fb_cma_init() : channel descriptor unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("\n[GIET ERROR] in _fb_cma_init() : channel descriptor unmapped\n");
         return 1;
+    }
 …
 #if GIET_DEBUG_FBF_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[CMA DEBUG] fb_cma_init()");
+_puts("\n - fbf       pbase = ");
+_putl( _fb_cma_channel[channel_id].fbf );
+_puts("\n - buf0      pbase = ");
+_putl( _fb_cma_channel[channel_id].buf0 );
+_puts("\n - buf1      pbase = ");
+_putl( _fb_cma_channel[channel_id].buf1 );
+_puts("\n - channel   pbase = ");
+_putl( _fb_cma_desc_paddr[channel_id] );
+_puts("\n");
+_tty_release_lock( 0 );
+_printf("\n[CMA DEBUG] enters _fb_cma_init()\n"
+        " - fbf       pbase = %l\n"
+        " - buf0      pbase = %l\n"
+        " - buf1      pbase = %l\n"
+        " - channel   pbase = %l\n"
+        _fb_cma_channel[channel_id].fbf,
+        _fb_cma_channel[channel_id].buf0,
+        _fb_cma_channel[channel_id].buf1,
+        _fb_cma_desc_paddr[channel_id] );
 #endif
 …
     // CMA channel activation
+    unsigned int* cma_vbase = (unsigned int *)&seg_cma_base;
+    unsigned int  offset    = channel_id * CHBUF_CHANNEL_SPAN;
+    cma_vbase[offset + CHBUF_SRC_DESC]  = (unsigned int)(desc_paddr & 0xFFFFFFFF);
+    cma_vbase[offset + CHBUF_SRC_EXT]   = (unsigned int)(desc_paddr >> 32);
+    cma_vbase[offset + CHBUF_SRC_NBUFS] = 2;
+    cma_vbase[offset + CHBUF_DST_DESC]  = (unsigned int)(desc_paddr & 0xFFFFFFFF) + 16;
+    cma_vbase[offset + CHBUF_DST_EXT]   = (unsigned int)(desc_paddr >> 32);
+    cma_vbase[offset + CHBUF_DST_NBUFS] = 1;
+    cma_vbase[offset + CHBUF_BUF_SIZE]  = length;
+    cma_vbase[offset + CHBUF_PERIOD]    = 300;
+    cma_vbase[offset + CHBUF_RUN]       = 1;
+    _cma_set_register( channel_id, CHBUF_SRC_DESC , (unsigned int)(desc_paddr & 0xFFFFFFFF) );
+    _cma_set_register( channel_id, CHBUF_SRC_EXT  , (unsigned int)(desc_paddr >> 32) );
+    _cma_set_register( channel_id, CHBUF_SRC_NBUFS, 2 );
+    _cma_set_register( channel_id, CHBUF_DST_DESC , (unsigned int)(desc_paddr & 0xFFFFFFFF) + 16 );
+    _cma_set_register( channel_id, CHBUF_DST_EXT  , (unsigned int)(desc_paddr >> 32) );
+    _cma_set_register( channel_id, CHBUF_DST_NBUFS, 1 );
+    _cma_set_register( channel_id, CHBUF_BUF_SIZE , length );
+    _cma_set_register( channel_id, CHBUF_PERIOD   , 300 );
+    _cma_set_register( channel_id, CHBUF_RUN      , 1 );
     return 0;
 #else
+    _tty_get_lock( 0 );
+    _puts("\n[GIET ERROR] in _fb_cma_init() : no CMA channel allocated\n");
+    _tty_release_lock( 0 );
+    _printf("\n[GIET ERROR] in _fb_cma_init() : no CMA channel allocated\n");
     return 1;
 #endif
+}
 ////////////////////////////////////////////////////////////////////////////////////
 // _fb_cma_write()
 …
     volatile paddr_t buf_paddr;
-    unsigned int     buf_length;
     unsigned int     full = 1;
 …
 #if GIET_DEBUG_FBF_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[CMA DEBUG] fb_cma_write() for CMA channel ");
+_putd( channel_id );
+_puts(" / buf_id = ");
+_putd( buffer_id );
+_puts("\n");
+_tty_release_lock( 0 );
+_printf("\n[CMA DEBUG] _fb_cma_write() for CMA channel %d / bufid = %d at cycle %d\n",
+        channel_id, buffer_id, _get_proctime() );
 #endif
 …
             // INVAL L1 cache for the channel descriptor,
             _dcache_buf_invalidate( &_fb_cma_channel[channel_id], 32 );
+            _dcache_buf_invalidate( (void*)&_fb_cma_channel[channel_id], 32 );
+        }
 …
         count++;
         if ( count == 10 ) _exit();
-#if GIET_DEBUG_FBF_DRIVER
-_tty_get_lock( 0 );
-_puts(" - buffer descriptor = ");
-_putl( buf_paddr );
-_puts(" at cycle ");
-_putd( _get_proctime() );
-_puts("\n");
-_tty_release_lock( 0 );
-#endif
+    }
 …
 #else
+    _tty_get_lock( 0 );
+    _puts("\n[GIET ERROR] in _fb_cma_channel() : no CMA channel allocated\n");
+    _tty_release_lock( 0 );
+    _printf("\n[GIET ERROR] in _fb_cma_channel() : no CMA channel allocated\n");
     return 1;
 …
     unsigned int channel_id = _get_context_slot(CTX_CMA_ID);
+#if GIET_DEBUG_FBF_DRIVER
+_printf("\n[CMA DEBUG] _fb_cma_stop() for CMA channel %d at cycle %d\n",
+        channel_id, _get_proctime() );
+#endif
     // CMA channel desactivation
+    unsigned int* cma_vbase = (unsigned int *)&seg_cma_base;
+    unsigned int  offset     = channel_id * CHBUF_CHANNEL_SPAN;
+    cma_vbase[offset + CHBUF_RUN] = 0;
+    _cma_set_register( channel_id, CHBUF_RUN, 0 );
     return 0;
 #else
+    _tty_get_lock( 0 );
+    _puts("\n[GIET ERROR] in _fb_cma_stop() : no CMA channel allocated\n");
+    _tty_release_lock( 0 );
+    _printf("\n[GIET ERROR] in _fb_cma_stop() : no CMA channel allocated\n");
     return 1;

soft/giet_vm/giet_drivers/hba_driver.c

-                      r289
+                      r295
 // File     : hba_driver.c
 // Date     : 23/11/2013
 // Author   : alain greiner and zhang
+// Author   : alain greiner
 // Copyright (c) UPMC-LIP6
 ///////////////////////////////////////////////////////////////////////////////////
 …
 // block oriented, external storage contrÃŽler, respecting the AHCI standard.
 //
+// It can exist only one ahci-device controler in the architecture.
+// The seg_ioc_base (standard HBA virtual base address) and seg_ioc_base_bis
+// (backup HBA virtual base address) must be defined in giet_vsegs.ld file.
+//////////////////////////////////////////////////////////////////////////////////
+// Implementation notes:
 //
 // The _ioc_read() and _ioc_write() functions use the _ioc_access() function,
 // that is always blocking, but can be called in 4 modes:
+// 1. In order to share code, the two _hba_read() and _hba_write() functions
+//    call the same _hba_set_cmd() function.
 //
+// - In BOOT_PA mode, the _ioc_access() function use the buffer virtual address
+//   as a physical address (as the page tables are not build) and use a polling
+//   policy on the IOC_STATUS register to detect transfer completion, as
+//   hardware interrupts are not activated. This mode is used by the
+//   boot code to load the map.bin file into memory.
+//
+// - In BOOT_VA mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address, and use a polling policy on IOC_STATUS
+//   register to detect transfer completion. This mode is used by the boot code
+//   to load the various .elf files into memory.
+//
+// - In KERNEL mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address, and use a descheduling strategy:
+//   The ISR executed when transfer completes should restart the calling task.
+//   There is no checking of user access right to the memory buffer.
+//   This mode must be used to access IOC, for an "open" system call.
+//
+// - In USER mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address, and use a descheduling strategy:
+//   The ISR executed when transfer completes should restart the calling task,
+//   The user access right to the memory buffer must be checked.
+//   This mode must be used to access IOC, for a "read/write" system call.
+//
+// As the IOC component can be used by several programs running in parallel,
+// the _ioc_lock variable guaranties exclusive access to the device.  The
+// _ioc_read() and _ioc_write() functions use atomic LL/SC to get the lock.
+//
+// The IOMMU can be activated or not:
+//
+// 1) When the IOMMU is used, a fixed size 2Mbytes vseg is allocated to
+// the IOC peripheral, in the I/O virtual space, and the user buffer is
+// dynamically remapped in the IOMMU page table. The corresponding entry
+// in the IOMMU PT1 is defined by the kernel _ioc_iommu_ix1 variable.
+// The number of pages to be unmapped is stored in the _ioc_npages variable.
+// The number of PT2 entries is dynamically computed and stored in the
+// kernel _ioc_iommu_npages variable. It cannot be larger than 512.
+// The user buffer is unmapped by the _ioc_completed() function when
+// the transfer is completed.
+//
+// 2/ If the IOMMU is not used, we check that  the user buffer is mapped to a
+// contiguous physical buffer (this is generally true because the user space
+// page tables are statically constructed to use contiguous physical memory).
+//
+// Finally, the memory buffer must fulfill the following conditions:
+// - The buffer must be word aligned,
+// - The buffer must be mapped in user space for an user access,
+// - The buffer must be writable in case of (to_mem) access,
+// - The total number of physical pages occupied by the user buffer cannot
+//   be larger than 512 pages if the IOMMU is activated,
+// - All physical pages occupied by the user buffer must be contiguous
+//   if the IOMMU is not activated.
+// An error code is returned if these conditions are not verified.
+///////////////////////////////////////////////////////////////////////////////////
+// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file.
+// 2. All accesses to HBA registers are done by the two
+//    _hba_set_register() and _hba_get_register() low-level functions,
+//    that are handling virtual / physical extended addressing.
 ///////////////////////////////////////////////////////////////////////////////////
 …
 #include <vmem.h>
+#if !defined( NB_HBA_CHANNELS )
+# error: You must define NB_HBA_CHANNELS in the hard_config.h file
+#endif
+#if ( NB_HBA_CHANNELS > 8 )
+# error: NB_HBA_CHANNELS cannot be larger than 8
+#endif
+#if !defined( USE_IOB )
+# error: You must define USE_IOB in the hard_config.h file
+#endif
+#if !defined(GIET_USE_IOMMU)
+# error: You must define GIET_USE_IOMMU in the giet_config.h file
+#if !defined( NB_IOC_CHANNELS )
+# error: You must define NB_IOC_CHANNELS in the hard_config.h file
+#endif
+#if ( NB_IOC_CHANNELS > 8 )
+# error: NB_IOC_CHANNELS cannot be larger than 8
 #endif
 …
 // command list array (one per channel)
 hba_cmd_list_t   hba_cmd_list[NB_HBA_CHANNELS] __attribute__((aligned(0x1000)));
+hba_cmd_list_t   hba_cmd_list[NB_IOC_CHANNELS] __attribute__((aligned(0x1000)));
 // command tables array (32 command tables per channel)
 hba_cmd_table_t  hba_cmd_table[NB_HBA_CHANNELS][32] __attribute__((aligned(0x1000)));
+hba_cmd_table_t  hba_cmd_table[NB_IOC_CHANNELS][32] __attribute__((aligned(0x1000)));
 // command list physical addresses array (one per channel)
 paddr_t          hba_cmd_list_paddr[NB_HBA_CHANNELS];
+paddr_t          hba_cmd_list_paddr[NB_IOC_CHANNELS];
 // command tables physical addresses array (32 command tables per channel)
 paddr_t          hba_cmd_table_paddr[NB_HBA_CHANNELS][32];
+paddr_t          hba_cmd_table_paddr[NB_IOC_CHANNELS][32];
 // command list pointer array (one per channel)
+unsigned int     hba_cmd_slot[NB_HBA_CHANNELS];
+//////////////////////////////////////////////////////////////////
+// This function returns the status of a given channel.
+// return 0 if success, >0 if error
+//////////////////////////////////////////////////////////////////
+unsigned int _hba_get_status( unsigned int   channel,
+                              unsigned int*  status )
+{
+    volatile unsigned int* hba_address;
+    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel);
+    if( channel >= NB_HBA_CHANNELS )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _hba_get_status() : illegal channel\n");
+        _tty_release_lock( 0 );
+        return 1;
+    }
+    else
+    {
+        *status = hba_address[HBA_PXIS];
+        return 0;
+    }
+}
+//////////////////////////////////////////////////////////////////
+// This function reset the status resgister for a given channel.
+// return 0 if success, >0 if error
+//////////////////////////////////////////////////////////////////
+unsigned int _hba_reset_status( unsigned int channel )
+{
+    volatile unsigned int* hba_address;
+    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel);
+    if( channel >= NB_HBA_CHANNELS )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _hba_reset_status() : illegal channel\n");
+        _tty_release_lock( 0 );
+        return 1;
+    }
+    else
+    {
+        hba_address[HBA_PXIS] = 0;
+        return 0;
+    }
+}
+unsigned int     hba_cmd_slot[NB_IOC_CHANNELS];
+//////////////////////////////////////////////////////////////////////////////
+// This low level function returns the value of register (channel / index)
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _hba_get_register( unsigned int channel,
+                                unsigned int index )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_ioc_base + channel*HBA_SPAN + index;
+    return _io_extended_read( vaddr );
+}
+//////////////////////////////////////////////////////////////////////////////
+// This low level function set a new value in register (channel / index)
+//////////////////////////////////////////////////////////////////////////////
+void _hba_set_register( unsigned int channel,
+                        unsigned int index,
+                        unsigned int value )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_ioc_base + channel*HBA_SPAN + index;
+    _io_extended_write( vaddr, value );
+}
 ///////////////////////////////////////////////////////////////////////////////
 // This function register a command in both the command list
 …
 // return 0 if success, > 0 if error
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _hba_cmd_set( unsigned int  is_read,     // to memory
+unsigned int _hba_cmd_set( unsigned int  channel,     // channel index
+                           unsigned int  is_read,     // to memory
                            unsigned int  lba,         // logic block address
                            unsigned int  buf_vaddr,   // buffer virtual address
+                           paddr_t       buffer,      // buffer physical address
                            unsigned int  count )      // number of blocks
+{
-    volatile unsigned int *hba_address;
     unsigned int       block_size;     // defined by the block device (bytes)
-    unsigned int       channel_id;     // channel index
     unsigned int       pxci;           // command list status
     unsigned int       cmd_id;         // command index in command list
+    unsigned int       buf_id;         // for physical buffers covering user buffer
+    unsigned int       user_pt_vbase;  // user page table virtual base address
+    unsigned int       vpn;            // for all pages covering the userbuffer
+    unsigned int       vpn_min;        // first virtual page index for user buffer
+    unsigned int       vpn_max;        // last  virtual page index for user buffer
+    unsigned int       offset;         // unaligned bytes in page frame: buf_vaddr & 0xFFF
+    unsigned int       offset_last;    // unaligned bytes in last frame
     hba_cmd_desc_t*    cmd_desc;       // command descriptor pointer
     hba_cmd_table_t*   cmd_table;      // command table pointer
 …
     // check buffer alignment
+    if( buf_vaddr & (block_size-1) )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _hba_set_cmd() : user buffer not block aligned\n");
+        _tty_release_lock( 0 );
+    if( buffer & (block_size-1) )
+    {
+        _printf("\n[GIET ERROR] in _hba_set_cmd() : user buffer not block aligned\n");
         return 1;
+    }
+    // get channel index
+    channel_id = _get_context_slot(CTX_HBA_ID);
+    if ( channel_id == 0xFFFFFFFF )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _hba_set_cmd() : no HBA channel allocated\n");
+        _tty_release_lock( 0 );
+    // get command list status from PXCI register
+    pxci = _hba_get_register( channel, HBA_PXCI );
+    // get command index and return error if command list full
+    cmd_id = hba_cmd_slot[channel];
+    if( pxci & (1<<cmd_id ) )
+    {
+        _printf("\n[GIET ERROR] in _hba_set_cmd() : command list full for channel %d\n",
+                channel );
         return 1;
+    }
-    // get hba device address
-    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN * channel_id);
-    // get command list status
-    pxci = hba_address[HBA_PXCI];
-    // get command index and return error if command list full
-    cmd_id = hba_cmd_slot[channel_id];
-    if( pxci & (1<<cmd_id ) )
+    {
-        _tty_get_lock( 0 );
-        _puts("\n[GIET ERROR] in _hba_set_cmd() : command list full in channel \n");
-        _putd( channel_id );
-        _puts("\n");
-        _tty_release_lock( 0 );
-        return 1;
+    }
     // compute pointers on command descriptor and command table
+    cmd_desc  = (hba_cmd_desc_t*)(&(hba_cmd_list[channel_id].desc[cmd_id]));
+    cmd_table = (hba_cmd_table_t*)(&(hba_cmd_table[channel_id][cmd_id]));
+    cmd_desc  = (hba_cmd_desc_t*)(&(hba_cmd_list[channel].desc[cmd_id]));
+    cmd_table = (hba_cmd_table_t*)(&(hba_cmd_table[channel][cmd_id]));
+    // set  buffer descriptor in command table
+    cmd_table->entry[0].dba  = (unsigned int)(buffer);
+    cmd_table->entry[0].dbau = (unsigned int)(buffer >> 32);
+    cmd_table->entry[0].dbc  = count * block_size;
+    // initialize command table header
+    cmd_table->header.lba0 = (char)lba;
+    cmd_table->header.lba1 = (char)(lba>>8);
+    cmd_table->header.lba2 = (char)(lba>>16);
+    cmd_table->header.lba3 = (char)(lba>>24);
+    cmd_table->header.lba4 = 0;
+    cmd_table->header.lba5 = 0;
+    // initialise command descriptor
+    cmd_desc->prdtl[0] = 1;
+    cmd_desc->prdtl[1] = 0;
+    cmd_desc->ctba     = (unsigned int)(hba_cmd_table_paddr[channel][cmd_id]);
+    cmd_desc->ctbau    = (unsigned int)(hba_cmd_table_paddr[channel][cmd_id]>>32);
+    if( is_read ) cmd_desc->flag[0] = 0x00;
+    else          cmd_desc->flag[0] = 0x40;
+    // update PXCI register
+    _hba_set_register( channel, HBA_PXCI, (1<<cmd_id) );
+    // update command pointer
+    hba_cmd_slot[channel] = (cmd_id + 1)%32;
+    return  0;
+}
+/* This can be used for a future use with buffer in virtual space
     // get user space page table virtual address
 …
         if ( ko )
+        {
+            _tty_get_lock( 0 );
+            _puts("[GIET ERROR] in _hba_set_cmd() : user buffer unmapped\n");
+            _tty_release_lock( 0 );
+            _printf("[GIET ERROR] in _hba_set_cmd() : user buffer unmapped\n");
             return 1;
+        }
         if ((flags & PTE_U) == 0)
+        {
+            _tty_get_lock( 0 );
+            _puts("[GIET ERROR] in _hba_set_cmd() : user buffer not in user space\n");
+            _tty_release_lock( 0 );
+            _printf("[GIET ERROR] in _hba_set_cmd() : user buffer not in user space\n");
             return 1;
+        }
         if (((flags & PTE_W) == 0 ) && (is_read == 0) )
+        {
+            _tty_get_lock( 0 );
+            _puts("[GIET ERROR] in _hba_set_cmd() : user buffer not writable\n");
+            _tty_release_lock( 0 );
+            _printf("[GIET ERROR] in _hba_set_cmd() : user buffer not writable\n");
             return 1;
+        }
 …
         if( buf_id > 245 )
+        {
+            _tty_get_lock( 0 );
+            _puts("[GIET ERROR] in _hba_set_cmd() : max number of buffers is 248\n");
+            _tty_release_lock( 0 );
+            _printf("[GIET ERROR] in _hba_set_cmd() : max number of buffers is 248\n");
             return 1;
+        }
 …
 #if GIET_DEBUG_HBA_DRIVER
 _puts("\n- buf_index = ");
+_printf("\n- buf_index = ");
 _putd( buf_id );
 _puts(" / paddr = ");
+_printf(" / paddr = ");
 _putl( paddr );
 _puts(" / count = ");
+_printf(" / count = ");
 _putd( count );
 _puts("\n");
+_printf("\n");
 #endif
             buf_id++;
 …
 #if GIET_DEBUG_HBA_DRIVER
 _puts("\n- buf_index = ");
+_printf("\n- buf_index = ");
 _putd( buf_id );
 _puts(" / paddr = ");
+_printf(" / paddr = ");
 _putl( paddr );
 _puts(" / count = ");
+_printf(" / count = ");
 _putd( count );
 _puts("\n");
+_printf("\n");
 #endif
             buf_id++;
 …
 #if GIET_DEBUG_HBA_DRIVER
 _puts("\n- buf_index = ");
+_printf("\n- buf_index = ");
 _putd( buf_id );
 _puts(" / paddr = ");
+_printf(" / paddr = ");
 _putl( paddr );
 _puts(" / count = ");
+_printf(" / count = ");
 _putd( count );
 _puts("\n");
+_printf("\n");
 #endif
             buf_id++;
 …
 #if GIET_DEBUG_HBA_DRIVER
 _puts("\n- buf_index = ");
+_printf("\n- buf_index = ");
 _putd( buf_id );
 _puts(" / paddr = ");
+_printf(" / paddr = ");
 _putl( paddr );
 _puts(" / count = ");
+_printf(" / count = ");
 _putd( count );
 _puts("\n");
+_printf("\n");
 #endif
             buf_id++;
 …
 #if GIET_DEBUG_HBA_DRIVER
 _puts("\n- buf_index = ");
+_printf("\n- buf_index = ");
 _putd( buf_id );
 _puts(" / paddr = ");
+_printf(" / paddr = ");
 _putl( paddr );
 _puts(" / count = ");
+_printf(" / count = ");
 _putd( count );
 _puts("\n");
+_printf("\n");
 #endif
             buf_id++;
+        }
+    }
+    // initialize command table header
+    cmd_table->header.lba0 = (char)lba;
+    cmd_table->header.lba1 = (char)(lba>>8);
+    cmd_table->header.lba2 = (char)(lba>>16);
+    cmd_table->header.lba3 = (char)(lba>>24);
+    // initialise command descriptor
+    cmd_desc->prdtl[0] = (unsigned char)(buf_id);
+    cmd_desc->prdtl[1] = (unsigned char)(buf_id>>8);
+    cmd_desc->ctba     = (unsigned int)(hba_cmd_table_paddr[channel_id][cmd_id]);
+    cmd_desc->ctbau    = (unsigned int)(hba_cmd_table_paddr[channel_id][cmd_id]>>32);
+    if( is_read ) cmd_desc->flag[0] = 0x00;
+    else          cmd_desc->flag[0] = 0x40;
+    // update PXCI register
+    hba_address[HBA_PXCI] = (1<<cmd_id);
+    // update command pointer
+    hba_cmd_slot[channel_id] = (cmd_id + 1)%32;
+    return  0;
+}
+*/
 ///////////////////////////////////////////////////////////////////
 // Register a write command in Command List and Command Table
 // for a single buffer.
+// for a single physical buffer.
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////
+unsigned int _hba_write( unsigned int  mode,
+unsigned int _hba_write( unsigned int  channel,
+                         unsigned int  mode,
                          unsigned int  lba,
                          void*         buffer,
+                         paddr_t       buffer,
                          unsigned int  count )
+{
+    return _hba_cmd_set( 0, lba, (unsigned int)buffer, count );
+    return _hba_cmd_set( channel,
+,         // write
+                         lba,
+                         buffer,
+                         count );
+}
 ///////////////////////////////////////////////////////////////////
 // Register a read command in Command List and Command Table
 // for a single buffer.
+// for a single physical buffer.
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////
+unsigned int _hba_read( unsigned int  mode,
+unsigned int _hba_read( unsigned int  channel,
+                        unsigned int  mode,
                         unsigned int  lba,
                         void*         buffer,
+                        paddr_t       buffer,
                         unsigned int  count )
+{
+    return _hba_cmd_set( 1, lba, (unsigned int)buffer, count );
+}
+    return _hba_cmd_set( channel,
+,          // read
+                         lba,
+                         buffer,
+                         count );
+}
 //////////////////////////////////////////////////////////////////
 // This function initializes for a given channel
 …
     unsigned int pt = _get_context_slot(CTX_PTAB_ID);
+    // HBA registers
+    unsigned int*  hba_address;
+    hba_address = (unsigned int*)&seg_ioc_base + HBA_SPAN * channel;
+    hba_address[HBA_PXCLB]  = (unsigned int)(&hba_cmd_list[channel]);
+    hba_address[HBA_PXCLBU] = 0;
+    hba_address[HBA_PXIE]   = 0x40000001;
+    hba_address[HBA_PXIS]   = 0;
+    hba_address[HBA_PXCI]   = 0;
+    hba_address[HBA_PXCMD]  = 1;
+    // HBA registers TODO: ne faut_il pas un V2P pour PXCLB/PXCLBU ? (AG)
+    _hba_set_register( channel, HBA_PXCLB , (unsigned int)&hba_cmd_list[channel] );
+    _hba_set_register( channel, HBA_PXCLBU, 0 );
+    _hba_set_register( channel, HBA_PXIE  , 0x40000001 );
+    _hba_set_register( channel, HBA_PXIS  , 0 );
+    _hba_set_register( channel, HBA_PXCI  , 0 );
+    _hba_set_register( channel, HBA_PXCMD , 1 );
     // command list pointer
 …
     if ( fail )
+    {
+        _tty_get_lock( 0 );
+        _puts("[GIET ERROR] in _hba_init() : command list unmapped\n");
+        _tty_release_lock( 0 );
+        _printf("[GIET ERROR] in _hba_init() : command list unmapped\n");
         return 1;
+    }
 …
         if ( fail )
+        {
+            _tty_get_lock( 0 );
+            _puts("[GIET ERROR] in _hba_init() : command table unmapped\n");
+            _tty_release_lock( 0 );
+            _printf("[GIET ERROR] in _hba_init() : command table unmapped\n");
             return 1;
+        }
 …
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// This function returns the content of the HBA_PXIS register for a given channel,
+// and reset this register to acknoledge IRQ.
+// return 0 if success, > 0 if error
+/////////////////////////////////////////////////////////////////////////////////////
+unsigned int _hba_get_status( unsigned int channel )
+{
+    if( channel >= NB_IOC_CHANNELS )
+    {
+        _printf("\n[GIET ERROR] in _hba_get_status() : illegal channel\n");
+        _exit();
+    }
+    // get HBA_PXIS value
+    unsigned int status = _hba_get_register( channel, HBA_PXIS );
+    // reset HBA_PXIS
+    _hba_set_register( channel, HBA_PXIS, 0 );
+    return status;
+}
 // Local Variables:

soft/giet_vm/giet_drivers/hba_driver.h

-                      r289
+                      r295
 } hba_cmd_entry_t;
 typedef struct hba_cmd_table_s  // size = 256 bytes
+typedef struct hba_cmd_table_s  // size = 4096 bytes
+{
 …
 ///////////////////////////////////////////////////////////////////////////////////
+unsigned int _hba_write( unsigned int mode,
+                         unsigned int lba,       // logic bloc address on device
+                         void*        buffer,    // memory buffer base address
+                         unsigned int count );   // number of blocs
+extern unsigned int _hba_init ( unsigned int channel );
+unsigned int _hba_read ( unsigned int mode,
+                         unsigned int lba,       // logic bloc address on device
+                         void*        buffer,    // memory buffer base address
+                         unsigned int count );   // number of blocks
+extern unsigned int _hba_write( unsigned int channel,     // channel index
+                                unsigned int mode,        // BOOT / KERNEL / USER
+                                unsigned int lba,         // logic bloc address on device
+                                unsigned long long paddr, // memory buffer base address
+                                unsigned int count );     // number of blocs
+unsigned int _hba_init ( unsigned int channel );
+extern unsigned int _hba_read ( unsigned int channel,     // channel index
+                                unsigned int mode,        // BOOT / KERNEL / USER
+                                unsigned int lba,         // logic bloc address on device
+                                unsigned long long paddr, // memory buffer base address
+                                unsigned int count );     // number of blocks
+unsigned int _hba_get_status( unsigned int   channel,
+                              unsigned int*  status );
+extern unsigned int _hba_get_status( unsigned int   channel );
+unsigned int _hba_reset_status( unsigned int channel );
+unsigned int _hba_get_block_size ();
+extern unsigned int _hba_get_block_size ();

soft/giet_vm/giet_drivers/icu_driver.c

-                      r263
+                      r295
 #if USE_XICU
     _puts("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n");
+    _printf("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n");
     return 1;
 #else
 …
 #if USE_XICU
     _puts("[GIET ERROR] _icu_get_index() should not be used if USE_XICU is set\n");
+    _printf("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n");
     return 1;
 #else

soft/giet_vm/giet_drivers/ioc_driver.c

-                      r289
+                      r295
 ///////////////////////////////////////////////////////////////////////////////////
 // The ioc_driver.c and ioc_driver.h files are part ot the GIET-VM kernel.
+// This driver supports the SocLib vci_block_device component, that is
+// a single channel, block oriented, external storage contrÃŽler.
+//
+// It can exist only one block-device controler in the architecture.
+//
+// The _ioc_read() and _ioc_write() functions use the _ioc_access() function,
+// that is always blocking. The _ioc_access function will call the read or
+// write function in the driver of the choosen IOC peripheral, which can be for
+// now: BDV, HBA and SPI. This function can be called in 4 modes:
+//
+// - In BOOT_PA mode, the _ioc_access() function use the buffer virtual address
+//   as a physical address (as the page tables are not build). This mode is
+//   used by the boot code to load the map.bin file into memory.
+//
+// - In BOOT_VA mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address. This mode is used by the boot code to
+//   load the various .elf files into memory.
+//
+// - In KERNEL mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address. There is no checking of user access
+//   right to the memory buffer.  This mode must be used to access IOC, for an
+//   "open" system call.
+//
+// - In USER mode, the _ioc_access() function makes a V2P translation to
+//   compute the buffer physical address. The user access right to the memory
+//   buffer must be checked.  This mode must be used to access IOC, for a
+//   "read/write" system call.
+//
+// This abstact driver define a generic API, supporting various physical
+// block device controlers, including:
+// - vci_block_device : single channel)                    => bdv_driver
+// - vci_ahci         : multi channels                     => hba_driver
+// - sd_card          : single channel                     => sdc_driver
+// - ramdisk (single channel meory mapped virtual disk)    => rdk_driver
+//
+// It can exist only one block-device type in the architecture, that must be
+// defined by one of the following configuration variables in hard_config.h file:
+// USE_IOC_BDV, USE_IOC_SDC, USE_IOC_HBA, USE_IOC_RDK.
+//
+// Any physical driver xxx must provide the following API:
+// - _xxx_init()
+// - _xxx_read()
+// - _xxx_write()
+// - _xxx_get_status()
+// - _xxx_get_block_size()
+// The "channel" parameter is no transmited to single channel devices.
+//
+// The _ioc_read() and _ioc_write() functions are always blocking for
+// the calling user program.
+//
+// These functions compute the physical address of the memory buffer before
+// calling the proper physical device. They can be called in 3 modes:
+//
+// - In BOOT mode, these functions use the buffer virtual address
+//   as a physical address if the MMU is not activated.
+//   They make a V2P translation if the MMU is activated.
+//   This mode is used to load the map.bin file (before memory activation),
+//   or to load the various .elf files (after MMU activation).
+//
+// - In KERNEL mode, these functions make a V2P translation to
+//   compute the buffer physical address.
+//   There is no checking of user access right to the memory buffer.
+//   This mode must be used for an "open" system call.
+//
+// - In USER mode, these functions make a V2P translation to
+//   compute the buffer physical address.
+//   The user access right to the memory buffer are checked.
+//   This mode must be used for a "read" or "write" system call.
 //
 // The IOMMU can be activated or not:
 …
 //   if the IOMMU is not activated.
 // An error code is returned if these conditions are not verified.
+//
+// The "seg_ioc_base" virtual base address of the segment containing the
+// memory-mapped registers of the device must be defined in the giet_vsegs.ld file.
+// If the RAMDISK is used, an extra memory segment with virtual base address
+// "seg_ramdisk_base" must be defined in the giet_vsegs.ld file.
 ///////////////////////////////////////////////////////////////////////////////////
+// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file.
+// Implementation note:
+// In order to share the code, the two _ioc_read() and _ioc_write() functions
+// call the same _ioc_access() function.
 ///////////////////////////////////////////////////////////////////////////////////
 #include <giet_config.h>
 #include <ioc_driver.h>
+#include <bdv_driver.h>
+#include <hba_driver.h>
+#include <sdc_driver.h>
+#include <rdk_driver.h>
 #include <utils.h>
 #include <tty_driver.h>
 …
 #endif
 #if (USE_BDV + USE_SPI + USE_HBA) != 1
 # error: You must use only one IOC controller (BDV or SPI or HBA)
 #endif
 #if USE_BDV
+#if (USE_IOC_BDV + USE_IOC_SPI + USE_IOC_HBA + USE_IOC_RDK) != 1
+# error: You must use only one IOC controller type (BDV or SPI or HBA or RDK)
+#endif
+#if USE_IOC_BDV
 # include <bdv_driver.h>
 #endif
 #if USE_SPI
+#if USE_IOC_SPI
 # include <sdc_driver.h>
 #endif
 #if USE_HBA
+#if USE_IOC_HBA
 # include <hba_driver.h>
 #endif
+#if USE_IOC_RDK
+# include <rdk_driver.h>
+#endif
+///////////////////////////////////////////////////////////////////////////////
+// IOC global variables
+///////////////////////////////////////////////////////////////////////////////
 #define in_unckdata __attribute__((section (".unckdata")))
-///////////////////// IOC global variables
-in_unckdata unsigned int _ioc_lock = 0;
-in_unckdata unsigned int _ioc_status = 0;
-in_unckdata volatile unsigned int _ioc_gtid;
 in_unckdata volatile unsigned int _ioc_iommu_ix1 = 0;
 in_unckdata volatile unsigned int _ioc_iommu_npages;
 ///////////////////////////////////////////////////////////////////////////////
-//      _ioc_access()
 // This function transfer data between a memory buffer and the block device.
 // The buffer lentgth is (count*block_size) bytes.
 // Arguments are:
 // - to_mem     : from external storage to memory when non 0.
 // - kernel     : kernel buffer with identity mapping when non 0.
+// - mode       : BOOT_PA / BOOT_VA / KERNEL / USER
 // - lba        : first block index on the external storage.
 // - buf_vaddr  : virtual base address of the memory buffer.
 …
 ///////////////////////////////////////////////////////////////////////////////
 static unsigned int _ioc_access( unsigned int to_mem,
+                                 unsigned int channel,
                                  unsigned int mode,
                                  unsigned int lba,
 …
 #if GIET_DEBUG_IOC_DRIVER
+_tty_get_lock( 0 );
+_puts("\n[IOC DEBUG] Enter _ioc_access() at cycle ");
+_putd( _get_proctime() );
+_puts(" for processor ");
+_putd( _get_procid() );
+_puts("\n - mode    = ");
+_putd( mode );
+_puts("\n - vaddr   = ");
+_putx( buf_vaddr );
+_puts("\n - sectors = ");
+_putd( count );
+_puts("\n - lba     = ");
+_putx( lba );
+_puts("\n");
+_tty_release_lock( 0 );
+unsigned int procid  = _get_procid();
+unsigned int cid     = procid / NB_PROCS_MAX;
+unsigned int lpid    = procid % NB_PROCS_MAX;
+unsigned int x       = cid >> Y_WIDTH;
+unsigned int y       = cid & ((1<<Y_WIDTH) - 1);
+_printf("\n[IOC DEBUG] Processor[%d,%d,%d] enters _ioc_access() at cycle %d\n"
+        " - channel  = %d\n"
+        " - mode     = %d\n"
+        " - vaddr    = %d\n"
+        " - sectors  = %d\n"
+        " - lba      = %d\n",
+        x, y, lpid, _get_proctime(), channel, mode, buf_vaddr, count, lba );
 #endif
 …
     if ((unsigned int) buf_vaddr & 0x3)
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[GIET ERROR] in _ioc_access() : buffer not word aligned\n");
+        _tty_release_lock( 0 );
+        return 1;
+        _printf("\n[GIET ERROR] in _ioc_access() : buffer not word aligned\n");
+        _exit();
+    }
+    // check channel
+    if ( (USE_IOC_HBA == 0) && (channel > 0) )
+    {
+        _printf("\n[GIET ERROR] in _ioc_access() : channel must be 0 when HBA not used\n");
+        _exit();
+    }
     unsigned int length = count << 9;  // count * 512 bytes
     // computing target buffer physical address
     if ( mode == IOC_BOOT_PA_MODE )                // identity mapping
+    // computing memory buffer physical address
+    if ( (mode == IOC_BOOT_MODE) && ((_get_mmu_mode() & 0x4) == 0) ) // identity mapping
+    {
         buf_paddr = (paddr_t)buf_vaddr;
+    }
     else                                           // V2P translation
+    else                                                    // V2P translation required
+    {
         // get page table virtual address
         pt_vbase = _get_context_slot(CTX_PTAB_ID);
         vpn_min = buf_vaddr >> 12;
         vpn_max = (buf_vaddr + length - 1) >> 12;
+        vpn_min  = buf_vaddr >> 12;
+        vpn_max  = (buf_vaddr + length - 1) >> 12;
         // loop on all virtual pages covering the user buffer
+        for (vpn = vpn_min, ix2 = 0 ;
+             vpn <= vpn_max ;
+             vpn++, ix2++ )
+        for (vpn = vpn_min, ix2 = 0 ; vpn <= vpn_max ; vpn++, ix2++ )
+        {
             // get ppn and flags for each vpn
 …
             if ( ko )
+            {
+                _tty_get_lock( 0 );
+                _puts("\n[GIET ERROR] in _ioc_access() : buffer unmapped\n");
+                _tty_release_lock( 0 );
+                _printf("\n[GIET ERROR] in _ioc_access() : buffer unmapped\n");
                 return 1;
+            }
 …
             if ( (mode == IOC_USER_MODE) && ((flags & PTE_U) == 0) )
+            {
+                _tty_get_lock( 0 );
+                _puts("\n[GIET ERROR] in _ioc_access() : buffer not user accessible\n");
+                _tty_release_lock( 0 );
+                _printf("\n[GIET ERROR] in _ioc_access() : buffer not user accessible\n");
                 return 1;
+            }
 …
             if ( ((flags & PTE_W) == 0 ) && to_mem )
+            {
+                _tty_get_lock( 0 );
+                _puts("\n[GIET ERROR] in _ioc_access() : buffer not writable\n");
+                _tty_release_lock( 0 );
+                _printf("\n[GIET ERROR] in _ioc_access() : buffer not writable\n");
                 return 1;
+            }
 …
             if (ix2 > 511) // check buffer length < 2 Mbytes
+            {
+                _tty_get_lock( 0 );
+                _puts("\n[GIET ERROR] in _ioc_access() : user buffer > 2 Mbytes\n");
+                _tty_release_lock( 0 );
+                _printf("\n[GIET ERROR] in _ioc_access() : user buffer > 2 Mbytes\n");
                 return 1;
+            }
 …
             if ((ppn - ppn_first) != ix2)
+            {
+                _tty_get_lock( 0 );
+                _puts("[GIET ERROR] in _ioc_access() : split physical buffer\n");
+                _tty_release_lock( 0 );
+                _printf("[GIET ERROR] in _ioc_access() : split physical buffer\n");
                 return 1;
+            }
 …
     else         // memory read : update data caches
+    {
         // L1 cache : nothing to do if L1 write-through
+        // L1 cache : nothing to do for L1 write-through
         // L2 cache (only if IOB used)
 …
     if ( GIET_USE_IOMMU ) buf_paddr = (paddr_t) buf_xaddr;
+#if   USE_BDV
+    if (to_mem) error = _bdv_read (mode, lba, buf_paddr, count);
+    else        error = _bdv_write(mode, lba, buf_paddr, count);
+#elif USE_SPI
+    if (to_mem) error = _sdc_read (mode, lba, buf_paddr, count);
+    else        error = _sdc_write(mode, lba, buf_paddr, count);
+#elif USE_HBA
+    if (to_mem) error = _hba_read (mode, lba, buf_paddr, count);
+    else        error = _hba_write(mode, lba, buf_paddr, count);
+    ///////////////////////////////////////////
+    // select the proper physical device
+    ///////////////////////////////////////////
+#if       ( USE_IOC_BDV )
+#if GIET_DEBUG_IOC_DRIVER
+_printf("\n[IOC DEBUG] Calling BDV driver\n");
+#endif
+        if (to_mem) error = _bdv_read ( mode, lba, buf_paddr, count);
+        else        error = _bdv_write( mode, lba, buf_paddr, count);
+#elif ( USE_IOC_SPI )
+#if GIET_DEBUG_IOC_DRIVER
+_printf("\n[IOC DEBUG] Calling SPI driver\n");
+#endif
+        if (to_mem) error = _sdc_read (mode, lba, buf_paddr, count);
+        else        error = _sdc_write(mode, lba, buf_paddr, count);
+#elif ( USE_IOC_HBA )
+#if GIET_DEBUG_IOC_DRIVER
+_printf("\n[IOC DEBUG] Calling HBA driver\n");
+#endif
+        if (to_mem) error = _hba_read (channel, mode, lba, buf_paddr, count);
+        else        error = _hba_write(channel, mode, lba, buf_paddr, count);
+#elif ( USE_IOC_RDK )
+#if GIET_DEBUG_IOC_DRIVER
+_printf("\n[IOC DEBUG] Calling RDK driver\n");
+#endif
+        if (to_mem) error = _rdk_read (lba, buf_vaddr, count);
+        else        error = _rdk_write(lba, buf_vaddr, count);
 #endif
 …
 ///////////////////////////////////////////////////////////////////////////////
-//       _ioc_init()
 // This function cheks block size, and activates the IOC interrupts.
 // Return 0 for success.
 …
 unsigned int _ioc_init( unsigned int channel )
+{
+#if   USE_BDV
+    return _bdv_init( channel );
+#elif USE_SPI
+    return _sdc_init( channel );
+#elif USE_HBA
+#if   ( USE_IOC_BDV )
+    return _bdv_init();
+#elif ( USE_IOC_SPI )
+    return _sdc_init();
+#elif ( USE_IOC_HBA )
     return _hba_init( channel );
+#endif
+#elif ( USE_IOC_RDK )
+    return _rdk_init();
+#endif
+}
 ///////////////////////////////////////////////////////////////////////////////
-//     _ioc_read()
 // Transfer data from the block device to a memory buffer.
 // - mode     : BOOT / KERNEL / USER
+// - mode     : BOOT_PA / BOOT_VA / KERNEL / USER
 // - lba      : first block index on the block device
 // - buffer   : base address of the memory buffer (must be word aligned)
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _ioc_read( unsigned int mode,
+unsigned int _ioc_read( unsigned int channel,
+                        unsigned int mode,
                         unsigned int lba,
                         void*        buffer,
 …
+{
     return _ioc_access( 1,        // read access
+                        channel,
                         mode,
                         lba,
 …
 ///////////////////////////////////////////////////////////////////////////////
-//     _ioc_write()
 // Transfer data from a memory buffer to the block device.
 // - mode     : BOOT / KERNEL / USER
+// - mode     : BOOT_PA / BOOT_VA / KERNEL / USER
 // - lba      : first block index on the block device
 // - buffer   : base address of the memory buffer (must be word aligned)
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _ioc_write( unsigned int mode,
+unsigned int _ioc_write( unsigned int channel,
+                         unsigned int mode,
                          unsigned int lba,
                          const void*  buffer,
 …
+{
     return _ioc_access( 0,        // write access
+                        channel,
                         mode,
                         lba,
 …
 ///////////////////////////////////////////////////////////////////////////////
-//     _ioc_get_status()
 // This function returns in the status variable, the transfert status, and
 // acknowledge the IRQ if the IOC controler is not busy.
 // Returns 0 if success, > 0 if error
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _ioc_get_status( unsigned int  channel,
+                              unsigned int* status )
+{
+#if   USE_BDV
+    return _bdv_get_status(channel, status);
+#elif USE_SPI
+    return _sdc_get_status(channel, status);
+#elif USE_HBA
+    return _hba_get_status(channel, status);
+#endif
+unsigned int _ioc_get_status( unsigned int  channel )
+{
+#if   ( USE_IOC_BDV )
+    return _bdv_get_status( );
+#elif ( USE_IOC_SPI )
+    return _sdc_get_status( );
+#elif ( USE_IOC_HBA )
+    return _hba_get_status( channel );
+#elif ( USE_IOC_RDK )
+    _printf("[GIET ERROR] _ioc_get_status() should not be called");
+    _printf(" when RAMDISK  is used...\n");
+    _exit();
+    return 0;
+#endif
+}
 ///////////////////////////////////////////////////////////////////////////////
-//     _ioc_get_block_size()
 // This function returns the block_size with which the IOC has been configured.
 ///////////////////////////////////////////////////////////////////////////////
 unsigned int _ioc_get_block_size()
+{
+#if   USE_BDV
+#if   ( USE_IOC_BDV )
     return _bdv_get_block_size();
+#elif USE_SPI
+#elif ( USE_IOC_SPI )
     return _sdc_get_block_size();
+#elif USE_HBA
+#elif ( USE_IOC_HBA )
     return _hba_get_block_size();
+#endif
+#elif ( USE_IOC_RDK )
+    return 512;
+#endif
+}

soft/giet_vm/giet_drivers/ioc_driver.h

-                      r289
+                      r295
 ///////////////////////////////////////////////////////////////////////////////////
-enum IOC_registers
+{
-    BLOCK_DEVICE_BUFFER,
-    BLOCK_DEVICE_LBA,
-    BLOCK_DEVICE_COUNT,
-    BLOCK_DEVICE_OP,
-    BLOCK_DEVICE_STATUS,
-    BLOCK_DEVICE_IRQ_ENABLE,
-    BLOCK_DEVICE_SIZE,
-    BLOCK_DEVICE_BLOCK_SIZE,
-    BLOCK_DEVICE_BUFFER_EXT,
-};
-enum IOC_operations
+{
-    BLOCK_DEVICE_NOOP,
-    BLOCK_DEVICE_READ,
-    BLOCK_DEVICE_WRITE,
-};
-enum IOC_status
+{
-    BLOCK_DEVICE_IDLE,
-    BLOCK_DEVICE_BUSY,
-    BLOCK_DEVICE_READ_SUCCESS,
-    BLOCK_DEVICE_WRITE_SUCCESS,
-    BLOCK_DEVICE_READ_ERROR,
-    BLOCK_DEVICE_WRITE_ERROR,
-    BLOCK_DEVICE_ERROR,
-};
 enum IOC_driver_modes
+{
+    IOC_BOOT_PA_MODE,  // No V2P translation / Polling IOC_STATUS / no access checking
+    IOC_BOOT_VA_MODE,  // V2P translation    / Polling IOC_STATUS / no access checking
+    IOC_KERNEL_MODE,   // V2P translation    / Descheduling + IRQ / no access checking
+    IOC_USER_MODE,     // V2P translation    / Descheduling + IRQ / access checking
+    IOC_BOOT_MODE   = 0,     //  Polling IOC_STATUS / no access right checking
+    IOC_KERNEL_MODE = 1,     //  Descheduling + IRQ / no access right checking
+    IOC_USER_MODE   = 2,     //  Descheduling + IRQ / access right checking
 };
 ///////////////////////////////////////////////////////////////////////////////////
 // IOC access functions and variables (vci_block_device)
+// IOC global variables (generic disk controller)
 ///////////////////////////////////////////////////////////////////////////////////
-extern unsigned int _ioc_lock;
-extern unsigned int _ioc_status;
-extern volatile unsigned int _ioc_gtid;
 extern volatile unsigned int _ioc_iommu_ix1;
 extern volatile unsigned int _ioc_iommu_npages;
+///////////////////////////////////////////////////////////////////////////////////
+// IOC access functions  (generic disk controller)
+///////////////////////////////////////////////////////////////////////////////////
 extern unsigned int _ioc_init( unsigned int channel );
+extern unsigned int _ioc_write( unsigned int mode,
+extern unsigned int _ioc_write( unsigned int channel,
+                                unsigned int mode,
                                 unsigned int lba,
                                 const void*  buffer,
                                 unsigned int count );
+extern unsigned int _ioc_read(  unsigned int mode,
+extern unsigned int _ioc_read(  unsigned int channel,
+                                unsigned int mode,
                                 unsigned int lba,
                                 void*        buffer,
                                 unsigned int count );
+extern unsigned int _ioc_get_status( unsigned int  channel,
+                                     unsigned int* status );
+extern unsigned int _ioc_get_status( unsigned int channel );
 extern unsigned int _ioc_get_block_size();

soft/giet_vm/giet_drivers/mmc_driver.c

-                      r263
+                      r295
     if ( (x >= X_SIZE) || (y >= Y_SIZE) )
+    {
+        _puts("\n[GIET ERROR] in _memc_inval() : illegal cluster index[");
+        _putd( x );
+        _puts(",");
+        _putd( y );
+        _puts("]\n");
+        _puts("   - paddr      = ");
+        _putl( buf_paddr );
+        _puts("\n   - cluster_xy = ");
+        _putx( cluster_xy );
+        _puts("\n");
+        _printf("\n[GIET ERROR] in _memc_inval() : illegal cluster_xy for paddr %l\n",
+                 buf_paddr );
         _exit();
+    }
 …
     if ( (x >= X_SIZE) || (y >= Y_SIZE) )
+    {
+        _puts("\n[GIET ERROR] in _memc_sync() : illegal cluster index[");
+        _putd( x );
+        _puts(",");
+        _putd( y );
+        _puts("]\n");
+        _puts("   - paddr      = ");
+        _putl( buf_paddr );
+        _puts("\n   - cluster_xy = ");
+        _putx( cluster_xy );
+        _puts("\n");
+        _printf( "\n[GIET ERROR] in _memc_sync() : illegal cluster_xy for paddr %l\n",
+                 buf_paddr );
         _exit();
+    }

soft/giet_vm/giet_drivers/mwr_driver.c

r263	r295
56	56	paddr_t channel_pbase )
57	57	{
58		_p~~uts~~(" [GIET_ERROR] _mwr_hw_init() function not supported yet\n");
	58	_printf(" [GIET_ERROR] _mwr_hw_init() function not supported yet\n");
59	59	_exit();
60	60

soft/giet_vm/giet_drivers/nic_driver.c

-                      r258
+                      r295
 #define in_unckdata __attribute__((section (".unckdata")))
+///////////////////////////////////////////////////////////////////////////////
+// This low_level function returns the value contained in register (index).
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _nic_get_register( unsigned int channel,
+                                unsigned int index )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_nic_base +
+                           NIC_CHANNEL_SPAN*channel + index;
+    return _io_extended_read( vaddr );
+}
+///////////////////////////////////////////////////////////////////////////////
+// This low-level function set a new value in register (index).
+///////////////////////////////////////////////////////////////////////////////
+void _nic_set_register( unsigned int channel,
+                        unsigned int index,
+                        unsigned int value )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_nic_base +
+                           NIC_CHANNEL_SPAN*channel + index;
+    _io_extended_write( vaddr, value );
+}
 //////////////////////////////////////////////////////////////////////////////////
-// _nic_sync_write()
 // Transfer data from an memory buffer to the NIC device using a memcpy.
 // - buffer : base address of the memory buffer.
 …
                               unsigned int   length )
+{
     _puts("[GIET ERROR] _nic_sync_write function not implemented\n");
+    _printf("[GIET ERROR] _nic_sync_write function not implemented\n");
     _exit();
 …
+}
 //////////////////////////////////////////////////////////////////////////////////
-// _nic_sync_read()
 // Transfer data from the NIC device to a memory buffer using a memcpy.
 // - buffer : base address of the memory buffer.
 …
                              unsigned int   length )
+{
     _puts("[GIET ERROR] _nic_sync_read function not implemented\n");
+    _printf("[GIET ERROR] _nic_sync_read function not implemented\n");
     _exit();
 …
+}
 //////////////////////////////////////////////////////////////////////////////////
-// _nic_cma_start()
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
 unsigned int _nic_cma_start( )
+{
     _puts("[GIET ERROR] _nic_cma_start function not implemented\n");
+    _printf("[GIET ERROR] _nic_cma_start() not implemented\n");
     _exit();
 …
+}
 //////////////////////////////////////////////////////////////////////////////////
-// _nic_cma_stop()
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
 unsigned int _nic_cma_stop()
+{
     _puts("[GIET ERROR] _nic_cma_stop function not implemented\n");
+    _printf("[GIET ERROR] _nic_cma_stop() not implemented\n");
     _exit();
 …
+}
+//////////////////////////////////////////////////////////////////////////////////
+// This ISR handles IRQx from a NIC RX channeL
+//////////////////////////////////////////////////////////////////////////////////
+void _nic_rx_isr( unsigned int irq_type,
+                  unsigned int irq_id,
+                  unsigned int channel )
+{
+    _printf("[GIET ERROR] _nic_rx_isr() not implemented\n");
+    _exit();
+}
+//////////////////////////////////////////////////////////////////////////////////
+// This ISR handles IRQx from a NIC RX channeL
+//////////////////////////////////////////////////////////////////////////////////
+void _nic_tx_isr( unsigned int irq_type,
+                  unsigned int irq_id,
+                  unsigned int channel )
+{
+    _printf("[GIET ERROR] _nic_tx_isr() not implemented\n");
+    _exit();
+}
 // Local Variables:

soft/giet_vm/giet_drivers/nic_driver.h

-                      r258
+                      r295
 #ifndef _GIET_NIC_DRIVERS_H_
 #define _GIET_NIC_DRIVERS_H_
+///////////////////////////////////////////////////////////////////////////////////
+// NIC Registers  (vci_multi_nic)
+///////////////////////////////////////////////////////////////////////////////////
+enum SoclibMultiNicHyperviseurRegisters {
+    NIC_G_VIS                        = 0,   // bitfield : bit N = 0 -> channel N disabled
+    NIC_G_ON                         = 1,   // boolean : NIC component activated
+    NIC_G_NB_CHAN                    = 2,   // Number of channels present in this NIC (read only)
+    NIC_G_BC_ENABLE                  = 3,   // boolean : Enable Broadcast if non zero
+    NIC_G_TDM_ENABLE                 = 4,   // boolean : TDM Scheduler if non zero
+    NIC_G_TDM_PERIOD                 = 5,   // TDM time slot value
+    NIC_G_BYPASS_ENABLE              = 6,   // boolean : Enable bypass for TX packets
+    // alignment
+    NIC_G_MAC_4                      = 8,   // channel mac address 32 LSB bits array[8]
+    NIC_G_MAC_2                      = 16,  // channel mac address 16 MSB bits array[8]
+    // alignment
+    NIC_G_NPKT_RX_G2S_RECEIVED       = 32,  // number of packets received on GMII RX port
+    NIC_G_NPKT_RX_G2S_DISCARDED      = 33,  // number of RX packets discarded by RX_G2S FSM
+    NIC_G_NPKT_RX_DES_SUCCESS        = 34,  // number of RX packets transmited by RX_DES FSM
+    NIC_G_NPKT_RX_DES_TOO_SMALL      = 35,  // number of discarded too small RX packets (<60B)
+    NIC_G_NPKT_RX_DES_TOO_BIG        = 36,  // number of discarded too big RX packets (>1514B)
+    NIC_G_NPKT_RX_DES_MFIFO_FULL     = 37,  // number of discarded RX packets because fifo full
+    NIC_G_NPKT_RX_DES_CRC_FAIL       = 38,  // number of discarded RX packets because CRC32 failure
+    NIC_G_NPKT_RX_DISPATCH_RECEIVED  = 39,  // number of packets received by RX_DISPATCH FSM
+    NIC_G_NPKT_RX_DISPATCH_BROADCAST = 40,  // number of broadcast RX packets received
+    NIC_G_NPKT_RX_DISPATCH_DST_FAIL  = 41,  // number of discarded RX packets for DST MAC not found
+    NIC_G_NPKT_RX_DISPATCH_CH_FULL   = 42,  // number of discarded RX packets for channel full
+    NIC_G_NPKT_TX_DISPATCH_RECEIVED  = 43,  // number of packets received by TX_DISPATCH FSM
+    NIC_G_NPKT_TX_DISPATCH_TOO_SMALL = 44,  // number of discarded too small TX packets (<60B)
+    NIC_G_NPKT_TX_DISPATCH_TOO_BIG   = 45,  // number of discarded too big TX packets (>1514B)
+    NIC_G_NPKT_TX_DISPATCH_SRC_FAIL  = 46,  // number of discarded TX packets for SRC MAC failed
+    NIC_G_NPKT_TX_DISPATCH_BROADCAST = 47,  // number of broadcast TX packets received
+    NIC_G_NPKT_TX_DISPATCH_BYPASS    = 48,  // number of bypassed TX->RX packets
+    NIC_G_NPKT_TX_DISPATCH_TRANSMIT  = 49,  // number of transmit TX packets
+    NIC_CHANNEL_SPAN                 = 0x2000,
+};
+/////////////////////////////////////////////////////////////////////
+// A container descriptor has the following form:
+// LOW WORD : Container LSB base address
+// HIGH WORD: Container status (leftmost bit), '1' means full
+//            Base address MSB extension, if needed (right aligned)
+//////////////////////////////////////////////////////////////////////
+enum SoclibMultiNicChannelRegisters
+{
+    NIC_RX_DESC_LO_0          = 0,   // RX_0 descriptor low word         (Read/Write)
+    NIC_RX_DESC_HI_0          = 1,   // RX_0 descriptor high word        (Read/Write)
+    NIC_RX_DESC_LO_1          = 2,   // RX_1 descriptor low word         (Read/Write)
+    NIC_RX_DESC_HI_1          = 3,   // RX_1 descriptor high word        (Read/Write)
+    NIC_TX_DESC_LO_0          = 4,   // TX_0 descriptor low word         (Read/Write)
+    NIC_TX_DESC_HI_0          = 5,   // TX_0 descriptor high word        (Read/Write)
+    NIC_TX_DESC_LO_1          = 6,   // TX_1 descriptor low word         (Read/Write)
+    NIC_TX_DESC_HI_1          = 7,   // TX_1 descriptor high word        (Read/Write)
+    NIC_MAC_4                 = 8,   // channel mac address 32 LSB bits  (Read Only)
+    NIC_MAC_2                 = 9,   // channel mac address 16 LSB bits  (Read Only)
+    NIC_RX_RUN                = 10,  // RX packets can be received       (write_only)
+    NIC_TX_RUN                = 11,  // TX packets can be transmitted    (write_only)
+};
 ///////////////////////////////////////////////////////////////////////////////////
 …
 extern unsigned int _nic_cma_stop();
+extern void _nic_rx_isr( unsigned int irq_type,
+                         unsigned int irq_id,
+                         unsigned int channel );
+extern void _nic_tx_isr( unsigned int irq_type,
+                         unsigned int irq_id,
+                         unsigned int channel );
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/giet_drivers/sdc_driver.c

-                      r289
+                      r295
 // Copyright (c) UPMC-LIP6
 ///////////////////////////////////////////////////////////////////////////////////
 #include <sdc_driver.h>
+#include <tty_driver.h>
 #include <utils.h>
 …
         if ( sdcard_rsp != 0x01 )
+        {
+                _puts("card CMD0 failed ");
+                _printf("[SDC ERROR] card CMD0 failed\n");
                 return sdcard_rsp;
+        }
 …
         if (!SDCARD_CHECK_R1_VALID(sdcard_rsp))
+    {
                 _puts("card CMD8 failed ");
+                _printf("[SDC ERROR] card CMD8 failed\n");
                 return sdcard_rsp;
+        }
 …
                 ersp = (ersp << 8) | _sdc_receive_char();
                 ersp = (ersp << 8) | _sdc_receive_char();
+                if ((ersp & 0xffff) != 0x0101) {
+                if ((ersp & 0xffff) != 0x0101)
+        {
                         // voltage mismatch
+                        _puts("card CMD8 mismatch: ");
+                        _putx(ersp);
+                        _printf("[SDC ERROR] card CMD8 mismatch : ersp = %x\n");
                         return sdcard_rsp;
+                }
                 _puts("v2 or later ");
+                _printf("[SDC WARNING] v2 or later ");
                 sdcard.sdhc = 1;
+        }
 …
+    {
                 // other error
                 _puts("card CMD8 error ");
+                _printf("[SDC ERROR] card CMD8 error\n");
                 return sdcard_rsp;
+        }
 …
         if (sdcard_rsp)
+    {
                 _puts("SD ACMD41 failed ");
+                _printf("[SDC ERROR] ACMD41 failed\n");
                 return sdcard_rsp;
+        }
 …
                 if (sdcard_rsp)
+        {
                         _puts("SD CMD58 failed ");
+                        _printf("[SDC ERROR] CMD58 failed\n");
                         return sdcard_rsp;
+                }
 …
                 if (ersp & 0x40000000)
+        {
+                        _puts("SDHC ");
+                } else
+                        _printf(" SDHC ");
+                }
+        else
+        {
                         sdcard.sdhc = 0;
 …
                 _sdc_disable();
+        }
         _puts("card detected ");
+        _printf("card detected\n");
         return 0;
+}
 …
 // Returns 0 if success, other value if failure
 ///////////////////////////////////////////////////////////////////////////////
 unsigned int _sdc_init( unsigned int channel )
+unsigned int _sdc_init()
+{
     spi = (struct spi_dev*) &seg_ioc_base;
 …
     while(1)
+    {
         _puts("Trying to initialize SD card... ");
         sdcard_rsp = _sdc_open( channel );
+        _printf("[SDC WARNING] Trying to initialize SD card...\n");
+        sdcard_rsp = _sdc_open( 0 );  // only channel 0
         if (sdcard_rsp == 0)
+        {
             _puts("OK\n");
+            _printf("OK\n");
             break;
+        }
         _puts("KO\n");
+        _printf("KO\n");
         for (i = 0; i < 1000; i++);
 …
         if (++iter >= SDCARD_RESET_ITER_MAX)
+        {
+            _puts("\nERROR: During SD card reset to IDLE state\n"
+                 "/ card response = ");
+            _putx(sdcard_rsp);
+            _puts("\n");
+            _printf("\n[SDC ERROR] During SD card reset to IDLE state "
+                    "/ card response = %x\n", sdcard_rsp );
             _exit();
+        }
 …
     if (sdcard_rsp)
+    {
         _puts("ERROR: During SD card blocklen initialization\n");
+        _printf("[SDC ERROR] During SD card blocklen initialization\n");
         _exit();
+    }
 …
     );
     _puts("Finish block device initialization\n\r");
+    _printf("[SDC WARNING] Finish SD card initialization\n\r");
     return 0;
 …
 ///////////////////////////////////////////////////////////////////////////////
-//     _sdc_get_status()
 // Transfer data from memory buffer to SD card device.
 // - channel: channel index
 …
 // Returns 0 if success, > 0 if error.
 ///////////////////////////////////////////////////////////////////////////////
+unsigned int _sdc_get_status( unsigned int channel ,
+                              unsigned int* status )
+{
+    *status = BLOCK_DEVICE_IDLE;
+    return 0;
+}
+///////////////////////////////////////////////////////////////////////////////
+//     _sdc_get_block_size()
+unsigned int _sdc_get_status()
+{
+    _printf("[SDC ERROR] function _sdc_get_status() should not be called\n");
+    _exit();
+    return 0;  // to avoid a warning
+}
+///////////////////////////////////////////////////////////////////////////////
 // Returns the block size in bytes of the SD card
 ///////////////////////////////////////////////////////////////////////////////

soft/giet_vm/giet_drivers/sdc_driver.h

-                      r289
+                      r295
 };
+unsigned int _sdc_init( unsigned int channel );
+unsigned int _sdc_init();
 unsigned int _sdc_read( unsigned int mode,
 …
                          unsigned int count);
+unsigned int _sdc_get_status();
 unsigned int _sdc_get_block_size();
-unsigned int _sdc_get_status( unsigned int channel ,
-                              unsigned int* status );

soft/giet_vm/giet_drivers/tim_driver.c

-                      r263
+                      r295
 // The global index is cluster_xy * (NB_PROCS_MAX + NB_TIM_CHANNELS) + local_id
 //
+// The NB_PROCS_MAX and NB_TIM_CHANNELS values must be defined in the
+// hard_config.h file.
+//
+// The register offsets must be defined in the hwr_mapping.h file.
+// The NB_PROCS_MAX and NB_TIM_CHANNELS values must be defined in hard_config.h file.
 /////////////////////////////////////////////////////////////////////////////////////
 // The virtual base address of the segment associated to a channel is:
 …
 #include <giet_config.h>
 #include <tim_driver.h>
+#include <xcu_driver.h>
+#include <tty_driver.h>
 #include <utils.h>
 …
 #if (NB_TIM_CHANNELS > 0)
 in_unckdata volatile unsigned char _user_timer_event[X_SIZE*Y_SIZE*NB_TIM_CHANNELS]
                             = { [0 ... ((X_SIZE*Y_SIZE*NB_TIM_CHANNELS) - 1)] = 0 };
+in_unckdata volatile unsigned char _user_timer_event[(1<<X_WIDTH)*(1<<Y_WIDTH)*NB_TIM_CHANNELS]
+                        = { [0 ... (((1<<X_WIDTH)*(1<<Y_WIDTH)*NB_TIM_CHANNELS) - 1)] = 0 };
 #endif
 ////////////////////////////////////////////////////////////////////////////////////
-//     _timer_start()
 // This function activates a timer in the vci_timer component
 // by writing in the proper register the period value.
 // It can be used by both the kernel to initialise a "system" timer,
 // or by a task (through a system call) to configure an "user" timer.
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _timer_start( unsigned int cluster_xy,
+                           unsigned int local_id,
+                           unsigned int period)
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                  return 1;
+    if (y >= Y_SIZE)                  return 1;
+    if (local_id >= NB_TIM_CHANNELS)  return 1;
+///////////////////////////////////////////////////////////////////////////////////
+void _timer_start( unsigned int cluster_xy,
+                   unsigned int local_id,
+                   unsigned int period)
+{
+#if NB_TIM_CHANNELS
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if ( (x >= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) )
+    {
+        _printf("[GIET ERROR] in _timer_start()\n");
+        _exit();
+    }
     unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base +
 …
     timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period;
     timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0x3;
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////
+//     _timer_stop()
+#else
+    _printf("[GIET ERROR] _timer_start() should not be called when NB_TIM_CHANNELS is 0\n");
+    _exit();
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // This function desactivates a timer in the vci_timer component
 // by writing in the proper register.
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////
+unsigned int _timer_stop( unsigned int cluster_xy,
+                          unsigned int local_id)
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                  return 1;
+    if (y >= Y_SIZE)                  return 1;
+    if (local_id >= NB_TIM_CHANNELS)  return 1;
+void _timer_stop( unsigned int cluster_xy,
+                  unsigned int local_id)
+{
+#if NB_TIM_CHANNELS
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if ( (x >= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) )
+    {
+        _printf("[GIET ERROR] in _timer_stop()\n");
+        _exit();
+    }
     unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base +
 …
     timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0;
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////
+//     _timer_reset_irq()
+#else
+    _printf("[GIET ERROR] _timer_stop() should not be called when NB_TIM_CHANNELS is 0\n");
+    _exit();
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // This function acknowlegge a timer interrupt in the vci_timer
 // component by writing in the proper register.
 …
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////
+unsigned int _timer_reset_irq( unsigned int cluster_xy,
+                               unsigned int local_id )
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                  return 1;
+    if (y >= Y_SIZE)                  return 1;
+    if (local_id >= NB_TIM_CHANNELS)  return 1;
+void _timer_reset_irq( unsigned int cluster_xy,
+                       unsigned int local_id )
+{
+#if NB_TIM_CHANNELS
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if ( (x >= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) )
+    {
+        _printf("[GIET ERROR] in _timer_reset_irq()\n");
+        _exit();
+    }
     unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_tim_base +
 …
     timer_address[local_id * TIMER_SPAN + TIMER_RESETIRQ] = 0;
+    return 0;
+#else
+    _printf("[GIET ERROR] _timer_reset_irq() should not be called when NB_TIM_CHANNELS is 0\n");
+    _exit();
+#endif
+}
 /////////////////////////////////////////////////////////////////////////////
-//     _timer_reset_cpt()
 // This function resets the timer counter. To do so, we re-write the period
 // in the proper register, what causes the count to restart.
 …
 // This function is called during a context switch (user or preemptive)
 //////////////////////////////////////////////////////////////////////i//////
+unsigned int _timer_reset_cpt( unsigned int cluster_xy,
+                               unsigned int local_id)
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                  return 1;
+    if (y >= Y_SIZE)                  return 1;
+    if (local_id >= NB_TIM_CHANNELS)  return 1;
+void _timer_reset_cpt( unsigned int cluster_xy,
+                       unsigned int local_id)
+{
+#if NB_TIM_CHANNELS
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if ( (x >= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) )
+    {
+        _printf("[GIET ERROR in _timer_reset_cpt()\n");
+        _exit();
+    }
     // We suppose that the TIMER_MODE register value is 0x3
 …
     unsigned int period = timer_address[local_id * TIMER_SPAN + TIMER_PERIOD];
     timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period;
+    return 0;
+}
+#else
+    _printf("[GIET ERROR] _timer_reset_cpt should not be called when NB_TIM_CHANNELS is 0\n");
+    _exit();
+#endif
+}
+///////////////////////////////////////////////////////////////////////////////////
+// This ISR handles the IRQs generated by the "user" timers that are
+// replicated in all clusters.
+// The IRQs generated by the "system" timers should be handled by _isr_switch().
+// It can be a HWI or a PTI.
+// The channel argument is the user timer local index.
+//     timer_global_id = cluster_id*(NB_TIM_CHANNELS) + channel
+// The ISR acknowledges the IRQ and registers the event in the proper entry
+// of the _user_timer_event[] array, and a log message is displayed on TTY0.
+///////////////////////////////////////////////////////////////////////////////////
+void _timer_isr( unsigned int irq_type,   // HWI / PTI
+                 unsigned int irq_id,     // index returned by XCU
+                 unsigned int channel )   // user timer index
+{
+#if NB_TIM_CHANNELS
+    unsigned int cluster_xy = _get_procid() / NB_PROCS_MAX;
+    // acknowledge IRQ depending on type
+    if   ( irq_type == IRQ_TYPE_HWI )  _timer_reset_irq( cluster_xy, channel );
+    else                               _xcu_timer_reset_irq( cluster_xy, irq_id );
+    // register the event
+    _user_timer_event[cluster_xy * NB_TIM_CHANNELS + channel] = 1;
+    // display a message on TTY 0
+    _printf("\n[GIET WARNING] User Timer IRQ at cycle %d / cluster = %x / channel = %d\n",
+            _get_proctime(), cluster_xy, channel );
+#else
+    _printf("[GIET ERROR] _timer_isr() should not be called when NB_TIM_CHANNELS == 0\n");
+    _exit();
+#endif
+}

soft/giet_vm/giet_drivers/tim_driver.h

-                      r263
+                      r295
 ///////////////////////////////////////////////////////////////////////////////////
 #ifndef _GIET_TIM_DRIVERS_H_
 #define _GIET_TIM_DRIVERS_H_
+#ifndef _GIET_TIM_DRIVER_H_
+#define _GIET_TIM_DRIVER_H_
 ///////////////////////////////////////////////////////////////////////////////////
 …
 ///////////////////////////////////////////////////////////////////////////////////
+extern volatile unsigned char _timer_event[];
+extern void _timer_start( unsigned int cluster_xy,
+                          unsigned int local_id,
+                          unsigned int period );
+extern unsigned int _timer_start( unsigned int cluster_xy,
+                                  unsigned int local_id,
+                                  unsigned int period );
+extern void _timer_stop( unsigned int cluster_xy,
+                         unsigned int local_id );
 extern unsigned int _timer_stop( unsigned int cluster_xy,
                                  unsigned int local_id );
+extern void _timer_reset_irq( unsigned int cluster_xy,
+                              unsigned int local_id );
 extern unsigned int _timer_reset_irq( unsigned int cluster_xy,
                                       unsigned int local_id );
+extern void _timer_reset_cpt( unsigned int cluster_xy,
+                              unsigned int local_id);
+extern unsigned int _timer_reset_cpt( unsigned int cluster_xy,
+                                      unsigned int local_id);
+extern void _timer_isr( unsigned int irq_type,
+                        unsigned int irq_id,
+                        unsigned int channel );
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/giet_drivers/tty_driver.c

-                      r258
+                      r295
 // This driver supports the SocLib vci_multi_tty component.
 //
-// It can exist only one multi_tty controler in the architecture.
-//
 // The total number of TTY terminals must be defined by the configuration
 // parameter NB_TTY_CHANNELS in the hard_config.h file.
-//
-// The register offsets must be defined in the hwr_mapping.h file.
 //
 // The "system" terminal is TTY[0].
 …
 // as defined in the mapping_info data structure. The corresponding tty_id must
 // be stored in the context of the task by the boot code.
-///////////////////////////////////////////////////////////////////////////////////
-// The virtual base address of the segment associated to a channel is:
 //
+//                  seg_tty_base  + TTY_SPAN * channel_id
+//
+// The seg_tty_base virtual base addresses must be defined in giet_vsegs.ld file.
+// The seg_tty_base must be defined in giet_vsegs.ld file.
+///////////////////////////////////////////////////////////////////////////////////
+// Implementation note:
+//
+// All physical accesses to device registers are done by the two
+// _tty_get_register(), _tty_set_register() low-level functions,
+// that are handling virtual / physical addressing.
 ///////////////////////////////////////////////////////////////////////////////////
 #include <giet_config.h>
 #include <tty_driver.h>
+#include <xcu_driver.h>
 #include <ctx_handler.h>
 #include <utils.h>
 …
 #define in_unckdata __attribute__((section (".unckdata")))
+/////////////////   TTY global variables
+in_unckdata volatile unsigned char _tty_get_buf[NB_TTY_CHANNELS];
+in_unckdata volatile unsigned char _tty_get_full[NB_TTY_CHANNELS]
+//////////////////////////////////////////////////////////////////////////////
+//   TTY global variables
+//////////////////////////////////////////////////////////////////////////////
+in_unckdata volatile unsigned int _tty_rx_buf[NB_TTY_CHANNELS];
+in_unckdata volatile unsigned int _tty_rx_full[NB_TTY_CHANNELS]
                                      = { [0 ... NB_TTY_CHANNELS - 1] = 0 };
+//////////////////////////////////////////////////////////////////////////////
+// This low level function returns the value of register (channel / index)
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _tty_get_register( unsigned int channel,
+                                unsigned int index )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_tty_base + channel*TTY_SPAN + index;
+    return _io_extended_read( vaddr );
+}
+//////////////////////////////////////////////////////////////////////////////
+// This low level function set a new value in register (channel / index)
+//////////////////////////////////////////////////////////////////////////////
+void _tty_set_register( unsigned int channel,
+                        unsigned int index,
+                        unsigned int value )
+{
+    unsigned int* vaddr = (unsigned int*)&seg_tty_base + channel*TTY_SPAN + index;
+    _io_extended_write( vaddr, value );
+}
 /////////////////////////////////////////////////////////////////////////////////
 // This non-blocking function writes a character string from a fixed-length
+// buffer to the TTY_WRITE register of a TTY terminal identified by the
+// channel argument. If the channel argument is 0xFFFFFFFF, the channel
+// index is obtained from the current taxk context.
+// It doesn't use any interrupt.
+// buffer to a TTY terminal identified by the channel argument.
+// This function is intended to be used to handle a system call, and should
+// not be used by the kernel for log messages on TTY 0.
+// protecting exclusive access to the selected terminal.
+// If channel argument is 0xFFFFFFFF, the TTY index is found in the task context.
 // This is a non blocking call: it tests the TTY_STATUS register, and stops
 // the transfer as soon as the TTY_STATUS[WRITE] bit is set.
 …
                          unsigned int channel)   // channel index
+{
+    unsigned int nwritten;
+    unsigned int tty_id;
+    unsigned int* tty_address = (unsigned int *) &seg_tty_base;
+    // compute tty channel
+    if( channel == 0xFFFFFFFF )
+    {
+        tty_id = _get_context_slot(CTX_TTY_ID);
+    }
+    else
+    {
+        tty_id = (unsigned int)channel;
+    }
+    unsigned int  nwritten;
+    // compute and check tty channel
+    if( channel == 0xFFFFFFFF )  channel = _get_context_slot(CTX_TTY_ID);
+    if( channel >= NB_TTY_CHANNELS ) return -1;
     // write string to TTY channel
 …
+    {
         // check tty's status
+        if ((tty_address[tty_id * TTY_SPAN + TTY_STATUS] & 0x2) == 0x2) break;
+        _tty_write_data( tty_id, buffer[nwritten] );
+    }
+        if ( _tty_get_register( channel, TTY_STATUS ) & 0x2 )  break;
+        // write one byte
+        _tty_set_register( channel, TTY_WRITE, (unsigned int)buffer[nwritten] );
+    }
     return nwritten;
+}
 …
 // It uses the TTY_GET_IRQ[tty_id] interrupt and the buffer must have been
 // filled by the TTY_ISR.
 // It test the _tty_get_full[tty_id] register, read the _tty_get_buf[tty_id]
+// It test the _tty_rx_full[tty_id] variable, read the _tty_rx_buf[tty_id]
 // buffer, writes this character to the target buffer, and resets the
 // _tty_get_full[tty_id] register.
+// _tty_rx_full[tty_id] register.
 // The length argument is not used.
 //////////////////////////////////////////////////////////////////////////////
 …
                         unsigned int channel)   // channel index
+{
+    unsigned int tty_id;
+    // compute tty channel
+    if( channel == 0xFFFFFFFF )
+    {
+        tty_id = _get_context_slot(CTX_TTY_ID);
+    }
+    else
+    {
+        tty_id = (unsigned int)channel;
+    }
+    // compute and check tty channel
+    if( channel == 0xFFFFFFFF )  channel = _get_context_slot(CTX_TTY_ID);
+    if( channel >= NB_TTY_CHANNELS ) return -1;
     // read one character from TTY channel
     if (_tty_get_full[tty_id] == 0)
+    if (_tty_rx_full[channel] == 0)
+    {
         return 0;
 …
     else
+    {
         *buffer = _tty_get_buf[tty_id];
         _tty_get_full[tty_id] = 0;
+        *buffer = _tty_rx_buf[channel];
+        _tty_rx_full[channel] = 0;
         return 1;
+    }
+}
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+// This function try to take the hardwired lock protecting exclusive access
+// to TTY terminal identified by the channel argument.
+//////////////////////////////////////////////////////////////////////////////
+// This function try to take the hardwired lock protecting
+// exclusive access to TTY terminal identified by the "channel" argument.
+// It enters a critical section before taking the lock, and save the SR value
+// at address defined by the "save_sr_ptr" argument.
 // It returns only when the lock has been successfully taken.
 //////////////////////////////////////////////////////////////////////////////
 void _tty_get_lock( unsigned int channel )
+{
+    unsigned int* tty_address = (unsigned int *) &seg_tty_base;
     if( channel >= NB_TTY_CHANNELS )
+    {
+        _puts("[GIET ERROR] in _tty_get_lock() : illegal TTY index\n");
+        _exit();
+    }
+    while ( tty_address[channel * TTY_SPAN + TTY_CONFIG] );
+}
 //////////////////////////////////////////////////////////////////////////////
+// This function releases the hardwired lock protecting exclusive access
+// to TTY terminal identified by the channel argument.
+//////////////////////////////////////////////////////////////////////////////
+void _tty_release_lock( unsigned int channel )
+{
     unsigned int* tty_address = (unsigned int *) &seg_tty_base;
+    if( channel >= NB_TTY_CHANNELS )
+    {
+        _puts("[GIET ERROR] in _tty_release_lock() : illegal TTY index\n");
+        _exit();
+    }
+    tty_address[channel * TTY_SPAN + TTY_CONFIG] = 0;
+}
 //////////////////////////////////////////////////////////////////////////////
+// This function returns the content of the TTY_READ register in the
+// TTY terminal identified by the channel argument.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _tty_read_data( unsigned int channel )
+{
+    unsigned int* tty_address = (unsigned int *) &seg_tty_base;
     if( channel >= NB_TTY_CHANNELS )
+    {
         _puts("[GIET ERROR] in _tty_read_data() : illegal TTY index\n");
         _exit();
+    }
     return tty_address[channel * TTY_SPAN + TTY_READ];
+}
+//////////////////////////////////////////////////////////////////////////////
+// This function returns the content of the TTY_STATUS register in the
+// TTY terminal identified by the channel argument.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _tty_get_status( unsigned int channel )
+{
     unsigned int* tty_address = (unsigned int *) &seg_tty_base;
+    if( channel >= NB_TTY_CHANNELS )
+    {
         _puts("[GIET ERROR] in _tty_get_status() : illegal TTY index\n");
+        _exit();
+    }
+    return tty_address[channel * TTY_SPAN + TTY_STATUS];
+}
+//////////////////////////////////////////////////////////////////////////////
+// This function writes one character in the TTY_WRITE register in the
+// TTY terminal identified by the channel argument.
 //////////////////////////////////////////////////////////////////////////////
+void _tty_write_data( unsigned int channel,
+                      char         byte )
+{
+    unsigned int* tty_address = (unsigned int *) &seg_tty_base;
+    if( channel >= NB_TTY_CHANNELS )
+    {
+        _puts("[GIET ERROR] in _tty_write_data() : illegal TTY index\n");
         _exit();
+    }
     tty_address[channel * TTY_SPAN + TTY_WRITE] = (unsigned int) byte;
+}
+void _tty_get_lock( unsigned int   channel,
+                    unsigned int * save_sr_ptr )
+{
+    if( channel >= NB_TTY_CHANNELS ) _exit();
+    _it_disable( save_sr_ptr );
+    while ( _tty_get_register( channel, TTY_CONFIG ) ); // busy waiting
+}
+//////////////////////////////////////////////////////////////////////////////
+// This function releases the hardwired lock protecting
+// exclusive access to TTY terminal identified by the channel argument.
+// It exit the critical section after lock release, and restore SR value
+// from address defined by the "save_sr_ptr" argument.
+//////////////////////////////////////////////////////////////////////////////
+void _tty_release_lock( unsigned int   channel,
+                        unsigned int * save_sr_ptr )
+{
+    if( channel >= NB_TTY_CHANNELS ) _exit();
+    _tty_set_register( channel, TTY_CONFIG, 0 );
+    _it_restore( save_sr_ptr );
+}
+///////////////////////////////////////////////////////////////////////////////////
+// This ISR handles the IRQ signaling that the RX buffer is full.
+// IT can be an HWI or an SWI.
+// There is one single multi_tty component controling all channels.
+// There is one communication buffer _tty_rx_buf[i] and one synchronisation
+// variable _tty_rx_full[i] per channel.
+// A character is lost if the buffer is full when the ISR is executed.
+///////////////////////////////////////////////////////////////////////////////////
+void _tty_rx_isr( unsigned int irq_type,   // HWI / WTI
+                  unsigned int irq_id,     // index returned by XCU
+                  unsigned int channel )   // TTY channel
+{
+    unsigned int cluster_xy = _get_procid() / NB_PROCS_MAX;
+    if ( irq_type == IRQ_TYPE_WTI )   // reset SWI in XCU if required
+    {
+        unsigned int value;
+        _xcu_get_wti_value( cluster_xy, irq_id, &value );
+    }
+    // get character and reset TTY IRQ
+    _tty_rx_buf[channel] = _tty_get_register( channel, TTY_READ );
+#if GIET_DEBUG_IRQS  // we don't take the TTY lock to avoid deadlock
+unsigned int x              = cluster_xy >> Y_WIDTH;
+unsigned int y              = cluster_xy & ((1<<Y_WIDTH)-1);
+unsigned int lpid           = _get_procid() % NB_PROCS_MAX;
+_puts("\n[IRQS DEBUG] Processor[");
+_putd(x );
+_puts(",");
+_putd(y );
+_puts(",");
+_putd(lpid );
+_puts("] enters _tty_rx_isr() at cycle ");
+_putd(_get_proctime() );
+_puts("\n  read byte = ");
+_putx(_tty_rx_buf[channel] );
+_puts("\n");
+#endif
+    // signals character available
+    _tty_rx_full[channel] = 1;
+}
+///////////////////////////////////////////////////////////////////////////////////
+// This ISR handles the IRQ signaling that the TX buffer is empty.
+// IT can be an HWI or an SWI.
+// There is one single multi_tty component controling all channels.
+// There is one communication buffer _tty_rx_buf[i] and one synchronisation
+// variable _tty_rx_full[i] per channel.
+// A character is lost if the buffer is full when the ISR is executed.
+///////////////////////////////////////////////////////////////////////////////////
+void _tty_tx_isr( unsigned int irq_type,   // HWI / WTI
+                  unsigned int irq_id,     // index returned by XCU
+                  unsigned int channel )   // TTY channel
+{
+    _puts("\n[GIET ERROR] the _tty_tx_isr() is not implemented\n");
+    _exit();
+}
 // Local Variables:

soft/giet_vm/giet_drivers/tty_driver.h

-                      r258
+                      r295
 ///////////////////////////////////////////////////////////////////////////////////
 // TTY access functions and variables
+// TTY variables
 ///////////////////////////////////////////////////////////////////////////////////
 …
 extern volatile unsigned char _tty_get_full[];
+/////// rather high level access functions ///////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+// TTY access functions
+//////////////////////////////////////////////////////////////////////////////////
 extern unsigned int _tty_write( const char*  buffer,
                                 unsigned int length,     // number of characters
                                 unsigned int channel );  // channel index
+                                unsigned int length,
+                                unsigned int channel );
 extern unsigned int _tty_read(  char*        buffer,
                                 unsigned int length,     // unused
                                 unsigned int channel );  // channel index
+                                unsigned int length,
+                                unsigned int channel );
+/////// very low level access functions //////////////////////////////////////////
+extern void _tty_get_lock( unsigned int  channel,
+                           unsigned int* save_sr_ptr );
+extern void _tty_write_data( unsigned int channel, char byte );
+extern void _tty_release_lock( unsigned int  channel,
+                               unsigned int* save_sr_ptr );
+extern unsigned int _tty_read_data( unsigned int channel );
+extern void _tty_rx_isr( unsigned int irq_type,
+                         unsigned int irq_id,
+                         unsigned int channel );
+extern unsigned int _tty_get_status( unsigned int channel );
+extern void _tty_get_lock( unsigned int channel );
+extern void _tty_release_lock( unsigned int channel );
+extern void _tty_tx_isr( unsigned int irq_type,
+                         unsigned int irq_id,
+                         unsigned int channel );
 ///////////////////////////////////////////////////////////////////////////////////
+// low-level access functions
+///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _tty_get_register( unsigned int channel,
+                                       unsigned int index );
+extern void _tty_set_register( unsigned int channel,
+                               unsigned int index,
+                               unsigned int value );
 #endif

soft/giet_vm/giet_drivers/xcu_driver.c

-                      r281
+                      r295
 // Copyright (c) UPMC-LIP6
 ///////////////////////////////////////////////////////////////////////////////////
-// The xcu_driver.c and xcu_driver.h files are part ot the GIET-VM nano-kernel.
-// This driver supports the SoCLib vci_xicu, that is a vectorised interrupt
-// controler supporting IPI (Inter Processor Interrupts) and integrated timers.
-//
-// It can exist several interrupt controller unit in the architecture
-// (one per cluster), and each one can contain several channels.
-// The number of XICU channels is equal to NB_PROCS_MAX, because there is
-// one private XICU channel per processor in a cluster.
-////////////////////////////////////////////////////////////////////////////////
-// The virtual base address of the segment associated to the component is:
-//
-//      seg_xcu_base + cluster_xy * vseg_cluster_increment
-//
-// The seg_xcu_base and vseg_cluster_increment values must be defined
-// in giet_vsegs.ld file.
-////////////////////////////////////////////////////////////////////////////////
 #include <giet_config.h>
 …
 #endif
+////////////////////////////////////////////////////////////////////////////////
+//     _xcu_set_mask()
+// This function set the mask register for the XICU channel identified by the
+// cluster index and the processor index multiplied by the number of IRQ per
+// processor.
+////////////////////////////////////////////////////////////////////////////////
+// This function set the mask register for the IRQ type defined by "irq_type",
+// and for the channel identified by the "cluster_xy" and "channel" arguments.
 // All '1' bits are set / all '0' bits are not modified.
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_set_mask( unsigned int cluster_xy,
+                            unsigned int irq_index,
+                            unsigned int value,
+                            unsigned int irq_type )
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                                     return 1;
+    if (y >= Y_SIZE)                                     return 1;
+    if (irq_index >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) return 1;
+#if USE_XICU
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_set_mask( unsigned int cluster_xy,
+                    unsigned int channel,
+                    unsigned int value,
+                    unsigned int irq_type )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                                   _exit();
+    if (y >= Y_SIZE)                                   _exit();
+    if (channel >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) _exit();
     volatile unsigned int* xcu_address =
         (unsigned int *) ((unsigned int)&seg_xcu_base +
 …
     unsigned int func;
     if      (irq_type == IRQ_TYPE_PTI) func = XICU_MSK_PTI_ENABLE;
+    else if (irq_type == IRQ_TYPE_SWI) func = XICU_MSK_WTI_ENABLE;
+    else                               func = XICU_MSK_HWI_ENABLE;
+    xcu_address[XICU_REG(func,irq_index)] = value;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_set_mask should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
+//     _xcu_get_index()
+// This function returns the index of the highest priority (smaller index)
+// - active HWI (Hardware Interrupt), or
+// - active PTI (Timer Interrupt), or
+// - active SWI (Software Interrupt).
+// The ICU channel is identified by the cluster index and the processor index
+// multiplied by the number of IRQ per processor.
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_get_index( unsigned int cluster_xy,
+                             unsigned int irq_index,
+                             unsigned int * buffer)
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                                     return 1;
+    if (y >= Y_SIZE)                                     return 1;
+    if (irq_index >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) return 1;
+#if USE_XICU
+    volatile unsigned int* xcu_address =
+        (unsigned int *) ((unsigned int)&seg_xcu_base +
+        (cluster_xy * (unsigned int)&vseg_cluster_increment));
+    unsigned int prio = xcu_address[XICU_REG(XICU_PRIO,irq_index)];
+    else if (irq_type == IRQ_TYPE_WTI) func = XICU_MSK_WTI_ENABLE;
+    else if (irq_type == IRQ_TYPE_HWI) func = XICU_MSK_HWI_ENABLE;
+    else
+    {
+        _printf("[GIET ERROR] _xcu_set_mask() receives illegal IRQ type\n");
+        _exit();
+    }
+    xcu_address[XICU_REG(func,channel)] = value;
+#else
+    _printf("[GIET ERROR] _xcu_set_mask() should not be used if USE_XICU not set\n");
+    _exit();
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
+// This function returns the index and the type of the highest priority
+// - active PTI (Timer Interrupt), then
+// - active HWI (Hardware Interrupt), then
+// - active WTI (Software Interrupt)
+// As the hardware can define more than one IRQ per processor, but the GIET
+// use only one, channel = lpid * IRQ_PER_PROCESSOR.
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_get_index( unsigned int cluster_xy,
+                     unsigned int channel,
+                     unsigned int * index,
+                     unsigned int * irq_type )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)                                   _exit();
+    if (y >= Y_SIZE)                                   _exit();
+    if (channel >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) _exit();
+    volatile unsigned int* xcu_address =
+        (unsigned int *) ((unsigned int)&seg_xcu_base +
+        (cluster_xy * (unsigned int)&vseg_cluster_increment));
+    unsigned int prio = xcu_address[XICU_REG(XICU_PRIO,channel)];
     unsigned int pti_ok = (prio & 0x00000001);
     unsigned int hwi_ok = (prio & 0x00000002);
     unsigned int swi_ok = (prio & 0x00000004);
+    unsigned int wti_ok = (prio & 0x00000004);
     unsigned int pti_id = (prio & 0x00001F00) >> 8;
     unsigned int hwi_id = (prio & 0x001F0000) >> 16;
+    unsigned int swi_id = (prio & 0x1F000000) >> 24;
+    if      (pti_ok)  *buffer = pti_id;
+    else if (hwi_ok)  *buffer = hwi_id;
+    else if (swi_ok)  *buffer = swi_id;
+    else              *buffer = 32;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_get_index should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
+//     _xcu_send_ipi()
+// This function can be used only in an architecture using  XICU components.
+// It writes the "wdata" value in the mailbox defined by the cluster index
+// and the processor index.
+// Giet-VM supports at most NB_PROCS_MAX mailboxes:
+// (0 <= wti_index <= NB_PROCS_MAX-1)
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_send_ipi( unsigned int cluster_xy,
+                            unsigned int wti_index,
+                            unsigned int wdata )
+    unsigned int wti_id = (prio & 0x1F000000) >> 24;
+    if      (pti_ok)
+    {
+        *index    = pti_id;
+        *irq_type = IRQ_TYPE_PTI;
+    }
+    else if (hwi_ok)
+    {
+        *index    = hwi_id;
+        *irq_type = IRQ_TYPE_HWI;
+    }
+    else if (wti_ok)
+    {
+        *index    = wti_id;
+        *irq_type = IRQ_TYPE_WTI;
+    }
+    else
+    {
+        *index = 32;
+    }
+#else
+    _printf("[GIET ERROR] _xcu_get_index should not be used if USE_XICU is not set\n");
+    _exit();
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
+// This function writes the "wdata" value in the mailbox defined
+// by the "cluster_xy" and "wti_index" arguments.
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_send_wti( unsigned int cluster_xy,
+                    unsigned int wti_index,
+                    unsigned int wdata )
+{
+    // parameters checking
     unsigned int x = cluster_xy >> Y_WIDTH;
     unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
     if (x >= X_SIZE)               return 1;
     if (y >= Y_SIZE)               return 1;
     if (wti_index >= NB_PROCS_MAX) return 1;
+#if USE_XICU
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)               _exit();
+    if (y >= Y_SIZE)               _exit();
+    if (wti_index >= 32)           _exit();
     volatile unsigned int* xcu_address =
         (unsigned int *) ((unsigned int)&seg_xcu_base +
 …
     xcu_address[XICU_REG(XICU_WTI_REG,wti_index)] = wdata;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_send_ipi should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#else
+    _printf("[GIET ERROR] _xcu_send_ipi should not be used if USE_XICU is not set\n");
+    _exit();
 #endif
+}
 ////////////////////////////////////////////////////////////////////////////////
+//    _xcu_timer_start()
+// This function returns the value contained in a WTI mailbox defined by
+// the cluster_xy and "wti_index" arguments. This value is written in
+// the "value" argument, and the corresponding WTI is acknowledged.
+// returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_get_wti_value( unsigned int   cluster_xy,
+                         unsigned int   wti_index,
+                         unsigned int * value )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)               _exit();
+    if (y >= Y_SIZE)               _exit();
+    if (wti_index >= 32)           _exit();
+    volatile unsigned int* xcu_address =
+        (unsigned int *) ((unsigned int)&seg_xcu_base +
+        (cluster_xy * (unsigned int)&vseg_cluster_increment));
+    *value = xcu_address[XICU_REG(XICU_WTI_REG, wti_index)];
+#else
+    _printf("[GIET ERROR] in _xcu_get_wti_value() USE_XICU is not set\n");
+    _exit();
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
+// This function returns the address of a WTI mailbox defined by
+// the "wti_index" argument, in the unsigned int "address" argument.
+// It is used by the GIET to configurate the IOPIC component.
+// There is no access to a specific XCU component in a specific cluster.
+// returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_get_wti_address( unsigned int   wti_index,
+                           unsigned int * address )
+{
+#if USE_XICU
+    if (wti_index >= 32)           _exit();
+    unsigned int xcu_address = (unsigned int)&seg_xcu_base;
+    *address = xcu_address + (XICU_REG(XICU_WTI_REG, wti_index)<<2);
+#else
+    _printf("[GIET ERROR] in _xcu_get_wti_address() USE_XICU is not set\n");
+    _exit();
+#endif
+}
+////////////////////////////////////////////////////////////////////////////////
 // This function activates a timer contained in XICU by writing in the
 // proper register the period value.
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_timer_start( unsigned int cluster_xy,
+                               unsigned int pti_index,
+                               unsigned int period )
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             return 1;
+    if (y >= Y_SIZE)             return 1;
+#if USE_XICU
+////////////////////////////////////////////////////////////////////////////////
+void _xcu_timer_start( unsigned int cluster_xy,
+                       unsigned int pti_index,
+                       unsigned int period )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             _exit();
+    if (y >= Y_SIZE)             _exit();
     volatile unsigned int* xcu_address =
         (unsigned int *) ((unsigned int)&seg_xcu_base +
 …
     xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = period;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_timer_start should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+//     _xcu_timer_stop()
+#else
+    _printf("[GIET ERROR] in _xcu_timer_start() USE_XICU is not set\n");
+    _exit();
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // This function desactivates a timer in XICU component
 // by writing in the proper register.
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_timer_stop( unsigned int cluster_xy,
+                              unsigned int pti_index)
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             return 1;
+    if (y >= Y_SIZE)             return 1;
+#if USE_XICU
+//////////////////////////////////////////////////////////////////////////////
+void _xcu_timer_stop( unsigned int cluster_xy,
+                      unsigned int pti_index)
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             _exit();
+    if (y >= Y_SIZE)             _exit();
     volatile unsigned int * xcu_address =
         (unsigned int *) ((unsigned int)&seg_xcu_base +
 …
     xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = 0;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_timer_stop should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+//     _xcu_timer_reset_irq()
+#else
+    _printf("[GIET ERROR] in _xcu_timer_stop() USE_XICU is not set\n");
+    _exit();
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // This function acknowlegge a timer interrupt in XICU
 // component by reading in the proper register.
 // It can be used by both the isr_switch() for a "system" timer,
 // or by the _isr_timer() for an "user" timer.
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _xcu_timer_reset_irq( unsigned int cluster_xy,
+                                   unsigned int pti_index )
+{
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             return 1;
+    if (y >= Y_SIZE)             return 1;
+#if USE_XICU
+//////////////////////////////////////////////////////////////////////////////
+void _xcu_timer_reset_irq( unsigned int cluster_xy,
+                           unsigned int pti_index )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             _exit();
+    if (y >= Y_SIZE)             _exit();
     volatile unsigned int * xcu_address =
         (unsigned int *) ((unsigned int)&seg_xcu_base +
 …
     xcu_address[XICU_REG(XICU_PTI_ACK, pti_index)];
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_timer_reset_irq should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+//     _xcu_timer_reset_cpt()
+#else
+    _printf("[GIET ERROR] in _xcu_timer_reset_irq() USE_XICU is not set\n");
+    _exit();
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // This function resets a timer counter. To do so, we re-write the period
 // in the proper register, what causes the count to restart.
 // The period value is read from the same (TIMER_PERIOD) register,
 // this is why in appearance we do nothing useful (read a value
 // from a register and write this value in the same register)
+// from a register and write this value in the same register).
 // This function is called during a context switch (user or preemptive)
 /////////////////////////////////////////////////////////////////////////////
 unsigned int _xcu_timer_reset_cpt( unsigned int cluster_xy,
                                    unsigned int pti_index )
+{
+    // parameters checking
     unsigned int x = cluster_xy >> Y_WIDTH;
     unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
     if (x >= X_SIZE)             return 1;
     if (y >= Y_SIZE)             return 1;
+#if USE_XICU
+void _xcu_timer_reset_cpt( unsigned int cluster_xy,
+                           unsigned int pti_index )
+{
+#if USE_XICU
+    // parameters checking
+    unsigned int x = cluster_xy >> Y_WIDTH;
+    unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1);
+    if (x >= X_SIZE)             _exit();
+    if (y >= Y_SIZE)             _exit();
     volatile unsigned int * xcu_address =
         (unsigned int *) ((unsigned int) &seg_xcu_base +
 …
     xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = 0;
     xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = period;
+    return 0;
+#else
+    _tty_get_lock( 0 );
+    _puts("[GIET ERROR] _xcu_timer_reset_irq should not be used if USE_XICU is not set\n");
+    _tty_release_lock( 0 );
+    return 1;
+#else
+    _printf("[GIET ERROR] in _xcu_timer_reset_cpt() USE_XICU is not set\n");
+    _exit();
 #endif
+}

soft/giet_vm/giet_drivers/xcu_driver.h

-                      r281
+                      r295
 // Copyright (c) UPMC-LIP6
 ///////////////////////////////////////////////////////////////////////////////////
+// The xcu_driver.c and xcu_driver.h files are part ot the GIET-VM nano-kernel.
+// This driver supports the SoCLib vci_xicu, that is a vectorised interrupt
+// controler supporting IPI (Inter Processor Interrupts) and integrated timers.
+//
+// It can exist several interrupt controller unit in the architecture
+// (one per cluster), and each one can contain several channels.
+// The number of XICU channels is equal to NB_PROCS_MAX, because there is
+// one private XICU channel per processor in a cluster.
+////////////////////////////////////////////////////////////////////////////////
+// The virtual base address of the segment associated to the component is:
+//
+//      seg_xcu_base + cluster_xy * vseg_cluster_increment
+//
+// The seg_xcu_base and vseg_cluster_increment values must be defined
+// in giet_vsegs.ld file.
+////////////////////////////////////////////////////////////////////////////////
 #ifndef _GIET_XCU_DRIVER_H_
 …
 ///////////////////////////////////////////////////////////////////////////////////
+extern unsigned int _xcu_get_index( unsigned int cluster_xy,
+                                    unsigned int irq_index,
+                                    unsigned int * buffer );
+extern void _xcu_set_mask( unsigned int cluster_xy,
+                           unsigned int channel,
+                           unsigned int mask,
+                           unsigned int irq_type );
 extern unsigned int _xcu_set_mask( unsigned int cluster_xy,
                                    unsigned int irq_index,
                                    unsigned int mask,
                                    unsigned int is_timer );
+extern void _xcu_get_index( unsigned int   cluster_xy,
+                            unsigned int   channel,
+                            unsigned int * index,
+                            unsigned int * irq_type );
 extern unsigned int _xcu_send_ipi( unsigned int cluster_xy,
                                    unsigned int wti_index,
                                    unsigned int wdata );
+extern void _xcu_send_wti( unsigned int cluster_xy,
+                           unsigned int wti_index,
+                           unsigned int wdata );
 extern unsigned int _xcu_timer_start( unsigned int cluster_xy,
                                       unsigned int pti_index,
                                       unsigned int period );
+extern void _xcu_get_wti_value( unsigned int   cluster_xy,
+                                unsigned int   wti_index,
+                                unsigned int * value );
 extern unsigned int _xcu_timer_stop( unsigned int cluster_xy,
                                      unsigned int pti_index );
+extern void _xcu_get_wti_address( unsigned int   wti_index,
+                                  unsigned int * address );
+extern unsigned int _xcu_timer_reset_irq( unsigned int cluster_xy,
+                                          unsigned int pti_index );
+extern void _xcu_timer_start( unsigned int cluster_xy,
+                              unsigned int pti_index,
+                              unsigned int period );
+extern unsigned int _xcu_timer_reset_cpt( unsigned int cluster_xy,
+                                          unsigned int pti_index );
+extern void _xcu_timer_stop( unsigned int cluster_xy,
+                             unsigned int pti_index );
+extern void _xcu_timer_reset_irq( unsigned int cluster_xy,
+                                  unsigned int pti_index );
+extern void _xcu_timer_reset_cpt( unsigned int cluster_xy,
+                                  unsigned int pti_index );
 ///////////////////////////////////////////////////////////////////////////////////

Context Navigation

Legend:

soft/giet_vm/giet_drivers/bdv_driver.c

soft/giet_vm/giet_drivers/bdv_driver.h

soft/giet_vm/giet_drivers/cma_driver.h

soft/giet_vm/giet_drivers/dma_driver.c

soft/giet_vm/giet_drivers/fbf_driver.c

soft/giet_vm/giet_drivers/hba_driver.c

soft/giet_vm/giet_drivers/hba_driver.h

soft/giet_vm/giet_drivers/icu_driver.c

soft/giet_vm/giet_drivers/ioc_driver.c

soft/giet_vm/giet_drivers/ioc_driver.h

soft/giet_vm/giet_drivers/mmc_driver.c

soft/giet_vm/giet_drivers/mwr_driver.c

soft/giet_vm/giet_drivers/nic_driver.c

soft/giet_vm/giet_drivers/nic_driver.h

soft/giet_vm/giet_drivers/sdc_driver.c

soft/giet_vm/giet_drivers/sdc_driver.h

soft/giet_vm/giet_drivers/tim_driver.c

soft/giet_vm/giet_drivers/tim_driver.h

soft/giet_vm/giet_drivers/tty_driver.c

soft/giet_vm/giet_drivers/tty_driver.h

soft/giet_vm/giet_drivers/xcu_driver.c

soft/giet_vm/giet_drivers/xcu_driver.h

Download in other formats: