1// SPDX-License-Identifier: GPL-2.0 2/* sysfs entries for device PM */ 3#include <linux/device.h> 4#include <linux/kobject.h> 5#include <linux/string.h> 6#include <linux/export.h> 7#include <linux/pm_qos.h> 8#include <linux/pm_runtime.h> 9#include <linux/pm_wakeup.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 98static const char ctrl_auto[] = "auto"; 99static const char ctrl_on[] = "on"; 100 101static ssize_t control_show(struct device *dev, struct device_attribute *attr, 102 char *buf) 103{ 104 return sysfs_emit(buf, "%s\n", 105 dev->power.runtime_auto ? ctrl_auto : ctrl_on); 106} 107 108static ssize_t control_store(struct device * dev, struct device_attribute *attr, 109 const char * buf, size_t n) 110{ 111 device_lock(dev); 112 if (sysfs_streq(buf, ctrl_auto)) 113 pm_runtime_allow(dev); 114 else if (sysfs_streq(buf, ctrl_on)) 115 pm_runtime_forbid(dev); 116 else 117 n = -EINVAL; 118 device_unlock(dev); 119 return n; 120} 121 122static DEVICE_ATTR_RW(control); 123 124static ssize_t runtime_active_time_show(struct device *dev, 125 struct device_attribute *attr, 126 char *buf) 127{ 128 u64 tmp = pm_runtime_active_time(dev); 129 130 do_div(tmp, NSEC_PER_MSEC); 131 132 return sysfs_emit(buf, "%llu\n", tmp); 133} 134 135static DEVICE_ATTR_RO(runtime_active_time); 136 137static ssize_t runtime_suspended_time_show(struct device *dev, 138 struct device_attribute *attr, 139 char *buf) 140{ 141 u64 tmp = pm_runtime_suspended_time(dev); 142 143 do_div(tmp, NSEC_PER_MSEC); 144 145 return sysfs_emit(buf, "%llu\n", tmp); 146} 147 148static DEVICE_ATTR_RO(runtime_suspended_time); 149 150static ssize_t runtime_status_show(struct device *dev, 151 struct device_attribute *attr, char *buf) 152{ 153 const char *output; 154 155 if (dev->power.runtime_error) { 156 output = "error"; 157 } else if (dev->power.disable_depth) { 158 output = "unsupported"; 159 } else { 160 switch (dev->power.runtime_status) { 161 case RPM_SUSPENDED: 162 output = "suspended"; 163 break; 164 case RPM_SUSPENDING: 165 output = "suspending"; 166 break; 167 case RPM_RESUMING: 168 output = "resuming"; 169 break; 170 case RPM_ACTIVE: 171 output = "active"; 172 break; 173 default: 174 return -EIO; 175 } 176 } 177 return sysfs_emit(buf, "%s\n", output); 178} 179 180static DEVICE_ATTR_RO(runtime_status); 181 182static ssize_t autosuspend_delay_ms_show(struct device *dev, 183 struct device_attribute *attr, 184 char *buf) 185{ 186 if (!dev->power.use_autosuspend) 187 return -EIO; 188 189 return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay); 190} 191 192static ssize_t autosuspend_delay_ms_store(struct device *dev, 193 struct device_attribute *attr, const char *buf, size_t n) 194{ 195 long delay; 196 197 if (!dev->power.use_autosuspend) 198 return -EIO; 199 200 if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay) 201 return -EINVAL; 202 203 device_lock(dev); 204 pm_runtime_set_autosuspend_delay(dev, delay); 205 device_unlock(dev); 206 return n; 207} 208 209static DEVICE_ATTR_RW(autosuspend_delay_ms); 210 211static ssize_t pm_qos_resume_latency_us_show(struct device *dev, 212 struct device_attribute *attr, 213 char *buf) 214{ 215 s32 value = dev_pm_qos_requested_resume_latency(dev); 216 217 if (value == 0) 218 return sysfs_emit(buf, "n/a\n"); 219 if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) 220 value = 0; 221 222 return sysfs_emit(buf, "%d\n", value); 223} 224 225static ssize_t pm_qos_resume_latency_us_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 /* 234 * Prevent users from writing negative or "no constraint" values 235 * directly. 236 */ 237 if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) 238 return -EINVAL; 239 240 if (value == 0) 241 value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT; 242 } else if (sysfs_streq(buf, "n/a")) { 243 value = 0; 244 } else { 245 return -EINVAL; 246 } 247 248 ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req, 249 value); 250 return ret < 0 ? ret : n; 251} 252 253static DEVICE_ATTR_RW(pm_qos_resume_latency_us); 254 255static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev, 256 struct device_attribute *attr, 257 char *buf) 258{ 259 s32 value = dev_pm_qos_get_user_latency_tolerance(dev); 260 261 if (value < 0) 262 return sysfs_emit(buf, "%s\n", "auto"); 263 if (value == PM_QOS_LATENCY_ANY) 264 return sysfs_emit(buf, "%s\n", "any"); 265 266 return sysfs_emit(buf, "%d\n", value); 267} 268 269static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev, 270 struct device_attribute *attr, 271 const char *buf, size_t n) 272{ 273 s32 value; 274 int ret; 275 276 if (kstrtos32(buf, 0, &value) == 0) { 277 /* Users can't write negative values directly */ 278 if (value < 0) 279 return -EINVAL; 280 } else { 281 if (sysfs_streq(buf, "auto")) 282 value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT; 283 else if (sysfs_streq(buf, "any")) 284 value = PM_QOS_LATENCY_ANY; 285 else 286 return -EINVAL; 287 } 288 ret = dev_pm_qos_update_user_latency_tolerance(dev, value); 289 return ret < 0 ? ret : n; 290} 291 292static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us); 293 294static ssize_t pm_qos_no_power_off_show(struct device *dev, 295 struct device_attribute *attr, 296 char *buf) 297{ 298 return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) 299 & PM_QOS_FLAG_NO_POWER_OFF)); 300} 301 302static ssize_t pm_qos_no_power_off_store(struct device *dev, 303 struct device_attribute *attr, 304 const char *buf, size_t n) 305{ 306 int ret; 307 308 if (kstrtoint(buf, 0, &ret)) 309 return -EINVAL; 310 311 if (ret != 0 && ret != 1) 312 return -EINVAL; 313 314 ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret); 315 return ret < 0 ? ret : n; 316} 317 318static DEVICE_ATTR_RW(pm_qos_no_power_off); 319 320#ifdef CONFIG_PM_SLEEP 321static const char _enabled[] = "enabled"; 322static const char _disabled[] = "disabled"; 323 324static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr, 325 char *buf) 326{ 327 return sysfs_emit(buf, "%s\n", device_can_wakeup(dev) 328 ? (device_may_wakeup(dev) ? _enabled : _disabled) 329 : ""); 330} 331 332static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr, 333 const char *buf, size_t n) 334{ 335 if (!device_can_wakeup(dev)) 336 return -EINVAL; 337 338 if (sysfs_streq(buf, _enabled)) 339 device_set_wakeup_enable(dev, 1); 340 else if (sysfs_streq(buf, _disabled)) 341 device_set_wakeup_enable(dev, 0); 342 else 343 return -EINVAL; 344 return n; 345} 346 347static DEVICE_ATTR_RW(wakeup); 348 349static ssize_t wakeup_count_show(struct device *dev, 350 struct device_attribute *attr, char *buf) 351{ 352 unsigned long count; 353 bool enabled = false; 354 355 spin_lock_irq(&dev->power.lock); 356 if (dev->power.wakeup) { 357 count = dev->power.wakeup->wakeup_count; 358 enabled = true; 359 } 360 spin_unlock_irq(&dev->power.lock); 361 362 if (!enabled) 363 return sysfs_emit(buf, "\n"); 364 return sysfs_emit(buf, "%lu\n", count); 365} 366 367static DEVICE_ATTR_RO(wakeup_count); 368 369static ssize_t wakeup_active_count_show(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372{ 373 unsigned long count; 374 bool enabled = false; 375 376 spin_lock_irq(&dev->power.lock); 377 if (dev->power.wakeup) { 378 count = dev->power.wakeup->active_count; 379 enabled = true; 380 } 381 spin_unlock_irq(&dev->power.lock); 382 383 if (!enabled) 384 return sysfs_emit(buf, "\n"); 385 return sysfs_emit(buf, "%lu\n", count); 386} 387 388static DEVICE_ATTR_RO(wakeup_active_count); 389 390static ssize_t wakeup_abort_count_show(struct device *dev, 391 struct device_attribute *attr, 392 char *buf) 393{ 394 unsigned long count; 395 bool enabled = false; 396 397 spin_lock_irq(&dev->power.lock); 398 if (dev->power.wakeup) { 399 count = dev->power.wakeup->wakeup_count; 400 enabled = true; 401 } 402 spin_unlock_irq(&dev->power.lock); 403 404 if (!enabled) 405 return sysfs_emit(buf, "\n"); 406 return sysfs_emit(buf, "%lu\n", count); 407} 408 409static DEVICE_ATTR_RO(wakeup_abort_count); 410 411static ssize_t wakeup_expire_count_show(struct device *dev, 412 struct device_attribute *attr, 413 char *buf) 414{ 415 unsigned long count; 416 bool enabled = false; 417 418 spin_lock_irq(&dev->power.lock); 419 if (dev->power.wakeup) { 420 count = dev->power.wakeup->expire_count; 421 enabled = true; 422 } 423 spin_unlock_irq(&dev->power.lock); 424 425 if (!enabled) 426 return sysfs_emit(buf, "\n"); 427 return sysfs_emit(buf, "%lu\n", count); 428} 429 430static DEVICE_ATTR_RO(wakeup_expire_count); 431 432static ssize_t wakeup_active_show(struct device *dev, 433 struct device_attribute *attr, char *buf) 434{ 435 unsigned int active; 436 bool enabled = false; 437 438 spin_lock_irq(&dev->power.lock); 439 if (dev->power.wakeup) { 440 active = dev->power.wakeup->active; 441 enabled = true; 442 } 443 spin_unlock_irq(&dev->power.lock); 444 445 if (!enabled) 446 return sysfs_emit(buf, "\n"); 447 return sysfs_emit(buf, "%u\n", active); 448} 449 450static DEVICE_ATTR_RO(wakeup_active); 451 452static ssize_t wakeup_total_time_ms_show(struct device *dev, 453 struct device_attribute *attr, 454 char *buf) 455{ 456 s64 msec; 457 bool enabled = false; 458 459 spin_lock_irq(&dev->power.lock); 460 if (dev->power.wakeup) { 461 msec = ktime_to_ms(dev->power.wakeup->total_time); 462 enabled = true; 463 } 464 spin_unlock_irq(&dev->power.lock); 465 466 if (!enabled) 467 return sysfs_emit(buf, "\n"); 468 return sysfs_emit(buf, "%lld\n", msec); 469} 470 471static DEVICE_ATTR_RO(wakeup_total_time_ms); 472 473static ssize_t wakeup_max_time_ms_show(struct device *dev, 474 struct device_attribute *attr, char *buf) 475{ 476 s64 msec; 477 bool enabled = false; 478 479 spin_lock_irq(&dev->power.lock); 480 if (dev->power.wakeup) { 481 msec = ktime_to_ms(dev->power.wakeup->max_time); 482 enabled = true; 483 } 484 spin_unlock_irq(&dev->power.lock); 485 486 if (!enabled) 487 return sysfs_emit(buf, "\n"); 488 return sysfs_emit(buf, "%lld\n", msec); 489} 490 491static DEVICE_ATTR_RO(wakeup_max_time_ms); 492 493static ssize_t wakeup_last_time_ms_show(struct device *dev, 494 struct device_attribute *attr, 495 char *buf) 496{ 497 s64 msec; 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 507 if (!enabled) 508 return sysfs_emit(buf, "\n"); 509 return sysfs_emit(buf, "%lld\n", msec); 510} 511 512static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid, 513 kgid_t kgid) 514{ 515 if (dev->power.wakeup && dev->power.wakeup->dev) 516 return device_change_owner(dev->power.wakeup->dev, kuid, kgid); 517 return 0; 518} 519 520static DEVICE_ATTR_RO(wakeup_last_time_ms); 521 522#ifdef CONFIG_PM_AUTOSLEEP 523static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev, 524 struct device_attribute *attr, 525 char *buf) 526{ 527 s64 msec; 528 bool enabled = false; 529 530 spin_lock_irq(&dev->power.lock); 531 if (dev->power.wakeup) { 532 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time); 533 enabled = true; 534 } 535 spin_unlock_irq(&dev->power.lock); 536 537 if (!enabled) 538 return sysfs_emit(buf, "\n"); 539 return sysfs_emit(buf, "%lld\n", msec); 540} 541 542static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms); 543#endif /* CONFIG_PM_AUTOSLEEP */ 544#else /* CONFIG_PM_SLEEP */ 545static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid, 546 kgid_t kgid) 547{ 548 return 0; 549} 550#endif 551 552#ifdef CONFIG_PM_ADVANCED_DEBUG 553static ssize_t runtime_usage_show(struct device *dev, 554 struct device_attribute *attr, char *buf) 555{ 556 return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count)); 557} 558static DEVICE_ATTR_RO(runtime_usage); 559 560static ssize_t runtime_active_kids_show(struct device *dev, 561 struct device_attribute *attr, 562 char *buf) 563{ 564 return sysfs_emit(buf, "%d\n", dev->power.ignore_children ? 565 0 : atomic_read(&dev->power.child_count)); 566} 567static DEVICE_ATTR_RO(runtime_active_kids); 568 569static ssize_t runtime_enabled_show(struct device *dev, 570 struct device_attribute *attr, char *buf) 571{ 572 const char *output; 573 574 if (dev->power.disable_depth && !dev->power.runtime_auto) 575 output = "disabled & forbidden"; 576 else if (dev->power.disable_depth) 577 output = "disabled"; 578 else if (!dev->power.runtime_auto) 579 output = "forbidden"; 580 else 581 output = "enabled"; 582 583 return sysfs_emit(buf, "%s\n", output); 584} 585static DEVICE_ATTR_RO(runtime_enabled); 586 587#ifdef CONFIG_PM_SLEEP 588static ssize_t async_show(struct device *dev, struct device_attribute *attr, 589 char *buf) 590{ 591 return sysfs_emit(buf, "%s\n", 592 device_async_suspend_enabled(dev) ? 593 _enabled : _disabled); 594} 595 596static ssize_t async_store(struct device *dev, struct device_attribute *attr, 597 const char *buf, size_t n) 598{ 599 if (sysfs_streq(buf, _enabled)) 600 device_enable_async_suspend(dev); 601 else if (sysfs_streq(buf, _disabled)) 602 device_disable_async_suspend(dev); 603 else 604 return -EINVAL; 605 return n; 606} 607 608static DEVICE_ATTR_RW(async); 609 610#endif /* CONFIG_PM_SLEEP */ 611#endif /* CONFIG_PM_ADVANCED_DEBUG */ 612 613static struct attribute *power_attrs[] = { 614#ifdef CONFIG_PM_ADVANCED_DEBUG 615#ifdef CONFIG_PM_SLEEP 616 &dev_attr_async.attr, 617#endif 618 &dev_attr_runtime_status.attr, 619 &dev_attr_runtime_usage.attr, 620 &dev_attr_runtime_active_kids.attr, 621 &dev_attr_runtime_enabled.attr, 622#endif /* CONFIG_PM_ADVANCED_DEBUG */ 623 NULL, 624}; 625static const struct attribute_group pm_attr_group = { 626 .name = power_group_name, 627 .attrs = power_attrs, 628}; 629 630static struct attribute *wakeup_attrs[] = { 631#ifdef CONFIG_PM_SLEEP 632 &dev_attr_wakeup.attr, 633 &dev_attr_wakeup_count.attr, 634 &dev_attr_wakeup_active_count.attr, 635 &dev_attr_wakeup_abort_count.attr, 636 &dev_attr_wakeup_expire_count.attr, 637 &dev_attr_wakeup_active.attr, 638 &dev_attr_wakeup_total_time_ms.attr, 639 &dev_attr_wakeup_max_time_ms.attr, 640 &dev_attr_wakeup_last_time_ms.attr, 641#ifdef CONFIG_PM_AUTOSLEEP 642 &dev_attr_wakeup_prevent_sleep_time_ms.attr, 643#endif 644#endif 645 NULL, 646}; 647static const struct attribute_group pm_wakeup_attr_group = { 648 .name = power_group_name, 649 .attrs = wakeup_attrs, 650}; 651 652static struct attribute *runtime_attrs[] = { 653#ifndef CONFIG_PM_ADVANCED_DEBUG 654 &dev_attr_runtime_status.attr, 655#endif 656 &dev_attr_control.attr, 657 &dev_attr_runtime_suspended_time.attr, 658 &dev_attr_runtime_active_time.attr, 659 &dev_attr_autosuspend_delay_ms.attr, 660 NULL, 661}; 662static const struct attribute_group pm_runtime_attr_group = { 663 .name = power_group_name, 664 .attrs = runtime_attrs, 665}; 666 667static struct attribute *pm_qos_resume_latency_attrs[] = { 668 &dev_attr_pm_qos_resume_latency_us.attr, 669 NULL, 670}; 671static const struct attribute_group pm_qos_resume_latency_attr_group = { 672 .name = power_group_name, 673 .attrs = pm_qos_resume_latency_attrs, 674}; 675 676static struct attribute *pm_qos_latency_tolerance_attrs[] = { 677 &dev_attr_pm_qos_latency_tolerance_us.attr, 678 NULL, 679}; 680static const struct attribute_group pm_qos_latency_tolerance_attr_group = { 681 .name = power_group_name, 682 .attrs = pm_qos_latency_tolerance_attrs, 683}; 684 685static struct attribute *pm_qos_flags_attrs[] = { 686 &dev_attr_pm_qos_no_power_off.attr, 687 NULL, 688}; 689static const struct attribute_group pm_qos_flags_attr_group = { 690 .name = power_group_name, 691 .attrs = pm_qos_flags_attrs, 692}; 693 694int dpm_sysfs_add(struct device *dev) 695{ 696 int rc; 697 698 /* No need to create PM sysfs if explicitly disabled. */ 699 if (device_pm_not_required(dev)) 700 return 0; 701 702 rc = sysfs_create_group(&dev->kobj, &pm_attr_group); 703 if (rc) 704 return rc; 705 706 if (!pm_runtime_has_no_callbacks(dev)) { 707 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group); 708 if (rc) 709 goto err_out; 710 } 711 if (device_can_wakeup(dev)) { 712 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); 713 if (rc) 714 goto err_runtime; 715 } 716 if (dev->power.set_latency_tolerance) { 717 rc = sysfs_merge_group(&dev->kobj, 718 &pm_qos_latency_tolerance_attr_group); 719 if (rc) 720 goto err_wakeup; 721 } 722 rc = pm_wakeup_source_sysfs_add(dev); 723 if (rc) 724 goto err_latency; 725 return 0; 726 727 err_latency: 728 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group); 729 err_wakeup: 730 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 731 err_runtime: 732 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group); 733 err_out: 734 sysfs_remove_group(&dev->kobj, &pm_attr_group); 735 return rc; 736} 737 738int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 739{ 740 int rc; 741 742 if (device_pm_not_required(dev)) 743 return 0; 744 745 rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid); 746 if (rc) 747 return rc; 748 749 if (!pm_runtime_has_no_callbacks(dev)) { 750 rc = sysfs_group_change_owner( 751 &dev->kobj, &pm_runtime_attr_group, kuid, kgid); 752 if (rc) 753 return rc; 754 } 755 756 if (device_can_wakeup(dev)) { 757 rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group, 758 kuid, kgid); 759 if (rc) 760 return rc; 761 762 rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid); 763 if (rc) 764 return rc; 765 } 766 767 if (dev->power.set_latency_tolerance) { 768 rc = sysfs_group_change_owner( 769 &dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid, 770 kgid); 771 if (rc) 772 return rc; 773 } 774 return 0; 775} 776 777int wakeup_sysfs_add(struct device *dev) 778{ 779 int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); 780 781 if (!ret) 782 kobject_uevent(&dev->kobj, KOBJ_CHANGE); 783 784 return ret; 785} 786 787void wakeup_sysfs_remove(struct device *dev) 788{ 789 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 790 kobject_uevent(&dev->kobj, KOBJ_CHANGE); 791} 792 793int pm_qos_sysfs_add_resume_latency(struct device *dev) 794{ 795 return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group); 796} 797 798void pm_qos_sysfs_remove_resume_latency(struct device *dev) 799{ 800 sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group); 801} 802 803int pm_qos_sysfs_add_flags(struct device *dev) 804{ 805 return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group); 806} 807 808void pm_qos_sysfs_remove_flags(struct device *dev) 809{ 810 sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group); 811} 812 813int pm_qos_sysfs_add_latency_tolerance(struct device *dev) 814{ 815 return sysfs_merge_group(&dev->kobj, 816 &pm_qos_latency_tolerance_attr_group); 817} 818 819void pm_qos_sysfs_remove_latency_tolerance(struct device *dev) 820{ 821 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group); 822} 823 824void rpm_sysfs_remove(struct device *dev) 825{ 826 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group); 827} 828 829void dpm_sysfs_remove(struct device *dev) 830{ 831 if (device_pm_not_required(dev)) 832 return; 833 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group); 834 dev_pm_qos_constraints_destroy(dev); 835 rpm_sysfs_remove(dev); 836 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); 837 sysfs_remove_group(&dev->kobj, &pm_attr_group); 838} 839