chromium_ec: Add host command to read board ID

framework_lib/src/chromium_ec/command.rs

@@ -12,7 +12,7 @@ use crate::util;
 use super::{CrosEc, CrosEcDriver, EcError, EcResult};
 
 #[non_exhaustive]
-#[derive(Debug, FromPrimitive)]
+#[derive(Debug, Clone, Copy, FromPrimitive)]
 #[repr(u16)]
 pub enum EcCommands {
     GetVersion = 0x02,
@@ -107,6 +107,8 @@ pub enum EcCommands {
     GetGpuPcie = 0x3E1E,
     /// Set gpu bay serial and program structure
     ProgramGpuEeprom = 0x3E1F,
+    /// Read board ID of specific ADC channel
+    ReadBoardId = 0x3E26,
 }
 
 pub trait EcRequest<R> {

framework_lib/src/chromium_ec/commands.rs

@@ -1501,3 +1501,39 @@ impl EcRequest<EcResponseSetGpuSerial> for EcRequestSetGpuSerial {
         EcCommands::ProgramGpuEeprom
     }
 }
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum BoardIdType {
+    /// Mainboard - any system
+    Mainboard = 0,
+    /// Power button board - Framework 12
+    PowerButtonBoard = 1,
+    /// Touchpad - Framework 12, 13, 16
+    Touchpad = 2,
+    /// Audio Board - Framework 12, 13
+    AudioBoard = 3,
+    /// dGPU board - Framework 16
+    DGpu0 = 4,
+    /// dGPU board - Framework 16
+    DGpu1 = 5,
+}
+
+#[repr(C, packed)]
+pub struct EcRequestReadBoardId {
+    /// See BoardIdType
+    pub board_id_type: u8,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct EcResponseReadBoardId {
+    /// Board ID (-1 invalid, 15 not present)
+    pub board_id: i8,
+}
+
+impl EcRequest<EcResponseReadBoardId> for EcRequestReadBoardId {
+    fn command_id() -> EcCommands {
+        EcCommands::ReadBoardId
+    }
+}

framework_lib/src/chromium_ec/mod.rs

@@ -298,8 +298,8 @@ impl CrosEc {
         }
     }
 
-    pub fn cmd_version_supported(&self, cmd: u16, version: u8) -> EcResult<bool> {
-        let res = EcRequestGetCmdVersionsV1 { cmd: cmd.into() }.send_command(self);
+    pub fn cmd_version_supported(&self, cmd: EcCommands, version: u8) -> EcResult<bool> {
+        let res = EcRequestGetCmdVersionsV1 { cmd: cmd as u32 }.send_command(self);
         let mask = if let Ok(res) = res {
             res.version_mask
         } else {
@@ -1616,6 +1616,8 @@ impl CrosEc {
     }
 
     fn read_board_id(&self, channel: u8) -> EcResult<Option<u8>> {
+        // TODO: This change the parmeter to BoardIdType and map that to ADC if needed
+        // if ec.cmd_version_supported(command::EcCommands::ReadBoardId, 0) == Ok(true) {
         self.read_board_id_raw(channel, BOARD_VERSION)
     }
     fn read_board_id_npc_db(&self, channel: u8) -> EcResult<Option<u8>> {
@@ -1670,6 +1672,22 @@ impl CrosEc {
         }
         Ok(())
     }
+
+    pub fn read_board_id_hc(&self, board_id_type: BoardIdType) -> EcResult<Option<u8>> {
+        let res = EcRequestReadBoardId {
+            board_id_type: board_id_type as u8,
+        }
+        .send_command(self)?;
+        match res.board_id {
+            -1 => Err(EcError::DeviceError(format!(
+                "Failed to read Board ID {:?}",
+                board_id_type
+            ))),
+            15 => Ok(None),
+            0..=14 => Ok(Some(res.board_id as u8)),
+            n => Err(EcError::DeviceError(format!("Invalid Board ID {}", n))),
+        }
+    }
 }
 
 #[cfg_attr(not(feature = "uefi"), derive(clap::ValueEnum))]

framework_lib/src/commandline/mod.rs

@@ -35,6 +35,8 @@ use crate::ccgx::device::{FwMode, PdController, PdPort};
 use crate::ccgx::hid::{check_ccg_fw_version, find_devices, DP_CARD_PID, HDMI_CARD_PID};
 use crate::ccgx::{self, MainPdVersions, PdVersions, SiliconId::*};
 use crate::chromium_ec;
+use crate::chromium_ec::command;
+use crate::chromium_ec::commands::BoardIdType;
 use crate::chromium_ec::commands::DeckStateMode;
 use crate::chromium_ec::commands::FpLedBrightnessLevel;
 use crate::chromium_ec::commands::RebootEcCmd;
@@ -1034,6 +1036,21 @@ pub fn run_with_args(args: &Cli, _allupdate: bool) -> i32 {
                 // Only Framework 16 has this GPIO
                 if ec.get_gpio("sleep_l").is_ok() {
                     ec.print_fw16_inputdeck_status()
+                } else if ec.cmd_version_supported(command::EcCommands::ReadBoardId, 0) == Ok(true) {
+                    println!("Input Deck (Board ID - Unable to determine platform)");
+                    let boardid = ec.read_board_id_hc(BoardIdType::Mainboard);
+                    println!("  Mainboard:   {:?}", boardid);
+                    let boardid = ec.read_board_id_hc(BoardIdType::PowerButtonBoard);
+                    println!("  PowerButton: {:?}", boardid);
+                    let boardid = ec.read_board_id_hc(BoardIdType::Touchpad);
+                    println!("  Touchpad:    {:?}", boardid);
+                    let boardid = ec.read_board_id_hc(BoardIdType::AudioBoard);
+                    println!("  AudioBoard:  {:?}", boardid);
+                    let boardid = ec.read_board_id_hc(BoardIdType::DGpu0);
+                    println!("  dGPU0:       {:?}", boardid);
+                    let boardid = ec.read_board_id_hc(BoardIdType::DGpu1);
+                    println!("  dGPU1:       {:?}", boardid);
+                    Ok(())
                 } else {
                     println!("  Unable to tell");
                     Ok(())
@@ -1547,6 +1564,20 @@ fn hash(data: &[u8]) {
 }
 
 fn selftest(ec: &CrosEc) -> Option<()> {
+    let boardid = ec.read_board_id_hc(BoardIdType::Mainboard);
+    println!("Mainboard   Board ID: {:?}", boardid);
+    let boardid = ec.read_board_id_hc(BoardIdType::PowerButtonBoard);
+    println!("PowerButton Board ID: {:?}", boardid);
+    let boardid = ec.read_board_id_hc(BoardIdType::Touchpad);
+    println!("Touchpad    Board ID: {:?}", boardid);
+    let boardid = ec.read_board_id_hc(BoardIdType::AudioBoard);
+    println!("AudioBoard  Board ID: {:?}", boardid);
+    let boardid = ec.read_board_id_hc(BoardIdType::DGpu0);
+    println!("dGPU0       Board ID: {:?}", boardid);
+    let boardid = ec.read_board_id_hc(BoardIdType::DGpu1);
+    println!("dGPU1       Board ID: {:?}", boardid);
+
+    return Some(());
     if let Some(platform) = smbios::get_platform() {
         println!("  SMBIOS Platform:     {:?}", platform);
     } else {