1181834Sroberto// SPDX-License-Identifier: GPL-2.0 2181834Sroberto/* sysfs entries for device PM */ 3181834Sroberto#include <linux/device.h> 4200576Sroberto#include <linux/kobject.h> 5181834Sroberto#include <linux/string.h> 6181834Sroberto#include <linux/export.h> 7181834Sroberto#include <linux/pm_qos.h> 8181834Sroberto#include <linux/pm_runtime.h> 9181834Sroberto#include <linux/pm_wakeup.h> 10181834Sroberto#include <linux/atomic.h> 11181834Sroberto#include <linux/jiffies.h> 12181834Sroberto#include "power.h" 13181834Sroberto 14181834Sroberto/* 15181834Sroberto * control - Report/change current runtime PM setting of the device 16181834Sroberto * 17181834Sroberto * Runtime power management of a device can be blocked with the help of 18181834Sroberto * this attribute. All devices have one of the following two values for 19181834Sroberto * the power/control file: 20181834Sroberto * 21181834Sroberto * + "auto\n" to allow the device to be power managed at run time; 22200576Sroberto * + "on\n" to prevent the device from being power managed at run time; 23181834Sroberto * 24181834Sroberto * The default for all devices is "auto", which means that devices may be 25181834Sroberto * subject to automatic power management, depending on their drivers. 26181834Sroberto * Changing this attribute to "on" prevents the driver from power managing 27181834Sroberto * the device at run time. Doing that while the device is suspended causes 28181834Sroberto * it to be woken up. 29181834Sroberto * 30181834Sroberto * wakeup - Report/change current wakeup option for device 31181834Sroberto * 32181834Sroberto * Some devices support "wakeup" events, which are hardware signals 33181834Sroberto * used to activate devices from suspended or low power states. Such 34181834Sroberto * devices have one of three values for the sysfs power/wakeup file: 35181834Sroberto * 36181834Sroberto * + "enabled\n" to issue the events; 37181834Sroberto * + "disabled\n" not to do so; or 38181834Sroberto * + "\n" for temporary or permanent inability to issue wakeup. 39181834Sroberto * 40181834Sroberto * (For example, unconfigured USB devices can't issue wakeups.) 41181834Sroberto * 42181834Sroberto * Familiar examples of devices that can issue wakeup events include 43181834Sroberto * keyboards and mice (both PS2 and USB styles), power buttons, modems, 44181834Sroberto * "Wake-On-LAN" Ethernet links, GPIO lines, and more. Some events 45181834Sroberto * will wake the entire system from a suspend state; others may just 46181834Sroberto * wake up the device (if the system as a whole is already active). 47181834Sroberto * Some wakeup events use normal IRQ lines; other use special out 48181834Sroberto * of band signaling. 49181834Sroberto * 50181834Sroberto * It is the responsibility of device drivers to enable (or disable) 51181834Sroberto * wakeup signaling as part of changing device power states, respecting 52181834Sroberto * the policy choices provided through the driver model. 53181834Sroberto * 54181834Sroberto * Devices may not be able to generate wakeup events from all power 55181834Sroberto * states. Also, the events may be ignored in some configurations; 56181834Sroberto * for example, they might need help from other devices that aren't 57181834Sroberto * active, or which may have wakeup disabled. Some drivers rely on 58181834Sroberto * wakeup events internally (unless they are disabled), keeping 59181834Sroberto * their hardware in low power modes whenever they're unused. This 60181834Sroberto * saves runtime power, without requiring system-wide sleep states. 61181834Sroberto * 62181834Sroberto * async - Report/change current async suspend setting for the device 63181834Sroberto * 64181834Sroberto * Asynchronous suspend and resume of the device during system-wide power 65181834Sroberto * state transitions can be enabled by writing "enabled" to this file. 66181834Sroberto * Analogously, if "disabled" is written to this file, the device will be 67181834Sroberto * suspended and resumed synchronously. 68181834Sroberto * 69181834Sroberto * All devices have one of the following two values for power/async: 70181834Sroberto * 71181834Sroberto * + "enabled\n" to permit the asynchronous suspend/resume of the device; 72181834Sroberto * + "disabled\n" to forbid it; 73181834Sroberto * 74181834Sroberto * NOTE: It generally is unsafe to permit the asynchronous suspend/resume 75181834Sroberto * of a device unless it is certain that all of the PM dependencies of the 76181834Sroberto * device are known to the PM core. However, for some devices this 77181834Sroberto * attribute is set to "enabled" by bus type code or device drivers and in 78181834Sroberto * that cases it should be safe to leave the default value. 79181834Sroberto * 80181834Sroberto * autosuspend_delay_ms - Report/change a device's autosuspend_delay value 81181834Sroberto * 82200576Sroberto * Some drivers don't want to carry out a runtime suspend as soon as a 83200576Sroberto * device becomes idle; they want it always to remain idle for some period 84181834Sroberto * of time before suspending it. This period is the autosuspend_delay 85181834Sroberto * value (expressed in milliseconds) and it can be controlled by the user. 86181834Sroberto * If the value is negative then the device will never be runtime 87181834Sroberto * suspended. 88181834Sroberto * 89181834Sroberto * NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay 90181834Sroberto * value are used only if the driver calls pm_runtime_use_autosuspend(). 91181834Sroberto * 92181834Sroberto * wakeup_count - Report the number of wakeup events related to the device 93181834Sroberto */ 94181834Sroberto 95181834Srobertoconst char power_group_name[] = "power"; 96181834SrobertoEXPORT_SYMBOL_GPL(power_group_name); 97181834Sroberto 98181834Srobertostatic const char ctrl_auto[] = "auto"; 99181834Srobertostatic const char ctrl_on[] = "on"; 100181834Sroberto 101181834Srobertostatic ssize_t control_show(struct device *dev, struct device_attribute *attr, 102181834Sroberto char *buf) 103181834Sroberto{ 104181834Sroberto return sysfs_emit(buf, "%s\n", 105181834Sroberto dev->power.runtime_auto ? ctrl_auto : ctrl_on); 106181834Sroberto} 107181834Sroberto 108181834Srobertostatic ssize_t control_store(struct device * dev, struct device_attribute *attr, 109181834Sroberto const char * buf, size_t n) 110181834Sroberto{ 111181834Sroberto device_lock(dev); 112181834Sroberto if (sysfs_streq(buf, ctrl_auto)) 113181834Sroberto pm_runtime_allow(dev); 114181834Sroberto else if (sysfs_streq(buf, ctrl_on)) 115181834Sroberto pm_runtime_forbid(dev); 116181834Sroberto else 117181834Sroberto n = -EINVAL; 118181834Sroberto device_unlock(dev); 119181834Sroberto return n; 120181834Sroberto} 121181834Sroberto 122181834Srobertostatic DEVICE_ATTR_RW(control); 123181834Sroberto 124181834Srobertostatic ssize_t runtime_active_time_show(struct device *dev, 125181834Sroberto struct device_attribute *attr, 126181834Sroberto char *buf) 127181834Sroberto{ 128181834Sroberto u64 tmp = pm_runtime_active_time(dev); 129181834Sroberto 130181834Sroberto do_div(tmp, NSEC_PER_MSEC); 131181834Sroberto 132181834Sroberto return sysfs_emit(buf, "%llu\n", tmp); 133181834Sroberto} 134181834Sroberto 135181834Srobertostatic DEVICE_ATTR_RO(runtime_active_time); 136181834Sroberto 137181834Srobertostatic ssize_t runtime_suspended_time_show(struct device *dev, 138181834Sroberto struct device_attribute *attr, 139181834Sroberto char *buf) 140181834Sroberto{ 141181834Sroberto u64 tmp = pm_runtime_suspended_time(dev); 142181834Sroberto 143181834Sroberto do_div(tmp, NSEC_PER_MSEC); 144181834Sroberto 145181834Sroberto return sysfs_emit(buf, "%llu\n", tmp); 146181834Sroberto} 147181834Sroberto 148181834Srobertostatic DEVICE_ATTR_RO(runtime_suspended_time); 149181834Sroberto 150181834Srobertostatic ssize_t runtime_status_show(struct device *dev, 151181834Sroberto struct device_attribute *attr, char *buf) 152181834Sroberto{ 153181834Sroberto const char *output; 154181834Sroberto 155181834Sroberto if (dev->power.runtime_error) { 156181834Sroberto output = "error"; 157181834Sroberto } else if (dev->power.disable_depth) { 158181834Sroberto output = "unsupported"; 159181834Sroberto } else { 160181834Sroberto switch (dev->power.runtime_status) { 161181834Sroberto case RPM_SUSPENDED: 162181834Sroberto output = "suspended"; 163181834Sroberto break; 164181834Sroberto case RPM_SUSPENDING: 165181834Sroberto output = "suspending"; 166181834Sroberto break; 167181834Sroberto case RPM_RESUMING: 168181834Sroberto output = "resuming"; 169181834Sroberto break; 170181834Sroberto case RPM_ACTIVE: 171181834Sroberto output = "active"; 172181834Sroberto break; 173181834Sroberto default: 174181834Sroberto return -EIO; 175181834Sroberto } 176181834Sroberto } 177181834Sroberto return sysfs_emit(buf, "%s\n", output); 178181834Sroberto} 179181834Sroberto 180181834Srobertostatic DEVICE_ATTR_RO(runtime_status); 181181834Sroberto 182181834Srobertostatic ssize_t autosuspend_delay_ms_show(struct device *dev, 183181834Sroberto struct device_attribute *attr, 184181834Sroberto char *buf) 185181834Sroberto{ 186181834Sroberto if (!dev->power.use_autosuspend) 187181834Sroberto return -EIO; 188181834Sroberto 189181834Sroberto return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay); 190181834Sroberto} 191181834Sroberto 192181834Srobertostatic ssize_t autosuspend_delay_ms_store(struct device *dev, 193181834Sroberto struct device_attribute *attr, const char *buf, size_t n) 194181834Sroberto{ 195181834Sroberto long delay; 196181834Sroberto 197181834Sroberto if (!dev->power.use_autosuspend) 198181834Sroberto return -EIO; 199181834Sroberto 200181834Sroberto if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay) 201181834Sroberto return -EINVAL; 202181834Sroberto 203181834Sroberto device_lock(dev); 204181834Sroberto pm_runtime_set_autosuspend_delay(dev, delay); 205181834Sroberto device_unlock(dev); 206181834Sroberto return n; 207181834Sroberto} 208181834Sroberto 209181834Srobertostatic DEVICE_ATTR_RW(autosuspend_delay_ms); 210181834Sroberto 211181834Srobertostatic ssize_t pm_qos_resume_latency_us_show(struct device *dev, 212181834Sroberto struct device_attribute *attr, 213181834Sroberto char *buf) 214181834Sroberto{ 215181834Sroberto s32 value = dev_pm_qos_requested_resume_latency(dev); 216181834Sroberto 217181834Sroberto if (value == 0) 218181834Sroberto return sysfs_emit(buf, "n/a\n"); 219181834Sroberto if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) 220181834Sroberto value = 0; 221181834Sroberto 222181834Sroberto return sysfs_emit(buf, "%d\n", value); 223181834Sroberto} 224181834Sroberto 225181834Srobertostatic ssize_t pm_qos_resume_latency_us_store(struct device *dev, 226181834Sroberto struct device_attribute *attr, 227181834Sroberto const char *buf, size_t n) 228181834Sroberto{ 229181834Sroberto s32 value; 230181834Sroberto int ret; 231181834Sroberto 232181834Sroberto if (!kstrtos32(buf, 0, &value)) { 233181834Sroberto /* 234181834Sroberto * Prevent users from writing negative or "no constraint" values 235181834Sroberto * directly. 236181834Sroberto */ 237181834Sroberto if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) 238181834Sroberto return -EINVAL; 239181834Sroberto 240181834Sroberto if (value == 0) 241181834Sroberto value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT; 242181834Sroberto } else if (sysfs_streq(buf, "n/a")) { 243181834Sroberto value = 0; 244181834Sroberto } else { 245181834Sroberto return -EINVAL; 246181834Sroberto } 247181834Sroberto 248181834Sroberto ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req, 249181834Sroberto value); 250181834Sroberto return ret < 0 ? ret : n; 251181834Sroberto} 252181834Sroberto 253181834Srobertostatic DEVICE_ATTR_RW(pm_qos_resume_latency_us); 254181834Sroberto 255181834Srobertostatic ssize_t pm_qos_latency_tolerance_us_show(struct device *dev, 256181834Sroberto struct device_attribute *attr, 257181834Sroberto char *buf) 258181834Sroberto{ 259181834Sroberto s32 value = dev_pm_qos_get_user_latency_tolerance(dev); 260181834Sroberto 261181834Sroberto if (value < 0) 262181834Sroberto return sysfs_emit(buf, "%s\n", "auto"); 263181834Sroberto if (value == PM_QOS_LATENCY_ANY) 264181834Sroberto return sysfs_emit(buf, "%s\n", "any"); 265181834Sroberto 266181834Sroberto return sysfs_emit(buf, "%d\n", value); 267181834Sroberto} 268181834Sroberto 269181834Srobertostatic ssize_t pm_qos_latency_tolerance_us_store(struct device *dev, 270181834Sroberto struct device_attribute *attr, 271181834Sroberto const char *buf, size_t n) 272181834Sroberto{ 273181834Sroberto s32 value; 274181834Sroberto int ret; 275181834Sroberto 276181834Sroberto if (kstrtos32(buf, 0, &value) == 0) { 277181834Sroberto /* Users can't write negative values directly */ 278181834Sroberto if (value < 0) 279181834Sroberto return -EINVAL; 280181834Sroberto } else { 281181834Sroberto if (sysfs_streq(buf, "auto")) 282181834Sroberto value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT; 283181834Sroberto else if (sysfs_streq(buf, "any")) 284181834Sroberto value = PM_QOS_LATENCY_ANY; 285181834Sroberto else 286181834Sroberto return -EINVAL; 287181834Sroberto } 288181834Sroberto ret = dev_pm_qos_update_user_latency_tolerance(dev, value); 289200576Sroberto return ret < 0 ? ret : n; 290181834Sroberto} 291181834Sroberto 292181834Srobertostatic DEVICE_ATTR_RW(pm_qos_latency_tolerance_us); 293181834Sroberto 294181834Srobertostatic ssize_t pm_qos_no_power_off_show(struct device *dev, 295181834Sroberto struct device_attribute *attr, 296181834Sroberto char *buf) 297181834Sroberto{ 298181834Sroberto return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) 299181834Sroberto & PM_QOS_FLAG_NO_POWER_OFF)); 300181834Sroberto} 301181834Sroberto 302181834Srobertostatic ssize_t pm_qos_no_power_off_store(struct device *dev, 303181834Sroberto struct device_attribute *attr, 304181834Sroberto const char *buf, size_t n) 305181834Sroberto{ 306181834Sroberto int ret; 307181834Sroberto 308181834Sroberto if (kstrtoint(buf, 0, &ret)) 309181834Sroberto return -EINVAL; 310181834Sroberto 311181834Sroberto if (ret != 0 && ret != 1) 312181834Sroberto return -EINVAL; 313181834Sroberto 314181834Sroberto ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret); 315181834Sroberto return ret < 0 ? ret : n; 316181834Sroberto} 317181834Sroberto 318181834Srobertostatic 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