Initial import, WIP.

.gitignore

@@ -0,0 +1,3 @@
+/target
+Cargo.lock
+*.swp

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "mkl25z4-usbd"
+version = "0.1.0"
+authors = ["Mathias Gottschlag <mgottschlag@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.6"
+mkl25z4 = { version = "0.0.3", features = ["rt"] }
+mkl25z4-hal = { git = "https://github.com/mgottschlag/mkl25z4-hal" }
+usb-device = "0.2.4"

rust-toolchain

@@ -0,0 +1 @@
+nightly-2020-04-11

src/bus.rs

@@ -0,0 +1,388 @@
+use core::mem::{self, MaybeUninit};
+use cortex_m::interrupt::{self, Mutex};
+use mkl25z4::{SIM, USB0};
+use usb_device::bus::{PollResult, UsbBusAllocator};
+use usb_device::endpoint::{EndpointAddress, EndpointType};
+use usb_device::{Result, UsbDirection, UsbError};
+
+use crate::UsbBuffers;
+
+pub const NUM_ENDPOINTS: usize = 16;
+pub const BUF_SIZE: usize = 64;
+
+#[repr(C)]
+pub(crate) struct BufferDescriptor {
+    flags: u32,
+    addr: u32,
+}
+
+impl BufferDescriptor {
+    // TODO
+}
+
+#[repr(align(512), C)]
+pub(crate) struct BufferDescriptorTable([BufferDescriptor; NUM_ENDPOINTS * 4]);
+
+impl BufferDescriptorTable {
+    pub(crate) fn new() -> Self {
+        Self([BufferDescriptor { flags: 0, addr: 0 }; NUM_ENDPOINTS * 4])
+    }
+}
+
+pub struct Endpoint {
+    ep_type: Option<EndpointType>,
+    in_buf: [[u8; BUF_SIZE]; 2],
+    out_buf: [[u8; BUF_SIZE]; 2],
+}
+
+impl Endpoint {
+    pub fn ep_type(&self) -> Option<EndpointType> {
+        self.ep_type
+    }
+
+    pub fn set_ep_type(&mut self, ep_type: EndpointType) {
+        self.ep_type = Some(ep_type);
+    }
+}
+
+impl Default for Endpoint {
+    fn default() -> Endpoint {
+        Endpoint {
+            ep_type: None,
+            in_buf: [[0; 64]; 2],
+            out_buf: [[0; 64]; 2],
+        }
+    }
+}
+pub struct UsbBus {
+    regs: Mutex<USB0>,
+    buffers: &'static mut UsbBuffers,
+    endpoints: [Endpoint; NUM_ENDPOINTS],
+    /*ep_allocator: EndpointMemoryAllocator<USB>,
+    max_endpoint: usize,*/
+}
+
+impl UsbBus {
+    /// Constructs a new USB peripheral driver.
+    pub fn new(
+        peripheral: USB0,
+        sim: &mut SIM,
+        buffers: &'static mut UsbBuffers,
+    ) -> UsbBusAllocator<Self> {
+        // TODO: Check whether the clocks are correct? USB requires a 48MHz reference clock.
+        // SIM->SOPT2 |= SIM_SOPT2_USBSRC_MASK | SIM_SOPT2_PLLFLLSEL_MASK;
+
+        // Enable the peripheral.
+        sim.scgc4.modify(|_, w| w.usbotg().set_bit());
+
+        let bus = UsbBus {
+            regs: Mutex::new(peripheral),
+            buffers: buffers,
+            /*ep_allocator: EndpointMemoryAllocator::new(),
+            max_endpoint: 0,*/
+            endpoints: [Endpoint::default(); NUM_ENDPOINTS],
+        };
+
+        UsbBusAllocator::new(bus)
+    }
+
+    /*pub fn free(self) -> USB0 {
+        // TODO: Disable the USB peripheral again?
+        // TODO: The following requires an updated bare-metal crate.
+        self.regs.into_inner()
+    }*/
+
+    /*/// Simulates a disconnect from the USB bus, causing the host to reset and re-enumerate the
+    /// device.
+    ///
+    /// Mostly used for development. By calling this at the start of your program ensures that the
+    /// host re-enumerates your device after a new program has been flashed.
+    ///
+    /// `disconnect` parameter is used to provide a custom disconnect function.
+    /// This function will be called with USB peripheral powered down
+    /// and interrupts disabled.
+    /// It should perform disconnect in a platform-specific way.
+    pub fn force_reenumeration<F: FnOnce()>(&self, disconnect: F) {
+        interrupt::free(|cs| {
+            let regs = self.regs.borrow(cs);
+
+            let pdwn = regs.cntr.read().pdwn().bit_is_set();
+            regs.cntr.modify(|_, w| w.pdwn().set_bit());
+
+            disconnect();
+
+            regs.cntr.modify(|_, w| w.pdwn().bit(pdwn));
+        });
+    }*/
+}
+
+impl usb_device::bus::UsbBus for UsbBus {
+    fn alloc_ep(
+        &mut self,
+        ep_dir: UsbDirection,
+        ep_addr: Option<EndpointAddress>,
+        ep_type: EndpointType,
+        max_packet_size: u16,
+        _interval: u8,
+    ) -> Result<EndpointAddress> {
+        for index in ep_addr
+            .map(|a| a.index()..a.index() + 1)
+            .unwrap_or(1..NUM_ENDPOINTS)
+        {
+            let ep = &mut self.endpoints[index];
+
+            match ep.ep_type() {
+                None => {
+                    ep.set_ep_type(ep_type);
+                }
+                Some(t) if t != ep_type => {
+                    continue;
+                }
+                _ => {}
+            };
+
+            match ep_dir {
+                UsbDirection::Out if !ep.is_out_buf_set() => {
+                    let (out_size, size_bits) = calculate_count_rx(max_packet_size as usize)?;
+
+                    let buffer = self.ep_allocator.allocate_buffer(out_size)?;
+
+                    ep.set_out_buf(buffer, size_bits);
+
+                    return Ok(EndpointAddress::from_parts(index, ep_dir));
+                }
+                UsbDirection::In if !ep.is_in_buf_set() => {
+                    let size = (max_packet_size as usize + 1) & !0x01;
+
+                    let buffer = self.ep_allocator.allocate_buffer(size)?;
+
+                    ep.set_in_buf(buffer);
+
+                    return Ok(EndpointAddress::from_parts(index, ep_dir));
+                }
+                _ => {}
+            }
+        }
+
+        Err(match ep_addr {
+            Some(_) => UsbError::InvalidEndpoint,
+            None => UsbError::EndpointOverflow,
+        })
+    }
+
+    fn enable(&mut self) {
+        /*let mut max = 0;
+        for (index, ep) in self.endpoints.iter().enumerate() {
+            if ep.is_out_buf_set() || ep.is_in_buf_set() {
+                max = index;
+            }
+        }
+
+        self.max_endpoint = max;*/
+
+        interrupt::free(|cs| {
+            let regs = self.regs.borrow(cs);
+
+            // Reset the USB module.
+            regs.usbtrc0.modify(|_, w| w.usbreset().set_bit());
+            // TODO: Wait two USB clock cycles for reset.
+
+            // Set the BDT base registers.
+            let bdt_address = &self.buffers.bdt as *const _ as u32;
+            regs.bdtpage1
+                .modify(|_, w| w.bdtba().bits((bdt_address >> 8) as u8));
+            regs.bdtpage2
+                .modify(|_, w| w.bdtba().bits((bdt_address >> 16) as u8));
+            regs.bdtpage3
+                .modify(|_, w| w.bdtba().bits((bdt_address >> 24) as u8));
+
+            // Clear all interrupt flags.
+            regs.istat.write(|w| unsafe { w.bits(0xff) });
+            regs.otgistat.write(|w| unsafe { w.bits(0xff) });
+            // Clear all errors.
+            regs.errstat.write(|w| unsafe { w.bits(0xff) });
+            // Undocumented interrupt bit?
+            regs.usbtrc0.write(|w| unsafe { w.bits(0x40) });
+
+            // Enable USB.
+            regs.ctl.write(|w| w.usbensofen().set_bit());
+            // Disable suspend, enable weak pull down.
+            regs.usbctrl.write(|w| w.pde().set_bit());
+            // Enable USB reset interrupt.
+            regs.inten.modify(|_, w| w.usbrsten().set_bit());
+        });
+    }
+
+    fn reset(&self) {
+        interrupt::free(|cs| {
+            let regs = self.regs.borrow(cs);
+
+            regs.ctl.modify(|_, w| w.oddrst().set_bit());
+
+            // Initialize all buffer descriptors and endpoints.
+            for ep in self.endpoints.iter() {
+                ep.configure(cs);
+            }
+
+            // Clear all interrupts.
+            regs.istat.write(|w| unsafe { w.bits(0xff) });
+            regs.errstat.write(|w| unsafe { w.bits(0xff) });
+
+            // After reset, the address is 0.
+            regs.addr.modify(|_, w| w.addr().bits(0));
+            // Enable all relevant interrupts.
+            regs.erren.modify(|_, w| unsafe { w.bits(0xff) });
+            regs.inten.modify(|_, w| {
+                w.usbrsten()
+                    .set_bit()
+                    .erroren()
+                    .set_bit()
+                    .softoken()
+                    .set_bit()
+                    .tokdneen()
+                    .set_bit()
+                    .sleepen()
+                    .set_bit()
+                    .stallen()
+                    .set_bit()
+            });
+        });
+    }
+
+    fn set_device_address(&self, addr: u8) {
+        interrupt::free(|cs| {
+            self.regs
+                .borrow(cs)
+                .addr
+                .modify(|_, w| w.addr().bits(addr as u8));
+        });
+    }
+
+    fn poll(&self) -> PollResult {
+        interrupt::free(|cs| {
+            let regs = self.regs.borrow(cs);
+
+            let istat = regs.istat.read();
+
+            if istr.wkup().bit_is_set() {
+                // Interrupt flag bits are write-0-to-clear, other bits should be written as 1 to avoid
+                // race conditions
+                regs.istr
+                    .write(|w| unsafe { w.bits(0xffff) }.wkup().clear_bit());
+
+                // Required by datasheet
+                regs.cntr.modify(|_, w| w.fsusp().clear_bit());
+
+                PollResult::Resume
+            } else if istr.reset().bit_is_set() {
+                regs.istr
+                    .write(|w| unsafe { w.bits(0xffff) }.reset().clear_bit());
+
+                PollResult::Reset
+            } else if istr.susp().bit_is_set() {
+                regs.istr
+                    .write(|w| unsafe { w.bits(0xffff) }.susp().clear_bit());
+
+                PollResult::Suspend
+            } else if istr.ctr().bit_is_set() {
+                let mut ep_out = 0;
+                let mut ep_in_complete = 0;
+                let mut ep_setup = 0;
+                let mut bit = 1;
+
+                for ep in &self.endpoints[0..=self.max_endpoint] {
+                    let v = ep.read_reg();
+
+                    if v.ctr_rx().bit_is_set() {
+                        ep_out |= bit;
+
+                        if v.setup().bit_is_set() {
+                            ep_setup |= bit;
+                        }
+                    }
+
+                    if v.ctr_tx().bit_is_set() {
+                        ep_in_complete |= bit;
+
+                        interrupt::free(|cs| {
+                            ep.clear_ctr_tx(cs);
+                        });
+                    }
+
+                    bit <<= 1;
+                }
+
+                PollResult::Data {
+                    ep_out,
+                    ep_in_complete,
+                    ep_setup,
+                }
+            } else {
+                PollResult::None
+            }
+        })
+    }
+
+    fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> Result<usize> {
+        if !ep_addr.is_in() {
+            return Err(UsbError::InvalidEndpoint);
+        }
+
+        self.endpoints[ep_addr.index()].write(buf)
+    }
+
+    fn read(&self, ep_addr: EndpointAddress, buf: &mut [u8]) -> Result<usize> {
+        if !ep_addr.is_out() {
+            return Err(UsbError::InvalidEndpoint);
+        }
+
+        self.endpoints[ep_addr.index()].read(buf)
+    }
+
+    fn set_stalled(&self, ep_addr: EndpointAddress, stalled: bool) {
+        interrupt::free(|cs| {
+            if self.is_stalled(ep_addr) == stalled {
+                return;
+            }
+
+            let ep = &self.endpoints[ep_addr.index()];
+
+            match (stalled, ep_addr.direction()) {
+                (true, UsbDirection::In) => ep.set_stat_tx(cs, EndpointStatus::Stall),
+                (true, UsbDirection::Out) => ep.set_stat_rx(cs, EndpointStatus::Stall),
+                (false, UsbDirection::In) => ep.set_stat_tx(cs, EndpointStatus::Nak),
+                (false, UsbDirection::Out) => ep.set_stat_rx(cs, EndpointStatus::Valid),
+            };
+        });
+    }
+
+    fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
+        let ep = &self.endpoints[ep_addr.index()];
+        let reg_v = ep.read_reg();
+
+        let status = match ep_addr.direction() {
+            UsbDirection::In => reg_v.stat_tx().bits(),
+            UsbDirection::Out => reg_v.stat_rx().bits(),
+        };
+
+        status == (EndpointStatus::Stall as u8)
+    }
+
+    fn suspend(&self) {
+        interrupt::free(|cs| {
+            self.regs
+                .borrow(cs)
+                .cntr
+                .modify(|_, w| w.fsusp().set_bit().lpmode().set_bit());
+        });
+    }
+
+    fn resume(&self) {
+        interrupt::free(|cs| {
+            self.regs
+                .borrow(cs)
+                .cntr
+                .modify(|_, w| w.fsusp().clear_bit().lpmode().clear_bit());
+        });
+    }
+}

src/endpoint.rs

@@ -0,0 +1 @@
+

src/lib.rs

@@ -0,0 +1,24 @@
+//! USB peripheral driver for MKL25Z microcontrollers.
+
+#![no_std]
+
+pub mod bus;
+//mod endpoint;
+//mod endpoint_memory;
+//mod registers;
+pub use crate::bus::UsbBus;
+
+//mod pac;
+
+pub struct UsbBuffers {
+    bdt: bus::BufferDescriptorTable,
+    // TODO
+}
+
+impl UsbBuffers {
+    const fn new() -> UsbBuffers {
+        UsbBuffers {
+            bdt: bus::BufferDescriptorTable::new(),
+        }
+    }
+}