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 <drm/drmP.h> 33 34 #include "nouveau_drm.h" 35 #include "nouveau_hwmon.h" 36 37 #include <subdev/gpio.h> 38 #include <subdev/timer.h> 39 #include <subdev/therm.h> 40 41 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 42 static ssize_t 43 nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf) 44 { 45 struct drm_device *dev = dev_get_drvdata(d); 46 struct nouveau_drm *drm = nouveau_drm(dev); 47 struct nouveau_therm *therm = nouveau_therm(drm->device); 48 int temp = therm->temp_get(therm); 49 50 if (temp < 0) 51 return temp; 52 53 return snprintf(buf, PAGE_SIZE, "%d\n", temp * 1000); 54 } 55 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, nouveau_hwmon_show_temp, 56 NULL, 0); 57 58 static ssize_t 59 nouveau_hwmon_show_temp1_auto_point1_pwm(struct device *d, 60 struct device_attribute *a, char *buf) 61 { 62 return snprintf(buf, PAGE_SIZE, "%d\n", 100); 63 } 64 static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO, 65 nouveau_hwmon_show_temp1_auto_point1_pwm, NULL, 0); 66 67 static ssize_t 68 nouveau_hwmon_temp1_auto_point1_temp(struct device *d, 69 struct device_attribute *a, char *buf) 70 { 71 struct drm_device *dev = dev_get_drvdata(d); 72 struct nouveau_drm *drm = nouveau_drm(dev); 73 struct nouveau_therm *therm = nouveau_therm(drm->device); 74 75 return snprintf(buf, PAGE_SIZE, "%d\n", 76 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST) * 1000); 77 } 78 static ssize_t 79 nouveau_hwmon_set_temp1_auto_point1_temp(struct device *d, 80 struct device_attribute *a, 81 const char *buf, size_t count) 82 { 83 struct drm_device *dev = dev_get_drvdata(d); 84 struct nouveau_drm *drm = nouveau_drm(dev); 85 struct nouveau_therm *therm = nouveau_therm(drm->device); 86 long value; 87 88 if (kstrtol(buf, 10, &value) == -EINVAL) 89 return count; 90 91 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST, 92 value / 1000); 93 94 return count; 95 } 96 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IRUGO | S_IWUSR, 97 nouveau_hwmon_temp1_auto_point1_temp, 98 nouveau_hwmon_set_temp1_auto_point1_temp, 0); 99 100 static ssize_t 101 nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device *d, 102 struct device_attribute *a, char *buf) 103 { 104 struct drm_device *dev = dev_get_drvdata(d); 105 struct nouveau_drm *drm = nouveau_drm(dev); 106 struct nouveau_therm *therm = nouveau_therm(drm->device); 107 108 return snprintf(buf, PAGE_SIZE, "%d\n", 109 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000); 110 } 111 static ssize_t 112 nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device *d, 113 struct device_attribute *a, 114 const char *buf, size_t count) 115 { 116 struct drm_device *dev = dev_get_drvdata(d); 117 struct nouveau_drm *drm = nouveau_drm(dev); 118 struct nouveau_therm *therm = nouveau_therm(drm->device); 119 long value; 120 121 if (kstrtol(buf, 10, &value) == -EINVAL) 122 return count; 123 124 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST, 125 value / 1000); 126 127 return count; 128 } 129 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, S_IRUGO | S_IWUSR, 130 nouveau_hwmon_temp1_auto_point1_temp_hyst, 131 nouveau_hwmon_set_temp1_auto_point1_temp_hyst, 0); 132 133 static ssize_t 134 nouveau_hwmon_max_temp(struct device *d, struct device_attribute *a, char *buf) 135 { 136 struct drm_device *dev = dev_get_drvdata(d); 137 struct nouveau_drm *drm = nouveau_drm(dev); 138 struct nouveau_therm *therm = nouveau_therm(drm->device); 139 140 return snprintf(buf, PAGE_SIZE, "%d\n", 141 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK) * 1000); 142 } 143 static ssize_t 144 nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a, 145 const char *buf, size_t count) 146 { 147 struct drm_device *dev = dev_get_drvdata(d); 148 struct nouveau_drm *drm = nouveau_drm(dev); 149 struct nouveau_therm *therm = nouveau_therm(drm->device); 150 long value; 151 152 if (kstrtol(buf, 10, &value) == -EINVAL) 153 return count; 154 155 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK, value / 1000); 156 157 return count; 158 } 159 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, nouveau_hwmon_max_temp, 160 nouveau_hwmon_set_max_temp, 161 0); 162 163 static ssize_t 164 nouveau_hwmon_max_temp_hyst(struct device *d, struct device_attribute *a, 165 char *buf) 166 { 167 struct drm_device *dev = dev_get_drvdata(d); 168 struct nouveau_drm *drm = nouveau_drm(dev); 169 struct nouveau_therm *therm = nouveau_therm(drm->device); 170 171 return snprintf(buf, PAGE_SIZE, "%d\n", 172 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST) * 1000); 173 } 174 static ssize_t 175 nouveau_hwmon_set_max_temp_hyst(struct device *d, struct device_attribute *a, 176 const char *buf, size_t count) 177 { 178 struct drm_device *dev = dev_get_drvdata(d); 179 struct nouveau_drm *drm = nouveau_drm(dev); 180 struct nouveau_therm *therm = nouveau_therm(drm->device); 181 long value; 182 183 if (kstrtol(buf, 10, &value) == -EINVAL) 184 return count; 185 186 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST, 187 value / 1000); 188 189 return count; 190 } 191 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 192 nouveau_hwmon_max_temp_hyst, 193 nouveau_hwmon_set_max_temp_hyst, 0); 194 195 static ssize_t 196 nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a, 197 char *buf) 198 { 199 struct drm_device *dev = dev_get_drvdata(d); 200 struct nouveau_drm *drm = nouveau_drm(dev); 201 struct nouveau_therm *therm = nouveau_therm(drm->device); 202 203 return snprintf(buf, PAGE_SIZE, "%d\n", 204 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL) * 1000); 205 } 206 static ssize_t 207 nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a, 208 const char *buf, 209 size_t count) 210 { 211 struct drm_device *dev = dev_get_drvdata(d); 212 struct nouveau_drm *drm = nouveau_drm(dev); 213 struct nouveau_therm *therm = nouveau_therm(drm->device); 214 long value; 215 216 if (kstrtol(buf, 10, &value) == -EINVAL) 217 return count; 218 219 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL, value / 1000); 220 221 return count; 222 } 223 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 224 nouveau_hwmon_critical_temp, 225 nouveau_hwmon_set_critical_temp, 226 0); 227 228 static ssize_t 229 nouveau_hwmon_critical_temp_hyst(struct device *d, struct device_attribute *a, 230 char *buf) 231 { 232 struct drm_device *dev = dev_get_drvdata(d); 233 struct nouveau_drm *drm = nouveau_drm(dev); 234 struct nouveau_therm *therm = nouveau_therm(drm->device); 235 236 return snprintf(buf, PAGE_SIZE, "%d\n", 237 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST) * 1000); 238 } 239 static ssize_t 240 nouveau_hwmon_set_critical_temp_hyst(struct device *d, 241 struct device_attribute *a, 242 const char *buf, 243 size_t count) 244 { 245 struct drm_device *dev = dev_get_drvdata(d); 246 struct nouveau_drm *drm = nouveau_drm(dev); 247 struct nouveau_therm *therm = nouveau_therm(drm->device); 248 long value; 249 250 if (kstrtol(buf, 10, &value) == -EINVAL) 251 return count; 252 253 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST, 254 value / 1000); 255 256 return count; 257 } 258 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR, 259 nouveau_hwmon_critical_temp_hyst, 260 nouveau_hwmon_set_critical_temp_hyst, 0); 261 static ssize_t 262 nouveau_hwmon_emergency_temp(struct device *d, struct device_attribute *a, 263 char *buf) 264 { 265 struct drm_device *dev = dev_get_drvdata(d); 266 struct nouveau_drm *drm = nouveau_drm(dev); 267 struct nouveau_therm *therm = nouveau_therm(drm->device); 268 269 return snprintf(buf, PAGE_SIZE, "%d\n", 270 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN) * 1000); 271 } 272 static ssize_t 273 nouveau_hwmon_set_emergency_temp(struct device *d, struct device_attribute *a, 274 const char *buf, 275 size_t count) 276 { 277 struct drm_device *dev = dev_get_drvdata(d); 278 struct nouveau_drm *drm = nouveau_drm(dev); 279 struct nouveau_therm *therm = nouveau_therm(drm->device); 280 long value; 281 282 if (kstrtol(buf, 10, &value) == -EINVAL) 283 return count; 284 285 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN, value / 1000); 286 287 return count; 288 } 289 static SENSOR_DEVICE_ATTR(temp1_emergency, S_IRUGO | S_IWUSR, 290 nouveau_hwmon_emergency_temp, 291 nouveau_hwmon_set_emergency_temp, 292 0); 293 294 static ssize_t 295 nouveau_hwmon_emergency_temp_hyst(struct device *d, struct device_attribute *a, 296 char *buf) 297 { 298 struct drm_device *dev = dev_get_drvdata(d); 299 struct nouveau_drm *drm = nouveau_drm(dev); 300 struct nouveau_therm *therm = nouveau_therm(drm->device); 301 302 return snprintf(buf, PAGE_SIZE, "%d\n", 303 therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST) * 1000); 304 } 305 static ssize_t 306 nouveau_hwmon_set_emergency_temp_hyst(struct device *d, 307 struct device_attribute *a, 308 const char *buf, 309 size_t count) 310 { 311 struct drm_device *dev = dev_get_drvdata(d); 312 struct nouveau_drm *drm = nouveau_drm(dev); 313 struct nouveau_therm *therm = nouveau_therm(drm->device); 314 long value; 315 316 if (kstrtol(buf, 10, &value) == -EINVAL) 317 return count; 318 319 therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST, 320 value / 1000); 321 322 return count; 323 } 324 static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO | S_IWUSR, 325 nouveau_hwmon_emergency_temp_hyst, 326 nouveau_hwmon_set_emergency_temp_hyst, 327 0); 328 329 static ssize_t nouveau_hwmon_show_name(struct device *dev, 330 struct device_attribute *attr, 331 char *buf) 332 { 333 return sprintf(buf, "nouveau\n"); 334 } 335 static SENSOR_DEVICE_ATTR(name, S_IRUGO, nouveau_hwmon_show_name, NULL, 0); 336 337 static ssize_t nouveau_hwmon_show_update_rate(struct device *dev, 338 struct device_attribute *attr, 339 char *buf) 340 { 341 return sprintf(buf, "1000\n"); 342 } 343 static SENSOR_DEVICE_ATTR(update_rate, S_IRUGO, 344 nouveau_hwmon_show_update_rate, 345 NULL, 0); 346 347 static ssize_t 348 nouveau_hwmon_show_fan1_input(struct device *d, struct device_attribute *attr, 349 char *buf) 350 { 351 struct drm_device *dev = dev_get_drvdata(d); 352 struct nouveau_drm *drm = nouveau_drm(dev); 353 struct nouveau_therm *therm = nouveau_therm(drm->device); 354 355 return snprintf(buf, PAGE_SIZE, "%d\n", therm->fan_sense(therm)); 356 } 357 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, nouveau_hwmon_show_fan1_input, 358 NULL, 0); 359 360 static ssize_t 361 nouveau_hwmon_get_pwm1_enable(struct device *d, 362 struct device_attribute *a, char *buf) 363 { 364 struct drm_device *dev = dev_get_drvdata(d); 365 struct nouveau_drm *drm = nouveau_drm(dev); 366 struct nouveau_therm *therm = nouveau_therm(drm->device); 367 int ret; 368 369 ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MODE); 370 if (ret < 0) 371 return ret; 372 373 return sprintf(buf, "%i\n", ret); 374 } 375 376 static ssize_t 377 nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute *a, 378 const char *buf, size_t count) 379 { 380 struct drm_device *dev = dev_get_drvdata(d); 381 struct nouveau_drm *drm = nouveau_drm(dev); 382 struct nouveau_therm *therm = nouveau_therm(drm->device); 383 long value; 384 int ret; 385 386 if (strict_strtol(buf, 10, &value) == -EINVAL) 387 return -EINVAL; 388 389 ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MODE, value); 390 if (ret) 391 return ret; 392 else 393 return count; 394 } 395 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, 396 nouveau_hwmon_get_pwm1_enable, 397 nouveau_hwmon_set_pwm1_enable, 0); 398 399 static ssize_t 400 nouveau_hwmon_get_pwm1(struct device *d, struct device_attribute *a, char *buf) 401 { 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); 405 int ret; 406 407 ret = therm->fan_get(therm); 408 if (ret < 0) 409 return ret; 410 411 return sprintf(buf, "%i\n", ret); 412 } 413 414 static ssize_t 415 nouveau_hwmon_set_pwm1(struct device *d, struct device_attribute *a, 416 const char *buf, size_t count) 417 { 418 struct drm_device *dev = dev_get_drvdata(d); 419 struct nouveau_drm *drm = nouveau_drm(dev); 420 struct nouveau_therm *therm = nouveau_therm(drm->device); 421 int ret = -ENODEV; 422 long value; 423 424 if (kstrtol(buf, 10, &value) == -EINVAL) 425 return -EINVAL; 426 427 ret = therm->fan_set(therm, value); 428 if (ret) 429 return ret; 430 431 return count; 432 } 433 434 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, 435 nouveau_hwmon_get_pwm1, 436 nouveau_hwmon_set_pwm1, 0); 437 438 static ssize_t 439 nouveau_hwmon_get_pwm1_min(struct device *d, 440 struct device_attribute *a, char *buf) 441 { 442 struct drm_device *dev = dev_get_drvdata(d); 443 struct nouveau_drm *drm = nouveau_drm(dev); 444 struct nouveau_therm *therm = nouveau_therm(drm->device); 445 int ret; 446 447 ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY); 448 if (ret < 0) 449 return ret; 450 451 return sprintf(buf, "%i\n", ret); 452 } 453 454 static ssize_t 455 nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a, 456 const char *buf, size_t count) 457 { 458 struct drm_device *dev = dev_get_drvdata(d); 459 struct nouveau_drm *drm = nouveau_drm(dev); 460 struct nouveau_therm *therm = nouveau_therm(drm->device); 461 long value; 462 int ret; 463 464 if (kstrtol(buf, 10, &value) == -EINVAL) 465 return -EINVAL; 466 467 ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY, value); 468 if (ret < 0) 469 return ret; 470 471 return count; 472 } 473 474 static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO | S_IWUSR, 475 nouveau_hwmon_get_pwm1_min, 476 nouveau_hwmon_set_pwm1_min, 0); 477 478 static ssize_t 479 nouveau_hwmon_get_pwm1_max(struct device *d, 480 struct device_attribute *a, char *buf) 481 { 482 struct drm_device *dev = dev_get_drvdata(d); 483 struct nouveau_drm *drm = nouveau_drm(dev); 484 struct nouveau_therm *therm = nouveau_therm(drm->device); 485 int ret; 486 487 ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY); 488 if (ret < 0) 489 return ret; 490 491 return sprintf(buf, "%i\n", ret); 492 } 493 494 static ssize_t 495 nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a, 496 const char *buf, size_t count) 497 { 498 struct drm_device *dev = dev_get_drvdata(d); 499 struct nouveau_drm *drm = nouveau_drm(dev); 500 struct nouveau_therm *therm = nouveau_therm(drm->device); 501 long value; 502 int ret; 503 504 if (kstrtol(buf, 10, &value) == -EINVAL) 505 return -EINVAL; 506 507 ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY, value); 508 if (ret < 0) 509 return ret; 510 511 return count; 512 } 513 514 static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO | S_IWUSR, 515 nouveau_hwmon_get_pwm1_max, 516 nouveau_hwmon_set_pwm1_max, 0); 517 518 static struct attribute *hwmon_default_attributes[] = { 519 &sensor_dev_attr_name.dev_attr.attr, 520 &sensor_dev_attr_update_rate.dev_attr.attr, 521 NULL 522 }; 523 static struct attribute *hwmon_temp_attributes[] = { 524 &sensor_dev_attr_temp1_input.dev_attr.attr, 525 &sensor_dev_attr_temp1_auto_point1_pwm.dev_attr.attr, 526 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 527 &sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr, 528 &sensor_dev_attr_temp1_max.dev_attr.attr, 529 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 530 &sensor_dev_attr_temp1_crit.dev_attr.attr, 531 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 532 &sensor_dev_attr_temp1_emergency.dev_attr.attr, 533 &sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr, 534 NULL 535 }; 536 static struct attribute *hwmon_fan_rpm_attributes[] = { 537 &sensor_dev_attr_fan1_input.dev_attr.attr, 538 NULL 539 }; 540 static struct attribute *hwmon_pwm_fan_attributes[] = { 541 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 542 &sensor_dev_attr_pwm1.dev_attr.attr, 543 &sensor_dev_attr_pwm1_min.dev_attr.attr, 544 &sensor_dev_attr_pwm1_max.dev_attr.attr, 545 NULL 546 }; 547 548 static const struct attribute_group hwmon_default_attrgroup = { 549 .attrs = hwmon_default_attributes, 550 }; 551 static const struct attribute_group hwmon_temp_attrgroup = { 552 .attrs = hwmon_temp_attributes, 553 }; 554 static const struct attribute_group hwmon_fan_rpm_attrgroup = { 555 .attrs = hwmon_fan_rpm_attributes, 556 }; 557 static const struct attribute_group hwmon_pwm_fan_attrgroup = { 558 .attrs = hwmon_pwm_fan_attributes, 559 }; 560 #endif 561 562 int 563 nouveau_hwmon_init(struct drm_device *dev) 564 { 565 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 566 struct nouveau_drm *drm = nouveau_drm(dev); 567 struct nouveau_therm *therm = nouveau_therm(drm->device); 568 struct nouveau_hwmon *hwmon; 569 struct device *hwmon_dev; 570 int ret = 0; 571 572 hwmon = drm->hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL); 573 if (!hwmon) 574 return -ENOMEM; 575 hwmon->dev = dev; 576 577 if (!therm || !therm->temp_get || !therm->attr_get || !therm->attr_set) 578 return -ENODEV; 579 580 hwmon_dev = hwmon_device_register(&dev->pdev->dev); 581 if (IS_ERR(hwmon_dev)) { 582 ret = PTR_ERR(hwmon_dev); 583 NV_ERROR(drm, "Unable to register hwmon device: %d\n", ret); 584 return ret; 585 } 586 dev_set_drvdata(hwmon_dev, dev); 587 588 /* set the default attributes */ 589 ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_default_attrgroup); 590 if (ret) { 591 if (ret) 592 goto error; 593 } 594 595 /* if the card has a working thermal sensor */ 596 if (therm->temp_get(therm) >= 0) { 597 ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_temp_attrgroup); 598 if (ret) { 599 if (ret) 600 goto error; 601 } 602 } 603 604 /* if the card has a pwm fan */ 605 /*XXX: incorrect, need better detection for this, some boards have 606 * the gpio entries for pwm fan control even when there's no 607 * actual fan connected to it... therm table? */ 608 if (therm->fan_get && therm->fan_get(therm) >= 0) { 609 ret = sysfs_create_group(&hwmon_dev->kobj, 610 &hwmon_pwm_fan_attrgroup); 611 if (ret) 612 goto error; 613 } 614 615 /* if the card can read the fan rpm */ 616 if (therm->fan_sense(therm) >= 0) { 617 ret = sysfs_create_group(&hwmon_dev->kobj, 618 &hwmon_fan_rpm_attrgroup); 619 if (ret) 620 goto error; 621 } 622 623 hwmon->hwmon = hwmon_dev; 624 625 return 0; 626 627 error: 628 NV_ERROR(drm, "Unable to create some hwmon sysfs files: %d\n", ret); 629 hwmon_device_unregister(hwmon_dev); 630 hwmon->hwmon = NULL; 631 return ret; 632 #else 633 return 0; 634 #endif 635 } 636 637 void 638 nouveau_hwmon_fini(struct drm_device *dev) 639 { 640 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 641 struct nouveau_hwmon *hwmon = nouveau_hwmon(dev); 642 643 if (hwmon->hwmon) { 644 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_default_attrgroup); 645 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_temp_attrgroup); 646 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_pwm_fan_attrgroup); 647 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_fan_rpm_attrgroup); 648 649 hwmon_device_unregister(hwmon->hwmon); 650 } 651 652 nouveau_drm(dev)->hwmon = NULL; 653 kfree(hwmon); 654 #endif 655 } 656