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

Compare commits

base: TheEmbeddedRust:5ac1a07c6bc821eb574de533b2373bcefdcbfc8b
Branches Tags
TheEmbeddedRust:main
..
compare: TheEmbeddedRust:4a90b9a6c87eef24c249908196f72ba2cde2b2b0
Branches Tags
TheEmbeddedRust:main

No commits in common. "5ac1a07c6bc821eb574de533b2373bcefdcbfc8b" and "4a90b9a6c87eef24c249908196f72ba2cde2b2b0" have entirely different histories.
5ac1a07c6b ... 4a90b9a6c8

1 changed files with 127 additions and 132 deletions
Show Stats Expand all files Collapse all files

259
src/lib.rs
View File

@ -14,10 +14,6 @@ pub use types::*;
use types::{DPRAM_SIZE, ENDPOINTS_ALLOC_LAYOUT, ONE_MS_16_MGHZ}; use types::{DPRAM_SIZE, ENDPOINTS_ALLOC_LAYOUT, ONE_MS_16_MGHZ};
const RESTRICT_RW_FLAG: u8 = !(1 << 5);
const USBINT_CLEAR: u8 = 1 << 0;
const UDINT_CLEAR: u8 = !(1 << 7 | 1 << 1);
impl<const L: usize> UsbBus for UsbDevice<L> { impl<const L: usize> UsbBus for UsbDevice<L> {
fn alloc_ep( fn alloc_ep(
&mut self, &mut self,
@ -28,58 +24,60 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
_interval: u8, _interval: u8,
) -> UsbResult<EndpointAddress> { ) -> UsbResult<EndpointAddress> {
// Handle first endpoint. // // Handle first endpoint. //
free(|_cs| {
if ep_addr == Some(EndpointAddress::from_parts(0, UsbDirection::In)) { if ep_addr == Some(EndpointAddress::from_parts(0, UsbDirection::In)) {
ep_addr.ok_or(UsbError::InvalidState) Ok(ep_addr.unwrap())
} else {
let address = match ep_addr {
// If current endpoint doesn't allocated, assign ep_addr to variable. //
Some(addr) if !self.ep_table[addr.index()].is_allocated => addr,
// If ep_aadr not provided, or current endpoint is allocated, try to find next free endpoint, otherwise return UsbError. //
_ => {
let index = self
.ep_table
.iter()
.enumerate()
.skip(1)
.find(|(index, ep)| {
!ep.is_allocated && max_packet_size <= ENDPOINTS_ALLOC_LAYOUT[*index]
})
.ok_or(UsbError::EndpointOverflow)?
.0;
EndpointAddress::from_parts(index, ep_dir)
}
};
// Select endpoint info by address index. //
let target_endpoint = &mut self.ep_table[address.index()];
// Get power of two number of endpoint size. //
let ep_size = max(8, max_packet_size.next_power_of_two());
// Endpoint allocation marker. //
if DPRAM_SIZE - self.dpram_already_used < ep_size {
Err(UsbError::EndpointMemoryOverflow)
} else { } else {
// Set endpoint parameters. // let address = match ep_addr {
// If current endpoint doesn't allocated, assign ep_addr to variable. //
Some(addr) if !self.ep_table[addr.index()].is_allocated => addr,
target_endpoint.set_dir(ep_dir); // If ep_aadr not provided, or current endpoint is allocated, try to find next free endpoint, otherwise return UsbError. //
target_endpoint.set_type(ep_type); _ => {
target_endpoint.set_size(ep_size)?; let index = self
.ep_table
.iter()
.enumerate()
.skip(1)
.find(|(index, ep)| {
!ep.is_allocated
&& max_packet_size <= ENDPOINTS_ALLOC_LAYOUT[*index]
})
.ok_or(UsbError::EndpointOverflow)?
.0;
// Add used dpram memory. // EndpointAddress::from_parts(index, ep_dir)
}
};
target_endpoint.is_allocated = true; // Select endpoint info by address index. //
self.dpram_already_used += ep_size;
Ok(address) let target_endpoint = &mut self.ep_table[address.index()];
// Get power of two number of endpoint size. //
let ep_size = max(8, max_packet_size.next_power_of_two());
// Endpoint allocation marker. //
if DPRAM_SIZE - self.dpram_already_used < ep_size {
Err(UsbError::EndpointMemoryOverflow)
} else {
// Set endpoint parameters. //
target_endpoint.set_dir(ep_dir);
target_endpoint.set_type(ep_type);
target_endpoint.set_size(ep_size)?;
// Add used dpram memory. //
target_endpoint.is_allocated = true;
self.dpram_already_used += ep_size;
Ok(address)
}
} }
} })
} }
fn enable(&mut self) { fn enable(&mut self) {
@ -118,7 +116,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
// Endpoint configuration // // Endpoint configuration //
self.allocated_endpoints().for_each(|(i, _ep)| { self.allocated_endpoints().for_each(|(i, _ep)| {
let _ = self.configure_endpoint(cs, i); self.configure_endpoint(cs, i).unwrap();
}); });
// Set high speed and attach the USB. // // Set high speed and attach the USB. //
@ -134,15 +132,17 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
fn force_reset(&self) -> UsbResult<()> { fn force_reset(&self) -> UsbResult<()> {
let set_detach = |bit| { free(|cs| {
free(|cs| { let usbcon = &self.usb.borrow(cs).usbcon;
self.usb.borrow(cs).udcon.modify(|_, w| w.detach().bit(bit)); usbcon.modify(|_, w| w.usbe().set_bit());
}); });
};
set_detach(true);
delay_cycles(ONE_MS_16_MGHZ); delay_cycles(ONE_MS_16_MGHZ);
set_detach(false);
free(|cs| {
let usbcon = &self.usb.borrow(cs).usbcon;
usbcon.modify(|_, w| w.usbe().set_bit());
});
Ok(()) Ok(())
} }
@ -162,8 +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| unsafe { w.bits(USBINT_CLEAR) }.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 {
@ -185,7 +184,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
if udint.sofi().bit_is_set() { if udint.sofi().bit_is_set() {
usb.udint usb.udint
.write(|w| unsafe { w.bits(UDINT_CLEAR) }.sofi().clear_bit()); .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() {
@ -227,62 +226,60 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
free(|cs| { free(|cs| {
let usb = self.usb.borrow(cs); let usb = self.usb.borrow(cs);
self.select_endpoint(cs, ep_addr.index())?; if let Err(error) = self.select_endpoint(cs, ep_addr.index()) {
Err(error)
let ep = &self.ep_table[ep_addr.index()];
if ep.ep_type == 0 {
let ueintx = usb.ueintx.read();
if ueintx.rxouti().bit_is_clear() && ueintx.rxstpi().bit_is_clear() {
return Err(UsbError::WouldBlock);
}
let buf_size = self.get_size(cs);
if buf.len() < buf_size {
return Err(UsbError::BufferOverflow);
}
for byte in &mut buf[..buf_size] {
*byte = usb.uedatx.read().bits();
}
usb.ueintx.write(|w| {
unsafe { w.bits(RESTRICT_RW_FLAG) }
.rxouti()
.clear_bit()
.rxstpi()
.clear_bit()
});
Ok(buf_size)
} else { } else {
if usb.ueintx.read().rxouti().bit_is_clear() { let ep = &self.ep_table[ep_addr.index()];
return Err(UsbError::WouldBlock);
}
usb.ueintx if ep.ep_type == 0 {
.write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.rxouti().clear_bit()); let ueintx = usb.ueintx.read();
let mut bytes_read = 0; if ueintx.rxouti().bit_is_clear() && ueintx.rxstpi().bit_is_clear() {
return Err(UsbError::WouldBlock);
for slot in buf {
if usb.ueintx.read().rwal().bit_is_clear() {
break;
} }
*slot = usb.uedatx.read().bits();
bytes_read += 1; let buf_size = self.get_size(cs);
if buf.len() < buf_size {
return Err(UsbError::BufferOverflow);
}
for byte in &mut buf[..buf_size] {
*byte = usb.uedatx.read().bits();
}
usb.ueintx.write(|w| {
unsafe { w.bits(0xdf) }
.rxouti()
.clear_bit()
.rxstpi()
.clear_bit()
});
Ok(buf_size)
} else {
if usb.ueintx.read().rxouti().bit_is_clear() {
return Err(UsbError::WouldBlock);
}
usb.ueintx
.write(|w| unsafe { w.bits(0xdf) }.rxouti().clear_bit());
let mut bytes_read = 0;
for slot in buf {
if usb.ueintx.read().rwal().bit_is_clear() {
break;
}
*slot = usb.uedatx.read().bits();
bytes_read += 1;
}
if usb.ueintx.read().rwal().bit_is_set() {
return Err(UsbError::BufferOverflow);
}
usb.ueintx
.write(|w| unsafe { w.bits(0xdf) }.fifocon().clear_bit());
Ok(bytes_read)
} }
if usb.ueintx.read().rwal().bit_is_set() {
return Err(UsbError::BufferOverflow);
}
usb.ueintx
.write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.fifocon().clear_bit());
Ok(bytes_read)
} }
}) })
} }
@ -294,13 +291,13 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
usb.udint.modify(|_, w| w.eorsti().clear_bit()); usb.udint.modify(|_, w| w.eorsti().clear_bit());
self.allocated_endpoints().for_each(|(i, _)| { self.allocated_endpoints().for_each(|(i, _)| {
let _ = self.configure_endpoint(cs, i); self.configure_endpoint(cs, i).unwrap();
}); });
// Clear resume informations. // // Clear resume informations. //
usb.udint.write(|w| { usb.udint.write(|w| {
unsafe { w.bits(UDINT_CLEAR) } unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -328,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| {
unsafe { w.bits(UDINT_CLEAR) } unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -372,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| {
unsafe { w.bits(UDINT_CLEAR) } unsafe { w.bits(0x7d) }
.wakeupi() .wakeupi()
.clear_bit() .clear_bit()
.suspi() .suspi()
@ -398,14 +395,14 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
free(|cs| { free(|cs| {
let usb = self.usb.borrow(cs); let usb = self.usb.borrow(cs);
self.select_endpoint(cs, ep_addr.index())?; if let Err(error) = self.select_endpoint(cs, ep_addr.index()) {
Err(error)
} else {
let ep = &self.ep_table[ep_addr.index()];
let ep = &self.ep_table[ep_addr.index()]; // Endpoint type confitions //
// Endpoint type confitions // if ep.ep_type == 0 {
match ep.ep_type {
0 => {
if usb.ueintx.read().txini().bit_is_clear() { if usb.ueintx.read().txini().bit_is_clear() {
return Err(UsbError::WouldBlock); return Err(UsbError::WouldBlock);
} }
@ -419,15 +416,13 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx usb.ueintx
.write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.txini().clear_bit()); .write(|w| unsafe { w.bits(0xdf) }.txini().clear_bit());
} } 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| {
unsafe { w.bits(RESTRICT_RW_FLAG) } unsafe { w.bits(0xdf) }
.txini() .txini()
.clear_bit() .clear_bit()
.rxouti() .rxouti()
@ -443,19 +438,19 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
} }
usb.ueintx.write(|w| { usb.ueintx.write(|w| {
unsafe { w.bits(RESTRICT_RW_FLAG) } unsafe { w.bits(0xdf) }
.rxouti() .rxouti()
.clear_bit() .clear_bit()
.fifocon() .fifocon()
.clear_bit() .clear_bit()
}); });
} }
};
let pending_ins = self.pending_ins.borrow(cs); let pending_ins = self.pending_ins.borrow(cs);
pending_ins.set(pending_ins.get() | 1 << ep_addr.index()); pending_ins.set(pending_ins.get() | 1 << ep_addr.index());
Ok(buf.len()) Ok(buf.len())
}
}) })
} }
} }