--versions: Get stylus information through USI

Only works on our touchscreen because report IDs are hardcoded instead
of derived from report descriptor.

```
> sudo framework_tool --versions
[...]
Stylus
  Serial Number:    28C1A00-12E71DAE
  Vendor ID:        32AC (Framework Computer)
  Product ID:       002B (Framework Stylus)
  Firmware Version: FF.FF
[...]
```

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

Author: JohnAZoidberg

EXAMPLES.md

@@ -33,6 +33,19 @@ Touchscreen
   MPP Protocol:     true
 ```
 
+### Stylus (Framework 12)
+
+```
+> sudo framework_tool --versions
+[...]
+Stylus
+  Serial Number:    28C1A00-12E71DAE
+  Vendor ID:        32AC (Framework Computer)
+  Product ID:       002B (Framework Stylus)
+  Firmware Version: FF.FF
+[...]
+```
+
 ### Touchpad (Framework 12, Framework 13, Framework 16)
 
 ```

framework_lib/src/touchscreen.rs

@@ -5,16 +5,24 @@ use crate::touchscreen_win;
 
 pub const ILI_VID: u16 = 0x222A;
 pub const ILI_PID: u16 = 0x5539;
+const VENDOR_USAGE_PAGE: u16 = 0xFF00;
 pub const USI_BITMAP: u8 = 1 << 1;
 pub const MPP_BITMAP: u8 = 1 << 2;
 
+const REPORT_ID_FIRMWARE: u8 = 0x27;
+const REPORT_ID_USI_VER: u8 = 0x28;
+
 struct HidapiTouchScreen {
     device: HidDevice,
 }
 
 impl TouchScreen for HidapiTouchScreen {
-    fn open_device() -> Option<HidapiTouchScreen> {
-        debug!("Looking for touchscreen HID device");
+    fn open_device(target_up: u16, skip: u8) -> Option<HidapiTouchScreen> {
+        debug!(
+            "Looking for touchscreen HID device {:X} {}",
+            target_up, skip
+        );
+        let mut skip = skip;
         match HidApi::new() {
             Ok(api) => {
                 for dev_info in api.device_list() {
@@ -29,7 +37,7 @@ impl TouchScreen for HidapiTouchScreen {
                         "  Found {:04X}:{:04X} (Usage Page {:04X})",
                         vid, pid, usage_page
                     );
-                    if usage_page != 0xFF00 {
+                    if usage_page != target_up {
                         debug!("    Skipping usage page. Expected {:04X}", 0xFF00);
                         continue;
                     }
@@ -40,6 +48,10 @@ impl TouchScreen for HidapiTouchScreen {
                     debug!("  Found matching touchscreen HID device");
                     debug!("  Path:             {:?}", dev_info.path());
                     debug!("  IC Type:          {:04X}", pid);
+                    if skip > 0 {
+                        skip -= 1;
+                        continue;
+                    }
 
                     // Unwrapping because if we can enumerate it, we should be able to open it
                     let device = dev_info.open_device(&api).unwrap();
@@ -97,16 +109,57 @@ impl TouchScreen for HidapiTouchScreen {
         debug!("  Read buf: {:X?}", buf);
         Some(buf[msg_len..msg_len + read_len].to_vec())
     }
+
+    fn get_stylus_fw(&self) -> Option<()> {
+        let mut msg = [0u8; 0x40];
+        msg[0] = REPORT_ID_USI_VER;
+        self.device.get_feature_report(&mut msg).ok()?;
+        let usi_major = msg[2];
+        let usi_minor = msg[3];
+        debug!("USI version (Major.Minor): {}.{}", usi_major, usi_minor);
+
+        if usi_major != 2 || usi_minor != 0 {
+            // Probably not USI mode
+            return None;
+        }
+
+        let mut msg = [0u8; 0x40];
+        msg[0] = REPORT_ID_FIRMWARE;
+        self.device.get_feature_report(&mut msg).ok()?;
+        let sn_low = u32::from_le_bytes([msg[2], msg[3], msg[4], msg[5]]);
+        let sn_high = u32::from_le_bytes([msg[6], msg[7], msg[8], msg[9]]);
+        let vid = u16::from_le_bytes([msg[14], msg[15]]);
+        let vendor = if vid == 0x32AC {
+            " (Framework Computer)"
+        } else {
+            ""
+        };
+        let pid = u16::from_le_bytes([msg[16], msg[17]]);
+        let product = if pid == 0x002B {
+            " (Framework Stylus)"
+        } else {
+            ""
+        };
+        println!("Stylus");
+        println!("  Serial Number:    {:X}-{:X}", sn_high, sn_low);
+        debug!("  Redundant SN      {:X?}", &msg[10..14]);
+        println!("  Vendor ID:        {:04X}{}", vid, vendor);
+        println!("  Product ID:       {:04X}{}", pid, product);
+        println!("  Firmware Version: {:02X}.{:02X}", &msg[18], msg[19]);
+
+        Some(())
+    }
 }
 
 pub trait TouchScreen {
-    fn open_device() -> Option<Self>
+    fn open_device(usage_page: u16, skip: u8) -> 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()
@@ -135,22 +188,32 @@ pub trait TouchScreen {
         self.send_message(0x38, 0, vec![!enable as u8, 0x00])?;
         Some(())
     }
+
+    fn get_stylus_fw(&self) -> Option<()>;
 }
 
 pub fn print_fw_ver() -> Option<()> {
+    for skip in 0..5 {
+        if let Some(device) = HidapiTouchScreen::open_device(0x000D, skip) {
+            if device.get_stylus_fw().is_some() {
+                break;
+            }
+        }
+    }
+
     #[cfg(target_os = "windows")]
-    let device = touchscreen_win::NativeWinTouchScreen::open_device()?;
+    let device = touchscreen_win::NativeWinTouchScreen::open_device(VENDOR_USAGE_PAGE, 0)?;
     #[cfg(not(target_os = "windows"))]
-    let device = HidapiTouchScreen::open_device()?;
+    let device = HidapiTouchScreen::open_device(VENDOR_USAGE_PAGE, 0)?;
 
     device.check_fw_version()
 }
 
 pub fn enable_touch(enable: bool) -> Option<()> {
     #[cfg(target_os = "windows")]
-    let device = touchscreen_win::NativeWinTouchScreen::open_device()?;
+    let device = touchscreen_win::NativeWinTouchScreen::open_device(VENDOR_USAGE_PAGE, 0)?;
     #[cfg(not(target_os = "windows"))]
-    let device = HidapiTouchScreen::open_device()?;
+    let device = HidapiTouchScreen::open_device(VENDOR_USAGE_PAGE, 0)?;
 
     device.enable_touch(enable)
 }

framework_lib/src/touchscreen_win.rs

@@ -16,13 +16,20 @@ use windows::{
     },
 };
 
+const REPORT_ID_FIRMWARE: u8 = 0x27;
+const REPORT_ID_USI_VER: u8 = 0x28;
+
 pub struct NativeWinTouchScreen {
     handle: HANDLE,
 }
 
 impl TouchScreen for NativeWinTouchScreen {
-    fn open_device() -> Option<Self> {
-        debug!("Looking for touchscreen HID device");
+    fn open_device(target_up: u16, skip: u8) -> Option<Self> {
+        debug!(
+            "Looking for touchscreen HID device {:X} {}",
+            target_up, skip
+        );
+        let mut skip = skip;
         match HidApi::new() {
             Ok(api) => {
                 for dev_info in api.device_list() {
@@ -37,7 +44,7 @@ impl TouchScreen for NativeWinTouchScreen {
                         "  Found {:04X}:{:04X} (Usage Page {:04X})",
                         vid, pid, usage_page
                     );
-                    if usage_page != 0xFF00 {
+                    if usage_page != target_up {
                         debug!("    Skipping usage page. Expected {:04X}", 0xFF00);
                         continue;
                     }
@@ -48,6 +55,10 @@ impl TouchScreen for NativeWinTouchScreen {
                     debug!("  Found matching touchscreen HID device");
                     debug!("  Path:             {:?}", dev_info.path());
                     debug!("  IC Type:          {:04X}", pid);
+                    if skip > 0 {
+                        skip -= 1;
+                        continue;
+                    }
 
                     // TODO: Enumerate with windows
                     // Should enumerate and find the right one
@@ -135,4 +146,24 @@ impl TouchScreen for NativeWinTouchScreen {
 
         Some(buf[msg_len..msg_len + read_len].to_vec())
     }
+
+    fn get_stylus_fw(&self) -> Option<()> {
+        let mut msg = [0u8; 0x40];
+        msg[0] = REPORT_ID_FIRMWARE;
+        unsafe {
+            let success = HidD_GetFeature(self.handle, msg.as_mut_ptr() as _, msg.len() as u32);
+            debug!("    Success: {}", success);
+        }
+        println!("Stylus firmware: {:X?}", msg);
+
+        let mut msg = [0u8; 0x40];
+        msg[0] = REPORT_ID_USI_VER;
+        unsafe {
+            let success = HidD_GetFeature(self.handle, msg.as_mut_ptr() as _, msg.len() as u32);
+            debug!("    Success: {}", success);
+        }
+        println!("USI Version:     {:X?}", msg);
+
+        None
+    }
 }