Loading...
1/*
2 * Permission is hereby granted, free of charge, to any person obtaining a
3 * copy of this software and associated documentation files (the "Software"),
4 * to deal in the Software without restriction, including without limitation
5 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
6 * and/or sell copies of the Software, and to permit persons to whom the
7 * Software is furnished to do so, subject to the following conditions:
8 *
9 * The above copyright notice and this permission notice shall be included in
10 * all copies or substantial portions of the Software.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
16 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
17 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
18 * OTHER DEALINGS IN THE SOFTWARE.
19 *
20 * Authors: Rafał Miłecki <zajec5@gmail.com>
21 * Alex Deucher <alexdeucher@gmail.com>
22 */
23#include <drm/drmP.h>
24#include "amdgpu.h"
25#include "amdgpu_drv.h"
26#include "amdgpu_pm.h"
27#include "amdgpu_dpm.h"
28#include "atom.h"
29#include <linux/power_supply.h>
30#include <linux/hwmon.h>
31#include <linux/hwmon-sysfs.h>
32
33#include "amd_powerplay.h"
34
35static int amdgpu_debugfs_pm_init(struct amdgpu_device *adev);
36
37void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev)
38{
39 if (adev->pp_enabled)
40 /* TODO */
41 return;
42
43 if (adev->pm.dpm_enabled) {
44 mutex_lock(&adev->pm.mutex);
45 if (power_supply_is_system_supplied() > 0)
46 adev->pm.dpm.ac_power = true;
47 else
48 adev->pm.dpm.ac_power = false;
49 if (adev->pm.funcs->enable_bapm)
50 amdgpu_dpm_enable_bapm(adev, adev->pm.dpm.ac_power);
51 mutex_unlock(&adev->pm.mutex);
52 }
53}
54
55static ssize_t amdgpu_get_dpm_state(struct device *dev,
56 struct device_attribute *attr,
57 char *buf)
58{
59 struct drm_device *ddev = dev_get_drvdata(dev);
60 struct amdgpu_device *adev = ddev->dev_private;
61 enum amd_pm_state_type pm;
62
63 if (adev->pp_enabled) {
64 pm = amdgpu_dpm_get_current_power_state(adev);
65 } else
66 pm = adev->pm.dpm.user_state;
67
68 return snprintf(buf, PAGE_SIZE, "%s\n",
69 (pm == POWER_STATE_TYPE_BATTERY) ? "battery" :
70 (pm == POWER_STATE_TYPE_BALANCED) ? "balanced" : "performance");
71}
72
73static ssize_t amdgpu_set_dpm_state(struct device *dev,
74 struct device_attribute *attr,
75 const char *buf,
76 size_t count)
77{
78 struct drm_device *ddev = dev_get_drvdata(dev);
79 struct amdgpu_device *adev = ddev->dev_private;
80 enum amd_pm_state_type state;
81
82 if (strncmp("battery", buf, strlen("battery")) == 0)
83 state = POWER_STATE_TYPE_BATTERY;
84 else if (strncmp("balanced", buf, strlen("balanced")) == 0)
85 state = POWER_STATE_TYPE_BALANCED;
86 else if (strncmp("performance", buf, strlen("performance")) == 0)
87 state = POWER_STATE_TYPE_PERFORMANCE;
88 else {
89 count = -EINVAL;
90 goto fail;
91 }
92
93 if (adev->pp_enabled) {
94 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
95 } else {
96 mutex_lock(&adev->pm.mutex);
97 adev->pm.dpm.user_state = state;
98 mutex_unlock(&adev->pm.mutex);
99
100 /* Can't set dpm state when the card is off */
101 if (!(adev->flags & AMD_IS_PX) ||
102 (ddev->switch_power_state == DRM_SWITCH_POWER_ON))
103 amdgpu_pm_compute_clocks(adev);
104 }
105fail:
106 return count;
107}
108
109static ssize_t amdgpu_get_dpm_forced_performance_level(struct device *dev,
110 struct device_attribute *attr,
111 char *buf)
112{
113 struct drm_device *ddev = dev_get_drvdata(dev);
114 struct amdgpu_device *adev = ddev->dev_private;
115
116 if ((adev->flags & AMD_IS_PX) &&
117 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
118 return snprintf(buf, PAGE_SIZE, "off\n");
119
120 if (adev->pp_enabled) {
121 enum amd_dpm_forced_level level;
122
123 level = amdgpu_dpm_get_performance_level(adev);
124 return snprintf(buf, PAGE_SIZE, "%s\n",
125 (level == AMD_DPM_FORCED_LEVEL_AUTO) ? "auto" :
126 (level == AMD_DPM_FORCED_LEVEL_LOW) ? "low" :
127 (level == AMD_DPM_FORCED_LEVEL_HIGH) ? "high" :
128 (level == AMD_DPM_FORCED_LEVEL_MANUAL) ? "manual" : "unknown");
129 } else {
130 enum amdgpu_dpm_forced_level level;
131
132 level = adev->pm.dpm.forced_level;
133 return snprintf(buf, PAGE_SIZE, "%s\n",
134 (level == AMDGPU_DPM_FORCED_LEVEL_AUTO) ? "auto" :
135 (level == AMDGPU_DPM_FORCED_LEVEL_LOW) ? "low" : "high");
136 }
137}
138
139static ssize_t amdgpu_set_dpm_forced_performance_level(struct device *dev,
140 struct device_attribute *attr,
141 const char *buf,
142 size_t count)
143{
144 struct drm_device *ddev = dev_get_drvdata(dev);
145 struct amdgpu_device *adev = ddev->dev_private;
146 enum amdgpu_dpm_forced_level level;
147 int ret = 0;
148
149 /* Can't force performance level when the card is off */
150 if ((adev->flags & AMD_IS_PX) &&
151 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
152 return -EINVAL;
153
154 if (strncmp("low", buf, strlen("low")) == 0) {
155 level = AMDGPU_DPM_FORCED_LEVEL_LOW;
156 } else if (strncmp("high", buf, strlen("high")) == 0) {
157 level = AMDGPU_DPM_FORCED_LEVEL_HIGH;
158 } else if (strncmp("auto", buf, strlen("auto")) == 0) {
159 level = AMDGPU_DPM_FORCED_LEVEL_AUTO;
160 } else if (strncmp("manual", buf, strlen("manual")) == 0) {
161 level = AMDGPU_DPM_FORCED_LEVEL_MANUAL;
162 } else {
163 count = -EINVAL;
164 goto fail;
165 }
166
167 if (adev->pp_enabled)
168 amdgpu_dpm_force_performance_level(adev, level);
169 else {
170 mutex_lock(&adev->pm.mutex);
171 if (adev->pm.dpm.thermal_active) {
172 count = -EINVAL;
173 mutex_unlock(&adev->pm.mutex);
174 goto fail;
175 }
176 ret = amdgpu_dpm_force_performance_level(adev, level);
177 if (ret)
178 count = -EINVAL;
179 else
180 adev->pm.dpm.forced_level = level;
181 mutex_unlock(&adev->pm.mutex);
182 }
183fail:
184 return count;
185}
186
187static ssize_t amdgpu_get_pp_num_states(struct device *dev,
188 struct device_attribute *attr,
189 char *buf)
190{
191 struct drm_device *ddev = dev_get_drvdata(dev);
192 struct amdgpu_device *adev = ddev->dev_private;
193 struct pp_states_info data;
194 int i, buf_len;
195
196 if (adev->pp_enabled)
197 amdgpu_dpm_get_pp_num_states(adev, &data);
198
199 buf_len = snprintf(buf, PAGE_SIZE, "states: %d\n", data.nums);
200 for (i = 0; i < data.nums; i++)
201 buf_len += snprintf(buf + buf_len, PAGE_SIZE, "%d %s\n", i,
202 (data.states[i] == POWER_STATE_TYPE_INTERNAL_BOOT) ? "boot" :
203 (data.states[i] == POWER_STATE_TYPE_BATTERY) ? "battery" :
204 (data.states[i] == POWER_STATE_TYPE_BALANCED) ? "balanced" :
205 (data.states[i] == POWER_STATE_TYPE_PERFORMANCE) ? "performance" : "default");
206
207 return buf_len;
208}
209
210static ssize_t amdgpu_get_pp_cur_state(struct device *dev,
211 struct device_attribute *attr,
212 char *buf)
213{
214 struct drm_device *ddev = dev_get_drvdata(dev);
215 struct amdgpu_device *adev = ddev->dev_private;
216 struct pp_states_info data;
217 enum amd_pm_state_type pm = 0;
218 int i = 0;
219
220 if (adev->pp_enabled) {
221
222 pm = amdgpu_dpm_get_current_power_state(adev);
223 amdgpu_dpm_get_pp_num_states(adev, &data);
224
225 for (i = 0; i < data.nums; i++) {
226 if (pm == data.states[i])
227 break;
228 }
229
230 if (i == data.nums)
231 i = -EINVAL;
232 }
233
234 return snprintf(buf, PAGE_SIZE, "%d\n", i);
235}
236
237static ssize_t amdgpu_get_pp_force_state(struct device *dev,
238 struct device_attribute *attr,
239 char *buf)
240{
241 struct drm_device *ddev = dev_get_drvdata(dev);
242 struct amdgpu_device *adev = ddev->dev_private;
243 struct pp_states_info data;
244 enum amd_pm_state_type pm = 0;
245 int i;
246
247 if (adev->pp_force_state_enabled && adev->pp_enabled) {
248 pm = amdgpu_dpm_get_current_power_state(adev);
249 amdgpu_dpm_get_pp_num_states(adev, &data);
250
251 for (i = 0; i < data.nums; i++) {
252 if (pm == data.states[i])
253 break;
254 }
255
256 if (i == data.nums)
257 i = -EINVAL;
258
259 return snprintf(buf, PAGE_SIZE, "%d\n", i);
260
261 } else
262 return snprintf(buf, PAGE_SIZE, "\n");
263}
264
265static ssize_t amdgpu_set_pp_force_state(struct device *dev,
266 struct device_attribute *attr,
267 const char *buf,
268 size_t count)
269{
270 struct drm_device *ddev = dev_get_drvdata(dev);
271 struct amdgpu_device *adev = ddev->dev_private;
272 enum amd_pm_state_type state = 0;
273 long idx;
274 int ret;
275
276 if (strlen(buf) == 1)
277 adev->pp_force_state_enabled = false;
278 else {
279 ret = kstrtol(buf, 0, &idx);
280
281 if (ret) {
282 count = -EINVAL;
283 goto fail;
284 }
285
286 if (adev->pp_enabled) {
287 struct pp_states_info data;
288 amdgpu_dpm_get_pp_num_states(adev, &data);
289 state = data.states[idx];
290 /* only set user selected power states */
291 if (state != POWER_STATE_TYPE_INTERNAL_BOOT &&
292 state != POWER_STATE_TYPE_DEFAULT) {
293 amdgpu_dpm_dispatch_task(adev,
294 AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
295 adev->pp_force_state_enabled = true;
296 }
297 }
298 }
299fail:
300 return count;
301}
302
303static ssize_t amdgpu_get_pp_table(struct device *dev,
304 struct device_attribute *attr,
305 char *buf)
306{
307 struct drm_device *ddev = dev_get_drvdata(dev);
308 struct amdgpu_device *adev = ddev->dev_private;
309 char *table = NULL;
310 int size, i;
311
312 if (adev->pp_enabled)
313 size = amdgpu_dpm_get_pp_table(adev, &table);
314 else
315 return 0;
316
317 if (size >= PAGE_SIZE)
318 size = PAGE_SIZE - 1;
319
320 for (i = 0; i < size; i++) {
321 sprintf(buf + i, "%02x", table[i]);
322 }
323 sprintf(buf + i, "\n");
324
325 return size;
326}
327
328static ssize_t amdgpu_set_pp_table(struct device *dev,
329 struct device_attribute *attr,
330 const char *buf,
331 size_t count)
332{
333 struct drm_device *ddev = dev_get_drvdata(dev);
334 struct amdgpu_device *adev = ddev->dev_private;
335
336 if (adev->pp_enabled)
337 amdgpu_dpm_set_pp_table(adev, buf, count);
338
339 return count;
340}
341
342static ssize_t amdgpu_get_pp_dpm_sclk(struct device *dev,
343 struct device_attribute *attr,
344 char *buf)
345{
346 struct drm_device *ddev = dev_get_drvdata(dev);
347 struct amdgpu_device *adev = ddev->dev_private;
348 ssize_t size = 0;
349
350 if (adev->pp_enabled)
351 size = amdgpu_dpm_print_clock_levels(adev, PP_SCLK, buf);
352
353 return size;
354}
355
356static ssize_t amdgpu_set_pp_dpm_sclk(struct device *dev,
357 struct device_attribute *attr,
358 const char *buf,
359 size_t count)
360{
361 struct drm_device *ddev = dev_get_drvdata(dev);
362 struct amdgpu_device *adev = ddev->dev_private;
363 int ret;
364 long level;
365
366 ret = kstrtol(buf, 0, &level);
367
368 if (ret) {
369 count = -EINVAL;
370 goto fail;
371 }
372
373 if (adev->pp_enabled)
374 amdgpu_dpm_force_clock_level(adev, PP_SCLK, level);
375fail:
376 return count;
377}
378
379static ssize_t amdgpu_get_pp_dpm_mclk(struct device *dev,
380 struct device_attribute *attr,
381 char *buf)
382{
383 struct drm_device *ddev = dev_get_drvdata(dev);
384 struct amdgpu_device *adev = ddev->dev_private;
385 ssize_t size = 0;
386
387 if (adev->pp_enabled)
388 size = amdgpu_dpm_print_clock_levels(adev, PP_MCLK, buf);
389
390 return size;
391}
392
393static ssize_t amdgpu_set_pp_dpm_mclk(struct device *dev,
394 struct device_attribute *attr,
395 const char *buf,
396 size_t count)
397{
398 struct drm_device *ddev = dev_get_drvdata(dev);
399 struct amdgpu_device *adev = ddev->dev_private;
400 int ret;
401 long level;
402
403 ret = kstrtol(buf, 0, &level);
404
405 if (ret) {
406 count = -EINVAL;
407 goto fail;
408 }
409
410 if (adev->pp_enabled)
411 amdgpu_dpm_force_clock_level(adev, PP_MCLK, level);
412fail:
413 return count;
414}
415
416static ssize_t amdgpu_get_pp_dpm_pcie(struct device *dev,
417 struct device_attribute *attr,
418 char *buf)
419{
420 struct drm_device *ddev = dev_get_drvdata(dev);
421 struct amdgpu_device *adev = ddev->dev_private;
422 ssize_t size = 0;
423
424 if (adev->pp_enabled)
425 size = amdgpu_dpm_print_clock_levels(adev, PP_PCIE, buf);
426
427 return size;
428}
429
430static ssize_t amdgpu_set_pp_dpm_pcie(struct device *dev,
431 struct device_attribute *attr,
432 const char *buf,
433 size_t count)
434{
435 struct drm_device *ddev = dev_get_drvdata(dev);
436 struct amdgpu_device *adev = ddev->dev_private;
437 int ret;
438 long level;
439
440 ret = kstrtol(buf, 0, &level);
441
442 if (ret) {
443 count = -EINVAL;
444 goto fail;
445 }
446
447 if (adev->pp_enabled)
448 amdgpu_dpm_force_clock_level(adev, PP_PCIE, level);
449fail:
450 return count;
451}
452
453static DEVICE_ATTR(power_dpm_state, S_IRUGO | S_IWUSR, amdgpu_get_dpm_state, amdgpu_set_dpm_state);
454static DEVICE_ATTR(power_dpm_force_performance_level, S_IRUGO | S_IWUSR,
455 amdgpu_get_dpm_forced_performance_level,
456 amdgpu_set_dpm_forced_performance_level);
457static DEVICE_ATTR(pp_num_states, S_IRUGO, amdgpu_get_pp_num_states, NULL);
458static DEVICE_ATTR(pp_cur_state, S_IRUGO, amdgpu_get_pp_cur_state, NULL);
459static DEVICE_ATTR(pp_force_state, S_IRUGO | S_IWUSR,
460 amdgpu_get_pp_force_state,
461 amdgpu_set_pp_force_state);
462static DEVICE_ATTR(pp_table, S_IRUGO | S_IWUSR,
463 amdgpu_get_pp_table,
464 amdgpu_set_pp_table);
465static DEVICE_ATTR(pp_dpm_sclk, S_IRUGO | S_IWUSR,
466 amdgpu_get_pp_dpm_sclk,
467 amdgpu_set_pp_dpm_sclk);
468static DEVICE_ATTR(pp_dpm_mclk, S_IRUGO | S_IWUSR,
469 amdgpu_get_pp_dpm_mclk,
470 amdgpu_set_pp_dpm_mclk);
471static DEVICE_ATTR(pp_dpm_pcie, S_IRUGO | S_IWUSR,
472 amdgpu_get_pp_dpm_pcie,
473 amdgpu_set_pp_dpm_pcie);
474
475static ssize_t amdgpu_hwmon_show_temp(struct device *dev,
476 struct device_attribute *attr,
477 char *buf)
478{
479 struct amdgpu_device *adev = dev_get_drvdata(dev);
480 struct drm_device *ddev = adev->ddev;
481 int temp;
482
483 /* Can't get temperature when the card is off */
484 if ((adev->flags & AMD_IS_PX) &&
485 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
486 return -EINVAL;
487
488 if (!adev->pp_enabled && !adev->pm.funcs->get_temperature)
489 temp = 0;
490 else
491 temp = amdgpu_dpm_get_temperature(adev);
492
493 return snprintf(buf, PAGE_SIZE, "%d\n", temp);
494}
495
496static ssize_t amdgpu_hwmon_show_temp_thresh(struct device *dev,
497 struct device_attribute *attr,
498 char *buf)
499{
500 struct amdgpu_device *adev = dev_get_drvdata(dev);
501 int hyst = to_sensor_dev_attr(attr)->index;
502 int temp;
503
504 if (hyst)
505 temp = adev->pm.dpm.thermal.min_temp;
506 else
507 temp = adev->pm.dpm.thermal.max_temp;
508
509 return snprintf(buf, PAGE_SIZE, "%d\n", temp);
510}
511
512static ssize_t amdgpu_hwmon_get_pwm1_enable(struct device *dev,
513 struct device_attribute *attr,
514 char *buf)
515{
516 struct amdgpu_device *adev = dev_get_drvdata(dev);
517 u32 pwm_mode = 0;
518
519 if (!adev->pp_enabled && !adev->pm.funcs->get_fan_control_mode)
520 return -EINVAL;
521
522 pwm_mode = amdgpu_dpm_get_fan_control_mode(adev);
523
524 /* never 0 (full-speed), fuse or smc-controlled always */
525 return sprintf(buf, "%i\n", pwm_mode == FDO_PWM_MODE_STATIC ? 1 : 2);
526}
527
528static ssize_t amdgpu_hwmon_set_pwm1_enable(struct device *dev,
529 struct device_attribute *attr,
530 const char *buf,
531 size_t count)
532{
533 struct amdgpu_device *adev = dev_get_drvdata(dev);
534 int err;
535 int value;
536
537 if (!adev->pp_enabled && !adev->pm.funcs->set_fan_control_mode)
538 return -EINVAL;
539
540 err = kstrtoint(buf, 10, &value);
541 if (err)
542 return err;
543
544 switch (value) {
545 case 1: /* manual, percent-based */
546 amdgpu_dpm_set_fan_control_mode(adev, FDO_PWM_MODE_STATIC);
547 break;
548 default: /* disable */
549 amdgpu_dpm_set_fan_control_mode(adev, 0);
550 break;
551 }
552
553 return count;
554}
555
556static ssize_t amdgpu_hwmon_get_pwm1_min(struct device *dev,
557 struct device_attribute *attr,
558 char *buf)
559{
560 return sprintf(buf, "%i\n", 0);
561}
562
563static ssize_t amdgpu_hwmon_get_pwm1_max(struct device *dev,
564 struct device_attribute *attr,
565 char *buf)
566{
567 return sprintf(buf, "%i\n", 255);
568}
569
570static ssize_t amdgpu_hwmon_set_pwm1(struct device *dev,
571 struct device_attribute *attr,
572 const char *buf, size_t count)
573{
574 struct amdgpu_device *adev = dev_get_drvdata(dev);
575 int err;
576 u32 value;
577
578 err = kstrtou32(buf, 10, &value);
579 if (err)
580 return err;
581
582 value = (value * 100) / 255;
583
584 err = amdgpu_dpm_set_fan_speed_percent(adev, value);
585 if (err)
586 return err;
587
588 return count;
589}
590
591static ssize_t amdgpu_hwmon_get_pwm1(struct device *dev,
592 struct device_attribute *attr,
593 char *buf)
594{
595 struct amdgpu_device *adev = dev_get_drvdata(dev);
596 int err;
597 u32 speed;
598
599 err = amdgpu_dpm_get_fan_speed_percent(adev, &speed);
600 if (err)
601 return err;
602
603 speed = (speed * 255) / 100;
604
605 return sprintf(buf, "%i\n", speed);
606}
607
608static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, amdgpu_hwmon_show_temp, NULL, 0);
609static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 0);
610static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 1);
611static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1, amdgpu_hwmon_set_pwm1, 0);
612static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1_enable, amdgpu_hwmon_set_pwm1_enable, 0);
613static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO, amdgpu_hwmon_get_pwm1_min, NULL, 0);
614static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO, amdgpu_hwmon_get_pwm1_max, NULL, 0);
615
616static struct attribute *hwmon_attributes[] = {
617 &sensor_dev_attr_temp1_input.dev_attr.attr,
618 &sensor_dev_attr_temp1_crit.dev_attr.attr,
619 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
620 &sensor_dev_attr_pwm1.dev_attr.attr,
621 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
622 &sensor_dev_attr_pwm1_min.dev_attr.attr,
623 &sensor_dev_attr_pwm1_max.dev_attr.attr,
624 NULL
625};
626
627static umode_t hwmon_attributes_visible(struct kobject *kobj,
628 struct attribute *attr, int index)
629{
630 struct device *dev = kobj_to_dev(kobj);
631 struct amdgpu_device *adev = dev_get_drvdata(dev);
632 umode_t effective_mode = attr->mode;
633
634 /* Skip limit attributes if DPM is not enabled */
635 if (!adev->pm.dpm_enabled &&
636 (attr == &sensor_dev_attr_temp1_crit.dev_attr.attr ||
637 attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr ||
638 attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
639 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
640 attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
641 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
642 return 0;
643
644 if (adev->pp_enabled)
645 return effective_mode;
646
647 /* Skip fan attributes if fan is not present */
648 if (adev->pm.no_fan &&
649 (attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
650 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
651 attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
652 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
653 return 0;
654
655 /* mask fan attributes if we have no bindings for this asic to expose */
656 if ((!adev->pm.funcs->get_fan_speed_percent &&
657 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't query fan */
658 (!adev->pm.funcs->get_fan_control_mode &&
659 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't query state */
660 effective_mode &= ~S_IRUGO;
661
662 if ((!adev->pm.funcs->set_fan_speed_percent &&
663 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't manage fan */
664 (!adev->pm.funcs->set_fan_control_mode &&
665 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't manage state */
666 effective_mode &= ~S_IWUSR;
667
668 /* hide max/min values if we can't both query and manage the fan */
669 if ((!adev->pm.funcs->set_fan_speed_percent &&
670 !adev->pm.funcs->get_fan_speed_percent) &&
671 (attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
672 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
673 return 0;
674
675 return effective_mode;
676}
677
678static const struct attribute_group hwmon_attrgroup = {
679 .attrs = hwmon_attributes,
680 .is_visible = hwmon_attributes_visible,
681};
682
683static const struct attribute_group *hwmon_groups[] = {
684 &hwmon_attrgroup,
685 NULL
686};
687
688void amdgpu_dpm_thermal_work_handler(struct work_struct *work)
689{
690 struct amdgpu_device *adev =
691 container_of(work, struct amdgpu_device,
692 pm.dpm.thermal.work);
693 /* switch to the thermal state */
694 enum amd_pm_state_type dpm_state = POWER_STATE_TYPE_INTERNAL_THERMAL;
695
696 if (!adev->pm.dpm_enabled)
697 return;
698
699 if (adev->pm.funcs->get_temperature) {
700 int temp = amdgpu_dpm_get_temperature(adev);
701
702 if (temp < adev->pm.dpm.thermal.min_temp)
703 /* switch back the user state */
704 dpm_state = adev->pm.dpm.user_state;
705 } else {
706 if (adev->pm.dpm.thermal.high_to_low)
707 /* switch back the user state */
708 dpm_state = adev->pm.dpm.user_state;
709 }
710 mutex_lock(&adev->pm.mutex);
711 if (dpm_state == POWER_STATE_TYPE_INTERNAL_THERMAL)
712 adev->pm.dpm.thermal_active = true;
713 else
714 adev->pm.dpm.thermal_active = false;
715 adev->pm.dpm.state = dpm_state;
716 mutex_unlock(&adev->pm.mutex);
717
718 amdgpu_pm_compute_clocks(adev);
719}
720
721static struct amdgpu_ps *amdgpu_dpm_pick_power_state(struct amdgpu_device *adev,
722 enum amd_pm_state_type dpm_state)
723{
724 int i;
725 struct amdgpu_ps *ps;
726 u32 ui_class;
727 bool single_display = (adev->pm.dpm.new_active_crtc_count < 2) ?
728 true : false;
729
730 /* check if the vblank period is too short to adjust the mclk */
731 if (single_display && adev->pm.funcs->vblank_too_short) {
732 if (amdgpu_dpm_vblank_too_short(adev))
733 single_display = false;
734 }
735
736 /* certain older asics have a separare 3D performance state,
737 * so try that first if the user selected performance
738 */
739 if (dpm_state == POWER_STATE_TYPE_PERFORMANCE)
740 dpm_state = POWER_STATE_TYPE_INTERNAL_3DPERF;
741 /* balanced states don't exist at the moment */
742 if (dpm_state == POWER_STATE_TYPE_BALANCED)
743 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
744
745restart_search:
746 /* Pick the best power state based on current conditions */
747 for (i = 0; i < adev->pm.dpm.num_ps; i++) {
748 ps = &adev->pm.dpm.ps[i];
749 ui_class = ps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK;
750 switch (dpm_state) {
751 /* user states */
752 case POWER_STATE_TYPE_BATTERY:
753 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BATTERY) {
754 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
755 if (single_display)
756 return ps;
757 } else
758 return ps;
759 }
760 break;
761 case POWER_STATE_TYPE_BALANCED:
762 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BALANCED) {
763 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
764 if (single_display)
765 return ps;
766 } else
767 return ps;
768 }
769 break;
770 case POWER_STATE_TYPE_PERFORMANCE:
771 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE) {
772 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
773 if (single_display)
774 return ps;
775 } else
776 return ps;
777 }
778 break;
779 /* internal states */
780 case POWER_STATE_TYPE_INTERNAL_UVD:
781 if (adev->pm.dpm.uvd_ps)
782 return adev->pm.dpm.uvd_ps;
783 else
784 break;
785 case POWER_STATE_TYPE_INTERNAL_UVD_SD:
786 if (ps->class & ATOM_PPLIB_CLASSIFICATION_SDSTATE)
787 return ps;
788 break;
789 case POWER_STATE_TYPE_INTERNAL_UVD_HD:
790 if (ps->class & ATOM_PPLIB_CLASSIFICATION_HDSTATE)
791 return ps;
792 break;
793 case POWER_STATE_TYPE_INTERNAL_UVD_HD2:
794 if (ps->class & ATOM_PPLIB_CLASSIFICATION_HD2STATE)
795 return ps;
796 break;
797 case POWER_STATE_TYPE_INTERNAL_UVD_MVC:
798 if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_MVC)
799 return ps;
800 break;
801 case POWER_STATE_TYPE_INTERNAL_BOOT:
802 return adev->pm.dpm.boot_ps;
803 case POWER_STATE_TYPE_INTERNAL_THERMAL:
804 if (ps->class & ATOM_PPLIB_CLASSIFICATION_THERMAL)
805 return ps;
806 break;
807 case POWER_STATE_TYPE_INTERNAL_ACPI:
808 if (ps->class & ATOM_PPLIB_CLASSIFICATION_ACPI)
809 return ps;
810 break;
811 case POWER_STATE_TYPE_INTERNAL_ULV:
812 if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_ULV)
813 return ps;
814 break;
815 case POWER_STATE_TYPE_INTERNAL_3DPERF:
816 if (ps->class & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
817 return ps;
818 break;
819 default:
820 break;
821 }
822 }
823 /* use a fallback state if we didn't match */
824 switch (dpm_state) {
825 case POWER_STATE_TYPE_INTERNAL_UVD_SD:
826 dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD;
827 goto restart_search;
828 case POWER_STATE_TYPE_INTERNAL_UVD_HD:
829 case POWER_STATE_TYPE_INTERNAL_UVD_HD2:
830 case POWER_STATE_TYPE_INTERNAL_UVD_MVC:
831 if (adev->pm.dpm.uvd_ps) {
832 return adev->pm.dpm.uvd_ps;
833 } else {
834 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
835 goto restart_search;
836 }
837 case POWER_STATE_TYPE_INTERNAL_THERMAL:
838 dpm_state = POWER_STATE_TYPE_INTERNAL_ACPI;
839 goto restart_search;
840 case POWER_STATE_TYPE_INTERNAL_ACPI:
841 dpm_state = POWER_STATE_TYPE_BATTERY;
842 goto restart_search;
843 case POWER_STATE_TYPE_BATTERY:
844 case POWER_STATE_TYPE_BALANCED:
845 case POWER_STATE_TYPE_INTERNAL_3DPERF:
846 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
847 goto restart_search;
848 default:
849 break;
850 }
851
852 return NULL;
853}
854
855static void amdgpu_dpm_change_power_state_locked(struct amdgpu_device *adev)
856{
857 int i;
858 struct amdgpu_ps *ps;
859 enum amd_pm_state_type dpm_state;
860 int ret;
861
862 /* if dpm init failed */
863 if (!adev->pm.dpm_enabled)
864 return;
865
866 if (adev->pm.dpm.user_state != adev->pm.dpm.state) {
867 /* add other state override checks here */
868 if ((!adev->pm.dpm.thermal_active) &&
869 (!adev->pm.dpm.uvd_active))
870 adev->pm.dpm.state = adev->pm.dpm.user_state;
871 }
872 dpm_state = adev->pm.dpm.state;
873
874 ps = amdgpu_dpm_pick_power_state(adev, dpm_state);
875 if (ps)
876 adev->pm.dpm.requested_ps = ps;
877 else
878 return;
879
880 /* no need to reprogram if nothing changed unless we are on BTC+ */
881 if (adev->pm.dpm.current_ps == adev->pm.dpm.requested_ps) {
882 /* vce just modifies an existing state so force a change */
883 if (ps->vce_active != adev->pm.dpm.vce_active)
884 goto force;
885 if (adev->flags & AMD_IS_APU) {
886 /* for APUs if the num crtcs changed but state is the same,
887 * all we need to do is update the display configuration.
888 */
889 if (adev->pm.dpm.new_active_crtcs != adev->pm.dpm.current_active_crtcs) {
890 /* update display watermarks based on new power state */
891 amdgpu_display_bandwidth_update(adev);
892 /* update displays */
893 amdgpu_dpm_display_configuration_changed(adev);
894 adev->pm.dpm.current_active_crtcs = adev->pm.dpm.new_active_crtcs;
895 adev->pm.dpm.current_active_crtc_count = adev->pm.dpm.new_active_crtc_count;
896 }
897 return;
898 } else {
899 /* for BTC+ if the num crtcs hasn't changed and state is the same,
900 * nothing to do, if the num crtcs is > 1 and state is the same,
901 * update display configuration.
902 */
903 if (adev->pm.dpm.new_active_crtcs ==
904 adev->pm.dpm.current_active_crtcs) {
905 return;
906 } else if ((adev->pm.dpm.current_active_crtc_count > 1) &&
907 (adev->pm.dpm.new_active_crtc_count > 1)) {
908 /* update display watermarks based on new power state */
909 amdgpu_display_bandwidth_update(adev);
910 /* update displays */
911 amdgpu_dpm_display_configuration_changed(adev);
912 adev->pm.dpm.current_active_crtcs = adev->pm.dpm.new_active_crtcs;
913 adev->pm.dpm.current_active_crtc_count = adev->pm.dpm.new_active_crtc_count;
914 return;
915 }
916 }
917 }
918
919force:
920 if (amdgpu_dpm == 1) {
921 printk("switching from power state:\n");
922 amdgpu_dpm_print_power_state(adev, adev->pm.dpm.current_ps);
923 printk("switching to power state:\n");
924 amdgpu_dpm_print_power_state(adev, adev->pm.dpm.requested_ps);
925 }
926
927 /* update whether vce is active */
928 ps->vce_active = adev->pm.dpm.vce_active;
929
930 ret = amdgpu_dpm_pre_set_power_state(adev);
931 if (ret)
932 return;
933
934 /* update display watermarks based on new power state */
935 amdgpu_display_bandwidth_update(adev);
936
937 /* wait for the rings to drain */
938 for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
939 struct amdgpu_ring *ring = adev->rings[i];
940 if (ring && ring->ready)
941 amdgpu_fence_wait_empty(ring);
942 }
943
944 /* program the new power state */
945 amdgpu_dpm_set_power_state(adev);
946
947 /* update current power state */
948 adev->pm.dpm.current_ps = adev->pm.dpm.requested_ps;
949
950 amdgpu_dpm_post_set_power_state(adev);
951
952 /* update displays */
953 amdgpu_dpm_display_configuration_changed(adev);
954
955 adev->pm.dpm.current_active_crtcs = adev->pm.dpm.new_active_crtcs;
956 adev->pm.dpm.current_active_crtc_count = adev->pm.dpm.new_active_crtc_count;
957
958 if (adev->pm.funcs->force_performance_level) {
959 if (adev->pm.dpm.thermal_active) {
960 enum amdgpu_dpm_forced_level level = adev->pm.dpm.forced_level;
961 /* force low perf level for thermal */
962 amdgpu_dpm_force_performance_level(adev, AMDGPU_DPM_FORCED_LEVEL_LOW);
963 /* save the user's level */
964 adev->pm.dpm.forced_level = level;
965 } else {
966 /* otherwise, user selected level */
967 amdgpu_dpm_force_performance_level(adev, adev->pm.dpm.forced_level);
968 }
969 }
970}
971
972void amdgpu_dpm_enable_uvd(struct amdgpu_device *adev, bool enable)
973{
974 if (adev->pp_enabled)
975 amdgpu_dpm_powergate_uvd(adev, !enable);
976 else {
977 if (adev->pm.funcs->powergate_uvd) {
978 mutex_lock(&adev->pm.mutex);
979 /* enable/disable UVD */
980 amdgpu_dpm_powergate_uvd(adev, !enable);
981 mutex_unlock(&adev->pm.mutex);
982 } else {
983 if (enable) {
984 mutex_lock(&adev->pm.mutex);
985 adev->pm.dpm.uvd_active = true;
986 adev->pm.dpm.state = POWER_STATE_TYPE_INTERNAL_UVD;
987 mutex_unlock(&adev->pm.mutex);
988 } else {
989 mutex_lock(&adev->pm.mutex);
990 adev->pm.dpm.uvd_active = false;
991 mutex_unlock(&adev->pm.mutex);
992 }
993 amdgpu_pm_compute_clocks(adev);
994 }
995
996 }
997}
998
999void amdgpu_dpm_enable_vce(struct amdgpu_device *adev, bool enable)
1000{
1001 if (adev->pp_enabled)
1002 amdgpu_dpm_powergate_vce(adev, !enable);
1003 else {
1004 if (adev->pm.funcs->powergate_vce) {
1005 mutex_lock(&adev->pm.mutex);
1006 amdgpu_dpm_powergate_vce(adev, !enable);
1007 mutex_unlock(&adev->pm.mutex);
1008 } else {
1009 if (enable) {
1010 mutex_lock(&adev->pm.mutex);
1011 adev->pm.dpm.vce_active = true;
1012 /* XXX select vce level based on ring/task */
1013 adev->pm.dpm.vce_level = AMDGPU_VCE_LEVEL_AC_ALL;
1014 mutex_unlock(&adev->pm.mutex);
1015 } else {
1016 mutex_lock(&adev->pm.mutex);
1017 adev->pm.dpm.vce_active = false;
1018 mutex_unlock(&adev->pm.mutex);
1019 }
1020 amdgpu_pm_compute_clocks(adev);
1021 }
1022 }
1023}
1024
1025void amdgpu_pm_print_power_states(struct amdgpu_device *adev)
1026{
1027 int i;
1028
1029 if (adev->pp_enabled)
1030 /* TO DO */
1031 return;
1032
1033 for (i = 0; i < adev->pm.dpm.num_ps; i++)
1034 amdgpu_dpm_print_power_state(adev, &adev->pm.dpm.ps[i]);
1035
1036}
1037
1038int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
1039{
1040 int ret;
1041
1042 if (adev->pm.sysfs_initialized)
1043 return 0;
1044
1045 if (!adev->pp_enabled) {
1046 if (adev->pm.funcs->get_temperature == NULL)
1047 return 0;
1048 }
1049
1050 adev->pm.int_hwmon_dev = hwmon_device_register_with_groups(adev->dev,
1051 DRIVER_NAME, adev,
1052 hwmon_groups);
1053 if (IS_ERR(adev->pm.int_hwmon_dev)) {
1054 ret = PTR_ERR(adev->pm.int_hwmon_dev);
1055 dev_err(adev->dev,
1056 "Unable to register hwmon device: %d\n", ret);
1057 return ret;
1058 }
1059
1060 ret = device_create_file(adev->dev, &dev_attr_power_dpm_state);
1061 if (ret) {
1062 DRM_ERROR("failed to create device file for dpm state\n");
1063 return ret;
1064 }
1065 ret = device_create_file(adev->dev, &dev_attr_power_dpm_force_performance_level);
1066 if (ret) {
1067 DRM_ERROR("failed to create device file for dpm state\n");
1068 return ret;
1069 }
1070
1071 if (adev->pp_enabled) {
1072 ret = device_create_file(adev->dev, &dev_attr_pp_num_states);
1073 if (ret) {
1074 DRM_ERROR("failed to create device file pp_num_states\n");
1075 return ret;
1076 }
1077 ret = device_create_file(adev->dev, &dev_attr_pp_cur_state);
1078 if (ret) {
1079 DRM_ERROR("failed to create device file pp_cur_state\n");
1080 return ret;
1081 }
1082 ret = device_create_file(adev->dev, &dev_attr_pp_force_state);
1083 if (ret) {
1084 DRM_ERROR("failed to create device file pp_force_state\n");
1085 return ret;
1086 }
1087 ret = device_create_file(adev->dev, &dev_attr_pp_table);
1088 if (ret) {
1089 DRM_ERROR("failed to create device file pp_table\n");
1090 return ret;
1091 }
1092 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_sclk);
1093 if (ret) {
1094 DRM_ERROR("failed to create device file pp_dpm_sclk\n");
1095 return ret;
1096 }
1097 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_mclk);
1098 if (ret) {
1099 DRM_ERROR("failed to create device file pp_dpm_mclk\n");
1100 return ret;
1101 }
1102 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_pcie);
1103 if (ret) {
1104 DRM_ERROR("failed to create device file pp_dpm_pcie\n");
1105 return ret;
1106 }
1107 }
1108 ret = amdgpu_debugfs_pm_init(adev);
1109 if (ret) {
1110 DRM_ERROR("Failed to register debugfs file for dpm!\n");
1111 return ret;
1112 }
1113
1114 adev->pm.sysfs_initialized = true;
1115
1116 return 0;
1117}
1118
1119void amdgpu_pm_sysfs_fini(struct amdgpu_device *adev)
1120{
1121 if (adev->pm.int_hwmon_dev)
1122 hwmon_device_unregister(adev->pm.int_hwmon_dev);
1123 device_remove_file(adev->dev, &dev_attr_power_dpm_state);
1124 device_remove_file(adev->dev, &dev_attr_power_dpm_force_performance_level);
1125 if (adev->pp_enabled) {
1126 device_remove_file(adev->dev, &dev_attr_pp_num_states);
1127 device_remove_file(adev->dev, &dev_attr_pp_cur_state);
1128 device_remove_file(adev->dev, &dev_attr_pp_force_state);
1129 device_remove_file(adev->dev, &dev_attr_pp_table);
1130 device_remove_file(adev->dev, &dev_attr_pp_dpm_sclk);
1131 device_remove_file(adev->dev, &dev_attr_pp_dpm_mclk);
1132 device_remove_file(adev->dev, &dev_attr_pp_dpm_pcie);
1133 }
1134}
1135
1136void amdgpu_pm_compute_clocks(struct amdgpu_device *adev)
1137{
1138 struct drm_device *ddev = adev->ddev;
1139 struct drm_crtc *crtc;
1140 struct amdgpu_crtc *amdgpu_crtc;
1141
1142 if (!adev->pm.dpm_enabled)
1143 return;
1144
1145 if (adev->pp_enabled) {
1146 int i = 0;
1147
1148 amdgpu_display_bandwidth_update(adev);
1149 for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
1150 struct amdgpu_ring *ring = adev->rings[i];
1151 if (ring && ring->ready)
1152 amdgpu_fence_wait_empty(ring);
1153 }
1154
1155 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE, NULL, NULL);
1156 } else {
1157 mutex_lock(&adev->pm.mutex);
1158 adev->pm.dpm.new_active_crtcs = 0;
1159 adev->pm.dpm.new_active_crtc_count = 0;
1160 if (adev->mode_info.num_crtc && adev->mode_info.mode_config_initialized) {
1161 list_for_each_entry(crtc,
1162 &ddev->mode_config.crtc_list, head) {
1163 amdgpu_crtc = to_amdgpu_crtc(crtc);
1164 if (crtc->enabled) {
1165 adev->pm.dpm.new_active_crtcs |= (1 << amdgpu_crtc->crtc_id);
1166 adev->pm.dpm.new_active_crtc_count++;
1167 }
1168 }
1169 }
1170 /* update battery/ac status */
1171 if (power_supply_is_system_supplied() > 0)
1172 adev->pm.dpm.ac_power = true;
1173 else
1174 adev->pm.dpm.ac_power = false;
1175
1176 amdgpu_dpm_change_power_state_locked(adev);
1177
1178 mutex_unlock(&adev->pm.mutex);
1179 }
1180}
1181
1182/*
1183 * Debugfs info
1184 */
1185#if defined(CONFIG_DEBUG_FS)
1186
1187static int amdgpu_debugfs_pm_info(struct seq_file *m, void *data)
1188{
1189 struct drm_info_node *node = (struct drm_info_node *) m->private;
1190 struct drm_device *dev = node->minor->dev;
1191 struct amdgpu_device *adev = dev->dev_private;
1192 struct drm_device *ddev = adev->ddev;
1193
1194 if (!adev->pm.dpm_enabled) {
1195 seq_printf(m, "dpm not enabled\n");
1196 return 0;
1197 }
1198 if ((adev->flags & AMD_IS_PX) &&
1199 (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) {
1200 seq_printf(m, "PX asic powered off\n");
1201 } else if (adev->pp_enabled) {
1202 amdgpu_dpm_debugfs_print_current_performance_level(adev, m);
1203 } else {
1204 mutex_lock(&adev->pm.mutex);
1205 if (adev->pm.funcs->debugfs_print_current_performance_level)
1206 amdgpu_dpm_debugfs_print_current_performance_level(adev, m);
1207 else
1208 seq_printf(m, "Debugfs support not implemented for this asic\n");
1209 mutex_unlock(&adev->pm.mutex);
1210 }
1211
1212 return 0;
1213}
1214
1215static struct drm_info_list amdgpu_pm_info_list[] = {
1216 {"amdgpu_pm_info", amdgpu_debugfs_pm_info, 0, NULL},
1217};
1218#endif
1219
1220static int amdgpu_debugfs_pm_init(struct amdgpu_device *adev)
1221{
1222#if defined(CONFIG_DEBUG_FS)
1223 return amdgpu_debugfs_add_files(adev, amdgpu_pm_info_list, ARRAY_SIZE(amdgpu_pm_info_list));
1224#else
1225 return 0;
1226#endif
1227}
1/*
2 * Permission is hereby granted, free of charge, to any person obtaining a
3 * copy of this software and associated documentation files (the "Software"),
4 * to deal in the Software without restriction, including without limitation
5 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
6 * and/or sell copies of the Software, and to permit persons to whom the
7 * Software is furnished to do so, subject to the following conditions:
8 *
9 * The above copyright notice and this permission notice shall be included in
10 * all copies or substantial portions of the Software.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
16 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
17 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
18 * OTHER DEALINGS IN THE SOFTWARE.
19 *
20 * Authors: Rafał Miłecki <zajec5@gmail.com>
21 * Alex Deucher <alexdeucher@gmail.com>
22 */
23#include <drm/drmP.h>
24#include "amdgpu.h"
25#include "amdgpu_drv.h"
26#include "amdgpu_pm.h"
27#include "amdgpu_dpm.h"
28#include "atom.h"
29#include <linux/power_supply.h>
30#include <linux/hwmon.h>
31#include <linux/hwmon-sysfs.h>
32
33#include "amd_powerplay.h"
34
35static int amdgpu_debugfs_pm_init(struct amdgpu_device *adev);
36
37void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev)
38{
39 if (adev->pp_enabled)
40 /* TODO */
41 return;
42
43 if (adev->pm.dpm_enabled) {
44 mutex_lock(&adev->pm.mutex);
45 if (power_supply_is_system_supplied() > 0)
46 adev->pm.dpm.ac_power = true;
47 else
48 adev->pm.dpm.ac_power = false;
49 if (adev->pm.funcs->enable_bapm)
50 amdgpu_dpm_enable_bapm(adev, adev->pm.dpm.ac_power);
51 mutex_unlock(&adev->pm.mutex);
52 }
53}
54
55static ssize_t amdgpu_get_dpm_state(struct device *dev,
56 struct device_attribute *attr,
57 char *buf)
58{
59 struct drm_device *ddev = dev_get_drvdata(dev);
60 struct amdgpu_device *adev = ddev->dev_private;
61 enum amd_pm_state_type pm;
62
63 if (adev->pp_enabled) {
64 pm = amdgpu_dpm_get_current_power_state(adev);
65 } else
66 pm = adev->pm.dpm.user_state;
67
68 return snprintf(buf, PAGE_SIZE, "%s\n",
69 (pm == POWER_STATE_TYPE_BATTERY) ? "battery" :
70 (pm == POWER_STATE_TYPE_BALANCED) ? "balanced" : "performance");
71}
72
73static ssize_t amdgpu_set_dpm_state(struct device *dev,
74 struct device_attribute *attr,
75 const char *buf,
76 size_t count)
77{
78 struct drm_device *ddev = dev_get_drvdata(dev);
79 struct amdgpu_device *adev = ddev->dev_private;
80 enum amd_pm_state_type state;
81
82 if (strncmp("battery", buf, strlen("battery")) == 0)
83 state = POWER_STATE_TYPE_BATTERY;
84 else if (strncmp("balanced", buf, strlen("balanced")) == 0)
85 state = POWER_STATE_TYPE_BALANCED;
86 else if (strncmp("performance", buf, strlen("performance")) == 0)
87 state = POWER_STATE_TYPE_PERFORMANCE;
88 else {
89 count = -EINVAL;
90 goto fail;
91 }
92
93 if (adev->pp_enabled) {
94 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
95 } else {
96 mutex_lock(&adev->pm.mutex);
97 adev->pm.dpm.user_state = state;
98 mutex_unlock(&adev->pm.mutex);
99
100 /* Can't set dpm state when the card is off */
101 if (!(adev->flags & AMD_IS_PX) ||
102 (ddev->switch_power_state == DRM_SWITCH_POWER_ON))
103 amdgpu_pm_compute_clocks(adev);
104 }
105fail:
106 return count;
107}
108
109static ssize_t amdgpu_get_dpm_forced_performance_level(struct device *dev,
110 struct device_attribute *attr,
111 char *buf)
112{
113 struct drm_device *ddev = dev_get_drvdata(dev);
114 struct amdgpu_device *adev = ddev->dev_private;
115
116 if ((adev->flags & AMD_IS_PX) &&
117 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
118 return snprintf(buf, PAGE_SIZE, "off\n");
119
120 if (adev->pp_enabled) {
121 enum amd_dpm_forced_level level;
122
123 level = amdgpu_dpm_get_performance_level(adev);
124 return snprintf(buf, PAGE_SIZE, "%s\n",
125 (level == AMD_DPM_FORCED_LEVEL_AUTO) ? "auto" :
126 (level == AMD_DPM_FORCED_LEVEL_LOW) ? "low" :
127 (level == AMD_DPM_FORCED_LEVEL_HIGH) ? "high" :
128 (level == AMD_DPM_FORCED_LEVEL_MANUAL) ? "manual" : "unknown");
129 } else {
130 enum amdgpu_dpm_forced_level level;
131
132 level = adev->pm.dpm.forced_level;
133 return snprintf(buf, PAGE_SIZE, "%s\n",
134 (level == AMDGPU_DPM_FORCED_LEVEL_AUTO) ? "auto" :
135 (level == AMDGPU_DPM_FORCED_LEVEL_LOW) ? "low" : "high");
136 }
137}
138
139static ssize_t amdgpu_set_dpm_forced_performance_level(struct device *dev,
140 struct device_attribute *attr,
141 const char *buf,
142 size_t count)
143{
144 struct drm_device *ddev = dev_get_drvdata(dev);
145 struct amdgpu_device *adev = ddev->dev_private;
146 enum amdgpu_dpm_forced_level level;
147 int ret = 0;
148
149 /* Can't force performance level when the card is off */
150 if ((adev->flags & AMD_IS_PX) &&
151 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
152 return -EINVAL;
153
154 if (strncmp("low", buf, strlen("low")) == 0) {
155 level = AMDGPU_DPM_FORCED_LEVEL_LOW;
156 } else if (strncmp("high", buf, strlen("high")) == 0) {
157 level = AMDGPU_DPM_FORCED_LEVEL_HIGH;
158 } else if (strncmp("auto", buf, strlen("auto")) == 0) {
159 level = AMDGPU_DPM_FORCED_LEVEL_AUTO;
160 } else if (strncmp("manual", buf, strlen("manual")) == 0) {
161 level = AMDGPU_DPM_FORCED_LEVEL_MANUAL;
162 } else {
163 count = -EINVAL;
164 goto fail;
165 }
166
167 if (adev->pp_enabled)
168 amdgpu_dpm_force_performance_level(adev, level);
169 else {
170 mutex_lock(&adev->pm.mutex);
171 if (adev->pm.dpm.thermal_active) {
172 count = -EINVAL;
173 mutex_unlock(&adev->pm.mutex);
174 goto fail;
175 }
176 ret = amdgpu_dpm_force_performance_level(adev, level);
177 if (ret)
178 count = -EINVAL;
179 else
180 adev->pm.dpm.forced_level = level;
181 mutex_unlock(&adev->pm.mutex);
182 }
183fail:
184 return count;
185}
186
187static ssize_t amdgpu_get_pp_num_states(struct device *dev,
188 struct device_attribute *attr,
189 char *buf)
190{
191 struct drm_device *ddev = dev_get_drvdata(dev);
192 struct amdgpu_device *adev = ddev->dev_private;
193 struct pp_states_info data;
194 int i, buf_len;
195
196 if (adev->pp_enabled)
197 amdgpu_dpm_get_pp_num_states(adev, &data);
198
199 buf_len = snprintf(buf, PAGE_SIZE, "states: %d\n", data.nums);
200 for (i = 0; i < data.nums; i++)
201 buf_len += snprintf(buf + buf_len, PAGE_SIZE, "%d %s\n", i,
202 (data.states[i] == POWER_STATE_TYPE_INTERNAL_BOOT) ? "boot" :
203 (data.states[i] == POWER_STATE_TYPE_BATTERY) ? "battery" :
204 (data.states[i] == POWER_STATE_TYPE_BALANCED) ? "balanced" :
205 (data.states[i] == POWER_STATE_TYPE_PERFORMANCE) ? "performance" : "default");
206
207 return buf_len;
208}
209
210static ssize_t amdgpu_get_pp_cur_state(struct device *dev,
211 struct device_attribute *attr,
212 char *buf)
213{
214 struct drm_device *ddev = dev_get_drvdata(dev);
215 struct amdgpu_device *adev = ddev->dev_private;
216 struct pp_states_info data;
217 enum amd_pm_state_type pm = 0;
218 int i = 0;
219
220 if (adev->pp_enabled) {
221
222 pm = amdgpu_dpm_get_current_power_state(adev);
223 amdgpu_dpm_get_pp_num_states(adev, &data);
224
225 for (i = 0; i < data.nums; i++) {
226 if (pm == data.states[i])
227 break;
228 }
229
230 if (i == data.nums)
231 i = -EINVAL;
232 }
233
234 return snprintf(buf, PAGE_SIZE, "%d\n", i);
235}
236
237static ssize_t amdgpu_get_pp_force_state(struct device *dev,
238 struct device_attribute *attr,
239 char *buf)
240{
241 struct drm_device *ddev = dev_get_drvdata(dev);
242 struct amdgpu_device *adev = ddev->dev_private;
243 struct pp_states_info data;
244 enum amd_pm_state_type pm = 0;
245 int i;
246
247 if (adev->pp_force_state_enabled && adev->pp_enabled) {
248 pm = amdgpu_dpm_get_current_power_state(adev);
249 amdgpu_dpm_get_pp_num_states(adev, &data);
250
251 for (i = 0; i < data.nums; i++) {
252 if (pm == data.states[i])
253 break;
254 }
255
256 if (i == data.nums)
257 i = -EINVAL;
258
259 return snprintf(buf, PAGE_SIZE, "%d\n", i);
260
261 } else
262 return snprintf(buf, PAGE_SIZE, "\n");
263}
264
265static ssize_t amdgpu_set_pp_force_state(struct device *dev,
266 struct device_attribute *attr,
267 const char *buf,
268 size_t count)
269{
270 struct drm_device *ddev = dev_get_drvdata(dev);
271 struct amdgpu_device *adev = ddev->dev_private;
272 enum amd_pm_state_type state = 0;
273 unsigned long idx;
274 int ret;
275
276 if (strlen(buf) == 1)
277 adev->pp_force_state_enabled = false;
278 else if (adev->pp_enabled) {
279 struct pp_states_info data;
280
281 ret = kstrtoul(buf, 0, &idx);
282 if (ret || idx >= ARRAY_SIZE(data.states)) {
283 count = -EINVAL;
284 goto fail;
285 }
286
287 amdgpu_dpm_get_pp_num_states(adev, &data);
288 state = data.states[idx];
289 /* only set user selected power states */
290 if (state != POWER_STATE_TYPE_INTERNAL_BOOT &&
291 state != POWER_STATE_TYPE_DEFAULT) {
292 amdgpu_dpm_dispatch_task(adev,
293 AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
294 adev->pp_force_state_enabled = true;
295 }
296 }
297fail:
298 return count;
299}
300
301static ssize_t amdgpu_get_pp_table(struct device *dev,
302 struct device_attribute *attr,
303 char *buf)
304{
305 struct drm_device *ddev = dev_get_drvdata(dev);
306 struct amdgpu_device *adev = ddev->dev_private;
307 char *table = NULL;
308 int size;
309
310 if (adev->pp_enabled)
311 size = amdgpu_dpm_get_pp_table(adev, &table);
312 else
313 return 0;
314
315 if (size >= PAGE_SIZE)
316 size = PAGE_SIZE - 1;
317
318 memcpy(buf, table, size);
319
320 return size;
321}
322
323static ssize_t amdgpu_set_pp_table(struct device *dev,
324 struct device_attribute *attr,
325 const char *buf,
326 size_t count)
327{
328 struct drm_device *ddev = dev_get_drvdata(dev);
329 struct amdgpu_device *adev = ddev->dev_private;
330
331 if (adev->pp_enabled)
332 amdgpu_dpm_set_pp_table(adev, buf, count);
333
334 return count;
335}
336
337static ssize_t amdgpu_get_pp_dpm_sclk(struct device *dev,
338 struct device_attribute *attr,
339 char *buf)
340{
341 struct drm_device *ddev = dev_get_drvdata(dev);
342 struct amdgpu_device *adev = ddev->dev_private;
343 ssize_t size = 0;
344
345 if (adev->pp_enabled)
346 size = amdgpu_dpm_print_clock_levels(adev, PP_SCLK, buf);
347 else if (adev->pm.funcs->print_clock_levels)
348 size = adev->pm.funcs->print_clock_levels(adev, PP_SCLK, buf);
349
350 return size;
351}
352
353static ssize_t amdgpu_set_pp_dpm_sclk(struct device *dev,
354 struct device_attribute *attr,
355 const char *buf,
356 size_t count)
357{
358 struct drm_device *ddev = dev_get_drvdata(dev);
359 struct amdgpu_device *adev = ddev->dev_private;
360 int ret;
361 long level;
362 uint32_t i, mask = 0;
363 char sub_str[2];
364
365 for (i = 0; i < strlen(buf); i++) {
366 if (*(buf + i) == '\n')
367 continue;
368 sub_str[0] = *(buf + i);
369 sub_str[1] = '\0';
370 ret = kstrtol(sub_str, 0, &level);
371
372 if (ret) {
373 count = -EINVAL;
374 goto fail;
375 }
376 mask |= 1 << level;
377 }
378
379 if (adev->pp_enabled)
380 amdgpu_dpm_force_clock_level(adev, PP_SCLK, mask);
381 else if (adev->pm.funcs->force_clock_level)
382 adev->pm.funcs->force_clock_level(adev, PP_SCLK, mask);
383fail:
384 return count;
385}
386
387static ssize_t amdgpu_get_pp_dpm_mclk(struct device *dev,
388 struct device_attribute *attr,
389 char *buf)
390{
391 struct drm_device *ddev = dev_get_drvdata(dev);
392 struct amdgpu_device *adev = ddev->dev_private;
393 ssize_t size = 0;
394
395 if (adev->pp_enabled)
396 size = amdgpu_dpm_print_clock_levels(adev, PP_MCLK, buf);
397 else if (adev->pm.funcs->print_clock_levels)
398 size = adev->pm.funcs->print_clock_levels(adev, PP_MCLK, buf);
399
400 return size;
401}
402
403static ssize_t amdgpu_set_pp_dpm_mclk(struct device *dev,
404 struct device_attribute *attr,
405 const char *buf,
406 size_t count)
407{
408 struct drm_device *ddev = dev_get_drvdata(dev);
409 struct amdgpu_device *adev = ddev->dev_private;
410 int ret;
411 long level;
412 uint32_t i, mask = 0;
413 char sub_str[2];
414
415 for (i = 0; i < strlen(buf); i++) {
416 if (*(buf + i) == '\n')
417 continue;
418 sub_str[0] = *(buf + i);
419 sub_str[1] = '\0';
420 ret = kstrtol(sub_str, 0, &level);
421
422 if (ret) {
423 count = -EINVAL;
424 goto fail;
425 }
426 mask |= 1 << level;
427 }
428
429 if (adev->pp_enabled)
430 amdgpu_dpm_force_clock_level(adev, PP_MCLK, mask);
431 else if (adev->pm.funcs->force_clock_level)
432 adev->pm.funcs->force_clock_level(adev, PP_MCLK, mask);
433fail:
434 return count;
435}
436
437static ssize_t amdgpu_get_pp_dpm_pcie(struct device *dev,
438 struct device_attribute *attr,
439 char *buf)
440{
441 struct drm_device *ddev = dev_get_drvdata(dev);
442 struct amdgpu_device *adev = ddev->dev_private;
443 ssize_t size = 0;
444
445 if (adev->pp_enabled)
446 size = amdgpu_dpm_print_clock_levels(adev, PP_PCIE, buf);
447 else if (adev->pm.funcs->print_clock_levels)
448 size = adev->pm.funcs->print_clock_levels(adev, PP_PCIE, buf);
449
450 return size;
451}
452
453static ssize_t amdgpu_set_pp_dpm_pcie(struct device *dev,
454 struct device_attribute *attr,
455 const char *buf,
456 size_t count)
457{
458 struct drm_device *ddev = dev_get_drvdata(dev);
459 struct amdgpu_device *adev = ddev->dev_private;
460 int ret;
461 long level;
462 uint32_t i, mask = 0;
463 char sub_str[2];
464
465 for (i = 0; i < strlen(buf); i++) {
466 if (*(buf + i) == '\n')
467 continue;
468 sub_str[0] = *(buf + i);
469 sub_str[1] = '\0';
470 ret = kstrtol(sub_str, 0, &level);
471
472 if (ret) {
473 count = -EINVAL;
474 goto fail;
475 }
476 mask |= 1 << level;
477 }
478
479 if (adev->pp_enabled)
480 amdgpu_dpm_force_clock_level(adev, PP_PCIE, mask);
481 else if (adev->pm.funcs->force_clock_level)
482 adev->pm.funcs->force_clock_level(adev, PP_PCIE, mask);
483fail:
484 return count;
485}
486
487static ssize_t amdgpu_get_pp_sclk_od(struct device *dev,
488 struct device_attribute *attr,
489 char *buf)
490{
491 struct drm_device *ddev = dev_get_drvdata(dev);
492 struct amdgpu_device *adev = ddev->dev_private;
493 uint32_t value = 0;
494
495 if (adev->pp_enabled)
496 value = amdgpu_dpm_get_sclk_od(adev);
497 else if (adev->pm.funcs->get_sclk_od)
498 value = adev->pm.funcs->get_sclk_od(adev);
499
500 return snprintf(buf, PAGE_SIZE, "%d\n", value);
501}
502
503static ssize_t amdgpu_set_pp_sclk_od(struct device *dev,
504 struct device_attribute *attr,
505 const char *buf,
506 size_t count)
507{
508 struct drm_device *ddev = dev_get_drvdata(dev);
509 struct amdgpu_device *adev = ddev->dev_private;
510 int ret;
511 long int value;
512
513 ret = kstrtol(buf, 0, &value);
514
515 if (ret) {
516 count = -EINVAL;
517 goto fail;
518 }
519
520 if (adev->pp_enabled) {
521 amdgpu_dpm_set_sclk_od(adev, (uint32_t)value);
522 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_READJUST_POWER_STATE, NULL, NULL);
523 } else if (adev->pm.funcs->set_sclk_od) {
524 adev->pm.funcs->set_sclk_od(adev, (uint32_t)value);
525 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
526 amdgpu_pm_compute_clocks(adev);
527 }
528
529fail:
530 return count;
531}
532
533static ssize_t amdgpu_get_pp_mclk_od(struct device *dev,
534 struct device_attribute *attr,
535 char *buf)
536{
537 struct drm_device *ddev = dev_get_drvdata(dev);
538 struct amdgpu_device *adev = ddev->dev_private;
539 uint32_t value = 0;
540
541 if (adev->pp_enabled)
542 value = amdgpu_dpm_get_mclk_od(adev);
543 else if (adev->pm.funcs->get_mclk_od)
544 value = adev->pm.funcs->get_mclk_od(adev);
545
546 return snprintf(buf, PAGE_SIZE, "%d\n", value);
547}
548
549static ssize_t amdgpu_set_pp_mclk_od(struct device *dev,
550 struct device_attribute *attr,
551 const char *buf,
552 size_t count)
553{
554 struct drm_device *ddev = dev_get_drvdata(dev);
555 struct amdgpu_device *adev = ddev->dev_private;
556 int ret;
557 long int value;
558
559 ret = kstrtol(buf, 0, &value);
560
561 if (ret) {
562 count = -EINVAL;
563 goto fail;
564 }
565
566 if (adev->pp_enabled) {
567 amdgpu_dpm_set_mclk_od(adev, (uint32_t)value);
568 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_READJUST_POWER_STATE, NULL, NULL);
569 } else if (adev->pm.funcs->set_mclk_od) {
570 adev->pm.funcs->set_mclk_od(adev, (uint32_t)value);
571 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
572 amdgpu_pm_compute_clocks(adev);
573 }
574
575fail:
576 return count;
577}
578
579static DEVICE_ATTR(power_dpm_state, S_IRUGO | S_IWUSR, amdgpu_get_dpm_state, amdgpu_set_dpm_state);
580static DEVICE_ATTR(power_dpm_force_performance_level, S_IRUGO | S_IWUSR,
581 amdgpu_get_dpm_forced_performance_level,
582 amdgpu_set_dpm_forced_performance_level);
583static DEVICE_ATTR(pp_num_states, S_IRUGO, amdgpu_get_pp_num_states, NULL);
584static DEVICE_ATTR(pp_cur_state, S_IRUGO, amdgpu_get_pp_cur_state, NULL);
585static DEVICE_ATTR(pp_force_state, S_IRUGO | S_IWUSR,
586 amdgpu_get_pp_force_state,
587 amdgpu_set_pp_force_state);
588static DEVICE_ATTR(pp_table, S_IRUGO | S_IWUSR,
589 amdgpu_get_pp_table,
590 amdgpu_set_pp_table);
591static DEVICE_ATTR(pp_dpm_sclk, S_IRUGO | S_IWUSR,
592 amdgpu_get_pp_dpm_sclk,
593 amdgpu_set_pp_dpm_sclk);
594static DEVICE_ATTR(pp_dpm_mclk, S_IRUGO | S_IWUSR,
595 amdgpu_get_pp_dpm_mclk,
596 amdgpu_set_pp_dpm_mclk);
597static DEVICE_ATTR(pp_dpm_pcie, S_IRUGO | S_IWUSR,
598 amdgpu_get_pp_dpm_pcie,
599 amdgpu_set_pp_dpm_pcie);
600static DEVICE_ATTR(pp_sclk_od, S_IRUGO | S_IWUSR,
601 amdgpu_get_pp_sclk_od,
602 amdgpu_set_pp_sclk_od);
603static DEVICE_ATTR(pp_mclk_od, S_IRUGO | S_IWUSR,
604 amdgpu_get_pp_mclk_od,
605 amdgpu_set_pp_mclk_od);
606
607static ssize_t amdgpu_hwmon_show_temp(struct device *dev,
608 struct device_attribute *attr,
609 char *buf)
610{
611 struct amdgpu_device *adev = dev_get_drvdata(dev);
612 struct drm_device *ddev = adev->ddev;
613 int temp;
614
615 /* Can't get temperature when the card is off */
616 if ((adev->flags & AMD_IS_PX) &&
617 (ddev->switch_power_state != DRM_SWITCH_POWER_ON))
618 return -EINVAL;
619
620 if (!adev->pp_enabled && !adev->pm.funcs->get_temperature)
621 temp = 0;
622 else
623 temp = amdgpu_dpm_get_temperature(adev);
624
625 return snprintf(buf, PAGE_SIZE, "%d\n", temp);
626}
627
628static ssize_t amdgpu_hwmon_show_temp_thresh(struct device *dev,
629 struct device_attribute *attr,
630 char *buf)
631{
632 struct amdgpu_device *adev = dev_get_drvdata(dev);
633 int hyst = to_sensor_dev_attr(attr)->index;
634 int temp;
635
636 if (hyst)
637 temp = adev->pm.dpm.thermal.min_temp;
638 else
639 temp = adev->pm.dpm.thermal.max_temp;
640
641 return snprintf(buf, PAGE_SIZE, "%d\n", temp);
642}
643
644static ssize_t amdgpu_hwmon_get_pwm1_enable(struct device *dev,
645 struct device_attribute *attr,
646 char *buf)
647{
648 struct amdgpu_device *adev = dev_get_drvdata(dev);
649 u32 pwm_mode = 0;
650
651 if (!adev->pp_enabled && !adev->pm.funcs->get_fan_control_mode)
652 return -EINVAL;
653
654 pwm_mode = amdgpu_dpm_get_fan_control_mode(adev);
655
656 /* never 0 (full-speed), fuse or smc-controlled always */
657 return sprintf(buf, "%i\n", pwm_mode == FDO_PWM_MODE_STATIC ? 1 : 2);
658}
659
660static ssize_t amdgpu_hwmon_set_pwm1_enable(struct device *dev,
661 struct device_attribute *attr,
662 const char *buf,
663 size_t count)
664{
665 struct amdgpu_device *adev = dev_get_drvdata(dev);
666 int err;
667 int value;
668
669 if (!adev->pp_enabled && !adev->pm.funcs->set_fan_control_mode)
670 return -EINVAL;
671
672 err = kstrtoint(buf, 10, &value);
673 if (err)
674 return err;
675
676 switch (value) {
677 case 1: /* manual, percent-based */
678 amdgpu_dpm_set_fan_control_mode(adev, FDO_PWM_MODE_STATIC);
679 break;
680 default: /* disable */
681 amdgpu_dpm_set_fan_control_mode(adev, 0);
682 break;
683 }
684
685 return count;
686}
687
688static ssize_t amdgpu_hwmon_get_pwm1_min(struct device *dev,
689 struct device_attribute *attr,
690 char *buf)
691{
692 return sprintf(buf, "%i\n", 0);
693}
694
695static ssize_t amdgpu_hwmon_get_pwm1_max(struct device *dev,
696 struct device_attribute *attr,
697 char *buf)
698{
699 return sprintf(buf, "%i\n", 255);
700}
701
702static ssize_t amdgpu_hwmon_set_pwm1(struct device *dev,
703 struct device_attribute *attr,
704 const char *buf, size_t count)
705{
706 struct amdgpu_device *adev = dev_get_drvdata(dev);
707 int err;
708 u32 value;
709
710 err = kstrtou32(buf, 10, &value);
711 if (err)
712 return err;
713
714 value = (value * 100) / 255;
715
716 err = amdgpu_dpm_set_fan_speed_percent(adev, value);
717 if (err)
718 return err;
719
720 return count;
721}
722
723static ssize_t amdgpu_hwmon_get_pwm1(struct device *dev,
724 struct device_attribute *attr,
725 char *buf)
726{
727 struct amdgpu_device *adev = dev_get_drvdata(dev);
728 int err;
729 u32 speed;
730
731 err = amdgpu_dpm_get_fan_speed_percent(adev, &speed);
732 if (err)
733 return err;
734
735 speed = (speed * 255) / 100;
736
737 return sprintf(buf, "%i\n", speed);
738}
739
740static ssize_t amdgpu_hwmon_get_fan1_input(struct device *dev,
741 struct device_attribute *attr,
742 char *buf)
743{
744 struct amdgpu_device *adev = dev_get_drvdata(dev);
745 int err;
746 u32 speed;
747
748 err = amdgpu_dpm_get_fan_speed_rpm(adev, &speed);
749 if (err)
750 return err;
751
752 return sprintf(buf, "%i\n", speed);
753}
754
755static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, amdgpu_hwmon_show_temp, NULL, 0);
756static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 0);
757static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 1);
758static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1, amdgpu_hwmon_set_pwm1, 0);
759static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1_enable, amdgpu_hwmon_set_pwm1_enable, 0);
760static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO, amdgpu_hwmon_get_pwm1_min, NULL, 0);
761static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO, amdgpu_hwmon_get_pwm1_max, NULL, 0);
762static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, amdgpu_hwmon_get_fan1_input, NULL, 0);
763
764static struct attribute *hwmon_attributes[] = {
765 &sensor_dev_attr_temp1_input.dev_attr.attr,
766 &sensor_dev_attr_temp1_crit.dev_attr.attr,
767 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
768 &sensor_dev_attr_pwm1.dev_attr.attr,
769 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
770 &sensor_dev_attr_pwm1_min.dev_attr.attr,
771 &sensor_dev_attr_pwm1_max.dev_attr.attr,
772 &sensor_dev_attr_fan1_input.dev_attr.attr,
773 NULL
774};
775
776static umode_t hwmon_attributes_visible(struct kobject *kobj,
777 struct attribute *attr, int index)
778{
779 struct device *dev = kobj_to_dev(kobj);
780 struct amdgpu_device *adev = dev_get_drvdata(dev);
781 umode_t effective_mode = attr->mode;
782
783 /* Skip limit attributes if DPM is not enabled */
784 if (!adev->pm.dpm_enabled &&
785 (attr == &sensor_dev_attr_temp1_crit.dev_attr.attr ||
786 attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr ||
787 attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
788 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
789 attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
790 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
791 return 0;
792
793 if (adev->pp_enabled)
794 return effective_mode;
795
796 /* Skip fan attributes if fan is not present */
797 if (adev->pm.no_fan &&
798 (attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
799 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
800 attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
801 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
802 return 0;
803
804 /* mask fan attributes if we have no bindings for this asic to expose */
805 if ((!adev->pm.funcs->get_fan_speed_percent &&
806 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't query fan */
807 (!adev->pm.funcs->get_fan_control_mode &&
808 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't query state */
809 effective_mode &= ~S_IRUGO;
810
811 if ((!adev->pm.funcs->set_fan_speed_percent &&
812 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't manage fan */
813 (!adev->pm.funcs->set_fan_control_mode &&
814 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't manage state */
815 effective_mode &= ~S_IWUSR;
816
817 /* hide max/min values if we can't both query and manage the fan */
818 if ((!adev->pm.funcs->set_fan_speed_percent &&
819 !adev->pm.funcs->get_fan_speed_percent) &&
820 (attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
821 attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
822 return 0;
823
824 /* requires powerplay */
825 if (attr == &sensor_dev_attr_fan1_input.dev_attr.attr)
826 return 0;
827
828 return effective_mode;
829}
830
831static const struct attribute_group hwmon_attrgroup = {
832 .attrs = hwmon_attributes,
833 .is_visible = hwmon_attributes_visible,
834};
835
836static const struct attribute_group *hwmon_groups[] = {
837 &hwmon_attrgroup,
838 NULL
839};
840
841void amdgpu_dpm_thermal_work_handler(struct work_struct *work)
842{
843 struct amdgpu_device *adev =
844 container_of(work, struct amdgpu_device,
845 pm.dpm.thermal.work);
846 /* switch to the thermal state */
847 enum amd_pm_state_type dpm_state = POWER_STATE_TYPE_INTERNAL_THERMAL;
848
849 if (!adev->pm.dpm_enabled)
850 return;
851
852 if (adev->pm.funcs->get_temperature) {
853 int temp = amdgpu_dpm_get_temperature(adev);
854
855 if (temp < adev->pm.dpm.thermal.min_temp)
856 /* switch back the user state */
857 dpm_state = adev->pm.dpm.user_state;
858 } else {
859 if (adev->pm.dpm.thermal.high_to_low)
860 /* switch back the user state */
861 dpm_state = adev->pm.dpm.user_state;
862 }
863 mutex_lock(&adev->pm.mutex);
864 if (dpm_state == POWER_STATE_TYPE_INTERNAL_THERMAL)
865 adev->pm.dpm.thermal_active = true;
866 else
867 adev->pm.dpm.thermal_active = false;
868 adev->pm.dpm.state = dpm_state;
869 mutex_unlock(&adev->pm.mutex);
870
871 amdgpu_pm_compute_clocks(adev);
872}
873
874static struct amdgpu_ps *amdgpu_dpm_pick_power_state(struct amdgpu_device *adev,
875 enum amd_pm_state_type dpm_state)
876{
877 int i;
878 struct amdgpu_ps *ps;
879 u32 ui_class;
880 bool single_display = (adev->pm.dpm.new_active_crtc_count < 2) ?
881 true : false;
882
883 /* check if the vblank period is too short to adjust the mclk */
884 if (single_display && adev->pm.funcs->vblank_too_short) {
885 if (amdgpu_dpm_vblank_too_short(adev))
886 single_display = false;
887 }
888
889 /* certain older asics have a separare 3D performance state,
890 * so try that first if the user selected performance
891 */
892 if (dpm_state == POWER_STATE_TYPE_PERFORMANCE)
893 dpm_state = POWER_STATE_TYPE_INTERNAL_3DPERF;
894 /* balanced states don't exist at the moment */
895 if (dpm_state == POWER_STATE_TYPE_BALANCED)
896 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
897
898restart_search:
899 /* Pick the best power state based on current conditions */
900 for (i = 0; i < adev->pm.dpm.num_ps; i++) {
901 ps = &adev->pm.dpm.ps[i];
902 ui_class = ps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK;
903 switch (dpm_state) {
904 /* user states */
905 case POWER_STATE_TYPE_BATTERY:
906 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BATTERY) {
907 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
908 if (single_display)
909 return ps;
910 } else
911 return ps;
912 }
913 break;
914 case POWER_STATE_TYPE_BALANCED:
915 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BALANCED) {
916 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
917 if (single_display)
918 return ps;
919 } else
920 return ps;
921 }
922 break;
923 case POWER_STATE_TYPE_PERFORMANCE:
924 if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE) {
925 if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) {
926 if (single_display)
927 return ps;
928 } else
929 return ps;
930 }
931 break;
932 /* internal states */
933 case POWER_STATE_TYPE_INTERNAL_UVD:
934 if (adev->pm.dpm.uvd_ps)
935 return adev->pm.dpm.uvd_ps;
936 else
937 break;
938 case POWER_STATE_TYPE_INTERNAL_UVD_SD:
939 if (ps->class & ATOM_PPLIB_CLASSIFICATION_SDSTATE)
940 return ps;
941 break;
942 case POWER_STATE_TYPE_INTERNAL_UVD_HD:
943 if (ps->class & ATOM_PPLIB_CLASSIFICATION_HDSTATE)
944 return ps;
945 break;
946 case POWER_STATE_TYPE_INTERNAL_UVD_HD2:
947 if (ps->class & ATOM_PPLIB_CLASSIFICATION_HD2STATE)
948 return ps;
949 break;
950 case POWER_STATE_TYPE_INTERNAL_UVD_MVC:
951 if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_MVC)
952 return ps;
953 break;
954 case POWER_STATE_TYPE_INTERNAL_BOOT:
955 return adev->pm.dpm.boot_ps;
956 case POWER_STATE_TYPE_INTERNAL_THERMAL:
957 if (ps->class & ATOM_PPLIB_CLASSIFICATION_THERMAL)
958 return ps;
959 break;
960 case POWER_STATE_TYPE_INTERNAL_ACPI:
961 if (ps->class & ATOM_PPLIB_CLASSIFICATION_ACPI)
962 return ps;
963 break;
964 case POWER_STATE_TYPE_INTERNAL_ULV:
965 if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_ULV)
966 return ps;
967 break;
968 case POWER_STATE_TYPE_INTERNAL_3DPERF:
969 if (ps->class & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
970 return ps;
971 break;
972 default:
973 break;
974 }
975 }
976 /* use a fallback state if we didn't match */
977 switch (dpm_state) {
978 case POWER_STATE_TYPE_INTERNAL_UVD_SD:
979 dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD;
980 goto restart_search;
981 case POWER_STATE_TYPE_INTERNAL_UVD_HD:
982 case POWER_STATE_TYPE_INTERNAL_UVD_HD2:
983 case POWER_STATE_TYPE_INTERNAL_UVD_MVC:
984 if (adev->pm.dpm.uvd_ps) {
985 return adev->pm.dpm.uvd_ps;
986 } else {
987 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
988 goto restart_search;
989 }
990 case POWER_STATE_TYPE_INTERNAL_THERMAL:
991 dpm_state = POWER_STATE_TYPE_INTERNAL_ACPI;
992 goto restart_search;
993 case POWER_STATE_TYPE_INTERNAL_ACPI:
994 dpm_state = POWER_STATE_TYPE_BATTERY;
995 goto restart_search;
996 case POWER_STATE_TYPE_BATTERY:
997 case POWER_STATE_TYPE_BALANCED:
998 case POWER_STATE_TYPE_INTERNAL_3DPERF:
999 dpm_state = POWER_STATE_TYPE_PERFORMANCE;
1000 goto restart_search;
1001 default:
1002 break;
1003 }
1004
1005 return NULL;
1006}
1007
1008static void amdgpu_dpm_change_power_state_locked(struct amdgpu_device *adev)
1009{
1010 struct amdgpu_ps *ps;
1011 enum amd_pm_state_type dpm_state;
1012 int ret;
1013 bool equal;
1014
1015 /* if dpm init failed */
1016 if (!adev->pm.dpm_enabled)
1017 return;
1018
1019 if (adev->pm.dpm.user_state != adev->pm.dpm.state) {
1020 /* add other state override checks here */
1021 if ((!adev->pm.dpm.thermal_active) &&
1022 (!adev->pm.dpm.uvd_active))
1023 adev->pm.dpm.state = adev->pm.dpm.user_state;
1024 }
1025 dpm_state = adev->pm.dpm.state;
1026
1027 ps = amdgpu_dpm_pick_power_state(adev, dpm_state);
1028 if (ps)
1029 adev->pm.dpm.requested_ps = ps;
1030 else
1031 return;
1032
1033 if (amdgpu_dpm == 1) {
1034 printk("switching from power state:\n");
1035 amdgpu_dpm_print_power_state(adev, adev->pm.dpm.current_ps);
1036 printk("switching to power state:\n");
1037 amdgpu_dpm_print_power_state(adev, adev->pm.dpm.requested_ps);
1038 }
1039
1040 /* update whether vce is active */
1041 ps->vce_active = adev->pm.dpm.vce_active;
1042
1043 amdgpu_dpm_display_configuration_changed(adev);
1044
1045 ret = amdgpu_dpm_pre_set_power_state(adev);
1046 if (ret)
1047 return;
1048
1049 if ((0 != amgdpu_dpm_check_state_equal(adev, adev->pm.dpm.current_ps, adev->pm.dpm.requested_ps, &equal)))
1050 equal = false;
1051
1052 if (equal)
1053 return;
1054
1055 amdgpu_dpm_set_power_state(adev);
1056 amdgpu_dpm_post_set_power_state(adev);
1057
1058 adev->pm.dpm.current_active_crtcs = adev->pm.dpm.new_active_crtcs;
1059 adev->pm.dpm.current_active_crtc_count = adev->pm.dpm.new_active_crtc_count;
1060
1061 if (adev->pm.funcs->force_performance_level) {
1062 if (adev->pm.dpm.thermal_active) {
1063 enum amdgpu_dpm_forced_level level = adev->pm.dpm.forced_level;
1064 /* force low perf level for thermal */
1065 amdgpu_dpm_force_performance_level(adev, AMDGPU_DPM_FORCED_LEVEL_LOW);
1066 /* save the user's level */
1067 adev->pm.dpm.forced_level = level;
1068 } else {
1069 /* otherwise, user selected level */
1070 amdgpu_dpm_force_performance_level(adev, adev->pm.dpm.forced_level);
1071 }
1072 }
1073}
1074
1075void amdgpu_dpm_enable_uvd(struct amdgpu_device *adev, bool enable)
1076{
1077 if (adev->pp_enabled || adev->pm.funcs->powergate_uvd) {
1078 /* enable/disable UVD */
1079 mutex_lock(&adev->pm.mutex);
1080 amdgpu_dpm_powergate_uvd(adev, !enable);
1081 mutex_unlock(&adev->pm.mutex);
1082 } else {
1083 if (enable) {
1084 mutex_lock(&adev->pm.mutex);
1085 adev->pm.dpm.uvd_active = true;
1086 adev->pm.dpm.state = POWER_STATE_TYPE_INTERNAL_UVD;
1087 mutex_unlock(&adev->pm.mutex);
1088 } else {
1089 mutex_lock(&adev->pm.mutex);
1090 adev->pm.dpm.uvd_active = false;
1091 mutex_unlock(&adev->pm.mutex);
1092 }
1093 amdgpu_pm_compute_clocks(adev);
1094 }
1095}
1096
1097void amdgpu_dpm_enable_vce(struct amdgpu_device *adev, bool enable)
1098{
1099 if (adev->pp_enabled || adev->pm.funcs->powergate_vce) {
1100 /* enable/disable VCE */
1101 mutex_lock(&adev->pm.mutex);
1102 amdgpu_dpm_powergate_vce(adev, !enable);
1103 mutex_unlock(&adev->pm.mutex);
1104 } else {
1105 if (enable) {
1106 mutex_lock(&adev->pm.mutex);
1107 adev->pm.dpm.vce_active = true;
1108 /* XXX select vce level based on ring/task */
1109 adev->pm.dpm.vce_level = AMD_VCE_LEVEL_AC_ALL;
1110 mutex_unlock(&adev->pm.mutex);
1111 } else {
1112 mutex_lock(&adev->pm.mutex);
1113 adev->pm.dpm.vce_active = false;
1114 mutex_unlock(&adev->pm.mutex);
1115 }
1116 amdgpu_pm_compute_clocks(adev);
1117 }
1118}
1119
1120void amdgpu_pm_print_power_states(struct amdgpu_device *adev)
1121{
1122 int i;
1123
1124 if (adev->pp_enabled)
1125 /* TO DO */
1126 return;
1127
1128 for (i = 0; i < adev->pm.dpm.num_ps; i++)
1129 amdgpu_dpm_print_power_state(adev, &adev->pm.dpm.ps[i]);
1130
1131}
1132
1133int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
1134{
1135 int ret;
1136
1137 if (adev->pm.sysfs_initialized)
1138 return 0;
1139
1140 if (!adev->pp_enabled) {
1141 if (adev->pm.funcs->get_temperature == NULL)
1142 return 0;
1143 }
1144
1145 adev->pm.int_hwmon_dev = hwmon_device_register_with_groups(adev->dev,
1146 DRIVER_NAME, adev,
1147 hwmon_groups);
1148 if (IS_ERR(adev->pm.int_hwmon_dev)) {
1149 ret = PTR_ERR(adev->pm.int_hwmon_dev);
1150 dev_err(adev->dev,
1151 "Unable to register hwmon device: %d\n", ret);
1152 return ret;
1153 }
1154
1155 ret = device_create_file(adev->dev, &dev_attr_power_dpm_state);
1156 if (ret) {
1157 DRM_ERROR("failed to create device file for dpm state\n");
1158 return ret;
1159 }
1160 ret = device_create_file(adev->dev, &dev_attr_power_dpm_force_performance_level);
1161 if (ret) {
1162 DRM_ERROR("failed to create device file for dpm state\n");
1163 return ret;
1164 }
1165
1166 if (adev->pp_enabled) {
1167 ret = device_create_file(adev->dev, &dev_attr_pp_num_states);
1168 if (ret) {
1169 DRM_ERROR("failed to create device file pp_num_states\n");
1170 return ret;
1171 }
1172 ret = device_create_file(adev->dev, &dev_attr_pp_cur_state);
1173 if (ret) {
1174 DRM_ERROR("failed to create device file pp_cur_state\n");
1175 return ret;
1176 }
1177 ret = device_create_file(adev->dev, &dev_attr_pp_force_state);
1178 if (ret) {
1179 DRM_ERROR("failed to create device file pp_force_state\n");
1180 return ret;
1181 }
1182 ret = device_create_file(adev->dev, &dev_attr_pp_table);
1183 if (ret) {
1184 DRM_ERROR("failed to create device file pp_table\n");
1185 return ret;
1186 }
1187 }
1188
1189 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_sclk);
1190 if (ret) {
1191 DRM_ERROR("failed to create device file pp_dpm_sclk\n");
1192 return ret;
1193 }
1194 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_mclk);
1195 if (ret) {
1196 DRM_ERROR("failed to create device file pp_dpm_mclk\n");
1197 return ret;
1198 }
1199 ret = device_create_file(adev->dev, &dev_attr_pp_dpm_pcie);
1200 if (ret) {
1201 DRM_ERROR("failed to create device file pp_dpm_pcie\n");
1202 return ret;
1203 }
1204 ret = device_create_file(adev->dev, &dev_attr_pp_sclk_od);
1205 if (ret) {
1206 DRM_ERROR("failed to create device file pp_sclk_od\n");
1207 return ret;
1208 }
1209 ret = device_create_file(adev->dev, &dev_attr_pp_mclk_od);
1210 if (ret) {
1211 DRM_ERROR("failed to create device file pp_mclk_od\n");
1212 return ret;
1213 }
1214
1215 ret = amdgpu_debugfs_pm_init(adev);
1216 if (ret) {
1217 DRM_ERROR("Failed to register debugfs file for dpm!\n");
1218 return ret;
1219 }
1220
1221 adev->pm.sysfs_initialized = true;
1222
1223 return 0;
1224}
1225
1226void amdgpu_pm_sysfs_fini(struct amdgpu_device *adev)
1227{
1228 if (adev->pm.int_hwmon_dev)
1229 hwmon_device_unregister(adev->pm.int_hwmon_dev);
1230 device_remove_file(adev->dev, &dev_attr_power_dpm_state);
1231 device_remove_file(adev->dev, &dev_attr_power_dpm_force_performance_level);
1232 if (adev->pp_enabled) {
1233 device_remove_file(adev->dev, &dev_attr_pp_num_states);
1234 device_remove_file(adev->dev, &dev_attr_pp_cur_state);
1235 device_remove_file(adev->dev, &dev_attr_pp_force_state);
1236 device_remove_file(adev->dev, &dev_attr_pp_table);
1237 }
1238 device_remove_file(adev->dev, &dev_attr_pp_dpm_sclk);
1239 device_remove_file(adev->dev, &dev_attr_pp_dpm_mclk);
1240 device_remove_file(adev->dev, &dev_attr_pp_dpm_pcie);
1241 device_remove_file(adev->dev, &dev_attr_pp_sclk_od);
1242 device_remove_file(adev->dev, &dev_attr_pp_mclk_od);
1243}
1244
1245void amdgpu_pm_compute_clocks(struct amdgpu_device *adev)
1246{
1247 struct drm_device *ddev = adev->ddev;
1248 struct drm_crtc *crtc;
1249 struct amdgpu_crtc *amdgpu_crtc;
1250 int i = 0;
1251
1252 if (!adev->pm.dpm_enabled)
1253 return;
1254
1255 if (adev->mode_info.num_crtc)
1256 amdgpu_display_bandwidth_update(adev);
1257
1258 for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
1259 struct amdgpu_ring *ring = adev->rings[i];
1260 if (ring && ring->ready)
1261 amdgpu_fence_wait_empty(ring);
1262 }
1263
1264 if (adev->pp_enabled) {
1265 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE, NULL, NULL);
1266 } else {
1267 mutex_lock(&adev->pm.mutex);
1268 adev->pm.dpm.new_active_crtcs = 0;
1269 adev->pm.dpm.new_active_crtc_count = 0;
1270 if (adev->mode_info.num_crtc && adev->mode_info.mode_config_initialized) {
1271 list_for_each_entry(crtc,
1272 &ddev->mode_config.crtc_list, head) {
1273 amdgpu_crtc = to_amdgpu_crtc(crtc);
1274 if (crtc->enabled) {
1275 adev->pm.dpm.new_active_crtcs |= (1 << amdgpu_crtc->crtc_id);
1276 adev->pm.dpm.new_active_crtc_count++;
1277 }
1278 }
1279 }
1280 /* update battery/ac status */
1281 if (power_supply_is_system_supplied() > 0)
1282 adev->pm.dpm.ac_power = true;
1283 else
1284 adev->pm.dpm.ac_power = false;
1285
1286 amdgpu_dpm_change_power_state_locked(adev);
1287
1288 mutex_unlock(&adev->pm.mutex);
1289 }
1290}
1291
1292/*
1293 * Debugfs info
1294 */
1295#if defined(CONFIG_DEBUG_FS)
1296
1297static int amdgpu_debugfs_pm_info_pp(struct seq_file *m, struct amdgpu_device *adev)
1298{
1299 int32_t value;
1300
1301 /* sanity check PP is enabled */
1302 if (!(adev->powerplay.pp_funcs &&
1303 adev->powerplay.pp_funcs->read_sensor))
1304 return -EINVAL;
1305
1306 /* GPU Clocks */
1307 seq_printf(m, "GFX Clocks and Power:\n");
1308 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_GFX_MCLK, &value))
1309 seq_printf(m, "\t%u MHz (MCLK)\n", value/100);
1310 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_GFX_SCLK, &value))
1311 seq_printf(m, "\t%u MHz (SCLK)\n", value/100);
1312 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_VDDGFX, &value))
1313 seq_printf(m, "\t%u mV (VDDGFX)\n", value);
1314 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_VDDNB, &value))
1315 seq_printf(m, "\t%u mV (VDDNB)\n", value);
1316 seq_printf(m, "\n");
1317
1318 /* GPU Temp */
1319 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_GPU_TEMP, &value))
1320 seq_printf(m, "GPU Temperature: %u C\n", value/1000);
1321
1322 /* GPU Load */
1323 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_GPU_LOAD, &value))
1324 seq_printf(m, "GPU Load: %u %%\n", value);
1325 seq_printf(m, "\n");
1326
1327 /* UVD clocks */
1328 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_UVD_POWER, &value)) {
1329 if (!value) {
1330 seq_printf(m, "UVD: Disabled\n");
1331 } else {
1332 seq_printf(m, "UVD: Enabled\n");
1333 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_UVD_DCLK, &value))
1334 seq_printf(m, "\t%u MHz (DCLK)\n", value/100);
1335 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_UVD_VCLK, &value))
1336 seq_printf(m, "\t%u MHz (VCLK)\n", value/100);
1337 }
1338 }
1339 seq_printf(m, "\n");
1340
1341 /* VCE clocks */
1342 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_VCE_POWER, &value)) {
1343 if (!value) {
1344 seq_printf(m, "VCE: Disabled\n");
1345 } else {
1346 seq_printf(m, "VCE: Enabled\n");
1347 if (!amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_VCE_ECCLK, &value))
1348 seq_printf(m, "\t%u MHz (ECCLK)\n", value/100);
1349 }
1350 }
1351
1352 return 0;
1353}
1354
1355static int amdgpu_debugfs_pm_info(struct seq_file *m, void *data)
1356{
1357 struct drm_info_node *node = (struct drm_info_node *) m->private;
1358 struct drm_device *dev = node->minor->dev;
1359 struct amdgpu_device *adev = dev->dev_private;
1360 struct drm_device *ddev = adev->ddev;
1361
1362 if (!adev->pm.dpm_enabled) {
1363 seq_printf(m, "dpm not enabled\n");
1364 return 0;
1365 }
1366 if ((adev->flags & AMD_IS_PX) &&
1367 (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) {
1368 seq_printf(m, "PX asic powered off\n");
1369 } else if (adev->pp_enabled) {
1370 return amdgpu_debugfs_pm_info_pp(m, adev);
1371 } else {
1372 mutex_lock(&adev->pm.mutex);
1373 if (adev->pm.funcs->debugfs_print_current_performance_level)
1374 adev->pm.funcs->debugfs_print_current_performance_level(adev, m);
1375 else
1376 seq_printf(m, "Debugfs support not implemented for this asic\n");
1377 mutex_unlock(&adev->pm.mutex);
1378 }
1379
1380 return 0;
1381}
1382
1383static const struct drm_info_list amdgpu_pm_info_list[] = {
1384 {"amdgpu_pm_info", amdgpu_debugfs_pm_info, 0, NULL},
1385};
1386#endif
1387
1388static int amdgpu_debugfs_pm_init(struct amdgpu_device *adev)
1389{
1390#if defined(CONFIG_DEBUG_FS)
1391 return amdgpu_debugfs_add_files(adev, amdgpu_pm_info_list, ARRAY_SIZE(amdgpu_pm_info_list));
1392#else
1393 return 0;
1394#endif
1395}