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