shrike-esp 0.1.0

ESP32-specific implementation for flashing FPGAs using shrike-core.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#[cfg(not(feature = "embassy"))]
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    peripherals::{GPIO8, GPIO9, GPIO10, GPIO11, GPIO12, GPIO13, SPI2},
    spi::{
        Mode,
        master::{Config, Spi},
    },
    time::Rate,
};
#[cfg(not(feature = "embassy"))]
use shrike_core::{error::FlashError, universal::UniversalSPIflash};

/*
  #define SHRIKE_DEFAULT_EN_PIN     9
  #define SHRIKE_DEFAULT_PWR_PIN    8
  #define SHRIKE_DEFAULT_SS_PIN    10
  #define SHRIKE_DEFAULT_SCK_PIN   12
  #define SHRIKE_DEFAULT_MOSI_PIN  11
  #define SHRIKE_DEFAULT_MISO_PIN  13
*/

#[cfg(not(feature = "embassy"))]
pub fn init_esp32s3_normal(
    spi: SPI2<'static>,
    sclk: GPIO12<'static>,
    mosi: GPIO11<'static>,
    miso: GPIO13<'static>,
    ss: GPIO10<'static>,
    en: GPIO9<'static>,
    pwr: GPIO8<'static>,
    bin: &[u8],
) -> Result<(), FlashError> {
    use shrike_core::universal::Flash;

    let config = Config::default()
        .with_frequency(Rate::from_hz(1_600_000))
        .with_mode(Mode::_0);

    let spi = Spi::new(spi, config)
        .map_err(|_| FlashError::SpiWriteError)?
        .with_sck(sclk)
        .with_mosi(mosi)
        .with_miso(miso);

    let en = Output::new(en, Level::Low, OutputConfig::default());
    let ss = Output::new(ss, Level::Low, OutputConfig::default());
    let pwr = Output::new(pwr, Level::Low, OutputConfig::default());

    let mut delay = Delay::new();
    let mut flash = UniversalSPIflash::new(spi, en, pwr, ss, &mut delay);
    flash.flash(bin)
}

#[cfg(feature = "embassy")]
pub mod async_esp {
    use esp_hal::{
        dma::{DmaRxBuf, DmaTxBuf},
        gpio::{Level, Output, OutputConfig},
        peripherals::{DMA_CH0, GPIO8, GPIO9, GPIO10, GPIO11, GPIO12, GPIO13, SPI2},
        spi::{
            Mode,
            master::{Config, Spi},
        },
        time::Rate,
    };
    use shrike_core::{
        async_universal::{AsyncFlash, UniversalAsyncSPIflash},
        error::FlashError,
        universal::UniversalSPIflash,
    };

    pub async fn init_esp32s3_blocking_async(
        spi: SPI2<'static>,
        sclk: GPIO12<'static>,
        mosi: GPIO11<'static>,
        miso: GPIO13<'static>,
        ss: GPIO10<'static>,
        en: GPIO9<'static>,
        pwr: GPIO8<'static>,
        bin: &[u8],
    ) -> Result<(), FlashError> {
        let config = Config::default()
            .with_frequency(Rate::from_hz(1_600_000))
            .with_mode(Mode::_0);

        let spi = Spi::new(spi, config)
            .map_err(|_| FlashError::SpiWriteError)?
            .with_sck(sclk)
            .with_mosi(mosi)
            .with_miso(miso);

        let en = Output::new(en, Level::Low, OutputConfig::default());
        let ss = Output::new(ss, Level::Low, OutputConfig::default());
        let pwr = Output::new(pwr, Level::Low, OutputConfig::default());

        let mut flash = UniversalSPIflash::new(spi, en, pwr, ss);
        flash.flash(bin).await
    }

    pub async fn init_esp32s3_all_async<'d>(
        spi: SPI2<'static>,
        sclk: GPIO12<'static>,
        mosi: GPIO11<'static>,
        miso: GPIO13<'static>,
        ss: GPIO10<'static>,
        en: GPIO9<'static>,
        pwr: GPIO8<'static>,
        dma_channel: DMA_CH0<'static>,
        rx_buf: DmaRxBuf,
        tx_buf: DmaTxBuf,
        bin: &[u8],
    ) -> Result<(), FlashError> {
        let config = Config::default()
            .with_frequency(Rate::from_hz(1_600_000))
            .with_mode(Mode::_0);

        let spi = Spi::new(spi, config)
            .map_err(|_| FlashError::SpiWriteError)?
            .with_sck(sclk)
            .with_mosi(mosi)
            .with_miso(miso)
            .with_dma(dma_channel)
            .with_buffers(rx_buf, tx_buf)
            .into_async();

        let en = Output::new(en, Level::Low, OutputConfig::default());
        let ss = Output::new(ss, Level::Low, OutputConfig::default());
        let pwr = Output::new(pwr, Level::Low, OutputConfig::default());

        let mut flash = UniversalAsyncSPIflash::new(spi, en, pwr, ss);
        flash.flash(bin).await
    }
}