Method set_gpu_descriptor

framework_lib/src/chromium_ec/mod.rs:1439–1527

Writes EC GPU descriptor to the GPU EEPROM.

(&self, data: &[u8], dry_run: bool)

    /// Writes EC GPU descriptor to the GPU EEPROM.
    pub fn set_gpu_descriptor(&self, data: &[u8], dry_run: bool) -> EcResult<()> {
        println!(
            "Writing GPU EEPROM {}",
            if dry_run { " (DRY RUN)" } else { "" }
        );
        let mut force_power = false;

        let info = EcRequestExpansionBayStatus {}.send_command(self)?;
        println!("  Enabled:       {}", info.module_enabled());
        println!("  No fault:      {}", !info.module_fault());
        println!("  Door closed:   {}", info.hatch_switch_closed());

        match info.expansion_bay_board() {
            Ok(board) => println!("  Board:         {:?}", board),
            Err(err) => println!("  Board:         {:?}", err),
        }

        if let Ok(ExpansionBayBoard::DualInterposer) = info.expansion_bay_board() {
            // If bay power is on already, we don't need to enable/disable it
            if !self.get_gpio("gpu_3v_5v_en")? {
                println!("Expansion Bay Power is Off");
                if dry_run {
                    println!("Forcing Power to Expansion Bay (skip - dry-run)");
                } else {
                    // Force power to the GPU if we are writing the EEPROM
                    let res = self.set_gpio("gpu_3v_5v_en", true);
                    if let Err(err) = res {
                        error!("Failed to set ALW power to GPU on {:?}", err);
                        return Err(err);
                    }
                    println!("Forcing Power to Expansion Bay");
                    os_specific::sleep(100_000);
                    force_power = true;
                }
            }
        }

        // Need to program the EEPROM 32 bytes at a time.
        let chunk_size = 32;

        let chunks = data.len().div_ceil(chunk_size);
        let mut return_val: EcResult<()> = Ok(());
        for chunk_no in 0..chunks {
            let offset = chunk_no * chunk_size;
            // Current chunk might be smaller if it's the last
            let cur_chunk_size = std::cmp::min(chunk_size, data.len() - chunk_no * chunk_size);

            if chunk_no % 100 == 0 {
                println!();
                print!(
                    "Writing chunk {:>4}/{:>4} ({:>6}/{:>6}): X",
                    chunk_no,
                    chunks,
                    offset,
                    cur_chunk_size * chunks
                );
            } else {
                print!("X");