OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/tools/stm32_pinmap_tool.py

574 lines
19 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python3
############################################################################
# tools/stm32_pinmap_tool.py
#
# SPDX-License-Identifier: Apache-2.0
#
# 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()
Reference in New Issue View Git Blame Copy Permalink