scripts: mcux: update pin script to generate headers

Update pin generation script to create pinctrl headers, and add second
script to generate headers versus pinctrl definition files

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

Author: danieldegrasse

mcux/scripts/kinetis_cfg_utils.py

@@ -10,7 +10,6 @@
 pinctrl definitions for Zephyr
 """
 
-from bdb import set_trace
 import xml.etree.ElementTree as ET
 import re
 import collections
@@ -70,7 +69,7 @@ def get_name(self):
         Get mux option name
         """
         return self._name
-    
+
     def get_mux_name(self):
         """
         Get name of the mux option, without pin name
@@ -261,9 +260,6 @@ def _get_pin_properties(self, props):
         """
         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
@@ -272,7 +268,11 @@ def _get_pin_properties(self, props):
             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)
+                if reg_assign:
+                    bit_value = int(reg_assign.attrib['bit_field_value'], 0)
+                else:
+                    # Assume writing zero to register will select default
+                    bit_value = 0
                 prop_mapping[prop_id][state.attrib['id']] = bit_value
         return prop_mapping
 
@@ -322,6 +322,20 @@ def __repr__(self):
         Get string representation of the object
         """
         return "PinGroup(%s)" % (self._name)
+    
+    def __eq__(self, obj):
+        """
+        return true if two objects have the same pin group name
+        """
+        return isinstance(obj, PinGroup) and self._name == obj._name
+
+    def __lt__(self, obj):
+        """
+        Compare objects based on name
+        """
+        if not isinstance(obj, PinGroup):
+            return True
+        return self._name < obj._name
 
     def get_pin_props(self):
         """
@@ -459,22 +473,19 @@ def _write_pins(self, which_port, pins, file):
             label = pin_data.get_name()
             port = pin_data.get_port()
             pin = pin_data.get_pin()
-
-            # Port values range from 'A'-'E'. Store with 4 bits
-            # Shift port value so it will not conflict with pin configuration
-            pin_val = (((ord(port) - ord('A')) & 0xF) << 28)
-            # Shift pin value to where it will be stored in the pin setting reg
-            # Pin values range from 0-31, give 6 bits for future expansion
-            # Shift pin value so it will not conflict with pin configuration
-            pin_val |= ((int(pin) & 0x3F) << 22)
-            # Put pin mux value in at the correct offset for the pin config register
-            pin_val |= ((pin_data.get_mux() & 0x7) << 8)
+            mux = pin_data.get_mux()
 
             if label in seen_nodes:
                 continue
             seen_nodes.append(label)
 
-            file.write(f"#define {label} 0x{pin_val:x} /* PT{port}{pin} */\n")
+            file.write(f"#define {label} KINETIS_MUX('{port}',{pin},{mux}) /* PT{port}{pin} */\n")
+
+    def get_part_num(self):
+        """
+        Return the part number this class is instantiated for
+        """
+        return self._part_num
 
     def write_pinctrl_defs(self, outputfile):
         """
@@ -494,15 +505,27 @@ def write_pinctrl_defs(self, outputfile):
             f" * {self._copyright}\n"
             " */\n"
             "\n")
+        
+        # Notes on the below macro:
+        # Port values range from 'A'-'E', so we store them with 4 bits,
+        # with port A being 0, B=1,...
+        # Pin values range from 0-31, so we give 6 bits for future expansion
+        # Mux values range from 0-8, so we give 3 bits
+        # shift the port and pin values to the MSBs of the mux value, so they
+        # don't conflict with pin configuration settings
+        # Store the mux value at the offset it will actually be written to the
+        # configuration register
+        mux_macro = ("#define KINETIS_MUX(port, pin, mux)\t\t\\\n"
+                "\t(((((port) - 'A') & 0xF) << 28) |\t\\\n"
+                "\t(((pin) & 0x3F) << 22) |\t\t\\\n"
+                "\t(((mux) & 0x7) << 8))\n\n")
         with open(outputfile, "w", encoding="utf8") as file:
             file.write(file_header)
             # ifdef guard
             file.write(f"#ifndef _ZEPHYR_DTS_BINDING_{self._part_num.upper()}_\n")
             file.write(f"#define _ZEPHYR_DTS_BINDING_{self._part_num.upper()}_\n\n")
             # Write macro to make port name
-            file.write("#define MUX(port, pin) (((((port) - 'A') & 0xF) << 28) | (((pin) & 0x3F)) << 22)\n\n")
-            file.write("#define PIN(mux) (((mux) & 0xFC00000) >> 22\n\n")
-            file.write("#define PORT(mux) (((mux) & 0xF0000000) >> 28)\n\n")
+            file.write(mux_macro)
             self._write_pins('a', pcr_pins, file)
             self._write_pins('b', pcr_pins, file)
             self._write_pins('c', pcr_pins, file)
@@ -548,7 +571,7 @@ def write_pinctrl_groups(self, mexfile, outputfile):
             file.write(f"\n#include <nxp/kinetis/{get_package_name(mexfile)}-pinctrl.h>\n\n")
             file.write("&pinctrl {\n")
             # Write pin groups back out to disk
-            for group in pin_groups.values():
+            for group in sorted(pin_groups.values()):
                 pin_props = group.get_pin_props()
                 if len(pin_props) == 0:
                     # Do not write to disk
@@ -559,11 +582,11 @@ def write_pinctrl_groups(self, mexfile, outputfile):
                 for pin_prop in sorted(pin_props):
                     group_str = f"\t\tgroup{idx} {{\n"
                     # Write all pin names
-                    group_str += "\t\t\tpinmux = <"
+                    group_str += "\t\t\tpinmux = "
                     for pin in group.get_pins(pin_prop):
-                        group_str += f"{pin.get_name()}\n\t\t\t\t"
+                        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)
+                    group_str = re.sub(r',\n\t\t\t\t$', ';\n', group_str)
                     idx += 1
                     # Write all pin props
                     for prop in pin_prop:

mcux/scripts/kinetis_gen_dts.py

@@ -8,12 +8,10 @@
 Wrapper around kinetis_signal2dts.py to provide arguments
 """
 
-import logging
 import datetime
 import argparse
 import pathlib
 import sys
-import re
 
 import kinetis_cfg_utils
 
@@ -41,10 +39,6 @@
                     help='Enable default NXP copyright')
 parser.add_argument('--board-output', metavar = 'BOARD_OUT', type=str,
                     help='Output path for board level DTS file')
-parser.add_argument('--soc-output', metavar = 'SOC_OUT', type=str,
-                    help='Output path for soc level DTSI file')
-parser.add_argument('--signal-file', metavar = 'SIGNAL_XML', type=str,
-                    help='Direct path to source signal_configuration.xml file')
 
 args = parser.parse_args()
 
@@ -54,41 +48,37 @@
 
 if not args.board_output:
     args.board_output = f"{board_name.lower().replace('-', '_')}-pinctrl.dtsi"
-
-if not args.soc_output:
-    args.soc_output = f"{package_name}-pinctrl.h"
+elif pathlib.Path(args.board_output).is_dir():
+    # Append board name to path
+    if not args.board_output.endswith('/'):
+        args.board_output += '/'
+    args.board_output += f"{board_name.lower().replace('-', '_')}-pinctrl.dtsi"
 
 if args.cfg_tool_root:
     # Attempt to locate all the required config files automatically, using
     # the processor name given in the mex file
     proc_root = pathlib.Path(args.cfg_tool_root) / processor_name / 'ksdk2_0' / package_name
     if not proc_root.exists():
-        print(f"Error: Path {args.cfg_tool_root} provided for config root root is invalid")
+        print(f"Error: Path {args.cfg_tool_root} provided for config root is invalid")
         sys.exit(255)
     # Check for all the files we need
     signal_path = proc_root / 'signal_configuration.xml'
     # Verify files exist
     if not signal_path.exists():
         print("CFG tools path appears valid, but required files could not be found")
         sys.exit(254)
-    # Set filenames to arguments for tool
-    if not args.signal_file:
-        args.signal_file = str(signal_path)
-
+    signal_file = str(signal_path)
 
 
-xml = "signal_configuration.xml"
 
 if args.copyright:
     # Add default copyright
     copyright_txt = (f"Copyright (c) {datetime.datetime.today().year}, NXP\n"
     f" * SPDX-License-Identifier: Apache-2.0")
-    util = kinetis_cfg_utils.NXPSdkUtil(args.signal_file, copyright_header= copyright_txt)
+    util = kinetis_cfg_utils.NXPSdkUtil(signal_file, copyright_header= copyright_txt)
 else:
-    util = kinetis_cfg_utils.NXPSdkUtil(args.signal_file)
+    util = kinetis_cfg_utils.NXPSdkUtil(signal_file)
 
 print(f"Generating configuration for {board_name}")
-util.write_pinctrl_defs(args.soc_output)
-print(f"Wrote pinctrl header defs to {args.soc_output}")
 util.write_pinctrl_groups(args.mex_file, args.board_output)
 print(f"Wrote pinctrl dts file to {args.board_output}")

mcux/scripts/kinetis_gen_headers.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2022, NXP
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Wrapper around kinetis_signal2dts.py to provide arguments
+"""
+
+import datetime
+import argparse
+from errno import EINVAL, ENOTDIR
+import pathlib
+import sys
+
+import kinetis_cfg_utils
+
+HELPSTR = """
+Processes NXP Kinetis signal configuration files and outputs kinetis pinctrl
+headers. Only supports Kinetis parts.
+This tool is intended to be used with the configuration data downloaded
+from NXP's website. One way to extract this config data is to use the
+MCUXpresso configuration tool to download processor defintions, locate
+those defintions on the disk. Alternatively, individual processor config
+data packs can be downloaded from the MCUXpresso SDK builder tool. Either way,
+the path to the 'processors' directory must be provided as the 'cfg-tool-root'
+parameter.
+"""
+
+parser = argparse.ArgumentParser(description=HELPSTR,
+    formatter_class=argparse.RawDescriptionHelpFormatter)
+
+parser.add_argument('--processor-root', metavar = 'PROC_ROOT', type=str,
+                    help='Path to root of processor directory with package defintions')
+parser.add_argument('--copyright', action='store_true',
+                    help='Enable default NXP copyright')
+parser.add_argument('--soc-output', metavar = 'SOC_OUT', type=str,
+                    help='Output folder for soc level header files')
+
+args = parser.parse_args()
+
+if not args.soc_output:
+    args.soc_output = "."
+elif not pathlib.Path(args.soc_output).is_dir():
+    print('SOC output path must be a directory')
+    sys.exit(ENOTDIR)
+
+# Attempt to locate the signal XML files we will generate from
+proc_root = pathlib.Path(args.processor_root) / 'ksdk2_0'
+if not proc_root.exists():
+    print(f"Error: Path {args.processor_root} provided for processor root is invalid")
+    sys.exit(EINVAL)
+# Iterate through all processor package signal.xml files
+for directory in proc_root.iterdir():
+    signal_path = directory / 'signal_configuration.xml'
+    if signal_path.exists():
+        if args.copyright:
+            # Add default copyright
+            copyright_txt = (f"Copyright (c) {datetime.datetime.today().year}, NXP\n"
+            f" * SPDX-License-Identifier: Apache-2.0")
+            util = kinetis_cfg_utils.NXPSdkUtil(str(signal_path), copyright_header= copyright_txt)
+        else:
+            util = kinetis_cfg_utils.NXPSdkUtil(str(signal_path))
+        out_path = f"{args.soc_output}/{util.get_part_num().upper()}-pinctrl.h"
+        util.write_pinctrl_defs(out_path)
+        print(f"Wrote pinctrl header defs to {out_path}")