--versions: Return any number of PD versions

Based on EC host command.

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

Author: JohnAZoidberg

framework_lib/src/ccgx/mod.rs

@@ -3,6 +3,7 @@
 use alloc::format;
 use alloc::string::String;
 use alloc::string::ToString;
+use alloc::vec::Vec;
 #[cfg(feature = "uefi")]
 use core::prelude::rust_2021::derive;
 use num_derive::FromPrimitive;
@@ -241,9 +242,10 @@ pub struct PdVersions {
 
 /// Same as PdVersions but only the main FW
 #[derive(Debug)]
-pub struct MainPdVersions {
-    pub controller01: ControllerVersion,
-    pub controller23: ControllerVersion,
+pub enum MainPdVersions {
+    RightLeft((ControllerVersion, ControllerVersion)),
+    Single(ControllerVersion),
+    Many(Vec<ControllerVersion>),
 }
 
 pub fn get_pd_controller_versions(ec: &CrosEc) -> EcResult<PdVersions> {

framework_lib/src/commandline/mod.rs

@@ -33,7 +33,7 @@ use crate::capsule_content::{
 use crate::ccgx::device::{FwMode, PdController, PdPort};
 #[cfg(feature = "hidapi")]
 use crate::ccgx::hid::{check_ccg_fw_version, find_devices, DP_CARD_PID, HDMI_CARD_PID};
-use crate::ccgx::{self, SiliconId::*};
+use crate::ccgx::{self, MainPdVersions, SiliconId::*};
 use crate::chromium_ec;
 use crate::chromium_ec::commands::DeckStateMode;
 use crate::chromium_ec::commands::FpLedBrightnessLevel;
@@ -478,8 +478,25 @@ fn print_versions(ec: &CrosEc) {
         }
     } else if let Ok(pd_versions) = power::read_pd_version(ec) {
         // As fallback try to get it from the EC. But not all EC versions have this command
-        println!("  Right (01):     {}", pd_versions.controller01.app);
-        println!("  Left  (23):     {}", pd_versions.controller23.app);
+        match pd_versions {
+            MainPdVersions::RightLeft((controller01, controller23)) => {
+                if let Some(Platform::IntelGen11) = smbios::get_platform() {
+                    println!("  Right (01):     {}", controller01.base);
+                    println!("  Left  (23):     {}", controller23.base);
+                } else {
+                    println!("  Right (01):     {}", controller01.app);
+                    println!("  Left  (23):     {}", controller23.app);
+                }
+            }
+            MainPdVersions::Single(version) => {
+                println!("  Version:        {}", version.app);
+            }
+            MainPdVersions::Many(versions) => {
+                for (i, version) in versions.into_iter().enumerate() {
+                    println!("  PD {}:          {}", i, version.app);
+                }
+            }
+        }
     } else {
         println!("  Unknown")
     }

framework_lib/src/power.rs

@@ -1,7 +1,7 @@
 //! Get information about system power (battery, AC, PD ports)
 
 use alloc::format;
-use alloc::string::String;
+use alloc::string::{String, ToString};
 use alloc::vec;
 use alloc::vec::Vec;
 use core::convert::TryInto;
@@ -798,6 +798,11 @@ pub fn is_charging(ec: &CrosEc) -> EcResult<(bool, bool)> {
     Ok((port0 || port1, port2 || port3))
 }
 
+fn parse_pd_ver_slice(data: &[u8]) -> ControllerVersion {
+    parse_pd_ver(&[
+        data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
+    ])
+}
 fn parse_pd_ver(data: &[u8; 8]) -> ControllerVersion {
     ControllerVersion {
         base: BaseVersion {
@@ -815,15 +820,37 @@ fn parse_pd_ver(data: &[u8; 8]) -> ControllerVersion {
     }
 }
 
-// NOTE: Only works on ADL at the moment!
-// TODO: Not on TGL, need to check if RPL and later have it.
+// NOTE: TGL (hx20) does not have this host command
 pub fn read_pd_version(ec: &CrosEc) -> EcResult<MainPdVersions> {
-    let info = EcRequestReadPdVersion {}.send_command(ec)?;
+    let info = EcRequestReadPdVersionV1 {}.send_command_vec(ec);
 
-    Ok(MainPdVersions {
-        controller01: parse_pd_ver(&info.controller01),
-        controller23: parse_pd_ver(&info.controller23),
-    })
+    // If v1 not available, fall back
+    if let Err(EcError::Response(EcResponseStatus::InvalidVersion)) = info {
+        let info = EcRequestReadPdVersionV0 {}.send_command(ec)?;
+
+        return Ok(if info.controller23 == [0, 0, 0, 0, 0, 0, 0, 0] {
+            MainPdVersions::Single(parse_pd_ver(&info.controller01))
+        } else {
+            MainPdVersions::RightLeft((
+                parse_pd_ver(&info.controller01),
+                parse_pd_ver(&info.controller23),
+            ))
+        });
+    }
+    // If any other error, exit
+    let info = info?;
+
+    let mut versions = vec![];
+    let pd_count = info[0] as usize;
+    for i in 0..pd_count {
+        // TODO: Is there a safer way to check the range?
+        if info.len() < 1 + 8 * (i + 1) {
+            return Err(EcError::DeviceError("Not enough data returned".to_string()));
+        }
+        versions.push(parse_pd_ver_slice(&info[1 + 8 * i..1 + 8 * (i + 1)]));
+    }
+
+    Ok(MainPdVersions::Many(versions))
 }
 
 pub fn standalone_mode(ec: &CrosEc) -> bool {