Context Navigation

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

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

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

Download in other formats: