1// SPDX-License-Identifier: MIT
  2/*
  3 * Copyright © 2023 Intel Corporation
  4 */
  5
  6#include "xe_gt_freq.h"
  7
  8#include <linux/kobject.h>
  9#include <linux/sysfs.h>
 10
 11#include <drm/drm_managed.h>
 12#include <drm/drm_print.h>
 13
 14#include "xe_device_types.h"
 15#include "xe_gt_sysfs.h"
 16#include "xe_gt_throttle_sysfs.h"
 17#include "xe_guc_pc.h"
 18
 19/**
 20 * DOC: Xe GT Frequency Management
 21 *
 22 * This component is responsible for the raw GT frequency management, including
 23 * the sysfs API.
 24 *
 25 * Underneath, Xe enables GuC SLPC automated frequency management. GuC is then
 26 * allowed to request PCODE any frequency between the Minimum and the Maximum
 27 * selected by this component. Furthermore, it is important to highlight that
 28 * PCODE is the ultimate decision maker of the actual running frequency, based
 29 * on thermal and other running conditions.
 30 *
 31 * Xe's Freq provides a sysfs API for frequency management:
 32 *
 33 * device/tile#/gt#/freq0/<item>_freq *read-only* files:
 34 * - act_freq: The actual resolved frequency decided by PCODE.
 35 * - cur_freq: The current one requested by GuC PC to the PCODE.
 36 * - rpn_freq: The Render Performance (RP) N level, which is the minimal one.
 37 * - rpe_freq: The Render Performance (RP) E level, which is the efficient one.
 38 * - rp0_freq: The Render Performance (RP) 0 level, which is the maximum one.
 39 *
 40 * device/tile#/gt#/freq0/<item>_freq *read-write* files:
 41 * - min_freq: Min frequency request.
 42 * - max_freq: Max frequency request.
 43 *             If max <= min, then freq_min becomes a fixed frequency request.
 44 */
 45
 46static struct xe_guc_pc *
 47dev_to_pc(struct device *dev)
 48{
 49	return &kobj_to_gt(dev->kobj.parent)->uc.guc.pc;
 50}
 51
 52static ssize_t act_freq_show(struct device *dev,
 53			     struct device_attribute *attr, char *buf)
 54{
 55	struct xe_guc_pc *pc = dev_to_pc(dev);
 56
 57	return sysfs_emit(buf, "%d\n", xe_guc_pc_get_act_freq(pc));
 58}
 59static DEVICE_ATTR_RO(act_freq);
 60
 61static ssize_t cur_freq_show(struct device *dev,
 62			     struct device_attribute *attr, char *buf)
 63{
 64	struct xe_guc_pc *pc = dev_to_pc(dev);
 65	u32 freq;
 66	ssize_t ret;
 67
 68	ret = xe_guc_pc_get_cur_freq(pc, &freq);
 69	if (ret)
 70		return ret;
 71
 72	return sysfs_emit(buf, "%d\n", freq);
 73}
 74static DEVICE_ATTR_RO(cur_freq);
 75
 76static ssize_t rp0_freq_show(struct device *dev,
 77			     struct device_attribute *attr, char *buf)
 78{
 79	struct xe_guc_pc *pc = dev_to_pc(dev);
 80
 81	return sysfs_emit(buf, "%d\n", xe_guc_pc_get_rp0_freq(pc));
 82}
 83static DEVICE_ATTR_RO(rp0_freq);
 84
 85static ssize_t rpe_freq_show(struct device *dev,
 86			     struct device_attribute *attr, char *buf)
 87{
 88	struct xe_guc_pc *pc = dev_to_pc(dev);
 89
 90	return sysfs_emit(buf, "%d\n", xe_guc_pc_get_rpe_freq(pc));
 91}
 92static DEVICE_ATTR_RO(rpe_freq);
 93
 94static ssize_t rpn_freq_show(struct device *dev,
 95			     struct device_attribute *attr, char *buf)
 96{
 97	struct xe_guc_pc *pc = dev_to_pc(dev);
 98
 99	return sysfs_emit(buf, "%d\n", xe_guc_pc_get_rpn_freq(pc));
100}
101static DEVICE_ATTR_RO(rpn_freq);
102
103static ssize_t min_freq_show(struct device *dev,
104			     struct device_attribute *attr, char *buf)
105{
106	struct xe_guc_pc *pc = dev_to_pc(dev);
107	u32 freq;
108	ssize_t ret;
109
110	ret = xe_guc_pc_get_min_freq(pc, &freq);
111	if (ret)
112		return ret;
113
114	return sysfs_emit(buf, "%d\n", freq);
115}
116
117static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
118			      const char *buff, size_t count)
119{
120	struct xe_guc_pc *pc = dev_to_pc(dev);
121	u32 freq;
122	ssize_t ret;
123
124	ret = kstrtou32(buff, 0, &freq);
125	if (ret)
126		return ret;
127
128	ret = xe_guc_pc_set_min_freq(pc, freq);
129	if (ret)
130		return ret;
131
132	return count;
133}
134static DEVICE_ATTR_RW(min_freq);
135
136static ssize_t max_freq_show(struct device *dev,
137			     struct device_attribute *attr, char *buf)
138{
139	struct xe_guc_pc *pc = dev_to_pc(dev);
140	u32 freq;
141	ssize_t ret;
142
143	ret = xe_guc_pc_get_max_freq(pc, &freq);
144	if (ret)
145		return ret;
146
147	return sysfs_emit(buf, "%d\n", freq);
148}
149
150static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
151			      const char *buff, size_t count)
152{
153	struct xe_guc_pc *pc = dev_to_pc(dev);
154	u32 freq;
155	ssize_t ret;
156
157	ret = kstrtou32(buff, 0, &freq);
158	if (ret)
159		return ret;
160
161	ret = xe_guc_pc_set_max_freq(pc, freq);
162	if (ret)
163		return ret;
164
165	return count;
166}
167static DEVICE_ATTR_RW(max_freq);
168
169static const struct attribute *freq_attrs[] = {
170	&dev_attr_act_freq.attr,
171	&dev_attr_cur_freq.attr,
172	&dev_attr_rp0_freq.attr,
173	&dev_attr_rpe_freq.attr,
174	&dev_attr_rpn_freq.attr,
175	&dev_attr_min_freq.attr,
176	&dev_attr_max_freq.attr,
177	NULL
178};
179
180static void freq_fini(struct drm_device *drm, void *arg)
181{
182	struct kobject *kobj = arg;
183
184	sysfs_remove_files(kobj, freq_attrs);
185	kobject_put(kobj);
186}
187
188/**
189 * xe_gt_freq_init - Initialize Xe Freq component
190 * @gt: Xe GT object
191 *
192 * It needs to be initialized after GT Sysfs and GuC PC components are ready.
193 */
194void xe_gt_freq_init(struct xe_gt *gt)
195{
196	struct xe_device *xe = gt_to_xe(gt);
197	int err;
198
199	if (xe->info.skip_guc_pc)
200		return;
201
202	gt->freq = kobject_create_and_add("freq0", gt->sysfs);
203	if (!gt->freq) {
204		drm_warn(&xe->drm, "failed to add freq0 directory to %s\n",
205			 kobject_name(gt->sysfs));
206		return;
207	}
208
209	err = drmm_add_action_or_reset(&xe->drm, freq_fini, gt->freq);
210	if (err) {
211		drm_warn(&xe->drm, "%s: drmm_add_action_or_reset failed, err: %d\n",
212			 __func__, err);
213		return;
214	}
215
216	err = sysfs_create_files(gt->freq, freq_attrs);
217	if (err)
218		drm_warn(&xe->drm,  "failed to add freq attrs to %s, err: %d\n",
219			 kobject_name(gt->freq), err);
220
221	xe_gt_throttle_sysfs_init(gt);
222}