Context Navigation

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

Last change on this file since 294 was 289, checked in by cfuguet, 11 years ago

Modifications on GIET-VM IOC driver:

Introducing new layer on the IOC driver. Every call to ioc_read, ioc_write, ioc_get_block_size or ioc_init

functions will call the specific driver of the used IOC
controller. Supported IOC controllers are (for now) :

BDV (Soclib Block Device)
HBA
SPI (SDCARD - SPI controller)

All functions of IOC controllers drivers respect the same interface.

To specify the used IOC controller of the platform, a subtype field has been introduced on the map.xml file. This subtype field must be declared on the IOC periph instantiation. Available subtypes (for now) : BDV, HBA or SPI.

Property svn:executable set to *

File size: 86.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: