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 DEVICE_ATTR_RO(wakeup_last_time_ms);
513
514#ifdef CONFIG_PM_AUTOSLEEP
515static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
516						 struct device_attribute *attr,
517						 char *buf)
518{
519	s64 msec;
520	bool enabled = false;
521
522	spin_lock_irq(&dev->power.lock);
523	if (dev->power.wakeup) {
524		msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
525		enabled = true;
526	}
527	spin_unlock_irq(&dev->power.lock);
528
529	if (!enabled)
530		return sysfs_emit(buf, "\n");
531	return sysfs_emit(buf, "%lld\n", msec);
532}
533
534static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
535#endif /* CONFIG_PM_AUTOSLEEP */
536
537static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
538						kgid_t kgid)
539{
540	if (dev->power.wakeup && dev->power.wakeup->dev)
541		return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
542	return 0;
543}
544
545#else /* CONFIG_PM_SLEEP */
546static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
547						kgid_t kgid)
548{
549	return 0;
550}
551#endif
552
553#ifdef CONFIG_PM_ADVANCED_DEBUG
554static ssize_t runtime_usage_show(struct device *dev,
555				  struct device_attribute *attr, char *buf)
556{
557	return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
558}
559static DEVICE_ATTR_RO(runtime_usage);
560
561static ssize_t runtime_active_kids_show(struct device *dev,
562					struct device_attribute *attr,
563					char *buf)
564{
565	return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
566			  0 : atomic_read(&dev->power.child_count));
567}
568static DEVICE_ATTR_RO(runtime_active_kids);
569
570static ssize_t runtime_enabled_show(struct device *dev,
571				    struct device_attribute *attr, char *buf)
572{
573	const char *output;
574
575	if (dev->power.disable_depth && !dev->power.runtime_auto)
576		output = "disabled & forbidden";
577	else if (dev->power.disable_depth)
578		output = "disabled";
579	else if (!dev->power.runtime_auto)
580		output = "forbidden";
581	else
582		output = "enabled";
583
584	return sysfs_emit(buf, "%s\n", output);
585}
586static DEVICE_ATTR_RO(runtime_enabled);
587
588#ifdef CONFIG_PM_SLEEP
589static ssize_t async_show(struct device *dev, struct device_attribute *attr,
590			  char *buf)
591{
592	return sysfs_emit(buf, "%s\n",
593			  device_async_suspend_enabled(dev) ?
594			  _enabled : _disabled);
595}
596
597static ssize_t async_store(struct device *dev, struct device_attribute *attr,
598			   const char *buf, size_t n)
599{
600	if (sysfs_streq(buf, _enabled))
601		device_enable_async_suspend(dev);
602	else if (sysfs_streq(buf, _disabled))
603		device_disable_async_suspend(dev);
604	else
605		return -EINVAL;
606	return n;
607}
608
609static DEVICE_ATTR_RW(async);
610
611#endif /* CONFIG_PM_SLEEP */
612#endif /* CONFIG_PM_ADVANCED_DEBUG */
613
614static struct attribute *power_attrs[] = {
615#ifdef CONFIG_PM_ADVANCED_DEBUG
616#ifdef CONFIG_PM_SLEEP
617	&dev_attr_async.attr,
618#endif
619	&dev_attr_runtime_status.attr,
620	&dev_attr_runtime_usage.attr,
621	&dev_attr_runtime_active_kids.attr,
622	&dev_attr_runtime_enabled.attr,
623#endif /* CONFIG_PM_ADVANCED_DEBUG */
624	NULL,
625};
626static const struct attribute_group pm_attr_group = {
627	.name	= power_group_name,
628	.attrs	= power_attrs,
629};
630
631static struct attribute *wakeup_attrs[] = {
632#ifdef CONFIG_PM_SLEEP
633	&dev_attr_wakeup.attr,
634	&dev_attr_wakeup_count.attr,
635	&dev_attr_wakeup_active_count.attr,
636	&dev_attr_wakeup_abort_count.attr,
637	&dev_attr_wakeup_expire_count.attr,
638	&dev_attr_wakeup_active.attr,
639	&dev_attr_wakeup_total_time_ms.attr,
640	&dev_attr_wakeup_max_time_ms.attr,
641	&dev_attr_wakeup_last_time_ms.attr,
642#ifdef CONFIG_PM_AUTOSLEEP
643	&dev_attr_wakeup_prevent_sleep_time_ms.attr,
644#endif
645#endif
646	NULL,
647};
648static const struct attribute_group pm_wakeup_attr_group = {
649	.name	= power_group_name,
650	.attrs	= wakeup_attrs,
651};
652
653static struct attribute *runtime_attrs[] = {
654#ifndef CONFIG_PM_ADVANCED_DEBUG
655	&dev_attr_runtime_status.attr,
656#endif
657	&dev_attr_control.attr,
658	&dev_attr_runtime_suspended_time.attr,
659	&dev_attr_runtime_active_time.attr,
660	&dev_attr_autosuspend_delay_ms.attr,
661	NULL,
662};
663static const struct attribute_group pm_runtime_attr_group = {
664	.name	= power_group_name,
665	.attrs	= runtime_attrs,
666};
667
668static struct attribute *pm_qos_resume_latency_attrs[] = {
669	&dev_attr_pm_qos_resume_latency_us.attr,
670	NULL,
671};
672static const struct attribute_group pm_qos_resume_latency_attr_group = {
673	.name	= power_group_name,
674	.attrs	= pm_qos_resume_latency_attrs,
675};
676
677static struct attribute *pm_qos_latency_tolerance_attrs[] = {
678	&dev_attr_pm_qos_latency_tolerance_us.attr,
679	NULL,
680};
681static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
682	.name	= power_group_name,
683	.attrs	= pm_qos_latency_tolerance_attrs,
684};
685
686static struct attribute *pm_qos_flags_attrs[] = {
687	&dev_attr_pm_qos_no_power_off.attr,
688	NULL,
689};
690static const struct attribute_group pm_qos_flags_attr_group = {
691	.name	= power_group_name,
692	.attrs	= pm_qos_flags_attrs,
693};
694
695int dpm_sysfs_add(struct device *dev)
696{
697	int rc;
698
699	/* No need to create PM sysfs if explicitly disabled. */
700	if (device_pm_not_required(dev))
701		return 0;
702
703	rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
704	if (rc)
705		return rc;
706
707	if (!pm_runtime_has_no_callbacks(dev)) {
708		rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
709		if (rc)
710			goto err_out;
711	}
712	if (device_can_wakeup(dev)) {
713		rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
714		if (rc)
715			goto err_runtime;
716	}
717	if (dev->power.set_latency_tolerance) {
718		rc = sysfs_merge_group(&dev->kobj,
719				       &pm_qos_latency_tolerance_attr_group);
720		if (rc)
721			goto err_wakeup;
722	}
723	rc = pm_wakeup_source_sysfs_add(dev);
724	if (rc)
725		goto err_latency;
726	return 0;
727
728 err_latency:
729	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
730 err_wakeup:
731	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
732 err_runtime:
733	sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
734 err_out:
735	sysfs_remove_group(&dev->kobj, &pm_attr_group);
736	return rc;
737}
738
739int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
740{
741	int rc;
742
743	if (device_pm_not_required(dev))
744		return 0;
745
746	rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
747	if (rc)
748		return rc;
749
750	if (!pm_runtime_has_no_callbacks(dev)) {
751		rc = sysfs_group_change_owner(
752			&dev->kobj, &pm_runtime_attr_group, kuid, kgid);
753		if (rc)
754			return rc;
755	}
756
757	if (device_can_wakeup(dev)) {
758		rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
759					      kuid, kgid);
760		if (rc)
761			return rc;
762
763		rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
764		if (rc)
765			return rc;
766	}
767
768	if (dev->power.set_latency_tolerance) {
769		rc = sysfs_group_change_owner(
770			&dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
771			kgid);
772		if (rc)
773			return rc;
774	}
775	return 0;
776}
777
778int wakeup_sysfs_add(struct device *dev)
779{
780	int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
781
782	if (!ret)
783		kobject_uevent(&dev->kobj, KOBJ_CHANGE);
784
785	return ret;
786}
787
788void wakeup_sysfs_remove(struct device *dev)
789{
790	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
791	kobject_uevent(&dev->kobj, KOBJ_CHANGE);
792}
793
794int pm_qos_sysfs_add_resume_latency(struct device *dev)
795{
796	return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
797}
798
799void pm_qos_sysfs_remove_resume_latency(struct device *dev)
800{
801	sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
802}
803
804int pm_qos_sysfs_add_flags(struct device *dev)
805{
806	return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
807}
808
809void pm_qos_sysfs_remove_flags(struct device *dev)
810{
811	sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
812}
813
814int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
815{
816	return sysfs_merge_group(&dev->kobj,
817				 &pm_qos_latency_tolerance_attr_group);
818}
819
820void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
821{
822	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
823}
824
825void rpm_sysfs_remove(struct device *dev)
826{
827	sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
828}
829
830void dpm_sysfs_remove(struct device *dev)
831{
832	if (device_pm_not_required(dev))
833		return;
834	sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
835	dev_pm_qos_constraints_destroy(dev);
836	rpm_sysfs_remove(dev);
837	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
838	sysfs_remove_group(&dev->kobj, &pm_attr_group);
839}