2 * Copyright 2010 Red Hat Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
26 #include <linux/acpi.h>
28 #include <linux/power_supply.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
34 #include "nouveau_drm.h"
35 #include "nouveau_pm.h"
37 #include <subdev/gpio.h>
38 #include <subdev/timer.h>
39 #include <subdev/therm.h>
41 MODULE_PARM_DESC(perflvl
, "Performance level (default: boot)");
42 static char *nouveau_perflvl
;
43 module_param_named(perflvl
, nouveau_perflvl
, charp
, 0400);
45 MODULE_PARM_DESC(perflvl_wr
, "Allow perflvl changes (warning: dangerous!)");
46 static int nouveau_perflvl_wr
;
47 module_param_named(perflvl_wr
, nouveau_perflvl_wr
, int, 0400);
50 nouveau_pm_perflvl_aux(struct drm_device
*dev
, struct nouveau_pm_level
*perflvl
,
51 struct nouveau_pm_level
*a
, struct nouveau_pm_level
*b
)
53 struct nouveau_drm
*drm
= nouveau_drm(dev
);
54 struct nouveau_pm
*pm
= nouveau_pm(dev
);
55 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
58 /*XXX: not on all boards, we should control based on temperature
59 * on recent boards.. or maybe on some other factor we don't
62 if (therm
&& therm
->fan_set
&&
63 a
->fanspeed
&& b
->fanspeed
&& b
->fanspeed
> a
->fanspeed
) {
64 ret
= therm
->fan_set(therm
, perflvl
->fanspeed
);
65 if (ret
&& ret
!= -ENODEV
) {
66 NV_ERROR(drm
, "fanspeed set failed: %d\n", ret
);
70 if (pm
->voltage
.supported
&& pm
->voltage_set
) {
71 if (perflvl
->volt_min
&& b
->volt_min
> a
->volt_min
) {
72 ret
= pm
->voltage_set(dev
, perflvl
->volt_min
);
74 NV_ERROR(drm
, "voltage set failed: %d\n", ret
);
84 nouveau_pm_perflvl_set(struct drm_device
*dev
, struct nouveau_pm_level
*perflvl
)
86 struct nouveau_pm
*pm
= nouveau_pm(dev
);
90 if (perflvl
== pm
->cur
)
93 ret
= nouveau_pm_perflvl_aux(dev
, perflvl
, pm
->cur
, perflvl
);
97 state
= pm
->clocks_pre(dev
, perflvl
);
102 ret
= pm
->clocks_set(dev
, state
);
106 ret
= nouveau_pm_perflvl_aux(dev
, perflvl
, perflvl
, pm
->cur
);
114 /* restore the fan speed and voltage before leaving */
115 nouveau_pm_perflvl_aux(dev
, perflvl
, perflvl
, pm
->cur
);
120 nouveau_pm_trigger(struct drm_device
*dev
)
122 struct nouveau_drm
*drm
= nouveau_drm(dev
);
123 struct nouveau_timer
*ptimer
= nouveau_timer(drm
->device
);
124 struct nouveau_pm
*pm
= nouveau_pm(dev
);
125 struct nouveau_pm_profile
*profile
= NULL
;
126 struct nouveau_pm_level
*perflvl
= NULL
;
129 /* select power profile based on current power source */
130 if (power_supply_is_system_supplied())
131 profile
= pm
->profile_ac
;
133 profile
= pm
->profile_dc
;
135 if (profile
!= pm
->profile
) {
136 pm
->profile
->func
->fini(pm
->profile
);
137 pm
->profile
= profile
;
138 pm
->profile
->func
->init(pm
->profile
);
141 /* select performance level based on profile */
142 perflvl
= profile
->func
->select(profile
);
144 /* change perflvl, if necessary */
145 if (perflvl
!= pm
->cur
) {
146 u64 time0
= ptimer
->read(ptimer
);
148 NV_INFO(drm
, "setting performance level: %d", perflvl
->id
);
149 ret
= nouveau_pm_perflvl_set(dev
, perflvl
);
151 NV_INFO(drm
, "> reclocking failed: %d\n\n", ret
);
153 NV_INFO(drm
, "> reclocking took %lluns\n\n",
154 ptimer
->read(ptimer
) - time0
);
158 static struct nouveau_pm_profile
*
159 profile_find(struct drm_device
*dev
, const char *string
)
161 struct nouveau_pm
*pm
= nouveau_pm(dev
);
162 struct nouveau_pm_profile
*profile
;
164 list_for_each_entry(profile
, &pm
->profiles
, head
) {
165 if (!strncmp(profile
->name
, string
, sizeof(profile
->name
)))
173 nouveau_pm_profile_set(struct drm_device
*dev
, const char *profile
)
175 struct nouveau_pm
*pm
= nouveau_pm(dev
);
176 struct nouveau_pm_profile
*ac
= NULL
, *dc
= NULL
;
177 char string
[16], *cur
= string
, *ptr
;
179 /* safety precaution, for now */
180 if (nouveau_perflvl_wr
!= 7777)
183 strncpy(string
, profile
, sizeof(string
));
184 string
[sizeof(string
) - 1] = 0;
185 if ((ptr
= strchr(string
, '\n')))
188 ptr
= strsep(&cur
, ",");
190 ac
= profile_find(dev
, ptr
);
192 ptr
= strsep(&cur
, ",");
194 dc
= profile_find(dev
, ptr
);
198 if (ac
== NULL
|| dc
== NULL
)
203 nouveau_pm_trigger(dev
);
208 nouveau_pm_static_dummy(struct nouveau_pm_profile
*profile
)
212 static struct nouveau_pm_level
*
213 nouveau_pm_static_select(struct nouveau_pm_profile
*profile
)
215 return container_of(profile
, struct nouveau_pm_level
, profile
);
218 const struct nouveau_pm_profile_func nouveau_pm_static_profile_func
= {
219 .destroy
= nouveau_pm_static_dummy
,
220 .init
= nouveau_pm_static_dummy
,
221 .fini
= nouveau_pm_static_dummy
,
222 .select
= nouveau_pm_static_select
,
226 nouveau_pm_perflvl_get(struct drm_device
*dev
, struct nouveau_pm_level
*perflvl
)
228 struct nouveau_drm
*drm
= nouveau_drm(dev
);
229 struct nouveau_pm
*pm
= nouveau_pm(dev
);
230 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
233 memset(perflvl
, 0, sizeof(*perflvl
));
235 if (pm
->clocks_get
) {
236 ret
= pm
->clocks_get(dev
, perflvl
);
241 if (pm
->voltage
.supported
&& pm
->voltage_get
) {
242 ret
= pm
->voltage_get(dev
);
244 perflvl
->volt_min
= ret
;
245 perflvl
->volt_max
= ret
;
249 if (therm
&& therm
->fan_get
) {
250 ret
= therm
->fan_get(therm
);
252 perflvl
->fanspeed
= ret
;
255 nouveau_mem_timing_read(dev
, &perflvl
->timing
);
260 nouveau_pm_perflvl_info(struct nouveau_pm_level
*perflvl
, char *ptr
, int len
)
262 char c
[16], s
[16], v
[32], f
[16], m
[16];
266 snprintf(c
, sizeof(c
), " core %dMHz", perflvl
->core
/ 1000);
270 snprintf(s
, sizeof(s
), " shader %dMHz", perflvl
->shader
/ 1000);
274 snprintf(m
, sizeof(m
), " memory %dMHz", perflvl
->memory
/ 1000);
277 if (perflvl
->volt_min
&& perflvl
->volt_min
!= perflvl
->volt_max
) {
278 snprintf(v
, sizeof(v
), " voltage %dmV-%dmV",
279 perflvl
->volt_min
/ 1000, perflvl
->volt_max
/ 1000);
281 if (perflvl
->volt_min
) {
282 snprintf(v
, sizeof(v
), " voltage %dmV",
283 perflvl
->volt_min
/ 1000);
287 if (perflvl
->fanspeed
)
288 snprintf(f
, sizeof(f
), " fanspeed %d%%", perflvl
->fanspeed
);
290 snprintf(ptr
, len
, "%s%s%s%s%s\n", c
, s
, m
, v
, f
);
294 nouveau_pm_get_perflvl_info(struct device
*d
,
295 struct device_attribute
*a
, char *buf
)
297 struct nouveau_pm_level
*perflvl
=
298 container_of(a
, struct nouveau_pm_level
, dev_attr
);
302 snprintf(ptr
, len
, "%d:", perflvl
->id
);
306 nouveau_pm_perflvl_info(perflvl
, ptr
, len
);
311 nouveau_pm_get_perflvl(struct device
*d
, struct device_attribute
*a
, char *buf
)
313 struct drm_device
*dev
= pci_get_drvdata(to_pci_dev(d
));
314 struct nouveau_pm
*pm
= nouveau_pm(dev
);
315 struct nouveau_pm_level cur
;
316 int len
= PAGE_SIZE
, ret
;
319 snprintf(ptr
, len
, "profile: %s, %s\nc:",
320 pm
->profile_ac
->name
, pm
->profile_dc
->name
);
324 ret
= nouveau_pm_perflvl_get(dev
, &cur
);
326 nouveau_pm_perflvl_info(&cur
, ptr
, len
);
331 nouveau_pm_set_perflvl(struct device
*d
, struct device_attribute
*a
,
332 const char *buf
, size_t count
)
334 struct drm_device
*dev
= pci_get_drvdata(to_pci_dev(d
));
337 ret
= nouveau_pm_profile_set(dev
, buf
);
343 static DEVICE_ATTR(performance_level
, S_IRUGO
| S_IWUSR
,
344 nouveau_pm_get_perflvl
, nouveau_pm_set_perflvl
);
347 nouveau_sysfs_init(struct drm_device
*dev
)
349 struct nouveau_drm
*drm
= nouveau_drm(dev
);
350 struct nouveau_pm
*pm
= nouveau_pm(dev
);
351 struct device
*d
= &dev
->pdev
->dev
;
354 ret
= device_create_file(d
, &dev_attr_performance_level
);
358 for (i
= 0; i
< pm
->nr_perflvl
; i
++) {
359 struct nouveau_pm_level
*perflvl
= &pm
->perflvl
[i
];
361 perflvl
->dev_attr
.attr
.name
= perflvl
->name
;
362 perflvl
->dev_attr
.attr
.mode
= S_IRUGO
;
363 perflvl
->dev_attr
.show
= nouveau_pm_get_perflvl_info
;
364 perflvl
->dev_attr
.store
= NULL
;
365 sysfs_attr_init(&perflvl
->dev_attr
.attr
);
367 ret
= device_create_file(d
, &perflvl
->dev_attr
);
369 NV_ERROR(drm
, "failed pervlvl %d sysfs: %d\n",
371 perflvl
->dev_attr
.attr
.name
= NULL
;
372 nouveau_pm_fini(dev
);
381 nouveau_sysfs_fini(struct drm_device
*dev
)
383 struct nouveau_pm
*pm
= nouveau_pm(dev
);
384 struct device
*d
= &dev
->pdev
->dev
;
387 device_remove_file(d
, &dev_attr_performance_level
);
388 for (i
= 0; i
< pm
->nr_perflvl
; i
++) {
389 struct nouveau_pm_level
*pl
= &pm
->perflvl
[i
];
391 if (!pl
->dev_attr
.attr
.name
)
394 device_remove_file(d
, &pl
->dev_attr
);
398 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
400 nouveau_hwmon_show_temp(struct device
*d
, struct device_attribute
*a
, char *buf
)
402 struct drm_device
*dev
= dev_get_drvdata(d
);
403 struct nouveau_drm
*drm
= nouveau_drm(dev
);
404 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
406 return snprintf(buf
, PAGE_SIZE
, "%d\n", therm
->temp_get(therm
) * 1000);
408 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, nouveau_hwmon_show_temp
,
412 nouveau_hwmon_show_temp1_auto_point1_pwm(struct device
*d
,
413 struct device_attribute
*a
, char *buf
)
415 return snprintf(buf
, PAGE_SIZE
, "%d\n", 100);
417 static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm
, S_IRUGO
,
418 nouveau_hwmon_show_temp1_auto_point1_pwm
, NULL
, 0);
421 nouveau_hwmon_temp1_auto_point1_temp(struct device
*d
,
422 struct device_attribute
*a
, char *buf
)
424 struct drm_device
*dev
= dev_get_drvdata(d
);
425 struct nouveau_drm
*drm
= nouveau_drm(dev
);
426 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
428 return snprintf(buf
, PAGE_SIZE
, "%d\n",
429 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST
) * 1000);
432 nouveau_hwmon_set_temp1_auto_point1_temp(struct device
*d
,
433 struct device_attribute
*a
,
434 const char *buf
, size_t count
)
436 struct drm_device
*dev
= dev_get_drvdata(d
);
437 struct nouveau_drm
*drm
= nouveau_drm(dev
);
438 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
441 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
444 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST
,
449 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp
, S_IRUGO
| S_IWUSR
,
450 nouveau_hwmon_temp1_auto_point1_temp
,
451 nouveau_hwmon_set_temp1_auto_point1_temp
, 0);
454 nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device
*d
,
455 struct device_attribute
*a
, char *buf
)
457 struct drm_device
*dev
= dev_get_drvdata(d
);
458 struct nouveau_drm
*drm
= nouveau_drm(dev
);
459 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
461 return snprintf(buf
, PAGE_SIZE
, "%d\n",
462 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST
) * 1000);
465 nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device
*d
,
466 struct device_attribute
*a
,
467 const char *buf
, size_t count
)
469 struct drm_device
*dev
= dev_get_drvdata(d
);
470 struct nouveau_drm
*drm
= nouveau_drm(dev
);
471 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
474 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
477 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST
,
482 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst
, S_IRUGO
| S_IWUSR
,
483 nouveau_hwmon_temp1_auto_point1_temp_hyst
,
484 nouveau_hwmon_set_temp1_auto_point1_temp_hyst
, 0);
487 nouveau_hwmon_max_temp(struct device
*d
, struct device_attribute
*a
, char *buf
)
489 struct drm_device
*dev
= dev_get_drvdata(d
);
490 struct nouveau_drm
*drm
= nouveau_drm(dev
);
491 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
493 return snprintf(buf
, PAGE_SIZE
, "%d\n",
494 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK
) * 1000);
497 nouveau_hwmon_set_max_temp(struct device
*d
, struct device_attribute
*a
,
498 const char *buf
, size_t count
)
500 struct drm_device
*dev
= dev_get_drvdata(d
);
501 struct nouveau_drm
*drm
= nouveau_drm(dev
);
502 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
505 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
508 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK
, value
/ 1000);
512 static SENSOR_DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
, nouveau_hwmon_max_temp
,
513 nouveau_hwmon_set_max_temp
,
517 nouveau_hwmon_max_temp_hyst(struct device
*d
, struct device_attribute
*a
,
520 struct drm_device
*dev
= dev_get_drvdata(d
);
521 struct nouveau_drm
*drm
= nouveau_drm(dev
);
522 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
524 return snprintf(buf
, PAGE_SIZE
, "%d\n",
525 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST
) * 1000);
528 nouveau_hwmon_set_max_temp_hyst(struct device
*d
, struct device_attribute
*a
,
529 const char *buf
, size_t count
)
531 struct drm_device
*dev
= dev_get_drvdata(d
);
532 struct nouveau_drm
*drm
= nouveau_drm(dev
);
533 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
536 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
539 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST
,
544 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
545 nouveau_hwmon_max_temp_hyst
,
546 nouveau_hwmon_set_max_temp_hyst
, 0);
549 nouveau_hwmon_critical_temp(struct device
*d
, struct device_attribute
*a
,
552 struct drm_device
*dev
= dev_get_drvdata(d
);
553 struct nouveau_drm
*drm
= nouveau_drm(dev
);
554 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
556 return snprintf(buf
, PAGE_SIZE
, "%d\n",
557 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_CRITICAL
) * 1000);
560 nouveau_hwmon_set_critical_temp(struct device
*d
, struct device_attribute
*a
,
564 struct drm_device
*dev
= dev_get_drvdata(d
);
565 struct nouveau_drm
*drm
= nouveau_drm(dev
);
566 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
569 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
572 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_CRITICAL
, value
/ 1000);
576 static SENSOR_DEVICE_ATTR(temp1_crit
, S_IRUGO
| S_IWUSR
,
577 nouveau_hwmon_critical_temp
,
578 nouveau_hwmon_set_critical_temp
,
582 nouveau_hwmon_critical_temp_hyst(struct device
*d
, struct device_attribute
*a
,
585 struct drm_device
*dev
= dev_get_drvdata(d
);
586 struct nouveau_drm
*drm
= nouveau_drm(dev
);
587 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
589 return snprintf(buf
, PAGE_SIZE
, "%d\n",
590 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST
) * 1000);
593 nouveau_hwmon_set_critical_temp_hyst(struct device
*d
,
594 struct device_attribute
*a
,
598 struct drm_device
*dev
= dev_get_drvdata(d
);
599 struct nouveau_drm
*drm
= nouveau_drm(dev
);
600 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
603 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
606 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST
,
611 static SENSOR_DEVICE_ATTR(temp1_crit_hyst
, S_IRUGO
| S_IWUSR
,
612 nouveau_hwmon_critical_temp_hyst
,
613 nouveau_hwmon_set_critical_temp_hyst
, 0);
615 nouveau_hwmon_emergency_temp(struct device
*d
, struct device_attribute
*a
,
618 struct drm_device
*dev
= dev_get_drvdata(d
);
619 struct nouveau_drm
*drm
= nouveau_drm(dev
);
620 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
622 return snprintf(buf
, PAGE_SIZE
, "%d\n",
623 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN
) * 1000);
626 nouveau_hwmon_set_emergency_temp(struct device
*d
, struct device_attribute
*a
,
630 struct drm_device
*dev
= dev_get_drvdata(d
);
631 struct nouveau_drm
*drm
= nouveau_drm(dev
);
632 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
635 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
638 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN
, value
/ 1000);
642 static SENSOR_DEVICE_ATTR(temp1_emergency
, S_IRUGO
| S_IWUSR
,
643 nouveau_hwmon_emergency_temp
,
644 nouveau_hwmon_set_emergency_temp
,
648 nouveau_hwmon_emergency_temp_hyst(struct device
*d
, struct device_attribute
*a
,
651 struct drm_device
*dev
= dev_get_drvdata(d
);
652 struct nouveau_drm
*drm
= nouveau_drm(dev
);
653 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
655 return snprintf(buf
, PAGE_SIZE
, "%d\n",
656 therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST
) * 1000);
659 nouveau_hwmon_set_emergency_temp_hyst(struct device
*d
,
660 struct device_attribute
*a
,
664 struct drm_device
*dev
= dev_get_drvdata(d
);
665 struct nouveau_drm
*drm
= nouveau_drm(dev
);
666 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
669 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
672 therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST
,
677 static SENSOR_DEVICE_ATTR(temp1_emergency_hyst
, S_IRUGO
| S_IWUSR
,
678 nouveau_hwmon_emergency_temp_hyst
,
679 nouveau_hwmon_set_emergency_temp_hyst
,
682 static ssize_t
nouveau_hwmon_show_name(struct device
*dev
,
683 struct device_attribute
*attr
,
686 return sprintf(buf
, "nouveau\n");
688 static SENSOR_DEVICE_ATTR(name
, S_IRUGO
, nouveau_hwmon_show_name
, NULL
, 0);
690 static ssize_t
nouveau_hwmon_show_update_rate(struct device
*dev
,
691 struct device_attribute
*attr
,
694 return sprintf(buf
, "1000\n");
696 static SENSOR_DEVICE_ATTR(update_rate
, S_IRUGO
,
697 nouveau_hwmon_show_update_rate
,
701 nouveau_hwmon_show_fan1_input(struct device
*d
, struct device_attribute
*attr
,
704 struct drm_device
*dev
= dev_get_drvdata(d
);
705 struct nouveau_drm
*drm
= nouveau_drm(dev
);
706 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
708 return snprintf(buf
, PAGE_SIZE
, "%d\n", therm
->fan_sense(therm
));
710 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, nouveau_hwmon_show_fan1_input
,
714 nouveau_hwmon_get_pwm1_enable(struct device
*d
,
715 struct device_attribute
*a
, char *buf
)
717 struct drm_device
*dev
= dev_get_drvdata(d
);
718 struct nouveau_drm
*drm
= nouveau_drm(dev
);
719 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
722 ret
= therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_FAN_MODE
);
726 return sprintf(buf
, "%i\n", ret
);
730 nouveau_hwmon_set_pwm1_enable(struct device
*d
, struct device_attribute
*a
,
731 const char *buf
, size_t count
)
733 struct drm_device
*dev
= dev_get_drvdata(d
);
734 struct nouveau_drm
*drm
= nouveau_drm(dev
);
735 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
739 if (strict_strtol(buf
, 10, &value
) == -EINVAL
)
742 ret
= therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_FAN_MODE
, value
);
748 static SENSOR_DEVICE_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
749 nouveau_hwmon_get_pwm1_enable
,
750 nouveau_hwmon_set_pwm1_enable
, 0);
753 nouveau_hwmon_get_pwm1(struct device
*d
, struct device_attribute
*a
, char *buf
)
755 struct drm_device
*dev
= dev_get_drvdata(d
);
756 struct nouveau_drm
*drm
= nouveau_drm(dev
);
757 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
760 ret
= therm
->fan_get(therm
);
764 return sprintf(buf
, "%i\n", ret
);
768 nouveau_hwmon_set_pwm1(struct device
*d
, struct device_attribute
*a
,
769 const char *buf
, size_t count
)
771 struct drm_device
*dev
= dev_get_drvdata(d
);
772 struct nouveau_drm
*drm
= nouveau_drm(dev
);
773 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
777 if (nouveau_perflvl_wr
!= 7777)
780 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
783 ret
= therm
->fan_set(therm
, value
);
790 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
,
791 nouveau_hwmon_get_pwm1
,
792 nouveau_hwmon_set_pwm1
, 0);
795 nouveau_hwmon_get_pwm1_min(struct device
*d
,
796 struct device_attribute
*a
, char *buf
)
798 struct drm_device
*dev
= dev_get_drvdata(d
);
799 struct nouveau_drm
*drm
= nouveau_drm(dev
);
800 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
803 ret
= therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY
);
807 return sprintf(buf
, "%i\n", ret
);
811 nouveau_hwmon_set_pwm1_min(struct device
*d
, struct device_attribute
*a
,
812 const char *buf
, size_t count
)
814 struct drm_device
*dev
= dev_get_drvdata(d
);
815 struct nouveau_drm
*drm
= nouveau_drm(dev
);
816 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
820 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
823 ret
= therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY
, value
);
830 static SENSOR_DEVICE_ATTR(pwm1_min
, S_IRUGO
| S_IWUSR
,
831 nouveau_hwmon_get_pwm1_min
,
832 nouveau_hwmon_set_pwm1_min
, 0);
835 nouveau_hwmon_get_pwm1_max(struct device
*d
,
836 struct device_attribute
*a
, char *buf
)
838 struct drm_device
*dev
= dev_get_drvdata(d
);
839 struct nouveau_drm
*drm
= nouveau_drm(dev
);
840 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
843 ret
= therm
->attr_get(therm
, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY
);
847 return sprintf(buf
, "%i\n", ret
);
851 nouveau_hwmon_set_pwm1_max(struct device
*d
, struct device_attribute
*a
,
852 const char *buf
, size_t count
)
854 struct drm_device
*dev
= dev_get_drvdata(d
);
855 struct nouveau_drm
*drm
= nouveau_drm(dev
);
856 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
860 if (kstrtol(buf
, 10, &value
) == -EINVAL
)
863 ret
= therm
->attr_set(therm
, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY
, value
);
870 static SENSOR_DEVICE_ATTR(pwm1_max
, S_IRUGO
| S_IWUSR
,
871 nouveau_hwmon_get_pwm1_max
,
872 nouveau_hwmon_set_pwm1_max
, 0);
874 static struct attribute
*hwmon_attributes
[] = {
875 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
876 &sensor_dev_attr_temp1_auto_point1_pwm
.dev_attr
.attr
,
877 &sensor_dev_attr_temp1_auto_point1_temp
.dev_attr
.attr
,
878 &sensor_dev_attr_temp1_auto_point1_temp_hyst
.dev_attr
.attr
,
879 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
880 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
881 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
882 &sensor_dev_attr_temp1_crit_hyst
.dev_attr
.attr
,
883 &sensor_dev_attr_temp1_emergency
.dev_attr
.attr
,
884 &sensor_dev_attr_temp1_emergency_hyst
.dev_attr
.attr
,
885 &sensor_dev_attr_name
.dev_attr
.attr
,
886 &sensor_dev_attr_update_rate
.dev_attr
.attr
,
889 static struct attribute
*hwmon_fan_rpm_attributes
[] = {
890 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
893 static struct attribute
*hwmon_pwm_fan_attributes
[] = {
894 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
895 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
896 &sensor_dev_attr_pwm1_min
.dev_attr
.attr
,
897 &sensor_dev_attr_pwm1_max
.dev_attr
.attr
,
901 static const struct attribute_group hwmon_attrgroup
= {
902 .attrs
= hwmon_attributes
,
904 static const struct attribute_group hwmon_fan_rpm_attrgroup
= {
905 .attrs
= hwmon_fan_rpm_attributes
,
907 static const struct attribute_group hwmon_pwm_fan_attrgroup
= {
908 .attrs
= hwmon_pwm_fan_attributes
,
913 nouveau_hwmon_init(struct drm_device
*dev
)
915 struct nouveau_pm
*pm
= nouveau_pm(dev
);
917 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
918 struct nouveau_drm
*drm
= nouveau_drm(dev
);
919 struct nouveau_therm
*therm
= nouveau_therm(drm
->device
);
920 struct device
*hwmon_dev
;
923 if (!therm
|| !therm
->temp_get
|| !therm
->attr_get
|| !therm
->attr_set
)
926 hwmon_dev
= hwmon_device_register(&dev
->pdev
->dev
);
927 if (IS_ERR(hwmon_dev
)) {
928 ret
= PTR_ERR(hwmon_dev
);
929 NV_ERROR(drm
, "Unable to register hwmon device: %d\n", ret
);
932 dev_set_drvdata(hwmon_dev
, dev
);
934 /* default sysfs entries */
935 ret
= sysfs_create_group(&hwmon_dev
->kobj
, &hwmon_attrgroup
);
941 /* if the card has a pwm fan */
942 /*XXX: incorrect, need better detection for this, some boards have
943 * the gpio entries for pwm fan control even when there's no
944 * actual fan connected to it... therm table? */
945 if (therm
->fan_get
&& therm
->fan_get(therm
) >= 0) {
946 ret
= sysfs_create_group(&hwmon_dev
->kobj
,
947 &hwmon_pwm_fan_attrgroup
);
952 /* if the card can read the fan rpm */
953 if (therm
->fan_sense(therm
) >= 0) {
954 ret
= sysfs_create_group(&hwmon_dev
->kobj
,
955 &hwmon_fan_rpm_attrgroup
);
960 pm
->hwmon
= hwmon_dev
;
965 NV_ERROR(drm
, "Unable to create some hwmon sysfs files: %d\n", ret
);
966 hwmon_device_unregister(hwmon_dev
);
976 nouveau_hwmon_fini(struct drm_device
*dev
)
978 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
979 struct nouveau_pm
*pm
= nouveau_pm(dev
);
982 sysfs_remove_group(&pm
->hwmon
->kobj
, &hwmon_attrgroup
);
983 sysfs_remove_group(&pm
->hwmon
->kobj
,
984 &hwmon_pwm_fan_attrgroup
);
985 sysfs_remove_group(&pm
->hwmon
->kobj
,
986 &hwmon_fan_rpm_attrgroup
);
988 hwmon_device_unregister(pm
->hwmon
);
993 #if defined(CONFIG_ACPI) && defined(CONFIG_POWER_SUPPLY)
995 nouveau_pm_acpi_event(struct notifier_block
*nb
, unsigned long val
, void *data
)
997 struct nouveau_pm
*pm
= container_of(nb
, struct nouveau_pm
, acpi_nb
);
998 struct nouveau_drm
*drm
= nouveau_drm(pm
->dev
);
999 struct acpi_bus_event
*entry
= (struct acpi_bus_event
*)data
;
1001 if (strcmp(entry
->device_class
, "ac_adapter") == 0) {
1002 bool ac
= power_supply_is_system_supplied();
1004 NV_DEBUG(drm
, "power supply changed: %s\n", ac
? "AC" : "DC");
1005 nouveau_pm_trigger(pm
->dev
);
1013 nouveau_pm_init(struct drm_device
*dev
)
1015 struct nouveau_device
*device
= nouveau_dev(dev
);
1016 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1017 struct nouveau_pm
*pm
;
1021 pm
= drm
->pm
= kzalloc(sizeof(*pm
), GFP_KERNEL
);
1027 if (device
->card_type
< NV_40
) {
1028 pm
->clocks_get
= nv04_pm_clocks_get
;
1029 pm
->clocks_pre
= nv04_pm_clocks_pre
;
1030 pm
->clocks_set
= nv04_pm_clocks_set
;
1031 if (nouveau_gpio(drm
->device
)) {
1032 pm
->voltage_get
= nouveau_voltage_gpio_get
;
1033 pm
->voltage_set
= nouveau_voltage_gpio_set
;
1036 if (device
->card_type
< NV_50
) {
1037 pm
->clocks_get
= nv40_pm_clocks_get
;
1038 pm
->clocks_pre
= nv40_pm_clocks_pre
;
1039 pm
->clocks_set
= nv40_pm_clocks_set
;
1040 pm
->voltage_get
= nouveau_voltage_gpio_get
;
1041 pm
->voltage_set
= nouveau_voltage_gpio_set
;
1043 if (device
->card_type
< NV_C0
) {
1044 if (device
->chipset
< 0xa3 ||
1045 device
->chipset
== 0xaa ||
1046 device
->chipset
== 0xac) {
1047 pm
->clocks_get
= nv50_pm_clocks_get
;
1048 pm
->clocks_pre
= nv50_pm_clocks_pre
;
1049 pm
->clocks_set
= nv50_pm_clocks_set
;
1051 pm
->clocks_get
= nva3_pm_clocks_get
;
1052 pm
->clocks_pre
= nva3_pm_clocks_pre
;
1053 pm
->clocks_set
= nva3_pm_clocks_set
;
1055 pm
->voltage_get
= nouveau_voltage_gpio_get
;
1056 pm
->voltage_set
= nouveau_voltage_gpio_set
;
1058 if (device
->card_type
< NV_E0
) {
1059 pm
->clocks_get
= nvc0_pm_clocks_get
;
1060 pm
->clocks_pre
= nvc0_pm_clocks_pre
;
1061 pm
->clocks_set
= nvc0_pm_clocks_set
;
1062 pm
->voltage_get
= nouveau_voltage_gpio_get
;
1063 pm
->voltage_set
= nouveau_voltage_gpio_set
;
1067 /* parse aux tables from vbios */
1068 nouveau_volt_init(dev
);
1070 INIT_LIST_HEAD(&pm
->profiles
);
1072 /* determine current ("boot") performance level */
1073 ret
= nouveau_pm_perflvl_get(dev
, &pm
->boot
);
1075 NV_ERROR(drm
, "failed to determine boot perflvl\n");
1079 strncpy(pm
->boot
.name
, "boot", 4);
1080 strncpy(pm
->boot
.profile
.name
, "boot", 4);
1081 pm
->boot
.profile
.func
= &nouveau_pm_static_profile_func
;
1083 list_add(&pm
->boot
.profile
.head
, &pm
->profiles
);
1085 pm
->profile_ac
= &pm
->boot
.profile
;
1086 pm
->profile_dc
= &pm
->boot
.profile
;
1087 pm
->profile
= &pm
->boot
.profile
;
1088 pm
->cur
= &pm
->boot
;
1090 /* add performance levels from vbios */
1091 nouveau_perf_init(dev
);
1093 /* display available performance levels */
1094 NV_INFO(drm
, "%d available performance level(s)\n", pm
->nr_perflvl
);
1095 for (i
= 0; i
< pm
->nr_perflvl
; i
++) {
1096 nouveau_pm_perflvl_info(&pm
->perflvl
[i
], info
, sizeof(info
));
1097 NV_INFO(drm
, "%d:%s", pm
->perflvl
[i
].id
, info
);
1100 nouveau_pm_perflvl_info(&pm
->boot
, info
, sizeof(info
));
1101 NV_INFO(drm
, "c:%s", info
);
1103 /* switch performance levels now if requested */
1104 if (nouveau_perflvl
!= NULL
)
1105 nouveau_pm_profile_set(dev
, nouveau_perflvl
);
1107 nouveau_sysfs_init(dev
);
1108 nouveau_hwmon_init(dev
);
1109 #if defined(CONFIG_ACPI) && defined(CONFIG_POWER_SUPPLY)
1110 pm
->acpi_nb
.notifier_call
= nouveau_pm_acpi_event
;
1111 register_acpi_notifier(&pm
->acpi_nb
);
1118 nouveau_pm_fini(struct drm_device
*dev
)
1120 struct nouveau_pm
*pm
= nouveau_pm(dev
);
1121 struct nouveau_pm_profile
*profile
, *tmp
;
1123 list_for_each_entry_safe(profile
, tmp
, &pm
->profiles
, head
) {
1124 list_del(&profile
->head
);
1125 profile
->func
->destroy(profile
);
1128 if (pm
->cur
!= &pm
->boot
)
1129 nouveau_pm_perflvl_set(dev
, &pm
->boot
);
1131 nouveau_perf_fini(dev
);
1132 nouveau_volt_fini(dev
);
1134 #if defined(CONFIG_ACPI) && defined(CONFIG_POWER_SUPPLY)
1135 unregister_acpi_notifier(&pm
->acpi_nb
);
1137 nouveau_hwmon_fini(dev
);
1138 nouveau_sysfs_fini(dev
);
1140 nouveau_drm(dev
)->pm
= NULL
;
1145 nouveau_pm_resume(struct drm_device
*dev
)
1147 struct nouveau_pm
*pm
= nouveau_pm(dev
);
1148 struct nouveau_pm_level
*perflvl
;
1150 if (!pm
->cur
|| pm
->cur
== &pm
->boot
)
1154 pm
->cur
= &pm
->boot
;
1155 nouveau_pm_perflvl_set(dev
, perflvl
);