scripts: Enabled argparse for kinetis_gen_dts.py

Enabled argument parsing for kinetis_gen_dts.py, to simplify usage.

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

Author: danieldegrasse

mcux/scripts/kinetis_signal2dts.py renamed to mcux/scripts/kinetis_cfg_utils.py

@@ -69,6 +69,14 @@ 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
+        """
+        if self._channel:
+            return f"{self._periph}_{self._signal}, {self._channel}"
+        return f"{self._periph}_{self._signal}"
 
     def get_port(self):
         """
@@ -143,7 +151,7 @@ def __init__(self, pin):
             logging.debug('Could not match pin name %s', pin.attrib['name'])
             self._name = ''
             return
-        self._name = pin_regex.group(0)
+        self._name = pin.attrib['name']
         self._port = pin_regex.group(1)
         self._pin = pin_regex.group(2)
         self._properties = self._get_pin_properties(pin.find('functional_properties'))
@@ -152,13 +160,7 @@ def __init__(self, pin):
             mux_opt = MUXOption(connections)
             # Only append mux options with a valid name
             if mux_opt.get_name() != '':
-                # 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
+                self._mux_options[mux_opt.get_mux_name()] = mux_opt
 
     def __repr__(self):
         """
@@ -285,34 +287,30 @@ def __init__(self, function, signal_map):
         """
         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'))
+            signal_name = pin.attrib.get('pin_signal')
+            signal = signal_map[signal_name]
+            if not signal:
+                logging.warning('Signal name %s not present in mapping', signal_name)
+                # No way to find mux option
                 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)
+            # Get mux option for this signal
+            mux_option = f"{pin.attrib.get('peripheral')}_{pin.attrib.get('signal')}"
+            mux = signal.get_mux_connection(mux_option)
             if mux is None:
+                logging.warning('Signal name %s has no mux', mux_option)
                 # 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)
+            pin_overrides = {}
             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)
@@ -499,7 +497,6 @@ def write_pinctrl_defs(self, outputfile):
             f" *       for {self._part_num}/signal_configuration.xml\n"
             " *\n"
             f" * {self._copyright}\n"
-            " * SPDX-License-Identifier: Apache-2.0\n"
             " */\n"
             "\n")
         with open(outputfile, "w", encoding="utf8") as file:
@@ -540,12 +537,12 @@ def write_pinctrl_groups(self, mexfile, outputfile):
             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(f"\n#include <nxp/kinetis/{get_package_name(mexfile)}-pinctrl.dtsi>\n\n")
             file.write("&pinctrl {\n")
             # Write pin groups back out to disk
             for group in pin_groups.values():
@@ -554,21 +551,73 @@ def write_pinctrl_groups(self, mexfile, outputfile):
                     # 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")
+                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 = <"
+                    group_str += "\t\t\tpinmux = <"
                     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 += f"\t\t\t{prop};\n"
                     group_str += "\t\t};\n"
                     file.write(group_str)
                 file.write("\t};\n\n")
             file.write("};\n")
+
+"""
+Utility functions used to get details about board/processor from MEX file
+"""
+
+def get_board_name(mexfile):
+    """
+    Extracts board name from a mex file
+    @param mexfile: mex file to parse for board name
+    """
+    try:
+        config_tree = ET.parse(mexfile)
+        return config_tree.getroot().find('mex:common/mex:board',
+            NAMESPACES).text
+    except ET.ParseError:
+        print(f"Malformed XML tree {mexfile}")
+        return None
+    except IOError:
+        print(f"File {mexfile} could not be opened")
+        return None
+
+def get_processor_name(mexfile):
+    """
+    Extracts processor name from a mex file
+    @param mexfile: mex file to parse for processor name
+    """
+    try:
+        config_tree = ET.parse(mexfile)
+        return config_tree.getroot().find('mex:common/mex:processor',
+            NAMESPACES).text
+    except ET.ParseError:
+        print(f"Malformed XML tree {mexfile}")
+        return None
+    except IOError:
+        print(f"File {mexfile} could not be opened")
+        return None
+
+def get_package_name(mexfile):
+    """
+    Extracts package name from a mex file
+    @param mexfile: mex file to parse for package name
+    """
+    try:
+        config_tree = ET.parse(mexfile)
+        return config_tree.getroot().find('mex:common/mex:package',
+            NAMESPACES).text
+    except ET.ParseError:
+        print(f"Malformed XML tree {mexfile}")
+        return None
+    except IOError:
+        print(f"File {mexfile} could not be opened")
+        return None

mcux/scripts/kinetis_gen_dts.py

@@ -4,12 +4,91 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""
+Wrapper around kinetis_signal2dts.py to provide arguments
+"""
+
 import logging
+import datetime
+import argparse
+import pathlib
+import sys
+import re
+
+import kinetis_cfg_utils
+
+HELPSTR = """
+Processes NXP Kinetis MEX configuration files
+Given a mex file, generates the board level pinctrl groups required for
+Zephyr. 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('mex_file', metavar = 'MEX',
+                    type=str, help='path to source MEX file')
+parser.add_argument('--cfg-tool-root', metavar = 'CFG_TOOL', type=str,
+                    help='Path to root of MCUXpresso processors directory')
+parser.add_argument('--copyright', action='store_true',
+                    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()
+
+board_name = kinetis_cfg_utils.get_board_name(args.mex_file)
+processor_name = kinetis_cfg_utils.get_processor_name(args.mex_file)
+package_name = kinetis_cfg_utils.get_package_name(args.mex_file)
+
+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.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")
+        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)
+
 
-from kinetis_signal2dts import NXPSdkUtil
 
 xml = "signal_configuration.xml"
 
-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')
+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)
+else:
+    util = kinetis_cfg_utils.NXPSdkUtil(args.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}")