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