esp-storage 0.9.0

Implementation of embedded-storage traits to access unencrypted ESP32 flash
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! # Low-level API
//!
//! ⚠️ This is a low-level API and should be used with caution. ⚠️
//!
//! This gives you access to the underlying low level functionality.
//! These operate on raw pointers and all functions here are unsafe.
//! No pre-conditions are checked by any of these functions.

use crate::chip_specific;

/// Low-level SPI NOR Flash read
///
/// # Safety
///
/// The `src_addr` + `len` should not exceeds the size of flash.
/// The `data` expected to points to word-aligned pre-allocated buffer with size
/// greater or equals to `len`.
pub unsafe fn spiflash_read(src_addr: u32, data: *mut u32, len: u32) -> Result<(), i32> {
    match chip_specific::spiflash_read(src_addr, data, len) {
        0 => Ok(()),
        value => Err(value),
    }
}

/// Low-level SPI NOR Flash unlock
///
/// # Safety
pub unsafe fn spiflash_unlock() -> Result<(), i32> {
    match chip_specific::spiflash_unlock() {
        0 => Ok(()),
        value => Err(value),
    }
}

/// Low-level SPI NOR Flash sector erase
///
/// # Safety
///
/// The `sector_number` * sector_size should not exceeds the size of flash.
pub unsafe fn spiflash_erase_sector(sector_number: u32) -> Result<(), i32> {
    match chip_specific::spiflash_erase_sector(sector_number) {
        0 => Ok(()),
        value => Err(value),
    }
}

/// Low-level SPI NOR Flash block erase
///
/// # Safety
///
/// The `block_number` * block_size should not exceeds the size of flash.
pub unsafe fn spiflash_erase_block(block_number: u32) -> Result<(), i32> {
    match chip_specific::spiflash_erase_block(block_number) {
        0 => Ok(()),
        value => Err(value),
    }
}

/// Low-level SPI NOR Flash write
///
/// # Safety
///
/// The `dest_addr` + `len` should not exceeds the size of flash.
/// The `data` expected to points to word-aligned buffer with size greater or
/// equals to `len`.
pub unsafe fn spiflash_write(dest_addr: u32, data: *const u32, len: u32) -> Result<(), i32> {
    match chip_specific::spiflash_write(dest_addr, data, len) {
        0 => Ok(()),
        value => Err(value),
    }
}