248 lines
10 KiB
Python
248 lines
10 KiB
Python
# -----------------------------------------------------------------------------
|
|
# Title : VHDL register definition package generator
|
|
# Project : Generic FW tools
|
|
# -----------------------------------------------------------------------------
|
|
# File : gen_pkg.py
|
|
# Author : Simon Southwell
|
|
# Company : Global Inkjet Systems
|
|
# Created : 2017-12-04
|
|
# Last update: 2017-12-13
|
|
# Platform :
|
|
# Standard : Python 3.x
|
|
# -----------------------------------------------------------------------------
|
|
# Description:
|
|
# Definition of class to read JSON register definitions and generate a VHDL
|
|
# package with constant definitions for address offsets and subtypes
|
|
# for bit-slicing the sub-fields. Inherits MemMapperBase for methods
|
|
# to read JSON files and produce a model.
|
|
# -----------------------------------------------------------------------------
|
|
# Copyright (c) 2017 Global Inkjet Systems
|
|
# -----------------------------------------------------------------------------
|
|
|
|
import os
|
|
import argparse
|
|
|
|
# Import base class to locate and read JSON files, and present a model
|
|
# to derived child class.
|
|
import memMapperBase
|
|
from memMapperBase import MemMapperBase, attr, regtype
|
|
|
|
# ---------------------------------------------------------
|
|
# Class to generate a VHDL file with some useful register
|
|
# constants in it, from the set of JSON definitions for a
|
|
# project.
|
|
# ---------------------------------------------------------
|
|
|
|
class MemMapperPkg(MemMapperBase) :
|
|
|
|
outputNameWidth = 35
|
|
|
|
# ---------------------------------------------------------
|
|
# Constructor
|
|
# ---------------------------------------------------------
|
|
def __init__(self) :
|
|
|
|
print('MemMapperPkg')
|
|
|
|
MemMapperBase.__init__(self)
|
|
|
|
# ---------------------------------------------------------
|
|
# Returns a string that is the input string padded with
|
|
# spaces to fit the width
|
|
# ---------------------------------------------------------
|
|
@staticmethod
|
|
def __padString(rawStr, width) :
|
|
|
|
rtnStr = rawStr
|
|
rtnStrLen = len(rtnStr)
|
|
|
|
if rtnStrLen < width :
|
|
rtnStr += ' ' * (width - rtnStrLen)
|
|
|
|
return rtnStr
|
|
|
|
# ---------------------------------------------------------
|
|
# Overload base classes virtual function with specific
|
|
# output generation (VHDL package)
|
|
# ---------------------------------------------------------
|
|
def genOutput(self, ip, opDir='', opSuffix='') :
|
|
|
|
# Fetch the JSON path and the dictionary with the parsed data
|
|
jsonPath, jsonDict = self._getModel(ip)
|
|
|
|
# What's the path separator? Usually '\\' for windows, else '/'
|
|
sep = os.sep
|
|
|
|
# Generate specific output in the doc/ directory where the JSON file is located
|
|
if opDir == '':
|
|
srcDir = sep.join(jsonPath.split(sep)[:-2]) + sep + 'src'
|
|
else:
|
|
srcDir = opDir
|
|
|
|
# Check destination directory exists, and create it if not
|
|
if not os.path.exists(srcDir) :
|
|
os.makedirs(srcDir)
|
|
|
|
writeFileName = srcDir + sep + ip + '_pkg' + opSuffix + '.vhd'
|
|
wfp = open(writeFileName, 'w')
|
|
|
|
wfp.write('-- Block name: ' + jsonDict[0][attr.IP_NAME] + '\n')
|
|
wfp.write('-- And now for some register addresses...\n')
|
|
wfp.write('-- altera vhdl_input_version vhdl_2008\n')
|
|
wfp.write('library ieee;\n')
|
|
wfp.write('use ieee.std_logic_1164.all;\n')
|
|
wfp.write('use ieee.numeric_std.all;\n\n')
|
|
wfp.write('package ' + ip + '_pkg is\n\n')
|
|
|
|
# Iterate through each bus dictionary
|
|
for jsonBusDict in jsonDict :
|
|
|
|
# Get the bus name from the dictionary
|
|
bus = jsonBusDict[attr.BUS]
|
|
|
|
# If a hierarchy block, process
|
|
if attr.SUB_BLOCKS in jsonBusDict:
|
|
subBlockDict = jsonBusDict[attr.SUB_BLOCKS]
|
|
|
|
for sbEntryKey in subBlockDict :
|
|
|
|
sbEntry = sbEntryKey.split(':')[0]
|
|
offset = subBlockDict[sbEntryKey][attr.OFFSET]
|
|
|
|
if subBlockDict[sbEntryKey][attr.INSTANCE] == '':
|
|
instance = ''
|
|
else:
|
|
instance = '_' + subBlockDict[sbEntryKey][attr.INSTANCE]
|
|
|
|
constName = bus.upper() + '_' + sbEntry.upper() + instance.upper()
|
|
|
|
constNameVec = constName + '_ADDR'
|
|
constNameVec = MemMapperPkg.__padString(constNameVec, MemMapperPkg.outputNameWidth)
|
|
|
|
constNameInt = constName + '_ADDR_INT'
|
|
constNameInt = MemMapperPkg.__padString(constNameInt, MemMapperPkg.outputNameWidth)
|
|
|
|
wfp.write(' constant ' + constNameVec + ' : std_logic_vector(31 downto 0) := 32x"' + format(int(offset, 0), '08X') + '";\n')
|
|
wfp.write(' constant ' + constNameInt + ' : integer := 16#' + format(int(offset, 0), '08X') + '#;\n')
|
|
|
|
wfp.write('\n')
|
|
|
|
# If a hierarchy block, skip
|
|
if attr.REGISTERS not in jsonBusDict:
|
|
continue
|
|
|
|
# Determine the address decode width if specified with addr_width and/or hi and lo address bits,
|
|
# else default to 32
|
|
if attr.ADDR_WIDTH in jsonBusDict :
|
|
addrWidthInt = int(jsonBusDict[attr.ADDR_WIDTH], 0)
|
|
elif attr.ADDR_HI_BIT in jsonBusDict :
|
|
addrWidthInt = int(jsonBusDict[attr.ADDR_HI_BIT], 0) - int(jsonBusDict[attr.ADDR_LO_BIT], 0) + 1
|
|
else :
|
|
addrWidthInt = 32
|
|
|
|
# Only process the bus in the bus list
|
|
if bus in self.busList :
|
|
|
|
regDict = jsonBusDict[attr.REGISTERS]
|
|
regKeys = regDict.keys()
|
|
|
|
for regName in regKeys :
|
|
|
|
# An '_ADDR' suffix for the register address definition
|
|
regFullName = MemMapperBase.createPkgTag(bus, regName)
|
|
regFullUsName = regFullName + '_US'
|
|
regFullIntName = regFullName + '_INT'
|
|
|
|
# Pad the output string to a fixed value
|
|
regFullName = MemMapperPkg.__padString(regFullName, MemMapperPkg.outputNameWidth)
|
|
regFullUsName = MemMapperPkg.__padString(regFullUsName, MemMapperPkg.outputNameWidth)
|
|
regFullIntName = MemMapperPkg.__padString(regFullIntName, MemMapperPkg.outputNameWidth)
|
|
|
|
# Output the address declaration for this register
|
|
opStr = ' constant ' + regFullName + ' : std_logic_vector(' + str(addrWidthInt-1) + ' downto 0) := '
|
|
|
|
# Get the address value form the dictionary, and convert to an integer value
|
|
addrVal = int(str(regDict[regName][attr.ADDRESS]), 0)
|
|
|
|
# Generate a hex string for the value (without a leading '0x') and output
|
|
nibbles = (addrWidthInt + 3) >> 2
|
|
fmtStr = '0' + str(nibbles) + 'X'
|
|
addrValHex = format(addrVal, fmtStr)
|
|
opStr += str(addrWidthInt) + 'x\"' + addrValHex + '\";\n'
|
|
wfp.write(opStr)
|
|
|
|
opStr = ' constant ' + regFullUsName + ' : unsigned(' + str(addrWidthInt-1) + ' downto 0) := '
|
|
opStr += str(addrWidthInt) + 'x\"' + addrValHex + '\";\n'
|
|
wfp.write(opStr)
|
|
|
|
opStr = ' constant ' + regFullIntName + ' : integer := '
|
|
opStr += '16#' + format(addrVal, '08X') + '#;\n'
|
|
wfp.write(opStr)
|
|
|
|
# If there are sub-fields, process them here
|
|
if attr.FIELDS in regDict[regName] :
|
|
|
|
# Extract the fields dictionary from the register
|
|
fields = regDict[regName][attr.FIELDS]
|
|
|
|
# Keep a bit position count, initialised to 0
|
|
bitStart = 0
|
|
|
|
# Loop through the fields
|
|
for fieldName in fields :
|
|
|
|
# Extract the field bit length, and calculate the top and bottom bit positions
|
|
fieldLen = int(fields[fieldName][attr.BIT_LEN], 0)
|
|
bottomStr = str(bitStart)
|
|
topStr = str(bitStart + fieldLen - 1)
|
|
|
|
# Increment the bit start position to be the bit after current field
|
|
bitStart += fieldLen
|
|
|
|
# Don't process reserved fields (but still need above bit calculations to skip them)
|
|
if fields[fieldName][attr.TYPE] != regtype.RESERVED :
|
|
|
|
# Extract the field name and pad to a fixed width
|
|
fieldFullName = MemMapperBase.createPkgTag(bus, regName + '_' + fieldName, False)
|
|
|
|
# Pad the string to match the desired o/p width
|
|
fieldFullName = MemMapperPkg.__padString(fieldFullName, MemMapperPkg.outputNameWidth)
|
|
|
|
# Output the bit-slice subtype declaration
|
|
wfp.write(' subtype ' + fieldFullName +
|
|
' is natural range ' + topStr + ' downto ' + bottomStr + ';\n')
|
|
|
|
# Put a blank line between busses
|
|
wfp.write('\n')
|
|
|
|
# Finish off the package declaration and close the output file
|
|
wfp.write('end package ' + ip + '_pkg;\n')
|
|
wfp.close()
|
|
|
|
# --------------------------------------------------------------
|
|
# Parse the command line arguments specific to the package
|
|
# generator
|
|
#
|
|
def processCmdLine() :
|
|
|
|
# Create a parser object
|
|
parser = argparse.ArgumentParser(description='Process command line options.')
|
|
|
|
# Process common command line options with inherited static base class method
|
|
MemMapperPkg.processCmdLine(parser)
|
|
|
|
return parser.parse_args()
|
|
|
|
# ###############################################################
|
|
# Only run if not imported
|
|
#
|
|
if __name__ == '__main__' :
|
|
|
|
memMap = MemMapperPkg()
|
|
|
|
# Process the command line options
|
|
cmdArgs = processCmdLine()
|
|
|
|
# Run the program for VHDL package generation
|
|
memMap.run(cmdArgs.topBlock, cmdArgs.busList, cmdArgs.repoDir, cmdArgs.opDir, cmdArgs.opFileSuffix, cmdArgs.jsonFile, cmdArgs.buildDir, cmdArgs.qsysSuffix)
|
|
del memMap
|