Implement latch control

Author: qzed

Cargo.lock

@@ -13,3 +13,4 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 indoc = "0.3.1"
+nix = "0.13.0"

Cargo.toml

@@ -0,0 +1,101 @@
+use std::fs::File;
+use std::path::Path;
+use std::io::Result;
+use std::os::unix::io::AsRawFd;
+
+
+use nix::ioctl_none;
+use nix::ioctl_read;
+use nix::request_code_read;
+use nix::request_code_none;
+use nix::convert_ioctl_res;
+use nix::ioc;
+
+
+#[derive(Debug)]
+pub enum OpMode {
+    Tablet,
+    Laptop,
+    Studio,
+}
+
+impl OpMode {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            OpMode::Tablet => "tablet",
+            OpMode::Laptop => "laptop",
+            OpMode::Studio => "studio",
+        }
+    }
+}
+
+impl std::fmt::Display for OpMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+
+#[derive(Debug)]
+pub struct Device {
+    file: File,
+}
+
+impl Device {
+    pub fn open() -> Result<Self> {
+        Device::open_path("/dev/surface_dtx")
+    }
+
+    pub fn open_path<P: AsRef<Path>>(path: P) -> Result<Self> {
+        let file = File::open(path)?;
+        Ok(Device { file })
+    }
+
+    pub fn latch_lock(&self) -> Result<()> {
+        unsafe {
+            dtx_latch_lock(self.file.as_raw_fd())
+                .map_err(|_| std::io::Error::last_os_error())?;
+        }
+        Ok(())
+    }
+
+    pub fn latch_unlock(&self) -> Result<()> {
+        unsafe {
+            dtx_latch_unlock(self.file.as_raw_fd())
+                .map_err(|_| std::io::Error::last_os_error())?;
+        }
+        Ok(())
+    }
+
+    pub fn latch_request(&self) -> Result<()> {
+        unsafe {
+            dtx_latch_request(self.file.as_raw_fd())
+                .map_err(|_| std::io::Error::last_os_error())?;
+        }
+        Ok(())
+    }
+
+    pub fn get_opmode(&self) -> Result<OpMode> {
+        use std::io;
+
+        let mut opmode: u32 = 0;
+        unsafe {
+            dtx_get_opmode(self.file.as_raw_fd(), &mut opmode as *mut u32)
+                .map_err(|_| std::io::Error::last_os_error())?;
+        }
+
+        match opmode {
+            0 => Ok(OpMode::Tablet),
+            1 => Ok(OpMode::Laptop),
+            2 => Ok(OpMode::Studio),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidData, "invalid opmode").into()),
+        }
+    }
+}
+
+
+ioctl_none!(dtx_latch_lock,    0x11, 0x01);
+ioctl_none!(dtx_latch_unlock,  0x11, 0x02);
+ioctl_none!(dtx_latch_request, 0x11, 0x03);
+ioctl_none!(dtx_latch_open,    0x11, 0x04);
+ioctl_read!(dtx_get_opmode,    0x11, 0x05, u32);

src/latch.rs

@@ -4,6 +4,7 @@ use indoc::indoc;
 
 mod dgpu;
 mod perf;
+mod latch;
 
 
 fn app() -> clap::App<'static, 'static> {
@@ -59,6 +60,22 @@ fn app() -> clap::App<'static, 'static> {
         .subcommand(SubCommand::with_name("get")
             .about("Get the current dGPU power state"));
 
+    let latch = SubCommand::with_name("latch")
+        .about("Control the latch/dtx-system on the Surface Book 2")
+        .setting(AppSettings::SubcommandRequiredElseHelp)
+        .subcommand(SubCommand::with_name("lock")
+            .about("Lock the latch")
+            .display_order(1))
+        .subcommand(SubCommand::with_name("unlock")
+            .about("Unlock the latch")
+            .display_order(2))
+        .subcommand(SubCommand::with_name("request")
+            .about("Request latch-open or abort if already in progress")
+            .display_order(3))
+        .subcommand(SubCommand::with_name("get-opmode")
+            .about("Query the current device operation mode")
+            .display_order(4));
+
     App::new(clap::crate_name!())
         .version(clap::crate_version!())
         .author(clap::crate_authors!("\n"))
@@ -68,6 +85,7 @@ fn app() -> clap::App<'static, 'static> {
         .subcommand(status)
         .subcommand(perf)
         .subcommand(dgpu)
+        .subcommand(latch)
 }
 
 fn main() {
@@ -77,6 +95,7 @@ fn main() {
         ("status",      Some(m)) => cmd_status(m),
         ("dgpu",        Some(m)) => cmd_dgpu(m),
         ("performance", Some(m)) => cmd_perf(m),
+        ("latch",       Some(m)) => cmd_latch(m),
         _                        => unreachable!(),
     };
 
@@ -138,3 +157,31 @@ fn cmd_perf_get(_: &clap::ArgMatches) -> Result<()> {
     println!("{}", perf::Device::open()?.get_mode()?);
     Ok(())
 }
+
+
+fn cmd_latch(m: &clap::ArgMatches) -> Result<()> {
+    match m.subcommand() {
+        ("lock",       Some(m)) => cmd_latch_lock(m),
+        ("unlock",     Some(m)) => cmd_latch_unlock(m),
+        ("request",    Some(m)) => cmd_latch_request(m),
+        ("get-opmode", Some(m)) => cmd_latch_get_opmode(m),
+        _                       => unreachable!(),
+    }
+}
+
+fn cmd_latch_lock(_: &clap::ArgMatches) -> Result<()> {
+    latch::Device::open()?.latch_lock()
+}
+
+fn cmd_latch_unlock(_: &clap::ArgMatches) -> Result<()> {
+    latch::Device::open()?.latch_unlock()
+}
+
+fn cmd_latch_request(_: &clap::ArgMatches) -> Result<()> {
+    latch::Device::open()?.latch_request()
+}
+
+fn cmd_latch_get_opmode(_: &clap::ArgMatches) -> Result<()> {
+    println!("{}", latch::Device::open()?.get_opmode()?);
+    Ok(())
+}