Context Navigation

source: trunk/kernel/kern/kernel_init.c @ 5

Last change on this file since 5 was 5, checked in by alain, 9 years ago
Introduce the chdev_t structure in place of the device_t structure.
File size: 30.6 KB

Line
1	/*
2	* kernel_init.c - kernel parallel initialization
3	*
4	* Authors : Alain Greiner (2016)
5	*
6	* Copyright (c) Sorbonne Universites
7	*
8	* This file is part of ALMOS-MKH.
9	*
10	* ALMOS-MKH is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; version 2.0 of the License.
13	*
14	* ALMOS-MKH is distributed in the hope that it will be useful, but
15	* WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
21	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22	*/
23
24	#include <almos_config.h>
25	#include <errno.h>
26	#include <hal_types.h>
27	#include <hal_special.h>
28	#include <hal_context.h>
29	#include <remote_barrier.h>
30	#include <core.h>
31	#include <list.h>
32	#include <thread.h>
33	#include <scheduler.h>
34	#include <kmem.h>
35	#include <cluster.h>
36	#include <devfs.h>
37	#include <sysfs.h>
38	#include <string.h>
39	#include <memcpy.h>
40	#include <ppm.h>
41	#include <page.h>
42	#include <chdev.h>
43	#include <boot_info.h>
44	#include <dqdt.h>
45	#include <dev_icu.h>
46	#include <dev_mmc.h>
47	#include <dev_dma.h>
48	#include <dev_iob.h>
49	#include <dev_ioc.h>
50	#include <dev_txt.h>
51	#include <dev_pic.h>
52	#include <printk.h>
53	#include <vfs.h>
54	#include <soclib_tty.h>
55
56
57	#define KERNEL_INIT_SYNCHRO 0xA5A5B5B5
58
59	///////////////////////////////////////////////////////////////////////////////////////////
60	// All these global variables are replicated in all clusters.
61	// They are initialised by the kernel_init() function.
62	///////////////////////////////////////////////////////////////////////////////////////////
63
64	// This variable defines the local boot_info structure
65	__attribute__((section(".kinfo")))
66	boot_info_t boot_info CACHELINE_ALIGNED;
67
68	// This variable defines the local cluster manager
69	__attribute__((section(".kdata")))
70	cluster_t cluster_manager CACHELINE_ALIGNED;
71
72	// These variables define the kernel process0 descriptor and associated thread
73	__attribute__((section(".kdata")))
74	process_t process_zero CACHELINE_ALIGNED;
75	thread_t thread_zero CACHELINE_ALIGNED;
76
77	// This variable contains the extended pointers on the device descriptors
78	__attribute__((section(".kdata")))
79	chdev_directory_t chdev_dir CACHELINE_ALIGNED;
80
81	// This variable contains the input IRQ indexes for the PIC device
82	__attribute__((section(".kdata")))
83	chdev_pic_input_t chdev_pic_input CACHELINE_ALIGNED;
84
85	// This variable contains the input IRQ indexes for the ICU device
86	__attribute__((section(".kdata")))
87	chdev_icu_input_t chdev_icu_input CACHELINE_ALIGNED;
88
89	// This variable synchronizes the local cores during kernel_init()
90	__attribute__((section(".kdata")))
91	volatile uint32_t local_sync_init CACHELINE_ALIGNED;
92
93	// This variable defines the local cluster identifier
94	__attribute__((section(".kdata")))
95	cxy_t local_cxy CACHELINE_ALIGNED;
96
97	// This variable is the lock protecting the kernel TXT terminal (used by printk)
98	__attribute__((section(".kdata")))
99	remote_spinlock_t txt0_lock CACHELINE_ALIGNED;
100
101	///////////////////////////////////////////////////////////////////////////////////////////
102	// This function displays the ALMOS_MKH banner.
103	///////////////////////////////////////////////////////////////////////////////////////////
104	static void print_banner( uint32_t nclusters , uint32_t ncores )
105	{
106	printk("\n"
107	" _ __ __ _____ ______ __ __ _ __ _ _ \n"
108	" /\\ \| \| \| \\ / \| / ___ \\ / _____\| \| \\ / \| \| \| / / \| \| \| \| \n"
109	" / \\ \| \| \| \\/ \| \| / \\ \| \| / \| \\/ \| \| \|/ / \| \| \| \| \n"
110	" / /\\ \\ \| \| \| \|\\ /\| \| \| \| \| \| \| \|_____ ___ \| \|\\ /\| \| \| / \| \|___\| \| \n"
111	" / /__\\ \\ \| \| \| \| \\/ \| \| \| \| \| \| \\_____ \\ \|___\| \| \| \\/ \| \| \| \\ \| ___ \| \n"
112	" / ______ \\ \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|\\ \\ \| \| \| \| \n"
113	" / / \\ \\ \| \|____ \| \| \| \| \| \\___/ \| _____/ \| \| \| \| \| \| \| \\ \\ \| \| \| \| \n"
114	" /_/ \\_\\ \|______\| \|_\| \|_\| \\_____/ \|______/ \|_\| \|_\| \|_\| \\_\\ \|_\| \|_\| \n"
115	"\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
116	"\n\n\t\t\t Version 0.0 : %d clusters / %d cores per cluster\n\n", nclusters , ncores );
117	}
118
119
120	///////////////////////////////////////////////////////////////////////////////////////////
121	// This static function allocates memory and initializes the TXT0 chdev descriptor,
122	// associated to the kernel terminal, shared by all kernel instances for debug messages.
123	// It should be called by a thread running in the I/O cluster, because the TXT0 chdev
124	// is created in the I/O cluster.
125	///////////////////////////////////////////////////////////////////////////////////////////
126	// @ info : pointer on the local boot-info structure.
127	///////////////////////////////////////////////////////////////////////////////////////////
128	static void txt0_device_init( boot_info_t * info )
129	{
130	boot_device_t * dev_tbl; // pointer on array of devices in boot_info
131	uint32_t dev_nr; // actual number of devices in this cluster
132	xptr_t base; // remote pointer on segment base
133	uint32_t size; // channel size (bytes)
134	uint32_t type; // peripheral type
135	uint32_t func; // device functionnal index
136	uint32_t impl; // device implementation index
137	uint32_t i; // device index in dev_tbl
138	uint32_t x; // X cluster coordinate
139	uint32_t y; // Y cluster coordinate
140	chdev_t * chdev; // local pointer on created chdev
141
142	// get number of peripherals and base of devices array from boot_info
143	dev_nr = info->ext_dev_nr;
144	dev_tbl = info->ext_dev;
145
146	// loop on external peripherals to find TXT
147	for( i = 0 ; i < dev_nr ; i++ )
148	{
149	size = dev_tbl[i].size;
150	base = dev_tbl[i].base;
151	type = dev_tbl[i].type;
152	func = FUNC_FROM_TYPE( type );
153	impl = IMPL_FROM_TYPE( type );
154
155	if (func == DEV_FUNC_TXT )
156	{
157	// allocate and initialize a local chdev for TXT0
158	chdev = chdev_create( func,
159	impl,
160	0, // channel
161	0, // direction
162	base );
163
164	// Complete TXT specific initialisation
165	if( impl == IMPL_TXT_TTY )
166	{
167	chdev->cmd = &soclib_tty_cmd;
168	chdev->isr = &soclib_tty_isr;
169	soclib_tty_init( chdev );
170	}
171
172	// initialize the replicated chdev_dir[x][y] structures
173	for( x = 0 ; x < info->x_size ; x++ )
174	{
175	for( y = 0 ; y < info->y_size ; y++ )
176	{
177	cxy_t cxy = (x<<info->y_width) + y;
178	hal_remote_swd( XPTR( cxy , &chdev_dir.txt[0] ) , XPTR( local_cxy , chdev ) );
179	}
180	}
181
182	kinit_dmsg("\n[INFO] %s : core[%x][0] created TXT0 chdev / paddr = %l at cycle %d\n",
183	__FUNCTION__ , local_cxy , chdev_func_str( func ), chdev_xp , hal_time_stamp() );
184	}
185
186	} // end loop on devices
187
188	} // end txt0_device_init()
189
190	///////////////////////////////////////////////////////////////////////////////////////////
191	// This static function allocates memory for the chdev (channel_device) descriptors
192	// associated to the internal peripherals contained in the local cluster. These internal
193	// devices (ICU, MMC, DMA) chdev descriptors are placed in the local cluster.
194	// It initialises these device descriptors as specified by the boot_info_t structure,
195	// including the dynamic linking with the driver for the specified implementation.
196	// Finally, all copies of the devices directory are initialised.
197	///////////////////////////////////////////////////////////////////////////////////////////
198	// @ info : pointer on the local boot-info structure.
199	///////////////////////////////////////////////////////////////////////////////////////////
200	static void internal_devices_init( boot_info_t * info )
201	{
202	boot_device_t * dev_tbl; // pointer on array of devices in boot_info
203	uint32_t dev_nr; // actual number of devices in this cluster
204	xptr_t base; // remote pointer on segment base
205	uint32_t size; // channel size (bytes)
206	uint32_t type; // peripheral type
207	uint32_t func; // device functionnal index
208	uint32_t impl; // device implementation index
209	uint32_t i; // device index in dev_tbl
210	uint32_t x; // X cluster coordinate
211	uint32_t y; // Y cluster coordinate
212	uint32_t channels_nr; // number of channels in device
213	uint32_t channel; // channel index
214	uint32_t p0; // device parameter 0
215	uint32_t p1; // device parameter 1
216	uint32_t p2; // device parameter 2
217	uint32_t p3; // device parameter 3
218
219	chdev_t * chdev; // local pointer on one channel_device descriptor
220	xptr_t chdev_xp; // extended pointer on channel_device descriptor
221
222	// get number of internal devices and base of devices array from boot_info
223	dev_nr = info->int_dev_nr;
224	dev_tbl = info->int_dev;
225
226	// loop on all internal devices in cluster
227	for( i = 0 ; i < dev_nr ; i++ )
228	{
229	size = dev_tbl[i].size;
230	base = dev_tbl[i].base;
231	type = dev_tbl[i].type;
232	channels_nr = dev_tbl[i].channels;
233	p0 = dev_tbl[i].param0;
234	p1 = dev_tbl[i].param1;
235	p2 = dev_tbl[i].param2;
236	p3 = dev_tbl[i].param3;
237
238	func = FUNC_FROM_TYPE( type );
239	impl = IMPL_FROM_TYPE( type );
240
241	// do nothing for RAM, that does not require a chdev descriptor.
242	if( func == DEV_FUNC_RAM ) continue;
243
244	// check internal device functional type
245	if( (func != DEV_FUNC_MMC) &&
246	(func != DEV_FUNC_ICU) &&
247	(func != DEV_FUNC_DMA) )
248	{
249	assert( false , __FUNCTION__ , "illegal internal peripheral type" );
250	}
251
252	// loop on channels
253	for( channel = 0 ; channel < channels_nr ; channel++ )
254	{
255	// create one chdev in local cluster
256	chdev = chdev_create( func ,
257	impl,
258	channel,
259	false, // TX
260	base );
261
262	assert( (chdev != NULL) , __FUNCTION__ , "cannot allocate internal chdev" );
263
264	// get extended pointer on channel descriptor
265	chdev_xp = XPTR( local_cxy , chdev );
266
267	// TODO ??? AG
268	// devfs_register( dev );
269
270	// make device type specific initialisation
271	// the number of parameters depends on the device type
272	// TODO : remove these parameters that must be provided by the driver
273	if ( func == DEV_FUNC_ICU ) dev_icu_init( chdev , p0 , p1 , p2 );
274	else if( func == DEV_FUNC_MMC ) dev_mmc_init( chdev );
275	else dev_dma_init( chdev );
276
277	// initialize the replicated chdev_dir[x][y] structures
278	// containing extended pointers on all devices descriptors
279	xptr_t * entry;
280
281	if ( func == DEV_FUNC_ICU ) entry = &chdev_dir.icu[local_cxy];
282	else if( func == DEV_FUNC_MMC ) entry = &chdev_dir.mmc[local_cxy];
283	else entry = &chdev_dir.dma[channel];
284
285	if( func != DEV_FUNC_DMA ) // ICU and MMC devices are remotely accessible
286	{
287	for( x = 0 ; x < info->x_size ; x++ )
288	{
289	for( y = 0 ; y < info->y_size ; y++ )
290	{
291	cxy_t cxy = (x<<info->y_width) + y;
292	hal_remote_swd( XPTR( cxy , entry ) , chdev_xp );
293	}
294	}
295	}
296	else // DMA devices are NOT remotely accessible
297	{
298	*entry = chdev_xp;
299	}
300
301	kinit_dmsg("\n[INFO] %s :core[%x][0] created chdev %s / channel %d"
302	" / paddr = %l at cycle %d\n",
303	__FUNCTION__ , local_cxy , chdev_func_str( func ) ,
304	channel , chdev_xp , hal_time_stamp() );
305
306	} // end loop on channels
307
308	// initialize the entries of the local chdev_icu_input structure
309	// defining how internal peripherals are connected to ICU
310	if( func == DEV_FUNC_ICU )
311	{
312	uint32_t id;
313	uint8_t valid;
314	uint32_t dev_type;
315	uint8_t channel;
316
317	// loop on ICU inputs
318	for( id = 0 ; id < CONFIG_MAX_HWIS_PER_ICU ; id++ )
319	{
320	valid = dev_tbl[i].irq[id].valid;
321	dev_type = dev_tbl[i].irq[id].dev_type;
322	channel = dev_tbl[i].irq[id].channel;
323
324	if( valid ) // only valid local IRQs are registered
325	{
326	uint32_t * index; // local pointer on the entry to be set
327	uint16_t dev_func = FUNC_FROM_TYPE( dev_type );
328	if( dev_func == DEV_FUNC_MMC )
329	index = &chdev_icu_input.mmc;
330	else if( dev_func == DEV_FUNC_DMA )
331	index = &chdev_icu_input.dma[channel];
332	else
333	{
334	assert( false , __FUNCTION__ , "illegal source device for ICU input" );
335	}
336
337	// set entry in local structure
338	*index = id;
339	}
340
341	} // end loop on ICU inputs
342	} // end if ICU
343	} // end loop on peripherals
344	} // end internal_devices_init()
345
346	///////////////////////////////////////////////////////////////////////////////////////////
347	// This static function allocates memory for the chdev descriptors associated
348	// to the external (shared) peripherals contained in the local cluster. These external
349	// devices (IOB, IOC, TXT, NIC, etc ) are distributed on all clusters.
350	// It initialises these device descriptors as specified by the boot_info_t structure,
351	// including the dynamic linking with the driver for the specified implementation.
352	// Finally, all copies of the devices directory are initialised.
353	//
354	// The number of channel_devices depends on the device functionnal type.
355	// There is three nested loops to scan the full set of external channel_devices:
356	// - loop on external devices.
357	// - loop on channels for multi-channels devices.
358	// - loop on directions (RX/TX) for NIC device.
359	// The set of channel_devices is indexed by the chdev_gid global index, that is used
360	// to select the cluster containing a given chdev[func,channel,direction].
361	// All clusters scan the full set of chdevs, but only the cluster matching
362	// (chdev_gid % (x_size*y_size)) create the corresponding chdev.
363	//
364	// TODO check that cluster IO contains a PIC [AG]
365	///////////////////////////////////////////////////////////////////////////////////////////
366	// @ info : pointer on the local boot-info structure.
367	///////////////////////////////////////////////////////////////////////////////////////////
368	static void external_devices_init( boot_info_t * info )
369	{
370	boot_device_t * dev_tbl; // pointer on array of devices in boot_info
371	uint32_t dev_nr; // actual number of devices in this cluster
372	xptr_t base; // remote pointer on segment base
373	uint32_t size; // channel size (bytes)
374	uint32_t type; // peripheral type
375	uint32_t func; // device functionnal index
376	uint32_t impl; // device implementation index
377	uint32_t i; // device index in dev_tbl
378	uint32_t x; // X cluster coordinate
379	uint32_t y; // Y cluster coordinate
380	uint32_t channels_nr; // number of channels
381	uint32_t channel; // channel index
382	uint32_t directions_nr; // number of directions
383	uint32_t direction; // direction index
384	uint32_t p0; // device parameter 0
385	uint32_t p1; // device parameter 1
386	uint32_t p2; // device parameter 2
387	uint32_t p3; // device parameter 3
388	uint32_t first_channel; // used in loop on channels
389
390	chdev_t * chdev; // local pointer on one channel_device descriptor
391	xptr_t chdev_xp; // extended pointer on channel_device descriptor
392	uint32_t chdev_gid = 0; // global index of channel_device descriptor
393
394	// get number of peripherals and base of devices array from boot_info
395	dev_nr = info->ext_dev_nr;
396	dev_tbl = info->ext_dev;
397
398	// loop on external peripherals
399	for( i = 0 ; i < dev_nr ; i++ )
400	{
401	size = dev_tbl[i].size;
402	base = dev_tbl[i].base;
403	type = dev_tbl[i].type;
404	channels_nr = dev_tbl[i].channels;
405	p0 = dev_tbl[i].param0;
406	p1 = dev_tbl[i].param1;
407	p2 = dev_tbl[i].param2;
408	p3 = dev_tbl[i].param3;
409
410	func = FUNC_FROM_TYPE( type );
411	impl = IMPL_FROM_TYPE( type );
412
413	// There is one chdev per direction for NIC
414	if (func == DEV_FUNC_NIC) directions_nr = 2;
415	else directions_nr = 1;
416
417	// The TXT0 chdev has already been created
418	if (func == DEV_FUNC_TXT) first_channel = 1;
419	else first_channel = 0;
420
421	// do nothing for ROM, that does not require a device descriptor.
422	if( func == DEV_FUNC_ROM ) continue;
423
424	// check external device functionnal type
425	if( (func != DEV_FUNC_IOB) &&
426	(func != DEV_FUNC_PIC) &&
427	(func != DEV_FUNC_IOC) &&
428	(func != DEV_FUNC_TXT) &&
429	(func != DEV_FUNC_NIC) &&
430	(func != DEV_FUNC_FBF) )
431	{
432	assert( false , __FUNCTION__ , "undefined external peripheral type" );
433	}
434
435	// loops on channels
436	for( channel = first_channel ; channel < channels_nr ; channel++ )
437	{
438	// loop on directions
439	for( direction = 0 ; direction < directions_nr ; direction++ )
440	{
441	// get target cluster for chdev[func,channel,direction]
442	uint32_t offset = chdev_gid % ( info->x_size * info->y_size );
443	uint32_t cx = offset / info->y_size;
444	uint32_t cy = offset % info->y_size;
445	uint32_t target_cxy = (cx<<info->y_width) + cy;
446
447	// allocate and initialize a local chdev
448	// if local cluster matches target cluster
449	if( target_cxy == local_cxy )
450	{
451	chdev = chdev_create( func,
452	impl,
453	channel,
454	direction,
455	base );
456
457	assert( (chdev != NULL), __FUNCTION__ ,
458	"cannot allocate external device" );
459
460	// get extended pointer on chdev
461	chdev_xp = XPTR( local_cxy , chdev );
462
463	// make device type specific initialisation
464	// the number of parameters depends on the device type
465	// TODO : remove the parameters that must be provided by the drivers
466	if ( func == DEV_FUNC_IOB ) dev_iob_init( chdev );
467	else if( func == DEV_FUNC_IOC ) dev_ioc_init( chdev );
468	else if( func == DEV_FUNC_TXT ) dev_txt_init( chdev );
469	else if( func == DEV_FUNC_NIC ) dev_nic_init( chdev );
470	else if( func == DEV_FUNC_PIC ) dev_pic_init( chdev , p0 );
471	else if( func == DEV_FUNC_FBF ) dev_fbf_init( chdev , p0 , p1 );
472	else
473	{
474	assert( false , __FUNCTION__ , "undefined device type" );
475	}
476
477	// all external (shared) devices are remotely accessible
478	// initialize the replicated chdev_dir[x][y] structures
479	// defining the extended pointers on chdev descriptors
480	xptr_t * entry;
481
482	if( func == DEV_FUNC_IOB ) entry = &chdev_dir.iob;
483	if( func == DEV_FUNC_PIC ) entry = &chdev_dir.pic;
484	if( func == DEV_FUNC_TXT ) entry = &chdev_dir.txt[channel];
485	if( func == DEV_FUNC_IOC ) entry = &chdev_dir.ioc[channel];
486	if( func == DEV_FUNC_FBF ) entry = &chdev_dir.fbf[channel];
487	if( func == DEV_FUNC_NIC ) entry = &chdev_dir.nic_tx[channel];
488
489	for( x = 0 ; x < info->x_size ; x++ )
490	{
491	for( y = 0 ; y < info->y_size ; y++ )
492	{
493	cxy_t cxy = (x<<info->y_width) + y;
494	hal_remote_swd( XPTR( cxy , entry ) , chdev_xp );
495	}
496	}
497
498	kinit_dmsg("\n[INFO] %s : core[%x][0] created chdev %s / channel = %d"
499	" / paddr = %l at cycle %d\n",
500	__FUNCTION__ , local_cxy , chdev_func_str( func ),
501	channel , chdev_xp , hal_time_stamp() );
502
503	} // end if match
504
505	// increment chdev global index (matching or not)
506	chdev_gid++;
507
508	} // end loop on directions
509
510	} // end loop on channels
511
512	// initialize the entries of the local chdev_pic_input structure
513	// defining how external peripherals are connected to PIC
514	if( func == DEV_FUNC_PIC )
515	{
516	uint32_t id;
517	uint8_t valid;
518	uint32_t dev_type;
519	uint8_t channel;
520	uint8_t is_rx;
521
522	// loop on PIC inputs
523	for( id = 0 ; id < CONFIG_MAX_IRQS_PER_PIC ; id++ )
524	{
525	valid = dev_tbl[i].irq[id].valid;
526	dev_type = dev_tbl[i].irq[id].dev_type;
527	channel = dev_tbl[i].irq[id].channel;
528	is_rx = dev_tbl[i].irq[id].is_rx;
529
530	if( valid ) // only valid inputs are registered
531	{
532	uint32_t * index; // local pointer on one entry
533	uint16_t dev_func = FUNC_FROM_TYPE( dev_type );
534
535	if( dev_func == DEV_FUNC_TXT )
536	{
537	index = &chdev_pic_input.txt[channel];
538	}
539	else if( dev_func == DEV_FUNC_IOC )
540	{
541	index = &chdev_pic_input.ioc[channel];
542	}
543	else if( (dev_func == DEV_FUNC_NIC) && (is_rx == 0) )
544	{
545	index = &chdev_pic_input.nic_tx[channel];
546	}
547	else if( (dev_func == DEV_FUNC_NIC) && (is_rx != 0) )
548	{
549	index = &chdev_pic_input.nic_rx[channel];
550	}
551	else
552	{
553	assert( false , __FUNCTION__ , "illegal source device for PIC input" );
554	}
555
556	// set entry in local structure
557	*index = id;
558	}
559	} // end loop on PIC inputs
560	} // end PIC
561	} // end loop on devices
562	} // end external_devices_init()
563
564
565	///////////////////////////////////////////////////////////////////////////////////////////
566	// This function is the entry point for the kernel initialisation.
567	// It is executed by all cores in all clusters, but only core[0] in each cluster
568	// initialize the cluster manager, ant the local peripherals.
569	// To comply with the multi-kernels paradigm, it access only local cluster memory, using
570	// only informations contained in the local boot_info_t structure, set by the bootloader.
571	///////////////////////////////////////////////////////////////////////////////////////////
572	// @ info : pointer on the local boot-info structure.
573	///////////////////////////////////////////////////////////////////////////////////////////
574	void kernel_init( boot_info_t * info )
575	{
576	uint32_t core_lid; // running core local index
577	cxy_t core_cxy; // running core cluster identifier
578	gid_t core_gid; // running core hardware identifier
579	cluster_t * cluster; // pointer on local cluster manager
580	core_t * core; // pointer on running core descriptor
581	thread_t * thread_idle; // pointer on thread_idle
582
583	uint32_t i;
584	bool_t found;
585	error_t error;
586
587	// initialise global cluster identifier
588	local_cxy = info->cxy;
589
590	// each core get its global index from hardware register
591	core_gid = hal_get_gid();
592
593	// Each core makes an associative search in boot_info
594	// to get its (cxy,lid) composite index from its gid
595	found = false;
596	core_cxy = 0;
597	core_lid = 0;
598	for( i = 0 ; i < info->cores_nr ; i++ )
599	{
600	if( core_gid == info->core[i].gid )
601	{
602	core_lid = info->core[i].lid;
603	core_cxy = info->core[i].cxy;
604	found = true;
605	break;
606	}
607	}
608
609	// suicide if not found
610	if( (found == false) \|\| (core_cxy != local_cxy) ) hal_core_sleep();
611
612	//////////////////////////////////////////////////////////////
613	// In first step, only CP0 initialises local resources
614	//////////////////////////////////////////////////////////////
615
616	if( core_lid == 0 )
617	{
618	// initialize local cluster manager (cores and memory allocators)
619	error = cluster_init( info );
620
621	// suicide if failure
622	if( error ) hal_core_sleep();
623
624	// get pointer on local cluster manager and on core descriptor
625	cluster = LOCAL_CLUSTER;
626	core = &cluster->core_tbl[core_lid];
627
628	// initialize process_zero descriptor
629	process_zero_init( info );
630
631	// CP0 initialize its private thread_zero descriptor
632	memset( &thread_zero , 0 , sizeof(thread_t) );
633	thread_zero.type = THREAD_KERNEL;
634	thread_zero.process = &process_zero;
635	hal_set_current_thread( &thread_zero );
636
637	// CP0 in I/O cluster initialize the kernel TXT0 chdev descriptor.
638	// this TXTO device is shared by the all kernel instances for debug messages:
639	// the printk() function call the dev_txt_sync_write() function that call
640	// directly the relevant TXT driver, without desheduling.
641	if( core_cxy == info->io_cxy ) txt0_device_init( info );
642
643	// synchronise all CP0s before using TXT0
644	remote_barrier( XPTR( info->io_cxy , &cluster->barrier ) ,
645	(cluster->x_size * cluster->y_size) );
646
647	// All CP0 initialise internal peripheral chdev descriptors.
648	// Each CP0[cxy] scan the set of its internal (private) peripherals,
649	// and allocate memory for the corresponding chdev descriptors.
650	internal_devices_init( info );
651
652	// All CP0 contribute to initialise external peripheral chdev descriptors.
653	// Each CP0[cxy] scan the set of external (shared) peripherals (but the TXT0),
654	// and allocates memory for the chdev descriptors that must be placed
655	// on the (cxy) cluster according to its global index.
656	external_devices_init( info );
657
658	// TODO initialize devFS and sysFS
659	// devfs_root_init();
660	// sysfs_root_init();
661
662	// TODO ??? [AG]
663	// clusters_sysfs_register();
664
665	// TODO initialize virtual file system
666	// vfs_init();
667
668	// TODO ??? [AG]
669	// sysconf_init();
670
671	// activate other cores in same cluster
672	local_sync_init = KERNEL_INIT_SYNCHRO;
673	hal_wbflush();
674	}
675	else // other cores
676	{
677	// other cores wait synchro from core[0]
678	while( local_sync_init != KERNEL_INIT_SYNCHRO )
679	{
680	uint32_t retval = hal_time_stamp() + 1000;
681	while( hal_time_stamp() < retval ) asm volatile ("nop");
682	}
683
684	// get pointer on local cluster manager and on core descriptor
685	cluster = LOCAL_CLUSTER;
686	core = &cluster->core_tbl[core_lid];
687
688	// core initialise its private thread_zero descriptor
689	memset( &thread_zero , 0 , sizeof(thread_t) );
690	thread_zero.type = THREAD_KERNEL;
691	thread_zero.process = &process_zero;
692	hal_set_current_thread( &thread_zero );
693	}
694
695	// each core creates its private idle thread descriptor
696	error = thread_kernel_create( &thread_idle,
697	THREAD_IDLE,
698	&thread_idle_func,
699	NULL,
700	core_lid );
701
702	assert( (error == 0) , __FUNCTION__ , "cannot create idle thread" );
703
704	// each core register thread_idle in scheduler
705	core->scheduler.idle = thread_idle;
706
707	// each core register thread pointer in core hardware register
708	hal_set_current_thread( thread_idle );
709
710	kinit_dmsg("\n[INFO] %s : thread idle created for core[%x][%d] at cycle %d\n",
711	__FUNCTION__ , core_cxy , core_lid , hal_time_stamp());
712
713	// global syncho for all core[0] in all clusters
714	if( core_lid == 0 )
715	{
716	remote_barrier( XPTR( info->io_cxy , &cluster->barrier ) ,
717	(cluster->x_size * cluster->y_size) );
718	}
719
720	// local synchro for all cores in local cluster
721	remote_barrier( XPTR( local_cxy , &cluster->barrier ) ,
722	cluster->cores_nr );
723
724	if( (core_lid == 0) && (local_cxy == info->io_cxy) )
725	{
726	print_banner( (info->x_size * info->y_size) , info->cores_nr );
727	}
728
729	// load idle thread context on calling core
730	hal_cpu_context_load( thread_idle );
731
732	} // end kernel_init()
733
734
735

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

Download in other formats: