13 files changed, 340 insertions, 58 deletions

diff --git a/ci.sh b/ci.sh
index a585a3ab8..e1197f397 100755
--- a/ci.sh
+++ b/ci.sh
@@ -193,18 +193,19 @@ cargo batch \
     --- build --release --manifest-path embassy-nxp/Cargo.toml --target thumbv8m.main-none-eabihf --features lpc55,defmt \
     --- build --release --manifest-path embassy-nxp/Cargo.toml --target thumbv7em-none-eabihf --features mimxrt1011,rt,defmt,time-driver-pit \
     --- build --release --manifest-path embassy-nxp/Cargo.toml --target thumbv7em-none-eabihf --features mimxrt1062,rt,defmt,time-driver-pit \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0c1104dgs20,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3507pm,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3519pz,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1306rhb,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l2228pn,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1345dgs28,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1106dgs28,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1228pm,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1107ycj,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3105rhb,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1505pt,defmt,time-driver-any \
-    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1519rhb,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0c1104dgs20,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0c1106rgz,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3507pm,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3519pz,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1306rhb,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l2228pn,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1345dgs28,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1106dgs28,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0l1228pm,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1107ycj,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g3105rhb,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1505pt,rt,defmt,time-driver-any \
+    --- build --release --manifest-path embassy-mspm0/Cargo.toml --target thumbv6m-none-eabi --features mspm0g1519rhb,rt,defmt,time-driver-any \
     --- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features ''\
     --- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features 'log' \
     --- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features 'defmt' \
diff --git a/embassy-executor/CHANGELOG.md b/embassy-executor/CHANGELOG.md
index 3e6c180c6..a36d270ba 100644
--- a/embassy-executor/CHANGELOG.md
+++ b/embassy-executor/CHANGELOG.md
@@ -20,8 +20,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added `extern "Rust" fn __embassy_time_queue_item_from_waker`
 - Removed `TaskRef::dangling`
-- Added `embassy_time_queue_utils` as a dependency
-- Moved the `TimeQueueItem` struct and `timer-item-payload-size-*` features into embassy-time-queue-utils
+- Added `embassy-executor-timer-queue` as a dependency
+- Moved the `TimeQueueItem` struct and `timer-item-payload-size-*` features (as `timer-item-size-X-words`) into `embassy-executor-timer-queue`
 
 ## 0.8.0 - 2025-07-31
 
diff --git a/embassy-executor/Cargo.toml b/embassy-executor/Cargo.toml
index dc423aba2..ed72a585f 100644
--- a/embassy-executor/Cargo.toml
+++ b/embassy-executor/Cargo.toml
@@ -125,19 +125,3 @@ trace = ["_any_trace"]
 ## Enable support for rtos-trace framework
 rtos-trace = ["_any_trace", "metadata-name", "dep:rtos-trace", "dep:embassy-time-driver"]
 _any_trace = []
-
-#! ### Timer Item Payload Size
-#! Sets the size of the payload for timer items, allowing integrated timer implementors to store
-#! additional data in the timer item. The payload field will be aligned to this value as well.
-#! If these features are not defined, the timer item will contain no payload field.
-
-_timer-item-payload = [] # A size was picked
-
-## 1 bytes
-timer-item-payload-size-1 = ["_timer-item-payload"]
-## 2 bytes
-timer-item-payload-size-2 = ["_timer-item-payload"]
-## 4 bytes
-timer-item-payload-size-4 = ["_timer-item-payload"]
-## 8 bytes
-timer-item-payload-size-8 = ["_timer-item-payload"]
diff --git a/embassy-mspm0/CHANGELOG.md b/embassy-mspm0/CHANGELOG.md
index eca0defd7..c7da4eb33 100644
--- a/embassy-mspm0/CHANGELOG.md
+++ b/embassy-mspm0/CHANGELOG.md
@@ -7,7 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- next-header -->
 ## Unreleased - ReleaseDate
-
+ 
 - feat: Add I2C Controller (blocking & async) + examples for mspm0l1306, mspm0g3507 (tested MCUs) (#4435)
 - fix gpio interrupt not being set for mspm0l110x
 - feat: Add window watchdog implementation based on WWDT0, WWDT1 peripherals (#4574)
+- feat: Add MSPM0C1105/C1106 support
diff --git a/embassy-mspm0/Cargo.toml b/embassy-mspm0/Cargo.toml
index 92f7a2655..1b32c4d43 100644
--- a/embassy-mspm0/Cargo.toml
+++ b/embassy-mspm0/Cargo.toml
@@ -69,7 +69,7 @@ cortex-m = "0.7.6"
 critical-section = "1.2.0"
 
 # mspm0-metapac = { version = "" }
-mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-fe17d879548757ca29821da66a1bebf2debd4846" }
+mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-d7bf3d01ac0780e716a45b0474234d39443dc5cf" }
 
 [build-dependencies]
 proc-macro2 = "1.0.94"
@@ -77,7 +77,7 @@ quote = "1.0.40"
 cfg_aliases = "0.2.1"
 
 # mspm0-metapac = { version = "", default-features = false, features = ["metadata"] }
-mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-fe17d879548757ca29821da66a1bebf2debd4846", default-features = false, features = ["metadata"] }
+mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-d7bf3d01ac0780e716a45b0474234d39443dc5cf", default-features = false, features = ["metadata"] }
 
 [features]
 default = ["rt"]
@@ -159,6 +159,24 @@ mspm0c1104dsg = ["mspm0-metapac/mspm0c1104dsg"]
 mspm0c1104dyy = ["mspm0-metapac/mspm0c1104dyy"]
 mspm0c1104ruk = ["mspm0-metapac/mspm0c1104ruk"]
 mspm0c1104ycj = ["mspm0-metapac/mspm0c1104ycj"]
+mspm0c1105pt = ["mspm0-metapac/mspm0c1105pt"]
+mspm0c1105rgz = ["mspm0-metapac/mspm0c1105rgz"]
+mspm0c1105rhb = ["mspm0-metapac/mspm0c1105rhb"]
+mspm0c1105dgs32 = ["mspm0-metapac/mspm0c1105dgs32"]
+mspm0c1105dgs28 = ["mspm0-metapac/mspm0c1105dgs28"]
+mspm0c1105rge = ["mspm0-metapac/mspm0c1105rge"]
+mspm0c1105dgs20 = ["mspm0-metapac/mspm0c1105dgs20"]
+mspm0c1105ruk = ["mspm0-metapac/mspm0c1105ruk"]
+mspm0c1105zcm = ["mspm0-metapac/mspm0c1105zcm"]
+mspm0c1106pt = ["mspm0-metapac/mspm0c1106pt"]
+mspm0c1106rgz = ["mspm0-metapac/mspm0c1106rgz"]
+mspm0c1106rhb = ["mspm0-metapac/mspm0c1106rhb"]
+mspm0c1106dgs32 = ["mspm0-metapac/mspm0c1106dgs32"]
+mspm0c1106dgs28 = ["mspm0-metapac/mspm0c1106dgs28"]
+mspm0c1106rge = ["mspm0-metapac/mspm0c1106rge"]
+mspm0c1106dgs20 = ["mspm0-metapac/mspm0c1106dgs20"]
+mspm0c1106ruk = ["mspm0-metapac/mspm0c1106ruk"]
+mspm0c1106zcm = ["mspm0-metapac/mspm0c1106zcm"]
 mspm0g1105dgs28 = ["mspm0-metapac/mspm0g1105dgs28"]
 mspm0g1105pm = ["mspm0-metapac/mspm0g1105pm"]
 mspm0g1105pt = ["mspm0-metapac/mspm0g1105pt"]
diff --git a/embassy-mspm0/build.rs b/embassy-mspm0/build.rs
index 256192f8b..e8364e31a 100644
--- a/embassy-mspm0/build.rs
+++ b/embassy-mspm0/build.rs
@@ -79,10 +79,14 @@ fn get_chip_cfgs(chip_name: &str) -> Vec<String> {
     let mut cfgs = Vec::new();
 
     // GPIO on C110x is special as it does not belong to an interrupt group.
-    if chip_name.starts_with("mspm0c110") || chip_name.starts_with("msps003f") {
+    if chip_name.starts_with("mspm0c1103") || chip_name.starts_with("mspm0c1104") || chip_name.starts_with("msps003f") {
         cfgs.push("mspm0c110x".to_string());
     }
 
+    if chip_name.starts_with("mspm0c1105") || chip_name.starts_with("mspm0c1106") {
+        cfgs.push("mspm0c1105_c1106".to_string());
+    }
+
     // Family ranges (temporary until int groups are generated)
     //
     // TODO: Remove this once int group stuff is generated.
@@ -537,6 +541,8 @@ fn generate_interrupts() -> TokenStream {
         pub fn enable_group_interrupts(_cs: critical_section::CriticalSection) {
             use crate::interrupt::typelevel::Interrupt;
 
+            // This is empty for C1105/6
+            #[allow(unused_unsafe)]
             unsafe {
                 #(#group_interrupt_enables)*
             }
diff --git a/embassy-mspm0/src/gpio.rs b/embassy-mspm0/src/gpio.rs
index f77848888..d5fd36dbf 100644
--- a/embassy-mspm0/src/gpio.rs
+++ b/embassy-mspm0/src/gpio.rs
@@ -10,7 +10,7 @@ use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::pac::gpio::vals::*;
 use crate::pac::gpio::{self};
-#[cfg(all(feature = "rt", any(mspm0c110x, mspm0l110x)))]
+#[cfg(all(feature = "rt", any(mspm0c110x, mspm0c1105_c1106, mspm0l110x)))]
 use crate::pac::interrupt;
 use crate::pac::{self};
 
@@ -1108,24 +1108,30 @@ fn irq_handler(gpio: gpio::Gpio, wakers: &[AtomicWaker; 32]) {
 // C110x and L110x have a dedicated interrupts just for GPIOA.
 //
 // These chips do not have a GROUP1 interrupt.
-#[cfg(all(feature = "rt", any(mspm0c110x, mspm0l110x)))]
+#[cfg(all(feature = "rt", any(mspm0c110x, mspm0c1105_c1106, mspm0l110x)))]
 #[interrupt]
 fn GPIOA() {
     irq_handler(pac::GPIOA, &PORTA_WAKERS);
 }
 
+#[cfg(all(feature = "rt", mspm0c1105_c1106))]
+#[interrupt]
+fn GPIOB() {
+    irq_handler(pac::GPIOB, &PORTB_WAKERS);
+}
+
 // These symbols are weakly defined as DefaultHandler and are called by the interrupt group implementation.
 //
 // Defining these as no_mangle is required so that the linker will pick these over the default handler.
 
-#[cfg(all(feature = "rt", not(any(mspm0c110x, mspm0l110x))))]
+#[cfg(all(feature = "rt", not(any(mspm0c110x, mspm0c1105_c1106, mspm0l110x))))]
 #[no_mangle]
 #[allow(non_snake_case)]
 fn GPIOA() {
     irq_handler(pac::GPIOA, &PORTA_WAKERS);
 }
 
-#[cfg(all(feature = "rt", gpio_pb))]
+#[cfg(all(feature = "rt", gpio_pb, not(mspm0c1105_c1106)))]
 #[no_mangle]
 #[allow(non_snake_case)]
 fn GPIOB() {
diff --git a/embassy-mspm0/src/i2c.rs b/embassy-mspm0/src/i2c.rs
index 7e22bb724..1906e37ba 100644
--- a/embassy-mspm0/src/i2c.rs
+++ b/embassy-mspm0/src/i2c.rs
@@ -195,7 +195,7 @@ impl Config {
             .unwrap();
     }
 
-    #[cfg(any(mspm0c110x))]
+    #[cfg(any(mspm0c110x, mspm0c1105_c1106))]
     fn calculate_clock_source(&self) -> u32 {
         // Assume that BusClk has default value.
         // TODO: calculate BusClk more precisely.
diff --git a/embassy-stm32/CHANGELOG.md b/embassy-stm32/CHANGELOG.md
index dfb8ca066..4cc48ed97 100644
--- a/embassy-stm32/CHANGELOG.md
+++ b/embassy-stm32/CHANGELOG.md
@@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## Unreleased - ReleaseDate
 
 - fix: Fixed STM32H5 builds requiring time feature
+- feat: Derive Clone, Copy for QSPI Config
+- fix: stm32/i2c in master mode (blocking): subsequent transmissions failed after a NACK was received
+- feat: stm32/timer: add set_polarity functions for main and complementary outputs in complementary_pwm
 
 ## 0.4.0 - 2025-08-26
 
diff --git a/embassy-stm32/src/i2c/v2.rs b/embassy-stm32/src/i2c/v2.rs
index 3b09f1b34..6b20a601b 100644
--- a/embassy-stm32/src/i2c/v2.rs
+++ b/embassy-stm32/src/i2c/v2.rs
@@ -454,7 +454,8 @@ impl<'d, M: Mode, IM: MasterMode> I2c<'d, M, IM> {
                 // (START has been ACKed or last byte when
                 // through)
                 if let Err(err) = self.wait_txis(timeout) {
-                    if send_stop {
+                    if send_stop && err != Error::Nack {
+                        // STOP is sent automatically if a NACK was received
                         self.master_stop();
                     }
                     return Err(err);
@@ -548,7 +549,9 @@ impl<'d, M: Mode, IM: MasterMode> I2c<'d, M, IM> {
                     (idx != last_slice_index) || (slice_len > 255),
                     timeout,
                 ) {
-                    self.master_stop();
+                    if err != Error::Nack {
+                        self.master_stop();
+                    }
                     return Err(err);
                 }
             }
@@ -561,7 +564,9 @@ impl<'d, M: Mode, IM: MasterMode> I2c<'d, M, IM> {
                         (number != last_chunk_idx) || (idx != last_slice_index),
                         timeout,
                     ) {
-                        self.master_stop();
+                        if err != Error::Nack {
+                            self.master_stop();
+                        }
                         return Err(err);
                     }
                 }
@@ -571,7 +576,9 @@ impl<'d, M: Mode, IM: MasterMode> I2c<'d, M, IM> {
                     // (START has been ACKed or last byte when
                     // through)
                     if let Err(err) = self.wait_txis(timeout) {
-                        self.master_stop();
+                        if err != Error::Nack {
+                            self.master_stop();
+                        }
                         return Err(err);
                     }
 
diff --git a/embassy-stm32/src/qspi/mod.rs b/embassy-stm32/src/qspi/mod.rs
index 1e20d7cd3..c0cd216f0 100644
--- a/embassy-stm32/src/qspi/mod.rs
+++ b/embassy-stm32/src/qspi/mod.rs
@@ -17,6 +17,7 @@ use crate::rcc::{self, RccPeripheral};
 use crate::{peripherals, Peri};
 
 /// QSPI transfer configuration.
+#[derive(Clone, Copy)]
 pub struct TransferConfig {
     /// Instruction width (IMODE)
     pub iwidth: QspiWidth,
@@ -46,6 +47,7 @@ impl Default for TransferConfig {
 }
 
 /// QSPI driver configuration.
+#[derive(Clone, Copy)]
 pub struct Config {
     /// Flash memory size representend as 2^[0-32], as reasonable minimum 1KiB(9) was chosen.
     /// If you need other value the whose predefined use `Other` variant.
diff --git a/embassy-stm32/src/timer/complementary_pwm.rs b/embassy-stm32/src/timer/complementary_pwm.rs
index b291fc155..7d6c2273e 100644
--- a/embassy-stm32/src/timer/complementary_pwm.rs
+++ b/embassy-stm32/src/timer/complementary_pwm.rs
@@ -185,6 +185,16 @@ impl<'d, T: AdvancedInstance4Channel> ComplementaryPwm<'d, T> {
         self.inner.set_complementary_output_polarity(channel, polarity);
     }
 
+    /// Set the main output polarity for a given channel.
+    pub fn set_main_polarity(&mut self, channel: Channel, polarity: OutputPolarity) {
+        self.inner.set_output_polarity(channel, polarity);
+    }
+
+    /// Set the complementary output polarity for a given channel.
+    pub fn set_complementary_polarity(&mut self, channel: Channel, polarity: OutputPolarity) {
+        self.inner.set_complementary_output_polarity(channel, polarity);
+    }
+
     /// Set the dead time as a proportion of max_duty
     pub fn set_dead_time(&mut self, value: u16) {
         let (ckd, value) = compute_dead_time_value(value);
diff --git a/examples/nrf52840/src/bin/nfct.rs b/examples/nrf52840/src/bin/nfct.rs
index d559d006a..fafa37f48 100644
--- a/examples/nrf52840/src/bin/nfct.rs
+++ b/examples/nrf52840/src/bin/nfct.rs
@@ -1,11 +1,12 @@
 #![no_std]
 #![no_main]
 
-use defmt::*;
+use defmt::{todo, *};
 use embassy_executor::Spawner;
 use embassy_nrf::config::HfclkSource;
 use embassy_nrf::nfct::{Config as NfcConfig, NfcId, NfcT};
 use embassy_nrf::{bind_interrupts, nfct};
+use iso14443_4::{Card, IsoDep};
 use {defmt_rtt as _, embassy_nrf as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -30,12 +31,28 @@ async fn main(_spawner: Spawner) {
 
     let mut buf = [0u8; 256];
 
+    let cc = &[
+        0x00, 0x0f, /* CCEN_HI, CCEN_LOW */
+        0x20, /* VERSION */
+        0x00, 0x7f, /* MLe_HI, MLe_LOW */
+        0x00, 0x7f, /* MLc_HI, MLc_LOW */
+        /* TLV */
+        0x04, 0x06, 0xe1, 0x04, 0x00, 0x7f, 0x00, 0x00,
+    ];
+
+    let ndef = &[
+        0x00, 0x10, 0xd1, 0x1, 0xc, 0x55, 0x4, 0x65, 0x6d, 0x62, 0x61, 0x73, 0x73, 0x79, 0x2e, 0x64, 0x65, 0x76,
+    ];
+    let mut selected: &[u8] = cc;
+
     loop {
         info!("activating");
         nfc.activate().await;
+        info!("activated!");
+
+        let mut nfc = IsoDep::new(iso14443_3::Logger(&mut nfc));
 
         loop {
-            info!("rxing");
             let n = match nfc.receive(&mut buf).await {
                 Ok(n) => n,
                 Err(e) => {
@@ -44,25 +61,51 @@ async fn main(_spawner: Spawner) {
                 }
             };
             let req = &buf[..n];
-            info!("received frame {:02x}", req);
+            info!("iso-dep rx {:02x}", req);
 
-            let mut deselect = false;
-            let resp = match req {
-                [0xe0, ..] => {
-                    info!("Got RATS, tx'ing ATS");
-                    &[0x06, 0x77, 0x77, 0x81, 0x02, 0x80][..]
+            let Ok(apdu) = Apdu::parse(req) else {
+                error!("apdu parse error");
+                break;
+            };
+
+            info!("apdu: {:?}", apdu);
+
+            let resp = match (apdu.cla, apdu.ins, apdu.p1, apdu.p2) {
+                (0, 0xa4, 4, 0) => {
+                    info!("select app");
+                    &[0x90, 0x00][..]
                 }
-                [0xc2] => {
-                    info!("Got deselect!");
-                    deselect = true;
-                    &[0xc2]
+                (0, 0xa4, 0, 12) => {
+                    info!("select df");
+                    match apdu.data {
+                        [0xe1, 0x03] => {
+                            selected = cc;
+                            &[0x90, 0x00][..]
+                        }
+                        [0xe1, 0x04] => {
+                            selected = ndef;
+                            &[0x90, 0x00][..]
+                        }
+                        _ => todo!(), // return NOT FOUND
+                    }
+                }
+                (0, 0xb0, p1, p2) => {
+                    info!("read");
+                    let offs = u16::from_be_bytes([p1 & 0x7f, p2]) as usize;
+                    let len = if apdu.le == 0 { usize::MAX } else { apdu.le as usize };
+                    let n = len.min(selected.len() - offs);
+                    buf[..n].copy_from_slice(&selected[offs..][..n]);
+                    buf[n..][..2].copy_from_slice(&[0x90, 0x00]);
+                    &buf[..n + 2]
                 }
                 _ => {
                     info!("Got unknown command!");
-                    &[0xFF]
+                    &[0xFF, 0xFF]
                 }
             };
 
+            info!("iso-dep tx {:02x}", resp);
+
             match nfc.transmit(resp).await {
                 Ok(()) => {}
                 Err(e) => {
@@ -70,10 +113,211 @@ async fn main(_spawner: Spawner) {
                     break;
                 }
             }
+        }
+    }
+}
 
-            if deselect {
-                break;
+#[derive(Debug, Clone, defmt::Format)]
+struct Apdu<'a> {
+    pub cla: u8,
+    pub ins: u8,
+    pub p1: u8,
+    pub p2: u8,
+    pub data: &'a [u8],
+    pub le: u16,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, defmt::Format)]
+struct ApduParseError;
+
+impl<'a> Apdu<'a> {
+    pub fn parse(apdu: &'a [u8]) -> Result<Self, ApduParseError> {
+        if apdu.len() < 4 {
+            return Err(ApduParseError);
+        }
+
+        let (data, le) = match apdu.len() - 4 {
+            0 => (&[][..], 0),
+            1 => (&[][..], apdu[4]),
+            n if n == 1 + apdu[4] as usize && apdu[4] != 0 => (&apdu[5..][..apdu[4] as usize], 0),
+            n if n == 2 + apdu[4] as usize && apdu[4] != 0 => (&apdu[5..][..apdu[4] as usize], apdu[apdu.len() - 1]),
+            _ => return Err(ApduParseError),
+        };
+
+        Ok(Apdu {
+            cla: apdu[0],
+            ins: apdu[1],
+            p1: apdu[2],
+            p2: apdu[3],
+            data,
+            le: le as _,
+        })
+    }
+}
+
+mod iso14443_3 {
+    use core::future::Future;
+
+    use defmt::info;
+    use embassy_nrf::nfct::{Error, NfcT};
+
+    pub trait Card {
+        type Error;
+        async fn receive(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
+        async fn transmit(&mut self, buf: &[u8]) -> Result<(), Self::Error>;
+    }
+
+    impl<'a, T: Card> Card for &'a mut T {
+        type Error = T::Error;
+
+        fn receive(&mut self, buf: &mut [u8]) -> impl Future<Output = Result<usize, Self::Error>> {
+            T::receive(self, buf)
+        }
+
+        fn transmit(&mut self, buf: &[u8]) -> impl Future<Output = Result<(), Self::Error>> {
+            T::transmit(self, buf)
+        }
+    }
+
+    impl<'a> Card for NfcT<'a> {
+        type Error = Error;
+
+        fn receive(&mut self, buf: &mut [u8]) -> impl Future<Output = Result<usize, Self::Error>> {
+            self.receive(buf)
+        }
+
+        fn transmit(&mut self, buf: &[u8]) -> impl Future<Output = Result<(), Self::Error>> {
+            self.transmit(buf)
+        }
+    }
+
+    pub struct Logger<T: Card>(pub T);
+
+    impl<T: Card> Card for Logger<T> {
+        type Error = T::Error;
+
+        async fn receive(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+            let n = T::receive(&mut self.0, buf).await?;
+            info!("<- {:02x}", &buf[..n]);
+            Ok(n)
+        }
+
+        fn transmit(&mut self, buf: &[u8]) -> impl Future<Output = Result<(), Self::Error>> {
+            info!("-> {:02x}", buf);
+            T::transmit(&mut self.0, buf)
+        }
+    }
+}
+
+mod iso14443_4 {
+    use defmt::info;
+
+    use crate::iso14443_3;
+
+    #[derive(defmt::Format)]
+    pub enum Error<T> {
+        Deselected,
+        Protocol,
+        Lower(T),
+    }
+
+    pub trait Card {
+        type Error;
+        async fn receive(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
+        async fn transmit(&mut self, buf: &[u8]) -> Result<(), Self::Error>;
+    }
+
+    pub struct IsoDep<T: iso14443_3::Card> {
+        nfc: T,
+
+        /// Block count spin bit: 0 or 1
+        block_num: u8,
+
+        /// true if deselected. This is permanent, you must create another IsoDep
+        /// instance if we get selected again.
+        deselected: bool,
+
+        /// last response, in case we need to retransmit.
+        resp: [u8; 256],
+        resp_len: usize,
+    }
+
+    impl<T: iso14443_3::Card> IsoDep<T> {
+        pub fn new(nfc: T) -> Self {
+            Self {
+                nfc,
+                block_num: 1,
+                deselected: false,
+                resp: [0u8; 256],
+                resp_len: 0,
             }
         }
     }
+
+    impl<T: iso14443_3::Card> Card for IsoDep<T> {
+        type Error = Error<T::Error>;
+
+        async fn receive(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+            if self.deselected {
+                return Err(Error::Deselected);
+            }
+
+            let mut temp = [0u8; 256];
+
+            loop {
+                let n = self.nfc.receive(&mut temp).await.map_err(Error::Lower)?;
+                assert!(n != 0);
+                match temp[0] {
+                    0x02 | 0x03 => {
+                        self.block_num ^= 0x01;
+                        assert!(temp[0] == 0x02 | self.block_num);
+                        buf[..n - 1].copy_from_slice(&temp[1..n]);
+                        return Ok(n - 1);
+                    }
+                    0xb2 | 0xb3 => {
+                        if temp[0] & 0x01 != self.block_num {
+                            info!("Got NAK, transmitting ACK.");
+                            let resp = &[0xA2 | self.block_num];
+                            self.nfc.transmit(resp).await.map_err(Error::Lower)?;
+                        } else {
+                            info!("Got NAK, retransmitting.");
+                            let resp: &[u8] = &self.resp[..self.resp_len];
+                            self.nfc.transmit(resp).await.map_err(Error::Lower)?;
+                        }
+                    }
+                    0xe0 => {
+                        info!("Got RATS, tx'ing ATS");
+                        let resp = &[0x06, 0x77, 0x77, 0x81, 0x02, 0x80];
+                        self.nfc.transmit(resp).await.map_err(Error::Lower)?;
+                    }
+                    0xc2 => {
+                        info!("Got deselect!");
+                        self.deselected = true;
+                        let resp = &[0xC2];
+                        self.nfc.transmit(resp).await.map_err(Error::Lower)?;
+                        return Err(Error::Deselected);
+                    }
+                    _ => {
+                        info!("Got unknown command {:02x}!", temp[0]);
+                        return Err(Error::Protocol);
+                    }
+                };
+            }
+        }
+
+        async fn transmit(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+            if self.deselected {
+                return Err(Error::Deselected);
+            }
+
+            self.resp[0] = 0x02 | self.block_num;
+            self.resp[1..][..buf.len()].copy_from_slice(buf);
+            self.resp_len = 1 + buf.len();
+
+            let resp: &[u8] = &self.resp[..self.resp_len];
+            self.nfc.transmit(resp).await.map_err(Error::Lower)?;
+
+            Ok(())
+        }
+    }
 }