HID Get Report

Author: DavidLesnjak

pyocd/probe/pydapaccess/interface/hidapi_backend.py

@@ -20,17 +20,17 @@
 import platform
 import threading
 import queue
-from typing import Optional
+import struct
+import array
+from typing import Optional, Tuple
 
 from .interface import Interface
 from .common import (
-    USB_CLASS_HID,
     filter_device_by_usage_page,
     generate_device_unique_id,
     is_known_cmsis_dap_vid_pid,
     )
 from ..dap_access_api import DAPAccessIntf
-from .pyusb_backend import MatchCmsisDapv1Interface
 from ....utility.compatibility import to_str_safe
 from ....utility.timeout import Timeout
 
@@ -40,11 +40,6 @@
 
 try:
     import hid
-    import usb.util
-    try:
-        from libusb_package import find as usb_find
-    except ImportError:
-        from usb.core import find as usb_find
 except ImportError:
     IS_AVAILABLE = False
 else:
@@ -54,6 +49,97 @@
 _IS_DARWIN = (platform.system() == 'Darwin')
 _IS_WINDOWS = (platform.system() == 'Windows')
 
+if _IS_WINDOWS:
+    import ctypes
+    from ctypes import wintypes
+
+    # Define necessary Windows structures and functions for HID
+    class HIDP_CAPS(ctypes.Structure):
+        _fields_ = [
+            ("Usage", wintypes.USHORT),
+            ("UsagePage", wintypes.USHORT),
+            ("InputReportByteLength", wintypes.USHORT),
+            ("OutputReportByteLength", wintypes.USHORT),
+            ("FeatureReportByteLength", wintypes.USHORT),
+            ("Reserved", wintypes.USHORT * 17),
+            ("NumberLinkCollectionNodes", wintypes.USHORT),
+            ("NumberInputButtonCaps", wintypes.USHORT),
+            ("NumberInputValueCaps", wintypes.USHORT),
+            ("NumberInputDataIndices", wintypes.USHORT),
+            ("NumberOutputButtonCaps", wintypes.USHORT),
+            ("NumberOutputValueCaps", wintypes.USHORT),
+            ("NumberOutputDataIndices", wintypes.USHORT),
+            ("NumberFeatureButtonCaps", wintypes.USHORT),
+            ("NumberFeatureValueCaps", wintypes.USHORT),
+            ("NumberFeatureDataIndices", wintypes.USHORT),
+        ]
+
+    hid_dll = ctypes.windll.hid
+    kernel32_dll = ctypes.windll.kernel32
+
+    # HidD_GetPreparsedData
+    hid_dll.HidD_GetPreparsedData.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.HANDLE)]
+    hid_dll.HidD_GetPreparsedData.restype = wintypes.BOOLEAN
+
+    # HidP_GetCaps
+    hid_dll.HidP_GetCaps.argtypes = [wintypes.HANDLE, ctypes.POINTER(HIDP_CAPS)]
+    hid_dll.HidP_GetCaps.restype = ctypes.c_long # NTSTATUS
+
+    # HidD_FreePreparsedData
+    hid_dll.HidD_FreePreparsedData.argtypes = [wintypes.HANDLE]
+    hid_dll.HidD_FreePreparsedData.restype = wintypes.BOOLEAN
+
+    # CreateFileW
+    kernel32_dll.CreateFileW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, ctypes.c_void_p, wintypes.DWORD, wintypes.DWORD, wintypes.HANDLE]
+    kernel32_dll.CreateFileW.restype = wintypes.HANDLE
+
+    # CloseHandle
+    kernel32_dll.CloseHandle.argtypes = [wintypes.HANDLE]
+    kernel32_dll.CloseHandle.restype = wintypes.BOOL
+
+    INVALID_HANDLE_VALUE = -1
+    GENERIC_READ = 0x80000000
+    GENERIC_WRITE = 0x40000000
+    FILE_SHARE_READ = 1
+    FILE_SHARE_WRITE = 2
+    OPEN_EXISTING = 3
+
+elif _IS_DARWIN:
+    import ctypes
+    import ctypes.util
+
+    iokit = ctypes.cdll.LoadLibrary(ctypes.util.find_library('IOKit'))
+
+    kCFStringEncodingUTF8 = 0x08000100
+
+    # Define CFString functions
+    CFStringCreateWithCString = iokit.CFStringCreateWithCString
+    CFStringCreateWithCString.restype = ctypes.c_void_p
+    CFStringCreateWithCString.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_uint32]
+
+    CFRelease = iokit.CFRelease
+    CFRelease.restype = None
+    CFRelease.argtypes = [ctypes.c_void_p]
+
+    # Define IOHIDDevice functions
+    IOHIDDeviceGetProperty = iokit.IOHIDDeviceGetProperty
+    IOHIDDeviceGetProperty.restype = ctypes.c_void_p
+    IOHIDDeviceGetProperty.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+
+    # Define CFNumber functions
+    CFNumberGetValue = iokit.CFNumberGetValue
+    CFNumberGetValue.restype = ctypes.c_bool
+    CFNumberGetValue.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_void_p]
+    kCFNumberSInt32Type = 3
+
+    # Keys for IOHIDDeviceGetProperty
+    def _create_cfstring(s):
+        return CFStringCreateWithCString(None, s.encode('utf-8'), kCFStringEncodingUTF8)
+
+    kIOHIDMaxInputReportSizeKey = _create_cfstring("MaxInputReportSize")
+    kIOHIDMaxOutputReportSizeKey = _create_cfstring("MaxOutputReportSize")
+
+
 class HidApiUSB(Interface):
     """@brief CMSIS-DAP USB interface class using hidapi backend."""
 
@@ -91,48 +177,14 @@ def set_packet_count(self, count):
         self.packet_count = count
 
     def open(self):
+        probe_id = self.serial_number or f"VID={self.vid:#06x}:PID={self.pid:#06x}"
 
-        # Use pyUSB to get HID Interrupt EP wMaxPacketSize, since hidapi is not reliable
-
-        # Get device handle.
-        # If multiple identical (same PID & VID) probes without serial number are connected,
-        # assume they share the same wMaxPacketSize.
-
-        usb_serial = self.device_info['serial_number']
-
-        kwargs = {'idVendor': self.vid, 'idProduct': self.pid}
-        if usb_serial:  # only pass a real USB serial
-            kwargs['serial_number'] = usb_serial
-
-        probe_id = usb_serial or f"VID={self.vid:#06x}:PID={self.pid:#06x}"
-
-        dev = usb_find(**kwargs)
-        if dev is None:
-            raise DAPAccessIntf.DeviceError(f"Probe {probe_id} not found")
-
-        # Get active config
-        config = dev.get_active_configuration()
-
-        # Get count of HID interfaces and create the matcher object
-        hid_interface_count = len(list(usb.util.find_descriptor(config, find_all=True, bInterfaceClass=USB_CLASS_HID)))
-        matcher = MatchCmsisDapv1Interface(hid_interface_count)
-
-        # Get CMSIS-DAPv1 interface
-        interface = usb.util.find_descriptor(config, custom_match=matcher)
-        if interface is None:
-            raise DAPAccessIntf.DeviceError(f"Probe {probe_id} has no CMSIS-DAPv1 interface")
-
-        # Set report sizes, assuming HID report size matches endpoint wMaxPacketSize.
-        for endpoint in interface:
-            if usb.util.endpoint_type(endpoint.bmAttributes) == usb.util.ENDPOINT_TYPE_INTR:
-                if endpoint.bEndpointAddress & usb.util.ENDPOINT_IN:
-                    self.report_in_size = endpoint.wMaxPacketSize
-                else:
-                    self.report_out_size = endpoint.wMaxPacketSize
+        self.report_in_size, self.report_out_size = self._get_hid_report_sizes()
 
         if self.report_in_size is None:
-            raise DAPAccessIntf.DeviceError(
-                f"Could not determine packet sizes for probe {probe_id}")
+            # Fallback: set report size to 64 bytes
+            LOG.warning("Could not determine IN report size for probe %s, defaulting to 64 bytes", probe_id)
+            self.report_in_size = 64
 
         if self.report_out_size is None:
             # No interrupt OUT endpoint. Out reports will be sent via control transfer.
@@ -156,6 +208,74 @@ def open(self):
 
         self.closed = False
 
+    def _get_hid_report_sizes(self) -> Tuple[Optional[int], Optional[int]]:
+        """Get actual HID report sizes using platform-specific APIs."""
+        if _IS_WINDOWS:
+            return self._get_hid_report_sizes_windows()
+        elif _IS_DARWIN:
+            return self._get_hid_report_sizes_macos()
+        else:
+            # Linux and other OSes are not supported for this mechanism.
+            LOG.debug("Unsupported OS for getting HID report sizes directly.")
+            return None, None
+
+    def _get_hid_report_sizes_windows(self) -> Tuple[Optional[int], Optional[int]]:
+        try:
+            path = to_str_safe(self.device_info['path'])
+            handle = kernel32_dll.CreateFileW(path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, None, OPEN_EXISTING, 0, None)
+        except Exception as exc:
+            LOG.error("Exception opening device handle for HID report size query: %s", exc)
+            return None, None
+
+        if handle == INVALID_HANDLE_VALUE:
+            LOG.debug("Failed to open device handle for HID report size query.")
+            return None, None
+
+        try:
+            preparsed_data = wintypes.HANDLE()
+            if not hid_dll.HidD_GetPreparsedData(handle, ctypes.byref(preparsed_data)):
+                LOG.debug("HidD_GetPreparsedData failed.")
+                return None, None
+
+            try:
+                caps = HIDP_CAPS()
+                HIDP_STATUS_SUCCESS = 0x00110000
+                if hid_dll.HidP_GetCaps(preparsed_data, ctypes.byref(caps)) == HIDP_STATUS_SUCCESS:
+                    # The lengths include the report ID byte, which we don't use in the packet size.
+                    # However, the packet size should match the report size.
+                    return caps.InputReportByteLength, caps.OutputReportByteLength
+                else:
+                    LOG.debug("HidP_GetCaps failed.")
+                    return None, None
+            finally:
+                hid_dll.HidD_FreePreparsedData(preparsed_data)
+        finally:
+            kernel32_dll.CloseHandle(handle)
+        return None, None
+
+    def _get_hid_report_sizes_macos(self) -> Tuple[Optional[int], Optional[int]]:
+        # The hid.device object from hidapi is what we need.
+        # The underlying object is an IOHIDDeviceRef, which is a void*
+        hid_device_ref = ctypes.c_void_p(self.device.dev)
+        input_size = None
+        output_size = None
+
+        # Get input report size
+        value_ref = IOHIDDeviceGetProperty(hid_device_ref, kIOHIDMaxInputReportSizeKey)
+        if value_ref:
+            val = ctypes.c_int32(0)
+            if CFNumberGetValue(value_ref, kCFNumberSInt32Type, ctypes.byref(val)):
+                input_size = val.value
+
+        # Get output report size
+        value_ref = IOHIDDeviceGetProperty(hid_device_ref, kIOHIDMaxOutputReportSizeKey)
+        if value_ref:
+            val = ctypes.c_int32(0)
+            if CFNumberGetValue(value_ref, kCFNumberSInt32Type, ctypes.byref(val)):
+                output_size = val.value
+
+        return input_size, output_size
+
     def rx_task(self):
         try:
             while not self.closed_event.is_set():