Context Navigation

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

Last change on this file since 497 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

Rev	Line
[306]	1	//////////////////////////////////////////////////////////////////////////////////////
[258]	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
	51	mapping_header_t * header;
	52	mapping_cluster_t * cluster[MAX_CLUSTERS]; // cluster array
	53	mapping_pseg_t * pseg[MAX_PSEGS]; // pseg array
	54	mapping_vspace_t * vspace[MAX_VSPACES]; // vspace array
	55	mapping_vseg_t * vseg[MAX_VSEGS]; // vseg array
	56	mapping_vobj_t * vobj[MAX_VOBJS]; // vobj array
	57	mapping_task_t * task[MAX_TASKS]; // task array
	58	mapping_proc_t * proc[MAX_PROCS]; // proc array
	59	mapping_irq_t * irq[MAX_IRQS]; // irq array
	60	mapping_coproc_t * coproc[MAX_COPROCS]; // coproc array
	61	mapping_cp_port_t * cp_port[MAX_CP_PORTS]; // coproc port array
	62	mapping_periph_t * periph[MAX_PERIPHS]; // peripheral array
	63
	64	// Index for the various arrays
	65
	66	unsigned int cluster_index = 0;
	67	unsigned int vspace_index = 0;
	68	unsigned int global_index = 0;
	69	unsigned int pseg_index = 0;
	70
	71	unsigned int proc_index = 0;
	72	unsigned int proc_loc_index = 0;
	73
	74	unsigned int irq_index = 0;
	75	unsigned int irq_loc_index = 0;
	76
	77	unsigned int coproc_index = 0;
	78	unsigned int coproc_loc_index = 0;
	79
	80	unsigned int cp_port_index = 0;
	81	unsigned int cp_port_loc_index = 0;
	82
	83	unsigned int periph_index = 0;
	84	unsigned int periph_loc_index = 0;
	85
	86	unsigned int vseg_index = 0;
	87	unsigned int vseg_loc_index = 0;
	88
	89	unsigned int task_index = 0;
	90	unsigned int task_loc_index = 0;
	91
	92	unsigned int vobj_index = 0;
	93	unsigned int vobj_loc_index = 0;
	94	unsigned int vobj_count = 0;
	95
	96
	97	//////////////////////////////
	98	// for replicated peripheral
	99	//////////////////////////////
	100	char found_timer = 0;
	101	char found_icu = 0;
	102	char found_xcu = 0;
	103	char found_dma = 0;
	104	char found_mmc = 0;
	105
[295]	106	////////////////////////////////////////////////////////////////////////
	107	// These variables are used to generate the hard_config.h file.
	108	////////////////////////////////////////////////////////////////////////
[258]	109
[299]	110	unsigned int total_procs = 0; // total number of processors
[295]	111	unsigned int nb_procs_max = 0; // max number of processors per cluster
[263]	112	unsigned int nb_tasks_max = 0; // max number of tasks (in all vspaces)
[258]	113
[295]	114	unsigned int tim_channels = 0; // number of user timers (per cluster)
	115	unsigned int dma_channels = 0; // number of DMA channels (per cluster)
[258]	116
[295]	117	unsigned int tty_channels = 0; // number of TTY channels
	118	unsigned int ioc_channels = 0; // number of HBA channels
	119	unsigned int nic_channels = 0; // number of NIC channels
	120	unsigned int cma_channels = 0; // number of CMA channels
	121	unsigned int pic_channels = 0; // number of PIC channels
[258]	122
	123	unsigned int use_iob = 0; // using IOB component
[295]	124	unsigned int use_pic = 0; // using PIC component
[258]	125	unsigned int use_xcu = 0; // using XCU (not ICU)
[306]	126	unsigned int use_fbf = 0; // using Frame Buffer
[289]	127
	128	// These variables define the IOC peripheral subtype
[258]	129
[295]	130	unsigned int use_hba = 0; // using SoClib AHCI controller
	131	unsigned int use_bdv = 0; // using SoCLIB block device controller
	132	unsigned int use_spi = 0; // using SDCard-SPI
	133
[258]	134	////////////////////////////////////////////////////////////////
	135	// These variables are used to generate the giet_vseg.ld file
	136	////////////////////////////////////////////////////////////////
	137
	138	unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE]
[263]	139	= { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };
[258]	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	/////////////////////////////////////////////////////////////////////
	147	typedef struct vobj_ref_s
	148	{
	149	char vspace_name[32];
	150	char vobj_name[32];
	151	} vobj_ref_t;
	152
	153	vobj_ref_t * cp_port_vobj_ref[MAX_CP_PORTS];
	154
	155
	156	//////////////////////////////////////////////////
	157	unsigned 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	////////////////////////////////////////////////
	212	paddr_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	////////////////////////////////////////////////
	259	char * 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	///////////////////////////////////////////////////////////////////////////////////
[295]	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:
[323]	296	// vbase = seg_type_base & 0XFF000000 + (cluster_xy * 0x00010000) & 0x00FF0000
[295]	297	//
	298	// - For non-replicated peripherals, the cluster index must be cluster_io.
[258]	299	///////////////////////////////////////////////////////////////////////////////////
	300	void 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
[263]	305	unsigned int cluster_id; // cluster linear index
	306	unsigned int cluster_xy; // cluster topological index
[258]	307	unsigned int type; // peripheral type
	308
[323]	309	unsigned int type_mask = 0xFF000000;
	310	unsigned int cluster_mask = 0x00FF0000;
	311	unsigned int vseg_increment = 0x00010000;
[258]	312
[295]	313	#if XML_PARSER_DEBUG
	314	printf("\n set peripherals vbase array\n");
	315	#endif
[258]	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	{
[295]	323	pseg_id = vseg[vseg_id]->psegid;
[258]	324
[295]	325	#if XML_PARSER_DEBUG
[296]	326	printf(" - found vseg %s associated to pseg %d", vseg[vseg_id]->name, pseg_id );
[295]	327	#endif
	328
[263]	329	// scan all periphs to retrieve peripheral type (same psegid)
[258]	330	for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
	331	{
	332	if( periph[periph_id]->psegid == pseg_id ) // matching !!!
	333	{
[295]	334	cluster_id = pseg[pseg_id]->clusterid;
	335	type = periph[periph_id]->type;
	336
	337	#if XML_PARSER_DEBUG
	338	printf(" / matching periph type %d\n", type );
	339	#endif
	340
[263]	341	if ( (type == PERIPH_TYPE_DMA) \|\|
	342	(type == PERIPH_TYPE_MMC) \|\|
[472]	343	(type == PERIPH_TYPE_XCU) ) // replicated peripheral
[263]	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) !=
[323]	349	(vseg_increment * cluster_xy) )
[258]	350	{
[295]	351	printf("[XML ERROR] All replicated peripherals "
	352	"must have cluster bits = cluster_xy * increment\n");
[258]	353	printf("periph index = %d / periph type = %d / vbase = %x\n",
	354	periph_id, type, vseg[vseg_id]->vbase);
	355	exit(1);
	356	}
[295]	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	}
[258]	386	}
	387	}
	388	}
	389	}
	390	} // end set_periph_vbase_array()
	391
[263]	392	///////////////////////////////////////////////////////////////
	393	int getClusterId( unsigned int x, unsigned int y )
[258]	394	{
[263]	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	///////////////////////////////////////////////////////////////
	409	int 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
[258]	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;
[263]	428	} // end getPsegId()
[258]	429
	430	///////////////////////////////////
	431	int 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
[323]	445	////////////////////////////////////////////////////////////////////////////////
	446	int getVobjId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max)
[258]	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	{
[323]	454	if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return vobj_id;
[258]	455	}
	456	return -1;
	457	}
	458
[295]	459	///////////////////////////////////////////////////////////
	460	unsigned int alignTo( unsigned int value, unsigned int pow2 )
	461	{
	462	unsigned int mask = (1 << pow2) - 1;
	463	return ( (value + mask) & ~mask);
	464	}
	465
	466	////////////////////
	467	void 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	///////////////////////
	490	void 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
[258]	536	//////////////////////////////////////
	537	void taskNode(xmlTextReaderPtr reader)
	538	{
	539	unsigned int ok;
	540	unsigned int value;
[263]	541	unsigned int x,y;
[258]	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
	553	printf(" 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
[263]	563	printf(" name = %s\n", str);
[258]	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
[295]	574	///////// get trdid attribute (optional)
[267]	575	task[task_index]->trdid = getIntValue(reader, "trdid", &ok);
[263]	576	#if XML_PARSER_DEBUG
[295]	577	printf(" trdid = %d\n", x);
[263]	578	#endif
[267]	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
	587	printf(" x = %d\n", x);
	588	#endif
[263]	589	if ( !(ok && (x < header->x_size)) )
[258]	590	{
[263]	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
[267]	597	y = getIntValue(reader, "y", &ok);
[258]	598	#if XML_PARSER_DEBUG
[263]	599	printf(" y = %d\n", y);
[258]	600	#endif
[263]	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);
[258]	606	}
[263]	607
	608	///////// set clusterid attribute
	609	int index = getClusterId( x, y );
	610	#if XML_PARSER_DEBUG
	611	printf(" clusterid = %d\n", index);
	612	#endif
	613	if( index >= 0 )
[258]	614	{
[263]	615	task[task_index]->clusterid = index;
	616	}
	617	else
	618	{
	619	printf("[XML ERROR] <clusterid> not found for task (%d,%d)\n",
[258]	620	vspace_index, task_loc_index);
	621	exit(1);
	622	}
	623
[306]	624	////////// get p attribute
	625	value = getIntValue(reader, "p", &ok);
[258]	626	if (ok)
	627	{
	628	#if XML_PARSER_DEBUG
	629	printf(" 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	{
[306]	641	printf("[XML ERROR] illegal or missing <p> attribute for task (%d,%d)\n",
[258]	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	{
[323]	650	int index = getVobjId(vspace_index, str , vobj_loc_index);
[258]	651	if (index >= 0)
	652	{
	653	#if XML_PARSER_DEBUG
	654	printf(" stackname = %s\n", str);
[323]	655	printf(" stack_id = %d\n", index);
[258]	656	#endif
[323]	657	task[task_index]->stack_vobj_id = index;
[258]	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	{
[323]	677	int index = getVobjId(vspace_index, str, vobj_loc_index);
[258]	678	if (index >= 0)
	679	{
	680	#if XML_PARSER_DEBUG
[263]	681	printf(" heapname = %s\n", str);
[323]	682	printf(" heap_id = %d\n", index );
[258]	683	#endif
[323]	684	task[task_index]->heap_vobj_id = index;
[258]	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	{
[323]	695	task[task_index]->heap_vobj_id = -1;
[258]	696	}
	697
	698	////////// get startid attribute
	699	value = getIntValue(reader, "startid", &ok);
	700	if (ok)
	701	{
	702	#if XML_PARSER_DEBUG
[263]	703	printf(" startid = %x\n", value);
[258]	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	//////////////////////////////////////
	719	void 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
	734	printf(" 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
	744	printf(" 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
	758	printf(" 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; }
[472]	772	else if (ok && (strcmp(str, "HEAP") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_HEAP; }
[258]	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);
[295]	790	if (ok)
	791	{
[258]	792	#if XML_PARSER_DEBUG
[295]	793	printf(" length = %x\n", value);
[258]	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);
[295]	805	if (ok)
	806	{
[258]	807	#if XML_PARSER_DEBUG
	808	printf(" align = %d\n", value);
	809	#endif
	810	vobj[vobj_index]->align = value;
	811	}
[295]	812	else
	813	{
[258]	814	vobj[vobj_index]->align = 0;
	815	}
	816
[306]	817	////////// get binpath attribute (optional : "" if missing)
[258]	818	str = getStringValue(reader, "binpath", &ok);
[295]	819	if (ok)
	820	{
[258]	821	#if XML_PARSER_DEBUG
	822	printf(" binpath = %s\n", str);
	823	#endif
	824	strncpy(vobj[vobj_index]->binpath, str, 63);
	825	}
[306]	826	else
	827	{
	828	vobj[vobj_index]->binpath[0] = 0;
[258]	829	}
	830
[306]	831	////////// get init attribute (optional, mandatory for mwmr and barrier)
[258]	832	value = getIntValue(reader, "init", &ok);
	833	if (ok)
	834	{
	835	#if XML_PARSER_DEBUG
	836	printf(" 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	//////////////////////////////////////
	860	void vsegNode(xmlTextReaderPtr reader)
	861	{
	862	unsigned int ok;
	863	unsigned int value;
[263]	864	unsigned int x,y;
[258]	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
	878	printf(" vseg %d\n", vseg_loc_index);
	879	#endif
	880
	881	vseg[vseg_index] = (mapping_vseg_t *) malloc(sizeof(mapping_vseg_t));
	882
[306]	883	////////// set vobj_offset attribute
[258]	884	vseg[vseg_index]->vobj_offset = vobj_index;
	885
	886	#if XML_PARSER_DEBUG
	887	printf(" 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
[263]	901	printf(" name = %s\n", str);
[258]	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
[263]	917	printf(" ident = %d\n", value);
[258]	918	#endif
	919	vseg[vseg_index]->ident = value;
	920	}
	921	else
	922	{
	923	vseg[vseg_index]->ident = 0;
	924	}
	925
[349]	926	////////// get local attribute (optional : 0 if missing)
	927	value = getIntValue(reader, "local", &ok);
	928	if (ok)
	929	{
	930	#if XML_PARSER_DEBUG
	931	printf(" local = %d\n", value);
	932	#endif
	933	vseg[vseg_index]->local = value;
	934	}
	935	else
	936	{
	937	vseg[vseg_index]->local = 0;
	938	}
	939
[258]	940	/////////// get vbase attribute
	941	value = getIntValue(reader, "vbase", &ok);
	942	if (ok)
	943	{
	944	#if XML_PARSER_DEBUG
[263]	945	printf(" vbase = 0x%x\n", value);
[258]	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
[263]	956	////////// get x coordinate
	957	x = getIntValue(reader, "x", &ok);
	958	#if XML_PARSER_DEBUG
	959	printf(" x = %d\n", x);
	960	#endif
	961	if ( !(ok && (x < header->x_size)) )
[258]	962	{
[263]	963	printf("[XML ERROR] illegal or missing < x > attribute for vseg %d\n",
[258]	964	vseg_loc_index);
	965	exit(1);
	966	}
[263]	967
	968	////////// get y coordinate
	969	y = getIntValue(reader, "y", &ok);
	970	#if XML_PARSER_DEBUG
	971	printf(" 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
[258]	981	str = getStringValue(reader, "psegname", &ok);
[263]	982	#if XML_PARSER_DEBUG
	983	printf(" psegname = %s\n", str);
	984	#endif
[258]	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
[263]	993	int psegid = getPsegId( x, y, str );
	994	#if XML_PARSER_DEBUG
	995	printf(" psegid = %d\n", psegid);
	996	#endif
[306]	997	if (psegid >= 0)
[258]	998	{
[263]	999	vseg[vseg_index]->psegid = psegid;
[258]	1000	}
	1001	else
	1002	{
[263]	1003	printf("[XML ERROR] pseg not found for vseg %d / x = %d / y = %d / psegname = %s\n",
	1004	vseg_loc_index, x, y, str );
[258]	1005	exit(1);
	1006	}
	1007
	1008	//////// get mode attribute
	1009	str = getStringValue(reader, "mode", &ok);
	1010	#if XML_PARSER_DEBUG
[263]	1011	printf(" mode = %s\n", str);
[258]	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;
[295]	1047	setVsegLength();
	1048	checkVsegOverlap();
[258]	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	////////////////////////////////////////
	1063	void 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
	1076	printf("\n vspace %d\n", vspace_index);
	1077	#endif
	1078
	1079	vspace[vspace_index] = (mapping_vspace_t *) malloc(sizeof(mapping_vspace_t));
[295]	1080	header->vspaces = header->vspaces + 1;
[258]	1081
	1082	////////// get name attribute
	1083	str = getStringValue(reader, "name", &ok);
	1084	if (ok) {
	1085	#if XML_PARSER_DEBUG
	1086	printf(" 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);
[323]	1110	if (ok)
	1111	{
[258]	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);
[295]	1122	while (status == 1)
	1123	{
[258]	1124	const char * tag = (const char *) xmlTextReaderConstName(reader);
	1125
[263]	1126	if (strcmp(tag, "vseg") == 0)
	1127	{
[258]	1128	vsegNode(reader);
	1129	}
[263]	1130	else if (strcmp(tag, "task") == 0)
	1131	{
[258]	1132	taskNode(reader);
	1133	nb_task_vspace++;
	1134	}
	1135	else if (strcmp(tag, "#text") == 0) { }
	1136	else if (strcmp(tag, "#comment") == 0) { }
[295]	1137	else if (strcmp(tag, "vspace") == 0)
	1138	{
[258]	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
[323]	1144	int index = getVobjId(vspace_index, str , vobj_loc_index);
[258]	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	{
[323]	1153	vspace[vspace_index]->start_vobj_id = index;
[258]	1154	#if XML_PARSER_DEBUG
	1155	printf(" startname = %s\n", str);
[323]	1156	printf(" start_id = %d\n", index);
[258]	1157	printf(" end vspace %d\n\n", vspace_index);
	1158	#endif
	1159	}
	1160
[323]	1161	// checking for all tasks that the startid
	1162	// is smaller than the number of tasks in vspace
[258]	1163	int task_id;
	1164	int task_min = vspace[vspace_index]->task_offset;
	1165	int task_max = task_min + vspace[vspace_index]->tasks;
[323]	1166	for (task_id = task_min; task_id < task_max; task_id++)
	1167	{
[258]	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
[295]	1189	/////////////////////////////////////
	1190	void 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
	1204	printf(" irq %d\n", irq_loc_index);
	1205	#endif
	1206
	1207	irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t));
	1208
[306]	1209	///////// get srcid attribute
	1210	value = getIntValue(reader, "srcid", &ok);
[295]	1211	if (ok)
	1212	{
	1213	#if XML_PARSER_DEBUG
[306]	1214	printf(" srcid = %d\n", value);
[295]	1215	#endif
[306]	1216	irq[irq_index]->srcid = value;
	1217	if (value >= 32)
[295]	1218	{
[306]	1219	printf("[XML ERROR] IRQ <srcid> too large for periph %d in cluster %d\n",
[295]	1220	cluster_index, periph_loc_index);
	1221	exit(1);
	1222	}
	1223	}
	1224	else
	1225	{
[306]	1226	printf("[XML ERROR] missing IRQ <srcid> for periph %d in cluster %d\n",
[295]	1227	cluster_index, periph_loc_index);
	1228	exit(1);
	1229	}
	1230
[323]	1231	///////// get srctype attribute
	1232	str = getStringValue(reader, "srctype", &ok);
	1233	if (ok)
[295]	1234	{
	1235	#if XML_PARSER_DEBUG
[306]	1236	printf(" srctype = %s\n", str);
[295]	1237	#endif
[323]	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
[295]	1242	{
[323]	1243	printf("[XML ERROR] illegal IRQ <srctype> for periph %d in cluster %d\n",
[306]	1244	cluster_index, periph_loc_index);
[295]	1245	exit(1);
	1246	}
	1247	}
[323]	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	}
[295]	1254
[323]	1255	///////// get isr attribute
	1256	str = getStringValue(reader, "isr", &ok);
	1257	if (ok)
[295]	1258	{
	1259	#if XML_PARSER_DEBUG
	1260	printf(" isr = %s\n", str);
	1261	#endif
[323]	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;
[295]	1275	else
	1276	{
[323]	1277	printf("[XML ERROR] illegal IRQ <isr> for periph %d in cluster %d\n",
	1278	periph_loc_index, cluster_index );
[295]	1279	exit(1);
	1280	}
[323]	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);
[295]	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
	1294	printf(" 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
[258]	1310	////////////////////////////////////////
	1311	void 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
[295]	1326	printf("\n port %d\n", cp_port_index);
[258]	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
[295]	1337	printf(" direction = %s\n", str);
[258]	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
[295]	1364	printf(" vspacename = %s\n", str);
[258]	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
[295]	1380	printf(" vobjname = %s\n", str);
[258]	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	////////////////////////////////////////
	1397	void periphNode(xmlTextReaderPtr reader)
	1398	{
	1399	char * str;
	1400	unsigned int value;
	1401	unsigned int ok;
	1402
[295]	1403	irq_loc_index = 0;
	1404
[258]	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
[295]	1414	printf("\n periph %d\n", periph_index);
[258]	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
[295]	1424	printf(" channels = %d\n", value);
[258]	1425	#endif
	1426	periph[periph_index]->channels = value;
	1427	}
	1428	else
	1429	{
	1430	periph[periph_index]->channels = 1;
	1431	}
	1432
[323]	1433	///////// get arg attribute (optionnal : 0 if missing)
	1434	value = getIntValue(reader, "arg", &ok);
	1435	if (ok)
	1436	{
	1437	#if XML_PARSER_DEBUG
	1438	printf(" arg = %d\n", value);
	1439	#endif
	1440	periph[periph_index]->arg = value;
	1441	}
	1442	else
	1443	{
	1444	periph[periph_index]->arg = 1;
	1445	}
	1446
[258]	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
[263]	1457	int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
[258]	1458	if (index >= 0)
	1459	{
	1460	#if XML_PARSER_DEBUG
[295]	1461	printf(" clusterid = %d\n", cluster_index);
	1462	printf(" psegname = %s\n", str);
	1463	printf(" psegid = %d\n", index);
[258]	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
[295]	1479	printf(" type = %s\n", str);
[258]	1480	#endif
	1481	unsigned int error = 0;
	1482
[289]	1483	// initialize peripheral subtype
	1484	periph[periph_index]->subtype = 0xFFFFFFFF;
	1485
[491]	1486	// The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, PIC, DROM peripherals are not
[295]	1487	// replicated in all clusters but can be instanciated twice.
[258]	1488
	1489	////////////////////////////
	1490	if (strcmp(str, "CMA") == 0)
	1491	{
	1492	periph[periph_index]->type = PERIPH_TYPE_CMA;
[295]	1493	if ( cma_channels < periph[periph_index]->channels )
[258]	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;
[306]	1502	use_fbf = 1;
[258]	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	{
[295]	1513	char* subtype = getStringValue(reader, "subtype", &ok);
[289]	1514	if (!ok)
	1515	{
[295]	1516	printf("[XML ERROR] IOC peripheral needs a subtype: BDV, HBA or SPI\n");
[289]	1517	exit(1);
	1518	}
	1519
[295]	1520	if ( strcmp(subtype, "BDV") == 0 )
	1521	{
	1522	periph[periph_index]->type = PERIPH_TYPE_IOC;
[289]	1523	periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV;
[295]	1524	ioc_channels = 1;
[306]	1525	if ( header->use_ram_disk == 0 ) use_bdv = 1;
[289]	1526	}
[295]	1527	else if ( strcmp(subtype, "HBA") == 0 )
[289]	1528	{
[295]	1529	periph[periph_index]->type = PERIPH_TYPE_IOC;
[289]	1530	periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA;
[295]	1531	ioc_channels = periph[periph_index]->channels;
[306]	1532	if ( header->use_ram_disk == 0 ) use_hba = 1;
[289]	1533	}
[295]	1534	else if ( strcmp(subtype, "SPI") == 0 )
[289]	1535	{
[295]	1536	periph[periph_index]->type = PERIPH_TYPE_IOC;
[289]	1537	periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI;
[295]	1538	ioc_channels = periph[periph_index]->channels;
[306]	1539	if ( header->use_ram_disk == 0 ) use_spi = 1;
[289]	1540	}
	1541	else
	1542	{
	1543	printf("[XML ERROR] illegal subtype for IOC peripheral\n");
	1544	exit(1);
	1545	}
[258]	1546	}
	1547	/////////////////////////////////
	1548	else if (strcmp(str, "NIC") == 0)
	1549	{
	1550	periph[periph_index]->type = PERIPH_TYPE_NIC;
[295]	1551	if ( nic_channels < periph[periph_index]->channels )
[258]	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;
[295]	1570	if ( tty_channels < periph[periph_index]->channels )
[258]	1571	{
	1572	tty_channels = periph[periph_index]->channels;
	1573	}
[295]	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 )
[258]	1580	{
[295]	1581	pic_channels = periph[periph_index]->channels;
[258]	1582	}
[295]	1583	use_pic = 1;
[258]	1584	}
	1585
[295]	1586
[472]	1587	// The DMA, MMC, XCU peripherals can be replicated in all clusters
[295]	1588	// but no more than one component of each type per cluster
[258]	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;
[281]	1611	if (found_xcu \|\| found_icu \|\| found_timer) error = 1;
[258]	1612	found_xcu = 1;
	1613	found_timer = 1;
	1614	tim_channels = 32;
	1615	use_xcu = 1;
[281]	1616
[295]	1617	if ( periph[periph_index]->channels <
	1618	(header->irq_per_proc * cluster[cluster_index]->procs) )
[281]	1619	{
[295]	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);
[281]	1626	}
[258]	1627	}
[491]	1628	/////////////////////////////////
	1629	else if (strcmp(str, "DROM") == 0)
[258]	1630	{
[491]	1631	periph[periph_index]->type = PERIPH_TYPE_DROM;
	1632	}
	1633	else
	1634	{
[295]	1635	printf("[XML ERROR] illegal peripheral type: %s in cluster %d\n",
	1636	str, cluster_index);
[258]	1637	exit(1);
	1638	}
	1639
	1640	if (error)
	1641	{
[295]	1642	printf("[XML ERROR] illegal peripheral %s in cluster %d\n",
	1643	str, cluster_index);
[258]	1644	exit(1);
	1645	}
	1646	}
	1647	else
	1648	{
[295]	1649	printf("[XML ERROR] illegal or missing <type> for peripheral %d in cluster %d\n",
[258]	1650	periph_loc_index, cluster_index);
	1651	exit(1);
	1652	}
	1653
[295]	1654	////////////// set irq_offset attribute
	1655	periph[periph_index]->irq_offset = irq_index;
[258]	1656
[295]	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	{
[472]	1665	if ( (periph[periph_index]->type != PERIPH_TYPE_XCU) &&
[295]	1666	(periph[periph_index]->type != PERIPH_TYPE_PIC) )
	1667	{
	1668	printf("[XML ERROR] periph %d in cluster(%d,%d) "
[472]	1669	" only XCU and PIC can contain IRQs",
[295]	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
	1688	printf(" irqs = %d\n", irq_loc_index);
	1689	printf(" 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	}
[258]	1700	} // end periphNode
	1701
	1702	////////////////////////////////////////
	1703	void 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
[295]	1719	printf("\n coproc %d\n", coproc_index);
[258]	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
[295]	1729	printf(" name = %s\n", str);
[258]	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
[263]	1750	int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
[258]	1751	if (index >= 0)
	1752	{
	1753	#if XML_PARSER_DEBUG
[295]	1754	printf(" clusterid = %d\n", cluster_index);
	1755	printf(" psegname = %s\n", str);
	1756	printf(" psegid = %d\n", index);
[258]	1757	#endif
	1758	coproc[coproc_index]->psegid = index;
[295]	1759	assert(pseg[index]->type == PSEG_TYPE_PERI &&
	1760	"coproc psegname attribute must refer to a pseg of type PERI" );
[258]	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
[295]	1773	printf(" port_offset = %d\n", cp_port_index);
[258]	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	//////////////////////////////////////
	1806	void 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
[295]	1820	printf("\n proc %d\n", proc_index);
[258]	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	{
[306]	1829	printf("[XML ERROR] wrong local proc index / expected value is %d",
[258]	1830	proc_loc_index);
	1831	exit(1);
	1832	}
[295]	1833	proc[proc_index]->index = proc_loc_index;
[258]	1834
[295]	1835	cluster[cluster_index]->procs++;
	1836	proc_loc_index++;
	1837	proc_index++;
[299]	1838	total_procs++;
[258]	1839	} // end procNode()
	1840
	1841
	1842	//////////////////////////////////////
	1843	void 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
[295]	1858	printf(" pseg %d\n", pseg_index);
[258]	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
[295]	1866	printf(" name = %s\n", str);
[258]	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
[295]	1882	printf(" type = %s\n", str);
[258]	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; }
[491]	1886	else if (ok && (strcmp(str, "DROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
[258]	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
[295]	1898	printf(" base = 0x%llx\n", ll_value);
[258]	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
[295]	1913	printf(" length = 0x%llx\n", ll_value);
[258]	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
[263]	1927	pseg[pseg_index]->clusterid = cluster_index;
[258]	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	/////////////////////////////////////////
	1938	void 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
[263]	1945	//initialise variables that will be incremented by *Node() functions
[258]	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
[295]	1963	if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
[258]	1964
[263]	1965	#if XML_PARSER_DEBUG
	1966	printf("\n cluster %d\n", cluster_index);
	1967	#endif
	1968
	1969	/////////// get x coordinate
	1970	value = getIntValue(reader, "x", &ok);
	1971	#if XML_PARSER_DEBUG
	1972	printf(" x = %d\n", value);
	1973	#endif
	1974	if (ok && (value < header->x_size) )
[258]	1975	{
[263]	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);
[258]	1982	exit(1);
	1983	}
	1984
[263]	1985	/////////// get y coordinate
	1986	value = getIntValue(reader, "y", &ok);
[258]	1987	#if XML_PARSER_DEBUG
[263]	1988	printf(" y = %d\n", value);
[258]	1989	#endif
[263]	1990	if (ok && (value < header->y_size) )
[258]	1991	{
[263]	1992	cluster[cluster_index]->y = value;
	1993	}
	1994	else
	1995	{
	1996	printf("[XML ERROR] Illegal or missing < y > attribute for cluster %d",
[258]	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
[263]	2008	printf(" pseg_offset = %d\n", pseg_index);
	2009	printf(" proc_offset = %d\n", proc_index);
	2010	printf(" coproc_offset = %d\n", coproc_index);
	2011	printf(" periph_offset = %d\n", coproc_index);
[258]	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	{
[295]	2029	///////// TIMER and ICU peripheral are mandatory when nprocs != 0
[306]	2030
[295]	2031	unsigned int procs = cluster[cluster_index]->procs;
	2032	if ( procs && !found_timer && !found_xcu)
[258]	2033	{
	2034	printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index);
	2035	exit(1);
	2036	}
	2037
[295]	2038	if ( procs && !found_icu && !found_xcu)
[258]	2039	{
	2040	printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index);
	2041	exit(1);
	2042	}
	2043
[295]	2044	if (nb_procs_max < procs) nb_procs_max = procs;
[258]	2045
	2046	#if XML_PARSER_DEBUG
[263]	2047	printf(" psegs = %d\n", cluster[cluster_index]->psegs);
	2048	printf(" procs = %d\n", cluster[cluster_index]->procs);
	2049	printf(" coprocs = %d\n", cluster[cluster_index]->coprocs);
	2050	printf(" periphs = %d\n", cluster[cluster_index]->periphs);
	2051	printf(" end cluster %d\n", cluster_index);
[258]	2052	#endif
	2053	cluster_index++;
	2054	return;
	2055	}
	2056	status = xmlTextReaderRead(reader);
	2057	}
	2058	} // end clusterNode()
	2059
	2060
	2061	//////////////////////////////////////////////
	2062	void clusterSetNode(xmlTextReaderPtr reader)
	2063	{
	2064	if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;
	2065
	2066	#if XML_PARSER_DEBUG
[263]	2067	printf("\n clusters set\n");
[258]	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	{
[295]	2080	// checking number of clusters
[263]	2081	if ( cluster_index != (header->x_size * header->y_size) )
[258]	2082	{
	2083	printf("[XML ERROR] Wrong number of clusters\n");
	2084	exit(1);
	2085	}
	2086
[295]	2087	// checking TTY terminal for system boot
	2088	if ( tty_channels == 0 )
[258]	2089	{
[295]	2090	printf("[XML ERROR] missing TTY peripheral\n");
[258]	2091	exit(1);
	2092	}
	2093
[295]	2094	// checking IOC sub-types
	2095	if ( (use_bdv + use_hba + use_spi) > 1 )
[287]	2096	{
[295]	2097	printf("[XML ERROR] all IOC peripherals must have the same type\n");
[287]	2098	exit(1);
	2099	}
	2100
[258]	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	///////////////////////////////////////////
	2123	void 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
[295]	2136	if (strcmp(tag, "vseg") == 0)
	2137	{
	2138	vsegNode( reader );
	2139	header->globals = header->globals + 1;
	2140	}
[258]	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	///////////////////////////////////////////
	2162	void 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	{
[295]	2183	header->vsegs = vseg_index;
	2184	header->vobjs = vobj_index;
	2185	header->tasks = task_index;
	2186	return;
[258]	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	////////////////////////////////////////
	2199	void 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
[296]	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
[263]	2244	/////////// get x_width attribute
	2245	value = getIntValue(reader, "x_width", &ok);
[258]	2246	if (ok)
	2247	{
	2248	#if XML_PARSER_DEBUG
[263]	2249	printf(" x_width = %d\n", value);
[258]	2250	#endif
[263]	2251	header->x_width = value;
[258]	2252	}
[263]	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	}
[258]	2273	else
	2274	{
[263]	2275	printf("[XML ERROR] illegal or missing <x_size> attribute in header\n");
[258]	2276	exit(1);
	2277	}
	2278
[263]	2279	/////////// get y_size attribute
	2280	unsigned int y_size = getIntValue(reader, "y_size", &ok);
[258]	2281	if (ok)
	2282	{
	2283	#if XML_PARSER_DEBUG
[263]	2284	printf(" y_size = %d\n", y_size);
[258]	2285	#endif
[263]	2286	header->y_size = y_size;
[258]	2287	}
	2288	else
	2289	{
[263]	2290	printf("[XML ERROR] illegal or missing <y_size> attribute in header\n");
[258]	2291	exit(1);
	2292	}
	2293
[295]	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) )
[258]	2300	{
[295]	2301	header->x_io = x_io;
	2302	}
	2303	else
	2304	{
	2305	printf("[XML ERROR] illegal or missing <x_io> attribute in header\n");
[258]	2306	exit(1);
	2307	}
	2308
[295]	2309	/////////// get y_io attribute
	2310	unsigned int y_io = getIntValue(reader, "y_io", &ok);
[258]	2311	#if XML_PARSER_DEBUG
[296]	2312	printf(" y_io = %d\n", y_io);
[258]	2313	#endif
[295]	2314	if ( ok &&(y_io < y_size) )
	2315	{
	2316	header->y_io = y_io;
[258]	2317	}
	2318	else
	2319	{
[295]	2320	printf("[XML ERROR] illegal or missing <y_io> attribute in header\n");
[258]	2321	exit(1);
	2322	}
	2323
[295]	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);
[258]	2333	if (ok)
	2334	{
	2335	#if XML_PARSER_DEBUG
[295]	2336	printf(" irq_per_proc = %d\n", value);
[258]	2337	#endif
[295]	2338	header->irq_per_proc = value;
[258]	2339	}
	2340	else
	2341	{
[295]	2342	printf("[XML ERROR] illegal or missing <irq_per_proc> attribute in mapping\n");
[258]	2343	exit(1);
	2344	}
	2345
[306]	2346	///////// get use_ram_disk attribute (default = 0)
	2347	value = getIntValue(reader, "use_ram_disk", &ok);
[287]	2348	if (ok)
	2349	{
	2350	#if XML_PARSER_DEBUG
[306]	2351	printf(" use_ram_disk = %d\n", value);
[287]	2352	#endif
[306]	2353	header->use_ram_disk = value;
[287]	2354	}
	2355	else
	2356	{
[306]	2357	header->use_ram_disk = 0;
[287]	2358	}
	2359
[295]	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;
[258]	2372
	2373
	2374	int status = xmlTextReaderRead(reader);
	2375	while (status == 1)
	2376	{
	2377	const char * tag = (const char *) xmlTextReaderConstName(reader);
	2378
[295]	2379	if (strcmp(tag, "clusterset") == 0) { clusterSetNode(reader); }
[258]	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	///////////////////////////////////////
	2402	void 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	/////////////////////////////////////
	2420	int 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	/////////////////////////////////////
	2446	void buildBin(const char * file_path)
	2447	{
	2448	unsigned int length;
	2449
	2450	int fdout = open_file(file_path);
	2451
	2452	#if XML_PARSER_DEBUG
	2453	printf("Building map.bin for %s\n", header->name);
	2454	printf("signature = %x\n", header->signature);
[263]	2455	printf("x_size = %d\n", header->x_size);
	2456	printf("y_size = %d\n", header->y_size);
	2457	printf("x_width = %d\n", header->x_width);
	2458	printf("y_width = %d\n", header->y_width);
[258]	2459	printf("vspaces = %d\n", header->vspaces);
	2460	printf("psegs = %d\n", header->psegs);
	2461	printf("vobjs = %d\n", header->vobjs);
	2462	printf("vsegs = %d\n", header->vsegs);
	2463	printf("tasks = %d\n", header->tasks);
	2464	printf("procs = %d\n", header->procs);
	2465	printf("irqs = %d\n", header->irqs);
	2466	printf("coprocs = %d\n", header->coprocs);
	2467	printf("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
[323]	2506	///////////////////////////////////////////////////////////////////////////////////
	2507	// this function set the values of vspace_id and vobj_id fields for all cp_ports
	2508	///////////////////////////////////////////////////////////////////////////////////
[258]	2509	void prepareBuild()
	2510	{
	2511	unsigned int i;
[323]	2512
	2513	for (i = 0; i < cp_port_index; i++)
	2514	{
[258]	2515	int vspace_id = getVspaceId(cp_port_vobj_ref[i]->vspace_name);
[323]	2516	if (vspace_id < 0)
	2517	{
[258]	2518	printf("[XML ERROR] illegal <vspacename> for cp_port %d,\n", i);
	2519	exit(1);
	2520	}
	2521	cp_port[i]->vspaceid = vspace_id;
	2522
[323]	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	{
[258]	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
[323]	2535	cp_port[i]->mwmr_vobj_id = vobj_id;
[258]	2536
[323]	2537	assert((vobj[vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR)
	2538	&& "coproc ports must refer a vobj of type MWMR");
[258]	2539	}
[323]	2540	else
	2541	{
	2542	printf("[XML ERROR] <vobjname> not found for cp_port %d,\n", i);
[258]	2543	exit(1);
	2544	}
	2545	}
	2546	}
	2547
	2548	//////////////////////////////////////////
	2549	void 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	//////////////////////////////////////////////////
	2560	void 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	//////////////////////////////////////////////////
	2568	void 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	///////////////////////////////////
	2576	void 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
[281]	2583	char * ifdef = "#ifndef _HARD_CONFIG_H\n#define _HARD_CONFIG_H\n\n";
[258]	2584	char * epil = "\n#endif //_HARD_CONFIG_H";
	2585
	2586	file_write(fdout, prol);
	2587	file_write(fdout, ifdef);
	2588
[263]	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);
[295]	2593	def_int_write(fdout, "X_IO ", header->x_io);
	2594	def_int_write(fdout, "Y_IO ", header->y_io);
[263]	2595
	2596	file_write(fdout, "\n");
	2597
[299]	2598	def_int_write(fdout, "TOTAL_PROCS ", total_procs);
[295]	2599	def_int_write(fdout, "NB_PROCS_MAX ", nb_procs_max);
[258]	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);
[295]	2610	def_int_write(fdout, "NB_IOC_CHANNELS ", ioc_channels);
[258]	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);
[295]	2618	def_int_write(fdout, "USE_PIC ", use_pic);
[306]	2619	def_int_write(fdout, "USE_FBF ", use_fbf);
[258]	2620
[281]	2621	file_write(fdout, "\n");
	2622
[306]	2623	def_int_write(fdout, "USE_IOC_RDK ", header->use_ram_disk);
[295]	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
[287]	2630	def_int_write(fdout, "IRQ_PER_PROCESSOR ", header->irq_per_proc);
[281]	2631
[258]	2632	file_write(fdout, epil);
	2633
	2634	close(fdout);
	2635	}
	2636
	2637	////////////////////////////////////////////////////////
	2638	void 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	//////////////////////////////////
	2646	void genLd(const char * file_path)
	2647	{
	2648	int fdout = open_file(file_path);
[295]	2649	unsigned int count;
[258]	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
[295]	2659	// boot mandatory global vsegs
	2660	for (vseg_id = 0 , count = 0 ; vseg_id < header->vsegs ; vseg_id++)
[258]	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	}
[295]	2694	}
	2695
[363]	2696	if ( count != 4 )
[295]	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 )
[258]	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	}
[295]	2745	if ( count != 4 )
[258]	2746	{
[295]	2747	printf ("[XML ERROR] Missing mandatory Kernel global vseg : only %d\n", count);
[258]	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");
[295]	2753	exit(0);
[258]	2754	}
	2755
	2756	file_write(fdout, "\n");
	2757
[295]	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
[258]	2784	// fill the peripherals base address array
	2785	set_periph_vbase_array();
	2786
[295]	2787	// non replicated peripherals
[258]	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]);
[295]	2796	ld_write(fdout, "seg_pic_base ", periph_vbase_array[PERIPH_TYPE_PIC]);
[258]	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
[323]	2807	ld_write(fdout, "vseg_cluster_increment ", 0x00010000);
[258]	2808
	2809	close(fdout);
	2810	}
	2811
	2812	//////////////////////////////////////////////////////
	2813	char * 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	//////////////////////////////////
	2824	int 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.

Download in other formats: