trcc-linux 1.2.14__tar.gz → 1.2.16__tar.gz

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/PKG-INFO

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

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

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.14"
+__version__ = "1.2.16"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -41,3 +41,7 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 # 1.2.13 - Fix format buttons not updating preview on fresh install: set overlay_enabled
 #          on theme load, persist format prefs (time/date/temp) across theme changes
 # 1.2.14 - Add GrandVision 360 AIO support (VID 87AD:70DB), fix sysfs VID readback
+# 1.2.15 - Auto-detect stale udev quirks: trcc detect warns and prompts
+#          sudo trcc setup-udev + reboot when USB storage quirk is missing
+# 1.2.16 - Fix udev permissions on SELinux/immutable distros (Bazzite, Silverblue):
+#          use MODE="0666" instead of TAG+="uaccess" which fails with SELinux enforcing

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/cli.py

@@ -335,7 +335,7 @@ def _format_device(dev, probe=False):
 def detect(show_all=False):
     """Detect LCD device."""
     try:
-        from trcc.device_detector import detect_devices
+        from trcc.device_detector import check_udev_rules, detect_devices
 
         devices = detect_devices()
         if not devices:
@@ -358,6 +358,16 @@ def detect(show_all=False):
                 dev = devices[0]
             print(f"Active: {_format_device(dev, probe=True)}")
 
+        # Check for stale/missing udev rules on any device
+        for dev in devices:
+            if not check_udev_rules(dev):
+                msg = f"\nDevice {dev.vid:04x}:{dev.pid:04x} needs updated udev rules.\n"
+                msg += "Run:  sudo trcc setup-udev"
+                if dev.protocol == "scsi":
+                    msg += "\nThen reboot for the USB storage quirk to take effect."
+                print(msg)
+                break
+
         return 0
     except Exception as e:
         print(f"Error: {e}")
@@ -944,11 +954,11 @@ def setup_udev(dry_run=False):
                     f'SUBSYSTEM=="hidraw", '
                     f'ATTRS{{idVendor}}=="{vid:04x}", '
                     f'ATTRS{{idProduct}}=="{pid:04x}", '
-                    f'MODE="0660", TAG+="uaccess"\n'
+                    f'MODE="0666"\n'
                     f'SUBSYSTEM=="usb", '
                     f'ATTR{{idVendor}}=="{vid:04x}", '
                     f'ATTR{{idProduct}}=="{pid:04x}", '
-                    f'MODE="0660", TAG+="uaccess"'
+                    f'MODE="0666"'
                 )
             else:
                 rules_lines.append(
@@ -956,7 +966,7 @@ def setup_udev(dry_run=False):
                     f'SUBSYSTEM=="scsi_generic", '
                     f'ATTRS{{idVendor}}=="{vid:04x}", '
                     f'ATTRS{{idProduct}}=="{pid:04x}", '
-                    f'MODE="0660", TAG+="uaccess"'
+                    f'MODE="0666"'
                 )
 
         rules_content = "\n\n".join(rules_lines) + "\n"

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/core/controllers.py

@@ -842,7 +842,7 @@ class LCDDeviceController:
             self._send_frame_to_lcd(img)
         self._update_status(f"Mask: {mask_dir.name}")
 
-    def _load_and_play_video(self, path: Path | str):
+    def _load_and_play_video(self, path: Path):
         """Load video, show first frame on preview+LCD, and start playback."""
         self.video.load(path)
         first_frame = self.video.model.get_frame(0)

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/device_detector.py

@@ -5,7 +5,6 @@ Finds Thermalright LCD and LED devices and maps them to SCSI or HID devices.
 
 Supported devices (SCSI — stable):
 - Thermalright: VID=0x87CD, PID=0x70DB
-- Thermalright: VID=0x87AD, PID=0x70DB  (GrandVision series)
 - Winbond:      VID=0x0416, PID=0x5406
 - ALi Corp:     VID=0x0402, PID=0x3922
 
@@ -16,6 +15,7 @@ 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)
 """
 
 import logging
@@ -59,14 +59,6 @@ KNOWN_DEVICES = {
         "button_image": "A1CZTV",
         "implementation": "thermalright_lcd_v1"
     },
-    # Same chip (ChiZhu Tech USBDISPLAY), different VID — GrandVision 360 AIO etc.
-    (0x87AD, 0x70DB): {
-        "vendor": "Thermalright",
-        "product": "LCD Display (USBLCD)",
-        "model": "CZTV",
-        "button_image": "A1CZTV",
-        "implementation": "thermalright_lcd_v1"
-    },
     (0x0416, 0x5406): {
         "vendor": "Winbond",
         "product": "LCD Display (USBLCD)",
@@ -119,13 +111,14 @@ _HID_LCD_DEVICES = {
     },
 }
 
-# LED HID devices (RGB controllers — FormLED in Windows, not FormCZTV)
-# These use 64-byte HID reports for LED color control, not LCD image display.
-# device1: UsbHidDevice(1046, 32769) = 0x0416:0x8001, 64-byte packets
-# NOTE: All LED devices share PID 0x8001 — AX120 Digital, PA120 Digital,
-# Peerless Assassin 120 Digital, etc.  The actual model is resolved at runtime
-# via the PM byte from the HID handshake (see led_device.PM_TO_MODEL).
+# LED HID devices (RGB controllers + case 257 LCD+LED combos)
+# These use 64-byte HID reports. Case 1 devices (0416:8001) are LED-only.
+# 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 = {
+    # 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)",
@@ -135,6 +128,17 @@ _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
+    (0x87AD, 0x70DB): {
+        "vendor": "ChiZhu Tech",
+        "product": "LCD+LED Display (HID)",
+        "model": "GRAND_VISION",
+        "button_image": "A1GRAND_VISION",
+        "implementation": "hid_led",
+        "protocol": "hid",
+        "device_type": 1,
+    },
 }
 
 # Backward-compat alias (tests and setup-udev reference this)
@@ -367,6 +371,20 @@ def detect_devices() -> List[DetectedDevice]:
     return devices
 
 
+def check_udev_rules(device: DetectedDevice) -> bool:
+    """Check if udev rules file contains the VID:PID for *device*.
+
+    Returns True if a matching rule exists, False if missing or file absent.
+    Works for both SCSI and HID devices.
+    """
+    vid_hex = f"{device.vid:04x}"
+    try:
+        with open("/etc/udev/rules.d/99-trcc-lcd.rules") as f:
+            return vid_hex in f.read()
+    except (IOError, OSError):
+        return False
+
+
 def get_default_device() -> Optional[DetectedDevice]:
     """Get the first available LCD device"""
     devices = detect_devices()
@@ -374,9 +392,9 @@ def get_default_device() -> Optional[DetectedDevice]:
     if not devices:
         return None
 
-    # Prefer Thermalright device, then any other
+    # Prefer Thermalright SCSI device, then any other
     for device in devices:
-        if device.vid in (0x87CD, 0x87AD):
+        if device.vid == 0x87CD:
             return device
 
     return devices[0]

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/device_factory.py

@@ -287,19 +287,7 @@ class HidProtocol(DeviceProtocol):
 
     def _create_transport(self):
         """Create the best available USB transport."""
-        from .hid_device import HIDAPI_AVAILABLE, PYUSB_AVAILABLE
-        if PYUSB_AVAILABLE:
-            from .hid_device import PyUsbTransport
-            return PyUsbTransport(self._vid, self._pid)
-        elif HIDAPI_AVAILABLE:
-            from .hid_device import HidApiTransport
-            return HidApiTransport(self._vid, self._pid)
-        else:
-            raise ImportError(
-                "No USB backend available. Install pyusb or hidapi:\n"
-                "  pip install pyusb   (+ apt install libusb-1.0-0)\n"
-                "  pip install hidapi  (+ apt install libhidapi-dev)"
-            )
+        return _create_usb_transport(self._vid, self._pid)
 
     @property
     def protocol_name(self) -> str:
@@ -451,19 +439,7 @@ class LedProtocol(DeviceProtocol):
 
     def _create_transport(self):
         """Create the best available USB transport."""
-        from .hid_device import HIDAPI_AVAILABLE, PYUSB_AVAILABLE
-        if PYUSB_AVAILABLE:
-            from .hid_device import PyUsbTransport
-            return PyUsbTransport(self._vid, self._pid)
-        elif HIDAPI_AVAILABLE:
-            from .hid_device import HidApiTransport
-            return HidApiTransport(self._vid, self._pid)
-        else:
-            raise ImportError(
-                "No USB backend available. Install pyusb or hidapi:\n"
-                "  pip install pyusb   (+ apt install libusb-1.0-0)\n"
-                "  pip install hidapi  (+ apt install libhidapi-dev)"
-            )
+        return _create_usb_transport(self._vid, self._pid)
 
     @property
     def protocol_name(self) -> str:
@@ -673,6 +649,23 @@ def _check_sg_raw() -> bool:
     return shutil.which("sg_raw") is not None
 
 
+def _create_usb_transport(vid: int, pid: int):
+    """Create the best available USB transport (pyusb preferred, hidapi fallback)."""
+    from .hid_device import HIDAPI_AVAILABLE, PYUSB_AVAILABLE
+    if PYUSB_AVAILABLE:
+        from .hid_device import PyUsbTransport
+        return PyUsbTransport(vid, pid)
+    elif HIDAPI_AVAILABLE:
+        from .hid_device import HidApiTransport
+        return HidApiTransport(vid, pid)
+    else:
+        raise ImportError(
+            "No USB backend available. Install pyusb or hidapi:\n"
+            "  pip install pyusb   (+ apt install libusb-1.0-0)\n"
+            "  pip install hidapi  (+ apt install libhidapi-dev)"
+        )
+
+
 def _get_hid_backends() -> Dict[str, bool]:
     """Check HID backend availability."""
     try:

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/device_implementations.py

@@ -8,6 +8,8 @@ import struct
 from abc import ABC, abstractmethod
 from typing import Tuple
 
+from .scsi_device import _get_frame_chunks
+
 
 class LCDDeviceImplementation(ABC):
     """Base class for LCD device implementations"""
@@ -41,25 +43,10 @@ class LCDDeviceImplementation(ABC):
     def get_frame_chunks(self) -> list:
         """Get frame chunk commands [(cmd, size), ...] for current resolution.
 
-        Each chunk is up to 64 KiB.  The chunk index is encoded in bits [27:24]
-        above the base command 0x101F5.
-
-        For 320x320: 4 chunks (3x64K + 8K = 204,800 bytes)
-        For 480x480: 8 chunks (7x64K + 2K = 460,800 bytes)
+        Delegates to scsi_device._get_frame_chunks() — single source of truth
+        for the SCSI chunking algorithm.
         """
-        base_cmd = 0x101F5
-        chunk_size = 0x10000  # 64 KiB
-        total = self.width * self.height * 2  # RGB565: 2 bytes per pixel
-        chunks = []
-        offset = 0
-        idx = 0
-        while offset < total:
-            size = min(chunk_size, total - offset)
-            cmd = base_cmd | (idx << 24)
-            chunks.append((cmd, size))
-            offset += size
-            idx += 1
-        return chunks
+        return _get_frame_chunks(self.width, self.height)
 
     def needs_init_per_frame(self) -> bool:
         """Whether device needs init before each frame"""

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/lcd_driver.py

@@ -4,12 +4,7 @@ Unified LCD Driver
 Combines device detection with implementation-specific protocols.
 """
 
-import binascii
 import logging
-import os
-import struct
-import subprocess
-import tempfile
 from typing import Optional
 
 log = logging.getLogger(__name__)
@@ -17,7 +12,7 @@ log = logging.getLogger(__name__)
 try:
     from .device_detector import DetectedDevice, detect_devices, get_default_device
     from .device_implementations import LCDDeviceImplementation, get_implementation
-    from .paths import require_sg_raw
+    from .scsi_device import _build_header, _scsi_read, _scsi_write
 except ImportError:
     from trcc.device_detector import (  # type: ignore[no-redef]
         DetectedDevice,
@@ -28,7 +23,7 @@ except ImportError:
         LCDDeviceImplementation,
         get_implementation,
     )
-    from trcc.paths import require_sg_raw  # type: ignore[no-redef]
+    from trcc.scsi_device import _build_header, _scsi_read, _scsi_write  # type: ignore[no-redef]
 
 
 class LCDDriver:
@@ -99,54 +94,6 @@ class LCDDriver:
         self.device_path = device.scsi_device
         self.implementation = get_implementation(device.implementation)
 
-    def _crc32(self, data: bytes) -> int:
-        """Calculate CRC32"""
-        return binascii.crc32(data) & 0xFFFFFFFF
-
-    def _build_header(self, cmd: int, size: int) -> bytes:
-        """Build 20-byte SCSI command header"""
-        header_16 = struct.pack('<I', cmd) + b'\x00' * 8 + struct.pack('<I', size)
-        crc = self._crc32(header_16)
-        return header_16 + struct.pack('<I', crc)
-
-    @staticmethod
-    def _check_sg_raw():
-        """Verify sg_raw is available, raise helpful error if not."""
-        require_sg_raw()
-
-    def _scsi_read(self, cdb: bytes, length: int) -> bytes:
-        """Execute SCSI READ command"""
-        if not self.device_path:
-            raise RuntimeError("No device path available")
-        self._check_sg_raw()
-
-        cdb_hex = ' '.join(f'{b:02x}' for b in cdb)
-        cmd = ['sg_raw', '-r', str(length), self.device_path] + cdb_hex.split()
-
-        result = subprocess.run(cmd, capture_output=True, timeout=10)
-        return result.stdout if result.returncode == 0 else b''
-
-    def _scsi_write(self, header: bytes, data: bytes) -> bool:
-        """Execute SCSI WRITE command"""
-        if not self.device_path:
-            raise RuntimeError("No device path available")
-        self._check_sg_raw()
-
-        cdb = list(header[:16])
-        cdb_hex = ' '.join(f'{b:02x}' for b in cdb)
-
-        with tempfile.NamedTemporaryFile(delete=False) as f:
-            f.write(data)
-            tmp_path = f.name
-
-        cmd = ['sg_raw', '-s', str(len(data)), '-i', tmp_path, self.device_path] + cdb_hex.split()
-
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
-            return result.returncode == 0
-        finally:
-            os.unlink(tmp_path)
-
     def init_device(self):
         """Initialize device (call once at startup)"""
         if self.initialized:
@@ -154,17 +101,19 @@ class LCDDriver:
         assert self.implementation is not None
         log.debug("Initializing LCD device at %s", self.device_path)
 
+        assert self.device_path is not None
+
         # Step 1: Poll device
         poll_cmd, poll_size = self.implementation.get_poll_command()
-        poll_header = self._build_header(poll_cmd, poll_size)
+        poll_header = _build_header(poll_cmd, poll_size)
         log.debug("Poll: cmd=0x%X, size=0x%X", poll_cmd, poll_size)
-        self._scsi_read(poll_header[:16], poll_size)
+        _scsi_read(self.device_path, poll_header[:16], poll_size)
 
         # Step 2: Init
         init_cmd, init_size = self.implementation.get_init_command()
-        init_header = self._build_header(init_cmd, init_size)
+        init_header = _build_header(init_cmd, init_size)
         log.debug("Init: cmd=0x%X, size=0x%X", init_cmd, init_size)
-        self._scsi_write(init_header, b'\x00' * init_size)
+        _scsi_write(self.device_path, init_header, b'\x00' * init_size)
 
         self.initialized = True
         log.info("LCD device initialized: %s (%s)", self.device_path,
@@ -194,11 +143,12 @@ class LCDDriver:
             image_data += b'\x00' * (total_size - len(image_data))
 
         # Send chunks
+        assert self.device_path is not None
         log.debug("Sending frame: %d bytes in %d chunks", total_size, len(chunks))
         offset = 0
         for cmd, size in chunks:
-            header = self._build_header(cmd, size)
-            self._scsi_write(header, image_data[offset:offset + size])
+            header = _build_header(cmd, size)
+            _scsi_write(self.device_path, header, image_data[offset:offset + size])
             offset += size
 
     def create_solid_color(self, r: int, g: int, b: int) -> bytes:

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/src/trcc/led_device.py

@@ -482,14 +482,14 @@ class LedHidSender(DeviceHandler):
                         resp[12],
                     )
 
-                # PM and SUB extraction — matches existing working behavior.
-                # UCDevice.cs uses data[6]/data[5] (with Report ID at [0]),
-                # but LED handshake already worked with these offsets in the
-                # field (shadowepaxeor-glitch got PM=0 cached from a live
-                # handshake). Keep resp[6]/resp[5] until we can verify with
-                # hex dumps from successful handshakes.
-                pm = resp[6]
-                sub_type = resp[5]
+                # PM and SUB extraction — matches Windows UCDevice.cs offsets.
+                # Windows HID API prepends Report ID at data[0], so:
+                #   data[6] = raw resp[5] = PM (product model byte)
+                #   data[5] = raw resp[4] = SUB (sub-variant byte)
+                # Previous code used resp[6]/resp[5] (off by one) which read
+                # zeros on AX120 devices (shadowepaxeor-glitch PM=0 was wrong).
+                pm = resp[5]
+                sub_type = resp[4]
                 style = get_style_for_pm(pm, sub_type)
 
                 override = SUB_TYPE_OVERRIDES.get((pm, sub_type))
@@ -504,6 +504,7 @@ class LedHidSender(DeviceHandler):
                     sub_type=sub_type,
                     style=style,
                     model_name=model_name,
+                    raw_response=bytes(resp[:64]),
                 )
 
             except Exception as e:

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/tests/hid_testing/test_led_device.py

@@ -85,14 +85,14 @@ def _make_mock_transport() -> MagicMock:
 def _make_valid_handshake_response(pm: int = 3, sub_type: int = 0) -> bytes:
     """Build a valid LED handshake response (64 bytes).
 
-    Args:
-        pm: Product model byte at resp[6].
-        sub_type: Sub-type byte at resp[5].
+    Offsets match Windows UCDevice.cs with Report ID removed:
+        PM  = data[6] → raw resp[5]
+        SUB = data[5] → raw resp[4]
     """
     resp = bytearray(LED_RESPONSE_SIZE)
     resp[0:4] = LED_MAGIC  # magic echo
-    resp[5] = sub_type
-    resp[6] = pm
+    resp[4] = sub_type     # SUB at raw[4] (Windows data[5])
+    resp[5] = pm           # PM at raw[5] (Windows data[6])
     resp[12] = LED_CMD_INIT  # cmd echo = 1
     return bytes(resp)
 
@@ -789,7 +789,7 @@ class TestLedHidSenderHandshake:
         assert read_args[0][1] == LED_RESPONSE_SIZE
 
     def test_handshake_extracts_pm(self):
-        """pm byte at response[6] should be extracted."""
+        """pm byte at response[5] (Windows data[6]) should be extracted."""
         transport = _make_mock_transport()
         transport.read.return_value = _make_valid_handshake_response(pm=48)
 
@@ -799,7 +799,7 @@ class TestLedHidSenderHandshake:
         assert info.pm == 48
 
     def test_handshake_extracts_sub_type(self):
-        """sub_type byte at response[5] should be extracted."""
+        """sub_type byte at response[4] (Windows data[5]) should be extracted."""
         transport = _make_mock_transport()
         transport.read.return_value = _make_valid_handshake_response(pm=1, sub_type=7)
 
@@ -891,6 +891,54 @@ class TestLedHidSenderHandshake:
             assert calls[0] == call(DELAY_PRE_INIT_S)
             assert calls[1] == call(DELAY_POST_INIT_S)
 
+    def test_handshake_pm_sub_offset_matches_windows(self):
+        """PM at raw[5] and SUB at raw[4] — matches Windows Report ID offset.
+
+        Windows HID API prepends Report ID at data[0], so:
+            data[6] = raw resp[5] = PM
+            data[5] = raw resp[4] = SUB
+        """
+        transport = _make_mock_transport()
+        resp = bytearray(LED_RESPONSE_SIZE)
+        resp[0:4] = LED_MAGIC
+        resp[4] = 0x42   # SUB at raw[4]
+        resp[5] = 0x80   # PM at raw[5] (128 = LC1)
+        resp[6] = 0xFF   # noise — should NOT be read as PM
+        resp[12] = 1
+        transport.read.return_value = bytes(resp)
+
+        sender = LedHidSender(transport)
+        info = sender.handshake()
+
+        assert info.pm == 0x80
+        assert info.sub_type == 0x42
+
+    def test_handshake_stores_raw_response(self):
+        """Handshake should store first 64 bytes of response for diagnostics."""
+        transport = _make_mock_transport()
+        transport.read.return_value = _make_valid_handshake_response(pm=3)
+
+        sender = LedHidSender(transport)
+        info = sender.handshake()
+
+        assert len(info.raw_response) == 64
+        assert info.raw_response[0:4] == LED_MAGIC
+
+    def test_handshake_hr10_via_sub_type(self):
+        """HR10 device (PM=128, SUB=129) resolved via SUB_TYPE_OVERRIDES."""
+        transport = _make_mock_transport()
+        transport.read.return_value = _make_valid_handshake_response(
+            pm=128, sub_type=129
+        )
+
+        sender = LedHidSender(transport)
+        info = sender.handshake()
+
+        assert info.pm == 128
+        assert info.sub_type == 129
+        assert info.style.style_id == 13
+        assert info.model_name == "HR10_2280_PRO_DIGITAL"
+
 
 class TestLedHidSenderSendLedData:
     """Test LedHidSender.send_led_data() chunking and transport calls."""

{trcc_linux-1.2.14 → trcc_linux-1.2.16}/tests/test_integration.py

@@ -39,8 +39,8 @@ def _make_png(path, w=320, h=320):
 class TestDetectToSend(unittest.TestCase):
     """Full pipeline: detect device → create LCDDriver → send_frame."""
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     def test_detect_init_send(self, mock_get_impl, mock_detect, mock_run, mock_sg):
@@ -78,8 +78,8 @@ class TestDetectToSend(unittest.TestCase):
         expected_calls = 1 + 1 + len(chunks)  # poll + init + chunks
         self.assertEqual(mock_run.call_count, expected_calls)
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     def test_send_image_pipeline(self, mock_get_impl, mock_detect, mock_run, mock_sg):
@@ -114,8 +114,8 @@ class TestDetectToSend(unittest.TestCase):
 class TestCLISendPipeline(unittest.TestCase):
     """CLI send_image() → LCDDriver → sg_raw."""
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     @patch("trcc.cli._get_selected_device", return_value="/dev/sg0")
@@ -147,8 +147,8 @@ class TestCLISendPipeline(unittest.TestCase):
         result = send_image("/nonexistent/image.png")
         self.assertEqual(result, 1)
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     def test_cli_send_color(self, mock_get_impl, mock_detect, mock_run, mock_sg):
@@ -180,8 +180,8 @@ class TestCLISendPipeline(unittest.TestCase):
 class TestCLIResumePipeline(unittest.TestCase):
     """CLI resume() — detect → load theme config → apply brightness/rotation → send."""
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     @patch("trcc.device_detector.detect_devices")
@@ -332,8 +332,8 @@ class TestDeviceDetectorRoundTrip(unittest.TestCase):
 class TestMultiResolution(unittest.TestCase):
     """Verify frame sizing and chunk counts for different resolutions."""
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     def test_480x480_frame_size(self, mock_get_impl, mock_detect, mock_run, mock_sg):
@@ -362,8 +362,8 @@ class TestMultiResolution(unittest.TestCase):
         # 480*480*2 = 460800, ceil(460800/65536) = 8 chunks
         self.assertEqual(len(chunks), 8)
 
-    @patch("trcc.lcd_driver.require_sg_raw")
-    @patch("trcc.lcd_driver.subprocess.run")
+    @patch("trcc.scsi_device.require_sg_raw")
+    @patch("trcc.scsi_device.subprocess.run")
     @patch("trcc.lcd_driver.detect_devices")
     @patch("trcc.lcd_driver.get_implementation")
     def test_240x240_frame_size(self, mock_get_impl, mock_detect, mock_run, mock_sg):
@@ -566,15 +566,9 @@ class TestSCSIHeaderIntegrity(unittest.TestCase):
         """_build_header produces 20-byte header with valid CRC32."""
         import binascii
 
-        from trcc.lcd_driver import LCDDriver
-
-        driver = LCDDriver.__new__(LCDDriver)
-        driver.device_info = None
-        driver.device_path = "/dev/sg0"
-        driver.implementation = None
-        driver.initialized = False
+        from trcc.scsi_device import _build_header
 
-        header = driver._build_header(0xF5, 0xE100)
+        header = _build_header(0xF5, 0xE100)
         self.assertEqual(len(header), 20)
 
         # First 4 bytes = cmd (little-endian)