nander-rs 0.5.5

Modern SPI NAND/NOR Flash programmer for CH341A with cross-platform GUI and comprehensive diagnostics
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
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

//! CLI Handler - Erase
//!
//! Handles the 'erase' command by invoking the erase flash use case.

use crate::application::use_cases::detect_chip::DetectChipUseCase;
use crate::application::use_cases::erase_flash::{EraseFlashUseCase, EraseParams};
use crate::domain::FlashType;
use crate::error::Result;
use crate::infrastructure::chip_database::ChipRegistry;
use crate::infrastructure::flash_protocol::eeprom::{I2cEeprom, MicrowireEeprom, SpiEeprom};
use crate::infrastructure::flash_protocol::nand::SpiNand;
use crate::infrastructure::flash_protocol::nor::SpiNor;

pub struct EraseHandler {
    detect_use_case: DetectChipUseCase,
}

impl Default for EraseHandler {
    fn default() -> Self {
        Self::new()
    }
}

impl EraseHandler {
    pub fn new() -> Self {
        Self {
            detect_use_case: DetectChipUseCase::new(ChipRegistry::new()),
        }
    }

    pub fn handle(&self, options: crate::domain::FlashOptions) -> Result<()> {
        let (programmer, spec) = self
            .detect_use_case
            .execute(options.speed, options.driver.as_deref())?;
        println!("Detected chip: {} ({})", spec.name, spec.manufacturer);

        let start = options.address;
        let erase_len = options.length.unwrap_or(spec.capacity.as_bytes() - start);

        // Load BBT if provided
        let bbt = if let Some(ref path) = options.bbt_file {
            Some(super::load_bbt(path)?)
        } else {
            None
        };

        let params = EraseParams {
            address: start,
            length: erase_len,
            bad_block_strategy: options.bad_block_strategy,
            bbt,
        };

        println!("Erasing {} bytes starting at 0x{:08X}...", erase_len, start);

        let pb = super::create_progress_bar(erase_len as u64, "Erasing");

        match spec.flash_type {
            FlashType::Nand => {
                let protocol = SpiNand::new(programmer, spec);
                let mut use_case = EraseFlashUseCase::new(protocol);
                use_case.execute(params, |progress| {
                    pb.set_position(progress.current);
                })?
            }
            FlashType::Nor => {
                let protocol = SpiNor::new(programmer, spec);
                let mut use_case = EraseFlashUseCase::new(protocol);
                use_case.execute(params, |progress| {
                    pb.set_position(progress.current);
                })?
            }
            FlashType::SpiEeprom => {
                // SPI EEPROM doesn't need explicit erase, but we fill with 0xFF
                pb.set_message("Filling with 0xFF");
                let protocol = SpiEeprom::new(programmer, spec);
                let mut use_case = EraseFlashUseCase::new(protocol);
                use_case.execute(params, |progress| {
                    pb.set_position(progress.current);
                })?
            }
            FlashType::I2cEeprom => {
                // I2C EEPROM doesn't need explicit erase, but we fill with 0xFF
                pb.set_message("Filling with 0xFF");
                let protocol = I2cEeprom::new(programmer, spec);
                let mut use_case = EraseFlashUseCase::new(protocol);
                use_case.execute(params, |progress| {
                    pb.set_position(progress.current);
                })?
            }
            FlashType::MicrowireEeprom => {
                // Microwire EEPROM doesn't need explicit erase, but we fill with 0xFF
                pb.set_message("Filling with 0xFF");
                let protocol = MicrowireEeprom::new(programmer, spec);
                let mut use_case = EraseFlashUseCase::new(protocol);
                use_case.execute(params, |progress| {
                    pb.set_position(progress.current);
                })?
            }
            FlashType::SpiFram => {
                // FRAM doesn't need erase
                pb.set_message("Skipping erase (FRAM)");
                pb.finish_with_message("Done");
            }
        };

        pb.finish_with_message("Erase Complete");

        use colored::*;
        println!("{}", "\nErase SUCCESSFUL!".green().bold());
        Ok(())
    }
}