#[cfg(feature = "rusb")]
pub use self::inner::*;
#[cfg(feature = "rusb")]
mod inner {
use alloc::sync::Arc;
use alloc::vec::Vec;
use core::time::Duration;
use rusb::{Context, Direction, TransferType, UsbContext};
use crate::transport::runtime::Runtime;
use crate::transport::{ADB_CLASS, ADB_PROTOCOL, ADB_SUBCLASS};
use crate::uri::UsbSelector;
const NO_TIMEOUT: Duration = Duration::ZERO;
const CONTROL_TIMEOUT: Duration = Duration::from_secs(1);
pub struct UsbTransport<R> {
handle: Arc<rusb::DeviceHandle<Context>>,
ep_in: u8,
ep_out: u8,
runtime: core::marker::PhantomData<R>,
#[cfg_attr(not(any(feature = "tokio", feature = "smol")), allow(dead_code))]
buffer: Vec<u8>,
}
impl<R> Clone for UsbTransport<R> {
fn clone(&self) -> Self {
Self {
handle: self.handle.clone(),
ep_in: self.ep_in,
ep_out: self.ep_out,
runtime: core::marker::PhantomData,
buffer: Vec::new(),
}
}
}
impl<R: Runtime> UsbTransport<R> {
pub fn new(
handle: rusb::DeviceHandle<Context>,
iface: u8,
) -> Result<Self, UsbConnectError> {
let (_, ep_in, ep_out) = find_interface_endpoints(&handle.device(), |desc| {
desc.interface_number() == iface
})?
.ok_or(UsbConnectError::NoBulkEndpoints)?;
Ok(Self::from_parts(handle, ep_in, ep_out))
}
fn from_parts(handle: rusb::DeviceHandle<Context>, ep_in: u8, ep_out: u8) -> Self {
Self {
handle: Arc::new(handle),
ep_in,
ep_out,
runtime: core::marker::PhantomData,
buffer: Vec::new(),
}
}
pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, UsbError> {
let handle = self.handle.clone();
let ep = self.ep_in;
let mut buffer = core::mem::take(&mut self.buffer);
buffer.resize(buf.len(), 0);
let (n, buffer) = R::run_blocking(move || {
let n = bulk_read(&handle, ep, &mut buffer)?;
Ok::<_, UsbError>((n, buffer))
})
.await
.map_err(|_| UsbError::BlockingTaskFailed)??;
buf[..n].copy_from_slice(&buffer[..n]);
self.buffer = buffer;
Ok(n)
}
pub async fn write(&mut self, buf: &[u8]) -> Result<usize, UsbError> {
let handle = self.handle.clone();
let ep = self.ep_out;
let mut buffer = core::mem::take(&mut self.buffer);
buffer.clear();
buffer.extend_from_slice(buf);
let (n, buffer) = R::run_blocking(move || {
let n = bulk_write(&handle, ep, &buffer)?;
Ok::<_, UsbError>((n, buffer))
})
.await
.map_err(|_| UsbError::BlockingTaskFailed)??;
self.buffer = buffer;
Ok(n)
}
}
fn bulk_read(
handle: &rusb::DeviceHandle<Context>,
ep: u8,
buf: &mut [u8],
) -> Result<usize, UsbError> {
if buf.is_empty() {
return Ok(0);
}
handle
.read_bulk(ep, buf, NO_TIMEOUT)
.map_err(UsbError::Transfer)
}
fn bulk_write(
handle: &rusb::DeviceHandle<Context>,
ep: u8,
buf: &[u8],
) -> Result<usize, UsbError> {
if buf.is_empty() {
return Ok(0);
}
handle
.write_bulk(ep, buf, NO_TIMEOUT)
.map_err(UsbError::Transfer)
}
impl<R> embedded_io::ErrorType for UsbTransport<R> {
type Error = UsbError;
}
impl<R: Runtime> embedded_io_async::Read for UsbTransport<R> {
async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
UsbTransport::read(self, buf).await
}
}
impl<R: Runtime> embedded_io_async::Write for UsbTransport<R> {
async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
UsbTransport::write(self, buf).await
}
async fn flush(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
impl<R> crate::transport::ReadCancelSafety for UsbTransport<R> {
fn read_cancel_safe(&self) -> bool {
false
}
}
impl<R: Runtime> crate::transport::Splittable for UsbTransport<R> {
type ReadHalf = UsbTransport<R>;
type WriteHalf = UsbTransport<R>;
fn split(self) -> Result<(Self::ReadHalf, Self::WriteHalf), UsbError> {
let clone = self.clone();
Ok((self, clone))
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum UsbError {
Transfer(rusb::Error),
BlockingTaskFailed,
}
impl core::fmt::Display for UsbError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Transfer(e) => write!(f, "usb: {e}"),
Self::BlockingTaskFailed => f.write_str("usb: blocking task failed"),
}
}
}
impl core::error::Error for UsbError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Transfer(e) => Some(e),
Self::BlockingTaskFailed => None,
}
}
}
impl embedded_io::Error for UsbError {
fn kind(&self) -> embedded_io::ErrorKind {
embedded_io::ErrorKind::Other
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum UsbConnectError {
Context(rusb::Error),
Enumerate(rusb::Error),
NotFound,
NoAdbInterface,
Open(rusb::Error),
Descriptor(rusb::Error),
SerialRead(rusb::Error),
Claim(rusb::Error),
NoBulkEndpoints,
}
impl core::fmt::Display for UsbConnectError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Context(e) => write!(f, "libusb init: {e}"),
Self::Enumerate(e) => write!(f, "enumerate: {e}"),
Self::NotFound => f.write_str("device not found"),
Self::NoAdbInterface => f.write_str("no adb interface on device"),
Self::Open(e) => write!(f, "open: {e}"),
Self::Descriptor(e) => write!(f, "descriptor: {e}"),
Self::SerialRead(e) => write!(f, "serial read: {e}"),
Self::Claim(e) => write!(f, "claim: {e}"),
Self::NoBulkEndpoints => f.write_str("interface has no bulk endpoints"),
}
}
}
pub struct Rusb;
impl<R: Runtime> crate::transport::UsbBackend<R> for Rusb {
type Transport = UsbTransport<R>;
type Error = UsbConnectError;
fn connect_by_selector(
selector: UsbSelector<'_>,
) -> Result<UsbTransport<R>, UsbConnectError> {
connect_by_selector(selector)
}
}
pub fn connect_by_selector<R: Runtime>(
selector: UsbSelector<'_>,
) -> Result<UsbTransport<R>, UsbConnectError> {
let context = Context::new().map_err(UsbConnectError::Context)?;
let devices = context.devices().map_err(UsbConnectError::Enumerate)?;
let hard_fail = matches!(selector, UsbSelector::VidPid { .. });
let mut first_err: Option<UsbConnectError> = None;
for device in devices.iter() {
match try_open_device(device, selector, hard_fail) {
Ok(Some(t)) => return Ok(t),
Ok(None) => continue,
Err(e) if hard_fail => return Err(e),
Err(e) => {
first_err.get_or_insert(e);
}
}
}
Err(first_err.unwrap_or(UsbConnectError::NotFound))
}
fn try_open_device<R: Runtime>(
device: rusb::Device<Context>,
selector: UsbSelector<'_>,
hard_fail: bool,
) -> Result<Option<UsbTransport<R>>, UsbConnectError> {
let desc = device
.device_descriptor()
.map_err(UsbConnectError::Descriptor)?;
if let UsbSelector::VidPid { vid, pid } = selector {
if desc.vendor_id() != vid || desc.product_id() != pid {
return Ok(None);
}
}
let (iface_num, ep_in, ep_out) = match find_interface_endpoints(&device, |desc| {
desc.class_code() == ADB_CLASS
&& desc.sub_class_code() == ADB_SUBCLASS
&& desc.protocol_code() == ADB_PROTOCOL
})? {
Some(t) => t,
None if hard_fail => return Err(UsbConnectError::NoAdbInterface),
None => return Ok(None),
};
let handle = device.open().map_err(UsbConnectError::Open)?;
if let UsbSelector::Serial(wanted) = selector {
let serial = read_serial(&handle, &desc).map_err(UsbConnectError::SerialRead)?;
if serial.as_deref() != Some(wanted) {
return Ok(None);
}
}
handle
.claim_interface(iface_num)
.map_err(UsbConnectError::Claim)?;
Ok(Some(UsbTransport::from_parts(handle, ep_in, ep_out)))
}
fn find_interface_endpoints(
device: &rusb::Device<Context>,
pick: impl Fn(&rusb::InterfaceDescriptor) -> bool,
) -> Result<Option<(u8, u8, u8)>, UsbConnectError> {
let config = device
.active_config_descriptor()
.map_err(UsbConnectError::Descriptor)?;
let mut any_match = false;
for iface in config.interfaces() {
for desc in iface.descriptors() {
if !pick(&desc) {
continue;
}
any_match = true;
let mut ep_in = None;
let mut ep_out = None;
for ep in desc.endpoint_descriptors() {
if ep.transfer_type() == TransferType::Bulk {
match ep.direction() {
Direction::In => ep_in = Some(ep.address()),
Direction::Out => ep_out = Some(ep.address()),
}
}
}
if let (Some(r), Some(w)) = (ep_in, ep_out) {
return Ok(Some((iface.number(), r, w)));
}
}
}
if any_match {
Err(UsbConnectError::NoBulkEndpoints)
} else {
Ok(None)
}
}
fn read_serial(
handle: &rusb::DeviceHandle<Context>,
desc: &rusb::DeviceDescriptor,
) -> Result<Option<alloc::string::String>, rusb::Error> {
let langs = handle.read_languages(CONTROL_TIMEOUT)?;
let Some(&lang) = langs.first() else {
return Ok(None);
};
handle
.read_serial_number_string(lang, desc, CONTROL_TIMEOUT)
.map(Some)
}
}
#[cfg(all(test, feature = "rusb"))]
mod tests {
use crate::transport::runtime::Inline;
use crate::transport::rusb::Rusb;
use crate::transport::UsbBackend;
#[test]
fn the_backend_serves_every_runtime() {
fn takes_backend<R, B: UsbBackend<R>>() {}
takes_backend::<Inline, Rusb>();
#[cfg(feature = "tokio")]
takes_backend::<crate::transport::runtime::Tokio, Rusb>();
#[cfg(feature = "smol")]
takes_backend::<crate::transport::runtime::Smol, Rusb>();
}
#[cfg(feature = "tokio")]
#[test]
fn transports_of_different_runtimes_are_different_types() {
use crate::transport::rusb::UsbTransport;
use core::any::TypeId;
assert_ne!(
TypeId::of::<UsbTransport<Inline>>(),
TypeId::of::<UsbTransport<crate::transport::runtime::Tokio>>(),
);
}
}