drivers/base/power/sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* sysfs entries for device PM */
   3 #include <linux/device.h>
   4 #include <linux/kobject.h>
   5 #include <linux/string.h>
   6 #include <linux/export.h>
   7 #include <linux/pm_qos.h>
   8 #include <linux/pm_runtime.h>
   9 #include <linux/pm_wakeup.h>
  10 #include <linux/atomic.h>
  11 #include <linux/jiffies.h>
  12 #include "power.h"
  13
  14 /*
  15  *      control - Report/change current runtime PM setting of the device
  16  *
  17  *      Runtime power management of a device can be blocked with the help of
  18  *      this attribute.  All devices have one of the following two values for
  19  *      the power/control file:
  20  *
  21  *       + "auto\n" to allow the device to be power managed at run time;
  22  *       + "on\n" to prevent the device from being power managed at run time;
  23  *
  24  *      The default for all devices is "auto", which means that devices may be
  25  *      subject to automatic power management, depending on their drivers.
  26  *      Changing this attribute to "on" prevents the driver from power managing
  27  *      the device at run time.  Doing that while the device is suspended causes
  28  *      it to be woken up.
  29  *
  30  *      wakeup - Report/change current wakeup option for device
  31  *
  32  *      Some devices support "wakeup" events, which are hardware signals
  33  *      used to activate devices from suspended or low power states.  Such
  34  *      devices have one of three values for the sysfs power/wakeup file:
  35  *
  36  *       + "enabled\n" to issue the events;
  37  *       + "disabled\n" not to do so; or
  38  *       + "\n" for temporary or permanent inability to issue wakeup.
  39  *
  40  *      (For example, unconfigured USB devices can't issue wakeups.)
  41  *
  42  *      Familiar examples of devices that can issue wakeup events include
  43  *      keyboards and mice (both PS2 and USB styles), power buttons, modems,
  44  *      "Wake-On-LAN" Ethernet links, GPIO lines, and more.  Some events
  45  *      will wake the entire system from a suspend state; others may just
  46  *      wake up the device (if the system as a whole is already active).
  47  *      Some wakeup events use normal IRQ lines; other use special out
  48  *      of band signaling.
  49  *
  50  *      It is the responsibility of device drivers to enable (or disable)
  51  *      wakeup signaling as part of changing device power states, respecting
  52  *      the policy choices provided through the driver model.
  53  *
  54  *      Devices may not be able to generate wakeup events from all power
  55  *      states.  Also, the events may be ignored in some configurations;
  56  *      for example, they might need help from other devices that aren't
  57  *      active, or which may have wakeup disabled.  Some drivers rely on
  58  *      wakeup events internally (unless they are disabled), keeping
  59  *      their hardware in low power modes whenever they're unused.  This
  60  *      saves runtime power, without requiring system-wide sleep states.
  61  *
  62  *      async - Report/change current async suspend setting for the device
  63  *
  64  *      Asynchronous suspend and resume of the device during system-wide power
  65  *      state transitions can be enabled by writing "enabled" to this file.
  66  *      Analogously, if "disabled" is written to this file, the device will be
  67  *      suspended and resumed synchronously.
  68  *
  69  *      All devices have one of the following two values for power/async:
  70  *
  71  *       + "enabled\n" to permit the asynchronous suspend/resume of the device;
  72  *       + "disabled\n" to forbid it;
  73  *
  74  *      NOTE: It generally is unsafe to permit the asynchronous suspend/resume
  75  *      of a device unless it is certain that all of the PM dependencies of the
  76  *      device are known to the PM core.  However, for some devices this
  77  *      attribute is set to "enabled" by bus type code or device drivers and in
  78  *      that cases it should be safe to leave the default value.
  79  *
  80  *      autosuspend_delay_ms - Report/change a device's autosuspend_delay value
  81  *
  82  *      Some drivers don't want to carry out a runtime suspend as soon as a
  83  *      device becomes idle; they want it always to remain idle for some period
  84  *      of time before suspending it.  This period is the autosuspend_delay
  85  *      value (expressed in milliseconds) and it can be controlled by the user.
  86  *      If the value is negative then the device will never be runtime
  87  *      suspended.
  88  *
  89  *      NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
  90  *      value are used only if the driver calls pm_runtime_use_autosuspend().
  91  *
  92  *      wakeup_count - Report the number of wakeup events related to the device
  93  */
  94
  95 const char power_group_name[] = "power";
  96 EXPORT_SYMBOL_GPL(power_group_name);
  97
  98 static const char ctrl_auto[] = "auto";
  99 static const char ctrl_on[] = "on";
 100
 101 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
 102                             char *buf)
 103 {
 104         return sprintf(buf, "%s\n",
 105                                 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
 106 }
 107
 108 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
 109                              const char * buf, size_t n)
 110 {
 111         device_lock(dev);
 112         if (sysfs_streq(buf, ctrl_auto))
 113                 pm_runtime_allow(dev);
 114         else if (sysfs_streq(buf, ctrl_on))
 115                 pm_runtime_forbid(dev);
 116         else
 117                 n = -EINVAL;
 118         device_unlock(dev);
 119         return n;
 120 }
 121
 122 static DEVICE_ATTR_RW(control);
 123
 124 static ssize_t runtime_active_time_show(struct device *dev,
 125                                 struct device_attribute *attr, char *buf)
 126 {
 127         int ret;
 128         u64 tmp = pm_runtime_active_time(dev);
 129         do_div(tmp, NSEC_PER_MSEC);
 130         ret = sprintf(buf, "%llu\n", tmp);
 131         return ret;
 132 }
 133
 134 static DEVICE_ATTR_RO(runtime_active_time);
 135
 136 static ssize_t runtime_suspended_time_show(struct device *dev,
 137                                 struct device_attribute *attr, char *buf)
 138 {
 139         int ret;
 140         u64 tmp = pm_runtime_suspended_time(dev);
 141         do_div(tmp, NSEC_PER_MSEC);
 142         ret = sprintf(buf, "%llu\n", tmp);
 143         return ret;
 144 }
 145
 146 static DEVICE_ATTR_RO(runtime_suspended_time);
 147
 148 static ssize_t runtime_status_show(struct device *dev,
 149                                 struct device_attribute *attr, char *buf)
 150 {
 151         const char *p;
 152
 153         if (dev->power.runtime_error) {
 154                 p = "error\n";
 155         } else if (dev->power.disable_depth) {
 156                 p = "unsupported\n";
 157         } else {
 158                 switch (dev->power.runtime_status) {
 159                 case RPM_SUSPENDED:
 160                         p = "suspended\n";
 161                         break;
 162                 case RPM_SUSPENDING:
 163                         p = "suspending\n";
 164                         break;
 165                 case RPM_RESUMING:
 166                         p = "resuming\n";
 167                         break;
 168                 case RPM_ACTIVE:
 169                         p = "active\n";
 170                         break;
 171                 default:
 172                         return -EIO;
 173                 }
 174         }
 175         return sprintf(buf, p);
 176 }
 177
 178 static DEVICE_ATTR_RO(runtime_status);
 179
 180 static ssize_t autosuspend_delay_ms_show(struct device *dev,
 181                 struct device_attribute *attr, char *buf)
 182 {
 183         if (!dev->power.use_autosuspend)
 184                 return -EIO;
 185         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
 186 }
 187
 188 static ssize_t autosuspend_delay_ms_store(struct device *dev,
 189                 struct device_attribute *attr, const char *buf, size_t n)
 190 {
 191         long delay;
 192
 193         if (!dev->power.use_autosuspend)
 194                 return -EIO;
 195
 196         if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
 197                 return -EINVAL;
 198
 199         device_lock(dev);
 200         pm_runtime_set_autosuspend_delay(dev, delay);
 201         device_unlock(dev);
 202         return n;
 203 }
 204
 205 static DEVICE_ATTR_RW(autosuspend_delay_ms);
 206
 207 static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
 208                                              struct device_attribute *attr,
 209                                              char *buf)
 210 {
 211         s32 value = dev_pm_qos_requested_resume_latency(dev);
 212
 213         if (value == 0)
 214                 return sprintf(buf, "n/a\n");
 215         if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
 216                 value = 0;
 217
 218         return sprintf(buf, "%d\n", value);
 219 }
 220
 221 static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
 222                                               struct device_attribute *attr,
 223                                               const char *buf, size_t n)
 224 {
 225         s32 value;
 226         int ret;
 227
 228         if (!kstrtos32(buf, 0, &value)) {
 229                 /*
 230                  * Prevent users from writing negative or "no constraint" values
 231                  * directly.
 232                  */
 233                 if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
 234                         return -EINVAL;
 235
 236                 if (value == 0)
 237                         value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
 238         } else if (sysfs_streq(buf, "n/a")) {
 239                 value = 0;
 240         } else {
 241                 return -EINVAL;
 242         }
 243
 244         ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
 245                                         value);
 246         return ret < 0 ? ret : n;
 247 }
 248
 249 static DEVICE_ATTR_RW(pm_qos_resume_latency_us);
 250
 251 static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
 252                                                 struct device_attribute *attr,
 253                                                 char *buf)
 254 {
 255         s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
 256
 257         if (value < 0)
 258                 return sprintf(buf, "auto\n");
 259         if (value == PM_QOS_LATENCY_ANY)
 260                 return sprintf(buf, "any\n");
 261
 262         return sprintf(buf, "%d\n", value);
 263 }
 264
 265 static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
 266                                                  struct device_attribute *attr,
 267                                                  const char *buf, size_t n)
 268 {
 269         s32 value;
 270         int ret;
 271
 272         if (kstrtos32(buf, 0, &value) == 0) {
 273                 /* Users can't write negative values directly */
 274                 if (value < 0)
 275                         return -EINVAL;
 276         } else {
 277                 if (sysfs_streq(buf, "auto"))
 278                         value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
 279                 else if (sysfs_streq(buf, "any"))
 280                         value = PM_QOS_LATENCY_ANY;
 281                 else
 282                         return -EINVAL;
 283         }
 284         ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
 285         return ret < 0 ? ret : n;
 286 }
 287
 288 static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us);
 289
 290 static ssize_t pm_qos_no_power_off_show(struct device *dev,
 291                                         struct device_attribute *attr,
 292                                         char *buf)
 293 {
 294         return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
 295                                         & PM_QOS_FLAG_NO_POWER_OFF));
 296 }
 297
 298 static ssize_t pm_qos_no_power_off_store(struct device *dev,
 299                                          struct device_attribute *attr,
 300                                          const char *buf, size_t n)
 301 {
 302         int ret;
 303
 304         if (kstrtoint(buf, 0, &ret))
 305                 return -EINVAL;
 306
 307         if (ret != 0 && ret != 1)
 308                 return -EINVAL;
 309
 310         ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
 311         return ret < 0 ? ret : n;
 312 }
 313
 314 static DEVICE_ATTR_RW(pm_qos_no_power_off);
 315
 316 #ifdef CONFIG_PM_SLEEP
 317 static const char _enabled[] = "enabled";
 318 static const char _disabled[] = "disabled";
 319
 320 static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
 321                            char *buf)
 322 {
 323         return sprintf(buf, "%s\n", device_can_wakeup(dev)
 324                 ? (device_may_wakeup(dev) ? _enabled : _disabled)
 325                 : "");
 326 }
 327
 328 static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
 329                             const char *buf, size_t n)
 330 {
 331         if (!device_can_wakeup(dev))
 332                 return -EINVAL;
 333
 334         if (sysfs_streq(buf, _enabled))
 335                 device_set_wakeup_enable(dev, 1);
 336         else if (sysfs_streq(buf, _disabled))
 337                 device_set_wakeup_enable(dev, 0);
 338         else
 339                 return -EINVAL;
 340         return n;
 341 }
 342
 343 static DEVICE_ATTR_RW(wakeup);
 344
 345 static ssize_t wakeup_count_show(struct device *dev,
 346                                  struct device_attribute *attr, char *buf)
 347 {
 348         unsigned long count = 0;
 349         bool enabled = false;
 350
 351         spin_lock_irq(&dev->power.lock);
 352         if (dev->power.wakeup) {
 353                 count = dev->power.wakeup->wakeup_count;
 354                 enabled = true;
 355         }
 356         spin_unlock_irq(&dev->power.lock);
 357         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 358 }
 359
 360 static DEVICE_ATTR_RO(wakeup_count);
 361
 362 static ssize_t wakeup_active_count_show(struct device *dev,
 363                                         struct device_attribute *attr,
 364                                         char *buf)
 365 {
 366         unsigned long count = 0;
 367         bool enabled = false;
 368
 369         spin_lock_irq(&dev->power.lock);
 370         if (dev->power.wakeup) {
 371                 count = dev->power.wakeup->active_count;
 372                 enabled = true;
 373         }
 374         spin_unlock_irq(&dev->power.lock);
 375         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 376 }
 377
 378 static DEVICE_ATTR_RO(wakeup_active_count);
 379
 380 static ssize_t wakeup_abort_count_show(struct device *dev,
 381                                        struct device_attribute *attr,
 382                                        char *buf)
 383 {
 384         unsigned long count = 0;
 385         bool enabled = false;
 386
 387         spin_lock_irq(&dev->power.lock);
 388         if (dev->power.wakeup) {
 389                 count = dev->power.wakeup->wakeup_count;
 390                 enabled = true;
 391         }
 392         spin_unlock_irq(&dev->power.lock);
 393         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 394 }
 395
 396 static DEVICE_ATTR_RO(wakeup_abort_count);
 397
 398 static ssize_t wakeup_expire_count_show(struct device *dev,
 399                                         struct device_attribute *attr,
 400                                         char *buf)
 401 {
 402         unsigned long count = 0;
 403         bool enabled = false;
 404
 405         spin_lock_irq(&dev->power.lock);
 406         if (dev->power.wakeup) {
 407                 count = dev->power.wakeup->expire_count;
 408                 enabled = true;
 409         }
 410         spin_unlock_irq(&dev->power.lock);
 411         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 412 }
 413
 414 static DEVICE_ATTR_RO(wakeup_expire_count);
 415
 416 static ssize_t wakeup_active_show(struct device *dev,
 417                                   struct device_attribute *attr, char *buf)
 418 {
 419         unsigned int active = 0;
 420         bool enabled = false;
 421
 422         spin_lock_irq(&dev->power.lock);
 423         if (dev->power.wakeup) {
 424                 active = dev->power.wakeup->active;
 425                 enabled = true;
 426         }
 427         spin_unlock_irq(&dev->power.lock);
 428         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
 429 }
 430
 431 static DEVICE_ATTR_RO(wakeup_active);
 432
 433 static ssize_t wakeup_total_time_ms_show(struct device *dev,
 434                                          struct device_attribute *attr,
 435                                          char *buf)
 436 {
 437         s64 msec = 0;
 438         bool enabled = false;
 439
 440         spin_lock_irq(&dev->power.lock);
 441         if (dev->power.wakeup) {
 442                 msec = ktime_to_ms(dev->power.wakeup->total_time);
 443                 enabled = true;
 444         }
 445         spin_unlock_irq(&dev->power.lock);
 446         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 447 }
 448
 449 static DEVICE_ATTR_RO(wakeup_total_time_ms);
 450
 451 static ssize_t wakeup_max_time_ms_show(struct device *dev,
 452                                        struct device_attribute *attr, char *buf)
 453 {
 454         s64 msec = 0;
 455         bool enabled = false;
 456
 457         spin_lock_irq(&dev->power.lock);
 458         if (dev->power.wakeup) {
 459                 msec = ktime_to_ms(dev->power.wakeup->max_time);
 460                 enabled = true;
 461         }
 462         spin_unlock_irq(&dev->power.lock);
 463         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 464 }
 465
 466 static DEVICE_ATTR_RO(wakeup_max_time_ms);
 467
 468 static ssize_t wakeup_last_time_ms_show(struct device *dev,
 469                                         struct device_attribute *attr,
 470                                         char *buf)
 471 {
 472         s64 msec = 0;
 473         bool enabled = false;
 474
 475         spin_lock_irq(&dev->power.lock);
 476         if (dev->power.wakeup) {
 477                 msec = ktime_to_ms(dev->power.wakeup->last_time);
 478                 enabled = true;
 479         }
 480         spin_unlock_irq(&dev->power.lock);
 481         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 482 }
 483
 484 static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
 485                                                 kgid_t kgid)
 486 {
 487         if (dev->power.wakeup && dev->power.wakeup->dev)
 488                 return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
 489         return 0;
 490 }
 491
 492 static DEVICE_ATTR_RO(wakeup_last_time_ms);
 493
 494 #ifdef CONFIG_PM_AUTOSLEEP
 495 static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
 496                                                  struct device_attribute *attr,
 497                                                  char *buf)
 498 {
 499         s64 msec = 0;
 500         bool enabled = false;
 501
 502         spin_lock_irq(&dev->power.lock);
 503         if (dev->power.wakeup) {
 504                 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
 505                 enabled = true;
 506         }
 507         spin_unlock_irq(&dev->power.lock);
 508         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 509 }
 510
 511 static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
 512 #endif /* CONFIG_PM_AUTOSLEEP */
 513 #else /* CONFIG_PM_SLEEP */
 514 static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
 515                                                 kgid_t kgid)
 516 {
 517         return 0;
 518 }
 519 #endif
 520
 521 #ifdef CONFIG_PM_ADVANCED_DEBUG
 522 static ssize_t runtime_usage_show(struct device *dev,
 523                                   struct device_attribute *attr, char *buf)
 524 {
 525         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
 526 }
 527 static DEVICE_ATTR_RO(runtime_usage);
 528
 529 static ssize_t runtime_active_kids_show(struct device *dev,
 530                                         struct device_attribute *attr,
 531                                         char *buf)
 532 {
 533         return sprintf(buf, "%d\n", dev->power.ignore_children ?
 534                 0 : atomic_read(&dev->power.child_count));
 535 }
 536 static DEVICE_ATTR_RO(runtime_active_kids);
 537
 538 static ssize_t runtime_enabled_show(struct device *dev,
 539                                     struct device_attribute *attr, char *buf)
 540 {
 541         if (dev->power.disable_depth && (dev->power.runtime_auto == false))
 542                 return sprintf(buf, "disabled & forbidden\n");
 543         if (dev->power.disable_depth)
 544                 return sprintf(buf, "disabled\n");
 545         if (dev->power.runtime_auto == false)
 546                 return sprintf(buf, "forbidden\n");
 547         return sprintf(buf, "enabled\n");
 548 }
 549 static DEVICE_ATTR_RO(runtime_enabled);
 550
 551 #ifdef CONFIG_PM_SLEEP
 552 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 553                           char *buf)
 554 {
 555         return sprintf(buf, "%s\n",
 556                         device_async_suspend_enabled(dev) ?
 557                                 _enabled : _disabled);
 558 }
 559
 560 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 561                            const char *buf, size_t n)
 562 {
 563         if (sysfs_streq(buf, _enabled))
 564                 device_enable_async_suspend(dev);
 565         else if (sysfs_streq(buf, _disabled))
 566                 device_disable_async_suspend(dev);
 567         else
 568                 return -EINVAL;
 569         return n;
 570 }
 571
 572 static DEVICE_ATTR_RW(async);
 573
 574 #endif /* CONFIG_PM_SLEEP */
 575 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 576
 577 static struct attribute *power_attrs[] = {
 578 #ifdef CONFIG_PM_ADVANCED_DEBUG
 579 #ifdef CONFIG_PM_SLEEP
 580         &dev_attr_async.attr,
 581 #endif
 582         &dev_attr_runtime_status.attr,
 583         &dev_attr_runtime_usage.attr,
 584         &dev_attr_runtime_active_kids.attr,
 585         &dev_attr_runtime_enabled.attr,
 586 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 587         NULL,
 588 };
 589 static const struct attribute_group pm_attr_group = {
 590         .name   = power_group_name,
 591         .attrs  = power_attrs,
 592 };
 593
 594 static struct attribute *wakeup_attrs[] = {
 595 #ifdef CONFIG_PM_SLEEP
 596         &dev_attr_wakeup.attr,
 597         &dev_attr_wakeup_count.attr,
 598         &dev_attr_wakeup_active_count.attr,
 599         &dev_attr_wakeup_abort_count.attr,
 600         &dev_attr_wakeup_expire_count.attr,
 601         &dev_attr_wakeup_active.attr,
 602         &dev_attr_wakeup_total_time_ms.attr,
 603         &dev_attr_wakeup_max_time_ms.attr,
 604         &dev_attr_wakeup_last_time_ms.attr,
 605 #ifdef CONFIG_PM_AUTOSLEEP
 606         &dev_attr_wakeup_prevent_sleep_time_ms.attr,
 607 #endif
 608 #endif
 609         NULL,
 610 };
 611 static const struct attribute_group pm_wakeup_attr_group = {
 612         .name   = power_group_name,
 613         .attrs  = wakeup_attrs,
 614 };
 615
 616 static struct attribute *runtime_attrs[] = {
 617 #ifndef CONFIG_PM_ADVANCED_DEBUG
 618         &dev_attr_runtime_status.attr,
 619 #endif
 620         &dev_attr_control.attr,
 621         &dev_attr_runtime_suspended_time.attr,
 622         &dev_attr_runtime_active_time.attr,
 623         &dev_attr_autosuspend_delay_ms.attr,
 624         NULL,
 625 };
 626 static const struct attribute_group pm_runtime_attr_group = {
 627         .name   = power_group_name,
 628         .attrs  = runtime_attrs,
 629 };
 630
 631 static struct attribute *pm_qos_resume_latency_attrs[] = {
 632         &dev_attr_pm_qos_resume_latency_us.attr,
 633         NULL,
 634 };
 635 static const struct attribute_group pm_qos_resume_latency_attr_group = {
 636         .name   = power_group_name,
 637         .attrs  = pm_qos_resume_latency_attrs,
 638 };
 639
 640 static struct attribute *pm_qos_latency_tolerance_attrs[] = {
 641         &dev_attr_pm_qos_latency_tolerance_us.attr,
 642         NULL,
 643 };
 644 static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
 645         .name   = power_group_name,
 646         .attrs  = pm_qos_latency_tolerance_attrs,
 647 };
 648
 649 static struct attribute *pm_qos_flags_attrs[] = {
 650         &dev_attr_pm_qos_no_power_off.attr,
 651         NULL,
 652 };
 653 static const struct attribute_group pm_qos_flags_attr_group = {
 654         .name   = power_group_name,
 655         .attrs  = pm_qos_flags_attrs,
 656 };
 657
 658 int dpm_sysfs_add(struct device *dev)
 659 {
 660         int rc;
 661
 662         /* No need to create PM sysfs if explicitly disabled. */
 663         if (device_pm_not_required(dev))
 664                 return 0;
 665
 666         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 667         if (rc)
 668                 return rc;
 669
 670         if (!pm_runtime_has_no_callbacks(dev)) {
 671                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 672                 if (rc)
 673                         goto err_out;
 674         }
 675         if (device_can_wakeup(dev)) {
 676                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 677                 if (rc)
 678                         goto err_runtime;
 679         }
 680         if (dev->power.set_latency_tolerance) {
 681                 rc = sysfs_merge_group(&dev->kobj,
 682                                        &pm_qos_latency_tolerance_attr_group);
 683                 if (rc)
 684                         goto err_wakeup;
 685         }
 686         rc = pm_wakeup_source_sysfs_add(dev);
 687         if (rc)
 688                 goto err_latency;
 689         return 0;
 690
 691  err_latency:
 692         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
 693  err_wakeup:
 694         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 695  err_runtime:
 696         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 697  err_out:
 698         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 699         return rc;
 700 }
 701
 702 int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
 703 {
 704         int rc;
 705
 706         if (device_pm_not_required(dev))
 707                 return 0;
 708
 709         rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
 710         if (rc)
 711                 return rc;
 712
 713         if (!pm_runtime_has_no_callbacks(dev)) {
 714                 rc = sysfs_group_change_owner(
 715                         &dev->kobj, &pm_runtime_attr_group, kuid, kgid);
 716                 if (rc)
 717                         return rc;
 718         }
 719
 720         if (device_can_wakeup(dev)) {
 721                 rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
 722                                               kuid, kgid);
 723                 if (rc)
 724                         return rc;
 725
 726                 rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
 727                 if (rc)
 728                         return rc;
 729         }
 730
 731         if (dev->power.set_latency_tolerance) {
 732                 rc = sysfs_group_change_owner(
 733                         &dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
 734                         kgid);
 735                 if (rc)
 736                         return rc;
 737         }
 738         return 0;
 739 }
 740
 741 int wakeup_sysfs_add(struct device *dev)
 742 {
 743         int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 744
 745         if (!ret)
 746                 kobject_uevent(&dev->kobj, KOBJ_CHANGE);
 747
 748         return ret;
 749 }
 750
 751 void wakeup_sysfs_remove(struct device *dev)
 752 {
 753         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 754         kobject_uevent(&dev->kobj, KOBJ_CHANGE);
 755 }
 756
 757 int pm_qos_sysfs_add_resume_latency(struct device *dev)
 758 {
 759         return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
 760 }
 761
 762 void pm_qos_sysfs_remove_resume_latency(struct device *dev)
 763 {
 764         sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
 765 }
 766
 767 int pm_qos_sysfs_add_flags(struct device *dev)
 768 {
 769         return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
 770 }
 771
 772 void pm_qos_sysfs_remove_flags(struct device *dev)
 773 {
 774         sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
 775 }
 776
 777 int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
 778 {
 779         return sysfs_merge_group(&dev->kobj,
 780                                  &pm_qos_latency_tolerance_attr_group);
 781 }
 782
 783 void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
 784 {
 785         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
 786 }
 787
 788 void rpm_sysfs_remove(struct device *dev)
 789 {
 790         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 791 }
 792
 793 void dpm_sysfs_remove(struct device *dev)
 794 {
 795         if (device_pm_not_required(dev))
 796                 return;
 797         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
 798         dev_pm_qos_constraints_destroy(dev);
 799         rpm_sysfs_remove(dev);
 800         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 801         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 802 }