Struct Ethernet 

pub struct Ethernet<'d, DM: DriverMode, P: Phy> { /* private fields */ }

EMAC Ethernet driver.

Implementations

impl<'d, P: Phy> Ethernet<'d, Blocking, P>

pub fn new<B: EthernetPinBundle + 'd, const RX: usize, const TX: usize>( eth: ETH<'d>, storage: &'d mut EthernetDmaStorage<RX, TX>, mac_addr: [u8; 6], phy: P, pins: B, ) -> Result<Self, Error>

Creates an Ethernet driver using RMII (RmiiPinBundle) or MII (MiiPinBundle).

pub fn receive(&mut self) -> Result<&mut [u8], Error>

Returns the received frame data if one is ready.

Call pop_rx after processing the frame.

pub fn pop_rx(&mut self)

Releases the current RX descriptor back to DMA.

pub fn into_async(self) -> Ethernet<'d, Async, P>

Converts to async mode.

The DMA ISR is bound and its interrupts enabled on the first link-up, not here: without a link there is no RX clock and the DMA would only report errors.

impl<'d, Dm: DriverMode, P: Phy> Ethernet<'d, Dm, P>

pub fn set_speed(&mut self, speed: Speed)

Configures the MAC for the given speed.

The speed must be one the wired interface can carry: MII and RMII top out at 100 Mbps, only RGMII reaches 1000 Mbps.

pub fn set_duplex(&mut self, duplex: Duplex)

Configures the MAC for the given duplex mode.

pub fn transmit(&mut self, frame: &[u8]) -> Result<(), Error>

Copies frame into the next TX slot and initiates transmission.

pub fn poll_link(&mut self, cx: Option<&mut Context<'_>>) -> LinkState

Returns the current PHY link state.

Async callers are encouraged to pass the context to allow the PHY driver to wake them when the link state needs to be re-polled.

pub fn mac_addr(&self) -> [u8; 6]

Returns the MAC address configured during construction.

impl<'d, P: Phy> Ethernet<'d, Async, P>

pub async fn transmit_async(&mut self, frame: &[u8]) -> Result<(), Error>

Asynchronously waits for a TX slot and transmits frame.

pub async fn receive_async(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Asynchronously waits for a frame and copies it into buf.

pub fn into_blocking(self) -> Ethernet<'d, Blocking, P>

Converts back to blocking mode, disabling all DMA interrupts.

pub fn tx_has_capacity(&self) -> bool

Returns whether there is at least one free TX descriptor slot.

pub fn peek_rx(&mut self) -> Option<&mut [u8]>

Peeks at the next received frame without consuming it.

Returns Some(data_slice) if a valid frame is ready, or None. The caller must call release_rx after processing.

pub fn release_rx(&mut self)

Releases the current RX descriptor back to the DMA engine.

Trait Implementations

impl<'d, P: Phy> Driver for Ethernet<'d, Async, P>

Available on crate feature unstable only.

fn link_state(&mut self, cx: &mut Context<'_>) -> LinkState

Polls the PHY and tracks the DMA interrupt state with the link.

DMA interrupts are only enabled while the link is up: with no link there is no RX clock, and error interrupts would otherwise fire continuously.

type RxToken<'a> = EthernetRxToken<'a, 'd> where Self: 'a

A token to receive a single network packet.

type TxToken<'a> = EthernetTxToken<'a, 'd> where Self: 'a

A token to transmit a single network packet.

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

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

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

Construct a transmit token.

fn capabilities(&self) -> Capabilities

Get a description of device capabilities.

fn hardware_address(&self) -> HardwareAddress

Get the device’s hardware address.

impl<'d, Dm: DriverMode + 'static, P: Phy> Driver for Ethernet<'d, Dm, P>

Available on crate feature unstable only.

fn capabilities(&self) -> Capabilities

Get a description of the device’s capabilities.

fn hardware_address(&self) -> HardwareAddress

Get the device’s hardware address.

fn link_state(&mut self) -> LinkState

Get the link state.

fn register_waker(&mut self, waker: &Waker) -> Result<(), NotSupported>

Available on crate feature async only.

Register a waker.

fn receive(&mut self) -> Option<PacketBuf>

Poll for a received frame.

fn can_transmit(&mut self) -> bool

Whether the device can transmit one frame right now.

fn transmit(&mut self, buffer: PacketBuf) -> Result<(), PacketBuf>

Queue a frame for transmission, transferring ownership of the buffer to the driver.

fn set_multicast_filter(&mut self, addrs: &[[u8; 6]])

Set the device’s multicast hardware address filter.