From db0d798b4896e97bf40e42cb54344e7a3f77a5c8 Mon Sep 17 00:00:00 2001 From: chemicstry Date: Tue, 8 Feb 2022 00:32:49 +0200 Subject: [PATCH] Add stm32 USB OTG peripherals --- embassy-stm32/Cargo.toml | 6 + embassy-stm32/build.rs | 8 ++ embassy-stm32/src/lib.rs | 4 + embassy-stm32/src/usb_otg_fs.rs | 159 +++++++++++++++++++++++++++ embassy-stm32/src/usb_otg_hs.rs | 147 +++++++++++++++++++++++++ examples/stm32f4/Cargo.toml | 5 +- examples/stm32f4/src/bin/usb_uart.rs | 99 +++++++++++++++++ 7 files changed, 427 insertions(+), 1 deletion(-) create mode 100644 embassy-stm32/src/usb_otg_fs.rs create mode 100644 embassy-stm32/src/usb_otg_hs.rs create mode 100644 examples/stm32f4/src/bin/usb_uart.rs diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml index 1aa665fb..8f6504b5 100644 --- a/embassy-stm32/Cargo.toml +++ b/embassy-stm32/Cargo.toml @@ -23,6 +23,7 @@ futures = { version = "0.3.17", default-features = false, features = ["async-awa rand_core = "0.6.3" sdio-host = "0.5.0" embedded-sdmmc = { git = "https://github.com/thalesfragoso/embedded-sdmmc-rs", branch = "async", optional = true } +synopsys-usb-otg = { version = "0.3", features = ["cortex-m"], optional = true } critical-section = "0.2.5" bare-metal = "1.0.0" atomic-polyfill = "0.1.5" @@ -43,6 +44,11 @@ memory-x = ["stm32-metapac/memory-x"] subghz = [] exti = [] +# These features are exclusive +# synopsys-usb-otg does not support simultaneous FS and HS +usb-otg-fs = ["synopsys-usb-otg", "synopsys-usb-otg/fs"] +usb-otg-hs = ["synopsys-usb-otg", "synopsys-usb-otg/hs"] + # Features starting with `_` are for internal use only. They're not intended # to be enabled by other crates, and are not covered by semver guarantees. _time-driver = ["embassy/time-tick-32768hz"] diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs index ff91f93d..aee59644 100644 --- a/embassy-stm32/build.rs +++ b/embassy-stm32/build.rs @@ -185,6 +185,14 @@ fn main() { println!("cargo:rustc-cfg={}x{}", &chip_name[..9], &chip_name[10..11]); } + // ======= + // Features for targeting groups of chips + + println!("cargo:rustc-cfg={}", &chip_name[..7]); // stm32f4 + println!("cargo:rustc-cfg={}", &chip_name[..9]); // stm32f429 + println!("cargo:rustc-cfg={}x", &chip_name[..8]); // stm32f42x + println!("cargo:rustc-cfg={}x{}", &chip_name[..7], &chip_name[8..9]); // stm32f4x9 + // ======== // Handle time-driver-XXXX features. diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs index dfc02773..3b9a61d4 100644 --- a/embassy-stm32/src/lib.rs +++ b/embassy-stm32/src/lib.rs @@ -50,6 +50,10 @@ pub mod sdmmc; pub mod spi; #[cfg(usart)] pub mod usart; +#[cfg(feature = "usb-otg-fs")] +pub mod usb_otg_fs; +#[cfg(feature = "usb-otg-hs")] +pub mod usb_otg_hs; #[cfg(feature = "subghz")] pub mod subghz; diff --git a/embassy-stm32/src/usb_otg_fs.rs b/embassy-stm32/src/usb_otg_fs.rs new file mode 100644 index 00000000..3e0cadb1 --- /dev/null +++ b/embassy-stm32/src/usb_otg_fs.rs @@ -0,0 +1,159 @@ +use crate::gpio::sealed::{AFType, Pin}; +use crate::{peripherals, rcc::RccPeripheral}; +use core::marker::PhantomData; +use embassy::util::Unborrow; +use embassy_hal_common::unborrow; +pub use embassy_hal_common::usb::*; +pub use synopsys_usb_otg::UsbBus; +use synopsys_usb_otg::UsbPeripheral; + +pub struct UsbOtgFs<'d, T: Instance> { + phantom: PhantomData<&'d mut T>, +} + +impl<'d, T: Instance> UsbOtgFs<'d, T> { + pub fn new( + _peri: impl Unborrow + 'd, + dp: impl Unborrow> + 'd, + dm: impl Unborrow> + 'd, + ) -> Self { + unborrow!(dp, dm); + + unsafe { + dp.set_as_af(dp.af_num(), AFType::OutputPushPull); + dm.set_as_af(dm.af_num(), AFType::OutputPushPull); + } + + Self { + phantom: PhantomData, + } + } +} + +impl<'d, T: Instance> Drop for UsbOtgFs<'d, T> { + fn drop(&mut self) { + T::reset(); + T::disable(); + } +} + +unsafe impl<'d, T: Instance> Send for UsbOtgFs<'d, T> {} +unsafe impl<'d, T: Instance> Sync for UsbOtgFs<'d, T> {} + +unsafe impl<'d, T: Instance> UsbPeripheral for UsbOtgFs<'d, T> { + const REGISTERS: *const () = T::REGISTERS; + + const HIGH_SPEED: bool = false; + + cfg_if::cfg_if! { + if #[cfg(stm32f1)] { + const FIFO_DEPTH_WORDS: usize = 128; + const ENDPOINT_COUNT: usize = 8; + } else if #[cfg(any( + stm32f2, + stm32f401, + stm32f405, + stm32f407, + stm32f411, + stm32f415, + stm32f417, + stm32f427, + stm32f429, + stm32f437, + stm32f439, + ))] { + const FIFO_DEPTH_WORDS: usize = 320; + const ENDPOINT_COUNT: usize = 4; + } else if #[cfg(any( + stm32f412, + stm32f413, + stm32f423, + stm32f446, + stm32f469, + stm32f479, + stm32f7, + stm32l4, + stm32u5, + ))] { + const FIFO_DEPTH_WORDS: usize = 320; + const ENDPOINT_COUNT: usize = 6; + } else if #[cfg(stm32g0x1)] { + const FIFO_DEPTH_WORDS: usize = 512; + const ENDPOINT_COUNT: usize = 8; + } else { + compile_error!("USB_OTG_FS peripheral is not supported by this chip. Disable \"usb-otg-fs\" feature or select a different chip."); + } + } + + fn enable() { + ::enable(); + ::reset(); + } + + fn ahb_frequency_hz(&self) -> u32 { + ::frequency().0 + } +} + +pub(crate) mod sealed { + use super::*; + + pub trait Instance { + const REGISTERS: *const (); + } + + pub trait DpPin: Pin { + fn af_num(&self) -> u8; + } + + pub trait DmPin: Pin { + fn af_num(&self) -> u8; + } +} + +pub trait Instance: sealed::Instance + RccPeripheral {} +pub trait DpPin: sealed::DpPin {} +pub trait DmPin: sealed::DmPin {} + +crate::pac::peripherals!( + (otgfs, $inst:ident) => { + impl sealed::Instance for crate::peripherals::$inst { + const REGISTERS: *const () = crate::pac::$inst.0 as *const (); + } + + impl Instance for peripherals::$inst {} + }; +); + +crate::pac::interrupts!( + ($inst:ident, otgfs, $block:ident, GLOBAL, $irq:ident) => { + unsafe impl USBInterrupt for crate::interrupt::$irq {} + }; +); + +macro_rules! impl_pin { + ($inst:ident, $pin:ident, $signal:ident, $af:expr) => { + impl $signal for peripherals::$pin {} + + impl sealed::$signal for peripherals::$pin { + fn af_num(&self) -> u8 { + $af + } + } + }; +} + +crate::pac::peripheral_pins!( + ($inst:ident, otgfs, OTG_FS, $pin:ident, DP, $af:expr) => { + impl_pin!($inst, $pin, DpPin, $af); + }; + ($inst:ident, otgfs, OTG_FS, $pin:ident, DM, $af:expr) => { + impl_pin!($inst, $pin, DmPin, $af); + }; + ($inst:ident, otgfs, OTG_FS, $pin:ident, DP) => { + impl_pin!($inst, $pin, DpPin, 0); + }; + ($inst:ident, otgfs, OTG_FS, $pin:ident, DM) => { + impl_pin!($inst, $pin, DmPin, 0); + }; +); diff --git a/embassy-stm32/src/usb_otg_hs.rs b/embassy-stm32/src/usb_otg_hs.rs new file mode 100644 index 00000000..8de4601e --- /dev/null +++ b/embassy-stm32/src/usb_otg_hs.rs @@ -0,0 +1,147 @@ +use crate::gpio::sealed::{AFType, Pin}; +use crate::{peripherals, rcc::RccPeripheral}; +use core::marker::PhantomData; +use embassy::util::Unborrow; +use embassy_hal_common::unborrow; +pub use embassy_hal_common::usb::*; +pub use synopsys_usb_otg::UsbBus; +use synopsys_usb_otg::UsbPeripheral; + +pub struct UsbOtgHs<'d, T: Instance> { + phantom: PhantomData<&'d mut T>, +} + +impl<'d, T: Instance> UsbOtgHs<'d, T> { + pub fn new( + _peri: impl Unborrow + 'd, + dp: impl Unborrow> + 'd, + dm: impl Unborrow> + 'd, + ) -> Self { + unborrow!(dp, dm); + + unsafe { + dp.set_as_af(dp.af_num(), AFType::OutputPushPull); + dm.set_as_af(dm.af_num(), AFType::OutputPushPull); + } + + Self { + phantom: PhantomData, + } + } +} + +impl<'d, T: Instance> Drop for UsbOtgHs<'d, T> { + fn drop(&mut self) { + T::reset(); + T::disable(); + } +} + +unsafe impl<'d, T: Instance> Send for UsbOtgHs<'d, T> {} +unsafe impl<'d, T: Instance> Sync for UsbOtgHs<'d, T> {} + +unsafe impl<'d, T: Instance> UsbPeripheral for UsbOtgHs<'d, T> { + const REGISTERS: *const () = T::REGISTERS; + + const HIGH_SPEED: bool = true; + + cfg_if::cfg_if! { + if #[cfg(any( + stm32f2, + stm32f405, + stm32f407, + stm32f415, + stm32f417, + stm32f427, + stm32f429, + stm32f437, + stm32f439, + ))] { + const FIFO_DEPTH_WORDS: usize = 1024; + const ENDPOINT_COUNT: usize = 6; + } else if #[cfg(any( + stm32f446, + stm32f469, + stm32f479, + stm32f7, + stm32h7, + ))] { + const FIFO_DEPTH_WORDS: usize = 1024; + const ENDPOINT_COUNT: usize = 9; + } else { + compile_error!("USB_OTG_HS peripheral is not supported by this chip. Disable \"usb-otg-hs\" feature or select a different chip."); + } + } + + fn enable() { + ::enable(); + ::reset(); + } + + fn ahb_frequency_hz(&self) -> u32 { + ::frequency().0 + } +} + +pub(crate) mod sealed { + use super::*; + + pub trait Instance { + const REGISTERS: *const (); + } + + pub trait DpPin: Pin { + fn af_num(&self) -> u8; + } + + pub trait DmPin: Pin { + fn af_num(&self) -> u8; + } +} + +pub trait Instance: sealed::Instance + RccPeripheral {} +pub trait DpPin: sealed::DpPin {} +pub trait DmPin: sealed::DmPin {} + +crate::pac::peripherals!( + (otghs, $inst:ident) => { + impl sealed::Instance for crate::peripherals::$inst { + const REGISTERS: *const () = crate::pac::$inst.0 as *const (); + } + + impl Instance for peripherals::$inst {} + }; +); + +crate::pac::interrupts!( + ($inst:ident, otghs, $block:ident, GLOBAL, $irq:ident) => { + unsafe impl USBInterrupt for crate::interrupt::$irq {} + }; +); + +macro_rules! impl_pin { + ($inst:ident, $pin:ident, $signal:ident, $af:expr) => { + impl $signal for peripherals::$pin {} + + impl sealed::$signal for peripherals::$pin { + fn af_num(&self) -> u8 { + $af + } + } + }; +} + +crate::pac::peripheral_pins!( + ($inst:ident, otghs, OTG_HS, $pin:ident, DP, $af:expr) => { + impl_pin!($inst, $pin, DpPin, $af); + }; + ($inst:ident, otghs, OTG_HS, $pin:ident, DM, $af:expr) => { + impl_pin!($inst, $pin, DmPin, $af); + }; + ($inst:ident, otghs, OTG_HS, $pin:ident, DP) => { + impl_pin!($inst, $pin, DpPin, 0); + }; + ($inst:ident, otghs, OTG_HS, $pin:ident, DM) => { + impl_pin!($inst, $pin, DmPin, 0); + }; +); diff --git a/examples/stm32f4/Cargo.toml b/examples/stm32f4/Cargo.toml index 67b212d5..8a5908e2 100644 --- a/examples/stm32f4/Cargo.toml +++ b/examples/stm32f4/Cargo.toml @@ -8,7 +8,7 @@ resolver = "2" [dependencies] embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "unstable-traits"] } -embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32f429zi", "unstable-pac", "memory-x", "time-driver-any", "exti"] } +embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32f429zi", "unstable-pac", "memory-x", "time-driver-any", "exti", "usb-otg-fs"] } defmt = "0.3" defmt-rtt = "0.3" @@ -20,3 +20,6 @@ panic-probe = { version = "0.3", features = ["print-defmt"] } futures = { version = "0.3.17", default-features = false, features = ["async-await"] } heapless = { version = "0.7.5", default-features = false } nb = "1.0.0" + +usb-device = "0.2" +usbd-serial = "0.1.1" diff --git a/examples/stm32f4/src/bin/usb_uart.rs b/examples/stm32f4/src/bin/usb_uart.rs new file mode 100644 index 00000000..7167a28b --- /dev/null +++ b/examples/stm32f4/src/bin/usb_uart.rs @@ -0,0 +1,99 @@ +#![no_std] +#![no_main] +#![feature(type_alias_impl_trait)] + +#[path = "../example_common.rs"] +mod example_common; + +use defmt::{info, unwrap}; +use defmt_rtt as _; // global logger +use embassy::interrupt::InterruptExt; +use futures::pin_mut; +use panic_probe as _; // print out panic messages + +use embassy::executor::Spawner; +use embassy::io::{AsyncBufReadExt, AsyncWriteExt}; +use embassy_stm32::usb_otg_fs::{State, Usb, UsbBus, UsbOtgFs, UsbSerial}; +use embassy_stm32::{interrupt, time::Hertz, Config, Peripherals}; +use usb_device::device::{UsbDeviceBuilder, UsbVidPid}; + +static mut EP_MEMORY: [u32; 2048] = [0; 2048]; + +// USB requires at least 48 MHz clock +fn config() -> Config { + let mut config = Config::default(); + config.rcc.sys_ck = Some(Hertz(48_000_000)); + config +} + +#[embassy::main(config = "config()")] +async fn main(_spawner: Spawner, p: Peripherals) { + let mut rx_buffer = [0u8; 64]; + // we send back input + cr + lf + let mut tx_buffer = [0u8; 66]; + + let peri = UsbOtgFs::new(p.USB_OTG_FS, p.PA12, p.PA11); + let usb_bus = UsbBus::new(peri, unsafe { &mut EP_MEMORY }); + + let serial = UsbSerial::new(&usb_bus, &mut rx_buffer, &mut tx_buffer); + + let device = UsbDeviceBuilder::new(&usb_bus, UsbVidPid(0x16c0, 0x27dd)) + .manufacturer("Fake company") + .product("Serial port") + .serial_number("TEST") + .device_class(0x02) + .build(); + + let irq = interrupt::take!(OTG_FS); + irq.set_priority(interrupt::Priority::P3); + + let mut state = State::new(); + let usb = unsafe { Usb::new(&mut state, device, serial, irq) }; + pin_mut!(usb); + + let (mut reader, mut writer) = usb.as_ref().take_serial_0(); + + info!("usb initialized!"); + + unwrap!( + writer + .write_all(b"\r\nInput returned upper cased on CR+LF\r\n") + .await + ); + + let mut buf = [0u8; 64]; + loop { + let mut n = 0; + + async { + loop { + let char = unwrap!(reader.read_byte().await); + + if char == b'\r' || char == b'\n' { + break; + } + + buf[n] = char; + n += 1; + + // stop if we're out of room + if n == buf.len() { + break; + } + } + } + .await; + + if n > 0 { + for char in buf[..n].iter_mut() { + // upper case + if 0x61 <= *char && *char <= 0x7a { + *char &= !0x20; + } + } + unwrap!(writer.write_all(&buf[..n]).await); + unwrap!(writer.write_all(b"\r\n").await); + unwrap!(writer.flush().await); + } + } +}