scripts: updated rt_cfg_utils for rt11xx support

Updated rt_cfg_utils for rt11xx support, and changed name formatting

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

Author: danieldegrasse

mcux/scripts/rt_cfg_utils.py

@@ -163,31 +163,36 @@ def __init__(self, pin, peripheral_map):
         """
         self._name = pin.attrib['name']
         self._properties = self._get_pin_properties(pin.find('functional_properties'))
-        cfg_assign_xml = pin.find('functional_properties/functional_property/'
-                'state/configuration/assign')
+        functional_prop = pin.find('functional_properties/functional_property')
+        cfg_assign_xml = functional_prop.find('state/configuration/assign')
         self._iomuxc_options = {}
         if cfg_assign_xml is None:
             # Not a configurable register. Skip.
             return
         match = re.match(r'init_([\w_]+)', cfg_assign_xml.attrib['configuration_step'])
         periph_name = match.group(1)
-        match = re.match(re.escape(periph_name) + r'_(\w+)', cfg_assign_xml.attrib['register'])
-        reg_name = match.group(1)
-        cfg_addr = peripheral_map[periph_name].get_reg_addr(reg_name)
+        if functional_prop.attrib.get('id') != 'software_input_on':
+            match = re.match(re.escape(periph_name) + r'_(\w+)', cfg_assign_xml.attrib['register'])
+            reg_name = match.group(1)
+            match = re.match(r'SW_PAD_CTL_PAD_(\w+)', reg_name)
+            pad_name = match.group(1)
+            cfg_addr = peripheral_map[periph_name].get_reg_addr(reg_name)
+        else:
+            # This pad has mux options, but no configuration settings.
+            cfg_addr = 0x0
+            pad_name = self._name
         for connections in pin.findall('connections'):
+            name_part = connections.attrib.get('name_part')
             connection = connections.find('connection')
-            iomux_opt = IOMUXOption(connection, peripheral_map, cfg_addr)
+            name = f"{periph_name}_{pad_name}_{name_part}"
+            iomux_opt = IOMUXOption(connection, peripheral_map, cfg_addr, name)
             peripheral = connection.find('peripheral_signal_ref').attrib['peripheral']
             signal = connection.find('peripheral_signal_ref').attrib['signal']
             channel = connection.find('peripheral_signal_ref').attrib.get('channel')
             if channel is not None:
                 mux_name = f"{peripheral}_{signal}, {channel}"
             else:
                 mux_name = f"{peripheral}_{signal}"
-            if iomux_opt.get_name() == '':
-                # Use the default name of {peripheral_name}_{pin_name}
-                iomux_opt = IOMUXOption(connection,
-                    peripheral_map, cfg_addr, name = f"{periph_name}_{self._name}")
             self._iomuxc_options[mux_name] = iomux_opt
 
     def __repr__(self):
@@ -289,11 +294,14 @@ def _get_pin_properties(self, props):
         return prop_mapping
 
 
+# named tuple for GPIO port/pin
+GPIO = collections.namedtuple('GPIO', 'port pin')
+
 class IOMUXOption:
     """
     Internal class representing an IOMUXC option
     """
-    def __init__(self, connection, peripheral_map, cfg_reg, name = ''):
+    def __init__(self, connection, peripheral_map, cfg_reg, name):
         """
         Initializes an IOMUXC option object
         @param connection: connection XML object from signal_configuration.xml
@@ -309,8 +317,20 @@ def __init__(self, connection, peripheral_map, cfg_reg, name = ''):
         self._daisy_val = 0
         self._cfg_reg = cfg_reg
         self._has_extended_config = False
+        self._has_gpr = False
         self._extended_config = []
         self._name = name
+        # Check if this connection controls a GPIO
+        peripheral = connection.find('peripheral_signal_ref').attrib.get('peripheral')
+        channel = connection.find('peripheral_signal_ref').attrib.get('channel')
+        if 'GPIO' in peripheral and channel is not None:
+            match = re.search(r'GPIO(\d+)', peripheral)
+            gpio_port = match.group(1)
+            self._is_gpio = True
+            self._gpio = GPIO(int(gpio_port), int(channel))
+        else:
+            self._is_gpio = False
+            self._gpio = (0, 0)
         # Get connection register names
         for assignment in connection.findall('configuration/assign'):
             match = re.match(r'init_([\w_]+)', assignment.attrib['configuration_step'])
@@ -321,22 +341,21 @@ def __init__(self, connection, peripheral_map, cfg_reg, name = ''):
             periph = peripheral_map[periph_name]
             addr = periph.get_reg_addr(reg_name)
             value = int(assignment.attrib['bit_field_value'], 0)
-            if not 'bit_field' in assignment.attrib:
-                # Add register name and bit field value to extra configuration
-                self._has_extended_config = True
-                config = {full_name : assignment.attrib['bit_field_value']}
-                self._extended_config.append(config)
-                continue
-            if assignment.attrib['bit_field'] == 'DAISY':
+            if assignment.attrib.get('bit_field') == 'DAISY':
                 self._daisy = addr
                 self._daisy_val = value
-            elif assignment.attrib['bit_field'] == 'MUX_MODE':
+            elif assignment.attrib.get('bit_field') == 'MUX_MODE':
                 self._mux = addr
                 self._mux_val = value
-                register = periph.get_register(reg_name)
-                # Create IOMUXC name for this connection
-                if self._name == '':
-                    self._name = self._generate_iomuxc_name(periph, register, value)
+            elif periph_name == 'IOMUXC_GPR':
+                # GPR register can be used as a secondary pinmux selection,
+                # record this setting
+                self._has_gpr = True
+                self._gpr_reg = addr
+                gpr_mask = int(assignment.attrib.get('bit_field_mask'), 0)
+                # Calculate gpr bit shift
+                self._gpr_shift = ((gpr_mask) & -(gpr_mask)).bit_length() - 1
+                self._gpr_val = int(assignment.attrib.get('bit_field_value'), 0)
             else:
                 # Add register name and bit field value to extra configuration
                 self._has_extended_config = True
@@ -349,6 +368,8 @@ def __repr__(self):
         """
         if self._has_extended_config:
             return "IOMUXOpt(%s, 0x%X = %d, ExtCfg)" % (self._name, self._mux, self._mux_val)
+        elif self._has_gpr:
+            return "IOMUXOpt(%s, 0x%X = %d, GPR)" % (self._name, self._mux, self._mux_val)
         return "IOMUXOpt(%s, 0x%X = %d)" % (self._name, self._mux, self._mux_val)
 
     def __hash__(self):
@@ -387,7 +408,20 @@ def get_mux_reg(self):
         Get the mux reg for this iomux option
         """
         return self._mux
-
+    
+    def is_gpio(self):
+        """
+        return True if this iomux option is for a GPIO
+        """
+        return self._is_gpio
+    
+    def gpio(self):
+        """
+        Get iomux gpio port and pin as a tuple of (port,pin)
+        only valid if is_gpio is True
+        """
+        return self._gpio
+     
     def get_mux_val(self):
         """
         Get the mux value for this iomux option
@@ -412,6 +446,30 @@ def get_cfg_reg(self):
         """
         return self._cfg_reg
 
+    def has_gpr(self):
+        """
+        Return true if iomux option has associated GPR configuration requirement
+        """
+        return self._has_gpr
+    
+    def gpr_reg(self):
+        """
+        If has_gpr() is true, return GPR register address
+        """
+        return self._gpr_reg
+    
+    def gpr_shift(self):
+        """
+        If has_gpr() is true, return shift on GPR register value
+        """
+        return self._gpr_shift
+    
+    def gpr_val(self):
+        """
+        If has_gpr() is true, return GPR register value
+        """
+        return self._gpr_val
+
     def has_extended_config(self):
         """
         Return true if the iomux option requires extended register configuration
@@ -424,21 +482,6 @@ def get_extended_config(self):
         """
         return self._extended_config
 
-    def _generate_iomuxc_name(self, periph, reg, mux_val):
-        """
-        Extracts the iomuxc name for a connection from the SW_MUX_CTL_PAD
-        register that is being set. The register description is used to generate
-        the final iomuxc name, like in MCUXpresso config tools
-        @param periph: peripheral object with the SW_MUX_CTL_PAD register
-        @param reg: register object holding the SW_MUX_CTL_PAD register object
-        @param mux_val: mux value being selected in register
-        """
-        pad_name = re.match(r'SW_MUX_CTL_PAD_(\w+)', reg.get_name()).group(1)
-        description = reg.get_bit_field_value_description('MUX_MODE', mux_val)
-        mux_name = re.search(r': (\w+) of instance', description).group(1)
-        return f"{periph.get_name()}_{pad_name}_{mux_name}"
-
-
 class PinGroup:
     """
     Internal class representing pin group
@@ -680,6 +723,54 @@ def get_part_num(self):
         """
         return self._soc_sku
 
+    def write_gpio_mux(self, outputfile):
+        """
+        Write pinctrl defintions for GPIO mux. These defintions map GPIO port
+        and pin combinations to iomuxc options. Note that these defintions are
+        not indended to be used directly, and will likely need to be hand edited.
+        @param outputfile file to write gpio dtsi file to
+        """
+        # Layered dictionary of gpio mux options. The root keys
+        # are the port names, and those port names map to
+        # dictionaries of pin->iomux option mappings
+        gpio_map = collections.defaultdict(lambda: {})
+        with open(outputfile, "w", encoding='utf8') as gpio_dsti:
+            # Write header
+            gpio_dsti.write(f"/*\n"
+                f" * File created by {os.path.basename(__file__)}\n"
+                " * not intended for direct usage. Hand edit these DTS\n"
+                " * nodes as needed to integrate them into Zephyr.\n"
+                " */\n\n")
+            for pin in sorted(self._signal_map.values()):
+                for iomux_opt in sorted(pin.get_mux_options()):
+                    if iomux_opt.is_gpio():
+                        gpio = iomux_opt.gpio()
+                        if 'CM7' in iomux_opt.get_name():
+                            gpio_map[f"{gpio.port}_CM7"][gpio.pin] = iomux_opt
+                        else:
+                            gpio_map[str(gpio.port)][gpio.pin] = iomux_opt
+            # Now write SOC level GPIO pinmux definitions. These are required
+            # so that gpio driver is capable of selecting pinmux options when
+            # a gpio pin is configured.
+            gpio_dsti.write("/*\n"
+                " * GPIO pinmux options. These options define the pinmux settings\n"
+                " * for GPIO ports on the package, so that the GPIO driver can\n"
+                " * select GPIO mux options during GPIO configuration.\n"
+                " */\n\n")
+            for port in sorted(gpio_map):
+                dts_node = (f"&gpio{port}{{\n"
+                                "\tpinmux = ")
+                for pin in sorted(gpio_map[port]):
+                    iomux_opt = gpio_map[port][pin]
+                    dts_node += f"<&{iomux_opt.get_name().lower()}>,\n\t\t"
+                dts_node = re.sub(r',\n\t\t$', ";\n", dts_node)
+                # end group
+                dts_node += "};\n\n"
+                gpio_dsti.write(dts_node)
+            gpio_dsti.close()
+
+
+
     def write_pinctrl_defs(self, outputfile):
         """
         Writes a pinctrl dtsi file that defines all pinmux options. The board
@@ -743,11 +834,16 @@ def write_pinctrl_defs(self, outputfile):
                             print(f"Warning: unmatched signal pin name {iomuxc_name}")
                             reg_type = ''
                         dts_node += f"\t\t{reg_type};\n"
+                    if iomux_opt.has_gpr():
+                        gpr_reg = iomux_opt.gpr_reg()
+                        gpr_shift = iomux_opt.gpr_shift()
+                        gpr_val = iomux_opt.gpr_val()
+                        # Add GPR configuration
+                        dts_node += f"\t\tgpr = <0x{gpr_reg:x} 0x{gpr_shift:x} 0x{gpr_val:x}>;\n"
                     dts_node += "\t};\n"
                     # Write iomuxc dts node to file
                     soc_dtsi.write(dts_node)
-            soc_dtsi.write("};\n\n")
-            soc_dtsi.close()
+            soc_dtsi.write("};\n\n") 
 
     def write_pinctrl_groups(self, mexfile, outputfile):
         """
@@ -876,10 +972,9 @@ def _load_signal_map(self, xml):
         iomuxc_options = {}
         for pad in pads:
             pad_name = pad.attrib['name']
-            if len(pad.findall('functional_properties/functional_property')) == 0:
-                # Not a configurable pad. Continue
-                continue
-            iomuxc_options[pad_name] = SignalPin(pad, self._peripheral_map)
+            # Verify signal pad is configurable
+            if len(pad.findall('functional_properties/functional_property')) != 0:
+                iomuxc_options[pad_name] = SignalPin(pad, self._peripheral_map)
         return iomuxc_options