drivers/gpu/drm/nouveau/nouveau_hwmon.c

   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 }