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 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 478                           char *buf)
 479 {
 480         return sprintf(buf, "%s\n",
 481                         device_async_suspend_enabled(dev) ? enabled : disabled);
 482 }
 483
 484 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 485                            const char *buf, size_t n)
 486 {
 487         char *cp;
 488         int len = n;
 489
 490         cp = memchr(buf, '\n', n);
 491         if (cp)
 492                 len = cp - buf;
 493         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
 494                 device_enable_async_suspend(dev);
 495         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
 496                 device_disable_async_suspend(dev);
 497         else
 498                 return -EINVAL;
 499         return n;
 500 }
 501
 502 static DEVICE_ATTR(async, 0644, async_show, async_store);
 503 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 504
 505 static struct attribute *power_attrs[] = {
 506 #ifdef CONFIG_PM_ADVANCED_DEBUG
 507 #ifdef CONFIG_PM_SLEEP
 508         &dev_attr_async.attr,
 509 #endif
 510 #ifdef CONFIG_PM_RUNTIME
 511         &dev_attr_runtime_status.attr,
 512         &dev_attr_runtime_usage.attr,
 513         &dev_attr_runtime_active_kids.attr,
 514         &dev_attr_runtime_enabled.attr,
 515 #endif
 516 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 517         NULL,
 518 };
 519 static struct attribute_group pm_attr_group = {
 520         .name   = power_group_name,
 521         .attrs  = power_attrs,
 522 };
 523
 524 static struct attribute *wakeup_attrs[] = {
 525 #ifdef CONFIG_PM_SLEEP
 526         &dev_attr_wakeup.attr,
 527         &dev_attr_wakeup_count.attr,
 528         &dev_attr_wakeup_active_count.attr,
 529         &dev_attr_wakeup_abort_count.attr,
 530         &dev_attr_wakeup_expire_count.attr,
 531         &dev_attr_wakeup_active.attr,
 532         &dev_attr_wakeup_total_time_ms.attr,
 533         &dev_attr_wakeup_max_time_ms.attr,
 534         &dev_attr_wakeup_last_time_ms.attr,
 535 #ifdef CONFIG_PM_AUTOSLEEP
 536         &dev_attr_wakeup_prevent_sleep_time_ms.attr,
 537 #endif
 538 #endif
 539         NULL,
 540 };
 541 static struct attribute_group pm_wakeup_attr_group = {
 542         .name   = power_group_name,
 543         .attrs  = wakeup_attrs,
 544 };
 545
 546 static struct attribute *runtime_attrs[] = {
 547 #ifdef CONFIG_PM_RUNTIME
 548 #ifndef CONFIG_PM_ADVANCED_DEBUG
 549         &dev_attr_runtime_status.attr,
 550 #endif
 551         &dev_attr_control.attr,
 552         &dev_attr_runtime_suspended_time.attr,
 553         &dev_attr_runtime_active_time.attr,
 554         &dev_attr_autosuspend_delay_ms.attr,
 555 #endif /* CONFIG_PM_RUNTIME */
 556         NULL,
 557 };
 558 static struct attribute_group pm_runtime_attr_group = {
 559         .name   = power_group_name,
 560         .attrs  = runtime_attrs,
 561 };
 562
 563 static struct attribute *pm_qos_attrs[] = {
 564 #ifdef CONFIG_PM_RUNTIME
 565         &dev_attr_pm_qos_resume_latency_us.attr,
 566 #endif /* CONFIG_PM_RUNTIME */
 567         NULL,
 568 };
 569 static struct attribute_group pm_qos_attr_group = {
 570         .name   = power_group_name,
 571         .attrs  = pm_qos_attrs,
 572 };
 573
 574 int dpm_sysfs_add(struct device *dev)
 575 {
 576         int rc;
 577
 578         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 579         if (rc)
 580                 return rc;
 581
 582         if (pm_runtime_callbacks_present(dev)) {
 583                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 584                 if (rc)
 585                         goto err_out;
 586         }
 587
 588         if (device_can_wakeup(dev)) {
 589                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 590                 if (rc) {
 591                         if (pm_runtime_callbacks_present(dev))
 592                                 sysfs_unmerge_group(&dev->kobj,
 593                                                     &pm_runtime_attr_group);
 594                         goto err_out;
 595                 }
 596         }
 597         return 0;
 598
 599  err_out:
 600         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 601         return rc;
 602 }
 603
 604 int wakeup_sysfs_add(struct device *dev)
 605 {
 606         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 607 }
 608
 609 void wakeup_sysfs_remove(struct device *dev)
 610 {
 611         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 612 }
 613
 614 int pm_qos_sysfs_add(struct device *dev)
 615 {
 616         return sysfs_merge_group(&dev->kobj, &pm_qos_attr_group);
 617 }
 618
 619 void pm_qos_sysfs_remove(struct device *dev)
 620 {
 621         sysfs_unmerge_group(&dev->kobj, &pm_qos_attr_group);
 622 }
 623
 624 void rpm_sysfs_remove(struct device *dev)
 625 {
 626         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 627 }
 628
 629 void dpm_sysfs_remove(struct device *dev)
 630 {
 631         rpm_sysfs_remove(dev);
 632         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 633         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 634 }