sftool_lib/common/
write_flash.rs1use 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
8pub struct FlashWriter;
10
11impl FlashWriter {
12 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 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 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 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 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 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 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}