Index: /soft/giet_vm/Makefile =================================================================== --- /soft/giet_vm/Makefile (revision 294) +++ /soft/giet_vm/Makefile (revision 295) @@ -11,5 +11,5 @@ ### partition sectors = 524832 -MAP_XML = mappings/4c_1p_iob_four.xml +MAP_XML = mappings/4c_4p_sort_leti_ext.xml ### Objects to be linked for kernel.elf @@ -18,4 +18,5 @@ build/fat32/fat32.o \ build/drivers/dma_driver.o \ + build/drivers/cma_driver.o \ build/drivers/fbf_driver.o \ build/drivers/xcu_driver.o \ @@ -26,4 +27,5 @@ build/drivers/sdc_driver.o \ build/drivers/spi_driver.o \ + build/drivers/rdk_driver.o \ build/drivers/iob_driver.o \ build/drivers/mmc_driver.o \ @@ -32,4 +34,5 @@ build/drivers/tim_driver.o \ build/drivers/tty_driver.o \ + build/drivers/pic_driver.o \ build/kernel/giet.o \ build/kernel/switch.o \ @@ -44,15 +47,15 @@ build/common/vmem.o \ build/fat32/fat32.o \ + build/drivers/dma_driver.o \ build/drivers/tty_driver.o \ + build/drivers/pic_driver.o \ build/drivers/xcu_driver.o \ - build/drivers/dma_driver.o \ - build/drivers/mwr_driver.o \ build/drivers/ioc_driver.o \ build/drivers/bdv_driver.o \ - build/drivers/hba_driver.o \ build/drivers/sdc_driver.o \ build/drivers/spi_driver.o \ - build/drivers/nic_driver.o \ + build/drivers/rdk_driver.o \ build/drivers/mmc_driver.o \ + build/drivers/mwr_driver.o \ build/kernel/ctx_handler.o \ build/kernel/switch.o \ @@ -96,4 +99,10 @@ build/libs/barrier.o +### Objects to be linked for transpose.elf +TRANSPOSE_OBJS = build/transpose/main.o \ + build/libs/stdio.o \ + build/libs/malloc.o \ + build/libs/spin_lock.o \ + build/libs/barrier.o CFLAGS = -Wall -ffreestanding -mno-gpopt -mips32 @@ -123,4 +132,5 @@ build/gameoflife/gameoflife.elf \ build/sort/sort.elf \ + build/transpose/transpose.elf \ hdd/virt_hdd.dmg @@ -128,13 +138,16 @@ ### This requires the generic LINUX/MacOS script "create_dmg" script ### written by C.Fuguet. (should be installed in GIET-VM root directory). -hdd/virt_hdd.dmg: map.bin \ - build/boot/boot.elf \ - build/kernel/kernel.elf \ - build/display/display.elf \ - build/hello/hello.elf \ - build/pgcd/pgcd.elf \ - build/router/router.elf \ - build/dhrystone/dhrystone.elf \ - build/gameoflife/gameoflife.elf +hdd/virt_hdd.dmg: map.bin \ + build/boot/boot.elf \ + build/kernel/kernel.elf \ + build/display/display.elf \ + build/hello/hello.elf \ + build/pgcd/pgcd.elf \ + build/router/router.elf \ + build/dhrystone/dhrystone.elf \ + build/gameoflife/gameoflife.elf \ + build/sort/sort.elf \ + build/transpose/transpose.elf + ### remove all content of virtual disk virt_hdd rm -rf hdd/virt_hdd/* @@ -162,4 +175,10 @@ ### drivers compilation +build/drivers/cma_driver.o: giet_drivers/cma_driver.c \ + giet_drivers/cma_driver.h \ + giet_config.h \ + $(MAP_XML) + $(CC) $(GIET_INCLUDE) $(CFLAGS) -c -o $@ $< + build/drivers/dma_driver.o: giet_drivers/dma_driver.c \ giet_drivers/dma_driver.h \ @@ -216,4 +235,10 @@ $(CC) $(GIET_INCLUDE) $(CFLAGS) -c -o $@ $< +build/drivers/rdk_driver.o: giet_drivers/rdk_driver.c \ + giet_drivers/rdk_driver.h \ + giet_config.h \ + $(MAP_XML) + $(CC) $(GIET_INCLUDE) $(CFLAGS) -c -o $@ $< + build/drivers/iob_driver.o: giet_drivers/iob_driver.c \ giet_drivers/iob_driver.h \ @@ -248,4 +273,10 @@ build/drivers/tty_driver.o: giet_drivers/tty_driver.c \ giet_drivers/tty_driver.h \ + giet_config.h \ + $(MAP_XML) + $(CC) $(GIET_INCLUDE) $(CFLAGS) -c -o $@ $< + +build/drivers/pic_driver.o: giet_drivers/pic_driver.c \ + giet_drivers/pic_driver.h \ giet_config.h \ $(MAP_XML) @@ -399,4 +430,12 @@ build/sort/main.o: sort/main.c + $(CC) $(USER_INCLUDE) $(CFLAGS) -c -o $@ $< + +### transpose compilation +build/transpose/transpose.elf: $(TRANSPOSE_OBJS) transpose/transpose.ld + $(LD) -o $@ -T transpose/transpose.ld $(TRANSPOSE_OBJS) + $(DU) -D $@ > $@.txt + +build/transpose/main.o: transpose/main.c $(CC) $(USER_INCLUDE) $(CFLAGS) -c -o $@ $< @@ -419,4 +458,5 @@ rm -rf build/dhrystone/* rm -rf build/sort/* + rm -rf build/transpose/* rm -rf build/map.bin rm -rf hdd/virt_hdd/* Index: /soft/giet_vm/display/main.c =================================================================== --- /soft/giet_vm/display/main.c (revision 294) +++ /soft/giet_vm/display/main.c (revision 295) @@ -1,3 +1,4 @@ -#include +#include "stdio.h" +#include "hard_config.h" #define NBLOCKS 32 // (128 * 128) / 512 @@ -7,11 +8,17 @@ __attribute__((constructor)) void main() { - int fd; - int blocks; - unsigned int ko; - unsigned int blocks_to_skip = 8*NBLOCKS; + int fd; + int blocks; + unsigned int ko; + unsigned int blocks_to_skip = 8*NBLOCKS; - giet_tty_printf("\nStarting task DISPLAY on processor %d at cycle %d\n", - giet_procid(), giet_proctime() ); + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< +#include "stdio.h" +#include "hard_config.h" #define NBLOCKS 32 @@ -8,11 +9,14 @@ __attribute__((constructor)) void main(void) { - unsigned int ko; - int blocks; - int fd; - unsigned int blocks_to_skip = 0; + int fd; + unsigned int blocks_to_skip = 0; + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< #include @@ -80,4 +79,5 @@ #include #include +#include #include #include @@ -874,5 +874,5 @@ _putx( curr->length ); _puts(" / vbase "); - _putl( curr->vbase ); + _putx( curr->vbase ); _puts(" / pbase "); _putl( curr->pbase ); @@ -894,7 +894,7 @@ boot_vspace_pt_build(vspace_id); - _puts("\n[BOOT] Page Table for vspace "); + _puts("\n[BOOT] Page Table for vspace \""); _puts( vspace[vspace_id].name ); - _puts(" completed at cycle "); + _puts("\" completed at cycle "); _putd( _get_proctime() ); _puts("\n"); @@ -1149,9 +1149,9 @@ mapping_task_t* task = _get_task_base(header); mapping_vobj_t* vobj = _get_vobj_base(header); - mapping_proc_t* proc = _get_proc_base(header); + mapping_periph_t* periph = _get_periph_base(header); mapping_irq_t* irq = _get_irq_base(header); unsigned int cluster_id; // cluster index in mapping_info - unsigned int proc_id; // processor index in mapping_info + unsigned int periph_id; // peripheral index in mapping_info unsigned int irq_id; // irq index in mapping_info unsigned int vspace_id; // vspace index in mapping_info @@ -1163,11 +1163,9 @@ // are reserved for the kernel (context switch) - unsigned int alloc_tty_channel = 0; // TTY channel allocator - unsigned int alloc_nic_channel = 0; // NIC channel allocator - unsigned int alloc_cma_channel = 0; // CMA channel allocator - unsigned int alloc_hba_channel = 0; // IOC channel allocator - unsigned int alloc_tim_channel[X_SIZE*Y_SIZE]; // user TIMER allocators - - if (NB_TTY_CHANNELS > 1) alloc_tty_channel++; + unsigned int alloc_tty_channel = 1; // TTY channel allocator + unsigned int alloc_nic_channel = 0; // NIC channel allocator + unsigned int alloc_cma_channel = 0; // CMA channel allocator + unsigned int alloc_hba_channel = 0; // HBA channel allocator + unsigned int alloc_tim_channel[X_SIZE*Y_SIZE]; // user TIMER allocators ///////////////////////////////////////////////////////////////////////// @@ -1198,13 +1196,6 @@ alloc_tim_channel[cluster_id] = NB_PROCS_MAX; - unsigned int lpid; // processor local index in cluster - unsigned int sched_vbase; // schedulers segment virtual base address - unsigned int sched_length; // schedulers segment length - unsigned int nprocs; // number of processors in cluster - - nprocs = cluster[cluster_id].procs; - // checking processors number - if ( nprocs > NB_PROCS_MAX ) + if ( cluster[cluster_id].procs > NB_PROCS_MAX ) { _puts("\n[BOOT ERROR] Too much processors in cluster["); @@ -1216,105 +1207,165 @@ } - // get scheduler array virtual base address and length - boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length ); - - // each processor scheduler requires 4 Kbytes - if ( sched_length < (nprocs<<12) ) - { - _puts("\n[BOOT ERROR] Schedulers segment too small in cluster["); - _putd( x ); - _puts(","); - _putd( y ); - _puts("]\n"); - _exit(); - } - - // loop on processors - for ( proc_id = cluster[cluster_id].proc_offset, lpid = 0 ; - proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs; - proc_id++, lpid++ ) - { - // current processor scheduler pointer : psched - static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12)); - - // set the schedulers pointers array - _schedulers[cluster_xy * NB_PROCS_MAX + lpid] = psched; + static_scheduler_t* psched; // schedulers array base address in cluster + + // no schedulers initialisation if nprocs == 0 + if ( cluster[cluster_id].procs > 0 ) + { + // get scheduler array virtual base address and length + unsigned int sched_vbase; // schedulers segment virtual base address + unsigned int sched_length; // schedulers segment length + boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length ); + + if ( sched_length < (cluster[cluster_id].procs<<12) ) // 4 Kbytes per scheduler + { + _puts("\n[BOOT ERROR] Schedulers segment too small in cluster["); + _putd( x ); + _puts(","); + _putd( y ); + _puts("]\n"); + _exit(); + } + + psched = (static_scheduler_t*)sched_vbase; + + // scan cluster peripherals to find the ICU/XCU + unsigned int found = 0; + for ( periph_id = cluster[cluster_id].periph_offset ; + periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs; + periph_id++ ) + { + if( (periph[periph_id].type == PERIPH_TYPE_XCU) || + (periph[periph_id].type == PERIPH_TYPE_ICU) ) + { + found = 1; + break; + } + } + if ( found == 0 ) + { + _puts("\n[BOOT ERROR] No ICU / XCU component in cluster["); + _putd( x ); + _puts(","); + _putd( y ); + _puts("]\n"); + _exit(); + } + + // loop on schedulers for default values initialisation + unsigned int lpid; + for ( lpid = 0 ; lpid < cluster[cluster_id].procs ; lpid++ ) + { + // set the schedulers pointers array + _schedulers[cluster_xy * NB_PROCS_MAX + lpid] = + (static_scheduler_t*)&psched[lpid]; #if BOOT_DEBUG_SCHED -_puts("\nProc_"); +_puts("\nProc["); _putd( x ); -_puts("_"); +_puts(","); _putd( y ); -_puts("_"); +_puts(","); _putd( lpid ); -_puts(" : scheduler virtual base address = "); -_putx( sched_vbase + (lpid<<12) ); -_puts("\n"); -#endif - - // initialise the "tasks" variable : default value is 0 - psched->tasks = 0; - - // initialise the "current" variable : default value is idle_task - psched->current = IDLE_TASK_INDEX; - - // initialise interrupt_vector with default value (valid bit = 0) - unsigned int slot; - for (slot = 0; slot < 32; slot++) psched->interrupt_vector[slot] = 0; - - // initialise interrupt vector with the IRQs actually allocated - for (irq_id = proc[proc_id].irq_offset; - irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs; - irq_id++) +_puts("] : scheduler virtual base address = "); +_putx( (unsigned int)&psched[lpid] ); +_puts("\n"); +#endif + // initialise the "tasks" and "current" variables default values + psched[lpid].tasks = 0; + psched[lpid].current = IDLE_TASK_INDEX; + + // initialise HWI / PTI / SWI vectors (valid bit = 0) + unsigned int slot; + for (slot = 0; slot < 32; slot++) + { + psched[lpid].hwi_vector[slot] = 0; + psched[lpid].pti_vector[slot] = 0; + psched[lpid].wti_vector[slot] = 0; + } + + // initializes the idle_task context in scheduler: + // - the SR slot is 0xFF03 because this task run in kernel mode. + // - it uses the page table of vspace[0] + // - it uses the kernel TTY terminal + // - slots containing addresses (SP, RA, EPC, PTAB, PTPR) + // must be re-initialised by kernel_parallel_init() + + psched[lpid].context[IDLE_TASK_INDEX][CTX_CR_ID] = 0; + psched[lpid].context[IDLE_TASK_INDEX][CTX_SR_ID] = 0xFF03; + psched[lpid].context[IDLE_TASK_INDEX][CTX_PTPR_ID] = _ptabs_paddr[0]>>13; + psched[lpid].context[IDLE_TASK_INDEX][CTX_PTAB_ID] = _ptabs_vaddr[0]; + psched[lpid].context[IDLE_TASK_INDEX][CTX_TTY_ID] = 0; + psched[lpid].context[IDLE_TASK_INDEX][CTX_LTID_ID] = IDLE_TASK_INDEX; + psched[lpid].context[IDLE_TASK_INDEX][CTX_VSID_ID] = 0; + psched[lpid].context[IDLE_TASK_INDEX][CTX_RUN_ID] = 1; + } + + + // loop on irqs for actual HWI / PTI / WTI vectors initialisation + for ( irq_id = periph[periph_id].irq_offset ; + irq_id < periph[periph_id].irq_offset + periph[periph_id].irqs ; + irq_id++ ) { - unsigned int type = irq[irq_id].type; - unsigned int icu_id = irq[irq_id].icuid; - unsigned int isr_id = irq[irq_id].isr; + unsigned int lpid = irq[irq_id].dstid; + unsigned int dstx = irq[irq_id].dstx; + unsigned int dsty = irq[irq_id].dsty; + if ( (dstx != x) || (dsty != y) ) + { + _puts("\n[BOOT ERROR] Bad IRQ cluster coordinates in cluster["); + _putd( x ); + _puts(","); + _putd( y ); + _puts("]\n - dstx = "); + _putd( dstx ); + _puts("\n - dsty = "); + _putd( dsty ); + _puts("\n - x = "); + _putd( x ); + _puts("\n - y = "); + _putd( y ); + _puts("\n"); + _exit(); + } + if ( lpid >= cluster[cluster_id].procs ) + { + _puts("\n[BOOT ERROR] Bad IRQ processor index in cluster["); + _putd( x ); + _puts(","); + _putd( y ); + _puts("]\n"); + _exit(); + } + unsigned int type = irq[irq_id].srctype; + unsigned int index = irq[irq_id].srcid; + unsigned int isr = irq[irq_id].isr; unsigned int channel = irq[irq_id].channel; - unsigned int value = ((isr_id & 0xFF) ) | - ((type & 0xFF) << 8) | + unsigned int entry = ((isr & 0xFFFF) ) | ((channel & 0x7FFF) << 16) | 0x80000000; // Valid entry - psched->interrupt_vector[icu_id] = value; + if (type == IRQ_TYPE_HWI) psched[lpid].hwi_vector[index] = entry; + else if (type == IRQ_TYPE_PTI) psched[lpid].pti_vector[index] = entry; + else if (type == IRQ_TYPE_WTI) psched[lpid].wti_vector[index] = entry; #if BOOT_DEBUG_SCHED -_puts("- IRQ : icu = "); -_putd(icu_id); -_puts(" / type = "); -_putd(type); +_puts("- IRQ : type = "); +_putd( type ); +_puts(" / index = "); +_putd( index ); _puts(" / isr = "); -_putd(isr_id); +_putd( isr ); _puts(" / channel = "); -_putd(channel); -_puts(" => vector_entry = "); -_putx( value ); -_puts("\n"); -#endif - } - - // initializes the idle_task context in scheduler: - // - the SR slot is 0xFF03 because this task run in kernel mode. - // - it uses the page table of vspace[0] - // - it uses the kernel TTY terminal - // - slots containing addresses (SP, RA, EPC, PTAB, PTPR) - // must be re-initialised by kernel_parallel_init() - - psched->context[IDLE_TASK_INDEX][CTX_CR_ID] = 0; - psched->context[IDLE_TASK_INDEX][CTX_SR_ID] = 0xFF03; - psched->context[IDLE_TASK_INDEX][CTX_PTPR_ID] = _ptabs_paddr[0]>>13; - psched->context[IDLE_TASK_INDEX][CTX_PTAB_ID] = _ptabs_vaddr[0]; - psched->context[IDLE_TASK_INDEX][CTX_TTY_ID] = 0; - psched->context[IDLE_TASK_INDEX][CTX_LTID_ID] = IDLE_TASK_INDEX; - psched->context[IDLE_TASK_INDEX][CTX_VSID_ID] = 0; - psched->context[IDLE_TASK_INDEX][CTX_RUN_ID] = 1; - - } // end for procs +_putd( channel ); +_puts("\n"); +#endif + + } // end for irqs + } // end if nprocs > 0 } // end for clusters /////////////////////////////////////////////////////////////////// - // Step 2 : loop on the vspaces and the tasks - // to initialise the schedulers and the task contexts. + // Step 2 : loop on the vspaces and the tasks to complete + // the schedulers and task contexts initialisation. for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) @@ -1329,9 +1380,9 @@ task_id++) { - - // compute the cluster coordinates + // compute the cluster coordinates & local processor index unsigned int x = cluster[task[task_id].clusterid].x; unsigned int y = cluster[task[task_id].clusterid].y; unsigned int cluster_xy = (x<= NB_TTY_CHANNELS) { - _puts("\n[BOOT ERROR] TTY index too large for task "); + _puts("\n[BOOT ERROR] TTY channel index too large for task "); _puts(task[task_id].name); _puts(" in vspace "); @@ -1373,7 +1426,10 @@ } ctx_tty = alloc_tty_channel; - if (NB_TTY_CHANNELS > 1) alloc_tty_channel++; - } + alloc_tty_channel++; + } + // ctx_nic : NIC channel global index provided by the global allocator + // Each channel is a private ressource: the number of + // requested channels cannot be larger than NB_NIC_CHANNELS. unsigned int ctx_nic = 0xFFFFFFFF; if (task[task_id].use_nic) @@ -1391,5 +1447,8 @@ alloc_nic_channel++; } + // ctx_cma : CMA channel global index provided by the global allocator + // Each channel is a private ressource: the number of + // requested channels cannot be larger than NB_NIC_CHANNELS. unsigned int ctx_cma = 0xFFFFFFFF; if (task[task_id].use_cma) @@ -1407,9 +1466,12 @@ alloc_cma_channel++; } + // ctx_hba : HBA channel global index provided by the global allocator + // Each channel is a private ressource: the number of + // requested channels cannot be larger than NB_NIC_CHANNELS. unsigned int ctx_hba = 0xFFFFFFFF; if (task[task_id].use_hba) { - if (alloc_hba_channel >= NB_HBA_CHANNELS) + if (alloc_hba_channel >= NB_IOC_CHANNELS) { _puts("\n[BOOT ERROR] IOC channel index too large for task "); @@ -1423,5 +1485,6 @@ alloc_hba_channel++; } - // ctx_tim : TIM local channel index provided by the cluster allocator + // ctx_tim : TIMER local channel index provided by the cluster allocator + // Each timer is a private ressource unsigned int ctx_tim = 0xFFFFFFFF; if (task[task_id].use_tim) @@ -1438,29 +1501,6 @@ _exit(); } - - // checking that there is an ISR_TIMER installed - unsigned int found = 0; - for ( irq_id = 0 ; irq_id < 32 ; irq_id++ ) - { - unsigned int entry = psched->interrupt_vector[irq_id]; - unsigned int isr = entry & 0x000000FF; - unsigned int channel = entry>>16; - if ( (isr == ISR_TIMER) && (channel == alloc_tim_channel[cluster_id]) ) - { - found = 1; - ctx_tim = alloc_tim_channel[cluster_id]; - alloc_tim_channel[cluster_id]++; - break; - } - } - if (!found) - { - _puts("\n[BOOT ERROR] No ISR_TIMER installed for task "); - _puts(task[task_id].name); - _puts(" in vspace "); - _puts(vspace[vspace_id].name); - _puts("\n"); - _exit(); - } + ctx_tim = alloc_tim_channel[cluster_id]; + alloc_tim_channel[cluster_id]++; } // ctx_epc : Get the virtual address of the memory location containing @@ -1520,7 +1560,11 @@ _puts("\nTask "); _putd( task_id ); -_puts(" allocated to processor "); -_putd( gpid ); -_puts("\n - ctx[LTID] = "); +_puts(" allocated to processor["); +_putd( x ) +_puts(","); +_putd( y ) +_puts(","); +_putd( lpid ) +_puts("]\n - ctx[LTID] = "); _putd( psched->context[ltid][CTX_LTID_ID] ); _puts("\n - ctx[SR] = "); @@ -1533,21 +1577,21 @@ _putx( psched->context[ltid][CTX_PTPR_ID] ); _puts("\n - ctx[TTY] = "); -_putd( psched->context[ltid][CTX_TTY_ID] ); +_putx( psched->context[ltid][CTX_TTY_ID] ); _puts("\n - ctx[NIC] = "); -_putd( psched->context[ltid][CTX_NIC_ID] ); +_putx( psched->context[ltid][CTX_NIC_ID] ); _puts("\n - ctx[CMA] = "); -_putd( psched->context[ltid][CTX_CMA_ID] ); +_putx( psched->context[ltid][CTX_CMA_ID] ); _puts("\n - ctx[IOC] = "); -_putd( psched->context[ltid][CTX_HBA_ID] ); +_putx( psched->context[ltid][CTX_HBA_ID] ); _puts("\n - ctx[TIM] = "); -_putd( psched->context[ltid][CTX_TIM_ID] ); +_putx( psched->context[ltid][CTX_TIM_ID] ); _puts("\n - ctx[PTAB] = "); _putx( psched->context[ltid][CTX_PTAB_ID] ); _puts("\n - ctx[GTID] = "); -_putd( psched->context[ltid][CTX_GTID_ID] ); +_putx( psched->context[ltid][CTX_GTID_ID] ); _puts("\n - ctx[VSID] = "); -_putd( psched->context[ltid][CTX_VSID_ID] ); +_putx( psched->context[ltid][CTX_VSID_ID] ); _puts("\n - ctx[TRDID] = "); -_putd( psched->context[ltid][CTX_TRDID_ID] ); +_putx( psched->context[ltid][CTX_TRDID_ID] ); _puts("\n"); #endif @@ -1565,5 +1609,5 @@ _ioc_init( 0 ); - int fd_id = _fat_open( IOC_BOOT_PA_MODE, + int fd_id = _fat_open( IOC_BOOT_MODE, "map.bin", 0 ); // no creation @@ -1586,5 +1630,5 @@ if ( offset ) nblocks++; - unsigned int ok = _fat_read( IOC_BOOT_PA_MODE, + unsigned int ok = _fat_read( IOC_BOOT_MODE, fd_id, (unsigned int*)( &seg_boot_mapping_base), @@ -1781,5 +1825,5 @@ // The "preloader.elf" file is not loaded, because it has been burned in the ROM. // The "boot.elf" file is not loaded, because it has been loaded by the preloader. -// It scans all vobjs defined in the map.bin data structure to collect +// This function scans all vobjs defined in the map.bin data structure to collect // all .elf files pathnames, and calls the load_one_elf_file() function to // load all loadable segments at the virtual address found in the .elf file. @@ -1813,11 +1857,11 @@ } - load_one_elf_file( IOC_BOOT_VA_MODE, + load_one_elf_file( IOC_BOOT_MODE, vobj[vobj_id].binpath, 0 ); // vspace 0 - _puts("\n[BOOT] File "); + _puts("\n[BOOT] File \""); _puts( vobj[vobj_id].binpath ); - _puts(" loaded at cycle "); + _puts("\" loaded at cycle "); _putd( _get_proctime() ); _puts("\n"); @@ -1852,11 +1896,11 @@ } - load_one_elf_file( IOC_BOOT_VA_MODE, + load_one_elf_file( IOC_BOOT_MODE, vobj[vobj_id].binpath, vspace_id ); - _puts("\n[BOOT] File "); + _puts("\n[BOOT] File \""); _puts( vobj[vobj_id].binpath ); - _puts(" loaded at cycle "); + _puts("\" loaded at cycle "); _putd( _get_proctime() ); _puts("\n"); @@ -1882,4 +1926,5 @@ mapping_coproc_t * coproc = _get_coproc_base(header); mapping_cp_port_t * cp_port = _get_cp_port_base(header); + mapping_irq_t * irq = _get_irq_base(header); unsigned int cluster_id; @@ -2001,4 +2046,5 @@ case PERIPH_TYPE_TTY: // vci_multi_tty component { + // nothing to do #if BOOT_DEBUG_PERI _puts("- TTY / channels = "); @@ -2025,4 +2071,44 @@ _puts("\n"); #endif + break; + } + case PERIPH_TYPE_PIC: // vci_iopic component + { + +#if BOOT_DEBUG_PERI +_puts("- PIC / channels = "); +_putd(channels); +_puts("\n"); +#endif + // scan all HWI IRQs defined in mapping for PIC component, + // and initialises addresses for WTI IRQs + for ( channel_id = periph[periph_id].irq_offset ; + channel_id < periph[periph_id].irq_offset + periph[periph_id].irqs ; + channel_id++ ) + { + unsigned int hwi_id = irq[channel_id].srcid; // HWI index in PIC + unsigned int wti_id = irq[channel_id].dstid; // WTI index in XCU + unsigned int x = irq[channel_id].dstx; // XCU X coordinate + unsigned int y = irq[channel_id].dsty; // XCU Y coordinate + unsigned int cluster = (x<name ); - _puts(" loaded at cycle "); + _puts("\" loaded at cycle "); _putd(_get_proctime()); _puts("\n"); @@ -2111,8 +2196,4 @@ // Building all page tables boot_pt_init(); - - _puts("\n[BOOT] Page Tables initialisation completed at cycle "); - _putd(_get_proctime()); - _puts("\n"); // Activating proc 0 MMU @@ -2134,5 +2215,5 @@ boot_schedulers_init(); - _puts("\n[BOOT] All schedulers initialised at cycle "); + _puts("\n[BOOT] Schedulers initialised at cycle "); _putd(_get_proctime()); _puts("\n"); @@ -2144,5 +2225,5 @@ boot_peripherals_init(); - _puts("\n[BOOT] All peripherals initialised at cycle "); + _puts("\n[BOOT] Non replicated peripherals initialised at cycle "); _putd(_get_proctime()); _puts("\n"); @@ -2151,25 +2232,23 @@ boot_elf_load(); - _puts("\n[BOOT] All ELF files loaded at cycle "); - _putd(_get_proctime()); - _puts("\n"); - // P0 starts all other processors - unsigned int x,y,p; - for (x = 0 ; x < X_SIZE ; x++) - { - for (y = 0 ; y < Y_SIZE ; y++) + unsigned int clusterid, p; + + for ( clusterid = 0 ; clusterid < X_SIZE*Y_SIZE ; clusterid++ ) + { + unsigned int nprocs = cluster[clusterid].procs; + unsigned int xdest = cluster[clusterid].x; + unsigned int ydest = cluster[clusterid].y; + unsigned int cluster_xy = (xdest< 0) && ((clusterid != 0) || (p != 0)) ) + { + _xcu_send_wti( cluster_xy, p, (unsigned int)boot_init ); } } } + } // end monoprocessor boot @@ -2186,37 +2265,8 @@ _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) ); _set_mmu_mode( 0xF ); - - _tty_get_lock( 0 ); - _puts("\n[BOOT] Processor["); - _putd( cluster_xy >> Y_WIDTH ); - _puts(","); - _putd( cluster_xy & ((1<> Y_WIDTH ); - _puts(","); - _putd( cluster_xy & ((1< 3) { - *dst++ = *src++; + *idst++ = *isrc++; size -= 4; } } - unsigned char * cdst = (unsigned char *) dst; - unsigned char * csrc = (unsigned char *) src; + unsigned char* cdst = (unsigned char*)dest; + unsigned char* csrc = (unsigned char*)source; /* byte-by-byte copy */ @@ -73,14 +73,44 @@ // Fill a byte string with a byte value. ////////////////////////////////////////////////////////////////////////////////// -inline void * _memset( void* dst, +inline void * _memset( void* dest, int value, unsigned int count ) { - char * a = (char *) dst; + // word-by-word copy + unsigned int* idst = dest; + unsigned int data = (((unsigned char)value) ) | + (((unsigned char)value) << 8) | + (((unsigned char)value) << 16) | + (((unsigned char)value) << 24) ; + + if ( ! ((unsigned int)idst & 3) ) + { + while ( count > 3 ) + { + *idst++ = data; + count -= 4; + } + } + + // byte-by-byte copy + unsigned char* cdst = dest; while (count--) { - *a++ = (char)value; - } - return dst; + *cdst++ = (unsigned char)value; + } + return dest; +} + +////////////////////////////////////////////////////////////////////////////////// +// This function implements an interactive break for debug. +// Execution continue when typing any character on TTY0. +// The "str" argument is supposed to indicate the break location. +////////////////////////////////////////////////////////////////////////////////// +inline void _break( char* string ) +{ + char byte; + + _printf("\n[GIET DEBUG] break from %s / continue ?\n", string ); + _getc( &byte ); } @@ -90,4 +120,13 @@ inline void _exit() { + unsigned int procid = _get_procid(); + unsigned int lpid = procid % NB_PROCS_MAX; + unsigned int cluster_xy = procid / NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< 0 ) + { + // test status register + while ( (_tty_get_register( 0, TTY_STATUS ) & 0x2) ); + + // write one byte + _tty_set_register( 0, TTY_WRITE, (unsigned int)string[n] ); + n++; + } +} + +/////////////////////////////////////////////////////////////////////////////////// +// Display a 32 bits unsigned int as an hexadecimal string on TTY0. +/////////////////////////////////////////////////////////////////////////////////// +void _putx( unsigned int val ) { static const char HexaTab[] = "0123456789ABCDEF"; @@ -368,11 +519,11 @@ val = val >> 4; } - _puts(buf); -} - -/////////////////////////////////////////////////////////////////////////////////// -// Display a 64 bits unsigned long as an hexadecimal string on TTY0 -/////////////////////////////////////////////////////////////////////////////////// -void _putl(unsigned long long val) + _puts( buf ); +} + +/////////////////////////////////////////////////////////////////////////////////// +// Display a 64 bits unsigned long as an hexadecimal string on TTY0. +/////////////////////////////////////////////////////////////////////////////////// +void _putl( unsigned long long val ) { static const char HexaTab[] = "0123456789ABCDEF"; @@ -389,11 +540,11 @@ val = val >> 4; } - _puts(buf); -} - -/////////////////////////////////////////////////////////////////////////////////// -// Display a 32 bits unsigned int as a decimal string on TTY0 -/////////////////////////////////////////////////////////////////////////////////// -void _putd(unsigned int val) + _puts( buf ); +} + +/////////////////////////////////////////////////////////////////////////////////// +// Display a 32 bits unsigned int as a decimal string on TTY0. +/////////////////////////////////////////////////////////////////////////////////// +void _putd( unsigned int val ) { static const char DecTab[] = "0123456789"; @@ -414,5 +565,180 @@ val /= 10; } - _puts(&buf[first]); + _puts( &buf[first] ); +} + +/////////////////////////////////////////////////////////////////////////////////// +// Display a format on TTY0. +// To provide an atomic display, this function takes the lock protecting +// exclusive access to TTY0, entering a critical section until the lock +// is released. +// Only a limited number of formats are supported: +// - %d : 32 bits signed decimal +// - %u : 32 bits unsigned decimal +// - %x : 32 bits unsigned hexa +// - %l : 64 bits unsigned hexa +// - %c : char +// - %s : string +/////////////////////////////////////////////////////////////////////////////////// +void _printf( char * format, ... ) +{ + va_list ap; + va_start(ap, format); + unsigned int save_sr; // used to save the SR value in critical section + + // get TTY0 lock + _tty_get_lock( 0, &save_sr ); + +printf_text: + + while (*format) + { + unsigned int i; + for (i = 0 ; format[i] && (format[i] != '%') ; i++); + if (i) + { + if ( _tty_write( format, i, 0 ) != i ) goto return_error; + format += i; + } + if (*format == '%') + { + format++; + goto printf_arguments; + } + } + + // release TTY0 lock + _tty_release_lock( 0, &save_sr ); + + va_end(ap); + return; + +printf_arguments: + + { + char buf[20]; + char * pbuf; + unsigned int len = 0; + static const char HexaTab[] = "0123456789ABCDEF"; + unsigned int i; + + switch (*format++) + { + case ('c'): /* char conversion */ + { + int val = va_arg( ap, int ); + len = 1; + buf[0] = val; + pbuf = &buf[0]; + break; + } + case ('d'): /* 32 bits decimal signed */ + { + int val = va_arg( ap, int ); + if (val < 0) + { + val = -val; + if ( _tty_write( "-" , 1, 0 ) != 1 ) goto return_error; + } + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('u'): /* 32 bits decimal unsigned */ + { + unsigned int val = va_arg( ap, unsigned int ); + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('x'): /* 32 bits hexadecimal unsigned */ + { + unsigned int val = va_arg( ap, unsigned int ); + if ( _tty_write( "0x" , 2, 0 ) != 2 ) goto return_error; + for(i = 0; i < 8; i++) + { + buf[7 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[7 - i]; + break; + } + case ('l'): /* 64 bits hexadecimal unsigned */ + { + unsigned long long val = va_arg( ap, unsigned long long ); + if ( _tty_write( "0x" , 2, 0 ) != 2 ) goto return_error; + for(i = 0; i < 16; i++) + { + buf[15 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[15 - i]; + break; + } + case ('s'): /* string */ + { + char* str = va_arg( ap, char* ); + while (str[len]) + { + len++; + } + pbuf = str; + break; + } + default: + goto return_error; + } + + if ( _tty_write( pbuf, len, 0 ) != len ) goto return_error; + + goto printf_text; + } + +return_error: + + { + unsigned int procid = _get_procid(); + unsigned int lpid = procid % NB_PROCS_MAX; + unsigned int cluster_xy = procid / NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<pt1[ix1] & PTE_V) == 0) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in iommu_add_pte2 function\n"); - _puts("the IOMMU PT1 entry is not mapped / ix1 = "); - _putx( ix1 ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in iommu_add_pte2() : " + "IOMMU PT1 entry not mapped / ix1 = %d\n", ix1 ); _exit(); } @@ -63,5 +58,7 @@ // _iommu_inval_pte2() ////////////////////////////////////////////////////////////////////////////// -void _iommu_inval_pte2(unsigned int ix1, unsigned int ix2) { +void _iommu_inval_pte2( unsigned int ix1, + unsigned int ix2 ) +{ unsigned int ptba; unsigned int * pt_flags; @@ -73,8 +70,6 @@ if ((pt->pt1[ix1] & PTE_V) == 0) { - _puts("\n[GIET ERROR] in iommu_inval_pte2 function\n"); - _puts("the IOMMU PT1 entry is not mapped / ix1 = "); - _putx( ix1 ); - _puts("\n"); + _printf("\n[GIET ERROR] in iommu_inval_pte2() " + "IOMMU PT1 entry not mapped / ix1 = %d\n", ix1 ); _exit(); } @@ -95,5 +90,5 @@ unsigned int vpn, unsigned int* ppn, - unsigned int* flags) + unsigned int* flags ) { unsigned long long ptba; Index: /soft/giet_vm/giet_config.h =================================================================== --- /soft/giet_vm/giet_config.h (revision 294) +++ /soft/giet_vm/giet_config.h (revision 295) @@ -23,8 +23,10 @@ #define GIET_DEBUG_INIT 0 /* trace parallel kernel initialisation */ - #define GIET_DEBUG_FAT 0 /* trace fat accesses */ -#define GIET_DEBUG_SWITCH 0 /* trace context switchs */ +#define GIET_DEBUG_SWITCH 0 /* trace context switchs */ +#define GIET_DEBUG_IRQS 0 /* trace interrupts */ #define GIET_DEBUG_IOC_DRIVER 0 /* trace IOC accesses */ +#define GIET_DEBUG_BDV_DRIVER 0 /* trace BDV accesses */ +#define GIET_DEBUG_TTY_DRIVER 0 /* trace TTY accesses */ #define GIET_DEBUG_DMA_DRIVER 0 /* trace DMA accesses */ #define GIET_DEBUG_FBF_DRIVER 0 /* trace FBF accesses */ @@ -34,11 +36,9 @@ /* software parameters */ -#define GIET_IDLE_TASK_PERIOD 10000000 /* Idle Task message period */ -#define GIET_IDLE_TASK_VERBOSITY 1 - +#define GIET_IDLE_TASK_PERIOD 0xFFFFFFFF /* Idle Task message period */ #define GIET_MAX_ELF_FILES 20 /* max .elf files loaded by boot-loader */ #define GIET_OPEN_FILES_MAX 16 /* max simultaneously open files */ #define GIET_NB_VSPACE_MAX 64 /* max number of virtual spaces */ -#define GIET_TICK_VALUE 100000 /* context switch period (number of cycles) */ +#define GIET_TICK_VALUE 0x8000 /* context switch period (number of cycles) */ #define GIET_USE_IOMMU 0 /* IOMMU activated when non zero */ #define GIET_NO_HARD_CC 0 /* No hard cache coherence when non zero */ Index: /soft/giet_vm/giet_drivers/bdv_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/bdv_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/bdv_driver.c (revision 295) @@ -10,30 +10,24 @@ // a single channel, block oriented, external storage contrÃŽler. // -// It can exist only one block-device controler in the architecture. -// -// The _bdv_read() and _bdv_write() functions use the _bdv_access() function, -// that is always blocking, but can be called in 4 modes: -// -// - In BOOT_PA mode, the _bdv_access() function uses a polling policy on the -// IOC_STATUS register to detect transfer completion, as hardware interrupts -// are not activated. This mode is used by the boot code to load the map.bin -// file into memory. -// -// - In BOOT_VA mode, the _bdv_access() function uses a polling policy on -// IOC_STATUS register to detect transfer completion. This mode is used by -// the boot code to load the various .elf files into memory. -// -// - In KERNEL mode, the _bdv_access() function uses a descheduling strategy: +// The _bdv_read() and _bdv_write() functions are always blocking. +// They can be called in 3 modes: +// +// - In BOOT mode, these functions use a polling policy on the BDV STATUS +// register to detect transfer completion, as interrupts are not activated. +// This mode is used by the boot code to load the map.bin file into memory +// (before MMU activation), or to load the .elf files (after MMU activation). +// +// - In KERNEL mode, these functions use a descheduling strategy: // The ISR executed when transfer completes should restart the calling task. -// There is no checking of user access right to the memory buffer. This mode -// must be used to access IOC, for an "open" system call. -// -// - In USER mode, the _bdv_access() function uses a descheduling strategy: +// There is no checking of user access right to the memory buffer. +// This mode must be used, for an "open" system call. +// +// - In USER mode, these functions use a descheduling strategy: // The ISR executed when transfer completes should restart the calling task, // The user access right to the memory buffer must be checked. -// This mode must be used to access IOC, for a "read/write" system call. +// This mode must be used for a "read/write" system call. // // As the BDV component can be used by several programs running in parallel, -// the _ioc_lock variable guaranties exclusive access to the device. The +// the _bdv_lock variable guaranties exclusive access to the device. The // _bdv_read() and _bdv_write() functions use atomic LL/SC to get the lock. // @@ -47,11 +41,21 @@ // if the IOMMU is not activated. // An error code is returned if these conditions are not verified. -/////////////////////////////////////////////////////////////////////////////////// -// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file. +// +// The "seg_ioc_base" must be defined in giet_vsegs.ld file. +/////////////////////////////////////////////////////////////////////////////////// +// Implementation notes: +// +// 1. In order to share code, the two _bdv_read() and _bdv_write() functions +// call the same _bdv_access() function. +// +// 2. All accesses to BDV registers are done by the two +// _bdv_set_register() and _bdv_get_register() low-level functions, +// that are handling virtual / physical extended addressing. /////////////////////////////////////////////////////////////////////////////////// #include +#include +#include #include -#include #include #include @@ -59,5 +63,33 @@ /////////////////////////////////////////////////////////////////////////////// -// _bdv_access() +// BDV global variables +/////////////////////////////////////////////////////////////////////////////// + +#define in_unckdata __attribute__((section (".unckdata"))) + +in_unckdata unsigned int _bdv_lock = 0; +in_unckdata volatile unsigned int _bdv_status = 0; +in_unckdata volatile unsigned int _bdv_gtid; + +/////////////////////////////////////////////////////////////////////////////// +// This low_level function returns the value contained in register (index). +/////////////////////////////////////////////////////////////////////////////// +unsigned int _bdv_get_register( unsigned int index ) +{ + unsigned int* vaddr = (unsigned int*)&seg_ioc_base + index; + return _io_extended_read( vaddr ); +} + +/////////////////////////////////////////////////////////////////////////////// +// This low-level function set a new value in register (index). +/////////////////////////////////////////////////////////////////////////////// +void _bdv_set_register( unsigned int index, + unsigned int value ) +{ + unsigned int* vaddr = (unsigned int*)&seg_ioc_base + index; + _io_extended_write( vaddr, value ); +} + +/////////////////////////////////////////////////////////////////////////////// // This function transfer data between a memory buffer and the block device. // The buffer lentgth is (count*block_size) bytes. @@ -70,62 +102,52 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -static unsigned int _bdv_access( unsigned int to_mem, - unsigned int mode, - unsigned int lba, - paddr_t buf_paddr, - unsigned int count) -{ - -#if GIET_DEBUG_IOC_DRIVER -_tty_get_lock( 0 ); -_puts("\n[IOC DEBUG] Enter _bdv_access() at cycle "); -_putd( _get_proctime() ); -_puts(" for processor "); -_putd( _get_procid() ); -_puts("\n - mode = "); -_putd( mode ); -_puts("\n - paddr = "); -_putx( buf_paddr ); -_puts("\n - sectors = "); -_putd( count ); -_puts("\n - lba = "); -_putx( lba ); -_puts("\n"); -_tty_release_lock( 0 ); +static unsigned int _bdv_access( unsigned int to_mem, + unsigned int mode, + unsigned int lba, + unsigned long long buf_paddr, + unsigned int count) +{ + +#if GIET_DEBUG_BDV_DRIVER +unsigned int procid = _get_procid(); +unsigned int cxy = procid / NB_PROCS_MAX; +unsigned int lpid = procid % NB_PROCS_MAX; +unsigned int x = cxy >> Y_WIDTH; +unsigned int y = cxy & ((1<>32); - ioc_address[BLOCK_DEVICE_COUNT] = count; - ioc_address[BLOCK_DEVICE_LBA] = lba; - - // There are two policies for transfer completion - // detection, depending on the mode argument: - - if ( (mode == IOC_BOOT_PA_MODE) || // We poll directly the IOC_STATUS register - (mode == IOC_BOOT_VA_MODE) ) // as IRQs are masked. + unsigned int error = 0; + + // get the lock protecting BDV + _get_lock(&_bdv_lock); + + // set device registers + _bdv_set_register( BLOCK_DEVICE_BUFFER , (unsigned int)buf_paddr ); + _bdv_set_register( BLOCK_DEVICE_BUFFER_EXT, (unsigned int)(buf_paddr>>32) ); + _bdv_set_register( BLOCK_DEVICE_COUNT , count ); + _bdv_set_register( BLOCK_DEVICE_LBA , lba ); + + // In BOOT mode, we launch transfer, and poll the BDV_STATUS + // register because IRQs are masked. + if ( mode == IOC_BOOT_MODE ) { // Launch transfert - if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE; - else ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ; + if (to_mem == 0) _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_WRITE ); + else _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_READ ); unsigned int status; do { - if ( _bdv_get_status( 0, &status ) ) return 1; - -#if GIET_DEBUG_IOC_DRIVER -_tty_get_lock( 0 ); -_puts("\n[IOC DEBUG] _bdv_access() : ... waiting on IOC_STATUS register ...\n"); -_tty_release_lock( 0 ); + status = _bdv_get_register( BLOCK_DEVICE_STATUS ); + +#if GIET_DEBUG_BDV_DRIVER +_printf("\n[BDV DEBUG] _bdv_access() : ... waiting on BDV_STATUS register ...\n"); #endif } @@ -133,5 +155,5 @@ (status != BLOCK_DEVICE_READ_ERROR) && (status != BLOCK_DEVICE_WRITE_SUCCESS) && - (status != BLOCK_DEVICE_WRITE_ERROR) ); + (status != BLOCK_DEVICE_WRITE_ERROR) ); // busy waiting // analyse status @@ -140,49 +162,53 @@ // release lock - _release_lock(&_ioc_lock); + _release_lock(&_bdv_lock); } - else // in USER or KERNEL mode, we deschedule the task. - // When the task is rescheduled by the ISR, we reset - // the _ioc_status variable, and release the lock + // in USER or KERNEL mode, we deschedule the task. + // When the task is rescheduled, we check the _bdv_status variable, + // and release the lock. + // We need a critical section, because we must reset the RUN bit + // before to launch the transfer, and we don't want to be descheduled + // between these two operations. + else { - // We need a critical section, because we must reset the RUN bit - // before to launch the transfer, and we want to avoid to be descheduled - // between these two operations. - - // Enter critical section - _it_disable(); + unsigned int save_sr; + unsigned int ltid = _get_current_task_id(); + unsigned int gpid = _get_procid(); + + // activates BDV interrupts + _bdv_set_register( BLOCK_DEVICE_IRQ_ENABLE, 1 ); + + // set the _bdv_status variable + _bdv_status = BLOCK_DEVICE_BUSY; + + // enters critical section + _it_disable( &save_sr ); - // set _ioc_gtid and reset runnable - unsigned int ltid = _get_proc_task_id(); - unsigned int pid = _get_procid(); - _ioc_gtid = (pid<<16) + ltid; - _set_task_slot( pid, ltid, CTX_RUN_ID, 0 ); + // set _bdv_gtid and reset runnable + _bdv_gtid = (gpid<<16) + ltid; + _set_task_slot( gpid, ltid, CTX_RUN_ID, 0 ); - // Launch transfert - if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE; - else ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ; + // launch transfer + if (to_mem == 0) _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_WRITE ); + else _bdv_set_register( BLOCK_DEVICE_OP, BLOCK_DEVICE_READ ); // deschedule task _ctx_switch(); + // restore SR + _it_restore( &save_sr ); + // analyse status - error = ( (_ioc_status == BLOCK_DEVICE_READ_ERROR) || - (_ioc_status == BLOCK_DEVICE_WRITE_ERROR) ); - - // reset _ioc_status and release lock - _ioc_status = BLOCK_DEVICE_IDLE; - _release_lock(&_ioc_lock); + error = ( (_bdv_status == BLOCK_DEVICE_READ_ERROR) || + (_bdv_status == BLOCK_DEVICE_WRITE_ERROR) ); + + // reset _bdv_status and release lock + _bdv_status = BLOCK_DEVICE_IDLE; + _release_lock(&_bdv_lock); } -#if GIET_DEBUG_IOC_DRIVER -_tty_get_lock( 0 ); -_puts("\n[IOC DEBUG] _bdv_access completed at cycle "); -_putd( _get_proctime() ); -_puts(" for processor "); -_putd( _get_procid() ); -_puts(" : error = "); -_putd( (unsigned int)error ); -_puts("\n"); -_tty_release_lock( 0 ); +#if GIET_DEBUG_BDV_DRIVER +_printf("\n[BDV DEBUG] Processor[%d,%d,%d] exit _bdv_access() at cycle %d\n", + x, y, lpid, _get_proctime() ); #endif @@ -191,35 +217,20 @@ /////////////////////////////////////////////////////////////////////////////// -// _bdv_init() -// This function cheks block size, and activates the IOC interrupts. +// This function cheks block size, and desactivates the interrupts. // Return 0 for success, > 0 if error /////////////////////////////////////////////////////////////////////////////// -unsigned int _bdv_init( unsigned int channel ) -{ - volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base ; - - if ( ioc_address[BLOCK_DEVICE_BLOCK_SIZE] != 512 ) +unsigned int _bdv_init() +{ + if ( _bdv_get_register( BLOCK_DEVICE_BLOCK_SIZE ) != 512 ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _bdv_init() : block size must be 512 bytes\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _bdv_init() : block size must be 512 bytes\n"); return 1; } - if ( channel != 0 ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _bdv_init() : illegal channel\n"); - _tty_release_lock( 0 ); - - return 1; - } - - ioc_address[BLOCK_DEVICE_IRQ_ENABLE] = 1; + _bdv_set_register( BLOCK_DEVICE_IRQ_ENABLE, 0 ); return 0; } /////////////////////////////////////////////////////////////////////////////// -// _bdv_read() // Transfer data from the block device to a memory buffer. // - mode : BOOT / KERNEL / USER @@ -229,8 +240,8 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -unsigned int _bdv_read( unsigned int mode, - unsigned int lba, - paddr_t buffer, - unsigned int count) +unsigned int _bdv_read( unsigned int mode, + unsigned int lba, + unsigned long long buffer, + unsigned int count) { return _bdv_access( 1, // read access @@ -242,5 +253,4 @@ /////////////////////////////////////////////////////////////////////////////// -// _bdv_write() // Transfer data from a memory buffer to the block device. // - mode : BOOT / KERNEL / USER @@ -250,8 +260,8 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -unsigned int _bdv_write( unsigned int mode, - unsigned int lba, - paddr_t buffer, - unsigned int count ) +unsigned int _bdv_write( unsigned int mode, + unsigned int lba, + unsigned long long buffer, + unsigned int count ) { return _bdv_access( 0, // write access @@ -263,38 +273,84 @@ /////////////////////////////////////////////////////////////////////////////// -// _bdv_get_status() -// This function returns in the status variable, the transfert status, and -// acknowledge the IRQ if the IOC controler is not busy. -// Returns 0 if success, > 0 if error -/////////////////////////////////////////////////////////////////////////////// -unsigned int _bdv_get_status( unsigned int channel, - unsigned int* status ) -{ - if ( channel != 0 ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _bdv_get_status() : illegal channel\n"); - _tty_release_lock( 0 ); - - return 1; - } - - // get IOC base address - volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base; - *status = ioc_address[BLOCK_DEVICE_STATUS]; - - return 0; -} - -/////////////////////////////////////////////////////////////////////////////// -// _bdv_get_block_size() -// This function returns the block_size with which the IOC has been configured. -/////////////////////////////////////////////////////////////////////////////// -unsigned int _bdv_get_block_size() -{ - // get IOC base address - volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base; - - return ioc_address[BLOCK_DEVICE_BLOCK_SIZE]; +// Returns device status. +/////////////////////////////////////////////////////////////////////////////// +unsigned int _bdv_get_status() +{ + return _bdv_get_register( BLOCK_DEVICE_STATUS ); +} + +/////////////////////////////////////////////////////////////////////////////// +// Returns block size. +/////////////////////////////////////////////////////////////////////////////// +unsigned int _bdv_get_block_size() +{ + return _bdv_get_register( BLOCK_DEVICE_BLOCK_SIZE ); +} + +/////////////////////////////////////////////////////////////////////////////////// +// This ISR save the status, acknowledge the IRQ, +// and activates the task waiting on IO transfer. +// It can be an HWI or a SWI. +// +// TODO the _set_task_slot access should be replaced by an atomic LL/SC +// when the CTX_RUN bool will be replaced by a bit_vector. +/////////////////////////////////////////////////////////////////////////////////// +void _bdv_isr( unsigned int irq_type, // HWI / WTI + unsigned int irq_id, // index returned by ICU + unsigned int channel ) // unused +{ + unsigned int procid = _get_procid(); + unsigned int cluster_xy = procid / NB_PROCS_MAX; + unsigned int lpid = procid % NB_PROCS_MAX; + + // acknowledge WTI in local XCU if required + unsigned int value; + if ( irq_type == IRQ_TYPE_WTI ) _xcu_get_wti_value( cluster_xy, irq_id, &value ); + + // save status in _bdv_status variable and reset IRQ + _bdv_status = _bdv_get_register( BLOCK_DEVICE_STATUS ); + + // identify task waiting on BDV + unsigned int rprocid = _bdv_gtid>>16; + unsigned int ltid = _bdv_gtid & 0xFFFF; + unsigned int remote_xy = rprocid / NB_PROCS_MAX; + +#if GIET_DEBUG_IRQS // we don't take the TTY lock to avoid deadlock +unsigned int x = cluster_xy >> Y_WIDTH; +unsigned int y = cluster_xy & ((1<> Y_WIDTH; +unsigned int ry = remote_xy & ((1< +#ifndef _GIET_BDV_DRIVER_H_ +#define _GIET_BDV_DRIVER_H_ /////////////////////////////////////////////////////////////////////////////////// -// BDV access functions and variables (vci_block_device) +// BDV global variables /////////////////////////////////////////////////////////////////////////////////// -extern unsigned int _bdv_init( unsigned int channel ); +extern unsigned int _bdv_lock; // BDV is a shared ressource +extern volatile unsigned int _bdv_status; // required for IRQ signaling +extern volatile unsigned int _bdv_gtid; // descheduled task id = gpid<<16 + ltid -extern unsigned int _bdv_write( unsigned int mode, - unsigned int lba, - paddr_t buffer, - unsigned int count ); +/////////////////////////////////////////////////////////////////////////////////// +// BDV registers, operations and status values +/////////////////////////////////////////////////////////////////////////////////// -extern unsigned int _bdv_read( unsigned int mode, - unsigned int lba, - paddr_t buffer, - unsigned int count ); +enum BDV_registers +{ + BLOCK_DEVICE_BUFFER, + BLOCK_DEVICE_LBA, + BLOCK_DEVICE_COUNT, + BLOCK_DEVICE_OP, + BLOCK_DEVICE_STATUS, + BLOCK_DEVICE_IRQ_ENABLE, + BLOCK_DEVICE_SIZE, + BLOCK_DEVICE_BLOCK_SIZE, + BLOCK_DEVICE_BUFFER_EXT, +}; -extern unsigned int _bdv_get_status( unsigned int channel, - unsigned int* status ); +enum BDV_operations +{ + BLOCK_DEVICE_NOOP, + BLOCK_DEVICE_READ, + BLOCK_DEVICE_WRITE, +}; + +enum BDV_status +{ + BLOCK_DEVICE_IDLE, + BLOCK_DEVICE_BUSY, + BLOCK_DEVICE_READ_SUCCESS, + BLOCK_DEVICE_WRITE_SUCCESS, + BLOCK_DEVICE_READ_ERROR, + BLOCK_DEVICE_WRITE_ERROR, + BLOCK_DEVICE_ERROR, +}; + +/////////////////////////////////////////////////////////////////////////////////// +// BDV access functions (vci_block_device) +/////////////////////////////////////////////////////////////////////////////////// + +extern unsigned int _bdv_init(); + +extern unsigned int _bdv_write( unsigned int mode, + unsigned int lba, + unsigned long long buffer, + unsigned int count ); + +extern unsigned int _bdv_read( unsigned int mode, + unsigned int lba, + unsigned long long buffer, + unsigned int count ); + +extern unsigned int _bdv_get_status(); extern unsigned int _bdv_get_block_size(); + +extern void _bdv_isr( unsigned irq_type, + unsigned irq_id, + unsigned channel ); /////////////////////////////////////////////////////////////////////////////////// Index: /soft/giet_vm/giet_drivers/cma_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/cma_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/cma_driver.h (revision 295) @@ -29,4 +29,21 @@ }; +/////////////////////////////////////////////////////////////////////////////////// +// CMA (vci_chbuf_dma) low-level access functions +/////////////////////////////////////////////////////////////////////////////////// + +extern unsigned int _cma_get_register( unsigned int channel, + unsigned int index ); + +extern void _cma_set_register( unsigned int channel, + unsigned int index, + unsigned int value ); + +extern void _cma_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ); + +/////////////////////////////////////////////////////////////////////////////////// + #endif Index: /soft/giet_vm/giet_drivers/dma_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/dma_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/dma_driver.c (revision 295) @@ -196,4 +196,6 @@ unsigned int procid = _get_procid(); unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= NB_CMA_CHANNELS ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : CMA channel index too large\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : CMA channel index too large\n"); return 1; } @@ -154,7 +154,5 @@ if ( sizeof(fb_cma_channel_t) != 32 ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel size\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel size\n"); return 1; } @@ -163,7 +161,5 @@ if ( (unsigned int)(&_fb_cma_channel[channel_id]) & 0x1F ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel alignment\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : bad fb_cma_channel alignment\n"); return 1; } @@ -172,7 +168,5 @@ if ( ((unsigned int)vbase0 & 0x3) || ((unsigned int)vbase1 & 0x3) || (length & 0x3) ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer not word aligned\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer not word aligned\n"); return 1; } @@ -189,7 +183,5 @@ if (ko) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : frame buffer unmapped\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : frame buffer unmapped\n"); return 1; } @@ -204,14 +196,10 @@ if (ko) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 0 unmapped\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer 0 unmapped\n"); return 1; } if ((flags & PTE_U) == 0) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _fb_cma_init() : user buffer 0 not in user space\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _fb_cma_init() : user buffer 0 not in user space\n"); return 1; } @@ -226,14 +214,10 @@ if (ko) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : user buffer 1 unmapped\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : user buffer 1 unmapped\n"); return 1; } if ((flags & PTE_U) == 0) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _fb_cma_init() : user buffer 1 not in user space\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _fb_cma_init() : user buffer 1 not in user space\n"); return 1; } @@ -251,7 +235,5 @@ if (ko) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : channel descriptor unmapped\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_init() : channel descriptor unmapped\n"); return 1; } @@ -262,16 +244,13 @@ #if GIET_DEBUG_FBF_DRIVER -_tty_get_lock( 0 ); -_puts("\n[CMA DEBUG] fb_cma_init()"); -_puts("\n - fbf pbase = "); -_putl( _fb_cma_channel[channel_id].fbf ); -_puts("\n - buf0 pbase = "); -_putl( _fb_cma_channel[channel_id].buf0 ); -_puts("\n - buf1 pbase = "); -_putl( _fb_cma_channel[channel_id].buf1 ); -_puts("\n - channel pbase = "); -_putl( _fb_cma_desc_paddr[channel_id] ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[CMA DEBUG] enters _fb_cma_init()\n" + " - fbf pbase = %l\n" + " - buf0 pbase = %l\n" + " - buf1 pbase = %l\n" + " - channel pbase = %l\n" + _fb_cma_channel[channel_id].fbf, + _fb_cma_channel[channel_id].buf0, + _fb_cma_channel[channel_id].buf1, + _fb_cma_desc_paddr[channel_id] ); #endif @@ -283,28 +262,21 @@ // CMA channel activation - unsigned int* cma_vbase = (unsigned int *)&seg_cma_base; - unsigned int offset = channel_id * CHBUF_CHANNEL_SPAN; - - cma_vbase[offset + CHBUF_SRC_DESC] = (unsigned int)(desc_paddr & 0xFFFFFFFF); - cma_vbase[offset + CHBUF_SRC_EXT] = (unsigned int)(desc_paddr >> 32); - cma_vbase[offset + CHBUF_SRC_NBUFS] = 2; - cma_vbase[offset + CHBUF_DST_DESC] = (unsigned int)(desc_paddr & 0xFFFFFFFF) + 16; - cma_vbase[offset + CHBUF_DST_EXT] = (unsigned int)(desc_paddr >> 32); - cma_vbase[offset + CHBUF_DST_NBUFS] = 1; - cma_vbase[offset + CHBUF_BUF_SIZE] = length; - cma_vbase[offset + CHBUF_PERIOD] = 300; - cma_vbase[offset + CHBUF_RUN] = 1; - + _cma_set_register( channel_id, CHBUF_SRC_DESC , (unsigned int)(desc_paddr & 0xFFFFFFFF) ); + _cma_set_register( channel_id, CHBUF_SRC_EXT , (unsigned int)(desc_paddr >> 32) ); + _cma_set_register( channel_id, CHBUF_SRC_NBUFS, 2 ); + _cma_set_register( channel_id, CHBUF_DST_DESC , (unsigned int)(desc_paddr & 0xFFFFFFFF) + 16 ); + _cma_set_register( channel_id, CHBUF_DST_EXT , (unsigned int)(desc_paddr >> 32) ); + _cma_set_register( channel_id, CHBUF_DST_NBUFS, 1 ); + _cma_set_register( channel_id, CHBUF_BUF_SIZE , length ); + _cma_set_register( channel_id, CHBUF_PERIOD , 300 ); + _cma_set_register( channel_id, CHBUF_RUN , 1 ); return 0; #else - - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_init() : no CMA channel allocated\n"); - _tty_release_lock( 0 ); - + _printf("\n[GIET ERROR] in _fb_cma_init() : no CMA channel allocated\n"); return 1; #endif } + //////////////////////////////////////////////////////////////////////////////////// // _fb_cma_write() @@ -330,5 +302,4 @@ volatile paddr_t buf_paddr; - unsigned int buf_length; unsigned int full = 1; @@ -339,11 +310,6 @@ #if GIET_DEBUG_FBF_DRIVER -_tty_get_lock( 0 ); -_puts("\n[CMA DEBUG] fb_cma_write() for CMA channel "); -_putd( channel_id ); -_puts(" / buf_id = "); -_putd( buffer_id ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[CMA DEBUG] _fb_cma_write() for CMA channel %d / bufid = %d at cycle %d\n", + channel_id, buffer_id, _get_proctime() ); #endif @@ -357,5 +323,5 @@ // INVAL L1 cache for the channel descriptor, - _dcache_buf_invalidate( &_fb_cma_channel[channel_id], 32 ); + _dcache_buf_invalidate( (void*)&_fb_cma_channel[channel_id], 32 ); } @@ -367,15 +333,4 @@ count++; if ( count == 10 ) _exit(); - -#if GIET_DEBUG_FBF_DRIVER -_tty_get_lock( 0 ); -_puts(" - buffer descriptor = "); -_putl( buf_paddr ); -_puts(" at cycle "); -_putd( _get_proctime() ); -_puts("\n"); -_tty_release_lock( 0 ); -#endif - } @@ -408,7 +363,5 @@ #else - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_channel() : no CMA channel allocated\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_channel() : no CMA channel allocated\n"); return 1; @@ -427,15 +380,17 @@ unsigned int channel_id = _get_context_slot(CTX_CMA_ID); +#if GIET_DEBUG_FBF_DRIVER +_printf("\n[CMA DEBUG] _fb_cma_stop() for CMA channel %d at cycle %d\n", + channel_id, _get_proctime() ); +#endif + // CMA channel desactivation - unsigned int* cma_vbase = (unsigned int *)&seg_cma_base; - unsigned int offset = channel_id * CHBUF_CHANNEL_SPAN; - cma_vbase[offset + CHBUF_RUN] = 0; + _cma_set_register( channel_id, CHBUF_RUN, 0 ); + return 0; #else - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _fb_cma_stop() : no CMA channel allocated\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _fb_cma_stop() : no CMA channel allocated\n"); return 1; Index: /soft/giet_vm/giet_drivers/hba_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/hba_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/hba_driver.c (revision 295) @@ -2,5 +2,5 @@ // File : hba_driver.c // Date : 23/11/2013 -// Author : alain greiner and zhang +// Author : alain greiner // Copyright (c) UPMC-LIP6 /////////////////////////////////////////////////////////////////////////////////// @@ -9,63 +9,15 @@ // block oriented, external storage contrÃŽler, respecting the AHCI standard. // -// It can exist only one ahci-device controler in the architecture. +// The seg_ioc_base (standard HBA virtual base address) and seg_ioc_base_bis +// (backup HBA virtual base address) must be defined in giet_vsegs.ld file. +////////////////////////////////////////////////////////////////////////////////// +// Implementation notes: // -// The _ioc_read() and _ioc_write() functions use the _ioc_access() function, -// that is always blocking, but can be called in 4 modes: +// 1. In order to share code, the two _hba_read() and _hba_write() functions +// call the same _hba_set_cmd() function. // -// - In BOOT_PA mode, the _ioc_access() function use the buffer virtual address -// as a physical address (as the page tables are not build) and use a polling -// policy on the IOC_STATUS register to detect transfer completion, as -// hardware interrupts are not activated. This mode is used by the -// boot code to load the map.bin file into memory. -// -// - In BOOT_VA mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address, and use a polling policy on IOC_STATUS -// register to detect transfer completion. This mode is used by the boot code -// to load the various .elf files into memory. -// -// - In KERNEL mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address, and use a descheduling strategy: -// The ISR executed when transfer completes should restart the calling task. -// There is no checking of user access right to the memory buffer. -// This mode must be used to access IOC, for an "open" system call. -// -// - In USER mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address, and use a descheduling strategy: -// The ISR executed when transfer completes should restart the calling task, -// The user access right to the memory buffer must be checked. -// This mode must be used to access IOC, for a "read/write" system call. -// -// As the IOC component can be used by several programs running in parallel, -// the _ioc_lock variable guaranties exclusive access to the device. The -// _ioc_read() and _ioc_write() functions use atomic LL/SC to get the lock. -// -// The IOMMU can be activated or not: -// -// 1) When the IOMMU is used, a fixed size 2Mbytes vseg is allocated to -// the IOC peripheral, in the I/O virtual space, and the user buffer is -// dynamically remapped in the IOMMU page table. The corresponding entry -// in the IOMMU PT1 is defined by the kernel _ioc_iommu_ix1 variable. -// The number of pages to be unmapped is stored in the _ioc_npages variable. -// The number of PT2 entries is dynamically computed and stored in the -// kernel _ioc_iommu_npages variable. It cannot be larger than 512. -// The user buffer is unmapped by the _ioc_completed() function when -// the transfer is completed. -// -// 2/ If the IOMMU is not used, we check that the user buffer is mapped to a -// contiguous physical buffer (this is generally true because the user space -// page tables are statically constructed to use contiguous physical memory). -// -// Finally, the memory buffer must fulfill the following conditions: -// - The buffer must be word aligned, -// - The buffer must be mapped in user space for an user access, -// - The buffer must be writable in case of (to_mem) access, -// - The total number of physical pages occupied by the user buffer cannot -// be larger than 512 pages if the IOMMU is activated, -// - All physical pages occupied by the user buffer must be contiguous -// if the IOMMU is not activated. -// An error code is returned if these conditions are not verified. -/////////////////////////////////////////////////////////////////////////////////// -// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file. +// 2. All accesses to HBA registers are done by the two +// _hba_set_register() and _hba_get_register() low-level functions, +// that are handling virtual / physical extended addressing. /////////////////////////////////////////////////////////////////////////////////// @@ -80,18 +32,10 @@ #include -#if !defined( NB_HBA_CHANNELS ) -# error: You must define NB_HBA_CHANNELS in the hard_config.h file -#endif - -#if ( NB_HBA_CHANNELS > 8 ) -# error: NB_HBA_CHANNELS cannot be larger than 8 -#endif - -#if !defined( USE_IOB ) -# error: You must define USE_IOB in the hard_config.h file -#endif - -#if !defined(GIET_USE_IOMMU) -# error: You must define GIET_USE_IOMMU in the giet_config.h file +#if !defined( NB_IOC_CHANNELS ) +# error: You must define NB_IOC_CHANNELS in the hard_config.h file +#endif + +#if ( NB_IOC_CHANNELS > 8 ) +# error: NB_IOC_CHANNELS cannot be larger than 8 #endif @@ -103,63 +47,40 @@ // command list array (one per channel) -hba_cmd_list_t hba_cmd_list[NB_HBA_CHANNELS] __attribute__((aligned(0x1000))); +hba_cmd_list_t hba_cmd_list[NB_IOC_CHANNELS] __attribute__((aligned(0x1000))); // command tables array (32 command tables per channel) -hba_cmd_table_t hba_cmd_table[NB_HBA_CHANNELS][32] __attribute__((aligned(0x1000))); +hba_cmd_table_t hba_cmd_table[NB_IOC_CHANNELS][32] __attribute__((aligned(0x1000))); // command list physical addresses array (one per channel) -paddr_t hba_cmd_list_paddr[NB_HBA_CHANNELS]; +paddr_t hba_cmd_list_paddr[NB_IOC_CHANNELS]; // command tables physical addresses array (32 command tables per channel) -paddr_t hba_cmd_table_paddr[NB_HBA_CHANNELS][32]; +paddr_t hba_cmd_table_paddr[NB_IOC_CHANNELS][32]; // command list pointer array (one per channel) -unsigned int hba_cmd_slot[NB_HBA_CHANNELS]; - -////////////////////////////////////////////////////////////////// -// This function returns the status of a given channel. -// return 0 if success, >0 if error -////////////////////////////////////////////////////////////////// -unsigned int _hba_get_status( unsigned int channel, - unsigned int* status ) -{ - volatile unsigned int* hba_address; - hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel); - - if( channel >= NB_HBA_CHANNELS ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _hba_get_status() : illegal channel\n"); - _tty_release_lock( 0 ); - return 1; - } - else - { - *status = hba_address[HBA_PXIS]; - return 0; - } -} -////////////////////////////////////////////////////////////////// -// This function reset the status resgister for a given channel. -// return 0 if success, >0 if error -////////////////////////////////////////////////////////////////// -unsigned int _hba_reset_status( unsigned int channel ) -{ - volatile unsigned int* hba_address; - hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel); - - if( channel >= NB_HBA_CHANNELS ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _hba_reset_status() : illegal channel\n"); - _tty_release_lock( 0 ); - return 1; - } - else - { - hba_address[HBA_PXIS] = 0; - return 0; - } -} +unsigned int hba_cmd_slot[NB_IOC_CHANNELS]; + +////////////////////////////////////////////////////////////////////////////// +// This low level function returns the value of register (channel / index) +////////////////////////////////////////////////////////////////////////////// +unsigned int _hba_get_register( unsigned int channel, + unsigned int index ) +{ + unsigned int* vaddr = (unsigned int*)&seg_ioc_base + channel*HBA_SPAN + index; + return _io_extended_read( vaddr ); +} + +////////////////////////////////////////////////////////////////////////////// +// This low level function set a new value in register (channel / index) +////////////////////////////////////////////////////////////////////////////// +void _hba_set_register( unsigned int channel, + unsigned int index, + unsigned int value ) +{ + unsigned int* vaddr = (unsigned int*)&seg_ioc_base + channel*HBA_SPAN + index; + _io_extended_write( vaddr, value ); +} + + /////////////////////////////////////////////////////////////////////////////// // This function register a command in both the command list @@ -171,22 +92,14 @@ // return 0 if success, > 0 if error /////////////////////////////////////////////////////////////////////////////// -unsigned int _hba_cmd_set( unsigned int is_read, // to memory +unsigned int _hba_cmd_set( unsigned int channel, // channel index + unsigned int is_read, // to memory unsigned int lba, // logic block address - unsigned int buf_vaddr, // buffer virtual address + paddr_t buffer, // buffer physical address unsigned int count ) // number of blocks { - volatile unsigned int *hba_address; - unsigned int block_size; // defined by the block device (bytes) - unsigned int channel_id; // channel index unsigned int pxci; // command list status unsigned int cmd_id; // command index in command list - unsigned int buf_id; // for physical buffers covering user buffer - unsigned int user_pt_vbase; // user page table virtual base address - unsigned int vpn; // for all pages covering the userbuffer - unsigned int vpn_min; // first virtual page index for user buffer - unsigned int vpn_max; // last virtual page index for user buffer - unsigned int offset; // unaligned bytes in page frame: buf_vaddr & 0xFFF - unsigned int offset_last; // unaligned bytes in last frame + hba_cmd_desc_t* cmd_desc; // command descriptor pointer hba_cmd_table_t* cmd_table; // command table pointer @@ -195,43 +108,57 @@ // check buffer alignment - if( buf_vaddr & (block_size-1) ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _hba_set_cmd() : user buffer not block aligned\n"); - _tty_release_lock( 0 ); + if( buffer & (block_size-1) ) + { + _printf("\n[GIET ERROR] in _hba_set_cmd() : user buffer not block aligned\n"); return 1; } - // get channel index - channel_id = _get_context_slot(CTX_HBA_ID); - if ( channel_id == 0xFFFFFFFF ) - { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _hba_set_cmd() : no HBA channel allocated\n"); - _tty_release_lock( 0 ); + // get command list status from PXCI register + pxci = _hba_get_register( channel, HBA_PXCI ); + + // get command index and return error if command list full + cmd_id = hba_cmd_slot[channel]; + if( pxci & (1<entry[0].dba = (unsigned int)(buffer); + cmd_table->entry[0].dbau = (unsigned int)(buffer >> 32); + cmd_table->entry[0].dbc = count * block_size; + + // initialize command table header + cmd_table->header.lba0 = (char)lba; + cmd_table->header.lba1 = (char)(lba>>8); + cmd_table->header.lba2 = (char)(lba>>16); + cmd_table->header.lba3 = (char)(lba>>24); + cmd_table->header.lba4 = 0; + cmd_table->header.lba5 = 0; + + // initialise command descriptor + cmd_desc->prdtl[0] = 1; + cmd_desc->prdtl[1] = 0; + cmd_desc->ctba = (unsigned int)(hba_cmd_table_paddr[channel][cmd_id]); + cmd_desc->ctbau = (unsigned int)(hba_cmd_table_paddr[channel][cmd_id]>>32); + if( is_read ) cmd_desc->flag[0] = 0x00; + else cmd_desc->flag[0] = 0x40; + + // update PXCI register + _hba_set_register( channel, HBA_PXCI, (1< 245 ) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _hba_set_cmd() : max number of buffers is 248\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _hba_set_cmd() : max number of buffers is 248\n"); return 1; } @@ -301,11 +220,11 @@ #if GIET_DEBUG_HBA_DRIVER -_puts("\n- buf_index = "); +_printf("\n- buf_index = "); _putd( buf_id ); -_puts(" / paddr = "); +_printf(" / paddr = "); _putl( paddr ); -_puts(" / count = "); +_printf(" / count = "); _putd( count ); -_puts("\n"); +_printf("\n"); #endif buf_id++; @@ -320,11 +239,11 @@ #if GIET_DEBUG_HBA_DRIVER -_puts("\n- buf_index = "); +_printf("\n- buf_index = "); _putd( buf_id ); -_puts(" / paddr = "); +_printf(" / paddr = "); _putl( paddr ); -_puts(" / count = "); +_printf(" / count = "); _putd( count ); -_puts("\n"); +_printf("\n"); #endif buf_id++; @@ -340,11 +259,11 @@ #if GIET_DEBUG_HBA_DRIVER -_puts("\n- buf_index = "); +_printf("\n- buf_index = "); _putd( buf_id ); -_puts(" / paddr = "); +_printf(" / paddr = "); _putl( paddr ); -_puts(" / count = "); +_printf(" / count = "); _putd( count ); -_puts("\n"); +_printf("\n"); #endif buf_id++; @@ -357,11 +276,11 @@ #if GIET_DEBUG_HBA_DRIVER -_puts("\n- buf_index = "); +_printf("\n- buf_index = "); _putd( buf_id ); -_puts(" / paddr = "); +_printf(" / paddr = "); _putl( paddr ); -_puts(" / count = "); +_printf(" / count = "); _putd( count ); -_puts("\n"); +_printf("\n"); #endif buf_id++; @@ -376,63 +295,54 @@ #if GIET_DEBUG_HBA_DRIVER -_puts("\n- buf_index = "); +_printf("\n- buf_index = "); _putd( buf_id ); -_puts(" / paddr = "); +_printf(" / paddr = "); _putl( paddr ); -_puts(" / count = "); +_printf(" / count = "); _putd( count ); -_puts("\n"); +_printf("\n"); #endif buf_id++; } } - - // initialize command table header - cmd_table->header.lba0 = (char)lba; - cmd_table->header.lba1 = (char)(lba>>8); - cmd_table->header.lba2 = (char)(lba>>16); - cmd_table->header.lba3 = (char)(lba>>24); - - // initialise command descriptor - cmd_desc->prdtl[0] = (unsigned char)(buf_id); - cmd_desc->prdtl[1] = (unsigned char)(buf_id>>8); - cmd_desc->ctba = (unsigned int)(hba_cmd_table_paddr[channel_id][cmd_id]); - cmd_desc->ctbau = (unsigned int)(hba_cmd_table_paddr[channel_id][cmd_id]>>32); - if( is_read ) cmd_desc->flag[0] = 0x00; - else cmd_desc->flag[0] = 0x40; - - // update PXCI register - hba_address[HBA_PXCI] = (1< 0 if error. /////////////////////////////////////////////////////////////////// -unsigned int _hba_write( unsigned int mode, +unsigned int _hba_write( unsigned int channel, + unsigned int mode, unsigned int lba, - void* buffer, + paddr_t buffer, unsigned int count ) { - return _hba_cmd_set( 0, lba, (unsigned int)buffer, count ); + return _hba_cmd_set( channel, + 0, // write + lba, + buffer, + count ); } /////////////////////////////////////////////////////////////////// // Register a read command in Command List and Command Table -// for a single buffer. +// for a single physical buffer. // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////// -unsigned int _hba_read( unsigned int mode, +unsigned int _hba_read( unsigned int channel, + unsigned int mode, unsigned int lba, - void* buffer, + paddr_t buffer, unsigned int count ) { - return _hba_cmd_set( 1, lba, (unsigned int)buffer, count ); -} + return _hba_cmd_set( channel, + 1, // read + lba, + buffer, + count ); +} + ////////////////////////////////////////////////////////////////// // This function initializes for a given channel @@ -453,14 +363,11 @@ unsigned int pt = _get_context_slot(CTX_PTAB_ID); - // HBA registers - unsigned int* hba_address; - hba_address = (unsigned int*)&seg_ioc_base + HBA_SPAN * channel; - - hba_address[HBA_PXCLB] = (unsigned int)(&hba_cmd_list[channel]); - hba_address[HBA_PXCLBU] = 0; - hba_address[HBA_PXIE] = 0x40000001; - hba_address[HBA_PXIS] = 0; - hba_address[HBA_PXCI] = 0; - hba_address[HBA_PXCMD] = 1; + // HBA registers TODO: ne faut_il pas un V2P pour PXCLB/PXCLBU ? (AG) + _hba_set_register( channel, HBA_PXCLB , (unsigned int)&hba_cmd_list[channel] ); + _hba_set_register( channel, HBA_PXCLBU, 0 ); + _hba_set_register( channel, HBA_PXIE , 0x40000001 ); + _hba_set_register( channel, HBA_PXIS , 0 ); + _hba_set_register( channel, HBA_PXCI , 0 ); + _hba_set_register( channel, HBA_PXCMD , 1 ); // command list pointer @@ -475,7 +382,5 @@ if ( fail ) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _hba_init() : command list unmapped\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _hba_init() : command list unmapped\n"); return 1; } @@ -492,7 +397,5 @@ if ( fail ) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _hba_init() : command table unmapped\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _hba_init() : command table unmapped\n"); return 1; } @@ -513,4 +416,26 @@ } +///////////////////////////////////////////////////////////////////////////////////// +// This function returns the content of the HBA_PXIS register for a given channel, +// and reset this register to acknoledge IRQ. +// return 0 if success, > 0 if error +///////////////////////////////////////////////////////////////////////////////////// +unsigned int _hba_get_status( unsigned int channel ) +{ + + if( channel >= NB_IOC_CHANNELS ) + { + _printf("\n[GIET ERROR] in _hba_get_status() : illegal channel\n"); + _exit(); + } + + // get HBA_PXIS value + unsigned int status = _hba_get_register( channel, HBA_PXIS ); + + // reset HBA_PXIS + _hba_set_register( channel, HBA_PXIS, 0 ); + + return status; +} // Local Variables: Index: /soft/giet_vm/giet_drivers/hba_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/hba_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/hba_driver.h (revision 295) @@ -59,5 +59,5 @@ } hba_cmd_entry_t; -typedef struct hba_cmd_table_s // size = 256 bytes +typedef struct hba_cmd_table_s // size = 4096 bytes { @@ -97,22 +97,21 @@ /////////////////////////////////////////////////////////////////////////////////// -unsigned int _hba_write( unsigned int mode, - unsigned int lba, // logic bloc address on device - void* buffer, // memory buffer base address - unsigned int count ); // number of blocs +extern unsigned int _hba_init ( unsigned int channel ); -unsigned int _hba_read ( unsigned int mode, - unsigned int lba, // logic bloc address on device - void* buffer, // memory buffer base address - unsigned int count ); // number of blocks +extern unsigned int _hba_write( unsigned int channel, // channel index + unsigned int mode, // BOOT / KERNEL / USER + unsigned int lba, // logic bloc address on device + unsigned long long paddr, // memory buffer base address + unsigned int count ); // number of blocs -unsigned int _hba_init ( unsigned int channel ); +extern unsigned int _hba_read ( unsigned int channel, // channel index + unsigned int mode, // BOOT / KERNEL / USER + unsigned int lba, // logic bloc address on device + unsigned long long paddr, // memory buffer base address + unsigned int count ); // number of blocks -unsigned int _hba_get_status( unsigned int channel, - unsigned int* status ); +extern unsigned int _hba_get_status( unsigned int channel ); -unsigned int _hba_reset_status( unsigned int channel ); - -unsigned int _hba_get_block_size (); +extern unsigned int _hba_get_block_size (); Index: /soft/giet_vm/giet_drivers/icu_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/icu_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/icu_driver.c (revision 295) @@ -70,5 +70,5 @@ #if USE_XICU - _puts("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n"); + _printf("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n"); return 1; #else @@ -98,5 +98,5 @@ #if USE_XICU - _puts("[GIET ERROR] _icu_get_index() should not be used if USE_XICU is set\n"); + _printf("[GIET ERROR] _icu_set_mask() should not be used if USE_XICU is set\n"); return 1; #else Index: /soft/giet_vm/giet_drivers/ioc_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/ioc_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/ioc_driver.c (revision 295) @@ -7,31 +7,45 @@ /////////////////////////////////////////////////////////////////////////////////// // The ioc_driver.c and ioc_driver.h files are part ot the GIET-VM kernel. -// This driver supports the SocLib vci_block_device component, that is -// a single channel, block oriented, external storage contrÃŽler. -// -// It can exist only one block-device controler in the architecture. -// -// The _ioc_read() and _ioc_write() functions use the _ioc_access() function, -// that is always blocking. The _ioc_access function will call the read or -// write function in the driver of the choosen IOC peripheral, which can be for -// now: BDV, HBA and SPI. This function can be called in 4 modes: -// -// - In BOOT_PA mode, the _ioc_access() function use the buffer virtual address -// as a physical address (as the page tables are not build). This mode is -// used by the boot code to load the map.bin file into memory. -// -// - In BOOT_VA mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address. This mode is used by the boot code to -// load the various .elf files into memory. -// -// - In KERNEL mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address. There is no checking of user access -// right to the memory buffer. This mode must be used to access IOC, for an -// "open" system call. -// -// - In USER mode, the _ioc_access() function makes a V2P translation to -// compute the buffer physical address. The user access right to the memory -// buffer must be checked. This mode must be used to access IOC, for a -// "read/write" system call. +// +// This abstact driver define a generic API, supporting various physical +// block device controlers, including: +// - vci_block_device : single channel) => bdv_driver +// - vci_ahci : multi channels => hba_driver +// - sd_card : single channel => sdc_driver +// - ramdisk (single channel meory mapped virtual disk) => rdk_driver +// +// It can exist only one block-device type in the architecture, that must be +// defined by one of the following configuration variables in hard_config.h file: +// USE_IOC_BDV, USE_IOC_SDC, USE_IOC_HBA, USE_IOC_RDK. +// +// Any physical driver xxx must provide the following API: +// - _xxx_init() +// - _xxx_read() +// - _xxx_write() +// - _xxx_get_status() +// - _xxx_get_block_size() +// The "channel" parameter is no transmited to single channel devices. +// +// The _ioc_read() and _ioc_write() functions are always blocking for +// the calling user program. +// +// These functions compute the physical address of the memory buffer before +// calling the proper physical device. They can be called in 3 modes: +// +// - In BOOT mode, these functions use the buffer virtual address +// as a physical address if the MMU is not activated. +// They make a V2P translation if the MMU is activated. +// This mode is used to load the map.bin file (before memory activation), +// or to load the various .elf files (after MMU activation). +// +// - In KERNEL mode, these functions make a V2P translation to +// compute the buffer physical address. +// There is no checking of user access right to the memory buffer. +// This mode must be used for an "open" system call. +// +// - In USER mode, these functions make a V2P translation to +// compute the buffer physical address. +// The user access right to the memory buffer are checked. +// This mode must be used for a "read" or "write" system call. // // The IOMMU can be activated or not: @@ -60,10 +74,21 @@ // if the IOMMU is not activated. // An error code is returned if these conditions are not verified. +// +// The "seg_ioc_base" virtual base address of the segment containing the +// memory-mapped registers of the device must be defined in the giet_vsegs.ld file. +// If the RAMDISK is used, an extra memory segment with virtual base address +// "seg_ramdisk_base" must be defined in the giet_vsegs.ld file. /////////////////////////////////////////////////////////////////////////////////// -// The seg_ioc_base virtual base addresses must be defined in giet_vsegs.ld file. +// Implementation note: +// In order to share the code, the two _ioc_read() and _ioc_write() functions +// call the same _ioc_access() function. /////////////////////////////////////////////////////////////////////////////////// #include #include +#include +#include +#include +#include #include #include @@ -81,38 +106,39 @@ #endif -#if (USE_BDV + USE_SPI + USE_HBA) != 1 -# error: You must use only one IOC controller (BDV or SPI or HBA) -#endif - -#if USE_BDV +#if (USE_IOC_BDV + USE_IOC_SPI + USE_IOC_HBA + USE_IOC_RDK) != 1 +# error: You must use only one IOC controller type (BDV or SPI or HBA or RDK) +#endif + +#if USE_IOC_BDV # include #endif -#if USE_SPI +#if USE_IOC_SPI # include #endif -#if USE_HBA +#if USE_IOC_HBA # include #endif +#if USE_IOC_RDK +# include +#endif + +/////////////////////////////////////////////////////////////////////////////// +// IOC global variables +/////////////////////////////////////////////////////////////////////////////// #define in_unckdata __attribute__((section (".unckdata"))) -///////////////////// IOC global variables - -in_unckdata unsigned int _ioc_lock = 0; -in_unckdata unsigned int _ioc_status = 0; -in_unckdata volatile unsigned int _ioc_gtid; in_unckdata volatile unsigned int _ioc_iommu_ix1 = 0; in_unckdata volatile unsigned int _ioc_iommu_npages; /////////////////////////////////////////////////////////////////////////////// -// _ioc_access() // This function transfer data between a memory buffer and the block device. // The buffer lentgth is (count*block_size) bytes. // Arguments are: // - to_mem : from external storage to memory when non 0. -// - kernel : kernel buffer with identity mapping when non 0. +// - mode : BOOT_PA / BOOT_VA / KERNEL / USER // - lba : first block index on the external storage. // - buf_vaddr : virtual base address of the memory buffer. @@ -121,4 +147,5 @@ /////////////////////////////////////////////////////////////////////////////// static unsigned int _ioc_access( unsigned int to_mem, + unsigned int channel, unsigned int mode, unsigned int lba, @@ -128,19 +155,17 @@ #if GIET_DEBUG_IOC_DRIVER -_tty_get_lock( 0 ); -_puts("\n[IOC DEBUG] Enter _ioc_access() at cycle "); -_putd( _get_proctime() ); -_puts(" for processor "); -_putd( _get_procid() ); -_puts("\n - mode = "); -_putd( mode ); -_puts("\n - vaddr = "); -_putx( buf_vaddr ); -_puts("\n - sectors = "); -_putd( count ); -_puts("\n - lba = "); -_putx( lba ); -_puts("\n"); -_tty_release_lock( 0 ); +unsigned int procid = _get_procid(); +unsigned int cid = procid / NB_PROCS_MAX; +unsigned int lpid = procid % NB_PROCS_MAX; +unsigned int x = cid >> Y_WIDTH; +unsigned int y = cid & ((1< 0) ) + { + _printf("\n[GIET ERROR] in _ioc_access() : channel must be 0 when HBA not used\n"); + _exit(); } unsigned int length = count << 9; // count * 512 bytes - // computing target buffer physical address - if ( mode == IOC_BOOT_PA_MODE ) // identity mapping + // computing memory buffer physical address + if ( (mode == IOC_BOOT_MODE) && ((_get_mmu_mode() & 0x4) == 0) ) // identity mapping { buf_paddr = (paddr_t)buf_vaddr; } - else // V2P translation + else // V2P translation required { // get page table virtual address pt_vbase = _get_context_slot(CTX_PTAB_ID); - vpn_min = buf_vaddr >> 12; - vpn_max = (buf_vaddr + length - 1) >> 12; + vpn_min = buf_vaddr >> 12; + vpn_max = (buf_vaddr + length - 1) >> 12; // loop on all virtual pages covering the user buffer - for (vpn = vpn_min, ix2 = 0 ; - vpn <= vpn_max ; - vpn++, ix2++ ) + for (vpn = vpn_min, ix2 = 0 ; vpn <= vpn_max ; vpn++, ix2++ ) { // get ppn and flags for each vpn @@ -193,7 +221,5 @@ if ( ko ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _ioc_access() : buffer unmapped\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _ioc_access() : buffer unmapped\n"); return 1; } @@ -201,7 +227,5 @@ if ( (mode == IOC_USER_MODE) && ((flags & PTE_U) == 0) ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _ioc_access() : buffer not user accessible\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _ioc_access() : buffer not user accessible\n"); return 1; } @@ -209,7 +233,5 @@ if ( ((flags & PTE_W) == 0 ) && to_mem ) { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _ioc_access() : buffer not writable\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _ioc_access() : buffer not writable\n"); return 1; } @@ -223,7 +245,5 @@ if (ix2 > 511) // check buffer length < 2 Mbytes { - _tty_get_lock( 0 ); - _puts("\n[GIET ERROR] in _ioc_access() : user buffer > 2 Mbytes\n"); - _tty_release_lock( 0 ); + _printf("\n[GIET ERROR] in _ioc_access() : user buffer > 2 Mbytes\n"); return 1; } @@ -242,7 +262,5 @@ if ((ppn - ppn_first) != ix2) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] in _ioc_access() : split physical buffer\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] in _ioc_access() : split physical buffer\n"); return 1; } @@ -272,5 +290,5 @@ else // memory read : update data caches { - // L1 cache : nothing to do if L1 write-through + // L1 cache : nothing to do for L1 write-through // L2 cache (only if IOB used) @@ -280,13 +298,40 @@ if ( GIET_USE_IOMMU ) buf_paddr = (paddr_t) buf_xaddr; -#if USE_BDV - if (to_mem) error = _bdv_read (mode, lba, buf_paddr, count); - else error = _bdv_write(mode, lba, buf_paddr, count); -#elif USE_SPI - if (to_mem) error = _sdc_read (mode, lba, buf_paddr, count); - else error = _sdc_write(mode, lba, buf_paddr, count); -#elif USE_HBA - if (to_mem) error = _hba_read (mode, lba, buf_paddr, count); - else error = _hba_write(mode, lba, buf_paddr, count); + /////////////////////////////////////////// + // select the proper physical device + /////////////////////////////////////////// + +#if ( USE_IOC_BDV ) + +#if GIET_DEBUG_IOC_DRIVER +_printf("\n[IOC DEBUG] Calling BDV driver\n"); +#endif + if (to_mem) error = _bdv_read ( mode, lba, buf_paddr, count); + else error = _bdv_write( mode, lba, buf_paddr, count); + +#elif ( USE_IOC_SPI ) + +#if GIET_DEBUG_IOC_DRIVER +_printf("\n[IOC DEBUG] Calling SPI driver\n"); +#endif + if (to_mem) error = _sdc_read (mode, lba, buf_paddr, count); + else error = _sdc_write(mode, lba, buf_paddr, count); + +#elif ( USE_IOC_HBA ) + +#if GIET_DEBUG_IOC_DRIVER +_printf("\n[IOC DEBUG] Calling HBA driver\n"); +#endif + if (to_mem) error = _hba_read (channel, mode, lba, buf_paddr, count); + else error = _hba_write(channel, mode, lba, buf_paddr, count); + +#elif ( USE_IOC_RDK ) + +#if GIET_DEBUG_IOC_DRIVER +_printf("\n[IOC DEBUG] Calling RDK driver\n"); +#endif + if (to_mem) error = _rdk_read (lba, buf_vaddr, count); + else error = _rdk_write(lba, buf_vaddr, count); + #endif @@ -295,5 +340,4 @@ /////////////////////////////////////////////////////////////////////////////// -// _ioc_init() // This function cheks block size, and activates the IOC interrupts. // Return 0 for success. @@ -301,17 +345,28 @@ unsigned int _ioc_init( unsigned int channel ) { -#if USE_BDV - return _bdv_init( channel ); -#elif USE_SPI - return _sdc_init( channel ); -#elif USE_HBA + +#if ( USE_IOC_BDV ) + + return _bdv_init(); + +#elif ( USE_IOC_SPI ) + + return _sdc_init(); + +#elif ( USE_IOC_HBA ) + return _hba_init( channel ); -#endif + +#elif ( USE_IOC_RDK ) + + return _rdk_init(); + +#endif + } /////////////////////////////////////////////////////////////////////////////// -// _ioc_read() // Transfer data from the block device to a memory buffer. -// - mode : BOOT / KERNEL / USER +// - mode : BOOT_PA / BOOT_VA / KERNEL / USER // - lba : first block index on the block device // - buffer : base address of the memory buffer (must be word aligned) @@ -319,5 +374,6 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -unsigned int _ioc_read( unsigned int mode, +unsigned int _ioc_read( unsigned int channel, + unsigned int mode, unsigned int lba, void* buffer, @@ -325,4 +381,5 @@ { return _ioc_access( 1, // read access + channel, mode, lba, @@ -332,7 +389,6 @@ /////////////////////////////////////////////////////////////////////////////// -// _ioc_write() // Transfer data from a memory buffer to the block device. -// - mode : BOOT / KERNEL / USER +// - mode : BOOT_PA / BOOT_VA / KERNEL / USER // - lba : first block index on the block device // - buffer : base address of the memory buffer (must be word aligned) @@ -340,5 +396,6 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -unsigned int _ioc_write( unsigned int mode, +unsigned int _ioc_write( unsigned int channel, + unsigned int mode, unsigned int lba, const void* buffer, @@ -346,4 +403,5 @@ { return _ioc_access( 0, // write access + channel, mode, lba, @@ -353,34 +411,59 @@ /////////////////////////////////////////////////////////////////////////////// -// _ioc_get_status() // This function returns in the status variable, the transfert status, and // acknowledge the IRQ if the IOC controler is not busy. // Returns 0 if success, > 0 if error /////////////////////////////////////////////////////////////////////////////// -unsigned int _ioc_get_status( unsigned int channel, - unsigned int* status ) -{ -#if USE_BDV - return _bdv_get_status(channel, status); -#elif USE_SPI - return _sdc_get_status(channel, status); -#elif USE_HBA - return _hba_get_status(channel, status); -#endif +unsigned int _ioc_get_status( unsigned int channel ) +{ + +#if ( USE_IOC_BDV ) + + return _bdv_get_status( ); + +#elif ( USE_IOC_SPI ) + + return _sdc_get_status( ); + +#elif ( USE_IOC_HBA ) + + return _hba_get_status( channel ); + +#elif ( USE_IOC_RDK ) + + _printf("[GIET ERROR] _ioc_get_status() should not be called"); + _printf(" when RAMDISK is used...\n"); + _exit(); + + return 0; + +#endif + } /////////////////////////////////////////////////////////////////////////////// -// _ioc_get_block_size() // This function returns the block_size with which the IOC has been configured. /////////////////////////////////////////////////////////////////////////////// unsigned int _ioc_get_block_size() { -#if USE_BDV + +#if ( USE_IOC_BDV ) + return _bdv_get_block_size(); -#elif USE_SPI + +#elif ( USE_IOC_SPI ) + return _sdc_get_block_size(); -#elif USE_HBA + +#elif ( USE_IOC_HBA ) + return _hba_get_block_size(); -#endif + +#elif ( USE_IOC_RDK ) + + return 512; + +#endif + } Index: /soft/giet_vm/giet_drivers/ioc_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/ioc_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/ioc_driver.h (revision 295) @@ -13,64 +13,37 @@ /////////////////////////////////////////////////////////////////////////////////// -enum IOC_registers -{ - BLOCK_DEVICE_BUFFER, - BLOCK_DEVICE_LBA, - BLOCK_DEVICE_COUNT, - BLOCK_DEVICE_OP, - BLOCK_DEVICE_STATUS, - BLOCK_DEVICE_IRQ_ENABLE, - BLOCK_DEVICE_SIZE, - BLOCK_DEVICE_BLOCK_SIZE, - BLOCK_DEVICE_BUFFER_EXT, -}; -enum IOC_operations -{ - BLOCK_DEVICE_NOOP, - BLOCK_DEVICE_READ, - BLOCK_DEVICE_WRITE, -}; -enum IOC_status -{ - BLOCK_DEVICE_IDLE, - BLOCK_DEVICE_BUSY, - BLOCK_DEVICE_READ_SUCCESS, - BLOCK_DEVICE_WRITE_SUCCESS, - BLOCK_DEVICE_READ_ERROR, - BLOCK_DEVICE_WRITE_ERROR, - BLOCK_DEVICE_ERROR, -}; enum IOC_driver_modes { - IOC_BOOT_PA_MODE, // No V2P translation / Polling IOC_STATUS / no access checking - IOC_BOOT_VA_MODE, // V2P translation / Polling IOC_STATUS / no access checking - IOC_KERNEL_MODE, // V2P translation / Descheduling + IRQ / no access checking - IOC_USER_MODE, // V2P translation / Descheduling + IRQ / access checking + IOC_BOOT_MODE = 0, // Polling IOC_STATUS / no access right checking + IOC_KERNEL_MODE = 1, // Descheduling + IRQ / no access right checking + IOC_USER_MODE = 2, // Descheduling + IRQ / access right checking }; /////////////////////////////////////////////////////////////////////////////////// -// IOC access functions and variables (vci_block_device) +// IOC global variables (generic disk controller) /////////////////////////////////////////////////////////////////////////////////// -extern unsigned int _ioc_lock; -extern unsigned int _ioc_status; -extern volatile unsigned int _ioc_gtid; extern volatile unsigned int _ioc_iommu_ix1; extern volatile unsigned int _ioc_iommu_npages; +/////////////////////////////////////////////////////////////////////////////////// +// IOC access functions (generic disk controller) +/////////////////////////////////////////////////////////////////////////////////// + extern unsigned int _ioc_init( unsigned int channel ); -extern unsigned int _ioc_write( unsigned int mode, +extern unsigned int _ioc_write( unsigned int channel, + unsigned int mode, unsigned int lba, const void* buffer, unsigned int count ); -extern unsigned int _ioc_read( unsigned int mode, +extern unsigned int _ioc_read( unsigned int channel, + unsigned int mode, unsigned int lba, void* buffer, unsigned int count ); -extern unsigned int _ioc_get_status( unsigned int channel, - unsigned int* status ); +extern unsigned int _ioc_get_status( unsigned int channel ); extern unsigned int _ioc_get_block_size(); Index: /soft/giet_vm/giet_drivers/mmc_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/mmc_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/mmc_driver.c (revision 295) @@ -57,14 +57,6 @@ if ( (x >= X_SIZE) || (y >= Y_SIZE) ) { - _puts("\n[GIET ERROR] in _memc_inval() : illegal cluster index["); - _putd( x ); - _puts(","); - _putd( y ); - _puts("]\n"); - _puts(" - paddr = "); - _putl( buf_paddr ); - _puts("\n - cluster_xy = "); - _putx( cluster_xy ); - _puts("\n"); + _printf("\n[GIET ERROR] in _memc_inval() : illegal cluster_xy for paddr %l\n", + buf_paddr ); _exit(); } @@ -102,14 +94,6 @@ if ( (x >= X_SIZE) || (y >= Y_SIZE) ) { - _puts("\n[GIET ERROR] in _memc_sync() : illegal cluster index["); - _putd( x ); - _puts(","); - _putd( y ); - _puts("]\n"); - _puts(" - paddr = "); - _putl( buf_paddr ); - _puts("\n - cluster_xy = "); - _putx( cluster_xy ); - _puts("\n"); + _printf( "\n[GIET ERROR] in _memc_sync() : illegal cluster_xy for paddr %l\n", + buf_paddr ); _exit(); } Index: /soft/giet_vm/giet_drivers/mwr_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/mwr_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/mwr_driver.c (revision 295) @@ -56,5 +56,5 @@ paddr_t channel_pbase ) { - _puts(" [GIET_ERROR] _mwr_hw_init() function not supported yet\n"); + _printf(" [GIET_ERROR] _mwr_hw_init() function not supported yet\n"); _exit(); Index: /soft/giet_vm/giet_drivers/nic_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/nic_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/nic_driver.c (revision 295) @@ -56,6 +56,28 @@ #define in_unckdata __attribute__((section (".unckdata"))) +/////////////////////////////////////////////////////////////////////////////// +// This low_level function returns the value contained in register (index). +/////////////////////////////////////////////////////////////////////////////// +unsigned int _nic_get_register( unsigned int channel, + unsigned int index ) +{ + unsigned int* vaddr = (unsigned int*)&seg_nic_base + + NIC_CHANNEL_SPAN*channel + index; + return _io_extended_read( vaddr ); +} + +/////////////////////////////////////////////////////////////////////////////// +// This low-level function set a new value in register (index). +/////////////////////////////////////////////////////////////////////////////// +void _nic_set_register( unsigned int channel, + unsigned int index, + unsigned int value ) +{ + unsigned int* vaddr = (unsigned int*)&seg_nic_base + + NIC_CHANNEL_SPAN*channel + index; + _io_extended_write( vaddr, value ); +} + ////////////////////////////////////////////////////////////////////////////////// -// _nic_sync_write() // Transfer data from an memory buffer to the NIC device using a memcpy. // - buffer : base address of the memory buffer. @@ -65,5 +87,5 @@ unsigned int length ) { - _puts("[GIET ERROR] _nic_sync_write function not implemented\n"); + _printf("[GIET ERROR] _nic_sync_write function not implemented\n"); _exit(); @@ -73,5 +95,4 @@ } ////////////////////////////////////////////////////////////////////////////////// -// _nic_sync_read() // Transfer data from the NIC device to a memory buffer using a memcpy. // - buffer : base address of the memory buffer. @@ -81,5 +102,5 @@ unsigned int length ) { - _puts("[GIET ERROR] _nic_sync_read function not implemented\n"); + _printf("[GIET ERROR] _nic_sync_read function not implemented\n"); _exit(); @@ -89,10 +110,9 @@ } ////////////////////////////////////////////////////////////////////////////////// -// _nic_cma_start() // Returns 0 if success, > 0 if error. ////////////////////////////////////////////////////////////////////////////////// unsigned int _nic_cma_start( ) { - _puts("[GIET ERROR] _nic_cma_start function not implemented\n"); + _printf("[GIET ERROR] _nic_cma_start() not implemented\n"); _exit(); @@ -101,10 +121,9 @@ } ////////////////////////////////////////////////////////////////////////////////// -// _nic_cma_stop() // Returns 0 if success, > 0 if error. ////////////////////////////////////////////////////////////////////////////////// unsigned int _nic_cma_stop() { - _puts("[GIET ERROR] _nic_cma_stop function not implemented\n"); + _printf("[GIET ERROR] _nic_cma_stop() not implemented\n"); _exit(); @@ -113,4 +132,25 @@ } +////////////////////////////////////////////////////////////////////////////////// +// This ISR handles IRQx from a NIC RX channeL +////////////////////////////////////////////////////////////////////////////////// +void _nic_rx_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ) +{ + _printf("[GIET ERROR] _nic_rx_isr() not implemented\n"); + _exit(); +} + +////////////////////////////////////////////////////////////////////////////////// +// This ISR handles IRQx from a NIC RX channeL +////////////////////////////////////////////////////////////////////////////////// +void _nic_tx_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ) +{ + _printf("[GIET ERROR] _nic_tx_isr() not implemented\n"); + _exit(); +} // Local Variables: Index: /soft/giet_vm/giet_drivers/nic_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/nic_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/nic_driver.h (revision 295) @@ -8,4 +8,67 @@ #ifndef _GIET_NIC_DRIVERS_H_ #define _GIET_NIC_DRIVERS_H_ + +/////////////////////////////////////////////////////////////////////////////////// +// NIC Registers (vci_multi_nic) +/////////////////////////////////////////////////////////////////////////////////// + +enum SoclibMultiNicHyperviseurRegisters { + NIC_G_VIS = 0, // bitfield : bit N = 0 -> channel N disabled + NIC_G_ON = 1, // boolean : NIC component activated + NIC_G_NB_CHAN = 2, // Number of channels present in this NIC (read only) + NIC_G_BC_ENABLE = 3, // boolean : Enable Broadcast if non zero + NIC_G_TDM_ENABLE = 4, // boolean : TDM Scheduler if non zero + NIC_G_TDM_PERIOD = 5, // TDM time slot value + NIC_G_BYPASS_ENABLE = 6, // boolean : Enable bypass for TX packets + // alignment + NIC_G_MAC_4 = 8, // channel mac address 32 LSB bits array[8] + NIC_G_MAC_2 = 16, // channel mac address 16 MSB bits array[8] + // alignment + NIC_G_NPKT_RX_G2S_RECEIVED = 32, // number of packets received on GMII RX port + NIC_G_NPKT_RX_G2S_DISCARDED = 33, // number of RX packets discarded by RX_G2S FSM + + NIC_G_NPKT_RX_DES_SUCCESS = 34, // number of RX packets transmited by RX_DES FSM + NIC_G_NPKT_RX_DES_TOO_SMALL = 35, // number of discarded too small RX packets (<60B) + NIC_G_NPKT_RX_DES_TOO_BIG = 36, // number of discarded too big RX packets (>1514B) + NIC_G_NPKT_RX_DES_MFIFO_FULL = 37, // number of discarded RX packets because fifo full + NIC_G_NPKT_RX_DES_CRC_FAIL = 38, // number of discarded RX packets because CRC32 failure + + NIC_G_NPKT_RX_DISPATCH_RECEIVED = 39, // number of packets received by RX_DISPATCH FSM + NIC_G_NPKT_RX_DISPATCH_BROADCAST = 40, // number of broadcast RX packets received + NIC_G_NPKT_RX_DISPATCH_DST_FAIL = 41, // number of discarded RX packets for DST MAC not found + NIC_G_NPKT_RX_DISPATCH_CH_FULL = 42, // number of discarded RX packets for channel full + + NIC_G_NPKT_TX_DISPATCH_RECEIVED = 43, // number of packets received by TX_DISPATCH FSM + NIC_G_NPKT_TX_DISPATCH_TOO_SMALL = 44, // number of discarded too small TX packets (<60B) + NIC_G_NPKT_TX_DISPATCH_TOO_BIG = 45, // number of discarded too big TX packets (>1514B) + NIC_G_NPKT_TX_DISPATCH_SRC_FAIL = 46, // number of discarded TX packets for SRC MAC failed + NIC_G_NPKT_TX_DISPATCH_BROADCAST = 47, // number of broadcast TX packets received + NIC_G_NPKT_TX_DISPATCH_BYPASS = 48, // number of bypassed TX->RX packets + NIC_G_NPKT_TX_DISPATCH_TRANSMIT = 49, // number of transmit TX packets + + NIC_CHANNEL_SPAN = 0x2000, +}; + +///////////////////////////////////////////////////////////////////// +// A container descriptor has the following form: +// LOW WORD : Container LSB base address +// HIGH WORD: Container status (leftmost bit), '1' means full +// Base address MSB extension, if needed (right aligned) +////////////////////////////////////////////////////////////////////// +enum SoclibMultiNicChannelRegisters +{ + NIC_RX_DESC_LO_0 = 0, // RX_0 descriptor low word (Read/Write) + NIC_RX_DESC_HI_0 = 1, // RX_0 descriptor high word (Read/Write) + NIC_RX_DESC_LO_1 = 2, // RX_1 descriptor low word (Read/Write) + NIC_RX_DESC_HI_1 = 3, // RX_1 descriptor high word (Read/Write) + NIC_TX_DESC_LO_0 = 4, // TX_0 descriptor low word (Read/Write) + NIC_TX_DESC_HI_0 = 5, // TX_0 descriptor high word (Read/Write) + NIC_TX_DESC_LO_1 = 6, // TX_1 descriptor low word (Read/Write) + NIC_TX_DESC_HI_1 = 7, // TX_1 descriptor high word (Read/Write) + NIC_MAC_4 = 8, // channel mac address 32 LSB bits (Read Only) + NIC_MAC_2 = 9, // channel mac address 16 LSB bits (Read Only) + NIC_RX_RUN = 10, // RX packets can be received (write_only) + NIC_TX_RUN = 11, // TX packets can be transmitted (write_only) +}; /////////////////////////////////////////////////////////////////////////////////// @@ -23,4 +86,12 @@ extern unsigned int _nic_cma_stop(); +extern void _nic_rx_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ); + +extern void _nic_tx_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ); + /////////////////////////////////////////////////////////////////////////////////// Index: /soft/giet_vm/giet_drivers/sdc_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/sdc_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/sdc_driver.c (revision 295) @@ -5,5 +5,7 @@ // Copyright (c) UPMC-LIP6 /////////////////////////////////////////////////////////////////////////////////// + #include +#include #include @@ -179,6 +181,5 @@ if ( sdcard_rsp != 0x01 ) { - - _puts("card CMD0 failed "); + _printf("[SDC ERROR] card CMD0 failed\n"); return sdcard_rsp; } @@ -196,5 +197,5 @@ if (!SDCARD_CHECK_R1_VALID(sdcard_rsp)) { - _puts("card CMD8 failed "); + _printf("[SDC ERROR] card CMD8 failed\n"); return sdcard_rsp; } @@ -206,11 +207,11 @@ ersp = (ersp << 8) | _sdc_receive_char(); ersp = (ersp << 8) | _sdc_receive_char(); - if ((ersp & 0xffff) != 0x0101) { + if ((ersp & 0xffff) != 0x0101) + { // voltage mismatch - _puts("card CMD8 mismatch: "); - _putx(ersp); + _printf("[SDC ERROR] card CMD8 mismatch : ersp = %x\n"); return sdcard_rsp; } - _puts("v2 or later "); + _printf("[SDC WARNING] v2 or later "); sdcard.sdhc = 1; } @@ -218,5 +219,5 @@ { // other error - _puts("card CMD8 error "); + _printf("[SDC ERROR] card CMD8 error\n"); return sdcard_rsp; } @@ -249,5 +250,5 @@ if (sdcard_rsp) { - _puts("SD ACMD41 failed "); + _printf("[SDC ERROR] ACMD41 failed\n"); return sdcard_rsp; } @@ -263,5 +264,5 @@ if (sdcard_rsp) { - _puts("SD CMD58 failed "); + _printf("[SDC ERROR] CMD58 failed\n"); return sdcard_rsp; } @@ -272,6 +273,7 @@ if (ersp & 0x40000000) { - _puts("SDHC "); - } else + _printf(" SDHC "); + } + else { sdcard.sdhc = 0; @@ -279,5 +281,5 @@ _sdc_disable(); } - _puts("card detected "); + _printf("card detected\n"); return 0; } @@ -334,5 +336,5 @@ // Returns 0 if success, other value if failure /////////////////////////////////////////////////////////////////////////////// -unsigned int _sdc_init( unsigned int channel ) +unsigned int _sdc_init() { spi = (struct spi_dev*) &seg_ioc_base; @@ -355,14 +357,14 @@ while(1) { - _puts("Trying to initialize SD card... "); - - sdcard_rsp = _sdc_open( channel ); + _printf("[SDC WARNING] Trying to initialize SD card...\n"); + + sdcard_rsp = _sdc_open( 0 ); // only channel 0 if (sdcard_rsp == 0) { - _puts("OK\n"); + _printf("OK\n"); break; } - _puts("KO\n"); + _printf("KO\n"); for (i = 0; i < 1000; i++); @@ -370,8 +372,6 @@ if (++iter >= SDCARD_RESET_ITER_MAX) { - _puts("\nERROR: During SD card reset to IDLE state\n" - "/ card response = "); - _putx(sdcard_rsp); - _puts("\n"); + _printf("\n[SDC ERROR] During SD card reset to IDLE state " + "/ card response = %x\n", sdcard_rsp ); _exit(); } @@ -382,5 +382,5 @@ if (sdcard_rsp) { - _puts("ERROR: During SD card blocklen initialization\n"); + _printf("[SDC ERROR] During SD card blocklen initialization\n"); _exit(); } @@ -396,5 +396,5 @@ ); - _puts("Finish block device initialization\n\r"); + _printf("[SDC WARNING] Finish SD card initialization\n\r"); return 0; @@ -478,5 +478,4 @@ /////////////////////////////////////////////////////////////////////////////// -// _sdc_get_status() // Transfer data from memory buffer to SD card device. // - channel: channel index @@ -484,14 +483,13 @@ // Returns 0 if success, > 0 if error. /////////////////////////////////////////////////////////////////////////////// -unsigned int _sdc_get_status( unsigned int channel , - unsigned int* status ) -{ - *status = BLOCK_DEVICE_IDLE; - - return 0; -} - -/////////////////////////////////////////////////////////////////////////////// -// _sdc_get_block_size() +unsigned int _sdc_get_status() +{ + _printf("[SDC ERROR] function _sdc_get_status() should not be called\n"); + _exit(); + + return 0; // to avoid a warning +} + +/////////////////////////////////////////////////////////////////////////////// // Returns the block size in bytes of the SD card /////////////////////////////////////////////////////////////////////////////// Index: /soft/giet_vm/giet_drivers/sdc_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/sdc_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/sdc_driver.h (revision 295) @@ -36,6 +36,5 @@ }; -unsigned int _sdc_init( unsigned int channel ); - +unsigned int _sdc_init(); unsigned int _sdc_read( unsigned int mode, @@ -50,8 +49,7 @@ unsigned int count); +unsigned int _sdc_get_status(); + unsigned int _sdc_get_block_size(); - -unsigned int _sdc_get_status( unsigned int channel , - unsigned int* status ); Index: /soft/giet_vm/giet_drivers/tim_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/tim_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/tim_driver.c (revision 295) @@ -18,8 +18,5 @@ // The global index is cluster_xy * (NB_PROCS_MAX + NB_TIM_CHANNELS) + local_id // -// The NB_PROCS_MAX and NB_TIM_CHANNELS values must be defined in the -// hard_config.h file. -// -// The register offsets must be defined in the hwr_mapping.h file. +// The NB_PROCS_MAX and NB_TIM_CHANNELS values must be defined in hard_config.h file. ///////////////////////////////////////////////////////////////////////////////////// // The virtual base address of the segment associated to a channel is: @@ -33,4 +30,6 @@ #include #include +#include +#include #include @@ -68,26 +67,28 @@ #if (NB_TIM_CHANNELS > 0) -in_unckdata volatile unsigned char _user_timer_event[X_SIZE*Y_SIZE*NB_TIM_CHANNELS] - = { [0 ... ((X_SIZE*Y_SIZE*NB_TIM_CHANNELS) - 1)] = 0 }; +in_unckdata volatile unsigned char _user_timer_event[(1< 0 if error. -////////////////////////////////////////////////////////////////////////////// -unsigned int _timer_start( unsigned int cluster_xy, - unsigned int local_id, - unsigned int period) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (local_id >= NB_TIM_CHANNELS) return 1; +/////////////////////////////////////////////////////////////////////////////////// +void _timer_start( unsigned int cluster_xy, + unsigned int local_id, + unsigned int period) +{ +#if NB_TIM_CHANNELS + + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) ) + { + _printf("[GIET ERROR] in _timer_start()\n"); + _exit(); + } unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + @@ -96,22 +97,29 @@ timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period; timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0x3; - return 0; -} - -////////////////////////////////////////////////////////////////////////////// -// _timer_stop() + +#else + _printf("[GIET ERROR] _timer_start() should not be called when NB_TIM_CHANNELS is 0\n"); + _exit(); +#endif +} + +////////////////////////////////////////////////////////////////////////////// // This function desactivates a timer in the vci_timer component // by writing in the proper register. // Returns 0 if success, > 0 if error. ////////////////////////////////////////////////////////////////////////////// -unsigned int _timer_stop( unsigned int cluster_xy, - unsigned int local_id) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (local_id >= NB_TIM_CHANNELS) return 1; +void _timer_stop( unsigned int cluster_xy, + unsigned int local_id) +{ +#if NB_TIM_CHANNELS + + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) ) + { + _printf("[GIET ERROR] in _timer_stop()\n"); + _exit(); + } unsigned int* timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + @@ -119,9 +127,12 @@ timer_address[local_id * TIMER_SPAN + TIMER_MODE] = 0; - return 0; -} - -////////////////////////////////////////////////////////////////////////////// -// _timer_reset_irq() + +#else + _printf("[GIET ERROR] _timer_stop() should not be called when NB_TIM_CHANNELS is 0\n"); + _exit(); +#endif +} + +////////////////////////////////////////////////////////////////////////////// // This function acknowlegge a timer interrupt in the vci_timer // component by writing in the proper register. @@ -130,13 +141,17 @@ // Returns 0 if success, > 0 if error. ////////////////////////////////////////////////////////////////////////////// -unsigned int _timer_reset_irq( unsigned int cluster_xy, - unsigned int local_id ) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (local_id >= NB_TIM_CHANNELS) return 1; +void _timer_reset_irq( unsigned int cluster_xy, + unsigned int local_id ) +{ +#if NB_TIM_CHANNELS + + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) ) + { + _printf("[GIET ERROR] in _timer_reset_irq()\n"); + _exit(); + } unsigned int * timer_address = (unsigned int *) ((unsigned int)&seg_tim_base + @@ -144,9 +159,12 @@ timer_address[local_id * TIMER_SPAN + TIMER_RESETIRQ] = 0; - return 0; + +#else + _printf("[GIET ERROR] _timer_reset_irq() should not be called when NB_TIM_CHANNELS is 0\n"); + _exit(); +#endif } ///////////////////////////////////////////////////////////////////////////// -// _timer_reset_cpt() // This function resets the timer counter. To do so, we re-write the period // in the proper register, what causes the count to restart. @@ -156,13 +174,17 @@ // This function is called during a context switch (user or preemptive) //////////////////////////////////////////////////////////////////////i////// -unsigned int _timer_reset_cpt( unsigned int cluster_xy, - unsigned int local_id) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (local_id >= NB_TIM_CHANNELS) return 1; +void _timer_reset_cpt( unsigned int cluster_xy, + unsigned int local_id) +{ +#if NB_TIM_CHANNELS + + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) || (y >= Y_SIZE) || (local_id >= NB_TIM_CHANNELS) ) + { + _printf("[GIET ERROR in _timer_reset_cpt()\n"); + _exit(); + } // We suppose that the TIMER_MODE register value is 0x3 @@ -172,6 +194,46 @@ unsigned int period = timer_address[local_id * TIMER_SPAN + TIMER_PERIOD]; timer_address[local_id * TIMER_SPAN + TIMER_PERIOD] = period; - return 0; -} + +#else + _printf("[GIET ERROR] _timer_reset_cpt should not be called when NB_TIM_CHANNELS is 0\n"); + _exit(); +#endif +} + +/////////////////////////////////////////////////////////////////////////////////// +// This ISR handles the IRQs generated by the "user" timers that are +// replicated in all clusters. +// The IRQs generated by the "system" timers should be handled by _isr_switch(). +// It can be a HWI or a PTI. +// The channel argument is the user timer local index. +// timer_global_id = cluster_id*(NB_TIM_CHANNELS) + channel +// The ISR acknowledges the IRQ and registers the event in the proper entry +// of the _user_timer_event[] array, and a log message is displayed on TTY0. +/////////////////////////////////////////////////////////////////////////////////// +void _timer_isr( unsigned int irq_type, // HWI / PTI + unsigned int irq_id, // index returned by XCU + unsigned int channel ) // user timer index +{ +#if NB_TIM_CHANNELS + + unsigned int cluster_xy = _get_procid() / NB_PROCS_MAX; + + // acknowledge IRQ depending on type + if ( irq_type == IRQ_TYPE_HWI ) _timer_reset_irq( cluster_xy, channel ); + else _xcu_timer_reset_irq( cluster_xy, irq_id ); + + // register the event + _user_timer_event[cluster_xy * NB_TIM_CHANNELS + channel] = 1; + + // display a message on TTY 0 + _printf("\n[GIET WARNING] User Timer IRQ at cycle %d / cluster = %x / channel = %d\n", + _get_proctime(), cluster_xy, channel ); + +#else + _printf("[GIET ERROR] _timer_isr() should not be called when NB_TIM_CHANNELS == 0\n"); + _exit(); +#endif +} + Index: /soft/giet_vm/giet_drivers/tim_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/tim_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/tim_driver.h (revision 295) @@ -6,6 +6,6 @@ /////////////////////////////////////////////////////////////////////////////////// -#ifndef _GIET_TIM_DRIVERS_H_ -#define _GIET_TIM_DRIVERS_H_ +#ifndef _GIET_TIM_DRIVER_H_ +#define _GIET_TIM_DRIVER_H_ /////////////////////////////////////////////////////////////////////////////////// @@ -27,18 +27,20 @@ /////////////////////////////////////////////////////////////////////////////////// -extern volatile unsigned char _timer_event[]; +extern void _timer_start( unsigned int cluster_xy, + unsigned int local_id, + unsigned int period ); -extern unsigned int _timer_start( unsigned int cluster_xy, - unsigned int local_id, - unsigned int period ); +extern void _timer_stop( unsigned int cluster_xy, + unsigned int local_id ); -extern unsigned int _timer_stop( unsigned int cluster_xy, - unsigned int local_id ); +extern void _timer_reset_irq( unsigned int cluster_xy, + unsigned int local_id ); -extern unsigned int _timer_reset_irq( unsigned int cluster_xy, - unsigned int local_id ); +extern void _timer_reset_cpt( unsigned int cluster_xy, + unsigned int local_id); -extern unsigned int _timer_reset_cpt( unsigned int cluster_xy, - unsigned int local_id); +extern void _timer_isr( unsigned int irq_type, + unsigned int irq_id, + unsigned int channel ); /////////////////////////////////////////////////////////////////////////////////// Index: /soft/giet_vm/giet_drivers/tty_driver.c =================================================================== --- /soft/giet_vm/giet_drivers/tty_driver.c (revision 294) +++ /soft/giet_vm/giet_drivers/tty_driver.c (revision 295) @@ -8,10 +8,6 @@ // This driver supports the SocLib vci_multi_tty component. // -// It can exist only one multi_tty controler in the architecture. -// // The total number of TTY terminals must be defined by the configuration // parameter NB_TTY_CHANNELS in the hard_config.h file. -// -// The register offsets must be defined in the hwr_mapping.h file. // // The "system" terminal is TTY[0]. @@ -19,14 +15,17 @@ // as defined in the mapping_info data structure. The corresponding tty_id must // be stored in the context of the task by the boot code. -/////////////////////////////////////////////////////////////////////////////////// -// The virtual base address of the segment associated to a channel is: // -// seg_tty_base + TTY_SPAN * channel_id -// -// The seg_tty_base virtual base addresses must be defined in giet_vsegs.ld file. +// The seg_tty_base must be defined in giet_vsegs.ld file. +/////////////////////////////////////////////////////////////////////////////////// +// Implementation note: +// +// All physical accesses to device registers are done by the two +// _tty_get_register(), _tty_set_register() low-level functions, +// that are handling virtual / physical addressing. /////////////////////////////////////////////////////////////////////////////////// #include #include +#include #include #include @@ -42,15 +41,40 @@ #define in_unckdata __attribute__((section (".unckdata"))) -///////////////// TTY global variables -in_unckdata volatile unsigned char _tty_get_buf[NB_TTY_CHANNELS]; -in_unckdata volatile unsigned char _tty_get_full[NB_TTY_CHANNELS] +////////////////////////////////////////////////////////////////////////////// +// TTY global variables +////////////////////////////////////////////////////////////////////////////// + +in_unckdata volatile unsigned int _tty_rx_buf[NB_TTY_CHANNELS]; +in_unckdata volatile unsigned int _tty_rx_full[NB_TTY_CHANNELS] = { [0 ... NB_TTY_CHANNELS - 1] = 0 }; + +////////////////////////////////////////////////////////////////////////////// +// This low level function returns the value of register (channel / index) +////////////////////////////////////////////////////////////////////////////// +unsigned int _tty_get_register( unsigned int channel, + unsigned int index ) +{ + unsigned int* vaddr = (unsigned int*)&seg_tty_base + channel*TTY_SPAN + index; + return _io_extended_read( vaddr ); +} + +////////////////////////////////////////////////////////////////////////////// +// This low level function set a new value in register (channel / index) +////////////////////////////////////////////////////////////////////////////// +void _tty_set_register( unsigned int channel, + unsigned int index, + unsigned int value ) +{ + unsigned int* vaddr = (unsigned int*)&seg_tty_base + channel*TTY_SPAN + index; + _io_extended_write( vaddr, value ); +} ///////////////////////////////////////////////////////////////////////////////// // This non-blocking function writes a character string from a fixed-length -// buffer to the TTY_WRITE register of a TTY terminal identified by the -// channel argument. If the channel argument is 0xFFFFFFFF, the channel -// index is obtained from the current taxk context. -// It doesn't use any interrupt. +// buffer to a TTY terminal identified by the channel argument. +// This function is intended to be used to handle a system call, and should +// not be used by the kernel for log messages on TTY 0. +// protecting exclusive access to the selected terminal. +// If channel argument is 0xFFFFFFFF, the TTY index is found in the task context. // This is a non blocking call: it tests the TTY_STATUS register, and stops // the transfer as soon as the TTY_STATUS[WRITE] bit is set. @@ -62,17 +86,9 @@ unsigned int channel) // channel index { - unsigned int nwritten; - unsigned int tty_id; - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - // compute tty channel - if( channel == 0xFFFFFFFF ) - { - tty_id = _get_context_slot(CTX_TTY_ID); - } - else - { - tty_id = (unsigned int)channel; - } + unsigned int nwritten; + + // compute and check tty channel + if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); + if( channel >= NB_TTY_CHANNELS ) return -1; // write string to TTY channel @@ -80,7 +96,10 @@ { // check tty's status - if ((tty_address[tty_id * TTY_SPAN + TTY_STATUS] & 0x2) == 0x2) break; - _tty_write_data( tty_id, buffer[nwritten] ); - } + if ( _tty_get_register( channel, TTY_STATUS ) & 0x2 ) break; + + // write one byte + _tty_set_register( channel, TTY_WRITE, (unsigned int)buffer[nwritten] ); + } + return nwritten; } @@ -92,7 +111,7 @@ // It uses the TTY_GET_IRQ[tty_id] interrupt and the buffer must have been // filled by the TTY_ISR. -// It test the _tty_get_full[tty_id] register, read the _tty_get_buf[tty_id] +// It test the _tty_rx_full[tty_id] variable, read the _tty_rx_buf[tty_id] // buffer, writes this character to the target buffer, and resets the -// _tty_get_full[tty_id] register. +// _tty_rx_full[tty_id] register. // The length argument is not used. ////////////////////////////////////////////////////////////////////////////// @@ -103,19 +122,10 @@ unsigned int channel) // channel index { - - unsigned int tty_id; - - // compute tty channel - if( channel == 0xFFFFFFFF ) - { - tty_id = _get_context_slot(CTX_TTY_ID); - } - else - { - tty_id = (unsigned int)channel; - } + // compute and check tty channel + if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); + if( channel >= NB_TTY_CHANNELS ) return -1; // read one character from TTY channel - if (_tty_get_full[tty_id] == 0) + if (_tty_rx_full[channel] == 0) { return 0; @@ -123,98 +133,99 @@ else { - *buffer = _tty_get_buf[tty_id]; - _tty_get_full[tty_id] = 0; + *buffer = _tty_rx_buf[channel]; + _tty_rx_full[channel] = 0; return 1; } } -////////////////////////////////////////////////////////////////////////////// - -////////////////////////////////////////////////////////////////////////////// -// This function try to take the hardwired lock protecting exclusive access -// to TTY terminal identified by the channel argument. + +////////////////////////////////////////////////////////////////////////////// +// This function try to take the hardwired lock protecting +// exclusive access to TTY terminal identified by the "channel" argument. +// It enters a critical section before taking the lock, and save the SR value +// at address defined by the "save_sr_ptr" argument. // It returns only when the lock has been successfully taken. ////////////////////////////////////////////////////////////////////////////// -void _tty_get_lock( unsigned int channel ) -{ - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - if( channel >= NB_TTY_CHANNELS ) - { - _puts("[GIET ERROR] in _tty_get_lock() : illegal TTY index\n"); - _exit(); - } - - while ( tty_address[channel * TTY_SPAN + TTY_CONFIG] ); -} - -////////////////////////////////////////////////////////////////////////////// -// This function releases the hardwired lock protecting exclusive access -// to TTY terminal identified by the channel argument. -////////////////////////////////////////////////////////////////////////////// -void _tty_release_lock( unsigned int channel ) -{ - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - if( channel >= NB_TTY_CHANNELS ) - { - _puts("[GIET ERROR] in _tty_release_lock() : illegal TTY index\n"); - _exit(); - } - - tty_address[channel * TTY_SPAN + TTY_CONFIG] = 0; -} - -////////////////////////////////////////////////////////////////////////////// -// This function returns the content of the TTY_READ register in the -// TTY terminal identified by the channel argument. -////////////////////////////////////////////////////////////////////////////// -unsigned int _tty_read_data( unsigned int channel ) -{ - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - if( channel >= NB_TTY_CHANNELS ) - { - _puts("[GIET ERROR] in _tty_read_data() : illegal TTY index\n"); - _exit(); - } - - return tty_address[channel * TTY_SPAN + TTY_READ]; -} - -////////////////////////////////////////////////////////////////////////////// -// This function returns the content of the TTY_STATUS register in the -// TTY terminal identified by the channel argument. -////////////////////////////////////////////////////////////////////////////// -unsigned int _tty_get_status( unsigned int channel ) -{ - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - if( channel >= NB_TTY_CHANNELS ) - { - _puts("[GIET ERROR] in _tty_get_status() : illegal TTY index\n"); - _exit(); - } - - return tty_address[channel * TTY_SPAN + TTY_STATUS]; -} - -////////////////////////////////////////////////////////////////////////////// -// This function writes one character in the TTY_WRITE register in the -// TTY terminal identified by the channel argument. -////////////////////////////////////////////////////////////////////////////// -void _tty_write_data( unsigned int channel, - char byte ) -{ - unsigned int* tty_address = (unsigned int *) &seg_tty_base; - - if( channel >= NB_TTY_CHANNELS ) - { - _puts("[GIET ERROR] in _tty_write_data() : illegal TTY index\n"); - _exit(); - } - - tty_address[channel * TTY_SPAN + TTY_WRITE] = (unsigned int) byte; -} - +void _tty_get_lock( unsigned int channel, + unsigned int * save_sr_ptr ) +{ + if( channel >= NB_TTY_CHANNELS ) _exit(); + _it_disable( save_sr_ptr ); + while ( _tty_get_register( channel, TTY_CONFIG ) ); // busy waiting +} + +////////////////////////////////////////////////////////////////////////////// +// This function releases the hardwired lock protecting +// exclusive access to TTY terminal identified by the channel argument. +// It exit the critical section after lock release, and restore SR value +// from address defined by the "save_sr_ptr" argument. +////////////////////////////////////////////////////////////////////////////// +void _tty_release_lock( unsigned int channel, + unsigned int * save_sr_ptr ) +{ + if( channel >= NB_TTY_CHANNELS ) _exit(); + + _tty_set_register( channel, TTY_CONFIG, 0 ); + _it_restore( save_sr_ptr ); +} + +/////////////////////////////////////////////////////////////////////////////////// +// This ISR handles the IRQ signaling that the RX buffer is full. +// IT can be an HWI or an SWI. +// There is one single multi_tty component controling all channels. +// There is one communication buffer _tty_rx_buf[i] and one synchronisation +// variable _tty_rx_full[i] per channel. +// A character is lost if the buffer is full when the ISR is executed. +/////////////////////////////////////////////////////////////////////////////////// +void _tty_rx_isr( unsigned int irq_type, // HWI / WTI + unsigned int irq_id, // index returned by XCU + unsigned int channel ) // TTY channel +{ + unsigned int cluster_xy = _get_procid() / NB_PROCS_MAX; + + if ( irq_type == IRQ_TYPE_WTI ) // reset SWI in XCU if required + { + unsigned int value; + _xcu_get_wti_value( cluster_xy, irq_id, &value ); + } + + // get character and reset TTY IRQ + _tty_rx_buf[channel] = _tty_get_register( channel, TTY_READ ); + +#if GIET_DEBUG_IRQS // we don't take the TTY lock to avoid deadlock +unsigned int x = cluster_xy >> Y_WIDTH; +unsigned int y = cluster_xy & ((1< @@ -52,25 +36,23 @@ #endif -//////////////////////////////////////////////////////////////////////////////// -// _xcu_set_mask() -// This function set the mask register for the XICU channel identified by the -// cluster index and the processor index multiplied by the number of IRQ per -// processor. + +//////////////////////////////////////////////////////////////////////////////// +// This function set the mask register for the IRQ type defined by "irq_type", +// and for the channel identified by the "cluster_xy" and "channel" arguments. // All '1' bits are set / all '0' bits are not modified. -// Returns 0 if success, > 0 if error. -//////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_set_mask( unsigned int cluster_xy, - unsigned int irq_index, - unsigned int value, - unsigned int irq_type ) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (irq_index >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) return 1; - -#if USE_XICU +//////////////////////////////////////////////////////////////////////////////// +void _xcu_set_mask( unsigned int cluster_xy, + unsigned int channel, + unsigned int value, + unsigned int irq_type ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + if (channel >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) _exit(); + volatile unsigned int* xcu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + @@ -79,83 +61,94 @@ unsigned int func; if (irq_type == IRQ_TYPE_PTI) func = XICU_MSK_PTI_ENABLE; - else if (irq_type == IRQ_TYPE_SWI) func = XICU_MSK_WTI_ENABLE; - else func = XICU_MSK_HWI_ENABLE; - xcu_address[XICU_REG(func,irq_index)] = value; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_set_mask should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; -#endif -} - -//////////////////////////////////////////////////////////////////////////////// -// _xcu_get_index() -// This function returns the index of the highest priority (smaller index) -// - active HWI (Hardware Interrupt), or -// - active PTI (Timer Interrupt), or -// - active SWI (Software Interrupt). -// The ICU channel is identified by the cluster index and the processor index -// multiplied by the number of IRQ per processor. -// Returns 0 if success, > 0 if error. -//////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_get_index( unsigned int cluster_xy, - unsigned int irq_index, - unsigned int * buffer) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (irq_index >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) return 1; - -#if USE_XICU - volatile unsigned int* xcu_address = - (unsigned int *) ((unsigned int)&seg_xcu_base + - (cluster_xy * (unsigned int)&vseg_cluster_increment)); - - unsigned int prio = xcu_address[XICU_REG(XICU_PRIO,irq_index)]; + else if (irq_type == IRQ_TYPE_WTI) func = XICU_MSK_WTI_ENABLE; + else if (irq_type == IRQ_TYPE_HWI) func = XICU_MSK_HWI_ENABLE; + else + { + _printf("[GIET ERROR] _xcu_set_mask() receives illegal IRQ type\n"); + _exit(); + } + + xcu_address[XICU_REG(func,channel)] = value; + +#else + _printf("[GIET ERROR] _xcu_set_mask() should not be used if USE_XICU not set\n"); + _exit(); +#endif +} + +//////////////////////////////////////////////////////////////////////////////// +// This function returns the index and the type of the highest priority +// - active PTI (Timer Interrupt), then +// - active HWI (Hardware Interrupt), then +// - active WTI (Software Interrupt) +// As the hardware can define more than one IRQ per processor, but the GIET +// use only one, channel = lpid * IRQ_PER_PROCESSOR. +//////////////////////////////////////////////////////////////////////////////// +void _xcu_get_index( unsigned int cluster_xy, + unsigned int channel, + unsigned int * index, + unsigned int * irq_type ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + if (channel >= (NB_PROCS_MAX * IRQ_PER_PROCESSOR)) _exit(); + + volatile unsigned int* xcu_address = + (unsigned int *) ((unsigned int)&seg_xcu_base + + (cluster_xy * (unsigned int)&vseg_cluster_increment)); + + unsigned int prio = xcu_address[XICU_REG(XICU_PRIO,channel)]; unsigned int pti_ok = (prio & 0x00000001); unsigned int hwi_ok = (prio & 0x00000002); - unsigned int swi_ok = (prio & 0x00000004); + unsigned int wti_ok = (prio & 0x00000004); unsigned int pti_id = (prio & 0x00001F00) >> 8; unsigned int hwi_id = (prio & 0x001F0000) >> 16; - unsigned int swi_id = (prio & 0x1F000000) >> 24; - if (pti_ok) *buffer = pti_id; - else if (hwi_ok) *buffer = hwi_id; - else if (swi_ok) *buffer = swi_id; - else *buffer = 32; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_get_index should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; -#endif -} - -//////////////////////////////////////////////////////////////////////////////// -// _xcu_send_ipi() -// This function can be used only in an architecture using XICU components. -// It writes the "wdata" value in the mailbox defined by the cluster index -// and the processor index. -// Giet-VM supports at most NB_PROCS_MAX mailboxes: -// (0 <= wti_index <= NB_PROCS_MAX-1) -// Returns 0 if success, > 0 if error. -//////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_send_ipi( unsigned int cluster_xy, - unsigned int wti_index, - unsigned int wdata ) + unsigned int wti_id = (prio & 0x1F000000) >> 24; + if (pti_ok) + { + *index = pti_id; + *irq_type = IRQ_TYPE_PTI; + } + else if (hwi_ok) + { + *index = hwi_id; + *irq_type = IRQ_TYPE_HWI; + } + else if (wti_ok) + { + *index = wti_id; + *irq_type = IRQ_TYPE_WTI; + } + else + { + *index = 32; + } + +#else + _printf("[GIET ERROR] _xcu_get_index should not be used if USE_XICU is not set\n"); + _exit(); +#endif +} + +//////////////////////////////////////////////////////////////////////////////// +// This function writes the "wdata" value in the mailbox defined +// by the "cluster_xy" and "wti_index" arguments. +//////////////////////////////////////////////////////////////////////////////// +void _xcu_send_wti( unsigned int cluster_xy, + unsigned int wti_index, + unsigned int wdata ) { - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - if (wti_index >= NB_PROCS_MAX) return 1; - -#if USE_XICU +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + if (wti_index >= 32) _exit(); + volatile unsigned int* xcu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + @@ -163,30 +156,78 @@ xcu_address[XICU_REG(XICU_WTI_REG,wti_index)] = wdata; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_send_ipi should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; + +#else + _printf("[GIET ERROR] _xcu_send_ipi should not be used if USE_XICU is not set\n"); + _exit(); #endif } //////////////////////////////////////////////////////////////////////////////// -// _xcu_timer_start() +// This function returns the value contained in a WTI mailbox defined by +// the cluster_xy and "wti_index" arguments. This value is written in +// the "value" argument, and the corresponding WTI is acknowledged. +// returns 0 if success, > 0 if error. +//////////////////////////////////////////////////////////////////////////////// +void _xcu_get_wti_value( unsigned int cluster_xy, + unsigned int wti_index, + unsigned int * value ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + if (wti_index >= 32) _exit(); + + volatile unsigned int* xcu_address = + (unsigned int *) ((unsigned int)&seg_xcu_base + + (cluster_xy * (unsigned int)&vseg_cluster_increment)); + + *value = xcu_address[XICU_REG(XICU_WTI_REG, wti_index)]; + +#else + _printf("[GIET ERROR] in _xcu_get_wti_value() USE_XICU is not set\n"); + _exit(); +#endif +} + +//////////////////////////////////////////////////////////////////////////////// +// This function returns the address of a WTI mailbox defined by +// the "wti_index" argument, in the unsigned int "address" argument. +// It is used by the GIET to configurate the IOPIC component. +// There is no access to a specific XCU component in a specific cluster. +// returns 0 if success, > 0 if error. +//////////////////////////////////////////////////////////////////////////////// +void _xcu_get_wti_address( unsigned int wti_index, + unsigned int * address ) +{ +#if USE_XICU + if (wti_index >= 32) _exit(); + + unsigned int xcu_address = (unsigned int)&seg_xcu_base; + *address = xcu_address + (XICU_REG(XICU_WTI_REG, wti_index)<<2); + +#else + _printf("[GIET ERROR] in _xcu_get_wti_address() USE_XICU is not set\n"); + _exit(); +#endif +} + +//////////////////////////////////////////////////////////////////////////////// // This function activates a timer contained in XICU by writing in the // proper register the period value. -// Returns 0 if success, > 0 if error. -//////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_timer_start( unsigned int cluster_xy, - unsigned int pti_index, - unsigned int period ) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - -#if USE_XICU +//////////////////////////////////////////////////////////////////////////////// +void _xcu_timer_start( unsigned int cluster_xy, + unsigned int pti_index, + unsigned int period ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + volatile unsigned int* xcu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + @@ -194,29 +235,25 @@ xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = period; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_timer_start should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; -#endif -} - -////////////////////////////////////////////////////////////////////////////// -// _xcu_timer_stop() + +#else + _printf("[GIET ERROR] in _xcu_timer_start() USE_XICU is not set\n"); + _exit(); +#endif +} + +////////////////////////////////////////////////////////////////////////////// // This function desactivates a timer in XICU component // by writing in the proper register. -// Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_timer_stop( unsigned int cluster_xy, - unsigned int pti_index) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - -#if USE_XICU +////////////////////////////////////////////////////////////////////////////// +void _xcu_timer_stop( unsigned int cluster_xy, + unsigned int pti_index) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + volatile unsigned int * xcu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + @@ -224,31 +261,27 @@ xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = 0; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_timer_stop should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; -#endif -} - -////////////////////////////////////////////////////////////////////////////// -// _xcu_timer_reset_irq() + +#else + _printf("[GIET ERROR] in _xcu_timer_stop() USE_XICU is not set\n"); + _exit(); +#endif +} + +////////////////////////////////////////////////////////////////////////////// // This function acknowlegge a timer interrupt in XICU // component by reading in the proper register. // It can be used by both the isr_switch() for a "system" timer, // or by the _isr_timer() for an "user" timer. -// Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_timer_reset_irq( unsigned int cluster_xy, - unsigned int pti_index ) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - -#if USE_XICU +////////////////////////////////////////////////////////////////////////////// +void _xcu_timer_reset_irq( unsigned int cluster_xy, + unsigned int pti_index ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + volatile unsigned int * xcu_address = (unsigned int *) ((unsigned int)&seg_xcu_base + @@ -256,32 +289,29 @@ xcu_address[XICU_REG(XICU_PTI_ACK, pti_index)]; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_timer_reset_irq should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; -#endif -} - -////////////////////////////////////////////////////////////////////////////// -// _xcu_timer_reset_cpt() + +#else + _printf("[GIET ERROR] in _xcu_timer_reset_irq() USE_XICU is not set\n"); + _exit(); +#endif +} + +////////////////////////////////////////////////////////////////////////////// // This function resets a timer counter. To do so, we re-write the period // in the proper register, what causes the count to restart. // The period value is read from the same (TIMER_PERIOD) register, // this is why in appearance we do nothing useful (read a value -// from a register and write this value in the same register) +// from a register and write this value in the same register). // This function is called during a context switch (user or preemptive) ///////////////////////////////////////////////////////////////////////////// -unsigned int _xcu_timer_reset_cpt( unsigned int cluster_xy, - unsigned int pti_index ) -{ - // parameters checking - unsigned int x = cluster_xy >> Y_WIDTH; - unsigned int y = cluster_xy & ((1<= X_SIZE) return 1; - if (y >= Y_SIZE) return 1; - -#if USE_XICU +void _xcu_timer_reset_cpt( unsigned int cluster_xy, + unsigned int pti_index ) +{ +#if USE_XICU + // parameters checking + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<= X_SIZE) _exit(); + if (y >= Y_SIZE) _exit(); + volatile unsigned int * xcu_address = (unsigned int *) ((unsigned int) &seg_xcu_base + @@ -294,10 +324,8 @@ xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = 0; xcu_address[XICU_REG(XICU_PTI_PER, pti_index)] = period; - return 0; -#else - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _xcu_timer_reset_irq should not be used if USE_XICU is not set\n"); - _tty_release_lock( 0 ); - return 1; + +#else + _printf("[GIET ERROR] in _xcu_timer_reset_cpt() USE_XICU is not set\n"); + _exit(); #endif } Index: /soft/giet_vm/giet_drivers/xcu_driver.h =================================================================== --- /soft/giet_vm/giet_drivers/xcu_driver.h (revision 294) +++ /soft/giet_vm/giet_drivers/xcu_driver.h (revision 295) @@ -5,4 +5,20 @@ // Copyright (c) UPMC-LIP6 /////////////////////////////////////////////////////////////////////////////////// +// The xcu_driver.c and xcu_driver.h files are part ot the GIET-VM nano-kernel. +// This driver supports the SoCLib vci_xicu, that is a vectorised interrupt +// controler supporting IPI (Inter Processor Interrupts) and integrated timers. +// +// It can exist several interrupt controller unit in the architecture +// (one per cluster), and each one can contain several channels. +// The number of XICU channels is equal to NB_PROCS_MAX, because there is +// one private XICU channel per processor in a cluster. +//////////////////////////////////////////////////////////////////////////////// +// The virtual base address of the segment associated to the component is: +// +// seg_xcu_base + cluster_xy * vseg_cluster_increment +// +// The seg_xcu_base and vseg_cluster_increment values must be defined +// in giet_vsegs.ld file. +//////////////////////////////////////////////////////////////////////////////// #ifndef _GIET_XCU_DRIVER_H_ @@ -44,29 +60,37 @@ /////////////////////////////////////////////////////////////////////////////////// -extern unsigned int _xcu_get_index( unsigned int cluster_xy, - unsigned int irq_index, - unsigned int * buffer ); +extern void _xcu_set_mask( unsigned int cluster_xy, + unsigned int channel, + unsigned int mask, + unsigned int irq_type ); -extern unsigned int _xcu_set_mask( unsigned int cluster_xy, - unsigned int irq_index, - unsigned int mask, - unsigned int is_timer ); +extern void _xcu_get_index( unsigned int cluster_xy, + unsigned int channel, + unsigned int * index, + unsigned int * irq_type ); -extern unsigned int _xcu_send_ipi( unsigned int cluster_xy, - unsigned int wti_index, - unsigned int wdata ); +extern void _xcu_send_wti( unsigned int cluster_xy, + unsigned int wti_index, + unsigned int wdata ); -extern unsigned int _xcu_timer_start( unsigned int cluster_xy, - unsigned int pti_index, - unsigned int period ); +extern void _xcu_get_wti_value( unsigned int cluster_xy, + unsigned int wti_index, + unsigned int * value ); -extern unsigned int _xcu_timer_stop( unsigned int cluster_xy, - unsigned int pti_index ); +extern void _xcu_get_wti_address( unsigned int wti_index, + unsigned int * address ); -extern unsigned int _xcu_timer_reset_irq( unsigned int cluster_xy, - unsigned int pti_index ); +extern void _xcu_timer_start( unsigned int cluster_xy, + unsigned int pti_index, + unsigned int period ); -extern unsigned int _xcu_timer_reset_cpt( unsigned int cluster_xy, - unsigned int pti_index ); +extern void _xcu_timer_stop( unsigned int cluster_xy, + unsigned int pti_index ); + +extern void _xcu_timer_reset_irq( unsigned int cluster_xy, + unsigned int pti_index ); + +extern void _xcu_timer_reset_cpt( unsigned int cluster_xy, + unsigned int pti_index ); /////////////////////////////////////////////////////////////////////////////////// Index: /soft/giet_vm/giet_fat32/fat32.c =================================================================== --- /soft/giet_vm/giet_fat32/fat32.c (revision 294) +++ /soft/giet_vm/giet_fat32/fat32.c (revision 295) @@ -17,6 +17,6 @@ // 2. This FAT32 library uses a FAT cache whose storage capacity is one // sector (512 bytes, or 128 cluster indexes in FAT) -// 3. This FAT32 library can be used in three modes: BOOT/KERNEL/USER -// defining three different behaviours for the IOC driver. +// 3. This FAT32 library can be used in four modes: BOOT_PA/BOOT_VA/KERNEL/USER +// defining different behaviours for the IOC driver. ////////////////////////////////////////////////////////////////////////////////// @@ -46,14 +46,11 @@ temp[8] = 0; - _tty_get_lock( 0 ); - _puts("\n*********************** fat_cache_lba = "); - _putx( fat.cache_lba ); - _puts(" **************************\n"); + _printf("\n*********************** fat_cache_lba = %x *****************************\n", + fat.cache_lba ); for ( line=0 ; line<16 ; line++ ) { // display address - _putx( (fat.cache_lba<<9) + (line<<5) ); - _puts(" : "); + _printf( "%x : ", (fat.cache_lba<<9) + (line<<5) ); // display data hexa @@ -65,6 +62,5 @@ (fat.fat_cache[byte+2]<< 8) | (fat.fat_cache[byte+3]); - _putx( hexa ); - _puts(" | "); + _printf("%x | ", hexa ); // prepare display ascii @@ -76,9 +72,8 @@ // display data ascii - _puts( (char*)temp ); - _puts("\n"); - } - _puts("***************************************************************************\n"); - _tty_release_lock( 0 ); + _printf( (char*)temp ); + _printf("\n"); + } + _printf("**************************************************************************\n"); } // end display_fat_cache() #endif @@ -202,14 +197,12 @@ // access fat - if( _ioc_read( mode, // mode for IOC driver + if( _ioc_read( 0, // channel + mode, // mode for IOC driver lba, // sector index fat.fat_cache, // fat cache 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT_ERROR] in get_next cluster_id() cannot read block "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT_ERROR] in get_next cluster_id() " + "cannot read block %x\n", lba ); return 1; } @@ -271,8 +264,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] filename "); -_puts( string ); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] filename %s", string ); #endif @@ -282,9 +272,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts(" converted to 8.3 SFN format : "); -_puts( sfn_string ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf(" converted to 8.3 SFN format : %s\n", sfn_string ); #endif @@ -298,9 +284,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts(" converted to 8.3 SFN format : "); -_puts( string ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf(" converted to 8.3 SFN format : %s\n", sfn_string ); #endif @@ -358,9 +340,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts(" converted to 8.3 SFN format : "); -_puts( sfn_string ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf(" converted to 8.3 SFN format : %s\n", sfn_string ); #endif @@ -524,14 +502,11 @@ is_sfn = is_short( file_name, sfn ); - if ( _ioc_read( IOC_KERNEL_MODE, // mode for IOC driver + if ( _ioc_read( 0, // channel + IOC_KERNEL_MODE, // mode for IOC driver lba, // sector index fat.fat_cache, // buffer address 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT ERROR] in update_entry() cannot read sector "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT ERROR] in update_entry() cannot read sector %x\n", lba ); return 1; } @@ -562,8 +537,5 @@ else if (ord == NO_MORE_ENTRY ) // end of directory : return { - _tty_get_lock( 0 ); - _puts("[FAT ERROR] in update_entry() end of directory reaches "); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT ERROR] in update_entry() : reaches end of directory\n"); return 1; } @@ -591,8 +563,5 @@ else if (ord == NO_MORE_ENTRY ) // end of directory : return { - _tty_get_lock( 0 ); - _puts("[FAT ERROR] in update_entry() end of directory reaches "); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT ERROR] in update_entry() reaches end of directory\n"); return 1; } @@ -643,12 +612,13 @@ } - return _ioc_write( IOC_KERNEL_MODE, - lba, - fat.fat_cache, - 1 ); -} -////////////////////////////////////////////////////////////////////////////////// -// This function update FS_INFO, for new last cluster allocated and number of free -// cluster. + return _ioc_write( 0, // channel + IOC_KERNEL_MODE, // mode + lba, // sector index + fat.fat_cache, // source buffer + 1 ); // one sector +} +////////////////////////////////////////////////////////////////////////////////// +// This function update FS_INFO: +// last cluster allocated and number of free cluster. // Return 0 in case of success, > 0 if failure. ////////////////////////////////////////////////////////////////////////////////// @@ -658,7 +628,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Enter in update_fs_info()\n"); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] Enter update_fs_info()\n"); #endif @@ -670,14 +638,11 @@ else // miss cache { - if ( _ioc_read( IOC_KERNEL_MODE, // mode for IOC driver + if ( _ioc_read( 0, // channel + IOC_KERNEL_MODE, // mode for IOC driver lba, // sector index - fat.fat_cache, // fat cache + fat.fat_cache, // source buffer 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT_ERROR] in update_fat() cannot read block "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT_ERROR] in update_fat() cannot read block %x\n", lba ); return 1; } @@ -686,8 +651,9 @@ write_entry( FS_FREE_CLUSTER_HINT, fat.fat_cache, fat.last_cluster_allocated ); } - return _ioc_write( IOC_KERNEL_MODE, - lba, - fat.fat_cache, - 1 ); + return _ioc_write( 0, // channel + IOC_KERNEL_MODE, // mode + lba, // sector index + fat.fat_cache, // source buffer + 1 ); // one sector } @@ -703,13 +669,6 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Enter in update_fat() :\n"); -_puts(" - Cluster to update = "); -_putd( cluster ); -_puts("\n"); -_puts(" - Value to write = "); -_putd( value ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] Enter update_fat() : cluster = %x / value = %x\n", + cluster, value ); #endif @@ -720,14 +679,11 @@ else // miss cache { - if ( _ioc_read( IOC_KERNEL_MODE, // mode for IOC driver + if ( _ioc_read( 0, // channel + IOC_KERNEL_MODE, // mode for IOC driver lba, // sector index - fat.fat_cache, // fat cache + fat.fat_cache, // source buffer 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT_ERROR] in update_fat() cannot read block "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT_ERROR] in update_fat() cannot read block %x\n"); return 1; } @@ -735,8 +691,9 @@ write_entry( ((cluster % 128) << 2), 4, fat.fat_cache, value ); } - return _ioc_write( IOC_KERNEL_MODE, - lba, - fat.fat_cache, - 1 ); + return _ioc_write( 0, // channel + IOC_KERNEL_MODE, // mode + lba, // sector indexs + fat.fat_cache, // source buffer + 1 ); // one sector } @@ -759,7 +716,5 @@ if ( get_next_cluster_id( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : first free_cluster isnt free\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : first free_cluster not free\n"); return -1; } @@ -767,19 +722,10 @@ if ( count > fat.number_free_cluster ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s) for this allocation\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s)\n"); return -1; } #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Enter in _fat_allocate() :\n"); -_puts(" - Need to allocate "); -_putd( count ); -_puts(" cluster(s) for file "); -_putd( fd_id ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] Enter in _fat_allocate() for file %d\n", fd_id ); #endif @@ -795,15 +741,6 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Cluster to update is : "); -_putd( last_cluster_file ); -_puts("\n"); -_puts("[FAT DEBUG] Free cluster is : "); -_putd( free_cluster ); -_puts("\n"); -_puts("[FAT DEBUG] Number of cluster need to be allocated : "); -_putd( cluster_to_allocate ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] cluster to update = %x / free cluster = %x / clusters required = %d\n", + last_cluster_file, free_cluster, cluster_to_allocate ); #endif @@ -812,9 +749,5 @@ if ( update_fat( last_cluster_file, free_cluster ) ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : update fat for file "); - _putd( fd_id ); - _puts(" failed\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n"); return -1; } @@ -831,9 +764,5 @@ if ( update_fat( last_cluster_file, END_OF_CHAIN_CLUSTER ) ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : update fat for file "); - _putd( fd_id ); - _puts(" failed\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n"); return -1; } @@ -845,7 +774,5 @@ if ( get_next_cluster_id( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : free_cluster isnt free\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : free_cluster not free\n"); return -1; } @@ -859,9 +786,5 @@ if ( update_fs_info() ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_allocate() : update fs_info for file "); - _putd( fd_id ); - _puts(" failed\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_allocate() : update fs_info failed\n"); return -1; } @@ -895,9 +818,5 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] enter _scan_directory() searching dir/file : "); -_puts( file_name ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf("\n[FAT DEBUG] enter _scan_directory() searching dir/file %s", filename ); #endif @@ -920,14 +839,11 @@ // load first cluster sector from DATA region into FAT cache // other sectors will be loaded inside loop as required - if( _ioc_read( mode, // mode for IOC driver + if( _ioc_read( 0, // channel + mode, // mode for IOC driver lba, // sector index fat.fat_cache, // buffer address 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT ERROR] in scan directory() cannot read sector "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT ERROR] in scan directory() cannot read sector %x\n", lba ); return -1; } @@ -935,7 +851,7 @@ fat.cache_lba = lba; - #if GIET_DEBUG_FAT - display_fat_cache(); - #endif +#if GIET_DEBUG_FAT +display_fat_cache(); +#endif // in this loop we scan all names in directory identified by cluster: @@ -961,14 +877,11 @@ block_id = fat.sectors_per_cluster; } - if( _ioc_read( mode, // mode for IOC driver + if( _ioc_read( 0, // channel + mode, // mode for IOC driver lba, // sector index fat.fat_cache, // buffer address 1 ) ) // one sector { - _tty_get_lock( 0 ); - _puts("[FAT ERROR] in scan directory() cannot read sector "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("[FAT ERROR] in scan directory() cannot read sector %x\n", lba ); return -1; } @@ -1072,9 +985,4 @@ *lba_dir_entry = lba; -#if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] FILE FOUND\n"); -_tty_release_lock( 0 ); -#endif return read_cluster( dir_entry ); } @@ -1094,7 +1002,5 @@ unsigned int dir_cluster ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] _fat_create() not implemented\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] _fat_create() not implemented\n"); return 0; } //end _fat_create() @@ -1115,37 +1021,39 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Enter _fat_init() / fat_cache_base = "); -_putx( (unsigned int)fat.fat_cache ); -_puts("\n"); -_tty_release_lock( 0 ); +unsigned int procid = _get_procid(); +unsigned int cid = procid / NB_PROCS_MAX; +unsigned int lpid = procid % NB_PROCS_MAX; +unsigned int x = cid >> Y_WIDTH; +unsigned int y = cid & ((1<> Y_WIDTH; +unsigned int y = cid & ((1<= GIET_OPEN_FILES_MAX ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n"); return -1; } if ( fat.fd[fd_id].used != 1 ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_read() : file not open\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_read() : file not open\n"); return -1; } if ( ((unsigned int)buffer & 0x1FF) != 0 ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n"); return -1; } if ( offset >= file_sectors ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] offset larger than number of sectors in file\n"); - _puts(" - offset = "); - _putd( offset ); - _puts(" - file_sectors = "); - _putd( file_sectors ); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] offset larger than number of sectors\n"); return -1; } @@ -1533,11 +1404,7 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n - first cluster = "); -_putd( cluster ); -_puts("\n - skiped clusters = "); -_putd( clusters_to_skip ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf(" - first cluster = %x\n" + " - skiped clusters = %x\n", + cluster, clusters_to_skip ); #endif @@ -1568,25 +1435,16 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] _fat_read() IOC request : buf = "); -_putx( (unsigned int)dst ); -_puts(" / lba = "); -_putd( lba ); -_puts(" / sectors = "); -_putd( iter_sectors ); -_puts("\n"); -_tty_release_lock( 0 ); -#endif - - if( _ioc_read( mode, // mode for IOC driver +_printf("\n[FAT DEBUG] Processor[%d,%d,%d] makes an IOC read :" + " buf = %x / lba = %x / sectors = %d\n", + x, y, lpid, (unsigned int)dst, lba, iter_sectors ); +#endif + + if( _ioc_read( 0, // channel + mode, // mode for IOC driver lba, // first sector index dst, // buffer address iter_sectors ) ) // number of sectors { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_read() cannot load block "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_read() cannot load block %x\n", lba ); return -1; } @@ -1653,18 +1511,18 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] Enter _fat_write() for file "); -_puts( fat.fd[fd_id].name ); -_puts("\n - buffer base = "); -_putx( (unsigned int)buffer ); -_puts("\n - skipped sectors = "); -_putd( offset ); -_puts("\n - write sectors = "); -_putd( count ); -_puts("\n - file size (sectors) = "); -_putd( file_sectors ); -_puts("\n - need allocate = "); - allocate ? _puts( "True" ) : _puts( "False"); -_tty_release_lock( 0 ); +unsigned int procid = _get_procid(); +unsigned int cid = procid / NB_PROCS_MAX; +unsigned int lpid = procid % NB_PROCS_MAX; +unsigned int x = cid >> Y_WIDTH; +unsigned int y = cid & ((1<= GIET_OPEN_FILES_MAX ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n"); return -1; } if ( fat.fd[fd_id].used != 1 ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() : file not open\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() : file not open\n"); return -1; } if ( ((unsigned int)buffer & 0x1FF) != 0 ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n"); return -1; } @@ -1696,9 +1548,5 @@ if ( _fat_allocate( fd_id, (required_cluster - current_cluster) ) < 0 ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() : fat_allocate for file "); - _putd( fd_id ); - _puts(" failed\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() : fat_allocate failed\n"); return -1; } @@ -1713,11 +1561,7 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n - first cluster = "); -_putd( cluster ); -_puts("\n - skiped clusters = "); -_putd( clusters_to_skip ); -_puts("\n"); -_tty_release_lock( 0 ); +_printf(" - first cluster = %x\n" + " - skiped clusters = %x\n", + cluster, clusters_to_skip ); #endif @@ -1748,25 +1592,16 @@ #if GIET_DEBUG_FAT -_tty_get_lock( 0 ); -_puts("\n[FAT DEBUG] _fat_write() IOC request : buf = "); -_putx( (unsigned int)src ); -_puts(" / lba = "); -_putd( lba ); -_puts(" / sectors = "); -_putd( iter_sectors ); -_puts("\n"); -_tty_release_lock( 0 ); -#endif - - if( _ioc_write( mode, // mode for IOC driver +_printf("\n[FAT DEBUG] Processor[%d,%d,%d] makes an IOC write : " + "buf = %x / lba = %x / sectors = %x\n", + x, y, lpid, (unsigned int)src, lba, iter_sectors ); +#endif + + if( _ioc_write( 0, // channel + mode, // mode for IOC driver lba, // first sector index - src, // buffer address + src, // source buffer address iter_sectors ) ) // number of sectors { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() cannot write block "); - _putd( lba ); - _puts("\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() cannot write block %x\n", lba ); return -1; } @@ -1792,9 +1627,5 @@ if ( update_entry(fd_id, DIR_FILE_SIZE, fat.fd[fd_id].file_size) ) { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_write() update entry for file "); - _putd( fd_id ); - _puts(" failed\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_write() update entry failed\n"); return -1; } @@ -1826,7 +1657,5 @@ else { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n"); return -1; } @@ -1847,7 +1676,5 @@ else { - _tty_get_lock( 0 ); - _puts("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n"); - _tty_release_lock( 0 ); + _printf("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n"); return -1; } @@ -1863,7 +1690,7 @@ unsigned int flags ) // unused: TODO { - return _fat_open( IOC_KERNEL_MODE, // we KERNEL_MODE, because + return _fat_open( IOC_KERNEL_MODE, // we use KERNEL_MODE, because pathname, // we need to write into FAT cache - 0 ); + 0 ); // no creation if not found } @@ -1909,7 +1736,5 @@ unsigned int whence ) { - _tty_get_lock( 0 ); - _puts("[GIET ERROR] _fat_user_lseek function not implemented\n"); - _tty_release_lock( 0 ); + _printf("[GIET ERROR] _fat_user_lseek() not implemented\n"); _exit(); return 0; Index: /soft/giet_vm/giet_fat32/fat32.h =================================================================== --- /soft/giet_vm/giet_fat32/fat32.h (revision 294) +++ /soft/giet_vm/giet_fat32/fat32.h (revision 295) @@ -143,5 +143,5 @@ unsigned int cluster_size; // sector_size * sector_per_cluster (bytes) unsigned int fat_sectors; // number of sectors occupied by one FAT copy - unsigned int partition_sectors; // total number of sectors (RESVD + FAT + DATA) + unsigned int partition_sectors; // total number of sectors (RESVD+FAT+DATA) unsigned int partition_lba; // lba of first partiton sector unsigned int data_lba; // lba of first data sector @@ -150,4 +150,5 @@ unsigned int number_free_cluster; // number of free clusters unsigned int fs_info_lba; // lba of fs_info + unsigned int lock; // lock protecting exclusive access } fat32_fs_t; /***************************************************************************************/ Index: /soft/giet_vm/giet_libs/barrier.c =================================================================== --- /soft/giet_vm/giet_libs/barrier.c (revision 294) +++ /soft/giet_vm/giet_libs/barrier.c (revision 295) @@ -15,38 +15,20 @@ /////////////////////////////////////////////////////////////////////////////////// -// barrier_init() -// This function makes a cooperative initialisation of the barrier: -// several tasks try to initialize the barrier, but the initialisation -// is done by only one task, using LL/SC instructions. +// This function initializes the barrier: this should be done by a single task. /////////////////////////////////////////////////////////////////////////////////// -void barrier_init( giet_barrier_t * barrier, unsigned int value) { - unsigned int * pinit = (unsigned int *) &barrier->init; - unsigned int * pcount = (unsigned int *) &barrier->count; - - // parallel initialisation using atomic instructions LL/SC - // inputs : pinit, pcount, value - // no output - asm volatile ("_barrier_init_test: \n" - "ll $2, 0(%0) \n" /* read initial value */ - "bnez $2, _barrier_init_done \n" - "move $3, %2 \n" - "sc $3, 0(%0) \n" /* write initial value */ - "beqz $3, _barrier_init_test \n" - "move $3, %2 \n" - "sw $3, 0(%1) \n" /* write count */ - "_barrier_init_done: \n" - : - : "r"(pinit), "r"(pcount), "r"(value) - : "$2", "$3"); +void barrier_init( giet_barrier_t* barrier, + unsigned int value ) +{ + barrier->init = value; + barrier->count = value; } /////////////////////////////////////////////////////////////////////////////////// -// barrier_wait() // This blocking function uses LL/SC to decrement the barrier's counter. // Then, it uses a busy_waiting mechanism if it is not the last. -// (because the GIET does not support dynamic task scheduling/descheduling) /////////////////////////////////////////////////////////////////////////////////// -void barrier_wait(giet_barrier_t * barrier) { +void barrier_wait( giet_barrier_t* barrier ) +{ unsigned int * pcount = (unsigned int *) &barrier->count; unsigned int maxcount = barrier->init; @@ -56,5 +38,5 @@ // - input : pointer on the barrier counter // - output : counter value - asm volatile ("_barrier_decrement: \n" + asm volatile ("_barrier_decrement: \n" "ll %0, 0(%1) \n" "addi $3, %0, -1 \n" @@ -68,5 +50,6 @@ // waking up all other waiting tasks - if (count == 1) { + if (count == 1) + { // last task *pcount = maxcount; Index: /soft/giet_vm/giet_libs/barrier.h =================================================================== --- /soft/giet_vm/giet_libs/barrier.h (revision 294) +++ /soft/giet_vm/giet_libs/barrier.h (revision 295) @@ -13,5 +13,6 @@ /////////////////////////////////////////////////////////////////////////////////// -typedef struct giet_barrier_s { +typedef struct giet_barrier_s +{ char name[32]; // barrier name unsigned int init; // total number of participants @@ -23,6 +24,8 @@ ////////////////////////////////////////////////////////////////////////////// -void barrier_init(giet_barrier_t * barrier, unsigned int value); -void barrier_wait(giet_barrier_t * barrier); +void barrier_init( giet_barrier_t* barrier, + unsigned int value ); // number of tasks + +void barrier_wait( giet_barrier_t* barrier ); #endif Index: /soft/giet_vm/giet_libs/malloc.h =================================================================== --- /soft/giet_vm/giet_libs/malloc.h (revision 294) +++ /soft/giet_vm/giet_libs/malloc.h (revision 295) @@ -8,4 +8,5 @@ #ifndef _MALLOC_H_ #define _MALLOC_H_ + //#define DEBUG_MALLOC 1 Index: /soft/giet_vm/giet_libs/stdio.c =================================================================== --- /soft/giet_vm/giet_libs/stdio.c (revision 294) +++ /soft/giet_vm/giet_libs/stdio.c (revision 295) @@ -19,99 +19,342 @@ //////////////////////////////////////////////////////////////////////////////////// -// giet_procid() -//////////////////////////////////////////////////////////////////////////////////// -// This function returns the processor identifier. -//////////////////////////////////////////////////////////////////////////////////// -int giet_procid() -{ - return sys_call( SYSCALL_PROCID, - 0, 0, 0, 0 ); -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_proctime() -//////////////////////////////////////////////////////////////////////////////////// -// This function returns the local processor time (clock cycles since boot) -//////////////////////////////////////////////////////////////////////////////////// -int giet_proctime() -{ - return sys_call( SYSCALL_PROCTIME, - 0, 0, 0, 0 ); -} - - -//////////////////////////////////////////////////////////////////////////////////// ///////////////////// TTY device related system calls ///////////////////////////// //////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_putc() -//////////////////////////////////////////////////////////////////////////////////// -// This function displays a single ascii character on a terminal. -// The terminal index must be defined in the task context in the boot phase. -// It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer. -// - Returns 1 if the character has been written, 0 otherwise. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_putc(char byte) -{ - return sys_call(SYSCALL_TTY_WRITE, - (unsigned int)(&byte), - 1, - 0xFFFFFFFF, - 0); -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_puts() -//////////////////////////////////////////////////////////////////////////////////// -// This function displays a string on a terminal. -// The terminal index must be defined in the task context in the boot phase. -// The string must be terminated by a NUL character. -// It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer. -// - Returns the number of written characters. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_puts(char * buf) -{ - unsigned int length = 0; - while (buf[length] != 0) { length++; } - return sys_call(SYSCALL_TTY_WRITE, - (unsigned int)buf, - length, - 0xFFFFFFFF, - 0); -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_putw() -//////////////////////////////////////////////////////////////////////////////////// -// This function displays the value of a 32-bit word with decimal characters. -// The terminal index must be defined in the task context in the boot phase. -// It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer. -// Returns the number of written characters (should be equal to ten). -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_putw(unsigned int val) -{ - char buf[10]; - unsigned int i; - for (i = 0; i < 10; i++) - { - buf[9 - i] = (val % 10) + 0x30; - val = val / 10; - } - return sys_call(SYSCALL_TTY_WRITE, - (unsigned int)buf, - 10, - 0xFFFFFFFF, - 0); -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_getc() -//////////////////////////////////////////////////////////////////////////////////// -// This blocking function fetches a single ascii character from a terminal. -// The terminal index must be defined in the task context in the boot phase. -// It uses the IRQ_GET interrupt, and the associated kernel buffer. -// - Returns 0 when completed. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_getc(char * byte) -{ - unsigned int ret = 0; - while (ret == 0) +//////////////////////////////////////// +void giet_tty_printf( char* format, ...) +{ + va_list args; + va_start( args, format ); + + int ret; // return value from the syscalls + unsigned int channel = 0xFFFFFFFF; + +printf_text: + + while (*format) + { + unsigned int i; + for (i = 0 ; format[i] && (format[i] != '%') ; i++); + if (i) + { + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)format, + i, + channel, + 0); + + if (ret != i) goto return_error; + + format += i; + } + if (*format == '%') + { + format++; + goto printf_arguments; + } + } + + va_end( args ); + return; + +printf_arguments: + + { + char buf[20]; + char * pbuf; + unsigned int len = 0; + static const char HexaTab[] = "0123456789ABCDEF"; + unsigned int i; + + switch (*format++) + { + case ('c'): /* char conversion */ + { + int val = va_arg( args, int ); + len = 1; + buf[0] = val; + pbuf = &buf[0]; + break; + } + case ('d'): /* 32 bits decimal signed integer */ + { + int val = va_arg( args, int ); + if (val < 0) + { + val = -val; + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"-", + 1, + channel, + 0); + if (ret != 1) goto return_error; + } + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('u'): /* 32 bits decimal unsigned integer */ + { + unsigned int val = va_arg( args, unsigned int ); + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('x'): /* 32 bits hexadecimal integer */ + { + unsigned int val = va_arg( args, unsigned int ); + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"0x", + 2, + channel, + 0); + if (ret != 2) goto return_error; + for(i = 0; i < 8; i++) + { + buf[7 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[7 - i]; + break; + } + case ('l'): /* 64 bits hexadecimal unsigned */ + { + unsigned long long val = va_arg( args, unsigned long long ); + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"0x", + 2, + channel, + 0); + if (ret != 2) goto return_error; + for(i = 0; i < 16; i++) + { + buf[15 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[15 - i]; + break; + } + case ('s'): /* string */ + { + char* str = va_arg( args, char* ); + while (str[len]) + { + len++; + } + pbuf = str; + break; + } + default: + goto return_error; + } + + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)pbuf, + len, + channel, + 0); + if (ret != len) goto return_error; + + goto printf_text; + } + +return_error: + + va_end( args ); + giet_exit("error in giet_tty_printf()"); +} // end giet_tty_printf() + +//////////////////////////////////////// +void giet_shr_printf( char* format, ...) +{ + va_list args; + va_start( args, format ); + + int ret; // return value from the syscalls + unsigned int channel = 0; + unsigned int sr_save; + + sys_call( SYSCALL_TTY_GET_LOCK, + channel, + (unsigned int)&sr_save, + 0, 0 ); + +printf_text: + + while (*format) + { + unsigned int i; + for (i = 0 ; format[i] && (format[i] != '%') ; i++); + if (i) + { + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)format, + i, + channel, + 0); + + if (ret != i) goto return_error; + + format += i; + } + if (*format == '%') + { + format++; + goto printf_arguments; + } + } + + sys_call( SYSCALL_TTY_RELEASE_LOCK, + channel, + (unsigned int)&sr_save, + 0, 0 ); + + va_end( args ); + return; + +printf_arguments: + + { + char buf[20]; + char * pbuf; + unsigned int len = 0; + static const char HexaTab[] = "0123456789ABCDEF"; + unsigned int i; + + switch (*format++) + { + case ('c'): /* char conversion */ + { + int val = va_arg( args, int ); + len = 1; + buf[0] = val; + pbuf = &buf[0]; + break; + } + case ('d'): /* 32 bits decimal signed integer */ + { + int val = va_arg( args, int ); + if (val < 0) + { + val = -val; + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"-", + 1, + channel, + 0); + if (ret != 1) goto return_error; + } + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('u'): /* 32 bits decimal unsigned integer */ + { + unsigned int val = va_arg( args, unsigned int ); + for(i = 0; i < 10; i++) + { + buf[9 - i] = HexaTab[val % 10]; + if (!(val /= 10)) break; + } + len = i + 1; + pbuf = &buf[9 - i]; + break; + } + case ('x'): /* 32 bits hexadecimal integer */ + { + unsigned int val = va_arg( args, unsigned int ); + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"0x", + 2, + channel, + 0); + if (ret != 2) goto return_error; + for(i = 0; i < 8; i++) + { + buf[7 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[7 - i]; + break; + } + case ('l'): /* 64 bits hexadecimal unsigned */ + { + unsigned long long val = va_arg( args, unsigned long long ); + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)"0x", + 2, + channel, + 0); + if (ret != 2) goto return_error; + for(i = 0; i < 16; i++) + { + buf[15 - i] = HexaTab[val % 16]; + if (!(val /= 16)) break; + } + len = i + 1; + pbuf = &buf[15 - i]; + break; + } + case ('s'): /* string */ + { + char* str = va_arg( args, char* ); + while (str[len]) + { + len++; + } + pbuf = str; + break; + } + default: + goto return_error; + } + + ret = sys_call(SYSCALL_TTY_WRITE, + (unsigned int)pbuf, + len, + channel, + 0); + if (ret != len) goto return_error; + + goto printf_text; + } + +return_error: + + sys_call( SYSCALL_TTY_RELEASE_LOCK, + channel, + (unsigned int)&sr_save, + 0, 0 ); + + va_end( args ); + giet_exit("error in giet_shr_printf()"); +} // end giet_shr_printf() + + +///////////////////////////////// +void giet_tty_getc( char * byte ) +{ + int ret; + + do { ret = sys_call(SYSCALL_TTY_READ, @@ -120,29 +363,17 @@ 0xFFFFFFFF, // channel index from task context 0); - } - return 0; -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_gets() -//////////////////////////////////////////////////////////////////////////////////// -// This blocking function fetches a string from a terminal to a fixed length buffer. -// The terminal index must be defined in the task context in the boot phase. -// It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer. -// - Returns 0 when completed. -// - Up to (bufsize - 1) characters (including the non printable characters) -// will be copied into buffer, and the string is always completed by a NUL -// character. -// - The character is interpreted, and the function close the string with a -// NUL character if is read. -// - The character is interpreted, and the corresponding character(s) are -// removed from the target buffer. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_gets( char* buf, - unsigned int bufsize) -{ - unsigned int ret; + if ( ret < 0 ) giet_exit("error in giet_tty_getc()"); + } + while (ret != 1); +} + +///////////////////////////////////// +void giet_tty_gets( char* buf, + unsigned int bufsize ) +{ + int ret; unsigned char byte; - unsigned int index = 0; - + unsigned int index = 0; + while (index < (bufsize - 1)) { @@ -154,4 +385,5 @@ 0xFFFFFFFF, 0); + if ( ret < 0 ) giet_exit("error in giet_tty_gets()"); } while (ret != 1); @@ -172,252 +404,120 @@ } buf[index] = 0; - return 0; -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_getw() -//////////////////////////////////////////////////////////////////////////////////// -// This blocking function fetches a string of decimal characters (most -// significant digit first) to build a 32-bit unsigned integer. -// The terminal index must be defined in the task context in the boot phase. -// It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer. -// - Returns necessarily 0 when completed. -// -// - The non-blocking system function _tty_read_irq is called several times, -// and the decimal characters are written in a 32 characters buffer until a -// character is read. -// - The character is interpreted, and previous characters can be -// cancelled. All others characters are ignored. -// - When the character is received, the string is converted to an -// unsigned int value. If the number of decimal digit is too large for the 32 -// bits range, the zero value is returned. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_getw(unsigned int * val) +} + +/////////////////////////////////////// +void giet_tty_getw( unsigned int* val ) { unsigned char buf[32]; - unsigned char byte; - unsigned int save = 0; - unsigned int dec = 0; - unsigned int done = 0; - unsigned int overflow = 0; - unsigned int max = 0; - unsigned int i; - unsigned int ret; - + unsigned int string_byte = 0x00000000; // string containing one single byte + unsigned int string_cancel = 0x00082008; // string containing BS/SPACE/BS + unsigned int save = 0; + unsigned int dec = 0; + unsigned int done = 0; + unsigned int overflow = 0; + unsigned int length = 0; + unsigned int i; + unsigned int channel = 0xFFFFFFFF; + int ret; // return value from syscalls + + // get characters while (done == 0) { + // read one character do { - ret = sys_call(SYSCALL_TTY_READ, - (unsigned int)(&byte), - 1, - 0xFFFFFFFF, - 0); + ret = sys_call( SYSCALL_TTY_READ, + (unsigned int)(&string_byte), + 1, + channel, + 0); + if ( ret < 0 ) giet_exit("error in giet_tty_getw()"); } while (ret != 1); - if ((byte > 0x2F) && (byte < 0x3A)) /* decimal character */ - { - buf[max] = byte; - max++; - giet_tty_putc(byte); - } - else if ((byte == 0x0A)) /* LF */ + // analyse character + if ((string_byte > 0x2F) && (string_byte < 0x3A)) /* decimal character */ + { + buf[length] = (unsigned char)string_byte; + length++; + + // echo + ret = sys_call( SYSCALL_TTY_WRITE, + (unsigned int)(&string_byte), + 1, + channel, + 0 ); + if ( ret < 0 ) giet_exit("error in giet_tty_gets()"); + } + else if (string_byte == 0x0A) /* LF character */ { done = 1; } - else if (byte == 0x7F) /* DEL */ - { - if (max > 0) - { - max--; /* cancel the character */ - giet_tty_putc(0x08); - giet_tty_putc(0x20); - giet_tty_putc(0x08); - } - } - if (max == 32) /* decimal string overflow */ - { - for (i = 0; i < max; i++) - { - /* cancel the string */ - giet_tty_putc(0x08); - giet_tty_putc(0x20); - giet_tty_putc(0x08); - } - giet_tty_putc(0x30); - *val = 0; /* return 0 value */ - return 0; - } - } - - /* string conversion */ - for (i = 0; i < max; i++) - { - dec = dec * 10 + (buf[i] - 0x30); - if (dec < save) overflow = 1; - save = dec; - } - - /* check overflow */ - if (overflow == 0) - { - *val = dec; /* return decimal value */ - } - else - { - for (i = 0; i < max; i++) - { - /* cancel the string */ - giet_tty_putc(0x08); - giet_tty_putc(0x20); - giet_tty_putc(0x08); - } - giet_tty_putc(0x30); - *val = 0; /* return 0 value */ - } - return 0; -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_tty_printf() -//////////////////////////////////////////////////////////////////////////////////// -// This function is a simplified version of the mutek_printf() function. -// The terminal index must be defined in the calling task context. -// It doesn't use the IRQ_PUT interrupt, and the associated kernel buffer. -// Only a limited number of formats are supported: -// - %d : signed decimal -// - %u : unsigned decimal -// - %x : hexadecimal -// - %c : char -// - %s : string -// - Returns 0 if success, > 0 if error. -//////////////////////////////////////////////////////////////////////////////////// -int giet_tty_printf(char * format, ...) -{ - va_list ap; - va_start(ap, format); - unsigned int ret; - - if (NB_TTY_CHANNELS == 1) - { - ret = sys_call(SYSCALL_TTY_LOCK, 0, 0, 0, 0); // Get TTY lock - } - -printf_text: - - while (*format) - { - unsigned int i; - for (i = 0 ; format[i] && (format[i] != '%') ; i++); - if (i) - { - ret = sys_call(SYSCALL_TTY_WRITE, - (unsigned int)format, - i, - 0xFFFFFFFF, - 0); - - if (ret != i) goto return_error; - - format += i; - } - if (*format == '%') - { - format++; - goto printf_arguments; - } - } - - if (NB_TTY_CHANNELS == 1) - { - ret = sys_call(SYSCALL_TTY_LOCK, 1, 0, 0, 0); // Release TTY lock - } - - va_end(ap); - return 0; - -printf_arguments: - - { - int val = va_arg(ap, long); - char buf[20]; - char * pbuf; - unsigned int len = 0; - static const char HexaTab[] = "0123456789ABCDEF"; - unsigned int i; - - switch (*format++) { - case ('c'): /* char conversion */ - len = 1; - buf[0] = val; - pbuf = buf; - break; - case ('d'): /* decimal signed integer */ - if (val < 0) - { - val = -val; - ret = sys_call(SYSCALL_TTY_WRITE, - (unsigned int)"-", - 1, - 0xFFFFFFFF, - 0); - if (ret != 1) goto return_error; - } - case ('u'): /* decimal unsigned integer */ - for(i = 0; i < 10; i++) - { - buf[9 - i] = HexaTab[val % 10]; - if (!(val /= 10)) break; - } - len = i + 1; - pbuf = &buf[9 - i]; - break; - case ('x'): /* hexadecimal integer */ - ret = sys_call(SYSCALL_TTY_WRITE, - (unsigned int)"0x", - 2, - 0xFFFFFFFF, - 0); - if (ret != 2) goto return_error; /* return error */ - for(i = 0; i < 8; i++) - { - buf[7 - i] = HexaTab[val % 16U]; - if (!(val /= 16U)) break; - } - len = i + 1; - pbuf = &buf[7 - i]; - break; - case ('s'): /* string */ - { - char * str = (char *) val; - while (str[len]) - { - len++; - } - pbuf = (char *) val; - } - break; - default: - goto printf_text; - } - - ret = sys_call(SYSCALL_TTY_WRITE, - (unsigned int)pbuf, - len, - 0xFFFFFFFF, - 0); - if (ret != len) goto return_error; - - goto printf_text; - } - -return_error: - if (NB_TTY_CHANNELS == 1) - { - ret = sys_call(SYSCALL_TTY_LOCK, 1, 0, 0, 0); // Release TTY lock - } - - return 1; -} - + else if ( (string_byte == 0x7F) || /* DEL character */ + (string_byte == 0x08) ) /* BS character */ + { + if ( length > 0 ) + { + length--; // cancel the character + + ret = sys_call( SYSCALL_TTY_WRITE, + (unsigned int)(&string_cancel), + 3, + channel, + 0 ); + if ( ret < 0 ) giet_exit("error in giet_tty_gets()"); + } + } + + // test buffer overflow + if ( length >= 32 ) + { + overflow = 1; + done = 1; + } + } // end while characters + + // string to int conversion with overflow detection + if ( overflow == 0 ) + { + for (i = 0; (i < length) && (overflow == 0) ; i++) + { + dec = dec * 10 + (buf[i] - 0x30); + if (dec < save) overflow = 1; + save = dec; + } + } + + // final evaluation + if ( overflow == 0 ) + { + // return value + *val = dec; + } + else + { + // cancel all echo characters + for (i = 0; i < length ; i++) + { + ret = sys_call( SYSCALL_TTY_WRITE, + (unsigned int)(&string_cancel), + 3, + channel, + 0 ); + if ( ret < 0 ) giet_exit("error in giet_tty_gets()"); + } + // echo character '0' + string_byte = 0x30; + ret = sys_call( SYSCALL_TTY_WRITE, + (unsigned int)(&string_byte), + 1, + channel, + 0 ); + if ( ret < 0 ) giet_exit(); + + // return 0 value + *val = 0; + } +} @@ -426,26 +526,16 @@ ////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////// -// giet_timer_start() -////////////////////////////////////////////////////////////////////////////////// -// This function activates the private user timer allocated to the calling task -// in the boot phase. -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_timer_start() -{ - return sys_call( SYSCALL_TIMER_START, - 0, 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_timer_stop() -////////////////////////////////////////////////////////////////////////////////// -// This function activates the user timer allocated to the calling task. -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_timer_stop() -{ - return sys_call( SYSCALL_TIMER_STOP, - 0, 0, 0, 0 ); +/////////////////////// +void giet_timer_start() +{ + if ( sys_call( SYSCALL_TIMER_START, 0, 0, 0, 0 ) ) + giet_exit("error in giet_timer_start()"); +} + +////////////////////// +void giet_timer_stop() +{ + if ( sys_call( SYSCALL_TIMER_STOP, 0, 0, 0, 0 ) ) + giet_exit("error in giet_timer_stop()"); } @@ -455,88 +545,53 @@ ////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////// -// giet_fb_sync_write() -////////////////////////////////////////////////////////////////////////////////// -// This blocking function use a memory copy strategy to transfer data from a -// user buffer to the frame buffer device in kernel space. -// offset : offset (in bytes) in the frame buffer -// buffer : base address of the memory buffer -// length : number of bytes to be transfered -// - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space). -////////////////////////////////////////////////////////////////////////////////// -int giet_fb_sync_write( unsigned int offset, +//////////////////////////////////////////// +void giet_fb_sync_write( unsigned int offset, void * buffer, unsigned int length ) { - return sys_call( SYSCALL_FB_SYNC_WRITE, - offset, - (unsigned int)buffer, - length, - 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_fb_sync_read() -////////////////////////////////////////////////////////////////////////////////// -// This blocking function use a memory copy strategy to transfer data from the -// frame buffer device in kernel space to an user buffer. -// offset : offset (in bytes) in the frame buffer -// buffer : base address of the user buffer -// length : number of bytes to be transfered -// - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space). -////////////////////////////////////////////////////////////////////////////////// -int giet_fb_sync_read( unsigned int offset, - void * buffer, - unsigned int length ) -{ - return sys_call( SYSCALL_FB_SYNC_READ, - offset, - (unsigned int)buffer, - length, - 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_fb_cma_init() -////////////////////////////////////////////////////////////////////////////////// -// This function initializes the two chbuf SRC an DST used by the CMA controller -// and activates the CMA channel allocated to the calling task. -// - buf0 : first user buffer virtual address -// - buf0 : second user buffer virtual address -// - length : buffer size (bytes) -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_fb_cma_init( void * buf0, - void * buf1, - unsigned int length ) -{ - return sys_call( SYSCALL_FB_CMA_INIT, - (unsigned int)buf0, - (unsigned int)buf1, - length, - 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_fb_cma_write() -////////////////////////////////////////////////////////////////////////////////// -// This function set the valid status for one of the SRC user buffer. -// and reset the valid status for the DST frame buffer. -// - bufffer_id : 0 => buf0 valid is set / not 0 => buf1 valid is set -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_fb_cma_write( unsigned int buffer_id ) -{ - return sys_call( SYSCALL_FB_CMA_WRITE, - buffer_id, - 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_fb_cma_stop() -////////////////////////////////////////////////////////////////////////////////// -// This function desactivates the CMA channel allocated to the calling task. -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_fb_cma_stop( ) -{ - return sys_call( SYSCALL_FB_CMA_STOP, - 0, 0, 0, 0 ); + if ( sys_call( SYSCALL_FB_SYNC_WRITE, + offset, + (unsigned int)buffer, + length, + 0 ) ) giet_exit("error in giet_fb_sync_write()"); +} + +/////////////////////////////////////////// +void giet_fb_sync_read( unsigned int offset, + void * buffer, + unsigned int length ) +{ + if ( sys_call( SYSCALL_FB_SYNC_READ, + offset, + (unsigned int)buffer, + length, + 0 ) ) giet_exit("error in giet_fb_sync_read()"); +} + +///////////////////////////////////////// +void giet_fb_cma_init( void * buf0, + void * buf1, + unsigned int length ) +{ + if ( sys_call( SYSCALL_FB_CMA_INIT, + (unsigned int)buf0, + (unsigned int)buf1, + length, + 0 ) ) giet_exit("error in giet_fb_cma_init()"); +} + +/////////////////////////////////////////////// +void giet_fb_cma_write( unsigned int buffer_id ) +{ + if ( sys_call( SYSCALL_FB_CMA_WRITE, + buffer_id, + 0, 0, 0 ) ) giet_exit("error in giet_fb_cma_write()"); +} + +//////////////////////// +void giet_fb_cma_stop() +{ + if ( sys_call( SYSCALL_FB_CMA_STOP, + 0, 0, 0, 0 ) ) giet_exit("error in giet_fb_cma_stop()"); } @@ -546,151 +601,16 @@ ////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////// -// giet_nic_cma_init() -////////////////////////////////////////////////////////////////////////////////// -// This function initializes the memory chbuf used by the CMA controller, -// activates the NIC channel allocated to the calling task, and the CMA channel. -// - tx : RX channel if 0 / TX channel if non 0 -// - buf0 : first user buffer virtual address -// - buf1 : second user buffer virtual address -// - length : buffer size (bytes) -// - Returns 0 if success, > 0 if error -////////////////////////////////////////////////////////////////////////////////// -int giet_nic_cma_start() -{ - return sys_call( SYSCALL_NIC_CMA_START, - 0, 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_nic_cma_stop() -////////////////////////////////////////////////////////////////////////////////// -// This function desactivates the NIC channel and the two CMA channels -// allocated to the calling task. -// - Returns 0 if success, > 0 if error. -////////////////////////////////////////////////////////////////////////////////// -int giet_nic_cma_stop( ) -{ - return sys_call( SYSCALL_NIC_CMA_STOP, - 0, 0, 0, 0 ); -} - - -////////////////////////////////////////////////////////////////////////////////// -///////////////////// Miscellaneous system calls ///////////////////////////////// -////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////// -// giet_assert() -/////////////////////////////////////////////////////////////////////////////////// -// This function uses the giet_tty_puts() and giet_exit() system calls. -/////////////////////////////////////////////////////////////////////////////////// -void giet_assert( unsigned int condition, - char* string ) -{ - if ( condition == 0 ) - { - giet_tty_puts( string ); - giet_exit(); - } -} -////////////////////////////////////////////////////////////////////////////////// -// giet_vobj_get_vbase() -////////////////////////////////////////////////////////////////////////////////// -// This function writes in argument (vobj_vaddr) the virtual base address -// of a vobj (defined in the mapping_info data structure), identified by -// the two arguments (vspace_name and vobj_name). -// The (vobj_type) argument is redundant, and used for coherence checking. -// - Returns the address if success, 0 if error ( not defined or wrong type ) -////////////////////////////////////////////////////////////////////////////////// -int giet_vobj_get_vbase( char* vspace_name, - char* vobj_name, - unsigned int vobj_type, - unsigned int* vobj_vaddr ) -{ - return sys_call( SYSCALL_VOBJ_GET_VBASE, - (unsigned int) vspace_name, - (unsigned int) vobj_name, - (unsigned int) vobj_type, - (unsigned int) vobj_vaddr ); -} -//////////////////////////////////////////////////////////////////////////////////// -// giet_proc_number() -//////////////////////////////////////////////////////////////////////////////////// -// This function returns in the buffer argument the number of processors -// in the cluster specified by the cluster_id argument. -// - Returns 0 if success, > 0 if error ( cluster index too large ) -//////////////////////////////////////////////////////////////////////////////////// -int giet_proc_number( unsigned int cluster_id, - unsigned int* buffer ) -{ - return sys_call(SYSCALL_PROC_NUMBER, cluster_id, (unsigned int) buffer, 0, 0); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_exit() -////////////////////////////////////////////////////////////////////////////////// -// This function stops execution of the calling task with a TTY message, -// the user task is descheduled and becomes not runable. -// It does not consume processor cycles anymore. -////////////////////////////////////////////////////////////////////////////////// -void giet_exit() -{ - sys_call( SYSCALL_EXIT, - 0, 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_context_switch() -////////////////////////////////////////////////////////////////////////////////// -// The user task calling this function is descheduled and -// the processor is allocated to another task. -////////////////////////////////////////////////////////////////////////////////// -int giet_context_switch() -{ - return sys_call( SYSCALL_CTX_SWITCH, - 0, 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_proc_task_id() -////////////////////////////////////////////////////////////////////////////////// -// This functions returns the local task id. -// If processor has n tasks the local task index is ranging from 0 to n-1 -////////////////////////////////////////////////////////////////////////////////// -int giet_proc_task_id() -{ - return sys_call( SYSCALL_LOCAL_TASK_ID, - 0, 0, 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_heap_info() -////////////////////////////////////////////////////////////////////////////////// -// This function returns the base address and size of the current task's heap -////////////////////////////////////////////////////////////////////////////////// -int giet_heap_info( unsigned int* vaddr, - unsigned int* length ) -{ - return sys_call( SYSCALL_HEAP_INFO, - (unsigned int)vaddr, - (unsigned int)length, - 0, 0 ); -} -////////////////////////////////////////////////////////////////////////////////// -// giet_global_task_id() -////////////////////////////////////////////////////////////////////////////////// -// This functions returns the global task id, which is unique in all the giet. -////////////////////////////////////////////////////////////////////////////////// -int giet_global_task_id() -{ - return sys_call( SYSCALL_GLOBAL_TASK_ID, - 0, 0, 0, 0 ); -} - -////////////////////////////////////////////////////////////////////////////////// -// giet_thread_id() -////////////////////////////////////////////////////////////////////////////////// -// This functions returns the thread index of the current task. -////////////////////////////////////////////////////////////////////////////////// -int giet_thread_id() -{ - return sys_call( SYSCALL_THREAD_ID, - 0, 0, 0, 0 ); +///////////////////////// +void giet_nic_cma_start() +{ + if ( sys_call( SYSCALL_NIC_CMA_START, 0, 0, 0, 0 ) ) + giet_exit("error in giet_nic_cma_start()"); +} + +///////////////////////// +void giet_nic_cma_stop() +{ + if ( sys_call( SYSCALL_NIC_CMA_STOP, 0, 0, 0, 0 ) ) + giet_exit("error in giet_nic_cma_stop()"); } @@ -699,10 +619,5 @@ /////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////// -// giet_fat_open() -/////////////////////////////////////////////////////////////////////////////////// -// Open a file identified by a pathname, and contained in the system FAT. -// The read/write flags are not supported yet: no effect. -/////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////// int giet_fat_open( const char* pathname, unsigned int flags ) @@ -713,103 +628,118 @@ 0, 0 ); } + +//////////////////////////////////// +void giet_fat_read( unsigned int fd, + void* buffer, + unsigned int count, + unsigned int offset ) +{ + if ( sys_call( SYSCALL_FAT_READ, + fd, + (unsigned int)buffer, + count, + offset ) != count ) giet_exit("in giet_fat_read()"); +} + +///////////////////////////////////// +void giet_fat_write( unsigned int fd, + void* buffer, + unsigned int count, + unsigned int offset ) +{ + if ( sys_call( SYSCALL_FAT_WRITE, + fd, + (unsigned int)buffer, + count, + offset ) != count ) giet_exit("in giet_fat_write()"); +} + +/* variant implementing the UNIX spec /////////////////////////////////////////////////////////////////////////////////// -// giet_fat_read() +// This system call writes to a file identified by the "fd" file descriptor. +// - "buffer" is the source buffer virtual address (must be word aligned). +// - "count" is a number of bytes (must be multiple of 4). +// It uses the implicit "lseek" pointer in file descriptor. /////////////////////////////////////////////////////////////////////////////////// -// Read "count" sectors from a file identified by "fd", skipping "offset" -// sectors in file, and writing into the user "buffer". -// The user buffer base address shoulb be 64 bytes aligned. -/////////////////////////////////////////////////////////////////////////////////// -// This system call specification should evolve to the UNIX specification: -// - count must be a number of bytes, with no alignment constraint on user buffer. -// - offset argument should be removed and replaced by an implicit "lseek" pointer -// stored in the file descriptor. -// This suppose to implement a sectors cache -/////////////////////////////////////////////////////////////////////////////////// -int giet_fat_read( unsigned int fd, - void* buffer, - unsigned int count, - unsigned int offset ) -{ - return sys_call( SYSCALL_FAT_READ, - fd, - (unsigned int)buffer, - count, - offset ); -} -/////////////////////////////////////////////////////////////////////////////////// -// giet_fat_write() -/////////////////////////////////////////////////////////////////////////////////// -// Write "count" sectors from a file identified by "fd", skipping "offset" -// sectors in file, and reading from the user "buffer". -// The user buffer base address shoulb be 64 bytes aligned. -/////////////////////////////////////////////////////////////////////////////////// -// This system call specification should evolve to the UNIX specification: -// - count must be a number of bytes, with no alignment constraint on buffer -// - offset argument should be removed and replaced by an implicit "lseek" pointer -// stored in the file descriptor. -// This suppose to implement a sectors cache -/////////////////////////////////////////////////////////////////////////////////// -int giet_fat_write( unsigned int fd, +void giet_fat_write( unsigned int fd, void* buffer, - unsigned int count, - unsigned int offset ) + unsigned int count ) // number of bytes { return sys_call( SYSCALL_FAT_WRITE, fd, (unsigned int)buffer, - count, - offset ); -} -/////////////////////////////////////////////////////////////////////////////////// -// giet_fat_lseek() -/////////////////////////////////////////////////////////////////////////////////// -// Change the lseek file pointer value for a file identified by "fd". -/////////////////////////////////////////////////////////////////////////////////// -int giet_fat_lseek( unsigned int fd, + count, 0 ); +} +*/ + +///////////////////////////////////// +void giet_fat_lseek( unsigned int fd, unsigned int offset, - unsigned int whence) -{ - return sys_call( SYSCALL_FAT_LSEEK, - fd, - offset, - whence, - 0 ); -} - -/////////////////////////////////////////////////////////////////////////////////// -// giet_fat_fstat() -/////////////////////////////////////////////////////////////////////////////////// -// Return stats of a file identified by "fd". -// (Only the file_size in sectors for this moment) -/////////////////////////////////////////////////////////////////////////////////// -int giet_fat_fstat( unsigned int fd ) -{ - return sys_call( SYSCALL_FAT_FSTAT, - fd, - 0, 0, 0 ); -} - -/////////////////////////////////////////////////////////////////////////////////// -// giet_fat_close() -/////////////////////////////////////////////////////////////////////////////////// -// Close a file identified by "fd". -/////////////////////////////////////////////////////////////////////////////////// -int giet_fat_close( unsigned int fd ) -{ - return sys_call( SYSCALL_FAT_CLOSE, - fd, - 0, 0, 0 ); -} - - -/////////////////////////////////////////////////////////////////////////////////// -////////////////// Pseudo system calls (no syscall instruction) /////////////////// -/////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////// -// giet_rand() -// This function returns a pseudo-random value derived from the processor cycle -// count. This value is comprised between 0 & 65535. -/////////////////////////////////////////////////////////////////////////////////// + unsigned int whence ) +{ + if ( sys_call( SYSCALL_FAT_LSEEK, + fd, + offset, + whence, + 0 ) ) giet_exit("in giet_fat_lseek()"); +} + +////////////////////////////////////// +void giet_fat_fstat( unsigned int fd ) +{ + if ( sys_call( SYSCALL_FAT_FSTAT, + fd, + 0, 0, 0 ) ) giet_exit("in giet_fat_lseek()"); +} + +///////////////////////////////////// +void giet_fat_close( unsigned int fd ) +{ + if ( sys_call( SYSCALL_FAT_CLOSE, + fd, + 0, 0, 0 ) ) giet_exit("in giet_fat_close()"); +} + + +////////////////////////////////////////////////////////////////////////////////// +///////////////////// Miscellaneous system calls ///////////////////////////////// +////////////////////////////////////////////////////////////////////////////////// + +///////////////// +int giet_procid() +{ + return sys_call( SYSCALL_PROCID, + 0, 0, 0, 0 ); +} + +//////////////////// +int giet_proctime() +{ + return sys_call( SYSCALL_PROCTIME, + 0, 0, 0, 0 ); +} + +/////////////////////// +int giet_proc_task_id() +{ + return sys_call( SYSCALL_LOCAL_TASK_ID, + 0, 0, 0, 0 ); +} + +///////////////////////// +int giet_global_task_id() +{ + return sys_call( SYSCALL_GLOBAL_TASK_ID, + 0, 0, 0, 0 ); +} + +//////////////////// +int giet_thread_id() +{ + return sys_call( SYSCALL_THREAD_ID, + 0, 0, 0, 0 ); +} + +/////////////// int giet_rand() { @@ -822,4 +752,59 @@ } } + +////////////////////////////// +void giet_exit( char* string ) +{ + sys_call( SYSCALL_EXIT, + (unsigned int)string, + 0, 0, 0 ); +} + +///////////////////////////////////////// +void giet_assert( unsigned int condition, + char* string ) +{ + if ( condition == 0 ) giet_exit( string ); +} + +//////////////////////////////////////////////////// +void giet_vobj_get_vbase( char* vspace_name, + char* vobj_name, + unsigned int* vobj_vaddr ) +{ + if ( sys_call( SYSCALL_VOBJ_GET_VBASE, + (unsigned int) vspace_name, + (unsigned int) vobj_name, + (unsigned int) vobj_vaddr, + 0 ) ) giet_exit("in giet_vobj_get_vbase()"); +} + +/////////////////////////////////////////////// +void giet_proc_number( unsigned int cluster_id, + unsigned int* buffer ) +{ + if ( sys_call( SYSCALL_PROC_NUMBER, + cluster_id, + (unsigned int) buffer, + 0, 0) ) giet_exit("in giet_proc_number()"); +} + +////////////////////////// +void giet_context_switch() +{ + sys_call( SYSCALL_CTX_SWITCH, + 0, 0, 0, 0 ); +} + +///////////////////////////////////////// +void giet_heap_info( unsigned int* vaddr, + unsigned int* length ) +{ + if ( sys_call( SYSCALL_HEAP_INFO, + (unsigned int)vaddr, + (unsigned int)length, + 0, 0 ) ) giet_exit("in giet_heap_info()"); +} + // Local Variables: Index: /soft/giet_vm/giet_libs/stdio.h =================================================================== --- /soft/giet_vm/giet_libs/stdio.h (revision 294) +++ /soft/giet_vm/giet_libs/stdio.h (revision 295) @@ -18,6 +18,6 @@ #define SYSCALL_TIMER_START 0x04 #define SYSCALL_TIMER_STOP 0x05 -#define SYSCALL_FREE_06 0x06 -#define SYSCALL_FREE_07 0x07 +#define SYSCALL_TTY_GET_LOCK 0x06 +#define SYSCALL_TTY_RELEASE_LOCK 0x07 #define SYSCALL_HEAP_INFO 0x08 #define SYSCALL_LOCAL_TASK_ID 0x09 @@ -32,5 +32,5 @@ #define SYSCALL_FB_SYNC_READ 0x11 #define SYSCALL_THREAD_ID 0x12 -#define SYSCALL_TTY_LOCK 0x13 +#define SYSCALL_FREE_13 0x13 #define SYSCALL_FREE_14 0x14 #define SYSCALL_FREE_15 0x15 @@ -99,120 +99,331 @@ ////////////////////////////////////////////////////////////////////////// -// MIPS32 related system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_procid(); - -extern int giet_proctime(); - -////////////////////////////////////////////////////////////////////////// -// TTY device related system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_tty_putc(char byte); - -extern int giet_tty_puts(char* buf); - -extern int giet_tty_putw(unsigned int val); - -extern int giet_tty_getc_no_irq(char* byte); - -extern int giet_tty_getc(char* byte); - -extern int giet_tty_gets(char* buf, unsigned int bufsize); - -extern int giet_tty_getw(unsigned int* val); - -extern int giet_tty_printf(char* format,...); - -////////////////////////////////////////////////////////////////////////// -// TIMER device related system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_timer_start(); - -extern int giet_timer_stop(); +////////////////////////////////////////////////////////////////////////// +// MIPS32 related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// TTY device related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// This function is a modified version of the mutek_printf(). +// It uses a private terminal allocated to the calling task in the boot. +// ("use_tty" argument in xml mapping), and does not take the TTY lock. +// It calls several times the _tty_write system function. +// Only a limited number of formats are supported: +// - %d : signed decimal +// - %u : unsigned decimal +// - %x : 32 bits hexadecimal +// - %l : 64 bits hexadecimal +// - %c : char +// - %s : string +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_tty_printf( char* format, ... ); + +////////////////////////////////////////////////////////////////////////// +// This function is a modified version of the mutek_printf(). +// It uses the kernel TTY0 as a shared terminal, and it takes the +// TTY lock to get exclusive access during the format display. +// It calls several times the _tty_write system function. +// Only a limited number of formats are supported: +// - %d : signed decimal +// - %u : unsigned decimal +// - %x : 32 bits hexadecimal +// - %l : 64 bits hexadecimal +// - %c : char +// - %s : string +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_shr_printf( char* format, ... ); + +////////////////////////////////////////////////////////////////////////// +// This blocking function fetches a single character from the private +// terminal allocated to the calling task in the boot. +// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_tty_getc( char* byte ); + +////////////////////////////////////////////////////////////////////////// +// This blocking function fetches a string from the private terminal +// allocated to the calling task to a fixed length buffer. +// The terminal index must be defined in the task context in the boot. +// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer. +// - Up to (bufsize - 1) characters (including the non printable characters) +// are copied into buffer, and the string is completed by a NUL character. +// - The character is interpreted, and the function close the string +// with a NUL character if is read. +// - The character is interpreted, and the corresponding character(s) +// are removed from the target buffer. +// - It does not provide an echo. +// In case or error returned by syscall, it makes a giet_exit(). +///////////////////////////////////////////////////////////////////////// +extern void giet_tty_gets( char* buf, unsigned int bufsize ); + +///////////////////////////////////////////////////////////////////////// +// This blocking function fetches a string of decimal characters (most +// significant digit first) to build a 32-bit unsigned integer from +// the private TTY terminal allocated to the calling task. +// The terminal index must be defined in the task context in the boot. +// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer. +// - The non-blocking system function _tty_read is called several times, +// and the decimal characters are written in a 32 characters buffer +// until a character is read. +// - It ignores non-decimal characters, and displays an echo +// system function) for each decimal character. +// - The character is interpreted, and previous characters can be cancelled. +// - When the character is received, the string is converted to an +// unsigned int value. If the number of decimal digit is too large for the 32 +// bits range, the zero value is returned. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_tty_getw( unsigned int* val ); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// TIMER device related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// This function activates the private user timer allocated +// to the calling task in the boot phase. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_timer_start(); + +////////////////////////////////////////////////////////////////////////// +// This function stops the private user timer allocated +// to the calling task. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_timer_stop(); ////////////////////////////////////////////////////////////////////////// -// Frame buffer device related system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_fb_sync_read( unsigned int offset, - void* buffer, +////////////////////////////////////////////////////////////////////////// +// Frame buffer device related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// This blocking function use a memory copy strategy to transfer data +// from the frame buffer device in kernel space to an user buffer. +// offset : offset (in bytes) in the frame buffer +// buffer : base address of the user buffer +// length : number of bytes to be transfered +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_fb_sync_read( unsigned int offset, + void* buffer, + unsigned int length ); + +////////////////////////////////////////////////////////////////////////// +// This blocking function use a memory copy strategy to transfer data +// from a user buffer to the frame buffer device in kernel space. +// offset : offset (in bytes) in the frame buffer +// buffer : base address of the memory buffer +// length : number of bytes to be transfered +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_fb_sync_write( unsigned int offset, + void* buffer, + unsigned int length ); + +////////////////////////////////////////////////////////////////////////// +// This function initializes the two chbuf SRC an DST used by the CMA +// controller and activates the CMA channel allocated to the calling task. +// - buf0 : first user buffer virtual address +// - buf1 : second user buffer virtual address +// - length : buffer size (bytes) +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_fb_cma_init( void* buf0, + void* buf1, unsigned int length ); -extern int giet_fb_sync_write(unsigned int offset, - void* buffer, - unsigned int length); - -extern int giet_fb_cma_init( void* buf0, - void* buf1, - unsigned int length); - -extern int giet_fb_cma_write(unsigned int buf_id); - -extern int giet_fb_cma_stop(); - -////////////////////////////////////////////////////////////////////////// -// Network controller related system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_nic_cma_start(); - -extern int giet_nic_cma_stop(); - -////////////////////////////////////////////////////////////////////////// -// FAT related system calls -////////////////////////////////////////////////////////////////////////// - +////////////////////////////////////////////////////////////////////////// +// This function initializes the two chbuf SRC an DST used by the CMA +// controller and activates the CMA channel allocated to the calling task. +// - buf0 : first user buffer virtual address +// - buf0 : second user buffer virtual address +// - length : buffer size (bytes) +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_fb_cma_write( unsigned int buf_id ); + +////////////////////////////////////////////////////////////////////////// +// This function desactivates the CMA channel allocated to the task. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_fb_cma_stop(); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// NIC related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// This function initializes the memory chbuf used by the CMA controller, +// activates the NIC channel allocated to the calling task, +// and activates the two CMA channels. +// - tx : RX channel if 0 / TX channel if non 0 +// - buf0 : first user buffer virtual address +// - buf1 : second user buffer virtual address +// - length : buffer size (bytes) +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_nic_cma_start(); + +////////////////////////////////////////////////////////////////////////// +// This function desactivates the NIC channel and the two CMA channels +// allocated to the calling task. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_nic_cma_stop(); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// FAT related system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// Open a file identified by a pathname, and contained in the system FAT. +// The read/write flags are not supported yet: no effect. +// Return -1 in case or error. +////////////////////////////////////////////////////////////////////////// extern int giet_fat_open( const char* pathname, unsigned int flags ); -extern int giet_fat_read( unsigned int fd, - void* buffer, - unsigned int count, - unsigned int offset ); - -extern int giet_fat_write( unsigned int fd, - void* buffer, - unsigned int count, - unsigned int offset ); - -extern int giet_fat_lseek( unsigned int fd, - unsigned int offset, - unsigned int whence ); - -extern int giet_fat_fstat( unsigned int fd ); - -extern int giet_fat_close( unsigned int fd ); - -////////////////////////////////////////////////////////////////////////// -// Miscelaneous system calls -////////////////////////////////////////////////////////////////////////// - -extern int giet_vobj_get_vbase( char* vspace_name, - char* vobj_name, - unsigned int vobj_type, - unsigned int* vobj_vaddr); - -extern int giet_procnumber(); - +/////////////////////////////////////////////////////////////////////////////////// +// Read "count" sectors from a file identified by "fd", skipping "offset" +// sectors in file, and writing into the user "buffer". +// The user buffer base address shoulb be 64 bytes aligned. +// In case or error returned by syscall, it makes a giet_exit(). +/////////////////////////////////////////////////////////////////////////////////// +extern void giet_fat_read( unsigned int fd, + void* buffer, + unsigned int count, + unsigned int offset ); + +/////////////////////////////////////////////////////////////////////////////////// +// Write "count" sectors from a file identified by "fd", skipping "offset" +// sectors in file, and reading from the user "buffer". +// The user buffer base address shoulb be 64 bytes aligned. +// In case or error returned by syscall, it makes a giet_exit(). +/////////////////////////////////////////////////////////////////////////////////// +extern void giet_fat_write( unsigned int fd, + void* buffer, + unsigned int count, + unsigned int offset ); + +/////////////////////////////////////////////////////////////////////////////////// +// Change the lseek file pointer value for a file identified by "fd". +// In case or error returned by syscall, it makes a giet_exit(). +/////////////////////////////////////////////////////////////////////////////////// +extern void giet_fat_lseek( unsigned int fd, + unsigned int offset, + unsigned int whence ); + +/////////////////////////////////////////////////////////////////////////////////// +// Returns general informations of a file identified by "fd". +// (Only the file_size in sectors for this moment) +/////////////////////////////////////////////////////////////////////////////////// +extern void giet_fat_fstat( unsigned int fd ); + +////////////////////////////////////////////////////////////////////////// +// Close a file identified by "fd". +////////////////////////////////////////////////////////////////////////// +extern void giet_fat_close( unsigned int fd ); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// Miscelaneous system calls +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////// +// This function returns the processor identifier. +////////////////////////////////////////////////////////////////////////// +extern int giet_procid(); + +////////////////////////////////////////////////////////////////////////// +// This function returns the local processor time. +////////////////////////////////////////////////////////////////////////// +extern int giet_proctime(); + +////////////////////////////////////////////////////////////////////////// +// This functions returns the local task id. +// If processor has n tasks the local task index is ranging from 0 to n-1 +////////////////////////////////////////////////////////////////////////// +extern int giet_proc_task_id(); + +////////////////////////////////////////////////////////////////////////// +// This functions returns the global task id, (unique in the system). +////////////////////////////////////////////////////////////////////////// +extern int giet_global_task_id(); + +////////////////////////////////////////////////////////////////////////// +// This functions returns the thread index of the task in its vspace. +////////////////////////////////////////////////////////////////////////// +extern int giet_thread_id(); + +////////////////////////////////////////////////////////////////////////// +// This function returns a pseudo-random value derived from the processor +// cycle count. This value is comprised between 0 & 65535. +///////////////////////////////////////////////////////////////////////// +extern int giet_rand(); + +////////////////////////////////////////////////////////////////////////// +// This function stops execution of the calling task with a TTY message, +// the user task is descheduled and becomes not runable. +// It does not consume processor cycles anymore. +////////////////////////////////////////////////////////////////////////// extern void giet_exit(); -extern int giet_context_switch(); - -extern int giet_proc_task_id(); - -extern int giet_heap_info( unsigned int* vaddr, - unsigned int* size ); - -extern int giet_global_task_id(); - -extern int giet_thread_id(); - +////////////////////////////////////////////////////////////////////////// +// This function uses the giet_exit() system call +// and kill the calling task if the condition is false. +////////////////////////////////////////////////////////////////////////// extern void giet_assert( unsigned int, char* string ); -extern int giet_rand(); +////////////////////////////////////////////////////////////////////////// +// This function writes in argument "vobj_vaddr" the virtual base address +// of a vobj (defined in the mapping_info data structure), identified by +// the two arguments "vspace_name" and "vobj_name". +// In case or error returned by syscall, it makes a giet_exit(). +// ( vobj not defined or wrong vspace ) +////////////////////////////////////////////////////////////////////////// +extern void giet_vobj_get_vbase( char* vspace_name, + char* vobj_name, + unsigned int* vobj_vaddr); + +////////////////////////////////////////////////////////////////////////// +// This function returns in the "buffer" argument the number of processors +// in the cluster specified by the "cluster_xy" argument. +// In case or error returned by syscall, it makes a giet_exit(). +////////////////////////////////////////////////////////////////////////// +extern void giet_procnumber( unsigned int cluster_xy, + unsigned int buffer ); + +////////////////////////////////////////////////////////////////////////// +// The user task calling this function is descheduled and +// the processor is allocated to another task. +////////////////////////////////////////////////////////////////////////// +extern void giet_context_switch(); + +////////////////////////////////////////////////////////////////////////// +// This function returns the base address and size of the task's heap +////////////////////////////////////////////////////////////////////////// +extern void giet_heap_info( unsigned int* vaddr, + unsigned int* size ); + #endif Index: /soft/giet_vm/giet_xml/mapping_info.h =================================================================== --- /soft/giet_vm/giet_xml/mapping_info.h (revision 294) +++ /soft/giet_vm/giet_xml/mapping_info.h (revision 295) @@ -30,5 +30,5 @@ // - mapping_vspace_t vspace[] // - mapping_vseg_t vseg[] -// - mapping_vseg_t vobj[] +// - mapping_vobj_t vobj[] // - mapping_task_t task[] // - mapping_proc_t proc[] @@ -61,5 +61,5 @@ #define U_MODE_MASK 0b0001 // user access -#define IN_MAPPING_SIGNATURE 0xDEADBEEF +#define IN_MAPPING_SIGNATURE 0xDACE2014 #define OUT_MAPPING_SIGNATURE 0xBABEF00D @@ -85,5 +85,5 @@ { IRQ_TYPE_HWI = 0, // HARD in map.xml file - IRQ_TYPE_SWI = 1, // SOFT in map.xml file, + IRQ_TYPE_WTI = 1, // SOFT in map.xml file, IRQ_TYPE_PTI = 2, // TIME in map.xml file, }; @@ -115,6 +115,7 @@ PERIPH_TYPE_TTY = 12, PERIPH_TYPE_XCU = 13, - - PERIPH_TYPE_MAX_VALUE = 14, + PERIPH_TYPE_PIC = 14, + + PERIPH_TYPE_MAX_VALUE = 15, }; @@ -145,30 +146,9 @@ unsigned int globals; // number of vsegs mapped in all vspaces unsigned int vspaces; // number of virtual spaces - unsigned int increment; // vseg cluster increment for replicated periphs + unsigned int x_io; // x coordinate for cluster_io_ext + unsigned int y_io; // y coordinate for cluster_io_ext unsigned int irq_per_proc; // number of IRQ per processor - - unsigned int cma_cluster; // index of cluster containing CMA controler - unsigned int cma_cluster_bis; // index of cluster containing second CMA controler - - unsigned int fbf_cluster; // index of cluster containing FBF controler - unsigned int fbf_cluster_bis; // index of cluster containing second FBF controler - - unsigned int iob_cluster; // index of cluster containing IOB controler - unsigned int iob_cluster_bis; // index of cluster containing second IOB controler - - unsigned int ioc_cluster; // index of cluster containing IOC controler - unsigned int ioc_cluster_bis; // index of cluster containing second IOC controler - - unsigned int nic_cluster; // index of cluster containing NIC controler - unsigned int nic_cluster_bis; // index of cluster containing second NIC controler - - unsigned int rom_cluster; // index of cluster containing ROM controler - unsigned int rom_cluster_bis; // index of cluster containing second ROM controler - - unsigned int sim_cluster; // index of cluster containing SIM controler - unsigned int sim_cluster_bis; // index of cluster containing second SIM controler - - unsigned int tty_cluster; // index of cluster containing TTY controler - unsigned int tty_cluster_bis; // index of cluster containing second TTY controler + unsigned int use_ramdisk; // does not use IOC peripheral if non zero + unsigned int increment; // vbase address increment (replicated peripherals) unsigned int psegs; // total number of physical segments (for all clusters) @@ -286,17 +266,6 @@ typedef struct __attribute__((packed)) mapping_proc_s { - unsigned int irqs; // number of IRQs allocated to processor - unsigned int irq_offset; // index of first IRQ allocated to processor + unsigned int index; // processor local index (in cluster) } mapping_proc_t; - - -///////////////////////////////////////////////////// -typedef struct __attribute__((packed)) mapping_irq_s -{ - unsigned int type; // HWI / SWI / PTI - unsigned int icuid; // IRQ Index for the ICU component - unsigned int isr; // ISR Index (defined in irq_handler.h) - unsigned int channel; // Channel Index (for multi-channels peripherals) -} mapping_irq_t; @@ -323,9 +292,24 @@ typedef struct __attribute__((packed)) mapping_periph_s { - unsigned int type; + unsigned int type; // legal values defined above unsigned int subtype; // periph specialization unsigned int psegid; // pseg index in cluster unsigned int channels; // number of channels + unsigned int irqs; // number of input IRQs (for ICU, XCU or PIC) + unsigned int irq_offset; // index of first IRQ (can be HWI/PTI/WTI) } mapping_periph_t; + + +///////////////////////////////////////////////////// +typedef struct __attribute__((packed)) mapping_irq_s +{ + unsigned int srctype; // source IRQ type (HWI / WTI / PTI) + unsigned int srcid; // source IRQ index (for ICU/PIC component) + unsigned int isr; // ISR type (defined in irq_handler.h) + unsigned int channel; // channel index (for multi-channels peripherals) + unsigned int dstx; // x coordinate of destination cluster + unsigned int dsty; // y coordinate of destination cluster + unsigned int dstid; // destination IRQ index (can be PROC or ICU) +} mapping_irq_t; Index: /soft/giet_vm/giet_xml/xml_driver.c =================================================================== --- /soft/giet_vm/giet_xml/xml_driver.c (revision 294) +++ /soft/giet_vm/giet_xml/xml_driver.c (revision 295) @@ -18,5 +18,7 @@ ////////////////////////////////////////////////////// -void buildXml(mapping_header_t * header, FILE * fpout) { +void buildXml(mapping_header_t * header, FILE * fpout) +{ + // mnemonics defined in mapping_info.h const char * vobj_type[] = { @@ -27,5 +29,5 @@ "MWMR", // MWMR channel "LOCK", // Spin-Lock - "BUFFER", // Any "no intialiasation needed" objects (stacks...) + "BUFFER", // Any "no intialiasation needed" object (stacks...) "BARRIER", // Barrier "CONST", // Constant @@ -34,28 +36,36 @@ }; + // mnemonics defined in mapping_info.h const char * pseg_type[] = { "RAM", - "ROM", + "ROM", // deprecated => use PERI "PERI", }; + // mnemonics defined in mapping_info.h const char * irq_type[] = { - "HARD", - "SOFT", - "TIME", - }; - + "HWI", + "WTI", + "PTI", + }; + + // mnemonics defined in irq_handler.h const char * isr_type[] = { - "ISR_DEFAULT", - "ISR_SWITCH", - "ISR_TTY", - "ISR_DMA", - "ISR_IOC", + "ISR_DEFAULT", + "ISR_TICK", + "ISR_TTY_RX", + "ISR_TTY_TX", + "ISR_BDV", "ISR_TIMER", - }; - + "ISR_WAKUP", + "ISR_NIC_RX", + "ISR_NIC_TX", + "ISR_CMA", + }; + + // mnemonics defined in mapping_info.h const char * periph_type[] = { @@ -74,7 +84,8 @@ "TTY", "XCU", - }; - - const char * periph_subtype[] = + "PIC", + }; + + const char * ioc_subtype[] = { "BDV", @@ -242,7 +253,8 @@ fprintf(fpout, " x_width = \"%d\" \n" , header->x_width); fprintf(fpout, " y_width = \"%d\" \n" , header->y_width); - fprintf(fpout, " vspaces = \"%d\" \n" , header->vspaces); - fprintf(fpout, " increment = \"%d\" \n" , header->vspaces); - fprintf(fpout, " irq_per_proc = \"%d\" >\n\n", header->irq_per_proc); + fprintf(fpout, " irq_per_proc = \"%d\" \n" , header->irq_per_proc); + fprintf(fpout, " use_ramdisk = \"%d\" \n" , header->use_ramdisk); + fprintf(fpout, " x_io = \"%d\" \n" , header->x_io); + fprintf(fpout, " y_io = \"%d\" >\n\n", header->y_io); ///////////////////// clusters /////////////////////////////////////////////// @@ -271,19 +283,8 @@ for (proc_id = cluster[cluster_id].proc_offset; proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs; - proc_id++) - { - fprintf(fpout, " \n", proc_index); - for (irq_id = proc[proc_id].irq_offset; - irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs; - irq_id++) - { - fprintf(fpout, " \n", irq[irq_id].channel); - } - fprintf(fpout, " \n" ); - } - + proc_id++, proc_index++) + { + fprintf(fpout, " \n", proc_index); + } ///////////////////// coprocessors /////////////////////////////////////////// @@ -316,8 +317,21 @@ if (periph[periph_id].subtype < PERIPH_SUBTYPE_MAX_VALUE) - fprintf(fpout, " subtype = \"%s\" ", periph_subtype[periph[periph_id].subtype]); + fprintf(fpout, " subtype = \"%s\" ", ioc_subtype[periph[periph_id].subtype]); fprintf(fpout, " psegname = \"%s\" ", pseg[periph[periph_id].psegid].name); - fprintf(fpout, " channels = \"%d\" />\n", periph[periph_id].channels); + fprintf(fpout, " channels = \"%d\" >\n", periph[periph_id].channels); + for (irq_id = periph[periph_id].irq_offset; + irq_id < periph[periph_id].irq_offset + periph[periph_id].irqs; + irq_id++) + { + fprintf(fpout, " \n", irq[irq_id].dstid); + } + fprintf(fpout, " \n"); } fprintf(fpout, " \n" ); Index: /soft/giet_vm/giet_xml/xml_parser.c =================================================================== --- /soft/giet_vm/giet_xml/xml_parser.c (revision 294) +++ /soft/giet_vm/giet_xml/xml_parser.c (revision 295) @@ -104,28 +104,29 @@ char found_mmc = 0; - -//////////////////////////////////////////////////////////////////// -// These variables are used to generate the hard_config.h file -//////////////////////////////////////////////////////////////////// - -unsigned int nb_proc_max = 0; // max number of processors per cluster +//////////////////////////////////////////////////////////////////////// +// These variables are used to generate the hard_config.h file. +//////////////////////////////////////////////////////////////////////// + +unsigned int nb_procs_max = 0; // max number of processors per cluster unsigned int nb_tasks_max = 0; // max number of tasks (in all vspaces) -unsigned int tim_channels = 0; // max number of user timers (per cluster) -unsigned int dma_channels = 0; // max number of DMA channels (per cluster) - -unsigned int icu_channels = 0; // total number of channels in ICU/XICU -unsigned int tty_channels = 0; // total number of terminals in TTY -unsigned int hba_channels = 0; // total number of channels in HBA -unsigned int nic_channels = 0; // total number of channels in NIC -unsigned int cma_channels = 0; // total number of channels in CMA +unsigned int tim_channels = 0; // number of user timers (per cluster) +unsigned int dma_channels = 0; // number of DMA channels (per cluster) + +unsigned int tty_channels = 0; // number of TTY channels +unsigned int ioc_channels = 0; // number of HBA channels +unsigned int nic_channels = 0; // number of NIC channels +unsigned int cma_channels = 0; // number of CMA channels +unsigned int pic_channels = 0; // number of PIC channels unsigned int use_iob = 0; // using IOB component +unsigned int use_pic = 0; // using PIC component unsigned int use_xcu = 0; // using XCU (not ICU) // These variables define the IOC peripheral subtype -unsigned int use_hba = 0; // using HBA -unsigned int use_bdv = 0; // using SoCLIB block device -unsigned int use_spi = 0; // using SD Card-SPI + +unsigned int use_hba = 0; // using SoClib AHCI controller +unsigned int use_bdv = 0; // using SoCLIB block device controller +unsigned int use_spi = 0; // using SDCard-SPI //////////////////////////////////////////////////////////////// @@ -283,8 +284,15 @@ /////////////////////////////////////////////////////////////////////////////////// -// This function set the vbase address for all peripheral types. -// For replicated peripherals with the same type the virtual base address must be: -// vbase = seg_type_base & 0XFF000000 + -// (cluster_id * vbase_cluster_increment) & 0x00FF0000 +// This function set the vbase addresses for all peripheral types, in order +// to generate the ldscript file, that contains one single virtual address +// for peripherals replicated in all clusters, and one virtual addresses for +// each non replicated peripheral type. +// +// It makes the following checks on the virtual addresses: +// +// - For replicated peripherals the virtual base address must be: +// vbase = seg_type_base & 0XFF000000 + (cluster_xy * increment) & 0x00FF0000 +// +// - For non-replicated peripherals, the cluster index must be cluster_io. /////////////////////////////////////////////////////////////////////////////////// void set_periph_vbase_array() @@ -300,5 +308,7 @@ unsigned int cluster_mask = 0x00FF0000; - // We are analysing all vsegs corresponding to a peripheral +#if XML_PARSER_DEBUG +printf("\n set peripherals vbase array\n"); +#endif // scan all vsegs @@ -308,5 +318,9 @@ if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI ) { - pseg_id = vseg[vseg_id]->psegid; + pseg_id = vseg[vseg_id]->psegid; + +#if XML_PARSER_DEBUG +printf(" - found vseg %s with psegid = %d", vseg[vseg_id]->name, pseg_id ); +#endif // scan all periphs to retrieve peripheral type (same psegid) @@ -315,17 +329,37 @@ if( periph[periph_id]->psegid == pseg_id ) // matching !!! { - type = periph[periph_id]->type; - if ( periph_vbase_array[type] == 0xFFFFFFFF ) // vbase not set + cluster_id = pseg[pseg_id]->clusterid; + type = periph[periph_id]->type; + +#if XML_PARSER_DEBUG +printf(" / matching periph type %d\n", type ); +#endif + + if ( (type == PERIPH_TYPE_DMA) || + (type == PERIPH_TYPE_MMC) || + (type == PERIPH_TYPE_ICU) || + (type == PERIPH_TYPE_XCU) || + (type == PERIPH_TYPE_TIM) ) // replicated peripheral { - periph_vbase_array[type] = vseg[vseg_id]->vbase & type_mask; - } - else // vbase already set - { - // checking mask bits - if( (vseg[vseg_id]->vbase & type_mask) != - (periph_vbase_array[type]) ) + cluster_xy = (cluster[cluster_id]->x << header->y_width) + + cluster[cluster_id]->y; + + if( (vseg[vseg_id]->vbase & cluster_mask) != + (header->increment * cluster_xy) ) { - printf("[XML ERROR] All peripherals with same type "); - printf(" should share the same 8 MSB bits in base address\n"); + printf("[XML ERROR] All replicated peripherals " + "must have cluster bits = cluster_xy * increment\n"); + printf("periph index = %d / periph type = %d / vbase = %x\n", + periph_id, type, vseg[vseg_id]->vbase); + exit(1); + } + else if ( periph_vbase_array[type] == 0xFFFFFFFF ) // vbase not set + { + periph_vbase_array[type] = vseg[vseg_id]->vbase & type_mask; + } + else if ((vseg[vseg_id]->vbase & type_mask) != (periph_vbase_array[type])) + { + printf("[XML ERROR] All peripherals with same type" + " should share the same 8 MSB bits in vbase address\n"); printf("periph index = %d / periph type = %d / vbase = %x\n", periph_id, type, vseg[vseg_id]->vbase); @@ -333,26 +367,20 @@ } } - - // checking cluster bits for all replicated peripherals - if ( (type == PERIPH_TYPE_DMA) || - (type == PERIPH_TYPE_MMC) || - (type == PERIPH_TYPE_ICU) || - (type == PERIPH_TYPE_XCU) || - (type == PERIPH_TYPE_TIM) ) + else // non replicated peripheral { - cluster_id = pseg[pseg_id]->clusterid; - cluster_xy = (cluster[cluster_id]->x << header->y_width) + - cluster[cluster_id]->y; - - if( (vseg[vseg_id]->vbase & cluster_mask) != - (header->increment * cluster_xy) ) + if ( (cluster[cluster_id]->x == header->x_io) && + (cluster[cluster_id]->y == header->y_io) ) { - printf("[XML ERROR] All replicated peripherals "); - printf("must have cluster bits = cluster_id * increment"); - printf("periph index = %d / periph type = %d / vbase = %x\n", - periph_id, type, vseg[vseg_id]->vbase); + periph_vbase_array[type] = vseg[vseg_id]->vbase; + } + else + { + printf("[XML ERROR] Non replicated peripherals must be in cluster_io\n"); + printf(" periph index = %d / periph type = %d / vbase = %x" + " / pseg index = %d / cluster index = %d\n", + periph_id, type, vseg[vseg_id]->vbase, pseg_id, cluster_id); exit(1); } - } + } } } @@ -428,4 +456,81 @@ } +/////////////////////////////////////////////////////////// +unsigned int alignTo( unsigned int value, unsigned int pow2 ) +{ + unsigned int mask = (1 << pow2) - 1; + return ( (value + mask) & ~mask); +} + +//////////////////// +void setVsegLength() +{ + // for a given vseg identified vseg_index + // scan all contained vobjs to compute the vseg lenth + + unsigned int vobj_id; + unsigned int cur_length = 0; + + unsigned int first = vseg[vseg_index]->vobj_offset; + unsigned int last = first + vseg[vseg_index]->vobjs; + + for ( vobj_id = first ; vobj_id < last ; vobj_id++ ) + { + if (vobj[vobj_id]->align) + { + cur_length = alignTo( cur_length, vobj[vobj_id]->align ); + } + cur_length += vobj[vobj_id]->length; + } + vseg[vseg_index]->length = alignTo( cur_length, 12 ); +} + +/////////////////////// +void checkVsegOverlap() +{ + // for a given vseg identified by vseg_index, + // check overlap with all vsegs in same vspace, + // and check overlap with all global vsegs. + + unsigned int vseg_id; + unsigned int prev_vbase; // previous vseg vbase + unsigned int prev_length; // previous vseg length + + unsigned int vbase = vseg[vseg_index]->vbase; // new vseg vbase + unsigned int length = vseg[vseg_index]->length; // new vseg length + + // checking overlap with other vsegs in same vspace + if ( header->vspaces > 0 ) + { + unsigned int first = vspace[vspace_index]->vseg_offset; + unsigned int last = vseg_index; + + for( vseg_id = first ; vseg_id < last ; vseg_id++ ) + { + prev_vbase = vseg[vseg_id]->vbase; + prev_length = vseg[vseg_id]->length; + if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) ) + { + printf("[XML ERROR] vseg %s in vspace %s overlaps other vseg %s\n", + vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name ); + exit(1); + } + } + } + + // checking overlap with existing global vsegs + for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ ) + { + prev_vbase = vseg[vseg_id]->vbase; + prev_length = vseg[vseg_id]->length; + if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) ) + { + printf("[XML ERROR] vseg %s in vspace %s overlaps global vseg %s\n", + vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name ); + exit(1); + } + } +} + ////////////////////////////////////// void taskNode(xmlTextReaderPtr reader) @@ -466,15 +571,12 @@ } - ///////// get x coordinate + ///////// get trdid attribute (optional) task[task_index]->trdid = getIntValue(reader, "trdid", &ok); #if XML_PARSER_DEBUG -printf(" x = %d\n", x); +printf(" trdid = %d\n", x); #endif if ( !ok ) { task[task_index]->trdid = task_loc_index; - printf("[XML WARNING] missing trdid (thread index) attribute " - "for task in vspace %d. Using value %d\n" - , vspace_index, task_loc_index); } @@ -720,7 +822,8 @@ ////////// get length attribute value = getIntValue(reader, "length", &ok); - if (ok) { -#if XML_PARSER_DEBUG -printf(" length = %d\n", value); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" length = %x\n", value); #endif vobj[vobj_index]->length = value; @@ -734,5 +837,6 @@ ////////// get align attribute (optional : 0 if missing) value = getIntValue(reader, "align", &ok); - if (ok) { + if (ok) + { #if XML_PARSER_DEBUG printf(" align = %d\n", value); @@ -740,5 +844,6 @@ vobj[vobj_index]->align = value; } - else { + else + { vobj[vobj_index]->align = 0; } @@ -746,5 +851,6 @@ ////////// get binpath attribute (optional : '\0' if missing) str = getStringValue(reader, "binpath", &ok); - if (ok) { + if (ok) + { #if XML_PARSER_DEBUG printf(" binpath = %s\n", str); @@ -958,4 +1064,6 @@ { vseg[vseg_index]->vobjs = vobj_count; + setVsegLength(); + checkVsegOverlap(); vseg_index++; vseg_loc_index++; @@ -984,11 +1092,4 @@ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; - // checking source file consistency - if (vspace_index >= header->vspaces) { - printf("[XML ERROR] The vspace index is too large : %d\n", - vspace_index); - exit(1); - } - #if XML_PARSER_DEBUG printf("\n vspace %d\n", vspace_index); @@ -996,4 +1097,5 @@ vspace[vspace_index] = (mapping_vspace_t *) malloc(sizeof(mapping_vspace_t)); + header->vspaces = header->vspaces + 1; ////////// get name attribute @@ -1036,5 +1138,6 @@ int status = xmlTextReaderRead(reader); - while (status == 1) { + while (status == 1) + { const char * tag = (const char *) xmlTextReaderConstName(reader); @@ -1050,5 +1153,6 @@ else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } - else if (strcmp(tag, "vspace") == 0) { + else if (strcmp(tag, "vspace") == 0) + { vspace[vspace_index]->vobjs = vobj_loc_index; vspace[vspace_index]->tasks = task_loc_index ; @@ -1099,4 +1203,196 @@ } // end vspaceNode() +///////////////////////////////////// +void irqNode(xmlTextReaderPtr reader) +{ + unsigned int ok; + unsigned int value; + char * str; + + if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; + + if (irq_index >= MAX_IRQS) + { + printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS); + } + +#if XML_PARSER_DEBUG +printf(" irq %d\n", irq_loc_index); +#endif + + irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t)); + + ///////// get srctype attribute + str = getStringValue(reader, "srctype", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" srctype = %s\n", str); +#endif + if ( strcmp(str, "HWI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_HWI; + else if ( strcmp(str, "WTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_WTI; + else if ( strcmp(str, "PTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_PTI; + else + { + printf("[XML ERROR] illegal IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + ///////// get srcid attribute + value = getIntValue(reader, "srcid", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" srcid = %d\n", value); +#endif + irq[irq_index]->srcid = value; + if (value >= 32) + { + printf("[XML ERROR] IRQ too large for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + ///////// get isr attribute + str = getStringValue(reader, "isr", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" isr = %s\n", str); +#endif + if (strcmp(str, "ISR_TICK" ) == 0) irq[irq_index]->isr = ISR_TICK; + else if (strcmp(str, "ISR_BDV" ) == 0) irq[irq_index]->isr = ISR_BDV; + else if (strcmp(str, "ISR_CMA" ) == 0) irq[irq_index]->isr = ISR_CMA; + else if (strcmp(str, "ISR_TTY_RX" ) == 0) irq[irq_index]->isr = ISR_TTY_RX; + else if (strcmp(str, "ISR_TTY_TX" ) == 0) irq[irq_index]->isr = ISR_TTY_TX; + else if (strcmp(str, "ISR_TIMER" ) == 0) irq[irq_index]->isr = ISR_TIMER; + else if (strcmp(str, "ISR_WAKUP" ) == 0) irq[irq_index]->isr = ISR_WAKUP; + else if (strcmp(str, "ISR_NIC_RX" ) == 0) irq[irq_index]->isr = ISR_NIC_RX; + else if (strcmp(str, "ISR_NIC_TX" ) == 0) irq[irq_index]->isr = ISR_NIC_TX; + else if (strcmp(str, "ISR_DEFAULT") == 0) irq[irq_index]->isr = ISR_DEFAULT; + else + { + printf("[XML ERROR] illegal IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + ///////// get channel attribute (optionnal : 0 if missing) + value = getIntValue(reader, "channel", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" channel = %d\n", value); +#endif + irq[irq_index]->channel = value; + } + else + { + irq[irq_index]->channel = 0; + } + + ///////// get dstx attribute + value = getIntValue(reader, "dstx", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" dstx = %d\n", value); +#endif + + if ( value < header->x_size ) + { + irq[irq_index]->dstx = value; + } + else + { + printf("[XML ERROR] IRQ too large for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + ///////// get dsty attribute + value = getIntValue(reader, "dsty", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" dsty = %d\n", value); +#endif + + if ( value < header->y_size ) + { + irq[irq_index]->dsty = value; + } + else + { + printf("[XML ERROR] IRQ too large for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + ///////// get dstid attribute + value = getIntValue(reader, "dstid", &ok); + if (ok) + { +#if XML_PARSER_DEBUG +printf(" dstid = %d\n", value); +#endif + irq[irq_index]->dstid = value; + if (value >= 32) + { + printf("[XML ERROR] IRQ too large for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + } + else + { + printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", + cluster_index, periph_loc_index); + exit(1); + } + + irq_index++; + irq_loc_index++; + +} // end irqNode + + + //////////////////////////////////////// void cpPortNode(xmlTextReaderPtr reader) @@ -1115,5 +1411,5 @@ #if XML_PARSER_DEBUG - printf("\n port %d\n", cp_port_index); +printf("\n port %d\n", cp_port_index); #endif @@ -1126,5 +1422,5 @@ { #if XML_PARSER_DEBUG - printf(" direction = %s\n", str); +printf(" direction = %s\n", str); #endif if (strcmp(str, "TO_COPROC") == 0) @@ -1153,5 +1449,5 @@ str = getStringValue(reader, "vspacename", &ok); #if XML_PARSER_DEBUG - printf(" vspacename = %s\n", str); +printf(" vspacename = %s\n", str); #endif if (ok) @@ -1169,5 +1465,5 @@ str = getStringValue(reader, "vobjname", &ok); #if XML_PARSER_DEBUG - printf(" vobjname = %s\n", str); +printf(" vobjname = %s\n", str); #endif if (ok) @@ -1192,4 +1488,6 @@ unsigned int ok; + irq_loc_index = 0; + if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; @@ -1201,5 +1499,5 @@ #if XML_PARSER_DEBUG - printf("\n periph %d\n", periph_index); +printf("\n periph %d\n", periph_index); #endif @@ -1211,5 +1509,5 @@ { #if XML_PARSER_DEBUG - printf(" channels = %d\n", value); +printf(" channels = %d\n", value); #endif periph[periph_index]->channels = value; @@ -1234,7 +1532,7 @@ { #if XML_PARSER_DEBUG - printf(" clusterid = %d\n", cluster_index); - printf(" psegname = %s\n", str); - printf(" psegid = %d\n", index); +printf(" clusterid = %d\n", cluster_index); +printf(" psegname = %s\n", str); +printf(" psegid = %d\n", index); #endif periph[periph_index]->psegid = index; @@ -1252,5 +1550,5 @@ { #if XML_PARSER_DEBUG - printf(" type = %s\n", str); +printf(" type = %s\n", str); #endif unsigned int error = 0; @@ -1260,6 +1558,5 @@ // The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, peripherals are not - // replicated in all clusters but can be replicated in two clusters (fault tolerance) - // In case of replication, the two copies must have same number of channels. + // replicated in all clusters but can be instanciated twice. //////////////////////////// @@ -1267,19 +1564,8 @@ { periph[periph_index]->type = PERIPH_TYPE_CMA; - if (header->cma_cluster == 0xFFFFFFFF) + if ( cma_channels < periph[periph_index]->channels ) { - header->cma_cluster = cluster_index; cma_channels = periph[periph_index]->channels; } - else if (header->cma_cluster_bis == 0xFFFFFFFF) - { - header->cma_cluster_bis = cluster_index; - assert( (cma_channels == periph[periph_index]->channels) && - "[XML ERROR] unconsistent non replicated peripheral"); - } - else - { - error = 1; - } } ///////////////////////////////// @@ -1287,16 +1573,4 @@ { periph[periph_index]->type = PERIPH_TYPE_FBF; - if (header->fbf_cluster == 0xFFFFFFFF) - { - header->fbf_cluster = cluster_index; - } - else if (header->fbf_cluster_bis == 0xFFFFFFFF) - { - header->fbf_cluster_bis = cluster_index; - } - else - { - error = 1; - } } ///////////////////////////////// @@ -1305,69 +1579,35 @@ periph[periph_index]->type = PERIPH_TYPE_IOB; use_iob = 1; - if (header->iob_cluster == 0xFFFFFFFF) - { - header->iob_cluster = cluster_index; - } - else if (header->iob_cluster_bis == 0xFFFFFFFF) - { - header->iob_cluster_bis = cluster_index; - } - else - { - error = 1; - } } ///////////////////////////////// else if (strcmp(str, "IOC") == 0) { - periph[periph_index]->type = PERIPH_TYPE_IOC; - if (header->ioc_cluster == 0xFFFFFFFF) - { - header->ioc_cluster = cluster_index; - } - else if (header->ioc_cluster_bis == 0xFFFFFFFF) - { - header->ioc_cluster_bis = cluster_index; - } - else - { - printf("[XML ERROR] At most two copies for non replicated " - "peripheral\n"); - exit(1); - } - - str = getStringValue(reader, "subtype", &ok); - + char* subtype = getStringValue(reader, "subtype", &ok); if (!ok) { - printf("[XML ERROR] IOC peripheral needs a subtype parameter: " - "BDV, HBA or SPI\n"); + printf("[XML ERROR] IOC peripheral needs a subtype: BDV, HBA or SPI\n"); exit(1); } - if (strcmp(str, "BDV") == 0) - { + if ( strcmp(subtype, "BDV") == 0 ) + { + periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV; - use_bdv = 1; + ioc_channels = 1; + if ( header->use_ramdisk == 0 ) use_bdv = 1; } - else if (strcmp(str, "HBA") == 0) + else if ( strcmp(subtype, "HBA") == 0 ) { + periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA; - - if (use_hba == 0) - { - use_hba = 1; - hba_channels = periph[periph_index]->channels; - } - else - { - assert( (hba_channels == periph[periph_index]->channels) && - "[XML ERROR] unconsistent non replicated peripheral"); - } + ioc_channels = periph[periph_index]->channels; + if ( header->use_ramdisk == 0 ) use_hba = 1; } - else if (strcmp(str, "SPI") == 0) + else if ( strcmp(subtype, "SPI") == 0 ) { + periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI; - use_spi = 1; + ioc_channels = periph[periph_index]->channels; + if ( header->use_ramdisk == 0 ) use_spi = 1; } else @@ -1381,19 +1621,8 @@ { periph[periph_index]->type = PERIPH_TYPE_NIC; - if (header->nic_cluster == 0xFFFFFFFF) + if ( nic_channels < periph[periph_index]->channels ) { - header->nic_cluster = cluster_index; nic_channels = periph[periph_index]->channels; } - else if (header->nic_cluster_bis == 0xFFFFFFFF) - { - header->nic_cluster_bis = cluster_index; - assert( (nic_channels == periph[periph_index]->channels) && - "[XML ERROR] unconsistent non replicated peripheral"); - } - else - { - error = 1; - } } ///////////////////////////////// @@ -1401,16 +1630,4 @@ { periph[periph_index]->type = PERIPH_TYPE_ROM; - if (header->rom_cluster == 0xFFFFFFFF) - { - header->rom_cluster = cluster_index; - } - else if (header->rom_cluster_bis == 0xFFFFFFFF) - { - header->rom_cluster_bis = cluster_index; - } - else - { - error = 1; - } } ///////////////////////////////// @@ -1418,16 +1635,4 @@ { periph[periph_index]->type = PERIPH_TYPE_SIM; - if (header->sim_cluster == 0xFFFFFFFF) - { - header->sim_cluster = cluster_index; - } - else if (header->sim_cluster_bis == 0xFFFFFFFF) - { - header->sim_cluster_bis = cluster_index; - } - else - { - error = 1; - } } ///////////////////////////////// @@ -1435,23 +1640,23 @@ { periph[periph_index]->type = PERIPH_TYPE_TTY; - if (header->tty_cluster == 0xFFFFFFFF) + if ( tty_channels < periph[periph_index]->channels ) { - header->tty_cluster = cluster_index; tty_channels = periph[periph_index]->channels; } - else if (header->tty_cluster_bis == 0xFFFFFFFF) + } + ///////////////////////////////// + else if (strcmp(str, "PIC") == 0) + { + periph[periph_index]->type = PERIPH_TYPE_PIC; + if ( pic_channels < periph[periph_index]->channels ) { - header->tty_cluster_bis = cluster_index; - assert( (tty_channels == periph[periph_index]->channels) && - "[XML ERROR] unconsistent non replicated peripheral"); + pic_channels = periph[periph_index]->channels; } - else - { - error = 1; - } - } + use_pic = 1; + } + // The DMA, ICU, MMC, TIM, XCU peripherals can be replicated in all clusters - // but it must exist only one component of each type per cluster + // but no more than one component of each type per cluster ///////////////////////////////// @@ -1471,14 +1676,13 @@ found_icu = 1; - if (icu_channels > 0) + if ( periph[periph_index]->channels < + (header->irq_per_proc * cluster[cluster_index]->procs) ) { - assert( (periph[periph_index]->channels == icu_channels) && - "[XML ERROR] the number of interruptions per processor " - "from the ICU (icu channels) must be the same on all " - "clusters"); - } - else - { - icu_channels = periph[periph_index]->channels; + printf("[XML ERROR] ICU channels smaller than PROCS * IRQ_PER_PROC\n"); + printf(" - icu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n", + periph[periph_index]->channels, + cluster[cluster_index]->procs, + header->irq_per_proc ); + exit(1); } } @@ -1498,7 +1702,5 @@ found_timer = 1; if (tim_channels < periph[periph_index]->channels) - { tim_channels = periph[periph_index]->channels; - } } ////////////////////////////////// @@ -1512,41 +1714,87 @@ use_xcu = 1; - if (icu_channels > 0) + if ( periph[periph_index]->channels < + (header->irq_per_proc * cluster[cluster_index]->procs) ) { - assert( (periph[periph_index]->channels == icu_channels) && - "[XML ERROR] the number of interruptions per processor " - "from the ICU (icu channels) must be the same on all " - "clusters"); + printf("[XML ERROR] XCU channels smaller than PROCS * IRQ_PER_PROC\n"); + printf(" - xcu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n", + periph[periph_index]->channels, + cluster[cluster_index]->procs, + header->irq_per_proc ); + exit(1); + } + } + else + { + printf("[XML ERROR] illegal peripheral type: %s in cluster %d\n", + str, cluster_index); + exit(1); + } + + if (error) + { + printf("[XML ERROR] illegal peripheral %s in cluster %d\n", + str, cluster_index); + exit(1); + } + } + else + { + printf("[XML ERROR] illegal or missing for peripheral %d in cluster %d\n", + periph_loc_index, cluster_index); + exit(1); + } + + ////////////// set irq_offset attribute + periph[periph_index]->irq_offset = irq_index; + +#if XML_PARSER_DEBUG +printf(" irq_offset = %d\n", irq_index ); +#endif + + ///////////// get IRQs + int status = xmlTextReaderRead(reader); + while (status == 1) + { + const char * tag = (const char *) xmlTextReaderConstName(reader); + + if (strcmp(tag, "irq") == 0) + { + if ( (periph[periph_index]->type != PERIPH_TYPE_ICU) && + (periph[periph_index]->type != PERIPH_TYPE_XCU) && + (periph[periph_index]->type != PERIPH_TYPE_PIC) ) + { + printf("[XML ERROR] periph %d in cluster(%d,%d) " + " only ICU, XCU and PIC can contain IRQs", + periph_loc_index, cluster[cluster_index]->x, cluster[cluster_index]->y); + exit(1); } else { - icu_channels = periph[periph_index]->channels; + irqNode(reader); } } + else if (strcmp(tag, "#text") == 0) { } + else if (strcmp(tag, "#comment") == 0) { } + else if (strcmp(tag, "periph") == 0) + { + periph[periph_index]->irqs = irq_loc_index; + cluster[cluster_index]->periphs++; + periph_loc_index++; + periph_index++; + +#if XML_PARSER_DEBUG +printf(" irqs = %d\n", irq_loc_index); +printf(" irq_offset = %d\n", irq_index); +#endif + return; + } else { - printf("[XML ERROR] illegal : %s for peripheral %d in cluster %d\n", - str, periph_loc_index, cluster_index); + printf("[XML ERROR] Unknown tag %s", tag); exit(1); } - - if (error) - { - printf("[XML ERROR] illegal : %s for peripheral %d in cluster %d\n", - str, periph_loc_index, cluster_index); - exit(1); - } - } - else - { - printf("[XML ERROR] missing for peripheral %d in cluster %d\n", - periph_loc_index, cluster_index); - exit(1); - } - - periph_index++; - periph_loc_index++; - cluster[cluster_index]->periphs++; - + status = xmlTextReaderRead(reader); + } } // end periphNode @@ -1568,5 +1816,5 @@ #if XML_PARSER_DEBUG - printf("\n coproc %d\n", coproc_index); +printf("\n coproc %d\n", coproc_index); #endif @@ -1578,5 +1826,5 @@ { #if XML_PARSER_DEBUG - printf(" name = %s\n", str); +printf(" name = %s\n", str); #endif strncpy(coproc[coproc_index]->name, str, 31); @@ -1603,10 +1851,11 @@ { #if XML_PARSER_DEBUG - printf(" clusterid = %d\n", cluster_index); - printf(" psegname = %s\n", str); - printf(" psegid = %d\n", index); +printf(" clusterid = %d\n", cluster_index); +printf(" psegname = %s\n", str); +printf(" psegid = %d\n", index); #endif coproc[coproc_index]->psegid = index; - assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" ); + assert(pseg[index]->type == PSEG_TYPE_PERI && + "coproc psegname attribute must refer to a pseg of type PERI" ); } else @@ -1621,5 +1870,5 @@ #if XML_PARSER_DEBUG - printf(" port_offset = %d\n", cp_port_index); +printf(" port_offset = %d\n", cp_port_index); #endif @@ -1653,130 +1902,12 @@ -///////////////////////////////////// -void irqNode(xmlTextReaderPtr reader) +////////////////////////////////////// +void procNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; - char * str; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; - if (irq_index >= MAX_IRQS) { - printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS); - } - -#if XML_PARSER_DEBUG - printf(" irq %d\n", irq_loc_index); -#endif - - irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t)); - - ///////// get type attribute - str = getStringValue(reader, "type", &ok); - if (ok) - { -#if XML_PARSER_DEBUG - printf(" type = %s\n", str); -#endif - if ( strcmp(str, "HARD") == 0 ) irq[irq_index]->type = IRQ_TYPE_HWI; - else if ( strcmp(str, "SOFT") == 0 ) irq[irq_index]->type = IRQ_TYPE_SWI; - else if ( strcmp(str, "TIME") == 0 ) irq[irq_index]->type = IRQ_TYPE_PTI; - else - { - printf("[XML ERROR] illegal IRQ for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } - } - else - { - printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } - - ///////// get icuid attribute - value = getIntValue(reader, "icuid", &ok); - if (ok) - { -#if XML_PARSER_DEBUG - printf(" icuid = %d\n", value); -#endif - irq[irq_index]->icuid = value; - if (value >= 32) - { - printf("[XML ERROR] IRQ too large for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } - } - else - { - printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } - - ///////// get isr attribute - str = getStringValue(reader, "isr", &ok); - if (ok) - { -#if XML_PARSER_DEBUG - printf(" isr = %s\n", str); -#endif - if (strcmp(str, "ISR_SWITCH" ) == 0) irq[irq_index]->isr = ISR_SWITCH; - else if (strcmp(str, "ISR_IOC" ) == 0) irq[irq_index]->isr = ISR_IOC; - else if (strcmp(str, "ISR_DMA" ) == 0) irq[irq_index]->isr = ISR_DMA; - else if (strcmp(str, "ISR_TTY" ) == 0) irq[irq_index]->isr = ISR_TTY; - else if (strcmp(str, "ISR_TIMER" ) == 0) irq[irq_index]->isr = ISR_TIMER; - else if (strcmp(str, "ISR_WAKUP" ) == 0) irq[irq_index]->isr = ISR_WAKUP; - else if (strcmp(str, "ISR_DEFAULT") == 0) irq[irq_index]->isr = ISR_DEFAULT; - else - { - printf("[XML ERROR] illegal IRQ for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } -#if XML_PARSER_DEBUG - printf(" isrnum = %d\n", irq[irq_index]->isr); -#endif - } - else - { - printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", - cluster_index, proc_loc_index); - exit(1); - } - - ///////// get channel attribute (optionnal : 0 if missing) - value = getIntValue(reader, "channel", &ok); - if (ok) - { -#if XML_PARSER_DEBUG - printf(" channel = %d\n", value); -#endif - irq[irq_index]->channel = value; - } - else - { - irq[irq_index]->channel = 0; - } - - irq_index++; - irq_loc_index++; - -} // end irqNode - - -////////////////////////////////////// -void procNode(xmlTextReaderPtr reader) -{ - unsigned int ok; - unsigned int value; - - irq_loc_index = 0; - - if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; - if (proc_index >= MAX_PROCS) { @@ -1786,5 +1917,5 @@ #if XML_PARSER_DEBUG - printf("\n proc %d\n", proc_index); +printf("\n proc %d\n", proc_index); #endif @@ -1799,38 +1930,9 @@ exit(1); } - - ////////// set irq_offset attribute - proc[proc_index]->irq_offset = irq_index; - -#if XML_PARSER_DEBUG - printf(" irq_offset = %d\n", irq_index); -#endif - - int status = xmlTextReaderRead(reader); - while (status == 1) - { - const char * tag = (const char *) xmlTextReaderConstName(reader); - - if (strcmp(tag, "irq") == 0) - { - irqNode(reader); - } - else if (strcmp(tag, "#text") == 0) { } - else if (strcmp(tag, "#comment") == 0) { } - else if (strcmp(tag, "proc") == 0) - { - proc[proc_index]->irqs = irq_loc_index; - cluster[cluster_index]->procs++; - proc_loc_index++; - proc_index++; - return; - } - else - { - printf("[XML ERROR] Unknown tag %s", tag); - exit(1); - } - status = xmlTextReaderRead(reader); - } + proc[proc_index]->index = proc_loc_index; + + cluster[cluster_index]->procs++; + proc_loc_index++; + proc_index++; } // end procNode() @@ -1852,5 +1954,5 @@ #if XML_PARSER_DEBUG - printf(" pseg %d\n", pseg_index); +printf(" pseg %d\n", pseg_index); #endif @@ -1860,5 +1962,5 @@ str = getStringValue(reader, "name", &ok); #if XML_PARSER_DEBUG - printf(" name = %s\n", str); +printf(" name = %s\n", str); #endif if (ok) @@ -1876,5 +1978,5 @@ str = getStringValue(reader, "type", &ok); #if XML_PARSER_DEBUG - printf(" type = %s\n", str); +printf(" type = %s\n", str); #endif if (ok && (strcmp(str, "RAM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_RAM; } @@ -1891,5 +1993,5 @@ ll_value = getPaddrValue(reader, "base", &ok); #if XML_PARSER_DEBUG - printf(" base = 0x%llx\n", ll_value); +printf(" base = 0x%llx\n", ll_value); #endif if (ok) @@ -1906,5 +2008,5 @@ ll_value = getPaddrValue(reader, "length", &ok); #if XML_PARSER_DEBUG - printf(" length = 0x%llx\n", ll_value); +printf(" length = 0x%llx\n", ll_value); #endif if (ok) @@ -1956,7 +2058,5 @@ found_mmc = 0; - if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { - return; - } + if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG @@ -2024,7 +2124,7 @@ else if (strcmp(tag, "cluster") == 0) { - - ///////// TIMER and ICU peripheral are mandatory ////////////// - if (!found_timer && !found_xcu) + ///////// TIMER and ICU peripheral are mandatory when nprocs != 0 + unsigned int procs = cluster[cluster_index]->procs; + if ( procs && !found_timer && !found_xcu) { printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index); @@ -2032,5 +2132,5 @@ } - if (!found_icu && !found_xcu) + if ( procs && !found_icu && !found_xcu) { printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index); @@ -2038,8 +2138,5 @@ } - if (nb_proc_max < cluster[cluster_index]->procs) - { - nb_proc_max = cluster[cluster_index]->procs; - } + if (nb_procs_max < procs) nb_procs_max = procs; #if XML_PARSER_DEBUG @@ -2077,5 +2174,5 @@ else if (strcmp(tag, "clusterset") == 0) { - // checking source file consistency + // checking number of clusters if ( cluster_index != (header->x_size * header->y_size) ) { @@ -2084,16 +2181,15 @@ } - // At least one TTY terminal for system boot - if (header->tty_cluster == 0xFFFFFFFF) + // checking TTY terminal for system boot + if ( tty_channels == 0 ) { - printf("[XML ERROR] illegal or missing tty peripheral"); + printf("[XML ERROR] missing TTY peripheral\n"); exit(1); } - // the number of ICU channels must be NB_PROCS * irq_per_proc - if (icu_channels != (header->irq_per_proc * proc_loc_index)) + // checking IOC sub-types + if ( (use_bdv + use_hba + use_spi) > 1 ) { - printf("[XML ERROR] illegal ICU number of channels. " - "It must be equal to NB_PROCS * IRQ_PER_PROC\n"); + printf("[XML ERROR] all IOC peripherals must have the same type\n"); exit(1); } @@ -2134,5 +2230,9 @@ const char * tag = (const char *) xmlTextReaderConstName(reader); - if (strcmp(tag, "vseg") == 0) { vsegNode(reader); } + if (strcmp(tag, "vseg") == 0) + { + vsegNode( reader ); + header->globals = header->globals + 1; + } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } @@ -2142,5 +2242,4 @@ printf(" end global set\n\n"); #endif - header->globals = vseg_index; vseg_loc_index = 0; return; @@ -2178,17 +2277,8 @@ else if (strcmp(tag, "vspaceset") == 0 ) { - // checking source file consistency - if (vspace_index != header->vspaces) - { - printf("[XML ERROR] Wrong number of vspaces\n"); - exit(1); - } - else - { - header->vsegs = vseg_index; - header->vobjs = vobj_index; - header->tasks = task_index; - return; - } + header->vsegs = vseg_index; + header->vobjs = vobj_index; + header->tasks = task_index; + return; } else @@ -2282,5 +2372,35 @@ } - //check the number of cluster + /////////// get x_io attribute + unsigned int x_io = getIntValue(reader, "x_io", &ok); +#if XML_PARSER_DEBUG + printf(" x_io = %d\n", x_io); +#endif + if ( ok && (x_io < x_size) ) + { + header->x_io = x_io; + } + else + { + printf("[XML ERROR] illegal or missing attribute in header\n"); + exit(1); + } + + /////////// get y_io attribute + unsigned int y_io = getIntValue(reader, "y_io", &ok); +#if XML_PARSER_DEBUG + printf(" y_io = %d\n", y_size); +#endif + if ( ok &&(y_io < y_size) ) + { + header->y_io = y_io; + } + else + { + printf("[XML ERROR] illegal or missing attribute in header\n"); + exit(1); + } + + // check the number of cluster if ( (x_size * y_size) >= MAX_CLUSTERS ) { @@ -2289,48 +2409,5 @@ } - ///////// get vspaces attribute - value = getIntValue(reader, "vspaces", &ok); - if (ok) - { - if (value >= MAX_VSPACES) - { - printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES); - exit(1); - } -#if XML_PARSER_DEBUG - printf(" vspaces = %d\n", value); -#endif - header->vspaces = value; - } - else - { - printf("[XML ERROR] illegal or missing attribute in mapping\n"); - exit(1); - } - - ///////// get increment attribute - value = getIntValue(reader, "increment", &ok); - if (ok) - { - if ( (value != 0x10000) && (value != 0x8000) && - (value != 0x4000) && (value != 0x2000) ) - - { - printf("[XML ERROR] The vseg increment must be one of the following: "); - printf(" 0x00010000 / 0x00008000 / 0x00004000 / 0x00002000"); - exit(1); - } -#if XML_PARSER_DEBUG - printf(" increment = %d\n", value); -#endif - header->increment = value; - } - else - { - printf("[XML ERROR] illegal or missing attribute in mapping\n"); - exit(1); - } - - ///////// get increment attribute + ///////// get irq_per_proc attribute value = getIntValue(reader, "irq_per_proc", &ok); if (ok) @@ -2347,31 +2424,33 @@ } - //////// initialise non replicated peripherals cluster index - header->cma_cluster = 0xFFFFFFFF; - header->cma_cluster_bis = 0xFFFFFFFF; - - header->fbf_cluster = 0xFFFFFFFF; - header->fbf_cluster_bis = 0xFFFFFFFF; - - header->iob_cluster = 0xFFFFFFFF; - header->iob_cluster_bis = 0xFFFFFFFF; - - header->ioc_cluster = 0xFFFFFFFF; - header->ioc_cluster_bis = 0xFFFFFFFF; - - header->nic_cluster = 0xFFFFFFFF; - header->nic_cluster_bis = 0xFFFFFFFF; - - header->rom_cluster = 0xFFFFFFFF; - header->rom_cluster_bis = 0xFFFFFFFF; - - header->sim_cluster = 0xFFFFFFFF; - header->sim_cluster_bis = 0xFFFFFFFF; - - header->tty_cluster = 0xFFFFFFFF; - header->tty_cluster_bis = 0xFFFFFFFF; - - ///////// set signature + ///////// get use_ramdisk attribute (default = 0) + value = getIntValue(reader, "use_ramdisk", &ok); + if (ok) + { +#if XML_PARSER_DEBUG + printf(" use_ramdisk = %d\n", value); +#endif + header->use_ramdisk = value; + } + else + { + header->use_ramdisk = 0; + } + + ///////// set other header fields + header->increment = 0x10000; header->signature = IN_MAPPING_SIGNATURE; + header->globals = 0; + header->vspaces = 0; + header->psegs = 0; + header->vsegs = 0; + header->vobjs = 0; + header->tasks = 0; + header->procs = 0; + header->irqs = 0; + header->coprocs = 0; + header->cp_ports = 0; + header->periphs = 0; + int status = xmlTextReaderRead(reader); @@ -2380,8 +2459,5 @@ const char * tag = (const char *) xmlTextReaderConstName(reader); - if (strcmp(tag, "clusterset") == 0) - { - clusterSetNode(reader); - } + if (strcmp(tag, "clusterset") == 0) { clusterSetNode(reader); } else if (strcmp(tag, "globalset") == 0) { globalSetNode(reader); } else if (strcmp(tag, "vspaceset") == 0) { vspaceSetNode(reader); } @@ -2591,8 +2667,10 @@ def_int_write(fdout, "X_WIDTH ", header->x_width); def_int_write(fdout, "Y_WIDTH ", header->y_width); + def_int_write(fdout, "X_IO ", header->x_io); + def_int_write(fdout, "Y_IO ", header->y_io); file_write(fdout, "\n"); - def_int_write(fdout, "NB_PROCS_MAX ", nb_proc_max); + def_int_write(fdout, "NB_PROCS_MAX ", nb_procs_max); def_int_write(fdout, "NB_TASKS_MAX ", nb_tasks_max); @@ -2605,5 +2683,5 @@ def_int_write(fdout, "NB_TTY_CHANNELS ", tty_channels); - def_int_write(fdout, "NB_HBA_CHANNELS ", hba_channels); + def_int_write(fdout, "NB_IOC_CHANNELS ", ioc_channels); def_int_write(fdout, "NB_NIC_CHANNELS ", nic_channels); def_int_write(fdout, "NB_CMA_CHANNELS ", cma_channels); @@ -2613,7 +2691,12 @@ def_int_write(fdout, "USE_XICU ", use_xcu); def_int_write(fdout, "USE_IOB ", use_iob); - def_int_write(fdout, "USE_HBA ", use_hba); - def_int_write(fdout, "USE_BDV ", use_bdv); - def_int_write(fdout, "USE_SPI ", use_spi); + def_int_write(fdout, "USE_PIC ", use_pic); + + file_write(fdout, "\n"); + + def_int_write(fdout, "USE_IOC_RDK ", header->use_ramdisk); + def_int_write(fdout, "USE_IOC_HBA ", use_hba); + def_int_write(fdout, "USE_IOC_BDV ", use_bdv); + def_int_write(fdout, "USE_IOC_SPI ", use_spi); file_write(fdout, "\n"); @@ -2638,5 +2721,5 @@ { int fdout = open_file(file_path); - unsigned int count = 0; + unsigned int count; unsigned int vseg_id; unsigned int base; // vseg base @@ -2648,6 +2731,6 @@ file_write(fdout, prol); - // boot and kernel segments - for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++) + // boot mandatory global vsegs + for (vseg_id = 0 , count = 0 ; vseg_id < header->vsegs ; vseg_id++) { if ( strcmp(vseg[vseg_id]->name, "seg_boot_code") == 0 ) @@ -2691,40 +2774,9 @@ count++; } - else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 ) - { - base = vseg[vseg_id]->vbase; - size = vobj[vseg[vseg_id]->vobj_offset]->length; - ld_write(fdout, "seg_kernel_code_base ", base); - ld_write(fdout, "seg_kernel_code_size ", size); - count++; - } - else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 ) - { - base = vseg[vseg_id]->vbase; - size = vobj[vseg[vseg_id]->vobj_offset]->length; - ld_write(fdout, "seg_kernel_data_base ", base); - ld_write(fdout, "seg_kernel_data_size ", size); - count++; - } - else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 ) - { - base = vseg[vseg_id]->vbase; - size = vobj[vseg[vseg_id]->vobj_offset]->length; - ld_write(fdout, "seg_kernel_uncdata_base ", base); - ld_write(fdout, "seg_kernel_uncdata_size ", size); - count++; - } - else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 ) - { - base = vseg[vseg_id]->vbase; - size = vobj[vseg[vseg_id]->vobj_offset]->length; - ld_write(fdout, "seg_kernel_init_base ", base); - ld_write(fdout, "seg_kernel_init_size ", size); - count++; - } - } - if ( count != 9 ) + } + + if ( count != 5 ) { - printf ("[XML ERROR] Missing Boot or Kernel vseg : only %d\n", count); + printf ("[XML ERROR] Missing mandatory Boot global vseg : only %d\n", count); printf ("Mandatory segments are :\n"); printf (" - seg_boot_code\n"); @@ -2733,10 +2785,82 @@ printf (" - seg_boot_mapping\n"); printf (" - seg_boot_buffer\n"); + exit(0); + } + + file_write(fdout, "\n"); + + // kernel mandatory global vsegs + for (vseg_id = 0, count = 0 ; vseg_id < header->vsegs ; vseg_id++) + { + if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 ) + { + base = vseg[vseg_id]->vbase; + size = vobj[vseg[vseg_id]->vobj_offset]->length; + ld_write(fdout, "seg_kernel_code_base ", base); + ld_write(fdout, "seg_kernel_code_size ", size); + count++; + } + else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 ) + { + base = vseg[vseg_id]->vbase; + size = vobj[vseg[vseg_id]->vobj_offset]->length; + ld_write(fdout, "seg_kernel_data_base ", base); + ld_write(fdout, "seg_kernel_data_size ", size); + count++; + } + else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 ) + { + base = vseg[vseg_id]->vbase; + size = vobj[vseg[vseg_id]->vobj_offset]->length; + ld_write(fdout, "seg_kernel_uncdata_base ", base); + ld_write(fdout, "seg_kernel_uncdata_size ", size); + count++; + } + else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 ) + { + base = vseg[vseg_id]->vbase; + size = vobj[vseg[vseg_id]->vobj_offset]->length; + ld_write(fdout, "seg_kernel_init_base ", base); + ld_write(fdout, "seg_kernel_init_size ", size); + count++; + } + } + if ( count != 4 ) + { + printf ("[XML ERROR] Missing mandatory Kernel global vseg : only %d\n", count); + printf ("Mandatory segments are :\n"); printf (" - seg_kernel_code\n"); printf (" - seg_kernel_data\n"); printf (" - seg_kernel_uncdata\n"); printf (" - seg_kernel_init\n"); - } - + exit(0); + } + + file_write(fdout, "\n"); + + // boot and kernel optionnal global vsegs (pseudo ROMs) + unsigned int seg_ram_disk_base = 0xFFFFFFFF; + unsigned int seg_ram_disk_size = 0; + unsigned int seg_reset_code_base = 0xFFFFFFFF; + unsigned int seg_reset_code_size = 0; + for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++) + { + if ( strcmp(vseg[vseg_id]->name, "seg_reset_code") == 0 ) + { + seg_reset_code_base = vseg[vseg_id]->vbase; + seg_reset_code_size = vobj[vseg[vseg_id]->vobj_offset]->length; + } + if ( strcmp(vseg[vseg_id]->name, "seg_ram_disk") == 0 ) + { + seg_ram_disk_base = vseg[vseg_id]->vbase; + seg_ram_disk_size = vobj[vseg[vseg_id]->vobj_offset]->length; + } + } + + ld_write(fdout, "seg_reset_code_base ", seg_reset_code_base); + ld_write(fdout, "seg_reset_code_size ", seg_reset_code_size); + ld_write(fdout, "seg_ram_disk_base ", seg_ram_disk_base); + ld_write(fdout, "seg_ram_disk_size ", seg_ram_disk_size); + file_write(fdout, "\n"); @@ -2744,5 +2868,5 @@ set_periph_vbase_array(); - // non replicated peripherals + // non replicated peripherals ld_write(fdout, "seg_cma_base ", periph_vbase_array[PERIPH_TYPE_CMA]); ld_write(fdout, "seg_fbf_base ", periph_vbase_array[PERIPH_TYPE_FBF]); @@ -2753,4 +2877,5 @@ ld_write(fdout, "seg_sim_base ", periph_vbase_array[PERIPH_TYPE_SIM]); ld_write(fdout, "seg_tty_base ", periph_vbase_array[PERIPH_TYPE_TTY]); + ld_write(fdout, "seg_pic_base ", periph_vbase_array[PERIPH_TYPE_PIC]); file_write(fdout, "\n"); Index: /soft/giet_vm/hello/main.c =================================================================== --- /soft/giet_vm/hello/main.c (revision 294) +++ /soft/giet_vm/hello/main.c (revision 295) @@ -1,3 +1,4 @@ #include "stdio.h" +#include "hard_config.h" __attribute__((constructor)) void main() @@ -6,10 +7,16 @@ unsigned int proc = giet_procid(); - giet_tty_printf("Starting task HELLO on processor %d at cycle %d\n", - giet_procid(), giet_proctime() ); - + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< - - -*** The "increment" parameter is the virtual address cluster increment -*** The physical address cluster increment is 0x10000000000 / NB_CLUSTERS - -*** This first section describes an instance of the "tsar_generic_iob" architecture -*** with 4 clusters, 1 processor per cluster and 40 bits physical address. + irq_per_proc = "4" + use_ramdisk = "1" + x_io = "0" + y_io = "0" > + +*** This mapping is for the "tsar_generic_leti" hardware architecture +*** with 4 clusters containing processors and 4 processors per cluster +*** 40 bits physical address, and 64 Mbytes per cluster. +*** There is 4 IRQ inputs per processor +*** It does not use the external peripherals. +*** It uses the RAMDISK in cluster(0,0) +*** It uses the mono-channel TTY implemented in cluster(0,0). - - + - -*** Non replicated peripherals (including the ROM containing the preloader code) - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + +*** empty clusters + + + + + + -*** Segments used by the boot code / A[31:28] = 0x0 / Identity mapping -- seg_boot_mapping is loaded by the boot-loader. It contains the mapping info. The content is reused by the kernel. -- seg_boot_code and seg_boot data are loaded by the preloader, used by the boot-loader The content is not reused by the kernel. -- seg_boot_stack is contains the stacks used by all processors during reset and boot. The content is not reused by the Kernel. -- seg_boot_buffer is used by the boot-loader. It can contain a complete .elf file. The content is not reused by the kernel. +*** Global vsegs associated to peripherals replicated in all clusters (XCU, MMC, SCHED) +*** must respect the following policy (checked by the XML parser) : +*** vbase[x,y] = vbase[0,0] + 64K * cluster_xy +*** pbase[x,y] = pbase[0,0] + 4G * cluster_xy +*** ( with cluster_xy = x*16 + y ) +*** the vseg type is entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) +*** The cluster index must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) + +*** 5 global vsegs used by the boot code / A[31:28] = 0x0 / Identity mapping +*** seg_boot_mapping is loaded by the boot-loader. It contains the mapping info. Reused by the kernel. +*** seg_boot_code and seg_boot data are loaded by the preloader, used by the boot-loader. Not reused by the kernel. +*** seg_boot_stack contains the stacks used by all processors during reset and boot. Not reused by the Kernel. +*** seg_boot_buffer is used by the boot-loader. It contains a complete .elf file. Not reused by the kernel. @@ -153,14 +179,14 @@ - - - - + + + + - -*** Segments used by the kernel / A[31:28] = 0x8 + +*** 4 global vsegs used by the kernel / A[31:28] = 0x8 / No identity mapping constraint @@ -177,17 +203,25 @@ -*** Segments for non replicated peripherals / A[31:28] = 0xF / Identity mapping - - +*** 2 global vsegs for non replicated peripherals in cluster(0,0) / A[31:28] = 0xF / + + - + + - + +*** 2 global vsegs for pseudo-peripherals (PRELOADER and RAMDISK) / A[31:28] = 0x0 + + -*** Segments for replicated ICUS / A[31:24] = 0xF0 / Increment = 0x10000 / Identity mapping in cluster 0 + + + + +*** 4 global vsegs for replicated ICUS / A[31:24] = 0xF0 / Increment = 0x10000 / Identity mapping in cluster (0,0) @@ -204,7 +238,5 @@ -*** segments for replicated MMC / A[31:24] = 0xE0 / Increment = 0x10000 / Identity mapping in cluster 0 -*** The peripheral type must be entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) -*** The cluster id must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) +*** 4 global vsegs for replicated MMC / A[31:24] = 0xE0 / Increment = 0x10000 / Identity mapping in cluster 0 @@ -221,7 +253,5 @@ -*** segments for replicated schedulers / A[31:28] = 0xC / Increment = 0x10000 -*** The type must be entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) -*** The cluster id must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) +*** 4 global vsegs for replicated schedulers / A[31:28] = 0xC / Increment = 0x10000 @@ -237,5 +267,5 @@ -*** + @@ -249,61 +279,67 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** This vobj emulates a command line argument for the sort application + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + Index: /soft/giet_vm/mappings/4c_4p_sort_leti_ext.xml =================================================================== --- /soft/giet_vm/mappings/4c_4p_sort_leti_ext.xml (revision 295) +++ /soft/giet_vm/mappings/4c_4p_sort_leti_ext.xml (revision 295) @@ -0,0 +1,397 @@ + + + + +*** This mapping is for the "tsar_generic_leti" hardware architecture +*** with 4 clusters containing processors and 4 processors per cluster +*** 40 bits physical address, and 64 Mbytes per cluster. +*** It uses the external peripherals, which means 2*3 clusters, because +*** External peripherals are implemented in cluster(1,2), and the associated WTI +*** are routed by the PIC component to the XCU in cluster (0,0). +*** Cluster (0,0) contains two backup peripherals (TTY and Block Device), +*** and the corresponding HWI are connected to the XICU in cluster (0,0) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** empty cluster + + + + +*** cluster_io + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** Global vsegs associated to peripherals replicated in all clusters (XCU, MMC, SCHED) +*** must respect the following policy (checked by the XML parser) : +*** For segments replicated in all clusters +*** vbase[x,y] = vbase[0,0] + 64K * cluster_xy +*** pbase[x,y] = pbase[0,0] + 4G * cluster_xy +*** ( with cluster_xy = x*16 + y ) +*** the vseg type is entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) +*** The cluster index must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) + +*** 5 global vsegs used by the boot code / A[31:28] = 0x0 / Identity mapping +*** seg_boot_mapping is loaded by the boot-loader. It contains the mapping info. Reused by the kernel. +*** seg_boot_code and seg_boot data are loaded by the preloader, used by the boot-loader. Not reused by the kernel. +*** seg_boot_stack contains the stacks used by all processors during reset and boot. Not reused by the Kernel. +*** seg_boot_buffer is used by the boot-loader. It contains a complete .elf file. Not reused by the kernel. + + + + + + + + + + + + + + + + + +*** 4 global vsegs used by the kernel / A[31:28] = 0x8 / No identity mapping constraint + + + + + + + + + + + + + + +*** 6 global vsegs for non replicated peripherals in cluster(1,2) / A[31:28] = 0xF / + + + + + + + + + + + + + + + + + + + + +*** 1 global vseg for pseudo-peripherals (PRELOADER) / A[31:28] = 0x0 + + + + + +*** 4 global vsegs for replicated ICUS / A[31:24] = 0xF0 / Increment = 0x10000 / Identity mapping in cluster (0,0) + + + + + + + + + + + + + + +*** 4 global vsegs for replicated MMC / A[31:24] = 0xE0 / Increment = 0x10000 / Identity mapping in cluster 0 + + + + + + + + + + + + + + +*** 4 global vsegs for replicated schedulers / A[31:28] = 0xC / Increment = 0x10000 + + + + + + + + + + + + + + + + + + +*** For each vspace, the startname field is the name of the vobj containing the start_vector (entry point array) +*** For each task, the startid field define the task entry point as an index in the start_vector +*** For each task, the clusterid and proclocid arguments define the task static placement +*** For each task, the stackname field is the name of the vobj containing the task stack +*** For each task, the heapname field is the name of the vobj containing the task heap + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** This vobj emulates a command line argument for the sort application + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /soft/giet_vm/mappings/4c_4p_transpose_leti.xml =================================================================== --- /soft/giet_vm/mappings/4c_4p_transpose_leti.xml (revision 295) +++ /soft/giet_vm/mappings/4c_4p_transpose_leti.xml (revision 295) @@ -0,0 +1,339 @@ + + + + +*** This mapping is for the "tsar_generic_leti" hardware architecture +*** with 4 clusters containing processors and 4 processors per cluster +*** 40 bits physical address, and 64 Mbytes per cluster. +*** There is 4 IRQ inputs per processor +*** It does not use the external peripherals. +*** It uses the RAMDISK in cluster(0,0) +*** It uses the mono-channel TTY implemented in cluster(0,0). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +***empty clusters + + + + + + + + + + +*** Global vsegs associated to peripherals replicated in all clusters (XCU, MMC, SCHED) +*** must respect the following policy (checked by the XML parser) : +*** vbase[x,y] = vbase[0,0] + 64K * cluster_xy +*** pbase[x,y] = pbase[0,0] + 4G * cluster_xy +*** ( with cluster_xy = x*16 + y ) +*** the vseg type is entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) +*** The cluster index must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) + +*** 5 global vsegs used by the boot code / A[31:28] = 0x0 / Identity mapping +*** seg_boot_mapping is loaded by the boot-loader. It contains the mapping info. Reused by the kernel. +*** seg_boot_code and seg_boot data are loaded by the preloader, used by the boot-loader. Not reused by the kernel. +*** seg_boot_stack contains the stacks used by all processors during reset and boot. Not reused by the Kernel. +*** seg_boot_buffer is used by the boot-loader. It contains a complete .elf file. Not reused by the kernel. + + + + + + + + + + + + + + + + + +*** 4 global vsegs used by the kernel / A[31:28] = 0x8 / No identity mapping constraint + + + + + + + + + + + + + + +*** 2 global vsegs for non replicated peripherals in cluster(0,0) / A[31:28] = 0xF / + + + + + + + + + +*** 2 global vsegs for pseudo-peripherals (PRELOADER and RAMDISK) / A[31:28] = 0x0 + + + + + + + + + +*** 4 global vsegs for replicated ICUS / A[31:24] = 0xF0 / Increment = 0x10000 / Identity mapping in cluster (0,0) + + + + + + + + + + + + + + +*** 4 global vsegs for replicated MMC / A[31:24] = 0xE0 / Increment = 0x10000 / Identity mapping in cluster 0 + + + + + + + + + + + + + + +*** 4 global vsegs for replicated schedulers / A[31:28] = 0xC / Increment = 0x10000 + + + + + + + + + + + + + + + + + + +*** For each vspace, the startname field is the name of the vobj containing the start_vector (entry point array) +*** For each task, the startid field define the task entry point as an index in the start_vector +*** For each task, the clusterid and proclocid arguments define the task static placement +*** For each task, the stackname field is the name of the vobj containing the task stack +*** For each task, the heapname field is the name of the vobj containing the task heap + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /soft/giet_vm/mappings/4c_4p_transpose_leti_ext.xml =================================================================== --- /soft/giet_vm/mappings/4c_4p_transpose_leti_ext.xml (revision 295) +++ /soft/giet_vm/mappings/4c_4p_transpose_leti_ext.xml (revision 295) @@ -0,0 +1,385 @@ + + + + +*** This mapping is for the "tsar_generic_leti" hardware architecture +*** with 4 clusters containing processors and 4 processors per cluster +*** 40 bits physical address, and 64 Mbytes per cluster. +*** It uses the external peripherals, which means 2*3 clusters, because +*** External peripherals are implemented in cluster(1,2), and the associated WTI +*** are routed by the PIC component to the XCU in cluster (0,0). +*** Cluster (0,0) contains two backup peripherals (TTY and Block Device), +*** and the corresponding HWI are connected to the XICU in cluster (0,0) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** empty cluster + + + + +*** cluster_io + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*** Global vsegs associated to peripherals replicated in all clusters (XCU, MMC, SCHED) +*** must respect the following policy (checked by the XML parser) : +*** For segments replicated in all clusters +*** vbase[x,y] = vbase[0,0] + 64K * cluster_xy +*** pbase[x,y] = pbase[0,0] + 4G * cluster_xy +*** ( with cluster_xy = x*16 + y ) +*** the vseg type is entirely defined by the 8 virtual address MSB bits (mask_type = 0xFF000000) +*** The cluster index must be encoded in the next 8 virtual address bits (cluster_mask = 0x00FF0000) + +*** 5 global vsegs used by the boot code / A[31:28] = 0x0 / Identity mapping +*** seg_boot_mapping is loaded by the boot-loader. It contains the mapping info. Reused by the kernel. +*** seg_boot_code and seg_boot data are loaded by the preloader, used by the boot-loader. Not reused by the kernel. +*** seg_boot_stack contains the stacks used by all processors during reset and boot. Not reused by the Kernel. +*** seg_boot_buffer is used by the boot-loader. It contains a complete .elf file. Not reused by the kernel. + + + + + + + + + + + + + + + + + +*** 4 global vsegs used by the kernel / A[31:28] = 0x8 / No identity mapping constraint + + + + + + + + + + + + + + +*** 6 global vsegs for non replicated peripherals in cluster(1,2) / A[31:28] = 0xF / + + + + + + + + + + + + + + + + + + + + +*** 1 global vseg for pseudo-peripherals (PRELOADER) / A[31:28] = 0x0 + + + + + +*** 4 global vsegs for replicated ICUS / A[31:24] = 0xF0 / Increment = 0x10000 / Identity mapping in cluster (0,0) + + + + + + + + + + + + + + +*** 4 global vsegs for replicated MMC / A[31:24] = 0xE0 / Increment = 0x10000 / Identity mapping in cluster 0 + + + + + + + + + + + + + + +*** 4 global vsegs for replicated schedulers / A[31:28] = 0xC / Increment = 0x10000 + + + + + + + + + + + + + + + + + + +*** For each vspace, the startname field is the name of the vobj containing the start_vector (entry point array) +*** For each task, the startid field define the task entry point as an index in the start_vector +*** For each task, the clusterid and proclocid arguments define the task static placement +*** For each task, the stackname field is the name of the vobj containing the task stack +*** For each task, the heapname field is the name of the vobj containing the task heap + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /soft/giet_vm/pgcd/main.c =================================================================== --- /soft/giet_vm/pgcd/main.c (revision 294) +++ /soft/giet_vm/pgcd/main.c (revision 295) @@ -1,3 +1,4 @@ #include "stdio.h" +#include "hard_config.h" ///////////////////////////////////////// @@ -7,6 +8,12 @@ unsigned int opy; - giet_tty_printf("Starting task PGCD on processor %d at cycle %d\n", - giet_procid(), giet_proctime()); + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1<> Y_WIDTH; + unsigned int y = cluster_xy & ((1< channel: %d\n", mwmr); - giet_tty_printf( "*** &mwmr_in = %x\n\n", (unsigned int)mwmr ); - giet_exit(); - } + giet_tty_printf( "*** Starting task producer on processor[%d,%d,%d] at cycle %d\n\n", + x, y, lpid, giet_proctime() ); + + giet_vobj_get_vbase( "router" , + "mwmr_in", + (void*)&mwmr ); // main loop : display token value = source index @@ -35,6 +35,5 @@ } - giet_tty_printf( "\n*** Completing producer task at cycle %d ***\n", giet_proctime()); - giet_exit(); + giet_exit( "Producer task completed"); } // end producer() @@ -47,16 +46,16 @@ mwmr_channel_t* mwmr; - giet_tty_printf( "*** Starting task consumer on processor %d", giet_procid() ); - giet_tty_printf( " at cycle %d ***\n\n", giet_proctime() ); + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< channel\n"); - giet_exit(); - } + giet_tty_printf( "*** Starting task consumer on processor[%d,%d,%d] at cycle %d\n\n", + x, y, lpid, giet_proctime() ); + + giet_vobj_get_vbase( "router" , + "mwmr_out", + (void*)&mwmr ); // main loop : display token arrival index and value @@ -67,6 +66,5 @@ } - giet_tty_printf( "\n*** Completing consumer task at cycle %d ***\n", giet_proctime()); - giet_exit(); + giet_exit( "Consumer task completed"); } // end consumer() @@ -76,33 +74,25 @@ { unsigned int buf; - unsigned int x; + unsigned int n; unsigned int tempo; mwmr_channel_t* mwmr_in ; mwmr_channel_t* mwmr_out ; - - giet_tty_printf( "*** Starting task router on processor %d", giet_procid() ); - giet_tty_printf( " at cycle %d ***\n\n", giet_proctime() ); + unsigned int procid = giet_procid(); + unsigned int cluster_xy = procid/NB_PROCS_MAX; + unsigned int lpid = procid%NB_PROCS_MAX; + unsigned int x = cluster_xy >> Y_WIDTH; + unsigned int y = cluster_xy & ((1< channel\n"); - giet_exit(); - } + giet_tty_printf( "*** Starting task router on processor[%d,%d,%d] at cycle %d\n\n", + x, y, lpid, giet_proctime() ); - if ( giet_vobj_get_vbase( "router" , - "mwmr_in", - VOBJ_TYPE_MWMR, - (void*)&mwmr_in ) ) - { - giet_tty_printf( "\n[ERROR] in router task :\n"); - giet_tty_printf( " undefined channel\n"); - giet_exit(); - } + giet_vobj_get_vbase( "router" , + "mwmr_out", + (void*)&mwmr_out ); + giet_vobj_get_vbase( "router" , + "mwmr_in", + (void*)&mwmr_in ); // main loop while(1) @@ -110,5 +100,5 @@ mwmr_read( mwmr_in , &buf , 1 ); tempo = giet_rand() >> 6; - for ( x = 0 ; x < tempo ; x++ ) asm volatile (""); + for ( n = 0 ; n < tempo ; n++ ) asm volatile (""); giet_tty_printf( "token value : %d / temporisation = %d\n", buf, tempo); mwmr_write( mwmr_out, &buf , 1 ); Index: /soft/giet_vm/sort/main.c =================================================================== --- /soft/giet_vm/sort/main.c (revision 294) +++ /soft/giet_vm/sort/main.c (revision 295) @@ -1,14 +1,6 @@ /////////////////////////////////////////////////////////////////////////////// -// File : -// -// main.c -// -// Date : -// -// November 2013 -// -// Author : -// -// Cesar Fuguet Tortolero +// File : main.c +// Date : November 2013 +// Author : Cesar Fuguet Tortolero // // Description : @@ -38,5 +30,5 @@ #include "barrier.h" -#define ARRAY_LENGTH 2048 +#define ARRAY_LENGTH 512 #define IPT (ARRAY_LENGTH / *nb_thread) // ITEMS PER THREAD @@ -47,17 +39,15 @@ #define VERBOSE 1 -/////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// // Define printf according to verbosity option and number of available // TTY #if (VERBOSE == 1) -# define printf(...) giet_tty_printf(__VA_ARGS__) -# define puts(...) giet_tty_puts(__VA_ARGS__) +# define printf(...) giet_shr_printf(__VA_ARGS__) #else // VERBOSE == 0 # define printf(...) -# define puts(...) #endif -#define task0_printf(...) if(thread_id == 0) giet_tty_printf(__VA_ARGS__) +#define task0_printf(...) if(thread_id == 0) giet_shr_printf(__VA_ARGS__) #define exit giet_exit @@ -89,4 +79,5 @@ giet_barrier_t barrier[8]; +////////////////////////////////////////// __attribute__ ((constructor)) void sort() { @@ -100,15 +91,9 @@ unsigned int time_end; - if( giet_vobj_get_vbase( "sort" , - "nb_thread", - VOBJ_TYPE_CONST, - (unsigned int*)&nb_thread ) ) - { - printf( "\n[ERROR] in sort task :\n"); - printf( " undefined constant: %d\n", nb_thread); - exit(); - } + giet_vobj_get_vbase( "sort" , + "nb_thread", + (unsigned int*)&nb_thread ); - task0_printf("[Thread 0 ] Starting sort application with %d threads " + task0_printf("\n[ Thread 0 ] Starting sort application with %d threads " "at cycle %d\n", *nb_thread, time_start); @@ -141,5 +126,5 @@ // Parallel sort of array elements - printf("[ Thread %d ] Stage 0: Processor Sorting...\n\r", thread_id); + printf("[ Thread %d ] Stage 0: Sorting...\n\r", thread_id); bubbleSort(array0, IPT, IPT * thread_id); @@ -154,9 +139,9 @@ if((thread_id % (2 << i)) != 0) { - printf("[ Thread %d ] Quits\n\r", thread_id); - exit(); - } - - printf("[ Thread %d ] Stage %d: Starting...\n\r", thread_id, i+1); + printf("[ Thread %d ] Quit\n\r", thread_id ); + exit("Completed"); + } + + printf("[ Thread %d ] Stage %d: Sorting...\n\r", thread_id, i+1); if((i % 2) == 0) @@ -203,4 +188,5 @@ time_end = giet_proctime(); + printf("[ Thread 0 ] Finishing sort application at cycle %d\n" "[ Thread 0 ] Time elapsed = %d\n", @@ -209,26 +195,24 @@ if (success) { - - printf("[ Thread 0 ] Success!!\n\r"); + exit("!!! Success !!!"); } else { - printf("[ Thread 0 ] Failure!! Incorrect element: %d\n\r", failure_index); - - + printf("[ Thread 0 ] Failure!! Incorrect element: %d\n\r", + failure_index); for(i=0; i‰šGTru}‹¢²yˆ +eiuœhd_[`}sZffbZ`6PJjhHk—gaYR[g`IURVDMYobQTK8E6E`cltj`€ntjf[WefX]dš•€zÀ·±®jeÎÞààäæÁÙßáåâʷŘlreck]¡ž®›Œœƒ|֪Ɣ™Ÿ”©Â£­¥””rƒžÂâĊ¿ÖŸ§­©¯ÌƧ¯§°¹Œ­¥ÂŒ±™ª ¡ ¡ivt‰ª–WOYegxqŠzŠbYƒ‹€x}}\—„†šµ»Âº¶Ž°ª©¡™¬Žwƒ™À»šuVVSQYGYkYZPjœwefrbˆŠ\&GE3sSBLFd{|a~š‰š¡®zZ{g“š€eqw‚fULlQS€u?DLz]El¢€_RVZ_]XQMXG;EOa_MSJEL@UJDGNDIJ@6>PI94Y\OGW;=L?@^K›snMZ_P]Wd|­Ž„­²„ƒŠxhŒØáßß×ß¹×æäéç×ÔѲ}}t‹Ÿƒ±{ˆ€ÍÛÀ¡®£®¶±›Ÿ‰l›|ÛŽÔœŽÂÉŽ¡’¯€²º¯±¥Ÿ‘Žš—Š¬–§e‘Šptž¢hKddqkn²›–hfuzjfrkwr“–£Ž„¡Ÿ§šŽ„r•€šw­”hBkƒocVag^bYd€Ž–pwvbem][U~PL+;>lraJ{4@bŠ;uxF@2YwW_um——kekI\M[FI7TJGkelWinLr]]Oop{—Š“ƒ~ŠdS:EefXRV~nF71SDKWE\NBXJO>]Vc]q]ey£»Ÿ³‘qboºÌàÔßä׳ÕæàÙÎÅ­‘q}k‘›¡€’|rz’„}‚Àž«²œµ­’’™Ÿ”ž¡‹ÖØÐÈŸŸŽªœž¶€«¹”}Š{w„»‚–|“y‡œ˜kJuzQaqoše™`gwŠ}~PCFtwoiMl‰ƒ š™˜£¬Áµ[wŒw|„?:eP‚|\XTfQUGLirmmŒtƒstLLJsƒIy?.K0=GƒmC‰XD-cy`–t‡€fPYtmVnxG>A>7dsNg{Œ]XRdhf`[v—ˆrfsA=A5UILIXh[Q02>BbMST?EY|kyz]RPQp~c”£—Œ±ªºŒXatºÔÒÔÝâå©ÌÙ·£‡ˆ ’zixwžx‚nsphq„ˆszВȻ­ŸË£‰’‘{º•³ÎÑËÊ©š£¥°”š¥~Ž—yw +R”‰‹†~‰„‘wz§©šuPdƒKZZzœx[nNLvŽŠ‹oZ_e`i]\lqg]®ˆ‹®›’„³§x–]T=?OymEIJKkJKEaaszxev|_To]e„f‘iI]bIU_CHbeYœ²­œhTT†qZzdU;BKNIYiS7/09AZHW5Ay¯q¹®vARtzBpy[IFGGGGVJPwf]XKb‚‡Š†M„keMBIJHZ]LadeJ4GN@KX^aj`|h\UjHbrigxœ ˆ +Œ›ujxr£ÚÆäØÛßž¡Œ{‡¡­|§l„gftz^ZHrȍŽn{—ϏŠ×¬ +}£”|lš +~ºÆÌ؉”a›”‰€µ›†`^u +hNW{ˆ“Œm`x|ŠŽz|©‰}•ÐuvyrSIAZZ€‹ +˜’XƒzXBXQewpn“­ÁœÄ±ªkpŒ]aC3:7AcTB:.p‘¥ž¥¯mAROeMSXkRFMIK>XIJxeb`Lk€—}dt\nU>MRYcgUjKFAAYTPa\JN™a}PRY`‰‚|hYµš²ªq€˜wn’~zgqØÇÔÞÞמ‰ +ŸŒÒܱ›±©ˆy|q_e~°¡Žƒ š|²Ç˜Û˜¬~i‹ŒžŽÀ”¶á±¥ƒ€lˆš«²°Œlkc—lNV{ ‘˜|o|g€ƒ’­‹vm¶ŒvxƒW_VX„lh +ž¢hž„ÇxXPMdvytl˜¬—£€Ã£ ‚|‹UG17AHBECE7>?CNXXKOFh‹T{e‚›ƒž¹uW]PL>.6PP:@X_Xe ³^gnQJUPTTY‚ULaK>:OXU`bZWfƒs–ŽjZ{klEMQPQYoki]^S^TLLFOFpdvjb\nxrZdٙ›ž~•‹ygœ’ugf¹ØÝÂÖÛ°•| Ô×Ñßᱡ˜£}xkhy€„Š¢‹”œ©q’¶ ÎÒ~›«•’š£»ÅÕáÐÇœ£˜®º®»’ŸržJHYwŠo~ +_ssˆ‚~ˆŒ¢©Å—kSG]i‡]V{ Wn‚¡o§›hZqrv`r\—}‰Âgtš·z›eNebVQ;GyHleEH`lM\]EIDIN\\PQ\bQfP[egQQLJMgn‰RNMJYXABW_ueVliV[YVSPIF;Ui^_\wsshZ‡¶y`¡£­r”šžƒš¯hXœÖÝÆ£ŸÉ³»ÞåÛÎ×à•˜Œv{~dej‹†Ê§‡ƒ‹‰wd`i‰n¢Š~‚‘s„È­œàÕË«¹“²À»°§{€¢ sxhrŽ†‹myrm ”mc„s—ˆ¿kg`ZH\UFGMRLc`Y^L^bnxJ=Ud[USu”LKGU§š:eVˆkD:613DG6GOFDDUHVNKS_muŸŒ¥¡›‘nf—ˆfcMfkC[Œov]P=5Eip\hd]j\uXTca=Z^wH_UL[c_cP\UQzVnRY‘KFDUZngXU_RPZUII?NT[KIRv_gRvgvŠ‡pšÂʊ˜ŽŠˆn~˜w`g–ÃÉ̎­»ÈÝæáÌÏÝ¡”–nˆtacƒˆ•Î­ŒyŽrYLW‰k|sw¡š’‰†‚Í×ÉÆÀŽ¥·Æº ²¡” ‰xqg~”]€ox‹ph‘v“‚uif_JCVR3@MS^YutUc§ºˆZlYi?Kt{c\_2eb§Žx]Ž˜P>?8<7>3HCJHUEQZGU]jj¢ÏÄ«”[UT~k +ž’UXfUZUiacPBYjeygPSWS`jU[¥€bIYhc[VLaP]_Pq^AO{e`a’aTXYZ^rdaZOXJ[BFOPXMEK`WWe +]²Œ€„§¿ž—–©§no h]b‡££¥‚kižÁÖâÜÔÙÝ°‰Ÿ¥–_Td’–Ž—‡}|RZb|s\{u|‰—}n¶š–ÔÖӻŢŌšš‹£³†{‹pqk‰“¢do{‚“{lzqˆ_XS_NUHNB;4@WnHTKSw~«Ô—ˆUKP?N`~bB?13jb”Zz’pG743>FABEDQTDQNGQX`|¯Îœ·Ow‘ +¶·€R_ESDA[QK`Wt‹UqyaLIEXc`Riy‰FEQ`^CBXWR^PhŠcfos}ZgˆicXRLK^eiSQSGSRQR^ZT=RbgLJyžŽ‚¥‡s¥°z‡ƒ‰d‚ž™uYcnqujljg}ÀÖàÜÜÞÙ¢o˜È¢š• “y•“uŠb„š|e}w +ŽŽz—§o€ÒÒ¥§Œ Ÿ²”›”œ’l v”u]s’°h~Œ›kgr—ŠW[XKLR@VLDT6GIDBMVŠ²ÖµŽsAKR:S[aK:-q[LSVSI{}DA<=?B?@D=LMLWU\TZaŽ¬¢—h +±vŠ‚Š·€t\Q`HV\^ivRnyfTobKDVROoL^m{MDfSJ?aWXjgbpxlnV‹bhkxb[_RM[Zf]aIILC>@^MURAQ[qHYScPyŠsRŸ›‰tr€Šm‰tS`qq„rr‡ÃŽ®ÓÜãäàٞvŸ·«—‘œš–m€rd`Ÿ·–ƒ^Zar• –š¢¿¶„‹·Œž€ÀŽ¯Ã†Ž‘ƒŽ^snxq–•ºt„ƒšˆbbc”Š\f~jkZQgUF8gxwk`~_VTHP_JVGHPAHBRay +z„qfwoWKarb}]Q[WPDOG\ITe`PUJEEYYHLD_‹yfTtao{šNT‚gab[rrkt˜cgTdm™ÀóžÚ£ªÎ×åäßܯ˜™›©œ“”†‚m‘xcˆœ°šŽmaco‰‡žÆº¥¡‹–ŒÀ¢±œª®£šž¢‡Ž—|mrc^w©Ÿn‹ +‘ƒeru”m^[Zgnskn>bdJ3B]kGœËÉÉÆÂA,6;;Qm8dKMRLKk]\ºÛÁ§Ò¿T)?JKRHEEGLSOJDYis]adfp`†lp^W ƒDOWpr€SAIQ‚mœ®—oBLG2GFSFQQU[Xa]QxeAHb]TBDH]UOGVMQ2=SVMKM_nRkVAbDWMH\c]hTQcnƒ{ƒ’ra_uV\luXonXUqžÑßÛÅųµ°ØæåäÙÚ±ay£ˆ{q’•‹†}™µƒ€•oj +ƒtfŠt»”§£°›¡ÂÆÊž«¶œ© Ž£ª¥¬­«¢nZWt„k~€d|y“‚‹ijjdQOCXFAEW[ZGEY^WGÁÇŒ¿ÁŒY)6BQSoYdPvcc¬lBJTQN8IHB=?CPFEFEOXQSILbkqvRc{¬Š‡ªq‚Š©cJa;5G|—cPT]‚Se|ŒB7AKLSMVW_TJXLK\wqBMjKY:NLQRBSKHJJYKHFLFT\bPU?WGknP`GWS^IiŒ«Œ¡a|o‚TYxqX‚Ž^YnÃÎÕÕ÷­ŽÈÐÞààÔҁbgx„pe‹”“z‹—”q„zfm‚’’€¥·œ +³‚Ÿw®ÓÖÀ¿¬¡Ÿ¬˜«µ°ª§«™­ˆ‰‘^O’†lƒ^hoighZ]VgMHCC;><=6CMX`PD7EYU@AFaPWIVE9SOfzv–ºŸ’’‚” ZdKKVcLyj\zmvD^†gH?;>IYbFLD^HFIKKFVhCM]VMCQYXFY<>RK@@MESJYthfKZ]e‹}mnUEYWNuvx¯Ær¡k‰k\~kjm{jU~ÑÆÔÛÖÀ«±ŸÈÑÜåÜÐraŠ}©¥{–‹˜Œ€™ +Š‡tftpŽ®šŽž™˜y˜€ÃÜÀÊÒÌ·¶º™¶¶¶—šž€€ŽcpYgœ€pf^[a[Zc[VZXVGZBA>mzWRIYQQMOKoVNI@A8o„\dflžƒŒ{t†€}USVFDU +‡Ykk}[GCQ=FARoXW[KYLIƒpL?>b\[PGDD4s‹]][U<:XHMANDo`[_cc +_XX +nrP]Qri{«„c”ÅŠ{f„zglaiidbWŽÑÃØâ×ËÁ¯Æ×ÞÙÜàÈp] +s„xx~ +™xx‰‘x{‹™²œ³š¡œ™›yŸÙ×ÞÛԱźŠ¬¯®«®©œ—“elq +”¬†kyvkakilmV^\QLA8@:Kh`Ux:;bBU}Š«³Î»µ|—agjcXcz›Š¯]F‡HMfKE?Mn~ƒ¡’n‘ÖĞmjtvqo{jT_gZ–ÉÜÚÚÖ·Ž¥ÆæèãÒÓž|}qxy‹ +{’‰‹we‚œ~v~ŸŽ—ªž‚˜§¢šˆÅßÞÖÚÓ€Œ¶Š¥¬€®ŠŠ˜”–nz ’«‘tpˆo_hYUbcVKOH=9<;==LmrCB]MN_W‘¬¹Ÿ°¬ž–‰ˆmpUZ‰X]PSJX[MN?MSSPS\C@R__UcYd„]dp„vf]‹“ic¡žŸ‚yon]VnObp—EaNaL0m`98I[_YMGbbOqCFFKHcXH=9]uWbC7EZMdSaTENRTF[FUQLT=7:S£|MJIYjn†”q™ÝÙvpxˆpWY™jUac¯ÍØ̜۟›ßèçêßƱˆƒlŽ˜•Žz“„‘dks˜‰fƒ—šž’®‡k  ‰–•ÂãâÞÛ׏­¶¶²¡š«ª¬ž•Œlz«¥©‡rcfZV_VRLPNHQKHPVYQVk‚f?B:=Oo‰¹ŒÃĶ•‰wxVoX^O`P_JML]\AOSdpQFLrD<5PPhKF[\WTF?OFLNABHC|‡_MPI]tv“‰ŽÕÝ``d’`Z]}|u]t[šÁÃÀŒÂÅŠæêëêåÌš‹§‹ˆ€“cW^q}q™¢’›£”““Š žƒy¡ÚãáãÙÏ¡­ž®³®£Š§§Ž£¢Š°µƒpineKLRLS`SGDHJ[Mxq€†zkH=A58Yˆ‹·°ª»Šfhk\[\N?I<@96>'#D7GA^LZVPhY\s™ua|Žžvv‘Ž™€ˆs\–w«—¬l}w‘ŒÅ̏?DSvªŒf{_W/C^CpeRQI_bHSKOˆgVh_S]CU]lTKRk\^VNK^SPQCOKD<5N]kqRJEWY\ŠxlšÉSoYl{femghaoƒÆË·ÕÏÖÒ§Éçêìåæס“˜Œ„††‚vX[]_b}Šœ›„Ÿ²šœ‰¬­Ÿ–{ +ÝáãáßȞ¶Ž³š¬€Š·šŽ|€_–š™jgxa]HROs}_AB9@QLw +ˆ˜sq +cE<4Dc°ªœÃ®Š}aU3TeEMINCKFE%1?CPQ^[VmyTSdW¡žŒžšw +”›—ª¬£‡“c”©œfO”}‹³É©j?am“†YeHkGuTbYXKSM\YDH^W€ €{TO@ILŒeVLKfnIC7WDXMPLZUGKEFF72;ML]u\LRS[umykk•—lgUmaŒsmq{nmÇŒÓáÝÚàŸÈéíãæäכsz +Š˜vs†raqrfcŒ’˜{®Áƕ©ž„‹ +iÃâãâ×Û¶«³¯Š€¶©«|šŽ]pz~e`tdQ\\wNJO=9;:=TYXGMfueME;GUš±ÄÊÔŠ’~bUQSQEK9@E.FV1,aMZwWNFSg\]Š‹«¥ª™pwvŸ¹¯™Ÿ¯ž‚m±©¯ef|zžÈŒš×¯;k‡‚bSMUIS“xMf_IA[csTBNŠœžinYODG@F]s;?O{‰D8JKF?Ebb]UN<4CGE@HHSCMYXVK]\^]ol²\cRdXov˜ƒli€ÙÕÜåãÖÞÚÜçêæäÞ֊„‡Ž uk‹¡„‚ttŠŠžz€’Ï»¢•Àƒ™’‘~ÃÚåæÙŸº°¶²ª³¥°œ¬••„L€Y€medi_hw‡`EB:N3=6:9L^UxdjJTU7H\OeV@MEQNGYape692HAHOO/@L@6>JPZZjZRY_ ‡wkxcO€lƒ‰riƒÝçåäâÙÞÖÞæçÛÛÙ٘z–©¢x§ž·²Œwlf†ŒŽ¢Œ±š“‹ŽÆŒ“ÀÒÛçÓŽ“¶³­¯­Œ€š«›”µƒ +ozYba\ZPXmW?<55=44E?EEbudp_M~i@BW·ŸÒÞ×ÃcaaOK_\ŠFcT;MQ;Q +’}i`m_|†‘ˆ‚”¹Á•ˆ\\nž®Šª¥ª¡¡r”µ—u‘—Š Ž•“nlZ^gogr[b­tGZ”awVT\`¶ÑjU{’qZIu<;4GNh?Mz†¡MODVhTTbOZkNK>PPX_865K==8GIHIGPV]d’\[]ZSi{‡„mg’áêêááÜàÒÜäãàÙÏ×€•¯Ÿª’§¬ž¥–Œ†‰y’~³ÛÙ¥¢~w—ÈŒ +†”ÆåàâÚ±Œ¥·© °Âœ–²©–£”d{mQLTKVPJGBFDB>4BI>165=G^OU^bFn;;C£²ÄÓ£‡stg\VuƒMFZXtn‚£†„|tq]snŒŠŸ˜muiv„cPLR†ˆ¢¢¡Œ²©v‘°mŸŽ‹d]z›ÈËǃqcgv|zŒrHG~IMQ\Œ€—u[krzyDHX==;IYJ6j_itNNRW`N=5<7IAEKILIDNTVWihubpV^jv_^Se°âééåêãáÌÛÙÃãÚÈȀ˜ŒŠ©‹““–”qk_rƒ‡°Ô±ƒ„ƒ—¡Âž™›—Œ€âççâ­u§¶¡¶¬Ž€›³·§|’VqrJOWa_RSO@VO[EHJE3/64E[ULJRaV=O9B•©µ¢hhogX`j +guugdlTrqVkto}yz”„˜ºŽ~]Z>\gOI?†—©µŠ¡ŸŽ„\uay›‚]o“ž¡ÆÇÔœVAte€v²ŒBQRaVJFL\tƒpKfO[ZCR6::<1;Kh‹[R‚”Žy¡Ž©Žš_^}m`KM`p]TW>KPN]^TQZsbNg~€uxjCIW;Z\€ˆ™€Š¢’t”£W·ŽŠš§ÂÇÅØÒÊr?NEXVvzKWU^diWBLUi\IKGQHNM>?73_oIW··bZF71[piFBDJCKHCKCSI5154;ESRXKWOVSRliƒNi{~‰mceobwÇÈÔâáÚàßÉÊÌçæàÝ΄‘•›§¡oˆq‰ˆ†€ƒÁ¥­r‘œ¡£¡ªœ„ˆˆ|ÚåäÝȐ¯«‰ŠŽ³ŠŸ¬µ°ˆ€io +J;nV1IHKAgHdXcRKJ88Hf™pJb•{žœšsp¬ŸÄÏÀ›xog~m_pdrfWIT?MIEQuiBQj_b[Yt•Š›h8Kr“^MOx·šš‰mº©z ‘Ž¹ÆÒØÉ°P‚‰‘`f\S\m\VQGF\DQWHCFoWˆbj[I=OH4£ÖºŒ@<8ao„T;:BRKIE>HTN8/45CDVIKJ]WJYYvSe„]¡sb]UaŽcØàÙØÁ¿Õ×ÖÃÎ×àØÓº‘™£†–ŽŽ›ž‘Š–¡•m•©„sŽwŠ’š—œšŸ” Ïàäàⶪ˜€­±Žº°Áµ—†p +wO6J8JqbP_hbƒ^qŠDG3PouYGYp]hŠ„_U +ŸœÅ²ŸŠun]}|rl’P^J?ODOSVU[QpZmd_tˆ†YUa€xVSKkŽ +ž| zqz†›³®»·ÊÎÉÅ¥ ±^FUdT}q]_\II\HfpP=CDFKjyveEBVE.“ÁЬ{8AHYdlUFAUROLC@@C_9.1??IMSAMYOJYy€PUŽk|~OuUZŠguÓèÚáÙ¿ÎÆÓÉàÜ×ÓЧš– ¡¯œŒŒ›ª˜•Žˆ—Œ’‹miš“’Š¥¯zxŸ‘}µÛäçä˯ž­¥š°®¶¬·»€’‰ˆMKDA=•c[Xv†‰ib8H9@n˜H]{r™†›žžž‡¬²±š|ukfS‚‡Žs¥œžsˆOVDQDQNXrinWbjwX–€Oc[gMORZšœ¯š•v]˜«²ÅŸÃκŽ›“•XBFLT‚tTG[VXQN_h]EELIN£ULnƒK7R^VI‹€‚ŽŒ:HB_]MQ^P??AJB43EBJXM7PLKTlqœ€xmq[ŒuQLiƒdmÓèåâÛÃÁÓÕ»ÔØÌÇËŽt~’—ŸŽxš‘~˜°¶Œjjf—¯©šª€ƒ•ˆ‚‡‰¯Ùæèâǟ®®©³¬¬©£µŸ˜–Š‘qdo6q•YMUcLo„now>OAS nut––eQ˜Ž§‰›£”qpddxw•¢Š‹foLRNlUZOifXWr†iftQn‹ŽZ6MoŠ“ššºµ„ºÁ€[¥«£šÇÌÑÄ¿±µ±f_9EX`tUHWe]fr[^P@RGG@ŠHFVM?F[B.z‰Œˆš8@K2BBME?0@D?J[UJEIW[V=R‡X_npWMJQ\wa‹ØáçèçÎÑÛÄ×ááßÓסv’€«Ë«”šŒœƒ„Ì৙mlg¢„x}¯™“Ÿ™“¶ÔçéâÌ©µœŒ¯›’§¯¿®–”œ +‚ +{5Ž}]V``\va_WSVMjx‡o_€³ËNJau‚¥šœ£‰wcaŒ•¬Š™Œˆa]GAFXSR[zx\epmTNtnrq^VYXebn„ŽŠšœ›—‘sŽŸ²ŸÂÌÓʯŒ·µ‘_YFQRbhygOXLwWTLYXBDIQ@]OXSCHDT?7Qj•Vj„99DU]`QR=C:MfU5CZ]N=:9GVLLH=NUiO+4y·Š\fPP9AFB\;>DB=DALF_o›bC4Bsvv†v~hc_€âàäìåÕÒŒ©ÑåéËÌ̉ƒˆs–¬Ÿ™ÊÙ㉧¶‰‹u¡¢qzž‘­»³º³ŒÕæåàÑŠ«°²ž‘°žš«š£{|€t]OQN^]dƒŒ€\LSPplcXX +®¥n[FO[ŒŸ³¹™~_Wp€¯Ê¢ÀŬ­©©‡ab^crSFQhgv_TI[?_[˜X<^di[{¢¥’‹ºƒc¢“žŸ£ÂËÏÎÀœÂ£|k{[fwYkWVfhhkaYY\RZAQSNSWejbNLOSyxŽœSL5:ÁÊ®s\R_:@EFIMP>TAFCN@HAIJUlp^UCA>Ud_g{ldeoqiÝãëéàÏÌž²ãêåßß̆„ƒŸŠƒ + ÓÛÞa\kpxuxššwg”y +€ŒÁ¶œÅÛçãÞÝ®Ž¡£› ¬–ª®±«€t™dmtcMMi¯‡€n]RW\glq`tbTCGuU[~–«¬¥¿®Ždwcˆš²­©Ì¯¡˜­hr_8:]hNJDauokdG>w}º¬L\fOW™™­„Œe¥±§¥Š»¯ËÉÅÂÁÆ ‹—fvJb„y``Qkpl_NUo\Qe_PZZ\cg{iYJ\[^d€™d?A8»œµhYeT5FmbJGGG[O?OSOVJC?RbR‡`RU>CPokna[\^gqÕäëèÝŧ®©âëáÓݘ–Ž‡™„mˆÎÚÒjY[X\ty™zrŸ„{y¥œÀŸÈÞæäÜÁ”°²‹‚š˜ª‰™¬±Žz~Ž¶µŽ~rj`X{—‹|QPM\YVLSEII>SAKKFŒ«º¿Š²—de +Ÿ›©§ÁÁ~†ŽyIZLV=ESIDE`UsoLWXmi{ª›CV~T\ƒ†˜‡ix‹›˜ª±·µšÇ¿·Á©’‡–O`‹”gwVmaR\ELv†\†hLLclTLpWRKmƒ[y˜P7b8‘¥µ“o©qIR_KYHQX[NKFPPhG=QKa]T]YWUbiY`dbfX^lž°ÆÓéÝŒ¹ÉÍËÙÚÚƬ•˜¡¯€ +­µÚà¬cZY]`]n{€€‰†Œ¢ÁÅÈâèåâħªº®£­Š”²—£”€£Á¬‚˜€Šxu{VTJ_MVKPGeSBF=BWIIzšÃŸµ”®€ƒ€‡p’ÀÞo›ŠdNBHQI?KA:[dh_DH_‡{ƒ›ÀrSoi€ŸƒqWn’—œ›ŽžŽŸ¶¬­¹ŸœÂ~®¡§‰cLy˜Šo—IYdDSQNXNVƒXT[€nK?TXiBgpF„eŠU,GJ +Ÿž†k‡RZPQKp”a[UJ?BBJXVISLZKOPNGf^c[Rav`adh„ÑèÈÚêêßµÛÙÛÉâÜÉ¡–‘˜œ¢›†|žËÃÝÜ +[VU[hvjdŒdlyvoyœº·Øäå嚯ŶŰÁŽŽm +¯—§±µ‚xŽ«„s~Š£ŒycSHGGRZcƒ]\CU[\`@E€v¢pš²¬’™}ˆ’ŸŸ}d²Š‰R4HbZABMaQu`kiaNŒˆ‰ƒ¡r?[t¹ŠÆxŽŸŽ¢¯©Ž­³Œ³Ÿ­ªº°·›¥”±ŸwLOfv­¥\hŸIU_uYUy{ug\™ +i=@VoDnNUŒTc7%7V–¢r +†€€‹gdvzXIBTJHMFBRFKOCNRIRLMR\RRbdeox×âë¿æÞß¹ÍÍÔ×όț‰Ž–š‘¢ŒwËÚ»ÒÙÍsXSb”‰i‚bYjjlŒ†ºßåà䘜«œ‘™Š€u²€¢¡ŠqTx¡v“wŠžœuiUEI`ISohciQH@C>YklsW„”®À›Œœ’žº–—˜‘„Q2Q]F\Ynmqnf€rSVfZha“Z]O€¹•y›˜–u«ÁžŠ¬³žŒ¯«–~µ¿»¡»§‚KPLi~}k[jSTU]||~[mPa« ue>9cHLk_F:W50*[ª€¹€‚«¬¡|kSyiLY^Q;TGQE_LI?KEELUXOVNUS`o~w‘ÜçàãœâÜÌÍÀÐÚÓÊ­žŠ”’‡‘“«ÛÔÚ¡àà¹enytz +hZO\q‚¥œ˜Áàæãካ’ +l›t’}™šž«ŸYyŠ + +ª±Œ€‘oye^w~YeŽœ¶–T`HBHPGNWLy¢‘ž³ª—®º“«±ºf£rp‹P4OWBOZg^[zwšGJ‰d^dGŠcf›ž•žše©hkzšŽ€Ÿ§€Ž¯Ž­¯¢š—«€³ +Zk\Uƒˆ‘_UYPBa‹ +i¡Zb_S‰wNa7AH[ƒWbiƒxq€hvwSƒ^>jor€µxn“zšœ£¶©ž±©€±¿­µÆŠyz‰oŠVnVŽ‹šma\DGcšxurVbTnigF/WGLTŽng’K=02AM|v„vt€ ¿Á‹SRNvbc@XLC[eH>Q[T=@VRRm\\kkgaQ]iuâêÞëìãŒÓÿÿêâòðП¡©‰š® +™Ž€Ýáۈ€Óà×{oxŒffi``cZbs’žµØçéå{ff^†v–„lŒ™Œ‚Tn[z–™œŒ›œ£fJu‡{p^Rf”Œƒ˜ˆ +¬¡€ˆsav‚³ÈŽ­²šy‹œŠ„p3HpM=B=F:JQj^bfz]‹‡œ‰bŠ‰_I[qu€¬š­ŽŽ‰ ¢žž€•Ÿµœ©£« ¬¥wpVTbž²€~_nsQhjRRRU s‚}faFRC<@7DAYZ`„g‡GJ7IUQŽ^m€p­Ž®s^[iiKb9CCI^`MJAPRUIFEUnf\OLRd``z|ŒàñòìÛãáüçíòõûü÷Ȕ‘”¬«£’žßã̀{ÝÞŒwqŒŽuve[\ej‘¶³áÜè眂‘i—‚˜‡jl›—}›}|•ohn•fq–xez™—“{S]žŸŽ†®Œ®µ» Æ²šy”«ªÄ»Ÿ©¡¡‡­—i\NGPCB>>9;GDQfœ€‘”•UT[“EBY<>AT`YSJPXPB5AFJPE`VQV__^sv§åòïìàåüÿýàÑà÷þÿñ—†š³¯ žŒàä¿rvx±Þݏluec|“†vzv†o¥¹ãÔä瘔™†ª›|Qj„k§’~uf‡Y–i^ƒd™}ˆ_T^Zx|™”©ŽŒ»·Ÿ wŽ ‹„²Ÿ»€•™œy¡•’pŽNOJG;:F€i[†ZŠŽXp^[\–nnšfxs¯ŽŠx +’s”Ž›€s[Gu^ƒs\pSVJg”ždVVSTUqƒ™HKM:2@;87-?bŸ¡SefY;@9jpTpVdœbm¥QUgOyw?HN\P_bNHA622:1, +18@k†TLEAC;=k¡–bqFZTjKK[cQ:Q~INRO[]vX^K216CL`€¬©«ªµž¢Œ~x áìôöôõþüùýüþÿíæã쑙Ÿ±¶ªÓàæ}mr„¶œÂˆŠƒ}†Š•£Ÿ~—£»×Þç籒§Ž®º³žapŽk€qyMb‚¥’‰yOstpy\€”†sy©˜¶ž¯®ŠœnŒœ­œÄ­µÃ²¿ +aŒ®Œ—rWRWKNBQYMBL<;_ONMAHEUUwš +yqsxgmSDRhu‚¹¶š‹ykab_lzjOOGJobUBA@PBw‡ž’XYAJ=7HI6tm:22:0PhWX[}T_74)3D¢mQUIIGDWQahW:D=;AaO?KA_VNSP96>Q[SUdXWZ]`benžåéò÷õóýêèöéãíêÜØš¥¢Ž‹Š¯®ÜÚâ›xx’oŸÍׯž“ŒŠ„ƒ—¡ËÛÚåç·£œš±º­³cvh†Šp_~ˆž™j|ƒKk +‘kt€‚‹ƒœª¯ŠŽ¥¥˜†Ž£ŒµŒ¬Á²¯°KU’­ž¡sZL]MCCXqP=;>NqT_>p¢©kRNLB1=@FVNTB,(J3zŠpRWwbsf85>N‚j\9C895KB=/.EIKMX76DMSFHI>A@>RUSWVUUWX[]bhšáïòõïßñöøôçîäêîñƺ¶™œŠ§›ÎÑÔÊŸ€wtxzË×Ü¡”–š”ž‡ +˜ŒŠÐßÞê韈—¥ŸÎœ»”lv›yg~Œ‡‹˜h{[eaiScld–„¶¯£¡¢¥¬•msª«µ¹Œ­·­ÅšePžµŸ~{]LIFPWa€W8D@I‡rBBIKMVYG^b‡ƒux‡eelpj‹–™kePeutzSNDKBZ‰pkL=:_RL_qzudsidxZNZ€|itŠkj{LNR`\QD?E63FLWB>;CFUnTN>5FZF=8?V10G,CKKpˆ ŽQ(-5OodbO.7K[?AgGT9J[iF8ACHI}”h]X7LLdLÉÑÑŸ®°ºœŸ¡nªëëíòðÖ¢Ïþÿùùÿÿö·‚‹¬š¬€ŠÅ×ÐÛÔɉ‹ˆˆ™‘·â㬃™ šª—–ŸÈâãèß¹ŸŒ¿µ¿¬¹¯xV~ž~KK}vZZ‰ycOIP[w¡Ž¿šž€ÁžÃ¹µ«ŽŠ“¡¹€¹š©«Á²¢~­œ¬‹ +^R[CDLZAOXOOG?I<=?17AC1<*5G8O‹”xRC2J18?V‚eIUYUxSlEU_\JB:5XRJIaSdpU[YDGÉÎËƬ±³¹¥ˆq§ÞìîñòߛäîìäÝϪ|ˆŽ­”Œ‰ŒÅÑÌÎÞΓ—šq‡x¢ÜÜØ€¢•œ±¡ÄÑÛêäÛ³Ž·Ê¿»¹Œ»“‚‹˜šjŒ„h_Z~p[NVnŒ­€°¥­µÅÀŸœÁ¢š–ƒ¯Ã°°Š™›µ°Ã§®ÔÒÁ§—¯yprb>HCPXHblaBIb]SYavfLRF=@Gh’nAVof[bY`j\W›x_VMIID:=A>C>8:D>7=PSVJ>4BI?EBF<0(#+;:e‘š~Y3C;B4kl‘ZKHMV„|[b[W{wd27KYKMfdZ`YYZIWÄÊËȵ²Ÿ·©wrÄéíðññèÜìéêåÕÛ×ujz“¹©—©ŸÍÛØÙßډ°u™xuœÞãË¡¯ Š£­·ÔçêåÜðœÌ¿·ÊÀŸ¥™’·°y€‘sttˆxXKQq‰‘µ­žŠžÁ¹ŸœŒž±Ÿ§ŒŸÀ£ƒ’©¬ Î§­ÍºÉ··—Ÿ‹o|iSdW`XtZhKRYri»^}¢cJ;:ERt\P_ZVP_enZqw{ceNRL=DNGBAC::@8:<;+;@?MV<>=?PPvn]l6LNJ;76MCI978DO^Zps@FHEE?.8@299%(487scjREB3TYuz||]AfZ]‹ŠŽ‚jnKŽN)3@Q3[_XRLCRJÂÄÆÈÏœ»ÊµŠu®ßëéòôëàçíéæããҒ§ª¥€±¹ÊÙÜØàåàÐÁ±²±¯˜‘—›œµäæ໳§­¿ÏÒÎÆËÄÀºŸËÚÈÄŸ¹®µ³Å»¯¶˜–u—ˆÇŒfŒo†³œ¿ÅÄÉœÂÀÇžµ·«º¥‰š‚©ÀÁɚ‚Špu¬ÀÁŽ`qqwi}„pŠtnbqhz{olwks|‘r„ŽviYU]lady~}w„ —|zzƒ‡••’Š„ƒ|†Œ~‹H7,8EPl„kPVX[K75/7@A7&0B?4FDDKI&@@Uk]\rHPuic‡ +‡uX‘—‡k**SFEb„vQmcaV>QÁÄÅÆÌŮű„u°åïíóòîØéïêëéèՔ«š¯®²œÍÐÙØÚÝØÙÕŸÁŽŸ»°¥ž—£ÏæåƱª³Æ×Ýáá×ÐʺŒÉÈÎƳŒŒµ¶ÂÀº¹©¢Œ®ºÇ °€ƒ•Œ¿ÇÌÊÅààÉÅÀ¬£Œ•gŠ®§žš‰ª³®ŸÊ—‘—‰‡—Š™ © §Ÿµ¹œ¿ÌÈÅÌÌÎÉÌÎÑØßêäåååæãåâæãÛáâãââããããåáÛÊÈ»£ŸŽ›Šš¬O-1@=D}gYUJbeZJIYVZejTyZD7I:LT9=@A\kY\[DQbHsv‰}uŠ¶‘ + +25AKU–gfŠ‹€jdEI»ÀÃÄÉÈ°œ«‚vºäêðóóêÝëñíïíÜӑ£«¯¶²›œÍÓÖÚÙÕÖÓÙÙÙÖÑͿƌ²ßãä¹€±ÄàãçâÉÈÌÃŒÂÂÏÆŸŸŽœ¿ÆÌÇĹ²ÄÝÈÂή‚¡·ÅÒÔÑÍÈÛÖÓÓÌÆËÈ·°©¯ªš±žžµ­ÁÆÎÓÚÝÝáâãçäççææêçëéïóñóõô÷ø÷öòôõóóóïðëìêêæåáÞÒÒÍÍÆÇŸœœž··Ž­¥ ’Œzrufl‹“Œ›€ ž‘U€•¢¢¢ ¥£¥¥•}JDIPS\gVRd‡„•w“œ{¡¢”¬ª³¯ +²®­ŽŽ³±o›±Ž‘†OTpT¶ÀÈÇËÊŒ®ªƒw»áçèòóíàçëîîíÜΞ£žª±§ÁžÍËÌ×ÝÞßàßßÝÜÝÛÕÚÝßáÆãåØÊÑÎÐØÞÚÈŒŽÁÅÅÍͺš¥¡¢¥€¶ÒâìñðïíìðíäéìèäâßÝßáÝäääääçâÛØÍÈŒŽµ·Ž»ÄœÆÄž±»ÂÃÂß»·Ÿ¿¿ÀŒŽ·¹¹Ž­¬¬ªšŸž—”Š‡‡† +~}}ywursqonmmlkihfeeeh¡ˆj^Ip“¥ª¬­¬ªŠšF +¢œ¢’€¥¥¥ŠšštÀÉȹª‰š¬¿ÃÃζʛ¹•­º®Ÿµ±ªy§©¥€¡ ˜hž¡˜šœ–œ“¶ŸÉÊÌÑÑš­ƒv±ãàÙäóçÛèííäæÞÍɹ³ÃÊÊÉÊÖÖØßàßäâæåæéêêæîìïïííííäȟ¬ŸÄŒ¡”š¿ÈÎÒɹ™Š‰‡‰ˆœ³ÂÊÑÜÚÏÊÎÕÐÏÉÀŸ¹µ®ª§€£œš˜“Ž‹ˆ„€}xuuutssqrtrrrrsx||ƒwƒ‡†††„ƒ~€€€~~}||zyyxuwyxwvvvuutttspppoooolnkmmqŠ––uhŠš«®­Š¥ž›L•š––ŠŠ Š§Š¥ˆši°¹¿ºž§®­žÊÅƯœ·‚»Â›Ÿ»º†šµ²±³²™cˆ€«±¯™°±±±²žŒÈÌÓ×Ú¶ž‡w·áÍáçñèÚëçîíéëêèëÞÚßæáØÔÒÖÒÈÅÊÇÅÇÁÂÁÆÁŸ»»³«±²¥™“‡ŠŒ€}ztwxzzwurooonnoruy}ëè°§±»³š¡›•”‘Œ‹ˆ‡ +‚‚€}|{yxyxwvvutuvwvvuvww +ˆ”‡ˆ‰‰‡‡ +„„ƒƒ‚‚€€€€€{||~~~~~|||~~|~|{{{z}}~y~~€Š›— +˜¡šª¬««©€¥VŠ“˜Ÿ¢¢œ©©ž©ªˆ®jÄÈ“žµºÄÇÅÕÒÏʀ†§®x¹¹¹Š¥·³²³Žw}Š®±°±²œ±²³³µÁÃÉÌÔ×ÛёŠyºÂÕÝèôôóôðÕŸ«¢¯ª§ž›——’ŽŽŽŽŽŒŠŠŠŠŠ‰‰‰Š‰‹–”˜”‰†‚€~}{||zyyyyxwvtwvuvwxz|œóöÚ®œÅŒ­£œ˜•’Œ‹Š‡ˆ†„„ƒ„ƒ‚‚ƒ„ƒ‚ƒ‚ƒ„„„„—•Ÿ•™Ž˜”ŽŒŒ‹‹Š‹Š‹‰‰ˆŠˆ‡ˆˆˆˆ‡‡ˆˆˆ‡ +‡ˆ‡ˆ‡†ˆ††ˆ†ˆˆˆˆ‡‰¢—›˜˜”¡¥©©¥Š§¥££Z™ œ”Œ–¥¥£Š©œ^Ç☟ƹÆÕÕÉÒ×ӝgƔbºž„¥¶¶ŽŽ­n‹²±®²±³²²ŽµŽÈÈÉÊÑÖÙÖ­„|»ÙÓ×àùúù÷øìﵩ¶²Š žœ˜—•–”””“‘šŒŒ¯™¢˜’Œ‰‡„„„ +„ƒƒ€€€€€€„„ƒ„†ŠŸðøú¿ÏÐÀŽª€žœ˜”””“ŽŽŒŒŒ‹ŒŒŒ‹Œ‹ŒŒŒŒŒŽÀèæéÞ¡­ š˜––”“’•“”•”•••–––”–—™šœœ  ¢¢¢€£¢¢ŠŠ«®°¶·¹œÀÁ¥˜ž ˜ŒÒÒ¬žËÊÈÃÅg¥ÐÏÍÄœ¹ÇËÇÆÍÄŧ]Á¢ŒœÄÒÔÒÅ×ÆÔÌ̖†Äƒ¹º£º¶µµi›t¡›‘¢¡€–®š¥š–ÍÌÌËÒ××ÕÀˆ›Ãåãéäùùø÷ñãó޷Ź«§¥€  œœ›š™˜˜˜–˜–˜–—­ôôí¶œ¥›–”””’“““”•—–˜˜šš™™™š£§­²ºÁÏòøÿåçåÞÙÖÓÒÒÑÏÏËÉÇÅŸ»»œÁÃÄÆÇÈÆÃÃÆÇÈÈÆÆÈÇÈÜëëëðÝÝÛÙÑÎÉÇÆÇÈÇÈÅÇÎØÝÞÞÝÜÛÜßäæéêëééêèæäßàÝáçéëíïñòóòª¢¥Þõôñ·‡ŸÓßÛÕ`°É¿²²³¬•±­£™“zQˆ]|uytoqfe[qf[Klpmu[\{efUjW•|%+?špg‚x›„]ˆeÑÓÒÓ×ÚØÕŸ ®ÄééêêääéìÞáïøÒÀ³³°«±»ÎÒÌÅȑ›‚±¬š³‘ŸÇÕÆÌ÷÷ûџ­©ºÛßâÁš³ÆÑÕ×ÙØ×ÕÑÍÊÄÆßßãéïñóõùÿý÷÷÷÷ø÷ø÷öóñïëèäÞÙ××ÛßâåæäâàÚÚÜÚÙ×Ö×ÕÔÕÞèççîçØÒËÄÇÅŸÀ®¥¢ ¥Š§®µ¹¿ÏËÅ­šššªš ¡¥¢œ’”‡‡ +„uxrehotm£™ ŠŠufVSW_WŸšŸOIJHOcF<60-A;(5&!(2-><[K<>Lb^LJ`W[DAL††Q +H_rŠ”wt}Ÿ +krYÚØÙÙÙÞÜÖÁ±ÂÍíïëßÏÜÖãßâîøçÁËŒª«º×ïëæÖÖš©¡ÈŸ³ŒÃžÉäËÇøøü奭±ŽžäãÌb] +ˬšÏÒÉÅÇÉŶÖÛÝäçèëöúÿþãêäãæäßÙâÓÔÐØØÄÄÌÊÊÏÍÐÍÁɬŽžžŽ«²±€®µª°ÎååãîÛŽŸš˜€­Š¹‹[OLPXbV^\ƒµ²ŠYPQHGFD?QPMKGFC?FQQMF?@CBA£™ ŠŠ\=LIRTd˜œœN@HI;7E;*-]M>.,1="$!.1;BZF6QWHJ=@IX?=FgfvZTR8¡¥ +we{]\eMßÜÞÞßàáÚÈÊÑÞêîïÜÖÜÝãÝáêöç·³¥ŠÄãïëåÙÙÑÐÛÙØÒÑÖ×ÕÓÈÏù÷ü㪢 ®œÂãß­]c±ÞÞ¹œ¹®ŸÅLj~©ÇÅÆÕÜõùÿùžÇÂÍÇÔÇÈÏÅÀ»äÍšžÌáÔŸ¿µÂºŒ€ÃÉǟ¬±­Š»ªŸÉäääî׹а•§›Ÿ¢ŠvxwtbZ[\—ÚÔ€^UVOHOLOPVB?DAJGKFB9GGC9BA¡š£§©WADNEKwåْP<>7*5>/$+F85 +&>&&0 + + +<=:'7K3EDF<8;/C?=Bb\dj?)+š§«”wTegY_Táãàâäãá×ÀÊÒÛêëîèÙØáÞßàíöÞ±§¬Žª©ßïëãØÛÚÚÛÚÙÙ×ØÕÕØÚàûùúïÈÊÆŹ„ÑãâV±áÞÉŽÁŠ¡·»Ã„u}·ÂÊÐÜ÷ùÿúŒŸÀŸÔÉŽÄǹÂÂÒÅÈÉÎÛÌÆÇ»¹®»ˆŸÖÛÙ¯š¥°Ž¿¡˜Ÿàáâï˕›œ’«š ®§›ˆnn_iXdU•àæœuf_PNPKMEPHL>BHTA?H=C>7@RAšžªªQF:F?GhæçãÁUbM7;@;'+*A&.8 +3%)(/ +28>B>S,CG8;HN=:7LPXidH + '££•†qkcJNJççåäãçãØœ­¶ÖçëïáÇÉàáèâíøÚ¥¯ž©¡·åííØÍØØÕÚÛÚÖÕÙÙ×××Þùöòé×ÛÜÚÛàŒÞãÙ«ÕÞÛƜߋŠ²²Šsjº²ÔÑÑöúÿÿÖ·¹ÏÇÄ˶¿°ÊµŒÉÀÐÅÈ¿Ä¿¶Ç¶ªŠ“ÓØØÁ˜Ÿ¬²À¯¡ÃÛßâï׬šŒšª© “£ riaabmZaœÚãÞqc[ACQFGICMEGACQP=C48C=7.7•”‘›ž]OQJHWléçäâYSVbO6&#*HR0&E+*4#1&2 +<@JHAX8FIO;=BHHEQbrU3H)0,Š¬¶«•wYPUKSéèéèåçÜÛÓßÔÕèêìØÎ×âçæâîùà••«»Š²âîìÔÙÝÛ×ØØØÚÓ×ØØ×ÕÞ÷íßßÖÐÖÙÚÝÛ»äãÞØØÕÑÏ̻ڋ«¯”vÇÜÚÖàõ÷ýÿõ«º¹ŸÉŸµŽºÍь޹ȺÆØÚÛƜϩÂ×ØÙÊ ­Š·¯ª®ÀÚÞáîÊž˜¥£™š ŠÌ›o]SaPXe£èæéy`XTXXRDLT\PYJEVOEKJJUJQIH¡¢€©¬fKSKWXfåäâàXONP`ZD& +%G6 +2351!4:""9@@66NFBD5<83CG]dmODCL+&+Ÿºž¯\djSJXêéçÐ×ÛÝÐÕÃÊåáæçÛÓÚåëØâðù컀«Ñ±°æïîÁ —¢ªÇÏØÍÒØØÖ×ÖÝïØÈÕÔÔ×ÙÚÚÞÏÃãßÜØÕÏÒÐÉ¿º­¶²¥}ÐÑÊÒÞöùÿþüŸÃÊœ¿ÁœÂÁÈÀÒœžªÀÃÉÖÊÄœ·ÆÂÈÖÚÛ̳³Šž¶Ž¥ÔØÝãñ¿¢—š©¥£±¿É}h_ZXXTX¥íôñˆdaTY[ZPHNXTR\gdTIWcN^S[YW¡¢£ª±^1-:@#$#2?-2<<9OA69=8Hu‡[PJTQNN* $¬Œº³fC\OIMGϪ±×ÉÐÃÒÞàãäèæàÙÓÕØÙâñùðãÓÔØÒÕâäãáÜŸ»¹ÒÌÑÖâéééëëæßÃàäÞÜÖÉÔÜãåÓìêìçæäâÝÐŒ¯š®ªš°ÉÓáÓÑóøÿÿøÑ×ÚÕÔÑÑÏÌÌÖÎÊ¿ŒÀÈÎÐËÍÈÊ×ÖÌÙÜÝÕ¯ŒŸ¹ªÌºÍÚßäðË€·±°¬Ä»ÃÉ̶”ˆ‚‚‚‘Âòö÷±ž–‰Ž‹‘ +|}wwv}ws]dhkonsowt€›€«°€bahoi{êãÛ·PWkaZ__ZP_ZC@-5I=F@MA<:?KNKEMJaMKRZ{“zXJNOYX]jN;F¶ŸŒ³vOTSYTSƒˆ¿àãàçååßâàæåâßÕÏÕ×Ý×ðùõìåáÜÜÞßâããããäçëïòó÷øüûúúáÄÖëïæÛŸÆßêïðóóö÷ööõóëÛž¥£¢£§ŒÜìòÝœôõÿü÷ôîìëëëëëìëëèåßÛÖÏÉßÀËÖÙßáãáãàßÜÙØÛÜÔÐÚáåòëåçäåèëééëíìêêëëìíîîïññòóéäãïñêëïíìéäÞÙÎËÑÚãëîòóñ¬˜¥­­ÛëìîìëçãäÚÌXÒàìæÞÂÞ®zyiw†\‰À—¥º²¯Àº²ƒŒ±‹bnGŽ “³²±®°±³··±«¶¹ž¶¶’ˆ±°°~¶àáåååêêèãßåå×ÝÓÍÕÙÞàðûôíäÝÛÝÝÞáâãââäéìïóöøøûûùôÙÑâíóâÄÆßëðòóô÷÷÷ö÷øóêÚº¥€£¥Š»ÝíóÝÀòöþþöñïëíëëìëììëéåáÜÕÍÄŒ¹ÄÐÚÞäåçåãâÝÚÕÒÑÐŒÆÝãéööôõõõõöôóòðïëëêéêèçååççèëëèâÞäíèëìëêåàÙÎÄžª«¬­®³Ž§¡Š­¯Ž¿¿ÃÃÂÂÁÄ¿£\ÉÁÈ»¶¯¯°¯Ÿ¶¶†„NSd]is}‚{†\lm^pUVšœ©’µµ²°³³¶¯®šž»Žºžµµo˜²œ™ŒŸÙèåáåääãâãáæçáæãàââåãñúóæåßÜÜÝÞÞààßßãæéíñó÷÷÷øöéÎàäéïÑÅÝêòóóõ÷÷÷÷÷ø÷òëݹ¥¥€€§ŒÜìòÜÀïöÿþöóïìíîîîîììëèäßÙÓËÄ»ÁÎÙßãçççåããÝ×ÓÏÌËŒÊãåêøøöôööóòóóðîíìêêêêèçèëéëìëëìîìâäéçíéèâÜÖËŒ¬€€££¢¢¢¢€®°›«ªŠŠŠŠ§‘—’T£¢Šœ §Ššªª§O›£‰€tŽql”–§·­gƒ¥²”¶·³³¶Žš Ž¹ººŸ»¹žµŠlˆ‹”š¬ÓèåäçåçêêéçãæåÌÖÛæéêéëñøîâåãåãããããâããáãåäââæãâÜÙÖÑæàÔÒÊÍÐÌÌØØÌÄǵÖàᷗ„„œ²“˜µÅØÜÕîõÿüîíèëìíïïîíîëèäÞÙÐÇ¿ÀÌ×ÞãçëéççãßÚÓÎÊÊÌŒÀÛàäøùôôõôóóñðììëçèçèçççêêëìììíïïïíìÞàÝèäáÙÏŵ§ŠŠŠŠ£¢¢ €«¯€ªŠ§€£¥¥Ÿ”P–ŸŠ“£œ šŠ”§§¥šSƒ€©ŸŽ¥’‘‡»º»·¶±T—¥‹­¯¥š€€šº»žº»Ÿ¿¯¶Žšm£·µ¶Ž¶çéìèçäèêéìçèéåèåáÚßÜÚêîôìäåâãããããââäâáãããâääãåäàÞããÌÁÑÚÓÍÉÒÜÜÏÏÐÇĉÓÍȔoYj£ÂVY—¯šÂÌîôûòÃËÅ¿ŒÀ«žÅŶŸÂÂÂœÃĺŒ¿ÈÔÔÖÚÚßáßÙÔËÉÄÈÏ»ÏæäëùùöóóóòðïîëêéççççççèëëëëíîëéëìììíëÛÑÐÚÖËŒ­šŠŠŠŠ€¢£ œŠª®£ª€Š£Š¥£Š‰?ªš¡™£§ž‹”Š™žŒA=JAD3;<1<.+/,)0GLE193*+72<543389=cd]TJBH>EDWçãÞÝàâÜßâÜÜÞàåæåæéêéåíñðéæääååãääßÝåäãäääãããåãâáââÓ¹ÔãããáØÝÝÝÏÇÔÒӉŒÅÃÀŸ­•šÅ®^{¹Œ‚Çíôúùɟ¬Š®Š°À³Ÿ²Ã¬²ŽËžµž§À·Å¬ÀÜåäÖž·¹žµ²ÑëëîùØÆÉÌÀÏÈÇÈÄÇÂËʹÇÊÎäéêäÜÞãèêìííëëçÞÒœº»¶©©©©©šŠ€¢¡ŽŠªª¢Š¡£ŠŠ¥¢€F©š—~—›¢§‡–ª©›’>?B:63<60,5722>8;K0):112515=1%&'#‘ˆai9+/:?6BÚ×ÌÈÒÍÍÑÚÚàçæäãàâåçéæèéíèçæææååâãßÕÙ×ââããââæççâäãàºÍçéßÞáßáÜßßÙÙÕÔÖ³­œ³«³‘€ÇǍ¯Š{{ºìôõûُª«€žŸ³² š˜¯ªµ¥±¬”µ£€¥ ³ÕçäàŸÄ¬’ˆŒ™ÍëìíøÄ£©¯•‹«“„”˜­µ–€‹±ÜðóÍrfmonmin`ejimZ\Pclfbcntx|ŽŸ‘€£š‰‰Š‰—–¢§Š“A–˜” +ŒŸŠª„›Ÿ„¡”BM5,.;8789177?49;398.5:?/@''-*1 +2§l‘r925"=?8àãåäâÛ×ÓÖÍÇÑÖÙÜÞâãäæèçåçäëéééêééæèçããáßàâââßäåàØÞÚÊáïïßßÛÛÚÚÙÕÎÌÈËÐÏÂËÆÆÀ»ÁÉÌ¿Š¿·ª“ºìòöüØxˆ¬Ÿ³°­œ¡ªœœ‘µ»ŽšŠ€‡¡˜m­ÔçäÚŠ¹Áµž˜Ëëîï÷ɝŠ”tto›ˆ–±ÐÔÆàå²ÇÞñó딑’­yt]bNKNNPN?9:BJRMMS^hk¡€£_^_T^W_ÝáÛ¶>QJcGW[SPNYTFNHIL+)7*?.8G?228AC9155+;.20$ +*+:.+-3‹Š£z7-7.959ÖÞééëìíëìêëäßáßÝáäåçèäÝáÜëéäçæåæåååäããäááãßßßÝØÃÞÜÞéôîÕØ×ÔÑÔÐÃŒÀÀÄÀ¹Œº¹»œÁÄÌÐÎÒÓäæÕ÷ëóûúèÄËÏÚØÖÕÇÄ¿»Ž°³ŸÂÆÕÁ§Ã«±›yÑåäݟ®Â«’Œ‚Ííîî÷ɱŽstry‘¡§¯æõ÷ööôðäïííñôòòñøö“rRME>RMIGDDIHSVMEGX¡€¢Ÿ¢fT_hVUWÙ×̱AVD`ggR=IG?;;<@D;'$4/"B44('8B/;:<10;/.49)%;B8IZ”“A88;?;.ÉÙØÕÏÒÚÙÞÞÞÆâßáÑ©œÔáæÞÛØŸ»ÀŒŒÉÊÑÔÙÞààãæåäåèççåääÝ×çíô錹ÃÌÍÐɺºÄÆÉÏÐÐÏÎÎÏÓÕ×ØÛÜÕãêÔÖëóüôñóìôôóôòñãæÞÊÕÓÓÓÒ×àááâá×ÓÐÒØÜàÙ×ãØÙÓÉêïðïöÖŒš§¬¶ž²È·¿ÞîïòôöôàòðòññòôôûúŠ’‰bQVVUQCGE?EQBOdR—¢¢žœ_BZYNVhÖËűAVLJrPYN=D@DDDB:-&),*%$?93,AD27:+'/33341<@18H8=(Mž£{=FA@=2&ªœÌÑÒÒÉÇÕ×Æ¿ÎËÉÃŒ°¯šÂÊÌÔ»³­±²¿ÇÌÔÚâäàÞáäãÚÑœÂØÛÔÀÎíïñòãããäàÛÛËÂПŸÀÃÄÂÅÉÄÂÂÅÉÎÏÒáéÍÇðôûöóïîííîúüùÏÈÈÉÆÄÄÆÆÂÆÉÌÍΟÈÉÌÕÜàæéìïìãðððïðößÕÖÚÛàåÖìñòôõôõõööööõóñîííìöóÔÊÍÌŒª ™™‡ƒvr€||v}pŠ‚‹Œ{`ZYKMjËÈÇ®EfpNWUJWROL@C,:2:@.,9;6360CD:9.<%$ +*%-4,9>3;98QFž«¥{D/3'@9>¬¬Ž¬¡™˜‘’‰ƒ|”¡²ŽÄœŸÇÎÐÔ·­ª²µ¿ÈÏÙàäâàßææÚÌ¿ÉÍÜÔ¿ÎÖíïóöòñêððîïóö÷õõòñçÝÏ­Š©®±Ž·ÏàêË¿áöþùôððïíòüþúÍÌËÉÈÇÀŸ¶Žµµ»¿ÃÃÁÁ¿¿ÂÀÄÄÅÊÍÑÔêïïïöÛÏÌÊÅŸÅËÓØÚáãéíîìòòòôóðòòöóôõõòïìéáÚÔÉÁ¹ÂÅÒÙÝÝãæ姟¡™Œ£®€Šš¶¹ÌÕس\įŠy¡ ˜”j€ƒkB:7;QQE:C9A>O66,27-.,")--#!4@F:AOAU­—ro:D<%$32ƒŸ˜ž£•u{}y}k}‰ ¡²ž»ÏÑÖ¿¶±µ¥°¶ÃÜäæäââãÛÏžÄÕÛÏ»ÊàÚïí÷÷ñòïòóóôõùùù÷öñíçÚʲžŸŸœŸ ÉÛåÈŒæöþøòñïðóïó÷òÚÓÐÈÁ¿œÅÁÂŒÄÅÂœºžŽŠ­§§ª®Ž¶ŸÀÂçòïíôÕÌÏÒÔÙÚ×ÚÚÖÔÓÐÏÉÈÉÊËÏÓ×ÛÚÝÝÞÞÞßßÝÞÛÙÒÍÇÂÆŸÈÌÍÅÎÕÕ¥ ¢žµÄ°®²°©Æâ³rÜÝÝ·ÐáßÜ ÂÏÊ¥KU««­®²µ¶¢xµµŸ  ?Ž’‡†ƒ}yu{¢vxdkzqvƒœWIUU_bB›ƒ|g{‡wZi’‰ ”‘«Ÿ•¬±«ÇØ×¹ÅčnCCLNU\Z_mrgu”™™€Ôèàïñùü÷õôôòôòöûù÷÷óðêæÝη€¢ €¥¬ËÙçÌÈïöýùóòòòòñåâïîéäÓÙÛÞäéññòòðîêêæãäãâÞÛ×ØÖÏÎêñíëñÕÎÏËÎÏÎÌËÉÆÃŒ·²­ŠŸŸ’–ž¯¶¹ÀÁÆÉÈÊÍÇËÌËÊÌÍÊÊÆÄÀµŠ¢˜ŸŸ¢Ÿžž£©­°³¶³Ÿ‘vmŒÀŸŸ“ÊÉƚ®žÀšD‡­¬®­±³š†°€Šš–¥C†—ž§§Š¥šš¥§ž”k¥mv”€Š¥€ž¡’zi]pmijx‡‘Ž‘¬‡¢©™ŠËÙÉŽÈÐÎx>:=@CEIMOPQPOPOPPV\óóùí¹¥‰ž­ŽÅÐÚíøüøõñëãÕŒ£œŠÁÚæÎÆîôþúôðïóòñíéóïíåÈßâèìñóøùú÷÷ööòáòðñððíòòî¿âíëéòæåààÛÜÝÜÞÝÞÝÝÛÛÛØÓÎÅ¿Ÿ»¿œŒÁœÃÄÅÁÁœž¬š¢¢ž‡ylmjnkis›ž¢žŸŠŠŒŒ”Œ—cfš©Š˜n¡¬šš—Š’>——”–‰zsŒ‘‰ˆ”•†Cw€€ˆ‰”“‹’“‰a“hˆy §¥ €œŸˆvgOvƒeb€„€‰”{uš‰x‚ˆ“q]wÃÑàÍMDGG<569:CGJNSRRUVVWYZ€ùúûÙeXUUUSSRSQQRRSTTTRKKIHHEM°ÅϵÃíòýøìäÝßàæíîðîæØŒèîóõøûüþþþûúø÷÷÷÷÷÷õø÷ôöÄàìçáîÝÒÝÙ××Ø֚××××ÓÎʏÉÆÇËÊËÊÊÇÃŒž³®«ªª§§š£Š£¥€¥§ªª«©›˜ ¥–Œ‘“Š„~ƒ†hQ}|uuMo^cT]SZ]CE][EOSLOILQJLVGO7gc_a[XVYUaVSahhngZSOLB81I?Yl\i}xwvZu“ +cš|z{€ƒŠ}ŽÙäÞF30.--.0258>EEIMOMNRRSSXnÄÍÖ¹\URQOONLLKKJJNPQQQRSUQQS[ÈâìËÈïôÿýöñìíè⿁jTQJL|Ž¢ŽÆáãæêñüüüþûùûüøúýø÷÷ÁáíçåïáÞÛÛÙØ×ÖÕÓÕÖÒÍÈÅ®ÃÃÅÈÇÇÇÄÀŒ·²¯­ª©§§Šš§§tŽ££¢¢¡ž —š˜¢žž€™šš¥ŠŠ¡‹iQ + +„}fnoP`k[iRKLhchajqphY^e`hUX3\uklicoh`H_bZa^aX_FA978:@8:BhaahŒoxrz‘ˆ€„zt‚™‘›ÚâÝTB@W97899:=@ABBACEEEGHKLRW[][QMKLKJIFHEFGHILNPPUSQPRRVŒ£¶¢¶áøÿþúöõôôõë}TIGGHHKKPTZ\]\^ch™€­¶²¯³µŒÆšâëéæïáâÞßÝÞÜÛÙÖÖÒÌÈÅ¿³¯·œŸÁÀŒ¹¹Ž°¬ª©©ªªŠŠªªª +¥££¢€£¡o—“” ŸžšŸ[€šaHgnaaXPRLUKRE>9?SU\Zcyuufga\mj_1Z_Z^^ku`Jczyx}}|yzz€z| +wPoviZqooR†{‰™¥šžwm‡ +šŽ˜ÜâÙŠ¢¥­ŒF66689662326=FNT\YUROPPKFCCCA@B>A@BCEGHILPTSQQOOOPQUXªîùþÒ}} +˜§µÃˆTFDECDEEGGJMNONQPMMOMNNNLMLNNQÛîêäîyYjz€‹”›£­ŽºŸÆÄÁŒ¿¿ÀŒŸ¿Ÿ»º¹³±«Š¡¢Ššš€¥¢¡Ÿ™›ž¡Ÿ¢¢š™j˜ž–¢ štœŸ—Š_GNSg]\D\MNWT`eEOc`SSPPKRVbfuusq0j}wƒ‰j[X`vz{z{xx~{~vpwvgd}€ƒ^obhix~”¬£~yc“ƒy‚ŽšwoÃ¹¯«Š–;9;?;77346?MPYDceb`\]\[WURRNPJEC@>?@@>=<=@@ADGIHJKKOYk€zlWSSQQQMHGB@@?ABACBFDFFGHHGFFEEEDEEGIMSÞîéåírGB>>9914332027:@FCADSkyˆ•œ¥¬®®ª©­®ªšªªª¥€Ÿ  ›™‘š— ”“jx‹‰Š“‹ƒ{f>_hbgfB\RN`O^aCNUbmwsttu{~|}„~ƒ1s~tmUagYvlz~onnwzxtvpxmOx€wU[PhojD‡”†wž”’Ž”™Ÿ«›mS˜µŠ¹³§¥¥l:9659756BACXjLYdba`_^_\YUWVUURPOOOPMB<>BDB???>:=;=@@DFHHEEFFEEDCBA=>=@>@@AACCDDEEBCBC@AAAEEEISâîèåîqH@==<<746766853224220.-,)'''*.30.124AOZr”€£€¢¡¡œ¡¡¢œ~9;GP^kfSFMF9ADGR_MaRcMeklBQ`snswzvuoƒc{}zz1q‚bb{qWwwvqnttrtmwwmxzGƒƒ€xSbhCi~fuœ’œª˜€––£œxQ¥Œµ­ž¯¬°«L;984;99OLC\oPFY[\\[\ZZWUVUUUTQQQQRO@-,-,-///4AEH@?@DDBC@>@A=?>@CCEISâîèçñmGB??==95655465123578885555542//--,#&" + -š§Ÿž™Ÿ™¢¢€›{9?HJHMQRV_a=ƒw^\YLaJS\sroEDkodƒŠŒuwyzsqr`1^UtzvQvzz|uy{z{{|{~}Oi€}€ +Kb~la}˜‰ˆŽšœ©£“ššˆi¥µºž»œ¯¶³šB><9=;>BCDMQbMMUTUUUUVUSQSRSQQSQRQRB0/11/0,16AEK;76:=AD:52.7;C?3/%&')/2334444778879:;;<>ABDGM{žŠ³^FB?=<<7456555531359:86545243211-.0-.'',-4©§šŠ¡¢u€£€˜l8=HJJKJJIJP7LT`]kTsXOss}yBLtukx}wvwwy|y_1e|lyPy~z€„€|ƒ‡†„ +eez‚x‚}jTq~”oxŠƒrŸœ¥¢ž š“gr§©¢ŸŸž­ºž¿t@ABA??AAEHJjWPQOOMNPVRSQQQQg¯¯¯QC90)&$"(-/2BFM;1(''$$#!!"3;D>.(+'58+16'.Ž35:8+))*-100/3458<=?AEEEBA@==<74866777533469975554532312321/,(--2©©­šŠ¡‘¥¡¥’B15?IQMQOMEO6HKOOLCXDhkpw|?czur}yx~tiqu}o[W2p~zUw†‘–Ž†††~ƒ‚ + +bkiVƒŠƒ„qikH^Z{ŸCQHwt—¥®¢¢£•Žwiv»»Å¹¯œŸŒ±L?<;7779;:=d]>954232223:?DGs÷óíÒR2)(#"" + + +%ABK;)&$'?LKHGE;9C=-'1+25 + + +-0:A:$"!%*)#!$&*6?;;8742,---,,*//13444476899866744544334220,(/.-AHR]jt}¥¢“\,1;CISQTSQV9KJJMMLOCfZKMQ;`oij|€vy‡ŒbtnY\c0vuOs|‚€uy +‡Œ† +‡ˆ +„S‚wimr +†ZUW€~kNRt{|ŒŸªšœ ›‡ƒzk‹›Š²·«ˆœ¡v224-0-..17;QD42111.1.+,).1O¯œ³š}NC:7:?<93--;9E9NKHB84/,'!6:D>-$ +/;D>$# + + + ".023INJIJIFCB<83..++()%')((+000202765575555522.,1./.(,-,.:¡Š¡”`,3AJKMNQNIV=PPRPOPEEG^KIL=HEZ6COTZs‹rVfx\C4hM\xyvs€{{zvgr‚‡}i\lv†ˆ +††ƒsmmR¥ZjYS|‡~¡£Ÿ§•‡v]`‚‚“‘rrz}Œ˜V/-.-/--/4:<7111-.291++--5;@_abb\YRC@LYYTSQOMJU‚jtR1(%#$ +34?=)"&**-/1366;0=D=$$8;<=<743110.FHKOHKIQJHE9A>><;;9874214/.*,*)(&))*++/0-.+).--.)&./.7€ž¢•^ %/4>DMMHMSAOIHNMQ@>FP]OF4HBU0EBECDF@NVU_G4Q`yzoy{zwzˆˆvnpfpsM‹†‚|{u}paŠrš€yTjXep‹‚”›–†sfg{y‚‘ +k`ev’ƒw1+,,.),0622<311-.2=8+/0-0+-G^`a]YXMMV`aa\\[[Y]†‹WC@?<7?<<;/,9>=??>@?>=1;D=$&>AAD?=<<5422MTQTSPQPOMHCDACCCBAAAA?=<6<;:76432//$ +! + +!"#! ##"$'&1¥ £”o&-34:4:<??>4.'" +JHRTGJJPNSJHEBEDECDBABA@A=BCABAAA@>=& + + + –¢£“x22069IKOKLO;BAC:[H>JHP.CBC;6CA>ABBH0$17BLYKRdpwxtxtYuutw{~isy‚¡žk¯æçæ³<&!!NSRTTRPOPMJLMFEDDIEDCCABCDBBACBDBAA3‡Ÿ¡’yC;699;DGNGP?GLG>=E<>BGEAT>K=P)>E87IB>@>AKdgqmY„{rwl{z +€tž¢•Œˆlczˆ„Csc{sn‡“Ÿ£™ƒqrilrpsWH?EGDHJ)',))(++.23/--,-,-&')%+,)&$+27:88=HT]``]]\[YXVUQNRPPNRQQQQQOQSQQRRRRUQQOMMMI‘Ëп¬l840)1;GGHJIKIHIJGGCGKLGGMCEECCDEDEDCDDBC7 + ¢z$+6:9>;BB=IIDLORID>5==>?K?MKP1?54;B??@BA?C3720g_@B^ -;Q@AB5GRYpx€‡‚€‰ +¯sw™‚~Œ~Ul\~skssr‹™“zŽ†‰|ned^`][bgU((,,)-36100.'(+)$"&%(((('&)'(#  +"$+07?ELQTTSOPNMLQOQPQOMORRQSRRUTSRPPQRPQWWVROLHC64@?DCDDEFC>569:=@FLOJKDFCBCDEEDEDEEA>JNcYMPPRTSRRRTUUTTQQQQRTUTUSQPNLEBOQSQSRQMKA +"26@HR>9" + + +$22‡€¥|6 +  + :9BEJ?IK?FCDII:<,5;:9#(146M;626OFJ:DDBB@BDHCKJ@?£–®£†•†Š•‡Lbgsrpdk€†ˆs[f~†ˆ|yzwnt‚ +‡7-,,)+23/.5))&()&&'')&*))'&# +! + + +##'&%#%.,-4<@JOU]\[XWWTSTQQQTUTUTPQQNJHQQRQSUUTRzk‰u{vgG6+#1BB+$*/B:"!E;1,52A"1-21+2$*-2:,‡€€x6 + + + +0#'5)1D=KGHFA@B8HG:L>=;8<=70>=99(&'/*KPZNIA<8@GDAB>CDGLD>?<”ž§¡ž„„†˜uo”}`‚^s†vbji}‡‰‡‡~dZgu{ +p,()/--'/.),++&'(),'')(#%" + + + + + + + + +$)($%$# + +4 * +(@N^tPhkda\XUWUUTQRPNLNSSSQTUUSyšŸ•¥µš«º¶’ti‹—rK1&B=%:Q;.93>>$?1( +!%(.1(47‡€€‘|7 + + + +0&( + + +<9*2?CE6>G8XA89=59976<:=**$)08@21)J118?KDA@BFBHD;CAB +Œ£ +|q|ƒ +lwwˆ|ˆzˆˆŸ +vj]iy•ˆ‘†~rflq‚sv}?--*01/,.)&&'$')+)& $ $)' # + +" + +" +""# + '-&$2=†WZsœ»°™|T`bXXRLPIJQUUSSUUe¬·³’ˆ–‚„²º™Ž{~ŒŽ¡^ƒŸzV]>Q>;;.3M62C-.!.;?43$#†¥£‘~: + + +0"84& +"77">.+0;AHG9545>B5..<8?'$*.2-4$C594>=9>4@@9HD?"AE63?86!*926H/!'5DI..J5*58=CIG;6:9046>EDxd^}z~bXshuz”œ‡†„“‡hdt•†gpˆ‘‹—™Š­Žœ‹\6-.412-1+)1.('(/'( #%  + + + + + + + + "# + +!.0J?HTt³kcX_WPC0U@;XZVŠ€˜~nxnZujž§§‡ª¯¥€Šªžš§œ¢¯¢§Ž„KM[XROZ1;5T;;80-'&-086 +$"†ŠŠŽbM& + +4-(301//J=14%./,=3.$9: +@ +"*//>4+T.$.)(85Q4,.79?79C5234/17ˆ¥¥ˆC_J +( +13:CCW*$5 +H + + +*/,.(Q.+$&/4A7+27:B637KE569:62;@B€‡ +~Šƒhup„j€my†Œvoj’‘}Zdl€q¡³žœšŽžŒËº·¶®Ž265,+234))($'$"#" + + + + +   + + + + + +!!!#)(/992?KBŒ·sIwewKKTVLI\†sƒž¢_QPqžª±¬¯Ÿ› +bbbv{hso”‘Ÿlk›MSiNQC7KJbM=A8?18@@--43>IŠŠ‹]_W. + +83DSEG=@8=1=;55L25G#$$ +",0,"R3+96O(3@36B45=A5642456=?=‘sqy +wy|‡hšž–œŠrv_cpsWf[iodeŽµÆùžºÂÁŸŒŸ·Žc8:541.)$&&,.$$! + + + + + + +"&$%&### + + + + +!#" + + +$#,/).3=1G?8w¡Ž”NGnq”„n`VVv„­“‘peM†‘§€¿¥Ëp[sct|praƒŸvZl`bfKM8@;;BMTTO>3<<@;27.*6H>!)0JJD8*SA330&A<2&++6@5;qyrš‘•“{§ªXhŸ‚cXJ[RVX\Tas +œ¬¹ÁÃœÀÀŸŒÁ¿žŽ¥N<74.+&"#$#"#!! +#'&$""&'+(('2+ + + +42-$* +&/'&2,1'+/).3Aƒv~Œ˜Xbw¬l6?vqf‹~„dt§±¹ÂÐÿ‡‡®nw\gxls†Ÿš˜ksjo[]THGB>JGGDLTTMFCPKF>JFŽ¥Š’~AB5 + + + +=<.O12G4F8B5GD7MVe`chO7:L@dR=\CEW4{M1/V4F2L0,,)01/4177owzŽš€­­•˜‡•–’jwx”~fXJ,DVvŒV‡Š¯¶œŒÁŸÂÃÔØÀº³@;6/)"##$&''()+*(+.,*$++'&$),,(#'## + + + + +04-&0&(!(+!)#/*;-ANrb +UT|ŠiR7G.@FB@J;@4V`G@aVI;CHS5GYb_5y‚v|sH&iD#79/734168£ }{–šŠŠ™‚yyw|s\‰q|fc/==NZŠƒbzš«¹ÁŸÁÈÛÊÝßÈÃÂG762...-..+../-287;@0''(,*&('(()%%,&,+#  +$ + +#%"!) +1/%9;/)(4Yy’„zp¡  O==m‹† +•ÁÐœ¿Ìœ¹¹¬t|‚Œ“Ž›€ªªž™Ž +~somhXnpmf]Y^VV]cb]]gghdq˜¥§›nU: +5CJ:PB&0[D?<6:N>JPX{l_ufG6aVl^Q;5DM+@<'%$),+((&'*())(*.($&&&+& + #'4- 030*#& +$)(&2.59a}™°«qjš®q<J:PMLA+GHHN2JMrdecRCp‹˜ŠshY8;4^5=XF2FdG<==OSeWXJ[=):5(1}dXU`UNW‹–”š„d` +””™miVhIKZwm}‚“œ¯¹ÂÄÎÙÖÚãëéëðòÊtÖ³[>99865767:56.,,&$##&,(&&$!$%%" ! +%.$ !"/;.17.3+*,4/;0&+/462,6YZ37QUoUkpGP^][LobMOmX|l9LVRMCA`xV<=Q",0FBUV^U631O\†z_uogplvjŠw‰‚|‰mfq|ucšŸ¥¯³Ÿ¿ÈÙßèéååâßÞÝÝÜÚØÝáÅ[PJC@=85442/,-.&&'($$'($#%$#%$'%#!''+211(/.&<889;>::869?@;44:?DM}s_NUTNHFLJIAPo³’p‰ŒŠ‰‘‰ˆ~ +‚œ¡€­ªŠ¢•œ€šŸ™š—ž§‚‡‰•ƒwcU[XVe\UdcYN?6DLMTQ[TNRbbLtT2PgƒP4lagj‡ˆckALTl^5?PeZGBrzylU=FVS5%+) *8Zb:0BW4QQsh€’n„l`mdk–Žuykqš‡zwu’–¯·ÈÆËÑÕÅÚÜÜÜÜ××ÕÖÏÓÖÓËÌÏØÝ [PKF<553/.,+!(($$%"" +"" +$# +%$$'(**'+,)+*,0-1,:588#.-04:<:BTKUN;<=H?KJJTZVZeinxƒ”™’”‰„ +™ŠŽ·³©³Š +œžŠ|aaljgjkxt•­¢™ƒ‚—ŽlypiUVLKOAPRCJJMI]X\eQi^n\NZ4^lmO+P]C>`}U_^YaTLoGIE@Wl]U +ƒmc`P<5DNPA/7P†qZG(j?@Hy——qmnm—t^nwuhgrtp†qsfr{˜¬ËÇËÌÓÌÚÚÓÌÆÁœœÂœÂÊÈÆÈÕÝåè–WI=63-*.0(% +%%! +! +$ + +#!"%# +" +"$&$ +$&+&(-!6+'()-09ANQHSPRPYaaXI[`abaZehikpqqmfW\aZZOW_cih|”¡ž˜ƒ¢’† +xŽ‰‡‡tkc[``[imcu€~drk[X>C;?EIXOJSSUCE\hIii\i^SupmqsPVb‘‚cdssdd:tXLQeŠ Ž„‡€¹­­°ºœÓÓÌÆ¿»¹·±µŸ¿ŸŸÇÐÛãäàyOI;19<=//'! + +!$'" +"##+$& +! +&.) +!!'+! !!'6>DJMM\]^[ffkih]VhUZ_bL3W^XLINMFDLSSKE?QVQLTMLONQU`bi +Š™nTQhvrngcfwdƒU^]dPa[RIFCGNUJR\engcPMdZFqbXQVY=J_WB7*/QKRME\cn5`N=+me[L>PmMBfREb[lSbJ2G[O7`D]zp`HMlQ_HLNP|RV^D8965;C9[Uahk]2&oti[VMJ?@B?CJD8CLT^T@JLMFGGJKGPJFIGLB;FOJFYOITWpiwlVOu›•sneZPMF86LIQVRU[mjpHZ|aK^gdMPUD?0N;-5>4O4AjG6_mlCF&d^mbUp`LH5J&ZSF\XjJaufKhaqwM1?Z[VppŸšÆ‚£Ÿ– +†ƒƒˆŠ|•¢š°ŒÊ·£Æ¿ÆÔÁÃŽ¶¬ª·ÁÇÐÔ£[Zc“z=**3(2'2/0-2'""" +! +# + + + +#//.05B;MFISKV\Y5?Z_SQ[TJE=>AE>C=@HB>?@72LTOIHK87646998=>=D@<<:=QKDMTe`TX@1 +!3IM53YKK9W(d_pS8RDU0!#+*!?=/!.%//297?DE><30441QBC52-)-.%('-%%'*%%',-.22653,.,.,(.95)8:8;?;A;C=9OO?99IL^HNA;2C7[WhE=?*>;/C$' +%5OZBJVK+ +5I=:95=T, +QE{lGXRb921:itVca†•€¬¢œ—¥§¡ Ÿ«« ©³£«—¢” +Š™€§š®°¶ÀÌÌÐÌÍÎÎÕÓÔÔÚÉŒ‡X8Jb_QU<15').*'23/??.:=;"#! + " +%& +%""+(&'#&0'$.%#2*0+0/B;8479589;65H;HM@2:=:QJ/AEJB>@)59<5;r“6&0 +KC>2KD3G/'<7=*2*)F/@ULJa7X3O6X\AZ6B=.2->;C30(:8<:7%;L + "EHCK22W^IUWK^?N_cfSO_v€“™™Ÿ`Wn’Š‡Šk€¢˜‰Ž™y†˜Ÿ²œ®±»ÂÊÛèÞÊÌÕÒÖÛÜßâÜݝx?%Dr²·X),$$/' +" + + +.+1(--06/9)-,,9H=59( + !(% + + + +%$" + &$$ #!"&1'( %((0,7.,2921>?905,EB962/%,..2MOG66./FNC.=9:Y+#",/7PN:MCN]\^ZS”}~Ž’o]`kay~‡„x~t†‰yny€{s’™|vŒ‹š•xŽ ¹ ÊÇÇÖ×àåÍÖÐÏàåàÛÖÛçÓÆI)-V™±ˆ7PšˆW3.# %""$(,,8+*(&2/%(.?M7@0$,'# +"#" +$"! !" + + + +(7##&"",)'",,6,*.61:7582B@85!+$8-.$D.+:5:?2r•‰B.;MHJP &1:C5%#-#FO7.D,%N$&"'&" + +!"" &!())! + + + +(# + + & *$ $-'($**%/1215/A>2* + +38&6B8BEIS?i{uX:53?ESLRY6(&@?%3F=B27-CJHV;]OMJIIB;/KagaEBFGFPb6477?6:3(887X\363#8E;SXl\A599H# +AB85J +B +%EMJBA-85!@PzeisdZPYgzjoy]un‰kgd`ibb|x„rSrly€|{pwˆŠŒ Ž·¡·ØÃÕÃÊÎÔÝÖ×Âɹ¹¡¡«°ŽvZ=56@Gdª·ž igozŒž§¯žÈʓa35<80M>-"#%#&# !#!!$# ! %%$#!"(!&"!#%$ +#+"$" + +(2! +!!)! %%#""*2)$-,59BDLKLHXPVSLA10@dA[$#1-++ERID!6 <->C\U)?3%/kGu~se^VUXgec_h}|hsqX\kV]\ZYeu}tsquhv{y‡ +}‚ŠŒ™°žÆÓÿÅÊÊÃØ͹µ¬Šš—”† +oP3..=MŽ°ÂŒž±±£š“ +}~~‰Ÿ±¹œ·²d605,#93*('%"$'&""$"" + +!$ +",&&" +**()&"4  + + +! +"" + +! +#% + +#! +&5>TI87:FH4B]M]D722E:E<\e=B@2CN?- + +$XKBNeL__6P`i[zp`eUROEo`\_c}o]r| +„qgukXlf\i\ot~‚‹nz„s„‡‰©·ÃÏÕŸ€¥³²ª³»š¢¡Žš’•—›wZ>78?i”š£š  Š£¥¬¥˜™›Ÿ–Š•¬»«ª—’WHg„€7222-*.4)##"# + %$& $&%0')(("$!/ +# + +!@cƒƒ‰vL73).ERXdfII:=D^L<@<[bg@P^[ZSL0 !,?HPD>E638=AVn“·ÍØÏÀË¿®«¯“l]cjxš™š›œ¢«²ºµ³·®§œŽm`MB1.(,*',&5 +&&-(%%!$(+" +!$9Ja{’•–Œ‰ˆ +„‡ +}nC*&QWTkWZpY^oNNcm_PdK__8Pa\RkIE7:^,bJSozzAFdJJgM=GFL>86J@C1G:9- + 8?R:gI%HJ*JšE\ah`_XtUYhpyyy~„rq€wbllf_jxus„}|ruxrrfikwŠ•–—ƒxtpxjz‰•—¥¢–“”•†zxx~•š  ˆg<58AGS˜³ÄÌÎȹ™‚Ÿ¯¶žžŸz©—’Œ——¡ ŸŠ¥€š„r}hbUL12)%7)*%1" + +" +;=HVKTbnzny†ƒŠŽz~„‚vkjdKD:;Hl]JfnYQOUP]NaTcMOlG`cgsh +XBca6G9MO]T'0QO60>5IBRDC[O[CX:F=4 +,CMOmcTmF[LJFŠD9%c``HINJCD[qx||}ƒ€„bbb[cvu‚ +rrfifQXhgc`_gn{{}wv\`[bplsˆŽ‡Ž™•”—›¡€¥ –„^<;89MGI>YSrTRQLJRO^GN71[iZOE)PbWPO;'CNOW;KHRI^Za;GlFBTmTbJY_JjDS&[4H9<7I]DV627TGU_dYGTECD\xgS59Die_I@UeP6R<-%BEEJdIQfpefU",Dfvj‹w†}kjVHREg]T37K]cYY\wdYXQZdpqrx~ytq•“™˜Š„ +Ž•ˆoaNHPNIZip™§–˜ššŽujgmnt{’˜šœ›£––™Š~{oTHA37+00lpe^|1+q|`KYiwdkI2Uq>'.BAQ`€TAHy|sqjP- ++&AXDSlL +,897@EGN[YLpflvƒŠ~xvvdnvwxklƒˆsfG=@KFRZdp|‹Œš¬žŠujiluz“œ™ˆnm{„‡}w^PYYZTUTY\[`feegd`]Yacd`_aejvnkdcOXTNJTdv +€‚ +ˆ‹””–u„Š +yUMRYga{†l,YOkpŠsh>bEoh5USh\wxT\LAKKeSSB@RYK$DtkA=.K=EXFNNixF`ibVfWpiogbV-lh-g3*XUES68/6ZBI3,BFP1$<7>`r]F]i\["1ID7%"khW.)&%* +,9CIT]_Znolqqq`YW[W[X[mx{mdixf_]bdu˜žš«²ž¬Šž‘ƒxqs‚Œ˜š Ÿ”ŠqimyxtkjgdeicZZWbb^[PWkOOH=?WPKDU2LVC^HH_V*>M>I093-G+$EH: +$Ei?kLVŠvp]ieqoTtvJ:3]QI8C.?5F^R;8/%DRUABNdtpDe^ecTKhaoƒymDDE"(9.3*%+ + +.KGSbojWW@M3?FCNsfUanmbJ;3nLE@hh:0T<,#8BaS0Z^N(`lVzT@>>]|zX?/4. +1\WL6P@WGMˆa^x{’P=hGYjdO„MBK?Ykƒ‡•Ž•ˆW_6.OL];#<)4XY*:ZW\hmyyk`_c^XYWRTTVRU^WQQMLJLLKIMLOPSU]Y[j_oaZQKRD?B@FEDHNKQe|„‡™ £¢›’‰{umkjpjfhi_TSPW[\^[^\ZV[]`_ei\NCEUVXw„vnelqqnrqp|~jcjlm€‡~{fXZlytT:@WEE:t[}w\]W[VD.GZ1JLtA,`TF77E[p|iTL5&IaShOCJ^p]sl_H1214:;1OkP0) +2Ml ;HPTp^hqv€ˆ†ˆ{vljjd``\]WXTVOLJJFCADBJWRY\YaZXY_ZXUUJJGB>5@DCHEDGDKZk|†ŒŒˆ{roj_^\Zedbdmmgfjnwsllmkgfdd^WSLA::@CLJ:Y[stb\\r|yo{ƒ‰Šˆ{opq_dt~}x}zxgYPPO2CbZNdkDAWh[VRoSV!0IE6@JLDQ6\iYXX\C*.+LO12\[ +?nyhUITNrUPS\ebRM=A@4TS(,W\iT]`MIRUQltdLNZSHQiuyy}V.., "g>-NPZOHMbnty{y€~oiga^_[WUSSNLIIJFLXS^ZXNZQSRWKGRPCBCCGIJGICEGIEEKMP\iottnkjjcZXZZ[[WWV[``][ZWTZ_gkhjjggb[]Z]Y[WSYNHTRblgd]rwgS`u +kaUYqrvqj +{zwql2203),,/?=PT@bjQABDZ=GC8=>KF:[JB_RFM[W/"Nm6.CdF=_RAFULA[Jq-;]H2MOZa:R +U-X@GHIM?J_eLcjVZdocZm\egiaXSSINJHEcT`ogW[aZdjhmqnmljhigh^YY[\[ZUSX]_[`wj\u`QQYVOBMDA@AEDHDFGPNSNHDFGBDFIKKSZcc`ac_WX^gicZSS^ebZWWXRT^\TPLJV\]^bjfaaeb`_LbgmcpocYsi\Ydqtn`Zbqhz‰–~{Œn^SFC30 +<.#&POR\bLK<_YV\UBCDQJ-ZR3"LF>`J-CagcTF=,:[a*3Ohc58I) HA#B:5cMWq7<-F.K]DDLIN15>d`hhcd`lu|rknka`jrvu‚€yxjfqpnolsonnjsnp|ƒ‹ƒpqwxpfqvuvtqwvrvqdTFEFEIKHACACEDBBOYQOIJLHJOPROIQUaife`XSRUVafb_a\RRVTLKGIIIIFCDJNPSNTUOWWXdijYl[s]Zgl^eTVWTap~‰†zn\bemoj€{`PPIZ=029@_[?H>2ZHJ^gpCE=C4Z:!8F@Z@2\UlU4WQ:?,Qb+9A?dRQNSLBM46YMZTSYF/=>BFWfD

)*3 <7^2$.BAA\WCfYfE47RH7N5%HC8"AtiZ454ED&-LICVQM?D[O_H6;'5OZgFKQQMWbWR/99K1 +-(u‹„‡xtƒŠ‹ŠŠ††š£’˜™—“‹•“Œ‰Š„ +‚y|uw{{w|}ƒ†ˆ€‡‰‰Š„„‰„xjcu‰„mmdSOQQS^aZbiebZ_\Y]YTWWSNRPPPRXhuxupkpldYQLNNTc\SYZ\[djZTW\XWZV\a_a_YQG?>@ES[OT]RYT\lw~|psaY^nnlj{thT^\wmjY:**%2,148PP<##O8F-!!K_H4G@N>Z5WPQGiS,2IJ3P&(/]CEVMOKI2K,$ +20@_&DIQVUQD65-9M3ejww€ƒ††ŒŠ‘•š¥ª«­®¯šª¢ š•‡~‚Šˆ†ƒ‡‹ŒŽŒ„„‚pƒ‡‹Œ‘‘˜˜‘x€{c^decc`egfZ\YW\Y[^VOKPVYTW]ZWQTPRQPVis}ytxog[UZXUWge]`hjknqjdei^XibPIABHTXVQMUVNgHIKOYNMamvsm^QY_ahntldQAZ[hWI3TEJA% +HRI@B +3fY>60+:4@aPB]_=SX8Gwn_A=Wi`Ybw&ImHET?R>VVy~mW*/3F\Q8Y;3E*Ap<[SIOc +KGHA +FB9 + -+Imhei +N8xD,4,1Y^Y_8)ED;C.93MH7# +"'9E10(TC +2%2,:V+Ydv\4j:'3@B^l?;M1>/6&"71R97E:-BNFAH7u{LC.2CGSqb\jejT;SDAIA;+OEL@55:Uln%FWC;G5 1OPH8jt¢§™™œ”–š›£€£œŠ‰—ž€§§€¡¡Ž«¬Š™‘‡‚ƒ‹™•Ž ˜Š©¬ž„¢š¢™—˜–y‰“•˜”ŒŽ†‚qqtusswƒ„||zsknv{yf^cggfa]ZW^]Zbe^[YUOMR\[W^^cX]_cgpbTMOVQPRQLU[ZY[_QQRQWTRSZb`WEDNCLKTQYNWXfp}usX2"%PgL+TlWZ68IgcFG$ +45*&90=B=VC\Pe2^wP:)5[LmtpYELX]@LD]qH=S+Rf" +Q(g€sk=0EJX\Saaj\<\(UX«« € Ÿ£¢žžšš£ œŸŸ¥€§šª€²Ÿ€š£––ˆ‹Ÿ–|”œ«­£„š¥Ÿš—™–ƒ– £€ž›”’Ž‡‡„{€vhbaomddjggeYVa_[V]cifgYSSUW`eag`XVUMPQY]_^]][[`a`b`bcia][[__`[[_bdY[bbbdafnha]Jb[c\WaUPZarvwzg<9,)P9?T@BB2GDK. +9$4UH(+D=@8DK;gRfSWTmhTS(Db^PXL;N'&QUTnzoMMoihkR -piIGlCNO`\\V_bLQI.Nb·€—“Žš‰”›£©§¡¢¢™‘ ¬š¡Ÿ©ž¥‘‘”‡‹ +‰ +€ +Šššš¡‘€§”ˆ‹‹„—§§¡œ•—’‘Œ‰„yugdhonnlqulormlljbcehnonjgUU][RNQQPPTVZ[a__ahieYSPRXPPT[^^WSNSW[XX[`]WSWVMPJLSYXFUSekYfTZ``pr€oAA?503X7LIFJJYS93/A=J/,Y:B[P9]@FDdTDFb9rZdPSg\AZL#4D&K2GKw7$4V‡YU; +$blrcb?[^kk_TUDSeKU8&BVŠˆ‡{ˆ•Ÿ œœ€š¯®–›Š­©¥ š›™Žsfksjdlv€™€§š—ž¥¡ž”“†˜›ž™—“—•ŽŒŽ“‘Š}ywto{†{v{†|xjdfd][_itwujcXVLORRRUXVW]YXYZ\_dgdYW[^XTZ\UVUSQJKQUXUZUOVZQOMLRTRbZLPALCMb[_abklgF=C>4;9USITP=CSY;.&:3jNOa€sp9Dc5LO^75aw_bTjjMJ_?LA#:P5-=\K{e9 +(dnTB4Gk]aZjO4QH>0Bl«“™Œu{ƒˆ–£Ÿ¥¯²¬˜Ž²²±²¬€£œŽ~o]a`^rnrˆ’Œ–Ÿ™¢£œ™š–œ ¡€›Ÿ›“‰‡“‰–’•’Š‡„| + +{tu}€„}j^acb`Y_nxwiYQUSUYZVZ`_[Z_c_Y]bbb_dded^W]`[XTRXY[]XRKRSVX^][YXa`_[[OOPX\OE\WHNGigUIIB,?"KFTNSKapjQ=4R$aUaZKSTW6Z10EOLVkTO`olC.AB:,MF6SLNT9>xkeDDZ]^SWk_fSZ]sO,@a`JIOU>I[R+Nk€Ÿ‘‡|“™šž¥§š¡§²²¿¿Â°° žŠŠ„]`bjnhmdnuvƒ™Ž”–——–‘ŠŸŸšŠ‹}ƒŒ”‘•‘‰‡†‰ˆ‡†v|ˆŽ +|€ƒƒ†Š +vuojabh^XU[_^\dcbnrxrilfhb_VTOVXYW\]ZXT^TMIRVPHQIFQeSPKLNHMGELPLPROJUe_0F$BF:L:VMPdLTO$@[ˆ†Ž€€ ”›šš£Š³Ÿ¿ÀÁÌÄÀ¯™‘š¢– +‘‹zgXco~y“€Š‰Š”‹–¥©Ž’‡‰ˆy|wx†ˆ–‘—–˜––”{~Ž˜–”™–Ž•’‡ˆ‡‰‘Œ††‚uhgbdkomnpvpssplnkr{||uqlgbe^XV_`\ce^YR[\\RWVV]Y\X[WX[PUSV\PEO^ZKKZYVI:N=HTHGGE@Da^ZpiVM[d|NnuN]6 + +)(^O]ACgnwp^WC3’c4HX?G3AKUHJKi^>XRGM+4vP6HhlO.<& +Bf|meKaYtaR77:SQGSejb*\,BC>x‰le=RhiJM +aijK6a\LkaSS:;K86OJ`}šŠªµ·²³¶”˜™™¢žŒÃÔÙÐËÏÉ®··±ªŠ£§šž•ƒ~–”}y‚“—ˆŸ–Š†| +skm]]^o|ƒ†}~ƒŽŠŽŽ‚Œ–›Ÿ›’›£¡˜’‘‰„Š“‘†‰|pow|sqoorqqqsw“ŽmdjgWV][RY`ZY[\\ZSRWXe`^btsifhhh`gomZBEUbEDZL`FG>B:DYEA?TYHEZ2/>_J(NP + ++%W?LZeWƒyWN-& +W@4BIIM#S&6`aymqY;`OrlSBfarhs_frlqN9Z]A:?CIkrz§«µ·¿µº¶ª«°¡€žŒËÓÑËÔǺ¯ÃÞª¥«¬®šŸ‘£œ‰vž¡œ‹•˜š„ymlYTP>O`{Š~€xutw|†’ŒŠ‘Œ‹Š“›š‘‘”š–•Š‹ƒ}„ˆŒ‹€q“™‚nf~mnhehf_]ixvx‰ƒiqrupdlqcfWbimooc\VU\bfXLHPUV\lsbKEMHG@SHFKPQUT@HNLPR670DZA<.FAD:#RUX\,8D!PE`sgjdz[RFA(7AM#@;"gq^bT>>]\g]vZ[nsx`d[kM?hTriX`hdqfœ¯¶¹ž»¿µ°«ž±œËÎÐÌÔÎĵÁÇǶ§¡«©°š€¥‚“§šœŒ•‘—‚skZPBD?H]~„|yuoorp‚‹„’’Ž•‘–„ˆŒ–—œ“‰|‚‚ˆˆ–Š}mhlmfehaVZsˆ†‡‰liy‚‚vmƒ†viW]^^ffl[Xhq[/"#&(,49FB$,:::K?NNJHLXOVP‡€˜A&7-E_6+0''4~cCF +.FLMLQ+GL_BTk,hZMTO +IQt_R7GAR:GvW1@+QBpVOJIWv +RWjULH6QikpihLS]IUªŽº¹žŽ¹µ®ª±°ÈÑÌÒÖÑÙØźÉÊÇÿ·žŽ­šŠ« +“¥ª•””‹ˆ—‹qfXPGOTO]„ˆujoiimvz††}~z†‡€„††ŒŒƒ‚y–™–|zƒy–’‰†›”•ˆossvvoimn‡‘Ž‡‡‰—›”‡‚€yl\^f\TPVU_feZM7-6A<$%)'7GKQU[^ZIBGBOVYDcšª—-$4=\4)' +NL!1,'"-;-BW77ATcoDG]mM:6GZYVyVVNQ-mo[RVJ}YHgN_KNT[X9a\IIWHcWI[[+CE;U.WOÀÀÁÄÂÂÀ±§·œÎÊÇÄÇËÕγÆÆÆÄÅÁ¿¹š°¯ªœ–£¯°—‡¡¡¢Ÿ§˜‚tƒ†ihtidt +xy{}|pkogduyupocTPZzƒs]h{su‚w€†„ŠŒ–Š„|–‚sj‚yrjpuspƒ—ˆŒ†~Šˆ‹ +| +„qqhkeopuuuneTZ\_ZPUT`\^]UVVVZdxxjURWX[IXŽ¢†C'>A +?B. +$!"(687?VZ4BB1;?V;*LI7KIO;B.tkG_E/37Lao_g^\nE>KHR^PQUM3UW3V]l^XmhÁÃÍÖÙÑĵ¬ÂÌËÅÆÊÆÏÑÆÁžÇÄÃÄÇËÊ»¶¶³Šš¡¯»Ž‹¥§¥ ¥£šˆ}•“igurnrx€ +ƒƒqm]S]ptsol\RUTZb^X`okiqz~ˆ†‚ŠŒŒ‹ˆ‚}phvyvg^LZlŽ‘–Žw”ƒ|ƒŽyfp€ƒ~€~mX]\SXa_ZUOP\W[VaqrjjcT3N\ogŒ\HƒžƒGAQE/CP +& + +" + + #$- +),RG$?WWS150%R"!1,B5'RtIKI>RVAitcn€}e*8YYf?CUgG!6IVjPV]dJ`ÂÊÍÔÛÚÄ°žËÏÈÎÈÃËÑÈÄŸÂËÉÆÊÊÉÅŽ¯³«¡œ°¹¹•Š¢¡Š€€œŽ™—Žˆzqy„ +ykpt€wfOLR[dpoi[W[`a\bd`aad`is}wp€} +ŒŠ +—Œƒoy“xgRDPu„™•†p}€‡vcarzxnlrpiovxymimlgglaYYdmw‘vvbBe +„€diyh—š•xM[gRVBG!:R$$ +$""&#7R6;&(@;UdaV?8Q]B2O;S]IGMF\ZYt}tygH3SabSNTaTgS9?WSKS2?YLU\Q@UV>BDBaÏÑÏÍÖÛÚÛáãáÛÕÕÕÓÐÎȹËËÌÊ¿¬£€¥§©Š°žž²–{”’š–™¡Ÿ¥§“xxqlxƒsd\`cXYWPYY\ee]X]\d`d[PRXVhqtWWp|r|uˆ–—‡|Š‚‚fI^j|ˆŒŠ‡wkpPQV\UPPYW]Yei`msqzwoQbemwUW[_^a{lWFc}„a7@IXlr[COegC1?Q8H&;@N'/6'# &)'-OB( +B 6)5?@=9%176DvqYQ*8D.QGX0AEhXƒviU6>ZB"3=#6JJ;HWPbgXi?7TRÍÆÆËÕÚÛàßàãàÚÚØÓÐÉŽ±ÈÊʱ›ª®·ž²·¹Žžx€ +ŽŒŠ””žŸ¡¥Šž‚ˆˆ‹ +tlmmmeY^dVV`nqi_[bcbqofPSWYbwt^fw|s„‹‡p}‘ˆx‰•‹‘^brwv +‡‰†zƒˆzdUHJRYubckuomxt€w_MYibSSN?LVmfgT?8602- +$' !HE "2*!/2184B6 +2;&/1l=OOZ9R'] +CTV_m=^3HL"9 +0 +ESI>Jg^geV]RS\8¿ŸÅÍÓØÛáãâÞÝÛÝÝÙÝÙÁÑÛØÖÐÁ»ŸÄÁŸ¹¹·¶²Ÿ›uv~‹‘”¡¢£€£ŒŠ“•“yndjngeS[PZnrro]Vfkmytqhff]`leYnxuu‹ujv‚ +so—›™Žotxuvy€†‚WKK`{soxwswy +{‡fIO^uTKKBGURl[dRIV7.)BdsrSRV[Wjmfe[OMI +O>! +! + ++ @L&$1)!',/:6:5 +5A1/CSrN2Q/)fRS0&2nlk[HP=3"-  +."!2C +(8*+%+101?= ++:*$+)A@[k@}4/U55JIAP;.]`B7 +?RUBB JFHV)8D_JTZQŸœŸÁÅÊÒØÛÛÚÕÜÝßÝØÂÕÕÒÎÈÁœŸŸÂÂÄ¿œÀÃÁ¹€­ÅÆÈÅÄÄŒ§¡™§¯®€ ¡§•u|}ni}Ž€n^upwndffainnh]Vgphm‹—„„¡œˆcr‡euŸœš–‘†€}ƒ„‹gDCHBC>Go_iaYcYa\\aa_WNU; + +0- +! +H + + +%..*)(/683, +->0($(<0FMv`09VB42;63@2?EEQhW;1EIQ*-5hTW=K1IAaE7/P206&4@>5C9:89DS[YQ5BQI^cUF\XWHA1vjX¯®±¶ŒœŸÁÆÈÆ¿ÈÈÇ«¹ÁŸŒŒ²°°¶º¹Œœº»¿ŸÀ±ª¶ÈÈÊÊÉÃÄÆÆÇÉÈÅÂÁÄÄ¿ººŒœÃ» «±—¢¥˜ +}tlfhdWDJp|Ž¡—’•œ¥¡ƒs‰Ž€rŠ’“|ˆ€Ž•‚`NRFJ^zŒrR_xˆ|xwŒ•£¬®œ™Š‰xrigc\QKSTULY\[TLJkaRD%RlvqhdYYO]SbLQJ) + + + +1R69&?:EDVGTOPjD46U7 ;@Z88R®ª®°±Ž±³µ¶³¯º»Œ±©ºº¹Ž®ª¬®µ¹ÀÀÀœ¿¿¿¿Ÿª«µÄÇÃÃÄÅÄÇÆÄÆÅÿÃÄÄÂÂÂÂÁÃÆIJÃÊÈÊÀ€|kji{‹ysgZeuŽšž«®§ ž„„˜‡|—œ™¥Š“—‰gOTXU_l€†eHa€ƒ}ƒqƒ’˜¬µ³€Ÿ›ŠumXjUANJGW‚”‹]\iai^Ro`hdQrshaXRWVXK^D# + +K? +D (1 +!!&'+2A"&"C*UAm! +$Y?"*EJG368=O9L8-&B. ++BGG@19?02>(7J_B"bZ3@\FAIŒŒŠ–šœŸš•¢¡˜—˜©€ª­³Žµ³³Ž²¯±°®¯ª™ž®¶¶·¶Ž²Ž¶žž¿Á¿ÁÂÄÿ¿¿ÀÃÄñÊËõ­©©¹ÀÁÀÁŸÁÁœ±zo£ÃÉÉÇÉŒ±ÅÃŽŠ««­¡˜‹€ƒ”ž›lXPkƒŠ™’€t[Ui‚{†‘‘ª­±²¯€‘›Œi]OXBRPR]UZSQSK76. 0 +56GPRNUZWQIIQ;_-%0'‹†‚‰‹‘‹“”„˜‘˜¥­¥¬°³±³°¯¬««©®Ž¹Ž¡ž±Ž³²±°Ž¶žº¹ÀÂÂÂÂÂÂÂÂÂÂÁÃÄ·©Ç¯|{ŽŸ±¹ž¹ºŒŸÀ»®€³ÅÈÇÆŵ¯ÆƳ²·¶µ¯§Š¡•”ž– +d[Wt|nx\Yi„}|Š–ŒŠ¯°¬Š›|\feUMJNQeqjS>UnUUL\YXRTH,JL>WUF=B==9W"!*3FEMG - +. + +'*( +, +"3<_W7j$5C'$M+4:8A8?K4"1?A%:]H5@N@HHƒ~ƒ„Š†ˆ“’‘’’—˜Ÿš«¬­®ª«®ª­¯­«¬°®®¬”¢²³²²³¶·¶¶¹ŸÁÀÂÁÀœ¿ÀŸœºœŒžª ¿ŽHOjª²Žžºœ¿ÂÀÀŒ¶žœ¿Ÿ¿œŠ®ÃįŒÂ¿Ÿœ»¹¹®š œ”yqdlƒ‹ˆ|kƒpv€„{‚‘™—›¯®š¢’‚q\eOd[MYŠcMPJViTQbmbum^T3@KLT<.7 +!"Y%25?;-KB2)  + + +5'")&N,;(&-9/c'S@n;)#?8$*/9>- +EE,%"2H/3?49?W=%/JG<7RFXP”Œ‘•–“Ž’”Œ„Œ|ž¢š¬­²²¯®°Ž±±±ªª©©¬³°†«žµµ·µµ·¹žŸ¿Ÿºº»¹¹ŒŸœ»žž±®ª§ºŠlFDNZo–¯µžº¹ŒœºººœŸŸœœœº ¬ÀºšŸÁÁœžµŽŽŽ­€¡š’Œ“ƒqŽŒ†r|nu +‚~„‘šŠŸ«©€˜ŠŽybK.C^g]U<%3@uq[npVm‡Štg`[MH9PB/+;=74_;>HJ.5L;C +3($@"e6K>`.> +6-0CF% +6F&/(747<;):T. +FJHINPEEA{ˆŠ‡Ž“—–’‘–¡¥©®±³²°±²Ž³µ²°²Ž²­®Žž~®·¶¶µ¶žºœÀÂÁŸººž¹·µµ·µµ±­­€¢­ŠVG<>EIš¶ž¶µŽ²µ·º¹ŒŒŒ¿œ¶¡Ž»©¡»Œœº³±³±€ –—˜‘Š +”Œ +ˆŠŒŒ†Ž’‡ˆ”¡¬® €¡‡ˆ†iXS?\YtpsL8:Epoc‚|W‰‹ŠrcRVDP4/(@EL?O]GC24&90)$TR*%$BS;+$"34/"F^A+ +MWQ%B/."BG&6+%8L-/!(786*/[2-F<6) +; +.’•‹Šž£§š€Š Œ + Ÿ ¥¬®¯µ¹ž«§©¬«¬°žŒºžŒ¹‘µžº»»œÁÇÇÆÇÅÂÁŒ¹¶µµºµ¶²««®žŸdE=6:EM|Š°³µ·ž¶µ¶µ·¶¶¶··®—®¹’˜²±Ž·¶¶°©¡™‹‡‰‹ŽŒ•œ“˜–‘“Š€Š§£¡©±®£™˜ŠŒƒs_^XVThY> +6<7+1V^XP=Y^/4$$13 +$ +;&*@aM77(IKCRUc^KD:G:,SC#3U\‰~ryzdg86 +2: +1&N6D3 +Uh+,'5K4 + +&9J5 +3$38ZXBC!&=B' /‡ŠŒ’˜›¡šªšŠƒ™·Œº³°°°°µ¿œ¹ž³¶µ·»ŸŸŸÁ«šºžººŸÁÄŸžŽžµ°®­«š¥§§ž¡§¬ªˆˆb%'2BG;@e]M2#,EA\NR,3H?@SXQaNFLGQA0PyŒŠ]VlaTXMv#'*SW'2*ARpVWsŒ‹–Ÿ¢™€©ª“¡§¶¶ŒÀºžŸÁÂÀÂÀŸŒ»œœŸœº¶ŒŸ µŒ»µ³¯²ºž³¯¯ª«¯°¯§Ÿš™šœžz—z?1OˆŒ™¢œš›šž œœœœœž  œwŽ†‡–Ž‰„Œ™ˆ‚‹ˆ{‡zluœ¥Š§¬¬¯Ž²¯¹º¹Ž±®©ª¢™ £–†odaSYLDFFCG\ok`J+)-I;;3#CT`.%-?>EVShBIKGF#f‡‘”•ˆvNfdLPg /+k\:#@RC$29JD`T::  +> +*5E&-E*7bE $1$FE9=a>^=[HF;C”‘‘Ÿ€ž££™“š¶¿ÄÅÃÂÃÿÁÁÀŸ¹º¹¹žžŽ»º˜ª²²žŒœºµ±®±²°¯®«©š¡œž–”ž|†m<.Qyup†‰‡‹ŠŽŒ”•—’–“zw~w€xŒ‰ˆŽŠ‰Žyy{v{{rxc~€ª¬®°¯¬±žŒ»µ±¬¡¡šŽzŠ“‡~o_\WW?DEIUZ\L?HZcPIKB;@cDADG@NTJCSGLDI8 +ADIOgrw†ƒ‹ +TUƒŒ‰3. +zK+!-lU,9NLFN3'G64 +@16GD=]YB[‡‹•šœ¡Š§‘ª°£³ÁÅÄÃÆÆÁ¿¿¿Ÿ¿Œœº¶Ž·žž€sv®·»º»¶µžŽª©Š¢¢¡œ¡££€¡—‹‰o`-+Zwqm‡†‡ˆŒŽŒŒˆ†‡Œ‹‹‰s{tu~tˆ‘‹ +€ŒŠ‰†Œ††th™œ©¬«§­³³¶·¹Ž³°Š£’‰€zˆˆmedb\]YU_XK>OGDJD;QV>FZQM2,[LVVM6HPVZ]L7LA!P418?IK=M`fokZ@q„!1=uw +4&)G@<8GJW>0/@L=3K1V2>2FH09DV]`\LH;05TJ<:DPK3^UG"& +5I73:F>&O=2BVWQ0 +(QDTICF`<27@IY4=P?A7<,OH\kU=SfL9JTebE\H8XP8™—•›™©¥®¶º³±Àœžžž·ž¹ºœœœŸÀÀº²¡«©«Š¯Ž±­®««ªŠ§ £Ÿ ›œ——œ‘Ž‹‰„dpc_sˆzly‚ + +‚„€€€€‚€}vsdyas€r†‹„‡‹„„ +~qv~ƒzgcto~‘¡€§«ª­µž¶°¬­­µ¶¶±€ˆŠ‘sj^VV[WZULU\^X\ZRUSUIUN1!EL9JBACA;C^1?MFL!*<>A% +/F59G@,">FAC:;2%&8?M9KHcC'33?P&MD<1:R[aZD:@HCT)CFT[ZbKd`gR@X_Zg[?N’’‘•“«Šˆž¶¹Ÿ·²À·Žµ¶³²µœ¿»ºŒÀÀ·±žŽ¹ž”‘®¯¬±³²±«ª«š¢ŸŸŸŸž—”““’‰†`mrv|ropm{}„ +‚}}{{~{~x|jdt_vyo~“”‰‘Žƒ˜~vlgvˆŠ£¬¬ª¬¬¬ª«²®«ª§€«¯­Š˜ƒz~oufZSSNSTV]`_\TVMEZNNIO2OF97EQN1EU9C,%7,882@.+(:;'(?FD! +6N7J;8?E:=<=MJgFB:&-,U.RG:1HWB0DZf^qYAN6RodV\b_XEDKWeC?V‘“šžŠ®«Š«µ¹Ž¶­ž³¶±®­°µ¹µžž·²«±²°¹Œ·‘®¯«­®§¬šŠ¥¡œ›œšš˜˜–“’“ +|\x{~wbWVdx|‚„~zusz€}~zxwcala€‰wu‰Š +|qxroz|{‚„”–”}žŠªšŠš©§šª€§ª¬«¬¯ª¡¡˜l_m]XSURRSNMOPRUVNSgRSGH0BJ53TJVPY\C +:-=24I\D6B@(!?. + * --O@@EMOVONJ]YžœŸ”ŽŽ ¯²°«š ®­²²³²µ¯¡¯·º®§°©«¶žŽŽ’—¬š©©€¡§©š¢€ Ÿž—••“••’“Œ„xsi„ƒwc[Y^klox{{~}†€u}wupU[gs€zm`tsplnthov|qe}ˆ +u‡ˆš€š£ £š­©Š®«­¬­šŠ¡žtn`ZY[XSTKNNNJJIKFBO_UNLL5 +>GaSMWUR[KK0&MC@7..6@8*/>YNI7.0(3A;I31%*'+BQXX^:53BF?0:OED?P__\QX[T>DPD39IFMQSCUdwV889BU•’†gK€¥ª¬¯¯“ŸŠ¬«®­£³ºŽ¥«°§µ·ŸŒ°®•ž­¯±©Š¥£¢š¥€£Ÿš˜”Ž—’’‰teiƒ‚~rec_Veiov‚|~u{wxzryzwpY`hmi\aTu€ +nsmpsq{iy‚xtqqƒ[|“–’’”¥Šš£¥ š‘”š«ª¡”ˆY]_]\UOJLPOJFBIJGZVPOXSCQF_fcA7PNGSND0.8-.9\N`kbWTJ>:+043D+!13(2MJ^;I1?6,]MGR[jdI[WEnvjBAJIGSiOGTHRH]odDR;DRR†vnybO +˜š«­Ž±š€¥­ªª¢Ž °¬œšš£®°ŽµŒ±œ£¯°¬ŠŠ©«¥ €Š¡ž›œ˜–Œ••“’Œ€gbu{zkhg`hsp{wxwwzr|ulx|wXg\coprNgryppgvjxk`u|€ +y|‰Qj‰‹‘ˆ}s +Œ{viesu„“–‘’^\_qi\QOROQSID=NPhMK_XEJgWbYWM09JQUKHSH8& +,/<'D;EHdaZPl„xxob,(9C--/7J6+/K^KD64Q;OGKRVED]lmak|cW7QSOR`uG]PHBQipOSHCE;M~ya{uiž€š¬²­°¥¬­Ššš¥££§š€¯¬ª§ª²¬Ÿ¡Š¢Ÿ¡Ÿœ›£™šš˜“‰—–‘Ž‰om€yvpkgmuxru‚€xxnwrslR``x~|zYhuvmkknmoinvzsrdq„Sb}ƒƒy~siqkml^_]geel„–jj`hYZWOVSPIA;35RjLM_XML]PVXL?85GQXKTXI659=GMA>PDJ9LZPSQeotru/&QuC'8EPI@PbH[WQ9%4=D=ZZvtkelmhnQ9ibmyjLI]HOM]€\ZKGJRSSmxuy†’˜–§°±¶š§«š’—š›€œ—¡€©ª©¢¡ŸŠ©Œ‘˜˜——˜•˜––š—˜–”“ƒŽ‘ˆ‡ˆ‚kt‚‚†zujgqz‚„„{{{}qy|o{whYSfjp€~|bo|wdioon_Ymkswr]bjKYuu}qj^[emoj`agiegdv„|k +w[^UTFQ[^[RKMKRqTRO`fb\T\B7867SPXT`ULOFBM?@FM0N3(0Cd[dc\\5(HUH!-*A8HVSZeYR$ +=7%B>,-D`aY=/+OTOJ +9eJT`M@a|k\P_SWYUVƒwsgrvŒ’•Ÿ³±—š˜˜š•—£œž¢££§©š¬šŠ§š†ƒ˜“•—•““•••”’’ŒŒ„‡ŒŽŽŒŠ‰ƒ`x€†‰ƒ‡‚h]qvxurorwttz|€j_f[Unrƒ†~€fs€‚`fr{ycXcuolvamiHTkdhkmenhnvsfbnmlqhiiiYm{h^f\O\ba][VMIMVPHLPTOSKLNOLWRNHWNO=ORRNED18C)A +$2*.WeacK4$@=1$7:;JbR_WR)6QSH1*.%34[NSSE757IYX^qaC_`HQawbDGWbbFXQnvlk}ƒ„ˆŒ‰ ª­™—¢­¡”£–¢œ«²«°®©±°€ ŸŽ{˜•’””‘”‹Š}Œ‹ŒŒŽŽ‰†|Z‹Žˆ‚}‡ngu{vxysfuyv€uiszT\{‡rxZcpubivwoasqkl^m\ghDZosxwqgspsrmednpnpn^bf]dnkc]YLYXPU`YMDNYX[SKVMOEP9JVSOOQWH?53$10A3/ +4MC +3&.+"JVQG;$; +55F"E>ZbP\c@.=KKP[L6.=5YFHDJ=G*P]XN?Hb\INccPDHNWFCKZŠ‡p|Š‰‰ˆ‹šž“ƒ¢ª ’Ÿ‚˜«³»ž°¬§Š¥€ž¡¥˜r‘™™•Š‹‹ŠŒ‹‰x††ˆŽŒˆ‹€†Šj| +‚‚Š„seoqlpttqv|yoqoxtSg†‘’xug`bakkriYeuu|ddhel`C_sporkoptpomdmeflmdajk^aaW_UOQZVZ[]SRSSZV[GCBHXR_D5.$#7@>328K$7KW<,03:P;7C=)=':=Mi[Fbb?HNTNG;WPY†vt„‰Š‡„wzŸ‘Ž~•§§©©šš£¢Ÿžœ˜–”k‚‰‰ŠŠ‰ˆ‹‰ˆŒŽ‰‡‹‹‹ +‰•p†‹‰‡„‚lZ\^dnwxuovrmxxenm]x‹’’ztd\aQd_j^XillxhpbYibBgpqtumfplhlekunorjcbe`\aaebfPN_X[dZUQPQ\XZIKCALTaKE?RQR9AHOM<49.,(?Q0OJ7K9;4"4GJ]gkKS@4""8E@GITVELu_;55BTZQ@VXZaxoaQPIRXOFFUXsx‰‰ +‚u€‘š‘Šrl‚‘—™Ÿ€ªš©©§¢¡€›˜’‰j}ˆ +†„†‰ŒŽ +„Š‹€~ŒˆŠŠ‚„†dy‡} + +zndv‚spwwpzwwnlhgubj‰u„{s‰†yb_Olong~}zm{jgf`]XMeehhdXjoomn`Uihehbhhe`TOZ]][Ycf]ZY[[[[X\Vb[VPLG\\HLWMRPHDLj†_B9AIGID?gwPn}gfn‚Œ‹Œ•]~ +“•œ¡¥§®®«¥§«©¢š“Œl~„††‡‡‹ƒˆŽƒˆ‹‡†Š„‡†_‡ +„|zn]n|stml^kblojchzmc~„ƒ‡{‚zjbahi[`qhsj~nib^hQTdcgkdWiqlfigckrrjY^[Z^Y[edZZchgcVg`Z]_]`ZdW\RUGUbJSTJKLKMOLP407COe^9/:3$".% '*?VVU=5VeSNIC_V@^hdtQPEJ0 > HY?AKVROH9IdIR’ƒ[QC=(8VsNQvwe_dtz€ˆ‚hl€’”   ¥§ªª§«©Š¡ž™”‘’t} + +ˆ‡ƒŠŒ‹v€u€€‚‡‡‹‰†‰ŒŠ]‹‡‡Š†ƒw]gtqtn]^jippsq€yag +„wsxz†dv„l`N_gibZicb`[aNU[]aebTegddchjbi\YdjebdX`Z_X\fd\i`Z[[b`V^`eUPRPFKgOTLTFIIIIRKB6/-FrVE94.9=*";av„‹UEZJJ9*C.JezŽm€n;,---6}Š†‚ˆ§lRA +4-%7F6O‰d—­~t|Z* +&6,_]vfcPRY[\V@:Wqt†z]LMYkSG5-]MQT{y{€ƒ€|}vqfn{†‰‘˜ ¥¥¢¥Šš£ Ÿš”–Žr€“ˆ„‡ƒ‚ +ms~„€€}„ + +‰ˆ‹„X| +„sv„ˆy]rzohlqq||‡†~xvnf]RYeu}€xRV\TUhgfhupppngRJGaga^_ni`^RVV\ee`dif]`behbkpm_defid`]adYL[[^SOTPBN^ORWKNROP\\KEA;i‰K55O`ST\TUHJQ^KEFBd™|b@DPLPK7:DQx}ˆ•‹‘‡†;>A,.k'ur`hsŠ‚STœZŠcN\r\`LcWaHp^b\_JRJUfDA\zeE1('7NMYY~ƒz||y€yptrmbxy +“Œ˜¢Ÿ ¡€©¢›–Œ”k}’’ƒe„†Š„|~|€„Š‹‡‚‡w^vv{Œˆ‰uXdwr{€‚„„ƒŒˆ„„}a^qpheqxn\YXcoYk^MMR\gagdgLaU`a\\ZWdX]ebiphdggl^bdpha][_X\^]]`]^W][WLU\YONNNCG]WNQaMCLW:HDCKqƒTBNZf[VQSH]€sš©ºnZf_KF9:9+f‰W^]`[rVY‡—‰hpeIXdzrmN58OqbMIJ37XLR]UaP+ !8]XZUxnt}€}}|qolsb_uuw‚ŒŒ˜Ÿ£šš£Ÿš•’˜•–ƒ‚™”š–uvƒŠƒ††€ƒ}{‚‰ƒ†„„w[jv€‰‰ƒ~qUew‚luww€|‡Œ‹€[TgmlvrdO[_QY]`dgahƒulfuZUHFT^VXdnssnmtqc`bliZ`\\eghdZWemg`kieWVUZ_U[X_]TRN:KJV[ONdU@ZZKHL]Y\k|P7GOY]ULN\tm_Vaf]dt[G@-&Rƒ›¢f]d}fem‰ˆpgxX5Q[qƒVLFYDKT?PV:NWMc}F9V6;8K`V@Af`€~~}|sqdfeW_pwz†Ž‡‹  €œœ—•–œ¢¥£€ž¡ž‰ƒy}‡Ž„ƒ‚‡ƒ„„„ +z +xm[mt€Š„z„mT]k~iimt„Œ‡ +‡‹uR[a]lvaIH`_SQOFSnhffkqugH8/=U`VW`mtsobgoxsjntng]\_`b[_lg^[OY]RRONKMCMO\\LHAANRUMMNTVRdOY]rx„‡~uOLMSWO:Cw™Ÿ‘ibˆƒIE/"-vŠ„][`Trkxrƒ£meTA3jŠrCKV]\MJ>=TOWU_:V5#8^BE8RC1#1j|~ulmojfhf_U]hqˆ‹ +•˜Ÿ¡ ˜ ŸŸ£ž£¢¢št•“„ƒˆp‡Œ„ +†ƒ€~„zw|t\srx{t{y_Mayrp~‰‘–‚‹Š„lQhgbgZK:Y_Yc]F,Juqwjzo[K7ID1biljijihb^\``ipyvwd^dng^`]hf[]\XUY]U]OHEQN[ZRI=NRQRKJIJ[[VXyJ_‘œ•‘w|_WUWPKLT`kx}vjs}}C-:%4Š|sIbcM@f‹‹ki<%H;4Xf~]VNAARM?WrMGTf^?E0'IB<1#02- 2e\Rlkaigjf^bT]ikw~~–œŸ›™š›››™–eˆ|Š€‹‹“‹Œ‰ˆ„ˆƒ†~~u~Œ +m_l{xy}ztnVglr +ƒŠƒxl‹~{gGasxcZ;?SLX]]cOp|tofcPF]eTF@mgicmrxhlpeVeUT_if\cZlmjj\`[X\lkeb]Y\J:G\U\ZXBLTNKNRSOG\dXˆg<}˜•‘~Z_]TMNJ>>B\qts}zero=$3%)+06>Qd`jecabjb^cW^ppt‹—’–—žš™œšœ˜˜–”‘[hƒ’“ƒ‹Œ•’‹ŽŒ‚wyy‚ŠƒeYqz~tv +‰sWf{{{‚wtv +„|yyaWXsfe]Mb\Pd_TfWoog_XTYvzr;:`yhgeditphbeRbg[XW[HNP]c[^WWPP\ecb[UWXR>PUQWQNIUUQHQSUNJLLtB>oVOUXXcG@BR?=A[`ra[‡†“h’r=&-!B¯‡TjKVVeY6[†cD9637;ssTTLCH584KYG?31^FCO''%54;Kgnokmn___da[]hlo„”˜‘’–›ž ˜˜˜˜•ŽXaƒ“”Œ”’Ž‘ŽŒ„‚|‚‡„}‡za`oyu€†Œ~fVk„yxqnzx~ƒ{mgSX^afMZc[_rW[bQc^SbOa{xy]7Rggdgd_izsjdWZfigjZ]]TbXWdl^\\RTQSTSIKKJDYSRZNVSWXMGIKF9JRdN'>LMVM7IADLVG8WŽ„kL[q~scw3'*#QŠŽ ŽENMqlSKZVSPN.9LeH>FK[HKA+&IADGId}E40>n^B" +:,%NRgi_cnphakqtdfltsyƒˆ +ƒ€†‹”ŒŽ‘”˜‘†‡^\‚–‘™Ž’‹zx€‡€x|‰‡†‡}w{€kZdv +†~okV`dfcakmjfs’ŽjhXTY[XB_]Woc`YVSZ`]X^pwxuW_W{{pjurrprphZaYYVSb\f]^Xeeqo|jmaR]X[YNLDOXOXQXZJEDYRSHIk +d@ +!4PeeMM@N@\^chy€|qlphdaox{x‰’™“–˜›—’Š‹‰€pp‡ƒievy|„†‡ˆ‘ +‰‚xownXkslusrpnbQ^sqr€€vf{ŠŠpcnƒ~qZSmfV_RXSLDZeTpmrxhnqIvznibfqgdehpnpUMYaasrcZR[\S]e`^c[mkRXUQLIVX`SZLLDAbKNEn“‰@$ + +.@NNC9>QEDNUKQQQaJMSXid1D8`aSGW3*5O]\jru|wyx~zbWgnr‡‹”›œžž¡ ž›š–Š‚wxiˆ„ˆŽ‘‘Œ•“’—†ƒƒ‚vjpqp[syl{yk`beZmzy +„‚Š‚„u†‚i[k{€ˆWhlaUWMTLDSPTmlmoon\€vUiuvt`[\k„ƒ€rudom|rmƒtcZkdNONPNKUQQPLKOPWU]]URWKI=;XBQV‹”e)##&+B@LA4?MRFGP7K[esJQKShdt`?:F=:bfal‘LPTj`OUYdfZcWRY^E`‡‡gj_zOYJk`.(8&)LMKHODDKOQOIXQOT\GAF?YAYTb~OTL97=6BHXba=hl65I;,49.;]fsllnir‚ +‡nyzw~unt +‹ˆŸšªw™›™˜‰ˆ„‡b‹•Œ’˜‘‹’•†ljtŠƒwtnye€zMkuqtl_grvmho~†‰‚sjWVuoXHX_^OGW_hkBZpsovWrHSxhdlwyc\hkq~ +ˆx”iq[Yldf_YngXTLQVLOURMSUPLFJSTTZ[SKHGUR]<(116211;ANORO@8UQLu„s[GWcaZa],$0!$HNJHHIFS[VIOX7OPXFEECSPwunfRPEBE@;78]}`=QWDB):09PWarsiarv‚†zcuxs{y„~qeqˆ–—‹ƒ‡† +Œ†ƒkvŽ”Ž‹ƒhgn€ +|‚‡‰|]luvzromog_p‡yGRMNcgeejUSqMBb~a6;AogB^em‘wepƒvOkss~bHRrpjtx‚us +w‰{„wuƒ†k^of`lrojkilszf\oqk\SFIDXROOQYGM>.992=-)(,0AOTJNQLF3&A% 93LVU^ITQ8/#)YL=D\BEJBF87HlnRmwPfNOX_P;8KBLFKUKIOYTHJD<8::6+%%+19AE>DLFI*2@:NYPfMaKKUN:=3EX]*#5UWK7ESB?MWY]ic]a`grvttnle~‚yvx’¢£–Œm_ +‹‹ +p~~€ƒ€ekƒ†v[t‚ˆ€ƒƒ‚|v‚ƒ’–vTc‚xywsktz}dmumIGm‚fXfŒqic`NˆˆfN5BOo“Žtmmˆ‰oqbPcyvwttzQhpegilovloww{ƒukovƒy +ur‚€xnn]ifPKGRXPQWkJETOOWbQKJOC8::.)&(%'**9BLEGC,>=+-JWgRX>>:0Z5%BT>N77FFMRXO-zTCzDZG_VEe]7;1,#&'$&4=HOSMRX:HRea\<4=nL39)QH'7;FOPROORE>SBrFS\HHYHZV[]X7KD;OOLE_YS<5#(FTFTIF&F58RVSQff^gjjjkbj|p +ˆ“Žƒji{‰|qim +‚ww†‰hehg~|yxƒ}‡|z +t{]oydcz‚{vuzwwoabpooim^gk^\jSln}ƒŠZ?8>-)+&$2?RVQV`_Z\ZMQ5IRPVISJNL<. +A=>CYNbR`WVQXW\ifengWZYiu‘‰t‡’~„wˆw}‰Šj~kZrwƒŽwZTyvx‚†‰‰–‰‚ƒŽ–|pT^prhbƒ„w}~xkme^uuzofn€•\\_Q‰Ž€Œ™|PSJUn“„|uyŒ„¡›–ŽŽpwxmetxwe`ir{†ufd`auyrŠjmskYVUg\Zqcaba`acreXZLOU]PSWe_YCQHA8;-''('HMZ_^ffRN[CIfZH``JOKYR,57I>*5=;=RNJOVa€€Gl`EABCPVWI>K=DNVwc7?TI2).H*+P?S[EPDIJXrafkj[WYbsy„ˆ{YqˆŠ~o{xv†€xcw +yhZmƒ‚d_k]}ƒ†Š}hjŽˆŠƒyn`rwwub` +srhqƒ}lg~rlsmlVkhN]ƒ +js\KY@NUt„ˆ˜›•Ž~f_uedlpf`kllkjjrpnmknkwut‚||tqhT\``d^ZLX^gbUOSRLJKO9X[WRC>SDD;2'&('.JGUUpolXL\C@nK]YKSTUlN%G9&N#'8@O]ZRORAX{yhlGM89>JYT8AE37`dE53K`B.8A*'?VKGO/MOX\QcOOXYSWdgoloqmQ_gdefjs‰„‡‰yopunhV]ryŠuUuƒ‘†z€†|pz‚qer{~\_qnlasŠœ—‰m\kyu€wsakvNa‰‡xnHQG4]Tkmv€€€€kzma\ƒ{mlq|q +y„iZ^hhdzp}ntqpu‡Š€„xiulXYZNKY[SUZ]YReTRKAC]TLBJN:BB'# ((7P?_jrmdUXZFFGWg^T@FSgQ37<"-),05,/:03L/*275) +*" + +$* + +" + + + + + + + + ebQXY]qzyƒƒ|us^fwxwzvmpnldjjh[fl†dbwxkUrƒ‹ˆ‡ƒ~{u~tf|}‚|~€rbn|€m{ +}|xiX`zt{vcX[ohXc{{\jWdOLmXLUorp +~iqyX>ysqcplhzrpebkjnlms€‡wszjmp‘¢™‘ˆdt]YƒhUV`KNblYX[RNB6152> Y_WIDTH; // x coordinate + unsigned int y = cluster_xy & ((1< NN ) + { + giet_exit("[TRANSPOSE ERROR] number of tasks larger than number of lines"); + } + + barrier_init( &barrier_0, ntasks ); + barrier_init( &barrier_1, ntasks ); + barrier_init( &barrier_2, ntasks ); + barrier_init( &barrier_3, ntasks ); + barrier_init( &barrier_4, ntasks ); + + giet_shr_printf("\n*** Proc [%d,%d,%d] completes barrier init at cycle %d\n", + 0, 0, 0, giet_proctime() ); + init_ok = 0; + } + else // others processors wait initialisation completion + { + while ( init_ok == 1 ); + } + + // The buffers containing the images are distributed in clusters + // (one buf_in and one buf_out per cluster). + // Each buffer contains (NN*NN / nclusters) bytes. + // They are allocated in the cluster heap by processor with (lpid == 0). + if ( lpid == 0 ) + { + unsigned int heap_base; + giet_vobj_get_vbase( "transpose", + heap_name[cluster_id], + &heap_base ); + + buf_in[cluster_id] = (unsigned char*)heap_base; + buf_out[cluster_id] = (unsigned char*)(heap_base + NN*NN/nclusters); + + giet_shr_printf("\n*** Proc [%d,%d,%d] completes buffer allocation at cycle %d\n" + " - buf_in = %x\n" + " - buf_out = %x\n", + x, y, 0, giet_proctime(), + (unsigned int)buf_in[cluster_id], + (unsigned int)buf_out[cluster_id] ); + + // open file containing images + file = giet_fat_open( "misc/images.raw", 0); + + giet_assert( (file >= 0), + "[TRANSPOSE ERROR] cannot open file misc/images.raw"); + + giet_shr_printf("\n*** Proc [%d,%d,%d] completes _fat_open at cycle %d\n", + x, y, 0, giet_proctime() ); + } + + ////////////////////////////////////////////////// + // all tasks wait buffer allocation completion + ////////////////////////////////////////////////// + barrier_wait( &barrier_0 ); + + // Main loop (on images) + while (image < NB_IMAGES) + { + // pseudo parallel load from disk to buf_in buffer : nblocks/nclusters blocks + // only task running on processor with (lpid == 0) does it + + LOAD_START[cluster_id][lpid] = giet_proctime(); + + if (lpid == 0) + { + giet_shr_printf("\n*** Proc [%d,%d,%d] starts load for image %d at cycle %d\n", + x, y, 0, image, giet_proctime() ); + + giet_fat_read( file, + buf_in[cluster_id], + (nblocks / nclusters), + ((image*nblocks) + ((nblocks*cluster_id)/nclusters)) ); + + giet_shr_printf("\n*** Proc [%d,%d,0] completes load for image %d at cycle %d\n", + x, y, image, giet_proctime() ); + } + + LOAD_END[cluster_id][lpid] = giet_proctime(); + + ////////////////////////////////////////////////// + // all tasks wait buf_in load completion + ////////////////////////////////////////////////// + barrier_wait( &barrier_1 ); + + // parallel transpose from buf_in to buf_out + // each task makes the transposition for nlt lines (nlt = NN/ntasks) + // from line [task_id*nlt] to line [(task_id + 1)*nlt - 1] + // (p,l) are the absolute pixel coordinates in the source image + + giet_shr_printf("\n*** proc [%d,%d,%d] starts transpose for image %d at cycle %d\n", + x, y, lpid, image, giet_proctime()); + + TRSP_START[cluster_id][lpid] = giet_proctime(); + + unsigned int nlt = NN / ntasks; // number of lines per task + unsigned int nlc = NN / nclusters; // number of lines per cluster + + unsigned int src_cluster; + unsigned int src_index; + unsigned int dst_cluster; + unsigned int dst_index; + + unsigned char byte; + + unsigned int first = task_id * nlt; // first line index for a given task + unsigned int last = first + nlt; // last line index for a given task + + for ( l = first ; l < last ; l++ ) + { + +#if VERBOSE_OK +giet_shr_printf(" - Proc[%d,%d,%d] process line %d\n", x, y, lpid, l ); +#endif + + check_line_before[l] = 0; + + // in each iteration we transfer one byte + for ( p = 0 ; p < NN ; p++ ) + { + // read one byte from local buf_in + src_cluster = l / nlc; + src_index = (l % nlc)*NN + p; + byte = buf_in[src_cluster][src_index]; + + // compute checksum + check_line_before[l] = check_line_before[l] + byte; + + // write one byte to remote buf_out + dst_cluster = p / nlc; + dst_index = (p % nlc)*NN + l; + buf_out[dst_cluster][dst_index] = byte; + } + } + + giet_shr_printf("\n*** proc [%d,%d,%d] completes transpose for image %d at cycle %d\n", + x, y, lpid, image, giet_proctime() ); + + TRSP_END[cluster_id][lpid] = giet_proctime(); + + ////////////////////////////////////////////////// + // all tasks wait transpose completion + ////////////////////////////////////////////////// + barrier_wait( &barrier_2 ); + + // optional parallel display from local buf_out to frame buffer + // all processors contribute to display using memcpy... + + if ( ( X_IO != 0) || (Y_IO != 0) ) // external frame buffer available + { + giet_shr_printf("\n*** proc [%d,%d,%d] starts display for image %d at cycle %d\n", + x, y, lpid, image, giet_proctime() ); + + DISP_START[cluster_id][lpid] = giet_proctime(); + + unsigned int npt = npixels / ntasks; // number of pixels per task + + giet_fb_sync_write( npt * task_id, + &buf_out[cluster_id][lpid*npt], + npt ); + + giet_shr_printf("\n*** Proc [%d,%d,%d] completes display for image %d at cycle %d\n", + x, y, lpid, image, giet_proctime() ); + + DISP_END[cluster_id][lpid] = giet_proctime(); + + ////////////////////////////////////////////////// + // all tasks wait display completion + ////////////////////////////////////////////////// + barrier_wait( &barrier_3 ); + } + + // checksum done by processor (lpid == 0) in each cluster + + if ( lpid == 0 ) + { + giet_shr_printf("\n*** Proc [%d,%d,%d] starts checks for image %d at cycle %d\n", + x, y, lpid, image, giet_proctime() ); + + unsigned int success = 1; + unsigned int start = cluster_id * nlc; + unsigned int stop = start + nlc; + + for ( l = start ; l < stop ; l++ ) + { + check_line_after[l] = 0; + + for ( p = 0 ; p < NN ; p++ ) + { + // read one byte in remote buffer + src_cluster = p / nlc; + src_index = (p % nlc)*NN + l; + + unsigned char byte = buf_out[src_cluster][src_index]; + + check_line_after[l] = check_line_after[l] + byte; + } + +#if VERBOSE_OK +giet_shr_printf(" - l = %d / before = %d / after = %d \n", + l, check_line_before[l], check_line_after[l] ); +#endif + if ( check_line_before[l] != check_line_after[l] ) success = 0; + } + + if ( success ) + { + giet_shr_printf("\n*** proc [%d,%d,0] : checksum OK for image %d\n", + x, y, image ); + } + else + { + giet_shr_printf("\n*** proc [%d,%d,0] : checksum KO for image %d\n", + x, y, image ); + } + } + + // instrumentation done by processor [0,0,0] + + if ( (proc_id == 0) && INSTRUMENTATION_OK ) + { + int cc, pp; + unsigned int min_load_start = 0xFFFFFFFF; + unsigned int max_load_start = 0; + unsigned int min_load_ended = 0xFFFFFFFF; + unsigned int max_load_ended = 0; + unsigned int min_trsp_start = 0xFFFFFFFF; + unsigned int max_trsp_start = 0; + unsigned int min_trsp_ended = 0xFFFFFFFF; + unsigned int max_trsp_ended = 0; + unsigned int min_disp_start = 0xFFFFFFFF; + unsigned int max_disp_start = 0; + unsigned int min_disp_ended = 0xFFFFFFFF; + unsigned int max_disp_ended = 0; + + for (cc = 0; cc < nclusters; cc++) + { + for (pp = 0; pp < NB_PROCS_MAX; pp++) + { + if (LOAD_START[cc][pp] < min_load_start) min_load_start = LOAD_START[cc][pp]; + if (LOAD_START[cc][pp] > max_load_start) max_load_start = LOAD_START[cc][pp]; + if (LOAD_END[cc][pp] < min_load_ended) min_load_ended = LOAD_END[cc][pp]; + if (LOAD_END[cc][pp] > max_load_ended) max_load_ended = LOAD_END[cc][pp]; + if (TRSP_START[cc][pp] < min_trsp_start) min_trsp_start = TRSP_START[cc][pp]; + if (TRSP_START[cc][pp] > max_trsp_start) max_trsp_start = TRSP_START[cc][pp]; + if (TRSP_END[cc][pp] < min_trsp_ended) min_trsp_ended = TRSP_END[cc][pp]; + if (TRSP_END[cc][pp] > max_trsp_ended) max_trsp_ended = TRSP_END[cc][pp]; + if (DISP_START[cc][pp] < min_disp_start) min_disp_start = DISP_START[cc][pp]; + if (DISP_START[cc][pp] > max_disp_start) max_disp_start = DISP_START[cc][pp]; + if (DISP_END[cc][pp] < min_disp_ended) min_disp_ended = DISP_END[cc][pp]; + if (DISP_END[cc][pp] > max_disp_ended) max_disp_ended = DISP_END[cc][pp]; + } + } + + giet_shr_printf(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n", + min_load_start, max_load_start, (min_load_start+max_load_start)/2, + max_load_start-min_load_start); + + giet_shr_printf(" - LOAD_END : min = %d / max = %d / med = %d / delta = %d\n", + min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, + max_load_ended-min_load_ended); + + giet_shr_printf(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n", + min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, + max_trsp_start-min_trsp_start); + + giet_shr_printf(" - TRSP_END : min = %d / max = %d / med = %d / delta = %d\n", + min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, + max_trsp_ended-min_trsp_ended); + + giet_shr_printf(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, + max_disp_start-min_disp_start); + + giet_shr_printf(" - DISP_END : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, + max_disp_ended-min_disp_ended); + } + + image++; + + ////////////////////////////////////////////////// + // all tasks wait instrumentation completion + ////////////////////////////////////////////////// + barrier_wait( &barrier_4 ); + + } // end while image + + giet_exit("Completed"); + +} // end main() + +// Local Variables: +// tab-width: 3 +// c-basic-offset: +// c-file-offsets:((innamespace . 0)(inline-open . 0)) +// indent-tabs-mode: nil +// End: + +// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3 + + + Index: /soft/giet_vm/transpose/transpose.ld =================================================================== --- /soft/giet_vm/transpose/transpose.ld (revision 295) +++ /soft/giet_vm/transpose/transpose.ld (revision 295) @@ -0,0 +1,40 @@ +/**************************************************************************** +* Definition of the base address for all virtual segments +*****************************************************************************/ + +seg_code_base = 0x00400000; +seg_data_base = 0x00500000; + +/*************************************************************************** +* Grouping sections into segments for code and data +***************************************************************************/ + +SECTIONS +{ + . = seg_code_base; + seg_code : + { + *(.text) + *(.text.*) + } + . = seg_data_base; + seg_data : + { + *(.ctors) + *(.rodata) + /* . = ALIGN(4); */ + *(.rodata.*) + /* . = ALIGN(4); */ + *(.data) + /* . = ALIGN(4); */ + *(.lit8) + *(.lit4) + *(.sdata) + /* . = ALIGN(4); */ + *(.bss) + *(COMMON) + *(.sbss) + *(.scommon) + } +} +