scripts: Update signal2dts to use SignalPin class structure

Rework signal2dts to use SignalPin class structure, so that pin defaults
can be captured.

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

Author: danieldegrasse

mcux/scripts/kinetis_signal2dts.py

@@ -19,6 +19,239 @@
 PIN = collections.namedtuple('PIN', ['PERIPH', 'NAME_PART', 'SIGNAL', 'PORT',
                                      'PIN', 'CH', 'MUX_FUNC'])
 
+NAMESPACES = {'mex': 'http://mcuxpresso.nxp.com/XSD/mex_configuration_10'}
+
+class MUXOption:
+    """
+    Internal class representing a mux option on the SOC
+    """
+    def __init__(self, connection):
+        """
+        Initializes a mux option
+        @param connection XML connection option from signal_configuration.xml
+        """
+        self._name = connection.attrib.get('name_part')
+        logging.debug("\t\t %s", self._name)
+        if self._name is None:
+            self._name = ''
+            return
+        # Get MUX settings
+        self._port = None
+        for periph in connection.iter('peripheral_signal_ref'):
+            self._periph = periph.attrib.get('peripheral')
+        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)}"
+                self._port = match.group(1)
+                self._pin = int(match.group(2))
+                self._mux = int(val, 16)
+        if self._port is None:
+            # Not a valid port mapping. Clear name
+            self._name = ''
+
+    def __repr__(self):
+        """
+        String representation of object
+        """
+        return "MUXOption(%s)" % (self._name)
+
+    def get_name(self):
+        """
+        Get mux option name
+        """
+        return self._name
+
+    def get_port(self):
+        """
+        Get mux port
+        """
+        return self._port
+
+    def get_pin(self):
+        """
+        Get mux pin
+        """
+        return self._pin
+
+    def get_mux(self):
+        """
+        Get mux register write value
+        """
+        return self._mux
+
+    def get_periph(self):
+        """
+        Get peripheral name
+        """
+        return self._periph
+
+    def __hash__(self):
+        """
+        Override hash method to return pin name as hash
+        """
+        return hash(self._name)
+
+    def __eq__(self, obj):
+        """
+        Like the hash method, we override the eq method to return true if two
+        objects have the same pin name
+        """
+        return isinstance(obj, SignalPin) and self._name == obj._name
+
+    def __lt__(self, obj):
+        """
+        Compare objects based on name
+        """
+        if not isinstance(obj, SignalPin):
+            return True
+        return self._name < obj._name
+
+
+class SignalPin:
+    """
+    Internal class representing a signal on the SOC
+    """
+    def __init__(self, pin):
+        """
+        Initializes a SignalPin object
+        @param pin: pin XML object from signal_configuration.xml
+        """
+        # Kinetis pin names are formatted as [PT[Port][Pin]]
+        pin_regex = re.search(r'PT([A-Z])(\d+)', pin.attrib['name'])
+        if pin_regex is None:
+            logging.debug('Could not match pin name %s', pin.attrib['name'])
+            self._name = ''
+            return
+        self._name = pin_regex.group(0)
+        self._port = pin_regex.group(1)
+        self._pin = pin_regex.group(2)
+        self._properties = self._get_pin_properties(pin.find('functional_properties'))
+        self._mux_options = {}
+        for connections in pin.findall('connections'):
+            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
+
+    def __repr__(self):
+        """
+        String representation of object
+        """
+        return "SignalPin(%s)" % (self._name)
+
+    def __hash__(self):
+        """
+        Override hash method to return pin name as hash
+        """
+        return hash(self._name)
+
+    def __eq__(self, obj):
+        """
+        Like the hash method, we override the eq method to return true if two
+        objects have the same pin name
+        """
+        return isinstance(obj, SignalPin) and self._name == obj._name
+
+    def __lt__(self, obj):
+        """
+        Compare objects based on name
+        """
+        if not isinstance(obj, SignalPin):
+            return True
+        return self._name < obj._name
+
+    def get_name(self):
+        """
+        Get name of pin
+        """
+        return self._name
+
+    def get_port(self):
+        """
+        Get PORT this signal is defined for
+        """
+        return self._port
+
+    def get_pin(self):
+        """
+        Get pin this signal is defined for
+        """
+        return self._pin
+
+    def get_mux_connection(self, signal):
+        """
+        Gets an MUXOption object for the relevant signal name
+        @param signal: Signal name on pin to get mux option for
+        """
+        if signal in self._mux_options:
+            return self._mux_options[signal]
+        return None
+
+    def get_mux_options(self):
+        """
+        Gets all unique settings for IOMUX on the specific pin
+        """
+        return set(self._mux_options.values())
+
+    def get_pin_properties(self):
+        """
+        Gets array of pin property names
+        """
+        return self._properties.keys()
+
+    def get_pin_property_default(self, prop):
+        """
+        Gets name of default pin property
+        @param prop: name of pin property
+        """
+        return self._properties[prop]['default']
+
+    def get_pin_defaults(self):
+        """
+        Gets mapping of all pin property names to default value names
+        """
+        pin_defaults = {}
+        for prop in self.get_pin_properties():
+            pin_default = self.get_pin_property_default(prop)
+            pin_defaults[prop] = pin_default
+        return pin_defaults
+
+    def get_pin_property_value(self, prop, selection):
+        """
+        Gets bit value for pin property
+        @param prop: name of pin property
+        @param selection: name of option selected for property
+        """
+        return self._properties[prop][selection]
+
+    def _get_pin_properties(self, props):
+        """
+        Builds dictionary with all pin properties
+        @param props: pin function_properties XML object in signal_configuration.xml
+        """
+        prop_mapping = {}
+        for prop in props.findall('functional_property'):
+            if len(prop.findall('state/configuration/assign')) == 0:
+                # Not configurable property. Skip
+                continue
+            prop_id = prop.attrib['id']
+            if not 'default' in prop.attrib:
+                # No default property. Skip
+                continue
+            prop_mapping[prop_id] = {}
+            prop_mapping[prop_id]['default'] = prop.attrib['default']
+            for state in prop.findall('state'):
+                reg_assign = state.find('configuration/assign')
+                bit_value = int(reg_assign.attrib['bit_field_value'], 0)
+                prop_mapping[prop_id][state.attrib['id']] = bit_value
+        return prop_mapping
+
+
 class NXPSdkUtil:
     """
     Class for kinetis configuration file parser
@@ -38,15 +271,15 @@ 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 pinmux defs", len(self._pins))
+        logging.info("Loaded %d pin defs", len(self._pins))
 
     def _parse_signal_xml(self, signal_fn):
         """
         Parses signal XML configuration file. Builds a list of pins, which can
         be used to generate soc level DTSI file.
         @param signal_fn: signal_configuration.xml file to parse
         """
-        self._pins = []
+        self._pins = {}
         try:
             signal_tree = ET.parse(signal_fn)
         except ET.ParseError:
@@ -72,69 +305,10 @@ def _parse_signal_xml(self, signal_fn):
 
         pins_node = signal_root.find("pins")
         for pin in pins_node:
-            name = pin.attrib.get("name")
-
-            # Kinetis family uses PT[A-Z][0-31]
-            if "PT" in name:
-                logging.debug(name)
-
-                num_conns = 0
-
-                for conns in pin.findall("connections"):
-                    num_conns += 1
-                    logging.debug("\t%s - %s %s", num_conns, conns.tag, conns.attrib)
-                    name_part = conns.attrib.get("name_part")
-                    # func = conns.attrib.get("package_function")
-
-                    conns_tree = ET.ElementTree(conns)
-                    periph = None
-
-                    num_periph_sig = 0
-
-                    for ref in conns_tree.iter('peripheral_signal_ref'):
-                        num_periph_sig += 1
-                        logging.debug("\t\t%s - %s %s", num_periph_sig, ref.tag, ref.attrib)
-                        signal = ref.attrib.get("signal")
-                        periph = ref.attrib.get("peripheral")
-                        channel = ref.attrib.get("channel")
-
-                    if num_periph_sig > 1:
-                        logging.error(num_periph_sig)
-
-                    # handle unrouted_pin_function_ref case (disabled pin)
-                    if periph is None:
-                        continue
-
-                    pin = None
-
-                    for ref in conns_tree.iter('assign'):
-                        logging.debug("\t\t\t[ASSIGN] %s %s", ref.tag, ref.attrib)
-                        reg = ref.attrib.get("register")
-                        reg_match = re.search(r"PORT([A-Z])_PCR(\d+)", reg)
-
-                        # Only process PCR registers
-                        if reg_match:
-                            port = reg_match.group(1).lower()
-                            if len(reg_match.groups()) == 2:
-                                pin = reg_match.group(2).lower()
-                            else:
-                                pin = None
-                        else:
-                            continue
-
-                        logging.debug(ref.attrib)
-
-                        val = ref.attrib.get("bit_field_value")
-
-                        pin_data = PIN(PERIPH=periph,
-                                       NAME_PART=name_part,
-                                       SIGNAL=signal,
-                                       PORT=port,
-                                       PIN=int(pin),
-                                       CH=channel,
-                                       MUX_FUNC=int(val, 16))
-                        logging.debug(pin_data)
-                        self._pins.append(pin_data)
+            signal = SignalPin(pin)
+            # Only add valid signal pins to list
+            if signal.get_name() != '':
+                self._pins[signal.get_name()] = signal
 
     def _write_pins(self, which_port, pins, file):
         """
@@ -144,30 +318,30 @@ def _write_pins(self, which_port, pins, file):
         @param pins: list of pin mux options to write
         @param file: output file to write to
         """
-        port_pins = list(filter(lambda p: (p.PORT.lower() == which_port), pins))
+        port_pins = list(filter(lambda p: (p.get_port().lower() == which_port), pins))
 
         if (len(port_pins)) == 0:
             return
 
-        port_pins.sort(key=lambda p: (p.PIN, p.MUX_FUNC))
+        port_pins.sort(key=lambda p: (p.get_pin(), p.get_mux()))
 
         seen_nodes = []
 
         file.write(f"&port{which_port} {{\n")
         for pin_data in port_pins:
-            port_name = f"PT{pin_data.PORT.upper()}{pin_data.PIN}"
+            port_name = f"PT{pin_data.get_port().upper()}{pin_data.get_pin()}"
             # Special case handle GPIO so that it will be of the form:
             # PT[A-E][0-31]: GPIO[A-E]_PT[A-E][0-31]: ...
             #
             # eg:
             # PTA3: GPIOA_PTA3: gpioa_pta3 { .... };
-            if pin_data.PERIPH.startswith("GPIO"):
-                node = f"{pin_data.PERIPH.lower()}_{port_name.lower()}"
+            if pin_data.get_periph().startswith("GPIO"):
+                node = f"{pin_data.get_periph().lower()}_{port_name.lower()}"
                 label = f"{port_name}: {node.upper()}"
             else:
-                label = f"{pin_data.NAME_PART}_{port_name}"
+                label = pin_data.get_name()
                 node = label.lower()
-            k_port_pins_prop = f"< {pin_data.PIN} {pin_data.MUX_FUNC} >"
+            k_port_pins_prop = f"< {pin_data.get_pin()} {pin_data.get_mux()} >"
 
             if node in seen_nodes:
                 continue
@@ -187,7 +361,11 @@ def write_pinctrl_defs(self, outputfile):
         can include this pinctrl dtsi file to access pin control defintions.
         @param outputfile: file to write output pinctrl defs to
         """
-        pcr_pins = list(filter(lambda p: (p.PERIPH not in ["FB", "EZPORT"]), self._pins))
+        # Create list of all pin mux options
+        pinmux_opts = []
+        for pin in self._pins.values():
+            pinmux_opts.extend(pin.get_mux_options())
+        pcr_pins = list(filter(lambda p: (p.get_periph() not in ["FB", "EZPORT"]), pinmux_opts))
         file_header = ("/*\n"
             " * NOTE: Autogenerated file by kinetis_signal2dts.py\n"
             f" *       for {self._part_num}/signal_configuration.xml\n"
@@ -203,3 +381,4 @@ 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)
+