12 files changed, 1044 insertions, 25 deletions

diff --git a/embassy-imxrt/Cargo.toml b/embassy-imxrt/Cargo.toml
index 7561640dd..81377579b 100644
--- a/embassy-imxrt/Cargo.toml
+++ b/embassy-imxrt/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "embassy-imxrt"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 license = "MIT OR Apache-2.0"
 description = "Embassy Hardware Abstraction Layer (HAL) for the IMXRT microcontroller"
 keywords = ["embedded", "async", "imxrt", "rt600", "embedded-hal"]
@@ -103,5 +103,5 @@ document-features = "0.2.7"
 paste = "1.0"
 
 # PACs
-mimxrt685s-pac = { version = "0.4.0", optional = true, features = ["rt", "critical-section"] }
-mimxrt633s-pac = { version = "0.4.0", optional = true, features = ["rt", "critical-section"] }
+mimxrt685s-pac = { version = "0.5.0", optional = true, features = ["rt", "critical-section"] }
+mimxrt633s-pac = { version = "0.5.0", optional = true, features = ["rt", "critical-section"] }
diff --git a/embassy-imxrt/src/clocks.rs b/embassy-imxrt/src/clocks.rs
index 39c3e6238..22df2686f 100644
--- a/embassy-imxrt/src/clocks.rs
+++ b/embassy-imxrt/src/clocks.rs
@@ -1,5 +1,5 @@
 //! Clock configuration for the `RT6xx`
-use core::sync::atomic::{AtomicU32, AtomicU8, Ordering};
+use core::sync::atomic::{AtomicU8, AtomicU32, Ordering};
 
 use paste::paste;
 
diff --git a/embassy-imxrt/src/crc.rs b/embassy-imxrt/src/crc.rs
index 24d6ba5bd..d6f0419d0 100644
--- a/embassy-imxrt/src/crc.rs
+++ b/embassy-imxrt/src/crc.rs
@@ -2,9 +2,9 @@
 
 use core::marker::PhantomData;
 
-use crate::clocks::{enable_and_reset, SysconPeripheral};
+use crate::clocks::{SysconPeripheral, enable_and_reset};
 pub use crate::pac::crc_engine::mode::CrcPolynomial as Polynomial;
-use crate::{peripherals, Peri, PeripheralType};
+use crate::{Peri, PeripheralType, peripherals};
 
 /// CRC driver.
 pub struct Crc<'d> {
diff --git a/embassy-imxrt/src/dma.rs b/embassy-imxrt/src/dma.rs
index e141447f3..e71a27e0e 100644
--- a/embassy-imxrt/src/dma.rs
+++ b/embassy-imxrt/src/dma.rs
@@ -2,10 +2,10 @@
 
 use core::future::Future;
 use core::pin::Pin;
-use core::sync::atomic::{compiler_fence, Ordering};
+use core::sync::atomic::{Ordering, compiler_fence};
 use core::task::{Context, Poll};
 
-use embassy_hal_internal::{impl_peripheral, Peri, PeripheralType};
+use embassy_hal_internal::{Peri, PeripheralType, impl_peripheral};
 use embassy_sync::waitqueue::AtomicWaker;
 use pac::dma0::channel::cfg::Periphreqen;
 use pac::dma0::channel::xfercfg::{Dstinc, Srcinc, Width};
@@ -14,7 +14,7 @@ use crate::clocks::enable_and_reset;
 use crate::interrupt::InterruptExt;
 use crate::peripherals::DMA0;
 use crate::sealed::Sealed;
-use crate::{interrupt, pac, peripherals, BitIter};
+use crate::{BitIter, interrupt, pac, peripherals};
 
 #[cfg(feature = "rt")]
 #[interrupt]
diff --git a/embassy-imxrt/src/flexcomm/mod.rs b/embassy-imxrt/src/flexcomm/mod.rs
index 4473c9a77..ed87c7fb4 100644
--- a/embassy-imxrt/src/flexcomm/mod.rs
+++ b/embassy-imxrt/src/flexcomm/mod.rs
@@ -1,14 +1,15 @@
 //! Implements Flexcomm interface wrapper for easier usage across modules
 
+pub mod spi;
 pub mod uart;
 
 use paste::paste;
 
-use crate::clocks::{enable_and_reset, SysconPeripheral};
+use crate::clocks::{SysconPeripheral, enable_and_reset};
 use crate::peripherals::{
-    FLEXCOMM0, FLEXCOMM1, FLEXCOMM14, FLEXCOMM15, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7,
+    FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7, FLEXCOMM14, FLEXCOMM15,
 };
-use crate::{pac, PeripheralType};
+use crate::{PeripheralType, pac};
 
 /// clock selection option
 #[derive(Copy, Clone, Debug)]
@@ -223,9 +224,15 @@ macro_rules! into_mode {
     }
 }
 
-into_mode!(usart, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7);
-into_mode!(spi, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7, FLEXCOMM14);
-into_mode!(i2c, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7, FLEXCOMM15);
+into_mode!(
+    usart, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7
+);
+into_mode!(
+    spi, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7, FLEXCOMM14
+);
+into_mode!(
+    i2c, FLEXCOMM0, FLEXCOMM1, FLEXCOMM2, FLEXCOMM3, FLEXCOMM4, FLEXCOMM5, FLEXCOMM6, FLEXCOMM7, FLEXCOMM15
+);
 
 into_mode!(
     i2s_transmit,
diff --git a/embassy-imxrt/src/flexcomm/spi.rs b/embassy-imxrt/src/flexcomm/spi.rs
new file mode 100644
index 000000000..9dd776ac7
--- /dev/null
+++ b/embassy-imxrt/src/flexcomm/spi.rs
@@ -0,0 +1,1011 @@
+//! Serial Peripheral Interface (SPI) driver.
+
+use core::future::{Future, poll_fn};
+use core::marker::PhantomData;
+use core::task::Poll;
+
+use embassy_embedded_hal::SetConfig;
+use embassy_hal_internal::{Peri, PeripheralType};
+use embassy_sync::waitqueue::AtomicWaker;
+pub use embedded_hal_1::spi::{MODE_0, MODE_1, MODE_2, MODE_3, Mode, Phase, Polarity};
+use paste::paste;
+
+use crate::flexcomm::Clock;
+use crate::gpio::{AnyPin, GpioPin as Pin};
+use crate::interrupt;
+use crate::interrupt::typelevel::Interrupt;
+use crate::iopctl::{DriveMode, DriveStrength, Inverter, IopctlPin, Pull, SlewRate};
+use crate::pac::spi0::cfg::{Cpha, Cpol};
+
+/// Driver move trait.
+#[allow(private_bounds)]
+pub trait IoMode: sealed::Sealed {}
+
+/// Blocking mode.
+pub struct Blocking;
+impl sealed::Sealed for Blocking {}
+impl IoMode for Blocking {}
+
+/// Async mode.
+pub struct Async;
+impl sealed::Sealed for Async {}
+impl IoMode for Async {}
+
+/// Spi errors.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Error {
+    // No errors for now.
+}
+
+/// Spi driver.
+pub struct Spi<'a, M: IoMode> {
+    info: Info,
+    _phantom: PhantomData<&'a M>,
+}
+
+impl<'a> Spi<'a, Blocking> {
+    /// Create a SPI driver in blocking mode.
+    pub fn new_blocking<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        mosi: Peri<'a, impl MosiPin<T> + 'a>,
+        miso: Peri<'a, impl MisoPin<T> + 'a>,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        mosi.as_mosi();
+        miso.as_miso();
+
+        Self::new_inner(_inner, Some(sck.into()), Some(mosi.into()), Some(miso.into()), config)
+    }
+
+    /// Create a TX-only SPI driver in blocking mode.
+    pub fn new_blocking_txonly<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        mosi: Peri<'a, impl MosiPin<T> + 'a>,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        mosi.as_mosi();
+
+        Self::new_inner(_inner, Some(sck.into()), Some(mosi.into()), None, config)
+    }
+
+    /// Create an RX-only SPI driver in blocking mode.
+    pub fn new_blocking_rxonly<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        miso: Peri<'a, impl MisoPin<T> + 'a>,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        miso.as_miso();
+
+        Self::new_inner(_inner, Some(sck.into()), None, Some(miso.into()), config)
+    }
+
+    /// Create an internal-loopback SPI driver in blocking mode.
+    ///
+    /// WARNING: This is only useful for testing as it doesn't use any
+    /// external pins.
+    pub fn new_blocking_loopback<T: Instance>(_inner: Peri<'a, T>, config: Config) -> Self {
+        Self::new_inner(_inner, None, None, None, config)
+    }
+}
+
+impl<'a, M: IoMode> Spi<'a, M> {
+    /// Read data from Spi blocking execution until done.
+    pub fn blocking_read(&mut self, data: &mut [u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+
+            for word in data.iter_mut() {
+                // wait until we have data in the RxFIFO.
+                while self.info.regs.fifostat().read().rxnotempty().bit_is_clear() {}
+
+                self.info
+                    .regs
+                    .fifowr()
+                    .write(|w| unsafe { w.txdata().bits(*word as u16).len().bits(7) });
+
+                *word = self.info.regs.fiford().read().rxdata().bits() as u8;
+            }
+        });
+
+        self.flush()
+    }
+
+    /// Write data to Spi blocking execution until done.
+    pub fn blocking_write(&mut self, data: &[u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+
+            for (i, word) in data.iter().enumerate() {
+                // wait until we have space in the TxFIFO.
+                while self.info.regs.fifostat().read().txnotfull().bit_is_clear() {}
+
+                self.info.regs.fifowr().write(|w| {
+                    unsafe { w.txdata().bits(*word as u16).len().bits(7) }
+                        .rxignore()
+                        .set_bit();
+
+                    if i == data.len() - 1 {
+                        w.eot().set_bit();
+                    }
+
+                    w
+                });
+            }
+        });
+
+        self.flush()
+    }
+
+    /// Transfer data to SPI blocking execution until done.
+    pub fn blocking_transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Error> {
+        let len = read.len().max(write.len());
+
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+
+            for i in 0..len {
+                let wb = write.get(i).copied().unwrap_or(0);
+
+                // wait until we have space in the TxFIFO.
+                while self.info.regs.fifostat().read().txnotfull().bit_is_clear() {}
+
+                self.info.regs.fifowr().write(|w| {
+                    unsafe { w.txdata().bits(wb as u16).len().bits(7) };
+
+                    if i == len - 1 {
+                        w.eot().set_bit();
+                    }
+
+                    w
+                });
+
+                // wait until we have data in the RxFIFO.
+                while self.info.regs.fifostat().read().rxnotempty().bit_is_clear() {}
+
+                let rb = self.info.regs.fiford().read().rxdata().bits() as u8;
+
+                if let Some(r) = read.get_mut(i) {
+                    *r = rb;
+                }
+            }
+        });
+
+        self.flush()
+    }
+
+    /// Transfer data in place to SPI blocking execution until done.
+    pub fn blocking_transfer_in_place(&mut self, data: &mut [u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+
+            for word in data {
+                // wait until we have space in the TxFIFO.
+                while self.info.regs.fifostat().read().txnotfull().bit_is_clear() {}
+                self.info
+                    .regs
+                    .fifowr()
+                    .write(|w| unsafe { w.txdata().bits(*word as u16) });
+
+                // wait until we have data in the RxFIFO.
+                while self.info.regs.fifostat().read().rxnotempty().bit_is_clear() {}
+                *word = self.info.regs.fiford().read().rxdata().bits() as u8;
+            }
+        });
+
+        self.flush()
+    }
+
+    /// Block execution until Spi is done.
+    pub fn flush(&mut self) -> Result<(), Error> {
+        let regs = self.info.regs;
+        while regs.stat().read().mstidle().bit_is_clear() {}
+        Ok(())
+    }
+}
+
+impl<'a> Spi<'a, Async> {
+    /// Create a SPI driver in async mode.
+    pub fn new_async<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        mosi: Peri<'a, impl MosiPin<T> + 'a>,
+        miso: Peri<'a, impl MisoPin<T> + 'a>,
+        _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'a,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        mosi.as_mosi();
+        miso.as_miso();
+
+        T::Interrupt::unpend();
+        unsafe { T::Interrupt::enable() };
+
+        Self::new_inner(_inner, Some(sck.into()), Some(mosi.into()), Some(miso.into()), config)
+    }
+
+    /// Create a TX-only SPI driver in async mode.
+    pub fn new_async_txonly<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        mosi: Peri<'a, impl MosiPin<T> + 'a>,
+        _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'a,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        mosi.as_mosi();
+
+        T::Interrupt::unpend();
+        unsafe { T::Interrupt::enable() };
+
+        Self::new_inner(_inner, Some(sck.into()), Some(mosi.into()), None, config)
+    }
+
+    /// Create an RX-only SPI driver in async mode.
+    pub fn new_async_rxonly<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Peri<'a, impl SckPin<T> + 'a>,
+        miso: Peri<'a, impl MisoPin<T> + 'a>,
+        _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'a,
+        config: Config,
+    ) -> Self {
+        sck.as_sck();
+        miso.as_miso();
+
+        T::Interrupt::unpend();
+        unsafe { T::Interrupt::enable() };
+
+        Self::new_inner(_inner, Some(sck.into()), None, Some(miso.into()), config)
+    }
+
+    /// Create an internal-loopback SPI driver in async mode.
+    ///
+    /// WARNING: This is only useful for testing as it doesn't use any
+    /// external pins.
+    pub fn new_async_loopback<T: Instance>(
+        _inner: Peri<'a, T>,
+        _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'a,
+        config: Config,
+    ) -> Self {
+        T::Interrupt::unpend();
+        unsafe { T::Interrupt::enable() };
+
+        Self::new_inner(_inner, None, None, None, config)
+    }
+
+    /// Read data from Spi async execution until done.
+    pub async fn async_read(&mut self, data: &mut [u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+        });
+
+        for word in data.iter_mut() {
+            // wait until we have data in the RxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().rxnotempty().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.rxlvl().set_bit().rxerr().set_bit());
+                },
+            )
+            .await;
+
+            self.info
+                .regs
+                .fifowr()
+                .write(|w| unsafe { w.txdata().bits(*word as u16).len().bits(7) });
+
+            *word = self.info.regs.fiford().read().rxdata().bits() as u8;
+        }
+
+        self.async_flush().await;
+
+        Ok(())
+    }
+
+    /// Write data to Spi async execution until done.
+    pub async fn async_write(&mut self, data: &[u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+        });
+
+        for (i, word) in data.iter().enumerate() {
+            // wait until we have space in the TxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().txnotfull().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.txlvl().set_bit().txerr().set_bit());
+                },
+            )
+            .await;
+
+            self.info.regs.fifowr().write(|w| {
+                unsafe { w.txdata().bits(*word as u16).len().bits(7) }
+                    .rxignore()
+                    .set_bit();
+
+                if i == data.len() - 1 {
+                    w.eot().set_bit();
+                }
+
+                w
+            });
+        }
+
+        self.async_flush().await;
+
+        Ok(())
+    }
+
+    /// Transfer data to SPI async execution until done.
+    pub async fn async_transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Error> {
+        let len = read.len().max(write.len());
+
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+        });
+
+        for i in 0..len {
+            let wb = write.get(i).copied().unwrap_or(0);
+
+            // wait until we have space in the TxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().txnotfull().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info.regs.fifotrig().write(|w| w.txlvlena().set_bit());
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.txlvl().set_bit().txerr().set_bit());
+                },
+            )
+            .await;
+
+            self.info.regs.fifowr().write(|w| {
+                unsafe { w.txdata().bits(wb as u16).len().bits(7) };
+
+                if i == len - 1 {
+                    w.eot().set_bit();
+                }
+
+                w
+            });
+
+            // wait until we have data in the RxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().rxnotempty().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info.regs.fifotrig().write(|w| w.rxlvlena().set_bit());
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.rxlvl().set_bit().rxerr().set_bit());
+                },
+            )
+            .await;
+
+            let rb = self.info.regs.fiford().read().rxdata().bits() as u8;
+
+            if let Some(r) = read.get_mut(i) {
+                *r = rb;
+            }
+        }
+
+        self.async_flush().await;
+
+        Ok(())
+    }
+
+    /// Transfer data in place to SPI async execution until done.
+    pub async fn async_transfer_in_place(&mut self, data: &mut [u8]) -> Result<(), Error> {
+        critical_section::with(|_| {
+            self.info
+                .regs
+                .fifostat()
+                .modify(|_, w| w.txerr().set_bit().rxerr().set_bit());
+        });
+
+        for word in data {
+            // wait until we have space in the TxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().txnotfull().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.txlvl().set_bit().txerr().set_bit());
+                },
+            )
+            .await;
+
+            self.info
+                .regs
+                .fifowr()
+                .write(|w| unsafe { w.txdata().bits(*word as u16) });
+
+            // wait until we have data in the RxFIFO.
+            self.wait_for(
+                |me| {
+                    if me.info.regs.fifostat().read().rxnotempty().bit_is_set() {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                },
+                |me| {
+                    me.info
+                        .regs
+                        .fifointenset()
+                        .write(|w| w.rxlvl().set_bit().rxerr().set_bit());
+                },
+            )
+            .await;
+
+            *word = self.info.regs.fiford().read().rxdata().bits() as u8;
+        }
+
+        self.async_flush().await;
+
+        Ok(())
+    }
+
+    /// Async flush.
+    pub fn async_flush(&mut self) -> impl Future<Output = ()> + use<'_, 'a> {
+        self.wait_for(
+            |me| {
+                if me.info.regs.stat().read().mstidle().bit_is_set() {
+                    Poll::Ready(())
+                } else {
+                    Poll::Pending
+                }
+            },
+            |me| {
+                me.info.regs.intenset().write(|w| w.mstidleen().set_bit());
+            },
+        )
+    }
+
+    /// Calls `f` to check if we are ready or not.
+    /// If not, `g` is called once the waker is set (to eg enable the required interrupts).
+    fn wait_for<F, U, G>(&mut self, mut f: F, mut g: G) -> impl Future<Output = U> + use<'_, 'a, F, U, G>
+    where
+        F: FnMut(&mut Self) -> Poll<U>,
+        G: FnMut(&mut Self),
+    {
+        poll_fn(move |cx| {
+            // Register waker before checking condition, to ensure that wakes/interrupts
+            // aren't lost between f() and g()
+            self.info.waker.register(cx.waker());
+            let r = f(self);
+
+            if r.is_pending() {
+                g(self);
+            }
+
+            r
+        })
+    }
+}
+
+impl<'a, M: IoMode> Spi<'a, M> {
+    fn new_inner<T: Instance>(
+        _inner: Peri<'a, T>,
+        sck: Option<Peri<'a, AnyPin>>,
+        mosi: Option<Peri<'a, AnyPin>>,
+        miso: Option<Peri<'a, AnyPin>>,
+        config: Config,
+    ) -> Self {
+        // REVISIT: allow selecting from multiple clocks.
+        let clk = Self::clock(&config);
+
+        T::enable(clk);
+        T::into_spi();
+
+        Self::apply_config(T::info().regs, &config);
+
+        let info = T::info();
+        let regs = info.regs;
+
+        critical_section::with(|_| match (sck.is_some(), mosi.is_some(), miso.is_some()) {
+            (true, true, true) => {
+                regs.fifocfg().modify(|_, w| {
+                    w.enabletx()
+                        .set_bit()
+                        .emptytx()
+                        .set_bit()
+                        .enablerx()
+                        .set_bit()
+                        .emptyrx()
+                        .set_bit()
+                });
+            }
+            (true, false, true) => {
+                regs.fifocfg().modify(|_, w| {
+                    w.enabletx()
+                        .set_bit()
+                        .emptytx()
+                        .clear_bit()
+                        .enablerx()
+                        .set_bit()
+                        .emptyrx()
+                        .set_bit()
+                });
+            }
+            (true, true, false) => {
+                regs.fifocfg().modify(|_, w| {
+                    w.enabletx()
+                        .set_bit()
+                        .emptytx()
+                        .set_bit()
+                        .enablerx()
+                        .clear_bit()
+                        .emptyrx()
+                        .set_bit()
+                });
+            }
+            (false, _, _) => {
+                regs.fifocfg().modify(|_, w| {
+                    w.enabletx()
+                        .set_bit()
+                        .emptytx()
+                        .set_bit()
+                        .enablerx()
+                        .set_bit()
+                        .emptyrx()
+                        .set_bit()
+                });
+                regs.cfg().modify(|_, w| w.loop_().enabled());
+            }
+            _ => {}
+        });
+
+        Self {
+            info,
+            _phantom: PhantomData,
+        }
+    }
+
+    fn set_config(&mut self, config: &Config) {
+        Self::apply_config(self.info.regs, config);
+    }
+
+    fn clock(config: &Config) -> Clock {
+        const SFRO_CLOCK_SPEED_HZ: u32 = 16_000_000;
+
+        if config.frequency > SFRO_CLOCK_SPEED_HZ {
+            Clock::Ffro
+        } else {
+            Clock::Sfro
+        }
+    }
+
+    fn clock_frequency(clock: Clock) -> u32 {
+        match clock {
+            Clock::Sfro => 16_000_000,
+            Clock::Ffro => 48_000_000,
+            _ => unreachable!(),
+        }
+    }
+
+    fn apply_config(regs: &'static crate::pac::spi0::RegisterBlock, config: &Config) {
+        let polarity = if config.mode.polarity == Polarity::IdleLow {
+            Cpol::Low
+        } else {
+            Cpol::High
+        };
+
+        let phase = if config.mode.phase == Phase::CaptureOnFirstTransition {
+            Cpha::Change
+        } else {
+            Cpha::Capture
+        };
+
+        let clk = Self::clock(config);
+        let div = Self::clock_frequency(clk) / config.frequency - 1;
+
+        critical_section::with(|_| {
+            // disable SPI every time we need to modify configuration.
+            regs.cfg().modify(|_, w| w.enable().disabled());
+
+            regs.cfg().modify(|_, w| {
+                w.cpha()
+                    .variant(phase)
+                    .cpol()
+                    .variant(polarity)
+                    .loop_()
+                    .disabled()
+                    .master()
+                    .master_mode()
+            });
+
+            regs.div().write(|w| unsafe { w.divval().bits(div as u16) });
+
+            regs.cfg().modify(|_, w| w.enable().enabled());
+        });
+    }
+}
+
+/// Spi config.
+#[derive(Clone)]
+pub struct Config {
+    /// Frequency in Hertz.
+    pub frequency: u32,
+    /// SPI operating mode.
+    pub mode: Mode,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            frequency: 1_000_000,
+            mode: MODE_0,
+        }
+    }
+}
+
+struct Info {
+    regs: &'static crate::pac::spi0::RegisterBlock,
+    waker: &'static AtomicWaker,
+}
+
+// SAFETY: safety for Send here is the same as the other accessors to
+// unsafe blocks: it must be done from a single executor context.
+//
+// This is a temporary workaround -- a better solution might be to
+// refactor Info to no longer maintain a reference to regs, but
+// instead look up the correct register set and then perform
+// operations within an unsafe block as we do for other peripherals
+unsafe impl Send for Info {}
+
+trait SealedInstance {
+    fn info() -> Info;
+}
+
+/// Spi interrupt handler.
+pub struct InterruptHandler<T: Instance> {
+    _phantom: PhantomData<T>,
+}
+
+impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandler<T> {
+    unsafe fn on_interrupt() {
+        let waker = T::info().waker;
+        let stat = T::info().regs.fifointstat().read();
+
+        if stat.perint().bit_is_set() {
+            T::info().regs.intenclr().write(|w| w.mstidle().clear_bit_by_one());
+        }
+
+        if stat.txlvl().bit_is_set() {
+            T::info().regs.fifointenclr().write(|w| w.txlvl().set_bit());
+        }
+
+        if stat.txerr().bit_is_set() {
+            T::info().regs.fifointenclr().write(|w| w.txerr().set_bit());
+        }
+
+        if stat.rxlvl().bit_is_set() {
+            T::info().regs.fifointenclr().write(|w| w.rxlvl().set_bit());
+        }
+
+        if stat.rxerr().bit_is_set() {
+            T::info().regs.fifointenclr().write(|w| w.rxerr().set_bit());
+        }
+
+        waker.wake();
+    }
+}
+
+/// Spi instance trait.
+#[allow(private_bounds)]
+pub trait Instance: crate::flexcomm::IntoSpi + SealedInstance + PeripheralType + 'static + Send {
+    /// Interrupt for this Spi instance.
+    type Interrupt: interrupt::typelevel::Interrupt;
+}
+
+macro_rules! impl_instance {
+    ($($n:expr),*) => {
+        $(
+            paste!{
+                impl SealedInstance for crate::peripherals::[<FLEXCOMM $n>] {
+                    #[inline]
+                    fn info() -> Info {
+                        static WAKER: AtomicWaker = AtomicWaker::new();
+
+                        Info {
+                            regs: unsafe { &*crate::pac::[<Spi $n>]::ptr() },
+                            waker: &WAKER,
+                        }
+                    }
+                }
+
+                impl Instance for crate::peripherals::[<FLEXCOMM $n>] {
+                    type Interrupt = crate::interrupt::typelevel::[<FLEXCOMM $n>];
+                }
+            }
+        )*
+    }
+}
+
+impl_instance!(0, 1, 2, 3, 4, 5, 6, 7, 14);
+
+mod sealed {
+    /// Seal a trait
+    pub trait Sealed {}
+}
+
+impl<T: Pin> sealed::Sealed for T {}
+
+/// IO configuration trait for Spi clk
+pub trait SckPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
+    /// convert the pin to appropriate function for Spi clk usage.
+    fn as_sck(&self);
+}
+
+/// IO configuration trait for Spi mosi
+pub trait MosiPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
+    /// convert the pin to appropriate function for Spi mosi usage.
+    fn as_mosi(&self);
+}
+
+/// IO configuration trait for Spi miso
+pub trait MisoPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
+    /// convert the pin to appropriate function for Spi miso usage.
+    fn as_miso(&self);
+}
+
+macro_rules! impl_pin_trait {
+    ($fcn:ident, $mode:ident, $($pin:ident, $fn:ident),*) => {
+        paste! {
+            $(
+                impl [<$mode:camel Pin>]<crate::peripherals::$fcn> for crate::peripherals::$pin {
+                    fn [<as_ $mode>](&self) {
+                        // UM11147 table 530 pg 518
+                        self.set_function(crate::iopctl::Function::$fn)
+                            .set_pull(Pull::None)
+                            .enable_input_buffer()
+                            .set_slew_rate(SlewRate::Standard)
+                            .set_drive_strength(DriveStrength::Normal)
+                            .disable_analog_multiplex()
+                            .set_drive_mode(DriveMode::PushPull)
+                            .set_input_inverter(Inverter::Disabled);
+                    }
+                }
+            )*
+        }
+    }
+}
+
+// FLEXCOMM0
+impl_pin_trait!(FLEXCOMM0, sck, PIO0_0, F1, PIO3_0, F5);
+impl_pin_trait!(FLEXCOMM0, miso, PIO0_1, F1, PIO3_1, F5);
+impl_pin_trait!(FLEXCOMM0, mosi, PIO0_2, F1, PIO3_2, F5);
+
+// FLEXCOMM1
+impl_pin_trait!(FLEXCOMM1, sck, PIO0_7, F1, PIO7_25, F1);
+impl_pin_trait!(FLEXCOMM1, miso, PIO0_8, F1, PIO7_26, F1);
+impl_pin_trait!(FLEXCOMM1, mosi, PIO0_9, F1, PIO7_28, F1);
+
+// FLEXCOMM2
+impl_pin_trait!(FLEXCOMM2, sck, PIO0_14, F1, PIO7_29, F5);
+impl_pin_trait!(FLEXCOMM2, miso, PIO0_15, F1, PIO7_30, F5);
+impl_pin_trait!(FLEXCOMM2, mosi, PIO0_16, F1, PIO7_31, F5);
+
+// FLEXCOMM3
+impl_pin_trait!(FLEXCOMM3, sck, PIO0_21, F1);
+impl_pin_trait!(FLEXCOMM3, miso, PIO0_22, F1);
+impl_pin_trait!(FLEXCOMM3, mosi, PIO0_23, F1);
+
+// FLEXCOMM4
+impl_pin_trait!(FLEXCOMM4, sck, PIO0_28, F1);
+impl_pin_trait!(FLEXCOMM4, miso, PIO0_29, F1);
+impl_pin_trait!(FLEXCOMM4, mosi, PIO0_30, F1);
+
+// FLEXCOMM5
+impl_pin_trait!(FLEXCOMM5, sck, PIO1_3, F1, PIO3_15, F5);
+impl_pin_trait!(FLEXCOMM5, miso, PIO1_4, F1, PIO3_16, F5);
+impl_pin_trait!(FLEXCOMM5, mosi, PIO1_5, F1, PIO3_17, F5);
+
+// FLEXCOMM6
+impl_pin_trait!(FLEXCOMM6, sck, PIO3_25, F1);
+impl_pin_trait!(FLEXCOMM6, miso, PIO3_26, F1);
+impl_pin_trait!(FLEXCOMM6, mosi, PIO3_27, F1);
+
+// FLEXCOMM7
+impl_pin_trait!(FLEXCOMM7, sck, PIO4_0, F1);
+impl_pin_trait!(FLEXCOMM7, miso, PIO4_1, F1);
+impl_pin_trait!(FLEXCOMM7, mosi, PIO4_2, F1);
+
+// FLEXCOMM14
+impl_pin_trait!(FLEXCOMM14, sck, PIO1_11, F1);
+impl_pin_trait!(FLEXCOMM14, miso, PIO1_12, F1);
+impl_pin_trait!(FLEXCOMM14, mosi, PIO1_13, F1);
+
+/// Spi Tx DMA trait.
+#[allow(private_bounds)]
+pub trait TxDma<T: Instance>: crate::dma::Channel {}
+
+/// Spi Rx DMA trait.
+#[allow(private_bounds)]
+pub trait RxDma<T: Instance>: crate::dma::Channel {}
+
+macro_rules! impl_dma {
+    ($fcn:ident, $mode:ident, $dma:ident) => {
+        paste! {
+            impl [<$mode Dma>]<crate::peripherals::$fcn> for crate::peripherals::$dma {}
+        }
+    };
+}
+
+impl_dma!(FLEXCOMM0, Rx, DMA0_CH0);
+impl_dma!(FLEXCOMM0, Tx, DMA0_CH1);
+
+impl_dma!(FLEXCOMM1, Rx, DMA0_CH2);
+impl_dma!(FLEXCOMM1, Tx, DMA0_CH3);
+
+impl_dma!(FLEXCOMM2, Rx, DMA0_CH4);
+impl_dma!(FLEXCOMM2, Tx, DMA0_CH5);
+
+impl_dma!(FLEXCOMM3, Rx, DMA0_CH6);
+impl_dma!(FLEXCOMM3, Tx, DMA0_CH7);
+
+impl_dma!(FLEXCOMM4, Rx, DMA0_CH8);
+impl_dma!(FLEXCOMM4, Tx, DMA0_CH9);
+
+impl_dma!(FLEXCOMM5, Rx, DMA0_CH10);
+impl_dma!(FLEXCOMM5, Tx, DMA0_CH11);
+
+impl_dma!(FLEXCOMM6, Rx, DMA0_CH12);
+impl_dma!(FLEXCOMM6, Tx, DMA0_CH13);
+
+impl_dma!(FLEXCOMM7, Rx, DMA0_CH14);
+impl_dma!(FLEXCOMM7, Tx, DMA0_CH15);
+
+impl_dma!(FLEXCOMM14, Rx, DMA0_CH16);
+impl_dma!(FLEXCOMM14, Tx, DMA0_CH17);
+
+// ==============================
+
+impl<'d, M: IoMode> embedded_hal_02::blocking::spi::Transfer<u8> for Spi<'d, M> {
+    type Error = Error;
+    fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
+        self.blocking_transfer_in_place(words)?;
+        Ok(words)
+    }
+}
+
+impl<'d, M: IoMode> embedded_hal_02::blocking::spi::Write<u8> for Spi<'d, M> {
+    type Error = Error;
+
+    fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(words)
+    }
+}
+
+impl embedded_hal_1::spi::Error for Error {
+    fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
+        match *self {}
+    }
+}
+
+impl<'d, M: IoMode> embedded_hal_1::spi::ErrorType for Spi<'d, M> {
+    type Error = Error;
+}
+
+impl<'d, M: IoMode> embedded_hal_1::spi::SpiBus<u8> for Spi<'d, M> {
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        self.flush()
+    }
+
+    fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_read(words)
+    }
+
+    fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(words)
+    }
+
+    fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_transfer(read, write)
+    }
+
+    fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_transfer_in_place(words)
+    }
+}
+
+impl<'d> embedded_hal_async::spi::SpiBus<u8> for Spi<'d, Async> {
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        self.async_flush().await;
+
+        Ok(())
+    }
+
+    async fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+        self.async_write(words).await
+    }
+
+    async fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+        self.async_read(words).await
+    }
+
+    async fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
+        self.async_transfer(read, write).await
+    }
+
+    async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+        self.async_transfer_in_place(words).await
+    }
+}
+
+impl<'d, M: IoMode> SetConfig for Spi<'d, M> {
+    type Config = Config;
+    type ConfigError = ();
+    fn set_config(&mut self, config: &Self::Config) -> Result<(), ()> {
+        self.set_config(config);
+
+        Ok(())
+    }
+}
diff --git a/embassy-imxrt/src/flexcomm/uart.rs b/embassy-imxrt/src/flexcomm/uart.rs
index 230b30d43..2b759ba84 100644
--- a/embassy-imxrt/src/flexcomm/uart.rs
+++ b/embassy-imxrt/src/flexcomm/uart.rs
@@ -2,10 +2,10 @@
 
 use core::future::poll_fn;
 use core::marker::PhantomData;
-use core::sync::atomic::{compiler_fence, AtomicU8, Ordering};
+use core::sync::atomic::{AtomicU8, Ordering, compiler_fence};
 use core::task::Poll;
 
-use embassy_futures::select::{select, Either};
+use embassy_futures::select::{Either, select};
 use embassy_hal_internal::drop::OnDrop;
 use embassy_hal_internal::{Peri, PeripheralType};
 use embassy_sync::waitqueue::AtomicWaker;
diff --git a/embassy-imxrt/src/gpio.rs b/embassy-imxrt/src/gpio.rs
index e62fde8b1..4a0608e76 100644
--- a/embassy-imxrt/src/gpio.rs
+++ b/embassy-imxrt/src/gpio.rs
@@ -13,7 +13,7 @@ use crate::clocks::enable_and_reset;
 use crate::iopctl::IopctlPin;
 pub use crate::iopctl::{AnyPin, DriveMode, DriveStrength, Function, Inverter, Pull, SlewRate};
 use crate::sealed::Sealed;
-use crate::{interrupt, peripherals, BitIter, Peri, PeripheralType};
+use crate::{BitIter, Peri, PeripheralType, interrupt, peripherals};
 
 // This should be unique per IMXRT package
 const PORT_COUNT: usize = 8;
diff --git a/embassy-imxrt/src/iopctl.rs b/embassy-imxrt/src/iopctl.rs
index a3b8b14d6..805bf2f1b 100644
--- a/embassy-imxrt/src/iopctl.rs
+++ b/embassy-imxrt/src/iopctl.rs
@@ -2,7 +2,7 @@
 //!
 //! Also known as IO Pin Configuration (IOCON)
 
-use crate::pac::{iopctl, Iopctl};
+use crate::pac::{Iopctl, iopctl};
 
 // A generic pin of any type.
 //
diff --git a/embassy-imxrt/src/lib.rs b/embassy-imxrt/src/lib.rs
index a3437c655..643dd0c8a 100644
--- a/embassy-imxrt/src/lib.rs
+++ b/embassy-imxrt/src/lib.rs
@@ -1,5 +1,6 @@
 #![no_std]
 #![allow(async_fn_in_trait)]
+#![allow(unsafe_op_in_unsafe_fn)]
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
 
@@ -39,7 +40,7 @@ pub use chip::interrupts::*;
 pub use chip::pac;
 #[cfg(not(feature = "unstable-pac"))]
 pub(crate) use chip::pac;
-pub use chip::{peripherals, Peripherals};
+pub use chip::{Peripherals, peripherals};
 pub use embassy_hal_internal::{Peri, PeripheralType};
 
 #[cfg(feature = "rt")]
@@ -74,7 +75,7 @@ macro_rules! bind_interrupts {
 
         $(
             #[allow(non_snake_case)]
-            #[no_mangle]
+            #[unsafe(no_mangle)]
             unsafe extern "C" fn $irq() {
                 unsafe {
                     $(
diff --git a/embassy-imxrt/src/rng.rs b/embassy-imxrt/src/rng.rs
index 75f243df9..094418e41 100644
--- a/embassy-imxrt/src/rng.rs
+++ b/embassy-imxrt/src/rng.rs
@@ -7,9 +7,9 @@ use core::task::Poll;
 use embassy_futures::block_on;
 use embassy_sync::waitqueue::AtomicWaker;
 
-use crate::clocks::{enable_and_reset, SysconPeripheral};
+use crate::clocks::{SysconPeripheral, enable_and_reset};
 use crate::interrupt::typelevel::Interrupt;
-use crate::{interrupt, peripherals, Peri, PeripheralType};
+use crate::{Peri, PeripheralType, interrupt, peripherals};
 
 static RNG_WAKER: AtomicWaker = AtomicWaker::new();
 
diff --git a/embassy-imxrt/src/time_driver.rs b/embassy-imxrt/src/time_driver.rs
index f127609c8..fbd935b70 100644
--- a/embassy-imxrt/src/time_driver.rs
+++ b/embassy-imxrt/src/time_driver.rs
@@ -1,11 +1,11 @@
 //! Time Driver.
 use core::cell::{Cell, RefCell};
 #[cfg(feature = "time-driver-rtc")]
-use core::sync::atomic::{compiler_fence, AtomicU32, Ordering};
+use core::sync::atomic::{AtomicU32, Ordering, compiler_fence};
 
 use critical_section::CriticalSection;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::blocking_mutex::Mutex;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_time_driver::Driver;
 use embassy_time_queue_utils::Queue;