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 64 struct throttle_attribute { 65 struct kobj_attribute attr; 66 u32 mask; 67 }; 68 69 static struct xe_gt *dev_to_gt(struct device *dev) 70 { 71 return kobj_to_gt(dev->kobj.parent); 72 } 73 74 static struct xe_gt *throttle_to_gt(struct kobject *kobj) 75 { 76 return dev_to_gt(kobj_to_dev(kobj)); 77 } 78 79 static struct throttle_attribute *kobj_attribute_to_throttle(struct kobj_attribute *attr) 80 { 81 return container_of(attr, struct throttle_attribute, attr); 82 } 83 84 u32 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(>->mmio, reg) & mask; 102 xe_pm_runtime_put(xe); 103 104 return val; 105 } 106 107 static bool is_throttled_by(struct xe_gt *gt, u32 mask) 108 { 109 return xe_gt_throttle_get_limit_reasons(gt) & mask; 110 } 111 112 static 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 121 static const struct attribute_group *get_platform_throttle_group(struct xe_device *xe); 122 123 static 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 155 ret_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 171 static THROTTLE_ATTR_RO_FUNC(reasons, 0, reasons_show); 172 static THROTTLE_ATTR_RO(status, U32_MAX); 173 static THROTTLE_ATTR_RO(reason_pl1, POWER_LIMIT_1_MASK); 174 static THROTTLE_ATTR_RO(reason_pl2, POWER_LIMIT_2_MASK); 175 static THROTTLE_ATTR_RO(reason_pl4, POWER_LIMIT_4_MASK); 176 static THROTTLE_ATTR_RO(reason_thermal, THERMAL_LIMIT_MASK); 177 static THROTTLE_ATTR_RO(reason_prochot, PROCHOT_MASK); 178 static THROTTLE_ATTR_RO(reason_ratl, RATL_MASK); 179 static THROTTLE_ATTR_RO(reason_vr_thermalert, VR_THERMALERT_MASK); 180 static THROTTLE_ATTR_RO(reason_vr_tdc, VR_TDC_MASK); 181 182 static 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 196 static THROTTLE_ATTR_RO(reason_vr_thermal, VR_THERMAL_MASK); 197 static THROTTLE_ATTR_RO(reason_soc_thermal, SOC_THERMAL_LIMIT_MASK); 198 static THROTTLE_ATTR_RO(reason_mem_thermal, MEM_THERMAL_MASK); 199 static THROTTLE_ATTR_RO(reason_iccmax, ICCMAX_MASK); 200 static THROTTLE_ATTR_RO(reason_soc_avg_thermal, SOC_AVG_THERMAL_MASK); 201 static THROTTLE_ATTR_RO(reason_fastvmode, FASTVMODE_MASK); 202 static THROTTLE_ATTR_RO(reason_psys_pl1, PSYS_PL1_MASK); 203 static THROTTLE_ATTR_RO(reason_psys_pl2, PSYS_PL2_MASK); 204 static THROTTLE_ATTR_RO(reason_p0_freq, P0_FREQ_MASK); 205 static THROTTLE_ATTR_RO(reason_psys_crit, PSYS_CRIT_MASK); 206 207 static 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 230 static const struct attribute_group throttle_group_attrs = { 231 .name = "throttle", 232 .attrs = throttle_attrs, 233 }; 234 235 static const struct attribute_group cri_throttle_group_attrs = { 236 .name = "throttle", 237 .attrs = cri_throttle_attrs, 238 }; 239 240 static 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 250 static 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 259 int 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 } 271