Initial rusb version that actually compiles!

1 files changed, 65 insertions, 26 deletions

diff --git a/src/usb.rs b/src/usb.rs
index 2767d3d..92f99d1 100644
--- a/src/usb.rs
+++ b/src/usb.rs
@@ -1,7 +1,6 @@
-extern crate libusb;
+extern crate rusb;
 
-use libusb::DeviceHandle;
-use libusb::{Direction, RequestType, Recipient};
+use rusb::{DeviceHandle, Direction, GlobalContext, Recipient, RequestType};
 use std::time::Duration;
 
 // const BLOCK_DEMODB: u16 = 0;
@@ -24,8 +23,8 @@ const ADDR_SYS_DEMOD_CTL_1: u16 = 0x300b;
 
 const FIR_LENGTH: usize = 20;
 const FIR_DEFAULT: [u8; FIR_LENGTH] = [
-    0xca, 0xdc, 0xd7, 0xd8, 0xe0, 0xf2, 0x0e, 0x35, 0x06, 0x50,
-    0x9c, 0x0d, 0x71, 0x11, 0x14, 0x71, 0x74, 0x19, 0x41, 0xa5,
+    0xca, 0xdc, 0xd7, 0xd8, 0xe0, 0xf2, 0x0e, 0x35, 0x06, 0x50, 0x9c, 0x0d, 0x71, 0x11, 0x14, 0x71,
+    0x74, 0x19, 0x41, 0xa5,
 ];
 
 const DEF_RTL_XTAL_FREQ: u32 = 28800000;
@@ -34,19 +33,39 @@ const DEF_RTL_XTAL_FREQ: u32 = 28800000;
 
 const CTRL_TIMEOUT: Duration = Duration::from_millis(300);
 
-pub struct Usb<'a> {
-    handle: &'a DeviceHandle<'a>
+pub struct RtlSdrDeviceHandle {
+    handle: DeviceHandle<GlobalContext>,
+    iface_id: u8,
 }
 
-impl<'a> Usb<'a> {
-    pub fn new(handle: &'a DeviceHandle) -> Usb<'a> {
-        Usb {
-            handle
+impl RtlSdrDeviceHandle {
+    /// A wrapper around libusb's DeviceHandle that implements
+    /// various rtl-sdr specific methods
+    pub fn new(handle: DeviceHandle<GlobalContext>, iface_id: u8) -> RtlSdrDeviceHandle {
+        RtlSdrDeviceHandle { handle, iface_id }
+    }
+
+    pub fn detach_kernel_driver(&mut self) -> bool {
+        match self.handle.kernel_driver_active(self.iface_id) {
+            Ok(true) => {
+                self.handle.detach_kernel_driver(self.iface_id).ok();
+                true
+            }
+            _ => false,
         }
     }
 
+    pub fn attach_kernel_driver(&mut self) {
+        self.handle.attach_kernel_driver(self.iface_id).ok();
+    }
+
+    pub fn claim_interface(&mut self) {
+        self.handle.claim_interface(self.iface_id).unwrap()
+    }
+
     pub fn write_reg(&self, block: u16, addr: u16, val: u16, len: u8) -> usize {
-        let type_vendor_out = libusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
+        let type_vendor_out =
+            rusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
         let mut data: [u8; 2] = [0, 0];
         let index: u16 = (block << 8) | 0x10;
 
@@ -58,24 +77,31 @@ impl<'a> Usb<'a> {
         };
         data[1] = (val & 0xff) as u8;
 
-        match self.handle.write_control(type_vendor_out, 0, addr, index, &data, CTRL_TIMEOUT) {
+        match self
+            .handle
+            .write_control(type_vendor_out, 0, addr, index, &data, CTRL_TIMEOUT)
+        {
             Ok(n) => n,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 
     pub fn demod_read_reg(&self, page: u8, addr: u16, _len: u8) -> u16 {
-        let type_vendor_in = libusb::request_type(Direction::In, RequestType::Vendor, Recipient::Device);
+        let type_vendor_in =
+            rusb::request_type(Direction::In, RequestType::Vendor, Recipient::Device);
         let data: [u8; 2] = [0, 0];
         let index: u16 = page.into();
         let addr = (addr << 8) | 0x20;
-        let _res = self.handle.write_control(type_vendor_in, 0, addr, index, &data, CTRL_TIMEOUT);
+        let _res = self
+            .handle
+            .write_control(type_vendor_in, 0, addr, index, &data, CTRL_TIMEOUT);
         let reg: u16 = ((data[1] as u16) << 8) | (data[0] as u16);
         return reg;
     }
 
     pub fn demod_write_reg(&self, page: u8, addr: u16, val: u16, len: u8) -> u16 {
-        let type_vendor_out = libusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
+        let type_vendor_out =
+            rusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
         let mut data: [u8; 2] = [0, 0];
         let index: u16 = (0x10 | page).into();
         let addr = (addr << 8) | 0x20;
@@ -87,20 +113,33 @@ impl<'a> Usb<'a> {
         };
         data[1] = (val & 0xff) as u8;
 
-        let _res = self.handle.write_control(type_vendor_out, 0, addr, index, &data, CTRL_TIMEOUT);
+        let _res = self
+            .handle
+            .write_control(type_vendor_out, 0, addr, index, &data, CTRL_TIMEOUT);
         self.demod_read_reg(0x0a, 0x01, 1)
     }
 
     pub fn read_array(&self, block: u8, addr: u16, arr: &mut [u8], _len: u8) -> usize {
-        let type_vendor_in = libusb::request_type(Direction::In, RequestType::Vendor, Recipient::Device);
+        let type_vendor_in =
+            rusb::request_type(Direction::In, RequestType::Vendor, Recipient::Device);
         let index: u16 = (block as u16) << 8;
-        self.handle.read_control(type_vendor_in, 0, addr, index, arr, CTRL_TIMEOUT).unwrap()
+        self.handle
+            .read_control(type_vendor_in, 0, addr, index, arr, CTRL_TIMEOUT)
+            .unwrap()
     }
 
-    pub fn write_array(&self, block: u8, addr: u16, arr: &[u8], _len: u8) -> Result<usize, libusb::Error> {
-        let type_vendor_out = libusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
+    pub fn write_array(
+        &self,
+        block: u8,
+        addr: u16,
+        arr: &[u8],
+        _len: u8,
+    ) -> Result<usize, rusb::Error> {
+        let type_vendor_out =
+            rusb::request_type(Direction::Out, RequestType::Vendor, Recipient::Device);
         let index: u16 = ((block as u16) << 8) | 0x10;
-        self.handle.write_control(type_vendor_out, 0, addr, index, arr, CTRL_TIMEOUT)
+        self.handle
+            .write_control(type_vendor_out, 0, addr, index, arr, CTRL_TIMEOUT)
     }
 
     pub fn i2c_read_reg(&self, i2c_addr: u8, reg: u8) -> Result<u8, &str> {
@@ -112,15 +151,15 @@ impl<'a> Usb<'a> {
             Ok(_res) => {
                 self.read_array(BLOCK_IICB, addr, &mut data, 1);
                 Ok(data[0])
-            },
-            Err(_) => Err("Error")
+            }
+            Err(_) => Err("Error"),
         }
     }
 
     pub fn set_i2c_repeater(&self, on: bool) {
         let val = match on {
             true => 0x18,
-            false => 0x10
+            false => 0x10,
         };
         self.demod_write_reg(1, 0x01, val, 1);
     }