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

Last change on this file since 535 was 535, checked in by nicolas.van.phan@…, 8 years ago

Replace TXT0 by MTTY0 for LETI
File size: 56.0 KB
Line 
1/*
2 * kernel_init.c - kernel parallel initialization
3 *
4 * Authors : Mohamed Lamine Karaoui (2015)
5 * Alain Greiner (2016,2017)
6 *
7 * Copyright (c) Sorbonne Universites
8 *
9 * This file is part of ALMOS-MKH.
10 *
11 * ALMOS-MKH is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2.0 of the License.
14 *
15 * ALMOS-MKH is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25#include <kernel_config.h>
26#include <errno.h>
27#include <hal_kernel_types.h>
28#include <hal_special.h>
29#include <hal_context.h>
30#include <hal_irqmask.h>
31#include <hal_ppm.h>
32#include <barrier.h>
33#include <remote_barrier.h>
34#include <remote_fifo.h>
35#include <core.h>
36#include <list.h>
37#include <xlist.h>
38#include <xhtab.h>
39#include <thread.h>
40#include <scheduler.h>
41#include <kmem.h>
42#include <cluster.h>
43#include <string.h>
44#include <memcpy.h>
45#include <ppm.h>
46#include <page.h>
47#include <chdev.h>
48#include <boot_info.h>
49#include <dqdt.h>
50#include <dev_mmc.h>
51#include <dev_dma.h>
52#include <dev_iob.h>
53#include <dev_ioc.h>
54#include <dev_txt.h>
55#include <dev_pic.h>
56#include <printk.h>
57#include <vfs.h>
58#include <devfs.h>
59#include <mapper.h>
60
61///////////////////////////////////////////////////////////////////////////////////////////
62// All the following global variables are replicated in all clusters.
63// They are initialised by the kernel_init() function.
64//
65// WARNING : The section names have been defined to control the base addresses of the
66// boot_info structure and the idle thread descriptors, through the kernel.ld script:
67// - the boot_info structure is built by the bootloader, and used by kernel_init.
68// it must be the first object in the kdata segment.
69// - the array of idle threads descriptors must be placed on the first page boundary after
70// the boot_info structure in the kdata segment.
71///////////////////////////////////////////////////////////////////////////////////////////
72
73// This variable defines the local boot_info structure
74__attribute__((section(".kinfo")))
75boot_info_t boot_info;
76
77// This variable defines the "idle" threads descriptors array
78__attribute__((section(".kidle")))
79char idle_threads[CONFIG_THREAD_DESC_SIZE *
80 CONFIG_MAX_LOCAL_CORES] CONFIG_PPM_PAGE_ALIGNED;
81
82// This variable defines the local cluster manager
83__attribute__((section(".kdata")))
84cluster_t cluster_manager CONFIG_CACHE_LINE_ALIGNED;
85
86// This variable defines the TXT0 kernel terminal (TX only)
87__attribute__((section(".kdata")))
88chdev_t txt0_chdev CONFIG_CACHE_LINE_ALIGNED;
89
90// This variables define the kernel process0 descriptor
91__attribute__((section(".kdata")))
92process_t process_zero CONFIG_CACHE_LINE_ALIGNED;
93
94// This variable defines extended pointers on the distributed chdevs
95__attribute__((section(".kdata")))
96chdev_directory_t chdev_dir CONFIG_CACHE_LINE_ALIGNED;
97
98// This variable contains the input IRQ indexes for the IOPIC controller
99__attribute__((section(".kdata")))
100iopic_input_t iopic_input CONFIG_CACHE_LINE_ALIGNED;
101
102// This variable contains the input IRQ indexes for the LAPIC controller
103__attribute__((section(".kdata")))
104lapic_input_t lapic_input CONFIG_CACHE_LINE_ALIGNED;
105
106// This variable defines the local cluster identifier
107__attribute__((section(".kdata")))
108cxy_t local_cxy CONFIG_CACHE_LINE_ALIGNED;
109
110// This variable is used for CP0 cores synchronisation in kernel_init()
111__attribute__((section(".kdata")))
112remote_barrier_t global_barrier CONFIG_CACHE_LINE_ALIGNED;
113
114// This variable is used for local cores synchronisation in kernel_init()
115__attribute__((section(".kdata")))
116barrier_t local_barrier CONFIG_CACHE_LINE_ALIGNED;
117
118// This variable defines the array of supported File System contexts
119__attribute__((section(".kdata")))
120vfs_ctx_t fs_context[FS_TYPES_NR] CONFIG_CACHE_LINE_ALIGNED;
121
122// kernel_init is the entry point defined in hal/tsar_mips32/kernel.ld
123// It will be used by the bootloader.
124extern void kernel_init( boot_info_t * info );
125
126// these debug variables are used to analyse the sys_read() syscall timing
127
128#if DEBUG_SYS_READ
129uint32_t enter_sys_read;
130uint32_t exit_sys_read;
131
132uint32_t enter_devfs_read;
133uint32_t exit_devfs_read;
134
135uint32_t enter_txt_read;
136uint32_t exit_txt_read;
137
138uint32_t enter_chdev_cmd_read;
139uint32_t exit_chdev_cmd_read;
140
141uint32_t enter_chdev_server_read;
142uint32_t exit_chdev_server_read;
143
144uint32_t enter_tty_cmd_read;
145uint32_t exit_tty_cmd_read;
146
147uint32_t enter_tty_isr_read;
148uint32_t exit_tty_isr_read;
149#endif
150
151// these debug variables are used to analyse the sys_write() syscall timing
152
153#if DEBUG_SYS_WRITE
154uint32_t enter_sys_write;
155uint32_t exit_sys_write;
156
157uint32_t enter_devfs_write;
158uint32_t exit_devfs_write;
159
160uint32_t enter_txt_write;
161uint32_t exit_txt_write;
162
163uint32_t enter_chdev_cmd_write;
164uint32_t exit_chdev_cmd_write;
165
166uint32_t enter_chdev_server_write;
167uint32_t exit_chdev_server_write;
168
169uint32_t enter_tty_cmd_write;
170uint32_t exit_tty_cmd_write;
171
172uint32_t enter_tty_isr_write;
173uint32_t exit_tty_isr_write;
174#endif
175
176///////////////////////////////////////////////////////////////////////////////////////////
177// This function displays the ALMOS_MKH banner.
178///////////////////////////////////////////////////////////////////////////////////////////
179static void print_banner( uint32_t nclusters , uint32_t ncores )
180{
181 printk("\n"
182 " _ __ __ _____ ______ __ __ _ __ _ _ \n"
183 " /\\ | | | \\ / | / ___ \\ / _____| | \\ / | | | / / | | | | \n"
184 " / \\ | | | \\/ | | / \\ | | / | \\/ | | |/ / | | | | \n"
185 " / /\\ \\ | | | |\\ /| | | | | | | |_____ ___ | |\\ /| | | / | |___| | \n"
186 " / /__\\ \\ | | | | \\/ | | | | | | \\_____ \\ |___| | | \\/ | | | \\ | ___ | \n"
187 " / ______ \\ | | | | | | | | | | | | | | | | | |\\ \\ | | | | \n"
188 " / / \\ \\ | |____ | | | | | \\___/ | _____/ | | | | | | | \\ \\ | | | | \n"
189 " /_/ \\_\\ |______| |_| |_| \\_____/ |______/ |_| |_| |_| \\_\\ |_| |_| \n"
190 "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
191 "\n\n\t\t %s / %d cluster(s) / %d core(s) per cluster\n\n",
192 CONFIG_ALMOS_VERSION , nclusters , ncores );
193}
194
195
196///////////////////////////////////////////////////////////////////////////////////////////
197// This function initializes the TXT0 chdev descriptor, that is the "kernel terminal",
198// shared by all kernel instances for debug messages.
199// It is a global variable (replicated in all clusters), because this terminal is used
200// before the kmem allocator initialisation, but only the instance in cluster containing
201// the calling core is registered in the "chdev_dir" directory.
202// As this TXT0 chdev supports only the TXT_SYNC_WRITE command, we don't create
203// a server thread, we don't allocate a WTI, and we don't initialize the waiting queue.
204///////////////////////////////////////////////////////////////////////////////////////////
205// @ info : pointer on the local boot-info structure.
206///////////////////////////////////////////////////////////////////////////////////////////
207static void txt0_device_init( boot_info_t * info )
208{
209 boot_device_t * dev_tbl; // pointer on array of devices in boot_info
210 uint32_t dev_nr; // actual number of devices in this cluster
211 xptr_t base; // remote pointer on segment base
212 uint32_t func; // device functional index
213 uint32_t impl; // device implementation index
214 uint32_t i; // device index in dev_tbl
215 uint32_t x; // X cluster coordinate
216 uint32_t y; // Y cluster coordinate
217 uint32_t channels; // number of channels
218
219 // get number of peripherals and base of devices array from boot_info
220 dev_nr = info->ext_dev_nr;
221 dev_tbl = info->ext_dev;
222
223 // loop on external peripherals to find TXT device
224 for( i = 0 ; i < dev_nr ; i++ )
225 {
226 base = dev_tbl[i].base;
227 func = FUNC_FROM_TYPE( dev_tbl[i].type );
228 impl = IMPL_FROM_TYPE( dev_tbl[i].type );
229 channels = dev_tbl[i].channels;
230
231 if (func == DEV_FUNC_TXT )
232 {
233 assert( (channels > 0) , "number of TXT channels cannot be 0\n");
234
235 // initializes TXT_TX[0] chdev
236 txt0_chdev.func = func;
237 txt0_chdev.impl = impl;
238 txt0_chdev.channel = 0;
239 txt0_chdev.base = base;
240 txt0_chdev.is_rx = false;
241
242 // initializes lock
243 remote_spinlock_init( XPTR( local_cxy , &txt0_chdev.wait_lock ) );
244
245 // TXT specific initialisation:
246 // no server thread & no IRQ routing for channel 0
247 dev_txt_init( &txt0_chdev );
248
249 // register the TXT0 in all chdev_dir[x][y] structures
250 for( x = 0 ; x < info->x_size ; x++ )
251 {
252 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
253 {
254 cxy_t cxy = (x<<info->y_width) + y;
255 hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
256 XPTR( local_cxy , &txt0_chdev ) );
257 }
258 }
259 }
260 } // end loop on devices
261} // end txt0_device_init()
262
263///////////////////////////////////////////////////////////////////////////////////////////
264// This function is the same as txt0_device_init() but uses the internal multi_tty device
265// attached to cluster (0,0) instead of the external tty_tsar.
266// This function is used instead of txt0_device_init() only for TSAR LETI.
267///////////////////////////////////////////////////////////////////////////////////////////
268// @ info : pointer on the local boot-info structure.
269///////////////////////////////////////////////////////////////////////////////////////////
270static void mtty0_device_init( boot_info_t * info)
271{
272 boot_device_t * dev_tbl; // pointer on array of devices in boot_info
273 uint32_t dev_nr; // actual number of devices in this cluster
274 xptr_t base; // remote pointer on segment base
275 uint32_t func; // device functional index
276 uint32_t impl; // device implementation index
277 uint32_t i; // device index in dev_tbl
278 uint32_t x; // X cluster coordinate
279 uint32_t y; // Y cluster coordinate
280
281 dev_nr = info->int_dev_nr;
282 dev_tbl = info->int_dev;
283
284 // Loop on internal peripherals of cluster (0,0) to find MTY0
285 for ( i = 0; i < dev_nr; i++ )
286 {
287 base = dev_tbl[i].base;
288 func = FUNC_FROM_TYPE( dev_tbl[i].type );
289 impl = IMPL_FROM_TYPE( dev_tbl[i].type );
290
291 if ( func == DEV_FUNC_TXT )
292 {
293 txt0_chdev.func = func;
294 txt0_chdev.impl = impl;
295 txt0_chdev.channel = 0;
296 txt0_chdev.base = base;
297 txt0_chdev.is_rx = false;
298
299 // Initialize MTY0 chdev lock
300 remote_spinlock_init( XPTR( local_cxy, &txt0_chdev.wait_lock ) );
301
302 // MTY specific initialization
303 dev_txt_init( &txt0_chdev );
304
305 // register the MTY in all chdev_dir[x][y] structures
306 for( x = 0 ; x < info->x_size ; x++ )
307 {
308 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
309 {
310 cxy_t cxy = (x<<info->y_width) + y;
311 hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
312 XPTR( local_cxy , &txt0_chdev ) );
313 }
314 }
315 }
316 } // end loop on internal devices
317} // end mty0_device_init()
318
319///////////////////////////////////////////////////////////////////////////////////////////
320// This function allocates memory and initializes the chdev descriptors for the internal
321// peripherals contained in the local cluster, other than the LAPIC, as specified by
322// the boot_info, including the linking with the driver for the specified implementation.
323// The relevant entries in all copies of the devices directory are initialised.
324///////////////////////////////////////////////////////////////////////////////////////////
325// @ info : pointer on the local boot-info structure.
326///////////////////////////////////////////////////////////////////////////////////////////
327static void internal_devices_init( boot_info_t * info )
328{
329 boot_device_t * dev_tbl; // pointer on array of internaldevices in boot_info
330 uint32_t dev_nr; // actual number of devices in this cluster
331 xptr_t base; // remote pointer on segment base
332 uint32_t func; // device functionnal index
333 uint32_t impl; // device implementation index
334 uint32_t i; // device index in dev_tbl
335 uint32_t x; // X cluster coordinate
336 uint32_t y; // Y cluster coordinate
337 uint32_t channels; // number of channels
338 uint32_t channel; // channel index
339 chdev_t * chdev_ptr; // local pointer on created chdev
340
341 // get number of internal peripherals and base from boot_info
342 dev_nr = info->int_dev_nr;
343 dev_tbl = info->int_dev;
344
345 // loop on internal peripherals
346 for( i = 0 ; i < dev_nr ; i++ )
347 {
348 base = dev_tbl[i].base;
349 channels = dev_tbl[i].channels;
350 func = FUNC_FROM_TYPE( dev_tbl[i].type );
351 impl = IMPL_FROM_TYPE( dev_tbl[i].type );
352
353 //////////////////////////
354 if( func == DEV_FUNC_MMC )
355 {
356 assert( (channels == 1) , "MMC device must be single channel\n" );
357
358 // create chdev in local cluster
359 chdev_ptr = chdev_create( func,
360 impl,
361 0, // channel
362 false, // direction
363 base );
364
365 assert( (chdev_ptr != NULL) ,
366 "cannot allocate memory for MMC chdev\n" );
367
368 // make MMC specific initialisation
369 dev_mmc_init( chdev_ptr );
370
371 // set the MMC field in all chdev_dir[x][y] structures
372 for( x = 0 ; x < info->x_size ; x++ )
373 {
374 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
375 {
376 cxy_t cxy = (x<<info->y_width) + y;
377 hal_remote_swd( XPTR( cxy , &chdev_dir.mmc[local_cxy] ),
378 XPTR( local_cxy , chdev_ptr ) );
379 }
380 }
381
382#if( DEBUG_KERNEL_INIT & 0x1 )
383if( hal_time_stamp() > DEBUG_KERNEL_INIT )
384printk("\n[DBG] %s : created MMC in cluster %x / chdev = %x\n",
385__FUNCTION__ , local_cxy , chdev_ptr );
386#endif
387 }
388 ///////////////////////////////
389 else if( func == DEV_FUNC_DMA )
390 {
391 // create one chdev per channel in local cluster
392 for( channel = 0 ; channel < channels ; channel++ )
393 {
394 // create chdev[channel] in local cluster
395 chdev_ptr = chdev_create( func,
396 impl,
397 channel,
398 false, // direction
399 base );
400
401 assert( (chdev_ptr != NULL) , "cannot allocate memory for DMA chdev" );
402
403 // make DMA specific initialisation
404 dev_dma_init( chdev_ptr );
405
406 // initialize only the DMA[channel] field in the local chdev_dir[x][y]
407 // structure because the DMA device is not remotely accessible.
408 chdev_dir.dma[channel] = XPTR( local_cxy , chdev_ptr );
409
410#if( DEBUG_KERNEL_INIT & 0x1 )
411if( hal_time_stamp() > DEBUG_KERNEL_INIT )
412printk("\n[DBG] %s : created DMA[%d] in cluster %x / chdev = %x\n",
413__FUNCTION__ , channel , local_cxy , chdev_ptr );
414#endif
415 }
416 }
417 }
418} // end internal_devices_init()
419
420///////////////////////////////////////////////////////////////////////////////////////////
421// This function allocates memory and initializes the chdev descriptors for the
422// external (shared) peripherals other than the IOPIC, as specified by the boot_info.
423// This includes the dynamic linking with the driver for the specified implementation.
424// These chdev descriptors are distributed on all clusters, using a modulo on a global
425// index, identically computed in all clusters.
426// This function is executed in all clusters by the CP0 core, that computes a global index
427// for all external chdevs. Each CP0 core creates only the chdevs that must be placed in
428// the local cluster, because the global index matches the local index.
429// The relevant entries in all copies of the devices directory are initialised.
430///////////////////////////////////////////////////////////////////////////////////////////
431// @ info : pointer on the local boot-info structure.
432///////////////////////////////////////////////////////////////////////////////////////////
433static void external_devices_init( boot_info_t * info )
434{
435 boot_device_t * dev_tbl; // pointer on array of external devices in boot_info
436 uint32_t dev_nr; // actual number of external devices
437 xptr_t base; // remote pointer on segment base
438 uint32_t func; // device functionnal index
439 uint32_t impl; // device implementation index
440 uint32_t i; // device index in dev_tbl
441 uint32_t x; // X cluster coordinate
442 uint32_t y; // Y cluster coordinate
443 uint32_t channels; // number of channels
444 uint32_t channel; // channel index
445 uint32_t directions; // number of directions (1 or 2)
446 uint32_t rx; // direction index (0 or 1)
447 chdev_t * chdev; // local pointer on one channel_device descriptor
448 uint32_t ext_chdev_gid; // global index of external chdev
449
450 // get number of peripherals and base of devices array from boot_info
451 dev_nr = info->ext_dev_nr;
452 dev_tbl = info->ext_dev;
453
454 // initializes global index (PIC is already placed in cluster 0
455 ext_chdev_gid = 1;
456
457 // loop on external peripherals
458 for( i = 0 ; i < dev_nr ; i++ )
459 {
460 base = dev_tbl[i].base;
461 channels = dev_tbl[i].channels;
462 func = FUNC_FROM_TYPE( dev_tbl[i].type );
463 impl = IMPL_FROM_TYPE( dev_tbl[i].type );
464
465 // There is one chdev per direction for NIC and for TXT
466 if((func == DEV_FUNC_NIC) || (func == DEV_FUNC_TXT)) directions = 2;
467 else directions = 1;
468
469 // do nothing for ROM, that does not require a device descriptor.
470 if( func == DEV_FUNC_ROM ) continue;
471
472 // do nothing for PIC, that is already initialized
473 if( func == DEV_FUNC_PIC ) continue;
474
475 // check PIC device initialized
476 assert( (chdev_dir.pic != XPTR_NULL ) ,
477 "PIC device must be initialized before other devices\n" );
478
479 // check external device functionnal type
480 assert( ( (func == DEV_FUNC_IOB) ||
481 (func == DEV_FUNC_IOC) ||
482 (func == DEV_FUNC_TXT) ||
483 (func == DEV_FUNC_NIC) ||
484 (func == DEV_FUNC_FBF) ) ,
485 "undefined external peripheral type\n" );
486
487 // loops on channels
488 for( channel = 0 ; channel < channels ; channel++ )
489 {
490 // loop on directions
491 for( rx = 0 ; rx < directions ; rx++ )
492 {
493 // skip TXT_TX[0] chdev that has already been created & registered
494 if( (func == DEV_FUNC_TXT) && (channel == 0) && (rx == 0) ) continue;
495
496 // compute target cluster for chdev[func,channel,direction]
497 uint32_t offset = ext_chdev_gid % ( info->x_size * (info->y_max) ); // [FIXME]
498 uint32_t cx = offset / (info->y_max); // [FIXME]
499 uint32_t cy = offset % (info->y_max); // [FIXME]
500 uint32_t target_cxy = (cx<<info->y_width) + cy;
501
502 // allocate and initialize a local chdev
503 // when local cluster matches target cluster
504 if( target_cxy == local_cxy )
505 {
506 chdev = chdev_create( func,
507 impl,
508 channel,
509 rx, // direction
510 base );
511
512 assert( (chdev != NULL),
513 "cannot allocate external device" );
514
515 // make device type specific initialisation
516 if ( func == DEV_FUNC_IOB ) dev_iob_init( chdev );
517 else if( func == DEV_FUNC_IOC ) dev_ioc_init( chdev );
518 else if( func == DEV_FUNC_TXT ) dev_txt_init( chdev );
519 else if( func == DEV_FUNC_NIC ) dev_nic_init( chdev );
520 else if( func == DEV_FUNC_FBF ) dev_fbf_init( chdev );
521
522 // all external (shared) devices are remotely accessible
523 // initialize the replicated chdev_dir[x][y] structures
524 // defining the extended pointers on chdev descriptors
525 xptr_t * entry;
526
527 if(func==DEV_FUNC_IOB ) entry = &chdev_dir.iob;
528 if(func==DEV_FUNC_IOC ) entry = &chdev_dir.ioc[channel];
529 if(func==DEV_FUNC_FBF ) entry = &chdev_dir.fbf[channel];
530 if((func==DEV_FUNC_TXT) && (rx==0)) entry = &chdev_dir.txt_tx[channel];
531 if((func==DEV_FUNC_TXT) && (rx==1)) entry = &chdev_dir.txt_rx[channel];
532 if((func==DEV_FUNC_NIC) && (rx==0)) entry = &chdev_dir.nic_tx[channel];
533 if((func==DEV_FUNC_NIC) && (rx==1)) entry = &chdev_dir.nic_rx[channel];
534
535 for( x = 0 ; x < info->x_size ; x++ )
536 {
537 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
538 {
539 cxy_t cxy = (x<<info->y_width) + y;
540 hal_remote_swd( XPTR( cxy , entry ),
541 XPTR( local_cxy , chdev ) );
542 }
543 }
544
545#if( DEBUG_KERNEL_INIT & 0x1 )
546if( hal_time_stamp() > DEBUG_KERNEL_INIT )
547printk("\n[DBG] %s : create chdev %s / channel = %d / rx = %d / cluster %x / chdev = %x\n",
548__FUNCTION__ , chdev_func_str( func ), channel , rx , local_cxy , chdev );
549#endif
550 } // end if match
551
552 // increment chdev global index (matching or not)
553 ext_chdev_gid++;
554
555 } // end loop on directions
556 } // end loop on channels
557 } // end loop on devices
558} // end external_devices_init()
559
560///////////////////////////////////////////////////////////////////////////////////////////
561// This function is called by CP0 in cluster 0 to allocate memory and initialize the PIC
562// device, namely the informations attached to the external IOPIC controller, that
563// must be replicated in all clusters (struct iopic_input).
564// This initialisation must be done before other devices initialisation because the IRQ
565// routing infrastructure is required for both internal and external devices init.
566///////////////////////////////////////////////////////////////////////////////////////////
567// @ info : pointer on the local boot-info structure.
568///////////////////////////////////////////////////////////////////////////////////////////
569static void iopic_init( boot_info_t * info )
570{
571 boot_device_t * dev_tbl; // pointer on boot_info external devices array
572 uint32_t dev_nr; // actual number of external devices
573 xptr_t base; // remote pointer on segment base
574 uint32_t func; // device functionnal index
575 uint32_t impl; // device implementation index
576 uint32_t i; // device index in dev_tbl
577 uint32_t x; // cluster X coordinate
578 uint32_t y; // cluster Y coordinate
579 bool_t found; // IOPIC found
580 chdev_t * chdev; // pointer on PIC chdev descriptor
581
582 // get number of external peripherals and base of array from boot_info
583 dev_nr = info->ext_dev_nr;
584 dev_tbl = info->ext_dev;
585
586 // loop on external peripherals to get the IOPIC
587 for( i = 0 , found = false ; i < dev_nr ; i++ )
588 {
589 func = FUNC_FROM_TYPE( dev_tbl[i].type );
590
591 if( func == DEV_FUNC_PIC )
592 {
593 base = dev_tbl[i].base;
594 impl = IMPL_FROM_TYPE( dev_tbl[i].type );
595 found = true;
596 break;
597 }
598 }
599
600 assert( found , "PIC device not found\n" );
601
602 // allocate and initialize the PIC chdev in cluster 0
603 chdev = chdev_create( DEV_FUNC_PIC,
604 impl,
605 0, // channel
606 0, // direction,
607 base );
608
609 assert( (chdev != NULL), "no memory for PIC chdev\n" );
610
611 // make PIC device type specific initialisation
612 dev_pic_init( chdev );
613
614 // register, in all clusters, the extended pointer
615 // on PIC chdev in "chdev_dir" array
616 xptr_t * entry = &chdev_dir.pic;
617
618 for( x = 0 ; x < info->x_size ; x++ )
619 {
620 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
621 {
622 cxy_t cxy = (x<<info->y_width) + y;
623 hal_remote_swd( XPTR( cxy , entry ) ,
624 XPTR( local_cxy , chdev ) );
625 }
626 }
627
628 // initialize, in all clusters, the "iopic_input" structure
629 // defining how external IRQs are connected to IOPIC
630
631 // register default value for unused inputs
632 for( x = 0 ; x < info->x_size ; x++ )
633 {
634 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
635 {
636 cxy_t cxy = (x<<info->y_width) + y;
637 hal_remote_memset( XPTR( cxy , &iopic_input ) , 0xFF , sizeof(iopic_input_t) );
638 }
639 }
640
641 // register input IRQ index for valid inputs
642 uint32_t id; // input IRQ index
643 uint8_t valid; // input IRQ is connected
644 uint32_t type; // source device type
645 uint8_t channel; // source device channel
646 uint8_t is_rx; // source device direction
647 uint32_t * ptr; // local pointer on one field in iopic_input stucture
648
649 for( id = 0 ; id < CONFIG_MAX_EXTERNAL_IRQS ; id++ )
650 {
651 valid = dev_tbl[i].irq[id].valid;
652 type = dev_tbl[i].irq[id].dev_type;
653 channel = dev_tbl[i].irq[id].channel;
654 is_rx = dev_tbl[i].irq[id].is_rx;
655 func = FUNC_FROM_TYPE( type );
656
657 // get pointer on relevant field in iopic_input
658 if( valid )
659 {
660 if ( func == DEV_FUNC_IOC ) ptr = &iopic_input.ioc[channel];
661 else if((func == DEV_FUNC_TXT) && (is_rx == 0)) ptr = &iopic_input.txt_tx[channel];
662 else if((func == DEV_FUNC_TXT) && (is_rx != 0)) ptr = &iopic_input.txt_rx[channel];
663 else if((func == DEV_FUNC_NIC) && (is_rx == 0)) ptr = &iopic_input.nic_tx[channel];
664 else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel];
665 else if( func == DEV_FUNC_IOB ) ptr = &iopic_input.iob;
666 else assert( false , "illegal source device for IOPIC input" );
667
668 // set one entry in all "iopic_input" structures
669 for( x = 0 ; x < info->x_size ; x++ )
670 {
671 for( y = 0 ; y < info->y_max; y++ ) // [FIXME]
672 {
673 cxy_t cxy = (x<<info->y_width) + y;
674 hal_remote_swd( XPTR( cxy , ptr ) , id );
675 }
676 }
677 }
678 }
679
680#if( DEBUG_KERNEL_INIT & 0x1 )
681if( hal_time_stamp() > DEBUG_KERNEL_INIT )
682{
683 printk("\n[DBG] %s created PIC chdev in cluster %x at cycle %d\n",
684 __FUNCTION__ , local_cxy , (uint32_t)hal_time_stamp() );
685 dev_pic_inputs_display();
686}
687#endif
688
689} // end iopic_init()
690
691///////////////////////////////////////////////////////////////////////////////////////////
692// This function is called by all CP0s in all cluster to complete the PIC device
693// initialisation, namely the informations attached to the LAPIC controller.
694// This initialisation must be done after the IOPIC initialisation, but before other
695// devices initialisation because the IRQ routing infrastructure is required for both
696// internal and external devices initialisation.
697///////////////////////////////////////////////////////////////////////////////////////////
698// @ info : pointer on the local boot-info structure.
699///////////////////////////////////////////////////////////////////////////////////////////
700static void lapic_init( boot_info_t * info )
701{
702 boot_device_t * dev_tbl; // pointer on boot_info internal devices array
703 uint32_t dev_nr; // number of internal devices
704 uint32_t i; // device index in dev_tbl
705 xptr_t base; // remote pointer on segment base
706 uint32_t func; // device functionnal type in boot_info
707 bool_t found; // LAPIC found
708
709 // get number of internal peripherals and base
710 dev_nr = info->int_dev_nr;
711 dev_tbl = info->int_dev;
712
713 // loop on internal peripherals to get the lapic device
714 for( i = 0 , found = false ; i < dev_nr ; i++ )
715 {
716 func = FUNC_FROM_TYPE( dev_tbl[i].type );
717
718 if( func == DEV_FUNC_ICU )
719 {
720 base = dev_tbl[i].base;
721 found = true;
722 break;
723 }
724 }
725
726 // if the LAPIC controller is not defined in the boot_info,
727 // we simply don't initialize the PIC extensions in the kernel,
728 // making the assumption that the LAPIC related informations
729 // are hidden in the hardware specific PIC driver.
730 if( found )
731 {
732 // initialise the PIC extensions for
733 // the core descriptor and core manager extensions
734 dev_pic_extend_init( (uint32_t *)GET_PTR( base ) );
735
736 // initialize the "lapic_input" structure
737 // defining how internal IRQs are connected to LAPIC
738 uint32_t id;
739 uint8_t valid;
740 uint8_t channel;
741 uint32_t func;
742
743 for( id = 0 ; id < CONFIG_MAX_INTERNAL_IRQS ; id++ )
744 {
745 valid = dev_tbl[i].irq[id].valid;
746 func = FUNC_FROM_TYPE( dev_tbl[i].irq[id].dev_type );
747 channel = dev_tbl[i].irq[id].channel;
748
749 if( valid ) // only valid local IRQs are registered
750 {
751 if ( func == DEV_FUNC_MMC ) lapic_input.mmc = id;
752 else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id;
753 else if( func == DEV_FUNC_TXT ) lapic_input.mtty = id;
754 else assert( false , "illegal source device for LAPIC input" );
755 }
756 }
757 }
758} // end lapic_init()
759
760///////////////////////////////////////////////////////////////////////////////////////////
761// This static function returns the identifiers of the calling core.
762///////////////////////////////////////////////////////////////////////////////////////////
763// @ info : pointer on boot_info structure.
764// @ lid : [out] core local index in cluster.
765// @ cxy : [out] cluster identifier.
766// @ lid : [out] core global identifier (hardware).
767// @ return 0 if success / return EINVAL if not found.
768///////////////////////////////////////////////////////////////////////////////////////////
769static error_t get_core_identifiers( boot_info_t * info,
770 lid_t * lid,
771 cxy_t * cxy,
772 gid_t * gid )
773{
774 uint32_t i;
775 gid_t global_id;
776
777 // get global identifier from hardware register
778 global_id = hal_get_gid();
779
780 // makes an associative search in boot_info to get (cxy,lid) from global_id
781 for( i = 0 ; i < info->cores_nr ; i++ )
782 {
783 if( global_id == info->core[i].gid )
784 {
785 *lid = info->core[i].lid;
786 *cxy = info->core[i].cxy;
787 *gid = global_id;
788 return 0;
789 }
790 }
791 return EINVAL;
792}
793
794///////////////////////////////////////////////////////////////////////////////////////////
795// This function is the entry point for the kernel initialisation.
796// It is executed by all cores in all clusters, but only core[0], called CP0,
797// initializes the shared resources such as the cluster manager, or the local peripherals.
798// To comply with the multi-kernels paradigm, it accesses only local cluster memory, using
799// only information contained in the local boot_info_t structure, set by the bootloader.
800// Only CP0 in cluster 0 print the log messages.
801///////////////////////////////////////////////////////////////////////////////////////////
802// @ info : pointer on the local boot-info structure.
803///////////////////////////////////////////////////////////////////////////////////////////
804void kernel_init( boot_info_t * info )
805{
806 lid_t core_lid = -1; // running core local index
807 cxy_t core_cxy = -1; // running core cluster identifier
808 gid_t core_gid; // running core hardware identifier
809 cluster_t * cluster; // pointer on local cluster manager
810 core_t * core; // pointer on running core descriptor
811 thread_t * thread; // pointer on idle thread descriptor
812
813 xptr_t vfs_root_inode_xp; // extended pointer on VFS root inode
814 xptr_t devfs_dev_inode_xp; // extended pointer on DEVFS dev inode
815 xptr_t devfs_external_inode_xp; // extended pointer on DEVFS external inode
816 xptr_t devfs_internal_inode_xp; // extended pointer on DEVFS internal inode
817
818 error_t error;
819 reg_t status; // running core status register
820
821 /////////////////////////////////////////////////////////////////////////////////
822 // STEP 0 : Each core get its core identifier from boot_info, and makes
823 // a partial initialisation of its private idle thread descriptor.
824 // CP0 initializes the "local_cxy" global variable.
825 // CP0 in cluster IO initializes the TXT0 chdev to print log messages.
826 /////////////////////////////////////////////////////////////////////////////////
827
828 error = get_core_identifiers( info,
829 &core_lid,
830 &core_cxy,
831 &core_gid );
832
833 // CP0 initializes cluster identifier
834 if( core_lid == 0 ) local_cxy = info->cxy;
835
836 // each core gets a pointer on its private idle thread descriptor
837 thread = (thread_t *)( idle_threads + (core_lid * CONFIG_THREAD_DESC_SIZE) );
838
839 // each core registers this thread pointer in hardware register
840 hal_set_current_thread( thread );
841
842 // each core register core descriptor pointer in idle thread descriptor
843 thread->core = &LOCAL_CLUSTER->core_tbl[core_lid];
844
845 // each core initializes the idle thread lists of locks
846 list_root_init( &thread->locks_root );
847 xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
848 thread->local_locks = 0;
849 thread->remote_locks = 0;
850
851 // CP0 in cluster 0 initializes TXT0 chdev descriptor
852 if( core_cxy == 0 && core_lid == 0 ) // [MODIF]
853 {
854 if( info->use_mty0 == 1 ) {
855 mtty0_device_init( info );
856 } else {
857 txt0_device_init( info );
858 }
859 }
860 // [FIXME]
861
862 /////////////////////////////////////////////////////////////////////////////////
863 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
864 (info->x_size * (info->y_max)) );
865 barrier_wait( &local_barrier , info->cores_nr );
866 /////////////////////////////////////////////////////////////////////////////////
867
868#if DEBUG_KERNEL_INIT
869if( (core_lid == 0) & (local_cxy == 0) )
870printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",
871__FUNCTION__, (uint32_t)hal_get_cycles() );
872#endif
873
874 /////////////////////////////////////////////////////////////////////////////
875 // STEP 1 : all cores check core identifier.
876 // CP0 initializes the local cluster manager.
877 // This includes the memory allocators.
878 /////////////////////////////////////////////////////////////////////////////
879
880 // all cores check identifiers
881 if( error )
882 {
883 assert( false ,
884 "illegal core identifiers gid = %x / cxy = %x / lid = %d",
885 core_lid , core_cxy , core_lid );
886 }
887
888 // CP0 initializes cluster manager
889 if( core_lid == 0 )
890 {
891 error = cluster_init( info );
892
893 if( error )
894 {
895 assert( false ,
896 "cannot initialise cluster %x", local_cxy );
897 }
898 }
899
900 /////////////////////////////////////////////////////////////////////////////////
901 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
902 (info->x_size * (info->y_max)) );
903 barrier_wait( &local_barrier , info->cores_nr );
904 /////////////////////////////////////////////////////////////////////////////////
905
906#if DEBUG_KERNEL_INIT
907if( (core_lid == 0) & (local_cxy == 0) )
908printk("\n[DBG] %s : exit barrier 1 : clusters initialised / cycle %d\n",
909__FUNCTION__, (uint32_t)hal_get_cycles() );
910#endif
911
912 /////////////////////////////////////////////////////////////////////////////////
913 // STEP 2 : CP0 initializes the process_zero descriptor.
914 // CP0 in cluster 0 initializes the IOPIC device.
915 /////////////////////////////////////////////////////////////////////////////////
916
917 // all cores get pointer on local cluster manager & core descriptor
918 cluster = &cluster_manager;
919 core = &cluster->core_tbl[core_lid];
920
921 // all CP0s initialize the process_zero descriptor
922 if( core_lid == 0 ) process_zero_create( &process_zero );
923
924 // CP0 in cluster 0 initializes the PIC chdev,
925 if( (core_lid == 0) && (local_cxy == 0) ) iopic_init( info );
926
927 ////////////////////////////////////////////////////////////////////////////////
928 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
929 (info->x_size * (info->y_max)) );
930 barrier_wait( &local_barrier , info->cores_nr );
931 ////////////////////////////////////////////////////////////////////////////////
932
933#if DEBUG_KERNEL_INIT
934if( (core_lid == 0) & (local_cxy == 0) )
935printk("\n[DBG] %s : exit barrier 2 : PIC initialised / cycle %d\n",
936__FUNCTION__, (uint32_t)hal_get_cycles() );
937#endif
938
939 ////////////////////////////////////////////////////////////////////////////////
940 // STEP 3 : CP0 initializes the distibuted LAPIC descriptor.
941 // CP0 initializes the internal chdev descriptors
942 // CP0 initialize the local external chdev descriptors
943 ////////////////////////////////////////////////////////////////////////////////
944
945 // all CP0s initialize their local LAPIC extension,
946 if( core_lid == 0 ) lapic_init( info );
947
948 // CP0 scan the internal (private) peripherals,
949 // and allocates memory for the corresponding chdev descriptors.
950 if( core_lid == 0 ) internal_devices_init( info );
951
952
953 // All CP0s contribute to initialise external peripheral chdev descriptors.
954 // Each CP0[cxy] scan the set of external (shared) peripherals (but the TXT0),
955 // and allocates memory for the chdev descriptors that must be placed
956 // on the (cxy) cluster according to the global index value.
957
958 if( core_lid == 0 ) external_devices_init( info );
959
960 /////////////////////////////////////////////////////////////////////////////////
961 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
962 (info->x_size * (info->y_max)) );
963 barrier_wait( &local_barrier , info->cores_nr );
964 /////////////////////////////////////////////////////////////////////////////////
965
966#if DEBUG_KERNEL_INIT
967if( (core_lid == 0) & (local_cxy == 0) )
968printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / cycle %d\n",
969__FUNCTION__, (uint32_t)hal_get_cycles() );
970#endif
971
972#if( DEBUG_KERNEL_INIT & 1 )
973if( (core_lid == 0) & (local_cxy == 0) )
974chdev_dir_display();
975#endif
976
977 /////////////////////////////////////////////////////////////////////////////////
978 // STEP 4 : All cores enable IPI (Inter Procesor Interrupt),
979 // Alh cores initialize IDLE thread.
980 // Only CP0 in cluster 0 creates the VFS root inode.
981 // It access the boot device to initialize the file system context.
982 /////////////////////////////////////////////////////////////////////////////////
983
984 // All cores enable the shared IPI channel
985 dev_pic_enable_ipi();
986 hal_enable_irq( &status );
987
988#if DEBUG_KERNEL_INIT
989printk("\n[DBG] %s: IPI enabled for core %d cluster %d\n", __FUNCTION__,
990 core_lid, local_cxy);
991#endif
992
993 // all cores initialize the idle thread descriptor
994 thread_idle_init( thread,
995 THREAD_IDLE,
996 &thread_idle_func,
997 NULL,
998 core_lid );
999
1000 // all cores unblock idle thread, and register it in scheduler
1001 thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
1002 core->scheduler.idle = thread;
1003
1004#if( DEBUG_KERNEL_INIT & 1 )
1005sched_display( core_lid );
1006#endif
1007
1008 // CPO in cluster 0 creates the VFS root
1009 if( (core_lid == 0) && (local_cxy == 0 ) )
1010 {
1011 vfs_root_inode_xp = XPTR_NULL;
1012
1013 // File System must be FATFS in this implementation,
1014 // but other File System can be introduced here
1015 if( CONFIG_VFS_ROOT_IS_FATFS )
1016 {
1017 // 1. allocate memory for FATFS context in cluster 0
1018 fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
1019
1020 assert( (fatfs_ctx != NULL) ,
1021 "cannot create FATFS context in cluster 0\n" );
1022
1023 // 2. access boot device to initialize FATFS context
1024 fatfs_ctx_init( fatfs_ctx );
1025
1026 // 3. get various informations from FATFS context
1027 uint32_t root_dir_cluster = fatfs_ctx->root_dir_cluster;
1028 uint32_t cluster_size = fatfs_ctx->bytes_per_sector *
1029 fatfs_ctx->sectors_per_cluster;
1030 uint32_t total_clusters = fatfs_ctx->fat_sectors_count << 7;
1031
1032 // 4. create VFS root inode in cluster 0
1033 error = vfs_inode_create( XPTR_NULL, // dentry_xp
1034 FS_TYPE_FATFS, // fs_type
1035 INODE_TYPE_DIR, // inode_type
1036 (void *)(intptr_t)root_dir_cluster, // extend
1037 0, // attr
1038 0, // rights
1039 0, // uid
1040 0, // gid
1041 &vfs_root_inode_xp ); // return
1042
1043 assert( (error == 0) ,
1044 "cannot create VFS root inode\n" );
1045
1046 // 5. initialize VFS context for FAT in cluster 0
1047 vfs_ctx_init( FS_TYPE_FATFS, // file system type
1048 0, // attributes
1049 total_clusters,
1050 cluster_size,
1051 vfs_root_inode_xp, // VFS root
1052 fatfs_ctx ); // extend
1053
1054 // 6. check initialisation
1055 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
1056 assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
1057 "illegal value for FATFS context in cluster %x\n", local_cxy );
1058 }
1059 else
1060 {
1061 assert( false ,
1062 "root FS must be FATFS" );
1063 }
1064
1065 // register VFS root inode in process_zero descriptor of cluster 0
1066 process_zero.vfs_root_xp = vfs_root_inode_xp;
1067 process_zero.vfs_cwd_xp = vfs_root_inode_xp;
1068 }
1069
1070 /////////////////////////////////////////////////////////////////////////////////
1071 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
1072 (info->x_size * (info->y_max)) );
1073 barrier_wait( &local_barrier , info->cores_nr );
1074 /////////////////////////////////////////////////////////////////////////////////
1075
1076#if DEBUG_KERNEL_INIT
1077if( (core_lid == 0) & (local_cxy == 0) )
1078printk("\n[DBG] %s : exit barrier 4 : VFS_root = %l in cluster 0 / cycle %d\n",
1079__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
1080#endif
1081
1082 /////////////////////////////////////////////////////////////////////////////////
1083 // STEP 5 : Other CP0s allocate memory for the selected FS context,
1084 // and initialise both the local FS context and the local VFS context
1085 // from values stored in cluster 0.
1086 // They get the VFS root inode extended pointer from cluster 0.
1087 /////////////////////////////////////////////////////////////////////////////////
1088
1089 if( (core_lid == 0) && (local_cxy != 0) )
1090 {
1091 // File System must be FATFS in this implementation,
1092 // but other File System can be introduced here
1093 if( CONFIG_VFS_ROOT_IS_FATFS )
1094 {
1095 // 1. allocate memory for local FATFS context
1096 fatfs_ctx_t * local_fatfs_ctx = fatfs_ctx_alloc();
1097
1098 assert( (local_fatfs_ctx != NULL) ,
1099 "cannot create FATFS context in cluster %x\n", local_cxy );
1100
1101 // 2. get local pointer on VFS context for FATFS
1102 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
1103
1104 // 3. get local pointer on FATFS context in cluster 0
1105 fatfs_ctx_t * remote_fatfs_ctx = hal_remote_lpt( XPTR( 0 , &vfs_ctx->extend ) );
1106
1107 // 4. copy FATFS context from cluster 0 to local cluster
1108 hal_remote_memcpy( XPTR( local_cxy , local_fatfs_ctx ),
1109 XPTR( 0 , remote_fatfs_ctx ), sizeof(fatfs_ctx_t) );
1110
1111 // 5. copy VFS context from cluster 0 to local cluster
1112 hal_remote_memcpy( XPTR( local_cxy , vfs_ctx ),
1113 XPTR( 0 , vfs_ctx ), sizeof(vfs_ctx_t) );
1114
1115 // 6. update extend field in local copy of VFS context
1116 vfs_ctx->extend = local_fatfs_ctx;
1117
1118 // 7. check initialisation
1119 assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
1120 "illegal value for FATFS context in cluster %x\n", local_cxy );
1121 }
1122
1123 // get extended pointer on VFS root inode from cluster 0
1124 vfs_root_inode_xp = hal_remote_lwd( XPTR( 0 , &process_zero.vfs_root_xp ) );
1125
1126 // update local process_zero descriptor
1127 process_zero.vfs_root_xp = vfs_root_inode_xp;
1128 process_zero.vfs_cwd_xp = vfs_root_inode_xp;
1129 }
1130
1131 /////////////////////////////////////////////////////////////////////////////////
1132 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
1133 (info->x_size * (info->y_max)) );
1134 barrier_wait( &local_barrier , info->cores_nr );
1135 /////////////////////////////////////////////////////////////////////////////////
1136
1137#if DEBUG_KERNEL_INIT
1138if( (core_lid == 0) & (local_cxy == 0) )
1139printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
1140__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
1141#endif
1142
1143 /////////////////////////////////////////////////////////////////////////////////
1144 // STEP 6 : CP0 in cluster IO makes the global DEVFS tree initialisation:
1145 // It creates the DEVFS directory "dev", and the DEVFS "external"
1146 // directory in cluster IO and mount these inodes into VFS.
1147 /////////////////////////////////////////////////////////////////////////////////
1148
1149 if( (core_lid == 0) && (local_cxy == 0) ) // [FIXME]
1150 {
1151 // create "dev" and "external" directories.
1152 devfs_global_init( process_zero.vfs_root_xp,
1153 &devfs_dev_inode_xp,
1154 &devfs_external_inode_xp );
1155
1156 // creates the DEVFS context in cluster IO
1157 devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
1158
1159 assert( (devfs_ctx != NULL) ,
1160 "cannot create DEVFS context in cluster IO\n");
1161
1162 // register DEVFS root and external directories
1163 devfs_ctx_init( devfs_ctx, devfs_dev_inode_xp, devfs_external_inode_xp );
1164 }
1165
1166 /////////////////////////////////////////////////////////////////////////////////
1167 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
1168 (info->x_size * (info->y_max)) );
1169 barrier_wait( &local_barrier , info->cores_nr );
1170 /////////////////////////////////////////////////////////////////////////////////
1171
1172#if DEBUG_KERNEL_INIT
1173if( (core_lid == 0) & (local_cxy == 0) )
1174printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
1175__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
1176#endif
1177
1178 /////////////////////////////////////////////////////////////////////////////////
1179 // STEP 7 : All CP0s complete in parallel the DEVFS tree initialization.
1180 // Each CP0 get the "dev" and "external" extended pointers from
1181 // values stored in cluster IO.
1182 // Then each CP0 in cluster(i) creates the DEVFS "internal directory,
1183 // and creates the pseudo-files for all chdevs in cluster (i).
1184 /////////////////////////////////////////////////////////////////////////////////
1185
1186 if( core_lid == 0 )
1187 {
1188 // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
1189 xptr_t extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend ); // [FIXME]
1190
1191 // get pointer on DEVFS context in cluster 0
1192 devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
1193
1194 devfs_dev_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
1195 devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
1196
1197 // populate DEVFS in all clusters
1198 devfs_local_init( devfs_dev_inode_xp,
1199 devfs_external_inode_xp,
1200 &devfs_internal_inode_xp );
1201 }
1202
1203 /////////////////////////////////////////////////////////////////////////////////
1204 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
1205 (info->x_size * (info->y_max)) );
1206 barrier_wait( &local_barrier , info->cores_nr );
1207 /////////////////////////////////////////////////////////////////////////////////
1208
1209#if DEBUG_KERNEL_INIT
1210if( (core_lid == 0) & (local_cxy == 0) )
1211printk("\n[DBG] %s : exit barrier 7 : dev_root = %l in cluster 0 / cycle %d\n",
1212__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
1213#endif
1214
1215 /////////////////////////////////////////////////////////////////////////////////
1216 // STEP 8 : CP0 in cluster 0 creates the first user process (process_init)
1217 /////////////////////////////////////////////////////////////////////////////////
1218
1219 if( (core_lid == 0) && (local_cxy == 0) )
1220 {
1221
1222#if( DEBUG_KERNEL_INIT & 1 )
1223vfs_display( vfs_root_inode_xp );
1224#endif
1225
1226 process_init_create();
1227 }
1228
1229 /////////////////////////////////////////////////////////////////////////////////
1230 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
1231 (info->x_size * (info->y_max)) );
1232 barrier_wait( &local_barrier , info->cores_nr );
1233 /////////////////////////////////////////////////////////////////////////////////
1234
1235#if DEBUG_KERNEL_INIT
1236if( (core_lid == 0) & (local_cxy == 0) )
1237printk("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n",
1238__FUNCTION__ , (uint32_t)hal_get_cycles() );
1239#endif
1240
1241#if (DEBUG_KERNEL_INIT & 1)
1242if( (core_lid == 0) & (local_cxy == 0) )
1243sched_display( 0 );
1244#endif
1245
1246 /////////////////////////////////////////////////////////////////////////////////
1247 // STEP 9 : CP0 in cluster 0 print banner
1248 /////////////////////////////////////////////////////////////////////////////////
1249
1250 if( (core_lid == 0) && (local_cxy == 0) ) // [FIXME]
1251 {
1252 print_banner( (info->x_size * info->y_size) , info->cores_nr );
1253
1254#if( DEBUG_KERNEL_INIT & 1 )
1255printk("\n\n***** memory fooprint for main kernel objects\n\n"
1256 " - thread descriptor : %d bytes\n"
1257 " - process descriptor : %d bytes\n"
1258 " - cluster manager : %d bytes\n"
1259 " - chdev descriptor : %d bytes\n"
1260 " - core descriptor : %d bytes\n"
1261 " - scheduler : %d bytes\n"
1262 " - rpc fifo : %d bytes\n"
1263 " - page descriptor : %d bytes\n"
1264 " - mapper root : %d bytes\n"
1265 " - ppm manager : %d bytes\n"
1266 " - kcm manager : %d bytes\n"
1267 " - khm manager : %d bytes\n"
1268 " - vmm manager : %d bytes\n"
1269 " - gpt root : %d bytes\n"
1270 " - list item : %d bytes\n"
1271 " - xlist item : %d bytes\n"
1272 " - spinlock : %d bytes\n"
1273 " - remote spinlock : %d bytes\n"
1274 " - rwlock : %d bytes\n"
1275 " - remote rwlock : %d bytes\n",
1276 sizeof( thread_t ),
1277 sizeof( process_t ),
1278 sizeof( cluster_t ),
1279 sizeof( chdev_t ),
1280 sizeof( core_t ),
1281 sizeof( scheduler_t ),
1282 sizeof( remote_fifo_t ),
1283 sizeof( page_t ),
1284 sizeof( mapper_t ),
1285 sizeof( ppm_t ),
1286 sizeof( kcm_t ),
1287 sizeof( khm_t ),
1288 sizeof( vmm_t ),
1289 sizeof( gpt_t ),
1290 sizeof( list_entry_t ),
1291 sizeof( xlist_entry_t ),
1292 sizeof( spinlock_t ),
1293 sizeof( remote_spinlock_t ),
1294 sizeof( rwlock_t ),
1295 sizeof( remote_rwlock_t ));
1296#endif
1297
1298 }
1299
1300 // each core activates its private TICK IRQ
1301 dev_pic_enable_timer( CONFIG_SCHED_TICK_MS_PERIOD );
1302
1303#if DEBUG_KERNEL_INIT
1304printk("\n[DBG] %s : thread %x on core[%x,%d] jumps to thread_idle_func() / cycle %d\n",
1305__FUNCTION__ , CURRENT_THREAD , local_cxy , core_lid , (uint32_t)hal_get_cycles() );
1306#endif
1307
1308 // each core jump to thread_idle_func
1309 thread_idle_func();
1310}
1311
Note: See TracBrowser for help on using the repository browser.