touchscreen: Make it work on windows

```
> target\debug\framework_tool.exe --versions
  Firmware Version: v7.0.0.4.0.0.0.0
  USI Protocol:     false
  MPP Protocol:     true
```

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

framework_lib/Cargo.toml

@@ -63,7 +63,7 @@ uefi = { version = "0.20", features = ["alloc"], optional = true }
 uefi-services = { version = "0.17", optional = true }
 plain = { version = "0.2.3", optional = true }
 spin = { version = "0.9.8", optional = false }
-hidapi = { version = "2.6.3", optional = true }
+hidapi = { version = "2.6.3", optional = true, features = [ "windows-native" ] }
 rusb = { version = "0.9.4", optional = true }
 no-std-compat = { version = "0.4.1", features = [ "alloc" ] }
 guid_macros = { path = "../guid_macros" }
@@ -89,5 +89,12 @@ features = [
     "Win32_System_IO",
     "Win32_System_Ioctl",
     "Win32_System_SystemServices",
+    # For HID devices
+    "Win32_Devices_DeviceAndDriverInstallation",
+    "Win32_Devices_HumanInterfaceDevice",
+    "Win32_Devices_Properties",
+    "Win32_Storage_EnhancedStorage",
+    "Win32_System_Threading",
+    "Win32_UI_Shell_PropertiesSystem"
 ]
 

framework_lib/src/lib.rs

@@ -20,6 +20,8 @@ pub mod camera;
 pub mod touchpad;
 #[cfg(feature = "hidapi")]
 pub mod touchscreen;
+#[cfg(feature = "windows")]
+pub mod touchscreen_win;
 
 #[cfg(feature = "uefi")]
 #[macro_use]

framework_lib/src/touchscreen.rs

@@ -1,5 +1,10 @@
 use hidapi::{HidApi, HidDevice, HidError};
 
+#[cfg(target_os = "windows")]
+use crate::touchscreen_win;
+
+use std::{thread, time};
+
 pub const ILI_VID: u16 = 0x222A;
 pub const ILI_PID: u16 = 0x5539;
 pub const USI_BITMAP: u8 = 1 << 1;
@@ -20,6 +25,7 @@ fn send_message(device: &HidDevice, message_id: u8, read_len: usize, data: Vec<u
 
     // Not sure why, but on Windows we just have to write an output report
     // HidApiError { message: "HidD_SetFeature: (0x00000057) The parameter is incorrect." }
+    // Still doesn't work on Windows. Need to write a byte more than the buffer is long
     #[cfg(target_os = "windows")]
     let send_feature_report = false;
     #[cfg(not(target_os = "windows"))]
@@ -33,7 +39,6 @@ fn send_message(device: &HidDevice, message_id: u8, read_len: usize, data: Vec<u
         device.write(&msg)?;
     }
 
-    use std::{thread, time};
     thread::sleep(time::Duration::from_millis(1000));
 
     if read_len == 0 {
@@ -46,28 +51,10 @@ fn send_message(device: &HidDevice, message_id: u8, read_len: usize, data: Vec<u
     let mut res = device.read(&mut buf);
     debug!("  res: {:?}", res);
     debug!("  Read buf: {:X?}", buf);
-    if let Err(_) = res {
-        res = device.read_timeout(&mut buf[..read_len + msg_len], 100);
-        debug!("  res: {:?}", res);
-        debug!("  Read buf: {:X?}", buf);
-    }
-    if let Err(_) = res {
-        res = device.read_timeout(&mut buf[..read_len + msg_len], 100);
-        debug!("  res: {:?}", res);
-        debug!("  Read buf: {:X?}", buf);
-    }
-    if let Err(_) = res {
-        res = device.read_timeout(&mut buf[..read_len + msg_len], 100);
-        debug!("  res: {:?}", res);
-        debug!("  Read buf: {:X?}", buf);
-    }
-    if let Err(_) = res {
-        device.read_timeout(&mut buf[..read_len + msg_len], 100)?;
-        debug!("  Read buf: {:X?}", buf);
-    }
     Ok(buf[msg_len..msg_len + read_len].to_vec())
 }
 
+#[cfg(not(target_os = "windows"))]
 fn check_fw_version(device: &HidDevice) -> Result<(), HidError> {
     device.set_blocking_mode(true).unwrap();
     send_message(device, 0xF0, 0, vec![3, 0, 0]).unwrap();
@@ -97,7 +84,13 @@ fn check_fw_version(device: &HidDevice) -> Result<(), HidError> {
     Ok(())
 }
 
-pub fn print_touchscreen_fw_ver() -> Result<(), HidError> {
+#[cfg(target_os = "windows")]
+pub fn print_touchscreen_fw_ver() -> Option<()> {
+    touchscreen_win::print_touchscreen_fw_ver()
+}
+
+#[cfg(not(target_os = "windows"))]
+pub fn print_touchscreen_fw_ver() -> Option<()> {
     debug!("Looking for touchscreen HID device");
     match HidApi::new() {
         Ok(api) => {
@@ -141,5 +134,5 @@ pub fn print_touchscreen_fw_ver() -> Result<(), HidError> {
         }
     };
 
-    Ok(())
+    Some(())
 }

framework_lib/src/touchscreen_win.rs

@@ -0,0 +1,136 @@
+#[allow(unused_imports)]
+use windows::{
+    core::*,
+    Win32::{
+        Devices::HumanInterfaceDevice::*,
+        Devices::Properties::*,
+        Foundation::*,
+        Storage::FileSystem::*,
+        System::{Ioctl::*, IO::*},
+        System::Threading::ResetEvent,
+        System::IO::{CancelIoEx, DeviceIoControl},
+    },
+};
+
+pub const USI_BITMAP: u8 = 1 << 1;
+pub const MPP_BITMAP: u8 = 1 << 2;
+
+pub fn open_device(open_rw: bool) -> Option<HANDLE> {
+    // TODO: I don't know if this might be different on other systems
+    // Should enumerate and find the right one
+    // See: https://learn.microsoft.com/en-us/windows-hardware/drivers/hid/finding-and-opening-a-hid-collection
+    let path = w!(r"\\?\HID#ILIT2901&Col03#5&357cbf85&0&0002#{4d1e55b2-f16f-11cf-88cb-001111000030}");
+
+    let res = unsafe {
+        CreateFileW(
+            path,
+            match open_rw {
+                true => FILE_GENERIC_WRITE.0 | FILE_GENERIC_READ.0,
+                false => 0,
+            },
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            None,
+            OPEN_EXISTING,
+            // hidapi-rs is using FILE_FLAG_OVERLAPPED but it doesn't look like we need that
+            FILE_FLAGS_AND_ATTRIBUTES(0),
+            None,
+        )
+    };
+    let handle = match res {
+        Ok(h) => h,
+        Err(err) => {
+            error!("Failed to open device {:?}", err);
+            return None;
+        }
+    };
+
+    debug!("Opened {:?}", path);
+
+    Some(handle)
+}
+
+pub fn send_message(handle: &HANDLE, message_id: u8, read_len: usize, data: Vec<u8>) -> Option<Vec<u8>> {
+    let report_id = 0x03;
+    let data_len = data.len();
+    let mut msg = [0u8; 0x40];
+    let msg_len = 3 + data_len;
+    msg[0] = report_id;
+    msg[1] = 0xA3;
+    msg[2] = data_len as u8;
+    msg[3] = read_len as u8;
+    msg[4] = message_id;
+    for (i, b) in data.into_iter().enumerate() {
+        msg[5 + i] = b;
+    }
+
+    let mut buf = [0u8; 0x40];
+    buf[0] = report_id;
+
+    unsafe {
+        debug!("  HidD_SetOutputReport {:X?}", msg);
+        let success = HidD_SetOutputReport(
+            *handle,
+            // Microsoft docs says that the first byte of the message has to be the report ID.
+            // This is normal with HID implementations.
+            // But it seems on Windows (at least for this device's firmware) we have to set the
+            // length as one more than the buffer is long.
+            // Otherwise no data is returned in the read call later.
+            msg.as_mut_ptr() as _,
+            msg.len() as u32 + 1,
+        );
+        debug!("    Success: {}", success);
+
+        let mut bytes_read = 0;
+        debug!("  ReadFile");
+        // HidD_GetFeature doesn't work, have to use ReadFile
+        // Microsoft does recommend that
+        // https://learn.microsoft.com/en-us/windows-hardware/drivers/hid/obtaining-hid-reports
+        let res = ReadFile(
+            *handle,
+            Some(&mut buf),
+            Some(&mut bytes_read),
+            None,
+        );
+        debug!("    Success: {:?}, Bytes: {}", res, bytes_read);
+        debug!("    Read buf: {:X?}", buf);
+        debug!("    Read msg: {:X?}", msg);
+
+    }
+
+    Some(buf[msg_len..msg_len + read_len].to_vec())
+}
+
+pub fn check_fw_version(device: &HANDLE) -> Option<()> {
+    let res = send_message(device, 0x42, 3, vec![0])?;
+    let ver = res
+        .iter()
+        .skip(1)
+        .fold(format!("{:02X}", res[0]), |acc, &x| {
+            acc + "." + &format!("{:02X}", x)
+        });
+    // Expecting 06.00.0A
+    debug!("  Protocol Version: v{}", ver);
+
+    let res = send_message(device, 0x40, 8, vec![0])?;
+    let ver = res
+        .iter()
+        .skip(1)
+        .fold(res[0].to_string(), |acc, &x| acc + "." + &x.to_string());
+    println!("  Firmware Version: v{}", ver);
+
+    let res = send_message(device, 0x20, 16, vec![0])?;
+    println!("  USI Protocol:     {:?}", (res[15] & USI_BITMAP) > 0);
+    println!("  MPP Protocol:     {:?}", (res[15] & MPP_BITMAP) > 0);
+
+    Some(())
+}
+
+pub fn print_touchscreen_fw_ver() -> Option<()> {
+    let device = open_device(true)?;
+
+    if let None = check_fw_version(&device) {
+        error!("Failed to read touchscreen firmware version");
+    };
+
+    Some(())
+}