Context Navigation

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

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

Adding new task context information: THREAD INDEX.

This value can be accessed by USER applications to get the
thread index of the current task. This thread index
corresponds to the index in a vspace.

The value of this index can be forced in the vspace part
of the XML description file using the trdid field in the
task description. When this value is missing, for each
task, a value from 0 to N-1 will be assigned, where N is
the number of task in the vspace.

The user application access this value through the
giet_thread_id() function defined in the stdio library
which uses the SYSCALL_THREAD_ID to access the task
context information.

Supporting mono TTY platforms

When the GIET_MONO_TTY constant defined in the giet_config
file, contains a value different than 0, all tasks will
share the TTY[0]. If this is the case, in the stdio
library, the giet_tty_printf() function will take the TTY
hardware lock before writing

Property svn:executable set to *

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

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

Download in other formats: