////////////////////////////////////////////////////////////////////////////////////// // File : xml_parser.c // Date : 14/04/2012 // Author : alain greiner // Copyright (c) UPMC-LIP6 /////////////////////////////////////////////////////////////////////////////////////// // This program translate a "map.xml" source file to a binary file "map.bin" that // can be directly loaded in memory and used by the GIET-VM operating system. // // This map.xml file contains : // 1) the multi-cluster/multi-processors hardware architecture description // 2) the various multi-threaded software applications // 3) the mapping directives bor both the tasks and the virtual segments. // The corresponding C structures are defined in the "mapping_info.h" file. // // This parser also generates the "hard_config.h" and the "giet_vsegs.ld" files, // required to compile the GIET-VM code. /////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include #include #include #include #include #include #include #define MAX_CLUSTERS 1024 #define MAX_PSEGS 4096 #define MAX_VSPACES 1024 #define MAX_TASKS 4096 #define MAX_MWMRS 4096 #define MAX_VSEGS 4096 #define MAX_VOBJS 8192 #define MAX_PROCS 1024 #define MAX_IRQS 8192 #define MAX_COPROCS 4096 #define MAX_CP_PORTS 8192 #define MAX_PERIPHS 8192 #define XML_PARSER_DEBUG 0 /////////////////////////////////////////////////////////////////////////////////// // global variables used to store and index the data structures /////////////////////////////////////////////////////////////////////////////////// mapping_header_t * header; mapping_cluster_t * cluster[MAX_CLUSTERS]; // cluster array mapping_pseg_t * pseg[MAX_PSEGS]; // pseg array mapping_vspace_t * vspace[MAX_VSPACES]; // vspace array mapping_vseg_t * vseg[MAX_VSEGS]; // vseg array mapping_vobj_t * vobj[MAX_VOBJS]; // vobj array mapping_task_t * task[MAX_TASKS]; // task array mapping_proc_t * proc[MAX_PROCS]; // proc array mapping_irq_t * irq[MAX_IRQS]; // irq array mapping_coproc_t * coproc[MAX_COPROCS]; // coproc array mapping_cp_port_t * cp_port[MAX_CP_PORTS]; // coproc port array mapping_periph_t * periph[MAX_PERIPHS]; // peripheral array // Index for the various arrays unsigned int cluster_index = 0; unsigned int vspace_index = 0; unsigned int global_index = 0; unsigned int pseg_index = 0; unsigned int proc_index = 0; unsigned int proc_loc_index = 0; unsigned int irq_index = 0; unsigned int irq_loc_index = 0; unsigned int coproc_index = 0; unsigned int coproc_loc_index = 0; unsigned int cp_port_index = 0; unsigned int cp_port_loc_index = 0; unsigned int periph_index = 0; unsigned int periph_loc_index = 0; unsigned int vseg_index = 0; unsigned int vseg_loc_index = 0; unsigned int task_index = 0; unsigned int task_loc_index = 0; unsigned int vobj_index = 0; unsigned int vobj_loc_index = 0; unsigned int vobj_count = 0; ////////////////////////////// // for replicated peripheral ////////////////////////////// char found_timer = 0; char found_icu = 0; char found_xcu = 0; char found_dma = 0; char found_mmc = 0; //////////////////////////////////////////////////////////////////////// // These variables are used to generate the hard_config.h file. //////////////////////////////////////////////////////////////////////// unsigned int total_procs = 0; // total number of processors unsigned int nb_procs_max = 0; // max number of processors per cluster unsigned int nb_tasks_max = 0; // max number of tasks (in all vspaces) unsigned int tim_channels = 0; // number of user timers (per cluster) unsigned int dma_channels = 0; // number of DMA channels (per cluster) unsigned int tty_channels = 0; // number of TTY channels unsigned int ioc_channels = 0; // number of HBA channels unsigned int nic_channels = 0; // number of NIC channels unsigned int cma_channels = 0; // number of CMA channels unsigned int pic_channels = 0; // number of PIC channels unsigned int use_iob = 0; // using IOB component unsigned int use_pic = 0; // using PIC component unsigned int use_xcu = 0; // using XCU (not ICU) unsigned int use_fbf = 0; // using Frame Buffer // These variables define the IOC peripheral subtype unsigned int use_hba = 0; // using SoClib AHCI controller unsigned int use_bdv = 0; // using SoCLIB block device controller unsigned int use_spi = 0; // using SDCard-SPI //////////////////////////////////////////////////////////////// // These variables are used to generate the giet_vseg.ld file //////////////////////////////////////////////////////////////// unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE] = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF }; ////////////////////////////////////////////////////////////////////// // This arrray is useful to build a temporary list of vobj references. // The struct vobj_ref_s is formed by a vspace_name and a vobj_name. // This array is used to set the attribute vobj_id of a cp_port // once all the vspace have been parsed. ///////////////////////////////////////////////////////////////////// typedef struct vobj_ref_s { char vspace_name[32]; char vobj_name[32]; } vobj_ref_t; vobj_ref_t * cp_port_vobj_ref[MAX_CP_PORTS]; ////////////////////////////////////////////////// unsigned int getIntValue( xmlTextReaderPtr reader, const char * attributeName, unsigned int * ok) { unsigned int value = 0; unsigned int i; char c; char * string = (char *) xmlTextReaderGetAttribute(reader, (const xmlChar *) attributeName); if (string == NULL) { // missing argument *ok = 0; return 0; } else { if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) { // Hexa for (i = 2 ; (string[i] != 0) && (i < 10) ; i++) { c = string[i]; if ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; } else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; } else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; } else { *ok = 0; return 0; } } } else { // Decimal for (i = 0; (string[i] != 0) && (i < 9); i++) { c = string[i]; if ((c >= '0') && (c <= '9')) value = (value * 10) + string[i] - 48; else { *ok = 0; return 0; } } } *ok = 1; return value; } } // end getIntValue() //////////////////////////////////////////////// paddr_t getPaddrValue( xmlTextReaderPtr reader, const char * attributeName, unsigned int * ok) { paddr_t value = 0; unsigned int i; char c; char * string = (char *) xmlTextReaderGetAttribute(reader, (const xmlChar *) attributeName); if (string == NULL) { // missing argument *ok = 0; return 0; } else { if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) { // Hexa for (i = 2 ; (string[i] != 0) && (i < 18) ; i++) { c = string[i]; if ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; } else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; } else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; } else { *ok = 0; return 0; } } } else { // Decimal not supported for paddr_t *ok = 0; return 0; } *ok = 1; return value; } } // end getPaddrValue() //////////////////////////////////////////////// char * getStringValue( xmlTextReaderPtr reader, const char * attributeName, unsigned int * ok ) { char * string = (char *) xmlTextReaderGetAttribute(reader, (const xmlChar *) attributeName); if (string == NULL) { // missing argument *ok = 0; return NULL; } else { //we read only string smaller than 32 byte if (strlen(string) > 32) { printf("[XML ERROR] all strings must be less than 32 bytes\n"); exit(1); } *ok = 1; return string; } } // end getStringValue() /////////////////////////////////////////////////////////////////////////////////// // This function set the vbase addresses for all peripheral types, in order // to generate the ldscript file, that contains one single virtual address // for peripherals replicated in all clusters, and one virtual addresses for // each non replicated peripheral type. // // It makes the following checks on the virtual addresses: // // - For replicated peripherals the virtual base address must be: // vbase = seg_type_base & 0XFF000000 + (cluster_xy * 0x00010000) & 0x00FF0000 // // - For non-replicated peripherals, the cluster index must be cluster_io. /////////////////////////////////////////////////////////////////////////////////// void set_periph_vbase_array() { unsigned int vseg_id; // vseg global index unsigned int periph_id; // periph global index unsigned int pseg_id; // pseg global index unsigned int cluster_id; // cluster linear index unsigned int cluster_xy; // cluster topological index unsigned int type; // peripheral type unsigned int type_mask = 0xFF000000; unsigned int cluster_mask = 0x00FF0000; unsigned int vseg_increment = 0x00010000; #if XML_PARSER_DEBUG printf("\n set peripherals vbase array\n"); #endif // scan all vsegs for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++) { // keep only vseg corresponding to a periph if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI ) { pseg_id = vseg[vseg_id]->psegid; #if XML_PARSER_DEBUG printf(" - found vseg %s associated to pseg %d", vseg[vseg_id]->name, pseg_id ); #endif // scan all periphs to retrieve peripheral type (same psegid) for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++) { if( periph[periph_id]->psegid == pseg_id ) // matching !!! { cluster_id = pseg[pseg_id]->clusterid; type = periph[periph_id]->type; #if XML_PARSER_DEBUG printf(" / matching periph type %d\n", type ); #endif if ( (type == PERIPH_TYPE_DMA) || (type == PERIPH_TYPE_MMC) || (type == PERIPH_TYPE_ICU) || (type == PERIPH_TYPE_XCU) || (type == PERIPH_TYPE_TIM) ) // replicated peripheral { cluster_xy = (cluster[cluster_id]->x << header->y_width) + cluster[cluster_id]->y; if( (vseg[vseg_id]->vbase & cluster_mask) != (vseg_increment * cluster_xy) ) { printf("[XML ERROR] All replicated peripherals " "must have cluster bits = cluster_xy * increment\n"); printf("periph index = %d / periph type = %d / vbase = %x\n", periph_id, type, vseg[vseg_id]->vbase); exit(1); } else if ( periph_vbase_array[type] == 0xFFFFFFFF ) // vbase not set { periph_vbase_array[type] = vseg[vseg_id]->vbase & type_mask; } else if ((vseg[vseg_id]->vbase & type_mask) != (periph_vbase_array[type])) { printf("[XML ERROR] All peripherals with same type" " should share the same 8 MSB bits in vbase address\n"); printf("periph index = %d / periph type = %d / vbase = %x\n", periph_id, type, vseg[vseg_id]->vbase); exit(1); } } else // non replicated peripheral { if ( (cluster[cluster_id]->x == header->x_io) && (cluster[cluster_id]->y == header->y_io) ) { periph_vbase_array[type] = vseg[vseg_id]->vbase; } else { printf("[XML ERROR] Non replicated peripherals must be in cluster_io\n"); printf(" periph index = %d / periph type = %d / vbase = %x" " / pseg index = %d / cluster index = %d\n", periph_id, type, vseg[vseg_id]->vbase, pseg_id, cluster_id); exit(1); } } } } } } } // end set_periph_vbase_array() /////////////////////////////////////////////////////////////// int getClusterId( unsigned int x, unsigned int y ) { // associative search of cluster index unsigned int cluster_id; for( cluster_id = 0 ; cluster_id < (header->x_size * header->y_size) ; cluster_id++ ) { if( (cluster[cluster_id]->x == x) && (cluster[cluster_id]->y == y) ) { return cluster_id; } } return -1; } // end getClusterId() /////////////////////////////////////////////////////////////// int getPsegId(unsigned int x, unsigned int y, char * pseg_name) { int cluster_id = getClusterId( x, y ); if ( cluster_id == -1 ) return -1; // associative search for pseg index unsigned int pseg_id; unsigned int pseg_min = cluster[cluster_id]->pseg_offset; unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs; for (pseg_id = pseg_min; pseg_id < pseg_max; pseg_id++) { if (strcmp(pseg[pseg_id]->name, pseg_name) == 0) { return pseg_id; } } return -1; } // end getPsegId() /////////////////////////////////// int getVspaceId(char * vspace_name) { unsigned int vspace_id; for (vspace_id = 0; vspace_id < vspace_index; vspace_id++) { if (strcmp(vspace[vspace_id]->name, vspace_name) == 0) { return vspace_id; } } return -1; } //////////////////////////////////////////////////////////////////////////////// int getVobjId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max) { unsigned int vobj_id; unsigned int vobj_min = vspace[vspace_id]->vobj_offset; unsigned int vobj_max = vobj_min + vspace_max; for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) { if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return vobj_id; } return -1; } /////////////////////////////////////////////////////////// unsigned int alignTo( unsigned int value, unsigned int pow2 ) { unsigned int mask = (1 << pow2) - 1; return ( (value + mask) & ~mask); } //////////////////// void setVsegLength() { // for a given vseg identified vseg_index // scan all contained vobjs to compute the vseg lenth unsigned int vobj_id; unsigned int cur_length = 0; unsigned int first = vseg[vseg_index]->vobj_offset; unsigned int last = first + vseg[vseg_index]->vobjs; for ( vobj_id = first ; vobj_id < last ; vobj_id++ ) { if (vobj[vobj_id]->align) { cur_length = alignTo( cur_length, vobj[vobj_id]->align ); } cur_length += vobj[vobj_id]->length; } vseg[vseg_index]->length = alignTo( cur_length, 12 ); } /////////////////////// void checkVsegOverlap() { // for a given vseg identified by vseg_index, // check overlap with all vsegs in same vspace, // and check overlap with all global vsegs. unsigned int vseg_id; unsigned int prev_vbase; // previous vseg vbase unsigned int prev_length; // previous vseg length unsigned int vbase = vseg[vseg_index]->vbase; // new vseg vbase unsigned int length = vseg[vseg_index]->length; // new vseg length // checking overlap with other vsegs in same vspace if ( header->vspaces > 0 ) { unsigned int first = vspace[vspace_index]->vseg_offset; unsigned int last = vseg_index; for( vseg_id = first ; vseg_id < last ; vseg_id++ ) { prev_vbase = vseg[vseg_id]->vbase; prev_length = vseg[vseg_id]->length; if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) ) { printf("[XML ERROR] vseg %s in vspace %s overlaps other vseg %s\n", vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name ); exit(1); } } } // checking overlap with existing global vsegs for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ ) { prev_vbase = vseg[vseg_id]->vbase; prev_length = vseg[vseg_id]->length; if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) ) { printf("[XML ERROR] vseg %s in vspace %s overlaps global vseg %s\n", vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name ); exit(1); } } } ////////////////////////////////////// void taskNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; unsigned int x,y; char * str; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (task_index >= MAX_TASKS) { printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS); exit(1); } #if XML_PARSER_DEBUG printf(" task %d\n", task_loc_index); #endif task[task_index] = (mapping_task_t *) malloc(sizeof(mapping_task_t)); ////////// get name attribute str = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy( task[task_index]->name, str, 31 ); } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ///////// get trdid attribute (optional) task[task_index]->trdid = getIntValue(reader, "trdid", &ok); #if XML_PARSER_DEBUG printf(" trdid = %d\n", x); #endif if ( !ok ) { task[task_index]->trdid = task_loc_index; } ///////// get x coordinate x = getIntValue(reader, "x", &ok); #if XML_PARSER_DEBUG printf(" x = %d\n", x); #endif if ( !(ok && (x < header->x_size)) ) { printf("[XML ERROR] illegal or missing < x > attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ///////// get y coordinate y = getIntValue(reader, "y", &ok); #if XML_PARSER_DEBUG printf(" y = %d\n", y); #endif if ( !(ok && (y < header->y_size)) ) { printf("[XML ERROR] illegal or missing < y > attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ///////// set clusterid attribute int index = getClusterId( x, y ); #if XML_PARSER_DEBUG printf(" clusterid = %d\n", index); #endif if( index >= 0 ) { task[task_index]->clusterid = index; } else { printf("[XML ERROR] not found for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get p attribute value = getIntValue(reader, "p", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" proclocid = %x\n", value); #endif if (value >= cluster[task[task_index]->clusterid]->procs) { printf("[XML ERROR] too large for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } task[task_index]->proclocid = value; } else { printf("[XML ERROR] illegal or missing

attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get stackname attribute str = getStringValue(reader, "stackname" , &ok); if (ok) { int index = getVobjId(vspace_index, str , vobj_loc_index); if (index >= 0) { #if XML_PARSER_DEBUG printf(" stackname = %s\n", str); printf(" stack_id = %d\n", index); #endif task[task_index]->stack_vobj_id = index; } else { printf("[XML ERROR] illegal or missing for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } } else { printf("[XML ERROR] illegal or missing for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get heap attribute str = getStringValue(reader, "heapname", &ok); if (ok) { int index = getVobjId(vspace_index, str, vobj_loc_index); if (index >= 0) { #if XML_PARSER_DEBUG printf(" heapname = %s\n", str); printf(" heap_id = %d\n", index ); #endif task[task_index]->heap_vobj_id = index; } else { printf("[XML ERROR] illegal or missing for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } } else { task[task_index]->heap_vobj_id = -1; } ////////// get startid attribute value = getIntValue(reader, "startid", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" startid = %x\n", value); #endif task[task_index]->startid = value; } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } /////////// get use_tty attribute (optionnal : 0 if missing) value = getIntValue(reader, "usetty", &ok); #if XML_PARSER_DEBUG printf(" usetty = %x\n", value); #endif task[task_index]->use_tty = (ok)? value : 0; /////////// get use_nic attribute (optionnal : 0 if missing) value = getIntValue(reader, "usenic", &ok); #if XML_PARSER_DEBUG printf(" usenic = %x\n", value); #endif task[task_index]->use_nic = (ok)? value : 0; /////////// get use_tim attribute (optionnal : 0 if missing) value = getIntValue(reader, "usetim", &ok); #if XML_PARSER_DEBUG printf(" usetim = %x\n", value); #endif task[task_index]->use_tim = (ok)? value : 0; /////////// get use_hba attribute (optionnal : 0 if missing) value = getIntValue(reader, "usehba", &ok); #if XML_PARSER_DEBUG printf(" usehba = %x\n", value); #endif task[task_index]->use_hba = (ok)? value : 0; /////////// get usecma attribute (optionnal : 0 if missing) value = getIntValue(reader, "usecma", &ok); #if XML_PARSER_DEBUG printf(" usecma = %x\n", value); #endif task[task_index]->use_cma = (ok)? value : 0; task_index++; task_loc_index++; } // end taskNode() ////////////////////////////////////// void vobjNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; char * str; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (vobj_index >= MAX_VOBJS) { printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VOBJS); exit(1); } #if XML_PARSER_DEBUG printf(" vobj %d\n", vobj_loc_index); #endif vobj[vobj_index] = (mapping_vobj_t *) malloc(sizeof(mapping_vobj_t)); ///////// get name attribute str = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy(vobj[vobj_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vseg_index, vobj_loc_index); exit(1); } //////// get type attribute str = getStringValue(reader, "type", &ok); #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif if (ok && (strcmp(str, "ELF") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF; } else if (ok && (strcmp(str, "PERI") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI; } else if (ok && (strcmp(str, "BLOB") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB; } else if (ok && (strcmp(str, "PTAB") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB; } else if (ok && (strcmp(str, "MWMR") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MWMR; } else if (ok && (strcmp(str, "LOCK") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_LOCK; } else if (ok && (strcmp(str, "BUFFER") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BUFFER; } else if (ok && (strcmp(str, "BARRIER") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BARRIER; } else if (ok && (strcmp(str, "CONST") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_CONST; } else if (ok && (strcmp(str, "MEMSPACE") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MEMSPACE; } else if (ok && (strcmp(str, "SCHED") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_SCHED; } else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vspace_index, vobj_loc_index); exit(1); } // some more checking if ( (vobj[vobj_index]->type == VOBJ_TYPE_ELF) || (vobj[vobj_index]->type == VOBJ_TYPE_PERI) ) { assert( (vobj_count == 0) && "[XML ERROR] an ELF or PERI vobj must be alone in a vseg"); } ////////// get length attribute value = getIntValue(reader, "length", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" length = %x\n", value); #endif vobj[vobj_index]->length = value; } else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vspace_index, vobj_loc_index); exit(1); } ////////// get align attribute (optional : 0 if missing) value = getIntValue(reader, "align", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" align = %d\n", value); #endif vobj[vobj_index]->align = value; } else { vobj[vobj_index]->align = 0; } ////////// get binpath attribute (optional : "" if missing) str = getStringValue(reader, "binpath", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" binpath = %s\n", str); #endif strncpy(vobj[vobj_index]->binpath, str, 63); } else { vobj[vobj_index]->binpath[0] = 0; } ////////// get init attribute (optional, mandatory for mwmr and barrier) value = getIntValue(reader, "init", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" init = %d\n", value); #endif vobj[vobj_index]->init = value; } else { if ((vobj[vobj_index]->type == VOBJ_TYPE_MWMR) || (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) || (vobj[vobj_index]->type == VOBJ_TYPE_CONST)) { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d). \ All MWMR or BARRIER or CONST vobj must have a init value \n", vspace_index, vobj_loc_index); exit(1); } vobj[vobj_index]->init = 0; } vobj_index++; vobj_count++; vobj_loc_index++; } // end vobjNode() ////////////////////////////////////// void vsegNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; unsigned int x,y; char * str; vobj_count = 0; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (vseg_index >= MAX_VSEGS) { printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" vseg %d\n", vseg_loc_index); #endif vseg[vseg_index] = (mapping_vseg_t *) malloc(sizeof(mapping_vseg_t)); ////////// set vobj_offset attribute vseg[vseg_index]->vobj_offset = vobj_index; #if XML_PARSER_DEBUG printf(" vobj_offset = %d\n", vobj_index); #endif ///////// set mapped attribute vseg[vseg_index]->mapped = 0; //////// set next_vseg attribute vseg[vseg_index]->next_vseg = 0; ///////// get name attribute str = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy( vseg[vseg_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } ////////// get ident attribute (optional : 0 if missing) value = getIntValue(reader, "ident", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" ident = %d\n", value); #endif vseg[vseg_index]->ident = value; } else { vseg[vseg_index]->ident = 0; } /////////// get vbase attribute value = getIntValue(reader, "vbase", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" vbase = 0x%x\n", value); #endif vseg[vseg_index]->vbase = value; } else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } ////////// get x coordinate x = getIntValue(reader, "x", &ok); #if XML_PARSER_DEBUG printf(" x = %d\n", x); #endif if ( !(ok && (x < header->x_size)) ) { printf("[XML ERROR] illegal or missing < x > attribute for vseg %d\n", vseg_loc_index); exit(1); } ////////// get y coordinate y = getIntValue(reader, "y", &ok); #if XML_PARSER_DEBUG printf(" y = %d\n", y); #endif if ( !(ok && (y < header->y_size)) ) { printf("[XML ERROR] illegal or missing < y > attribute for vseg %d\n", vseg_loc_index); exit(1); } ///////// get psegname attribute str = getStringValue(reader, "psegname", &ok); #if XML_PARSER_DEBUG printf(" psegname = %s\n", str); #endif if (ok == 0) { printf("[XML ERROR] illegal or missing for vseg %d\n", vseg_loc_index); exit(1); } /////////// set psegid field int psegid = getPsegId( x, y, str ); #if XML_PARSER_DEBUG printf(" psegid = %d\n", psegid); #endif if (psegid >= 0) { vseg[vseg_index]->psegid = psegid; } else { printf("[XML ERROR] pseg not found for vseg %d / x = %d / y = %d / psegname = %s\n", vseg_loc_index, x, y, str ); exit(1); } //////// get mode attribute str = getStringValue(reader, "mode", &ok); #if XML_PARSER_DEBUG printf(" mode = %s\n", str); #endif if (ok && (strcmp(str, "CXWU") == 0)) { vseg[vseg_index]->mode = 0xF; } else if (ok && (strcmp(str, "CXW_") == 0)) { vseg[vseg_index]->mode = 0xE; } else if (ok && (strcmp(str, "CX_U") == 0)) { vseg[vseg_index]->mode = 0xD; } else if (ok && (strcmp(str, "CX__") == 0)) { vseg[vseg_index]->mode = 0xC; } else if (ok && (strcmp(str, "C_WU") == 0)) { vseg[vseg_index]->mode = 0xB; } else if (ok && (strcmp(str, "C_W_") == 0)) { vseg[vseg_index]->mode = 0xA; } else if (ok && (strcmp(str, "C__U") == 0)) { vseg[vseg_index]->mode = 0x9; } else if (ok && (strcmp(str, "C___") == 0)) { vseg[vseg_index]->mode = 0x8; } else if (ok && (strcmp(str, "_XWU") == 0)) { vseg[vseg_index]->mode = 0x7; } else if (ok && (strcmp(str, "_XW_") == 0)) { vseg[vseg_index]->mode = 0x6; } else if (ok && (strcmp(str, "_X_U") == 0)) { vseg[vseg_index]->mode = 0x5; } else if (ok && (strcmp(str, "_X__") == 0)) { vseg[vseg_index]->mode = 0x4; } else if (ok && (strcmp(str, "__WU") == 0)) { vseg[vseg_index]->mode = 0x3; } else if (ok && (strcmp(str, "__W_") == 0)) { vseg[vseg_index]->mode = 0x2; } else if (ok && (strcmp(str, "___U") == 0)) { vseg[vseg_index]->mode = 0x1; } else if (ok && (strcmp(str, "____") == 0)) { vseg[vseg_index]->mode = 0x0; } else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } ////////// get vobjs in vseg int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "vobj") == 0 ) { vobjNode(reader); } else if (strcmp(tag, "#text" ) == 0 ) { } else if (strcmp(tag, "#comment") == 0 ) { } else if (strcmp(tag, "vseg") == 0 ) { vseg[vseg_index]->vobjs = vobj_count; setVsegLength(); checkVsegOverlap(); vseg_index++; vseg_loc_index++; return; } else { printf("[XML ERROR] Unknown tag %s", tag); exit(1); } status = xmlTextReaderRead (reader); } } // end vsegNode() //////////////////////////////////////// void vspaceNode(xmlTextReaderPtr reader) { char * str; unsigned int ok; unsigned int nb_task_vspace = 0; vobj_loc_index = 0; vseg_loc_index = 0; task_loc_index = 0; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG printf("\n vspace %d\n", vspace_index); #endif vspace[vspace_index] = (mapping_vspace_t *) malloc(sizeof(mapping_vspace_t)); header->vspaces = header->vspaces + 1; ////////// get name attribute str = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy(vspace[vspace_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vspace %d\n", vspace_index); exit(1); } ////////// set vseg_offset and task_offset attributes vspace[vspace_index]->vseg_offset = vseg_index; vspace[vspace_index]->vobj_offset = vobj_index; vspace[vspace_index]->task_offset = task_index; #if XML_PARSER_DEBUG printf(" vseg_offset = %d\n", vseg_index); printf(" vobj_offset = %d\n", vobj_index); printf(" task_offset = %d\n", task_index); #endif ////////// get startname attribute str = getStringValue(reader, "startname", &ok); if (ok) { //used after parsing the vobjs } else { printf("[XML ERROR] illegal or missing attribute for vspace %s\n", vspace[vspace_index]->name); exit(1); } int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "vseg") == 0) { vsegNode(reader); } else if (strcmp(tag, "task") == 0) { taskNode(reader); nb_task_vspace++; } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "vspace") == 0) { vspace[vspace_index]->vobjs = vobj_loc_index; vspace[vspace_index]->tasks = task_loc_index ; vspace[vspace_index]->vsegs = vseg_loc_index ; // get index of the vobj containing the start vector int index = getVobjId(vspace_index, str , vobj_loc_index); if (index == -1) { printf("[XML ERROR] vobj containing start vector not found in vspace %s\n", vspace[vspace_index]->name); exit(1); } else { vspace[vspace_index]->start_vobj_id = index; #if XML_PARSER_DEBUG printf(" startname = %s\n", str); printf(" start_id = %d\n", index); printf(" end vspace %d\n\n", vspace_index); #endif } // checking for all tasks that the startid // is smaller than the number of tasks in vspace int task_id; int task_min = vspace[vspace_index]->task_offset; int task_max = task_min + vspace[vspace_index]->tasks; for (task_id = task_min; task_id < task_max; task_id++) { if (task[task_id]->startid >= vspace[vspace_index]->tasks) { printf("[XML ERROR] too large for task (%d,%d)\n", vspace_index, task_id ); exit(1); } } nb_tasks_max += nb_task_vspace; vspace_index++; return; } else { printf("[XML ERROR] Unknown tag %s", tag); exit(1); } status = xmlTextReaderRead(reader); } } // end vspaceNode() ///////////////////////////////////// void irqNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; char * str; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (irq_index >= MAX_IRQS) { printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS); } #if XML_PARSER_DEBUG printf(" irq %d\n", irq_loc_index); #endif irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t)); ///////// get srcid attribute value = getIntValue(reader, "srcid", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" srcid = %d\n", value); #endif irq[irq_index]->srcid = value; if (value >= 32) { printf("[XML ERROR] IRQ too large for periph %d in cluster %d\n", cluster_index, periph_loc_index); exit(1); } } else { printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", cluster_index, periph_loc_index); exit(1); } ///////// get srctype attribute str = getStringValue(reader, "srctype", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" srctype = %s\n", str); #endif if ( strcmp(str, "HWI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_HWI; else if ( strcmp(str, "WTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_WTI; else if ( strcmp(str, "PTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_PTI; else { printf("[XML ERROR] illegal IRQ for periph %d in cluster %d\n", cluster_index, periph_loc_index); exit(1); } } else { printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", cluster_index, periph_loc_index); exit(1); } ///////// get isr attribute str = getStringValue(reader, "isr", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" isr = %s\n", str); #endif if (strcmp(str, "ISR_TICK" ) == 0) irq[irq_index]->isr = ISR_TICK; else if (strcmp(str, "ISR_BDV" ) == 0) irq[irq_index]->isr = ISR_BDV; else if (strcmp(str, "ISR_CMA" ) == 0) irq[irq_index]->isr = ISR_CMA; else if (strcmp(str, "ISR_TTY_RX" ) == 0) irq[irq_index]->isr = ISR_TTY_RX; else if (strcmp(str, "ISR_TTY_TX" ) == 0) irq[irq_index]->isr = ISR_TTY_TX; else if (strcmp(str, "ISR_TIMER" ) == 0) irq[irq_index]->isr = ISR_TIMER; else if (strcmp(str, "ISR_WAKUP" ) == 0) irq[irq_index]->isr = ISR_WAKUP; else if (strcmp(str, "ISR_NIC_RX" ) == 0) irq[irq_index]->isr = ISR_NIC_RX; else if (strcmp(str, "ISR_NIC_TX" ) == 0) irq[irq_index]->isr = ISR_NIC_TX; else if (strcmp(str, "ISR_MMC" ) == 0) irq[irq_index]->isr = ISR_MMC; else if (strcmp(str, "ISR_DMA" ) == 0) irq[irq_index]->isr = ISR_DMA; else if (strcmp(str, "ISR_SPI" ) == 0) irq[irq_index]->isr = ISR_SPI; else if (strcmp(str, "ISR_DEFAULT") == 0) irq[irq_index]->isr = ISR_DEFAULT; else { printf("[XML ERROR] illegal IRQ for periph %d in cluster %d\n", periph_loc_index, cluster_index ); exit(1); } } else { printf("[XML ERROR] missing IRQ for periph %d in cluster %d\n", cluster_index, periph_loc_index); exit(1); } ///////// get channel attribute (optionnal : 0 if missing) value = getIntValue(reader, "channel", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" channel = %d\n", value); #endif irq[irq_index]->channel = value; } else { irq[irq_index]->channel = 0; } irq_index++; irq_loc_index++; } // end irqNode //////////////////////////////////////// void cpPortNode(xmlTextReaderPtr reader) { char * str; unsigned int ok; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (cp_port_index >= MAX_CP_PORTS) { printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS); exit(1); } #if XML_PARSER_DEBUG printf("\n port %d\n", cp_port_index); #endif cp_port[cp_port_index] = (mapping_cp_port_t *) malloc(sizeof(mapping_cp_port_t)); cp_port_vobj_ref[cp_port_index] = (vobj_ref_t *) malloc(sizeof(vobj_ref_t)); ///////// get direction attribute str = getStringValue(reader, "direction", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" direction = %s\n", str); #endif if (strcmp(str, "TO_COPROC") == 0) { cp_port[cp_port_index]->direction = PORT_TO_COPROC; } else if (strcmp(str, "FROM_COPROC") == 0) { cp_port[cp_port_index]->direction = PORT_FROM_COPROC; } else { printf("[XML ERROR] illegal for cp_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } } else { printf("[XML ERROR] missing for cp_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } /////////// get vspacename attribute str = getStringValue(reader, "vspacename", &ok); #if XML_PARSER_DEBUG printf(" vspacename = %s\n", str); #endif if (ok) { strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31); } else { printf("[XML ERROR] missing for cp_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } /////////// get vobjname attribute str = getStringValue(reader, "vobjname", &ok); #if XML_PARSER_DEBUG printf(" vobjname = %s\n", str); #endif if (ok) { strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31); } else { printf("[XML ERROR] missing for cp_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } cp_port_index++; cp_port_loc_index++; } // end cpPortNode() //////////////////////////////////////// void periphNode(xmlTextReaderPtr reader) { char * str; unsigned int value; unsigned int ok; irq_loc_index = 0; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (periph_index >= MAX_PERIPHS) { printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS); exit(1); } #if XML_PARSER_DEBUG printf("\n periph %d\n", periph_index); #endif periph[periph_index] = (mapping_periph_t *) malloc(sizeof(mapping_periph_t)); ///////// get channels attribute (optionnal : 1 if missing) value = getIntValue(reader, "channels", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" channels = %d\n", value); #endif periph[periph_index]->channels = value; } else { periph[periph_index]->channels = 1; } ///////// get arg attribute (optionnal : 0 if missing) value = getIntValue(reader, "arg", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" arg = %d\n", value); #endif periph[periph_index]->arg = value; } else { periph[periph_index]->arg = 1; } /////////// get psegname attribute str = getStringValue(reader, "psegname", &ok); if (ok == 0) { printf("[XML ERROR] illegal or missing for coproc %d in cluster %d\n", coproc_index, cluster_index); exit(1); } /////////// set psegid attribute int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str); if (index >= 0) { #if XML_PARSER_DEBUG printf(" clusterid = %d\n", cluster_index); printf(" psegname = %s\n", str); printf(" psegid = %d\n", index); #endif periph[periph_index]->psegid = index; } else { printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n", periph_loc_index, cluster_index, str ); exit(1); } /////////// get type attribute str = getStringValue(reader, "type", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif unsigned int error = 0; // initialize peripheral subtype periph[periph_index]->subtype = 0xFFFFFFFF; // The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, peripherals are not // replicated in all clusters but can be instanciated twice. //////////////////////////// if (strcmp(str, "CMA") == 0) { periph[periph_index]->type = PERIPH_TYPE_CMA; if ( cma_channels < periph[periph_index]->channels ) { cma_channels = periph[periph_index]->channels; } } ///////////////////////////////// else if (strcmp(str, "FBF") == 0) { periph[periph_index]->type = PERIPH_TYPE_FBF; use_fbf = 1; } ///////////////////////////////// else if (strcmp(str, "IOB") == 0) { periph[periph_index]->type = PERIPH_TYPE_IOB; use_iob = 1; } ///////////////////////////////// else if (strcmp(str, "IOC") == 0) { char* subtype = getStringValue(reader, "subtype", &ok); if (!ok) { printf("[XML ERROR] IOC peripheral needs a subtype: BDV, HBA or SPI\n"); exit(1); } if ( strcmp(subtype, "BDV") == 0 ) { periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV; ioc_channels = 1; if ( header->use_ram_disk == 0 ) use_bdv = 1; } else if ( strcmp(subtype, "HBA") == 0 ) { periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA; ioc_channels = periph[periph_index]->channels; if ( header->use_ram_disk == 0 ) use_hba = 1; } else if ( strcmp(subtype, "SPI") == 0 ) { periph[periph_index]->type = PERIPH_TYPE_IOC; periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI; ioc_channels = periph[periph_index]->channels; if ( header->use_ram_disk == 0 ) use_spi = 1; } else { printf("[XML ERROR] illegal subtype for IOC peripheral\n"); exit(1); } } ///////////////////////////////// else if (strcmp(str, "NIC") == 0) { periph[periph_index]->type = PERIPH_TYPE_NIC; if ( nic_channels < periph[periph_index]->channels ) { nic_channels = periph[periph_index]->channels; } } ///////////////////////////////// else if (strcmp(str, "ROM") == 0) { periph[periph_index]->type = PERIPH_TYPE_ROM; } ///////////////////////////////// else if (strcmp(str, "SIM") == 0) { periph[periph_index]->type = PERIPH_TYPE_SIM; } ///////////////////////////////// else if (strcmp(str, "TTY") == 0) { periph[periph_index]->type = PERIPH_TYPE_TTY; if ( tty_channels < periph[periph_index]->channels ) { tty_channels = periph[periph_index]->channels; } } ///////////////////////////////// else if (strcmp(str, "PIC") == 0) { periph[periph_index]->type = PERIPH_TYPE_PIC; if ( pic_channels < periph[periph_index]->channels ) { pic_channels = periph[periph_index]->channels; } use_pic = 1; } // The DMA, ICU, MMC, TIM, XCU peripherals can be replicated in all clusters // but no more than one component of each type per cluster ///////////////////////////////// else if (strcmp(str, "DMA") == 0) { periph[periph_index]->type = PERIPH_TYPE_DMA; if (found_dma) error = 1; found_dma = 1; if (dma_channels < periph[periph_index]->channels) dma_channels = periph[periph_index]->channels; } ////////////////////////////////// else if (strcmp(str, "ICU") == 0) { periph[periph_index]->type = PERIPH_TYPE_ICU; if (found_icu || use_xcu) error = 1; found_icu = 1; if ( periph[periph_index]->channels < (header->irq_per_proc * cluster[cluster_index]->procs) ) { printf("[XML ERROR] ICU channels smaller than PROCS * IRQ_PER_PROC\n"); printf(" - icu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n", periph[periph_index]->channels, cluster[cluster_index]->procs, header->irq_per_proc ); exit(1); } } ////////////////////////////////// else if (strcmp(str, "MMC") == 0) { periph[periph_index]->type = PERIPH_TYPE_MMC; if (found_mmc) error = 1; found_mmc = 1; if ( periph[periph_index]->channels != 1 ) error = 1; } ////////////////////////////////// else if (strcmp(str, "TIM") == 0 ) { periph[periph_index]->type = PERIPH_TYPE_TIM; if (found_timer || use_xcu) error = 1; found_timer = 1; if (tim_channels < periph[periph_index]->channels) tim_channels = periph[periph_index]->channels; } ////////////////////////////////// else if (strcmp(str, "XCU") == 0) { periph[periph_index]->type = PERIPH_TYPE_XCU; if (found_xcu || found_icu || found_timer) error = 1; found_xcu = 1; found_timer = 1; tim_channels = 32; use_xcu = 1; if ( periph[periph_index]->channels < (header->irq_per_proc * cluster[cluster_index]->procs) ) { printf("[XML ERROR] XCU channels smaller than PROCS * IRQ_PER_PROC\n"); printf(" - xcu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n", periph[periph_index]->channels, cluster[cluster_index]->procs, header->irq_per_proc ); exit(1); } } else { printf("[XML ERROR] illegal peripheral type: %s in cluster %d\n", str, cluster_index); exit(1); } if (error) { printf("[XML ERROR] illegal peripheral %s in cluster %d\n", str, cluster_index); exit(1); } } else { printf("[XML ERROR] illegal or missing for peripheral %d in cluster %d\n", periph_loc_index, cluster_index); exit(1); } ////////////// set irq_offset attribute periph[periph_index]->irq_offset = irq_index; ///////////// get IRQs int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "irq") == 0) { if ( (periph[periph_index]->type != PERIPH_TYPE_ICU) && (periph[periph_index]->type != PERIPH_TYPE_XCU) && (periph[periph_index]->type != PERIPH_TYPE_PIC) ) { printf("[XML ERROR] periph %d in cluster(%d,%d) " " only ICU, XCU and PIC can contain IRQs", periph_loc_index, cluster[cluster_index]->x, cluster[cluster_index]->y); exit(1); } else { irqNode(reader); } } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "periph") == 0) { periph[periph_index]->irqs = irq_loc_index; cluster[cluster_index]->periphs++; periph_loc_index++; periph_index++; #if XML_PARSER_DEBUG printf(" irqs = %d\n", irq_loc_index); printf(" irq_offset = %d\n", irq_index); #endif return; } else { printf("[XML ERROR] Unknown tag %s", tag); exit(1); } status = xmlTextReaderRead(reader); } } // end periphNode //////////////////////////////////////// void coprocNode(xmlTextReaderPtr reader) { char * str; unsigned int ok; cp_port_loc_index = 0; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (coproc_index >= MAX_COPROCS) { printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS); exit(1); } #if XML_PARSER_DEBUG printf("\n coproc %d\n", coproc_index); #endif coproc[coproc_index] = (mapping_coproc_t *) malloc(sizeof(mapping_coproc_t)); /////////// get name attribute str = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy(coproc[coproc_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing for coproc %d in cluster %d\n", coproc_index, cluster_index); exit(1); } /////////// get psegname attribute str = getStringValue(reader, "psegname", &ok); if (ok == 0) { printf("[XML ERROR] illegal or missing for coproc %d in cluster %d\n", coproc_index, cluster_index); exit(1); } /////////// set psegid attribute int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str); if (index >= 0) { #if XML_PARSER_DEBUG printf(" clusterid = %d\n", cluster_index); printf(" psegname = %s\n", str); printf(" psegid = %d\n", index); #endif coproc[coproc_index]->psegid = index; assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" ); } else { printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", coproc_index, cluster_index, str ); exit(1); } ////////// set port_offset coproc[coproc_index]->port_offset = cp_port_index; #if XML_PARSER_DEBUG printf(" port_offset = %d\n", cp_port_index); #endif int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "port") == 0 ) { cpPortNode(reader); } else if (strcmp(tag, "#text") == 0 ) { } else if (strcmp(tag, "#comment") == 0 ) { } else if (strcmp(tag, "coproc") == 0 ) { coproc[coproc_index]->ports = cp_port_loc_index; cluster[cluster_index]->coprocs++; coproc_loc_index++; coproc_index++; return; } else { printf("[XML ERROR] Unknown tag %s", tag); exit(1); } status = xmlTextReaderRead(reader); } } // end coprocNode() ////////////////////////////////////// void procNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (proc_index >= MAX_PROCS) { printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS); exit(1); } #if XML_PARSER_DEBUG printf("\n proc %d\n", proc_index); #endif proc[proc_index] = (mapping_proc_t *) malloc(sizeof(mapping_proc_t)); /////////// get index attribute (optional) value = getIntValue(reader, "index", &ok); if (ok && (value != proc_loc_index)) { printf("[XML ERROR] wrong local proc index / expected value is %d", proc_loc_index); exit(1); } proc[proc_index]->index = proc_loc_index; cluster[cluster_index]->procs++; proc_loc_index++; proc_index++; total_procs++; } // end procNode() ////////////////////////////////////// void psegNode(xmlTextReaderPtr reader) { unsigned int ok; paddr_t ll_value; char * str; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; if (pseg_index >= MAX_PSEGS) { printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" pseg %d\n", pseg_index); #endif pseg[pseg_index] = (mapping_pseg_t *) malloc(sizeof(mapping_pseg_t)); /////// get name attribute str = getStringValue(reader, "name", &ok); #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif if (ok) { strncpy(pseg[pseg_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing for pseg %d in cluster %d\n", pseg_index, cluster_index); exit(1); } //////// get type attribute str = getStringValue(reader, "type", &ok); #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif if (ok && (strcmp(str, "RAM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_RAM; } else if (ok && (strcmp(str, "ROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; } else if (ok && (strcmp(str, "PERI") == 0)) { pseg[pseg_index]->type = PSEG_TYPE_PERI; } else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// get base attribute ll_value = getPaddrValue(reader, "base", &ok); #if XML_PARSER_DEBUG printf(" base = 0x%llx\n", ll_value); #endif if (ok) { pseg[pseg_index]->base = ll_value; } else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// get length attribute ll_value = getPaddrValue(reader, "length", &ok); #if XML_PARSER_DEBUG printf(" length = 0x%llx\n", ll_value); #endif if (ok) { pseg[pseg_index]->length = ll_value; } else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// set cluster attribute pseg[pseg_index]->clusterid = cluster_index; //////// set next_vseg attribute pseg[pseg_index]->next_vseg = 0; pseg_index++; cluster[cluster_index]->psegs++; } // end psegNode() ///////////////////////////////////////// void clusterNode(xmlTextReaderPtr reader) { unsigned int ok; unsigned int value; cluster[cluster_index] = (mapping_cluster_t *) malloc(sizeof(mapping_cluster_t)); //initialise variables that will be incremented by *Node() functions cluster[cluster_index]->psegs = 0; cluster[cluster_index]->procs = 0; cluster[cluster_index]->coprocs = 0; cluster[cluster_index]->periphs = 0; //initialise global variables proc_loc_index = 0; coproc_loc_index = 0; periph_loc_index = 0; // for replicated periph found_timer = 0; found_icu = 0; found_xcu = 0; found_dma = 0; found_mmc = 0; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG printf("\n cluster %d\n", cluster_index); #endif /////////// get x coordinate value = getIntValue(reader, "x", &ok); #if XML_PARSER_DEBUG printf(" x = %d\n", value); #endif if (ok && (value < header->x_size) ) { cluster[cluster_index]->x = value; } else { printf("[XML ERROR] Illegal or missing < x > attribute for cluster %d", cluster_index); exit(1); } /////////// get y coordinate value = getIntValue(reader, "y", &ok); #if XML_PARSER_DEBUG printf(" y = %d\n", value); #endif if (ok && (value < header->y_size) ) { cluster[cluster_index]->y = value; } else { printf("[XML ERROR] Illegal or missing < y > attribute for cluster %d", cluster_index); exit(1); } ////////// set offsets cluster[cluster_index]->pseg_offset = pseg_index; cluster[cluster_index]->proc_offset = proc_index; cluster[cluster_index]->coproc_offset = coproc_index; cluster[cluster_index]->periph_offset = periph_index; #if XML_PARSER_DEBUG printf(" pseg_offset = %d\n", pseg_index); printf(" proc_offset = %d\n", proc_index); printf(" coproc_offset = %d\n", coproc_index); printf(" periph_offset = %d\n", coproc_index); #endif ////////// get psegs, procs, coprocs and periphs int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "pseg") == 0) psegNode(reader); else if (strcmp(tag, "proc") == 0) procNode(reader); else if (strcmp(tag, "coproc") == 0) coprocNode(reader); else if (strcmp(tag, "periph") == 0) periphNode(reader); else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "cluster") == 0) { ///////// TIMER and ICU peripheral are mandatory when nprocs != 0 unsigned int procs = cluster[cluster_index]->procs; if ( procs && !found_timer && !found_xcu) { printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index); exit(1); } if ( procs && !found_icu && !found_xcu) { printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index); exit(1); } if (nb_procs_max < procs) nb_procs_max = procs; #if XML_PARSER_DEBUG printf(" psegs = %d\n", cluster[cluster_index]->psegs); printf(" procs = %d\n", cluster[cluster_index]->procs); printf(" coprocs = %d\n", cluster[cluster_index]->coprocs); printf(" periphs = %d\n", cluster[cluster_index]->periphs); printf(" end cluster %d\n", cluster_index); #endif cluster_index++; return; } status = xmlTextReaderRead(reader); } } // end clusterNode() ////////////////////////////////////////////// void clusterSetNode(xmlTextReaderPtr reader) { if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG printf("\n clusters set\n"); #endif int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "cluster") == 0) { clusterNode(reader); } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "clusterset") == 0) { // checking number of clusters if ( cluster_index != (header->x_size * header->y_size) ) { printf("[XML ERROR] Wrong number of clusters\n"); exit(1); } // checking TTY terminal for system boot if ( tty_channels == 0 ) { printf("[XML ERROR] missing TTY peripheral\n"); exit(1); } // checking IOC sub-types if ( (use_bdv + use_hba + use_spi) > 1 ) { printf("[XML ERROR] all IOC peripherals must have the same type\n"); exit(1); } #if XML_PARSER_DEBUG printf(" end cluster set\n\n"); #endif header->psegs = pseg_index; header->procs = proc_index; header->irqs = irq_index; header->coprocs = coproc_index; header->cp_ports = cp_port_index; header->periphs = periph_index; return; } else { printf("[XML ERROR] Unknown tag in clusterset node : %s",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end clusterSetNode() /////////////////////////////////////////// void globalSetNode(xmlTextReaderPtr reader) { if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG printf(" globals set\n"); #endif int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "vseg") == 0) { vsegNode( reader ); header->globals = header->globals + 1; } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "globalset") == 0) { #if XML_PARSER_DEBUG printf(" end global set\n\n"); #endif vseg_loc_index = 0; return; } else { printf("[XML ERROR] Unknown tag in globalset node : %s",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end globalSetNode() /////////////////////////////////////////// void vspaceSetNode(xmlTextReaderPtr reader) { if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) { return; } #if XML_PARSER_DEBUG printf("\n vspaces set\n"); #endif int status = xmlTextReaderRead ( reader ); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "vspace") == 0) { vspaceNode(reader); } else if (strcmp(tag, "#text" ) == 0 ) { } else if (strcmp(tag, "#comment" ) == 0 ) { } else if (strcmp(tag, "vspaceset") == 0 ) { header->vsegs = vseg_index; header->vobjs = vobj_index; header->tasks = task_index; return; } else { printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end globalSetNode() //////////////////////////////////////// void headerNode(xmlTextReaderPtr reader) { char * name; unsigned int value; unsigned int ok; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return; #if XML_PARSER_DEBUG printf("mapping_info\n"); #endif header = (mapping_header_t *) malloc(sizeof(mapping_header_t)); ////////// get name attribute name = getStringValue(reader, "name", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" name = %s\n", name); #endif strncpy( header->name, name, 31); } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } /////////// get signature attribute value = getIntValue(reader, "signature", &ok); if ( ok && (value == IN_MAPPING_SIGNATURE) ) { #if XML_PARSER_DEBUG printf(" signature = %x\n", value); #endif header->signature = IN_MAPPING_SIGNATURE; } else { printf("[XML ERROR] illegal or missing for mapping %s\n", header->name ); exit(1); } /////////// get x_width attribute value = getIntValue(reader, "x_width", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" x_width = %d\n", value); #endif header->x_width = value; } /////////// get y_width attribute value = getIntValue(reader, "y_width", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" y_width = %d\n", value); #endif header->y_width = value; } /////////// get x_size attribute unsigned int x_size = getIntValue(reader, "x_size", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" x_size = %d\n", x_size); #endif header->x_size = x_size; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } /////////// get y_size attribute unsigned int y_size = getIntValue(reader, "y_size", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" y_size = %d\n", y_size); #endif header->y_size = y_size; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } /////////// get x_io attribute unsigned int x_io = getIntValue(reader, "x_io", &ok); #if XML_PARSER_DEBUG printf(" x_io = %d\n", x_io); #endif if ( ok && (x_io < x_size) ) { header->x_io = x_io; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } /////////// get y_io attribute unsigned int y_io = getIntValue(reader, "y_io", &ok); #if XML_PARSER_DEBUG printf(" y_io = %d\n", y_io); #endif if ( ok &&(y_io < y_size) ) { header->y_io = y_io; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } // check the number of cluster if ( (x_size * y_size) >= MAX_CLUSTERS ) { printf("[XML ERROR] Number of clusters cannot be larger than %d\n", MAX_CLUSTERS); exit(1); } ///////// get irq_per_proc attribute value = getIntValue(reader, "irq_per_proc", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" irq_per_proc = %d\n", value); #endif header->irq_per_proc = value; } else { printf("[XML ERROR] illegal or missing attribute in mapping\n"); exit(1); } ///////// get use_ram_disk attribute (default = 0) value = getIntValue(reader, "use_ram_disk", &ok); if (ok) { #if XML_PARSER_DEBUG printf(" use_ram_disk = %d\n", value); #endif header->use_ram_disk = value; } else { header->use_ram_disk = 0; } ///////// set other header fields header->globals = 0; header->vspaces = 0; header->psegs = 0; header->vsegs = 0; header->vobjs = 0; header->tasks = 0; header->procs = 0; header->irqs = 0; header->coprocs = 0; header->cp_ports = 0; header->periphs = 0; int status = xmlTextReaderRead(reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "clusterset") == 0) { clusterSetNode(reader); } else if (strcmp(tag, "globalset") == 0) { globalSetNode(reader); } else if (strcmp(tag, "vspaceset") == 0) { vspaceSetNode(reader); } else if (strcmp(tag, "#text") == 0) { } else if (strcmp(tag, "#comment") == 0) { } else if (strcmp(tag, "mapping_info") == 0) { #if XML_PARSER_DEBUG printf("end mapping_info\n"); #endif return; } else { printf("[XML ERROR] Unknown tag in header node : %s\n",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end headerNode() /////////////////////////////////////// void BuildTable(int fdout, const char * type, unsigned int nb_elem, unsigned int elem_size, char ** table) { unsigned int i; // write element for (i = 0; i < nb_elem; i++) { if (elem_size != write(fdout, table[i], elem_size)) { printf("function %s: %s(%d) write error \n", __FUNCTION__, type, i); exit(1); } #if XML_PARSER_DEBUG printf("Building binary: writing %s %d\n", type, i); #endif } } ///////////////////////////////////// int open_file(const char * file_path) { //open file int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) ); if (fdout < 0) { perror("open"); exit(1); } //reinitialise the file if (ftruncate(fdout, 0)) { perror("truncate"); exit(1); } //#if XML_PARSER_DEBUG printf("%s\n", file_path); //#endif return fdout; } ///////////////////////////////////// void buildBin(const char * file_path) { unsigned int length; int fdout = open_file(file_path); #if XML_PARSER_DEBUG printf("Building map.bin for %s\n", header->name); printf("signature = %x\n", header->signature); printf("x_size = %d\n", header->x_size); printf("y_size = %d\n", header->y_size); printf("x_width = %d\n", header->x_width); printf("y_width = %d\n", header->y_width); printf("vspaces = %d\n", header->vspaces); printf("psegs = %d\n", header->psegs); printf("vobjs = %d\n", header->vobjs); printf("vsegs = %d\n", header->vsegs); printf("tasks = %d\n", header->tasks); printf("procs = %d\n", header->procs); printf("irqs = %d\n", header->irqs); printf("coprocs = %d\n", header->coprocs); printf("periphs = %d\n", header->periphs); #endif // write header to binary file length = write(fdout, (char *) header, sizeof(mapping_header_t)); if (length != sizeof(mapping_header_t)) { printf("write header error : length = %d \n", length); exit(1); } // write clusters BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char **) cluster); // write psegs BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char **) pseg); // write vspaces BuildTable(fdout, "vspace", vspace_index, sizeof(mapping_vspace_t), (char **) vspace); // write vsegs BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char **) vseg); // write vobjs BuildTable(fdout, "vobj", vobj_index, sizeof(mapping_vobj_t), (char **) vobj); // write tasks array BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char **) task); //building procs array BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char **) proc); //building irqs array BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char **) irq); //building coprocs array BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char **) coproc); //building cp_ports array BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_cp_port_t),(char **) cp_port); //building periphs array BuildTable(fdout, "periph", periph_index, sizeof(mapping_periph_t), (char **) periph); close(fdout); } // end buildBin() /////////////////////////////////////////////////////////////////////////////////// // this function set the values of vspace_id and vobj_id fields for all cp_ports /////////////////////////////////////////////////////////////////////////////////// void prepareBuild() { unsigned int i; for (i = 0; i < cp_port_index; i++) { int vspace_id = getVspaceId(cp_port_vobj_ref[i]->vspace_name); if (vspace_id < 0) { printf("[XML ERROR] illegal for cp_port %d,\n", i); exit(1); } cp_port[i]->vspaceid = vspace_id; int vobj_id = getVobjId( vspace_id, cp_port_vobj_ref[i]->vobj_name, vspace[vspace_id]->vobjs ); if (vobj_id >= 0) { #if XML_PARSER_DEBUG printf("\ncp_port = %d\n", i); printf(" vspace_name = %s\n", cp_port_vobj_ref[i]->vspace_name); printf(" vobj_name = %s\n", cp_port_vobj_ref[i]->vobj_name); printf(" vobj_index = %d\n", vobj_id); #endif cp_port[i]->mwmr_vobj_id = vobj_id; assert((vobj[vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR) && "coproc ports must refer a vobj of type MWMR"); } else { printf("[XML ERROR] not found for cp_port %d,\n", i); exit(1); } } } ////////////////////////////////////////// void file_write(int fdout, char * towrite) { unsigned int size = strlen(towrite); if (size != write(fdout, towrite, size)) { printf("file_write error"); exit(1); } } ////////////////////////////////////////////////// void def_int_write(int fdout, char * def, int num) { char buf[64]; sprintf(buf, "#define\t %s %d\n", def, num); file_write(fdout, buf); } ////////////////////////////////////////////////// void def_hex_write(int fdout, char * def, int num) { char buf[64]; sprintf(buf, "#define\t %s 0x%x\n", def, num); file_write(fdout, buf); } /////////////////////////////////// void genHd(const char * file_path) { int fdout = open_file(file_path); char prol[80]; sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name); char * ifdef = "#ifndef _HARD_CONFIG_H\n#define _HARD_CONFIG_H\n\n"; char * epil = "\n#endif //_HARD_CONFIG_H"; file_write(fdout, prol); file_write(fdout, ifdef); def_int_write(fdout, "X_SIZE ", header->x_size); def_int_write(fdout, "Y_SIZE ", header->y_size); def_int_write(fdout, "X_WIDTH ", header->x_width); def_int_write(fdout, "Y_WIDTH ", header->y_width); def_int_write(fdout, "X_IO ", header->x_io); def_int_write(fdout, "Y_IO ", header->y_io); file_write(fdout, "\n"); def_int_write(fdout, "TOTAL_PROCS ", total_procs); def_int_write(fdout, "NB_PROCS_MAX ", nb_procs_max); def_int_write(fdout, "NB_TASKS_MAX ", nb_tasks_max); file_write(fdout, "\n"); def_int_write(fdout, "NB_TIM_CHANNELS ", tim_channels); def_int_write(fdout, "NB_DMA_CHANNELS ", dma_channels); file_write(fdout, "\n"); def_int_write(fdout, "NB_TTY_CHANNELS ", tty_channels); def_int_write(fdout, "NB_IOC_CHANNELS ", ioc_channels); def_int_write(fdout, "NB_NIC_CHANNELS ", nic_channels); def_int_write(fdout, "NB_CMA_CHANNELS ", cma_channels); file_write(fdout, "\n"); def_int_write(fdout, "USE_XICU ", use_xcu); def_int_write(fdout, "USE_IOB ", use_iob); def_int_write(fdout, "USE_PIC ", use_pic); def_int_write(fdout, "USE_FBF ", use_fbf); file_write(fdout, "\n"); def_int_write(fdout, "USE_IOC_RDK ", header->use_ram_disk); def_int_write(fdout, "USE_IOC_HBA ", use_hba); def_int_write(fdout, "USE_IOC_BDV ", use_bdv); def_int_write(fdout, "USE_IOC_SPI ", use_spi); file_write(fdout, "\n"); def_int_write(fdout, "IRQ_PER_PROCESSOR ", header->irq_per_proc); file_write(fdout, epil); close(fdout); } //////////////////////////////////////////////////////// void ld_write(int fdout, char * seg, unsigned int addr) { char buf[64]; sprintf(buf, "%s = 0x%x;\n", seg, addr); file_write(fdout, buf); } ////////////////////////////////// void genLd(const char * file_path) { int fdout = open_file(file_path); unsigned int count; unsigned int vseg_id; unsigned int base; // vseg base unsigned int size; // vseg size char prol[80]; sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name); file_write(fdout, prol); // boot mandatory global vsegs for (vseg_id = 0 , count = 0 ; vseg_id < header->vsegs ; vseg_id++) { if ( strcmp(vseg[vseg_id]->name, "seg_boot_code") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_boot_code_base ", base); ld_write(fdout, "seg_boot_code_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_boot_data") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_boot_data_base ", base); ld_write(fdout, "seg_boot_data_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_boot_stack") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_boot_stack_base ", base); ld_write(fdout, "seg_boot_stack_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_boot_mapping") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_boot_mapping_base ", base); ld_write(fdout, "seg_boot_mapping_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_boot_buffer") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_boot_buffer_base ", base); ld_write(fdout, "seg_boot_buffer_size ", size); count++; } } if ( count != 5 ) { printf ("[XML ERROR] Missing mandatory Boot global vseg : only %d\n", count); printf ("Mandatory segments are :\n"); printf (" - seg_boot_code\n"); printf (" - seg_boot_data\n"); printf (" - seg_boot_stack\n"); printf (" - seg_boot_mapping\n"); printf (" - seg_boot_buffer\n"); exit(0); } file_write(fdout, "\n"); // kernel mandatory global vsegs for (vseg_id = 0, count = 0 ; vseg_id < header->vsegs ; vseg_id++) { if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_kernel_code_base ", base); ld_write(fdout, "seg_kernel_code_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_kernel_data_base ", base); ld_write(fdout, "seg_kernel_data_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_kernel_uncdata_base ", base); ld_write(fdout, "seg_kernel_uncdata_size ", size); count++; } else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 ) { base = vseg[vseg_id]->vbase; size = vobj[vseg[vseg_id]->vobj_offset]->length; ld_write(fdout, "seg_kernel_init_base ", base); ld_write(fdout, "seg_kernel_init_size ", size); count++; } } if ( count != 4 ) { printf ("[XML ERROR] Missing mandatory Kernel global vseg : only %d\n", count); printf ("Mandatory segments are :\n"); printf (" - seg_kernel_code\n"); printf (" - seg_kernel_data\n"); printf (" - seg_kernel_uncdata\n"); printf (" - seg_kernel_init\n"); exit(0); } file_write(fdout, "\n"); // boot and kernel optionnal global vsegs (pseudo ROMs) unsigned int seg_ram_disk_base = 0xFFFFFFFF; unsigned int seg_ram_disk_size = 0; unsigned int seg_reset_code_base = 0xFFFFFFFF; unsigned int seg_reset_code_size = 0; for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++) { if ( strcmp(vseg[vseg_id]->name, "seg_reset_code") == 0 ) { seg_reset_code_base = vseg[vseg_id]->vbase; seg_reset_code_size = vobj[vseg[vseg_id]->vobj_offset]->length; } if ( strcmp(vseg[vseg_id]->name, "seg_ram_disk") == 0 ) { seg_ram_disk_base = vseg[vseg_id]->vbase; seg_ram_disk_size = vobj[vseg[vseg_id]->vobj_offset]->length; } } ld_write(fdout, "seg_reset_code_base ", seg_reset_code_base); ld_write(fdout, "seg_reset_code_size ", seg_reset_code_size); ld_write(fdout, "seg_ram_disk_base ", seg_ram_disk_base); ld_write(fdout, "seg_ram_disk_size ", seg_ram_disk_size); file_write(fdout, "\n"); // fill the peripherals base address array set_periph_vbase_array(); // non replicated peripherals ld_write(fdout, "seg_cma_base ", periph_vbase_array[PERIPH_TYPE_CMA]); ld_write(fdout, "seg_fbf_base ", periph_vbase_array[PERIPH_TYPE_FBF]); ld_write(fdout, "seg_iob_base ", periph_vbase_array[PERIPH_TYPE_IOB]); ld_write(fdout, "seg_ioc_base ", periph_vbase_array[PERIPH_TYPE_IOC]); ld_write(fdout, "seg_nic_base ", periph_vbase_array[PERIPH_TYPE_NIC]); ld_write(fdout, "seg_rom_base ", periph_vbase_array[PERIPH_TYPE_ROM]); ld_write(fdout, "seg_sim_base ", periph_vbase_array[PERIPH_TYPE_SIM]); ld_write(fdout, "seg_tty_base ", periph_vbase_array[PERIPH_TYPE_TTY]); ld_write(fdout, "seg_pic_base ", periph_vbase_array[PERIPH_TYPE_PIC]); file_write(fdout, "\n"); // replicated peripherals ld_write(fdout, "seg_dma_base ", periph_vbase_array[PERIPH_TYPE_DMA]); ld_write(fdout, "seg_icu_base ", periph_vbase_array[PERIPH_TYPE_ICU]); ld_write(fdout, "seg_mmc_base ", periph_vbase_array[PERIPH_TYPE_MMC]); ld_write(fdout, "seg_tim_base ", periph_vbase_array[PERIPH_TYPE_TIM]); ld_write(fdout, "seg_xcu_base ", periph_vbase_array[PERIPH_TYPE_XCU]); file_write(fdout, "\n"); ld_write(fdout, "vseg_cluster_increment ", 0x00010000); close(fdout); } ////////////////////////////////////////////////////// char * buildPath(const char * path, const char * name) { char * res = calloc(strlen(path) + strlen(name) + 1, 1); strcat(res, path); strcat(res, "/"); strcat(res, name); return res; } ////////////////////////////////// int main(int argc, char * argv[]) { if (argc < 3) { printf("Usage: xml2bin \n"); return 1; } struct stat dir_st; if (stat( argv[2], &dir_st)) { perror("bad path"); exit(1); } if ((dir_st.st_mode & S_IFDIR) == 0) { printf("path is not a dir: %s", argv[2] ); exit(1); } char * map_path = buildPath(argv[2], "map.bin"); char * ld_path = buildPath(argv[2], "giet_vsegs.ld"); char * hd_path = buildPath(argv[2], "hard_config.h"); LIBXML_TEST_VERSION; int status; xmlTextReaderPtr reader = xmlReaderForFile(argv[1], NULL, 0); if (reader != NULL) { status = xmlTextReaderRead (reader); while (status == 1) { const char * tag = (const char *) xmlTextReaderConstName(reader); if (strcmp(tag, "mapping_info") == 0) { headerNode(reader); prepareBuild(); buildBin(map_path); genHd(hd_path); genLd(ld_path); } else { printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]); return 1; } status = xmlTextReaderRead(reader); } xmlFreeTextReader(reader); if (status != 0) { printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]); return 1; } } return 0; } // end main() // Local Variables: // tab-width: 4 // c-basic-offset: 4 // c-file-offsets:((innamespace . 0)(inline-open . 0)) // indent-tabs-mode: nil // End: // vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4