Changeset 253

Timestamp:

Aug 14, 2013, 11:19:29 PM (11 years ago)

Author:

alain

Message:

1/ introducing support to display images on the frame buffer
with the vci_chbuf_dma (in stdio.c and drivers.c)
2/ introducing support for mem_cache configuration segment
as the memory cache is considered as another addressable peripheral type
(in drivers.c)
3/ Introducing the new "increment" parameter in the mapping header.
This parameter define the virtual address increment for the vsegs
associated to the replicated peripherals (ICU, XICU, MDMA, TIMER, MMC).
This parameter is mandatory, and all map.xml files the "mappings"
directory have been updated.

Location:

soft/giet_vm

Files:

• Makefile (modified) (1 diff)
• boot/boot_init.c (modified) (9 diffs)
• giet_config.h (modified) (2 diffs)
• libs/mwmr_channel.h (modified) (1 diff)
• libs/stdio.c (modified) (29 diffs)
• libs/stdio.h (modified) (1 diff)
• mappings/1c_1p_40.xml (deleted)
• mappings/1c_4p_four.xml (modified) (2 diffs)
• mappings/1c_4p_four_dhrystone.xml (modified) (4 diffs)
• mappings/1c_4p_gameoflife.xml (modified) (4 diffs)
• mappings/4c_1p_40.xml (modified) (8 diffs)
• mappings/4c_1p_display.xml (modified) (10 diffs)
• mappings/4c_1p_iob.xml (modified) (11 diffs)
• mappings/exemple.xml (deleted)
• sys/common.h (modified) (2 diffs)
• sys/drivers.c (modified) (39 diffs)
• sys/drivers.h (modified) (4 diffs)
• sys/hwr_mapping.h (modified) (1 diff)
• sys/sys_handler.c (modified) (2 diffs)
• xml/mapping_info.h (modified) (7 diffs)
• xml/xml_driver.c (modified) (2 diffs)
• xml/xml_parser.c (modified) (98 diffs)

soft/giet_vm/Makefile

@@ -5 +5 @@
 DU = mipsel-unknown-elf-objdump
 
-MAP_XML       = mappings/1c_4p_gameoflife.xml
+MAP_XML      = mappings/4c_1p_iob.xml
 
 SYS_OBJS     = build/sys/vm_handler.o \

soft/giet_vm/boot/boot_init.c

@@ -806 +806 @@
 {
     mapping_header_t * header = (mapping_header_t *) & seg_mapping_base;
-    mapping_cluster_t * cluster = boot_get_cluster_base(header);
-    mapping_periph_t * periph = boot_get_periph_base(header);
 
     // checking mapping availability
@@ -835 +833 @@
         boot_exit();
     }
-    // checking hardware
-    unsigned int periph_id;
-    unsigned int cluster_id;
-    unsigned int tty_found = 0;
-    unsigned int nic_found = 0;
-    for (cluster_id = 0; cluster_id < NB_CLUSTERS; cluster_id++) 
-    {
-        // NB_PROCS_MAX
-        if (cluster[cluster_id].procs > NB_PROCS_MAX) 
-        {
-            boot_puts("\n[BOOT ERROR] too many processors in cluster ");
-            boot_putd(cluster_id);
-            boot_puts(" : procs = ");
-            boot_putd(cluster[cluster_id].procs);
-            boot_puts("\n");
-            boot_exit();
-        }
-
-        for (periph_id = cluster[cluster_id].periph_offset;
-                periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs;
-                periph_id++) 
-        {
-            // NB_TTY_CHANNELS
-            if (periph[periph_id].type == PERIPH_TYPE_TTY) 
-            {
-                if (tty_found) 
-                {
-                    boot_puts("\n[BOOT ERROR] TTY component should not be replicated\n");
-                    boot_exit();
-                }
-                if (periph[periph_id].channels > NB_TTY_CHANNELS) 
-                {
-                    boot_puts("\n[BOOT ERROR] Wrong NB_TTY_CHANNELS in cluster ");
-                    boot_putd(cluster_id);
-                    boot_puts(" : ttys = ");
-                    boot_putd(periph[periph_id].channels);
-                    boot_puts("\n");
-                    boot_exit();
-                }
-                tty_found = 1;
-            }
-            // NB_NIC_CHANNELS
-            if (periph[periph_id].type == PERIPH_TYPE_NIC) 
-            {
-                if (nic_found) 
-                {
-                    boot_puts("\n[BOOT ERROR] NIC component should not be replicated\n");
-                    boot_exit();
-                }
-                if (periph[periph_id].channels != NB_NIC_CHANNELS) 
-                {
-                    boot_puts("\n[BOOT ERROR] Wrong NB_NIC_CHANNELS in cluster ");
-                    boot_putd(cluster_id);
-                    boot_puts(" : nics = ");
-                    boot_putd(periph[periph_id].channels);
-                    boot_puts("\n");
-                    boot_exit();
-                }
-                nic_found = 1;
-            }
-            // NB_TIMERS
-            if (periph[periph_id].type == PERIPH_TYPE_TIM) 
-            {
-                if (periph[periph_id].channels > NB_TIM_CHANNELS) 
-                {
-                    boot_puts("\n[BOOT ERROR] Too much user timers in cluster ");
-                    boot_putd(cluster_id);
-                    boot_puts(" : timers = ");
-                    boot_putd(periph[periph_id].channels);
-                    boot_puts("\n");
-                    boot_exit();
-                }
-            }
-            // NB_DMAS
-            if (periph[periph_id].type == PERIPH_TYPE_DMA) 
-            {
-                if (periph[periph_id].channels > NB_DMA_CHANNELS) 
-                {
-                    boot_puts("\n[BOOT ERROR] Too much DMA channels in cluster ");
-                    boot_putd(cluster_id);
-                    boot_puts(" : channels = ");
-                    boot_putd(periph[periph_id].channels);
-                    boot_puts(" - NB_DMA_CHANNELS : ");
-                    boot_putd(NB_DMA_CHANNELS);
-                    boot_puts("\n");
-                    boot_exit();
-                }
-            }
-        } // end for periphs
-    } // end for clusters
+
+#if BOOT_DEBUG_MAPPING
+boot_puts("\nclusters  = ");
+boot_putd( header->clusters );
+boot_puts("\nprocs     = ");
+boot_putd( header->procs );
+boot_puts("\nperiphs   = ");
+boot_putd( header->periphs );
+boot_puts("\nvspaces   = ");
+boot_putd( header->vspaces );
+boot_puts("\ntasks     = ");
+boot_putd( header->tasks );
+boot_puts("\n");
+
+unsigned int        cluster_id;
+mapping_cluster_t * cluster = boot_get_cluster_base(header);
+for (cluster_id = 0; cluster_id < NB_CLUSTERS; cluster_id++) 
+{
+boot_puts("\n cluster = ");
+boot_putd( cluster_id );
+boot_puts("\n procs   = ");
+boot_putd( cluster[cluster_id].procs );
+boot_puts("\n psegs   = ");
+boot_putd( cluster[cluster_id].psegs );
+boot_puts("\n periphs = ");
+boot_putd( cluster[cluster_id].periphs );
+boot_puts("\n");
+}
+#endif
+
+    boot_puts("\n[BOOT] Mapping check completed at cycle ");
+    boot_putd(boot_proctime());
+    boot_puts(" for ");
+    boot_puts( header->name );
+    boot_puts("\n");
+
 } // end boot_check_mapping()
 
@@ -971 +915 @@
         }
     }
+
+    boot_puts("\n[BOOT] Pseg allocators initialisation completed at cycle ");
+    boot_putd(boot_proctime());
+    boot_puts("\n");
+
 } // end boot_psegs_init()
 
@@ -1037 +986 @@
 #endif
     }
+
+    boot_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
+    boot_putd(boot_proctime());
+    boot_puts("\n");
+
 } // end boot_pt_init()
 
@@ -1216 +1170 @@
         }
     } // end loop on vspaces
+
+    boot_puts("\n[BOOT] Vobjs initialisation completed at cycle : ");
+    boot_putd(boot_proctime());
+    boot_puts("\n");
+
 } // end boot_vobjs_init()
 
@@ -1423 +1382 @@
         } // end for coprocs
     } // end for clusters
+
+    boot_puts("\n[BOOT] Peripherals initialisation completed at cycle ");
+    boot_putd(boot_proctime());
+    boot_puts("\n");
+
 } // end boot_peripherals_init()
 
@@ -1858 +1822 @@
         } // end loop on tasks
     } // end loop on vspaces
+
+    boot_puts("\n[BOOT] Schedulers initialisation completed at cycle ");
+    boot_putd(boot_proctime());
+    boot_puts("\n");
+
 } // end boot_schedulers_init()
 
@@ -1879 +1848 @@
     boot_check_mapping();
 
-    boot_puts("\n[BOOT] Mapping check completed at cycle ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
-
     // pseg allocators initialisation 
     boot_psegs_init();
 
-    boot_puts("\n[BOOT] Pseg allocators initialisation completed at cycle ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
-
     // page table building
     boot_pt_init();
 
-    boot_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
-
-    // mmu activation ( with page table [Ø] )
+    // mmu activation ( with page table [0] )
     boot_set_mmu_ptpr((unsigned int) (boot_ptabs_paddr[0] >> 13));
     boot_set_mmu_mode(0xF);
@@ -1905 +1862 @@
     boot_puts("\n");
 
-
     // vobjs initialisation
     boot_vobjs_init();
 
-    boot_puts("\n[BOOT] Vobjs initialisation completed at cycle : ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
-
     // peripherals initialisation
     boot_peripherals_init();
 
-    boot_puts("\n[BOOT] Peripherals initialisation completed at cycle ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
-
     // schedulers initialisation
     boot_schedulers_init();
-
-    boot_puts("\n[BOOT] Schedulers initialisation completed at cycle ");
-    boot_putd(boot_proctime());
-    boot_puts("\n");
 
     // start all processors

soft/giet_vm/giet_config.h

@@ -15 +15 @@
 /* Debug parameters */
 
-#define BOOT_DEBUG_PERI          0                      /* trace peripherals initialisation */
+#define BOOT_DEBUG_MAPPING       1                      /* trace map_info checking */
 #define BOOT_DEBUG_PT                0                  /* trace page tables initialisation */
 #define BOOT_DEBUG_VOBJS             0                  /* trace vobjs initialisation */
+#define BOOT_DEBUG_PERI          0                      /* trace peripherals initialisation */
 #define BOOT_DEBUG_SCHED             0                  /* trace schedulers initialisation */
 
@@ -29 +30 @@
 /* software parameters */
 
-#define GIET_CLUSTER_INCREMENT   0x100000       /* address increment for replicated peripherals */
 #define GIET_NB_VSPACE_MAX           64                 /* max number of virtual spaces */
 #define GIET_TICK_VALUE          0x100000       /* context switch period (number of cycles) */

soft/giet_vm/libs/mwmr_channel.h

@@ -15 +15 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-typedef struct mwmr_channel_s {
+typedef struct mwmr_channel_s 
+{
     unsigned int ptr;        // index of the first valid data word
     unsigned int ptw;        // index of the first empty slot 

soft/giet_vm/libs/stdio.c

@@ -13 +13 @@
 #include <stdio.h>
 
-#define SYSCALL_PROCID          0x00
-#define SYSCALL_PROCTIME        0x01
-#define SYSCALL_TTY_WRITE       0x02
-#define SYSCALL_TTY_READ        0x03
-#define SYSCALL_TIMER_START     0x04
-#define SYSCALL_TIMER_STOP      0x05
-#define SYSCALL_GCD_WRITE       0x06
-#define SYSCALL_GCD_READ        0x07
-#define SYSCALL_HEAP_INFO       0x08
-#define SYSCALL_PROC_TASK_ID    0x09
-#define SYSCALL_GLOBAL_TASK_ID  0x0A
-#define SYSCALL_CTX_SWITCH      0x0D
-#define SYSCALL_EXIT            0x0E
-#define SYSCALL_PROC_NUMBER     0x0F
-#define SYSCALL_FB_SYNC_WRITE   0x10
-#define SYSCALL_FB_SYNC_READ    0x11
-#define SYSCALL_FB_WRITE        0x12
-#define SYSCALL_FB_READ         0x13
-#define SYSCALL_FB_COMPLETED    0x14
-#define SYSCALL_IOC_WRITE       0x15
-#define SYSCALL_IOC_READ        0x16
-#define SYSCALL_IOC_COMPLETED   0x17
-#define SYSCALL_IOC_BLOCK_SIZE  0x18
-#define SYSCALL_VOBJ_GET_VBASE  0x1A
-#define SYSCALL_NIC_WRITE       0x1B
-#define SYSCALL_NIC_READ        0x1C
-#define SYSCALL_NIC_COMPLETED   0x1D
+#define SYSCALL_PROCID            0x00
+#define SYSCALL_PROCTIME          0x01
+#define SYSCALL_TTY_WRITE         0x02
+#define SYSCALL_TTY_READ          0x03
+#define SYSCALL_TIMER_START       0x04
+#define SYSCALL_TIMER_STOP        0x05
+#define SYSCALL_GCD_WRITE         0x06
+#define SYSCALL_GCD_READ          0x07
+#define SYSCALL_HEAP_INFO         0x08
+#define SYSCALL_LOCAL_TASK_ID     0x09
+#define SYSCALL_GLOBAL_TASK_ID    0x0A
+#define SYSCALL_FB_CMA_INIT       0x0B
+#define SYSCALL_FB_CMA_WRITE      0x0C
+#define SYSCALL_FB_CMA_STOP       0x0D
+#define SYSCALL_EXIT              0x0E
+#define SYSCALL_PROC_NUMBER       0x0F
+#define SYSCALL_FB_SYNC_WRITE     0x10
+#define SYSCALL_FB_SYNC_READ      0x11
+#define SYSCALL_FB_DMA_WRITE      0x12
+#define SYSCALL_FB_DMA_READ       0x13
+#define SYSCALL_FB_DMA_COMPLETED  0x14
+#define SYSCALL_IOC_WRITE         0x15
+#define SYSCALL_IOC_READ          0x16
+#define SYSCALL_IOC_COMPLETED     0x17
+#define SYSCALL_IOC_BLOCK_SIZE    0x18
+#define SYSCALL_CTX_SWITCH        0x19
+#define SYSCALL_VOBJ_GET_VBASE    0x1A
+#define SYSCALL_NIC_CMA_RX_INIT   0x1B
+#define SYSCALL_NIC_CMA_TX_INIT   0x1C
+#define SYSCALL_NIC_CMA_STOP      0x1D
+#define SYSCALL_NIC_SYNC_READ     0x1E
+#define SYSCALL_NIC_SYNC_WRITE    0x1F
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -47 +52 @@
 // and tells GCC what has been modified by system call execution.
 //////////////////////////////////////////////////////////////////////////////////
-static inline unsigned int sys_call(unsigned int call_no,
-        unsigned int arg_0, 
-        unsigned int arg_1, 
-        unsigned int arg_2, 
-        unsigned int arg_3) {
+static inline unsigned int sys_call( unsigned int call_no,
+                                     unsigned int arg_0, 
+                                     unsigned int arg_1, 
+                                     unsigned int arg_2, 
+                                     unsigned int arg_3 ) 
+{
     register unsigned int reg_no_and_output asm("v0") = call_no;
     register unsigned int reg_a0 asm("a0") = arg_0;
@@ -109 +115 @@
 
 
-//////     TTY device related system calls /////
+//////  TTY device related system calls /////
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -123 +129 @@
     return sys_call(SYSCALL_TTY_WRITE, (unsigned int) (&byte), 1, 0, 0);
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_puts()
@@ -140 +144 @@
     return sys_call(SYSCALL_TTY_WRITE, (unsigned int) buf, length, 0, 0);
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_putw()
@@ -161 +163 @@
     return sys_call(SYSCALL_TTY_WRITE, (unsigned int) buf, 10, 0, 0);
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_getc()
@@ -180 +180 @@
     return 0;
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_gets()
@@ -226 +224 @@
     return 0;
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_getw()
@@ -325 +321 @@
     return 0;
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_printf()
@@ -448 +442 @@
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_timer_start() {
+unsigned int giet_timer_start() 
+{
     return sys_call(SYSCALL_TIMER_START, 0, 0, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // giet_timer_stop()
@@ -459 +452 @@
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_timer_stop() {
+unsigned int giet_timer_stop() 
+{
     return sys_call(SYSCALL_TIMER_STOP, 0, 0, 0, 0);
 }
@@ -477 +471 @@
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_gcd_set_opa(unsigned int val) {
+unsigned int giet_gcd_set_opa(unsigned int val) 
+{
     return sys_call(SYSCALL_GCD_WRITE, GCD_OPA, val, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 //     giet_gcd_set_opb()
@@ -488 +481 @@
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_gcd_set_opb(unsigned int val) {
+unsigned int giet_gcd_set_opb(unsigned int val) 
+{
     return sys_call(SYSCALL_GCD_WRITE, GCD_OPB, val, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 //     giet_gcd_start()
@@ -499 +491 @@
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_gcd_start() {
+unsigned int giet_gcd_start() 
+{
     return sys_call(SYSCALL_GCD_WRITE, GCD_START, 0, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 //     giet_gcd_get_status()
@@ -510 +501 @@
 // - The value is 0 when the coprocessor is idle (computation completed).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_gcd_get_status(unsigned int * val) {
+unsigned int giet_gcd_get_status(unsigned int * val) 
+{
     return sys_call(SYSCALL_GCD_READ, GCD_STATUS, (unsigned int) val, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 //     giet_gcd_get_result()
@@ -520 +510 @@
 // This function gets the result of the computation from the GCD coprocessor.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_gcd_get_result(unsigned int * val) {
+unsigned int giet_gcd_get_result(unsigned int * val) 
+{
     return sys_call(SYSCALL_GCD_READ, GCD_OPA, (unsigned int) val, 0, 0);
 }
@@ -536 +527 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_ioc_write( unsigned int lba, void * buffer, unsigned int count) {
+unsigned int giet_ioc_write( unsigned int lba, 
+                             void *       buffer, 
+                             unsigned int count) 
+{
     return sys_call(SYSCALL_IOC_WRITE, lba, (unsigned int) buffer, count, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // giet_ioc_read()
@@ -550 +542 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_ioc_read(unsigned int lba, void * buffer, unsigned int count) {
+unsigned int giet_ioc_read( unsigned int lba, 
+                            void *       buffer, 
+                            unsigned int count ) 
+{
     return sys_call(SYSCALL_IOC_READ, lba, (unsigned int) buffer, count, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // giet_ioc_completed()
@@ -561 +554 @@
 // successfully completed, and returns 1 if an address error has been detected.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_ioc_completed() {
+unsigned int giet_ioc_completed() 
+{
     return sys_call(SYSCALL_IOC_COMPLETED, 0, 0, 0, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // giet_ioc_block_size()
@@ -571 +563 @@
 // This blocking function returns the block_size (in bytes) of the block device
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_ioc_block_size() {
+unsigned int giet_ioc_block_size() 
+{
     return sys_call(SYSCALL_IOC_BLOCK_SIZE, 0, 0, 0, 0);
 }
@@ -588 +581 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_fb_sync_write(unsigned int offset, void * buffer, unsigned int length) {
+unsigned int giet_fb_sync_write( unsigned int offset, 
+                                 void *       buffer, 
+                                 unsigned int length ) 
+{
     return sys_call(SYSCALL_FB_SYNC_WRITE, offset, (unsigned int) buffer, length, 0);
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // giet_fb_sync_read()
@@ -603 +597 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_fb_sync_read(unsigned int offset, void * buffer, unsigned int length) {
+unsigned int giet_fb_sync_read( unsigned int offset, 
+                                void *       buffer, 
+                                unsigned int length ) 
+{
     return sys_call(SYSCALL_FB_SYNC_READ, offset, (unsigned int) buffer, length, 0);
 }
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_fb_write()
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_dma_write()
 //////////////////////////////////////////////////////////////////////////////////
 // This non-blocking function use the DMA coprocessor to transfer data from a
@@ -620 +615 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_fb_write(unsigned int offset, void * buffer, unsigned int length) {
-    return sys_call(SYSCALL_FB_WRITE, offset, (unsigned int) buffer, length, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_fb_read()
+unsigned int giet_fb_dma_write( unsigned int offset, 
+                                void *       buffer, 
+                                unsigned int length ) 
+{
+    return sys_call(SYSCALL_FB_DMA_WRITE, offset, (unsigned int) buffer, length, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_dma_read()
 //////////////////////////////////////////////////////////////////////////////////
 // This non-blocking function use the DMA coprocessor to transfer data from the
@@ -637 +633 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_fb_read(unsigned int offset, void * buffer, unsigned int length) {
-    return sys_call(SYSCALL_FB_READ, offset, (unsigned int) buffer, length, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_fb_completed()
+unsigned int giet_fb_dma_read( unsigned int offset, 
+                               void *       buffer, 
+                               unsigned int length ) 
+{
+    return sys_call(SYSCALL_FB_DMA_READ, offset, (unsigned int) buffer, length, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_dma_completed()
 //////////////////////////////////////////////////////////////////////////////////
 // This blocking function returns when the transfer is completed.
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_fb_completed() {
-    return sys_call(SYSCALL_FB_COMPLETED, 0, 0, 0, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_nic_write()
-//////////////////////////////////////////////////////////////////////////////////
-// This non-blocking function use the DMA coprocessor to transfer data from the
-// NIC device to an user buffer.
-// - offset : offset (in bytes) in the NIC
-// - buffer : base address of the memory buffer
-// - length : number of bytes to be transfered
-// The transfer completion is signaled by an IRQ, and must be tested by the
-// nic_completed() function.
+unsigned int giet_fb_dma_completed() 
+{
+    return sys_call(SYSCALL_FB_DMA_COMPLETED, 0, 0, 0, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_cma_init()
+//////////////////////////////////////////////////////////////////////////////////
+// This function initializes the two chbuf SRC an DST used by the CMA controller 
+// and activates the CMA channel allocated to the calling task.
+// - buf0   : first user buffer virtual address
+// - buf0   : second user buffer virtual address
+// - length : buffer size (bytes)
+// - Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_fb_cma_init( void *       buf0,
+                               void *       buf1,
+                               unsigned int length )
+{
+    return sys_call(SYSCALL_FB_CMA_INIT, (unsigned int)buf0, (unsigned int)buf1, length, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_cma_write()
+//////////////////////////////////////////////////////////////////////////////////
+// This function set the valid status for one of the SRC user buffer.
+// and reset the valid status for the DST frame buffer.
+// - bufffer_id : 0 => buf0 valid is set / not 0  => buf1 valid is set
+// - Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_fb_cma_write( unsigned int buffer_id )
+{
+    return sys_call(SYSCALL_FB_CMA_WRITE, buffer_id, 0, 0, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_fb_cma_stop()
+//////////////////////////////////////////////////////////////////////////////////
+// This function desactivates the CMA channel allocated to the calling task.
+// - Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_fb_cma_stop( )
+{
+    return sys_call(SYSCALL_FB_CMA_STOP, 0, 0, 0, 0);
+}
+
+
+//////// NIC related system calls ////////
+
+//////////////////////////////////////////////////////////////////////////////////
+// giet_nic_cma_rx_init()
+//////////////////////////////////////////////////////////////////////////////////
+// This function initializes the two chbuf SRC an DST used by the CMA controller 
+// and activates the NIC RX channel allocated to the calling task, and the 
+// CMA channel used for RX transfer.
+// - buf0   : first user buffer virtual address
+// - buf0   : second user buffer virtual address
+// - length : buffer size (bytes)
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-
-unsigned int giet_nic_write(unsigned int offset, void * buffer, unsigned int length) {
-    return sys_call(SYSCALL_NIC_WRITE, offset, (unsigned int) buffer, length, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_nic_read()
-//////////////////////////////////////////////////////////////////////////////////
-// This non-blocking function use the DMA coprocessor to transfer data from the
-// NIC device to an user buffer.
-// - offset : offset (in bytes) in the NIC
-// - buffer : base address of the memory buffer
-// - length : number of bytes to be transfered
-// The transfer completion is signaled by an IRQ, and must be tested by the
-// nic_completed() function.
+unsigned int giet_nic_cma_rx_init( void *       buf0,
+                                   void *       buf1,
+                                   unsigned int length ) 
+{
+    return sys_call(SYSCALL_NIC_CMA_RX_INIT, (unsigned int)buf0, (unsigned int)buf1, length, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_nic_cma_tx_init()
+//////////////////////////////////////////////////////////////////////////////////
+// This function initializes the two chbuf SRC an DST used by the CMA controller 
+// and activates the NIC TX channel allocated to the calling task, and the two
+// CMA channel used for TX transfer.
+// - buf0   : first user buffer virtual address
+// - buf0   : second user buffer virtual address
+// - length : buffer size (bytes)
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-
-unsigned int giet_nic_read(unsigned int offset, void * buffer, unsigned int length) {
-    return sys_call(SYSCALL_NIC_READ, offset, (unsigned int) buffer, length, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_nic_completed()
-//////////////////////////////////////////////////////////////////////////////////
-// This blocking function returns when the transfer is completed.
-// - Returns 0 if success, > 0 if error.
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_nic_completed() {
-    return sys_call(SYSCALL_NIC_COMPLETED, 0, 0, 0, 0);
-}
-
-
-///// Miscellaneous related system calls /////
+unsigned int giet_nic_cma_tx_init( void *       buf0,
+                                   void *       buf1,
+                                   unsigned int length ) 
+{
+    return sys_call(SYSCALL_NIC_CMA_TX_INIT, (unsigned int)buf0, (unsigned int)buf1, length, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_nic_cma_stop()
+//////////////////////////////////////////////////////////////////////////////////
+// This function desactivates the NIC channel and the two CMA channels
+// allocated to the calling task.
+// - Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_nic_cma_stop( )
+{
+    return sys_call(SYSCALL_NIC_CMA_STOP, 0, 0, 0, 0);
+}
+
+
+///// Miscellaneous system calls /////
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -711 +749 @@
 // - Returns the address if success,  0 if error ( not defined or wrong type )
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_vobj_get_vbase(char * vspace_name, char * vobj_name, unsigned int vobj_type, unsigned int * vobj_vaddr) {
+unsigned int giet_vobj_get_vbase( char*         vspace_name, 
+                                  char*         vobj_name, 
+                                  unsigned int  vobj_type, 
+                                  unsigned int* vobj_vaddr ) 
+{
     return sys_call(SYSCALL_VOBJ_GET_VBASE, 
             (unsigned int) vspace_name,
@@ -718 +760 @@
             (unsigned int) vobj_vaddr);
 }
-
-
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_proc_number()
@@ -727 +767 @@
 // - Returns 0 if success, > 0 if error ( cluster index too large )
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_proc_number(unsigned int cluster_id, unsigned int * buffer) {
+unsigned int giet_proc_number( unsigned int  cluster_id, 
+                               unsigned int* buffer ) 
+{
     return sys_call(SYSCALL_PROC_NUMBER, cluster_id, (unsigned int) buffer, 0, 0);
 }
-
-
-/////  Miscellaneous system calls /////
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_task_exit()
+//////////////////////////////////////////////////////////////////////////////////
+// giet_exit()
 //////////////////////////////////////////////////////////////////////////////////
 // This function stops execution of the calling task with a TTY message, 
-// and enter an infinite loop.
-// The task is blocked, but it still consume processor cycles ...
-//////////////////////////////////////////////////////////////////////////////////
-void giet_exit() {
+// and the task is descheduled and becomes not runable. 
+// It does not consume processor cycles anymore.
+//////////////////////////////////////////////////////////////////////////////////
+void giet_exit() 
+{
     sys_call(SYSCALL_EXIT, 0, 0, 0, 0);
 }
-
+//////////////////////////////////////////////////////////////////////////////////
+// giet_context_switch()
+// The user task calling this function is descheduled and
+// the processor is allocated to another task.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_context_switch() 
+{
+    return sys_call(SYSCALL_CTX_SWITCH, 0, 0, 0, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_proc_task_id()
+// This functions returns the local task id, i.e. the processor task id (ranging
+// from 0 to n-1(p) for each processor if p has n tasks)
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_proc_task_id() 
+{
+    return sys_call(SYSCALL_LOCAL_TASK_ID, 0, 0, 0, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_heap_info()
+// This function returns the base address and size of the current task's heap
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_heap_info( unsigned int* vaddr, 
+                             unsigned int* length) 
+{
+    return sys_call(SYSCALL_HEAP_INFO, (unsigned int)vaddr, (unsigned int)length, 0, 0);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// giet_global_task_id()
+// This functions returns the global task id, which is unique in all the giet.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_global_task_id() 
+{
+    return sys_call(SYSCALL_GLOBAL_TASK_ID, 0, 0, 0, 0);
+}
+///////////////////////////////////////////////////////////////////////////////////
+// giet_assert()
+// This function 
+///////////////////////////////////////////////////////////////////////////////////
+void giet_assert( unsigned int condition,
+                  char*        string )
+{
+    if ( condition == 0 )
+    {
+        giet_tty_puts( string );
+        giet_exit();
+    }
+}
+
+////// Pseudo system calls (no syscall instruction) ///////
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -751 +839 @@
 // count. This value is comprised between 0 & 65535.
 ///////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_rand() {
+unsigned int giet_rand() 
+{
     unsigned int x = sys_call(SYSCALL_PROCTIME, 0, 0, 0, 0);
     if ((x & 0xF) > 7) {
@@ -761 +850 @@
 }
 
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_context_switch()
-// The user task calling this function is descheduled and
-// the processor is allocated to another task.
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_context_switch() {
-    return sys_call(SYSCALL_CTX_SWITCH, 0, 0, 0, 0);
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_proc_task_id()
-// This functions returns the local task id, i.e. the processor task id (ranging
-// from 0 to n-1(p) for each processor if p has n tasks)
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_proc_task_id() {
-    return sys_call(SYSCALL_PROC_TASK_ID, 0, 0, 0, 0);
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_heap_info()
-// This function returns the base address and size of the current task's heap
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_heap_info(unsigned int * vaddr, unsigned int * length) {
-    return sys_call(SYSCALL_HEAP_INFO, (unsigned int) vaddr, (unsigned int) length, 0, 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// giet_global_task_id()
-// This functions returns the global task id, which is unique in all the giet
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_global_task_id() {
-    return sys_call(SYSCALL_GLOBAL_TASK_ID, 0, 0, 0, 0);
-}
 
 // Local Variables:

soft/giet_vm/libs/stdio.h

@@ -15 +15 @@
 /* TTY device related functions */
 unsigned int giet_tty_putc(char byte);
-unsigned int giet_tty_puts(char * buf);
+unsigned int giet_tty_puts(char* buf);
 unsigned int giet_tty_putw(unsigned int val);
-unsigned int giet_tty_getc_no_irq(char * byte);
-unsigned int giet_tty_getc(char * byte);
-unsigned int giet_tty_gets(char * buf, unsigned int bufsize);
-unsigned int giet_tty_getw(unsigned int * val);
-unsigned int giet_tty_printf(char * format,...);
+unsigned int giet_tty_getc_no_irq(char* byte);
+unsigned int giet_tty_getc(char* byte);
+unsigned int giet_tty_gets(char* buf, unsigned int bufsize);
+unsigned int giet_tty_getw(unsigned int* val);
+unsigned int giet_tty_printf(char* format,...);
 
+/* TIMER device related functions */
+unsigned int giet_timer_start();
+unsigned int giet_timer_stop();
+ 
 /* GCD coprocessor related functions */
 unsigned int giet_gcd_set_opa(unsigned int val);
 unsigned int giet_gcd_set_opb(unsigned int val);
 unsigned int giet_gcd_start();
-unsigned int giet_gcd_get_result(unsigned int * val);
-unsigned int giet_gcd_get_status(unsigned int * val);
+unsigned int giet_gcd_get_result(unsigned int* val);
+unsigned int giet_gcd_get_status(unsigned int* val);
 
 /* Block device related functions */
-unsigned int giet_ioc_read(unsigned int lba, void * buffer, unsigned int count);
-unsigned int giet_ioc_write(unsigned int lba, void * buffer, unsigned int count);
+unsigned int giet_ioc_read(unsigned int lba, void* buffer, unsigned int count);
+unsigned int giet_ioc_write(unsigned int lba, void* buffer, unsigned int count);
 unsigned int giet_ioc_completed();
 unsigned int giet_ioc_block_size();
 
 /* Frame buffer device related functions */
-unsigned int giet_fb_sync_read(unsigned int offset, void * buffer, unsigned int length );
-unsigned int giet_fb_sync_write(unsigned int offset, void * buffer, unsigned int length);
-unsigned int giet_fb_read(unsigned int offset, void * buffer, unsigned int length);
-unsigned int giet_fb_write(unsigned int offset, void * buffer, unsigned int length);
-unsigned int giet_nic_write(unsigned int offset, void * buffer, unsigned int length);
-unsigned int giet_nic_read(unsigned int offset, void * buffer, unsigned int length);
-unsigned int giet_fb_completed();
-unsigned int giet_nic_completed();
+unsigned int giet_fb_sync_read(unsigned int offset, void* buffer, unsigned int length );
+unsigned int giet_fb_sync_write(unsigned int offset, void* buffer, unsigned int length);
+unsigned int giet_fb_dma_read(unsigned int offset, void* buffer, unsigned int length);
+unsigned int giet_fb_dma_write(unsigned int offset, void* buffer, unsigned int length);
+unsigned int giet_fb_dma_completed();
+unsigned int giet_fb_cma_init(void* buf0, void* buf1, unsigned int length);
+unsigned int giet_fb_cma_write(unsigned int buf_id);
+unsigned int giet_fb_cma_stop();
+
+/* Network controller relate functions */
+unsigned int giet_nic_cma_rx_init(void* buf0, void* buf1, unsigned int length);
+unsigned int giet_nic_cma_tx_init(void* buf0, void* buf1, unsigned int length);
+unsigned int giet_nic_cma_stop();
 
 /* Misc */
-unsigned int giet_vobj_get_vbase(char * vspace_name, char * vobj_name, unsigned int vobj_type, unsigned int * vobj_vaddr);
+unsigned int giet_vobj_get_vbase(char* vspace_name, char* vobj_name, 
+                                 unsigned int vobj_type, unsigned int* vobj_vaddr);
+unsigned int giet_procnumber();
 void giet_exit();
-unsigned int giet_rand();
 unsigned int giet_context_switch();
 unsigned int giet_proc_task_id();
-unsigned int giet_heap_info(unsigned int * vaddr, unsigned int * size);
+unsigned int giet_heap_info(unsigned int* vaddr, unsigned int* size);
 unsigned int giet_global_task_id();
-
-unsigned int giet_procnumber();
+void giet_assert( unsigned int, char* string);
+unsigned int giet_rand();
 
 #endif

soft/giet_vm/mappings/1c_4p_four.xml

@@ -1 +1 @@
 <?xml version="1.0"?>
 
-<mapping_info   signature = "0xdeadbeef" name = "1c_4p_four" cluster_x = "1" cluster_y = "1" vspaces  = "4" >
+<mapping_info   signature = "0xdeadbeef" 
+                name      = "1c_4p_four" 
+                cluster_x = "1" 
+                cluster_y = "1" 
+                vspaces   = "4" 
+                increment = "0x10000" >
 
 *** This section describes an instance of the "caba_vgsb_xicu_mmu" generic architecture
@@ -70 +75 @@
             <periph type = "TTY" psegname = "PSEG_TTY" channels  = "8" /> 
             <periph type = "DMA" psegname = "PSEG_DMA" channels  = "1" /> 
-            <periph type = "XICU" psegname = "PSEG_ICU" channels  = "5" /> 
+            <periph type = "XCU" psegname = "PSEG_ICU" channels  = "5" /> 
             <periph type = "FBF" psegname = "PSEG_FBF" /> 
 

soft/giet_vm/mappings/1c_4p_four_dhrystone.xml

@@ -1 +1 @@
 <?xml version="1.0"?>
 
-<mapping_info   signature = "0xdeadbeef" name = "1c_4p_four_dhrystone" cluster_x = "1" cluster_y = "1" vspaces  = "4" >
+<mapping_info   signature = "0xdeadbeef" 
+                name      = "1c_4p_four_dhrystone" 
+                cluster_x = "1" 
+                cluster_y = "1" 
+                vspaces   = "4" 
+                increment = "0x10000" >
 
     <clusterset>
@@ -9 +14 @@
 
             <pseg name = "PSEG_RAM"  type  = "RAM"  base = "0x0000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type  = "PERI" base = "0x00B0000000" length = "0x0000001000" />
+            <pseg name = "PSEG_XCU"  type  = "PERI" base = "0x00B0000000" length = "0x0000001000" />
             <pseg name = "PSEG_DMA"  type  = "PERI" base = "0x00B1000000" length = "0x0000001000" />
             <pseg name = "PSEG_FBF"  type  = "PERI" base = "0x00B2000000" length = "0x0000200000" />
@@ -61 +66 @@
             <periph type = "TTY" psegname = "PSEG_TTY" channels  = "8" />
             <periph type = "DMA" psegname = "PSEG_DMA" channels  = "1" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels  = "5" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels  = "5" />
             <periph type = "FBF" psegname = "PSEG_FBF" />
 
@@ -103 +108 @@
 
 *** XICU / A[31:28] = 0xE
-        <vseg name = "seg_icu"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" >
+        <vseg name = "seg_icu"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XCU"  >
             <vobj name = "icu"          type = "PERI" length  = "0x00001000" />
         </vseg>

soft/giet_vm/mappings/1c_4p_gameoflife.xml

@@ -1 +1 @@
 <?xml version="1.0"?>
 
-<mapping_info   signature = "0xdeadbeef" name = "1c_4p_gameoflife" cluster_x = "1" cluster_y = "1" vspaces  = "1" >
+<mapping_info   signature = "0xdeadbeef" 
+                name      = "1c_4p_gameoflife" 
+                cluster_x = "1" 
+                cluster_y = "1" 
+                vspaces   = "1"
+                increment = "0x10000 >
 
     <clusterset>
@@ -9 +14 @@
 
             <pseg name = "PSEG_RAM"  type  = "RAM"  base = "0x0000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type  = "PERI" base = "0x00B0000000" length = "0x0000001000" />
+            <pseg name = "PSEG_XCU"  type  = "PERI" base = "0x00B0000000" length = "0x0000001000" />
             <pseg name = "PSEG_DMA"  type  = "PERI" base = "0x00B1000000" length = "0x0000001000" />
             <pseg name = "PSEG_FBF"  type  = "PERI" base = "0x00B2000000" length = "0x0000200000" />
@@ -64 +69 @@
             <periph type = "TTY" psegname = "PSEG_TTY" channels  = "2" /> 
             <periph type = "DMA" psegname = "PSEG_DMA" channels  = "1" /> 
-            <periph type = "XICU" psegname = "PSEG_XICU" channels  = "5" /> 
+            <periph type = "XCU" psegname = "PSEG_XCU" channels  = "5" /> 
             <periph type = "FBF" psegname = "PSEG_FBF" /> 
 
@@ -109 +114 @@
         </vseg>
 
-*** XICU / A[31:28] = 0xE
-        <vseg name = "seg_icu"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" >
+*** XCU / A[31:28] = 0xE
+        <vseg name = "seg_icu"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XCU"  >
             <vobj name = "icu"          type = "PERI" length  = "0x00001000" />
         </vseg>

soft/giet_vm/mappings/4c_1p_40.xml

@@ -5 +5 @@
               cluster_x    = "2" 
               cluster_y    = "2" 
-              vspaces      = "4">
+              vspaces      = "4"
+              increment    = "0x0010000" >
 
 *** This first section describes an instance of the "tsar_generic_xbar" architecture
@@ -14 +15 @@
         <cluster index = "0" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x0000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x00B1000000" length = "0x0000008000" />
 
@@ -45 +46 @@
                 <irq type = "HARD" icuid = "29" isr = "ISR_TTY" channel = "13" /> 
                 <irq type = "HARD" icuid = "30" isr = "ISR_TTY" channel = "14" /> 
-                <irq type = "HARD" icuid = "31" isr = "ISR_IOC" /> 
+                <irq type = "HARD" icuid = "31" isr = "ISR_IOC" channel = "0" /> 
             </proc> 
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" /> 
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "18" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "1" />
             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" /> 
             <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "8" /> 
@@ -58 +59 @@
         <cluster index = "1" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x4000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x40B1000000" length = "0x0000008000" />
 
@@ -67 +68 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
         </cluster>
 
         <cluster index = "2" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x8000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x80B1000000" length = "0x0000008000" />
 
@@ -81 +82 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
         </cluster>
 
         <cluster index = "3" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0xC000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0xC0B1000000" length = "0x0000008000" />
 
@@ -95 +96 @@
 
             <periph  type = "DMA" psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph  type = "XCU" psegname = "PSEG_XCU"  channels = "2" />
         </cluster>
     </clusterset>
-
-
 
     <globalset> 
@@ -148 +147 @@
         </vseg>
 
-*** Replicated ICUS / A[31:28] = 0xE / Increment = 0x100000             
-
-        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" > 
+*** Replicated ICUS / A[31:28] = 0xE / Increment = 0x10000             
+
+        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_0"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_1"          vbase = "0xE0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_1"          vbase = "0xE0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_1"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_2"          vbase = "0xE0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_2"          vbase = "0xE0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_2"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_3"          vbase = "0xE0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_3"          vbase = "0xE0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_3"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
 
-*** Replicated DMAs / A[31:28] = 0xD / Increment = 0x100000
+*** Replicated DMAs / A[31:28] = 0xD / Increment = 0x10000
 
         <vseg name = "seg_dma_0"          vbase = "0xD0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_DMA" >
             <vobj name = "dma_0"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_1"          vbase = "0xD0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_1"          vbase = "0xD0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
             <vobj name = "dma_1"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_2"          vbase = "0xD0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_2"          vbase = "0xD0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
             <vobj name = "dma_2"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_3"          vbase = "0xD0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_3"          vbase = "0xD0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
             <vobj name = "dma_3"          type = "PERI" length  = "0x00008000" />
         </vseg>
 
-*** Replicated schedulers / A[31:28] = 0xF / Increment = 0x100000
+*** Replicated schedulers / A[31:28] = 0xF / Increment = 0x10000
 
         <vseg name = "seg_sched_0"        vbase = "0xF0000000" mode = "C_W_" clusterid = "0" psegname = "PSEG_RAM" >
             <vobj name = "sched_0"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_1"        vbase = "0xF0100000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_1"        vbase = "0xF0010000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
             <vobj name = "sched_1"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_2"        vbase = "0xF0200000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_2"        vbase = "0xF0020000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
             <vobj name = "sched_2"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_3"        vbase = "0xF0300000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_3"        vbase = "0xF0030000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
             <vobj name = "sched_3"        type = "SCHED" length  = "0x00008000" />
         </vseg>

soft/giet_vm/mappings/4c_1p_display.xml

@@ -5 +5 @@
               cluster_x    = "2" 
               cluster_y    = "2" 
-              vspaces      = "1">
+              vspaces      = "1"
+              increment    = "0x10000 >
 
 *** This first section describes an instance of the "tsar_generic_iob" architecture
@@ -14 +15 @@
         <cluster index = "0" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x0000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x00B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x00B2000000" length = "0x0000001000" />
@@ -50 +51 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4"  /> 
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "18" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "18" />
             <periph type = "MMC"  psegname = "PSEG_MMC" channels = "1"  />
             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1"  /> 
@@ -62 +63 @@
         <cluster index = "1" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x4000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x40B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x40B2000000" length = "0x0000001000" />
@@ -72 +73 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -78 +79 @@
         <cluster index = "2" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x8000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x80B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x80B2000000" length = "0x0000001000" />
@@ -88 +89 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -94 +95 @@
         <cluster index = "3" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0xC000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0xC0B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0xC0B2000000" length = "0x0000001000" />
@@ -104 +105 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -163 +164 @@
         </vseg>
 
-*** segments for replicated ICUS / A[31:28] = 0xE / Increment = 0x100000             
-
-        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" > 
+*** segments for replicated ICUS / A[31:28] = 0xE / Increment = 0x10000             
+
+        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_0"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_1"          vbase = "0xE0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_1"          vbase = "0xE0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_1"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_2"          vbase = "0xE0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_2"          vbase = "0xE0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_2"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_3"          vbase = "0xE0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_3"          vbase = "0xE0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_3"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
 
-*** segments for replicated DMAs / A[31:28] = 0xD / Increment = 0x100000
+*** segments for replicated DMAs / A[31:28] = 0xD / Increment = 0x10000
 
         <vseg name = "seg_dma_0"          vbase = "0xD0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_DMA" >
             <vobj name = "dma_0"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_1"          vbase = "0xD0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_1"          vbase = "0xD0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
             <vobj name = "dma_1"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_2"          vbase = "0xD0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_2"          vbase = "0xD0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
             <vobj name = "dma_2"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_3"          vbase = "0xD0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_3"          vbase = "0xD0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
             <vobj name = "dma_3"          type = "PERI" length  = "0x00008000" />
         </vseg>
 
-*** segments for replicated MMC / A[31:28] = 0xC / Increment = 0x100000
+*** segments for replicated MMC / A[31:28] = 0xC / Increment = 0x10000
 
         <vseg name = "seg_memc_0"         vbase = "0xC0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_MMC" >
             <vobj name = "memc_0"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_1"         vbase = "0xC0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_1"         vbase = "0xC0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_MMC" >
             <vobj name = "memc_1"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_2"         vbase = "0xC0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_2"         vbase = "0xC0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_MMC" >
             <vobj name = "memc_2"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_3"         vbase = "0xC0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_3"         vbase = "0xC0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_MMC" >
             <vobj name = "memc_3"         type = "PERI" length  = "0x00001000" />
         </vseg>
 
-*** segments for replicated schedulers / A[31:28] = 0xF / Increment = 0x100000
+*** segments for replicated schedulers / A[31:28] = 0xF / Increment = 0x10000
 
         <vseg name = "seg_sched_0"        vbase = "0xF0000000" mode = "C_W_" clusterid = "0" psegname = "PSEG_RAM" >
             <vobj name = "sched_0"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_1"        vbase = "0xF0100000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_1"        vbase = "0xF0010000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
             <vobj name = "sched_1"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_2"        vbase = "0xF0200000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_2"        vbase = "0xF0020000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
             <vobj name = "sched_2"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_3"        vbase = "0xF0300000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_3"        vbase = "0xF0030000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
             <vobj name = "sched_3"        type = "SCHED" length  = "0x00008000" />
         </vseg>

soft/giet_vm/mappings/4c_1p_iob.xml

@@ -5 +5 @@
               cluster_x    = "2" 
               cluster_y    = "2" 
-              vspaces      = "4">
+              vspaces      = "4"
+              increment    = "0x10000" >
 
 *** This first section describes an instance of the "tsar_generic_iob" architecture
@@ -14 +15 @@
         <cluster index = "0" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x0000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x00B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x00B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x00B2000000" length = "0x0000001000" />
@@ -50 +51 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4"  /> 
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "18" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "18" />
             <periph type = "MMC"  psegname = "PSEG_MMC" channels = "1"  />
             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1"  /> 
@@ -63 +64 @@
         <cluster index = "1" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x4000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x40B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x40B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x40B2000000" length = "0x0000001000" />
@@ -73 +74 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -79 +80 @@
         <cluster index = "2" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0x8000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0x80B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0x80B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0x80B2000000" length = "0x0000001000" />
@@ -89 +90 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -95 +96 @@
         <cluster index = "3" >
             <pseg name = "PSEG_RAM"  type = "RAM"  base = "0xC000000000" length = "0x0010000000" />
-            <pseg name = "PSEG_XICU" type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
+            <pseg name = "PSEG_XCU"  type = "PERI" base = "0xC0B0000000" length = "0x0000002000" />
             <pseg name = "PSEG_DMA"  type = "PERI" base = "0xC0B1000000" length = "0x0000008000" />
             <pseg name = "PSEG_MMC"  type = "PERI" base = "0xC0B2000000" length = "0x0000001000" />
@@ -105 +106 @@
 
             <periph type = "DMA"  psegname = "PSEG_DMA"  channels = "4" />
-            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
+            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "2" />
             <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1" />
         </cluster>
@@ -163 +164 @@
         </vseg>
 
-*** segments for replicated ICUS / A[31:28] = 0xE / Increment = 0x100000             
-
-        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" > 
+*** segments for replicated ICUS / A[31:28] = 0xE / Increment = 0x10000             
+
+        <vseg name = "seg_icu_0"          vbase = "0xE0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_0"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_1"          vbase = "0xE0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_1"          vbase = "0xE0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_1"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_2"          vbase = "0xE0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_2"          vbase = "0xE0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_2"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
-        <vseg name = "seg_icu_3"          vbase = "0xE0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_XICU" > 
+        <vseg name = "seg_icu_3"          vbase = "0xE0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_XCU"  > 
             <vobj name = "icu_3"          type = "PERI" length  = "0x00001000" /> 
         </vseg>
 
-*** segments for replicated DMAs / A[31:28] = 0xD / Increment = 0x100000
+*** segments for replicated DMAs / A[31:28] = 0xD / Increment = 0x10000
 
         <vseg name = "seg_dma_0"          vbase = "0xD0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_DMA" >
             <vobj name = "dma_0"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_1"          vbase = "0xD0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_1"          vbase = "0xD0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_DMA" >
             <vobj name = "dma_1"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_2"          vbase = "0xD0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_2"          vbase = "0xD0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_DMA" >
             <vobj name = "dma_2"          type = "PERI" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_dma_3"          vbase = "0xD0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
+        <vseg name = "seg_dma_3"          vbase = "0xD0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_DMA" >
             <vobj name = "dma_3"          type = "PERI" length  = "0x00008000" />
         </vseg>
 
-*** segments for replicated MMC / A[31:28] = 0xC / Increment = 0x100000
+*** segments for replicated MMC / A[31:28] = 0xC / Increment = 0x10000
 
         <vseg name = "seg_memc_0"         vbase = "0xC0000000" mode = "__W_" clusterid = "0" psegname = "PSEG_MMC" >
             <vobj name = "memc_0"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_1"         vbase = "0xC0100000" mode = "__W_" clusterid = "1" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_1"         vbase = "0xC0010000" mode = "__W_" clusterid = "1" psegname = "PSEG_MMC" >
             <vobj name = "memc_1"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_2"         vbase = "0xC0200000" mode = "__W_" clusterid = "2" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_2"         vbase = "0xC0020000" mode = "__W_" clusterid = "2" psegname = "PSEG_MMC" >
             <vobj name = "memc_2"         type = "PERI" length  = "0x00001000" />
         </vseg>
-        <vseg name = "seg_memc_3"         vbase = "0xC0300000" mode = "__W_" clusterid = "3" psegname = "PSEG_MMC" >
+        <vseg name = "seg_memc_3"         vbase = "0xC0030000" mode = "__W_" clusterid = "3" psegname = "PSEG_MMC" >
             <vobj name = "memc_3"         type = "PERI" length  = "0x00001000" />
         </vseg>
 
-*** segments for replicated schedulers / A[31:28] = 0xF / Increment = 0x100000
+*** segments for replicated schedulers / A[31:28] = 0xF / Increment = 0x10000
 
         <vseg name = "seg_sched_0"        vbase = "0xF0000000" mode = "C_W_" clusterid = "0" psegname = "PSEG_RAM" >
             <vobj name = "sched_0"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_1"        vbase = "0xF0100000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_1"        vbase = "0xF0010000" mode = "C_W_" clusterid = "1" psegname = "PSEG_RAM" >
             <vobj name = "sched_1"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_2"        vbase = "0xF0200000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_2"        vbase = "0xF0020000" mode = "C_W_" clusterid = "2" psegname = "PSEG_RAM" >
             <vobj name = "sched_2"        type = "SCHED" length  = "0x00008000" />
         </vseg>
-        <vseg name = "seg_sched_3"        vbase = "0xF0300000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
+        <vseg name = "seg_sched_3"        vbase = "0xF0030000" mode = "C_W_" clusterid = "3" psegname = "PSEG_RAM" >
             <vobj name = "sched_3"        type = "SCHED" length  = "0x00008000" />
         </vseg>
@@ -314 +315 @@
             </vseg>
 
-            <task name = "main_display" clusterid = "3" proclocid = "0" stackname = "stack" heapname = "heap" startid = "0" usetty = "1" usedma = "1" />
+            <task name = "main_display" clusterid = "3" proclocid = "0" stackname = "stack" heapname = "heap" startid = "0" usetty = "1" usecma = "1" />
         </vspace>
     </vspaceset>

soft/giet_vm/sys/common.h

@@ -22 +22 @@
 extern _ld_symbol_t seg_nic_base;
 extern _ld_symbol_t seg_icu_base;
+extern _ld_symbol_t seg_xcu_base;
 extern _ld_symbol_t seg_tim_base;
 extern _ld_symbol_t seg_tty_base;
@@ -29 +30 @@
 extern _ld_symbol_t seg_ioc_base;
 extern _ld_symbol_t seg_mmc_base;
+extern _ld_symbol_t seg_cma_base;
+
+extern _ld_symbol_t vseg_cluster_increment;
 
 extern _ld_symbol_t seg_mapping_base;

soft/giet_vm/sys/drivers.c

@@ -5 +5 @@
 // Copyright (c) UPMC-LIP6
 ///////////////////////////////////////////////////////////////////////////////////
-// The drivers.c and drivers.h files are part ot the GIET-VM nano kernel.
+// The drivers.c and drivers.h files are part ot the GIET-VM kernel.
+//
 // They contains the drivers for the peripherals available in the SoCLib library:
 // - vci_multi_tty
@@ -11 +12 @@
 // - vci_multi_dma
 // - vci_multi_icu
-// - vci_xicu & vci_multi_icu
+// - vci_xicu
 // - vci_gcd
 // - vci_frame_buffer
 // - vci_block_device
-//
-// For the peripherals replicated in each cluster (ICU, TIMER, DMA),
+// - vci_multi_nic
+// - vci_chbuf_dma
+//
+// For the peripherals replicated in each cluster (ICU, TIMER, XCU, DMA, MMC),
 // the corresponding (virtual) base addresses must be completed by an offset 
 // depending on the cluster index.
-//
-// The following global parameter must be defined in the giet_config.h file:
-// - GIET_CLUSTER_INCREMENT
 //
 // The following global parameters must be defined in the hard_config.h file:
@@ -32 +32 @@
 // The following virtual base addresses must be defined in the giet_vsegs.ld file:
 // - seg_icu_base
+// - seg_xcu_base
 // - seg_tim_base
 // - seg_dma_base
@@ -42 +43 @@
 // - seg_iob_base
 // - seg_mmc_base
-//
+// - vseg_cluster_increment
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -68 +69 @@
 #if (NB_PROCS_MAX > 8)
 # error: NB_PROCS_MAX cannot be larger than 8!
-#endif
-
-#if !defined(GIET_CLUSTER_INCREMENT) 
-# error: You must define GIET_CLUSTER_INCREMENT in the giet_config.h file
 #endif
 
@@ -153 +150 @@
 // The (virtual) base address of the associated segment is:
 //
-//       timer_address = seg_icu_base + cluster_id * GIET_CLUSTER_INCREMENT
-//
-// - cluster id is an explicit argument of all access functions
-// - seg_icu_base must be defined in the giet_vsegs.ld file
-// - GIET_CLUSTER_INCREMENT must be defined in the giet_config.h file
+//       timer_address = seg_tim_base + cluster_id * vseg_cluster_increment
+//   or  timer_address = seg_xcu_base + cluster_id * vseg_cluster_increment
+//
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -184 +179 @@
 
 #if USE_XICU
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_icu_base + 
-                                                     (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_xcu_base + 
+                                  (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = period;
 #else
-    unsigned int* timer_address = (unsigned int *) ((char *) &seg_tim_base + 
-                                                    (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + 
+                                  (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period;
@@ -212 +207 @@
 
 #if USE_XICU
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_icu_base + 
-                                                     (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_xcu_base + 
+                                   (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = 0;
 #else
-    unsigned int* timer_address = (unsigned int *) ((char *) &seg_tim_base + 
-                                                    (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + 
+                                  (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0;
@@ -224 +219 @@
     return 0;
 }
-
 
 //////////////////////////////////////////////////////////////////////////////
@@ -242 +236 @@
 
 #if USE_XICU
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_icu_base +
-                                                     (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_xcu_base +
+                                   (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     unsigned int bloup = timer_address[XICU_REG(XICU_PTI_ACK, local_id)];
     bloup++; // to avoid a warning 
 #else
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_tim_base + 
-            (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + 
+                                   (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     timer_address[local_id * TIMER_SPAN + TIMER_RESETIRQ] = 0;
@@ -255 +249 @@
     return 0;
 }
-
-
 
 ///////////////////////////////////////////////////////////////////////
@@ -263 +255 @@
 // This function resets the period at the end of which
 // an interrupt is sent. To do so, we re-write the period
-// ini the proper register, what causes the count to restart.
+// 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
@@ -269 +261 @@
 // This function is called during a context switch (user or preemptive)
 ///////////////////////////////////////////////////////////////////////
-unsigned int _timer_reset_irq_cpt(unsigned int cluster_id, unsigned int local_id) {
+unsigned int _timer_reset_irq_cpt( unsigned int cluster_id, 
+                                   unsigned int local_id) {
     // parameters checking 
     if (cluster_id >= NB_CLUSTERS) {
@@ -279 +272 @@
 
 #if USE_XICU
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_icu_base + (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * timer_address = (unsigned int *) ((unsigned int) &seg_xcu_base + 
+                                   (cluster_id * (unsigned int)&vseg_cluster_increment));
+
     unsigned int timer_period = timer_address[XICU_REG(XICU_PTI_PER, local_id)];
 
-    // we write 0 first because if the timer is currently running, the corresponding timer counter is not reset
+    // we write 0 first because if the timer is currently running, 
+    //the corresponding timer counter is not reset
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = 0;
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = timer_period;
 #else
     // We suppose that the TIMER_MODE register value is 0x3
-    unsigned int * timer_address = (unsigned int *) ((char *) &seg_tim_base + (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + 
+                                   (cluster_id * (unsigned int)&vseg_cluster_increment));
+
     unsigned int timer_period = timer_address[local_id * TIMER_SPAN + TIMER_PERIOD];
 
@@ -295 +293 @@
     return 0;
 }
-
 
 /////////////////////////////////////////////////////////////////////////////////
@@ -412 +409 @@
 // This hardware component is replicated in all clusters.
 // There is one vci_multi_icu (or vci_xicu) component per cluster, 
-// and the number of independant ICUs is equal to NB_PROCS_MAX, 
+// and the number of ICU channels is equal to NB_PROCS_MAX, 
 // because there is one private interrupt controler per processor.
 ////////////////////////////////////////////////////////////////////////////////
 // The (virtual) base address of the associated segment is:
 //
-//       icu_address = seg_icu_base + cluster_id * GIET_CLUSTER_INCREMENT
-//
-// - cluster id is an explicit argument of all access functions
-// - seg_icu_base must be defined in the giet_vsegs.ld file
-// - GIET_CLUSTER_INCREMENT must be defined in the giet_config.h file
+//       icu_address = seg_icu_base + cluster_id * vseg_cluster_increment
+//  or   icu_address = seg_xcu_base + cluster_id * vseg_cluster_increment
+//
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -434 +429 @@
                             unsigned int proc_id,
                             unsigned int value,
-                            unsigned int is_timer) 
+                            unsigned int is_PTI) 
 {
     // parameters checking 
@@ -440 +435 @@
     if (proc_id >= NB_PROCS_MAX)   return 1; 
 
-    unsigned int * icu_address = (unsigned int *) ((char *) &seg_icu_base + 
-                                                   (cluster_id * GIET_CLUSTER_INCREMENT));
 #if USE_XICU
-    if (is_timer) 
+    unsigned int * icu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
+    if (is_PTI) 
     {
         icu_address[XICU_REG(XICU_MSK_PTI_ENABLE, proc_id)] = value;
@@ -452 +447 @@
     }
 #else
+    unsigned int * icu_address = (unsigned int *) ((unsigned int)&seg_icu_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
+
     icu_address[proc_id * ICU_SPAN + ICU_MASK_SET] = value; 
 #endif
     return 0;
 }
-
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -473 +470 @@
     if (proc_id >= NB_PROCS_MAX)    return 1;
 
-    unsigned int * icu_address = (unsigned int *) ((char *) &seg_icu_base + 
-                                                   (cluster_id * GIET_CLUSTER_INCREMENT));
 #if USE_XICU
+    unsigned int * icu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
+
     unsigned int prio = icu_address[XICU_REG(XICU_PRIO, proc_id)];
     unsigned int pti_ok = (prio & 0x00000001);
@@ -488 +486 @@
     else             { *buffer = 32; }
 #else
+    unsigned int * icu_address = (unsigned int *) ((unsigned int)&seg_icu_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
+
     *buffer = icu_address[proc_id * ICU_SPAN + ICU_IT_VECTOR]; 
 #endif
     return 0;
 }
-
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -912 +912 @@
 // The (virtual) base address of the associated segment is:
 //
-//       dma_address = seg_dma_base + cluster_id * GIET_CLUSTER_INCREMENT
-//
-// - seg_dma_base  must be defined in the giet_vsegs.ld file
-// - GIET_CLUSTER_INCREMENT  must be defined in the giet_config.h file
+//       dma_address = seg_dma_base + cluster_id * vseg_cluster_increment
+//
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -942 +940 @@
 
     // compute DMA base address
-    unsigned int * dma_address = (unsigned int *) ((char *) &seg_dma_base + 
-                                                   (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * dma_address = (unsigned int *) ((unsigned int)&seg_dma_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     dma_address[channel_id * DMA_SPAN + DMA_RESET] = 0;            
@@ -951 +949 @@
 #endif
 }
-
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -966 +963 @@
 
     // compute DMA base address
-    unsigned int * dma_address = (unsigned int *) ((char *) &seg_dma_base + 
-                                                   (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * dma_address = (unsigned int *) ((unsigned int)&seg_dma_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     *status = dma_address[channel_id * DMA_SPAN + DMA_LEN];
@@ -975 +972 @@
 #endif
 }
-
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -1031 +1027 @@
     unsigned int cluster_id  = dma_id / NB_DMA_CHANNELS;
     unsigned int channel_id  = dma_id % NB_DMA_CHANNELS;
-    unsigned int * dma_vbase  = (unsigned int *) ((char *) &seg_dma_base + 
-                                                (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * dma_vbase = (unsigned int *) ((unsigned int)&seg_dma_base + 
+                               (cluster_id * (unsigned int)&vseg_cluster_increment));
     // get page table address
     unsigned int user_ptab = _get_context_slot(CTX_PTAB_ID);
@@ -1196 +1192 @@
 }  // end _dma_transfer()  
 
-
 //////////////////////////////////////////////////////////////////////////////////
 // _dma_completed()
@@ -1257 +1252 @@
 //     VciFrameBuffer driver
 //////////////////////////////////////////////////////////////////////////////////
-// The vci_frame_buffer device can be accessed directly by software with memcpy(),
-// or it can be accessed through a multi-channels DMA component:
+// There three methods to access the VciFrameBuffer device:
 //  
-// The '_fb_sync_write' and '_fb_sync_read' functions use a memcpy strategy to
-// implement the transfer between a data buffer (user space) and the frame
+// 1) The _fb_sync_write() and _fb_sync_read() functions use a memcpy strategy 
+// to implement the transfer between a data buffer (user space) and the frame
 // buffer (kernel space). They are blocking until completion of the transfer.
 //
-// The '_fb_write()', '_fb_read()' and '_fb_completed()' functions use the 
-// VciMultiDma components (distributed in the clusters) to transfer data 
-// between the user buffer and the frame buffer. A DMA channel is
-// allocated to each task requesting it in the mapping_info data structure.
+// 2) The _fb_dma_write(), _fb_dma_read() and _fb_mdma_completed() functions use 
+// the VciMultiDma components (distributed in the clusters) to transfer data 
+// between the user buffer and the frame buffer. 
+// A DMA channel is allocated to the task requesting it in the mapping_info,
+// and stored in the task context.
+//
+// 3) The _fb_cma_init(), _fb_cma_write() and _fb_cma_stop() functions use
+// the VciChbufDma component (non replicated) to transfer a flow of images from
+// an user space chained buffer (two buffers) to the frame buffer.
+// A CMA channel is allocated to the task requesting it in the mapping_info,
+// and stored in the task context.
 //////////////////////////////////////////////////////////////////////////////////
 
@@ -1306 +1307 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-// _fb_write()
+// _fb_dma_write()
 // Transfer data from a memory buffer to the frame_buffer device using  DMA.
 // - offset : offset (in bytes) in the frame buffer.
@@ -1313 +1314 @@
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _fb_write( unsigned int   offset, 
-                        const void*    buffer, 
-                        unsigned int   length) 
+unsigned int _fb_dma_write( unsigned int   offset, 
+                            const void*    buffer, 
+                            unsigned int   length) 
 {
     return _dma_transfer( 0,             // frame buffer
@@ -1323 +1324 @@
                           length );
 }
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// _fb_read()
+//////////////////////////////////////////////////////////////////////////////////
+// _fb_dma_read()
 // Transfer data from the frame_buffer device to a memory buffer using  DMA.
 // - offset : offset (in bytes) in the frame buffer.
-// - buffer : base address of the memory buffer.
-// - length : number of bytes to be transfered.
+// - buffer : virtual base address of the user buffer.
+// - length : buffer size (number of bytes)
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _fb_read( unsigned int   offset, 
-                       const void*    buffer, 
-                       unsigned int   length ) 
+unsigned int _fb_dma_read( unsigned int   offset,  
+                           const void*    buffer, 
+                           unsigned int   length ) 
 {
     return _dma_transfer( 0,    // frame buffer
@@ -1343 +1342 @@
                           length );
 }
-
-
 //////////////////////////////////////////////////////////////////////////////////
 // _fb_completed()
@@ -1352 +1349 @@
 // (1 == read error / 2 == DMA idle error / 3 == write error)
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _fb_completed() 
+unsigned int _fb_dma_completed() 
 {
     return _dma_completed();
 }
 
+// This structure contains two chbuf descriptors that can be used by 
+// the VciChbufDma component to tranfer a flow of images:
+// - The SRC chbuf descriptor contain two slots (two user buffers)
+// - The DST chbuf descriptor contains only one slot (frame buffer)
+typedef struct fb_cma_channel_s
+{
+    paddr_t buf0;   // physical address + status for user buffer 0 
+    paddr_t buf1;   // physical address + status for user buffer 1
+    paddr_t fbf;    // physical address + status for frame buffer
+} fb_cma_channel_t;
+
+in_unckdata volatile fb_cma_channel_t _fb_cma_channel[NB_CMA_CHANNELS];
+
+//////////////////////////////////////////////////////////////////////////////////
+// _fb_cma_init()
+// This function does two things:
+// 1) Initialises the SRC chbuf descriptor (two buffers), and the DST
+//    chbuf descriptor (one single frame buffer), after translating  
+//    virtual addresses to physical addresses, and checking access rights.
+// 2) Starts the CMA hardware channel, that will permanently try to display
+//    images as soon as the SRC buffers are filled.
+// Arguments are:
+// - vbase0 : virtual base address of the first user buffer.
+// - vbase1 : virtual base address of the second user buffer.
+// - length : user buffer size (number of bytes)
+// Returns 0 if success, > 0 if error 
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _fb_cma_init( const void*  vbase0,
+                           const void*  vbase1,
+                           unsigned int length ) 
+{
+#if NB_CMA_CHANNELS > 0
+
+    unsigned int  channel_id;       // CMA channel index
+    unsigned int  user_ptab;        // page table virtual address
+    unsigned int  ko;               // unsuccessfull V2P translation
+    unsigned int  vpn;              // virtual page number
+    unsigned int  flags;            // protection flags
+    unsigned int  ppn;              // physical page number
+    paddr_t       src_chbuf_pbase;  // physical address for SRC chbuf descriptor
+    paddr_t       dst_chbuf_pbase;  // physical address for SRC chbuf descriptor
+
+    // get CMA channel index
+    channel_id = _get_context_slot(CTX_CMA_ID);
+    if ( channel_id >= NB_CMA_CHANNELS )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : CMA channel index too large\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    }
+
+    // check user buffer virtual addresses and length alignment
+    if ( ((unsigned int)vbase0 & 0x3) || ((unsigned int)vbase1 & 0x3) || (length & 0x3) ) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer not word aligned\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    }
+
+    // get page table virtual address
+    user_ptab = _get_context_slot(CTX_PTAB_ID);
+
+    // get frame buffer virtual address
+
+    // compute and register frame buffer physical address
+    vpn = ((unsigned int)&seg_fbf_base) >> 12;
+    ko = _v2p_translate( (page_table_t*) user_ptab, 
+                         vpn, 
+                         &ppn, 
+                         &flags );
+    if (ko) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : frame buffer unmapped\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    }
+    _fb_cma_channel[channel_id].fbf = ((paddr_t)ppn << 12) | (vpn & 0x00000FFF);
+
+    // Compute and register first user buffer physical address
+    vpn = (unsigned int)vbase0 >> 12; 
+    ko = _v2p_translate( (page_table_t*) user_ptab, 
+                         vpn, 
+                         &ppn, 
+                         &flags );
+    if (ko) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 0 unmapped\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    } 
+    if ((flags & PTE_U) == 0) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] in _fb_cma_init() : user buffer 0 not in user space\n");
+        _release_lock(&_tty_put_lock);
+        return 1; 
+    }
+    _fb_cma_channel[channel_id].buf0 = ((paddr_t)ppn << 12) | (vpn & 0x00000FFF);
+
+    // Compute and register second user buffer physical address
+    vpn = (unsigned int)vbase1 >> 12; 
+    ko = _v2p_translate( (page_table_t*) user_ptab, 
+                         vpn, 
+                         &ppn, 
+                         &flags );
+    if (ko) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 1 unmapped\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    } 
+    if ((flags & PTE_U) == 0) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] in _fb_cma_init() : user buffer 1 not in user space\n");
+        _release_lock(&_tty_put_lock);
+        return 1; 
+    }
+    _fb_cma_channel[channel_id].buf1 = ((paddr_t)ppn << 12) | (vpn & 0x00000FFF);
+
+    // Compute physical adress of the SRC chbuf descriptor
+    vpn = ((unsigned int)(&_fb_cma_channel[channel_id].buf0)) >> 12;
+    ko = _v2p_translate( (page_table_t*) user_ptab, 
+                         vpn,
+                         &ppn, 
+                         &flags );
+    if (ko) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : SRC chbuf descriptor unmapped\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    } 
+    src_chbuf_pbase = (((paddr_t)ppn) << 12) | (vpn & 0x00000FFF);
+
+    // Compute physical adress of the DST chbuf descriptor
+    vpn = ((unsigned int)(&_fb_cma_channel[channel_id].fbf)) >> 12;
+    ko = _v2p_translate( (page_table_t*) user_ptab, 
+                         vpn,
+                         &ppn, 
+                         &flags );
+    if (ko) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_init() : DST chbuf descriptor unmapped\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    } 
+    dst_chbuf_pbase = (((paddr_t)ppn) << 12) | (vpn & 0x00000FFF);
+
+    // 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)(src_chbuf_pbase & 0xFFFFFFFF);
+    cma_vbase[offset + CHBUF_SRC_EXT]   = (unsigned int)(src_chbuf_pbase >> 32);
+    cma_vbase[offset + CHBUF_SRC_NBUFS] = 2;
+    cma_vbase[offset + CHBUF_DST_DESC]  = (unsigned int)(dst_chbuf_pbase & 0xFFFFFFFF);
+    cma_vbase[offset + CHBUF_DST_EXT]   = (unsigned int)(dst_chbuf_pbase >> 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;
+
+    return 0;
+
+#else
+
+    _get_lock(&_tty_put_lock);
+    _puts("\n[GIET ERROR] in _fb_cma_init() : no CMA channel allocated\n");
+    _release_lock(&_tty_put_lock);
+
+    return 1;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////////
+// _fb_cma_write()
+// This function updates the status of the SRC and DST chbuf descriptors
+// to allows the CMA component to transfer another buffer.
+// - buffer_id : user buffer index (0 => buf0 / not 0 => buf1)
+// Returns 0 if success, > 0 if error 
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _fb_cma_write( unsigned int buffer_id )
+{
+#if NB_CMA_CHANNELS > 0
+
+    // get CMA channel index 
+    unsigned int channel_id = _get_context_slot(CTX_CMA_ID);
+    if ( channel_id >= NB_CMA_CHANNELS )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_write() : CMA channel index too large\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    }
+    // set SRC full 
+    if ( buffer_id == 0 )
+    _fb_cma_channel[channel_id].buf0 = _fb_cma_channel[channel_id].buf0 
+                                       | 0x8000000000000000ULL;
+    else
+    _fb_cma_channel[channel_id].buf1 = _fb_cma_channel[channel_id].buf1 
+                                       | 0x8000000000000000ULL;
+    // set DST empty
+    _fb_cma_channel[channel_id].fbf  = _fb_cma_channel[channel_id].fbf
+                                       & 0x7FFFFFFFFFFFFFFFULL;
+    return 0;
+
+#else
+
+    _get_lock(&_tty_put_lock);
+    _puts("\n[GIET ERROR] in _fb_cma_channel() : no CMA channel allocated\n");
+    _release_lock(&_tty_put_lock);
+    return 1;
+
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////////
+// _fb_cma_stop()
+// This function desactivates the CMA channel allocated to the calling task.
+// Returns 0 if success, > 0 if error 
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _fb_cma_stop( unsigned int buffer_id )
+{
+#if NB_CMA_CHANNELS > 0
+
+    // get CMA channel allocated 
+    unsigned int channel_id = _get_context_slot(CTX_CMA_ID);
+    if ( channel_id >= NB_CMA_CHANNELS )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("\n[GIET ERROR] in _fb_cma_stop() : CMA channel index too large\n");
+        _release_lock(&_tty_put_lock);
+        return 1;
+    }
+    // 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;
+    return 0;
+
+#else
+
+    _get_lock(&_tty_put_lock);
+    _puts("\n[GIET ERROR] in _fb_cma_stop() : no CMA channel allocated\n");
+    _release_lock(&_tty_put_lock);
+    return 1;
+
+#endif
+}
+    
 //////////////////////////////////////////////////////////////////////////////////
 //     VciMultiNic driver
 //////////////////////////////////////////////////////////////////////////////////
 // The VciMultiNic device can be accessed directly by software with memcpy(),
-// or it can be accessed through a multi-channels DMA component:
+// or it can be accessed through a multi-channels CMA component:
 //  
 // The '_nic_sync_write' and '_nic_sync_read' functions use a memcpy strategy to
@@ -1367 +1619 @@
 // buffer (kernel space). They are blocking until completion of the transfer.
 //
-// The '_nic_write()', '_nic_read()' and '_nic_completed()' functions use the 
-// VciMultiDma components (distributed in the clusters) to transfer data 
-// between the user buffer and the NIC. A  NIDMA channel is allocated to each 
-// task requesting it in the mapping_info data structure.
+// The _nic_cma_init() and _nic_cma_stop() functions use the VciChbufDma component 
+// to transfer a flow of packets from the NIC RX hard chbuf (two containers) 
+// to an user RX chbuf (two containers), and to transfer another flow of packets
+// from an user TX chbuf (two containers) to the NIC TX chbuf (two containers).
+// One NIC channel and two CMA channels must be allocated to the task 
+// in the mapping_info data structure.
 //////////////////////////////////////////////////////////////////////////////////
 
@@ -1376 +1630 @@
 // _nic_sync_write()
 // Transfer data from an memory buffer to the NIC device using a memcpy.
-// - offset : offset (in bytes) in the frame buffer.
 // - buffer : base address of the memory buffer.
 // - length : number of bytes to be transfered.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _nic_sync_write( unsigned int   offset, 
-                              const void*    buffer, 
+unsigned int _nic_sync_write( const void*    buffer,
                               unsigned int   length ) 
 {
-    unsigned char* nic_address = (unsigned char *) &seg_nic_base + offset;
-    memcpy((void *) nic_address, (void *) buffer, length);
-    return 0;
-}
-
-
+    // To be defined
+    // unsigned char* nic_address = (unsigned char *) &seg_nic_base;
+    // memcpy((void *) nic_address, (void *) buffer, length);
+    return 0;
+}
 //////////////////////////////////////////////////////////////////////////////////
 // _nic_sync_read()
 // Transfer data from the NIC device to a memory buffer using a memcpy. 
-// - offset : offset (in bytes) in the frame buffer.
 // - buffer : base address of the memory buffer.
 // - length : number of bytes to be transfered.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _nic_sync_read(unsigned int offset, const void * buffer, unsigned int length) {
-    unsigned char *nic_address = (unsigned char *) &seg_nic_base + offset;
-    memcpy((void *) buffer, (void *) nic_address, length);
-    return 0;
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// _nic_write()
-// Transfer data from a memory buffer to the NIC device using  DMA.
-// - offset : offset (in bytes) in the frame buffer.
-// - buffer : base address of the memory buffer.
-// - length : number of bytes to be transfered.
+unsigned int _nic_sync_read( const void*    buffer, 
+                             unsigned int   length ) 
+{
+    // To be defined
+    // unsigned char* nic_address = (unsigned char *) &seg_nic_base;
+    // memcpy((void *) buffer, (void *) nic_address, length);
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////////
+// _nic_cma_rx_init()
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _nic_write(unsigned int offset, const void * buffer, unsigned int length) {
-    return _dma_transfer(
-            1,            // NIC
-            0,            // write
-            offset,
-            (unsigned int) buffer,
-            length );    
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// _nic_read()
-// Transfer data from the NIC device to a memory buffer using  DMA.
-// - offset : offset (in bytes) in the frame buffer.
-// - buffer : base address of the memory buffer.
-// - length : number of bytes to be transfered.
+unsigned int _nic_cma_rx_init( const void*  buf0,
+                               const void*  buf1,
+                               unsigned int length ) 
+{
+    // to be defined
+    // unsigned char* nic_address = (unsigned char *) &seg_nic_base;
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////////
+// _nic_cma_tx_init()
 // Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int _nic_read(unsigned int offset, const void * buffer, unsigned int length) {
-    return _dma_transfer(
-            1,            // NIC
-            1,            // read
-            offset,
-            (unsigned int) buffer,
-            length );    
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////
-// _nic_completed()
-// This function checks completion of a DMA transfer to or fom a NIC channel.
-// As it is a blocking call, the processor is busy waiting.
-// Returns 0 if success, > 0 if error 
-// (1 == read error / 2 == DMA idle error / 3 == write error)
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int _nic_completed() 
-{
-    return _dma_completed();
-}
+unsigned int _nic_cma_tx_init( const void*  buf0,
+                               const void*  buf1,
+                               unsigned int length ) 
+{
+    // to be defined
+    // unsigned char* nic_address = (unsigned char *) &seg_nic_base;
+    return 0;
+}//////////////////////////////////////////////////////////////////////////////////
+// _nic_cma_stop()
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _nic_cma_stop()
+{
+    // to be defined
+    // unsigned char* nic_address = (unsigned char *) &seg_nic_base;
+    return 0;
+}
+
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -1458 +1696 @@
 // as a set of uncached, memory mapped registers.
 ///////////////////////////////////////////////////////////////////////////////////
+// The (virtual) base address of the associated segment is:
+//
+//       mmc_address = seg_mmc_base + cluster_id * vseg_cluster_increment
+//
+////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -1470 +1713 @@
     unsigned int cluster_id    = (unsigned int)((buf_paddr>>32)/(256/NB_CLUSTERS));
 
-    unsigned int * mmc_address = (unsigned int *) ((char *) &seg_mmc_base + 
-                                                   (cluster_id * GIET_CLUSTER_INCREMENT));
+    unsigned int * mmc_address = (unsigned int *) ((unsigned int)&seg_mmc_base + 
+                                 (cluster_id * (unsigned int)&vseg_cluster_increment));
 
     // get the lock protecting exclusive access to MEMC
@@ -1485 +1728 @@
     mmc_address[MEMC_LOCK] = 0;
 }
+
 ///////////////////////////////////////////////////////////////////////////////////
 // _heap_info()

soft/giet_vm/sys/drivers.h

@@ -62 +62 @@
 
 ///////////////////////////////////////////////////////////////////////////////////
-// Multi DMA variables            (vci_multi_dma)
+// Multi DMA variables and access functions  (vci_multi_dma)
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -74 +74 @@
 unsigned int _dma_get_status(unsigned int cluster_id, unsigned int local_id, unsigned int * status);
 
-unsigned int _dma_transfer(
-        unsigned int dev_type,
-        unsigned int to_user,
-        unsigned int offset,
-        unsigned int user_vaddr,
-        unsigned int length);
+unsigned int _dma_transfer( unsigned int dev_type,
+                            unsigned int to_user,
+                            unsigned int offset,
+                            unsigned int user_vaddr,
+                            unsigned int length );
 
 unsigned int _dma_completed();
@@ -87 +86 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-unsigned int _fb_sync_write(unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _fb_sync_read( unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _fb_write(     unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _fb_read(      unsigned int offset, const void * buffer, unsigned int length);
+unsigned int _fb_sync_write( unsigned int offset, 
+                             const void * buffer, 
+                             unsigned int length);
+unsigned int _fb_sync_read(  unsigned int offset, 
+                             const void * buffer, 
+                             unsigned int length);
 
-unsigned int _fb_completed();
+unsigned int _fb_dma_write(  unsigned int offset,
+                             const void * buffer, 
+                             unsigned int length);
+unsigned int _fb_dma_read(   unsigned int offset, 
+                             const void * buffer, 
+                             unsigned int length);
+unsigned int _fb_dma_completed();
+
+unsigned int _fb_cma_init( const void*  vbase0,
+                           const void*  vbase1,
+                           unsigned int length );
+unsigned int _fb_cma_write( unsigned int buffer_id );
+unsigned int _fb_cma_stop();
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -98 +111 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-unsigned int _nic_sync_write(unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _nic_sync_read( unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _nic_write(     unsigned int offset, const void * buffer, unsigned int length);
-unsigned int _nic_read(      unsigned int offset, const void * buffer, unsigned int length);
+unsigned int _nic_sync_write( const void*  buffer, 
+                              unsigned int length);
+unsigned int _nic_sync_read(  const void*  buffer, 
+                              unsigned int length);
 
-unsigned int _nic_completed();
+unsigned int _nic_cma_rx_init( const void*  buf0,
+                               const void*  buf1, 
+                               unsigned int length );
+unsigned int _nic_cma_tx_init( const void*  buf0,
+                               const void*  buf1, 
+                               unsigned int length );
+unsigned int _nic_cma_stop();
 
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/sys/hwr_mapping.h

@@ -49 +49 @@
     DMA_END         = 7,
     DMA_SPAN        = 8,
+};
+
+/* CMA */
+enum CMA_registers 
+{
+    CHBUF_RUN           = 0,    // write-only : channel activated
+    CHBUF_STATUS        = 1,    // read-only  : channel fsm state
+    CHBUF_SRC_DESC      = 2,    // read/write : source chbuf : descriptor base address
+    CHBUF_DST_DESC      = 3,    // read/write : destination chbuf : descriptor base address,
+    CHBUF_SRC_NBUFS     = 4,    // read/write : source chbuf : number of buffers,
+    CHBUF_DST_NBUFS     = 5,    // read/write : destination chbuf : number of buffers,
+    CHBUF_BUF_SIZE      = 6,    // read/write : buffer size for both source & destination  
+    CHBUF_PERIOD        = 7,    // read/write : period for status polling 
+    CHBUF_SRC_EXT       = 8,    // read/write : source chbuf : descriptor base address
+    CHBUF_DST_EXT       = 9,    // read/write : destination chbuf : descriptor base address,
+    /****/
+    CHBUF_CHANNEL_SPAN  = 1024,
 };
 

soft/giet_vm/sys/sys_handler.c

@@ -21 +21 @@
 //    Initialize the syscall vector with syscall handlers
 ////////////////////////////////////////////////////////////////////////////
-const void * _syscall_vector[32] = {
+const void * _syscall_vector[32] = 
+{
     &_procid,              /* 0x00 */
     &_proctime,            /* 0x01 */
@@ -33 +34 @@
     &_local_task_id,       /* 0x09 */
     &_global_task_id,      /* 0x0A */ 
-    &_sys_ukn,             /* 0x0B */
-    &_sys_ukn,             /* 0x0C */
-    &_context_switch,      /* 0x0D */
+    &_fb_cma_init,         /* 0x0B */
+    &_fb_cma_write,        /* 0x0C */
+    &_fb_cma_stop,         /* 0x0D */
     &_exit,                /* 0x0E */
     &_procs_number,        /* 0x0F */
     &_fb_sync_write,       /* 0x10 */
     &_fb_sync_read,        /* 0x11 */
-    &_fb_write,            /* 0x12 */
-    &_fb_read,             /* 0x13 */
-    &_fb_completed,        /* 0x14 */
+    &_fb_dma_write,        /* 0x12 */
+    &_fb_dma_read,         /* 0x13 */
+    &_fb_dma_completed,    /* 0x14 */
     &_ioc_write,           /* 0x15 */
     &_ioc_read,            /* 0x16 */
     &_ioc_completed,       /* 0x17 */
     &_ioc_get_block_size,  /* 0x18 */
-    &_sys_ukn,             /* 0x19 */
+    &_ctx_switch,          /* 0x19 */
     &_vobj_get_vbase,      /* 0x1A */
-    &_nic_write,           /* 0x1B */
-    &_nic_read,            /* 0x1C */
-    &_nic_completed,       /* 0x1D */
-    &_sys_ukn,             /* 0x1E */
-    &_sys_ukn,             /* 0x1F */
+    &_nic_cma_rx_init,     /* 0x1B */
+    &_nic_cma_tx_init,     /* 0x1C */
+    &_nic_cma_stop,        /* 0x1D */
+    &_nic_sync_read,       /* 0x1E */
+    &_nic_sync_write,      /* 0x1F */
 };
 

soft/giet_vm/xml/mapping_info.h

@@ -5 +5 @@
 // Copyright (c) UPMC-LIP6
 ////////////////////////////////////////////////////////////////////////////
-// The MAPPING_INFO data structure can be used with the GIET.
-// It contains the mapping directive for one or several virtual spaces.
-// Ech virtual space contains a variable number of virtual segments
+// The MAPPING_INFO data structure, used by the GIET_VM kernel contains:
+// 
+// 1) a description of a clusterized hardware architecture.
+// The number of cluster is variable (can be one). The number of processors
+// per cluster is variable (can be one). The number of peripherals per cluser
+// and coprocessor per cluster is variable. The number of physical memory
+// banks per cluster is variable.
+//
+// 2/ a description of the applications (called vspaces) to be - statically - 
+// launched on the platform. The number of parallel tasks per application is
+// variable (can be one). Multi-Writer/Multi-Reader communication channels
+// betwwen tasks are supported. Each vspace contains a variable number 
+// of virtual segments (called vsegs).
+//
+// 3/ the mapping directives: both tasks on processors, and software objects 
+// (vobjs and vsegs) on the physical memory banks (called psegs).
 // and a variable number of tasks. The number of virtual space can be one.
 //
-// The mapping table data structure is organised as the concatenation of
-// a fixed size header, and 6 variable size arrays:
+// The mapping_info data structure is organised as the concatenation of
+// a fixed size header, and 11 variable size arrays:
 //
 // - mapping_cluster_t  cluster[]  
@@ -19 +32 @@
 // - mapping_vseg_t     vobj[]    
 // - mapping_task_t     task[]  
-// - mapping_irq_t      irq[irqs]   
+// - mapping_proc_t     proc[]  
+// - mapping_irq_t      irq[]   
 // - mapping_coproc_t   coproc[]
 // - mapping_cp_port_t  cp_port[] 
 // - mapping_periph_t   periph[]
 //
-// It is intended to be stored in the boot ROM at address MAPPING_BOOT_BASE. 
+// It is intended to be stored in memory at address MAPPING_BOOT_BASE. 
 ////////////////////////////////////////////////////////////////////////////
 
@@ -75 +89 @@
 };
 
+// The enum definitions for psegType and periphType must be kept
+// consistent with the definitions in the xml_driver.c file...
 
 enum periphType 
@@ -82 +98 @@
     PERIPH_TYPE_DMA       = 2,
     PERIPH_TYPE_MMC       = 3,
-
     PERIPH_TYPE_CMA       = 4,
     PERIPH_TYPE_IOC       = 5,
@@ -90 +105 @@
     PERIPH_TYPE_IOB       = 9,
     PERIPH_TYPE_GCD       = 10,
-
-    PERIPH_TYPE_MAX_VALUE = 11,
+    PERIPH_TYPE_XCU       = 11,
+
+    PERIPH_TYPE_MAX_VALUE = 12,
 };
 
@@ -112 +128 @@
     unsigned int globals;            // number of vsegs mapped in all vspaces
     unsigned int vspaces;            // number of virtual spaces
+    unsigned int increment;          // vseg cluster increment for replicated periphs
 
     unsigned int tty_cluster;        // index of cluster containing TTY controler
@@ -270 +287 @@
 typedef struct __attribute__((packed))  mapping_periph_s 
 {
-    unsigned int type;           // IOC / TTY / TIM / DMA / FBF / NIC / IOB
+    unsigned int type;         
     unsigned int psegid;         // pseg index in cluster
     unsigned int channels;       // number of channels

soft/giet_vm/xml/xml_driver.c

@@ -61 +61 @@
         "ICU",
         "TIM",
-        "XICU",
         "DMA",
+        "MMC",
+        "CMA",
         "IOC",
         "TTY",
@@ -68 +69 @@
         "NIC",
         "IOB",
+        "GCD",
+        "XCU",
     };
 

soft/giet_vm/xml/xml_parser.c

@@ -6 +6 @@
 ///////////////////////////////////////////////////////////////////////////////////////
 // This program translate a "map.xml" source file to a binary file "map.bin" that 
-// can be directly loaded in the boot ROM and used by the GIET-VM operating system.
+// can be directly loaded in memory and used by the GIET-VM operating system.
 //
 // This map.xml file contains :
@@ -14 +14 @@
 // The corresponding C structures are defined in the "mapping_info.h" file.
 // 
-// This program also generates the "hard_config.h" and the "giet_vsegs.ld" files,
+// This parser also generates the "hard_config.h" and the "giet_vsegs.ld" files,
 // required  to compile the GIET-VM code. 
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -100 +100 @@
 char found_timer = 0;
 char found_icu   = 0;
+char found_xcu   = 0;
 char found_dma   = 0;
 char found_mmc   = 0;
@@ -122 +123 @@
 
 unsigned int use_iob          = 0; // using IOB component
-unsigned int use_xicu         = 0; // using XICU (not ICU)
+unsigned int use_xcu          = 0; // using XCU (not ICU)
 
 
@@ -130 +131 @@
 
 unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE] 
-         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };
+         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFF00000 };
 
 //////////////////////////////////////////////////////////////////////
@@ -278 +279 @@
 } // end getStringValue()
 
-///////////////////////////////////////////////////////
-void set_periph_vbase_array( unsigned int vseg_index )
-{
-    unsigned int vbase  = vseg[vseg_index]->vbase;  // peripheral vbase address
-    unsigned int psegid = vseg[vseg_index]->psegid; // pseg global index
-    unsigned int type;                              // peripheral type
-    unsigned int periph_id; 
-
-    for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
-    {
-        if( periph[periph_id]->psegid == psegid )
-        {
-            type = periph[periph_id]->type;
-            if ( periph_vbase_array[type] == 0xFFFFFFFF ) 
-                 periph_vbase_array[type] = vbase;    
-        }
+///////////////////////////////////////////////////////////////////////////////////
+// This function set the vbase address for all peripheral types. 
+// For replicated peripherals with the same type the virtual base address must be:
+//   vbase = seg_type_base & 0XFFF00000 + 
+//          (cluster_id * vbase_cluster_increment) & 0x000FFFFF
+void set_periph_vbase_array()
+{
+    unsigned int vseg_id;      // vseg global index
+    unsigned int periph_id;    // periph global index
+    unsigned int pseg_id;      // pseg global index
+    unsigned int cluster_id;   // cluster global index
+    unsigned int type;         // peripheral type 
+
+    unsigned int msb_mask = 0xFFF00000;
+    unsigned int lsb_mask = 0x000FFFFF;
+
+    // We are looking for any vseg matching a peripheral
+    // (i.e. they are associated to the same pseg)
+
+    // scan all vsegs
+    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
+    {
+        // keep only vseg corresponding to a periph        
+        if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI )
+        {
+            pseg_id = vseg[vseg_id]->psegid; 
+            cluster_id = pseg[pseg_id]->cluster;
+
+            // scan all periphs 
+            for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
+            {
+                if( periph[periph_id]->psegid == pseg_id ) // matching !!!
+                {
+                    type = periph[periph_id]->type;
+                    if ( periph_vbase_array[type] == 0xFFF00000 )  // vbase not set
+                    {
+                        periph_vbase_array[type] = vseg[vseg_id]->vbase;    
+                    }
+                    else                                 // vbase already set
+                    {
+                        // checking 12 MSB bits for replicated peripherals
+                        if( (vseg[vseg_id]->vbase & msb_mask) != 
+                            (periph_vbase_array[type] & msb_mask) )
+                        {
+                            printf("[XML ERROR] All peripherals with same type ");
+                            printf(" should share the same 12 MSB for vbase address\n");
+                            printf("periph index = %d / periph type = %d / vbase = %x\n",
+                                    periph_id, type, vseg[vseg_id]->vbase);
+                            exit(1);
+                        }
+                        // checking 20 LSB bits for replicated peripherals
+                        if( (vseg[vseg_id]->vbase & lsb_mask) != 
+                            (header->increment * cluster_id) )
+                        {
+                            printf("[XML ERROR] All peripherals with same type ");
+                            printf(" must have the 20 LSB bits = cluster_id * increment");
+                            printf("periph index = %d / periph type = %d / vbase = %x\n",
+                                    periph_id, type, vseg[vseg_id]->vbase);
+                            exit(1);
+                        }
+                    }
+                }
+            }
+        }    
     }
 }  // end set_periph_vbase_array()
@@ -336 +385 @@
     unsigned int vobj_max = vobj_min + vspace_max;
 
-    for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) {
-        if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) {
-            return (vobj_id - vobj_min);
-        }
+    for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) 
+    {
+        if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return (vobj_id - vobj_min);
     }
     return -1;
 }
 
-
-/////////////////////////////////////////
+//////////////////////////////////////
 void taskNode(xmlTextReaderPtr reader) 
 {
@@ -352 +399 @@
     char * str;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     if (task_index >= MAX_TASKS) 
     {
         printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
+        exit(1);
     }
 
@@ -540 +588 @@
 } // end taskNode()
 
-
 //////////////////////////////////////
 void vobjNode(xmlTextReaderPtr reader) 
@@ -548 +595 @@
     char * str;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     if (vobj_index >= MAX_VOBJS) 
@@ -583 +630 @@
 printf("        type = %s\n", str);
 #endif
-    if (ok && (strcmp(str, "ELF") == 0)) 
-    {
-        vobj[vobj_index]->type = VOBJ_TYPE_ELF;
-
-        assert( (vobj_count == 0) && "[XML ERROR] an ELF vobj must be alone in a vseg");
-    }
-    else if (ok && (strcmp(str, "PERI")     == 0)) 
-    { 
-        vobj[vobj_index]->type = VOBJ_TYPE_PERI;     
-
-        assert( (vobj_count == 0) && "[XML ERROR] a PERI vobj must be alone in a vseg");
-
-        // fill the peripheral base address array 
-        set_periph_vbase_array( vseg_index );
-    }
+
+    if      (ok && (strcmp(str, "ELF")      == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF;      }
+    else if (ok && (strcmp(str, "PERI")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI;     }
     else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB;     }
     else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB;     }
@@ -613 +648 @@
         exit(1);
     }
+    // some more checking
+    if ( (vobj[vobj_index]->type == VOBJ_TYPE_ELF) ||
+         (vobj[vobj_index]->type == VOBJ_TYPE_PERI) )
+    {
+        assert( (vobj_count == 0) && 
+        "[XML ERROR] an ELF or PERI vobj must be alone in a vseg");
+    }
+        
 
     ////////// get length attribute 
@@ -680 +723 @@
 } // end vobjNode()
 
-
 //////////////////////////////////////
 void vsegNode(xmlTextReaderPtr reader) 
@@ -690 +732 @@
     vobj_count = 0;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     if (vseg_index >= MAX_VSEGS) 
@@ -833 +875 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag %s", tag);
             exit(1);
@@ -841 +884 @@
 } // end vsegNode()
 
-
-//////////////////////////////////////////
-void vspaceNode(xmlTextReaderPtr reader) {
+////////////////////////////////////////
+void vspaceNode(xmlTextReaderPtr reader) 
+{
     char * str;
     unsigned int ok;
@@ -852 +895 @@
     task_loc_index = 0;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     // checking source file consistency
@@ -877 +918 @@
         strncpy(vspace[vspace_index]->name, str, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
                 vspace_index);
@@ -899 +941 @@
         //used after parsing the vobjs
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <startname> attribute for vspace %s\n", 
                 vspace[vspace_index]->name);
@@ -925 +968 @@
             // get index of the vobj containing the start vector
             int index = getVobjLocId(vspace_index, str , vobj_loc_index);
-            if (index == -1) {
+            if (index == -1) 
+            {
                 printf("[XML ERROR] vobj containing start vector not found in vspace %s\n",
                         vspace[vspace_index]->name);
-                exit(-1);
-            }
-            else {
+                exit(1);
+            }
+            else 
+            {
                 vspace[vspace_index]->start_offset = index;
 #if XML_PARSER_DEBUG
@@ -944 +989 @@
             int task_max = task_min + vspace[vspace_index]->tasks; 
             for (task_id = task_min; task_id < task_max; task_id++) {
-                if (task[task_id]->startid >= vspace[vspace_index]->tasks) {
+                if (task[task_id]->startid >= vspace[vspace_index]->tasks) 
+                {
                     printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
                             vspace_index, task_id );
@@ -955 +1001 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag %s", tag);
             exit(1);
@@ -963 +1010 @@
 } // end vspaceNode()
 
-
-///////////////////////////////////////////
-void cpPortNode(xmlTextReaderPtr reader) {
+////////////////////////////////////////
+void cpPortNode(xmlTextReaderPtr reader) 
+{
     char * str;
     unsigned int ok;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
-
-    if (cp_port_index >= MAX_CP_PORTS) {
-        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS);
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
+
+    if (cp_port_index >= MAX_CP_PORTS) 
+    {
+        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", 
+                 MAX_CP_PORTS);
+        exit(1);
     }
 
@@ -984 +1032 @@
     cp_port_vobj_ref[cp_port_index] = (vobj_ref_t *) malloc(sizeof(vobj_ref_t));
 
-
-
     ///////// get direction attribute
     str = getStringValue(reader, "direction", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("      direction = %s\n", str);
 #endif
-        if (strcmp(str, "TO_COPROC")   ==  0) {
+        if (strcmp(str, "TO_COPROC")   ==  0) 
+        {
             cp_port[cp_port_index]->direction = PORT_TO_COPROC;
         }
-        else if (strcmp(str, "FROM_COPROC") ==  0) {
+        else if (strcmp(str, "FROM_COPROC") ==  0) 
+        {
             cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
                     cp_port_index, cluster_index);
@@ -1004 +1054 @@
         }
     }  
-    else {
+    else 
+    {
         printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
                 cp_port_index, cluster_index);
@@ -1015 +1066 @@
     printf("      vspacename = %s\n", str);
 #endif
-    if (ok) {
+    if (ok) 
+    {
         strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
                 cp_port_index, cluster_index);
@@ -1029 +1082 @@
     printf("      vobjname = %s\n", str);
 #endif
-    if (ok) {
+    if (ok) 
+    {
         strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
                 cp_port_index, cluster_index);
         exit(1);
     }
-
     cp_port_index++;
     cp_port_loc_index++;
-
 } // end cpPortNode()
-
 
 ////////////////////////////////////////
@@ -1051 +1103 @@
     unsigned int ok;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     if (periph_index >= MAX_PERIPHS) 
     {
         printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
+        exit(1);
     }
 
@@ -1194 +1247 @@
                 cma_channels = periph[periph_index]->channels;
             }
-            else if (header->nic_cluster_bis == 0xFFFFFFFF) 
+            else if (header->cma_cluster_bis == 0xFFFFFFFF) 
             {
                 header->cma_cluster_bis = cluster_index;
@@ -1221 +1274 @@
         }
         // The TIM, ICU, XICU, DMA, MEMC peripherals are replicated in all clusters
-        // but only one component per cluster
+        // but it must exist only one component of each type per cluster
         else if (strcmp(str, "TIM") == 0 ) 
         {
             periph[periph_index]->type = PERIPH_TYPE_TIM;
-            if (found_timer || use_xicu)  error = 1; 
+            if (found_timer || use_xcu)  error = 1; 
             found_timer = 1;
             if (tim_channels < periph[periph_index]->channels) 
@@ -1235 +1288 @@
         {
             periph[periph_index]->type = PERIPH_TYPE_ICU;
-            if (found_icu)  error = 1; 
+            if (found_icu || use_xcu)  error = 1; 
             found_icu = 1;
         }
-        else if (strcmp(str, "XICU") == 0) 
-        {
-            periph[periph_index]->type = PERIPH_TYPE_ICU;
+        else if (strcmp(str, "XCU") == 0) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_XCU;
             if (found_icu || found_timer)  error = 1; 
-            found_icu = 1;
-            if (tim_channels == 0) 
-            { 
-                tim_channels = 32; 
-            }
-            use_xicu = 1;
+            found_xcu    = 1;
+            found_timer  = 1;
+            tim_channels = 32; 
+            use_xcu      = 1;
         }
         else if (strcmp(str, "DMA") == 0) 
@@ -1291 +1342 @@
 } // end periphNode
 
-
-/////////////////////////////////////////
-void coprocNode(xmlTextReaderPtr reader) {
+////////////////////////////////////////
+void coprocNode(xmlTextReaderPtr reader) 
+{
     char * str;
     unsigned int ok;
@@ -1299 +1350 @@
     cp_port_loc_index = 0;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
-
-    if (coproc_index >= MAX_COPROCS) {
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
+
+    if (coproc_index >= MAX_COPROCS) 
+    {
         printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
+        exit(1);
     }
 
@@ -1315 +1366 @@
     /////////// get name attribute 
     str = getStringValue(reader, "name", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("      name = %s\n", str);
@@ -1321 +1373 @@
         strncpy(coproc[coproc_index]->name, str, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
                 coproc_index, cluster_index);
@@ -1329 +1382 @@
     /////////// get psegname attribute 
     str = getStringValue(reader, "psegname", &ok);
-    if (ok == 0) {
+    if (ok == 0) 
+    {
         printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
                 coproc_index, cluster_index);
@@ -1337 +1391 @@
     /////////// set psegid attribute
     int index = getPsegId(cluster_index, str);
-    if (index >= 0) {
+    if (index >= 0) 
+    {
 #if XML_PARSER_DEBUG
         printf("      clusterid = %d\n", cluster_index);
@@ -1346 +1401 @@
         assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" );
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", 
                 coproc_index, cluster_index, str );
@@ -1360 +1416 @@
 
     int status = xmlTextReaderRead(reader);
-    while (status == 1) {
+    while (status == 1) 
+    {
         const char * tag = (const char *) xmlTextReaderConstName(reader);
 
-        if (strcmp(tag, "port") == 0 ) {
+        if (strcmp(tag, "port") == 0 ) 
+        {
             cpPortNode(reader);
         }
         else if (strcmp(tag, "#text")    == 0 ) { }
         else if (strcmp(tag, "#comment") == 0 ) { }
-        else if (strcmp(tag, "coproc") == 0 ) {
+        else if (strcmp(tag, "coproc") == 0 ) 
+        {
             coproc[coproc_index]->ports = cp_port_loc_index;
             cluster[cluster_index]->coprocs++;
@@ -1375 +1434 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag %s", tag);
             exit(1);
@@ -1384 +1444 @@
 
 
-///////////////////////////////////////
-void irqNode(xmlTextReaderPtr reader) {
+/////////////////////////////////////
+void irqNode(xmlTextReaderPtr reader) 
+{
     unsigned int ok;
     unsigned int value;
     char * str;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
     if (irq_index >= MAX_IRQS) {
@@ -1406 +1465 @@
     ///////// get type attribute
     str = getStringValue(reader, "type", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("        type    = %s\n", str);
 #endif
-        if (strcmp(str, "HARD") == 0 ) {
-            irq[irq_index]->type = 0;
-        }
-        else {
-            irq[irq_index]->type = 1;
-        }
-    }
-    else {
+        if (strcmp(str, "HARD") == 0 ) irq[irq_index]->type = 0;
+        else                           irq[irq_index]->type = 1;
+    }
+    else 
+    {
         printf("[XML ERROR] missing IRQ <type> for processor %d in cluster %d\n",
                 cluster_index, proc_loc_index);
@@ -1425 +1482 @@
     ///////// get icuid attribute
     value = getIntValue(reader, "icuid", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("        icuid   = %d\n", value);
 #endif
         irq[irq_index]->icuid = value;
-        if (value >= 32) {
+        if (value >= 32) 
+        {
             printf("[XML ERROR] IRQ <icuid> too large for processor %d in cluster %d\n",
                     cluster_index, proc_loc_index);
@@ -1436 +1495 @@
         }
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] missing IRQ <icuid> for processor %d in cluster %d\n",
                 cluster_index, proc_loc_index);
@@ -1444 +1504 @@
     ///////// get isr attribute
     str = getStringValue(reader, "isr", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("        isr     = %s\n", str);
@@ -1453 +1514 @@
         else if (strcmp(str, "ISR_TTY"    ) == 0) { irq[irq_index]->isr = ISR_TTY; }
         else if (strcmp(str, "ISR_TIMER"  ) == 0) { irq[irq_index]->isr = ISR_TIMER; }
-        else {
+        else 
+        {
             printf("[XML ERROR] illegal IRQ <isr> for processor %d in cluster %d\n",
                     cluster_index, proc_loc_index);
@@ -1462 +1524 @@
 #endif
     }  
-    else {
+    else 
+    {
         printf("[XML ERROR] missing IRQ <isr> for processor %d in cluster %d\n",
                 cluster_index, proc_loc_index);
@@ -1470 +1533 @@
     ///////// get channel attribute (optionnal : 0 if missing)
     value = getIntValue(reader, "channel", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("        channel = %d\n", value);
@@ -1476 +1540 @@
         irq[irq_index]->channel = value;
     }
-    else {
+    else 
+    {
         irq[irq_index]->channel = 0;
     }
@@ -1486 +1551 @@
 
 
-/////////////////////////////////////////
-void procNode(xmlTextReaderPtr reader) {
+//////////////////////////////////////
+void procNode(xmlTextReaderPtr reader) 
+{
     unsigned int ok;
     unsigned int value;
@@ -1493 +1559 @@
     irq_loc_index = 0;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
-
-    if (proc_index >= MAX_PROCS) {
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
+
+    if (proc_index >= MAX_PROCS) 
+    {
         printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
+        exit(1);
     }
 
@@ -1506 +1572 @@
 
     proc[proc_index] = (mapping_proc_t *) malloc(sizeof(mapping_proc_t));
-
 
     /////////// get index attribute (optional)
     value = getIntValue(reader, "index", &ok);
-    if (ok && (value != proc_loc_index)) {
+    if (ok && (value != proc_loc_index)) 
+    {
         printf("[XML ERROR] wrong proc index / expected value is %d", 
                 proc_loc_index);
@@ -1524 +1590 @@
 
     int status = xmlTextReaderRead(reader);
-    while (status == 1) {
+    while (status == 1) 
+    {
         const char * tag = (const char *) xmlTextReaderConstName(reader);
 
-        if (strcmp(tag, "irq") == 0) {
+        if (strcmp(tag, "irq") == 0) 
+        {
             irqNode(reader);
         }
         else if (strcmp(tag, "#text")    == 0) { }
         else if (strcmp(tag, "#comment") == 0) { }
-        else if (strcmp(tag, "proc")     == 0) {
+        else if (strcmp(tag, "proc")     == 0) 
+        {
             proc[proc_index]->irqs = irq_loc_index;
             cluster[cluster_index]->procs++;
@@ -1539 +1608 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag %s", tag);
             exit(1);
@@ -1548 +1618 @@
 
 
-//////////////////////////////////////////
-void psegNode(xmlTextReaderPtr reader) {
+//////////////////////////////////////
+void psegNode(xmlTextReaderPtr reader) 
+{
     unsigned int ok;
     paddr_t      ll_value;
     char * str;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
-
-    if (pseg_index >= MAX_PSEGS) {
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
+
+    if (pseg_index >= MAX_PSEGS) 
+    {
         printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
         exit(1);
@@ -1574 +1644 @@
     printf("      name = %s\n", str);
 #endif
-    if (ok) {
+    if (ok) 
+    {
         strncpy(pseg[pseg_index]->name, str, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <name> for pseg %d in cluster %d\n",
                 pseg_index, cluster_index);
@@ -1591 +1663 @@
     else if (ok && (strcmp(str, "ROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
     else if (ok && (strcmp(str, "PERI") == 0)) { pseg[pseg_index]->type = PSEG_TYPE_PERI; }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <type> for pseg %s in cluster %d\n",
                 pseg[pseg_index]->name, cluster_index);
@@ -1602 +1675 @@
     printf("      base = 0x%llx\n", ll_value);
 #endif
-    if (ok) {
+    if (ok) 
+    {
         pseg[pseg_index]->base = ll_value;
     }
@@ -1616 +1690 @@
     printf("      length = 0x%llx\n", ll_value);
 #endif
-    if (ok) {
+    if (ok) 
+    {
         pseg[pseg_index]->length = ll_value;
     }  
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <length> for pseg %s in cluster %d\n",
                 pseg[pseg_index]->name, cluster_index);
@@ -1659 +1735 @@
     found_timer = 0;
     found_icu   = 0;
+    found_xcu   = 0;
     found_dma   = 0;
     found_mmc   = 0;
@@ -1667 +1744 @@
 
     // checking source file consistency
-    if (cluster_index >= header->clusters) {
+    if (cluster_index >= header->clusters) 
+    {
         printf("[XML ERROR] The cluster index is too large : %d\n", cluster_index);
         exit(1);
@@ -1679 +1757 @@
     /////////// check cluster index attribute (optional)
     value = getIntValue(reader, "index", &ok);
-    if (ok && (value != cluster_index)) {
+    if (ok && (value != cluster_index)) 
+    {
         printf("[XML ERROR] wrong cluster index / expected value is %d", 
                 cluster_index);
@@ -1714 +1793 @@
         {
 
-            ////////////////// peripherals checks /////////////////////////
-            if ((found_timer  && use_xicu) || (!found_timer  && !use_xicu)) 
-            {
-                printf("[XML ERROR] illegal or missing timer peripheral in cluster %d\n", cluster_index);
+            ///////// TIMER and ICU peripheral are mandatory //////////////
+            if (!found_timer && !found_xcu)
+            {
+                printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index);
                 exit(1);
             }
 
-            if (!found_icu) 
-            {
-                printf("[XML ERROR] illegal or missing icu peripheral in cluster %d\n", cluster_index);
+            if (!found_icu && !found_xcu) 
+            {
+                printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index);
                 exit(1);
             }
-
-            if (!found_dma) 
-            {
-                printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
-                exit(1);
-            }
-
 
             if (nb_proc_max < cluster[cluster_index]->procs) 
@@ -1757 +1829 @@
 void clusterSetNode(xmlTextReaderPtr reader) 
 {
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
 #if XML_PARSER_DEBUG
@@ -1798 +1870 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
             exit(1);
@@ -1807 +1880 @@
 
 
-/////////////////////////////////////////////
-void globalSetNode(xmlTextReaderPtr reader) {
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
-        return;
-    }
+///////////////////////////////////////////
+void globalSetNode(xmlTextReaderPtr reader) 
+{
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
 #if XML_PARSER_DEBUG
@@ -1825 +1897 @@
         else if (strcmp(tag, "#text")     == 0) { }
         else if (strcmp(tag, "#comment")  == 0) { }
-        else if (strcmp(tag, "globalset") == 0) {
+        else if (strcmp(tag, "globalset") == 0) 
+        {
 #if XML_PARSER_DEBUG
             printf("  end global set\n\n");
@@ -1833 +1906 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
             exit(1);
@@ -1842 +1916 @@
 
 
-/////////////////////////////////////////////
-void vspaceSetNode(xmlTextReaderPtr reader) {
+///////////////////////////////////////////
+void vspaceSetNode(xmlTextReaderPtr reader)
+{
     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
         return;
@@ -1861 +1936 @@
         else if (strcmp(tag, "#text"    ) == 0 ) { }
         else if (strcmp(tag, "#comment" ) == 0 ) { }
-        else if (strcmp(tag, "vspaceset") == 0 ) {
+        else if (strcmp(tag, "vspaceset") == 0 ) 
+        {
             // checking source file consistency
-            if (vspace_index != header->vspaces) {
+            if (vspace_index != header->vspaces) 
+            {
                 printf("[XML ERROR] Wrong number of vspaces\n");
                 exit(1);
             }
-            else {
+            else 
+            {
                 header->vsegs = vseg_index;
                 header->vobjs = vobj_index;
@@ -1874 +1952 @@
             }
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
             exit(1);
@@ -1883 +1962 @@
 
 
-//////////////////////////////////////////
+////////////////////////////////////////
 void headerNode(xmlTextReaderPtr reader) 
 {
@@ -1890 +1969 @@
     unsigned int ok;
 
-    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
+    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
 
 #if XML_PARSER_DEBUG
@@ -1900 +1979 @@
     ////////// get name attribute
     name = getStringValue(reader, "name", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("  name = %s\n", name);
@@ -1906 +1986 @@
         strncpy( header->name, name, 31);
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <name> attribute in header\n");
         exit(1);
@@ -1913 +1994 @@
     /////////// get cluster_x attribute
     cluster_x = getIntValue(reader, "cluster_x", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("  cluster_x = %d\n", cluster_x);
@@ -1919 +2001 @@
         header->cluster_x = cluster_x;
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <cluster_x> attribute in header\n");
         exit(1);
@@ -1926 +2009 @@
     /////////// get cluster_y attribute
     cluster_y = getIntValue(reader, "cluster_y", &ok);
-    if (ok) {
+    if (ok) 
+    {
 #if XML_PARSER_DEBUG
         printf("  cluster_y = %d\n", cluster_y);
@@ -1932 +2016 @@
         header->cluster_y = cluster_y;
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <cluster_y> attribute in header\n");
         exit(1);
@@ -1939 +2024 @@
     //check the number of cluster
     value = cluster_x * cluster_y;
-    if (value >= MAX_CLUSTERS) {
+    if (value >= MAX_CLUSTERS) 
+    {
         printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
         exit(1);
@@ -1952 +2038 @@
     ///////// get vspaces attribute
     value = getIntValue(reader, "vspaces", &ok);
-    if (ok) {
-        if (value >= MAX_VSPACES) {
+    if (ok) 
+    {
+        if (value >= MAX_VSPACES) 
+        {
             printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES);
             exit(1);
@@ -1962 +2050 @@
         header->vspaces  = value;
     }
-    else {
+    else 
+    {
         printf("[XML ERROR] illegal or missing <vspaces> attribute in mapping\n");
+        exit(1);
+    }
+
+    ///////// get increment attribute
+    value = getIntValue(reader, "increment", &ok);
+    if (ok) 
+    {
+        if ( (value != 0x10000) && (value != 0x8000) &&
+             (value != 0x4000)  && (value != 0x2000) )
+       
+        {
+            printf("[XML ERROR] The vseg increment must be one of the following: ");
+            printf(" 0x00010000 / 0x00008000 / 0x00004000 / 0x00002000");
+            exit(1);
+        }
+#if XML_PARSER_DEBUG
+        printf("  increment = %d\n", value);
+#endif
+        header->increment  = value;
+    }
+    else 
+    {
+        printf("[XML ERROR] illegal or missing <increment> attribute in mapping\n");
         exit(1);
     }
@@ -1985 +2097 @@
 
     int status = xmlTextReaderRead(reader);
-    while (status == 1) {
+    while (status == 1) 
+    {
         const char * tag = (const char *) xmlTextReaderConstName(reader);
 
-        if (strcmp(tag, "clusterset") == 0) {
+        if (strcmp(tag, "clusterset") == 0) 
+        {
             clusterSetNode(reader);
         }
@@ -1995 +2109 @@
         else if (strcmp(tag, "#text")        == 0) { }
         else if (strcmp(tag, "#comment")     == 0) { }
-        else if (strcmp(tag, "mapping_info") == 0) {
+        else if (strcmp(tag, "mapping_info") == 0) 
+        {
 #if XML_PARSER_DEBUG
             printf("end mapping_info\n");
@@ -2001 +2116 @@
             return;
         }
-        else {
+        else 
+        {
             printf("[XML ERROR] Unknown tag in header node : %s\n",tag);
             exit(1);
@@ -2012 +2128 @@
 ///////////////////////////////////////
 void BuildTable(int fdout, const char * type, unsigned int nb_elem,
-                unsigned int elem_size, char ** table) {
+                unsigned int elem_size, char ** table) 
+{
     unsigned int i;
     // write element
@@ -2027 +2144 @@
 }
 
-
-int open_file(const char * file_path) {
-
+/////////////////////////////////////
+int open_file(const char * file_path) 
+{
     //open file
     int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) );
-    if (fdout < 0) {
+    if (fdout < 0) 
+    {
         perror("open");
         exit(1);
@@ -2038 +2156 @@
 
     //reinitialise the file
-    if (ftruncate(fdout, 0)) {
+    if (ftruncate(fdout, 0)) 
+    {
         perror("truncate");
         exit(1);
@@ -2051 +2170 @@
 
 
-///////////////////////////
-void buildBin(const char * file_path) {
+/////////////////////////////////////
+void buildBin(const char * file_path) 
+{
     unsigned int length;
 
     int fdout = open_file(file_path);
+
+#if XML_PARSER_DEBUG
+printf("Building map.bin for %s\n", header->name);
+printf("signature = %x\n", header->signature);
+printf("clusters  = %d\n", header->clusters);
+printf("vspaces   = %d\n", header->vspaces);
+printf("psegs     = %d\n", header->psegs);
+printf("vobjs     = %d\n", header->vobjs);
+printf("vsegs     = %d\n", header->vsegs);
+printf("tasks     = %d\n", header->tasks);
+printf("procs     = %d\n", header->procs);
+printf("irqs      = %d\n", header->irqs);
+printf("coprocs   = %d\n", header->coprocs);
+printf("periphs   = %d\n", header->periphs);
+#endif
 
     // write header to binary file
     length = write(fdout, (char *) header, sizeof(mapping_header_t));
-    if (length != sizeof(mapping_header_t)) {
+    if (length != sizeof(mapping_header_t)) 
+    {
         printf("write header error : length = %d \n", length);
         exit(1);
@@ -2160 +2296 @@
     int fdout = open_file(file_path);
 
-    char * prol   = "/* Generated from the mapping_info file */\n\n";
-    char * ifdef  = "#ifndef _HD_CONFIG_H\n#define _HD_CONFIG_H\n\n";
-    char * epil   = "\n#endif //_HD_CONFIG_H";
+    char prol[80];
+    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
+
+    char * ifdef  = "#ifndef _HARD_CONFIG_H\n#define _HARDD_CONFIG_H\n\n";
+    char * epil   = "\n#endif //_HARD_CONFIG_H";
 
     file_write(fdout, prol);
@@ -2187 +2325 @@
     file_write(fdout, "\n");
 
-    def_int_write(fdout, "USE_XICU          ", use_xicu);
+    def_int_write(fdout, "USE_XICU          ", use_xcu);
     def_int_write(fdout, "USE_IOB           ", use_iob);
 
@@ -2210 +2348 @@
     unsigned int vseg_id;
 
-    char * prol = "/* Generated from the mapping_info file */\n\n";
+    char prol[80];
+    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
+
     file_write(fdout, prol);
 
@@ -2273 +2413 @@
     file_write(fdout, "\n");
 
+    // fill the peripheral base address array 
+    set_periph_vbase_array();
+
     // non replicated peripherals
     ld_write(fdout, "seg_cma_base            ",   periph_vbase_array[PERIPH_TYPE_CMA]);
@@ -2285 +2428 @@
 
     // replicated peripherals
+    ld_write(fdout, "seg_xcu_base            ",   periph_vbase_array[PERIPH_TYPE_XCU]);
     ld_write(fdout, "seg_icu_base            ",   periph_vbase_array[PERIPH_TYPE_ICU]);
     ld_write(fdout, "seg_tim_base            ",   periph_vbase_array[PERIPH_TYPE_TIM]);
     ld_write(fdout, "seg_dma_base            ",   periph_vbase_array[PERIPH_TYPE_DMA]);
     ld_write(fdout, "seg_mmc_base            ",   periph_vbase_array[PERIPH_TYPE_MMC]);
+
+    file_write(fdout, "\n");
+
+    ld_write(fdout, "vseg_cluster_increment  ",   header->increment);
 
     close(fdout);
@@ -2323 +2471 @@
     }
 
-
     char * map_path = buildPath(argv[2], "map.bin"); 
     char * ld_path = buildPath(argv[2], "giet_vsegs.ld"); 
@@ -2333 +2480 @@
     xmlTextReaderPtr reader = xmlReaderForFile(argv[1], NULL, 0);
 
-    if (reader != NULL) {
+    if (reader != NULL) 
+    {
         status = xmlTextReaderRead (reader);
-        while (status == 1) {
+        while (status == 1) 
+        {
             const char * tag = (const char *) xmlTextReaderConstName(reader);
 
-            if (strcmp(tag, "mapping_info") == 0) { 
+            if (strcmp(tag, "mapping_info") == 0) 
+            { 
                 headerNode(reader);
                 prepareBuild();
@@ -2345 +2495 @@
                 genLd(ld_path);
             }
-            else {
+            else 
+            {
                 printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
                 return 1;
@@ -2353 +2504 @@
         xmlFreeTextReader(reader);
 
-        if (status != 0) {
+        if (status != 0) 
+        {
             printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
             return 1;