trcc-linux 1.2.18__tar.gz → 1.2.20__tar.gz

{trcc_linux-1.2.18 → trcc_linux-1.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 1.2.18
+Version: 1.2.20
 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.18 → trcc_linux-1.2.20}/pyproject.toml

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

{trcc_linux-1.2.18 → trcc_linux-1.2.20}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.18"
+__version__ = "1.2.20"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -52,3 +52,10 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 # 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
+# 1.2.20 - Fix GUI not performing handshake for HID/Bulk devices: resolution
+#          stayed (0,0) so themes never loaded. Now runs handshake async on
+#          device selection. OOP refactor: DeviceEntry dataclass, PmEntry
+#          NamedTuple, _LedProbeCache class, _resolve_pm() DRY helper

trcc_linux-1.2.20/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.18 → trcc_linux-1.2.20}/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:
@@ -881,20 +899,24 @@ def led_diag(test=False):
         else:
             print(f"\n  Status: UNKNOWN PM byte ({info.pm})")
             print("  This device falls back to AX120 defaults.")
-            print(f"  Add PM {info.pm} to led_device.py PM_TO_STYLE/PM_TO_MODEL.")
+            print(f"  Add PM {info.pm} to led_device.py _PM_REGISTRY.")
 
         if test:
+            from .led_device import remap_led_colors
+
             print("\n  Sending test colors...")
             led_count = style.led_count
             for name, color in [("RED", (255, 0, 0)), ("GREEN", (0, 255, 0)),
                                 ("BLUE", (0, 0, 255)), ("WHITE", (255, 255, 255))]:
-                led_colors = [color] * led_count
+                led_colors = remap_led_colors(
+                    [color] * led_count, style.style_id)
                 packet = LedPacketBuilder.build_led_packet(led_colors, brightness=100)
                 sender.send_led_data(packet)
                 print(f"    {name}")
                 time.sleep(1.5)
-            packet = LedPacketBuilder.build_led_packet(
-                [(0, 0, 0)] * led_count, brightness=0)
+            led_colors = remap_led_colors(
+                [(0, 0, 0)] * led_count, style.style_id)
+            packet = LedPacketBuilder.build_led_packet(led_colors, brightness=0)
             sender.send_led_data(packet)
             print("    OFF")
 
@@ -933,20 +955,25 @@ 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"
         rules_lines = ["# Thermalright LCD/LED cooler devices — auto-generated by trcc setup-udev"]
 
         for (vid, pid), info in sorted(all_devices.items()):
-            vendor = info.get("vendor", "Unknown")
-            product = info.get("product", "Unknown")
-            protocol = info.get("protocol", "scsi")
+            vendor = info.vendor
+            product = info.product
+            protocol = info.protocol
             if protocol == "hid":
                 # HID devices need hidraw/usb subsystem rules
                 rules_lines.append(
@@ -960,6 +987,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.18 → trcc_linux-1.2.20}/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
@@ -30,6 +32,18 @@ from .paths import find_scsi_devices as _find_sg_entries
 log = logging.getLogger(__name__)
 
 
+@dataclass
+class DeviceEntry:
+    """Registry entry describing a known USB device's capabilities."""
+    vendor: str
+    product: str
+    implementation: str
+    model: str = "CZTV"
+    button_image: str = "A1CZTV"
+    protocol: str = "scsi"
+    device_type: int = 1  # 1=SCSI, 2=HID Type 2, 3=HID Type 3, 4=Raw USB Bulk
+
+
 @dataclass
 class DetectedDevice:
     """Detected USB/SCSI device"""
@@ -51,72 +65,42 @@ class DetectedDevice:
 # NOTE: On Linux we can't access HID pm/sub bytes to identify exact model,
 # so we map VID:PID directly to the most common device for that hardware.
 # Users can override model via config if needed.
-KNOWN_DEVICES = {
-    (0x87CD, 0x70DB): {
-        "vendor": "Thermalright",
-        "product": "LCD Display (USBLCD)",
-        "model": "CZTV",
-        "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"
-    },
-    (0x0416, 0x5406): {
-        "vendor": "Winbond",
-        "product": "LCD Display (USBLCD)",
-        "model": "CZTV",
-        "button_image": "A1CZTV",
-        "implementation": "ali_corp_lcd_v1"
-    },
+KNOWN_DEVICES: dict[tuple[int, int], DeviceEntry] = {
+    (0x87CD, 0x70DB): DeviceEntry(
+        vendor="Thermalright", product="LCD Display (USBLCD)",
+        implementation="thermalright_lcd_v1",
+    ),
+    # NOTE: 87AD:70DB (GrandVision) moved to _BULK_DEVICES — it's raw USB bulk, not SCSI.
+    (0x0416, 0x5406): DeviceEntry(
+        vendor="Winbond", product="LCD Display (USBLCD)",
+        implementation="ali_corp_lcd_v1",
+    ),
     # USB 0402:3922 - FROZEN WARFRAME series (SE/PRO/Ultra, confirmed on PRO 360 Black)
-    (0x0402, 0x3922): {
-        "vendor": "ALi Corp",
-        "product": "FROZEN WARFRAME",
-        "model": "FROZEN_WARFRAME",
-        "button_image": "A1FROZEN_WARFRAME",
-        "implementation": "ali_corp_lcd_v1"
-    },
+    (0x0402, 0x3922): DeviceEntry(
+        vendor="ALi Corp", product="FROZEN WARFRAME",
+        model="FROZEN_WARFRAME", button_image="A1FROZEN_WARFRAME",
+        implementation="ali_corp_lcd_v1",
+    ),
 }
 
 # HID LCD devices — auto-detected when plugged in.
 # From UCDevice.cs (TRCC 2.0.3 decompiled — decimal PIDs confirmed).
-_HID_LCD_DEVICES = {
+_HID_LCD_DEVICES: dict[tuple[int, int], DeviceEntry] = {
     # device2: UsbHidDevice(1046, 21250) = 0x0416:0x5302, DA/DB/DC/DD handshake, 512-byte chunks
-    (0x0416, 0x5302): {
-        "vendor": "Winbond",
-        "product": "USBDISPLAY (HID)",
-        "model": "CZTV",
-        "button_image": "A1CZTV",
-        "implementation": "hid_type2",
-        "protocol": "hid",
-        "device_type": 2,
-    },
+    (0x0416, 0x5302): DeviceEntry(
+        vendor="Winbond", product="USBDISPLAY (HID)",
+        implementation="hid_type2", protocol="hid", device_type=2,
+    ),
     # device3: UsbHidDevice(1048, 21251) = 0x0418:0x5303, 64-byte packets
-    (0x0418, 0x5303): {
-        "vendor": "ALi Corp",
-        "product": "LCD Display (HID)",
-        "model": "CZTV",
-        "button_image": "A1CZTV",
-        "implementation": "hid_type3",
-        "protocol": "hid",
-        "device_type": 3,
-    },
+    (0x0418, 0x5303): DeviceEntry(
+        vendor="ALi Corp", product="LCD Display (HID)",
+        implementation="hid_type3", protocol="hid", device_type=3,
+    ),
     # device4: UsbHidDevice(1048, 21252) = 0x0418:0x5304
-    (0x0418, 0x5304): {
-        "vendor": "ALi Corp",
-        "product": "LCD Display (HID)",
-        "model": "CZTV",
-        "button_image": "A1CZTV",
-        "implementation": "hid_type3",
-        "protocol": "hid",
-        "device_type": 3,
-    },
+    (0x0418, 0x5304): DeviceEntry(
+        vendor="ALi Corp", product="LCD Display (HID)",
+        implementation="hid_type3", protocol="hid", device_type=3,
+    ),
 }
 
 # LED HID devices (RGB controllers + case 257 LCD+LED combos)
@@ -124,26 +108,35 @@ _HID_LCD_DEVICES = {
 # Case 257 devices (87AD:70DB) are LCD+LED combos that also use FormCZTV.
 # The actual model is resolved at runtime via the PM byte from the HID
 # handshake (see led_device.PM_TO_MODEL).
-_LED_DEVICES = {
+_LED_DEVICES: dict[tuple[int, int], DeviceEntry] = {
     # device1: UsbHidDevice(1046, 32769) = 0x0416:0x8001, 64-byte packets
     # Case 1 — LED-only (AX120 Digital, PA120 Digital, etc.)
-    (0x0416, 0x8001): {
-        "vendor": "Winbond",
-        "product": "LED Controller (HID)",
-        "model": "LED_DIGITAL",
-        "button_image": "A1CZTV",
-        "implementation": "hid_led",
-        "protocol": "hid",
-        "device_type": 1,
-    },
-    # NOTE: 87AD:70DB (GrandVision) is NOT HID — bInterfaceClass=255 (Vendor Specific).
-    # Uses USBLCDNew raw bulk protocol (ThreadSendDeviceData), not HID handshake.
-    # Removed from _LED_DEVICES to prevent timeout loops. Needs raw bulk implementation.
+    (0x0416, 0x8001): DeviceEntry(
+        vendor="Winbond", product="LED Controller (HID)",
+        model="LED_DIGITAL", implementation="hid_led",
+        protocol="hid", device_type=1,
+    ),
+}
+
+# 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: dict[tuple[int, int], DeviceEntry] = {
+    # 87AD:70DB — GrandVision 360 AIO / Mjolnir Vision 360
+    # USBLCDNew ThreadSendDeviceData: 64-byte handshake → 1024-byte response → RGB565 frames
+    (0x87AD, 0x70DB): DeviceEntry(
+        vendor="ChiZhu Tech", product="GrandVision 360 AIO (Bulk USB)",
+        model="GRAND_VISION", implementation="bulk_usblcdnew",
+        protocol="bulk", device_type=4,
+    ),
 }
 
 # 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
@@ -156,10 +149,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
 
 
@@ -211,18 +205,18 @@ def find_usb_devices() -> List[DetectedDevice]:
         usb_path = f"{int(bus)}-{device}"
 
         log.debug("Found known device: %04X:%04X %s (%s)",
-                  vid, pid, device_info["vendor"], device_info.get("protocol", "scsi"))
+                  vid, pid, device_info.vendor, device_info.protocol)
         devices.append(DetectedDevice(
             vid=vid,
             pid=pid,
-            vendor_name=device_info["vendor"],
-            product_name=device_info["product"],
+            vendor_name=device_info.vendor,
+            product_name=device_info.product,
             usb_path=usb_path,
-            implementation=device_info["implementation"],
-            model=device_info.get("model", "CZTV"),
-            button_image=device_info.get("button_image", "A1CZTV"),
-            protocol=device_info.get("protocol", "scsi"),
-            device_type=int(device_info.get("device_type", 1)),
+            implementation=device_info.implementation,
+            model=device_info.model,
+            button_image=device_info.button_image,
+            protocol=device_info.protocol,
+            device_type=device_info.device_type,
         ))
 
     log.debug("USB scan found %d known device(s)", len(devices))
@@ -320,8 +314,8 @@ def find_scsi_usblcd_devices() -> List[DetectedDevice]:
                             # Look up in KNOWN_DEVICES
                             if (dev_vid, dev_pid) in KNOWN_DEVICES:
                                 dev_info = KNOWN_DEVICES[(dev_vid, dev_pid)]
-                                dev_model = dev_info.get("model", "CZTV")
-                                dev_button = dev_info.get("button_image", "A1CZTV")
+                                dev_model = dev_info.model
+                                dev_button = dev_info.button_image
                             break
                 except (IOError, OSError, ValueError):
                     pass