Correctly track DMA's current descriptor indexes

Author: dtwood

tm4c129x-hal/src/ethernet.rs

@@ -4,7 +4,7 @@ use crate::edes_old::*;
 use crate::sysctl;
 use byteorder::ByteOrder;
 use core::convert::TryInto;
-use smoltcp::phy::{self, Checksum, ChecksumCapabilities, Device, DeviceCapabilities};
+use smoltcp::phy::{self, ChecksumCapabilities, Device, DeviceCapabilities};
 use smoltcp::time::Instant;
 use tm4c129x::EMAC0;
 
@@ -240,6 +240,8 @@ fn emac_rx_enable(emac0: &EMAC0) {
 
 pub struct EthernetDevice {
     emac0: EMAC0,
+    next_rx_descriptor: &'static RDES,
+    next_tx_descriptor: &'static TDES,
 }
 
 impl EthernetDevice {
@@ -333,6 +335,7 @@ impl EthernetDevice {
             }
 
             for i in 0..NUM_RX_DESCRIPTORS {
+                RX_DESCRIPTORS[i].rdes0.write(|w| w.own().set_bit());
                 RX_DESCRIPTORS[i].rdes1.write(|w| {
                     w.bits(
                         DES1_RX_CTRL_CHAINED
@@ -349,7 +352,6 @@ impl EthernetDevice {
                         &RX_DESCRIPTORS[i + 1]
                     } as *const _ as u32)
                 });
-                RX_DESCRIPTORS[i].rdes0.write(|w| w.own().set_bit());
             }
 
             emac0
@@ -380,7 +382,11 @@ impl EthernetDevice {
         emac_rx_enable(&emac0);
         nvic.enable(tm4c129x::Interrupt::EMAC0);
 
-        EthernetDevice { emac0 }
+        EthernetDevice {
+            emac0,
+            next_rx_descriptor: &RX_DESCRIPTORS[0],
+            next_tx_descriptor: &TX_DESCRIPTORS[0],
+        }
     }
 }
 
@@ -389,33 +395,33 @@ impl<'a> Device<'a> for EthernetDevice {
     type TxToken = TxToken<'a>;
 
     fn receive(&'a mut self) -> Option<(Self::RxToken, Self::TxToken)> {
-        let rx_descriptor = RX_DESCRIPTORS
-            .iter()
-            .find(|rxd| rxd.rdes0.read().own().bit_is_clear())?;
-
-        let tx_descriptor = TX_DESCRIPTORS
-            .iter()
-            .find(|txd| txd.tdes0.read().own().bit_is_clear())?;
+        if self.next_rx_descriptor.rdes0.read().own().bit_is_set() {
+            return None;
+        }
+        if self.next_tx_descriptor.tdes0.read().own().bit_is_set() {
+            return None;
+        }
 
         Some((
             RxToken {
-                descriptor: rx_descriptor,
+                emac0: &self.emac0,
+                descriptor_pointer: &mut self.next_rx_descriptor,
             },
             TxToken {
                 emac0: &self.emac0,
-                descriptor: tx_descriptor,
+                descriptor_pointer: &mut self.next_tx_descriptor,
             },
         ))
     }
 
     fn transmit(&'a mut self) -> Option<Self::TxToken> {
-        let tx_descriptor = TX_DESCRIPTORS
-            .iter()
-            .find(|txd| txd.tdes0.read().own().bit_is_clear())?;
+        if self.next_tx_descriptor.tdes0.read().own().bit_is_set() {
+            return None;
+        }
 
         Some(TxToken {
             emac0: &self.emac0,
-            descriptor: tx_descriptor,
+            descriptor_pointer: &mut self.next_tx_descriptor,
         })
     }
 
@@ -438,69 +444,74 @@ impl<'a> Device<'a> for EthernetDevice {
 }
 
 pub struct RxToken<'a> {
-    descriptor: &'a RDES,
+    emac0: &'a EMAC0,
+    descriptor_pointer: &'a mut &'static RDES,
 }
 
 impl<'a> phy::RxToken for RxToken<'a> {
     fn consume<R, F>(self, _timestamp: Instant, f: F) -> smoltcp::Result<R>
     where
         F: FnOnce(&[u8]) -> smoltcp::Result<R>,
     {
+        let descriptor = *self.descriptor_pointer;
+
         // We own the receive descriptor so check to see if it contains a valid frame.
-        if self.descriptor.rdes0.read().bits() & DES0_RX_STAT_ERR == DES0_RX_STAT_ERR {
-            self.descriptor.rdes0.write(|w| w.own().set_bit());
+        if descriptor.rdes0.read().bits() & DES0_RX_STAT_ERR == DES0_RX_STAT_ERR {
+            descriptor.rdes0.write(|w| w.own().set_bit());
             return Err(smoltcp::Error::Checksum);
         }
 
         // We have a valid frame. First check that the "last descriptor" flag is set. We
         // sized the receive buffer such that it can always hold a valid frame so this
         // flag should never be clear at this point but...
-        if self.descriptor.rdes0.read().bits() & DES0_RX_STAT_LAST_DESC != DES0_RX_STAT_LAST_DESC {
-            self.descriptor.rdes0.write(|w| w.own().set_bit());
+        if descriptor.rdes0.read().bits() & DES0_RX_STAT_LAST_DESC != DES0_RX_STAT_LAST_DESC {
+            descriptor.rdes0.write(|w| w.own().set_bit());
             return Err(smoltcp::Error::Truncated);
         }
 
-        let len = ((self.descriptor.rdes0.read().bits() & DES0_RX_STAT_FRAME_LENGTH_M)
+        let len = ((descriptor.rdes0.read().bits() & DES0_RX_STAT_FRAME_LENGTH_M)
             >> DES0_RX_STAT_FRAME_LENGTH_S) as usize;
         assert!(len <= RX_BUFFER_SIZE);
-        let data = unsafe {
-            core::slice::from_raw_parts(self.descriptor.rdes2.read().bits() as *mut u8, len)
-        };
+        let data =
+            unsafe { core::slice::from_raw_parts(descriptor.rdes2.read().bits() as *mut u8, len) };
 
         let result = f(data);
-        self.descriptor.rdes0.write(|w| w.own().set_bit());
+
+        descriptor.rdes0.write(|w| w.own().set_bit());
+        self.emac0.rxpolld.write(|w| w);
+        *self.descriptor_pointer = unsafe { &*(descriptor.rdes3.read().bits() as *const _) };
         result
     }
 }
 
 pub struct TxToken<'a> {
     emac0: &'a EMAC0,
-    descriptor: &'a TDES,
+    descriptor_pointer: &'a mut &'static TDES,
 }
 
 impl<'a> phy::TxToken for TxToken<'a> {
     fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> smoltcp::Result<R>
     where
         F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
     {
+        let descriptor = *self.descriptor_pointer;
+
         assert!(len <= TX_BUFFER_SIZE);
+
         let data = unsafe {
-            core::slice::from_raw_parts_mut(self.descriptor.tdes2.read().bits() as *mut u8, len)
+            core::slice::from_raw_parts_mut(descriptor.tdes2.read().bits() as *mut u8, len)
         };
         let result = f(data);
 
         unsafe {
-            self.descriptor
+            descriptor
                 .tdes1
                 .write(|w| w.tbs1().bits(len.try_into().unwrap()));
         }
-        self.descriptor.tdes0.modify(|_, w| w.own().set_bit());
 
-        // Tell the DMA to reacquire the descriptor now that we've filled it in. This
-        // call is benign if the transmitter hasn't stalled and checking the state takes
-        // longer than just issuing a poll demand so we do this for all packets.
+        descriptor.tdes0.modify(|_, w| w.own().set_bit());
         self.emac0.txpolld.write(|w| w);
-
+        *self.descriptor_pointer = unsafe { &*(descriptor.tdes3.read().bits() as *const _) };
         result
     }
 }