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

Last change on this file since 438 was 428, checked in by alain, 10 years ago

Introducing fixed format (X_WIDTH / Y_WIDTH / P_WIDTH) for processor index.
  • Property svn:executable set to *
File size: 13.9 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 [x,y,lpid],
14// and where there is one physical memory bank per cluster.
15//
16// The kernel_init() function is executed sequencially by all procesors.
17// It completes the system initialisation that has been started by processor[0,0,0]
18// in the boot_init() function. It makes the following assuptions, regarding the work
19// bone by the boot code:
20//
21// 1) The page tables associated to the various vspaces have been build
22//    in physical memory, and can be used by the kernel code.
23//
24// 2) All schedulers (this include all task contexts) have been initialised,
25//    Both the virtual and the physical base addresses of the page tables
26//    are available in the CTX_PTAB and CTX_PTPR slots.
27//
28// 3) The CP0_SCHED register of each processor contains a pointer on its
29//    private scheduler (virtual address).
30//
31// 4) The CP2_PTPR register of each processor contains a pointer on
32//    the vspace_0 page table (physical address>>13).
33//
34// 5) For all processors, the MMU is activated (CP2_MODE contains 0xF).
35//
36// This code must be loaded in .kinit section, in order to control seg_kinit_base,
37// as this address is used by the boot code to jump into kernel code.
38//
39// Each processor performs the following actions:
40// 1/ contribute to _schedulers_paddr[] array initialisation.
41// 2/ contribute to _ptabs_paddr[] and _ptabs_vaddr arrays initialisation
42// 3/ completes task context initialisation for ech allocated task
43// 4/ compute and set the ICU mask for its private ICU channel
44// 5/ initialise its private TICK timer (if tasks > 0)
45// 6/ initialise the "idle" task context in its private scheduler
46// 7/ initialise SP, SR, PTPR, EPC registers and jump to user code with an eret.
47////////////////////////////////////////////////////////////////////////////////////
48
49#include <giet_config.h>
50
51// kernel libraries
52#include <utils.h>
53#include <fat32.h>
54
55//for peripheral initialisation
56#include <dma_driver.h>
57#include <fbf_driver.h>
58#include <tty_driver.h>
59#include <icu_driver.h>
60#include <xcu_driver.h>
61#include <ioc_driver.h>
62#include <mmc_driver.h>
63#include <mwr_driver.h>
64#include <nic_driver.h>
65#include <tim_driver.h>
66
67#include <ctx_handler.h>
68#include <irq_handler.h>
69
70#include <mapping_info.h>
71#include <mips32_registers.h>
72
73#if !defined(X_SIZE)
74# error: You must define X_SIZE in the hard_config.h file
75#endif
76
77#if !defined(Y_SIZE)
78# error: You must define Y_SIZE in the hard_config.h file
79#endif
80
81#if !defined(Y_WIDTH)
82# error: You must define Y_WIDTH in the hard_config.h file
83#endif
84
85#if !defined(Y_WIDTH)
86# error: You must define Y_WIDTH in the hard_config.h file
87#endif
88
89#if !defined(NB_PROCS_MAX)
90# error: You must define NB_PROCS_MAX in the hard_config.h file
91#endif
92
93#if !defined(NB_TOTAL_PROCS)
94# error: You must define NB_TOTAL_PROCS in the hard_config.h file
95#endif
96
97#if !defined(USE_XCU)
98# error: You must define USE_XCU in the hard_config.h file
99#endif
100
101#if !defined(IDLE_TASK_INDEX)
102# error: You must define IDLE_TASK_INDEX in the ctx_handler.h file
103#endif
104
105#if !defined(GIET_TICK_VALUE)
106# error: You must define GIET_TICK_VALUE in the giet_config.h file
107#endif
108
109#if !defined(GIET_NB_VSPACE_MAX)
110# error: You must define GIET_NB_VSPACE_MAX in the giet_config.h file
111#endif
112
113///////////////////////////////////////////////////////////////////////////////////
114// FAT internal representation for kernel code
115///////////////////////////////////////////////////////////////////////////////////
116
117__attribute__((section (".kdata"))) 
118fat32_fs_t fat __attribute__((aligned(512)));
119
120///////////////////////////////////////////////////////////////////////////////////
121// array of pointers on the page tables (virtual addresses)
122///////////////////////////////////////////////////////////////////////////////////
123
124__attribute__((section (".kdata"))) 
125volatile unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];    // virtual addresses
126
127__attribute__((section (".kdata")))       
128volatile unsigned int _ptabs_ptprs[GIET_NB_VSPACE_MAX];    // physical addresses >> 13
129
130///////////////////////////////////////////////////////////////////////////////////
131// array of pointers on the schedulers (physical addresses)
132///////////////////////////////////////////////////////////////////////////////////
133
134__attribute__((section (".kdata"))) 
135volatile static_scheduler_t* _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX]; 
136
137////////////////////////////////////////////////////////////////////////////////////
138// Synchonisation barrier before jumping to user code
139////////////////////////////////////////////////////////////////////////////////////
140
141__attribute__((section (".kdata"))) 
142volatile unsigned int kernel_init_barrier = 0;
143
144///////////////////////////////////////////////////////////////////////////////////
145__attribute__((section (".kinit"))) void kernel_init() 
146{
147    // gpid : hardware processor index (fixed format: X_WIDTH|Y_WIDTH|P_WIDTH)
148    // lpid : local processor id in a cluster ( lpid < NB_PROCS_MAX)
149    // cpid : "continuous" processor index = (((x * Y_SIZE + y) * NB_PROCS_MAX) + p
150
151    unsigned int gpid       = _get_procid();
152    unsigned int cluster_xy = gpid >> P_WIDTH;
153    unsigned int x          = cluster_xy >> Y_WIDTH & ((1<<X_WIDTH)-1);
154    unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
155    unsigned int lpid       = gpid & ((1<<P_WIDTH)-1);
156    unsigned int cpid       = ((( x * Y_SIZE) + y) * NB_PROCS_MAX) + lpid;
157
158
159    // This initialisation is done sequencially by each processor
160    while( cpid != kernel_init_barrier ) asm volatile ( "nop" );
161
162    // Step 1 : each processor get its scheduler virtual address from CP0 register
163    //          and contribute to initialise the _schedulers[] array
164
165    static_scheduler_t* psched     = (static_scheduler_t*)_get_sched();
166    unsigned int        tasks      = psched->tasks;
167
168    _schedulers[x][y][lpid] = psched;
169
170#if GIET_DEBUG_INIT
171_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] starts kernel init\n"
172        " - scheduler vbase = %x\n"
173        " - tasks           = %d\n",
174        x, y, lpid, (unsigned int)psched, tasks );
175#endif
176
177    // step 2 : each processor that is allocated at least one task loops
178    //          on all allocated tasks:
179    //          - contributes to _ptabs_vaddr[] & _ptabs_ptprs[] initialisation.
180    //          - set CTX_RA slot  with the kernel _ctx_eret() virtual address.
181    //          - set CTX_EPC slot that must contain the task entry point,
182    //            and contain only at this point the virtual address of the memory
183    //            location containing this entry point. We must switch the PTPR
184    //            to use the page table corresponding to the task.
185
186    unsigned int ltid;
187
188    for (ltid = 0; ltid < tasks; ltid++) 
189    {
190        unsigned int vsid = _get_task_slot( x, y, lpid, ltid , CTX_VSID_ID ); 
191        unsigned int ptab = _get_task_slot( x, y, lpid, ltid , CTX_PTAB_ID ); 
192        unsigned int ptpr = _get_task_slot( x, y, lpid, ltid , CTX_PTPR_ID ); 
193
194        // initialize PTABS arrays
195        _ptabs_vaddr[vsid] = ptab;
196        _ptabs_ptprs[vsid] = ptpr;
197
198#if GIET_DEBUG_INIT
199_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] contributes to PTABS arrays\n"
200        " - ptabs_vaddr[%d] = %x / ptpr_paddr[%d] = %l\n",
201        x, y, lpid, 
202        vsid, ptab, vsid, ((unsigned long long)ptpr)<<13 );
203#endif
204
205        // set the ptpr to use the task page table
206        asm volatile( "mtc2    %0,   $0   \n"
207                      : : "r" (ptpr) );
208
209        // compute ctx_ra
210        unsigned int ctx_ra = (unsigned int)(&_ctx_eret);
211        _set_task_slot( x, y, lpid, ltid, CTX_RA_ID, ctx_ra );
212
213        // compute ctx_epc
214        unsigned int* ptr = (unsigned int*)_get_task_slot( x, y, lpid, ltid, CTX_EPC_ID );
215        _set_task_slot( x, y, lpid, ltid, CTX_EPC_ID, *ptr );
216
217#if GIET_DEBUG_INIT
218_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] updates context for task %d\n"
219        " - ctx_epc   = %x\n"
220        " - ctx_ra    = %x\n",
221        x, y, lpid, ltid,
222        _get_task_slot( x, y, lpid, ltid, CTX_EPC_ID ),
223        _get_task_slot( x, y, lpid, ltid, CTX_RA_ID ) );
224#endif
225
226    }  // end for tasks
227
228    // step 4 : compute and set ICU or XCU masks
229
230    unsigned int isr_switch_index = 0xFFFFFFFF;
231    unsigned int hwi_mask = 0;
232    unsigned int pti_mask = 0;
233    unsigned int wti_mask = 0;
234    unsigned int irq_id;            // IN_IRQ index
235    unsigned int entry;             // interrupt vector entry
236
237    for (irq_id = 0; irq_id < 32; irq_id++) 
238    {
239        entry = psched->hwi_vector[irq_id];
240        if ( entry & 0x80000000 ) hwi_mask = hwi_mask | (1<<irq_id);
241        if ( (entry & 0x0000FFFF) == ISR_TICK ) isr_switch_index = irq_id;
242
243        entry = psched->pti_vector[irq_id];
244        if ( entry & 0x80000000 ) pti_mask = pti_mask | (1<<irq_id);
245        if ( (entry & 0x0000FFFF) == ISR_TICK ) isr_switch_index = irq_id;
246
247        entry = psched->wti_vector[irq_id];
248        if ( entry & 0x80000000 ) wti_mask = wti_mask | (1<<irq_id);
249        if ( (entry & 0x0000FFFF) == ISR_TICK ) isr_switch_index = irq_id;
250    }
251
252#if GIET_DEBUG_INIT
253_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] sets XCU masks\n"
254        " - ICU HWI_MASK = %x\n"
255        " - ICU WTI_MASK = %x\n"
256        " - ICU PTI_MASK = %x\n",
257        x, y, lpid, hwi_mask, wti_mask, pti_mask );
258#endif
259
260    unsigned int channel = lpid * IRQ_PER_PROCESSOR; 
261
262#if USE_XCU
263    _xcu_set_mask( cluster_xy, channel, hwi_mask, IRQ_TYPE_HWI ); 
264    _xcu_set_mask( cluster_xy, channel, wti_mask, IRQ_TYPE_WTI );
265    _xcu_set_mask( cluster_xy, channel, pti_mask, IRQ_TYPE_PTI );
266#else
267    _icu_set_mask( cluster_xy, channel, hwi_mask );   
268#endif
269
270    // step 5 : start TICK timer if at least one task
271    if (tasks > 0) 
272    {
273        // one ISR_TICK must be defined for each proc
274        if (isr_switch_index == 0xFFFFFFFF) 
275        {
276            _printf("\n[GIET ERROR] ISR_TICK not found for processor[%d,%d,%d]\n",
277                    x, y, lpid );
278            _exit();
279        }
280
281        // start system timer
282
283#if USE_XCU
284        _xcu_timer_start( cluster_xy, isr_switch_index, GIET_TICK_VALUE ); 
285#else
286        _timer_start( cluster_xy, isr_switch_index, GIET_TICK_VALUE ); 
287#endif
288
289    }
290
291#if GIET_DEBUG_INIT
292_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] starts TICK timer\n",
293        x, y, lpid );
294#endif
295
296    // step 6 : each processor updates the idle_task context:
297    //          (CTX_SP, CTX_RA, CTX_EPC).
298    //          The 4 Kbytes idle stack is implemented in the scheduler.
299    //          The PTPR register, the CTX_PTPR and CTX_PTAB slots
300    //          have been initialised in boot code.
301
302    unsigned int pstack = ((unsigned int)psched) + 0x2000;
303
304    _set_task_slot( x, y, lpid, IDLE_TASK_INDEX, CTX_SP_ID,  pstack);
305    _set_task_slot( x, y, lpid, IDLE_TASK_INDEX, CTX_RA_ID,  (unsigned int) &_ctx_eret);
306    _set_task_slot( x, y, lpid, IDLE_TASK_INDEX, CTX_EPC_ID, (unsigned int) &_idle_task);
307
308#if GIET_DEBUG_INIT
309_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] initializes IDLE task\n"
310        " - stack_base = %x\n"
311        " - stack_size = 0x1000\n",
312        x, y, lpid, pstack - 0x1000 );
313#endif
314
315    // step 7 : when all processors reach the synchronisation barrier,
316    //          each processor set registers SP, SR, PTPR, EPC,
317    //          with the values corresponding to the first allocated task,
318    //          or to the idle_task if there is no task allocated,
319    //          and jump to user code
320
321    if (tasks == 0) 
322    {
323        ltid = IDLE_TASK_INDEX;
324
325        _printf("\n[GIET WARNING] No task allocated to processor[%d,%d,%d]\n",
326                x, y, lpid );
327    }
328    else
329    {
330        ltid = 0;
331    }
332
333    unsigned int sp_value   = _get_task_slot( x, y, lpid, ltid, CTX_SP_ID);
334    unsigned int sr_value   = _get_task_slot( x, y, lpid, ltid, CTX_SR_ID);
335    unsigned int ptpr_value = _get_task_slot( x, y, lpid, ltid, CTX_PTPR_ID);
336    unsigned int epc_value  = _get_task_slot( x, y, lpid, ltid, CTX_EPC_ID);
337
338#if GIET_DEBUG_INIT
339_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] reach barrier at cycle %d\n",
340        x, y, lpid, _get_proctime() );
341#endif
342
343    // increment barrier counter
344    kernel_init_barrier++;
345
346    // busy waiting until all processors synchronized
347    while ( kernel_init_barrier != NB_TOTAL_PROCS );
348
349#if GIET_DEBUG_INIT
350_printf("\n[GIET DEBUG INIT] Processor[%d,%d,%d] initializes registers at cycle %d\n"
351        " - sp   = %x\n"
352        " - sr   = %x\n"
353        " - ptpr = %x\n"
354        " - epc  = %x\n",
355        x, y, lpid, _get_proctime(),
356        sp_value, sr_value, ptpr_value, epc_value );
357#endif
358
359    // set registers and jump to user code
360    asm volatile ( "move  $29,  %0                  \n"   /* SP <= ctx[CTX_SP_ID] */
361                   "mtc0  %1,   $12                 \n"   /* SR <= ctx[CTX_SR_ID] */
362                   "mtc2  %2,   $0                  \n"   /* PTPR <= ctx[CTX_PTPR] */
363                   "mtc0  %3,   $14                 \n"   /* EPC <= ctx[CTX_EPC]  */
364                   "eret                            \n"   /* jump to user code  */
365                   "nop                             \n"
366                   : 
367                   : "r"(sp_value), "r"(sr_value), "r"(ptpr_value), "r"(epc_value)
368                   : "$29", "memory" );
369
370} // end kernel_init()
371
372
373// Local Variables:
374// tab-width: 4
375// c-basic-offset: 4
376// c-file-offsets:((innamespace . 0)(inline-open . 0))
377// indent-tabs-mode: nil
378// End:
379// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
380
Note: See TracBrowser for help on using the repository browser.