scripts: kinetis: Add ability to generate pin groups

Script now supports generating pin groups from input mex file

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

Author: danieldegrasse

mcux/scripts/kinetis_gen_dts.py

@@ -12,3 +12,4 @@
 
 gen = NXPSdkUtil(xml, log_level = logging.INFO)
 gen.write_pinctrl_defs("pinctrl.dtsi")
+gen.write_pinctrl_groups("/mnt/windows-share/mex-files/FRDM-K64F.mex", 'board.dtsi')

mcux/scripts/kinetis_signal2dts.py

@@ -39,14 +39,18 @@ def __init__(self, connection):
         self._port = None
         for periph in connection.iter('peripheral_signal_ref'):
             self._periph = periph.attrib.get('peripheral')
+            self._signal = periph.attrib.get('signal')
+            self._channel = periph.attrib.get('channel')
         for assign in connection.iter('assign'):
             reg = assign.attrib.get('register')
             val = assign.attrib.get('bit_field_value')
             logging.debug('\t\t\t [ASSIGN] %s %s', reg, val)
             # Only process PCR registers
             match = re.match(r'PORT([A-Z])_PCR(\d+)', reg)
             if match:
-                self._name += f"_PT{match.group(1)}{match.group(2)}"
+                # For muxes like PTC5, do not append peripheral name
+                if re.match(r'PT[A-Z]\d+', self._name) is None:
+                    self._name += f"_PT{match.group(1)}{match.group(2)}"
                 self._port = match.group(1)
                 self._pin = int(match.group(2))
                 self._mux = int(val, 16)
@@ -72,6 +76,12 @@ def get_port(self):
         """
         return self._port
 
+    def get_signal(self):
+        """
+        Get mux signal name
+        """
+        return self._signal
+
     def get_pin(self):
         """
         Get mux pin
@@ -90,6 +100,12 @@ def get_periph(self):
         """
         return self._periph
 
+    def get_channel(self):
+        """
+        Get channel number
+        """
+        return self._channel
+
     def __hash__(self):
         """
         Override hash method to return pin name as hash
@@ -136,7 +152,13 @@ def __init__(self, pin):
             mux_opt = MUXOption(connections)
             # Only append mux options with a valid name
             if mux_opt.get_name() != '':
-                self._mux_options[mux_opt.get_name()] = mux_opt
+                # Use a string of the peripheral name and signal here, since that
+                # is what the MEX file uses as a key to find this mux option
+                key = f"{mux_opt.get_periph()}_{mux_opt.get_signal()}"
+                if mux_opt.get_channel() is not None:
+                    # Special case, use channel for key
+                    key = f"{mux_opt.get_periph()}_{mux_opt.get_channel()}"
+                self._mux_options[key] = mux_opt
 
     def __repr__(self):
         """
@@ -251,6 +273,112 @@ def _get_pin_properties(self, props):
                 prop_mapping[prop_id][state.attrib['id']] = bit_value
         return prop_mapping
 
+class PinGroup:
+    """
+    Internal class representing pin group
+    """
+    def __init__(self, function, signal_map):
+        """
+        Creates a pin group
+        @param function: function xml structure from MEX configuration file
+        @param signal_map: Signal mapping, maps signal names to signal pins
+        """
+        self._name = function.attrib.get('name')
+        pins = function.find('mex:pins', NAMESPACES)
+        signal_regex = re.compile(r'PT[A-Z]\d+')
+        # Build dictionary mapping pin properties to pins. This allows us to
+        # group pins based on shared configuration
+        self._pin_groups = collections.defaultdict(lambda: [])
+        for pin in pins:
+            # find signal defintion for this pin
+            signal_name = signal_regex.search(pin.attrib.get('pin_signal'))
+            if signal_name is None or (not signal_name.group(0) in signal_map):
+                # No definition for this pin mapping
+                logging.warning('Signal %s not matched', pin.attrib.get('pin_signal'))
+                continue
+            signal = signal_map[signal_name.group(0)]
+            # Get mux option for this pin
+            key = f"{pin.attrib.get('peripheral')}_{pin.attrib.get('signal')}"
+            channel =  re.search(r'(\d+)', pin.attrib.get('signal'))
+            # Special case, use channel for key
+            if channel:
+                key = f"{pin.attrib.get('peripheral')}_{channel.group(1)}"
+            mux = signal.get_mux_connection(key)
+            if mux is None:
+                # Do not add pinmux option to group
+                continue
+            # Get pin defaults for this pin
+            defaults = signal.get_pin_defaults()
+            # Get pin overrides
+            features = pin.find('mex:pin_features', NAMESPACES)
+            if features is not None:
+                pin_overrides = {}
+                for feature in pin.find('mex:pin_features', NAMESPACES):
+                    pin_overrides[feature.attrib.get('name')] = feature.attrib.get('value')
+            pin_props = self._props_to_dts(pin_overrides, defaults)
+            self._pin_groups[pin_props].append(mux)
+
+    def __repr__(self):
+        """
+        Get string representation of the object
+        """
+        return "PinGroup(%s)" % (self._name)
+
+    def get_pin_props(self):
+        """
+        Get all unique pin properties
+        """
+        return self._pin_groups.keys()
+
+    def get_pins(self, props):
+        """
+        Get all pins with a provided set of properties
+        @param props: property set
+        """
+        return self._pin_groups[props]
+
+    def get_name(self):
+        """
+        Get pin group name
+        """
+        return self._name
+
+    def _props_to_dts(self, props, defaults):
+        """
+        Remap dictionary of property names from NXP defined values to
+        Zephyr ones
+        @param props: Dictionary of NXP property names and values
+        @param defaults: Dictionary of NXP property names and default pin values
+        @return array of strings suitable for writing to DTS
+        """
+        zephyr_props = []
+        prop_mapping = {
+            'fast': 'fast',
+            'slow': 'slow',
+            'low': 'low',
+            'high': 'high',
+        }
+        # Lambda to convert property names to zephyr formatted strings
+        sanitize = lambda x: "\"" + prop_mapping[x] + "\"" if (x in prop_mapping) else ""
+        # Lambda to get property value or fallback on default
+        prop_val = lambda x: props[x] if x in props else defaults[x]
+        # Check pin defaults and overrides to see if the pin will have a pull
+        pull_enable = prop_val('pull_enable') == 'enable'
+        # For each property, append the provided override or the default
+        zephyr_props.append(f"drive-strength = {sanitize(prop_val('drive_strength'))}")
+        if prop_val('open_drain') == 'enable':
+            zephyr_props.append('drive-open-drain')
+        if pull_enable:
+            # If pull is enabled, select pull up or pull down
+            if prop_val('pull_select') == 'up':
+                zephyr_props.append('bias-pull-up')
+            else:
+                zephyr_props.append('bias-pull-down')
+        zephyr_props.append(f"slew-rate = {sanitize(prop_val('slew_rate'))}")
+        if prop_val('passive_filter') == 'enable':
+            zephyr_props.append("nxp,passive-filter")
+        return tuple(zephyr_props)
+
 
 class NXPSdkUtil:
     """
@@ -271,7 +399,7 @@ def __init__(self, signal_file, copyright_header = "", log_level = logging.ERROR
         self._logger.setLevel(log_level)
         self._parse_signal_xml(signal_file)
         self._copyright = copyright_header
-        logging.info("Loaded %d pin defs", len(self._pins))
+        logging.info("Loaded %d configurable pin defs", len(self._pins))
 
     def _parse_signal_xml(self, signal_fn):
         """
@@ -381,4 +509,66 @@ def write_pinctrl_defs(self, outputfile):
             self._write_pins('c', pcr_pins, file)
             self._write_pins('d', pcr_pins, file)
             self._write_pins('e', pcr_pins, file)
-    
+
+    def _parse_mex_cfg(self, mexfile):
+        """
+        Parses mex configuration into pin groups.
+        @param mexfile: mex configuration file to parse
+        @return parsed pin groups
+        """
+        pin_groups = {}
+        try:
+            mex_xml = ET.parse(mexfile)
+            for function in mex_xml.findall(
+                'mex:tools/mex:pins/mex:functions_list/mex:function', NAMESPACES):
+                group = PinGroup(function, self._pins)
+                pin_groups[group.get_name()] = group
+            return pin_groups
+        except ET.ParseError:
+            logging.error("Could not parse mex file %s", mex_xml)
+            return None
+
+    def write_pinctrl_groups(self, mexfile, outputfile):
+        """
+        Write pinctrl groups to disk as a parsed DTS file. Intended for use
+        with the output of @ref write_pinctrl_defs
+        @param mexfile: mex file to parse
+        @param outputfile: DTS pinctrl file to write pin groups to
+        """
+        file_header = ("/*\n"
+            " * NOTE: Autogenerated file by kinetis_signal2dts.py\n"
+            f" *       for {self._part_num}/signal_configuration.xml\n"
+            " *\n"
+            f" * {self._copyright}\n"
+            " * SPDX-License-Identifier: Apache-2.0\n"
+            " */\n"
+            "\n")
+        pin_groups = self._parse_mex_cfg(mexfile)
+        with open(outputfile, "w", encoding="utf8") as file:
+            file.write(file_header)
+            file.write("&pinctrl {\n")
+            # Write pin groups back out to disk
+            for group in pin_groups.values():
+                pin_props = group.get_pin_props()
+                if len(pin_props) == 0:
+                    # Do not write to disk
+                    continue
+                logging.info("Writing pin group %s to disk", group.get_name())
+                file.write(f"\t{group.get_name().lower()}:{group.get_name().lower()}: {{\n")
+                idx = 0
+                for pin_prop in sorted(pin_props):
+                    group_str = f"\t\tgroup{idx} {{\n"
+                    # Write all pin names
+                    group_str += "\t\t\tpins = <"
+                    for pin in group.get_pins(pin_prop):
+                        group_str += f"&{pin.get_name()}\n\t\t\t\t"
+                    # Strip out last 3 tabs and close pin name list
+                    group_str = re.sub(r'\n\t\t\t\t$', '>;\n', group_str)
+                    idx += 1
+                    # Write all pin props
+                    for prop in pin_prop:
+                        group_str += f"\t\t\t{prop}\n"
+                    group_str += "\t\t};\n"
+                    file.write(group_str)
+                file.write("\t};\n\n")
+            file.write("};\n")