drm/asahi: starlight-debug

- pass exact size via "debug,*-size" properties
- skip comparison if the starlight data is missing
- use `dev_{err,info}!` for logging
- explicitly log matching data

Signed-off-by: Sasha Finkelstein <fnkl.kernel@gmail.com>
Co-developed-by: Janne Grunau <j@jannau.net>
Signed-off-by: Janne Grunau <j@jannau.net>

Author: WhatAmISupposedToPutHere

drivers/gpu/drm/asahi/gpu.rs

@@ -13,6 +13,7 @@
 
 use core::any::Any;
 use core::ops::Range;
+use core::slice;
 use core::sync::atomic::{
     AtomicBool,
     AtomicU64,
@@ -23,6 +24,8 @@ use kernel::{
     c_str,
     drm::gem::shmem,
     error::code::*,
+    io::mem::{Mem, MemFlags},
+    iosys_map::IoSysMapRef,
     macros::versions,
     new_mutex,
     prelude::*,
@@ -773,6 +776,28 @@ impl GpuManager::ver {
         Ok(x)
     }
 
+    fn load_hwdata_blob(dev: &AsahiDevice, name: &CStr, size_name: &CStr) -> Result<KVVec<u8>> {
+        let of_node = dev.as_ref().of_node().ok_or(EINVAL)?;
+        let size: usize = dev
+            .as_ref()
+            .fwnode()
+            .ok_or(ENOENT)?
+            .property_read::<u32>(size_name)
+            .or(0)
+            .try_into()?;
+        let res = of_node.reserved_mem_region_to_resource_byname(name)?;
+        // SAFETY: No dma here, just loading init data.
+        let mem = unsafe { Mem::try_new(res, MemFlags::WB)? };
+        if size > mem.size() {
+            return Err(ENOENT);
+        }
+        // SAFETY: trusting the bootloader to fill it out correctly
+        let blob_sl = unsafe { slice::from_raw_parts(mem.ptr(), size) };
+        let mut blob = KVVec::new();
+        blob.extend_from_slice(blob_sl, GFP_KERNEL)?;
+        Ok(blob)
+    }
+
     /// Fetch and validate the GPU dynamic configuration from the device tree and hardware.
     ///
     /// Force disable inlining to avoid blowing up the stack.
@@ -880,6 +905,25 @@ impl GpuManager::ver {
                 firmware_version: fwnode
                     .property_read_array_vec(c_str!("apple,firmware-version"), 3)?
                     .or(kernel::kvec![0; 3]?),
+
+                hw_data_a: Self::load_hwdata_blob(
+                    dev,
+                    c_str!("hw-cal-a"),
+                    c_str!("debug,hw-cal-a-size"),
+                )
+                .unwrap_or(KVVec::new()),
+                hw_data_b: Self::load_hwdata_blob(
+                    dev,
+                    c_str!("hw-cal-b"),
+                    c_str!("debug,hw-cal-b-size"),
+                )
+                .unwrap_or(KVVec::new()),
+                hw_globals: Self::load_hwdata_blob(
+                    dev,
+                    c_str!("globals"),
+                    c_str!("debug,globals-size"),
+                )
+                .unwrap_or(KVVec::new()),
             },
             GFP_KERNEL,
         )?)

drivers/gpu/drm/asahi/hw/mod.rs

@@ -303,6 +303,10 @@ pub(crate) struct DynConfig {
     /// Firmware version.
     #[allow(dead_code)]
     pub(crate) firmware_version: KVec<u32>,
+
+    pub(crate) hw_data_a: KVVec<u8>,
+    pub(crate) hw_data_b: KVVec<u8>,
+    pub(crate) hw_globals: KVVec<u8>,
 }
 
 /// Specific GPU ID configuration fetched from SGX MMIO registers.

drivers/gpu/drm/asahi/initdata.rs

@@ -483,6 +483,35 @@ impl<'a> InitDataBuilder::ver<'a> {
                         raw.unk_hws2[i] = if *j == 0xffff { 0 } else { j / 2 };
                     }
 
+                    if !dyncfg.hw_data_b.is_empty() {
+                        unsafe {
+                            let mut matches: bool = true;
+                            let sla = core::slice::from_raw_parts(
+                                raw as *const raw::HwDataA::ver as *const u8,
+                                core::mem::size_of::<raw::HwDataA::ver>(),
+                            );
+                            if sla.len() != dyncfg.hw_data_a.len() {
+                                matches = false;
+                                dev_err!(
+                                    self.dev.as_ref(),
+                                    "!!! Hwdata A size mismatch: {} {}",
+                                    sla.len(),
+                                    dyncfg.hw_data_a.len(),
+                                );
+                            }
+                            for i in 0..core::cmp::min(sla.len(), dyncfg.hw_data_a.len()) {
+                                if sla[i] != dyncfg.hw_data_a[i] {
+                                    matches = false;
+                                    dev_err!(self.dev.as_ref(), "!!! Hwdata A first mismatch: {i}");
+                                    break;
+                                }
+                            }
+                            if matches {
+                                dev_info!(self.dev.as_ref(), "!!! Hwdata A match");
+                            }
+                        }
+                    }
+
                     Ok(())
                 })
             })
@@ -633,6 +662,35 @@ impl<'a> InitDataBuilder::ver<'a> {
                         raw.gpu_rev_id = hw::GpuRevisionID::B0 as u32;
                     }
 
+                    if !dyncfg.hw_data_b.is_empty() {
+                        unsafe {
+                            let mut matches: bool = true;
+                            let sla = core::slice::from_raw_parts(
+                                raw as *const raw::HwDataB::ver as *const u8,
+                                core::mem::size_of::<raw::HwDataB::ver>(),
+                            );
+                            if sla.len() != dyncfg.hw_data_b.len() {
+                                matches = false;
+                                dev_err!(
+                                    self.dev.as_ref(),
+                                    "!!! Hwdata B size mismatch: {} {}",
+                                    sla.len(),
+                                    dyncfg.hw_data_b.len(),
+                                );
+                            }
+                            for i in 0..core::cmp::min(sla.len(), dyncfg.hw_data_b.len()) {
+                                if sla[i] != dyncfg.hw_data_b[i] {
+                                    matches = false;
+                                    dev_err!(self.dev.as_ref(), "!!! Hwdata B first mismatch: {i}");
+                                    break;
+                                }
+                            }
+                            if matches {
+                                dev_info!(self.dev.as_ref(), "!!! Hwdata B match");
+                            }
+                        }
+                    }
+
                     Ok(())
                 })
             })
@@ -757,6 +815,36 @@ impl<'a> InitDataBuilder::ver<'a> {
                         }
                         raw.unk_118e8 = 1;
                     }
+
+                    if !dyncfg.hw_globals.is_empty() {
+                        unsafe {
+                            let mut matches: bool = true;
+                            let sla = core::slice::from_raw_parts(
+                                raw as *const raw::Globals::ver as *const u8,
+                                core::mem::size_of::<raw::Globals::ver>(),
+                            );
+                            if sla.len() != dyncfg.hw_globals.len() {
+                                matches = false;
+                                dev_err!(
+                                    self.dev.as_ref(),
+                                    "!!! Globals size mismatch: {} {}",
+                                    sla.len(),
+                                    dyncfg.hw_globals.len(),
+                                );
+                            }
+                            for i in 0..core::cmp::min(sla.len(), dyncfg.hw_globals.len()) {
+                                if sla[i] != dyncfg.hw_globals[i] {
+                                    matches = false;
+                                    dev_err!(self.dev.as_ref(), "!!! Globals first mismatch: {i}");
+                                    break;
+                                }
+                            }
+                            if matches {
+                                dev_info!(self.dev.as_ref(), "!!! Globals match");
+                            }
+                        }
+                    }
+
                     Ok(())
                 })
             })