aboutsummaryrefslogtreecommitdiff
path: root/embassy-boot/boot/src/test_flash/blocking.rs
blob: 5ec476c6574811f22b034e273f8a65188a126a71 (plain)
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
use core::cell::RefCell;

use embassy_embedded_hal::flash::partition::BlockingPartition;
use embassy_sync::blocking_mutex::raw::NoopRawMutex;
use embassy_sync::blocking_mutex::Mutex;
use embedded_storage::nor_flash::NorFlash;

use crate::BootLoaderConfig;

pub struct BlockingTestFlash<ACTIVE, DFU, STATE>
where
    ACTIVE: NorFlash,
    DFU: NorFlash,
    STATE: NorFlash,
{
    active: Mutex<NoopRawMutex, RefCell<ACTIVE>>,
    dfu: Mutex<NoopRawMutex, RefCell<DFU>>,
    state: Mutex<NoopRawMutex, RefCell<STATE>>,
}

impl<ACTIVE, DFU, STATE> BlockingTestFlash<ACTIVE, DFU, STATE>
where
    ACTIVE: NorFlash,
    DFU: NorFlash,
    STATE: NorFlash,
{
    pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
        Self {
            active: Mutex::new(RefCell::new(config.active)),
            dfu: Mutex::new(RefCell::new(config.dfu)),
            state: Mutex::new(RefCell::new(config.state)),
        }
    }

    pub fn active(&self) -> BlockingPartition<NoopRawMutex, ACTIVE> {
        Self::create_partition(&self.active)
    }

    pub fn dfu(&self) -> BlockingPartition<NoopRawMutex, DFU> {
        Self::create_partition(&self.dfu)
    }

    pub fn state(&self) -> BlockingPartition<NoopRawMutex, STATE> {
        Self::create_partition(&self.state)
    }

    pub fn create_partition<T: NorFlash>(
        mutex: &Mutex<NoopRawMutex, RefCell<T>>,
    ) -> BlockingPartition<NoopRawMutex, T> {
        BlockingPartition::new(mutex, 0, mutex.lock(|f| f.borrow().capacity()) as u32)
    }
}

impl<ACTIVE, DFU, STATE> BlockingTestFlash<ACTIVE, DFU, STATE>
where
    ACTIVE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
    DFU: NorFlash + embedded_storage_async::nor_flash::NorFlash,
    STATE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
{
    pub fn into_async(self) -> super::AsyncTestFlash<ACTIVE, DFU, STATE> {
        let config = BootLoaderConfig {
            active: self.active.into_inner().into_inner(),
            dfu: self.dfu.into_inner().into_inner(),
            state: self.state.into_inner().into_inner(),
        };
        super::AsyncTestFlash::new(config)
    }
}