--versions: Return any number of PD versions

Based on EC host command.

Signed-off-by: Daniel Schaefer <dhs@frame.work>

Author: JohnAZoidberg

framework_lib/src/ccgx/mod.rs

@@ -241,9 +241,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

@@ -32,7 +32,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;
@@ -477,8 +477,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

@@ -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 {
@@ -818,12 +823,31 @@ 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.
 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::InvalidCommand)) = info {
+        let info = EcRequestReadPdVersionV0 {}.send_command(ec)?;
+
+        return Ok(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 {