embassy/embassy-nrf/src/qspi.rs

448 lines
13 KiB
Rust
Raw Normal View History

#![macro_use]
2020-09-22 16:03:43 +00:00
use core::future::Future;
2021-03-21 19:54:09 +00:00
use core::marker::PhantomData;
use core::ptr;
2021-02-28 21:05:37 +00:00
use core::task::Poll;
2021-04-14 15:00:28 +00:00
use embassy::interrupt::{Interrupt, InterruptExt};
use embassy::traits::flash::{Error, Flash};
use embassy::util::Unborrow;
use embassy_hal_common::drop::DropBomb;
use embassy_hal_common::unborrow;
2021-04-14 15:00:28 +00:00
use futures::future::poll_fn;
2021-03-07 23:15:40 +00:00
use crate::gpio::sealed::Pin as _;
use crate::gpio::{self, Pin as GpioPin};
2021-05-17 09:48:58 +00:00
use crate::pac;
2020-09-22 16:03:43 +00:00
pub use crate::pac::qspi::ifconfig0::ADDRMODE_A as AddressMode;
pub use crate::pac::qspi::ifconfig0::PPSIZE_A as WritePageSize;
pub use crate::pac::qspi::ifconfig0::READOC_A as ReadOpcode;
pub use crate::pac::qspi::ifconfig0::WRITEOC_A as WriteOpcode;
// TODO
// - config:
// - 32bit address mode
// - SPI freq
// - SPI sck delay
// - Deep power down mode (DPM)
// - SPI mode 3
// - activate/deactivate
// - set gpio in high drive
2020-11-27 17:42:59 +00:00
pub struct DeepPowerDownConfig {
/// Time required for entering DPM, in units of 16us
2020-11-27 17:42:59 +00:00
pub enter_time: u16,
/// Time required for exiting DPM, in units of 16us
2020-11-27 17:42:59 +00:00
pub exit_time: u16,
}
2021-03-28 22:55:05 +00:00
#[non_exhaustive]
2020-09-22 16:03:43 +00:00
pub struct Config {
pub xip_offset: u32,
pub read_opcode: ReadOpcode,
pub write_opcode: WriteOpcode,
pub write_page_size: WritePageSize,
2020-11-27 17:42:59 +00:00
pub deep_power_down: Option<DeepPowerDownConfig>,
2020-09-22 16:03:43 +00:00
}
2021-03-28 22:55:05 +00:00
impl Default for Config {
fn default() -> Self {
Self {
read_opcode: ReadOpcode::READ4IO,
write_opcode: WriteOpcode::PP4IO,
xip_offset: 0,
write_page_size: WritePageSize::_256BYTES,
deep_power_down: None,
}
}
}
2021-03-21 19:54:09 +00:00
pub struct Qspi<'d, T: Instance> {
dpm_enabled: bool,
2021-03-21 19:54:09 +00:00
phantom: PhantomData<&'d mut T>,
2021-02-28 21:05:37 +00:00
}
2021-03-21 19:54:09 +00:00
impl<'d, T: Instance> Qspi<'d, T> {
pub async fn new(
2021-05-17 10:23:04 +00:00
_qspi: impl Unborrow<Target = T> + 'd,
2021-04-14 17:59:52 +00:00
irq: impl Unborrow<Target = T::Interrupt> + 'd,
sck: impl Unborrow<Target = impl GpioPin> + 'd,
csn: impl Unborrow<Target = impl GpioPin> + 'd,
io0: impl Unborrow<Target = impl GpioPin> + 'd,
io1: impl Unborrow<Target = impl GpioPin> + 'd,
io2: impl Unborrow<Target = impl GpioPin> + 'd,
io3: impl Unborrow<Target = impl GpioPin> + 'd,
2021-03-21 19:54:09 +00:00
config: Config,
) -> Qspi<'d, T> {
2021-05-17 10:23:04 +00:00
unborrow!(irq, sck, csn, io0, io1, io2, io3);
2021-03-21 19:54:09 +00:00
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
let sck = sck.degrade();
let csn = csn.degrade();
let io0 = io0.degrade();
let io1 = io1.degrade();
let io2 = io2.degrade();
let io3 = io3.degrade();
for pin in [&sck, &csn, &io0, &io1, &io2, &io3] {
pin.set_high();
pin.conf().write(|w| w.dir().output().drive().h0h1());
2021-03-21 19:54:09 +00:00
}
2020-09-22 16:03:43 +00:00
2021-03-21 19:54:09 +00:00
r.psel.sck.write(|w| unsafe { w.bits(sck.psel_bits()) });
r.psel.csn.write(|w| unsafe { w.bits(csn.psel_bits()) });
r.psel.io0.write(|w| unsafe { w.bits(io0.psel_bits()) });
r.psel.io1.write(|w| unsafe { w.bits(io1.psel_bits()) });
r.psel.io2.write(|w| unsafe { w.bits(io2.psel_bits()) });
r.psel.io3.write(|w| unsafe { w.bits(io3.psel_bits()) });
2020-09-22 16:03:43 +00:00
r.ifconfig0.write(|w| {
w.addrmode().variant(AddressMode::_24BIT);
w.dpmenable().bit(config.deep_power_down.is_some());
w.ppsize().variant(config.write_page_size);
w.readoc().variant(config.read_opcode);
w.writeoc().variant(config.write_opcode);
2020-09-22 16:03:43 +00:00
w
});
2020-11-27 17:42:59 +00:00
if let Some(dpd) = &config.deep_power_down {
r.dpmdur.write(|w| unsafe {
w.enter().bits(dpd.enter_time);
w.exit().bits(dpd.exit_time);
2020-11-27 17:42:59 +00:00
w
})
}
r.ifconfig1.write(|w| unsafe {
w.sckdelay().bits(80);
w.dpmen().exit();
w.spimode().mode0();
w.sckfreq().bits(3);
w
});
r.xipoffset.write(|w| unsafe {
w.xipoffset().bits(config.xip_offset);
2020-09-22 16:03:43 +00:00
w
});
irq.set_handler(Self::on_interrupt);
irq.unpend();
irq.enable();
2020-09-22 16:03:43 +00:00
// Enable it
2021-03-21 19:54:09 +00:00
r.enable.write(|w| w.enable().enabled());
2020-09-22 16:03:43 +00:00
let mut res = Self {
dpm_enabled: config.deep_power_down.is_some(),
phantom: PhantomData,
};
2021-03-21 19:54:09 +00:00
r.events_ready.reset();
r.intenset.write(|w| w.ready().set());
2021-03-21 19:54:09 +00:00
r.tasks_activate.write(|w| w.tasks_activate().bit(true));
2020-09-22 16:03:43 +00:00
res.wait_ready().await;
2021-04-14 15:00:28 +00:00
res
2020-09-22 16:03:43 +00:00
}
2021-04-14 15:00:28 +00:00
fn on_interrupt(_: *mut ()) {
let r = T::regs();
let s = T::state();
if r.events_ready.read().bits() != 0 {
s.ready_waker.wake();
r.intenclr.write(|w| w.ready().clear());
}
}
2021-03-21 19:54:09 +00:00
pub async fn custom_instruction(
2021-04-14 15:00:28 +00:00
&mut self,
2020-09-22 16:03:43 +00:00
opcode: u8,
2021-03-21 19:54:09 +00:00
req: &[u8],
resp: &mut [u8],
2021-02-14 00:41:36 +00:00
) -> Result<(), Error> {
let bomb = DropBomb::new();
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
assert!(req.len() <= 8);
assert!(resp.len() <= 8);
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
let mut dat0: u32 = 0;
let mut dat1: u32 = 0;
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
for i in 0..4 {
if i < req.len() {
dat0 |= (req[i] as u32) << (i * 8);
2020-09-22 16:03:43 +00:00
}
2021-02-14 00:41:36 +00:00
}
for i in 0..4 {
if i + 4 < req.len() {
dat1 |= (req[i + 4] as u32) << (i * 8);
2020-09-22 16:03:43 +00:00
}
2021-02-14 00:41:36 +00:00
}
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
let len = core::cmp::max(req.len(), resp.len()) as u8;
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
r.cinstrdat0.write(|w| unsafe { w.bits(dat0) });
r.cinstrdat1.write(|w| unsafe { w.bits(dat1) });
r.events_ready.reset();
r.intenset.write(|w| w.ready().set());
r.cinstrconf.write(|w| {
let w = unsafe { w.opcode().bits(opcode) };
let w = unsafe { w.length().bits(len + 1) };
let w = w.lio2().bit(true);
let w = w.lio3().bit(true);
let w = w.wipwait().bit(true);
let w = w.wren().bit(true);
let w = w.lfen().bit(false);
let w = w.lfstop().bit(false);
w
2021-02-14 00:41:36 +00:00
});
2020-09-22 16:03:43 +00:00
2021-04-14 15:00:28 +00:00
self.wait_ready().await;
2020-09-22 16:03:43 +00:00
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
let dat0 = r.cinstrdat0.read().bits();
let dat1 = r.cinstrdat1.read().bits();
for i in 0..4 {
if i < resp.len() {
resp[i] = (dat0 >> (i * 8)) as u8;
2020-09-22 16:03:43 +00:00
}
2021-03-21 19:54:09 +00:00
}
for i in 0..4 {
if i + 4 < resp.len() {
resp[i] = (dat1 >> (i * 8)) as u8;
2020-09-22 16:03:43 +00:00
}
2021-03-21 19:54:09 +00:00
}
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
bomb.defuse();
2020-09-22 16:03:43 +00:00
2021-02-14 00:41:36 +00:00
Ok(())
2020-09-22 16:03:43 +00:00
}
2021-02-28 21:05:37 +00:00
2021-04-14 15:00:28 +00:00
async fn wait_ready(&mut self) {
2021-02-28 21:05:37 +00:00
poll_fn(move |cx| {
2021-04-14 15:00:28 +00:00
let r = T::regs();
let s = T::state();
s.ready_waker.register(cx.waker());
2021-03-21 19:54:09 +00:00
if r.events_ready.read().bits() != 0 {
return Poll::Ready(());
}
Poll::Pending
2021-02-28 21:05:37 +00:00
})
2021-03-21 19:54:09 +00:00
.await
2021-02-28 21:05:37 +00:00
}
2020-09-22 16:03:43 +00:00
}
impl<'d, T: Instance> Drop for Qspi<'d, T> {
fn drop(&mut self) {
let r = T::regs();
if self.dpm_enabled {
info!("qspi: doing deep powerdown...");
r.ifconfig1.modify(|_, w| w.dpmen().enter());
// Wait for DPM enter.
// Unfortunately we must spin. There's no way to do this interrupt-driven.
// The READY event does NOT fire on DPM enter (but it does fire on DPM exit :shrug:)
while r.status.read().dpm().is_disabled() {}
2021-05-26 22:42:29 +00:00
// Wait MORE for DPM enter.
// I have absolutely no idea why, but the wait above is not enough :'(
// Tested with mx25r64 in nrf52840-dk, and with mx25r16 in custom board
cortex_m::asm::delay(4096);
}
// it seems events_ready is not generated in response to deactivate. nrfx doesn't wait for it.
r.tasks_deactivate.write(|w| w.tasks_deactivate().set_bit());
// Workaround https://infocenter.nordicsemi.com/topic/errata_nRF52840_Rev1/ERR/nRF52840/Rev1/latest/anomaly_840_122.html?cp=4_0_1_2_1_7
// Note that the doc has 2 register writes, but the first one is really the write to tasks_deactivate,
// so we only do the second one here.
unsafe { ptr::write_volatile(0x40029054 as *mut u32, 1) }
r.enable.write(|w| w.enable().disabled());
// Note: we do NOT deconfigure CSN here. If DPM is in use and we disconnect CSN,
// leaving it floating, the flash chip might read it as zero which would cause it to
// spuriously exit DPM.
gpio::deconfigure_pin(r.psel.sck.read().bits());
gpio::deconfigure_pin(r.psel.io0.read().bits());
gpio::deconfigure_pin(r.psel.io1.read().bits());
gpio::deconfigure_pin(r.psel.io2.read().bits());
gpio::deconfigure_pin(r.psel.io3.read().bits());
info!("qspi: dropped");
}
}
2021-03-21 19:54:09 +00:00
impl<'d, T: Instance> Flash for Qspi<'d, T> {
2021-12-16 10:37:53 +00:00
type ReadFuture<'a>
where
Self: 'a,
= impl Future<Output = Result<(), Error>> + 'a;
type WriteFuture<'a>
where
Self: 'a,
= impl Future<Output = Result<(), Error>> + 'a;
type ErasePageFuture<'a>
where
Self: 'a,
= impl Future<Output = Result<(), Error>> + 'a;
2020-09-22 16:03:43 +00:00
2021-04-14 15:00:28 +00:00
fn read<'a>(&'a mut self, address: usize, data: &'a mut [u8]) -> Self::ReadFuture<'a> {
2020-09-22 16:03:43 +00:00
async move {
let bomb = DropBomb::new();
assert_eq!(data.as_ptr() as u32 % 4, 0);
assert_eq!(data.len() as u32 % 4, 0);
assert_eq!(address as u32 % 4, 0);
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
r.read
.src
.write(|w| unsafe { w.src().bits(address as u32) });
r.read
.dst
.write(|w| unsafe { w.dst().bits(data.as_ptr() as u32) });
r.read
.cnt
.write(|w| unsafe { w.cnt().bits(data.len() as u32) });
r.events_ready.reset();
r.intenset.write(|w| w.ready().set());
r.tasks_readstart.write(|w| w.tasks_readstart().bit(true));
2021-02-28 21:05:37 +00:00
2021-04-14 15:00:28 +00:00
self.wait_ready().await;
2020-09-22 16:03:43 +00:00
bomb.defuse();
Ok(())
}
}
2021-04-14 15:00:28 +00:00
fn write<'a>(&'a mut self, address: usize, data: &'a [u8]) -> Self::WriteFuture<'a> {
2020-09-22 16:03:43 +00:00
async move {
let bomb = DropBomb::new();
assert_eq!(data.as_ptr() as u32 % 4, 0);
assert_eq!(data.len() as u32 % 4, 0);
assert_eq!(address as u32 % 4, 0);
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
r.write
.src
.write(|w| unsafe { w.src().bits(data.as_ptr() as u32) });
r.write
.dst
.write(|w| unsafe { w.dst().bits(address as u32) });
r.write
.cnt
.write(|w| unsafe { w.cnt().bits(data.len() as u32) });
r.events_ready.reset();
r.intenset.write(|w| w.ready().set());
r.tasks_writestart.write(|w| w.tasks_writestart().bit(true));
2021-02-28 21:05:37 +00:00
2021-04-14 15:00:28 +00:00
self.wait_ready().await;
2020-09-22 16:03:43 +00:00
bomb.defuse();
Ok(())
}
}
2021-04-14 15:00:28 +00:00
fn erase<'a>(&'a mut self, address: usize) -> Self::ErasePageFuture<'a> {
2020-09-22 16:03:43 +00:00
async move {
let bomb = DropBomb::new();
assert_eq!(address as u32 % 4096, 0);
2021-04-14 15:00:28 +00:00
let r = T::regs();
2021-03-21 19:54:09 +00:00
r.erase
.ptr
.write(|w| unsafe { w.ptr().bits(address as u32) });
r.erase.len.write(|w| w.len()._4kb());
2021-02-28 21:05:37 +00:00
2021-03-21 19:54:09 +00:00
r.events_ready.reset();
r.intenset.write(|w| w.ready().set());
r.tasks_erasestart.write(|w| w.tasks_erasestart().bit(true));
2020-09-22 16:03:43 +00:00
2021-04-14 15:00:28 +00:00
self.wait_ready().await;
2020-09-22 16:03:43 +00:00
bomb.defuse();
Ok(())
}
}
fn size(&self) -> usize {
256 * 4096 // TODO
}
fn read_size(&self) -> usize {
4 // TODO
}
fn write_size(&self) -> usize {
4 // TODO
}
fn erase_size(&self) -> usize {
4096 // TODO
}
}
pub(crate) mod sealed {
use embassy::waitqueue::AtomicWaker;
2021-03-21 19:54:09 +00:00
use super::*;
2020-09-22 16:03:43 +00:00
2021-04-14 15:00:28 +00:00
pub struct State {
pub ready_waker: AtomicWaker,
}
impl State {
pub const fn new() -> Self {
Self {
ready_waker: AtomicWaker::new(),
}
}
}
2021-03-21 19:54:09 +00:00
pub trait Instance {
2021-04-14 15:00:28 +00:00
fn regs() -> &'static pac::qspi::RegisterBlock;
fn state() -> &'static State;
2020-09-22 16:03:43 +00:00
}
}
2021-03-21 19:54:09 +00:00
pub trait Instance: Unborrow<Target = Self> + sealed::Instance + 'static {
2021-03-21 19:54:09 +00:00
type Interrupt: Interrupt;
}
macro_rules! impl_qspi {
($type:ident, $pac_type:ident, $irq:ident) => {
impl crate::qspi::sealed::Instance for peripherals::$type {
2021-04-14 15:00:28 +00:00
fn regs() -> &'static pac::qspi::RegisterBlock {
unsafe { &*pac::$pac_type::ptr() }
2021-03-21 19:54:09 +00:00
}
fn state() -> &'static crate::qspi::sealed::State {
static STATE: crate::qspi::sealed::State = crate::qspi::sealed::State::new();
2021-04-14 15:00:28 +00:00
&STATE
}
2021-03-21 19:54:09 +00:00
}
impl crate::qspi::Instance for peripherals::$type {
type Interrupt = crate::interrupt::$irq;
2021-03-21 19:54:09 +00:00
}
};
}