[RFC] ANDROID: GPU frequency tracing support (002)

A periodic GPU frequency monitoring and tracing program for the
Xe driver. The implementation provides bothperiodic sampling and
event-driven frequency change notifications through the Linux
ftrace infrastructure.

Key features:
- Periodic GPU frequency sampling with configurable intervals
- Immediate frequency change reporting via tracepoints
- Integration with Linux ftrace subsystem under 'power' events
- Per-GT (Graphics Technology) monitoring support
- Dedicated workqueue for non-blocking frequency sampling
- Configurable via CONFIG_DRM_XE_GPUFREQTRACER kernel option
- The monitoring interval can be configured at runtime via the sysfs
  (default 5sec).

The sysfs entry is at:
/sys/module/xe/parameters/gpufreq_monitoring_interval_ms

The tracepoint is exposed at:
/sys/kernel/debug/tracing/events/power/gpu_frequency

Format: {unsigned int state, unsigned int gpu_id}
- state: GPU frequency in KHz
- gpu_id: GPU clock domain identifier

This enables userspace tools and system monitoring applications to track
GPU frequency changes for power management analysis, performance tuning,
and debugging purposes.

Bug: 388282937
Test: CtsGpuProfilingDataTestCases
Change-Id: I7e8025004abd4b3ffdfb4d7214a4b4896be95a64
Signed-off-by: S Sebinraj <[email protected]>

Author: ssebinraj

drivers/gpu/drm/xe/Kconfig

@@ -86,6 +86,28 @@ config DRM_XE_FORCE_PROBE
 
 	  Use "!*" to block the probe of the driver for all known devices.
 
+config DRM_XE_GPUFREQTRACER
+	bool "Enable XE GPU frequency tracing"
+	depends on DRM_XE
+	default n
+	help
+	  Enable GPU frequency tracing support for Intel XE driver.
+	  This adds an ftrace tracepoint that reports GPU frequency changes
+	  at periodic boundaries (default 5 secs, configurable via the
+	  gpufreq_monitoring_interval_ms module parameter) and
+	  on direct frequency change events.
+
+	  The monitoring interval can be configured at runtime via the sysfs module parameter:
+	  /sys/module/xe/parameters/gpufreq_monitoring_interval_ms
+
+	  The tracepoint will be available at:
+	  /sys/kernel/debug/tracing/events/power/gpu_frequency
+
+	  Format: {unsigned int state, unsigned int gpu_id}
+	  Where state is the frequency in KHz and gpu_id is the GPU clock domain.
+
+	  If unsure, say N.
+
 menu "drm/Xe Debugging"
 depends on DRM_XE
 depends on EXPERT

drivers/gpu/drm/xe/Makefile

@@ -138,6 +138,9 @@ xe-$(CONFIG_PCI_IOV) += \
 	xe_pci_sriov.o \
 	xe_sriov_pf.o
 
+# GPU frequency tracer
+xe-$(CONFIG_DRM_XE_GPUFREQTRACER) += xe_gpufreqtracer/xe_gpufreqtracer.o
+
 # include helpers for tests even when XE is built-in
 ifdef CONFIG_DRM_XE_KUNIT_TEST
 xe-y += tests/xe_kunit_helpers.o

drivers/gpu/drm/xe/xe_device.c

@@ -31,6 +31,7 @@
 #include "xe_exec_queue.h"
 #include "xe_force_wake.h"
 #include "xe_ggtt.h"
+#include "xe_gpufreqtracer/xe_gpufreqtracer.h"
 #include "xe_gsc_proxy.h"
 #include "xe_gt.h"
 #include "xe_gt_mcr.h"
@@ -727,6 +728,21 @@ int xe_device_probe(struct xe_device *xe)
 
 	xe_heci_gsc_init(xe);
 
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+	err = xe_gpufreqtracer_init(xe);
+	if (err)
+		goto err_fini_gt;
+
+	/* Start periodic monitoring on all GTs using global module parameter */
+	for_each_gt(gt, xe, id) {
+		err = xe_gpufreqtracer_start_monitoring(gt);
+		if (err) {
+			drm_err(&xe->drm, "xe_gpufreqtracer: failed to start monitoring for GT%u, err=%d\n",
+				gt->info.id, err);
+		}
+	}
+#endif
+
 	err = xe_oa_init(xe);
 	if (err)
 		goto err_fini_gt;
@@ -788,6 +804,10 @@ void xe_device_remove(struct xe_device *xe)
 
 	xe_device_remove_display(xe);
 
+#ifdef CONFIG_DRM_GPUFREQTRACER
+	xe_gpufreqtracer_fini(xe);
+#endif
+
 	xe_display_fini(xe);
 
 	xe_oa_fini(xe);

drivers/gpu/drm/xe/xe_device_types.h

@@ -33,6 +33,7 @@
 #endif
 
 struct xe_ggtt;
+struct xe_gpufreqtracer_data;
 struct xe_pat_ops;
 
 #define XE_BO_INVALID_OFFSET	LONG_MAX
@@ -496,6 +497,11 @@ struct xe_device {
 	/** @oa: oa observation subsystem */
 	struct xe_oa oa;
 
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+	/** @gpufreqtracer_data: GPU frequency tracer data */
+	struct xe_gpufreqtracer_data *gpufreqtracer_data;
+#endif
+
 	/** @needs_flr_on_fini: requests function-reset on fini */
 	bool needs_flr_on_fini;
 

drivers/gpu/drm/xe/xe_gpufreqtracer/xe_gpufreqtracer.c

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright © 2024 Intel Corporation
+ */
+
+#include "xe_gpufreqtracer.h"
+
+#include <linux/workqueue.h>
+#include <linux/timer.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/container_of.h>
+#include <linux/gfp.h>
+
+#include "xe_device.h"
+#include "xe_gt.h"
+#include "xe_gt_types.h"
+#include "xe_guc_pc.h"
+#include "xe_module.h"
+
+#define CREATE_TRACE_POINTS
+#include "xe_gpufreqtracer_trace.h"
+
+/**
+ * struct xe_gpufreqtracer_gt_data - Per-GT frequency monitoring data
+ * @gt: Reference to the GT
+ * @timer: Timer for periodic monitoring
+ * @work: Work item for frequency sampling
+ * @last_frequency: Last reported frequency to avoid duplicate reports
+ * @monitoring_active: Whether monitoring is currently active
+ */
+struct xe_gpufreqtracer_gt_data {
+	struct xe_gt *gt;
+	struct timer_list timer;
+	struct work_struct work;
+	u32 last_frequency;
+	bool monitoring_active;
+};
+
+/**
+ * struct xe_gpufreqtracer_data - Per-device frequency tracer data
+ * @xe: Reference to the XE device
+ * @gt_data: Array of per-GT monitoring data
+ */
+struct xe_gpufreqtracer_data {
+	struct xe_device *xe;
+	struct xe_gpufreqtracer_gt_data *gt_data;
+};
+
+
+/**
+ * xe_gpufreqtracer_sample_work - Worker function to sample GPU frequency.
+ * @work: Pointer to the work_struct representing the scheduled work.
+ *
+ * This function is executed in a workqueue context to periodically sample
+ * the GPU frequency and perform any necessary tracing or logging operations.
+ * It is part of the GPU frequency tracer subsystem.
+ */
+static void xe_gpufreqtracer_sample_work(struct work_struct *work)
+{
+	struct xe_gpufreqtracer_gt_data *gt_data =
+		container_of(work, struct xe_gpufreqtracer_gt_data, work);
+	struct xe_gt *gt = gt_data->gt;
+	struct xe_guc_pc *pc = &gt->uc.guc.pc;
+	u32 current_freq;
+
+	if (!gt_data->monitoring_active) {
+		drm_warn(&gt_to_xe(gt)->drm, "monitoring not active for GT%u, exiting",
+			 gt->info.id);
+		return;
+	}
+
+	current_freq = xe_guc_pc_get_act_freq(pc) * 1000; /* Convert MHz to KHz */
+
+	/* Only report if frequency has changed or this is the first sample */
+	if (current_freq != gt_data->last_frequency) {
+		drm_dbg(&gt_to_xe(gt)->drm, "GT%u frequency changed, tracing %u KHz",
+			gt->info.id, current_freq);
+		trace_gpu_frequency(current_freq, gt->info.id);
+		gt_data->last_frequency = current_freq;
+	}
+}
+
+/**
+ * xe_gpufreqtracer_timer_callback - Timer callback for GPU frequency tracer
+ * @timer: Pointer to the timer_list structure associated with this callback
+ *
+ * This function is invoked when the timer associated with the GPU frequency tracer expires.
+ * It is responsible for handling periodic tasks related to GPU frequency tracing, such as
+ * sampling or logging frequency data.
+ */
+static void xe_gpufreqtracer_timer_callback(struct timer_list *timer)
+{
+	struct xe_gpufreqtracer_gt_data *gt_data =
+		container_of(timer, struct xe_gpufreqtracer_gt_data, timer);
+
+	if (gt_data->monitoring_active) {
+		queue_work(system_highpri_wq, &gt_data->work);
+		mod_timer(&gt_data->timer, jiffies +
+			  msecs_to_jiffies(xe_modparam.gpufreq_monitoring_interval_ms));
+	} else {
+		drm_warn(&gt_to_xe(gt_data->gt)->drm, "timer callback for GT%u but monitoring inactive",
+			 gt_data->gt->info.id);
+	}
+}
+
+/**
+ * xe_gpufreqtracer_init - Initialize GPU frequency tracer for a device
+ * @xe: The XE device
+ *
+ * Sets up the frequency tracer infrastructure for all GTs in the device.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int xe_gpufreqtracer_init(struct xe_device *xe)
+{
+	struct xe_gpufreqtracer_data *tracer_data;
+	struct xe_gt *gt;
+	u8 tile_id;
+	int ret = 0;
+
+	tracer_data = kzalloc(sizeof(*tracer_data), GFP_KERNEL);
+	if (!tracer_data)
+		return -ENOMEM;
+
+	tracer_data->xe = xe;
+
+	/* Allocate GT data array based on actual GT count */
+	tracer_data->gt_data = kcalloc(xe->info.gt_count,
+				       sizeof(*tracer_data->gt_data),
+				       GFP_KERNEL);
+	if (!tracer_data->gt_data) {
+		ret = -ENOMEM;
+		goto err_free_tracer;
+	}
+
+	/* Initialize per-GT data */
+	for_each_gt(gt, xe, tile_id) {
+		struct xe_gpufreqtracer_gt_data *gt_data =
+			&tracer_data->gt_data[gt->info.id];
+
+		drm_dbg(&xe->drm, "initializing GT%u (tile %u)", gt->info.id, tile_id);
+
+		gt_data->gt = gt;
+		gt_data->monitoring_active = false;
+		gt_data->last_frequency = 0;
+
+		INIT_WORK(&gt_data->work, xe_gpufreqtracer_sample_work);
+		timer_setup(&gt_data->timer, xe_gpufreqtracer_timer_callback, 0);
+
+		drm_dbg(&xe->drm, "GT%u initialized with global interval=%u ms",
+			 gt->info.id, xe_modparam.gpufreq_monitoring_interval_ms);
+	}
+
+	xe->gpufreqtracer_data = tracer_data;
+	return 0;
+
+err_free_tracer:
+	drm_err(&xe->drm, "initialization failed, freeing tracer data");
+	kfree(tracer_data);
+	return ret;
+}
+
+/**
+ * xe_gpufreqtracer_fini - Cleanup GPU frequency tracer for a device
+ * @xe: The XE device
+ *
+ * Stops all monitoring and cleans up tracer resources.
+ */
+void xe_gpufreqtracer_fini(struct xe_device *xe)
+{
+	struct xe_gpufreqtracer_data *tracer_data = xe->gpufreqtracer_data;
+	struct xe_gt *gt;
+	u8 tile_id;
+
+	if (!tracer_data) {
+		drm_warn(&xe->drm, "no tracer data found, nothing to cleanup");
+		return;
+	}
+
+	/* Stop all monitoring */
+	for_each_gt(gt, xe, tile_id) {
+		drm_dbg(&xe->drm, "stopping monitoring for GT%u", gt->info.id);
+		xe_gpufreqtracer_stop_monitoring(gt);
+	}
+
+	kfree(tracer_data->gt_data);
+	kfree(tracer_data);
+	xe->gpufreqtracer_data = NULL;
+}
+
+/**
+ * xe_gpufreqtracer_report_frequency_change - Report frequency change directly
+ * @gt: The GT instance
+ * @frequency_khz: The new frequency in KHz
+ *
+ * Reports a frequency change immediately through the tracepoint.
+ */
+void xe_gpufreqtracer_report_frequency_change(struct xe_gt *gt, u32 frequency_khz)
+{
+	drm_dbg(&gt_to_xe(gt)->drm, "direct frequency report for GT%u: %u KHz",
+		 gt->info.id, frequency_khz);
+
+	if (frequency_khz > 0) {
+		trace_gpu_frequency(frequency_khz, gt->info.id);
+		drm_dbg(&gt_to_xe(gt)->drm, "traced frequency change for GT%u", gt->info.id);
+	}
+}
+
+/**
+ * xe_gpufreqtracer_start_monitoring - Start periodic frequency monitoring
+ * @gt: The GT instance
+ *
+ * Starts periodic sampling of GPU frequency for the specified GT using the global
+ * monitoring interval from module parameters.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int xe_gpufreqtracer_start_monitoring(struct xe_gt *gt)
+{
+	struct xe_gpufreqtracer_data *tracer_data = gt_to_xe(gt)->gpufreqtracer_data;
+	struct xe_gpufreqtracer_gt_data *gt_data;
+
+	if (!tracer_data) {
+		drm_warn(&gt_to_xe(gt)->drm, "no tracer data for GT%u, not supported", gt->info.id);
+		return -EOPNOTSUPP;
+	}
+
+	if (gt->info.id >= gt_to_xe(gt)->info.gt_count) {
+		drm_err(&gt_to_xe(gt)->drm, "invalid GT ID %u, max supported is %u",
+			gt->info.id, gt_to_xe(gt)->info.gt_count - 1);
+		return -EINVAL;
+	}
+
+	gt_data = &tracer_data->gt_data[gt->info.id];
+
+	if (gt_data->monitoring_active) {
+		drm_warn(&gt_to_xe(gt)->drm, "monitoring already active for GT%u", gt->info.id);
+		return -EALREADY;
+	}
+
+	gt_data->monitoring_active = true;
+	gt_data->last_frequency = 0;
+
+	/* Start the timer using global interval */
+	mod_timer(&gt_data->timer, jiffies +
+		  msecs_to_jiffies(xe_modparam.gpufreq_monitoring_interval_ms));
+
+	drm_dbg(&gt_to_xe(gt)->drm, "monitoring started for GT%u with interval %u ms",
+		 gt->info.id, xe_modparam.gpufreq_monitoring_interval_ms);
+
+	return 0;
+}
+
+/**
+ * xe_gpufreqtracer_stop_monitoring - Stop periodic frequency monitoring
+ * @gt: The GT instance
+ *
+ * Stops periodic sampling of GPU frequency for the specified GT.
+ */
+void xe_gpufreqtracer_stop_monitoring(struct xe_gt *gt)
+{
+	struct xe_gpufreqtracer_data *tracer_data = gt_to_xe(gt)->gpufreqtracer_data;
+	struct xe_gpufreqtracer_gt_data *gt_data;
+
+	if (!tracer_data || gt->info.id >= gt_to_xe(gt)->info.gt_count) {
+		drm_err(&gt_to_xe(gt)->drm, "invalid tracer data or GT ID %u for stop request",
+			gt->info.id);
+		return;
+	}
+
+	gt_data = &tracer_data->gt_data[gt->info.id];
+
+	if (!gt_data->monitoring_active) {
+		drm_warn(&gt_to_xe(gt)->drm, "monitoring not active for GT%u, nothing to stop",
+			 gt->info.id);
+		return;
+	}
+
+	gt_data->monitoring_active = false;
+
+	del_timer_sync(&gt_data->timer);
+	cancel_work_sync(&gt_data->work);
+}