From aff66b9695a70222b20c19585f04df2ecbabccb1 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 21 Jun 2024 20:17:39 +0200
Subject: [PATCH 01/21] nrf: add try_write to BufferedUarte.

---
 embassy-nrf/src/buffered_uarte.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs
index 159b4db8f..6d39597c6 100644
--- a/embassy-nrf/src/buffered_uarte.rs
+++ b/embassy-nrf/src/buffered_uarte.rs
@@ -358,6 +358,11 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
         self.tx.write(buf).await
     }
 
+    /// Try writing a buffer without waiting, returning how many bytes were written.
+    pub fn try_write(&mut self, buf: &[u8]) -> Result<usize, Error> {
+        self.tx.try_write(buf)
+    }
+
     /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
     pub async fn flush(&mut self) -> Result<(), Error> {
         self.tx.flush().await
@@ -482,6 +487,29 @@ impl<'d, U: UarteInstance> BufferedUarteTx<'d, U> {
         .await
     }
 
+    /// Try writing a buffer without waiting, returning how many bytes were written.
+    pub fn try_write(&mut self, buf: &[u8]) -> Result<usize, Error> {
+        //trace!("poll_write: {:?}", buf.len());
+        let s = U::buffered_state();
+        let mut tx = unsafe { s.tx_buf.writer() };
+
+        let tx_buf = tx.push_slice();
+        if tx_buf.is_empty() {
+            return Ok(0);
+        }
+
+        let n = min(tx_buf.len(), buf.len());
+        tx_buf[..n].copy_from_slice(&buf[..n]);
+        tx.push_done(n);
+
+        //trace!("poll_write: queued {:?}", n);
+
+        compiler_fence(Ordering::SeqCst);
+        U::Interrupt::pend();
+
+        Ok(n)
+    }
+
     /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
     pub async fn flush(&mut self) -> Result<(), Error> {
         poll_fn(move |cx| {

From 160e1c38ceab0ae8876c2bf5f12438edd4d9b018 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 21 Jun 2024 20:19:54 +0200
Subject: [PATCH 02/21] Add embassy-net-nrf91.

---
 embassy-net-nrf91/Cargo.toml                 |  37 +
 embassy-net-nrf91/README.md                  |   9 +
 embassy-net-nrf91/src/fmt.rs                 | 274 ++++++
 embassy-net-nrf91/src/lib.rs                 | 970 +++++++++++++++++++
 examples/nrf9160/.cargo/config.toml          |   3 +-
 examples/nrf9160/Cargo.toml                  |   5 +
 examples/nrf9160/memory.x                    |   8 +-
 examples/nrf9160/src/bin/modem_tcp_client.rs | 250 +++++
 8 files changed, 1553 insertions(+), 3 deletions(-)
 create mode 100644 embassy-net-nrf91/Cargo.toml
 create mode 100644 embassy-net-nrf91/README.md
 create mode 100644 embassy-net-nrf91/src/fmt.rs
 create mode 100644 embassy-net-nrf91/src/lib.rs
 create mode 100644 examples/nrf9160/src/bin/modem_tcp_client.rs

diff --git a/embassy-net-nrf91/Cargo.toml b/embassy-net-nrf91/Cargo.toml
new file mode 100644
index 000000000..2156346a4
--- /dev/null
+++ b/embassy-net-nrf91/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "embassy-net-nrf91"
+version = "0.1.0"
+edition = "2021"
+description = "embassy-net driver for Nordic nRF91-series cellular modems"
+keywords = ["embedded", "nrf91", "embassy-net", "cellular"]
+categories = ["embedded", "hardware-support", "no-std", "network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/embassy-rs/embassy"
+documentation = "https://docs.embassy.dev/embassy-net-nrf91"
+
+[features]
+defmt = [ "dep:defmt", "heapless/defmt-03" ]
+log = [ "dep:log" ]
+
+[dependencies]
+defmt = { version = "0.3", optional = true }
+log = { version = "0.4.14", optional = true }
+
+nrf9160-pac = { version = "0.12.0" }
+
+embassy-time = { version = "0.3.1", path = "../embassy-time" }
+embassy-sync = { version = "0.6.0", path = "../embassy-sync"}
+embassy-futures = { version = "0.1.0", path = "../embassy-futures"}
+embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel"}
+
+heapless = "0.8"
+embedded-io = "0.6.1"
+
+[package.metadata.embassy_docs]
+src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-nrf91-v$VERSION/embassy-net-nrf91/src/"
+src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-net-nrf91/src/"
+target = "thumbv7em-none-eabi"
+features = ["defmt"]
+
+[package.metadata.docs.rs]
+features = ["defmt"]
diff --git a/embassy-net-nrf91/README.md b/embassy-net-nrf91/README.md
new file mode 100644
index 000000000..30da71787
--- /dev/null
+++ b/embassy-net-nrf91/README.md
@@ -0,0 +1,9 @@
+# nRF91 `embassy-net` integration
+
+[`embassy-net`](https://crates.io/crates/embassy-net) driver for Nordic nRF91-series cellular modems.
+
+See the [`examples`](https://github.com/embassy-rs/embassy/tree/main/examples/nrf9160) directory for usage examples with the nRF9160.
+
+## Interoperability
+
+This crate can run on any executor.
diff --git a/embassy-net-nrf91/src/fmt.rs b/embassy-net-nrf91/src/fmt.rs
new file mode 100644
index 000000000..35b929fde
--- /dev/null
+++ b/embassy-net-nrf91/src/fmt.rs
@@ -0,0 +1,274 @@
+#![macro_use]
+#![allow(unused)]
+
+use core::fmt::{Debug, Display, LowerHex};
+
+#[cfg(all(feature = "defmt", feature = "log"))]
+compile_error!("You may not enable both `defmt` and `log` features.");
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::todo!($($x)*);
+        }
+    };
+}
+
+#[cfg(not(feature = "defmt"))]
+#[collapse_debuginfo(yes)]
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        ::core::unreachable!($($x)*)
+    };
+}
+
+#[cfg(feature = "defmt")]
+#[collapse_debuginfo(yes)]
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        ::defmt::unreachable!($($x)*)
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::panic!($($x)*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! trace {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::trace!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::trace!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::debug!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! info {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::info!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::info!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! warn {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::warn!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::warn!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! error {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::error!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::error!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[cfg(feature = "defmt")]
+#[collapse_debuginfo(yes)]
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        ::defmt::unwrap!($($x)*)
+    };
+}
+
+#[cfg(not(feature = "defmt"))]
+#[collapse_debuginfo(yes)]
+macro_rules! unwrap {
+    ($arg:expr) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
+            }
+        }
+    };
+    ($arg:expr, $($msg:expr),+ $(,)? ) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct NoneError;
+
+pub trait Try {
+    type Ok;
+    type Error;
+    fn into_result(self) -> Result<Self::Ok, Self::Error>;
+}
+
+impl<T> Try for Option<T> {
+    type Ok = T;
+    type Error = NoneError;
+
+    #[inline]
+    fn into_result(self) -> Result<T, NoneError> {
+        self.ok_or(NoneError)
+    }
+}
+
+impl<T, E> Try for Result<T, E> {
+    type Ok = T;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Self {
+        self
+    }
+}
+
+pub(crate) struct Bytes<'a>(pub &'a [u8]);
+
+impl<'a> Debug for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl<'a> Display for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl<'a> LowerHex for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+#[cfg(feature = "defmt")]
+impl<'a> defmt::Format for Bytes<'a> {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "{:02x}", self.0)
+    }
+}
diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
new file mode 100644
index 000000000..62ade6dd3
--- /dev/null
+++ b/embassy-net-nrf91/src/lib.rs
@@ -0,0 +1,970 @@
+#![no_std]
+#![doc = include_str!("../README.md")]
+#![warn(missing_docs)]
+
+// must be first
+mod fmt;
+
+use core::cell::RefCell;
+use core::future::poll_fn;
+use core::marker::PhantomData;
+use core::mem::{self, MaybeUninit};
+use core::ptr::{self, addr_of, addr_of_mut, copy_nonoverlapping};
+use core::slice;
+use core::sync::atomic::{compiler_fence, fence, Ordering};
+use core::task::{Poll, Waker};
+
+use embassy_net_driver_channel as ch;
+use embassy_sync::waitqueue::{AtomicWaker, WakerRegistration};
+use heapless::Vec;
+use nrf9160_pac as pac;
+use pac::NVIC;
+
+const RX_SIZE: usize = 8 * 1024;
+const TRACE_SIZE: usize = 16 * 1024;
+const MTU: usize = 1500;
+
+/// Network driver.
+///
+/// This is the type you have to pass to `embassy-net` when creating the network stack.
+pub type NetDriver<'a> = ch::Device<'a, MTU>;
+
+static WAKER: AtomicWaker = AtomicWaker::new();
+
+/// Call this function on IPC IRQ
+pub fn on_ipc_irq() {
+    let ipc = unsafe { &*pac::IPC_NS::ptr() };
+
+    trace!("irq");
+
+    ipc.inten.write(|w| w);
+    WAKER.wake();
+}
+
+struct Allocator<'a> {
+    start: *mut u8,
+    end: *mut u8,
+    _phantom: PhantomData<&'a mut u8>,
+}
+
+impl<'a> Allocator<'a> {
+    fn alloc_bytes(&mut self, size: usize) -> &'a mut [MaybeUninit<u8>] {
+        // safety: both pointers come from the same allocation.
+        let available_size = unsafe { self.end.offset_from(self.start) } as usize;
+        if size > available_size {
+            panic!("out of memory")
+        }
+
+        // safety: we've checked above this doesn't go out of bounds.
+        let p = self.start;
+        self.start = unsafe { p.add(size) };
+
+        // safety: we've checked the pointer is in-bounds.
+        unsafe { slice::from_raw_parts_mut(p as *mut _, size) }
+    }
+
+    fn alloc<T>(&mut self) -> &'a mut MaybeUninit<T> {
+        let align = mem::align_of::<T>();
+        let size = mem::size_of::<T>();
+
+        let align_size = match (self.start as usize) % align {
+            0 => 0,
+            n => align - n,
+        };
+
+        // safety: both pointers come from the same allocation.
+        let available_size = unsafe { self.end.offset_from(self.start) } as usize;
+        if align_size + size > available_size {
+            panic!("out of memory")
+        }
+
+        // safety: we've checked above this doesn't go out of bounds.
+        let p = unsafe { self.start.add(align_size) };
+        self.start = unsafe { p.add(size) };
+
+        // safety: we've checked the pointer is aligned and in-bounds.
+        unsafe { &mut *(p as *mut _) }
+    }
+}
+
+/// Create a new nRF91 embassy-net driver.
+pub async fn new<'a, TW: embedded_io::Write>(
+    state: &'a mut State,
+    shmem: &'a mut [MaybeUninit<u8>],
+    trace_writer: TW,
+) -> (NetDriver<'a>, Control<'a>, Runner<'a, TW>) {
+    let shmem_len = shmem.len();
+    let shmem_ptr = shmem.as_mut_ptr() as *mut u8;
+
+    const SPU_REGION_SIZE: usize = 8192; // 8kb
+    assert!(shmem_len != 0);
+    assert!(
+        shmem_len % SPU_REGION_SIZE == 0,
+        "shmem length must be a multiple of 8kb"
+    );
+    assert!(
+        (shmem_ptr as usize) % SPU_REGION_SIZE == 0,
+        "shmem length must be a multiple of 8kb"
+    );
+    assert!(
+        (shmem_ptr as usize + shmem_len) < 0x2002_0000,
+        "shmem must be in the lower 128kb of RAM"
+    );
+
+    let spu = unsafe { &*pac::SPU_S::ptr() };
+    debug!("Setting IPC RAM as nonsecure...");
+    let region_start = (shmem_ptr as usize - 0x2000_0000) / SPU_REGION_SIZE;
+    let region_end = region_start + shmem_len / SPU_REGION_SIZE;
+    for i in region_start..region_end {
+        spu.ramregion[i].perm.write(|w| {
+            w.execute().set_bit();
+            w.write().set_bit();
+            w.read().set_bit();
+            w.secattr().clear_bit();
+            w.lock().clear_bit();
+            w
+        })
+    }
+
+    spu.periphid[42].perm.write(|w| w.secattr().non_secure());
+
+    let mut alloc = Allocator {
+        start: shmem_ptr,
+        end: unsafe { shmem_ptr.add(shmem_len) },
+        _phantom: PhantomData,
+    };
+
+    let ipc = unsafe { &*pac::IPC_NS::ptr() };
+    let power = unsafe { &*pac::POWER_S::ptr() };
+
+    let cb: &mut ControlBlock = alloc.alloc().write(unsafe { mem::zeroed() });
+    let rx = alloc.alloc_bytes(RX_SIZE);
+    let trace = alloc.alloc_bytes(TRACE_SIZE);
+
+    cb.version = 0x00010000;
+    cb.rx_base = rx.as_mut_ptr() as _;
+    cb.rx_size = RX_SIZE;
+    cb.control_list_ptr = &mut cb.lists[0];
+    cb.data_list_ptr = &mut cb.lists[1];
+    cb.modem_info_ptr = &mut cb.modem_info;
+    cb.trace_ptr = &mut cb.trace;
+    cb.lists[0].len = LIST_LEN;
+    cb.lists[1].len = LIST_LEN;
+    cb.trace.base = trace.as_mut_ptr() as _;
+    cb.trace.size = TRACE_SIZE;
+
+    ipc.gpmem[0].write(|w| unsafe { w.bits(cb as *mut _ as u32) });
+    ipc.gpmem[1].write(|w| unsafe { w.bits(0) });
+
+    // connect task/event i to channel i
+    for i in 0..8 {
+        ipc.send_cnf[i].write(|w| unsafe { w.bits(1 << i) });
+        ipc.receive_cnf[i].write(|w| unsafe { w.bits(1 << i) });
+    }
+
+    compiler_fence(Ordering::SeqCst);
+
+    // POWER.LTEMODEM.STARTN = 0
+    // The reg is missing in the PAC??
+    let startn = unsafe { (power as *const _ as *mut u32).add(0x610 / 4) };
+    unsafe { startn.write_volatile(0) }
+
+    unsafe { NVIC::unmask(pac::Interrupt::IPC) };
+
+    let state_inner = &*state.inner.write(RefCell::new(StateInner {
+        init: false,
+        init_waker: WakerRegistration::new(),
+        cb,
+        requests: [const { None }; REQ_COUNT],
+        next_req_serial: 0x12345678,
+
+        rx_control_list: ptr::null_mut(),
+        rx_data_list: ptr::null_mut(),
+        rx_seq_no: 0,
+        rx_check: PointerChecker {
+            start: rx.as_mut_ptr() as *mut u8,
+            end: (rx.as_mut_ptr() as *mut u8).wrapping_add(RX_SIZE),
+        },
+
+        tx_seq_no: 0,
+        tx_buf_used: [false; TX_BUF_COUNT],
+
+        trace_chans: Vec::new(),
+        trace_check: PointerChecker {
+            start: trace.as_mut_ptr() as *mut u8,
+            end: (trace.as_mut_ptr() as *mut u8).wrapping_add(TRACE_SIZE),
+        },
+    }));
+
+    let control = Control { state: state_inner };
+
+    let (ch_runner, device) = ch::new(&mut state.ch, ch::driver::HardwareAddress::Ip);
+    let state_ch = ch_runner.state_runner();
+    state_ch.set_link_state(ch::driver::LinkState::Up);
+
+    let runner = Runner {
+        ch: ch_runner,
+        state: state_inner,
+        trace_writer,
+    };
+
+    (device, control, runner)
+}
+
+/// Shared state for the drivver.
+pub struct State {
+    ch: ch::State<MTU, 4, 4>,
+    inner: MaybeUninit<RefCell<StateInner>>,
+}
+
+impl State {
+    /// Create a new State.
+    pub const fn new() -> Self {
+        Self {
+            ch: ch::State::new(),
+            inner: MaybeUninit::uninit(),
+        }
+    }
+}
+
+const TX_BUF_COUNT: usize = 4;
+const TX_BUF_SIZE: usize = 1024;
+
+struct TraceChannelInfo {
+    ptr: *mut TraceChannel,
+    start: *mut u8,
+    end: *mut u8,
+}
+
+const REQ_COUNT: usize = 4;
+
+struct PendingRequest {
+    req_serial: u32,
+    resp_msg: *mut Message,
+    waker: Waker,
+}
+
+struct StateInner {
+    init: bool,
+    init_waker: WakerRegistration,
+
+    cb: *mut ControlBlock,
+    requests: [Option<PendingRequest>; REQ_COUNT],
+    next_req_serial: u32,
+
+    rx_control_list: *mut List,
+    rx_data_list: *mut List,
+    rx_seq_no: u16,
+    rx_check: PointerChecker,
+
+    tx_seq_no: u16,
+    tx_buf_used: [bool; TX_BUF_COUNT],
+
+    trace_chans: Vec<TraceChannelInfo, TRACE_CHANNEL_COUNT>,
+    trace_check: PointerChecker,
+}
+
+impl StateInner {
+    fn poll(&mut self, trace_writer: &mut impl embedded_io::Write, ch: &mut ch::Runner<MTU>) {
+        trace!("poll!");
+        let ipc = unsafe { &*pac::IPC_NS::ptr() };
+
+        if ipc.events_receive[0].read().bits() != 0 {
+            ipc.events_receive[0].reset();
+            trace!("ipc 0");
+        }
+
+        if ipc.events_receive[2].read().bits() != 0 {
+            ipc.events_receive[2].reset();
+            trace!("ipc 2");
+
+            if !self.init {
+                let desc = unsafe { addr_of!((*self.cb).modem_info).read_volatile() };
+                assert_eq!(desc.version, 1);
+
+                self.rx_check.check_mut(desc.control_list_ptr);
+                self.rx_check.check_mut(desc.data_list_ptr);
+
+                self.rx_control_list = desc.control_list_ptr;
+                self.rx_data_list = desc.data_list_ptr;
+                let rx_control_len = unsafe { addr_of!((*self.rx_control_list).len).read_volatile() };
+                let rx_data_len = unsafe { addr_of!((*self.rx_data_list).len).read_volatile() };
+                assert_eq!(rx_control_len, LIST_LEN);
+                assert_eq!(rx_data_len, LIST_LEN);
+                self.init = true;
+
+                debug!("IPC initialized OK!");
+                self.init_waker.wake();
+            }
+        }
+
+        if ipc.events_receive[4].read().bits() != 0 {
+            ipc.events_receive[4].reset();
+            trace!("ipc 4");
+
+            loop {
+                let list = unsafe { &mut *self.rx_control_list };
+                let control_work = self.process(list, true, ch);
+                let list = unsafe { &mut *self.rx_data_list };
+                let data_work = self.process(list, false, ch);
+                if !control_work && !data_work {
+                    break;
+                }
+            }
+        }
+
+        if ipc.events_receive[6].read().bits() != 0 {
+            ipc.events_receive[6].reset();
+            trace!("ipc 6");
+        }
+
+        if ipc.events_receive[7].read().bits() != 0 {
+            ipc.events_receive[7].reset();
+            trace!("ipc 7: trace");
+
+            let msg = unsafe { addr_of!((*self.cb).trace.rx_state).read_volatile() };
+            if msg != 0 {
+                trace!("trace msg {}", msg);
+                match msg {
+                    0 => unreachable!(),
+                    1 => {
+                        let ctx = unsafe { addr_of!((*self.cb).trace.rx_ptr).read_volatile() } as *mut TraceContext;
+                        debug!("trace init: {:?}", ctx);
+                        self.trace_check.check(ctx);
+                        let chans = unsafe { addr_of!((*ctx).chans).read_volatile() };
+                        for chan_ptr in chans {
+                            let chan = self.trace_check.check_read(chan_ptr);
+                            self.trace_check.check(chan.start);
+                            self.trace_check.check(chan.end);
+                            assert!(chan.start < chan.end);
+                            self.trace_chans
+                                .push(TraceChannelInfo {
+                                    ptr: chan_ptr,
+                                    start: chan.start,
+                                    end: chan.end,
+                                })
+                                .map_err(|_| ())
+                                .unwrap()
+                        }
+                    }
+                    2 => {
+                        for chan_info in &self.trace_chans {
+                            let read_ptr = unsafe { addr_of!((*chan_info.ptr).read_ptr).read_volatile() };
+                            let write_ptr = unsafe { addr_of!((*chan_info.ptr).write_ptr).read_volatile() };
+                            assert!(read_ptr >= chan_info.start && read_ptr <= chan_info.end);
+                            assert!(write_ptr >= chan_info.start && write_ptr <= chan_info.end);
+                            if read_ptr != write_ptr {
+                                let id = unsafe { addr_of!((*chan_info.ptr).id).read_volatile() };
+                                fence(Ordering::SeqCst); // synchronize volatile accesses with the slice access.
+                                if read_ptr < write_ptr {
+                                    Self::handle_trace(trace_writer, id, unsafe {
+                                        slice::from_raw_parts(read_ptr, write_ptr.offset_from(read_ptr) as _)
+                                    });
+                                } else {
+                                    Self::handle_trace(trace_writer, id, unsafe {
+                                        slice::from_raw_parts(read_ptr, chan_info.end.offset_from(read_ptr) as _)
+                                    });
+                                    Self::handle_trace(trace_writer, id, unsafe {
+                                        slice::from_raw_parts(
+                                            chan_info.start,
+                                            write_ptr.offset_from(chan_info.start) as _,
+                                        )
+                                    });
+                                }
+                                fence(Ordering::SeqCst); // synchronize volatile accesses with the slice access.
+                                unsafe { addr_of_mut!((*chan_info.ptr).read_ptr).write_volatile(write_ptr) };
+                            }
+                        }
+                    }
+                    _ => warn!("unknown trace msg {}", msg),
+                }
+                unsafe { addr_of_mut!((*self.cb).trace.rx_state).write_volatile(0) };
+            }
+        }
+
+        ipc.intenset.write(|w| {
+            w.receive0().set_bit();
+            w.receive2().set_bit();
+            w.receive4().set_bit();
+            w.receive6().set_bit();
+            w.receive7().set_bit();
+            w
+        });
+    }
+
+    fn handle_trace(writer: &mut impl embedded_io::Write, id: u8, data: &[u8]) {
+        trace!("trace: {} {}", id, data.len());
+        let mut header = [0u8; 5];
+        header[0] = 0xEF;
+        header[1] = 0xBE;
+        header[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
+        header[4] = id;
+        writer.write_all(&header).unwrap();
+        writer.write_all(data).unwrap();
+    }
+
+    fn process(&mut self, list: *mut List, is_control: bool, ch: &mut ch::Runner<MTU>) -> bool {
+        let mut did_work = false;
+        for i in 0..LIST_LEN {
+            let item_ptr = unsafe { addr_of_mut!((*list).items[i]) };
+            let preamble = unsafe { addr_of!((*item_ptr).state).read_volatile() };
+            if preamble & 0xFF == 0x01 && preamble >> 16 == self.rx_seq_no as u32 {
+                let msg_ptr = unsafe { addr_of!((*item_ptr).message).read_volatile() };
+                let msg = self.rx_check.check_read(msg_ptr);
+
+                debug!("rx seq {} msg: {:?}", preamble >> 16, msg);
+
+                if is_control {
+                    self.handle_control(&msg);
+                } else {
+                    self.handle_data(&msg, ch);
+                }
+
+                unsafe { addr_of_mut!((*item_ptr).state).write_volatile(0x03) };
+                self.rx_seq_no = self.rx_seq_no.wrapping_add(1);
+
+                did_work = true;
+            }
+        }
+        did_work
+    }
+
+    fn find_free_message(&mut self, ch: usize) -> Option<usize> {
+        for i in 0..LIST_LEN {
+            let preamble = unsafe { addr_of!((*self.cb).lists[ch].items[i].state).read_volatile() };
+            if matches!(preamble & 0xFF, 0 | 3) {
+                trace!("using tx msg idx {}", i);
+                return Some(i);
+            }
+        }
+        return None;
+    }
+
+    fn find_free_tx_buf(&mut self) -> Option<usize> {
+        for i in 0..TX_BUF_COUNT {
+            if !self.tx_buf_used[i] {
+                trace!("using tx buf idx {}", i);
+                return Some(i);
+            }
+        }
+        return None;
+    }
+
+    fn send_message(&mut self, msg: &mut Message, data: &[u8]) {
+        if data.is_empty() {
+            msg.data = ptr::null_mut();
+            msg.data_len = 0;
+        } else {
+            assert!(data.len() <= TX_BUF_SIZE);
+            let buf_idx = self.find_free_tx_buf().unwrap(); // TODO handle out of bufs
+            let buf = unsafe { addr_of_mut!((*self.cb).tx_bufs[buf_idx]) } as *mut u8;
+            unsafe { copy_nonoverlapping(data.as_ptr(), buf, data.len()) }
+            msg.data = buf;
+            msg.data_len = data.len();
+            self.tx_buf_used[buf_idx] = true;
+
+            fence(Ordering::SeqCst); // synchronize copy_nonoverlapping (non-volatile) with volatile writes below.
+        }
+
+        // TODO free data buf if send_message_raw fails.
+        self.send_message_raw(msg);
+    }
+
+    fn send_message_raw(&mut self, msg: &Message) {
+        let (ch, ipc_ch) = match msg.channel {
+            1 => (0, 1), // control
+            2 => (1, 3), // data
+            _ => unreachable!(),
+        };
+
+        // allocate a msg.
+        let idx = self.find_free_message(ch).unwrap(); // TODO handle list full
+
+        debug!("tx seq {} msg: {:?}", self.tx_seq_no, msg);
+
+        let msg_slot = unsafe { addr_of_mut!((*self.cb).msgs[ch][idx]) };
+        unsafe { msg_slot.write_volatile(*msg) }
+        let list_item = unsafe { addr_of_mut!((*self.cb).lists[ch].items[idx]) };
+        unsafe { addr_of_mut!((*list_item).message).write_volatile(msg_slot) }
+        unsafe { addr_of_mut!((*list_item).state).write_volatile((self.tx_seq_no as u32) << 16 | 0x01) }
+        self.tx_seq_no = self.tx_seq_no.wrapping_add(1);
+
+        let ipc = unsafe { &*pac::IPC_NS::ptr() };
+        ipc.tasks_send[ipc_ch].write(|w| unsafe { w.bits(1) });
+    }
+
+    fn handle_control(&mut self, msg: &Message) {
+        match msg.id >> 16 {
+            1 => debug!("control msg: modem ready"),
+            2 => self.handle_control_free(msg.data),
+            _ => warn!("unknown control message id {:08x}", msg.id),
+        }
+    }
+
+    fn handle_control_free(&mut self, ptr: *mut u8) {
+        let base = unsafe { addr_of!((*self.cb).tx_bufs) } as usize;
+        let ptr = ptr as usize;
+
+        if ptr < base {
+            warn!("control free bad pointer {:08x}", ptr);
+            return;
+        }
+
+        let diff = ptr - base;
+        let idx = diff / TX_BUF_SIZE;
+
+        if idx >= TX_BUF_COUNT || idx * TX_BUF_SIZE != diff {
+            warn!("control free bad pointer {:08x}", ptr);
+            return;
+        }
+
+        trace!("control free pointer {:08x} idx {}", ptr, idx);
+        if !self.tx_buf_used[idx] {
+            warn!(
+                "control free pointer {:08x} idx {}: buffer was already free??",
+                ptr, idx
+            );
+        }
+        self.tx_buf_used[idx] = false;
+    }
+
+    fn handle_data(&mut self, msg: &Message, ch: &mut ch::Runner<MTU>) {
+        if !msg.data.is_null() {
+            self.rx_check.check_length(msg.data, msg.data_len);
+        }
+
+        let freed = match msg.id & 0xFFFF {
+            // AT
+            3 => {
+                match msg.id >> 16 {
+                    // AT request ack
+                    2 => false,
+                    // AT response
+                    3 => self.handle_resp(msg),
+                    // AT notification
+                    4 => false,
+                    x => {
+                        warn!("received unknown AT kind {}", x);
+                        false
+                    }
+                }
+            }
+            // IP
+            4 => {
+                match msg.id >> 28 {
+                    // IP response
+                    8 => self.handle_resp(msg),
+                    // IP notification
+                    9 => match (msg.id >> 16) & 0xFFF {
+                        // IP receive notification
+                        1 => {
+                            if let Some(buf) = ch.try_rx_buf() {
+                                let mut len = msg.data_len;
+                                if len > buf.len() {
+                                    warn!("truncating rx'd packet from {} to {} bytes", len, buf.len());
+                                    len = buf.len();
+                                }
+                                fence(Ordering::SeqCst); // synchronize volatile accesses with the nonvolatile copy_nonoverlapping.
+                                unsafe { ptr::copy_nonoverlapping(msg.data, buf.as_mut_ptr(), len) }
+                                fence(Ordering::SeqCst); // synchronize volatile accesses with the nonvolatile copy_nonoverlapping.
+                                ch.rx_done(len);
+                            }
+                            false
+                        }
+                        _ => false,
+                    },
+                    x => {
+                        warn!("received unknown IP kind {}", x);
+                        false
+                    }
+                }
+            }
+            x => {
+                warn!("received unknown kind {}", x);
+                false
+            }
+        };
+
+        if !freed {
+            self.send_free(msg);
+        }
+    }
+
+    fn handle_resp(&mut self, msg: &Message) -> bool {
+        let req_serial = u32::from_le_bytes(msg.param[0..4].try_into().unwrap());
+        if req_serial == 0 {
+            return false;
+        }
+
+        for optr in &mut self.requests {
+            if let Some(r) = optr {
+                if r.req_serial == req_serial {
+                    let r = optr.take().unwrap();
+                    unsafe { r.resp_msg.write(*msg) }
+                    r.waker.wake();
+                    *optr = None;
+                    return true;
+                }
+            }
+        }
+
+        warn!(
+            "resp with id {} serial {} doesn't match any pending req",
+            msg.id, req_serial
+        );
+        false
+    }
+
+    fn send_free(&mut self, msg: &Message) {
+        if msg.data.is_null() {
+            return;
+        }
+
+        let mut free_msg: Message = unsafe { mem::zeroed() };
+        free_msg.channel = 1; // control
+        free_msg.id = 0x20001; // free
+        free_msg.data = msg.data;
+        free_msg.data_len = msg.data_len;
+
+        self.send_message_raw(&free_msg);
+    }
+}
+
+struct PointerChecker {
+    start: *mut u8,
+    end: *mut u8,
+}
+
+impl PointerChecker {
+    // check the pointer is in bounds in the arena, panic otherwise.
+    fn check_length(&self, ptr: *const u8, len: usize) {
+        assert!(ptr as usize >= self.start as usize);
+        let end_ptr = (ptr as usize).checked_add(len).unwrap();
+        assert!(end_ptr <= self.end as usize);
+    }
+
+    // check the pointer is in bounds in the arena, panic otherwise.
+    fn check<T>(&self, ptr: *const T) {
+        assert!(ptr.is_aligned());
+        self.check_length(ptr as *const u8, mem::size_of::<T>());
+    }
+
+    // check the pointer is in bounds in the arena, panic otherwise.
+    fn check_read<T>(&self, ptr: *const T) -> T {
+        self.check(ptr);
+        unsafe { ptr.read_volatile() }
+    }
+
+    // check the pointer is in bounds in the arena, panic otherwise.
+    fn check_mut<T>(&self, ptr: *mut T) {
+        self.check(ptr as *const T)
+    }
+}
+
+/// Control handle for the driver.
+///
+/// You can use this object to control the modem at runtime, such as running AT commands.
+pub struct Control<'a> {
+    state: &'a RefCell<StateInner>,
+}
+
+impl<'a> Control<'a> {
+    /// Wait for modem IPC to be initialized.
+    pub async fn wait_init(&self) {
+        poll_fn(|cx| {
+            let mut state = self.state.borrow_mut();
+            if state.init {
+                return Poll::Ready(());
+            }
+            state.init_waker.register(cx.waker());
+            Poll::Pending
+        })
+        .await
+    }
+
+    async fn request(&self, msg: &mut Message, req_data: &[u8], resp_data: &mut [u8]) -> usize {
+        // get waker
+        let waker = poll_fn(|cx| Poll::Ready(cx.waker().clone())).await;
+
+        // Send request
+        let mut state = self.state.borrow_mut();
+        let mut req_serial = state.next_req_serial;
+        if msg.id & 0xFFFF == 3 {
+            // AT response seems to keep only the lower 8 bits. Others do keep the full 32 bits..??
+            req_serial &= 0xFF;
+        }
+
+        // increment next_req_serial, skip zero because we use it as an "ignore" value.
+        // We have to skip when the *lowest byte* is zero because AT responses.
+        state.next_req_serial = state.next_req_serial.wrapping_add(1);
+        if state.next_req_serial & 0xFF == 0 {
+            state.next_req_serial = state.next_req_serial.wrapping_add(1);
+        }
+
+        msg.param[0..4].copy_from_slice(&req_serial.to_le_bytes());
+        state.send_message(msg, req_data);
+
+        // Setup the pending request state.
+        let (req_slot_idx, req_slot) = state
+            .requests
+            .iter_mut()
+            .enumerate()
+            .find(|(_, x)| x.is_none())
+            .unwrap();
+        msg.id = 0; // zero out id, so when it becomes nonzero we know the req is done.
+        let msg_ptr: *mut Message = msg;
+        *req_slot = Some(PendingRequest {
+            req_serial,
+            resp_msg: msg_ptr,
+            waker,
+        });
+
+        drop(state); // don't borrow state across awaits.
+
+        // On cancel, unregister the request slot.
+        let _drop = OnDrop::new(|| {
+            // Remove request slot.
+            let mut state = self.state.borrow_mut();
+            let slot = &mut state.requests[req_slot_idx];
+            if let Some(s) = slot {
+                if s.req_serial == req_serial {
+                    *slot = None;
+                }
+            }
+
+            // If cancelation raced with actually receiving the response,
+            // we own the data, so we have to free it.
+            let msg = unsafe { &mut *msg_ptr };
+            if msg.id != 0 {
+                state.send_free(msg);
+            }
+        });
+        // Wait for response.
+        poll_fn(|_| {
+            // we have to use the raw pointer and not the original reference `msg`
+            // because that'd invalidate the raw ptr that's still stored in `req_slot`.
+            if unsafe { (*msg_ptr).id } != 0 {
+                Poll::Ready(())
+            } else {
+                Poll::Pending
+            }
+        })
+        .await;
+        _drop.defuse();
+
+        if msg.data.is_null() {
+            // no response data.
+            return 0;
+        }
+
+        // Copy response data out, if any.
+        // Pointer was validated in StateInner::handle_data().
+        let mut len = msg.data_len;
+        if len > resp_data.len() {
+            warn!("truncating response data from {} to {}", len, resp_data.len());
+            len = resp_data.len();
+        }
+        fence(Ordering::SeqCst); // synchronize volatile accesses with the nonvolatile copy_nonoverlapping.
+        unsafe { ptr::copy_nonoverlapping(msg.data, resp_data.as_mut_ptr(), len) }
+        fence(Ordering::SeqCst); // synchronize volatile accesses with the nonvolatile copy_nonoverlapping.
+        self.state.borrow_mut().send_free(msg);
+        len
+    }
+
+    /// Run an AT command.
+    ///
+    /// The response is written in `resp` and its length returned.
+    pub async fn at_command(&self, req: &[u8], resp: &mut [u8]) -> usize {
+        let mut msg: Message = unsafe { mem::zeroed() };
+        msg.channel = 2; // data
+        msg.id = 0x0001_0003; // AT command
+        msg.param_len = 4;
+
+        self.request(&mut msg, req, resp).await
+    }
+
+    /// Open the raw socket used for sending/receiving IP packets.
+    ///
+    /// This must be done after `AT+CFUN=1` (?)
+    pub async fn open_raw_socket(&self) {
+        let mut msg: Message = unsafe { mem::zeroed() };
+        msg.channel = 2; // data
+        msg.id = 0x7001_0004; // open socket
+        msg.param_len = 20;
+
+        let param = [
+            0xFF, 0xFF, 0xFF, 0xFF, // req_serial
+            0xFF, 0xFF, 0xFF, 0xFF, // ???
+            0x05, 0x00, 0x00, 0x00, // family
+            0x03, 0x00, 0x00, 0x00, // type
+            0x00, 0x00, 0x00, 0x00, // protocol
+        ];
+        msg.param[..param.len()].copy_from_slice(&param);
+
+        self.request(&mut msg, &[], &mut []).await;
+
+        assert_eq!(msg.id, 0x80010004);
+        assert!(msg.param_len >= 12);
+        let status = u32::from_le_bytes(msg.param[8..12].try_into().unwrap());
+        assert_eq!(status, 0);
+        assert_eq!(msg.param_len, 16);
+        let fd = u32::from_le_bytes(msg.param[12..16].try_into().unwrap());
+        debug!("got FD: {}", fd);
+    }
+}
+
+/// Background runner for the driver.
+pub struct Runner<'a, TW: embedded_io::Write> {
+    ch: ch::Runner<'a, MTU>,
+    state: &'a RefCell<StateInner>,
+    trace_writer: TW,
+}
+
+impl<'a, TW: embedded_io::Write> Runner<'a, TW> {
+    /// Run the driver operation in the background.
+    ///
+    /// You must run this in a background task, concurrently with all network operations.
+    pub async fn run(mut self) -> ! {
+        poll_fn(|cx| {
+            WAKER.register(cx.waker());
+
+            let mut state = self.state.borrow_mut();
+            state.poll(&mut self.trace_writer, &mut self.ch);
+
+            if let Poll::Ready(buf) = self.ch.poll_tx_buf(cx) {
+                let fd = 128u32; // TODO unhardcode
+                let mut msg: Message = unsafe { mem::zeroed() };
+                msg.channel = 2; // data
+                msg.id = 0x7006_0004; // IP send
+                msg.param_len = 12;
+                msg.param[4..8].copy_from_slice(&fd.to_le_bytes());
+                state.send_message(&mut msg, buf);
+                self.ch.tx_done();
+            }
+
+            Poll::Pending
+        })
+        .await
+    }
+}
+
+const LIST_LEN: usize = 16;
+
+#[repr(C)]
+struct ControlBlock {
+    version: u32,
+    rx_base: *mut u8,
+    rx_size: usize,
+    control_list_ptr: *mut List,
+    data_list_ptr: *mut List,
+    modem_info_ptr: *mut ModemInfo,
+    trace_ptr: *mut Trace,
+    unk: u32,
+
+    modem_info: ModemInfo,
+    trace: Trace,
+
+    // 0 = control, 1 = data
+    lists: [List; 2],
+    msgs: [[Message; LIST_LEN]; 2],
+
+    tx_bufs: [[u8; TX_BUF_SIZE]; TX_BUF_COUNT],
+}
+
+#[repr(C)]
+struct ModemInfo {
+    version: u32,
+    control_list_ptr: *mut List,
+    data_list_ptr: *mut List,
+    padding: [u32; 5],
+}
+
+#[repr(C)]
+struct Trace {
+    size: usize,
+    base: *mut u8,
+    tx_state: u32,
+    tx_ptr: *mut u8,
+    rx_state: u32,
+    rx_ptr: *mut u8,
+    unk1: u32,
+    unk2: u32,
+}
+
+const TRACE_CHANNEL_COUNT: usize = 3;
+
+#[repr(C)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct TraceContext {
+    unk1: u32,
+    unk2: u32,
+    len: u32,
+    chans: [*mut TraceChannel; TRACE_CHANNEL_COUNT],
+}
+
+#[repr(C)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct TraceChannel {
+    id: u8,
+    unk1: u8,
+    unk2: u8,
+    unk3: u8,
+    write_ptr: *mut u8,
+    read_ptr: *mut u8,
+    start: *mut u8,
+    end: *mut u8,
+}
+
+#[repr(C)]
+struct List {
+    len: usize,
+    items: [ListItem; LIST_LEN],
+}
+
+#[repr(C)]
+struct ListItem {
+    /// top 16 bits: seqno
+    /// bottom 8 bits:
+    ///     0x01: sent
+    ///     0x02: held
+    ///     0x03: freed
+    state: u32,
+    message: *mut Message,
+}
+
+#[repr(C)]
+#[derive(defmt::Format, Clone, Copy)]
+struct Message {
+    id: u32,
+
+    /// 1 = control, 2 = data
+    channel: u8,
+    unk1: u8,
+    unk2: u8,
+    unk3: u8,
+
+    data: *mut u8,
+    data_len: usize,
+    param_len: usize,
+    param: [u8; 44],
+}
+
+struct OnDrop<F: FnOnce()> {
+    f: MaybeUninit<F>,
+}
+
+impl<F: FnOnce()> OnDrop<F> {
+    pub fn new(f: F) -> Self {
+        Self { f: MaybeUninit::new(f) }
+    }
+
+    pub fn defuse(self) {
+        mem::forget(self)
+    }
+}
+
+impl<F: FnOnce()> Drop for OnDrop<F> {
+    fn drop(&mut self) {
+        unsafe { self.f.as_ptr().read()() }
+    }
+}
diff --git a/examples/nrf9160/.cargo/config.toml b/examples/nrf9160/.cargo/config.toml
index f64c63966..6072b8595 100644
--- a/examples/nrf9160/.cargo/config.toml
+++ b/examples/nrf9160/.cargo/config.toml
@@ -1,5 +1,6 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-runner = "probe-rs run --chip nRF9160_xxAA"
+# runner = "probe-rs run --chip nRF9160_xxAA"
+runner = [ "probe-rs", "run", "--chip=nRF9160_xxAA", "--always-print-stacktrace", "--log-format={t} {[{L}]%bold} {s}  {{c} {ff}:{l:1}%dimmed}" ]
 
 [build]
 target = "thumbv8m.main-none-eabihf"
diff --git a/examples/nrf9160/Cargo.toml b/examples/nrf9160/Cargo.toml
index c30b54ebd..fc24e99d2 100644
--- a/examples/nrf9160/Cargo.toml
+++ b/examples/nrf9160/Cargo.toml
@@ -8,6 +8,8 @@ license = "MIT OR Apache-2.0"
 embassy-executor = { version = "0.6.0", path = "../../embassy-executor", features = ["task-arena-size-32768", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.3.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime"] }
 embassy-nrf = { version = "0.2.0", path = "../../embassy-nrf", features = ["defmt", "nrf9160-s", "time-driver-rtc1", "gpiote", "unstable-pac", "time"] }
+embassy-net-nrf91 = { version = "0.1.0", path = "../../embassy-net-nrf91", features = ["defmt"] }
+embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defmt", "tcp", "proto-ipv4", "medium-ip"] }
 
 defmt = "0.3"
 defmt-rtt = "0.4"
@@ -15,6 +17,9 @@ defmt-rtt = "0.4"
 cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
+static_cell = { version = "2" }
+embedded-io = "0.6.1"
+embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
 
 [profile.release]
 debug = 2
diff --git a/examples/nrf9160/memory.x b/examples/nrf9160/memory.x
index 4c7d4ebf0..e33498773 100644
--- a/examples/nrf9160/memory.x
+++ b/examples/nrf9160/memory.x
@@ -1,5 +1,9 @@
 MEMORY
 {
-  FLASH                    : ORIGIN = 0x00000000, LENGTH = 1024K
-  RAM                      : ORIGIN = 0x20018000, LENGTH = 160K
+    FLASH : ORIGIN = 0x00000000, LENGTH = 1024K
+    RAM   : ORIGIN = 0x20010000, LENGTH = 192K
+    IPC   : ORIGIN = 0x20000000, LENGTH = 64K
 }
+
+PROVIDE(__start_ipc = ORIGIN(IPC));
+PROVIDE(__end_ipc   = ORIGIN(IPC) + LENGTH(IPC));
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
new file mode 100644
index 000000000..b1dac18a1
--- /dev/null
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -0,0 +1,250 @@
+#![no_std]
+#![no_main]
+
+use core::mem::MaybeUninit;
+use core::ptr::addr_of_mut;
+use core::str::FromStr;
+use core::{slice, str};
+
+use defmt::{assert, *};
+use embassy_executor::Spawner;
+use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
+use embassy_net_nrf91::{Runner, State};
+use embassy_nrf::buffered_uarte::{self, BufferedUarteTx};
+use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
+use embassy_nrf::uarte::Baudrate;
+use embassy_nrf::{bind_interrupts, interrupt, peripherals, uarte};
+use embassy_time::{Duration, Timer};
+use embedded_io_async::Write;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+#[interrupt]
+fn IPC() {
+    embassy_net_nrf91::on_ipc_irq();
+}
+
+bind_interrupts!(struct Irqs {
+    UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 => buffered_uarte::InterruptHandler<peripherals::SERIAL0>;
+});
+
+// embassy-net-nrf91 only supports blocking trace write for now.
+// We don't want to block packet processing with slow uart writes, so
+// we make an adapter that writes whatever fits in the buffer and drops
+// data if it's full.
+struct TraceWriter(BufferedUarteTx<'static, peripherals::SERIAL0>);
+
+impl embedded_io::ErrorType for TraceWriter {
+    type Error = core::convert::Infallible;
+}
+
+impl embedded_io::Write for TraceWriter {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        let _ = self.0.try_write(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[embassy_executor::task]
+async fn modem_task(runner: Runner<'static, TraceWriter>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::task]
+async fn net_task(stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>) -> ! {
+    stack.run().await
+}
+
+#[embassy_executor::task]
+async fn blink_task(pin: AnyPin) {
+    let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
+    loop {
+        led.set_high();
+        Timer::after_millis(100).await;
+        led.set_low();
+        Timer::after_millis(100).await;
+    }
+}
+
+extern "C" {
+    static __start_ipc: u8;
+    static __end_ipc: u8;
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    info!("Hello World!");
+
+    unwrap!(spawner.spawn(blink_task(p.P0_02.degrade())));
+
+    let ipc_mem = unsafe {
+        let ipc_start = &__start_ipc as *const u8 as *mut MaybeUninit<u8>;
+        let ipc_end = &__end_ipc as *const u8 as *mut MaybeUninit<u8>;
+        let ipc_len = ipc_end.offset_from(ipc_start) as usize;
+        slice::from_raw_parts_mut(ipc_start, ipc_len)
+    };
+
+    static mut TRACE_BUF: [u8; 4096] = [0u8; 4096];
+    let mut config = uarte::Config::default();
+    config.baudrate = Baudrate::BAUD1M;
+    let trace_writer = TraceWriter(BufferedUarteTx::new(
+        //let trace_uart = BufferedUarteTx::new(
+        unsafe { peripherals::SERIAL0::steal() },
+        Irqs,
+        unsafe { peripherals::P0_01::steal() },
+        //unsafe { peripherals::P0_14::steal() },
+        config,
+        unsafe { &mut *addr_of_mut!(TRACE_BUF) },
+    ));
+
+    static STATE: StaticCell<State> = StaticCell::new();
+    let (device, control, runner) = embassy_net_nrf91::new(STATE.init(State::new()), ipc_mem, trace_writer).await;
+    unwrap!(spawner.spawn(modem_task(runner)));
+
+    let config = embassy_net::Config::default();
+
+    // Generate "random" seed. nRF91 has no RNG, TODO figure out something...
+    let seed = 123456;
+
+    // Init network stack
+    static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
+    static STACK: StaticCell<Stack<embassy_net_nrf91::NetDriver<'static>>> = StaticCell::new();
+    let stack = &*STACK.init(Stack::new(
+        device,
+        config,
+        RESOURCES.init(StackResources::<2>::new()),
+        seed,
+    ));
+
+    unwrap!(spawner.spawn(net_task(stack)));
+
+    control.wait_init().await;
+    info!("INIT OK");
+
+    let mut buf = [0u8; 256];
+
+    let n = control.at_command(b"AT+CFUN?", &mut buf).await;
+    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
+
+    let n = control
+        .at_command(b"AT+CGDCONT=0,\"IP\",\"iot.nat.es\"", &mut buf)
+        .await;
+    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
+    let n = control
+        .at_command(b"AT+CGAUTH=0,1,\"orange\",\"orange\"", &mut buf)
+        .await;
+    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
+
+    let n = control.at_command(b"AT+CFUN=1", &mut buf).await;
+    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
+
+    info!("waiting for attach...");
+    loop {
+        Timer::after_millis(500).await;
+        let n = control.at_command(b"AT+CGATT?", &mut buf).await;
+        let mut res = &buf[..n];
+        pop_prefix(&mut res, b"+CGATT: ");
+        let res = split_field(&mut res);
+        info!("AT resp field: '{}'", unsafe { str::from_utf8_unchecked(res) });
+        if res == b"1" {
+            break;
+        }
+    }
+
+    let n = control.at_command(b"AT+CGPADDR=0", &mut buf).await;
+    let mut res = &buf[..n];
+    pop_prefix(&mut res, b"+CGPADDR: 0,");
+    let ip = split_field(&mut res);
+    let ip = Ipv4Address::from_str(unsafe { str::from_utf8_unchecked(ip) }).unwrap();
+    info!("IP: '{}'", ip);
+
+    info!("============== OPENING SOCKET");
+    control.open_raw_socket().await;
+
+    stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
+        address: Ipv4Cidr::new(ip, 32),
+        gateway: None,
+        dns_servers: Default::default(),
+    }));
+
+    let mut rx_buffer = [0; 4096];
+    let mut tx_buffer = [0; 4096];
+    loop {
+        let mut socket = embassy_net::tcp::TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+        socket.set_timeout(Some(Duration::from_secs(10)));
+
+        info!("Connecting...");
+        let host_addr = embassy_net::Ipv4Address::from_str("83.51.182.206").unwrap();
+        if let Err(e) = socket.connect((host_addr, 8000)).await {
+            warn!("connect error: {:?}", e);
+            continue;
+        }
+        info!("Connected to {:?}", socket.remote_endpoint());
+
+        let msg = b"Hello world!\n";
+        loop {
+            if let Err(e) = socket.write_all(msg).await {
+                warn!("write error: {:?}", e);
+                break;
+            }
+            info!("txd: {}", core::str::from_utf8(msg).unwrap());
+            Timer::after_secs(1).await;
+        }
+    }
+}
+
+fn is_whitespace(char: u8) -> bool {
+    match char {
+        b'\r' | b'\n' | b' ' => true,
+        _ => false,
+    }
+}
+
+fn is_separator(char: u8) -> bool {
+    match char {
+        b',' | b'\r' | b'\n' | b' ' => true,
+        _ => false,
+    }
+}
+
+fn split_field<'a>(data: &mut &'a [u8]) -> &'a [u8] {
+    while !data.is_empty() && is_whitespace(data[0]) {
+        *data = &data[1..];
+    }
+
+    if data.is_empty() {
+        return &[];
+    }
+
+    if data[0] == b'"' {
+        let data2 = &data[1..];
+        let end = data2.iter().position(|&x| x == b'"').unwrap_or(data2.len());
+        let field = &data2[..end];
+        let mut rest = &data2[data2.len().min(end + 1)..];
+        if rest.first() == Some(&b'\"') {
+            rest = &rest[1..];
+        }
+        while !rest.is_empty() && is_separator(rest[0]) {
+            rest = &rest[1..];
+        }
+        *data = rest;
+        field
+    } else {
+        let end = data.iter().position(|&x| is_separator(x)).unwrap_or(data.len());
+        let field = &data[0..end];
+        let rest = &data[data.len().min(end + 1)..];
+        *data = rest;
+        field
+    }
+}
+
+fn pop_prefix(data: &mut &[u8], prefix: &[u8]) {
+    assert!(data.len() >= prefix.len());
+    assert!(&data[..prefix.len()] == prefix);
+    *data = &data[prefix.len()..];
+}

From 11652ff5c7b139fd14ae270659181c65e59515dc Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Tue, 25 Jun 2024 21:15:23 +0200
Subject: [PATCH 03/21] don't crash if tx buffers fill up.

---
 embassy-net-nrf91/src/lib.rs | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index 62ade6dd3..70ad176da 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -1,6 +1,7 @@
 #![no_std]
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
+#![deny(unused_must_use)]
 
 // must be first
 mod fmt;
@@ -244,6 +245,10 @@ struct PendingRequest {
     waker: Waker,
 }
 
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct NoFreeBufs;
+
 struct StateInner {
     init: bool,
     init_waker: WakerRegistration,
@@ -450,13 +455,13 @@ impl StateInner {
         return None;
     }
 
-    fn send_message(&mut self, msg: &mut Message, data: &[u8]) {
+    fn send_message(&mut self, msg: &mut Message, data: &[u8]) -> Result<(), NoFreeBufs> {
         if data.is_empty() {
             msg.data = ptr::null_mut();
             msg.data_len = 0;
         } else {
             assert!(data.len() <= TX_BUF_SIZE);
-            let buf_idx = self.find_free_tx_buf().unwrap(); // TODO handle out of bufs
+            let buf_idx = self.find_free_tx_buf().ok_or(NoFreeBufs)?;
             let buf = unsafe { addr_of_mut!((*self.cb).tx_bufs[buf_idx]) } as *mut u8;
             unsafe { copy_nonoverlapping(data.as_ptr(), buf, data.len()) }
             msg.data = buf;
@@ -467,10 +472,10 @@ impl StateInner {
         }
 
         // TODO free data buf if send_message_raw fails.
-        self.send_message_raw(msg);
+        self.send_message_raw(msg)
     }
 
-    fn send_message_raw(&mut self, msg: &Message) {
+    fn send_message_raw(&mut self, msg: &Message) -> Result<(), NoFreeBufs> {
         let (ch, ipc_ch) = match msg.channel {
             1 => (0, 1), // control
             2 => (1, 3), // data
@@ -478,7 +483,7 @@ impl StateInner {
         };
 
         // allocate a msg.
-        let idx = self.find_free_message(ch).unwrap(); // TODO handle list full
+        let idx = self.find_free_message(ch).ok_or(NoFreeBufs)?;
 
         debug!("tx seq {} msg: {:?}", self.tx_seq_no, msg);
 
@@ -491,6 +496,7 @@ impl StateInner {
 
         let ipc = unsafe { &*pac::IPC_NS::ptr() };
         ipc.tasks_send[ipc_ch].write(|w| unsafe { w.bits(1) });
+        Ok(())
     }
 
     fn handle_control(&mut self, msg: &Message) {
@@ -626,7 +632,7 @@ impl StateInner {
         free_msg.data = msg.data;
         free_msg.data_len = msg.data_len;
 
-        self.send_message_raw(&free_msg);
+        unwrap!(self.send_message_raw(&free_msg));
     }
 }
 
@@ -702,7 +708,7 @@ impl<'a> Control<'a> {
         }
 
         msg.param[0..4].copy_from_slice(&req_serial.to_le_bytes());
-        state.send_message(msg, req_data);
+        unwrap!(state.send_message(msg, req_data));
 
         // Setup the pending request state.
         let (req_slot_idx, req_slot) = state
@@ -838,7 +844,9 @@ impl<'a, TW: embedded_io::Write> Runner<'a, TW> {
                 msg.id = 0x7006_0004; // IP send
                 msg.param_len = 12;
                 msg.param[4..8].copy_from_slice(&fd.to_le_bytes());
-                state.send_message(&mut msg, buf);
+                if let Err(e) = state.send_message(&mut msg, buf) {
+                    warn!("tx failed: {:?}", e);
+                }
                 self.ch.tx_done();
             }
 

From bc67cc22aa1461e6bce19b663b00bdccc818a998 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf.lilleengen@gmail.com>
Date: Mon, 5 Aug 2024 12:09:29 +0200
Subject: [PATCH 04/21] update driver channel dependency

---
 embassy-net-nrf91/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-net-nrf91/Cargo.toml b/embassy-net-nrf91/Cargo.toml
index 2156346a4..e2d596d59 100644
--- a/embassy-net-nrf91/Cargo.toml
+++ b/embassy-net-nrf91/Cargo.toml
@@ -22,7 +22,7 @@ nrf9160-pac = { version = "0.12.0" }
 embassy-time = { version = "0.3.1", path = "../embassy-time" }
 embassy-sync = { version = "0.6.0", path = "../embassy-sync"}
 embassy-futures = { version = "0.1.0", path = "../embassy-futures"}
-embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel"}
+embassy-net-driver-channel = { version = "0.3.0", path = "../embassy-net-driver-channel"}
 
 heapless = "0.8"
 embedded-io = "0.6.1"

From 86a45b47e529864ac5a203b4ad26b9ee62127a1e Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf.lilleengen@gmail.com>
Date: Mon, 5 Aug 2024 12:09:58 +0200
Subject: [PATCH 05/21] add at command file

---
 embassy-net-nrf91/src/at.rs | 45 +++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 embassy-net-nrf91/src/at.rs

diff --git a/embassy-net-nrf91/src/at.rs b/embassy-net-nrf91/src/at.rs
new file mode 100644
index 000000000..04cbf3876
--- /dev/null
+++ b/embassy-net-nrf91/src/at.rs
@@ -0,0 +1,45 @@
+use crate::{Error, Control};
+
+// Drives the control loop of the modem based on declarative configuration.
+pub struct AtDriver<'a> {
+    control: Control<'a>,
+    config: Config,
+}
+
+pub struct Config {
+    pub network: NetworkConfig,
+}
+
+pub struct NetworkConfig {
+    pub apn: &'static str,
+    pub prot: AuthProtection,
+    pub userid: &'static str,
+    pub password: &'static str,
+}
+
+#[repr(u8)]
+pub enum AuthProtection {
+    None = 0,
+    Pap = 1,
+    Chap = 2,
+}
+
+impl<'a> AtDriver<'a> {
+    pub async fn new(control: Control<'a>, config: Config) -> Result<Self, Error> {
+        control.wait_init().await;
+        Ok(Self {
+            control,
+            config,
+        })
+    }
+
+    async fn setup(&self) -> Result<(), Error> {
+
+    }
+
+    pub fn run(&self, stack: Stack<crate::NetDriver<'static>>) -> ! {
+        loop {
+
+        }
+    }
+}

From a6db8678eb5a7c9ebcf6449799b4ff525fe52d5f Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 11:04:36 +0200
Subject: [PATCH 06/21] Add utility for setting configuration for a context

---
 embassy-net-nrf91/src/at.rs                  |  45 -----
 embassy-net-nrf91/src/context.rs             | 196 +++++++++++++++++++
 embassy-net-nrf91/src/lib.rs                 |   2 +
 examples/nrf9160/src/bin/modem_tcp_client.rs |  64 +++---
 4 files changed, 220 insertions(+), 87 deletions(-)
 delete mode 100644 embassy-net-nrf91/src/at.rs
 create mode 100644 embassy-net-nrf91/src/context.rs

diff --git a/embassy-net-nrf91/src/at.rs b/embassy-net-nrf91/src/at.rs
deleted file mode 100644
index 04cbf3876..000000000
--- a/embassy-net-nrf91/src/at.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use crate::{Error, Control};
-
-// Drives the control loop of the modem based on declarative configuration.
-pub struct AtDriver<'a> {
-    control: Control<'a>,
-    config: Config,
-}
-
-pub struct Config {
-    pub network: NetworkConfig,
-}
-
-pub struct NetworkConfig {
-    pub apn: &'static str,
-    pub prot: AuthProtection,
-    pub userid: &'static str,
-    pub password: &'static str,
-}
-
-#[repr(u8)]
-pub enum AuthProtection {
-    None = 0,
-    Pap = 1,
-    Chap = 2,
-}
-
-impl<'a> AtDriver<'a> {
-    pub async fn new(control: Control<'a>, config: Config) -> Result<Self, Error> {
-        control.wait_init().await;
-        Ok(Self {
-            control,
-            config,
-        })
-    }
-
-    async fn setup(&self) -> Result<(), Error> {
-
-    }
-
-    pub fn run(&self, stack: Stack<crate::NetDriver<'static>>) -> ! {
-        loop {
-
-        }
-    }
-}
diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
new file mode 100644
index 000000000..6dda51793
--- /dev/null
+++ b/embassy-net-nrf91/src/context.rs
@@ -0,0 +1,196 @@
+use core::net::IpAddr;
+use heapless::String;
+use core::str::FromStr;
+use core::fmt::Write;
+
+/// Provides a higher level API for configuring and reading information for a given
+/// context id.
+pub struct Control<'a> {
+    control: crate::Control<'a>,
+    cid: u8,
+}
+
+pub struct Config<'a> {
+    pub gateway: &'a str,
+    pub auth_prot: AuthProt,
+    pub auth: Option<(&'a str, &'a str)>,
+}
+
+#[repr(u8)]
+pub enum AuthProt {
+    None = 0,
+    Pap = 1,
+    Chap = 2,
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Error {
+    BufferTooSmall,
+    AtCommand,
+    AddrParseError,
+    Format,
+}
+
+impl From<core::fmt::Error> for Error {
+    fn from(_: core::fmt::Error) -> Self {
+        Self::Format
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub struct Status {
+    pub attached: bool,
+    pub ip: Option<IpAddr>,
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Status {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        defmt::write!(f, "attached: {}", self.attached);
+        if let Some(ip) = &self.ip {
+            defmt::write!(f, ", ip: {}", defmt::Debug2Format(&ip));
+        }
+    }
+}
+
+impl<'a> Control<'a> {
+    pub async fn new(control: crate::Control<'a>, cid: u8) -> Self {
+        control.wait_init().await;
+        Self { control, cid }
+    }
+
+    /// Bypass modem configurator
+    pub async fn at_command(&self, req: &[u8], resp: &mut [u8]) -> usize {
+        self.control.at_command(req, resp).await
+    }
+
+    /// Configures the modem with the provided config.
+    pub async fn configure(&self, config: Config<'_>) -> Result<(), Error> {
+        let mut cmd: String<128> = String::new();
+        let mut buf: [u8; 256] = [0; 256];
+
+        write!(cmd, "AT+CGDCONT={},\"IP\",\"{}\"", self.cid, config.gateway).map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(cmd.as_bytes(), &mut buf).await;
+        let mut res = &buf[..n];
+        let res = split_field(&mut res);
+        if res != b"OK" {
+            return Err(Error::AtCommand)
+        }
+        cmd.clear();
+
+        write!(cmd, "AT+CGAUTH={},{}", self.cid, config.auth_prot as u8)?;
+        if let Some((username, password)) = config.auth {
+            write!(cmd, ",\"{}\",\"{}\"", username, password).map_err(|_| Error::BufferTooSmall)?;
+        }
+        let n = self.control.at_command(cmd.as_bytes(), &mut buf).await;
+        let mut res = &buf[..n];
+        let res = split_field(&mut res);
+        if res != b"OK" {
+            return Err(Error::AtCommand)
+        }
+        cmd.clear();
+
+        let n = self.control.at_command(b"AT+CFUN=1", &mut buf).await;
+        let mut res = &buf[..n];
+        let res = split_field(&mut res);
+        if res != b"OK" {
+            return Err(Error::AtCommand);
+        }
+
+        Ok(())
+    }
+
+    pub async fn status(&self) -> Result<Status, Error> {
+        let mut buf: [u8; 256] = [0; 256];
+        let n = self.control.at_command(b"AT+CGATT?", &mut buf).await;
+        let mut res = &buf[..n];
+        pop_prefix(&mut res, b"+CGATT: ");
+        let res = split_field(&mut res);
+        let attached = res == b"1";
+
+        if !attached {
+            return Ok(Status { attached, ip: None })
+        }
+
+        let mut s: String<128> = String::new();
+        write!(s, "AT+CGPADDR={}", self.cid)?;
+        let n = self.control.at_command(s.as_bytes(), &mut buf).await;
+        let mut res = &buf[..n];
+        s.clear();
+
+        write!(s, "+CGPADDR: {},", self.cid)?;
+
+        info!("RES: {:?}", unsafe {core::str::from_utf8_unchecked(res)});
+        if s.len() > res.len() {
+            let res = split_field(&mut res);
+            if res == b"OK" {
+                Ok(Status { attached, ip: None })
+            } else {
+                Err(Error::AtCommand)
+            }
+        } else {
+            pop_prefix(&mut res, s.as_bytes());
+
+            let ip = split_field(&mut res);
+            if !ip.is_empty() {
+                let ip = IpAddr::from_str(unsafe { core::str::from_utf8_unchecked(ip) }).map_err(|_| Error::AddrParseError)?;
+                self.control.open_raw_socket().await;
+                Ok(Status { attached, ip: Some(ip) })
+            } else {
+                Ok(Status { attached, ip: None })
+            }
+        }
+    }
+}
+
+pub(crate) fn is_whitespace(char: u8) -> bool {
+    match char {
+        b'\r' | b'\n' | b' ' => true,
+        _ => false,
+    }
+}
+
+pub(crate) fn is_separator(char: u8) -> bool {
+    match char {
+        b',' | b'\r' | b'\n' | b' ' => true,
+        _ => false,
+    }
+}
+
+pub(crate) fn split_field<'a>(data: &mut &'a [u8]) -> &'a [u8] {
+    while !data.is_empty() && is_whitespace(data[0]) {
+        *data = &data[1..];
+    }
+
+    if data.is_empty() {
+        return &[];
+    }
+
+    if data[0] == b'"' {
+        let data2 = &data[1..];
+        let end = data2.iter().position(|&x| x == b'"').unwrap_or(data2.len());
+        let field = &data2[..end];
+        let mut rest = &data2[data2.len().min(end + 1)..];
+        if rest.first() == Some(&b'\"') {
+            rest = &rest[1..];
+        }
+        while !rest.is_empty() && is_separator(rest[0]) {
+            rest = &rest[1..];
+        }
+        *data = rest;
+        field
+    } else {
+        let end = data.iter().position(|&x| is_separator(x)).unwrap_or(data.len());
+        let field = &data[0..end];
+        let rest = &data[data.len().min(end + 1)..];
+        *data = rest;
+        field
+    }
+}
+
+pub(crate) fn pop_prefix(data: &mut &[u8], prefix: &[u8]) {
+    assert!(data.len() >= prefix.len());
+    assert!(&data[..prefix.len()] == prefix);
+    *data = &data[prefix.len()..];
+}
diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index 70ad176da..beed7c65a 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -6,6 +6,8 @@
 // must be first
 mod fmt;
 
+pub mod context;
+
 use core::cell::RefCell;
 use core::future::poll_fn;
 use core::marker::PhantomData;
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index b1dac18a1..817ad17c7 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -2,14 +2,15 @@
 #![no_main]
 
 use core::mem::MaybeUninit;
+use core::net::IpAddr;
 use core::ptr::addr_of_mut;
 use core::str::FromStr;
 use core::{slice, str};
 
-use defmt::{assert, *};
+use defmt::{assert, info, warn, unwrap};
 use embassy_executor::Spawner;
 use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
-use embassy_net_nrf91::{Runner, State};
+use embassy_net_nrf91::{Runner, State, context};
 use embassy_nrf::buffered_uarte::{self, BufferedUarteTx};
 use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
 use embassy_nrf::uarte::Baudrate;
@@ -63,9 +64,9 @@ async fn blink_task(pin: AnyPin) {
     let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
     loop {
         led.set_high();
-        Timer::after_millis(100).await;
+        Timer::after_millis(1000).await;
         led.set_low();
-        Timer::after_millis(100).await;
+        Timer::after_millis(1000).await;
     }
 }
 
@@ -123,51 +124,30 @@ async fn main(spawner: Spawner) {
 
     unwrap!(spawner.spawn(net_task(stack)));
 
-    control.wait_init().await;
-    info!("INIT OK");
+    let control = context::Control::new(control, 0).await;
 
-    let mut buf = [0u8; 256];
-
-    let n = control.at_command(b"AT+CFUN?", &mut buf).await;
-    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
-
-    let n = control
-        .at_command(b"AT+CGDCONT=0,\"IP\",\"iot.nat.es\"", &mut buf)
-        .await;
-    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
-    let n = control
-        .at_command(b"AT+CGAUTH=0,1,\"orange\",\"orange\"", &mut buf)
-        .await;
-    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
-
-    let n = control.at_command(b"AT+CFUN=1", &mut buf).await;
-    info!("AT resp: '{}'", unsafe { str::from_utf8_unchecked(&buf[..n]) });
+    unwrap!(control.configure(context::Config {
+        gateway: "iot.nat.es",
+        auth_prot: context::AuthProt::Pap,
+        auth: Some(("orange", "orange")),
+    }).await);
 
     info!("waiting for attach...");
-    loop {
-        Timer::after_millis(500).await;
-        let n = control.at_command(b"AT+CGATT?", &mut buf).await;
-        let mut res = &buf[..n];
-        pop_prefix(&mut res, b"+CGATT: ");
-        let res = split_field(&mut res);
-        info!("AT resp field: '{}'", unsafe { str::from_utf8_unchecked(res) });
-        if res == b"1" {
-            break;
-        }
+
+    let mut status = unwrap!(control.status().await);
+    while !status.attached && status.ip.is_none() {
+        Timer::after_millis(1000).await;
+        status = unwrap!(control.status().await);
+        info!("STATUS: {:?}", status);
     }
 
-    let n = control.at_command(b"AT+CGPADDR=0", &mut buf).await;
-    let mut res = &buf[..n];
-    pop_prefix(&mut res, b"+CGPADDR: 0,");
-    let ip = split_field(&mut res);
-    let ip = Ipv4Address::from_str(unsafe { str::from_utf8_unchecked(ip) }).unwrap();
-    info!("IP: '{}'", ip);
-
-    info!("============== OPENING SOCKET");
-    control.open_raw_socket().await;
+    let Some(IpAddr::V4(addr)) = status.ip else {
+        panic!("Unexpected IP address");
+    };
+    let addr = Ipv4Address(addr.octets());
 
     stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
-        address: Ipv4Cidr::new(ip, 32),
+        address: Ipv4Cidr::new(addr, 32),
         gateway: None,
         dns_servers: Default::default(),
     }));

From aabdd45424ae71550be542a3a62872b33a4e0717 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 11:09:27 +0200
Subject: [PATCH 07/21] remove debug logging

---
 embassy-net-nrf91/src/context.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 6dda51793..c47b1ade6 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -121,7 +121,6 @@ impl<'a> Control<'a> {
 
         write!(s, "+CGPADDR: {},", self.cid)?;
 
-        info!("RES: {:?}", unsafe {core::str::from_utf8_unchecked(res)});
         if s.len() > res.len() {
             let res = split_field(&mut res);
             if res == b"OK" {

From b76b7ca9f5d64e83f7f69a6f7d97ba605ab2af7f Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 12:58:33 +0200
Subject: [PATCH 08/21] Use at-commands crate and support DNS

* Use at-commands for building and parsing AT commands which has better
  error handling.
* Retrieve DNS servers
* Retrieve gateway
* Update example to configure embassy-net with retrieved parameters.
---
 embassy-net-nrf91/Cargo.toml                 |   1 +
 embassy-net-nrf91/src/context.rs             | 202 ++++++++++---------
 examples/nrf9160/Cargo.toml                  |   1 +
 examples/nrf9160/src/bin/modem_tcp_client.rs |  78 ++-----
 4 files changed, 126 insertions(+), 156 deletions(-)

diff --git a/embassy-net-nrf91/Cargo.toml b/embassy-net-nrf91/Cargo.toml
index e2d596d59..07a0c8886 100644
--- a/embassy-net-nrf91/Cargo.toml
+++ b/embassy-net-nrf91/Cargo.toml
@@ -26,6 +26,7 @@ embassy-net-driver-channel = { version = "0.3.0", path = "../embassy-net-driver-
 
 heapless = "0.8"
 embedded-io = "0.6.1"
+at-commands = "0.5.4"
 
 [package.metadata.embassy_docs]
 src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-nrf91-v$VERSION/embassy-net-nrf91/src/"
diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index c47b1ade6..b532dca14 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -2,6 +2,8 @@ use core::net::IpAddr;
 use heapless::String;
 use core::str::FromStr;
 use core::fmt::Write;
+use heapless::Vec;
+use at_commands::{builder::CommandBuilder, parser::CommandParser};
 
 /// Provides a higher level API for configuring and reading information for a given
 /// context id.
@@ -28,10 +30,17 @@ pub enum AuthProt {
 pub enum Error {
     BufferTooSmall,
     AtCommand,
+    AtParseError,
     AddrParseError,
     Format,
 }
 
+impl From<at_commands::parser::ParseError> for Error {
+    fn from(_: at_commands::parser::ParseError) -> Self {
+        Self::AtParseError
+    }
+}
+
 impl From<core::fmt::Error> for Error {
     fn from(_: core::fmt::Error) -> Self {
         Self::Format
@@ -42,6 +51,8 @@ impl From<core::fmt::Error> for Error {
 pub struct Status {
     pub attached: bool,
     pub ip: Option<IpAddr>,
+    pub gateway: Option<IpAddr>,
+    pub dns: Vec<IpAddr, 2>,
 }
 
 #[cfg(feature = "defmt")]
@@ -67,129 +78,122 @@ impl<'a> Control<'a> {
 
     /// Configures the modem with the provided config.
     pub async fn configure(&self, config: Config<'_>) -> Result<(), Error> {
-        let mut cmd: String<128> = String::new();
+        let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
 
-        write!(cmd, "AT+CGDCONT={},\"IP\",\"{}\"", self.cid, config.gateway).map_err(|_| Error::BufferTooSmall)?;
-        let n = self.control.at_command(cmd.as_bytes(), &mut buf).await;
-        let mut res = &buf[..n];
-        let res = split_field(&mut res);
-        if res != b"OK" {
-            return Err(Error::AtCommand)
-        }
-        cmd.clear();
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGDCONT")
+            .with_int_parameter(self.cid)
+            .with_string_parameter("IP")
+            .with_string_parameter(config.gateway)
+            .finish().map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
-        write!(cmd, "AT+CGAUTH={},{}", self.cid, config.auth_prot as u8)?;
+        let mut op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGAUTH")
+            .with_int_parameter(self.cid)
+            .with_int_parameter(config.auth_prot as u8);
         if let Some((username, password)) = config.auth {
-            write!(cmd, ",\"{}\",\"{}\"", username, password).map_err(|_| Error::BufferTooSmall)?;
+            op = op.with_string_parameter(username).with_string_parameter(password);
         }
-        let n = self.control.at_command(cmd.as_bytes(), &mut buf).await;
-        let mut res = &buf[..n];
-        let res = split_field(&mut res);
-        if res != b"OK" {
-            return Err(Error::AtCommand)
-        }
-        cmd.clear();
+        let op = op.finish().map_err(|_| Error::BufferTooSmall)?;
 
-        let n = self.control.at_command(b"AT+CFUN=1", &mut buf).await;
-        let mut res = &buf[..n];
-        let res = split_field(&mut res);
-        if res != b"OK" {
-            return Err(Error::AtCommand);
-        }
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CFUN")
+            .with_int_parameter(1)
+            .finish().map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
         Ok(())
     }
 
     pub async fn status(&self) -> Result<Status, Error> {
+        let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
-        let n = self.control.at_command(b"AT+CGATT?", &mut buf).await;
-        let mut res = &buf[..n];
-        pop_prefix(&mut res, b"+CGATT: ");
-        let res = split_field(&mut res);
-        let attached = res == b"1";
 
+        let op = CommandBuilder::create_query(&mut cmd, true)
+            .named("+CGATT")
+            .finish().map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        let (res, ) = CommandParser::parse(&buf[..n])
+            .expect_identifier(b"+CGATT: ")
+            .expect_int_parameter()
+            .expect_identifier(b"\r\nOK").finish()?;
+        let attached = res == 1;
         if !attached {
-            return Ok(Status { attached, ip: None })
+            return Ok(Status { attached, ip: None, gateway: None, dns: Vec::new() })
         }
 
-        let mut s: String<128> = String::new();
-        write!(s, "AT+CGPADDR={}", self.cid)?;
-        let n = self.control.at_command(s.as_bytes(), &mut buf).await;
-        let mut res = &buf[..n];
-        s.clear();
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGPADDR")
+            .with_int_parameter(self.cid)
+            .finish().map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        let (_, ip1, ip2, ) = CommandParser::parse(&buf[..n])
+            .expect_identifier(b"+CGPADDR: ")
+            .expect_int_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_string_parameter()
+            .expect_identifier(b"\r\nOK").finish()?;
 
-        write!(s, "+CGPADDR: {},", self.cid)?;
+        let ip = if let Some(ip) = ip1 {
+            let ip = IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?;
+            self.control.open_raw_socket().await;
+            Some(ip)
+        } else {
+            None
+        };
 
-        if s.len() > res.len() {
-            let res = split_field(&mut res);
-            if res == b"OK" {
-                Ok(Status { attached, ip: None })
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGCONTRDP")
+            .with_int_parameter(self.cid)
+            .finish().map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        let (_cid, _bid, _apn, _mask, gateway, dns1, dns2, _, _, _, _, mtu) = CommandParser::parse(&buf[..n])
+            .expect_identifier(b"+CGCONTRDP: ")
+            .expect_int_parameter()
+            .expect_optional_int_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_string_parameter()
+            .expect_optional_int_parameter()
+            .expect_optional_int_parameter()
+            .expect_optional_int_parameter()
+            .expect_optional_int_parameter()
+            .expect_optional_int_parameter()
+            .expect_identifier(b"\r\nOK").finish()?;
+
+        let gateway = if let Some(ip) = gateway {
+            if ip.is_empty() {
+                None
             } else {
-                Err(Error::AtCommand)
+                Some(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?)
             }
         } else {
-            pop_prefix(&mut res, s.as_bytes());
+            None
+        };
 
-            let ip = split_field(&mut res);
-            if !ip.is_empty() {
-                let ip = IpAddr::from_str(unsafe { core::str::from_utf8_unchecked(ip) }).map_err(|_| Error::AddrParseError)?;
-                self.control.open_raw_socket().await;
-                Ok(Status { attached, ip: Some(ip) })
-            } else {
-                Ok(Status { attached, ip: None })
-            }
+        let mut dns = Vec::new();
+        if let Some(ip) = dns1 {
+            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?).unwrap();
         }
-    }
-}
 
-pub(crate) fn is_whitespace(char: u8) -> bool {
-    match char {
-        b'\r' | b'\n' | b' ' => true,
-        _ => false,
-    }
-}
-
-pub(crate) fn is_separator(char: u8) -> bool {
-    match char {
-        b',' | b'\r' | b'\n' | b' ' => true,
-        _ => false,
-    }
-}
-
-pub(crate) fn split_field<'a>(data: &mut &'a [u8]) -> &'a [u8] {
-    while !data.is_empty() && is_whitespace(data[0]) {
-        *data = &data[1..];
-    }
-
-    if data.is_empty() {
-        return &[];
-    }
-
-    if data[0] == b'"' {
-        let data2 = &data[1..];
-        let end = data2.iter().position(|&x| x == b'"').unwrap_or(data2.len());
-        let field = &data2[..end];
-        let mut rest = &data2[data2.len().min(end + 1)..];
-        if rest.first() == Some(&b'\"') {
-            rest = &rest[1..];
+        if let Some(ip) = dns2 {
+            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?).unwrap();
         }
-        while !rest.is_empty() && is_separator(rest[0]) {
-            rest = &rest[1..];
-        }
-        *data = rest;
-        field
-    } else {
-        let end = data.iter().position(|&x| is_separator(x)).unwrap_or(data.len());
-        let field = &data[0..end];
-        let rest = &data[data.len().min(end + 1)..];
-        *data = rest;
-        field
+
+        Ok(Status {
+            attached,
+            ip,
+            gateway,
+            dns,
+        })
     }
 }
-
-pub(crate) fn pop_prefix(data: &mut &[u8], prefix: &[u8]) {
-    assert!(data.len() >= prefix.len());
-    assert!(&data[..prefix.len()] == prefix);
-    *data = &data[prefix.len()..];
-}
diff --git a/examples/nrf9160/Cargo.toml b/examples/nrf9160/Cargo.toml
index fc24e99d2..9aeb99317 100644
--- a/examples/nrf9160/Cargo.toml
+++ b/examples/nrf9160/Cargo.toml
@@ -14,6 +14,7 @@ embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defm
 defmt = "0.3"
 defmt-rtt = "0.4"
 
+heapless = "0.8"
 cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index 817ad17c7..f80861693 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -5,9 +5,10 @@ use core::mem::MaybeUninit;
 use core::net::IpAddr;
 use core::ptr::addr_of_mut;
 use core::str::FromStr;
-use core::{slice, str};
+use core::slice;
 
 use defmt::{assert, info, warn, unwrap};
+use heapless::Vec;
 use embassy_executor::Spawner;
 use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
 use embassy_net_nrf91::{Runner, State, context};
@@ -146,10 +147,23 @@ async fn main(spawner: Spawner) {
     };
     let addr = Ipv4Address(addr.octets());
 
+    let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
+        Some(Ipv4Address(addr.octets()))
+    } else {
+        None
+    };
+
+    let mut dns_servers = Vec::new();
+    for dns in status.dns {
+        if let IpAddr::V4(ip) = dns {
+            unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
+        }
+    }
+
     stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
         address: Ipv4Cidr::new(addr, 32),
-        gateway: None,
-        dns_servers: Default::default(),
+        gateway,
+        dns_servers,
     }));
 
     let mut rx_buffer = [0; 4096];
@@ -159,15 +173,16 @@ async fn main(spawner: Spawner) {
         socket.set_timeout(Some(Duration::from_secs(10)));
 
         info!("Connecting...");
-        let host_addr = embassy_net::Ipv4Address::from_str("83.51.182.206").unwrap();
-        if let Err(e) = socket.connect((host_addr, 8000)).await {
+        let host_addr = embassy_net::Ipv4Address::from_str("45.79.112.203").unwrap();
+        if let Err(e) = socket.connect((host_addr, 4242)).await {
             warn!("connect error: {:?}", e);
+            Timer::after_secs(1).await;
             continue;
         }
         info!("Connected to {:?}", socket.remote_endpoint());
 
         let msg = b"Hello world!\n";
-        loop {
+        for _ in 0..10 {
             if let Err(e) = socket.write_all(msg).await {
                 warn!("write error: {:?}", e);
                 break;
@@ -177,54 +192,3 @@ async fn main(spawner: Spawner) {
         }
     }
 }
-
-fn is_whitespace(char: u8) -> bool {
-    match char {
-        b'\r' | b'\n' | b' ' => true,
-        _ => false,
-    }
-}
-
-fn is_separator(char: u8) -> bool {
-    match char {
-        b',' | b'\r' | b'\n' | b' ' => true,
-        _ => false,
-    }
-}
-
-fn split_field<'a>(data: &mut &'a [u8]) -> &'a [u8] {
-    while !data.is_empty() && is_whitespace(data[0]) {
-        *data = &data[1..];
-    }
-
-    if data.is_empty() {
-        return &[];
-    }
-
-    if data[0] == b'"' {
-        let data2 = &data[1..];
-        let end = data2.iter().position(|&x| x == b'"').unwrap_or(data2.len());
-        let field = &data2[..end];
-        let mut rest = &data2[data2.len().min(end + 1)..];
-        if rest.first() == Some(&b'\"') {
-            rest = &rest[1..];
-        }
-        while !rest.is_empty() && is_separator(rest[0]) {
-            rest = &rest[1..];
-        }
-        *data = rest;
-        field
-    } else {
-        let end = data.iter().position(|&x| is_separator(x)).unwrap_or(data.len());
-        let field = &data[0..end];
-        let rest = &data[data.len().min(end + 1)..];
-        *data = rest;
-        field
-    }
-}
-
-fn pop_prefix(data: &mut &[u8], prefix: &[u8]) {
-    assert!(data.len() >= prefix.len());
-    assert!(&data[..prefix.len()] == prefix);
-    *data = &data[prefix.len()..];
-}

From 5e27a3e64f46340e50bc6f61e6ef5a89e9f077ab Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 13:09:27 +0200
Subject: [PATCH 09/21] Document public API and fix warnings

---
 embassy-net-nrf91/src/context.rs             | 48 +++++++++++---------
 examples/nrf9160/src/bin/modem_tcp_client.rs |  6 +--
 2 files changed, 30 insertions(+), 24 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index b532dca14..9c67cbc9f 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -1,38 +1,46 @@
+//! Helper utility to configure a specific modem context.
 use core::net::IpAddr;
-use heapless::String;
 use core::str::FromStr;
-use core::fmt::Write;
 use heapless::Vec;
 use at_commands::{builder::CommandBuilder, parser::CommandParser};
 
-/// Provides a higher level API for configuring and reading information for a given
-/// context id.
+/// Provides a higher level API for controlling a given context.
 pub struct Control<'a> {
     control: crate::Control<'a>,
     cid: u8,
 }
 
+/// Configuration for a given context
 pub struct Config<'a> {
-    pub gateway: &'a str,
+    /// Desired APN address.
+    pub apn: &'a str,
+    /// Desired authentication protocol.
     pub auth_prot: AuthProt,
+    /// Credentials.
     pub auth: Option<(&'a str, &'a str)>,
 }
 
+/// Authentication protocol.
 #[repr(u8)]
 pub enum AuthProt {
+    /// No authentication.
     None = 0,
+    /// PAP authentication.
     Pap = 1,
+    /// CHAP authentication.
     Chap = 2,
 }
 
+/// Error returned by control.
 #[derive(Clone, Copy, PartialEq, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Error {
+    /// Not enough space for command.
     BufferTooSmall,
-    AtCommand,
+    /// Error parsing response from modem.
     AtParseError,
+    /// Error parsing IP addresses.
     AddrParseError,
-    Format,
 }
 
 impl From<at_commands::parser::ParseError> for Error {
@@ -41,17 +49,16 @@ impl From<at_commands::parser::ParseError> for Error {
     }
 }
 
-impl From<core::fmt::Error> for Error {
-    fn from(_: core::fmt::Error) -> Self {
-        Self::Format
-    }
-}
-
+/// Status of a given context.
 #[derive(PartialEq, Debug)]
 pub struct Status {
+    /// Attached to APN or not.
     pub attached: bool,
+    /// IP if assigned.
     pub ip: Option<IpAddr>,
+    /// Gateway if assigned.
     pub gateway: Option<IpAddr>,
+    /// DNS servers if assigned.
     pub dns: Vec<IpAddr, 2>,
 }
 
@@ -66,16 +73,14 @@ impl defmt::Format for Status {
 }
 
 impl<'a> Control<'a> {
+    /// Create a new instance of a control handle for a given context.
+    ///
+    /// Will wait for the modem to be initialized if not.
     pub async fn new(control: crate::Control<'a>, cid: u8) -> Self {
         control.wait_init().await;
         Self { control, cid }
     }
 
-    /// Bypass modem configurator
-    pub async fn at_command(&self, req: &[u8], resp: &mut [u8]) -> usize {
-        self.control.at_command(req, resp).await
-    }
-
     /// Configures the modem with the provided config.
     pub async fn configure(&self, config: Config<'_>) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];
@@ -85,7 +90,7 @@ impl<'a> Control<'a> {
             .named("+CGDCONT")
             .with_int_parameter(self.cid)
             .with_string_parameter("IP")
-            .with_string_parameter(config.gateway)
+            .with_string_parameter(config.apn)
             .finish().map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
@@ -112,6 +117,7 @@ impl<'a> Control<'a> {
         Ok(())
     }
 
+    /// Read current connectivity status for modem.
     pub async fn status(&self) -> Result<Status, Error> {
         let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
@@ -134,7 +140,7 @@ impl<'a> Control<'a> {
             .with_int_parameter(self.cid)
             .finish().map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
-        let (_, ip1, ip2, ) = CommandParser::parse(&buf[..n])
+        let (_, ip1, _ip2, ) = CommandParser::parse(&buf[..n])
             .expect_identifier(b"+CGPADDR: ")
             .expect_int_parameter()
             .expect_optional_string_parameter()
@@ -154,7 +160,7 @@ impl<'a> Control<'a> {
             .with_int_parameter(self.cid)
             .finish().map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
-        let (_cid, _bid, _apn, _mask, gateway, dns1, dns2, _, _, _, _, mtu) = CommandParser::parse(&buf[..n])
+        let (_cid, _bid, _apn, _mask, gateway, dns1, dns2, _, _, _, _, _mtu) = CommandParser::parse(&buf[..n])
             .expect_identifier(b"+CGCONTRDP: ")
             .expect_int_parameter()
             .expect_optional_int_parameter()
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index f80861693..55ab2a707 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -7,7 +7,7 @@ use core::ptr::addr_of_mut;
 use core::str::FromStr;
 use core::slice;
 
-use defmt::{assert, info, warn, unwrap};
+use defmt::{info, warn, unwrap};
 use heapless::Vec;
 use embassy_executor::Spawner;
 use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
@@ -93,7 +93,7 @@ async fn main(spawner: Spawner) {
 
     static mut TRACE_BUF: [u8; 4096] = [0u8; 4096];
     let mut config = uarte::Config::default();
-    config.baudrate = Baudrate::BAUD1M;
+    config.baudrate = Baudrate::BAUD115200;
     let trace_writer = TraceWriter(BufferedUarteTx::new(
         //let trace_uart = BufferedUarteTx::new(
         unsafe { peripherals::SERIAL0::steal() },
@@ -128,7 +128,7 @@ async fn main(spawner: Spawner) {
     let control = context::Control::new(control, 0).await;
 
     unwrap!(control.configure(context::Config {
-        gateway: "iot.nat.es",
+        apn: "iot.nat.es",
         auth_prot: context::AuthProt::Pap,
         auth: Some(("orange", "orange")),
     }).await);

From b4221d75b87664485977d37df28f7319143411fc Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 14:09:17 +0200
Subject: [PATCH 10/21] Make tracing optional and use dedicated task

---
 embassy-net-nrf91/src/lib.rs                 | 90 +++++++++++++++-----
 examples/nrf9160/src/bin/modem_tcp_client.rs | 58 ++++++-------
 2 files changed, 98 insertions(+), 50 deletions(-)

diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index beed7c65a..673784cb2 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -19,12 +19,15 @@ use core::task::{Poll, Waker};
 
 use embassy_net_driver_channel as ch;
 use embassy_sync::waitqueue::{AtomicWaker, WakerRegistration};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use heapless::Vec;
 use nrf9160_pac as pac;
 use pac::NVIC;
+use embassy_sync::pipe;
 
 const RX_SIZE: usize = 8 * 1024;
 const TRACE_SIZE: usize = 16 * 1024;
+const TRACE_BUF: usize = 1024;
 const MTU: usize = 1500;
 
 /// Network driver.
@@ -91,11 +94,30 @@ impl<'a> Allocator<'a> {
 }
 
 /// Create a new nRF91 embassy-net driver.
-pub async fn new<'a, TW: embedded_io::Write>(
+pub async fn new<'a>(
     state: &'a mut State,
     shmem: &'a mut [MaybeUninit<u8>],
-    trace_writer: TW,
-) -> (NetDriver<'a>, Control<'a>, Runner<'a, TW>) {
+) -> (NetDriver<'a>, Control<'a>, Runner<'a>) {
+    let (n, c, r, _) = new_internal(state, shmem, None).await;
+    (n, c, r)
+}
+
+/// Create a new nRF91 embassy-net driver with trace.
+pub async fn new_with_trace<'a>(
+    state: &'a mut State,
+    shmem: &'a mut [MaybeUninit<u8>],
+    trace_buffer: &'a mut TraceBuffer,
+) -> (NetDriver<'a>, Control<'a>, Runner<'a>, TraceReader<'a>) {
+    let (n, c, r, t) = new_internal(state, shmem, Some(trace_buffer)).await;
+    (n, c, r, t.unwrap())
+}
+
+/// Create a new nRF91 embassy-net driver.
+async fn new_internal<'a>(
+    state: &'a mut State,
+    shmem: &'a mut [MaybeUninit<u8>],
+    trace_buffer: Option<&'a mut TraceBuffer>,
+) -> (NetDriver<'a>, Control<'a>, Runner<'a>, Option<TraceReader<'a>>) {
     let shmem_len = shmem.len();
     let shmem_ptr = shmem.as_mut_ptr() as *mut u8;
 
@@ -205,21 +227,49 @@ pub async fn new<'a, TW: embedded_io::Write>(
     let state_ch = ch_runner.state_runner();
     state_ch.set_link_state(ch::driver::LinkState::Up);
 
+    let (trace_reader, trace_writer) = if let Some(trace) = trace_buffer {
+        let (r, w) = trace.trace.split();
+        (Some(r), Some(w))
+    } else {
+        (None, None)
+    };
+
     let runner = Runner {
         ch: ch_runner,
         state: state_inner,
         trace_writer,
     };
 
-    (device, control, runner)
+    (device, control, runner, trace_reader)
 }
 
-/// Shared state for the drivver.
+/// State holding modem traces.
+pub struct TraceBuffer {
+    trace: pipe::Pipe<NoopRawMutex, TRACE_BUF>,
+}
+
+/// Represents writer half of the trace buffer.
+pub type TraceWriter<'a> = pipe::Writer<'a, NoopRawMutex, TRACE_BUF>;
+
+/// Represents the reader half of the trace buffer.
+pub type TraceReader<'a> = pipe::Reader<'a, NoopRawMutex, TRACE_BUF>;
+
+impl TraceBuffer {
+    /// Create a new TraceBuffer.
+    pub const fn new() -> Self {
+        Self {
+            trace: pipe::Pipe::new(),
+        }
+    }
+}
+
+/// Shared state for the driver.
 pub struct State {
     ch: ch::State<MTU, 4, 4>,
     inner: MaybeUninit<RefCell<StateInner>>,
 }
 
+
 impl State {
     /// Create a new State.
     pub const fn new() -> Self {
@@ -272,7 +322,7 @@ struct StateInner {
 }
 
 impl StateInner {
-    fn poll(&mut self, trace_writer: &mut impl embedded_io::Write, ch: &mut ch::Runner<MTU>) {
+    fn poll(&mut self, trace_writer: &mut Option<TraceWriter<'_>>, ch: &mut ch::Runner<MTU>) {
         trace!("poll!");
         let ipc = unsafe { &*pac::IPC_NS::ptr() };
 
@@ -399,15 +449,17 @@ impl StateInner {
         });
     }
 
-    fn handle_trace(writer: &mut impl embedded_io::Write, id: u8, data: &[u8]) {
-        trace!("trace: {} {}", id, data.len());
-        let mut header = [0u8; 5];
-        header[0] = 0xEF;
-        header[1] = 0xBE;
-        header[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
-        header[4] = id;
-        writer.write_all(&header).unwrap();
-        writer.write_all(data).unwrap();
+    fn handle_trace(writer: &mut Option<TraceWriter<'_>>, id: u8, data: &[u8]) {
+        if let Some(writer) = writer {
+            trace!("trace: {} {}", id, data.len());
+            let mut header = [0u8; 5];
+            header[0] = 0xEF;
+            header[1] = 0xBE;
+            header[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
+            header[4] = id;
+            writer.try_write(&header).ok();
+            writer.try_write(data).ok();
+        }
     }
 
     fn process(&mut self, list: *mut List, is_control: bool, ch: &mut ch::Runner<MTU>) -> bool {
@@ -794,7 +846,7 @@ impl<'a> Control<'a> {
     /// Open the raw socket used for sending/receiving IP packets.
     ///
     /// This must be done after `AT+CFUN=1` (?)
-    pub async fn open_raw_socket(&self) {
+    async fn open_raw_socket(&self) {
         let mut msg: Message = unsafe { mem::zeroed() };
         msg.channel = 2; // data
         msg.id = 0x7001_0004; // open socket
@@ -822,13 +874,13 @@ impl<'a> Control<'a> {
 }
 
 /// Background runner for the driver.
-pub struct Runner<'a, TW: embedded_io::Write> {
+pub struct Runner<'a> {
     ch: ch::Runner<'a, MTU>,
     state: &'a RefCell<StateInner>,
-    trace_writer: TW,
+    trace_writer: Option<TraceWriter<'a>>,
 }
 
-impl<'a, TW: embedded_io::Write> Runner<'a, TW> {
+impl<'a> Runner<'a> {
     /// Run the driver operation in the background.
     ///
     /// You must run this in a background task, concurrently with all network operations.
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index 55ab2a707..c65e6e153 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -4,20 +4,20 @@
 use core::mem::MaybeUninit;
 use core::net::IpAddr;
 use core::ptr::addr_of_mut;
-use core::str::FromStr;
 use core::slice;
+use core::str::FromStr;
 
-use defmt::{info, warn, unwrap};
-use heapless::Vec;
+use defmt::{info, unwrap, warn};
 use embassy_executor::Spawner;
 use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
-use embassy_net_nrf91::{Runner, State, context};
+use embassy_net_nrf91::{context, Runner, State, TraceBuffer, TraceReader};
 use embassy_nrf::buffered_uarte::{self, BufferedUarteTx};
 use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
 use embassy_nrf::uarte::Baudrate;
 use embassy_nrf::{bind_interrupts, interrupt, peripherals, uarte};
 use embassy_time::{Duration, Timer};
 use embedded_io_async::Write;
+use heapless::Vec;
 use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -30,28 +30,17 @@ bind_interrupts!(struct Irqs {
     UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 => buffered_uarte::InterruptHandler<peripherals::SERIAL0>;
 });
 
-// embassy-net-nrf91 only supports blocking trace write for now.
-// We don't want to block packet processing with slow uart writes, so
-// we make an adapter that writes whatever fits in the buffer and drops
-// data if it's full.
-struct TraceWriter(BufferedUarteTx<'static, peripherals::SERIAL0>);
-
-impl embedded_io::ErrorType for TraceWriter {
-    type Error = core::convert::Infallible;
-}
-
-impl embedded_io::Write for TraceWriter {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        let _ = self.0.try_write(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> Result<(), Self::Error> {
-        Ok(())
+#[embassy_executor::task]
+async fn trace_task(mut uart: BufferedUarteTx<'static, peripherals::SERIAL0>, reader: TraceReader<'static>) -> ! {
+    let mut rx = [0u8; 1024];
+    loop {
+        let n = reader.read(&mut rx[..]).await;
+        unwrap!(uart.write_all(&rx[..n]).await);
     }
 }
 
 #[embassy_executor::task]
-async fn modem_task(runner: Runner<'static, TraceWriter>) -> ! {
+async fn modem_task(runner: Runner<'static>) -> ! {
     runner.run().await
 }
 
@@ -93,8 +82,8 @@ async fn main(spawner: Spawner) {
 
     static mut TRACE_BUF: [u8; 4096] = [0u8; 4096];
     let mut config = uarte::Config::default();
-    config.baudrate = Baudrate::BAUD115200;
-    let trace_writer = TraceWriter(BufferedUarteTx::new(
+    config.baudrate = Baudrate::BAUD1M;
+    let uart = BufferedUarteTx::new(
         //let trace_uart = BufferedUarteTx::new(
         unsafe { peripherals::SERIAL0::steal() },
         Irqs,
@@ -102,11 +91,14 @@ async fn main(spawner: Spawner) {
         //unsafe { peripherals::P0_14::steal() },
         config,
         unsafe { &mut *addr_of_mut!(TRACE_BUF) },
-    ));
+    );
 
     static STATE: StaticCell<State> = StaticCell::new();
-    let (device, control, runner) = embassy_net_nrf91::new(STATE.init(State::new()), ipc_mem, trace_writer).await;
+    static TRACE: StaticCell<TraceBuffer> = StaticCell::new();
+    let (device, control, runner, tracer) =
+        embassy_net_nrf91::new_with_trace(STATE.init(State::new()), ipc_mem, TRACE.init(TraceBuffer::new())).await;
     unwrap!(spawner.spawn(modem_task(runner)));
+    unwrap!(spawner.spawn(trace_task(uart, tracer)));
 
     let config = embassy_net::Config::default();
 
@@ -127,11 +119,15 @@ async fn main(spawner: Spawner) {
 
     let control = context::Control::new(control, 0).await;
 
-    unwrap!(control.configure(context::Config {
-        apn: "iot.nat.es",
-        auth_prot: context::AuthProt::Pap,
-        auth: Some(("orange", "orange")),
-    }).await);
+    unwrap!(
+        control
+            .configure(context::Config {
+                apn: "iot.nat.es",
+                auth_prot: context::AuthProt::Pap,
+                auth: Some(("orange", "orange")),
+            })
+            .await
+    );
 
     info!("waiting for attach...");
 

From 49881f6fd1e3d77d63dea2313afb5201eca8ebd9 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 14:21:13 +0200
Subject: [PATCH 11/21] rustfmt

---
 embassy-net-nrf91/src/context.rs | 45 ++++++++++++++++++++++----------
 embassy-net-nrf91/src/lib.rs     | 10 +++----
 2 files changed, 35 insertions(+), 20 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 9c67cbc9f..954830417 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -1,8 +1,10 @@
 //! Helper utility to configure a specific modem context.
 use core::net::IpAddr;
 use core::str::FromStr;
+
+use at_commands::builder::CommandBuilder;
+use at_commands::parser::CommandParser;
 use heapless::Vec;
-use at_commands::{builder::CommandBuilder, parser::CommandParser};
 
 /// Provides a higher level API for controlling a given context.
 pub struct Control<'a> {
@@ -91,7 +93,8 @@ impl<'a> Control<'a> {
             .with_int_parameter(self.cid)
             .with_string_parameter("IP")
             .with_string_parameter(config.apn)
-            .finish().map_err(|_| Error::BufferTooSmall)?;
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
@@ -110,7 +113,8 @@ impl<'a> Control<'a> {
         let op = CommandBuilder::create_set(&mut cmd, true)
             .named("+CFUN")
             .with_int_parameter(1)
-            .finish().map_err(|_| Error::BufferTooSmall)?;
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
@@ -124,28 +128,37 @@ impl<'a> Control<'a> {
 
         let op = CommandBuilder::create_query(&mut cmd, true)
             .named("+CGATT")
-            .finish().map_err(|_| Error::BufferTooSmall)?;
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
-        let (res, ) = CommandParser::parse(&buf[..n])
+        let (res,) = CommandParser::parse(&buf[..n])
             .expect_identifier(b"+CGATT: ")
             .expect_int_parameter()
-            .expect_identifier(b"\r\nOK").finish()?;
+            .expect_identifier(b"\r\nOK")
+            .finish()?;
         let attached = res == 1;
         if !attached {
-            return Ok(Status { attached, ip: None, gateway: None, dns: Vec::new() })
+            return Ok(Status {
+                attached,
+                ip: None,
+                gateway: None,
+                dns: Vec::new(),
+            });
         }
 
         let op = CommandBuilder::create_set(&mut cmd, true)
             .named("+CGPADDR")
             .with_int_parameter(self.cid)
-            .finish().map_err(|_| Error::BufferTooSmall)?;
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
-        let (_, ip1, _ip2, ) = CommandParser::parse(&buf[..n])
+        let (_, ip1, _ip2) = CommandParser::parse(&buf[..n])
             .expect_identifier(b"+CGPADDR: ")
             .expect_int_parameter()
             .expect_optional_string_parameter()
             .expect_optional_string_parameter()
-            .expect_identifier(b"\r\nOK").finish()?;
+            .expect_identifier(b"\r\nOK")
+            .finish()?;
 
         let ip = if let Some(ip) = ip1 {
             let ip = IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?;
@@ -158,7 +171,8 @@ impl<'a> Control<'a> {
         let op = CommandBuilder::create_set(&mut cmd, true)
             .named("+CGCONTRDP")
             .with_int_parameter(self.cid)
-            .finish().map_err(|_| Error::BufferTooSmall)?;
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
         let (_cid, _bid, _apn, _mask, gateway, dns1, dns2, _, _, _, _, _mtu) = CommandParser::parse(&buf[..n])
             .expect_identifier(b"+CGCONTRDP: ")
@@ -174,7 +188,8 @@ impl<'a> Control<'a> {
             .expect_optional_int_parameter()
             .expect_optional_int_parameter()
             .expect_optional_int_parameter()
-            .expect_identifier(b"\r\nOK").finish()?;
+            .expect_identifier(b"\r\nOK")
+            .finish()?;
 
         let gateway = if let Some(ip) = gateway {
             if ip.is_empty() {
@@ -188,11 +203,13 @@ impl<'a> Control<'a> {
 
         let mut dns = Vec::new();
         if let Some(ip) = dns1 {
-            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?).unwrap();
+            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?)
+                .unwrap();
         }
 
         if let Some(ip) = dns2 {
-            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?).unwrap();
+            dns.push(IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?)
+                .unwrap();
         }
 
         Ok(Status {
diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index 673784cb2..a60e27d97 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -17,13 +17,12 @@ use core::slice;
 use core::sync::atomic::{compiler_fence, fence, Ordering};
 use core::task::{Poll, Waker};
 
-use embassy_net_driver_channel as ch;
-use embassy_sync::waitqueue::{AtomicWaker, WakerRegistration};
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
-use heapless::Vec;
-use nrf9160_pac as pac;
-use pac::NVIC;
 use embassy_sync::pipe;
+use embassy_sync::waitqueue::{AtomicWaker, WakerRegistration};
+use heapless::Vec;
+use pac::NVIC;
+use {embassy_net_driver_channel as ch, nrf9160_pac as pac};
 
 const RX_SIZE: usize = 8 * 1024;
 const TRACE_SIZE: usize = 16 * 1024;
@@ -269,7 +268,6 @@ pub struct State {
     inner: MaybeUninit<RefCell<StateInner>>,
 }
 
-
 impl State {
     /// Create a new State.
     pub const fn new() -> Self {

From 372e45dabc0cfd3eb495e902665bb752a67aa804 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 18:47:26 +0200
Subject: [PATCH 12/21] Add context run task

---
 embassy-net-nrf91/src/context.rs             | 86 +++++++++++++++++-
 embassy-net-nrf91/src/lib.rs                 |  5 +-
 examples/nrf9160/src/bin/modem_tcp_client.rs | 93 +++++++++++---------
 3 files changed, 137 insertions(+), 47 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 954830417..f73719224 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -5,6 +5,7 @@ use core::str::FromStr;
 use at_commands::builder::CommandBuilder;
 use at_commands::parser::CommandParser;
 use heapless::Vec;
+use embassy_time::{Timer, Duration};
 
 /// Provides a higher level API for controlling a given context.
 pub struct Control<'a> {
@@ -23,6 +24,8 @@ pub struct Config<'a> {
 }
 
 /// Authentication protocol.
+#[derive(Clone, Copy, PartialEq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum AuthProt {
     /// No authentication.
@@ -84,7 +87,7 @@ impl<'a> Control<'a> {
     }
 
     /// Configures the modem with the provided config.
-    pub async fn configure(&self, config: Config<'_>) -> Result<(), Error> {
+    pub async fn configure(&self, config: &Config<'_>) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
 
@@ -118,9 +121,64 @@ impl<'a> Control<'a> {
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("%XPDNCFG")
+            .with_int_parameter(1)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+
+
+
         Ok(())
     }
 
+    /// Attach to the PDN
+    pub async fn attach(&self) -> Result<(), Error> {
+        let mut cmd: [u8; 256] = [0; 256];
+        let mut buf: [u8; 256] = [0; 256];
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGATT")
+            .with_int_parameter(1)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+        Ok(())
+    }
+
+    /// Read current connectivity status for modem.
+    pub async fn detach(&self) -> Result<(), Error> {
+        let mut cmd: [u8; 256] = [0; 256];
+        let mut buf: [u8; 256] = [0; 256];
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CGATT")
+            .with_int_parameter(0)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+        Ok(())
+    }
+
+    async fn attached(&self) -> Result<bool, Error> {
+        let mut cmd: [u8; 256] = [0; 256];
+        let mut buf: [u8; 256] = [0; 256];
+
+        let op = CommandBuilder::create_query(&mut cmd, true)
+            .named("+CGATT")
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        let (res,) = CommandParser::parse(&buf[..n])
+            .expect_identifier(b"+CGATT: ")
+            .expect_int_parameter()
+            .expect_identifier(b"\r\nOK")
+            .finish()?;
+        Ok(res == 1)
+    }
+
     /// Read current connectivity status for modem.
     pub async fn status(&self) -> Result<Status, Error> {
         let mut cmd: [u8; 256] = [0; 256];
@@ -162,7 +220,6 @@ impl<'a> Control<'a> {
 
         let ip = if let Some(ip) = ip1 {
             let ip = IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?;
-            self.control.open_raw_socket().await;
             Some(ip)
         } else {
             None
@@ -219,4 +276,29 @@ impl<'a> Control<'a> {
             dns,
         })
     }
+
+    /// Run a control loop for this context, ensuring that reaattach is handled.
+    pub async fn run<F: Fn(&Status)>(&self, config: &Config<'_>, reattach: F) -> Result<(), Error> {
+        self.configure(config).await?;
+        while !self.attached().await? {
+            Timer::after(Duration::from_secs(1)).await;
+        }
+        let status = self.status().await?;
+        let mut fd = self.control.open_raw_socket().await;
+        reattach(&status);
+
+        loop {
+            if !self.attached().await? {
+                // TODO: self.control.close_raw_socket(fd).await;
+                self.attach().await?;
+                while !self.attached().await? {
+                    Timer::after(Duration::from_secs(1)).await;
+                }
+                let status = self.status().await?;
+                // TODO: let mut fd = self.control.open_raw_socket().await;
+                reattach(&status);
+            }
+            Timer::after(Duration::from_secs(10)).await;
+        }
+    }
 }
diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index a60e27d97..ab3c6f327 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -844,7 +844,7 @@ impl<'a> Control<'a> {
     /// Open the raw socket used for sending/receiving IP packets.
     ///
     /// This must be done after `AT+CFUN=1` (?)
-    async fn open_raw_socket(&self) {
+    async fn open_raw_socket(&self) -> u32 {
         let mut msg: Message = unsafe { mem::zeroed() };
         msg.channel = 2; // data
         msg.id = 0x7001_0004; // open socket
@@ -867,7 +867,8 @@ impl<'a> Control<'a> {
         assert_eq!(status, 0);
         assert_eq!(msg.param_len, 16);
         let fd = u32::from_le_bytes(msg.param[12..16].try_into().unwrap());
-        debug!("got FD: {}", fd);
+        trace!("got FD: {}", fd);
+        fd
     }
 }
 
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index c65e6e153..a6f42eb3b 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -49,6 +49,43 @@ async fn net_task(stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>)
     stack.run().await
 }
 
+#[embassy_executor::task]
+async fn control_task(
+    control: &'static context::Control<'static>,
+    config: context::Config<'static>,
+    stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>,
+) {
+    unwrap!(
+        control
+            .run(&config, |status| {
+                let Some(IpAddr::V4(addr)) = status.ip else {
+                    panic!("Unexpected IP address");
+                };
+                let addr = Ipv4Address(addr.octets());
+
+                let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
+                    Some(Ipv4Address(addr.octets()))
+                } else {
+                    None
+                };
+
+                let mut dns_servers = Vec::new();
+                for dns in status.dns.iter() {
+                    if let IpAddr::V4(ip) = dns {
+                        unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
+                    }
+                }
+
+                stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
+                    address: Ipv4Cidr::new(addr, 32),
+                    gateway,
+                    dns_servers,
+                }));
+            })
+            .await
+    );
+}
+
 #[embassy_executor::task]
 async fn blink_task(pin: AnyPin) {
     let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
@@ -117,50 +154,20 @@ async fn main(spawner: Spawner) {
 
     unwrap!(spawner.spawn(net_task(stack)));
 
-    let control = context::Control::new(control, 0).await;
+    static CONTROL: StaticCell<context::Control<'static>> = StaticCell::new();
+    let control = CONTROL.init(context::Control::new(control, 0).await);
 
-    unwrap!(
-        control
-            .configure(context::Config {
-                apn: "iot.nat.es",
-                auth_prot: context::AuthProt::Pap,
-                auth: Some(("orange", "orange")),
-            })
-            .await
-    );
+    unwrap!(spawner.spawn(control_task(
+        control,
+        context::Config {
+            apn: "iot.nat.es",
+            auth_prot: context::AuthProt::Pap,
+            auth: Some(("orange", "orange")),
+        },
+        stack
+    )));
 
-    info!("waiting for attach...");
-
-    let mut status = unwrap!(control.status().await);
-    while !status.attached && status.ip.is_none() {
-        Timer::after_millis(1000).await;
-        status = unwrap!(control.status().await);
-        info!("STATUS: {:?}", status);
-    }
-
-    let Some(IpAddr::V4(addr)) = status.ip else {
-        panic!("Unexpected IP address");
-    };
-    let addr = Ipv4Address(addr.octets());
-
-    let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
-        Some(Ipv4Address(addr.octets()))
-    } else {
-        None
-    };
-
-    let mut dns_servers = Vec::new();
-    for dns in status.dns {
-        if let IpAddr::V4(ip) = dns {
-            unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
-        }
-    }
-
-    stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
-        address: Ipv4Cidr::new(addr, 32),
-        gateway,
-        dns_servers,
-    }));
+    stack.wait_config_up().await;
 
     let mut rx_buffer = [0; 4096];
     let mut tx_buffer = [0; 4096];
@@ -172,7 +179,7 @@ async fn main(spawner: Spawner) {
         let host_addr = embassy_net::Ipv4Address::from_str("45.79.112.203").unwrap();
         if let Err(e) = socket.connect((host_addr, 4242)).await {
             warn!("connect error: {:?}", e);
-            Timer::after_secs(1).await;
+            Timer::after_secs(10).await;
             continue;
         }
         info!("Connected to {:?}", socket.remote_endpoint());

From ccfa6264b0ad258625f2dd667ba8e6eaca1cfdc3 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Wed, 4 Sep 2024 19:31:55 +0200
Subject: [PATCH 13/21] Add closing if raw socket to handle re-attach

---
 embassy-net-nrf91/src/context.rs             |  8 +++-----
 embassy-net-nrf91/src/lib.rs                 | 15 +++++++++++++++
 examples/nrf9160/src/bin/modem_tcp_client.rs |  2 ++
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index f73719224..511468316 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -4,8 +4,8 @@ use core::str::FromStr;
 
 use at_commands::builder::CommandBuilder;
 use at_commands::parser::CommandParser;
+use embassy_time::{Duration, Timer};
 use heapless::Vec;
-use embassy_time::{Timer, Duration};
 
 /// Provides a higher level API for controlling a given context.
 pub struct Control<'a> {
@@ -129,8 +129,6 @@ impl<'a> Control<'a> {
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
-
-
         Ok(())
     }
 
@@ -289,13 +287,13 @@ impl<'a> Control<'a> {
 
         loop {
             if !self.attached().await? {
-                // TODO: self.control.close_raw_socket(fd).await;
+                self.control.close_raw_socket(fd).await;
                 self.attach().await?;
                 while !self.attached().await? {
                     Timer::after(Duration::from_secs(1)).await;
                 }
                 let status = self.status().await?;
-                // TODO: let mut fd = self.control.open_raw_socket().await;
+                fd = self.control.open_raw_socket().await;
                 reattach(&status);
             }
             Timer::after(Duration::from_secs(10)).await;
diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index ab3c6f327..d8cbe47fc 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -870,6 +870,21 @@ impl<'a> Control<'a> {
         trace!("got FD: {}", fd);
         fd
     }
+
+    async fn close_raw_socket(&self, fd: u32) {
+        let mut msg: Message = unsafe { mem::zeroed() };
+        msg.channel = 2; // data
+        msg.id = 0x7009_0004; // close socket
+        msg.param_len = 8;
+        msg.param[4..8].copy_from_slice(&fd.to_le_bytes());
+
+        self.request(&mut msg, &[], &mut []).await;
+
+        assert_eq!(msg.id, 0x80090004);
+        assert!(msg.param_len >= 12);
+        let status = u32::from_le_bytes(msg.param[8..12].try_into().unwrap());
+        assert_eq!(status, 0);
+    }
 }
 
 /// Background runner for the driver.
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index a6f42eb3b..fb14b746f 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -193,5 +193,7 @@ async fn main(spawner: Spawner) {
             info!("txd: {}", core::str::from_utf8(msg).unwrap());
             Timer::after_secs(1).await;
         }
+        // Test auto-attach
+        unwrap!(control.detach().await);
     }
 }

From 836e8add1bcb09c476a3aa3d7a416a15b8c21e6a Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Thu, 5 Sep 2024 10:02:45 +0200
Subject: [PATCH 14/21] Mintor fixes after testing re-attach

---
 embassy-net-nrf91/src/context.rs             | 20 +++++---
 examples/nrf9160/src/bin/modem_tcp_client.rs | 54 +++++++++++---------
 2 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 511468316..6b841aa16 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -275,24 +275,28 @@ impl<'a> Control<'a> {
         })
     }
 
-    /// Run a control loop for this context, ensuring that reaattach is handled.
-    pub async fn run<F: Fn(&Status)>(&self, config: &Config<'_>, reattach: F) -> Result<(), Error> {
-        self.configure(config).await?;
+    async fn wait_attached(&self) -> Result<Status, Error> {
         while !self.attached().await? {
             Timer::after(Duration::from_secs(1)).await;
         }
         let status = self.status().await?;
+        Ok(status)
+    }
+
+    /// Run a control loop for this context, ensuring that reaattach is handled.
+    pub async fn run<F: Fn(&Status)>(&self, config: &Config<'_>, reattach: F) -> Result<(), Error> {
+        self.configure(config).await?;
+        let status = self.wait_attached().await?;
         let mut fd = self.control.open_raw_socket().await;
         reattach(&status);
 
         loop {
             if !self.attached().await? {
+                trace!("detached");
+
                 self.control.close_raw_socket(fd).await;
-                self.attach().await?;
-                while !self.attached().await? {
-                    Timer::after(Duration::from_secs(1)).await;
-                }
-                let status = self.status().await?;
+                let status = self.wait_attached().await?;
+                trace!("attached");
                 fd = self.control.open_raw_socket().await;
                 reattach(&status);
             }
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index fb14b746f..b7d56802d 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -10,6 +10,7 @@ use core::str::FromStr;
 use defmt::{info, unwrap, warn};
 use embassy_executor::Spawner;
 use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
+use embassy_net_nrf91::context::Status;
 use embassy_net_nrf91::{context, Runner, State, TraceBuffer, TraceReader};
 use embassy_nrf::buffered_uarte::{self, BufferedUarteTx};
 use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
@@ -58,34 +59,38 @@ async fn control_task(
     unwrap!(
         control
             .run(&config, |status| {
-                let Some(IpAddr::V4(addr)) = status.ip else {
-                    panic!("Unexpected IP address");
-                };
-                let addr = Ipv4Address(addr.octets());
-
-                let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
-                    Some(Ipv4Address(addr.octets()))
-                } else {
-                    None
-                };
-
-                let mut dns_servers = Vec::new();
-                for dns in status.dns.iter() {
-                    if let IpAddr::V4(ip) = dns {
-                        unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
-                    }
-                }
-
-                stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
-                    address: Ipv4Cidr::new(addr, 32),
-                    gateway,
-                    dns_servers,
-                }));
+                stack.set_config_v4(status_to_config(status));
             })
             .await
     );
 }
 
+fn status_to_config(status: &Status) -> embassy_net::ConfigV4 {
+    let Some(IpAddr::V4(addr)) = status.ip else {
+        panic!("Unexpected IP address");
+    };
+    let addr = Ipv4Address(addr.octets());
+
+    let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
+        Some(Ipv4Address(addr.octets()))
+    } else {
+        None
+    };
+
+    let mut dns_servers = Vec::new();
+    for dns in status.dns.iter() {
+        if let IpAddr::V4(ip) = dns {
+            unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
+        }
+    }
+
+    embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
+        address: Ipv4Cidr::new(addr, 32),
+        gateway,
+        dns_servers,
+    })
+}
+
 #[embassy_executor::task]
 async fn blink_task(pin: AnyPin) {
     let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
@@ -193,7 +198,6 @@ async fn main(spawner: Spawner) {
             info!("txd: {}", core::str::from_utf8(msg).unwrap());
             Timer::after_secs(1).await;
         }
-        // Test auto-attach
-        unwrap!(control.detach().await);
+        Timer::after_secs(4).await;
     }
 }

From 5d0ed246400b1e7973c1fe870dba977ab7186a21 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Thu, 5 Sep 2024 10:31:51 +0200
Subject: [PATCH 15/21] Move configure out of run

---
 embassy-net-nrf91/src/context.rs             | 3 +--
 examples/nrf9160/src/bin/modem_tcp_client.rs | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 6b841aa16..3671fdd68 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -284,8 +284,7 @@ impl<'a> Control<'a> {
     }
 
     /// Run a control loop for this context, ensuring that reaattach is handled.
-    pub async fn run<F: Fn(&Status)>(&self, config: &Config<'_>, reattach: F) -> Result<(), Error> {
-        self.configure(config).await?;
+    pub async fn run<F: Fn(&Status)>(&self, reattach: F) -> Result<(), Error> {
         let status = self.wait_attached().await?;
         let mut fd = self.control.open_raw_socket().await;
         reattach(&status);
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index b7d56802d..7d78eba0a 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -56,9 +56,10 @@ async fn control_task(
     config: context::Config<'static>,
     stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>,
 ) {
+    unwrap!(control.configure(&config).await);
     unwrap!(
         control
-            .run(&config, |status| {
+            .run(|status| {
                 stack.set_config_v4(status_to_config(status));
             })
             .await

From d71fd447cc4778be8abfdaf510be3a75dac23bf8 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Thu, 5 Sep 2024 11:25:19 +0200
Subject: [PATCH 16/21] Add method for buypassing and running at command
 directly

---
 embassy-net-nrf91/src/context.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 3671fdd68..b936e5f87 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -86,6 +86,11 @@ impl<'a> Control<'a> {
         Self { control, cid }
     }
 
+    /// Perform a raw AT command
+    pub async fn at_command(&self, req: &[u8], resp: &mut [u8]) -> usize {
+        self.control.at_command(req, resp).await
+    }
+
     /// Configures the modem with the provided config.
     pub async fn configure(&self, config: &Config<'_>) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];

From ac7ebea762519505a0ea54ce753ec2a9fc67dfe9 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Fri, 6 Sep 2024 09:34:39 +0200
Subject: [PATCH 17/21] Make sure to CFUN=0 before changing configuration

---
 embassy-net-nrf91/src/context.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index b936e5f87..d5d088ec0 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -92,10 +92,21 @@ impl<'a> Control<'a> {
     }
 
     /// Configures the modem with the provided config.
+    ///
+    /// NOTE: This will disconnect the modem from any current APN and should not
+    /// be called if the configuration has not been changed.
     pub async fn configure(&self, config: &Config<'_>) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
 
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CFUN")
+            .with_int_parameter(0)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+
         let op = CommandBuilder::create_set(&mut cmd, true)
             .named("+CGDCONT")
             .with_int_parameter(self.cid)
@@ -104,6 +115,7 @@ impl<'a> Control<'a> {
             .finish()
             .map_err(|_| Error::BufferTooSmall)?;
         let n = self.control.at_command(op, &mut buf).await;
+        // info!("RES1: {}", unsafe { core::str::from_utf8_unchecked(&buf[..n]) });
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
         let mut op = CommandBuilder::create_set(&mut cmd, true)
@@ -116,6 +128,7 @@ impl<'a> Control<'a> {
         let op = op.finish().map_err(|_| Error::BufferTooSmall)?;
 
         let n = self.control.at_command(op, &mut buf).await;
+        // info!("RES2: {}", unsafe { core::str::from_utf8_unchecked(&buf[..n]) });
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
         let op = CommandBuilder::create_set(&mut cmd, true)

From 5e74434cb8b89b62f7bc0d2a9ab90d94aa11fe4b Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Fri, 6 Sep 2024 09:52:26 +0200
Subject: [PATCH 18/21] Ensure modem is enabled in run()

---
 embassy-net-nrf91/src/context.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index d5d088ec0..2f2452bd0 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -303,6 +303,18 @@ impl<'a> Control<'a> {
 
     /// Run a control loop for this context, ensuring that reaattach is handled.
     pub async fn run<F: Fn(&Status)>(&self, reattach: F) -> Result<(), Error> {
+        let mut cmd: [u8; 256] = [0; 256];
+        let mut buf: [u8; 256] = [0; 256];
+
+        // Make sure modem is enabled
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CFUN")
+            .with_int_parameter(1)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
         let status = self.wait_attached().await?;
         let mut fd = self.control.open_raw_socket().await;
         reattach(&status);

From e2e3143c2ea9a606eff2fa1d4e51a74824b5c2ac Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Fri, 6 Sep 2024 09:58:54 +0200
Subject: [PATCH 19/21] Add explicit disable/enable function and skip enable in
 configure

---
 embassy-net-nrf91/src/context.rs | 55 ++++++++++++++++++++------------
 1 file changed, 35 insertions(+), 20 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 2f2452bd0..22629fe5b 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -95,6 +95,8 @@ impl<'a> Control<'a> {
     ///
     /// NOTE: This will disconnect the modem from any current APN and should not
     /// be called if the configuration has not been changed.
+    ///
+    /// After configuring, invoke [`enable()`] to activate the configuration.
     pub async fn configure(&self, config: &Config<'_>) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
@@ -131,22 +133,6 @@ impl<'a> Control<'a> {
         // info!("RES2: {}", unsafe { core::str::from_utf8_unchecked(&buf[..n]) });
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
 
-        let op = CommandBuilder::create_set(&mut cmd, true)
-            .named("+CFUN")
-            .with_int_parameter(1)
-            .finish()
-            .map_err(|_| Error::BufferTooSmall)?;
-        let n = self.control.at_command(op, &mut buf).await;
-        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
-
-        let op = CommandBuilder::create_set(&mut cmd, true)
-            .named("%XPDNCFG")
-            .with_int_parameter(1)
-            .finish()
-            .map_err(|_| Error::BufferTooSmall)?;
-        let n = self.control.at_command(op, &mut buf).await;
-        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
-
         Ok(())
     }
 
@@ -301,20 +287,49 @@ impl<'a> Control<'a> {
         Ok(status)
     }
 
-    /// Run a control loop for this context, ensuring that reaattach is handled.
-    pub async fn run<F: Fn(&Status)>(&self, reattach: F) -> Result<(), Error> {
+    /// Disable modem
+    pub async fn disable(&self) -> Result<(), Error> {
+        let mut cmd: [u8; 256] = [0; 256];
+        let mut buf: [u8; 256] = [0; 256];
+
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("+CFUN")
+            .with_int_parameter(0)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+
+        Ok(())
+    }
+
+    /// Enable modem
+    pub async fn enable(&self) -> Result<(), Error> {
         let mut cmd: [u8; 256] = [0; 256];
         let mut buf: [u8; 256] = [0; 256];
 
-        // Make sure modem is enabled
         let op = CommandBuilder::create_set(&mut cmd, true)
             .named("+CFUN")
             .with_int_parameter(1)
             .finish()
             .map_err(|_| Error::BufferTooSmall)?;
-
         let n = self.control.at_command(op, &mut buf).await;
         CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+
+        // Make modem survive PDN detaches
+        let op = CommandBuilder::create_set(&mut cmd, true)
+            .named("%XPDNCFG")
+            .with_int_parameter(1)
+            .finish()
+            .map_err(|_| Error::BufferTooSmall)?;
+        let n = self.control.at_command(op, &mut buf).await;
+        CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
+        Ok(())
+    }
+
+    /// Run a control loop for this context, ensuring that reaattach is handled.
+    pub async fn run<F: Fn(&Status)>(&self, reattach: F) -> Result<(), Error> {
+        self.enable().await?;
         let status = self.wait_attached().await?;
         let mut fd = self.control.open_raw_socket().await;
         reattach(&status);

From 1b1db2401bfdfe6f813fb7738529749e4ec80882 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Fri, 6 Sep 2024 11:22:07 +0200
Subject: [PATCH 20/21] Use byte slice for config

---
 embassy-net-nrf91/src/context.rs             | 4 ++--
 examples/nrf9160/src/bin/modem_tcp_client.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/embassy-net-nrf91/src/context.rs b/embassy-net-nrf91/src/context.rs
index 22629fe5b..8b45919ef 100644
--- a/embassy-net-nrf91/src/context.rs
+++ b/embassy-net-nrf91/src/context.rs
@@ -16,11 +16,11 @@ pub struct Control<'a> {
 /// Configuration for a given context
 pub struct Config<'a> {
     /// Desired APN address.
-    pub apn: &'a str,
+    pub apn: &'a [u8],
     /// Desired authentication protocol.
     pub auth_prot: AuthProt,
     /// Credentials.
-    pub auth: Option<(&'a str, &'a str)>,
+    pub auth: Option<(&'a [u8], &'a [u8])>,
 }
 
 /// Authentication protocol.
diff --git a/examples/nrf9160/src/bin/modem_tcp_client.rs b/examples/nrf9160/src/bin/modem_tcp_client.rs
index 7d78eba0a..5335b6b51 100644
--- a/examples/nrf9160/src/bin/modem_tcp_client.rs
+++ b/examples/nrf9160/src/bin/modem_tcp_client.rs
@@ -166,9 +166,9 @@ async fn main(spawner: Spawner) {
     unwrap!(spawner.spawn(control_task(
         control,
         context::Config {
-            apn: "iot.nat.es",
+            apn: b"iot.nat.es",
             auth_prot: context::AuthProt::Pap,
-            auth: Some(("orange", "orange")),
+            auth: Some((b"orange", b"orange")),
         },
         stack
     )));

From 6af1cb7a20fe15750b353e2e6af6832786f8c065 Mon Sep 17 00:00:00 2001
From: Ulf Lilleengen <ulf@digili.no>
Date: Mon, 9 Sep 2024 15:45:15 +0200
Subject: [PATCH 21/21] Use TX_BUF_SIZE matching MTU

---
 embassy-net-nrf91/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-net-nrf91/src/lib.rs b/embassy-net-nrf91/src/lib.rs
index d8cbe47fc..60cdc38c6 100644
--- a/embassy-net-nrf91/src/lib.rs
+++ b/embassy-net-nrf91/src/lib.rs
@@ -279,7 +279,7 @@ impl State {
 }
 
 const TX_BUF_COUNT: usize = 4;
-const TX_BUF_SIZE: usize = 1024;
+const TX_BUF_SIZE: usize = 1500;
 
 struct TraceChannelInfo {
     ptr: *mut TraceChannel,