Context Navigation

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

Last change on this file since 319 was 316, checked in by cfuguet, 10 years ago

boot.c:

Initializing Local, Remote and Dirty flags of each pte2 to 1. The goal is to avoid the hardware update mechanism for these flags. This is a performance optimization that can be made because mentioned flags are not exploited by GIET_VM.

File size: 79.7 KB

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

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

Download in other formats: