572 lines
19 KiB
Python
Executable File
572 lines
19 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
############################################################################
|
|
# tools/stm32_pinmap_tool.py
|
|
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one or more
|
|
# contributor license agreements. See the NOTICE file distributed with
|
|
# this work for additional information regarding copyright ownership. The
|
|
# ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance with the
|
|
# License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
############################################################################
|
|
|
|
# for python2.7 compatibility
|
|
from __future__ import print_function
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import sys
|
|
from argparse import RawTextHelpFormatter
|
|
from glob import glob
|
|
|
|
suffix = "_0"
|
|
remaps_re = re.compile(r"(.*REMAP.*)=y")
|
|
ip_block_re = re.compile(r"CONFIG_STM32[A-Z0-9]*_([A-Z0-9]+[0-9]*)=")
|
|
stm32f1_re = re.compile(r"stm32f10[0-9][a-z]*_pinmap")
|
|
speed_re = re.compile(r"(GPIO_(?:SPEED|MODE)_[zA-Z0-9]+)")
|
|
port_re = re.compile(r"GPIO_PORT([A-Z])\|")
|
|
pin_re = re.compile(r"GPIO_PIN(\d+)")
|
|
define_re = re.compile(r"#\s*define\s+(GPIO.*)\s+(GPIO.*?)\s+")
|
|
|
|
|
|
class GPIODef:
|
|
def __init__(self, original_name, name, description):
|
|
self.original_name = original_name
|
|
self.name = name
|
|
self.block = name.split("_")[1]
|
|
self.speed = None
|
|
s = speed_re.search(description)
|
|
if s:
|
|
self.speed = s.group(1)
|
|
s = port_re.search(description)
|
|
if s:
|
|
self.port = s.group(1)
|
|
s = pin_re.search(description)
|
|
if s:
|
|
self.pin = s.group(1)
|
|
|
|
def __str__(self):
|
|
fmt = "#define {0: <20} {1} /* P{2} */"
|
|
if self.speed:
|
|
if "MODE" in self.speed:
|
|
if "MHz" in self.speed:
|
|
# F1 has mode, MHz is output, we must adjust the speed
|
|
fmt = "#define {0: <20} GPIO_ADJUST_MODE({1}, {3}) /* P{2} */ "
|
|
else:
|
|
# All others had a OSPEDD reg so we just set it
|
|
fmt = "#define {0: <20} ({1} | {3}) /* P{2} */ "
|
|
|
|
return fmt.format(
|
|
self.original_name,
|
|
self.name,
|
|
self.port + self.pin,
|
|
self.speed,
|
|
)
|
|
|
|
def __repr__(self):
|
|
return f"<GPIODef block:{self.block} \
|
|
original_name:{self.original_name} \
|
|
name:{self.name} port:{self.port} \
|
|
pin:{self.pin} speed:{self.speed}>"
|
|
|
|
|
|
# Detect python version
|
|
if sys.version_info[0] < 3:
|
|
runningPython3 = False
|
|
else:
|
|
runningPython3 = True
|
|
|
|
|
|
def parse_args():
|
|
# Parse commandline arguments
|
|
parser = argparse.ArgumentParser(
|
|
formatter_class=RawTextHelpFormatter,
|
|
description="""stm32_pinmap_tool.py
|
|
|
|
This tool is used to migrate legacy stm32 pinmap files that
|
|
had included pin speed (slew rate control) in pinmap pin definitions
|
|
|
|
These speeds should have never been part of the arch defines as these
|
|
are layout and board dependent. Therefore, the complete definition
|
|
should be a composition of the pinmap defines and speed, and defined in
|
|
board.h
|
|
|
|
Furthermore, pinmaps did not suffix pins that had only one ALT
|
|
appearance on a GPIO. Therefore there was no way to change the speed
|
|
or any other pins attribute i.e. Pullup Pulldown, Push pull. Open Drain etc.
|
|
|
|
The tool has a conversion mode and a report mode.
|
|
|
|
Conversion mode tool use:
|
|
|
|
Run the tool to do the conversion:
|
|
i.e tools/stm32_pinmap_tool.py
|
|
--pinmap arch/arm/src/stm32h7/hardware/stm32h7x3xx_pinmap.h
|
|
--legacy > arch/arm/src/stm32h7/hardware/stm32h7x3xx_pinmap-new.h
|
|
|
|
-- pinmap - the file to convert
|
|
--legacy will make a copy of the pinmap. Properly updating the file with
|
|
xxxx/xxxxxxx_legacy to the title block,
|
|
and adding _LEGACY to the #ifdef, #define and endif comment of the inclusion guard.
|
|
|
|
Conversion mode follow up edits:
|
|
1. diff and verify the original pinmap and the pinmap-new.h are as expected.
|
|
delete original pinmap
|
|
rename pinmap-new.h to the original pinmap name.
|
|
2. Edit the top level pinmap (i.e. arch/arm/src/stm32x/stm32x_pinmap.h) file and
|
|
add a CONFIG_STM32xx_USE_LEGACY_PINMAP section
|
|
that includes the legacy pinmap files.
|
|
|
|
For example
|
|
if defined(CONFIG_STM32H7_USE_LEGACY_PINMAP)
|
|
if defined(CONFIG_STM32H7_STM32H7X3XX)
|
|
include "hardware/stm32h7x3xx_pinmap_legacy.h"
|
|
elif defined(CONFIG_STM32H7_STM32H7B3XX)
|
|
include "hardware/stm32h7x3xx_pinmap_legacy.h"
|
|
elif defined(CONFIG_STM32H7_STM32H7X7XX)
|
|
include "hardware/stm32h7x3xx_pinmap_legacy.h"
|
|
else
|
|
error "Unsupported STM32 H7 Pin map"
|
|
endif
|
|
else
|
|
if defined(CONFIG_STM32H7_STM32H7X3XX)
|
|
include "hardware/stm32h7x3xx_pinmap.h"
|
|
elif defined(CONFIG_STM32H7_STM32H7B3XX)
|
|
include "hardware/stm32h7x3xx_pinmap.h"
|
|
elif defined(CONFIG_STM32H7_STM32H7X7XX)
|
|
include "hardware/stm32h7x3xx_pinmap.h"
|
|
else
|
|
error "Unsupported STM32 H7 Pin map"
|
|
endif
|
|
endif
|
|
|
|
3. Add a STM32Hx_USE_LEGACY_PINMAP to the Kconfig defaulted to y
|
|
|
|
For example
|
|
|
|
config STM32H7_USE_LEGACY_PINMAP
|
|
bool "Use the legacy pinmap with GPIO_SPEED_xxx included."
|
|
default y
|
|
---help---
|
|
In the past, pinmap files included GPIO_SPEED_xxxMhz. These speed
|
|
settings should have come from the board.h as it describes the wiring
|
|
of the SoC to the board. The speed is really slew rate control and
|
|
therefore is related to the layout and can only be properly set
|
|
in board.h.
|
|
|
|
STM32H7_USE_LEGACY_PINMAP is provided, to allow lazy migration to
|
|
using pinmaps without speeds. The work required to do this can be aided
|
|
by running tools/stm32_pinmap_tool.py. The tools will take a board.h
|
|
file and a legacy pinmap and output the required changes that one needs
|
|
to make to a board.h file.
|
|
|
|
Eventually, STM32H7_USE_LEGACY_PINMAP will be deprecated and the legacy
|
|
pinmaps removed from NuttX. Any new boards added should set
|
|
STM32H7_USE_LEGACY_PINMAP=n and fully define the pins in board.h
|
|
4. Add a warning to the xxx_gpio.c file
|
|
|
|
For example
|
|
|
|
#if defined(CONFIG_STM32_USE_LEGACY_PINMAP)
|
|
# pragma message "CONFIG_STM32_USE_LEGACY_PINMAP will be deprecated migrate board.h see tools/stm32_pinmap_tool.py"
|
|
#endif
|
|
|
|
Report mode tool use:
|
|
|
|
Run the tool to aid in migrating a board.h
|
|
|
|
tools/stm32_pinmap_tool.py --pinmap arch/arm/src/stm32h7/hardware/stm32h7x3xx_pinmap_legacy.h
|
|
--report <fullpath>/include/board.h
|
|
|
|
it will output 2 sections that should be used to update the board.h.
|
|
board.h defines that need to have speeds added.
|
|
board.h defines that will need to be added:
|
|
""",
|
|
)
|
|
|
|
parser.add_argument(
|
|
"--pinmap",
|
|
action="store",
|
|
help="""pin map file to convert (changes are printed on stdout) or
|
|
Legacy file pin map file named <filename>_legacy.<ext> to report board.h changes""",
|
|
)
|
|
parser.add_argument(
|
|
"--report",
|
|
default=False,
|
|
action="store",
|
|
help="Generate change set for a board",
|
|
)
|
|
parser.add_argument(
|
|
"--legacy",
|
|
default=False,
|
|
action="store_true",
|
|
help="If one does not exist, create a copy of the original pin map named <filename>_legacy.<ext>",
|
|
)
|
|
args = parser.parse_args()
|
|
return args
|
|
|
|
|
|
def create_legacy(source):
|
|
legacy = source.replace(".h", "_legacy.h")
|
|
sourceshort = source[source.find("arch") :]
|
|
legacyshort = legacy[legacy.find("arch") :]
|
|
srctag = "__" + sourceshort.upper().replace("/", "_")
|
|
destag = "__" + legacyshort.upper().replace("/", "_").replace(".", "_")
|
|
if not os.path.isfile(legacy):
|
|
fout = open(legacy, "w")
|
|
fin = open(source, "r")
|
|
|
|
for line in fin:
|
|
out = re.sub(sourceshort, legacyshort, line)
|
|
out = re.sub(srctag, destag, out)
|
|
fout.write(out)
|
|
fout.close()
|
|
fin.close()
|
|
|
|
|
|
def read_defconfigs(boardfile_path):
|
|
configs_lines = []
|
|
defconfigs_files = []
|
|
|
|
for dir, _, _ in os.walk(boardfile_path[: boardfile_path.find("include/board.h")]):
|
|
defconfigs_files.extend(glob(os.path.join(dir, "defconfig")))
|
|
|
|
for file in defconfigs_files:
|
|
defconfigfile = open(file, "r")
|
|
configs_lines.extend(defconfigfile.readlines())
|
|
defconfigfile.close()
|
|
return configs_lines
|
|
|
|
|
|
def build_ip_remap_list(boardfile_path):
|
|
ip_blocks = []
|
|
ip_remaps = []
|
|
configs_lines = read_defconfigs(boardfile_path)
|
|
configs_lines = sorted(set(configs_lines))
|
|
|
|
for line in configs_lines:
|
|
s = ip_block_re.search(line)
|
|
if s:
|
|
ip_blocks.extend([s.group(1)])
|
|
else:
|
|
s = remaps_re.search(line)
|
|
if s:
|
|
ip_remaps.extend([s.group(1)])
|
|
return [ip_blocks, ip_remaps]
|
|
|
|
|
|
def read_board_h(boardfile_path):
|
|
boardfile = open(boardfile_path, "r")
|
|
lines = boardfile.readlines()
|
|
boardfile.close()
|
|
return lines
|
|
|
|
|
|
def formated_print(lines):
|
|
maxlen = 0
|
|
for line in lines:
|
|
linelen = line.find("/*")
|
|
if linelen > maxlen:
|
|
maxlen = linelen
|
|
|
|
for line in lines:
|
|
linelen = line.find("/*")
|
|
if linelen > 1 and linelen < maxlen:
|
|
nl = line[:linelen] + " " * (maxlen - linelen) + line[linelen:]
|
|
line = nl
|
|
print(line)
|
|
|
|
|
|
def report(boardfile_path, boards_ip_blocks, changelog, changelog_like):
|
|
output = [
|
|
"",
|
|
]
|
|
output.extend(
|
|
[
|
|
"""
|
|
There were 3 issues with the Legacy pinmaps.
|
|
|
|
1. The legacy version of the pin defines included speed settings. (These are
|
|
in reality, slew rates).
|
|
|
|
2. Legacy pinmaps erroneously added speeds on pins that are only used
|
|
as an inputs (i.e UART4_RX). These speeds can be removed from the board.h
|
|
defines.
|
|
|
|
3. Also the legacy version of the pin defines did not have a suffix on all
|
|
pins and therefore all pins could not have the attributes set or changed
|
|
by board.h
|
|
|
|
The new pinmaps correct these issues:
|
|
|
|
Pin that had an explicit (GPIO_SPEED|MODE)_xxxMHz are removed or set to
|
|
the lowest speed.
|
|
|
|
If the pin had only one choice previously (un-suffixed) the pin name now
|
|
contains _0 as the suffix.
|
|
|
|
N.B. The correct speed setting for a given pin is very dependent on the
|
|
layout of the circuit board and load presented to the SoC on that pin.
|
|
|
|
The speeds listed below are from the Legacy pinmaps and are provided ONLY
|
|
to insure these changes do not break existing systems that are relying on
|
|
the legacy speed settings.
|
|
|
|
It highly recommended that the speed setting for each pin be verified for
|
|
overshoot and undershoot on real hardware and adjusted in the board,h
|
|
appropriately.
|
|
|
|
|
|
board.h defines that need to have speeds added.
|
|
|
|
"""
|
|
]
|
|
)
|
|
|
|
boards_blocks = []
|
|
Lines = read_board_h(boardfile_path)
|
|
for line in Lines:
|
|
s = define_re.search(line)
|
|
if s:
|
|
# #define GPIO_SD_CK GPIO_SD_CK_1 /* PD6 FC_PD6_SD_CK */
|
|
define = s.group(1)
|
|
original_name = s.group(2)
|
|
change = changelog.get(original_name)
|
|
if change:
|
|
pindef = GPIODef(define, original_name, line)
|
|
if pindef.block not in boards_blocks:
|
|
boards_blocks.append(pindef.block)
|
|
output.extend([f"\n/* {pindef.block} */\n"])
|
|
output.extend([str(changelog[original_name])])
|
|
if len(boards_blocks) == 0:
|
|
output.extend(
|
|
[
|
|
"""
|
|
No pins are defined in board.h to change speeds on (most likely an stm32f1")
|
|
We will define all the pins used next...
|
|
"""
|
|
]
|
|
)
|
|
|
|
formated_print(output)
|
|
output = []
|
|
|
|
output.extend(
|
|
[
|
|
"""
|
|
|
|
Pin that had only one choice previously (un-suffixed) pins will need to be
|
|
defined in board.h to map the un-suffixed) pin name used in the drives to
|
|
the _0 suffixed ones.
|
|
|
|
Pins that did not have an explicit (GPIO_SPEED|MODE)_xxxMHz specified are
|
|
listed with the pin name containing the new suffix.
|
|
|
|
|
|
board.h defines that may need to be added if the pins are used on the board:
|
|
|
|
|
|
"""
|
|
]
|
|
)
|
|
|
|
for block in boards_ip_blocks:
|
|
change = changelog_like.get(block)
|
|
if change:
|
|
block_title = f"\n/* {block} */\n"
|
|
for gpio in change:
|
|
if re.search(r"_\d+$", gpio.original_name) is None:
|
|
if block_title:
|
|
output.extend([block_title])
|
|
block_title = None
|
|
output.extend([str(gpio)])
|
|
|
|
formated_print(output)
|
|
|
|
|
|
def formatcols(list, cols):
|
|
lines = ("\t".join(list[i : i + cols]) for i in range(0, len(list), cols))
|
|
return "\n".join(lines)
|
|
|
|
|
|
def parse_conditional(lines, conditions):
|
|
defines = []
|
|
|
|
def_remap_re = re.compile(r"\s*defined\s*\((.*REMAP.*)\)")
|
|
def_else_re = re.compile(r"#\s*else")
|
|
def_endif_re = re.compile(r"#\s*endif")
|
|
|
|
active_define = None
|
|
output = True
|
|
once = False
|
|
|
|
for line in lines:
|
|
# process #[el]if define(...REMAP)
|
|
s = def_remap_re.search(line)
|
|
if s:
|
|
once = True
|
|
define = s.group(1)
|
|
if define in conditions:
|
|
active_define = define
|
|
output = True
|
|
else:
|
|
output = False
|
|
else:
|
|
# process #endif
|
|
s = def_endif_re.search(line)
|
|
if s:
|
|
active_define = None
|
|
output = True
|
|
else:
|
|
# process #elese
|
|
s = def_else_re.search(line)
|
|
if s:
|
|
once = True
|
|
# the if or elif was taken do not output the else
|
|
if active_define:
|
|
output = False
|
|
else:
|
|
output = output ^ True
|
|
|
|
if once or output:
|
|
once = False
|
|
defines.extend([line])
|
|
return defines
|
|
|
|
|
|
def formmatter(args):
|
|
# if pinmap passed is a legacy pinmap. Just generate a report
|
|
report_only = args.report is not False
|
|
|
|
speed_not_mode = stm32f1_re.search(args.pinmap) is None
|
|
|
|
if not report_only and args.legacy is True:
|
|
create_legacy(args.pinmap)
|
|
|
|
pinfile = open(args.pinmap, "r")
|
|
Lines = pinfile.readlines()
|
|
|
|
if report_only:
|
|
boards_ip_blocks, remaps = build_ip_remap_list(args.report)
|
|
print(
|
|
f"\n\nBoard enabled Blocks:\n\n{formatcols(sorted(boards_ip_blocks), 8)}\n\n"
|
|
)
|
|
if (
|
|
"ADC1" in boards_ip_blocks
|
|
or "ADC2" in boards_ip_blocks
|
|
or "ADC3" in boards_ip_blocks
|
|
):
|
|
boards_ip_blocks.extend(["ADC12"])
|
|
boards_ip_blocks.extend(["ADC123"])
|
|
boards_ip_blocks = sorted(boards_ip_blocks)
|
|
# Filter out ifdefed by remap conditionals (F1)
|
|
if len(remaps) > 0:
|
|
Lines = parse_conditional(Lines, remaps)
|
|
|
|
Pass = False
|
|
inComment = False
|
|
|
|
changelog = {}
|
|
changelog_like = {}
|
|
pass_list = [r"#\s*if", r"#\s*else", r"#\s*end", r"#\s*include", r"#\s*undef"]
|
|
pass_list_re = re.compile("|".join(pass_list))
|
|
|
|
for line in Lines:
|
|
if len(line.strip()) == 0:
|
|
Pass = True
|
|
if pass_list_re.search(line):
|
|
Pass = True
|
|
if "#define" in line and "GPIO" not in line:
|
|
Pass = True
|
|
if "defined(" in line:
|
|
Pass = True
|
|
if "/*" in line:
|
|
inComment = True
|
|
Pass = True
|
|
if "*/" in line:
|
|
inComment = False
|
|
Pass = True
|
|
if Pass or inComment:
|
|
Pass = False
|
|
if not report_only:
|
|
print(line.rstrip(), end="")
|
|
else:
|
|
changed = False
|
|
# split the line on spaces
|
|
pieces = line.split()
|
|
# deal with white space in the # define for nested defines
|
|
sel = 0
|
|
# Does it have white space then use next set?
|
|
if pieces[0] == "#":
|
|
sel = 1
|
|
original_name = pieces[sel + 1]
|
|
gpiocgf = pieces[sel + 2]
|
|
new_name = original_name
|
|
if re.search(r"_\d+$", original_name) is None:
|
|
# Add suffix
|
|
pad = ""
|
|
sel = line.find(original_name) + len(original_name)
|
|
if line[sel + len(suffix)] == "(":
|
|
pad = " "
|
|
if line[sel + len(suffix)] == "G":
|
|
pad = " ("
|
|
nl = line[:sel] + suffix + pad + line[sel + len(suffix) :]
|
|
new_name = original_name + suffix
|
|
changed = True
|
|
else:
|
|
nl = line
|
|
# Remove the speed or chege the Mode
|
|
if speed_not_mode:
|
|
ol = re.sub(r"\s*GPIO_SPEED_[zA-Z0-9]+\s*\|", "", nl)
|
|
else:
|
|
ol = re.sub(
|
|
r"(\s*)GPIO_MODE_[0-9]+MHz(\s*\|)", r"\g<1>GPIO_MODE_2MHz\g<2>", nl
|
|
)
|
|
|
|
changed = changed or ol != nl
|
|
if not report_only:
|
|
print(ol.strip(), end="")
|
|
if args.report and changed:
|
|
changelog[original_name] = pindef = GPIODef(
|
|
original_name, new_name, gpiocgf
|
|
)
|
|
|
|
# create changes by block if enabled
|
|
if pindef.block in boards_ip_blocks:
|
|
# Is block in already?
|
|
if pindef.block in changelog_like:
|
|
# do not duplicate it
|
|
if pindef not in changelog_like[pindef.block]:
|
|
changelog_like[pindef.block].append(pindef)
|
|
else:
|
|
changelog_like[pindef.block] = [pindef]
|
|
|
|
if not report_only:
|
|
print("")
|
|
if args.report:
|
|
report(args.report, boards_ip_blocks, changelog, changelog_like)
|
|
|
|
|
|
def main():
|
|
# Python2 is EOL
|
|
if not runningPython3:
|
|
raise RuntimeError(
|
|
"Python 2 is not supported. Please try again using Python 3."
|
|
)
|
|
args = parse_args()
|
|
formmatter(args)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|