Merge branch 'main' into adc_with_clock

5 files changed, 410 insertions, 17 deletions

diff --git a/examples/nrf-rtos-trace/Cargo.toml b/examples/nrf-rtos-trace/Cargo.toml
index a2dc0c7ad..c9eeaaac7 100644
--- a/examples/nrf-rtos-trace/Cargo.toml
+++ b/examples/nrf-rtos-trace/Cargo.toml
@@ -25,8 +25,8 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 panic-probe = "1.0.0"
 serde = { version = "1.0.136", default-features = false }
-rtos-trace = "0.1.3"
-systemview-target = { version = "0.1.2", features = ["callbacks-app", "callbacks-os", "log", "cortex-m"] }
+rtos-trace = "0.2"
+systemview-target = { version = "0.2", features = ["callbacks-app", "callbacks-os", "log", "cortex-m"] }
 log = { version = "0.4.17", optional = true }
 
 [[bin]]
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(())
+        }
+    }
 }
diff --git a/examples/stm32h5/src/bin/sai.rs b/examples/stm32h5/src/bin/sai.rs
new file mode 100644
index 000000000..0e182f9cf
--- /dev/null
+++ b/examples/stm32h5/src/bin/sai.rs
@@ -0,0 +1,52 @@
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_stm32::{sai, Config};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Hello world.");
+
+    let mut config = Config::default();
+    {
+        use embassy_stm32::rcc::*;
+
+        config.rcc.pll2 = Some(Pll {
+            source: PllSource::HSI,
+            prediv: PllPreDiv::DIV16,
+            mul: PllMul::MUL32,
+            divp: Some(PllDiv::DIV16), // 8 MHz SAI clock
+            divq: None,
+            divr: None,
+        });
+
+        config.rcc.mux.sai1sel = mux::Saisel::PLL2_P;
+    }
+    let p = embassy_stm32::init(config);
+
+    let mut write_buffer = [0u16; 1024];
+    let (_, sai_b) = sai::split_subblocks(p.SAI1);
+
+    let mut sai_b = sai::Sai::new_asynchronous(
+        sai_b,
+        p.PF8,
+        p.PE3,
+        p.PF9,
+        p.GPDMA1_CH0,
+        &mut write_buffer,
+        Default::default(),
+    );
+
+    // Populate arbitrary data.
+    let mut data = [0u16; 256];
+    for (index, sample) in data.iter_mut().enumerate() {
+        *sample = index as u16;
+    }
+
+    loop {
+        sai_b.write(&data).await.unwrap();
+    }
+}
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index 90f57a2d8..d42cdac15 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -11,6 +11,8 @@ embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = ["
 embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
+embassy-usb = { version = "0.5.1", path = "../../embassy-usb", features = ["defmt"] }
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
 
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
diff --git a/examples/stm32l0/src/bin/usb_serial.rs b/examples/stm32l0/src/bin/usb_serial.rs
new file mode 100644
index 000000000..fdb1aeb59
--- /dev/null
+++ b/examples/stm32l0/src/bin/usb_serial.rs
@@ -0,0 +1,95 @@
+#![no_std]
+#![no_main]
+
+use defmt::{panic, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_stm32::usb::{self, Driver, Instance};
+use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
+use embassy_usb::driver::EndpointError;
+use embassy_usb::Builder;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    USB => usb::InterruptHandler<peripherals::USB>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.hsi = true;
+        config.rcc.pll = Some(Pll {
+            source: PllSource::HSI,
+            mul: PllMul::MUL6, // PLLVCO = 16*6 = 96Mhz
+            div: PllDiv::DIV3, // 32Mhz clock (16 * 6 / 3)
+        });
+        config.rcc.sys = Sysclk::PLL1_R;
+    }
+
+    let p = embassy_stm32::init(config);
+
+    info!("Hello World!");
+
+    let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
+
+    let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("USB-Serial Example");
+    config.serial_number = Some("123456");
+
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut [], // no msos descriptors
+        &mut control_buf,
+    );
+
+    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
+
+    let mut usb = builder.build();
+
+    let usb_fut = usb.run();
+
+    let echo_fut = async {
+        loop {
+            class.wait_connection().await;
+            info!("Connected");
+            let _ = echo(&mut class).await;
+            info!("Disconnected");
+        }
+    };
+
+    join(usb_fut, echo_fut).await;
+}
+
+struct Disconnected {}
+
+impl From<EndpointError> for Disconnected {
+    fn from(val: EndpointError) -> Self {
+        match val {
+            EndpointError::BufferOverflow => panic!("Buffer overflow"),
+            EndpointError::Disabled => Disconnected {},
+        }
+    }
+}
+
+async fn echo<'d, T: Instance + 'd>(class: &mut CdcAcmClass<'d, Driver<'d, T>>) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = class.read_packet(&mut buf).await?;
+        let data = &buf[..n];
+        info!("data: {:x}", data);
+        class.write_packet(data).await?;
+    }
+}