Initial pipewiremain

3 files changed, 738 insertions, 0 deletions

diff --git a/src/usb/device.rs b/src/usb/device.rs
new file mode 100644
index 0000000..b285e81
--- /dev/null
+++ b/src/usb/device.rs
@@ -0,0 +1,287 @@
+//! USB device implementation for the Geek szitman supercamera
+
+use super::{ENDPOINT_1, ENDPOINT_2, INTERFACE_A_NUMBER, INTERFACE_B_NUMBER, INTERFACE_B_ALTERNATE_SETTING, USB_PRODUCT_ID, USB_TIMEOUT, USB_VENDOR_ID};
+use crate::error::{Result, UsbError};
+use rusb::{Context, Device, DeviceHandle, UsbContext};
+use std::sync::Arc;
+use std::sync::Mutex;
+use tracing::{debug, error, info, warn};
+
+/// USB device handle wrapper
+pub struct UsbSupercamera {
+    context: Arc<Context>,
+    handle: Arc<Mutex<Option<DeviceHandle<Context>>>>,
+    device_info: super::UsbDeviceInfo,
+}
+
+impl UsbSupercamera {
+    /// Create a new USB supercamera instance
+    pub fn new() -> Result<Self> {
+        let context = Arc::new(Context::new()?);
+        let handle = Arc::new(Mutex::new(None));
+        let device_info = super::UsbDeviceInfo::default();
+
+        let mut instance = Self {
+            context,
+            handle,
+            device_info,
+        };
+
+        instance.connect()?;
+        instance.initialize_device()?;
+
+        Ok(instance)
+    }
+
+    /// Connect to the USB device
+    fn connect(&mut self) -> Result<()> {
+        let device = self.find_device()?;
+        let handle = device.open()?;
+
+        // Ensure kernel drivers are detached when claiming interfaces
+        handle.set_auto_detach_kernel_driver(true)?;
+
+        let mut handle_guard = self.handle.try_lock()
+            .map_err(|_| UsbError::Generic("Failed to acquire handle lock".to_string()))?;
+        *handle_guard = Some(handle);
+
+        info!("Connected to USB device {:04x}:{:04x}", USB_VENDOR_ID, USB_PRODUCT_ID);
+        Ok(())
+    }
+
+    /// Find the target USB device
+    fn find_device(&self) -> Result<Device<Context>> {
+        for device in self.context.devices()?.iter() {
+            let device_desc = device.device_descriptor()?;
+            
+            if device_desc.vendor_id() == USB_VENDOR_ID && 
+               device_desc.product_id() == USB_PRODUCT_ID {
+                debug!("Found target device: {:04x}:{:04x}", USB_VENDOR_ID, USB_PRODUCT_ID);
+                return Ok(device);
+            }
+        }
+
+        Err(UsbError::DeviceNotFound.into())
+    }
+
+    /// Initialize the USB device interfaces and endpoints
+    fn initialize_device(&self) -> Result<()> {
+        let handle_guard = self.handle.try_lock()
+            .map_err(|_| UsbError::Generic("Failed to acquire handle lock".to_string()))?;
+        
+        let handle = handle_guard.as_ref()
+            .ok_or_else(|| UsbError::Generic("No device handle available".to_string()))?;
+
+        // Claim interface A
+        self.claim_interface(handle, INTERFACE_A_NUMBER)?;
+        
+        // Claim interface B
+        self.claim_interface(handle, INTERFACE_B_NUMBER)?;
+        
+        // Set alternate setting for interface B
+        self.set_interface_alt_setting(handle, INTERFACE_B_NUMBER, INTERFACE_B_ALTERNATE_SETTING)?;
+        
+        // Clear halt on endpoint 1 (both directions)
+        self.clear_halt(handle, ENDPOINT_1 | 0x80)?; // IN  (0x81)
+        self.clear_halt(handle, ENDPOINT_1)?;        // OUT (0x01)
+        
+        // Send initialization commands
+        self.send_init_commands(handle)?;
+
+        info!("USB device initialized successfully");
+        Ok(())
+    }
+
+    /// Claim a USB interface
+    fn claim_interface(&self, handle: &DeviceHandle<Context>, interface: u8) -> Result<()> {
+        match handle.claim_interface(interface) {
+            Ok(()) => {
+                debug!("Claimed interface {}", interface);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to claim interface {}: {}", interface, e);
+                Err(UsbError::InterfaceClaimFailed(e.to_string()).into())
+            }
+        }
+    }
+
+    /// Set interface alternate setting
+    fn set_interface_alt_setting(&self, handle: &DeviceHandle<Context>, interface: u8, setting: u8) -> Result<()> {
+        match handle.set_alternate_setting(interface, setting) {
+            Ok(()) => {
+                debug!("Set interface {} alternate setting to {}", interface, setting);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to set interface {} alternate setting {}: {}", interface, setting, e);
+                Err(UsbError::Generic(format!("Failed to set alternate setting: {e}")).into())
+            }
+        }
+    }
+
+    /// Clear halt on an endpoint
+    fn clear_halt(&self, handle: &DeviceHandle<Context>, endpoint: u8) -> Result<()> {
+        match handle.clear_halt(endpoint) {
+            Ok(()) => {
+                debug!("Cleared halt on endpoint {}", endpoint);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to clear halt on endpoint {}: {}", endpoint, e);
+                Err(UsbError::Generic(format!("Failed to clear halt: {e}")).into())
+            }
+        }
+    }
+
+    /// Send initialization commands to the device
+    fn send_init_commands(&self, handle: &DeviceHandle<Context>) -> Result<()> {
+        // Send magic words to endpoint 2
+        let ep2_buf = vec![0xFF, 0x55, 0xFF, 0x55, 0xEE, 0x10];
+        self.write_bulk(handle, ENDPOINT_2, &ep2_buf)?;
+        
+        // Send start stream command to endpoint 1
+        let start_stream = vec![0xBB, 0xAA, 5, 0, 0];
+        self.write_bulk(handle, ENDPOINT_1, &start_stream)?;
+        
+        debug!("Sent initialization commands");
+        Ok(())
+    }
+
+    /// Read a frame from the USB device
+    pub fn read_frame(&self) -> Result<Vec<u8>> {
+        let handle_guard = self.handle.lock().unwrap();
+        let handle = handle_guard.as_ref()
+            .ok_or_else(|| UsbError::Generic("No device handle available".to_string()))?;
+
+        // Use a larger buffer to handle potential frame buffering
+        let mut buffer = vec![0u8; 0x2000]; // Increased from 0x1000 to 0x2000
+        let transferred = self.read_bulk(handle, ENDPOINT_1, &mut buffer)?;
+        
+        buffer.truncate(transferred);
+        // Reduce logging frequency - only log every 100th read
+        static mut READ_COUNT: u32 = 0;
+        unsafe {
+            READ_COUNT += 1;
+            if READ_COUNT % 100 == 0 {
+                debug!("Read {} bytes from USB device", transferred);
+            }
+        }
+        
+        // Validate that we got a reasonable amount of data
+        if transferred < 12 { // Minimum frame size: USB header (5) + camera header (7)
+            return Err(UsbError::Generic(format!(
+                "Received frame too small: {} bytes (minimum: 12)",
+                transferred
+            )).into());
+        }
+        
+        // Check if this looks like a valid UPP frame
+        if transferred >= 5 {
+            let magic_bytes = [buffer[0], buffer[1]];
+            let magic = u16::from_le_bytes(magic_bytes);
+            if magic != crate::protocol::UPP_USB_MAGIC {
+                warn!("Received data doesn't start with expected magic: 0x{:04X}", magic);
+            }
+        }
+        
+        Ok(buffer)
+    }
+
+    /// Read bulk data from an endpoint
+    fn read_bulk(&self, handle: &DeviceHandle<Context>, endpoint: u8, buffer: &mut [u8]) -> Result<usize> {
+        let endpoint_address = endpoint | 0x80; // IN endpoint address bit
+
+        match handle.read_bulk(endpoint_address, buffer, USB_TIMEOUT) {
+            Ok(transferred) => {
+                debug!("Read {} bytes from endpoint {}", transferred, endpoint);
+                Ok(transferred)
+            }
+            Err(e) => {
+                error!("USB read error on endpoint {}: {}", endpoint, e);
+                match e {
+                    rusb::Error::NoDevice => Err(UsbError::DeviceDisconnected.into()),
+                    rusb::Error::Timeout => Err(UsbError::Timeout.into()),
+                    _ => Err(UsbError::BulkTransferFailed(e.to_string()).into()),
+                }
+            }
+        }
+    }
+
+    /// Write bulk data to an endpoint
+    fn write_bulk(&self, handle: &DeviceHandle<Context>, endpoint: u8, data: &[u8]) -> Result<()> {
+        let endpoint_address = endpoint; // OUT endpoint has no direction bit set
+
+        match handle.write_bulk(endpoint_address, data, USB_TIMEOUT) {
+            Ok(transferred) => {
+                debug!("Wrote {} bytes to endpoint {}", transferred, endpoint);
+                Ok(())
+            }
+            Err(e) => {
+                error!("USB write error on endpoint {}: {}", endpoint, e);
+                match e {
+                    rusb::Error::NoDevice => Err(UsbError::DeviceDisconnected.into()),
+                    rusb::Error::Timeout => Err(UsbError::Timeout.into()),
+                    _ => Err(UsbError::BulkTransferFailed(e.to_string()).into()),
+                }
+            }
+        }
+    }
+
+    /// Get device information
+    pub fn device_info(&self) -> &super::UsbDeviceInfo {
+        &self.device_info
+    }
+
+    /// Check if device is connected
+    pub fn is_connected(&self) -> bool {
+        let handle_guard = self.handle.lock().unwrap();
+        handle_guard.is_some()
+    }
+}
+
+impl Drop for UsbSupercamera {
+    fn drop(&mut self) {
+        if let Ok(handle_guard) = self.handle.try_lock() {
+            if let Some(handle) = handle_guard.as_ref() {
+                // Release interfaces
+                let _ = handle.release_interface(INTERFACE_A_NUMBER);
+                let _ = handle.release_interface(INTERFACE_B_NUMBER);
+                debug!("Released USB interfaces");
+            }
+        }
+        debug!("USB supercamera dropped");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+
+    // Mock USB context for testing - simplified for now
+    // TODO: Implement proper mock when needed for more complex testing
+
+    #[test]
+    fn test_usb_device_info() {
+        let device_info = super::super::UsbDeviceInfo::default();
+        assert_eq!(device_info.vendor_id, USB_VENDOR_ID);
+        assert_eq!(device_info.product_id, USB_PRODUCT_ID);
+    }
+
+    #[test]
+    fn test_endpoint_constants() {
+        assert_eq!(ENDPOINT_1, 1);
+        assert_eq!(ENDPOINT_2, 2);
+        assert_eq!(INTERFACE_A_NUMBER, 0);
+        assert_eq!(INTERFACE_B_NUMBER, 1);
+        assert_eq!(INTERFACE_B_ALTERNATE_SETTING, 1);
+    }
+
+    #[test]
+    fn test_usb_supercamera_creation_fails_without_device() {
+        // This test will fail in CI/CD environments without actual USB device
+        // In a real test environment, we'd use mocks
+        assert!(true);
+    }
+}
diff --git a/src/usb/mod.rs b/src/usb/mod.rs
new file mode 100644
index 0000000..38d9c7d
--- /dev/null
+++ b/src/usb/mod.rs
@@ -0,0 +1,164 @@
+//! USB communication module for the Geek szitman supercamera
+
+mod device;
+mod transfer;
+
+pub use device::UsbSupercamera;
+pub use transfer::{UsbTransferConfig, UsbTransferError, UsbTransferResult, UsbTransferStats};
+
+use rusb::{Direction, TransferType};
+use std::time::Duration;
+
+/// USB device constants
+pub const USB_VENDOR_ID: u16 = 0x2ce3;
+pub const USB_PRODUCT_ID: u16 = 0x3828;
+pub const INTERFACE_A_NUMBER: u8 = 0;
+pub const INTERFACE_B_NUMBER: u8 = 1;
+pub const INTERFACE_B_ALTERNATE_SETTING: u8 = 1;
+pub const ENDPOINT_1: u8 = 1;
+pub const ENDPOINT_2: u8 = 2;
+pub const USB_TIMEOUT: Duration = Duration::from_millis(1000);
+
+/// USB device information
+#[derive(Debug, Clone)]
+pub struct UsbDeviceInfo {
+    pub vendor_id: u16,
+    pub product_id: u16,
+    pub manufacturer: Option<String>,
+    pub product: Option<String>,
+    pub serial_number: Option<String>,
+}
+
+impl Default for UsbDeviceInfo {
+    fn default() -> Self {
+        Self {
+            vendor_id: USB_VENDOR_ID,
+            product_id: USB_PRODUCT_ID,
+            manufacturer: None,
+            product: None,
+            serial_number: None,
+        }
+    }
+}
+
+/// USB endpoint configuration
+#[derive(Debug, Clone)]
+pub struct UsbEndpoint {
+    pub address: u8,
+    pub direction: Direction,
+    pub transfer_type: TransferType,
+    pub max_packet_size: u16,
+}
+
+impl UsbEndpoint {
+    /// Create a new USB endpoint
+    pub fn new(
+        address: u8,
+        direction: Direction,
+        transfer_type: TransferType,
+        max_packet_size: u16,
+    ) -> Self {
+        Self {
+            address,
+            direction,
+            transfer_type,
+            max_packet_size,
+        }
+    }
+}
+
+/// USB interface configuration
+#[derive(Debug, Clone)]
+pub struct UsbInterface {
+    pub number: u8,
+    pub alternate_setting: u8,
+    pub endpoints: Vec<UsbEndpoint>,
+}
+
+impl UsbInterface {
+    /// Create a new USB interface
+    pub fn new(number: u8, alternate_setting: u8) -> Self {
+        Self {
+            number,
+            alternate_setting,
+            endpoints: Vec::new(),
+        }
+    }
+
+    /// Add an endpoint to this interface
+    pub fn add_endpoint(&mut self, endpoint: UsbEndpoint) {
+        self.endpoints.push(endpoint);
+    }
+}
+
+/// USB device configuration
+#[derive(Debug, Clone)]
+pub struct UsbConfig {
+    pub interfaces: Vec<UsbInterface>,
+    pub max_packet_size: u16,
+}
+
+impl Default for UsbConfig {
+    fn default() -> Self {
+        let mut interface_a = UsbInterface::new(INTERFACE_A_NUMBER, 0);
+        interface_a.add_endpoint(UsbEndpoint::new(
+            ENDPOINT_1,
+            Direction::In,
+            TransferType::Bulk,
+            0x1000,
+        ));
+
+        let mut interface_b = UsbInterface::new(INTERFACE_B_NUMBER, INTERFACE_B_ALTERNATE_SETTING);
+        interface_b.add_endpoint(UsbEndpoint::new(
+            ENDPOINT_2,
+            Direction::Out,
+            TransferType::Bulk,
+            64,
+        ));
+
+        Self {
+            interfaces: vec![interface_a, interface_b],
+            max_packet_size: 0x1000,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_usb_device_info_default() {
+        let info = UsbDeviceInfo::default();
+        assert_eq!(info.vendor_id, USB_VENDOR_ID);
+        assert_eq!(info.product_id, USB_PRODUCT_ID);
+    }
+
+    #[test]
+    fn test_usb_endpoint_creation() {
+        let endpoint = UsbEndpoint::new(ENDPOINT_1, Direction::In, TransferType::Bulk, 0x1000);
+        assert_eq!(endpoint.address, ENDPOINT_1);
+        assert_eq!(endpoint.direction, Direction::In);
+        assert_eq!(endpoint.transfer_type, TransferType::Bulk);
+        assert_eq!(endpoint.max_packet_size, 0x1000);
+    }
+
+    #[test]
+    fn test_usb_interface_management() {
+        let mut interface = UsbInterface::new(0, 0);
+        let endpoint = UsbEndpoint::new(1, Direction::In, TransferType::Bulk, 64);
+
+        interface.add_endpoint(endpoint);
+        assert_eq!(interface.endpoints.len(), 1);
+        assert_eq!(interface.endpoints[0].address, 1);
+    }
+
+    #[test]
+    fn test_usb_config_default() {
+        let config = UsbConfig::default();
+        assert_eq!(config.interfaces.len(), 2);
+        assert_eq!(config.interfaces[0].number, INTERFACE_A_NUMBER);
+        assert_eq!(config.interfaces[1].number, INTERFACE_B_NUMBER);
+        assert_eq!(config.max_packet_size, 0x1000);
+    }
+}
diff --git a/src/usb/transfer.rs b/src/usb/transfer.rs
new file mode 100644
index 0000000..51d31ce
--- /dev/null
+++ b/src/usb/transfer.rs
@@ -0,0 +1,287 @@
+//! USB transfer handling for the Geek szitman supercamera
+
+use crate::error::Result;
+use rusb::{Direction, TransferType};
+use std::time::Duration;
+use tracing::{error, trace};
+
+/// USB transfer error types
+#[derive(Debug, thiserror::Error)]
+pub enum UsbTransferError {
+    /// Transfer timeout
+    #[error("Transfer timeout after {:?}", duration)]
+    Timeout { duration: Duration },
+
+    /// Transfer failed
+    #[error("Transfer failed: {}", reason)]
+    Failed { reason: String },
+
+    /// Invalid endpoint
+    #[error("Invalid endpoint: {}", endpoint)]
+    InvalidEndpoint { endpoint: u8 },
+
+    /// Buffer too small
+    #[error("Buffer too small: required {}, provided {}", required, provided)]
+    BufferTooSmall { required: usize, provided: usize },
+}
+
+/// USB transfer configuration
+#[derive(Debug, Clone)]
+pub struct UsbTransferConfig {
+    pub timeout: Duration,
+    pub retry_count: u32,
+    pub buffer_size: usize,
+}
+
+impl Default for UsbTransferConfig {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_millis(1000),
+            retry_count: 3,
+            buffer_size: 0x1000,
+        }
+    }
+}
+
+/// USB transfer result
+#[derive(Debug)]
+pub struct UsbTransferResult {
+    pub bytes_transferred: usize,
+    pub endpoint: u8,
+    pub direction: Direction,
+    pub transfer_type: TransferType,
+}
+
+impl UsbTransferResult {
+    /// Create a new transfer result
+    pub fn new(
+        bytes_transferred: usize,
+        endpoint: u8,
+        direction: Direction,
+        transfer_type: TransferType,
+    ) -> Self {
+        Self {
+            bytes_transferred,
+            endpoint,
+            direction,
+            transfer_type,
+        }
+    }
+
+    /// Check if the transfer was successful
+    pub fn is_successful(&self) -> bool {
+        self.bytes_transferred > 0
+    }
+
+    /// Get the effective endpoint address
+    pub fn endpoint_address(&self) -> u8 {
+        match self.direction {
+            Direction::In => self.endpoint | 0x80,
+            Direction::Out => self.endpoint,
+        }
+    }
+}
+
+/// USB transfer statistics
+#[derive(Debug, Default)]
+pub struct UsbTransferStats {
+    pub total_transfers: u64,
+    pub successful_transfers: u64,
+    pub failed_transfers: u64,
+    pub total_bytes_transferred: u64,
+    pub average_transfer_size: f64,
+}
+
+impl UsbTransferStats {
+    /// Update statistics with a transfer result
+    pub fn update(&mut self, result: &UsbTransferResult) {
+        self.total_transfers += 1;
+
+        if result.is_successful() {
+            self.successful_transfers += 1;
+            self.total_bytes_transferred += result.bytes_transferred as u64;
+        } else {
+            self.failed_transfers += 1;
+        }
+
+        // Update average transfer size
+        if self.successful_transfers > 0 {
+            self.average_transfer_size =
+                self.total_bytes_transferred as f64 / self.successful_transfers as f64;
+        }
+    }
+
+    /// Get success rate as a percentage
+    pub fn success_rate(&self) -> f64 {
+        if self.total_transfers == 0 {
+            0.0
+        } else {
+            (self.successful_transfers as f64 / self.total_transfers as f64) * 100.0
+        }
+    }
+
+    /// Reset statistics
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+}
+
+/// USB transfer manager
+pub struct UsbTransferManager {
+    config: UsbTransferConfig,
+    stats: UsbTransferStats,
+}
+
+impl UsbTransferManager {
+    /// Create a new transfer manager
+    pub fn new(config: UsbTransferConfig) -> Self {
+        Self {
+            config,
+            stats: UsbTransferStats::default(),
+        }
+    }
+
+    /// Create a transfer manager with default configuration
+    pub fn new_default() -> Self {
+        Self::new(UsbTransferConfig::default())
+    }
+
+    /// Get current statistics
+    pub fn stats(&self) -> &UsbTransferStats {
+        &self.stats
+    }
+
+    /// Get mutable reference to statistics
+    pub fn stats_mut(&mut self) -> &mut UsbTransferStats {
+        &mut self.stats
+    }
+
+    /// Reset statistics
+    pub fn reset_stats(&mut self) {
+        self.stats.reset();
+    }
+
+    /// Validate endpoint configuration
+    pub fn validate_endpoint(
+        &self,
+        endpoint: u8,
+        direction: Direction,
+        transfer_type: TransferType,
+    ) -> Result<()> {
+        if endpoint > 15 {
+            return Err(UsbTransferError::InvalidEndpoint { endpoint }.into());
+        }
+
+        // Validate endpoint address based on direction
+        let endpoint_address = match direction {
+            Direction::In => endpoint | 0x80,
+            Direction::Out => endpoint,
+        };
+
+        trace!(
+            "Validated endpoint: 0x{:02X} ({:?}, {:?})",
+            endpoint_address,
+            direction,
+            transfer_type
+        );
+        Ok(())
+    }
+
+    /// Validate buffer size
+    pub fn validate_buffer(&self, buffer_size: usize) -> Result<()> {
+        if buffer_size < self.config.buffer_size {
+            return Err(UsbTransferError::BufferTooSmall {
+                required: self.config.buffer_size,
+                provided: buffer_size,
+            }
+            .into());
+        }
+        Ok(())
+    }
+
+    /// Get transfer configuration
+    pub fn config(&self) -> &UsbTransferConfig {
+        &self.config
+    }
+
+    /// Update transfer configuration
+    pub fn update_config(&mut self, config: UsbTransferConfig) {
+        self.config = config;
+    }
+}
+
+impl Default for UsbTransferManager {
+    fn default() -> Self {
+        Self::new_default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_usb_transfer_config_default() {
+        let config = UsbTransferConfig::default();
+        assert_eq!(config.timeout, Duration::from_millis(1000));
+        assert_eq!(config.retry_count, 3);
+        assert_eq!(config.buffer_size, 0x1000);
+    }
+
+    #[test]
+    fn test_usb_transfer_result() {
+        let result = UsbTransferResult::new(1024, 1, Direction::In, TransferType::Bulk);
+
+        assert_eq!(result.bytes_transferred, 1024);
+        assert_eq!(result.endpoint, 1);
+        assert!(result.is_successful());
+        assert_eq!(result.endpoint_address(), 0x81);
+    }
+
+    #[test]
+    fn test_usb_transfer_stats() {
+        let mut stats = UsbTransferStats::default();
+
+        let result = UsbTransferResult::new(1024, 1, Direction::In, TransferType::Bulk);
+        stats.update(&result);
+
+        assert_eq!(stats.total_transfers, 1);
+        assert_eq!(stats.successful_transfers, 1);
+        assert_eq!(stats.failed_transfers, 0);
+        assert_eq!(stats.total_bytes_transferred, 1024);
+        assert_eq!(stats.success_rate(), 100.0);
+    }
+
+    #[test]
+    fn test_usb_transfer_manager() {
+        let manager = UsbTransferManager::new_default();
+        assert_eq!(manager.config().timeout, Duration::from_millis(1000));
+        assert_eq!(manager.stats().total_transfers, 0);
+    }
+
+    #[test]
+    fn test_endpoint_validation() {
+        let manager = UsbTransferManager::new_default();
+
+        // Valid endpoint
+        assert!(manager
+            .validate_endpoint(1, Direction::In, TransferType::Bulk)
+            .is_ok());
+
+        // Invalid endpoint
+        assert!(manager
+            .validate_endpoint(16, Direction::In, TransferType::Bulk)
+            .is_err());
+    }
+
+    #[test]
+    fn test_buffer_validation() {
+        let manager = UsbTransferManager::new_default();
+
+        // Valid buffer size
+        assert!(manager.validate_buffer(0x1000).is_ok());
+
+        // Invalid buffer size
+        assert!(manager.validate_buffer(0x800).is_err());
+    }
+}