148 lines
3.8 KiB
Rust
148 lines
3.8 KiB
Rust
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<Target = T> + 'd,
|
|
dp: impl Unborrow<Target = impl DpPin<T>> + 'd,
|
|
dm: impl Unborrow<Target = impl DmPin<T>> + '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() {
|
|
<T as crate::rcc::sealed::RccPeripheral>::enable();
|
|
<T as crate::rcc::sealed::RccPeripheral>::reset();
|
|
}
|
|
|
|
fn ahb_frequency_hz(&self) -> u32 {
|
|
<T as crate::rcc::sealed::RccPeripheral>::frequency().0
|
|
}
|
|
}
|
|
|
|
pub(crate) mod sealed {
|
|
use super::*;
|
|
|
|
pub trait Instance {
|
|
const REGISTERS: *const ();
|
|
}
|
|
|
|
pub trait DpPin<T: Instance>: Pin {
|
|
fn af_num(&self) -> u8;
|
|
}
|
|
|
|
pub trait DmPin<T: Instance>: Pin {
|
|
fn af_num(&self) -> u8;
|
|
}
|
|
}
|
|
|
|
pub trait Instance: sealed::Instance + RccPeripheral {}
|
|
pub trait DpPin<T: Instance>: sealed::DpPin<T> {}
|
|
pub trait DmPin<T: Instance>: sealed::DmPin<T> {}
|
|
|
|
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<peripherals::$inst> for peripherals::$pin {}
|
|
|
|
impl sealed::$signal<peripherals::$inst> 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);
|
|
};
|
|
);
|