Remove transmit buffer references

Author: dtwood

tm4c129x-hal/src/ethernet.rs

@@ -371,9 +371,6 @@ impl EthernetDevice {
             w
         });
 
-        // unsafe {
-        //     EMACIntClear(emac0_base, EMACIntStatus(emac0_base, false));
-        // }
         unsafe {
             emac0.dmaim.write(|w| w.bits(0xffff_ffff));
             emac0.ephyim.write(|w| w.bits(0xffff_ffff));
@@ -396,41 +393,37 @@ impl<'a> Device<'a> for EthernetDevice {
             .iter()
             .find(|rxd| rxd.rdes0.read().own().bit_is_clear())?;
 
-        let (tx_descriptor, tx_buffer) = TX_DESCRIPTORS
+        let tx_descriptor = TX_DESCRIPTORS
             .iter()
-            .zip(unsafe { TX_BUFFERS.iter_mut() })
-            .find(|(txd, _)| txd.tdes0.read().own().bit_is_clear())?;
+            .find(|txd| txd.tdes0.read().own().bit_is_clear())?;
 
         Some((
             RxToken {
                 descriptor: rx_descriptor,
             },
             TxToken {
-                descriptor: tx_descriptor,
-                buffer: tx_buffer,
                 emac0: &self.emac0,
+                descriptor: tx_descriptor,
             },
         ))
     }
 
     fn transmit(&'a mut self) -> Option<Self::TxToken> {
-        let (tx_descriptor, tx_buffer) = TX_DESCRIPTORS
+        let tx_descriptor = TX_DESCRIPTORS
             .iter()
-            .zip(unsafe { TX_BUFFERS.iter_mut() })
-            .find(|(txd, _)| txd.tdes0.read().own().bit_is_clear())?;
+            .find(|txd| txd.tdes0.read().own().bit_is_clear())?;
 
         Some(TxToken {
-            descriptor: tx_descriptor,
-            buffer: tx_buffer,
             emac0: &self.emac0,
+            descriptor: tx_descriptor,
         })
     }
 
     fn capabilities(&self) -> DeviceCapabilities {
         let mut cap = DeviceCapabilities::default();
 
-        cap.max_transmission_unit = RX_BUFFER_SIZE;
-        cap.max_burst_size = Some(1);
+        cap.max_transmission_unit = TX_BUFFER_SIZE;
+        cap.max_burst_size = Some(NUM_TX_DESCRIPTORS);
 
         cap.checksum = ChecksumCapabilities::ignored();
         cap.checksum.ipv4 = Checksum::None;
@@ -453,56 +446,49 @@ impl<'a> phy::RxToken for RxToken<'a> {
     where
         F: FnOnce(&[u8]) -> smoltcp::Result<R>,
     {
-        let result;
+        // 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());
+            return Err(smoltcp::Error::Checksum);
+        }
 
-        unsafe {
-            // 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 {
-                // 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
-                {
-                    // What size is the received frame?
-                    let frame_len = (self.descriptor.rdes0.read().bits()
-                        & DES0_RX_STAT_FRAME_LENGTH_M)
-                        >> DES0_RX_STAT_FRAME_LENGTH_S;
-                    let data = core::slice::from_raw_parts(
-                        self.descriptor.rdes2.read().bits() as *mut u8,
-                        frame_len as usize,
-                    );
-                    result = f(data);
-                } else {
-                    result = Err(smoltcp::Error::Truncated);
-                }
-            } else {
-                result = 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());
+            return Err(smoltcp::Error::Truncated);
         }
 
+        let len = ((self.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 result = f(data);
+        self.descriptor.rdes0.write(|w| w.own().set_bit());
         result
     }
 }
 
 pub struct TxToken<'a> {
-    descriptor: &'a TDES,
-    buffer: &'a mut [u8],
     emac0: &'a EMAC0,
+    descriptor: &'a 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>,
     {
-        assert!(self.descriptor.tdes0.read().own().bit_is_clear());
-
-        assert!(len <= self.buffer.len());
-        let result = f(self.buffer);
+        assert!(len <= TX_BUFFER_SIZE);
+        let data = unsafe {
+            core::slice::from_raw_parts_mut(self.descriptor.tdes2.read().bits() as *mut u8, len)
+        };
+        let result = f(data);
 
-        // Fill in the packet size and pointer, and tell the transmitter to start work.
         unsafe {
             self.descriptor
                 .tdes1