Changeset 215 for soft/giet_vm


Ignore:
Timestamp:
Sep 17, 2012, 10:47:46 AM (12 years ago)
Author:
karaoui
Message:

New components are now mandotory in the XML description:

The files giet_vsegs.ld and hard_config.h are now autogenerated by the xml2bin tool.

Location:
soft/giet_vm
Files:
1 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/Makefile

    r214 r215  
    4444TRASH= /dev/null||true
    4545
    46 all: soft.elf
     46all: map.bin soft.elf
    4747       
    4848## merge all *.elf and map.bin to soft.elf
    … …  
    5353          build/pgcd/pgcd.elf \
    5454          build/hello/hello.elf \
    55           map.bin
     55         
    5656        $(MAKE) -C memo
    5757        memo/memo.x  map.bin
    … …  
    6161map.bin: $(MAP_XML)
    6262        $(MAKE) -C xml
    63         xml/xml2bin $< $@
     63        xml/xml2bin $< .
    6464
    6565### system compilation
    … …  
    130130### clean
    131131clean:
    132         rm -f *.o *.elf *.bin *.txt core *~     2>$(TRASH)
     132        rm -f *.o *.elf *.bin *.txt core  giet_vsegs.ld hard_config.h *~ 2>$(TRASH)
    133133        $(MAKE) -s clean -C xml 2>$(TRASH)
    134134        $(MAKE) -s clean -C memo 2>$(TRASH)

  • soft/giet_vm/boot/boot_init.c

    r210 r215  
    187187                   : "$26" );
    188188}
     189
     190//////////////////////////////////////////////////////////////////////////////
     191// boot_scheduler_get_itvector()
     192// This function get an interrupt vector slot in a scheduler, after a temporary
     193// desactivation of the DTLB (because we use the scheduler physical address).
     194// - gpid   : global processor/scheduler index
     195// - slotid : context slot index
     196// - return the content of the slot
     197//////////////////////////////////////////////////////////////////////////////
     198unsigned int boot_scheduler_get_itvector( unsigned int gpid,
     199                                         unsigned int slotid)
     200{
     201    unsigned int value;
     202
     203    // get scheduler physical address
     204    static_scheduler_t*     psched = boot_schedulers_paddr[gpid];
     205   
     206    // get slot physical address
     207    unsigned int*           pslot  = &(psched->interrupt_vector[slotid]);
     208
     209    asm volatile ( "li      $26,    0xB     \n"
     210                   "mtc2    $26,    $1      \n"     /* desactivate DTLB */
     211                   "lw      %0,     0(%1)   \n"     /* *pslot <= value  */
     212                   "li      $26,    0xF     \n"
     213                   "mtc2    $26,    $1      \n"     /* activate DTLB    */
     214                   : "=r"(value)
     215                   : "r"(pslot)
     216                   : "$26" );
     217    return value;
     218}
     219
    189220//////////////////////////////////////////////////////////////////////////////
    190221// boot_scheduler_get_tasks()
    … …  
    286317void boot_puts(const char *buffer)
    287318{
    288     unsigned int* tty_address = (unsigned int*)( (char*)&seg_tty_base +
    289                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     319    unsigned int* tty_address = (unsigned int*) &seg_tty_base;
    290320    unsigned int n;
    291321
    … …  
    915945            if ( periph[periph_id].type == PERIPH_TYPE_TIM )
    916946            {
    917                 if ( periph[periph_id].channels != (NB_PROCS_MAX + NB_TIMERS_MAX) )
     947                if ( periph[periph_id].channels > NB_TIMERS_MAX )
    918948                {
    919949                    boot_puts("\n[BOOT ERROR] Too much user timers in cluster ");
    … …  
    13121342
    13131343            //////// vci_io_bridge component
    1314             else if ( (type == PERIPH_TYPE_IOB) && GIET_IOMMU_ACTIVE )
     1344            else if ( (type == PERIPH_TYPE_IOB) && IOMMU_ACTIVE )
    13151345            {
    13161346                // get the iommu page table physical address
    … …  
    14351465    {
    14361466        alloc_fbdma_channel[cluster_id] = 0;
    1437         alloc_timer_channel[cluster_id] = NB_PROCS_MAX;
     1467        alloc_timer_channel[cluster_id] = 0;
    14381468    }
    14391469               
    … …  
    15601590            unsigned int ctx_ptpr = (unsigned int)boot_ptabs_paddr[vspace_id] >> 13;
    15611591
     1592            // compute gpid = global processor index
     1593            unsigned int gpid = task[task_id].clusterid*NB_PROCS_MAX +
     1594                                task[task_id].proclocid;
     1595
    15621596            // ctx_ptab : page_table virtual base address
    15631597            unsigned int ctx_ptab = (unsigned int)boot_ptabs_vaddr[vspace_id];
    … …  
    16021636            {
    16031637                unsigned int cluster_id = task[task_id].clusterid;
    1604                 if ( alloc_timer_channel[cluster_id] >= NB_TIMERS_MAX )
     1638                unsigned int allocated = alloc_timer_channel[cluster_id];
     1639
     1640                if ( allocated >= NB_TIMERS_MAX )
    16051641                {
    16061642                    boot_puts("\n[BOOT ERROR] local TIMER index too large for task ");
    … …  
    16111647                    boot_exit();
    16121648                }
    1613                 ctx_timer = cluster_id*NB_TIMERS_MAX + alloc_timer_channel[cluster_id];
    1614                 alloc_timer_channel[cluster_id]++;
     1649               
     1650                //assert(allocated >= 0);
     1651                char found = 0;
     1652                for( irq_id = 0; irq_id < 32; irq_id++)//look at the isr_timer isr channel
     1653                {
     1654                    unsigned int isr = boot_scheduler_get_itvector(gpid, irq_id) && 0x000000FF;
     1655                    if(isr == ISR_TIMER)
     1656                    {
     1657                        if(allocated == 0)
     1658                        {
     1659                            found = 1;
     1660                            alloc_timer_channel[cluster_id]++;
     1661                            ctx_timer = cluster_id*NB_TIMERS_MAX + alloc_timer_channel[cluster_id];
     1662                            break;
     1663                        }else
     1664                            allocated--;
     1665                    }
     1666                }
     1667
     1668                if(!found)
     1669                {
     1670                    boot_puts("\n[BOOT ERROR] No user timer available for task ");
     1671                    boot_puts( task[task_id].name );
     1672                    boot_puts(" in vspace ");
     1673                    boot_puts( vspace[vspace_id].name );
     1674                    boot_puts("\n");
     1675                    boot_exit();
     1676                }
     1677
    16151678            }
    16161679
    … …  
    16421705            unsigned int vobj_id = task[task_id].vobjlocid + vspace[vspace_id].vobj_offset;
    16431706            unsigned int ctx_sp = vobj[vobj_id].vaddr + vobj[vobj_id].length;
    1644 
    1645             // compute gpid = global processor index
    1646             unsigned int gpid = task[task_id].clusterid*NB_PROCS_MAX +
    1647                                 task[task_id].proclocid;
    16481707
    16491708            // In the code below, we access the scheduler with specific access

  • soft/giet_vm/giet_config.h

    r207 r215  
    1010#define _CONFIG_H
    1111
     12/* hardware parameters */
     13#include "hard_config.h"
     14
     15
    1216/* Debug parameters */
    1317
    … …  
    1519#define BOOT_DEBUG_PT           0                       /* trace page tables initialisation on TTY0 */
    1620#define BOOT_DEBUG_VOBJS        0                       /* trace vobjs initialisation on TTY0 */
    17 #define BOOT_DEBUG_SCHED        0                       /* trace schedulers initialisation on TTY0 */
     21#define BOOT_DEBUG_SCHED        1                       /* trace schedulers initialisation on TTY0 */
    1822
    1923#define GIET_DEBUG_INIT         0                       /* trace parallel kernel initialisation on TTY0 */
    2024#define GIET_DEBUG_SWITCH       0                       /* trace context switchs on TTY0 */
    2125
    22 
    2326#define CONFIG_SRL_VERBOSITY TRACE
    24 
    25 /* hardware parameters */
    26 
    27 #define NB_CLUSTERS             4                       /* number of clusters */
    28 #define CLUSTER_SIZE            0x40000000      /* address increment between clusters */
    29 #define CLUSTER_IO_ID       2                   /* cluster containing non replicated peripherals */
    30        
    31 #define NB_PROCS_MAX        1                   /* max number of processors per cluster */
    32 #define NB_TIMERS_MAX           0                       /* max number of user timers per cluster */
    33 #define NB_DMAS_MAX                     1                       /* max number of DMA channels per cluster*/
    34 #define NB_TTYS                         8                       /* total number of TTY channels */
    35 #define NB_IOCS                         1                       /* total number of IOC channels */
    36 #define NB_NICS                         8                       /* total number of NIC channels */
    3727
    3828/* software parameters */
    3929
    40 #define GIET_NB_VSPACE_MAX      4                       /* max number of virtual spaces */
     30#define GIET_NB_VSPACE_MAX      64                      /* max number of virtual spaces */
    4131#define GIET_TICK_VALUE     0x4000              /* context switch period (number of cycles) */
    42 #define GIET_IOMMU_ACTIVE   0                   /* The IOMMU vspace is defined */
    43 #define GIET_USE_XICU       1                   /* Use the XICU interrupt controler */
    4432
    4533#endif

  • soft/giet_vm/libs/libsrl/srl_args.h

    r213 r215  
    1111
    1212
    13 # define SRL_GET_VBASE(task_name, port, type)                                                         \
    14 ({                                                                                                  \
     13# define SRL_GET_VBASE(task_name, port, type)                                                      \
     14({                                                                                                 \
    1515    unsigned int  vbase;                                                                           \
    16     if( giet_vobj_get_vbase( APP_NAME , alias_##task_name.port, type, &vbase ) )                    \
    17     {                                                                                               \
    18         srl_log_printf( NONE, "\n[ERROR] in "#task_name" task :\n");                                \
    19         srl_log_printf( NONE, "          undefined port <"#port"> for channel(%s): %d\n",           \
    20                                                                 alias_##task_name.port,vbase);      \
    21         srl_log_printf( TRACE, "*** &"#port" = %x\n\n", vbase );                                    \
    22         srl_exit();                                                                                 \
    23     }else                                                                                           \
    24         srl_log_printf( TRACE, "%s:%d: arg of %s for %s,from %s; &"#port" = %x\n\n",                \
    25                             __FILE__, __LINE__, APP_NAME, #task_name,#port, vbase );                \
     16    if( giet_vobj_get_vbase( APP_NAME , alias_##task_name.port, type, &vbase ) )                   \
     17    {                                                                                              \
     18        srl_log_printf( NONE, "\n[ERROR] in "#task_name" task :\n");                               \
     19        srl_log_printf( NONE, "          undefined port <"#port"> for channel(%s): %d\n",          \
     20                                                                alias_##task_name.port,vbase);     \
     21        srl_log_printf( TRACE, "*** &"#port" = %x\n\n", vbase );                                   \
     22        srl_exit();                                                                                \
     23    }else                                                                                          \
     24        srl_log_printf( TRACE, "%s:%d: arg of %s for %s,from %s; &"#port" = %x\n\n",               \
     25                            __FILE__, __LINE__, APP_NAME, #task_name,#port, vbase );               \
    2626    vbase;\
    2727})

  • soft/giet_vm/mappings/1c_4p_four.xml

    r214 r215  
    11<?xml version="1.0"?>
    22
    3 <mapping_info   signature = "0xdeadbeef" name = "1c_4p_four" clusters = "1" vspaces  = "4" >
     3<mapping_info   signature = "0xdeadbeef" name = "1c_4p_four" cluster_x = "1" cluster_y = "1" vspaces  = "4" >
    44
    55*** This section describes an instance of the "caba_vgsb_xicu_mmu" generic architecture
    … …  
    7171            <periph type = "TTY" psegname = "PSEG_TTY" channels  = "8" />
    7272            <periph type = "DMA" psegname = "PSEG_DMA" channels  = "1" />
     73            <periph type = "TIM" psegname = "PSEG_TIM" channels  = "4" />
     74            <periph type = "XICU" psegname = "PSEG_ICU" channels  = "5" />
    7375            <periph type = "FBF" psegname = "PSEG_FBF" />
    7476

  • soft/giet_vm/mappings/4c_1p_four.xml

    r214 r215  
    11<?xml version="1.0"?>
    22
    3 <mapping_info signature = "0xdeadbeef" name = "C4_P1_FOUR" clusters = "4" vspaces = "4" >
     3<mapping_info signature = "0xdeadbeef" name = "C4_P1_FOUR" cluster_x = "2" cluster_y = "2" vspaces = "4" >
    44
    55    <clusterset>
    … …  
    88
    99            <pseg name = "PSEG_RAM" type = "RAM"  base = "0x00000000" length = "0x00C00000" />
    10             <pseg name = "PSEG_ICU" type = "PERI" base = "0x00F00000" length = "0x00001000" />
     10            <pseg name = "PSEG_XICU" type = "PERI" base = "0x00F00000" length = "0x00002000" />
    1111            <pseg name = "PSEG_DMA" type = "PERI" base = "0x00F30000" length = "0x00008000" />
    1212
    … …  
    1717
    1818            <periph type = "DMA" psegname = "PSEG_DMA" channels = "1" />
     19            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
    1920
    2021        </cluster>
    … …  
    2223
    2324            <pseg name = "PSEG_RAM" type = "RAM"  base = "0x40000000" length = "0x00C00000" />
    24             <pseg name = "PSEG_ICU" type = "PERI" base = "0x40F00000" length = "0x00001000" />
     25            <pseg name = "PSEG_XICU" type = "PERI" base = "0x40F00000" length = "0x00002000" />
    2526            <pseg name = "PSEG_DMA" type = "PERI" base = "0x40F30000" length = "0x00008000" />
    2627
    … …  
    3132
    3233            <periph type = "DMA" psegname = "PSEG_DMA" channels = "1" />
     34            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
    3335
    3436        </cluster>
    … …  
    3638
    3739            <pseg name = "PSEG_RAM" type = "RAM"  base = "0x80000000" length = "0x00C00000" />
    38             <pseg name = "PSEG_ICU" type = "PERI" base = "0x80F00000" length = "0x00001000" />
     40            <pseg name = "PSEG_XICU" type = "PERI" base = "0x80F00000" length = "0x00002000" />
    3941            <pseg name = "PSEG_DMA" type = "PERI" base = "0x80F30000" length = "0x00008000" />
    4042
    … …  
    6971
    7072            <periph type = "DMA" psegname = "PSEG_DMA" channels = "1" />
     73            <periph type = "XICU" psegname = "PSEG_XICU" channels = "18" />
    7174            <periph type = "IOC" psegname = "PSEG_IOC" channels = "1" />
    7275            <periph type = "TTY" psegname = "PSEG_TTY" channels = "8" />
    … …  
    7881
    7982            <pseg name = "PSEG_RAM" type = "RAM"  base = "0xC0000000" length = "0x00C00000" />
    80             <pseg name = "PSEG_ICU" type = "PERI" base = "0xC0F00000" length = "0x00001000" />
     83            <pseg name = "PSEG_XICU" type = "PERI" base = "0xC0F00000" length = "0x00001000" />
    8184            <pseg name = "PSEG_DMA" type = "PERI" base = "0xC0F30000" length = "0x00008000" />
    8285
    … …  
    8790
    8891            <periph  type = "DMA" psegname  = "PSEG_DMA" channels = "1" />
     92            <periph type = "XICU" psegname = "PSEG_XICU" channels = "2" />
    8993        </cluster>
    9094    </clusterset>
    … …  
    135139*** On peut aussi définir un vseg factorisé en introduisant le CLUSTER_SIZE...
    136140
    137         <vseg name = "seg_icu_0"          vbase = "0x00F00000" mode = "__W_" clusterid = "0" psegname = "PSEG_ICU" >
     141        <vseg name = "seg_icu_0"          vbase = "0x00F00000" mode = "__W_" clusterid = "0" psegname = "PSEG_XICU" >
    138142            <vobj name = "icu_0"          type = "PERI" length  = "0x00001000" />
    139143        </vseg>
    140         <vseg name = "seg_icu_1"          vbase = "0x40F00000" mode = "__W_" clusterid = "1" psegname = "PSEG_ICU" >
     144        <vseg name = "seg_icu_1"          vbase = "0x40F00000" mode = "__W_" clusterid = "1" psegname = "PSEG_XICU" >
    141145            <vobj name = "icu_1"          type = "PERI" length  = "0x00001000" />
    142146        </vseg>
    143         <vseg name = "seg_icu_2"          vbase = "0x80F00000" mode = "__W_" clusterid = "2" psegname = "PSEG_ICU" >
     147        <vseg name = "seg_icu_2"          vbase = "0x80F00000" mode = "__W_" clusterid = "2" psegname = "PSEG_XICU" >
    144148            <vobj name = "icu_2"          type = "PERI" length  = "0x00001000" />
    145149        </vseg>
    146         <vseg name = "seg_icu_3"          vbase = "0xC0F00000" mode = "__W_" clusterid = "3" psegname = "PSEG_ICU" >
     150        <vseg name = "seg_icu_3"          vbase = "0xC0F00000" mode = "__W_" clusterid = "3" psegname = "PSEG_XICU" >
    147151            <vobj name = "icu_3"          type = "PERI" length  = "0x00001000" />
    148152        </vseg>

  • soft/giet_vm/mappings/exemple.xml

    r214 r215  
    33<mapping_info   signature = "0xdeadbeef"
    44                name     = "1C_4P_FOUR"
    5                 clusters = "1"
    6                 vspaces  = "4" >
     5                vspaces  = "4"
     6                cluster_x = "1"
     7                cluster_y = "1" >
    78
    89        <clusterset>
    … …  
    212213                                  channels  = "8" />
    213214
     215                         <periph  type      = "ICU"
     216                                  psegname  = "PSEG_ICU"
     217                                  channels  = "8" />
     218
    214219                         <periph  type      = "FBF"
    215220                                  psegname  = "PSEG_FBF" />

  • soft/giet_vm/memo/src/memo.cpp

    r212 r215  
    3939#include "memo.h"
    4040
    41 //#define MOVER_DEBUG 
     41//#define MOVER_DEBUG
    4242
    4343MeMo::MeMo( const std::string &filename,
    … …  
    258258    std::cout << std::hex << "mapping_info" << std::dec << std::endl
    259259              << " + signature = " << header->signature << std::endl
    260               << " + name      = " << header->name      << std::endl
     260              << " + name      = " << (char*)header->name      << std::endl
    261261              << " + clusters  = " << header->clusters  << std::endl
    262262              << " + psegs     = " << header->psegs     << std::endl
    … …  
    279279    {
    280280        std::cout << std::endl;
     281        //std::cout << vseg[vseg_id].psegid << std::endl;
    281282        std::cout << "global vseg "   << vseg[vseg_id].name << std::hex << std::endl
    282283                  << " + vbase    = " << vseg[vseg_id].vbase << std::endl

  • soft/giet_vm/sys/common.c

    r207 r215  
    158158void _puts(char* buffer)
    159159{
    160     unsigned int* tty_address = (unsigned int*)( (char*)&seg_tty_base +
    161                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     160    unsigned int* tty_address = (unsigned int*) &seg_tty_base;
    162161    unsigned int n;
    163162

  • soft/giet_vm/sys/drivers.c

    r213 r215  
    1717//
    1818// The following global parameters must be defined in the giet_config.h file:
    19 // - CLUSTER_IO_ID
    2019// - CLUSTER_SIZE
    2120// - NB_CLUSTERS   
    … …  
    4847
    4948#if !defined(NB_CLUSTERS)
    50 # error: You must define NB_CLUSTERS in 'giet_config.h' file
     49# error: You must define NB_CLUSTERS in the configs file
    5150#endif
    5251
    5352#if !defined(NB_PROCS_MAX)
    54 # error: You must define NB_PROCS_MAX in 'giet_config.h' file
     53# error: You must define NB_PROCS_MAX in the configs file
    5554#endif
    5655
    … …  
    6059
    6160#if !defined(CLUSTER_SIZE)
    62 # error: You must define CLUSTER_SIZE in 'giet_config.h' file
     61# error: You must define CLUSTER_SIZE in the configs file
    6362#endif
    6463
    6564#if !defined(NB_TTYS)
    66 # error: You must define NB_TTYS in 'giet_config.h' file
     65# error: You must define NB_TTYS in the configs file
    6766#endif
    6867
    … …  
    8483
    8584#if !defined(NB_IOCS)
    86 # error: You must define NB_IOCS in 'giet_config.h' file
     85# error: You must define NB_IOCS in the configs file
    8786#endif
    8887
    8988#if ( NB_IOCS > 1 )
    9089# error: NB_IOCS cannot be larger than 1
     90#endif
     91
     92#if !defined( USE_XICU )
     93# error: You must define USE_XICU in the configs file
     94#endif
     95
     96#if !defined( IOMMU_ACTIVE )
     97# error: You must define IOMMU_ACTIVE in the configs file
    9198#endif
    9299
    … …  
    98105//////////////////////////////////////////////////////////////////////////////
    99106// The timers can be implemented in a vci_timer component or in a vci_xicu
    100 // component (depending on the GIET_USE_XICU parameter).
     107// component (depending on the USE_XICU parameter).
    101108// There is one timer (or xicu) component per cluster.
    102109// There is two types of timers:
    … …  
    132139    if ( local_id >= NB_TIMERS_MAX + NB_PROCS_MAX ) return 1;
    133140
    134 #if GIET_USE_XICU
     141#if USE_XICU
    135142    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
    136143                                  (cluster_id * CLUSTER_SIZE) );
    … …  
    160167    if ( local_id >= NB_TIMERS_MAX + NB_PROCS_MAX ) return 1;
    161168
    162 #if GIET_USE_XICU
     169#if USE_XICU
    163170    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
    164171                                  (cluster_id * CLUSTER_SIZE) );
    … …  
    189196    if ( local_id >= NB_TIMERS_MAX + NB_PROCS_MAX ) return 1;
    190197
    191 #if GIET_USE_XICU
     198#if USE_XICU
    192199    unsigned int* timer_address = (unsigned int*)((char*)&seg_icu_base +
    193200                                  (cluster_id * (unsigned)CLUSTER_SIZE) );
    … …  
    260267    }
    261268
    262     unsigned int*       tty_address = (unsigned int*)( (char*)&seg_tty_base +
    263                                   (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     269    unsigned int*       tty_address = (unsigned int*) &seg_tty_base;
    264270
    265271    for (nwritten = 0; nwritten < length; nwritten++)
    … …  
    322328
    323329    // compute terminal base address
    324     unsigned int *tty_address = (unsigned int*)( (char*)&seg_tty_base +
    325                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     330    unsigned int *tty_address = (unsigned int*) &seg_tty_base;
    326331
    327332    *buffer = (unsigned char)tty_address[tty_id*TTY_SPAN + TTY_READ];
    … …  
    355360    unsigned int* icu_address = (unsigned int*)( (char*)&seg_icu_base +
    356361                                (cluster_id * (unsigned)CLUSTER_SIZE) );
    357 #if GIET_USE_XICU
     362#if USE_XICU
    358363    if ( is_timer ) icu_address[XICU_REG(XICU_MSK_PTI_ENABLE, proc_id)] = value;
    359364    else            icu_address[XICU_REG(XICU_MSK_HWI_ENABLE, proc_id)] = value;
    … …  
    381386    unsigned int* icu_address = (unsigned int*)( (char*)&seg_icu_base +
    382387                                (cluster_id * (unsigned)CLUSTER_SIZE) );
    383 #if GIET_USE_XICU
     388#if USE_XICU
    384389    unsigned int prio   = icu_address[XICU_REG(XICU_PRIO, proc_id)];
    385390    unsigned int pti_ok = (prio & 0x00000001);
    … …  
    420425        return 1;
    421426
    422     unsigned int* gcd_address = (unsigned int*)( (char*)&seg_gcd_base +
    423                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     427    unsigned int* gcd_address = (unsigned int*) &seg_gcd_base;
    424428
    425429    gcd_address[register_index] = value; // write word
    … …  
    438442        return 1;
    439443
    440     unsigned int* gcd_address = (unsigned int*)( (char*)&seg_gcd_base +
    441                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     444    unsigned int* gcd_address = (unsigned int*) &seg_gcd_base;
    442445
    443446    *buffer = gcd_address[register_index]; // read word
    … …  
    530533    if ( (unsigned int)user_vaddr & 0x3 ) return 1;
    531534
    532     unsigned int*       ioc_address = (unsigned int*)( (char*)&seg_ioc_base +
    533                                   (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     535    unsigned int*       ioc_address = (unsigned int*) &seg_ioc_base ;
    534536
    535537    unsigned int        block_size   = ioc_address[BLOCK_DEVICE_BLOCK_SIZE];
    … …  
    561563        if ( ix2 == 0 ) ppn_first = ppn;
    562564
    563         if ( GIET_IOMMU_ACTIVE )    // the user buffer must be remapped in the I/0 space
     565        if ( IOMMU_ACTIVE )    // the user buffer must be remapped in the I/0 space
    564566        {
    565567            // check buffer length < 2 Mbytes
    … …  
    588590
    589591    // compute buffer base address for IOC depending on IOMMU activation
    590     if ( GIET_IOMMU_ACTIVE ) addr = (_ioc_iommu_ix1) << 21 | (user_vaddr & 0xFFF);
     592    if ( IOMMU_ACTIVE ) addr = (_ioc_iommu_ix1) << 21 | (user_vaddr & 0xFFF);
    591593    else                     addr = (ppn_first << 12) | (user_vaddr & 0xFFF);
    592594
    … …  
    622624
    623625    // unmap the buffer from IOMMU page table if IOMMU is activated
    624     if ( GIET_IOMMU_ACTIVE )
    625     {
    626         unsigned int* iob_address = (unsigned int*)( (char*)&seg_iob_base +
    627                                     (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     626    if ( IOMMU_ACTIVE )
     627    {
     628        unsigned int* iob_address = (unsigned int*) &seg_iob_base;
    628629
    629630        for ( ix2 = 0 ; ix2 < _ioc_iommu_npages ; ix2++ )
    … …  
    691692{
    692693    // get IOC base address
    693     unsigned int* ioc_address = (unsigned int*)( (char*)&seg_ioc_base +
    694                                 (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     694    unsigned int* ioc_address = (unsigned int*) &seg_ioc_base;
    695695
    696696    *status = ioc_address[BLOCK_DEVICE_STATUS]; // read status & reset IRQ
    … …  
    891891
    892892    // compute frame buffer pbase address
    893     unsigned int fb_vaddr = (unsigned int)&seg_fbf_base +
    894                             (CLUSTER_IO_ID * (unsigned int)CLUSTER_SIZE) + offset;
     893    unsigned int fb_vaddr = (unsigned int)&seg_fbf_base + offset;
    895894
    896895    ko = _v2p_translate( (page_table_t*)user_ptab,
    … …  
    962961        if ( ix2 == 0 ) ppn_first = ppn;
    963962
    964         if ( GIET_IOMMU_ACTIVE )    // the user buffer must be remapped in the I/0 space
     963        if ( IOMMU_ACTIVE )    // the user buffer must be remapped in the I/0 space
    965964        {
    966965            // check buffer length < 2 Mbytes
    … …  
    10711070   
    10721071    // unmap the buffer from IOMMU page table if IOMMU is activated
    1073     if ( GIET_IOMMU_ACTIVE )
    1074     {
    1075         unsigned int* iob_address = (unsigned int*)( (char*)&seg_iob_base +
    1076                                     (CLUSTER_IO_ID * (unsigned)CLUSTER_SIZE) );
     1072    if ( IOMMU_ACTIVE )
     1073    {
     1074        unsigned int* iob_address = (unsigned int*) &seg_iob_base;
    10771075
    10781076        unsigned int  ix1         = _dma_iommu_ix1 + dma_id;

  • soft/giet_vm/sys/irq_handler.c

    r213 r215  
    1818#include <ctx_handler.h>
    1919#include <hwr_mapping.h>
     20
     21#if NB_TIMERS_MAX
     22extern volatile unsigned char _user_timer_event[NB_CLUSTERS*NB_TIMERS_MAX] ;
     23#endif
    2024
    2125///////////////////////////////////////////////////////////////////////////////////

  • soft/giet_vm/sys/kernel_init.c

    r207 r215  
    4848unsigned int                    _idle_stack[NB_CLUSTERS*NB_PROCS_MAX*64];
    4949
     50void _sys_exit()
     51{
     52    while(1);
     53}
     54
    5055//////////////////////////////////////////////////////////////////////////////////
    5156// This function is the entry point for the last step of the boot sequence.
    … …  
    127132    unsigned int pti_mask = 0;
    128133
     134    unsigned int isr_switch_channel = 0xFFFFFFFF;
     135
    129136    for ( irq_id = 0 ; irq_id < 32 ; irq_id++ )
    130137    {
    … …  
    136143             hwi_mask = hwi_mask | 0x1<< irq_id;
    137144        }
    138         else if ( (isr == ISR_SWITCH) || (isr == ISR_TIMER) )
     145        else if ( (isr == ISR_SWITCH) )
    139146        {
     147            pti_mask = pti_mask | 0x1<< irq_id;
     148            isr_switch_channel = irq_id;
     149        }
     150        else if ( (isr == ISR_TIMER) )
     151        {
    140152            pti_mask = pti_mask | 0x1<< irq_id;
    141153        }
    … …  
    159171    if ( tasks > 1 )
    160172    {
     173        if(isr_switch_channel == 0xFFFFFFFF)
     174        {
     175            _puts("\n[GIET ERROR] ISR_SWITCH not found on proc ");
     176            _putd( proc_id);
     177            _puts("\n");
     178            _sys_exit();
     179        }
    161180        _timer_start( cluster_id,
    162                       proc_id,
     181                      isr_switch_channel,
    163182                      GIET_TICK_VALUE );
    164183       

  • soft/giet_vm/sys/sys_handler.c

    r207 r215  
    139139}
    140140
    141 /////////////////////////////////////////////////////////////////////////////
    142 // _vobj_get_vbase()
    143 // This function writes in vobj_buffer the virtual base address of a vobj
    144 // identified by the (vspace_name / vobj_name ) couple.
    145 // The vobj_type argument is redundant, and for checking purpose.
    146 // returns 0: success, else: failed.
    147 /////////////////////////////////////////////////////////////////////////////
    148 unsigned int _vobj_get_vbase( char*                     vspace_name,
    149                               char*                     vobj_name,
    150                               unsigned int      vobj_type,
    151                               unsigned int* vobj_vaddr )
     141int _get_vobj( char* vspace_name, char* vobj_name, unsigned int vobj_type, mapping_vobj_t** res_vobj)
    152142{
    153143    mapping_header_t* header = (mapping_header_t*)&seg_mapping_base;
    … …  
    175165                        return -1;                                                      //wrong type
    176166
    177                     *vobj_vaddr = (unsigned int)vobj[vobj_id].vaddr;
     167                    *res_vobj = &vobj[vobj_id];
     168
    178169                    return 0;
    179170                }
    … …  
    182173    }
    183174    return -2;          //not found
    184 }
    185 
     175
     176}
     177/////////////////////////////////////////////////////////////////////////////
     178// _vobj_get_vbase()
     179// This function writes in vobj_vaddr the virtual base address of a vobj
     180// identified by the (vspace_name / vobj_name ) couple.
     181// The vobj_type argument is here only for the purpose of checking .
     182// returns 0: success, else: failed.
     183/////////////////////////////////////////////////////////////////////////////
     184unsigned int _vobj_get_vbase( char*                     vspace_name,
     185                              char*                     vobj_name,
     186                              unsigned int      vobj_type,
     187                              unsigned int* vobj_vaddr )
     188{
     189    mapping_vobj_t*   res_vobj;
     190    unsigned int ret;
     191    if( (ret = _get_vobj(vspace_name, vobj_name, vobj_type, &res_vobj)) )
     192    {
     193        return ret;
     194    }
     195   
     196    *vobj_vaddr = res_vobj->vaddr;
     197
     198    return 0;
     199}
     200
     201/////////////////////////////////////////////////////////////////////////////
     202// _vobj_get_length()
     203// This function writes in vobj_length the virtual base address of a vobj
     204// identified by the (vspace_name / vobj_name ) couple.
     205// The vobj_type argument is here only for the purpose of checking .
     206// returns 0: success, else: failed.
     207/////////////////////////////////////////////////////////////////////////////
     208unsigned int _vobj_get_length(char*                     vspace_name,
     209                              char*                     vobj_name,
     210                              unsigned int      vobj_type,
     211                              unsigned int* vobj_length )
     212{
     213
     214    mapping_vobj_t*   res_vobj;
     215    unsigned int ret;
     216    if( (ret = _get_vobj(vspace_name, vobj_name, vobj_type, &res_vobj)) )
     217    {
     218        return ret;
     219    }
     220   
     221    *vobj_length = res_vobj->length;
     222
     223    return 0;
     224}

  • soft/giet_vm/xml/mapping_info.h

    r200 r215  
    7171enum periphType
    7272{
    73     PERIPH_TYPE_IOC   = 0,
    74     PERIPH_TYPE_TTY   = 1,
    75     PERIPH_TYPE_TIM   = 2,
     73    PERIPH_TYPE_ICU   = 0,
     74    PERIPH_TYPE_TIM   = 1,
     75    PERIPH_TYPE_XICU  = 2,
    7676    PERIPH_TYPE_DMA   = 3,
    77     PERIPH_TYPE_FBF   = 4,
    78     PERIPH_TYPE_NIC   = 5,
    79     PERIPH_TYPE_IOB   = 6,
     77    PERIPH_TYPE_IOC   = 4,
     78    PERIPH_TYPE_TTY   = 5,
     79    PERIPH_TYPE_FBF   = 6,
     80    PERIPH_TYPE_NIC   = 7,
     81    PERIPH_TYPE_IOB   = 8,
    8082};
    8183
    … …  
    9294    unsigned int    signature;      // must contain MAPPING_SIGNATURE
    9395        unsigned int    clusters;           // number of clusters
     96        unsigned int    cluster_x;          // number of cluster on the abcsisse axe
     97        unsigned int    cluster_y;          // number of cluster on the ordinate axe
    9498        unsigned int    globals;                // number of vsegs mapped in all vspaces
    9599        unsigned int    vspaces;                // number of virtual spaces

  • soft/giet_vm/xml/xml_driver.c

    r204 r215  
    5757    const char* periph_type[] =
    5858    {
     59        "ICU",
     60        "TIM",
     61        "XICU",
     62        "DMA",
    5963        "IOC",
    6064        "TTY",
    61         "TIM",
    62         "DMA",
    6365        "FBF",
    6466        "NIC",
    … …  
    220222    fprintf( fpout, "<mapping_info signature = \"0x%x\" ", header->signature);
    221223    fprintf( fpout, " name = \"%s\" ", header->name);
    222     fprintf( fpout, " clusters = \"%d\" ", header->clusters);
     224    fprintf( fpout, " cluster_x = \"%d\" ", header->cluster_x);
     225    fprintf( fpout, " cluster_y = \"%d\" ", header->cluster_y);
    223226    fprintf( fpout, " vspaces = \"%d\" >\n\n", header->vspaces);
    224227
    … …  
    241244    ///////////////////// processors /////////////////////////////////////////////
    242245
     246        unsigned int proc_index = 0;
    243247        for ( proc_id = cluster[cluster_id].proc_offset ;
    244248              proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs ;
    245249              proc_id++ )
    246250        {
    247             fprintf( fpout, "            <proc index = \"%d\" >\n", proc_id);
     251            fprintf( fpout, "            <proc index = \"%d\" >\n", proc_index);
    248252            for ( irq_id = proc[proc_id].irq_offset ;
    249253                  irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs ;

  • soft/giet_vm/xml/xml_parser.c

    r206 r215  
    8686unsigned int            vobj_count     = 0;
    8787
    88 ///////////////////////////////////////////////////////////////////////
     88
     89/////////////////////////
     90// found peripheral
     91/////////////////////////
     92char found_timer = 0;
     93char found_icu = 0;
     94char found_xicu = 0;
     95char found_dma = 0;
     96
     97
     98//////////////////////////////////
     99//needed to generate map_config.ld
     100//////////////////////////////////
     101unsigned int cluster_y              = 0;
     102unsigned int cluster_x              = 0;
     103unsigned int nb_proc_max            = 0; // max number of processors per cluster
     104unsigned int nb_timer_channel_max   = 0; // max number of user timer
     105unsigned int nb_dma_channel_max     = 0;
     106unsigned int nb_tty_channel         = 0;
     107unsigned int nb_ioc_channel         = 0;
     108unsigned int nb_nic_channel         = 0;
     109unsigned int io_mmu_active          = 0;
     110unsigned int use_xicu               = 0xFFFFFFFF;
     111
     112
     113//////////////////////////////////
     114//needed to generate giet_vseg.ld
     115//////////////////////////////////
     116
     117//kernel and boot code
     118unsigned int kernel_code_base    = 0x80000000;  /* kernel code */
     119unsigned int kernel_data_base    = 0x80010000;  /* system cacheable data */
     120unsigned int kernel_uncdata_base = 0x80080000;  /* system uncacheable data */
     121unsigned int kernel_init_base    = 0x80090000;  /* system init entry */
     122
     123unsigned int boot_code_base      = 0xBFC00000;   /* boot code */
     124unsigned int boot_stack_base     = 0xBFC08000;  /* boot temporary stack */
     125unsigned int boot_mapping_base   = 0xBFC0C000;  /* mapping_info blob */
     126
     127//periphs
     128unsigned int tim_base_offset = 0xFFFFFFFF;
     129unsigned int tty_base_offset = 0xFFFFFFFF;
     130unsigned int dma_base_offset = 0xFFFFFFFF;
     131unsigned int ioc_base_offset = 0xFFFFFFFF;
     132unsigned int fbf_base_offset = 0xFFFFFFFF;
     133unsigned int icu_base_offset = 0xFFFFFFFF;
     134unsigned int gcd_base_offset = 0xFFFFFFFF;
     135unsigned int iob_base_offset = 0xFFFFFFFF;
     136
     137
     138//////////////////////////////////////////////////////////////////////
    89139// This arrray is useful to build a temporary list of vobj references.
    90140// The struct vobj_ref_s is formed by a vspace_name and a vobj_name.
    91141// This array is used to set the attribute vobj_id of a cp_port
    92142// once all the vspace have been parsed.
    93 
     143/////////////////////////////////////////////////////////////////////
    94144typedef struct vobj_ref_s
    95145{
    … …  
    159209    char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName);
    160210
     211   
    161212    if ( string == NULL )  // missing argument
    162213    {
    … …  
    166217    else
    167218    {
     219        //we read only string smaller than 32 byte
     220        if(strlen(string) > 32)
     221        {
     222            printf("[XML ERROR] all strings must be less than 32 bytes\n");
     223            exit(1);
     224        }
     225
    168226        *ok = 1;
    169227        return string;
    … …  
    181239    for ( pseg_id = pseg_min ; pseg_id < pseg_max ; pseg_id++ )
    182240    {
    183         if ( strcmp(pseg[pseg_id]->name, pseg_name) == 0 ) return pseg_id;
     241        if ( strcmp(pseg[pseg_id]->name, pseg_name) == 0 )
     242        {
     243            return pseg_id;
     244        }
    184245    }
    185246    return -1;
    … …  
    219280    return -1;
    220281}
    221 
    222 ///////////////////////////////////////////
    223 void cpPortNode ( xmlTextReaderPtr reader )
    224 ///////////////////////////////////////////
    225 {
    226     char*           str;
    227     unsigned int    ok;
    228 
    229     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    230 
    231     if ( cp_port_index >= MAX_CP_PORTS )
    232     {
    233         printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS);
    234     }
    235 
    236 #if XML_PARSER_DEBUG
    237 printf("\n  port %d\n", cp_port_index);
    238 #endif
    239 
    240     cp_port[cp_port_index] = (mapping_cp_port_t*)malloc(sizeof(mapping_cp_port_t));
    241     cp_port_vobj_ref[cp_port_index] = (vobj_ref_t*)malloc(sizeof(vobj_ref_t));
    242 
    243 
    244    
    245     ///////// get direction attribute
    246     str = getStringValue( reader, "direction", &ok );
    247     if ( ok )
    248     {
    249 #if XML_PARSER_DEBUG
    250 printf("      direction = %s\n", str);
    251 #endif
    252         if      ( strcmp(str, "TO_COPROC")   ==  0 ) cp_port[cp_port_index]->direction = PORT_TO_COPROC;
    253         else if ( strcmp(str, "FROM_COPROC") ==  0 ) cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
    254         else
    255         {
    256             printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
    257                    cp_port_index, cluster_index);
    258             exit(1);
    259         }
    260     } 
    261     else
    262     {
    263         printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
    264                cp_port_index, cluster_index);
    265         exit(1);
    266     }
    267    
    268     /////////// get vspacename attribute
    269     str = getStringValue( reader, "vspacename", &ok );
    270 #if XML_PARSER_DEBUG
    271 printf("      vspacename = %s\n", str);
    272 #endif
    273     if ( ok )
    274     {
    275         strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
    276     }
    277     else
    278     {
    279         printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
    280                cp_port_index, cluster_index);
    281         exit(1);
    282     }
    283 
    284     /////////// get vobjname attribute
    285     str = getStringValue( reader, "vobjname", &ok );
    286 #if XML_PARSER_DEBUG
    287 printf("      vobjname = %s\n", str);
    288 #endif
    289     if ( ok )
    290     {
    291         strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
    292     }
    293     else
    294     {
    295         printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
    296                cp_port_index, cluster_index);
    297         exit(1);
    298     }
    299    
    300     cp_port_index++;
    301     cp_port_loc_index++;
    302 
    303 } // end cpPortNode()
    304 
    305 ///////////////////////////////////////////
    306 void periphNode ( xmlTextReaderPtr reader )
    307 ///////////////////////////////////////////
    308 {
    309     char*           str;
    310     unsigned int    value;
    311     unsigned int        ok;
    312 
    313     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    314 
    315     if ( periph_index >= MAX_PERIPHS )
    316     {
    317         printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
    318     }
    319 
    320 #if XML_PARSER_DEBUG
    321 printf("\n  periph %d\n", periph_index);
    322 #endif
    323 
    324     periph[periph_index] = (mapping_periph_t*)malloc(sizeof(mapping_periph_t));
    325 
    326     /////////// get type attribute
    327     str = getStringValue( reader, "type", &ok );
    328     if ( ok )
    329     {
    330 #if XML_PARSER_DEBUG
    331 printf("      type     = %s\n", str);
    332 #endif
    333         unsigned int error = 0;
    334  
    335         // The TTY, IOC, NIC, FBF and IOB peripherals cannot be replicated
    336         if      ( strcmp( str, "IOC" ) == 0 )
    337         {
    338             periph[periph_index]->type = PERIPH_TYPE_IOC;
    339             if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
    340             else  error = 1;
    341         }
    342         else if ( strcmp( str, "TTY" ) == 0 )
    343         {
    344             periph[periph_index]->type = PERIPH_TYPE_TTY;
    345             if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
    346             else  error = 1;
    347         }
    348         else if ( strcmp( str, "FBF" ) == 0 )
    349         {
    350             periph[periph_index]->type = PERIPH_TYPE_FBF;
    351             if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
    352             else  error = 1;
    353         }
    354         else if ( strcmp( str, "NIC" ) == 0 )
    355         {
    356             periph[periph_index]->type = PERIPH_TYPE_NIC;
    357             if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
    358             else  error = 1;
    359         }
    360         // The TIM, DMA and IOB peripherals can be replicated in several clusters
    361         else if ( strcmp( str, "TIM" ) == 0 )
    362         {
    363             periph[periph_index]->type = PERIPH_TYPE_TIM;
    364         }
    365         else if ( strcmp( str, "DMA" ) == 0 )
    366         {
    367             periph[periph_index]->type = PERIPH_TYPE_DMA;
    368         }
    369         else if ( strcmp( str, "IOB" ) == 0 )
    370         {
    371             periph[periph_index]->type = PERIPH_TYPE_IOB;
    372         }
    373         else
    374         {
    375             printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
    376                    periph_loc_index, cluster_index);
    377             exit(1);
    378         }
    379     }
    380     else
    381     {
    382         printf("[XML ERROR] missing <type> for peripheral  %d in cluster %d\n",
    383                periph_loc_index, cluster_index);
    384         exit(1);
    385     }
    386 
    387     ///////// get channels attribute (optionnal : 1 if missing)
    388     value = getIntValue( reader, "channels", &ok );
    389     if ( ok )
    390     {
    391 #if XML_PARSER_DEBUG
    392 printf("      channels = %d\n", value);
    393 #endif
    394         periph[periph_index]->channels = value;
    395     }
    396     else
    397     {
    398         periph[periph_index]->channels = 1;
    399     }
    400 
    401     /////////// get psegname attribute
    402     str = getStringValue(reader,"psegname", &ok);
    403     if ( ok == 0 )
    404     {
    405         printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
    406                  coproc_index, cluster_index);
    407         exit(1);
    408     }
    409 
    410     /////////// set psegid attribute
    411     int index = getPsegId( cluster_index, str );
    412     if ( index >= 0 )
    413     {
    414 #if XML_PARSER_DEBUG
    415 printf("      clusterid = %d\n", cluster_index);
    416 printf("      psegname  = %s\n", str);
    417 printf("      psegid    = %d\n", index);
    418 #endif
    419         periph[periph_index]->psegid = index;
    420         assert(pseg[index]->type == PSEG_TYPE_PERI &&
    421         "peripheral psegname attribute must refer to a pseg of type PERI" );
    422     }
    423     else             
    424     {
    425         printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n",
    426                    periph_loc_index, cluster_index, str );
    427         exit(1);
    428     } 
    429    
    430     periph_index++;
    431     periph_loc_index++;
    432 
    433 } // end periphNode
    434 
    435 /////////////////////////////////////////
    436 void coprocNode ( xmlTextReaderPtr reader )
    437 /////////////////////////////////////////
    438 {
    439     char*           str;
    440     unsigned int        ok;
    441 
    442     cp_port_loc_index = 0;
    443 
    444     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    445 
    446     if ( coproc_index >= MAX_COPROCS )
    447     {
    448         printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
    449     }
    450 
    451 #if XML_PARSER_DEBUG
    452 printf("\n  coproc %d\n", coproc_index);
    453 #endif
    454 
    455     coproc[coproc_index] = (mapping_coproc_t*)malloc(sizeof(mapping_coproc_t));
    456 
    457     /////////// get name attribute
    458     str = getStringValue( reader, "name", &ok );
    459     if ( ok )
    460     {
    461 #if XML_PARSER_DEBUG
    462 printf("      name = %s\n", str);
    463 #endif
    464         strncpy(coproc[coproc_index]->name, str, 31);
    465     }
    466     else
    467     {
    468         printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
    469                coproc_index, cluster_index);
    470         exit(1);
    471     }
    472 
    473     /////////// get psegname attribute
    474     str = getStringValue(reader,"psegname", &ok);
    475     if ( ok == 0 )
    476     {
    477         printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
    478                  coproc_index, cluster_index);
    479         exit(1);
    480     }
    481 
    482     /////////// set psegid attribute
    483     int index = getPsegId( cluster_index, str );
    484     if ( index >= 0 )
    485     {
    486 #if XML_PARSER_DEBUG
    487 printf("      clusterid = %d\n", cluster_index);
    488 printf("      psegname  = %s\n", str);
    489 printf("      psegid    = %d\n", index);
    490 #endif
    491         coproc[coproc_index]->psegid = index;
    492         assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" );
    493     }
    494     else             
    495     {
    496         printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n",
    497                    coproc_index, cluster_index, str );
    498         exit(1);
    499     } 
    500 
    501     ////////// set port_offset
    502     coproc[coproc_index]->port_offset = cp_port_index;
    503 
    504 #if XML_PARSER_DEBUG
    505 printf("      port_offset = %d\n", cp_port_index);
    506 #endif
    507 
    508     int status = xmlTextReaderRead(reader);
    509     while ( status == 1 )
    510     {
    511         const char* tag = (const char*)xmlTextReaderConstName(reader);
    512 
    513         if      ( strcmp(tag, "port")     == 0 ) cpPortNode(reader);
    514         else if ( strcmp(tag, "#text")    == 0 ) { }
    515         else if ( strcmp(tag, "#comment") == 0 ) { }
    516         else if ( strcmp(tag, "coproc")   == 0 )
    517         {
    518             coproc[coproc_index]->ports = cp_port_loc_index;
    519             coproc_loc_index++;
    520             coproc_index++;
    521             return;
    522         }
    523         else
    524         {
    525             printf("[XML ERROR] Unknown tag %s",tag);
    526             exit(1);
    527         }
    528         status = xmlTextReaderRead ( reader );
    529     }
    530 } // end coprocNode()
    531 
    532 ///////////////////////////////////////
    533 void irqNode( xmlTextReaderPtr reader )
    534 ///////////////////////////////////////
    535 {
    536     unsigned int        ok;
    537     unsigned int        value;
    538     char*               str;
    539 
    540     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    541 
    542     if ( irq_index >= MAX_IRQS )
    543     {
    544         printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS);
    545     }
    546 
    547 #if XML_PARSER_DEBUG
    548 printf("     irq %d\n", irq_loc_index);
    549 #endif
    550 
    551     irq[irq_index] = (mapping_irq_t*)malloc(sizeof(mapping_irq_t));
    552 
    553     ///////// get type attribute
    554     str = getStringValue(reader,"type", &ok);
    555     if ( ok )
    556     {
    557 #if XML_PARSER_DEBUG
    558 printf("        type    = %s\n", str);
    559 #endif
    560         if      ( strcmp(str, "HARD") == 0 ) irq[irq_index]->type = 0;
    561         else if ( strcmp(str, "SOFT") == 0 ) irq[irq_index]->type = 1;
    562         else
    563         {
    564             printf("[XML ERROR] undefined IRQ  <type> for processor %d in cluster %d\n",
    565                    cluster_index, proc_loc_index );
    566             exit(1);
    567         }
    568     } 
    569     else
    570     {
    571         printf("[XML ERROR] missing IRQ <type> for processor %d in cluster %d\n",
    572                cluster_index, proc_loc_index );
    573         exit(1);
    574     }
    575 
    576     ///////// get icuid attribute
    577     value = getIntValue(reader, "icuid", &ok);
    578     if ( ok )
    579     {
    580 #if XML_PARSER_DEBUG
    581 printf("        icuid   = %d\n", value);
    582 #endif
    583         irq[irq_index]->icuid = value;
    584         if ( value >= 32 )
    585         {
    586             printf("[XML ERROR] IRQ <icuid> too large for processor %d in cluster %d\n",
    587                    cluster_index, proc_loc_index );
    588             exit(1);
    589         }
    590     }
    591     else
    592     {
    593         printf("[XML ERROR] missing IRQ <icuid> for processor %d in cluster %d\n",
    594                cluster_index, proc_loc_index );
    595         exit(1);
    596     }
    597 
    598     ///////// get isr attribute
    599     str = getStringValue(reader,"isr", &ok);
    600     if ( ok )
    601     {
    602 #if XML_PARSER_DEBUG
    603 printf("        isr     = %s\n", str);
    604 #endif
    605         if      ( strcmp(str, "ISR_SWITCH" ) == 0 ) irq[irq_index]->isr = ISR_SWITCH;
    606         else if ( strcmp(str, "ISR_IOC"    ) == 0 ) irq[irq_index]->isr = ISR_IOC;
    607         else if ( strcmp(str, "ISR_DMA"    ) == 0 ) irq[irq_index]->isr = ISR_DMA;
    608         else if ( strcmp(str, "ISR_TTY"    ) == 0 ) irq[irq_index]->isr = ISR_TTY;
    609         else if ( strcmp(str, "ISR_TIMER"  ) == 0 ) irq[irq_index]->isr = ISR_TIMER;
    610         else
    611         {
    612             printf("[XML ERROR] illegal IRQ <isr> for processor %d in cluster %d\n",
    613                    cluster_index, proc_loc_index );
    614             exit(1);
    615         }
    616 #if XML_PARSER_DEBUG
    617 printf("        isrnum  = %d\n", irq[irq_index]->isr);
    618 #endif
    619     } 
    620     else
    621     {
    622         printf("[XML ERROR] missing IRQ <isr> for processor %d in cluster %d\n",
    623                cluster_index, proc_loc_index );
    624         exit(1);
    625     }
    626 
    627     ///////// get channel attribute (optionnal : 0 if missing)
    628     value = getIntValue(reader, "channel", &ok);
    629     if ( ok )
    630     {
    631 #if XML_PARSER_DEBUG
    632 printf("        channel = %d\n", value);
    633 #endif
    634         irq[irq_index]->channel = value;
    635     }
    636     else
    637     {
    638         irq[irq_index]->channel = 0;
    639     }
    640 
    641     irq_index++;
    642     irq_loc_index++;
    643 
    644 } // end irqNode
    645 
    646 /////////////////////////////////////////
    647 void procNode ( xmlTextReaderPtr reader )
    648 /////////////////////////////////////////
    649 {
    650     unsigned int        ok;
    651     unsigned int    value;
    652 
    653     irq_loc_index = 0;
    654 
    655     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    656 
    657     if ( proc_index >= MAX_PROCS )
    658     {
    659         printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
    660     }
    661 
    662 #if XML_PARSER_DEBUG
    663 printf("\n  proc %d\n", proc_index);
    664 #endif
    665 
    666     proc[proc_index] = (mapping_proc_t*)malloc(sizeof(mapping_proc_t));
    667 
    668 
    669     /////////// get index attribute (optional)
    670     value = getIntValue(reader,"index",&ok);
    671     if ( ok && (value != proc_loc_index) )
    672     {
    673             printf("[XML ERROR] wrong proc index / expected value is %d",
    674                 proc_loc_index);
    675             exit(1);
    676     }
    677 
    678     ////////// set irq_offset attribute
    679     proc[proc_index]->irq_offset = irq_index;
    680 
    681 #if XML_PARSER_DEBUG
    682 printf("    irq_offset = %d\n", irq_index);
    683 #endif
    684 
    685     int status = xmlTextReaderRead(reader);
    686     while ( status == 1 )
    687     {
    688         const char* tag = (const char*)xmlTextReaderConstName(reader);
    689 
    690         if      ( strcmp(tag, "irq")      == 0 ) irqNode(reader);
    691         else if ( strcmp(tag, "#text")    == 0 ) { }
    692         else if ( strcmp(tag, "#comment") == 0 ) { }
    693         else if ( strcmp(tag, "proc")     == 0 )
    694         {
    695             proc[proc_index]->irqs = irq_loc_index;
    696             proc_loc_index++;
    697             proc_index++;
    698             return;
    699         }
    700         else
    701         {
    702             printf("[XML ERROR] Unknown tag %s",tag);
    703             exit(1);
    704         }
    705         status = xmlTextReaderRead ( reader );
    706     }
    707 } // end procNode()
    708 
    709282
    710283/////////////////////////////////////////
    … …  
    1321894} // end vspaceNode()
    1322895
     896///////////////////////////////////////////
     897void cpPortNode ( xmlTextReaderPtr reader )
     898///////////////////////////////////////////
     899{
     900    char*           str;
     901    unsigned int    ok;
     902
     903    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
     904
     905    if ( cp_port_index >= MAX_CP_PORTS )
     906    {
     907        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS);
     908    }
     909
     910#if XML_PARSER_DEBUG
     911printf("\n  port %d\n", cp_port_index);
     912#endif
     913
     914    cp_port[cp_port_index] = (mapping_cp_port_t*)malloc(sizeof(mapping_cp_port_t));
     915    cp_port_vobj_ref[cp_port_index] = (vobj_ref_t*)malloc(sizeof(vobj_ref_t));
     916
     917
     918   
     919    ///////// get direction attribute
     920    str = getStringValue( reader, "direction", &ok );
     921    if ( ok )
     922    {
     923#if XML_PARSER_DEBUG
     924printf("      direction = %s\n", str);
     925#endif
     926        if      ( strcmp(str, "TO_COPROC")   ==  0 ) cp_port[cp_port_index]->direction = PORT_TO_COPROC;
     927        else if ( strcmp(str, "FROM_COPROC") ==  0 ) cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
     928        else
     929        {
     930            printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
     931                   cp_port_index, cluster_index);
     932            exit(1);
     933        }
     934    } 
     935    else
     936    {
     937        printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
     938               cp_port_index, cluster_index);
     939        exit(1);
     940    }
     941   
     942    /////////// get vspacename attribute
     943    str = getStringValue( reader, "vspacename", &ok );
     944#if XML_PARSER_DEBUG
     945printf("      vspacename = %s\n", str);
     946#endif
     947    if ( ok )
     948    {
     949        strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
     950    }
     951    else
     952    {
     953        printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
     954               cp_port_index, cluster_index);
     955        exit(1);
     956    }
     957
     958    /////////// get vobjname attribute
     959    str = getStringValue( reader, "vobjname", &ok );
     960#if XML_PARSER_DEBUG
     961printf("      vobjname = %s\n", str);
     962#endif
     963    if ( ok )
     964    {
     965        strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
     966    }
     967    else
     968    {
     969        printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
     970               cp_port_index, cluster_index);
     971        exit(1);
     972    }
     973   
     974    cp_port_index++;
     975    cp_port_loc_index++;
     976
     977} // end cpPortNode()
     978
     979///////////////////////////////////////////
     980void periphNode ( xmlTextReaderPtr reader )
     981///////////////////////////////////////////
     982{
     983    char*           str;
     984    unsigned int    value;
     985    unsigned int        ok;
     986
     987    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
     988
     989    if ( periph_index >= MAX_PERIPHS )
     990    {
     991        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
     992    }
     993
     994#if XML_PARSER_DEBUG
     995printf("\n  periph %d\n", periph_index);
     996#endif
     997
     998    periph[periph_index] = (mapping_periph_t*)malloc(sizeof(mapping_periph_t));
     999
     1000
     1001    ///////// get channels attribute (optionnal : 1 if missing)
     1002    value = getIntValue( reader, "channels", &ok );
     1003    if ( ok )
     1004    {
     1005#if XML_PARSER_DEBUG
     1006printf("      channels = %d\n", value);
     1007#endif
     1008        periph[periph_index]->channels = value;
     1009    }
     1010    else
     1011    {
     1012        periph[periph_index]->channels = 1;
     1013    }
     1014
     1015    /////////// get psegname attribute
     1016    str = getStringValue(reader,"psegname", &ok);
     1017    if ( ok == 0 )
     1018    {
     1019        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
     1020                 coproc_index, cluster_index);
     1021        exit(1);
     1022    }
     1023
     1024    /////////// set psegid attribute
     1025    int index = getPsegId( cluster_index, str );
     1026    if ( index >= 0 )
     1027    {
     1028#if XML_PARSER_DEBUG
     1029printf("      clusterid = %d\n", cluster_index);
     1030printf("      psegname  = %s\n", str);
     1031printf("      psegid    = %d\n", index);
     1032#endif
     1033        periph[periph_index]->psegid = index;
     1034        assert(pseg[index]->type == PSEG_TYPE_PERI &&
     1035        "peripheral psegname attribute must refer to a pseg of type PERI" );
     1036    }
     1037    else             
     1038    {
     1039        printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n",
     1040                   periph_loc_index, cluster_index, str );
     1041        exit(1);
     1042    } 
     1043
     1044
     1045    /////////// get type attribute
     1046    str = getStringValue( reader, "type", &ok );
     1047    if ( ok )
     1048    {
     1049#if XML_PARSER_DEBUG
     1050printf("      type     = %s\n", str);
     1051#endif
     1052        unsigned int error = 0;
     1053 
     1054        // The TTY, IOC, NIC, FBF and IOB peripherals cannot be replicated
     1055        // one per architecture
     1056        if      ( strcmp( str, "IOC" ) == 0 )
     1057        {
     1058            periph[periph_index]->type = PERIPH_TYPE_IOC;
     1059            if ( header->ioc_clusterid == 0xFFFFFFFF) header->ioc_clusterid = cluster_index;
     1060            else  error = 1;
     1061
     1062            ioc_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1063            nb_ioc_channel = periph[periph_index]->channels;
     1064        }
     1065        else if ( strcmp( str, "TTY" ) == 0 )
     1066        {
     1067            periph[periph_index]->type = PERIPH_TYPE_TTY;
     1068            if ( header->tty_clusterid == 0xFFFFFFFF) header->tty_clusterid = cluster_index;
     1069            else  error = 1;
     1070
     1071            tty_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1072            nb_tty_channel = periph[periph_index]->channels;
     1073        }
     1074        else if ( strcmp( str, "FBF" ) == 0 )
     1075        {
     1076            periph[periph_index]->type = PERIPH_TYPE_FBF;
     1077            if ( header->fbf_clusterid == 0xFFFFFFFF) header->fbf_clusterid = cluster_index;
     1078            else  error = 1;
     1079
     1080            fbf_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1081        }
     1082        else if ( strcmp( str, "NIC" ) == 0 )
     1083        {
     1084            periph[periph_index]->type = PERIPH_TYPE_NIC;
     1085            if ( header->nic_clusterid == 0xFFFFFFFF) header->nic_clusterid = cluster_index;
     1086            else  error = 1;
     1087
     1088            //nic_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1089            nb_nic_channel = periph[periph_index]->channels;
     1090        }
     1091        else if ( strcmp( str, "IOB" ) == 0 )
     1092        {
     1093            periph[periph_index]->type = PERIPH_TYPE_IOB;
     1094            iob_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1095
     1096            if(io_mmu_active) error = 1;
     1097            io_mmu_active = 1;
     1098        }
     1099        // The TIM, ICU, XICU, DMA and IOB peripherals can be replicated in several clusters
     1100        // one per cluster
     1101        else if ( strcmp( str, "TIM" ) == 0 )
     1102        {
     1103            periph[periph_index]->type = PERIPH_TYPE_TIM;
     1104            if(found_timer) error = 1;
     1105            found_timer = 1;
     1106
     1107            if(tim_base_offset == 0xFFFFFFFF)
     1108                tim_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1109
     1110            if(nb_timer_channel_max < periph[periph_index]->channels)
     1111                nb_timer_channel_max = periph[periph_index]->channels;
     1112        }
     1113        else if ( strcmp( str, "ICU" ) == 0 )
     1114        {
     1115            periph[periph_index]->type = PERIPH_TYPE_ICU;
     1116            if(found_icu) error = 1;
     1117            found_icu = 1;
     1118
     1119            if(icu_base_offset == 0xFFFFFFFF)
     1120                icu_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1121        }
     1122        else if ( strcmp( str, "XICU" ) == 0 )
     1123        {
     1124            periph[periph_index]->type = PERIPH_TYPE_XICU;
     1125            if(found_xicu) error = 1;
     1126            found_xicu = 1;
     1127
     1128            //'icu' since we can't have both xicu and icu in an arch
     1129            if(icu_base_offset == 0xFFFFFFFF)
     1130                icu_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1131        }
     1132        else if ( strcmp( str, "DMA" ) == 0 )
     1133        {
     1134            periph[periph_index]->type = PERIPH_TYPE_DMA;
     1135            if(found_dma) error = 1;
     1136            found_dma = 1;
     1137
     1138            if(dma_base_offset == 0xFFFFFFFF)
     1139                dma_base_offset = pseg[ periph[periph_index]->psegid ]->base;
     1140            if(nb_dma_channel_max < periph[periph_index]->channels)
     1141                nb_dma_channel_max = periph[periph_index]->channels;
     1142        }
     1143        else
     1144        {
     1145            printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
     1146                   periph_loc_index, cluster_index);
     1147            exit(1);
     1148        }
     1149
     1150        if(error)
     1151        {
     1152            printf("[XML ERROR] illegal <type> for peripheral %d in cluster %d\n",
     1153                   periph_loc_index, cluster_index);
     1154            exit(1);
     1155        }
     1156    }
     1157    else
     1158    {
     1159        printf("[XML ERROR] missing <type> for peripheral  %d in cluster %d\n",
     1160               periph_loc_index, cluster_index);
     1161        exit(1);
     1162    }
     1163
     1164   
     1165    periph_index++;
     1166    periph_loc_index++;
     1167    cluster[cluster_index]->periphs++;
     1168
     1169} // end periphNode
     1170
     1171/////////////////////////////////////////
     1172void coprocNode ( xmlTextReaderPtr reader )
     1173/////////////////////////////////////////
     1174{
     1175    char*           str;
     1176    unsigned int        ok;
     1177
     1178    cp_port_loc_index = 0;
     1179
     1180    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
     1181
     1182    if ( coproc_index >= MAX_COPROCS )
     1183    {
     1184        printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
     1185    }
     1186
     1187#if XML_PARSER_DEBUG
     1188printf("\n  coproc %d\n", coproc_index);
     1189#endif
     1190
     1191    coproc[coproc_index] = (mapping_coproc_t*)malloc(sizeof(mapping_coproc_t));
     1192
     1193    /////////// get name attribute
     1194    str = getStringValue( reader, "name", &ok );
     1195    if ( ok )
     1196    {
     1197#if XML_PARSER_DEBUG
     1198printf("      name = %s\n", str);
     1199#endif
     1200        strncpy(coproc[coproc_index]->name, str, 31);
     1201    }
     1202    else
     1203    {
     1204        printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
     1205               coproc_index, cluster_index);
     1206        exit(1);
     1207    }
     1208
     1209    /////////// get psegname attribute
     1210    str = getStringValue(reader,"psegname", &ok);
     1211    if ( ok == 0 )
     1212    {
     1213        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n",
     1214                 coproc_index, cluster_index);
     1215        exit(1);
     1216    }
     1217
     1218    /////////// set psegid attribute
     1219    int index = getPsegId( cluster_index, str );
     1220    if ( index >= 0 )
     1221    {
     1222#if XML_PARSER_DEBUG
     1223printf("      clusterid = %d\n", cluster_index);
     1224printf("      psegname  = %s\n", str);
     1225printf("      psegid    = %d\n", index);
     1226#endif
     1227        coproc[coproc_index]->psegid = index;
     1228        assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" );
     1229    }
     1230    else             
     1231    {
     1232        printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n",
     1233                   coproc_index, cluster_index, str );
     1234        exit(1);
     1235    } 
     1236
     1237    ////////// set port_offset
     1238    coproc[coproc_index]->port_offset = cp_port_index;
     1239
     1240#if XML_PARSER_DEBUG
     1241printf("      port_offset = %d\n", cp_port_index);
     1242#endif
     1243
     1244    int status = xmlTextReaderRead(reader);
     1245    while ( status == 1 )
     1246    {
     1247        const char* tag = (const char*)xmlTextReaderConstName(reader);
     1248
     1249        if      ( strcmp(tag, "port")     == 0 ) cpPortNode(reader);
     1250        else if ( strcmp(tag, "#text")    == 0 ) { }
     1251        else if ( strcmp(tag, "#comment") == 0 ) { }
     1252        else if ( strcmp(tag, "coproc")   == 0 )
     1253        {
     1254            coproc[coproc_index]->ports = cp_port_loc_index;
     1255            cluster[cluster_index]->coprocs++;
     1256            coproc_loc_index++;
     1257            coproc_index++;
     1258            return;
     1259        }
     1260        else
     1261        {
     1262            printf("[XML ERROR] Unknown tag %s",tag);
     1263            exit(1);
     1264        }
     1265        status = xmlTextReaderRead ( reader );
     1266    }
     1267} // end coprocNode()
     1268
     1269///////////////////////////////////////
     1270void irqNode( xmlTextReaderPtr reader )
     1271///////////////////////////////////////
     1272{
     1273    unsigned int        ok;
     1274    unsigned int        value;
     1275    char*               str;
     1276
     1277    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
     1278
     1279    if ( irq_index >= MAX_IRQS )
     1280    {
     1281        printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS);
     1282    }
     1283
     1284#if XML_PARSER_DEBUG
     1285printf("     irq %d\n", irq_loc_index);
     1286#endif
     1287
     1288    irq[irq_index] = (mapping_irq_t*)malloc(sizeof(mapping_irq_t));
     1289
     1290    ///////// get type attribute
     1291    str = getStringValue(reader,"type", &ok);
     1292    if ( ok )
     1293    {
     1294#if XML_PARSER_DEBUG
     1295printf("        type    = %s\n", str);
     1296#endif
     1297        if      ( strcmp(str, "HARD") == 0 ) irq[irq_index]->type = 0;
     1298        else if ( strcmp(str, "SOFT") == 0 ) irq[irq_index]->type = 1;
     1299        else
     1300        {
     1301            printf("[XML ERROR] undefined IRQ  <type> for processor %d in cluster %d\n",
     1302                   cluster_index, proc_loc_index );
     1303            exit(1);
     1304        }
     1305    } 
     1306    else
     1307    {
     1308        printf("[XML ERROR] missing IRQ <type> for processor %d in cluster %d\n",
     1309               cluster_index, proc_loc_index );
     1310        exit(1);
     1311    }
     1312
     1313    ///////// get icuid attribute
     1314    value = getIntValue(reader, "icuid", &ok);
     1315    if ( ok )
     1316    {
     1317#if XML_PARSER_DEBUG
     1318printf("        icuid   = %d\n", value);
     1319#endif
     1320        irq[irq_index]->icuid = value;
     1321        if ( value >= 32 )
     1322        {
     1323            printf("[XML ERROR] IRQ <icuid> too large for processor %d in cluster %d\n",
     1324                   cluster_index, proc_loc_index );
     1325            exit(1);
     1326        }
     1327    }
     1328    else
     1329    {
     1330        printf("[XML ERROR] missing IRQ <icuid> for processor %d in cluster %d\n",
     1331               cluster_index, proc_loc_index );
     1332        exit(1);
     1333    }
     1334
     1335    ///////// get isr attribute
     1336    str = getStringValue(reader,"isr", &ok);
     1337    if ( ok )
     1338    {
     1339#if XML_PARSER_DEBUG
     1340printf("        isr     = %s\n", str);
     1341#endif
     1342        if      ( strcmp(str, "ISR_SWITCH" ) == 0 ) irq[irq_index]->isr = ISR_SWITCH;
     1343        else if ( strcmp(str, "ISR_IOC"    ) == 0 ) irq[irq_index]->isr = ISR_IOC;
     1344        else if ( strcmp(str, "ISR_DMA"    ) == 0 ) irq[irq_index]->isr = ISR_DMA;
     1345        else if ( strcmp(str, "ISR_TTY"    ) == 0 ) irq[irq_index]->isr = ISR_TTY;
     1346        else if ( strcmp(str, "ISR_TIMER"  ) == 0 ) irq[irq_index]->isr = ISR_TIMER;
     1347        else
     1348        {
     1349            printf("[XML ERROR] illegal IRQ <isr> for processor %d in cluster %d\n",
     1350                   cluster_index, proc_loc_index );
     1351            exit(1);
     1352        }
     1353#if XML_PARSER_DEBUG
     1354printf("        isrnum  = %d\n", irq[irq_index]->isr);
     1355#endif
     1356    } 
     1357    else
     1358    {
     1359        printf("[XML ERROR] missing IRQ <isr> for processor %d in cluster %d\n",
     1360               cluster_index, proc_loc_index );
     1361        exit(1);
     1362    }
     1363
     1364    ///////// get channel attribute (optionnal : 0 if missing)
     1365    value = getIntValue(reader, "channel", &ok);
     1366    if ( ok )
     1367    {
     1368#if XML_PARSER_DEBUG
     1369printf("        channel = %d\n", value);
     1370#endif
     1371        irq[irq_index]->channel = value;
     1372    }
     1373    else
     1374    {
     1375        irq[irq_index]->channel = 0;
     1376    }
     1377
     1378    irq_index++;
     1379    irq_loc_index++;
     1380
     1381} // end irqNode
     1382
     1383/////////////////////////////////////////
     1384void procNode ( xmlTextReaderPtr reader )
     1385/////////////////////////////////////////
     1386{
     1387    unsigned int        ok;
     1388    unsigned int    value;
     1389
     1390    irq_loc_index = 0;
     1391
     1392    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
     1393
     1394    if ( proc_index >= MAX_PROCS )
     1395    {
     1396        printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
     1397    }
     1398
     1399#if XML_PARSER_DEBUG
     1400printf("\n  proc %d\n", proc_index);
     1401#endif
     1402
     1403    proc[proc_index] = (mapping_proc_t*)malloc(sizeof(mapping_proc_t));
     1404
     1405
     1406    /////////// get index attribute (optional)
     1407    value = getIntValue(reader,"index",&ok);
     1408    if ( ok && (value != proc_loc_index) )
     1409    {
     1410            printf("[XML ERROR] wrong proc index / expected value is %d",
     1411                proc_loc_index);
     1412            exit(1);
     1413    }
     1414
     1415    ////////// set irq_offset attribute
     1416    proc[proc_index]->irq_offset = irq_index;
     1417
     1418#if XML_PARSER_DEBUG
     1419printf("    irq_offset = %d\n", irq_index);
     1420#endif
     1421
     1422    int status = xmlTextReaderRead(reader);
     1423    while ( status == 1 )
     1424    {
     1425        const char* tag = (const char*)xmlTextReaderConstName(reader);
     1426
     1427        if      ( strcmp(tag, "irq")      == 0 ) irqNode(reader);
     1428        else if ( strcmp(tag, "#text")    == 0 ) { }
     1429        else if ( strcmp(tag, "#comment") == 0 ) { }
     1430        else if ( strcmp(tag, "proc")     == 0 )
     1431        {
     1432            proc[proc_index]->irqs = irq_loc_index;
     1433            cluster[cluster_index]->procs++;
     1434            proc_loc_index++;
     1435            proc_index++;
     1436            return;
     1437        }
     1438        else
     1439        {
     1440            printf("[XML ERROR] Unknown tag %s",tag);
     1441            exit(1);
     1442        }
     1443        status = xmlTextReaderRead ( reader );
     1444    }
     1445} // end procNode()
     1446
     1447
    13231448//////////////////////////////////////////
    13241449void  psegNode ( xmlTextReaderPtr reader )
    … …  
    14201545    unsigned int value;
    14211546
     1547    cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
     1548   
     1549    //initialise all variables
     1550    //they will be incremented by *Node() functions
     1551    //FIXME: calloc?
     1552    cluster[cluster_index]->psegs = 0;
     1553    cluster[cluster_index]->procs = 0;
     1554    cluster[cluster_index]->coprocs = 0;
     1555    cluster[cluster_index]->periphs = 0;
     1556
     1557
     1558    //initialise global variables
     1559    //TODO: delete those three
    14221560    proc_loc_index = 0;
    14231561    coproc_loc_index = 0;
    14241562    periph_loc_index = 0;
    14251563
     1564    // for replicated periph
     1565    found_timer = 0;
     1566    found_icu = 0;
     1567    found_xicu = 0;
     1568    found_dma = 0;
     1569
    14261570    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
    14271571
    … …  
    14371581#endif
    14381582
    1439     cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
    1440    
    1441     //initialise the number of pseg
    1442     //it will be incremented by PsegNode
    1443     cluster[cluster_index]->psegs = 0;
    14441583
    14451584    /////////// check cluster index attribute (optional)
    … …  
    14801619        else if ( strcmp(tag, "cluster")  == 0 )
    14811620        {
    1482             cluster[cluster_index]->procs   = proc_loc_index;
    1483             cluster[cluster_index]->coprocs = coproc_loc_index;
    1484             cluster[cluster_index]->periphs = periph_loc_index;
    1485 
    1486             // cluster[cluster_index]psegs update is done in psegNode(),
    1487             // because the coprocNode() call to getPsegId() need it
     1621
     1622            if(use_xicu == 0xFFFFFFFF)
     1623                use_xicu = found_xicu;
     1624
     1625            ////////////////// peripherals checks ////////////////////
     1626            if( (found_timer  && use_xicu) || (!found_timer  && !use_xicu) )
     1627            {
     1628                printf("[XML ERROR] illegal or missing timer peripheral in cluster %d\n", cluster_index);
     1629                exit(1);
     1630            }
     1631
     1632            if( (found_icu  && use_xicu) || (!found_icu  && !use_xicu) )
     1633            {
     1634                printf("[XML ERROR] illegal or missing icu peripheral in cluster %d\n", cluster_index);
     1635                exit(1);
     1636            }
     1637
     1638            if( !found_xicu && use_xicu)
     1639            {
     1640                printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
     1641                exit(1);
     1642            }
     1643
     1644            if(!found_dma)
     1645            {
     1646                printf("[XML ERROR] illegal or missing dma peripheral in cluster %d\n", cluster_index);
     1647                exit(1);
     1648            }
     1649
     1650               
     1651            if(nb_proc_max < cluster[cluster_index]->procs)
     1652                nb_proc_max = cluster[cluster_index]->procs;
    14881653
    14891654#if XML_PARSER_DEBUG
    … …  
    14921657printf("    coprocs = %d\n", cluster[cluster_index]->coprocs);
    14931658printf("    periphs = %d\n", cluster[cluster_index]->periphs);
    1494 printf("  end cluster %d\n", cluster_index);
     1659printf("    end cluster %d\n", cluster_index);
    14951660#endif
    14961661            cluster_index++;
    … …  
    15271692                exit(1);
    15281693            }
    1529             else
     1694
     1695            if(header->tty_clusterid == 0xFFFFFFFF)
    15301696            {
     1697                printf("[XML ERROR] illegal or missing tty peripheral");
     1698                exit(1);
     1699            }
     1700
    15311701#if XML_PARSER_DEBUG
    15321702printf("  end cluster set\n\n");
    15331703#endif
    1534                 header->psegs    = pseg_index;
    1535                 header->procs    = proc_index;
    1536                 header->irqs     = irq_index;
    1537                 header->coprocs  = coproc_index;
    1538                 header->cp_ports = cp_port_index;
    1539                 return;
    1540             }
     1704            header->psegs    = pseg_index;
     1705            header->procs    = proc_index;
     1706            header->irqs     = irq_index;
     1707            header->coprocs  = coproc_index;
     1708            header->cp_ports = cp_port_index;
     1709            return;
    15411710        }
    15421711        else
    … …  
    16591828    }
    16601829
    1661     /////////// get clusters attribute
    1662     value = getIntValue(reader, "clusters", &ok);
    1663     if ( ok )
    1664     {
    1665         if ( value >= MAX_CLUSTERS )
    1666         {
    1667             printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
    1668             exit(1);
    1669         }
     1830    /////////// get cluster_x attribute
     1831    cluster_x = getIntValue(reader, "cluster_x", &ok);
     1832    if ( ok )
     1833    {
     1834#if XML_PARSER_DEBUG
     1835printf("  cluster_x = %d\n", cluster_x);
     1836#endif
     1837        header->cluster_x = cluster_x;
     1838    }
     1839    else
     1840    {
     1841        printf("[XML ERROR] illegal or missing <cluster_x> attribute in header\n");
     1842        exit(1);
     1843    }
     1844
     1845    /////////// get cluster_y attribute
     1846    cluster_y = getIntValue(reader, "cluster_y", &ok);
     1847    if ( ok )
     1848    {
     1849#if XML_PARSER_DEBUG
     1850printf("  cluster_y = %d\n", cluster_y);
     1851#endif
     1852        header->cluster_y = cluster_y;
     1853    }
     1854    else
     1855    {
     1856        printf("[XML ERROR] illegal or missing <cluster_y> attribute in header\n");
     1857        exit(1);
     1858    }
     1859
     1860    //check the number of cluster
     1861    value = cluster_x*cluster_y;
     1862    if ( value >= MAX_CLUSTERS )
     1863    {
     1864        printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
     1865        exit(1);
     1866    }
     1867       
     1868    header->clusters  = value;
     1869
    16701870#if XML_PARSER_DEBUG
    16711871printf("  clusters = %d\n", value);
    16721872#endif
    1673         header->clusters  = value;
    1674     }
    1675     else
    1676     {
    1677         printf("[XML ERROR] illegal or missing <clusters> attribute in header\n");
    1678         exit(1);
    1679     }
    16801873
    16811874    ///////// get vspaces attribute
    … …  
    17431936{
    17441937    unsigned int i;
    1745     unsigned int length;
    17461938    // write element
    17471939    for ( i = 0 ; i < nb_elem ; i++ )
    17481940    {
    1749         length = write(fdout, table[i], elem_size);
    1750    
     1941        if(elem_size != write(fdout, table[i], elem_size))
     1942        {
     1943            printf("function %s: %s(%d) write  error \n", __FUNCTION__, type, i);
     1944            exit(1);
     1945        }
     1946
    17511947#if XML_PARSER_DEBUG
    17521948printf("Building binary: writing %s %d\n", type, i);
    17531949#endif
    1754 
    1755         if ( length != elem_size )
    1756         {
    1757             printf("type: %s\n", type);
    1758             perror("error writing");
    1759             exit(1);
    1760         }
    17611950    }
    17621951}
    17631952
     1953int open_file(const char* file_path)
     1954{
     1955
     1956    //open file
     1957    int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) );
     1958    if ( fdout < 0)
     1959    {
     1960        perror("open");
     1961        exit(1);
     1962    }
     1963
     1964    //reinitialise the file
     1965    if( ftruncate(fdout, 0) )
     1966    {
     1967        perror("truncate");
     1968        exit(1);
     1969    }
     1970
     1971//#if XML_PARSER_DEBUG
     1972    printf("%s\n",file_path);
     1973//#endif
     1974
     1975    return fdout;
     1976}
     1977
     1978
    17641979///////////////////////////
    1765 void  buildBin( int fdout )
     1980void  buildBin( const char* file_path )
    17661981///////////////////////////
    17671982{
    1768     unsigned int    vspace_id;
    1769     unsigned int    vobj_id;
    17701983    unsigned int    length;
     1984
     1985    int fdout = open_file(file_path);
    17711986
    17721987    // write header to binary file
    17731988    length = write(fdout, (char*)header, sizeof(mapping_header_t));
    1774    
    1775 #if XML_PARSER_DEBUG
    1776 printf("\n*** write header\n");
    1777 #endif
    1778 
    17791989    if ( length != sizeof(mapping_header_t) )
    17801990    {
    … …  
    17851995    // write clusters
    17861996    BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char**) cluster);
    1787 
    17881997    // write psegs
    17891998    BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char**) pseg);
    1790 
    17911999    // write vspaces
    1792     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
    1793     {
    1794         length = write(fdout, (char*)vspace[vspace_id], sizeof(mapping_vspace_t));
    1795    
    1796 #if XML_PARSER_DEBUG
    1797 printf("write vspace %d\n", vspace_id);
    1798 printf("vspace->vobj_offset: %d\n", vspace[vspace_id]->vobj_offset);
    1799 printf("vspace->vobjs: %d\n", vspace[vspace_id]->vobjs);
    1800 printf("header->vobjs: %d\n", header->vobjs);
    1801 #endif
    1802 
    1803         if ( length != sizeof(mapping_vspace_t) )
    1804         {
    1805             perror("write vspace");
    1806             exit(1);
    1807         }
    1808     }
    1809 
     2000    BuildTable(fdout, "vspace", vspace_index, sizeof(mapping_vspace_t), (char**) vspace);
    18102001    // write vsegs
    18112002    BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char**) vseg);
    1812    
    18132003    // write vobjs
    1814     for ( vobj_id = 0 ; vobj_id < header->vobjs ; vobj_id++ )
    1815     {
    1816         length = write(fdout, (char*)vobj[vobj_id], sizeof(mapping_vobj_t));
    1817    
    1818 #if XML_PARSER_DEBUG
    1819 printf("write vobj %d\n", vobj_id);
    1820 printf("write vobj name %s\n", vobj[vobj_id]->name);
    1821 printf("write vobj length %x\n", vobj[vobj_id]->length);
    1822 printf("write vobj type %d\n", vobj[vobj_id]->type);
    1823 #endif
    1824 
    1825         if ( length != sizeof(mapping_vobj_t) )
    1826         {
    1827             perror("write vobj");
    1828             exit(1);
    1829         }
    1830     }
    1831 
     2004    BuildTable(fdout, "vobj", vobj_index, sizeof(mapping_vobj_t), (char**) vobj);
    18322005    // write tasks array
    18332006    BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char**) task);
    … …  
    18422015    //building periphs array
    18432016    BuildTable(fdout, "periph", periph_index, sizeof(mapping_periph_t), (char**)periph);
     2017   
     2018    close(fdout);
    18442019
    18452020} // end buildBin()
    … …  
    18892064}
    18902065
     2066
     2067void file_write(int fdout, char* towrite)
     2068{
     2069    unsigned int size = strlen(towrite);
     2070    if(size != write(fdout, towrite, size))
     2071    {
     2072        printf("file_write error");
     2073        exit(1);
     2074    }
     2075}
     2076
     2077void def_int_write(int fdout, char* def, int num)
     2078{
     2079    char  buf[64];
     2080    sprintf(buf, "#define\t %s  %d\n", def, num);
     2081    file_write(fdout, buf);
     2082
     2083}
     2084
     2085void def_hex_write(int fdout, char* def, int num)
     2086{
     2087    char  buf[64];
     2088    sprintf(buf, "#define\t %s  0x%x\n", def, num);
     2089    file_write(fdout, buf);
     2090}
     2091
     2092///////////////////////////
     2093void  genHd( const char* file_path )
     2094///////////////////////////
     2095{
     2096    int fdout = open_file(file_path);
     2097
     2098    char* prol = " /* AUTO GENRATED FILE */\n\n#ifndef _HD_CONFIG_H\n#define _HD_CONFIG_H\n\n";
     2099    file_write(fdout, prol);
     2100
     2101    def_int_write(fdout, "CLUSTER_X"       , cluster_x);
     2102    def_int_write(fdout, "CLUSTER_Y"       , cluster_y);
     2103    def_int_write(fdout, "NB_CLUSTERS"      , cluster_index);
     2104    def_hex_write(fdout, "CLUSTER_SIZE"    , ( ((unsigned long)1) << 32)/cluster_index);
     2105    def_int_write(fdout, "NB_PROCS_MAX"     , nb_proc_max);
     2106    def_int_write(fdout, "NB_TIMERS_MAX"   , nb_timer_channel_max);
     2107    def_int_write(fdout, "NB_DMAS_MAX"     , nb_dma_channel_max);
     2108    def_int_write(fdout, "NB_TTYS"         , nb_tty_channel);
     2109    def_int_write(fdout, "NB_IOCS"         , nb_ioc_channel);
     2110    def_int_write(fdout, "NB_NICS"         , nb_nic_channel);
     2111   
     2112    file_write(fdout, "\n");
     2113    def_int_write(fdout, "USE_XICU"         , use_xicu);
     2114    def_int_write(fdout, "IOMMU_ACTIVE "    , io_mmu_active);
     2115
     2116    char* epil = "\n#endif //_HD_CONFIG_H";
     2117    file_write(fdout, epil);
     2118
     2119    close(fdout);
     2120}
     2121
     2122void ld_write(int fdout, char* seg, unsigned int addr)
     2123{
     2124    char  buf[64];
     2125    sprintf(buf, "%s = 0x%x;\n", seg, addr);
     2126    file_write(fdout, buf);
     2127
     2128}
     2129
     2130///////////////////////////
     2131void  genLd( const char* file_path )
     2132///////////////////////////
     2133{
     2134    int fdout = open_file(file_path);
     2135
     2136    char* prol = "/* AUTO GENRATED FILE */\n\n";
     2137    file_write(fdout, prol);
     2138
     2139    //boot
     2140    ld_write(fdout, "seg_boot_code_base"           , boot_code_base);
     2141    ld_write(fdout, "seg_boot_stack_base"          , boot_stack_base);
     2142    ld_write(fdout, "seg_mapping_base"        , boot_mapping_base );
     2143
     2144    //kernel
     2145    ld_write(fdout, "\nseg_kernel_code_base"         , kernel_code_base);
     2146    ld_write(fdout, "seg_kernel_data_base"         , kernel_data_base);
     2147    ld_write(fdout, "seg_kernel_uncdata_base"      , kernel_uncdata_base);
     2148    ld_write(fdout, "seg_kernel_init_base"         , kernel_init_base);
     2149
     2150    //peripherals
     2151    ld_write(fdout, "\nseg_fbf_base" ,  fbf_base_offset);
     2152    ld_write(fdout, "seg_icu_base" ,  icu_base_offset);
     2153    ld_write(fdout, "seg_ioc_base" ,  ioc_base_offset);
     2154    ld_write(fdout, "seg_tty_base" ,  tty_base_offset);
     2155    ld_write(fdout, "seg_dma_base" ,  dma_base_offset);
     2156    ld_write(fdout, "seg_tim_base" ,  tim_base_offset);
     2157    ld_write(fdout, "seg_gcd_base" ,  gcd_base_offset);
     2158    ld_write(fdout, "seg_iob_base" ,  iob_base_offset);
     2159
     2160    close(fdout);
     2161}
     2162
     2163char* buildPath(const char* path, const char*name)
     2164{
     2165    char *res = calloc(strlen(path) + strlen(name) + 1, 1);
     2166    strcat(res, path);
     2167    strcat(res, "/");
     2168    strcat(res, name);
     2169    return res;
     2170}
     2171
    18912172/////////////////////////////////////
    18922173int  main ( int argc, char* argv[] )
    … …  
    18952176    if ( argc < 3 )
    18962177    {
    1897         printf("Usage: xml2bin <input_file_path> <output_file_path>\n");
     2178        printf("Usage: xml2bin <input_file_path> <output_path>\n");
    18982179        return 1;
    18992180    }
    19002181
    1901     int fdout = open( argv[2], (O_CREAT | O_RDWR), S_IRWXU );
    1902     if ( fdout < 0)
    1903     {
    1904         perror("open");
    1905         exit(1);
    1906     }
     2182    struct stat dir_st;
     2183    if(stat( argv[2], &dir_st ))
     2184    {
     2185        perror("bad path");
     2186        exit(1);
     2187    }
     2188
     2189    if((dir_st.st_mode & S_IFDIR) == 0)
     2190    {
     2191        printf("path is not a dir: %s", argv[2] );
     2192        exit(1);
     2193    }
     2194
    19072195   
     2196    char *map_path = buildPath(argv[2], "map.bin");
     2197    char *ld_path = buildPath(argv[2],  "giet_vsegs.ld");
     2198    char *hd_path = buildPath(argv[2],  "hard_config.h");
     2199
    19082200    LIBXML_TEST_VERSION;
    19092201
    … …  
    19222214                headerNode( reader );
    19232215                prepareBuild();
    1924                 buildBin( fdout );
     2216                buildBin( map_path );
     2217                genHd(hd_path);
     2218                genLd(ld_path);
    19252219            }
    19262220            else
Note: See TracChangeset for help on using the changeset viewer.