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