1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
use std::marker::PhantomData;
use std::mem;
use libusb::*;
use context::Context;
use device_handle::{self, DeviceHandle};
use device_descriptor::{self, DeviceDescriptor};
use config_descriptor::{self, ConfigDescriptor};
use fields::{self, Speed};
pub struct Device<'a> {
context: PhantomData<&'a Context>,
device: *mut libusb_device,
}
impl<'a> Drop for Device<'a> {
fn drop(&mut self) {
unsafe {
libusb_unref_device(self.device);
}
}
}
unsafe impl<'a> Send for Device<'a> {}
unsafe impl<'a> Sync for Device<'a> {}
impl<'a> Device<'a> {
pub fn device_descriptor(&self) -> ::Result<DeviceDescriptor> {
let mut descriptor: libusb_device_descriptor = unsafe { mem::uninitialized() };
try_unsafe!(libusb_get_device_descriptor(self.device, &mut descriptor));
Ok(device_descriptor::from_libusb(descriptor))
}
pub fn config_descriptor(&self, config_index: u8) -> ::Result<ConfigDescriptor> {
let mut config: *const libusb_config_descriptor = unsafe { mem::uninitialized() };
try_unsafe!(libusb_get_config_descriptor(self.device, config_index, &mut config));
Ok(unsafe { config_descriptor::from_libusb(config) })
}
pub fn active_config_descriptor(&self) -> ::Result<ConfigDescriptor> {
let mut config: *const libusb_config_descriptor = unsafe { mem::uninitialized() };
try_unsafe!(libusb_get_active_config_descriptor(self.device, &mut config));
Ok(unsafe { config_descriptor::from_libusb(config) })
}
pub fn bus_number(&self) -> u8 {
unsafe {
libusb_get_bus_number(self.device)
}
}
pub fn address(&self) -> u8 {
unsafe {
libusb_get_device_address(self.device)
}
}
pub fn speed(&self) -> Speed {
fields::speed_from_libusb(unsafe {
libusb_get_device_speed(self.device)
})
}
pub fn open(&self) -> ::Result<DeviceHandle<'a>> {
let mut handle: *mut libusb_device_handle = unsafe { mem::uninitialized() };
try_unsafe!(libusb_open(self.device, &mut handle));
Ok(unsafe { device_handle::from_libusb(self.context, handle) })
}
}
#[doc(hidden)]
pub unsafe fn from_libusb<'a>(context: PhantomData<&'a Context>, device: *mut libusb_device) -> Device<'a> {
libusb_ref_device(device);
Device {
context: context,
device: device,
}
}