Ignore:
Timestamp:
May 29, 2013, 1:24:09 AM (11 years ago)
Author:
alain
Message:

Major evolution to support physical addresses larger than 32 bits.
The map.xml format has been modified: the vsegs associated to schedulers
are now explicitely defined and mapped in the page tables.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • soft/giet_vm/sys/kernel_init.c

    r228 r238  
    3333
    3434///////////////////////////////////////////////////////////////////////////////////
    35 // array of pointers on the page tables (both virtual and physical addresses)
     35// array of pointers on the page tables (virtual addresses)
    3636///////////////////////////////////////////////////////////////////////////////////
    3737
    3838__attribute__((section (".kdata")))
    39 unsigned int _ptabs_paddr[GIET_NB_VSPACE_MAX];
     39unsigned int _ptabs[GIET_NB_VSPACE_MAX];    // virtual addresses
     40
     41__attribute__((section (".kdata")))       
     42unsigned int _ptprs[GIET_NB_VSPACE_MAX];    // physical addresses >> 13
     43
     44///////////////////////////////////////////////////////////////////////////////////
     45// array of pointers on the schedulers (physical addresses)
     46///////////////////////////////////////////////////////////////////////////////////
    4047
    4148__attribute__((section (".kdata")))
    42 unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];
    43 
    44 ///////////////////////////////////////////////////////////////////////////////////
    45 // array of pointers on the schedulers (physical addresses)
     49static_scheduler_t* _schedulers[NB_CLUSTERS * NB_PROCS_MAX];
     50
     51///////////////////////////////////////////////////////////////////////////////////
     52// staks for the "idle" tasks (256 bytes for each processor)
    4653///////////////////////////////////////////////////////////////////////////////////
    4754
    4855__attribute__((section (".kdata")))
    49 static_scheduler_t * _schedulers_paddr[NB_CLUSTERS * NB_PROCS_MAX];
    50 
    51 ///////////////////////////////////////////////////////////////////////////////////
    52 // staks for the "idle" tasks (256 bytes for each processor)
    53 ///////////////////////////////////////////////////////////////////////////////////
    54 
    55 __attribute__((section (".kdata")))
    56 unsigned int _idle_stack[NB_CLUSTERS*NB_PROCS_MAX * 64];
    57 
    58 void _sys_exit() {
     56unsigned int _idle_stack[NB_CLUSTERS * NB_PROCS_MAX * 64];
     57
     58////////////////
     59void _sys_exit()
     60{
    5961    while (1);
    6062}
     
    6365//////////////////////////////////////////////////////////////////////////////////
    6466// This function is the entry point for the last step of the boot sequence.
     67// that is done in parallel by all processors, with MMU activated.
    6568//////////////////////////////////////////////////////////////////////////////////
    66 __attribute__((section (".kinit"))) void _kernel_init() {
    67     // compute cluster and local processor index
    68     unsigned int global_pid = _procid();
    69     unsigned int cluster_id = global_pid / NB_PROCS_MAX;
    70     unsigned int proc_id = global_pid % NB_PROCS_MAX;
    71 
    72     // Step 0 : Compute number of tasks allocated to proc
    73 
    74     unsigned int tasks = _get_tasks_number();
    75 
    76 #if GIET_DEBUG_INIT
    77     _get_lock(&_tty_put_lock);
    78     _puts("\n[GIET DEBUG] step 0 for processor ");
    79     _putd(global_pid);
    80     _puts(" : tasks = ");
    81     _putd(tasks);
    82     _puts("\n");
    83     _release_lock(&_tty_put_lock);
    84 #endif
    85 
    86     // step 1 : Initialise scheduler physical addresses array
    87     //          get scheduler physical address (from CP0 register)
    88 
    89     static_scheduler_t * psched = (static_scheduler_t *) _get_sched();
    90     _schedulers_paddr[global_pid] = psched;
    91 
    92 #if GIET_DEBUG_INIT
    93     _get_lock(&_tty_put_lock);
    94     _puts("\n[GIET DEBUG] step 1 for processor ");
    95     _putd(global_pid);
    96     _puts(" / scheduler pbase = ");
    97     _putx((unsigned int) psched);
    98     _puts("\n");
    99     _release_lock(&_tty_put_lock);
    100 #endif
    101 
    102     // step 2 : initialise page table addresse arrays
     69__attribute__((section (".kinit"))) void _kernel_init()
     70{
     71    // Step 1 : get processor index,
     72    //          get scheduler address
     73    //          initialise _schedulers[] array
     74
     75    unsigned int        global_pid = _procid();
     76    unsigned int        cluster_id = global_pid / NB_PROCS_MAX;
     77    unsigned int        proc_id    = global_pid % NB_PROCS_MAX;
     78    static_scheduler_t* psched     = _get_sched();
     79    unsigned int        tasks      = psched->tasks;
     80
     81    _schedulers[global_pid] = psched;
     82
     83#if GIET_DEBUG_INIT
     84_get_lock(&_tty_put_lock);
     85_puts("\n[GIET DEBUG] step 1 for processor ");
     86_putd(global_pid);
     87_puts(" : tasks = ");
     88_putd(tasks);
     89_puts(" / scheduler vbase = ");
     90_putx((unsigned int) psched);
     91_puts("\n");
     92_release_lock(&_tty_put_lock);
     93#endif
     94
     95    // step 2 : initialise ptabs[] & ptprs[] arrays
    10396    //          each processor scans all tasks contexts in its
    10497    //          private scheduler and get VSID, PTAB and PTPR values
     
    10699    unsigned int ltid;
    107100
    108     for (ltid = 0; ltid < tasks; ltid++) {
    109         unsigned int vspace_id = _get_context_slot(ltid , CTX_VSID_ID);
    110         unsigned int ptab_vaddr = _get_context_slot(ltid , CTX_PTAB_ID);
    111         unsigned int ptab_paddr = _get_context_slot(ltid , CTX_PTPR_ID) << 13;
    112 
    113         _ptabs_vaddr[vspace_id] = ptab_vaddr;
    114         _ptabs_paddr[vspace_id] = ptab_paddr;
    115 
    116 #if GIET_DEBUG_INIT
    117         _get_lock(&_tty_put_lock);
    118         _puts("\n[GIET DEBUG] step 2 for processor ");
    119         _putd(global_pid);
    120         _puts(" / vspace ");
    121         _putd(vspace_id);
    122         _puts("\n- ptab vbase = ");
    123         _putx(ptab_vaddr);
    124         _puts("\n- ptab pbase = ");
    125         _putx(ptab_paddr);
    126         _puts("\n");
    127         _release_lock(&_tty_put_lock);
     101    for (ltid = 0; ltid < tasks; ltid++)
     102    {
     103        unsigned int vsid  = _get_task_slot(ltid , CTX_VSID_ID);
     104        unsigned int ptab  = _get_task_slot(ltid , CTX_PTAB_ID);
     105        unsigned int ptpr  = _get_task_slot(ltid , CTX_PTPR_ID);
     106
     107        _ptabs[vsid] = ptab;
     108        _ptprs[vsid] = ptpr;
     109
     110#if GIET_DEBUG_INIT
     111_get_lock(&_tty_put_lock);
     112_puts("\n[GIET DEBUG] step 2 for processor ");
     113_putd(global_pid);
     114_puts(" / vspace ");
     115_putd(vsid);
     116_puts("\n- ptab = ");
     117_putx(ptab);
     118_puts("\n- ptpr = ");
     119_putx(ptpr);
     120_puts("\n");
     121_release_lock(&_tty_put_lock);
    128122#endif
    129123
    130124    }
    131 
    132     unsigned int isr_switch_channel = 0xFFFFFFFF;
    133125
    134126    // step 3 : compute and set ICU masks
     
    136128    //          software interrupts are not supported yet
    137129
    138     unsigned int irq_id;
     130    unsigned int isr_switch_channel = 0xFFFFFFFF;
     131    unsigned int irq_id;            // IN_IRQ index
    139132    unsigned int hwi_mask = 0;
    140133    unsigned int pti_mask = 0;
    141134
    142     for (irq_id = 0; irq_id < 32; irq_id++) {
    143         unsigned int entry = _get_interrupt_vector_entry(irq_id);
    144         unsigned int isr = entry & 0x000000FF;
    145 
    146         if ((isr == ISR_DMA) || (isr == ISR_IOC) || (isr == ISR_TTY)) {
     135    for (irq_id = 0; irq_id < 32; irq_id++)
     136    {
     137        unsigned int entry = psched->interrupt_vector[irq_id];
     138        unsigned int isr   = entry & 0x000000FF;
     139
     140        if ((isr == ISR_DMA) || (isr == ISR_IOC) || (isr == ISR_TTY))
     141        {
    147142            hwi_mask = hwi_mask | 0x1 << irq_id;
    148143        }
    149         else if ((isr == ISR_SWITCH)) {
     144        else if ((isr == ISR_SWITCH))
     145        {
    150146            pti_mask = pti_mask | 0x1 << irq_id;
    151147            isr_switch_channel = irq_id;
    152148        }
    153         else if ((isr == ISR_TIMER)) {
     149        else if ((isr == ISR_TIMER))
     150        {
    154151            pti_mask = pti_mask | 0x1 << irq_id;
    155152        }
    156153    }
     154
     155#if GIET_DEBUG_INIT
     156_get_lock(&_tty_put_lock);
     157_puts("\n[GIET DEBUG] step 3 for processor ");
     158_putd(global_pid);
     159_puts("\n - ICU HWI_MASK = ");
     160_putx(hwi_mask);
     161_puts("\n - ICU PTI_MASK = ");
     162_putx(pti_mask);
     163_puts("\n");
     164_release_lock(&_tty_put_lock);
     165#endif
     166
    157167    _icu_set_mask(cluster_id, proc_id, hwi_mask, 0); // set HWI_MASK
    158168    _icu_set_mask(cluster_id, proc_id, pti_mask, 1); // set PTI_MASK
    159169
    160 #if GIET_DEBUG_INIT
    161     _get_lock(&_tty_put_lock);
    162     _puts("\n[GIET DEBUG] step 3 for processor ");
    163     _putd(global_pid);
    164     _puts("\n - ICU HWI_MASK = ");
    165     _putx(hwi_mask);
    166     _puts("\n - ICU PTI_MASK = ");
    167     _putx(pti_mask);
    168     _puts("\n");
    169     _release_lock(&_tty_put_lock);
    170 #endif
    171 
    172170    // step 4 : start TICK timer if more than one task
    173     if (tasks > 1) {
    174         if (isr_switch_channel == 0xFFFFFFFF) {
     171    if (tasks > 1)
     172    {
     173        if (isr_switch_channel == 0xFFFFFFFF)
     174        {
    175175            _get_lock(&_tty_put_lock);
    176176            _puts("\n[GIET ERROR] ISR_SWITCH not found on proc ");
     
    181181        }
    182182
    183         if (_timer_start( cluster_id, isr_switch_channel, GIET_TICK_VALUE)) {
     183        if (_timer_start( cluster_id, isr_switch_channel, GIET_TICK_VALUE))
     184        {
    184185            _get_lock(&_tty_put_lock);
    185186            _puts("\n[GIET ERROR] ISR_SWITCH init error for proc ");
     
    191192
    192193#if GIET_DEBUG_INIT
    193         _get_lock(&_tty_put_lock);
    194         _puts("\n[GIET DEBUG] Step 4 for processor ");
    195         _putd(global_pid);
    196         _puts(" / context switch activated\n");
    197         _release_lock(&_tty_put_lock);
     194_get_lock(&_tty_put_lock);
     195_puts("\n[GIET DEBUG] Step 4 for processor ");
     196_putd(global_pid);
     197_puts(" / context switch activated\n");
     198_release_lock(&_tty_put_lock);
    198199#endif
    199200
     
    206207    //          the stack size is 256 bytes
    207208
    208     _set_context_slot( IDLE_TASK_INDEX, CTX_RUN_ID, 1);
    209     _set_context_slot( IDLE_TASK_INDEX, CTX_SR_ID,  0xFF03);
    210     _set_context_slot( IDLE_TASK_INDEX, CTX_SP_ID,  (unsigned int) _idle_stack + ((global_pid + 1) << 8));
    211     _set_context_slot( IDLE_TASK_INDEX, CTX_RA_ID,  (unsigned int) &_ctx_eret);
    212     _set_context_slot( IDLE_TASK_INDEX, CTX_EPC_ID, (unsigned int) &_ctx_idle);
    213     _set_context_slot( IDLE_TASK_INDEX, CTX_LTID_ID, IDLE_TASK_INDEX);
    214     _set_context_slot( IDLE_TASK_INDEX, CTX_PTPR_ID, _ptabs_paddr[0] >> 13);
    215 
    216 #if GIET_DEBUG_INIT
    217     _get_lock(&_tty_put_lock);
    218     _puts("\n[GIET DEBUG] Step 5 for processor ");
    219     _putd(global_pid);
    220     _puts(" / idle task context set\n");
    221     _release_lock(&_tty_put_lock);
     209    unsigned int stack = (unsigned int)_idle_stack + ((global_pid + 1)<<8);
     210
     211    _set_task_slot( IDLE_TASK_INDEX, CTX_RUN_ID, 1);
     212    _set_task_slot( IDLE_TASK_INDEX, CTX_SR_ID,  0xFF03);
     213    _set_task_slot( IDLE_TASK_INDEX, CTX_SP_ID,  stack);
     214    _set_task_slot( IDLE_TASK_INDEX, CTX_RA_ID,  (unsigned int) &_ctx_eret);
     215    _set_task_slot( IDLE_TASK_INDEX, CTX_EPC_ID, (unsigned int) &_ctx_idle);
     216    _set_task_slot( IDLE_TASK_INDEX, CTX_LTID_ID, IDLE_TASK_INDEX);
     217    _set_task_slot( IDLE_TASK_INDEX, CTX_PTPR_ID, _ptprs[0]);
     218
     219#if GIET_DEBUG_INIT
     220_get_lock(&_tty_put_lock);
     221_puts("\n[GIET DEBUG] Step 5 for processor ");
     222_putd(global_pid);
     223_puts(" / idle task context set\n");
     224_release_lock(&_tty_put_lock);
    222225#endif
    223226
     
    226229    //          and starts the "idle" task if there is no task allocated.
    227230
    228     unsigned int task_id;
    229 
    230     if (tasks == 0) {
    231         task_id = IDLE_TASK_INDEX;
     231    ltid = 0;
     232
     233    if (tasks == 0)
     234    {
     235        ltid = IDLE_TASK_INDEX;
    232236
    233237        _get_lock(&_tty_put_lock);
     
    237241        _release_lock (&_tty_put_lock);
    238242    }
    239     else {
    240         task_id = 0;
    241     }
    242 
    243     unsigned int sp_value = _get_context_slot(task_id, CTX_SP_ID);
    244     unsigned int sr_value = _get_context_slot(task_id, CTX_SR_ID);
    245     unsigned int ptpr_value = _get_context_slot(task_id, CTX_PTPR_ID);
    246     unsigned int epc_value = _get_context_slot(task_id, CTX_EPC_ID);
    247 
    248 #if GIET_DEBUG_INIT
    249     _get_lock(&_tty_put_lock);
    250     _puts("\n[GIET DEBUG] step 6 for processor ");
    251     _putd(global_pid);
    252     _puts(" / registers initialised \n");
    253     _puts("- sp   = ");
    254     _putx(sp_value);
    255     _puts("\n");
    256     _puts("- sr   = ");
    257     _putx(sr_value);
    258     _puts("\n");
    259     _puts("- ptpr = ");
    260     _putx(ptpr_value << 13);
    261     _puts("\n");
    262     _puts("- epc  = ");
    263     _putx(epc_value);
    264     _puts("\n");
    265     _release_lock(&_tty_put_lock);
    266 #endif
     243
     244    unsigned int sp_value   = _get_task_slot(ltid, CTX_SP_ID);
     245    unsigned int sr_value   = _get_task_slot(ltid, CTX_SR_ID);
     246    unsigned int ptpr_value = _get_task_slot(ltid, CTX_PTPR_ID);
     247    unsigned int epc_value  = _get_task_slot(ltid, CTX_EPC_ID);
     248
     249    _set_task_slot( ltid, CTX_LTID_ID, ltid);
     250
     251#if GIET_DEBUG_INIT
     252_get_lock(&_tty_put_lock);
     253_puts("\n[GIET DEBUG] step 6 for processor ");
     254_putd(global_pid);
     255_puts(" / registers initialised \n");
     256_puts("- sp   = ");
     257_putx(sp_value);
     258_puts("\n");
     259_puts("- sr   = ");
     260_putx(sr_value);
     261_puts("\n");
     262_puts("- ptpr = ");
     263_putx(ptpr_value);
     264_puts("\n");
     265_puts("- epc  = ");
     266_putx(epc_value);
     267_puts("\n");
     268_release_lock(&_tty_put_lock);
     269#endif
     270
     271_get_lock(&_tty_put_lock);
     272_puts("\n[GIET] Processor ");
     273_putd( global_pid );
     274_puts(" starting user code at cycle ");
     275_putd( _proctime() );
     276_puts("\n");
     277_release_lock(&_tty_put_lock);
    267278
    268279    // set  registers and jump to user code
Note: See TracChangeset for help on using the changeset viewer.