libboard_zynq/smoltcp: default without ipv6 support

SZL netboot binary size too large with ipv6.
We can enable the ipv6 support in the runtime crate instead.

libasync/src/smoltcp/mod.rs

@@ -30,7 +30,7 @@ impl Sockets {
         let sockets = RefCell::new(SocketSet::new(sockets_storage));
 
         let wakers = RefCell::new(Vec::new());
-        
+
         let instance = Sockets {
             sockets,
             wakers,
@@ -57,7 +57,7 @@ impl Sockets {
     pub(crate) fn instance() -> &'static Self {
         unsafe { SOCKETS.as_ref().expect("Sockets") }
     }
-    
+
     fn poll<'b, 'c, 'e, D: for<'d> Device<'d>>(
         &self,
         iface: &mut EthernetInterface<'b, 'c, 'e, D>,
@@ -81,7 +81,14 @@ impl Sockets {
     /// TODO: this was called through eg. TcpStream, another poll()
     /// might want to send packets before sleeping for an interrupt.
     pub(crate) fn register_waker(waker: Waker) {
-        Self::instance().wakers.borrow_mut()
-            .push(waker);
+        let mut wakers = Self::instance().wakers.borrow_mut();
+        for (i, w) in wakers.iter().enumerate() {
+            if w.will_wake(&waker) {
+                let last = wakers.len() - 1;
+                wakers.swap(i, last);
+                return;
+            }
+        }
+        wakers.push(waker);
     }
 }

libboard_zynq/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2018"
 [features]
 target_zc706 = []
 target_cora_z7_10 = []
+ipv6 = [ "smoltcp/proto-ipv6" ]
 
 [dependencies]
 volatile-register = "0.2"
@@ -21,5 +22,5 @@ libcortex_a9 = { path = "../libcortex_a9" }
 
 [dependencies.smoltcp]
 version = "0.6"
-features = ["ethernet", "proto-ipv4", "proto-ipv6", "socket-tcp"]
+features = ["ethernet", "proto-ipv4", "socket-tcp"]
 default-features = false

libboard_zynq/src/eth/tx.rs

@@ -132,10 +132,8 @@ impl<'a> Drop for PktRef<'a> {
         dcc_slice(self.buffer);
 
         self.entry.word1.modify(|_, w| w.used(false));
-        if ! self.regs.tx_status.read().tx_go() {
-            // Start TX if not already running
-            self.regs.net_ctrl.modify(|_, w| w.start_tx(true));
-        }
+        // Start the TX engine
+        self.regs.net_ctrl.modify(|_, w| w.start_tx(true));
     }
 }
 
@@ -166,10 +164,7 @@ impl<'a> smoltcp::phy::TxToken for Token<'a> {
             None =>
                 Err(smoltcp::Error::Exhausted),
             Some(mut pktref) => {
-                let result = f(pktref.deref_mut());
-                // TODO: on result.is_err() don;t send
-                drop(pktref);
-                result
+                f(pktref.deref_mut())
             }
         }
     }

libcortex_a9/src/mutex.rs

@@ -3,7 +3,7 @@ use core::sync::atomic::{AtomicU32, Ordering};
 use core::cell::UnsafeCell;
 use super::{
     spin_lock_yield, notify_spin_lock,
-    asm::{dmb, enter_critical, exit_critical}
+    asm::{enter_critical, exit_critical}
 };
 
 const LOCKED: u32 = 1;
@@ -32,30 +32,27 @@ impl<T> Mutex<T> {
     /// Lock the Mutex, blocks when already locked
     pub fn lock(&self) -> MutexGuard<T> {
         let mut irq = unsafe { enter_critical() };
-        while self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::Acquire) != UNLOCKED {
+        while self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::AcqRel) != UNLOCKED {
             unsafe {
                 exit_critical(irq);
                 spin_lock_yield();
                 irq = enter_critical();
             }
         }
-        dmb();
         MutexGuard { mutex: self, irq }
     }
 
     pub fn try_lock(&self) -> Option<MutexGuard<T>> {
         let irq = unsafe { enter_critical() };
-        if self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::Acquire) != UNLOCKED {
+        if self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::AcqRel) != UNLOCKED {
             unsafe { exit_critical(irq) };
             None
         } else {
-            dmb();
             Some(MutexGuard { mutex: self, irq })
         }
     }
 
     fn unlock(&self) {
-        dmb();
         self.locked.store(UNLOCKED, Ordering::Release);
 
         notify_spin_lock();

libcortex_a9/src/sync_channel.rs

@@ -1,7 +1,6 @@
 use core::{
     pin::Pin,
     future::Future,
-    ptr::drop_in_place,
     sync::atomic::{AtomicPtr, AtomicUsize, Ordering},
     task::{Context, Poll},
 };
@@ -38,7 +37,7 @@ impl<'a, T> Sender<'a, T> where T: Clone {
             notify_spin_lock();
             if !prev.is_null() {
                 unsafe {
-                    drop_in_place(prev);
+                    Box::from_raw(prev);
                 }
             }
             Ok(())
@@ -92,7 +91,7 @@ impl<'a, T> Sender<'a, T> where T: Clone {
         for v in self.list.iter() {
             let original = v.swap(core::ptr::null_mut(), Ordering::Relaxed);
             if !original.is_null() {
-                drop_in_place(original);
+                Box::from_raw(original);
             }
         }
     }