drivers/gpu/drm/nouveau/nouveau_pm.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 #include "drmP.h"
  26
  27 #include "nouveau_drv.h"
  28 #include "nouveau_pm.h"
  29
  30 #ifdef CONFIG_ACPI
  31 #include <linux/acpi.h>
  32 #endif
  33 #include <linux/power_supply.h>
  34 #include <linux/hwmon.h>
  35 #include <linux/hwmon-sysfs.h>
  36
  37 static int
  38 nouveau_pm_clock_set(struct drm_device *dev, struct nouveau_pm_level *perflvl,
  39                      u8 id, u32 khz)
  40 {
  41         struct drm_nouveau_private *dev_priv = dev->dev_private;
  42         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
  43         void *pre_state;
  44
  45         if (khz == 0)
  46                 return 0;
  47
  48         pre_state = pm->clock_pre(dev, perflvl, id, khz);
  49         if (IS_ERR(pre_state))
  50                 return PTR_ERR(pre_state);
  51
  52         if (pre_state)
  53                 pm->clock_set(dev, pre_state);
  54         return 0;
  55 }
  56
  57 static int
  58 nouveau_pm_perflvl_set(struct drm_device *dev, struct nouveau_pm_level *perflvl)
  59 {
  60         struct drm_nouveau_private *dev_priv = dev->dev_private;
  61         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
  62         int ret;
  63
  64         if (perflvl == pm->cur)
  65                 return 0;
  66
  67         if (pm->voltage.supported && pm->voltage_set && perflvl->voltage) {
  68                 ret = pm->voltage_set(dev, perflvl->voltage);
  69                 if (ret) {
  70                         NV_ERROR(dev, "voltage_set %d failed: %d\n",
  71                                  perflvl->voltage, ret);
  72                 }
  73         }
  74
  75         nouveau_pm_clock_set(dev, perflvl, PLL_CORE, perflvl->core);
  76         nouveau_pm_clock_set(dev, perflvl, PLL_SHADER, perflvl->shader);
  77         nouveau_pm_clock_set(dev, perflvl, PLL_MEMORY, perflvl->memory);
  78         nouveau_pm_clock_set(dev, perflvl, PLL_UNK05, perflvl->unk05);
  79
  80         pm->cur = perflvl;
  81         return 0;
  82 }
  83
  84 static int
  85 nouveau_pm_profile_set(struct drm_device *dev, const char *profile)
  86 {
  87         struct drm_nouveau_private *dev_priv = dev->dev_private;
  88         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
  89         struct nouveau_pm_level *perflvl = NULL;
  90
  91         /* safety precaution, for now */
  92         if (nouveau_perflvl_wr != 7777)
  93                 return -EPERM;
  94
  95         if (!pm->clock_set)
  96                 return -EINVAL;
  97
  98         if (!strncmp(profile, "boot", 4))
  99                 perflvl = &pm->boot;
 100         else {
 101                 int pl = simple_strtol(profile, NULL, 10);
 102                 int i;
 103
 104                 for (i = 0; i < pm->nr_perflvl; i++) {
 105                         if (pm->perflvl[i].id == pl) {
 106                                 perflvl = &pm->perflvl[i];
 107                                 break;
 108                         }
 109                 }
 110
 111                 if (!perflvl)
 112                         return -EINVAL;
 113         }
 114
 115         NV_INFO(dev, "setting performance level: %s\n", profile);
 116         return nouveau_pm_perflvl_set(dev, perflvl);
 117 }
 118
 119 static int
 120 nouveau_pm_perflvl_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 121 {
 122         struct drm_nouveau_private *dev_priv = dev->dev_private;
 123         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 124         int ret;
 125
 126         if (!pm->clock_get)
 127                 return -EINVAL;
 128
 129         memset(perflvl, 0, sizeof(*perflvl));
 130
 131         ret = pm->clock_get(dev, PLL_CORE);
 132         if (ret > 0)
 133                 perflvl->core = ret;
 134
 135         ret = pm->clock_get(dev, PLL_MEMORY);
 136         if (ret > 0)
 137                 perflvl->memory = ret;
 138
 139         ret = pm->clock_get(dev, PLL_SHADER);
 140         if (ret > 0)
 141                 perflvl->shader = ret;
 142
 143         ret = pm->clock_get(dev, PLL_UNK05);
 144         if (ret > 0)
 145                 perflvl->unk05 = ret;
 146
 147         if (pm->voltage.supported && pm->voltage_get) {
 148                 ret = pm->voltage_get(dev);
 149                 if (ret > 0)
 150                         perflvl->voltage = ret;
 151         }
 152
 153         return 0;
 154 }
 155
 156 static void
 157 nouveau_pm_perflvl_info(struct nouveau_pm_level *perflvl, char *ptr, int len)
 158 {
 159         char c[16], s[16], v[16], f[16];
 160
 161         c[0] = '\0';
 162         if (perflvl->core)
 163                 snprintf(c, sizeof(c), " core %dMHz", perflvl->core / 1000);
 164
 165         s[0] = '\0';
 166         if (perflvl->shader)
 167                 snprintf(s, sizeof(s), " shader %dMHz", perflvl->shader / 1000);
 168
 169         v[0] = '\0';
 170         if (perflvl->voltage)
 171                 snprintf(v, sizeof(v), " voltage %dmV", perflvl->voltage * 10);
 172
 173         f[0] = '\0';
 174         if (perflvl->fanspeed)
 175                 snprintf(f, sizeof(f), " fanspeed %d%%", perflvl->fanspeed);
 176
 177         snprintf(ptr, len, "memory %dMHz%s%s%s%s\n", perflvl->memory / 1000,
 178                  c, s, v, f);
 179 }
 180
 181 static ssize_t
 182 nouveau_pm_get_perflvl_info(struct device *d,
 183                             struct device_attribute *a, char *buf)
 184 {
 185         struct nouveau_pm_level *perflvl = (struct nouveau_pm_level *)a;
 186         char *ptr = buf;
 187         int len = PAGE_SIZE;
 188
 189         snprintf(ptr, len, "%d: ", perflvl->id);
 190         ptr += strlen(buf);
 191         len -= strlen(buf);
 192
 193         nouveau_pm_perflvl_info(perflvl, ptr, len);
 194         return strlen(buf);
 195 }
 196
 197 static ssize_t
 198 nouveau_pm_get_perflvl(struct device *d, struct device_attribute *a, char *buf)
 199 {
 200         struct drm_device *dev = pci_get_drvdata(to_pci_dev(d));
 201         struct drm_nouveau_private *dev_priv = dev->dev_private;
 202         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 203         struct nouveau_pm_level cur;
 204         int len = PAGE_SIZE, ret;
 205         char *ptr = buf;
 206
 207         if (!pm->cur)
 208                 snprintf(ptr, len, "setting: boot\n");
 209         else if (pm->cur == &pm->boot)
 210                 snprintf(ptr, len, "setting: boot\nc: ");
 211         else
 212                 snprintf(ptr, len, "setting: static %d\nc: ", pm->cur->id);
 213         ptr += strlen(buf);
 214         len -= strlen(buf);
 215
 216         ret = nouveau_pm_perflvl_get(dev, &cur);
 217         if (ret == 0)
 218                 nouveau_pm_perflvl_info(&cur, ptr, len);
 219         return strlen(buf);
 220 }
 221
 222 static ssize_t
 223 nouveau_pm_set_perflvl(struct device *d, struct device_attribute *a,
 224                        const char *buf, size_t count)
 225 {
 226         struct drm_device *dev = pci_get_drvdata(to_pci_dev(d));
 227         int ret;
 228
 229         ret = nouveau_pm_profile_set(dev, buf);
 230         if (ret)
 231                 return ret;
 232         return strlen(buf);
 233 }
 234
 235 static DEVICE_ATTR(performance_level, S_IRUGO | S_IWUSR,
 236                    nouveau_pm_get_perflvl, nouveau_pm_set_perflvl);
 237
 238 static int
 239 nouveau_sysfs_init(struct drm_device *dev)
 240 {
 241         struct drm_nouveau_private *dev_priv = dev->dev_private;
 242         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 243         struct device *d = &dev->pdev->dev;
 244         int ret, i;
 245
 246         ret = device_create_file(d, &dev_attr_performance_level);
 247         if (ret)
 248                 return ret;
 249
 250         for (i = 0; i < pm->nr_perflvl; i++) {
 251                 struct nouveau_pm_level *perflvl = &pm->perflvl[i];
 252
 253                 perflvl->dev_attr.attr.name = perflvl->name;
 254                 perflvl->dev_attr.attr.mode = S_IRUGO;
 255                 perflvl->dev_attr.show = nouveau_pm_get_perflvl_info;
 256                 perflvl->dev_attr.store = NULL;
 257                 sysfs_attr_init(&perflvl->dev_attr.attr);
 258
 259                 ret = device_create_file(d, &perflvl->dev_attr);
 260                 if (ret) {
 261                         NV_ERROR(dev, "failed pervlvl %d sysfs: %d\n",
 262                                  perflvl->id, i);
 263                         perflvl->dev_attr.attr.name = NULL;
 264                         nouveau_pm_fini(dev);
 265                         return ret;
 266                 }
 267         }
 268
 269         return 0;
 270 }
 271
 272 static void
 273 nouveau_sysfs_fini(struct drm_device *dev)
 274 {
 275         struct drm_nouveau_private *dev_priv = dev->dev_private;
 276         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 277         struct device *d = &dev->pdev->dev;
 278         int i;
 279
 280         device_remove_file(d, &dev_attr_performance_level);
 281         for (i = 0; i < pm->nr_perflvl; i++) {
 282                 struct nouveau_pm_level *pl = &pm->perflvl[i];
 283
 284                 if (!pl->dev_attr.attr.name)
 285                         break;
 286
 287                 device_remove_file(d, &pl->dev_attr);
 288         }
 289 }
 290
 291 #ifdef CONFIG_HWMON
 292 static ssize_t
 293 nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf)
 294 {
 295         struct drm_device *dev = dev_get_drvdata(d);
 296         struct drm_nouveau_private *dev_priv = dev->dev_private;
 297         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 298
 299         return snprintf(buf, PAGE_SIZE, "%d\n", pm->temp_get(dev)*1000);
 300 }
 301 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, nouveau_hwmon_show_temp,
 302                                                   NULL, 0);
 303
 304 static ssize_t
 305 nouveau_hwmon_max_temp(struct device *d, struct device_attribute *a, char *buf)
 306 {
 307         struct drm_device *dev = dev_get_drvdata(d);
 308         struct drm_nouveau_private *dev_priv = dev->dev_private;
 309         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 310         struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
 311
 312         return snprintf(buf, PAGE_SIZE, "%d\n", temp->down_clock*1000);
 313 }
 314 static ssize_t
 315 nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a,
 316                                                 const char *buf, size_t count)
 317 {
 318         struct drm_device *dev = dev_get_drvdata(d);
 319         struct drm_nouveau_private *dev_priv = dev->dev_private;
 320         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 321         struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
 322         long value;
 323
 324         if (strict_strtol(buf, 10, &value) == -EINVAL)
 325                 return count;
 326
 327         temp->down_clock = value/1000;
 328
 329         nouveau_temp_safety_checks(dev);
 330
 331         return count;
 332 }
 333 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, nouveau_hwmon_max_temp,
 334                                                   nouveau_hwmon_set_max_temp,
 335                                                   0);
 336
 337 static ssize_t
 338 nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a,
 339                                                         char *buf)
 340 {
 341         struct drm_device *dev = dev_get_drvdata(d);
 342         struct drm_nouveau_private *dev_priv = dev->dev_private;
 343         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 344         struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
 345
 346         return snprintf(buf, PAGE_SIZE, "%d\n", temp->critical*1000);
 347 }
 348 static ssize_t
 349 nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a,
 350                                                             const char *buf,
 351                                                                 size_t count)
 352 {
 353         struct drm_device *dev = dev_get_drvdata(d);
 354         struct drm_nouveau_private *dev_priv = dev->dev_private;
 355         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 356         struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
 357         long value;
 358
 359         if (strict_strtol(buf, 10, &value) == -EINVAL)
 360                 return count;
 361
 362         temp->critical = value/1000;
 363
 364         nouveau_temp_safety_checks(dev);
 365
 366         return count;
 367 }
 368 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
 369                                                 nouveau_hwmon_critical_temp,
 370                                                 nouveau_hwmon_set_critical_temp,
 371                                                 0);
 372
 373 static ssize_t nouveau_hwmon_show_name(struct device *dev,
 374                                       struct device_attribute *attr,
 375                                       char *buf)
 376 {
 377         return sprintf(buf, "nouveau\n");
 378 }
 379 static SENSOR_DEVICE_ATTR(name, S_IRUGO, nouveau_hwmon_show_name, NULL, 0);
 380
 381 static ssize_t nouveau_hwmon_show_update_rate(struct device *dev,
 382                                       struct device_attribute *attr,
 383                                       char *buf)
 384 {
 385         return sprintf(buf, "1000\n");
 386 }
 387 static SENSOR_DEVICE_ATTR(update_rate, S_IRUGO,
 388                                                 nouveau_hwmon_show_update_rate,
 389                                                 NULL, 0);
 390
 391 static struct attribute *hwmon_attributes[] = {
 392         &sensor_dev_attr_temp1_input.dev_attr.attr,
 393         &sensor_dev_attr_temp1_max.dev_attr.attr,
 394         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 395         &sensor_dev_attr_name.dev_attr.attr,
 396         &sensor_dev_attr_update_rate.dev_attr.attr,
 397         NULL
 398 };
 399
 400 static const struct attribute_group hwmon_attrgroup = {
 401         .attrs = hwmon_attributes,
 402 };
 403 #endif
 404
 405 static int
 406 nouveau_hwmon_init(struct drm_device *dev)
 407 {
 408 #ifdef CONFIG_HWMON
 409         struct drm_nouveau_private *dev_priv = dev->dev_private;
 410         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 411         struct device *hwmon_dev;
 412         int ret;
 413
 414         if (!pm->temp_get)
 415                 return -ENODEV;
 416
 417         hwmon_dev = hwmon_device_register(&dev->pdev->dev);
 418         if (IS_ERR(hwmon_dev)) {
 419                 ret = PTR_ERR(hwmon_dev);
 420                 NV_ERROR(dev,
 421                         "Unable to register hwmon device: %d\n", ret);
 422                 return ret;
 423         }
 424         dev_set_drvdata(hwmon_dev, dev);
 425         ret = sysfs_create_group(&dev->pdev->dev.kobj, &hwmon_attrgroup);
 426         if (ret) {
 427                 NV_ERROR(dev,
 428                         "Unable to create hwmon sysfs file: %d\n", ret);
 429                 hwmon_device_unregister(hwmon_dev);
 430                 return ret;
 431         }
 432
 433         pm->hwmon = hwmon_dev;
 434 #endif
 435         return 0;
 436 }
 437
 438 static void
 439 nouveau_hwmon_fini(struct drm_device *dev)
 440 {
 441 #ifdef CONFIG_HWMON
 442         struct drm_nouveau_private *dev_priv = dev->dev_private;
 443         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 444
 445         if (pm->hwmon) {
 446                 sysfs_remove_group(&dev->pdev->dev.kobj, &hwmon_attrgroup);
 447                 hwmon_device_unregister(pm->hwmon);
 448         }
 449 #endif
 450 }
 451
 452 #ifdef CONFIG_ACPI
 453 static int
 454 nouveau_pm_acpi_event(struct notifier_block *nb, unsigned long val, void *data)
 455 {
 456         struct drm_nouveau_private *dev_priv =
 457                 container_of(nb, struct drm_nouveau_private, engine.pm.acpi_nb);
 458         struct drm_device *dev = dev_priv->dev;
 459         struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
 460
 461         if (strcmp(entry->device_class, "ac_adapter") == 0) {
 462                 bool ac = power_supply_is_system_supplied();
 463
 464                 NV_DEBUG(dev, "power supply changed: %s\n", ac ? "AC" : "DC");
 465         }
 466
 467         return NOTIFY_OK;
 468 }
 469 #endif
 470
 471 int
 472 nouveau_pm_init(struct drm_device *dev)
 473 {
 474         struct drm_nouveau_private *dev_priv = dev->dev_private;
 475         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 476         char info[256];
 477         int ret, i;
 478
 479         nouveau_volt_init(dev);
 480         nouveau_perf_init(dev);
 481         nouveau_temp_init(dev);
 482         nouveau_mem_timing_init(dev);
 483
 484         NV_INFO(dev, "%d available performance level(s)\n", pm->nr_perflvl);
 485         for (i = 0; i < pm->nr_perflvl; i++) {
 486                 nouveau_pm_perflvl_info(&pm->perflvl[i], info, sizeof(info));
 487                 NV_INFO(dev, "%d: %s", pm->perflvl[i].id, info);
 488         }
 489
 490         /* determine current ("boot") performance level */
 491         ret = nouveau_pm_perflvl_get(dev, &pm->boot);
 492         if (ret == 0) {
 493                 pm->cur = &pm->boot;
 494
 495                 nouveau_pm_perflvl_info(&pm->boot, info, sizeof(info));
 496                 NV_INFO(dev, "c: %s", info);
 497         }
 498
 499         /* switch performance levels now if requested */
 500         if (nouveau_perflvl != NULL) {
 501                 ret = nouveau_pm_profile_set(dev, nouveau_perflvl);
 502                 if (ret) {
 503                         NV_ERROR(dev, "error setting perflvl \"%s\": %d\n",
 504                                  nouveau_perflvl, ret);
 505                 }
 506         }
 507
 508         nouveau_sysfs_init(dev);
 509         nouveau_hwmon_init(dev);
 510 #ifdef CONFIG_ACPI
 511         pm->acpi_nb.notifier_call = nouveau_pm_acpi_event;
 512         register_acpi_notifier(&pm->acpi_nb);
 513 #endif
 514
 515         return 0;
 516 }
 517
 518 void
 519 nouveau_pm_fini(struct drm_device *dev)
 520 {
 521         struct drm_nouveau_private *dev_priv = dev->dev_private;
 522         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 523
 524         if (pm->cur != &pm->boot)
 525                 nouveau_pm_perflvl_set(dev, &pm->boot);
 526
 527         nouveau_mem_timing_fini(dev);
 528         nouveau_temp_fini(dev);
 529         nouveau_perf_fini(dev);
 530         nouveau_volt_fini(dev);
 531
 532 #ifdef CONFIG_ACPI
 533         unregister_acpi_notifier(&pm->acpi_nb);
 534 #endif
 535         nouveau_hwmon_fini(dev);
 536         nouveau_sysfs_fini(dev);
 537 }
 538
 539 void
 540 nouveau_pm_resume(struct drm_device *dev)
 541 {
 542         struct drm_nouveau_private *dev_priv = dev->dev_private;
 543         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 544         struct nouveau_pm_level *perflvl;
 545
 546         if (pm->cur == &pm->boot)
 547                 return;
 548
 549         perflvl = pm->cur;
 550         pm->cur = &pm->boot;
 551         nouveau_pm_perflvl_set(dev, perflvl);
 552 }