sysfs.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766
  1. /*
  2. * drivers/base/power/sysfs.c - sysfs entries for device PM
  3. */
  4. #include <linux/device.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/atomic.h>
  10. #include <linux/jiffies.h>
  11. #include "power.h"
  12. /*
  13. * control - Report/change current runtime PM setting of the device
  14. *
  15. * Runtime power management of a device can be blocked with the help of
  16. * this attribute. All devices have one of the following two values for
  17. * the power/control file:
  18. *
  19. * + "auto\n" to allow the device to be power managed at run time;
  20. * + "on\n" to prevent the device from being power managed at run time;
  21. *
  22. * The default for all devices is "auto", which means that devices may be
  23. * subject to automatic power management, depending on their drivers.
  24. * Changing this attribute to "on" prevents the driver from power managing
  25. * the device at run time. Doing that while the device is suspended causes
  26. * it to be woken up.
  27. *
  28. * wakeup - Report/change current wakeup option for device
  29. *
  30. * Some devices support "wakeup" events, which are hardware signals
  31. * used to activate devices from suspended or low power states. Such
  32. * devices have one of three values for the sysfs power/wakeup file:
  33. *
  34. * + "enabled\n" to issue the events;
  35. * + "disabled\n" not to do so; or
  36. * + "\n" for temporary or permanent inability to issue wakeup.
  37. *
  38. * (For example, unconfigured USB devices can't issue wakeups.)
  39. *
  40. * Familiar examples of devices that can issue wakeup events include
  41. * keyboards and mice (both PS2 and USB styles), power buttons, modems,
  42. * "Wake-On-LAN" Ethernet links, GPIO lines, and more. Some events
  43. * will wake the entire system from a suspend state; others may just
  44. * wake up the device (if the system as a whole is already active).
  45. * Some wakeup events use normal IRQ lines; other use special out
  46. * of band signaling.
  47. *
  48. * It is the responsibility of device drivers to enable (or disable)
  49. * wakeup signaling as part of changing device power states, respecting
  50. * the policy choices provided through the driver model.
  51. *
  52. * Devices may not be able to generate wakeup events from all power
  53. * states. Also, the events may be ignored in some configurations;
  54. * for example, they might need help from other devices that aren't
  55. * active, or which may have wakeup disabled. Some drivers rely on
  56. * wakeup events internally (unless they are disabled), keeping
  57. * their hardware in low power modes whenever they're unused. This
  58. * saves runtime power, without requiring system-wide sleep states.
  59. *
  60. * async - Report/change current async suspend setting for the device
  61. *
  62. * Asynchronous suspend and resume of the device during system-wide power
  63. * state transitions can be enabled by writing "enabled" to this file.
  64. * Analogously, if "disabled" is written to this file, the device will be
  65. * suspended and resumed synchronously.
  66. *
  67. * All devices have one of the following two values for power/async:
  68. *
  69. * + "enabled\n" to permit the asynchronous suspend/resume of the device;
  70. * + "disabled\n" to forbid it;
  71. *
  72. * NOTE: It generally is unsafe to permit the asynchronous suspend/resume
  73. * of a device unless it is certain that all of the PM dependencies of the
  74. * device are known to the PM core. However, for some devices this
  75. * attribute is set to "enabled" by bus type code or device drivers and in
  76. * that cases it should be safe to leave the default value.
  77. *
  78. * autosuspend_delay_ms - Report/change a device's autosuspend_delay value
  79. *
  80. * Some drivers don't want to carry out a runtime suspend as soon as a
  81. * device becomes idle; they want it always to remain idle for some period
  82. * of time before suspending it. This period is the autosuspend_delay
  83. * value (expressed in milliseconds) and it can be controlled by the user.
  84. * If the value is negative then the device will never be runtime
  85. * suspended.
  86. *
  87. * NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
  88. * value are used only if the driver calls pm_runtime_use_autosuspend().
  89. *
  90. * wakeup_count - Report the number of wakeup events related to the device
  91. */
  92. const char power_group_name[] = "power";
  93. EXPORT_SYMBOL_GPL(power_group_name);
  94. static const char ctrl_auto[] = "auto";
  95. static const char ctrl_on[] = "on";
  96. static ssize_t control_show(struct device *dev, struct device_attribute *attr,
  97. char *buf)
  98. {
  99. return sprintf(buf, "%s\n",
  100. dev->power.runtime_auto ? ctrl_auto : ctrl_on);
  101. }
  102. static ssize_t control_store(struct device * dev, struct device_attribute *attr,
  103. const char * buf, size_t n)
  104. {
  105. char *cp;
  106. int len = n;
  107. cp = memchr(buf, '\n', n);
  108. if (cp)
  109. len = cp - buf;
  110. device_lock(dev);
  111. if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
  112. pm_runtime_allow(dev);
  113. else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
  114. pm_runtime_forbid(dev);
  115. else
  116. n = -EINVAL;
  117. device_unlock(dev);
  118. return n;
  119. }
  120. static DEVICE_ATTR(control, 0644, control_show, control_store);
  121. static ssize_t rtpm_active_time_show(struct device *dev,
  122. struct device_attribute *attr, char *buf)
  123. {
  124. int ret;
  125. spin_lock_irq(&dev->power.lock);
  126. update_pm_runtime_accounting(dev);
  127. ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
  128. spin_unlock_irq(&dev->power.lock);
  129. return ret;
  130. }
  131. static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
  132. static ssize_t rtpm_suspended_time_show(struct device *dev,
  133. struct device_attribute *attr, char *buf)
  134. {
  135. int ret;
  136. spin_lock_irq(&dev->power.lock);
  137. update_pm_runtime_accounting(dev);
  138. ret = sprintf(buf, "%i\n",
  139. jiffies_to_msecs(dev->power.suspended_jiffies));
  140. spin_unlock_irq(&dev->power.lock);
  141. return ret;
  142. }
  143. static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
  144. static ssize_t rtpm_status_show(struct device *dev,
  145. struct device_attribute *attr, char *buf)
  146. {
  147. const char *p;
  148. if (dev->power.runtime_error) {
  149. p = "error\n";
  150. } else if (dev->power.disable_depth) {
  151. p = "unsupported\n";
  152. } else {
  153. switch (dev->power.runtime_status) {
  154. case RPM_SUSPENDED:
  155. p = "suspended\n";
  156. break;
  157. case RPM_SUSPENDING:
  158. p = "suspending\n";
  159. break;
  160. case RPM_RESUMING:
  161. p = "resuming\n";
  162. break;
  163. case RPM_ACTIVE:
  164. p = "active\n";
  165. break;
  166. default:
  167. return -EIO;
  168. }
  169. }
  170. return sprintf(buf, p);
  171. }
  172. static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
  173. static ssize_t autosuspend_delay_ms_show(struct device *dev,
  174. struct device_attribute *attr, char *buf)
  175. {
  176. if (!dev->power.use_autosuspend)
  177. return -EIO;
  178. return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
  179. }
  180. static ssize_t autosuspend_delay_ms_store(struct device *dev,
  181. struct device_attribute *attr, const char *buf, size_t n)
  182. {
  183. long delay;
  184. if (!dev->power.use_autosuspend)
  185. return -EIO;
  186. if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
  187. return -EINVAL;
  188. device_lock(dev);
  189. pm_runtime_set_autosuspend_delay(dev, delay);
  190. device_unlock(dev);
  191. return n;
  192. }
  193. static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
  194. autosuspend_delay_ms_store);
  195. static ssize_t pm_qos_resume_latency_show(struct device *dev,
  196. struct device_attribute *attr,
  197. char *buf)
  198. {
  199. return sprintf(buf, "%d\n", dev_pm_qos_requested_resume_latency(dev));
  200. }
  201. static ssize_t pm_qos_resume_latency_store(struct device *dev,
  202. struct device_attribute *attr,
  203. const char *buf, size_t n)
  204. {
  205. s32 value;
  206. int ret;
  207. if (kstrtos32(buf, 0, &value))
  208. return -EINVAL;
  209. if (value < 0)
  210. return -EINVAL;
  211. ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
  212. value);
  213. return ret < 0 ? ret : n;
  214. }
  215. static DEVICE_ATTR(pm_qos_resume_latency_us, 0644,
  216. pm_qos_resume_latency_show, pm_qos_resume_latency_store);
  217. static ssize_t pm_qos_latency_tolerance_show(struct device *dev,
  218. struct device_attribute *attr,
  219. char *buf)
  220. {
  221. s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
  222. if (value < 0)
  223. return sprintf(buf, "auto\n");
  224. else if (value == PM_QOS_LATENCY_ANY)
  225. return sprintf(buf, "any\n");
  226. return sprintf(buf, "%d\n", value);
  227. }
  228. static ssize_t pm_qos_latency_tolerance_store(struct device *dev,
  229. struct device_attribute *attr,
  230. const char *buf, size_t n)
  231. {
  232. s32 value;
  233. int ret;
  234. if (kstrtos32(buf, 0, &value)) {
  235. if (!strcmp(buf, "auto") || !strcmp(buf, "auto\n"))
  236. value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
  237. else if (!strcmp(buf, "any") || !strcmp(buf, "any\n"))
  238. value = PM_QOS_LATENCY_ANY;
  239. else
  240. return -EINVAL;
  241. }
  242. ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
  243. return ret < 0 ? ret : n;
  244. }
  245. static DEVICE_ATTR(pm_qos_latency_tolerance_us, 0644,
  246. pm_qos_latency_tolerance_show, pm_qos_latency_tolerance_store);
  247. static ssize_t pm_qos_no_power_off_show(struct device *dev,
  248. struct device_attribute *attr,
  249. char *buf)
  250. {
  251. return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
  252. & PM_QOS_FLAG_NO_POWER_OFF));
  253. }
  254. static ssize_t pm_qos_no_power_off_store(struct device *dev,
  255. struct device_attribute *attr,
  256. const char *buf, size_t n)
  257. {
  258. int ret;
  259. if (kstrtoint(buf, 0, &ret))
  260. return -EINVAL;
  261. if (ret != 0 && ret != 1)
  262. return -EINVAL;
  263. ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
  264. return ret < 0 ? ret : n;
  265. }
  266. static DEVICE_ATTR(pm_qos_no_power_off, 0644,
  267. pm_qos_no_power_off_show, pm_qos_no_power_off_store);
  268. static ssize_t pm_qos_remote_wakeup_show(struct device *dev,
  269. struct device_attribute *attr,
  270. char *buf)
  271. {
  272. return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
  273. & PM_QOS_FLAG_REMOTE_WAKEUP));
  274. }
  275. static ssize_t pm_qos_remote_wakeup_store(struct device *dev,
  276. struct device_attribute *attr,
  277. const char *buf, size_t n)
  278. {
  279. int ret;
  280. if (kstrtoint(buf, 0, &ret))
  281. return -EINVAL;
  282. if (ret != 0 && ret != 1)
  283. return -EINVAL;
  284. ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP, ret);
  285. return ret < 0 ? ret : n;
  286. }
  287. static DEVICE_ATTR(pm_qos_remote_wakeup, 0644,
  288. pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store);
  289. #ifdef CONFIG_PM_SLEEP
  290. static const char _enabled[] = "enabled";
  291. static const char _disabled[] = "disabled";
  292. static ssize_t
  293. wake_show(struct device * dev, struct device_attribute *attr, char * buf)
  294. {
  295. return sprintf(buf, "%s\n", device_can_wakeup(dev)
  296. ? (device_may_wakeup(dev) ? _enabled : _disabled)
  297. : "");
  298. }
  299. static ssize_t
  300. wake_store(struct device * dev, struct device_attribute *attr,
  301. const char * buf, size_t n)
  302. {
  303. char *cp;
  304. int len = n;
  305. if (!device_can_wakeup(dev))
  306. return -EINVAL;
  307. cp = memchr(buf, '\n', n);
  308. if (cp)
  309. len = cp - buf;
  310. if (len == sizeof _enabled - 1
  311. && strncmp(buf, _enabled, sizeof _enabled - 1) == 0)
  312. device_set_wakeup_enable(dev, 1);
  313. else if (len == sizeof _disabled - 1
  314. && strncmp(buf, _disabled, sizeof _disabled - 1) == 0)
  315. device_set_wakeup_enable(dev, 0);
  316. else
  317. return -EINVAL;
  318. return n;
  319. }
  320. static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
  321. static ssize_t wakeup_count_show(struct device *dev,
  322. struct device_attribute *attr, char *buf)
  323. {
  324. unsigned long count = 0;
  325. bool enabled = false;
  326. spin_lock_irq(&dev->power.lock);
  327. if (dev->power.wakeup) {
  328. count = dev->power.wakeup->event_count;
  329. enabled = true;
  330. }
  331. spin_unlock_irq(&dev->power.lock);
  332. return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
  333. }
  334. static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
  335. static ssize_t wakeup_active_count_show(struct device *dev,
  336. struct device_attribute *attr, char *buf)
  337. {
  338. unsigned long count = 0;
  339. bool enabled = false;
  340. spin_lock_irq(&dev->power.lock);
  341. if (dev->power.wakeup) {
  342. count = dev->power.wakeup->active_count;
  343. enabled = true;
  344. }
  345. spin_unlock_irq(&dev->power.lock);
  346. return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
  347. }
  348. static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
  349. static ssize_t wakeup_abort_count_show(struct device *dev,
  350. struct device_attribute *attr,
  351. char *buf)
  352. {
  353. unsigned long count = 0;
  354. bool enabled = false;
  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. return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
  362. }
  363. static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL);
  364. static ssize_t wakeup_expire_count_show(struct device *dev,
  365. struct device_attribute *attr,
  366. char *buf)
  367. {
  368. unsigned long count = 0;
  369. bool enabled = false;
  370. spin_lock_irq(&dev->power.lock);
  371. if (dev->power.wakeup) {
  372. count = dev->power.wakeup->expire_count;
  373. enabled = true;
  374. }
  375. spin_unlock_irq(&dev->power.lock);
  376. return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
  377. }
  378. static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL);
  379. static ssize_t wakeup_active_show(struct device *dev,
  380. struct device_attribute *attr, char *buf)
  381. {
  382. unsigned int active = 0;
  383. bool enabled = false;
  384. spin_lock_irq(&dev->power.lock);
  385. if (dev->power.wakeup) {
  386. active = dev->power.wakeup->active;
  387. enabled = true;
  388. }
  389. spin_unlock_irq(&dev->power.lock);
  390. return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
  391. }
  392. static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
  393. static ssize_t wakeup_total_time_show(struct device *dev,
  394. struct device_attribute *attr, char *buf)
  395. {
  396. s64 msec = 0;
  397. bool enabled = false;
  398. spin_lock_irq(&dev->power.lock);
  399. if (dev->power.wakeup) {
  400. msec = ktime_to_ms(dev->power.wakeup->total_time);
  401. enabled = true;
  402. }
  403. spin_unlock_irq(&dev->power.lock);
  404. return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
  405. }
  406. static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
  407. static ssize_t wakeup_max_time_show(struct device *dev,
  408. struct device_attribute *attr, char *buf)
  409. {
  410. s64 msec = 0;
  411. bool enabled = false;
  412. spin_lock_irq(&dev->power.lock);
  413. if (dev->power.wakeup) {
  414. msec = ktime_to_ms(dev->power.wakeup->max_time);
  415. enabled = true;
  416. }
  417. spin_unlock_irq(&dev->power.lock);
  418. return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
  419. }
  420. static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
  421. static ssize_t wakeup_last_time_show(struct device *dev,
  422. struct device_attribute *attr, char *buf)
  423. {
  424. s64 msec = 0;
  425. bool enabled = false;
  426. spin_lock_irq(&dev->power.lock);
  427. if (dev->power.wakeup) {
  428. msec = ktime_to_ms(dev->power.wakeup->last_time);
  429. enabled = true;
  430. }
  431. spin_unlock_irq(&dev->power.lock);
  432. return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
  433. }
  434. static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
  435. #ifdef CONFIG_PM_AUTOSLEEP
  436. static ssize_t wakeup_prevent_sleep_time_show(struct device *dev,
  437. struct device_attribute *attr,
  438. char *buf)
  439. {
  440. s64 msec = 0;
  441. bool enabled = false;
  442. spin_lock_irq(&dev->power.lock);
  443. if (dev->power.wakeup) {
  444. msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
  445. enabled = true;
  446. }
  447. spin_unlock_irq(&dev->power.lock);
  448. return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
  449. }
  450. static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444,
  451. wakeup_prevent_sleep_time_show, NULL);
  452. #endif /* CONFIG_PM_AUTOSLEEP */
  453. #endif /* CONFIG_PM_SLEEP */
  454. #ifdef CONFIG_PM_ADVANCED_DEBUG
  455. static ssize_t rtpm_usagecount_show(struct device *dev,
  456. struct device_attribute *attr, char *buf)
  457. {
  458. return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
  459. }
  460. static ssize_t rtpm_children_show(struct device *dev,
  461. struct device_attribute *attr, char *buf)
  462. {
  463. return sprintf(buf, "%d\n", dev->power.ignore_children ?
  464. 0 : atomic_read(&dev->power.child_count));
  465. }
  466. static ssize_t rtpm_enabled_show(struct device *dev,
  467. struct device_attribute *attr, char *buf)
  468. {
  469. if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
  470. return sprintf(buf, "disabled & forbidden\n");
  471. else if (dev->power.disable_depth)
  472. return sprintf(buf, "disabled\n");
  473. else if (dev->power.runtime_auto == false)
  474. return sprintf(buf, "forbidden\n");
  475. return sprintf(buf, "enabled\n");
  476. }
  477. static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
  478. static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
  479. static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
  480. #ifdef CONFIG_PM_SLEEP
  481. static ssize_t async_show(struct device *dev, struct device_attribute *attr,
  482. char *buf)
  483. {
  484. return sprintf(buf, "%s\n",
  485. device_async_suspend_enabled(dev) ?
  486. _enabled : _disabled);
  487. }
  488. static ssize_t async_store(struct device *dev, struct device_attribute *attr,
  489. const char *buf, size_t n)
  490. {
  491. char *cp;
  492. int len = n;
  493. cp = memchr(buf, '\n', n);
  494. if (cp)
  495. len = cp - buf;
  496. if (len == sizeof _enabled - 1 && strncmp(buf, _enabled, len) == 0)
  497. device_enable_async_suspend(dev);
  498. else if (len == sizeof _disabled - 1 &&
  499. strncmp(buf, _disabled, len) == 0)
  500. device_disable_async_suspend(dev);
  501. else
  502. return -EINVAL;
  503. return n;
  504. }
  505. static DEVICE_ATTR(async, 0644, async_show, async_store);
  506. #endif /* CONFIG_PM_SLEEP */
  507. #endif /* CONFIG_PM_ADVANCED_DEBUG */
  508. static struct attribute *power_attrs[] = {
  509. #ifdef CONFIG_PM_ADVANCED_DEBUG
  510. #ifdef CONFIG_PM_SLEEP
  511. &dev_attr_async.attr,
  512. #endif
  513. &dev_attr_runtime_status.attr,
  514. &dev_attr_runtime_usage.attr,
  515. &dev_attr_runtime_active_kids.attr,
  516. &dev_attr_runtime_enabled.attr,
  517. #endif /* CONFIG_PM_ADVANCED_DEBUG */
  518. NULL,
  519. };
  520. static struct attribute_group pm_attr_group = {
  521. .name = power_group_name,
  522. .attrs = power_attrs,
  523. };
  524. static struct attribute *wakeup_attrs[] = {
  525. #ifdef CONFIG_PM_SLEEP
  526. &dev_attr_wakeup.attr,
  527. &dev_attr_wakeup_count.attr,
  528. &dev_attr_wakeup_active_count.attr,
  529. &dev_attr_wakeup_abort_count.attr,
  530. &dev_attr_wakeup_expire_count.attr,
  531. &dev_attr_wakeup_active.attr,
  532. &dev_attr_wakeup_total_time_ms.attr,
  533. &dev_attr_wakeup_max_time_ms.attr,
  534. &dev_attr_wakeup_last_time_ms.attr,
  535. #ifdef CONFIG_PM_AUTOSLEEP
  536. &dev_attr_wakeup_prevent_sleep_time_ms.attr,
  537. #endif
  538. #endif
  539. NULL,
  540. };
  541. static struct attribute_group pm_wakeup_attr_group = {
  542. .name = power_group_name,
  543. .attrs = wakeup_attrs,
  544. };
  545. static struct attribute *runtime_attrs[] = {
  546. #ifndef CONFIG_PM_ADVANCED_DEBUG
  547. &dev_attr_runtime_status.attr,
  548. #endif
  549. &dev_attr_control.attr,
  550. &dev_attr_runtime_suspended_time.attr,
  551. &dev_attr_runtime_active_time.attr,
  552. &dev_attr_autosuspend_delay_ms.attr,
  553. NULL,
  554. };
  555. static struct attribute_group pm_runtime_attr_group = {
  556. .name = power_group_name,
  557. .attrs = runtime_attrs,
  558. };
  559. static struct attribute *pm_qos_resume_latency_attrs[] = {
  560. &dev_attr_pm_qos_resume_latency_us.attr,
  561. NULL,
  562. };
  563. static struct attribute_group pm_qos_resume_latency_attr_group = {
  564. .name = power_group_name,
  565. .attrs = pm_qos_resume_latency_attrs,
  566. };
  567. static struct attribute *pm_qos_latency_tolerance_attrs[] = {
  568. &dev_attr_pm_qos_latency_tolerance_us.attr,
  569. NULL,
  570. };
  571. static struct attribute_group pm_qos_latency_tolerance_attr_group = {
  572. .name = power_group_name,
  573. .attrs = pm_qos_latency_tolerance_attrs,
  574. };
  575. static struct attribute *pm_qos_flags_attrs[] = {
  576. &dev_attr_pm_qos_no_power_off.attr,
  577. &dev_attr_pm_qos_remote_wakeup.attr,
  578. NULL,
  579. };
  580. static struct attribute_group pm_qos_flags_attr_group = {
  581. .name = power_group_name,
  582. .attrs = pm_qos_flags_attrs,
  583. };
  584. int dpm_sysfs_add(struct device *dev)
  585. {
  586. int rc;
  587. rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
  588. if (rc)
  589. return rc;
  590. if (pm_runtime_callbacks_present(dev)) {
  591. rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
  592. if (rc)
  593. goto err_out;
  594. }
  595. if (device_can_wakeup(dev)) {
  596. rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
  597. if (rc)
  598. goto err_runtime;
  599. }
  600. if (dev->power.set_latency_tolerance) {
  601. rc = sysfs_merge_group(&dev->kobj,
  602. &pm_qos_latency_tolerance_attr_group);
  603. if (rc)
  604. goto err_wakeup;
  605. }
  606. return 0;
  607. err_wakeup:
  608. sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
  609. err_runtime:
  610. sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
  611. err_out:
  612. sysfs_remove_group(&dev->kobj, &pm_attr_group);
  613. return rc;
  614. }
  615. int wakeup_sysfs_add(struct device *dev)
  616. {
  617. return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
  618. }
  619. void wakeup_sysfs_remove(struct device *dev)
  620. {
  621. sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
  622. }
  623. int pm_qos_sysfs_add_resume_latency(struct device *dev)
  624. {
  625. return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
  626. }
  627. void pm_qos_sysfs_remove_resume_latency(struct device *dev)
  628. {
  629. sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
  630. }
  631. int pm_qos_sysfs_add_flags(struct device *dev)
  632. {
  633. return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
  634. }
  635. void pm_qos_sysfs_remove_flags(struct device *dev)
  636. {
  637. sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
  638. }
  639. int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
  640. {
  641. return sysfs_merge_group(&dev->kobj,
  642. &pm_qos_latency_tolerance_attr_group);
  643. }
  644. void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
  645. {
  646. sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
  647. }
  648. void rpm_sysfs_remove(struct device *dev)
  649. {
  650. sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
  651. }
  652. void dpm_sysfs_remove(struct device *dev)
  653. {
  654. sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
  655. dev_pm_qos_constraints_destroy(dev);
  656. rpm_sysfs_remove(dev);
  657. sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
  658. sysfs_remove_group(&dev->kobj, &pm_attr_group);
  659. }