9e619b0d26
Use run_client_and_server() to work across supported platforms. Signed-off-by: Marti Bolivar <marti.bolivar@linaro.org>
853 lines
30 KiB
Python
Executable file
853 lines
30 KiB
Python
Executable file
#! /usr/bin/env python3
|
|
|
|
# Copyright (c) 2017 Linaro Limited.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
"""Zephyr flash/debug script
|
|
|
|
This script is a transparent replacement for existing Zephyr flash and debug
|
|
scripts, i.e. scripts to flash binaries, run them, and debug them on real or
|
|
emulated hardware. If it can invoke the relevant tools natively, it will do so;
|
|
otherwise, it delegates to the shell script."""
|
|
|
|
import abc
|
|
from os import path
|
|
import os
|
|
import pprint
|
|
import platform
|
|
import signal
|
|
import sys
|
|
import subprocess
|
|
import time
|
|
|
|
|
|
def get_env_or_bail(env_var):
|
|
try:
|
|
return os.environ[env_var]
|
|
except KeyError:
|
|
print('Variable {} not in environment:'.format(
|
|
env_var), file=sys.stderr)
|
|
pprint.pprint(dict(os.environ), stream=sys.stderr)
|
|
raise
|
|
|
|
|
|
def get_env_bool_or(env_var, default_value):
|
|
try:
|
|
return bool(int(os.environ[env_var]))
|
|
except KeyError:
|
|
return default_value
|
|
|
|
|
|
def check_call(cmd, debug):
|
|
if debug:
|
|
print(' '.join(cmd))
|
|
subprocess.check_call(cmd)
|
|
|
|
|
|
def check_output(cmd, debug):
|
|
if debug:
|
|
print(' '.join(cmd))
|
|
return subprocess.check_output(cmd)
|
|
|
|
|
|
def popen_ignore_int(cmd, debug):
|
|
'''Spawn a child command, ensuring it ignores SIGINT.
|
|
|
|
The returned subprocess.Popen object must be manually terminated.'''
|
|
cflags = 0
|
|
preexec = None
|
|
system = platform.system()
|
|
|
|
if system == 'Windows':
|
|
cflags |= subprocess.CREATE_NEW_PROCESS_GROUP
|
|
elif system in {'Linux', 'Darwin'}:
|
|
preexec = os.setsid
|
|
|
|
if debug:
|
|
print(' '.join(cmd))
|
|
|
|
return subprocess.Popen(cmd, creationflags=cflags, preexec_fn=preexec)
|
|
|
|
|
|
class ZephyrBinaryRunner(abc.ABC):
|
|
'''Abstract superclass for binary runners (flashers, debuggers).
|
|
|
|
With some exceptions, boards supported by Zephyr must provide
|
|
generic means to be flashed (have a Zephyr firmware binary
|
|
permanently installed on the device for running) and debugged
|
|
(have a breakpoint debugger and program loader on a host
|
|
workstation attached to a running target). This is supported by
|
|
three top-level commands managed by the Zephyr build system:
|
|
|
|
- 'flash': flash a previously configured binary to the board,
|
|
start execution on the target, then return.
|
|
|
|
- 'debug': connect to the board via a debugging protocol, then
|
|
drop the user into a debugger interface with symbol tables
|
|
loaded from the current binary, and block until it exits.
|
|
|
|
- 'debugserver': connect via a board-specific debugging protocol,
|
|
then reset and halt the target. Ensure the user is now able to
|
|
connect to a debug server with symbol tables loaded from the
|
|
binary.
|
|
|
|
Runner functionality relies on a variety of target-specific tools
|
|
and configuration values, the user interface to which is
|
|
abstracted by this class. Each runner subclass should take any
|
|
values it needs to execute one of these commands in its
|
|
constructor. The actual command execution is handled in the run()
|
|
method.
|
|
|
|
This functionality is also replacing the legacy Zephyr runners,
|
|
which are shell scripts.
|
|
|
|
At present, the Zephyr build system uses a variety of
|
|
tool-specific environment variables to control runner behavior.
|
|
To support a transition to ZephyrBinaryRunner and subclasses, this
|
|
class provides a create_for_shell_script() static factory method.
|
|
This method iterates over ZephyrBinaryRUnner subclasses,
|
|
determines which (if any) can provide equivalent functionality to
|
|
the shell-based runner, and returns a subclass instance with its
|
|
configuration determined from the environment.
|
|
|
|
To support this, subclasess currently must provide a pair of
|
|
static methods, replaces_shell_script() and create_from_env(). The
|
|
first allows the runner subclass to declare which commands and
|
|
scripts it can replace. The second is called by
|
|
create_for_shell_script() to create a concrete runner instance.
|
|
|
|
The environment-based factories are for legacy use *only*; the
|
|
user must be able to construct and use a runner using only the
|
|
constructor and run() method.'''
|
|
|
|
def __init__(self, debug=False):
|
|
self.debug = debug
|
|
|
|
@staticmethod
|
|
def create_for_shell_script(shell_script, command, debug):
|
|
'''Factory for using as a drop-in replacement to a shell script.
|
|
|
|
Command is one of 'flash', 'debug', 'debugserver'.
|
|
|
|
Get runner instance to use in place of shell_script, deriving
|
|
configuration from the environment.'''
|
|
for sub_cls in ZephyrBinaryRunner.__subclasses__():
|
|
if sub_cls.replaces_shell_script(shell_script, command):
|
|
return sub_cls.create_from_env(command, debug)
|
|
raise ValueError('cannot implement script {} command {}'.format(
|
|
shell_script, command))
|
|
|
|
@staticmethod
|
|
@abc.abstractmethod
|
|
def replaces_shell_script(shell_script, command):
|
|
'''Check if this class replaces shell_script for the given command.'''
|
|
|
|
@staticmethod
|
|
@abc.abstractmethod
|
|
def create_from_env(command, debug):
|
|
'''Create new flasher instance from environment variables.
|
|
|
|
This class must be able to replace the current shell script
|
|
(FLASH_SCRIPT or DEBUG_SCRIPT, depending on command). The
|
|
environment variables expected by that script are used to build
|
|
the flasher in a backwards-compatible manner.'''
|
|
|
|
@abc.abstractmethod
|
|
def run(self, command, **kwargs):
|
|
'''Run a command ('flash', 'debug', 'debugserver').
|
|
|
|
In case of an unsupported command, raise a ValueError.'''
|
|
|
|
def run_server_and_client(self, server, client):
|
|
'''Run a server that ignores SIGINT, and a client that handles it.
|
|
|
|
This routine portably:
|
|
|
|
- creates a Popen object for the `server' command which ignores SIGINT
|
|
- runs `client' in a subprocess while temporarily ignoring SIGINT
|
|
- cleans up the server after the client exits.
|
|
|
|
It's useful to e.g. open a GDB server and client.'''
|
|
server_proc = popen_ignore_int(server, self.debug)
|
|
previous = signal.signal(signal.SIGINT, signal.SIG_IGN)
|
|
try:
|
|
check_call(client, self.debug)
|
|
finally:
|
|
signal.signal(signal.SIGINT, previous)
|
|
server_proc.terminate()
|
|
server_proc.wait()
|
|
|
|
|
|
DEFAULT_ARC_TCL_PORT = 6333
|
|
DEFAULT_ARC_TELNET_PORT = 4444
|
|
DEFAULT_ARC_GDB_PORT = 3333
|
|
|
|
|
|
class ArcBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for the ARC architecture, using openocd.'''
|
|
|
|
# This unusual 'flash' implementation matches the original shell script.
|
|
#
|
|
# It works by starting a GDB server in a separate session, connecting a
|
|
# client to it to load the program, and running 'continue' within the
|
|
# client to execute the application.
|
|
#
|
|
# TODO: exit immediately when flashing is done, leaving Zephyr running.
|
|
|
|
def __init__(self, elf, zephyr_base, arch, board_name, python,
|
|
gdb, openocd='openocd', extra_init=None, default_path=None,
|
|
tui=None, tcl_port=DEFAULT_ARC_TCL_PORT,
|
|
telnet_port=DEFAULT_ARC_TELNET_PORT,
|
|
gdb_port=DEFAULT_ARC_GDB_PORT, debug=False):
|
|
super(ArcBinaryRunner, self).__init__(debug=debug)
|
|
self.elf = elf
|
|
self.zephyr_base = zephyr_base
|
|
self.arch = arch
|
|
self.board_name = board_name
|
|
self.python = python
|
|
self.gdb = gdb
|
|
search_args = []
|
|
if default_path is not None:
|
|
search_args = ['-s', default_path]
|
|
self.openocd_cmd = [openocd] + search_args
|
|
self.extra_init = extra_init
|
|
self.tui = tui
|
|
self.tcl_port = tcl_port
|
|
self.telnet_port = telnet_port
|
|
self.gdb_port = gdb_port
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return (command in {'flash', 'debug', 'debugserver'} and
|
|
shell_script == 'arc_debugger.sh')
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create runner from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_ELF_NAME: zephyr kernel binary in ELF format
|
|
- ZEPHYR_BASE: zephyr Git repository base directory
|
|
- ARCH: board architecture
|
|
- BOARD_NAME: zephyr name of board
|
|
- PYTHON: python executable
|
|
- GDB: gdb executable
|
|
|
|
Optional:
|
|
|
|
- OPENOCD: path to openocd, defaults to openocd
|
|
- OPENOCD_EXTRA_INIT: initialization command for GDB server
|
|
- OPENOCD_DEFAULT_PATH: openocd search path to use
|
|
- TUI: if present, passed to gdb server used to flash
|
|
- TCL_PORT: openocd TCL port, defaults to 6333
|
|
- TELNET_PORT: openocd telnet port, defaults to 4444
|
|
- GDB_PORT: openocd gdb port, defaults to 3333
|
|
'''
|
|
elf = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_ELF_NAME'))
|
|
zephyr_base = get_env_or_bail('ZEPHYR_BASE')
|
|
arch = get_env_or_bail('ARCH')
|
|
board_name = get_env_or_bail('BOARD_NAME')
|
|
python = get_env_or_bail('PYTHON')
|
|
gdb = get_env_or_bail('GDB')
|
|
|
|
openocd = os.environ.get('OPENOCD', 'openocd')
|
|
extra_init = os.environ.get('OPENOCD_EXTRA_INIT', None)
|
|
default_path = os.environ.get('OPENOCD_DEFAULT_PATH', None)
|
|
tui = os.environ.get('TUI', None)
|
|
tcl_port = int(os.environ.get('TCL_PORT',
|
|
str(DEFAULT_ARC_TCL_PORT)))
|
|
telnet_port = int(os.environ.get('TELNET_PORT',
|
|
str(DEFAULT_ARC_TELNET_PORT)))
|
|
gdb_port = int(os.environ.get('GDB_PORT',
|
|
str(DEFAULT_ARC_GDB_PORT)))
|
|
|
|
return ArcBinaryRunner(elf, zephyr_base, arch, board_name, python,
|
|
gdb, openocd=openocd, extra_init=extra_init,
|
|
default_path=default_path, tui=tui,
|
|
tcl_port=tcl_port, telnet_port=telnet_port,
|
|
gdb_port=gdb_port, debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command not in {'flash', 'debug', 'debugserver'}:
|
|
raise ValueError('{} is not supported'.format(command))
|
|
|
|
kwargs['openocd-cfg'] = path.join(self.zephyr_base, 'boards',
|
|
self.arch, self.board_name,
|
|
'support', 'openocd.cfg')
|
|
|
|
if command in {'flash', 'debug'}:
|
|
self.flash_debug(command, **kwargs)
|
|
else:
|
|
self.debugserver(**kwargs)
|
|
|
|
def flash_debug(self, command, **kwargs):
|
|
extra_init_args = []
|
|
if self.extra_init is not None:
|
|
extra_init_args = self.extra_init.split()
|
|
|
|
config = kwargs['openocd-cfg']
|
|
|
|
server_cmd = (self.openocd_cmd +
|
|
['-f', config] +
|
|
extra_init_args +
|
|
['-c', 'tcl_port {}'.format(self.tcl_port),
|
|
'-c', 'telnet_port {}'.format(self.telnet_port),
|
|
'-c', 'gdb_port {}'.format(self.gdb_port),
|
|
'-c', 'init',
|
|
'-c', 'targets',
|
|
'-c', 'halt'])
|
|
|
|
tui_arg = []
|
|
if self.tui is not None:
|
|
tui_arg = [self.tui]
|
|
|
|
continue_arg = []
|
|
if command == 'flash':
|
|
continue_arg = ['-ex', 'c']
|
|
|
|
gdb_cmd = ([self.gdb] +
|
|
tui_arg +
|
|
['-ex', 'target remote :{}'.format(self.gdb_port),
|
|
'-ex', 'load'] +
|
|
continue_arg +
|
|
[self.elf])
|
|
|
|
self.run_server_and_client(server_cmd, gdb_cmd)
|
|
|
|
def debugserver(self, **kwargs):
|
|
config = kwargs['openocd-cfg']
|
|
cmd = (self.openocd_cmd +
|
|
['-f', config,
|
|
'-c', 'init',
|
|
'-c', 'targets',
|
|
'-c', 'reset halt'])
|
|
check_call(cmd, self.debug)
|
|
|
|
|
|
class BossacBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for bossac.'''
|
|
|
|
def __init__(self, bin_name, bossac='bossac', debug=False):
|
|
super(BossacBinaryRunner, self).__init__(debug=debug)
|
|
self.bin_name = bin_name
|
|
self.bossac = bossac
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'bossa-flash.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_BIN_NAME: name of kernel binary
|
|
|
|
Optional:
|
|
|
|
- BOSSAC: path to bossac, default is bossac
|
|
'''
|
|
bin_name = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_BIN_NAME'))
|
|
bossac = os.environ.get('BOSSAC', 'bossac')
|
|
return BossacBinaryRunner(bin_name, bossac=bossac, debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
if platform.system() != 'Linux':
|
|
msg = 'CAUTION: No flash tool for your host system found!'
|
|
raise NotImplementedError(msg)
|
|
|
|
cmd_stty = ['stty', '-F', '/dev/ttyACM0', 'raw', 'ispeed', '1200',
|
|
'ospeed', '1200', 'cs8', '-cstopb', 'ignpar', 'eol', '255',
|
|
'eof', '255']
|
|
cmd_flash = [self.bossac, '-R', '-e', '-w', '-v', '-b', self.bin_name]
|
|
|
|
check_call(cmd_stty, self.debug)
|
|
check_call(cmd_flash, self.debug)
|
|
|
|
|
|
class DfuUtilBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for dfu-util.'''
|
|
|
|
def __init__(self, pid, alt, img, dfuse=None, exe='dfu-util', debug=False):
|
|
super(DfuUtilBinaryRunner, self).__init__(debug=debug)
|
|
self.alt = alt
|
|
self.img = img
|
|
self.dfuse = dfuse
|
|
self.cmd = [exe, '-d,{}'.format(pid)]
|
|
try:
|
|
self.list_pattern = ', alt={},'.format(int(self.alt))
|
|
except ValueError:
|
|
self.list_pattern = ', name="{}",'.format(self.alt)
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'dfuutil.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- DFUUTIL_PID: USB VID:PID of the board
|
|
- DFUUTIL_ALT: interface alternate setting number or name
|
|
- DFUUTIL_IMG: binary to flash
|
|
|
|
Optional:
|
|
|
|
- DFUUTIL_DFUSE_ADDR: target address if the board is a
|
|
DfuSe device. Ignored if not present.
|
|
- DFUUTIL: dfu-util executable, defaults to dfu-util.
|
|
'''
|
|
pid = get_env_or_bail('DFUUTIL_PID')
|
|
alt = get_env_or_bail('DFUUTIL_ALT')
|
|
img = get_env_or_bail('DFUUTIL_IMG')
|
|
dfuse = os.environ.get('DFUUTIL_DFUSE_ADDR', None)
|
|
exe = os.environ.get('DFUUTIL', 'dfu-util')
|
|
|
|
return DfuUtilBinaryRunner(pid, alt, img, dfuse=dfuse, exe=exe,
|
|
debug=debug)
|
|
|
|
def find_device(self):
|
|
cmd = list(self.cmd) + ['-l']
|
|
output = check_output(cmd, self.debug)
|
|
output = output.decode(sys.getdefaultencoding())
|
|
return self.list_pattern in output
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
reset = 0
|
|
if not self.find_device():
|
|
reset = 1
|
|
print('Please reset your board to switch to DFU mode...')
|
|
while not self.find_device():
|
|
time.sleep(0.1)
|
|
|
|
cmd = list(self.cmd)
|
|
if self.dfuse is not None:
|
|
cmd.extend(['-s', '{}:leave'.format(self.dfuse)])
|
|
cmd.extend(['-a', self.alt, '-D', self.img])
|
|
check_call(cmd, self.debug)
|
|
if reset:
|
|
print('Now reset your board again to switch back to runtime mode.')
|
|
|
|
|
|
class Esp32BinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for espidf.'''
|
|
|
|
def __init__(self, elf, device, baud=921600, flash_size='detect',
|
|
flash_freq='40m', flash_mode='dio', espidf='espidf',
|
|
debug=False):
|
|
super(Esp32BinaryRunner, self).__init__(debug=debug)
|
|
self.elf = elf
|
|
self.device = device
|
|
self.baud = baud
|
|
self.flash_size = flash_size
|
|
self.flash_freq = flash_freq
|
|
self.flash_mode = flash_mode
|
|
self.espidf = espidf
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'esp32.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_ELF_NAME: name of kernel binary in ELF format
|
|
|
|
Optional:
|
|
|
|
- ESP_DEVICE: serial port to flash, default /dev/ttyUSB0
|
|
- ESP_BAUD_RATE: serial baud rate, default 921600
|
|
- ESP_FLASH_SIZE: flash size, default 'detect'
|
|
- ESP_FLASH_FREQ: flash frequency, default '40m'
|
|
- ESP_FLASH_MODE: flash mode, default 'dio'
|
|
- ESP_TOOL: complete path to espidf, or set to 'espidf' to look for it
|
|
in $ESP_IDF_PATH/components/esptool_py/esptool/esptool.py
|
|
'''
|
|
elf = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_ELF_NAME'))
|
|
|
|
# TODO add sane device defaults on other platforms than Linux.
|
|
device = os.environ.get('ESP_DEVICE', '/dev/ttyUSB0')
|
|
baud = os.environ.get('ESP_BAUD_RATE', '921600')
|
|
flash_size = os.environ.get('ESP_FLASH_SIZE', 'detect')
|
|
flash_freq = os.environ.get('ESP_FLASH_FREQ', '40m')
|
|
flash_mode = os.environ.get('ESP_FLASH_MODE', 'dio')
|
|
espidf = os.environ.get('ESP_TOOL', 'espidf')
|
|
|
|
if espidf == 'espidf':
|
|
idf_path = get_env_or_bail('ESP_IDF_PATH')
|
|
espidf = path.join(idf_path, 'components', 'esptool_py', 'esptool',
|
|
'esptool.py')
|
|
|
|
return Esp32BinaryRunner(elf, device, baud=baud,
|
|
flash_size=flash_size, flash_freq=flash_freq,
|
|
flash_mode=flash_mode, espidf=espidf,
|
|
debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
bin_name = path.splitext(self.elf)[0] + path.extsep + 'bin'
|
|
cmd_convert = [self.espidf, '--chip', 'esp32', 'elf2image', self.elf]
|
|
cmd_flash = [self.espidf, '--chip', 'esp32', '--port', self.device,
|
|
'--baud', self.baud, '--before', 'default_reset',
|
|
'--after', 'hard_reset', 'write_flash', '-u',
|
|
'--flash_mode', self.flash_mode,
|
|
'--flash_freq', self.flash_freq,
|
|
'--flash_size', self.flash_size,
|
|
'0x1000', bin_name]
|
|
|
|
print("Converting ELF to BIN")
|
|
check_call(cmd_convert, self.debug)
|
|
|
|
print("Flashing ESP32 on {} ({}bps)".format(self.device, self.baud))
|
|
check_call(cmd_flash, self.debug)
|
|
|
|
|
|
class Nios2BinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for NIOS II.'''
|
|
|
|
# From the original shell script:
|
|
#
|
|
# "XXX [flash] only support[s] cases where the .elf is sent
|
|
# over the JTAG and the CPU directly boots from __start. CONFIG_XIP
|
|
# and CONFIG_INCLUDE_RESET_VECTOR must be disabled."
|
|
|
|
def __init__(self, hex_, cpu_sof, zephyr_base, debug=False):
|
|
super(Nios2BinaryRunner, self).__init__(debug=debug)
|
|
self.hex_ = hex_
|
|
self.cpu_sof = cpu_sof
|
|
self.zephyr_base = zephyr_base
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'nios2.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_HEX_NAME: name of kernel binary in ELF format
|
|
- NIOS2_CPU_SOF: location of the CPU .sof data
|
|
- ZEPHYR_BASE: zephyr Git repository base directory
|
|
'''
|
|
hex_ = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_HEX_NAME'))
|
|
cpu_sof = get_env_or_bail('NIOS2_CPU_SOF')
|
|
zephyr_base = get_env_or_bail('ZEPHYR_BASE')
|
|
|
|
return Nios2BinaryRunner(hex_, cpu_sof, zephyr_base, debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
cmd = [path.join(self.zephyr_base, 'scripts', 'support',
|
|
'quartus-flash.py'),
|
|
'--sof', self.cpu_sof,
|
|
'--kernel', self.hex_]
|
|
|
|
check_call(cmd, self.debug)
|
|
|
|
|
|
class NrfJprogBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for nrfjprog.'''
|
|
|
|
def __init__(self, hex_, family, board, debug=False):
|
|
super(NrfJprogBinaryRunner, self).__init__(debug=debug)
|
|
self.hex_ = hex_
|
|
self.family = family
|
|
self.board = board
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'nrf_flash.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_HEX_NAME: name of kernel binary in ELF format
|
|
- NRF_FAMILY: e.g. NRF51 or NRF52
|
|
- BOARD: Zephyr board name
|
|
'''
|
|
hex_ = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_HEX_NAME'))
|
|
family = get_env_or_bail('NRF_FAMILY')
|
|
board = get_env_or_bail('BOARD')
|
|
|
|
return NrfJprogBinaryRunner(hex_, family, board, debug=debug)
|
|
|
|
def get_board_snr_from_user(self):
|
|
snrs = check_output(['nrfjprog', '--ids'], self.debug)
|
|
snrs = snrs.decode(sys.getdefaultencoding()).strip().splitlines()
|
|
|
|
if len(snrs) == 1:
|
|
return snrs[0]
|
|
|
|
print('There are multiple boards connected.')
|
|
for i, snr in enumerate(snrs, 1):
|
|
print('{}. {}'.format(i, snr))
|
|
|
|
p = 'Please select one with desired serial number (1-{}): '.format(
|
|
len(snrs))
|
|
while True:
|
|
value = input(p)
|
|
try:
|
|
value = int(value)
|
|
except ValueError:
|
|
continue
|
|
if 1 <= value <= len(snrs):
|
|
break
|
|
|
|
return snrs[value - 1]
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
board_snr = self.get_board_snr_from_user()
|
|
|
|
print('Flashing file: {}'.format(self.hex_))
|
|
commands = [
|
|
['nrfjprog', '--eraseall', '-f', self.family, '--snr', board_snr],
|
|
['nrfjprog', '--program', self.hex_, '-f', self.family, '--snr',
|
|
board_snr],
|
|
]
|
|
if self.family == 'NRF52':
|
|
commands.extend([
|
|
# Set reset pin
|
|
['nrfjprog', '--memwr', '0x10001200', '--val', '0x00000015',
|
|
'-f', self.family, '--snr', board_snr],
|
|
['nrfjprog', '--memwr', '0x10001204', '--val', '0x00000015',
|
|
'-f', self.family, '--snr', board_snr],
|
|
['nrfjprog', '--reset', '-f', self.family, '--snr', board_snr],
|
|
])
|
|
commands.append(['nrfjprog',
|
|
'--pinreset',
|
|
'-f', self.family,
|
|
'--snr', board_snr])
|
|
|
|
for cmd in commands:
|
|
check_call(cmd, self.debug)
|
|
|
|
print('{} Serial Number {} flashed with success.'.format(
|
|
self.board, board_snr))
|
|
|
|
|
|
class OpenOcdBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for openocd.'''
|
|
|
|
def __init__(self, bin_name, zephyr_base, arch, board_name,
|
|
load_cmd, verify_cmd, openocd='openocd',
|
|
default_path=None, pre_cmd=None,
|
|
post_cmd=None, debug=False):
|
|
super(OpenOcdBinaryRunner, self).__init__(debug=debug)
|
|
self.bin_name = bin_name
|
|
self.zephyr_base = zephyr_base
|
|
self.arch = arch
|
|
self.board_name = board_name
|
|
self.load_cmd = load_cmd
|
|
self.verify_cmd = verify_cmd
|
|
self.openocd = openocd
|
|
self.default_path = default_path
|
|
self.pre_cmd = pre_cmd
|
|
self.post_cmd = post_cmd
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'openocd.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_BIN_NAME: zephyr kernel binary
|
|
- ZEPHYR_BASE: zephyr Git repository base directory
|
|
- ARCH: board architecture
|
|
- BOARD_NAME: zephyr name of board
|
|
- OPENOCD_LOAD_CMD: command to load binary into flash
|
|
- OPENOCD_VERIFY_CMD: command to verify flash executed correctly
|
|
|
|
Optional:
|
|
|
|
- OPENOCD: path to openocd, defaults to openocd
|
|
- OPENOCD_DEFAULT_PATH: openocd search path to use
|
|
- OPENOCD_PRE_CMD: command to run before any others
|
|
- OPENOCD_POST_CMD: command to run after verifying flash write
|
|
'''
|
|
bin_name = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_BIN_NAME'))
|
|
zephyr_base = get_env_or_bail('ZEPHYR_BASE')
|
|
arch = get_env_or_bail('ARCH')
|
|
board_name = get_env_or_bail('BOARD_NAME')
|
|
load_cmd = get_env_or_bail('OPENOCD_LOAD_CMD').strip('"')
|
|
verify_cmd = get_env_or_bail('OPENOCD_VERIFY_CMD').strip('"')
|
|
|
|
openocd = os.environ.get('OPENOCD', 'openocd')
|
|
default_path = os.environ.get('OPENOCD_DEFAULT_PATH', None)
|
|
pre_cmd = os.environ.get('OPENOCD_PRE_CMD', None)
|
|
if pre_cmd is not None:
|
|
pre_cmd = pre_cmd.strip('"')
|
|
post_cmd = os.environ.get('OPENOCD_POST_CMD', None)
|
|
if post_cmd is not None:
|
|
post_cmd = post_cmd.strip('"')
|
|
|
|
return OpenOcdBinaryRunner(bin_name, zephyr_base, arch, board_name,
|
|
load_cmd, verify_cmd, openocd=openocd,
|
|
default_path=default_path, pre_cmd=pre_cmd,
|
|
post_cmd=post_cmd, debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
search_args = []
|
|
if self.default_path is not None:
|
|
search_args = ['-s', self.default_path]
|
|
|
|
config = path.join(self.zephyr_base, 'boards', self.arch,
|
|
self.board_name, 'support', 'openocd.cfg')
|
|
|
|
pre_cmd = []
|
|
if self.pre_cmd is not None:
|
|
pre_cmd = ['-c', self.pre_cmd]
|
|
|
|
post_cmd = []
|
|
if self.post_cmd is not None:
|
|
post_cmd = ['-c', self.post_cmd]
|
|
|
|
cmd = ([self.openocd] +
|
|
search_args +
|
|
['-f', config,
|
|
'-c', 'init',
|
|
'-c', 'targets'] +
|
|
pre_cmd +
|
|
['-c', 'reset halt',
|
|
'-c', self.load_cmd,
|
|
'-c', 'reset halt',
|
|
'-c', self.verify_cmd] +
|
|
post_cmd +
|
|
['-c', 'reset run',
|
|
'-c', 'shutdown'])
|
|
check_call(cmd, self.debug)
|
|
|
|
|
|
class PyOcdBinaryRunner(ZephyrBinaryRunner):
|
|
'''Runner front-end for pyocd-flashtool.'''
|
|
|
|
def __init__(self, bin_name, target, flashtool='pyocd-flashtool',
|
|
board_id=None, daparg=None, debug=False):
|
|
super(PyOcdBinaryRunner, self).__init__(debug=debug)
|
|
self.bin_name = bin_name
|
|
self.target = target
|
|
self.flashtool = flashtool
|
|
self.board_id = board_id
|
|
self.daparg = daparg
|
|
|
|
def replaces_shell_script(shell_script, command):
|
|
return command == 'flash' and shell_script == 'pyocd.sh'
|
|
|
|
def create_from_env(command, debug):
|
|
'''Create flasher from environment.
|
|
|
|
Required:
|
|
|
|
- O: build output directory
|
|
- KERNEL_BIN_NAME: name of kernel binary
|
|
- PYOCD_TARGET: target override
|
|
|
|
Optional:
|
|
|
|
- PYOCD_FLASHTOOL: flash tool path, defaults to pyocd-flashtool
|
|
- PYOCD_BOARD_ID: ID of board to flash, default is to guess
|
|
- PYOCD_DAPARG: arguments to pass to flashtool, default is none
|
|
'''
|
|
bin_name = path.join(get_env_or_bail('O'),
|
|
get_env_or_bail('KERNEL_BIN_NAME'))
|
|
target = get_env_or_bail('PYOCD_TARGET')
|
|
|
|
flashtool = os.environ.get('PYOCD_FLASHTOOL', 'pyocd-flashtool')
|
|
board_id = os.environ.get('PYOCD_BOARD_ID', None)
|
|
daparg = os.environ.get('PYOCD_DAPARG', None)
|
|
|
|
return PyOcdBinaryRunner(bin_name, target,
|
|
flashtool=flashtool, board_id=board_id,
|
|
daparg=daparg, debug=debug)
|
|
|
|
def run(self, command, **kwargs):
|
|
if command != 'flash':
|
|
raise ValueError('only flash is supported')
|
|
|
|
daparg_args = []
|
|
if self.daparg is not None:
|
|
daparg_args = ['-da', self.daparg]
|
|
|
|
board_args = []
|
|
if self.board_id is not None:
|
|
board_args = ['-b', self.board_id]
|
|
|
|
cmd = ([self.flashtool] +
|
|
daparg_args +
|
|
['-t', self.target] +
|
|
board_args +
|
|
[self.bin_name])
|
|
|
|
print('Flashing Target Device')
|
|
check_call(cmd, self.debug)
|
|
|
|
|
|
# TODO: Stop using environment variables.
|
|
#
|
|
# Migrate the build system so we can use an argparse.ArgumentParser and
|
|
# per-flasher subparsers, so invoking the script becomes something like:
|
|
#
|
|
# python zephyr_flash_debug.py openocd --openocd-bin=/openocd/path ...
|
|
#
|
|
# For now, maintain compatibility.
|
|
def run(shell_script_full, command, debug):
|
|
shell_script = path.basename(shell_script_full)
|
|
try:
|
|
runner = ZephyrBinaryRunner.create_for_shell_script(shell_script,
|
|
command,
|
|
debug)
|
|
except ValueError:
|
|
# Unsupported; fall back on shell script.
|
|
check_call([shell_script_full, command], debug)
|
|
return
|
|
|
|
runner.run(command)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
commands = {'flash', 'debug', 'debugserver'}
|
|
debug = True
|
|
try:
|
|
debug = get_env_bool_or('KBUILD_VERBOSE', False)
|
|
if len(sys.argv) != 3 or sys.argv[1] not in commands:
|
|
raise ValueError('usage: {} <{}> path-to-script'.format(
|
|
sys.argv[0], '|'.join(commands)))
|
|
run(sys.argv[2], sys.argv[1], debug)
|
|
except Exception as e:
|
|
if debug:
|
|
raise
|
|
else:
|
|
print('Error: {}'.format(e), file=sys.stderr)
|
|
print('Re-run with KBUILD_VERBOSE=1 for a stack trace.',
|
|
file=sys.stderr)
|
|
sys.exit(1)
|