source: soft/giet_vm/giet_kernel/kernel_init.c @ 269

Last change on this file since 269 was 263, checked in by alain, 11 years ago

Introducing support for TSAR fixed format cluster index (cluster_xy)
We have now 4 parameters defined in map.xml:

  • X_WIDTH, Y_WIDTH define the fixed format (typically X_WIDTH = 4 / Y_WIDTH = 4)
  • X_SIZE, Y_SIZE define the actual TSAR 2D mesh variable size (from 1 to 16)
  • Property svn:executable set to *
File size: 14.7 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////
2// File     : kernel_init.c
3// Date     : 26/05/2012
4// Authors  : alain greiner & mohamed karaoui
5// Copyright (c) UPMC-LIP6
6////////////////////////////////////////////////////////////////////////////////////
7// The kernel_init.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 file contains the _kernel_init() function, that performs the second
17// phase of system initialisation.  The three significant actions are:
18// 1) processor 0 makes peripherals and system FAT initialisation.
19// 2) processor 0 awake all other processors by an IPI.
20// 3) all processors running in parallel perform register initialisation,
21//    from their private scheduler, and jump to user code.
22////////////////////////////////////////////////////////////////////////////////////
23
24#include <giet_config.h>
25
26// kernel libraries
27#include <utils.h>
28#include <fat32.h>
29
30//for peripheral initialisation
31#include <dma_driver.h>
32#include <fbf_driver.h>
33#include <tty_driver.h>
34#include <icu_driver.h>
35#include <xcu_driver.h>
36#include <ioc_driver.h>
37#include <mmc_driver.h>
38#include <mwr_driver.h>
39#include <nic_driver.h>
40#include <tim_driver.h>
41
42#include <ctx_handler.h>
43#include <irq_handler.h>
44
45#include <mapping_info.h>
46#include <mips32_registers.h>
47
48///////////////////////////////////////////////////////////////////////////////////
49// array of pointers on the page tables (virtual addresses)
50///////////////////////////////////////////////////////////////////////////////////
51
52__attribute__((section (".kdata"))) 
53unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];    // virtual addresses
54
55__attribute__((section (".kdata")))       
56unsigned int _ptabs_ptprs[GIET_NB_VSPACE_MAX];    // physical addresses >> 13
57
58///////////////////////////////////////////////////////////////////////////////////
59// array of pointers on the schedulers (physical addresses)
60///////////////////////////////////////////////////////////////////////////////////
61
62__attribute__((section (".kdata"))) 
63static_scheduler_t* _schedulers[X_SIZE*Y_SIZE * NB_PROCS_MAX];   // virtual addresses
64
65////////////////////////////////////////////////////////////////////////////////////
66// staks for the "idle" tasks (256 bytes for each processor)
67////////////////////////////////////////////////////////////////////////////////////
68
69__attribute__((section (".kdata"))) 
70unsigned int _idle_stack[X_SIZE*Y_SIZE * NB_PROCS_MAX * 128]; 
71
72////////////////////////////////////////////////////////////////////////////////////
73// This function is the entry point in kernel for all processors.
74// It is executed in parallel by all procesors, and completes the system
75// initialisation that has been started by processor 0 in the boot_init() function.
76//
77// This kernel code makes the following assuptions, regarding the work bone
78// by the boot code:
79//
80// 1) The page tables associated to the various vspaces have been build
81//    in physical memory, and can be used by the kernel code.
82//
83// 2) All schedulers (this include all task contexts) have been initialised,
84//    Both the virtual and the physical base addresses of the page tables
85//    are available in the CTX_PTAB and CTX_PTPR slots.
86//
87// 3) The CP0_SCHED register of each processor contains a pointer on its
88//    private scheduler (virtual address).
89//
90// 4) The CP2_PTPR register of each processor contains a pointer on
91//    the vspace_0 page table (physical address>>13).
92//
93// 5) For all processors, the MMU is activated (CP2_MODE contains 0xF).
94//
95// This code must be loaded in .kinit section, in order to control seg_kinit_base,
96// as this address is used by the boot code to jump into kernel code.
97////////////////////////////////////////////////////////////////////////////////////
98// Each processor performs the following actions:
99// 1/ contribute to _schedulers_paddr[] array initialisation.
100// 2/ contribute to _ptabs_paddr[] and _ptabs_vaddr arrays initialisation
101// 3/ compute and set the ICU mask for its private ICU channel
102// 4/ initialise its private TICK timer (if tasks > 0)
103// 5/ initialise the "idle" task context in its private scheduler
104// 6/ initialise the SP, SR, PTPR, EPC registers
105// 7/ jump to the user code with an eret.
106////////////////////////////////////////////////////////////////////////////////////
107__attribute__((section (".kinit"))) void kernel_parallel_init() 
108{
109    unsigned int global_pid = _get_procid();
110    unsigned int cluster_xy = global_pid / NB_PROCS_MAX;
111    unsigned int local_pid  = global_pid % NB_PROCS_MAX;
112
113#if 0
114////////////// Debug : we can kill all processors but one
115if ( global_pid != 0 )
116{
117    _tty_get_lock( 0 );
118    _puts("\n[GIET] Processor[");
119    _putd( cluster_xy >> Y_WIDTH );
120    _puts(",");
121    _putd( cluster_xy & ((1<<Y_WIDTH)-1) );
122    _puts(",");
123    _putd( local_pid );
124    _puts("] suicide...\n");
125    _tty_release_lock( 0 );
126    _exit();
127}
128#endif
129
130    // Step 1 : each processor get its scheduler virtual address
131    //          and contribute to initialise the _schedulers[] array
132
133    static_scheduler_t* psched     = (static_scheduler_t*)_get_sched();
134    unsigned int        tasks      = psched->tasks;
135
136    _schedulers[global_pid] = psched;
137
138#if GIET_DEBUG_INIT
139_tty_get_lock( 0 );
140_puts("\n[GIET DEBUG] Parallel init : step 1 for processor[");
141_putd( cluster_xy >> Y_WIDTH );
142_puts(",");
143_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
144_puts(",");
145_putd( local_pid );
146_puts("]\n - scheduler vbase = ");
147_putx((unsigned int) psched);
148_puts("\n - tasks           = ");
149_putd(tasks);
150_puts("\n");
151_tty_release_lock( 0 );
152#endif
153
154    // step 2 : each processor that is allocated at least one task
155    //          completes its private scheduler initialisation, and
156    //          contribute to _ptabs_vaddr[] and _ptabs_ptprs[] arrays initialisation.
157    //          - set the CTX_RA slot vith the virtual address
158    //            of the _ctx_eret() function (for context switch).
159    //          - set the CTX_EPC slot that must contain the task
160    //            entry point, and contain only the address of the
161    //            memory location containing this entry point.
162
163    unsigned int ltid;
164
165    // loop on all allocated tasks
166    for (ltid = 0; ltid < tasks; ltid++) 
167    {
168        unsigned int vsid = _get_task_slot( global_pid, ltid , CTX_VSID_ID ); 
169        unsigned int ptab = _get_task_slot( global_pid, ltid , CTX_PTAB_ID ); 
170        unsigned int ptpr = _get_task_slot( global_pid, ltid , CTX_PTPR_ID ); 
171
172        _ptabs_vaddr[vsid] = ptab;
173        _ptabs_ptprs[vsid] = ptpr;
174
175        unsigned int ctx_ra = (unsigned int)(&_ctx_eret);
176        _set_task_slot( global_pid, ltid, CTX_RA_ID, ctx_ra );
177
178        unsigned int* ptr = (unsigned int*)_get_task_slot( global_pid, ltid, CTX_EPC_ID );
179        _set_task_slot( global_pid, ltid, CTX_EPC_ID, *ptr );
180
181#if GIET_DEBUG_INIT
182_tty_get_lock( 0 );
183_puts("\n[GIET DEBUG] Parallel init : step 2 for processor[");
184_putd( cluster_xy >> Y_WIDTH );
185_puts(",");
186_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
187_puts(",");
188_putd( local_pid );
189_puts("] / task ");
190_putd( ltid );
191_puts("\n - ctx_vsid  = ");
192_putd( _get_task_slot( global_pid, ltid, CTX_VSID_ID ) );
193_puts("\n - ctx_ptpr  = ");
194_putx( _get_task_slot( global_pid, ltid, CTX_PTPR_ID ) );
195_puts("\n - ctx_ptab  = ");
196_putx( _get_task_slot( global_pid, ltid, CTX_PTAB_ID ) );
197_puts("\n - ctx_ltid  = ");
198_putd( _get_task_slot( global_pid, ltid, CTX_LTID_ID ) );
199_puts("\n - ctx_epc   = ");
200_putx( _get_task_slot( global_pid, ltid, CTX_EPC_ID ) );
201_puts("\n - ctx_ra    = ");
202_putx( _get_task_slot( global_pid, ltid, CTX_RA_ID ) );
203_puts("\n - ctx_gtid  = ");
204_putd( _get_task_slot( global_pid, ltid, CTX_GTID_ID ) );
205_puts("\n - ctx_tty   = ");
206_putd( _get_task_slot( global_pid, ltid, CTX_TTY_ID ) );
207_puts("\n");
208_tty_release_lock( 0 );
209#endif
210
211    }
212
213    // step 3 : compute and set ICU or XICU masks
214    //          there is at most 32 interrupts per processor
215
216    unsigned int isr_switch_index = 0xFFFFFFFF;
217    unsigned int irq_id;            // IN_IRQ index
218    unsigned int hwi_mask = 0;
219    unsigned int swi_mask = 0;
220    unsigned int pti_mask = 0;
221
222    for (irq_id = 0; irq_id < 32; irq_id++) 
223    {
224        unsigned int entry = psched->interrupt_vector[irq_id];
225        unsigned int isr   = (entry & 0x000000FF);
226        unsigned int type  = (entry & 0x0000FF00) >> 8;
227        unsigned int valid = (entry & 0x80000000);
228
229        if      ((type == IRQ_TYPE_HWI) && valid ) hwi_mask = hwi_mask | (1<<irq_id);
230        else if ((type == IRQ_TYPE_SWI) && valid ) swi_mask = swi_mask | (1<<irq_id);
231        else if ((type == IRQ_TYPE_PTI) && valid ) pti_mask = pti_mask | (1<<irq_id);
232        else if ( valid )
233        {
234            _puts("\n[GIET ERROR] _kernel_parallel_start() : illegal IRQ type\n");
235            _puts(" irq_id = ");
236            _putx( irq_id );
237            _puts(" / entry = ");
238            _putx( entry );
239            _puts("\n");
240            _exit();
241        }
242        if (isr == ISR_SWITCH) isr_switch_index = irq_id;
243    }
244
245#if GIET_DEBUG_INIT
246_tty_get_lock( 0 );
247_puts("\n[GIET DEBUG] Parallel init : step 3 for processor[");
248_putd( cluster_xy >> Y_WIDTH );
249_puts(",");
250_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
251_puts(",");
252_putd( local_pid );
253_puts("]\n - ICU HWI_MASK = ");
254_putx(hwi_mask);
255_puts("\n - ICU SWI_MASK = ");
256_putx(swi_mask);
257_puts("\n - ICU PTI_MASK = ");
258_putx(pti_mask);
259_puts("\n");
260_tty_release_lock( 0 );
261#endif
262
263    // GIET-VM consraint : only one IRQ type per irq_id
264    if ( hwi_mask & swi_mask & pti_mask )
265    {
266        _puts("[GIET ERROR] _kernel_parallel_start : conflicting IRQs\n");
267        _exit();
268    }
269
270#if USE_XICU
271    _xcu_set_mask(cluster_xy, local_pid, hwi_mask, IRQ_TYPE_HWI); // set HWI_MASK
272    _xcu_set_mask(cluster_xy, local_pid, swi_mask, IRQ_TYPE_SWI); // set SWI_MASK
273    _xcu_set_mask(cluster_xy, local_pid, pti_mask, IRQ_TYPE_PTI); // set PTI_MASK
274#else
275    _icu_set_mask(cluster_xy, local_pid, (hwi_mask | pti_mask | swi_mask) );   
276#endif
277
278    // step 4 : start TICK timer if at least one task
279    if (tasks > 0) 
280    {
281        // one ISR_SWITCH must be defined for each proc
282        if (isr_switch_index == 0xFFFFFFFF) 
283        {
284            _tty_get_lock( 0 );
285            _puts("\n[GIET ERROR] ISR_SWITCH not found for processor ");
286            _putx(global_pid);
287            _puts("\n");
288            _tty_release_lock( 0 );
289            _exit();
290        }
291
292        // start system timer
293        unsigned int ko;
294#if USE_XICU
295        ko = _xcu_timer_start( cluster_xy, local_pid, GIET_TICK_VALUE ); 
296#else
297        ko = _timer_start( cluster_xy, local_pid, GIET_TICK_VALUE ); 
298#endif
299        if ( ko )
300        {
301            _tty_get_lock( 0 );
302            _puts("\n[GIET ERROR] cannot start timer for processor ");
303            _putd(local_pid);
304            _puts("\n");
305            _tty_release_lock( 0 );
306            _exit();
307        }
308    } 
309
310#if GIET_DEBUG_INIT
311_tty_get_lock( 0 );
312_puts("\n[GIET DEBUG] Parallel init : step 4 for processor[");
313_putd( cluster_xy >> Y_WIDTH );
314_puts(",");
315_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
316_puts(",");
317_putd( local_pid );
318_puts("]");
319if ( tasks > 1 ) _puts("\n  context switch activated\n");
320else             _puts("\n  context switch  not activated\n");
321_tty_release_lock( 0 );
322#endif
323
324    // step 5 : each processor updates the idle_task context:
325    //          (only CTX_SP, CTX_RA, CTX_EPC).
326    //          The stack size is 256 bytes, reserved in seg_kdata.
327    //          The PTPR register, the CTX_PTPR and CTX_PTAB slots
328    //          have been initialised in boot code.
329
330    unsigned int stack = (unsigned int)_idle_stack + ((global_pid + 1)<<9);
331
332    _set_task_slot( global_pid, IDLE_TASK_INDEX, CTX_SP_ID,  stack);
333    _set_task_slot( global_pid, IDLE_TASK_INDEX, CTX_RA_ID,  (unsigned int) &_ctx_eret);
334    _set_task_slot( global_pid, IDLE_TASK_INDEX, CTX_EPC_ID, (unsigned int) &_idle_task);
335
336#if GIET_DEBUG_INIT
337_tty_get_lock( 0 );
338_puts("\n[GIET DEBUG] Parallel init : step 5 for processor[");
339_putd( cluster_xy >> Y_WIDTH );
340_puts(",");
341_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
342_puts(",");
343_putd( local_pid );
344_puts("] : idle task context set\n");
345_tty_release_lock( 0 );
346#endif
347
348    // step 6 : each processor initialises SP, SR, PTPR, EPC, registers
349    //          with the values corresponding to the first allocated task,
350    //          or to the idle_task if there is no task allocated.
351
352    ltid = 0;
353
354    if (tasks == 0) 
355    {
356        ltid = IDLE_TASK_INDEX;
357
358        _tty_get_lock( 0 );
359        _puts("\n[GIET WARNING] No task allocated to processor ");
360        _putx(global_pid);
361        _puts(" => idle\n");
362        _tty_release_lock ( 0 );
363    }
364
365    unsigned int sp_value   = _get_task_slot(global_pid, ltid, CTX_SP_ID);
366    unsigned int sr_value   = _get_task_slot(global_pid, ltid, CTX_SR_ID);
367    unsigned int ptpr_value = _get_task_slot(global_pid, ltid, CTX_PTPR_ID);
368    unsigned int epc_value  = _get_task_slot(global_pid, ltid, CTX_EPC_ID);
369
370#if GIET_DEBUG_INIT
371_tty_get_lock( 0 );
372_puts("\n[GIET DEBUG] Parallel init : step 6 for processor[");
373_putd( cluster_xy >> Y_WIDTH );
374_puts(",");
375_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
376_puts(",");
377_putd( local_pid );
378_puts("]\n - sp   = ");
379_putx(sp_value);
380_puts("\n - sr   = ");
381_putx(sr_value);
382_puts("\n - ptpr = ");
383_putx(ptpr_value);
384_puts("\n - epc  = ");
385_putx(epc_value);
386_puts("\n");
387_tty_release_lock( 0 );
388#endif
389
390_tty_get_lock( 0 );
391_puts("\n[GIET] Processor[");
392_putd( cluster_xy >> Y_WIDTH );
393_puts(",");
394_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
395_puts(",");
396_putd( local_pid );
397_puts("] completes kernel init at cycle ");
398_putd( _get_proctime() );
399_puts(" / task_entry_point = ");
400_putx( epc_value );
401_puts("\n");
402_tty_release_lock( 0 );
403
404    // Step 7 : set  registers and jump to user code
405    asm volatile (
406            "move    $29,       %0    \n"        /* SP <= ctx[CTX_SP_ID] */
407            "mtc0    %1,        $12   \n"        /* SR <= ctx[CTX_SR_ID] */
408            "mtc2    %2,        $0    \n"        /* PTPR <= ctx[CTX_PTPR_ID] */
409            "mtc0    %3,        $14   \n"        /* EPC <= ctx[CTX_EPC_ID] */
410            "eret                     \n"        /* jump to user code */
411            "nop                      \n"
412            :
413            : "r" (sp_value), "r" (sr_value), "r" (ptpr_value), "r" (epc_value));
414
415} // end kernel_parallel_init()
416
417
418// Local Variables:
419// tab-width: 4
420// c-basic-offset: 4
421// c-file-offsets:((innamespace . 0)(inline-open . 0))
422// indent-tabs-mode: nil
423// End:
424// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
425
Note: See TracBrowser for help on using the repository browser.