Context Navigation

source: soft/giet_vm/giet_boot/boot.c @ 266

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

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

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

File size: 76.5 KB

Rev	Line
[258]	1	//////////////////////////////////////////////////////////////////////////////////////////
	2	// File : boot.c
	3	// Date : 01/11/2013
	4	// Author : alain greiner
	5	// Copyright (c) UPMC-LIP6
	6	//////////////////////////////////////////////////////////////////////////////////////////
	7	// The boot.c file is part of the GIET-VM nano-kernel.
	8	//
	9	// This nano-kernel has been written for the MIPS32 processor.
	10	// The virtual adresses are on 32 bits and use the (unsigned int) type, but the
	11	// physicals addresses can have up to 40 bits, and use the (unsigned long long) type.
	12	// It natively supports clusterised shared mmemory multi-processors architectures,
[263]	13	// where each processor is identified by a composite index (cluster_xy, local_id),
[258]	14	// and where there is one physical memory bank per cluster.
	15	//
	16	// This code is executed in the boot phase by proc[0] and performs the following tasks:
	17	// - load into memory the giet_vm binary files, contained in a FAT32 file system,
	18	// - build the various page tables (one page table per vspace)
	19	// - initialize the shedulers (one scheduler per processor)
	20	//
	21	// 1) The binary files to be loaded are:
	22	// - the "map.bin" file contains the hardware architecture description and the
	23	// mapping directives. It must be stored in the the seg_boot_mapping segment
	24	// (at address seg_boot_mapping_base).
	25	// - the "sys.elf" file contains the kernel binary code and data.
	26	// - the various "application.elf" files.
	27	//
	28	// 2) The map.bin file contains the binary representation of the map.xml file defining:
	29	// - the hardware architecture: number of clusters, number or processors,
	30	// size of the memory segments, and peripherals in each cluster.
	31	// - The structure of the various multi-threaded software applications:
	32	// number of tasks, communication channels.
	33	// - The mapping: placement of virtual objects (vobj) in the virtual segments (vseg),
	34	// placement of virtual segments (vseg) in the physical segments (pseg), placement
	35	// of software tasks on the processors,
	36	//
	37	// 3) The GIET-VM uses the paged virtual memory to provides two services:
	38	// - classical memory protection, when several independant applications compiled
	39	// in different virtual spaces are executing on the same hardware platform.
	40	// - data placement in NUMA architectures, when we want to control the placement
	41	// of the software objects (virtual segments) on the physical memory banks.
	42	//
	43	// The page table are statically build in the boot phase, and they do not
	44	// change during execution. The GIET uses only 4 Kbytes pages.
	45	// As most applications use only a limited number of segments, the number of PT2s
	46	// actually used by a given virtual space is generally smaller than 2048, and is
	47	// computed during the boot phase.
	48	// The max number of virtual spaces (GIET_NB_VSPACE_MAX) is a configuration parameter.
	49	//
	50	// Each page table (one page table per virtual space) is monolithic, and contains
	51	// one PT1 and up to (GIET_NB_PT2_MAX) PT2s. The PT1 is addressed using the ix1 field
	52	// (11 bits) of the VPN, and the selected PT2 is addressed using the ix2 field (9 bits).
	53	// - PT1[2048] : a first 8K aligned array of unsigned int, indexed by (ix1) field of VPN.
	54	// Each entry in the PT1 contains a 32 bits PTD. The MSB bit PTD[31] is
	55	// the PTD valid bit, and LSB bits PTD[19:0] are the 20 MSB bits of the physical base
	56	// address of the selected PT2.
	57	// The PT1 contains 2048 PTD of 4 bytes => 8K bytes.
	58	// - PT2[1024][GIET_NB_PT2_MAX] : an array of array of unsigned int.
	59	// Each PT2[1024] must be 4K aligned, each entry in a PT2 contains two unsigned int:
	60	// the first word contains the protection flags, and the second word contains the PPN.
	61	// Each PT2 contains 512 PTE2 of 8bytes => 4K bytes.
	62	// The total size of a page table is finally = 8K + (GIET_NB_PT2_MAX)*4K bytes.
[263]	63	///////////////////////////////////////////////////////////////////////////////////////
	64	// Implementation Notes:
	65	//
	66	// 1) The cluster_id variable is a linear index in the mapping_info array of clusters.
	67	// We use the cluster_xy variable for the tological index = x << Y_WIDTH + y
	68	///////////////////////////////////////////////////////////////////////////////////////
[258]	69
	70	// for vobjs initialisation
[263]	71	#include <giet_config.h>
[258]	72	#include <mwmr_channel.h>
	73	#include <barrier.h>
	74	#include <memspace.h>
	75	#include <tty_driver.h>
	76	#include <xcu_driver.h>
	77	#include <ioc_driver.h>
	78	#include <dma_driver.h>
	79	#include <cma_driver.h>
	80	#include <nic_driver.h>
	81	#include <ioc_driver.h>
	82	#include <mwr_driver.h>
	83	#include <ctx_handler.h>
	84	#include <irq_handler.h>
	85	#include <vmem.h>
	86	#include <utils.h>
	87	#include <elf-types.h>
	88
	89	// for boot FAT initialisation
	90	#include <fat32.h>
	91
	92	#include <mips32_registers.h>
	93	#include <stdarg.h>
	94
[263]	95	#if !defined(X_SIZE)
	96	# error The X_SIZE value must be defined in the 'hard_config.h' file !
[258]	97	#endif
	98
[263]	99	#if !defined(Y_SIZE)
	100	# error The Y_SIZE value must be defined in the 'hard_config.h' file !
	101	#endif
	102
	103	#if !defined(X_WIDTH)
	104	# error The X_WIDTH value must be defined in the 'hard_config.h' file !
	105	#endif
	106
	107	#if !defined(Y_WIDTH)
	108	# error The Y_WIDTH value must be defined in the 'hard_config.h' file !
	109	#endif
	110
[258]	111	#if !defined(NB_PROCS_MAX)
[263]	112	# error The NB_PROCS_MAX value must be defined in the 'hard_config.h' file !
[258]	113	#endif
	114
	115	#if !defined(GIET_NB_VSPACE_MAX)
	116	# error The GIET_NB_VSPACE_MAX value must be defined in the 'giet_config.h' file !
	117	#endif
	118
	119	////////////////////////////////////////////////////////////////////////////
	120	// Global variables for boot code
	121	// Both the page tables for the various virtual spaces, and the schedulers
	122	// for the processors are physically distributed on the clusters.
	123	// These global variables are just arrays of pointers.
	124	////////////////////////////////////////////////////////////////////////////
	125
	126	// This global variable is allocated in "fat32.c" file
	127	extern fat32_fs_t fat;
	128
	129	// Page table addresses arrays
	130	__attribute__((section (".bootdata")))
	131	paddr_t _ptabs_paddr[GIET_NB_VSPACE_MAX];
	132
	133	__attribute__((section (".bootdata")))
	134	unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];
	135
	136	// Next free PT2 index array
	137	__attribute__((section (".bootdata")))
	138	unsigned int _next_free_pt2[GIET_NB_VSPACE_MAX] =
	139	{ [0 ... GIET_NB_VSPACE_MAX - 1] = 0 };
	140
	141	// Max PT2 index
	142	__attribute__((section (".bootdata")))
	143	unsigned int _max_pt2[GIET_NB_VSPACE_MAX] =
	144	{ [0 ... GIET_NB_VSPACE_MAX - 1] = 0 };
	145
[263]	146	// Scheduler pointers array (virtual addresses)
	147	// indexed by (x,y,lpid) : ((x << Y_WIDTH) + y)*NB_PROCS_MAX + lpid
	148	__attribute__((section (".bootdata")))
	149	static_scheduler_t* _schedulers[NB_PROCS_MAX<<(X_WIDTH+Y_WIDTH)];
[258]	150
[263]	151
[258]	152	/////////////////////////////////////////////////////////////////////
	153	// This function checks consistence beween the mapping_info data
	154	// structure (soft), and the giet_config file (hard).
	155	/////////////////////////////////////////////////////////////////////
	156	void boot_mapping_check()
	157	{
	158	mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
	159
	160	// checking mapping availability
	161	if (header->signature != IN_MAPPING_SIGNATURE)
	162	{
	163	_puts("\n[BOOT ERROR] Illegal mapping signature: ");
	164	_putx(header->signature);
	165	_puts("\n");
	166	_exit();
	167	}
[263]	168
[258]	169	// checking number of clusters
[263]	170	if ( (header->x_size != X_SIZE) \|\|
	171	(header->y_size != Y_SIZE) \|\|
	172	(header->x_width != X_WIDTH) \|\|
	173	(header->y_width != Y_WIDTH) )
[258]	174	{
[263]	175	_puts("\n[BOOT ERROR] Incoherent X_SIZE or Y_SIZE ");
	176	_puts("\n - In hard_config: X_SIZE = ");
	177	_putd( X_SIZE );
	178	_puts(" / Y_SIZE = ");
	179	_putd( Y_SIZE );
	180	_puts(" / X_WIDTH = ");
	181	_putd( X_WIDTH );
	182	_puts(" / Y_WIDTH = ");
	183	_putd( Y_WIDTH );
	184	_puts("\n - In mapping_info: x_size = ");
	185	_putd( header->x_size );
	186	_puts(" / y_size = ");
	187	_putd( header->y_size );
	188	_puts(" / x_width = ");
	189	_putd( header->x_width );
	190	_puts(" / y_width = ");
	191	_putd( header->y_width );
[258]	192	_puts("\n");
	193	_exit();
	194	}
	195	// checking number of virtual spaces
	196	if (header->vspaces > GIET_NB_VSPACE_MAX)
	197	{
	198	_puts("\n[BOOT ERROR] : number of vspaces > GIET_NB_VSPACE_MAX\n");
	199	_puts("\n");
	200	_exit();
	201	}
	202
	203	#if BOOT_DEBUG_MAPPING
[263]	204	_puts("\n - x_size = ");
	205	_putd( header->x_size );
	206	_puts("\n - y_size = ");
	207	_putd( header->y_size );
[258]	208	_puts("\n - procs = ");
	209	_putd( header->procs );
	210	_puts("\n - periphs = ");
	211	_putd( header->periphs );
	212	_puts("\n - vspaces = ");
	213	_putd( header->vspaces );
	214	_puts("\n - tasks = ");
	215	_putd( header->tasks );
	216	_puts("\n");
	217	_puts("\n - size of header = ");
	218	_putd( MAPPING_HEADER_SIZE );
	219	_puts("\n - size of cluster = ");
	220	_putd( MAPPING_CLUSTER_SIZE );
	221	_puts("\n - size of pseg = ");
	222	_putd( MAPPING_PSEG_SIZE );
	223	_puts("\n - size of proc = ");
	224	_putd( MAPPING_PROC_SIZE );
	225	_puts("\n - size of vspace = ");
	226	_putd( MAPPING_VSPACE_SIZE );
	227	_puts("\n - size of vseg = ");
	228	_putd( MAPPING_VSEG_SIZE );
	229	_puts("\n - size of vobj = ");
	230	_putd( MAPPING_VOBJ_SIZE );
	231	_puts("\n - size of task = ");
	232	_putd( MAPPING_TASK_SIZE );
	233	_puts("\n");
	234
[263]	235	unsigned int cluster_id;
[258]	236	mapping_cluster_t * cluster = _get_cluster_base(header);
[263]	237	for( cluster_id = 0; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
[258]	238	{
[263]	239	_puts("\n - cluster[");
	240	_putd( cluster[cluster_id].x );
	241	_puts(",");
	242	_putd( cluster[cluster_id].y );
	243	_puts("]\n procs = ");
	244	_putd( cluster[cluster_id].procs );
	245	_puts("\n psegs = ");
	246	_putd( cluster[cluster_id].psegs );
	247	_puts("\n periphs = ");
	248	_putd( cluster[cluster_id].periphs );
	249	_puts("\n");
[258]	250	}
	251	#endif
	252
	253	} // end boot_mapping_check()
	254
	255
	256	//////////////////////////////////////////////////////////////////////////////
	257	// boot_pseg_get()
	258	// This function returns the pointer on a physical segment
	259	// identified by the pseg index.
	260	//////////////////////////////////////////////////////////////////////////////
	261	mapping_pseg_t *boot_pseg_get(unsigned int seg_id)
	262	{
	263	mapping_header_t* header = (mapping_header_t*)(&seg_boot_mapping_base);
	264	mapping_pseg_t * pseg = _get_pseg_base(header);
	265
	266	// checking argument
	267	if (seg_id >= header->psegs)
	268	{
	269	_puts("\n[BOOT ERROR] : seg_id argument too large\n");
	270	_puts(" in function boot_pseg_get()\n");
	271	_exit();
	272	}
	273
	274	return &pseg[seg_id];
	275	}
	276
	277	//////////////////////////////////////////////////////////////////////////////
	278	// boot_add_pte()
	279	// This function registers a new PTE in the page table defined
	280	// by the vspace_id argument, and updates both PT1 and PT2.
	281	// A new PT2 is used when required.
	282	// As the set of PT2s is implemented as a fixed size array (no dynamic
	283	// allocation), this function checks a possible overflow of the PT2 array.
	284	//////////////////////////////////////////////////////////////////////////////
	285	void boot_add_pte(unsigned int vspace_id,
	286	unsigned int vpn,
	287	unsigned int flags,
	288	unsigned int ppn,
	289	unsigned int verbose)
	290	{
	291	unsigned int ix1;
	292	unsigned int ix2;
	293	paddr_t pt1_pbase; // PT1 physical base address
	294	paddr_t pt2_pbase; // PT2 physical base address
	295	paddr_t pte_paddr; // PTE physucal address
	296	unsigned int pt2_id; // PT2 index
	297	unsigned int ptd; // PTD : entry in PT1
	298	unsigned int max_pt2; // max number of PT2s for a given vspace
	299
	300	ix1 = vpn >> 9; // 11 bits
	301	ix2 = vpn & 0x1FF; // 9 bits
	302
	303	// check that the _max_pt2[vspace_id] has been set
	304	max_pt2 = _max_pt2[vspace_id];
	305
	306	if (max_pt2 == 0)
	307	{
	308	_puts("Undefined page table for vspace ");
	309	_putd(vspace_id);
	310	_puts("\n");
	311	_exit();
	312	}
	313
	314
	315	// get page table physical base address
	316	pt1_pbase = _ptabs_paddr[vspace_id];
	317
	318	// get ptd in PT1
	319	ptd = _physical_read(pt1_pbase + 4 * ix1);
	320
	321	if ((ptd & PTE_V) == 0) // invalid PTD: compute PT2 base address,
	322	// and set a new PTD in PT1
	323	{
	324	pt2_id = _next_free_pt2[vspace_id];
	325	if (pt2_id == max_pt2)
	326	{
	327	_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
	328	_puts("the length of the ptab vobj is too small\n");
	329
	330	_puts(" max_pt2 = ");
	331	_putd( max_pt2 );
	332	_puts("\n");
	333	_puts(" pt2_id = ");
	334	_putd( pt2_id );
	335	_puts("\n");
	336
	337	_exit();
	338	}
	339	else
	340	{
	341	pt2_pbase = pt1_pbase + PT1_SIZE + PT2_SIZE * pt2_id;
	342	ptd = PTE_V \| PTE_T \| (unsigned int) (pt2_pbase >> 12);
	343	_physical_write( pt1_pbase + 4 * ix1, ptd);
	344	_next_free_pt2[vspace_id] = pt2_id + 1;
	345	}
	346	}
	347	else // valid PTD: compute PT2 base address
	348	{
	349	pt2_pbase = ((paddr_t)(ptd & 0x0FFFFFFF)) << 12;
	350	}
	351
	352	// set PTE in PT2 : flags & PPN in two 32 bits words
	353	pte_paddr = pt2_pbase + 8 * ix2;
	354	_physical_write(pte_paddr , flags);
	355	_physical_write(pte_paddr + 4, ppn);
	356
	357	if (verbose)
	358	{
	359	_puts(" / pt1_pbase = ");
	360	_putl( pt1_pbase );
	361	_puts(" / ptd = ");
	362	_putl( ptd );
	363	_puts(" / pt2_pbase = ");
	364	_putl( pt2_pbase );
	365	_puts(" / pte_paddr = ");
	366	_putl( pte_paddr );
	367	_puts(" / ppn = ");
	368	_putx( ppn );
	369	_puts("/\n");
	370	}
	371
	372	} // end boot_add_pte()
	373
	374
	375	/////////////////////////////////////////////////////////////////////
	376	// This function build the page table for a given vspace.
	377	// The physical base addresses for all vsegs (global and private)
	378	// must have been previously computed and stored in the mapping.
	379	// It initializes the MWMR channels.
	380	/////////////////////////////////////////////////////////////////////
	381	void boot_vspace_pt_build(unsigned int vspace_id)
	382	{
	383	unsigned int vseg_id;
	384	unsigned int npages;
	385	unsigned int ppn;
	386	unsigned int vpn;
	387	unsigned int flags;
	388	unsigned int page_id;
	389	unsigned int verbose = 0; // can be used to activate trace in add_pte()
	390
	391	mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
	392	mapping_vspace_t * vspace = _get_vspace_base(header);
	393	mapping_vseg_t * vseg = _get_vseg_base(header);
	394
	395	// private segments
	396	for (vseg_id = vspace[vspace_id].vseg_offset;
	397	vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
	398	vseg_id++)
	399	{
	400	vpn = vseg[vseg_id].vbase >> 12;
	401	ppn = (unsigned int) (vseg[vseg_id].pbase >> 12);
	402
	403	npages = vseg[vseg_id].length >> 12;
	404	if ((vseg[vseg_id].length & 0xFFF) != 0) npages++;
	405
	406	flags = PTE_V;
	407	if (vseg[vseg_id].mode & C_MODE_MASK) flags = flags \| PTE_C;
	408	if (vseg[vseg_id].mode & X_MODE_MASK) flags = flags \| PTE_X;
	409	if (vseg[vseg_id].mode & W_MODE_MASK) flags = flags \| PTE_W;
	410	if (vseg[vseg_id].mode & U_MODE_MASK) flags = flags \| PTE_U;
	411
	412	#if BOOT_DEBUG_PT
	413	_puts(vseg[vseg_id].name);
	414	_puts(" : flags = ");
	415	_putx(flags);
	416	_puts(" / npages = ");
	417	_putd(npages);
	418	_puts(" / pbase = ");
	419	_putl(vseg[vseg_id].pbase);
	420	_puts("\n");
	421	#endif
	422	// loop on 4K pages
	423	for (page_id = 0; page_id < npages; page_id++)
	424	{
	425	boot_add_pte(vspace_id, vpn, flags, ppn, verbose);
	426	vpn++;
	427	ppn++;
	428	}
	429	}
	430
	431	// global segments
	432	for (vseg_id = 0; vseg_id < header->globals; vseg_id++)
	433	{
	434	vpn = vseg[vseg_id].vbase >> 12;
	435	ppn = (unsigned int)(vseg[vseg_id].pbase >> 12);
	436	npages = vseg[vseg_id].length >> 12;
	437	if ((vseg[vseg_id].length & 0xFFF) != 0) npages++;
	438
	439	flags = PTE_V;
	440	if (vseg[vseg_id].mode & C_MODE_MASK) flags = flags \| PTE_C;
	441	if (vseg[vseg_id].mode & X_MODE_MASK) flags = flags \| PTE_X;
	442	if (vseg[vseg_id].mode & W_MODE_MASK) flags = flags \| PTE_W;
	443	if (vseg[vseg_id].mode & U_MODE_MASK) flags = flags \| PTE_U;
	444
	445	#if BOOT_DEBUG_PT
	446	_puts(vseg[vseg_id].name);
	447	_puts(" : flags = ");
	448	_putx(flags);
	449	_puts(" / npages = ");
	450	_putd(npages);
	451	_puts(" / pbase = ");
	452	_putl(vseg[vseg_id].pbase);
	453	_puts("\n");
	454	#endif
	455	// loop on 4K pages
	456	for (page_id = 0; page_id < npages; page_id++)
	457	{
	458	boot_add_pte(vspace_id, vpn, flags, ppn, verbose);
	459	vpn++;
	460	ppn++;
	461	}
	462	}
	463	} // end boot_vspace_pt_build()
	464
	465
	466	///////////////////////////////////////////////////////////////////////////
	467	// Align the value of paddr or vaddr to the required alignement,
	468	// defined by alignPow2 == L2(alignement).
	469	///////////////////////////////////////////////////////////////////////////
	470	paddr_t paddr_align_to(paddr_t paddr, unsigned int alignPow2)
	471	{
	472	paddr_t mask = (1 << alignPow2) - 1;
	473	return ((paddr + mask) & ~mask);
	474	}
	475
	476	unsigned int vaddr_align_to(unsigned int vaddr, unsigned int alignPow2)
	477	{
	478	unsigned int mask = (1 << alignPow2) - 1;
	479	return ((vaddr + mask) & ~mask);
	480	}
	481
	482	///////////////////////////////////////////////////////////////////////////
	483	// Set pbase for a vseg when identity mapping is required.
	484	// The length of the vseg must be known.
	485	// The ordered linked list of vsegs mapped on pseg must be updated,
	486	// and overlap with previously mapped vsegs must be checked.
	487	///////////////////////////////////////////////////////////////////////////
	488	void boot_vseg_set_paddr_ident(mapping_vseg_t * vseg)
	489	{
	490	// checking vseg not already mapped
	491	if (vseg->mapped != 0)
	492	{
	493	_puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
	494	_puts( vseg->name );
	495	_puts(" already mapped\n");
	496	_exit();
	497	}
	498
	499	// computes selected pseg pointer
	500	mapping_pseg_t* pseg = boot_pseg_get( vseg->psegid );
	501
	502	// computes vseg alignment constraint
	503	mapping_header_t* header = (mapping_header_t*)&seg_boot_mapping_base;
	504	mapping_vobj_t* vobj_base = _get_vobj_base( header );
	505	unsigned int align = vobj_base[vseg->vobj_offset].align;
	506	if ( vobj_base[vseg->vobj_offset].align < 12 ) align = 12;
	507
	508	// computes required_pbase for identity mapping,
	509	paddr_t required_pbase = (paddr_t)vseg->vbase;
	510
	511	// checks identity constraint against alignment constraint
	512	if ( paddr_align_to( required_pbase, align) != required_pbase )
	513	{
	514	_puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
	515	_puts( vseg->name );
	516	_puts(" has uncompatible identity and alignment constraints\n");
	517	_exit();
	518	}
	519
	520	// We are looking for a contiguous space in target pseg.
	521	// If there is vsegs already mapped, we scan the vsegs list to:
	522	// - check overlap with already mapped vsegs,
	523	// - try mapping in holes between already mapped vsegs,
	524	// - update the ordered linked list if success
	525	// We don't enter the loop if no vsegs is already mapped.
	526	// implementation note: The next_vseg field is unsigned int,
	527	// but we use it to store a MIP32 pointer on a vseg...
	528
	529	mapping_vseg_t* curr = 0;
	530	mapping_vseg_t* prev = 0;
	531	unsigned int min_pbase = pseg->base;
	532
	533	for ( curr = (mapping_vseg_t*)pseg->next_vseg ;
	534	(curr != 0) && (vseg->mapped == 0) ;
	535	curr = (mapping_vseg_t*)curr->next_vseg )
	536	{
	537	// looking before current vseg
	538	if( (required_pbase >= min_pbase) &&
	539	(curr->pbase >= (required_pbase + vseg->length)) ) // space found
	540	{
	541	vseg->pbase = required_pbase;
	542	vseg->mapped = 1;
	543
	544	// update linked list
	545	vseg->next_vseg = (unsigned int)curr;
	546	if( curr == (mapping_vseg_t*)pseg->next_vseg )
	547	pseg->next_vseg = (unsigned int)vseg;
	548	else
	549	prev->next_vseg = (unsigned int)vseg;
	550	}
	551	else // looking in space after curr
	552	{
	553	prev = curr;
	554	min_pbase = curr->pbase + curr->length;
	555	}
	556	}
	557
	558	// no success in the loop
	559	if( (vseg->mapped == 0) &&
	560	(required_pbase >= min_pbase) &&
	561	((required_pbase + vseg->length) <= (pseg->base + pseg->length)) )
	562	{
	563	vseg->pbase = required_pbase;
	564	vseg->mapped = 1;
	565
	566	// update linked list
	567	vseg->next_vseg = 0;
	568	if ((curr == 0) && (prev == 0)) pseg->next_vseg = (unsigned int)vseg;
	569	else prev->next_vseg = (unsigned int)vseg;
	570	}
	571
	572	if( vseg->mapped == 0 )
	573	{
	574	_puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
	575	_puts( vseg->name );
	576	_puts(" cannot be mapped on pseg ");
	577	_puts( pseg->name );
	578	_puts("\n");
	579	_exit();
	580	}
	581	} // end boot_vseg_set_paddr_ident()
	582
	583
	584	////////////////////////////////////////////////////////////////////////////
	585	// Set pbase for a vseg when there is no identity mapping constraint.
	586	// This is the physical memory allocator (written by Q.Meunier).
	587	// The length of the vseg must be known.
	588	// All identity mapping vsegs must be already mapped.
	589	// We use a linked list of already mapped vsegs, ordered by incresing pbase.
	590	// We try to place the vseg in the "first fit" hole in this list.
	591	////////////////////////////////////////////////////////////////////////////
	592	void boot_vseg_set_paddr(mapping_vseg_t * vseg)
	593	{
	594	// checking vseg not already mapped
	595	if ( vseg->mapped != 0 )
	596	{
	597	_puts("\n[BOOT ERROR] in boot_vseg_set_paddr() : vseg ");
	598	_puts( vseg->name );
	599	_puts(" already mapped\n");
	600	_exit();
	601	}
	602
	603	// computes selected pseg pointer
	604	mapping_pseg_t* pseg = boot_pseg_get( vseg->psegid );
	605
	606	// computes vseg alignment constraint
	607	mapping_header_t* header = (mapping_header_t*)&seg_boot_mapping_base;
	608	mapping_vobj_t* vobj_base = _get_vobj_base( header );
	609	unsigned int align = vobj_base[vseg->vobj_offset].align;
	610	if ( vobj_base[vseg->vobj_offset].align < 12 ) align = 12;
	611
	612	// initialise physical base address, with alignment constraint
	613	paddr_t possible_pbase = paddr_align_to( pseg->base, align );
	614
	615	// We are looking for a contiguous space in target pseg
	616	// If there is vsegs already mapped, we scan the vsegs list to:
	617	// - try mapping in holes between already mapped vsegs,
	618	// - update the ordered linked list if success
	619	// We don't enter the loop if no vsegs is already mapped.
	620	// implementation note: The next_vseg field is unsigned int,
	621	// but we use it to store a MIP32 pointer on a vseg...
	622
	623	mapping_vseg_t* curr = 0;
	624	mapping_vseg_t* prev = 0;
	625
	626	for( curr = (mapping_vseg_t*)pseg->next_vseg ;
	627	(curr != 0) && (vseg->mapped == 0) ;
	628	curr = (mapping_vseg_t*)curr->next_vseg )
	629	{
	630	// looking for space before current vseg
	631	if ( (curr->pbase >= possible_pbase + vseg->length) ) // space before curr
	632	{
	633	vseg->pbase = possible_pbase;
	634	vseg->mapped = 1;
	635
	636	// update linked list
	637	vseg->next_vseg = (unsigned int)curr;
	638	if( curr == (mapping_vseg_t*)pseg->next_vseg )
	639	pseg->next_vseg = (unsigned int)vseg;
	640	else
	641	prev->next_vseg = (unsigned int)vseg;
	642	}
	643	else // looking for space after curr
	644	{
	645	possible_pbase = paddr_align_to( curr->pbase + curr->length, align );
	646	prev = curr;
	647	}
	648	}
	649
	650	// when no space found, try to allocate space after already mapped vsegs
	651	if( (vseg->mapped == 0) &&
	652	((possible_pbase + vseg->length) <= (pseg->base + pseg->length)) )
	653	{
	654	vseg->pbase = possible_pbase;
	655	vseg->mapped = 1;
	656
	657	// update linked list
	658	vseg->next_vseg = 0;
	659	if ((curr == 0 ) && (prev == 0)) pseg->next_vseg = (unsigned int)vseg;
	660	else prev->next_vseg = (unsigned int)vseg;
	661	}
	662
	663	if( vseg->mapped == 0 )
	664	{
	665	_puts("\n[BOOT ERROR] in boot_vseg_set_paddr() : vseg ");
	666	_puts( vseg->name );
	667	_puts(" cannot be mapped on pseg ");
	668	_puts( pseg->name );
	669	_puts("\n");
	670	_exit();
	671	}
	672	} // end boot_vseg_set_paddr()
	673
	674	///////////////////////////////////////////////////////////////////////////
	675	// This function computes the physical base address for a vseg
	676	// as specified in the mapping info data structure.
	677	// It updates the pbase and the length fields of the vseg.
	678	// It updates the pbase and vbase fields of all vobjs in the vseg.
	679	// It updates the _ptabs_paddr[] and _ptabs_vaddr[] arrays.
	680	// It is a global vseg if vspace_id = (-1).
	681	///////////////////////////////////////////////////////////////////////////
	682	void boot_vseg_map(mapping_vseg_t * vseg, unsigned int vspace_id)
	683	{
	684	unsigned int vobj_id;
	685	unsigned int cur_vaddr;
	686	paddr_t cur_paddr;
	687	paddr_t cur_length;
	688	unsigned int offset;
	689
	690	mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
	691	mapping_vobj_t * vobj = _get_vobj_base(header);
	692
	693	// loop on the vobjs contained in vseg to compute
	694	// the vseg length, required for mapping.
	695	cur_length = 0;
	696	for ( vobj_id = vseg->vobj_offset;
	697	vobj_id < (vseg->vobj_offset + vseg->vobjs);
	698	vobj_id++ )
	699	{
	700	if (vobj[vobj_id].align)
	701	{
	702	cur_length = vaddr_align_to(cur_length, vobj[vobj_id].align);
	703	}
	704	cur_length += vobj[vobj_id].length;
	705	}
	706	vseg->length = paddr_align_to(cur_length, 12);
	707
	708	// mapping: computes vseg pbase address
	709	if (vseg->ident != 0) // identity mapping
	710	{
	711	boot_vseg_set_paddr_ident( vseg );
	712	}
	713	else // unconstrained mapping
	714	{
	715	boot_vseg_set_paddr( vseg );
	716	}
	717
	718	// second loop on vobjs contained in vseg to :
	719	// initialize the vaddr and paddr fields of all vobjs,
	720	// and initialize the page table pointers arrays
	721
	722	cur_vaddr = vseg->vbase;
	723	cur_paddr = vseg->pbase;
	724
	725	for (vobj_id = vseg->vobj_offset;
	726	vobj_id < (vseg->vobj_offset + vseg->vobjs); vobj_id++)
	727	{
	728	if (vobj[vobj_id].align)
	729	{
	730	cur_paddr = paddr_align_to(cur_paddr, vobj[vobj_id].align);
	731	cur_vaddr = vaddr_align_to(cur_vaddr, vobj[vobj_id].align);
	732	}
	733	// set vaddr/paddr for current vobj
	734	vobj[vobj_id].vaddr = cur_vaddr;
	735	vobj[vobj_id].paddr = cur_paddr;
	736
	737	// initialize _ptabs_vaddr[] & boot_ptabs-paddr[] if PTAB
	738	if (vobj[vobj_id].type == VOBJ_TYPE_PTAB)
	739	{
	740	if (vspace_id == ((unsigned int) -1)) // global vseg
	741	{
	742	_puts("\n[BOOT ERROR] in boot_vseg_map() function: ");
	743	_puts("a PTAB vobj cannot be global");
	744	_exit();
	745	}
	746	// we need at least one PT2
	747	if (vobj[vobj_id].length < (PT1_SIZE + PT2_SIZE))
	748	{
	749	_puts("\n[BOOT ERROR] in boot_vseg_map() function, ");
	750	_puts("PTAB too small, minumum size is: ");
	751	_putx(PT1_SIZE + PT2_SIZE);
	752	_exit();
	753	}
	754	// register both physical and virtual page table address
	755	_ptabs_vaddr[vspace_id] = vobj[vobj_id].vaddr;
	756	_ptabs_paddr[vspace_id] = vobj[vobj_id].paddr;
	757
	758	// reset all valid bits in PT1
	759	for ( offset = 0 ; offset < 8192 ; offset = offset + 4)
	760	{
	761	_physical_write(cur_paddr + offset, 0);
	762	}
	763
	764	// computing the number of second level pages
	765	_max_pt2[vspace_id] = (vobj[vobj_id].length - PT1_SIZE) / PT2_SIZE;
	766	}
	767
	768	// set next vaddr/paddr
	769	cur_vaddr = cur_vaddr + vobj[vobj_id].length;
	770	cur_paddr = cur_paddr + vobj[vobj_id].length;
	771	} // end for vobjs
	772
	773	} // end boot_vseg_map()
	774
	775	/////////////////////////////////////////////////////////////////////
	776	// This function builds the page tables for all virtual spaces
	777	// defined in the mapping_info data structure, in three steps:
	778	// - step 1 : It computes the physical base address for global vsegs
	779	// and for all associated vobjs.
	780	// - step 2 : It computes the physical base address for all private
	781	// vsegs and all vobjs in each virtual space.
	782	// - step 3 : It actually fill the page table for each vspace.
	783	//
	784	// Note: It must exist at least one vspace in the mapping_info...
	785	/////////////////////////////////////////////////////////////////////
	786	void boot_pt_init()
	787	{
	788	mapping_header_t * header = (mapping_header_t *) &seg_boot_mapping_base;
	789	mapping_vspace_t * vspace = _get_vspace_base(header);
	790	mapping_vseg_t * vseg = _get_vseg_base(header);
	791
	792	unsigned int vspace_id;
	793	unsigned int vseg_id;
	794
	795	if (header->vspaces == 0 )
	796	{
	797	_puts("\n[BOOT ERROR] in boot_pt_init() : mapping ");
	798	_puts( header->name );
	799	_puts(" contains no vspace\n");
	800	_exit();
	801	}
	802
	803	#if BOOT_DEBUG_PT
	804	_puts("\n[BOOT DEBUG] **** mapping global vsegs ****\n");
	805	#endif
	806
	807	// step 1 : loop on global vsegs
	808
	809	// vsegs with identity mapping constraint first
	810	for (vseg_id = 0; vseg_id < header->globals; vseg_id++)
	811	{
	812	if (vseg[vseg_id].ident == 1)
	813	boot_vseg_map(&vseg[vseg_id], ((unsigned int) (-1)));
	814	}
	815
	816	// unconstrained vsegs second
	817	for (vseg_id = 0; vseg_id < header->globals; vseg_id++)
	818	{
	819	if (vseg[vseg_id].ident == 0)
	820	boot_vseg_map(&vseg[vseg_id], ((unsigned int) (-1)));
	821	}
	822
	823	// step 2 : loop on virtual vspaces to map private vsegs
	824	for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++)
	825	{
	826
	827	#if BOOT_DEBUG_PT
	828	_puts("\n[BOOT DEBUG] ****** mapping private vsegs in vspace ");
	829	_puts(vspace[vspace_id].name);
	830	_puts(" ******\n");
	831	#endif
	832
	833	// vsegs with identity mapping constraint first
	834	for (vseg_id = vspace[vspace_id].vseg_offset;
	835	vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
	836	vseg_id++)
	837	{
	838	if (vseg[vseg_id].ident == 1)
	839	boot_vseg_map(&vseg[vseg_id], vspace_id);
	840	}
	841	// unconstrained vsegs second
	842	for (vseg_id = vspace[vspace_id].vseg_offset;
	843	vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
	844	vseg_id++)
	845	{
	846	if (vseg[vseg_id].ident == 0)
	847	boot_vseg_map(&vseg[vseg_id], vspace_id);
	848	}
	849	}
	850
	851	#if BOOT_DEBUG_PT
	852	mapping_vseg_t* curr;
	853	mapping_pseg_t* pseg = _get_pseg_base(header);
	854	unsigned int pseg_id;
	855	for( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
	856	{
	857	_puts("\n[BOOT DEBUG] ****** vsegs mapped on pseg ");
	858	_puts( pseg[pseg_id].name );
	859	_putd( pseg[pseg_id].cluster);
	860	_puts(" ******\n");
	861	for( curr = (mapping_vseg_t*)pseg[pseg_id].next_vseg ;
	862	curr != 0 ;
	863	curr = (mapping_vseg_t*)curr->next_vseg )
	864	{
	865	_puts(" - vseg ");
	866	_puts( curr->name );
	867	_puts(" : len = ");
	868	_putx( curr->length );
	869	_puts(" / vbase ");
	870	_putl( curr->vbase );
	871	_puts(" / pbase ");
	872	_putl( curr->pbase );
	873	_puts("\n");
	874	}
	875	}
	876	#endif
	877
	878	// step 3 : loop on the vspaces to build the page tables
	879	for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++)
	880	{
	881
	882	#if BOOT_DEBUG_PT
	883	_puts("\n[BOOT DEBUG] ****** building page table for vspace ");
	884	_puts(vspace[vspace_id].name);
	885	_puts(" ******\n");
	886	#endif
	887
	888	boot_vspace_pt_build(vspace_id);
	889
	890	_puts("\n[BOOT] Page Table for vspace ");
	891	_puts( vspace[vspace_id].name );
	892	_puts(" completed at cycle ");
	893	_putd( _get_proctime() );
	894	_puts("\n");
	895
	896	#if BOOT_DEBUG_PT
	897	_puts(" vaddr = ");
	898	_putx( _ptabs_vaddr[vspace_id] );
	899	_puts(" / paddr = ");
	900	_putl( _ptabs_paddr[vspace_id] );
	901	_puts(" / PT2 number = ");
	902	_putd( _max_pt2[vspace_id] );
	903	_puts("\n");
	904	#endif
	905	}
	906	} // end boot_pt_init()
	907
	908	///////////////////////////////////////////////////////////////////////////////
	909	// This function initializes all private vobjs defined in the vspaces,
	910	// such as mwmr channels, barriers and locks, because these vobjs
	911	// are not known, and not initialized by the compiler.
	912	// The MMU is supposed to be activated...
	913	///////////////////////////////////////////////////////////////////////////////
	914	void boot_vobjs_init()
	915	{
	916	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	917	mapping_vspace_t* vspace = _get_vspace_base(header);
	918	mapping_vobj_t* vobj = _get_vobj_base(header);
	919
	920	unsigned int vspace_id;
	921	unsigned int vobj_id;
	922
	923	// loop on the vspaces
	924	for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++)
	925	{
	926
	927	#if BOOT_DEBUG_VOBJS
	928	_puts("\n[BOOT DEBUG] ****** vobjs initialisation in vspace ");
	929	_puts(vspace[vspace_id].name);
	930	_puts(" ******\n");
	931	#endif
	932
	933	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id] >> 13) );
	934
	935	unsigned int ptab_found = 0;
	936
	937	// loop on the vobjs
	938	for (vobj_id = vspace[vspace_id].vobj_offset;
	939	vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs);
	940	vobj_id++)
	941	{
	942	switch (vobj[vobj_id].type)
	943	{
	944	case VOBJ_TYPE_MWMR: // storage capacity is (vobj.length/4 - 5) words
	945	{
	946	mwmr_channel_t* mwmr = (mwmr_channel_t *) (vobj[vobj_id].vaddr);
	947	mwmr->ptw = 0;
	948	mwmr->ptr = 0;
	949	mwmr->sts = 0;
	950	mwmr->width = vobj[vobj_id].init;
	951	mwmr->depth = (vobj[vobj_id].length >> 2) - 6;
	952	mwmr->lock = 0;
	953	#if BOOT_DEBUG_VOBJS
	954	_puts("MWMR : ");
	955	_puts(vobj[vobj_id].name);
	956	_puts(" / depth = ");
	957	_putd(mwmr->depth);
	958	_puts(" / width = ");
	959	_putd(mwmr->width);
	960	_puts("\n");
	961	#endif
	962	break;
	963	}
	964	case VOBJ_TYPE_ELF: // initialisation done by the loader
	965	{
	966	#if BOOT_DEBUG_VOBJS
	967	_puts("ELF : ");
	968	_puts(vobj[vobj_id].name);
	969	_puts(" / length = ");
	970	_putx(vobj[vobj_id].length);
	971	_puts("\n");
	972	#endif
	973	break;
	974	}
	975	case VOBJ_TYPE_BLOB: // initialisation done by the loader
	976	{
	977	#if BOOT_DEBUG_VOBJS
	978	_puts("BLOB : ");
	979	_puts(vobj[vobj_id].name);
	980	_puts(" / length = ");
	981	_putx(vobj[vobj_id].length);
	982	_puts("\n");
	983	#endif
	984	break;
	985	}
	986	case VOBJ_TYPE_BARRIER: // init is the number of participants
	987	{
	988	giet_barrier_t* barrier = (giet_barrier_t *) (vobj[vobj_id].vaddr);
	989	barrier->count = vobj[vobj_id].init;
	990	barrier->init = vobj[vobj_id].init;
	991	#if BOOT_DEBUG_VOBJS
	992	_puts("BARRIER : ");
	993	_puts(vobj[vobj_id].name);
	994	_puts(" / init_value = ");
	995	_putd(barrier->init);
	996	_puts("\n");
	997	#endif
	998	break;
	999	}
	1000	case VOBJ_TYPE_LOCK: // init value is "not taken"
	1001	{
	1002	unsigned int* lock = (unsigned int *) (vobj[vobj_id].vaddr);
	1003	*lock = 0;
	1004	#if BOOT_DEBUG_VOBJS
	1005	_puts("LOCK : ");
	1006	_puts(vobj[vobj_id].name);
	1007	_puts("\n");
	1008	#endif
	1009	break;
	1010	}
	1011	case VOBJ_TYPE_BUFFER: // nothing to initialise
	1012	{
	1013	#if BOOT_DEBUG_VOBJS
	1014	_puts("BUFFER : ");
	1015	_puts(vobj[vobj_id].name);
	1016	_puts(" / paddr = ");
	1017	_putl(vobj[vobj_id].paddr);
	1018	_puts(" / length = ");
	1019	_putx(vobj[vobj_id].length);
	1020	_puts("\n");
	1021	#endif
	1022	break;
	1023	}
	1024	case VOBJ_TYPE_MEMSPACE:
	1025	{
	1026	giet_memspace_t* memspace = (giet_memspace_t *) vobj[vobj_id].vaddr;
	1027	memspace->buffer = (void *) vobj[vobj_id].vaddr + 8;
	1028	memspace->size = vobj[vobj_id].length - 8;
	1029	#if BOOT_DEBUG_VOBJS
	1030	_puts("MEMSPACE : ");
	1031	_puts(vobj[vobj_id].name);
	1032	_puts(" / vaddr = ");
	1033	_putx(vobj[vobj_id].vaddr);
	1034	_puts(" / length = ");
	1035	_putx(vobj[vobj_id].length);
	1036	_puts(" / buffer = ");
	1037	_putx((unsigned int)memspace->buffer);
	1038	_puts(" / size = ");
	1039	_putx(memspace->size);
	1040	_puts("\n");
	1041	#endif
	1042	break;
	1043	}
	1044	case VOBJ_TYPE_PTAB: // nothing to initialize
	1045	{
	1046	ptab_found = 1;
	1047	#if BOOT_DEBUG_VOBJS
	1048	_puts("PTAB : ");
	1049	_puts(vobj[vobj_id].name);
	1050	_puts(" / length = ");
	1051	_putx(vobj[vobj_id].length);
	1052	_puts("\n");
	1053	#endif
	1054	break;
	1055	}
	1056	case VOBJ_TYPE_CONST:
	1057	{
	1058	unsigned int* addr = (unsigned int *) vobj[vobj_id].vaddr;
	1059	*addr = vobj[vobj_id].init;
	1060	#if BOOT_DEBUG_VOBJS
	1061	_puts("CONST : ");
	1062	_puts(vobj[vobj_id].name);
	1063	_puts(" / Paddr :");
	1064	_putl(vobj[vobj_id].paddr);
	1065	_puts(" / init = ");
	1066	_putx(*addr);
	1067	_puts("\n");
	1068	#endif
	1069	break;
	1070	}
	1071	default:
	1072	{
	1073	_puts("\n[BOOT ERROR] illegal vobj type: ");
	1074	_putd(vobj[vobj_id].type);
	1075	_puts("\n");
	1076	_exit();
	1077	}
	1078	} // end switch type
	1079	} // end loop on vobjs
	1080	if (ptab_found == 0)
	1081	{
	1082	_puts("\n[BOOT ERROR] Missing PTAB for vspace ");
	1083	_putd(vspace_id);
	1084	_exit();
	1085	}
	1086	} // end loop on vspaces
	1087
	1088	} // end boot_vobjs_init()
	1089
	1090	///////////////////////////////////////////////////////////////////////////////
	1091	// This function returns in the vbase and length buffers the virtual base
	1092	// address and the length of the segment allocated to the schedulers array
	1093	// in the cluster defined by the clusterid argument.
	1094	///////////////////////////////////////////////////////////////////////////////
	1095	void boot_get_sched_vaddr( unsigned int cluster_id,
	1096	unsigned int* vbase,
	1097	unsigned int* length )
	1098	{
	1099	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	1100	mapping_vobj_t* vobj = _get_vobj_base(header);
	1101	mapping_vseg_t* vseg = _get_vseg_base(header);
	1102	mapping_pseg_t* pseg = _get_pseg_base(header);
	1103
	1104	unsigned int vseg_id;
	1105	unsigned int found = 0;
	1106
	1107	for ( vseg_id = 0 ; (vseg_id < header->vsegs) && (found == 0) ; vseg_id++ )
	1108	{
	1109	if ( (vobj[vseg[vseg_id].vobj_offset].type == VOBJ_TYPE_SCHED) &&
[263]	1110	(pseg[vseg[vseg_id].psegid].clusterid == cluster_id ) )
[258]	1111	{
	1112	*vbase = vseg[vseg_id].vbase;
	1113	*length = vobj[vseg[vseg_id].vobj_offset].length;
	1114	found = 1;
	1115	}
	1116	}
	1117	if ( found == 0 )
	1118	{
[263]	1119	mapping_cluster_t* cluster = _get_cluster_base(header);
	1120	_puts("\n[BOOT ERROR] No vobj of type SCHED in cluster [");
	1121	_putd( cluster[cluster_id].x );
	1122	_puts(",");
	1123	_putd( cluster[cluster_id].y );
	1124	_puts("]\n");
[258]	1125	_exit();
	1126	}
	1127	} // end boot_get_sched_vaddr()
	1128
	1129	////////////////////////////////////////////////////////////////////////////////////
	1130	// This function initialises all processors schedulers.
	1131	// This is done by processor 0, and the MMU must be activated.
	1132	// - In Step 1, it initialises the _schedulers[gpid] pointers array, and scan
	1133	// the processors to initialise the schedulers, including the
	1134	// idle_task context (ltid == 14).
	1135	// - In Step 2, it scan all tasks in all vspaces to initialise the tasks contexts,
	1136	// as specified in the mapping_info data structure.
	1137	////////////////////////////////////////////////////////////////////////////////////
	1138	void boot_schedulers_init()
	1139	{
	1140	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	1141	mapping_cluster_t* cluster = _get_cluster_base(header);
	1142	mapping_vspace_t* vspace = _get_vspace_base(header);
	1143	mapping_task_t* task = _get_task_base(header);
	1144	mapping_vobj_t* vobj = _get_vobj_base(header);
	1145	mapping_proc_t* proc = _get_proc_base(header);
	1146	mapping_irq_t* irq = _get_irq_base(header);
	1147
	1148	unsigned int cluster_id; // cluster index in mapping_info
	1149	unsigned int proc_id; // processor index in mapping_info
	1150	unsigned int irq_id; // irq index in mapping_info
	1151	unsigned int vspace_id; // vspace index in mapping_info
	1152	unsigned int task_id; // task index in mapping_info
	1153
	1154	// TTY, NIC, CMA, HBA, TIM and DMA channels allocators
	1155	// - TTY[0] is reserved for the kernel
	1156	// - In all clusters the first NB_PROCS_MAX timers
	1157	// are reserved for the kernel (context switch)
	1158
	1159	unsigned int alloc_tty_channel = 1; // TTY channel allocator
	1160	unsigned int alloc_nic_channel = 0; // NIC channel allocator
	1161	unsigned int alloc_cma_channel = 0; // CMA channel allocator
	1162	unsigned int alloc_hba_channel = 0; // IOC channel allocator
[263]	1163	unsigned int alloc_tim_channel[X_SIZE*Y_SIZE]; // user TIMER allocators
[258]	1164
	1165	/////////////////////////////////////////////////////////////////////////
	1166	// Step 1 : loop on the clusters and on the processors
	1167	// to initialize the schedulers[] array of pointers,
	1168	// and the interrupt vectors.
	1169	// Implementation note:
	1170	// We need to use both proc_id to scan the mapping info structure,
	1171	// and lpid to access the schedulers array.
	1172	// - the _schedulers[] array of pointers can contain "holes", because
[263]	1173	// it is indexed by the global pid = cluster_xy*NB_PROCS_MAX + lpid
[258]	1174	// - the mapping info array of processors is contiguous, it is indexed
	1175	// by proc_id, and use an offset specific in each cluster.
	1176
[263]	1177	for (cluster_id = 0 ; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
[258]	1178	{
[263]	1179	unsigned int x = cluster[cluster_id].x;
	1180	unsigned int y = cluster[cluster_id].y;
	1181	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
[258]	1182
	1183	#if BOOT_DEBUG_SCHED
[263]	1184	_puts("\n[BOOT DEBUG] Initialise schedulers in cluster[");
	1185	_putd( x );
	1186	_puts(",");
	1187	_putd( y );
	1188	_puts("]\n");
[258]	1189	#endif
	1190	alloc_tim_channel[cluster_id] = NB_PROCS_MAX;
	1191
	1192	unsigned int lpid; // processor local index in cluster
	1193	unsigned int sched_vbase; // schedulers segment virtual base address
	1194	unsigned int sched_length; // schedulers segment length
	1195	unsigned int nprocs; // number of processors in cluster
	1196
	1197	nprocs = cluster[cluster_id].procs;
	1198
	1199	// checking processors number
	1200	if ( nprocs > NB_PROCS_MAX )
	1201	{
[263]	1202	_puts("\n[BOOT ERROR] Too much processors in cluster[");
	1203	_putd( x );
	1204	_puts(",");
	1205	_putd( y );
	1206	_puts("]\n");
[258]	1207	_exit();
	1208	}
	1209
	1210	// get scheduler array virtual base address and length
	1211	boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length );
	1212
	1213	// each processor scheduler requires 4 Kbytes
	1214	if ( sched_length < (nprocs<<12) )
	1215	{
[263]	1216	_puts("\n[BOOT ERROR] Schedulers segment too small in cluster[");
	1217	_putd( x );
	1218	_puts(",");
	1219	_putd( y );
	1220	_puts("]\n");
[258]	1221	_exit();
	1222	}
	1223
	1224	// loop on processors
	1225	for ( proc_id = cluster[cluster_id].proc_offset, lpid = 0 ;
	1226	proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs;
	1227	proc_id++, lpid++ )
	1228	{
[263]	1229	// current processor scheduler pointer : psched
	1230	static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12));
	1231
[258]	1232	// set the schedulers pointers array
[263]	1233	_schedulers[cluster_xy * NB_PROCS_MAX + lpid] = psched;
[258]	1234
	1235	#if BOOT_DEBUG_SCHED
	1236	_puts("\nProc_");
[263]	1237	_putd( x );
[258]	1238	_puts("_");
[263]	1239	_putd( y );
	1240	_puts("_");
	1241	_putd( lpid );
[258]	1242	_puts(" : scheduler virtual base address = ");
	1243	_putx( sched_vbase + (lpid<<12) );
	1244	_puts("\n");
	1245	#endif
	1246
	1247	// initialise the "tasks" variable : default value is 0
	1248	psched->tasks = 0;
	1249
	1250	// initialise the "current" variable : default value is idle_task
	1251	psched->current = IDLE_TASK_INDEX;
	1252
	1253	// initialise interrupt_vector with default value (valid bit = 0)
	1254	unsigned int slot;
	1255	for (slot = 0; slot < 32; slot++) psched->interrupt_vector[slot] = 0;
	1256
	1257	// initialise interrupt vector with the IRQs actually allocated
	1258	for (irq_id = proc[proc_id].irq_offset;
	1259	irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs;
	1260	irq_id++)
	1261	{
	1262	unsigned int type = irq[irq_id].type;
	1263	unsigned int icu_id = irq[irq_id].icuid;
	1264	unsigned int isr_id = irq[irq_id].isr;
	1265	unsigned int channel = irq[irq_id].channel;
	1266
	1267	unsigned int value = ((isr_id & 0xFF) ) \|
	1268	((type & 0xFF) << 8) \|
	1269	((channel & 0x7FFF) << 16) \|
	1270	0x80000000; // Valid entry
	1271
	1272	psched->interrupt_vector[icu_id] = value;
	1273
	1274	#if BOOT_DEBUG_SCHED
	1275	_puts("- IRQ : icu = ");
	1276	_putd(icu_id);
	1277	_puts(" / type = ");
	1278	_putd(type);
	1279	_puts(" / isr = ");
	1280	_putd(isr_id);
	1281	_puts(" / channel = ");
	1282	_putd(channel);
	1283	_puts(" => vector_entry = ");
	1284	_putx( value );
	1285	_puts("\n");
	1286	#endif
	1287	}
	1288
	1289	// initializes the idle_task context in scheduler:
	1290	// - the SR slot is 0xFF03 because this task run in kernel mode.
	1291	// - it uses the page table of vspace[0]
	1292	// - it uses the kernel TTY terminal
	1293	// - slots containing addresses (SP, RA, EPC, PTAB, PTPR)
	1294	// must be re-initialised by kernel_parallel_init()
	1295
	1296	psched->context[IDLE_TASK_INDEX][CTX_SR_ID] = 0xFF03;
	1297	psched->context[IDLE_TASK_INDEX][CTX_PTPR_ID] = _ptabs_paddr[0]>>13;
	1298	psched->context[IDLE_TASK_INDEX][CTX_PTAB_ID] = _ptabs_vaddr[0];
	1299	psched->context[IDLE_TASK_INDEX][CTX_TTY_ID] = 0;
	1300	psched->context[IDLE_TASK_INDEX][CTX_LTID_ID] = IDLE_TASK_INDEX;
	1301	psched->context[IDLE_TASK_INDEX][CTX_VSID_ID] = 0;
	1302	psched->context[IDLE_TASK_INDEX][CTX_RUN_ID] = 1;
	1303
	1304	} // end for procs
	1305	} // end for clusters
	1306
	1307	///////////////////////////////////////////////////////////////////
	1308	// Step 2 : loop on the vspaces and the tasks
	1309	// to initialise the schedulers and the task contexts.
	1310
	1311	for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++)
	1312	{
	1313	// We must set the PTPR depending on the vspace, because the start_vector
	1314	// and the stack address are defined in virtual space.
	1315	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id] >> 13) );
	1316
	1317	// loop on the tasks in vspace (task_id is the global index)
	1318	for (task_id = vspace[vspace_id].task_offset;
	1319	task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks);
	1320	task_id++)
	1321	{
	1322
[263]	1323	// compute the cluster coordinates
	1324	unsigned int x = cluster[task[task_id].clusterid].x;
	1325	unsigned int y = cluster[task[task_id].clusterid].y;
	1326	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
	1327
[258]	1328	#if BOOT_DEBUG_SCHED
	1329	_puts("\n[BOOT DEBUG] Initialise context for task ");
	1330	_puts( task[task_id].name );
	1331	_puts(" in vspace ");
	1332	_puts( vspace[vspace_id].name );
[263]	1333	_puts(" running on cluster[");
	1334	_putd( x );
	1335	_puts(",");
	1336	_putd( y );
	1337	_puts("]\n");
[258]	1338	#endif
	1339	// compute gpid (global processor index) and scheduler base address
[263]	1340	unsigned int gpid = cluster_xy * NB_PROCS_MAX + task[task_id].proclocid;
[258]	1341	static_scheduler_t* psched = _schedulers[gpid];
	1342
	1343	// ctx_sr : value required before an eret instruction
	1344	unsigned int ctx_sr = 0x0000FF13;
	1345
	1346	// ctx_ptpr : page table physical base address (shifted by 13 bit)
	1347	unsigned int ctx_ptpr = (unsigned int)(_ptabs_paddr[vspace_id] >> 13);
	1348
	1349	// ctx_ptab : page_table virtual base address
	1350	unsigned int ctx_ptab = _ptabs_vaddr[vspace_id];
	1351
	1352	// ctx_tty : TTY terminal global index provided by the global allocator
	1353	unsigned int ctx_tty = 0xFFFFFFFF;
	1354	if (task[task_id].use_tty)
	1355	{
	1356	if (alloc_tty_channel >= NB_TTY_CHANNELS)
	1357	{
	1358	_puts("\n[BOOT ERROR] TTY index too large for task ");
	1359	_puts(task[task_id].name);
	1360	_puts(" in vspace ");
	1361	_puts(vspace[vspace_id].name);
	1362	_puts("\n");
	1363	_exit();
	1364	}
	1365	ctx_tty = alloc_tty_channel;
	1366	alloc_tty_channel++;
	1367	}
	1368	// ctx_nic : NIC channel global index provided by the global allocator
	1369	unsigned int ctx_nic = 0xFFFFFFFF;
	1370	if (task[task_id].use_nic)
	1371	{
	1372	if (alloc_nic_channel >= NB_NIC_CHANNELS)
	1373	{
	1374	_puts("\n[BOOT ERROR] NIC channel index too large for task ");
	1375	_puts(task[task_id].name);
	1376	_puts(" in vspace ");
	1377	_puts(vspace[vspace_id].name);
	1378	_puts("\n");
	1379	_exit();
	1380	}
	1381	ctx_nic = alloc_nic_channel;
	1382	alloc_nic_channel++;
	1383	}
	1384	// ctx_cma : CMA channel global index provided by the global allocator
	1385	unsigned int ctx_cma = 0xFFFFFFFF;
	1386	if (task[task_id].use_cma)
	1387	{
	1388	if (alloc_cma_channel >= NB_CMA_CHANNELS)
	1389	{
	1390	_puts("\n[BOOT ERROR] CMA channel index too large for task ");
	1391	_puts(task[task_id].name);
	1392	_puts(" in vspace ");
	1393	_puts(vspace[vspace_id].name);
	1394	_puts("\n");
	1395	_exit();
	1396	}
	1397	ctx_cma = alloc_cma_channel;
	1398	alloc_cma_channel++;
	1399	}
	1400	// ctx_hba : HBA channel global index provided by the global allocator
	1401	unsigned int ctx_hba = 0xFFFFFFFF;
	1402	if (task[task_id].use_hba)
	1403	{
	1404	if (alloc_hba_channel >= NB_HBA_CHANNELS)
	1405	{
	1406	_puts("\n[BOOT ERROR] IOC channel index too large for task ");
	1407	_puts(task[task_id].name);
	1408	_puts(" in vspace ");
	1409	_puts(vspace[vspace_id].name);
	1410	_puts("\n");
	1411	_exit();
	1412	}
	1413	ctx_hba = alloc_hba_channel;
	1414	alloc_hba_channel++;
	1415	}
	1416	// ctx_tim : TIM local channel index provided by the cluster allocator
	1417	unsigned int ctx_tim = 0xFFFFFFFF;
	1418	if (task[task_id].use_tim)
	1419	{
	1420	unsigned int cluster_id = task[task_id].clusterid;
	1421
	1422	if ( alloc_tim_channel[cluster_id] >= NB_TIM_CHANNELS )
	1423	{
	1424	_puts("\n[BOOT ERROR] local TIMER index too large for task ");
	1425	_puts(task[task_id].name);
	1426	_puts(" in vspace ");
	1427	_puts(vspace[vspace_id].name);
	1428	_puts("\n");
	1429	_exit();
	1430	}
	1431
	1432	// checking that there is an ISR_TIMER installed
	1433	unsigned int found = 0;
	1434	for ( irq_id = 0 ; irq_id < 32 ; irq_id++ )
	1435	{
	1436	unsigned int entry = psched->interrupt_vector[irq_id];
	1437	unsigned int isr = entry & 0x000000FF;
	1438	unsigned int channel = entry>>16;
	1439	if ( (isr == ISR_TIMER) && (channel == alloc_tim_channel[cluster_id]) )
	1440	{
	1441	found = 1;
	1442	ctx_tim = alloc_tim_channel[cluster_id];
	1443	alloc_tim_channel[cluster_id]++;
	1444	break;
	1445	}
	1446	}
	1447	if (!found)
	1448	{
	1449	_puts("\n[BOOT ERROR] No ISR_TIMER installed for task ");
	1450	_puts(task[task_id].name);
	1451	_puts(" in vspace ");
	1452	_puts(vspace[vspace_id].name);
	1453	_puts("\n");
	1454	_exit();
	1455	}
	1456	}
	1457	// ctx_epc : Get the virtual address of the memory location containing
	1458	// the task entry point : the start_vector is stored by GCC in the seg_data
	1459	// segment and we must wait the .elf loading to get the entry point value...
	1460	mapping_vobj_t* pvobj = &vobj[vspace[vspace_id].vobj_offset +
	1461	vspace[vspace_id].start_offset];
	1462	unsigned int ctx_epc = pvobj->vaddr + (task[task_id].startid)*4;
	1463
	1464	// ctx_sp : Get the vobj containing the stack
	1465	unsigned int vobj_id = task[task_id].stack_vobjid + vspace[vspace_id].vobj_offset;
	1466	unsigned int ctx_sp = vobj[vobj_id].vaddr + vobj[vobj_id].length;
	1467
	1468	// get local task index in scheduler
	1469	unsigned int ltid = psched->tasks;
	1470
	1471	if (ltid >= IDLE_TASK_INDEX)
	1472	{
	1473	_puts("\n[BOOT ERROR] in boot_schedulers_init() : ");
	1474	_putd( ltid );
	1475	_puts(" tasks allocated to processor ");
	1476	_putd( gpid );
	1477	_puts(" / max is ");
	1478	_putd( IDLE_TASK_INDEX );
	1479	_puts("\n");
	1480	_exit();
	1481	}
	1482
	1483	// update the "tasks" and "current" fields in scheduler:
	1484	// the first task to execute is task 0 as soon as there is at least
	1485	// one task allocated to processor.
	1486	psched->tasks = ltid + 1;
	1487	psched->current = 0;
	1488
	1489	// initializes the task context in scheduler
	1490	psched->context[ltid][CTX_SR_ID] = ctx_sr;
	1491	psched->context[ltid][CTX_SP_ID] = ctx_sp;
	1492	psched->context[ltid][CTX_EPC_ID] = ctx_epc;
	1493	psched->context[ltid][CTX_PTPR_ID] = ctx_ptpr;
	1494	psched->context[ltid][CTX_TTY_ID] = ctx_tty;
	1495	psched->context[ltid][CTX_CMA_ID] = ctx_cma;
	1496	psched->context[ltid][CTX_HBA_ID] = ctx_hba;
	1497	psched->context[ltid][CTX_NIC_ID] = ctx_nic;
	1498	psched->context[ltid][CTX_TIM_ID] = ctx_tim;
	1499	psched->context[ltid][CTX_PTAB_ID] = ctx_ptab;
	1500	psched->context[ltid][CTX_LTID_ID] = ltid;
	1501	psched->context[ltid][CTX_GTID_ID] = task_id;
	1502	psched->context[ltid][CTX_VSID_ID] = vspace_id;
	1503	psched->context[ltid][CTX_RUN_ID] = 1;
	1504
	1505	#if BOOT_DEBUG_SCHED
	1506	_puts("\nTask ");
	1507	_puts( task[task_id].name );
	1508	_puts(" (");
	1509	_putd( task_id );
	1510	_puts(") allocated to processor ");
	1511	_putd( gpid );
	1512	_puts("\n - ctx[LTID] = ");
	1513	_putd( psched->context[ltid][CTX_LTID_ID] );
	1514	_puts("\n - ctx[SR] = ");
	1515	_putx( psched->context[ltid][CTX_SR_ID] );
	1516	_puts("\n - ctx[SP] = ");
	1517	_putx( psched->context[ltid][CTX_SP_ID] );
	1518	_puts("\n - ctx[EPC] = ");
	1519	_putx( psched->context[ltid][CTX_EPC_ID] );
	1520	_puts("\n - ctx[PTPR] = ");
	1521	_putx( psched->context[ltid][CTX_PTPR_ID] );
	1522	_puts("\n - ctx[TTY] = ");
	1523	_putd( psched->context[ltid][CTX_TTY_ID] );
	1524	_puts("\n - ctx[NIC] = ");
	1525	_putd( psched->context[ltid][CTX_NIC_ID] );
	1526	_puts("\n - ctx[CMA] = ");
	1527	_putd( psched->context[ltid][CTX_CMA_ID] );
	1528	_puts("\n - ctx[IOC] = ");
	1529	_putd( psched->context[ltid][CTX_HBA_ID] );
	1530	_puts("\n - ctx[TIM] = ");
	1531	_putd( psched->context[ltid][CTX_TIM_ID] );
	1532	_puts("\n - ctx[PTAB] = ");
	1533	_putx( psched->context[ltid][CTX_PTAB_ID] );
	1534	_puts("\n - ctx[GTID] = ");
	1535	_putd( psched->context[ltid][CTX_GTID_ID] );
	1536	_puts("\n - ctx[VSID] = ");
	1537	_putd( psched->context[ltid][CTX_VSID_ID] );
	1538	_puts("\n");
	1539	#endif
	1540
	1541	} // end loop on tasks
	1542	} // end loop on vspaces
	1543	} // end _schedulers_init()
	1544
	1545	//////////////////////////////////////////////////////////////////////////////////
	1546	// This function loads the map.bin file from block device.
	1547	// The fat global varible is defined in fat32.c file.
	1548	//////////////////////////////////////////////////////////////////////////////////
	1549	void boot_mapping_init()
	1550	{
	1551	// Initializing the FAT descriptor and files descriptor array
	1552	if ( _fat_init( IOC_BOOT_PA_MODE ) )
	1553	{
	1554	_puts("[BOOT ERROR] Cannot initialize FAT descriptor fom Boot Sector\n");
	1555	_exit();
	1556	}
	1557
	1558	#if BOOT_DEBUG_MAPPING
	1559	_puts("\n[BOOT] FAT initialisation completed at cycle ");
	1560	_putd(_get_proctime());
	1561	_puts("\n");
	1562	_fat_print();
	1563	#endif
	1564
	1565	int fd_id = _fat_open( IOC_BOOT_PA_MODE,
	1566	"map.bin",
	1567	0 ); // no creation
	1568
	1569	if ( fd_id == -1 )
	1570	{
	1571	_puts("\n[BOOT ERROR] : map.bin file not found \n");
	1572	_exit();
	1573	}
	1574
	1575	#if BOOT_DEBUG_MAPPING
	1576	_puts("\n[BOOT] map.bin file successfully open at cycle ");
	1577	_putd(_get_proctime());
	1578	_puts("\n");
	1579	#endif
	1580
	1581	unsigned int size = fat.fd[fd_id].file_size;
	1582	unsigned int nblocks = size >> 9;
	1583	unsigned int offset = size & 0x1FF;
	1584	if ( offset ) nblocks++;
	1585
	1586	unsigned int ok = _fat_read( IOC_BOOT_PA_MODE,
	1587	fd_id,
	1588	(unsigned int*)( &seg_boot_mapping_base),
	1589	nblocks,
	1590	0 ); // offset
	1591	if ( ok == -1 )
	1592	{
	1593	_puts("\n[BOOT ERROR] : unable to load map.bin file \n");
	1594	_exit();
	1595	}
	1596	_fat_close( fd_id );
	1597
	1598	boot_mapping_check();
	1599	} // end boot_mapping_init()
	1600
	1601
	1602	//////////////////////////////////////////////////////////////////////////////////
	1603	// This function open the .elf file identified by the "pathname" argument.
	1604	// It loads the complete file in a dedicated buffer, it copies all loadable
	1605	// segments at the memory virtual address defined in the .elf file,
	1606	// and close the file.
	1607	// Notes:
	1608	// - The processor PTPR should contain the value corresponding to the
	1609	// vspace containing the .elf file.
	1610	// - As this function requires a temporary memory buffer
	1611	// to load the complete .elf file before to copy the various segments
	1612	// to te proper location, it uses the seg_boot_buffer defined in map.xml.
	1613	//////////////////////////////////////////////////////////////////////////////////
	1614	void load_one_elf_file( unsigned int mode,
	1615	char* pathname,
	1616	unsigned int vspace_id ) // to use the proper page_table
	1617	{
	1618	unsigned int seg_id;
	1619
	1620	// get boot buffer address and size
	1621	char* boot_buffer = (char*)(&seg_boot_buffer_base);
	1622	unsigned int boot_buffer_size = (unsigned int)(&seg_boot_buffer_size);
	1623
	1624	#if BOOT_DEBUG_ELF
	1625	_puts("\n[BOOT DEBUG] Start searching file ");
	1626	_puts( pathname );
	1627	_puts(" at cycle ");
	1628	_putd( _get_proctime() );
	1629	_puts("\n");
	1630	#endif
	1631
	1632	// open .elf file
	1633	int fd_id = _fat_open( mode,
	1634	pathname,
	1635	0 ); // no creation
	1636	if ( fd_id < 0 )
	1637	{
	1638	_puts("\n[BOOT ERROR] load_one_elf_file() : ");
	1639	_puts( pathname );
	1640	_puts(" not found\n");
	1641	_exit();
	1642	}
	1643
	1644	// check boot_buffer size versus file size
	1645	if ( fat.fd[fd_id].file_size > boot_buffer_size )
	1646	{
	1647	_puts("\n[BOOT ERROR] load_one_elf_file() : ");
	1648	_puts( pathname );
	1649	_puts(" exceeds the seg_boot_buffer size\n");
	1650	_exit();
	1651	}
	1652
	1653	// compute number of sectors
	1654	unsigned int nbytes = fat.fd[fd_id].file_size;
	1655	unsigned int nsectors = nbytes>>9;
	1656	if( nbytes & 0x1FF) nsectors++;
	1657
	1658	// load file in boot_buffer
	1659	if( _fat_read( mode,
	1660	fd_id,
	1661	boot_buffer,
	1662	nsectors,
	1663	0 ) != nsectors )
	1664	{
	1665	_puts("\n[BOOT ERROR] load_one_elf_file() : unexpected EOF for file ");
	1666	_puts( pathname );
	1667	_puts("\n");
	1668	_exit();
	1669	}
	1670
	1671	// Check ELF Magic Number in ELF header
	1672	Elf32_Ehdr* elf_header_ptr = (Elf32_Ehdr*)boot_buffer;
	1673
	1674	if ( (elf_header_ptr->e_ident[EI_MAG0] != ELFMAG0) \|\|
	1675	(elf_header_ptr->e_ident[EI_MAG1] != ELFMAG1) \|\|
	1676	(elf_header_ptr->e_ident[EI_MAG2] != ELFMAG2) \|\|
	1677	(elf_header_ptr->e_ident[EI_MAG3] != ELFMAG3) )
	1678	{
	1679	_puts("\n[BOOT ERROR] load_elf() : file ");
	1680	_puts( pathname );
	1681	_puts(" does not use ELF format\n");
	1682	_exit();
	1683	}
	1684
	1685	// get program header table pointer
	1686	unsigned int pht_index = elf_header_ptr->e_phoff;
	1687	if( pht_index == 0 )
	1688	{
	1689	_puts("\n[BOOT ERROR] load_one_elf_file() : file ");
	1690	_puts( pathname );
	1691	_puts(" does not contain loadable segment\n");
	1692	_exit();
	1693	}
	1694	Elf32_Phdr* elf_pht_ptr = (Elf32_Phdr*)(boot_buffer + pht_index);
	1695
	1696	// get number of segments
	1697	unsigned int nsegments = elf_header_ptr->e_phnum;
	1698
	1699	#if BOOT_DEBUG_ELF
	1700	_puts("\n[BOOT DEBUG] File ");
	1701	_puts( pathname );
	1702	_puts(" loaded at cycle ");
	1703	_putd( _get_proctime() );
	1704	_puts(" / bytes = ");
	1705	_putd( nbytes );
	1706	_puts(" / sectors = ");
	1707	_putd( nsectors );
	1708	_puts("\n");
	1709	#endif
	1710
	1711	// Loop on loadable segments in the ELF file
	1712	for (seg_id = 0 ; seg_id < nsegments ; seg_id++)
	1713	{
	1714	if(elf_pht_ptr[seg_id].p_type == PT_LOAD)
	1715	{
	1716	// Get segment attributes
	1717	unsigned int seg_vaddr = elf_pht_ptr[seg_id].p_vaddr;
	1718	unsigned int seg_offset = elf_pht_ptr[seg_id].p_offset;
	1719	unsigned int seg_filesz = elf_pht_ptr[seg_id].p_filesz;
	1720	unsigned int seg_memsz = elf_pht_ptr[seg_id].p_memsz;
	1721
	1722	if( seg_memsz < seg_filesz )
	1723	{
	1724	_puts("\n[BOOT ERROR] load_one_elf_file() : segment at vaddr = ");
	1725	_putx( seg_vaddr );
	1726	_puts(" in file ");
	1727	_puts( pathname );
	1728	_puts(" has a wrong size \n");
	1729	_exit();
	1730	}
	1731
	1732	// fill empty space with 0 as required
	1733	if( seg_memsz > seg_filesz )
	1734	{
	1735	unsigned int i;
	1736	for( i = seg_filesz ; i < seg_memsz; i++ ) boot_buffer[i] = 0;
	1737	}
	1738
	1739	unsigned int src_vaddr = (unsigned int)boot_buffer + seg_offset;
	1740
	1741	#if BOOT_DEBUG_ELF
	1742	_puts(" - segment ");
	1743	_putd( seg_id );
	1744	_puts(" / dst_vaddr = ");
	1745	_putx( seg_vaddr );
	1746	_puts(" / src_vaddr = ");
	1747	_putx( src_vaddr );
	1748	_puts(" / size = ");
	1749	_putx( seg_filesz );
	1750	_puts("\n");
	1751	#endif
	1752
	1753	// copy the segment from boot buffer to destination buffer
	1754	if( NB_DMA_CHANNELS > 0 )
	1755	{
	1756	_dma_copy( vspace_id, // required for V2P translation
	1757	(char*)seg_vaddr,
	1758	(char*)src_vaddr,
	1759	seg_filesz );
	1760	}
	1761	else
	1762	{
	1763	_memcpy( (char*)seg_vaddr,
	1764	(char*)src_vaddr,
	1765	seg_filesz );
	1766	}
	1767	}
	1768	} // end for segments
	1769
	1770	// close .elf file
	1771	_fat_close( fd_id );
	1772
	1773	} // end load_one_elf_file()
	1774
	1775
	1776	//////////////////////////////////////////////////////////////////////////////////
	1777	// This function uses the map.bin data structure to load the "kernel.elf" file
	1778	// as well as the various "application.elf" files.
	1779	// The "preloader.elf" file is not loaded, because it has been burned in the ROM.
	1780	// The "boot.elf" file is not loaded, because it has been loaded by the preloader.
	1781	// It scans all vobjs defined in the map.bin data structure to collect
	1782	// all .elf files pathnames, and calls the load_one_elf_file() function to
	1783	// load all loadable segments at the virtual address found in the .elf file.
	1784	//////////////////////////////////////////////////////////////////////////////////
	1785	void boot_elf_load()
	1786	{
	1787	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	1788	mapping_vspace_t* vspace = _get_vspace_base( header );
	1789	mapping_vobj_t* vobj = _get_vobj_base( header );
	1790	unsigned int vspace_id;
	1791	unsigned int vobj_id;
	1792	unsigned int found;
	1793
	1794	// Scan all vobjs corresponding to global vsegs,
	1795	// to find the pathname to the kernel.elf file
	1796	found = 0;
	1797	for( vobj_id = 0 ; vobj_id < header->globals ; vobj_id++ )
	1798	{
	1799	if(vobj[vobj_id].type == VOBJ_TYPE_ELF)
	1800	{
	1801	found = 1;
	1802	break;
	1803	}
	1804	}
	1805
	1806	// We need one kernel.elf file
	1807	if (found == 0)
	1808	{
	1809	_puts("[BOOT ERROR] boot_elf_load() : kernel.elf file not found\n");
	1810	_exit();
	1811	}
	1812
	1813	load_one_elf_file( IOC_BOOT_VA_MODE,
	1814	vobj[vobj_id].binpath,
	1815	0 ); // vspace 0
	1816
	1817	_puts("\n[BOOT] File ");
	1818	_puts( vobj[vobj_id].binpath );
	1819	_puts(" loaded at cycle ");
	1820	_putd( _get_proctime() );
	1821	_puts("\n");
	1822
	1823	// loop on the vspaces, scanning all vobjs in a vspace,
	1824	// to find the pathname of the .elf file associated to the vspace.
	1825	for( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
	1826	{
	1827	// Set PTPR depending on the vspace, as seg_data is defined in virtual space.
	1828	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id] >> 13) );
	1829
	1830	// loop on the vobjs in vspace (vobj_id is the global index)
	1831	unsigned int found = 0;
	1832	for (vobj_id = vspace[vspace_id].vobj_offset;
	1833	vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs);
	1834	vobj_id++)
	1835	{
	1836	if(vobj[vobj_id].type == VOBJ_TYPE_ELF)
	1837	{
	1838	found = 1;
	1839	break;
	1840	}
	1841	}
	1842
	1843	// We want one .elf file per vspace
	1844	if (found == 0)
	1845	{
	1846	_puts("[BOOT ERROR] boot_elf_load() : .elf file not found for vspace ");
	1847	_puts( vspace[vspace_id].name );
	1848	_puts("\n");
	1849	_exit();
	1850	}
	1851
	1852	load_one_elf_file( IOC_BOOT_VA_MODE,
	1853	vobj[vobj_id].binpath,
	1854	vspace_id );
	1855
	1856	_puts("\n[BOOT] File ");
	1857	_puts( vobj[vobj_id].binpath );
	1858	_puts(" loaded at cycle ");
	1859	_putd( _get_proctime() );
	1860	_puts("\n");
	1861
	1862	} // end for vspaces
	1863
	1864	// restaure vspace 0 PTPR
	1865	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0] >> 13) );
	1866
	1867	} // end boot_elf_load()
	1868
	1869	////////////////////////////////////////////////////////////////////////////////
	1870	// This function intializes the periherals and coprocessors, as specified
	1871	// in the mapping_info file.
	1872	////////////////////////////////////////////////////////////////////////////////
	1873	void boot_peripherals_init()
	1874	{
	1875	mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
	1876	mapping_cluster_t * cluster = _get_cluster_base(header);
	1877	mapping_periph_t * periph = _get_periph_base(header);
	1878	mapping_vobj_t * vobj = _get_vobj_base(header);
	1879	mapping_vspace_t * vspace = _get_vspace_base(header);
	1880	mapping_coproc_t * coproc = _get_coproc_base(header);
	1881	mapping_cp_port_t * cp_port = _get_cp_port_base(header);
	1882
	1883	unsigned int cluster_id;
	1884	unsigned int periph_id;
	1885	unsigned int coproc_id;
	1886	unsigned int cp_port_id;
	1887	unsigned int channel_id;
	1888
[263]	1889	// loop on all physical clusters
	1890	for (cluster_id = 0; cluster_id < X_SIZE*Y_SIZE; cluster_id++)
[258]	1891	{
[263]	1892	// computes cluster coordinates
	1893	unsigned int x = cluster[cluster_id].x;
	1894	unsigned int y = cluster[cluster_id].y;
	1895	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
[258]	1896
	1897	#if BOOT_DEBUG_PERI
[263]	1898	_puts("\n[BOOT DEBUG] ****** peripherals initialisation in cluster[");
	1899	_putd( x );
	1900	_puts(",");
	1901	_putd( y );
	1902	_puts("] ******\n");
[258]	1903	#endif
	1904
[263]	1905	// loop on peripherals
[258]	1906	for (periph_id = cluster[cluster_id].periph_offset;
	1907	periph_id < cluster[cluster_id].periph_offset +
	1908	cluster[cluster_id].periphs; periph_id++)
	1909	{
	1910	unsigned int type = periph[periph_id].type;
	1911	unsigned int channels = periph[periph_id].channels;
	1912
	1913	switch (type)
	1914	{
	1915	case PERIPH_TYPE_IOC: // vci_block_device component
	1916	{
	1917	_ioc_init();
	1918	#if BOOT_DEBUG_PERI
[263]	1919	_puts("- IOC / channels = ");
	1920	_putd(channels);
	1921	_puts("\n");
[258]	1922	#endif
	1923	break;
	1924	}
	1925	case PERIPH_TYPE_DMA: // vci_multi_dma component
	1926	{
	1927	for (channel_id = 0; channel_id < channels; channel_id++)
	1928	{
[263]	1929	_dma_init( cluster_xy, channel_id );
[258]	1930	}
	1931	#if BOOT_DEBUG_PERI
[263]	1932	_puts("- DMA / channels = ");
	1933	_putd(channels);
	1934	_puts("\n");
[258]	1935	#endif
	1936	break;
	1937	}
[263]	1938	case PERIPH_TYPE_FBF: // vci_block_device component
	1939	{
	1940	// nothing to do
	1941	#if BOOT_DEBUG_PERI
	1942	_puts("- FBF / channels = ");
	1943	_putd(channels);
	1944	_puts("\n");
	1945	#endif
	1946	break;
	1947	}
	1948	case PERIPH_TYPE_HBA: // vci_multi_ahci component
	1949	{
	1950	for (channel_id = 0; channel_id < channels; channel_id++)
	1951	{
	1952	// TODO
	1953	}
	1954	#if BOOT_DEBUG_PERI
	1955	_puts("- HBA / channels = ");
	1956	_putd(channels);
	1957	_puts("\n");
	1958	#endif
	1959	break;
	1960	}
	1961	case PERIPH_TYPE_CMA: // vci_chbuf_dma component
	1962	{
	1963	for (channel_id = 0; channel_id < channels; channel_id++)
	1964	{
	1965	// TODO
	1966	}
	1967	#if BOOT_DEBUG_PERI
	1968	_puts("- CMA / channels = ");
	1969	_putd(channels);
	1970	_puts("\n");
	1971	#endif
	1972	break;
	1973	}
[258]	1974	case PERIPH_TYPE_NIC: // vci_multi_nic component
	1975	{
	1976	for (channel_id = 0; channel_id < channels; channel_id++)
	1977	{
	1978	// TODO
	1979	}
	1980	#if BOOT_DEBUG_PERI
[263]	1981	_puts("- NIC / channels = ");
	1982	_putd(channels);
	1983	_puts("\n");
[258]	1984	#endif
	1985	break;
	1986	}
[263]	1987	case PERIPH_TYPE_XCU: // vci_xicu component
	1988	{
	1989	// nothing to do
	1990	#if BOOT_DEBUG_PERI
	1991	_puts("- XCU / channels = ");
	1992	_putd(channels);
	1993	_puts("\n");
	1994	#endif
	1995	break;
	1996	}
	1997	case PERIPH_TYPE_MMC: // vci_memcache config
	1998	{
	1999	// nothing to do
	2000	#if BOOT_DEBUG_PERI
	2001	_puts("- MMC / channels = ");
	2002	_putd(channels);
	2003	_puts("\n");
	2004	#endif
	2005	break;
	2006	}
[258]	2007	case PERIPH_TYPE_TTY: // vci_multi_tty component
	2008	{
	2009	#if BOOT_DEBUG_PERI
[263]	2010	_puts("- TTY / channels = ");
	2011	_putd(channels);
	2012	_puts("\n");
[258]	2013	#endif
	2014	break;
	2015	}
	2016	case PERIPH_TYPE_IOB: // vci_io_bridge component
	2017	{
	2018	if (USE_IOB)
	2019	{
	2020	// TODO
	2021	// get the iommu page table physical address
	2022	// define IPI address mapping the IOC interrupt
	2023	// set IOMMU page table address
	2024	// pseg_base[IOB_IOMMU_PTPR] = ptab_pbase;
	2025	// activate IOMMU
	2026	// pseg_base[IOB_IOMMU_ACTIVE] = 1;
	2027	}
	2028	#if BOOT_DEBUG_PERI
[263]	2029	_puts("- IOB / channels = ");
	2030	_putd(channels);
	2031	_puts("\n");
[258]	2032	#endif
	2033	break;
	2034	}
	2035	} // end switch periph type
	2036	} // end for periphs
	2037
	2038	#if BOOT_DEBUG_PERI
[263]	2039	_puts("\n[BOOT DEBUG] ****** coprocessors initialisation in cluster[");
	2040	_putd( x );
	2041	_puts(",");
	2042	_putd( y );
	2043	_puts("] ******\n");
[258]	2044	#endif
	2045
[263]	2046	// loop on coprocessors
[258]	2047	for ( coproc_id = cluster[cluster_id].coproc_offset;
	2048	coproc_id < cluster[cluster_id].coproc_offset +
	2049	cluster[cluster_id].coprocs; coproc_id++ )
	2050	{
	2051
	2052	#if BOOT_DEBUG_PERI
	2053	_puts("- coprocessor name : ");
	2054	_puts(coproc[coproc_id].name);
	2055	_puts(" / nb ports = ");
	2056	_putd((unsigned int) coproc[coproc_id].ports);
	2057	_puts("\n");
	2058	#endif
	2059	// loop on the coprocessor ports
	2060	for ( cp_port_id = coproc[coproc_id].port_offset;
	2061	cp_port_id < coproc[coproc_id].port_offset + coproc[coproc_id].ports;
	2062	cp_port_id++ )
	2063	{
	2064	unsigned int vspace_id = cp_port[cp_port_id].vspaceid;
	2065	unsigned int vobj_id = cp_port[cp_port_id].mwmr_vobjid +
	2066	vspace[vspace_id].vobj_offset;
	2067
	2068	// Get MWMR channel base address
	2069	paddr_t mwmr_channel_pbase = vobj[vobj_id].paddr;
	2070
[263]	2071	_mwr_hw_init( cluster_xy,
	2072	cp_port_id,
	2073	cp_port[cp_port_id].direction,
	2074	mwmr_channel_pbase );
[258]	2075	#if BOOT_DEBUG_PERI
	2076	_puts(" port direction: ");
	2077	_putd( (unsigned int)cp_port[cp_port_id].direction );
	2078	_puts(" / mwmr_channel_pbase = ");
	2079	_putl( mwmr_channel_pbase );
	2080	_puts(" / name = ");
	2081	_puts(vobj[vobj_id].name);
	2082	_puts(" / in vspace ");
	2083	_puts(vspace[vspace_id].name);
	2084	_puts("\n");
	2085	#endif
	2086	} // end for cp_ports
	2087	} // end for coprocs
	2088	} // end for clusters
	2089	} // end boot_peripherals_init()
	2090
	2091	/////////////////////////////////////////////////////////////////////////
	2092	// This function is the entry point of the boot code for all processors.
	2093	// Most of this code is executed by Processor 0 only.
	2094	/////////////////////////////////////////////////////////////////////////
	2095	void boot_init()
	2096	{
[263]	2097	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	2098	unsigned int gpid = _get_procid();
	2099	unsigned int cluster_xy = gpid / NB_PROCS_MAX;
	2100	unsigned int lpid = gpid % NB_PROCS_MAX;
[258]	2101
[263]	2102	if ( gpid == 0 ) // only Processor 0 does it
[258]	2103	{
	2104	_puts("\n[BOOT] boot_init start at cycle ");
	2105	_putd(_get_proctime());
	2106	_puts("\n");
	2107
	2108	// Loading the map.bin file into memory and checking it
	2109	boot_mapping_init();
	2110
	2111	_puts("\n[BOOT] Mapping ");
	2112	_puts( header->name );
	2113	_puts(" loaded at cycle ");
	2114	_putd(_get_proctime());
	2115	_puts("\n");
	2116
	2117	// Building all page tables
	2118	boot_pt_init();
	2119
	2120	_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
	2121	_putd(_get_proctime());
	2122	_puts("\n");
	2123
	2124	// Activating proc 0 MMU
	2125	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
	2126	_set_mmu_mode( 0xF );
	2127
[263]	2128	_puts("\n[BOOT] Processor[0,0,0] : MMU activation at cycle ");
[258]	2129	_putd(_get_proctime());
	2130	_puts("\n");
	2131
	2132	// Initialising private vobjs in vspaces
	2133	boot_vobjs_init();
	2134
	2135	_puts("\n[BOOT] Private vobjs initialised at cycle ");
	2136	_putd(_get_proctime());
	2137	_puts("\n");
	2138
	2139	// Initializing schedulers
	2140	boot_schedulers_init();
	2141
	2142	_puts("\n[BOOT] All schedulers initialised at cycle ");
	2143	_putd(_get_proctime());
	2144	_puts("\n");
	2145
	2146	// Setting CP0_SCHED register for proc 0
	2147	_set_sched( (unsigned int)_schedulers[0] );
	2148
[263]	2149	// Initializing peripherals
[258]	2150	boot_peripherals_init();
	2151
[263]	2152	_puts("\n[BOOT] All peripherals initialised at cycle ");
[258]	2153	_putd(_get_proctime());
	2154	_puts("\n");
	2155
	2156	// Loading all .elf files
	2157	boot_elf_load();
	2158
	2159	_puts("\n[BOOT] All ELF files loaded at cycle ");
	2160	_putd(_get_proctime());
	2161	_puts("\n");
	2162
	2163	// P0 starts all other processors
[263]	2164	unsigned int x,y,p;
	2165	for (x = 0 ; x < X_SIZE ; x++)
[258]	2166	{
[263]	2167	for (y = 0 ; y < Y_SIZE ; y++)
[258]	2168	{
[263]	2169	for(p = 0; p < NB_PROCS_MAX; p++)
[258]	2170	{
[263]	2171	if ( (x != 0) \|\| (y != 0) \|\| (p != 0) )
	2172	{
	2173	_xcu_send_ipi( (x<<Y_WIDTH) + y,
	2174	p,
	2175	(unsigned int)boot_init );
	2176	}
[258]	2177	}
	2178	}
	2179	}
	2180	} // end monoprocessor boot
	2181
[262]	2182	// reset BEV bit in the status register to use GIET exception
	2183	// handler instead of the PRELOADER exception handler
	2184	_set_sr( 0 );
	2185
[258]	2186	// all processor initialise SCHED register
[263]	2187	_set_sched( (unsigned int)_schedulers[gpid] );
[258]	2188
	2189	// all processors (but Proc 0) activate MMU
[263]	2190	if ( gpid != 0 )
[258]	2191	{
	2192	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
	2193	_set_mmu_mode( 0xF );
	2194
	2195	_tty_get_lock( 0 );
[263]	2196	_puts("\n[BOOT] Processor[");
	2197	_putd( cluster_xy >> Y_WIDTH );
	2198	_puts(",");
	2199	_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
	2200	_puts(",");
	2201	_putd( lpid );
	2202	_puts("] : MMU activation at cycle ");
[258]	2203	_putd(_get_proctime());
	2204	_puts("\n");
	2205	_tty_release_lock( 0 );
	2206	}
	2207
	2208	// all processors jump to kernel_init
	2209	unsigned int kernel_entry = (unsigned int)&seg_kernel_init_base;
	2210
	2211	_tty_get_lock( 0 );
[263]	2212	_puts("\n[BOOT] Processor[");
	2213	_putd( cluster_xy >> Y_WIDTH );
	2214	_puts(",");
	2215	_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
	2216	_puts(",");
	2217	_putd( lpid );
	2218	_puts("] enters kernel at cycle ");
[258]	2219	_putd( _get_proctime() );
	2220	_puts(" / kernel entry = ");
	2221	_putx( kernel_entry );
	2222	_puts("\n");
	2223	_tty_release_lock( 0 );
	2224
	2225	asm volatile( "jr %0" ::"r"(kernel_entry) );
	2226
	2227	} // end boot_init()
	2228
	2229
	2230	// Local Variables:
	2231	// tab-width: 4
	2232	// c-basic-offset: 4
	2233	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	2234	// indent-tabs-mode: nil
	2235	// End:
	2236	// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	2237

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

Download in other formats: