init

src/atx/controller.rs

@@ -0,0 +1,356 @@
+//! ATX Controller
+//!
+//! High-level controller for ATX power management with flexible hardware binding.
+//! Each action (power short, power long, reset) can be configured independently.
+
+use tokio::sync::RwLock;
+use tracing::{debug, info, warn};
+
+use super::executor::{timing, AtxKeyExecutor};
+use super::led::LedSensor;
+use super::types::{AtxKeyConfig, AtxLedConfig, AtxState, PowerStatus};
+use crate::error::{AppError, Result};
+
+/// ATX power control configuration
+#[derive(Debug, Clone)]
+pub struct AtxControllerConfig {
+    /// Whether ATX is enabled
+    pub enabled: bool,
+    /// Power button configuration (used for both short and long press)
+    pub power: AtxKeyConfig,
+    /// Reset button configuration
+    pub reset: AtxKeyConfig,
+    /// LED sensing configuration
+    pub led: AtxLedConfig,
+}
+
+impl Default for AtxControllerConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            power: AtxKeyConfig::default(),
+            reset: AtxKeyConfig::default(),
+            led: AtxLedConfig::default(),
+        }
+    }
+}
+
+/// Internal state holding all ATX components
+/// Grouped together to reduce lock acquisitions
+struct AtxInner {
+    config: AtxControllerConfig,
+    power_executor: Option<AtxKeyExecutor>,
+    reset_executor: Option<AtxKeyExecutor>,
+    led_sensor: Option<LedSensor>,
+}
+
+/// ATX Controller
+///
+/// Manages ATX power control through independent executors for each action.
+/// Supports hot-reload of configuration.
+pub struct AtxController {
+    /// Single lock for all internal state to reduce lock contention
+    inner: RwLock<AtxInner>,
+}
+
+impl AtxController {
+    /// Create a new ATX controller with the specified configuration
+    pub fn new(config: AtxControllerConfig) -> Self {
+        Self {
+            inner: RwLock::new(AtxInner {
+                config,
+                power_executor: None,
+                reset_executor: None,
+                led_sensor: None,
+            }),
+        }
+    }
+
+    /// Create a disabled ATX controller
+    pub fn disabled() -> Self {
+        Self::new(AtxControllerConfig::default())
+    }
+
+    /// Initialize the ATX controller and its executors
+    pub async fn init(&self) -> Result<()> {
+        let mut inner = self.inner.write().await;
+
+        if !inner.config.enabled {
+            info!("ATX disabled in configuration");
+            return Ok(());
+        }
+
+        info!("Initializing ATX controller");
+
+        // Initialize power executor
+        if inner.config.power.is_configured() {
+            let mut executor = AtxKeyExecutor::new(inner.config.power.clone());
+            if let Err(e) = executor.init().await {
+                warn!("Failed to initialize power executor: {}", e);
+            } else {
+                info!(
+                    "Power executor initialized: {:?} on {} pin {}",
+                    inner.config.power.driver, inner.config.power.device, inner.config.power.pin
+                );
+                inner.power_executor = Some(executor);
+            }
+        }
+
+        // Initialize reset executor
+        if inner.config.reset.is_configured() {
+            let mut executor = AtxKeyExecutor::new(inner.config.reset.clone());
+            if let Err(e) = executor.init().await {
+                warn!("Failed to initialize reset executor: {}", e);
+            } else {
+                info!(
+                    "Reset executor initialized: {:?} on {} pin {}",
+                    inner.config.reset.driver, inner.config.reset.device, inner.config.reset.pin
+                );
+                inner.reset_executor = Some(executor);
+            }
+        }
+
+        // Initialize LED sensor
+        if inner.config.led.is_configured() {
+            let mut sensor = LedSensor::new(inner.config.led.clone());
+            if let Err(e) = sensor.init().await {
+                warn!("Failed to initialize LED sensor: {}", e);
+            } else {
+                info!(
+                    "LED sensor initialized on {} pin {}",
+                    inner.config.led.gpio_chip, inner.config.led.gpio_pin
+                );
+                inner.led_sensor = Some(sensor);
+            }
+        }
+
+        info!("ATX controller initialized successfully");
+        Ok(())
+    }
+
+    /// Reload the ATX controller with new configuration
+    ///
+    /// This is called when configuration changes and supports hot-reload.
+    pub async fn reload(&self, new_config: AtxControllerConfig) -> Result<()> {
+        info!("Reloading ATX controller with new configuration");
+
+        // Shutdown existing executors
+        self.shutdown_internal().await?;
+
+        // Update configuration and re-initialize
+        {
+            let mut inner = self.inner.write().await;
+            inner.config = new_config;
+        }
+
+        // Re-initialize
+        self.init().await?;
+
+        info!("ATX controller reloaded successfully");
+        Ok(())
+    }
+
+    /// Get current ATX state (single lock acquisition)
+    pub async fn state(&self) -> AtxState {
+        let inner = self.inner.read().await;
+
+        let power_status = if let Some(sensor) = inner.led_sensor.as_ref() {
+            sensor.read().await.unwrap_or(PowerStatus::Unknown)
+        } else {
+            PowerStatus::Unknown
+        };
+
+        AtxState {
+            available: inner.config.enabled,
+            power_configured: inner
+                .power_executor
+                .as_ref()
+                .map(|e| e.is_initialized())
+                .unwrap_or(false),
+            reset_configured: inner
+                .reset_executor
+                .as_ref()
+                .map(|e| e.is_initialized())
+                .unwrap_or(false),
+            power_status,
+            led_supported: inner
+                .led_sensor
+                .as_ref()
+                .map(|s| s.is_initialized())
+                .unwrap_or(false),
+        }
+    }
+
+    /// Get current state as SystemEvent
+    pub async fn current_state_event(&self) -> crate::events::SystemEvent {
+        let state = self.state().await;
+        crate::events::SystemEvent::AtxStateChanged {
+            power_status: state.power_status,
+        }
+    }
+
+    /// Check if ATX is available
+    pub async fn is_available(&self) -> bool {
+        let inner = self.inner.read().await;
+        inner.config.enabled
+    }
+
+    /// Check if power button is configured and initialized
+    pub async fn is_power_ready(&self) -> bool {
+        let inner = self.inner.read().await;
+        inner
+            .power_executor
+            .as_ref()
+            .map(|e| e.is_initialized())
+            .unwrap_or(false)
+    }
+
+    /// Check if reset button is configured and initialized
+    pub async fn is_reset_ready(&self) -> bool {
+        let inner = self.inner.read().await;
+        inner
+            .reset_executor
+            .as_ref()
+            .map(|e| e.is_initialized())
+            .unwrap_or(false)
+    }
+
+    /// Short press power button (turn on or graceful shutdown)
+    pub async fn power_short(&self) -> Result<()> {
+        let inner = self.inner.read().await;
+        let executor = inner
+            .power_executor
+            .as_ref()
+            .ok_or_else(|| AppError::Internal("Power button not configured".to_string()))?;
+
+        info!(
+            "ATX: Short press power button ({}ms)",
+            timing::SHORT_PRESS.as_millis()
+        );
+        executor.pulse(timing::SHORT_PRESS).await
+    }
+
+    /// Long press power button (force power off)
+    pub async fn power_long(&self) -> Result<()> {
+        let inner = self.inner.read().await;
+        let executor = inner
+            .power_executor
+            .as_ref()
+            .ok_or_else(|| AppError::Internal("Power button not configured".to_string()))?;
+
+        info!(
+            "ATX: Long press power button ({}ms)",
+            timing::LONG_PRESS.as_millis()
+        );
+        executor.pulse(timing::LONG_PRESS).await
+    }
+
+    /// Press reset button
+    pub async fn reset(&self) -> Result<()> {
+        let inner = self.inner.read().await;
+        let executor = inner
+            .reset_executor
+            .as_ref()
+            .ok_or_else(|| AppError::Internal("Reset button not configured".to_string()))?;
+
+        info!(
+            "ATX: Press reset button ({}ms)",
+            timing::RESET_PRESS.as_millis()
+        );
+        executor.pulse(timing::RESET_PRESS).await
+    }
+
+    /// Get current power status from LED sensor
+    pub async fn power_status(&self) -> Result<PowerStatus> {
+        let inner = self.inner.read().await;
+        match inner.led_sensor.as_ref() {
+            Some(sensor) => sensor.read().await,
+            None => Ok(PowerStatus::Unknown),
+        }
+    }
+
+    /// Shutdown the ATX controller
+    pub async fn shutdown(&self) -> Result<()> {
+        info!("Shutting down ATX controller");
+        self.shutdown_internal().await?;
+        info!("ATX controller shutdown complete");
+        Ok(())
+    }
+
+    /// Internal shutdown helper
+    async fn shutdown_internal(&self) -> Result<()> {
+        let mut inner = self.inner.write().await;
+
+        // Shutdown power executor
+        if let Some(mut executor) = inner.power_executor.take() {
+            executor.shutdown().await.ok();
+        }
+
+        // Shutdown reset executor
+        if let Some(mut executor) = inner.reset_executor.take() {
+            executor.shutdown().await.ok();
+        }
+
+        // Shutdown LED sensor
+        if let Some(mut sensor) = inner.led_sensor.take() {
+            sensor.shutdown().await.ok();
+        }
+
+        Ok(())
+    }
+}
+
+impl Drop for AtxController {
+    fn drop(&mut self) {
+        debug!("ATX controller dropped");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_controller_config_default() {
+        let config = AtxControllerConfig::default();
+        assert!(!config.enabled);
+        assert!(!config.power.is_configured());
+        assert!(!config.reset.is_configured());
+        assert!(!config.led.is_configured());
+    }
+
+    #[test]
+    fn test_controller_creation() {
+        let controller = AtxController::disabled();
+        assert!(controller.inner.try_read().is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_controller_disabled_state() {
+        let controller = AtxController::disabled();
+        let state = controller.state().await;
+        assert!(!state.available);
+        assert!(!state.power_configured);
+        assert!(!state.reset_configured);
+    }
+
+    #[tokio::test]
+    async fn test_controller_init_disabled() {
+        let controller = AtxController::disabled();
+        let result = controller.init().await;
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_controller_is_available() {
+        let controller = AtxController::disabled();
+        assert!(!controller.is_available().await);
+
+        let config = AtxControllerConfig {
+            enabled: true,
+            ..Default::default()
+        };
+        let controller = AtxController::new(config);
+        assert!(controller.is_available().await);
+    }
+}

src/atx/executor.rs

@@ -0,0 +1,305 @@
+//! ATX Key Executor
+//!
+//! Lightweight executor for a single ATX key operation.
+//! Each executor handles one button (power or reset) with its own hardware binding.
+
+use gpio_cdev::{Chip, LineHandle, LineRequestFlags};
+use std::fs::{File, OpenOptions};
+use std::io::Write;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
+use std::time::Duration;
+use tokio::time::sleep;
+use tracing::{debug, info};
+
+use super::types::{ActiveLevel, AtxDriverType, AtxKeyConfig};
+use crate::error::{AppError, Result};
+
+/// Timing constants for ATX operations
+pub mod timing {
+    use std::time::Duration;
+
+    /// Short press duration (power on/graceful shutdown)
+    pub const SHORT_PRESS: Duration = Duration::from_millis(500);
+
+    /// Long press duration (force power off)
+    pub const LONG_PRESS: Duration = Duration::from_millis(5000);
+
+    /// Reset press duration
+    pub const RESET_PRESS: Duration = Duration::from_millis(500);
+}
+
+/// Executor for a single ATX key operation
+///
+/// Each executor manages one hardware button (power or reset).
+/// It handles both GPIO and USB relay backends.
+pub struct AtxKeyExecutor {
+    config: AtxKeyConfig,
+    gpio_handle: Mutex<Option<LineHandle>>,
+    /// Cached USB relay file handle to avoid repeated open/close syscalls
+    usb_relay_handle: Mutex<Option<File>>,
+    initialized: AtomicBool,
+}
+
+impl AtxKeyExecutor {
+    /// Create a new executor with the given configuration
+    pub fn new(config: AtxKeyConfig) -> Self {
+        Self {
+            config,
+            gpio_handle: Mutex::new(None),
+            usb_relay_handle: Mutex::new(None),
+            initialized: AtomicBool::new(false),
+        }
+    }
+
+    /// Check if this executor is configured
+    pub fn is_configured(&self) -> bool {
+        self.config.is_configured()
+    }
+
+    /// Check if this executor is initialized
+    pub fn is_initialized(&self) -> bool {
+        self.initialized.load(Ordering::Relaxed)
+    }
+
+    /// Initialize the executor
+    pub async fn init(&mut self) -> Result<()> {
+        if !self.config.is_configured() {
+            debug!("ATX key executor not configured, skipping init");
+            return Ok(());
+        }
+
+        match self.config.driver {
+            AtxDriverType::Gpio => self.init_gpio().await?,
+            AtxDriverType::UsbRelay => self.init_usb_relay().await?,
+            AtxDriverType::None => {}
+        }
+
+        self.initialized.store(true, Ordering::Relaxed);
+        Ok(())
+    }
+
+    /// Initialize GPIO backend
+    async fn init_gpio(&mut self) -> Result<()> {
+        info!(
+            "Initializing GPIO ATX executor on {} pin {}",
+            self.config.device, self.config.pin
+        );
+
+        let mut chip = Chip::new(&self.config.device)
+            .map_err(|e| AppError::Internal(format!("GPIO chip open failed: {}", e)))?;
+
+        let line = chip.get_line(self.config.pin).map_err(|e| {
+            AppError::Internal(format!("GPIO line {} failed: {}", self.config.pin, e))
+        })?;
+
+        // Initial value depends on active level (start in inactive state)
+        let initial_value = match self.config.active_level {
+            ActiveLevel::High => 0, // Inactive = low
+            ActiveLevel::Low => 1,  // Inactive = high
+        };
+
+        let handle = line
+            .request(LineRequestFlags::OUTPUT, initial_value, "one-kvm-atx")
+            .map_err(|e| AppError::Internal(format!("GPIO request failed: {}", e)))?;
+
+        *self.gpio_handle.lock().unwrap() = Some(handle);
+        debug!("GPIO pin {} configured successfully", self.config.pin);
+        Ok(())
+    }
+
+    /// Initialize USB relay backend
+    async fn init_usb_relay(&self) -> Result<()> {
+        info!(
+            "Initializing USB relay ATX executor on {} channel {}",
+            self.config.device, self.config.pin
+        );
+
+        // Open and cache the device handle
+        let device = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(&self.config.device)
+            .map_err(|e| AppError::Internal(format!("USB relay device open failed: {}", e)))?;
+
+        *self.usb_relay_handle.lock().unwrap() = Some(device);
+
+        // Ensure relay is off initially
+        self.send_usb_relay_command(false)?;
+
+        debug!(
+            "USB relay channel {} configured successfully",
+            self.config.pin
+        );
+        Ok(())
+    }
+
+    /// Pulse the button for the specified duration
+    pub async fn pulse(&self, duration: Duration) -> Result<()> {
+        if !self.is_configured() {
+            return Err(AppError::Internal("ATX key not configured".to_string()));
+        }
+
+        if !self.is_initialized() {
+            return Err(AppError::Internal("ATX key not initialized".to_string()));
+        }
+
+        match self.config.driver {
+            AtxDriverType::Gpio => self.pulse_gpio(duration).await,
+            AtxDriverType::UsbRelay => self.pulse_usb_relay(duration).await,
+            AtxDriverType::None => Ok(()),
+        }
+    }
+
+    /// Pulse GPIO pin
+    async fn pulse_gpio(&self, duration: Duration) -> Result<()> {
+        let (active, inactive) = match self.config.active_level {
+            ActiveLevel::High => (1u8, 0u8),
+            ActiveLevel::Low => (0u8, 1u8),
+        };
+
+        // Set to active state
+        {
+            let guard = self.gpio_handle.lock().unwrap();
+            let handle = guard
+                .as_ref()
+                .ok_or_else(|| AppError::Internal("GPIO not initialized".to_string()))?;
+            handle
+                .set_value(active)
+                .map_err(|e| AppError::Internal(format!("GPIO set failed: {}", e)))?;
+        }
+
+        // Wait for duration (no lock held)
+        sleep(duration).await;
+
+        // Set to inactive state
+        {
+            let guard = self.gpio_handle.lock().unwrap();
+            if let Some(handle) = guard.as_ref() {
+                handle.set_value(inactive).ok();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Pulse USB relay
+    async fn pulse_usb_relay(&self, duration: Duration) -> Result<()> {
+        // Turn relay on
+        self.send_usb_relay_command(true)?;
+
+        // Wait for duration
+        sleep(duration).await;
+
+        // Turn relay off
+        self.send_usb_relay_command(false)?;
+
+        Ok(())
+    }
+
+    /// Send USB relay command using cached handle
+    fn send_usb_relay_command(&self, on: bool) -> Result<()> {
+        let channel = self.config.pin as u8;
+
+        // Standard HID relay command format
+        let cmd = if on {
+            [0x00, channel + 1, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00]
+        } else {
+            [0x00, channel + 1, 0xFD, 0x00, 0x00, 0x00, 0x00, 0x00]
+        };
+
+        let mut guard = self.usb_relay_handle.lock().unwrap();
+        let device = guard
+            .as_mut()
+            .ok_or_else(|| AppError::Internal("USB relay not initialized".to_string()))?;
+
+        device
+            .write_all(&cmd)
+            .map_err(|e| AppError::Internal(format!("USB relay write failed: {}", e)))?;
+
+        Ok(())
+    }
+
+    /// Shutdown the executor
+    pub async fn shutdown(&mut self) -> Result<()> {
+        if !self.is_initialized() {
+            return Ok(());
+        }
+
+        match self.config.driver {
+            AtxDriverType::Gpio => {
+                // Release GPIO handle
+                *self.gpio_handle.lock().unwrap() = None;
+            }
+            AtxDriverType::UsbRelay => {
+                // Ensure relay is off before closing handle
+                let _ = self.send_usb_relay_command(false);
+                // Release USB relay handle
+                *self.usb_relay_handle.lock().unwrap() = None;
+            }
+            AtxDriverType::None => {}
+        }
+
+        self.initialized.store(false, Ordering::Relaxed);
+        debug!("ATX key executor shutdown complete");
+        Ok(())
+    }
+}
+
+impl Drop for AtxKeyExecutor {
+    fn drop(&mut self) {
+        // Ensure GPIO lines are released
+        *self.gpio_handle.lock().unwrap() = None;
+
+        // Ensure USB relay is off and handle released
+        if self.config.driver == AtxDriverType::UsbRelay && self.is_initialized() {
+            let _ = self.send_usb_relay_command(false);
+        }
+        *self.usb_relay_handle.lock().unwrap() = None;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_executor_creation() {
+        let config = AtxKeyConfig::default();
+        let executor = AtxKeyExecutor::new(config);
+        assert!(!executor.is_configured());
+        assert!(!executor.is_initialized());
+    }
+
+    #[test]
+    fn test_executor_with_gpio_config() {
+        let config = AtxKeyConfig {
+            driver: AtxDriverType::Gpio,
+            device: "/dev/gpiochip0".to_string(),
+            pin: 5,
+            active_level: ActiveLevel::High,
+        };
+        let executor = AtxKeyExecutor::new(config);
+        assert!(executor.is_configured());
+        assert!(!executor.is_initialized());
+    }
+
+    #[test]
+    fn test_executor_with_usb_relay_config() {
+        let config = AtxKeyConfig {
+            driver: AtxDriverType::UsbRelay,
+            device: "/dev/hidraw0".to_string(),
+            pin: 0,
+            active_level: ActiveLevel::High, // Ignored for USB relay
+        };
+        let executor = AtxKeyExecutor::new(config);
+        assert!(executor.is_configured());
+    }
+
+    #[test]
+    fn test_timing_constants() {
+        assert_eq!(timing::SHORT_PRESS.as_millis(), 500);
+        assert_eq!(timing::LONG_PRESS.as_millis(), 5000);
+        assert_eq!(timing::RESET_PRESS.as_millis(), 500);
+    }
+}

src/atx/led.rs

@@ -0,0 +1,154 @@
+//! ATX LED Sensor
+//!
+//! Reads power LED status from GPIO to determine if the target system is powered on.
+
+use gpio_cdev::{Chip, LineHandle, LineRequestFlags};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
+use tracing::{debug, info};
+
+use super::types::{AtxLedConfig, PowerStatus};
+use crate::error::{AppError, Result};
+
+/// LED sensor for reading power status
+///
+/// Uses GPIO to read the power LED state and determine if the system is on or off.
+pub struct LedSensor {
+    config: AtxLedConfig,
+    handle: Mutex<Option<LineHandle>>,
+    initialized: AtomicBool,
+}
+
+impl LedSensor {
+    /// Create a new LED sensor with the given configuration
+    pub fn new(config: AtxLedConfig) -> Self {
+        Self {
+            config,
+            handle: Mutex::new(None),
+            initialized: AtomicBool::new(false),
+        }
+    }
+
+    /// Check if the sensor is configured
+    pub fn is_configured(&self) -> bool {
+        self.config.is_configured()
+    }
+
+    /// Check if the sensor is initialized
+    pub fn is_initialized(&self) -> bool {
+        self.initialized.load(Ordering::Relaxed)
+    }
+
+    /// Initialize the LED sensor
+    pub async fn init(&mut self) -> Result<()> {
+        if !self.config.is_configured() {
+            debug!("LED sensor not configured, skipping init");
+            return Ok(());
+        }
+
+        info!(
+            "Initializing LED sensor on {} pin {}",
+            self.config.gpio_chip, self.config.gpio_pin
+        );
+
+        let mut chip = Chip::new(&self.config.gpio_chip)
+            .map_err(|e| AppError::Internal(format!("LED GPIO chip failed: {}", e)))?;
+
+        let line = chip.get_line(self.config.gpio_pin).map_err(|e| {
+            AppError::Internal(format!("LED GPIO line {} failed: {}", self.config.gpio_pin, e))
+        })?;
+
+        let handle = line
+            .request(LineRequestFlags::INPUT, 0, "one-kvm-led")
+            .map_err(|e| AppError::Internal(format!("LED GPIO request failed: {}", e)))?;
+
+        *self.handle.lock().unwrap() = Some(handle);
+        self.initialized.store(true, Ordering::Relaxed);
+
+        debug!("LED sensor initialized successfully");
+        Ok(())
+    }
+
+    /// Read the current power status
+    pub async fn read(&self) -> Result<PowerStatus> {
+        if !self.is_configured() || !self.is_initialized() {
+            return Ok(PowerStatus::Unknown);
+        }
+
+        let guard = self.handle.lock().unwrap();
+        match guard.as_ref() {
+            Some(handle) => {
+                let value = handle
+                    .get_value()
+                    .map_err(|e| AppError::Internal(format!("LED read failed: {}", e)))?;
+
+                // Apply inversion if configured
+                let is_on = if self.config.inverted {
+                    value == 0 // Active low: 0 means on
+                } else {
+                    value == 1 // Active high: 1 means on
+                };
+
+                Ok(if is_on {
+                    PowerStatus::On
+                } else {
+                    PowerStatus::Off
+                })
+            }
+            None => Ok(PowerStatus::Unknown),
+        }
+    }
+
+    /// Shutdown the LED sensor
+    pub async fn shutdown(&mut self) -> Result<()> {
+        *self.handle.lock().unwrap() = None;
+        self.initialized.store(false, Ordering::Relaxed);
+        debug!("LED sensor shutdown complete");
+        Ok(())
+    }
+}
+
+impl Drop for LedSensor {
+    fn drop(&mut self) {
+        *self.handle.lock().unwrap() = None;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_led_sensor_creation() {
+        let config = AtxLedConfig::default();
+        let sensor = LedSensor::new(config);
+        assert!(!sensor.is_configured());
+        assert!(!sensor.is_initialized());
+    }
+
+    #[test]
+    fn test_led_sensor_with_config() {
+        let config = AtxLedConfig {
+            enabled: true,
+            gpio_chip: "/dev/gpiochip0".to_string(),
+            gpio_pin: 7,
+            inverted: false,
+        };
+        let sensor = LedSensor::new(config);
+        assert!(sensor.is_configured());
+        assert!(!sensor.is_initialized());
+    }
+
+    #[test]
+    fn test_led_sensor_inverted_config() {
+        let config = AtxLedConfig {
+            enabled: true,
+            gpio_chip: "/dev/gpiochip0".to_string(),
+            gpio_pin: 7,
+            inverted: true,
+        };
+        let sensor = LedSensor::new(config);
+        assert!(sensor.is_configured());
+        assert!(sensor.config.inverted);
+    }
+}

src/atx/mod.rs

@@ -0,0 +1,107 @@
+//! ATX Power Control Module
+//!
+//! Provides ATX power management functionality for IP-KVM.
+//! Supports flexible hardware binding with independent configuration for each action.
+//!
+//! # Features
+//!
+//! - Power button control (short press for on/graceful shutdown, long press for force off)
+//! - Reset button control
+//! - Power status monitoring via LED sensing (GPIO only)
+//! - Independent hardware binding for each action (GPIO or USB relay)
+//! - Hot-reload configuration support
+//!
+//! # Hardware Support
+//!
+//! - **GPIO**: Uses Linux GPIO character device (/dev/gpiochipX) for direct hardware control
+//! - **USB Relay**: Uses HID USB relay modules for isolated switching
+//!
+//! # Example
+//!
+//! ```ignore
+//! use one_kvm::atx::{AtxController, AtxControllerConfig, AtxKeyConfig, AtxDriverType, ActiveLevel};
+//!
+//! let config = AtxControllerConfig {
+//!     enabled: true,
+//!     power: AtxKeyConfig {
+//!         driver: AtxDriverType::Gpio,
+//!         device: "/dev/gpiochip0".to_string(),
+//!         pin: 5,
+//!         active_level: ActiveLevel::High,
+//!     },
+//!     reset: AtxKeyConfig {
+//!         driver: AtxDriverType::UsbRelay,
+//!         device: "/dev/hidraw0".to_string(),
+//!         pin: 0,
+//!         active_level: ActiveLevel::High,
+//!     },
+//!     led: Default::default(),
+//! };
+//!
+//! let controller = AtxController::new(config);
+//! controller.init().await?;
+//! controller.power_short().await?;  // Turn on or graceful shutdown
+//! ```
+
+mod controller;
+mod executor;
+mod led;
+mod types;
+mod wol;
+
+pub use controller::{AtxController, AtxControllerConfig};
+pub use executor::timing;
+pub use types::{
+    ActiveLevel, AtxAction, AtxDevices, AtxDriverType, AtxKeyConfig, AtxLedConfig,
+    AtxPowerRequest, AtxState, PowerStatus,
+};
+pub use wol::send_wol;
+
+/// Discover available ATX devices on the system
+///
+/// Scans for GPIO chips and USB HID relay devices in a single pass.
+pub fn discover_devices() -> AtxDevices {
+    let mut devices = AtxDevices::default();
+
+    // Single pass through /dev directory
+    if let Ok(entries) = std::fs::read_dir("/dev") {
+        for entry in entries.flatten() {
+            let name = entry.file_name();
+            let name_str = name.to_string_lossy();
+            if name_str.starts_with("gpiochip") {
+                devices.gpio_chips.push(format!("/dev/{}", name_str));
+            } else if name_str.starts_with("hidraw") {
+                devices.usb_relays.push(format!("/dev/{}", name_str));
+            }
+        }
+    }
+
+    devices.gpio_chips.sort();
+    devices.usb_relays.sort();
+
+    devices
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_discover_devices() {
+        let devices = discover_devices();
+        // Just verify the function runs without error
+        assert!(devices.gpio_chips.len() >= 0);
+        assert!(devices.usb_relays.len() >= 0);
+    }
+
+    #[test]
+    fn test_module_exports() {
+        // Verify all public exports are accessible
+        let _: AtxDriverType = AtxDriverType::None;
+        let _: ActiveLevel = ActiveLevel::High;
+        let _: AtxKeyConfig = AtxKeyConfig::default();
+        let _: AtxLedConfig = AtxLedConfig::default();
+        let _: AtxState = AtxState::default();
+        let _: AtxDevices = AtxDevices::default();
+    }
+}

src/atx/types.rs

@@ -0,0 +1,270 @@
+//! ATX data types and structures
+//!
+//! Defines the configuration and state types for the flexible ATX power control system.
+//! Each ATX action (power, reset) can be independently configured with different hardware.
+
+use serde::{Deserialize, Serialize};
+use typeshare::typeshare;
+
+/// Power status
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PowerStatus {
+    /// Power is on
+    On,
+    /// Power is off
+    Off,
+    /// Power status unknown (no LED connected)
+    Unknown,
+}
+
+impl Default for PowerStatus {
+    fn default() -> Self {
+        Self::Unknown
+    }
+}
+
+/// Driver type for ATX key operations
+#[typeshare]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum AtxDriverType {
+    /// GPIO control via Linux character device
+    Gpio,
+    /// USB HID relay module
+    UsbRelay,
+    /// Disabled / Not configured
+    None,
+}
+
+impl Default for AtxDriverType {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+/// Active level for GPIO pins
+#[typeshare]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ActiveLevel {
+    /// Active high (default for most cases)
+    High,
+    /// Active low (inverted)
+    Low,
+}
+
+impl Default for ActiveLevel {
+    fn default() -> Self {
+        Self::High
+    }
+}
+
+/// Configuration for a single ATX key (power or reset)
+/// This is the "four-tuple" configuration: (driver, device, pin/channel, level)
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct AtxKeyConfig {
+    /// Driver type (GPIO or USB Relay)
+    pub driver: AtxDriverType,
+    /// Device path:
+    /// - For GPIO: /dev/gpiochipX
+    /// - For USB Relay: /dev/hidrawX
+    pub device: String,
+    /// Pin or channel number:
+    /// - For GPIO: GPIO pin number
+    /// - For USB Relay: relay channel (0-based)
+    pub pin: u32,
+    /// Active level (only applicable to GPIO, ignored for USB Relay)
+    pub active_level: ActiveLevel,
+}
+
+impl Default for AtxKeyConfig {
+    fn default() -> Self {
+        Self {
+            driver: AtxDriverType::None,
+            device: String::new(),
+            pin: 0,
+            active_level: ActiveLevel::High,
+        }
+    }
+}
+
+impl AtxKeyConfig {
+    /// Check if this key is configured
+    pub fn is_configured(&self) -> bool {
+        self.driver != AtxDriverType::None && !self.device.is_empty()
+    }
+}
+
+/// LED sensing configuration (optional)
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct AtxLedConfig {
+    /// Whether LED sensing is enabled
+    pub enabled: bool,
+    /// GPIO chip for LED sensing
+    pub gpio_chip: String,
+    /// GPIO pin for LED input
+    pub gpio_pin: u32,
+    /// Whether LED is active low (inverted logic)
+    pub inverted: bool,
+}
+
+impl Default for AtxLedConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            gpio_chip: String::new(),
+            gpio_pin: 0,
+            inverted: false,
+        }
+    }
+}
+
+impl AtxLedConfig {
+    /// Check if LED sensing is configured
+    pub fn is_configured(&self) -> bool {
+        self.enabled && !self.gpio_chip.is_empty()
+    }
+}
+
+/// ATX state information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AtxState {
+    /// Whether ATX feature is available/enabled
+    pub available: bool,
+    /// Whether power button is configured
+    pub power_configured: bool,
+    /// Whether reset button is configured
+    pub reset_configured: bool,
+    /// Current power status
+    pub power_status: PowerStatus,
+    /// Whether power LED sensing is supported
+    pub led_supported: bool,
+}
+
+impl Default for AtxState {
+    fn default() -> Self {
+        Self {
+            available: false,
+            power_configured: false,
+            reset_configured: false,
+            power_status: PowerStatus::Unknown,
+            led_supported: false,
+        }
+    }
+}
+
+/// ATX power action request
+#[derive(Debug, Clone, Deserialize)]
+pub struct AtxPowerRequest {
+    /// Action to perform: "short", "long", "reset"
+    pub action: AtxAction,
+}
+
+/// ATX power action
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum AtxAction {
+    /// Short press power button (turn on or graceful shutdown)
+    Short,
+    /// Long press power button (force power off)
+    Long,
+    /// Press reset button
+    Reset,
+}
+
+/// Available ATX devices for discovery
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AtxDevices {
+    /// Available GPIO chips (/dev/gpiochip*)
+    pub gpio_chips: Vec<String>,
+    /// Available USB HID relay devices (/dev/hidraw*)
+    pub usb_relays: Vec<String>,
+}
+
+impl Default for AtxDevices {
+    fn default() -> Self {
+        Self {
+            gpio_chips: Vec::new(),
+            usb_relays: Vec::new(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_power_status_default() {
+        assert_eq!(PowerStatus::default(), PowerStatus::Unknown);
+    }
+
+    #[test]
+    fn test_atx_driver_type_default() {
+        assert_eq!(AtxDriverType::default(), AtxDriverType::None);
+    }
+
+    #[test]
+    fn test_active_level_default() {
+        assert_eq!(ActiveLevel::default(), ActiveLevel::High);
+    }
+
+    #[test]
+    fn test_atx_key_config_default() {
+        let config = AtxKeyConfig::default();
+        assert_eq!(config.driver, AtxDriverType::None);
+        assert!(config.device.is_empty());
+        assert_eq!(config.pin, 0);
+        assert!(!config.is_configured());
+    }
+
+    #[test]
+    fn test_atx_key_config_is_configured() {
+        let mut config = AtxKeyConfig::default();
+        assert!(!config.is_configured());
+
+        config.driver = AtxDriverType::Gpio;
+        assert!(!config.is_configured()); // device still empty
+
+        config.device = "/dev/gpiochip0".to_string();
+        assert!(config.is_configured());
+
+        config.driver = AtxDriverType::None;
+        assert!(!config.is_configured()); // driver is None
+    }
+
+    #[test]
+    fn test_atx_led_config_default() {
+        let config = AtxLedConfig::default();
+        assert!(!config.enabled);
+        assert!(config.gpio_chip.is_empty());
+        assert!(!config.is_configured());
+    }
+
+    #[test]
+    fn test_atx_led_config_is_configured() {
+        let mut config = AtxLedConfig::default();
+        assert!(!config.is_configured());
+
+        config.enabled = true;
+        assert!(!config.is_configured()); // gpio_chip still empty
+
+        config.gpio_chip = "/dev/gpiochip0".to_string();
+        assert!(config.is_configured());
+    }
+
+    #[test]
+    fn test_atx_state_default() {
+        let state = AtxState::default();
+        assert!(!state.available);
+        assert!(!state.power_configured);
+        assert!(!state.reset_configured);
+        assert_eq!(state.power_status, PowerStatus::Unknown);
+    }
+}

src/atx/wol.rs

@@ -0,0 +1,171 @@
+//! Wake-on-LAN (WOL) implementation
+//!
+//! Sends magic packets to wake up remote machines.
+
+use std::net::{SocketAddr, UdpSocket};
+use tracing::{debug, info};
+
+use crate::error::{AppError, Result};
+
+/// WOL magic packet structure:
+/// - 6 bytes of 0xFF
+/// - 16 repetitions of the target MAC address (6 bytes each)
+/// Total: 6 + 16 * 6 = 102 bytes
+const MAGIC_PACKET_SIZE: usize = 102;
+
+/// Parse MAC address string into bytes
+/// Supports formats: "AA:BB:CC:DD:EE:FF" or "AA-BB-CC-DD-EE-FF"
+fn parse_mac_address(mac: &str) -> Result<[u8; 6]> {
+    let mac = mac.trim().to_uppercase();
+    let parts: Vec<&str> = if mac.contains(':') {
+        mac.split(':').collect()
+    } else if mac.contains('-') {
+        mac.split('-').collect()
+    } else {
+        return Err(AppError::Config(format!("Invalid MAC address format: {}", mac)));
+    };
+
+    if parts.len() != 6 {
+        return Err(AppError::Config(format!(
+            "Invalid MAC address: expected 6 parts, got {}",
+            parts.len()
+        )));
+    }
+
+    let mut bytes = [0u8; 6];
+    for (i, part) in parts.iter().enumerate() {
+        bytes[i] = u8::from_str_radix(part, 16).map_err(|_| {
+            AppError::Config(format!("Invalid MAC address byte: {}", part))
+        })?;
+    }
+
+    Ok(bytes)
+}
+
+/// Build WOL magic packet
+fn build_magic_packet(mac: &[u8; 6]) -> [u8; MAGIC_PACKET_SIZE] {
+    let mut packet = [0u8; MAGIC_PACKET_SIZE];
+
+    // First 6 bytes are 0xFF
+    for byte in packet.iter_mut().take(6) {
+        *byte = 0xFF;
+    }
+
+    // Next 96 bytes are 16 repetitions of the MAC address
+    for i in 0..16 {
+        let offset = 6 + i * 6;
+        packet[offset..offset + 6].copy_from_slice(mac);
+    }
+
+    packet
+}
+
+/// Send WOL magic packet
+///
+/// # Arguments
+/// * `mac_address` - Target MAC address (e.g., "AA:BB:CC:DD:EE:FF")
+/// * `interface` - Optional network interface name (e.g., "eth0"). If None, uses default routing.
+pub fn send_wol(mac_address: &str, interface: Option<&str>) -> Result<()> {
+    let mac = parse_mac_address(mac_address)?;
+    let packet = build_magic_packet(&mac);
+
+    info!("Sending WOL packet to {} via {:?}", mac_address, interface);
+
+    // Create UDP socket
+    let socket = UdpSocket::bind("0.0.0.0:0")
+        .map_err(|e| AppError::Internal(format!("Failed to create UDP socket: {}", e)))?;
+
+    // Enable broadcast
+    socket
+        .set_broadcast(true)
+        .map_err(|e| AppError::Internal(format!("Failed to enable broadcast: {}", e)))?;
+
+    // Bind to specific interface if specified
+    #[cfg(target_os = "linux")]
+    if let Some(iface) = interface {
+        if !iface.is_empty() {
+            use std::os::unix::io::AsRawFd;
+            let fd = socket.as_raw_fd();
+            let iface_bytes = iface.as_bytes();
+
+            // SO_BINDTODEVICE requires interface name as null-terminated string
+            let mut iface_buf = [0u8; 16]; // IFNAMSIZ is typically 16
+            let len = iface_bytes.len().min(15);
+            iface_buf[..len].copy_from_slice(&iface_bytes[..len]);
+
+            let ret = unsafe {
+                libc::setsockopt(
+                    fd,
+                    libc::SOL_SOCKET,
+                    libc::SO_BINDTODEVICE,
+                    iface_buf.as_ptr() as *const libc::c_void,
+                    (len + 1) as libc::socklen_t,
+                )
+            };
+
+            if ret < 0 {
+                let err = std::io::Error::last_os_error();
+                return Err(AppError::Internal(format!(
+                    "Failed to bind to interface {}: {}",
+                    iface, err
+                )));
+            }
+            debug!("Bound to interface: {}", iface);
+        }
+    }
+
+    // Send to broadcast address on port 9 (discard protocol, commonly used for WOL)
+    let broadcast_addr: SocketAddr = "255.255.255.255:9".parse().unwrap();
+
+    socket
+        .send_to(&packet, broadcast_addr)
+        .map_err(|e| AppError::Internal(format!("Failed to send WOL packet: {}", e)))?;
+
+    // Also try sending to port 7 (echo protocol, alternative WOL port)
+    let broadcast_addr_7: SocketAddr = "255.255.255.255:7".parse().unwrap();
+    let _ = socket.send_to(&packet, broadcast_addr_7);
+
+    info!("WOL packet sent successfully to {}", mac_address);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_mac_address_colon() {
+        let mac = parse_mac_address("AA:BB:CC:DD:EE:FF").unwrap();
+        assert_eq!(mac, [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF]);
+    }
+
+    #[test]
+    fn test_parse_mac_address_dash() {
+        let mac = parse_mac_address("aa-bb-cc-dd-ee-ff").unwrap();
+        assert_eq!(mac, [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF]);
+    }
+
+    #[test]
+    fn test_parse_mac_address_invalid() {
+        assert!(parse_mac_address("invalid").is_err());
+        assert!(parse_mac_address("AA:BB:CC:DD:EE").is_err());
+        assert!(parse_mac_address("AA:BB:CC:DD:EE:GG").is_err());
+    }
+
+    #[test]
+    fn test_build_magic_packet() {
+        let mac = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF];
+        let packet = build_magic_packet(&mac);
+
+        // Check header (6 bytes of 0xFF)
+        for i in 0..6 {
+            assert_eq!(packet[i], 0xFF);
+        }
+
+        // Check MAC repetitions
+        for i in 0..16 {
+            let offset = 6 + i * 6;
+            assert_eq!(&packet[offset..offset + 6], &mac);
+        }
+    }
+}