SCSI support: ROG Arion external drive LED control

asusd/Cargo.toml

@@ -18,6 +18,7 @@ config-traits = { path = "../config-traits" }
 rog_anime = { path = "../rog-anime", features = ["dbus"] }
 rog_slash = { path = "../rog-slash", features = ["dbus"] }
 rog_aura = { path = "../rog-aura", features = ["dbus"] }
+rog_scsi = { path = "../rog-scsi", features = ["dbus"] }
 rog_platform = { path = "../rog-platform" }
 rog_profiles = { path = "../rog-profiles" }
 dmi_id = { path = "../dmi-id" }

asusd/src/aura_manager.rs

@@ -18,6 +18,7 @@ use zbus::Connection;
 
 use crate::aura_anime::trait_impls::AniMeZbus;
 use crate::aura_laptop::trait_impls::AuraZbus;
+use crate::aura_scsi::trait_impls::ScsiZbus;
 use crate::aura_slash::trait_impls::SlashZbus;
 use crate::aura_types::DeviceHandle;
 use crate::error::RogError;
@@ -70,6 +71,17 @@ fn dbus_path_for_anime() -> OwnedObjectPath {
     ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/anime")).into()
 }
 
+fn dbus_path_for_scsi(prod_id: &str) -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{prod_id}_scsi")).into()
+}
+
+fn dev_prop_matches(dev: &Device, prop: &str, value: &str) -> bool {
+    if let Some(p) = dev.property_value(prop) {
+        return p == value;
+    }
+    false
+}
+
 // TODO:
 // - make this the HID manager (and universal)
 // - *really* need to make most of this actual kernel drivers
@@ -83,7 +95,6 @@ fn dbus_path_for_anime() -> OwnedObjectPath {
 ///
 /// Each controller within should track its dbus path so it can be removed if
 /// required.
-#[derive(Debug)]
 pub struct AsusDevice {
     device: DeviceHandle,
     dbus_path: OwnedObjectPath,
@@ -197,7 +208,75 @@ impl DeviceManager {
         {
             devices.append(&mut Self::init_hid_devices(connection, device).await?);
         }
-        // debug!("Found devices: {devices:?}");
+
+        Ok(devices)
+    }
+
+    async fn init_scsi(
+        connection: &Connection,
+        device: &Device,
+        path: OwnedObjectPath,
+    ) -> Option<AsusDevice> {
+        // "ID_MODEL_ID" "1932"
+        // "ID_VENDOR_ID" "0b05"
+        if dev_prop_matches(&device, "ID_VENDOR_ID", "0b05") {
+            if let Some(dev_node) = device.devnode() {
+                let prod_id = device
+                    .property_value("ID_MODEL_ID")
+                    .unwrap_or_default()
+                    .to_string_lossy();
+                if let Ok(dev_type) =
+                    DeviceHandle::maybe_scsi(dev_node.as_os_str().to_str().unwrap(), &prod_id).await
+                {
+                    if let DeviceHandle::Scsi(scsi) = dev_type.clone() {
+                        let ctrl = ScsiZbus::new(scsi);
+                        ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                        return Some(AsusDevice {
+                            device: dev_type,
+                            dbus_path: path,
+                        });
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    async fn init_all_scsi(connection: &Connection) -> Result<Vec<AsusDevice>, RogError> {
+        // track and ensure we use only one hidraw per prod_id
+        // let mut interfaces = HashSet::new();
+        let mut devices: Vec<AsusDevice> = Vec::new();
+
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("enumerator failed".into(), err)
+        })?;
+
+        enumerator.match_subsystem("block").map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("match_subsystem failed".into(), err)
+        })?;
+
+        let mut found = Vec::new();
+        for device in enumerator
+            .scan_devices()
+            .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
+        {
+            if let Some(serial) = device.property_value("ID_SERIAL_SHORT") {
+                let serial = serial.to_string_lossy().to_string();
+                let path = dbus_path_for_scsi(&serial);
+                if found.contains(&path) {
+                    continue;
+                }
+
+                if let Some(dev) = Self::init_scsi(connection, &device, path.clone()).await {
+                    devices.push(dev);
+                    found.push(path);
+                }
+            } else {
+                warn!("No serial for SCSI device");
+            }
+        }
 
         Ok(devices)
     }
@@ -252,6 +331,11 @@ impl DeviceManager {
                 info!("Tested device was not AniMe Matrix");
             }
         }
+
+        if let Ok(devs) = &mut Self::init_all_scsi(connection).await {
+            devices.append(devs);
+        }
+
         devices
     }
 
@@ -268,7 +352,7 @@ impl DeviceManager {
         // detect all plugged in aura devices (eventually)
         // only USB devices are detected for here
         std::thread::spawn(move || {
-            let mut monitor = MonitorBuilder::new()?.match_subsystem("hidraw")?.listen()?;
+            let mut monitor = MonitorBuilder::new()?.listen()?;
             let mut poll = Poll::new()?;
             let mut events = Events::with_capacity(1024);
             poll.registry()
@@ -281,82 +365,142 @@ impl DeviceManager {
                     continue;
                 }
                 for event in monitor.iter() {
-                    let action = event.action().unwrap_or_default();
+                    let action = event
+                        .action()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .to_string();
 
-                    if let Some(parent) =
-                        event.parent_with_subsystem_devtype("usb", "usb_device")?
-                    {
-                        let devices = devices.clone();
+                    let subsys = if let Some(subsys) = event.subsystem() {
+                        subsys.to_string_lossy().to_string()
+                    } else {
+                        continue;
+                    };
 
-                        if action == "remove" {
-                            if let Some(path) = dbus_path_for_dev(&parent) {
-                                let conn_copy = conn_copy.clone();
-                                tokio::spawn(async move {
-                                    // Find the indexs of devices matching the path
-                                    let removals: Vec<usize> = devices
+                    let devices = devices.clone();
+                    let conn_copy = conn_copy.clone();
+                    block_on(async move {
+                        // SCSCI devs
+                        if subsys == "block" {
+                            if action == "remove" {
+                                if let Some(serial) =
+                                    event.device().property_value("ID_SERIAL_SHORT")
+                                {
+                                    let serial = serial.to_string_lossy().to_string();
+                                    let path = dbus_path_for_scsi(&serial);
+
+                                    let index = if let Some(index) = devices
                                         .lock()
                                         .await
                                         .iter()
-                                        .enumerate()
-                                        .filter_map(|(i, dev)| {
-                                            if dev.dbus_path == path {
-                                                Some(i)
-                                            } else {
-                                                None
-                                            }
-                                        })
-                                        .collect();
-                                    if removals.is_empty() {
+                                        .position(|dev| dev.dbus_path == path)
+                                    {
+                                        index
+                                    } else {
+                                        warn!("No device for dbus path: {path:?}");
                                         return Ok(());
-                                    }
+                                    };
                                     info!("removing: {path:?}");
-                                    // Iter in reverse so as to not screw up indexing
-                                    for index in removals.iter().rev() {
-                                        let dev = devices.lock().await.remove(*index);
-                                        let path = path.clone();
-                                        let res = match dev.device {
-                                            DeviceHandle::Aura(_) => {
-                                                conn_copy
-                                                    .object_server()
-                                                    .remove::<AuraZbus, _>(&path)
-                                                    .await?
-                                            }
-                                            DeviceHandle::Slash(_) => {
-                                                conn_copy
-                                                    .object_server()
-                                                    .remove::<SlashZbus, _>(&path)
-                                                    .await?
-                                            }
-                                            DeviceHandle::AniMe(_) => {
-                                                conn_copy
-                                                    .object_server()
-                                                    .remove::<AniMeZbus, _>(&path)
-                                                    .await?
-                                            }
-                                            DeviceHandle::Ally(_) => todo!(),
-                                            DeviceHandle::OldAura(_) => todo!(),
-                                            DeviceHandle::TufLedClass(_) => todo!(),
-                                            DeviceHandle::MulticolourLed => todo!(),
-                                            DeviceHandle::None => todo!(),
-                                        };
-                                        info!("AuraManager removed: {path:?}, {res}");
+                                    let dev = devices.lock().await.remove(index);
+                                    let path = path.clone();
+                                    match dev.device {
+                                        DeviceHandle::Scsi(_) => {
+                                            conn_copy
+                                                .object_server()
+                                                .remove::<ScsiZbus, _>(&path)
+                                                .await?;
+                                        }
+                                        _ => {}
                                     }
-                                    Ok::<(), RogError>(())
-                                });
-                            }
-                        } else if action == "add" {
-                            let evdev = event.device();
-                            let conn_copy = conn_copy.clone();
-                            block_on(async move {
-                                if let Ok(mut new_devs) = Self::init_hid_devices(&conn_copy, evdev)
-                                    .await
-                                    .map_err(|e| error!("Couldn't add new device: {e:?}"))
-                                {
-                                    devices.lock().await.append(&mut new_devs);
                                 }
-                            });
-                        };
-                    }
+                            } else if action == "add" {
+                                let evdev = event.device();
+                                if let Some(serial) = evdev.property_value("ID_SERIAL_SHORT") {
+                                    let serial = serial.to_string_lossy().to_string();
+                                    let path = dbus_path_for_scsi(&serial);
+                                    if let Some(new_devs) =
+                                        Self::init_scsi(&conn_copy, &evdev, path).await
+                                    {
+                                        devices.lock().await.append(&mut vec![new_devs]);
+                                    }
+                                }
+                            };
+                        }
+
+                        if subsys == "hidraw" {
+                            if let Some(parent) =
+                                event.parent_with_subsystem_devtype("usb", "usb_device")?
+                            {
+                                if action == "remove" {
+                                    if let Some(path) = dbus_path_for_dev(&parent) {
+                                        // Find the indexs of devices matching the path
+                                        let removals: Vec<usize> = devices
+                                            .lock()
+                                            .await
+                                            .iter()
+                                            .enumerate()
+                                            .filter_map(|(i, dev)| {
+                                                if dev.dbus_path == path {
+                                                    Some(i)
+                                                } else {
+                                                    None
+                                                }
+                                            })
+                                            .collect();
+                                        if removals.is_empty() {
+                                            return Ok(());
+                                        }
+                                        info!("removing: {path:?}");
+                                        // Iter in reverse so as to not screw up indexing
+                                        for index in removals.iter().rev() {
+                                            let dev = devices.lock().await.remove(*index);
+                                            let path = path.clone();
+                                            let res = match dev.device {
+                                                DeviceHandle::Aura(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<AuraZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::Slash(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<SlashZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::AniMe(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<AniMeZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::Scsi(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<ScsiZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                _ => todo!(),
+                                            };
+                                            info!("AuraManager removed: {path:?}, {res}");
+                                        }
+                                    }
+                                } else if action == "add" {
+                                    let evdev = event.device();
+                                    if let Ok(mut new_devs) =
+                                        Self::init_hid_devices(&conn_copy, evdev)
+                                            .await
+                                            .map_err(|e| error!("Couldn't add new device: {e:?}"))
+                                    {
+                                        devices.lock().await.append(&mut new_devs);
+                                    }
+                                };
+                            }
+                        }
+                        Ok::<(), RogError>(())
+                    })
+                    .map_err(|e| error!("{e:?}"))
+                    .ok();
                 }
             }
             // Required for return type on spawn

asusd/src/aura_scsi/config.rs

@@ -0,0 +1,114 @@
+use std::collections::BTreeMap;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_aura::AuraDeviceType;
+use rog_scsi::{AuraEffect, AuraMode};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "scsi.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ScsiConfig {
+    #[serde(skip)]
+    pub dev_type: AuraDeviceType,
+    pub enabled: bool,
+    pub current_mode: AuraMode,
+    pub modes: BTreeMap<AuraMode, AuraEffect>,
+}
+
+impl ScsiConfig {
+    pub fn get_effect(&mut self, mode: AuraMode) -> Option<&AuraEffect> {
+        self.modes.get(&mode)
+    }
+
+    pub fn save_effect(&mut self, effect: AuraEffect) {
+        self.current_mode = effect.mode;
+        self.modes.insert(*effect.mode(), effect);
+    }
+}
+
+impl Default for ScsiConfig {
+    fn default() -> Self {
+        ScsiConfig {
+            enabled: true,
+            current_mode: AuraMode::Static,
+            dev_type: AuraDeviceType::ScsiExtDisk,
+            modes: BTreeMap::from([
+                (AuraMode::Off, AuraEffect::default_with_mode(AuraMode::Off)),
+                (
+                    AuraMode::Static,
+                    AuraEffect::default_with_mode(AuraMode::Static),
+                ),
+                (
+                    AuraMode::Breathe,
+                    AuraEffect::default_with_mode(AuraMode::Breathe),
+                ),
+                (
+                    AuraMode::Flashing,
+                    AuraEffect::default_with_mode(AuraMode::Flashing),
+                ),
+                (
+                    AuraMode::RainbowCycle,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycle),
+                ),
+                (
+                    AuraMode::RainbowWave,
+                    AuraEffect::default_with_mode(AuraMode::RainbowWave),
+                ),
+                (
+                    AuraMode::RainbowCycleBreathe,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleBreathe),
+                ),
+                (
+                    AuraMode::ChaseFade,
+                    AuraEffect::default_with_mode(AuraMode::ChaseFade),
+                ),
+                (
+                    AuraMode::RainbowCycleChaseFade,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleChaseFade),
+                ),
+                (
+                    AuraMode::Chase,
+                    AuraEffect::default_with_mode(AuraMode::Chase),
+                ),
+                (
+                    AuraMode::RainbowCycleChase,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleChase),
+                ),
+                (
+                    AuraMode::RainbowCycleWave,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleWave),
+                ),
+                (
+                    AuraMode::RainbowPulseChase,
+                    AuraEffect::default_with_mode(AuraMode::RainbowPulseChase),
+                ),
+                (
+                    AuraMode::RandomFlicker,
+                    AuraEffect::default_with_mode(AuraMode::RandomFlicker),
+                ),
+                (
+                    AuraMode::DoubleFade,
+                    AuraEffect::default_with_mode(AuraMode::DoubleFade),
+                ),
+            ]),
+        }
+    }
+}
+
+impl StdConfig for ScsiConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for ScsiConfig {}

asusd/src/aura_scsi/mod.rs

@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use config::ScsiConfig;
+use rog_scsi::{AuraEffect, Device, Task};
+use tokio::sync::{Mutex, MutexGuard};
+
+use crate::error::RogError;
+
+pub mod config;
+pub mod trait_impls;
+
+#[derive(Clone)]
+pub struct ScsiAura {
+    device: Arc<Mutex<Device>>,
+    config: Arc<Mutex<ScsiConfig>>,
+}
+
+impl ScsiAura {
+    pub fn new(device: Arc<Mutex<Device>>, config: Arc<Mutex<ScsiConfig>>) -> Self {
+        Self { device, config }
+    }
+
+    pub async fn lock_config(&self) -> MutexGuard<ScsiConfig> {
+        self.config.lock().await
+    }
+
+    pub async fn write_effect(&self, effect: &AuraEffect) -> Result<(), RogError> {
+        let tasks: Vec<Task> = effect.into();
+        for task in &tasks {
+            self.device.lock().await.perform(task).ok();
+        }
+        Ok(())
+    }
+
+    /// Initialise the device if required. Locks the internal config so be wary
+    /// of deadlocks.
+    pub async fn do_initialization(&self) -> Result<(), RogError> {
+        let config = self.config.lock().await;
+        let mode = config.current_mode;
+        if let Some(effect) = config.modes.get(&mode) {
+            self.write_effect(effect).await?;
+        }
+        Ok(())
+    }
+}

asusd/src/aura_scsi/trait_impls.rs

@@ -0,0 +1,116 @@
+use std::collections::BTreeMap;
+
+use config_traits::StdConfig;
+use log::error;
+use rog_aura::AuraDeviceType;
+use rog_scsi::{AuraEffect, AuraMode};
+use zbus::fdo::Error as ZbErr;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::ScsiAura;
+use crate::error::RogError;
+
+#[derive(Clone)]
+pub struct ScsiZbus(ScsiAura);
+
+impl ScsiZbus {
+    pub fn new(scsi: ScsiAura) -> Self {
+        Self(scsi)
+    }
+
+    pub async fn start_tasks(
+        self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+}
+
+#[interface(name = "org.asuslinux.ScsiAura")]
+impl ScsiZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        self.0.config.lock().await.dev_type
+    }
+
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock_config().await;
+        lock.enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut config = self.0.lock_config().await;
+        config.enabled = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn led_mode(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.current_mode as u8
+    }
+
+    #[zbus(property)]
+    async fn set_led_mode(&self, mode: AuraMode) -> Result<(), zbus::Error> {
+        let mut config = self.0.lock_config().await;
+        if let Some(effect) = config.get_effect(mode) {
+            self.0
+                .write_effect(effect)
+                .await
+                .map_err(|e| zbus::Error::Failure(format!("{e:?}")))?;
+        } else {
+            return Err(zbus::Error::Failure("Mode data does not exist".to_string()));
+        }
+        config.current_mode = mode;
+        config.write();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        // entirely possible to deadlock here, so use try instead of lock()
+        if let Ok(config) = self.0.config.try_lock() {
+            let mode = config.current_mode;
+            match config.modes.get(&mode) {
+                Some(effect) => Ok(effect.clone()),
+                None => Err(ZbErr::Failed("Could not get the current effect".into())),
+            }
+        } else {
+            Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        self.0.write_effect(&effect).await?;
+
+        let mut config = self.0.config.lock().await;
+        config.save_effect(effect);
+        config.write();
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraMode, AuraEffect> {
+        let config = self.0.config.lock().await;
+        config.modes.clone()
+    }
+}

asusd/src/aura_types.rs

@@ -9,6 +9,7 @@ use rog_aura::AuraDeviceType;
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::keyboard_led::KeyboardBacklight;
 use rog_platform::usb_raw::USBRaw;
+use rog_scsi::{open_device, ScsiType};
 use rog_slash::error::SlashError;
 use rog_slash::SlashType;
 use tokio::sync::Mutex;
@@ -17,6 +18,8 @@ use crate::aura_anime::config::AniMeConfig;
 use crate::aura_anime::AniMe;
 use crate::aura_laptop::config::AuraConfig;
 use crate::aura_laptop::Aura;
+use crate::aura_scsi::config::ScsiConfig;
+use crate::aura_scsi::ScsiAura;
 use crate::aura_slash::config::SlashConfig;
 use crate::aura_slash::Slash;
 use crate::error::RogError;
@@ -31,12 +34,13 @@ pub enum _DeviceHandle {
     None,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum DeviceHandle {
     Aura(Aura),
     Slash(Slash),
     /// The AniMe devices require USBRaw as they are not HID devices
     AniMe(AniMe),
+    Scsi(ScsiAura),
     Ally(Arc<Mutex<HidRaw>>),
     OldAura(Arc<Mutex<HidRaw>>),
     /// TUF laptops have an aditional set of attributes added to the LED /sysfs/
@@ -146,6 +150,23 @@ impl DeviceHandle {
         }
     }
 
+    pub async fn maybe_scsi(dev_node: &str, prod_id: &str) -> Result<Self, RogError> {
+        debug!("Testing for SCSI");
+        let prod_id = ScsiType::from(prod_id);
+        if prod_id == ScsiType::Unsupported {
+            log::info!("Unknown or invalid SCSI: {prod_id:?}, skipping");
+            return Err(RogError::NotFound("No SCSI device".to_string()));
+        }
+        info!("Found SCSI device {prod_id:?} on {dev_node}");
+
+        let mut config = ScsiConfig::new().load();
+        config.dev_type = AuraDeviceType::ScsiExtDisk;
+        let dev = Arc::new(Mutex::new(open_device(dev_node)?));
+        let scsi = ScsiAura::new(dev, Arc::new(Mutex::new(config)));
+        scsi.do_initialization().await?;
+        Ok(Self::Scsi(scsi))
+    }
+
     pub async fn maybe_laptop_aura(
         device: Arc<Mutex<HidRaw>>,
         prod_id: &str,

asusd/src/lib.rs

@@ -9,6 +9,7 @@ pub mod ctrl_platform;
 pub mod aura_anime;
 pub mod aura_laptop;
 pub mod aura_manager;
+pub mod aura_scsi;
 pub mod aura_slash;
 pub mod aura_types;
 pub mod error;