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 95const char power_group_name[] = "power"; 96EXPORT_SYMBOL_GPL(power_group_name); 97 98#ifdef CONFIG_PM_RUNTIME 99static const char ctrl_auto[] = "auto"; 100static const char ctrl_on[] = "on"; 101 102static ssize_t control_show(struct device *dev, struct device_attribute *attr, 103 char *buf) 104{ 105 return sprintf(buf, "%s\n", 106 dev->power.runtime_auto ? ctrl_auto : ctrl_on); 107} 108 109static ssize_t control_store(struct device * dev, struct device_attribute *attr, 110 const char * buf, size_t n) 111{ 112 char *cp; 113 int len = n; 114 115 cp = memchr(buf, '\n', n); 116 if (cp) 117 len = cp - buf; 118 device_lock(dev); 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 n = -EINVAL; 125 device_unlock(dev); 126 return n; 127} 128 129static DEVICE_ATTR(control, 0644, control_show, control_store); 130 131static ssize_t rtpm_active_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", jiffies_to_msecs(dev->power.active_jiffies)); 138 spin_unlock_irq(&dev->power.lock); 139 return ret; 140} 141 142static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL); 143 144static ssize_t rtpm_suspended_time_show(struct device *dev, 145 struct device_attribute *attr, char *buf) 146{ 147 int ret; 148 spin_lock_irq(&dev->power.lock); 149 update_pm_runtime_accounting(dev); 150 ret = sprintf(buf, "%i\n", 151 jiffies_to_msecs(dev->power.suspended_jiffies)); 152 spin_unlock_irq(&dev->power.lock); 153 return ret; 154} 155 156static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL); 157 158static ssize_t rtpm_status_show(struct device *dev, 159 struct device_attribute *attr, char *buf) 160{ 161 const char *p; 162 163 if (dev->power.runtime_error) { 164 p = "error\n"; 165 } else if (dev->power.disable_depth) { 166 p = "unsupported\n"; 167 } else { 168 switch (dev->power.runtime_status) { 169 case RPM_SUSPENDED: 170 p = "suspended\n"; 171 break; 172 case RPM_SUSPENDING: 173 p = "suspending\n"; 174 break; 175 case RPM_RESUMING: 176 p = "resuming\n"; 177 break; 178 case RPM_ACTIVE: 179 p = "active\n"; 180 break; 181 default: 182 return -EIO; 183 } 184 } 185 return sprintf(buf, p); 186} 187 188static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL); 189 190static ssize_t autosuspend_delay_ms_show(struct device *dev, 191 struct device_attribute *attr, char *buf) 192{ 193 if (!dev->power.use_autosuspend) 194 return -EIO; 195 return sprintf(buf, "%d\n", dev->power.autosuspend_delay); 196} 197 198static ssize_t autosuspend_delay_ms_store(struct device *dev, 199 struct device_attribute *attr, const char *buf, size_t n) 200{ 201 long delay; 202 203 if (!dev->power.use_autosuspend) 204 return -EIO; 205 206 if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay) 207 return -EINVAL; 208 209 device_lock(dev); 210 pm_runtime_set_autosuspend_delay(dev, delay); 211 device_unlock(dev); 212 return n; 213} 214 215static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show, 216 autosuspend_delay_ms_store); 217 218static ssize_t pm_qos_resume_latency_show(struct device *dev, 219 struct device_attribute *attr, 220 char *buf) 221{ 222 return sprintf(buf, "%d\n", dev_pm_qos_requested_resume_latency(dev)); 223} 224 225static ssize_t pm_qos_resume_latency_store(struct device *dev, 226 struct device_attribute *attr, 227 const char *buf, size_t n) 228{ 229 s32 value; 230 int ret; 231 232 if (kstrtos32(buf, 0, &value)) 233 return -EINVAL; 234 235 if (value < 0) 236 return -EINVAL; 237 238 ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req, 239 value); 240 return ret < 0 ? ret : n; 241} 242 243static DEVICE_ATTR(pm_qos_resume_latency_us, 0644, 244 pm_qos_resume_latency_show, pm_qos_resume_latency_store); 245 246static ssize_t pm_qos_latency_tolerance_show(struct device *dev, 247 struct device_attribute *attr, 248 char *buf) 249{ 250 s32 value = dev_pm_qos_get_user_latency_tolerance(dev); 251 252 if (value < 0) 253 return sprintf(buf, "auto\n"); 254 else if (value == PM_QOS_LATENCY_ANY) 255 return sprintf(buf, "any\n"); 256 257 return sprintf(buf, "%d\n", value); 258} 259 260static ssize_t pm_qos_latency_tolerance_store(struct device *dev, 261 struct device_attribute *attr, 262 const char *buf, size_t n) 263{ 264 s32 value; 265 int ret; 266 267 if (kstrtos32(buf, 0, &value)) { 268 if (!strcmp(buf, "auto") || !strcmp(buf, "auto\n")) 269 value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT; 270 else if (!strcmp(buf, "any") || !strcmp(buf, "any\n")) 271 value = PM_QOS_LATENCY_ANY; 272 } 273 ret = dev_pm_qos_update_user_latency_tolerance(dev, value); 274 return ret < 0 ? ret : n; 275} 276 277static DEVICE_ATTR(pm_qos_latency_tolerance_us, 0644, 278 pm_qos_latency_tolerance_show, pm_qos_latency_tolerance_store); 279 280static ssize_t pm_qos_no_power_off_show(struct device *dev, 281 struct device_attribute *attr, 282 char *buf) 283{ 284 return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) 285 & PM_QOS_FLAG_NO_POWER_OFF)); 286} 287 288static ssize_t pm_qos_no_power_off_store(struct device *dev, 289 struct device_attribute *attr, 290 const char *buf, size_t n) 291{ 292 int ret; 293 294 if (kstrtoint(buf, 0, &ret)) 295 return -EINVAL; 296 297 if (ret != 0 && ret != 1) 298 return -EINVAL; 299 300 ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret); 301 return ret < 0 ? ret : n; 302} 303 304static DEVICE_ATTR(pm_qos_no_power_off, 0644, 305 pm_qos_no_power_off_show, pm_qos_no_power_off_store); 306 307static ssize_t pm_qos_remote_wakeup_show(struct device *dev, 308 struct device_attribute *attr, 309 char *buf) 310{ 311 return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) 312 & PM_QOS_FLAG_REMOTE_WAKEUP)); 313} 314 315static ssize_t pm_qos_remote_wakeup_store(struct device *dev, 316 struct device_attribute *attr, 317 const char *buf, size_t n) 318{ 319 int ret; 320 321 if (kstrtoint(buf, 0, &ret)) 322 return -EINVAL; 323 324 if (ret != 0 && ret != 1) 325 return -EINVAL; 326 327 ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP, ret); 328 return ret < 0 ? ret : n; 329} 330 331static DEVICE_ATTR(pm_qos_remote_wakeup, 0644, 332 pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store); 333#endif /* CONFIG_PM_RUNTIME */ 334 335#ifdef CONFIG_PM_SLEEP 336static const char _enabled[] = "enabled"; 337static const char _disabled[] = "disabled"; 338 339static ssize_t 340wake_show(struct device * dev, struct device_attribute *attr, char * buf) 341{ 342 return sprintf(buf, "%s\n", device_can_wakeup(dev) 343 ? (device_may_wakeup(dev) ? _enabled : _disabled) 344 : ""); 345} 346 347static ssize_t 348wake_store(struct device * dev, struct device_attribute *attr, 349 const char * buf, size_t n) 350{ 351 char *cp; 352 int len = n; 353 354 if (!device_can_wakeup(dev)) 355 return -EINVAL; 356 357 cp = memchr(buf, '\n', n); 358 if (cp) 359 len = cp - buf; 360 if (len == sizeof _enabled - 1 361 && strncmp(buf, _enabled, sizeof _enabled - 1) == 0) 362 device_set_wakeup_enable(dev, 1); 363 else if (len == sizeof _disabled - 1 364 && strncmp(buf, _disabled, sizeof _disabled - 1) == 0) 365 device_set_wakeup_enable(dev, 0); 366 else 367 return -EINVAL; 368 return n; 369} 370 371static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store); 372 373static ssize_t wakeup_count_show(struct device *dev, 374 struct device_attribute *attr, char *buf) 375{ 376 unsigned long count = 0; 377 bool enabled = false; 378 379 spin_lock_irq(&dev->power.lock); 380 if (dev->power.wakeup) { 381 count = dev->power.wakeup->event_count; 382 enabled = true; 383 } 384 spin_unlock_irq(&dev->power.lock); 385 return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); 386} 387 388static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL); 389 390static ssize_t wakeup_active_count_show(struct device *dev, 391 struct device_attribute *attr, char *buf) 392{ 393 unsigned long count = 0; 394 bool enabled = false; 395 396 spin_lock_irq(&dev->power.lock); 397 if (dev->power.wakeup) { 398 count = dev->power.wakeup->active_count; 399 enabled = true; 400 } 401 spin_unlock_irq(&dev->power.lock); 402 return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); 403} 404 405static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL); 406 407static ssize_t wakeup_abort_count_show(struct device *dev, 408 struct device_attribute *attr, 409 char *buf) 410{ 411 unsigned long count = 0; 412 bool enabled = false; 413 414 spin_lock_irq(&dev->power.lock); 415 if (dev->power.wakeup) { 416 count = dev->power.wakeup->wakeup_count; 417 enabled = true; 418 } 419 spin_unlock_irq(&dev->power.lock); 420 return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); 421} 422 423static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL); 424 425static ssize_t wakeup_expire_count_show(struct device *dev, 426 struct device_attribute *attr, 427 char *buf) 428{ 429 unsigned long count = 0; 430 bool enabled = false; 431 432 spin_lock_irq(&dev->power.lock); 433 if (dev->power.wakeup) { 434 count = dev->power.wakeup->expire_count; 435 enabled = true; 436 } 437 spin_unlock_irq(&dev->power.lock); 438 return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); 439} 440 441static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL); 442 443static ssize_t wakeup_active_show(struct device *dev, 444 struct device_attribute *attr, char *buf) 445{ 446 unsigned int active = 0; 447 bool enabled = false; 448 449 spin_lock_irq(&dev->power.lock); 450 if (dev->power.wakeup) { 451 active = dev->power.wakeup->active; 452 enabled = true; 453 } 454 spin_unlock_irq(&dev->power.lock); 455 return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n"); 456} 457 458static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL); 459 460static ssize_t wakeup_total_time_show(struct device *dev, 461 struct device_attribute *attr, char *buf) 462{ 463 s64 msec = 0; 464 bool enabled = false; 465 466 spin_lock_irq(&dev->power.lock); 467 if (dev->power.wakeup) { 468 msec = ktime_to_ms(dev->power.wakeup->total_time); 469 enabled = true; 470 } 471 spin_unlock_irq(&dev->power.lock); 472 return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); 473} 474 475static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL); 476 477static ssize_t wakeup_max_time_show(struct device *dev, 478 struct device_attribute *attr, char *buf) 479{ 480 s64 msec = 0; 481 bool enabled = false; 482 483 spin_lock_irq(&dev->power.lock); 484 if (dev->power.wakeup) { 485 msec = ktime_to_ms(dev->power.wakeup->max_time); 486 enabled = true; 487 } 488 spin_unlock_irq(&dev->power.lock); 489 return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); 490} 491 492static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL); 493 494static ssize_t wakeup_last_time_show(struct device *dev, 495 struct device_attribute *attr, char *buf) 496{ 497 s64 msec = 0; 498 bool enabled = false; 499 500 spin_lock_irq(&dev->power.lock); 501 if (dev->power.wakeup) { 502 msec = ktime_to_ms(dev->power.wakeup->last_time); 503 enabled = true; 504 } 505 spin_unlock_irq(&dev->power.lock); 506 return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); 507} 508 509static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL); 510 511#ifdef CONFIG_PM_AUTOSLEEP 512static ssize_t wakeup_prevent_sleep_time_show(struct device *dev, 513 struct device_attribute *attr, 514 char *buf) 515{ 516 s64 msec = 0; 517 bool enabled = false; 518 519 spin_lock_irq(&dev->power.lock); 520 if (dev->power.wakeup) { 521 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time); 522 enabled = true; 523 } 524 spin_unlock_irq(&dev->power.lock); 525 return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); 526} 527 528static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444, 529 wakeup_prevent_sleep_time_show, NULL); 530#endif /* CONFIG_PM_AUTOSLEEP */ 531#endif /* CONFIG_PM_SLEEP */ 532 533#ifdef CONFIG_PM_ADVANCED_DEBUG 534#ifdef CONFIG_PM_RUNTIME 535 536static ssize_t rtpm_usagecount_show(struct device *dev, 537 struct device_attribute *attr, char *buf) 538{ 539 return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count)); 540} 541 542static ssize_t rtpm_children_show(struct device *dev, 543 struct device_attribute *attr, char *buf) 544{ 545 return sprintf(buf, "%d\n", dev->power.ignore_children ? 546 0 : atomic_read(&dev->power.child_count)); 547} 548 549static ssize_t rtpm_enabled_show(struct device *dev, 550 struct device_attribute *attr, char *buf) 551{ 552 if ((dev->power.disable_depth) && (dev->power.runtime_auto == false)) 553 return sprintf(buf, "disabled & forbidden\n"); 554 else if (dev->power.disable_depth) 555 return sprintf(buf, "disabled\n"); 556 else if (dev->power.runtime_auto == false) 557 return sprintf(buf, "forbidden\n"); 558 return sprintf(buf, "enabled\n"); 559} 560 561static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL); 562static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL); 563static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL); 564 565#endif 566 567#ifdef CONFIG_PM_SLEEP 568 569static ssize_t async_show(struct device *dev, struct device_attribute *attr, 570 char *buf) 571{ 572 return sprintf(buf, "%s\n", 573 device_async_suspend_enabled(dev) ? 574 _enabled : _disabled); 575} 576 577static ssize_t async_store(struct device *dev, struct device_attribute *attr, 578 const char *buf, size_t n) 579{ 580 char *cp; 581 int len = n; 582 583 cp = memchr(buf, '\n', n); 584 if (cp) 585 len = cp - buf; 586 if (len == sizeof _enabled - 1 && strncmp(buf, _enabled, len) == 0) 587 device_enable_async_suspend(dev); 588 else if (len == sizeof _disabled - 1 && 589 strncmp(buf, _disabled, len) == 0) 590 device_disable_async_suspend(dev); 591 else 592 return -EINVAL; 593 return n; 594} 595 596static DEVICE_ATTR(async, 0644, async_show, async_store); 597 598#endif 599#endif /* CONFIG_PM_ADVANCED_DEBUG */ 600 601static struct attribute *power_attrs[] = { 602#ifdef CONFIG_PM_ADVANCED_DEBUG 603#ifdef CONFIG_PM_SLEEP 604 &dev_attr_async.attr, 605#endif 606#ifdef CONFIG_PM_RUNTIME 607 &dev_attr_runtime_status.attr, 608 &dev_attr_runtime_usage.attr, 609 &dev_attr_runtime_active_kids.attr, 610 &dev_attr_runtime_enabled.attr, 611#endif 612#endif /* CONFIG_PM_ADVANCED_DEBUG */ 613 NULL, 614}; 615static struct attribute_group pm_attr_group = { 616 .name = power_group_name, 617 .attrs = power_attrs, 618}; 619 620static struct attribute *wakeup_attrs[] = { 621#ifdef CONFIG_PM_SLEEP 622 &dev_attr_wakeup.attr, 623 &dev_attr_wakeup_count.attr, 624 &dev_attr_wakeup_active_count.attr, 625 &dev_attr_wakeup_abort_count.attr, 626 &dev_attr_wakeup_expire_count.attr, 627 &dev_attr_wakeup_active.attr, 628 &dev_attr_wakeup_total_time_ms.attr, 629 &dev_attr_wakeup_max_time_ms.attr, 630 &dev_attr_wakeup_last_time_ms.attr, 631#ifdef CONFIG_PM_AUTOSLEEP 632 &dev_attr_wakeup_prevent_sleep_time_ms.attr, 633#endif 634#endif 635 NULL, 636}; 637static struct attribute_group pm_wakeup_attr_group = { 638 .name = power_group_name, 639 .attrs = wakeup_attrs, 640}; 641 642static struct attribute *runtime_attrs[] = { 643#ifdef CONFIG_PM_RUNTIME 644#ifndef CONFIG_PM_ADVANCED_DEBUG 645 &dev_attr_runtime_status.attr, 646#endif 647 &dev_attr_control.attr, 648 &dev_attr_runtime_suspended_time.attr, 649 &dev_attr_runtime_active_time.attr, 650 &dev_attr_autosuspend_delay_ms.attr, 651#endif /* CONFIG_PM_RUNTIME */ 652 NULL, 653}; 654static struct attribute_group pm_runtime_attr_group = { 655 .name = power_group_name, 656 .attrs = runtime_attrs, 657}; 658 659static struct attribute *pm_qos_resume_latency_attrs[] = { 660#ifdef CONFIG_PM_RUNTIME 661 &dev_attr_pm_qos_resume_latency_us.attr, 662#endif /* CONFIG_PM_RUNTIME */ 663 NULL, 664}; 665static struct attribute_group pm_qos_resume_latency_attr_group = { 666 .name = power_group_name, 667 .attrs = pm_qos_resume_latency_attrs, 668}; 669 670static struct attribute *pm_qos_latency_tolerance_attrs[] = { 671#ifdef CONFIG_PM_RUNTIME 672 &dev_attr_pm_qos_latency_tolerance_us.attr, 673#endif /* CONFIG_PM_RUNTIME */ 674 NULL, 675}; 676static struct attribute_group pm_qos_latency_tolerance_attr_group = { 677 .name = power_group_name, 678 .attrs = pm_qos_latency_tolerance_attrs, 679}; 680 681static struct attribute *pm_qos_flags_attrs[] = { 682#ifdef CONFIG_PM_RUNTIME 683 &dev_attr_pm_qos_no_power_off.attr, 684 &dev_attr_pm_qos_remote_wakeup.attr, 685#endif /* CONFIG_PM_RUNTIME */ 686 NULL, 687}; 688static struct attribute_group pm_qos_flags_attr_group = { 689 .name = power_group_name, 690 .attrs = pm_qos_flags_attrs, 691}; 692 693int dpm_sysfs_add(struct device *dev) 694{ 695 int rc; 696 697 rc = sysfs_create_group(&dev->kobj, &pm_attr_group); 698 if (rc) 699 return rc; 700 701 if (pm_runtime_callbacks_present(dev)) { 702 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group); 703 if (rc) 704 goto err_out; 705 } 706 if (device_can_wakeup(dev)) { 707 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); 708 if (rc) 709 goto err_runtime; 710 } 711 if (dev->power.set_latency_tolerance) { 712 rc = sysfs_merge_group(&dev->kobj, 713 &pm_qos_latency_tolerance_attr_group); 714 if (rc) 715 goto err_wakeup; 716 } 717 return 0; 718 719 err_wakeup: 720 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 721 err_runtime: 722 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group); 723 err_out: 724 sysfs_remove_group(&dev->kobj, &pm_attr_group); 725 return rc; 726} 727 728int wakeup_sysfs_add(struct device *dev) 729{ 730 return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); 731} 732 733void wakeup_sysfs_remove(struct device *dev) 734{ 735 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 736} 737 738int pm_qos_sysfs_add_resume_latency(struct device *dev) 739{ 740 return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group); 741} 742 743void pm_qos_sysfs_remove_resume_latency(struct device *dev) 744{ 745 sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group); 746} 747 748int pm_qos_sysfs_add_flags(struct device *dev) 749{ 750 return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group); 751} 752 753void pm_qos_sysfs_remove_flags(struct device *dev) 754{ 755 sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group); 756} 757 758void rpm_sysfs_remove(struct device *dev) 759{ 760 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group); 761} 762 763void dpm_sysfs_remove(struct device *dev) 764{ 765 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group); 766 dev_pm_qos_constraints_destroy(dev); 767 rpm_sysfs_remove(dev); 768 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 769 sysfs_remove_group(&dev->kobj, &pm_attr_group); 770} 771