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