Merge pull request #85 from FrameworkComputer/ccg8

Author: JohnAZoidberg

README.md

@@ -25,13 +25,16 @@ see the [Support Matrices](support-matrices.md).
     - [x] ESRT table (UEFI and Linux only) (`--esrt`)
     - [x] SMBIOS
   - [x] Get firmware version from binary file
-    - [x] EC (`--ec-bin`)
+    - [x] MCHP EC on Intel Platform (`--ec-bin`)
+    - [ ] NPC EC on Framework 16
     - [x] CCG5 PD (11th Gen TigerLake) (`--pd-bin`)
     - [x] CCG6 PD (12th Gen AlderLake) (`--pd-bin`)
+    - [x] CCG8 PD (Framework 16) (`--pd-bin`)
     - [x] HO2 BIOS Capsule (`--ho2-capsule`)
       - [x] BIOS Version
       - [x] EC Version
       - [x] CCG5/CCG6 PD Version
+    - [x] UEFI Capsule (`--capsule`)
   - [x] Parse metadata from capsule binary
     - [x] Determine type (GUID) of capsule binary
     - [x] Extract bitmap image from winux capsule to file

framework_lib/src/ccgx/binary.rs

@@ -96,9 +96,14 @@ fn read_metadata(
     file_buffer: &[u8],
     flash_row_size: u32,
     metadata_offset: u32,
+    ccgx: SiliconId,
 ) -> Option<(u32, u32)> {
     let buffer = read_256_bytes(file_buffer, metadata_offset, flash_row_size)?;
-    parse_metadata_cyacd(&buffer)
+    match ccgx {
+        SiliconId::Ccg5 | SiliconId::Ccg6 => parse_metadata_cyacd(&buffer),
+        SiliconId::Ccg8 => parse_metadata_cyacd2(&buffer)
+            .map(|(fw_row_start, fw_size)| (fw_row_start / flash_row_size, fw_size)),
+    }
 }
 
 /// Read 256 bytes starting from a particular row
@@ -121,8 +126,10 @@ fn read_version(
     file_buffer: &[u8],
     flash_row_size: u32,
     metadata_offset: u32,
+    ccgx: SiliconId,
 ) -> Option<PdFirmware> {
-    let (fw_row_start, fw_size) = read_metadata(file_buffer, flash_row_size, metadata_offset)?;
+    let (fw_row_start, fw_size) =
+        read_metadata(file_buffer, flash_row_size, metadata_offset, ccgx)?;
     let data = read_256_bytes(file_buffer, fw_row_start, flash_row_size)?;
     let data = &data[FW_VERSION_OFFSET..];
 
@@ -152,9 +159,10 @@ pub fn read_versions(file_buffer: &[u8], ccgx: SiliconId) -> Option<PdFirmwareFi
     let (flash_row_size, f1_metadata_row, fw2_metadata_row) = match ccgx {
         SiliconId::Ccg5 => (0x100, FW1_METADATA_ROW, FW2_METADATA_ROW_CCG5),
         SiliconId::Ccg6 => (0x80, FW1_METADATA_ROW, FW2_METADATA_ROW_CCG6),
+        SiliconId::Ccg8 => (0x100, FW1_METADATA_ROW_CCG8, FW2_METADATA_ROW_CCG8),
     };
-    let backup_fw = read_version(file_buffer, flash_row_size, f1_metadata_row)?;
-    let main_fw = read_version(file_buffer, flash_row_size, fw2_metadata_row)?;
+    let backup_fw = read_version(file_buffer, flash_row_size, f1_metadata_row, ccgx)?;
+    let main_fw = read_version(file_buffer, flash_row_size, fw2_metadata_row, ccgx)?;
 
     Some(PdFirmwareFile { backup_fw, main_fw })
 }
@@ -190,8 +198,10 @@ mod tests {
         let data = fs::read(pd_bin_path).unwrap();
         let ccg5_ver = read_versions(&data, SiliconId::Ccg5);
         let ccg6_ver = read_versions(&data, SiliconId::Ccg6);
+        let ccg8_ver = read_versions(&data, SiliconId::Ccg8);
         assert!(ccg5_ver.is_some());
         assert!(ccg6_ver.is_none());
+        assert!(ccg8_ver.is_none());
 
         assert_eq!(
             ccg5_ver,
@@ -248,8 +258,10 @@ mod tests {
         let data = fs::read(pd_bin_path).unwrap();
         let ccg5_ver = read_versions(&data, SiliconId::Ccg5);
         let ccg6_ver = read_versions(&data, SiliconId::Ccg6);
+        let ccg8_ver = read_versions(&data, SiliconId::Ccg8);
         assert!(ccg5_ver.is_none());
         assert!(ccg6_ver.is_some());
+        assert!(ccg8_ver.is_none());
 
         assert_eq!(
             ccg6_ver,
@@ -297,4 +309,64 @@ mod tests {
             })
         );
     }
+
+    #[test]
+    fn can_parse_ccg8_binary() {
+        let mut pd_bin_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        pd_bin_path.push("test_bins/fl16-pd-0.0.03.bin");
+
+        let data = fs::read(pd_bin_path).unwrap();
+        let ccg5_ver = read_versions(&data, SiliconId::Ccg5);
+        let ccg6_ver = read_versions(&data, SiliconId::Ccg6);
+        let ccg8_ver = read_versions(&data, SiliconId::Ccg8);
+        assert!(ccg5_ver.is_none());
+        assert!(ccg6_ver.is_none());
+        assert!(ccg8_ver.is_some());
+
+        assert_eq!(
+            ccg8_ver,
+            Some({
+                PdFirmwareFile {
+                    backup_fw: PdFirmware {
+                        silicon_id: 0x11C5,
+                        silicon_family: 0x3580,
+                        base_version: BaseVersion {
+                            major: 3,
+                            minor: 6,
+                            patch: 0,
+                            build_number: 160,
+                        },
+                        app_version: AppVersion {
+                            application: Application::Notebook,
+                            major: 0,
+                            minor: 0,
+                            circuit: 3,
+                        },
+                        start_row: 290,
+                        size: 111536,
+                        row_size: 0x100,
+                    },
+                    main_fw: PdFirmware {
+                        silicon_id: 0x11C5,
+                        silicon_family: 0x3580,
+                        base_version: BaseVersion {
+                            major: 3,
+                            minor: 6,
+                            patch: 0,
+                            build_number: 160,
+                        },
+                        app_version: AppVersion {
+                            application: Application::Notebook,
+                            major: 0,
+                            minor: 0,
+                            circuit: 3,
+                        },
+                        start_row: 29,
+                        size: 42312,
+                        row_size: 0x100,
+                    },
+                }
+            })
+        );
+    }
 }

framework_lib/src/ccgx/mod.rs

@@ -15,10 +15,14 @@ pub mod device;
 pub mod hid;
 
 const FW1_METADATA_ROW: u32 = 0x1FE;
+const FW1_METADATA_ROW_CCG8: u32 = 0x3FE;
 const FW2_METADATA_ROW_CCG5: u32 = 0x1FF;
 const FW2_METADATA_ROW_CCG6: u32 = 0x1FD;
+const FW2_METADATA_ROW_CCG8: u32 = 0x3FF;
 const METADATA_OFFSET: usize = 0xC0; // TODO: Is this 0x40 on ADL?
+const CCG8_METADATA_OFFSET: usize = 0x80;
 const METADATA_MAGIC: u16 = u16::from_le_bytes([b'Y', b'C']); // CY (Cypress)
+const CCG8_METADATA_MAGIC: u16 = u16::from_le_bytes([b'F', b'I']); // IF (Infineon)
 
 #[repr(packed)]
 #[derive(Debug, Copy, Clone)]
@@ -53,11 +57,47 @@ struct CyAcdMetadata {
     _boot_seq: u32,
 }
 
+// TODO: Would be nice to check the checksums
+#[repr(packed)]
+#[derive(Debug, Copy, Clone)]
+struct CyAcd2Metadata {
+    /// Offset 00: App Firmware Start
+    fw_start: u32,
+    /// Offset 04: App Firmware Size
+    fw_size: u32,
+    /// Offset 08: Boot wait time
+    _boot_app_id: u16,
+    /// Offset 0A: Last Flash row of Bootloader or previous firmware
+    /// Is (fw_start/FLASH_ROW_SIZE) - 1
+    _boot_last_row: u16,
+    /// Offset 0C: Verify Start Address
+    _config_fw_start: u32,
+    /// Offset 10: Verify Size
+    _config_fw_size: u32,
+    /// Offset 14: Boot sequence number field. Boot-loader will load the valid
+    /// FW copy that has the higher sequence number associated with it
+    /// Not relevant when checking the update binary file
+    _boot_seq: u32,
+    /// Offset 18: Reserved
+    _reserved_1: [u32; 15],
+    /// Offset 54: Version of the metadata structure
+    metadata_version: u16,
+    /// Offset 56: Metadata Valid field. Valid if contains ASCII "IF"
+    metadata_valid: u16,
+    /// Offset 58: App Fw CRC32 checksum
+    _fw_crc32: u32,
+    /// Offset 5C: Reserved
+    _reserved_2: [u32; 8],
+    /// Offset 7C: Metadata CRC32 checksum
+    _md_crc32: u32,
+}
+
 #[non_exhaustive]
 #[derive(Debug, PartialEq, FromPrimitive, Clone, Copy)]
 pub enum SiliconId {
     Ccg5 = 0x2100,
     Ccg6 = 0x3000,
+    Ccg8 = 0x3580,
 }
 
 #[derive(Debug, PartialEq)]
@@ -192,3 +232,21 @@ fn parse_metadata_cyacd(buffer: &[u8]) -> Option<(u32, u32)> {
         None
     }
 }
+
+fn parse_metadata_cyacd2(buffer: &[u8]) -> Option<(u32, u32)> {
+    let buffer = &buffer[CCG8_METADATA_OFFSET..];
+    let metadata_len = std::mem::size_of::<CyAcd2Metadata>();
+    let metadata: CyAcd2Metadata =
+        unsafe { std::ptr::read(buffer[0..metadata_len].as_ptr() as *const _) };
+    //println!("Metadata: {:?}", metadata);
+    if metadata.metadata_valid == CCG8_METADATA_MAGIC {
+        if metadata.metadata_version == 1 {
+            Some((metadata.fw_start, metadata.fw_size))
+        } else {
+            println!("Unknown CCG8 metadata version");
+            None
+        }
+    } else {
+        None
+    }
+}

framework_lib/src/commandline/mod.rs

@@ -601,6 +601,16 @@ fn smbios_info() {
 fn analyze_ccgx_pd_fw(data: &[u8]) {
     let mut succeeded = false;
 
+    if let Some(versions) = ccgx::binary::read_versions(data, Ccg8) {
+        succeeded = true;
+        println!("Detected CCG8 firmware");
+        println!("FW 1");
+        ccgx::binary::print_fw(&versions.backup_fw);
+
+        println!("FW 2");
+        ccgx::binary::print_fw(&versions.main_fw);
+    }
+
     if let Some(versions) = ccgx::binary::read_versions(data, Ccg5) {
         succeeded = true;
         println!("Detected CCG5 firmware");