Changed implementation to i2cdev instead of sysfs calls.

bjarne-dietrich · jannau · commit a256c6238b30 · 2026-01-20T19:29:29.000+01:00
Signed-off-by: bjarne-dietrich &lt;78506612+bjarne-dietrich@users.noreply.github.com&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "tuxvdmtool"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 license = "Apache-2.0"
 description = "A tool to interact with USB Type C controller chips to interact with connected Apple devices"
@@ -10,3 +10,4 @@ repository = "https://github.com/AsahiLinux/tuxvdmtool"
 clap = { version = "3", features = ["cargo"] }
 log = "0.4.28"
 env_logger = { version = "0.11.8", default-features = false }
+i2cdev = "0.6"
diff --git a/src/cd321x.rs b/src/cd321x.rs
@@ -5,18 +5,23 @@
  */
 
 use crate::{Error, Result};
+use i2cdev::{core::I2CDevice, linux::LinuxI2CDevice};
 use log::{error, info};
 use std::{
-    fs::{self, OpenOptions},
-    io::Read,
-    path, thread,
+    str::FromStr,
+    thread,
     time::{Duration, Instant},
 };
 
 const RECONNECT_TIMEOUT: Duration = Duration::from_secs(3);
 const POLL_WAIT: Duration = Duration::from_millis(100);
 const RECONNECT_WAIT: Duration = Duration::from_secs(1);
 
+const TPS_REG_MODE: u8 = 0x03;
+const TPS_REG_CMD1: u8 = 0x08;
+const TPS_REG_DATA1: u8 = 0x09;
+const TPS_REG_POWER_STATUS: u8 = 0x3f;
+
 #[allow(dead_code)]
 enum VdmSopType {
     Sop = 0b00,
@@ -25,106 +30,222 @@ enum VdmSopType {
     SopStar = 0b11,
 }
 
+#[allow(dead_code)]
+#[derive(Debug, PartialEq)]
+enum TpsMode {
+    TpsModeApp,
+    TpsModeBoot,
+    TpsModeBist,
+    TpsModeDisc,
+    TpsModePtch,
+    TpsModeDbma,
+}
+
+impl FromStr for TpsMode {
+    type Err = ();
+    fn from_str(input: &str) -> std::result::Result<TpsMode, ()> {
+        match input {
+            "APP " => Ok(TpsMode::TpsModeApp),
+            "BOOT" => Ok(TpsMode::TpsModeBoot),
+            "BIST" => Ok(TpsMode::TpsModeBist),
+            "DISC" => Ok(TpsMode::TpsModeDisc),
+            "PTCH" => Ok(TpsMode::TpsModePtch),
+            "DBMa" => Ok(TpsMode::TpsModeDbma),
+            _ => Err(()),
+        }
+    }
+}
+
+fn is_invalid_cmd(val: u32) -> bool {
+    val == 0x444d4321
+}
+
 pub(crate) struct Device {
-    path: path::PathBuf,
+    i2c: LinuxI2CDevice,
     key: Vec<u8>,
 }
 
-fn verify_device(dev: &str) -> Result<path::PathBuf> {
-    let mut fname = OpenOptions::new()
-        .read(true)
-        .open(path::Path::new(dev).join("name"))
-        .unwrap();
-    let mut data = Vec::new();
-    fname.read_to_end(&mut data).unwrap();
-    let name = std::str::from_utf8(&data).map_err(Error::Utf8)?.trim();
-    if name != "cd321x" {
-        error!("{dev}/name \"{name}\" does not match \"cd321x\"");
-        return Err(Error::TypecController);
-    }
-
-    let vdm_dir = path::Path::new(dev).join("cd321x_vdm");
-    if !vdm_dir.exists() {
-        error!("{} does not exists", vdm_dir.display());
-        return Err(Error::FeatureMissing);
-    }
-    Ok(vdm_dir.to_path_buf())
+/// Try to open the given I2C bus and slave address.
+/// Returns a configured LinuxI2CDevice on success.
+fn verify_i2c_device(bus: &str, slave_address: u16) -> Result<LinuxI2CDevice> {
+    match LinuxI2CDevice::new(bus, slave_address) {
+        Ok(dev) => {
+            return Ok(dev);
+        }
+        Err(_) => {} // Fall through to attempt forced open
+    }
+
+    info!("Safely opening failed ==> Forcefully opening device...");
+    let forced = unsafe { LinuxI2CDevice::force_new(bus, slave_address) };
+    match forced {
+        Ok(dev) => Ok(dev),
+        Err(_) => Err(Error::I2CError),
+    }
 }
 
 impl Device {
-    pub(crate) fn new(dev: &str, code: String) -> Result<Self> {
-        let device = Self {
-            path: verify_device(dev)?,
+    pub(crate) fn new(bus: &str, address: u16, code: String) -> Result<Self> {
+        let mut device = Self {
+            i2c: verify_i2c_device(bus, address)?,
             key: code.into_bytes().into_iter().rev().collect::<Vec<u8>>(),
         };
-        device.lock(device.key.as_slice())?;
+        device.lock(device.key.clone().as_slice())?;
         device.dbma(true)?;
 
         Ok(device)
     }
 
-    fn command(&self, command: &[u8; 4], data: &[u8]) -> Result<()> {
-        let data: Vec<u8> = [command, data].concat();
-        fs::write(self.path.as_path().join("command"), &data).map_err(Error::Io)
+    fn exec_cmd(&mut self, cmd_tag: &[u8; 4], in_data: &[u8]) -> Result<()> {
+        self.exec_cmd_with_timing(cmd_tag, in_data, Duration::from_secs(1), Duration::ZERO)
     }
 
-    fn lock(&self, key: &[u8]) -> Result<()> {
-        self.command(b"LOCK", key)
+    fn exec_cmd_with_timing(
+        &mut self,
+        cmd_tag: &[u8; 4],
+        in_data: &[u8],
+        cmd_timeout: Duration,
+        res_delay: Duration,
+    ) -> Result<()> {
+        // First: Check CMD1 Register busy
+        {
+            let mut status_buf = [0u8; 4];
+            self.read_block(TPS_REG_CMD1, &mut status_buf)?;
+            let val = u32::from_le_bytes(status_buf);
+            if val != 0 && !is_invalid_cmd(val) {
+                info!("Busy Check Failed with VAL = {:?}", val);
+                return Err(Error::TypecController);
+            }
+        }
+
+        // Write input Data to DATA1
+        if !in_data.is_empty() {
+            self.write_block(TPS_REG_DATA1, in_data)?;
+            info!("Wrote Data: {:02X?}", in_data);
+        }
+
+        // Write 4-byte command tag
+        self.write_block(TPS_REG_CMD1, cmd_tag)?;
+
+        // Poll until CMD1 becomes zero or timeout
+        let start = Instant::now();
+        loop {
+            let mut status_buf = [0u8; 4];
+            self.read_block(TPS_REG_CMD1, &mut status_buf)?;
+            let val = u32::from_le_bytes(status_buf);
+
+            if is_invalid_cmd(val) {
+                info!("Invalid Command");
+                return Err(Error::InvalidArgument);
+            }
+
+            if val == 0 {
+                break;
+            }
+            if start.elapsed() > cmd_timeout {
+                return Err(Error::ControllerTimeout);
+            }
+        }
+        thread::sleep(res_delay);
+
+        Ok(())
+    }
+
+    fn write_block(&mut self, reg: u8, data: &[u8]) -> Result<()> {
+        let mut buf = Vec::with_capacity(1 + 1 + data.len());
+        let size: u8 = data.len().try_into().unwrap();
+        buf.push(reg);
+        buf.push(size);
+        buf.extend_from_slice(data);
+        self.i2c.write(&buf).map_err(|_| Error::I2CError)?;
+        Ok(())
+    }
+
+    fn read_block(&mut self, reg: u8, buf: &mut [u8]) -> Result<()> {
+        self.i2c.write(&[reg]).map_err(|_| Error::I2CError)?;
+        let mut internal_buf = vec![0u8; buf.len() + 1];
+        self.i2c
+            .read(&mut internal_buf)
+            .map_err(|_| Error::I2CError)?;
+        buf.copy_from_slice(&internal_buf[1..=buf.len()]);
+
+        Ok(())
     }
 
-    fn dbma(&self, debug: bool) -> Result<()> {
+    fn get_mode(&mut self) -> Result<TpsMode> {
+        let mut buf = [0u8; 4];
+        self.read_block(TPS_REG_MODE, &mut buf)?;
+        let s = std::str::from_utf8(&buf).unwrap();
+        let m = TpsMode::from_str(s).map_err(|_| Error::TypecController)?;
+
+        Ok(m)
+    }
+
+    fn lock(&mut self, key: &[u8]) -> Result<()> {
+        self.exec_cmd(b"LOCK", &key)
+    }
+
+    fn dbma(&mut self, debug: bool) -> Result<()> {
         let data: [u8; 1] = if debug { [1] } else { [0] };
-        self.command(b"DBMa", &data)
+        self.exec_cmd(b"DBMa", &data)?;
+        if self.get_mode()? != TpsMode::TpsModeDbma {
+            return Err(Error::TypecController);
+        }
+        Ok(())
     }
 
-    fn vdms(&self, sop: VdmSopType, vdos: &[u32]) -> Result<()> {
+    fn vdms(&mut self, sop: VdmSopType, vdos: &[u32]) -> Result<()> {
         if vdos.is_empty() || vdos.len() > 7 {
             return Err(Error::InvalidArgument);
         }
+        if self.get_mode()? != TpsMode::TpsModeDbma {
+            return Err(Error::TypecController);
+        }
         let data = [
             vec![((sop as u8) << 4) | vdos.len() as u8],
             vdos.iter().flat_map(|val| val.to_le_bytes()).collect(),
         ]
         .concat();
-        self.command(b"VDMs", &data)
+        self.exec_cmd_with_timing(
+            b"VDMs",
+            &data,
+            Duration::from_millis(200),
+            Duration::from_millis(200),
+        )
     }
 
-    fn dven(&self, vdos: &[u32]) -> Result<()> {
+    fn dven(&mut self, vdos: &[u32]) -> Result<()> {
         let data: Vec<u8> = vdos.iter().flat_map(|val| val.to_le_bytes()).collect();
-        self.command(b"DEVn", &data)
+        self.exec_cmd(b"DEVn", &data)
     }
 
-    fn is_connected(&self) -> Option<bool> {
-        let data: Vec<u8> = fs::read(self.path.as_path().join("power_status")).ok()?;
-        let string = std::str::from_utf8(&data).ok()?;
-        if string.len() < 6 {
-            return None;
-        }
-        let power_status = u16::from_str_radix(&string[2..6], 16).ok()?;
-
-        Some((power_status & 1) != 0)
+    fn check_connected(&mut self) -> Result<bool> {
+        let mut buf = [0u8; 2];
+        self.read_block(TPS_REG_POWER_STATUS, &mut buf)?;
+        let power_status = u16::from_le_bytes(buf);
+        Ok((power_status & 1) != 0)
     }
 
-    pub(crate) fn dfu(&self) -> Result<()> {
+    pub(crate) fn dfu(&mut self) -> Result<()> {
         let vdos: [u32; 3] = [0x5ac8012, 0x106, 0x80010000];
         info!("Rebooting target into DFU mode...");
         self.vdms(VdmSopType::SopStar, &vdos)
     }
-    pub(crate) fn reboot(&self) -> Result<()> {
+
+    pub(crate) fn reboot(&mut self) -> Result<()> {
         let vdos: [u32; 3] = [0x5ac8012, 0x105, 0x80000000];
         info!("Rebooting target into normal mode...");
         self.vdms(VdmSopType::SopStar, &vdos)
     }
 
-    pub(crate) fn reboot_serial(&self) -> Result<()> {
+    pub(crate) fn reboot_serial(&mut self) -> Result<()> {
         self.reboot()?;
         info!("Waiting for connection...");
 
         thread::sleep(RECONNECT_WAIT);
 
         let now = Instant::now();
         loop {
-            if self.is_connected().unwrap_or(false) {
+            if self.check_connected().unwrap_or(false) {
                 break;
             }
             thread::sleep(POLL_WAIT);
@@ -138,11 +259,14 @@ impl Device {
         self.serial()
     }
 
-    pub(crate) fn serial(&self) -> Result<()> {
+    pub(crate) fn serial(&mut self) -> Result<()> {
         let vdos: [u32; 2] = [0x5ac8012, 0x1840306];
         info!("Putting target into serial mode...");
         self.vdms(VdmSopType::SopStar, &vdos)?;
         info!("Putting local end into serial mode... ");
+        if self.get_mode()? != TpsMode::TpsModeDbma {
+            return Err(Error::TypecController);
+        }
         self.dven(&vdos[1..2])
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -19,6 +19,8 @@ enum Error {
     TypecController,
     InvalidArgument,
     ReconnectTimeout,
+    ControllerTimeout,
+    I2CError,
     Io(std::io::Error),
     Utf8(std::str::Utf8Error),
 }
@@ -28,8 +30,12 @@ type Result<T> = std::result::Result<T, Error>;
 fn vdmtool() -> Result<()> {
     let matches = clap::command!()
         .arg(
-            clap::arg!(-d --device [DEVICE] "Path to the USB-C controller device.")
-                .default_value("/sys/class/i2c-dev/i2c-0/device/0-0038"),
+            clap::arg!(-b --bus [BUS] "i2c bus of the USB-C controller device.")
+                .default_value("/dev/i2c-0"),
+        )
+        .arg(
+            clap::arg!(-a --address [ADDRESS] "i2c slave address of the USB-C controller device.")
+                .default_value("0x38"),
         )
         .subcommand(
             clap::Command::new("reboot")
@@ -55,8 +61,17 @@ fn vdmtool() -> Result<()> {
         error!("Host is not an Apple silicon system: \"{compat}\"");
         return Err(Error::Compatible);
     }
+
+    let addr_str = matches.get_one::<String>("address").unwrap();
+    let addr: u16;
+    if addr_str.starts_with("0x") {
+        addr = u16::from_str_radix(&addr_str[2..], 16).unwrap();
+    } else {
+        addr = u16::from_str_radix(addr_str, 10).unwrap();
+    }
+
     let code = device.to_uppercase();
-    let device = cd321x::Device::new(matches.get_one::<String>("device").unwrap(), code)?;
+    let mut device = cd321x::Device::new(matches.get_one::<String>("bus").unwrap(), addr, code)?;
 
     match matches.subcommand() {
         Some(("dfu", _)) => {
