Context Navigation

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

Last change on this file since 273 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

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: 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.
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	// for vobjs initialisation
71	#include <giet_config.h>
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
95	#if !defined(X_SIZE)
96	# error The X_SIZE value must be defined in the 'hard_config.h' file !
97	#endif
98
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
111	#if !defined(NB_PROCS_MAX)
112	# error The NB_PROCS_MAX value must be defined in the 'hard_config.h' file !
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
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)];
150
151
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	}
168
169	// checking number of clusters
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) )
174	{
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 );
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
204	_puts("\n - x_size = ");
205	_putd( header->x_size );
206	_puts("\n - y_size = ");
207	_putd( header->y_size );
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
235	unsigned int cluster_id;
236	mapping_cluster_t * cluster = _get_cluster_base(header);
237	for( cluster_id = 0; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
238	{
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");
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) &&
1110	(pseg[vseg[vseg_id].psegid].clusterid == cluster_id ) )
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	{
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");
1125	_exit();
1126	}
1127	} // end boot_get_sched_vaddr()
1128
1129	////////////////////////////////////////////////////////////////////////////////////
1130	// This function initialises all processors schedulers.
1131	// This is done by processor 0, and the MMU must be activated.
1132	// - In Step 1, it initialises the _schedulers[gpid] pointers array, and scan
1133	// the processors to initialise the schedulers, including the
1134	// idle_task context (ltid == 14).
1135	// - In Step 2, it scan all tasks in all vspaces to initialise the tasks contexts,
1136	// as specified in the mapping_info data structure.
1137	////////////////////////////////////////////////////////////////////////////////////
1138	void boot_schedulers_init()
1139	{
1140	mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
1141	mapping_cluster_t* cluster = _get_cluster_base(header);
1142	mapping_vspace_t* vspace = _get_vspace_base(header);
1143	mapping_task_t* task = _get_task_base(header);
1144	mapping_vobj_t* vobj = _get_vobj_base(header);
1145	mapping_proc_t* proc = _get_proc_base(header);
1146	mapping_irq_t* irq = _get_irq_base(header);
1147
1148	unsigned int cluster_id; // cluster index in mapping_info
1149	unsigned int proc_id; // processor index in mapping_info
1150	unsigned int irq_id; // irq index in mapping_info
1151	unsigned int vspace_id; // vspace index in mapping_info
1152	unsigned int task_id; // task index in mapping_info
1153
1154	// TTY, NIC, CMA, HBA, TIM and DMA channels allocators
1155	// - TTY[0] is reserved for the kernel
1156	// - In all clusters the first NB_PROCS_MAX timers
1157	// are reserved for the kernel (context switch)
1158
1159	unsigned int alloc_tty_channel = 0; // TTY channel allocator
1160	unsigned int alloc_nic_channel = 0; // NIC channel allocator
1161	unsigned int alloc_cma_channel = 0; // CMA channel allocator
1162	unsigned int alloc_hba_channel = 0; // IOC channel allocator
1163	unsigned int alloc_tim_channel[X_SIZE*Y_SIZE]; // user TIMER allocators
1164
1165	if (!GIET_MONO_TTY) alloc_tty_channel++;
1166
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
1175	// it is indexed by the global pid = cluster_xy*NB_PROCS_MAX + lpid
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
1179	for (cluster_id = 0 ; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
1180	{
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;
1184
1185	#if BOOT_DEBUG_SCHED
1186	_puts("\n[BOOT DEBUG] Initialise schedulers in cluster[");
1187	_putd( x );
1188	_puts(",");
1189	_putd( y );
1190	_puts("]\n");
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	{
1204	_puts("\n[BOOT ERROR] Too much processors in cluster[");
1205	_putd( x );
1206	_puts(",");
1207	_putd( y );
1208	_puts("]\n");
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	{
1218	_puts("\n[BOOT ERROR] Schedulers segment too small in cluster[");
1219	_putd( x );
1220	_puts(",");
1221	_putd( y );
1222	_puts("]\n");
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	{
1231	// current processor scheduler pointer : psched
1232	static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12));
1233
1234	// set the schedulers pointers array
1235	_schedulers[cluster_xy * NB_PROCS_MAX + lpid] = psched;
1236
1237	#if BOOT_DEBUG_SCHED
1238	_puts("\nProc_");
1239	_putd( x );
1240	_puts("_");
1241	_putd( y );
1242	_puts("_");
1243	_putd( lpid );
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
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
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 );
1335	_puts(" running on cluster[");
1336	_putd( x );
1337	_puts(",");
1338	_putd( y );
1339	_puts("]\n");
1340	#endif
1341	// compute gpid (global processor index) and scheduler base address
1342	unsigned int gpid = cluster_xy * NB_PROCS_MAX + task[task_id].proclocid;
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;
1368	if (!GIET_MONO_TTY) alloc_tty_channel++;
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
1473	// get vspace thread index
1474	unsigned int thread_id = task[task_id].trdid;
1475
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;
1507	psched->context[ltid][CTX_TRDID_ID] = thread_id;
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 );
1514	_puts(" allocated to processor ");
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] );
1542	_puts("\n - ctx[TRDID] = ");
1543	_putd( psched->context[ltid][CTX_TRDID_ID] );
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
1895	// loop on all physical clusters
1896	for (cluster_id = 0; cluster_id < X_SIZE*Y_SIZE; cluster_id++)
1897	{
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;
1902
1903	#if BOOT_DEBUG_PERI
1904	_puts("\n[BOOT DEBUG] ****** peripherals initialisation in cluster[");
1905	_putd( x );
1906	_puts(",");
1907	_putd( y );
1908	_puts("] ******\n");
1909	#endif
1910
1911	// loop on peripherals
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
1925	_puts("- IOC / channels = ");
1926	_putd(channels);
1927	_puts("\n");
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	{
1935	_dma_init( cluster_xy, channel_id );
1936	}
1937	#if BOOT_DEBUG_PERI
1938	_puts("- DMA / channels = ");
1939	_putd(channels);
1940	_puts("\n");
1941	#endif
1942	break;
1943	}
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	}
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
1987	_puts("- NIC / channels = ");
1988	_putd(channels);
1989	_puts("\n");
1990	#endif
1991	break;
1992	}
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	}
2013	case PERIPH_TYPE_TTY: // vci_multi_tty component
2014	{
2015	#if BOOT_DEBUG_PERI
2016	_puts("- TTY / channels = ");
2017	_putd(channels);
2018	_puts("\n");
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
2035	_puts("- IOB / channels = ");
2036	_putd(channels);
2037	_puts("\n");
2038	#endif
2039	break;
2040	}
2041	} // end switch periph type
2042	} // end for periphs
2043
2044	#if BOOT_DEBUG_PERI
2045	_puts("\n[BOOT DEBUG] ****** coprocessors initialisation in cluster[");
2046	_putd( x );
2047	_puts(",");
2048	_putd( y );
2049	_puts("] ******\n");
2050	#endif
2051
2052	// loop on coprocessors
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
2077	_mwr_hw_init( cluster_xy,
2078	cp_port_id,
2079	cp_port[cp_port_id].direction,
2080	mwmr_channel_pbase );
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	{
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;
2107
2108	if ( gpid == 0 ) // only Processor 0 does it
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
2134	_puts("\n[BOOT] Processor[0,0,0] : MMU activation at cycle ");
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
2155	// Initializing peripherals
2156	boot_peripherals_init();
2157
2158	_puts("\n[BOOT] All peripherals initialised at cycle ");
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
2170	unsigned int x,y,p;
2171	for (x = 0 ; x < X_SIZE ; x++)
2172	{
2173	for (y = 0 ; y < Y_SIZE ; y++)
2174	{
2175	for(p = 0; p < NB_PROCS_MAX; p++)
2176	{
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	}
2183	}
2184	}
2185	}
2186	} // end monoprocessor boot
2187
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
2192	// all processor initialise SCHED register
2193	_set_sched( (unsigned int)_schedulers[gpid] );
2194
2195	// all processors (but Proc 0) activate MMU
2196	if ( gpid != 0 )
2197	{
2198	_set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
2199	_set_mmu_mode( 0xF );
2200
2201	_tty_get_lock( 0 );
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 ");
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 );
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 ");
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: