xe_gt_throttle.c

  1// SPDX-License-Identifier: MIT
  2/*
  3 * Copyright © 2023 Intel Corporation
  4 */
  5
  6#include <drm/drm_managed.h>
  7
  8#include <regs/xe_gt_regs.h>
  9#include "xe_device.h"
 10#include "xe_gt.h"
 11#include "xe_gt_sysfs.h"
 12#include "xe_gt_throttle.h"
 13#include "xe_mmio.h"
 14#include "xe_platform_types.h"
 15#include "xe_pm.h"
 16
 17/**
 18 * DOC: Xe GT Throttle
 19 *
 20 * The GT frequency may be throttled by hardware/firmware for various reasons
 21 * that are provided through attributes under the ``freq0/throttle/`` directory.
 22 * Their availability depend on the platform and some may not be visible if that
 23 * reason is not available.
 24 *
 25 * The ``reasons`` attribute can be used by sysadmin to monitor all possible
 26 * reasons for throttling and report them. It's preferred over monitoring
 27 * ``status`` and then reading the reason from individual attributes since that
 28 * is racy. If there's no throttling happening, "none" is returned.
 29 *
 30 * The following attributes are available on Crescent Island platform:
 31 *
 32 * - ``status``: Overall throttle status (0: no throttling, 1: throttling)
 33 * - ``reasons``: Array of reasons causing throttling separated by space
 34 * - ``reason_pl1``: package PL1
 35 * - ``reason_pl2``: package PL2
 36 * - ``reason_pl4``: package PL4
 37 * - ``reason_prochot``: prochot
 38 * - ``reason_soc_thermal``: SoC thermal
 39 * - ``reason_mem_thermal``: Memory thermal
 40 * - ``reason_vr_thermal``: VR thermal
 41 * - ``reason_iccmax``: ICCMAX
 42 * - ``reason_ratl``: RATL thermal algorithm
 43 * - ``reason_soc_avg_thermal``: SoC average temp
 44 * - ``reason_fastvmode``: VR is hitting FastVMode
 45 * - ``reason_psys_pl1``: PSYS PL1
 46 * - ``reason_psys_pl2``: PSYS PL2
 47 * - ``reason_p0_freq``: P0 frequency
 48 * - ``reason_psys_crit``: PSYS critical
 49 *
 50 * Other platforms support the following reasons:
 51 *
 52 * - ``status``: Overall throttle status (0: no throttling, 1: throttling)
 53 * - ``reasons``: Array of reasons causing throttling separated by space
 54 * - ``reason_pl1``: package PL1
 55 * - ``reason_pl2``: package PL2
 56 * - ``reason_pl4``: package PL4, Iccmax etc.
 57 * - ``reason_thermal``: thermal
 58 * - ``reason_prochot``: prochot
 59 * - ``reason_ratl``: RATL hermal algorithm
 60 * - ``reason_vr_thermalert``: VR THERMALERT
 61 * - ``reason_vr_tdc``: VR TDC
 62 */
 63
 64struct throttle_attribute {
 65	struct kobj_attribute attr;
 66	u32 mask;
 67};
 68
 69static struct xe_gt *dev_to_gt(struct device *dev)
 70{
 71	return kobj_to_gt(dev->kobj.parent);
 72}
 73
 74static struct xe_gt *throttle_to_gt(struct kobject *kobj)
 75{
 76	return dev_to_gt(kobj_to_dev(kobj));
 77}
 78
 79static struct throttle_attribute *kobj_attribute_to_throttle(struct kobj_attribute *attr)
 80{
 81	return container_of(attr, struct throttle_attribute, attr);
 82}
 83
 84u32 xe_gt_throttle_get_limit_reasons(struct xe_gt *gt)
 85{
 86	struct xe_device *xe = gt_to_xe(gt);
 87	struct xe_reg reg;
 88	u32 val, mask;
 89
 90	if (xe_gt_is_media_type(gt))
 91		reg = MTL_MEDIA_PERF_LIMIT_REASONS;
 92	else
 93		reg = GT0_PERF_LIMIT_REASONS;
 94
 95	if (xe->info.platform == XE_CRESCENTISLAND)
 96		mask = CRI_PERF_LIMIT_REASONS_MASK;
 97	else
 98		mask = GT0_PERF_LIMIT_REASONS_MASK;
 99
100	xe_pm_runtime_get(xe);
101	val = xe_mmio_read32(&gt->mmio, reg) & mask;
102	xe_pm_runtime_put(xe);
103
104	return val;
105}
106
107static bool is_throttled_by(struct xe_gt *gt, u32 mask)
108{
109	return xe_gt_throttle_get_limit_reasons(gt) & mask;
110}
111
112static ssize_t reason_show(struct kobject *kobj,
113			   struct kobj_attribute *attr, char *buff)
114{
115	struct throttle_attribute *ta = kobj_attribute_to_throttle(attr);
116	struct xe_gt *gt = throttle_to_gt(kobj);
117
118	return sysfs_emit(buff, "%u\n", is_throttled_by(gt, ta->mask));
119}
120
121static const struct attribute_group *get_platform_throttle_group(struct xe_device *xe);
122
123static ssize_t reasons_show(struct kobject *kobj,
124			    struct kobj_attribute *attr, char *buff)
125{
126	struct xe_gt *gt = throttle_to_gt(kobj);
127	struct xe_device *xe = gt_to_xe(gt);
128	const struct attribute_group *group;
129	struct attribute **pother;
130	ssize_t ret = 0;
131	u32 reasons;
132
133	reasons = xe_gt_throttle_get_limit_reasons(gt);
134	if (!reasons)
135		goto ret_none;
136
137	group = get_platform_throttle_group(xe);
138	for (pother = group->attrs; *pother; pother++) {
139		struct kobj_attribute *kattr = container_of(*pother, struct kobj_attribute, attr);
140		struct throttle_attribute *other_ta = kobj_attribute_to_throttle(kattr);
141
142		if (other_ta->mask != U32_MAX && reasons & other_ta->mask)
143			ret += sysfs_emit_at(buff, ret, "%s ", (*pother)->name + strlen("reason_"));
144	}
145
146	if (drm_WARN_ONCE(&xe->drm, !ret, "Unknown reason: %#x\n", reasons))
147		goto ret_none;
148
149	/* Drop extra space from last iteration above */
150	ret--;
151	ret += sysfs_emit_at(buff, ret, "\n");
152
153	return ret;
154
155ret_none:
156	return sysfs_emit(buff, "none\n");
157}
158
159#define THROTTLE_ATTR_RO(name, _mask)				\
160	struct throttle_attribute attr_##name =	{		\
161		.attr = __ATTR(name, 0444, reason_show, NULL),	\
162		.mask = _mask,					\
163	}
164
165#define THROTTLE_ATTR_RO_FUNC(name, _mask, _show)		\
166	struct throttle_attribute attr_##name =	{		\
167		.attr = __ATTR(name, 0444, _show, NULL),	\
168		.mask = _mask,					\
169	}
170
171static THROTTLE_ATTR_RO_FUNC(reasons, 0, reasons_show);
172static THROTTLE_ATTR_RO(status, U32_MAX);
173static THROTTLE_ATTR_RO(reason_pl1, POWER_LIMIT_1_MASK);
174static THROTTLE_ATTR_RO(reason_pl2, POWER_LIMIT_2_MASK);
175static THROTTLE_ATTR_RO(reason_pl4, POWER_LIMIT_4_MASK);
176static THROTTLE_ATTR_RO(reason_thermal, THERMAL_LIMIT_MASK);
177static THROTTLE_ATTR_RO(reason_prochot, PROCHOT_MASK);
178static THROTTLE_ATTR_RO(reason_ratl, RATL_MASK);
179static THROTTLE_ATTR_RO(reason_vr_thermalert, VR_THERMALERT_MASK);
180static THROTTLE_ATTR_RO(reason_vr_tdc, VR_TDC_MASK);
181
182static struct attribute *throttle_attrs[] = {
183	&attr_reasons.attr.attr,
184	&attr_status.attr.attr,
185	&attr_reason_pl1.attr.attr,
186	&attr_reason_pl2.attr.attr,
187	&attr_reason_pl4.attr.attr,
188	&attr_reason_thermal.attr.attr,
189	&attr_reason_prochot.attr.attr,
190	&attr_reason_ratl.attr.attr,
191	&attr_reason_vr_thermalert.attr.attr,
192	&attr_reason_vr_tdc.attr.attr,
193	NULL
194};
195
196static THROTTLE_ATTR_RO(reason_vr_thermal, VR_THERMAL_MASK);
197static THROTTLE_ATTR_RO(reason_soc_thermal, SOC_THERMAL_LIMIT_MASK);
198static THROTTLE_ATTR_RO(reason_mem_thermal, MEM_THERMAL_MASK);
199static THROTTLE_ATTR_RO(reason_iccmax, ICCMAX_MASK);
200static THROTTLE_ATTR_RO(reason_soc_avg_thermal, SOC_AVG_THERMAL_MASK);
201static THROTTLE_ATTR_RO(reason_fastvmode, FASTVMODE_MASK);
202static THROTTLE_ATTR_RO(reason_psys_pl1, PSYS_PL1_MASK);
203static THROTTLE_ATTR_RO(reason_psys_pl2, PSYS_PL2_MASK);
204static THROTTLE_ATTR_RO(reason_p0_freq, P0_FREQ_MASK);
205static THROTTLE_ATTR_RO(reason_psys_crit, PSYS_CRIT_MASK);
206
207static struct attribute *cri_throttle_attrs[] = {
208	/* Common */
209	&attr_reasons.attr.attr,
210	&attr_status.attr.attr,
211	&attr_reason_pl1.attr.attr,
212	&attr_reason_pl2.attr.attr,
213	&attr_reason_pl4.attr.attr,
214	&attr_reason_prochot.attr.attr,
215	&attr_reason_ratl.attr.attr,
216	/* CRI */
217	&attr_reason_vr_thermal.attr.attr,
218	&attr_reason_soc_thermal.attr.attr,
219	&attr_reason_mem_thermal.attr.attr,
220	&attr_reason_iccmax.attr.attr,
221	&attr_reason_soc_avg_thermal.attr.attr,
222	&attr_reason_fastvmode.attr.attr,
223	&attr_reason_psys_pl1.attr.attr,
224	&attr_reason_psys_pl2.attr.attr,
225	&attr_reason_p0_freq.attr.attr,
226	&attr_reason_psys_crit.attr.attr,
227	NULL
228};
229
230static const struct attribute_group throttle_group_attrs = {
231	.name = "throttle",
232	.attrs = throttle_attrs,
233};
234
235static const struct attribute_group cri_throttle_group_attrs = {
236	.name = "throttle",
237	.attrs = cri_throttle_attrs,
238};
239
240static const struct attribute_group *get_platform_throttle_group(struct xe_device *xe)
241{
242	switch (xe->info.platform) {
243	case XE_CRESCENTISLAND:
244		return &cri_throttle_group_attrs;
245	default:
246		return &throttle_group_attrs;
247	}
248}
249
250static void gt_throttle_sysfs_fini(void *arg)
251{
252	struct xe_gt *gt = arg;
253	struct xe_device *xe = gt_to_xe(gt);
254	const struct attribute_group *group = get_platform_throttle_group(xe);
255
256	sysfs_remove_group(gt->freq, group);
257}
258
259int xe_gt_throttle_init(struct xe_gt *gt)
260{
261	struct xe_device *xe = gt_to_xe(gt);
262	const struct attribute_group *group = get_platform_throttle_group(xe);
263	int err;
264
265	err = sysfs_create_group(gt->freq, group);
266	if (err)
267		return err;
268
269	return devm_add_action_or_reset(xe->drm.dev, gt_throttle_sysfs_fini, gt);
270}