imx6ull: Test runner

JIRA: CI-72

runner.py

@@ -21,6 +21,7 @@
     ARMv7A9Zynq7000QemuTarget,
     STM32L4x6Target,
     Zynq7000ZedboardTarget,
+    IMX6ULLEvkTarget,
 )
 from trunner.ctx import TestContext
 from trunner.target.base import TargetBase
@@ -211,6 +212,7 @@ def resolve_targets_and_hosts() -> Tuple[Dict[str, TargetBase], Dict[str, Host]]
         IMXRT106xEvkTarget,
         IMXRT117xEvkTarget,
         Zynq7000ZedboardTarget,
+        IMX6ULLEvkTarget,
     ]
 
     hosts = [EmulatorHost, RpiHost]

trunner/harness/plo.py

@@ -100,7 +100,9 @@ def send_cmd(self, cmd: str):
             self.dut.send(cmd + "\r")
             self.dut.expect_exact(cmd)
         except pexpect.TIMEOUT as e:
-            raise PloError("failed to read echoed command", cmd=cmd, output=self.dut.before) from e
+            raise PloError(
+                "failed to read echoed command", cmd=cmd, output=self.dut.before
+            ) from e
 
     def cmd(self, cmd: str, timeout: Optional[int] = None):
         """Sends command and waits for it to finish.
@@ -136,6 +138,23 @@ def erase(self, device: str, offset: int, size: int, timeout: Optional[int] = No
             e.cmd = cmd
             raise e
 
+    # fmt: off
+    def jffs2(self, device: str, erase: bool, cleanmarkers_args: tuple, timeout: Optional[int] = None):
+        """Performs jffs2 command."""
+
+        e = "-e" if erase else ""
+
+        cmd = "".join(("jffs2 -d ",
+            f"{device} {e} ",
+            f"-c {cleanmarkers_args[0]}:",
+            f"{cleanmarkers_args[1]}:",
+            f"{cleanmarkers_args[2]}:",
+            f"{cleanmarkers_args[3]}"))
+
+        self.send_cmd(cmd)
+        self._assert_prompt(timeout=timeout)
+    # fmt: on
+
     def app(
         self, device: str, file: str, imap: str, dmap: str, exec: bool = False
     ):  # pylint: disable=redefined-builtin

trunner/target/__init__.py

@@ -1,8 +1,13 @@
 from .base import TargetBase, find_port
 from .armv7m7 import IMXRT106xEvkTarget, IMXRT117xEvkTarget, ARMv7M7Target
 from .armv7m4 import STM32L4x6Target
+from .armv7a7 import IMX6ULLEvkTarget
 from .armv7a9 import Zynq7000ZedboardTarget
-from .emulated import IA32GenericQemuTarget, RISCV64GenericQemuTarget, ARMv7A9Zynq7000QemuTarget
+from .emulated import (
+    IA32GenericQemuTarget,
+    RISCV64GenericQemuTarget,
+    ARMv7A9Zynq7000QemuTarget,
+)
 from .host import HostPCGenericTarget
 
 __all__ = [
@@ -17,4 +22,5 @@
     "Zynq7000ZedboardTarget",
     "TargetBase",
     "find_port",
+    "IMX6ULLEvkTarget",
 ]

trunner/target/armv7a7.py

@@ -0,0 +1,103 @@
+from typing import Callable, Optional
+
+from trunner.dut import Dut, SerialDut
+from trunner.harness import (
+    HarnessBuilder,
+    PloInterface,
+    PloImageLoader,
+    PloImageProperty,
+    ShellHarness,
+    Rebooter,
+    RebooterHarness,
+)
+
+from trunner.harness import TerminalHarness
+from trunner.host import Host
+from trunner.tools import Phoenixd, Psu
+from trunner.types import TestResult, TestOptions
+from .base import TargetBase, find_port
+
+
+class ARMv7A7TargetRebooter(Rebooter):
+    def _set_flash_mode(self, flash):
+        self.host.set_flash_mode(not flash)
+
+
+class PsuPloLoader(TerminalHarness, PloInterface):
+    def __init__(self, dut: Dut, psu: Psu):
+        TerminalHarness.__init__(self)
+        PloInterface.__init__(self, dut)
+        self.psu = psu
+
+    def __call__(self):
+        """Loads plo image to RAM using psu tool and erases an area intended for rootfs."""
+        self.psu.run()
+        self.wait_prompt()
+        self.jffs2("2.0", True, ("0x10", "0x1f0", "0x10000", "0x10"), 90)
+
+
+class ARMv7A7Target(TargetBase, PloInterface, Rebooter):
+    image = PloImageProperty(file="phoenix.disk", source="usb0", memory_bank="nor0")
+    plo_psu_script = "plo-ram.sdp"
+
+    def __init__(
+        self,
+        host: Host,
+        port: str,
+        baudrate: int = 115200,
+    ):
+        dut = SerialDut(port, baudrate, encoding="utf-8", codec_errors="ignore")
+        PloInterface.__init__(self, dut)
+        self.rebooter = ARMv7A7TargetRebooter(host, self.dut)
+        super().__init__()
+
+    @classmethod
+    def from_context(cls, ctx):
+        return cls(ctx.host, ctx.port, ctx.baudrate)
+
+    def flash_dut(self):
+        plo_loader = PsuPloLoader(
+            dut=self.dut,
+            psu=Psu(self.plo_psu_script, self.boot_dir()),
+        )
+
+        loader = PloImageLoader(
+            dut=self.dut,
+            rebooter=self.rebooter,
+            image=self.image,
+            plo_loader=plo_loader,
+            phoenixd=Phoenixd(directory=self.boot_dir()),
+        )
+
+        loader()
+
+    # Setup environment for tests
+    def build_test(self, test: TestOptions) -> Callable[[], Optional[TestResult]]:
+        builder = HarnessBuilder()
+
+        if test.should_reboot:
+            builder.add(RebooterHarness(self.rebooter))
+
+        if test.shell is not None:
+            builder.add(ShellHarness(self.dut, self.shell_prompt, test.shell.cmd))
+
+        builder.add(test.harness)
+
+        return builder.get_harness()
+
+
+class IMX6ULLEvkTarget(ARMv7A7Target):
+    name = "armv7a7-imx6ull-evk"
+
+    def __init__(self, host: Host, port: Optional[str] = None, baudrate: int = 115200):
+        port = find_port(
+            "10c4:ea60"
+        )  # vid:pid Product=CP2102 USB to UART Bridge Controller
+
+        super().__init__(host, port, baudrate)
+
+    # IMX6ULL with system jffs2 use nor0 as space to hold data
+    image = PloImageProperty(file="phoenix.disk", source="usb0", memory_bank="nor0")
+
+    def build_test(self, test: TestOptions) -> Callable[[], Optional[TestResult]]:
+        return super().build_test(test)