Struct EthernetDMA

pub struct EthernetDMA<'rx, 'tx> { /* private fields */ }

Ethernet DMA.

Implementations

impl<'rx, 'tx> EthernetDMA<'rx, 'tx>

pub fn split(&mut self) -> (&mut RxRing<'rx>, &mut TxRing<'tx>)

Split the EthernetDMA into concurrently operating send and receive parts.

pub fn enable_interrupt(&self)

Enable RX and TX interrupts

In your handler you must call EthernetDMA::interrupt_handler() or stm32_eth::eth_interrupt_handler to clear interrupt pending bits. Otherwise the interrupt will reoccur immediately.

If you have PTP enabled, you must also call EthernetPTP::interrupt_handler() if you wish to make use of the PTP timestamp trigger feature.

pub fn interrupt_handler() -> InterruptReasonSummary

Handle the DMA parts of the ETH interrupt.

pub fn recv_next( &mut self, packet_id: Option<PacketId>, ) -> Result<RxPacket<'_>, RxError>

Try to receive a packet.

If no packet is available, this function returns Err(RxError::WouldBlock).

It may also return another kind of RxError.

pub fn rx_is_running(&self) -> bool

Is Rx DMA currently running?

It stops if the ring is full. Call EthernetDMA::recv_next() to free an entry and to demand poll from the hardware.

pub fn tx_is_running(&self) -> bool

Is Tx DMA currently running?

pub fn send<F>( &mut self, length: usize, packet_id: Option<PacketId>, f: F, ) -> Result<(), TxError>

where F: FnOnce(&mut [u8]),

Try to send a packet with data.

If there are no free TX slots, this function will return Err(TxError::WouldBlock).

pub fn rx_available(&mut self) -> bool

Check if there is a packet available for reading.

If this function returns true, it is guaranteed that the next call to EthernetDMA::recv_next will return Ok.

pub fn tx_available(&mut self) -> bool

Check if sending a packet now would succeed.

If this function returns true, it is guaranteed that the next call to EthernetDMA::send will return Ok

impl<'rx, 'tx> EthernetDMA<'rx, 'tx>

pub async fn recv(&mut self, packet_id: Option<PacketId>) -> RxPacket<'_>

Receive a packet.

See RxRing::recv.

pub async fn prepare_packet<'borrow>( &'borrow mut self, length: usize, packet_id: Option<PacketId>, ) -> TxPacket<'borrow, 'tx>

Prepare a packet for sending.

See TxRing::prepare_packet.

pub async fn rx_or_tx(&mut self)

Wait for an RX or TX interrupt to have occured.

impl EthernetDMA<'_, '_>

pub fn poll_timestamp( &self, packet_id: &PacketId, ) -> Poll<Result<Option<Timestamp>, PacketIdNotFound>>

Try to get the timestamp for the given packet ID.

This function will attempt to find both RX and TX timestamps, so make sure that the provided packet ID is unique between the two.

pub fn rx_timestamp( &self, packet_id: &PacketId, ) -> Result<Option<Timestamp>, PacketIdNotFound>

Get the RX timestamp for the given packet ID.

pub fn wait_for_tx_timestamp( &self, packet_id: &PacketId, ) -> Result<Option<Timestamp>, PacketIdNotFound>

Blockingly wait until the TX timestamp for the given ID is available.

pub fn poll_tx_timestamp( &self, packet_id: &PacketId, ) -> Poll<Result<Option<Timestamp>, PacketIdNotFound>>

Poll to check if the TX timestamp for the given ID is available.

pub async fn tx_timestamp( &mut self, packet_id: &PacketId, ) -> Result<Option<Timestamp>, PacketIdNotFound>

Get the TX timestamp for the given ID.

pub fn next_packet_id(&mut self) -> PacketId

Get the next packet ID.

Trait Implementations

impl<'a, 'rx, 'tx> Device for &'a mut EthernetDMA<'rx, 'tx>

Use this Ethernet driver with smoltcp

type RxToken<'token> = EthRxToken<'token, 'rx> where Self: 'token

type TxToken<'token> = EthTxToken<'token, 'tx> where Self: 'token

fn capabilities(&self) -> DeviceCapabilities

Get a description of device capabilities.

fn receive( &mut self, _timestamp: Instant, ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)>

Construct a token pair consisting of one receive token and one transmit token.

fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>>

Construct a transmit token.

impl Drop for EthernetDMA<'_, '_>

fn drop(&mut self)

Executes the destructor for this type.