Context Navigation

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

Last change on this file since 263 was 263, checked in by alain, 11 years ago

Introducing support for TSAR fixed format cluster index (cluster_xy)
We have now 4 parameters defined in map.xml:

X_WIDTH, Y_WIDTH define the fixed format (typically X_WIDTH = 4 / Y_WIDTH = 4)
X_SIZE, Y_SIZE define the actual TSAR 2D mesh variable size (from 1 to 16)

Property svn:executable set to *

File size: 83.0 KB

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

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

Download in other formats: