Context Navigation

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

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

Adding new task context information: THREAD INDEX.

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

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

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

Supporting mono TTY platforms

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

File size: 76.8 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
[267]	1159	unsigned int alloc_tty_channel = 0; // TTY channel allocator
[258]	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
[267]	1165	if (!GIET_MONO_TTY) alloc_tty_channel++;
	1166
[258]	1167	/////////////////////////////////////////////////////////////////////////
	1168	// Step 1 : loop on the clusters and on the processors
	1169	// to initialize the schedulers[] array of pointers,
	1170	// and the interrupt vectors.
	1171	// Implementation note:
	1172	// We need to use both proc_id to scan the mapping info structure,
	1173	// and lpid to access the schedulers array.
	1174	// - the _schedulers[] array of pointers can contain "holes", because
[263]	1175	// it is indexed by the global pid = cluster_xy*NB_PROCS_MAX + lpid
[258]	1176	// - the mapping info array of processors is contiguous, it is indexed
	1177	// by proc_id, and use an offset specific in each cluster.
	1178
[263]	1179	for (cluster_id = 0 ; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
[258]	1180	{
[263]	1181	unsigned int x = cluster[cluster_id].x;
	1182	unsigned int y = cluster[cluster_id].y;
	1183	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
[258]	1184
	1185	#if BOOT_DEBUG_SCHED
[263]	1186	_puts("\n[BOOT DEBUG] Initialise schedulers in cluster[");
	1187	_putd( x );
	1188	_puts(",");
	1189	_putd( y );
	1190	_puts("]\n");
[258]	1191	#endif
	1192	alloc_tim_channel[cluster_id] = NB_PROCS_MAX;
	1193
	1194	unsigned int lpid; // processor local index in cluster
	1195	unsigned int sched_vbase; // schedulers segment virtual base address
	1196	unsigned int sched_length; // schedulers segment length
	1197	unsigned int nprocs; // number of processors in cluster
	1198
	1199	nprocs = cluster[cluster_id].procs;
	1200
	1201	// checking processors number
	1202	if ( nprocs > NB_PROCS_MAX )
	1203	{
[263]	1204	_puts("\n[BOOT ERROR] Too much processors in cluster[");
	1205	_putd( x );
	1206	_puts(",");
	1207	_putd( y );
	1208	_puts("]\n");
[258]	1209	_exit();
	1210	}
	1211
	1212	// get scheduler array virtual base address and length
	1213	boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length );
	1214
	1215	// each processor scheduler requires 4 Kbytes
	1216	if ( sched_length < (nprocs<<12) )
	1217	{
[263]	1218	_puts("\n[BOOT ERROR] Schedulers segment too small in cluster[");
	1219	_putd( x );
	1220	_puts(",");
	1221	_putd( y );
	1222	_puts("]\n");
[258]	1223	_exit();
	1224	}
	1225
	1226	// loop on processors
	1227	for ( proc_id = cluster[cluster_id].proc_offset, lpid = 0 ;
	1228	proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs;
	1229	proc_id++, lpid++ )
	1230	{
[263]	1231	// current processor scheduler pointer : psched
	1232	static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12));
	1233
[258]	1234	// set the schedulers pointers array
[263]	1235	_schedulers[cluster_xy * NB_PROCS_MAX + lpid] = psched;
[258]	1236
	1237	#if BOOT_DEBUG_SCHED
	1238	_puts("\nProc_");
[263]	1239	_putd( x );
[258]	1240	_puts("_");
[263]	1241	_putd( y );
	1242	_puts("_");
	1243	_putd( lpid );
[258]	1244	_puts(" : scheduler virtual base address = ");
	1245	_putx( sched_vbase + (lpid<<12) );
	1246	_puts("\n");
	1247	#endif
	1248
	1249	// initialise the "tasks" variable : default value is 0
	1250	psched->tasks = 0;
	1251
	1252	// initialise the "current" variable : default value is idle_task
	1253	psched->current = IDLE_TASK_INDEX;
	1254
	1255	// initialise interrupt_vector with default value (valid bit = 0)
	1256	unsigned int slot;
	1257	for (slot = 0; slot < 32; slot++) psched->interrupt_vector[slot] = 0;
	1258
	1259	// initialise interrupt vector with the IRQs actually allocated
	1260	for (irq_id = proc[proc_id].irq_offset;
	1261	irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs;
	1262	irq_id++)
	1263	{
	1264	unsigned int type = irq[irq_id].type;
	1265	unsigned int icu_id = irq[irq_id].icuid;
	1266	unsigned int isr_id = irq[irq_id].isr;
	1267	unsigned int channel = irq[irq_id].channel;
	1268
	1269	unsigned int value = ((isr_id & 0xFF) ) \|
	1270	((type & 0xFF) << 8) \|
	1271	((channel & 0x7FFF) << 16) \|
	1272	0x80000000; // Valid entry
	1273
	1274	psched->interrupt_vector[icu_id] = value;
	1275
	1276	#if BOOT_DEBUG_SCHED
	1277	_puts("- IRQ : icu = ");
	1278	_putd(icu_id);
	1279	_puts(" / type = ");
	1280	_putd(type);
	1281	_puts(" / isr = ");
	1282	_putd(isr_id);
	1283	_puts(" / channel = ");
	1284	_putd(channel);
	1285	_puts(" => vector_entry = ");
	1286	_putx( value );
	1287	_puts("\n");
	1288	#endif
	1289	}
	1290
	1291	// initializes the idle_task context in scheduler:
	1292	// - the SR slot is 0xFF03 because this task run in kernel mode.
	1293	// - it uses the page table of vspace[0]
	1294	// - it uses the kernel TTY terminal
	1295	// - slots containing addresses (SP, RA, EPC, PTAB, PTPR)
	1296	// must be re-initialised by kernel_parallel_init()
	1297
	1298	psched->context[IDLE_TASK_INDEX][CTX_SR_ID] = 0xFF03;
	1299	psched->context[IDLE_TASK_INDEX][CTX_PTPR_ID] = _ptabs_paddr[0]>>13;
	1300	psched->context[IDLE_TASK_INDEX][CTX_PTAB_ID] = _ptabs_vaddr[0];
	1301	psched->context[IDLE_TASK_INDEX][CTX_TTY_ID] = 0;
	1302	psched->context[IDLE_TASK_INDEX][CTX_LTID_ID] = IDLE_TASK_INDEX;
	1303	psched->context[IDLE_TASK_INDEX][CTX_VSID_ID] = 0;
	1304	psched->context[IDLE_TASK_INDEX][CTX_RUN_ID] = 1;
	1305
	1306	} // end for procs
	1307	} // end for clusters
	1308
	1309	///////////////////////////////////////////////////////////////////
	1310	// Step 2 : loop on the vspaces and the tasks
	1311	// to initialise the schedulers and the task contexts.
	1312
	1313	for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++)
	1314	{
	1315	// We must set the PTPR depending on the vspace, because the start_vector
	1316	// and the stack address are defined in virtual space.
	1317	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id] >> 13) );
	1318
	1319	// loop on the tasks in vspace (task_id is the global index)
	1320	for (task_id = vspace[vspace_id].task_offset;
	1321	task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks);
	1322	task_id++)
	1323	{
	1324
[263]	1325	// compute the cluster coordinates
	1326	unsigned int x = cluster[task[task_id].clusterid].x;
	1327	unsigned int y = cluster[task[task_id].clusterid].y;
	1328	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
	1329
[258]	1330	#if BOOT_DEBUG_SCHED
	1331	_puts("\n[BOOT DEBUG] Initialise context for task ");
	1332	_puts( task[task_id].name );
	1333	_puts(" in vspace ");
	1334	_puts( vspace[vspace_id].name );
[263]	1335	_puts(" running on cluster[");
	1336	_putd( x );
	1337	_puts(",");
	1338	_putd( y );
	1339	_puts("]\n");
[258]	1340	#endif
	1341	// compute gpid (global processor index) and scheduler base address
[263]	1342	unsigned int gpid = cluster_xy * NB_PROCS_MAX + task[task_id].proclocid;
[258]	1343	static_scheduler_t* psched = _schedulers[gpid];
	1344
	1345	// ctx_sr : value required before an eret instruction
	1346	unsigned int ctx_sr = 0x0000FF13;
	1347
	1348	// ctx_ptpr : page table physical base address (shifted by 13 bit)
	1349	unsigned int ctx_ptpr = (unsigned int)(_ptabs_paddr[vspace_id] >> 13);
	1350
	1351	// ctx_ptab : page_table virtual base address
	1352	unsigned int ctx_ptab = _ptabs_vaddr[vspace_id];
	1353
	1354	// ctx_tty : TTY terminal global index provided by the global allocator
	1355	unsigned int ctx_tty = 0xFFFFFFFF;
	1356	if (task[task_id].use_tty)
	1357	{
	1358	if (alloc_tty_channel >= NB_TTY_CHANNELS)
	1359	{
	1360	_puts("\n[BOOT ERROR] TTY index too large for task ");
	1361	_puts(task[task_id].name);
	1362	_puts(" in vspace ");
	1363	_puts(vspace[vspace_id].name);
	1364	_puts("\n");
	1365	_exit();
	1366	}
	1367	ctx_tty = alloc_tty_channel;
[267]	1368	if (!GIET_MONO_TTY) alloc_tty_channel++;
[258]	1369	}
	1370	// ctx_nic : NIC channel global index provided by the global allocator
	1371	unsigned int ctx_nic = 0xFFFFFFFF;
	1372	if (task[task_id].use_nic)
	1373	{
	1374	if (alloc_nic_channel >= NB_NIC_CHANNELS)
	1375	{
	1376	_puts("\n[BOOT ERROR] NIC channel index too large for task ");
	1377	_puts(task[task_id].name);
	1378	_puts(" in vspace ");
	1379	_puts(vspace[vspace_id].name);
	1380	_puts("\n");
	1381	_exit();
	1382	}
	1383	ctx_nic = alloc_nic_channel;
	1384	alloc_nic_channel++;
	1385	}
	1386	// ctx_cma : CMA channel global index provided by the global allocator
	1387	unsigned int ctx_cma = 0xFFFFFFFF;
	1388	if (task[task_id].use_cma)
	1389	{
	1390	if (alloc_cma_channel >= NB_CMA_CHANNELS)
	1391	{
	1392	_puts("\n[BOOT ERROR] CMA channel index too large for task ");
	1393	_puts(task[task_id].name);
	1394	_puts(" in vspace ");
	1395	_puts(vspace[vspace_id].name);
	1396	_puts("\n");
	1397	_exit();
	1398	}
	1399	ctx_cma = alloc_cma_channel;
	1400	alloc_cma_channel++;
	1401	}
	1402	// ctx_hba : HBA channel global index provided by the global allocator
	1403	unsigned int ctx_hba = 0xFFFFFFFF;
	1404	if (task[task_id].use_hba)
	1405	{
	1406	if (alloc_hba_channel >= NB_HBA_CHANNELS)
	1407	{
	1408	_puts("\n[BOOT ERROR] IOC channel index too large for task ");
	1409	_puts(task[task_id].name);
	1410	_puts(" in vspace ");
	1411	_puts(vspace[vspace_id].name);
	1412	_puts("\n");
	1413	_exit();
	1414	}
	1415	ctx_hba = alloc_hba_channel;
	1416	alloc_hba_channel++;
	1417	}
	1418	// ctx_tim : TIM local channel index provided by the cluster allocator
	1419	unsigned int ctx_tim = 0xFFFFFFFF;
	1420	if (task[task_id].use_tim)
	1421	{
	1422	unsigned int cluster_id = task[task_id].clusterid;
	1423
	1424	if ( alloc_tim_channel[cluster_id] >= NB_TIM_CHANNELS )
	1425	{
	1426	_puts("\n[BOOT ERROR] local TIMER index too large for task ");
	1427	_puts(task[task_id].name);
	1428	_puts(" in vspace ");
	1429	_puts(vspace[vspace_id].name);
	1430	_puts("\n");
	1431	_exit();
	1432	}
	1433
	1434	// checking that there is an ISR_TIMER installed
	1435	unsigned int found = 0;
	1436	for ( irq_id = 0 ; irq_id < 32 ; irq_id++ )
	1437	{
	1438	unsigned int entry = psched->interrupt_vector[irq_id];
	1439	unsigned int isr = entry & 0x000000FF;
	1440	unsigned int channel = entry>>16;
	1441	if ( (isr == ISR_TIMER) && (channel == alloc_tim_channel[cluster_id]) )
	1442	{
	1443	found = 1;
	1444	ctx_tim = alloc_tim_channel[cluster_id];
	1445	alloc_tim_channel[cluster_id]++;
	1446	break;
	1447	}
	1448	}
	1449	if (!found)
	1450	{
	1451	_puts("\n[BOOT ERROR] No ISR_TIMER installed for task ");
	1452	_puts(task[task_id].name);
	1453	_puts(" in vspace ");
	1454	_puts(vspace[vspace_id].name);
	1455	_puts("\n");
	1456	_exit();
	1457	}
	1458	}
	1459	// ctx_epc : Get the virtual address of the memory location containing
	1460	// the task entry point : the start_vector is stored by GCC in the seg_data
	1461	// segment and we must wait the .elf loading to get the entry point value...
	1462	mapping_vobj_t* pvobj = &vobj[vspace[vspace_id].vobj_offset +
	1463	vspace[vspace_id].start_offset];
	1464	unsigned int ctx_epc = pvobj->vaddr + (task[task_id].startid)*4;
	1465
	1466	// ctx_sp : Get the vobj containing the stack
	1467	unsigned int vobj_id = task[task_id].stack_vobjid + vspace[vspace_id].vobj_offset;
	1468	unsigned int ctx_sp = vobj[vobj_id].vaddr + vobj[vobj_id].length;
	1469
	1470	// get local task index in scheduler
	1471	unsigned int ltid = psched->tasks;
	1472
[267]	1473	// get vspace thread index
	1474	unsigned int thread_id = task[task_id].trdid;
	1475
[258]	1476	if (ltid >= IDLE_TASK_INDEX)
	1477	{
	1478	_puts("\n[BOOT ERROR] in boot_schedulers_init() : ");
	1479	_putd( ltid );
	1480	_puts(" tasks allocated to processor ");
	1481	_putd( gpid );
	1482	_puts(" / max is ");
	1483	_putd( IDLE_TASK_INDEX );
	1484	_puts("\n");
	1485	_exit();
	1486	}
	1487
	1488	// update the "tasks" and "current" fields in scheduler:
	1489	// the first task to execute is task 0 as soon as there is at least
	1490	// one task allocated to processor.
	1491	psched->tasks = ltid + 1;
	1492	psched->current = 0;
	1493
	1494	// initializes the task context in scheduler
	1495	psched->context[ltid][CTX_SR_ID] = ctx_sr;
	1496	psched->context[ltid][CTX_SP_ID] = ctx_sp;
	1497	psched->context[ltid][CTX_EPC_ID] = ctx_epc;
	1498	psched->context[ltid][CTX_PTPR_ID] = ctx_ptpr;
	1499	psched->context[ltid][CTX_TTY_ID] = ctx_tty;
	1500	psched->context[ltid][CTX_CMA_ID] = ctx_cma;
	1501	psched->context[ltid][CTX_HBA_ID] = ctx_hba;
	1502	psched->context[ltid][CTX_NIC_ID] = ctx_nic;
	1503	psched->context[ltid][CTX_TIM_ID] = ctx_tim;
	1504	psched->context[ltid][CTX_PTAB_ID] = ctx_ptab;
	1505	psched->context[ltid][CTX_LTID_ID] = ltid;
	1506	psched->context[ltid][CTX_GTID_ID] = task_id;
[267]	1507	psched->context[ltid][CTX_TRDID_ID] = thread_id;
[258]	1508	psched->context[ltid][CTX_VSID_ID] = vspace_id;
	1509	psched->context[ltid][CTX_RUN_ID] = 1;
	1510
	1511	#if BOOT_DEBUG_SCHED
	1512	_puts("\nTask ");
	1513	_putd( task_id );
[267]	1514	_puts(" allocated to processor ");
[258]	1515	_putd( gpid );
	1516	_puts("\n - ctx[LTID] = ");
	1517	_putd( psched->context[ltid][CTX_LTID_ID] );
	1518	_puts("\n - ctx[SR] = ");
	1519	_putx( psched->context[ltid][CTX_SR_ID] );
	1520	_puts("\n - ctx[SP] = ");
	1521	_putx( psched->context[ltid][CTX_SP_ID] );
	1522	_puts("\n - ctx[EPC] = ");
	1523	_putx( psched->context[ltid][CTX_EPC_ID] );
	1524	_puts("\n - ctx[PTPR] = ");
	1525	_putx( psched->context[ltid][CTX_PTPR_ID] );
	1526	_puts("\n - ctx[TTY] = ");
	1527	_putd( psched->context[ltid][CTX_TTY_ID] );
	1528	_puts("\n - ctx[NIC] = ");
	1529	_putd( psched->context[ltid][CTX_NIC_ID] );
	1530	_puts("\n - ctx[CMA] = ");
	1531	_putd( psched->context[ltid][CTX_CMA_ID] );
	1532	_puts("\n - ctx[IOC] = ");
	1533	_putd( psched->context[ltid][CTX_HBA_ID] );
	1534	_puts("\n - ctx[TIM] = ");
	1535	_putd( psched->context[ltid][CTX_TIM_ID] );
	1536	_puts("\n - ctx[PTAB] = ");
	1537	_putx( psched->context[ltid][CTX_PTAB_ID] );
	1538	_puts("\n - ctx[GTID] = ");
	1539	_putd( psched->context[ltid][CTX_GTID_ID] );
	1540	_puts("\n - ctx[VSID] = ");
	1541	_putd( psched->context[ltid][CTX_VSID_ID] );
[267]	1542	_puts("\n - ctx[TRDID] = ");
	1543	_putd( psched->context[ltid][CTX_TRDID_ID] );
[258]	1544	_puts("\n");
	1545	#endif
	1546
	1547	} // end loop on tasks
	1548	} // end loop on vspaces
	1549	} // end _schedulers_init()
	1550
	1551	//////////////////////////////////////////////////////////////////////////////////
	1552	// This function loads the map.bin file from block device.
	1553	// The fat global varible is defined in fat32.c file.
	1554	//////////////////////////////////////////////////////////////////////////////////
	1555	void boot_mapping_init()
	1556	{
	1557	// Initializing the FAT descriptor and files descriptor array
	1558	if ( _fat_init( IOC_BOOT_PA_MODE ) )
	1559	{
	1560	_puts("[BOOT ERROR] Cannot initialize FAT descriptor fom Boot Sector\n");
	1561	_exit();
	1562	}
	1563
	1564	#if BOOT_DEBUG_MAPPING
	1565	_puts("\n[BOOT] FAT initialisation completed at cycle ");
	1566	_putd(_get_proctime());
	1567	_puts("\n");
	1568	_fat_print();
	1569	#endif
	1570
	1571	int fd_id = _fat_open( IOC_BOOT_PA_MODE,
	1572	"map.bin",
	1573	0 ); // no creation
	1574
	1575	if ( fd_id == -1 )
	1576	{
	1577	_puts("\n[BOOT ERROR] : map.bin file not found \n");
	1578	_exit();
	1579	}
	1580
	1581	#if BOOT_DEBUG_MAPPING
	1582	_puts("\n[BOOT] map.bin file successfully open at cycle ");
	1583	_putd(_get_proctime());
	1584	_puts("\n");
	1585	#endif
	1586
	1587	unsigned int size = fat.fd[fd_id].file_size;
	1588	unsigned int nblocks = size >> 9;
	1589	unsigned int offset = size & 0x1FF;
	1590	if ( offset ) nblocks++;
	1591
	1592	unsigned int ok = _fat_read( IOC_BOOT_PA_MODE,
	1593	fd_id,
	1594	(unsigned int*)( &seg_boot_mapping_base),
	1595	nblocks,
	1596	0 ); // offset
	1597	if ( ok == -1 )
	1598	{
	1599	_puts("\n[BOOT ERROR] : unable to load map.bin file \n");
	1600	_exit();
	1601	}
	1602	_fat_close( fd_id );
	1603
	1604	boot_mapping_check();
	1605	} // end boot_mapping_init()
	1606
	1607
	1608	//////////////////////////////////////////////////////////////////////////////////
	1609	// This function open the .elf file identified by the "pathname" argument.
	1610	// It loads the complete file in a dedicated buffer, it copies all loadable
	1611	// segments at the memory virtual address defined in the .elf file,
	1612	// and close the file.
	1613	// Notes:
	1614	// - The processor PTPR should contain the value corresponding to the
	1615	// vspace containing the .elf file.
	1616	// - As this function requires a temporary memory buffer
	1617	// to load the complete .elf file before to copy the various segments
	1618	// to te proper location, it uses the seg_boot_buffer defined in map.xml.
	1619	//////////////////////////////////////////////////////////////////////////////////
	1620	void load_one_elf_file( unsigned int mode,
	1621	char* pathname,
	1622	unsigned int vspace_id ) // to use the proper page_table
	1623	{
	1624	unsigned int seg_id;
	1625
	1626	// get boot buffer address and size
	1627	char* boot_buffer = (char*)(&seg_boot_buffer_base);
	1628	unsigned int boot_buffer_size = (unsigned int)(&seg_boot_buffer_size);
	1629
	1630	#if BOOT_DEBUG_ELF
	1631	_puts("\n[BOOT DEBUG] Start searching file ");
	1632	_puts( pathname );
	1633	_puts(" at cycle ");
	1634	_putd( _get_proctime() );
	1635	_puts("\n");
	1636	#endif
	1637
	1638	// open .elf file
	1639	int fd_id = _fat_open( mode,
	1640	pathname,
	1641	0 ); // no creation
	1642	if ( fd_id < 0 )
	1643	{
	1644	_puts("\n[BOOT ERROR] load_one_elf_file() : ");
	1645	_puts( pathname );
	1646	_puts(" not found\n");
	1647	_exit();
	1648	}
	1649
	1650	// check boot_buffer size versus file size
	1651	if ( fat.fd[fd_id].file_size > boot_buffer_size )
	1652	{
	1653	_puts("\n[BOOT ERROR] load_one_elf_file() : ");
	1654	_puts( pathname );
	1655	_puts(" exceeds the seg_boot_buffer size\n");
	1656	_exit();
	1657	}
	1658
	1659	// compute number of sectors
	1660	unsigned int nbytes = fat.fd[fd_id].file_size;
	1661	unsigned int nsectors = nbytes>>9;
	1662	if( nbytes & 0x1FF) nsectors++;
	1663
	1664	// load file in boot_buffer
	1665	if( _fat_read( mode,
	1666	fd_id,
	1667	boot_buffer,
	1668	nsectors,
	1669	0 ) != nsectors )
	1670	{
	1671	_puts("\n[BOOT ERROR] load_one_elf_file() : unexpected EOF for file ");
	1672	_puts( pathname );
	1673	_puts("\n");
	1674	_exit();
	1675	}
	1676
	1677	// Check ELF Magic Number in ELF header
	1678	Elf32_Ehdr* elf_header_ptr = (Elf32_Ehdr*)boot_buffer;
	1679
	1680	if ( (elf_header_ptr->e_ident[EI_MAG0] != ELFMAG0) \|\|
	1681	(elf_header_ptr->e_ident[EI_MAG1] != ELFMAG1) \|\|
	1682	(elf_header_ptr->e_ident[EI_MAG2] != ELFMAG2) \|\|
	1683	(elf_header_ptr->e_ident[EI_MAG3] != ELFMAG3) )
	1684	{
	1685	_puts("\n[BOOT ERROR] load_elf() : file ");
	1686	_puts( pathname );
	1687	_puts(" does not use ELF format\n");
	1688	_exit();
	1689	}
	1690
	1691	// get program header table pointer
	1692	unsigned int pht_index = elf_header_ptr->e_phoff;
	1693	if( pht_index == 0 )
	1694	{
	1695	_puts("\n[BOOT ERROR] load_one_elf_file() : file ");
	1696	_puts( pathname );
	1697	_puts(" does not contain loadable segment\n");
	1698	_exit();
	1699	}
	1700	Elf32_Phdr* elf_pht_ptr = (Elf32_Phdr*)(boot_buffer + pht_index);
	1701
	1702	// get number of segments
	1703	unsigned int nsegments = elf_header_ptr->e_phnum;
	1704
	1705	#if BOOT_DEBUG_ELF
	1706	_puts("\n[BOOT DEBUG] File ");
	1707	_puts( pathname );
	1708	_puts(" loaded at cycle ");
	1709	_putd( _get_proctime() );
	1710	_puts(" / bytes = ");
	1711	_putd( nbytes );
	1712	_puts(" / sectors = ");
	1713	_putd( nsectors );
	1714	_puts("\n");
	1715	#endif
	1716
	1717	// Loop on loadable segments in the ELF file
	1718	for (seg_id = 0 ; seg_id < nsegments ; seg_id++)
	1719	{
	1720	if(elf_pht_ptr[seg_id].p_type == PT_LOAD)
	1721	{
	1722	// Get segment attributes
	1723	unsigned int seg_vaddr = elf_pht_ptr[seg_id].p_vaddr;
	1724	unsigned int seg_offset = elf_pht_ptr[seg_id].p_offset;
	1725	unsigned int seg_filesz = elf_pht_ptr[seg_id].p_filesz;
	1726	unsigned int seg_memsz = elf_pht_ptr[seg_id].p_memsz;
	1727
	1728	if( seg_memsz < seg_filesz )
	1729	{
	1730	_puts("\n[BOOT ERROR] load_one_elf_file() : segment at vaddr = ");
	1731	_putx( seg_vaddr );
	1732	_puts(" in file ");
	1733	_puts( pathname );
	1734	_puts(" has a wrong size \n");
	1735	_exit();
	1736	}
	1737
	1738	// fill empty space with 0 as required
	1739	if( seg_memsz > seg_filesz )
	1740	{
	1741	unsigned int i;
	1742	for( i = seg_filesz ; i < seg_memsz; i++ ) boot_buffer[i] = 0;
	1743	}
	1744
	1745	unsigned int src_vaddr = (unsigned int)boot_buffer + seg_offset;
	1746
	1747	#if BOOT_DEBUG_ELF
	1748	_puts(" - segment ");
	1749	_putd( seg_id );
	1750	_puts(" / dst_vaddr = ");
	1751	_putx( seg_vaddr );
	1752	_puts(" / src_vaddr = ");
	1753	_putx( src_vaddr );
	1754	_puts(" / size = ");
	1755	_putx( seg_filesz );
	1756	_puts("\n");
	1757	#endif
	1758
	1759	// copy the segment from boot buffer to destination buffer
	1760	if( NB_DMA_CHANNELS > 0 )
	1761	{
	1762	_dma_copy( vspace_id, // required for V2P translation
	1763	(char*)seg_vaddr,
	1764	(char*)src_vaddr,
	1765	seg_filesz );
	1766	}
	1767	else
	1768	{
	1769	_memcpy( (char*)seg_vaddr,
	1770	(char*)src_vaddr,
	1771	seg_filesz );
	1772	}
	1773	}
	1774	} // end for segments
	1775
	1776	// close .elf file
	1777	_fat_close( fd_id );
	1778
	1779	} // end load_one_elf_file()
	1780
	1781
	1782	//////////////////////////////////////////////////////////////////////////////////
	1783	// This function uses the map.bin data structure to load the "kernel.elf" file
	1784	// as well as the various "application.elf" files.
	1785	// The "preloader.elf" file is not loaded, because it has been burned in the ROM.
	1786	// The "boot.elf" file is not loaded, because it has been loaded by the preloader.
	1787	// It scans all vobjs defined in the map.bin data structure to collect
	1788	// all .elf files pathnames, and calls the load_one_elf_file() function to
	1789	// load all loadable segments at the virtual address found in the .elf file.
	1790	//////////////////////////////////////////////////////////////////////////////////
	1791	void boot_elf_load()
	1792	{
	1793	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	1794	mapping_vspace_t* vspace = _get_vspace_base( header );
	1795	mapping_vobj_t* vobj = _get_vobj_base( header );
	1796	unsigned int vspace_id;
	1797	unsigned int vobj_id;
	1798	unsigned int found;
	1799
	1800	// Scan all vobjs corresponding to global vsegs,
	1801	// to find the pathname to the kernel.elf file
	1802	found = 0;
	1803	for( vobj_id = 0 ; vobj_id < header->globals ; vobj_id++ )
	1804	{
	1805	if(vobj[vobj_id].type == VOBJ_TYPE_ELF)
	1806	{
	1807	found = 1;
	1808	break;
	1809	}
	1810	}
	1811
	1812	// We need one kernel.elf file
	1813	if (found == 0)
	1814	{
	1815	_puts("[BOOT ERROR] boot_elf_load() : kernel.elf file not found\n");
	1816	_exit();
	1817	}
	1818
	1819	load_one_elf_file( IOC_BOOT_VA_MODE,
	1820	vobj[vobj_id].binpath,
	1821	0 ); // vspace 0
	1822
	1823	_puts("\n[BOOT] File ");
	1824	_puts( vobj[vobj_id].binpath );
	1825	_puts(" loaded at cycle ");
	1826	_putd( _get_proctime() );
	1827	_puts("\n");
	1828
	1829	// loop on the vspaces, scanning all vobjs in a vspace,
	1830	// to find the pathname of the .elf file associated to the vspace.
	1831	for( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
	1832	{
	1833	// Set PTPR depending on the vspace, as seg_data is defined in virtual space.
	1834	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id] >> 13) );
	1835
	1836	// loop on the vobjs in vspace (vobj_id is the global index)
	1837	unsigned int found = 0;
	1838	for (vobj_id = vspace[vspace_id].vobj_offset;
	1839	vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs);
	1840	vobj_id++)
	1841	{
	1842	if(vobj[vobj_id].type == VOBJ_TYPE_ELF)
	1843	{
	1844	found = 1;
	1845	break;
	1846	}
	1847	}
	1848
	1849	// We want one .elf file per vspace
	1850	if (found == 0)
	1851	{
	1852	_puts("[BOOT ERROR] boot_elf_load() : .elf file not found for vspace ");
	1853	_puts( vspace[vspace_id].name );
	1854	_puts("\n");
	1855	_exit();
	1856	}
	1857
	1858	load_one_elf_file( IOC_BOOT_VA_MODE,
	1859	vobj[vobj_id].binpath,
	1860	vspace_id );
	1861
	1862	_puts("\n[BOOT] File ");
	1863	_puts( vobj[vobj_id].binpath );
	1864	_puts(" loaded at cycle ");
	1865	_putd( _get_proctime() );
	1866	_puts("\n");
	1867
	1868	} // end for vspaces
	1869
	1870	// restaure vspace 0 PTPR
	1871	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0] >> 13) );
	1872
	1873	} // end boot_elf_load()
	1874
	1875	////////////////////////////////////////////////////////////////////////////////
	1876	// This function intializes the periherals and coprocessors, as specified
	1877	// in the mapping_info file.
	1878	////////////////////////////////////////////////////////////////////////////////
	1879	void boot_peripherals_init()
	1880	{
	1881	mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
	1882	mapping_cluster_t * cluster = _get_cluster_base(header);
	1883	mapping_periph_t * periph = _get_periph_base(header);
	1884	mapping_vobj_t * vobj = _get_vobj_base(header);
	1885	mapping_vspace_t * vspace = _get_vspace_base(header);
	1886	mapping_coproc_t * coproc = _get_coproc_base(header);
	1887	mapping_cp_port_t * cp_port = _get_cp_port_base(header);
	1888
	1889	unsigned int cluster_id;
	1890	unsigned int periph_id;
	1891	unsigned int coproc_id;
	1892	unsigned int cp_port_id;
	1893	unsigned int channel_id;
	1894
[263]	1895	// loop on all physical clusters
	1896	for (cluster_id = 0; cluster_id < X_SIZE*Y_SIZE; cluster_id++)
[258]	1897	{
[263]	1898	// computes cluster coordinates
	1899	unsigned int x = cluster[cluster_id].x;
	1900	unsigned int y = cluster[cluster_id].y;
	1901	unsigned int cluster_xy = (x<<Y_WIDTH) + y;
[258]	1902
	1903	#if BOOT_DEBUG_PERI
[263]	1904	_puts("\n[BOOT DEBUG] ****** peripherals initialisation in cluster[");
	1905	_putd( x );
	1906	_puts(",");
	1907	_putd( y );
	1908	_puts("] ******\n");
[258]	1909	#endif
	1910
[263]	1911	// loop on peripherals
[258]	1912	for (periph_id = cluster[cluster_id].periph_offset;
	1913	periph_id < cluster[cluster_id].periph_offset +
	1914	cluster[cluster_id].periphs; periph_id++)
	1915	{
	1916	unsigned int type = periph[periph_id].type;
	1917	unsigned int channels = periph[periph_id].channels;
	1918
	1919	switch (type)
	1920	{
	1921	case PERIPH_TYPE_IOC: // vci_block_device component
	1922	{
	1923	_ioc_init();
	1924	#if BOOT_DEBUG_PERI
[263]	1925	_puts("- IOC / channels = ");
	1926	_putd(channels);
	1927	_puts("\n");
[258]	1928	#endif
	1929	break;
	1930	}
	1931	case PERIPH_TYPE_DMA: // vci_multi_dma component
	1932	{
	1933	for (channel_id = 0; channel_id < channels; channel_id++)
	1934	{
[263]	1935	_dma_init( cluster_xy, channel_id );
[258]	1936	}
	1937	#if BOOT_DEBUG_PERI
[263]	1938	_puts("- DMA / channels = ");
	1939	_putd(channels);
	1940	_puts("\n");
[258]	1941	#endif
	1942	break;
	1943	}
[263]	1944	case PERIPH_TYPE_FBF: // vci_block_device component
	1945	{
	1946	// nothing to do
	1947	#if BOOT_DEBUG_PERI
	1948	_puts("- FBF / channels = ");
	1949	_putd(channels);
	1950	_puts("\n");
	1951	#endif
	1952	break;
	1953	}
	1954	case PERIPH_TYPE_HBA: // vci_multi_ahci component
	1955	{
	1956	for (channel_id = 0; channel_id < channels; channel_id++)
	1957	{
	1958	// TODO
	1959	}
	1960	#if BOOT_DEBUG_PERI
	1961	_puts("- HBA / channels = ");
	1962	_putd(channels);
	1963	_puts("\n");
	1964	#endif
	1965	break;
	1966	}
	1967	case PERIPH_TYPE_CMA: // vci_chbuf_dma component
	1968	{
	1969	for (channel_id = 0; channel_id < channels; channel_id++)
	1970	{
	1971	// TODO
	1972	}
	1973	#if BOOT_DEBUG_PERI
	1974	_puts("- CMA / channels = ");
	1975	_putd(channels);
	1976	_puts("\n");
	1977	#endif
	1978	break;
	1979	}
[258]	1980	case PERIPH_TYPE_NIC: // vci_multi_nic component
	1981	{
	1982	for (channel_id = 0; channel_id < channels; channel_id++)
	1983	{
	1984	// TODO
	1985	}
	1986	#if BOOT_DEBUG_PERI
[263]	1987	_puts("- NIC / channels = ");
	1988	_putd(channels);
	1989	_puts("\n");
[258]	1990	#endif
	1991	break;
	1992	}
[263]	1993	case PERIPH_TYPE_XCU: // vci_xicu component
	1994	{
	1995	// nothing to do
	1996	#if BOOT_DEBUG_PERI
	1997	_puts("- XCU / channels = ");
	1998	_putd(channels);
	1999	_puts("\n");
	2000	#endif
	2001	break;
	2002	}
	2003	case PERIPH_TYPE_MMC: // vci_memcache config
	2004	{
	2005	// nothing to do
	2006	#if BOOT_DEBUG_PERI
	2007	_puts("- MMC / channels = ");
	2008	_putd(channels);
	2009	_puts("\n");
	2010	#endif
	2011	break;
	2012	}
[258]	2013	case PERIPH_TYPE_TTY: // vci_multi_tty component
	2014	{
	2015	#if BOOT_DEBUG_PERI
[263]	2016	_puts("- TTY / channels = ");
	2017	_putd(channels);
	2018	_puts("\n");
[258]	2019	#endif
	2020	break;
	2021	}
	2022	case PERIPH_TYPE_IOB: // vci_io_bridge component
	2023	{
	2024	if (USE_IOB)
	2025	{
	2026	// TODO
	2027	// get the iommu page table physical address
	2028	// define IPI address mapping the IOC interrupt
	2029	// set IOMMU page table address
	2030	// pseg_base[IOB_IOMMU_PTPR] = ptab_pbase;
	2031	// activate IOMMU
	2032	// pseg_base[IOB_IOMMU_ACTIVE] = 1;
	2033	}
	2034	#if BOOT_DEBUG_PERI
[263]	2035	_puts("- IOB / channels = ");
	2036	_putd(channels);
	2037	_puts("\n");
[258]	2038	#endif
	2039	break;
	2040	}
	2041	} // end switch periph type
	2042	} // end for periphs
	2043
	2044	#if BOOT_DEBUG_PERI
[263]	2045	_puts("\n[BOOT DEBUG] ****** coprocessors initialisation in cluster[");
	2046	_putd( x );
	2047	_puts(",");
	2048	_putd( y );
	2049	_puts("] ******\n");
[258]	2050	#endif
	2051
[263]	2052	// loop on coprocessors
[258]	2053	for ( coproc_id = cluster[cluster_id].coproc_offset;
	2054	coproc_id < cluster[cluster_id].coproc_offset +
	2055	cluster[cluster_id].coprocs; coproc_id++ )
	2056	{
	2057
	2058	#if BOOT_DEBUG_PERI
	2059	_puts("- coprocessor name : ");
	2060	_puts(coproc[coproc_id].name);
	2061	_puts(" / nb ports = ");
	2062	_putd((unsigned int) coproc[coproc_id].ports);
	2063	_puts("\n");
	2064	#endif
	2065	// loop on the coprocessor ports
	2066	for ( cp_port_id = coproc[coproc_id].port_offset;
	2067	cp_port_id < coproc[coproc_id].port_offset + coproc[coproc_id].ports;
	2068	cp_port_id++ )
	2069	{
	2070	unsigned int vspace_id = cp_port[cp_port_id].vspaceid;
	2071	unsigned int vobj_id = cp_port[cp_port_id].mwmr_vobjid +
	2072	vspace[vspace_id].vobj_offset;
	2073
	2074	// Get MWMR channel base address
	2075	paddr_t mwmr_channel_pbase = vobj[vobj_id].paddr;
	2076
[263]	2077	_mwr_hw_init( cluster_xy,
	2078	cp_port_id,
	2079	cp_port[cp_port_id].direction,
	2080	mwmr_channel_pbase );
[258]	2081	#if BOOT_DEBUG_PERI
	2082	_puts(" port direction: ");
	2083	_putd( (unsigned int)cp_port[cp_port_id].direction );
	2084	_puts(" / mwmr_channel_pbase = ");
	2085	_putl( mwmr_channel_pbase );
	2086	_puts(" / name = ");
	2087	_puts(vobj[vobj_id].name);
	2088	_puts(" / in vspace ");
	2089	_puts(vspace[vspace_id].name);
	2090	_puts("\n");
	2091	#endif
	2092	} // end for cp_ports
	2093	} // end for coprocs
	2094	} // end for clusters
	2095	} // end boot_peripherals_init()
	2096
	2097	/////////////////////////////////////////////////////////////////////////
	2098	// This function is the entry point of the boot code for all processors.
	2099	// Most of this code is executed by Processor 0 only.
	2100	/////////////////////////////////////////////////////////////////////////
	2101	void boot_init()
	2102	{
[263]	2103	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
	2104	unsigned int gpid = _get_procid();
	2105	unsigned int cluster_xy = gpid / NB_PROCS_MAX;
	2106	unsigned int lpid = gpid % NB_PROCS_MAX;
[258]	2107
[263]	2108	if ( gpid == 0 ) // only Processor 0 does it
[258]	2109	{
	2110	_puts("\n[BOOT] boot_init start at cycle ");
	2111	_putd(_get_proctime());
	2112	_puts("\n");
	2113
	2114	// Loading the map.bin file into memory and checking it
	2115	boot_mapping_init();
	2116
	2117	_puts("\n[BOOT] Mapping ");
	2118	_puts( header->name );
	2119	_puts(" loaded at cycle ");
	2120	_putd(_get_proctime());
	2121	_puts("\n");
	2122
	2123	// Building all page tables
	2124	boot_pt_init();
	2125
	2126	_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
	2127	_putd(_get_proctime());
	2128	_puts("\n");
	2129
	2130	// Activating proc 0 MMU
	2131	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
	2132	_set_mmu_mode( 0xF );
	2133
[263]	2134	_puts("\n[BOOT] Processor[0,0,0] : MMU activation at cycle ");
[258]	2135	_putd(_get_proctime());
	2136	_puts("\n");
	2137
	2138	// Initialising private vobjs in vspaces
	2139	boot_vobjs_init();
	2140
	2141	_puts("\n[BOOT] Private vobjs initialised at cycle ");
	2142	_putd(_get_proctime());
	2143	_puts("\n");
	2144
	2145	// Initializing schedulers
	2146	boot_schedulers_init();
	2147
	2148	_puts("\n[BOOT] All schedulers initialised at cycle ");
	2149	_putd(_get_proctime());
	2150	_puts("\n");
	2151
	2152	// Setting CP0_SCHED register for proc 0
	2153	_set_sched( (unsigned int)_schedulers[0] );
	2154
[263]	2155	// Initializing peripherals
[258]	2156	boot_peripherals_init();
	2157
[263]	2158	_puts("\n[BOOT] All peripherals initialised at cycle ");
[258]	2159	_putd(_get_proctime());
	2160	_puts("\n");
	2161
	2162	// Loading all .elf files
	2163	boot_elf_load();
	2164
	2165	_puts("\n[BOOT] All ELF files loaded at cycle ");
	2166	_putd(_get_proctime());
	2167	_puts("\n");
	2168
	2169	// P0 starts all other processors
[263]	2170	unsigned int x,y,p;
	2171	for (x = 0 ; x < X_SIZE ; x++)
[258]	2172	{
[263]	2173	for (y = 0 ; y < Y_SIZE ; y++)
[258]	2174	{
[263]	2175	for(p = 0; p < NB_PROCS_MAX; p++)
[258]	2176	{
[263]	2177	if ( (x != 0) \|\| (y != 0) \|\| (p != 0) )
	2178	{
	2179	_xcu_send_ipi( (x<<Y_WIDTH) + y,
	2180	p,
	2181	(unsigned int)boot_init );
	2182	}
[258]	2183	}
	2184	}
	2185	}
	2186	} // end monoprocessor boot
	2187
[262]	2188	// reset BEV bit in the status register to use GIET exception
	2189	// handler instead of the PRELOADER exception handler
	2190	_set_sr( 0 );
	2191
[258]	2192	// all processor initialise SCHED register
[263]	2193	_set_sched( (unsigned int)_schedulers[gpid] );
[258]	2194
	2195	// all processors (but Proc 0) activate MMU
[263]	2196	if ( gpid != 0 )
[258]	2197	{
	2198	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
	2199	_set_mmu_mode( 0xF );
	2200
	2201	_tty_get_lock( 0 );
[263]	2202	_puts("\n[BOOT] Processor[");
	2203	_putd( cluster_xy >> Y_WIDTH );
	2204	_puts(",");
	2205	_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
	2206	_puts(",");
	2207	_putd( lpid );
	2208	_puts("] : MMU activation at cycle ");
[258]	2209	_putd(_get_proctime());
	2210	_puts("\n");
	2211	_tty_release_lock( 0 );
	2212	}
	2213
	2214	// all processors jump to kernel_init
	2215	unsigned int kernel_entry = (unsigned int)&seg_kernel_init_base;
	2216
	2217	_tty_get_lock( 0 );
[263]	2218	_puts("\n[BOOT] Processor[");
	2219	_putd( cluster_xy >> Y_WIDTH );
	2220	_puts(",");
	2221	_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
	2222	_puts(",");
	2223	_putd( lpid );
	2224	_puts("] enters kernel at cycle ");
[258]	2225	_putd( _get_proctime() );
	2226	_puts(" / kernel entry = ");
	2227	_putx( kernel_entry );
	2228	_puts("\n");
	2229	_tty_release_lock( 0 );
	2230
	2231	asm volatile( "jr %0" ::"r"(kernel_entry) );
	2232
	2233	} // end boot_init()
	2234
	2235
	2236	// Local Variables:
	2237	// tab-width: 4
	2238	// c-basic-offset: 4
	2239	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	2240	// indent-tabs-mode: nil
	2241	// End:
	2242	// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	2243

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

Download in other formats: