Add GPIO Driver for gzvich GZ-HK401X 4 Port HDMI USB KVM Switch

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 4.131
+current_version = 4.145
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}

.gitignore

@@ -19,3 +19,4 @@
 *.pyc
 *.swp
 /venv/
+*.code-workspace

PKGBUILD

@@ -39,15 +39,15 @@ for _variant in "${_variants[@]}"; do
 	pkgname+=(kvmd-platform-$_platform-$_board)
 done
 pkgbase=kvmd
-pkgver=4.131
+pkgver=4.145
 pkgrel=1
 pkgdesc="The main PiKVM daemon"
 url="https://github.com/pikvm/kvmd"
 license=(GPL)
 arch=(any)
 depends=(
-	"python>=3.13"
-	"python<3.14"
+	"python>=3.14"
+	"python<3.15"
 	python-yaml
 	python-ruamel-yaml
 	python-aiohttp
@@ -97,7 +97,7 @@ depends=(
 	certbot
 	"raspberrypi-io-access>=0.7"
 	raspberrypi-utils
-	"ustreamer>=6.41"
+	"ustreamer>=6.47"
 
 	# Systemd UDEV bug
 	"systemd>=248.3-2"
@@ -106,9 +106,6 @@ depends=(
 	# https://archlinuxarm.org/forum/viewtopic.php?f=15&t=15725&start=40
 	"zstd>=1.5.1-2.1"
 
-	# Possible hotfix for the new os update
-	openssl-1.1
-
 	# Bootconfig
 	dos2unix
 	parted
@@ -225,7 +222,7 @@ for _variant in "${_variants[@]}"; do
 		backup=()
 
 		pkgdesc=\"PiKVM platform configs - $_platform for $_board\"
-		depends=(kvmd=$pkgver-$pkgrel \"linux-rpi-pikvm>=6.12.56-1\" \"raspberrypi-bootloader-pikvm>=20251031-1\")
+		depends=(kvmd=$pkgver-$pkgrel \"linux-rpi-pikvm>=6.12.56-5\" \"raspberrypi-bootloader-pikvm>=20251031-1\")
 
 		if [[ $_base == v0 ]]; then
 			depends=(\"\${depends[@]}\" platformio-core avrdude make patch)

configs/os/boot-config/v4plus-hdmi-rpi4.txt

@@ -15,10 +15,6 @@ dtoverlay=dwc2,dr_mode=peripheral
 dtoverlay=tc358743,4lane=1
 dtoverlay=tc358743-audio
 
-# Passthrough
-dtoverlay=vc4-kms-v3d
-disable_overscan=1
-
 # I2C (display)
 dtparam=i2c_arm=on
 

configs/os/modules-load/v2-hdmi.conf

@@ -1,3 +1,4 @@
 dwc2
 libcomposite
 tc358743
+nbd

configs/os/modules-load/v2-hdmiusb.conf

@@ -1,2 +1,3 @@
 dwc2
 libcomposite
+nbd

configs/os/modules-load/v3-hdmi.conf

@@ -2,3 +2,4 @@ dwc2
 libcomposite
 tc358743
 i2c-dev
+nbd

configs/os/modules-load/v4mini-hdmi.conf

@@ -2,3 +2,4 @@ dwc2
 libcomposite
 tc358743
 i2c-dev
+nbd

configs/os/modules-load/v4plus-hdmi.conf

@@ -2,3 +2,4 @@ dwc2
 libcomposite
 tc358743
 i2c-dev
+nbd

configs/os/udev/common.rules

@@ -3,6 +3,7 @@
 
 ACTION!="remove", KERNEL=="ttyACM[0-9]*", SUBSYSTEM=="tty", SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="eda3", SYMLINK+="kvmd-hid-bridge"
 ACTION!="remove", KERNEL=="ttyACM[0-9]*", SUBSYSTEM=="tty", SUBSYSTEMS=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="1080", SYMLINK+="kvmd-switch"
+ACTION!="remove", KERNEL=="nbd15", SUBSYSTEM=="block", GROUP="kvmd", SYMLINK+="kvmd-nbd"
 
 # Disable USB autosuspend for critical devices
 ACTION!="remove", SUBSYSTEM=="usb", ATTR{idVendor}=="1209", ATTR{idProduct}=="eda3", GOTO="kvmd-usb"

kvmd/__init__.py

@@ -20,4 +20,9 @@
 # ========================================================================== #
 
 
-__version__ = "4.131"
+__version__ = "4.145"
+
+
+import multiprocessing
+
+multiprocessing.set_start_method("fork")  # FIXME

kvmd/aiogp.py

@@ -70,10 +70,10 @@ async def poll(self) -> None:
             self.__loop = asyncio.get_running_loop()
             self.__thread.start()
             try:
-                await aiotools.run_async(self.__thread.join)
+                await asyncio.to_thread(self.__thread.join)
             finally:
                 self.__stop_event.set()
-                await aiotools.run_async(self.__thread.join)
+                await asyncio.to_thread(self.__thread.join)
 
     def __run(self) -> None:
         assert self.__values is None

kvmd/aiomulti.py

@@ -20,64 +20,205 @@
 # ========================================================================== #
 
 
+import os
+import signal
+import asyncio
 import multiprocessing
+import multiprocessing.queues
+import multiprocessing.connection
 import queue
+import logging
 
+from typing import Callable
 from typing import Type
 from typing import TypeVar
 from typing import Generic
+from typing import Any
 
-from . import aiotools
+import setproctitle
 
 
 # =====
-_QueueItemT = TypeVar("_QueueItemT")
+def rename_process(suffix: str) -> None:
+    setproctitle.setproctitle(f"kvmd/{suffix}: {setproctitle.getproctitle()}")
 
 
-async def queue_get_last(  # pylint: disable=invalid-name
-    q: "multiprocessing.Queue[_QueueItemT]",
-    timeout: float,
-) -> tuple[bool, (_QueueItemT | None)]:
+# =====
+class AioMpProcess:
+    def __init__(
+        self,
+        name: str,
+        target: Callable[..., None],
+        args: tuple[Any, ...]=(),
+    ) -> None:
+
+        self.__name = name
+        self.__target = target
 
-    return (await aiotools.run_async(queue_get_last_sync, q, timeout))
+        self.__proc = multiprocessing.Process(
+            target=self.__target_wrapper,
+            args=args,
+            daemon=True,
+            name=name,
+        )
 
+    def __target_wrapper(self, *args: Any, **kwargs: Any) -> None:
+        logger = logging.getLogger(self.__target.__module__)
+        logger.info("Started process kvmd/%s: pid=%s", self.__name, os.getpid())
+        os.setpgrp()
+        rename_process(self.__name)
+        self.__target(*args, **kwargs)
 
-def queue_get_last_sync(  # pylint: disable=invalid-name
-    q: "multiprocessing.Queue[_QueueItemT]",
-    timeout: float,
-) -> tuple[bool, (_QueueItemT | None)]:
+    def is_alive(self) -> bool:
+        return self.__proc.is_alive()
 
-    try:
-        item = q.get(timeout=timeout)
-        while not q.empty():
-            item = q.get()
-        return (True, item)
-    except queue.Empty:
-        return (False, None)
+    @property
+    def exitcode(self) -> (int | None):
+        return self.__proc.exitcode
+
+    def start(self) -> None:
+        self.__proc.start()
+
+    def send_sigterm(self) -> None:
+        if self.__proc.pid is None:
+            return
+        try:
+            os.kill(self.__proc.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+
+    def sendpg_sigkill(self) -> None:
+        if self.__proc.pid is None:
+            return
+        try:
+            own = os.getpgid(os.getpid())
+            target = os.getpgid(self.__proc.pid)
+            if own != target:
+                os.killpg(target, signal.SIGKILL)
+            else:
+                os.kill(self.__proc.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+
+    async def async_join(self, timeout: float=0.0) -> bool:
+        if self.__proc.pid is None:
+            return False
+
+        prev = self.__proc.is_alive()
+
+        loop = asyncio.get_running_loop()
+        fut = asyncio.Future()  # type: ignore
+        try:
+            fd = os.pidfd_open(self.__proc.pid, os.PIDFD_NONBLOCK)
+        except ProcessLookupError:
+            pass
+        else:
+            try:
+                loop.add_reader(fd, fut.set_result, None)
+                fut.add_done_callback(lambda _: loop.remove_reader(fd))
+                if timeout > 0:
+                    await asyncio.wait_for(fut, timeout)
+                else:
+                    await fut
+            except TimeoutError:
+                pass
+            finally:
+                try:
+                    loop.remove_reader(fd)
+                finally:
+                    os.close(fd)
+
+        # Crank the internal MP machinery and return a status code.
+        # It should be non-blocking.
+        new = self.__proc.is_alive()
+        if prev != new:
+            self.__get_logger().info("Stopped kvmd/%s: exitcode=%s", self.__name, self.exitcode)
+        return new
+
+    def __get_logger(self) -> logging.Logger:
+        return logging.getLogger(self.__target.__module__)
 
 
 # =====
-class AioProcessNotifier:
+class AioMpQueue[T](multiprocessing.queues.Queue[T]):
+    def __init__(self, maxsize: int=0) -> None:
+        super().__init__(maxsize=maxsize, ctx=multiprocessing.get_context())
+
+    def get_reader(self) -> multiprocessing.connection.Connection:
+        return self._reader  # type: ignore  # pylint: disable=protected-access
+
+    def get_reader_fd(self) -> int:
+        return self.get_reader().fileno()
+
+    async def async_fetch(self, timeout: float=0.0) -> tuple[bool, (T | None)]:
+        return (await self.__async_get(timeout, False))
+
+    async def async_fetch_last(self, timeout: float=0.0) -> tuple[bool, (T | None)]:
+        return (await self.__async_get(timeout, True))
+
+    async def __async_get(self, timeout: float, last_only: bool) -> tuple[bool, (T | None)]:
+        loop = asyncio.get_running_loop()
+        fut = asyncio.Future()  # type: ignore
+        fd = self.get_reader_fd()
+
+        try:
+            loop.add_reader(fd, fut.set_result, None)
+            fut.add_done_callback(lambda _: loop.remove_reader(fd))
+            if timeout > 0:
+                await asyncio.wait_for(fut, timeout)
+            else:
+                await fut
+
+            if not last_only:
+                return (True, self.get(False))
+
+            got = False
+            item: (T | None) = None
+            while not self.empty():
+                got = True
+                item = self.get(False)
+                await asyncio.sleep(0)  # Switch task to prevent hanging in a loop
+            return (got, item)
+        except (TimeoutError, queue.Empty):
+            return (False, None)
+        finally:
+            loop.remove_reader(fd)
+
+    def fetch_last(self, timeout: float=0.0) -> tuple[bool, (T | None)]:
+        try:
+            item = self.get(timeout=timeout)
+            while not self.empty():
+                item = self.get()
+            return (True, item)
+        except queue.Empty:
+            return (False, None)
+
+    def clear_current(self) -> None:
+        for _ in range(self.qsize()):
+            try:
+                self.get_nowait()
+            except queue.Empty:
+                break
+
+
+# =====
+class AioMpNotifier:
     def __init__(self) -> None:
-        self.__queue: "multiprocessing.Queue[int]" = multiprocessing.Queue()
+        self.__queue: AioMpQueue[int] = AioMpQueue()
 
     def notify(self, mask: int=0) -> None:
         self.__queue.put_nowait(mask)
 
-    async def wait(self) -> int:
-        while True:
-            mask = await aiotools.run_async(self.__get)
-            if mask >= 0:
-                return mask
-
-    def __get(self) -> int:
-        try:
-            mask = self.__queue.get(timeout=0.1)
+    async def wait(self, timeout: float=0) -> int:
+        (got, mask) = await self.__queue.async_fetch(timeout)
+        if not got:  # Timeout
+            return -1
+        assert mask is not None
+        if got:
             while not self.__queue.empty():
                 mask |= self.__queue.get()
-            return mask
-        except queue.Empty:
-            return -1
+                await asyncio.sleep(0)
+        return mask
 
 
 # =====
@@ -88,7 +229,7 @@ class AioSharedFlags(Generic[_SharedFlagT]):
     def __init__(
         self,
         initial: dict[str, _SharedFlagT],
-        notifier: AioProcessNotifier,
+        notifier: AioMpNotifier,
         type: Type[_SharedFlagT]=bool,  # pylint: disable=redefined-builtin
     ) -> None:
 
@@ -114,7 +255,7 @@ def update(self, **kwargs: _SharedFlagT) -> None:
             self.__notifier.notify()
 
     async def get(self) -> dict[str, _SharedFlagT]:
-        return (await aiotools.run_async(self.__inner_get))
+        return (await asyncio.to_thread(self.__inner_get))
 
     def __inner_get(self) -> dict[str, _SharedFlagT]:
         with self.__lock: