max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

eth-v2: Remove Instance trait

Browse Source
This commit is contained in:
Thales Fragoso 2021-06-10 23:33:31 -03:00 committed by Dario Nieuwenhuis
parent 05a239faf6
commit e039c7c42c
1 changed files with 57 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
embassy-stm32/src/eth/v2/mod.rs
View File

@ -11,7 +11,6 @@ use embassy_net::{Device, DeviceCapabilities, LinkState, PacketBuf, MTU};
use crate::gpio::sealed::Pin as __GpioPin; use crate::gpio::sealed::Pin as __GpioPin;
use crate::gpio::AnyPin; use crate::gpio::AnyPin;
use crate::gpio::Pin as GpioPin; use crate::gpio::Pin as GpioPin;
use crate::interrupt::Interrupt;
use crate::pac::gpio::vals::Ospeedr; use crate::pac::gpio::vals::Ospeedr;
use crate::pac::ETH; use crate::pac::ETH;
use crate::peripherals; use crate::peripherals;
@ -21,8 +20,8 @@ mod descriptors;
use super::{StationManagement, PHY}; use super::{StationManagement, PHY};
use descriptors::DescriptorRing; use descriptors::DescriptorRing;
pub struct Ethernet<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> { pub struct Ethernet<'d, P: PHY, const TX: usize, const RX: usize> {
state: PeripheralMutex<Inner<'d, T, TX, RX>>, state: PeripheralMutex<Inner<'d, TX, RX>>,
pins: [AnyPin; 9], pins: [AnyPin; 9],
_phy: P, _phy: P,
clock_range: u8, clock_range: u8,
@ -30,19 +29,19 @@ pub struct Ethernet<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> {
mac_addr: [u8; 6], mac_addr: [u8; 6],
} }
impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, T, P, TX, RX> { impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> {
pub fn new( pub fn new(
peri: impl Unborrow<Target = T> + 'd, peri: impl Unborrow<Target = peripherals::ETH> + 'd,
interrupt: impl Unborrow<Target = T::Interrupt> + 'd, interrupt: impl Unborrow<Target = crate::interrupt::ETH> + 'd,
ref_clk: impl Unborrow<Target = impl RefClkPin<T>> + 'd, ref_clk: impl Unborrow<Target = impl RefClkPin> + 'd,
mdio: impl Unborrow<Target = impl MDIOPin<T>> + 'd, mdio: impl Unborrow<Target = impl MDIOPin> + 'd,
mdc: impl Unborrow<Target = impl MDCPin<T>> + 'd, mdc: impl Unborrow<Target = impl MDCPin> + 'd,
crs: impl Unborrow<Target = impl CRSPin<T>> + 'd, crs: impl Unborrow<Target = impl CRSPin> + 'd,
rx_d0: impl Unborrow<Target = impl RXD0Pin<T>> + 'd, rx_d0: impl Unborrow<Target = impl RXD0Pin> + 'd,
rx_d1: impl Unborrow<Target = impl RXD1Pin<T>> + 'd, rx_d1: impl Unborrow<Target = impl RXD1Pin> + 'd,
tx_d0: impl Unborrow<Target = impl TXD0Pin<T>> + 'd, tx_d0: impl Unborrow<Target = impl TXD0Pin> + 'd,
tx_d1: impl Unborrow<Target = impl TXD1Pin<T>> + 'd, tx_d1: impl Unborrow<Target = impl TXD1Pin> + 'd,
tx_en: impl Unborrow<Target = impl TXEnPin<T>> + 'd, tx_en: impl Unborrow<Target = impl TXEnPin> + 'd,
phy: P, phy: P,
mac_addr: [u8; 6], mac_addr: [u8; 6],
hclk: Hertz, hclk: Hertz,
@ -183,8 +182,8 @@ impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, T,
} }
} }
unsafe impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> StationManagement unsafe impl<'d, P: PHY, const TX: usize, const RX: usize> StationManagement
for Ethernet<'d, T, P, TX, RX> for Ethernet<'d, P, TX, RX>
{ {
fn smi_read(&mut self, reg: u8) -> u16 { fn smi_read(&mut self, reg: u8) -> u16 {
// NOTE(unsafe) These registers aren't used in the interrupt and we have `&mut self` // NOTE(unsafe) These registers aren't used in the interrupt and we have `&mut self`
@ -221,9 +220,7 @@ unsafe impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> StationMa
} }
} }
impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Device impl<'d, P: PHY, const TX: usize, const RX: usize> Device for Pin<&mut Ethernet<'d, P, TX, RX>> {
for Pin<&mut Ethernet<'d, T, P, TX, RX>>
{
fn is_transmit_ready(&mut self) -> bool { fn is_transmit_ready(&mut self) -> bool {
// NOTE(unsafe) We won't move out of self // NOTE(unsafe) We won't move out of self
let this = unsafe { self.as_mut().get_unchecked_mut() }; let this = unsafe { self.as_mut().get_unchecked_mut() };
@ -249,7 +246,7 @@ impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Device
} }
fn register_waker(&mut self, waker: &Waker) { fn register_waker(&mut self, waker: &Waker) {
T::state().register(waker); WAKER.register(waker);
} }
fn capabilities(&mut self) -> DeviceCapabilities { fn capabilities(&mut self) -> DeviceCapabilities {
@ -278,9 +275,7 @@ impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Device
} }
} }
impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Drop impl<'d, P: PHY, const TX: usize, const RX: usize> Drop for Ethernet<'d, P, TX, RX> {
for Ethernet<'d, T, P, TX, RX>
{
fn drop(&mut self) { fn drop(&mut self) {
// NOTE(unsafe) We have `&mut self` and the interrupt doesn't use this registers // NOTE(unsafe) We have `&mut self` and the interrupt doesn't use this registers
unsafe { unsafe {
@ -323,13 +318,13 @@ impl<'d, T: Instance, P: PHY, const TX: usize, const RX: usize> Drop
//---------------------------------------------------------------------- //----------------------------------------------------------------------
struct Inner<'d, T: Instance, const TX: usize, const RX: usize> { struct Inner<'d, const TX: usize, const RX: usize> {
_peri: PhantomData<&'d mut T>, _peri: PhantomData<&'d mut peripherals::ETH>,
desc_ring: DescriptorRing<TX, RX>, desc_ring: DescriptorRing<TX, RX>,
} }
impl<'d, T: Instance, const TX: usize, const RX: usize> Inner<'d, T, TX, RX> { impl<'d, const TX: usize, const RX: usize> Inner<'d, TX, RX> {
pub fn new(_peri: impl Unborrow<Target = T> + 'd) -> Self { pub fn new(_peri: impl Unborrow<Target = peripherals::ETH> + 'd) -> Self {
Self { Self {
_peri: PhantomData, _peri: PhantomData,
desc_ring: DescriptorRing::new(), desc_ring: DescriptorRing::new(),
@ -337,14 +332,14 @@ impl<'d, T: Instance, const TX: usize, const RX: usize> Inner<'d, T, TX, RX> {
} }
} }
impl<'d, T: Instance, const TX: usize, const RX: usize> PeripheralState for Inner<'d, T, TX, RX> { impl<'d, const TX: usize, const RX: usize> PeripheralState for Inner<'d, TX, RX> {
type Interrupt = T::Interrupt; type Interrupt = crate::interrupt::ETH;
fn on_interrupt(&mut self) { fn on_interrupt(&mut self) {
unwrap!(self.desc_ring.tx.on_interrupt()); unwrap!(self.desc_ring.tx.on_interrupt());
self.desc_ring.rx.on_interrupt(); self.desc_ring.rx.on_interrupt();
T::state().wake(); WAKER.wake();
// TODO: Check and clear more flags // TODO: Check and clear more flags
unsafe { unsafe {
@ -364,87 +359,66 @@ impl<'d, T: Instance, const TX: usize, const RX: usize> PeripheralState for Inne
mod sealed { mod sealed {
use super::*; use super::*;
pub trait Instance { pub trait RefClkPin: GpioPin {
type Interrupt: Interrupt;
fn state() -> &'static AtomicWaker;
}
pub trait RefClkPin<T: Instance>: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait MDIOPin<T: Instance>: GpioPin { pub trait MDIOPin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait MDCPin<T: Instance>: GpioPin { pub trait MDCPin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait CRSPin<T: Instance>: GpioPin { pub trait CRSPin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait RXD0Pin<T: Instance>: GpioPin { pub trait RXD0Pin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait RXD1Pin<T: Instance>: GpioPin { pub trait RXD1Pin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait TXD0Pin<T: Instance>: GpioPin { pub trait TXD0Pin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait TXD1Pin<T: Instance>: GpioPin { pub trait TXD1Pin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
pub trait TXEnPin<T: Instance>: GpioPin { pub trait TXEnPin: GpioPin {
fn configure(&mut self); fn configure(&mut self);
} }
} }
pub trait Instance: sealed::Instance + 'static {} pub trait RefClkPin: sealed::RefClkPin + 'static {}
pub trait RefClkPin<T: Instance>: sealed::RefClkPin<T> + 'static {} pub trait MDIOPin: sealed::MDIOPin + 'static {}
pub trait MDIOPin<T: Instance>: sealed::MDIOPin<T> + 'static {} pub trait MDCPin: sealed::MDCPin + 'static {}
pub trait MDCPin<T: Instance>: sealed::MDCPin<T> + 'static {} pub trait CRSPin: sealed::CRSPin + 'static {}
pub trait CRSPin<T: Instance>: sealed::CRSPin<T> + 'static {} pub trait RXD0Pin: sealed::RXD0Pin + 'static {}
pub trait RXD0Pin<T: Instance>: sealed::RXD0Pin<T> + 'static {} pub trait RXD1Pin: sealed::RXD1Pin + 'static {}
pub trait RXD1Pin<T: Instance>: sealed::RXD1Pin<T> + 'static {} pub trait TXD0Pin: sealed::TXD0Pin + 'static {}
pub trait TXD0Pin<T: Instance>: sealed::TXD0Pin<T> + 'static {} pub trait TXD1Pin: sealed::TXD1Pin + 'static {}
pub trait TXD1Pin<T: Instance>: sealed::TXD1Pin<T> + 'static {} pub trait TXEnPin: sealed::TXEnPin + 'static {}
pub trait TXEnPin<T: Instance>: sealed::TXEnPin<T> + 'static {} static WAKER: AtomicWaker = AtomicWaker::new();
crate::pac::peripherals!(
(eth, $inst:ident) => {
impl sealed::Instance for peripherals::$inst {
type Interrupt = crate::interrupt::$inst;
fn state() -> &'static AtomicWaker {
static WAKER: AtomicWaker = AtomicWaker::new();
&WAKER
}
}
impl Instance for peripherals::$inst {}
};
);
macro_rules! impl_pin { macro_rules! impl_pin {
($inst:ident, $pin:ident, $signal:ident, $af:expr) => { ($pin:ident, $signal:ident, $af:expr) => {
impl sealed::$signal<peripherals::$inst> for peripherals::$pin { impl sealed::$signal for peripherals::$pin {
fn configure(&mut self) { fn configure(&mut self) {
// NOTE(unsafe) Exclusive access to the registers // NOTE(unsafe) Exclusive access to the registers
critical_section::with(|_| unsafe { critical_section::with(|_| unsafe {
@ -456,36 +430,36 @@ macro_rules! impl_pin {
} }
} }
impl $signal<peripherals::$inst> for peripherals::$pin {} impl $signal for peripherals::$pin {}
}; };
} }
crate::pac::peripheral_pins!( crate::pac::peripheral_pins!(
($inst:ident, eth, ETH, $pin:ident, REF_CLK, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, REF_CLK, $af:expr) => {
impl_pin!($inst, $pin, RefClkPin, $af); impl_pin!($pin, RefClkPin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, MDIO, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, MDIO, $af:expr) => {
impl_pin!($inst, $pin, MDIOPin, $af); impl_pin!($pin, MDIOPin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, MDC, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, MDC, $af:expr) => {
impl_pin!($inst, $pin, MDCPin, $af); impl_pin!($pin, MDCPin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, CRS_DV, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, CRS_DV, $af:expr) => {
impl_pin!($inst, $pin, CRSPin, $af); impl_pin!($pin, CRSPin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, RXD0, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, RXD0, $af:expr) => {
impl_pin!($inst, $pin, RXD0Pin, $af); impl_pin!($pin, RXD0Pin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, RXD1, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, RXD1, $af:expr) => {
impl_pin!($inst, $pin, RXD1Pin, $af); impl_pin!($pin, RXD1Pin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, TXD0, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, TXD0, $af:expr) => {
impl_pin!($inst, $pin, TXD0Pin, $af); impl_pin!($pin, TXD0Pin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, TXD1, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, TXD1, $af:expr) => {
impl_pin!($inst, $pin, TXD1Pin, $af); impl_pin!($pin, TXD1Pin, $af);
}; };
($inst:ident, eth, ETH, $pin:ident, TX_EN, $af:expr) => { ($inst:ident, eth, ETH, $pin:ident, TX_EN, $af:expr) => {
impl_pin!($inst, $pin, TXEnPin, $af); impl_pin!($pin, TXEnPin, $af);
}; };
); );