trcc-linux 1.2.17__tar.gz → 1.2.19__tar.gz

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 1.2.17
+Version: 1.2.19
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "1.2.17"
+version = "1.2.19"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.17"
+__version__ = "1.2.19"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -49,3 +49,9 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          USBLCD.exe protocol), KVM LED backend, sensor-driven LED fix (cpu_percent/
 #          gpu_usage metric keys), unified DEVICE_BUTTON_IMAGE dict for all protocols,
 #          LED button image resolver, sensor source CPU/GPU toggle in LED control UI
+# 1.2.18 - Fix GrandVision 360 AIO (87AD:70DB) causing GUI hang: device is vendor-
+#          specific USB (class 255), not HID — removed from LED device list to stop
+#          timeout loop on startup
+# 1.2.19 - Raw USB bulk protocol for GrandVision/Mjolnir Vision (87AD:70DB):
+#          BulkDevice handler (handshake + RGB565 frame send via pyusb),
+#          BulkProtocol in device factory, bulk udev rules, CLI detect/probe

trcc_linux-1.2.19/src/trcc/bulk_device.py

@@ -0,0 +1,194 @@
+"""
+Raw USB bulk device handler for USBLCDNew-type devices.
+
+Handles devices with bInterfaceClass=255 (Vendor Specific) that use
+raw USB bulk transfers instead of SCSI or HID.  Protocol reverse-engineered
+from USBLCDNew.exe ThreadSendDeviceData (87AD:70DB GrandVision series).
+
+Protocol:
+  1. Handshake: write 64 bytes {0x12,0x34,0x56,0x78,...,byte[56]=0x01},
+     read 1024 bytes.  resp[24]=PM, resp[36]=SUB.
+  2. Frame send: 64-byte header + RGB565 pixel data, bulk write.
+     ZLP if total size is 512-byte aligned.
+"""
+
+from __future__ import annotations
+
+import logging
+import struct
+
+from .device_base import DeviceHandler, HandshakeResult
+
+log = logging.getLogger(__name__)
+
+# Handshake payload: 64 bytes from USBLCDNew ThreadSendDeviceData
+_HANDSHAKE_PAYLOAD = bytes([
+    0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0,
+])
+
+_HANDSHAKE_READ_SIZE = 1024
+_HANDSHAKE_TIMEOUT_MS = 1000
+_WRITE_TIMEOUT_MS = 1000
+_FRAME_HEADER_SIZE = 64
+
+
+class BulkDevice(DeviceHandler):
+    """USB bulk device handler for USBLCDNew-type LCDs (87AD:70DB etc.).
+
+    Uses pyusb for raw bulk endpoint I/O.  The kernel must not have
+    claimed the interface (no usb-storage, no usbhid).
+    """
+
+    def __init__(self, vid: int, pid: int, usb_path: str = ""):
+        self.vid = vid
+        self.pid = pid
+        self.usb_path = usb_path
+        self._dev = None
+        self._ep_out = None
+        self._ep_in = None
+        self.pm: int = 0
+        self.sub_type: int = 0
+        self.width: int = 0
+        self.height: int = 0
+        self._raw_handshake: bytes = b""
+
+    def _open(self):
+        """Find and claim the USB device."""
+        import usb.core
+        import usb.util
+
+        dev = usb.core.find(idVendor=self.vid, idProduct=self.pid)  # type: ignore[union-attr]
+        if dev is None:
+            raise RuntimeError(f"USB device {self.vid:04x}:{self.pid:04x} not found")
+
+        # Detach kernel driver if attached
+        for i in range(dev.get_active_configuration().bNumInterfaces):  # type: ignore[union-attr]
+            if dev.is_kernel_driver_active(i):  # type: ignore[union-attr]
+                dev.detach_kernel_driver(i)  # type: ignore[union-attr]
+                log.debug("Detached kernel driver from interface %d", i)
+
+        dev.set_configuration()  # type: ignore[union-attr]
+        cfg = dev.get_active_configuration()  # type: ignore[union-attr]
+        intf = cfg[(0, 0)]  # type: ignore[index]
+
+        self._ep_out = usb.util.find_descriptor(
+            intf,
+            custom_match=lambda e: usb.util.endpoint_direction(
+                e.bEndpointAddress
+            ) == usb.util.ENDPOINT_OUT,
+        )
+        self._ep_in = usb.util.find_descriptor(
+            intf,
+            custom_match=lambda e: usb.util.endpoint_direction(
+                e.bEndpointAddress
+            ) == usb.util.ENDPOINT_IN,
+        )
+
+        if self._ep_out is None or self._ep_in is None:
+            raise RuntimeError("Could not find bulk IN/OUT endpoints")
+
+        self._dev = dev
+        log.info("Opened bulk device %04x:%04x (EP OUT=0x%02x, EP IN=0x%02x)",
+                 self.vid, self.pid,
+                 self._ep_out.bEndpointAddress,  # type: ignore[union-attr]
+                 self._ep_in.bEndpointAddress)  # type: ignore[union-attr]
+
+    def handshake(self) -> HandshakeResult:
+        """Send 64-byte handshake, read 1024-byte response.
+
+        Extracts PM from resp[24], SUB from resp[36].
+        """
+        if self._dev is None:
+            self._open()
+
+        assert self._ep_out is not None
+        assert self._ep_in is not None
+
+        # Write handshake
+        self._ep_out.write(_HANDSHAKE_PAYLOAD, timeout=_HANDSHAKE_TIMEOUT_MS)  # type: ignore[union-attr]
+        log.debug("Handshake sent (%d bytes)", len(_HANDSHAKE_PAYLOAD))
+
+        # Read response
+        resp = bytes(self._ep_in.read(  # type: ignore[union-attr]
+            _HANDSHAKE_READ_SIZE, timeout=_HANDSHAKE_TIMEOUT_MS
+        ))
+        self._raw_handshake = resp
+        log.info("Handshake response: %d bytes", len(resp))
+        log.debug("Response hex (first 64): %s",
+                  " ".join(f"{b:02x}" for b in resp[:64]))
+
+        # Validate: resp[24] must be non-zero (from CS code)
+        if len(resp) < 41 or resp[24] == 0:
+            log.warning("Handshake failed: resp[24]=%s (expected non-zero)",
+                        resp[24] if len(resp) > 24 else "N/A")
+            return HandshakeResult(raw_response=resp)
+
+        # Extract PM and SUB (from USBLCDNew shared memory mapping)
+        self.pm = resp[24]
+        self.sub_type = resp[36]
+
+        # Derive resolution from PM (same mapping as SCSI poll byte)
+        res_map = {36: (240, 240), 50: (240, 320), 51: (320, 240),
+                   100: (320, 320), 101: (480, 480)}
+        resolution = res_map.get(self.pm)
+        if resolution:
+            self.width, self.height = resolution
+
+        log.info("Bulk handshake OK: PM=%d, SUB=%d, resolution=%s",
+                 self.pm, self.sub_type, resolution)
+
+        return HandshakeResult(
+            resolution=resolution,
+            model_id=self.pm,
+            raw_response=resp,
+        )
+
+    def send_frame(self, rgb565_data: bytes) -> bool:
+        """Send one RGB565 frame via bulk write.
+
+        Frame format (from USBLCDNew ThreadSendDeviceData):
+          - 64-byte header (bytes[60:64] = data size as uint32 LE)
+          - RGB565 pixel data
+          - ZLP if total size is 512-byte aligned
+        """
+        if self._dev is None or self._ep_out is None:
+            self.handshake()
+
+        assert self._ep_out is not None
+
+        data_size = len(rgb565_data)
+
+        # Build 64-byte header
+        header = bytearray(64)
+        struct.pack_into("<I", header, 60, data_size)
+
+        payload = bytes(header) + rgb565_data
+        total = len(payload)
+
+        try:
+            self._ep_out.write(payload, timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
+
+            # Send ZLP if 512-byte aligned (from CS code)
+            if total % 512 == 0:
+                self._ep_out.write(b"", timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
+
+            return True
+        except Exception:
+            log.exception("Bulk frame send failed (%d bytes)", total)
+            return False
+
+    def close(self) -> None:
+        """Release USB device."""
+        if self._dev is not None:
+            import usb.util
+            usb.util.dispose_resources(self._dev)
+            self._dev = None
+            self._ep_out = None
+            self._ep_in = None
+            log.info("Bulk device closed")

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/src/trcc/cli.py

@@ -299,6 +299,19 @@ def _probe_device(dev):
         except Exception:
             pass
 
+    # Bulk USB devices: probe via bulk_device handshake
+    elif dev.implementation == 'bulk_usblcdnew':
+        try:
+            from trcc.bulk_device import BulkDevice
+            bd = BulkDevice(dev.vid, dev.pid)
+            hs = bd.handshake()
+            if hs.resolution:
+                result['resolution'] = hs.resolution
+                result['pm'] = hs.model_id
+            bd.close()
+        except Exception:
+            pass
+
     return result
 
 
@@ -306,7 +319,12 @@ def _format_device(dev, probe=False):
     """Format a detected device for display."""
     vid_pid = f"[{dev.vid:04x}:{dev.pid:04x}]"
     proto = dev.protocol.upper()
-    path = dev.scsi_device if dev.scsi_device else "No device path found"
+    if dev.scsi_device:
+        path = dev.scsi_device
+    elif dev.protocol in ("hid", "bulk"):
+        path = f"{dev.vid:04x}:{dev.pid:04x}"
+    else:
+        path = "No device path found"
     line = f"{path} — {dev.product_name} {vid_pid} ({proto})"
 
     if not probe:
@@ -933,11 +951,16 @@ def setup_udev(dry_run=False):
     (no /dev/sgX created). The :u quirk forces usb-storage bulk-only transport.
     """
     try:
-        from trcc.device_detector import _HID_LCD_DEVICES, _LED_DEVICES, KNOWN_DEVICES
+        from trcc.device_detector import (
+            _BULK_DEVICES,
+            _HID_LCD_DEVICES,
+            _LED_DEVICES,
+            KNOWN_DEVICES,
+        )
 
         # Always include ALL devices in udev rules (so hardware is ready
-        # when users plug in HID devices, even without --testing-hid)
-        all_devices = {**KNOWN_DEVICES, **_HID_LCD_DEVICES, **_LED_DEVICES}
+        # when users plug in HID/bulk devices, even without --testing-hid)
+        all_devices = {**KNOWN_DEVICES, **_HID_LCD_DEVICES, **_LED_DEVICES, **_BULK_DEVICES}
 
         # --- 1. udev rules (permissions) ---
         rules_path = "/etc/udev/rules.d/99-trcc-lcd.rules"
@@ -960,6 +983,15 @@ def setup_udev(dry_run=False):
                     f'ATTR{{idProduct}}=="{pid:04x}", '
                     f'MODE="0666"'
                 )
+            elif protocol == "bulk":
+                # Raw USB bulk devices need usb subsystem rules (pyusb access)
+                rules_lines.append(
+                    f'# {vendor} {product}\n'
+                    f'SUBSYSTEM=="usb", '
+                    f'ATTR{{idVendor}}=="{vid:04x}", '
+                    f'ATTR{{idProduct}}=="{pid:04x}", '
+                    f'MODE="0666"'
+                )
             else:
                 rules_lines.append(
                     f'# {vendor} {product}\n'

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/src/trcc/device_detector.py

@@ -15,7 +15,9 @@ Supported devices (HID LCD — auto-detected when plugged in):
 
 Supported devices (HID LED — RGB controllers, auto-detected when plugged in):
 - Winbond:      VID=0x0416, PID=0x8001  (64-byte reports)
-- ChiZhu Tech:  VID=0x87AD, PID=0x70DB  (GrandVision series, case 257)
+
+Supported devices (Raw USB bulk — bInterfaceClass=255, Vendor Specific):
+- ChiZhu Tech:  VID=0x87AD, PID=0x70DB  (GrandVision/Mjolnir Vision, USBLCDNew protocol)
 """
 
 import logging
@@ -59,14 +61,7 @@ KNOWN_DEVICES = {
         "button_image": "A1CZTV",
         "implementation": "thermalright_lcd_v1"
     },
-    # USB 87AD:70DB - GrandVision 360 AIO (ChiZhu Tech, case 257 LCD+LED combo)
-    (0x87AD, 0x70DB): {
-        "vendor": "ChiZhu Tech",
-        "product": "GrandVision 360 AIO (USBLCD)",
-        "model": "GRAND_VISION",
-        "button_image": "A1CZTV",
-        "implementation": "thermalright_lcd_v1"
-    },
+    # NOTE: 87AD:70DB (GrandVision) moved to _BULK_DEVICES — it's raw USB bulk, not SCSI.
     (0x0416, 0x5406): {
         "vendor": "Winbond",
         "product": "LCD Display (USBLCD)",
@@ -136,22 +131,31 @@ _LED_DEVICES = {
         "protocol": "hid",
         "device_type": 1,
     },
-    # Case 257 — LCD+LED combo (GrandVision, Core Vision, Hyper Vision, etc.)
-    # ChiZhu Tech USBDISPLAY — same 64-byte HID protocol as device1
+}
+
+# Raw USB bulk devices (bInterfaceClass=255, Vendor Specific).
+# These use the USBLCDNew protocol (ThreadSendDeviceData) — not SCSI, not HID.
+# Requires pyusb for raw bulk endpoint I/O.
+_BULK_DEVICES = {
+    # 87AD:70DB — GrandVision 360 AIO / Mjolnir Vision 360
+    # USBLCDNew ThreadSendDeviceData: 64-byte handshake → 1024-byte response → RGB565 frames
     (0x87AD, 0x70DB): {
         "vendor": "ChiZhu Tech",
-        "product": "LCD+LED Display (HID)",
+        "product": "GrandVision 360 AIO (Bulk USB)",
         "model": "GRAND_VISION",
-        "button_image": "A1GRAND_VISION",
-        "implementation": "hid_led",
-        "protocol": "hid",
-        "device_type": 1,
+        "button_image": "A1CZTV",
+        "implementation": "bulk_usblcdnew",
+        "protocol": "bulk",
+        "device_type": 4,  # 4 = raw USB bulk
     },
 }
 
 # Backward-compat alias (tests and setup-udev reference this)
 KNOWN_LED_DEVICES = _LED_DEVICES
 
+# Public alias for bulk devices (setup-udev needs VID:PIDs)
+KNOWN_BULK_DEVICES = _BULK_DEVICES
+
 # Legacy flag — kept for backward compat but no longer checked.
 # HID devices are now auto-detected when plugged in.
 _hid_testing_enabled = False
@@ -164,10 +168,11 @@ def enable_hid_testing():
 
 
 def _get_all_devices():
-    """Return device lookup dict (SCSI + HID LCD + LED)."""
+    """Return device lookup dict (SCSI + HID LCD + LED + Bulk)."""
     all_devices = dict(KNOWN_DEVICES)
     all_devices.update(_HID_LCD_DEVICES)
     all_devices.update(_LED_DEVICES)
+    all_devices.update(_BULK_DEVICES)
     return all_devices
 
 

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/src/trcc/device_factory.py

@@ -21,7 +21,7 @@ Usage::
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 log = logging.getLogger(__name__)
 
@@ -463,6 +463,102 @@ class LedProtocol(DeviceProtocol):
         return f"LedProtocol(vid=0x{self._vid:04x}, pid=0x{self._pid:04x})"
 
 
+# =========================================================================
+# BulkProtocol — raw USB bulk (USBLCDNew) implementation
+# =========================================================================
+
+class BulkProtocol(DeviceProtocol):
+    """LCD communication via raw USB bulk (bInterfaceClass=255).
+
+    Wraps bulk_device.BulkDevice.  Used for GrandVision / Mjolnir Vision
+    devices (87AD:70DB) that use the USBLCDNew ThreadSendDeviceData protocol.
+    """
+
+    def __init__(self, vid: int, pid: int):
+        super().__init__()
+        self._vid = vid
+        self._pid = pid
+        self._device: Optional[Any] = None  # BulkDevice (lazy import)
+        self._last_error: Optional[Exception] = None
+
+    def _ensure_device(self):
+        """Lazily create and handshake the bulk device."""
+        if self._device is None:
+            from .bulk_device import BulkDevice
+            self._device = BulkDevice(self._vid, self._pid)
+            result = self._device.handshake()
+            if result.resolution:
+                self._notify_state_changed("handshake_complete", True)
+                log.info("Bulk handshake OK: PM=%d, resolution=%s",
+                         result.model_id, result.resolution)
+            else:
+                log.warning("Bulk handshake: no resolution detected")
+
+    def handshake(self):
+        """Perform bulk device handshake."""
+        try:
+            self._ensure_device()
+            assert self._device is not None
+            return self._device._raw_handshake
+        except Exception as e:
+            log.exception("Bulk handshake failed for %04X:%04X",
+                          self._vid, self._pid)
+            self._last_error = e
+            self._notify_error(f"Bulk handshake failed: {e}")
+            return None
+
+    @property
+    def last_error(self) -> Optional[Exception]:
+        """Last exception from handshake."""
+        return self._last_error
+
+    def send_image(self, image_data: bytes, width: int, height: int) -> bool:
+        try:
+            self._ensure_device()
+            assert self._device is not None
+            success = self._device.send_frame(image_data)
+            self._notify_send_complete(success)
+            return success
+        except Exception as e:
+            self._notify_error(f"Bulk send failed: {e}")
+            self._notify_send_complete(False)
+            return False
+
+    def close(self) -> None:
+        if self._device is not None:
+            try:
+                self._device.close()
+            except Exception:
+                pass
+            self._device = None
+
+    def get_info(self) -> 'ProtocolInfo':
+        backends = _get_hid_backends()
+        active = "pyusb" if backends["pyusb"] else "none"
+        backends["sg_raw"] = False
+        return ProtocolInfo(
+            protocol="bulk",
+            device_type=4,
+            protocol_display="USB Bulk (USBLCDNew)",
+            device_type_display="Raw USB Bulk LCD",
+            active_backend=active,
+            backends=backends,
+            transport_open=self._device is not None,
+        )
+
+    @property
+    def protocol_name(self) -> str:
+        return "bulk"
+
+    @property
+    def is_available(self) -> bool:
+        backends = _get_hid_backends()
+        return backends["pyusb"]
+
+    def __repr__(self) -> str:
+        return f"BulkProtocol(vid=0x{self._vid:04x}, pid=0x{self._pid:04x})"
+
+
 # =========================================================================
 # Backward-compatible aliases (old names still work)
 # =========================================================================
@@ -526,6 +622,13 @@ class DeviceProtocolFactory:
         if protocol == 'scsi':
             log.info("Creating ScsiProtocol for %s", device_info.path)
             return ScsiProtocol(device_info.path)
+        elif protocol == 'bulk':
+            log.info("Creating BulkProtocol for %04X:%04X",
+                     device_info.vid, device_info.pid)
+            return BulkProtocol(
+                vid=device_info.vid,
+                pid=device_info.pid,
+            )
         elif protocol == 'hid':
             # LED devices use a different protocol than LCD HID devices
             if implementation == 'hid_led':
@@ -595,12 +698,14 @@ PROTOCOL_NAMES = {
     "scsi": "SCSI (sg_raw)",
     "hid": "HID (USB bulk)",
     "led": "LED (HID 64-byte)",
+    "bulk": "USB Bulk (USBLCDNew)",
 }
 
 DEVICE_TYPE_NAMES = {
     1: "SCSI RGB565",
     2: "HID Type 2 (H)",
     3: "HID Type 3 (ALi)",
+    4: "Raw USB Bulk LCD",
 }
 
 LED_DEVICE_TYPE_NAME = "RGB LED Controller"
@@ -726,6 +831,8 @@ def get_protocol_info(device_info=None) -> ProtocolInfo:
 
     if protocol == "scsi":
         active = "sg_raw" if backends["sg_raw"] else "none"
+    elif protocol == "bulk":
+        active = "pyusb" if backends["pyusb"] else "none"
     elif protocol == "hid":
         if backends["pyusb"]:
             active = "pyusb"

{trcc_linux-1.2.17 → trcc_linux-1.2.19}/src/trcc/scsi_device.py

@@ -297,6 +297,27 @@ def find_lcd_devices() -> List[Dict]:
                 'device_type': device_type,
                 'implementation': dev.implementation,
             })
+        elif protocol == 'bulk':
+            # Bulk USB devices — no SCSI path, use VID:PID
+            bulk_path = f"bulk:{dev.vid:04x}:{dev.pid:04x}"
+
+            # Resolution unknown until handshake; default from device registry
+            resolution = (0, 0)
+
+            devices.append({
+                'name': f"{dev.vendor_name} {dev.product_name}",
+                'path': bulk_path,
+                'resolution': resolution,
+                'vendor': dev.vendor_name,
+                'product': dev.product_name,
+                'model': dev.model,
+                'button_image': dev.button_image,
+                'vid': dev.vid,
+                'pid': dev.pid,
+                'protocol': 'bulk',
+                'device_type': device_type,
+                'implementation': dev.implementation,
+            })
 
     # Sort by path for stable ordinal assignment
     devices.sort(key=lambda d: d['path'])