chromium_ec: Allow flashing single EC FW

Only RO, only RW or both.

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

framework_lib/src/chromium_ec/mod.rs

@@ -59,6 +59,13 @@ const FLASH_RW_BASE: u32 = 0x40000;
 const FLASH_RW_SIZE: u32 = 0x39000;
 const FLASH_PROGRAM_OFFSET: u32 = 0x1000;
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum EcFlashType {
+    Full,
+    Ro,
+    Rw,
+}
+
 #[derive(PartialEq)]
 pub enum MecFlashNotify {
     AccessSpi = 0x00,
@@ -237,11 +244,11 @@ impl CrosEc {
         };
 
         Some((
-            std::str::from_utf8(&v.version_string_rw)
+            std::str::from_utf8(&v.version_string_ro)
                 .ok()?
                 .trim_end_matches(char::from(0))
                 .to_string(),
-            std::str::from_utf8(&v.version_string_ro)
+            std::str::from_utf8(&v.version_string_rw)
                 .ok()?
                 .trim_end_matches(char::from(0))
                 .to_string(),
@@ -368,49 +375,77 @@ impl CrosEc {
     }
 
     /// Overwrite RO and RW regions of EC flash
-    /// | Start | End   | Size  | Region    |
-    /// | 00000 | 3BFFF | 3C000 | RO Region |
-    /// | 3C000 | 3FFFF | 04000 | Preserved |
-    /// | 40000 | 3C000 | 39000 | RO Region |
-    /// | 79000 | 79FFF | 07000 | Preserved |
-    pub fn reflash(&self, data: &[u8]) -> EcResult<()> {
-        let mut _flash_bin: Vec<u8> = Vec::with_capacity(EC_FLASH_SIZE);
+    /// MEC/Legacy EC
+    /// | Start | End   | Size  | Region      |
+    /// | 00000 | 3BFFF | 3C000 | RO Region   |
+    /// | 3C000 | 3FFFF | 04000 | Preserved   |
+    /// | 40000 | 3C000 | 39000 | RO Region   |
+    /// | 79000 | 79FFF | 01000 | Preserved   |
+    /// | 80000 | 80FFF | 01000 | Flash Flags |
+    ///
+    /// NPC/Zephyr
+    /// | Start | End   | Size  | Region      |
+    /// | 00000 | 3BFFF | 3C000 | RO Region   |
+    /// | 3C000 | 3FFFF | 04000 | Preserved   |
+    /// | 40000 | 3C000 | 39000 | RO Region   |
+    /// | 79000 | 79FFF | 01000 | Flash Flags |
+    pub fn reflash(&self, data: &[u8], ft: EcFlashType) -> EcResult<()> {
+        if ft == EcFlashType::Full || ft == EcFlashType::Ro {
+            println!("For safety reasons flashing RO firmware is disabled.");
+            return Ok(());
+        }
+
         println!("Unlocking flash");
         self.flash_notify(MecFlashNotify::AccessSpi)?;
         self.flash_notify(MecFlashNotify::FirmwareStart)?;
 
-        //println!("Erasing RO region");
-        //self.erase_ec_flash(FLASH_BASE + FLASH_RO_BASE, FLASH_RO_SIZE)?;
-        println!("Erasing RW region");
-        self.erase_ec_flash(FLASH_BASE + FLASH_RW_BASE, FLASH_RW_SIZE)?;
+        // TODO: Check if erase was successful
+        // 1. First erase 0x10000 bytes
+        // 2. Read back two rows and make sure it's all 0xFF
+        // 3. Write each row (128B) individually
 
-        let ro_data = &data[FLASH_RO_BASE as usize..(FLASH_RO_BASE + FLASH_RO_SIZE) as usize];
-        //println!("Writing RO region");
-        //self.write_ec_flash(FLASH_BASE + FLASH_RO_BASE, ro_data);
+        if ft == EcFlashType::Full || ft == EcFlashType::Rw {
+            let rw_data = &data[FLASH_RW_BASE as usize..(FLASH_RW_BASE + FLASH_RW_SIZE) as usize];
 
-        let rw_data = &data[FLASH_RW_BASE as usize..(FLASH_RW_BASE + FLASH_RW_SIZE) as usize];
-        println!("Writing RW region");
-        self.write_ec_flash(FLASH_BASE + FLASH_RW_BASE, rw_data)?;
+            println!("Erasing RW region");
+            self.erase_ec_flash(FLASH_BASE + FLASH_RW_BASE, FLASH_RW_SIZE)?;
 
-        println!("Verifying");
-        let flash_ro_data = self.read_ec_flash(FLASH_BASE + FLASH_RO_BASE, FLASH_RO_SIZE)?;
-        if ro_data == flash_ro_data {
-            println!("RO verify success");
-        } else {
-            println!("RO verify fail");
+            println!("Writing RW region");
+            self.write_ec_flash(FLASH_BASE + FLASH_RW_BASE, rw_data)?;
+
+            println!("Verifying RW region");
+            let flash_rw_data = self.read_ec_flash(FLASH_BASE + FLASH_RW_BASE, FLASH_RW_SIZE)?;
+            if rw_data == flash_rw_data {
+                println!("RW verify success");
+            } else {
+                println!("RW verify fail");
+            }
         }
-        let flash_rw_data = self.read_ec_flash(FLASH_BASE + FLASH_RW_BASE, FLASH_RW_SIZE)?;
-        if rw_data == flash_rw_data {
-            println!("RW verify success");
-        } else {
-            println!("RW verify fail");
+
+        if ft == EcFlashType::Full || ft == EcFlashType::Ro {
+            let ro_data = &data[FLASH_RO_BASE as usize..(FLASH_RO_BASE + FLASH_RO_SIZE) as usize];
+
+            println!("Erasing RO region");
+            self.erase_ec_flash(FLASH_BASE + FLASH_RO_BASE, FLASH_RO_SIZE)?;
+
+            println!("Writing RO region");
+            self.write_ec_flash(FLASH_BASE + FLASH_RO_BASE, ro_data)?;
+
+            println!("Verifying RO region");
+            let flash_ro_data = self.read_ec_flash(FLASH_BASE + FLASH_RO_BASE, FLASH_RO_SIZE)?;
+            if ro_data == flash_ro_data {
+                println!("RO verify success");
+            } else {
+                println!("RO verify fail");
+            }
         }
 
         println!("Locking flash");
         self.flash_notify(MecFlashNotify::AccessSpiDone)?;
         self.flash_notify(MecFlashNotify::FirmwareDone)?;
 
         println!("Flashing EC done. You can reboot the EC now");
+        // TODO: Should we force a reboot if currently running one was reflashed?
 
         Ok(())
     }

framework_lib/src/commandline/clap_std.rs

@@ -85,6 +85,14 @@ struct ClapCli {
     #[arg(long)]
     flash_ec: Option<std::path::PathBuf>,
 
+    /// Flash EC with new RO firmware from file
+    #[arg(long)]
+    flash_ro_ec: Option<std::path::PathBuf>,
+
+    /// Flash EC with new RW firmware from file
+    #[arg(long)]
+    flash_rw_ec: Option<std::path::PathBuf>,
+
     /// Show status of intrusion switch
     #[arg(long)]
     intrusion: bool,
@@ -170,6 +178,12 @@ pub fn parse(args: &[String]) -> Cli {
         flash_ec: args
             .flash_ec
             .map(|x| x.into_os_string().into_string().unwrap()),
+        flash_ro_ec: args
+            .flash_ro_ec
+            .map(|x| x.into_os_string().into_string().unwrap()),
+        flash_rw_ec: args
+            .flash_rw_ec
+            .map(|x| x.into_os_string().into_string().unwrap()),
         intrusion: args.intrusion,
         inputmodules: args.inputmodules,
         input_deck_mode: args.input_deck_mode,

framework_lib/src/commandline/mod.rs

@@ -33,7 +33,7 @@ use crate::chromium_ec;
 use crate::chromium_ec::commands::DeckStateMode;
 use crate::chromium_ec::commands::FpLedBrightnessLevel;
 use crate::chromium_ec::commands::RebootEcCmd;
-use crate::chromium_ec::print_err;
+use crate::chromium_ec::{print_err, EcFlashType};
 use crate::chromium_ec::{EcError, EcResult};
 #[cfg(feature = "linux")]
 use crate::csme;
@@ -131,6 +131,8 @@ pub struct Cli {
     pub ho2_capsule: Option<String>,
     pub dump_ec_flash: Option<String>,
     pub flash_ec: Option<String>,
+    pub flash_ro_ec: Option<String>,
+    pub flash_rw_ec: Option<String>,
     pub driver: Option<CrosEcDriverType>,
     pub test: bool,
     pub intrusion: bool,
@@ -396,25 +398,31 @@ fn print_esrt() {
     }
 }
 
-#[cfg(feature = "uefi")]
-fn flash_ec(ec: &CrosEc, ec_bin_path: &str) {
+fn flash_ec(ec: &CrosEc, ec_bin_path: &str, flash_type: EcFlashType) {
     #[cfg(feature = "uefi")]
     let data = crate::uefi::fs::shell_read_file(ec_bin_path);
     #[cfg(not(feature = "uefi"))]
-    let data = match fs::read(ec_bin_path) {
-        Ok(data) => Some(data),
-        // TODO: Perhaps a more user-friendly error
-        Err(e) => {
-            println!("Error {:?}", e);
-            None
-        }
+    let data: Option<Vec<u8>> = {
+        let _data = match fs::read(ec_bin_path) {
+            Ok(data) => Some(data),
+            // TODO: Perhaps a more user-friendly error
+            Err(e) => {
+                println!("Error {:?}", e);
+                None
+            }
+        };
+
+        // EC communication from OS is not stable enough yet,
+        // it can't be trusted to reliably flash the EC without risk of damage.
+        println!("Sorry, flashing EC from the OS is not supported yet.");
+        None
     };
 
     if let Some(data) = data {
         println!("File");
         println!("  Size:       {:>20} B", data.len());
         println!("  Size:       {:>20} KB", data.len() / 1024);
-        if let Err(err) = ec.reflash(&data) {
+        if let Err(err) = ec.reflash(&data, flash_type) {
             println!("Error: {:?}", err);
         } else {
             println!("Success!");
@@ -708,15 +716,14 @@ pub fn run_with_args(args: &Cli, _allupdate: bool) -> i32 {
         }
     } else if let Some(dump_path) = &args.dump_ec_flash {
         println!("Dumping to {}", dump_path);
+        // TODO: Should have progress indicator
         dump_ec_flash(&ec, dump_path);
-    } else if let Some(_ec_bin_path) = &args.flash_ec {
-        // EC communication from OS is not stable enough yet,
-        // it can't be trusted to reliably flash the EC without risk of damage.
-        #[cfg(not(feature = "uefi"))]
-        println!("Sorry, flashing EC from the OS is not supported yet.");
-
-        #[cfg(feature = "uefi")]
-        flash_ec(&ec, _ec_bin_path);
+    } else if let Some(ec_bin_path) = &args.flash_ec {
+        flash_ec(&ec, ec_bin_path, EcFlashType::Full);
+    } else if let Some(ec_bin_path) = &args.flash_ro_ec {
+        flash_ec(&ec, ec_bin_path, EcFlashType::Ro);
+    } else if let Some(ec_bin_path) = &args.flash_rw_ec {
+        flash_ec(&ec, ec_bin_path, EcFlashType::Rw);
     } else if let Some(hash_file) = &args.hash {
         println!("Hashing file: {}", hash_file);
         #[cfg(feature = "uefi")]
@@ -764,6 +771,9 @@ Options:
       --pd-bin <PD_BIN>      Parse versions from PD firmware binary file
       --ec-bin <EC_BIN>      Parse versions from EC firmware binary file
       --capsule <CAPSULE>    Parse UEFI Capsule information from binary file
+      --flash-ec <FLASH_EC>            Flash EC with new firmware from file
+      --flash-ro-ec <FLASH_EC>         Flash EC with new firmware from file
+      --flash-rw-ec <FLASH_EC>         Flash EC with new firmware from file
       --intrusion            Show status of intrusion switch
       --inputmodules         Show status of the input modules (Framework 16 only)
       --charge-limit [<VAL>] Get or set battery charge limit (Percentage number as arg, e.g. '100')
@@ -772,7 +782,6 @@ Options:
       --console <CONSOLE>    Get EC console, choose whether recent or to follow the output [possible values: recent, follow]
       --reboot-ec            Control EC RO/RW jump [possible values: reboot, jump-ro, jump-rw, cancel-jump, disable-jump]
       --dump-ec-flash <DUMP_EC_FLASH>  Dump EC flash contents
-      --flash-ec <FLASH_EC>            Flash EC with new firmware from file
   -t, --test                 Run self-test to check if interaction with EC is possible
   -h, --help                 Print help information
     "#

framework_lib/src/commandline/uefi.rs

@@ -69,6 +69,8 @@ pub fn parse(args: &[String]) -> Cli {
         ec_bin: None,
         dump_ec_flash: None,
         flash_ec: None,
+        flash_ro_ec: None,
+        flash_rw_ec: None,
         capsule: None,
         dump: None,
         ho2_capsule: None,
@@ -306,7 +308,23 @@ pub fn parse(args: &[String]) -> Cli {
             cli.flash_ec = if args.len() > i + 1 {
                 Some(args[i + 1].clone())
             } else {
-                println!("--flash_ec requires extra argument to denote input file");
+                println!("--flash-ec requires extra argument to denote input file");
+                None
+            };
+            found_an_option = true;
+        } else if arg == "--flash-ro-ec" {
+            cli.flash_ro_ec = if args.len() > i + 1 {
+                Some(args[i + 1].clone())
+            } else {
+                println!("--flash-ro-ec requires extra argument to denote input file");
+                None
+            };
+            found_an_option = true;
+        } else if arg == "--flash-rw-ec" {
+            cli.flash_rw_ec = if args.len() > i + 1 {
+                Some(args[i + 1].clone())
+            } else {
+                println!("--flash-rw-ec requires extra argument to denote input file");
                 None
             };
             found_an_option = true;