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