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