1// SPDX-License-Identifier: GPL-2.0
  2/* sysfs entries for device PM */
 
 
  3#include <linux/device.h>
  4#include <linux/kobject.h>
  5#include <linux/string.h>
  6#include <linux/export.h>
  7#include <linux/pm_qos.h>
  8#include <linux/pm_runtime.h>
  9#include <linux/pm_wakeup.h>
 10#include <linux/atomic.h>
 11#include <linux/jiffies.h>
 12#include "power.h"
 13
 14/*
 15 *	control - Report/change current runtime PM setting of the device
 16 *
 17 *	Runtime power management of a device can be blocked with the help of
 18 *	this attribute.  All devices have one of the following two values for
 19 *	the power/control file:
 20 *
 21 *	 + "auto\n" to allow the device to be power managed at run time;
 22 *	 + "on\n" to prevent the device from being power managed at run time;
 23 *
 24 *	The default for all devices is "auto", which means that devices may be
 25 *	subject to automatic power management, depending on their drivers.
 26 *	Changing this attribute to "on" prevents the driver from power managing
 27 *	the device at run time.  Doing that while the device is suspended causes
 28 *	it to be woken up.
 29 *
 30 *	wakeup - Report/change current wakeup option for device
 31 *
 32 *	Some devices support "wakeup" events, which are hardware signals
 33 *	used to activate devices from suspended or low power states.  Such
 34 *	devices have one of three values for the sysfs power/wakeup file:
 35 *
 36 *	 + "enabled\n" to issue the events;
 37 *	 + "disabled\n" not to do so; or
 38 *	 + "\n" for temporary or permanent inability to issue wakeup.
 39 *
 40 *	(For example, unconfigured USB devices can't issue wakeups.)
 41 *
 42 *	Familiar examples of devices that can issue wakeup events include
 43 *	keyboards and mice (both PS2 and USB styles), power buttons, modems,
 44 *	"Wake-On-LAN" Ethernet links, GPIO lines, and more.  Some events
 45 *	will wake the entire system from a suspend state; others may just
 46 *	wake up the device (if the system as a whole is already active).
 47 *	Some wakeup events use normal IRQ lines; other use special out
 48 *	of band signaling.
 49 *
 50 *	It is the responsibility of device drivers to enable (or disable)
 51 *	wakeup signaling as part of changing device power states, respecting
 52 *	the policy choices provided through the driver model.
 53 *
 54 *	Devices may not be able to generate wakeup events from all power
 55 *	states.  Also, the events may be ignored in some configurations;
 56 *	for example, they might need help from other devices that aren't
 57 *	active, or which may have wakeup disabled.  Some drivers rely on
 58 *	wakeup events internally (unless they are disabled), keeping
 59 *	their hardware in low power modes whenever they're unused.  This
 60 *	saves runtime power, without requiring system-wide sleep states.
 61 *
 62 *	async - Report/change current async suspend setting for the device
 63 *
 64 *	Asynchronous suspend and resume of the device during system-wide power
 65 *	state transitions can be enabled by writing "enabled" to this file.
 66 *	Analogously, if "disabled" is written to this file, the device will be
 67 *	suspended and resumed synchronously.
 68 *
 69 *	All devices have one of the following two values for power/async:
 70 *
 71 *	 + "enabled\n" to permit the asynchronous suspend/resume of the device;
 72 *	 + "disabled\n" to forbid it;
 73 *
 74 *	NOTE: It generally is unsafe to permit the asynchronous suspend/resume
 75 *	of a device unless it is certain that all of the PM dependencies of the
 76 *	device are known to the PM core.  However, for some devices this
 77 *	attribute is set to "enabled" by bus type code or device drivers and in
 78 *	that cases it should be safe to leave the default value.
 79 *
 80 *	autosuspend_delay_ms - Report/change a device's autosuspend_delay value
 81 *
 82 *	Some drivers don't want to carry out a runtime suspend as soon as a
 83 *	device becomes idle; they want it always to remain idle for some period
 84 *	of time before suspending it.  This period is the autosuspend_delay
 85 *	value (expressed in milliseconds) and it can be controlled by the user.
 86 *	If the value is negative then the device will never be runtime
 87 *	suspended.
 88 *
 89 *	NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
 90 *	value are used only if the driver calls pm_runtime_use_autosuspend().
 91 *
 92 *	wakeup_count - Report the number of wakeup events related to the device
 93 */
 94
 
 
 
 95const char power_group_name[] = "power";
 96EXPORT_SYMBOL_GPL(power_group_name);
 97
 
 98static const char ctrl_auto[] = "auto";
 99static const char ctrl_on[] = "on";
100
101static ssize_t control_show(struct device *dev, struct device_attribute *attr,
102			    char *buf)
103{
104	return sysfs_emit(buf, "%s\n",
105			  dev->power.runtime_auto ? ctrl_auto : ctrl_on);
106}
107
108static ssize_t control_store(struct device * dev, struct device_attribute *attr,
109			     const char * buf, size_t n)
110{
 
 
 
 
 
 
111	device_lock(dev);
112	if (sysfs_streq(buf, ctrl_auto))
113		pm_runtime_allow(dev);
114	else if (sysfs_streq(buf, ctrl_on))
115		pm_runtime_forbid(dev);
116	else
117		n = -EINVAL;
118	device_unlock(dev);
119	return n;
120}
121
122static DEVICE_ATTR_RW(control);
123
124static ssize_t runtime_active_time_show(struct device *dev,
125					struct device_attribute *attr,
126					char *buf)
127{
128	u64 tmp = pm_runtime_active_time(dev);
129
130	do_div(tmp, NSEC_PER_MSEC);
131
132	return sysfs_emit(buf, "%llu\n", tmp);
 
133}
134
135static DEVICE_ATTR_RO(runtime_active_time);
136
137static ssize_t runtime_suspended_time_show(struct device *dev,
138					   struct device_attribute *attr,
139					   char *buf)
140{
141	u64 tmp = pm_runtime_suspended_time(dev);
142
143	do_div(tmp, NSEC_PER_MSEC);
144
145	return sysfs_emit(buf, "%llu\n", tmp);
 
 
146}
147
148static DEVICE_ATTR_RO(runtime_suspended_time);
149
150static ssize_t runtime_status_show(struct device *dev,
151				   struct device_attribute *attr, char *buf)
152{
153	const char *output;
154
155	if (dev->power.runtime_error) {
156		output = "error";
157	} else if (dev->power.disable_depth) {
158		output = "unsupported";
159	} else {
160		switch (dev->power.runtime_status) {
161		case RPM_SUSPENDED:
162			output = "suspended";
163			break;
164		case RPM_SUSPENDING:
165			output = "suspending";
166			break;
167		case RPM_RESUMING:
168			output = "resuming";
169			break;
170		case RPM_ACTIVE:
171			output = "active";
172			break;
173		default:
174			return -EIO;
175		}
176	}
177	return sysfs_emit(buf, "%s\n", output);
178}
179
180static DEVICE_ATTR_RO(runtime_status);
181
182static ssize_t autosuspend_delay_ms_show(struct device *dev,
183					 struct device_attribute *attr,
184					 char *buf)
185{
186	if (!dev->power.use_autosuspend)
187		return -EIO;
188
189	return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
190}
191
192static ssize_t autosuspend_delay_ms_store(struct device *dev,
193		struct device_attribute *attr, const char *buf, size_t n)
194{
195	long delay;
196
197	if (!dev->power.use_autosuspend)
198		return -EIO;
199
200	if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
201		return -EINVAL;
202
203	device_lock(dev);
204	pm_runtime_set_autosuspend_delay(dev, delay);
205	device_unlock(dev);
206	return n;
207}
208
209static DEVICE_ATTR_RW(autosuspend_delay_ms);
 
210
211static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
212					     struct device_attribute *attr,
213					     char *buf)
214{
215	s32 value = dev_pm_qos_requested_resume_latency(dev);
216
217	if (value == 0)
218		return sysfs_emit(buf, "n/a\n");
219	if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
220		value = 0;
221
222	return sysfs_emit(buf, "%d\n", value);
223}
224
225static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
226					      struct device_attribute *attr,
227					      const char *buf, size_t n)
228{
229	s32 value;
230	int ret;
231
232	if (!kstrtos32(buf, 0, &value)) {
233		/*
234		 * Prevent users from writing negative or "no constraint" values
235		 * directly.
236		 */
237		if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
238			return -EINVAL;
239
240		if (value == 0)
241			value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
242	} else if (sysfs_streq(buf, "n/a")) {
243		value = 0;
244	} else {
245		return -EINVAL;
246	}
247
248	ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
249					value);
250	return ret < 0 ? ret : n;
251}
252
253static DEVICE_ATTR_RW(pm_qos_resume_latency_us);
254
255static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
256						struct device_attribute *attr,
257						char *buf)
258{
259	s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
260
261	if (value < 0)
262		return sysfs_emit(buf, "%s\n", "auto");
263	if (value == PM_QOS_LATENCY_ANY)
264		return sysfs_emit(buf, "%s\n", "any");
265
266	return sysfs_emit(buf, "%d\n", value);
267}
268
269static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
270						 struct device_attribute *attr,
271						 const char *buf, size_t n)
272{
273	s32 value;
274	int ret;
275
276	if (kstrtos32(buf, 0, &value) == 0) {
277		/* Users can't write negative values directly */
278		if (value < 0)
279			return -EINVAL;
280	} else {
281		if (sysfs_streq(buf, "auto"))
282			value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
283		else if (sysfs_streq(buf, "any"))
284			value = PM_QOS_LATENCY_ANY;
285		else
286			return -EINVAL;
287	}
288	ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
289	return ret < 0 ? ret : n;
290}
291
292static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us);
293
294static ssize_t pm_qos_no_power_off_show(struct device *dev,
295					struct device_attribute *attr,
296					char *buf)
297{
298	return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
299					  & PM_QOS_FLAG_NO_POWER_OFF));
300}
301
302static ssize_t pm_qos_no_power_off_store(struct device *dev,
303					 struct device_attribute *attr,
304					 const char *buf, size_t n)
305{
306	int ret;
307
308	if (kstrtoint(buf, 0, &ret))
309		return -EINVAL;
310
311	if (ret != 0 && ret != 1)
312		return -EINVAL;
313
314	ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
315	return ret < 0 ? ret : n;
316}
317
318static DEVICE_ATTR_RW(pm_qos_no_power_off);
 
 
319
320#ifdef CONFIG_PM_SLEEP
321static const char _enabled[] = "enabled";
322static const char _disabled[] = "disabled";
323
324static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
325			   char *buf)
326{
327	return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
328			  ? (device_may_wakeup(dev) ? _enabled : _disabled)
329			  : "");
330}
331
332static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
333			    const char *buf, size_t n)
 
334{
 
 
 
335	if (!device_can_wakeup(dev))
336		return -EINVAL;
337
338	if (sysfs_streq(buf, _enabled))
 
 
 
 
339		device_set_wakeup_enable(dev, 1);
340	else if (sysfs_streq(buf, _disabled))
 
341		device_set_wakeup_enable(dev, 0);
342	else
343		return -EINVAL;
344	return n;
345}
346
347static DEVICE_ATTR_RW(wakeup);
348
349static ssize_t wakeup_count_show(struct device *dev,
350				 struct device_attribute *attr, char *buf)
351{
352	unsigned long count;
353	bool enabled = false;
354
355	spin_lock_irq(&dev->power.lock);
356	if (dev->power.wakeup) {
357		count = dev->power.wakeup->wakeup_count;
358		enabled = true;
359	}
360	spin_unlock_irq(&dev->power.lock);
361
362	if (!enabled)
363		return sysfs_emit(buf, "\n");
364	return sysfs_emit(buf, "%lu\n", count);
365}
366
367static DEVICE_ATTR_RO(wakeup_count);
368
369static ssize_t wakeup_active_count_show(struct device *dev,
370					struct device_attribute *attr,
371					char *buf)
372{
373	unsigned long count;
374	bool enabled = false;
375
376	spin_lock_irq(&dev->power.lock);
377	if (dev->power.wakeup) {
378		count = dev->power.wakeup->active_count;
379		enabled = true;
380	}
381	spin_unlock_irq(&dev->power.lock);
382
383	if (!enabled)
384		return sysfs_emit(buf, "\n");
385	return sysfs_emit(buf, "%lu\n", count);
386}
387
388static DEVICE_ATTR_RO(wakeup_active_count);
389
390static ssize_t wakeup_abort_count_show(struct device *dev,
391				       struct device_attribute *attr,
392				       char *buf)
393{
394	unsigned long count;
395	bool enabled = false;
396
397	spin_lock_irq(&dev->power.lock);
398	if (dev->power.wakeup) {
399		count = dev->power.wakeup->wakeup_count;
400		enabled = true;
401	}
402	spin_unlock_irq(&dev->power.lock);
403
404	if (!enabled)
405		return sysfs_emit(buf, "\n");
406	return sysfs_emit(buf, "%lu\n", count);
407}
408
409static DEVICE_ATTR_RO(wakeup_abort_count);
410
411static ssize_t wakeup_expire_count_show(struct device *dev,
412					struct device_attribute *attr,
413					char *buf)
414{
415	unsigned long count;
416	bool enabled = false;
417
418	spin_lock_irq(&dev->power.lock);
419	if (dev->power.wakeup) {
420		count = dev->power.wakeup->expire_count;
421		enabled = true;
422	}
423	spin_unlock_irq(&dev->power.lock);
424
425	if (!enabled)
426		return sysfs_emit(buf, "\n");
427	return sysfs_emit(buf, "%lu\n", count);
428}
429
430static DEVICE_ATTR_RO(wakeup_expire_count);
431
432static ssize_t wakeup_active_show(struct device *dev,
433				  struct device_attribute *attr, char *buf)
434{
435	unsigned int active;
436	bool enabled = false;
437
438	spin_lock_irq(&dev->power.lock);
439	if (dev->power.wakeup) {
440		active = dev->power.wakeup->active;
441		enabled = true;
442	}
443	spin_unlock_irq(&dev->power.lock);
444
445	if (!enabled)
446		return sysfs_emit(buf, "\n");
447	return sysfs_emit(buf, "%u\n", active);
448}
449
450static DEVICE_ATTR_RO(wakeup_active);
451
452static ssize_t wakeup_total_time_ms_show(struct device *dev,
453					 struct device_attribute *attr,
454					 char *buf)
455{
456	s64 msec;
457	bool enabled = false;
458
459	spin_lock_irq(&dev->power.lock);
460	if (dev->power.wakeup) {
461		msec = ktime_to_ms(dev->power.wakeup->total_time);
462		enabled = true;
463	}
464	spin_unlock_irq(&dev->power.lock);
465
466	if (!enabled)
467		return sysfs_emit(buf, "\n");
468	return sysfs_emit(buf, "%lld\n", msec);
469}
470
471static DEVICE_ATTR_RO(wakeup_total_time_ms);
472
473static ssize_t wakeup_max_time_ms_show(struct device *dev,
474				       struct device_attribute *attr, char *buf)
475{
476	s64 msec;
477	bool enabled = false;
478
479	spin_lock_irq(&dev->power.lock);
480	if (dev->power.wakeup) {
481		msec = ktime_to_ms(dev->power.wakeup->max_time);
482		enabled = true;
483	}
484	spin_unlock_irq(&dev->power.lock);
485
486	if (!enabled)
487		return sysfs_emit(buf, "\n");
488	return sysfs_emit(buf, "%lld\n", msec);
489}
490
491static DEVICE_ATTR_RO(wakeup_max_time_ms);
492
493static ssize_t wakeup_last_time_ms_show(struct device *dev,
494					struct device_attribute *attr,
495					char *buf)
496{
497	s64 msec;
498	bool enabled = false;
499
500	spin_lock_irq(&dev->power.lock);
501	if (dev->power.wakeup) {
502		msec = ktime_to_ms(dev->power.wakeup->last_time);
503		enabled = true;
504	}
505	spin_unlock_irq(&dev->power.lock);
506
507	if (!enabled)
508		return sysfs_emit(buf, "\n");
509	return sysfs_emit(buf, "%lld\n", msec);
510}
511
512static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
513						kgid_t kgid)
514{
515	if (dev->power.wakeup && dev->power.wakeup->dev)
516		return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
517	return 0;
518}
519
520static DEVICE_ATTR_RO(wakeup_last_time_ms);
521
522#ifdef CONFIG_PM_AUTOSLEEP
523static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
524						 struct device_attribute *attr,
525						 char *buf)
526{
527	s64 msec;
528	bool enabled = false;
529
530	spin_lock_irq(&dev->power.lock);
531	if (dev->power.wakeup) {
532		msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
533		enabled = true;
534	}
535	spin_unlock_irq(&dev->power.lock);
536
537	if (!enabled)
538		return sysfs_emit(buf, "\n");
539	return sysfs_emit(buf, "%lld\n", msec);
540}
541
542static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
 
543#endif /* CONFIG_PM_AUTOSLEEP */
544#else /* CONFIG_PM_SLEEP */
545static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
546						kgid_t kgid)
547{
548	return 0;
549}
550#endif
551
552#ifdef CONFIG_PM_ADVANCED_DEBUG
553static ssize_t runtime_usage_show(struct device *dev,
554				  struct device_attribute *attr, char *buf)
 
 
555{
556	return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
557}
558static DEVICE_ATTR_RO(runtime_usage);
559
560static ssize_t runtime_active_kids_show(struct device *dev,
561					struct device_attribute *attr,
562					char *buf)
563{
564	return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
565			  0 : atomic_read(&dev->power.child_count));
566}
567static DEVICE_ATTR_RO(runtime_active_kids);
568
569static ssize_t runtime_enabled_show(struct device *dev,
570				    struct device_attribute *attr, char *buf)
571{
572	const char *output;
573
574	if (dev->power.disable_depth && !dev->power.runtime_auto)
575		output = "disabled & forbidden";
576	else if (dev->power.disable_depth)
577		output = "disabled";
578	else if (!dev->power.runtime_auto)
579		output = "forbidden";
580	else
581		output = "enabled";
582
583	return sysfs_emit(buf, "%s\n", output);
584}
585static DEVICE_ATTR_RO(runtime_enabled);
586
587#ifdef CONFIG_PM_SLEEP
 
 
 
 
 
588static ssize_t async_show(struct device *dev, struct device_attribute *attr,
589			  char *buf)
590{
591	return sysfs_emit(buf, "%s\n",
592			  device_async_suspend_enabled(dev) ?
593			  _enabled : _disabled);
594}
595
596static ssize_t async_store(struct device *dev, struct device_attribute *attr,
597			   const char *buf, size_t n)
598{
599	if (sysfs_streq(buf, _enabled))
 
 
 
 
 
 
600		device_enable_async_suspend(dev);
601	else if (sysfs_streq(buf, _disabled))
602		device_disable_async_suspend(dev);
603	else
604		return -EINVAL;
605	return n;
606}
607
608static DEVICE_ATTR_RW(async);
609
610#endif /* CONFIG_PM_SLEEP */
611#endif /* CONFIG_PM_ADVANCED_DEBUG */
612
613static struct attribute *power_attrs[] = {
614#ifdef CONFIG_PM_ADVANCED_DEBUG
615#ifdef CONFIG_PM_SLEEP
616	&dev_attr_async.attr,
617#endif
 
618	&dev_attr_runtime_status.attr,
619	&dev_attr_runtime_usage.attr,
620	&dev_attr_runtime_active_kids.attr,
621	&dev_attr_runtime_enabled.attr,
 
622#endif /* CONFIG_PM_ADVANCED_DEBUG */
623	NULL,
624};
625static const struct attribute_group pm_attr_group = {
626	.name	= power_group_name,
627	.attrs	= power_attrs,
628};
629
630static struct attribute *wakeup_attrs[] = {
631#ifdef CONFIG_PM_SLEEP
632	&dev_attr_wakeup.attr,
633	&dev_attr_wakeup_count.attr,
634	&dev_attr_wakeup_active_count.attr,
635	&dev_attr_wakeup_abort_count.attr,
636	&dev_attr_wakeup_expire_count.attr,
637	&dev_attr_wakeup_active.attr,
638	&dev_attr_wakeup_total_time_ms.attr,
639	&dev_attr_wakeup_max_time_ms.attr,
640	&dev_attr_wakeup_last_time_ms.attr,
641#ifdef CONFIG_PM_AUTOSLEEP
642	&dev_attr_wakeup_prevent_sleep_time_ms.attr,
643#endif
644#endif
645	NULL,
646};
647static const struct attribute_group pm_wakeup_attr_group = {
648	.name	= power_group_name,
649	.attrs	= wakeup_attrs,
650};
651
652static struct attribute *runtime_attrs[] = {
 
653#ifndef CONFIG_PM_ADVANCED_DEBUG
654	&dev_attr_runtime_status.attr,
655#endif
656	&dev_attr_control.attr,
657	&dev_attr_runtime_suspended_time.attr,
658	&dev_attr_runtime_active_time.attr,
659	&dev_attr_autosuspend_delay_ms.attr,
 
660	NULL,
661};
662static const struct attribute_group pm_runtime_attr_group = {
663	.name	= power_group_name,
664	.attrs	= runtime_attrs,
665};
666
667static struct attribute *pm_qos_resume_latency_attrs[] = {
 
668	&dev_attr_pm_qos_resume_latency_us.attr,
 
669	NULL,
670};
671static const struct attribute_group pm_qos_resume_latency_attr_group = {
672	.name	= power_group_name,
673	.attrs	= pm_qos_resume_latency_attrs,
674};
675
676static struct attribute *pm_qos_latency_tolerance_attrs[] = {
677	&dev_attr_pm_qos_latency_tolerance_us.attr,
678	NULL,
679};
680static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
681	.name	= power_group_name,
682	.attrs	= pm_qos_latency_tolerance_attrs,
683};
684
685static struct attribute *pm_qos_flags_attrs[] = {
686	&dev_attr_pm_qos_no_power_off.attr,
687	NULL,
688};
689static const struct attribute_group pm_qos_flags_attr_group = {
690	.name	= power_group_name,
691	.attrs	= pm_qos_flags_attrs,
692};
693
694int dpm_sysfs_add(struct device *dev)
695{
696	int rc;
697
698	/* No need to create PM sysfs if explicitly disabled. */
699	if (device_pm_not_required(dev))
700		return 0;
701
702	rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
703	if (rc)
704		return rc;
705
706	if (!pm_runtime_has_no_callbacks(dev)) {
707		rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
708		if (rc)
709			goto err_out;
710	}
 
711	if (device_can_wakeup(dev)) {
712		rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
713		if (rc)
714			goto err_runtime;
715	}
716	if (dev->power.set_latency_tolerance) {
717		rc = sysfs_merge_group(&dev->kobj,
718				       &pm_qos_latency_tolerance_attr_group);
719		if (rc)
720			goto err_wakeup;
721	}
722	rc = pm_wakeup_source_sysfs_add(dev);
723	if (rc)
724		goto err_latency;
725	return 0;
726
727 err_latency:
728	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
729 err_wakeup:
730	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
731 err_runtime:
732	sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
733 err_out:
734	sysfs_remove_group(&dev->kobj, &pm_attr_group);
735	return rc;
736}
737
738int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
739{
740	int rc;
741
742	if (device_pm_not_required(dev))
743		return 0;
744
745	rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
746	if (rc)
747		return rc;
748
749	if (!pm_runtime_has_no_callbacks(dev)) {
750		rc = sysfs_group_change_owner(
751			&dev->kobj, &pm_runtime_attr_group, kuid, kgid);
752		if (rc)
753			return rc;
754	}
755
756	if (device_can_wakeup(dev)) {
757		rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
758					      kuid, kgid);
759		if (rc)
760			return rc;
761
762		rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
763		if (rc)
764			return rc;
765	}
766
767	if (dev->power.set_latency_tolerance) {
768		rc = sysfs_group_change_owner(
769			&dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
770			kgid);
771		if (rc)
772			return rc;
773	}
774	return 0;
775}
776
777int wakeup_sysfs_add(struct device *dev)
778{
779	int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
780
781	if (!ret)
782		kobject_uevent(&dev->kobj, KOBJ_CHANGE);
783
784	return ret;
785}
786
787void wakeup_sysfs_remove(struct device *dev)
788{
789	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
790	kobject_uevent(&dev->kobj, KOBJ_CHANGE);
791}
792
793int pm_qos_sysfs_add_resume_latency(struct device *dev)
794{
795	return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
796}
797
798void pm_qos_sysfs_remove_resume_latency(struct device *dev)
799{
800	sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
801}
802
803int pm_qos_sysfs_add_flags(struct device *dev)
804{
805	return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
806}
807
808void pm_qos_sysfs_remove_flags(struct device *dev)
809{
810	sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
811}
812
813int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
814{
815	return sysfs_merge_group(&dev->kobj,
816				 &pm_qos_latency_tolerance_attr_group);
817}
818
819void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
820{
821	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
822}
823
824void rpm_sysfs_remove(struct device *dev)
825{
826	sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
827}
828
829void dpm_sysfs_remove(struct device *dev)
830{
831	if (device_pm_not_required(dev))
832		return;
833	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
834	dev_pm_qos_constraints_destroy(dev);
835	rpm_sysfs_remove(dev);
836	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
837	sysfs_remove_group(&dev->kobj, &pm_attr_group);
838}