drivers/base/power/sysfs.c

   1 /*
   2  * drivers/base/power/sysfs.c - sysfs entries for device PM
   3  */
   4
   5 #include <linux/device.h>
   6 #include <linux/string.h>
   7 #include <linux/export.h>
   8 #include <linux/pm_qos.h>
   9 #include <linux/pm_runtime.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         char *cp;
 112         int len = n;
 113
 114         cp = memchr(buf, '\n', n);
 115         if (cp)
 116                 len = cp - buf;
 117         device_lock(dev);
 118         if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
 119                 pm_runtime_allow(dev);
 120         else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
 121                 pm_runtime_forbid(dev);
 122         else
 123                 n = -EINVAL;
 124         device_unlock(dev);
 125         return n;
 126 }
 127
 128 static DEVICE_ATTR(control, 0644, control_show, control_store);
 129
 130 static ssize_t rtpm_active_time_show(struct device *dev,
 131                                 struct device_attribute *attr, char *buf)
 132 {
 133         int ret;
 134         spin_lock_irq(&dev->power.lock);
 135         update_pm_runtime_accounting(dev);
 136         ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
 137         spin_unlock_irq(&dev->power.lock);
 138         return ret;
 139 }
 140
 141 static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
 142
 143 static ssize_t rtpm_suspended_time_show(struct device *dev,
 144                                 struct device_attribute *attr, char *buf)
 145 {
 146         int ret;
 147         spin_lock_irq(&dev->power.lock);
 148         update_pm_runtime_accounting(dev);
 149         ret = sprintf(buf, "%i\n",
 150                 jiffies_to_msecs(dev->power.suspended_jiffies));
 151         spin_unlock_irq(&dev->power.lock);
 152         return ret;
 153 }
 154
 155 static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
 156
 157 static ssize_t rtpm_status_show(struct device *dev,
 158                                 struct device_attribute *attr, char *buf)
 159 {
 160         const char *p;
 161
 162         if (dev->power.runtime_error) {
 163                 p = "error\n";
 164         } else if (dev->power.disable_depth) {
 165                 p = "unsupported\n";
 166         } else {
 167                 switch (dev->power.runtime_status) {
 168                 case RPM_SUSPENDED:
 169                         p = "suspended\n";
 170                         break;
 171                 case RPM_SUSPENDING:
 172                         p = "suspending\n";
 173                         break;
 174                 case RPM_RESUMING:
 175                         p = "resuming\n";
 176                         break;
 177                 case RPM_ACTIVE:
 178                         p = "active\n";
 179                         break;
 180                 default:
 181                         return -EIO;
 182                 }
 183         }
 184         return sprintf(buf, p);
 185 }
 186
 187 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
 188
 189 static ssize_t autosuspend_delay_ms_show(struct device *dev,
 190                 struct device_attribute *attr, char *buf)
 191 {
 192         if (!dev->power.use_autosuspend)
 193                 return -EIO;
 194         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
 195 }
 196
 197 static ssize_t autosuspend_delay_ms_store(struct device *dev,
 198                 struct device_attribute *attr, const char *buf, size_t n)
 199 {
 200         long delay;
 201
 202         if (!dev->power.use_autosuspend)
 203                 return -EIO;
 204
 205         if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
 206                 return -EINVAL;
 207
 208         device_lock(dev);
 209         pm_runtime_set_autosuspend_delay(dev, delay);
 210         device_unlock(dev);
 211         return n;
 212 }
 213
 214 static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
 215                 autosuspend_delay_ms_store);
 216
 217 static ssize_t pm_qos_resume_latency_show(struct device *dev,
 218                                           struct device_attribute *attr,
 219                                           char *buf)
 220 {
 221         return sprintf(buf, "%d\n", dev_pm_qos_requested_resume_latency(dev));
 222 }
 223
 224 static ssize_t pm_qos_resume_latency_store(struct device *dev,
 225                                            struct device_attribute *attr,
 226                                            const char *buf, size_t n)
 227 {
 228         s32 value;
 229         int ret;
 230
 231         if (kstrtos32(buf, 0, &value))
 232                 return -EINVAL;
 233
 234         if (value < 0)
 235                 return -EINVAL;
 236
 237         ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
 238                                         value);
 239         return ret < 0 ? ret : n;
 240 }
 241
 242 static DEVICE_ATTR(pm_qos_resume_latency_us, 0644,
 243                    pm_qos_resume_latency_show, pm_qos_resume_latency_store);
 244
 245 static ssize_t pm_qos_latency_tolerance_show(struct device *dev,
 246                                              struct device_attribute *attr,
 247                                              char *buf)
 248 {
 249         s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
 250
 251         if (value < 0)
 252                 return sprintf(buf, "auto\n");
 253         else if (value == PM_QOS_LATENCY_ANY)
 254                 return sprintf(buf, "any\n");
 255
 256         return sprintf(buf, "%d\n", value);
 257 }
 258
 259 static ssize_t pm_qos_latency_tolerance_store(struct device *dev,
 260                                               struct device_attribute *attr,
 261                                               const char *buf, size_t n)
 262 {
 263         s32 value;
 264         int ret;
 265
 266         if (kstrtos32(buf, 0, &value) == 0) {
 267                 /* Users can't write negative values directly */
 268                 if (value < 0)
 269                         return -EINVAL;
 270         } else {
 271                 if (!strcmp(buf, "auto") || !strcmp(buf, "auto\n"))
 272                         value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
 273                 else if (!strcmp(buf, "any") || !strcmp(buf, "any\n"))
 274                         value = PM_QOS_LATENCY_ANY;
 275                 else
 276                         return -EINVAL;
 277         }
 278         ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
 279         return ret < 0 ? ret : n;
 280 }
 281
 282 static DEVICE_ATTR(pm_qos_latency_tolerance_us, 0644,
 283                    pm_qos_latency_tolerance_show, pm_qos_latency_tolerance_store);
 284
 285 static ssize_t pm_qos_no_power_off_show(struct device *dev,
 286                                         struct device_attribute *attr,
 287                                         char *buf)
 288 {
 289         return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
 290                                         & PM_QOS_FLAG_NO_POWER_OFF));
 291 }
 292
 293 static ssize_t pm_qos_no_power_off_store(struct device *dev,
 294                                          struct device_attribute *attr,
 295                                          const char *buf, size_t n)
 296 {
 297         int ret;
 298
 299         if (kstrtoint(buf, 0, &ret))
 300                 return -EINVAL;
 301
 302         if (ret != 0 && ret != 1)
 303                 return -EINVAL;
 304
 305         ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
 306         return ret < 0 ? ret : n;
 307 }
 308
 309 static DEVICE_ATTR(pm_qos_no_power_off, 0644,
 310                    pm_qos_no_power_off_show, pm_qos_no_power_off_store);
 311
 312 static ssize_t pm_qos_remote_wakeup_show(struct device *dev,
 313                                          struct device_attribute *attr,
 314                                          char *buf)
 315 {
 316         return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
 317                                         & PM_QOS_FLAG_REMOTE_WAKEUP));
 318 }
 319
 320 static ssize_t pm_qos_remote_wakeup_store(struct device *dev,
 321                                           struct device_attribute *attr,
 322                                           const char *buf, size_t n)
 323 {
 324         int ret;
 325
 326         if (kstrtoint(buf, 0, &ret))
 327                 return -EINVAL;
 328
 329         if (ret != 0 && ret != 1)
 330                 return -EINVAL;
 331
 332         ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP, ret);
 333         return ret < 0 ? ret : n;
 334 }
 335
 336 static DEVICE_ATTR(pm_qos_remote_wakeup, 0644,
 337                    pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store);
 338
 339 #ifdef CONFIG_PM_SLEEP
 340 static const char _enabled[] = "enabled";
 341 static const char _disabled[] = "disabled";
 342
 343 static ssize_t
 344 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 345 {
 346         return sprintf(buf, "%s\n", device_can_wakeup(dev)
 347                 ? (device_may_wakeup(dev) ? _enabled : _disabled)
 348                 : "");
 349 }
 350
 351 static ssize_t
 352 wake_store(struct device * dev, struct device_attribute *attr,
 353         const char * buf, size_t n)
 354 {
 355         char *cp;
 356         int len = n;
 357
 358         if (!device_can_wakeup(dev))
 359                 return -EINVAL;
 360
 361         cp = memchr(buf, '\n', n);
 362         if (cp)
 363                 len = cp - buf;
 364         if (len == sizeof _enabled - 1
 365                         && strncmp(buf, _enabled, sizeof _enabled - 1) == 0)
 366                 device_set_wakeup_enable(dev, 1);
 367         else if (len == sizeof _disabled - 1
 368                         && strncmp(buf, _disabled, sizeof _disabled - 1) == 0)
 369                 device_set_wakeup_enable(dev, 0);
 370         else
 371                 return -EINVAL;
 372         return n;
 373 }
 374
 375 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 376
 377 static ssize_t wakeup_count_show(struct device *dev,
 378                                 struct device_attribute *attr, char *buf)
 379 {
 380         unsigned long count = 0;
 381         bool enabled = false;
 382
 383         spin_lock_irq(&dev->power.lock);
 384         if (dev->power.wakeup) {
 385                 count = dev->power.wakeup->event_count;
 386                 enabled = true;
 387         }
 388         spin_unlock_irq(&dev->power.lock);
 389         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 390 }
 391
 392 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
 393
 394 static ssize_t wakeup_active_count_show(struct device *dev,
 395                                 struct device_attribute *attr, char *buf)
 396 {
 397         unsigned long count = 0;
 398         bool enabled = false;
 399
 400         spin_lock_irq(&dev->power.lock);
 401         if (dev->power.wakeup) {
 402                 count = dev->power.wakeup->active_count;
 403                 enabled = true;
 404         }
 405         spin_unlock_irq(&dev->power.lock);
 406         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 407 }
 408
 409 static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
 410
 411 static ssize_t wakeup_abort_count_show(struct device *dev,
 412                                         struct device_attribute *attr,
 413                                         char *buf)
 414 {
 415         unsigned long count = 0;
 416         bool enabled = false;
 417
 418         spin_lock_irq(&dev->power.lock);
 419         if (dev->power.wakeup) {
 420                 count = dev->power.wakeup->wakeup_count;
 421                 enabled = true;
 422         }
 423         spin_unlock_irq(&dev->power.lock);
 424         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 425 }
 426
 427 static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL);
 428
 429 static ssize_t wakeup_expire_count_show(struct device *dev,
 430                                         struct device_attribute *attr,
 431                                         char *buf)
 432 {
 433         unsigned long count = 0;
 434         bool enabled = false;
 435
 436         spin_lock_irq(&dev->power.lock);
 437         if (dev->power.wakeup) {
 438                 count = dev->power.wakeup->expire_count;
 439                 enabled = true;
 440         }
 441         spin_unlock_irq(&dev->power.lock);
 442         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 443 }
 444
 445 static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL);
 446
 447 static ssize_t wakeup_active_show(struct device *dev,
 448                                 struct device_attribute *attr, char *buf)
 449 {
 450         unsigned int active = 0;
 451         bool enabled = false;
 452
 453         spin_lock_irq(&dev->power.lock);
 454         if (dev->power.wakeup) {
 455                 active = dev->power.wakeup->active;
 456                 enabled = true;
 457         }
 458         spin_unlock_irq(&dev->power.lock);
 459         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
 460 }
 461
 462 static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
 463
 464 static ssize_t wakeup_total_time_show(struct device *dev,
 465                                 struct device_attribute *attr, char *buf)
 466 {
 467         s64 msec = 0;
 468         bool enabled = false;
 469
 470         spin_lock_irq(&dev->power.lock);
 471         if (dev->power.wakeup) {
 472                 msec = ktime_to_ms(dev->power.wakeup->total_time);
 473                 enabled = true;
 474         }
 475         spin_unlock_irq(&dev->power.lock);
 476         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 477 }
 478
 479 static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
 480
 481 static ssize_t wakeup_max_time_show(struct device *dev,
 482                                 struct device_attribute *attr, char *buf)
 483 {
 484         s64 msec = 0;
 485         bool enabled = false;
 486
 487         spin_lock_irq(&dev->power.lock);
 488         if (dev->power.wakeup) {
 489                 msec = ktime_to_ms(dev->power.wakeup->max_time);
 490                 enabled = true;
 491         }
 492         spin_unlock_irq(&dev->power.lock);
 493         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 494 }
 495
 496 static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
 497
 498 static ssize_t wakeup_last_time_show(struct device *dev,
 499                                 struct device_attribute *attr, char *buf)
 500 {
 501         s64 msec = 0;
 502         bool enabled = false;
 503
 504         spin_lock_irq(&dev->power.lock);
 505         if (dev->power.wakeup) {
 506                 msec = ktime_to_ms(dev->power.wakeup->last_time);
 507                 enabled = true;
 508         }
 509         spin_unlock_irq(&dev->power.lock);
 510         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 511 }
 512
 513 static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
 514
 515 #ifdef CONFIG_PM_AUTOSLEEP
 516 static ssize_t wakeup_prevent_sleep_time_show(struct device *dev,
 517                                               struct device_attribute *attr,
 518                                               char *buf)
 519 {
 520         s64 msec = 0;
 521         bool enabled = false;
 522
 523         spin_lock_irq(&dev->power.lock);
 524         if (dev->power.wakeup) {
 525                 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
 526                 enabled = true;
 527         }
 528         spin_unlock_irq(&dev->power.lock);
 529         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 530 }
 531
 532 static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444,
 533                    wakeup_prevent_sleep_time_show, NULL);
 534 #endif /* CONFIG_PM_AUTOSLEEP */
 535 #endif /* CONFIG_PM_SLEEP */
 536
 537 #ifdef CONFIG_PM_ADVANCED_DEBUG
 538 static ssize_t rtpm_usagecount_show(struct device *dev,
 539                                     struct device_attribute *attr, char *buf)
 540 {
 541         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
 542 }
 543
 544 static ssize_t rtpm_children_show(struct device *dev,
 545                                   struct device_attribute *attr, char *buf)
 546 {
 547         return sprintf(buf, "%d\n", dev->power.ignore_children ?
 548                 0 : atomic_read(&dev->power.child_count));
 549 }
 550
 551 static ssize_t rtpm_enabled_show(struct device *dev,
 552                                  struct device_attribute *attr, char *buf)
 553 {
 554         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
 555                 return sprintf(buf, "disabled & forbidden\n");
 556         else if (dev->power.disable_depth)
 557                 return sprintf(buf, "disabled\n");
 558         else if (dev->power.runtime_auto == false)
 559                 return sprintf(buf, "forbidden\n");
 560         return sprintf(buf, "enabled\n");
 561 }
 562
 563 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
 564 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
 565 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 566
 567 #ifdef CONFIG_PM_SLEEP
 568 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 569                           char *buf)
 570 {
 571         return sprintf(buf, "%s\n",
 572                         device_async_suspend_enabled(dev) ?
 573                                 _enabled : _disabled);
 574 }
 575
 576 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 577                            const char *buf, size_t n)
 578 {
 579         char *cp;
 580         int len = n;
 581
 582         cp = memchr(buf, '\n', n);
 583         if (cp)
 584                 len = cp - buf;
 585         if (len == sizeof _enabled - 1 && strncmp(buf, _enabled, len) == 0)
 586                 device_enable_async_suspend(dev);
 587         else if (len == sizeof _disabled - 1 &&
 588                  strncmp(buf, _disabled, len) == 0)
 589                 device_disable_async_suspend(dev);
 590         else
 591                 return -EINVAL;
 592         return n;
 593 }
 594
 595 static DEVICE_ATTR(async, 0644, async_show, async_store);
 596
 597 #endif /* CONFIG_PM_SLEEP */
 598 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 599
 600 static struct attribute *power_attrs[] = {
 601 #ifdef CONFIG_PM_ADVANCED_DEBUG
 602 #ifdef CONFIG_PM_SLEEP
 603         &dev_attr_async.attr,
 604 #endif
 605         &dev_attr_runtime_status.attr,
 606         &dev_attr_runtime_usage.attr,
 607         &dev_attr_runtime_active_kids.attr,
 608         &dev_attr_runtime_enabled.attr,
 609 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 610         NULL,
 611 };
 612 static const struct attribute_group pm_attr_group = {
 613         .name   = power_group_name,
 614         .attrs  = power_attrs,
 615 };
 616
 617 static struct attribute *wakeup_attrs[] = {
 618 #ifdef CONFIG_PM_SLEEP
 619         &dev_attr_wakeup.attr,
 620         &dev_attr_wakeup_count.attr,
 621         &dev_attr_wakeup_active_count.attr,
 622         &dev_attr_wakeup_abort_count.attr,
 623         &dev_attr_wakeup_expire_count.attr,
 624         &dev_attr_wakeup_active.attr,
 625         &dev_attr_wakeup_total_time_ms.attr,
 626         &dev_attr_wakeup_max_time_ms.attr,
 627         &dev_attr_wakeup_last_time_ms.attr,
 628 #ifdef CONFIG_PM_AUTOSLEEP
 629         &dev_attr_wakeup_prevent_sleep_time_ms.attr,
 630 #endif
 631 #endif
 632         NULL,
 633 };
 634 static const struct attribute_group pm_wakeup_attr_group = {
 635         .name   = power_group_name,
 636         .attrs  = wakeup_attrs,
 637 };
 638
 639 static struct attribute *runtime_attrs[] = {
 640 #ifndef CONFIG_PM_ADVANCED_DEBUG
 641         &dev_attr_runtime_status.attr,
 642 #endif
 643         &dev_attr_control.attr,
 644         &dev_attr_runtime_suspended_time.attr,
 645         &dev_attr_runtime_active_time.attr,
 646         &dev_attr_autosuspend_delay_ms.attr,
 647         NULL,
 648 };
 649 static const struct attribute_group pm_runtime_attr_group = {
 650         .name   = power_group_name,
 651         .attrs  = runtime_attrs,
 652 };
 653
 654 static struct attribute *pm_qos_resume_latency_attrs[] = {
 655         &dev_attr_pm_qos_resume_latency_us.attr,
 656         NULL,
 657 };
 658 static const struct attribute_group pm_qos_resume_latency_attr_group = {
 659         .name   = power_group_name,
 660         .attrs  = pm_qos_resume_latency_attrs,
 661 };
 662
 663 static struct attribute *pm_qos_latency_tolerance_attrs[] = {
 664         &dev_attr_pm_qos_latency_tolerance_us.attr,
 665         NULL,
 666 };
 667 static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
 668         .name   = power_group_name,
 669         .attrs  = pm_qos_latency_tolerance_attrs,
 670 };
 671
 672 static struct attribute *pm_qos_flags_attrs[] = {
 673         &dev_attr_pm_qos_no_power_off.attr,
 674         &dev_attr_pm_qos_remote_wakeup.attr,
 675         NULL,
 676 };
 677 static const struct attribute_group pm_qos_flags_attr_group = {
 678         .name   = power_group_name,
 679         .attrs  = pm_qos_flags_attrs,
 680 };
 681
 682 int dpm_sysfs_add(struct device *dev)
 683 {
 684         int rc;
 685
 686         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 687         if (rc)
 688                 return rc;
 689
 690         if (pm_runtime_callbacks_present(dev)) {
 691                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 692                 if (rc)
 693                         goto err_out;
 694         }
 695         if (device_can_wakeup(dev)) {
 696                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 697                 if (rc)
 698                         goto err_runtime;
 699         }
 700         if (dev->power.set_latency_tolerance) {
 701                 rc = sysfs_merge_group(&dev->kobj,
 702                                        &pm_qos_latency_tolerance_attr_group);
 703                 if (rc)
 704                         goto err_wakeup;
 705         }
 706         return 0;
 707
 708  err_wakeup:
 709         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 710  err_runtime:
 711         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 712  err_out:
 713         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 714         return rc;
 715 }
 716
 717 int wakeup_sysfs_add(struct device *dev)
 718 {
 719         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 720 }
 721
 722 void wakeup_sysfs_remove(struct device *dev)
 723 {
 724         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 725 }
 726
 727 int pm_qos_sysfs_add_resume_latency(struct device *dev)
 728 {
 729         return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
 730 }
 731
 732 void pm_qos_sysfs_remove_resume_latency(struct device *dev)
 733 {
 734         sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
 735 }
 736
 737 int pm_qos_sysfs_add_flags(struct device *dev)
 738 {
 739         return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
 740 }
 741
 742 void pm_qos_sysfs_remove_flags(struct device *dev)
 743 {
 744         sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
 745 }
 746
 747 int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
 748 {
 749         return sysfs_merge_group(&dev->kobj,
 750                                  &pm_qos_latency_tolerance_attr_group);
 751 }
 752
 753 void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
 754 {
 755         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
 756 }
 757
 758 void rpm_sysfs_remove(struct device *dev)
 759 {
 760         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 761 }
 762
 763 void dpm_sysfs_remove(struct device *dev)
 764 {
 765         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
 766         dev_pm_qos_constraints_destroy(dev);
 767         rpm_sysfs_remove(dev);
 768         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 769         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 770 }