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 (strict_strtol(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->power.pq_req->node.prio);
 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.pq_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 #endif /* CONFIG_PM_RUNTIME */
 247
 248 #ifdef CONFIG_PM_SLEEP
 249 static ssize_t
 250 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 251 {
 252         return sprintf(buf, "%s\n", device_can_wakeup(dev)
 253                 ? (device_may_wakeup(dev) ? enabled : disabled)
 254                 : "");
 255 }
 256
 257 static ssize_t
 258 wake_store(struct device * dev, struct device_attribute *attr,
 259         const char * buf, size_t n)
 260 {
 261         char *cp;
 262         int len = n;
 263
 264         if (!device_can_wakeup(dev))
 265                 return -EINVAL;
 266
 267         cp = memchr(buf, '\n', n);
 268         if (cp)
 269                 len = cp - buf;
 270         if (len == sizeof enabled - 1
 271                         && strncmp(buf, enabled, sizeof enabled - 1) == 0)
 272                 device_set_wakeup_enable(dev, 1);
 273         else if (len == sizeof disabled - 1
 274                         && strncmp(buf, disabled, sizeof disabled - 1) == 0)
 275                 device_set_wakeup_enable(dev, 0);
 276         else
 277                 return -EINVAL;
 278         return n;
 279 }
 280
 281 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 282
 283 static ssize_t wakeup_count_show(struct device *dev,
 284                                 struct device_attribute *attr, char *buf)
 285 {
 286         unsigned long count = 0;
 287         bool enabled = false;
 288
 289         spin_lock_irq(&dev->power.lock);
 290         if (dev->power.wakeup) {
 291                 count = dev->power.wakeup->event_count;
 292                 enabled = true;
 293         }
 294         spin_unlock_irq(&dev->power.lock);
 295         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 296 }
 297
 298 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
 299
 300 static ssize_t wakeup_active_count_show(struct device *dev,
 301                                 struct device_attribute *attr, char *buf)
 302 {
 303         unsigned long count = 0;
 304         bool enabled = false;
 305
 306         spin_lock_irq(&dev->power.lock);
 307         if (dev->power.wakeup) {
 308                 count = dev->power.wakeup->active_count;
 309                 enabled = true;
 310         }
 311         spin_unlock_irq(&dev->power.lock);
 312         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 313 }
 314
 315 static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
 316
 317 static ssize_t wakeup_abort_count_show(struct device *dev,
 318                                         struct device_attribute *attr,
 319                                         char *buf)
 320 {
 321         unsigned long count = 0;
 322         bool enabled = false;
 323
 324         spin_lock_irq(&dev->power.lock);
 325         if (dev->power.wakeup) {
 326                 count = dev->power.wakeup->wakeup_count;
 327                 enabled = true;
 328         }
 329         spin_unlock_irq(&dev->power.lock);
 330         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 331 }
 332
 333 static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL);
 334
 335 static ssize_t wakeup_expire_count_show(struct device *dev,
 336                                         struct device_attribute *attr,
 337                                         char *buf)
 338 {
 339         unsigned long count = 0;
 340         bool enabled = false;
 341
 342         spin_lock_irq(&dev->power.lock);
 343         if (dev->power.wakeup) {
 344                 count = dev->power.wakeup->expire_count;
 345                 enabled = true;
 346         }
 347         spin_unlock_irq(&dev->power.lock);
 348         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 349 }
 350
 351 static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL);
 352
 353 static ssize_t wakeup_active_show(struct device *dev,
 354                                 struct device_attribute *attr, char *buf)
 355 {
 356         unsigned int active = 0;
 357         bool enabled = false;
 358
 359         spin_lock_irq(&dev->power.lock);
 360         if (dev->power.wakeup) {
 361                 active = dev->power.wakeup->active;
 362                 enabled = true;
 363         }
 364         spin_unlock_irq(&dev->power.lock);
 365         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
 366 }
 367
 368 static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
 369
 370 static ssize_t wakeup_total_time_show(struct device *dev,
 371                                 struct device_attribute *attr, char *buf)
 372 {
 373         s64 msec = 0;
 374         bool enabled = false;
 375
 376         spin_lock_irq(&dev->power.lock);
 377         if (dev->power.wakeup) {
 378                 msec = ktime_to_ms(dev->power.wakeup->total_time);
 379                 enabled = true;
 380         }
 381         spin_unlock_irq(&dev->power.lock);
 382         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 383 }
 384
 385 static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
 386
 387 static ssize_t wakeup_max_time_show(struct device *dev,
 388                                 struct device_attribute *attr, char *buf)
 389 {
 390         s64 msec = 0;
 391         bool enabled = false;
 392
 393         spin_lock_irq(&dev->power.lock);
 394         if (dev->power.wakeup) {
 395                 msec = ktime_to_ms(dev->power.wakeup->max_time);
 396                 enabled = true;
 397         }
 398         spin_unlock_irq(&dev->power.lock);
 399         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 400 }
 401
 402 static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
 403
 404 static ssize_t wakeup_last_time_show(struct device *dev,
 405                                 struct device_attribute *attr, char *buf)
 406 {
 407         s64 msec = 0;
 408         bool enabled = false;
 409
 410         spin_lock_irq(&dev->power.lock);
 411         if (dev->power.wakeup) {
 412                 msec = ktime_to_ms(dev->power.wakeup->last_time);
 413                 enabled = true;
 414         }
 415         spin_unlock_irq(&dev->power.lock);
 416         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 417 }
 418
 419 static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
 420
 421 #ifdef CONFIG_PM_AUTOSLEEP
 422 static ssize_t wakeup_prevent_sleep_time_show(struct device *dev,
 423                                               struct device_attribute *attr,
 424                                               char *buf)
 425 {
 426         s64 msec = 0;
 427         bool enabled = false;
 428
 429         spin_lock_irq(&dev->power.lock);
 430         if (dev->power.wakeup) {
 431                 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
 432                 enabled = true;
 433         }
 434         spin_unlock_irq(&dev->power.lock);
 435         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 436 }
 437
 438 static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444,
 439                    wakeup_prevent_sleep_time_show, NULL);
 440 #endif /* CONFIG_PM_AUTOSLEEP */
 441 #endif /* CONFIG_PM_SLEEP */
 442
 443 #ifdef CONFIG_PM_ADVANCED_DEBUG
 444 #ifdef CONFIG_PM_RUNTIME
 445
 446 static ssize_t rtpm_usagecount_show(struct device *dev,
 447                                     struct device_attribute *attr, char *buf)
 448 {
 449         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
 450 }
 451
 452 static ssize_t rtpm_children_show(struct device *dev,
 453                                   struct device_attribute *attr, char *buf)
 454 {
 455         return sprintf(buf, "%d\n", dev->power.ignore_children ?
 456                 0 : atomic_read(&dev->power.child_count));
 457 }
 458
 459 static ssize_t rtpm_enabled_show(struct device *dev,
 460                                  struct device_attribute *attr, char *buf)
 461 {
 462         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
 463                 return sprintf(buf, "disabled & forbidden\n");
 464         else if (dev->power.disable_depth)
 465                 return sprintf(buf, "disabled\n");
 466         else if (dev->power.runtime_auto == false)
 467                 return sprintf(buf, "forbidden\n");
 468         return sprintf(buf, "enabled\n");
 469 }
 470
 471 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
 472 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
 473 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 474
 475 #endif
 476
 477 #ifdef CONFIG_PM_SLEEP
 478
 479 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 480                           char *buf)
 481 {
 482         return sprintf(buf, "%s\n",
 483                         device_async_suspend_enabled(dev) ? enabled : disabled);
 484 }
 485
 486 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 487                            const char *buf, size_t n)
 488 {
 489         char *cp;
 490         int len = n;
 491
 492         cp = memchr(buf, '\n', n);
 493         if (cp)
 494                 len = cp - buf;
 495         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
 496                 device_enable_async_suspend(dev);
 497         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
 498                 device_disable_async_suspend(dev);
 499         else
 500                 return -EINVAL;
 501         return n;
 502 }
 503
 504 static DEVICE_ATTR(async, 0644, async_show, async_store);
 505
 506 #endif
 507 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 508
 509 static struct attribute *power_attrs[] = {
 510 #ifdef CONFIG_PM_ADVANCED_DEBUG
 511 #ifdef CONFIG_PM_SLEEP
 512         &dev_attr_async.attr,
 513 #endif
 514 #ifdef CONFIG_PM_RUNTIME
 515         &dev_attr_runtime_status.attr,
 516         &dev_attr_runtime_usage.attr,
 517         &dev_attr_runtime_active_kids.attr,
 518         &dev_attr_runtime_enabled.attr,
 519 #endif
 520 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 521         NULL,
 522 };
 523 static struct attribute_group pm_attr_group = {
 524         .name   = power_group_name,
 525         .attrs  = power_attrs,
 526 };
 527
 528 static struct attribute *wakeup_attrs[] = {
 529 #ifdef CONFIG_PM_SLEEP
 530         &dev_attr_wakeup.attr,
 531         &dev_attr_wakeup_count.attr,
 532         &dev_attr_wakeup_active_count.attr,
 533         &dev_attr_wakeup_abort_count.attr,
 534         &dev_attr_wakeup_expire_count.attr,
 535         &dev_attr_wakeup_active.attr,
 536         &dev_attr_wakeup_total_time_ms.attr,
 537         &dev_attr_wakeup_max_time_ms.attr,
 538         &dev_attr_wakeup_last_time_ms.attr,
 539 #ifdef CONFIG_PM_AUTOSLEEP
 540         &dev_attr_wakeup_prevent_sleep_time_ms.attr,
 541 #endif
 542 #endif
 543         NULL,
 544 };
 545 static struct attribute_group pm_wakeup_attr_group = {
 546         .name   = power_group_name,
 547         .attrs  = wakeup_attrs,
 548 };
 549
 550 static struct attribute *runtime_attrs[] = {
 551 #ifdef CONFIG_PM_RUNTIME
 552 #ifndef CONFIG_PM_ADVANCED_DEBUG
 553         &dev_attr_runtime_status.attr,
 554 #endif
 555         &dev_attr_control.attr,
 556         &dev_attr_runtime_suspended_time.attr,
 557         &dev_attr_runtime_active_time.attr,
 558         &dev_attr_autosuspend_delay_ms.attr,
 559 #endif /* CONFIG_PM_RUNTIME */
 560         NULL,
 561 };
 562 static struct attribute_group pm_runtime_attr_group = {
 563         .name   = power_group_name,
 564         .attrs  = runtime_attrs,
 565 };
 566
 567 static struct attribute *pm_qos_attrs[] = {
 568 #ifdef CONFIG_PM_RUNTIME
 569         &dev_attr_pm_qos_resume_latency_us.attr,
 570 #endif /* CONFIG_PM_RUNTIME */
 571         NULL,
 572 };
 573 static struct attribute_group pm_qos_attr_group = {
 574         .name   = power_group_name,
 575         .attrs  = pm_qos_attrs,
 576 };
 577
 578 int dpm_sysfs_add(struct device *dev)
 579 {
 580         int rc;
 581
 582         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 583         if (rc)
 584                 return rc;
 585
 586         if (pm_runtime_callbacks_present(dev)) {
 587                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 588                 if (rc)
 589                         goto err_out;
 590         }
 591
 592         if (device_can_wakeup(dev)) {
 593                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 594                 if (rc) {
 595                         if (pm_runtime_callbacks_present(dev))
 596                                 sysfs_unmerge_group(&dev->kobj,
 597                                                     &pm_runtime_attr_group);
 598                         goto err_out;
 599                 }
 600         }
 601         return 0;
 602
 603  err_out:
 604         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 605         return rc;
 606 }
 607
 608 int wakeup_sysfs_add(struct device *dev)
 609 {
 610         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 611 }
 612
 613 void wakeup_sysfs_remove(struct device *dev)
 614 {
 615         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 616 }
 617
 618 int pm_qos_sysfs_add(struct device *dev)
 619 {
 620         return sysfs_merge_group(&dev->kobj, &pm_qos_attr_group);
 621 }
 622
 623 void pm_qos_sysfs_remove(struct device *dev)
 624 {
 625         sysfs_unmerge_group(&dev->kobj, &pm_qos_attr_group);
 626 }
 627
 628 void rpm_sysfs_remove(struct device *dev)
 629 {
 630         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 631 }
 632
 633 void dpm_sysfs_remove(struct device *dev)
 634 {
 635         rpm_sysfs_remove(dev);
 636         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 637         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 638 }