xref: /openbmc/linux/drivers/base/power/domain.c (revision c819e2cf)
1 /*
2  * drivers/base/power/domain.c - Common code related to device power domains.
3  *
4  * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
5  *
6  * This file is released under the GPLv2.
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/io.h>
11 #include <linux/platform_device.h>
12 #include <linux/pm_runtime.h>
13 #include <linux/pm_domain.h>
14 #include <linux/pm_qos.h>
15 #include <linux/pm_clock.h>
16 #include <linux/slab.h>
17 #include <linux/err.h>
18 #include <linux/sched.h>
19 #include <linux/suspend.h>
20 #include <linux/export.h>
21 
22 #define GENPD_DEV_CALLBACK(genpd, type, callback, dev)		\
23 ({								\
24 	type (*__routine)(struct device *__d); 			\
25 	type __ret = (type)0;					\
26 								\
27 	__routine = genpd->dev_ops.callback; 			\
28 	if (__routine) {					\
29 		__ret = __routine(dev); 			\
30 	}							\
31 	__ret;							\
32 })
33 
34 #define GENPD_DEV_TIMED_CALLBACK(genpd, type, callback, dev, field, name)	\
35 ({										\
36 	ktime_t __start = ktime_get();						\
37 	type __retval = GENPD_DEV_CALLBACK(genpd, type, callback, dev);		\
38 	s64 __elapsed = ktime_to_ns(ktime_sub(ktime_get(), __start));		\
39 	struct gpd_timing_data *__td = &dev_gpd_data(dev)->td;			\
40 	if (!__retval && __elapsed > __td->field) {				\
41 		__td->field = __elapsed;					\
42 		dev_dbg(dev, name " latency exceeded, new value %lld ns\n",	\
43 			__elapsed);						\
44 		genpd->max_off_time_changed = true;				\
45 		__td->constraint_changed = true;				\
46 	}									\
47 	__retval;								\
48 })
49 
50 static LIST_HEAD(gpd_list);
51 static DEFINE_MUTEX(gpd_list_lock);
52 
53 static struct generic_pm_domain *pm_genpd_lookup_name(const char *domain_name)
54 {
55 	struct generic_pm_domain *genpd = NULL, *gpd;
56 
57 	if (IS_ERR_OR_NULL(domain_name))
58 		return NULL;
59 
60 	mutex_lock(&gpd_list_lock);
61 	list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
62 		if (!strcmp(gpd->name, domain_name)) {
63 			genpd = gpd;
64 			break;
65 		}
66 	}
67 	mutex_unlock(&gpd_list_lock);
68 	return genpd;
69 }
70 
71 struct generic_pm_domain *dev_to_genpd(struct device *dev)
72 {
73 	if (IS_ERR_OR_NULL(dev->pm_domain))
74 		return ERR_PTR(-EINVAL);
75 
76 	return pd_to_genpd(dev->pm_domain);
77 }
78 
79 static int genpd_stop_dev(struct generic_pm_domain *genpd, struct device *dev)
80 {
81 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, stop, dev,
82 					stop_latency_ns, "stop");
83 }
84 
85 static int genpd_start_dev(struct generic_pm_domain *genpd, struct device *dev)
86 {
87 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, start, dev,
88 					start_latency_ns, "start");
89 }
90 
91 static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
92 {
93 	bool ret = false;
94 
95 	if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
96 		ret = !!atomic_dec_and_test(&genpd->sd_count);
97 
98 	return ret;
99 }
100 
101 static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
102 {
103 	atomic_inc(&genpd->sd_count);
104 	smp_mb__after_atomic();
105 }
106 
107 static void genpd_acquire_lock(struct generic_pm_domain *genpd)
108 {
109 	DEFINE_WAIT(wait);
110 
111 	mutex_lock(&genpd->lock);
112 	/*
113 	 * Wait for the domain to transition into either the active,
114 	 * or the power off state.
115 	 */
116 	for (;;) {
117 		prepare_to_wait(&genpd->status_wait_queue, &wait,
118 				TASK_UNINTERRUPTIBLE);
119 		if (genpd->status == GPD_STATE_ACTIVE
120 		    || genpd->status == GPD_STATE_POWER_OFF)
121 			break;
122 		mutex_unlock(&genpd->lock);
123 
124 		schedule();
125 
126 		mutex_lock(&genpd->lock);
127 	}
128 	finish_wait(&genpd->status_wait_queue, &wait);
129 }
130 
131 static void genpd_release_lock(struct generic_pm_domain *genpd)
132 {
133 	mutex_unlock(&genpd->lock);
134 }
135 
136 static void genpd_set_active(struct generic_pm_domain *genpd)
137 {
138 	if (genpd->resume_count == 0)
139 		genpd->status = GPD_STATE_ACTIVE;
140 }
141 
142 static void genpd_recalc_cpu_exit_latency(struct generic_pm_domain *genpd)
143 {
144 	s64 usecs64;
145 
146 	if (!genpd->cpuidle_data)
147 		return;
148 
149 	usecs64 = genpd->power_on_latency_ns;
150 	do_div(usecs64, NSEC_PER_USEC);
151 	usecs64 += genpd->cpuidle_data->saved_exit_latency;
152 	genpd->cpuidle_data->idle_state->exit_latency = usecs64;
153 }
154 
155 static int genpd_power_on(struct generic_pm_domain *genpd)
156 {
157 	ktime_t time_start;
158 	s64 elapsed_ns;
159 	int ret;
160 
161 	if (!genpd->power_on)
162 		return 0;
163 
164 	time_start = ktime_get();
165 	ret = genpd->power_on(genpd);
166 	if (ret)
167 		return ret;
168 
169 	elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
170 	if (elapsed_ns <= genpd->power_on_latency_ns)
171 		return ret;
172 
173 	genpd->power_on_latency_ns = elapsed_ns;
174 	genpd->max_off_time_changed = true;
175 	genpd_recalc_cpu_exit_latency(genpd);
176 	pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
177 		genpd->name, "on", elapsed_ns);
178 
179 	return ret;
180 }
181 
182 static int genpd_power_off(struct generic_pm_domain *genpd)
183 {
184 	ktime_t time_start;
185 	s64 elapsed_ns;
186 	int ret;
187 
188 	if (!genpd->power_off)
189 		return 0;
190 
191 	time_start = ktime_get();
192 	ret = genpd->power_off(genpd);
193 	if (ret == -EBUSY)
194 		return ret;
195 
196 	elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
197 	if (elapsed_ns <= genpd->power_off_latency_ns)
198 		return ret;
199 
200 	genpd->power_off_latency_ns = elapsed_ns;
201 	genpd->max_off_time_changed = true;
202 	pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
203 		genpd->name, "off", elapsed_ns);
204 
205 	return ret;
206 }
207 
208 /**
209  * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
210  * @genpd: PM domain to power up.
211  *
212  * Restore power to @genpd and all of its masters so that it is possible to
213  * resume a device belonging to it.
214  */
215 static int __pm_genpd_poweron(struct generic_pm_domain *genpd)
216 	__releases(&genpd->lock) __acquires(&genpd->lock)
217 {
218 	struct gpd_link *link;
219 	DEFINE_WAIT(wait);
220 	int ret = 0;
221 
222 	/* If the domain's master is being waited for, we have to wait too. */
223 	for (;;) {
224 		prepare_to_wait(&genpd->status_wait_queue, &wait,
225 				TASK_UNINTERRUPTIBLE);
226 		if (genpd->status != GPD_STATE_WAIT_MASTER)
227 			break;
228 		mutex_unlock(&genpd->lock);
229 
230 		schedule();
231 
232 		mutex_lock(&genpd->lock);
233 	}
234 	finish_wait(&genpd->status_wait_queue, &wait);
235 
236 	if (genpd->status == GPD_STATE_ACTIVE
237 	    || (genpd->prepared_count > 0 && genpd->suspend_power_off))
238 		return 0;
239 
240 	if (genpd->status != GPD_STATE_POWER_OFF) {
241 		genpd_set_active(genpd);
242 		return 0;
243 	}
244 
245 	if (genpd->cpuidle_data) {
246 		cpuidle_pause_and_lock();
247 		genpd->cpuidle_data->idle_state->disabled = true;
248 		cpuidle_resume_and_unlock();
249 		goto out;
250 	}
251 
252 	/*
253 	 * The list is guaranteed not to change while the loop below is being
254 	 * executed, unless one of the masters' .power_on() callbacks fiddles
255 	 * with it.
256 	 */
257 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
258 		genpd_sd_counter_inc(link->master);
259 		genpd->status = GPD_STATE_WAIT_MASTER;
260 
261 		mutex_unlock(&genpd->lock);
262 
263 		ret = pm_genpd_poweron(link->master);
264 
265 		mutex_lock(&genpd->lock);
266 
267 		/*
268 		 * The "wait for parent" status is guaranteed not to change
269 		 * while the master is powering on.
270 		 */
271 		genpd->status = GPD_STATE_POWER_OFF;
272 		wake_up_all(&genpd->status_wait_queue);
273 		if (ret) {
274 			genpd_sd_counter_dec(link->master);
275 			goto err;
276 		}
277 	}
278 
279 	ret = genpd_power_on(genpd);
280 	if (ret)
281 		goto err;
282 
283  out:
284 	genpd_set_active(genpd);
285 
286 	return 0;
287 
288  err:
289 	list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
290 		genpd_sd_counter_dec(link->master);
291 
292 	return ret;
293 }
294 
295 /**
296  * pm_genpd_poweron - Restore power to a given PM domain and its masters.
297  * @genpd: PM domain to power up.
298  */
299 int pm_genpd_poweron(struct generic_pm_domain *genpd)
300 {
301 	int ret;
302 
303 	mutex_lock(&genpd->lock);
304 	ret = __pm_genpd_poweron(genpd);
305 	mutex_unlock(&genpd->lock);
306 	return ret;
307 }
308 
309 /**
310  * pm_genpd_name_poweron - Restore power to a given PM domain and its masters.
311  * @domain_name: Name of the PM domain to power up.
312  */
313 int pm_genpd_name_poweron(const char *domain_name)
314 {
315 	struct generic_pm_domain *genpd;
316 
317 	genpd = pm_genpd_lookup_name(domain_name);
318 	return genpd ? pm_genpd_poweron(genpd) : -EINVAL;
319 }
320 
321 static int genpd_start_dev_no_timing(struct generic_pm_domain *genpd,
322 				     struct device *dev)
323 {
324 	return GENPD_DEV_CALLBACK(genpd, int, start, dev);
325 }
326 
327 static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
328 {
329 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
330 					save_state_latency_ns, "state save");
331 }
332 
333 static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
334 {
335 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
336 					restore_state_latency_ns,
337 					"state restore");
338 }
339 
340 static int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
341 				     unsigned long val, void *ptr)
342 {
343 	struct generic_pm_domain_data *gpd_data;
344 	struct device *dev;
345 
346 	gpd_data = container_of(nb, struct generic_pm_domain_data, nb);
347 
348 	mutex_lock(&gpd_data->lock);
349 	dev = gpd_data->base.dev;
350 	if (!dev) {
351 		mutex_unlock(&gpd_data->lock);
352 		return NOTIFY_DONE;
353 	}
354 	mutex_unlock(&gpd_data->lock);
355 
356 	for (;;) {
357 		struct generic_pm_domain *genpd;
358 		struct pm_domain_data *pdd;
359 
360 		spin_lock_irq(&dev->power.lock);
361 
362 		pdd = dev->power.subsys_data ?
363 				dev->power.subsys_data->domain_data : NULL;
364 		if (pdd && pdd->dev) {
365 			to_gpd_data(pdd)->td.constraint_changed = true;
366 			genpd = dev_to_genpd(dev);
367 		} else {
368 			genpd = ERR_PTR(-ENODATA);
369 		}
370 
371 		spin_unlock_irq(&dev->power.lock);
372 
373 		if (!IS_ERR(genpd)) {
374 			mutex_lock(&genpd->lock);
375 			genpd->max_off_time_changed = true;
376 			mutex_unlock(&genpd->lock);
377 		}
378 
379 		dev = dev->parent;
380 		if (!dev || dev->power.ignore_children)
381 			break;
382 	}
383 
384 	return NOTIFY_DONE;
385 }
386 
387 /**
388  * __pm_genpd_save_device - Save the pre-suspend state of a device.
389  * @pdd: Domain data of the device to save the state of.
390  * @genpd: PM domain the device belongs to.
391  */
392 static int __pm_genpd_save_device(struct pm_domain_data *pdd,
393 				  struct generic_pm_domain *genpd)
394 	__releases(&genpd->lock) __acquires(&genpd->lock)
395 {
396 	struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
397 	struct device *dev = pdd->dev;
398 	int ret = 0;
399 
400 	if (gpd_data->need_restore > 0)
401 		return 0;
402 
403 	/*
404 	 * If the value of the need_restore flag is still unknown at this point,
405 	 * we trust that pm_genpd_poweroff() has verified that the device is
406 	 * already runtime PM suspended.
407 	 */
408 	if (gpd_data->need_restore < 0) {
409 		gpd_data->need_restore = 1;
410 		return 0;
411 	}
412 
413 	mutex_unlock(&genpd->lock);
414 
415 	genpd_start_dev(genpd, dev);
416 	ret = genpd_save_dev(genpd, dev);
417 	genpd_stop_dev(genpd, dev);
418 
419 	mutex_lock(&genpd->lock);
420 
421 	if (!ret)
422 		gpd_data->need_restore = 1;
423 
424 	return ret;
425 }
426 
427 /**
428  * __pm_genpd_restore_device - Restore the pre-suspend state of a device.
429  * @pdd: Domain data of the device to restore the state of.
430  * @genpd: PM domain the device belongs to.
431  */
432 static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
433 				      struct generic_pm_domain *genpd)
434 	__releases(&genpd->lock) __acquires(&genpd->lock)
435 {
436 	struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
437 	struct device *dev = pdd->dev;
438 	int need_restore = gpd_data->need_restore;
439 
440 	gpd_data->need_restore = 0;
441 	mutex_unlock(&genpd->lock);
442 
443 	genpd_start_dev(genpd, dev);
444 
445 	/*
446 	 * Call genpd_restore_dev() for recently added devices too (need_restore
447 	 * is negative then).
448 	 */
449 	if (need_restore)
450 		genpd_restore_dev(genpd, dev);
451 
452 	mutex_lock(&genpd->lock);
453 }
454 
455 /**
456  * genpd_abort_poweroff - Check if a PM domain power off should be aborted.
457  * @genpd: PM domain to check.
458  *
459  * Return true if a PM domain's status changed to GPD_STATE_ACTIVE during
460  * a "power off" operation, which means that a "power on" has occured in the
461  * meantime, or if its resume_count field is different from zero, which means
462  * that one of its devices has been resumed in the meantime.
463  */
464 static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
465 {
466 	return genpd->status == GPD_STATE_WAIT_MASTER
467 		|| genpd->status == GPD_STATE_ACTIVE || genpd->resume_count > 0;
468 }
469 
470 /**
471  * genpd_queue_power_off_work - Queue up the execution of pm_genpd_poweroff().
472  * @genpd: PM domait to power off.
473  *
474  * Queue up the execution of pm_genpd_poweroff() unless it's already been done
475  * before.
476  */
477 static void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
478 {
479 	queue_work(pm_wq, &genpd->power_off_work);
480 }
481 
482 /**
483  * pm_genpd_poweroff - Remove power from a given PM domain.
484  * @genpd: PM domain to power down.
485  *
486  * If all of the @genpd's devices have been suspended and all of its subdomains
487  * have been powered down, run the runtime suspend callbacks provided by all of
488  * the @genpd's devices' drivers and remove power from @genpd.
489  */
490 static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
491 	__releases(&genpd->lock) __acquires(&genpd->lock)
492 {
493 	struct pm_domain_data *pdd;
494 	struct gpd_link *link;
495 	unsigned int not_suspended;
496 	int ret = 0;
497 
498  start:
499 	/*
500 	 * Do not try to power off the domain in the following situations:
501 	 * (1) The domain is already in the "power off" state.
502 	 * (2) The domain is waiting for its master to power up.
503 	 * (3) One of the domain's devices is being resumed right now.
504 	 * (4) System suspend is in progress.
505 	 */
506 	if (genpd->status == GPD_STATE_POWER_OFF
507 	    || genpd->status == GPD_STATE_WAIT_MASTER
508 	    || genpd->resume_count > 0 || genpd->prepared_count > 0)
509 		return 0;
510 
511 	if (atomic_read(&genpd->sd_count) > 0)
512 		return -EBUSY;
513 
514 	not_suspended = 0;
515 	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
516 		enum pm_qos_flags_status stat;
517 
518 		stat = dev_pm_qos_flags(pdd->dev,
519 					PM_QOS_FLAG_NO_POWER_OFF
520 						| PM_QOS_FLAG_REMOTE_WAKEUP);
521 		if (stat > PM_QOS_FLAGS_NONE)
522 			return -EBUSY;
523 
524 		if (pdd->dev->driver && (!pm_runtime_suspended(pdd->dev)
525 		    || pdd->dev->power.irq_safe))
526 			not_suspended++;
527 	}
528 
529 	if (not_suspended > genpd->in_progress)
530 		return -EBUSY;
531 
532 	if (genpd->poweroff_task) {
533 		/*
534 		 * Another instance of pm_genpd_poweroff() is executing
535 		 * callbacks, so tell it to start over and return.
536 		 */
537 		genpd->status = GPD_STATE_REPEAT;
538 		return 0;
539 	}
540 
541 	if (genpd->gov && genpd->gov->power_down_ok) {
542 		if (!genpd->gov->power_down_ok(&genpd->domain))
543 			return -EAGAIN;
544 	}
545 
546 	genpd->status = GPD_STATE_BUSY;
547 	genpd->poweroff_task = current;
548 
549 	list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
550 		ret = atomic_read(&genpd->sd_count) == 0 ?
551 			__pm_genpd_save_device(pdd, genpd) : -EBUSY;
552 
553 		if (genpd_abort_poweroff(genpd))
554 			goto out;
555 
556 		if (ret) {
557 			genpd_set_active(genpd);
558 			goto out;
559 		}
560 
561 		if (genpd->status == GPD_STATE_REPEAT) {
562 			genpd->poweroff_task = NULL;
563 			goto start;
564 		}
565 	}
566 
567 	if (genpd->cpuidle_data) {
568 		/*
569 		 * If cpuidle_data is set, cpuidle should turn the domain off
570 		 * when the CPU in it is idle.  In that case we don't decrement
571 		 * the subdomain counts of the master domains, so that power is
572 		 * not removed from the current domain prematurely as a result
573 		 * of cutting off the masters' power.
574 		 */
575 		genpd->status = GPD_STATE_POWER_OFF;
576 		cpuidle_pause_and_lock();
577 		genpd->cpuidle_data->idle_state->disabled = false;
578 		cpuidle_resume_and_unlock();
579 		goto out;
580 	}
581 
582 	if (genpd->power_off) {
583 		if (atomic_read(&genpd->sd_count) > 0) {
584 			ret = -EBUSY;
585 			goto out;
586 		}
587 
588 		/*
589 		 * If sd_count > 0 at this point, one of the subdomains hasn't
590 		 * managed to call pm_genpd_poweron() for the master yet after
591 		 * incrementing it.  In that case pm_genpd_poweron() will wait
592 		 * for us to drop the lock, so we can call .power_off() and let
593 		 * the pm_genpd_poweron() restore power for us (this shouldn't
594 		 * happen very often).
595 		 */
596 		ret = genpd_power_off(genpd);
597 		if (ret == -EBUSY) {
598 			genpd_set_active(genpd);
599 			goto out;
600 		}
601 	}
602 
603 	genpd->status = GPD_STATE_POWER_OFF;
604 
605 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
606 		genpd_sd_counter_dec(link->master);
607 		genpd_queue_power_off_work(link->master);
608 	}
609 
610  out:
611 	genpd->poweroff_task = NULL;
612 	wake_up_all(&genpd->status_wait_queue);
613 	return ret;
614 }
615 
616 /**
617  * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
618  * @work: Work structure used for scheduling the execution of this function.
619  */
620 static void genpd_power_off_work_fn(struct work_struct *work)
621 {
622 	struct generic_pm_domain *genpd;
623 
624 	genpd = container_of(work, struct generic_pm_domain, power_off_work);
625 
626 	genpd_acquire_lock(genpd);
627 	pm_genpd_poweroff(genpd);
628 	genpd_release_lock(genpd);
629 }
630 
631 /**
632  * pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
633  * @dev: Device to suspend.
634  *
635  * Carry out a runtime suspend of a device under the assumption that its
636  * pm_domain field points to the domain member of an object of type
637  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
638  */
639 static int pm_genpd_runtime_suspend(struct device *dev)
640 {
641 	struct generic_pm_domain *genpd;
642 	struct generic_pm_domain_data *gpd_data;
643 	bool (*stop_ok)(struct device *__dev);
644 	int ret;
645 
646 	dev_dbg(dev, "%s()\n", __func__);
647 
648 	genpd = dev_to_genpd(dev);
649 	if (IS_ERR(genpd))
650 		return -EINVAL;
651 
652 	stop_ok = genpd->gov ? genpd->gov->stop_ok : NULL;
653 	if (stop_ok && !stop_ok(dev))
654 		return -EBUSY;
655 
656 	ret = genpd_stop_dev(genpd, dev);
657 	if (ret)
658 		return ret;
659 
660 	/*
661 	 * If power.irq_safe is set, this routine will be run with interrupts
662 	 * off, so it can't use mutexes.
663 	 */
664 	if (dev->power.irq_safe)
665 		return 0;
666 
667 	mutex_lock(&genpd->lock);
668 
669 	/*
670 	 * If we have an unknown state of the need_restore flag, it means none
671 	 * of the runtime PM callbacks has been invoked yet. Let's update the
672 	 * flag to reflect that the current state is active.
673 	 */
674 	gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
675 	if (gpd_data->need_restore < 0)
676 		gpd_data->need_restore = 0;
677 
678 	genpd->in_progress++;
679 	pm_genpd_poweroff(genpd);
680 	genpd->in_progress--;
681 	mutex_unlock(&genpd->lock);
682 
683 	return 0;
684 }
685 
686 /**
687  * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
688  * @dev: Device to resume.
689  *
690  * Carry out a runtime resume of a device under the assumption that its
691  * pm_domain field points to the domain member of an object of type
692  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
693  */
694 static int pm_genpd_runtime_resume(struct device *dev)
695 {
696 	struct generic_pm_domain *genpd;
697 	DEFINE_WAIT(wait);
698 	int ret;
699 
700 	dev_dbg(dev, "%s()\n", __func__);
701 
702 	genpd = dev_to_genpd(dev);
703 	if (IS_ERR(genpd))
704 		return -EINVAL;
705 
706 	/* If power.irq_safe, the PM domain is never powered off. */
707 	if (dev->power.irq_safe)
708 		return genpd_start_dev_no_timing(genpd, dev);
709 
710 	mutex_lock(&genpd->lock);
711 	ret = __pm_genpd_poweron(genpd);
712 	if (ret) {
713 		mutex_unlock(&genpd->lock);
714 		return ret;
715 	}
716 	genpd->status = GPD_STATE_BUSY;
717 	genpd->resume_count++;
718 	for (;;) {
719 		prepare_to_wait(&genpd->status_wait_queue, &wait,
720 				TASK_UNINTERRUPTIBLE);
721 		/*
722 		 * If current is the powering off task, we have been called
723 		 * reentrantly from one of the device callbacks, so we should
724 		 * not wait.
725 		 */
726 		if (!genpd->poweroff_task || genpd->poweroff_task == current)
727 			break;
728 		mutex_unlock(&genpd->lock);
729 
730 		schedule();
731 
732 		mutex_lock(&genpd->lock);
733 	}
734 	finish_wait(&genpd->status_wait_queue, &wait);
735 	__pm_genpd_restore_device(dev->power.subsys_data->domain_data, genpd);
736 	genpd->resume_count--;
737 	genpd_set_active(genpd);
738 	wake_up_all(&genpd->status_wait_queue);
739 	mutex_unlock(&genpd->lock);
740 
741 	return 0;
742 }
743 
744 static bool pd_ignore_unused;
745 static int __init pd_ignore_unused_setup(char *__unused)
746 {
747 	pd_ignore_unused = true;
748 	return 1;
749 }
750 __setup("pd_ignore_unused", pd_ignore_unused_setup);
751 
752 /**
753  * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
754  */
755 void pm_genpd_poweroff_unused(void)
756 {
757 	struct generic_pm_domain *genpd;
758 
759 	if (pd_ignore_unused) {
760 		pr_warn("genpd: Not disabling unused power domains\n");
761 		return;
762 	}
763 
764 	mutex_lock(&gpd_list_lock);
765 
766 	list_for_each_entry(genpd, &gpd_list, gpd_list_node)
767 		genpd_queue_power_off_work(genpd);
768 
769 	mutex_unlock(&gpd_list_lock);
770 }
771 
772 static int __init genpd_poweroff_unused(void)
773 {
774 	pm_genpd_poweroff_unused();
775 	return 0;
776 }
777 late_initcall(genpd_poweroff_unused);
778 
779 #ifdef CONFIG_PM_SLEEP
780 
781 /**
782  * pm_genpd_present - Check if the given PM domain has been initialized.
783  * @genpd: PM domain to check.
784  */
785 static bool pm_genpd_present(const struct generic_pm_domain *genpd)
786 {
787 	const struct generic_pm_domain *gpd;
788 
789 	if (IS_ERR_OR_NULL(genpd))
790 		return false;
791 
792 	list_for_each_entry(gpd, &gpd_list, gpd_list_node)
793 		if (gpd == genpd)
794 			return true;
795 
796 	return false;
797 }
798 
799 static bool genpd_dev_active_wakeup(struct generic_pm_domain *genpd,
800 				    struct device *dev)
801 {
802 	return GENPD_DEV_CALLBACK(genpd, bool, active_wakeup, dev);
803 }
804 
805 /**
806  * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
807  * @genpd: PM domain to power off, if possible.
808  *
809  * Check if the given PM domain can be powered off (during system suspend or
810  * hibernation) and do that if so.  Also, in that case propagate to its masters.
811  *
812  * This function is only called in "noirq" and "syscore" stages of system power
813  * transitions, so it need not acquire locks (all of the "noirq" callbacks are
814  * executed sequentially, so it is guaranteed that it will never run twice in
815  * parallel).
816  */
817 static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
818 {
819 	struct gpd_link *link;
820 
821 	if (genpd->status == GPD_STATE_POWER_OFF)
822 		return;
823 
824 	if (genpd->suspended_count != genpd->device_count
825 	    || atomic_read(&genpd->sd_count) > 0)
826 		return;
827 
828 	genpd_power_off(genpd);
829 
830 	genpd->status = GPD_STATE_POWER_OFF;
831 
832 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
833 		genpd_sd_counter_dec(link->master);
834 		pm_genpd_sync_poweroff(link->master);
835 	}
836 }
837 
838 /**
839  * pm_genpd_sync_poweron - Synchronously power on a PM domain and its masters.
840  * @genpd: PM domain to power on.
841  *
842  * This function is only called in "noirq" and "syscore" stages of system power
843  * transitions, so it need not acquire locks (all of the "noirq" callbacks are
844  * executed sequentially, so it is guaranteed that it will never run twice in
845  * parallel).
846  */
847 static void pm_genpd_sync_poweron(struct generic_pm_domain *genpd)
848 {
849 	struct gpd_link *link;
850 
851 	if (genpd->status != GPD_STATE_POWER_OFF)
852 		return;
853 
854 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
855 		pm_genpd_sync_poweron(link->master);
856 		genpd_sd_counter_inc(link->master);
857 	}
858 
859 	genpd_power_on(genpd);
860 
861 	genpd->status = GPD_STATE_ACTIVE;
862 }
863 
864 /**
865  * resume_needed - Check whether to resume a device before system suspend.
866  * @dev: Device to check.
867  * @genpd: PM domain the device belongs to.
868  *
869  * There are two cases in which a device that can wake up the system from sleep
870  * states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
871  * to wake up the system and it has to remain active for this purpose while the
872  * system is in the sleep state and (2) if the device is not enabled to wake up
873  * the system from sleep states and it generally doesn't generate wakeup signals
874  * by itself (those signals are generated on its behalf by other parts of the
875  * system).  In the latter case it may be necessary to reconfigure the device's
876  * wakeup settings during system suspend, because it may have been set up to
877  * signal remote wakeup from the system's working state as needed by runtime PM.
878  * Return 'true' in either of the above cases.
879  */
880 static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
881 {
882 	bool active_wakeup;
883 
884 	if (!device_can_wakeup(dev))
885 		return false;
886 
887 	active_wakeup = genpd_dev_active_wakeup(genpd, dev);
888 	return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
889 }
890 
891 /**
892  * pm_genpd_prepare - Start power transition of a device in a PM domain.
893  * @dev: Device to start the transition of.
894  *
895  * Start a power transition of a device (during a system-wide power transition)
896  * under the assumption that its pm_domain field points to the domain member of
897  * an object of type struct generic_pm_domain representing a PM domain
898  * consisting of I/O devices.
899  */
900 static int pm_genpd_prepare(struct device *dev)
901 {
902 	struct generic_pm_domain *genpd;
903 	int ret;
904 
905 	dev_dbg(dev, "%s()\n", __func__);
906 
907 	genpd = dev_to_genpd(dev);
908 	if (IS_ERR(genpd))
909 		return -EINVAL;
910 
911 	/*
912 	 * If a wakeup request is pending for the device, it should be woken up
913 	 * at this point and a system wakeup event should be reported if it's
914 	 * set up to wake up the system from sleep states.
915 	 */
916 	pm_runtime_get_noresume(dev);
917 	if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
918 		pm_wakeup_event(dev, 0);
919 
920 	if (pm_wakeup_pending()) {
921 		pm_runtime_put(dev);
922 		return -EBUSY;
923 	}
924 
925 	if (resume_needed(dev, genpd))
926 		pm_runtime_resume(dev);
927 
928 	genpd_acquire_lock(genpd);
929 
930 	if (genpd->prepared_count++ == 0) {
931 		genpd->suspended_count = 0;
932 		genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
933 	}
934 
935 	genpd_release_lock(genpd);
936 
937 	if (genpd->suspend_power_off) {
938 		pm_runtime_put_noidle(dev);
939 		return 0;
940 	}
941 
942 	/*
943 	 * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
944 	 * so pm_genpd_poweron() will return immediately, but if the device
945 	 * is suspended (e.g. it's been stopped by genpd_stop_dev()), we need
946 	 * to make it operational.
947 	 */
948 	pm_runtime_resume(dev);
949 	__pm_runtime_disable(dev, false);
950 
951 	ret = pm_generic_prepare(dev);
952 	if (ret) {
953 		mutex_lock(&genpd->lock);
954 
955 		if (--genpd->prepared_count == 0)
956 			genpd->suspend_power_off = false;
957 
958 		mutex_unlock(&genpd->lock);
959 		pm_runtime_enable(dev);
960 	}
961 
962 	pm_runtime_put(dev);
963 	return ret;
964 }
965 
966 /**
967  * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
968  * @dev: Device to suspend.
969  *
970  * Suspend a device under the assumption that its pm_domain field points to the
971  * domain member of an object of type struct generic_pm_domain representing
972  * a PM domain consisting of I/O devices.
973  */
974 static int pm_genpd_suspend(struct device *dev)
975 {
976 	struct generic_pm_domain *genpd;
977 
978 	dev_dbg(dev, "%s()\n", __func__);
979 
980 	genpd = dev_to_genpd(dev);
981 	if (IS_ERR(genpd))
982 		return -EINVAL;
983 
984 	return genpd->suspend_power_off ? 0 : pm_generic_suspend(dev);
985 }
986 
987 /**
988  * pm_genpd_suspend_late - Late suspend of a device from an I/O PM domain.
989  * @dev: Device to suspend.
990  *
991  * Carry out a late suspend of a device under the assumption that its
992  * pm_domain field points to the domain member of an object of type
993  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
994  */
995 static int pm_genpd_suspend_late(struct device *dev)
996 {
997 	struct generic_pm_domain *genpd;
998 
999 	dev_dbg(dev, "%s()\n", __func__);
1000 
1001 	genpd = dev_to_genpd(dev);
1002 	if (IS_ERR(genpd))
1003 		return -EINVAL;
1004 
1005 	return genpd->suspend_power_off ? 0 : pm_generic_suspend_late(dev);
1006 }
1007 
1008 /**
1009  * pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain.
1010  * @dev: Device to suspend.
1011  *
1012  * Stop the device and remove power from the domain if all devices in it have
1013  * been stopped.
1014  */
1015 static int pm_genpd_suspend_noirq(struct device *dev)
1016 {
1017 	struct generic_pm_domain *genpd;
1018 
1019 	dev_dbg(dev, "%s()\n", __func__);
1020 
1021 	genpd = dev_to_genpd(dev);
1022 	if (IS_ERR(genpd))
1023 		return -EINVAL;
1024 
1025 	if (genpd->suspend_power_off
1026 	    || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
1027 		return 0;
1028 
1029 	genpd_stop_dev(genpd, dev);
1030 
1031 	/*
1032 	 * Since all of the "noirq" callbacks are executed sequentially, it is
1033 	 * guaranteed that this function will never run twice in parallel for
1034 	 * the same PM domain, so it is not necessary to use locking here.
1035 	 */
1036 	genpd->suspended_count++;
1037 	pm_genpd_sync_poweroff(genpd);
1038 
1039 	return 0;
1040 }
1041 
1042 /**
1043  * pm_genpd_resume_noirq - Start of resume of device in an I/O PM domain.
1044  * @dev: Device to resume.
1045  *
1046  * Restore power to the device's PM domain, if necessary, and start the device.
1047  */
1048 static int pm_genpd_resume_noirq(struct device *dev)
1049 {
1050 	struct generic_pm_domain *genpd;
1051 
1052 	dev_dbg(dev, "%s()\n", __func__);
1053 
1054 	genpd = dev_to_genpd(dev);
1055 	if (IS_ERR(genpd))
1056 		return -EINVAL;
1057 
1058 	if (genpd->suspend_power_off
1059 	    || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
1060 		return 0;
1061 
1062 	/*
1063 	 * Since all of the "noirq" callbacks are executed sequentially, it is
1064 	 * guaranteed that this function will never run twice in parallel for
1065 	 * the same PM domain, so it is not necessary to use locking here.
1066 	 */
1067 	pm_genpd_sync_poweron(genpd);
1068 	genpd->suspended_count--;
1069 
1070 	return genpd_start_dev(genpd, dev);
1071 }
1072 
1073 /**
1074  * pm_genpd_resume_early - Early resume of a device in an I/O PM domain.
1075  * @dev: Device to resume.
1076  *
1077  * Carry out an early resume of a device under the assumption that its
1078  * pm_domain field points to the domain member of an object of type
1079  * struct generic_pm_domain representing a power domain consisting of I/O
1080  * devices.
1081  */
1082 static int pm_genpd_resume_early(struct device *dev)
1083 {
1084 	struct generic_pm_domain *genpd;
1085 
1086 	dev_dbg(dev, "%s()\n", __func__);
1087 
1088 	genpd = dev_to_genpd(dev);
1089 	if (IS_ERR(genpd))
1090 		return -EINVAL;
1091 
1092 	return genpd->suspend_power_off ? 0 : pm_generic_resume_early(dev);
1093 }
1094 
1095 /**
1096  * pm_genpd_resume - Resume of device in an I/O PM domain.
1097  * @dev: Device to resume.
1098  *
1099  * Resume a device under the assumption that its pm_domain field points to the
1100  * domain member of an object of type struct generic_pm_domain representing
1101  * a power domain consisting of I/O devices.
1102  */
1103 static int pm_genpd_resume(struct device *dev)
1104 {
1105 	struct generic_pm_domain *genpd;
1106 
1107 	dev_dbg(dev, "%s()\n", __func__);
1108 
1109 	genpd = dev_to_genpd(dev);
1110 	if (IS_ERR(genpd))
1111 		return -EINVAL;
1112 
1113 	return genpd->suspend_power_off ? 0 : pm_generic_resume(dev);
1114 }
1115 
1116 /**
1117  * pm_genpd_freeze - Freezing a device in an I/O PM domain.
1118  * @dev: Device to freeze.
1119  *
1120  * Freeze a device under the assumption that its pm_domain field points to the
1121  * domain member of an object of type struct generic_pm_domain representing
1122  * a power domain consisting of I/O devices.
1123  */
1124 static int pm_genpd_freeze(struct device *dev)
1125 {
1126 	struct generic_pm_domain *genpd;
1127 
1128 	dev_dbg(dev, "%s()\n", __func__);
1129 
1130 	genpd = dev_to_genpd(dev);
1131 	if (IS_ERR(genpd))
1132 		return -EINVAL;
1133 
1134 	return genpd->suspend_power_off ? 0 : pm_generic_freeze(dev);
1135 }
1136 
1137 /**
1138  * pm_genpd_freeze_late - Late freeze of a device in an I/O PM domain.
1139  * @dev: Device to freeze.
1140  *
1141  * Carry out a late freeze of a device under the assumption that its
1142  * pm_domain field points to the domain member of an object of type
1143  * struct generic_pm_domain representing a power domain consisting of I/O
1144  * devices.
1145  */
1146 static int pm_genpd_freeze_late(struct device *dev)
1147 {
1148 	struct generic_pm_domain *genpd;
1149 
1150 	dev_dbg(dev, "%s()\n", __func__);
1151 
1152 	genpd = dev_to_genpd(dev);
1153 	if (IS_ERR(genpd))
1154 		return -EINVAL;
1155 
1156 	return genpd->suspend_power_off ? 0 : pm_generic_freeze_late(dev);
1157 }
1158 
1159 /**
1160  * pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain.
1161  * @dev: Device to freeze.
1162  *
1163  * Carry out a late freeze of a device under the assumption that its
1164  * pm_domain field points to the domain member of an object of type
1165  * struct generic_pm_domain representing a power domain consisting of I/O
1166  * devices.
1167  */
1168 static int pm_genpd_freeze_noirq(struct device *dev)
1169 {
1170 	struct generic_pm_domain *genpd;
1171 
1172 	dev_dbg(dev, "%s()\n", __func__);
1173 
1174 	genpd = dev_to_genpd(dev);
1175 	if (IS_ERR(genpd))
1176 		return -EINVAL;
1177 
1178 	return genpd->suspend_power_off ? 0 : genpd_stop_dev(genpd, dev);
1179 }
1180 
1181 /**
1182  * pm_genpd_thaw_noirq - Early thaw of device in an I/O PM domain.
1183  * @dev: Device to thaw.
1184  *
1185  * Start the device, unless power has been removed from the domain already
1186  * before the system transition.
1187  */
1188 static int pm_genpd_thaw_noirq(struct device *dev)
1189 {
1190 	struct generic_pm_domain *genpd;
1191 
1192 	dev_dbg(dev, "%s()\n", __func__);
1193 
1194 	genpd = dev_to_genpd(dev);
1195 	if (IS_ERR(genpd))
1196 		return -EINVAL;
1197 
1198 	return genpd->suspend_power_off ? 0 : genpd_start_dev(genpd, dev);
1199 }
1200 
1201 /**
1202  * pm_genpd_thaw_early - Early thaw of device in an I/O PM domain.
1203  * @dev: Device to thaw.
1204  *
1205  * Carry out an early thaw of a device under the assumption that its
1206  * pm_domain field points to the domain member of an object of type
1207  * struct generic_pm_domain representing a power domain consisting of I/O
1208  * devices.
1209  */
1210 static int pm_genpd_thaw_early(struct device *dev)
1211 {
1212 	struct generic_pm_domain *genpd;
1213 
1214 	dev_dbg(dev, "%s()\n", __func__);
1215 
1216 	genpd = dev_to_genpd(dev);
1217 	if (IS_ERR(genpd))
1218 		return -EINVAL;
1219 
1220 	return genpd->suspend_power_off ? 0 : pm_generic_thaw_early(dev);
1221 }
1222 
1223 /**
1224  * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
1225  * @dev: Device to thaw.
1226  *
1227  * Thaw a device under the assumption that its pm_domain field points to the
1228  * domain member of an object of type struct generic_pm_domain representing
1229  * a power domain consisting of I/O devices.
1230  */
1231 static int pm_genpd_thaw(struct device *dev)
1232 {
1233 	struct generic_pm_domain *genpd;
1234 
1235 	dev_dbg(dev, "%s()\n", __func__);
1236 
1237 	genpd = dev_to_genpd(dev);
1238 	if (IS_ERR(genpd))
1239 		return -EINVAL;
1240 
1241 	return genpd->suspend_power_off ? 0 : pm_generic_thaw(dev);
1242 }
1243 
1244 /**
1245  * pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain.
1246  * @dev: Device to resume.
1247  *
1248  * Make sure the domain will be in the same power state as before the
1249  * hibernation the system is resuming from and start the device if necessary.
1250  */
1251 static int pm_genpd_restore_noirq(struct device *dev)
1252 {
1253 	struct generic_pm_domain *genpd;
1254 
1255 	dev_dbg(dev, "%s()\n", __func__);
1256 
1257 	genpd = dev_to_genpd(dev);
1258 	if (IS_ERR(genpd))
1259 		return -EINVAL;
1260 
1261 	/*
1262 	 * Since all of the "noirq" callbacks are executed sequentially, it is
1263 	 * guaranteed that this function will never run twice in parallel for
1264 	 * the same PM domain, so it is not necessary to use locking here.
1265 	 *
1266 	 * At this point suspended_count == 0 means we are being run for the
1267 	 * first time for the given domain in the present cycle.
1268 	 */
1269 	if (genpd->suspended_count++ == 0) {
1270 		/*
1271 		 * The boot kernel might put the domain into arbitrary state,
1272 		 * so make it appear as powered off to pm_genpd_sync_poweron(),
1273 		 * so that it tries to power it on in case it was really off.
1274 		 */
1275 		genpd->status = GPD_STATE_POWER_OFF;
1276 		if (genpd->suspend_power_off) {
1277 			/*
1278 			 * If the domain was off before the hibernation, make
1279 			 * sure it will be off going forward.
1280 			 */
1281 			genpd_power_off(genpd);
1282 
1283 			return 0;
1284 		}
1285 	}
1286 
1287 	if (genpd->suspend_power_off)
1288 		return 0;
1289 
1290 	pm_genpd_sync_poweron(genpd);
1291 
1292 	return genpd_start_dev(genpd, dev);
1293 }
1294 
1295 /**
1296  * pm_genpd_complete - Complete power transition of a device in a power domain.
1297  * @dev: Device to complete the transition of.
1298  *
1299  * Complete a power transition of a device (during a system-wide power
1300  * transition) under the assumption that its pm_domain field points to the
1301  * domain member of an object of type struct generic_pm_domain representing
1302  * a power domain consisting of I/O devices.
1303  */
1304 static void pm_genpd_complete(struct device *dev)
1305 {
1306 	struct generic_pm_domain *genpd;
1307 	bool run_complete;
1308 
1309 	dev_dbg(dev, "%s()\n", __func__);
1310 
1311 	genpd = dev_to_genpd(dev);
1312 	if (IS_ERR(genpd))
1313 		return;
1314 
1315 	mutex_lock(&genpd->lock);
1316 
1317 	run_complete = !genpd->suspend_power_off;
1318 	if (--genpd->prepared_count == 0)
1319 		genpd->suspend_power_off = false;
1320 
1321 	mutex_unlock(&genpd->lock);
1322 
1323 	if (run_complete) {
1324 		pm_generic_complete(dev);
1325 		pm_runtime_set_active(dev);
1326 		pm_runtime_enable(dev);
1327 		pm_request_idle(dev);
1328 	}
1329 }
1330 
1331 /**
1332  * genpd_syscore_switch - Switch power during system core suspend or resume.
1333  * @dev: Device that normally is marked as "always on" to switch power for.
1334  *
1335  * This routine may only be called during the system core (syscore) suspend or
1336  * resume phase for devices whose "always on" flags are set.
1337  */
1338 static void genpd_syscore_switch(struct device *dev, bool suspend)
1339 {
1340 	struct generic_pm_domain *genpd;
1341 
1342 	genpd = dev_to_genpd(dev);
1343 	if (!pm_genpd_present(genpd))
1344 		return;
1345 
1346 	if (suspend) {
1347 		genpd->suspended_count++;
1348 		pm_genpd_sync_poweroff(genpd);
1349 	} else {
1350 		pm_genpd_sync_poweron(genpd);
1351 		genpd->suspended_count--;
1352 	}
1353 }
1354 
1355 void pm_genpd_syscore_poweroff(struct device *dev)
1356 {
1357 	genpd_syscore_switch(dev, true);
1358 }
1359 EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff);
1360 
1361 void pm_genpd_syscore_poweron(struct device *dev)
1362 {
1363 	genpd_syscore_switch(dev, false);
1364 }
1365 EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron);
1366 
1367 #else /* !CONFIG_PM_SLEEP */
1368 
1369 #define pm_genpd_prepare		NULL
1370 #define pm_genpd_suspend		NULL
1371 #define pm_genpd_suspend_late		NULL
1372 #define pm_genpd_suspend_noirq		NULL
1373 #define pm_genpd_resume_early		NULL
1374 #define pm_genpd_resume_noirq		NULL
1375 #define pm_genpd_resume			NULL
1376 #define pm_genpd_freeze			NULL
1377 #define pm_genpd_freeze_late		NULL
1378 #define pm_genpd_freeze_noirq		NULL
1379 #define pm_genpd_thaw_early		NULL
1380 #define pm_genpd_thaw_noirq		NULL
1381 #define pm_genpd_thaw			NULL
1382 #define pm_genpd_restore_noirq		NULL
1383 #define pm_genpd_complete		NULL
1384 
1385 #endif /* CONFIG_PM_SLEEP */
1386 
1387 static struct generic_pm_domain_data *__pm_genpd_alloc_dev_data(struct device *dev)
1388 {
1389 	struct generic_pm_domain_data *gpd_data;
1390 
1391 	gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
1392 	if (!gpd_data)
1393 		return NULL;
1394 
1395 	mutex_init(&gpd_data->lock);
1396 	gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;
1397 	dev_pm_qos_add_notifier(dev, &gpd_data->nb);
1398 	return gpd_data;
1399 }
1400 
1401 static void __pm_genpd_free_dev_data(struct device *dev,
1402 				     struct generic_pm_domain_data *gpd_data)
1403 {
1404 	dev_pm_qos_remove_notifier(dev, &gpd_data->nb);
1405 	kfree(gpd_data);
1406 }
1407 
1408 /**
1409  * __pm_genpd_add_device - Add a device to an I/O PM domain.
1410  * @genpd: PM domain to add the device to.
1411  * @dev: Device to be added.
1412  * @td: Set of PM QoS timing parameters to attach to the device.
1413  */
1414 int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
1415 			  struct gpd_timing_data *td)
1416 {
1417 	struct generic_pm_domain_data *gpd_data_new, *gpd_data = NULL;
1418 	struct pm_domain_data *pdd;
1419 	int ret = 0;
1420 
1421 	dev_dbg(dev, "%s()\n", __func__);
1422 
1423 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1424 		return -EINVAL;
1425 
1426 	gpd_data_new = __pm_genpd_alloc_dev_data(dev);
1427 	if (!gpd_data_new)
1428 		return -ENOMEM;
1429 
1430 	genpd_acquire_lock(genpd);
1431 
1432 	if (genpd->prepared_count > 0) {
1433 		ret = -EAGAIN;
1434 		goto out;
1435 	}
1436 
1437 	list_for_each_entry(pdd, &genpd->dev_list, list_node)
1438 		if (pdd->dev == dev) {
1439 			ret = -EINVAL;
1440 			goto out;
1441 		}
1442 
1443 	ret = dev_pm_get_subsys_data(dev);
1444 	if (ret)
1445 		goto out;
1446 
1447 	genpd->device_count++;
1448 	genpd->max_off_time_changed = true;
1449 
1450 	spin_lock_irq(&dev->power.lock);
1451 
1452 	dev->pm_domain = &genpd->domain;
1453 	if (dev->power.subsys_data->domain_data) {
1454 		gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
1455 	} else {
1456 		gpd_data = gpd_data_new;
1457 		dev->power.subsys_data->domain_data = &gpd_data->base;
1458 	}
1459 	gpd_data->refcount++;
1460 	if (td)
1461 		gpd_data->td = *td;
1462 
1463 	spin_unlock_irq(&dev->power.lock);
1464 
1465 	if (genpd->attach_dev)
1466 		genpd->attach_dev(genpd, dev);
1467 
1468 	mutex_lock(&gpd_data->lock);
1469 	gpd_data->base.dev = dev;
1470 	list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
1471 	gpd_data->need_restore = -1;
1472 	gpd_data->td.constraint_changed = true;
1473 	gpd_data->td.effective_constraint_ns = -1;
1474 	mutex_unlock(&gpd_data->lock);
1475 
1476  out:
1477 	genpd_release_lock(genpd);
1478 
1479 	if (gpd_data != gpd_data_new)
1480 		__pm_genpd_free_dev_data(dev, gpd_data_new);
1481 
1482 	return ret;
1483 }
1484 
1485 /**
1486  * __pm_genpd_name_add_device - Find I/O PM domain and add a device to it.
1487  * @domain_name: Name of the PM domain to add the device to.
1488  * @dev: Device to be added.
1489  * @td: Set of PM QoS timing parameters to attach to the device.
1490  */
1491 int __pm_genpd_name_add_device(const char *domain_name, struct device *dev,
1492 			       struct gpd_timing_data *td)
1493 {
1494 	return __pm_genpd_add_device(pm_genpd_lookup_name(domain_name), dev, td);
1495 }
1496 
1497 /**
1498  * pm_genpd_remove_device - Remove a device from an I/O PM domain.
1499  * @genpd: PM domain to remove the device from.
1500  * @dev: Device to be removed.
1501  */
1502 int pm_genpd_remove_device(struct generic_pm_domain *genpd,
1503 			   struct device *dev)
1504 {
1505 	struct generic_pm_domain_data *gpd_data;
1506 	struct pm_domain_data *pdd;
1507 	bool remove = false;
1508 	int ret = 0;
1509 
1510 	dev_dbg(dev, "%s()\n", __func__);
1511 
1512 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)
1513 	    ||  IS_ERR_OR_NULL(dev->pm_domain)
1514 	    ||  pd_to_genpd(dev->pm_domain) != genpd)
1515 		return -EINVAL;
1516 
1517 	genpd_acquire_lock(genpd);
1518 
1519 	if (genpd->prepared_count > 0) {
1520 		ret = -EAGAIN;
1521 		goto out;
1522 	}
1523 
1524 	genpd->device_count--;
1525 	genpd->max_off_time_changed = true;
1526 
1527 	if (genpd->detach_dev)
1528 		genpd->detach_dev(genpd, dev);
1529 
1530 	spin_lock_irq(&dev->power.lock);
1531 
1532 	dev->pm_domain = NULL;
1533 	pdd = dev->power.subsys_data->domain_data;
1534 	list_del_init(&pdd->list_node);
1535 	gpd_data = to_gpd_data(pdd);
1536 	if (--gpd_data->refcount == 0) {
1537 		dev->power.subsys_data->domain_data = NULL;
1538 		remove = true;
1539 	}
1540 
1541 	spin_unlock_irq(&dev->power.lock);
1542 
1543 	mutex_lock(&gpd_data->lock);
1544 	pdd->dev = NULL;
1545 	mutex_unlock(&gpd_data->lock);
1546 
1547 	genpd_release_lock(genpd);
1548 
1549 	dev_pm_put_subsys_data(dev);
1550 	if (remove)
1551 		__pm_genpd_free_dev_data(dev, gpd_data);
1552 
1553 	return 0;
1554 
1555  out:
1556 	genpd_release_lock(genpd);
1557 
1558 	return ret;
1559 }
1560 
1561 /**
1562  * pm_genpd_dev_need_restore - Set/unset the device's "need restore" flag.
1563  * @dev: Device to set/unset the flag for.
1564  * @val: The new value of the device's "need restore" flag.
1565  */
1566 void pm_genpd_dev_need_restore(struct device *dev, bool val)
1567 {
1568 	struct pm_subsys_data *psd;
1569 	unsigned long flags;
1570 
1571 	spin_lock_irqsave(&dev->power.lock, flags);
1572 
1573 	psd = dev_to_psd(dev);
1574 	if (psd && psd->domain_data)
1575 		to_gpd_data(psd->domain_data)->need_restore = val ? 1 : 0;
1576 
1577 	spin_unlock_irqrestore(&dev->power.lock, flags);
1578 }
1579 EXPORT_SYMBOL_GPL(pm_genpd_dev_need_restore);
1580 
1581 /**
1582  * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
1583  * @genpd: Master PM domain to add the subdomain to.
1584  * @subdomain: Subdomain to be added.
1585  */
1586 int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
1587 			   struct generic_pm_domain *subdomain)
1588 {
1589 	struct gpd_link *link;
1590 	int ret = 0;
1591 
1592 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)
1593 	    || genpd == subdomain)
1594 		return -EINVAL;
1595 
1596  start:
1597 	genpd_acquire_lock(genpd);
1598 	mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1599 
1600 	if (subdomain->status != GPD_STATE_POWER_OFF
1601 	    && subdomain->status != GPD_STATE_ACTIVE) {
1602 		mutex_unlock(&subdomain->lock);
1603 		genpd_release_lock(genpd);
1604 		goto start;
1605 	}
1606 
1607 	if (genpd->status == GPD_STATE_POWER_OFF
1608 	    &&  subdomain->status != GPD_STATE_POWER_OFF) {
1609 		ret = -EINVAL;
1610 		goto out;
1611 	}
1612 
1613 	list_for_each_entry(link, &genpd->master_links, master_node) {
1614 		if (link->slave == subdomain && link->master == genpd) {
1615 			ret = -EINVAL;
1616 			goto out;
1617 		}
1618 	}
1619 
1620 	link = kzalloc(sizeof(*link), GFP_KERNEL);
1621 	if (!link) {
1622 		ret = -ENOMEM;
1623 		goto out;
1624 	}
1625 	link->master = genpd;
1626 	list_add_tail(&link->master_node, &genpd->master_links);
1627 	link->slave = subdomain;
1628 	list_add_tail(&link->slave_node, &subdomain->slave_links);
1629 	if (subdomain->status != GPD_STATE_POWER_OFF)
1630 		genpd_sd_counter_inc(genpd);
1631 
1632  out:
1633 	mutex_unlock(&subdomain->lock);
1634 	genpd_release_lock(genpd);
1635 
1636 	return ret;
1637 }
1638 
1639 /**
1640  * pm_genpd_add_subdomain_names - Add a subdomain to an I/O PM domain.
1641  * @master_name: Name of the master PM domain to add the subdomain to.
1642  * @subdomain_name: Name of the subdomain to be added.
1643  */
1644 int pm_genpd_add_subdomain_names(const char *master_name,
1645 				 const char *subdomain_name)
1646 {
1647 	struct generic_pm_domain *master = NULL, *subdomain = NULL, *gpd;
1648 
1649 	if (IS_ERR_OR_NULL(master_name) || IS_ERR_OR_NULL(subdomain_name))
1650 		return -EINVAL;
1651 
1652 	mutex_lock(&gpd_list_lock);
1653 	list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
1654 		if (!master && !strcmp(gpd->name, master_name))
1655 			master = gpd;
1656 
1657 		if (!subdomain && !strcmp(gpd->name, subdomain_name))
1658 			subdomain = gpd;
1659 
1660 		if (master && subdomain)
1661 			break;
1662 	}
1663 	mutex_unlock(&gpd_list_lock);
1664 
1665 	return pm_genpd_add_subdomain(master, subdomain);
1666 }
1667 
1668 /**
1669  * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
1670  * @genpd: Master PM domain to remove the subdomain from.
1671  * @subdomain: Subdomain to be removed.
1672  */
1673 int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
1674 			      struct generic_pm_domain *subdomain)
1675 {
1676 	struct gpd_link *link;
1677 	int ret = -EINVAL;
1678 
1679 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1680 		return -EINVAL;
1681 
1682  start:
1683 	genpd_acquire_lock(genpd);
1684 
1685 	list_for_each_entry(link, &genpd->master_links, master_node) {
1686 		if (link->slave != subdomain)
1687 			continue;
1688 
1689 		mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1690 
1691 		if (subdomain->status != GPD_STATE_POWER_OFF
1692 		    && subdomain->status != GPD_STATE_ACTIVE) {
1693 			mutex_unlock(&subdomain->lock);
1694 			genpd_release_lock(genpd);
1695 			goto start;
1696 		}
1697 
1698 		list_del(&link->master_node);
1699 		list_del(&link->slave_node);
1700 		kfree(link);
1701 		if (subdomain->status != GPD_STATE_POWER_OFF)
1702 			genpd_sd_counter_dec(genpd);
1703 
1704 		mutex_unlock(&subdomain->lock);
1705 
1706 		ret = 0;
1707 		break;
1708 	}
1709 
1710 	genpd_release_lock(genpd);
1711 
1712 	return ret;
1713 }
1714 
1715 /**
1716  * pm_genpd_attach_cpuidle - Connect the given PM domain with cpuidle.
1717  * @genpd: PM domain to be connected with cpuidle.
1718  * @state: cpuidle state this domain can disable/enable.
1719  *
1720  * Make a PM domain behave as though it contained a CPU core, that is, instead
1721  * of calling its power down routine it will enable the given cpuidle state so
1722  * that the cpuidle subsystem can power it down (if possible and desirable).
1723  */
1724 int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state)
1725 {
1726 	struct cpuidle_driver *cpuidle_drv;
1727 	struct gpd_cpuidle_data *cpuidle_data;
1728 	struct cpuidle_state *idle_state;
1729 	int ret = 0;
1730 
1731 	if (IS_ERR_OR_NULL(genpd) || state < 0)
1732 		return -EINVAL;
1733 
1734 	genpd_acquire_lock(genpd);
1735 
1736 	if (genpd->cpuidle_data) {
1737 		ret = -EEXIST;
1738 		goto out;
1739 	}
1740 	cpuidle_data = kzalloc(sizeof(*cpuidle_data), GFP_KERNEL);
1741 	if (!cpuidle_data) {
1742 		ret = -ENOMEM;
1743 		goto out;
1744 	}
1745 	cpuidle_drv = cpuidle_driver_ref();
1746 	if (!cpuidle_drv) {
1747 		ret = -ENODEV;
1748 		goto err_drv;
1749 	}
1750 	if (cpuidle_drv->state_count <= state) {
1751 		ret = -EINVAL;
1752 		goto err;
1753 	}
1754 	idle_state = &cpuidle_drv->states[state];
1755 	if (!idle_state->disabled) {
1756 		ret = -EAGAIN;
1757 		goto err;
1758 	}
1759 	cpuidle_data->idle_state = idle_state;
1760 	cpuidle_data->saved_exit_latency = idle_state->exit_latency;
1761 	genpd->cpuidle_data = cpuidle_data;
1762 	genpd_recalc_cpu_exit_latency(genpd);
1763 
1764  out:
1765 	genpd_release_lock(genpd);
1766 	return ret;
1767 
1768  err:
1769 	cpuidle_driver_unref();
1770 
1771  err_drv:
1772 	kfree(cpuidle_data);
1773 	goto out;
1774 }
1775 
1776 /**
1777  * pm_genpd_name_attach_cpuidle - Find PM domain and connect cpuidle to it.
1778  * @name: Name of the domain to connect to cpuidle.
1779  * @state: cpuidle state this domain can manipulate.
1780  */
1781 int pm_genpd_name_attach_cpuidle(const char *name, int state)
1782 {
1783 	return pm_genpd_attach_cpuidle(pm_genpd_lookup_name(name), state);
1784 }
1785 
1786 /**
1787  * pm_genpd_detach_cpuidle - Remove the cpuidle connection from a PM domain.
1788  * @genpd: PM domain to remove the cpuidle connection from.
1789  *
1790  * Remove the cpuidle connection set up by pm_genpd_attach_cpuidle() from the
1791  * given PM domain.
1792  */
1793 int pm_genpd_detach_cpuidle(struct generic_pm_domain *genpd)
1794 {
1795 	struct gpd_cpuidle_data *cpuidle_data;
1796 	struct cpuidle_state *idle_state;
1797 	int ret = 0;
1798 
1799 	if (IS_ERR_OR_NULL(genpd))
1800 		return -EINVAL;
1801 
1802 	genpd_acquire_lock(genpd);
1803 
1804 	cpuidle_data = genpd->cpuidle_data;
1805 	if (!cpuidle_data) {
1806 		ret = -ENODEV;
1807 		goto out;
1808 	}
1809 	idle_state = cpuidle_data->idle_state;
1810 	if (!idle_state->disabled) {
1811 		ret = -EAGAIN;
1812 		goto out;
1813 	}
1814 	idle_state->exit_latency = cpuidle_data->saved_exit_latency;
1815 	cpuidle_driver_unref();
1816 	genpd->cpuidle_data = NULL;
1817 	kfree(cpuidle_data);
1818 
1819  out:
1820 	genpd_release_lock(genpd);
1821 	return ret;
1822 }
1823 
1824 /**
1825  * pm_genpd_name_detach_cpuidle - Find PM domain and disconnect cpuidle from it.
1826  * @name: Name of the domain to disconnect cpuidle from.
1827  */
1828 int pm_genpd_name_detach_cpuidle(const char *name)
1829 {
1830 	return pm_genpd_detach_cpuidle(pm_genpd_lookup_name(name));
1831 }
1832 
1833 /* Default device callbacks for generic PM domains. */
1834 
1835 /**
1836  * pm_genpd_default_save_state - Default "save device state" for PM domains.
1837  * @dev: Device to handle.
1838  */
1839 static int pm_genpd_default_save_state(struct device *dev)
1840 {
1841 	int (*cb)(struct device *__dev);
1842 
1843 	if (dev->type && dev->type->pm)
1844 		cb = dev->type->pm->runtime_suspend;
1845 	else if (dev->class && dev->class->pm)
1846 		cb = dev->class->pm->runtime_suspend;
1847 	else if (dev->bus && dev->bus->pm)
1848 		cb = dev->bus->pm->runtime_suspend;
1849 	else
1850 		cb = NULL;
1851 
1852 	if (!cb && dev->driver && dev->driver->pm)
1853 		cb = dev->driver->pm->runtime_suspend;
1854 
1855 	return cb ? cb(dev) : 0;
1856 }
1857 
1858 /**
1859  * pm_genpd_default_restore_state - Default PM domains "restore device state".
1860  * @dev: Device to handle.
1861  */
1862 static int pm_genpd_default_restore_state(struct device *dev)
1863 {
1864 	int (*cb)(struct device *__dev);
1865 
1866 	if (dev->type && dev->type->pm)
1867 		cb = dev->type->pm->runtime_resume;
1868 	else if (dev->class && dev->class->pm)
1869 		cb = dev->class->pm->runtime_resume;
1870 	else if (dev->bus && dev->bus->pm)
1871 		cb = dev->bus->pm->runtime_resume;
1872 	else
1873 		cb = NULL;
1874 
1875 	if (!cb && dev->driver && dev->driver->pm)
1876 		cb = dev->driver->pm->runtime_resume;
1877 
1878 	return cb ? cb(dev) : 0;
1879 }
1880 
1881 /**
1882  * pm_genpd_init - Initialize a generic I/O PM domain object.
1883  * @genpd: PM domain object to initialize.
1884  * @gov: PM domain governor to associate with the domain (may be NULL).
1885  * @is_off: Initial value of the domain's power_is_off field.
1886  */
1887 void pm_genpd_init(struct generic_pm_domain *genpd,
1888 		   struct dev_power_governor *gov, bool is_off)
1889 {
1890 	if (IS_ERR_OR_NULL(genpd))
1891 		return;
1892 
1893 	INIT_LIST_HEAD(&genpd->master_links);
1894 	INIT_LIST_HEAD(&genpd->slave_links);
1895 	INIT_LIST_HEAD(&genpd->dev_list);
1896 	mutex_init(&genpd->lock);
1897 	genpd->gov = gov;
1898 	INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
1899 	genpd->in_progress = 0;
1900 	atomic_set(&genpd->sd_count, 0);
1901 	genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
1902 	init_waitqueue_head(&genpd->status_wait_queue);
1903 	genpd->poweroff_task = NULL;
1904 	genpd->resume_count = 0;
1905 	genpd->device_count = 0;
1906 	genpd->max_off_time_ns = -1;
1907 	genpd->max_off_time_changed = true;
1908 	genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
1909 	genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
1910 	genpd->domain.ops.prepare = pm_genpd_prepare;
1911 	genpd->domain.ops.suspend = pm_genpd_suspend;
1912 	genpd->domain.ops.suspend_late = pm_genpd_suspend_late;
1913 	genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
1914 	genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
1915 	genpd->domain.ops.resume_early = pm_genpd_resume_early;
1916 	genpd->domain.ops.resume = pm_genpd_resume;
1917 	genpd->domain.ops.freeze = pm_genpd_freeze;
1918 	genpd->domain.ops.freeze_late = pm_genpd_freeze_late;
1919 	genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
1920 	genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
1921 	genpd->domain.ops.thaw_early = pm_genpd_thaw_early;
1922 	genpd->domain.ops.thaw = pm_genpd_thaw;
1923 	genpd->domain.ops.poweroff = pm_genpd_suspend;
1924 	genpd->domain.ops.poweroff_late = pm_genpd_suspend_late;
1925 	genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq;
1926 	genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
1927 	genpd->domain.ops.restore_early = pm_genpd_resume_early;
1928 	genpd->domain.ops.restore = pm_genpd_resume;
1929 	genpd->domain.ops.complete = pm_genpd_complete;
1930 	genpd->dev_ops.save_state = pm_genpd_default_save_state;
1931 	genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
1932 
1933 	if (genpd->flags & GENPD_FLAG_PM_CLK) {
1934 		genpd->dev_ops.stop = pm_clk_suspend;
1935 		genpd->dev_ops.start = pm_clk_resume;
1936 	}
1937 
1938 	mutex_lock(&gpd_list_lock);
1939 	list_add(&genpd->gpd_list_node, &gpd_list);
1940 	mutex_unlock(&gpd_list_lock);
1941 }
1942 
1943 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
1944 /*
1945  * Device Tree based PM domain providers.
1946  *
1947  * The code below implements generic device tree based PM domain providers that
1948  * bind device tree nodes with generic PM domains registered in the system.
1949  *
1950  * Any driver that registers generic PM domains and needs to support binding of
1951  * devices to these domains is supposed to register a PM domain provider, which
1952  * maps a PM domain specifier retrieved from the device tree to a PM domain.
1953  *
1954  * Two simple mapping functions have been provided for convenience:
1955  *  - __of_genpd_xlate_simple() for 1:1 device tree node to PM domain mapping.
1956  *  - __of_genpd_xlate_onecell() for mapping of multiple PM domains per node by
1957  *    index.
1958  */
1959 
1960 /**
1961  * struct of_genpd_provider - PM domain provider registration structure
1962  * @link: Entry in global list of PM domain providers
1963  * @node: Pointer to device tree node of PM domain provider
1964  * @xlate: Provider-specific xlate callback mapping a set of specifier cells
1965  *         into a PM domain.
1966  * @data: context pointer to be passed into @xlate callback
1967  */
1968 struct of_genpd_provider {
1969 	struct list_head link;
1970 	struct device_node *node;
1971 	genpd_xlate_t xlate;
1972 	void *data;
1973 };
1974 
1975 /* List of registered PM domain providers. */
1976 static LIST_HEAD(of_genpd_providers);
1977 /* Mutex to protect the list above. */
1978 static DEFINE_MUTEX(of_genpd_mutex);
1979 
1980 /**
1981  * __of_genpd_xlate_simple() - Xlate function for direct node-domain mapping
1982  * @genpdspec: OF phandle args to map into a PM domain
1983  * @data: xlate function private data - pointer to struct generic_pm_domain
1984  *
1985  * This is a generic xlate function that can be used to model PM domains that
1986  * have their own device tree nodes. The private data of xlate function needs
1987  * to be a valid pointer to struct generic_pm_domain.
1988  */
1989 struct generic_pm_domain *__of_genpd_xlate_simple(
1990 					struct of_phandle_args *genpdspec,
1991 					void *data)
1992 {
1993 	if (genpdspec->args_count != 0)
1994 		return ERR_PTR(-EINVAL);
1995 	return data;
1996 }
1997 EXPORT_SYMBOL_GPL(__of_genpd_xlate_simple);
1998 
1999 /**
2000  * __of_genpd_xlate_onecell() - Xlate function using a single index.
2001  * @genpdspec: OF phandle args to map into a PM domain
2002  * @data: xlate function private data - pointer to struct genpd_onecell_data
2003  *
2004  * This is a generic xlate function that can be used to model simple PM domain
2005  * controllers that have one device tree node and provide multiple PM domains.
2006  * A single cell is used as an index into an array of PM domains specified in
2007  * the genpd_onecell_data struct when registering the provider.
2008  */
2009 struct generic_pm_domain *__of_genpd_xlate_onecell(
2010 					struct of_phandle_args *genpdspec,
2011 					void *data)
2012 {
2013 	struct genpd_onecell_data *genpd_data = data;
2014 	unsigned int idx = genpdspec->args[0];
2015 
2016 	if (genpdspec->args_count != 1)
2017 		return ERR_PTR(-EINVAL);
2018 
2019 	if (idx >= genpd_data->num_domains) {
2020 		pr_err("%s: invalid domain index %u\n", __func__, idx);
2021 		return ERR_PTR(-EINVAL);
2022 	}
2023 
2024 	if (!genpd_data->domains[idx])
2025 		return ERR_PTR(-ENOENT);
2026 
2027 	return genpd_data->domains[idx];
2028 }
2029 EXPORT_SYMBOL_GPL(__of_genpd_xlate_onecell);
2030 
2031 /**
2032  * __of_genpd_add_provider() - Register a PM domain provider for a node
2033  * @np: Device node pointer associated with the PM domain provider.
2034  * @xlate: Callback for decoding PM domain from phandle arguments.
2035  * @data: Context pointer for @xlate callback.
2036  */
2037 int __of_genpd_add_provider(struct device_node *np, genpd_xlate_t xlate,
2038 			void *data)
2039 {
2040 	struct of_genpd_provider *cp;
2041 
2042 	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
2043 	if (!cp)
2044 		return -ENOMEM;
2045 
2046 	cp->node = of_node_get(np);
2047 	cp->data = data;
2048 	cp->xlate = xlate;
2049 
2050 	mutex_lock(&of_genpd_mutex);
2051 	list_add(&cp->link, &of_genpd_providers);
2052 	mutex_unlock(&of_genpd_mutex);
2053 	pr_debug("Added domain provider from %s\n", np->full_name);
2054 
2055 	return 0;
2056 }
2057 EXPORT_SYMBOL_GPL(__of_genpd_add_provider);
2058 
2059 /**
2060  * of_genpd_del_provider() - Remove a previously registered PM domain provider
2061  * @np: Device node pointer associated with the PM domain provider
2062  */
2063 void of_genpd_del_provider(struct device_node *np)
2064 {
2065 	struct of_genpd_provider *cp;
2066 
2067 	mutex_lock(&of_genpd_mutex);
2068 	list_for_each_entry(cp, &of_genpd_providers, link) {
2069 		if (cp->node == np) {
2070 			list_del(&cp->link);
2071 			of_node_put(cp->node);
2072 			kfree(cp);
2073 			break;
2074 		}
2075 	}
2076 	mutex_unlock(&of_genpd_mutex);
2077 }
2078 EXPORT_SYMBOL_GPL(of_genpd_del_provider);
2079 
2080 /**
2081  * of_genpd_get_from_provider() - Look-up PM domain
2082  * @genpdspec: OF phandle args to use for look-up
2083  *
2084  * Looks for a PM domain provider under the node specified by @genpdspec and if
2085  * found, uses xlate function of the provider to map phandle args to a PM
2086  * domain.
2087  *
2088  * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR()
2089  * on failure.
2090  */
2091 struct generic_pm_domain *of_genpd_get_from_provider(
2092 					struct of_phandle_args *genpdspec)
2093 {
2094 	struct generic_pm_domain *genpd = ERR_PTR(-ENOENT);
2095 	struct of_genpd_provider *provider;
2096 
2097 	mutex_lock(&of_genpd_mutex);
2098 
2099 	/* Check if we have such a provider in our array */
2100 	list_for_each_entry(provider, &of_genpd_providers, link) {
2101 		if (provider->node == genpdspec->np)
2102 			genpd = provider->xlate(genpdspec, provider->data);
2103 		if (!IS_ERR(genpd))
2104 			break;
2105 	}
2106 
2107 	mutex_unlock(&of_genpd_mutex);
2108 
2109 	return genpd;
2110 }
2111 EXPORT_SYMBOL_GPL(of_genpd_get_from_provider);
2112 
2113 /**
2114  * genpd_dev_pm_detach - Detach a device from its PM domain.
2115  * @dev: Device to attach.
2116  * @power_off: Currently not used
2117  *
2118  * Try to locate a corresponding generic PM domain, which the device was
2119  * attached to previously. If such is found, the device is detached from it.
2120  */
2121 static void genpd_dev_pm_detach(struct device *dev, bool power_off)
2122 {
2123 	struct generic_pm_domain *pd = NULL, *gpd;
2124 	int ret = 0;
2125 
2126 	if (!dev->pm_domain)
2127 		return;
2128 
2129 	mutex_lock(&gpd_list_lock);
2130 	list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
2131 		if (&gpd->domain == dev->pm_domain) {
2132 			pd = gpd;
2133 			break;
2134 		}
2135 	}
2136 	mutex_unlock(&gpd_list_lock);
2137 
2138 	if (!pd)
2139 		return;
2140 
2141 	dev_dbg(dev, "removing from PM domain %s\n", pd->name);
2142 
2143 	while (1) {
2144 		ret = pm_genpd_remove_device(pd, dev);
2145 		if (ret != -EAGAIN)
2146 			break;
2147 		cond_resched();
2148 	}
2149 
2150 	if (ret < 0) {
2151 		dev_err(dev, "failed to remove from PM domain %s: %d",
2152 			pd->name, ret);
2153 		return;
2154 	}
2155 
2156 	/* Check if PM domain can be powered off after removing this device. */
2157 	genpd_queue_power_off_work(pd);
2158 }
2159 
2160 /**
2161  * genpd_dev_pm_attach - Attach a device to its PM domain using DT.
2162  * @dev: Device to attach.
2163  *
2164  * Parse device's OF node to find a PM domain specifier. If such is found,
2165  * attaches the device to retrieved pm_domain ops.
2166  *
2167  * Both generic and legacy Samsung-specific DT bindings are supported to keep
2168  * backwards compatibility with existing DTBs.
2169  *
2170  * Returns 0 on successfully attached PM domain or negative error code.
2171  */
2172 int genpd_dev_pm_attach(struct device *dev)
2173 {
2174 	struct of_phandle_args pd_args;
2175 	struct generic_pm_domain *pd;
2176 	int ret;
2177 
2178 	if (!dev->of_node)
2179 		return -ENODEV;
2180 
2181 	if (dev->pm_domain)
2182 		return -EEXIST;
2183 
2184 	ret = of_parse_phandle_with_args(dev->of_node, "power-domains",
2185 					"#power-domain-cells", 0, &pd_args);
2186 	if (ret < 0) {
2187 		if (ret != -ENOENT)
2188 			return ret;
2189 
2190 		/*
2191 		 * Try legacy Samsung-specific bindings
2192 		 * (for backwards compatibility of DT ABI)
2193 		 */
2194 		pd_args.args_count = 0;
2195 		pd_args.np = of_parse_phandle(dev->of_node,
2196 						"samsung,power-domain", 0);
2197 		if (!pd_args.np)
2198 			return -ENOENT;
2199 	}
2200 
2201 	pd = of_genpd_get_from_provider(&pd_args);
2202 	if (IS_ERR(pd)) {
2203 		dev_dbg(dev, "%s() failed to find PM domain: %ld\n",
2204 			__func__, PTR_ERR(pd));
2205 		of_node_put(dev->of_node);
2206 		return PTR_ERR(pd);
2207 	}
2208 
2209 	dev_dbg(dev, "adding to PM domain %s\n", pd->name);
2210 
2211 	while (1) {
2212 		ret = pm_genpd_add_device(pd, dev);
2213 		if (ret != -EAGAIN)
2214 			break;
2215 		cond_resched();
2216 	}
2217 
2218 	if (ret < 0) {
2219 		dev_err(dev, "failed to add to PM domain %s: %d",
2220 			pd->name, ret);
2221 		of_node_put(dev->of_node);
2222 		return ret;
2223 	}
2224 
2225 	dev->pm_domain->detach = genpd_dev_pm_detach;
2226 	pm_genpd_poweron(pd);
2227 
2228 	return 0;
2229 }
2230 EXPORT_SYMBOL_GPL(genpd_dev_pm_attach);
2231 #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
2232 
2233 
2234 /***        debugfs support        ***/
2235 
2236 #ifdef CONFIG_PM_ADVANCED_DEBUG
2237 #include <linux/pm.h>
2238 #include <linux/device.h>
2239 #include <linux/debugfs.h>
2240 #include <linux/seq_file.h>
2241 #include <linux/init.h>
2242 #include <linux/kobject.h>
2243 static struct dentry *pm_genpd_debugfs_dir;
2244 
2245 /*
2246  * TODO: This function is a slightly modified version of rtpm_status_show
2247  * from sysfs.c, so generalize it.
2248  */
2249 static void rtpm_status_str(struct seq_file *s, struct device *dev)
2250 {
2251 	static const char * const status_lookup[] = {
2252 		[RPM_ACTIVE] = "active",
2253 		[RPM_RESUMING] = "resuming",
2254 		[RPM_SUSPENDED] = "suspended",
2255 		[RPM_SUSPENDING] = "suspending"
2256 	};
2257 	const char *p = "";
2258 
2259 	if (dev->power.runtime_error)
2260 		p = "error";
2261 	else if (dev->power.disable_depth)
2262 		p = "unsupported";
2263 	else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup))
2264 		p = status_lookup[dev->power.runtime_status];
2265 	else
2266 		WARN_ON(1);
2267 
2268 	seq_puts(s, p);
2269 }
2270 
2271 static int pm_genpd_summary_one(struct seq_file *s,
2272 		struct generic_pm_domain *gpd)
2273 {
2274 	static const char * const status_lookup[] = {
2275 		[GPD_STATE_ACTIVE] = "on",
2276 		[GPD_STATE_WAIT_MASTER] = "wait-master",
2277 		[GPD_STATE_BUSY] = "busy",
2278 		[GPD_STATE_REPEAT] = "off-in-progress",
2279 		[GPD_STATE_POWER_OFF] = "off"
2280 	};
2281 	struct pm_domain_data *pm_data;
2282 	const char *kobj_path;
2283 	struct gpd_link *link;
2284 	int ret;
2285 
2286 	ret = mutex_lock_interruptible(&gpd->lock);
2287 	if (ret)
2288 		return -ERESTARTSYS;
2289 
2290 	if (WARN_ON(gpd->status >= ARRAY_SIZE(status_lookup)))
2291 		goto exit;
2292 	seq_printf(s, "%-30s  %-15s  ", gpd->name, status_lookup[gpd->status]);
2293 
2294 	/*
2295 	 * Modifications on the list require holding locks on both
2296 	 * master and slave, so we are safe.
2297 	 * Also gpd->name is immutable.
2298 	 */
2299 	list_for_each_entry(link, &gpd->master_links, master_node) {
2300 		seq_printf(s, "%s", link->slave->name);
2301 		if (!list_is_last(&link->master_node, &gpd->master_links))
2302 			seq_puts(s, ", ");
2303 	}
2304 
2305 	list_for_each_entry(pm_data, &gpd->dev_list, list_node) {
2306 		kobj_path = kobject_get_path(&pm_data->dev->kobj, GFP_KERNEL);
2307 		if (kobj_path == NULL)
2308 			continue;
2309 
2310 		seq_printf(s, "\n    %-50s  ", kobj_path);
2311 		rtpm_status_str(s, pm_data->dev);
2312 		kfree(kobj_path);
2313 	}
2314 
2315 	seq_puts(s, "\n");
2316 exit:
2317 	mutex_unlock(&gpd->lock);
2318 
2319 	return 0;
2320 }
2321 
2322 static int pm_genpd_summary_show(struct seq_file *s, void *data)
2323 {
2324 	struct generic_pm_domain *gpd;
2325 	int ret = 0;
2326 
2327 	seq_puts(s, "    domain                      status         slaves\n");
2328 	seq_puts(s, "           /device                                      runtime status\n");
2329 	seq_puts(s, "----------------------------------------------------------------------\n");
2330 
2331 	ret = mutex_lock_interruptible(&gpd_list_lock);
2332 	if (ret)
2333 		return -ERESTARTSYS;
2334 
2335 	list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
2336 		ret = pm_genpd_summary_one(s, gpd);
2337 		if (ret)
2338 			break;
2339 	}
2340 	mutex_unlock(&gpd_list_lock);
2341 
2342 	return ret;
2343 }
2344 
2345 static int pm_genpd_summary_open(struct inode *inode, struct file *file)
2346 {
2347 	return single_open(file, pm_genpd_summary_show, NULL);
2348 }
2349 
2350 static const struct file_operations pm_genpd_summary_fops = {
2351 	.open = pm_genpd_summary_open,
2352 	.read = seq_read,
2353 	.llseek = seq_lseek,
2354 	.release = single_release,
2355 };
2356 
2357 static int __init pm_genpd_debug_init(void)
2358 {
2359 	struct dentry *d;
2360 
2361 	pm_genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL);
2362 
2363 	if (!pm_genpd_debugfs_dir)
2364 		return -ENOMEM;
2365 
2366 	d = debugfs_create_file("pm_genpd_summary", S_IRUGO,
2367 			pm_genpd_debugfs_dir, NULL, &pm_genpd_summary_fops);
2368 	if (!d)
2369 		return -ENOMEM;
2370 
2371 	return 0;
2372 }
2373 late_initcall(pm_genpd_debug_init);
2374 
2375 static void __exit pm_genpd_debug_exit(void)
2376 {
2377 	debugfs_remove_recursive(pm_genpd_debugfs_dir);
2378 }
2379 __exitcall(pm_genpd_debug_exit);
2380 #endif /* CONFIG_PM_ADVANCED_DEBUG */
2381