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 <asm/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         if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
 120                 pm_runtime_allow(dev);
 121         else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
 122                 pm_runtime_forbid(dev);
 123         else
 124                 return -EINVAL;
 125         return n;
 126 }
 127
 128 static DEVICE_ATTR(control, 0644, control_show, control_store);
 129
 130 static ssize_t rtpm_active_time_show(struct device *dev,
 131                                 struct device_attribute *attr, char *buf)
 132 {
 133         int ret;
 134         spin_lock_irq(&dev->power.lock);
 135         update_pm_runtime_accounting(dev);
 136         ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
 137         spin_unlock_irq(&dev->power.lock);
 138         return ret;
 139 }
 140
 141 static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
 142
 143 static ssize_t rtpm_suspended_time_show(struct device *dev,
 144                                 struct device_attribute *attr, char *buf)
 145 {
 146         int ret;
 147         spin_lock_irq(&dev->power.lock);
 148         update_pm_runtime_accounting(dev);
 149         ret = sprintf(buf, "%i\n",
 150                 jiffies_to_msecs(dev->power.suspended_jiffies));
 151         spin_unlock_irq(&dev->power.lock);
 152         return ret;
 153 }
 154
 155 static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
 156
 157 static ssize_t rtpm_status_show(struct device *dev,
 158                                 struct device_attribute *attr, char *buf)
 159 {
 160         const char *p;
 161
 162         if (dev->power.runtime_error) {
 163                 p = "error\n";
 164         } else if (dev->power.disable_depth) {
 165                 p = "unsupported\n";
 166         } else {
 167                 switch (dev->power.runtime_status) {
 168                 case RPM_SUSPENDED:
 169                         p = "suspended\n";
 170                         break;
 171                 case RPM_SUSPENDING:
 172                         p = "suspending\n";
 173                         break;
 174                 case RPM_RESUMING:
 175                         p = "resuming\n";
 176                         break;
 177                 case RPM_ACTIVE:
 178                         p = "active\n";
 179                         break;
 180                 default:
 181                         return -EIO;
 182                 }
 183         }
 184         return sprintf(buf, p);
 185 }
 186
 187 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
 188
 189 static ssize_t autosuspend_delay_ms_show(struct device *dev,
 190                 struct device_attribute *attr, char *buf)
 191 {
 192         if (!dev->power.use_autosuspend)
 193                 return -EIO;
 194         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
 195 }
 196
 197 static ssize_t autosuspend_delay_ms_store(struct device *dev,
 198                 struct device_attribute *attr, const char *buf, size_t n)
 199 {
 200         long delay;
 201
 202         if (!dev->power.use_autosuspend)
 203                 return -EIO;
 204
 205         if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
 206                 return -EINVAL;
 207
 208         pm_runtime_set_autosuspend_delay(dev, delay);
 209         return n;
 210 }
 211
 212 static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
 213                 autosuspend_delay_ms_store);
 214
 215 #endif
 216
 217 static ssize_t
 218 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 219 {
 220         return sprintf(buf, "%s\n", device_can_wakeup(dev)
 221                 ? (device_may_wakeup(dev) ? enabled : disabled)
 222                 : "");
 223 }
 224
 225 static ssize_t
 226 wake_store(struct device * dev, struct device_attribute *attr,
 227         const char * buf, size_t n)
 228 {
 229         char *cp;
 230         int len = n;
 231
 232         if (!device_can_wakeup(dev))
 233                 return -EINVAL;
 234
 235         cp = memchr(buf, '\n', n);
 236         if (cp)
 237                 len = cp - buf;
 238         if (len == sizeof enabled - 1
 239                         && strncmp(buf, enabled, sizeof enabled - 1) == 0)
 240                 device_set_wakeup_enable(dev, 1);
 241         else if (len == sizeof disabled - 1
 242                         && strncmp(buf, disabled, sizeof disabled - 1) == 0)
 243                 device_set_wakeup_enable(dev, 0);
 244         else
 245                 return -EINVAL;
 246         return n;
 247 }
 248
 249 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 250
 251 #ifdef CONFIG_PM_SLEEP
 252 static ssize_t wakeup_count_show(struct device *dev,
 253                                 struct device_attribute *attr, char *buf)
 254 {
 255         unsigned long count = 0;
 256         bool enabled = false;
 257
 258         spin_lock_irq(&dev->power.lock);
 259         if (dev->power.wakeup) {
 260                 count = dev->power.wakeup->event_count;
 261                 enabled = true;
 262         }
 263         spin_unlock_irq(&dev->power.lock);
 264         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 265 }
 266
 267 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
 268
 269 static ssize_t wakeup_active_count_show(struct device *dev,
 270                                 struct device_attribute *attr, char *buf)
 271 {
 272         unsigned long count = 0;
 273         bool enabled = false;
 274
 275         spin_lock_irq(&dev->power.lock);
 276         if (dev->power.wakeup) {
 277                 count = dev->power.wakeup->active_count;
 278                 enabled = true;
 279         }
 280         spin_unlock_irq(&dev->power.lock);
 281         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 282 }
 283
 284 static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
 285
 286 static ssize_t wakeup_hit_count_show(struct device *dev,
 287                                 struct device_attribute *attr, char *buf)
 288 {
 289         unsigned long count = 0;
 290         bool enabled = false;
 291
 292         spin_lock_irq(&dev->power.lock);
 293         if (dev->power.wakeup) {
 294                 count = dev->power.wakeup->hit_count;
 295                 enabled = true;
 296         }
 297         spin_unlock_irq(&dev->power.lock);
 298         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 299 }
 300
 301 static DEVICE_ATTR(wakeup_hit_count, 0444, wakeup_hit_count_show, NULL);
 302
 303 static ssize_t wakeup_active_show(struct device *dev,
 304                                 struct device_attribute *attr, char *buf)
 305 {
 306         unsigned int active = 0;
 307         bool enabled = false;
 308
 309         spin_lock_irq(&dev->power.lock);
 310         if (dev->power.wakeup) {
 311                 active = dev->power.wakeup->active;
 312                 enabled = true;
 313         }
 314         spin_unlock_irq(&dev->power.lock);
 315         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
 316 }
 317
 318 static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
 319
 320 static ssize_t wakeup_total_time_show(struct device *dev,
 321                                 struct device_attribute *attr, char *buf)
 322 {
 323         s64 msec = 0;
 324         bool enabled = false;
 325
 326         spin_lock_irq(&dev->power.lock);
 327         if (dev->power.wakeup) {
 328                 msec = ktime_to_ms(dev->power.wakeup->total_time);
 329                 enabled = true;
 330         }
 331         spin_unlock_irq(&dev->power.lock);
 332         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 333 }
 334
 335 static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
 336
 337 static ssize_t wakeup_max_time_show(struct device *dev,
 338                                 struct device_attribute *attr, char *buf)
 339 {
 340         s64 msec = 0;
 341         bool enabled = false;
 342
 343         spin_lock_irq(&dev->power.lock);
 344         if (dev->power.wakeup) {
 345                 msec = ktime_to_ms(dev->power.wakeup->max_time);
 346                 enabled = true;
 347         }
 348         spin_unlock_irq(&dev->power.lock);
 349         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 350 }
 351
 352 static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
 353
 354 static ssize_t wakeup_last_time_show(struct device *dev,
 355                                 struct device_attribute *attr, char *buf)
 356 {
 357         s64 msec = 0;
 358         bool enabled = false;
 359
 360         spin_lock_irq(&dev->power.lock);
 361         if (dev->power.wakeup) {
 362                 msec = ktime_to_ms(dev->power.wakeup->last_time);
 363                 enabled = true;
 364         }
 365         spin_unlock_irq(&dev->power.lock);
 366         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
 367 }
 368
 369 static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
 370 #endif /* CONFIG_PM_SLEEP */
 371
 372 #ifdef CONFIG_PM_ADVANCED_DEBUG
 373 #ifdef CONFIG_PM_RUNTIME
 374
 375 static ssize_t rtpm_usagecount_show(struct device *dev,
 376                                     struct device_attribute *attr, char *buf)
 377 {
 378         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
 379 }
 380
 381 static ssize_t rtpm_children_show(struct device *dev,
 382                                   struct device_attribute *attr, char *buf)
 383 {
 384         return sprintf(buf, "%d\n", dev->power.ignore_children ?
 385                 0 : atomic_read(&dev->power.child_count));
 386 }
 387
 388 static ssize_t rtpm_enabled_show(struct device *dev,
 389                                  struct device_attribute *attr, char *buf)
 390 {
 391         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
 392                 return sprintf(buf, "disabled & forbidden\n");
 393         else if (dev->power.disable_depth)
 394                 return sprintf(buf, "disabled\n");
 395         else if (dev->power.runtime_auto == false)
 396                 return sprintf(buf, "forbidden\n");
 397         return sprintf(buf, "enabled\n");
 398 }
 399
 400 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
 401 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
 402 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 403
 404 #endif
 405
 406 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
 407                           char *buf)
 408 {
 409         return sprintf(buf, "%s\n",
 410                         device_async_suspend_enabled(dev) ? enabled : disabled);
 411 }
 412
 413 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 414                            const char *buf, size_t n)
 415 {
 416         char *cp;
 417         int len = n;
 418
 419         cp = memchr(buf, '\n', n);
 420         if (cp)
 421                 len = cp - buf;
 422         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
 423                 device_enable_async_suspend(dev);
 424         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
 425                 device_disable_async_suspend(dev);
 426         else
 427                 return -EINVAL;
 428         return n;
 429 }
 430
 431 static DEVICE_ATTR(async, 0644, async_show, async_store);
 432 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 433
 434 static struct attribute * power_attrs[] = {
 435         &dev_attr_wakeup.attr,
 436 #ifdef CONFIG_PM_SLEEP
 437         &dev_attr_wakeup_count.attr,
 438         &dev_attr_wakeup_active_count.attr,
 439         &dev_attr_wakeup_hit_count.attr,
 440         &dev_attr_wakeup_active.attr,
 441         &dev_attr_wakeup_total_time_ms.attr,
 442         &dev_attr_wakeup_max_time_ms.attr,
 443         &dev_attr_wakeup_last_time_ms.attr,
 444 #endif
 445 #ifdef CONFIG_PM_ADVANCED_DEBUG
 446         &dev_attr_async.attr,
 447 #ifdef CONFIG_PM_RUNTIME
 448         &dev_attr_runtime_status.attr,
 449         &dev_attr_runtime_usage.attr,
 450         &dev_attr_runtime_active_kids.attr,
 451         &dev_attr_runtime_enabled.attr,
 452 #endif
 453 #endif
 454         NULL,
 455 };
 456 static struct attribute_group pm_attr_group = {
 457         .name   = power_group_name,
 458         .attrs  = power_attrs,
 459 };
 460
 461 #ifdef CONFIG_PM_RUNTIME
 462
 463 static struct attribute *runtime_attrs[] = {
 464 #ifndef CONFIG_PM_ADVANCED_DEBUG
 465         &dev_attr_runtime_status.attr,
 466 #endif
 467         &dev_attr_control.attr,
 468         &dev_attr_runtime_suspended_time.attr,
 469         &dev_attr_runtime_active_time.attr,
 470         &dev_attr_autosuspend_delay_ms.attr,
 471         NULL,
 472 };
 473 static struct attribute_group pm_runtime_attr_group = {
 474         .name   = power_group_name,
 475         .attrs  = runtime_attrs,
 476 };
 477
 478 int dpm_sysfs_add(struct device *dev)
 479 {
 480         int rc;
 481
 482         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
 483         if (rc == 0 && !dev->power.no_callbacks) {
 484                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
 485                 if (rc)
 486                         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 487         }
 488         return rc;
 489 }
 490
 491 void rpm_sysfs_remove(struct device *dev)
 492 {
 493         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 494 }
 495
 496 void dpm_sysfs_remove(struct device *dev)
 497 {
 498         rpm_sysfs_remove(dev);
 499         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 500 }
 501
 502 #else /* CONFIG_PM_RUNTIME */
 503
 504 int dpm_sysfs_add(struct device * dev)
 505 {
 506         return sysfs_create_group(&dev->kobj, &pm_attr_group);
 507 }
 508
 509 void dpm_sysfs_remove(struct device * dev)
 510 {
 511         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 512 }
 513
 514 #endif