Subversion Repositories light52

#!/usr/bin/env python
"""
build_rom.py: Create VHDL package with ROM initialization constant from 
Intel-HEX object code file.
"""
__author__ = "Jose A. Ruiz"
__license__ = "LGPL"
 
 
"""
Please see the usage instructions and the comments for function 'main'.
"""
 
 
import sys
import getopt
 
 
 
def usage():
    """Print usage instructions"""
    print ""
    print "usage:"
    print "python build_rom.py [arguments]\n"
    print "Builds VHDL ROM constant from template and Intel HEX object file.\n"
    print "ALL of the following arguments should be given, in any order:"
    print "{f|file} <filename>        Object code file name"
    print "{c|constant} <name>        Name of target VHDL constant"
    print "{p|package} <name>         Name of target VHDL package"
    print "{n|name} <name>            Name of project (used only in comment)"
    print "{o|output} <filename>      Target VHDL file name"
    print ""
    print "Additionally, any of these arguments can be given:"
    print "{v|vhdl} <filename>        VHDL template"
    print "         (defaults to templates/obj_code_kg_template.vhdl)"
    print "{i|indent} <number>        Indentation in VHDL tables (decimal)"
    print "         (defaults to 4)"
 
 
def help():
    """Print help message a bit longer than usage message."""
    print "\nPurpose:\n"
    print "Reads the code and data binary files and 'slices' them in byte"
    print "columns."
    print "The data columns are converted to VHDL strings and then inserted"
    print "into the vhdl template, in place of tags @code0@ .. @code3@ and "
    print "@data0@ .. @data3@. Column 0 is LSB and column3 is MSB.\n"
    print "Tags like @data31@ and @data20@ etc. can be used to initialize"
    print "memories in 16-bit buses, also split in byte columns.\n"
    print "Template tags are replaced as follows:"
    print "@obj_pkg_name@        : Name of package in target vhdl file."
    print "@const_name@          : Name of constant (VHDL table)."
    print "@obj_size@            : Total size of code table in bytes."
    print "@project@             : Project name."
    print "@xcode_size@          : Size of XCODE memory."
    print "@xdata_size@          : Size of XDATA memory."
 
def parse_hex_line(line):
    """Parse code line in HEX object file."""
    line = line.strip()
    slen = int(line[1:3],16)
    sloc = int(line[3:7],16)
    stype = line[7:9]
    sdata = line[9:len(line)-2]
    schk = int(line[len(line)-2:],16)
 
    csum = slen + int(sloc / 256) + (sloc % 256) + int(stype,16)
    bytes = [0, ] * slen
    for i in range(slen):
        sbyte = int(sdata[i*2:i*2+2],16)
        bytes[i] = sbyte;
        csum = csum + sbyte
 
    csum = ~csum
    csum = csum + 1
    csum = csum % 256
    if csum != schk:
        return (None, None)
 
    return (sloc, bytes)
 
 
def read_ihex_file(ihex_filename):
    """
    Read Intel HEX file into a 64KB array.
    The file is assumed not to have any object code outside the 64K boundary.
    Return the 64K array plus the size and bounds of the read data.
    """
 
    # CODE array, initialized to 64K of zeros...
    xcode = [0, ] * 65536
    # ...and code boundaries, initialized out of range.
    bottom = 100000
    top = -1
    (xcode, top, bottom)
 
    # Read the whole file to a list of lines...
    fin = open(ihex_filename, "r")
    ihex_lines = fin.readlines()
    fin.close()
 
    # ...and parse the lines one by one.
    total_bytes = 0
    for line in ihex_lines:
        (address, bytes) = parse_hex_line(line)
        if address == None:
            print "Checksum error!"
            sys.exit(1)
        total_bytes = total_bytes + len(bytes)
        for i in range(len(bytes)):
            xcode[address + i] = bytes[i]
 
        if address < bottom:
            bottom = address
 
        if (address + len(bytes)) > top:
            top = (address + len(bytes))
 
    print "Read %d bytes from file '%s'" % (total_bytes, ihex_filename)
    print "Code range %04xh to %04xh" % (bottom, top)
    return (xcode, total_bytes, bottom, top)
 
 
def build_vhdl_code(params, xcode, obj_size):
    """
    Read VHDL template file and replace all the tags with the values given in
    the command line parameters.
    Return the new file contents as a string.
    """
 
    # The resulting VHDL text will be stored here.
    vhdl_code = ""
 
 
    # Open file and read it into a list of lines.
    fin = open(params['template'], "r")
    lines = fin.readlines()
    fin.close()
 
    # Now process the template lines one by one.
    for line in lines:
        line = line.strip()
 
        if line.rfind("@obj_bytes@") >= 0:
            # insert object code as list of byte literals.
            obj_str = "    "
            for i in range(obj_size):
                if i != (obj_size-1):
                    sbyte = "X\"%02x\", " % xcode[i]
                else:
                    sbyte = "X\"%02x\" " % xcode[i]
                obj_str = obj_str + sbyte
                if (i % 8) == 7:
                    obj_str = obj_str + "\n    "
 
            line = line.replace("@obj_bytes@",obj_str)
 
        elif line.rfind("@obj_size@") >= 0:
            # Insert object code size (not necessarily equal to xcode_size)
            line = line.replace("@obj_size@","%d" % (obj_size-1))
 
        elif line.rfind("@xcode_size@") >= 0:
            # Insert XCODE memory
            line = line.replace("@xcode_size@","%d" % (params['xcode_size']))
 
        elif line.rfind("@xdata_size@") >= 0:
            # Insert XDATA memory
            line = line.replace("@xdata_size@","%d" % (params['xdata_size']))
 
        elif line.rfind("@obj_pkg_name@") >= 0:
            # Insert package name: hardwired
            line = line.replace("@obj_pkg_name@",params['package'])
 
        elif line.rfind("@project_name@") >= 0:
            # Insert project name 
            line = line.replace("@project_name@",params['project'])
 
 
        vhdl_code = vhdl_code + line + "\n"
 
    return vhdl_code
 
 
def main(argv):
    """Main body of the program."""
 
    # Parse command line parameters using GetOpt 
    try:                                
        opts, args = getopt.getopt(argv, "hf:n:p:c:o:i:v:", 
        ["help", "file=", "name=", "package=", "constant=", 
         "output=", "indent=", "vhdl=", "xcode=", "xdata=" ])
    except getopt.GetoptError, err:
        print ""
        print err
        usage()
        sys.exit(2)  
 
    # Command line parameters, initialized to their default values
    params = {'project':    '<unknown>',
              'package':    'obj_code_pkg',
              'indent':     4,
              'constant':   'obj_code',
              'target':     'obj_code_pkg.vhdl',
              'hex':        '',
              'xcode_size': 2048,
              'xdata_size': 0,
              'template':   "./templates/obj_code_pkg_template.vhdl"
              }
 
 
    # Parse coommand line parameters
    for opt, arg in opts:
        if opt in ("-h", "--help"):
            usage()
            help()
            exit(1)
        if opt in ("-v", "--vhdl"):
            params['template'] = arg
        elif opt in ("-o", "--output"):
            params['target'] = arg
        elif opt in ("-c", "--constant"):
            params['constant'] = arg
        elif opt in ("-f", "--file"):
            params['hex'] = arg
        elif opt in ("-p", "--package"):
            params['package'] = arg
        elif opt in ("-n", "--name"):
            params['project'] = arg
        elif opt in ("-i", "--indent"):
            params['indent'] = int(arg)
        elif opt in ("--xcode"):
            params['xcode_size'] = int(arg)
        elif opt in ("--xdata"):
            params['xdata_size'] = int(arg)
 
    # Ok, now 
    if params['hex']:
        (xcode, total_bytes, bottom, top) = read_ihex_file(params['hex']);
    else:
        print "Object HEX file name missing.";
        usage()
        return 1
 
 
    # Make sure the object code fits the implemented XCODE space.
    # If it doesn't, print a warning and let the user deal with it.
    # Assuming that XCODE starts at address zero -- that's how the core works.
    if params['xcode_size'] < top:
        print "\nWARNING: Object code does not fit XCODE space!\n"
 
 
    # Build the package source...
    vhdl_code = build_vhdl_code(params, xcode, top);
 
    # ...and write it to the target file.
    fout = None
    try:
        fout = open(params['target'], "w")
        fout.write(vhdl_code)
        fout.close()
        print "VHDL code table written to %s" % params['target']
    except:
        print "Trouble opening %s for output" % params['target']
    finally:
        if fout: fout.close()
 
 
if __name__ == "__main__":
    main(sys.argv[1:])
    sys.exit(0)