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
 95static const char enabled[] = "enabled";
 96static const char disabled[] = "disabled";
 97
 98const char power_group_name[] = "power";
 99EXPORT_SYMBOL_GPL(power_group_name);
100
101#ifdef CONFIG_PM_RUNTIME
102static const char ctrl_auto[] = "auto";
103static const char ctrl_on[] = "on";
104
105static 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
112static 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
132static DEVICE_ATTR(control, 0644, control_show, control_store);
133
134static 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
145static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
146
147static 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
159static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
160
161static 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
191static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
192
193static 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
201static 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
218static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
219		autosuspend_delay_ms_store);
220
221static 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
228static 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
246static DEVICE_ATTR(pm_qos_resume_latency_us, 0644,
247		   pm_qos_resume_latency_show, pm_qos_resume_latency_store);
248
249static 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
263static 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
280static DEVICE_ATTR(pm_qos_latency_tolerance_us, 0644,
281		   pm_qos_latency_tolerance_show, pm_qos_latency_tolerance_store);
282
283static 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
291static 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
307static DEVICE_ATTR(pm_qos_no_power_off, 0644,
308		   pm_qos_no_power_off_show, pm_qos_no_power_off_store);
309
310static 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
318static 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
334static 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
339static ssize_t
340wake_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
347static ssize_t
348wake_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
371static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
372
373static 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
388static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
389
390static 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
405static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
406
407static 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
423static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL);
424
425static 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
441static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL);
442
443static 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
458static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
459
460static 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
475static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
476
477static 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
492static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
493
494static 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
509static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
510
511#ifdef CONFIG_PM_AUTOSLEEP
512static 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
528static 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
536static 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
542static 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
549static 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
561static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
562static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
563static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
564
565#endif
566
567#ifdef CONFIG_PM_SLEEP
568
569static 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
576static 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
594static DEVICE_ATTR(async, 0644, async_show, async_store);
595
596#endif
597#endif /* CONFIG_PM_ADVANCED_DEBUG */
598
599static 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};
613static struct attribute_group pm_attr_group = {
614	.name	= power_group_name,
615	.attrs	= power_attrs,
616};
617
618static 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};
635static struct attribute_group pm_wakeup_attr_group = {
636	.name	= power_group_name,
637	.attrs	= wakeup_attrs,
638};
639
640static 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};
652static struct attribute_group pm_runtime_attr_group = {
653	.name	= power_group_name,
654	.attrs	= runtime_attrs,
655};
656
657static 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};
663static struct attribute_group pm_qos_resume_latency_attr_group = {
664	.name	= power_group_name,
665	.attrs	= pm_qos_resume_latency_attrs,
666};
667
668static 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};
674static struct attribute_group pm_qos_latency_tolerance_attr_group = {
675	.name	= power_group_name,
676	.attrs	= pm_qos_latency_tolerance_attrs,
677};
678
679static 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};
686static struct attribute_group pm_qos_flags_attr_group = {
687	.name	= power_group_name,
688	.attrs	= pm_qos_flags_attrs,
689};
690
691int 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
726int wakeup_sysfs_add(struct device *dev)
727{
728	return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
729}
730
731void wakeup_sysfs_remove(struct device *dev)
732{
733	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
734}
735
736int 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
741void pm_qos_sysfs_remove_resume_latency(struct device *dev)
742{
743	sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
744}
745
746int pm_qos_sysfs_add_flags(struct device *dev)
747{
748	return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
749}
750
751void pm_qos_sysfs_remove_flags(struct device *dev)
752{
753	sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
754}
755
756void rpm_sysfs_remove(struct device *dev)
757{
758	sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
759}
760
761void 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}