source: soft/giet_vm/xml/xml_driver.c @ 220

////////////////////////////////////////////////////////////////////////////
// File     : xml_driver.c
// Date     : 04/04/2012
// Author   : alain greiner
// Copyright (c) UPMC-LIP6
////////////////////////////////////////////////////////////////////////////
// This program translate a binary file containing a MAPPING_INFO 
// data structure to an xml file.
////////////////////////////////////////////////////////////////////////////

#include  <stdlib.h>
#include  <fcntl.h>
#include  <unistd.h>
#include  <stdio.h>
#include  <string.h>
#include  <stdint.h>
#include  <mapping_info.h>

//////////////////////////////////////////////////////
void buildXml( mapping_header_t* header, FILE* fpout )
{
    const char* vobj_type[] = 
    { 
        "ELF",          // binary code generated by GCC
        "BLOB",         // binary code generated by GCC
        "PTAB",         // page table 
        "PERI",         // hardware component
        "MWMR",         // MWMR channel
        "LOCK",         // Spin-Lock
        "BUFFER",       // Any "no intialiasation needed" objects (stacks...)
        "BARRIER",      // Barrier
    };

    const char* pseg_type[] =
    {
        "RAM",
        "ROM",
        "PERI",
    };

    const char* irq_type[] =
    {
        "HARD",
        "SOFT",
    };

    const char* isr_type[] =
    {
        "ISR_DEFAULT",
        "ISR_SWITCH",
        "ISR_TTY",
        "ISR_DMA",
        "ISR_IOC",
        "ISR_TIMER",
    };

    const char* periph_type[] =
    {
        "ICU",
        "TIM",
        "XICU",
        "DMA",
        "IOC",
        "TTY",
        "FBF",
        "NIC",
        "IOB",
    };

    const char* port_direction[] =
    {
        "TO_COPROC",
        "FROM_COPROC",
    };

    const char* mode_str[] = 
    { "____",
      "___U", 
      "__W_", 
      "__WU", 
      "_X__", 
      "_X_U", 
      "_XW_", 
      "_XWU", 
      "C___", 
      "C__U", 
      "C_W_", 
      "C_WU", 
      "CX__", 
      "CX_U", 
      "CXW_", 
      "CXWU", 
    };

    unsigned int                vspace_id;
    unsigned int                cluster_id;
    unsigned int                pseg_id;
    unsigned int                vseg_id;
    unsigned int                vobj_id;
    unsigned int                task_id;
    unsigned int                proc_id;
    unsigned int                irq_id;
    unsigned int                coproc_id;
    unsigned int                port_id;
    unsigned int                periph_id;

    mapping_cluster_t*  cluster;
    mapping_pseg_t*         pseg;
    mapping_vspace_t*   vspace;
    mapping_vseg_t*         vseg;
    mapping_vobj_t*         vobj;
    mapping_task_t*         task;
    mapping_proc_t*         proc;
    mapping_irq_t*          irq;        
    mapping_coproc_t*   coproc;
    mapping_cp_port_t*  cp_port;
    mapping_periph_t*   periph;

    // computes the base adresss for clusters array, 
    cluster = (mapping_cluster_t*)((char*)header +
                                  MAPPING_HEADER_SIZE );

    // computes the base adresss for psegs array, 
    pseg    = (mapping_pseg_t*)   ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters );

    // computes the base adresss for vspaces array, 
    vspace  = (mapping_vspace_t*) ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs );

    // computes the base adresss for vsegs array, 
    vseg    = (mapping_vseg_t*)   ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces );

    // computes the base adresss for vobjs array, 
    vobj    = (mapping_vobj_t*)   ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VSEG_SIZE*header->vsegs );

    // computes the base address for tasks array 
    task    = (mapping_task_t*)   ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs );

    // computes the base address for procs array 
    proc    = (mapping_proc_t*)   ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs +
                                  MAPPING_TASK_SIZE*header->tasks);

    // computes the base address for irqs array 
    irq    = (mapping_irq_t*)    ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs +
                                  MAPPING_TASK_SIZE*header->tasks +
                                  MAPPING_PROC_SIZE*header->procs);

    // computes the base address for coprocs array 
    coproc = (mapping_coproc_t*)  ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs +
                                  MAPPING_TASK_SIZE*header->tasks +
                                  MAPPING_PROC_SIZE*header->procs +
                                  MAPPING_IRQ_SIZE*header->irqs);

    // computes the base address for cp_ports array 
    cp_port = (mapping_cp_port_t*)((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs +
                                  MAPPING_TASK_SIZE*header->tasks +
                                  MAPPING_PROC_SIZE*header->procs +
                                  MAPPING_IRQ_SIZE*header->irqs +
                                  MAPPING_COPROC_SIZE*header->coprocs);

    // computes the base address for periphs array 
    periph = (mapping_periph_t*)  ((char*)header +
                                  MAPPING_HEADER_SIZE +
                                  MAPPING_CLUSTER_SIZE*header->clusters +
                                  MAPPING_PSEG_SIZE*header->psegs +
                                  MAPPING_VSPACE_SIZE*header->vspaces +
                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                  MAPPING_VSEG_SIZE*header->vsegs +
                                  MAPPING_TASK_SIZE*header->tasks +
                                  MAPPING_PROC_SIZE*header->procs +
                                  MAPPING_IRQ_SIZE*header->irqs +
                                  MAPPING_COPROC_SIZE*header->coprocs +
                                  MAPPING_CP_PORT_SIZE*header->cp_ports);

    ///////////////////////// header /////////////////////////////////////////////

    fprintf( fpout, "<?xml version = \"1.0\"?>\n\n");

    fprintf( fpout, "<mapping_info signature = \"0x%x\" ", header->signature);
    fprintf( fpout, " name = \"%s\" ", header->name);
    fprintf( fpout, " cluster_x = \"%d\" ", header->cluster_x);
    fprintf( fpout, " cluster_y = \"%d\" ", header->cluster_y);
    fprintf( fpout, " vspaces = \"%d\" >\n\n", header->vspaces);

    ///////////////////// clusters ///////////////////////////////////////////////

    fprintf( fpout, "    <clusterset>\n" );
    for ( cluster_id = 0 ; cluster_id < header->clusters ; cluster_id++ )
    {
        fprintf( fpout, "        <cluster index  = \"%d\" >\n",   cluster_id);
        for ( pseg_id = cluster[cluster_id].pseg_offset ; 
              pseg_id < cluster[cluster_id].pseg_offset + cluster[cluster_id].psegs ; 
              pseg_id++ )
        {
            fprintf( fpout, "            <pseg name = \"%s\" ", pseg[pseg_id].name);
            fprintf( fpout, " type = \"%s\" ", pseg_type[pseg[pseg_id].type]);
            fprintf( fpout, " base = \"0x%x\" ", pseg[pseg_id].base);
            fprintf( fpout, " length = \"0x%x\" />\n",   pseg[pseg_id].length);
        }

    ///////////////////// processors /////////////////////////////////////////////

        unsigned int proc_index = 0;
        for ( proc_id = cluster[cluster_id].proc_offset ; 
              proc_id < cluster[cluster_id].proc_offset + cluster[cluster_id].procs ;
              proc_id++ )
        {
            fprintf( fpout, "            <proc index = \"%d\" >\n", proc_index);
            for ( irq_id = proc[proc_id].irq_offset ; 
                  irq_id < proc[proc_id].irq_offset + proc[proc_id].irqs ; 
                  irq_id++ )
            {
                fprintf( fpout, "                <irq type = \"%s\" ", irq_type[irq[irq_id].type]);
                fprintf( fpout, " icuid = \"0x%x\" ", irq[irq_id].icuid);
                fprintf( fpout, " isr = \"%s\" ", isr_type[irq[irq_id].isr]);
                fprintf( fpout, " channel = \"0x%x\" />\n", irq[irq_id].channel);
            }
            fprintf( fpout, "            </proc>\n" );
        }


    ///////////////////// coprocessors ///////////////////////////////////////////

        for ( coproc_id = cluster[cluster_id].coproc_offset ; 
              coproc_id < cluster[cluster_id].coproc_offset + cluster[cluster_id].coprocs ;
              coproc_id++ )
        {
            fprintf( fpout, "            <coproc name = \"%s\" ", coproc[coproc_id].name);
            fprintf( fpout, " psegname = \"%s\" >\n", pseg[coproc[coproc_id].psegid].name);
            for ( port_id = coproc[coproc_id].port_offset ; 
                  port_id < coproc[coproc_id].port_offset + coproc[coproc_id].ports ; 
                  port_id++ )
            {
                unsigned int vobj_id = cp_port[port_id].vobjlocid + vspace[cp_port[port_id].vspaceid].vobj_offset; 
                fprintf( fpout, "             <port direction = \"%s\" ",  port_direction[ cp_port[port_id].direction]);
                fprintf( fpout, " vspacename = \"%s\" ", vspace[cp_port[port_id].vspaceid].name);
                fprintf( fpout, " vobjname = \"%s\" />\n",  vobj[vobj_id].name);
            }
            fprintf( fpout, "            </coproc>\n" );
        }

    ///////////////////// periphs  ///////////////////////////////////////////////

        for ( periph_id = cluster[cluster_id].periph_offset ; 
              periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs ;
              periph_id++ )
        {
            fprintf( fpout, "            <periph type = \"%s\" ", periph_type[periph[periph_id].type]);
            fprintf( fpout, " psegname = \"%s\" ", pseg[periph[periph_id].psegid].name);
            fprintf( fpout, " channels = \"%d\" />\n",  periph[periph_id].channels);
        }
        fprintf( fpout, "        </cluster>\n" );
    }
    fprintf( fpout, "    </clusterset>\n\n" );

    /////////////////// globals /////////////////////////////////////////////////

    fprintf( fpout, "    <globalset>\n" );
    for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
    {
        unsigned int pseg_id = vseg[vseg_id].psegid; 

        fprintf( fpout, "        <vseg name = \"%s\" ", vseg[vseg_id].name);
        fprintf( fpout, "vbase = \"0x%x\" ", vseg[vseg_id].vbase);
        fprintf( fpout, "mode  = \"%s\" ", mode_str[vseg[vseg_id].mode]);
        fprintf( fpout, "clusterid = \"%d\" ", pseg[pseg_id].cluster);
        fprintf( fpout, "psegname = \"%s\" ", pseg[pseg_id].name);
        fprintf( fpout, "ident = \"%d\" >\n", vseg[vseg_id].ident);
        for ( vobj_id = vseg[vseg_id].vobj_offset;
              vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs); 
              vobj_id++ )
        {
            fprintf( fpout, "            <vobj name = \"%s\" ", vobj[vobj_id].name);
            fprintf( fpout, "type = \"%s\" ", vobj_type[vobj[vobj_id].type]);
            fprintf( fpout, "length = \"0x%x\" ", vobj[vobj_id].length);
            fprintf( fpout, "align = \"%d\" ", vobj[vobj_id].align);
            fprintf( fpout, "init = \"%d\" ", vobj[vobj_id].init);
            fprintf( fpout, "binpath = \"%s\" />\n", vobj[vobj_id].binpath);
        }
        fprintf( fpout, "        </vseg>\n");
    }
    fprintf( fpout, "    </globalset>\n" );

    //////////////////// vspaces ////////////////////////////////////////////////

    fprintf( fpout, "\n    <vspaceset>\n\n" );
    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
    {
        unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].start_offset; 
        fprintf( fpout, "        <vspace name = \"%s\" ", vspace[vspace_id].name); 
        fprintf( fpout, " startname = \"%s\" >\n", vobj[func_id].name); 

        for ( vseg_id = vspace[vspace_id].vseg_offset ;
              vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs) ; 
              vseg_id++ )
        {
            unsigned int pseg_id = vseg[vseg_id].psegid; 

            fprintf( fpout, "            <vseg name = \"%s\" ", vseg[vseg_id].name);
            fprintf( fpout, "vbase = \"0x%x\" ", vseg[vseg_id].vbase);
            fprintf( fpout, "mode  = \"%s\" ", mode_str[vseg[vseg_id].mode]);
            fprintf( fpout, "clusterid = \"%d\" ", pseg[pseg_id].cluster);
            fprintf( fpout, "psegname = \"%s\" ", pseg[pseg_id].name);
            fprintf( fpout, "ident = \"%d\" >\n", vseg[vseg_id].ident);

            for ( vobj_id = vseg[vseg_id].vobj_offset ;
                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; 
                  vobj_id++ )
            {
                fprintf( fpout, "             <vobj name = \"%s\" ", vobj[vobj_id].name);
                fprintf( fpout, "type = \"%s\" ", vobj_type[vobj[vobj_id].type]);
                fprintf( fpout, "length = \"0x%x\" ", vobj[vobj_id].length);
                fprintf( fpout, "align = \"%d\" ", vobj[vobj_id].align);
                fprintf( fpout, "init = \"%d\" ", vobj[vobj_id].init);
                fprintf( fpout, "binpath = \"%s\" />\n", vobj[vobj_id].binpath);
            }
            fprintf( fpout, "            </vseg>\n\n");
        }
        for ( task_id = vspace[vspace_id].task_offset ;
              task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks) ; 
              task_id++ )
        {
            unsigned int vobj_id = task[task_id].vobjlocid + vspace[vspace_id].vobj_offset; 

            fprintf( fpout, "            <task name = \"%s\" ", task[task_id].name);
            fprintf( fpout, "clusterid = \"%d\" ", task[task_id].clusterid);
            fprintf( fpout, "proclocid = \"%d\" ", task[task_id].proclocid);
            fprintf( fpout, "stackname = \"%s\" ", vobj[vobj_id].name);
            fprintf( fpout, "startid = \"%d\" ", task[task_id].startid);
            fprintf( fpout, "usetty = \"%d\" ", task[task_id].use_tty);
            fprintf( fpout, "usenic = \"%d\" ", task[task_id].use_nic);
            fprintf( fpout, "usetimer = \"%d\" ", task[task_id].use_timer);
            fprintf( fpout, "usefbma = \"%d\" />\n", task[task_id].use_fbdma);
        }
        fprintf( fpout, "        </vspace>\n\n");
    }
    fprintf( fpout, "    </vspaceset>\n" );
    fprintf( fpout, "</mapping_info>\n");
} // end buildXml()

/////////////////////////////////////
int  main ( int argc, char* argv[] )
{
    if ( argc < 2 ) 
    {
        printf("Usage: bin2xml <input_file_path> <output_file_path>\n");
        return 1;
    }

    unsigned int      bin[0x10000];             // 64 K int = 256 Kbytes 

    int fdin = open( argv[1], O_RDONLY );
    if (fdin < 0) 
    {
        perror("open");
        exit(1);
    }

    FILE* fpout = fopen( argv[2], "w" );
    if (fpout == NULL) 
    {
        perror("open");
        exit(1);
    }

    unsigned int length = read(fdin, bin, 0x40000);

    if ( length <= 0 )
    {
        perror("read");
        exit(1);
    }

    if ( bin[0] == IN_MAPPING_SIGNATURE )
    {
        buildXml( (mapping_header_t*)bin, fpout );
    } 
    else
    {
        printf("[ERROR] Wrong file format\n");
        exit(1);
    }
    return 0;
} // end main()