def board_power(
lab: typing.Optional[tbot.selectable.LabHost] = None,
board: typing.Optional[board.Board] = None,
state='on',
) -> None:
"""
power on or off the board without acquiring console.
This is only hacky version, we should bring in this into
tbot.
"""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
fl = tbot.flags
tbot.flags = {"no_console_check", "nopoweroff"}
b = cx.enter_context(board or tbot.acquire_board(lh))
tbot.flags = fl
if state == 'on':
b.poweron()
else:
b.poweroff()
tbot.flags = {"no_console_check", "nopoweroff"}
def ari_ub_check_multi_dtb_select(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as bx:
b = bx.enter_context(tbot.acquire_board(lh))
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
old_panel = cur_panel
check_panel(ub, cur_panel)
cur_panel = switch_panel(ub, cur_panel)
ub.ch.sendline("res")
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
if old_panel == cur_panel:
raise RuntimeError(
f"{cur_panel} == {old_panel}, should change")
old_panel = cur_panel
check_panel(ub, cur_panel)
cur_panel = switch_panel(ub, cur_panel)
ub.ch.sendline("res")
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
if old_panel == cur_panel:
raise RuntimeError(
f"{cur_panel} == {old_panel}, should change")
check_panel(ub, cur_panel)
def test_linux(mach: typing.Optional[linux.LinuxShell] = None, ) -> None:
with mach or tbot.acquire_lab() as lnx:
p = lnx.workdir / "foobar"
with tbot.acquire_lab() as lh:
p2 = lh.workdir / "barfoo"
# Should fail!
lnx.exec0("echo", p2)
lh.exec0("echo", p)
with tbot.acquire_board(lh) as b:
with tbot.acquire_linux(b) as lnx2:
p3 = lnx2.workdir / "barbarbar"
# Should fail!
lh.exec0("echo", p3)
lnx.exec0("echo", p3)
lnx2.exec0("echo", p)
lnx2.exec0("echo", p2)
# Should pass!
lnx.exec0("echo", p)
lh.exec0("echo", p2)
lnx2.exec0("echo", p3)
def selftest_board_uboot(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test if tbot intercepts U-Boot correctly."""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
try:
b: board.Board = cx.enter_context(tbot.acquire_board(lh))
ub: board.UBootShell = cx.enter_context(
tbot.acquire_uboot(b) # type: ignore
)
except NotImplementedError:
b = cx.enter_context(TestBoard(lh))
ub = cx.enter_context(TestBoardUBoot(b))
ub.exec0("version")
env = ub.exec0("printenv").strip().split("\n")
for line in env[:-1]:
if line != "" and line[0].isalnum():
assert "=" in line, repr(line)
out = ub.exec0("echo", hex(0x1234)).strip()
assert out == "0x1234", repr(out)
mach.selftest_machine_shell(ub)
def socrates_ub_update_i(
lab: typing.Optional[linux.LinuxShell] = None,
uboot: typing.Optional[board.UBootShell] = None,
interactive = True,
) -> None:
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
if uboot is not None:
ub = uboot
else:
b = cx.enter_context(tbot.acquire_board(lh))
ub = cx.enter_context(tbot.acquire_uboot(b))
ret = ub.exec("ping", "192.168.1.1")
while ret[0] != 0:
ret = ub.exec("ping", "192.168.1.1")
if "restore_old_ub" in tbot.flags:
tbot.log.message("restore old U-Boot")
ub.env("uboot_addr", "FFFA0000")
ub.env("uboot_file", "socrates-abb/20190627/socrates-u-boot.bin-voncajus")
else:
ub.env("uboot_addr", "FFF60000")
ub.env("uboot_file", f"socrates-abb/{b.date}/u-boot-socrates.bin")
ub.env("update_uboot", "tftp 110000 ${uboot_file};protect off ${uboot_addr} ffffffff;era ${uboot_addr} ffffffff;cp.b 110000 ${uboot_addr} ${filesize}")
ub.exec0("printenv")
ub.exec0("run", "update_uboot")
if interactive:
ub.interactive()
def ari_ub_check_version(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
u-boot check if version on board is the same as in binary
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
t = lh.tftp_dir / "u-boot-dtb.imx.signed"
#bin_vers = lh.exec0("strings", t, linux.Pipe, "grep", '"U-Boot 2"')
bin_vers = lh.exec0(
linux.Raw(
f"strings /tftpboot/aristainetos/tbot/u-boot-dtb.imx.signed | grep --color=never 'U-Boot 2'"
))
ub_vers = ub.exec0("version")
if bin_vers in ub_vers:
tbot.log.message(
tbot.log.c("Info: U-Boot version is the same").green)
else:
raise RuntimeError(f"{bin_vers} != {ub_vers}")
def socrates_ub_bdi_update(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubma: typing.Optional[board.UBootShell] = None,
) -> None:
with contextlib.ExitStack() as cx:
if lab is not None:
lh = lab
else:
lh = cx.enter_context(tbot.acquire_lab())
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
bd.bdi_connect(lh, b)
bd.bdi_reset_board()
bd.exec("era")
if "restore_old_ub" in tbot.flags:
bd.exec("prog", "0xfffa0000", f"socrates-abb/{b.date}/socrates-u-boot.bin-voncajus", "BIN")
else:
bd.exec("era", "0xfff60000")
bd.exec("prog", "0xfff60000", f"socrates-abb/{b.date}/u-boot-socrates.bin", "BIN")
bd.bdi_reset_board_run()
if ubma is not None:
ub = ubma
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ub.interactive()
def ub_check_version(
resfiles: list,
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
check if installed U-Boot version is the same as in
tftp directory.
"""
with lab or tbot.acquire_lab() as lh:
r = get_path(lh.tftp_root_path) + "/" + get_path(lh.tftp_dir_board)
spl_vers = None
ub_vers = None
splfiles = ["MLO", "SPL"]
ubfiles = ["u-boot.img", "u-boot-socrates.bin", "u-boot.bin", "u-boot-dtb.imx", "u-boot-dtb.bin"]
for f in resfiles:
if spl_vers == None:
if any(s in f for s in splfiles):
log_event.doc_begin("get_spl_vers")
spl_vers = lh.exec0(linux.Raw(f'strings {r}/{f} | grep --color=never "U-Boot SPL 2"'))
spl_vers = spl_vers.strip()
log_event.doc_tag("ub_spl_new_version", spl_vers)
log_event.doc_end("get_spl_vers")
tbot.log.message(tbot.log.c(f"found in image U-Boot SPL version {spl_vers}").green)
if ub_vers == None:
if any(s in f for s in ubfiles):
log_event.doc_begin("get_ub_vers")
ub_vers = lh.exec0(linux.Raw(f'strings {r}/{f} | grep --color=never "U-Boot 2"'))
for l in ub_vers.split('\n'):
if ":" in l:
ub_vers = l.strip()
if ub_vers[0] == 'V':
ub_vers = ub_vers[1:]
log_event.doc_tag("ub_ub_new_version", ub_vers)
log_event.doc_end("get_ub_vers")
tbot.log.message(tbot.log.c(f"found in image U-Boot version {ub_vers}").green)
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
if spl_vers != None:
if spl_vers not in ub.bootlog:
raise RuntimeError(f"{spl_vers} not found.")
tbot.log.message(tbot.log.c(f"found U-Boot SPL version {spl_vers} installed").green)
if ub_vers == None:
raise RuntimeError(f"No U-Boot version defined")
else:
if ub_vers not in ub.bootlog:
raise RuntimeError(f"{ub_vers} not found.")
tbot.log.message(tbot.log.c(f"found U-Boot version {ub_vers} installed").green)
def gettarget(mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
tc.testsuite(getcpu, getlinuxversion, getyoctoversion, mach=lnx)
def getcpu(mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
lnx.exec0("cat", "/proc/cpuinfo")
def getyoctoversion(
mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
lnx.exec0("cat", "/etc/os_release")
def selftest_board_linux(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test board's linux."""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
try:
b = cx.enter_context(tbot.acquire_board(lh))
except NotImplementedError:
tbot.skip("No board available")
lnx = cx.enter_context(tbot.acquire_linux(b))
mach.selftest_machine_shell(lnx)
def selftest_with_linux(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test the tbot.with_linux decorator."""
with lab or selftest.SelftestHost() as lh:
with SubstituteBoard():
# Call without anything
selftest_decorated_linux()
# Call with labhost
selftest_decorated_linux(lh)
# Call with Linux
with tbot.acquire_board(lh) as b:
with tbot.acquire_linux(b) as lnx:
selftest_decorated_linux(lnx)
def selftest_with_uboot(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test the tbot.with_uboot decorator."""
with lab or selftest.SelftestHost() as lh:
with SubstituteBoard():
# Call without anything
selftest_decorated_uboot()
# Call with labhost
selftest_decorated_uboot(lh)
# Call with U-Boot
with tbot.acquire_board(lh) as b:
with tbot.acquire_uboot(b) as ub:
selftest_decorated_uboot(ub)
def checkswupdate(
mach: typing.Optional[linux.LinuxMachine] = None,
**kwargs: typing.Any,
) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
version = lnx.exec("/usr/bin/swupdate", "--version")
tbot.log.message(f"SWUpdate detected version {version}")
def qemu_uboot_testcases(
lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
try:
b = cx.enter_context(tbot.acquire_board(lh))
ub = cx.enter_context(tbot.acquire_uboot(b))
except NotImplementedError:
b = cx.enter_context(QemuBoard(lh))
ub = cx.enter_context(QemuUBoot(b))
tbot.tc.testsuite(
uboot_verify_version,
ub=ub,
)
def ari_ub_check_hab(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
u-boot check hab_auth works as expected
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
load_addr = "10000000"
t = lh.tftp_dir / "testhabfile-pad-ivt.bin.signed"
ub.exec0("tftp", load_addr, ge.get_ub_tftp_path(lh, t))
ret = ub.exec0("hab_auth_img", load_addr,
linux.special.Raw("${filesize}"))
if "No HAB Events Found" in ret:
tbot.log.message(tbot.log.c("Info: no HAB events.").green)
else:
raise RuntimeError("HAB events found")
t = lh.tftp_dir / "boot-pad-ivt.scr.bin.signed"
ub.exec0("tftp", load_addr, ge.get_ub_tftp_path(lh, t))
ret = ub.exec0("hab_auth_img", load_addr,
linux.special.Raw("${filesize}"))
if "No HAB Events Found" in ret:
tbot.log.message(tbot.log.c("Info: no HAB events.").green)
else:
raise RuntimeError("HAB events found")
t = lh.tftp_dir / "testhabfile-pad-ivt.bin.signed.error"
ub.exec0("tftp", load_addr, ge.get_ub_tftp_path(lh, t))
ret = ub.exec0("hab_auth_img", load_addr,
linux.special.Raw("${filesize}"))
if "HAB_FAILURE" in ret:
tbot.log.message(
tbot.log.c("Info: HAB events, expected!").green)
else:
raise RuntimeError("HAB events not found")
def ari_ub_update(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
update u-boot
"""
with lab or tbot.acquire_lab() as lh:
# now we know what we have normally as bootmode
# we want to update this bootmode with new U-Boot
# so delete bootmode in flags and set other bootmode
if "bootmodesd" in tbot.flags:
bm = "sd"
tbot.flags.remove("bootmodesd")
lh.set_bootmode("spi")
elif "bootmodespi" in tbot.flags:
bm = "spi"
tbot.flags.remove("bootmodespi")
lh.set_bootmode("sd")
else:
raise RuntimeError("Set bootmode")
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ari_ub_set_env(ub)
loadaddr = "0x12000000"
ret = ub.exec("ping", "192.168.1.1")
while ret[0] != 0:
ret = ub.exec("ping", "192.168.1.1")
ub.exec0("mw", loadaddr, "0", "0x4000")
ub.exec0("tftp", loadaddr, b.envdir)
ub.exec0("env", "import", "-t", loadaddr)
if bm == "sd":
ub.exec0("run", "upd_uboot_sd")
else:
ub.exec0("run", "upd_uboot")
return
def selftest_board_linux(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test board's linux."""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
try:
b = cx.enter_context(tbot.acquire_board(lh))
except NotImplementedError:
tbot.log.message(
tbot.log.c("Skipped").yellow.bold + " because no board available."
)
return
lnx = cx.enter_context(tbot.acquire_linux(b))
mach.selftest_machine_shell(lnx)
def qemu_linux_testcases(
lab: typing.Optional[tbot.selectable.LabHost] = None,
board_linux: typing.Optional[board.LinuxMachine] = None,
) -> None:
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
if board_linux is not None:
lnx = board_linux
else:
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
tbot.tc.testsuite(
linux_verify_uname,
linux_regular_file_operations,
lnx=lnx,
)
def swupdateweb(
mach: typing.Optional[linux.LinuxMachine] = None,
ip=None,
path=None,
) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
if ip is None:
raise RuntimeError(f"IP Address is not set")
if path is None:
raise RuntimeError(f"Path to SWU is not set")
return SWUpdater(path, ip).update()
def ari_ub_basic_checks(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
u-boot check basic stuff
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ari_ub_set_env(ub)
ari_ub_check_bootlog(ub)
# check version
ari_ub_check_version(lh, b, ub)
# ethernet works?
ub.exec0("ping", lh.serverip)
# mmc work
ub.exec0("mmc", "info")
# check led / gpio
ari_ub_check_led(ub)
# check i2c
ari_ub_check_i2c(lh, b, ub)
# check hab_auth_img command
ari_ub_check_hab(lh, b, ub)
# must start from scratch
# check multi dtb select
ari_ub_check_multi_dtb_select()
ari_ub_check_empty_environment()
def ari_ub_check_i2c(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
check i2c probe and dumps
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ub.exec0("i2c", "dev", "0")
log = ub.exec0("i2c", "probe")
if "58 59 71" not in log:
raise RuntimeError("Probing bus 0 failed res: {log}")
ub.exec0("i2c", "dev", "1")
log = ub.exec("i2c", "probe")
if log[0] == 0:
raise RuntimeError("Probing bus 1 failed res: {log}")
ub.exec0("i2c", "dev", "2")
log = ub.exec0("i2c", "probe")
dump_file = i2c_dump_0_58_7
if "20 4D 68" not in log:
if "20 4B 68" not in log:
raise RuntimeError("Probing bus 2 failed res: {log}")
else:
dump_file = i2c_dump_0_58_4
ge.ub_check_i2c_dump(ub, "0", "0x58", dump_file)
def socrates_ub_usb(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubma: typing.Optional[board.UBootShell] = None,
) -> None:
"""
start usb and check if there is a usb storage device
"""
with contextlib.ExitStack() as cx:
if lab is not None:
lh = lab
else:
lh = cx.enter_context(tbot.acquire_lab())
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubma is not None:
ub = ubma
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ret = ub.exec0("usb", "start")
if "1 Storage Device" not in ret:
raise RuntimeError("no usb storage device found")
ret = ub.exec0("usb", "storage")
if "Vendor: Kingston" not in ret:
raise RuntimeError("vendor not Kingston")
if "Capacity: 954.0 MB" not in ret:
raise RuntimeError("wrong Capacity")
ub.exec0("usb", "read", "100000", "0", "1000")
ret = ub.exec0("crc", "100000", "80000")
if "e336ee43" not in ret:
raise RuntimeError(f"wrong checksum f{ret}")
def wandboard_check_iperf(
lab: linux.LinuxShell = None,
board: board.Board = None,
blx: linux.LinuxShell = None,
cycles: str = "5",
minval: str = "70",
intervall: str = "5",
) -> bool:
"""
check networkperformance with iperf
"""
with contextlib.ExitStack() as cx:
if lab is not None:
lh = lab
else:
lh = cx.enter_context(tbot.acquire_lab())
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if blx is not None:
lnx = blx
else:
lnx = cx.enter_context(tbot.acquire_linux(b))
ge.lx_check_iperf(lh,
lnx,
intervall=intervall,
cycles=cycles,
minval=minval,
filename="iperf.dat",
showlog=True)
return True
def interactive_linux() -> None:
with tbot.acquire_lab() as lh:
with tbot.acquire_board(lh) as b:
with tbot.acquire_linux(b) as lnx:
lnx.interactive()
def interactive_uboot() -> None:
with tbot.acquire_lab() as lh:
with tbot.acquire_board(lh) as b:
with tbot.acquire_uboot(b) as ub:
ub.interactive()
def interactive_board() -> None:
with tbot.acquire_lab() as lh:
with tbot.acquire_board(lh) as b:
b.channel.attach_interactive()
def ari_ub_dump_register(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
dump U-Boot register into file
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ge.ub_create_revfile(ub, path + "ccm.dump", "0x20c4000",
"0x20c408c")
ge.ub_create_revfile(ub, path + "ccm_an.dump", "0x20c8000",
"0x20c8190")
ge.ub_create_revfile(ub, path + "pinmux.dump", "0x20e0000",
"0x20e093c")
ge.ub_create_revfile(ub, path + "usdhc1.dump", "0x2190000",
"0x21900cc")
ge.ub_create_revfile(ub, path + "usdhc2.dump", "0x2194000",
"0x21940cc")
ge.ub_create_revfile(ub, path + "gpio1.dump", "0x209c000",
"0x209c020")
ge.ub_create_revfile(ub, path + "gpio2.dump", "0x20a0000",
"0x20a0020")
ge.ub_create_revfile(ub, path + "gpio3.dump", "0x20a4000",
"0x20a4020")
ge.ub_create_revfile(ub, path + "gpio4.dump", "0x20a8000",
"0x20a8020")
ge.ub_create_revfile(ub, path + "gpio5.dump", "0x20ac000",
"0x20ac020")
ge.ub_create_revfile(ub, path + "gpio6.dump", "0x20b0000",
"0x20b0020")
ge.ub_create_revfile(ub, path + "gpio7.dump", "0x20b4000",
"0x20b4020")
ge.ub_create_revfile(ub, path + "pwm1.dump", "0x2080000",
"0x2080018")
ge.ub_create_revfile(ub, path + "pwm2.dump", "0x2084000",
"0x2084018")
ge.ub_create_revfile(ub, path + "pwm3.dump", "0x2088000",
"0x2088018")
ge.ub_create_revfile(ub, path + "pwm4.dump", "0x208c000",
"0x208c018")
ge.ub_create_revfile(ub, path + "ecspi1.dump", "0x2008000",
"0x2008044")
ge.ub_create_revfile(ub, path + "ecspi2.dump", "0x200c000",
"0x200c044")
ge.ub_create_revfile(ub, path + "ecspi3.dump", "0x2010000",
"0x2010044")
ge.ub_create_revfile(ub, path + "ecspi4.dump", "0x2014000",
"0x2014044")
ge.ub_create_revfile(ub, path + "enet1.dump", "0x2188000",
"0x21881c4")
ge.ub_create_revfile(ub, path + "ipu1.dump", "0x2600000",
"0x260028c")
ge.ub_create_revfile(ub, path + "ipu1_dmac.dump", "0x2608000",
"0x2608108")
ge.ub_create_revfile(ub, path + "ipu1_dp.dump", "0x2618000",
"0x2618118")
ge.ub_create_revfile(ub, path + "ipu1_ic.dump", "0x2620000",
"0x262028")
ge.ub_create_revfile(ub, path + "ipu1_csi0.dump", "0x2630000",
"0x26300f0")
ge.ub_create_revfile(ub, path + "ipu1_csi1.dump", "0x2638000",
"0x26380f0")
ge.ub_create_revfile(ub, path + "ipu1_diu0.dump", "0x2640000",
"0x2640178")
ge.ub_create_revfile(ub, path + "ipu1_diu1.dump", "0x2648000",
"0x2648178")
ge.ub_create_revfile(ub, path + "ipu1_dc.dump", "0x2658000",
"0x26581cc")
def ari_ub_check_register(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
check U-Boot register
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
if "lg4573" in ub.bootlog:
ub.exec0("lgset")
path = "tc/aristainetos/files/"
files = [
"ccm.dump",
"ccm_an.dump",
"pinmux.dump",
"usdhc1.dump",
"usdhc2.dump",
"gpio1.dump",
"gpio2.dump",
"gpio3.dump",
"gpio4.dump",
"gpio5.dump",
"gpio6.dump",
"gpio7.dump",
"pwm1.dump",
"pwm2.dump",
"pwm3.dump",
"pwm4.dump",
"ecspi1.dump",
"ecspi2.dump",
"ecspi3.dump",
"ecspi4.dump",
"enet1.dump",
"ipu1.dump",
"ipu1_dmac.dump",
"ipu1_dp.dump",
"ipu1_ic.dump",
"ipu1_csi0.dump",
"ipu1_csi1.dump",
"ipu1_diu0.dump",
"ipu1_diu1.dump",
"ipu1_dc.dump",
"ldb.dump",
]
files = ["pinmux.dump"]
files = [
"ipu1.dump",
"ipu1_dmac.dump",
"ipu1_dp.dump",
"ipu1_ic.dump",
"ipu1_csi0.dump",
"ipu1_csi1.dump",
"ipu1_diu0.dump",
"ipu1_diu1.dump",
"ipu1_dc.dump",
"ldb.dump",
]
files = [
"gpio1.dump",
"gpio2.dump",
"gpio3.dump",
"gpio4.dump",
"gpio5.dump",
"gpio6.dump",
"gpio7.dump",
]
files = [
"ccm.dump",
"ccm_an.dump",
]
files = [
"ipu1.dump",
"ipu1_dmac.dump",
"ipu1_dp.dump",
"ipu1_ic.dump",
"ipu1_csi0.dump",
"ipu1_csi1.dump",
"ipu1_diu0.dump",
"ipu1_diu1.dump",
"ipu1_dc.dump",
"ldb.dump",
"ccm.dump",
"ccm_an.dump",
]
files = ["pinmux.dump"]
for f in files:
#ge.ub_check_revfile(ub, path + f, "diff_pinmux.txt", "/home/hs/data/Entwicklung/prozessordoku/imx6/IMX6SDLRM.txt")
ge.ub_check_revfile(ub, path + f)
