Merge pull request 'Merge first (maybe) stable version usb-avr for atmega32u4/atmega16u4' (#1) from test into main

Reviewed-on: https://gitea.doryan04.ru/TheEmbeddedRust/usb-avr-lib/pulls/1

Cargo.toml

@@ -11,7 +11,7 @@ embedded-hal = "1.0"
 usb-device = "0.3.2"
 
 [dependencies.avr-device]
-version = "0.8.1"
+version = "0.5.4"
 features = ["atmega32u4"]
 
 # The latest releases of `proc-macro2` do not support the rust toolchain that

rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "nightly-2024-06-13"
+components = [ "rust-src" ]
+profile = "default"

src/lib.rs

@@ -6,7 +6,7 @@ use avr_device::{asm::delay_cycles, interrupt::free};
 use usb_device::{
     bus::{PollResult, UsbBus},
     endpoint::{EndpointAddress, EndpointType},
-    Result as UsbResult, UsbDirection as Dir, UsbError,
+    Result as UsbResult, UsbDirection, UsbError,
 };
 
 mod types;
@@ -21,49 +21,65 @@ const UDINT_CLEAR: u8 = !(1 << 7 | 1 << 1);
 impl<const L: usize> UsbBus for UsbDevice<L> {
     fn alloc_ep(
         &mut self,
-        ep_dir: Dir,
+        ep_dir: UsbDirection,
         ep_addr: Option<EndpointAddress>,
         ep_type: EndpointType,
         max_packet_size: u16,
         _interval: u8,
     ) -> UsbResult<EndpointAddress> {
-        let target_ep_index = match ep_addr {
-            Some(ep) if ep.index() == 0 && ep_dir == Dir::In => {
-                return ep_addr.ok_or(UsbError::InvalidState);
-            } // TODO: rewrite to bind pattern with @
-            Some(ep) if !self.ep_table[ep.index()].is_allocated => Ok(ep),
-            _ => {
-                let index = self
-                    .ep_table
-                    .iter()
-                    .enumerate()
-                    .skip(1)
-                    .find(|(index, ep)| {
-                        !ep.is_allocated && max_packet_size <= ENDPOINTS_ALLOC_LAYOUT[*index]
-                    })
-                    .map(|(index, _)| index)
-                    .ok_or(UsbError::EndpointOverflow)?;
+        // Handle first endpoint. //
 
-                Ok(EndpointAddress::from_parts(index, ep_dir))
+        if ep_addr == Some(EndpointAddress::from_parts(0, UsbDirection::In)) {
+            ep_addr.ok_or(UsbError::InvalidState)
+        } 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 {
+                // 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)
             }
-        }?;
-
-        let ep_size = max(8, max_packet_size.next_power_of_two());
-
-        if DPRAM_SIZE - self.dpram_already_used < ep_size {
-            return Err(UsbError::EndpointMemoryOverflow);
         }
-
-        let target_ep = &mut self.ep_table[target_ep_index.index()];
-
-        target_ep.set_dir(ep_dir);
-        target_ep.set_type(ep_type);
-        target_ep.set_size(ep_size)?;
-
-        target_ep.is_allocated = true;
-        self.dpram_already_used += ep_size;
-
-        Ok(target_ep_index)
     }
 
     fn enable(&mut self) {
@@ -72,31 +88,31 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Enable USB pads regulators. //
 
-            usb.uhwcon().modify(|_, w| w.uvrege().set_bit());
+            usb.uhwcon.modify(|_, w| w.uvrege().set_bit());
 
             // PLL configuration //
 
-            pll.pllcsr().write(|w| w.pindiv().set_bit());
+            pll.pllcsr.write(|w| w.pindiv().set_bit());
 
-            pll.pllfrq()
-                .write(|w| w.pdiv().mhz96().plltm().factor_1().pllusb().set_bit());
+            pll.pllfrq
+                .write(|w| w.pdiv().mhz96().plltm().factor_15().pllusb().set_bit());
 
             // Enable PLL //
 
-            pll.pllcsr().modify(|_, w| w.plle().set_bit());
+            pll.pllcsr.modify(|_, w| w.plle().set_bit());
 
             // Check PLL lock //
 
-            while pll.pllcsr().read().plock().bit_is_clear() {}
+            while pll.pllcsr.read().plock().bit_is_clear() {}
 
             // Enable USB interface. //
 
-            usb.usbcon()
+            usb.usbcon
                 .modify(|_, w| w.usbe().set_bit().otgpade().set_bit());
 
             // Unfreeze clock. //
 
-            usb.usbcon()
+            usb.usbcon
                 .modify(|_, w| w.frzclk().clear_bit().vbuste().set_bit());
 
             // Endpoint configuration //
@@ -107,12 +123,12 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Set high speed and attach the USB. //
 
-            usb.udcon()
+            usb.udcon
                 .modify(|_, w| w.detach().clear_bit().lsm().clear_bit());
 
             // Interrupts. //
 
-            usb.udien()
+            usb.udien
                 .modify(|_, w| w.eorste().set_bit().sofe().set_bit());
         })
     }
@@ -120,10 +136,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
     fn force_reset(&self) -> UsbResult<()> {
         let set_detach = |bit| {
             free(|cs| {
-                self.usb
-                    .borrow(cs)
-                    .udcon()
-                    .modify(|_, w| w.detach().bit(bit));
+                self.usb.borrow(cs).udcon.modify(|_, w| w.detach().bit(bit));
             });
         };
 
@@ -136,7 +149,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
     fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
         free(|cs| match self.select_endpoint(cs, ep_addr.index()) {
-            Ok(_) => self.usb.borrow(cs).ueconx().read().stallrq().bit_is_set(),
+            Ok(_) => self.usb.borrow(cs).ueconx.read().stallrq().bit_is_set(),
             Err(_) => false,
         })
     }
@@ -145,14 +158,13 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|cs| {
             let usb = self.usb.borrow(cs);
 
-            let (udint, udien, usbint) =
-                (usb.udint().read(), usb.udien().read(), usb.usbint().read());
+            let (udint, udien, usbint) = (usb.udint.read(), usb.udien.read(), usb.usbint.read());
 
             if usbint.vbusti().bit_is_set() {
-                usb.usbint()
+                usb.usbint
                     .write(|w| unsafe { w.bits(USBINT_CLEAR) }.vbusti().clear_bit());
 
-                if usb.usbsta().read().vbus().bit_is_set() {
+                if usb.usbsta.read().vbus().bit_is_set() {
                     return PollResult::Resume;
                 } else {
                     return PollResult::Suspend;
@@ -172,21 +184,20 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             }
 
             if udint.sofi().bit_is_set() {
-                usb.udint()
+                usb.udint
                     .write(|w| unsafe { w.bits(UDINT_CLEAR) }.sofi().clear_bit());
             }
 
-            if usb.usbcon().read().frzclk().bit_is_clear() {
+            if usb.usbcon.read().frzclk().bit_is_clear() {
                 let (mut ep_out, mut ep_in_complete, mut ep_setup) = (0u16, 0u16, 0u16);
                 let pending_ins = self.pending_ins.borrow(cs);
 
-                for ep_index in 0usize..self.ep_table.len() {
-                    if !self.ep_table[ep_index].is_allocated {
-                        continue;
-                    }
+                for (ep_index, _ep) in self.allocated_endpoints() {
+                    if self.select_endpoint(cs, ep_index).is_err() {
+                        break;
+                    } else {
+                        let ueintx = usb.ueintx.read();
 
-                    if self.select_endpoint(cs, ep_index).is_ok() {
-                        let ueintx = usb.ueintx().read();
                         if ueintx.rxouti().bit_is_set() {
                             ep_out |= 1 << ep_index;
                         }
@@ -200,7 +211,6 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                         }
                     }
                 }
-
                 if ep_out | ep_in_complete | ep_setup != 0 {
                     return PollResult::Data {
                         ep_out,
@@ -222,7 +232,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             let ep = &self.ep_table[ep_addr.index()];
 
             if ep.ep_type == 0 {
-                let ueintx = usb.ueintx().read();
+                let ueintx = usb.ueintx.read();
 
                 if ueintx.rxouti().bit_is_clear() && ueintx.rxstpi().bit_is_clear() {
                     return Err(UsbError::WouldBlock);
@@ -235,10 +245,10 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 }
 
                 for byte in &mut buf[..buf_size] {
-                    *byte = usb.uedatx().read().bits();
+                    *byte = usb.uedatx.read().bits();
                 }
 
-                usb.ueintx().write(|w| {
+                usb.ueintx.write(|w| {
                     unsafe { w.bits(RESTRICT_RW_FLAG) }
                         .rxouti()
                         .clear_bit()
@@ -248,28 +258,28 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
                 Ok(buf_size)
             } else {
-                if usb.ueintx().read().rxouti().bit_is_clear() {
+                if usb.ueintx.read().rxouti().bit_is_clear() {
                     return Err(UsbError::WouldBlock);
                 }
 
-                usb.ueintx()
+                usb.ueintx
                     .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.rxouti().clear_bit());
 
                 let mut bytes_read = 0;
 
                 for slot in buf {
-                    if usb.ueintx().read().rwal().bit_is_clear() {
+                    if usb.ueintx.read().rwal().bit_is_clear() {
                         break;
                     }
-                    *slot = usb.uedatx().read().bits();
+                    *slot = usb.uedatx.read().bits();
                     bytes_read += 1;
                 }
 
-                if usb.ueintx().read().rwal().bit_is_set() {
+                if usb.ueintx.read().rwal().bit_is_set() {
                     return Err(UsbError::BufferOverflow);
                 }
 
-                usb.ueintx()
+                usb.ueintx
                     .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.fifocon().clear_bit());
 
                 Ok(bytes_read)
@@ -281,7 +291,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|cs| {
             let usb = self.usb.borrow(cs);
 
-            usb.udint().modify(|_, w| w.eorsti().clear_bit());
+            usb.udint.modify(|_, w| w.eorsti().clear_bit());
 
             self.allocated_endpoints().for_each(|(i, _)| {
                 let _ = self.configure_endpoint(cs, i);
@@ -289,7 +299,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Clear resume informations. //
 
-            usb.udint().write(|w| {
+            usb.udint.write(|w| {
                 unsafe { w.bits(UDINT_CLEAR) }
                     .wakeupi()
                     .clear_bit()
@@ -297,7 +307,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                     .clear_bit()
             });
 
-            usb.udien()
+            usb.udien
                 .modify(|_, w| w.wakeupe().clear_bit().suspe().set_bit());
         })
     }
@@ -308,16 +318,16 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // PLL enable //
 
-            pll.pllcsr()
+            pll.pllcsr
                 .modify(|_, w| w.pindiv().set_bit().plle().set_bit());
 
-            while pll.pllcsr().read().plock().bit_is_clear() {}
+            while pll.pllcsr.read().plock().bit_is_clear() {}
 
             // Resuming //
 
-            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) }
                     .wakeupi()
                     .clear_bit()
@@ -325,7 +335,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                     .clear_bit()
             });
 
-            usb.udien()
+            usb.udien
                 .modify(|_, w| w.wakeupe().clear_bit().suspe().set_bit());
         })
     }
@@ -336,14 +346,14 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Set address. //
 
-            usb.udaddr().modify(|_, w| w.uadd().set(addr));
+            usb.udaddr.modify(|_, w| w.uadd().bits(addr));
 
             // Note: ADDEN and UADD shall not be written at the same time.
             // (written in atmega32u4/16u4 docs)
 
             // Enable. //
 
-            usb.udaddr().modify(|_, w| w.adden().set_bit());
+            usb.udaddr.modify(|_, w| w.adden().set_bit());
         });
     }
 
@@ -351,7 +361,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|cs| {
             let usb = self.usb.borrow(cs);
             if self.select_endpoint(cs, ep_addr.index()).is_ok() {
-                usb.ueconx()
+                usb.ueconx
                     .modify(|_, w| w.stallrq().bit(stalled).stallrqc().bit(!stalled));
             }
         });
@@ -361,7 +371,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|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) }
                     .wakeupi()
                     .clear_bit()
@@ -371,22 +381,22 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Suspend. //
 
-            usb.udien()
+            usb.udien
                 .modify(|_, w| w.wakeupe().set_bit().suspe().clear_bit());
 
             // Freeze clock. //
 
-            usb.usbcon().modify(|_, w| w.frzclk().set_bit());
+            usb.usbcon.modify(|_, w| w.frzclk().set_bit());
 
             // Disable PLL. //
 
-            pll.pllcsr().modify(|_, w| w.plle().clear_bit());
+            pll.pllcsr.modify(|_, w| w.plle().clear_bit());
         })
     }
 
     fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> UsbResult<usize> {
         free(|cs| {
-            let (usb, pending_ins) = (self.usb.borrow(cs), self.pending_ins.borrow(cs));
+            let usb = self.usb.borrow(cs);
 
             self.select_endpoint(cs, ep_addr.index())?;
 
@@ -394,25 +404,29 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             // Endpoint type confitions //
 
-            if usb.ueintx().read().txini().bit_is_clear() {
-                return Err(UsbError::WouldBlock);
-            }
-
             match ep.ep_type {
                 0 => {
+                    if usb.ueintx.read().txini().bit_is_clear() {
+                        return Err(UsbError::WouldBlock);
+                    }
+
                     if buf.len() > ep.get_size() {
                         return Err(UsbError::BufferOverflow);
                     }
 
                     for &byte in buf {
-                        usb.uedatx().write(|w| w.set(byte));
+                        usb.uedatx.write(|w| w.bits(byte));
                     }
 
-                    usb.ueintx()
+                    usb.ueintx
                         .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.txini().clear_bit());
                 }
                 _ => {
-                    usb.ueintx().write(|w| {
+                    if usb.ueintx.read().txini().bit_is_clear() {
+                        return Err(UsbError::WouldBlock);
+                    }
+
+                    usb.ueintx.write(|w| {
                         unsafe { w.bits(RESTRICT_RW_FLAG) }
                             .txini()
                             .clear_bit()
@@ -421,14 +435,14 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                     });
 
                     for &byte in buf {
-                        if usb.ueintx().read().rwal().bit_is_set() {
-                            usb.uedatx().write(|w| w.set(byte));
+                        if usb.ueintx.read().rwal().bit_is_set() {
+                            usb.uedatx.write(|w| w.bits(byte));
                         } else {
                             return Err(UsbError::BufferOverflow);
                         }
                     }
 
-                    usb.ueintx().write(|w| {
+                    usb.ueintx.write(|w| {
                         unsafe { w.bits(RESTRICT_RW_FLAG) }
                             .rxouti()
                             .clear_bit()
@@ -438,6 +452,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 }
             };
 
+            let pending_ins = self.pending_ins.borrow(cs);
             pending_ins.set(pending_ins.get() | 1 << ep_addr.index());
 
             Ok(buf.len())

src/types/usb_device.rs

@@ -2,13 +2,13 @@ use core::cell::Cell;
 
 use avr_device::{
     atmega32u4::{PLL, USB_DEVICE},
-    interrupt::{free, CriticalSection, Mutex},
+    interrupt::{CriticalSection, Mutex},
 };
 use usb_device::{bus::UsbBusAllocator, endpoint::EndpointType, UsbDirection, UsbError};
 
 #[allow(unused)]
 #[derive(Default, Copy, Clone)]
-pub struct USBEndpoint {
+pub(crate) struct USBEndpoint {
     pub(crate) is_allocated: bool,
     pub(crate) size: u8,
     pub(crate) ep_type: u8,
@@ -71,8 +71,8 @@ impl USBEndpoint {
 pub struct UsbDevice<const L: usize> {
     pub(crate) pll: Mutex<PLL>,
     pub(crate) usb: Mutex<USB_DEVICE>,
-    pub(crate) pending_ins: Mutex<Cell<u8>>,
     pub(crate) ep_table: [USBEndpoint; L],
+    pub(crate) pending_ins: Mutex<Cell<u8>>,
     pub(crate) dpram_already_used: u16,
 }
 
@@ -80,7 +80,6 @@ pub(crate) const MAX_ENDPOINTS: usize = 7;
 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 ONE_MS_16_MGHZ: u32 = 16000;
-pub(crate) const ENDPOINT_EPNUM_MASK: u8 = 0x07;
 
 impl<const L: usize> UsbDevice<L> {
     #[inline]
@@ -88,8 +87,8 @@ impl<const L: usize> UsbDevice<L> {
         UsbBusAllocator::new(Self {
             pll: Mutex::new(pll),
             usb: Mutex::new(usb),
-            pending_ins: Mutex::new(Cell::new(0)),
             ep_table: [USBEndpoint::default(); L],
+            pending_ins: Mutex::new(Cell::new(0u8)),
             dpram_already_used: 0,
         })
     }
@@ -117,22 +116,21 @@ impl<const L: usize> UsbDevice<L> {
         cs: CriticalSection<'_>,
         endpoint_index: usize,
     ) -> Result<(), UsbError> {
+        let usb = self.usb.borrow(cs);
+        let endpoint_index = endpoint_index as u8;
+
         if endpoint_index >= 7 {
             return Err(UsbError::InvalidEndpoint);
         }
 
-        let usb = self.usb.borrow(cs);
-
-        if usb.usbcon().read().frzclk().bit_is_set() {
+        if usb.usbcon.read().frzclk().bit_is_set() {
             return Err(UsbError::InvalidState);
         }
 
-        let endpoint_index = (endpoint_index as u8) & ENDPOINT_EPNUM_MASK;
+        usb.uenum.write(|w| w.bits(endpoint_index));
 
-        usb.uenum().write(|w| unsafe { w.bits(endpoint_index) });
-
-        if usb.uenum().read().bits() & ENDPOINT_EPNUM_MASK != endpoint_index {
-            return Err(UsbError::InvalidState);
+        if usb.uenum.read().bits() & 7 /* 0b111 */ != endpoint_index {
+            return Err(UsbError::InvalidEndpoint);
         }
 
         Ok(())
@@ -144,44 +142,43 @@ impl<const L: usize> UsbDevice<L> {
         endpoint_index: usize,
     ) -> Result<(), UsbError> {
         let usb = self.usb.borrow(cs);
+        let current_endpoint = self.ep_table[endpoint_index];
 
-        self.select_endpoint(cs, endpoint_index)?;
+        match self.select_endpoint(cs, endpoint_index) {
+            Ok(_) => {
+                // Enable endpoint. //
 
-        let current_endpoint = &self.ep_table[endpoint_index];
+                usb.ueconx.modify(|_, w| w.epen().set_bit());
+                usb.uecfg1x.modify(|_, w| w.alloc().clear_bit());
 
-        usb.uecfg1x().modify(|_, w| w.alloc().clear_bit());
+                // Set markered endpoint parameters to uecfg0x/1x register. //
 
-        // Enable endpoint. //
+                usb.uecfg0x.modify(|_, w| {
+                    w.epdir()
+                        .bit(current_endpoint.ep_dir)
+                        .eptype()
+                        .bits(current_endpoint.ep_type)
+                });
 
-        usb.ueconx().modify(|_, w| w.epen().set_bit());
+                usb.uecfg1x.modify(|_, w| {
+                    w.epbk()
+                        .bits(0)
+                        .epsize()
+                        .bits(current_endpoint.size)
+                        .alloc()
+                        .set_bit()
+                });
 
-        // Set markered endpoint parameters to uecfg0x/1x register. //
+                if usb.uesta0x.read().cfgok().bit_is_clear() {
+                    Err(UsbError::EndpointMemoryOverflow)
+                } else {
+                    usb.ueienx
+                        .modify(|_, w| w.rxoute().set_bit().rxstpe().set_bit());
 
-        usb.uecfg0x().write(|w| unsafe {
-            w.epdir()
-                .bit(current_endpoint.ep_dir)
-                .eptype()
-                .bits(current_endpoint.ep_type)
-        });
-
-        usb.uecfg1x().write(|w| unsafe {
-            w.epbk()
-                .bits(0)
-                .epsize()
-                .bits(current_endpoint.size)
-                .alloc()
-                .set_bit()
-        });
-
-        usb.uecfg1x().modify(|_, w| w.alloc().set_bit());
-
-        if usb.uesta0x().read().cfgok().bit_is_clear() {
-            Err(UsbError::EndpointMemoryOverflow)
-        } else {
-            usb.ueienx()
-                .modify(|_, w| w.rxoute().set_bit().rxstpe().set_bit());
-
-            Ok(())
+                    Ok(())
+                }
+            }
+            Err(exception) => Err(exception),
         }
     }
 
@@ -189,6 +186,6 @@ impl<const L: usize> UsbDevice<L> {
     pub(crate) fn get_size(&self, cs: CriticalSection<'_>) -> usize {
         let usb = self.usb.borrow(cs);
 
-        (((usb.uebchx().read().bits() as u16) << 8) | (usb.uebclx().read().bits() as u16)).into()
+        (((usb.uebchx.read().bits() as u16) << 8) | (usb.uebclx.read().bits() as u16)).into()
     }
 }