diff --git a/embassy-rp/src/spi.rs b/embassy-rp/src/spi.rs
index ec2437e9..959ad9b0 100644
--- a/embassy-rp/src/spi.rs
+++ b/embassy-rp/src/spi.rs
@@ -111,6 +111,8 @@ impl<'d, T: Instance> Spi<'d, T> {
             for &b in data {
                 while !p.sr().read().tnf() {}
                 p.dr().write(|w| w.set_data(b as _));
+                while !p.sr().read().rne() {}
+                let _ = p.dr().read();
             }
             self.flush();
         }
@@ -140,10 +142,17 @@ impl<'d, T: Instance> Spi<'d, T> {
         let (presc, postdiv) = calc_prescs(freq);
         let p = self.inner.regs();
         unsafe {
+            // disable
+            p.cr1().write(|w| w.set_sse(false));
+
+            // change stuff
             p.cpsr().write(|w| w.set_cpsdvsr(presc));
             p.cr0().modify(|w| {
                 w.set_scr(postdiv);
             });
+
+            // enable
+            p.cr1().write(|w| w.set_sse(true));
         }
     }
 }
diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index e45bf594..4c4f983f 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -30,3 +30,6 @@ cortex-m-rt = "0.6.13"
 embedded-hal    = { version = "0.2.4" }
 panic-probe = { version = "0.2.0", features = ["print-defmt"] }
 futures = { version = "0.3.8", default-features = false, features = ["async-await", "cfg-target-has-atomic", "unstable"] }
+display-interface-spi = "0.4.1"
+embedded-graphics = "0.7.1"
+st7789 = "0.6.1"
diff --git a/examples/rp/assets/ferris.raw b/examples/rp/assets/ferris.raw
new file mode 100644
index 00000000..9733889c
Binary files /dev/null and b/examples/rp/assets/ferris.raw differ
diff --git a/examples/rp/src/bin/spi_display.rs b/examples/rp/src/bin/spi_display.rs
new file mode 100644
index 00000000..467cdf42
--- /dev/null
+++ b/examples/rp/src/bin/spi_display.rs
@@ -0,0 +1,215 @@
+#![no_std]
+#![no_main]
+#![feature(asm)]
+#![feature(min_type_alias_impl_trait)]
+#![feature(impl_trait_in_bindings)]
+#![feature(type_alias_impl_trait)]
+#![allow(incomplete_features)]
+
+#[path = "../example_common.rs"]
+mod example_common;
+
+use core::cell::RefCell;
+use core::fmt::Debug;
+
+use defmt::*;
+use display_interface_spi::SPIInterfaceNoCS;
+use embassy::executor::Spawner;
+use embassy::time::Delay;
+use embassy_rp::gpio::NoPin;
+use embassy_rp::peripherals;
+use embassy_rp::spi;
+use embassy_rp::spi::Spi;
+use embassy_rp::{gpio, Peripherals};
+use embedded_graphics::image::{Image, ImageRawLE};
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::*;
+use embedded_graphics::primitives::{PrimitiveStyleBuilder, Rectangle};
+use embedded_graphics::text::Text;
+use gpio::{Level, Output};
+use st7789::{Orientation, ST7789};
+
+#[embassy::main]
+async fn main(_spawner: Spawner, p: Peripherals) {
+    info!("Hello World!");
+
+    let bl = p.PIN_13;
+    let rst = p.PIN_15;
+    let display_cs = p.PIN_9;
+    let dcx = p.PIN_8;
+    let miso = p.PIN_12;
+    let mosi = p.PIN_11;
+    let clk = p.PIN_10;
+    let touch_cs = p.PIN_16;
+    //let touch_irq = p.PIN_17;
+
+    // create SPI
+    let mut config = spi::Config::default();
+    config.frequency = DISPLAY_FREQ;
+    config.phase = spi::Phase::CaptureOnSecondTransition;
+    config.polarity = spi::Polarity::IdleHigh;
+
+    let spi = RefCell::new(SpiState {
+        last_mode: SpiMode::Display,
+        spi: Spi::new(p.SPI1, clk, mosi, miso, NoPin, config),
+        display_cs: Output::new(display_cs, Level::Low),
+    });
+
+    let mut touch = Touch::new(TouchSpi(&spi), Output::new(touch_cs, Level::High));
+
+    let dcx = Output::new(dcx, Level::Low);
+    let rst = Output::new(rst, Level::Low);
+    // dcx: 0 = command, 1 = data
+
+    // Enable LCD backlight
+    let _bl = Output::new(bl, Level::High);
+
+    // display interface abstraction from SPI and DC
+    let di = SPIInterfaceNoCS::new(DisplaySpi(&spi), dcx);
+
+    // create driver
+    let mut display = ST7789::new(di, rst, 240, 320);
+
+    // initialize
+    display.init(&mut Delay).unwrap();
+
+    // set default orientation
+    display.set_orientation(Orientation::Landscape).unwrap();
+
+    display.clear(Rgb565::BLACK).unwrap();
+
+    let raw_image_data = ImageRawLE::new(include_bytes!("../../assets/ferris.raw"), 86);
+    let ferris = Image::new(&raw_image_data, Point::new(34, 68));
+
+    // Display the image
+    ferris.draw(&mut display).unwrap();
+
+    let style = MonoTextStyle::new(&FONT_10X20, Rgb565::GREEN);
+    Text::new(
+        "Hello embedded_graphics \n + embassy + RP2040!",
+        Point::new(20, 200),
+        style,
+    )
+    .draw(&mut display)
+    .unwrap();
+
+    loop {
+        if let Some((x, y)) = touch.read() {
+            let style = PrimitiveStyleBuilder::new()
+                .fill_color(Rgb565::BLUE)
+                .build();
+
+            Rectangle::new(Point::new(x - 1, y - 1), Size::new(3, 3))
+                .into_styled(style)
+                .draw(&mut display)
+                .unwrap();
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SpiMode {
+    Display,
+    Touch,
+}
+
+struct SpiState {
+    spi: Spi<'static, peripherals::SPI1>,
+    display_cs: Output<'static, peripherals::PIN_9>,
+
+    last_mode: SpiMode,
+}
+
+const DISPLAY_FREQ: u32 = 64_000_000;
+const TOUCH_FREQ: u32 = 200_000;
+
+struct DisplaySpi<'a>(&'a RefCell<SpiState>);
+impl<'a> embedded_hal::blocking::spi::Write<u8> for DisplaySpi<'a> {
+    type Error = core::convert::Infallible;
+
+    fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+        let this = &mut *self.0.borrow_mut();
+        if this.last_mode != SpiMode::Display {
+            this.spi.set_frequency(DISPLAY_FREQ);
+            this.display_cs.set_low();
+            this.last_mode = SpiMode::Display;
+        }
+        this.spi.write(words);
+        Ok(())
+    }
+}
+
+struct TouchSpi<'a>(&'a RefCell<SpiState>);
+impl<'a> embedded_hal::blocking::spi::Transfer<u8> for TouchSpi<'a> {
+    type Error = core::convert::Infallible;
+
+    fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
+        let this = &mut *self.0.borrow_mut();
+        if this.last_mode != SpiMode::Touch {
+            this.spi.set_frequency(TOUCH_FREQ);
+            this.display_cs.set_high();
+            this.last_mode = SpiMode::Touch;
+        }
+        this.spi.transfer(words);
+        Ok(words)
+    }
+}
+
+struct Calibration {
+    x1: i32,
+    x2: i32,
+    y1: i32,
+    y2: i32,
+    sx: i32,
+    sy: i32,
+}
+
+const CALIBRATION: Calibration = Calibration {
+    x1: 3880,
+    x2: 340,
+    y1: 262,
+    y2: 3850,
+    sx: 320,
+    sy: 240,
+};
+
+struct Touch<
+    SPI: embedded_hal::blocking::spi::Transfer<u8>,
+    CS: embedded_hal::digital::v2::OutputPin,
+> {
+    spi: SPI,
+    cs: CS,
+}
+
+impl<SPI: embedded_hal::blocking::spi::Transfer<u8>, CS: embedded_hal::digital::v2::OutputPin>
+    Touch<SPI, CS>
+where
+    SPI::Error: Debug,
+    CS::Error: Debug,
+{
+    pub fn new(spi: SPI, cs: CS) -> Self {
+        Self { spi, cs }
+    }
+
+    pub fn read(&mut self) -> Option<(i32, i32)> {
+        self.cs.set_low().unwrap();
+        let mut buf = [0x90, 0x00, 0x00, 0xd0, 0x00, 0x00];
+        self.spi.transfer(&mut buf).unwrap();
+        self.cs.set_high().unwrap();
+
+        let x = ((buf[1] as u32) << 5 | (buf[2] as u32) >> 3) as i32;
+        let y = ((buf[4] as u32) << 5 | (buf[5] as u32) >> 3) as i32;
+
+        let cal = &CALIBRATION;
+
+        let x = ((x - cal.x1) * cal.sx / (cal.x2 - cal.x1)).clamp(0, cal.sx);
+        let y = ((y - cal.y1) * cal.sy / (cal.y2 - cal.y1)).clamp(0, cal.sy);
+        if x == 0 && y == 0 {
+            None
+        } else {
+            Some((x, y))
+        }
+    }
+}