TheEmbeddedRust
/
usb-avr-lib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Compare commits

base: TheEmbeddedRust:c5788c5b2e1f930fa5de87cf7d14cb3de0d251c8
Branches Tags
TheEmbeddedRust:main
TheEmbeddedRust:1.0.0
..
compare: TheEmbeddedRust:8416bd0fa4fa0eccde2aa782c7d711a7489ff520
Branches Tags
TheEmbeddedRust:main
TheEmbeddedRust:1.0.0

No commits in common. "c5788c5b2e1f930fa5de87cf7d14cb3de0d251c8" and "8416bd0fa4fa0eccde2aa782c7d711a7489ff520" have entirely different histories.
c5788c5b2e ... 8416bd0fa4

2 changed files with 55 additions and 87 deletions
Show Stats Expand all files Collapse all files

45
src/lib.rs
View File

@ -133,24 +133,24 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
fn force_reset(&self) -> UsbResult<()> { fn force_reset(&self) -> UsbResult<()> {
free(|cs| { free(|cs| {
self.usb.borrow(cs).usbcon.modify(|_, w| w.usbe().set_bit()); let usbcon = &self.usb.borrow(cs).usbcon;
usbcon.modify(|_, w| w.usbe().set_bit());
}); });
delay_cycles(ONE_MS_16_MGHZ); delay_cycles(ONE_MS_16_MGHZ);
free(|cs| { free(|cs| {
self.usb.borrow(cs).usbcon.modify(|_, w| w.usbe().set_bit()); let usbcon = &self.usb.borrow(cs).usbcon;
usbcon.modify(|_, w| w.usbe().set_bit());
}); });
Ok(()) Ok(())
} }
fn is_stalled(&self, ep_addr: EndpointAddress) -> bool { fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
free(|cs| { free(|cs| match self.select_endpoint(cs, ep_addr.index()) {
if self.select_endpoint(cs, ep_addr.index()).is_ok() { Ok(_) => self.usb.borrow(cs).ueconx.read().stallrq().bit_is_set(),
return self.usb.borrow(cs).ueconx.read().stallrq().bit_is_set(); Err(_) => false,
}
false
}) })
} }
@ -162,7 +162,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
if usbint.vbusti().bit_is_set() { if usbint.vbusti().bit_is_set() {
usb.usbint usb.usbint
.write(|w| w.clear_interrupts().vbusti().clear_bit()); .write(|w| unsafe { w.bits(0x01) }.vbusti().clear_bit());
if usb.usbsta.read().vbus().bit_is_set() { if usb.usbsta.read().vbus().bit_is_set() {
return PollResult::Resume; return PollResult::Resume;
} else { } else {
@ -183,7 +183,8 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
if udint.sofi().bit_is_set() { if udint.sofi().bit_is_set() {
usb.udint.write(|w| w.clear_interrupts().sofi().clear_bit()); usb.udint
.write(|w| unsafe { w.bits(0x7d) }.sofi().clear_bit());
} }
if usb.usbcon.read().frzclk().bit_is_clear() { if usb.usbcon.read().frzclk().bit_is_clear() {
@ -225,8 +226,8 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
free(|cs| { free(|cs| {
let usb = self.usb.borrow(cs); let usb = self.usb.borrow(cs);
if let Err(usb_error) = self.select_endpoint(cs, ep_addr.index()) { if let Err(error) = self.select_endpoint(cs, ep_addr.index()) {
Err(usb_error) Err(error)
} else { } else {
let ep = &self.ep_table[ep_addr.index()]; let ep = &self.ep_table[ep_addr.index()];
@ -247,7 +248,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx.write(|w| { usb.ueintx.write(|w| {
w.clear_interrupts() unsafe { w.bits(0xdf) }
.rxouti() .rxouti()
.clear_bit() .clear_bit()
.rxstpi() .rxstpi()
@ -260,14 +261,14 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
return Err(UsbError::WouldBlock); return Err(UsbError::WouldBlock);
} }
usb.ueintx usb.ueintx
.write(|w| w.clear_interrupts().rxouti().clear_bit()); .write(|w| unsafe { w.bits(0xdf) }.rxouti().clear_bit());
let mut bytes_read = 0; let mut bytes_read = 0;
for data in buf { for slot in buf {
if usb.ueintx.read().rwal().bit_is_clear() { if usb.ueintx.read().rwal().bit_is_clear() {
break; break;
} }
*data = usb.uedatx.read().bits(); *slot = usb.uedatx.read().bits();
bytes_read += 1; bytes_read += 1;
} }
@ -276,7 +277,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx usb.ueintx
.write(|w| w.clear_interrupts().fifocon().clear_bit()); .write(|w| unsafe { w.bits(0xdf) }.fifocon().clear_bit());
Ok(bytes_read) Ok(bytes_read)
} }
} }
@ -296,7 +297,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
// Clear resume informations. // // Clear resume informations. //
usb.udint.write(|w| { usb.udint.write(|w| {
w.clear_interrupts() unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -324,7 +325,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
usb.usbcon.modify(|_, w| w.frzclk().clear_bit()); usb.usbcon.modify(|_, w| w.frzclk().clear_bit());
usb.udint.write(|w| { usb.udint.write(|w| {
w.clear_interrupts() unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -368,7 +369,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
let (usb, pll) = (self.usb.borrow(cs), self.pll.borrow(cs)); let (usb, pll) = (self.usb.borrow(cs), self.pll.borrow(cs));
usb.udint.write(|w| { usb.udint.write(|w| {
w.clear_interrupts() unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -415,13 +416,13 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx usb.ueintx
.write(|w| w.clear_interrupts().txini().clear_bit()); .write(|w| unsafe { w.bits(0xdf) }.txini().clear_bit());
} else { } else {
if usb.ueintx.read().txini().bit_is_clear() { if usb.ueintx.read().txini().bit_is_clear() {
return Err(UsbError::WouldBlock); return Err(UsbError::WouldBlock);
} }
usb.ueintx.write(|w| { usb.ueintx.write(|w| {
w.clear_interrupts() unsafe { w.bits(0xdf) }
.txini() .txini()
.clear_bit() .clear_bit()
.rxouti() .rxouti()
@ -437,7 +438,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx.write(|w| { usb.ueintx.write(|w| {
w.clear_interrupts() unsafe { w.bits(0xdf) }
.rxouti() .rxouti()
.clear_bit() .clear_bit()
.fifocon() .fifocon()

97
src/types/usb_device.rs
View File

@ -1,9 +1,6 @@
use core::cell::Cell; use core::cell::Cell;
use avr_device::{ use avr_device::{
atmega32u4::usb_device::{
udint::W as UDINTWriter, ueintx::W as UEINTXWriter, usbint::W as USBINTWriter,
},
atmega32u4::{PLL, USB_DEVICE}, atmega32u4::{PLL, USB_DEVICE},
interrupt::{CriticalSection, Mutex}, interrupt::{CriticalSection, Mutex},
}; };
@ -84,36 +81,6 @@ pub(crate) const DPRAM_SIZE: u16 = 832;
pub(crate) const ENDPOINTS_ALLOC_LAYOUT: [u16; MAX_ENDPOINTS] = [64, 256, 64, 64, 64, 64, 64]; pub(crate) const ENDPOINTS_ALLOC_LAYOUT: [u16; MAX_ENDPOINTS] = [64, 256, 64, 64, 64, 64, 64];
pub(crate) const ONE_MS_16_MGHZ: u32 = 16000; pub(crate) const ONE_MS_16_MGHZ: u32 = 16000;
const UDINT_BYTE: u8 = 0x7d;
const USBINT_BYTE: u8 = 0x01;
const UEINTX_BYTE: u8 = 0xdf;
const UENUM_MASK: u8 = 0b111;
pub(crate) trait InterruptCleaner {
fn clear_interrupts(&mut self) -> &mut Self;
}
impl InterruptCleaner for UDINTWriter {
#[inline]
fn clear_interrupts(&mut self) -> &mut Self {
unsafe { self.bits(UDINT_BYTE) }
}
}
impl InterruptCleaner for USBINTWriter {
#[inline]
fn clear_interrupts(&mut self) -> &mut Self {
unsafe { self.bits(USBINT_BYTE) }
}
}
impl InterruptCleaner for UEINTXWriter {
#[inline]
fn clear_interrupts(&mut self) -> &mut Self {
unsafe { self.bits(UEINTX_BYTE) }
}
}
impl<const L: usize> UsbDevice<L> { impl<const L: usize> UsbDevice<L> {
#[inline] #[inline]
pub(crate) fn get_size(&self, cs: CriticalSection<'_>) -> usize { pub(crate) fn get_size(&self, cs: CriticalSection<'_>) -> usize {
@ -147,8 +114,9 @@ impl<const L: usize> UsbDevice<L> {
endpoint_index: usize, endpoint_index: usize,
) -> Result<(), UsbError> { ) -> Result<(), UsbError> {
let usb = self.usb.borrow(cs); let usb = self.usb.borrow(cs);
let endpoint_index = endpoint_index as u8;
if endpoint_index >= MAX_ENDPOINTS { if endpoint_index >= 7 {
return Err(UsbError::InvalidEndpoint); return Err(UsbError::InvalidEndpoint);
} }
@ -156,9 +124,9 @@ impl<const L: usize> UsbDevice<L> {
return Err(UsbError::InvalidState); return Err(UsbError::InvalidState);
} }
usb.uenum.write(|w| w.bits(endpoint_index as u8)); usb.uenum.write(|w| w.bits(endpoint_index));
if usb.uenum.read().bits() & UENUM_MASK != endpoint_index as u8 { if usb.uenum.read().bits() & 7 /* 0b111 */ != endpoint_index {
return Err(UsbError::InvalidEndpoint); return Err(UsbError::InvalidEndpoint);
} }
@ -173,42 +141,41 @@ impl<const L: usize> UsbDevice<L> {
let usb = self.usb.borrow(cs); let usb = self.usb.borrow(cs);
let current_endpoint = self.ep_table[endpoint_index]; let current_endpoint = self.ep_table[endpoint_index];
let select_endpoint_result = self.select_endpoint(cs, endpoint_index); match self.select_endpoint(cs, endpoint_index) {
Ok(_) => {
// Enable endpoint. //
if select_endpoint_result.is_err() { usb.ueconx.modify(|_, w| w.epen().set_bit());
select_endpoint_result usb.uecfg1x.modify(|_, w| w.alloc().clear_bit());
} else {
// Enable endpoint. //
usb.ueconx.modify(|_, w| w.epen().set_bit()); // Set markered endpoint parameters to uecfg0x/1x register. //
usb.uecfg1x.modify(|_, w| w.alloc().clear_bit());
// Set markered endpoint parameters to uecfg0x/1x register. // usb.uecfg0x.modify(|_, w| {
w.epdir()
.bit(current_endpoint.ep_dir)
.eptype()
.bits(current_endpoint.ep_type)
});
usb.uecfg0x.modify(|_, w| { usb.uecfg1x.modify(|_, w| {
w.epdir() w.epbk()
.bit(current_endpoint.ep_dir) .bits(0)
.eptype() .epsize()
.bits(current_endpoint.ep_type) .bits(current_endpoint.size)
}); .alloc()
.set_bit()
});
usb.uecfg1x.modify(|_, w| { if usb.uesta0x.read().cfgok().bit_is_clear() {
w.epbk() Err(UsbError::EndpointMemoryOverflow)
.bits(0) } else {
.epsize() usb.ueienx
.bits(current_endpoint.size) .modify(|_, w| w.rxoute().set_bit().rxstpe().set_bit());
.alloc()
.set_bit()
});
if usb.uesta0x.read().cfgok().bit_is_clear() { Ok(())
Err(UsbError::EndpointMemoryOverflow) }
} else {
usb.ueienx
.modify(|_, w| w.rxoute().set_bit().rxstpe().set_bit());
select_endpoint_result
} }
Err(exception) => Err(exception),
} }
} }
} }