Changeset 189 for soft/giet_vm/xml

Timestamp:

Aug 7, 2012, 6:37:49 PM (12 years ago)

Author:

alain

Message:

Introducing a new release where all initialisation
is done in the boot code.

Location:

soft/giet_vm/xml

Files:

• Makefile (modified) (1 diff)
• mapping_info.h (modified) (8 diffs)
• xml_driver.c (modified) (13 diffs)
• xml_parser.c (modified) (57 diffs)

soft/giet_vm/xml/Makefile

@@ -3 +3 @@
 
 bin2xml: xml_driver.c mapping_info.h
-        gcc -Wall -g -I. xml_driver.c -o bin2xml
+        gcc -Wall -g -I. -I../sys xml_driver.c -o bin2xml
 
 xml2bin: xml_parser.c mapping_info.h
-        gcc -Wall -g -I. -I/usr/include/libxml2 xml_parser.c -o xml2bin -lxml2
+        gcc -Wall -g -I. -I../sys -I/usr/include/libxml2 xml_parser.c -o xml2bin -lxml2
 
 test:

soft/giet_vm/xml/mapping_info.h

@@ -13 +13 @@
 // a fixed size header, and 6 variable size arrays:
 //
-// - mapping_header_t   header              (MAPPING_HEADER_SIZE)
-// - mapping_cluster_t  cluster[clusters]   (MAPPING_CLUSTER_SIZE * clusters)
-// - mapping_pseg_t     pseg[psegs]         (MAPPING_PSEG_SIZE * psegs)
-// - mapping_vspace_t   vspace[vspaces]     (MAPPING_VSPACE_SIZE * vspaces)
-// - mapping_vseg_t     vseg[vsegs]         (MAPPING_VSEG_SIZE * vsegs)
-// - mapping_vseg_t     vobj[vsegs]         (MAPPING_VOBJ_SIZE * vsegs)
-// - mapping_task_t     task[tasks]         (MAPPING_TASK_SIZE * tasks)
-//
-// The number of clusters and the number of vspaces are defined in the header.
-// The number of psegs are defined in each cluster.
-// The number of vsegs, tasks ans mwmrs are defined in each vspace.
+// - mapping_cluster_t  cluster[]  
+// - mapping_pseg_t     pseg[]       
+// - mapping_vspace_t   vspace[]  
+// - mapping_vseg_t     vseg[]     
+// - mapping_vseg_t     vobj[]    
+// - mapping_task_t     task[]  
+// - mapping_irq_t      irq[irqs]   
+// - 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. 
-// For each cluster, the base address of the first pseg descriptor
-// is defined by a pseg_offset relative to MAPPING_BOOT_BASE.
-// For each vspace, the base address of the first vseg descriptor
-// is defined by a vseg_offset relative to MAPPING_BOOT_BASE.
-// For each vspace, the base address of the first task desciptor
-// is defined by a task_offset relative to MAPPING_BOOT_BASE.
-// For each vspace, the base address of the first mwmr desciptor
-// is defined by a mwmr_offset relative to MAPPING_BOOT_BASE.
 ////////////////////////////////////////////////////////////////////////////
 
@@ -49 +40 @@
 #define MAPPING_IRQ_SIZE            sizeof(mapping_irq_t)
 #define MAPPING_COPROC_SIZE         sizeof(mapping_coproc_t)
-#define MAPPING_CP_PORT_SIZE    sizeof(mapping_coproc_port_t)
-#define MAPPING_CP_REG_SIZE         sizeof(mapping_coproc_reg_t)
+#define MAPPING_CP_PORT_SIZE    sizeof(mapping_cp_port_t)
 
 #define C_MODE_MASK     0b1000      // cacheable
@@ -81 +71 @@
 enum
 {
-    IRQ_TYPE_HARD     = 0,          // hardware interrupt (peripheral)
-    IRQ_TYPE_SOFT     = 1,          // software interrupt (IPI)
-};
-
-enum
-{
-    ISR_SWITCH        = 0,
-    ISR_IOC           = 1,
-    ISR_FBDMA         = 2,
-    ISR_TTY           = 3,
-};
-
-enum
-{
-    REG_TYPE_STATUS   = 0,          // status register
-    REG_TYPE_CONFIG   = 1,          // config register
+    PERIPH_TYPE_IOC   = 0,
+    PERIPH_TYPE_TTY   = 1,
+    PERIPH_TYPE_TIM   = 2,
+    PERIPH_TYPE_DMA   = 3,
+    PERIPH_TYPE_FBF   = 4,
+    PERIPH_TYPE_NIC   = 5,
+    PERIPH_TYPE_IOB   = 6,
 };
 
@@ -106 +87 @@
 
 ///////////////////////////////
+
 typedef struct mapping_header_s
 {
     unsigned int    signature;      // must contain MAPPING_SIGNATURE
         unsigned int    clusters;           // number of clusters
-    unsigned int    ttys;           // number of TTY terminals 
-    unsigned int    fbs;            // number of FBDMA channels
         unsigned int    globals;                // number of vsegs mapped in all vspaces
         unsigned int    vspaces;                // number of virtual spaces
+
+    unsigned int    tty_clusterid;  // index of cluster containing TTY controler
+    unsigned int    ioc_clusterid;  // index of cluster containing IOC controler
+    unsigned int    nic_clusterid;  // index of cluster containing NIC controler
+    unsigned int    fbf_clusterid;  // index of cluster containing FBF controler
+
     unsigned int    psegs;          // total number of physical segments (for all clusters)
         unsigned int    vsegs;                  // total number of virtual segments (for all vspaces)
         unsigned int    vobjs;                  // total number of virtual objects (for all vspaces)
         unsigned int    tasks;                  // total number of tasks (for all vspaces)
-        unsigned int    procs;                  // total number of procs
-        unsigned int    irqs;           // total number of irqs
-        unsigned int    coprocs;                // total number of coprocs
-        unsigned int    cp_ports;               // total number of cp_ports
-        unsigned int    cp_regs;                // total number of cp_regss
+        unsigned int    procs;                  // total number of procs (for all clusters)
+        unsigned int    irqs;           // total number of irqs (for all processors)
+        unsigned int    coprocs;                // total number of coprocs (for all clusters)
+        unsigned int    cp_ports;               // total number of cp_ports (for all coprocs)
+    unsigned int    periphs;        // total number of peripherals (for all clusters)
+
     char            name[32];       // mapping name
 } mapping_header_t;
@@ -129 +116 @@
 typedef struct mapping_cluster_s
 {
+    unsigned int    psegs;          // number of psegs in cluster
+    unsigned int    pseg_offset;    // index of first pseg in pseg set
+
     unsigned int    procs;          // number of processors in cluster
     unsigned int    proc_offset;    // index of first proc in proc set
+
     unsigned int    coprocs;        // number of coprocessors in cluster
     unsigned int    coproc_offset;  // index of first coproc in coproc set
-    unsigned int    psegs;          // number of psegs in cluster
-    unsigned int    pseg_offset;    // index of first pseg in pseg set
+
+    unsigned int    periphs;        // number of peripherals in cluster
+    unsigned int    periph_offset;  // index of first coproc in coproc set
 } mapping_cluster_t;
 
@@ -183 +175 @@
     unsigned int    vobjlocid;      // stack vobj index in vspace
     unsigned int    startid;        // index in start_vector 
-    unsigned int    use_tty;        // TTY terminal required
-    unsigned int    use_fb;         // DMA channel to frame buffer required
+    unsigned int    use_tty;        // TTY terminal required (global)
+    unsigned int    use_nic;        // NIC channel required (global)
+    unsigned int    use_timer;      // user timer required (local)
+    unsigned int    use_fbdma;      // DMA channel to frame buffer required (local)
 } mapping_task_t;
 
@@ -210 +204 @@
 typedef struct mapping_irq_s
 {
-    unsigned int    type;           // HW_IRQ  / SW_IRQ
+    unsigned int    type;           // 0 => HW_IRQ  / 1 => SW_IRQ
     unsigned int    icuid;          // IRQ Index for the ICU component
     unsigned int    isr;            // Interrupt Service Routine Index 
     unsigned int    channel;        // Channel Index (for multi-cannels peripherals)
-
-    unsigned int    cluster_id;     // physical cluster index
-        unsigned int    proclocid;      // processor local index (inside cluster)
 } mapping_irq_t;
 
@@ -226 +217 @@
     unsigned int    ports;          // number of MWMR ports used by coprocessor
     unsigned int    port_offset;    // index of first MWMR port used by coprocessor
-    unsigned int    regs;           // number of config/status registers 
-    unsigned int    reg_offset;     // index of first register 
 } mapping_coproc_t;
 
-///////////////////////////////////////
-typedef struct mapping_coproc_port_s
+////////////////////////////////
+typedef struct mapping_cp_port_s
 {
     unsigned int    direction;      // TO_COPROC == 0 / FROM_COPROC == 1
-    unsigned int    vspaceid;      // global index of the vspace containing the MWMR channel
-    unsigned int    vobjlocid;        // local(to vspace) index of the vobj containing the MWMR channel
-} mapping_coproc_port_t;
-
-///////////////////////////////////
-typedef struct mapping_coproc_reg_s
-{
-    char            name[32];       // register name
-    unsigned int    type;           // STATUS = 0 / CONFIG == 1
-    unsigned int    loc_id;         // register index in coprocessor (word offset)
-    unsigned int    channel_id;     // channel index in coprocessor (page offset)
-    unsigned int    value;          // initialisation value
-}  mapping_coproc_reg_t;
+    unsigned int    vspaceid;       // index of the vspace containing the MWMR channel
+    unsigned int    vobjlocid;      // local index of the vobj containing the MWMR channel
+} mapping_cp_port_t;
+
+///////////////////////////////
+typedef struct mapping_periph_s
+{
+    unsigned int    type;           // IOC / TTY / TIM / DMA / FBF / NIC / IOB
+    unsigned int    psegid;         // pseg index in cluster
+    unsigned int    channels;       // number of channels
+} mapping_periph_t;
+
 
 #endif

soft/giet_vm/xml/xml_driver.c

@@ -17 +17 @@
 #include  <mapping_info.h>
 
-/////////////////////////////////////////////////////
-void buildXml( mapping_header_t* header, FILE* fpout)
+//////////////////////////////////////////////////////
+void buildXml( mapping_header_t* header, FILE* fpout )
 {
-
     const char* vobj_type[] = 
     { 
@@ -30 +29 @@
         "LOCK",         // Spin-Lock
         "BUFFER",       // Any "no intialiasation needed" objects (stacks...)
-        "BARRIER"       // Barrier
+        "BARRIER",      // Barrier
     };
 
@@ -37 +36 @@
         "RAM",
         "ROM",
-        "PERI"
+        "PERI",
     };
 
@@ -43 +42 @@
     {
         "HARD",
-        "SOFT"
+        "SOFT",
     };
 
     const char* isr_type[] =
     {
+        "ISR_DEFAULT",
+        "ISR_SWITCH",
+        "ISR_TTY",
+        "ISR_DMA",
         "ISR_IOC",
-        "ISR_FBDMA",
-        "ISR_TTY"
-    };
-
-    const char* reg_type[] =
-    {
-        "STATUS",
-        "CONFIG"
+        "ISR_TIMER",
+    };
+
+    const char* periph_type[] =
+    {
+        "IOC",
+        "TTY",
+        "TIM",
+        "DMA",
+        "FBF",
+        "NIC",
+        "IOB",
     };
 
@@ -62 +69 @@
     {
         "TO_COPROC",
-        "FROM_COPROC"
+        "FROM_COPROC",
     };
 
@@ -81 +88 @@
       "CX_U", 
       "CXW_", 
-      "CXWU" 
+      "CXWU", 
     };
 
@@ -94 +101 @@
     unsigned int                coproc_id;
     unsigned int                port_id;
-    unsigned int                reg_id;
-
-    mapping_cluster_t*      cluster;
-    mapping_pseg_t*             pseg;
-    mapping_vspace_t*       vspace;
-    mapping_vseg_t*             vseg;
-    mapping_vobj_t*             vobj;
-    mapping_task_t*             task;
-    mapping_proc_t*             proc;
-    mapping_irq_t*              irq;    
-    mapping_coproc_t*       coproc;
-    mapping_coproc_port_t*      cp_port;
-    mapping_coproc_reg_t*   cp_reg;
+    unsigned int                periph_id;
+
+    mapping_cluster_t*  cluster;
+    mapping_pseg_t*         pseg;
+    mapping_vspace_t*   vspace;
+    mapping_vseg_t*         vseg;
+    mapping_vobj_t*         vobj;
+    mapping_task_t*         task;
+    mapping_proc_t*         proc;
+    mapping_irq_t*          irq;        
+    mapping_coproc_t*   coproc;
+    mapping_cp_port_t*  cp_port;
+    mapping_periph_t*   periph;
 
     // computes the base adresss for clusters array, 
@@ -147 +154 @@
                                   MAPPING_VSEG_SIZE*header->vsegs );
 
-    // computes the base address the array 
+    // computes the base address for procs array 
     proc    = (mapping_proc_t*)   ((char*)header +
                                   MAPPING_HEADER_SIZE +
@@ -157 +164 @@
                                   MAPPING_TASK_SIZE*header->tasks);
 
-    // computes the base address the array 
-    irq    = (mapping_irq_t*)   ((char*)header +
-                                  MAPPING_HEADER_SIZE +
-                                  MAPPING_CLUSTER_SIZE*header->clusters +
-                                  MAPPING_PSEG_SIZE*header->psegs +
-                                  MAPPING_VSPACE_SIZE*header->vspaces +
-                                  MAPPING_VOBJ_SIZE*header->vobjs +
-                                  MAPPING_VSEG_SIZE*header->vsegs+
-                                  MAPPING_TASK_SIZE*header->tasks+
-                                  MAPPING_PROC_SIZE*header->procs
-                                    );
-
-    // computes the base address the array 
-    coproc    = (mapping_coproc_t*)   ((char*)header +
-                                  MAPPING_HEADER_SIZE +
-                                  MAPPING_CLUSTER_SIZE*header->clusters +
-                                  MAPPING_PSEG_SIZE*header->psegs +
-                                  MAPPING_VSPACE_SIZE*header->vspaces +
-                                  MAPPING_VOBJ_SIZE*header->vobjs +
-                                  MAPPING_VSEG_SIZE*header->vsegs+
-                                  MAPPING_TASK_SIZE*header->tasks+
-                                  MAPPING_PROC_SIZE*header->procs+
-                                  MAPPING_IRQ_SIZE*header->irqs
-                                    );
-
-    // computes the base address the array 
-    cp_port    = (mapping_coproc_port_t*)   ((char*)header +
-                                  MAPPING_HEADER_SIZE +
-                                  MAPPING_CLUSTER_SIZE*header->clusters +
-                                  MAPPING_PSEG_SIZE*header->psegs +
-                                  MAPPING_VSPACE_SIZE*header->vspaces +
-                                  MAPPING_VOBJ_SIZE*header->vobjs +
-                                  MAPPING_VSEG_SIZE*header->vsegs+
-                                  MAPPING_TASK_SIZE*header->tasks+
-                                  MAPPING_PROC_SIZE*header->procs+
-                                  MAPPING_IRQ_SIZE*header->irqs+
-                                  MAPPING_COPROC_SIZE*header->coprocs
-                                    );
-
-    // computes the base address the array 
-    cp_reg    = (mapping_coproc_reg_t*)   ((char*)header +
-                                  MAPPING_HEADER_SIZE +
-                                  MAPPING_CLUSTER_SIZE*header->clusters +
-                                  MAPPING_PSEG_SIZE*header->psegs +
-                                  MAPPING_VSPACE_SIZE*header->vspaces +
-                                  MAPPING_VOBJ_SIZE*header->vobjs +
-                                  MAPPING_VSEG_SIZE*header->vsegs+
-                                  MAPPING_TASK_SIZE*header->tasks+
-                                  MAPPING_PROC_SIZE*header->procs+
-                                  MAPPING_IRQ_SIZE*header->irqs+
-                                  MAPPING_COPROC_SIZE*header->coprocs+
-                                  MAPPING_CP_PORT_SIZE*header->cp_ports
-                                    );
+    // computes the base address for irqs array 
+    irq    = (mapping_irq_t*)    ((char*)header +
+                                  MAPPING_HEADER_SIZE +
+                                  MAPPING_CLUSTER_SIZE*header->clusters +
+                                  MAPPING_PSEG_SIZE*header->psegs +
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VOBJ_SIZE*header->vobjs +
+                                  MAPPING_VSEG_SIZE*header->vsegs +
+                                  MAPPING_TASK_SIZE*header->tasks +
+                                  MAPPING_PROC_SIZE*header->procs);
+
+    // computes the base address for coprocs array 
+    coproc = (mapping_coproc_t*)  ((char*)header +
+                                  MAPPING_HEADER_SIZE +
+                                  MAPPING_CLUSTER_SIZE*header->clusters +
+                                  MAPPING_PSEG_SIZE*header->psegs +
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VOBJ_SIZE*header->vobjs +
+                                  MAPPING_VSEG_SIZE*header->vsegs +
+                                  MAPPING_TASK_SIZE*header->tasks +
+                                  MAPPING_PROC_SIZE*header->procs +
+                                  MAPPING_IRQ_SIZE*header->irqs);
+
+    // computes the base address for cp_ports array 
+    cp_port = (mapping_cp_port_t*)((char*)header +
+                                  MAPPING_HEADER_SIZE +
+                                  MAPPING_CLUSTER_SIZE*header->clusters +
+                                  MAPPING_PSEG_SIZE*header->psegs +
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VOBJ_SIZE*header->vobjs +
+                                  MAPPING_VSEG_SIZE*header->vsegs +
+                                  MAPPING_TASK_SIZE*header->tasks +
+                                  MAPPING_PROC_SIZE*header->procs +
+                                  MAPPING_IRQ_SIZE*header->irqs +
+                                  MAPPING_COPROC_SIZE*header->coprocs);
+
+    // computes the base address for periphs array 
+    periph = (mapping_periph_t*)  ((char*)header +
+                                  MAPPING_HEADER_SIZE +
+                                  MAPPING_CLUSTER_SIZE*header->clusters +
+                                  MAPPING_PSEG_SIZE*header->psegs +
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VOBJ_SIZE*header->vobjs +
+                                  MAPPING_VSEG_SIZE*header->vsegs +
+                                  MAPPING_TASK_SIZE*header->tasks +
+                                  MAPPING_PROC_SIZE*header->procs +
+                                  MAPPING_IRQ_SIZE*header->irqs +
+                                  MAPPING_COPROC_SIZE*header->coprocs +
+                                  MAPPING_CP_PORT_SIZE*header->cp_ports);
+
+    ///////////////////////// header /////////////////////////////////////////////
 
     fprintf( fpout, "<?xml version = \"1.0\"?>\n\n");
-
-    ///////////////////////// header /////////////////////////////////////////////
 
     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, "              ttys      = \"%d\"\n", header->ttys);
-    fprintf( fpout, "              fbs       = \"%d\"\n", header->fbs);
     fprintf( fpout, "              vspaces   = \"%d\"\n", header->vspaces);
     fprintf( fpout, "              globals   = \"%d\" >\n\n", header->globals);
@@ -238 +239 @@
             fprintf( fpout, "                          length = \"0x%x\" />\n",   pseg[pseg_id].length);
         }
+
+    ///////////////////// processors /////////////////////////////////////////////
+
         for ( proc_id = cluster[cluster_id].proc_offset ; 
                 proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs ;
@@ -253 +257 @@
         }
 
+
+    ///////////////////// coprocessors ///////////////////////////////////////////
+
         for ( coproc_id = cluster[cluster_id].coproc_offset ; 
                 coproc_id < cluster[cluster_id].coproc_offset + cluster[cluster_id].coprocs ;
@@ -266 +273 @@
                 fprintf( fpout, "                                   vobjname     = \"%s\" />\n",  vobj[vobj_id].name);
             }
-            for ( reg_id = coproc[coproc_id].reg_offset ; 
-                    reg_id < coproc[coproc_id].reg_offset+coproc[coproc_id].regs ;
-                        reg_id++ )
-            {
-                fprintf( fpout, "                           <reg    name        = \"%s\"\n",        cp_reg[reg_id].name);
-                fprintf( fpout, "                                   type        = \"%s\"\n",        reg_type[cp_reg[reg_id].type]);
-                fprintf( fpout, "                                   value       = \"0x%x\"\n",      cp_reg[reg_id].value);
-                fprintf( fpout, "                                   channel     = \"0x%x\"\n",      cp_reg[reg_id].channel_id);
-                fprintf( fpout, "                                   index       = \"0x%x\" />\n",   cp_reg[reg_id].loc_id);
-            }
             fprintf( fpout, "                   </coproc>\n" );
+        }
+
+    ///////////////////// periphs  ///////////////////////////////////////////////
+
+        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);
         }
         fprintf( fpout, "        </cluster>\n" );
@@ -356 +364 @@
             fprintf( fpout, "                       startid   = \"%d\"\n",      task[task_id].startid);
             fprintf( fpout, "                       usetty    = \"%d\"\n",      task[task_id].use_tty);
-            fprintf( fpout, "                       usefb     = \"%d\" />\n\n", task[task_id].use_fb);
+            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, "        </vspace>\n\n");

soft/giet_vm/xml/xml_parser.c

@@ -20 +20 @@
 #include  <libxml/xmlreader.h>
 #include  <mapping_info.h>
+#include  <irq_handler.h>
 
 #define MAX_CLUSTERS    1024
@@ -32 +33 @@
 #define MAX_COPROCS             4096
 #define MAX_CP_PORTS    8192
-#define MAX_CP_REGS             8192
+#define MAX_PERIPHS             8192
 
 #define XML_PARSER_DEBUG        0
@@ -49 +50 @@
 mapping_proc_t*         proc[MAX_PROCS];                // proc array
 mapping_irq_t*          irq[MAX_IRQS];                  // irq array
-mapping_coproc_t*       coproc[MAX_COPROCS];            // coproc array
-mapping_coproc_port_t*  cp_port[MAX_CP_PORTS];  // coproc port array
-mapping_coproc_reg_t*   cp_reg[MAX_CP_REGS];     // coproc reg array
-
-typedef struct vobj_ref_s
-{
-    char vspace_name[32];
-    char vobj_name[32];
-}vobj_ref_t;
-
-// This arrray is useful to temporary save the a vobj referece 
-// formed by a vspace_name and a vobj_name (struct vobj_ref_s).
-// This arry will be used to set the attribute vobj_id of coproc_port
-// once all the vspace have been parsed.
-vobj_ref_t*                 cp_port_vobj_ref[MAX_CP_PORTS];     
+mapping_coproc_t*       coproc[MAX_COPROCS];    // coproc array
+mapping_cp_port_t*          cp_port[MAX_CP_PORTS];      // coproc port array
+mapping_periph_t*       periph[MAX_PERIPHS];    // peripheral array
+
+// Index for the various arrays
 
 unsigned int            cluster_index  = 0;
@@ -82 +73 @@
 unsigned int            cp_port_loc_index = 0;
 
-unsigned int            cp_reg_index     = 0;
-unsigned int            cp_reg_loc_index = 0;
+unsigned int            periph_index     = 0;
+unsigned int            periph_loc_index = 0;
 
 unsigned int            vseg_index     = 0;
 unsigned int            vseg_loc_index = 0;
+
 unsigned int            task_index     = 0;
 unsigned int            task_loc_index = 0;
+
 unsigned int            vobj_index     = 0;
 unsigned int            vobj_loc_index = 0;
 unsigned int            vobj_count     = 0;
 
-unsigned int            tty_index      = 1;
-unsigned int            fb_index       = 0;
-            
+///////////////////////////////////////////////////////////////////////
+// This arrray is useful to build a temporary list of vobj references. 
+// The struct vobj_ref_s is formed by a vspace_name and a vobj_name.
+// This array is used to set the attribute vobj_id of a cp_port
+// once all the vspace have been parsed.
+
+typedef struct vobj_ref_s
+{
+    char vspace_name[32];
+    char vobj_name[32];
+}vobj_ref_t;
+
+vobj_ref_t*             cp_port_vobj_ref[MAX_CP_PORTS]; 
+
+
 //////////////////////////////////////////////////
 unsigned int getIntValue( xmlTextReaderPtr reader, 
@@ -183 +188 @@
 ////////////////////////////////////////////
 int getVspaceId( char*         vspace_name)
-////////////////////////////////////////////
 {
     unsigned int vspace_id;
@@ -201 +205 @@
                   char*             vobj_name,
                   unsigned int  vspace_max)
-////////////////////////////////////////////
 {
     unsigned int vobj_id;
@@ -235 +238 @@
 #endif
 
-    cp_port[cp_port_index] = (mapping_coproc_port_t*)malloc(sizeof(mapping_coproc_port_t));
+    cp_port[cp_port_index] = (mapping_cp_port_t*)malloc(sizeof(mapping_cp_port_t));
     cp_port_vobj_ref[cp_port_index] = (vobj_ref_t*)malloc(sizeof(vobj_ref_t));
 
@@ -251 +254 @@
         else
         {
-            printf("[XML ERROR] illegal <direction> for coproc_port %d in cluster %d\n",
+            printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
                    cp_port_index, cluster_index);
             exit(1);
@@ -258 +261 @@
     else
     {
-        printf("[XML ERROR] missing <direction> for coproc_port %d in cluster %d\n",
+        printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
         exit(1);
@@ -274 +277 @@
     else
     {
-        printf("[XML ERROR] missing <vspacename> for coproc_port %d in cluster %d\n",
+        printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
         exit(1);
@@ -290 +293 @@
     else
     {
-        printf("[XML ERROR] missing <vobjname> for coproc_port %d in cluster %d\n",
+        printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
         exit(1);
@@ -300 +303 @@
 } // end cpPortNode()
 
-/////////////////////////////////////////
-void cpRegNode ( xmlTextReaderPtr reader )
-/////////////////////////////////////////
+///////////////////////////////////////////
+void periphNode ( xmlTextReaderPtr reader )
+///////////////////////////////////////////
 {
     char*           str;
     unsigned int    value;
-    unsigned int    ok;
+    unsigned int        ok;
 
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
 
-    /* TWO: check source file consistency if possible */
-    if ( cp_reg_index >= MAX_CP_REGS )
-    {
-        printf("[XML ERROR] The number of regs (for coprocs) is larger than %d\n", MAX_CP_REGS);
-    }
-
-#if XML_PARSER_DEBUG
-printf("\n  reg %d\n", cp_reg_index);
-#endif
-
-    /* THIRD*/
-    cp_reg[cp_reg_index] = (mapping_coproc_reg_t*)malloc(sizeof(mapping_coproc_reg_t));
-
-    /* FOURTH: read all attribute*/
-
-    /////////// get name attribute 
-    str = getStringValue( reader, "name", &ok );
-#if XML_PARSER_DEBUG
-printf("      name = %s\n", str);
-#endif
+    if ( periph_index >= MAX_PERIPHS )
+    {
+        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
+    }
+
+#if XML_PARSER_DEBUG
+printf("\n  periph %d\n", periph_index);
+#endif
+
+    periph[periph_index] = (mapping_periph_t*)malloc(sizeof(mapping_periph_t));
+
+    /////////// get type attribute 
+    str = getStringValue( reader, "type", &ok );
     if ( ok ) 
     {
-        strncpy(cp_reg[cp_reg_index]->name, str, 31);
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <name> for coproc_reg %d in cluster %d\n",
-               cp_reg_index, cluster_index);
-        exit(1);
-    }
+#if XML_PARSER_DEBUG
+printf("      type     = %s\n", str);
+#endif
+        unsigned int error = 0;
+  
+        // The TTY, IOC, NIC, FBF and IOB peripherals cannot be replicated
+        if      ( strcmp( str, "IOC" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_IOC;
+            if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
+            else  error = 1;
+        } 
+        else if ( strcmp( str, "TTY" ) == 0 )
+        {
+            periph[periph_index]->type = PERIPH_TYPE_TTY;
+            if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
+            else  error = 1;
+        }
+        else if ( strcmp( str, "FBF" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_FBF;
+            if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
+            else  error = 1;
+        }
+        else if ( strcmp( str, "NIC" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_NIC;
+            if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
+            else  error = 1;
+        }
+        // The TIM, DMA and IOB peripherals can be replicated in several clusters
+        else if ( strcmp( str, "TIM" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_TIM;
+        }
+        else if ( strcmp( str, "DMA" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_DMA;
+        }
+        else if ( strcmp( str, "IOB" ) == 0 ) 
+        {
+            periph[periph_index]->type = PERIPH_TYPE_IOB;
+        }
+        else
+        {
+            printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
+                   periph_loc_index, cluster_index);
+            exit(1);
+        }
+    }
+    else
+    {
+        printf("[XML ERROR] missing <type> for peripheral  %d in cluster %d\n",
+               periph_loc_index, cluster_index);
+        exit(1);
+    }
+
+    ///////// get channels attribute (optionnal : 1 if missing)
+    value = getIntValue( reader, "channels", &ok );
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      channels = %d\n", value);
+#endif
+        periph[periph_index]->channels = value;
+    }
+    else
+    {
+        periph[periph_index]->channels = 1;
+    }
+
+    /////////// get psegname attribute 
+    str = getStringValue(reader,"psegname", &ok);
+    if ( ok == 0 )
+    {
+        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
+                 coproc_index, cluster_index);
+        exit(1);
+    }
+
+    /////////// set psegid attribute
+    int index = getPsegId( cluster_index, str );
+    if ( index >= 0 ) 
+    {
+#if XML_PARSER_DEBUG
+printf("      clusterid = %d\n", cluster_index);
+printf("      psegname  = %s\n", str);
+printf("      psegid    = %d\n", index);
+#endif
+        periph[periph_index]->psegid = index;
+        assert(pseg[index]->type == PSEG_TYPE_PERI && 
+        "peripheral psegname attribute must refer to a pseg of type PERI" );
+    }
+    else              
+    {
+        printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n", 
+                   periph_loc_index, cluster_index, str );
+        exit(1);
+    }  
     
-    ///////// get type attribute
-    str = getStringValue( reader, "type", &ok );
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("      type = %s\n", str);
-#endif
-        if      ( strcmp(str, "STATUS")   ) cp_reg[cp_reg_index]->type = REG_TYPE_STATUS;
-        else if ( strcmp(str, "CONFIG")   ) cp_reg[cp_reg_index]->type = REG_TYPE_CONFIG;
-        else
-        {
-            printf("[XML ERROR] illegal <type> for coproc_reg %d in cluster %d\n",
-                   cp_reg_index, cluster_index);
-            exit(1);
-        }
-    }  
-    else
-    {
-        printf("[XML ERROR] missing <type> for coproc_reg %d in cluster %d\n",
-               cp_reg_index, cluster_index);
-        exit(1);
-    }
-
-    ///////// get value attribute
-    value = getIntValue(reader, "value", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("        value   = %d\n", value);
-#endif
-        cp_reg[cp_reg_index]->value = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <value> for coproc_reg %d in cluster %d\n",
-               cp_reg_index, cluster_index);
-        exit(1);
-    }
-
-    ///////// get channel attribute
-    value = getIntValue(reader, "channel", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("        channel   = %d\n", value);
-#endif
-        cp_reg[cp_reg_index]->channel_id = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <channel> for coproc_reg %d in cluster %d\n",
-               cp_reg_index, cluster_index);
-        exit(1);
-    }
-
-    ///////// get index attribute
-    value = getIntValue(reader, "index", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("        index   = %d\n", value);
-#endif
-        cp_reg[cp_reg_index]->loc_id = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <index> for coproc_reg %d in cluster %d\n",
-               cp_reg_index, cluster_index);
-        exit(1);
-    }
-    
-    cp_reg_index++;
-    cp_reg_loc_index++;
-
-} // end cpRegNode()
+    periph_index++;
+    periph_loc_index++;
+
+} // end periphNode
 
 /////////////////////////////////////////
@@ -425 +441 @@
 
     cp_port_loc_index = 0;
-    cp_reg_loc_index = 0;
 
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -439 +454 @@
 
     coproc[coproc_index] = (mapping_coproc_t*)malloc(sizeof(mapping_coproc_t));
-
 
     /////////// get name attribute 
@@ -485 +499 @@
     }  
 
-    ////////// set port_offset and reg_offset attribute
+    ////////// set port_offset 
     coproc[coproc_index]->port_offset = cp_port_index;
-    coproc[coproc_index]->reg_offset = cp_reg_index;
-
-#if XML_PARSER_DEBUG
-printf("    port_offset = %d\n", cp_port_index);
-printf("    reg_offset = %d\n", cp_reg_index);
+
+#if XML_PARSER_DEBUG
+printf("      port_offset = %d\n", cp_port_index);
 #endif
 
@@ -499 +511 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"port")    == 0 ) cpPortNode(reader);
-        else if ( strcmp(tag,"reg")   == 0 ) cpRegNode(reader);
-        else if ( strcmp(tag,"#text"  ) == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag,"coproc")  == 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 ) 
         {
             coproc[coproc_index]->ports = cp_port_loc_index;
-            coproc[coproc_index]->regs = cp_reg_loc_index;
             coproc_loc_index++;
             coproc_index++;
@@ -548 +558 @@
 printf("        type    = %s\n", str);
 #endif
-        if      ( strcmp(str, "HARD") ) irq[irq_index]->type = IRQ_TYPE_HARD;
-        else if ( strcmp(str, "SOFT") ) irq[irq_index]->type = IRQ_TYPE_SOFT;
+        if      ( strcmp(str, "HARD") == 0 ) irq[irq_index]->type = 0;
+        else if ( strcmp(str, "SOFT") == 0 ) irq[irq_index]->type = 1;
         else
         {
@@ -564 +574 @@
     }
 
-    ///////// get irqid attribute
+    ///////// get icuid attribute
     value = getIntValue(reader, "icuid", &ok);
     if ( ok )
@@ -593 +603 @@
 printf("        isr     = %s\n", str);
 #endif
-        if      ( strcmp(str, "ISR_SWITCH") ) irq[irq_index]->isr = ISR_SWITCH;
-        else if ( strcmp(str, "ISR_IOC")    ) irq[irq_index]->isr = ISR_IOC;
-        else if ( strcmp(str, "ISR_FBDMA")  ) irq[irq_index]->isr = ISR_FBDMA;
-        else if ( strcmp(str, "ISR_TTY")    ) irq[irq_index]->isr = ISR_TTY;
+        if      ( strcmp(str, "ISR_SWITCH" ) == 0 ) irq[irq_index]->isr = ISR_SWITCH;
+        else if ( strcmp(str, "ISR_IOC"    ) == 0 ) irq[irq_index]->isr = ISR_IOC;
+        else if ( strcmp(str, "ISR_DMA"    ) == 0 ) irq[irq_index]->isr = ISR_DMA;
+        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
         {
@@ -603 +614 @@
             exit(1);
         }
+#if XML_PARSER_DEBUG
+printf("        isrnum  = %d\n", irq[irq_index]->isr);
+#endif
     }  
     else
@@ -664 +678 @@
     ////////// set irq_offset attribute
     proc[proc_index]->irq_offset = irq_index;
+
 #if XML_PARSER_DEBUG
 printf("    irq_offset = %d\n", irq_index);
@@ -673 +688 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        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 ) 
+        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 ) 
         {
             proc[proc_index]->irqs = irq_loc_index;
@@ -817 +832 @@
     }
 
-    /////////// get use_tty  attribute (optionnal : 0 if missing)
+    /////////// get usetty  attribute (optionnal : 0 if missing)
     value = getIntValue(reader,"usetty", &ok);
     if ( ok )
@@ -824 +839 @@
 printf("      usetty = %x\n", value);
 #endif
-        if ( (value != 0) && (tty_index >= header->ttys) )
-        {
-            printf("[XML ERROR] The tty index is too large for task (%d,%d)\n", 
-                vspace_index, task_loc_index);
-            exit(1);
-        }
         task[task_index]->use_tty = value;
-        if (value != 0) tty_index++;
     }  
     else
@@ -838 +846 @@
     }
 
-    /////////// get use_fb  attribute (optionnal : 0 if missing)
-    value = getIntValue(reader,"usefb", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("      usefb = %x\n", value);
-#endif
-        if ( (value != 0) && (fb_index >= header->fbs) )
-        {
-            printf("[XML ERROR] The fb channel index is too large for task (%d,%d)\n", 
-                vspace_index, task_loc_index);
-            exit(1);
-        }
-        task[task_index]->use_fb = value;
-        if (value != 0) fb_index++;
+    /////////// get usenic  attribute (optionnal : 0 if missing)
+    value = getIntValue(reader,"usenic", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      usenic = %x\n", value);
+#endif
+        task[task_index]->use_nic = value;
     }  
     else
     {
-        task[task_index]->use_fb = 0;
+        task[task_index]->use_nic = 0;
+    }
+
+    /////////// get usetimer attribute (optionnal : 0 if missing)
+    value = getIntValue(reader,"usetimer", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      usetimer = %x\n", value);
+#endif
+        task[task_index]->use_timer = value;
+    }  
+    else
+    {
+        task[task_index]->use_timer = 0;
+    }
+
+    /////////// get usefbdma  attribute (optionnal : 0 if missing)
+    value = getIntValue(reader,"usefbdma", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      usefbdma = %x\n", value);
+#endif
+        task[task_index]->use_fbdma = value;
+    }  
+    else
+    {
+        task[task_index]->use_fbdma = 0;
     }
 
@@ -865 +894 @@
 //////////////////////////////////////////
 void  vobjNode ( xmlTextReaderPtr reader )
+//////////////////////////////////////////
 {
     unsigned int        ok;
@@ -986 +1016 @@
     else
     {
-        if((vobj[vobj_index]->type == VOBJ_TYPE_MWMR || vobj[vobj_index]->type == VOBJ_TYPE_BARRIER ))
+        if( (vobj[vobj_index]->type == VOBJ_TYPE_MWMR) || 
+            (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) )
         {
             printf("[XML ERROR] illegal or missing <value> attribute for vobj (%d,%d). \
@@ -1003 +1034 @@
 //////////////////////////////////////////
 void  vsegNode ( xmlTextReaderPtr reader )
+//////////////////////////////////////////
 {
     unsigned int        ok;
@@ -1144 +1176 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"vobj")    == 0 ) vobjNode(reader);
-        else if ( strcmp(tag,"#text"  ) == 0 ) { }
-        else if ( strcmp(tag,"vseg")    == 0 ) 
+        if      ( strcmp(tag, "vobj")     == 0 ) vobjNode(reader);
+        else if ( strcmp(tag, "#text"  )  == 0 ) { }
+        else if ( strcmp(tag, "#comment") == 0 ) { }
+        else if ( strcmp(tag, "vseg")     == 0 ) 
         {
             vseg[vseg_index]->vobjs = vobj_count;
@@ -1164 +1197 @@
 //////////////////////////////////////////
 void vspaceNode( xmlTextReaderPtr reader )
+//////////////////////////////////////////
 {
     char*               str;
@@ -1233 +1267 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"vseg")    == 0 ) vsegNode(reader);
-        else if ( strcmp(tag,"task")    == 0 ) taskNode(reader);
-        else if ( strcmp(tag,"#text")   == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag,"vspace")  == 0 ) 
+        if      ( strcmp(tag, "vseg")     == 0 ) vsegNode(reader);
+        else if ( strcmp(tag, "task")     == 0 ) taskNode(reader);
+        else if ( strcmp(tag, "#text")    == 0 ) { }
+        else if ( strcmp(tag, "#comment") == 0 ) { }
+        else if ( strcmp(tag, "vspace")   == 0 ) 
         {
             vspace[vspace_index]->vobjs = vobj_loc_index; 
@@ -1288 +1322 @@
 //////////////////////////////////////////
 void  psegNode ( xmlTextReaderPtr reader )
+//////////////////////////////////////////
 {
     unsigned int        ok;
@@ -1379 +1414 @@
 /////////////////////////////////////////////
 void  clusterNode ( xmlTextReaderPtr reader )
+/////////////////////////////////////////////
 {
     unsigned int ok;
@@ -1385 +1421 @@
     proc_loc_index = 0;
     coproc_loc_index = 0;
-    cluster[cluster_index] = 0;
+    periph_loc_index = 0;
 
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -1402 +1438 @@
     cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
 
-    /////////// get index attribute (optional)
+    /////////// check cluster index attribute (optional)
     value = getIntValue(reader,"index",&ok);
     if ( ok && (value != cluster_index) )
@@ -1411 +1447 @@
     }
 
-
-    ////////// set pseg_offset attribute
-    cluster[cluster_index]->pseg_offset = pseg_index;
-    cluster[cluster_index]->proc_offset = proc_index;
+    ////////// set offsets
+    cluster[cluster_index]->pseg_offset   = pseg_index;
+    cluster[cluster_index]->proc_offset   = proc_index;
     cluster[cluster_index]->coproc_offset = coproc_index;
-#if XML_PARSER_DEBUG
-printf("    pseg_offset = %d\n", pseg_index);
-printf("    proc_offset = %d\n", proc_index);
+    cluster[cluster_index]->periph_offset = periph_index;
+
+#if XML_PARSER_DEBUG
+printf("    pseg_offset   = %d\n", pseg_index);
+printf("    proc_offset   = %d\n", proc_index);
 printf("    coproc_offset = %d\n", coproc_index);
-#endif
-
-    ////////// get psegs, coproc and/or procs
+printf("    periph_offset = %d\n", coproc_index);
+#endif
+
+    ////////// get psegs, procs, coprocs and periphs
     int status = xmlTextReaderRead(reader);
 
@@ -1429 +1467 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag, "pseg")    == 0 ) psegNode(reader);
-        else if ( strcmp(tag, "proc")    == 0 ) procNode(reader);
-        else if ( strcmp(tag, "coproc")    == 0 ) coprocNode(reader);
-        else if ( strcmp(tag, "#text")   == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag, "cluster") == 0 ) 
-        {
-#if XML_PARSER_DEBUG
+        if      ( strcmp(tag, "pseg")     == 0 ) psegNode(reader);
+        else if ( strcmp(tag, "proc")     == 0 ) procNode(reader);
+        else if ( strcmp(tag, "coproc")   == 0 ) coprocNode(reader);
+        else if ( strcmp(tag, "periph")   == 0 ) periphNode(reader);
+        else if ( strcmp(tag, "#text")    == 0 ) { }
+        else if ( strcmp(tag, "#comment") == 0 ) { }
+        else if ( strcmp(tag, "cluster")  == 0 ) 
+        {
+            cluster[cluster_index]->procs   = proc_loc_index;
+            cluster[cluster_index]->coprocs = coproc_loc_index;
+            cluster[cluster_index]->periphs = periph_loc_index;
+
+            // cluster[cluster_index]psegs update is done in psegNode(),
+            // because the coprocNode() call to getPsegId() need it
+
+#if XML_PARSER_DEBUG
+printf("    psegs   = %d\n", cluster[cluster_index]->psegs);
+printf("    procs   = %d\n", cluster[cluster_index]->procs);
+printf("    coprocs = %d\n", cluster[cluster_index]->coprocs);
+printf("    periphs = %d\n", cluster[cluster_index]->periphs);
 printf("  end cluster %d\n", cluster_index);
 #endif
-            cluster[cluster_index]->procs = proc_loc_index;
-            cluster[cluster_index]->coprocs = coproc_loc_index;
-            //psegs = pseg_loc_index is done in psegNode(), so coprocNode() call to getPsegId() success
             cluster_index++;
             return;
@@ -1451 +1498 @@
 //////////////////////////////////////////////
 void clusterSetNode( xmlTextReaderPtr reader )
+//////////////////////////////////////////////
 {
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -1463 +1511 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"cluster") == 0 ) clusterNode(reader);
-        else if ( strcmp(tag,"#text") == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag,"clusterset") == 0 ) 
+        if      ( strcmp(tag, "cluster")    == 0 ) clusterNode(reader);
+        else if ( strcmp(tag, "#text")      == 0 ) { }
+        else if ( strcmp(tag, "#comment")   == 0 ) { }
+        else if ( strcmp(tag, "clusterset") == 0 ) 
         {
             // checking source file consistency
@@ -1479 +1527 @@
 printf("  end cluster set\n\n");
 #endif
-                header->psegs = pseg_index;
-                header->procs = proc_index;
-                header->irqs  = irq_index;
-                header->coprocs = coproc_index;
+                header->psegs    = pseg_index;
+                header->procs    = proc_index;
+                header->irqs     = irq_index;
+                header->coprocs  = coproc_index;
                 header->cp_ports = cp_port_index;
-                header->cp_regs = cp_reg_index;
                 return;
             }
@@ -1499 +1546 @@
 /////////////////////////////////////////////
 void globalSetNode( xmlTextReaderPtr reader )
+/////////////////////////////////////////////
 {
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -1511 +1559 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"vseg") == 0    ) vsegNode(reader);
-        else if ( strcmp(tag,"#text"  ) == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag,"globalset") == 0  ) 
+        if      ( strcmp(tag, "vseg")      == 0 ) vsegNode(reader);
+        else if ( strcmp(tag, "#text"  )   == 0 ) { }
+        else if ( strcmp(tag, "#comment")  == 0 ) { }
+        else if ( strcmp(tag, "globalset") == 0 ) 
         {
             // checking source file consistency
@@ -1542 +1590 @@
 /////////////////////////////////////////////
 void vspaceSetNode( xmlTextReaderPtr reader )
+/////////////////////////////////////////////
 {
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -1554 +1603 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"vspace") == 0    ) vspaceNode(reader);
-        else if ( strcmp(tag,"#text"  ) == 0 ) { }
-        else if ( strcmp(tag,"#comment") == 0 );
-        else if ( strcmp(tag,"vspaceset") == 0  ) 
+        if      ( strcmp(tag, "vspace"   ) == 0 ) vspaceNode(reader);
+        else if ( strcmp(tag, "#text"    ) == 0 ) { }
+        else if ( strcmp(tag, "#comment" ) == 0 ) { }
+        else if ( strcmp(tag, "vspaceset") == 0 ) 
         {
             // checking source file consistency
@@ -1584 +1633 @@
 //////////////////////////////////////////
 void headerNode(xmlTextReaderPtr reader )
+//////////////////////////////////////////
 {
     char*               name;
@@ -1632 +1682 @@
     }
 
-    ///////// get ttys attribute
-    value = getIntValue(reader, "ttys", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("  ttys = %d\n", value);
-#endif
-        header->ttys  = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <ttys> attribute in header\n");
-        exit(1);
-    }
-
-    ///////// get fbs attribute
-    value = getIntValue(reader, "fbs", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("  fbs = %d\n", value);
-#endif
-        header->fbs  = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <fbs> attribute in header\n");
-        exit(1);
-    }
-
     ///////// get vspaces attribute
     value = getIntValue(reader, "vspaces", &ok);
@@ -1702 +1722 @@
     }
 
+    //////// initialise non replicated peripherals cluster_id
+    header->tty_clusterid = 0xFFFFFFFF;
+    header->nic_clusterid = 0xFFFFFFFF;
+    header->ioc_clusterid = 0xFFFFFFFF;
+    header->fbf_clusterid = 0xFFFFFFFF;
+
+    ///////// set signature
     header->signature = IN_MAPPING_SIGNATURE;
 
@@ -1709 +1736 @@
         const char* tag = (const char*)xmlTextReaderConstName(reader);
 
-        if      ( strcmp(tag,"clusterset")   == 0 ) clusterSetNode(reader);
-        else if ( strcmp(tag,"globalset")    == 0 ) globalSetNode(reader);
-        else if ( strcmp(tag,"vspaceset")    == 0 ) vspaceSetNode(reader);
-        else if ( strcmp(tag,"#text")        == 0 ) ;
-        else if ( strcmp(tag,"#comment")     == 0 ) ;
-        else if ( strcmp(tag,"mapping_info") == 0 ) 
+        if      ( strcmp(tag, "clusterset")   == 0 ) clusterSetNode(reader);
+        else if ( strcmp(tag, "globalset")    == 0 ) globalSetNode(reader);
+        else if ( strcmp(tag, "vspaceset")    == 0 ) vspaceSetNode(reader);
+        else if ( strcmp(tag, "#text")        == 0 ) { }
+        else if ( strcmp(tag, "#comment")     == 0 ) { }
+        else if ( strcmp(tag, "mapping_info") == 0 ) 
         {
 #if XML_PARSER_DEBUG
@@ -1730 +1757 @@
 } // end headerNode()
     
+///////////////////////////////////////
 void BuildTable( int fdout,
                const char* type,
@@ -1735 +1763 @@
                unsigned int elem_size,
                char** table)        
+////////////////////////////////////////
 {
     unsigned int i;
@@ -1758 +1787 @@
 ///////////////////////////
 void  buildBin( int fdout )
+///////////////////////////
 {
     unsigned int    vspace_id;
@@ -1823 +1853 @@
     }
 
-    // write tasks
+    // write tasks array
     BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char**) task);
-    //building proc
+    //building procs array
     BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char**) proc);
-    //building irq
+    //building irqs array
     BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char**)irq);
-    //building coproc
+    //building coprocs array
     BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char**)coproc);
-    //building cp_port
-    BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_coproc_port_t),(char**) cp_port);
-    //building cp_reg
-    BuildTable(fdout, "cp_reg", cp_reg_index, sizeof(mapping_coproc_reg_t), (char**)cp_reg);
+    //building cp_ports array
+    BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_cp_port_t),(char**) cp_port);
+    //building periphs array
+    BuildTable(fdout, "periph", periph_index, sizeof(mapping_periph_t), (char**)periph);
 
 } // end buildBin()
 
-/////////////////////////////////////////
-// this function set the value of vobj_id 
-// of the coproc_ports.
-///////////////////
+///////////////////////////////////////////////////////////////////////
+// this function set the value the vobj_id fiels of all cp_ports
+///////////////////////////////////////////////////////////////////////
 void prepareBuild()
 {
@@ -1850 +1879 @@
         if ( vspace_id < 0 ) 
         {
-            printf("[XML ERROR] illegal  <vspacename> for coproc_port %d,\n", 
+            printf("[XML ERROR] illegal  <vspacename> for cp_port %d,\n", 
                     i);
             exit(1);
@@ -1856 +1885 @@
         cp_port[i]->vspaceid = vspace_id;
         
-        int vobj_id = getVobjLocId( vspace_id, cp_port_vobj_ref[i]->vobj_name, vspace[vspace_id]->vobjs );
+        int vobj_id = getVobjLocId( vspace_id, 
+                                    cp_port_vobj_ref[i]->vobj_name, 
+                                    vspace[vspace_id]->vobjs );
         if ( vobj_id >= 0 ) 
         {
-#if XML_PARSER_DEBUG
-printf("coproc_port = %d\n", i);
+
+#if XML_PARSER_DEBUG
+printf("\ncp_port = %d\n", i);
 printf("      vspace_name  = %s\n", cp_port_vobj_ref[i]->vspace_name);
 printf("      vobj_name    = %s\n", cp_port_vobj_ref[i]->vobj_name);
@@ -1866 +1898 @@
 #endif
             cp_port[i]->vobjlocid = vobj_id;
-            assert((vobj[ vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR) && "coproc ports has to refere to a vobj of type MWMR");
+
+            assert((vobj[ vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR)
+            && "coproc ports has to refere to a vobj of type MWMR");
         }
         else              
         {
-            printf("[XML ERROR] illegal  <vobjname> for coproc_port %d,\n", 
+            printf("[XML ERROR] illegal  <vobjname> for cp_port %d,\n", 
                     i);
             exit(1);
         }
-        
     }
 }
@@ -1880 +1913 @@
 /////////////////////////////////////
 int  main ( int argc, char* argv[] )
+/////////////////////////////////////
 {
     if ( argc < 3 ) 
@@ -1913 +1947 @@
             }
             else
-            if ( strcmp(tag,"#comment") == 0 );// a way to skips comment
-            else
             {
                 printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);