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/pm_runtime.h>
   8 #include <linux/atomic.h>
   9 #include <linux/jiffies.h>
  10 #include "power.h"
  11
  12 /*
  13  *      control - Report/change current runtime PM setting of the device
  14  *
  15  *      Runtime power management of a device can be blocked with the help of
  16  *      this attribute.  All devices have one of the following two values for
  17  *      the power/control file:
  18  *
  19  *       + "auto\n" to allow the device to be power managed at run time;
  20  *       + "on\n" to prevent the device from being power managed at run time;
  21  *
  22  *      The default for all devices is "auto", which means that devices may be
  23  *      subject to automatic power management, depending on their drivers.
  24  *      Changing this attribute to "on" prevents the driver from power managing
  25  *      the device at run time.  Doing that while the device is suspended causes
  26  *      it to be woken up.
  27  *
  28  *      wakeup - Report/change current wakeup option for device
  29  *
  30  *      Some devices support "wakeup" events, which are hardware signals
  31  *      used to activate devices from suspended or low power states.  Such
  32  *      devices have one of three values for the sysfs power/wakeup file:
  33  *
  34  *       + "enabled\n" to issue the events;
  35  *       + "disabled\n" not to do so; or
  36  *       + "\n" for temporary or permanent inability to issue wakeup.
  37  *
  38  *      (For example, unconfigured USB devices can't issue wakeups.)
  39  *
  40  *      Familiar examples of devices that can issue wakeup events include
  41  *      keyboards and mice (both PS2 and USB styles), power buttons, modems,
  42  *      "Wake-On-LAN" Ethernet links, GPIO lines, and more.  Some events
  43  *      will wake the entire system from a suspend state; others may just
  44  *      wake up the device (if the system as a whole is already active).
  45  *      Some wakeup events use normal IRQ lines; other use special out
  46  *      of band signaling.
  47  *
  48  *      It is the responsibility of device drivers to enable (or disable)
  49  *      wakeup signaling as part of changing device power states, respecting
  50  *      the policy choices provided through the driver model.
  51  *
  52  *      Devices may not be able to generate wakeup events from all power
  53  *      states.  Also, the events may be ignored in some configurations;
  54  *      for example, they might need help from other devices that aren't
  55  *      active, or which may have wakeup disabled.  Some drivers rely on
  56  *      wakeup events internally (unless they are disabled), keeping
  57  *      their hardware in low power modes whenever they're unused.  This
  58  *      saves runtime power, without requiring system-wide sleep states.
  59  *
  60  *      async - Report/change current async suspend setting for the device
  61  *
  62  *      Asynchronous suspend and resume of the device during system-wide power
  63  *      state transitions can be enabled by writing "enabled" to this file.
  64  *      Analogously, if "disabled" is written to this file, the device will be
  65  *      suspended and resumed synchronously.
  66  *
  67  *      All devices have one of the following two values for power/async:
  68  *
  69  *       + "enabled\n" to permit the asynchronous suspend/resume of the device;
  70  *       + "disabled\n" to forbid it;
  71  *
  72  *      NOTE: It generally is unsafe to permit the asynchronous suspend/resume
  73  *      of a device unless it is certain that all of the PM dependencies of the
  74  *      device are known to the PM core.  However, for some devices this
  75  *      attribute is set to "enabled" by bus type code or device drivers and in
  76  *      that cases it should be safe to leave the default value.
  77  *
  78  *      autosuspend_delay_ms - Report/change a device's autosuspend_delay value
  79  *
  80  *      Some drivers don't want to carry out a runtime suspend as soon as a
  81  *      device becomes idle; they want it always to remain idle for some period
  82  *      of time before suspending it.  This period is the autosuspend_delay
  83  *      value (expressed in milliseconds) and it can be controlled by the user.
  84  *      If the value is negative then the device will never be runtime
  85  *      suspended.
  86  *
  87  *      NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
  88  *      value are used only if the driver calls pm_runtime_use_autosuspend().
  89  *
  90  *      wakeup_count - Report the number of wakeup events related to the device
  91  */
  92
  93 static const char enabled[] = "enabled";
  94 static const char disabled[] = "disabled";
  95
  96 const char power_group_name[] = "power";
  97 EXPORT_SYMBOL_GPL(power_group_name);
  98
  99 #ifdef CONFIG_PM_RUNTIME
 100 static const char ctrl_auto[] = "auto";
 101 static const char ctrl_on[] = "on";
 102
 103 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
 104                             char *buf)
 105 {
 106         return sprintf(buf, "%s\n",
 107                                 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
 108 }
 109
 110 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
 111                              const char * buf, size_t n)
 112 {
 113         char *cp;
 114         int len = n;
 115
 116         cp = memchr(buf, '\n', n);
 117         if (cp)
 118                 len = cp - buf;
 119         device_lock(dev);
 120         if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
 121                 pm_runtime_allow(dev);
 122         else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
 123                 pm_runtime_forbid(dev);
 124         else
 125                 n = -EINVAL;
 126         device_unlock(dev);
 127         return n;
 128 }
 129
 130 static DEVICE_ATTR(control, 0644, control_show, control_store);
 131
 132 static ssize_t rtpm_active_time_show(struct device *dev,
 133                                 struct device_attribute *attr, char *buf)
 134 {
 135         int ret;
 136         spin_lock_irq(&dev->power.lock);
 137         update_pm_runtime_accounting(dev);
 138         ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
 139         spin_unlock_irq(&dev->power.lock);
 140         return ret;
 141 }
 142
 143 static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
 144
 145 static ssize_t rtpm_suspended_time_show(struct device *dev,
 146                                 struct device_attribute *attr, char *buf)
 147 {
 148         int ret;
 149         spin_lock_irq(&dev->power.lock);
 150         update_pm_runtime_accounting(dev);
 151         ret = sprintf(buf, "%i\n",
 152                 jiffies_to_msecs(dev->power.suspended_jiffies));
 153         spin_unlock_irq(&dev->power.lock);
 154         return ret;
 155 }
 156
 157 static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
 158
 159 static ssize_t rtpm_status_show(struct device *dev,
 160                                 struct device_attribute *attr, char *buf)
 161 {
 162         const char *p;
 163
 164         if (dev->power.runtime_error) {
 165                 p = "error\n";
 166         } else if (dev->power.disable_depth) {
 167                 p = "unsupported\n";
 168         } else {
 169                 switch (dev->power.runtime_status) {
 170                 case RPM_SUSPENDED:
 171                         p = "suspended\n";
 172                         break;
 173                 case RPM_SUSPENDING:
 174                         p = "suspending\n";
 175                         break;
 176                 case RPM_RESUMING:
 177                         p = "resuming\n";
 178                         break;
 179                 case RPM_ACTIVE:
 180                         p = "active\n";
 181                         break;
 182                 default:
 183                         return -EIO;
 184                 }
 185         }
 186         return sprintf(buf, p);
 187 }
 188
 189 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
 190
 191 static ssize_t autosuspend_delay_ms_show(struct device *dev,
 192                 struct device_attribute *attr, char *buf)
 193 {
 194         if (!dev->power.use_autosuspend)
 195                 return -EIO;
 196         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
 197 }
 198
 199 static ssize_t autosuspend_delay_ms_store(struct device *dev,
 200                 struct device_attribute *attr, const char *buf, size_t n)
 201 {
 202         long delay;
 203
 204         if (!dev->power.use_autosuspend)
 205                 return -EIO;
 206
 207         if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
 208                 return -EINVAL;
 209
 210         device_lock(dev);
 211         pm_runtime_set_autosuspend_delay(dev, delay);
 212         device_unlock(dev);
 213         return n;
 214 }
 215
 216 static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
 217                 autosuspend_delay_ms_store);
 218
 219 #endif /* CONFIG_PM_RUNTIME */
 220
 221 #ifdef CONFIG_PM_SLEEP
 222 static ssize_t
 223 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 224 {
 225         return sprintf(buf, "%s\n", device_can_wakeup(dev)
 226                 ? (device_may_wakeup(dev) ? enabled : disabled)
 227                 : "");
 228 }
 229
 230 static ssize_t
 231 wake_store(struct device * dev, struct device_attribute *attr,
 232         const char * buf, size_t n)
 233 {
 234         char *cp;
 235         int len = n;
 236
 237         if (!device_can_wakeup(dev))
 238                 return -EINVAL;
 239
 240         cp = memchr(buf, '\n', n);
 241         if (cp)
 242                 len = cp - buf;
 243         if (len == sizeof enabled - 1
 244                         && strncmp(buf, enabled, sizeof enabled - 1) == 0)
 245                 device_set_wakeup_enable(dev, 1);
 246         else if (len == sizeof disabled - 1
 247                         && strncmp(buf, disabled, sizeof disabled - 1) == 0)
 248                 device_set_wakeup_enable(dev, 0);
 249         else
 250                 return -EINVAL;
 251         return n;
 252 }
 253
 254 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 255
 256 static ssize_t wakeup_count_show(struct device *dev,
 257                                 struct device_attribute *attr, char *buf)
 258 {
 259         unsigned long count = 0;
 260         bool enabled = false;
 261
 262         spin_lock_irq(&dev->power.lock);
 263         if (dev->power.wakeup) {
 264                 count = dev->power.wakeup->event_count;
 265                 enabled = true;
 266         }
 267         spin_unlock_irq(&dev->power.lock);
 268         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 269 }
 270
 271 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
 272
 273 static ssize_t wakeup_active_count_show(struct device *dev,
 274                                 struct device_attribute *attr, char *buf)
 275 {
 276         unsigned long count = 0;
 277         bool enabled = false;
 278
 279         spin_lock_irq(&dev->power.lock);
 280         if (dev->power.wakeup) {
 281                 count = dev->power.wakeup->active_count;
 282                 enabled = true;
 283         }
 284         spin_unlock_irq(&dev->power.lock);
 285         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 286 }
 287
 288 static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
 289
 290 static ssize_t wakeup_hit_count_show(struct device *dev,
 291                                 struct device_attribute *attr, char *buf)
 292 {
 293         unsigned long count = 0;
 294         bool enabled = false;
 295
 296         spin_lock_irq(&dev->power.lock);
 297         if (dev->power.wakeup) {
 298                 count = dev->power.wakeup->hit_count;
 299                 enabled = true;
 300         }
 301         spin_unlock_irq(&dev->power.lock);
 302         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 303 }
 304
 305 static DEVICE_ATTR(wakeup_hit_count, 0444, wakeup_hit_count_show, NULL);
 306
 307 static ssize_t wakeup_active_show(struct device *dev,
 308                                 struct device_attribute *attr, char *buf)
 309 {
 310         unsigned int active = 0;
 311         bool enabled = false;
 312
 313         spin_lock_irq(&dev->power.lock);
 314         if (dev->power.wakeup) {
 315                 active = dev->power.wakeup->active;
 316                 enabled = true;
 317         }
 318         spin_unlock_irq(&dev->power.lock);
 319         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
 320 }
 321
 322 static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
 323
 324 static ssize_t wakeup_total_time_show(struct device *dev,
 325                                 struct device_attribute *attr, char *buf)
 326 {
 327         s64 msec = 0;
 328         bool enabled = false;
 329
 330         spin_lock_irq(&dev->power.lock);
 331         if (dev->power.wakeup) {
 332                 msec = ktime_to_ms(dev->power.wakeup->total_time);
 333                 enabled = true;
 334         }
 335         spin_unlock_irq(&dev->power.lock);
 336         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 337 }
 338
 339 static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
 340
 341 static ssize_t wakeup_max_time_show(struct device *dev,
 342                                 struct device_attribute *attr, char *buf)
 343 {
 344         s64 msec = 0;
 345         bool enabled = false;
 346
 347         spin_lock_irq(&dev->power.lock);
 348         if (dev->power.wakeup) {
 349                 msec = ktime_to_ms(dev->power.wakeup->max_time);
 350                 enabled = true;
 351         }
 352         spin_unlock_irq(&dev->power.lock);
 353         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 354 }
 355
 356 static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
 357
 358 static ssize_t wakeup_last_time_show(struct device *dev,
 359                                 struct device_attribute *attr, char *buf)
 360 {
 361         s64 msec = 0;
 362         bool enabled = false;
 363
 364         spin_lock_irq(&dev->power.lock);
 365         if (dev->power.wakeup) {
 366                 msec = ktime_to_ms(dev->power.wakeup->last_time);
 367                 enabled = true;
 368         }
 369         spin_unlock_irq(&dev->power.lock);
 370         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 371 }
 372
 373 static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
 374 #endif /* CONFIG_PM_SLEEP */
 375
 376 #ifdef CONFIG_PM_ADVANCED_DEBUG
 377 #ifdef CONFIG_PM_RUNTIME
 378
 379 static ssize_t rtpm_usagecount_show(struct device *dev,
 380                                     struct device_attribute *attr, char *buf)
 381 {
 382         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
 383 }
 384
 385 static ssize_t rtpm_children_show(struct device *dev,
 386                                   struct device_attribute *attr, char *buf)
 387 {
 388         return sprintf(buf, "%d\n", dev->power.ignore_children ?
 389                 0 : atomic_read(&dev->power.child_count));
 390 }
 391
 392 static ssize_t rtpm_enabled_show(struct device *dev,
 393                                  struct device_attribute *attr, char *buf)
 394 {
 395         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
 396                 return sprintf(buf, "disabled & forbidden\n");
 397         else if (dev->power.disable_depth)
 398                 return sprintf(buf, "disabled\n");
 399         else if (dev->power.runtime_auto == false)
 400                 return sprintf(buf, "forbidden\n");
 401         return sprintf(buf, "enabled\n");
 402 }
 403
 404 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
 405 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
 406 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 407
 408 #endif
 409
 410 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 411                           char *buf)
 412 {
 413         return sprintf(buf, "%s\n",
 414                         device_async_suspend_enabled(dev) ? enabled : disabled);
 415 }
 416
 417 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 418                            const char *buf, size_t n)
 419 {
 420         char *cp;
 421         int len = n;
 422
 423         cp = memchr(buf, '\n', n);
 424         if (cp)
 425                 len = cp - buf;
 426         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
 427                 device_enable_async_suspend(dev);
 428         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
 429                 device_disable_async_suspend(dev);
 430         else
 431                 return -EINVAL;
 432         return n;
 433 }
 434
 435 static DEVICE_ATTR(async, 0644, async_show, async_store);
 436 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 437
 438 static struct attribute *power_attrs[] = {
 439 #ifdef CONFIG_PM_ADVANCED_DEBUG
 440 #ifdef CONFIG_PM_SLEEP
 441         &dev_attr_async.attr,
 442 #endif
 443 #ifdef CONFIG_PM_RUNTIME
 444         &dev_attr_runtime_status.attr,
 445         &dev_attr_runtime_usage.attr,
 446         &dev_attr_runtime_active_kids.attr,
 447         &dev_attr_runtime_enabled.attr,
 448 #endif
 449 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 450         NULL,
 451 };
 452 static struct attribute_group pm_attr_group = {
 453         .name   = power_group_name,
 454         .attrs  = power_attrs,
 455 };
 456
 457 static struct attribute *wakeup_attrs[] = {
 458 #ifdef CONFIG_PM_SLEEP
 459         &dev_attr_wakeup.attr,
 460         &dev_attr_wakeup_count.attr,
 461         &dev_attr_wakeup_active_count.attr,
 462         &dev_attr_wakeup_hit_count.attr,
 463         &dev_attr_wakeup_active.attr,
 464         &dev_attr_wakeup_total_time_ms.attr,
 465         &dev_attr_wakeup_max_time_ms.attr,
 466         &dev_attr_wakeup_last_time_ms.attr,
 467 #endif
 468         NULL,
 469 };
 470 static struct attribute_group pm_wakeup_attr_group = {
 471         .name   = power_group_name,
 472         .attrs  = wakeup_attrs,
 473 };
 474
 475 static struct attribute *runtime_attrs[] = {
 476 #ifdef CONFIG_PM_RUNTIME
 477 #ifndef CONFIG_PM_ADVANCED_DEBUG
 478         &dev_attr_runtime_status.attr,
 479 #endif
 480         &dev_attr_control.attr,
 481         &dev_attr_runtime_suspended_time.attr,
 482         &dev_attr_runtime_active_time.attr,
 483         &dev_attr_autosuspend_delay_ms.attr,
 484 #endif /* CONFIG_PM_RUNTIME */
 485         NULL,
 486 };
 487 static struct attribute_group pm_runtime_attr_group = {
 488         .name   = power_group_name,
 489         .attrs  = runtime_attrs,
 490 };
 491
 492 int dpm_sysfs_add(struct device *dev)
 493 {
 494         int rc;
 495
 496         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 497         if (rc)
 498                 return rc;
 499
 500         if (pm_runtime_callbacks_present(dev)) {
 501                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 502                 if (rc)
 503                         goto err_out;
 504         }
 505
 506         if (device_can_wakeup(dev)) {
 507                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 508                 if (rc) {
 509                         if (pm_runtime_callbacks_present(dev))
 510                                 sysfs_unmerge_group(&dev->kobj,
 511                                                     &pm_runtime_attr_group);
 512                         goto err_out;
 513                 }
 514         }
 515         return 0;
 516
 517  err_out:
 518         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 519         return rc;
 520 }
 521
 522 int wakeup_sysfs_add(struct device *dev)
 523 {
 524         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 525 }
 526
 527 void wakeup_sysfs_remove(struct device *dev)
 528 {
 529         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 530 }
 531
 532 void rpm_sysfs_remove(struct device *dev)
 533 {
 534         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 535 }
 536
 537 void dpm_sysfs_remove(struct device *dev)
 538 {
 539         rpm_sysfs_remove(dev);
 540         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 541         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 542 }