omacom sync: G15 (M3 Pro/Max) backend, PB growth, stamps, raw GPU stats

.github/workflows/host-tests.yml

@@ -57,6 +57,8 @@ jobs:
             command -v "$p" >/dev/null || need="$need $p"
           done
           command -v "ld.lld-$CLANG_VERSION" >/dev/null || need="$need lld-$CLANG_VERSION"
+          # Device-tree tests read the built trees with fdtget.
+          command -v fdtget >/dev/null || need="$need device-tree-compiler"
           dpkg -s "libclang-rt-$CLANG_VERSION-dev" >/dev/null 2>&1 || need="$need libclang-rt-$CLANG_VERSION-dev"
           if [ -n "$need" ]; then
             sudo apt-get update -q

Documentation/ABI/testing/debugfs-driver-asahi-stats

@@ -0,0 +1,47 @@
+What:		/sys/kernel/debug/dri/<N>/asahi_stats
+Date:		October 2026
+Contact:	Ryan Murray <ryan@aurorasilicon.org>
+Description:
+		Read-only, root-only dump of the raw AGX firmware statistics
+		that the drm/asahi driver receives on its statistics channel.
+		The driver stores the latest message of each kind and prints
+		it unchanged. It does not compute utilization or any other
+		derived value.
+
+		The file is created in the debugfs directory of the DRM
+		device when the device is registered. It also appears under
+		the other names of that directory (dri/128 and the platform
+		device name, for example dri/406400000.gpu).
+
+		The format is ASCII text, one line per record:
+
+		- line 1: asahi_stats_v1, the format tag. A reader must check it.
+		- line 2: device=<platform device name>
+		- line 3: now_ns=<monotonic time of the read, nanoseconds>
+		- line 4: messages count=<number of statistics messages received>
+		- then one line per message kind, in this order: power,
+		  power_on, power_off, utilization, avg_power, temperature,
+		  power_state, fw_busy, pstate, temp_sensor.
+
+		A kind line is "<kind> count=<n>" followed, when n is not 0,
+		by " captured_ns=<ns of the last message>" and the fields of
+		that kind as key=value pairs:
+
+		- power: power
+		- power_on: off_time
+		- power_off: on_time
+		- utilization: timestamp, util1, util2, util3, util4
+		- avg_power: active_cs, unk2, unk3, unk4, avg_power
+		- temperature: raw_value, scale, tmin, tmax
+		- power_state: timestamp, last_busy_ts, active, poweroff,
+		  unk1, pstate, unk2, unk3
+		- fw_busy: timestamp, busy
+		- pstate: ps_min, unk1, ps_max, unk2
+		- temp_sensor: sensor_id, raw_value, scale, tmin, tmax
+
+		All counts are cumulative since the driver bound the device. A rate needs two reads.
+		The values are the raw firmware values. Their units and the
+		meaning of the util*, unk* fields are not established. A kind
+		that was never received prints count=0 and no payload. Keys
+		may be added in later versions of the format tag; readers
+		must ignore keys they do not know.

arch/arm64/boot/dts/apple/t6030.dtsi

@@ -836,6 +836,8 @@
 			#clock-cells = <1>;
 		};
 
+		/* The display handoff gate installs PMP unless explicitly static. */
+		#ifdef APPLE_USE_PMP
 		pmp_dart: iommu@350300000 {
 			compatible = "apple,t6030-dart", "apple,t8110-dart";
 			reg = <0x3 0x50300000 0x0 0x4000>;
@@ -985,6 +987,8 @@
 			power-domains = <&ps_pmp>, <&ps_pms_sram>;
 		};
 
+		#endif /* APPLE_USE_PMP */
+
 		aic: interrupt-controller@351000000 {
 			compatible = "apple,t6030-aic3", "apple,t8122-aic3";
 			#interrupt-cells = <3>;

arch/arm64/boot/dts/apple/t6031-dcp.dtsi

@@ -9,9 +9,10 @@
  * interrupts and DART windows are those of the J516C ADT.
  *
  * Every node stays status = "disabled". The display gate enables the DCP,
- * its mailbox, the two DARTs and the display subsystem only when
- * apple_t6031_display.enable=1 is on the kernel command line and the boot
- * loader has set apple,t6031-handoff = <1>. Compatibles are t6031-specific,
+ * its mailbox, the two DARTs and the display subsystem only when the boot
+ * loader has set apple,t6031-handoff = <1> and the native display is
+ * requested: by default on the J516C, with apple_t6031_display.enable=1 on
+ * the other boards, never with apple_t6031_display.enable=0. Compatibles are t6031-specific,
  * so a kernel that does not know them leaves the nodes unbound.
  *
  * Only the T6031 board files include this file: t6034.dtsi includes

drivers/gpu/drm/apple/apple_drv.c

@@ -64,28 +64,44 @@ struct apple_drm_private {
 };
 
 /* Component readiness is later than platform probe/bind. */
-static DEFINE_MUTEX(apple_t6030_display_lock);
+static DEFINE_MUTEX(apple_g15_display_lock);
 static struct device *apple_t6030_display;
+static struct device *apple_t6031_display;
 
-static int apple_t6030_display_publish(struct device *dev)
+/* The publication slot of a G15 SoC's internal display subsystem, or NULL. */
+static struct device **apple_g15_display_slot(struct device *dev)
 {
-	if (!of_device_is_compatible(dev->of_node, "apple,t6030-display-subsystem"))
+	if (of_device_is_compatible(dev->of_node, "apple,t6030-display-subsystem"))
+		return &apple_t6030_display;
+	if (of_device_is_compatible(dev->of_node, "apple,t6031-display-subsystem"))
+		return &apple_t6031_display;
+	return NULL;
+}
+
+static int apple_g15_display_publish(struct device *dev)
+{
+	struct device **slot = apple_g15_display_slot(dev);
+
+	if (!slot)
 		return 0;
-	guard(mutex)(&apple_t6030_display_lock);
-	if (apple_t6030_display)
-		return apple_t6030_display == dev ? 0 : -EBUSY;
-	apple_t6030_display = get_device(dev);
+	guard(mutex)(&apple_g15_display_lock);
+	if (*slot)
+		return *slot == dev ? 0 : -EBUSY;
+	*slot = get_device(dev);
 	return 0;
 }
 
-static void apple_t6030_display_withdraw(struct device *dev)
+static void apple_g15_display_withdraw(struct device *dev)
 {
+	struct device **slot = apple_g15_display_slot(dev);
 	struct device *old = NULL;
 
-	scoped_guard(mutex, &apple_t6030_display_lock) {
-		if (apple_t6030_display == dev) {
-			old = apple_t6030_display;
-			apple_t6030_display = NULL;
+	if (!slot)
+		return;
+	scoped_guard(mutex, &apple_g15_display_lock) {
+		if (*slot == dev) {
+			old = *slot;
+			*slot = NULL;
 		}
 	}
 	put_device(old);
@@ -96,22 +112,35 @@ static void apple_t6030_display_withdraw(struct device *dev)
  * publish separately. This lock protects only publication and a device link;
  * no display calls or firmware RPC run while it is held.
  */
-int apple_drm_t6030_link_device(struct device *consumer)
+static int apple_g15_link_device(struct device *consumer, const char *machine,
+				 const char *gpu, struct device **display)
 {
 	struct device_link *link;
 
-	if (!of_machine_is_compatible("apple,t6030") || !consumer->of_node ||
-	    !of_device_is_compatible(consumer->of_node, "apple,agx-t6030"))
+	if (!of_machine_is_compatible(machine) || !consumer->of_node ||
+	    !of_device_is_compatible(consumer->of_node, gpu))
 		return -ENODEV;
-	guard(mutex)(&apple_t6030_display_lock);
-	if (!apple_t6030_display)
+	guard(mutex)(&apple_g15_display_lock);
+	if (!*display)
 		return -EPROBE_DEFER;
-	link = device_link_add(consumer, apple_t6030_display,
-			       DL_FLAG_AUTOREMOVE_CONSUMER);
+	link = device_link_add(consumer, *display, DL_FLAG_AUTOREMOVE_CONSUMER);
 	return link ? 0 : -EINVAL;
 }
+
+int apple_drm_t6030_link_device(struct device *consumer)
+{
+	return apple_g15_link_device(consumer, "apple,t6030", "apple,agx-t6030",
+				     &apple_t6030_display);
+}
 EXPORT_SYMBOL_GPL(apple_drm_t6030_link_device);
 
+int apple_drm_t6031_link_device(struct device *consumer)
+{
+	return apple_g15_link_device(consumer, "apple,t6031", "apple,agx-t6031",
+				     &apple_t6031_display);
+}
+EXPORT_SYMBOL_GPL(apple_drm_t6031_link_device);
+
 DEFINE_DRM_GEM_DMA_FOPS(apple_fops);
 
 #define DART_PAGE_SIZE 16384
@@ -1316,7 +1345,7 @@ static int apple_drm_init(struct device *dev)
 	drm_client_setup_with_fourcc(&apple->drm, DRM_FORMAT_XRGB8888);
 
 	/* A subsequent successful platform probe retries deferred GPU probes. */
-	ret = apple_t6030_display_publish(dev);
+	ret = apple_g15_display_publish(dev);
 	if (ret) {
 		drm_dev_unregister(&apple->drm);
 		goto err_unbind;
@@ -1338,7 +1367,7 @@ static void apple_drm_uninit(struct device *dev)
 {
 	struct apple_drm_private *apple = dev_get_drvdata(dev);
 
-	apple_t6030_display_withdraw(dev);
+	apple_g15_display_withdraw(dev);
 
 	/* An aborted takeover leaves its DCPs running until the reboot. */
 	if (apple->aborted)

drivers/gpu/drm/asahi/asahi_core.rs

@@ -36,6 +36,7 @@ mod queue;
 mod regs;
 mod slotalloc;
 mod stats;
+mod stats_raw;
 mod sysfs_exports;
 mod timestamp;
 mod usage;
@@ -170,7 +171,7 @@ module! {
         },
         g15_pb_max_blocks: u32 {
             default: 3072,
-            description: "G15: parameter-buffer growth maximum given to the firmware, blocks of 128 KiB (1024..4095 in effect; the blocks above it, up to 4095, answer partial renders; the 512 MiB heap is allocated either way)",
+            description: "G15: PB growth maximum given to the firmware, 128 KiB blocks (64..4095)",
         },
         g15_early_tiling: u32 {
             default: 0,

drivers/gpu/drm/asahi/channel.rs

@@ -24,13 +24,17 @@ use crate::{
     event,
     gpu,
     mem,
-    module_parameters, //
+    module_parameters,
+    stats_raw::RawStatsSnapshot, //
 };
 use core::sync::atomic::Ordering;
 use kernel::{
     c_str,
     prelude::*,
-    sync::Arc,
+    sync::{
+        Arc,
+        SpinLock, //
+    },
     time::{
         delay::fsleep,
         Delta,
@@ -588,6 +592,9 @@ pub(crate) struct StatsChannel {
     dev: AsahiDevRef,
     ch: RxChannel<ChannelState, RawStatsMsg::ver>,
     snap: Arc<crate::stats::StatsSnapshot>,
+    /// Last raw sample of every statistics kind, shared with the export
+    /// through `crate::stats_raw`.
+    raw: Arc<SpinLock<RawStatsSnapshot>>,
     /// Rate of firmware stats-message timestamps (Hz). All stats timestamps
     /// run on the chip base clock (`HwConfig::base_clock_hz`, 24 MHz on every
     /// supported SoC), not nanoseconds.
@@ -604,12 +611,14 @@ impl StatsChannel::ver {
         dev: AsahiDevice,
         alloc: &mut gpu::KernelAllocators,
         snap: Arc<crate::stats::StatsSnapshot>,
+        raw: Arc<SpinLock<RawStatsSnapshot>>,
         ts_hz: u64,
     ) -> Result<StatsChannel::ver> {
         Ok(StatsChannel::ver {
             dev: dev.clone(),
             ch: RxChannel::<ChannelState, RawStatsMsg::ver>::new(alloc, 0x100)?,
             snap,
+            raw,
             ts_hz,
             last_util_ts: 0,
         })
@@ -631,6 +640,7 @@ impl StatsChannel::ver {
                     // accessing the enum view is valid.
                     let msg = unsafe { msg.msg };
                     cls_dev_dbg!(StatsCh, self.dev, "Stats: {:?}\n", msg);
+                    self.record_raw(&msg);
                     if module_parameters::stats_export.value() != 0 {
                         // Retain the latest values for /sys/class/drm/card*/
                         // device/agx_stats. Read-only with respect to
@@ -713,4 +723,80 @@ impl StatsChannel::ver {
             }
         }
     }
+
+    /// Record one statistics message in the raw per-device snapshot.
+    ///
+    /// The firmware words are stored exactly as they arrived: no unit is
+    /// assumed, nothing is scaled and no metric is derived from them.
+    fn record_raw(&mut self, msg: &StatsMsg::ver) {
+        let stamp = crate::stats_raw::monotonic_ns();
+        let mut snap = self.raw.lock();
+        snap.note_message();
+        match msg {
+            StatsMsg::ver::Power { power, .. } => snap.set_power(power.0, stamp),
+            StatsMsg::ver::PowerOn { off_time, .. } => snap.set_power_on(off_time.0, stamp),
+            StatsMsg::ver::PowerOff { on_time, .. } => snap.set_power_off(on_time.0, stamp),
+            StatsMsg::ver::Utilization {
+                timestamp,
+                util1,
+                util2,
+                util3,
+                util4,
+            } => snap.set_utilization(timestamp.0, [*util1, *util2, *util3, *util4], stamp),
+            StatsMsg::ver::AvgPower {
+                active_cs,
+                unk2,
+                unk3,
+                unk4,
+                avg_power,
+            } => snap.set_avg_power(active_cs.0, [*unk2, *unk3, *unk4], *avg_power, stamp),
+            StatsMsg::ver::Temperature {
+                raw_value,
+                scale,
+                tmin,
+                tmax,
+                ..
+            } => snap.set_temperature(*raw_value, *scale, *tmin, *tmax, stamp),
+            StatsMsg::ver::PowerState {
+                timestamp,
+                last_busy_ts,
+                active,
+                poweroff,
+                unk1,
+                pstate,
+                unk2,
+                unk3,
+            } => snap.set_power_state(
+                timestamp.0,
+                last_busy_ts.0,
+                *active,
+                *poweroff,
+                *unk1,
+                *pstate,
+                *unk2,
+                *unk3,
+                stamp,
+            ),
+            StatsMsg::ver::FwBusy { timestamp, busy } => {
+                snap.set_fw_busy(timestamp.0, *busy, stamp)
+            }
+            StatsMsg::ver::PState {
+                ps_min,
+                unk1,
+                ps_max,
+                unk2,
+                ..
+            } => snap.set_pstate(*ps_min, *unk1, *ps_max, *unk2, stamp),
+            StatsMsg::ver::TempSensor {
+                sensor_id,
+                raw_value,
+                scale,
+                tmin,
+                tmax,
+                ..
+            } => snap.set_temp_sensor(*sensor_id, *raw_value, *scale, *tmin, *tmax, stamp),
+            // The remaining tags are not decoded by the driver.
+            _ => {}
+        }
+    }
 }

drivers/gpu/drm/asahi/driver.rs

@@ -302,12 +302,20 @@ impl platform::Driver for AsahiPlatformDriver {
         gpu.init()?;
 
         let stats = gpu.stats_snapshot();
+        let debug_stats = gpu.raw_stats_snapshot();
         let data = try_pin_init!(AsahiDrmRegistrationData { gpu, resources });
 
         // SAFETY: `reg` is stored in `AsahiPlatformDriverData` and dropped when the driver is
         // unbound; it is never forgotten.
         let reg = unsafe { drm::Registration::new(pdev.as_ref(), drm, data, 0)? };
 
+        // The DRM core created this card's debugfs directory when the device was registered;
+        // publish the raw firmware statistics in it. drm_dev_unregister() removes the file, and
+        // waits for its readers, before the registration data that owns the snapshot is dropped.
+        if let Some(snapshot) = debug_stats.as_ref() {
+            crate::stats_raw::register(reg.device(), snapshot);
+        }
+
         // Register the sysfs file on the platform device. Must happen after
         // the DRM device is registered so the device is fully bound.
         let raw_dev = pdev.as_ref().as_raw();