touchscreen: Dump firmware version and protocol

JohnAZoidberg · JohnAZoidberg · commit 6c57b1e168fb · 2025-04-14T17:55:52.000+08:00
```
&gt; framework_tool --versions
[...]
Touchscreen
  Firmware Version: v7.0.0.4.0.0.0.0
  USI Protocol:     false
  MPP Protocol:     true
```

Signed-off-by: Daniel Schaefer &lt;dhs@frame.work&gt;
diff --git a/README.md b/README.md
@@ -43,7 +43,8 @@ see the [Support Matrices](support-matrices.md).
     - [x] PD
     - [x] ME (Only on Linux)
     - [x] Retimer
-    - [x] Touchpad (Linux and Windows)
+    - [x] Touchpad (Linux, Windows, FreeBSD, not UEFI)
+    - [x] Touchscreen (Linux, Windows, FreeBSD, not UEFI)
   - [x] Get Expansion Card Firmware (Not on UEFI so far)
     - [x] HDMI Expansion Card (`--dp-hdmi-info`)
     - [x] DisplayPort Expansion Card (`--dp-hdmi-info`)
@@ -69,6 +70,7 @@ All of these need EC communication support in order to work.
 - [x] Get and set keyboard brightness (`--kblight`)
 - [x] Get and set battery charge limit (`--charge-limit`)
 - [x] Get and set fingerprint LED brightness (`--fp-brightness`)
+- [x] Disable/Enable touchscreen (`--touchscreen-enable`)
 
 ###### Communication with Embedded Controller
 
@@ -177,6 +179,8 @@ Options:
       --intrusion                   Show status of intrusion switch
       --inputmodules                Show status of the input modules (Framework 16 only)
       --kblight [<KBLIGHT>]         Set keyboard backlight percentage or get, if no value provided
+      --touchscreen-enable <TOUCHSCREEN_ENABLE>
+          Enable/disable touchscreen [possible values: true, false]
       --console <CONSOLE>           Get EC console, choose whether recent or to follow the output [possible values: recent, follow]
       --driver <DRIVER>             Select which driver is used. By default portio is used [possible values: portio, cros-ec, windows]
   -t, --test                        Run self-test to check if interaction with EC is possible
diff --git a/framework_lib/Cargo.toml b/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"
 ]
 
diff --git a/framework_lib/src/commandline/mod.rs b/framework_lib/src/commandline/mod.rs
@@ -52,6 +52,8 @@ use crate::smbios::ConfigDigit0;
 use crate::smbios::{dmidecode_string_val, get_smbios, is_framework};
 #[cfg(feature = "hidapi")]
 use crate::touchpad::print_touchpad_fw_ver;
+#[cfg(feature = "hidapi")]
+use crate::touchscreen::print_touchscreen_fw_ver;
 #[cfg(feature = "uefi")]
 use crate::uefi::enable_page_break;
 use crate::util;
@@ -479,6 +481,9 @@ fn print_versions(ec: &CrosEc) {
 
     #[cfg(feature = "hidapi")]
     let _ignore_err = print_touchpad_fw_ver();
+
+    #[cfg(feature = "hidapi")]
+    let _ignore_err = print_touchscreen_fw_ver();
 }
 
 fn print_esrt() {
diff --git a/framework_lib/src/lib.rs b/framework_lib/src/lib.rs
@@ -18,6 +18,10 @@ pub mod audio_card;
 pub mod camera;
 #[cfg(feature = "hidapi")]
 pub mod touchpad;
+#[cfg(any(feature = "hidapi", feature = "windows"))]
+pub mod touchscreen;
+#[cfg(feature = "windows")]
+pub mod touchscreen_win;
 
 #[cfg(feature = "uefi")]
 #[macro_use]
diff --git a/framework_lib/src/touchscreen.rs b/framework_lib/src/touchscreen.rs
@@ -0,0 +1,142 @@
+use hidapi::{HidApi, HidDevice};
+
+#[cfg(target_os = "windows")]
+use crate::touchscreen_win;
+
+pub const ILI_VID: u16 = 0x222A;
+pub const ILI_PID: u16 = 0x5539;
+pub const USI_BITMAP: u8 = 1 << 1;
+pub const MPP_BITMAP: u8 = 1 << 2;
+
+struct HidapiTouchScreen {
+    device: HidDevice,
+}
+
+impl TouchScreen for HidapiTouchScreen {
+    fn open_device() -> Option<HidapiTouchScreen> {
+        debug!("Looking for touchscreen HID device");
+        match HidApi::new() {
+            Ok(api) => {
+                for dev_info in api.device_list() {
+                    let vid = dev_info.vendor_id();
+                    let pid = dev_info.product_id();
+                    let usage_page = dev_info.usage_page();
+                    if vid != ILI_VID {
+                        trace!("    Skipping VID:PID. Expected {:04X}:*", ILI_VID);
+                        continue;
+                    }
+                    debug!(
+                        "  Found {:04X}:{:04X} (Usage Page {:04X})",
+                        vid, pid, usage_page
+                    );
+                    if usage_page != 0xFF00 {
+                        debug!("    Skipping usage page. Expected {:04X}", 0xFF00);
+                        continue;
+                    }
+                    if pid != ILI_PID {
+                        debug!("  Warning: PID is {:04X}, expected {:04X}", pid, ILI_PID);
+                    }
+
+                    debug!("  Found matching touchscreen HID device");
+                    debug!("  Path:             {:?}", dev_info.path());
+                    debug!("  IC Type:          {:04X}", pid);
+
+                    // Unwrapping because if we can enumerate it, we should be able to open it
+                    let device = dev_info.open_device(&api).unwrap();
+                    debug!("  Opened device.");
+
+                    return Some(HidapiTouchScreen { device });
+                }
+            }
+            Err(e) => {
+                error!("Failed to open hidapi. Error: {e}");
+            }
+        };
+
+        None
+    }
+
+    fn send_message(&self, 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];
+        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;
+        }
+
+        // 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"))]
+        let send_feature_report = true;
+
+        if send_feature_report {
+            debug!("  send_feature_report {:X?}", msg);
+            self.device.send_feature_report(&msg).ok()?;
+        } else {
+            debug!("  Writing {:X?}", msg);
+            self.device.write(&msg).ok()?;
+        };
+
+        if read_len == 0 {
+            return Some(vec![]);
+        }
+
+        let msg_len = 3 + data_len;
+        let mut buf: [u8; 0x40] = [0; 0x40];
+        debug!("  Reading");
+        let res = self.device.read(&mut buf);
+        debug!("  res: {:?}", res);
+        debug!("  Read buf: {:X?}", buf);
+        Some(buf[msg_len..msg_len + read_len].to_vec())
+    }
+}
+
+pub trait TouchScreen {
+    fn open_device() -> Option<Self>
+    where
+        Self: std::marker::Sized;
+    fn send_message(&self, message_id: u8, read_len: usize, data: Vec<u8>) -> Option<Vec<u8>>;
+
+    fn check_fw_version(&self) -> Option<()> {
+        println!("Touchscreen");
+        let res = self.send_message(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 = self.send_message(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 = self.send_message(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<()> {
+    #[cfg(target_os = "windows")]
+    let device = touchscreen_win::NativeWinTouchScreen::open_device()?;
+    #[cfg(not(target_os = "windows"))]
+    let device = HidapiTouchScreen::open_device()?;
+
+    device.check_fw_version()
+}
diff --git a/framework_lib/src/touchscreen_win.rs b/framework_lib/src/touchscreen_win.rs
@@ -0,0 +1,101 @@
+use crate::touchscreen::TouchScreen;
+#[allow(unused_imports)]
+use windows::{
+    core::*,
+    Win32::{
+        Devices::HumanInterfaceDevice::*,
+        Devices::Properties::*,
+        Foundation::*,
+        Storage::FileSystem::*,
+        System::Threading::ResetEvent,
+        System::IO::{CancelIoEx, DeviceIoControl},
+        System::{Ioctl::*, IO::*},
+    },
+};
+
+pub struct NativeWinTouchScreen {
+    handle: HANDLE,
+}
+
+impl TouchScreen for NativeWinTouchScreen {
+    fn open_device() -> Option<Self> {
+        // 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,
+                FILE_GENERIC_WRITE.0 | FILE_GENERIC_READ.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(NativeWinTouchScreen { handle })
+    }
+
+    fn send_message(&self, 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(
+                self.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);
+
+            if read_len == 0 {
+                return Some(vec![]);
+            }
+
+            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(self.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())
+    }
+}
