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_drv.h" 35 #include "nouveau_hwmon.h" 36 37 #include <nvkm/subdev/iccsense.h> 38 #include <nvkm/subdev/volt.h> 39 40 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 41 static ssize_t 42 nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf) 43 { 44 struct drm_device *dev = dev_get_drvdata(d); 45 struct nouveau_drm *drm = nouveau_drm(dev); 46 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 47 int temp = nvkm_therm_temp_get(therm); 48 49 if (temp < 0) 50 return temp; 51 52 return snprintf(buf, PAGE_SIZE, "%d\n", temp * 1000); 53 } 54 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, nouveau_hwmon_show_temp, 55 NULL, 0); 56 57 static ssize_t 58 nouveau_hwmon_show_temp1_auto_point1_pwm(struct device *d, 59 struct device_attribute *a, char *buf) 60 { 61 return snprintf(buf, PAGE_SIZE, "%d\n", 100); 62 } 63 static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO, 64 nouveau_hwmon_show_temp1_auto_point1_pwm, NULL, 0); 65 66 static ssize_t 67 nouveau_hwmon_temp1_auto_point1_temp(struct device *d, 68 struct device_attribute *a, char *buf) 69 { 70 struct drm_device *dev = dev_get_drvdata(d); 71 struct nouveau_drm *drm = nouveau_drm(dev); 72 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 73 74 return snprintf(buf, PAGE_SIZE, "%d\n", 75 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST) * 1000); 76 } 77 static ssize_t 78 nouveau_hwmon_set_temp1_auto_point1_temp(struct device *d, 79 struct device_attribute *a, 80 const char *buf, size_t count) 81 { 82 struct drm_device *dev = dev_get_drvdata(d); 83 struct nouveau_drm *drm = nouveau_drm(dev); 84 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 85 long value; 86 87 if (kstrtol(buf, 10, &value) == -EINVAL) 88 return count; 89 90 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST, 91 value / 1000); 92 93 return count; 94 } 95 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IRUGO | S_IWUSR, 96 nouveau_hwmon_temp1_auto_point1_temp, 97 nouveau_hwmon_set_temp1_auto_point1_temp, 0); 98 99 static ssize_t 100 nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device *d, 101 struct device_attribute *a, char *buf) 102 { 103 struct drm_device *dev = dev_get_drvdata(d); 104 struct nouveau_drm *drm = nouveau_drm(dev); 105 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 106 107 return snprintf(buf, PAGE_SIZE, "%d\n", 108 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000); 109 } 110 static ssize_t 111 nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device *d, 112 struct device_attribute *a, 113 const char *buf, size_t count) 114 { 115 struct drm_device *dev = dev_get_drvdata(d); 116 struct nouveau_drm *drm = nouveau_drm(dev); 117 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 118 long value; 119 120 if (kstrtol(buf, 10, &value) == -EINVAL) 121 return count; 122 123 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST, 124 value / 1000); 125 126 return count; 127 } 128 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, S_IRUGO | S_IWUSR, 129 nouveau_hwmon_temp1_auto_point1_temp_hyst, 130 nouveau_hwmon_set_temp1_auto_point1_temp_hyst, 0); 131 132 static ssize_t 133 nouveau_hwmon_max_temp(struct device *d, 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 139 return snprintf(buf, PAGE_SIZE, "%d\n", 140 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK) * 1000); 141 } 142 static ssize_t 143 nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a, 144 const char *buf, size_t count) 145 { 146 struct drm_device *dev = dev_get_drvdata(d); 147 struct nouveau_drm *drm = nouveau_drm(dev); 148 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 149 long value; 150 151 if (kstrtol(buf, 10, &value) == -EINVAL) 152 return count; 153 154 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK, value / 1000); 155 156 return count; 157 } 158 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, nouveau_hwmon_max_temp, 159 nouveau_hwmon_set_max_temp, 160 0); 161 162 static ssize_t 163 nouveau_hwmon_max_temp_hyst(struct device *d, struct device_attribute *a, 164 char *buf) 165 { 166 struct drm_device *dev = dev_get_drvdata(d); 167 struct nouveau_drm *drm = nouveau_drm(dev); 168 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 169 170 return snprintf(buf, PAGE_SIZE, "%d\n", 171 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST) * 1000); 172 } 173 static ssize_t 174 nouveau_hwmon_set_max_temp_hyst(struct device *d, struct device_attribute *a, 175 const char *buf, size_t count) 176 { 177 struct drm_device *dev = dev_get_drvdata(d); 178 struct nouveau_drm *drm = nouveau_drm(dev); 179 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 180 long value; 181 182 if (kstrtol(buf, 10, &value) == -EINVAL) 183 return count; 184 185 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST, 186 value / 1000); 187 188 return count; 189 } 190 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 191 nouveau_hwmon_max_temp_hyst, 192 nouveau_hwmon_set_max_temp_hyst, 0); 193 194 static ssize_t 195 nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a, 196 char *buf) 197 { 198 struct drm_device *dev = dev_get_drvdata(d); 199 struct nouveau_drm *drm = nouveau_drm(dev); 200 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 201 202 return snprintf(buf, PAGE_SIZE, "%d\n", 203 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL) * 1000); 204 } 205 static ssize_t 206 nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a, 207 const char *buf, 208 size_t count) 209 { 210 struct drm_device *dev = dev_get_drvdata(d); 211 struct nouveau_drm *drm = nouveau_drm(dev); 212 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 213 long value; 214 215 if (kstrtol(buf, 10, &value) == -EINVAL) 216 return count; 217 218 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL, value / 1000); 219 220 return count; 221 } 222 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 223 nouveau_hwmon_critical_temp, 224 nouveau_hwmon_set_critical_temp, 225 0); 226 227 static ssize_t 228 nouveau_hwmon_critical_temp_hyst(struct device *d, struct device_attribute *a, 229 char *buf) 230 { 231 struct drm_device *dev = dev_get_drvdata(d); 232 struct nouveau_drm *drm = nouveau_drm(dev); 233 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 234 235 return snprintf(buf, PAGE_SIZE, "%d\n", 236 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST) * 1000); 237 } 238 static ssize_t 239 nouveau_hwmon_set_critical_temp_hyst(struct device *d, 240 struct device_attribute *a, 241 const char *buf, 242 size_t count) 243 { 244 struct drm_device *dev = dev_get_drvdata(d); 245 struct nouveau_drm *drm = nouveau_drm(dev); 246 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 247 long value; 248 249 if (kstrtol(buf, 10, &value) == -EINVAL) 250 return count; 251 252 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST, 253 value / 1000); 254 255 return count; 256 } 257 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR, 258 nouveau_hwmon_critical_temp_hyst, 259 nouveau_hwmon_set_critical_temp_hyst, 0); 260 static ssize_t 261 nouveau_hwmon_emergency_temp(struct device *d, struct device_attribute *a, 262 char *buf) 263 { 264 struct drm_device *dev = dev_get_drvdata(d); 265 struct nouveau_drm *drm = nouveau_drm(dev); 266 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 267 268 return snprintf(buf, PAGE_SIZE, "%d\n", 269 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN) * 1000); 270 } 271 static ssize_t 272 nouveau_hwmon_set_emergency_temp(struct device *d, struct device_attribute *a, 273 const char *buf, 274 size_t count) 275 { 276 struct drm_device *dev = dev_get_drvdata(d); 277 struct nouveau_drm *drm = nouveau_drm(dev); 278 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 279 long value; 280 281 if (kstrtol(buf, 10, &value) == -EINVAL) 282 return count; 283 284 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN, value / 1000); 285 286 return count; 287 } 288 static SENSOR_DEVICE_ATTR(temp1_emergency, S_IRUGO | S_IWUSR, 289 nouveau_hwmon_emergency_temp, 290 nouveau_hwmon_set_emergency_temp, 291 0); 292 293 static ssize_t 294 nouveau_hwmon_emergency_temp_hyst(struct device *d, struct device_attribute *a, 295 char *buf) 296 { 297 struct drm_device *dev = dev_get_drvdata(d); 298 struct nouveau_drm *drm = nouveau_drm(dev); 299 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 300 301 return snprintf(buf, PAGE_SIZE, "%d\n", 302 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST) * 1000); 303 } 304 static ssize_t 305 nouveau_hwmon_set_emergency_temp_hyst(struct device *d, 306 struct device_attribute *a, 307 const char *buf, 308 size_t count) 309 { 310 struct drm_device *dev = dev_get_drvdata(d); 311 struct nouveau_drm *drm = nouveau_drm(dev); 312 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 313 long value; 314 315 if (kstrtol(buf, 10, &value) == -EINVAL) 316 return count; 317 318 therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST, 319 value / 1000); 320 321 return count; 322 } 323 static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO | S_IWUSR, 324 nouveau_hwmon_emergency_temp_hyst, 325 nouveau_hwmon_set_emergency_temp_hyst, 326 0); 327 328 static ssize_t nouveau_hwmon_show_name(struct device *dev, 329 struct device_attribute *attr, 330 char *buf) 331 { 332 return sprintf(buf, "nouveau\n"); 333 } 334 static SENSOR_DEVICE_ATTR(name, S_IRUGO, nouveau_hwmon_show_name, NULL, 0); 335 336 static ssize_t nouveau_hwmon_show_update_rate(struct device *dev, 337 struct device_attribute *attr, 338 char *buf) 339 { 340 return sprintf(buf, "1000\n"); 341 } 342 static SENSOR_DEVICE_ATTR(update_rate, S_IRUGO, 343 nouveau_hwmon_show_update_rate, 344 NULL, 0); 345 346 static ssize_t 347 nouveau_hwmon_show_fan1_input(struct device *d, struct device_attribute *attr, 348 char *buf) 349 { 350 struct drm_device *dev = dev_get_drvdata(d); 351 struct nouveau_drm *drm = nouveau_drm(dev); 352 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 353 354 return snprintf(buf, PAGE_SIZE, "%d\n", nvkm_therm_fan_sense(therm)); 355 } 356 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, nouveau_hwmon_show_fan1_input, 357 NULL, 0); 358 359 static ssize_t 360 nouveau_hwmon_get_pwm1_enable(struct device *d, 361 struct device_attribute *a, char *buf) 362 { 363 struct drm_device *dev = dev_get_drvdata(d); 364 struct nouveau_drm *drm = nouveau_drm(dev); 365 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 366 int ret; 367 368 ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MODE); 369 if (ret < 0) 370 return ret; 371 372 return sprintf(buf, "%i\n", ret); 373 } 374 375 static ssize_t 376 nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute *a, 377 const char *buf, size_t count) 378 { 379 struct drm_device *dev = dev_get_drvdata(d); 380 struct nouveau_drm *drm = nouveau_drm(dev); 381 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 382 long value; 383 int ret; 384 385 ret = kstrtol(buf, 10, &value); 386 if (ret) 387 return ret; 388 389 ret = therm->attr_set(therm, NVKM_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 nvkm_therm *therm = nvxx_therm(&drm->client.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 nvkm_therm *therm = nvxx_therm(&drm->client.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 nvkm_therm *therm = nvxx_therm(&drm->client.device); 445 int ret; 446 447 ret = therm->attr_get(therm, NVKM_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 nvkm_therm *therm = nvxx_therm(&drm->client.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, NVKM_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 nvkm_therm *therm = nvxx_therm(&drm->client.device); 485 int ret; 486 487 ret = therm->attr_get(therm, NVKM_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 nvkm_therm *therm = nvxx_therm(&drm->client.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, NVKM_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 ssize_t 519 nouveau_hwmon_get_in0_input(struct device *d, 520 struct device_attribute *a, char *buf) 521 { 522 struct drm_device *dev = dev_get_drvdata(d); 523 struct nouveau_drm *drm = nouveau_drm(dev); 524 struct nvkm_volt *volt = nvxx_volt(&drm->client.device); 525 int ret; 526 527 ret = nvkm_volt_get(volt); 528 if (ret < 0) 529 return ret; 530 531 return sprintf(buf, "%i\n", ret / 1000); 532 } 533 534 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, 535 nouveau_hwmon_get_in0_input, NULL, 0); 536 537 static ssize_t 538 nouveau_hwmon_get_in0_min(struct device *d, 539 struct device_attribute *a, char *buf) 540 { 541 struct drm_device *dev = dev_get_drvdata(d); 542 struct nouveau_drm *drm = nouveau_drm(dev); 543 struct nvkm_volt *volt = nvxx_volt(&drm->client.device); 544 545 if (!volt || !volt->min_uv) 546 return -ENODEV; 547 548 return sprintf(buf, "%i\n", volt->min_uv / 1000); 549 } 550 551 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO, 552 nouveau_hwmon_get_in0_min, NULL, 0); 553 554 static ssize_t 555 nouveau_hwmon_get_in0_max(struct device *d, 556 struct device_attribute *a, char *buf) 557 { 558 struct drm_device *dev = dev_get_drvdata(d); 559 struct nouveau_drm *drm = nouveau_drm(dev); 560 struct nvkm_volt *volt = nvxx_volt(&drm->client.device); 561 562 if (!volt || !volt->max_uv) 563 return -ENODEV; 564 565 return sprintf(buf, "%i\n", volt->max_uv / 1000); 566 } 567 568 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO, 569 nouveau_hwmon_get_in0_max, NULL, 0); 570 571 static ssize_t 572 nouveau_hwmon_get_in0_label(struct device *d, 573 struct device_attribute *a, char *buf) 574 { 575 return sprintf(buf, "GPU core\n"); 576 } 577 578 static SENSOR_DEVICE_ATTR(in0_label, S_IRUGO, 579 nouveau_hwmon_get_in0_label, NULL, 0); 580 581 static ssize_t 582 nouveau_hwmon_get_power1_input(struct device *d, struct device_attribute *a, 583 char *buf) 584 { 585 struct drm_device *dev = dev_get_drvdata(d); 586 struct nouveau_drm *drm = nouveau_drm(dev); 587 struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device); 588 int result = nvkm_iccsense_read_all(iccsense); 589 590 if (result < 0) 591 return result; 592 593 return sprintf(buf, "%i\n", result); 594 } 595 596 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, 597 nouveau_hwmon_get_power1_input, NULL, 0); 598 599 static ssize_t 600 nouveau_hwmon_get_power1_max(struct device *d, struct device_attribute *a, 601 char *buf) 602 { 603 struct drm_device *dev = dev_get_drvdata(d); 604 struct nouveau_drm *drm = nouveau_drm(dev); 605 struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device); 606 return sprintf(buf, "%i\n", iccsense->power_w_max); 607 } 608 609 static SENSOR_DEVICE_ATTR(power1_max, S_IRUGO, 610 nouveau_hwmon_get_power1_max, NULL, 0); 611 612 static ssize_t 613 nouveau_hwmon_get_power1_crit(struct device *d, struct device_attribute *a, 614 char *buf) 615 { 616 struct drm_device *dev = dev_get_drvdata(d); 617 struct nouveau_drm *drm = nouveau_drm(dev); 618 struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device); 619 return sprintf(buf, "%i\n", iccsense->power_w_crit); 620 } 621 622 static SENSOR_DEVICE_ATTR(power1_crit, S_IRUGO, 623 nouveau_hwmon_get_power1_crit, NULL, 0); 624 625 static struct attribute *hwmon_default_attributes[] = { 626 &sensor_dev_attr_name.dev_attr.attr, 627 &sensor_dev_attr_update_rate.dev_attr.attr, 628 NULL 629 }; 630 static struct attribute *hwmon_temp_attributes[] = { 631 &sensor_dev_attr_temp1_input.dev_attr.attr, 632 &sensor_dev_attr_temp1_auto_point1_pwm.dev_attr.attr, 633 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 634 &sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr, 635 &sensor_dev_attr_temp1_max.dev_attr.attr, 636 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 637 &sensor_dev_attr_temp1_crit.dev_attr.attr, 638 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 639 &sensor_dev_attr_temp1_emergency.dev_attr.attr, 640 &sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr, 641 NULL 642 }; 643 static struct attribute *hwmon_fan_rpm_attributes[] = { 644 &sensor_dev_attr_fan1_input.dev_attr.attr, 645 NULL 646 }; 647 static struct attribute *hwmon_pwm_fan_attributes[] = { 648 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 649 &sensor_dev_attr_pwm1.dev_attr.attr, 650 &sensor_dev_attr_pwm1_min.dev_attr.attr, 651 &sensor_dev_attr_pwm1_max.dev_attr.attr, 652 NULL 653 }; 654 655 static struct attribute *hwmon_in0_attributes[] = { 656 &sensor_dev_attr_in0_input.dev_attr.attr, 657 &sensor_dev_attr_in0_min.dev_attr.attr, 658 &sensor_dev_attr_in0_max.dev_attr.attr, 659 &sensor_dev_attr_in0_label.dev_attr.attr, 660 NULL 661 }; 662 663 static struct attribute *hwmon_power_attributes[] = { 664 &sensor_dev_attr_power1_input.dev_attr.attr, 665 NULL 666 }; 667 668 static struct attribute *hwmon_power_caps_attributes[] = { 669 &sensor_dev_attr_power1_max.dev_attr.attr, 670 &sensor_dev_attr_power1_crit.dev_attr.attr, 671 NULL 672 }; 673 674 static const struct attribute_group hwmon_default_attrgroup = { 675 .attrs = hwmon_default_attributes, 676 }; 677 static const struct attribute_group hwmon_temp_attrgroup = { 678 .attrs = hwmon_temp_attributes, 679 }; 680 static const struct attribute_group hwmon_fan_rpm_attrgroup = { 681 .attrs = hwmon_fan_rpm_attributes, 682 }; 683 static const struct attribute_group hwmon_pwm_fan_attrgroup = { 684 .attrs = hwmon_pwm_fan_attributes, 685 }; 686 static const struct attribute_group hwmon_in0_attrgroup = { 687 .attrs = hwmon_in0_attributes, 688 }; 689 static const struct attribute_group hwmon_power_attrgroup = { 690 .attrs = hwmon_power_attributes, 691 }; 692 static const struct attribute_group hwmon_power_caps_attrgroup = { 693 .attrs = hwmon_power_caps_attributes, 694 }; 695 #endif 696 697 int 698 nouveau_hwmon_init(struct drm_device *dev) 699 { 700 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 701 struct nouveau_drm *drm = nouveau_drm(dev); 702 struct nvkm_therm *therm = nvxx_therm(&drm->client.device); 703 struct nvkm_volt *volt = nvxx_volt(&drm->client.device); 704 struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.device); 705 struct nouveau_hwmon *hwmon; 706 struct device *hwmon_dev; 707 int ret = 0; 708 709 hwmon = drm->hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL); 710 if (!hwmon) 711 return -ENOMEM; 712 hwmon->dev = dev; 713 714 hwmon_dev = hwmon_device_register(dev->dev); 715 if (IS_ERR(hwmon_dev)) { 716 ret = PTR_ERR(hwmon_dev); 717 NV_ERROR(drm, "Unable to register hwmon device: %d\n", ret); 718 return ret; 719 } 720 dev_set_drvdata(hwmon_dev, dev); 721 722 /* set the default attributes */ 723 ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_default_attrgroup); 724 if (ret) 725 goto error; 726 727 if (therm && therm->attr_get && therm->attr_set) { 728 /* if the card has a working thermal sensor */ 729 if (nvkm_therm_temp_get(therm) >= 0) { 730 ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_temp_attrgroup); 731 if (ret) 732 goto error; 733 } 734 735 /* if the card has a pwm fan */ 736 /*XXX: incorrect, need better detection for this, some boards have 737 * the gpio entries for pwm fan control even when there's no 738 * actual fan connected to it... therm table? */ 739 if (therm->fan_get && therm->fan_get(therm) >= 0) { 740 ret = sysfs_create_group(&hwmon_dev->kobj, 741 &hwmon_pwm_fan_attrgroup); 742 if (ret) 743 goto error; 744 } 745 } 746 747 /* if the card can read the fan rpm */ 748 if (therm && nvkm_therm_fan_sense(therm) >= 0) { 749 ret = sysfs_create_group(&hwmon_dev->kobj, 750 &hwmon_fan_rpm_attrgroup); 751 if (ret) 752 goto error; 753 } 754 755 if (volt && nvkm_volt_get(volt) >= 0) { 756 ret = sysfs_create_group(&hwmon_dev->kobj, 757 &hwmon_in0_attrgroup); 758 759 if (ret) 760 goto error; 761 } 762 763 if (iccsense && iccsense->data_valid && !list_empty(&iccsense->rails)) { 764 ret = sysfs_create_group(&hwmon_dev->kobj, 765 &hwmon_power_attrgroup); 766 767 if (ret) 768 goto error; 769 770 if (iccsense->power_w_max && iccsense->power_w_crit) { 771 ret = sysfs_create_group(&hwmon_dev->kobj, 772 &hwmon_power_caps_attrgroup); 773 if (ret) 774 goto error; 775 } 776 } 777 778 hwmon->hwmon = hwmon_dev; 779 780 return 0; 781 782 error: 783 NV_ERROR(drm, "Unable to create some hwmon sysfs files: %d\n", ret); 784 hwmon_device_unregister(hwmon_dev); 785 hwmon->hwmon = NULL; 786 return ret; 787 #else 788 return 0; 789 #endif 790 } 791 792 void 793 nouveau_hwmon_fini(struct drm_device *dev) 794 { 795 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) 796 struct nouveau_hwmon *hwmon = nouveau_hwmon(dev); 797 798 if (hwmon->hwmon) { 799 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_default_attrgroup); 800 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_temp_attrgroup); 801 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_pwm_fan_attrgroup); 802 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_fan_rpm_attrgroup); 803 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_in0_attrgroup); 804 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_power_attrgroup); 805 sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_power_caps_attrgroup); 806 807 hwmon_device_unregister(hwmon->hwmon); 808 } 809 810 nouveau_drm(dev)->hwmon = NULL; 811 kfree(hwmon); 812 #endif 813 } 814