Struct Flash 

pub struct Flash<'d, MODE = Async> { /* private fields */ }

Internal flash memory driver.

Implementations

impl<'d> Flash<'d, Blocking>

pub fn new_blocking(p: Peri<'d, FLASH>) -> Self

Create a new flash driver, usable in blocking mode.

impl<'d, MODE> Flash<'d, MODE>

pub fn into_blocking_regions(self) -> FlashLayout<'d, Blocking>

Split this flash driver into one instance per flash memory region.

See module-level documentation for details on how memory regions work.

pub fn blocking_read( &mut self, offset: u32, bytes: &mut [u8], ) -> Result<(), Error>

Blocking read.

NOTE: offset is an offset from the flash start, NOT an absolute address. For example, to read address 0x0800_1234 you have to use offset 0x1234.

pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error>

Blocking write.

NOTE: offset is an offset from the flash start, NOT an absolute address. For example, to write address 0x0800_1234 you have to use offset 0x1234.

pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error>

Blocking erase.

NOTE: from and to are offsets from the flash start, NOT an absolute address. For example, to erase address 0x0801_0000 you have to use offset 0x1_0000.

impl<'d> Flash<'d, Blocking>

pub fn edata_is_enabled(&self) -> bool

Returns whether the EDATA area is enabled by the option bytes.

pub fn edata_read( &self, bank: EDataBank, offset: u32, output: &mut [u8], ) -> Result<(), Error>

Reads output.len() bytes from an EDATA bank.

offset is a byte offset from the beginning of the selected physical bank and does not need to be aligned to 2 bytes.

Hardware behavior

EDATA associates ECC information with each aligned 16-bit word. Although this function accepts unaligned byte ranges, it reads the aligned 16-bit word containing each requested byte.

Reading a virgin EDATA word, such as a word that has not been programmed since the page was erased, raises a double ECC error. Therefore, callers should ensure that every 16-bit word touched by the requested range has been programmed before reading it.

See RM0522, “Error correction codes (ECC).”

pub fn edata_read_u16(&self, bank: EDataBank, offset: u32) -> Result<u16, Error>

Reads a 16-bit value from an EDATA bank.

offset is a byte offset from the beginning of the selected physical bank and must be aligned to 2 bytes.

Hardware behavior

EDATA associates ECC information with each aligned 16-bit word. Reading a virgin EDATA word, such as a word that has not been programmed since the page was erased, raises a double ECC error. Callers should ensure that the requested word has been programmed before reading it.

See RM0522, “Error correction codes (ECC).”

pub fn edata_read_u16_slice( &self, bank: EDataBank, offset: u32, output: &mut [u16], ) -> Result<(), Error>

Reads 16-bit values from an EDATA bank into output.

offset is a byte offset from the beginning of the selected physical bank and must be aligned to 2 bytes.

Hardware behavior

EDATA associates ECC information with each aligned 16-bit word. Reading a virgin EDATA word, such as a word that has not been programmed since the page was erased, raises a double ECC error. Callers should ensure that every requested word has been programmed before reading it.

See RM0522, “Error correction codes (ECC).”

pub fn edata_write_u16( &mut self, bank: EDataBank, offset: u32, value: u16, ) -> Result<(), Error>

Writes a 16-bit value to an EDATA bank.

offset is a byte offset from the beginning of the selected physical bank and must be aligned to 2 bytes.

pub fn edata_write_u16_slice( &mut self, bank: EDataBank, offset: u32, values: &[u16], ) -> Result<(), Error>

Writes 16-bit values to an EDATA bank.

offset is a byte offset from the beginning of the selected physical bank and must be aligned to 2 bytes.

pub fn edata_write_u32( &mut self, bank: EDataBank, offset: u32, value: u32, ) -> Result<(), Error>

Writes a 32-bit value to an EDATA bank.

offset is a byte offset from the beginning of the selected physical bank and must be aligned to 4 bytes.

pub fn edata_write( &mut self, bank: EDataBank, offset: u32, data: &[u8], ) -> Result<(), Error>

Writes bytes to an EDATA bank using 16-bit programming operations.

offset is a byte offset from the beginning of the selected physical bank. Both offset and data.len() must be aligned to 2 bytes.

pub fn edata_erase_page( &mut self, bank: EDataBank, page: u8, ) -> Result<(), Error>

Erases one page in an EDATA bank.

page is a zero-based physical page index within the selected bank.

Trait Implementations

impl<MODE> ErrorType for Flash<'_, MODE>

type Error = Error

Errors returned by this NOR flash.

impl<MODE> NorFlash for Flash<'_, MODE>

const WRITE_SIZE: usize = WRITE_SIZE

The minumum number of bytes the storage peripheral can write

const ERASE_SIZE: usize = MAX_ERASE_SIZE

The minumum number of bytes the storage peripheral can erase

fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error>

If power is lost during write, the contents of the written words are undefined, but the rest of the page is guaranteed to be unchanged. It is not allowed to write to the same word twice.

fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error>

Erase the given storage range, clearing all data within [from..to]. The given range will contain all 1s afterwards.

impl<MODE> ReadNorFlash for Flash<'_, MODE>

const READ_SIZE: usize = READ_SIZE

The minumum number of bytes the storage peripheral can read

fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error>

Read a slice of data from the storage peripheral, starting the read operation at the given address offset, and reading bytes.len() bytes.

fn capacity(&self) -> usize

The capacity of the peripheral in bytes.