1use crate::error::{Error, Result};
4#[cfg(feature = "cli")]
5use crate::tar::TarFile;
6use byteorder::{ByteOrder, LittleEndian};
7
8pub const NUM_INIT_ENTRIES: usize = 212;
10pub const BYTES_PER_INIT_ENTRY: usize = 4;
12
13#[derive(Debug, Clone)]
15pub struct ChipDesc {
16 pub vendor: String,
18 pub name: String,
20 pub size: u32,
22 pub init: [[u8; BYTES_PER_INIT_ENTRY]; NUM_INIT_ENTRIES],
24 pub init_len: usize,
26}
27
28impl Default for ChipDesc {
29 fn default() -> Self {
30 Self {
31 vendor: String::new(),
32 name: String::new(),
33 size: 0,
34 init: [[0u8; BYTES_PER_INIT_ENTRY]; NUM_INIT_ENTRIES],
35 init_len: 0,
36 }
37 }
38}
39
40const DEDIPROG_CFG_PRO_SIZE: usize = 176;
42const DEDIPROG_CFG_PRO_SIZE_SFDP: usize = 256;
43const DEDIPROG_CFG_PRO_SIZE_SRST: usize = 144;
44
45const DEDIPROG_CFG_MAGIC: u32 = 0x67666344; const DEDIPROG_SFDP_MAGIC: u32 = 0x50444653; const DEDIPROG_SRST_MAGIC: u32 = 0x54535253; const DEDIPROG_PROT_MAGIC: u32 = 0x544f5250; const INIT_SEQUENCE_REGISTER_OFFSET_0: u16 = 0x2300;
51const INIT_SEQUENCE_REGISTER_OFFSET_1: u16 = 0x1100;
52
53pub fn parse_dcfg(data: &[u8]) -> Result<ChipDesc> {
55 if data.len() < DEDIPROG_CFG_PRO_SIZE {
56 return Err(Error::InvalidConfig("File too small".to_string()));
57 }
58
59 let mut chip = ChipDesc::default();
60 let mut init_len = 0;
61
62 let magic = LittleEndian::read_u32(&data[0..4]);
64 if magic != DEDIPROG_CFG_MAGIC {
65 return Err(Error::InvalidConfig(format!(
66 "Invalid magic number: 0x{:x}",
67 magic
68 )));
69 }
70
71 let ver_min = LittleEndian::read_u16(&data[4..6]);
72 let ver_maj = LittleEndian::read_u16(&data[6..8]);
73 if ver_maj != 1 || ver_min != 1 {
74 return Err(Error::InvalidConfig(format!(
75 "Invalid version: {}.{}",
76 ver_maj, ver_min
77 )));
78 }
79
80 let init_offset = LittleEndian::read_u32(&data[8..12]) as usize;
81 chip.size = LittleEndian::read_u32(&data[12..16]);
82 let vendor_offset = LittleEndian::read_u32(&data[16..20]) as usize;
83 let chip_name_offset = LittleEndian::read_u32(&data[20..24]) as usize;
84
85 if vendor_offset < data.len() {
87 let end = data[vendor_offset..]
88 .iter()
89 .position(|&b| b == 0)
90 .unwrap_or(data.len() - vendor_offset);
91 chip.vendor =
92 String::from_utf8_lossy(&data[vendor_offset..vendor_offset + end]).to_string();
93 }
94
95 if chip_name_offset < data.len() {
96 let end = data[chip_name_offset..]
97 .iter()
98 .position(|&b| b == 0)
99 .unwrap_or(data.len() - chip_name_offset);
100 chip.name =
101 String::from_utf8_lossy(&data[chip_name_offset..chip_name_offset + end]).to_string();
102 }
103
104 let mut reg_offset = INIT_SEQUENCE_REGISTER_OFFSET_0;
106 let mut pos = init_offset;
107
108 while pos + 4 <= DEDIPROG_CFG_PRO_SIZE && init_len < NUM_INIT_ENTRIES {
109 let value = LittleEndian::read_u16(&data[pos..pos + 2]);
110 let reg = LittleEndian::read_u16(&data[pos + 2..pos + 4]);
111
112 if value == 0xffff && reg == 0xffff {
113 reg_offset = INIT_SEQUENCE_REGISTER_OFFSET_1;
114 pos += 4;
115 continue;
116 }
117
118 let full_reg = reg + reg_offset;
119
120 let be_value = value.to_be_bytes();
122 let be_reg = full_reg.to_be_bytes();
123
124 chip.init[init_len][0] = be_reg[0];
125 chip.init[init_len][1] = be_reg[1];
126 chip.init[init_len][2] = be_value[0];
127 chip.init[init_len][3] = be_value[1];
128 init_len += 1;
129 pos += 4;
130 }
131
132 let mut ptr = DEDIPROG_CFG_PRO_SIZE;
134 let mut length = data.len() - DEDIPROG_CFG_PRO_SIZE;
135
136 while length >= 4 {
137 let magic = LittleEndian::read_u32(&data[ptr..ptr + 4]);
138 ptr += 4;
139 length -= 4;
140
141 match magic {
142 DEDIPROG_SFDP_MAGIC => {
143 let added = parse_sfdp(&data[ptr..], &mut chip, init_len)?;
144 init_len += added;
145 ptr += DEDIPROG_CFG_PRO_SIZE_SFDP;
146 length = length.saturating_sub(DEDIPROG_CFG_PRO_SIZE_SFDP);
147 }
148 DEDIPROG_SRST_MAGIC => {
149 let added = parse_srst(&data[ptr..], &mut chip, init_len)?;
150 init_len += added;
151 ptr += DEDIPROG_CFG_PRO_SIZE_SRST;
152 length = length.saturating_sub(DEDIPROG_CFG_PRO_SIZE_SRST);
153 }
154 _ => {
155 break;
157 }
158 }
159 }
160
161 chip.init_len = init_len;
162 Ok(chip)
163}
164
165fn parse_sfdp(data: &[u8], chip: &mut ChipDesc, entries: usize) -> Result<usize> {
166 if data.len() < DEDIPROG_CFG_PRO_SIZE_SFDP {
167 return Err(Error::InvalidConfig("SFDP data too small".to_string()));
168 }
169
170 let mut len = 0;
171 let mut init_len = entries;
172
173 chip.init[init_len][0] = 0x23;
175 chip.init[init_len][1] = 0xc9;
176 chip.init[init_len][2] = 0x00;
177 chip.init[init_len][3] = 0x01;
178 init_len += 1;
179 len += 1;
180
181 for i in (0..DEDIPROG_CFG_PRO_SIZE_SFDP).step_by(2) {
182 if init_len >= NUM_INIT_ENTRIES {
183 break;
184 }
185 chip.init[init_len][0] = 0x23;
186 chip.init[init_len][1] = 0xc1;
187 chip.init[init_len][2] = data[i + 1];
188 chip.init[init_len][3] = data[i];
189 init_len += 1;
190 len += 1;
191 }
192
193 Ok(len)
194}
195
196fn parse_srst(data: &[u8], chip: &mut ChipDesc, entries: usize) -> Result<usize> {
197 if data.len() < DEDIPROG_CFG_PRO_SIZE_SRST {
198 return Err(Error::InvalidConfig("SRST data too small".to_string()));
199 }
200
201 let mut len = 0;
202 let mut init_len = entries;
203
204 let magic = LittleEndian::read_u32(&data[0..4]);
206 let start_offset = if magic != DEDIPROG_PROT_MAGIC {
207 for j in 0..3 {
209 if init_len >= NUM_INIT_ENTRIES {
210 break;
211 }
212 chip.init[init_len][0] = 0x23;
213 chip.init[init_len][1] = data[j * 4 + 2];
214 chip.init[init_len][2] = data[j * 4 + 1];
215 chip.init[init_len][3] = data[j * 4];
216 init_len += 1;
217 len += 1;
218 }
219 16 } else {
221 4 };
223
224 if init_len < NUM_INIT_ENTRIES {
226 chip.init[init_len][0] = 0x23;
227 chip.init[init_len][1] = 0xc4;
228 chip.init[init_len][2] = 0x00;
229 chip.init[init_len][3] = 0x01;
230 init_len += 1;
231 len += 1;
232 }
233
234 for i in (start_offset..DEDIPROG_CFG_PRO_SIZE_SRST).step_by(2) {
235 if init_len >= NUM_INIT_ENTRIES {
236 break;
237 }
238 chip.init[init_len][0] = 0x23;
239 chip.init[init_len][1] = 0xc5;
240 chip.init[init_len][2] = data[i + 1];
241 chip.init[init_len][3] = data[i];
242 init_len += 1;
243 len += 1;
244 }
245
246 Ok(len)
247}
248
249pub struct ChipDatabase {
251 pub chips: Vec<ChipDesc>,
252 pub version: String,
253}
254
255include!(concat!(env!("OUT_DIR"), "/chip_data.rs"));
257
258impl ChipDatabase {
259 #[cfg(feature = "cli")]
261 pub fn load() -> Result<Self> {
262 let config_path = get_em100_file("configs.tar.xz")?;
263 let configs = TarFile::load_compressed(&config_path)?;
264
265 let version_data = configs.find("configs/VERSION")?;
266 let version = String::from_utf8_lossy(&version_data).trim().to_string();
267 let mut chips = Vec::new();
268
269 for entry in configs.entries() {
270 if entry.ends_with(".cfg") {
271 if let Ok(data) = configs.find(entry) {
272 if let Ok(chip) = parse_dcfg(&data) {
273 chips.push(chip);
274 }
275 }
276 }
277 }
278 chips.sort_by(|a, b| a.vendor.cmp(&b.vendor).then(a.name.cmp(&b.name)));
279
280 Ok(Self { chips, version })
281 }
282
283 pub fn load_embedded() -> Self {
285 let mut chips = Vec::new();
286 for (_name, data) in EMBEDDED_CHIP_CONFIGS {
287 if let Ok(chip) = parse_dcfg(data) {
288 chips.push(chip);
289 }
290 }
291 chips.sort_by(|a, b| a.vendor.cmp(&b.vendor).then(a.name.cmp(&b.name)));
292
293 Self {
294 chips,
295 version: "embedded".to_string(),
296 }
297 }
298
299 pub fn from_data(chip_configs: Vec<(&str, &[u8])>, version: String) -> Result<Self> {
301 let mut chips = Vec::new();
302 for (_name, data) in chip_configs {
303 if let Ok(chip) = parse_dcfg(data) {
304 chips.push(chip);
305 }
306 }
307 Ok(Self { chips, version })
308 }
309
310 pub fn find_chip(&self, name: &str) -> Result<ChipDesc> {
312 self.chips
313 .iter()
314 .find(|c| c.name.eq_ignore_ascii_case(name))
315 .cloned()
316 .ok_or_else(|| Error::InvalidChip(format!("Could not find chip '{}'", name)))
317 }
318
319 pub fn list_chips(&self) -> Vec<ChipDesc> {
321 self.chips.clone()
322 }
323}
324
325#[cfg(feature = "cli")]
327pub fn get_em100_file(name: &str) -> Result<std::path::PathBuf> {
328 let base = if let Ok(home) = std::env::var("EM100_HOME") {
329 std::path::PathBuf::from(home)
330 } else if let Some(home) = dirs::home_dir() {
331 home.join(".em100")
332 } else {
333 return Err(Error::FileNotFound(
334 "Could not determine home directory".to_string(),
335 ));
336 };
337
338 if !base.exists() {
340 std::fs::create_dir_all(&base)?;
341 }
342
343 Ok(base.join(name))
344}