776 lines
27 KiB
Python
776 lines
27 KiB
Python
#!/usr/bin/python
|
|
"""
|
|
SPDX-License-Identifier: Apache-2.0
|
|
Copyright (c) 2019 STMicroelectronics.
|
|
This script define Stm32SerieUpdate class
|
|
to be used by update_stm32_package.py
|
|
"""
|
|
|
|
import os
|
|
import stat
|
|
import shutil
|
|
import subprocess
|
|
import re
|
|
from pathlib import Path
|
|
import logging
|
|
|
|
STM32_CUBE_REPO_BASE = "https://github.com/STMicroelectronics/STM32Cube"
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
|
|
def remove_readonly(func, path, _):
|
|
"""Remove read only protection"""
|
|
os.chmod(path, stat.S_IWRITE)
|
|
func(path)
|
|
|
|
|
|
def os_cmd(cmd, cwd=None, shell=False):
|
|
"""Execute a command with subprocess.check_call()
|
|
Args:
|
|
cmd: string command to execute.
|
|
cwd: directory where to run command
|
|
shell: boolean to enable command interpretation by the shell
|
|
|
|
Returns:
|
|
return the returncode of the command after execution.
|
|
"""
|
|
logging.info(cmd)
|
|
return subprocess.check_call(cmd, shell=shell, cwd=cwd)
|
|
|
|
|
|
class Stm32SerieUpdate:
|
|
"""class Stm32SerieUpdate"""
|
|
|
|
def __init__(self, stm32_serie, stm32cube_repo_path, force, noclean):
|
|
"""Class Stm32SerieUpdate constructor
|
|
|
|
Args:
|
|
stm32_serie: stm32 serie ex:stm32f3xx
|
|
stm32cube_repo_path: directory path where to fetch github repo
|
|
force: boolean to force or not git commit after applying update
|
|
noclean: boolean to clean or not github repo after update done
|
|
|
|
Returns:
|
|
return previous zephyr cube version.
|
|
|
|
Raises:
|
|
ValueError: If stm32 serie is not recognised.
|
|
FileNotFoundError: If Zphyr STM32 cube path is not found
|
|
"""
|
|
if not stm32_serie.startswith("stm32"):
|
|
raise ValueError(
|
|
"Error: Unknown stm32 serie: "
|
|
+ stm32_serie
|
|
+ ". Must start with 'stm32'"
|
|
)
|
|
|
|
# Set serie variables
|
|
self.stm32_serie = stm32_serie
|
|
self.stm32_seriexx = stm32_serie + "xx" # ex:stm32f3xx
|
|
self.stm32_serie_upper = stm32_serie.upper() # ex:STM32F3
|
|
self.stm32_seriexx_upper = self.stm32_serie_upper + "xx" # ex:STM32F3xx
|
|
self.serie = self.stm32_serie_upper[5:]
|
|
self.force = force
|
|
self.noclean = noclean
|
|
|
|
# ##### 3 root directories to work with ########
|
|
# 1: STM32Cube repo Default $HOME/STM32Cube_repo
|
|
# 2 : zephyr stm32 path : ex: .../zephyr_project/module/hal/stm32
|
|
# 3: Temporary directory to construct the update
|
|
# (within STM32Cube repo dir)
|
|
self.stm32cube_repo_path = stm32cube_repo_path
|
|
if not self.stm32cube_repo_path.exists():
|
|
self.stm32cube_repo_path.mkdir()
|
|
|
|
self.zephyr_hal_stm32_path = (
|
|
Path(os.getenv("ZEPHYR_BASE")).absolute()
|
|
/ ".."
|
|
/ "modules"
|
|
/ "hal"
|
|
/ "stm32"
|
|
)
|
|
if not self.zephyr_hal_stm32_path.exists():
|
|
raise FileNotFoundError("Error: cannot find zephyr project")
|
|
|
|
self.stm32cube_temp = self.stm32cube_repo_path / "temp_stm32xx_update"
|
|
if self.stm32cube_temp.exists():
|
|
shutil.rmtree(str(self.stm32cube_temp), onerror=remove_readonly)
|
|
self.stm32cube_temp.mkdir()
|
|
|
|
# subdir specific to a stm32 serie
|
|
self.stm32cube_serie_path = self.stm32cube_repo_path / Path(
|
|
"STM32Cube" + self.serie
|
|
)
|
|
self.zephyr_module_serie_path = (
|
|
self.zephyr_hal_stm32_path / "stm32cube" / self.stm32_seriexx
|
|
)
|
|
self.stm32cube_temp_serie = (
|
|
self.stm32cube_temp / "stm32cube" / self.stm32_seriexx
|
|
)
|
|
shutil.rmtree(str(self.stm32cube_temp), onerror=remove_readonly)
|
|
self.stm32cube_temp_serie.mkdir(parents=True)
|
|
|
|
self.readme_file_path = self.zephyr_module_serie_path / "README"
|
|
self.version_tag = []
|
|
self.current_version = ""
|
|
self.latest_version = ""
|
|
self.latest_commit = ""
|
|
|
|
def clone_cube_repo(self):
|
|
"""Clone or fetch a stm32 serie repo"""
|
|
# check whether master branch exist, otherwise use main branch
|
|
master_branch_exist = subprocess.check_output(
|
|
"git ls-remote --heads origin master", cwd=self.stm32cube_serie_path
|
|
).decode("utf-8")
|
|
if master_branch_exist:
|
|
branch = "master"
|
|
else:
|
|
branch = "main"
|
|
logging.info("Branch used:" + branch)
|
|
|
|
if self.stm32cube_serie_path.exists():
|
|
logging.info("fetching repo " + str(self.stm32cube_serie_path))
|
|
# if already exists, then just clean and fetch
|
|
os_cmd(("git", "clean", "-fdx"), cwd=self.stm32cube_serie_path)
|
|
os_cmd(("git", "fetch"), cwd=self.stm32cube_serie_path)
|
|
os_cmd(
|
|
("git", "reset", "--hard", branch),
|
|
cwd=self.stm32cube_serie_path,
|
|
)
|
|
else:
|
|
os_cmd(
|
|
("git", "clone", STM32_CUBE_REPO_BASE + self.serie + ".git"),
|
|
cwd=self.stm32cube_repo_path,
|
|
)
|
|
|
|
# get the latest version of cube,
|
|
# with the most recent one created being the last entry.
|
|
os_cmd(("git", "checkout", branch), cwd=self.stm32cube_serie_path)
|
|
self.version_tag = subprocess.check_output(
|
|
("git", "tag", "-l"),
|
|
cwd=self.stm32cube_serie_path
|
|
).splitlines()
|
|
self.version_tag = [x.decode("utf-8") for x in self.version_tag]
|
|
# Set latest version
|
|
self.latest_version = self.version_tag[-1]
|
|
|
|
def get_zephyr_current_version(self):
|
|
"""Look for current zephyr hal version
|
|
|
|
Returns:
|
|
return previous zephyr cube version.
|
|
|
|
Raises:
|
|
ValueError: If version is not found.
|
|
"""
|
|
with open(str(self.readme_file_path), "r") as f:
|
|
for line in f:
|
|
# pattern : "version " follow by optional "v",
|
|
# followed by x.y or x.y.z x,y,z may represent several digits
|
|
# ex: 'version v1.8.9', 'version 10.20.25'
|
|
pattern = r".*version v?(\d+\.\d+\.?\d*).*$"
|
|
if re.match(pattern, line):
|
|
previous_version = re.sub(pattern, r"\1", line).rstrip("\n")
|
|
break
|
|
|
|
# Match previous version and list of existing tags
|
|
# which could be vx.y or x.y
|
|
pos_version = [
|
|
i for i, a in enumerate(self.version_tag) if previous_version in a
|
|
]
|
|
if pos_version:
|
|
# return previous zephyr version
|
|
return self.version_tag[pos_version[0]]
|
|
else:
|
|
self.clean_files()
|
|
raise ValueError(
|
|
"Error: cannot find version "
|
|
+ previous_version
|
|
+ " in STM32Cube_repo"
|
|
)
|
|
|
|
def extract_source(self):
|
|
"""Extract sources and includes files from STM32Cube repo
|
|
and copy them in temporary directory
|
|
"""
|
|
# for CMSIS files
|
|
temp_cmsis_soc_path = self.stm32cube_temp_serie / "soc"
|
|
Path.mkdir(temp_cmsis_soc_path, parents=True)
|
|
stm32cube_cmsis_include_path = (
|
|
self.stm32cube_serie_path
|
|
/ "Drivers"
|
|
/ "CMSIS"
|
|
/ "Device"
|
|
/ "ST"
|
|
/ self.stm32_seriexx_upper
|
|
/ "Include"
|
|
)
|
|
os_cmd(
|
|
(
|
|
"cp",
|
|
"-r",
|
|
str(stm32cube_cmsis_include_path),
|
|
str(temp_cmsis_soc_path),
|
|
)
|
|
)
|
|
|
|
stm32cube_cmsis_templates_path = (
|
|
self.stm32cube_serie_path
|
|
/ "Drivers"
|
|
/ "CMSIS"
|
|
/ "Device"
|
|
/ "ST"
|
|
/ self.stm32_seriexx_upper
|
|
/ "Source"
|
|
/ "Templates"
|
|
)
|
|
for repo_file in stm32cube_cmsis_templates_path.iterdir():
|
|
repo_src = stm32cube_cmsis_templates_path / repo_file
|
|
if repo_src.is_file():
|
|
shutil.copy(str(repo_src), str(temp_cmsis_soc_path))
|
|
|
|
# for hal and ll drivers
|
|
temp_drivers_include_path = (
|
|
self.stm32cube_temp_serie / "drivers" / "include"
|
|
)
|
|
temp_drivers_include_path.parent.mkdir(parents=True)
|
|
stm32cube_driver_inc = (
|
|
self.stm32cube_serie_path
|
|
/ "Drivers"
|
|
/ Path(self.stm32_seriexx_upper + "_HAL_Driver")
|
|
/ "Inc"
|
|
)
|
|
os_cmd(
|
|
(
|
|
"cp",
|
|
"-r",
|
|
str(stm32cube_driver_inc),
|
|
str(temp_drivers_include_path),
|
|
)
|
|
)
|
|
|
|
# except for _hal_conf_template.h
|
|
hal_conf_template = [
|
|
f
|
|
for f in temp_drivers_include_path.iterdir()
|
|
if "hal_conf_template.h" in f.name
|
|
][0]
|
|
hal_conf_template_fullpath = (
|
|
temp_drivers_include_path / hal_conf_template
|
|
)
|
|
if hal_conf_template_fullpath.is_file():
|
|
hal_conf_fullpath = Path(
|
|
re.sub("_template", r"", str(hal_conf_template_fullpath))
|
|
)
|
|
if hal_conf_fullpath.exists():
|
|
hal_conf_fullpath.unlink()
|
|
hal_conf_template_fullpath.rename(hal_conf_fullpath)
|
|
|
|
temp_drivers_src_path = self.stm32cube_temp_serie / "drivers" / "src"
|
|
temp_drivers_src_path.mkdir()
|
|
stm32cube_drivers_src_path = (
|
|
self.stm32cube_serie_path
|
|
/ "Drivers"
|
|
/ Path(self.stm32_seriexx_upper + "_HAL_Driver")
|
|
/ "Src"
|
|
)
|
|
os_cmd(
|
|
(
|
|
"cp " +
|
|
"-r " +
|
|
str(stm32cube_drivers_src_path) + "/*.* " +
|
|
str(temp_drivers_src_path)
|
|
),
|
|
shell=True,
|
|
)
|
|
|
|
def build_from_current_cube_version(self):
|
|
"""Build a commit in temporary dir with STM32Cube version
|
|
corresponding to zephyr current hal version
|
|
"""
|
|
# reset the STM32Cube repo to this current version
|
|
os_cmd(
|
|
("git", "reset", "--hard", self.current_version),
|
|
cwd=self.stm32cube_serie_path,
|
|
)
|
|
|
|
# build the zephyr module from the stm32cube
|
|
self.extract_source()
|
|
logging.info(
|
|
"Building module from STM32Cube_repo " + self.current_version
|
|
)
|
|
|
|
if not self.stm32cube_temp_serie.parent.exists():
|
|
self.stm32cube_temp_serie.parent.mkdir(parents=True)
|
|
|
|
os_cmd(
|
|
("git", "add", "-A", "stm32cube/" + self.stm32_seriexx + "/*"),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
os_cmd(
|
|
("git", "commit", "-am", '"module' + self.current_version + '"'),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
|
|
def build_patch_from_current_zephyr_version(self):
|
|
"""Build patch between zephyr current hal version and
|
|
corresponding official STM32Cube version
|
|
"""
|
|
# clean-up the module
|
|
shutil.rmtree(str(self.stm32cube_temp_serie), onerror=remove_readonly)
|
|
|
|
# populate the new repo with this current zephyr module
|
|
os_cmd(
|
|
(
|
|
"cp",
|
|
"-rf",
|
|
str(self.zephyr_module_serie_path),
|
|
str(self.stm32cube_temp_serie),
|
|
)
|
|
)
|
|
|
|
# commit this current version module
|
|
os_cmd(("git", "add", "*"), cwd=self.stm32cube_temp)
|
|
os_cmd(("git", "commit", "-am", '"module"'), cwd=self.stm32cube_temp)
|
|
|
|
# Remove trailing space
|
|
os_cmd(
|
|
("git", "rebase", "--whitespace=fix", "HEAD~1"),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
|
|
# generate a patch for files and _hal.conf.h file in the module
|
|
logging.info(
|
|
"Building patch from " + self.current_version + " to current module"
|
|
)
|
|
os_cmd(
|
|
"git diff --ignore-space-at-eol HEAD~1 >> module.patch",
|
|
shell=True,
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
os_cmd(("dos2unix", "module.patch"), cwd=self.stm32cube_temp)
|
|
|
|
hal_conf = (
|
|
self.stm32cube_temp_serie
|
|
/ "drivers"
|
|
/ "include"
|
|
/ Path(self.stm32_seriexx + "_hal_conf.h")
|
|
)
|
|
hal_conf_patch = self.stm32cube_temp / "hal_conf.patch"
|
|
if hal_conf.exists():
|
|
os_cmd(
|
|
(
|
|
"git " +
|
|
"diff " +
|
|
"HEAD@{1} " +
|
|
"-- " +
|
|
str(hal_conf) +
|
|
" >> " +
|
|
str(hal_conf_patch)
|
|
),
|
|
shell=True,
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
if hal_conf_patch.stat().st_size == 0:
|
|
hal_conf_patch.unlink()
|
|
else:
|
|
os_cmd(("dos2unix", str(hal_conf_patch)))
|
|
|
|
def update_readme(self, make_version, make_commit):
|
|
"""Update README file
|
|
|
|
Args:
|
|
make_version: latest STM32Cube version.
|
|
make_commit: Commit corresponding to latest STM32Cube version.
|
|
"""
|
|
see_release_note = True
|
|
|
|
readme_path = self.stm32cube_temp_serie / "README"
|
|
|
|
with readme_path.open(mode="r") as readme_prev:
|
|
lines = (x for x in readme_prev.read().splitlines())
|
|
|
|
readme_path.unlink()
|
|
|
|
# Write README from previous one if exists
|
|
with open(str(readme_path), "w") as readme_file:
|
|
for LineItem in lines:
|
|
# change version nb
|
|
if "status" in LineItem.lower():
|
|
readme_file.write("Status:\n")
|
|
readme_file.write(" version {0}\n".format(make_version))
|
|
next(lines) # skip next line
|
|
elif "commit" in LineItem.lower():
|
|
readme_file.write("Commit:\n")
|
|
readme_file.write(" {0}".format(make_commit))
|
|
next(lines) # skip next line
|
|
elif "URL" in LineItem.upper():
|
|
readme_file.write("URL:\n")
|
|
readme_file.write(
|
|
" https://github.com/STMicroelectronics/"
|
|
+ "STM32Cube{0}\n".format(self.serie)
|
|
)
|
|
next(lines) # skip next line
|
|
# change patch list with a link to the release_note.html
|
|
elif "Patch List" in LineItem:
|
|
readme_file.write("Patch List:\n")
|
|
readme_file.write(
|
|
"--> please check that the following list "
|
|
+ "is still valid:\n"
|
|
)
|
|
else:
|
|
if "See release_note.html from STM32Cube" in LineItem:
|
|
see_release_note = False
|
|
readme_file.write("{0}\n".format(LineItem))
|
|
|
|
# at the very end of the file :
|
|
if see_release_note:
|
|
readme_file.write("\n See release_note.html from STM32Cube\n")
|
|
readme_file.flush()
|
|
|
|
os_cmd(("dos2unix", str(readme_path)))
|
|
|
|
def copy_release_note(self):
|
|
"""Copy release_note.html file from STM32Cube to zephyr"""
|
|
release_note_src = self.stm32cube_serie_path / "Release_Notes.html"
|
|
release_note_dst = self.zephyr_module_serie_path / "release_note.html"
|
|
if release_note_dst.exists():
|
|
release_note_dst.unlink()
|
|
if release_note_src.exists:
|
|
release_note_src.rename(release_note_dst)
|
|
os_cmd(("dos2unix", str(release_note_dst)))
|
|
|
|
def update_cmakelist(self):
|
|
"""Update CMakeLists.txt file"""
|
|
cmakelists_path = self.stm32cube_temp_serie / "CMakeLists.txt"
|
|
if cmakelists_path.exists():
|
|
# build new CMakeLists.txt
|
|
with cmakelists_path.open("r") as cmakelists_old:
|
|
# this line is the copyright line
|
|
first_line = cmakelists_old.readline()
|
|
cmakelists_path.unlink()
|
|
else:
|
|
first_line = ""
|
|
|
|
logging.info("Create a new CMakeLists.txt file")
|
|
|
|
with cmakelists_path.open("w") as cmakelists_new:
|
|
if first_line:
|
|
cmakelists_new.write(first_line)
|
|
cmakelists_new.write("# Copyright (c) 2020 STMicroelectronics\n")
|
|
cmakelists_new.write("#\n")
|
|
cmakelists_new.write("# SPDX-License-Identifier: Apache-2.0\n")
|
|
cmakelists_new.write("\n")
|
|
|
|
src_path = self.stm32cube_temp_serie / "drivers" / "src"
|
|
source_files = list(src_path.iterdir())
|
|
source_files.sort()
|
|
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources(soc/system_"
|
|
+ self.stm32_seriexx
|
|
+ ".c)\n"
|
|
)
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources(drivers/src/"
|
|
+ self.stm32_seriexx
|
|
+ "_hal.c)\n"
|
|
)
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources(drivers/src/"
|
|
+ self.stm32_seriexx
|
|
+ "_hal_rcc.c)\n"
|
|
)
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources(drivers/src/"
|
|
+ self.stm32_seriexx
|
|
+ "_hal_rcc_ex.c)\n"
|
|
)
|
|
|
|
for filename in source_files:
|
|
# also skipping '_xxx_hal.c'
|
|
if "template" in filename.name:
|
|
continue
|
|
|
|
# also skipping '_xxx_hal_rcc.c' and '_xxx_hal_rcc_ex.c'
|
|
if "_hal_rcc" in filename.name:
|
|
continue
|
|
|
|
if "_hal_" in filename.name:
|
|
# retrieve IP name from filename, like adc,
|
|
# which is delimited by
|
|
# * _hal_ on one side
|
|
# * and file extension on the other side
|
|
pattern = r".*_hal_(.*)\..*"
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources_ifdef(CONFIG_USE_STM32_HAL_"
|
|
+ re.sub(pattern, r"\1", filename.name).upper()
|
|
+ " drivers/src/"
|
|
+ filename.name
|
|
+ ")\n"
|
|
)
|
|
if "_ll_" in filename.name:
|
|
# retrieve IP name from filename, like adc,
|
|
# which is delimited by
|
|
# * _ll_ on one side
|
|
# * and file extension on the other side
|
|
pattern = r".*_ll_(.*)\..*"
|
|
cmakelists_new.write(
|
|
"zephyr_library_sources_ifdef(CONFIG_USE_STM32_LL_"
|
|
+ re.sub(pattern, r"\1", filename.name).upper()
|
|
+ " drivers/src/"
|
|
+ filename.name
|
|
+ ")\n"
|
|
)
|
|
os_cmd(("dos2unix", str(cmakelists_path)))
|
|
|
|
def build_from_latest_version(self):
|
|
"""Build a commit in temporary dir with STM32Cube version
|
|
corresponding to zephyr latest hal version
|
|
"""
|
|
# reset the STM32Cube repo to this latest version
|
|
os_cmd(
|
|
("git", "reset", "--hard", self.latest_version),
|
|
cwd=self.stm32cube_serie_path,
|
|
)
|
|
|
|
# Get the commit id of this latest version
|
|
self.latest_commit = subprocess.check_output(
|
|
("git", "rev-parse", "HEAD"),
|
|
cwd=self.stm32cube_serie_path
|
|
).decode("utf-8")
|
|
|
|
# clear previous version content before populating with latest version
|
|
shutil.rmtree(str(self.stm32cube_temp_serie), onerror=remove_readonly)
|
|
|
|
# populate temporary directory with latest version
|
|
self.extract_source()
|
|
|
|
# include README and CMakelists files from current zephyr module
|
|
shutil.copy(
|
|
str(self.readme_file_path),
|
|
str(self.stm32cube_temp_serie / "README"),
|
|
)
|
|
shutil.copy(
|
|
str(self.zephyr_module_serie_path / "CMakeLists.txt"),
|
|
str(self.stm32cube_temp_serie / "CMakeLists.txt"),
|
|
)
|
|
|
|
# Commit files except log or patch files
|
|
os_cmd(("git", "add", "*"), cwd=self.stm32cube_serie_path)
|
|
os_cmd(("git", "reset", "--", "*.patch"), cwd=self.stm32cube_serie_path)
|
|
os_cmd(("git", "reset", "--", "*.log"), cwd=self.stm32cube_serie_path)
|
|
os_cmd(
|
|
("git", "commit", "-am", '"module' + self.latest_version + '"'),
|
|
cwd=self.stm32cube_temp_serie,
|
|
)
|
|
|
|
def apply_zephyr_patch(self):
|
|
"""Apply zephyr stm32 patch to latest stm32Cube version"""
|
|
logging.info("Apply zephyr patches to " + self.latest_version)
|
|
|
|
# Update README and CMakeList, copy release note
|
|
self.update_readme(self.latest_version, self.latest_commit)
|
|
self.update_cmakelist()
|
|
self.copy_release_note()
|
|
|
|
# Apply previous patch on hal_conf.h file
|
|
if os.path.exists("hal_conf.patch"):
|
|
os_cmd(
|
|
("git", "apply", "--recount", "--3way", "./hal_conf.patch"),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
os.remove("hal_conf.patch")
|
|
|
|
# Commit files except log or patch files
|
|
os_cmd(("git", "add", "*"), cwd=self.stm32cube_temp)
|
|
os_cmd(("git", "reset", "--", "*.patch"), cwd=self.stm32cube_temp)
|
|
os_cmd(("git", "reset", "--", "*.log"), cwd=self.stm32cube_temp)
|
|
os_cmd(
|
|
("git", "commit", "-am", '"module' + self.latest_version + '"'),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
|
|
# Remove trailing spaces
|
|
os_cmd(
|
|
("git", "rebase", "--whitespace=fix", "HEAD~1"),
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
|
|
# Generate a patch for each file in the module
|
|
|
|
os_cmd(
|
|
"git diff HEAD~1 >> new_version.patch",
|
|
shell=True,
|
|
cwd=self.stm32cube_temp,
|
|
)
|
|
|
|
os_cmd(("dos2unix", "new_version.patch"), cwd=self.stm32cube_temp)
|
|
|
|
# Copy from stm32cube_temp
|
|
shutil.rmtree(
|
|
str(self.zephyr_hal_stm32_path / "stm32cube" / self.stm32_seriexx),
|
|
onerror=remove_readonly,
|
|
)
|
|
os_cmd(
|
|
(
|
|
"cp",
|
|
"-r",
|
|
str(self.stm32cube_temp_serie),
|
|
str(
|
|
self.zephyr_hal_stm32_path
|
|
/ "stm32cube"
|
|
/ self.stm32_seriexx
|
|
),
|
|
)
|
|
)
|
|
|
|
# Apply patch from new repo
|
|
module_log_path = self.zephyr_hal_stm32_path / Path(
|
|
"module_" + self.stm32_serie + ".log"
|
|
)
|
|
|
|
cmd = (
|
|
"git",
|
|
"apply",
|
|
"--recount",
|
|
"--reject",
|
|
str(self.stm32cube_temp / "module.patch"),
|
|
)
|
|
with open(module_log_path, "w") as output_log:
|
|
if subprocess.call(
|
|
cmd, stderr=output_log, cwd=self.zephyr_hal_stm32_path
|
|
):
|
|
logging.error(
|
|
"Error when applying patch to zephyr module: see "
|
|
+ str(module_log_path)
|
|
)
|
|
|
|
# Add files but do not commit
|
|
os_cmd(("git", "add", "*"), cwd=self.zephyr_hal_stm32_path)
|
|
os_cmd(
|
|
("git", "reset", "--", "*.patch"), cwd=self.zephyr_hal_stm32_path
|
|
)
|
|
os_cmd(("git", "reset", "--", "*.log"), cwd=self.zephyr_hal_stm32_path)
|
|
os_cmd(("git", "reset", "--", "*.rej"), cwd=self.zephyr_hal_stm32_path)
|
|
logging.info(
|
|
"README file : --> please check that the Patch list "
|
|
+ "is still valid"
|
|
)
|
|
|
|
def merge_commit(self):
|
|
"""Apply zephyr stm32 patch to latest stm32Cube version"""
|
|
# Merge & commit if needed
|
|
if self.force:
|
|
logging.info("Force commit module ")
|
|
# to clean the .rej files, uncomment line: reject()
|
|
# reject()
|
|
|
|
commit_file_path = self.zephyr_module_serie_path / "commit.msg"
|
|
with open(commit_file_path, "w") as commit:
|
|
commit.write(
|
|
"stm32cube: update "
|
|
+ self.stm32_serie
|
|
+ " to version "
|
|
+ self.latest_version.upper()
|
|
+ "\n"
|
|
)
|
|
|
|
commit.write("\n")
|
|
commit.write(
|
|
"Update Cube version for "
|
|
+ self.stm32_seriexx_upper
|
|
+ " series"
|
|
+ "\n"
|
|
)
|
|
commit.write("on https://github.com/STMicroelectronics" + "\n")
|
|
commit.write("from version " + self.current_version + "\n")
|
|
commit.write("to version " + self.latest_version + "\n")
|
|
os_cmd(
|
|
("git", "commit", "-as", "-F", commit_file_path),
|
|
cwd=self.zephyr_module_serie_path,
|
|
)
|
|
os_cmd(
|
|
("git", "rebase", "--whitespace=fix", "HEAD~1"),
|
|
cwd=self.zephyr_module_serie_path,
|
|
)
|
|
Path(commit_file_path).unlink()
|
|
|
|
def reject(self):
|
|
"""Clean *.rej files"""
|
|
reject_files = [
|
|
f for f in self.zephyr_module_serie_path.glob("**/*.rej")
|
|
]
|
|
if reject_files:
|
|
for f in reject_files:
|
|
f.unlink()
|
|
|
|
def cleanup_stm32cube_repo(self):
|
|
"""clean the STM32Cube repo"""
|
|
os_cmd(
|
|
("git", "reset", "--hard", "HEAD"), cwd=self.stm32cube_serie_path
|
|
)
|
|
|
|
def clean_files(self):
|
|
"""Clean repo file if required"""
|
|
# Remove temporary files unconditionally
|
|
os.chdir(os.getenv("HOME"))
|
|
shutil.rmtree(str(self.stm32cube_temp), onerror=remove_readonly)
|
|
|
|
# remove STM32Cube repo only if required
|
|
if not self.noclean:
|
|
self.cleanup_stm32cube_repo()
|
|
shutil.rmtree(
|
|
str(self.stm32cube_repo_path), onerror=remove_readonly
|
|
)
|
|
else:
|
|
os_cmd(
|
|
("git", "reset", "--hard", "HEAD"),
|
|
cwd=self.stm32cube_serie_path,
|
|
)
|
|
|
|
def update_stm32_hal_serie(self):
|
|
"""Update one single STM32Cube"""
|
|
# 1) clone full repo from github : get the repo STM32CubeXX
|
|
self.clone_cube_repo()
|
|
|
|
# 2) prepare a repo where to store module versions
|
|
os_cmd(("git", "init"), cwd=self.stm32cube_temp)
|
|
|
|
# 3) get the version of cube which is in the zephyr module
|
|
self.current_version = self.get_zephyr_current_version()
|
|
logging.info(
|
|
"Version "
|
|
+ self.current_version
|
|
+ " is the original version for "
|
|
+ self.zephyr_module_serie_path.name
|
|
)
|
|
|
|
# do not process if versions are similar
|
|
if (self.current_version in self.latest_version) or (
|
|
self.latest_version in self.current_version
|
|
):
|
|
logging.warning("Versions are identical: abandoned")
|
|
self.clean_files()
|
|
return
|
|
|
|
# 4) build the module from this previous version
|
|
self.build_from_current_cube_version()
|
|
|
|
# 5) build the module from the current version
|
|
self.build_patch_from_current_zephyr_version()
|
|
|
|
# 6) build the module from this latest version
|
|
self.build_from_latest_version()
|
|
|
|
# 7) apply zephyr patch : in the zephyr module repo
|
|
self.apply_zephyr_patch()
|
|
|
|
# 8) merge and commit if needed
|
|
self.merge_commit()
|
|
|
|
# 9) clean
|
|
self.clean_files()
|
|
logging.info("Done " + self.stm32_serie)
|