Ignore:
Timestamp:
May 29, 2013, 1:24:09 AM (11 years ago)
Author:
alain
Message:

Major evolution to support physical addresses larger than 32 bits.
The map.xml format has been modified: the vsegs associated to schedulers
are now explicitely defined and mapped in the page tables.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/xml/xml_parser.c

    r232 r238  
    4949///////////////////////////////////////////////////////////////////////////////////
    5050
    51 mapping_header_t * header;
    52 mapping_cluster_t * cluster[MAX_CLUSTERS];  // cluster array
    53 mapping_pseg_t * pseg[MAX_PSEGS];           // pseg array
    54 mapping_vspace_t * vspace[MAX_VSPACES];     // vspace array
    55 mapping_vseg_t * vseg[MAX_VSEGS];           // vseg array
    56 mapping_vobj_t * vobj[MAX_VOBJS];           // vobj array
    57 mapping_task_t * task[MAX_TASKS];           // task array
    58 mapping_proc_t * proc[MAX_PROCS];           // proc array
    59 mapping_irq_t * irq[MAX_IRQS];              // irq array
    60 mapping_coproc_t * coproc[MAX_COPROCS];     // coproc array
    61 mapping_cp_port_t * cp_port[MAX_CP_PORTS];  // coproc port array
    62 mapping_periph_t * periph[MAX_PERIPHS];     // peripheral array
     51mapping_header_t *   header;
     52mapping_cluster_t *  cluster[MAX_CLUSTERS];  // cluster array
     53mapping_pseg_t *     pseg[MAX_PSEGS];        // pseg array
     54mapping_vspace_t *   vspace[MAX_VSPACES];    // vspace array
     55mapping_vseg_t *     vseg[MAX_VSEGS];        // vseg array
     56mapping_vobj_t *     vobj[MAX_VOBJS];        // vobj array
     57mapping_task_t *     task[MAX_TASKS];        // task array
     58mapping_proc_t *     proc[MAX_PROCS];        // proc array
     59mapping_irq_t *      irq[MAX_IRQS];          // irq array
     60mapping_coproc_t *   coproc[MAX_COPROCS];    // coproc array
     61mapping_cp_port_t *  cp_port[MAX_CP_PORTS];  // coproc port array
     62mapping_periph_t *   periph[MAX_PERIPHS];    // peripheral array
    6363
    6464// Index for the various arrays
    … …  
    9595
    9696
    97 /////////////////////////
    98 // found peripheral
    99 /////////////////////////
     97//////////////////////////////
     98// for replicated peripheral
     99//////////////////////////////
    100100char found_timer = 0;
    101101char found_icu = 0;
    102 char found_xicu = 0;
    103102char found_dma = 0;
    104103
    105104
    106 //////////////////////////////////
    107 //needed to generate map_config.ld
    108 //////////////////////////////////
    109 unsigned int cluster_y            = 0;
    110 unsigned int cluster_x            = 0;
    111 unsigned int nb_proc_max          = 0; // max number of processors per cluste
    112 
    113 unsigned int nb_tasks_max         = 0; // max number of tasks (for all vspaces)
    114 unsigned int nb_timer_channel_max = 0; // max number of user timer
    115 unsigned int nb_dma_channel_max   = 0;
    116 unsigned int nb_tty_channel       = 0;
    117 unsigned int nb_ioc_channel       = 0;
    118 unsigned int nb_nic_channel       = 0;
    119 unsigned int io_mmu_active        = 0;
    120 unsigned int use_xicu             = 0xFFFFFFFF;
    121 
    122 
    123 //////////////////////////////////
    124 //needed to generate giet_vseg.ld
    125 //////////////////////////////////
    126 
    127 //kernel and boot code
    128 unsigned int kernel_code_base    = 0x80000000; /* kernel code */
    129 unsigned int kernel_data_base    = 0x80010000; /* system cacheable data */
    130 unsigned int kernel_uncdata_base = 0x80080000; /* system uncacheable data */
    131 unsigned int kernel_init_base    = 0x80090000; /* system init entry */
    132 
    133 unsigned int boot_code_base      = 0xBFC00000; /* boot code */
    134 unsigned int boot_stack_base     = 0xBFC08000; /* boot temporary stack */
    135 unsigned int boot_mapping_base   = 0xBFC0C000; /* mapping_info blob */
    136 
    137 //periphs
    138 unsigned int tim_base_offset = 0xFFFFFFFF;
    139 unsigned int tty_base_offset = 0xFFFFFFFF;
    140 unsigned int dma_base_offset = 0xFFFFFFFF;
    141 unsigned int ioc_base_offset = 0xFFFFFFFF;
    142 unsigned int nic_base_offset = 0xFFFFFFFF;
    143 unsigned int fbf_base_offset = 0xFFFFFFFF;
    144 unsigned int icu_base_offset = 0xFFFFFFFF;
    145 unsigned int gcd_base_offset = 0xFFFFFFFF;
    146 unsigned int iob_base_offset = 0xFFFFFFFF;
    147 
     105////////////////////////////////////////////////////////////////////
     106// These variables are used to generate the hard_config.h file
     107////////////////////////////////////////////////////////////////////
     108
     109unsigned int cluster_y        = 0; // number of clusters in a column
     110unsigned int cluster_x        = 0; // number of clusters in a row
     111unsigned int nb_proc_max      = 0; // max number of processors per cluster
     112unsigned int nb_tasks_max     = 0; // max number of tasks (for all vspaces)
     113
     114unsigned int tim_channels     = 0; // max number of user timers per cluster
     115unsigned int dma_channels     = 0; // max number of DMA channels per cluster
     116
     117unsigned int tty_channels     = 0; // total number of terminals in first TTY
     118unsigned int ioc_channels     = 0; // total number of channels in first IOC
     119unsigned int nic_channels     = 0; // total number of channels in first NIC
     120unsigned int cma_channels     = 0; // total number of channels in first CMA
     121
     122unsigned int io_mmu_active    = 0; // using IOB component
     123unsigned int use_xicu         = 0; // using XICU (not ICU)
     124
     125
     126////////////////////////////////////////////////////////////////
     127// These variables are used to generate the giet_vseg.ld file
     128////////////////////////////////////////////////////////////////
     129
     130unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE]
     131         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };
    148132
    149133//////////////////////////////////////////////////////////////////////
    … …  
    153137// once all the vspace have been parsed.
    154138/////////////////////////////////////////////////////////////////////
    155 typedef struct vobj_ref_s {
     139typedef struct vobj_ref_s
     140{
    156141    char vspace_name[32];
    157142    char vobj_name[32];
    … …  
    162147
    163148//////////////////////////////////////////////////
    164 unsigned int getIntValue(xmlTextReaderPtr reader, const char * attributeName, unsigned int * ok) {
     149unsigned int getIntValue( xmlTextReaderPtr reader,
     150                          const char * attributeName,
     151                          unsigned int * ok)
     152{
    165153    unsigned int value = 0;
    166154    unsigned int i;
    167155    char c;
    168156
    169     char * string = (char *) xmlTextReaderGetAttribute(reader, (const xmlChar *) attributeName);
    170 
    171     if (string == NULL) {
     157    char * string = (char *) xmlTextReaderGetAttribute(reader,
     158                                (const xmlChar *) attributeName);
     159
     160    if (string == NULL)
     161    {
    172162        // missing argument
    173163        *ok = 0;
    174164        return 0;
    175165    }
    176     else {
    177         if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) {
     166    else
     167    {
     168        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
     169        {
    178170            // Hexa
    179             for (i = 2 ; (string[i] != 0) && (i < 10) ; i++) {
     171            for (i = 2 ; (string[i] != 0) && (i < 10) ; i++)
     172            {
    180173                c = string[i];
    181174                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
    182175                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
    183176                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
    184                 else {
     177                else
     178                {
    185179                    *ok = 0;
    186180                    return 0;
    … …  
    188182            }
    189183        }
    190         else {
     184        else
     185        {
    191186            // Decimal
    192             for (i = 0; (string[i] != 0) && (i < 9); i++) {
     187            for (i = 0; (string[i] != 0) && (i < 9); i++)
     188            {
    193189                c = string[i];
    194190                if ((c >= '0') && (c <= '9')) value = (value * 10) + string[i] - 48;
    195                 else {
     191                else
     192                {
    196193                    *ok = 0;
    197194                    return 0;
    … …  
    204201} // end getIntValue()
    205202
    206 
    207 ///////////////////////////////////////////////
    208 char * getStringValue(xmlTextReaderPtr reader, const char * attributeName, unsigned int * ok) {
    209     char * string = (char *) xmlTextReaderGetAttribute(reader, (const xmlChar *) attributeName);
    210 
    211 
    212     if (string == NULL) {
     203////////////////////////////////////////////////
     204paddr_t getPaddrValue( xmlTextReaderPtr reader,
     205                       const char * attributeName,
     206                       unsigned int * ok)
     207{
     208    paddr_t value = 0;
     209    unsigned int i;
     210    char c;
     211
     212    char * string = (char *) xmlTextReaderGetAttribute(reader,
     213                                (const xmlChar *) attributeName);
     214
     215    if (string == NULL)
     216    {
     217        // missing argument
     218        *ok = 0;
     219        return 0;
     220    }
     221    else
     222    {
     223        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
     224        {
     225            // Hexa
     226            for (i = 2 ; (string[i] != 0) && (i < 18) ; i++)
     227            {
     228                c = string[i];
     229                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
     230                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
     231                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
     232                else
     233                {
     234                    *ok = 0;
     235                    return 0;
     236                }
     237            }
     238        }
     239        else
     240        {
     241            // Decimal not supported for paddr_t
     242            *ok = 0;
     243            return 0;
     244        }
     245        *ok = 1;
     246        return value;
     247    }
     248} // end getPaddrValue()
     249
     250////////////////////////////////////////////////
     251char * getStringValue( xmlTextReaderPtr reader,
     252                       const char * attributeName,
     253                       unsigned int * ok )
     254{
     255    char * string = (char *) xmlTextReaderGetAttribute(reader,
     256                               (const xmlChar *) attributeName);
     257
     258
     259    if (string == NULL)
     260    {
    213261        // missing argument
    214262        *ok = 0;
    215263        return NULL;
    216264    }
    217     else {
     265    else
     266    {
    218267        //we read only string smaller than 32 byte
    219         if (strlen(string) > 32) {
     268        if (strlen(string) > 32)
     269        {
    220270            printf("[XML ERROR] all strings must be less than 32 bytes\n");
    221271            exit(1);
    … …  
    227277} // end getStringValue()
    228278
    229 
    230 ///////////////////////////////////////
    231 int getPsegId(unsigned int cluster_id, char * pseg_name) {
     279///////////////////////////////////////////////////////
     280void set_periph_vbase_array( unsigned int vseg_index )
     281{
     282    unsigned int vbase  = vseg[vseg_index]->vbase;  // peripheral vbase address
     283    unsigned int psegid = vseg[vseg_index]->psegid; // pseg global index
     284    unsigned int type;                              // peripheral type
     285    unsigned int periph_id;
     286
     287    for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
     288    {
     289        if( periph[periph_id]->psegid == psegid )
     290        {
     291            type = periph[periph_id]->type;
     292            if ( periph_vbase_array[type] == 0xFFFFFFFF )
     293                 periph_vbase_array[type] = vbase;   
     294        }
     295    }
     296}  // end set_periph_vbase_array()
     297
     298////////////////////////////////////////////////////////
     299int getPsegId(unsigned int cluster_id, char * pseg_name)
     300{
    232301    unsigned int pseg_id;
    233302    unsigned int pseg_min = cluster[cluster_id]->pseg_offset;
    234303    unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs;
    235304
    236     for (pseg_id = pseg_min; pseg_id < pseg_max; pseg_id++) {
    237         if (strcmp(pseg[pseg_id]->name, pseg_name) == 0) {
     305    for (pseg_id = pseg_min; pseg_id < pseg_max; pseg_id++)
     306    {
     307        if (strcmp(pseg[pseg_id]->name, pseg_name) == 0)
     308        {
    238309            return pseg_id;
    239310        }
    … …  
    242313}
    243314
    244 
    245 ////////////////////////////////////////////
    246 int getVspaceId(char * vspace_name) {
     315///////////////////////////////////
     316int getVspaceId(char * vspace_name)
     317{
    247318    unsigned int vspace_id;
    248319
    249     for (vspace_id = 0; vspace_id < vspace_index; vspace_id++) {
    250         if (!strcmp(vspace[vspace_id]->name, vspace_name)) {
     320    for (vspace_id = 0; vspace_id < vspace_index; vspace_id++)
     321    {
     322        if (strcmp(vspace[vspace_id]->name, vspace_name) == 0)
     323        {
    251324            return vspace_id;
    252325        }
    … …  
    255328}
    256329
    257 
    258 ////////////////////////////////////////////
    259 int getVobjLocId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max) {
     330///////////////////////////////////////////////////////////////////////////////////
     331int getVobjLocId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max)
     332{
    260333    unsigned int vobj_id;
    261334    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
    … …  
    272345
    273346/////////////////////////////////////////
    274 void taskNode(xmlTextReaderPtr reader) {
     347void taskNode(xmlTextReaderPtr reader)
     348{
    275349    unsigned int ok;
    276350    unsigned int value;
    277351    char * str;
    278352
    279     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    280         return;
    281     }
    282 
    283     if (task_index >= MAX_TASKS) {
     353    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     354
     355    if (task_index >= MAX_TASKS)
     356    {
    284357        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
    285358    }
    286359
    287360#if XML_PARSER_DEBUG
    288     printf("   task %d\n", task_loc_index);
     361printf("   task %d\n", task_loc_index);
    289362#endif
    290363
    … …  
    293366    ////////// get name attribute
    294367    str = getStringValue(reader, "name", &ok);
    295     if (ok) {
    296 #if XML_PARSER_DEBUG
    297         printf("      name = %s\n", str);
     368    if (ok)
     369    {
     370#if XML_PARSER_DEBUG
     371printf("      name = %s\n", str);
    298372#endif
    299373        strncpy( task[task_index]->name, str, 31 );
    300374    }
    301     else {
     375    else
     376    {
    302377        printf("[XML ERROR] illegal or missing <name> attribute for task (%d,%d)\n",
    303378                vspace_index, task_loc_index);
    … …  
    307382    ///////// get clusterid attribute
    308383    value = getIntValue(reader, "clusterid", &ok);
    309     if (ok) {
    310 #if XML_PARSER_DEBUG
    311         printf("      clusterid = %x\n", value);
    312 #endif
    313         if (value >= header->clusters) {
     384    if (ok)
     385    {
     386#if XML_PARSER_DEBUG
     387printf("      clusterid = %x\n", value);
     388#endif
     389        if (value >= header->clusters)
     390        {
    314391            printf("[XML ERROR] <clusterid> too large for task (%d,%d)\n",
    315392                    vspace_index, task_loc_index);
    … …  
    318395        task[task_index]->clusterid = value;
    319396    } 
    320     else {
     397    else
     398    {
    321399        printf("[XML ERROR] illegal or missing <clusterid> attribute for task (%d,%d)\n",
    322400                vspace_index, task_loc_index);
    … …  
    326404    ////////// get proclocid attribute
    327405    value = getIntValue(reader, "proclocid", &ok);
    328     if (ok) {
    329 #if XML_PARSER_DEBUG
    330         printf("      proclocid = %x\n", value);
    331 #endif
    332         if (value >= cluster[task[task_index]->clusterid]->procs) {
     406    if (ok)
     407    {
     408#if XML_PARSER_DEBUG
     409printf("      proclocid = %x\n", value);
     410#endif
     411        if (value >= cluster[task[task_index]->clusterid]->procs)
     412        {
    333413            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
    334414                    vspace_index, task_loc_index);
    … …  
    337417        task[task_index]->proclocid = value;
    338418    } 
    339     else {
     419    else
     420    {
    340421        printf("[XML ERROR] illegal or missing <locprocid> attribute for task (%d,%d)\n",
    341422                vspace_index, task_loc_index);
    … …  
    345426    ////////// get stackname attribute
    346427    str = getStringValue(reader, "stackname" , &ok);
    347     if (ok) {
     428    if (ok)
     429    {
    348430        int index = getVobjLocId(vspace_index, str , vobj_loc_index);
    349         if (index >= 0) {
    350 #if XML_PARSER_DEBUG
    351             printf("      stackname = %s\n", str);
    352             printf("      stackid   = %d\n", index);
     431        if (index >= 0)
     432        {
     433#if XML_PARSER_DEBUG
     434printf("      stackname = %s\n", str);
     435printf("      stackid   = %d\n", index);
    353436#endif
    354437            task[task_index]->stack_vobjid = index;
    355438        }
    356         else {
     439        else
     440        {
    357441            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n",
    358442                    vspace_index, task_loc_index);
    … …  
    360444        }
    361445    } 
    362     else {
     446    else
     447    {
    363448        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n",
    364449                vspace_index, task_loc_index);
    … …  
    368453    ////////// get heap attribute
    369454    str = getStringValue(reader, "heapname", &ok);
    370     if (ok) {
     455    if (ok)
     456    {
    371457        int index = getVobjLocId(vspace_index, str, vobj_loc_index);
    372         if (index >= 0) {
    373 #if XML_PARSER_DEBUG
    374             printf("      heapname = %s\n", str);
    375             printf("      heapid   = %d\n", index);
     458        if (index >= 0)
     459        {
     460#if XML_PARSER_DEBUG
     461printf("      heapname = %s\n", str);
     462printf("      heapid   = %d\n", index);
    376463#endif
    377464            task[task_index]->heap_vobjid = index;
    378465        }
    379         else {
    380             printf("[XML ERROR] illegal or missing <heapname> for task (%d,%d)\n", vspace_index, task_loc_index);
     466        else
     467        {
     468            printf("[XML ERROR] illegal or missing <heapname> for task (%d,%d)\n",
     469                   vspace_index, task_loc_index);
    381470            exit(1);
    382471        }
    383472    } 
    384     else {
     473    else
     474    {
    385475        task[task_index]->heap_vobjid = -1;
    386476    }
    … …  
    389479    ////////// get startid  attribute
    390480    value = getIntValue(reader, "startid", &ok);
    391     if (ok) {
    392 #if XML_PARSER_DEBUG
    393         printf("      startid = %x\n", value);
     481    if (ok)
     482    {
     483#if XML_PARSER_DEBUG
     484printf("      startid = %x\n", value);
    394485#endif
    395486        task[task_index]->startid = value;
    396487    } 
    397     else {
     488    else
     489    {
    398490        printf("[XML ERROR] illegal or missing <startid> attribute for task (%d,%d)\n",
    399491                vspace_index, task_loc_index);
    … …  
    403495    /////////// get usetty  attribute (optionnal : 0 if missing)
    404496    value = getIntValue(reader, "usetty", &ok);
    405     if (ok) {
    406 #if XML_PARSER_DEBUG
    407         printf("      usetty = %x\n", value);
    408 #endif
    409         task[task_index]->use_tty = value;
    410     } 
    411     else {
    412         task[task_index]->use_tty = 0;
    413     }
     497#if XML_PARSER_DEBUG
     498printf("      usetty = %x\n", value);
     499#endif
     500    task[task_index]->use_tty = (ok)? value : 0;
    414501
    415502    /////////// get usenic  attribute (optionnal : 0 if missing)
    416503    value = getIntValue(reader, "usenic", &ok);
    417     if (ok) {
    418 #if XML_PARSER_DEBUG
    419         printf("      usenic = %x\n", value);
    420 #endif
    421         task[task_index]->use_nic = value;
    422     } 
    423     else {
    424         task[task_index]->use_nic = 0;
    425     }
    426 
    427     /////////// get usetimer attribute (optionnal : 0 if missing)
    428     value = getIntValue(reader, "usetimer", &ok);
    429     if (ok) {
    430 #if XML_PARSER_DEBUG
    431         printf("      usetimer = %x\n", value);
    432 #endif
    433         task[task_index]->use_timer = value;
    434     } 
    435     else {
    436         task[task_index]->use_timer = 0;
    437     }
    438 
    439     /////////// get usefbdma  attribute (optionnal : 0 if missing)
    440     value = getIntValue(reader, "usefbdma", &ok);
    441     if (ok) {
    442 #if XML_PARSER_DEBUG
    443         printf("      usefbdma = %x\n", value);
    444 #endif
    445         task[task_index]->use_fbdma = value;
    446     }
    447     else {
    448         task[task_index]->use_fbdma = 0;
    449     }
     504#if XML_PARSER_DEBUG
     505printf("      usenic = %x\n", value);
     506#endif
     507    task[task_index]->use_nic = (ok)? value : 0;
     508
     509    /////////// get usetim attribute (optionnal : 0 if missing)
     510    value = getIntValue(reader, "usetim", &ok);
     511#if XML_PARSER_DEBUG
     512printf("      usetim = %x\n", value);
     513#endif
     514    task[task_index]->use_tim = (ok)? value : 0;
     515
     516    /////////// get usedma  attribute (optionnal : 0 if missing)
     517    value = getIntValue(reader, "usedma", &ok);
     518#if XML_PARSER_DEBUG
     519printf("      usedma = %x\n", value);
     520#endif
     521    task[task_index]->use_dma = (ok)? value : 0;
     522
     523    /////////// get useioc  attribute (optionnal : 0 if missing)
     524    value = getIntValue(reader, "useioc", &ok);
     525#if XML_PARSER_DEBUG
     526printf("      useioc = %x\n", value);
     527#endif
     528    task[task_index]->use_ioc = (ok)? value : 0;
     529
     530    /////////// get usecma  attribute (optionnal : 0 if missing)
     531    value = getIntValue(reader, "usecma", &ok);
     532#if XML_PARSER_DEBUG
     533printf("      usecma = %x\n", value);
     534#endif
     535    task[task_index]->use_cma = (ok)? value : 0;
    450536
    451537    task_index++;
    … …  
    454540
    455541
    456 //////////////////////////////////////////
    457 void vobjNode(xmlTextReaderPtr reader) {
     542//////////////////////////////////////
     543void vobjNode(xmlTextReaderPtr reader)
     544{
    458545    unsigned int ok;
    459546    unsigned int value;
    460547    char * str;
    461548
    462     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    463         return;
    464     }
    465 
    466     if (vobj_index >= MAX_VOBJS) {
    467         printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VSEGS);
    468         exit(1);
    469     }
    470 
    471 #if XML_PARSER_DEBUG
    472     printf("      vobj %d\n", vobj_loc_index);
     549    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     550
     551    if (vobj_index >= MAX_VOBJS)
     552    {
     553        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VOBJS);
     554        exit(1);
     555    }
     556
     557#if XML_PARSER_DEBUG
     558printf("      vobj %d\n", vobj_loc_index);
    473559#endif
    474560
    … …  
    477563    ///////// get name attribute
    478564    str = getStringValue(reader, "name", &ok);
    479     if (ok) {
    480 #if XML_PARSER_DEBUG
    481         printf("        name = %s\n", str);
     565    if (ok)
     566    {
     567#if XML_PARSER_DEBUG
     568printf("        name = %s\n", str);
    482569#endif
    483570        strncpy(vobj[vobj_index]->name, str, 31);
    484571    }
    485     else {
     572    else
     573    {
    486574        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n",
    487575                vseg_index, vobj_loc_index);
    … …  
    492580    str = getStringValue(reader, "type", &ok);
    493581#if XML_PARSER_DEBUG
    494     printf("        type = %s\n", str);
    495 #endif
    496     if (ok && (strcmp(str, "ELF") == 0)) {
     582printf("        type = %s\n", str);
     583#endif
     584    if (ok && (strcmp(str, "ELF") == 0))
     585    {
    497586        vobj[vobj_index]->type = VOBJ_TYPE_ELF;
    498587
    499         //check that this vobj is the first in vseg
    500         if (vobj_count != 0) {
    501             printf("[XML ERROR] an ELF vobj must be alone in a vseg (%d,%d)\n",
    502                     vspace_index, vobj_loc_index);
    503             exit(1);
    504         }
    505     }
    506     else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB; }
    507     else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB; }
    508     else if (ok && (strcmp(str, "PERI")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI; }
    509     else if (ok && (strcmp(str, "MWMR")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MWMR; }
    510     else if (ok && (strcmp(str, "LOCK")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_LOCK; }
    511     else if (ok && (strcmp(str, "BUFFER")   == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BUFFER; }
    512     else if (ok && (strcmp(str, "BARRIER")  == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BARRIER; }
    513     else if (ok && (strcmp(str, "CONST")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_CONST; }
     588        assert( (vobj_count == 0) && "[XML ERROR] an ELF vobj must be alone in a vseg");
     589    }
     590    else if (ok && (strcmp(str, "PERI")     == 0))
     591    {
     592        vobj[vobj_index]->type = VOBJ_TYPE_PERI;     
     593
     594        assert( (vobj_count == 0) && "[XML ERROR] a PERI vobj must be alone in a vseg");
     595
     596        // fill the peripheral base address array
     597        set_periph_vbase_array( vseg_index );
     598    }
     599    else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB;     }
     600    else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB;     }
     601    else if (ok && (strcmp(str, "MWMR")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MWMR;     }
     602    else if (ok && (strcmp(str, "LOCK")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_LOCK;     }
     603    else if (ok && (strcmp(str, "BUFFER")   == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;   }
     604    else if (ok && (strcmp(str, "BARRIER")  == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;  }
     605    else if (ok && (strcmp(str, "CONST")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_CONST;    }
    514606    else if (ok && (strcmp(str, "MEMSPACE") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MEMSPACE; }
    515     else {
     607    else if (ok && (strcmp(str, "SCHED")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_SCHED;    }
     608    else
     609    {
    516610        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n",
    517611                vspace_index, vobj_loc_index);
    … …  
    523617    if (ok) {
    524618#if XML_PARSER_DEBUG
    525         printf("        length = %d\n", value);
     619printf("        length = %d\n", value);
    526620#endif
    527621        vobj[vobj_index]->length = value;
    … …  
    537631    if (ok) {
    538632#if XML_PARSER_DEBUG
    539         printf("        align = %d\n", value);
     633printf("        align = %d\n", value);
    540634#endif
    541635        vobj[vobj_index]->align = value;
    … …  
    549643    if (ok) {
    550644#if XML_PARSER_DEBUG
    551         printf("        binpath = %s\n", str);
     645printf("        binpath = %s\n", str);
    552646#endif
    553647        strncpy(vobj[vobj_index]->binpath, str, 63);
    … …  
    559653    ////////// get init attribute (mandatory for mwmr and barrier)
    560654    value = getIntValue(reader, "init", &ok);
    561     if (ok) {
    562 #if XML_PARSER_DEBUG
    563         printf("        init  = %d\n", value);
     655    if (ok)
     656    {
     657#if XML_PARSER_DEBUG
     658printf("        init  = %d\n", value);
    564659#endif
    565660        vobj[vobj_index]->init = value;
    566661    } 
    567     else {
     662    else
     663    {
    568664        if ((vobj[vobj_index]->type == VOBJ_TYPE_MWMR) ||
    569                 (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) ||
    570                 (vobj[vobj_index]->type == VOBJ_TYPE_CONST)) {
     665            (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) ||
     666            (vobj[vobj_index]->type == VOBJ_TYPE_CONST))
     667        {
    571668            printf("[XML ERROR] illegal or missing <value> attribute for vobj (%d,%d). \
    572                     All MWMR or BARRIER vobj must have a init value \n",
     669                    All MWMR or BARRIER or CONST vobj must have a init value \n",
    573670                    vspace_index, vobj_loc_index);
    574671            exit(1);
    … …  
    583680
    584681
    585 //////////////////////////////////////////
    586 void vsegNode(xmlTextReaderPtr reader) {
     682//////////////////////////////////////
     683void vsegNode(xmlTextReaderPtr reader)
     684{
    587685    unsigned int ok;
    588686    unsigned int value;
    … …  
    591689    vobj_count = 0;
    592690
    593     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    594         return;
    595     }
    596 
    597     if (vseg_index >= MAX_VSEGS) {
     691    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     692
     693    if (vseg_index >= MAX_VSEGS)
     694    {
    598695        printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS);
    599696        exit(1);
    … …  
    601698
    602699#if XML_PARSER_DEBUG
    603     printf("    vseg %d\n", vseg_loc_index);
     700printf("    vseg %d\n", vseg_loc_index);
    604701#endif
    605702
    … …  
    608705    ////////// set vobj_offset attributes
    609706    vseg[vseg_index]->vobj_offset = vobj_index;
    610 #if XML_PARSER_DEBUG
    611     printf("      vobj_offset = %d\n", vobj_index);
     707
     708#if XML_PARSER_DEBUG
     709printf("      vobj_offset = %d\n", vobj_index);
    612710#endif
    613711
    614712    ///////// get name attribute
    615713    str = getStringValue(reader, "name", &ok);
    616     if (ok) {
    617 #if XML_PARSER_DEBUG
    618         printf("      name = %s\n", str);
     714    if (ok)
     715    {
     716#if XML_PARSER_DEBUG
     717printf("      name = %s\n", str);
    619718#endif
    620719        strncpy( vseg[vseg_index]->name, str, 31);
    621720    }
    622     else {
     721    else
     722    {
    623723        printf("[XML ERROR] illegal or missing <name> attribute for vseg (%d,%d)\n",
    624724                vspace_index, vseg_loc_index);
    … …  
    628728    ////////// get ident attribute (optional : 0 if missing)
    629729    value = getIntValue(reader, "ident", &ok);
    630     if (ok) {
    631 #if XML_PARSER_DEBUG
    632         printf("      ident = %d\n", value);
     730    if (ok)
     731    {
     732#if XML_PARSER_DEBUG
     733printf("      ident = %d\n", value);
    633734#endif
    634735        vseg[vseg_index]->ident = value;
    635736    } 
    636     else {
     737    else
     738    {
    637739        vseg[vseg_index]->ident = 0;
    638740    }
    … …  
    640742    /////////// get vbase attribute
    641743    value = getIntValue(reader, "vbase", &ok);
    642     if (ok) {
    643 #if XML_PARSER_DEBUG
    644         printf("      vbase = 0x%x\n", value);
     744    if (ok)
     745    {
     746#if XML_PARSER_DEBUG
     747printf("      vbase = 0x%x\n", value);
    645748#endif
    646749        vseg[vseg_index]->vbase = value;
    647750    }
    648     else {
     751    else
     752    {
    649753        printf("[XML ERROR] illegal or missing <vbase> attribute for vseg (%d,%d)\n",
    650754                vspace_index, vseg_loc_index);
    … …  
    654758    ////////// get clusterid and psegname attributes
    655759    value = getIntValue(reader, "clusterid", &ok);
    656     if (ok == 0) {
     760    if (ok == 0)
     761    {
    657762        printf("[XML ERROR] illegal or missing <clusterid> for vseg %d\n",
    658763                vseg_loc_index);
    … …  
    660765    }
    661766    str = getStringValue(reader, "psegname", &ok);
    662     if (ok == 0) {
     767    if (ok == 0)
     768    {
    663769        printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n",
    664770                vseg_loc_index);
    … …  
    668774    /////////// set psegid field
    669775    int index = getPsegId(value, str);
    670     if (index >= 0) {
    671 #if XML_PARSER_DEBUG
    672         printf("      clusterid = %d\n", value);
    673         printf("      psegname  = %s\n", str);
    674         printf("      psegid    = %d\n", index);
     776    if (index >= 0)
     777    {
     778#if XML_PARSER_DEBUG
     779printf("      clusterid = %d\n", value);
     780printf("      psegname  = %s\n", str);
     781printf("      psegid    = %d\n", index);
    675782#endif
    676783        vseg[vseg_index]->psegid = index;
    677784    }
    678     else {
     785    else
     786    {
    679787        printf("[XML ERROR] pseg not found for vseg %d / clusterid = %d / psegname = %s\n",
    680788                vseg_loc_index, value, str );
    … …  
    685793    str = getStringValue(reader, "mode", &ok);
    686794#if XML_PARSER_DEBUG
    687     printf("      mode = %s\n", str);
     795printf("      mode = %s\n", str);
    688796#endif
    689797    if      (ok && (strcmp(str, "CXWU") == 0)) { vseg[vseg_index]->mode = 0xF; }
    … …  
    714822        const char * tag = (const char *) xmlTextReaderConstName(reader);
    715823
    716         if (strcmp(tag, "vobj")     == 0 ) {
    717             vobjNode(reader);
    718         }
     824        if      (strcmp(tag, "vobj")     == 0 ) { vobjNode(reader); }
    719825        else if (strcmp(tag, "#text"  )  == 0 ) { }
    720826        else if (strcmp(tag, "#comment") == 0 ) { }
    721         else if (strcmp(tag, "vseg")     == 0 ) {
     827        else if (strcmp(tag, "vseg")     == 0 )
     828        {
    722829            vseg[vseg_index]->vobjs = vobj_count;
    723830            vseg_index++;
    … …  
    756863
    757864#if XML_PARSER_DEBUG
    758     printf("\n  vspace %d\n", vspace_index);
     865printf("\n  vspace %d\n", vspace_index);
    759866#endif
    760867
    … …  
    765872    if (ok) {
    766873#if XML_PARSER_DEBUG
    767         printf("  name = %s\n", str);
     874printf("  name = %s\n", str);
    768875#endif
    769876        strncpy(vspace[vspace_index]->name, str, 31);
    … …  
    9361043
    9371044
    938 ///////////////////////////////////////////
    939 void periphNode(xmlTextReaderPtr reader) {
     1045////////////////////////////////////////
     1046void periphNode(xmlTextReaderPtr reader)
     1047{
    9401048    char * str;
    9411049    unsigned int value;
    9421050    unsigned int ok;
    9431051
    944     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    945         return;
    946     }
    947 
    948     if (periph_index >= MAX_PERIPHS) {
     1052    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     1053
     1054    if (periph_index >= MAX_PERIPHS)
     1055    {
    9491056        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
    9501057    }
    … …  
    9551062
    9561063    periph[periph_index] = (mapping_periph_t *) malloc(sizeof(mapping_periph_t));
    957 
    9581064
    9591065    ///////// get channels attribute (optionnal : 1 if missing)
    9601066    value = getIntValue(reader, "channels", &ok);
    961     if (ok) {
     1067    if (ok)
     1068    {
    9621069#if XML_PARSER_DEBUG
    9631070        printf("      channels = %d\n", value);
    … …  
    9651072        periph[periph_index]->channels = value;
    9661073    }
    967     else {
     1074    else
     1075    {
    9681076        periph[periph_index]->channels = 1;
    9691077    }
    … …  
    9711079    /////////// get psegname attribute
    9721080    str = getStringValue(reader, "psegname", &ok);
    973     if (ok == 0) {
     1081    if (ok == 0)
     1082    {
    9741083        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
    9751084                coproc_index, cluster_index);
    … …  
    9791088    /////////// set psegid attribute
    9801089    int index = getPsegId(cluster_index, str);
    981     if (index >= 0) {
     1090    if (index >= 0)
     1091    {
    9821092#if XML_PARSER_DEBUG
    9831093        printf("      clusterid = %d\n", cluster_index);
    … …  
    9891099                "peripheral psegname attribute must refer to a pseg of type PERI" );
    9901100    }
    991     else {
     1101    else
     1102    {
    9921103        printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n",
    9931104                periph_loc_index, cluster_index, str );
    … …  
    9951106    } 
    9961107
    997 
    9981108    /////////// get type attribute
    9991109    str = getStringValue(reader, "type", &ok);
    1000     if (ok) {
     1110    if (ok)
     1111    {
    10011112#if XML_PARSER_DEBUG
    10021113        printf("      type     = %s\n", str);
    … …  
    10041115        unsigned int error = 0;
    10051116
    1006         // The TTY, IOC, NIC, FBF and IOB peripherals cannot be replicated
    1007         // one per architecture
    1008         if (strcmp(str, "IOC") == 0) {
     1117        // The TTY, IOC, NIC, FBF, CMA and IOB peripherals are not replicated in all clusters
     1118        // but can be replicated in two different clusters for fault tolerance
     1119        // In case of replication, the number of channels must be the same
     1120        if (strcmp(str, "IOC") == 0)
     1121        {
    10091122            periph[periph_index]->type = PERIPH_TYPE_IOC;
    1010             if (header->ioc_clusterid == 0xFFFFFFFF) {
    1011                 header->ioc_clusterid = cluster_index;
    1012             }
    1013             else {
     1123            if (header->ioc_cluster == 0xFFFFFFFF)
     1124            {
     1125                header->ioc_cluster  = cluster_index;
     1126                ioc_channels = periph[periph_index]->channels;
     1127            }
     1128            else if (header->ioc_cluster_bis == 0xFFFFFFFF)
     1129            {
     1130                header->ioc_cluster_bis = cluster_index;
     1131            }
     1132            else
     1133            {
    10141134                error = 1;
    10151135            }
    1016 
    1017             ioc_base_offset = pseg[periph[periph_index]->psegid]->base;
    1018             nb_ioc_channel = periph[periph_index]->channels;
    10191136        }
    1020         else if (strcmp(str, "TTY") == 0) {
     1137        else if (strcmp(str, "TTY") == 0)
     1138        {
    10211139            periph[periph_index]->type = PERIPH_TYPE_TTY;
    1022             if (header->tty_clusterid == 0xFFFFFFFF) {
    1023                 header->tty_clusterid = cluster_index;
    1024             }
    1025             else  {
     1140            if (header->tty_cluster == 0xFFFFFFFF)
     1141            {
     1142                header->tty_cluster = cluster_index;
     1143                tty_channels = periph[periph_index]->channels;
     1144            }
     1145            else if (header->tty_cluster_bis == 0xFFFFFFFF)
     1146            {
     1147                header->tty_cluster_bis = cluster_index;
     1148            }
     1149            else 
     1150            {
    10261151                error = 1;
    10271152            }
    1028 
    1029             tty_base_offset = pseg[periph[periph_index]->psegid]->base;
    1030             nb_tty_channel = periph[periph_index]->channels;
    1031         }
    1032         else if (strcmp(str, "FBF") == 0) {
     1153        }
     1154        else if (strcmp(str, "FBF") == 0)
     1155        {
    10331156            periph[periph_index]->type = PERIPH_TYPE_FBF;
    1034             if (header->fbf_clusterid == 0xFFFFFFFF) {
    1035                 header->fbf_clusterid = cluster_index;
    1036             }
    1037             else {
     1157            if (header->fbf_cluster == 0xFFFFFFFF) 
     1158            {
     1159                header->fbf_cluster = cluster_index;
     1160            }
     1161            else if (header->fbf_cluster_bis == 0xFFFFFFFF)
     1162            {
     1163                header->fbf_cluster_bis = cluster_index;
     1164            }
     1165            else 
     1166            {
    10381167                error = 1;
    10391168            }
    1040             fbf_base_offset = pseg[periph[periph_index]->psegid]->base;
    1041         }
    1042         else if (strcmp(str, "NIC") == 0) {
     1169        }
     1170        else if (strcmp(str, "NIC") == 0)
     1171        {
    10431172            periph[periph_index]->type = PERIPH_TYPE_NIC;
    1044             if (header->nic_clusterid == 0xFFFFFFFF) {
    1045                 header->nic_clusterid = cluster_index;
    1046             }
    1047             else {
     1173            if (header->nic_cluster == 0xFFFFFFFF) 
     1174            {
     1175                header->nic_cluster = cluster_index;
     1176                nic_channels = periph[periph_index]->channels;
     1177            }
     1178            else if (header->nic_cluster_bis == 0xFFFFFFFF)
     1179            {
     1180                header->nic_cluster_bis = cluster_index;
     1181            }
     1182            else 
     1183            {
    10481184                error = 1;
    10491185            }
    1050             nic_base_offset = pseg[periph[periph_index]->psegid]->base;
    1051             nb_nic_channel = periph[periph_index]->channels;
    1052         }
    1053         else if (strcmp(str, "IOB") == 0) {
     1186        }
     1187        else if (strcmp(str, "CMA") == 0)
     1188        {
     1189            periph[periph_index]->type = PERIPH_TYPE_CMA;
     1190            if (header->cma_cluster == 0xFFFFFFFF) 
     1191            {
     1192                header->cma_cluster = cluster_index;
     1193                cma_channels = periph[periph_index]->channels;
     1194            }
     1195            else if (header->nic_cluster_bis == 0xFFFFFFFF)
     1196            {
     1197                header->cma_cluster_bis = cluster_index;
     1198            }
     1199            else 
     1200            {
     1201                error = 1;
     1202            }
     1203        }
     1204        else if (strcmp(str, "IOB") == 0)
     1205        {
    10541206            periph[periph_index]->type = PERIPH_TYPE_IOB;
    1055             iob_base_offset = pseg[periph[periph_index]->psegid]->base;
    1056 
    1057             if (io_mmu_active) {
     1207            io_mmu_active = 1;
     1208            if (header->iob_cluster == 0xFFFFFFFF) 
     1209            {
     1210                header->iob_cluster = cluster_index;
     1211            }
     1212            else if (header->iob_cluster_bis == 0xFFFFFFFF)
     1213            {
     1214                header->iob_cluster_bis = cluster_index;
     1215            }
     1216            else 
     1217            {
    10581218                error = 1;
    10591219            }
    1060             io_mmu_active = 1;
    1061         }
    1062         // The TIM, ICU, XICU, DMA and IOB peripherals can be replicated in several clusters
    1063         // one per cluster
    1064         else if (strcmp(str, "TIM") == 0 ) {
     1220        }
     1221        // The TIM, ICU, XICU, DMA peripherals are replicated in all clusters
     1222        // but only one component per cluster
     1223        else if (strcmp(str, "TIM") == 0 )
     1224        {
    10651225            periph[periph_index]->type = PERIPH_TYPE_TIM;
    1066             if (found_timer) {
    1067                 error = 1;
    1068             }
     1226            if (found_timer || use_xicu)  error = 1;
    10691227            found_timer = 1;
    1070 
    1071             if (tim_base_offset == 0xFFFFFFFF) {
    1072                 tim_base_offset = pseg[ periph[periph_index]->psegid ]->base;
    1073             }
    1074 
    1075             if (nb_timer_channel_max < periph[periph_index]->channels) {
    1076                 nb_timer_channel_max = periph[periph_index]->channels;
    1077             }
    1078         }
    1079         else if (strcmp(str, "ICU") == 0) {
     1228            if (tim_channels < periph[periph_index]->channels)
     1229            {
     1230                tim_channels = periph[periph_index]->channels;
     1231            }
     1232        }
     1233        else if (strcmp(str, "ICU") == 0)
     1234        {
    10801235            periph[periph_index]->type = PERIPH_TYPE_ICU;
    1081             if (found_icu) {
    1082                 error = 1;
    1083             }
     1236            if (found_icu)  error = 1;
    10841237            found_icu = 1;
    1085 
    1086             if (icu_base_offset == 0xFFFFFFFF) {
    1087                 icu_base_offset = pseg[periph[periph_index]->psegid]->base;
    1088             }
    1089         }
    1090         else if (strcmp(str, "XICU") == 0) {
    1091             periph[periph_index]->type = PERIPH_TYPE_XICU;
    1092             if (found_xicu) {
    1093                 error = 1;
    1094             }
    1095             found_xicu = 1;
    1096 
    1097             //'icu' since we can't have both xicu and icu in an arch
    1098             if (icu_base_offset == 0xFFFFFFFF) {
    1099                 icu_base_offset = pseg[ periph[periph_index]->psegid ]->base;
    1100             }
    1101 
    1102             if (nb_timer_channel_max == 0) {
    1103                 nb_timer_channel_max = 32;
    1104             }
    1105         }
    1106         else if (strcmp(str, "DMA") == 0) {
     1238        }
     1239        else if (strcmp(str, "XICU") == 0)
     1240        {
     1241            periph[periph_index]->type = PERIPH_TYPE_ICU;
     1242            if (found_icu || found_timer)  error = 1;
     1243            found_icu = 1;
     1244            if (tim_channels == 0)
     1245            {
     1246                tim_channels = 32;
     1247            }
     1248            use_xicu = 1;
     1249        }
     1250        else if (strcmp(str, "DMA") == 0)
     1251        {
    11071252            periph[periph_index]->type = PERIPH_TYPE_DMA;
    1108             if (found_dma) {
    1109                 error = 1;
    1110             }
     1253            if (found_dma)  error = 1;
    11111254            found_dma = 1;
    1112 
    1113             if (dma_base_offset == 0xFFFFFFFF) {
    1114                 dma_base_offset = pseg[periph[periph_index]->psegid]->base;
    1115             }
    1116             if (nb_dma_channel_max < periph[periph_index]->channels) {
    1117                 nb_dma_channel_max = periph[periph_index]->channels;
    1118             }
    1119         }
    1120         else {
     1255            if (dma_channels < periph[periph_index]->channels)
     1256                dma_channels = periph[periph_index]->channels;
     1257        }
     1258        else
     1259        {
    11211260            printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
    11221261                    periph_loc_index, cluster_index);
    … …  
    11241263        }
    11251264
    1126         if (error) {
     1265        if (error)
     1266        {
    11271267            printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
    11281268                    periph_loc_index, cluster_index);
    … …  
    11301270        }
    11311271    }
    1132     else {
     1272    else
     1273    {
    11331274        printf("[XML ERROR] missing <type> for peripheral  %d in cluster %d\n",
    11341275                periph_loc_index, cluster_index);
    11351276        exit(1);
    11361277    }
    1137 
    11381278
    11391279    periph_index++;
    … …  
    14031543void psegNode(xmlTextReaderPtr reader) {
    14041544    unsigned int ok;
    1405     unsigned int value;
     1545    paddr_t      ll_value;
    14061546    char * str;
    14071547
    … …  
    14501590
    14511591    //////// get base attribute
    1452     value = getIntValue(reader, "base", &ok);
    1453 #if XML_PARSER_DEBUG
    1454     printf("      base = 0x%x\n", value);
     1592    ll_value = getPaddrValue(reader, "base", &ok);
     1593#if XML_PARSER_DEBUG
     1594    printf("      base = 0x%llx\n", ll_value);
    14551595#endif
    14561596    if (ok) {
    1457         pseg[pseg_index]->base = value;
     1597        pseg[pseg_index]->base = ll_value;
    14581598    }
    14591599    else {
    … …  
    14641604
    14651605    //////// get length attribute
    1466     value = getIntValue(reader, "length", &ok);
    1467 #if XML_PARSER_DEBUG
    1468     printf("      length = 0x%x\n", value);
     1606    ll_value = getPaddrValue(reader, "length", &ok);
     1607#if XML_PARSER_DEBUG
     1608    printf("      length = 0x%llx\n", ll_value);
    14691609#endif
    14701610    if (ok) {
    1471         pseg[pseg_index]->length = value;
     1611        pseg[pseg_index]->length = ll_value;
    14721612    } 
    14731613    else {
    … …  
    14851625
    14861626
    1487 /////////////////////////////////////////////
    1488 void clusterNode(xmlTextReaderPtr reader) {
     1627/////////////////////////////////////////
     1628void clusterNode(xmlTextReaderPtr reader)
     1629{
    14891630    unsigned int ok;
    14901631    unsigned int value;
    … …  
    15101651    found_timer = 0;
    15111652    found_icu = 0;
    1512     found_xicu = 0;
    15131653    found_dma = 0;
    15141654
    … …  
    15521692    int status = xmlTextReaderRead(reader);
    15531693
    1554     while (status == 1) {
     1694    while (status == 1)
     1695    {
    15551696        const char * tag = (const char *) xmlTextReaderConstName(reader);
    15561697
    … …  
    15611702        else if (strcmp(tag, "#text")    == 0) { }
    15621703        else if (strcmp(tag, "#comment") == 0) { }
    1563         else if (strcmp(tag, "cluster")  == 0) {
    1564 
    1565             if (use_xicu == 0xFFFFFFFF) {
    1566                 use_xicu = found_xicu;
    1567             }
    1568 
    1569             ////////////////// peripherals checks ////////////////////
    1570             if ((found_timer  && use_xicu) || (!found_timer  && !use_xicu)) {
     1704        else if (strcmp(tag, "cluster")  == 0)
     1705        {
     1706
     1707            ////////////////// peripherals checks /////////////////////////
     1708            if ((found_timer  && use_xicu) || (!found_timer  && !use_xicu))
     1709            {
    15711710                printf("[XML ERROR] illegal or missing timer peripheral in cluster %d\n", cluster_index);
    15721711                exit(1);
    15731712            }
    15741713
    1575             if ((found_icu && use_xicu) || (!found_icu && !use_xicu)) {
     1714            if (!found_icu)
     1715            {
    15761716                printf("[XML ERROR] illegal or missing icu peripheral in cluster %d\n", cluster_index);
    15771717                exit(1);
    15781718            }
    15791719
    1580             if (!found_xicu && use_xicu) {
     1720            if (!found_dma)
     1721            {
    15811722                printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
    15821723                exit(1);
    15831724            }
    15841725
    1585             if (!found_dma) {
    1586                 printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
    1587                 exit(1);
    1588             }
    1589 
    1590 
    1591             if (nb_proc_max < cluster[cluster_index]->procs) {
     1726
     1727            if (nb_proc_max < cluster[cluster_index]->procs)
     1728            {
    15921729                nb_proc_max = cluster[cluster_index]->procs;
    15931730            }
    … …  
    16091746
    16101747//////////////////////////////////////////////
    1611 void clusterSetNode(xmlTextReaderPtr reader) {
    1612     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1613         return;
    1614     }
     1748void clusterSetNode(xmlTextReaderPtr reader)
     1749{
     1750    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
    16151751
    16161752#if XML_PARSER_DEBUG
    … …  
    16191755
    16201756    int status = xmlTextReaderRead(reader);
    1621     while (status == 1) {
     1757    while (status == 1)
     1758    {
    16221759        const char * tag = (const char *) xmlTextReaderConstName(reader);
    16231760
    1624         if (strcmp(tag, "cluster")    == 0) {
    1625             clusterNode(reader);
    1626         }
     1761        if      (strcmp(tag, "cluster")    == 0) { clusterNode(reader); }
    16271762        else if (strcmp(tag, "#text")      == 0) { }
    16281763        else if (strcmp(tag, "#comment")   == 0) { }
    1629         else if (strcmp(tag, "clusterset") == 0) {
     1764        else if (strcmp(tag, "clusterset") == 0)
     1765        {
    16301766            // checking source file consistency
    1631             if (cluster_index != header->clusters) {
     1767            if (cluster_index != header->clusters)
     1768            {
    16321769                printf("[XML ERROR] Wrong number of clusters\n");
    16331770                exit(1);
    16341771            }
    16351772
    1636             if (header->tty_clusterid == 0xFFFFFFFF) {
     1773            // At least one TTY terminal for system boot
     1774            if (header->tty_cluster == 0xFFFFFFFF)
     1775            {
    16371776                printf("[XML ERROR] illegal or missing tty peripheral");
    16381777                exit(1);
    … …  
    16471786            header->coprocs = coproc_index;
    16481787            header->cp_ports = cp_port_index;
     1788            header->periphs = periph_index;
    16491789            return;
    16501790        }
    … …  
    16691809
    16701810    int status = xmlTextReaderRead(reader);
    1671     while (status == 1) {
     1811    while (status == 1)
     1812    {
    16721813        const char * tag = (const char *) xmlTextReaderConstName(reader);
    16731814
    1674         if (strcmp(tag, "vseg") == 0) {
    1675             vsegNode(reader);
    1676         }
     1815        if      (strcmp(tag, "vseg")      == 0) { vsegNode(reader); }
    16771816        else if (strcmp(tag, "#text")     == 0) { }
    16781817        else if (strcmp(tag, "#comment")  == 0) { }
    … …  
    17361875
    17371876//////////////////////////////////////////
    1738 void headerNode(xmlTextReaderPtr reader) {
     1877void headerNode(xmlTextReaderPtr reader)
     1878{
    17391879    char * name;
    17401880    unsigned int value;
    17411881    unsigned int ok;
    17421882
    1743     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1744         return;
    1745     }
     1883    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
    17461884
    17471885#if XML_PARSER_DEBUG
    … …  
    18201958    }
    18211959
    1822     //////// initialise non replicated peripherals cluster_id
    1823     header->tty_clusterid = 0xFFFFFFFF;
    1824     header->nic_clusterid = 0xFFFFFFFF;
    1825     header->ioc_clusterid = 0xFFFFFFFF;
    1826     header->fbf_clusterid = 0xFFFFFFFF;
     1960    //////// initialise non replicated peripherals cluster index
     1961    header->tty_cluster = 0xFFFFFFFF;
     1962    header->nic_cluster = 0xFFFFFFFF;
     1963    header->ioc_cluster = 0xFFFFFFFF;
     1964    header->fbf_cluster = 0xFFFFFFFF;
     1965    header->cma_cluster = 0xFFFFFFFF;
     1966    header->iob_cluster = 0xFFFFFFFF;
     1967    header->tty_cluster_bis = 0xFFFFFFFF;
     1968    header->nic_cluster_bis = 0xFFFFFFFF;
     1969    header->ioc_cluster_bis = 0xFFFFFFFF;
     1970    header->fbf_cluster_bis = 0xFFFFFFFF;
     1971    header->cma_cluster_bis = 0xFFFFFFFF;
     1972    header->iob_cluster_bis = 0xFFFFFFFF;
    18271973
    18281974    ///////// set signature
    … …  
    19402086// this function set the value the vobj_id fiels of all cp_ports
    19412087///////////////////////////////////////////////////////////////////////
    1942 void prepareBuild() {
     2088void prepareBuild()
     2089{
    19432090    unsigned int i;
    19442091    //asign for all cp_ports the correct vspaceid and vobjid
    … …  
    19722119}
    19732120
    1974 
    19752121//////////////////////////////////////////
    1976 void file_write(int fdout, char * towrite) {
     2122void file_write(int fdout, char * towrite)
     2123{
    19772124    unsigned int size = strlen(towrite);
    1978     if (size != write(fdout, towrite, size)) {
     2125    if (size != write(fdout, towrite, size))
     2126    {
    19792127        printf("file_write error");
    19802128        exit(1);
    … …  
    19822130}
    19832131
    1984 
    19852132//////////////////////////////////////////////////
    1986 void def_int_write(int fdout, char * def, int num) {
     2133void def_int_write(int fdout, char * def, int num)
     2134{
    19872135    char  buf[64];
    19882136    sprintf(buf, "#define\t %s  %d\n", def, num);
    … …  
    19902138}
    19912139
    1992 
    1993 /////////////////////////////////////////////////
    1994 void def_hex_write(int fdout, char * def, int num) {
     2140//////////////////////////////////////////////////
     2141void def_hex_write(int fdout, char * def, int num)
     2142{
    19952143    char  buf[64];
    19962144    sprintf(buf, "#define\t %s  0x%x\n", def, num);
    … …  
    19982146}
    19992147
    2000 
    2001 ///////////////////////////////////////
    2002 void  genHd(const char * file_path) {
     2148///////////////////////////////////
     2149void  genHd(const char * file_path)
     2150{
    20032151    int fdout = open_file(file_path);
    20042152
    2005     char * prol = " /* Generated from the mapping_info file */\n\n#ifndef _HD_CONFIG_H\n#define _HD_CONFIG_H\n\n";
     2153    char * prol   = "/* Generated from the mapping_info file */\n\n";
     2154    char * ifdef  = "#ifndef _HD_CONFIG_H\n#define _HD_CONFIG_H\n\n";
     2155    char * epil   = "\n#endif //_HD_CONFIG_H";
     2156
    20062157    file_write(fdout, prol);
    2007 
    2008     def_int_write(fdout, "CLUSTER_X"    , cluster_x);
    2009     def_int_write(fdout, "CLUSTER_Y"    , cluster_y);
    2010     def_int_write(fdout, "NB_CLUSTERS"  , cluster_index);
    2011     def_hex_write(fdout, "CLUSTER_SIZE" , (((unsigned long long) 1) << 32) / cluster_index);
    2012     def_int_write(fdout, "NB_PROCS_MAX" , nb_proc_max);
    2013     def_int_write(fdout, "NB_TIMERS_MAX", nb_timer_channel_max);
    2014     def_int_write(fdout, "NB_DMAS_MAX"  , nb_dma_channel_max);
    2015     def_int_write(fdout, "NB_TTYS"      , nb_tty_channel);
    2016     def_int_write(fdout, "NB_IOCS"      , nb_ioc_channel);
    2017     def_int_write(fdout, "NB_NICS"      , nb_nic_channel);
    2018     def_int_write(fdout, "NB_TASKS"     , nb_tasks_max);
     2158    file_write(fdout, ifdef);
     2159
     2160    def_int_write(fdout, "CLUSTER_X         ", cluster_x);
     2161    def_int_write(fdout, "CLUSTER_Y         ", cluster_y);
     2162    def_int_write(fdout, "NB_CLUSTERS       ", cluster_index);
     2163    def_int_write(fdout, "NB_PROCS_MAX      ", nb_proc_max);
     2164    def_int_write(fdout, "NB_TASKS_MAX      ", nb_tasks_max);
    20192165
    20202166    file_write(fdout, "\n");
    2021     def_int_write(fdout, "USE_XICU"     , use_xicu);
    2022     def_int_write(fdout, "IOMMU_ACTIVE ", io_mmu_active);
    2023 
    2024     char * epil = "\n#endif //_HD_CONFIG_H";
     2167
     2168    def_int_write(fdout, "NB_TIM_CHANNELS   ", tim_channels);
     2169    def_int_write(fdout, "NB_DMA_CHANNELS   ", dma_channels);
     2170
     2171    file_write(fdout, "\n");
     2172
     2173    def_int_write(fdout, "NB_TTY_CHANNELS   ", tty_channels);
     2174    def_int_write(fdout, "NB_IOC_CHANNELS   ", ioc_channels);
     2175    def_int_write(fdout, "NB_NIC_CHANNELS   ", nic_channels);
     2176    def_int_write(fdout, "NB_CMA_CHANNELS   ", cma_channels);
     2177
     2178    file_write(fdout, "\n");
     2179
     2180    def_int_write(fdout, "USE_XICU          ", use_xicu);
     2181    def_int_write(fdout, "IOMMU_ACTIVE      ", io_mmu_active);
     2182
    20252183    file_write(fdout, epil);
    20262184
    … …  
    20282186}
    20292187
    2030 
    20312188////////////////////////////////////////////////////////
    2032 void ld_write(int fdout, char * seg, unsigned int addr) {
     2189void ld_write(int fdout, char * seg, unsigned int addr)
     2190{
    20332191    char buf[64];
    20342192    sprintf(buf, "%s = 0x%x;\n", seg, addr);
    20352193    file_write(fdout, buf);
    2036 
    20372194}
    20382195
    2039 
    2040 ///////////////////////////////////////
    2041 void genLd(const char * file_path) {
    2042     int fdout = open_file(file_path);
     2196//////////////////////////////////
     2197void genLd(const char * file_path)
     2198{
     2199    int          fdout = open_file(file_path);
     2200    unsigned int count = 0;
     2201    unsigned int vseg_id;
    20432202
    20442203    char * prol = "/* Generated from the mapping_info file */\n\n";
    20452204    file_write(fdout, prol);
    20462205
    2047     //boot
    2048     ld_write(fdout, "seg_boot_code_base", boot_code_base);
    2049     ld_write(fdout, "seg_boot_stack_base", boot_stack_base);
    2050     ld_write(fdout, "seg_mapping_base", boot_mapping_base);
    2051 
    2052     //kernel
    2053     ld_write(fdout, "\nseg_kernel_code_base",  kernel_code_base);
    2054     ld_write(fdout, "seg_kernel_data_base",    kernel_data_base);
    2055     ld_write(fdout, "seg_kernel_uncdata_base", kernel_uncdata_base);
    2056     ld_write(fdout, "seg_kernel_init_base",    kernel_init_base);
    2057 
    2058     //peripherals
    2059     ld_write(fdout, "\nseg_fbf_base", fbf_base_offset);
    2060     ld_write(fdout, "seg_icu_base",   icu_base_offset);
    2061     ld_write(fdout, "seg_ioc_base",   ioc_base_offset);
    2062     ld_write(fdout, "seg_nic_base",   nic_base_offset);
    2063     ld_write(fdout, "seg_tty_base",   tty_base_offset);
    2064     ld_write(fdout, "seg_dma_base",   dma_base_offset);
    2065     ld_write(fdout, "seg_tim_base",   tim_base_offset);
    2066     ld_write(fdout, "seg_gcd_base",   gcd_base_offset);
    2067     ld_write(fdout, "seg_iob_base",   iob_base_offset);
     2206    // boot and kernel segments
     2207    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
     2208    {
     2209        if ( strcmp(vseg[vseg_id]->name, "seg_boot_code") == 0 )
     2210        {
     2211            ld_write(fdout, "seg_boot_code_base      ",  vseg[vseg_id]->vbase);
     2212            count++;
     2213        }
     2214        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_stack") == 0 )
     2215        {
     2216            ld_write(fdout, "seg_boot_stack_base     ",  vseg[vseg_id]->vbase);
     2217            count++;
     2218        }
     2219        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_mapping") == 0 )
     2220        {
     2221            ld_write(fdout, "seg_mapping_base        ",  vseg[vseg_id]->vbase);
     2222            count++;
     2223        }
     2224        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 )
     2225        {
     2226            ld_write(fdout, "seg_kernel_code_base    ",  vseg[vseg_id]->vbase);
     2227            count++;
     2228        }
     2229        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 )
     2230        {
     2231            ld_write(fdout, "seg_kernel_data_base    ",  vseg[vseg_id]->vbase);
     2232            count++;
     2233        }
     2234        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 )
     2235        {
     2236            ld_write(fdout, "seg_kernel_uncdata_base ",  vseg[vseg_id]->vbase);
     2237            count++;
     2238        }
     2239        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 )
     2240        {
     2241            ld_write(fdout, "seg_kernel_init_base    ",  vseg[vseg_id]->vbase);
     2242            count++;
     2243        }
     2244    }
     2245    if ( count != 7 )
     2246    {
     2247        printf ("[XML ERROR] Missing Boot or Kernel vseg : only %d\n", count);
     2248        printf ("Mandatory segments are :\n");
     2249        printf (" - seg_boot_code\n");
     2250        printf (" - seg_boot_stack\n");
     2251        printf (" - seg_boot_mapping\n");
     2252        printf (" - seg_kernel_code\n");
     2253        printf (" - seg_kernel_data\n");
     2254        printf (" - seg_kernel_uncdata\n");
     2255        printf (" - seg_kernel_init\n");
     2256    }
     2257
     2258    file_write(fdout, "\n");
     2259
     2260    // non replicated peripherals
     2261    ld_write(fdout, "\nseg_fbf_base            ", periph_vbase_array[PERIPH_TYPE_FBF]);
     2262    ld_write(fdout, "seg_ioc_base            ",   periph_vbase_array[PERIPH_TYPE_IOC]);
     2263    ld_write(fdout, "seg_nic_base            ",   periph_vbase_array[PERIPH_TYPE_NIC]);
     2264    ld_write(fdout, "seg_tty_base            ",   periph_vbase_array[PERIPH_TYPE_TTY]);
     2265    ld_write(fdout, "seg_gcd_base            ",   periph_vbase_array[PERIPH_TYPE_GCD]);
     2266    ld_write(fdout, "seg_iob_base            ",   periph_vbase_array[PERIPH_TYPE_IOB]);
     2267
     2268    file_write(fdout, "\n");
     2269
     2270    // replicated peripherals
     2271    ld_write(fdout, "seg_icu_base            ",   periph_vbase_array[PERIPH_TYPE_ICU]);
     2272    ld_write(fdout, "seg_dma_base            ",   periph_vbase_array[PERIPH_TYPE_DMA]);
     2273    ld_write(fdout, "seg_tim_base            ",   periph_vbase_array[PERIPH_TYPE_TIM]);
    20682274
    20692275    close(fdout);
    20702276}
    20712277
    2072 
    2073 char * buildPath(const char * path, const char * name) {
     2278//////////////////////////////////////////////////////
     2279char * buildPath(const char * path, const char * name)
     2280{
    20742281    char * res = calloc(strlen(path) + strlen(name) + 1, 1);
    20752282    strcat(res, path);
    … …  
    20802287
    20812288
    2082 /////////////////////////////////////
    2083 int main(int argc, char * argv[]) {
     2289//////////////////////////////////
     2290int main(int argc, char * argv[])
     2291{
    20842292    if (argc < 3) {
    20852293        printf("Usage: xml2bin <input_file_path> <output_path>\n");
Note: See TracChangeset for help on using the changeset viewer.