1 /*
2  * Copyright 2010 Red Hat Inc.
3  *
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:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
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.
21  *
22  * Authors: Ben Skeggs
23  */
24 
25 #ifdef CONFIG_ACPI
26 #include <linux/acpi.h>
27 #endif
28 #include <linux/power_supply.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 
32 #include "nouveau_drv.h"
33 #include "nouveau_hwmon.h"
34 
35 #include <nvkm/subdev/iccsense.h>
36 #include <nvkm/subdev/volt.h>
37 
38 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
39 
40 static ssize_t
41 nouveau_hwmon_show_temp1_auto_point1_pwm(struct device *d,
42 					 struct device_attribute *a, char *buf)
43 {
44 	return snprintf(buf, PAGE_SIZE, "%d\n", 100);
45 }
46 static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, 0444,
47 			  nouveau_hwmon_show_temp1_auto_point1_pwm, NULL, 0);
48 
49 static ssize_t
50 nouveau_hwmon_temp1_auto_point1_temp(struct device *d,
51 				     struct device_attribute *a, char *buf)
52 {
53 	struct drm_device *dev = dev_get_drvdata(d);
54 	struct nouveau_drm *drm = nouveau_drm(dev);
55 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
56 
57 	return snprintf(buf, PAGE_SIZE, "%d\n",
58 	      therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST) * 1000);
59 }
60 static ssize_t
61 nouveau_hwmon_set_temp1_auto_point1_temp(struct device *d,
62 					 struct device_attribute *a,
63 					 const char *buf, size_t count)
64 {
65 	struct drm_device *dev = dev_get_drvdata(d);
66 	struct nouveau_drm *drm = nouveau_drm(dev);
67 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
68 	long value;
69 
70 	if (kstrtol(buf, 10, &value))
71 		return -EINVAL;
72 
73 	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST,
74 			value / 1000);
75 
76 	return count;
77 }
78 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, 0644,
79 			  nouveau_hwmon_temp1_auto_point1_temp,
80 			  nouveau_hwmon_set_temp1_auto_point1_temp, 0);
81 
82 static ssize_t
83 nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device *d,
84 					  struct device_attribute *a, char *buf)
85 {
86 	struct drm_device *dev = dev_get_drvdata(d);
87 	struct nouveau_drm *drm = nouveau_drm(dev);
88 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
89 
90 	return snprintf(buf, PAGE_SIZE, "%d\n",
91 	 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000);
92 }
93 static ssize_t
94 nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device *d,
95 					      struct device_attribute *a,
96 					      const char *buf, size_t count)
97 {
98 	struct drm_device *dev = dev_get_drvdata(d);
99 	struct nouveau_drm *drm = nouveau_drm(dev);
100 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
101 	long value;
102 
103 	if (kstrtol(buf, 10, &value))
104 		return -EINVAL;
105 
106 	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST,
107 			value / 1000);
108 
109 	return count;
110 }
111 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, 0644,
112 			  nouveau_hwmon_temp1_auto_point1_temp_hyst,
113 			  nouveau_hwmon_set_temp1_auto_point1_temp_hyst, 0);
114 
115 static ssize_t
116 nouveau_hwmon_get_pwm1_max(struct device *d,
117 			   struct device_attribute *a, char *buf)
118 {
119 	struct drm_device *dev = dev_get_drvdata(d);
120 	struct nouveau_drm *drm = nouveau_drm(dev);
121 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
122 	int ret;
123 
124 	ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MAX_DUTY);
125 	if (ret < 0)
126 		return ret;
127 
128 	return sprintf(buf, "%i\n", ret);
129 }
130 
131 static ssize_t
132 nouveau_hwmon_get_pwm1_min(struct device *d,
133 			   struct device_attribute *a, char *buf)
134 {
135 	struct drm_device *dev = dev_get_drvdata(d);
136 	struct nouveau_drm *drm = nouveau_drm(dev);
137 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
138 	int ret;
139 
140 	ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MIN_DUTY);
141 	if (ret < 0)
142 		return ret;
143 
144 	return sprintf(buf, "%i\n", ret);
145 }
146 
147 static ssize_t
148 nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a,
149 			   const char *buf, size_t count)
150 {
151 	struct drm_device *dev = dev_get_drvdata(d);
152 	struct nouveau_drm *drm = nouveau_drm(dev);
153 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
154 	long value;
155 	int ret;
156 
157 	if (kstrtol(buf, 10, &value))
158 		return -EINVAL;
159 
160 	ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MIN_DUTY, value);
161 	if (ret < 0)
162 		return ret;
163 
164 	return count;
165 }
166 static SENSOR_DEVICE_ATTR(pwm1_min, 0644,
167 			  nouveau_hwmon_get_pwm1_min,
168 			  nouveau_hwmon_set_pwm1_min, 0);
169 
170 static ssize_t
171 nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a,
172 			   const char *buf, size_t count)
173 {
174 	struct drm_device *dev = dev_get_drvdata(d);
175 	struct nouveau_drm *drm = nouveau_drm(dev);
176 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
177 	long value;
178 	int ret;
179 
180 	if (kstrtol(buf, 10, &value))
181 		return -EINVAL;
182 
183 	ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MAX_DUTY, value);
184 	if (ret < 0)
185 		return ret;
186 
187 	return count;
188 }
189 static SENSOR_DEVICE_ATTR(pwm1_max, 0644,
190 			  nouveau_hwmon_get_pwm1_max,
191 			  nouveau_hwmon_set_pwm1_max, 0);
192 
193 static struct attribute *pwm_fan_sensor_attrs[] = {
194 	&sensor_dev_attr_pwm1_min.dev_attr.attr,
195 	&sensor_dev_attr_pwm1_max.dev_attr.attr,
196 	NULL
197 };
198 static const struct attribute_group pwm_fan_sensor_group = {
199 	.attrs = pwm_fan_sensor_attrs,
200 };
201 
202 static struct attribute *temp1_auto_point_sensor_attrs[] = {
203 	&sensor_dev_attr_temp1_auto_point1_pwm.dev_attr.attr,
204 	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
205 	&sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr,
206 	NULL
207 };
208 static const struct attribute_group temp1_auto_point_sensor_group = {
209 	.attrs = temp1_auto_point_sensor_attrs,
210 };
211 
212 #define N_ATTR_GROUPS   3
213 
214 static const u32 nouveau_config_chip[] = {
215 	HWMON_C_UPDATE_INTERVAL,
216 	0
217 };
218 
219 static const u32 nouveau_config_in[] = {
220 	HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_LABEL,
221 	0
222 };
223 
224 static const u32 nouveau_config_temp[] = {
225 	HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
226 	HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_EMERGENCY |
227 	HWMON_T_EMERGENCY_HYST,
228 	0
229 };
230 
231 static const u32 nouveau_config_fan[] = {
232 	HWMON_F_INPUT,
233 	0
234 };
235 
236 static const u32 nouveau_config_pwm[] = {
237 	HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
238 	0
239 };
240 
241 static const u32 nouveau_config_power[] = {
242 	HWMON_P_INPUT | HWMON_P_CAP_MAX | HWMON_P_CRIT,
243 	0
244 };
245 
246 static const struct hwmon_channel_info nouveau_chip = {
247 	.type = hwmon_chip,
248 	.config = nouveau_config_chip,
249 };
250 
251 static const struct hwmon_channel_info nouveau_temp = {
252 	.type = hwmon_temp,
253 	.config = nouveau_config_temp,
254 };
255 
256 static const struct hwmon_channel_info nouveau_fan = {
257 	.type = hwmon_fan,
258 	.config = nouveau_config_fan,
259 };
260 
261 static const struct hwmon_channel_info nouveau_in = {
262 	.type = hwmon_in,
263 	.config = nouveau_config_in,
264 };
265 
266 static const struct hwmon_channel_info nouveau_pwm = {
267 	.type = hwmon_pwm,
268 	.config = nouveau_config_pwm,
269 };
270 
271 static const struct hwmon_channel_info nouveau_power = {
272 	.type = hwmon_power,
273 	.config = nouveau_config_power,
274 };
275 
276 static const struct hwmon_channel_info *nouveau_info[] = {
277 	&nouveau_chip,
278 	&nouveau_temp,
279 	&nouveau_fan,
280 	&nouveau_in,
281 	&nouveau_pwm,
282 	&nouveau_power,
283 	NULL
284 };
285 
286 static umode_t
287 nouveau_chip_is_visible(const void *data, u32 attr, int channel)
288 {
289 	switch (attr) {
290 	case hwmon_chip_update_interval:
291 		return 0444;
292 	default:
293 		return 0;
294 	}
295 }
296 
297 static umode_t
298 nouveau_power_is_visible(const void *data, u32 attr, int channel)
299 {
300 	struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
301 	struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device);
302 
303 	if (!iccsense || !iccsense->data_valid || list_empty(&iccsense->rails))
304 		return 0;
305 
306 	switch (attr) {
307 	case hwmon_power_input:
308 		return 0444;
309 	case hwmon_power_max:
310 		if (iccsense->power_w_max)
311 			return 0444;
312 		return 0;
313 	case hwmon_power_crit:
314 		if (iccsense->power_w_crit)
315 			return 0444;
316 		return 0;
317 	default:
318 		return 0;
319 	}
320 }
321 
322 static umode_t
323 nouveau_temp_is_visible(const void *data, u32 attr, int channel)
324 {
325 	struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
326 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
327 
328 	if (!therm || !therm->attr_get || nvkm_therm_temp_get(therm) < 0)
329 		return 0;
330 
331 	switch (attr) {
332 	case hwmon_temp_input:
333 		return 0444;
334 	case hwmon_temp_max:
335 	case hwmon_temp_max_hyst:
336 	case hwmon_temp_crit:
337 	case hwmon_temp_crit_hyst:
338 	case hwmon_temp_emergency:
339 	case hwmon_temp_emergency_hyst:
340 		return 0644;
341 	default:
342 		return 0;
343 	}
344 }
345 
346 static umode_t
347 nouveau_pwm_is_visible(const void *data, u32 attr, int channel)
348 {
349 	struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
350 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
351 
352 	if (!therm || !therm->attr_get || !therm->fan_get ||
353 	    therm->fan_get(therm) < 0)
354 		return 0;
355 
356 	switch (attr) {
357 	case hwmon_pwm_enable:
358 	case hwmon_pwm_input:
359 		return 0644;
360 	default:
361 		return 0;
362 	}
363 }
364 
365 static umode_t
366 nouveau_input_is_visible(const void *data, u32 attr, int channel)
367 {
368 	struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
369 	struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
370 
371 	if (!volt || nvkm_volt_get(volt) < 0)
372 		return 0;
373 
374 	switch (attr) {
375 	case hwmon_in_input:
376 	case hwmon_in_label:
377 	case hwmon_in_min:
378 	case hwmon_in_max:
379 		return 0444;
380 	default:
381 		return 0;
382 	}
383 }
384 
385 static umode_t
386 nouveau_fan_is_visible(const void *data, u32 attr, int channel)
387 {
388 	struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
389 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
390 
391 	if (!therm || !therm->attr_get || nvkm_therm_fan_sense(therm) < 0)
392 		return 0;
393 
394 	switch (attr) {
395 	case hwmon_fan_input:
396 		return 0444;
397 	default:
398 		return 0;
399 	}
400 }
401 
402 static int
403 nouveau_chip_read(struct device *dev, u32 attr, int channel, long *val)
404 {
405 	switch (attr) {
406 	case hwmon_chip_update_interval:
407 		*val = 1000;
408 		break;
409 	default:
410 		return -EOPNOTSUPP;
411 	}
412 
413 	return 0;
414 }
415 
416 static int
417 nouveau_temp_read(struct device *dev, u32 attr, int channel, long *val)
418 {
419 	struct drm_device *drm_dev = dev_get_drvdata(dev);
420 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
421 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
422 	int ret;
423 
424 	if (!therm || !therm->attr_get)
425 		return -EOPNOTSUPP;
426 
427 	switch (attr) {
428 	case hwmon_temp_input:
429 		if (drm_dev->switch_power_state != DRM_SWITCH_POWER_ON)
430 			return -EINVAL;
431 		ret = nvkm_therm_temp_get(therm);
432 		*val = ret < 0 ? ret : (ret * 1000);
433 		break;
434 	case hwmon_temp_max:
435 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK)
436 					* 1000;
437 		break;
438 	case hwmon_temp_max_hyst:
439 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST)
440 					* 1000;
441 		break;
442 	case hwmon_temp_crit:
443 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL)
444 					* 1000;
445 		break;
446 	case hwmon_temp_crit_hyst:
447 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST)
448 					* 1000;
449 		break;
450 	case hwmon_temp_emergency:
451 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN)
452 					* 1000;
453 		break;
454 	case hwmon_temp_emergency_hyst:
455 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST)
456 					* 1000;
457 		break;
458 	default:
459 		return -EOPNOTSUPP;
460 	}
461 
462 	return 0;
463 }
464 
465 static int
466 nouveau_fan_read(struct device *dev, u32 attr, int channel, long *val)
467 {
468 	struct drm_device *drm_dev = dev_get_drvdata(dev);
469 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
470 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
471 
472 	if (!therm)
473 		return -EOPNOTSUPP;
474 
475 	switch (attr) {
476 	case hwmon_fan_input:
477 		if (drm_dev->switch_power_state != DRM_SWITCH_POWER_ON)
478 			return -EINVAL;
479 		*val = nvkm_therm_fan_sense(therm);
480 		break;
481 	default:
482 		return -EOPNOTSUPP;
483 	}
484 
485 	return 0;
486 }
487 
488 static int
489 nouveau_in_read(struct device *dev, u32 attr, int channel, long *val)
490 {
491 	struct drm_device *drm_dev = dev_get_drvdata(dev);
492 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
493 	struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
494 	int ret;
495 
496 	if (!volt)
497 		return -EOPNOTSUPP;
498 
499 	switch (attr) {
500 	case hwmon_in_input:
501 		if (drm_dev->switch_power_state != DRM_SWITCH_POWER_ON)
502 			return -EINVAL;
503 		ret = nvkm_volt_get(volt);
504 		*val = ret < 0 ? ret : (ret / 1000);
505 		break;
506 	case hwmon_in_min:
507 		*val = volt->min_uv > 0 ? (volt->min_uv / 1000) : -ENODEV;
508 		break;
509 	case hwmon_in_max:
510 		*val = volt->max_uv > 0 ? (volt->max_uv / 1000) : -ENODEV;
511 		break;
512 	default:
513 		return -EOPNOTSUPP;
514 	}
515 
516 	return 0;
517 }
518 
519 static int
520 nouveau_pwm_read(struct device *dev, u32 attr, int channel, long *val)
521 {
522 	struct drm_device *drm_dev = dev_get_drvdata(dev);
523 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
524 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
525 
526 	if (!therm || !therm->attr_get || !therm->fan_get)
527 		return -EOPNOTSUPP;
528 
529 	switch (attr) {
530 	case hwmon_pwm_enable:
531 		*val = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MODE);
532 		break;
533 	case hwmon_pwm_input:
534 		if (drm_dev->switch_power_state != DRM_SWITCH_POWER_ON)
535 			return -EINVAL;
536 		*val = therm->fan_get(therm);
537 		break;
538 	default:
539 		return -EOPNOTSUPP;
540 	}
541 
542 	return 0;
543 }
544 
545 static int
546 nouveau_power_read(struct device *dev, u32 attr, int channel, long *val)
547 {
548 	struct drm_device *drm_dev = dev_get_drvdata(dev);
549 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
550 	struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device);
551 
552 	if (!iccsense)
553 		return -EOPNOTSUPP;
554 
555 	switch (attr) {
556 	case hwmon_power_input:
557 		if (drm_dev->switch_power_state != DRM_SWITCH_POWER_ON)
558 			return -EINVAL;
559 		*val = nvkm_iccsense_read_all(iccsense);
560 		break;
561 	case hwmon_power_max:
562 		*val = iccsense->power_w_max;
563 		break;
564 	case hwmon_power_crit:
565 		*val = iccsense->power_w_crit;
566 		break;
567 	default:
568 		return -EOPNOTSUPP;
569 	}
570 
571 	return 0;
572 }
573 
574 static int
575 nouveau_temp_write(struct device *dev, u32 attr, int channel, long val)
576 {
577 	struct drm_device *drm_dev = dev_get_drvdata(dev);
578 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
579 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
580 
581 	if (!therm || !therm->attr_set)
582 		return -EOPNOTSUPP;
583 
584 	switch (attr) {
585 	case hwmon_temp_max:
586 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK,
587 					val / 1000);
588 	case hwmon_temp_max_hyst:
589 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST,
590 					val / 1000);
591 	case hwmon_temp_crit:
592 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL,
593 					val / 1000);
594 	case hwmon_temp_crit_hyst:
595 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST,
596 					val / 1000);
597 	case hwmon_temp_emergency:
598 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN,
599 					val / 1000);
600 	case hwmon_temp_emergency_hyst:
601 		return therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST,
602 					val / 1000);
603 	default:
604 		return -EOPNOTSUPP;
605 	}
606 }
607 
608 static int
609 nouveau_pwm_write(struct device *dev, u32 attr, int channel, long val)
610 {
611 	struct drm_device *drm_dev = dev_get_drvdata(dev);
612 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
613 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
614 
615 	if (!therm || !therm->attr_set)
616 		return -EOPNOTSUPP;
617 
618 	switch (attr) {
619 	case hwmon_pwm_input:
620 		return therm->fan_set(therm, val);
621 	case hwmon_pwm_enable:
622 		return therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MODE, val);
623 	default:
624 		return -EOPNOTSUPP;
625 	}
626 }
627 
628 static umode_t
629 nouveau_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
630 			int channel)
631 {
632 	switch (type) {
633 	case hwmon_chip:
634 		return nouveau_chip_is_visible(data, attr, channel);
635 	case hwmon_temp:
636 		return nouveau_temp_is_visible(data, attr, channel);
637 	case hwmon_fan:
638 		return nouveau_fan_is_visible(data, attr, channel);
639 	case hwmon_in:
640 		return nouveau_input_is_visible(data, attr, channel);
641 	case hwmon_pwm:
642 		return nouveau_pwm_is_visible(data, attr, channel);
643 	case hwmon_power:
644 		return nouveau_power_is_visible(data, attr, channel);
645 	default:
646 		return 0;
647 	}
648 }
649 
650 static const char input_label[] = "GPU core";
651 
652 static int
653 nouveau_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
654 		    int channel, const char **buf)
655 {
656 	if (type == hwmon_in && attr == hwmon_in_label) {
657 		*buf = input_label;
658 		return 0;
659 	}
660 
661 	return -EOPNOTSUPP;
662 }
663 
664 static int
665 nouveau_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
666 							int channel, long *val)
667 {
668 	switch (type) {
669 	case hwmon_chip:
670 		return nouveau_chip_read(dev, attr, channel, val);
671 	case hwmon_temp:
672 		return nouveau_temp_read(dev, attr, channel, val);
673 	case hwmon_fan:
674 		return nouveau_fan_read(dev, attr, channel, val);
675 	case hwmon_in:
676 		return nouveau_in_read(dev, attr, channel, val);
677 	case hwmon_pwm:
678 		return nouveau_pwm_read(dev, attr, channel, val);
679 	case hwmon_power:
680 		return nouveau_power_read(dev, attr, channel, val);
681 	default:
682 		return -EOPNOTSUPP;
683 	}
684 }
685 
686 static int
687 nouveau_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
688 							int channel, long val)
689 {
690 	switch (type) {
691 	case hwmon_temp:
692 		return nouveau_temp_write(dev, attr, channel, val);
693 	case hwmon_pwm:
694 		return nouveau_pwm_write(dev, attr, channel, val);
695 	default:
696 		return -EOPNOTSUPP;
697 	}
698 }
699 
700 static const struct hwmon_ops nouveau_hwmon_ops = {
701 	.is_visible = nouveau_is_visible,
702 	.read = nouveau_read,
703 	.read_string = nouveau_read_string,
704 	.write = nouveau_write,
705 };
706 
707 static const struct hwmon_chip_info nouveau_chip_info = {
708 	.ops = &nouveau_hwmon_ops,
709 	.info = nouveau_info,
710 };
711 #endif
712 
713 int
714 nouveau_hwmon_init(struct drm_device *dev)
715 {
716 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
717 	struct nouveau_drm *drm = nouveau_drm(dev);
718 	struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device);
719 	struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
720 	struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
721 	const struct attribute_group *special_groups[N_ATTR_GROUPS];
722 	struct nouveau_hwmon *hwmon;
723 	struct device *hwmon_dev;
724 	int ret = 0;
725 	int i = 0;
726 
727 	if (!iccsense && !therm && !volt) {
728 		NV_DEBUG(drm, "Skipping hwmon registration\n");
729 		return 0;
730 	}
731 
732 	hwmon = drm->hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL);
733 	if (!hwmon)
734 		return -ENOMEM;
735 	hwmon->dev = dev;
736 
737 	if (therm && therm->attr_get && therm->attr_set) {
738 		if (nvkm_therm_temp_get(therm) >= 0)
739 			special_groups[i++] = &temp1_auto_point_sensor_group;
740 		if (therm->fan_get && therm->fan_get(therm) >= 0)
741 			special_groups[i++] = &pwm_fan_sensor_group;
742 	}
743 
744 	special_groups[i] = NULL;
745 	hwmon_dev = hwmon_device_register_with_info(dev->dev, "nouveau", dev,
746 							&nouveau_chip_info,
747 							special_groups);
748 	if (IS_ERR(hwmon_dev)) {
749 		ret = PTR_ERR(hwmon_dev);
750 		NV_ERROR(drm, "Unable to register hwmon device: %d\n", ret);
751 		return ret;
752 	}
753 
754 	hwmon->hwmon = hwmon_dev;
755 	return 0;
756 #else
757 	return 0;
758 #endif
759 }
760 
761 void
762 nouveau_hwmon_fini(struct drm_device *dev)
763 {
764 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
765 	struct nouveau_hwmon *hwmon = nouveau_hwmon(dev);
766 
767 	if (!hwmon)
768 		return;
769 
770 	if (hwmon->hwmon)
771 		hwmon_device_unregister(hwmon->hwmon);
772 
773 	nouveau_drm(dev)->hwmon = NULL;
774 	kfree(hwmon);
775 #endif
776 }
777