max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

usb: cleanup and simplify error handling.

Browse Source
This commit is contained in:
Dario Nieuwenhuis 2022-03-30 02:01:09 +02:00
parent 60d3d11197
commit a435d78cf7
5 changed files with 91 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
embassy-nrf/src/usb.rs
View File

@ -403,11 +403,9 @@ unsafe fn read_dma<T: Instance>(i: usize, buf: &mut [u8]) -> Result<usize, ReadE
Ok(size)
}
unsafe fn write_dma<T: Instance>(i: usize, buf: &[u8]) -> Result<(), WriteError> {
unsafe fn write_dma<T: Instance>(i: usize, buf: &[u8]) {
let regs = T::regs();
if buf.len() > 64 {
return Err(WriteError::BufferOverflow);
}
assert!(buf.len() <= 64);
let mut ram_buf: MaybeUninit<[u8; 64]> = MaybeUninit::uninit();
let ptr = if !slice_in_ram(buf) {
@ -441,8 +439,6 @@ unsafe fn write_dma<T: Instance>(i: usize, buf: &[u8]) -> Result<(), WriteError>
regs.tasks_startepin[i].write(|w| w.bits(1));
while regs.events_endepin[i].read().bits() == 0 {}
dma_end();
Ok(())
}
impl<'d, T: Instance> driver::EndpointOut for Endpoint<'d, T, Out> {
@ -497,6 +493,8 @@ impl<'d, T: Instance> driver::EndpointIn for Endpoint<'d, T, In> {
READY_ENDPOINTS.fetch_and(!(1 << i), Ordering::AcqRel);
unsafe { write_dma::<T>(i, buf) }
Ok(())
}
}
}
@ -535,9 +533,7 @@ impl<'d, T: Instance> ControlPipe<'d, T> {
async fn write(&mut self, buf: &[u8], last_chunk: bool) {
let regs = T::regs();
regs.events_ep0datadone.reset();
unsafe {
write_dma::<T>(0, buf).unwrap();
}
unsafe { write_dma::<T>(0, buf) }
regs.shorts
.modify(|_, w| w.ep0datadone_ep0status().bit(last_chunk));
@ -616,7 +612,7 @@ impl<'d, T: Instance> driver::ControlPipe for ControlPipe<'d, T> {
fn data_out<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::DataOutFuture<'a> {
async move {
let req = self.request.unwrap();
let req = unwrap!(self.request);
assert!(req.direction == UsbDirection::Out);
assert!(req.length > 0);
@ -649,7 +645,7 @@ impl<'d, T: Instance> driver::ControlPipe for ControlPipe<'d, T> {
debug!("control in accept {:x}", buf);
#[cfg(not(feature = "defmt"))]
debug!("control in accept {:x?}", buf);
let req = self.request.unwrap();
let req = unwrap!(self.request);
assert!(req.direction == UsbDirection::In);
let req_len = usize::from(req.length);

61
embassy-usb-serial/src/lib.rs
View File

@ -184,78 +184,57 @@ impl<'d, D: Driver<'d>> CdcAcmClass<'d, D> {
let read_ep = builder.alloc_bulk_endpoint_out(max_packet_size);
let write_ep = builder.alloc_bulk_endpoint_in(max_packet_size);
builder
.config_descriptor
.iad(
builder.config_descriptor.iad(
comm_if,
2,
USB_CLASS_CDC,
CDC_SUBCLASS_ACM,
CDC_PROTOCOL_NONE,
)
.unwrap();
builder
.config_descriptor
.interface(comm_if, USB_CLASS_CDC, CDC_SUBCLASS_ACM, CDC_PROTOCOL_NONE)
.unwrap();
builder
.config_descriptor
.write(
);
builder.config_descriptor.interface(
comm_if,
USB_CLASS_CDC,
CDC_SUBCLASS_ACM,
CDC_PROTOCOL_NONE,
);
builder.config_descriptor.write(
CS_INTERFACE,
&[
CDC_TYPE_HEADER, // bDescriptorSubtype
0x10,
0x01, // bcdCDC (1.10)
],
)
.unwrap();
builder
.config_descriptor
.write(
);
builder.config_descriptor.write(
CS_INTERFACE,
&[
CDC_TYPE_ACM, // bDescriptorSubtype
0x00, // bmCapabilities
],
)
.unwrap();
builder
.config_descriptor
.write(
);
builder.config_descriptor.write(
CS_INTERFACE,
&[
CDC_TYPE_UNION, // bDescriptorSubtype
comm_if.into(), // bControlInterface
data_if.into(), // bSubordinateInterface
],
)
.unwrap();
builder
.config_descriptor
.write(
);
builder.config_descriptor.write(
CS_INTERFACE,
&[
CDC_TYPE_CALL_MANAGEMENT, // bDescriptorSubtype
0x00, // bmCapabilities
data_if.into(), // bDataInterface
],
)
.unwrap();
builder.config_descriptor.endpoint(comm_ep.info()).unwrap();
);
builder.config_descriptor.endpoint(comm_ep.info());
builder
.config_descriptor
.interface(data_if, USB_CLASS_CDC_DATA, 0x00, 0x00)
.unwrap();
builder.config_descriptor.endpoint(write_ep.info()).unwrap();
builder.config_descriptor.endpoint(read_ep.info()).unwrap();
.interface(data_if, USB_CLASS_CDC_DATA, 0x00, 0x00);
builder.config_descriptor.endpoint(write_ep.info());
builder.config_descriptor.endpoint(read_ep.info());
CdcAcmClass {
comm_ep,

6
embassy-usb/src/builder.rs
View File

@ -168,9 +168,9 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
let mut config_descriptor = DescriptorWriter::new(config_descriptor_buf);
let mut bos_descriptor = BosWriter::new(DescriptorWriter::new(bos_descriptor_buf));
device_descriptor.device(&config).unwrap();
config_descriptor.configuration(&config).unwrap();
bos_descriptor.bos().unwrap();
device_descriptor.device(&config);
config_descriptor.configuration(&config);
bos_descriptor.bos();
UsbDeviceBuilder {
bus,

69
embassy-usb/src/descriptor.rs
View File

@ -1,13 +1,6 @@
use super::builder::Config;
use super::{types::*, CONFIGURATION_VALUE, DEFAULT_ALTERNATE_SETTING};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Error {
BufferFull,
InvalidState,
}
/// Standard descriptor types
#[allow(missing_docs)]
pub mod descriptor_type {
@ -69,11 +62,11 @@ impl<'a> DescriptorWriter<'a> {
}
/// Writes an arbitrary (usually class-specific) descriptor.
pub fn write(&mut self, descriptor_type: u8, descriptor: &[u8]) -> Result<(), Error> {
pub fn write(&mut self, descriptor_type: u8, descriptor: &[u8]) {
let length = descriptor.len();
if (self.position + 2 + length) > self.buf.len() || (length + 2) > 255 {
return Err(Error::BufferFull);
panic!("Descriptor buffer full");
}
self.buf[self.position] = (length + 2) as u8;
@ -84,11 +77,9 @@ impl<'a> DescriptorWriter<'a> {
self.buf[start..start + length].copy_from_slice(descriptor);
self.position = start + length;
Ok(())
}
pub(crate) fn device(&mut self, config: &Config) -> Result<(), Error> {
pub(crate) fn device(&mut self, config: &Config) {
self.write(
descriptor_type::DEVICE,
&[
@ -112,7 +103,7 @@ impl<'a> DescriptorWriter<'a> {
)
}
pub(crate) fn configuration(&mut self, config: &Config) -> Result<(), Error> {
pub(crate) fn configuration(&mut self, config: &Config) {
self.num_interfaces_mark = Some(self.position + 4);
self.write_iads = config.composite_with_iads;
@ -168,9 +159,9 @@ impl<'a> DescriptorWriter<'a> {
function_class: u8,
function_sub_class: u8,
function_protocol: u8,
) -> Result<(), Error> {
) {
if !self.write_iads {
return Ok(());
return;
}
self.write(
@ -183,9 +174,7 @@ impl<'a> DescriptorWriter<'a> {
function_protocol,
0,
],
)?;
Ok(())
);
}
/// Writes a interface descriptor.
@ -204,7 +193,7 @@ impl<'a> DescriptorWriter<'a> {
interface_class: u8,
interface_sub_class: u8,
interface_protocol: u8,
) -> Result<(), Error> {
) {
self.interface_alt(
number,
DEFAULT_ALTERNATE_SETTING,
@ -237,11 +226,13 @@ impl<'a> DescriptorWriter<'a> {
interface_sub_class: u8,
interface_protocol: u8,
interface_string: Option<StringIndex>,
) -> Result<(), Error> {
) {
if alternate_setting == DEFAULT_ALTERNATE_SETTING {
match self.num_interfaces_mark {
Some(mark) => self.buf[mark] += 1,
None => return Err(Error::InvalidState),
None => {
panic!("you can only call `interface/interface_alt` after `configuration`.")
}
};
}
@ -260,9 +251,7 @@ impl<'a> DescriptorWriter<'a> {
interface_protocol, // bInterfaceProtocol
str_index, // iInterface
],
)?;
Ok(())
);
}
/// Writes an endpoint descriptor.
@ -271,10 +260,10 @@ impl<'a> DescriptorWriter<'a> {
///
/// * `endpoint` - Endpoint previously allocated with
/// [`UsbDeviceBuilder`](crate::bus::UsbDeviceBuilder).
pub fn endpoint(&mut self, endpoint: &EndpointInfo) -> Result<(), Error> {
pub fn endpoint(&mut self, endpoint: &EndpointInfo) {
match self.num_endpoints_mark {
Some(mark) => self.buf[mark] += 1,
None => return Err(Error::InvalidState),
None => panic!("you can only call `endpoint` after `interface/interface_alt`."),
};
self.write(
@ -286,17 +275,15 @@ impl<'a> DescriptorWriter<'a> {
(endpoint.max_packet_size >> 8) as u8, // wMaxPacketSize
endpoint.interval, // bInterval
],
)?;
Ok(())
);
}
/// Writes a string descriptor.
pub(crate) fn string(&mut self, string: &str) -> Result<(), Error> {
pub(crate) fn string(&mut self, string: &str) {
let mut pos = self.position;
if pos + 2 > self.buf.len() {
return Err(Error::BufferFull);
panic!("Descriptor buffer full");
}
self.buf[pos] = 0; // length placeholder
@ -306,7 +293,7 @@ impl<'a> DescriptorWriter<'a> {
for c in string.encode_utf16() {
if pos >= self.buf.len() {
return Err(Error::BufferFull);
panic!("Descriptor buffer full");
}
self.buf[pos..pos + 2].copy_from_slice(&c.to_le_bytes());
@ -316,8 +303,6 @@ impl<'a> DescriptorWriter<'a> {
self.buf[self.position] = (pos - self.position) as u8;
self.position = pos;
Ok(())
}
}
@ -335,7 +320,7 @@ impl<'a> BosWriter<'a> {
}
}
pub(crate) fn bos(&mut self) -> Result<(), Error> {
pub(crate) fn bos(&mut self) {
self.num_caps_mark = Some(self.writer.position + 4);
self.writer.write(
descriptor_type::BOS,
@ -343,11 +328,9 @@ impl<'a> BosWriter<'a> {
0x00, 0x00, // wTotalLength
0x00, // bNumDeviceCaps
],
)?;
);
self.capability(capability_type::USB_2_0_EXTENSION, &[0; 4])?;
Ok(())
self.capability(capability_type::USB_2_0_EXTENSION, &[0; 4]);
}
/// Writes capability descriptor to a BOS
@ -356,17 +339,17 @@ impl<'a> BosWriter<'a> {
///
/// * `capability_type` - Type of a capability
/// * `data` - Binary data of the descriptor
pub fn capability(&mut self, capability_type: u8, data: &[u8]) -> Result<(), Error> {
pub fn capability(&mut self, capability_type: u8, data: &[u8]) {
match self.num_caps_mark {
Some(mark) => self.writer.buf[mark] += 1,
None => return Err(Error::InvalidState),
None => panic!("called `capability` not between `bos` and `end_bos`."),
}
let mut start = self.writer.position;
let blen = data.len();
if (start + blen + 3) > self.writer.buf.len() || (blen + 3) > 255 {
return Err(Error::BufferFull);
panic!("Descriptor buffer full");
}
self.writer.buf[start] = (blen + 3) as u8;
@ -376,8 +359,6 @@ impl<'a> BosWriter<'a> {
start += 3;
self.writer.buf[start..start + blen].copy_from_slice(data);
self.writer.position = start + blen;
Ok(())
}
pub(crate) fn end_bos(&mut self) {

12
embassy-usb/src/lib.rs
View File

@ -158,7 +158,13 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
// If the request has a data state, we must read it.
let data = if req.length > 0 {
let size = self.control.data_out(self.control_buf).await.unwrap();
let size = match self.control.data_out(self.control_buf).await {
Ok(size) => size,
Err(_) => {
warn!("usb: failed to read CONTROL OUT data stage.");
return;
}
};
&self.control_buf[0..size]
} else {
&[]
@ -311,7 +317,6 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
if index == 0 {
self.control_in_accept_writer(req, |w| {
w.write(descriptor_type::STRING, &lang_id::ENGLISH_US.to_le_bytes())
.unwrap();
})
.await
} else {
@ -328,8 +333,7 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
};
if let Some(s) = s {
self.control_in_accept_writer(req, |w| w.string(s).unwrap())
.await;
self.control_in_accept_writer(req, |w| w.string(s)).await;
} else {
self.control.reject()
}