Skip to main content

sftool_lib/common/
write_flash.rs

1use crate::common::debug_sequence::DebugSequenceReplacementInfo;
2use crate::common::ram_command::{Command, RamCommand, Response};
3use crate::common::serial_io::for_tool;
4use crate::progress::{ProgressOperation, ProgressStatus};
5use crate::{Error, Result, SifliToolTrait, WriteFlashFile};
6use std::io::{BufReader, Read, Seek, SeekFrom};
7
8/// 通用的Flash写入操作实现
9pub struct FlashWriter;
10
11impl FlashWriter {
12    /// 擦除所有Flash区域
13    pub fn erase_all<T>(tool: &mut T, write_flash_files: &[WriteFlashFile]) -> Result<()>
14    where
15        T: SifliToolTrait + RamCommand,
16    {
17        tool.check_cancelled()?;
18        let progress = tool.progress();
19        let spinner = progress.create_spinner(ProgressOperation::EraseAllRegions);
20
21        let mut erase_address: Vec<u32> = Vec::new();
22        for f in write_flash_files.iter() {
23            tool.check_cancelled()?;
24            let address = f.address & 0xFF00_0000;
25            // 如果ERASE_ADDRESS中的地址已经被擦除过,则跳过
26            if erase_address.contains(&address) {
27                continue;
28            }
29            tool.command(Command::EraseAll { address: f.address })?;
30            erase_address.push(address);
31        }
32
33        spinner.finish(ProgressStatus::Success);
34        Ok(())
35    }
36
37    /// 验证数据
38    pub fn verify<T>(tool: &mut T, address: u32, len: u32, crc: u32) -> Result<()>
39    where
40        T: SifliToolTrait + RamCommand,
41    {
42        tool.check_cancelled()?;
43        let progress = tool.progress();
44        let spinner = progress.create_spinner(ProgressOperation::Verify { address, len });
45
46        let response = tool.command(Command::Verify { address, len, crc })?;
47        if response != Response::Ok {
48            return Err(Error::protocol(format!(
49                "verify failed for 0x{:08X}..0x{:08X}",
50                address,
51                address + len.saturating_sub(1)
52            )));
53        }
54
55        spinner.finish(ProgressStatus::Success);
56        Ok(())
57    }
58
59    fn prepare_debug_sequence_replacement<T>(
60        tool: &mut T,
61        file: &WriteFlashFile,
62    ) -> Result<Option<DebugSequenceReplacementInfo>>
63    where
64        T: SifliToolTrait + RamCommand,
65    {
66        if !tool.supports_debug_sequence_replacement()? {
67            return Ok(None);
68        }
69
70        let info = DebugSequenceReplacementInfo::scan_file(&file.file)?;
71        let response = tool.send_debug_sequence_replacement_info(&info)?;
72        if response != Response::Ok {
73            return Err(Error::protocol(format!(
74                "burn_info rejected replacement table for 0x{:08X}: {response:?}",
75                file.address
76            )));
77        }
78
79        tracing::debug!(
80            address = format_args!("0x{:08X}", file.address),
81            replacement_count = info.len(),
82            "prepared Debug IP-safe flash transfer"
83        );
84        Ok(Some(info))
85    }
86
87    /// 写入单个文件到Flash(非全擦除模式)
88    pub fn write_file_incremental<T>(
89        tool: &mut T,
90        file: &WriteFlashFile,
91        verify: bool,
92    ) -> Result<()>
93    where
94        T: SifliToolTrait + RamCommand,
95    {
96        tool.check_cancelled()?;
97        let progress = tool.progress();
98        let re_download_spinner = progress.create_spinner(ProgressOperation::CheckRedownload {
99            address: file.address,
100            size: file.file.metadata()?.len(),
101        });
102
103        let response = tool.command(Command::Verify {
104            address: file.address,
105            len: file.file.metadata()?.len() as u32,
106            crc: file.crc32,
107        })?;
108
109        if response == Response::Ok {
110            re_download_spinner.finish(ProgressStatus::Skipped);
111            return Ok(());
112        }
113
114        re_download_spinner.finish(ProgressStatus::Required);
115        let replacement_info = Self::prepare_debug_sequence_replacement(tool, file)?;
116
117        let download_bar = progress.create_bar(
118            file.file.metadata()?.len(),
119            ProgressOperation::WriteFlash {
120                address: file.address,
121                size: file.file.metadata()?.len(),
122            },
123        );
124
125        let res = tool.command(Command::WriteAndErase {
126            address: file.address,
127            len: file.file.metadata()?.len() as u32,
128        })?;
129        if res != Response::RxWait {
130            return Err(Error::protocol(format!(
131                "write flash failed to start at 0x{:08X}",
132                file.address
133            )));
134        }
135
136        let mut buffer = vec![0u8; 128 * 1024];
137        let mut reader = BufReader::new(&file.file);
138        reader.seek(SeekFrom::Start(0))?;
139        let mut transfer_offset = 0u64;
140
141        loop {
142            tool.check_cancelled()?;
143            let bytes_read = reader.read(&mut buffer)?;
144            if bytes_read == 0 {
145                break;
146            }
147            tool.check_cancelled()?;
148            let data = &mut buffer[..bytes_read];
149            if let Some(info) = &replacement_info {
150                info.apply_to_chunk(transfer_offset, data);
151            }
152            let res = tool.send_data(data)?;
153            if res == Response::RxWait {
154                download_bar.inc(bytes_read as u64);
155                transfer_offset += bytes_read as u64;
156                continue;
157            } else if res != Response::Ok {
158                return Err(Error::protocol(format!(
159                    "write flash failed during transfer at 0x{:08X}",
160                    file.address
161                )));
162            }
163        }
164
165        download_bar.finish(ProgressStatus::Success);
166
167        // verify
168        if verify {
169            tool.check_cancelled()?;
170            Self::verify(
171                tool,
172                file.address,
173                file.file.metadata()?.len() as u32,
174                file.crc32,
175            )?;
176        }
177
178        Ok(())
179    }
180
181    /// 写入单个文件到Flash(全擦除模式)
182    pub fn write_file_full_erase<T>(
183        tool: &mut T,
184        file: &WriteFlashFile,
185        verify: bool,
186        packet_size: usize,
187    ) -> Result<()>
188    where
189        T: SifliToolTrait + RamCommand,
190    {
191        tool.check_cancelled()?;
192        let replacement_info = Self::prepare_debug_sequence_replacement(tool, file)?;
193        let progress = tool.progress();
194        let download_bar = progress.create_bar(
195            file.file.metadata()?.len(),
196            ProgressOperation::WriteFlash {
197                address: file.address,
198                size: file.file.metadata()?.len(),
199            },
200        );
201
202        let mut buffer = vec![0u8; packet_size];
203        let mut reader = BufReader::new(&file.file);
204        reader.seek(SeekFrom::Start(0))?;
205
206        let mut address = file.address;
207        let mut transfer_offset = 0u64;
208        loop {
209            tool.check_cancelled()?;
210            let bytes_read = reader.read(&mut buffer)?;
211            if bytes_read == 0 {
212                break;
213            }
214            tool.check_cancelled()?;
215            {
216                let mut io = for_tool(tool);
217                io.write_all(
218                    Command::Write {
219                        address,
220                        len: bytes_read as u32,
221                    }
222                    .to_string()
223                    .as_bytes(),
224                )?;
225                io.flush()?;
226            }
227            let data = &mut buffer[..bytes_read];
228            if let Some(info) = &replacement_info {
229                info.apply_to_chunk(transfer_offset, data);
230            }
231            let res = tool.send_data(data)?;
232            if res != Response::Ok {
233                return Err(Error::protocol(format!(
234                    "write flash failed during transfer at 0x{:08X}",
235                    address
236                )));
237            }
238            address += bytes_read as u32;
239            transfer_offset += bytes_read as u64;
240            download_bar.inc(bytes_read as u64);
241        }
242
243        download_bar.finish(ProgressStatus::Success);
244
245        // verify
246        if verify {
247            tool.check_cancelled()?;
248            Self::verify(
249                tool,
250                file.address,
251                file.file.metadata()?.len() as u32,
252                file.crc32,
253            )?;
254        }
255
256        Ok(())
257    }
258}