source: soft/giet_vm/giet_xml/xml_parser.c @ 493

Last change on this file since 493 was 491, checked in by cfuguet, 10 years ago

genmap: add distributed ROM support

  • Generate the DROM address space segment that is used for the TSAR reconfiguration distributed ROM.
  • Property svn:executable set to *
File size: 87.2 KB
Line 
1//////////////////////////////////////////////////////////////////////////////////////
2// File     : xml_parser.c
3// Date     : 14/04/2012
4// Author   : alain greiner
5// Copyright (c) UPMC-LIP6
6///////////////////////////////////////////////////////////////////////////////////////
7// This program translate a "map.xml" source file to a binary file "map.bin" that
8// can be directly loaded in memory and used by the GIET-VM operating system.
9//
10// This map.xml file contains :
11// 1) the multi-cluster/multi-processors hardware architecture description
12// 2) the various multi-threaded software applications
13// 3) the mapping directives bor both the tasks and the virtual segments.
14// The corresponding C structures are defined in the "mapping_info.h" file.
15//
16// This parser also generates the "hard_config.h" and the "giet_vsegs.ld" files,
17// required  to compile the GIET-VM code.
18///////////////////////////////////////////////////////////////////////////////////////
19
20#include  <stdlib.h>
21#include  <fcntl.h>
22#include  <sys/types.h>
23#include  <sys/stat.h>
24#include  <unistd.h>
25#include  <stdio.h>
26#include  <string.h>
27#include  <assert.h>
28#include  <libxml/xmlreader.h>
29#include  <mapping_info.h>
30#include  <irq_handler.h>
31
32#define MAX_CLUSTERS   1024
33#define MAX_PSEGS      4096
34#define MAX_VSPACES    1024
35#define MAX_TASKS      4096
36#define MAX_MWMRS      4096
37#define MAX_VSEGS      4096
38#define MAX_VOBJS      8192
39#define MAX_PROCS      1024
40#define MAX_IRQS       8192
41#define MAX_COPROCS    4096
42#define MAX_CP_PORTS   8192
43#define MAX_PERIPHS    8192
44
45#define XML_PARSER_DEBUG  0
46
47///////////////////////////////////////////////////////////////////////////////////
48//     global variables used to store and index the data structures
49///////////////////////////////////////////////////////////////////////////////////
50
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
63
64// Index for the various arrays
65
66unsigned int cluster_index  = 0;
67unsigned int vspace_index = 0;
68unsigned int global_index = 0;
69unsigned int pseg_index = 0;       
70
71unsigned int proc_index = 0;
72unsigned int proc_loc_index = 0;
73
74unsigned int irq_index = 0;
75unsigned int irq_loc_index  = 0;
76
77unsigned int coproc_index = 0;
78unsigned int coproc_loc_index = 0;
79
80unsigned int cp_port_index = 0;
81unsigned int cp_port_loc_index = 0;
82
83unsigned int periph_index = 0;
84unsigned int periph_loc_index = 0;
85
86unsigned int vseg_index = 0;
87unsigned int vseg_loc_index = 0;
88
89unsigned int task_index = 0;
90unsigned int task_loc_index = 0;
91
92unsigned int vobj_index = 0;
93unsigned int vobj_loc_index = 0;
94unsigned int vobj_count = 0;
95
96
97//////////////////////////////
98// for replicated peripheral
99//////////////////////////////
100char found_timer = 0;
101char found_icu   = 0;
102char found_xcu   = 0;
103char found_dma   = 0;
104char found_mmc   = 0;
105
106////////////////////////////////////////////////////////////////////////
107// These variables are used to generate the hard_config.h file.
108////////////////////////////////////////////////////////////////////////
109
110unsigned int total_procs      = 0; // total number of processors
111unsigned int nb_procs_max     = 0; // max number of processors per cluster
112unsigned int nb_tasks_max     = 0; // max number of tasks (in all vspaces)
113
114unsigned int tim_channels     = 0; // number of user timers  (per cluster)
115unsigned int dma_channels     = 0; // number of DMA channels (per cluster)
116
117unsigned int tty_channels     = 0; // number of TTY channels
118unsigned int ioc_channels     = 0; // number of HBA channels
119unsigned int nic_channels     = 0; // number of NIC channels
120unsigned int cma_channels     = 0; // number of CMA channels
121unsigned int pic_channels     = 0; // number of PIC channels
122
123unsigned int use_iob          = 0; // using IOB component
124unsigned int use_pic          = 0; // using PIC component
125unsigned int use_xcu          = 0; // using XCU (not ICU)
126unsigned int use_fbf          = 0; // using Frame Buffer
127
128// These variables define the IOC peripheral subtype
129
130unsigned int use_hba          = 0; // using SoClib AHCI controller
131unsigned int use_bdv          = 0; // using SoCLIB block device controller
132unsigned int use_spi          = 0; // using SDCard-SPI
133
134////////////////////////////////////////////////////////////////
135// These variables are used to generate the giet_vseg.ld file
136////////////////////////////////////////////////////////////////
137
138unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE] 
139         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };
140
141//////////////////////////////////////////////////////////////////////
142// This arrray is useful to build a temporary list of vobj references.
143// The struct vobj_ref_s is formed by a vspace_name and a vobj_name.
144// This array is used to set the attribute vobj_id of a cp_port
145// once all the vspace have been parsed.
146/////////////////////////////////////////////////////////////////////
147typedef struct vobj_ref_s
148{
149    char vspace_name[32];
150    char vobj_name[32];
151} vobj_ref_t;
152
153vobj_ref_t * cp_port_vobj_ref[MAX_CP_PORTS];   
154
155
156//////////////////////////////////////////////////
157unsigned int getIntValue( xmlTextReaderPtr reader, 
158                          const char * attributeName, 
159                          unsigned int * ok) 
160{
161    unsigned int value = 0;
162    unsigned int i;
163    char c;
164
165    char * string = (char *) xmlTextReaderGetAttribute(reader, 
166                                (const xmlChar *) attributeName);
167
168    if (string == NULL) 
169    {
170        // missing argument
171        *ok = 0;
172        return 0;
173    }
174    else 
175    {
176        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) 
177        {
178            // Hexa
179            for (i = 2 ; (string[i] != 0) && (i < 10) ; i++) 
180            {
181                c = string[i];
182                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
183                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
184                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
185                else 
186                {
187                    *ok = 0;
188                    return 0;
189                }
190            }
191        }
192        else 
193        {
194            // Decimal
195            for (i = 0; (string[i] != 0) && (i < 9); i++) 
196            {
197                c = string[i];
198                if ((c >= '0') && (c <= '9')) value = (value * 10) + string[i] - 48;
199                else 
200                {
201                    *ok = 0;
202                    return 0;
203                }
204            }
205        }
206        *ok = 1;
207        return value; 
208    }
209} // end getIntValue()
210
211////////////////////////////////////////////////
212paddr_t getPaddrValue( xmlTextReaderPtr reader, 
213                       const char * attributeName, 
214                       unsigned int * ok) 
215{
216    paddr_t value = 0;
217    unsigned int i;
218    char c;
219
220    char * string = (char *) xmlTextReaderGetAttribute(reader, 
221                                (const xmlChar *) attributeName);
222
223    if (string == NULL) 
224    {
225        // missing argument
226        *ok = 0;
227        return 0;
228    }
229    else 
230    {
231        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) 
232        {
233            // Hexa
234            for (i = 2 ; (string[i] != 0) && (i < 18) ; i++) 
235            {
236                c = string[i];
237                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
238                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
239                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
240                else 
241                {
242                    *ok = 0;
243                    return 0;
244                }
245            }
246        }
247        else 
248        {
249            // Decimal not supported for paddr_t
250            *ok = 0;
251            return 0;
252        }
253        *ok = 1;
254        return value; 
255    }
256} // end getPaddrValue()
257
258////////////////////////////////////////////////
259char * getStringValue( xmlTextReaderPtr reader, 
260                       const char * attributeName, 
261                       unsigned int * ok ) 
262{
263    char * string = (char *) xmlTextReaderGetAttribute(reader, 
264                               (const xmlChar *) attributeName);
265
266
267    if (string == NULL) 
268    {
269        // missing argument
270        *ok = 0;
271        return NULL;
272    }
273    else 
274    {
275        //we read only string smaller than 32 byte
276        if (strlen(string) > 32) 
277        {
278            printf("[XML ERROR] all strings must be less than 32 bytes\n");
279            exit(1);
280        }
281
282        *ok = 1;
283        return string;
284    }
285} // end getStringValue()
286
287///////////////////////////////////////////////////////////////////////////////////
288// This function set the vbase addresses for all peripheral types, in order
289// to generate the ldscript file, that contains one single virtual address
290// for peripherals replicated in all clusters, and one virtual addresses for
291// each non replicated peripheral type.
292//
293// It makes the following checks on the virtual addresses:
294//
295// - For replicated peripherals the virtual base address must be:
296//   vbase = seg_type_base & 0XFF000000 + (cluster_xy * 0x00010000) & 0x00FF0000
297//
298// - For non-replicated peripherals, the cluster index must be cluster_io.
299///////////////////////////////////////////////////////////////////////////////////
300void set_periph_vbase_array()
301{
302    unsigned int vseg_id;      // vseg global index
303    unsigned int periph_id;    // periph global index
304    unsigned int pseg_id;      // pseg global index
305    unsigned int cluster_id;   // cluster linear index
306    unsigned int cluster_xy;   // cluster topological index
307    unsigned int type;         // peripheral type
308
309    unsigned int type_mask      = 0xFF000000;
310    unsigned int cluster_mask   = 0x00FF0000;
311    unsigned int vseg_increment = 0x00010000;
312
313#if XML_PARSER_DEBUG
314printf("\n set peripherals vbase array\n");
315#endif
316
317    // scan all vsegs
318    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
319    {
320        // keep only vseg corresponding to a periph       
321        if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI )
322        {
323            pseg_id = vseg[vseg_id]->psegid; 
324
325#if XML_PARSER_DEBUG
326printf(" - found vseg %s associated to pseg %d", vseg[vseg_id]->name, pseg_id );
327#endif
328
329            // scan all periphs to retrieve peripheral type (same psegid)
330            for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
331            {
332                if( periph[periph_id]->psegid == pseg_id ) // matching !!!
333                {
334                    cluster_id = pseg[pseg_id]->clusterid;
335                    type       = periph[periph_id]->type;
336
337#if XML_PARSER_DEBUG
338printf(" / matching periph type %d\n", type );
339#endif
340
341                    if ( (type == PERIPH_TYPE_DMA) ||
342                         (type == PERIPH_TYPE_MMC) ||
343                         (type == PERIPH_TYPE_XCU) )   // replicated peripheral
344                    {
345                        cluster_xy = (cluster[cluster_id]->x << header->y_width) +
346                                      cluster[cluster_id]->y;
347
348                        if( (vseg[vseg_id]->vbase & cluster_mask) != 
349                            (vseg_increment * cluster_xy) )
350                        {
351                            printf("[XML ERROR] All replicated peripherals "
352                                   "must have cluster bits = cluster_xy * increment\n");
353                            printf("periph index = %d / periph type = %d / vbase = %x\n",
354                                    periph_id, type, vseg[vseg_id]->vbase);
355                            exit(1);
356                        }
357                        else if ( periph_vbase_array[type] == 0xFFFFFFFF ) // vbase not set
358                        {
359                            periph_vbase_array[type] = vseg[vseg_id]->vbase & type_mask;   
360                        }
361                        else if ((vseg[vseg_id]->vbase & type_mask) != (periph_vbase_array[type]))
362                        {
363                            printf("[XML ERROR] All peripherals with same type"
364                                   " should share the same 8 MSB bits in vbase address\n");
365                            printf("periph index = %d / periph type = %d / vbase = %x\n",
366                                    periph_id, type, vseg[vseg_id]->vbase);
367                            exit(1);
368                        }
369                    }
370                    else                               // non replicated peripheral
371                    {
372                        if ( (cluster[cluster_id]->x == header->x_io) && 
373                             (cluster[cluster_id]->y == header->y_io) )   
374                        {
375                            periph_vbase_array[type] = vseg[vseg_id]->vbase;   
376                        }
377                        else
378                        {
379                            printf("[XML ERROR] Non replicated peripherals must be in cluster_io\n");
380                            printf(" periph index = %d / periph type = %d / vbase = %x"
381                                   " / pseg index = %d / cluster index = %d\n",
382                                    periph_id, type, vseg[vseg_id]->vbase, pseg_id, cluster_id);
383                            exit(1);
384                        }
385                    }
386                }
387            }
388        }   
389    }
390}  // end set_periph_vbase_array()
391
392///////////////////////////////////////////////////////////////
393int getClusterId( unsigned int x, unsigned int y )
394{
395    // associative search of cluster index
396    unsigned int cluster_id;
397
398    for( cluster_id = 0 ; cluster_id < (header->x_size * header->y_size) ; cluster_id++ )
399    {
400        if( (cluster[cluster_id]->x == x) && (cluster[cluster_id]->y == y) )
401        {
402            return cluster_id;
403        }
404    }
405    return -1;
406}  // end getClusterId()
407
408///////////////////////////////////////////////////////////////
409int getPsegId(unsigned int x, unsigned int y, char * pseg_name) 
410{
411    int cluster_id = getClusterId( x, y );
412
413    if ( cluster_id == -1 ) return -1;
414
415    // associative search for pseg index
416    unsigned int pseg_id;
417    unsigned int pseg_min = cluster[cluster_id]->pseg_offset;
418    unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs;
419
420    for (pseg_id = pseg_min; pseg_id < pseg_max; pseg_id++) 
421    {
422        if (strcmp(pseg[pseg_id]->name, pseg_name) == 0) 
423        {
424            return pseg_id;
425        }
426    }
427    return -1;
428}  // end getPsegId()
429
430///////////////////////////////////
431int getVspaceId(char * vspace_name) 
432{
433    unsigned int vspace_id;
434
435    for (vspace_id = 0; vspace_id < vspace_index; vspace_id++) 
436    {
437        if (strcmp(vspace[vspace_id]->name, vspace_name) == 0) 
438        {
439            return vspace_id;
440        }
441    }
442    return -1;
443}
444
445////////////////////////////////////////////////////////////////////////////////
446int getVobjId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max) 
447{
448    unsigned int vobj_id;
449    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
450    unsigned int vobj_max = vobj_min + vspace_max;
451
452    for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) 
453    {
454        if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return vobj_id;
455    }
456    return -1;
457}
458
459///////////////////////////////////////////////////////////
460unsigned int alignTo( unsigned int value, unsigned int pow2 )
461{
462    unsigned int mask = (1 << pow2) - 1;
463    return ( (value + mask) & ~mask);
464}
465
466////////////////////
467void setVsegLength()
468{
469    // for a given vseg identified vseg_index
470    // scan all contained vobjs to compute the vseg lenth
471
472    unsigned int vobj_id;
473    unsigned int cur_length = 0;
474
475    unsigned int first = vseg[vseg_index]->vobj_offset;
476    unsigned int last  = first + vseg[vseg_index]->vobjs;
477
478    for ( vobj_id = first ; vobj_id < last ; vobj_id++ ) 
479    {
480        if (vobj[vobj_id]->align)
481        {
482            cur_length = alignTo( cur_length, vobj[vobj_id]->align );
483        }
484        cur_length += vobj[vobj_id]->length;
485    }
486    vseg[vseg_index]->length = alignTo( cur_length, 12 );
487}
488
489///////////////////////
490void checkVsegOverlap()
491{
492    // for a given vseg identified by vseg_index,
493    // check overlap with all vsegs in same vspace,
494    // and check overlap with all global vsegs.
495
496    unsigned int vseg_id;
497    unsigned int prev_vbase;                          // previous vseg vbase
498    unsigned int prev_length;                         // previous vseg length
499
500    unsigned int vbase  = vseg[vseg_index]->vbase;    // new vseg vbase
501    unsigned int length = vseg[vseg_index]->length;   // new vseg length
502 
503    // checking overlap with other vsegs in same vspace
504    if ( header->vspaces > 0 )
505    {
506        unsigned int first = vspace[vspace_index]->vseg_offset;   
507        unsigned int last  = vseg_index;
508   
509        for( vseg_id = first ; vseg_id < last ; vseg_id++ )
510        {
511            prev_vbase  = vseg[vseg_id]->vbase;
512            prev_length = vseg[vseg_id]->length;
513            if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) )
514            { 
515                printf("[XML ERROR] vseg %s in vspace %s overlaps other vseg %s\n",
516                vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name );
517                exit(1);
518            }
519        }
520    }
521
522    // checking overlap with existing global vsegs
523    for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
524    {
525        prev_vbase  = vseg[vseg_id]->vbase;
526        prev_length = vseg[vseg_id]->length;
527        if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) )
528        { 
529            printf("[XML ERROR] vseg %s in vspace %s overlaps global vseg %s\n",
530            vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name );
531            exit(1);
532        }
533    }
534}
535
536//////////////////////////////////////
537void taskNode(xmlTextReaderPtr reader) 
538{
539    unsigned int ok;
540    unsigned int value;
541    unsigned int x,y;
542    char * str;
543
544    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
545
546    if (task_index >= MAX_TASKS) 
547    {
548        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
549        exit(1);
550    }
551
552#if XML_PARSER_DEBUG
553printf("   task %d\n", task_loc_index);
554#endif
555
556    task[task_index] = (mapping_task_t *) malloc(sizeof(mapping_task_t));
557
558    ////////// get name attribute
559    str = getStringValue(reader, "name", &ok);
560    if (ok) 
561    {
562#if XML_PARSER_DEBUG
563printf("      name      = %s\n", str);
564#endif
565        strncpy( task[task_index]->name, str, 31 );
566    }
567    else 
568    {
569        printf("[XML ERROR] illegal or missing <name> attribute for task (%d,%d)\n", 
570                vspace_index, task_loc_index);
571        exit(1);
572    }
573
574    ///////// get trdid attribute (optional)
575    task[task_index]->trdid = getIntValue(reader, "trdid", &ok);
576#if XML_PARSER_DEBUG
577printf("      trdid     = %d\n", x);
578#endif
579    if ( !ok ) 
580    {
581        task[task_index]->trdid = task_loc_index;
582    } 
583
584    ///////// get x coordinate
585    x = getIntValue(reader, "x", &ok);
586#if XML_PARSER_DEBUG
587printf("      x         = %d\n", x);
588#endif
589    if ( !(ok && (x < header->x_size)) ) 
590    {
591        printf("[XML ERROR] illegal or missing < x > attribute for task (%d,%d)\n",
592                vspace_index, task_loc_index);
593        exit(1);
594    } 
595
596    ///////// get y coordinate
597    y = getIntValue(reader, "y", &ok);
598#if XML_PARSER_DEBUG
599printf("      y         = %d\n", y);
600#endif
601    if ( !(ok && (y < header->y_size)) ) 
602    {
603        printf("[XML ERROR] illegal or missing < y > attribute for task (%d,%d)\n",
604                vspace_index, task_loc_index);
605        exit(1);
606    } 
607
608    ///////// set clusterid attribute
609    int index = getClusterId( x, y );
610#if XML_PARSER_DEBUG
611printf("      clusterid = %d\n", index);
612#endif
613    if( index >= 0 )
614    {
615        task[task_index]->clusterid = index;
616    }
617    else
618    {
619        printf("[XML ERROR] <clusterid> not found for task (%d,%d)\n",
620                vspace_index, task_loc_index);
621        exit(1);
622    }
623
624    ////////// get p attribute
625    value = getIntValue(reader, "p", &ok);
626    if (ok) 
627    {
628#if XML_PARSER_DEBUG
629printf("      proclocid = %x\n", value);
630#endif
631        if (value >= cluster[task[task_index]->clusterid]->procs) 
632        {
633            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
634                    vspace_index, task_loc_index);
635            exit(1);
636        }
637        task[task_index]->proclocid = value;
638    } 
639    else 
640    {
641        printf("[XML ERROR] illegal or missing <p> attribute for task (%d,%d)\n", 
642                vspace_index, task_loc_index);
643        exit(1);
644    }
645
646    ////////// get stackname attribute
647    str = getStringValue(reader, "stackname" , &ok);
648    if (ok) 
649    {
650        int index = getVobjId(vspace_index, str , vobj_loc_index);
651        if (index >= 0) 
652        {
653#if XML_PARSER_DEBUG
654printf("      stackname = %s\n", str);
655printf("      stack_id  = %d\n", index);
656#endif
657            task[task_index]->stack_vobj_id = index;
658        }
659        else 
660        {
661            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
662                    vspace_index, task_loc_index);
663            exit(1);
664        }
665    } 
666    else 
667    {
668        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
669                vspace_index, task_loc_index);
670        exit(1);
671    }
672
673    ////////// get heap attribute
674    str = getStringValue(reader, "heapname", &ok);
675    if (ok) 
676    {
677        int index = getVobjId(vspace_index, str, vobj_loc_index);
678        if (index >= 0) 
679        {
680#if XML_PARSER_DEBUG
681printf("      heapname  = %s\n", str);
682printf("      heap_id   = %d\n", index );
683#endif
684            task[task_index]->heap_vobj_id = index;
685        }
686        else 
687        {
688            printf("[XML ERROR] illegal or missing <heapname> for task (%d,%d)\n", 
689                   vspace_index, task_loc_index);
690            exit(1);
691        }
692    } 
693    else 
694    {
695        task[task_index]->heap_vobj_id = -1;
696    }
697
698    ////////// get startid  attribute
699    value = getIntValue(reader, "startid", &ok);
700    if (ok) 
701    {
702#if XML_PARSER_DEBUG
703printf("      startid   = %x\n", value);
704#endif
705        task[task_index]->startid = value;
706    } 
707    else 
708    {
709        printf("[XML ERROR] illegal or missing <startid> attribute for task (%d,%d)\n", 
710                vspace_index, task_loc_index);
711        exit(1);
712    }
713
714    task_index++;
715    task_loc_index++;
716} // end taskNode()
717
718//////////////////////////////////////
719void vobjNode(xmlTextReaderPtr reader) 
720{
721    unsigned int ok;
722    unsigned int value;
723    char * str;
724
725    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
726
727    if (vobj_index >= MAX_VOBJS) 
728    {
729        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VOBJS);
730        exit(1);
731    }
732
733#if XML_PARSER_DEBUG
734printf("      vobj %d\n", vobj_loc_index);
735#endif
736
737    vobj[vobj_index] = (mapping_vobj_t *) malloc(sizeof(mapping_vobj_t));
738
739    ///////// get name attribute
740    str = getStringValue(reader, "name", &ok);
741    if (ok) 
742    {
743#if XML_PARSER_DEBUG
744printf("        name = %s\n", str);
745#endif
746        strncpy(vobj[vobj_index]->name, str, 31);
747    }
748    else 
749    {
750        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n", 
751                vseg_index, vobj_loc_index);
752        exit(1);
753    }
754
755    //////// get type attribute
756    str = getStringValue(reader, "type", &ok);
757#if XML_PARSER_DEBUG
758printf("        type = %s\n", str);
759#endif
760
761    if      (ok && (strcmp(str, "ELF")      == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF;      }
762    else if (ok && (strcmp(str, "PERI")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI;     }
763    else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB;     }
764    else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB;     }
765    else if (ok && (strcmp(str, "MWMR")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MWMR;     }
766    else if (ok && (strcmp(str, "LOCK")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_LOCK;     }
767    else if (ok && (strcmp(str, "BUFFER")   == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;   }
768    else if (ok && (strcmp(str, "BARRIER")  == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;  }
769    else if (ok && (strcmp(str, "CONST")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_CONST;    }
770    else if (ok && (strcmp(str, "MEMSPACE") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MEMSPACE; }
771    else if (ok && (strcmp(str, "SCHED")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_SCHED;    }
772    else if (ok && (strcmp(str, "HEAP")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_HEAP;     }
773    else 
774    {
775        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
776                vspace_index, vobj_loc_index);
777        exit(1);
778    }
779    // some more checking
780    if ( (vobj[vobj_index]->type == VOBJ_TYPE_ELF) ||
781         (vobj[vobj_index]->type == VOBJ_TYPE_PERI) )
782    {
783        assert( (vobj_count == 0) && 
784        "[XML ERROR] an ELF or PERI vobj must be alone in a vseg");
785    }
786       
787
788    ////////// get length attribute
789    value = getIntValue(reader, "length", &ok);
790    if (ok) 
791    {
792#if XML_PARSER_DEBUG
793printf("        length = %x\n", value);
794#endif
795        vobj[vobj_index]->length = value;
796    } 
797    else {
798        printf("[XML ERROR] illegal or missing <length> attribute for vobj (%d,%d)\n", 
799                vspace_index, vobj_loc_index);
800        exit(1);
801    }
802
803    ////////// get align attribute (optional : 0 if missing)
804    value = getIntValue(reader, "align", &ok);
805    if (ok) 
806    {
807#if XML_PARSER_DEBUG
808printf("        align = %d\n", value);
809#endif
810        vobj[vobj_index]->align = value;
811    } 
812    else 
813    {
814        vobj[vobj_index]->align = 0;
815    }
816
817    ////////// get binpath attribute (optional : "" if missing)
818    str = getStringValue(reader, "binpath", &ok);
819    if (ok) 
820    {
821#if XML_PARSER_DEBUG
822printf("        binpath = %s\n", str);
823#endif
824        strncpy(vobj[vobj_index]->binpath, str, 63);
825    } 
826    else 
827    {
828        vobj[vobj_index]->binpath[0] = 0;
829    }
830
831    ////////// get init attribute (optional, mandatory for mwmr and barrier)
832    value = getIntValue(reader, "init", &ok);
833    if (ok) 
834    {
835#if XML_PARSER_DEBUG
836printf("        init  = %d\n", value);
837#endif
838        vobj[vobj_index]->init = value;
839    } 
840    else 
841    {
842        if ((vobj[vobj_index]->type == VOBJ_TYPE_MWMR) || 
843            (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) ||
844            (vobj[vobj_index]->type == VOBJ_TYPE_CONST)) 
845        {
846            printf("[XML ERROR] illegal or missing <value> attribute for vobj (%d,%d). \
847                    All MWMR or BARRIER or CONST vobj must have a init value \n", 
848                    vspace_index, vobj_loc_index);
849            exit(1);
850        }
851        vobj[vobj_index]->init = 0;
852    }
853
854    vobj_index++;
855    vobj_count++;
856    vobj_loc_index++;
857} // end vobjNode()
858
859//////////////////////////////////////
860void vsegNode(xmlTextReaderPtr reader) 
861{
862    unsigned int ok;
863    unsigned int value;
864    unsigned int x,y;
865    char * str;
866
867    vobj_count = 0;
868
869    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
870
871    if (vseg_index >= MAX_VSEGS) 
872    {
873        printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS);
874        exit(1);
875    }
876
877#if XML_PARSER_DEBUG
878printf("    vseg %d\n", vseg_loc_index);
879#endif
880
881    vseg[vseg_index] = (mapping_vseg_t *) malloc(sizeof(mapping_vseg_t));
882
883    ////////// set vobj_offset attribute
884    vseg[vseg_index]->vobj_offset = vobj_index;
885
886#if XML_PARSER_DEBUG
887printf("      vobj_offset = %d\n", vobj_index);
888#endif
889
890    ///////// set mapped attribute
891    vseg[vseg_index]->mapped = 0;
892
893    //////// set next_vseg attribute
894    vseg[vseg_index]->next_vseg = 0;
895 
896    ///////// get name attribute
897    str = getStringValue(reader, "name", &ok);
898    if (ok) 
899    {
900#if XML_PARSER_DEBUG
901printf("      name        = %s\n", str);
902#endif
903        strncpy( vseg[vseg_index]->name, str, 31);
904    }
905    else 
906    {
907        printf("[XML ERROR] illegal or missing <name> attribute for vseg (%d,%d)\n", 
908                vspace_index, vseg_loc_index);
909        exit(1);
910    }
911
912    ////////// get ident attribute (optional : 0 if missing)
913    value = getIntValue(reader, "ident", &ok);
914    if (ok) 
915    {
916#if XML_PARSER_DEBUG
917printf("      ident       = %d\n", value);
918#endif
919        vseg[vseg_index]->ident = value;
920    } 
921    else 
922    {
923        vseg[vseg_index]->ident = 0;
924    }
925
926    ////////// get local attribute (optional : 0 if missing)
927    value = getIntValue(reader, "local", &ok);
928    if (ok) 
929    {
930#if XML_PARSER_DEBUG
931printf("      local       = %d\n", value);
932#endif
933        vseg[vseg_index]->local = value;
934    } 
935    else 
936    {
937        vseg[vseg_index]->local = 0;
938    }
939
940    /////////// get vbase attribute
941    value = getIntValue(reader, "vbase", &ok);
942    if (ok) 
943    {
944#if XML_PARSER_DEBUG
945printf("      vbase       = 0x%x\n", value);
946#endif
947        vseg[vseg_index]->vbase = value;
948    }
949    else 
950    {
951        printf("[XML ERROR] illegal or missing <vbase> attribute for vseg (%d,%d)\n", 
952                vspace_index, vseg_loc_index);
953        exit(1);
954    }
955
956    ////////// get x coordinate
957    x = getIntValue(reader, "x", &ok);
958#if XML_PARSER_DEBUG
959printf("      x           = %d\n", x);
960#endif
961    if ( !(ok && (x < header->x_size)) ) 
962    {
963        printf("[XML ERROR] illegal or missing < x > attribute for vseg %d\n", 
964                vseg_loc_index);
965        exit(1);
966    }
967
968    ////////// get y coordinate
969    y = getIntValue(reader, "y", &ok);
970#if XML_PARSER_DEBUG
971printf("      y           = %d\n", y);
972#endif
973    if ( !(ok && (y < header->y_size)) ) 
974    {
975        printf("[XML ERROR] illegal or missing < y > attribute for vseg %d\n", 
976                vseg_loc_index);
977        exit(1);
978    }
979
980    ///////// get psegname attribute
981    str = getStringValue(reader, "psegname", &ok);
982#if XML_PARSER_DEBUG
983printf("      psegname    = %s\n", str);
984#endif
985    if (ok == 0) 
986    {
987        printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
988                vseg_loc_index);
989        exit(1);
990    }
991
992    /////////// set psegid field
993    int psegid = getPsegId( x, y, str );
994#if XML_PARSER_DEBUG
995printf("      psegid      = %d\n", psegid);
996#endif
997    if (psegid >= 0) 
998    {
999        vseg[vseg_index]->psegid = psegid;
1000    }
1001    else 
1002    {
1003        printf("[XML ERROR] pseg not found for vseg %d / x = %d / y = %d / psegname = %s\n", 
1004                vseg_loc_index, x, y, str );
1005        exit(1);
1006    } 
1007
1008    //////// get mode attribute
1009    str = getStringValue(reader, "mode", &ok);
1010#if XML_PARSER_DEBUG
1011printf("      mode        = %s\n", str);
1012#endif
1013    if      (ok && (strcmp(str, "CXWU") == 0)) { vseg[vseg_index]->mode = 0xF; }
1014    else if (ok && (strcmp(str, "CXW_") == 0)) { vseg[vseg_index]->mode = 0xE; }
1015    else if (ok && (strcmp(str, "CX_U") == 0)) { vseg[vseg_index]->mode = 0xD; }
1016    else if (ok && (strcmp(str, "CX__") == 0)) { vseg[vseg_index]->mode = 0xC; }
1017    else if (ok && (strcmp(str, "C_WU") == 0)) { vseg[vseg_index]->mode = 0xB; }
1018    else if (ok && (strcmp(str, "C_W_") == 0)) { vseg[vseg_index]->mode = 0xA; }
1019    else if (ok && (strcmp(str, "C__U") == 0)) { vseg[vseg_index]->mode = 0x9; }
1020    else if (ok && (strcmp(str, "C___") == 0)) { vseg[vseg_index]->mode = 0x8; }
1021    else if (ok && (strcmp(str, "_XWU") == 0)) { vseg[vseg_index]->mode = 0x7; }
1022    else if (ok && (strcmp(str, "_XW_") == 0)) { vseg[vseg_index]->mode = 0x6; }
1023    else if (ok && (strcmp(str, "_X_U") == 0)) { vseg[vseg_index]->mode = 0x5; }
1024    else if (ok && (strcmp(str, "_X__") == 0)) { vseg[vseg_index]->mode = 0x4; }
1025    else if (ok && (strcmp(str, "__WU") == 0)) { vseg[vseg_index]->mode = 0x3; }
1026    else if (ok && (strcmp(str, "__W_") == 0)) { vseg[vseg_index]->mode = 0x2; }
1027    else if (ok && (strcmp(str, "___U") == 0)) { vseg[vseg_index]->mode = 0x1; }
1028    else if (ok && (strcmp(str, "____") == 0)) { vseg[vseg_index]->mode = 0x0; }
1029    else {
1030        printf("[XML ERROR] illegal or missing <mode> attribute for vseg (%d,%d)\n", 
1031                vspace_index, vseg_loc_index);
1032        exit(1);
1033    }
1034
1035    ////////// get vobjs in vseg
1036    int status = xmlTextReaderRead(reader);
1037    while (status == 1) 
1038    {
1039        const char * tag = (const char *) xmlTextReaderConstName(reader);
1040
1041        if      (strcmp(tag, "vobj")     == 0 ) { vobjNode(reader); }
1042        else if (strcmp(tag, "#text"  )  == 0 ) { }
1043        else if (strcmp(tag, "#comment") == 0 ) { }
1044        else if (strcmp(tag, "vseg")     == 0 ) 
1045        {
1046            vseg[vseg_index]->vobjs = vobj_count;
1047            setVsegLength();
1048            checkVsegOverlap();
1049            vseg_index++;
1050            vseg_loc_index++;
1051            return;
1052        }
1053        else 
1054        {
1055            printf("[XML ERROR] Unknown tag %s", tag);
1056            exit(1);
1057        }
1058        status = xmlTextReaderRead (reader);
1059    }
1060} // end vsegNode()
1061
1062////////////////////////////////////////
1063void vspaceNode(xmlTextReaderPtr reader) 
1064{
1065    char * str;
1066    unsigned int ok;
1067    unsigned int nb_task_vspace = 0;
1068
1069    vobj_loc_index = 0;
1070    vseg_loc_index = 0;
1071    task_loc_index = 0;
1072
1073    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1074
1075#if XML_PARSER_DEBUG
1076printf("\n  vspace %d\n", vspace_index);
1077#endif
1078
1079    vspace[vspace_index] = (mapping_vspace_t *) malloc(sizeof(mapping_vspace_t));
1080    header->vspaces      = header->vspaces + 1;
1081
1082    ////////// get name attribute
1083    str = getStringValue(reader, "name", &ok);
1084    if (ok) {
1085#if XML_PARSER_DEBUG
1086printf("  name = %s\n", str);
1087#endif
1088        strncpy(vspace[vspace_index]->name, str, 31);
1089    }
1090    else 
1091    {
1092        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
1093                vspace_index);
1094        exit(1);
1095    }
1096
1097    ////////// set vseg_offset and task_offset attributes
1098    vspace[vspace_index]->vseg_offset = vseg_index;
1099    vspace[vspace_index]->vobj_offset = vobj_index;
1100    vspace[vspace_index]->task_offset = task_index;
1101
1102#if XML_PARSER_DEBUG
1103    printf("  vseg_offset = %d\n", vseg_index);
1104    printf("  vobj_offset = %d\n", vobj_index);
1105    printf("  task_offset = %d\n", task_index);
1106#endif
1107
1108    ////////// get startname attribute
1109    str = getStringValue(reader, "startname", &ok);
1110    if (ok) 
1111    {
1112        //used after parsing the vobjs
1113    }
1114    else 
1115    {
1116        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %s\n", 
1117                vspace[vspace_index]->name);
1118        exit(1);
1119    }
1120
1121    int status = xmlTextReaderRead(reader);
1122    while (status == 1) 
1123    {
1124        const char * tag = (const char *) xmlTextReaderConstName(reader);
1125
1126        if (strcmp(tag, "vseg") == 0) 
1127        {
1128            vsegNode(reader);
1129        }
1130        else if (strcmp(tag, "task") == 0) 
1131        {
1132            taskNode(reader);
1133            nb_task_vspace++;
1134        }
1135        else if (strcmp(tag, "#text")    == 0) { }
1136        else if (strcmp(tag, "#comment") == 0) { }
1137        else if (strcmp(tag, "vspace")   == 0) 
1138        {
1139            vspace[vspace_index]->vobjs = vobj_loc_index; 
1140            vspace[vspace_index]->tasks = task_loc_index ;
1141            vspace[vspace_index]->vsegs = vseg_loc_index ;
1142
1143            // get index of the vobj containing the start vector
1144            int index = getVobjId(vspace_index, str , vobj_loc_index);
1145            if (index == -1) 
1146            {
1147                printf("[XML ERROR] vobj containing start vector not found in vspace %s\n",
1148                        vspace[vspace_index]->name);
1149                exit(1);
1150            }
1151            else 
1152            {
1153                vspace[vspace_index]->start_vobj_id = index;
1154#if XML_PARSER_DEBUG
1155                printf("      startname = %s\n", str);
1156                printf("      start_id  = %d\n", index);
1157                printf("  end vspace %d\n\n", vspace_index);
1158#endif
1159            }
1160
1161            // checking for all tasks that the startid
1162            // is smaller than the number of tasks in vspace
1163            int task_id;
1164            int task_min = vspace[vspace_index]->task_offset;
1165            int task_max = task_min + vspace[vspace_index]->tasks; 
1166            for (task_id = task_min; task_id < task_max; task_id++) 
1167            {
1168                if (task[task_id]->startid >= vspace[vspace_index]->tasks) 
1169                {
1170                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
1171                            vspace_index, task_id );
1172                    exit(1);
1173                }
1174            }
1175
1176            nb_tasks_max += nb_task_vspace;
1177            vspace_index++;
1178            return;
1179        }
1180        else 
1181        {
1182            printf("[XML ERROR] Unknown tag %s", tag);
1183            exit(1);
1184        }
1185        status = xmlTextReaderRead(reader);
1186    }
1187} // end vspaceNode()
1188
1189/////////////////////////////////////
1190void irqNode(xmlTextReaderPtr reader) 
1191{
1192    unsigned int ok;
1193    unsigned int value;
1194    char * str;
1195
1196    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1197
1198    if (irq_index >= MAX_IRQS) 
1199    {
1200        printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS);
1201    }
1202
1203#if XML_PARSER_DEBUG
1204printf("      irq %d\n", irq_loc_index);
1205#endif
1206
1207    irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t));
1208
1209    ///////// get srcid attribute
1210    value = getIntValue(reader, "srcid", &ok);
1211    if (ok) 
1212    {
1213#if XML_PARSER_DEBUG
1214printf("        srcid   = %d\n", value);
1215#endif
1216        irq[irq_index]->srcid = value;
1217        if (value >= 32) 
1218        {
1219            printf("[XML ERROR] IRQ <srcid> too large for periph %d in cluster %d\n",
1220                    cluster_index, periph_loc_index);
1221            exit(1);
1222        }
1223    }
1224    else 
1225    {
1226        printf("[XML ERROR] missing IRQ <srcid> for periph %d in cluster %d\n",
1227                cluster_index, periph_loc_index);
1228        exit(1);
1229    }
1230
1231    ///////// get srctype attribute
1232    str = getStringValue(reader, "srctype", &ok);
1233    if (ok) 
1234    {
1235#if XML_PARSER_DEBUG
1236printf("        srctype = %s\n", str);
1237#endif
1238        if      ( strcmp(str, "HWI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_HWI;
1239        else if ( strcmp(str, "WTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_WTI;
1240        else if ( strcmp(str, "PTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_PTI;
1241        else   
1242        {
1243            printf("[XML ERROR] illegal IRQ <srctype> for periph %d in cluster %d\n",
1244                   cluster_index, periph_loc_index);
1245            exit(1);
1246        }
1247    }
1248    else 
1249    {
1250        printf("[XML ERROR] missing IRQ <srctype> for periph %d in cluster %d\n",
1251               cluster_index, periph_loc_index);
1252        exit(1);
1253    }
1254
1255    ///////// get isr attribute
1256    str = getStringValue(reader, "isr", &ok);
1257    if (ok) 
1258    {
1259#if XML_PARSER_DEBUG
1260printf("        isr     = %s\n", str);
1261#endif
1262        if      (strcmp(str, "ISR_TICK"   ) == 0)  irq[irq_index]->isr = ISR_TICK;
1263        else if (strcmp(str, "ISR_BDV"    ) == 0)  irq[irq_index]->isr = ISR_BDV;
1264        else if (strcmp(str, "ISR_CMA"    ) == 0)  irq[irq_index]->isr = ISR_CMA;
1265        else if (strcmp(str, "ISR_TTY_RX" ) == 0)  irq[irq_index]->isr = ISR_TTY_RX;
1266        else if (strcmp(str, "ISR_TTY_TX" ) == 0)  irq[irq_index]->isr = ISR_TTY_TX;
1267        else if (strcmp(str, "ISR_TIMER"  ) == 0)  irq[irq_index]->isr = ISR_TIMER;
1268        else if (strcmp(str, "ISR_WAKUP"  ) == 0)  irq[irq_index]->isr = ISR_WAKUP;
1269        else if (strcmp(str, "ISR_NIC_RX" ) == 0)  irq[irq_index]->isr = ISR_NIC_RX;
1270        else if (strcmp(str, "ISR_NIC_TX" ) == 0)  irq[irq_index]->isr = ISR_NIC_TX;
1271        else if (strcmp(str, "ISR_MMC"    ) == 0)  irq[irq_index]->isr = ISR_MMC;
1272        else if (strcmp(str, "ISR_DMA"    ) == 0)  irq[irq_index]->isr = ISR_DMA;
1273        else if (strcmp(str, "ISR_SPI"    ) == 0)  irq[irq_index]->isr = ISR_SPI;
1274        else if (strcmp(str, "ISR_DEFAULT") == 0)  irq[irq_index]->isr = ISR_DEFAULT;
1275        else 
1276        {
1277            printf("[XML ERROR] illegal IRQ <isr> for periph %d in cluster %d\n",
1278                   periph_loc_index, cluster_index );
1279            exit(1);
1280        }
1281    } 
1282    else 
1283    {
1284        printf("[XML ERROR] missing IRQ <isr> for periph %d in cluster %d\n",
1285                cluster_index, periph_loc_index);
1286        exit(1);
1287    }
1288
1289    ///////// get channel attribute (optionnal : 0 if missing)
1290    value = getIntValue(reader, "channel", &ok);
1291    if (ok) 
1292    {
1293#if XML_PARSER_DEBUG
1294printf("        channel = %d\n", value);
1295#endif
1296        irq[irq_index]->channel = value;
1297    }
1298    else 
1299    {
1300        irq[irq_index]->channel = 0;
1301    }
1302
1303    irq_index++;
1304    irq_loc_index++;
1305
1306} // end irqNode
1307
1308
1309
1310////////////////////////////////////////
1311void cpPortNode(xmlTextReaderPtr reader) 
1312{
1313    char * str;
1314    unsigned int ok;
1315
1316    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1317
1318    if (cp_port_index >= MAX_CP_PORTS) 
1319    {
1320        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", 
1321                 MAX_CP_PORTS);
1322        exit(1);
1323    }
1324
1325#if XML_PARSER_DEBUG
1326printf("\n  port %d\n", cp_port_index);
1327#endif
1328
1329    cp_port[cp_port_index] = (mapping_cp_port_t *) malloc(sizeof(mapping_cp_port_t));
1330    cp_port_vobj_ref[cp_port_index] = (vobj_ref_t *) malloc(sizeof(vobj_ref_t));
1331
1332    ///////// get direction attribute
1333    str = getStringValue(reader, "direction", &ok);
1334    if (ok) 
1335    {
1336#if XML_PARSER_DEBUG
1337printf("      direction = %s\n", str);
1338#endif
1339        if (strcmp(str, "TO_COPROC")   ==  0) 
1340        {
1341            cp_port[cp_port_index]->direction = PORT_TO_COPROC;
1342        }
1343        else if (strcmp(str, "FROM_COPROC") ==  0) 
1344        {
1345            cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
1346        }
1347        else 
1348        {
1349            printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
1350                    cp_port_index, cluster_index);
1351            exit(1);
1352        }
1353    } 
1354    else 
1355    {
1356        printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
1357                cp_port_index, cluster_index);
1358        exit(1);
1359    }
1360
1361    /////////// get vspacename attribute
1362    str = getStringValue(reader, "vspacename", &ok);
1363#if XML_PARSER_DEBUG
1364printf("      vspacename = %s\n", str);
1365#endif
1366    if (ok) 
1367    {
1368        strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
1369    }
1370    else 
1371    {
1372        printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
1373                cp_port_index, cluster_index);
1374        exit(1);
1375    }
1376
1377    /////////// get vobjname attribute
1378    str = getStringValue(reader, "vobjname", &ok);
1379#if XML_PARSER_DEBUG
1380printf("      vobjname = %s\n", str);
1381#endif
1382    if (ok) 
1383    {
1384        strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
1385    }
1386    else 
1387    {
1388        printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
1389                cp_port_index, cluster_index);
1390        exit(1);
1391    }
1392    cp_port_index++;
1393    cp_port_loc_index++;
1394} // end cpPortNode()
1395
1396////////////////////////////////////////
1397void periphNode(xmlTextReaderPtr reader) 
1398{
1399    char * str;
1400    unsigned int value;
1401    unsigned int ok;
1402
1403    irq_loc_index = 0;
1404
1405    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1406
1407    if (periph_index >= MAX_PERIPHS) 
1408    {
1409        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
1410        exit(1);
1411    }
1412
1413#if XML_PARSER_DEBUG
1414printf("\n    periph %d\n", periph_index);
1415#endif
1416
1417    periph[periph_index] = (mapping_periph_t *) malloc(sizeof(mapping_periph_t));
1418
1419    ///////// get channels attribute (optionnal : 1 if missing)
1420    value = getIntValue(reader, "channels", &ok);
1421    if (ok) 
1422    {
1423#if XML_PARSER_DEBUG
1424printf("      channels    = %d\n", value);
1425#endif
1426        periph[periph_index]->channels = value;
1427    }
1428    else 
1429    {
1430        periph[periph_index]->channels = 1;
1431    }
1432
1433    ///////// get arg attribute (optionnal : 0 if missing)
1434    value = getIntValue(reader, "arg", &ok);
1435    if (ok) 
1436    {
1437#if XML_PARSER_DEBUG
1438printf("      arg         = %d\n", value);
1439#endif
1440        periph[periph_index]->arg = value;
1441    }
1442    else 
1443    {
1444        periph[periph_index]->arg = 1;
1445    }
1446
1447    /////////// get psegname attribute
1448    str = getStringValue(reader, "psegname", &ok);
1449    if (ok == 0) 
1450    {
1451        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
1452                coproc_index, cluster_index);
1453        exit(1);
1454    }
1455
1456    /////////// set psegid attribute
1457    int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
1458    if (index >= 0) 
1459    {
1460#if XML_PARSER_DEBUG
1461printf("      clusterid   = %d\n", cluster_index);
1462printf("      psegname    = %s\n", str);
1463printf("      psegid      = %d\n", index);
1464#endif
1465        periph[periph_index]->psegid = index;
1466    }
1467    else 
1468    {
1469        printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n", 
1470                periph_loc_index, cluster_index, str );
1471        exit(1);
1472    } 
1473
1474    /////////// get type attribute
1475    str = getStringValue(reader, "type", &ok);
1476    if (ok) 
1477    {
1478#if XML_PARSER_DEBUG
1479printf("      type        = %s\n", str);
1480#endif
1481        unsigned int error = 0;
1482
1483        // initialize peripheral subtype
1484        periph[periph_index]->subtype = 0xFFFFFFFF;
1485
1486        // The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, PIC, DROM peripherals are not
1487        // replicated in all clusters but can be instanciated twice.
1488
1489        ////////////////////////////
1490        if (strcmp(str, "CMA") == 0) 
1491        {
1492            periph[periph_index]->type = PERIPH_TYPE_CMA;
1493            if ( cma_channels < periph[periph_index]->channels )
1494            {
1495                cma_channels = periph[periph_index]->channels;
1496            }
1497        }
1498        /////////////////////////////////
1499        else if (strcmp(str, "FBF") == 0) 
1500        {
1501            periph[periph_index]->type = PERIPH_TYPE_FBF;
1502            use_fbf = 1;
1503        }
1504        /////////////////////////////////
1505        else if (strcmp(str, "IOB") == 0) 
1506        {
1507            periph[periph_index]->type = PERIPH_TYPE_IOB;
1508            use_iob = 1;
1509        }
1510        /////////////////////////////////
1511        else if (strcmp(str, "IOC") == 0) 
1512        {
1513            char* subtype = getStringValue(reader, "subtype", &ok);
1514            if (!ok)
1515            {
1516                printf("[XML ERROR] IOC peripheral needs a subtype: BDV, HBA or SPI\n");
1517                exit(1);
1518            } 
1519
1520            if ( strcmp(subtype, "BDV") == 0 )
1521            {
1522                periph[periph_index]->type    = PERIPH_TYPE_IOC;
1523                periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV;
1524                ioc_channels = 1;
1525                if ( header->use_ram_disk == 0 ) use_bdv = 1;
1526            }
1527            else if ( strcmp(subtype, "HBA") == 0 )
1528            {
1529                periph[periph_index]->type    = PERIPH_TYPE_IOC;
1530                periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA;
1531                ioc_channels = periph[periph_index]->channels;
1532                if ( header->use_ram_disk == 0 ) use_hba = 1;
1533            }
1534            else if ( strcmp(subtype, "SPI") == 0 )
1535            {
1536                periph[periph_index]->type    = PERIPH_TYPE_IOC;
1537                periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI;
1538                ioc_channels = periph[periph_index]->channels;
1539                if ( header->use_ram_disk == 0 ) use_spi = 1;
1540            }
1541            else
1542            {
1543                printf("[XML ERROR] illegal subtype for IOC peripheral\n");
1544                exit(1);
1545            }
1546        } 
1547        /////////////////////////////////
1548        else if (strcmp(str, "NIC") == 0) 
1549        {
1550            periph[periph_index]->type = PERIPH_TYPE_NIC;
1551            if ( nic_channels < periph[periph_index]->channels )
1552            {
1553                nic_channels = periph[periph_index]->channels;
1554            }
1555        }
1556        /////////////////////////////////
1557        else if (strcmp(str, "ROM") == 0) 
1558        {
1559            periph[periph_index]->type = PERIPH_TYPE_ROM;
1560        } 
1561        /////////////////////////////////
1562        else if (strcmp(str, "SIM") == 0) 
1563        {
1564            periph[periph_index]->type = PERIPH_TYPE_SIM;
1565        } 
1566        /////////////////////////////////
1567        else if (strcmp(str, "TTY") == 0) 
1568        {
1569            periph[periph_index]->type = PERIPH_TYPE_TTY;
1570            if ( tty_channels < periph[periph_index]->channels )
1571            {
1572                tty_channels = periph[periph_index]->channels;
1573            }
1574        }
1575        /////////////////////////////////
1576        else if (strcmp(str, "PIC") == 0) 
1577        {
1578            periph[periph_index]->type = PERIPH_TYPE_PIC;
1579            if ( pic_channels < periph[periph_index]->channels )
1580            {
1581                pic_channels = periph[periph_index]->channels;
1582            }
1583            use_pic = 1;
1584        }
1585
1586
1587        // The DMA, MMC, XCU peripherals can be replicated in all clusters
1588        // but no more than one component of each type per cluster
1589
1590        /////////////////////////////////
1591        else if (strcmp(str, "DMA") == 0) 
1592        {
1593            periph[periph_index]->type = PERIPH_TYPE_DMA;
1594            if (found_dma)  error = 1; 
1595            found_dma = 1;
1596            if (dma_channels < periph[periph_index]->channels)
1597                dma_channels = periph[periph_index]->channels;
1598        }
1599        //////////////////////////////////
1600        else if (strcmp(str, "MMC") == 0) 
1601        {
1602            periph[periph_index]->type = PERIPH_TYPE_MMC;
1603            if (found_mmc)  error = 1; 
1604            found_mmc = 1;
1605            if ( periph[periph_index]->channels != 1 ) error = 1;
1606        }
1607        //////////////////////////////////
1608        else if (strcmp(str, "XCU") == 0) 
1609        {
1610            periph[periph_index]->type = PERIPH_TYPE_XCU;
1611            if (found_xcu || found_icu || found_timer)  error = 1; 
1612            found_xcu    = 1;
1613            found_timer  = 1;
1614            tim_channels = 32; 
1615            use_xcu      = 1;
1616
1617            if ( periph[periph_index]->channels < 
1618                 (header->irq_per_proc * cluster[cluster_index]->procs) )
1619            {
1620                printf("[XML ERROR] XCU channels smaller than PROCS * IRQ_PER_PROC\n");
1621                printf(" - xcu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n",
1622                       periph[periph_index]->channels, 
1623                       cluster[cluster_index]->procs, 
1624                       header->irq_per_proc );
1625                exit(1);
1626            }
1627        }
1628        /////////////////////////////////
1629        else if (strcmp(str, "DROM") == 0)
1630        {
1631            periph[periph_index]->type = PERIPH_TYPE_DROM;
1632        }
1633        else
1634        {
1635            printf("[XML ERROR] illegal peripheral type: %s in cluster %d\n",
1636                    str, cluster_index);
1637            exit(1);
1638        }
1639
1640        if (error) 
1641        {
1642            printf("[XML ERROR] illegal peripheral %s in cluster %d\n",
1643                    str, cluster_index);
1644            exit(1);
1645        }
1646    }
1647    else 
1648    {
1649        printf("[XML ERROR] illegal or missing <type> for peripheral  %d in cluster %d\n",
1650                periph_loc_index, cluster_index);
1651        exit(1);
1652    }
1653
1654    ////////////// set irq_offset attribute
1655    periph[periph_index]->irq_offset = irq_index;
1656
1657    ///////////// get IRQs
1658    int status = xmlTextReaderRead(reader);
1659    while (status == 1) 
1660    {
1661        const char * tag = (const char *) xmlTextReaderConstName(reader);
1662
1663        if (strcmp(tag, "irq") == 0) 
1664        {
1665            if ( (periph[periph_index]->type != PERIPH_TYPE_XCU) &&
1666                 (periph[periph_index]->type != PERIPH_TYPE_PIC) )
1667            {
1668                printf("[XML ERROR] periph %d in cluster(%d,%d) "
1669                       " only XCU and PIC can contain IRQs",
1670                periph_loc_index, cluster[cluster_index]->x, cluster[cluster_index]->y);
1671                exit(1);
1672            }
1673            else
1674            {
1675                  irqNode(reader);
1676            }
1677        }
1678        else if (strcmp(tag, "#text")    == 0) { }
1679        else if (strcmp(tag, "#comment") == 0) { }
1680        else if (strcmp(tag, "periph")   == 0) 
1681        {
1682            periph[periph_index]->irqs = irq_loc_index;
1683            cluster[cluster_index]->periphs++;
1684            periph_loc_index++;
1685            periph_index++;
1686
1687#if XML_PARSER_DEBUG
1688printf("      irqs        = %d\n", irq_loc_index);
1689printf("      irq_offset  = %d\n", irq_index);
1690#endif
1691            return;
1692        }
1693        else 
1694        {
1695            printf("[XML ERROR] Unknown tag %s", tag);
1696            exit(1);
1697        }
1698        status = xmlTextReaderRead(reader);
1699    }
1700} // end periphNode
1701
1702////////////////////////////////////////
1703void coprocNode(xmlTextReaderPtr reader) 
1704{
1705    char * str;
1706    unsigned int ok;
1707
1708    cp_port_loc_index = 0;
1709
1710    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1711
1712    if (coproc_index >= MAX_COPROCS) 
1713    {
1714        printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
1715        exit(1);
1716    }
1717
1718#if XML_PARSER_DEBUG
1719printf("\n  coproc %d\n", coproc_index);
1720#endif
1721
1722    coproc[coproc_index] = (mapping_coproc_t *) malloc(sizeof(mapping_coproc_t));
1723
1724    /////////// get name attribute
1725    str = getStringValue(reader, "name", &ok);
1726    if (ok) 
1727    {
1728#if XML_PARSER_DEBUG
1729printf("      name = %s\n", str);
1730#endif
1731        strncpy(coproc[coproc_index]->name, str, 31);
1732    }
1733    else 
1734    {
1735        printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
1736                coproc_index, cluster_index);
1737        exit(1);
1738    }
1739
1740    /////////// get psegname attribute
1741    str = getStringValue(reader, "psegname", &ok);
1742    if (ok == 0) 
1743    {
1744        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
1745                coproc_index, cluster_index);
1746        exit(1);
1747    }
1748
1749    /////////// set psegid attribute
1750    int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
1751    if (index >= 0) 
1752    {
1753#if XML_PARSER_DEBUG
1754printf("      clusterid = %d\n", cluster_index);
1755printf("      psegname  = %s\n", str);
1756printf("      psegid    = %d\n", index);
1757#endif
1758        coproc[coproc_index]->psegid = index;
1759        assert(pseg[index]->type == PSEG_TYPE_PERI && 
1760        "coproc psegname attribute must refer to a pseg of type PERI" );
1761    }
1762    else 
1763    {
1764        printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", 
1765                coproc_index, cluster_index, str );
1766        exit(1);
1767    } 
1768
1769    ////////// set port_offset
1770    coproc[coproc_index]->port_offset = cp_port_index;
1771
1772#if XML_PARSER_DEBUG
1773printf("      port_offset = %d\n", cp_port_index);
1774#endif
1775
1776    int status = xmlTextReaderRead(reader);
1777    while (status == 1) 
1778    {
1779        const char * tag = (const char *) xmlTextReaderConstName(reader);
1780
1781        if (strcmp(tag, "port") == 0 ) 
1782        {
1783            cpPortNode(reader);
1784        }
1785        else if (strcmp(tag, "#text")    == 0 ) { }
1786        else if (strcmp(tag, "#comment") == 0 ) { }
1787        else if (strcmp(tag, "coproc") == 0 ) 
1788        {
1789            coproc[coproc_index]->ports = cp_port_loc_index;
1790            cluster[cluster_index]->coprocs++;
1791            coproc_loc_index++;
1792            coproc_index++;
1793            return;
1794        }
1795        else 
1796        {
1797            printf("[XML ERROR] Unknown tag %s", tag);
1798            exit(1);
1799        }
1800        status = xmlTextReaderRead(reader);
1801    }
1802} // end coprocNode()
1803
1804
1805//////////////////////////////////////
1806void procNode(xmlTextReaderPtr reader) 
1807{
1808    unsigned int ok;
1809    unsigned int value;
1810
1811    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1812
1813    if (proc_index >= MAX_PROCS) 
1814    {
1815        printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
1816        exit(1);
1817    }
1818
1819#if XML_PARSER_DEBUG
1820printf("\n    proc %d\n", proc_index);
1821#endif
1822
1823    proc[proc_index] = (mapping_proc_t *) malloc(sizeof(mapping_proc_t));
1824
1825    /////////// get index attribute (optional)
1826    value = getIntValue(reader, "index", &ok);
1827    if (ok && (value != proc_loc_index)) 
1828    {
1829        printf("[XML ERROR] wrong local proc index / expected value is %d", 
1830                proc_loc_index);
1831        exit(1);
1832    }
1833    proc[proc_index]->index = proc_loc_index;
1834
1835    cluster[cluster_index]->procs++;
1836    proc_loc_index++;
1837    proc_index++;
1838    total_procs++;
1839} // end procNode()
1840
1841
1842//////////////////////////////////////
1843void psegNode(xmlTextReaderPtr reader) 
1844{
1845    unsigned int ok;
1846    paddr_t      ll_value;
1847    char * str;
1848
1849    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
1850
1851    if (pseg_index >= MAX_PSEGS) 
1852    {
1853        printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
1854        exit(1);
1855    }
1856
1857#if XML_PARSER_DEBUG
1858printf("    pseg %d\n", pseg_index);
1859#endif
1860
1861    pseg[pseg_index] = (mapping_pseg_t *) malloc(sizeof(mapping_pseg_t));
1862
1863    /////// get name attribute
1864    str = getStringValue(reader, "name", &ok);
1865#if XML_PARSER_DEBUG
1866printf("      name = %s\n", str);
1867#endif
1868    if (ok) 
1869    {
1870        strncpy(pseg[pseg_index]->name, str, 31);
1871    }
1872    else 
1873    {
1874        printf("[XML ERROR] illegal or missing <name> for pseg %d in cluster %d\n",
1875                pseg_index, cluster_index);
1876        exit(1);
1877    }
1878
1879    //////// get type attribute
1880    str = getStringValue(reader, "type", &ok);
1881#if XML_PARSER_DEBUG
1882printf("      type = %s\n", str);
1883#endif
1884    if      (ok && (strcmp(str, "RAM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_RAM; }
1885    else if (ok && (strcmp(str, "ROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
1886    else if (ok && (strcmp(str, "DROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
1887    else if (ok && (strcmp(str, "PERI") == 0)) { pseg[pseg_index]->type = PSEG_TYPE_PERI; }
1888    else 
1889    {
1890        printf("[XML ERROR] illegal or missing <type> for pseg %s in cluster %d\n",
1891                pseg[pseg_index]->name, cluster_index);
1892        exit(1);
1893    }
1894
1895    //////// get base attribute
1896    ll_value = getPaddrValue(reader, "base", &ok);
1897#if XML_PARSER_DEBUG
1898printf("      base = 0x%llx\n", ll_value);
1899#endif
1900    if (ok) 
1901    {
1902        pseg[pseg_index]->base = ll_value;
1903    }
1904    else {
1905        printf("[XML ERROR] illegal or missing <base> for pseg %s in cluster %d\n",
1906                pseg[pseg_index]->name, cluster_index);
1907        exit(1);
1908    }
1909
1910    //////// get length attribute
1911    ll_value = getPaddrValue(reader, "length", &ok);
1912#if XML_PARSER_DEBUG
1913printf("      length = 0x%llx\n", ll_value);
1914#endif
1915    if (ok) 
1916    {
1917        pseg[pseg_index]->length = ll_value;
1918    } 
1919    else 
1920    {
1921        printf("[XML ERROR] illegal or missing <length> for pseg %s in cluster %d\n",
1922                pseg[pseg_index]->name, cluster_index);
1923        exit(1);
1924    }
1925
1926    //////// set cluster attribute
1927    pseg[pseg_index]->clusterid = cluster_index;
1928
1929    //////// set next_vseg attribute
1930    pseg[pseg_index]->next_vseg = 0;
1931
1932    pseg_index++;
1933    cluster[cluster_index]->psegs++;
1934} // end psegNode()
1935
1936
1937/////////////////////////////////////////
1938void clusterNode(xmlTextReaderPtr reader) 
1939{
1940    unsigned int ok;
1941    unsigned int value;
1942
1943    cluster[cluster_index] = (mapping_cluster_t *) malloc(sizeof(mapping_cluster_t));
1944
1945    //initialise variables that will be incremented by *Node() functions
1946    cluster[cluster_index]->psegs = 0;
1947    cluster[cluster_index]->procs = 0;
1948    cluster[cluster_index]->coprocs = 0;
1949    cluster[cluster_index]->periphs = 0;
1950
1951    //initialise global variables
1952    proc_loc_index = 0;
1953    coproc_loc_index = 0;
1954    periph_loc_index = 0;
1955
1956    // for replicated periph
1957    found_timer = 0;
1958    found_icu   = 0;
1959    found_xcu   = 0;
1960    found_dma   = 0;
1961    found_mmc   = 0;
1962
1963    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT)  return;
1964
1965#if XML_PARSER_DEBUG
1966printf("\n  cluster %d\n", cluster_index);
1967#endif
1968
1969    /////////// get x coordinate
1970    value = getIntValue(reader, "x", &ok);
1971#if XML_PARSER_DEBUG
1972printf("    x             = %d\n", value);
1973#endif
1974    if (ok && (value < header->x_size) ) 
1975    {
1976        cluster[cluster_index]->x = value;
1977    }
1978    else
1979    {
1980        printf("[XML ERROR] Illegal or missing < x > attribute for cluster %d", 
1981                cluster_index);
1982        exit(1);
1983    }
1984
1985    /////////// get y coordinate
1986    value = getIntValue(reader, "y", &ok);
1987#if XML_PARSER_DEBUG
1988printf("    y             = %d\n", value);
1989#endif
1990    if (ok && (value < header->y_size) ) 
1991    {
1992        cluster[cluster_index]->y = value;
1993    }
1994    else
1995    {
1996        printf("[XML ERROR] Illegal or missing < y > attribute for cluster %d", 
1997                cluster_index);
1998        exit(1);
1999    }
2000
2001    ////////// set offsets
2002    cluster[cluster_index]->pseg_offset = pseg_index;
2003    cluster[cluster_index]->proc_offset = proc_index;
2004    cluster[cluster_index]->coproc_offset = coproc_index;
2005    cluster[cluster_index]->periph_offset = periph_index;
2006
2007#if XML_PARSER_DEBUG
2008printf("    pseg_offset   = %d\n", pseg_index);
2009printf("    proc_offset   = %d\n", proc_index);
2010printf("    coproc_offset = %d\n", coproc_index);
2011printf("    periph_offset = %d\n", coproc_index);
2012#endif
2013
2014    ////////// get psegs, procs, coprocs and periphs
2015    int status = xmlTextReaderRead(reader);
2016
2017    while (status == 1) 
2018    {
2019        const char * tag = (const char *) xmlTextReaderConstName(reader);
2020
2021        if      (strcmp(tag, "pseg")     == 0) psegNode(reader);
2022        else if (strcmp(tag, "proc")     == 0) procNode(reader);
2023        else if (strcmp(tag, "coproc")   == 0) coprocNode(reader);
2024        else if (strcmp(tag, "periph")   == 0) periphNode(reader);
2025        else if (strcmp(tag, "#text")    == 0) { }
2026        else if (strcmp(tag, "#comment") == 0) { }
2027        else if (strcmp(tag, "cluster")  == 0) 
2028        {
2029            ///////// TIMER and ICU peripheral are mandatory when nprocs != 0
2030
2031            unsigned int procs = cluster[cluster_index]->procs;
2032            if ( procs && !found_timer && !found_xcu)
2033            {
2034                printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index);
2035                exit(1);
2036            }
2037
2038            if ( procs && !found_icu && !found_xcu) 
2039            {
2040                printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index);
2041                exit(1);
2042            }
2043
2044            if (nb_procs_max < procs) nb_procs_max = procs;
2045
2046#if XML_PARSER_DEBUG
2047printf("    psegs   = %d\n", cluster[cluster_index]->psegs);
2048printf("    procs   = %d\n", cluster[cluster_index]->procs);
2049printf("    coprocs = %d\n", cluster[cluster_index]->coprocs);
2050printf("    periphs = %d\n", cluster[cluster_index]->periphs);
2051printf("    end cluster %d\n", cluster_index);
2052#endif
2053            cluster_index++;
2054            return;
2055        }
2056        status = xmlTextReaderRead(reader);
2057    }
2058} // end clusterNode()
2059
2060
2061//////////////////////////////////////////////
2062void clusterSetNode(xmlTextReaderPtr reader) 
2063{
2064    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
2065
2066#if XML_PARSER_DEBUG
2067printf("\n  clusters set\n");
2068#endif
2069
2070    int status = xmlTextReaderRead(reader);
2071    while (status == 1) 
2072    {
2073        const char * tag = (const char *) xmlTextReaderConstName(reader);
2074
2075        if      (strcmp(tag, "cluster")    == 0) { clusterNode(reader); }
2076        else if (strcmp(tag, "#text")      == 0) { }
2077        else if (strcmp(tag, "#comment")   == 0) { }
2078        else if (strcmp(tag, "clusterset") == 0) 
2079        {
2080            // checking number of clusters
2081            if ( cluster_index != (header->x_size * header->y_size) ) 
2082            {
2083                printf("[XML ERROR] Wrong number of clusters\n");
2084                exit(1);
2085            }
2086
2087            // checking TTY terminal for system boot
2088            if ( tty_channels == 0 )
2089            {
2090                printf("[XML ERROR] missing TTY peripheral\n");
2091                exit(1);
2092            }
2093
2094            // checking IOC sub-types
2095            if ( (use_bdv + use_hba + use_spi) > 1 )
2096            {
2097                printf("[XML ERROR] all IOC peripherals must have the same type\n");
2098                exit(1);
2099            }
2100
2101#if XML_PARSER_DEBUG
2102            printf("  end cluster set\n\n");
2103#endif
2104            header->psegs = pseg_index;
2105            header->procs = proc_index;
2106            header->irqs = irq_index;
2107            header->coprocs = coproc_index;
2108            header->cp_ports = cp_port_index;
2109            header->periphs = periph_index;
2110            return;
2111        }
2112        else 
2113        {
2114            printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
2115            exit(1);
2116        }
2117        status = xmlTextReaderRead(reader);
2118    }
2119} // end clusterSetNode()
2120
2121
2122///////////////////////////////////////////
2123void globalSetNode(xmlTextReaderPtr reader) 
2124{
2125    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
2126
2127#if XML_PARSER_DEBUG
2128    printf("  globals set\n");
2129#endif
2130
2131    int status = xmlTextReaderRead(reader);
2132    while (status == 1) 
2133    {
2134        const char * tag = (const char *) xmlTextReaderConstName(reader);
2135
2136        if      (strcmp(tag, "vseg")      == 0) 
2137        { 
2138            vsegNode( reader ); 
2139            header->globals = header->globals + 1;
2140        }
2141        else if (strcmp(tag, "#text")     == 0) { }
2142        else if (strcmp(tag, "#comment")  == 0) { }
2143        else if (strcmp(tag, "globalset") == 0) 
2144        {
2145#if XML_PARSER_DEBUG
2146            printf("  end global set\n\n");
2147#endif
2148            vseg_loc_index = 0;
2149            return;
2150        }
2151        else 
2152        {
2153            printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
2154            exit(1);
2155        }
2156        status = xmlTextReaderRead(reader);
2157    }
2158} // end globalSetNode()
2159
2160
2161///////////////////////////////////////////
2162void vspaceSetNode(xmlTextReaderPtr reader)
2163{
2164    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
2165        return;
2166    }
2167
2168#if XML_PARSER_DEBUG
2169    printf("\n  vspaces set\n");
2170#endif
2171
2172    int status = xmlTextReaderRead ( reader );
2173    while (status == 1) {
2174        const char * tag = (const char *) xmlTextReaderConstName(reader);
2175
2176        if (strcmp(tag, "vspace") == 0) {
2177            vspaceNode(reader);
2178        }
2179        else if (strcmp(tag, "#text"    ) == 0 ) { }
2180        else if (strcmp(tag, "#comment" ) == 0 ) { }
2181        else if (strcmp(tag, "vspaceset") == 0 ) 
2182        {
2183            header->vsegs = vseg_index;
2184            header->vobjs = vobj_index;
2185            header->tasks = task_index;
2186            return;
2187        }
2188        else 
2189        {
2190            printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
2191            exit(1);
2192        }
2193        status = xmlTextReaderRead(reader);
2194    }
2195} // end globalSetNode()
2196
2197
2198////////////////////////////////////////
2199void headerNode(xmlTextReaderPtr reader) 
2200{
2201    char * name;
2202    unsigned int value;
2203    unsigned int ok;
2204
2205    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
2206
2207#if XML_PARSER_DEBUG
2208    printf("mapping_info\n");
2209#endif
2210
2211    header = (mapping_header_t *) malloc(sizeof(mapping_header_t));
2212
2213    ////////// get name attribute
2214    name = getStringValue(reader, "name", &ok);
2215    if (ok) 
2216    {
2217#if XML_PARSER_DEBUG
2218        printf("  name = %s\n", name);
2219#endif
2220        strncpy( header->name, name, 31);
2221    }
2222    else 
2223    {
2224        printf("[XML ERROR] illegal or missing <name> attribute in header\n");
2225        exit(1);
2226    }
2227
2228    /////////// get signature attribute
2229    value = getIntValue(reader, "signature", &ok);
2230    if ( ok && (value == IN_MAPPING_SIGNATURE) )
2231    {
2232#if XML_PARSER_DEBUG
2233        printf("  signature = %x\n", value);
2234#endif
2235        header->signature = IN_MAPPING_SIGNATURE;
2236    }
2237    else
2238    {
2239        printf("[XML ERROR] illegal or missing <signature> for mapping %s\n",
2240        header->name );
2241        exit(1);
2242    }
2243
2244    /////////// get x_width attribute
2245    value = getIntValue(reader, "x_width", &ok);
2246    if (ok) 
2247    {
2248#if XML_PARSER_DEBUG
2249        printf("  x_width = %d\n", value);
2250#endif
2251        header->x_width = value;
2252    }
2253
2254    /////////// get y_width attribute
2255    value = getIntValue(reader, "y_width", &ok);
2256    if (ok) 
2257    {
2258#if XML_PARSER_DEBUG
2259        printf("  y_width = %d\n", value);
2260#endif
2261        header->y_width = value;
2262    }
2263
2264    /////////// get x_size attribute
2265    unsigned int x_size = getIntValue(reader, "x_size", &ok);
2266    if (ok) 
2267    {
2268#if XML_PARSER_DEBUG
2269        printf("  x_size  = %d\n", x_size);
2270#endif
2271        header->x_size = x_size;
2272    }
2273    else 
2274    {
2275        printf("[XML ERROR] illegal or missing <x_size> attribute in header\n");
2276        exit(1);
2277    }
2278
2279    /////////// get y_size attribute
2280    unsigned int y_size = getIntValue(reader, "y_size", &ok);
2281    if (ok) 
2282    {
2283#if XML_PARSER_DEBUG
2284        printf("  y_size  = %d\n", y_size);
2285#endif
2286        header->y_size = y_size;
2287    }
2288    else 
2289    {
2290        printf("[XML ERROR] illegal or missing <y_size> attribute in header\n");
2291        exit(1);
2292    }
2293
2294    /////////// get x_io attribute
2295    unsigned int x_io = getIntValue(reader, "x_io", &ok);
2296#if XML_PARSER_DEBUG
2297        printf("  x_io      = %d\n", x_io);
2298#endif
2299    if ( ok && (x_io < x_size) ) 
2300    {
2301        header->x_io = x_io;
2302    }
2303    else 
2304    {
2305        printf("[XML ERROR] illegal or missing <x_io> attribute in header\n");
2306        exit(1);
2307    }
2308
2309    /////////// get y_io attribute
2310    unsigned int y_io = getIntValue(reader, "y_io", &ok);
2311#if XML_PARSER_DEBUG
2312        printf("  y_io      = %d\n", y_io);
2313#endif
2314    if ( ok &&(y_io < y_size) ) 
2315    {
2316        header->y_io = y_io;
2317    }
2318    else 
2319    {
2320        printf("[XML ERROR] illegal or missing <y_io> attribute in header\n");
2321        exit(1);
2322    }
2323
2324    // check the number of cluster
2325    if ( (x_size * y_size) >= MAX_CLUSTERS )
2326    {
2327        printf("[XML ERROR] Number of clusters cannot be larger than %d\n", MAX_CLUSTERS);
2328        exit(1);
2329    }
2330
2331    ///////// get irq_per_proc attribute
2332    value = getIntValue(reader, "irq_per_proc", &ok);
2333    if (ok) 
2334    {
2335#if XML_PARSER_DEBUG
2336        printf("  irq_per_proc = %d\n", value);
2337#endif
2338        header->irq_per_proc = value;
2339    }
2340    else 
2341    {
2342        printf("[XML ERROR] illegal or missing <irq_per_proc> attribute in mapping\n");
2343        exit(1);
2344    }
2345
2346    ///////// get use_ram_disk attribute (default = 0)
2347    value = getIntValue(reader, "use_ram_disk", &ok);
2348    if (ok) 
2349    {
2350#if XML_PARSER_DEBUG
2351        printf("  use_ram_disk = %d\n", value);
2352#endif
2353        header->use_ram_disk = value;
2354    }
2355    else 
2356    {
2357        header->use_ram_disk = 0;
2358    }
2359
2360    ///////// set other header fields
2361    header->globals   = 0;
2362    header->vspaces   = 0;
2363    header->psegs     = 0;
2364    header->vsegs     = 0;
2365    header->vobjs     = 0;
2366    header->tasks     = 0;
2367    header->procs     = 0;
2368    header->irqs      = 0;
2369    header->coprocs   = 0;
2370    header->cp_ports  = 0;
2371    header->periphs   = 0;
2372
2373
2374    int status = xmlTextReaderRead(reader);
2375    while (status == 1) 
2376    {
2377        const char * tag = (const char *) xmlTextReaderConstName(reader);
2378
2379        if      (strcmp(tag, "clusterset")   == 0) { clusterSetNode(reader); }
2380        else if (strcmp(tag, "globalset")    == 0) { globalSetNode(reader); }
2381        else if (strcmp(tag, "vspaceset")    == 0) { vspaceSetNode(reader); }
2382        else if (strcmp(tag, "#text")        == 0) { }
2383        else if (strcmp(tag, "#comment")     == 0) { }
2384        else if (strcmp(tag, "mapping_info") == 0) 
2385        {
2386#if XML_PARSER_DEBUG
2387            printf("end mapping_info\n");
2388#endif
2389            return;
2390        }
2391        else 
2392        {
2393            printf("[XML ERROR] Unknown tag in header node : %s\n",tag);
2394            exit(1);
2395        }
2396        status = xmlTextReaderRead(reader);
2397    }
2398} // end headerNode()
2399
2400
2401///////////////////////////////////////
2402void BuildTable(int fdout, const char * type, unsigned int nb_elem,
2403                unsigned int elem_size, char ** table) 
2404{
2405    unsigned int i;
2406    // write element
2407    for (i = 0; i < nb_elem; i++) {
2408        if (elem_size != write(fdout, table[i], elem_size)) {
2409            printf("function %s: %s(%d) write  error \n", __FUNCTION__, type, i);
2410            exit(1);
2411        }
2412
2413#if XML_PARSER_DEBUG
2414        printf("Building binary: writing %s %d\n", type, i);
2415#endif
2416    }
2417}
2418
2419/////////////////////////////////////
2420int open_file(const char * file_path) 
2421{
2422    //open file
2423    int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) );
2424    if (fdout < 0) 
2425    {
2426        perror("open");
2427        exit(1);
2428    }
2429
2430    //reinitialise the file
2431    if (ftruncate(fdout, 0)) 
2432    {
2433        perror("truncate");
2434        exit(1);
2435    }
2436
2437    //#if XML_PARSER_DEBUG
2438    printf("%s\n", file_path);
2439    //#endif
2440
2441    return fdout;
2442}
2443
2444
2445/////////////////////////////////////
2446void buildBin(const char * file_path) 
2447{
2448    unsigned int length;
2449
2450    int fdout = open_file(file_path);
2451
2452#if XML_PARSER_DEBUG
2453printf("Building map.bin for %s\n", header->name);
2454printf("signature = %x\n", header->signature);
2455printf("x_size    = %d\n", header->x_size);
2456printf("y_size    = %d\n", header->y_size);
2457printf("x_width   = %d\n", header->x_width);
2458printf("y_width   = %d\n", header->y_width);
2459printf("vspaces   = %d\n", header->vspaces);
2460printf("psegs     = %d\n", header->psegs);
2461printf("vobjs     = %d\n", header->vobjs);
2462printf("vsegs     = %d\n", header->vsegs);
2463printf("tasks     = %d\n", header->tasks);
2464printf("procs     = %d\n", header->procs);
2465printf("irqs      = %d\n", header->irqs);
2466printf("coprocs   = %d\n", header->coprocs);
2467printf("periphs   = %d\n", header->periphs);
2468#endif
2469
2470    // write header to binary file
2471    length = write(fdout, (char *) header, sizeof(mapping_header_t));
2472    if (length != sizeof(mapping_header_t)) 
2473    {
2474        printf("write header error : length = %d \n", length);
2475        exit(1);
2476    }
2477
2478    // write clusters
2479    BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char **) cluster);
2480    // write psegs
2481    BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char **) pseg);
2482    // write vspaces
2483    BuildTable(fdout, "vspace", vspace_index, sizeof(mapping_vspace_t), (char **) vspace);
2484    // write vsegs
2485    BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char **) vseg);
2486    // write vobjs
2487    BuildTable(fdout, "vobj", vobj_index, sizeof(mapping_vobj_t), (char **) vobj);
2488    // write tasks array
2489    BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char **) task);
2490    //building procs array
2491    BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char **) proc);
2492    //building irqs array
2493    BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char **) irq);
2494    //building coprocs array
2495    BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char **) coproc);
2496    //building cp_ports array
2497    BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_cp_port_t),(char **) cp_port);
2498    //building periphs array
2499    BuildTable(fdout, "periph", periph_index, sizeof(mapping_periph_t), (char **) periph);
2500
2501    close(fdout);
2502
2503} // end buildBin()
2504
2505
2506///////////////////////////////////////////////////////////////////////////////////
2507// this function set the values of vspace_id and vobj_id fields for all cp_ports
2508///////////////////////////////////////////////////////////////////////////////////
2509void prepareBuild() 
2510{
2511    unsigned int i;
2512   
2513    for (i = 0; i < cp_port_index; i++) 
2514    {
2515        int vspace_id = getVspaceId(cp_port_vobj_ref[i]->vspace_name);
2516        if (vspace_id < 0) 
2517        {
2518            printf("[XML ERROR] illegal  <vspacename> for cp_port %d,\n", i);
2519            exit(1);
2520        }
2521        cp_port[i]->vspaceid = vspace_id;
2522
2523        int vobj_id = getVobjId( vspace_id, 
2524                                 cp_port_vobj_ref[i]->vobj_name, 
2525                                 vspace[vspace_id]->vobjs );
2526        if (vobj_id >= 0) 
2527        {
2528
2529#if XML_PARSER_DEBUG
2530            printf("\ncp_port = %d\n", i);
2531            printf("      vspace_name  = %s\n", cp_port_vobj_ref[i]->vspace_name);
2532            printf("      vobj_name    = %s\n", cp_port_vobj_ref[i]->vobj_name);
2533            printf("      vobj_index   = %d\n", vobj_id);
2534#endif
2535            cp_port[i]->mwmr_vobj_id = vobj_id;
2536
2537            assert((vobj[vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR)
2538                    && "coproc ports must refer a vobj of type MWMR");
2539        }
2540        else 
2541        {
2542            printf("[XML ERROR]  <vobjname> not found for cp_port %d,\n", i);
2543            exit(1);
2544        }
2545    }
2546}
2547
2548//////////////////////////////////////////
2549void file_write(int fdout, char * towrite) 
2550{
2551    unsigned int size = strlen(towrite);
2552    if (size != write(fdout, towrite, size)) 
2553    {
2554        printf("file_write error");
2555        exit(1);
2556    }
2557}
2558
2559//////////////////////////////////////////////////
2560void def_int_write(int fdout, char * def, int num) 
2561{
2562    char  buf[64];
2563    sprintf(buf, "#define\t %s  %d\n", def, num);
2564    file_write(fdout, buf);
2565}
2566
2567//////////////////////////////////////////////////
2568void def_hex_write(int fdout, char * def, int num) 
2569{
2570    char  buf[64];
2571    sprintf(buf, "#define\t %s  0x%x\n", def, num);
2572    file_write(fdout, buf);
2573}
2574
2575///////////////////////////////////
2576void  genHd(const char * file_path) 
2577{
2578    int fdout = open_file(file_path);
2579
2580    char prol[80];
2581    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
2582
2583    char * ifdef  = "#ifndef _HARD_CONFIG_H\n#define _HARD_CONFIG_H\n\n";
2584    char * epil   = "\n#endif //_HARD_CONFIG_H";
2585
2586    file_write(fdout, prol);
2587    file_write(fdout, ifdef);
2588
2589    def_int_write(fdout, "X_SIZE            ", header->x_size);
2590    def_int_write(fdout, "Y_SIZE            ", header->y_size);
2591    def_int_write(fdout, "X_WIDTH           ", header->x_width);
2592    def_int_write(fdout, "Y_WIDTH           ", header->y_width);
2593    def_int_write(fdout, "X_IO              ", header->x_io);
2594    def_int_write(fdout, "Y_IO              ", header->y_io);
2595
2596    file_write(fdout, "\n");
2597
2598    def_int_write(fdout, "TOTAL_PROCS       ", total_procs);
2599    def_int_write(fdout, "NB_PROCS_MAX      ", nb_procs_max);
2600    def_int_write(fdout, "NB_TASKS_MAX      ", nb_tasks_max);
2601
2602    file_write(fdout, "\n");
2603
2604    def_int_write(fdout, "NB_TIM_CHANNELS   ", tim_channels);
2605    def_int_write(fdout, "NB_DMA_CHANNELS   ", dma_channels);
2606
2607    file_write(fdout, "\n");
2608
2609    def_int_write(fdout, "NB_TTY_CHANNELS   ", tty_channels);
2610    def_int_write(fdout, "NB_IOC_CHANNELS   ", ioc_channels);
2611    def_int_write(fdout, "NB_NIC_CHANNELS   ", nic_channels);
2612    def_int_write(fdout, "NB_CMA_CHANNELS   ", cma_channels);
2613
2614    file_write(fdout, "\n");
2615
2616    def_int_write(fdout, "USE_XICU          ", use_xcu);
2617    def_int_write(fdout, "USE_IOB           ", use_iob);
2618    def_int_write(fdout, "USE_PIC           ", use_pic);
2619    def_int_write(fdout, "USE_FBF           ", use_fbf);
2620
2621    file_write(fdout, "\n");
2622
2623    def_int_write(fdout, "USE_IOC_RDK       ", header->use_ram_disk);
2624    def_int_write(fdout, "USE_IOC_HBA       ", use_hba);
2625    def_int_write(fdout, "USE_IOC_BDV       ", use_bdv);
2626    def_int_write(fdout, "USE_IOC_SPI       ", use_spi);
2627
2628    file_write(fdout, "\n");
2629
2630    def_int_write(fdout, "IRQ_PER_PROCESSOR ", header->irq_per_proc);
2631
2632    file_write(fdout, epil);
2633
2634    close(fdout);
2635}
2636
2637////////////////////////////////////////////////////////
2638void ld_write(int fdout, char * seg, unsigned int addr) 
2639{
2640    char buf[64];
2641    sprintf(buf, "%s = 0x%x;\n", seg, addr);
2642    file_write(fdout, buf);
2643}
2644
2645//////////////////////////////////
2646void genLd(const char * file_path) 
2647{
2648    int          fdout = open_file(file_path);
2649    unsigned int count;
2650    unsigned int vseg_id;
2651    unsigned int base;      // vseg base
2652    unsigned int size;      // vseg size
2653
2654    char prol[80];
2655    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);
2656
2657    file_write(fdout, prol);
2658
2659    // boot mandatory global vsegs
2660    for (vseg_id = 0 , count = 0 ; vseg_id < header->vsegs ; vseg_id++)
2661    {
2662        if ( strcmp(vseg[vseg_id]->name, "seg_boot_code") == 0 )
2663        {
2664            base = vseg[vseg_id]->vbase;
2665            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2666            ld_write(fdout, "seg_boot_code_base      ", base);
2667            ld_write(fdout, "seg_boot_code_size      ", size);
2668            count++;
2669        }
2670        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_data") == 0 )
2671        {
2672            base = vseg[vseg_id]->vbase;
2673            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2674            ld_write(fdout, "seg_boot_data_base      ", base);
2675            ld_write(fdout, "seg_boot_data_size      ", size);
2676            count++;
2677        }
2678        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_stack") == 0 )
2679        {
2680            base = vseg[vseg_id]->vbase;
2681            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2682            ld_write(fdout, "seg_boot_stack_base     ", base);
2683            ld_write(fdout, "seg_boot_stack_size     ", size);
2684            count++;       
2685        }
2686        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_mapping") == 0 )
2687        {
2688            base = vseg[vseg_id]->vbase;
2689            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2690            ld_write(fdout, "seg_boot_mapping_base   ", base);
2691            ld_write(fdout, "seg_boot_mapping_size   ", size);
2692            count++;
2693        }
2694    }
2695
2696    if ( count != 4 )
2697    { 
2698        printf ("[XML ERROR] Missing mandatory Boot global vseg : only %d\n", count);
2699        printf ("Mandatory segments are :\n");
2700        printf (" - seg_boot_code\n");
2701        printf (" - seg_boot_data\n");
2702        printf (" - seg_boot_stack\n");
2703        printf (" - seg_boot_mapping\n");
2704        exit(0);
2705    }
2706
2707    file_write(fdout, "\n");
2708
2709    // kernel mandatory global vsegs
2710    for (vseg_id = 0, count = 0 ; vseg_id < header->vsegs ; vseg_id++)
2711    {
2712        if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 )
2713        {
2714            base = vseg[vseg_id]->vbase;
2715            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2716            ld_write(fdout, "seg_kernel_code_base    ", base);
2717            ld_write(fdout, "seg_kernel_code_size    ", size);
2718            count++;
2719        }
2720        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 )
2721        {
2722            base = vseg[vseg_id]->vbase;
2723            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2724            ld_write(fdout, "seg_kernel_data_base    ", base);
2725            ld_write(fdout, "seg_kernel_data_size    ", size);
2726            count++;
2727        }
2728        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 )
2729        {
2730            base = vseg[vseg_id]->vbase;
2731            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2732            ld_write(fdout, "seg_kernel_uncdata_base ", base);
2733            ld_write(fdout, "seg_kernel_uncdata_size ", size);
2734            count++;
2735        }
2736        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 )
2737        {
2738            base = vseg[vseg_id]->vbase;
2739            size = vobj[vseg[vseg_id]->vobj_offset]->length;
2740            ld_write(fdout, "seg_kernel_init_base    ", base);
2741            ld_write(fdout, "seg_kernel_init_size    ", size);
2742            count++;
2743        }
2744    }
2745    if ( count != 4 )
2746    { 
2747        printf ("[XML ERROR] Missing mandatory Kernel global vseg : only %d\n", count);
2748        printf ("Mandatory segments are :\n");
2749        printf (" - seg_kernel_code\n");
2750        printf (" - seg_kernel_data\n");
2751        printf (" - seg_kernel_uncdata\n");
2752        printf (" - seg_kernel_init\n");
2753        exit(0);
2754    }
2755
2756    file_write(fdout, "\n");
2757
2758    // boot and kernel optionnal global vsegs (pseudo ROMs)
2759    unsigned int seg_ram_disk_base    = 0xFFFFFFFF;
2760    unsigned int seg_ram_disk_size    = 0;
2761    unsigned int seg_reset_code_base  = 0xFFFFFFFF;
2762    unsigned int seg_reset_code_size  = 0;
2763    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
2764    {
2765        if ( strcmp(vseg[vseg_id]->name, "seg_reset_code") == 0 )
2766        {
2767            seg_reset_code_base = vseg[vseg_id]->vbase;
2768            seg_reset_code_size = vobj[vseg[vseg_id]->vobj_offset]->length;
2769        }
2770        if ( strcmp(vseg[vseg_id]->name, "seg_ram_disk") == 0 )
2771        {
2772            seg_ram_disk_base   = vseg[vseg_id]->vbase;
2773            seg_ram_disk_size   = vobj[vseg[vseg_id]->vobj_offset]->length;
2774        }
2775    }
2776
2777    ld_write(fdout, "seg_reset_code_base     ", seg_reset_code_base);
2778    ld_write(fdout, "seg_reset_code_size     ", seg_reset_code_size);
2779    ld_write(fdout, "seg_ram_disk_base       ", seg_ram_disk_base);
2780    ld_write(fdout, "seg_ram_disk_size       ", seg_ram_disk_size);
2781   
2782    file_write(fdout, "\n");
2783
2784    // fill the peripherals base address array
2785    set_periph_vbase_array();
2786
2787    //  non replicated peripherals
2788    ld_write(fdout, "seg_cma_base            ",   periph_vbase_array[PERIPH_TYPE_CMA]);
2789    ld_write(fdout, "seg_fbf_base            ",   periph_vbase_array[PERIPH_TYPE_FBF]);
2790    ld_write(fdout, "seg_iob_base            ",   periph_vbase_array[PERIPH_TYPE_IOB]);
2791    ld_write(fdout, "seg_ioc_base            ",   periph_vbase_array[PERIPH_TYPE_IOC]);
2792    ld_write(fdout, "seg_nic_base            ",   periph_vbase_array[PERIPH_TYPE_NIC]);
2793    ld_write(fdout, "seg_rom_base            ",   periph_vbase_array[PERIPH_TYPE_ROM]);
2794    ld_write(fdout, "seg_sim_base            ",   periph_vbase_array[PERIPH_TYPE_SIM]);
2795    ld_write(fdout, "seg_tty_base            ",   periph_vbase_array[PERIPH_TYPE_TTY]);
2796    ld_write(fdout, "seg_pic_base            ",   periph_vbase_array[PERIPH_TYPE_PIC]);
2797
2798    file_write(fdout, "\n");
2799
2800    // replicated peripherals
2801    ld_write(fdout, "seg_dma_base            ",   periph_vbase_array[PERIPH_TYPE_DMA]);
2802    ld_write(fdout, "seg_mmc_base            ",   periph_vbase_array[PERIPH_TYPE_MMC]);
2803    ld_write(fdout, "seg_xcu_base            ",   periph_vbase_array[PERIPH_TYPE_XCU]);
2804
2805    file_write(fdout, "\n");
2806
2807    ld_write(fdout, "vseg_cluster_increment  ",   0x00010000);
2808
2809    close(fdout);
2810}
2811
2812//////////////////////////////////////////////////////
2813char * buildPath(const char * path, const char * name) 
2814{
2815    char * res = calloc(strlen(path) + strlen(name) + 1, 1);
2816    strcat(res, path);
2817    strcat(res, "/");
2818    strcat(res, name);
2819    return res; 
2820}
2821
2822
2823//////////////////////////////////
2824int main(int argc, char * argv[]) 
2825{
2826    if (argc < 3) {
2827        printf("Usage: xml2bin <input_file_path> <output_path>\n");
2828        return 1;
2829    }
2830
2831    struct stat dir_st;
2832    if (stat( argv[2], &dir_st)) {
2833        perror("bad path");
2834        exit(1);
2835    }
2836
2837    if ((dir_st.st_mode & S_IFDIR) == 0) {
2838        printf("path is not a dir: %s", argv[2] );
2839        exit(1);
2840    }
2841
2842    char * map_path = buildPath(argv[2], "map.bin"); 
2843    char * ld_path = buildPath(argv[2], "giet_vsegs.ld"); 
2844    char * hd_path = buildPath(argv[2], "hard_config.h"); 
2845
2846    LIBXML_TEST_VERSION;
2847
2848    int status;
2849    xmlTextReaderPtr reader = xmlReaderForFile(argv[1], NULL, 0);
2850
2851    if (reader != NULL) 
2852    {
2853        status = xmlTextReaderRead (reader);
2854        while (status == 1) 
2855        {
2856            const char * tag = (const char *) xmlTextReaderConstName(reader);
2857
2858            if (strcmp(tag, "mapping_info") == 0) 
2859            { 
2860                headerNode(reader);
2861                prepareBuild();
2862                buildBin(map_path);
2863                genHd(hd_path);
2864                genLd(ld_path);
2865            }
2866            else 
2867            {
2868                printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
2869                return 1;
2870            }
2871            status = xmlTextReaderRead(reader);
2872        }
2873        xmlFreeTextReader(reader);
2874
2875        if (status != 0) 
2876        {
2877            printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
2878            return 1;
2879        }
2880    }
2881    return 0;
2882} // end main()
2883
2884
2885// Local Variables:
2886// tab-width: 4
2887// c-basic-offset: 4
2888// c-file-offsets:((innamespace . 0)(inline-open . 0))
2889// indent-tabs-mode: nil
2890// End:
2891// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
2892
Note: See TracBrowser for help on using the repository browser.