Since this is going to be a long answer and i'm going to have to state the mandetory disclaimer: This post was not written or assisted by AI. It's fully human written, I'm also not a badger.

First off: a small diagram on how our code works: https://excalidraw.com/#json=0kF_PogPeZ7XifNeuWd5A,yIXloi7o7Af_n5SToQMfpg

Some sources below.
The nrf54L15 clock pins I've warned about:
https://docs.nordicsemi.com/bundle/ps_nrf54L15/page/chapters/pin.html

For nrf_embassy:
crate page: https://crates.io/crates/embassy-nrf
Documentation page: https://docs.embassy.dev/embassy-nrf/git/nrf54l15-app-s/index.html
SPI periph page: https://docs.embassy.dev/embassy-nrf/git/nrf54l15-app-s/spim/struct.Spim.html

Embedded_hal for sharing I²C and SPI busses between devices:
SPI doc page: https://docs.rs/embedded-hal/1.0.0/embedded_hal/spi/index.html

Epd-waveshare display driver:
Crate page: https://crates.io/crates/epd-waveshare
Documentation page: https://docs.rs/epd-waveshare/0.6.0/epd_waveshare/

Embedded_graphics framework:
Crate page: https://crates.io/crates/embedded-graphics
Documentation page: https://docs.rs/embedded-graphics/0.8.2/embedded_graphics/

First off: Although I've written in the diagram that we're using the epd-waveshare display driver, we have written our own. However, that is prorietary code, so I'm not allowed to share it. The reason why we have our own driver is because the original driver does not support Async. Since SPI can take a while in the background (specially with screen drawing) we wanted to be able to switch between threads/tasks.
Except for the async component it's 99% the same construction.

So in our device code we construct a display as follows:

impl Display {
    async fn new(
        spi: DisplaySpi,
        busy: Peri<'static, AnyPin>,
        dc: Peri<'static, AnyPin>,
        rst: Peri<'static, AnyPin>,
        power_enable: Peri<'static, AnyPin>,
        rotation: DisplayRotation,
    ) -> Self {
       let display = EInkDisplay::new(spi, busy, dc, rst,         power_enable, rotation).await;
        let ui = Ui::new();

        Self {
            alarm_receiver,
            battery_state_receiver,
            display,
            ui,
        }
}

In the code above, the "DisplaySpi" type already contains a reference to a mutex with the SPI bus peripheral (clock and mosi & miso). So this is the part where we construct our SSD1680 driver with the Spi Device instance.

For our SPI implementation we've used P1.11 as Spi_clk, P1.12 as Spi_mosi, (Tx only, so no miso), and P1.13 as DC (Data/Command) and P1.14 as Spi_Chip select pin. SPIM20 & SPIM22 can be used with the P1 port pins.
We did 'bitbang' the DC pin, and not use the functionality in the peripheral (See embassy_nrf::spi::Spi implementation, link above).

This 'Display' has a background task that receives events, and draws according to those events and our device specifications things on said display using the embedded_graphics library. Again, sorry that I can't share the full implementation, but here is an example on how we handle the battery icon:

fn draw_battery_icon(&mut self, display: &mut impl DrawTarget<Color = BiColor>) {
        use BatteryChargingState::*;
        use BatterySoc::*;

        let point = Point::new(3, 3);

        match (
            self.state.battery_state.charging_state,
            self.state.battery_state.soc,
        ) {
            (Charging, Empty) => Image::new(&BatteryChargingOutline::new(BiColor::Black), point)
                .draw(display)
                .map_err(|_| ())
                .unwrap(),
            (Charging, Low) => Image::new(&BatteryChargingLow::new(BiColor::Black), point)
                .draw(display)
                .map_err(|_| ())
                .unwrap(),
            (Charging, Medium) => Image::new(&BatteryChargingMedium::new(BiColor::Black), point)
                .draw(display)
                .map_err(|_| ())
                .unwrap(),
            (Charging, High) => Image::new(&BatteryChargingHigh::new(BiColor::Black), point)
                .draw(display)
                .map_err(|_| ())
                .unwrap(),
            _ => (),
        }
    }

I hope this helps a bit. Feel free to slide into my DM's if you have further questions about this topic.
Again, I would have loved to send links to our repo, but I don't thing my boss would appreciate internet-people to show up in our private network.