source: soft/giet_vm/giet_boot/boot.c @ 682

Last change on this file since 682 was 656, checked in by guerin, 9 years ago

always set CTX_EPC in task context initialization

all runnable tasks not scheduled at boot but scheduled later would
jump at a random address, including the idle task.

File size: 76.3 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////
2// File     : boot.c
3// Date     : 01/11/2013
4// Author   : alain greiner
5// Copyright (c) UPMC-LIP6
6///////////////////////////////////////////////////////////////////////////////////
7// The boot.c file contains the bootloader for the GIET-VM static OS. 
8//
9// This code has been written for the MIPS32 processor.
10// The virtual adresses are on 32 bits and use the (unsigned int) type. The
11// physicals addresses can have up to 40 bits, and use type (unsigned long long).
12// It natively supports clusterised shared memory multi-processors architectures,
13// where each processor is identified by a composite index [x,y,p],
14// and where there is one physical memory bank per cluster.
15//
16// The boot.elf file is stored on disk and is loaded into memory by proc[0,0,0],
17// executing the generic preloader (stored in ROM). The boot-loader code itself
18// is executed in parallel by all proc[x,y,0], and performs the following tasks:
19// - load into memory various binary files, from a FAT32 file system.
20// - build the various page tables (one page table per vspace).
21// - initialize the shedulers (one scheduler per processor).
22//
23// 1) The binary files to be loaded are:
24//    - the "map.bin" file contains the hardware architecture description,
25//      the set of user applications that will be mapped on the architecture,
26//      and the mapping directives. The mapping includes the placement of tasks
27//      on processors, and the placement of virtual segments on the physical
28//      segments. It must be stored in the the seg_boot_mapping segment
29//      (at address SEG_BOOT_MAPPING_BASE defined in hard_config.h file).
30//    - the "kernel.elf" file contains the kernel binary code and data.
31//    - the various "application.elf" files.
32//
33// 2) The GIET-VM uses the paged virtual memory to provides two services:
34//    - classical memory protection, when several independant applications compiled
35//      in different virtual spaces are executing on the same hardware platform.
36//    - data placement in NUMA architectures, to control the placement
37//      of the software objects (vsegs) on the physical memory banks (psegs).
38//    The max number of vspaces (GIET_NB_VSPACE_MAX) is a configuration parameter.
39//    The page table are statically build in the boot phase, and they do not
40//    change during execution. For each application, the page tables are replicated
41//    in all clusters.
42//    The GIET_VM uses both small pages (4 Kbytes), and big pages (2 Mbytes).
43//    Each page table (one page table per virtual space) is monolithic, and
44//    contains one PT1 (8 Kbytes) and a variable number of PT2s (4 Kbytes each).
45//    For each vspace, the max number of PT2s is defined by the size of the PTAB
46//    vseg in the mapping.
47//    The PT1 is indexed by the ix1 field (11 bits) of the VPN. An entry is 32 bits.
48//    A PT2 is indexed the ix2 field (9 bits) of the VPN. An entry is 64 bits.
49//    The first word contains the flags, the second word contains the PPN.
50//
51// 3) The Giet-VM implement one private scheduler per processor.
52//    For each application, the tasks are statically allocated to processors
53//    and there is no task migration during execution.
54//    Each sheduler occupies 8K bytes, and contains up to 14 task contexts
55//    The task context [13] is reserved for the "idle" task that does nothing, and
56//    is launched by the scheduler when there is no other runable task.
57///////////////////////////////////////////////////////////////////////////////////
58// Implementation Notes:
59//
60// 1) The cluster_id variable is a linear index in the mapping_info array.
61//    The cluster_xy variable is the tological index = x << Y_WIDTH + y
62//
63// 2) We set the _tty0_boot_mode variable to force the _printf() function to use
64//    the tty0_spin_lock for exclusive access to TTY0.
65///////////////////////////////////////////////////////////////////////////////////
66
67#include <giet_config.h>
68#include <hard_config.h>
69#include <mapping_info.h>
70#include <kernel_malloc.h>
71#include <memspace.h>
72#include <tty_driver.h>
73#include <xcu_driver.h>
74#include <bdv_driver.h>
75#include <hba_driver.h>
76#include <sdc_driver.h>
77#include <cma_driver.h>
78#include <nic_driver.h>
79#include <iob_driver.h>
80#include <pic_driver.h>
81#include <mwr_driver.h>
82#include <dma_driver.h>
83#include <mmc_driver.h>
84#include <ctx_handler.h>
85#include <irq_handler.h>
86#include <vmem.h>
87#include <pmem.h>
88#include <utils.h>
89#include <tty0.h>
90#include <kernel_locks.h>
91#include <kernel_barriers.h>
92#include <elf-types.h>
93#include <fat32.h>
94#include <mips32_registers.h>
95#include <stdarg.h>
96
97#if !defined(X_SIZE)
98# error: The X_SIZE value must be defined in the 'hard_config.h' file !
99#endif
100
101#if !defined(Y_SIZE)
102# error: The Y_SIZE value must be defined in the 'hard_config.h' file !
103#endif
104
105#if !defined(X_WIDTH)
106# error: The X_WIDTH value must be defined in the 'hard_config.h' file !
107#endif
108
109#if !defined(Y_WIDTH)
110# error: The Y_WIDTH value must be defined in the 'hard_config.h' file !
111#endif
112
113#if !defined(SEG_BOOT_MAPPING_BASE)
114# error: The SEG_BOOT_MAPPING_BASE value must be defined in the hard_config.h file !
115#endif
116
117#if !defined(NB_PROCS_MAX)
118# error: The NB_PROCS_MAX value must be defined in the 'hard_config.h' file !
119#endif
120
121#if !defined(GIET_NB_VSPACE_MAX)
122# error: The GIET_NB_VSPACE_MAX value must be defined in the 'giet_config.h' file !
123#endif
124
125#if !defined(GIET_ELF_BUFFER_SIZE)
126# error: The GIET_ELF_BUFFER_SIZE value must be defined in the giet_config.h file !
127#endif
128
129////////////////////////////////////////////////////////////////////////////
130//      Global variables for boot code
131////////////////////////////////////////////////////////////////////////////
132
133// Temporaty buffer used to load one complete .elf file 
134__attribute__((section(".kdata")))
135unsigned char  _boot_elf_buffer[GIET_ELF_BUFFER_SIZE] __attribute__((aligned(64)));
136
137// Physical memory allocators array (one per cluster)
138__attribute__((section(".kdata")))
139pmem_alloc_t  boot_pmem_alloc[X_SIZE][Y_SIZE];
140
141// Schedulers virtual base addresses array (one per processor)
142__attribute__((section(".kdata")))
143static_scheduler_t* _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX];
144
145// Page tables virtual base addresses (one per vspace and per cluster)
146__attribute__((section(".kdata")))
147unsigned int        _ptabs_vaddr[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
148
149// Page tables physical base addresses (one per vspace and per cluster)
150__attribute__((section(".kdata")))
151paddr_t             _ptabs_paddr[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
152
153// Page tables pt2 allocators (one per vspace and per cluster)
154__attribute__((section(".kdata")))
155unsigned int        _ptabs_next_pt2[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
156
157// Page tables max_pt2  (same value for all page tables)
158__attribute__((section(".kdata")))
159unsigned int        _ptabs_max_pt2;
160
161// boot code uses a spin lock to protect TTY0
162__attribute__((section(".kdata")))
163unsigned int        _tty0_boot_mode = 1;
164
165// boot code does not uses a lock to protect HBA command allocator
166__attribute__((section(".kdata")))
167unsigned int        _hba_boot_mode = 1;
168
169__attribute__((section(".kdata")))
170spin_lock_t         _ptabs_spin_lock[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
171
172// barrier used by boot code for parallel execution
173__attribute__((section(".kdata")))
174simple_barrier_t    _barrier_all_clusters;
175
176//////////////////////////////////////////////////////////////////////////////
177//        Extern variables
178//////////////////////////////////////////////////////////////////////////////
179
180// this variable is allocated in the tty0.c file
181extern spin_lock_t  _tty0_spin_lock;
182
183// this variable is allocated in the mmc_driver.c
184extern unsigned int _mmc_boot_mode;
185
186extern void boot_entry();
187
188//////////////////////////////////////////////////////////////////////////////
189// This function registers a new PTE1 in the page table defined
190// by the vspace_id argument, and the (x,y) coordinates.
191// It updates only the first level PT1.
192// As each vseg is mapped by a different processor, the PT1 entry cannot
193// be concurrently accessed, and we don't need to take any lock.
194//////////////////////////////////////////////////////////////////////////////
195void boot_add_pte1( unsigned int vspace_id,
196                    unsigned int x,
197                    unsigned int y,
198                    unsigned int vpn,        // 20 bits right-justified
199                    unsigned int flags,      // 10 bits left-justified
200                    unsigned int ppn )       // 28 bits right-justified
201{
202    // compute index in PT1
203    unsigned int    ix1 = vpn >> 9;         // 11 bits for ix1
204
205    // get page table physical base address
206    paddr_t  pt1_pbase = _ptabs_paddr[vspace_id][x][y];
207
208    if ( pt1_pbase == 0 )
209    {
210        _printf("\n[BOOT ERROR] in boot_add_pte1() : no PTAB in cluster[%d,%d]"
211                    " containing processors\n", x , y );
212        _exit();
213    }
214
215    // compute pte1 : 2 bits V T / 8 bits flags / 3 bits RSVD / 19 bits bppi
216    unsigned int    pte1 = PTE_V |
217                           (flags & 0x3FC00000) |
218                           ((ppn>>9) & 0x0007FFFF);
219
220    // write pte1 in PT1
221    _physical_write( pt1_pbase + 4*ix1, pte1 );
222
223    asm volatile ("sync");
224
225}   // end boot_add_pte1()
226
227//////////////////////////////////////////////////////////////////////////////
228// This function registers a new PTE2 in the page table defined
229// by the vspace_id argument, and the (x,y) coordinates.
230// It updates both the first level PT1 and the second level PT2.
231// As the set of PT2s is implemented as a fixed size array (no dynamic
232// allocation), this function checks a possible overflow of the PT2 array.
233// As a given entry in PT1 can be shared by several vsegs, mapped by
234// different processors, we need to take the lock protecting PTAB[v][x]y].
235//////////////////////////////////////////////////////////////////////////////
236void boot_add_pte2( unsigned int vspace_id,
237                    unsigned int x,
238                    unsigned int y,
239                    unsigned int vpn,        // 20 bits right-justified
240                    unsigned int flags,      // 10 bits left-justified
241                    unsigned int ppn )       // 28 bits right-justified
242{
243    unsigned int ix1;
244    unsigned int ix2;
245    paddr_t      pt2_pbase;     // PT2 physical base address
246    paddr_t      pte2_paddr;    // PTE2 physical address
247    unsigned int pt2_id;        // PT2 index
248    unsigned int ptd;           // PTD : entry in PT1
249
250    ix1 = vpn >> 9;             // 11 bits for ix1
251    ix2 = vpn & 0x1FF;          //  9 bits for ix2
252
253    // get page table physical base address
254    paddr_t      pt1_pbase = _ptabs_paddr[vspace_id][x][y];
255
256    if ( pt1_pbase == 0 )
257    {
258        _printf("\n[BOOT ERROR] in boot_add_pte2() : no PTAB for vspace %d "
259                "in cluster[%d,%d]\n", vspace_id , x , y );
260        _exit();
261    }
262
263    // get lock protecting PTAB[vspace_id][x][y]
264    _spin_lock_acquire( &_ptabs_spin_lock[vspace_id][x][y] );
265
266    // get ptd in PT1
267    ptd = _physical_read( pt1_pbase + 4 * ix1 );
268
269    if ((ptd & PTE_V) == 0)    // undefined PTD: compute PT2 base address,
270                               // and set a new PTD in PT1
271    {
272        // get a new pt2_id
273        pt2_id = _ptabs_next_pt2[vspace_id][x][y];
274        _ptabs_next_pt2[vspace_id][x][y] = pt2_id + 1;
275
276        // check overflow
277        if (pt2_id == _ptabs_max_pt2) 
278        {
279            _printf("\n[BOOT ERROR] in boot_add_pte2() : PTAB[%d,%d,%d]"
280                    " contains not enough PT2s\n", vspace_id, x, y );
281            _exit();
282        }
283
284        pt2_pbase = pt1_pbase + PT1_SIZE + PT2_SIZE * pt2_id;
285        ptd = PTE_V | PTE_T | (unsigned int) (pt2_pbase >> 12);
286
287        // set PTD into PT1
288        _physical_write( pt1_pbase + 4*ix1, ptd);
289    }
290    else                       // valid PTD: compute PT2 base address
291    {
292        pt2_pbase = ((paddr_t)(ptd & 0x0FFFFFFF)) << 12;
293    }
294
295    // set PTE in PT2 : flags & PPN in two 32 bits words
296    pte2_paddr  = pt2_pbase + 8 * ix2;
297    _physical_write(pte2_paddr     , (PTE_V | flags) );
298    _physical_write(pte2_paddr + 4 , ppn );
299
300    // release lock protecting PTAB[vspace_id][x][y]
301    _spin_lock_release( &_ptabs_spin_lock[vspace_id][x][y] );
302
303    asm volatile ("sync");
304
305}   // end boot_add_pte2()
306
307////////////////////////////////////////////////////////////////////////////////////
308// Align the value of paddr or vaddr to the required alignement,
309// defined by alignPow2 == L2(alignement).
310////////////////////////////////////////////////////////////////////////////////////
311paddr_t paddr_align_to( paddr_t paddr, unsigned int alignPow2 ) 
312{
313    paddr_t mask = (1 << alignPow2) - 1;
314    return ((paddr + mask) & ~mask);
315}
316
317unsigned int vaddr_align_to( unsigned int vaddr, unsigned int alignPow2 ) 
318{
319    unsigned int mask = (1 << alignPow2) - 1;
320    return ((vaddr + mask) & ~mask);
321}
322
323/////////////////////////////////////////////////////////////////////////////////////
324// This function map a vseg identified by the vseg pointer.
325//
326// A given vseg can be mapped in a Big Physical Pages (BPP: 2 Mbytes) or in a
327// Small Physical Pages (SPP: 4 Kbytes), depending on the "big" attribute of vseg,
328// with the following rules:
329// - SPP : There is only one vseg in a small physical page, but a single vseg
330//   can cover several contiguous small physical pages.
331// - BPP : It can exist several vsegs in a single big physical page, and a single
332//   vseg can cover several contiguous big physical pages.
333//
334// 1) First step: it computes various vseg attributes and checks
335//    alignment constraints.
336//
337// 2) Second step: it allocates the required number of contiguous physical pages,
338//    computes the physical base address (if the vseg is not identity mapping),
339//    and register it in the vseg pbase field.
340//    Only the vsegs used by the boot code and the peripheral vsegs
341//    can be identity mapping. The first big physical page in cluster[0,0]
342//    is reserved for the boot vsegs.
343//
344// 3) Third step (only for vseg that have the VSEG_TYPE_PTAB): the M page tables
345//    associated to the M vspaces must be packed in the same vseg.
346//    We divide this vseg in M sub-segments, and compute the vbase and pbase
347//    addresses for M page tables, and register these addresses in the _ptabs_paddr
348//    and _ptabs_vaddr arrays.
349// 
350/////////////////////////////////////////////////////////////////////////////////////
351void boot_vseg_map( mapping_vseg_t* vseg,
352                    unsigned int    vspace_id )
353{
354    mapping_header_t*   header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
355    mapping_cluster_t*  cluster = _get_cluster_base(header);
356    mapping_pseg_t*     pseg    = _get_pseg_base(header);
357
358    //////////// First step : compute vseg attributes
359
360    // compute destination cluster pointer & coordinates
361    pseg    = pseg + vseg->psegid;
362    cluster = cluster + pseg->clusterid;
363    unsigned int        x_dest     = cluster->x;
364    unsigned int        y_dest     = cluster->y;
365
366    // compute the "big" vseg attribute
367    unsigned int        big = vseg->big;
368
369    // all vsegs must be aligned on 4Kbytes
370    if ( vseg->vbase & 0x00000FFF ) 
371    {
372        _printf("\n[BOOT ERROR] vseg %s not aligned : vbase = %x\n", 
373                vseg->name, vseg->vbase );
374        _exit();
375    }
376
377    // compute the "is_ram" vseg attribute
378    unsigned int        is_ram;
379    if ( pseg->type == PSEG_TYPE_RAM )  is_ram = 1;
380    else                                is_ram = 0;
381
382    // compute the "is_ptab" attribute
383    unsigned int        is_ptab;
384    if ( vseg->type == VSEG_TYPE_PTAB ) is_ptab = 1;
385    else                                is_ptab = 0;
386
387    // compute actual vspace index
388    unsigned int vsid;
389    if ( vspace_id == 0xFFFFFFFF ) vsid = 0;
390    else                           vsid = vspace_id;
391
392    //////////// Second step : compute ppn and npages 
393    //////////// - if identity mapping :  ppn <= vpn
394    //////////// - if vseg is periph   :  ppn <= pseg.base >> 12
395    //////////// - if vseg is ram      :  ppn <= physical memory allocator
396
397    unsigned int ppn;          // first physical page index (28 bits = |x|y|bppi|sppi|)
398    unsigned int vpn;          // first virtual page index  (20 bits = |ix1|ix2|)
399    unsigned int vpn_max;      // last  virtual page index  (20 bits = |ix1|ix2|)
400
401    vpn     = vseg->vbase >> 12;
402    vpn_max = (vseg->vbase + vseg->length - 1) >> 12;
403
404    // compute npages
405    unsigned int npages;       // number of required (big or small) pages
406    if ( big == 0 ) npages  = vpn_max - vpn + 1;            // number of small pages
407    else            npages  = (vpn_max>>9) - (vpn>>9) + 1;  // number of big pages
408
409    // compute ppn
410    if ( vseg->ident )           // identity mapping
411    {
412        ppn = vpn;
413    }
414    else                         // not identity mapping
415    {
416        if ( is_ram )            // RAM : physical memory allocation required
417        {
418            // compute pointer on physical memory allocator in dest cluster
419            pmem_alloc_t*     palloc = &boot_pmem_alloc[x_dest][y_dest];
420
421            if ( big == 0 )             // SPP : small physical pages
422            {
423                // allocate contiguous small physical pages
424                ppn = _get_small_ppn( palloc, npages );
425            }
426            else                            // BPP : big physical pages
427            {
428 
429                // one big page can be shared by several vsegs
430                // we must chek if BPP already allocated
431                if ( is_ptab )   // It cannot be mapped
432                {
433                    ppn = _get_big_ppn( palloc, npages ); 
434                }
435                else             // It can be mapped
436                {
437                    unsigned int ix1   = vpn >> 9;   // 11 bits
438                    paddr_t      paddr = _ptabs_paddr[vsid][x_dest][y_dest] + (ix1<<2);
439                    unsigned int pte1  = _physical_read( paddr );
440
441                    if ( (pte1 & PTE_V) == 0 )     // BPP not allocated yet
442                    {
443                        // allocate contiguous big physical pages
444                        ppn = _get_big_ppn( palloc, npages );
445                    }
446                    else                           // BPP already allocated
447                    {
448                        // test if new vseg has the same mode bits than
449                        // the other vsegs in the same big page
450                        unsigned int pte1_mode = 0;
451                        if (pte1 & PTE_C) pte1_mode |= C_MODE_MASK;
452                        if (pte1 & PTE_X) pte1_mode |= X_MODE_MASK;
453                        if (pte1 & PTE_W) pte1_mode |= W_MODE_MASK;
454                        if (pte1 & PTE_U) pte1_mode |= U_MODE_MASK;
455                        if (vseg->mode != pte1_mode) 
456                        {
457                            _printf("\n[BOOT ERROR] in boot_vseg_map() : "
458                                    "vseg %s has different flags than another vseg "
459                                    "in the same BPP\n", vseg->name );
460                            _exit();
461                        }
462                        ppn = ((pte1 << 9) & 0x0FFFFE00);
463                    }
464                }
465                ppn = ppn | (vpn & 0x1FF);
466            }
467        }
468        else                    // PERI : no memory allocation required
469        {
470            ppn = pseg->base >> 12;
471        }
472    }
473
474    // update vseg.pbase field and update vsegs chaining
475    vseg->pbase     = ((paddr_t)ppn) << 12;
476    vseg->mapped    = 1;
477
478
479    //////////// Third step : (only if the vseg is a page table)
480    //////////// - compute the physical & virtual base address for each vspace
481    ////////////   by dividing the vseg in several sub-segments.
482    //////////// - register it in _ptabs_vaddr & _ptabs_paddr arrays,
483    ////////////   and initialize next_pt2 allocators.
484    //////////// - reset all entries in first level page tables
485   
486    if ( is_ptab )
487    {
488        unsigned int   vs;        // vspace index
489        unsigned int   nspaces;   // number of vspaces
490        unsigned int   nsp;       // number of small pages for one PTAB
491        unsigned int   offset;    // address offset for current PTAB
492
493        nspaces = header->vspaces;
494        offset  = 0;
495
496        // each PTAB must be aligned on a 8 Kbytes boundary
497        nsp = ( vseg->length >> 12 ) / nspaces;
498        if ( (nsp & 0x1) == 0x1 ) nsp = nsp - 1;
499
500        // compute max_pt2
501        _ptabs_max_pt2 = ((nsp<<12) - PT1_SIZE) / PT2_SIZE;
502
503        for ( vs = 0 ; vs < nspaces ; vs++ )
504        {
505            _ptabs_vaddr   [vs][x_dest][y_dest] = (vpn + offset) << 12;
506            _ptabs_paddr   [vs][x_dest][y_dest] = ((paddr_t)(ppn + offset)) << 12;
507            _ptabs_next_pt2[vs][x_dest][y_dest] = 0;
508            offset += nsp;
509
510            // reset all entries in PT1 (8 Kbytes)
511            _physical_memset( _ptabs_paddr[vs][x_dest][y_dest], PT1_SIZE, 0 );
512        }
513    }
514
515    asm volatile ("sync");
516
517#if BOOT_DEBUG_PT
518if ( big )
519_printf("\n[BOOT] vseg %s : cluster[%d,%d] / "
520       "vbase = %x / length = %x / BIG    / npages = %d / pbase = %l\n",
521       vseg->name, x_dest, y_dest, vseg->vbase, vseg->length, npages, vseg-> pbase );
522else
523_printf("\n[BOOT] vseg %s : cluster[%d,%d] / "
524        "vbase = %x / length = %x / SMALL / npages = %d / pbase = %l\n",
525       vseg->name, x_dest, y_dest, vseg->vbase, vseg->length, npages, vseg-> pbase );
526#endif
527
528} // end boot_vseg_map()
529
530/////////////////////////////////////////////////////////////////////////////////////
531// For the vseg defined by the vseg pointer, this function register PTEs
532// in one or several page tables.
533// It is a global vseg (kernel vseg) if (vspace_id == 0xFFFFFFFF).
534// The number of involved PTABs depends on the "local" and "global" attributes:
535//  - PTEs are replicated in all vspaces for a global vseg.
536//  - PTEs are replicated in all clusters containing procs for a non local vseg.
537/////////////////////////////////////////////////////////////////////////////////////
538void boot_vseg_pte( mapping_vseg_t*  vseg,
539                    unsigned int     vspace_id )
540{
541    // compute the "global" vseg attribute and actual vspace index
542    unsigned int        global;
543    unsigned int        vsid;   
544    if ( vspace_id == 0xFFFFFFFF )
545    {
546        global = 1;
547        vsid   = 0;
548    }
549    else
550    {
551        global = 0;
552        vsid   = vspace_id;
553    }
554
555    // compute the "local" and "big" attributes
556    unsigned int        local  = vseg->local;
557    unsigned int        big    = vseg->big;
558
559    // compute vseg flags
560    // The three flags (Local, Remote and Dirty) are set to 1
561    // to avoid hardware update for these flags, because GIET_VM
562    // does use these flags.
563    unsigned int flags = 0;
564    if (vseg->mode & C_MODE_MASK) flags |= PTE_C;
565    if (vseg->mode & X_MODE_MASK) flags |= PTE_X;
566    if (vseg->mode & W_MODE_MASK) flags |= PTE_W;
567    if (vseg->mode & U_MODE_MASK) flags |= PTE_U;
568    if ( global )                 flags |= PTE_G;
569                                  flags |= PTE_L;
570                                  flags |= PTE_R;
571                                  flags |= PTE_D;
572
573    // compute VPN, PPN and number of pages (big or small)
574    unsigned int vpn     = vseg->vbase >> 12;
575    unsigned int vpn_max = (vseg->vbase + vseg->length - 1) >> 12;
576    unsigned int ppn     = (unsigned int)(vseg->pbase >> 12);
577    unsigned int npages;
578    if ( big == 0 ) npages  = vpn_max - vpn + 1;           
579    else            npages  = (vpn_max>>9) - (vpn>>9) + 1; 
580
581    // compute destination cluster coordinates, for local vsegs
582    mapping_header_t*   header       = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
583    mapping_cluster_t*  cluster      = _get_cluster_base(header);
584    mapping_pseg_t*     pseg         = _get_pseg_base(header);
585    mapping_pseg_t*     pseg_dest    = &pseg[vseg->psegid];
586    mapping_cluster_t*  cluster_dest = &cluster[pseg_dest->clusterid];
587    unsigned int        x_dest       = cluster_dest->x;
588    unsigned int        y_dest       = cluster_dest->y;
589
590    unsigned int p;           // iterator for physical page index
591    unsigned int x;           // iterator for cluster x coordinate 
592    unsigned int y;           // iterator for cluster y coordinate 
593    unsigned int v;           // iterator for vspace index
594
595    // loop on PTEs
596    for ( p = 0 ; p < npages ; p++ )
597    { 
598        if  ( (local != 0) && (global == 0) )         // one cluster  / one vspace
599        {
600            if ( big )   // big pages => PTE1s
601            {
602                boot_add_pte1( vsid,
603                               x_dest,
604                               y_dest,
605                               vpn + (p<<9),
606                               flags, 
607                               ppn + (p<<9) );
608            }
609            else         // small pages => PTE2s
610            {
611                boot_add_pte2( vsid,
612                               x_dest,
613                               y_dest,
614                               vpn + p,     
615                               flags, 
616                               ppn + p );
617            }
618        }
619        else if ( (local == 0) && (global == 0) )     // all clusters / one vspace
620        {
621            for ( x = 0 ; x < X_SIZE ; x++ )
622            {
623                for ( y = 0 ; y < Y_SIZE ; y++ )
624                {
625                    if ( cluster[(x * Y_SIZE) + y].procs )
626                    {
627                        if ( big )   // big pages => PTE1s
628                        {
629                            boot_add_pte1( vsid,
630                                           x,
631                                           y,
632                                           vpn + (p<<9),
633                                           flags, 
634                                           ppn + (p<<9) );
635                        }
636                        else         // small pages => PTE2s
637                        {
638                            boot_add_pte2( vsid,
639                                           x,
640                                           y,
641                                           vpn + p,
642                                           flags, 
643                                           ppn + p );
644                        }
645                    }
646                }
647            }
648        }
649        else if ( (local != 0) && (global != 0) )     // one cluster  / all vspaces
650        {
651            for ( v = 0 ; v < header->vspaces ; v++ )
652            {
653                if ( big )   // big pages => PTE1s
654                {
655                    boot_add_pte1( v,
656                                   x_dest,
657                                   y_dest,
658                                   vpn + (p<<9),
659                                   flags, 
660                                   ppn + (p<<9) );
661                }
662                else         // small pages = PTE2s
663                { 
664                    boot_add_pte2( v,
665                                   x_dest,
666                                   y_dest,
667                                   vpn + p,
668                                   flags, 
669                                   ppn + p );
670                }
671            }
672        }
673        else if ( (local == 0) && (global != 0) )     // all clusters / all vspaces
674        {
675            for ( x = 0 ; x < X_SIZE ; x++ )
676            {
677                for ( y = 0 ; y < Y_SIZE ; y++ )
678                {
679                    if ( cluster[(x * Y_SIZE) + y].procs )
680                    {
681                        for ( v = 0 ; v < header->vspaces ; v++ )
682                        {
683                            if ( big )  // big pages => PTE1s
684                            {
685                                boot_add_pte1( v,
686                                               x,
687                                               y,
688                                               vpn + (p<<9),
689                                               flags, 
690                                               ppn + (p<<9) );
691                            }
692                            else        // small pages -> PTE2s
693                            {
694                                boot_add_pte2( v,
695                                               x,
696                                               y,
697                                               vpn + p,
698                                               flags, 
699                                               ppn + p );
700                            }
701                        }
702                    }
703                }
704            }
705        }
706    }  // end for pages
707
708    asm volatile ("sync");
709
710}  // end boot_vseg_pte()
711
712
713///////////////////////////////////////////////////////////////////////////////
714// This function is executed by  processor[x][y][0] in each cluster
715// containing at least one processor.
716// It initialises all page table for all global or private vsegs
717// mapped in cluster[x][y], as specified in the mapping.
718// In each cluster all page tables for the different vspaces must be
719// packed in one vseg occupying one single BPP (Big Physical Page).
720//
721// For each vseg, the mapping is done in two steps:
722// 1) mapping : the boot_vseg_map() function allocates contiguous BPPs
723//    or SPPs (if the vseg is not associated to a peripheral), and register
724//    the physical base address in the vseg pbase field. It initialises the
725//    _ptabs_vaddr[] and _ptabs_paddr[] arrays if the vseg is a PTAB.
726//
727// 2) page table initialisation : the boot_vseg_pte() function initialise
728//    the PTEs (both PTE1 and PTE2) in one or several page tables:
729//    - PTEs are replicated in all vspaces for a global vseg.
730//    - PTEs are replicated in all clusters for a non local vseg.
731//
732// We must handle vsegs in the following order
733//   1) global vseg containing PTAB mapped in cluster[x][y],
734//   2) global vsegs occupying more than one BPP mapped in cluster[x][y],
735//   3) others global vsegs mapped in cluster[x][y],
736//   4) all private vsegs in all user spaces mapped in cluster[x][y].
737///////////////////////////////////////////////////////////////////////////////
738void boot_ptab_init( unsigned int cx,
739                     unsigned int cy ) 
740{
741    mapping_header_t*   header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
742    mapping_vspace_t*   vspace = _get_vspace_base(header);
743    mapping_vseg_t*     vseg   = _get_vseg_base(header);
744    mapping_cluster_t*  cluster ;
745    mapping_pseg_t*     pseg    ;
746
747    unsigned int vspace_id;
748    unsigned int vseg_id;
749
750    unsigned int procid     = _get_procid();
751    unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
752
753    if( lpid )
754    {
755        _printf("\n[BOOT ERROR] in boot_ptab_init() : "
756                "P[%d][%d][%d] should not execute it\n", cx, cy, lpid );
757        _exit();
758    } 
759
760    if ( header->vspaces == 0 )
761    {
762        _printf("\n[BOOT ERROR] in boot_ptab_init() : "
763                "mapping %s contains no vspace\n", header->name );
764        _exit();
765    }
766
767    ///////// Phase 1 : global vseg containing the PTAB (two barriers required)
768
769    // get PTAB global vseg in cluster(cx,cy)
770    unsigned int found = 0;
771    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
772    {
773        pseg    = _get_pseg_base(header) + vseg[vseg_id].psegid;
774        cluster = _get_cluster_base(header) + pseg->clusterid;
775        if ( (vseg[vseg_id].type == VSEG_TYPE_PTAB) && 
776             (cluster->x == cx) && (cluster->y == cy) )
777        {
778            found = 1;
779            break;
780        }
781    }
782    if ( found == 0 )
783    {
784        _printf("\n[BOOT ERROR] in boot_ptab_init() : "
785                "cluster[%d][%d] contains no PTAB vseg\n", cx , cy );
786        _exit();
787    }
788
789    boot_vseg_map( &vseg[vseg_id], 0xFFFFFFFF );
790
791    //////////////////////////////////////////////
792    _simple_barrier_wait( &_barrier_all_clusters );
793    //////////////////////////////////////////////
794
795    boot_vseg_pte( &vseg[vseg_id], 0xFFFFFFFF );
796
797    //////////////////////////////////////////////
798    _simple_barrier_wait( &_barrier_all_clusters );
799    //////////////////////////////////////////////
800
801    ///////// Phase 2 : global vsegs occupying more than one BPP
802
803    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
804    {
805        pseg    = _get_pseg_base(header) + vseg[vseg_id].psegid;
806        cluster = _get_cluster_base(header) + pseg->clusterid;
807        if ( (vseg[vseg_id].length > 0x200000) &&
808             (vseg[vseg_id].mapped == 0) &&
809             (cluster->x == cx) && (cluster->y == cy) )
810        {
811            boot_vseg_map( &vseg[vseg_id], 0xFFFFFFFF );
812            boot_vseg_pte( &vseg[vseg_id], 0xFFFFFFFF );
813        }
814    }
815
816    ///////// Phase 3 : all others global vsegs
817
818    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
819    { 
820        pseg    = _get_pseg_base(header) + vseg[vseg_id].psegid;
821        cluster = _get_cluster_base(header) + pseg->clusterid;
822        if ( (vseg[vseg_id].mapped == 0) && 
823             (cluster->x == cx) && (cluster->y == cy) )
824        {
825            boot_vseg_map( &vseg[vseg_id], 0xFFFFFFFF );
826            boot_vseg_pte( &vseg[vseg_id], 0xFFFFFFFF );
827        }
828    }
829
830    ///////// Phase 4 : all private vsegs
831
832    for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) 
833    {
834        for (vseg_id = vspace[vspace_id].vseg_offset;
835             vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
836             vseg_id++) 
837        {
838            pseg    = _get_pseg_base(header) + vseg[vseg_id].psegid;
839            cluster = _get_cluster_base(header) + pseg->clusterid;
840            if ( (cluster->x == cx) && (cluster->y == cy) )
841            {
842                boot_vseg_map( &vseg[vseg_id], vspace_id );
843                boot_vseg_pte( &vseg[vseg_id], vspace_id );
844            }
845        }
846    }
847
848    //////////////////////////////////////////////
849    _simple_barrier_wait( &_barrier_all_clusters );
850    //////////////////////////////////////////////
851
852} // end boot_ptab_init()
853
854////////////////////////////////////////////////////////////////////////////////
855// This function should be executed by P[0][0][0] only. It complete the
856// page table initialisation, taking care of all global vsegs that are
857// not mapped in a cluster containing a processor, and have not been
858// handled by the boot_ptab_init(x,y) function.
859// An example of such vsegs are the external peripherals in TSAR_LETI platform.
860////////////////////////////////////////////////////////////////////////////////
861void boot_ptab_extend()
862{
863
864    mapping_header_t*   header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
865    mapping_vseg_t*     vseg   = _get_vseg_base(header);
866
867    unsigned int vseg_id;
868
869    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
870    {
871        if ( vseg[vseg_id].mapped == 0 ) 
872        {
873            boot_vseg_map( &vseg[vseg_id], 0xFFFFFFFF );
874            boot_vseg_pte( &vseg[vseg_id], 0xFFFFFFFF );
875        }
876    }
877}  // end boot_ptab_extend()
878
879///////////////////////////////////////////////////////////////////////////////
880// This function returns in the vbase and length buffers the virtual base
881// address and the length of the  segment allocated to the schedulers array
882// in the cluster defined by the clusterid argument.
883///////////////////////////////////////////////////////////////////////////////
884void boot_get_sched_vaddr( unsigned int  cluster_id,
885                           unsigned int* vbase, 
886                           unsigned int* length )
887{
888    mapping_header_t* header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
889    mapping_vseg_t*   vseg   = _get_vseg_base(header);
890    mapping_pseg_t*   pseg   = _get_pseg_base(header);
891
892    unsigned int vseg_id;
893    unsigned int found = 0;
894
895    for ( vseg_id = 0 ; (vseg_id < header->vsegs) && (found == 0) ; vseg_id++ )
896    {
897        if ( (vseg[vseg_id].type == VSEG_TYPE_SCHED) && 
898             (pseg[vseg[vseg_id].psegid].clusterid == cluster_id ) )
899        {
900            *vbase  = vseg[vseg_id].vbase;
901            *length = vseg[vseg_id].length;
902            found = 1;
903        }
904    }
905    if ( found == 0 )
906    {
907        mapping_cluster_t* cluster = _get_cluster_base(header);
908        _printf("\n[BOOT ERROR] No vseg of type SCHED in cluster [%d,%d]\n",
909                cluster[cluster_id].x, cluster[cluster_id].y );
910        _exit();
911    }
912} // end boot_get_sched_vaddr()
913
914#if BOOT_DEBUG_SCHED
915/////////////////////////////////////////////////////////////////////////////
916// This debug function should be executed by only one procesor.
917// It loops on all processors in all clusters to display
918// the HWI / PTI / WTI interrupt vectors for each processor.
919/////////////////////////////////////////////////////////////////////////////
920void boot_sched_irq_display()
921{
922    unsigned int         cx;
923    unsigned int         cy;
924    unsigned int         lpid;
925    unsigned int         slot;
926    unsigned int         entry;
927    unsigned int         type;
928    unsigned int         channel;
929
930    mapping_header_t*    header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
931    mapping_cluster_t*   cluster = _get_cluster_base(header);
932
933    static_scheduler_t*  psched; 
934
935    for ( cx = 0 ; cx < X_SIZE ; cx++ )
936    {
937        for ( cy = 0 ; cy < Y_SIZE ; cy++ )
938        {
939            unsigned int cluster_id = (cx * Y_SIZE) + cy;
940            unsigned int nprocs = cluster[cluster_id].procs;
941
942            for ( lpid = 0 ; lpid < nprocs ; lpid++ )
943            {
944                psched = _schedulers[cx][cy][lpid];
945       
946                _printf("\n[BOOT] interrupt vectors for proc[%d,%d,%d]\n",
947                        cx , cy , lpid );
948
949                for ( slot = 0 ; slot < 32 ; slot++ )
950                {
951                    entry   = psched->hwi_vector[slot];
952                    type    = entry & 0xFFFF;
953                    channel = entry >> 16;
954                    if ( type != ISR_DEFAULT )     
955                    _printf(" - HWI : index = %d / type = %s / channel = %d\n",
956                            slot , _isr_type_str[type] , channel );
957                }
958                for ( slot = 0 ; slot < 32 ; slot++ )
959                {
960                    entry   = psched->wti_vector[slot];
961                    type    = entry & 0xFFFF;
962                    channel = entry >> 16;
963                    if ( type != ISR_DEFAULT )     
964                    _printf(" - WTI : index = %d / type = %s / channel = %d\n",
965                            slot , _isr_type_str[type] , channel );
966                }
967                for ( slot = 0 ; slot < 32 ; slot++ )
968                {
969                    entry   = psched->pti_vector[slot];
970                    type    = entry & 0xFFFF;
971                    channel = entry >> 16;
972                    if ( type != ISR_DEFAULT )     
973                    _printf(" - PTI : index = %d / type = %s / channel = %d\n",
974                            slot , _isr_type_str[type] , channel );
975                }
976            }
977        }
978    } 
979}  // end boot_sched_irq_display()
980#endif
981
982
983////////////////////////////////////////////////////////////////////////////////////
984// This function is executed in parallel by all processors P[x][y][0].
985// It initialises all schedulers in cluster [x][y]. The MMU must be activated.
986// It is split in two phases separated by a synchronisation barrier.
987// - In Step 1, it initialises the _schedulers[x][y][l] pointers array, the
988//              idle_task context, the  HWI / PTI / WTI interrupt vectors,
989//              and the CU HWI / PTI / WTI masks.
990// - In Step 2, it scan all tasks in all vspaces to complete the tasks contexts,
991//              initialisation as specified in the mapping_info data structure,
992//              and set the CP0_SCHED register.
993////////////////////////////////////////////////////////////////////////////////////
994void boot_scheduler_init( unsigned int x, 
995                          unsigned int y )
996{
997    mapping_header_t*    header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
998    mapping_cluster_t*   cluster = _get_cluster_base(header);
999    mapping_vspace_t*    vspace  = _get_vspace_base(header);
1000    mapping_vseg_t*      vseg    = _get_vseg_base(header);
1001    mapping_task_t*      task    = _get_task_base(header);
1002    mapping_periph_t*    periph  = _get_periph_base(header);
1003    mapping_irq_t*       irq     = _get_irq_base(header);
1004
1005    unsigned int         periph_id; 
1006    unsigned int         irq_id;
1007    unsigned int         vspace_id;
1008    unsigned int         vseg_id;
1009    unsigned int         task_id; 
1010
1011    unsigned int         sched_vbase;          // schedulers array vbase address
1012    unsigned int         sched_length;         // schedulers array length
1013    static_scheduler_t*  psched;               // pointer on processor scheduler
1014
1015    unsigned int cluster_id = (x * Y_SIZE) + y;
1016    unsigned int cluster_xy = (x << Y_WIDTH) + y; 
1017    unsigned int nprocs = cluster[cluster_id].procs;
1018    unsigned int lpid;                       
1019   
1020    if ( nprocs > 8 )
1021    {
1022        _printf("\n[BOOT ERROR] cluster[%d,%d] contains more than 8 procs\n", x, y );
1023        _exit();
1024    }
1025
1026    ////////////////////////////////////////////////////////////////////////////////
1027    // Step 1 : - initialize the schedulers[] array of pointers,
1028    //          - initialize the "tasks" and "current variables.
1029    //          - initialise the idle task context.
1030    //          - initialize the HWI, PTI and WTI interrupt vectors.
1031    //          - initialize the XCU masks for HWI / WTI / PTI interrupts.
1032    //
1033    // The general policy for interrupts routing is the following:         
1034    //          - the local HWI are statically allocatedted to local processors.
1035    //          - the nprocs first PTI are allocated for TICK (one per processor).
1036    //          - we allocate 4 WTI per processor: the first one is for WAKUP,
1037    //            the 3 others WTI are used for external interrupts (from PIC),
1038    //            and are dynamically allocated by kernel on demand.
1039    ///////////////////////////////////////////////////////////////////////////////
1040
1041    // get scheduler array virtual base address in cluster[x,y]
1042    boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length );
1043
1044    if ( sched_length < (nprocs<<13) ) // 8 Kbytes per scheduler
1045    {
1046        _printf("\n[BOOT ERROR] Sched segment too small in cluster[%d,%d]\n",
1047                x, y );
1048        _exit();
1049    }
1050
1051    // loop on local processors
1052    for ( lpid = 0 ; lpid < nprocs ; lpid++ )
1053    {
1054        // get scheduler pointer and initialise the schedulers pointers array
1055        psched = (static_scheduler_t*)(sched_vbase + (lpid<<13));
1056        _schedulers[x][y][lpid] = psched;
1057
1058        // initialise the "tasks" and "current" variables default values
1059        psched->tasks   = 0;
1060        psched->current = IDLE_TASK_INDEX;
1061
1062        // set default values for HWI / PTI / SWI vectors (valid bit = 0)
1063        unsigned int slot;
1064        for (slot = 0; slot < 32; slot++)
1065        {
1066            psched->hwi_vector[slot] = 0;
1067            psched->pti_vector[slot] = 0;
1068            psched->wti_vector[slot] = 0;
1069        }
1070
1071        // initializes the idle_task context:
1072        // - the SR slot is 0xFF03 because this task run in kernel mode.
1073        // - it uses the page table of vspace[0]
1074        // - it uses the kernel TTY terminal
1075        // - slots containing addresses (SP,RA,EPC) are initialised by kernel_init()
1076
1077        psched->context[IDLE_TASK_INDEX][CTX_CR_ID]    = 0;
1078        psched->context[IDLE_TASK_INDEX][CTX_SR_ID]    = 0xFF03;
1079        psched->context[IDLE_TASK_INDEX][CTX_PTPR_ID]  = _ptabs_paddr[0][x][y]>>13;
1080        psched->context[IDLE_TASK_INDEX][CTX_PTAB_ID]  = _ptabs_vaddr[0][x][y];
1081        psched->context[IDLE_TASK_INDEX][CTX_TTY_ID]   = 0;
1082        psched->context[IDLE_TASK_INDEX][CTX_LTID_ID]  = IDLE_TASK_INDEX;
1083        psched->context[IDLE_TASK_INDEX][CTX_VSID_ID]  = 0;
1084        psched->context[IDLE_TASK_INDEX][CTX_NORUN_ID] = 0;
1085    }
1086
1087    // HWI / PTI / WTI masks (up to 8 local processors)
1088    unsigned int hwi_mask[8] = {0,0,0,0,0,0,0,0};
1089    unsigned int pti_mask[8] = {0,0,0,0,0,0,0,0};
1090    unsigned int wti_mask[8] = {0,0,0,0,0,0,0,0};
1091
1092    // scan local peripherals to get and check local XCU
1093    mapping_periph_t*  xcu = NULL;
1094    unsigned int       min = cluster[cluster_id].periph_offset ;
1095    unsigned int       max = min + cluster[cluster_id].periphs ;
1096
1097    for ( periph_id = min ; periph_id < max ; periph_id++ )
1098    {
1099        if( periph[periph_id].type == PERIPH_TYPE_XCU ) 
1100        {
1101            xcu = &periph[periph_id];
1102
1103            // check nb_hwi_in
1104            if ( xcu->arg0 < xcu->irqs )
1105            {
1106                _printf("\n[BOOT ERROR] Not enough HWI inputs for XCU[%d,%d]"
1107                        " : nb_hwi = %d / nb_irqs = %d\n",
1108                         x , y , xcu->arg0 , xcu->irqs );
1109                _exit();
1110            }
1111            // check nb_pti_in
1112            if ( xcu->arg2 < nprocs )
1113            {
1114                _printf("\n[BOOT ERROR] Not enough PTI inputs for XCU[%d,%d]\n",
1115                         x, y );
1116                _exit();
1117            }
1118            // check nb_wti_in
1119            if ( xcu->arg1 < (4 * nprocs) )
1120            {
1121                _printf("\n[BOOT ERROR] Not enough WTI inputs for XCU[%d,%d]\n",
1122                        x, y );
1123                _exit();
1124            }
1125            // check nb_irq_out
1126            if ( xcu->channels < (nprocs * header->irq_per_proc) )
1127            {
1128                _printf("\n[BOOT ERROR] Not enough outputs for XCU[%d,%d]\n",
1129                        x, y );
1130                _exit();
1131            }
1132        }
1133    } 
1134
1135    if ( xcu == NULL )
1136    {         
1137        _printf("\n[BOOT ERROR] missing XCU in cluster[%d,%d]\n", x , y );
1138        _exit();
1139    }
1140
1141    // HWI interrupt vector definition
1142    // scan HWI connected to local XCU
1143    // for round-robin allocation to local processors
1144    lpid = 0;
1145    for ( irq_id = xcu->irq_offset ;
1146          irq_id < xcu->irq_offset + xcu->irqs ;
1147          irq_id++ )
1148    {
1149        unsigned int type    = irq[irq_id].srctype;
1150        unsigned int srcid   = irq[irq_id].srcid;
1151        unsigned int isr     = irq[irq_id].isr & 0xFFFF;
1152        unsigned int channel = irq[irq_id].channel << 16;
1153
1154        if ( (type != IRQ_TYPE_HWI) || (srcid > 31) )
1155        {
1156            _printf("\n[BOOT ERROR] Bad IRQ in cluster[%d,%d]\n", x, y );
1157            _exit();
1158        }
1159
1160        // register entry in HWI interrupt vector
1161        _schedulers[x][y][lpid]->hwi_vector[srcid] = isr | channel;
1162
1163        // update XCU HWI mask for P[x,y,lpid]
1164        hwi_mask[lpid] = hwi_mask[lpid] | (1<<srcid);
1165
1166        lpid = (lpid + 1) % nprocs; 
1167    } // end for irqs
1168
1169    // PTI interrupt vector definition
1170    // one PTI for TICK per processor
1171    for ( lpid = 0 ; lpid < nprocs ; lpid++ )
1172    {
1173        // register entry in PTI interrupt vector
1174        _schedulers[x][y][lpid]->pti_vector[lpid] = ISR_TICK;
1175
1176        // update XCU PTI mask for P[x,y,lpid]
1177        pti_mask[lpid] = pti_mask[lpid] | (1<<lpid);
1178    }
1179
1180    // WTI interrupt vector definition
1181    // 4 WTI per processor, first for WAKUP
1182    for ( lpid = 0 ; lpid < nprocs ; lpid++ )
1183    {
1184        // register WAKUP ISR in WTI interrupt vector
1185        _schedulers[x][y][lpid]->wti_vector[lpid] = ISR_WAKUP;
1186
1187        // update XCU WTI mask for P[x,y,lpid] (4 entries per proc)
1188        wti_mask[lpid] = wti_mask[lpid] | (0x1<<(lpid                 ));
1189        wti_mask[lpid] = wti_mask[lpid] | (0x1<<(lpid + NB_PROCS_MAX  ));
1190        wti_mask[lpid] = wti_mask[lpid] | (0x1<<(lpid + 2*NB_PROCS_MAX));
1191        wti_mask[lpid] = wti_mask[lpid] | (0x1<<(lpid + 3*NB_PROCS_MAX));
1192    }
1193
1194    // set the XCU masks for HWI / WTI / PTI interrupts
1195    for ( lpid = 0 ; lpid < nprocs ; lpid++ )
1196    {
1197        unsigned int channel = lpid * IRQ_PER_PROCESSOR; 
1198
1199        _xcu_set_mask( cluster_xy, channel, hwi_mask[lpid], IRQ_TYPE_HWI ); 
1200        _xcu_set_mask( cluster_xy, channel, wti_mask[lpid], IRQ_TYPE_WTI );
1201        _xcu_set_mask( cluster_xy, channel, pti_mask[lpid], IRQ_TYPE_PTI );
1202    }
1203
1204    //////////////////////////////////////////////
1205    _simple_barrier_wait( &_barrier_all_clusters );
1206    //////////////////////////////////////////////
1207
1208#if BOOT_DEBUG_SCHED
1209if ( cluster_xy == 0 ) boot_sched_irq_display();
1210_simple_barrier_wait( &_barrier_all_clusters );
1211#endif
1212
1213    ///////////////////////////////////////////////////////////////////////////////
1214    // Step 2 : Initialise the tasks context. The context of task placed
1215    //          on  processor P must be stored in the scheduler of P.
1216    //          This require two nested loops: loop on the tasks, and loop
1217    //          on the local processors. We complete the scheduler when the
1218    //          required placement fit one local processor.
1219    ///////////////////////////////////////////////////////////////////////////////
1220
1221    for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) 
1222    {
1223        // We must set the PTPR depending on the vspace, because the start_vector
1224        // and the stack address are defined in virtual space.
1225        _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id][x][y] >> 13) );
1226
1227        // ctx_norun depends on the vspace active field
1228        unsigned int ctx_norun = (vspace[vspace_id].active == 0);
1229
1230        // loop on the tasks in vspace (task_id is the global index in mapping)
1231        for (task_id = vspace[vspace_id].task_offset;
1232             task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks);
1233             task_id++) 
1234        {
1235            // get the required task placement coordinates [x,y,p]
1236            unsigned int req_x      = cluster[task[task_id].clusterid].x;
1237            unsigned int req_y      = cluster[task[task_id].clusterid].y;
1238            unsigned int req_p      = task[task_id].proclocid;                 
1239
1240            // ctx_ptpr : page table physical base address (shifted by 13 bit)
1241            unsigned int ctx_ptpr = (_ptabs_paddr[vspace_id][req_x][req_y] >> 13);
1242
1243            // ctx_ptab : page_table virtual base address
1244            unsigned int ctx_ptab = _ptabs_vaddr[vspace_id][req_x][req_y];
1245
1246            // ctx_entry : Get the virtual address of the memory location containing
1247            // the task entry point : the start_vector is stored by GCC in the
1248            // seg_data segment, and we must wait the .elf loading to get
1249            // the entry point value...
1250            vseg_id = vspace[vspace_id].start_vseg_id;     
1251            unsigned int ctx_entry = vseg[vseg_id].vbase + (task[task_id].startid)*4;
1252
1253            // ctx_sp :  Get the vseg containing the stack
1254            vseg_id = task[task_id].stack_vseg_id;
1255            unsigned int ctx_sp = vseg[vseg_id].vbase + vseg[vseg_id].length;
1256
1257            // get vspace thread index
1258            unsigned int thread_id = task[task_id].trdid;
1259
1260            // loop on the local processors
1261            for ( lpid = 0 ; lpid < nprocs ; lpid++ )
1262            {
1263                if ( (x == req_x) && (y == req_y) && (req_p == lpid) )   // fit
1264                {
1265                    // pointer on selected scheduler
1266                    psched = _schedulers[x][y][lpid];
1267
1268                    // get local task index in scheduler
1269                    unsigned int ltid = psched->tasks;
1270
1271                    // update the "tasks" field in scheduler:
1272                    psched->tasks   = ltid + 1;
1273
1274                    // initializes the task context
1275                    psched->context[ltid][CTX_CR_ID]     = 0;
1276                    psched->context[ltid][CTX_SR_ID]     = GIET_SR_INIT_VALUE;
1277                    psched->context[ltid][CTX_SP_ID]     = ctx_sp;
1278                    psched->context[ltid][CTX_EPC_ID]    = ctx_entry;
1279                    psched->context[ltid][CTX_ENTRY_ID]  = ctx_entry;
1280                    psched->context[ltid][CTX_PTPR_ID]   = ctx_ptpr;
1281                    psched->context[ltid][CTX_PTAB_ID]   = ctx_ptab;
1282                    psched->context[ltid][CTX_LTID_ID]   = ltid;
1283                    psched->context[ltid][CTX_GTID_ID]   = task_id;
1284                    psched->context[ltid][CTX_TRDID_ID]  = thread_id;
1285                    psched->context[ltid][CTX_VSID_ID]   = vspace_id;
1286                    psched->context[ltid][CTX_NORUN_ID]  = ctx_norun;
1287
1288                    psched->context[ltid][CTX_TTY_ID]    = 0xFFFFFFFF;
1289                    psched->context[ltid][CTX_CMA_FB_ID] = 0xFFFFFFFF;
1290                    psched->context[ltid][CTX_CMA_RX_ID] = 0xFFFFFFFF;
1291                    psched->context[ltid][CTX_CMA_TX_ID] = 0xFFFFFFFF;
1292                    psched->context[ltid][CTX_NIC_RX_ID] = 0xFFFFFFFF;
1293                    psched->context[ltid][CTX_NIC_TX_ID] = 0xFFFFFFFF;
1294                    psched->context[ltid][CTX_TIM_ID]    = 0xFFFFFFFF;
1295                    psched->context[ltid][CTX_HBA_ID]    = 0xFFFFFFFF;
1296
1297                    // update task ltid field in the mapping
1298                    task[task_id].ltid = ltid;
1299
1300#if BOOT_DEBUG_SCHED
1301_printf("\nTask %s in vspace %s allocated to P[%d,%d,%d]\n"
1302        " - ctx[LTID]  = %d\n"
1303        " - ctx[SR]    = %x\n"
1304        " - ctx[SP]    = %x\n"
1305        " - ctx[ENTRY] = %x\n"
1306        " - ctx[PTPR]  = %x\n"
1307        " - ctx[PTAB]  = %x\n"
1308        " - ctx[VSID]  = %d\n"
1309        " - ctx[TRDID] = %d\n"
1310        " - ctx[NORUN] = %x\n",
1311        task[task_id].name,
1312        vspace[vspace_id].name,
1313        x, y, lpid,
1314        psched->context[ltid][CTX_LTID_ID],
1315        psched->context[ltid][CTX_SR_ID],
1316        psched->context[ltid][CTX_SP_ID],
1317        psched->context[ltid][CTX_ENTRY_ID],
1318        psched->context[ltid][CTX_PTPR_ID],
1319        psched->context[ltid][CTX_PTAB_ID],
1320        psched->context[ltid][CTX_VSID_ID],
1321        psched->context[ltid][CTX_TRDID_ID],
1322        psched->context[ltid][CTX_NORUN_ID] );
1323#endif
1324                } // end if FIT
1325            } // end for loop on local procs
1326        } // end loop on tasks
1327    } // end loop on vspaces
1328} // end boot_scheduler_init()
1329
1330
1331
1332//////////////////////////////////////////////////////////////////////////////////
1333// This function loads the map.bin file from block device.
1334//////////////////////////////////////////////////////////////////////////////////
1335void boot_mapping_init()
1336{
1337    // load map.bin file into buffer
1338    if ( _fat_load_no_cache( "map.bin",
1339                             SEG_BOOT_MAPPING_BASE,
1340                             SEG_BOOT_MAPPING_SIZE ) )
1341    {
1342        _printf("\n[BOOT ERROR] : map.bin file not found \n");
1343        _exit();
1344    }
1345
1346    // check mapping signature, number of clusters, number of vspaces 
1347    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1348    if ( (header->signature != IN_MAPPING_SIGNATURE) ||
1349         (header->x_size    != X_SIZE)               || 
1350         (header->y_size    != Y_SIZE)               ||
1351         (header->vspaces   > GIET_NB_VSPACE_MAX)    )
1352    {
1353        _printf("\n[BOOT ERROR] Illegal mapping : signature = %x\n", header->signature );
1354        _exit();
1355    }
1356
1357#if BOOT_DEBUG_MAPPING
1358unsigned int  line;
1359unsigned int* pointer = (unsigned int*)SEG_BOOT_MAPPING_BASE;
1360_printf("\n[BOOT] First block of mapping\n");
1361for ( line = 0 ; line < 8 ; line++ )
1362{
1363    _printf(" | %X | %X | %X | %X | %X | %X | %X | %X |\n",
1364            *(pointer + 0),
1365            *(pointer + 1),
1366            *(pointer + 2),
1367            *(pointer + 3),
1368            *(pointer + 4),
1369            *(pointer + 5),
1370            *(pointer + 6),
1371            *(pointer + 7) );
1372
1373    pointer = pointer + 8;
1374}
1375#endif
1376
1377} // end boot_mapping_init()
1378
1379
1380///////////////////////////////////////////////////
1381void boot_dma_copy( unsigned int        cluster_xy,     
1382                    unsigned long long  dst_paddr,
1383                    unsigned long long  src_paddr, 
1384                    unsigned int        size )   
1385{
1386    // size must be multiple of 64 bytes
1387    if ( size & 0x3F ) size = (size & (~0x3F)) + 0x40;
1388
1389    unsigned int mode = MODE_DMA_NO_IRQ;
1390
1391    unsigned int src     = 0;
1392    unsigned int src_lsb = (unsigned int)src_paddr;
1393    unsigned int src_msb = (unsigned int)(src_paddr>>32);
1394   
1395    unsigned int dst     = 1;
1396    unsigned int dst_lsb = (unsigned int)dst_paddr;
1397    unsigned int dst_msb = (unsigned int)(dst_paddr>>32);
1398
1399    // initializes src channel
1400    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_MODE       , mode );
1401    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_SIZE       , size );
1402    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_BUFFER_LSB , src_lsb );
1403    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_BUFFER_MSB , src_msb );
1404    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_RUNNING    , 1 );
1405
1406    // initializes dst channel
1407    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_MODE       , mode );
1408    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_SIZE       , size );
1409    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_BUFFER_LSB , dst_lsb );
1410    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_BUFFER_MSB , dst_msb );
1411    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_RUNNING    , 1 );
1412
1413    // start CPY coprocessor (write non-zero value into config register)
1414    _mwr_set_coproc_register( cluster_xy, 0 , 1 );
1415
1416    // poll dst channel status register to detect completion
1417    unsigned int status;
1418    do
1419    {
1420        status = _mwr_get_channel_register( cluster_xy , dst , MWR_CHANNEL_STATUS );
1421    } while ( status == MWR_CHANNEL_BUSY );
1422
1423    if ( status )
1424    {
1425        _printf("\n[BOOT ERROR] in boot_dma_copy()\n");
1426        _exit();
1427    } 
1428 
1429    // stop CPY coprocessor and DMA channels
1430    _mwr_set_channel_register( cluster_xy , src , MWR_CHANNEL_RUNNING    , 0 );
1431    _mwr_set_channel_register( cluster_xy , dst , MWR_CHANNEL_RUNNING    , 0 );
1432    _mwr_set_coproc_register ( cluster_xy , 0 , 0 );
1433
1434}  // end boot_dma_copy()
1435
1436//////////////////////////////////////////////////////////////////////////////////
1437// This function load all loadable segments contained in the .elf file identified
1438// by the "pathname" argument. Some loadable segments can be copied in several
1439// clusters: same virtual address but different physical addresses. 
1440// - It open the file.
1441// - It loads the complete file in the dedicated _boot_elf_buffer.
1442// - It copies each loadable segments  at the virtual address defined in
1443//   the .elf file, making several copies if the target vseg is not local.
1444// - It closes the file.
1445// This function is supposed to be executed by all processors[x,y,0].
1446//
1447// Note: We must use physical addresses to reach the destination buffers that
1448// can be located in remote clusters. We use either a _physical_memcpy(),
1449// or a _dma_physical_copy() if DMA is available.
1450//////////////////////////////////////////////////////////////////////////////////
1451void load_one_elf_file( unsigned int is_kernel,     // kernel file if non zero
1452                        char*        pathname,
1453                        unsigned int vspace_id )    // to scan the proper vspace
1454{
1455    mapping_header_t  * header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1456    mapping_vspace_t  * vspace  = _get_vspace_base(header);
1457    mapping_vseg_t    * vseg    = _get_vseg_base(header);
1458
1459    unsigned int procid = _get_procid();
1460    unsigned int cxy    = procid >> P_WIDTH;
1461    unsigned int x      = cxy >> Y_WIDTH;
1462    unsigned int y      = cxy & ((1<<Y_WIDTH)-1);
1463    unsigned int p      = procid & ((1<<P_WIDTH)-1);
1464
1465#if BOOT_DEBUG_ELF
1466_printf("\n[DEBUG BOOT_ELF] load_one_elf_file() : P[%d,%d,%d] enters for %s\n",
1467        x , y , p , pathname );
1468#endif
1469
1470    Elf32_Ehdr* elf_header_ptr = NULL;  //  avoid a warning
1471
1472    // only P[0,0,0] load file
1473    if ( (cxy == 0) && (p == 0) )
1474    {
1475        if ( _fat_load_no_cache( pathname,
1476                                 (unsigned int)_boot_elf_buffer,
1477                                 GIET_ELF_BUFFER_SIZE ) )
1478        {
1479            _printf("\n[BOOT ERROR] in load_one_elf_file() : %s\n", pathname );
1480            _exit();
1481        }
1482
1483        // Check ELF Magic Number in ELF header
1484        Elf32_Ehdr* ptr = (Elf32_Ehdr*)_boot_elf_buffer;
1485
1486        if ( (ptr->e_ident[EI_MAG0] != ELFMAG0) ||
1487             (ptr->e_ident[EI_MAG1] != ELFMAG1) ||
1488             (ptr->e_ident[EI_MAG2] != ELFMAG2) ||
1489             (ptr->e_ident[EI_MAG3] != ELFMAG3) )
1490        {
1491            _printf("\n[BOOT ERROR] load_one_elf_file() : %s not ELF format\n",
1492                    pathname );
1493            _exit();
1494        }
1495
1496#if BOOT_DEBUG_ELF
1497_printf("\n[DEBUG BOOT_ELF] load_one_elf_file() : P[%d,%d,%d] load %s at cycle %d\n", 
1498        x , y , p , pathname , _get_proctime() );
1499#endif
1500
1501    } // end if P[0,0,0]
1502
1503    //////////////////////////////////////////////
1504    _simple_barrier_wait( &_barrier_all_clusters );
1505    //////////////////////////////////////////////
1506
1507    // Each processor P[x,y,0] copy replicated segments in cluster[x,y]
1508    elf_header_ptr = (Elf32_Ehdr*)_boot_elf_buffer;
1509
1510    // get program header table pointer
1511    unsigned int offset = elf_header_ptr->e_phoff;
1512    if( offset == 0 )
1513    {
1514        _printf("\n[BOOT ERROR] load_one_elf_file() : file %s "
1515                "does not contain loadable segment\n", pathname );
1516        _exit();
1517    }
1518
1519    Elf32_Phdr* elf_pht_ptr = (Elf32_Phdr*)(_boot_elf_buffer + offset);
1520
1521    // get number of segments
1522    unsigned int nsegments   = elf_header_ptr->e_phnum;
1523
1524    // First loop on loadable segments in the .elf file
1525    unsigned int seg_id;
1526    for (seg_id = 0 ; seg_id < nsegments ; seg_id++)
1527    {
1528        if(elf_pht_ptr[seg_id].p_type == PT_LOAD)
1529        {
1530            // Get segment attributes
1531            unsigned int seg_vaddr  = elf_pht_ptr[seg_id].p_vaddr;
1532            unsigned int seg_offset = elf_pht_ptr[seg_id].p_offset;
1533            unsigned int seg_filesz = elf_pht_ptr[seg_id].p_filesz;
1534            unsigned int seg_memsz  = elf_pht_ptr[seg_id].p_memsz;
1535
1536            if( seg_memsz != seg_filesz )
1537            {
1538                _printf("\n[BOOT ERROR] load_one_elf_file() : segment at vaddr = %x\n"
1539                        " in file %s has memsize = %x / filesize = %x \n"
1540                        " check that all global variables are in data segment\n", 
1541                        seg_vaddr, pathname , seg_memsz , seg_filesz );
1542                _exit();
1543            }
1544
1545            unsigned int src_vaddr = (unsigned int)_boot_elf_buffer + seg_offset;
1546
1547            // search all vsegs matching the virtual address
1548            unsigned int vseg_first;
1549            unsigned int vseg_last;
1550            unsigned int vseg_id;
1551            unsigned int found = 0;
1552            if ( is_kernel )
1553            {
1554                vseg_first = 0;
1555                vseg_last  = header->globals;
1556            }
1557            else
1558            {
1559                vseg_first = vspace[vspace_id].vseg_offset;
1560                vseg_last  = vseg_first + vspace[vspace_id].vsegs;
1561            }
1562
1563            // Second loop on vsegs in the mapping
1564            for ( vseg_id = vseg_first ; vseg_id < vseg_last ; vseg_id++ )
1565            {
1566                if ( seg_vaddr == vseg[vseg_id].vbase )  // matching
1567                {
1568                    found = 1;
1569
1570                    // get destination buffer physical address, size, coordinates
1571                    paddr_t      seg_paddr  = vseg[vseg_id].pbase;
1572                    unsigned int seg_size   = vseg[vseg_id].length;
1573                    unsigned int cluster_xy = (unsigned int)(seg_paddr>>32);
1574                    unsigned int cx         = cluster_xy >> Y_WIDTH;
1575                    unsigned int cy         = cluster_xy & ((1<<Y_WIDTH)-1);
1576
1577                    // check vseg size
1578                    if ( seg_size < seg_filesz )
1579                    {
1580                        _printf("\n[BOOT ERROR] in load_one_elf_file() : vseg %s "
1581                                "is too small for segment %x\n"
1582                                "  file = %s / vseg_size = %x / seg_file_size = %x\n",
1583                                vseg[vseg_id].name , seg_vaddr , pathname,
1584                                seg_size , seg_filesz );
1585                        _exit();
1586                    }
1587
1588                    // P[x,y,0] copy the segment from boot buffer in cluster[0,0]
1589                    // to destination buffer in cluster[x,y], using DMA if available
1590                    if ( (cx == x) && (cy == y) )
1591                    {
1592                        if( USE_MWR_CPY )
1593                        {
1594                            boot_dma_copy( cluster_xy,  // DMA in cluster[x,y]       
1595                                           seg_paddr,
1596                                           (paddr_t)src_vaddr, 
1597                                           seg_filesz );   
1598#if BOOT_DEBUG_ELF
1599_printf("\n[DEBUG BOOT_ELF] load_one_elf_file() : DMA[%d,%d] copy segment %d :\n"
1600        "  vaddr = %x / size = %x / paddr = %l\n",
1601        x , y , seg_id , seg_vaddr , seg_memsz , seg_paddr );
1602#endif
1603                        }
1604                        else
1605                        {
1606                            _physical_memcpy( seg_paddr,            // dest paddr
1607                                              (paddr_t)src_vaddr,   // source paddr
1608                                              seg_filesz );         // size
1609#if BOOT_DEBUG_ELF
1610_printf("\n[DEBUG BOOT_ELF] load_one_elf_file() : P[%d,%d,%d] copy segment %d :\n"
1611        "  vaddr = %x / size = %x / paddr = %l\n",
1612        x , y , p , seg_id , seg_vaddr , seg_memsz , seg_paddr );
1613#endif
1614                        }
1615                    }
1616                }
1617            }  // end for vsegs
1618
1619            // check at least one matching vseg
1620            if ( found == 0 )
1621            {
1622                _printf("\n[BOOT ERROR] in load_one_elf_file() : vseg for loadable "
1623                        "segment %x in file %s not found "
1624                        "check consistency between the .py and .ld files\n",
1625                        seg_vaddr, pathname );
1626                _exit();
1627            }
1628        }
1629    }  // end for loadable segments
1630
1631    //////////////////////////////////////////////
1632    _simple_barrier_wait( &_barrier_all_clusters );
1633    //////////////////////////////////////////////
1634
1635    // only P[0,0,0] signals completion
1636    if ( (cxy == 0) && (p == 0) )
1637    {
1638        _printf("\n[BOOT] File %s loaded at cycle %d\n", 
1639                pathname , _get_proctime() );
1640    }
1641
1642} // end load_one_elf_file()
1643
1644
1645/////i////////////////////////////////////////////////////////////////////////////////
1646// This function uses the map.bin data structure to load the "kernel.elf" file
1647// as well as the various "application.elf" files into memory.
1648// - The "preloader.elf" file is not loaded, because it has been burned in the ROM.
1649// - The "boot.elf" file is not loaded, because it has been loaded by the preloader.
1650// This function scans all vsegs defined in the map.bin data structure to collect
1651// all .elf files pathnames, and calls the load_one_elf_file() for each .elf file.
1652// As the code can be replicated in several vsegs, the same code can be copied
1653// in one or several clusters by the load_one_elf_file() function.
1654//////////////////////////////////////////////////////////////////////////////////////
1655void boot_elf_load()
1656{
1657    mapping_header_t* header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1658    mapping_vspace_t* vspace = _get_vspace_base( header );
1659    mapping_vseg_t*   vseg   = _get_vseg_base( header );
1660
1661    unsigned int      vspace_id;
1662    unsigned int      vseg_id;
1663    unsigned int      found;
1664
1665    // Scan all global vsegs to find the pathname to the kernel.elf file
1666    found = 0;
1667    for( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
1668    {
1669        if(vseg[vseg_id].type == VSEG_TYPE_ELF) 
1670        {   
1671            found = 1;
1672            break;
1673        }
1674    }
1675
1676    // We need one kernel.elf file
1677    if (found == 0)
1678    {
1679        _printf("\n[BOOT ERROR] boot_elf_load() : kernel.elf file not found\n");
1680        _exit();
1681    }
1682
1683    // Load the kernel
1684    load_one_elf_file( 1,                           // kernel file
1685                       vseg[vseg_id].binpath,       // file pathname
1686                       0 );                         // vspace 0
1687
1688    // loop on the vspaces, scanning all vsegs in the vspace,
1689    // to find the pathname of the .elf file associated to the vspace.
1690    for( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
1691    {
1692        // loop on the private vsegs
1693        unsigned int found = 0;
1694        for (vseg_id = vspace[vspace_id].vseg_offset;
1695             vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
1696             vseg_id++) 
1697        {
1698            if(vseg[vseg_id].type == VSEG_TYPE_ELF) 
1699            {   
1700                found = 1;
1701                break;
1702            }
1703        }
1704
1705        // We want one .elf file per vspace
1706        if (found == 0)
1707        {
1708            _printf("\n[BOOT ERROR] boot_elf_load() : "
1709                    ".elf file not found for vspace %s\n", vspace[vspace_id].name );
1710            _exit();
1711        }
1712
1713        load_one_elf_file( 0,                          // not a kernel file
1714                           vseg[vseg_id].binpath,      // file pathname
1715                           vspace_id );                // vspace index
1716
1717    }  // end for vspaces
1718
1719} // end boot_elf_load()
1720
1721
1722/////////////////////////////////////////////////////////////////////////////////
1723// This function is executed in parallel by all processors[x][y][0].
1724// It initialises the physical memory allocator in each cluster containing
1725// a RAM pseg.
1726/////////////////////////////////////////////////////////////////////////////////
1727void boot_pmem_init( unsigned int cx,
1728                     unsigned int cy ) 
1729{
1730    mapping_header_t*  header     = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1731    mapping_cluster_t* cluster    = _get_cluster_base(header);
1732    mapping_pseg_t*    pseg       = _get_pseg_base(header);
1733
1734    unsigned int pseg_id;
1735    unsigned int procid     = _get_procid();
1736    unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
1737
1738    if( lpid )
1739    {
1740        _printf("\n[BOOT ERROR] boot_pmem_init() : "
1741        "P[%d][%d][%d] should not execute it\n", cx, cy, lpid );
1742        _exit();
1743    }   
1744
1745    // scan the psegs in local cluster to find  pseg of type RAM
1746    unsigned int found      = 0;
1747    unsigned int cluster_id = cx * Y_SIZE + cy;
1748    unsigned int pseg_min   = cluster[cluster_id].pseg_offset;
1749    unsigned int pseg_max   = pseg_min + cluster[cluster_id].psegs;
1750    for ( pseg_id = pseg_min ; pseg_id < pseg_max ; pseg_id++ )
1751    {
1752        if ( pseg[pseg_id].type == PSEG_TYPE_RAM )
1753        {
1754            unsigned int base = (unsigned int)pseg[pseg_id].base;
1755            unsigned int size = (unsigned int)pseg[pseg_id].length;
1756            _pmem_alloc_init( cx, cy, base, size );
1757            found = 1;
1758
1759#if BOOT_DEBUG_PT
1760_printf("\n[BOOT] pmem allocator initialised in cluster[%d][%d]"
1761        " : base = %x / size = %x\n", cx , cy , base , size );
1762#endif
1763            break;
1764        }
1765    }
1766
1767    if ( found == 0 )
1768    {
1769        _printf("\n[BOOT ERROR] boot_pmem_init() : no RAM in cluster[%d][%d]\n",
1770                cx , cy );
1771        _exit();
1772    }   
1773} // end boot_pmem_init()
1774 
1775/////////////////////////////////////////////////////////////////////////
1776// This function is the entry point of the boot code for all processors.
1777/////////////////////////////////////////////////////////////////////////
1778void boot_init() 
1779{
1780
1781    unsigned int       gpid       = _get_procid();
1782    unsigned int       cx         = gpid >> (Y_WIDTH + P_WIDTH);
1783    unsigned int       cy         = (gpid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
1784    unsigned int       lpid       = gpid & ((1 << P_WIDTH) -1);
1785
1786    //////////////////////////////////////////////////////////
1787    // Phase ONE : only P[0][0][0] execute it
1788    //////////////////////////////////////////////////////////
1789    if ( gpid == 0 )   
1790    {
1791        unsigned int cid;  // index for loop on clusters
1792
1793        // initialises the TTY0 spin lock
1794        _spin_lock_init( &_tty0_spin_lock );
1795
1796        _printf("\n[BOOT] P[0,0,0] starts at cycle %d\n", _get_proctime() );
1797
1798        // initialise the MMC locks array
1799        _mmc_boot_mode = 1;
1800        _mmc_init_locks();
1801
1802        // initialises the IOC peripheral
1803        if      ( USE_IOC_BDV != 0 ) _bdv_init();
1804        else if ( USE_IOC_HBA != 0 ) _hba_init();
1805        else if ( USE_IOC_SDC != 0 ) _sdc_init();
1806        else if ( USE_IOC_RDK == 0 )
1807        {
1808            _printf("\n[BOOT ERROR] boot_init() : no IOC peripheral\n");
1809            _exit();
1810        }
1811
1812        // initialises the FAT
1813        _fat_init( 0 );          // don't use Inode-Tree, Fat-Cache, etc.
1814
1815        _printf("\n[BOOT] FAT initialised at cycle %d\n", _get_proctime() );
1816
1817        // Load the map.bin file into memory
1818        boot_mapping_init();
1819
1820        mapping_header_t*  header     = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1821        mapping_cluster_t* cluster    = _get_cluster_base(header);
1822
1823        _printf("\n[BOOT] Mapping %s loaded at cycle %d\n",
1824                header->name , _get_proctime() );
1825
1826        // initialises the barrier for all clusters containing processors
1827        unsigned int nclusters = 0;
1828        for ( cid = 0 ; cid < X_SIZE*Y_SIZE ; cid++ )
1829        {
1830            if ( cluster[cid].procs ) nclusters++ ;
1831        } 
1832
1833        _simple_barrier_init( &_barrier_all_clusters , nclusters );
1834
1835        // wake up all processors P[x][y][0]
1836        for ( cid = 1 ; cid < X_SIZE*Y_SIZE ; cid++ ) 
1837        {
1838            unsigned int x          = cluster[cid].x;
1839            unsigned int y          = cluster[cid].y;
1840            unsigned int cluster_xy = (x << Y_WIDTH) + y;
1841
1842            if ( cluster[cid].procs ) 
1843            {
1844                unsigned long long paddr = (((unsigned long long)cluster_xy)<<32) +
1845                                           SEG_XCU_BASE+XCU_REG( XCU_WTI_REG , 0 );
1846
1847                _physical_write( paddr , (unsigned int)boot_entry );
1848            }
1849        }
1850
1851        _printf("\n[BOOT] Processors P[x,y,0] start at cycle %d\n",
1852                _get_proctime() );
1853    }
1854
1855    /////////////////////////////////////////////////////////////////
1856    // Phase TWO : All processors P[x][y][0] execute it in parallel
1857    /////////////////////////////////////////////////////////////////
1858    if( lpid == 0 )
1859    {
1860        // Initializes physical memory allocator in cluster[cx][cy]
1861        boot_pmem_init( cx , cy );
1862
1863        // Build page table in cluster[cx][cy]
1864        boot_ptab_init( cx , cy );
1865
1866        //////////////////////////////////////////////
1867        _simple_barrier_wait( &_barrier_all_clusters );
1868        //////////////////////////////////////////////
1869
1870        // P[0][0][0] complete page tables with vsegs
1871        // mapped in clusters without processors
1872        if ( gpid == 0 )   
1873        {
1874            // complete page tables initialisation
1875            boot_ptab_extend();
1876
1877            _printf("\n[BOOT] Physical memory allocators and page tables"
1878                    " initialized at cycle %d\n", _get_proctime() );
1879        }
1880
1881        //////////////////////////////////////////////
1882        _simple_barrier_wait( &_barrier_all_clusters );
1883        //////////////////////////////////////////////
1884
1885        // All processors P[x,y,0] activate MMU (using local PTAB)
1886        _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0][cx][cy]>>13) );
1887        _set_mmu_mode( 0xF );
1888       
1889        // Each processor P[x,y,0] initialises all schedulers in cluster[x,y]
1890        boot_scheduler_init( cx , cy );
1891
1892        // Each processor P[x][y][0] initialises its CP0_SCHED register
1893        _set_sched( (unsigned int)_schedulers[cx][cy][0] );
1894
1895        //////////////////////////////////////////////
1896        _simple_barrier_wait( &_barrier_all_clusters );
1897        //////////////////////////////////////////////
1898
1899        if ( gpid == 0 ) 
1900        {
1901            _printf("\n[BOOT] Schedulers initialised at cycle %d\n", 
1902                    _get_proctime() );
1903        }
1904
1905        // All processor P[x,y,0] contributes to load .elf files into clusters.
1906        boot_elf_load();
1907
1908        //////////////////////////////////////////////
1909        _simple_barrier_wait( &_barrier_all_clusters );
1910        //////////////////////////////////////////////
1911       
1912        // Each processor P[x][y][0] wake up other processors in same cluster
1913        mapping_header_t*  header     = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
1914        mapping_cluster_t* cluster    = _get_cluster_base(header);
1915        unsigned int       cluster_xy = (cx << Y_WIDTH) + cy;
1916        unsigned int       cluster_id = (cx * Y_SIZE) + cy;
1917        unsigned int p;
1918        for ( p = 1 ; p < cluster[cluster_id].procs ; p++ )
1919        {
1920            _xcu_send_wti( cluster_xy , p , (unsigned int)boot_entry );
1921        }
1922
1923        // only P[0][0][0] makes display
1924        if ( gpid == 0 )
1925        {   
1926            _printf("\n[BOOT] All processors start at cycle %d\n",
1927                    _get_proctime() );
1928        }
1929    }
1930    // All other processors activate MMU (using local PTAB)
1931    if ( lpid != 0 )
1932    {
1933        _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0][cx][cy]>>13) );
1934        _set_mmu_mode( 0xF );
1935    }
1936
1937    // All processors set CP0_SCHED register
1938    _set_sched( (unsigned int)_schedulers[cx][cy][lpid] );
1939
1940    // All processors reset BEV bit in SR to use GIET_VM exception handler
1941    _set_sr( 0 );
1942
1943    // Each processor get kernel entry virtual address
1944    unsigned int kernel_entry = (unsigned int)&kernel_init_vbase;
1945
1946#if BOOT_DEBUG_ELF
1947_printf("\n[DEBUG BOOT_ELF] P[%d,%d,%d] exit boot & jump to %x at cycle %d\n",
1948        cx, cy, lpid, kernel_entry , _get_proctime() );
1949#endif
1950
1951    // All processors jump to kernel_init
1952    asm volatile( "jr   %0" ::"r"(kernel_entry) );
1953
1954} // end boot_init()
1955
1956
1957// Local Variables:
1958// tab-width: 4
1959// c-basic-offset: 4
1960// c-file-offsets:((innamespace . 0)(inline-open . 0))
1961// indent-tabs-mode: nil
1962// End:
1963// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
1964
Note: See TracBrowser for help on using the repository browser.