Changeset 204

Timestamp:

Aug 14, 2012, 8:14:55 PM (12 years ago)

Author:

alain

Message:

mproving support for multi-clusters architectures (CLUSTER_SIZE & CLUSTER_IO_ID parameters)

Location:

soft/giet_vm

Files:

• Makefile (modified) (2 diffs)
• boot/boot_init.c (modified) (50 diffs)
• boot/reset.S (modified) (6 diffs)
• giet_config.h (modified) (2 diffs)
• libs/stdio.c (modified) (5 diffs)
• sys/drivers.c (modified) (22 diffs)
• sys/drivers.h (modified) (3 diffs)
• sys/irq_handler.c (modified) (6 diffs)
• sys/sys_handler.c (modified) (1 diff)
• xml/xml_driver.c (modified) (9 diffs)
• xml/xml_parser.c (modified) (2 diffs)

soft/giet_vm/Makefile

@@ -4 +4 @@
 LD=mipsel-unknown-elf-ld
 DU=mipsel-unknown-elf-objdump
+
+MAP_XML      = 1c_4p_four.xml
 
 SYS_OBJS     = build/sys/vm_handler.o \
@@ -57 +59 @@
 
 ### mapping compilation
-map.bin: 1c_4p_four.xml
+map.bin: $(MAP_XML)
         $(MAKE) -C xml
         xml/xml2bin $< $@

soft/giet_vm/boot/boot_init.c

@@ -286 +286 @@
 void boot_puts(const char *buffer) 
 {
-    unsigned int* tty_address = (unsigned int*)&seg_tty_base;
+    unsigned int* tty_address = (unsigned int*)( (unsigned)&seg_tty_base +
+                                     (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     unsigned int n;
 
@@ -297 +298 @@
 } 
 ////////////////////////////////////////////////////////////////////////////
-// boot_putw() 
+// boot_putx() 
 // (it uses TTY0)
 ////////////////////////////////////////////////////////////////////////////
-void boot_putw(unsigned int val)
+void boot_putx(unsigned int val)
 {
     static const char   HexaTab[] = "0123456789ABCDEF";
@@ -316 +317 @@
     }
     boot_puts(buf);
+}
+////////////////////////////////////////////////////////////////////////////
+// boot_putd() 
+// (it uses TTY0)
+////////////////////////////////////////////////////////////////////////////
+void boot_putd(unsigned int val)
+{
+    static const char   DecTab[] = "0123456789";
+    char                buf[11];
+    unsigned int        i;
+    unsigned int        first;
+
+    buf[10] = 0;
+
+    for ( i = 0 ; i < 10 ; i++ )
+    {
+        if ((val != 0) || (i == 0))
+        {
+            buf[9-i] = DecTab[val % 10];
+            first    = 9-i;
+        }
+        else
+        {
+            break;
+        }
+        val /= 10;
+    }
+    boot_puts( &buf[first] );
 }
 
@@ -495 +524 @@
     {
         boot_puts("Unfound page table for vspace ");
-        boot_putw(vspace_id);
+        boot_putd(vspace_id);
         boot_puts("\n");
         boot_exit();
@@ -530 +559 @@
     if ( ( *pt_flags & PTE_V) != 0 )    // page already mapped
     {
-        boot_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
-        boot_puts("page already mapped\n");
+        boot_puts("\n[BOOT ERROR] double mapping in vspace ");
+        boot_putd( vspace_id );
+        boot_puts(" for vpn = ");
+        boot_putx( vpn );
+        boot_puts("\n");
         boot_exit();
     }
@@ -579 +611 @@
 boot_puts( vseg[vseg_id].name );
 boot_puts(" : flags = ");
-boot_putw( flags );
+boot_putx( flags );
 boot_puts(" / npages = ");
-boot_putw( npages );
+boot_putd( npages );
 boot_puts(" / pbase = ");
-boot_putw( vseg[vseg_id].pbase );
+boot_putx( vseg[vseg_id].pbase );
 boot_puts("\n");
 #endif        
@@ -615 +647 @@
 boot_puts( vseg[vseg_id].name );
 boot_puts(" / flags = ");
-boot_putw( flags );
+boot_putx( flags );
 boot_puts(" / npages = ");
-boot_putw( npages );
+boot_putd( npages );
 boot_puts(" / pbase = ");
-boot_putw( vseg[vseg_id].pbase );
+boot_putx( vseg[vseg_id].pbase );
 boot_puts("\n");
 #endif        
@@ -720 +752 @@
                 boot_puts( "\n[BOOT ERROR] in boot_vseg_map() function, " );
                 boot_puts("PTAB too small, minumum size is: ");
-                boot_putw( PT1_SIZE + PT2_SIZE);
+                boot_putx( PT1_SIZE + PT2_SIZE);
                 boot_exit();
             }
@@ -750 +782 @@
         boot_puts("\n"); 
         boot_puts("vseg pbase = ");
-        boot_putw( vseg->pbase ); 
+        boot_putx( vseg->pbase ); 
         boot_puts("\n"); 
         boot_puts("vseg length = ");
-        boot_putw( vseg->length ); 
+        boot_putx( vseg->length ); 
         boot_puts("\n"); 
         boot_puts("pseg pbase = ");
-        boot_putw( pseg->base ); 
+        boot_putx( pseg->base ); 
         boot_puts("\n"); 
         boot_puts("pseg length = ");
-        boot_putw( pseg->length ); 
+        boot_putx( pseg->length ); 
         boot_puts("\n"); 
         boot_exit();
@@ -771 +803 @@
 boot_puts( vseg->name );
 boot_puts(" : len = ");
-boot_putw( vseg->length );
+boot_putx( vseg->length );
 boot_puts(" / vbase = ");
-boot_putw( vseg->vbase );
+boot_putx( vseg->vbase );
 boot_puts(" / pbase = ");
-boot_putw( vseg->pbase );
+boot_putx( vseg->pbase );
 boot_puts("\n");
 #endif  
@@ -795 +827 @@
     {
         boot_puts("\n[BOOT ERROR] Illegal mapping signature: ");
-        boot_putw(header->signature);
+        boot_putx(header->signature);
         boot_puts("\n");
         boot_exit();
@@ -805 +837 @@
         boot_puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
         boot_puts("\n             - In giet_config,  value = ");
-        boot_putw ( NB_CLUSTERS );
+        boot_putd ( NB_CLUSTERS );
         boot_puts("\n             - In mapping_info, value = ");
-        boot_putw ( header->clusters );
+        boot_putd ( header->clusters );
         boot_puts("\n");
         boot_exit();
@@ -823 +855 @@
     unsigned int periph_id;
     unsigned int cluster_id;
-    unsigned int channels;
     unsigned int tty_found = 0;
     unsigned int nic_found = 0;
@@ -832 +863 @@
         {
             boot_puts("\n[BOOT ERROR] too much processors in cluster ");
-            boot_putw( cluster_id );
+            boot_putd( cluster_id );
             boot_puts(" : procs = ");
-            boot_putw ( cluster[cluster_id].procs );
+            boot_putd ( cluster[cluster_id].procs );
             boot_puts("\n");
             boot_exit();
@@ -854 +885 @@
                 {
                     boot_puts("\n[BOOT ERROR] Wrong NB_TTYS in cluster ");
-                    boot_putw( cluster_id );
+                    boot_putd( cluster_id );
                     boot_puts(" : ttys = ");
-                    boot_putw ( periph[periph_id].channels );
+                    boot_putd ( periph[periph_id].channels );
                     boot_puts("\n");
                     boot_exit();
@@ -873 +904 @@
                 {
                     boot_puts("\n[BOOT ERROR] Wrong NB_NICS in cluster ");
-                    boot_putw( cluster_id );
+                    boot_putd( cluster_id );
                     boot_puts(" : nics = ");
-                    boot_putw ( periph[periph_id].channels );
+                    boot_putd ( periph[periph_id].channels );
                     boot_puts("\n");
                     boot_exit();
@@ -887 +918 @@
                 {
                     boot_puts("\n[BOOT ERROR] Too much user timers in cluster ");
-                    boot_putw( cluster_id );
+                    boot_putd( cluster_id );
                     boot_puts(" : timers = ");
-                    boot_putw ( periph[periph_id].channels );
+                    boot_putd ( periph[periph_id].channels );
                     boot_puts("\n");
                     boot_exit();
@@ -900 +931 @@
                 {
                     boot_puts("\n[BOOT ERROR] Too much DMA channels in cluster ");
-                    boot_putw( cluster_id );
+                    boot_putd( cluster_id );
                     boot_puts(" : channels = ");
-                    boot_putw ( periph[periph_id].channels );
+                    boot_putd ( periph[periph_id].channels );
                     boot_puts("\n");
                     boot_exit();
@@ -937 +968 @@
         {
             boot_puts("\n[BOOT ERROR] The number of processors in cluster ");
-            boot_putw( cluster_id );
+            boot_putd( cluster_id );
             boot_puts(" is larger than NB_PROCS_MAX \n");
             boot_exit();
@@ -959 +990 @@
 #if BOOT_DEBUG_PT
 boot_puts("cluster ");
-boot_putw(cluster_id);
+boot_putd(cluster_id);
 boot_puts(" / pseg ");
 boot_puts(pseg[pseg_id].name);
 boot_puts(" : next_base = ");
-boot_putw(pseg[pseg_id].next_base);
+boot_putx(pseg[pseg_id].next_base);
 boot_puts("\n");
 #endif
@@ -1028 +1059 @@
 #if BOOT_DEBUG_PT
 boot_puts("\n>>> page table physical address = ");
-boot_putw((unsigned int)boot_ptabs_paddr[vspace_id]);
+boot_putx((unsigned int)boot_ptabs_paddr[vspace_id]);
 boot_puts(", page table number of PT2 = ");
-boot_putw((unsigned int)boot_max_pt2[vspace_id]);
+boot_putd((unsigned int)boot_max_pt2[vspace_id]);
 boot_puts("\n");
 #endif
@@ -1082 +1113 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / depth = ");
-boot_putw( mwmr->depth );
+boot_putd( mwmr->depth );
 boot_puts(" / width = ");
-boot_putw( mwmr->width );
+boot_putd( mwmr->width );
 boot_puts("\n");
 #endif
@@ -1095 +1126 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / length = ");
-boot_putw( vobj[vobj_id].length ); 
+boot_putx( vobj[vobj_id].length ); 
 boot_puts("\n");
 #endif
@@ -1106 +1137 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / length = ");
-boot_putw( vobj[vobj_id].length ); 
+boot_putx( vobj[vobj_id].length ); 
 boot_puts("\n");
 #endif
@@ -1120 +1151 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / init_value = ");
-boot_putw( barrier->init );
+boot_putd( barrier->init );
 boot_puts("\n");
 #endif
@@ -1142 +1173 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / length = ");
-boot_putw( vobj[vobj_id].length ); 
+boot_putx( vobj[vobj_id].length ); 
 boot_puts("\n");
 #endif
@@ -1154 +1185 @@
 boot_puts( vobj[vobj_id].name);
 boot_puts(" / length = ");
-boot_putw( vobj[vobj_id].length ); 
+boot_putx( vobj[vobj_id].length ); 
 boot_puts("\n");
 #endif
@@ -1173 +1204 @@
         {
             boot_puts("\n[INIT ERROR] Missing PTAB for vspace ");
-            boot_putw( vspace_id );
+            boot_putd( vspace_id );
             boot_exit();
         }
@@ -1185 +1216 @@
     volatile unsigned int *cbase = (unsigned int*) coproc;
     
-
     cbase[MWMR_CONFIG_FIFO_WAY] = way ;
     cbase[MWMR_CONFIG_FIFO_NO] = no ;
@@ -1222 +1252 @@
 #if BOOT_DEBUG_PERI
 boot_puts("\n[BOOT DEBUG] ****** peripheral initialisation in cluster "); 
-boot_putw( cluster_id );
+boot_putd( cluster_id );
 boot_puts(" ******\n");
 #endif
@@ -1245 +1275 @@
 #if BOOT_DEBUG_PERI
 boot_puts("- IOC initialised : ");
-boot_putw( channels );
+boot_putd( channels );
 boot_puts(" channels\n");
 #endif
@@ -1261 +1291 @@
 #if BOOT_DEBUG_PERI
 boot_puts("- DMA initialised : ");
-boot_putw( channels );
+boot_putd( channels );
 boot_puts(" channels\n");
 #endif
@@ -1276 +1306 @@
 #if BOOT_DEBUG_PERI
 boot_puts("- NIC initialised : ");
-boot_putw( channels );
+boot_putd( channels );
 boot_puts(" channels\n");
 #endif
@@ -1298 +1328 @@
 #if BOOT_DEBUG_PERI
 boot_puts("- IOB initialised : ");
-boot_putw( channels );
+boot_putd( channels );
 boot_puts(" channels\n");
 #endif
@@ -1304 +1334 @@
 
         } // end for periphs
-/*
+
         for ( coproc_id = cluster[cluster_id].coproc_offset ;
               coproc_id < cluster[cluster_id].coproc_offset + cluster[cluster_id].coprocs ;
@@ -1315 +1345 @@
 #if BOOT_DEBUG_PERI
 boot_puts("[BOOT] mwmr coproc initialisation of ");
-boot_putw((unsigned int) coproc[coproc_id].name);
+boot_putx((unsigned int) coproc[coproc_id].name);
 boot_puts(", nb ports");
-boot_putw((unsigned int)coproc[coproc_id].ports);
+boot_putd((unsigned int)coproc[coproc_id].ports);
 boot_puts("\n");
 #endif
@@ -1356 +1386 @@
             }
         } // end for coprocs
-*/
+
     } // end for clusters
 } // end boot_peripherals_init()
@@ -1417 +1447 @@
 #if BOOT_DEBUG_SCHED
 boot_puts("\n[BOOT DEBUG] Initialise schedulers / IT vector in cluster ");
-boot_putw( cluster_id );
+boot_putd( cluster_id );
 boot_puts("\n");
 #endif
@@ -1440 +1470 @@
         {
             boot_puts("\n[BOOT ERROR] Missing RAM pseg in cluster ");
-            boot_putw( cluster_id );
+            boot_putd( cluster_id );
             boot_puts("\n");
             boot_exit();
@@ -1459 +1489 @@
 #if BOOT_DEBUG_SCHED
 boot_puts("\nProc ");
-boot_putw( proc_id );
+boot_putd( proc_id );
 boot_puts(" : scheduler pbase = ");
-boot_putw( pseg_pbase + (proc_id<<12) );
+boot_putx( pseg_pbase + (proc_id<<12) );
 boot_puts("\n");
 #endif
@@ -1488 +1518 @@
 #if BOOT_DEBUG_SCHED
 boot_puts("- IRQ : icu = ");
-boot_putw( icu_id );
+boot_putd( icu_id );
 boot_puts(" / type = ");
-boot_putw( type );
+boot_putd( type );
 boot_puts(" / isr = ");
-boot_putw( isr_id );
+boot_putd( isr_id );
 boot_puts(" / channel = ");
-boot_putw( channel );
+boot_putd( channel );
 boot_puts("\n");
 #endif
@@ -1627 +1657 @@
             {
                 boot_puts("\n[BOOT ERROR] : ");
-                boot_putw( ltid );
+                boot_putd( ltid );
                 boot_puts(" tasks allocated to processor ");
-                boot_putw( gpid );
+                boot_putd( gpid );
                 boot_puts(" / max is 15\n");
                 boot_exit();
@@ -1659 +1689 @@
 boot_puts( task[task_id].name );
 boot_puts(" allocated to processor ");
-boot_putw( gpid );
+boot_putd( gpid );
 boot_puts("  - ctx[LTID]   = ");
-boot_putw( ltid );
+boot_putd( ltid );
 boot_puts("\n");
 
 boot_puts("  - ctx[SR]     = ");
-boot_putw( ctx_sr );
+boot_putx( ctx_sr );
 boot_puts("\n");
 
 boot_puts("  - ctx[SR]     = ");
-boot_putw( ctx_sp );
+boot_putx( ctx_sp );
 boot_puts("\n");
 
 boot_puts("  - ctx[RA]     = ");
-boot_putw( ctx_ra );
+boot_putx( ctx_ra );
 boot_puts("\n");
 
 boot_puts("  - ctx[EPC]    = ");
-boot_putw( ctx_epc );
+boot_putx( ctx_epc );
 boot_puts("\n");
 
 boot_puts("  - ctx[PTPR]   = ");
-boot_putw( ctx_ptpr );
+boot_putx( ctx_ptpr );
 boot_puts("\n");
 
 boot_puts("  - ctx[TTY]    = ");
-boot_putw( ctx_tty );
+boot_putd( ctx_tty );
 boot_puts("\n");
 
 boot_puts("  - ctx[NIC]    = ");
-boot_putw( ctx_nic );
+boot_putd( ctx_nic );
 boot_puts("\n");
 
 boot_puts("  - ctx[TIMER]  = ");
-boot_putw( ctx_timer );
+boot_putd( ctx_timer );
 boot_puts("\n");
 
 boot_puts("  - ctx[FBDMA]  = ");
-boot_putw( ctx_fbdma );
+boot_putd( ctx_fbdma );
 boot_puts("\n");
 
 boot_puts("  - ctx[PTAB]   = ");
-boot_putw( ctx_ptab );
+boot_putx( ctx_ptab );
 boot_puts("\n");
 
 boot_puts("  - ctx[VSID]   = ");
-boot_putw( vspace_id );
+boot_putd( vspace_id );
 boot_puts("\n");
 
@@ -1732 +1762 @@
 
     boot_puts("\n[BOOT] Mapping check completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1739 +1769 @@
 
     boot_puts("\n[BOOT] Pseg allocators initialisation completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1746 +1776 @@
 
     boot_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1753 +1783 @@
 
     boot_puts("\n[BOOT] Vobjs initialisation completed at cycle : ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1760 +1790 @@
 
     boot_puts("\n[BOOT] Peripherals initialisation completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1768 +1798 @@
 
     boot_puts("\n[BOOT] MMU activation completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 
@@ -1775 +1805 @@
 
     boot_puts("\n[BOOT] Schedulers initialisation completed at cycle ");
-    boot_putw( boot_proctime() );
+    boot_putd( boot_proctime() );
     boot_puts("\n");
 

soft/giet_vm/boot/reset.S

@@ -65 +65 @@
     nop
     mfc0        a0,     CP0_TIME
-        jal             boot_putw
+        jal             boot_putx
         nop
     la          a0,     boot_lf_string
@@ -76 +76 @@
     mfc0        k0,     CP0_PROCID
     andi        a0,     k0,     0xFFF
-        jal             boot_putw
+        jal             boot_putx
     nop
     la          a0,     boot_lf_string
@@ -86 +86 @@
     nop
     mfc0        a0,     CP0_EPC
-        jal             boot_putw
+        jal             boot_putx
     nop
     la          a0,     boot_lf_string
@@ -96 +96 @@
     nop
     mfc0        a0,     CP0_CR
-        jal             boot_putw
+        jal             boot_putx
     nop
     la          a0,     boot_lf_string
@@ -106 +106 @@
     nop
     mfc0        a0,     CP0_SR
-        jal             boot_putw
+        jal             boot_putx
     nop
     la          a0,     boot_lf_string
@@ -116 +116 @@
     nop
     mfc0        a0,     CP0_BVAR
-        jal             boot_putw
+        jal             boot_putx
     nop
     la          a0,     boot_lf_string

soft/giet_vm/giet_config.h

@@ -12 +12 @@
 /* Debug parameters */
 
-#define BOOT_DEBUG_PERI     0       /* display peripherals initialisation on TTY0 */
-#define BOOT_DEBUG_PT           0           /* display page tables initialisation on TTY0 */
-#define BOOT_DEBUG_VOBJS        0               /* display vobjs initialisation on TTY0 */
-#define BOOT_DEBUG_SCHED        0               /* display schedulers initialisation on TTY0 */
+#define BOOT_DEBUG_PERI     0                   /* trace peripherals initialisation on TTY0 */
+#define BOOT_DEBUG_PT           0                       /* trace page tables initialisation on TTY0 */
+#define BOOT_DEBUG_VOBJS        0                       /* trace vobjs initialisation on TTY0 */
+#define BOOT_DEBUG_SCHED        0                       /* trace schedulers initialisation on TTY0 */
 
-#define GIET_DEBUG_INIT         0               /* display parallel kernel initialisation on TTY0 */
-#define GIET_DEBUG_SWITCH       0           /* display context switchs on TTY0 */
+#define GIET_DEBUG_INIT         0                       /* trace parallel kernel initialisation on TTY0 */
+#define GIET_DEBUG_SWITCH       0                       /* trace context switchs on TTY0 */
 
 
@@ -25 +25 @@
 /* hardware parameters */
 
-#define NB_CLUSTERS             1           /* number of clusters */
-#define CLUSTER_SPAN            0           /* address increment between clusters */
-#define NB_PROCS_MAX        4       /* max number of processors per cluster */
-#define NB_TIMERS_MAX           0           /* max number of user timers per cluster */
-#define NB_DMAS_MAX                     1           /* max number of DMA channels per cluster*/
-#define NB_TTYS                         8           /* total number of TTY channels */
-#define NB_IOCS                         0           /* total number of IOC channels */
-#define NB_NICS                         0           /* total number of NIC channels */
+#define NB_CLUSTERS             1                       /* number of clusters */
+#define CLUSTER_SIZE            0x40000000      /* address increment between clusters */
+#define CLUSTER_IO_ID       0                   /* cluster containing non replicated peripherals */
+        
+#define NB_PROCS_MAX        4                   /* max number of processors per cluster */
+#define NB_TIMERS_MAX           0                       /* max number of user timers per cluster */
+#define NB_DMAS_MAX                     1                       /* max number of DMA channels per cluster*/
+#define NB_TTYS                         8                       /* total number of TTY channels */
+#define NB_IOCS                         0                       /* total number of IOC channels */
+#define NB_NICS                         0                       /* total number of NIC channels */
 
 /* software parameters */
 
-#define GIET_NB_VSPACE_MAX      4           /* max number of virtual spaces */
-#define GIET_TICK_VALUE     0x4000  /* context switch period (number of cycles) */
-#define GIET_IOMMU_ACTIVE   0           /* The IOMMU vspace is defined */
-#define GIET_USE_XICU       1           /* Use the XICU interrupt controler */
+#define GIET_NB_VSPACE_MAX      4                       /* max number of virtual spaces */
+#define GIET_TICK_VALUE     0x4000              /* context switch period (number of cycles) */
+#define GIET_IOMMU_ACTIVE   0                   /* The IOMMU vspace is defined */
+#define GIET_USE_XICU       1                   /* Use the XICU interrupt controler */
 
 #endif

soft/giet_vm/libs/stdio.c

@@ -21 +21 @@
 #define SYSCALL_GCD_WRITE       0x06
 #define SYSCALL_GCD_READ        0x07
-#define SYSCALL_TTY_READ_IRQ    0x0A
-#define SYSCALL_TTY_WRITE_IRQ   0x0B
 #define SYSCALL_CTX_SWITCH      0x0D
 #define SYSCALL_EXIT            0x0E
@@ -165 +163 @@
                     0,0);
 }
-
-////////////////////////////////////////////////////////////////////////////////////
-// giet_tty_getc_no_irq()
-////////////////////////////////////////////////////////////////////////////////////
-// This blocking function fetches a single ascii character from a terminal.
-// The terminal index must be defined in the task context in the boot phase.
-// It doesn't use the IRQ_GET interrupt, and the associated kernel buffer.
-// - Returns necessarily 0 when completed.
-////////////////////////////////////////////////////////////////////////////////////
-unsigned int giet_tty_getc_no_irq(char *byte)
-{
-    unsigned int ret = 0;
-    while (ret == 0)
-    {
-        ret = sys_call(SYSCALL_TTY_READ,
-                       (unsigned int)byte,
-                       1,
-                       0,0);
-    }
-    return 0;
-}
 ////////////////////////////////////////////////////////////////////////////////////
 // giet_tty_getc()
@@ -199 +176 @@
     while (ret == 0)
     {
-        ret = sys_call(SYSCALL_TTY_READ_IRQ,
+        ret = sys_call(SYSCALL_TTY_READ,
                        (unsigned int)byte,
                        1,
@@ -231 +208 @@
     {
         do {
-            ret = sys_call(SYSCALL_TTY_READ_IRQ,
+            ret = sys_call(SYSCALL_TTY_READ,
                            (unsigned int)(&byte),
                            1,
@@ -283 +260 @@
     {
         do {
-            ret = sys_call(SYSCALL_TTY_READ_IRQ,
+            ret = sys_call(SYSCALL_TTY_READ,
                            (unsigned int)(&byte),
                            1,

soft/giet_vm/sys/drivers.c

@@ -17 +17 @@
 //
 // The following global parameters must be defined in the giet_config.h file:
+// - CLUSTER_IO_ID
+// - CLUSTER_SIZE
 // - NB_CLUSTERS   
 // - NB_PROCS_MAX  
@@ -23 +25 @@
 // - NB_TTYS    
 //
-// The following virtual base addresses must be defined in the sys.ld file:
+// The following virtual base addresses must be defined in the giet.ld file:
 // - seg_icu_base
 // - seg_tim_base
@@ -31 +33 @@
 // - seg_fbf_base
 // - seg_ioc_base
+// As some peripherals can be replicated in the clusters (ICU, TIMER, DMA)
+// These addresses must be completed by an offset depending on the cluster index
+//    full_base_address = seg_***_base + cluster_id * CLUSTER_SIZE
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -54 +59 @@
 #endif
 
-#if !defined(CLUSTER_SPAN) 
-# error: You must define CLUSTER_SPAN in 'giet_config.h' file
+#if !defined(CLUSTER_SIZE) 
+# error: You must define CLUSTER_SIZE in 'giet_config.h' file
 #endif
 
@@ -132 +137 @@
 
 #if GIET_USE_XICU
-    unsigned int* timer_address = (unsigned int*)&seg_icu_base +
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
+                                  (cluster_id * CLUSTER_SIZE) );
 
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = period;
 #else
-    unsigned int* timer_address = (unsigned int*)&seg_tim_base + 
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_tim_base + 
+                                  (cluster_id * CLUSTER_SIZE) );
 
     timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period;
@@ -160 +165 @@
 
 #if GIET_USE_XICU
-    unsigned int* timer_address = (unsigned int*)&seg_icu_base +
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
+                                  (cluster_id * CLUSTER_SIZE) );
 
     timer_address[XICU_REG(XICU_PTI_PER, local_id)] = 0;
 #else
-    unsigned int* timer_address = (unsigned int*)&seg_tim_base + 
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_tim_base + 
+                                  (cluster_id * CLUSTER_SIZE) );
 
     timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0;
@@ -176 +181 @@
 //     _timer_reset_irq()
 // This function acknowlegge a timer interrupt in the vci_timer (or vci_xicu) 
-// component by writing in the proper register the period value.
+// component by reading/writing in the proper register.
 // It can be used by both the isr_switch() for a "system" timer, 
 // or by the _isr_timer() for an "user" timer.
@@ -189 +194 @@
 
 #if GIET_USE_XICU
-    unsigned int* timer_address = (unsigned int*)&seg_icu_base +
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
+                                  (cluster_id * (unsigned)CLUSTER_SIZE) );
 
     unsigned int bloup = timer_address[XICU_REG(XICU_PTI_ACK, local_id)];
+    bloup++;    // to avoid a warning 
 #else
-    unsigned int* timer_address = (unsigned int*)&seg_tim_base + 
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int* timer_address = (unsigned int*)((char*)&seg_tim_base + 
+                                  (cluster_id * CLUSTER_SIZE) );
 
     timer_address[local_id * TIMER_SPAN + TIMER_RESETIRQ] = 0;
@@ -258 +264 @@
     }
 
-    unsigned int*       tty_address = (unsigned int*)&seg_tty_base + tty_id*TTY_SPAN;
+    unsigned int*       tty_address = (unsigned int*)( (char*)&seg_tty_base + 
+                                  (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) ); 
 
     for (nwritten = 0; nwritten < length; nwritten++)
     {
         // check tty's status 
-        if ((tty_address[TTY_STATUS] & 0x2) == 0x2)
+        if ((tty_address[tty_id*TTY_SPAN + TTY_STATUS] & 0x2) == 0x2)
             break;
         else
             // write character 
-            tty_address[TTY_WRITE] = (unsigned int)buffer[nwritten];
+            tty_address[tty_id*TTY_SPAN + TTY_WRITE] = (unsigned int)buffer[nwritten];
     }
     return nwritten;
 }
 //////////////////////////////////////////////////////////////////////////////
-//      _tty_read_irq()
+//      _tty_read()
 // This non-blocking function uses the TTY_GET_IRQ[tty_id] interrupt and 
 // the associated kernel buffer, that has been written by the ISR.
+// It get the TTY terminal index from the context of the current task.
 // It fetches one single character from the _tty_get_buf[tty_id] kernel
 // buffer, writes this character to the user buffer, and resets the
 // _tty_get_full[tty_id] buffer.
+// The length argument is not used.
 // Returns 0 if the kernel buffer is empty, 1 if the buffer is full.
 //////////////////////////////////////////////////////////////////////////////
-unsigned int _tty_read_irq( char                        *buffer, 
-                            unsigned int        length)
+unsigned int _tty_read( char                    *buffer, 
+                        unsigned int    length)
 {
     unsigned int task_id  = _get_current_task_id();
@@ -304 +313 @@
 } 
 ////////////////////////////////////////////////////////////////////////////////
-//     _tty_read()
-// This non-blocking function fetches one character directly from the TTY_READ 
-// register of the TTY controler, and writes this character to the user buffer.
-// It doesn't use the TTY_GET_IRQ interrupt and the associated kernel buffer.
-// Returns 0 if the register is empty, 1 if the register is full.
-////////////////////////////////////////////////////////////////////////////////
-unsigned int _tty_read( char                    *buffer, 
-                        unsigned int    length)
-{
-    unsigned int task_id  = _get_current_task_id();
-    unsigned int tty_id   = _get_context_slot(task_id, CTX_TTY_ID);
-
-    if ( tty_id >= NB_TTYS )
-    {
-        _tty_error( task_id );
-        return 0;
-    }
-
-    unsigned int*       tty_address = (unsigned int*)&seg_tty_base + tty_id*TTY_SPAN;
-
-    if ((tty_address[TTY_STATUS] & 0x1) != 0x1) 
-    {
-        return 0;
-    }
-    else
-    {
-        *buffer = (char)tty_address[TTY_READ];
-        return 1;
-    }
+//     _tty_get_char()
+// This function is used by the _isr_tty to read a character in the TTY
+// terminal defined by the tty_id argument. The character is stored
+// in requested buffer, and the IRQ is acknowledged.
+// Returns 0 if success, 1 if tty_id too large. 
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _tty_get_char( unsigned int        tty_id,
+                            char*           buffer )
+{
+    // checking argument
+    if ( tty_id >= NB_TTYS ) return 1;
+
+    // compute terminal base address 
+    unsigned int *tty_address = (unsigned int*)( (char*)&seg_tty_base + 
+                                (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
+
+    *buffer = (unsigned char)tty_address[tty_id*TTY_SPAN + TTY_READ];
+    return 0;
 }
 
@@ -359 +357 @@
     if ( proc_id    >= NB_PROCS_MAX )   return 1;
 
-    unsigned int* icu_address = (unsigned int*)&seg_icu_base + 
-                                (cluster_id * CLUSTER_SPAN);
+    unsigned int* icu_address = (unsigned int*)( (char*)&seg_icu_base + 
+                                (cluster_id * (unsigned)CLUSTER_SIZE) );
 #if GIET_USE_XICU
     if ( is_timer ) icu_address[XICU_REG(XICU_MSK_PTI_ENABLE, proc_id)] = value;
@@ -385 +383 @@
     if ( proc_id    >= NB_PROCS_MAX )   return 1;
 
-    unsigned int* icu_address = (unsigned int*)&seg_icu_base + 
-                                (cluster_id * CLUSTER_SPAN);
+    unsigned int* icu_address = (unsigned int*)( (char*)&seg_icu_base + 
+                                (cluster_id * (unsigned)CLUSTER_SIZE) );
 #if GIET_USE_XICU
     unsigned int prio   = icu_address[XICU_REG(XICU_PRIO, proc_id)];
@@ -422 +420 @@
                          unsigned int value)
 {
-    volatile unsigned int *gcd_address;
-
     // parameters checking
     if (register_index >= GCD_END)
         return 1;
 
-    gcd_address = (unsigned int*)&seg_gcd_base;
+    unsigned int* gcd_address = (unsigned int*)( (char*)&seg_gcd_base +
+                                (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
 
     gcd_address[register_index] = value; // write word
@@ -441 +438 @@
                         unsigned int *buffer)
 {
-    volatile unsigned int *gcd_address;
-
     // parameters checking 
     if (register_index >= GCD_END)
         return 1;
 
-    gcd_address = (unsigned int*)&seg_gcd_base;
+    unsigned int* gcd_address = (unsigned int*)( (char*)&seg_gcd_base +
+                                (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
 
     *buffer = gcd_address[register_index]; // read word
@@ -538 +534 @@
     if ( (unsigned int)user_vaddr & 0x3 ) return 1;
 
-    unsigned int*       ioc_address = (unsigned int*)&seg_ioc_base;
+    unsigned int*       ioc_address = (unsigned int*)( (char*)&seg_ioc_base +
+                                  (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
+
     unsigned int        block_size   = ioc_address[BLOCK_DEVICE_BLOCK_SIZE];
     unsigned int        length       = count*block_size;
@@ -630 +628 @@
     if ( GIET_IOMMU_ACTIVE )
     {
-        unsigned int* iob_address = (unsigned int*)&seg_iob_base;
+        unsigned int* iob_address = (unsigned int*)( (char*)&seg_iob_base +
+                                    (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
 
         for ( ix2 = 0 ; ix2 < _ioc_iommu_npages ; ix2++ )
@@ -687 +686 @@
                         (unsigned int)buffer,
                         count );
+}
+///////////////////////////////////////////////////////////////////////////////
+//     _ioc_get_status()
+// This function returns the transfert status, and acknowledge the IRQ.
+// Returns 0 if success, > 0 if error.
+///////////////////////////////////////////////////////////////////////////////
+unsigned int _ioc_get_status(unsigned int* status)
+{
+    // get IOC base address
+    unsigned int* ioc_address = (unsigned int*)( (char*)&seg_ioc_base +
+                                (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
+
+    *status = ioc_address[BLOCK_DEVICE_STATUS]; // read status & reset IRQ 
+    return 0;
 }
 
@@ -718 +731 @@
 in_unckdata unsigned int            _dma_iommu_npages[NB_DMAS_MAX * NB_CLUSTERS];
 #endif
+
+//////////////////////////////////////////////////////////////////////////////////
+// _dma_reset_irq()
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _dma_reset_irq( unsigned int       cluster_id,
+                             unsigned int       local_id )
+{
+    // parameters checking 
+    if ( cluster_id >= NB_CLUSTERS ) return 1;
+    if ( local_id >= NB_DMAS_MAX )   return 1;
+
+    // compute DMA base address
+    unsigned int*       dma_address = (unsigned int*)( (char*)&seg_dma_base + 
+                                  (cluster_id * (unsigned)CLUSTER_SIZE) );
+
+    dma_address[local_id*DMA_SPAN + DMA_RESET] = 0;                     
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////////
+// _dma_get_status()
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int _dma_get_status( unsigned int      cluster_id,
+                              unsigned int      local_id,
+                              unsigned int* status )
+{
+    // parameters checking 
+    if ( cluster_id >= NB_CLUSTERS ) return 1;
+    if ( local_id >= NB_DMAS_MAX )   return 1;
+
+    // compute DMA base address
+    unsigned int*       dma_address = (unsigned int*)( (char*)&seg_dma_base + 
+                                  (cluster_id * (unsigned)CLUSTER_SIZE) );
+    
+    *status = dma_address[local_id*DMA_SPAN + DMA_LEN];
+    return 0;
+}
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -819 +868 @@
     unsigned int    cluster_id = dma_id / NB_DMAS_MAX;
     unsigned int    loc_id     = dma_id % NB_DMAS_MAX;
-    unsigned int*       dma_base   = (unsigned int*)&seg_dma_base +
-                                 (cluster_id * CLUSTER_SPAN) + 
-                                 (loc_id * DMA_SPAN);
-
+
+    unsigned int*       dma_base   = (unsigned int*)( (char*)&seg_dma_base +
+                                 (cluster_id * (unsigned)CLUSTER_SIZE) );
+ 
     // check user buffer address and length alignment
     if ( (user_vaddr & 0x3) || (length & 0x3) )
@@ -930 +979 @@
 
 */
+
     // invalidate data cache in case of memory write
     if ( to_user ) _dcache_buf_invalidate( (void*)user_vaddr, length );
@@ -939 +989 @@
     if ( to_user )
     {
-        dma_base[DMA_SRC] = (unsigned int)fb_pbase;
-        dma_base[DMA_DST] = (unsigned int)user_pbase;
+        dma_base[loc_id*DMA_SPAN + DMA_SRC] = (unsigned int)fb_pbase;
+        dma_base[loc_id*DMA_SPAN + DMA_DST] = (unsigned int)user_pbase;
     }
     else
     {
-        dma_base[DMA_SRC] = (unsigned int)user_pbase;
-        dma_base[DMA_DST] = (unsigned int)fb_pbase;
-    }
-    dma_base[DMA_LEN] = (unsigned int)length;
+        dma_base[loc_id*DMA_SPAN + DMA_SRC] = (unsigned int)user_pbase;
+        dma_base[loc_id*DMA_SPAN + DMA_DST] = (unsigned int)fb_pbase;
+    }
+    dma_base[loc_id*DMA_SPAN + DMA_LEN] = (unsigned int)length;
     
     return 0;
@@ -1011 +1061 @@
     if ( GIET_IOMMU_ACTIVE )
     {
-        unsigned int* iob_address = (unsigned int*)&seg_iob_base;
+        unsigned int* iob_address = (unsigned int*)( (char*)&seg_iob_base +
+                                    (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
+
         unsigned int  ix1         = _dma_iommu_ix1 + dma_id;
         unsigned int  ix2;

soft/giet_vm/sys/drivers.h

@@ -40 +40 @@
                             unsigned int        length);
 
-unsigned int _tty_read_irq( char*                       buffer, 
-                            unsigned int        length);
+unsigned int _tty_get_char( unsigned int        tty_id,
+                            char*                       buffer); 
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -77 +77 @@
 unsigned int _ioc_completed();
 
+unsigned int _ioc_get_status( unsigned int* status);
+
 ///////////////////////////////////////////////////////////////////////////////////
 // Multi DMA variables                  (vci_multi_dma)
@@ -86 +88 @@
 extern unsigned int                             _dma_iommu_ix1;
 extern unsigned int                             _dma_iommu_npages[];
+
+unsigned int _dma_reset_irq( unsigned int       cluster_id,
+                             unsigned int       local_id );
+
+unsigned int _dma_get_status( unsigned int      cluster_id,
+                              unsigned int      local_id,
+                              unsigned int*     status );
 
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/sys/irq_handler.c

@@ -92 +92 @@
     // compute cluster_id and loc_id
     unsigned int cluster_id = channel_id / NB_DMAS_MAX;
-    unsigned int loc_id     = channel_id % NB_DMAS_MAX;
-
-    // compute DMA channel address
-    unsigned int*       dma_address = (unsigned int*)&seg_dma_base + 
-                                  (loc_id * DMA_SPAN) +
-                                  (cluster_id * CLUSTER_SPAN);
+    unsigned int local_id   = channel_id % NB_DMAS_MAX;
 
     // save DMA channel status  
-    _dma_status[channel_id] = dma_address[DMA_LEN];
-
-    // reset DMA channel
-    dma_address[DMA_RESET] = 0;                 
+    if ( _dma_get_status(cluster_id, local_id, &_dma_status[channel_id]) )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
+
+    // reset DMA channel irq
+    if ( _dma_reset_irq(cluster_id, local_id) )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
 
     // release DMA channel 
@@ -117 +124 @@
 void _isr_ioc()
 {
-    unsigned int* ioc_address = (unsigned int*)&seg_ioc_base;
-
-    _ioc_status = ioc_address[BLOCK_DEVICE_STATUS]; // save status & reset IRQ 
-    _ioc_done   = 1;                                // signals completion 
+     // save status & reset IRQ 
+    if ( _ioc_get_status( &_ioc_status ) )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] bad access to IOC status detected by _isr_ioc\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
+
+    // signals completion 
+    _ioc_done   = 1; 
 }
 
@@ -148 +162 @@
         _puts("[GIET ERROR] Strange... User timer ISR for a system timer\n");
         _release_lock(&_tty_put_lock);
+        return;
     }
 
     // aknowledge IRQ 
-    _timer_reset_irq( cluster_id, local_id );
+    if ( _timer_reset_irq( cluster_id, local_id ) )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] illegal timer index detected by _isr_timer\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
 
 #if NB_TIMERS_MAX
@@ -172 +193 @@
 // This ISR handles the IRQs generated by the multi_tty controler,
 // signaling that a character is available.
-// There is one single multi_tty component controling all TTYs, and the tty_id 
-// argument is the global TTY index.
+// There is one single multi_tty component controling all TTYs, 
+// and the tty_id // argument is the global TTY index.
 // There is one communication buffer _tty_buf[tty_id] per terminal.
 // The sychronisation variable _tty_full[tty_id], is set by the ISR,
@@ -181 +202 @@
 void _isr_tty(unsigned int tty_id)
 {
-    // compute terminal base address 
-    unsigned int *tty_address = (unsigned int*)&seg_tty_base + (tty_id * TTY_SPAN);
-
     // save character and reset IRQ 
-    _tty_get_buf[tty_id] = (unsigned char)tty_address[TTY_READ];
+    if ( _tty_get_char( tty_id, &_tty_get_buf[tty_id] ) )
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] illegal tty index detected by _isr_tty\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
 
     // signals character available 
@@ -207 +231 @@
 
     // acknowledge IRQ
-    _timer_reset_irq( cluster_id, local_id ); 
+    if ( _timer_reset_irq( cluster_id, local_id ) ) 
+    {
+        _get_lock(&_tty_put_lock);
+        _puts("[GIET ERROR] illegal proc index detected by _isr_switch\n");
+        _release_lock(&_tty_put_lock);
+        return;
+    }
 
     // performs the context switch

soft/giet_vm/sys/sys_handler.c

@@ -32 +32 @@
     &_sys_ukn,          /* 0x08 */
     &_sys_ukn,          /* 0x09 */
-    &_tty_read_irq,     /* 0x0A */
+    &_sys_ukn,          /* 0x0A */
     &_sys_ukn,          /* 0x0B */
     &_sys_ukn,          /* 0x0C */

soft/giet_vm/xml/xml_driver.c

@@ -218 +218 @@
     fprintf( fpout, "<?xml version = \"1.0\"?>\n\n");
 
-    fprintf( fpout, "<mapping_info signature = \"0x%x\"\n", header->signature);
-    fprintf( fpout, "              name      = \"%s\"\n", header->name);
-    fprintf( fpout, "              clusters  = \"%d\"\n", header->clusters);
-    fprintf( fpout, "              vspaces   = \"%d\"\n", header->vspaces);
-    fprintf( fpout, "              globals   = \"%d\" >\n\n", header->globals);
+    fprintf( fpout, "<mapping_info signature = \"0x%x\" ", header->signature);
+    fprintf( fpout, " name = \"%s\" ", header->name);
+    fprintf( fpout, " clusters = \"%d\" ", header->clusters);
+    fprintf( fpout, " vspaces = \"%d\" >\n\n", header->vspaces);
 
     ///////////////////// clusters ///////////////////////////////////////////////
@@ -231 +230 @@
         fprintf( fpout, "        <cluster index  = \"%d\" >\n",   cluster_id);
         for ( pseg_id = cluster[cluster_id].pseg_offset ; 
-                pseg_id < cluster[cluster_id].pseg_offset + cluster[cluster_id].psegs ; 
-                    pseg_id++ )
-        {
-            fprintf( fpout, "                 <pseg    name   = \"%s\"\n",        pseg[pseg_id].name);
-            fprintf( fpout, "                          type   = \"%s\"\n",  pseg_type[pseg[pseg_id].type]);
-            fprintf( fpout, "                          base   = \"0x%x\"\n",      pseg[pseg_id].base);
-            fprintf( fpout, "                          length = \"0x%x\" />\n",   pseg[pseg_id].length);
+              pseg_id < cluster[cluster_id].pseg_offset + cluster[cluster_id].psegs ; 
+              pseg_id++ )
+        {
+            fprintf( fpout, "            <pseg name = \"%s\" ", pseg[pseg_id].name);
+            fprintf( fpout, " type = \"%s\" ", pseg_type[pseg[pseg_id].type]);
+            fprintf( fpout, " base = \"0x%x\" ", pseg[pseg_id].base);
+            fprintf( fpout, " length = \"0x%x\" />\n",   pseg[pseg_id].length);
         }
 
@@ -243 +242 @@
 
         for ( proc_id = cluster[cluster_id].proc_offset ; 
-                proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs ;
-                    proc_id++ )
-        {
-            fprintf( fpout, "                   <proc index   = \"%d\" >\n",       proc_id);
-            for ( irq_id = proc[proc_id].irq_offset ; irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs ; irq_id++ )
+              proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs ;
+              proc_id++ )
+        {
+            fprintf( fpout, "            <proc index = \"%d\" >\n", proc_id);
+            for ( irq_id = proc[proc_id].irq_offset ; 
+                  irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs ; 
+                  irq_id++ )
             {
-                fprintf( fpout, "                         <irq    type    = \"%s\"\n",  irq_type[irq[irq_id].type]);
-                fprintf( fpout, "                                 icuid   = \"0x%x\"\n",      irq[irq_id].icuid);
-                fprintf( fpout, "                                 isr     = \"%s\"\n",  isr_type[irq[irq_id].isr]);
-                fprintf( fpout, "                                 channel = \"0x%x\" />\n",   irq[irq_id].channel);
+                fprintf( fpout, "                <irq type = \"%s\" ", irq_type[irq[irq_id].type]);
+                fprintf( fpout, " icuid = \"0x%x\" ", irq[irq_id].icuid);
+                fprintf( fpout, " isr = \"%s\" ", isr_type[irq[irq_id].isr]);
+                fprintf( fpout, " channel = \"0x%x\" />\n", irq[irq_id].channel);
             }
-            fprintf( fpout, "                   </proc>\n" );
+            fprintf( fpout, "            </proc>\n" );
         }
 
@@ -261 +262 @@
 
         for ( coproc_id = cluster[cluster_id].coproc_offset ; 
-                coproc_id < cluster[cluster_id].coproc_offset + cluster[cluster_id].coprocs ;
-                    coproc_id++ )
-        {
-            fprintf( fpout, "                   <coproc name       = \"%s\"\n",       coproc[coproc_id].name);
-            fprintf( fpout, "                           psegname   = \"%s\" >\n",       pseg[coproc[coproc_id].psegid].name);
-            for ( port_id = coproc[coproc_id].port_offset ; port_id < coproc[coproc_id].port_offset + coproc[coproc_id].ports ; port_id++ )
+              coproc_id < cluster[cluster_id].coproc_offset + cluster[cluster_id].coprocs ;
+              coproc_id++ )
+        {
+            fprintf( fpout, "            <coproc name = \"%s\" ", coproc[coproc_id].name);
+            fprintf( fpout, " psegname = \"%s\" >\n", pseg[coproc[coproc_id].psegid].name);
+            for ( port_id = coproc[coproc_id].port_offset ; 
+                  port_id < coproc[coproc_id].port_offset + coproc[coproc_id].ports ; 
+                  port_id++ )
             {
                 unsigned int vobj_id = cp_port[port_id].vobjlocid + vspace[cp_port[port_id].vspaceid].vobj_offset; 
-                fprintf( fpout, "                           <port   direction    = \"%s\"\n",  port_direction[ cp_port[port_id].direction]);
-                fprintf( fpout, "                                   vspacename   = \"%s\"\n",  vspace[cp_port[port_id].vspaceid].name);
-                fprintf( fpout, "                                   vobjname     = \"%s\" />\n",  vobj[vobj_id].name);
+                fprintf( fpout, "             <port direction = \"%s\" ",  port_direction[ cp_port[port_id].direction]);
+                fprintf( fpout, " vspacename = \"%s\" ", vspace[cp_port[port_id].vspaceid].name);
+                fprintf( fpout, " vobjname = \"%s\" />\n",  vobj[vobj_id].name);
             }
-            fprintf( fpout, "                   </coproc>\n" );
+            fprintf( fpout, "            </coproc>\n" );
         }
 
@@ -279 +282 @@
 
         for ( periph_id = cluster[cluster_id].periph_offset ; 
-                periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs ;
-                    periph_id++ )
-        {
-            fprintf( fpout, "                   <periph type       = \"%s\"\n",     periph_type[periph[periph_id].type]);
-            fprintf( fpout, "                           psegname   = \"%s\"\n",     pseg[periph[periph_id].psegid].name);
-            fprintf( fpout, "                           channels   = \"%d\" />\n",  periph[periph_id].channels);
+              periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs ;
+              periph_id++ )
+        {
+            fprintf( fpout, "            <periph type = \"%s\" ", periph_type[periph[periph_id].type]);
+            fprintf( fpout, " psegname = \"%s\" ", pseg[periph[periph_id].psegid].name);
+            fprintf( fpout, " channels = \"%d\" />\n",  periph[periph_id].channels);
         }
         fprintf( fpout, "        </cluster>\n" );
@@ -297 +300 @@
         unsigned int pseg_id = vseg[vseg_id].psegid; 
 
-        fprintf( fpout, "        <vseg    name      = \"%s\"\n",      vseg[vseg_id].name);
-        fprintf( fpout, "                 vbase     = \"0x%x\"\n",    vseg[vseg_id].vbase);
-        fprintf( fpout, "                 mode      = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
-        fprintf( fpout, "                 clusterid = \"%d\"\n",      pseg[pseg_id].cluster);
-        fprintf( fpout, "                 psegname  = \"%s\"\n",      pseg[pseg_id].name);
-        fprintf( fpout, "                 ident     = \"%d\" >\n",    vseg[vseg_id].ident);
+        fprintf( fpout, "        <vseg name = \"%s\" ", vseg[vseg_id].name);
+        fprintf( fpout, "vbase = \"0x%x\" ", vseg[vseg_id].vbase);
+        fprintf( fpout, "mode  = \"%s\" ", mode_str[vseg[vseg_id].mode]);
+        fprintf( fpout, "clusterid = \"%d\" ", pseg[pseg_id].cluster);
+        fprintf( fpout, "psegname = \"%s\" ", pseg[pseg_id].name);
+        fprintf( fpout, "ident = \"%d\" >\n", vseg[vseg_id].ident);
         for ( vobj_id = vseg[vseg_id].vobj_offset;
               vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs); 
               vobj_id++ )
         {
-            fprintf( fpout, "                 <vobj name     = \"%s\"\n",    vobj[vobj_id].name);
-            fprintf( fpout, "                       type     = \"%s\"\n",    vobj_type[vobj[vobj_id].type]);
-            fprintf( fpout, "                       length   = \"0x%x\"\n",  vobj[vobj_id].length);
-            fprintf( fpout, "                       align    = \"%d\"\n",    vobj[vobj_id].align);
-            fprintf( fpout, "                       init     = \"%d\" \n",   vobj[vobj_id].init);
-            fprintf( fpout, "                       binpath  = \"%s\" />\n", vobj[vobj_id].binpath);
+            fprintf( fpout, "            <vobj name = \"%s\" ", vobj[vobj_id].name);
+            fprintf( fpout, "type = \"%s\" ", vobj_type[vobj[vobj_id].type]);
+            fprintf( fpout, "length = \"0x%x\" ", vobj[vobj_id].length);
+            fprintf( fpout, "align = \"%d\" ", vobj[vobj_id].align);
+            fprintf( fpout, "init = \"%d\" ", vobj[vobj_id].init);
+            fprintf( fpout, "binpath = \"%s\" />\n", vobj[vobj_id].binpath);
         }
         fprintf( fpout, "        </vseg>\n");
@@ -324 +327 @@
     {
         unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].start_offset; 
-        fprintf( fpout, "        <vspace  name      = \"%s\"\n",     vspace[vspace_id].name); 
-        fprintf( fpout, "                 startname = \"%s\" >\n\n", vobj[func_id].name); 
+        fprintf( fpout, "        <vspace name = \"%s\" ", vspace[vspace_id].name); 
+        fprintf( fpout, " startname = \"%s\" >\n", vobj[func_id].name); 
 
         for ( vseg_id = vspace[vspace_id].vseg_offset ;
-              vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs) ; vseg_id++ )
+              vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs) ; 
+              vseg_id++ )
         {
             unsigned int pseg_id = vseg[vseg_id].psegid; 
 
-            fprintf( fpout, "                 <vseg name      = \"%s\"\n",      vseg[vseg_id].name);
-            fprintf( fpout, "                       vbase     = \"0x%x\"\n",    vseg[vseg_id].vbase);
-            fprintf( fpout, "                       mode      = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
-            fprintf( fpout, "                       clusterid = \"%d\"\n",      pseg[pseg_id].cluster);
-            fprintf( fpout, "                       psegname  = \"%s\"\n",      pseg[pseg_id].name);
-            fprintf( fpout, "                       ident     = \"%d\" >\n",    vseg[vseg_id].ident);
+            fprintf( fpout, "            <vseg name = \"%s\" ", vseg[vseg_id].name);
+            fprintf( fpout, "vbase = \"0x%x\" ", vseg[vseg_id].vbase);
+            fprintf( fpout, "mode  = \"%s\" ", mode_str[vseg[vseg_id].mode]);
+            fprintf( fpout, "clusterid = \"%d\" ", pseg[pseg_id].cluster);
+            fprintf( fpout, "psegname = \"%s\" ", pseg[pseg_id].name);
+            fprintf( fpout, "ident = \"%d\" >\n", vseg[vseg_id].ident);
 
             for ( vobj_id = vseg[vseg_id].vobj_offset ;
@@ -343 +347 @@
                   vobj_id++ )
             {
-                fprintf( fpout, "                       <vobj name     = \"%s\"\n",    vobj[vobj_id].name);
-                fprintf( fpout, "                             type     = \"%s\" \n",   vobj_type[vobj[vobj_id].type]);
-                fprintf( fpout, "                             length   = \"0x%x\" \n", vobj[vobj_id].length);
-                fprintf( fpout, "                             align    = \"%d\" \n",   vobj[vobj_id].align);
-                fprintf( fpout, "                             init     = \"%d\" \n",   vobj[vobj_id].init);
-                fprintf( fpout, "                             binpath  = \"%s\" />\n", vobj[vobj_id].binpath);
+                fprintf( fpout, "             <vobj name = \"%s\" ", vobj[vobj_id].name);
+                fprintf( fpout, "type = \"%s\" ", vobj_type[vobj[vobj_id].type]);
+                fprintf( fpout, "length = \"0x%x\" ", vobj[vobj_id].length);
+                fprintf( fpout, "align = \"%d\" ", vobj[vobj_id].align);
+                fprintf( fpout, "init = \"%d\" ", vobj[vobj_id].init);
+                fprintf( fpout, "binpath = \"%s\" />\n", vobj[vobj_id].binpath);
             }
-            fprintf( fpout, "                 </vseg>\n");
+            fprintf( fpout, "            </vseg>\n\n");
         }
         for ( task_id = vspace[vspace_id].task_offset ;
@@ -358 +362 @@
             unsigned int vobj_id = task[task_id].vobjlocid + vspace[vspace_id].vobj_offset; 
 
-            fprintf( fpout, "                 <task name      = \"%s\"\n",      task[task_id].name);
-            fprintf( fpout, "                       clusterid = \"%d\"\n",      task[task_id].clusterid);
-            fprintf( fpout, "                       proclocid = \"%d\"\n",      task[task_id].proclocid);
-            fprintf( fpout, "                       stackname = \"%s\"\n",      vobj[vobj_id].name);
-            fprintf( fpout, "                       startid   = \"%d\"\n",      task[task_id].startid);
-            fprintf( fpout, "                       usetty    = \"%d\"\n",      task[task_id].use_tty);
-            fprintf( fpout, "                       usenic    = \"%d\"\n",      task[task_id].use_nic);
-            fprintf( fpout, "                       usetimer  = \"%d\"\n",      task[task_id].use_timer);
-            fprintf( fpout, "                       usefbma   = \"%d\" />\n\n", task[task_id].use_fbdma);
+            fprintf( fpout, "            <task name = \"%s\" ", task[task_id].name);
+            fprintf( fpout, "clusterid = \"%d\" ", task[task_id].clusterid);
+            fprintf( fpout, "proclocid = \"%d\" ", task[task_id].proclocid);
+            fprintf( fpout, "stackname = \"%s\" ", vobj[vobj_id].name);
+            fprintf( fpout, "startid = \"%d\" ", task[task_id].startid);
+            fprintf( fpout, "usetty = \"%d\" ", task[task_id].use_tty);
+            fprintf( fpout, "usenic = \"%d\" ", task[task_id].use_nic);
+            fprintf( fpout, "usetimer = \"%d\" ", task[task_id].use_timer);
+            fprintf( fpout, "usefbma = \"%d\" />\n", task[task_id].use_fbdma);
         }
         fprintf( fpout, "        </vspace>\n\n");

soft/giet_vm/xml/xml_parser.c

@@ -1565 +1565 @@
         else if ( strcmp(tag, "globalset") == 0 ) 
         {
-            // checking source file consistency
-            if ( vseg_index != header->globals )
-            {
-                printf("[XML ERROR] Wrong number of global vsegs\n");
-                exit(1);
-            }
-            else
-            {
 #if XML_PARSER_DEBUG
 printf("  end global set\n\n");
 #endif
-                vseg_loc_index = 0;
-                return;
-            }
+            header->globals = vseg_index;
+            vseg_loc_index = 0;
+            return;
         }
         else 
@@ -1703 +1695 @@
     }
 
-    ////////// get globals attribute
-    value = getIntValue(reader, "globals", &ok);
-    if ( ok )
-    {
-        if ( value >= MAX_VSEGS )
-        {
-            printf("[XML ERROR] The number of globals is larger than %d\n", MAX_VSEGS);
-            exit(1);
-        }
-#if XML_PARSER_DEBUG
-printf("  globals = %d\n", value);
-#endif
-        header->globals  = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <globals> attribute in mapping_info_header\n");
-        exit(1);
-    }
-
     //////// initialise non replicated peripherals cluster_id
     header->tty_clusterid = 0xFFFFFFFF;