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/rt_cfg_utils.py

@@ -0,0 +1,338 @@
+"""
+Implements a module to parse iMX.RT MEX configuration files to extract pin
+configuration groups, and transform them into pinctrl groups suitable for use
+in Zephyr.
+"""
+
+
+import xml.etree.ElementTree as ET
+import collections
+import datetime
+import re
+import os
+import sys
+
+# MEX file has a default namespace, map it here
+namespaces = {'mex' : 'http://mcuxpresso.nxp.com/XSD/mex_configuration_10'}
+
+
+class NXPSdkUtil:
+    """
+    Class for iMX.RT configuration file parser for Zephyr
+    """
+    def __init__(self, iomuxc_file, signal_file):
+        """
+        Initialize 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
+        """
+        # Load the iomuxc file
+        try:
+            iomux = open(iomuxc_file, 'r', encoding='utf8')
+            # Load the iomuxc name mapping
+            self._iomuxc_map = self._build_iomuxc_map(iomux)
+        except IOError:
+            print(f"File {iomuxc_file} could not be opened")
+            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 ET.ParseError:
+            print(f"Malformed XML tree {signal_file}")
+            self._signal_map = None
+        except IOError:
+            print(f"File {signal_file} could not be opened")
+            self._signal_map = None
+
+    def get_soc(self):
+        """
+        Get SOC this class is initialized for
+        """
+        return self._soc
+
+    def get_sku(self):
+        """
+        Get SOC SKU this class is initialized for
+        """
+        return self._soc_sku
+
+    def write_pinctrl_header(self, outputfile):
+        """
+        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
+        """
+        if self._iomuxc_map is None:
+            print("Cannot write pinctrl header file without an iomuxc file")
+        try:
+            header_file = open(outputfile, "w", encoding='utf8')
+        except IOError:
+            print(f"Could not write to file {outputfile}")
+            return
+        # Start by writing header
+        header = (f"/*\n"
+        f" * Generated by {os.path.basename(__file__)} on {datetime.date.today()}\n"
+        " */\n\n")
+        header_file.write(header)
+        for (iomuxc, entry) in self._iomuxc_map.items():
+            # Write iomuxc entry
+            register = entry[0]
+            mode = entry[1]
+            input_reg = entry[2]
+            input_daisy = entry[3]
+            config_reg = entry[4]
+            entry = (f"#define {iomuxc} 0x{register:x} {mode:d} 0x{input_reg:x} "
+                    f"{input_daisy:d} 0x{config_reg:x}\n")
+            header_file.write(entry)
+        header_file.write("\n")
+        header_file.close()
+
+
+    def write_pinctrl_groups(self, mexfile, outputfile):
+        """
+        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
+        """
+        if self._signal_map is None:
+            print("Cannot write pinctrl groups without a signal map")
+        try:
+            config_tree = ET.parse(mexfile)
+        except ET.ParseError:
+            print(f"Malformed XML tree {mexfile}")
+            return
+        except IOError:
+            print(f"File {mexfile} could not be opened")
+            return
+        try:
+            dts_file = open(outputfile, "w", encoding='utf8')
+        except IOError:
+            print(f"Could not write to file {outputfile}")
+            return
+        # Parse the mex file
+        pin_groups = self._parse_mex_cfg(config_tree, self._signal_map)
+        # Start by writing header
+        header = ("/*\n"
+         f" * Generated by {os.path.basename(__file__)} on {datetime.date.today()}\n"
+         " */\n\n")
+        dts_file.write(header)
+        dts_file.write(f"#include <nxp/nxp_imx/rt/{self.get_soc().lower()}_iomuxc.h>\n\n")
+        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(f"\t{pin_group}: {pin_group} {{\n")
+            # 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(f"\t\t{pin} {{\n")
+                # Write the pinmux setting first
+                dts_file.write(f"\t\t\tpinmux = <{sorted_pins[pin]['pinmux']}>;\n")
+                # 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(f"\t\t\tnxp,{setting} = <{feature_dict[setting]}>;\n")
+                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()
+
+    def get_board_name(self, mexfile):
+        """
+        Extracts board name from a mex file
+        """
+        try:
+            config_tree = ET.parse(mexfile)
+        except ET.ParseError:
+            print(f"Malformed XML tree {mexfile}")
+            return None
+        except IOError:
+            print(f"File {mexfile} could not be opened")
+            return None
+        return config_tree.getroot().find('mex:common/mex:board', namespaces).text
+
+
+    """
+    Private class methods
+    """
+    def _generate_pin_node(self, pad, pin):
+        """
+        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
+        """
+        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((f"Error: invalid value {feature.attrib['value']} "
+                                f"for feature {feature.attrib['name']}"))
+                            # Exit here, do not finish parsing the MEX file
+                            sys.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
+                        assign = state.find('configuration/assign')
+                        pin_node[prop.attrib['id']] = assign.attrib['bit_field_value']
+                        break
+        return pin_node
+
+    def _find_periph_connection(self, pad, pin):
+        """
+        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
+        """
+        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:
+                    sig_name = periph_sig_ref.attrib['signal']
+                    chan = periph_sig_ref.attrib['channel']
+                    signal = f"{sig_name}, {chan}"
+                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(r'DATA\d$', name_part) and not re.search('USDHC', name_part):
+                        name_part = re.sub(r'DATA(\d)$', r'DATA0\g<1>', name_part)
+                    mapping_name = f"IOMUXC_{pad.attrib['name']}_{name_part}"
+                    break
+        return mapping_name
+
+    def _parse_mex_cfg(self, mex_xml, pin_mapping):
+        """
+        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
+        """
+        # 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((f"Error: pin mapping has invalid pin name for peripheral "
+                        f"{pin.attrib['peripheral']} in group {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((f"Error: mapping peripheral {pin.attrib['peripheral']} "
+                        "to pad {pad.attrib['name']} is not valid"))
+                    # Exit here, do not finish parsing the MEX file.
+                    sys.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
+
+    def _build_iomuxc_map(self, iomuxc):
+        """
+        Build dictionary containing mapping of IOMUXC names to
+        a tuple with their register values
+        @param iomuxc iomuxc file to read from
+        @return generated dictionary
+        """
+        regexstr = (r'#define\s+(IOMUXC_\w+)\s+' # MUX name
+                r'([0x]*[\dA-F]+)U*[\s,]+' # MUX register
+                r'([0x]*[\dA-F]+)U*[\s,]+' # MUX mode
+                r'([0x]*[\dA-F]+)U*[\s,]+' # MUX input_reg
+                r'([0x]*[\dA-F]+)U*[\s,]+' # MUX input_daisy
+                r'([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
+
+    def _load_signal_map(self, xml):
+        """
+        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
+        """
+        # 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_dts_gen.py

@@ -0,0 +1,58 @@
+"""
+Wrapper around rt_cfg_utils.py to provide arguments to module
+"""
+import argparse
+
+from rt_cfg_utils import NXPSdkUtil
+
+
+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 = f"{board}-pinctrl.dtsi"
+    else:
+        args.dts_output = f"{util.get_soc().lower()}-pinctrl.dtsi"
+if not args.iomuxc_output:
+    args.iomuxc_output = f"{util.get_soc().lower()}_iomuxc.h"
+print(f"Generating configuration for {util.get_board_name(args.mex_file)}")
+util.write_pinctrl_header(args.iomuxc_output)
+print(f"Wrote pinctrl header file to {args.iomuxc_output}")
+util.write_pinctrl_groups(args.mex_file, args.dts_output)
+print(f"Wrote pinctrl dts file to {args.dts_output}")