X-Git-Url: https://git.ti.com/gitweb?p=glsdk%2Fiodelay-config.git;a=blobdiff_plain;f=iodelay-autogen.py;h=d6a8701f91a3a63ae3dd1b2be4c767ed6be36aba;hp=695ff74864cd1358e13d06f98245b81be4b9218e;hb=16c0125510e9f222b7e6cc074be84b3878bb6024;hpb=197976adfdb8ad5312f55ed52c4a1bcfa2a6adc8 diff --git a/iodelay-autogen.py b/iodelay-autogen.py index 695ff74..d6a8701 100755 --- a/iodelay-autogen.py +++ b/iodelay-autogen.py @@ -1,6 +1,6 @@ #!/usr/bin/python -#Python script to automatically generate the IO pad and delay data -#Author:- Nikhil Devshatwar +# Python script to automatically generate the IO pad and delay data +# Author:- Nikhil Devshatwar # This script uses regdump of the pad registers to figure out the muxmodes # Based on the pad and muxmode, it find out all possible virtual/manual modes @@ -12,26 +12,102 @@ # * Pad register dump - Generate using omapconf dump 0x4a003400 0x4a00380c # * selection file - List of selected virtual/manual modes to be used +import xml.etree.ElementTree as ET +import re +import argparse + +# Handle the command line arguments +parser = argparse.ArgumentParser(prog='iodelay-autogen.py', + description='Python script to generate the IOdelay data.\n' \ + 'This script refers to the XML data and automatically generates\n' \ + 'PAD and DELAY data for the same use case.\n' \ + 'Note that only the PADs which are used in the dump are configured.', + epilog='Generate the pad and delay data using pad register dumps. For this,\n' \ + 'Run omapconf dump 0x4a003400 0x4a00380c and save the output') + +parser.add_argument('-d', '--debug', dest='debug', + action='store', type=int, choices=[0, 1, 2], default=0, + help='set the debug level') + +parser.add_argument('-i', '--interactive', dest='interactive', + action='store', type=int, choices=[0, 1], default=1, + help='run interactively with menus for resolving conflicts') + +parser.add_argument('-f', '--format', dest='format', + action='store', type=str, choices=["linux", "uboot", "bios"], default="uboot", + help='select the output format to be used') + +parser.add_argument('-r', '--revision', dest='revision', + action='store', type=str, choices=["1.1", "2.0"], default="1.1", + help='select the silicon revision') + +parser.add_argument('-m', '--module', dest='module', + action='store', type=str, default="", + help='generate only for this module') + +parser.add_argument('-s', '--strict', dest='strict', + action='store_true', + help='strict mode - ask for each pad of the group, do not save selection.\n' \ + 'For some peripherals, same delaymode cannot be used for all the pads.\n' \ + 'Use this mode to select different modes for each pad') + +parser.add_argument('-g', '--gpio', dest='gpio', + action='store_true', + help='generate script to read pad data from GPIO') + +parser.add_argument('-c', '--check', dest='check_xml', + action='store_true', + help='check consistency of the XML files and other data') + +args = parser.parse_args() +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +PCT_VERSION = "v1.0.7" pad_data_xml = "XMLFiles/CTRL_MODULE_CORE.xml" iod_data_xml = "XMLFiles/IODELAYCONFIG.xml" -model_data_xml = "XMLFiles/model_DRA75x_DRA74x_SR1.1_v1.0.6.xml" -gdl_file = "guidelines.txt" +model_data_xml = "XMLFiles/model_DRA75x_DRA74x_SR" + args.revision + "_" + PCT_VERSION + ".xml" +modehelp_file = "guidelines.txt" pad_file = "ctrl-core.dump" sel_file = "selected-modes.txt" -config_file = "config-iodelay-autogen" - -import xml.etree.ElementTree as ET -import ConfigParser as CP -import re +# Read the XML file database for pad and delay registers pad_xml = ET.parse(pad_data_xml).getroot() iod_xml = ET.parse(iod_data_xml).getroot() model_xml = ET.parse(model_data_xml).getroot() -config = CP.RawConfigParser() -config.read(config_file) -def read_pad_file(file): +# Functions to parse the input files and build data structures +def read_guidelines(fname): + modehelp = {} + pattern = re.compile('(.+\w)\t+(.+)') + f = open(fname) + for line in f.readlines(): + list = re.match(pattern, line) + if ( list == None): + continue + mode = list.groups(0)[0] + info = list.groups(0)[1] + modehelp[mode] = info + if (args.debug >= 2): + print "Help: Mode '%s' is used for '%s'" % (mode, info) + return modehelp + +def read_selmodes(fname): + sel = {} + pattern = re.compile('(\w+)\W*,\W*(\w*)') + f = open(fname) + for line in f.readlines(): + list = re.match(pattern, line) + if ( list == None): + continue + module = list.groups(0)[0] + mode = list.groups(0)[1] + sel[module] = mode + if (args.debug >= 2): + print "INFO: Select '%s' for '%s'" % (mode, module) + return sel + +def read_pad_dump(file): regmap = {} pattern = re.compile('.*(0x[0-9A-F]+).*(0x[0-9A-F]+).*') f = open(file, 'r') @@ -41,18 +117,24 @@ def read_pad_file(file): continue addr = int(list.groups(0)[0], 16) val = int(list.groups(0)[1], 16) - #print "PADDUMP: Addr = %08x Value = %08x" % (addr, val) + #print "PADXML: Addr = %08x Value = %08x" % (addr, val) regmap[addr] = val return regmap +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Helper functions to parse XML nodes and get the desired data +# Hugely dependent on the XML format of the PCT files +# Uses XPath to search elements with queries and filters +# Parse the nodes to generate data in desired format -def pad_get_name(offset): +def xml_pad_get_name(offset): padlist = pad_xml.findall("register[@offset='0x%X']" % offset) if (len(padlist) == 0): return "Unknown" else: return padlist[0].get("id") -def pad_get_pin(offset, muxmode): +def xml_pad_get_pin(offset, muxmode): padlist = pad_xml.findall("register[@offset='0x%X']" % offset) if (len(padlist) == 0): return "Unknown" @@ -65,18 +147,7 @@ def pad_get_pin(offset, muxmode): return "Unknown" return modes[0].get("id") -def pad_dump_gpio(addr, offset, pin_name): - gpio_data_addrs = (0, 0x4ae10138, 0x48055138, 0x48057138, 0x48059138, 0x4805b138, 0x4805d138, 0x48051138, 0x48053138) - gpio_name = pad_get_pin(offset, 14) - matchlist = re.match("GPIO(.)_(.)", gpio_name) - if (matchlist == None): - return - inst = int(matchlist.groups(0)[0]) - bit = int(matchlist.groups(0)[1]) - gpio_addr = gpio_data_addrs[inst] - print "GPIO: echo %d > /sys/class/gpio/export 2>/dev/null; val=`omapconf read 0x%x 2>&1 | grep -v \"support\"`; status=$((0x$val >> %d & 0x1)); echo -e \"%s (%s)\t = $status\";" % ((inst - 1) * 32, gpio_addr, bit, pin_name, gpio_name) - -def iodelay_get_reg(name): +def xml_iodelay_get_reg(name): delaylist = iod_xml.findall("register[@id='%s']" % name) if (len(delaylist) == 0): return 0 @@ -85,22 +156,22 @@ def iodelay_get_reg(name): #print "IOD: Name = %s Offset = %s" % (del_reg, offset) return int(offset, 16) -def virtual_get_modes(mode): - list = [] +def xml_get_virtual(mode): + vmodes = {} signal = mode.findtext("signal") for virt in mode.findall("virtualmode/mode"): virt_mode = virt.findtext("value") virt_name = virt.findtext("name") if (virt_name == "NA"): continue - found = (virt_mode, virt_name) - list.append(found) - if (config.get("general", "dump_virtual") == "1"): - print ("VIRTUAL: %s %s" % found) + " %s" % signal - return list - -def manual_get_modes(mode): - list = [] + virt_mode = int(virt_mode) + vmodes[virt_name] = virt_mode + if (args.debug >= 1): + print (" * VIRTUAL: %s [%s] => delaymode = %d" % (signal, virt_name, virt_mode)) + return vmodes + +def xml_get_manual(mode): + mmodes = {} signal = mode.findtext("signal") for man in mode.findall("manualmode"): regname = man.findtext("cfgreg/name") @@ -110,14 +181,16 @@ def manual_get_modes(mode): man_name = sel.findtext("name") if (man_name == "NA"): continue - found = (regname, adel, gdel, man_name) - list.append(found) - if (config.get("general", "dump_manual") == "1"): - print ("MANUAL: %s %s %s %s" % found) + " %s" % signal - return list - - -def model_find_delaymodes(pad_name, muxmode): + adel = int(adel) + gdel = int(gdel) + if (man_name not in mmodes.keys()): + mmodes[man_name] = [] + mmodes[man_name].append((regname, adel, gdel)) + if (args.debug >= 1): + print (" * MANUAL: %s [%s] => delay[%s] = %d, %d" % (signal, man_name, regname, adel, gdel)) + return mmodes + +def xml_find_delaymodes(pad_name, muxmode): padlist = model_xml.findall("padDB/clockNode/type/pad") for pad in padlist: if (pad_name == pad.findtext("confregisters/regbit/register")): @@ -127,107 +200,401 @@ def model_find_delaymodes(pad_name, muxmode): return None for mode in muxmodes: if ("%d" % muxmode == mode.findtext("mode")): - virt = virtual_get_modes(mode) - man = manual_get_modes(mode) + virt = xml_get_virtual(mode) + man = xml_get_manual(mode) return (virt, man) return None -def get_pin_info(val): - inp_en = (val >> 18) & 0x1 - pulltype = (val >> 17) & 0x1 - pull_dis = (val >> 16) & 0x1 - pin = "PIN" - if (inp_en): - pin += "_INPUT" - else: - pin += "_OUTPUT" - if (pull_dis == 0): - if (pulltype): - pin += "_PULLUP" - else: - pin += "_PULLDOWN" - return pin +def xml_check_correctness(modehelp): + if(args.check_xml == False): + return -def read_guidelines(fname): - gdl = {} - pattern = re.compile('(.+\w)\t+(.+)') - f = open(fname) - for line in f.readlines(): - list = re.match(pattern, line) - if ( list == None): - continue - mode = list.groups(0)[0] - info = list.groups(0)[1] - gdl[mode] = info - #print "GDL: Parsed info<%s> <%s>" % ( mode, info) - return gdl + print "###########################################" + print "XML correctness checks:" + padcore_list = [] + padmodel_list = [] + modes = {} -def read_selection(fname): - sel = {} - pattern = re.compile('(\w+)\W*,\W*(\w*)') - f = open(fname) - for line in f.readlines(): - list = re.match(pattern, line) - if ( list == None): + # Fint all the pads in core XML + pad_list = pad_xml.findall("register") + for i in pad_list: + name = i.get("id") + if (re.match("CTRL_CORE_PAD_.*", name) == None): continue - group = list.groups(0)[0] - mode = list.groups(0)[1] - sel[group] = mode - #print "SEL: Parsed info<%s> <%s>" % (mode, group) - return sel + padcore_list.append(name) + print ">> Total pads defined in core XML = %d" % len(padcore_list) + + # Find all the pads in model XML + pad_list = model_xml.findall("padDB/clockNode/type/pad/confregisters/regbit") + for i in pad_list: + name = i.findtext("register") + padmodel_list.append(name) + print ">> Total pads defined in model XML = %d" % len(padmodel_list) + + # Find all the manual modes + manmode_list = model_xml.findall("padDB/clockNode/type/pad/muxmode/manualmode/cfgreg/mode") + for i in manmode_list: + man_name = i.findtext("name") + modes[man_name] = "manual" + # Find all the virtual modes + virtmode_list = model_xml.findall("padDB/clockNode/type/pad/muxmode/virtualmode/mode") + for i in virtmode_list: + virt_name = i.findtext("name") + modes[virt_name] = "virtual" + print ">> Total delaymodes defined in model XML = %d" % len(modes) + + # Print out all the errors found in the tests + print "== Pads defined in core XML but not in model XML ==" + for i in padcore_list: + if (i not in padmodel_list): + print "\t%s" % i + print "== Pads defined in model XML but not in core XML ==" + for i in padmodel_list: + if (i not in padcore_list): + print "\t%s" % i + + # Check if description for each mode is available + print "== Delaymodes missing description in the guidelines.txt ==" + for i in modes: + if (i not in modehelp): + print "\t%s" % i + + print "###########################################" + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Decision point of the script +# For each pad/pin, decide what delay method is used +# Lookup in the selection file or ask user with a menu +def select_mode(pad, pin, module, virt, man, modehelp, sel): + modelist = [] + for modename in virt.keys(): + modelist.append(modename) + + for modename in man.keys(): + modelist.append(modename) + + if (len(modelist) == 0): + return "LEGACY" + + if (module in sel.keys()): + mode = sel[module] + if (mode == "SKIP" or mode in modelist): + return mode + else: + print("ERR: Invalid delaymode '%s' for module '%s'" % (mode, module)) -def find_selection(pad, pin, modes, gdl, sel): - group = re.match("([^_]+)_.*", pin).groups(0)[0] - if (group in sel.keys()): - if (sel[group] == "SKIP"): - return sel[group] - for mode in modes: - if (sel[group] == mode): - #print "DBG: Found %s mode in selection for %s" % (mode, group) - return mode - - if (config.get("gui", "interactive") == "0"): - return "SKIP" - - #print "\nDBG: Selected modes" - #print sel + if (args.interactive == 0): + print "WARN: No delay modes for %s found, skipping" % module + mode = "SKIP" + sel[module] = mode + return mode + + # Display the menu and ask user to select the 'right' mode while True: print "" print "MENU: Select delay mode for %s -> %s" % (pad, pin) i = 0 - print "MENU: %d: %s \t\t\t%s" % (i, "SKIP", "Skips this group for now") - for mode in modes: + print "MENU: %d: %s \t\t\t%s" % (i, "SKIP", "Skips this module for now") + for mode in modelist: i += 1 - print "MENU: %d: %s \t\t%s" % (i, mode, gdl[mode]) + if (mode in modehelp): + helptext = modehelp[mode] + else: + helptext = "Unknown" + print "MENU: %d: %s \t\t%s" % (i, mode, helptext) try: choice = int(raw_input("Select delay mode #> ")) if (choice == 0): mode = "SKIP" break - elif (choice >=0 and choice <= len(modes)): - mode = modes.keys()[choice - 1] + elif (choice >=0 and choice <= len(modelist)): + mode = modelist[choice - 1] break print "ERROR: Invalid choice" except ValueError: print "ERROR: Invalid choice" print "MENU: Selected mode is %s" % mode print "" + return mode +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Pad read using GPIO - Specific to linux only +# As each pad is muxed with a SoC gpio (for most of the pads) +# It's possible to read the pad data using gpio datain registers +# Dump the linux commands to read the gpio registers and read the pad data +def pad_dump_gpio(padconf, per_padconf): + if(args.gpio == False): + return -#Main execution starts here -print "IOdelay autogen - Python script to generate the IOdelay data" -print "Generate the MUX mode data based on the register dumps" -print "" + print "# Read pad signals using GPIO DATA-IN registers" + print "# Works only for the input signals" + gpio_data_addrs = (0, 0x4ae10138, 0x48055138, 0x48057138, 0x48059138, 0x4805b138, 0x4805d138, 0x48051138, 0x48053138) + for i in padconf: + (pad_name, pin_name, addr, val, delayinfo) = i + + offset = addr - 0x4a002000 + gpio_name = xml_pad_get_pin(offset, 14) + matchlist = re.match("GPIO(.)_(.*)", gpio_name) + if (matchlist == None): + print "ERR: No GPIO for pad %s" % pad_name + continue -gdl = read_guidelines(gdl_file) -sel = read_selection(sel_file) -regmap = read_pad_file(pad_file) -reglist = regmap.keys() + inst = int(matchlist.groups(0)[0]) + bit = int(matchlist.groups(0)[1]) + gpio_addr = gpio_data_addrs[inst] + + print "#Read GPIO%d_%d to sample %s" % (inst, bit, pin_name) + print " echo %d > /sys/class/gpio/export 2>/dev/null;" % ((inst - 1) * 32) + print " val=`omapconf read 0x%x 2>&1 | grep -v \"support\"`;" % gpio_addr + print " status=$((0x$val >> %d & 0x1));" % bit + print " echo -e \"%s (%s)\t = $status\";" % (pin_name, gpio_name) + print "" + print "" +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Generate the final pad and delay data in the required format +def format_pad_regs(padconf, per_padconf): + print "###########################################" + print "Pad data output (with the delay modes)" + print "###########################################" + if (args.format == "uboot"): + uboot_format_pad_regs(padconf, per_padconf) + elif (args.format == "linux"): + linux_format_pad_regs(padconf, per_padconf) + elif (args.format == "bios"): + bios_format_pad_regs(padconf, per_padconf) + else: + print "ERR: Format %s not suppported" % args.format + +def format_delay_regs(delayconf, per_delayconf): + print "#########################################" + print "Delay data output (for manual modes)" + print "#########################################" + if (args.format == "uboot"): + uboot_format_delay_regs(delayconf, per_delayconf) + elif (args.format == "linux"): + linux_format_delay_regs(delayconf, per_delayconf) + elif (args.format == "bios"): + bios_format_delay_regs(delayconf, per_delayconf) + else: + print "ERR: Format %s not suppported" % args.format + +def get_pin_info(val): + inp_en = (val >> 18) & 0x1 + pulltype = (val >> 17) & 0x1 + pull_dis = (val >> 16) & 0x1 + pin = "PIN" + if (inp_en): + pin += "_INPUT" + else: + pin += "_OUTPUT" + if (pull_dis == 0): + if (pulltype): + pin += "_PULLUP" + else: + pin += "_PULLDOWN" + return pin + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Generate output in u-boot format +def uboot_format_pad_regs(padconf, per_padconf): + print "\nconst struct pad_conf_entry dra74x_core_padconf_array[] = {" + for i in padconf: + (pad_name, pin_name, addr, val, delayinfo) = i -pad_count = 0 -delay_count = 0 + if (re.match("MMC.*", pin_name) != None): + print "WARN: Skipping MMC padconf in uboot" + continue + + muxmode = val & 0xf + (method, data) = delayinfo + if (method == "LEGACY"): + extramode = "" + elif (method == "VIRTUAL"): + delaymode = data + extramode = " | VIRTUAL_MODE%d" % delaymode + elif (method == "MANUAL"): + extramode = " | MANUAL_MODE" + else: + print "ERR: Invalid method %s" % method + + pin_info = get_pin_info(val) + extramode + pad_short = re.sub("CTRL_CORE_PAD_", "", pad_name) + comment = (pad_short + "." + pin_name).lower() + + print "\t{ %s, (M%d | %s) },\t/* %s */" % (pad_short, muxmode, pin_info, comment) + print "};\n" + +def uboot_format_delay_regs(delayconf, per_delayconf): + manual_del = [] + for i in delayconf: + (pad_name, pin_name, regname, del_offset, man_name, adel, gdel) = i + + if (re.match("MMC.*", pin_name) != None): + print "WARN: Skipping MMC delayconf in uboot" + continue -for i in range(0, 281): + entry = (del_offset, adel, gdel, regname, pin_name, man_name) + manual_del.append(entry) + + es_rev = args.revision.replace('.', '_') + print "\nconst struct iodelay_cfg_entry dra742_es" + es_rev + "_iodelay_cfg_array[] = {" + for entry in sorted(manual_del): + print "\t{ 0x%04X, %5d, %5d },\t/* %s : %s - %s */" % entry + print "};\n" + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Generate output in linux format +def linux_format_pad_regs(padconf, per_padconf): + print "&dra7_pmx_core {" + for per in per_padconf: + + if (re.match("MMC.*", per) == None): + print "ERR: Only MMC padconf is recommended in kernel" + continue + + dtsnode = ("%s_pins_default" % per).lower() + print "" + print "\t%s: %s {" % (dtsnode, dtsnode) + print "\t\tpinctrl-single,pins = <" + for i in per_padconf[per]: + (pad_name, pin_name, addr, val, delayinfo) = i + + muxmode = val & 0xf + (method, data) = delayinfo + if (method == "LEGACY"): + extramode = "" + elif (method == "VIRTUAL"): + delaymode = data + extramode = " | VIRTUAL_MODE%d" % delaymode + elif (method == "MANUAL"): + extramode = " | MANUAL_MODE" + else: + print "ERR: Invalid method %s" % method + + pin_info = get_pin_info(val) + extramode + pad_short = re.sub("CTRL_CORE_PAD_", "", pad_name) + offset = addr - 0x4a003400 + comment = (pad_short + "." + pin_name).lower() + + print "\t\t\t0x%03X\t(%s | MUM_MODE%d)\t/* %s */" % (offset, pin_info, muxmode, comment) + print "\t\t>;" + print "\t};" + print "};\n" + + +def linux_format_delay_regs(delayconf, per_delayconf): + print "&dra7_iodelay_core {" + for per in per_delayconf.keys(): + + if (re.match("MMC.*", per) == None): + print "ERR: Only MMC delayconf is recommended in kernel" + continue + + # Get the mode from the first entry + (pad_name, pin_name, regname, del_offset, mode, adel, gdel) = per_delayconf[per][0] + + dtsnode = ("%s_iodelay_%s_conf" % (per, mode)).lower() + print "\t%s: %s {" % (dtsnode, dtsnode) + print "\t\tpinctrl-single,pins = <" + for i in per_delayconf[per]: + (pad_name, pin_name, regname, del_offset, mode, adel, gdel) = i + + print "\t\t\t0x%03X A_DELAY(%d) | G_DELAY(%d)\t/* %s */" % (del_offset, adel, gdel, regname) + print "\t\t>;" + print "\t};" + print "};\n" + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Generate output in bios format +def bios_format_pad_regs(padconf, per_padconf): + for i in padconf: + (pad_name, pin_name, addr, val, delayinfo) = i + + delaylist = [] + (method, data) = delayinfo + if (method == "VIRTUAL"): + virt_mode = data + val = val | ( virt_mode<< 4) + val = val | (1 << 8) + elif (method == "MANUAL"): + delaylist = data + val = val | (1 << 8) + + offset = addr - 0x4a003400 + out_delreg = out_adel = out_gdel = 0 + in_delreg = in_adel = in_gdel = 0 + oen_delreg = oen_adel = oen_gdel = 0 + + for j in delaylist: + (regname, adel, gdel) = j + if (re.match(".*_IN", regname) != None): + in_delreg = xml_iodelay_get_reg(regname) + in_adel = adel + in_gdel = gdel + elif (re.match(".*_OEN", regname) != None): + oen_delreg = xml_iodelay_get_reg(regname) + oen_adel = adel + oen_gdel = gdel + elif (re.match(".*_OUT", regname) != None): + out_delreg = xml_iodelay_get_reg(regname) + out_adel = adel + out_gdel = gdel + indel = "{ 0x%04X, %4d, %4d }" % (in_delreg, in_adel, in_gdel) + oendel = "{ 0x%04X, %4d, %4d }" % (oen_delreg, oen_adel, oen_gdel) + outdel = "{ 0x%04X, %4d, %4d }" % (out_delreg, out_adel, out_gdel) + pin_info = get_pin_info(val) + print "\t/* %s -> %s (%s) %s delaymode */" % (pad_name, pin_name, pin_info, method) + print "\t{ 0x%03X, 0x%08X, %s, %s, %s }" % (offset, val, indel, oendel, outdel) + +def bios_format_delay_regs(delayconf, per_delayconf): + print "Manual delays are not configured separately" + print "Delays are configured as part of the padconf step only" + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +# Main execution starts here +# * Parse all the XML files - Get the pad data and IOdelay data +# * Iterate over the pad register dumps +# * For each pad, find out the muxmode being used and the pad direction, etc +# * For the muxmode being used, find out available virtual/modes +# - Dump the virtual/manual modes available (based on options) +# - Build up the gpio script to read the pad data using GPIO module +# * Select the correct mode to be used +# - Check if the mode is described for the peripheral module, (from selected-modes.txt) +# - Otherwise ask the user (with a menu) to decide the delaymode +# => Update the selection for the whole of the peripheral module +# - Worst case, skip the delaymode for this pad +# * Build the pad and delay register information +# * Create the dump for pad and delay data in linux/u-boot format +# * Dump the delaymode selection for each peripheral +# * Dump the GPIO script for each peripheral (all pads grouped together) +# + +# Read all the input files and parse the required info +modehelp = read_guidelines(modehelp_file) +sel = read_selmodes(sel_file) +regmap = read_pad_dump(pad_file) +reglist = regmap.keys() + +# List of all the pads being configured +padconf = [] +# List of all the delay registers being configured (for manual mode) +delayconf = [] +# Dictionary of pads grouped by peripheral/module +per_padconf = {} +# Dictionary of delay registers grouped by peripheral/module +per_delayconf = {} + +xml_check_correctness(modehelp) +# Start iterating over each pad +for i in range(0, 260): + # Find out the muxmode and pad direction, etc addr = 0x4a003400 + i * 4 offset = 0x1400 + i * 4 dts_offset = offset - 0x1400 @@ -237,85 +604,87 @@ for i in range(0, 281): continue val = regmap[addr] muxmode = val & 0xf - pad_name = pad_get_name(offset) - pin_name = pad_get_pin(offset, muxmode) + + # Find out the pin based on the muxmode + pad_name = xml_pad_get_name(offset) + pin_name = xml_pad_get_pin(offset, muxmode) if (pad_name == "Unknown" or pin_name == "Unknown"): - print "ERROR: Cannot find out Pad/Pin name for PAD address 0x%X (%s[%s] = %s)" \ + print "WARN: Cannot find out Pad/Pin name for PAD address 0x%X (%s[%s] = %s)" \ % (addr, pad_name, muxmode, pin_name) continue - if (config.get("general", "dump_all") == "1"): - print "DUMP: %30s: Address = 0x%X \tOffset = 0x%X Value = 0x%08X \"%s\"" \ - % (pad_name, addr, offset, val, pin_name) - - if (config.get("general", "dump_gpio") == "1"): - pad_dump_gpio(addr, offset, pin_name) -#Find out all the possible virtual, manual modes fot the specific pad -> pin combination - (virt, man) = model_find_delaymodes(pad_name, muxmode) - modes = {} - for option in virt: - (virt_mode, virt_name) = option - extramode = "VIRTUAL_MODE%s" % virt_mode - modes[virt_name] = extramode - - for option in man: - (regname, a_del, g_del, man_name) = option - extramode = "MANUAL_MODE" - modes[man_name] = extramode - -#Decide the mode to be used:- - if (len(modes) == 0): - if (config.get("general", "auto_decide") == "0"): - continue - #Use Legacy mode - extramode = "" - else: - #Need to select one out of allowed modes - mode = find_selection(pad_name, pin_name, modes, gdl, sel) - if (mode == "unknown"): - print "ERROR: Unresolved delay modes for %s -> %s" % (pad_name, pin_name) - print modes - break + if (pin_name == "DRIVER OFF"): + continue - #Update the selection for that module - group = re.match("([^_]+)_.*", pin_name).groups(0)[0] - #print "DBG: Adding %s mode for group %s" % (mode, group) - if (mode != "SKIP" or group not in sel.keys()): - sel[group] = mode - if (mode == "SKIP"): - continue - extramode = modes[mode] + # Find out if the delaymode for this module is already selected + module = re.match("([^_]+)_.*", pin_name).groups(0)[0] + + if (args.module != "" and args.module != module): + continue + + if (args.debug >= 1): + print "\nPAD: %s: Addr= 0x%08X Value = 0x%08X \"%s\"" \ + % (pad_name, addr, val, pin_name) -#Generate the u-boot header for PAD mux array - if (extramode == ""): - delaymode = "" + # Find out all the possible virtual, manual modes fot the specific pad -> pin combination + (virt, man) = xml_find_delaymodes(pad_name, muxmode) + + # Need to select one out of allowed modes + mode = select_mode(pad_name, pin_name, module, virt, man, modehelp, sel) + + # Remember the selection for that module, for later reuse + if (args.strict == False): + sel[module] = mode + + if (mode == "SKIP"): + continue + elif (mode == "LEGACY"): + delayinfo = ("LEGACY", "") + elif (mode in virt): + delayinfo = ("VIRTUAL", virt[mode]) + elif (mode in man): + delayinfo = ("MANUAL", man[mode]) else: - delaymode = " | %s" % extramode - pin_info = get_pin_info(val) + delaymode - pad_short = re.sub("CTRL_CORE_PAD_", "", pad_name) - comment = (pad_short + "." + pin_name).lower() - print "PAD:\t{ %s, (M%d | %s) },\t/* %s */" % (pad_short, muxmode, pin_info, comment) - pad_count += 1 - -#Generate the u-boot header for IO delay array - if (extramode != "MANUAL_MODE"): + print "ERR: Unknown mode '%s' selected" % mode continue - for option in man: - (regname, a_del, g_del, man_name) = option - if (man_name != mode): - continue - del_offset = iodelay_get_reg(regname) + + if (args.debug >= 1): + print " => Using mode %s" % mode + paddata = (pad_name, pin_name, addr, val, delayinfo) + if (module not in per_padconf.keys()): + per_padconf[module] = [] + padconf.append(paddata) + per_padconf[module].append(paddata) + + if(mode not in man): + continue + + # Add the delay data if using manual mode + for regval in man[mode]: + (regname, adel, gdel) = regval + del_offset = xml_iodelay_get_reg(regname) if (del_offset == 0): - print "ERROR: Can't find delay offset of register %s" % regname + print "WARN: Can't find delay offset of register %s" % regname break - a_del = int(a_del) - g_del = int(g_del) - print "DELAY:\t{0x%04X, %d, %d},\t/* %s */" \ - % (del_offset, a_del, g_del, regname) + if (args.debug >= 1): + print " => Manual delay[%s] = (%d, %d)" % (regname, adel, gdel) + delaydata = (pad_name, pin_name, regname, del_offset, mode, adel, gdel) + if (module not in per_delayconf.keys()): + per_delayconf[module] = [] + delayconf.append(delaydata) + per_delayconf[module].append(delaydata) - delay_count += 1 print "" -print "Total PAD registers: %d, Total DELAY registers: %d" % (pad_count, delay_count) -#Dump the final selection for reuse +print "Total PAD registers: %d" % len(padconf) +print "Total DELAY registers: %d" % len(delayconf) +print "" + +format_pad_regs(padconf, per_padconf) +format_delay_regs(delayconf, per_delayconf) +pad_dump_gpio(padconf, per_padconf) + +# Dump the final selection for reuse +print "Selected modes for each peripheral module\n" for group in sel: print "%s,\t%s" % (group, sel[group]) print "" +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #