mirror of https://github.com/thesofproject/sof.git
1090 lines
40 KiB
Python
Executable File
1090 lines
40 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
# Too much noise for now, these can be re-enabled after they've been
|
|
# fixed (if that does not break `git blame` too much)
|
|
|
|
# W0311, W0312, W0603
|
|
# pylint:disable=bad-indentation
|
|
# pylint:disable=mixed-indentation
|
|
# pylint:disable=global-statement
|
|
|
|
# C0103, C0114, C0116
|
|
# pylint:disable=invalid-name
|
|
# pylint:disable=missing-module-docstring
|
|
# pylint:disable=missing-function-docstring
|
|
|
|
# Non-indentation whitespace has been removed from newer pylint. It does
|
|
# not hurt to keep them for older versions. The recommendation is to use
|
|
# a formatter like `black` instead, unfortunately this would totally
|
|
# destroy git blame, git revert, etc.
|
|
|
|
# C0326, C0330
|
|
# pylint:disable=bad-whitespace
|
|
# pylint:disable=bad-continuation
|
|
|
|
import argparse
|
|
import shlex
|
|
import subprocess
|
|
import pathlib
|
|
import errno
|
|
import platform as py_platform
|
|
import sys
|
|
import shutil
|
|
import os
|
|
import warnings
|
|
import fnmatch
|
|
import hashlib
|
|
import json
|
|
import gzip
|
|
import dataclasses
|
|
import concurrent.futures as concurrent
|
|
|
|
from west import configuration as west_config
|
|
|
|
# anytree module is defined in Zephyr build requirements
|
|
from anytree import AnyNode, RenderTree, render
|
|
from packaging import version
|
|
|
|
# https://chrisyeh96.github.io/2017/08/08/definitive-guide-python-imports.html#case-3-importing-from-parent-directory
|
|
sys.path.insert(1, os.path.join(sys.path[0], '..'))
|
|
from tools.sof_ri_info import sof_ri_info
|
|
|
|
MIN_PYTHON_VERSION = 3, 8
|
|
assert sys.version_info >= MIN_PYTHON_VERSION, \
|
|
f"Python {MIN_PYTHON_VERSION} or above is required."
|
|
|
|
# Version of this script matching Major.Minor.Patch style.
|
|
VERSION = version.Version("2.0.0")
|
|
|
|
# Constant value resolves SOF_TOP directory as: "this script directory/.."
|
|
SOF_TOP = pathlib.Path(__file__).parents[1].resolve()
|
|
west_top = pathlib.Path(SOF_TOP, "..").resolve()
|
|
|
|
sof_fw_version = None
|
|
|
|
if py_platform.system() == "Windows":
|
|
xtensa_tools_version_postfix = "-win32"
|
|
elif py_platform.system() == "Linux":
|
|
xtensa_tools_version_postfix = "-linux"
|
|
else:
|
|
xtensa_tools_version_postfix = "-unsupportedOS"
|
|
warnings.warn(f"Your operating system: {py_platform.system()} is not supported")
|
|
|
|
|
|
@dataclasses.dataclass
|
|
# pylint:disable=too-many-instance-attributes
|
|
class PlatformConfig:
|
|
"Product parameters"
|
|
vendor: str
|
|
PLAT_CONFIG: str
|
|
XTENSA_TOOLS_VERSION: str
|
|
XTENSA_CORE: str
|
|
DEFAULT_TOOLCHAIN_VARIANT: str = "xt-clang"
|
|
RIMAGE_KEY: pathlib.Path = pathlib.Path(SOF_TOP, "keys", "otc_private_key_3k.pem")
|
|
aliases: list = dataclasses.field(default_factory=list)
|
|
ipc4: bool = False
|
|
|
|
# These can all be built out of the box. --all builds all these.
|
|
# Some of these values are duplicated in sof/scripts/set_xtensa_param.sh: keep them in sync.
|
|
platform_configs_all = {
|
|
# Intel platforms
|
|
"tgl" : PlatformConfig(
|
|
"intel", "intel_adsp_cavs25",
|
|
f"RG-2017.8{xtensa_tools_version_postfix}",
|
|
"cavs2x_LX6HiFi3_2017_8",
|
|
"xcc",
|
|
aliases = ['adl', 'adl-n', 'ehl', 'rpl'],
|
|
ipc4 = True
|
|
),
|
|
"tgl-h" : PlatformConfig(
|
|
"intel", "intel_adsp_cavs25_tgph",
|
|
f"RG-2017.8{xtensa_tools_version_postfix}",
|
|
"cavs2x_LX6HiFi3_2017_8",
|
|
"xcc",
|
|
aliases = ['adl-s', 'rpl-s'],
|
|
ipc4 = True
|
|
),
|
|
"mtl" : PlatformConfig(
|
|
"intel", "intel_adsp_ace15_mtpm",
|
|
f"RI-2022.10{xtensa_tools_version_postfix}",
|
|
"ace10_LX7HiFi4_2022_10",
|
|
aliases = ['arl', 'arl-s'],
|
|
ipc4 = True
|
|
),
|
|
"lnl" : PlatformConfig(
|
|
"intel", "intel_adsp_ace20_lnl",
|
|
f"RI-2022.10{xtensa_tools_version_postfix}",
|
|
"ace10_LX7HiFi4_2022_10",
|
|
ipc4 = True
|
|
),
|
|
|
|
# NXP platforms
|
|
"imx8" : PlatformConfig(
|
|
"imx", "nxp_adsp_imx8",
|
|
f"RI-2023.11{xtensa_tools_version_postfix}",
|
|
"hifi4_nxp_v5_3_1_prod",
|
|
RIMAGE_KEY = "key param ignored by imx8",
|
|
),
|
|
"imx8x" : PlatformConfig(
|
|
"imx", "nxp_adsp_imx8x",
|
|
f"RI-2023.11{xtensa_tools_version_postfix}",
|
|
"hifi4_nxp_v5_3_1_prod",
|
|
RIMAGE_KEY = "key param ignored by imx8x"
|
|
),
|
|
"imx8m" : PlatformConfig(
|
|
"imx", "nxp_adsp_imx8m",
|
|
f"RI-2023.11{xtensa_tools_version_postfix}",
|
|
"hifi4_mscale_v2_0_2_prod",
|
|
RIMAGE_KEY = "key param ignored by imx8m"
|
|
),
|
|
"imx8ulp" : PlatformConfig(
|
|
"imx", "nxp_adsp_imx8ulp",
|
|
f"RI-2023.11{xtensa_tools_version_postfix}",
|
|
"hifi4_nxp2_s7_v2_1a_prod",
|
|
RIMAGE_KEY = "key param ignored by imx8ulp"
|
|
),
|
|
}
|
|
|
|
# These cannot be built out of the box yet
|
|
extra_platform_configs = {
|
|
}
|
|
|
|
platform_configs = platform_configs_all.copy()
|
|
platform_configs.update(extra_platform_configs)
|
|
|
|
class validate_platforms_arguments(argparse.Action):
|
|
"""Validates positional platform arguments whether provided platform name is supported."""
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
if values:
|
|
for value in values:
|
|
if value not in platform_configs:
|
|
raise argparse.ArgumentError(self, f"Unsupported platform: {value}")
|
|
setattr(namespace, "platforms", values)
|
|
|
|
args = None
|
|
def parse_args():
|
|
global args
|
|
global west_top
|
|
parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter,
|
|
epilog=("This script supports XtensaTools but only when installed in a specific\n" +
|
|
"directory structure, example:\n" +
|
|
"myXtensa/\n" +
|
|
"└── install/\n" +
|
|
" ├── builds/\n" +
|
|
" │ ├── RD-2012.5{}/\n".format(xtensa_tools_version_postfix) +
|
|
" │ │ └── Intel_HiFiEP/\n" +
|
|
" │ └── RG-2017.8{}/\n".format(xtensa_tools_version_postfix) +
|
|
" │ ├── LX4_langwell_audio_17_8/\n" +
|
|
" │ └── X4H3I16w2D48w3a_2017_8/\n" +
|
|
" └── tools/\n" +
|
|
" ├── RD-2012.5{}/\n".format(xtensa_tools_version_postfix) +
|
|
" │ └── XtensaTools/\n" +
|
|
" └── RG-2017.8{}/\n".format(xtensa_tools_version_postfix) +
|
|
" └── XtensaTools/\n" +
|
|
"$XTENSA_TOOLS_ROOT=/path/to/myXtensa ...\n" +
|
|
|
|
f"\nSupported platforms: {list(platform_configs)}"), add_help=False)
|
|
|
|
parser.add_argument('-h', '--help', action='store_true', help='show help')
|
|
parser.add_argument("-a", "--all", required=False, action="store_true",
|
|
help="Build all currently supported platforms")
|
|
parser.add_argument("platforms", nargs="*", action=validate_platforms_arguments,
|
|
help="List of platforms to build")
|
|
parser.add_argument("-d", "--debug", required=False, action="store_true",
|
|
help="Shortcut for: -o sof/app/debug_overlay.conf")
|
|
# NO SOF release will ever user the option --fw-naming.
|
|
# This option is only for disguising SOF IPC4 as CAVS IPC4 and only in cases where
|
|
# the kernel 'ipc_type' expects CAVS IPC4. In this way, developers and CI can test
|
|
# IPC4 on older platforms.
|
|
parser.add_argument("--fw-naming", required=False, choices=["AVS", "SOF"],
|
|
default="SOF",
|
|
help="""Determine firmware naming conversion and folder structure.
|
|
See also the newer and better '--deployable-build' for IPC4.
|
|
With "SOF" (default):
|
|
|
|
build-sof-staging (for /lib/firmware/intel/sof/)
|
|
├───community
|
|
│ └── sof-tgl.ri
|
|
├── dbgkey
|
|
│ └── sof-tgl.ri
|
|
├── sof-tgl.ri
|
|
└── sof-tgl.ldc
|
|
|
|
With "AVS"; filename 'dsp_basefw.bin'.
|
|
'AVS' automatically enables --use-platform-subdir which uses one subdirectory for each platform:
|
|
|
|
build-sof-staging (for old, developer /lib/firmware/intel/sof-ipc4/)
|
|
└── tgl
|
|
├── community
|
|
│ └── dsp_basefw.bin
|
|
├── dbgkey
|
|
│ └── dsp_basefw.bin
|
|
├── dsp_basefw.bin
|
|
└── sof-tgl.ldc
|
|
|
|
""")
|
|
parser.add_argument("-j", "--jobs", required=False, type=int,
|
|
help="Number of concurrent jobs. Passed to west build and"
|
|
" to cmake (for rimage)")
|
|
parser.add_argument("-k", "--key", type=pathlib.Path, required=False,
|
|
help="Path to a non-default rimage signing key.")
|
|
parser.add_argument("-o", "--overlay", type=pathlib.Path, required=False, action='append',
|
|
default=[], help="Paths to overlays")
|
|
parser.add_argument("-p", "--pristine", required=False, action="store_true",
|
|
help="Perform pristine build removing build directory.")
|
|
parser.add_argument("-u", "--update", required=False, action="store_true",
|
|
help="""Runs west update command - clones SOF dependencies. Downloads next to this sof clone a new Zephyr
|
|
project with its required dependencies. Creates a modules/audio/sof symbolic link pointing
|
|
back at this sof clone. All projects are checkout out to
|
|
revision defined in manifests of SOF and Zephyr.""")
|
|
parser.add_argument('-v', '--verbose', default=0, action='count',
|
|
help="""Verbosity level. Repetition of the flag increases verbosity.
|
|
The same number of '-v' is passed to "west".
|
|
""",
|
|
)
|
|
# Cannot use a standard -- delimiter because argparse deletes it.
|
|
parser.add_argument("-C", "--cmake-args", action='append', default=[],
|
|
help="""Cmake arguments passed as is to cmake configure step.
|
|
Can be passed multiple times; whitespace is preserved Example:
|
|
|
|
-C=--warn-uninitialized -C '-DEXTRA_FLAGS=-Werror -g0'
|
|
|
|
Note '-C --warn-uninitialized' is not supported by argparse, an equal
|
|
sign must be used (https://bugs.python.org/issue9334)""",
|
|
)
|
|
|
|
parser.add_argument("--key-type-subdir", default="community",
|
|
choices=["community", "none", "dbgkey"],
|
|
help="""Output subdirectory for rimage signing key type.
|
|
Default key type subdirectory is \"community\".""")
|
|
|
|
|
|
parser.add_argument("--use-platform-subdir", default = False,
|
|
action="store_true",
|
|
help="""Use an output subdirectory for each platform.
|
|
Otherwise, all firmware files are installed in the same staging directory by default.""")
|
|
|
|
parser.add_argument("--no-interactive", default=False, action="store_true",
|
|
help="""Run script in non-interactive mode when user input can not be provided.
|
|
This should be used with programmatic script invocations (eg. Continuous Integration).
|
|
""")
|
|
|
|
deploy_args = parser.add_mutually_exclusive_group()
|
|
# argparse.BooleanOptionalAction requires Python 3.9
|
|
parser.set_defaults(deployable_build=False)
|
|
deploy_args.add_argument("--no-deployable-build", dest='deployable_build', action='store_false')
|
|
deploy_args.add_argument("--deployable-build", dest='deployable_build', action='store_true',
|
|
help="""Create a directory structure for the firmware files which can be deployed on target as it is.
|
|
This option will cause the --fw-naming and --use-platform-subdir options to be ignored!
|
|
The generic, default directory and file structure is IPC version dependent:
|
|
IPC3
|
|
build-sof-staging/sof/VENDOR/sof/ (on target: /lib/firmware/VENDOR/sof/)
|
|
├── community
|
|
│ └── sof-PLAT.ri
|
|
├── dbgkey
|
|
│ └── sof-PLAT.ri
|
|
└── sof-PLAT.ri
|
|
IPC4
|
|
build-sof-staging/sof/VENDOR/sof-ipc4/ (on target: /lib/firmware/VENDOR/sof-ipc4/)
|
|
└── PLAT
|
|
├── community
|
|
│ └── sof-PLAT.ri
|
|
├── dbgkey
|
|
│ └── sof-PLAT.ri
|
|
└── sof-PLAT.ri\n
|
|
""")
|
|
|
|
parser.add_argument("--version", required=False, action="store_true",
|
|
help="Prints version of this script.")
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.all:
|
|
args.platforms = list(platform_configs_all)
|
|
|
|
# print help message if no arguments provided
|
|
if len(sys.argv) == 1 or args.help:
|
|
for platform in platform_configs:
|
|
if platform_configs[platform].aliases:
|
|
parser.epilog += "\nPlatform aliases for '" + platform + "':\t"
|
|
parser.epilog += f"{list(platform_configs[platform].aliases)}"
|
|
|
|
parser.print_help()
|
|
sys.exit(0)
|
|
|
|
if args.deployable_build:
|
|
if args.fw_naming == 'AVS' or args.use_platform_subdir:
|
|
sys.exit("Options '--fw-naming=AVS' and '--use-platform-subdir'"
|
|
" are incompatible with deployable builds, try --no-deployable-build?")
|
|
|
|
if args.fw_naming == 'AVS':
|
|
if not args.use_platform_subdir:
|
|
args.use_platform_subdir=True
|
|
warnings.warn("The option '--fw-naming AVS' has to be used with '--use-platform-subdir'. Enable '--use-platform-subdir' automatically.")
|
|
|
|
def execute_command(*run_args, **run_kwargs):
|
|
"""[summary] Provides wrapper for subprocess.run that prints
|
|
command executed when 'more verbose' verbosity level is set."""
|
|
command_args = run_args[0]
|
|
|
|
# If you really need the shell in some non-portable section then
|
|
# invoke subprocess.run() directly.
|
|
if run_kwargs.get('shell') or not isinstance(command_args, list):
|
|
raise RuntimeError("Do not rely on non-portable shell parsing")
|
|
|
|
if args.verbose >= 0:
|
|
cwd = run_kwargs.get('cwd')
|
|
print_cwd = f"In dir: {cwd}" if cwd else f"in current dir: {os.getcwd()}"
|
|
print_args = shlex.join(command_args)
|
|
output = f"{print_cwd}; running command:\n {print_args}"
|
|
env_arg = run_kwargs.get('env')
|
|
env_change = set(env_arg.items()) - set(os.environ.items()) if env_arg else None
|
|
if env_change and (run_kwargs.get('sof_log_env') or args.verbose >= 1):
|
|
output += "\n... with extra/modified environment:\n"
|
|
for k_v in env_change:
|
|
output += f"{k_v[0]}={k_v[1]}\n"
|
|
print(output, flush=True)
|
|
|
|
run_kwargs = {k: run_kwargs[k] for k in run_kwargs if not k.startswith("sof_")}
|
|
|
|
if not 'check' in run_kwargs:
|
|
run_kwargs['check'] = True
|
|
#pylint:disable=subprocess-run-check
|
|
|
|
return subprocess.run(*run_args, **run_kwargs)
|
|
|
|
def symlink_or_copy(targetdir, targetfile, linkdir, linkfile):
|
|
"""Create a relative symbolic link or copy. Don't bother Windows users
|
|
with symbolic links because they require special privileges.
|
|
Windows don't care about /lib/firmware/sof/ anyway.
|
|
Make a copy instead to preserve cross-platform consistency.
|
|
"""
|
|
target = pathlib.Path(targetdir) / targetfile
|
|
link = pathlib.Path(linkdir) / linkfile
|
|
if py_platform.system() == "Windows":
|
|
shutil.copy2(target, link)
|
|
else:
|
|
link.symlink_to(os.path.relpath(target, linkdir))
|
|
|
|
def show_installed_files():
|
|
"""[summary] Scans output directory building binary tree from files and folders
|
|
then presents them in similar way to linux tree command."""
|
|
graph_root = AnyNode(name=STAGING_DIR.name, long_name=".", parent=None)
|
|
relative_entries = [
|
|
entry.relative_to(STAGING_DIR) for entry in sorted(STAGING_DIR.glob("**/*"))
|
|
]
|
|
nodes = [ graph_root ]
|
|
for entry in relative_entries:
|
|
# Node's documentation does allow random attributes
|
|
# pylint: disable=no-member
|
|
# sorted() makes sure our parent is already there.
|
|
# This is slightly awkward, a recursive function would be more readable
|
|
matches = [node for node in nodes if node.long_name == str(entry.parent)]
|
|
assert len(matches) == 1, f'"{entry}" does not have exactly one parent'
|
|
nodes.append(AnyNode(name=entry.name, long_name=str(entry), parent=matches[0]))
|
|
|
|
for pre, _, node in RenderTree(graph_root, render.AsciiStyle):
|
|
fpath = STAGING_DIR / node.long_name
|
|
|
|
# pathLib.readlink() requires Python 3.9
|
|
symlink_trailer = f" -> {os.readlink(fpath)}" if fpath.is_symlink() else ""
|
|
|
|
stem = node.name[:-3] if node.name.endswith(".gz") else node.name
|
|
|
|
shasum_trailer = ""
|
|
if checksum_wanted(stem) and fpath.is_file() and not fpath.is_symlink():
|
|
shasum_trailer = "\tsha256=" + checksum(fpath)
|
|
|
|
print(f"{pre}{node.name} {symlink_trailer} {shasum_trailer}")
|
|
|
|
|
|
# TODO: among other things in this file it should be less SOF-specific;
|
|
# try to move as much as possible to generic Zephyr code. See
|
|
# discussions in https://github.com/zephyrproject-rtos/zephyr/pull/51954
|
|
def checksum_wanted(stem):
|
|
for pattern in CHECKSUM_WANTED:
|
|
if fnmatch.fnmatch(stem, pattern):
|
|
return True
|
|
return False
|
|
|
|
|
|
def checksum(fpath):
|
|
if fpath.suffix == ".gz":
|
|
inputf = gzip.GzipFile(fpath, "rb")
|
|
else:
|
|
inputf = open(fpath, "rb")
|
|
chksum = hashlib.sha256(inputf.read()).hexdigest()
|
|
inputf.close()
|
|
return chksum
|
|
|
|
|
|
def check_west_installation():
|
|
west_path = shutil.which("west")
|
|
if not west_path:
|
|
raise FileNotFoundError("Install west and a west toolchain,"
|
|
"https://docs.zephyrproject.org/latest/getting_started/index.html")
|
|
print(f"Found west: {west_path}")
|
|
|
|
def west_reinitialize(west_root_dir: pathlib.Path, west_manifest_path: pathlib.Path):
|
|
"""[summary] Performs west reinitialization to SOF manifest file asking user for permission.
|
|
Prints error message if script is running in non-interactive mode.
|
|
|
|
:param west_root_dir: directory where is initialized.
|
|
:type west_root_dir: pathlib.Path
|
|
:param west_manifest_path: manifest file to which west is initialized.
|
|
:type west_manifest_path: pathlib.Path
|
|
:raises RuntimeError: Raised when west is initialized to wrong manifest file
|
|
(not SOFs manifest) and script is running in non-interactive mode.
|
|
"""
|
|
global west_top
|
|
message = "West is initialized to manifest other than SOFs!\n"
|
|
message += f"Initialized to manifest: {west_manifest_path}." + "\n"
|
|
dot_west_directory = pathlib.Path(west_root_dir.resolve(), ".west")
|
|
if args.no_interactive:
|
|
message += f"Try deleting {dot_west_directory } directory and rerun this script."
|
|
raise RuntimeError(message)
|
|
question = message + "Reinitialize west to SOF manifest? [Y/n] "
|
|
print(f"{question}")
|
|
while True:
|
|
reinitialize_answer = input().lower()
|
|
if reinitialize_answer in ["y", "n"]:
|
|
break
|
|
sys.stdout.write('Please respond with \'Y\' or \'n\'.\n')
|
|
|
|
if reinitialize_answer != 'y':
|
|
sys.exit("Can not proceed. Reinitialize your west manifest to SOF and rerun this script.")
|
|
shutil.rmtree(dot_west_directory)
|
|
execute_command(["west", "init", "-l", f"{SOF_TOP}"], cwd=west_top)
|
|
|
|
|
|
# TODO: use west APIs directly instead of all these indirect subprocess.run("west", ...) processes
|
|
def west_init_if_needed():
|
|
"""[summary] Validates whether west workspace had been initialized and points to SOF manifest.
|
|
Peforms west initialization if needed.
|
|
"""
|
|
global west_top, SOF_TOP
|
|
west_manifest_path = pathlib.Path(SOF_TOP, "west.yml")
|
|
result_rootdir = execute_command(["west", "topdir"], capture_output=True, cwd=west_top,
|
|
timeout=10, check=False)
|
|
if result_rootdir.returncode != 0:
|
|
execute_command(["west", "init", "-l", f"{SOF_TOP}"], cwd=west_top)
|
|
return
|
|
west_root_dir = pathlib.Path(result_rootdir.stdout.decode().rstrip()).resolve()
|
|
result_manifest_dir = execute_command(["west", "config", "manifest.path"], capture_output=True,
|
|
cwd=west_top, timeout=10, check=True)
|
|
west_manifest_dir = pathlib.Path(west_root_dir, result_manifest_dir.stdout.decode().rstrip()).resolve()
|
|
manifest_file_result = execute_command(["west", "config", "manifest.file"], capture_output=True,
|
|
cwd=west_top, timeout=10, check=True)
|
|
returned_manifest_path = pathlib.Path(west_manifest_dir, manifest_file_result.stdout.decode().rstrip())
|
|
if not returned_manifest_path.samefile(west_manifest_path):
|
|
west_reinitialize(west_root_dir, returned_manifest_path)
|
|
else:
|
|
print(f"West workspace: {west_root_dir}")
|
|
print(f"West manifest path: {west_manifest_path}")
|
|
|
|
def create_zephyr_directory():
|
|
global west_top
|
|
# Do not fail when there's only an empty directory left over
|
|
# (because of some early interruption of this script or proxy
|
|
# misconfiguration, etc.)
|
|
try:
|
|
# rmdir() is safe: it deletes empty directories ONLY.
|
|
west_top.rmdir()
|
|
except OSError as oserr:
|
|
if oserr.errno not in [errno.ENOTEMPTY, errno.ENOENT]:
|
|
raise oserr
|
|
# else when not empty then let the next line fail with a
|
|
# _better_ error message:
|
|
# "zephyrproject already exists"
|
|
|
|
west_top.mkdir(parents=False, exist_ok=False)
|
|
west_top = west_top.resolve(strict=True)
|
|
|
|
def create_zephyr_sof_symlink():
|
|
global west_top, SOF_TOP
|
|
if not west_top.exists():
|
|
raise FileNotFoundError("No west top: {}".format(west_top))
|
|
audio_modules_dir = pathlib.Path(west_top, "modules", "audio")
|
|
audio_modules_dir.mkdir(parents=True, exist_ok=True)
|
|
sof_symlink = pathlib.Path(audio_modules_dir, "sof")
|
|
# Symlinks creation requires administrative privileges in Windows or special user rights
|
|
try:
|
|
if not sof_symlink.exists():
|
|
sof_symlink.symlink_to(SOF_TOP, target_is_directory=True)
|
|
except:
|
|
print(f"Failed to create symbolic link: {sof_symlink} to {SOF_TOP}."
|
|
"\nIf you run script on Windows run it with administrative privileges or\n"
|
|
"grant user symlink creation rights -"
|
|
"see: https://docs.microsoft.com/en-us/windows/security/threat-protection/"
|
|
"security-policy-settings/create-symbolic-links")
|
|
raise
|
|
|
|
def west_update():
|
|
"""[summary] Clones all west manifest projects to specified revisions"""
|
|
global west_top
|
|
execute_command(["west", "update"], check=True, timeout=3000, cwd=west_top)
|
|
|
|
|
|
def get_sof_version():
|
|
"""[summary] Get version string major.minor.micro of SOF
|
|
firmware file. When building multiple platforms from the same SOF
|
|
commit, all platforms share the same version. So for the 1st platform,
|
|
extract the version information from sof/versions.json and later platforms will
|
|
reuse it.
|
|
"""
|
|
global sof_fw_version
|
|
if sof_fw_version:
|
|
return sof_fw_version
|
|
|
|
versions = {}
|
|
with open(SOF_TOP / "versions.json") as versions_file:
|
|
versions = json.load(versions_file)
|
|
# Keep this default value the same as the default SOF_MICRO in version.cmake
|
|
sof_micro = versions['SOF'].get('MICRO', "0")
|
|
sof_fw_version = (
|
|
f"{versions['SOF']['MAJOR']}.{versions['SOF']['MINOR']}.{sof_micro}"
|
|
)
|
|
return sof_fw_version
|
|
|
|
def rmtree_if_exists(directory):
|
|
"This is different from ignore_errors=False because it deletes everything or nothing"
|
|
if os.path.exists(directory):
|
|
shutil.rmtree(directory)
|
|
|
|
def clean_staging(platform):
|
|
print(f"Cleaning {platform} from {STAGING_DIR}")
|
|
|
|
rmtree_if_exists(STAGING_DIR / "sof-info" / platform)
|
|
|
|
sof_output_dir = STAGING_DIR / "sof"
|
|
|
|
# --use-platform-subdir
|
|
rmtree_if_exists(sof_output_dir / platform)
|
|
|
|
# Remaining .ri and .ldc files
|
|
for p in [ platform ] + platform_configs[platform].aliases:
|
|
for f in sof_output_dir.glob(f"**/sof-{p}.*"):
|
|
os.remove(f)
|
|
|
|
# remove IPC4 deployable build directories
|
|
if platform_configs[platform].ipc4:
|
|
sof_platform_output_dir = sof_output_dir / platform_configs[platform].vendor / "sof-ipc4"
|
|
rmtree_if_exists(sof_platform_output_dir / platform)
|
|
for p_alias in platform_configs[platform].aliases:
|
|
rmtree_if_exists(sof_platform_output_dir / p_alias)
|
|
|
|
RIMAGE_BUILD_DIR = west_top / "build-rimage"
|
|
|
|
# Paths in `west.yml` must be "static", we cannot have something like a
|
|
# variable "$my_sof_path/rimage/" checkout. In the future "rimage/" will
|
|
# be moved one level up and it won't be nested inside "sof/" anymore. But
|
|
# for now we must stick to `sof/rimage/[tomlc99]` for
|
|
# backwards-compatibility with XTOS platforms and git submodules, see more
|
|
# detailed comments in west.yml
|
|
RIMAGE_SOURCE_DIR = west_top / "sof" / "tools" / "rimage"
|
|
|
|
|
|
def rimage_west_configuration(platform_dict, dest_dir):
|
|
"""Configure rimage in a new file `dest_dir/westconfig.ini`, starting
|
|
from the workspace .west/config.
|
|
Returns the pathlib.Path to the new file.
|
|
"""
|
|
|
|
saved_local_var = os.environ.get('WEST_CONFIG_LOCAL')
|
|
workspace_west_config_path = os.environ.get('WEST_CONFIG_LOCAL',
|
|
str(west_top / ".west" / "config"))
|
|
platform_west_config_path = dest_dir / "westconfig.ini"
|
|
dest_dir.mkdir(parents=True, exist_ok=True)
|
|
shutil.copyfile(workspace_west_config_path, platform_west_config_path)
|
|
|
|
# Create `platform_wconfig` object pointing at our copy
|
|
os.environ['WEST_CONFIG_LOCAL'] = str(platform_west_config_path)
|
|
platform_wconfig = west_config.Configuration()
|
|
if saved_local_var is None:
|
|
del os.environ['WEST_CONFIG_LOCAL']
|
|
else:
|
|
os.environ['WEST_CONFIG_LOCAL'] = saved_local_var
|
|
|
|
# By default, run rimage directly from the rimage build directory
|
|
if platform_wconfig.get("rimage.path") is None:
|
|
rimage_executable = shutil.which("rimage", path=RIMAGE_BUILD_DIR)
|
|
assert pathlib.Path(str(rimage_executable)).exists()
|
|
platform_wconfig.set("rimage.path", shlex.quote(rimage_executable),
|
|
west_config.ConfigFile.LOCAL)
|
|
|
|
_ws_args = platform_wconfig.get("rimage.extra-args")
|
|
workspace_extra_args = [] if _ws_args is None else shlex.split(_ws_args)
|
|
|
|
# Flatten default rimage options while giving precedence to the workspace =
|
|
# the user input. We could just append and leave duplicates but that would be
|
|
# at best confusing and at worst relying on undocumented rimage precedence.
|
|
extra_args = []
|
|
for default_opt in rimage_options(platform_dict):
|
|
if not default_opt[0] in workspace_extra_args:
|
|
extra_args += default_opt
|
|
|
|
extra_args += workspace_extra_args
|
|
|
|
platform_wconfig.set("rimage.extra-args", shlex.join(extra_args))
|
|
|
|
return platform_west_config_path
|
|
|
|
|
|
def build_rimage():
|
|
|
|
old_rimage_loc = SOF_TOP / "rimage"
|
|
# Don't warn on empty directories
|
|
if ( old_rimage_loc / "CMakeLists.txt" ).exists():
|
|
warnings.warn(f"""{old_rimage_loc} is now ignored,
|
|
new location is {RIMAGE_SOURCE_DIR}"""
|
|
)
|
|
rimage_dir_name = RIMAGE_BUILD_DIR.name
|
|
# CMake build rimage module
|
|
if not (RIMAGE_BUILD_DIR / "CMakeCache.txt").is_file():
|
|
execute_command(["cmake", "-B", rimage_dir_name, "-G", "Ninja",
|
|
"-S", str(RIMAGE_SOURCE_DIR)],
|
|
cwd=west_top)
|
|
rimage_build_cmd = ["cmake", "--build", rimage_dir_name]
|
|
if args.jobs is not None:
|
|
rimage_build_cmd.append(f"-j{args.jobs}")
|
|
if args.verbose > 1:
|
|
rimage_build_cmd.append("-v")
|
|
execute_command(rimage_build_cmd, cwd=west_top)
|
|
|
|
|
|
def rimage_options(platform_dict):
|
|
"""Return a list of default rimage options as a list of tuples,
|
|
example: [ (-f, 2.5.0), (-b, 1), (-k, key.pem),... ]
|
|
|
|
"""
|
|
opts = []
|
|
|
|
if args.verbose > 0:
|
|
opts.append(("-v",) * args.verbose)
|
|
|
|
signing_key = None
|
|
if args.key:
|
|
key_path = pathlib.Path(args.key)
|
|
assert key_path.exists(), f"{key_path} not found"
|
|
signing_key = key_path.resolve()
|
|
elif "RIMAGE_KEY" in platform_dict:
|
|
signing_key = platform_dict["RIMAGE_KEY"]
|
|
|
|
if signing_key is not None:
|
|
opts.append(("-k", str(signing_key)))
|
|
|
|
sof_fw_vers = get_sof_version()
|
|
|
|
opts.append(("-f", sof_fw_vers))
|
|
|
|
# Default value is 0 in rimage but for Zephyr the "build counter" has always
|
|
# been hardcoded to 1 in CMake and there is even a (broken) test that fails
|
|
# when it's not hardcoded to 1.
|
|
# FIXME: drop this line once the following test is fixed
|
|
# tests/avs/fw_00_basic/test_01_load_fw_extended.py::TestLoadFwExtended::()::
|
|
# test_00_01_load_fw_and_check_version
|
|
opts.append(("-b", "1"))
|
|
|
|
return opts
|
|
|
|
|
|
STAGING_DIR = None
|
|
def build_platforms():
|
|
global west_top, SOF_TOP
|
|
print(f"SOF_TOP={SOF_TOP}")
|
|
print(f"west_top={west_top}")
|
|
|
|
global STAGING_DIR
|
|
STAGING_DIR = pathlib.Path(west_top, "build-sof-staging")
|
|
# Don't leave the install of an old build behind
|
|
if args.pristine:
|
|
rmtree_if_exists(STAGING_DIR)
|
|
else:
|
|
# This is important in (at least) two use cases:
|
|
# - when switching `--use-platform-subdir` on/off or changing key subdir,
|
|
# - when the build starts failing after a code change.
|
|
# Do not delete platforms that were not requested so this script can be
|
|
# invoked once per platform.
|
|
for platform in args.platforms:
|
|
clean_staging(platform)
|
|
rmtree_if_exists(STAGING_DIR / "tools")
|
|
|
|
|
|
# smex does not use 'install -D'
|
|
sof_output_dir = pathlib.Path(STAGING_DIR, "sof")
|
|
sof_output_dir.mkdir(parents=True, exist_ok=True)
|
|
for platform in args.platforms:
|
|
platf_build_environ = os.environ.copy()
|
|
|
|
if args.deployable_build:
|
|
vendor_output_dir = pathlib.Path(sof_output_dir, platform_configs[platform].vendor)
|
|
if platform_configs[platform].ipc4:
|
|
sof_platform_output_dir = pathlib.Path(vendor_output_dir, "sof-ipc4")
|
|
else:
|
|
sof_platform_output_dir = pathlib.Path(vendor_output_dir, "sof")
|
|
|
|
sof_platform_output_dir.mkdir(parents=True, exist_ok=True)
|
|
else:
|
|
if args.use_platform_subdir:
|
|
sof_platform_output_dir = pathlib.Path(sof_output_dir, platform)
|
|
sof_platform_output_dir.mkdir(parents=True, exist_ok=True)
|
|
else:
|
|
sof_platform_output_dir = sof_output_dir
|
|
|
|
# For now convert the new dataclass to what it used to be
|
|
_dict = dataclasses.asdict(platform_configs[platform])
|
|
platform_dict = { k:v for (k,v) in _dict.items() if _dict[k] is not None }
|
|
|
|
xtensa_tools_root_dir = os.getenv("XTENSA_TOOLS_ROOT")
|
|
# when XTENSA_TOOLS_ROOT environmental variable is set,
|
|
# use user installed Xtensa tools not Zephyr SDK
|
|
if "XTENSA_TOOLS_VERSION" in platform_dict and xtensa_tools_root_dir:
|
|
xtensa_tools_root_dir = pathlib.Path(xtensa_tools_root_dir)
|
|
if not xtensa_tools_root_dir.is_dir():
|
|
raise RuntimeError(f"Platform {platform} uses Xtensa toolchain."
|
|
"\nVariable XTENSA_TOOLS_VERSION points path that does not exist\n"
|
|
"or is not a directory")
|
|
|
|
# set variables expected by zephyr/cmake/toolchain/xcc/generic.cmake
|
|
platf_build_environ["ZEPHYR_TOOLCHAIN_VARIANT"] = platf_build_environ.get("ZEPHYR_TOOLCHAIN_VARIANT",
|
|
platform_dict["DEFAULT_TOOLCHAIN_VARIANT"])
|
|
XTENSA_TOOLCHAIN_PATH = str(pathlib.Path(xtensa_tools_root_dir, "install",
|
|
"tools").absolute())
|
|
platf_build_environ["XTENSA_TOOLCHAIN_PATH"] = XTENSA_TOOLCHAIN_PATH
|
|
TOOLCHAIN_VER = platform_dict["XTENSA_TOOLS_VERSION"]
|
|
XTENSA_CORE = platform_dict["XTENSA_CORE"]
|
|
platf_build_environ["TOOLCHAIN_VER"] = TOOLCHAIN_VER
|
|
|
|
# Set variables expected by xcc toolchain. CMake cannot set (evil) build-time
|
|
# environment variables at configure time:
|
|
# https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#how-can-i-get-or-set-environment-variables
|
|
XTENSA_BUILDS_DIR=str(pathlib.Path(xtensa_tools_root_dir, "install", "builds",
|
|
TOOLCHAIN_VER).absolute())
|
|
XTENSA_SYSTEM = str(pathlib.Path(XTENSA_BUILDS_DIR, XTENSA_CORE, "config").absolute())
|
|
platf_build_environ["XTENSA_SYSTEM"] = XTENSA_SYSTEM
|
|
|
|
platform_build_dir_name = f"build-{platform}"
|
|
|
|
PLAT_CONFIG = platform_dict["PLAT_CONFIG"]
|
|
build_cmd = ["west"]
|
|
build_cmd += ["-v"] * args.verbose
|
|
build_cmd += ["build", "--build-dir", platform_build_dir_name]
|
|
source_dir = pathlib.Path(SOF_TOP, "app")
|
|
build_cmd += ["--board", PLAT_CONFIG, str(source_dir)]
|
|
if args.pristine:
|
|
build_cmd += ["-p", "always"]
|
|
|
|
if args.jobs is not None:
|
|
build_cmd += [f"--build-opt=-j{args.jobs}"]
|
|
|
|
build_cmd.append('--')
|
|
if args.cmake_args:
|
|
build_cmd += args.cmake_args
|
|
|
|
overlays = [str(item.resolve(True)) for item in args.overlay]
|
|
# The '-d' option is a shortcut for '-o path_to_debug_overlay', we are good
|
|
# if both are provided, because it's no harm to merge the same overlay twice.
|
|
if args.debug:
|
|
overlays.append(str(pathlib.Path(SOF_TOP, "app", "debug_overlay.conf")))
|
|
|
|
if overlays:
|
|
overlays = ";".join(overlays)
|
|
build_cmd.append(f"-DOVERLAY_CONFIG={overlays}")
|
|
|
|
abs_build_dir = pathlib.Path(west_top, platform_build_dir_name)
|
|
|
|
# Longer story in https://github.com/zephyrproject-rtos/zephyr/pull/56671
|
|
if not args.pristine and (
|
|
pathlib.Path(abs_build_dir, "build.ninja").is_file()
|
|
or pathlib.Path(abs_build_dir, "Makefile").is_file()
|
|
):
|
|
if args.cmake_args or overlays:
|
|
warnings.warn("""CMake args slow down incremental builds.
|
|
Passing CMake parameters and overlays on the command line slows down incremental builds
|
|
see https://docs.zephyrproject.org/latest/guides/west/build-flash-debug.html#one-time-cmake-arguments
|
|
Try "west config build.cmake-args -- ..." instead.""")
|
|
|
|
platf_build_environ['WEST_CONFIG_LOCAL'] = str(rimage_west_configuration(
|
|
platform_dict,
|
|
STAGING_DIR / "sof-info" / platform
|
|
))
|
|
|
|
# Make sure the build logs don't leave anything hidden
|
|
execute_command(['west', 'config', '-l'], cwd=west_top,
|
|
env=platf_build_environ, sof_log_env=True)
|
|
print()
|
|
|
|
# Build
|
|
try:
|
|
execute_command(build_cmd, cwd=west_top, env=platf_build_environ, sof_log_env=True)
|
|
except subprocess.CalledProcessError as cpe:
|
|
zephyr_path = pathlib.Path(west_top, "zephyr")
|
|
if not os.path.exists(zephyr_path):
|
|
sys.exit("Zephyr project not found. Please run this script with -u flag or `west update zephyr` manually.")
|
|
else: # unknown failure
|
|
raise cpe
|
|
|
|
smex_executable = pathlib.Path(west_top, platform_build_dir_name, "zephyr", "smex_ep",
|
|
"build", "smex")
|
|
fw_ldc_file = pathlib.Path(sof_platform_output_dir, f"sof-{platform}.ldc")
|
|
input_elf_file = pathlib.Path(west_top, platform_build_dir_name, "zephyr", "zephyr.elf")
|
|
# Extract metadata
|
|
execute_command([str(smex_executable), "-l", str(fw_ldc_file), str(input_elf_file)])
|
|
|
|
for p_alias in platform_configs[platform].aliases:
|
|
symlink_or_copy(sof_platform_output_dir, f"sof-{platform}.ldc", sof_platform_output_dir, f"sof-{p_alias}.ldc")
|
|
|
|
# reproducible-zephyr.ri is less useful now that show_installed_files() shows
|
|
# checksums too. However: - it's still useful when only the .ri file is
|
|
# available (no build logs for the other image), - it makes sure sof_ri_info.py
|
|
# itself does not bitrot, - it can catch rimage issues, see for instance rimage
|
|
# fix 4fb9fe00575b
|
|
if platform not in RI_INFO_UNSUPPORTED:
|
|
reproducible_checksum(platform, west_top / platform_build_dir_name / "zephyr" / "zephyr.ri")
|
|
|
|
install_platform(platform, sof_platform_output_dir, platf_build_environ)
|
|
|
|
src_dest_list = []
|
|
|
|
# Install sof-logger
|
|
sof_logger_dir = pathlib.Path(west_top, platform_build_dir_name, "zephyr",
|
|
"sof-logger_ep", "build", "logger")
|
|
sof_logger_executable_to_copy = pathlib.Path(shutil.which("sof-logger", path=sof_logger_dir))
|
|
tools_output_dir = pathlib.Path(STAGING_DIR, "tools")
|
|
sof_logger_installed_file = pathlib.Path(tools_output_dir, sof_logger_executable_to_copy.name).resolve()
|
|
|
|
src_dest_list += [(sof_logger_executable_to_copy, sof_logger_installed_file)]
|
|
|
|
src_dest_list += [(pathlib.Path(SOF_TOP) /
|
|
"tools" / "mtrace"/ "mtrace-reader.py",
|
|
tools_output_dir)]
|
|
|
|
# Append future files to `src_dest_list` here (but prefer
|
|
# copying entire directories; more flexible)
|
|
|
|
for _src, _dst in src_dest_list:
|
|
os.makedirs(os.path.dirname(_dst), exist_ok=True)
|
|
# looses file owner and group - file is commonly accessible
|
|
shutil.copy2(str(_src), str(_dst))
|
|
|
|
# cavstool and friends
|
|
shutil.copytree(pathlib.Path(west_top) /
|
|
"zephyr" / "soc" / "xtensa" / "intel_adsp" / "tools",
|
|
tools_output_dir,
|
|
symlinks=True, ignore_dangling_symlinks=True, dirs_exist_ok=True)
|
|
|
|
|
|
def install_platform(platform, sof_output_dir, platf_build_environ):
|
|
|
|
# Keep in sync with caller
|
|
platform_build_dir_name = f"build-{platform}"
|
|
|
|
# Install to STAGING_DIR
|
|
abs_build_dir = pathlib.Path(west_top) / platform_build_dir_name / "zephyr"
|
|
|
|
if args.fw_naming == "AVS":
|
|
# Disguise ourselves for local testing purposes
|
|
output_fwname = "dsp_basefw.bin"
|
|
else:
|
|
# Regular name (deployable build also uses SOF naming convention)
|
|
output_fwname = "".join(["sof-", platform, ".ri"])
|
|
|
|
if args.deployable_build and platform_configs[platform].ipc4:
|
|
install_key_dir = pathlib.Path(sof_output_dir, platform)
|
|
else:
|
|
install_key_dir = sof_output_dir
|
|
|
|
if args.key_type_subdir != "none":
|
|
install_key_dir = install_key_dir / args.key_type_subdir
|
|
|
|
os.makedirs(install_key_dir, exist_ok=True)
|
|
# looses file owner and group - file is commonly accessible
|
|
shutil.copy2(abs_build_dir / "zephyr.ri", install_key_dir / output_fwname)
|
|
|
|
if args.deployable_build and platform_configs[platform].ipc4:
|
|
# IPC4 deployable builds are using separate directories per platforms
|
|
# create the structure and symlinks for the alias platforms
|
|
for p_alias in platform_configs[platform].aliases:
|
|
alias_fwname = "".join(["sof-", p_alias, ".ri"])
|
|
|
|
alias_key_dir = pathlib.Path(sof_output_dir, p_alias)
|
|
if args.key_type_subdir != "none":
|
|
alias_key_dir = alias_key_dir / args.key_type_subdir
|
|
|
|
os.makedirs(alias_key_dir, exist_ok=True)
|
|
symlink_or_copy(install_key_dir, output_fwname, alias_key_dir, alias_fwname)
|
|
else:
|
|
# non deployable builds and IPC3 deployable builds are using the same symlink scheme
|
|
# The production key is usually different
|
|
if args.key_type_subdir != "none" and args.fw_naming != "AVS":
|
|
for p_alias in platform_configs[platform].aliases:
|
|
symlink_or_copy(install_key_dir, output_fwname, install_key_dir, f"sof-{p_alias}.ri")
|
|
|
|
|
|
# sof-info/ directory
|
|
|
|
@dataclasses.dataclass
|
|
class InstFile:
|
|
'How to install one file'
|
|
name: pathlib.Path
|
|
renameTo: pathlib.Path = None
|
|
# TODO: upgrade this to 3 states: optional/warning/error
|
|
optional: bool = False
|
|
gzip: bool = True
|
|
txt: bool = False
|
|
|
|
installed_files = [
|
|
# Fail if one of these is missing
|
|
InstFile(".config", "config", txt=True),
|
|
InstFile("misc/generated/configs.c", "generated_configs.c", txt=True),
|
|
InstFile("include/generated/version.h", "zephyr_version.h",
|
|
gzip=False, txt=True),
|
|
InstFile("include/generated/sof_versions.h", "sof_versions.h",
|
|
gzip=False, txt=True),
|
|
InstFile(BIN_NAME + ".elf"),
|
|
InstFile(BIN_NAME + ".lst", txt=True),
|
|
InstFile(BIN_NAME + ".map", txt=True),
|
|
|
|
# CONFIG_BUILD_OUTPUT_STRIPPED
|
|
# Renaming ELF files highlights the workaround below that strips the .comment section
|
|
InstFile(BIN_NAME + ".strip", renameTo=f"stripped-{BIN_NAME}.elf"),
|
|
|
|
# Not every platform has intermediate rimage modules
|
|
InstFile("main-stripped.mod", renameTo="stripped-main.elf", optional=True),
|
|
InstFile("boot.mod", optional=True),
|
|
InstFile("main.mod", optional=True),
|
|
]
|
|
|
|
# We cannot import at the start because zephyr may not be there yet
|
|
sys.path.insert(1, os.path.join(sys.path[0],
|
|
'..', '..', 'zephyr', 'scripts', 'west_commands'))
|
|
import zcmake
|
|
|
|
cmake_cache = zcmake.CMakeCache.from_build_dir(abs_build_dir.parent)
|
|
objcopy = cmake_cache.get("CMAKE_OBJCOPY")
|
|
|
|
sof_info = pathlib.Path(STAGING_DIR) / "sof-info" / platform
|
|
sof_info.mkdir(parents=True, exist_ok=True)
|
|
gzip_threads = concurrent.ThreadPoolExecutor()
|
|
gzip_futures = []
|
|
for f in installed_files:
|
|
if not pathlib.Path(abs_build_dir / f.name).is_file() and f.optional:
|
|
continue
|
|
dstname = f.renameTo or f.name
|
|
|
|
src = abs_build_dir / f.name
|
|
dst = sof_info / dstname
|
|
|
|
# Some Xtensa compilers (ab?)use the .ident / .comment
|
|
# section and append the typically absolute and not
|
|
# reproducible /path/to/the.c file after the usual
|
|
# compiler ID.
|
|
# https://sourceware.org/binutils/docs/as/Ident.html
|
|
#
|
|
# --strip-all does not remove the .comment section.
|
|
# Remove it like some gcc test scripts do:
|
|
# https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=c7046906c3ae
|
|
if "strip" in str(dstname):
|
|
execute_command(
|
|
[str(x) for x in [objcopy, "--remove-section", ".comment", src, dst]],
|
|
# Some xtensa installs don't have a
|
|
# XtensaTools/config/default-params symbolic link
|
|
env=platf_build_environ,
|
|
)
|
|
elif f.txt:
|
|
dos2unix(src, dst)
|
|
else:
|
|
shutil.copy2(src, dst)
|
|
if f.gzip:
|
|
gzip_futures.append(gzip_threads.submit(gzip_compress, dst))
|
|
for gzip_res in concurrent.as_completed(gzip_futures):
|
|
gzip_res.result() # throws exception if gzip unexpectedly failed
|
|
gzip_threads.shutdown()
|
|
|
|
|
|
# Zephyr's CONFIG_KERNEL_BIN_NAME default value
|
|
BIN_NAME = 'zephyr'
|
|
|
|
CHECKSUM_WANTED = [
|
|
# Some .ri files have a deterministic signature, others use
|
|
# a cryptographic salt. Even for the latter a checksum is still
|
|
# useful to match an artefact with a specific build log.
|
|
'*.ri',
|
|
'dsp_basefw.bin',
|
|
|
|
'*version*.h',
|
|
'*configs.c', # deterministic unlike .config
|
|
'*.strip', '*stripped*', # stripped ELF files are reproducible
|
|
'boot.mod', # no debug section -> no need to strip this ELF
|
|
BIN_NAME + '.lst', # objdump --disassemble
|
|
'*.ldc',
|
|
]
|
|
|
|
# Prefer CRLF->LF because unlike LF->CRLF it's (normally) idempotent.
|
|
def dos2unix(in_name, out_name):
|
|
with open(in_name, "rb") as inf:
|
|
# must read all at once otherwise could fall between CR and LF
|
|
content = inf.read()
|
|
assert content
|
|
with open(out_name, "wb") as outf:
|
|
outf.write(content.replace(b"\r\n", b"\n"))
|
|
|
|
def gzip_compress(fname, gzdst=None):
|
|
gzdst = gzdst or pathlib.Path(f"{fname}.gz")
|
|
with open(fname, 'rb') as inputf:
|
|
# mtime=0 for recursive diff convenience
|
|
with gzip.GzipFile(gzdst, 'wb', mtime=0) as gzf:
|
|
shutil.copyfileobj(inputf, gzf)
|
|
os.remove(fname)
|
|
|
|
|
|
# As of October 2022, sof_ri_info.py expects .ri files to include a CSE manifest / signature.
|
|
# Don't run sof_ri_info and ignore silently .ri files that don't have one.
|
|
RI_INFO_UNSUPPORTED = []
|
|
|
|
RI_INFO_UNSUPPORTED += ['imx8', 'imx8x', 'imx8m', 'imx8ulp']
|
|
RI_INFO_UNSUPPORTED += ['rn']
|
|
RI_INFO_UNSUPPORTED += ['mt8186', 'mt8195']
|
|
|
|
# For temporary workarounds. Unlike _UNSUPPORTED above, the platforms below will print a warning.
|
|
RI_INFO_FIXME = [ ]
|
|
|
|
def reproducible_checksum(platform, ri_file):
|
|
|
|
if platform in RI_INFO_FIXME:
|
|
print(f"FIXME: sof_ri_info does not support '{platform}'")
|
|
return
|
|
|
|
parsed_ri = sof_ri_info.parse_fw_bin(ri_file, False, False)
|
|
repro_output = ri_file.parent / ("reproducible-" + ri_file.name)
|
|
chk256 = sof_ri_info.EraseVariables(ri_file, parsed_ri, west_top / repro_output)
|
|
print('sha256sum {0}\n{1} {0}'.format(repro_output, chk256))
|
|
|
|
|
|
def main():
|
|
parse_args()
|
|
if args.version:
|
|
print(VERSION)
|
|
sys.exit(0)
|
|
check_west_installation()
|
|
if len(args.platforms) == 0:
|
|
print("No platform build requested")
|
|
else:
|
|
print("Building platforms: {}".format(" ".join(args.platforms)))
|
|
|
|
west_init_if_needed()
|
|
|
|
if args.update:
|
|
# Initialize zephyr project with west
|
|
west_update()
|
|
create_zephyr_sof_symlink()
|
|
|
|
if args.platforms:
|
|
build_rimage()
|
|
build_platforms()
|
|
show_installed_files()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|