Skip to main content

em100/
chips.rs

1//! Chip configuration parsing
2
3use crate::error::{Error, Result};
4#[cfg(feature = "cli")]
5use crate::tar::TarFile;
6use byteorder::{ByteOrder, LittleEndian};
7
8/// Number of init entries in chip configuration
9pub const NUM_INIT_ENTRIES: usize = 212;
10/// Bytes per init entry
11pub const BYTES_PER_INIT_ENTRY: usize = 4;
12
13/// Chip description
14#[derive(Debug, Clone)]
15pub struct ChipDesc {
16    /// Vendor name
17    pub vendor: String,
18    /// Chip name
19    pub name: String,
20    /// Chip size in bytes
21    pub size: u32,
22    /// Initialization sequence
23    pub init: [[u8; BYTES_PER_INIT_ENTRY]; NUM_INIT_ENTRIES],
24    /// Number of valid init entries
25    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
40// Dediprog configuration file constants
41const 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; // 'Dcfg'
46const DEDIPROG_SFDP_MAGIC: u32 = 0x50444653; // 'SFDP'
47const DEDIPROG_SRST_MAGIC: u32 = 0x54535253; // 'SRST'
48const DEDIPROG_PROT_MAGIC: u32 = 0x544f5250; // 'PROT'
49
50const INIT_SEQUENCE_REGISTER_OFFSET_0: u16 = 0x2300;
51const INIT_SEQUENCE_REGISTER_OFFSET_1: u16 = 0x1100;
52
53/// Parse a Dediprog chip configuration file
54pub 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    // Parse header
63    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    // Read vendor and chip name as null-terminated strings
86    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    // Parse init sequence
105    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        // Convert to big endian for output
121        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    // Handle extra data (SFDP, SRST)
133    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                // Unknown section, skip
156                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    // Enable SFDP
174    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    // Check for PROT magic at start
205    let magic = LittleEndian::read_u32(&data[0..4]);
206    let start_offset = if magic != DEDIPROG_PROT_MAGIC {
207        // 3 SRST entries before PROT
208        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 // Skip SFDP data and PROT magic
220    } else {
221        4 // Start after PROT magic
222    };
223
224    // Enable PROT
225    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
249/// Chip configuration database.
250pub struct ChipDatabase {
251    pub chips: Vec<ChipDesc>,
252    pub version: String,
253}
254
255// Include the generated chip data at module level.
256include!(concat!(env!("OUT_DIR"), "/chip_data.rs"));
257
258impl ChipDatabase {
259    /// Load chip database from configs.tar.xz.
260    #[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    /// Load chip database from embedded data.
284    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    /// Create chip database from in-memory data.
300    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    /// Find a chip by name.
311    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    /// List all available chips.
320    pub fn list_chips(&self) -> Vec<ChipDesc> {
321        self.chips.clone()
322    }
323}
324
325/// Get path to EM100 configuration file
326#[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    // Create directory if it doesn't exist
339    if !base.exists() {
340        std::fs::create_dir_all(&base)?;
341    }
342
343    Ok(base.join(name))
344}