Add PawnIO LpcCrOSEC device backend

Steve-Tech · Steve-Tech · commit a13dffbaaa94 · 2025-04-08T22:29:52.000+10:00
diff --git a/cros_ec_python/__init__.py b/cros_ec_python/__init__.py
@@ -7,5 +7,8 @@
 from .commands import memmap, general, features, pwm, leds, thermal, framework_laptop
 from .exceptions import ECError
 from .devices.lpc import CrosEcLpc
-if __import__("os").name == "posix":
-    from .devices.dev import CrosEcDev
+match __import__("os").name:
+    case "posix":
+        from .devices.dev import CrosEcDev
+    case "nt":
+        from .devices.pawnio import CrosEcPawnIO
diff --git a/cros_ec_python/commands/general.py b/cros_ec_python/commands/general.py
@@ -82,7 +82,7 @@ def get_build_info(ec: CrosEcClass) -> str:
     :param ec: The CrOS_EC object.
     :return: The build info as a string.
     """
-    resp = ec.command(0, EC_CMD_GET_BUILD_INFO, 0, 0xfc, warn=False)
+    resp = ec.command(0, EC_CMD_GET_BUILD_INFO, 0, 0xf8, warn=False)
     return resp.decode("utf-8").rstrip("\x00")
 
 
diff --git a/cros_ec_python/cros_ec.py b/cros_ec_python/cros_ec.py
@@ -9,7 +9,7 @@
 
 from .constants.COMMON import *
 from .baseclass import CrosEcClass
-from .devices import lpc
+from .devices import lpc, pawnio
 if sys.platform == "linux":
     from .devices import dev
 else:
@@ -25,7 +25,9 @@ class DeviceTypes(Enum):
     This is the Linux device interface, which uses the `/dev/cros_ec` device file.
     *Recommended if you have the `cros_ec_dev` kernel module loaded.*
     """
-    LPC = 1
+    PawnIO = 1
+    "This is the Windows PawnIO interface, which is recommended on Windows Systems."
+    LPC = 2
     "This manually talks to the EC over the LPC interface, using the ioports."
 
 
@@ -38,6 +40,8 @@ def pick_device() -> DeviceTypes:
     """
     if dev and dev.CrosEcDev.detect():
         return DeviceTypes.LinuxDev
+    elif pawnio and pawnio.CrosEcPawnIO.detect():
+        return DeviceTypes.PawnIO
     elif lpc and lpc.CrosEcLpc.detect():
         return DeviceTypes.LPC
     else:
@@ -58,6 +62,8 @@ def get_cros_ec(dev_type: DeviceTypes | None = None, **kwargs) -> CrosEcClass:
     match dev_type:
         case DeviceTypes.LinuxDev:
             return dev.CrosEcDev(**kwargs)
+        case DeviceTypes.PawnIO:
+            return pawnio.CrosEcPawnIO(**kwargs)
         case DeviceTypes.LPC:
             return lpc.CrosEcLpc(**kwargs)
         case _:
diff --git a/cros_ec_python/devices/pawnio.py b/cros_ec_python/devices/pawnio.py
@@ -0,0 +1,185 @@
+import struct
+import warnings
+import ctypes
+from ctypes import wintypes
+from ctypes import util as ctypes_util
+
+from ..baseclass import CrosEcClass
+from ..constants.COMMON import *
+from ..exceptions import ECError
+
+
+class CrosEcPawnIO(CrosEcClass):
+    """
+    Class to interact with the EC using the Windows PawnIO driver.
+    """
+
+    def __init__(self, dll: str | None = None, bin: str | None = None):
+        """
+        Initialise the EC using the Linux cros_ec device.
+        :param dll: Path to the DLL to use. If None, will use the default path.
+        :param bin: Path to the binary to load. If None, will use the default path.
+        """
+
+        self.bin = bin or "LpcCrOSEC.bin"
+
+        if dll or (dll := ctypes_util.find_library("PawnIOLib.dll")):
+            self.pawniolib = ctypes.OleDLL(dll)
+        else:
+            # Let this raise an error if we can't find it
+            self.pawniolib = ctypes.OleDLL("C:\\Program Files\\PawnIO\\PawnIOLib.dll")
+
+        self.pawniolib.pawnio_version.argtypes = [ctypes.POINTER(wintypes.ULONG)]
+        self.pawniolib.pawnio_open.argtypes = [ctypes.POINTER(wintypes.HANDLE)]
+        self.pawniolib.pawnio_load.argtypes = [
+            wintypes.HANDLE,
+            ctypes.POINTER(ctypes.c_ubyte),
+            ctypes.c_size_t,
+        ]
+        self.pawniolib.pawnio_execute.argtypes = [
+            wintypes.HANDLE,
+            ctypes.c_char_p,
+            ctypes.POINTER(ctypes.c_ulonglong),
+            ctypes.c_size_t,
+            ctypes.POINTER(ctypes.c_ulonglong),
+            ctypes.c_size_t,
+            ctypes.POINTER(ctypes.c_size_t),
+        ]
+        self.pawniolib.pawnio_close.argtypes = [wintypes.HANDLE]
+
+        self.ec_init()
+
+    def __del__(self):
+        self.ec_exit()
+
+    def _pawnio_version(self) -> str:
+        version = wintypes.ULONG()
+        self.pawniolib.pawnio_version(ctypes.byref(version))
+        major, minor, patch = (
+            version.value >> 16,
+            (version.value >> 8) & 0xFF,
+            version.value & 0xFF,
+        )
+        return f"{major}.{minor}.{patch}"
+
+    def _pawnio_open(self) -> None:
+        self.handle = wintypes.HANDLE()
+        self.pawniolib.pawnio_open(ctypes.byref(self.handle))
+
+    def _pawnio_load(self, filepath: str) -> None:
+        with open(filepath, "rb") as file:
+            blob = file.read()
+        size = len(blob)
+        blob_array = (ctypes.c_ubyte * size)(*blob)
+        self.pawniolib.pawnio_load(self.handle, blob_array, size)
+
+    def _pawnio_execute(
+        self,
+        function: str,
+        in_data: bytes,
+        out_size: bytes,
+        in_size: int | None = None,
+    ) -> tuple[int | ctypes.Array]:
+        function_bytes = function.encode("utf-8")
+        in_size = in_size if in_size is not None else len(in_data)
+        in_array = (ctypes.c_ulonglong * in_size)(*in_data)
+        out_array = (ctypes.c_ulonglong * out_size)()
+        return_size = ctypes.c_size_t()
+
+        self.pawniolib.pawnio_execute(
+            self.handle,
+            function_bytes,
+            in_array,
+            in_size,
+            out_array,
+            out_size,
+            ctypes.byref(return_size),
+        )
+
+        return (return_size.value, out_array)
+
+    def _pawnio_close(self):
+        self.pawniolib.pawnio_close(self.handle)
+
+    @staticmethod
+    def detect() -> bool:
+        # TODO
+        return True
+
+    def ec_init(self) -> None:
+        self._pawnio_open()
+        self._pawnio_load(self.bin)
+
+    def ec_exit(self) -> None:
+        """
+        Close the file on exit.
+        """
+        if hasattr(self, "handle"):
+            self._pawnio_close()
+
+    def command(
+        self,
+        version: Int32,
+        command: Int32,
+        outsize: Int32,
+        insize: Int32,
+        data: bytes = None,
+        warn: bool = True,
+    ) -> bytes:
+        """
+        Send a command to the EC and return the response.
+        :param version: Command version number (often 0).
+        :param command: Command to send (EC_CMD_...).
+        :param outsize: Outgoing length in bytes.
+        :param insize: Max number of bytes to accept from the EC.
+        :param data: Outgoing data to EC.
+        :param warn: Whether to warn if the response size is not as expected. Default is True.
+        :return: Incoming data from EC.
+        """
+        # LpcCrOSEC returns the EC result too
+        pawn_insize = insize + 1
+        header = struct.pack("<HB", command, version)
+        size, res = self._pawnio_execute(
+            "ioctl_ec_command",
+            header + (data or b""),
+            pawn_insize,
+            in_size=outsize + len(header),
+        )
+
+        if size != pawn_insize and warn:
+            warnings.warn(
+                f"Expected {pawn_insize} bytes, got {size} back from PawnIO",
+                RuntimeWarning,
+            )
+
+        # If the first cell is negative, it has failed
+        # Also convert to signed
+        if res[0] & (1 << 63):
+            signed_res = res[0] - (1 << 64)
+            raise ECError(-signed_res)
+
+        # Otherwise it's the length
+        if res[0] != insize and warn:
+            warnings.warn(
+                f"Expected {pawn_insize} bytes, got {res[0]} back from EC",
+                RuntimeWarning,
+            )
+
+        # The pawn cells are 64bit but all the values should fit in 8 bits
+        return bytes(res[1:])
+
+    def memmap(self, offset: Int32, num_bytes: Int32) -> bytes:
+        """
+        Read memory from the EC.
+        :param offset: Offset to read from.
+        :param num_bytes: Number of bytes to read.
+        :return: Bytes read from the EC.
+        """
+        size, res = self._pawnio_execute(
+            "ioctl_ec_readmem", offset.to_bytes(1), num_bytes
+        )
+
+        array = bytearray(size)
+        for i in range(size):
+            array[i] = res[i]
+        return bytes(array)
diff --git a/tests/devices.py b/tests/devices.py
@@ -1,10 +1,19 @@
 import unittest
-from cros_ec_python import CrosEcClass, CrosEcDev, CrosEcLpc, general
+import sys
+from cros_ec_python import CrosEcClass, CrosEcLpc, general
 from cros_ec_python.constants import MEMMAP
 
+
+if sys.platform == "linux":
+    from cros_ec_python import CrosEcDev
+elif sys.platform == "win32":
+    from cros_ec_python import CrosEcPawnIO
+
+
 ec: CrosEcClass | None = None
 
 
+@unittest.skipUnless(sys.platform == "linux", "requires Linux")
 class TestLinuxDev(unittest.TestCase):
     def test1_init(self):
         global ec
@@ -20,6 +29,22 @@ def test3_hello(self):
         resp = ec.command(0, general.EC_CMD_HELLO, len(data), 4, data)
         self.assertEqual(resp, b'\xa4\xb3\xc2\xd1')
 
+@unittest.skipUnless(sys.platform == "win32", "requires Windows")
+class TestWinPawnIO(unittest.TestCase):
+    def test1_init(self):
+        global ec
+        ec = CrosEcPawnIO()
+        self.assertIsNotNone(ec)
+
+    def test2_memmap(self):
+        resp = ec.memmap(MEMMAP.EC_MEMMAP_ID, 2)
+        self.assertEqual(resp, b'EC')
+
+    def test3_hello(self):
+        data = b'\xa0\xb0\xc0\xd0'
+        resp = ec.command(0, general.EC_CMD_HELLO, len(data), 4, data)
+        self.assertEqual(resp, b'\xa4\xb3\xc2\xd1')
+
 
 class TestLPC(unittest.TestCase):
     def test1_init(self):
