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