Changeset 16fd5a9 in rtems for tools/cpu/nios2/nios2gen.c


Ignore:
Timestamp:
Aug 15, 2006, 9:02:55 PM (13 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
67eede5
Parents:
5f88544
Message:

2006-08-15 Kolja Waschk <kawk@…>

  • linkcmds.c, linkcmds.h, memory.c, memory.h, sample.ptf: New files.
  • bridges.c: corrected detection of bridged connections
  • clocks.c: removed a printf
  • linkcmds.[ch] new files, added output of linker script
  • Makefile.am: added new files
  • memory.[ch]: new files, detection of memory in SOPC configuration
  • nios2gen.c: updated command line parsing and output control
  • output.[ch]: improved output of BSP header file
  • ptf.[ch]: added ptf_dump_ptf_item and small fixes
  • sample.ptf: new file, sample configuration for nios2gen
  • README: updated
File:
1 edited

Legend:

Unmodified
Added
Removed
  • tools/cpu/nios2/nios2gen.c

    r5f88544 r16fd5a9  
    1717#include "clocks.h"
    1818#include "devices.h"
     19#include "memory.h"
    1920#include "output.h"
     21#include "linkcmds.h"
     22
     23#define NIOS2GEN_PACKAGE PACKAGE
     24#define NIOS2GEN_VERSION VERSION
     25
     26#include "getopt.h"
    2027
    2128/********************************************************/
     
    6572}
    6673
    67 void usage()
    68 {
    69 printf(
    70   "Usage: nios2gen [PTFFILE]\n"
    71   "Generate BSP data based upon PTF file from SOPC Builder.\n"
    72   "\n"
    73   "Please specify the name of a nios2gen PTF file that describes where to\n"
    74   "find the system description PTF from SOPC Builder on the command line.\n"
    75 );
    76 }
    77 
    78 void version()
    79 {
    80 printf(
    81   "RTEMS/NIOS nios2gen\n"
     74/********************************************************/
     75
     76void version(FILE *f)
     77{
     78fprintf(f,
     79  "nios2gen (" __DATE__ ")\n"
    8280  "  Copyright (c) 2006 Kolja Waschk rtemsdev/ixo.de\n"
    8381  "\n"
     
    8583  "  found in the file LICENSE in this distribution or at\n"
    8684  "  http://www.rtems.com/license/LICENSE.\n"
     85  , VERSION
    8786);
     87}
     88
     89void usage (FILE *f, char *errmsg)
     90{
     91  char *info = "Purpose:\n  Create RTEMS nios2 BSP configuration from Altera SOPC description\n";
     92  if(errmsg) info=errmsg;
     93  version(f);
     94  fprintf(f,"\n%s\nUsage: nios2gen [OPTIONS] <SOPC PTF> [CONFIG PTF] [CONFIG PTF]...\n", info);
     95  fprintf(f,"   -h         --help               Print help and exit\n");
     96  fprintf(f,"   -V         --version            Print version and exit\n");
     97  fprintf(f,"   -bFILENAME --bspheader=FILENAME Output BSP configuration header file (default='sopc.h')\n");
     98  fprintf(f,"   -B         --no-bspheader       Do not output BSP configuration header file\n");
     99  fprintf(f,"   -lFILENAME --linkcmds=FILENAME  Output linker script (default='linkcmds')\n");
     100  fprintf(f,"   -L         --no-linkcmds        Do not output linker script\n");
     101  fprintf(f,"   -pFILENAME --parsed=FILENAME    Output PTF contents as long list (default: don't)\n");
     102  fprintf(f,"   -P         --no-parsed          Do not output PTF contents as long list\n");
     103  fprintf(f,"   -q         --quiet              Do not print progress info to stdout\n\n");
     104  fprintf(f,"Using \"-\" as the FILENAME means standard output (stdout).\n");
    88105}
    89106
     
    97114    bus_bridge_pair *bridges;
    98115    clock_desc *clocks;
    99 
    100     if (argc<2)
    101     {
    102         usage();
     116    memory_desc *memory;
     117
     118    int verbose = 1;
     119    int output_order = 127;
     120    char *parsed_filename = NULL;
     121    int output_parsed = 0;
     122    char *bspheader_filename = "sopc.h";
     123    int output_bspheader = 1;
     124    char *linkcmds_filename = "linkcmds";
     125    int output_linkcmds = 2;
     126
     127    optarg = 0;
     128    optind = 1;
     129    opterr = 1;
     130    optopt = '?';
     131
     132    if(argc > 126)
     133    {
     134      usage(stderr,"Too many commandline arguments!\n");
     135      return -1;
     136    };
     137
     138    while(1)
     139    {
     140      int c, long_index = 0;
     141      static char *optstring = "hVBb:Ll:Pp:q";
     142
     143      static struct option long_options[] =
     144      {
     145        { "help",           0, NULL, 'h' },
     146        { "version",        0, NULL, 'V' },
     147        { "no-bspheader",   0, NULL, 'B' },
     148        { "bspheader",      1, NULL, 'b' },
     149        { "no-linkcmds",    0, NULL, 'L' },
     150        { "linkcmds",       1, NULL, 'l' },
     151        { "no-parsed",      0, NULL, 'P' },
     152        { "parsed",         1, NULL, 'p' },
     153        { "quiet",          0, NULL, 'q' },
     154        { NULL, 0, NULL, 0 }
     155      };
     156
     157      c = getopt_long (argc, argv, optstring, long_options, &long_index);
     158
     159      if(c == -1) break; /* Exit from while(1) loop */
     160
     161      switch(c)
     162      {
     163      case 'q': /* Be quiet */
     164        verbose = 0;
     165        break;
     166
     167      case 'h': /* Print help and exit */
     168        usage(stdout,NULL);
     169        return 0;
     170
     171      case 'V': /* Print version and exit */
     172        version(stdout);
     173        return 0;
     174
     175      case 'B': /* Do not output BSP configuration header file */
     176        output_bspheader = 0;
     177        break;
     178
     179      case 'b': /* Output BSP configuration header file */
     180        bspheader_filename = optarg;
     181        output_bspheader = output_order;
     182        output_order--;
     183        break;
     184
     185      case 'L': /* Do not output linker script */
     186        output_linkcmds = 0;
     187        break;
     188
     189      case 'l': /* Output linker script */
     190        linkcmds_filename = optarg;
     191        output_linkcmds = output_order;
     192        output_order--;
     193        break;
     194
     195      case 'P': /* Do not output PTF contents */
     196        output_parsed = 0;
     197        break;
     198
     199      case 'p': /* Output PTF contents as long list */
     200        parsed_filename = optarg;
     201        output_parsed = output_order;
     202        output_order--;
     203        break;
     204
     205      case 0:
     206      case '?':
    103207        return -1;
    104     };
    105 
    106     if ( !strcmp(argv[1], "--help") || !strcmp(argv[1],"-?") ) {
    107         usage();
    108         return 0;
    109     };
    110 
    111     if ( !strcmp(argv[1], "--version") ) {
    112         version();
    113         return 0;
    114     };
    115 
    116     cfg = ptf_parse_file(argv[1]);
    117     if(cfg == NULL)
    118     {
    119         fprintf(stderr, "Couldn't parse '%s'.\n", argv[1]);
     208
     209      default:
     210        fprintf(stderr, "%s: unknown option: %c\n", NIOS2GEN_PACKAGE, c);
     211      };
     212    };
     213
     214    if(optind >= argc)
     215    {
     216        usage(stderr,"No PTF specified!\n");
    120217        return -1;
    121218    };
    122219
    123     printf("Successfully read config PTF file %s.\n", argv[1]);
    124 
    125     /********************************************************/
     220    /********************************************************/
     221
     222    sopc = ptf_parse_file(argv[optind]);
     223    if(sopc == NULL)
     224    {
     225        fprintf(stderr, "Could not parse system description PTF '%s'.\n", argv[optind]);
     226        return -1;
     227    };
     228
     229    if(verbose) printf("Successfully read SOPC PTF file %s.\n", argv[optind]);
     230
     231    /********************************************************/
     232
     233    cfg = NULL;
     234
     235    for(optind++;optind<argc;optind++)
     236    {
     237      struct ptf *morecfg = ptf_parse_file(argv[optind]);
     238
     239      if(morecfg == NULL)
     240      {
     241        fprintf(stderr, "Couldn't parse '%s'.\n", argv[optind]);
     242        return -1;
     243      };
     244 
     245      if(verbose) printf("Successfully read config PTF file %s.\n", argv[optind]);
     246
     247      cfg = ptf_concat(cfg, morecfg);
     248    };
     249
     250    /********************************************************/
     251    /* Pull in include files specified in the configs; */
     252    /* Only one level is read; included files are not */
     253    /* checked for further INCLUDEs */
    126254
    127255    {
     
    132260
    133261    /********************************************************/
    134    
    135     {
    136       struct ptf *p;
    137       struct ptf sopc_ptf_item = { item, "SOPC_PTF", 0, 0, 0 };
    138       struct ptf_item sopc_ptf_spec = { 1, &sopc_ptf_item };
    139       ptf_match(cfg, &sopc_ptf_spec, store_ptf_ptr, &p);
    140 
    141       if(p == NULL)
    142       {
    143           fprintf(stderr, "Missing 'SOPC_PTF' filename in %s!\n", argv[1]);
    144           return -1;
    145       };
    146 
    147       sopc = ptf_parse_file(p->value);
    148       if(sopc == NULL)
    149       {
    150           fprintf(stderr, "Could not parse SOPC_PTF '%s'.\n", p->value);
    151           return -1;
    152       };
    153 
    154       printf("Successfully read SOPC PTF file %s.\n", p->value);
    155     };
    156 
    157     /********************************************************/
    158262    /* Find CPU */
    159263
    160     printf("Looking for usable CPUs...\n");
    161 
     264    if(verbose) printf("Looking for usable CPUs...\n");
     265
     266    /* Check if a CPU has been specified in the config PTF */
    162267    {
    163268      struct ptf modules         = { section, "MODULES", 0, 0, 0 };
     
    168273    };
    169274
     275    /* Look for CPUs in system description PTF */
    170276    {
    171277      int cpu_count;
     
    181287      if(cpu_count > 1)
    182288      {
    183         printf("There is more than one CPU. Please specify the one\n");
    184         printf("you want to use with this BSP in your config file.\n");
    185         printf("The available CPUs are named as follows:\n");
     289        fprintf(stderr, "There is more than one CPU. Please specify the one\n");
     290        fprintf(stderr, "you want to use with this BSP in your config file.\n");
     291        fprintf(stderr, "The available CPUs are named as follows:\n");
    186292        ptf_match(sopc, &class_spec, printf_ptf_value, "  %s\n");
    187293        return -1; 
     
    190296      if(cpu_count == 0)
    191297      {
    192         printf("There is no NIOS2 cpu in the system.\n");
     298        fprintf(stderr, "There is no NIOS2 cpu in the system.\n");
    193299        return -1; 
    194300      }
    195301    };
    196302
    197     printf("Using NIOS II CPU '%s'.\n", cpu->value);
    198     printf("Only modules mastered by this CPU are considered now.\n");
     303    if(verbose)
     304    {
     305      printf("Using NIOS II CPU '%s'.\n", cpu->value);
     306      printf("Only modules mastered by this CPU are considered now.\n");
     307    };
     308
     309    /********************************************************/
     310    /* Find Bridges */
     311
     312    if(verbose) printf("Looking for bus bridges...\n");
     313
     314    bridges = find_bridges(sopc);
     315
     316    if(verbose)
     317    {
     318      if(bridges)
     319      {
     320        bus_bridge_pair *bbp;
     321        for(bbp = bridges; bbp; bbp=bbp->next)
     322        {
     323          printf("Found bridge: %s\n", bbp->mastered_by);
     324          printf("               \\_%s\n", bbp->bridges_to);
     325        };
     326      }
     327      else
     328      {
     329        printf("No bridges present.\n");
     330      };
     331    };
    199332
    200333    /********************************************************/
    201334    /* Find clocks */
    202335
    203     printf("Looking for clock definitions...\n");
     336    if(verbose) printf("Looking for clock definitions...\n");
    204337
    205338    clocks = find_clocks(sopc, cfg);
    206339
    207     if(clocks)
    208     {
    209       clock_desc *cs;
    210       for(cs = clocks; cs; cs = cs->next)
    211       {
    212         printf("Found clock: %s (%lu Hz)\n", cs->name, cs->freq);
    213       };
    214     }
    215     else
    216     {
    217       printf("No clocks present.\n");
    218     };
    219 
    220     /********************************************************/
    221     /* Find Bridges */
    222 
    223     printf("Looking for bus bridges...\n");
    224 
    225     bridges = find_bridges(sopc);
    226 
    227     if(bridges)
    228     {
    229       bus_bridge_pair *bbp;
    230       for(bbp = bridges; bbp; bbp=bbp->next)
    231       {
    232         printf("Found bridge: %s\n", bbp->mastered_by);
    233         printf("               \\_%s\n", bbp->bridges_to);
    234       };
    235     }
    236     else
    237     {
    238       printf("No bridges present.\n");
     340    if(verbose)
     341    {
     342      if(clocks)
     343      {
     344        clock_desc *cs;
     345        for(cs = clocks; cs; cs = cs->next)
     346        {
     347          printf("Found clock \"%s\" (%lu Hz), naming it %s\n", cs->name, cs->freq, cs->cfgname);
     348        };
     349      }
     350      else
     351      {
     352        printf("No clocks present.\n");
     353      };
    239354    };
    240355
     
    242357    /* Find other devices available to the selected CPU */
    243358
     359    if(verbose) printf("Looking for devices...\n");
     360
    244361    devices = find_devices(sopc, cfg, cpu, bridges);
    245362
    246     fwrite_header_file(stdout, cfg, devices, clocks);
    247 
    248     // ptf_printf(stdout, ptf, "");
    249     // ptf_printf(stdout, cfg, "");
     363    if(verbose)
     364    {
     365      if(devices)
     366      {
     367        device_desc *dd;
     368        for(dd = devices; dd; dd=dd->next)
     369        {
     370          printf("Found device \"%s\", naming it %s\n", dd->ptf->value, dd->cfgname);
     371        };
     372      }
     373      else
     374      {
     375        printf("No devices present.\n");
     376      };
     377    };
     378
     379    /********************************************************/
     380    /* Find out which devices are actually memory */
     381
     382    if(verbose) printf("Looking for memory...\n");
     383
     384    memory = find_memory(devices);
     385   
     386    if(verbose)
     387    {
     388      if(memory)
     389      {
     390        memory_desc *md;
     391        for(md = memory; md; md=md->next)
     392        {
     393          printf("Found memory in \"%s\", base=0x%08X, size=%lu bytes\n",
     394                          md->dev->cfgname,
     395                          md->base, md->size);
     396        };
     397      }
     398      else
     399      {
     400        printf("None of the devices seems to provide memory?!\n");
     401      };
     402    };
     403
     404
     405    /********************************************************/
     406    /* Output files in the order they were specified
     407       on the command line */
     408
     409    {
     410      int i;
     411      for(i=0;i<3;i++)
     412      {
     413        if(output_bspheader>0
     414           && output_bspheader>=output_linkcmds
     415           && output_bspheader>=output_parsed)
     416        {
     417          output_bspheader = 0;
     418          if(bspheader_filename == NULL || (bspheader_filename[0]=='-' && bspheader_filename[1]==0))
     419          {
     420            fwrite_header_file(stdout, cfg, devices, clocks);
     421          }
     422          else
     423          {
     424            FILE *f = fopen(bspheader_filename, "w");
     425            if(!f)
     426            {
     427              perror(bspheader_filename);
     428              return -1;
     429            }
     430            else
     431            {
     432              fwrite_header_file(f, cfg, devices, clocks);
     433              fclose(f);
     434            }
     435          }
     436        };
     437        if(output_linkcmds>0
     438           && output_linkcmds>=output_bspheader
     439           && output_linkcmds>=output_parsed)
     440        {
     441          output_linkcmds = 0;
     442          if(linkcmds_filename == NULL || (linkcmds_filename[0]=='-' && linkcmds_filename[1]==0))
     443          {
     444            fwrite_linkcmds_file(stdout, cfg, cpu, devices, memory);
     445          }
     446          else
     447          {
     448            FILE *f = fopen(linkcmds_filename, "w");
     449            if(!f)
     450            {
     451              perror(linkcmds_filename);
     452              return -1;
     453            }
     454            else
     455            {
     456              fwrite_linkcmds_file(f, cfg, cpu, devices, memory);
     457              fclose(f);
     458            }
     459          }
     460        };
     461        if(output_parsed>0
     462           && output_parsed>=output_linkcmds
     463           && output_parsed>=output_bspheader)
     464        {
     465          output_parsed = 0;
     466          if(parsed_filename == NULL || (parsed_filename[0]=='-' && parsed_filename[1]==0))
     467          {
     468            ptf_printf(stdout, sopc, "");
     469          }
     470          else
     471          {
     472            FILE *f = fopen(parsed_filename, "w");
     473            if(!f)
     474            {
     475              perror(parsed_filename);
     476              return -1;
     477            }
     478            else
     479            {
     480              ptf_printf(f, sopc, "");
     481              fclose(f);
     482            }
     483          }
     484        };
     485      }
     486    };
     487
     488    if(verbose) printf("Done.\n");
    250489
    251490    return 0;
Note: See TracChangeset for help on using the changeset viewer.