Context Navigation

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

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

Modifications in GIET_VM:

Supporting platforms with more than one IRQ per processor from the XICU.

When this is the case, the IRQ per processor can be signalled
by the XCU peripheric number of channels on the XML file.

The xml_parser will generate a constant on the hard_config.h
file, called IRQ_PER_PROCESSOR and this constant will be use
by the GIET_VM to create accordingly the irq masks on the
ICU

Property svn:executable set to *

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

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

Download in other formats: