Subversion Repositories light52

#!/usr/bin/env python
"""
build_rom.py: Create VHDL package with ROM initialization constant from 
Intel-HEX object code file.
Please use with --help to get some brief usage instructions.
"""
__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 ""
    print "Additionally, any of these arguments can be given:"
    print "{h|help}                   Show help string and exit"
    print "{c|constant} <name>        Name of target VHDL object code constant"
    print "{p|package} <name>         Name of target VHDL package"
    print "{n|name} <name>            Name of project (used only in comments)"
    print "{o|output} <filename>      Target VHDL file name"
    print "{xcode} <number>           Size of XCODE memory in bytes"
    print "         (defaults to 2048)"
    print "{xdata} <number>           Size of XDATA memory in bytes"
    print "         (defaults to 0)"
    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 "Builds initialization package for Light52 MCU core."
    print "The object code bytes are converted to VHDL strings and then inserted"
    print "into the vhdl template, in place of tag @code_bytes@.\n"
    print "Template tags are replaced as follows:"
    print "@obj_pkg_name@        : Name of package in target vhdl file."
    print "@const_name@          : Name of object code constant (VHDL table)."
    print "@obj_size@            : Total size of code table in bytes."
    print "@obj_bytes@           : Array of object code bytes."
    print "@project_name@        : 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 read and parse the input Intel HEX object code file.
    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 into 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)