Add initial script to parse signal XML file for iMX.RT parts

Add initial script to generate pinctrl groups from MEX file for iMX.RT
parts.

Signed-off-by: Daniel DeGrasse <[email protected]>

Author: danieldegrasse

tools/__pycache__/rt_cfg_utils.cpython-38.pyc

@@ -0,0 +1,325 @@
+import xml.etree.ElementTree as ET
+import collections
+import datetime
+import re
+import os
+
+# MEX file has a default namespace, map it here
+namespaces = {'mex' : 'http://mcuxpresso.nxp.com/XSD/mex_configuration_10'}
+
+
+"""
+Class for iMX.RT configuration file parser for Zephyr
+"""
+class NXPSdkUtil:
+    """
+    Initilize SDK utilities.
+    Providing a signal_configuration.xml file as well as an iomuxc.h file will enable
+    the class to parse MEX files and generate output DTS
+    """
+    def __init__(self, iomuxc_file, signal_file):
+        # Load the iomuxc file
+        try:
+            iomux = open(iomuxc_file, 'r')
+            # Load the iomuxc name mapping
+            self._iomuxc_map = self._build_iomuxc_map(iomux)
+        except IOError:
+            print("File %s could not be opened" % (iomuxc_file))
+            self._iomcux_map = None
+        # Try to parse the signal XML file
+        try:
+            signal_xml = ET.parse(signal_file)
+            # Load the signal file defintion
+            self._signal_map = self._load_signal_map(signal_xml)
+            # Set SOC name and SKU
+            self._soc_sku = signal_xml.find('part_information/part_number').attrib['id']
+            self._soc = re.match("MIMXRT[0-9]+", self._soc_sku).group(0)
+        except xml.etree.ElementTree.ParseError:
+            print("Malformed XML tree %s" % (signal_file))
+            self._signal_map = None
+        except IOError:
+            print("File %s could not be opened" % (signal_file))
+            self._signal_map = None
+        return
+    """
+    Get SOC this class is initialized for
+    """
+    def get_soc(self):
+       return self._soc
+
+    """
+    Get SOC SKU this class is initialized for
+    """
+    def get_sku(self):
+        return self._soc_sku
+    
+    """
+    Writes a pinctrl header suitable for inclusion in a DTS file, which
+    defines IOMUXC register constants for each pin configuration
+    @param outputfile file to write pinctrl header to
+    """
+    def write_pinctrl_header(self, outputfile):
+        if self._iomuxc_map is None:
+            print("Cannot write pinctrl header file without an iomuxc file")
+        try:
+            header_file = open(outputfile, "w")
+        except IOError:
+            print("Could not write to file %s" % (outputfile))
+            return
+        # Start by writing header
+        header = ("/*\n"
+        " * Generated by {} on {}\n"
+        " */\n\n").format(os.path.basename(__file__), datetime.date.today())
+        header_file.write(header)
+        for iomuxc in self._iomuxc_map:
+            # Write iomuxc entry
+            register = self._iomuxc_map[iomuxc][0]
+            mode = self._iomuxc_map[iomuxc][1]
+            input_reg = self._iomuxc_map[iomuxc][2]
+            input_daisy = self._iomuxc_map[iomuxc][3]
+            config_reg = self._iomuxc_map[iomuxc][4]
+            entry = "#define {} 0x{:x} {:d} 0x{:x} {:d} 0x{:x}\n".format(
+                iomuxc, register, mode, input_reg, input_daisy, config_reg)
+            header_file.write(entry)
+        header_file.write("\n")
+        header_file.close()
+
+
+    """
+    Write pinctrl groups to disk as a parsed DTS file
+    @param mexfile: mex file to parse for pin configuration
+    @param outputfile- file to write dts to
+    """
+    def write_pinctrl_groups(self, mexfile, outputfile):
+        if self._signal_map is None:
+            print("Cannot write pinctrl groups without a signal map")
+        try:
+            config_tree = ET.parse(mexfile)
+        except xml.etree.ElementTree.ParseError:
+            print("Malformed XML tree %s" % (mexfile))
+            return
+        except IOError:
+            print("File %s could not be opened" % (mexfile))
+            return
+        try:
+            dts_file = open(outputfile, "w")
+        except IOError:
+            print("Could not write to file %s" % (dts_file))
+            return
+        # Parse the mex file
+        pin_groups = self._parse_mex_cfg(config_tree, self._signal_map)
+        # Start by writing header
+        header = ("/*\n"
+         " * Generated by {} on {}\n"
+         " */\n\n").format(os.path.basename(__file__), datetime.date.today())
+        dts_file.write(header)
+        dts_file.write("#include <nxp/nxp_imx/rt/%s_iomuxc.h>\n\n" % (self.get_soc().lower()))
+        dts_file.write("&pinctrl {\n")
+        # Sort pin groups alphabetically
+        sorted_groups = collections.OrderedDict(sorted(pin_groups.items()))
+        for pin_group in sorted_groups:
+            dts_file.write("\t%s: %s {\n" % (pin_group, pin_group))
+            # Sort the pin groups by their IOMUXC mapping name
+            sorted_pins = collections.OrderedDict(sorted(sorted_groups[pin_group].items()))
+            for pin in sorted_pins:
+                # Write the pinctrl node
+                dts_file.write("\t\t%s {\n" % (pin))
+                # Write the pinmux setting first
+                dts_file.write("\t\t\tpinmux = <%s>;\n" % (sorted_pins[pin]['pinmux']))
+                # Remove the pinmux setting, and write the remaining settings in sorted order
+                sorted_pins[pin].pop('pinmux')
+                feature_dict = collections.OrderedDict(sorted(sorted_pins[pin].items()))
+                for setting in feature_dict:
+                    dts_file.write("\t\t\tnxp,%s = <%s>;\n" % (setting, feature_dict[setting]))
+                dts_file.write("\t\t};\n")
+            dts_file.write("\t};\n")
+        dts_file.write("};\n\n")
+        # DTS file write is done, close it
+        dts_file.close()
+
+    """
+    Extracts board name from a mex file
+    """
+    def get_board_name(self, mexfile):
+        try:
+            config_tree = ET.parse(mexfile)
+        except xml.etree.ElementTree.ParseError:
+            print("Malformed XML tree %s" % (mexfile))
+            return None
+        except IOError:
+            print("File %s could not be opened" % (mexfile))
+            return None
+        return config_tree.getroot().find('mex:common/mex:board', namespaces).text
+        
+
+    """
+    Private class methods
+    """
+    """
+    Create pinctrl dict using the SOC pad and pin XML definition
+    populates any selected pin features for the pinctrl dict
+    @param pad: SOC pad XML structure
+    @param pin: SOC pin XML structure
+    @return dictionary with pinctrl feature settings
+    """
+    def _generate_pin_node(self, pad, pin):
+        pin_node = {}
+        features = pin.find('mex:pin_features', namespaces)
+        if features is not None:
+            for feature in features:
+                # Get bit field value of feature
+                for prop in pad.find('functional_properties'):
+                    if prop.attrib['id'] == feature.attrib['name']:
+                        # Extract bit field
+                        bit_field = None
+                        for state in prop:
+                            if state.attrib['id'] == feature.attrib['value']:
+                                bit_field = state.find('configuration/assign').attrib['bit_field_value']
+                                break
+                        if bit_field is None:
+                            print(("Error: invalid value %s for feature %s" %
+                                  (feature.attrib['value'], feature.attrib['name'])))
+                            # Exit here, do not finish parsing the MEX file
+                            exit(-1)
+                        else:
+                            # Save bit field to pin node
+                            pin_node[feature.attrib['name']] = bit_field
+        # Populate remaining possible configuration values with defaults for pin
+        for prop in pad.find('functional_properties'):
+            if not prop.attrib['id'] in  pin_node and prop.find('state') is not None:
+                for state in prop:
+                    if state.attrib['id'] == prop.attrib['default']:
+                        # Default state located, record bit field
+                        pin_node[prop.attrib['id']] = state.find('configuration/assign').attrib['bit_field_value']
+                        break
+        return pin_node
+
+    """
+    Given the XML structure of an SOC pad, and pin selection,
+    locates the correct mux option in the pad and generates
+    a valid pinmux name
+    @param pad: SOC pad XML structure
+    @param pin: SOC pin XML structure
+    @return pinmux name if connection is valid, None otherwise
+    """
+    def _find_periph_connection(self, pad, pin):
+        mapping_name = None
+        for mux in pad.findall('connections'):
+            for connection in mux:
+                periph_sig_ref = connection.find('peripheral_signal_ref')
+                if 'channel' in periph_sig_ref.attrib:
+                    signal = "%s, %s" % (periph_sig_ref.attrib['signal'], periph_sig_ref.attrib['channel'])
+                else:
+                    signal = periph_sig_ref.attrib['signal']
+                if (signal == pin.attrib['signal'] and
+                    periph_sig_ref.attrib['peripheral'] == pin.attrib['peripheral']):
+                        # Found valid mapping. Set the IOMUXC name
+                        name_part = mux.attrib['name_part']
+                        # if the header name ends in DATAx, it must be expanded to DATA0x (except for USDHC)
+                        if re.search('DATA\d$', name_part) and not re.search('USDHC', name_part):
+                            name_part = re.sub('DATA(\d)$', 'DATA0\g<1>', name_part)
+                        mapping_name = "IOMUXC_%s_%s" % (pad.attrib['name'], name_part)
+                        break
+        return mapping_name
+    
+    """
+    Parses mex config file into pinctrl groups
+    @param mex_xml: xml to load MEX config from
+    @param pin_mapping: mapping of SOC pads to their associated XML structures
+    @return pinctrl groups dict
+    """
+    def _parse_mex_cfg(self, mex_xml, pin_mapping):
+        # MEX file is an XML file, parse it
+        config_root = mex_xml.getroot()
+
+        # Get the tools/pins/functions element to find functions defining pin groups
+        pin_groups =  config_root.find('mex:tools/mex:pins/mex:functions_list', namespaces) 
+
+        pinctrl_groups = {}
+
+        # Parse each pin group
+        for pin_group in pin_groups:
+            # Create initial empty pinctrl group
+            pinctrl_group = {}
+            # Get pin group pins
+            required_pins = pin_group.find('mex:pins', namespaces)
+            for pin in required_pins:
+                pin_node = {}
+                # Locate the pin name in the pin mapping
+                if not pin.attrib['pin_signal'] in pin_mapping:
+                    # Pin signal is not found in SOC pin mapping
+                    print("Error: pin mapping has invalid pin name for peripheral %s in group %s" %
+                           (pin.attrib['peripheral'], pin_group.attrib['name']))
+                    continue
+                # Get XML descriping pad on SOC
+                pad = pin_mapping[pin.attrib['pin_signal']]
+                # Get the connection for the pin from the SOC mapping
+                # all mapping names are defined in fsl_iomuxc.h
+                mapping_name = self._find_periph_connection(pad, pin)
+                if mapping_name is None:
+                    print(("Error: mapping peripheral %s to pad %s is not valid" %
+                          pin.attrib['peripheral'], pad.attrib['name']))
+                    # Exit here, do not finish parsing the MEX file.
+                    exit(-1)
+                # determine functional properties for pin
+                pin_node = self._generate_pin_node(pad, pin)
+                pin_node['pinmux'] = mapping_name
+                # Add pin node to pinctrl group
+                pinctrl_group[mapping_name.lower()] = pin_node
+            # Add finished group to all groups
+            pinctrl_groups[pin_group.attrib['name']] = pinctrl_group
+        # Return the finished pinctrl groups
+        return pinctrl_groups
+
+    """
+    Build dictionary containing mapping of IOMUXC names to
+    a tuple with their register values
+    @param iomuxc iomuxc file to read from
+    @return generated dictionary
+    """
+    def _build_iomuxc_map(self, iomuxc):
+        regexstr = ("#define\s+(IOMUXC_\w+)\s+" # MUX name
+                "([0x]*[\dA-F]+)U*[\s,]+" # MUX register
+                "([0x]*[\dA-F]+)U*[\s,]+" # MUX mode
+                "([0x]*[\dA-F]+)U*[\s,]+" # MUX input_reg
+                "([0x]*[\dA-F]+)U*[\s,]+" # MUX input_daisy
+                "([0x]*[\dA-F]+)U*") # config register
+        pattern = re.compile(regexstr)
+
+        iomuxc_map = {}
+        line = iomuxc.readline()
+        while line != "":
+            # Parse line for pinmux info
+            match = pattern.match(line)
+            if match is None or len(match.group(0)) == 0:
+                # Skip to next line
+                line = iomuxc.readline()
+                continue
+            # Read iomux configuration values
+            name = match.group(1)
+            register = int(match.group(2), 0)
+            mode = int(match.group(3), 0)
+            input_reg = int(match.group(4), 0)
+            input_daisy = int(match.group(5), 0)
+            config_reg = int(match.group(6), 0)
+            iomuxc_map[name] = (register, mode, input_reg, input_daisy, config_reg)
+            line = iomuxc.readline()
+        return iomuxc_map
+
+    """
+    Load signal XML file as a mapping of SOC pads to their XML structures
+    into memory to enable faster parsing
+    @param xml signal xml file
+    @return mapping of SOC pads to XML structures
+    """
+    def _load_signal_map(self, xml):
+        # Open signal XML file
+        signal_root = xml.getroot()
+        # Get the pins element
+        pins = signal_root.find('pins')
+        # Now, build a mapping in memory between the name of each pin
+        # and the XML elements representing that pin
+        pin_map = {}
+        for pin in pins:
+            pin_map[pin.attrib['name']] = pin
+        return pin_map

tools/rt_cfg_utils.py

@@ -0,0 +1,54 @@
+from rt_cfg_utils import NXPSdkUtil
+import argparse
+import pathlib
+
+helpstr = """
+Processes NXP iMX.RT MEX configuration files
+
+Given a mex file, generates the board level pinctrl groups required for
+Zephyr. Only supports iMX.RT parts.
+
+Additional required files:
+- fsl_iomucx.h file defining pinmux options
+- signal_configuration.xml file for SOC
+
+Where to find required files:
+- fsl_iomuxc.h file can be found in mcux/mcux-sdk/devices/{DEVICE_NAME}/drivers/
+- signal_configuration.xml file can be sourced from the NXP SDK builder, by
+    downloading the config tools offline data for your processor. The file
+    will be stored in processors/{SOC_NAME}/ksdk2_0/{SOC_NAME}/
+"""
+
+
+parser = argparse.ArgumentParser(description=helpstr,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+parser.add_argument('mex_file', metavar = 'MEX',
+                    type=str, help='path to source MEX file')
+parser.add_argument('iomuxc_file', metavar = 'IOMUXC',
+                    type=str, help='Direct path to source iomuxc file')
+parser.add_argument('signal_file', metavar = 'SIGNAL_XML', type=str,
+                    help='Direct path to source signal_configuration.xml file')
+parser.add_argument('--dts_output', metavar = 'DTS_OUT', type=str,
+                    help='Output path for DTS file')
+parser.add_argument('--iomuxc_output', metavar = 'DTS_OUT', type=str,
+                    help='Output path for iomuxc header file')
+
+args = parser.parse_args()
+
+
+util = NXPSdkUtil(args.iomuxc_file, args.signal_file)
+
+# Set defaults for optional arguments
+if not args.dts_output:
+    board = util.get_board_name(args.mex_file).lower().replace('-', '_')
+    if board:
+        args.dts_output = "%s-pinctrl.dtsi" % board
+    else:
+        args.dts_output = "%s-pinctrl.dtsi" % util.get_soc().lower()
+if not args.iomuxc_output:
+    args.iomuxc_output = "%s_iomuxc.h" % util.get_soc().lower()
+print("Generating configuration for %s" % (util.get_board_name(args.mex_file)))
+util.write_pinctrl_header(args.iomuxc_output)
+print("Wrote pinctrl header file to %s" % (args.iomuxc_output))
+util.write_pinctrl_groups(args.mex_file, args.dts_output)
+print("Wrote pinctrl dts file to %s" % (args.dts_output))