Ignore:
Timestamp:
Aug 14, 2013, 11:19:29 PM (11 years ago)
Author:
alain
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/xml/xml_parser.c

    r249 r253  
    66///////////////////////////////////////////////////////////////////////////////////////
    77// This program translate a "map.xml" source file to a binary file "map.bin" that
    8 // can be directly loaded in the boot ROM and used by the GIET-VM operating system.
     8// can be directly loaded in memory and used by the GIET-VM operating system.
    99//
    1010// This map.xml file contains :
    … …  
    1414// The corresponding C structures are defined in the "mapping_info.h" file.
    1515//
    16 // This program also generates the "hard_config.h" and the "giet_vsegs.ld" files,
     16// This parser also generates the "hard_config.h" and the "giet_vsegs.ld" files,
    1717// required  to compile the GIET-VM code.
    1818///////////////////////////////////////////////////////////////////////////////////////
    … …  
    100100char found_timer = 0;
    101101char found_icu   = 0;
     102char found_xcu   = 0;
    102103char found_dma   = 0;
    103104char found_mmc   = 0;
    … …  
    122123
    123124unsigned int use_iob          = 0; // using IOB component
    124 unsigned int use_xicu         = 0; // using XICU (not ICU)
     125unsigned int use_xcu          = 0; // using XCU (not ICU)
    125126
    126127
    … …  
    130131
    131132unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE]
    132          = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };
     133         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFF00000 };
    133134
    134135//////////////////////////////////////////////////////////////////////
    … …  
    278279} // end getStringValue()
    279280
    280 ///////////////////////////////////////////////////////
    281 void set_periph_vbase_array( unsigned int vseg_index )
    282 {
    283     unsigned int vbase  = vseg[vseg_index]->vbase;  // peripheral vbase address
    284     unsigned int psegid = vseg[vseg_index]->psegid; // pseg global index
    285     unsigned int type;                              // peripheral type
    286     unsigned int periph_id;
    287 
    288     for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
    289     {
    290         if( periph[periph_id]->psegid == psegid )
    291         {
    292             type = periph[periph_id]->type;
    293             if ( periph_vbase_array[type] == 0xFFFFFFFF )
    294                  periph_vbase_array[type] = vbase;   
    295         }
     281///////////////////////////////////////////////////////////////////////////////////
     282// This function set the vbase address for all peripheral types.
     283// For replicated peripherals with the same type the virtual base address must be:
     284//   vbase = seg_type_base & 0XFFF00000 +
     285//          (cluster_id * vbase_cluster_increment) & 0x000FFFFF
     286void set_periph_vbase_array()
     287{
     288    unsigned int vseg_id;      // vseg global index
     289    unsigned int periph_id;    // periph global index
     290    unsigned int pseg_id;      // pseg global index
     291    unsigned int cluster_id;   // cluster global index
     292    unsigned int type;         // peripheral type
     293
     294    unsigned int msb_mask = 0xFFF00000;
     295    unsigned int lsb_mask = 0x000FFFFF;
     296
     297    // We are looking for any vseg matching a peripheral
     298    // (i.e. they are associated to the same pseg)
     299
     300    // scan all vsegs
     301    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
     302    {
     303        // keep only vseg corresponding to a periph       
     304        if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI )
     305        {
     306            pseg_id = vseg[vseg_id]->psegid;
     307            cluster_id = pseg[pseg_id]->cluster;
     308
     309            // scan all periphs
     310            for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
     311            {
     312                if( periph[periph_id]->psegid == pseg_id ) // matching !!!
     313                {
     314                    type = periph[periph_id]->type;
     315                    if ( periph_vbase_array[type] == 0xFFF00000 )  // vbase not set
     316                    {
     317                        periph_vbase_array[type] = vseg[vseg_id]->vbase;   
     318                    }
     319                    else                                 // vbase already set
     320                    {
     321                        // checking 12 MSB bits for replicated peripherals
     322                        if( (vseg[vseg_id]->vbase & msb_mask) !=
     323                            (periph_vbase_array[type] & msb_mask) )
     324                        {
     325                            printf("[XML ERROR] All peripherals with same type ");
     326                            printf(" should share the same 12 MSB for vbase address\n");
     327                            printf("periph index = %d / periph type = %d / vbase = %x\n",
     328                                    periph_id, type, vseg[vseg_id]->vbase);
     329                            exit(1);
     330                        }
     331                        // checking 20 LSB bits for replicated peripherals
     332                        if( (vseg[vseg_id]->vbase & lsb_mask) !=
     333                            (header->increment * cluster_id) )
     334                        {
     335                            printf("[XML ERROR] All peripherals with same type ");
     336                            printf(" must have the 20 LSB bits = cluster_id * increment");
     337                            printf("periph index = %d / periph type = %d / vbase = %x\n",
     338                                    periph_id, type, vseg[vseg_id]->vbase);
     339                            exit(1);
     340                        }
     341                    }
     342                }
     343            }
     344        }   
    296345    }
    297346}  // end set_periph_vbase_array()
    … …  
    336385    unsigned int vobj_max = vobj_min + vspace_max;
    337386
    338     for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) {
    339         if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) {
    340             return (vobj_id - vobj_min);
    341         }
     387    for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++)
     388    {
     389        if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return (vobj_id - vobj_min);
    342390    }
    343391    return -1;
    344392}
    345393
    346 
    347 /////////////////////////////////////////
     394//////////////////////////////////////
    348395void taskNode(xmlTextReaderPtr reader)
    349396{
    … …  
    352399    char * str;
    353400
    354     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     401    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    355402
    356403    if (task_index >= MAX_TASKS)
    357404    {
    358405        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
     406        exit(1);
    359407    }
    360408
    … …  
    540588} // end taskNode()
    541589
    542 
    543590//////////////////////////////////////
    544591void vobjNode(xmlTextReaderPtr reader)
    … …  
    548595    char * str;
    549596
    550     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     597    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    551598
    552599    if (vobj_index >= MAX_VOBJS)
    … …  
    583630printf("        type = %s\n", str);
    584631#endif
    585     if (ok && (strcmp(str, "ELF") == 0))
    586     {
    587         vobj[vobj_index]->type = VOBJ_TYPE_ELF;
    588 
    589         assert( (vobj_count == 0) && "[XML ERROR] an ELF vobj must be alone in a vseg");
    590     }
    591     else if (ok && (strcmp(str, "PERI")     == 0))
    592     {
    593         vobj[vobj_index]->type = VOBJ_TYPE_PERI;     
    594 
    595         assert( (vobj_count == 0) && "[XML ERROR] a PERI vobj must be alone in a vseg");
    596 
    597         // fill the peripheral base address array
    598         set_periph_vbase_array( vseg_index );
    599     }
     632
     633    if      (ok && (strcmp(str, "ELF")      == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF;      }
     634    else if (ok && (strcmp(str, "PERI")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI;     }
    600635    else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB;     }
    601636    else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB;     }
    … …  
    613648        exit(1);
    614649    }
     650    // some more checking
     651    if ( (vobj[vobj_index]->type == VOBJ_TYPE_ELF) ||
     652         (vobj[vobj_index]->type == VOBJ_TYPE_PERI) )
     653    {
     654        assert( (vobj_count == 0) &&
     655        "[XML ERROR] an ELF or PERI vobj must be alone in a vseg");
     656    }
     657       
    615658
    616659    ////////// get length attribute
    … …  
    680723} // end vobjNode()
    681724
    682 
    683725//////////////////////////////////////
    684726void vsegNode(xmlTextReaderPtr reader)
    … …  
    690732    vobj_count = 0;
    691733
    692     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     734    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    693735
    694736    if (vseg_index >= MAX_VSEGS)
    … …  
    833875            return;
    834876        }
    835         else {
     877        else
     878        {
    836879            printf("[XML ERROR] Unknown tag %s", tag);
    837880            exit(1);
    … …  
    841884} // end vsegNode()
    842885
    843 
    844 //////////////////////////////////////////
    845 void vspaceNode(xmlTextReaderPtr reader) {
     886////////////////////////////////////////
     887void vspaceNode(xmlTextReaderPtr reader)
     888{
    846889    char * str;
    847890    unsigned int ok;
    … …  
    852895    task_loc_index = 0;
    853896
    854     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    855         return;
    856     }
     897    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    857898
    858899    // checking source file consistency
    … …  
    877918        strncpy(vspace[vspace_index]->name, str, 31);
    878919    }
    879     else {
     920    else
     921    {
    880922        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n",
    881923                vspace_index);
    … …  
    899941        //used after parsing the vobjs
    900942    }
    901     else {
     943    else
     944    {
    902945        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %s\n",
    903946                vspace[vspace_index]->name);
    … …  
    925968            // get index of the vobj containing the start vector
    926969            int index = getVobjLocId(vspace_index, str , vobj_loc_index);
    927             if (index == -1) {
     970            if (index == -1)
     971            {
    928972                printf("[XML ERROR] vobj containing start vector not found in vspace %s\n",
    929973                        vspace[vspace_index]->name);
    930                 exit(-1);
    931             }
    932             else {
     974                exit(1);
     975            }
     976            else
     977            {
    933978                vspace[vspace_index]->start_offset = index;
    934979#if XML_PARSER_DEBUG
    … …  
    944989            int task_max = task_min + vspace[vspace_index]->tasks;
    945990            for (task_id = task_min; task_id < task_max; task_id++) {
    946                 if (task[task_id]->startid >= vspace[vspace_index]->tasks) {
     991                if (task[task_id]->startid >= vspace[vspace_index]->tasks)
     992                {
    947993                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n",
    948994                            vspace_index, task_id );
    … …  
    9551001            return;
    9561002        }
    957         else {
     1003        else
     1004        {
    9581005            printf("[XML ERROR] Unknown tag %s", tag);
    9591006            exit(1);
    … …  
    9631010} // end vspaceNode()
    9641011
    965 
    966 ///////////////////////////////////////////
    967 void cpPortNode(xmlTextReaderPtr reader) {
     1012////////////////////////////////////////
     1013void cpPortNode(xmlTextReaderPtr reader)
     1014{
    9681015    char * str;
    9691016    unsigned int ok;
    9701017
    971     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    972         return;
    973     }
    974 
    975     if (cp_port_index >= MAX_CP_PORTS) {
    976         printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS);
     1018    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
     1019
     1020    if (cp_port_index >= MAX_CP_PORTS)
     1021    {
     1022        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n",
     1023                 MAX_CP_PORTS);
     1024        exit(1);
    9771025    }
    9781026
    … …  
    9841032    cp_port_vobj_ref[cp_port_index] = (vobj_ref_t *) malloc(sizeof(vobj_ref_t));
    9851033
    986 
    987 
    9881034    ///////// get direction attribute
    9891035    str = getStringValue(reader, "direction", &ok);
    990     if (ok) {
     1036    if (ok)
     1037    {
    9911038#if XML_PARSER_DEBUG
    9921039        printf("      direction = %s\n", str);
    9931040#endif
    994         if (strcmp(str, "TO_COPROC")   ==  0) {
     1041        if (strcmp(str, "TO_COPROC")   ==  0)
     1042        {
    9951043            cp_port[cp_port_index]->direction = PORT_TO_COPROC;
    9961044        }
    997         else if (strcmp(str, "FROM_COPROC") ==  0) {
     1045        else if (strcmp(str, "FROM_COPROC") ==  0)
     1046        {
    9981047            cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
    9991048        }
    1000         else {
     1049        else
     1050        {
    10011051            printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
    10021052                    cp_port_index, cluster_index);
    … …  
    10041054        }
    10051055    } 
    1006     else {
     1056    else
     1057    {
    10071058        printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
    10081059                cp_port_index, cluster_index);
    … …  
    10151066    printf("      vspacename = %s\n", str);
    10161067#endif
    1017     if (ok) {
     1068    if (ok)
     1069    {
    10181070        strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
    10191071    }
    1020     else {
     1072    else
     1073    {
    10211074        printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
    10221075                cp_port_index, cluster_index);
    … …  
    10291082    printf("      vobjname = %s\n", str);
    10301083#endif
    1031     if (ok) {
     1084    if (ok)
     1085    {
    10321086        strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
    10331087    }
    1034     else {
     1088    else
     1089    {
    10351090        printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
    10361091                cp_port_index, cluster_index);
    10371092        exit(1);
    10381093    }
    1039 
    10401094    cp_port_index++;
    10411095    cp_port_loc_index++;
    1042 
    10431096} // end cpPortNode()
    1044 
    10451097
    10461098////////////////////////////////////////
    … …  
    10511103    unsigned int ok;
    10521104
    1053     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     1105    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    10541106
    10551107    if (periph_index >= MAX_PERIPHS)
    10561108    {
    10571109        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
     1110        exit(1);
    10581111    }
    10591112
    … …  
    11941247                cma_channels = periph[periph_index]->channels;
    11951248            }
    1196             else if (header->nic_cluster_bis == 0xFFFFFFFF)
     1249            else if (header->cma_cluster_bis == 0xFFFFFFFF)
    11971250            {
    11981251                header->cma_cluster_bis = cluster_index;
    … …  
    12211274        }
    12221275        // The TIM, ICU, XICU, DMA, MEMC peripherals are replicated in all clusters
    1223         // but only one component per cluster
     1276        // but it must exist only one component of each type per cluster
    12241277        else if (strcmp(str, "TIM") == 0 )
    12251278        {
    12261279            periph[periph_index]->type = PERIPH_TYPE_TIM;
    1227             if (found_timer || use_xicu)  error = 1;
     1280            if (found_timer || use_xcu)  error = 1;
    12281281            found_timer = 1;
    12291282            if (tim_channels < periph[periph_index]->channels)
    … …  
    12351288        {
    12361289            periph[periph_index]->type = PERIPH_TYPE_ICU;
    1237             if (found_icu)  error = 1;
     1290            if (found_icu || use_xcu)  error = 1;
    12381291            found_icu = 1;
    12391292        }
    1240         else if (strcmp(str, "XICU") == 0)
    1241         {
    1242             periph[periph_index]->type = PERIPH_TYPE_ICU;
     1293        else if (strcmp(str, "XCU") == 0)
     1294        {
     1295            periph[periph_index]->type = PERIPH_TYPE_XCU;
    12431296            if (found_icu || found_timer)  error = 1;
    1244             found_icu = 1;
    1245             if (tim_channels == 0)
    1246             {
    1247                 tim_channels = 32;
    1248             }
    1249             use_xicu = 1;
     1297            found_xcu    = 1;
     1298            found_timer  = 1;
     1299            tim_channels = 32;
     1300            use_xcu      = 1;
    12501301        }
    12511302        else if (strcmp(str, "DMA") == 0)
    … …  
    12911342} // end periphNode
    12921343
    1293 
    1294 /////////////////////////////////////////
    1295 void coprocNode(xmlTextReaderPtr reader) {
     1344////////////////////////////////////////
     1345void coprocNode(xmlTextReaderPtr reader)
     1346{
    12961347    char * str;
    12971348    unsigned int ok;
    … …  
    12991350    cp_port_loc_index = 0;
    13001351
    1301     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1302         return;
    1303     }
    1304 
    1305     if (coproc_index >= MAX_COPROCS) {
     1352    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
     1353
     1354    if (coproc_index >= MAX_COPROCS)
     1355    {
    13061356        printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
     1357        exit(1);
    13071358    }
    13081359
    … …  
    13151366    /////////// get name attribute
    13161367    str = getStringValue(reader, "name", &ok);
    1317     if (ok) {
     1368    if (ok)
     1369    {
    13181370#if XML_PARSER_DEBUG
    13191371        printf("      name = %s\n", str);
    … …  
    13211373        strncpy(coproc[coproc_index]->name, str, 31);
    13221374    }
    1323     else {
     1375    else
     1376    {
    13241377        printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
    13251378                coproc_index, cluster_index);
    … …  
    13291382    /////////// get psegname attribute
    13301383    str = getStringValue(reader, "psegname", &ok);
    1331     if (ok == 0) {
     1384    if (ok == 0)
     1385    {
    13321386        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
    13331387                coproc_index, cluster_index);
    … …  
    13371391    /////////// set psegid attribute
    13381392    int index = getPsegId(cluster_index, str);
    1339     if (index >= 0) {
     1393    if (index >= 0)
     1394    {
    13401395#if XML_PARSER_DEBUG
    13411396        printf("      clusterid = %d\n", cluster_index);
    … …  
    13461401        assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" );
    13471402    }
    1348     else {
     1403    else
     1404    {
    13491405        printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n",
    13501406                coproc_index, cluster_index, str );
    … …  
    13601416
    13611417    int status = xmlTextReaderRead(reader);
    1362     while (status == 1) {
     1418    while (status == 1)
     1419    {
    13631420        const char * tag = (const char *) xmlTextReaderConstName(reader);
    13641421
    1365         if (strcmp(tag, "port") == 0 ) {
     1422        if (strcmp(tag, "port") == 0 )
     1423        {
    13661424            cpPortNode(reader);
    13671425        }
    13681426        else if (strcmp(tag, "#text")    == 0 ) { }
    13691427        else if (strcmp(tag, "#comment") == 0 ) { }
    1370         else if (strcmp(tag, "coproc") == 0 ) {
     1428        else if (strcmp(tag, "coproc") == 0 )
     1429        {
    13711430            coproc[coproc_index]->ports = cp_port_loc_index;
    13721431            cluster[cluster_index]->coprocs++;
    … …  
    13751434            return;
    13761435        }
    1377         else {
     1436        else
     1437        {
    13781438            printf("[XML ERROR] Unknown tag %s", tag);
    13791439            exit(1);
    … …  
    13841444
    13851445
    1386 ///////////////////////////////////////
    1387 void irqNode(xmlTextReaderPtr reader) {
     1446/////////////////////////////////////
     1447void irqNode(xmlTextReaderPtr reader)
     1448{
    13881449    unsigned int ok;
    13891450    unsigned int value;
    13901451    char * str;
    13911452
    1392     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1393         return;
    1394     }
     1453    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    13951454
    13961455    if (irq_index >= MAX_IRQS) {
    … …  
    14061465    ///////// get type attribute
    14071466    str = getStringValue(reader, "type", &ok);
    1408     if (ok) {
     1467    if (ok)
     1468    {
    14091469#if XML_PARSER_DEBUG
    14101470        printf("        type    = %s\n", str);
    14111471#endif
    1412         if (strcmp(str, "HARD") == 0 ) {
    1413             irq[irq_index]->type = 0;
    1414         }
    1415         else {
    1416             irq[irq_index]->type = 1;
    1417         }
    1418     }
    1419     else {
     1472        if (strcmp(str, "HARD") == 0 ) irq[irq_index]->type = 0;
     1473        else                           irq[irq_index]->type = 1;
     1474    }
     1475    else
     1476    {
    14201477        printf("[XML ERROR] missing IRQ <type> for processor %d in cluster %d\n",
    14211478                cluster_index, proc_loc_index);
    … …  
    14251482    ///////// get icuid attribute
    14261483    value = getIntValue(reader, "icuid", &ok);
    1427     if (ok) {
     1484    if (ok)
     1485    {
    14281486#if XML_PARSER_DEBUG
    14291487        printf("        icuid   = %d\n", value);
    14301488#endif
    14311489        irq[irq_index]->icuid = value;
    1432         if (value >= 32) {
     1490        if (value >= 32)
     1491        {
    14331492            printf("[XML ERROR] IRQ <icuid> too large for processor %d in cluster %d\n",
    14341493                    cluster_index, proc_loc_index);
    … …  
    14361495        }
    14371496    }
    1438     else {
     1497    else
     1498    {
    14391499        printf("[XML ERROR] missing IRQ <icuid> for processor %d in cluster %d\n",
    14401500                cluster_index, proc_loc_index);
    … …  
    14441504    ///////// get isr attribute
    14451505    str = getStringValue(reader, "isr", &ok);
    1446     if (ok) {
     1506    if (ok)
     1507    {
    14471508#if XML_PARSER_DEBUG
    14481509        printf("        isr     = %s\n", str);
    … …  
    14531514        else if (strcmp(str, "ISR_TTY"    ) == 0) { irq[irq_index]->isr = ISR_TTY; }
    14541515        else if (strcmp(str, "ISR_TIMER"  ) == 0) { irq[irq_index]->isr = ISR_TIMER; }
    1455         else {
     1516        else
     1517        {
    14561518            printf("[XML ERROR] illegal IRQ <isr> for processor %d in cluster %d\n",
    14571519                    cluster_index, proc_loc_index);
    … …  
    14621524#endif
    14631525    } 
    1464     else {
     1526    else
     1527    {
    14651528        printf("[XML ERROR] missing IRQ <isr> for processor %d in cluster %d\n",
    14661529                cluster_index, proc_loc_index);
    … …  
    14701533    ///////// get channel attribute (optionnal : 0 if missing)
    14711534    value = getIntValue(reader, "channel", &ok);
    1472     if (ok) {
     1535    if (ok)
     1536    {
    14731537#if XML_PARSER_DEBUG
    14741538        printf("        channel = %d\n", value);
    … …  
    14761540        irq[irq_index]->channel = value;
    14771541    }
    1478     else {
     1542    else
     1543    {
    14791544        irq[irq_index]->channel = 0;
    14801545    }
    … …  
    14861551
    14871552
    1488 /////////////////////////////////////////
    1489 void procNode(xmlTextReaderPtr reader) {
     1553//////////////////////////////////////
     1554void procNode(xmlTextReaderPtr reader)
     1555{
    14901556    unsigned int ok;
    14911557    unsigned int value;
    … …  
    14931559    irq_loc_index = 0;
    14941560
    1495     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1496         return;
    1497     }
    1498 
    1499     if (proc_index >= MAX_PROCS) {
     1561    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
     1562
     1563    if (proc_index >= MAX_PROCS)
     1564    {
    15001565        printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
     1566        exit(1);
    15011567    }
    15021568
    … …  
    15061572
    15071573    proc[proc_index] = (mapping_proc_t *) malloc(sizeof(mapping_proc_t));
    1508 
    15091574
    15101575    /////////// get index attribute (optional)
    15111576    value = getIntValue(reader, "index", &ok);
    1512     if (ok && (value != proc_loc_index)) {
     1577    if (ok && (value != proc_loc_index))
     1578    {
    15131579        printf("[XML ERROR] wrong proc index / expected value is %d",
    15141580                proc_loc_index);
    … …  
    15241590
    15251591    int status = xmlTextReaderRead(reader);
    1526     while (status == 1) {
     1592    while (status == 1)
     1593    {
    15271594        const char * tag = (const char *) xmlTextReaderConstName(reader);
    15281595
    1529         if (strcmp(tag, "irq") == 0) {
     1596        if (strcmp(tag, "irq") == 0)
     1597        {
    15301598            irqNode(reader);
    15311599        }
    15321600        else if (strcmp(tag, "#text")    == 0) { }
    15331601        else if (strcmp(tag, "#comment") == 0) { }
    1534         else if (strcmp(tag, "proc")     == 0) {
     1602        else if (strcmp(tag, "proc")     == 0)
     1603        {
    15351604            proc[proc_index]->irqs = irq_loc_index;
    15361605            cluster[cluster_index]->procs++;
    … …  
    15391608            return;
    15401609        }
    1541         else {
     1610        else
     1611        {
    15421612            printf("[XML ERROR] Unknown tag %s", tag);
    15431613            exit(1);
    … …  
    15481618
    15491619
    1550 //////////////////////////////////////////
    1551 void psegNode(xmlTextReaderPtr reader) {
     1620//////////////////////////////////////
     1621void psegNode(xmlTextReaderPtr reader)
     1622{
    15521623    unsigned int ok;
    15531624    paddr_t      ll_value;
    15541625    char * str;
    15551626
    1556     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1557         return;
    1558     }
    1559 
    1560     if (pseg_index >= MAX_PSEGS) {
     1627    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
     1628
     1629    if (pseg_index >= MAX_PSEGS)
     1630    {
    15611631        printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
    15621632        exit(1);
    … …  
    15741644    printf("      name = %s\n", str);
    15751645#endif
    1576     if (ok) {
     1646    if (ok)
     1647    {
    15771648        strncpy(pseg[pseg_index]->name, str, 31);
    15781649    }
    1579     else {
     1650    else
     1651    {
    15801652        printf("[XML ERROR] illegal or missing <name> for pseg %d in cluster %d\n",
    15811653                pseg_index, cluster_index);
    … …  
    15911663    else if (ok && (strcmp(str, "ROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
    15921664    else if (ok && (strcmp(str, "PERI") == 0)) { pseg[pseg_index]->type = PSEG_TYPE_PERI; }
    1593     else {
     1665    else
     1666    {
    15941667        printf("[XML ERROR] illegal or missing <type> for pseg %s in cluster %d\n",
    15951668                pseg[pseg_index]->name, cluster_index);
    … …  
    16021675    printf("      base = 0x%llx\n", ll_value);
    16031676#endif
    1604     if (ok) {
     1677    if (ok)
     1678    {
    16051679        pseg[pseg_index]->base = ll_value;
    16061680    }
    … …  
    16161690    printf("      length = 0x%llx\n", ll_value);
    16171691#endif
    1618     if (ok) {
     1692    if (ok)
     1693    {
    16191694        pseg[pseg_index]->length = ll_value;
    16201695    } 
    1621     else {
     1696    else
     1697    {
    16221698        printf("[XML ERROR] illegal or missing <length> for pseg %s in cluster %d\n",
    16231699                pseg[pseg_index]->name, cluster_index);
    … …  
    16591735    found_timer = 0;
    16601736    found_icu   = 0;
     1737    found_xcu   = 0;
    16611738    found_dma   = 0;
    16621739    found_mmc   = 0;
    … …  
    16671744
    16681745    // checking source file consistency
    1669     if (cluster_index >= header->clusters) {
     1746    if (cluster_index >= header->clusters)
     1747    {
    16701748        printf("[XML ERROR] The cluster index is too large : %d\n", cluster_index);
    16711749        exit(1);
    … …  
    16791757    /////////// check cluster index attribute (optional)
    16801758    value = getIntValue(reader, "index", &ok);
    1681     if (ok && (value != cluster_index)) {
     1759    if (ok && (value != cluster_index))
     1760    {
    16821761        printf("[XML ERROR] wrong cluster index / expected value is %d",
    16831762                cluster_index);
    … …  
    17141793        {
    17151794
    1716             ////////////////// peripherals checks /////////////////////////
    1717             if ((found_timer  && use_xicu) || (!found_timer  && !use_xicu))
    1718             {
    1719                 printf("[XML ERROR] illegal or missing timer peripheral in cluster %d\n", cluster_index);
     1795            ///////// TIMER and ICU peripheral are mandatory //////////////
     1796            if (!found_timer && !found_xcu)
     1797            {
     1798                printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index);
    17201799                exit(1);
    17211800            }
    17221801
    1723             if (!found_icu)
    1724             {
    1725                 printf("[XML ERROR] illegal or missing icu peripheral in cluster %d\n", cluster_index);
     1802            if (!found_icu && !found_xcu)
     1803            {
     1804                printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index);
    17261805                exit(1);
    17271806            }
    1728 
    1729             if (!found_dma)
    1730             {
    1731                 printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
    1732                 exit(1);
    1733             }
    1734 
    17351807
    17361808            if (nb_proc_max < cluster[cluster_index]->procs)
    … …  
    17571829void clusterSetNode(xmlTextReaderPtr reader)
    17581830{
    1759     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     1831    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    17601832
    17611833#if XML_PARSER_DEBUG
    … …  
    17981870            return;
    17991871        }
    1800         else {
     1872        else
     1873        {
    18011874            printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
    18021875            exit(1);
    … …  
    18071880
    18081881
    1809 /////////////////////////////////////////////
    1810 void globalSetNode(xmlTextReaderPtr reader) {
    1811     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    1812         return;
    1813     }
     1882///////////////////////////////////////////
     1883void globalSetNode(xmlTextReaderPtr reader)
     1884{
     1885    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    18141886
    18151887#if XML_PARSER_DEBUG
    … …  
    18251897        else if (strcmp(tag, "#text")     == 0) { }
    18261898        else if (strcmp(tag, "#comment")  == 0) { }
    1827         else if (strcmp(tag, "globalset") == 0) {
     1899        else if (strcmp(tag, "globalset") == 0)
     1900        {
    18281901#if XML_PARSER_DEBUG
    18291902            printf("  end global set\n\n");
    … …  
    18331906            return;
    18341907        }
    1835         else {
     1908        else
     1909        {
    18361910            printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
    18371911            exit(1);
    … …  
    18421916
    18431917
    1844 /////////////////////////////////////////////
    1845 void vspaceSetNode(xmlTextReaderPtr reader) {
     1918///////////////////////////////////////////
     1919void vspaceSetNode(xmlTextReaderPtr reader)
     1920{
    18461921    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
    18471922        return;
    … …  
    18611936        else if (strcmp(tag, "#text"    ) == 0 ) { }
    18621937        else if (strcmp(tag, "#comment" ) == 0 ) { }
    1863         else if (strcmp(tag, "vspaceset") == 0 ) {
     1938        else if (strcmp(tag, "vspaceset") == 0 )
     1939        {
    18641940            // checking source file consistency
    1865             if (vspace_index != header->vspaces) {
     1941            if (vspace_index != header->vspaces)
     1942            {
    18661943                printf("[XML ERROR] Wrong number of vspaces\n");
    18671944                exit(1);
    18681945            }
    1869             else {
     1946            else
     1947            {
    18701948                header->vsegs = vseg_index;
    18711949                header->vobjs = vobj_index;
    … …  
    18741952            }
    18751953        }
    1876         else {
     1954        else
     1955        {
    18771956            printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
    18781957            exit(1);
    … …  
    18831962
    18841963
    1885 //////////////////////////////////////////
     1964////////////////////////////////////////
    18861965void headerNode(xmlTextReaderPtr reader)
    18871966{
    … …  
    18901969    unsigned int ok;
    18911970
    1892     if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; }
     1971    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
    18931972
    18941973#if XML_PARSER_DEBUG
    … …  
    19001979    ////////// get name attribute
    19011980    name = getStringValue(reader, "name", &ok);
    1902     if (ok) {
     1981    if (ok)
     1982    {
    19031983#if XML_PARSER_DEBUG
    19041984        printf("  name = %s\n", name);
    … …  
    19061986        strncpy( header->name, name, 31);
    19071987    }
    1908     else {
     1988    else
     1989    {
    19091990        printf("[XML ERROR] illegal or missing <name> attribute in header\n");
    19101991        exit(1);
    … …  
    19131994    /////////// get cluster_x attribute
    19141995    cluster_x = getIntValue(reader, "cluster_x", &ok);
    1915     if (ok) {
     1996    if (ok)
     1997    {
    19161998#if XML_PARSER_DEBUG
    19171999        printf("  cluster_x = %d\n", cluster_x);
    … …  
    19192001        header->cluster_x = cluster_x;
    19202002    }
    1921     else {
     2003    else
     2004    {
    19222005        printf("[XML ERROR] illegal or missing <cluster_x> attribute in header\n");
    19232006        exit(1);
    … …  
    19262009    /////////// get cluster_y attribute
    19272010    cluster_y = getIntValue(reader, "cluster_y", &ok);
    1928     if (ok) {
     2011    if (ok)
     2012    {
    19292013#if XML_PARSER_DEBUG
    19302014        printf("  cluster_y = %d\n", cluster_y);
    … …  
    19322016        header->cluster_y = cluster_y;
    19332017    }
    1934     else {
     2018    else
     2019    {
    19352020        printf("[XML ERROR] illegal or missing <cluster_y> attribute in header\n");
    19362021        exit(1);
    … …  
    19392024    //check the number of cluster
    19402025    value = cluster_x * cluster_y;
    1941     if (value >= MAX_CLUSTERS) {
     2026    if (value >= MAX_CLUSTERS)
     2027    {
    19422028        printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
    19432029        exit(1);
    … …  
    19522038    ///////// get vspaces attribute
    19532039    value = getIntValue(reader, "vspaces", &ok);
    1954     if (ok) {
    1955         if (value >= MAX_VSPACES) {
     2040    if (ok)
     2041    {
     2042        if (value >= MAX_VSPACES)
     2043        {
    19562044            printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES);
    19572045            exit(1);
    … …  
    19622050        header->vspaces  = value;
    19632051    }
    1964     else {
     2052    else
     2053    {
    19652054        printf("[XML ERROR] illegal or missing <vspaces> attribute in mapping\n");
     2055        exit(1);
     2056    }
     2057
     2058    ///////// get increment attribute
     2059    value = getIntValue(reader, "increment", &ok);
     2060    if (ok)
     2061    {
     2062        if ( (value != 0x10000) && (value != 0x8000) &&
     2063             (value != 0x4000)  && (value != 0x2000) )
     2064       
     2065        {
     2066            printf("[XML ERROR] The vseg increment must be one of the following: ");
     2067            printf(" 0x00010000 / 0x00008000 / 0x00004000 / 0x00002000");
     2068            exit(1);
     2069        }
     2070#if XML_PARSER_DEBUG
     2071        printf("  increment = %d\n", value);
     2072#endif
     2073        header->increment  = value;
     2074    }
     2075    else
     2076    {
     2077        printf("[XML ERROR] illegal or missing <increment> attribute in mapping\n");
    19662078        exit(1);
    19672079    }
    … …  
    19852097
    19862098    int status = xmlTextReaderRead(reader);
    1987     while (status == 1) {
     2099    while (status == 1)
     2100    {
    19882101        const char * tag = (const char *) xmlTextReaderConstName(reader);
    19892102
    1990         if (strcmp(tag, "clusterset") == 0) {
     2103        if (strcmp(tag, "clusterset") == 0)
     2104        {
    19912105            clusterSetNode(reader);
    19922106        }
    … …  
    19952109        else if (strcmp(tag, "#text")        == 0) { }
    19962110        else if (strcmp(tag, "#comment")     == 0) { }
    1997         else if (strcmp(tag, "mapping_info") == 0) {
     2111        else if (strcmp(tag, "mapping_info") == 0)
     2112        {
    19982113#if XML_PARSER_DEBUG
    19992114            printf("end mapping_info\n");
    … …  
    20012116            return;
    20022117        }
    2003         else {
     2118        else
     2119        {
    20042120            printf("[XML ERROR] Unknown tag in header node : %s\n",tag);
    20052121            exit(1);
    … …  
    20122128///////////////////////////////////////
    20132129void BuildTable(int fdout, const char * type, unsigned int nb_elem,
    2014                 unsigned int elem_size, char ** table) {
     2130                unsigned int elem_size, char ** table)
     2131{
    20152132    unsigned int i;
    20162133    // write element
    … …  
    20272144}
    20282145
    2029 
    2030 int open_file(const char * file_path) {
    2031 
     2146/////////////////////////////////////
     2147int open_file(const char * file_path)
     2148{
    20322149    //open file
    20332150    int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) );
    2034     if (fdout < 0) {
     2151    if (fdout < 0)
     2152    {
    20352153        perror("open");
    20362154        exit(1);
    … …  
    20382156
    20392157    //reinitialise the file
    2040     if (ftruncate(fdout, 0)) {
     2158    if (ftruncate(fdout, 0))
     2159    {
    20412160        perror("truncate");
    20422161        exit(1);
    … …  
    20512170
    20522171
    2053 ///////////////////////////
    2054 void buildBin(const char * file_path) {
     2172/////////////////////////////////////
     2173void buildBin(const char * file_path)
     2174{
    20552175    unsigned int length;
    20562176
    20572177    int fdout = open_file(file_path);
     2178
     2179#if XML_PARSER_DEBUG
     2180printf("Building map.bin for %s\n", header->name);
     2181printf("signature = %x\n", header->signature);
     2182printf("clusters  = %d\n", header->clusters);
     2183printf("vspaces   = %d\n", header->vspaces);
     2184printf("psegs     = %d\n", header->psegs);
     2185printf("vobjs     = %d\n", header->vobjs);
     2186printf("vsegs     = %d\n", header->vsegs);
     2187printf("tasks     = %d\n", header->tasks);
     2188printf("procs     = %d\n", header->procs);
     2189printf("irqs      = %d\n", header->irqs);
     2190printf("coprocs   = %d\n", header->coprocs);
     2191printf("periphs   = %d\n", header->periphs);
     2192#endif
    20582193
    20592194    // write header to binary file
    20602195    length = write(fdout, (char *) header, sizeof(mapping_header_t));
    2061     if (length != sizeof(mapping_header_t)) {
     2196    if (length != sizeof(mapping_header_t))
     2197    {
    20622198        printf("write header error : length = %d \n", length);
    20632199        exit(1);
    … …  
    21602296    int fdout = open_file(file_path);
    21612297
    2162     char * prol   = "/* Generated from the mapping_info file */\n\n";
    2163     char * ifdef  = "#ifndef _HD_CONFIG_H\n#define _HD_CONFIG_H\n\n";
    2164     char * epil   = "\n#endif //_HD_CONFIG_H";
     2298    char prol[80];
     2299    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
     2300
     2301    char * ifdef  = "#ifndef _HARD_CONFIG_H\n#define _HARDD_CONFIG_H\n\n";
     2302    char * epil   = "\n#endif //_HARD_CONFIG_H";
    21652303
    21662304    file_write(fdout, prol);
    … …  
    21872325    file_write(fdout, "\n");
    21882326
    2189     def_int_write(fdout, "USE_XICU          ", use_xicu);
     2327    def_int_write(fdout, "USE_XICU          ", use_xcu);
    21902328    def_int_write(fdout, "USE_IOB           ", use_iob);
    21912329
    … …  
    22102348    unsigned int vseg_id;
    22112349
    2212     char * prol = "/* Generated from the mapping_info file */\n\n";
     2350    char prol[80];
     2351    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
     2352
    22132353    file_write(fdout, prol);
    22142354
    … …  
    22732413    file_write(fdout, "\n");
    22742414
     2415    // fill the peripheral base address array
     2416    set_periph_vbase_array();
     2417
    22752418    // non replicated peripherals
    22762419    ld_write(fdout, "seg_cma_base            ",   periph_vbase_array[PERIPH_TYPE_CMA]);
    … …  
    22852428
    22862429    // replicated peripherals
     2430    ld_write(fdout, "seg_xcu_base            ",   periph_vbase_array[PERIPH_TYPE_XCU]);
    22872431    ld_write(fdout, "seg_icu_base            ",   periph_vbase_array[PERIPH_TYPE_ICU]);
    22882432    ld_write(fdout, "seg_tim_base            ",   periph_vbase_array[PERIPH_TYPE_TIM]);
    22892433    ld_write(fdout, "seg_dma_base            ",   periph_vbase_array[PERIPH_TYPE_DMA]);
    22902434    ld_write(fdout, "seg_mmc_base            ",   periph_vbase_array[PERIPH_TYPE_MMC]);
     2435
     2436    file_write(fdout, "\n");
     2437
     2438    ld_write(fdout, "vseg_cluster_increment  ",   header->increment);
    22912439
    22922440    close(fdout);
    … …  
    23232471    }
    23242472
    2325 
    23262473    char * map_path = buildPath(argv[2], "map.bin");
    23272474    char * ld_path = buildPath(argv[2], "giet_vsegs.ld");
    … …  
    23332480    xmlTextReaderPtr reader = xmlReaderForFile(argv[1], NULL, 0);
    23342481
    2335     if (reader != NULL) {
     2482    if (reader != NULL)
     2483    {
    23362484        status = xmlTextReaderRead (reader);
    2337         while (status == 1) {
     2485        while (status == 1)
     2486        {
    23382487            const char * tag = (const char *) xmlTextReaderConstName(reader);
    23392488
    2340             if (strcmp(tag, "mapping_info") == 0) {
     2489            if (strcmp(tag, "mapping_info") == 0)
     2490            {
    23412491                headerNode(reader);
    23422492                prepareBuild();
    … …  
    23452495                genLd(ld_path);
    23462496            }
    2347             else {
     2497            else
     2498            {
    23482499                printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
    23492500                return 1;
    … …  
    23532504        xmlFreeTextReader(reader);
    23542505
    2355         if (status != 0) {
     2506        if (status != 0)
     2507        {
    23562508            printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
    23572509            return 1;
Note: See TracChangeset for help on using the changeset viewer.