domain.c 32.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * drivers/base/power/domain.c - Common code related to device power domains.
 *
 * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
 *
 * This file is released under the GPLv2.
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/pm_runtime.h>
#include <linux/pm_domain.h>
#include <linux/slab.h>
#include <linux/err.h>
16 17
#include <linux/sched.h>
#include <linux/suspend.h>
18

19 20 21
static LIST_HEAD(gpd_list);
static DEFINE_MUTEX(gpd_list_lock);

22 23 24 25 26 27 28
#ifdef CONFIG_PM

static struct generic_pm_domain *dev_to_genpd(struct device *dev)
{
	if (IS_ERR_OR_NULL(dev->pm_domain))
		return ERR_PTR(-EINVAL);

29
	return pd_to_genpd(dev->pm_domain);
30
}
31

32
static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
33
{
34 35 36 37 38 39 40 41 42 43 44 45
	bool ret = false;

	if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
		ret = !!atomic_dec_and_test(&genpd->sd_count);

	return ret;
}

static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
{
	atomic_inc(&genpd->sd_count);
	smp_mb__after_atomic_inc();
46 47
}

48 49 50 51 52 53 54 55 56 57 58 59
static void genpd_acquire_lock(struct generic_pm_domain *genpd)
{
	DEFINE_WAIT(wait);

	mutex_lock(&genpd->lock);
	/*
	 * Wait for the domain to transition into either the active,
	 * or the power off state.
	 */
	for (;;) {
		prepare_to_wait(&genpd->status_wait_queue, &wait,
				TASK_UNINTERRUPTIBLE);
60 61
		if (genpd->status == GPD_STATE_ACTIVE
		    || genpd->status == GPD_STATE_POWER_OFF)
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
			break;
		mutex_unlock(&genpd->lock);

		schedule();

		mutex_lock(&genpd->lock);
	}
	finish_wait(&genpd->status_wait_queue, &wait);
}

static void genpd_release_lock(struct generic_pm_domain *genpd)
{
	mutex_unlock(&genpd->lock);
}

77 78 79 80 81 82
static void genpd_set_active(struct generic_pm_domain *genpd)
{
	if (genpd->resume_count == 0)
		genpd->status = GPD_STATE_ACTIVE;
}

83
/**
84
 * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
85 86
 * @genpd: PM domain to power up.
 *
87
 * Restore power to @genpd and all of its masters so that it is possible to
88 89
 * resume a device belonging to it.
 */
90 91
int __pm_genpd_poweron(struct generic_pm_domain *genpd)
	__releases(&genpd->lock) __acquires(&genpd->lock)
92
{
93
	struct gpd_link *link;
94
	DEFINE_WAIT(wait);
95 96
	int ret = 0;

97
	/* If the domain's master is being waited for, we have to wait too. */
98 99 100
	for (;;) {
		prepare_to_wait(&genpd->status_wait_queue, &wait,
				TASK_UNINTERRUPTIBLE);
101
		if (genpd->status != GPD_STATE_WAIT_MASTER)
102 103
			break;
		mutex_unlock(&genpd->lock);
104

105 106 107 108 109
		schedule();

		mutex_lock(&genpd->lock);
	}
	finish_wait(&genpd->status_wait_queue, &wait);
110

111
	if (genpd->status == GPD_STATE_ACTIVE
112
	    || (genpd->prepared_count > 0 && genpd->suspend_power_off))
113
		return 0;
114

115 116
	if (genpd->status != GPD_STATE_POWER_OFF) {
		genpd_set_active(genpd);
117
		return 0;
118 119
	}

120 121 122 123 124 125 126
	/*
	 * The list is guaranteed not to change while the loop below is being
	 * executed, unless one of the masters' .power_on() callbacks fiddles
	 * with it.
	 */
	list_for_each_entry(link, &genpd->slave_links, slave_node) {
		genpd_sd_counter_inc(link->master);
127
		genpd->status = GPD_STATE_WAIT_MASTER;
128

129 130
		mutex_unlock(&genpd->lock);

131
		ret = pm_genpd_poweron(link->master);
132 133 134

		mutex_lock(&genpd->lock);

135 136
		/*
		 * The "wait for parent" status is guaranteed not to change
137
		 * while the master is powering on.
138 139 140
		 */
		genpd->status = GPD_STATE_POWER_OFF;
		wake_up_all(&genpd->status_wait_queue);
141 142
		if (ret) {
			genpd_sd_counter_dec(link->master);
143
			goto err;
144
		}
145 146
	}

147
	if (genpd->power_on) {
148
		ret = genpd->power_on(genpd);
149 150
		if (ret)
			goto err;
151
	}
152

153 154
	genpd_set_active(genpd);

155
	return 0;
156 157

 err:
158 159
	list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
		genpd_sd_counter_dec(link->master);
160

161 162 163 164
	return ret;
}

/**
165
 * pm_genpd_poweron - Restore power to a given PM domain and its masters.
166 167 168 169 170 171 172 173 174 175
 * @genpd: PM domain to power up.
 */
int pm_genpd_poweron(struct generic_pm_domain *genpd)
{
	int ret;

	mutex_lock(&genpd->lock);
	ret = __pm_genpd_poweron(genpd);
	mutex_unlock(&genpd->lock);
	return ret;
176 177 178 179 180 181
}

#endif /* CONFIG_PM */

#ifdef CONFIG_PM_RUNTIME

182 183
/**
 * __pm_genpd_save_device - Save the pre-suspend state of a device.
184
 * @pdd: Domain data of the device to save the state of.
185 186
 * @genpd: PM domain the device belongs to.
 */
187
static int __pm_genpd_save_device(struct pm_domain_data *pdd,
188
				  struct generic_pm_domain *genpd)
189
	__releases(&genpd->lock) __acquires(&genpd->lock)
190
{
191
	struct device *dev = pdd->dev;
192 193 194
	struct device_driver *drv = dev->driver;
	int ret = 0;

195
	if (pdd->need_restore)
196 197
		return 0;

198 199
	mutex_unlock(&genpd->lock);

200 201 202 203 204 205 206 207 208 209
	if (drv && drv->pm && drv->pm->runtime_suspend) {
		if (genpd->start_device)
			genpd->start_device(dev);

		ret = drv->pm->runtime_suspend(dev);

		if (genpd->stop_device)
			genpd->stop_device(dev);
	}

210 211
	mutex_lock(&genpd->lock);

212
	if (!ret)
213
		pdd->need_restore = true;
214 215 216 217 218 219

	return ret;
}

/**
 * __pm_genpd_restore_device - Restore the pre-suspend state of a device.
220
 * @pdd: Domain data of the device to restore the state of.
221 222
 * @genpd: PM domain the device belongs to.
 */
223
static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
224
				      struct generic_pm_domain *genpd)
225
	__releases(&genpd->lock) __acquires(&genpd->lock)
226
{
227
	struct device *dev = pdd->dev;
228 229
	struct device_driver *drv = dev->driver;

230
	if (!pdd->need_restore)
231 232
		return;

233 234
	mutex_unlock(&genpd->lock);

235 236 237 238 239 240 241 242 243 244
	if (drv && drv->pm && drv->pm->runtime_resume) {
		if (genpd->start_device)
			genpd->start_device(dev);

		drv->pm->runtime_resume(dev);

		if (genpd->stop_device)
			genpd->stop_device(dev);
	}

245 246
	mutex_lock(&genpd->lock);

247
	pdd->need_restore = false;
248 249
}

250 251 252 253 254 255 256 257 258 259 260
/**
 * genpd_abort_poweroff - Check if a PM domain power off should be aborted.
 * @genpd: PM domain to check.
 *
 * Return true if a PM domain's status changed to GPD_STATE_ACTIVE during
 * a "power off" operation, which means that a "power on" has occured in the
 * meantime, or if its resume_count field is different from zero, which means
 * that one of its devices has been resumed in the meantime.
 */
static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
{
261
	return genpd->status == GPD_STATE_WAIT_MASTER
262
		|| genpd->status == GPD_STATE_ACTIVE || genpd->resume_count > 0;
263 264
}

265 266 267 268 269 270 271
/**
 * genpd_queue_power_off_work - Queue up the execution of pm_genpd_poweroff().
 * @genpd: PM domait to power off.
 *
 * Queue up the execution of pm_genpd_poweroff() unless it's already been done
 * before.
 */
272
void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
273 274 275 276 277
{
	if (!work_pending(&genpd->power_off_work))
		queue_work(pm_wq, &genpd->power_off_work);
}

278 279 280 281 282 283 284 285 286
/**
 * pm_genpd_poweroff - Remove power from a given PM domain.
 * @genpd: PM domain to power down.
 *
 * If all of the @genpd's devices have been suspended and all of its subdomains
 * have been powered down, run the runtime suspend callbacks provided by all of
 * the @genpd's devices' drivers and remove power from @genpd.
 */
static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
287
	__releases(&genpd->lock) __acquires(&genpd->lock)
288
{
289
	struct pm_domain_data *pdd;
290
	struct gpd_link *link;
291
	unsigned int not_suspended;
292
	int ret = 0;
293

294 295 296 297
 start:
	/*
	 * Do not try to power off the domain in the following situations:
	 * (1) The domain is already in the "power off" state.
298
	 * (2) The domain is waiting for its master to power up.
299
	 * (3) One of the domain's devices is being resumed right now.
300
	 * (4) System suspend is in progress.
301
	 */
302
	if (genpd->status == GPD_STATE_POWER_OFF
303
	    || genpd->status == GPD_STATE_WAIT_MASTER
304
	    || genpd->resume_count > 0 || genpd->prepared_count > 0)
305 306
		return 0;

307
	if (atomic_read(&genpd->sd_count) > 0)
308 309 310
		return -EBUSY;

	not_suspended = 0;
311 312
	list_for_each_entry(pdd, &genpd->dev_list, list_node)
		if (pdd->dev->driver && !pm_runtime_suspended(pdd->dev))
313 314 315 316 317
			not_suspended++;

	if (not_suspended > genpd->in_progress)
		return -EBUSY;

318 319 320 321 322 323 324 325 326
	if (genpd->poweroff_task) {
		/*
		 * Another instance of pm_genpd_poweroff() is executing
		 * callbacks, so tell it to start over and return.
		 */
		genpd->status = GPD_STATE_REPEAT;
		return 0;
	}

327 328 329 330 331
	if (genpd->gov && genpd->gov->power_down_ok) {
		if (!genpd->gov->power_down_ok(&genpd->domain))
			return -EAGAIN;
	}

332
	genpd->status = GPD_STATE_BUSY;
333
	genpd->poweroff_task = current;
334

335
	list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
336
		ret = atomic_read(&genpd->sd_count) == 0 ?
337
			__pm_genpd_save_device(pdd, genpd) : -EBUSY;
338 339 340 341

		if (genpd_abort_poweroff(genpd))
			goto out;

342 343 344 345
		if (ret) {
			genpd_set_active(genpd);
			goto out;
		}
346

347 348 349 350 351
		if (genpd->status == GPD_STATE_REPEAT) {
			genpd->poweroff_task = NULL;
			goto start;
		}
	}
352

353 354 355
	if (genpd->power_off) {
		if (atomic_read(&genpd->sd_count) > 0) {
			ret = -EBUSY;
356 357
			goto out;
		}
358

359
		/*
360 361
		 * If sd_count > 0 at this point, one of the subdomains hasn't
		 * managed to call pm_genpd_poweron() for the master yet after
362 363 364 365 366
		 * incrementing it.  In that case pm_genpd_poweron() will wait
		 * for us to drop the lock, so we can call .power_off() and let
		 * the pm_genpd_poweron() restore power for us (this shouldn't
		 * happen very often).
		 */
367 368 369 370 371 372
		ret = genpd->power_off(genpd);
		if (ret == -EBUSY) {
			genpd_set_active(genpd);
			goto out;
		}
	}
373

374
	genpd->status = GPD_STATE_POWER_OFF;
375

376 377 378 379
	list_for_each_entry(link, &genpd->slave_links, slave_node) {
		genpd_sd_counter_dec(link->master);
		genpd_queue_power_off_work(link->master);
	}
380

381 382 383 384
 out:
	genpd->poweroff_task = NULL;
	wake_up_all(&genpd->status_wait_queue);
	return ret;
385 386 387 388 389 390 391 392 393 394 395 396
}

/**
 * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
 * @work: Work structure used for scheduling the execution of this function.
 */
static void genpd_power_off_work_fn(struct work_struct *work)
{
	struct generic_pm_domain *genpd;

	genpd = container_of(work, struct generic_pm_domain, power_off_work);

397
	genpd_acquire_lock(genpd);
398
	pm_genpd_poweroff(genpd);
399
	genpd_release_lock(genpd);
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
}

/**
 * pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
 * @dev: Device to suspend.
 *
 * Carry out a runtime suspend of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 */
static int pm_genpd_runtime_suspend(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

416 417
	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
418 419 420 421 422
		return -EINVAL;

	if (genpd->stop_device) {
		int ret = genpd->stop_device(dev);
		if (ret)
423
			return ret;
424
	}
425

426
	mutex_lock(&genpd->lock);
427 428 429
	genpd->in_progress++;
	pm_genpd_poweroff(genpd);
	genpd->in_progress--;
430
	mutex_unlock(&genpd->lock);
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445

	return 0;
}

/**
 * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
 * @dev: Device to resume.
 *
 * Carry out a runtime resume of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 */
static int pm_genpd_runtime_resume(struct device *dev)
{
	struct generic_pm_domain *genpd;
446
	DEFINE_WAIT(wait);
447 448 449 450
	int ret;

	dev_dbg(dev, "%s()\n", __func__);

451 452
	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
453 454
		return -EINVAL;

455
	mutex_lock(&genpd->lock);
456 457 458 459 460
	ret = __pm_genpd_poweron(genpd);
	if (ret) {
		mutex_unlock(&genpd->lock);
		return ret;
	}
461
	genpd->status = GPD_STATE_BUSY;
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
	genpd->resume_count++;
	for (;;) {
		prepare_to_wait(&genpd->status_wait_queue, &wait,
				TASK_UNINTERRUPTIBLE);
		/*
		 * If current is the powering off task, we have been called
		 * reentrantly from one of the device callbacks, so we should
		 * not wait.
		 */
		if (!genpd->poweroff_task || genpd->poweroff_task == current)
			break;
		mutex_unlock(&genpd->lock);

		schedule();

		mutex_lock(&genpd->lock);
	}
	finish_wait(&genpd->status_wait_queue, &wait);
480
	__pm_genpd_restore_device(&dev->power.subsys_data->domain_data, genpd);
481 482
	genpd->resume_count--;
	genpd_set_active(genpd);
483
	wake_up_all(&genpd->status_wait_queue);
484
	mutex_unlock(&genpd->lock);
485 486 487

	if (genpd->start_device)
		genpd->start_device(dev);
488 489 490 491

	return 0;
}

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
/**
 * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
 */
void pm_genpd_poweroff_unused(void)
{
	struct generic_pm_domain *genpd;

	mutex_lock(&gpd_list_lock);

	list_for_each_entry(genpd, &gpd_list, gpd_list_node)
		genpd_queue_power_off_work(genpd);

	mutex_unlock(&gpd_list_lock);
}

507 508 509 510 511 512 513 514 515
#else

static inline void genpd_power_off_work_fn(struct work_struct *work) {}

#define pm_genpd_runtime_suspend	NULL
#define pm_genpd_runtime_resume		NULL

#endif /* CONFIG_PM_RUNTIME */

516 517 518
#ifdef CONFIG_PM_SLEEP

/**
519
 * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
520 521 522
 * @genpd: PM domain to power off, if possible.
 *
 * Check if the given PM domain can be powered off (during system suspend or
523
 * hibernation) and do that if so.  Also, in that case propagate to its masters.
524 525 526 527 528 529 530
 *
 * This function is only called in "noirq" stages of system power transitions,
 * so it need not acquire locks (all of the "noirq" callbacks are executed
 * sequentially, so it is guaranteed that it will never run twice in parallel).
 */
static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
{
531
	struct gpd_link *link;
532

533
	if (genpd->status == GPD_STATE_POWER_OFF)
534 535
		return;

536 537
	if (genpd->suspended_count != genpd->device_count
	    || atomic_read(&genpd->sd_count) > 0)
538 539 540 541 542
		return;

	if (genpd->power_off)
		genpd->power_off(genpd);

543
	genpd->status = GPD_STATE_POWER_OFF;
544 545 546 547

	list_for_each_entry(link, &genpd->slave_links, slave_node) {
		genpd_sd_counter_dec(link->master);
		pm_genpd_sync_poweroff(link->master);
548 549 550
	}
}

551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
/**
 * resume_needed - Check whether to resume a device before system suspend.
 * @dev: Device to check.
 * @genpd: PM domain the device belongs to.
 *
 * There are two cases in which a device that can wake up the system from sleep
 * states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
 * to wake up the system and it has to remain active for this purpose while the
 * system is in the sleep state and (2) if the device is not enabled to wake up
 * the system from sleep states and it generally doesn't generate wakeup signals
 * by itself (those signals are generated on its behalf by other parts of the
 * system).  In the latter case it may be necessary to reconfigure the device's
 * wakeup settings during system suspend, because it may have been set up to
 * signal remote wakeup from the system's working state as needed by runtime PM.
 * Return 'true' in either of the above cases.
 */
static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
{
	bool active_wakeup;

	if (!device_can_wakeup(dev))
		return false;

	active_wakeup = genpd->active_wakeup && genpd->active_wakeup(dev);
	return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
}

578 579 580 581 582 583 584 585 586 587 588 589
/**
 * pm_genpd_prepare - Start power transition of a device in a PM domain.
 * @dev: Device to start the transition of.
 *
 * Start a power transition of a device (during a system-wide power transition)
 * under the assumption that its pm_domain field points to the domain member of
 * an object of type struct generic_pm_domain representing a PM domain
 * consisting of I/O devices.
 */
static int pm_genpd_prepare(struct device *dev)
{
	struct generic_pm_domain *genpd;
590
	int ret;
591 592 593 594 595 596 597

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

598 599 600 601 602 603 604 605 606 607 608 609 610 611
	/*
	 * If a wakeup request is pending for the device, it should be woken up
	 * at this point and a system wakeup event should be reported if it's
	 * set up to wake up the system from sleep states.
	 */
	pm_runtime_get_noresume(dev);
	if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
		pm_wakeup_event(dev, 0);

	if (pm_wakeup_pending()) {
		pm_runtime_put_sync(dev);
		return -EBUSY;
	}

612 613 614
	if (resume_needed(dev, genpd))
		pm_runtime_resume(dev);

615
	genpd_acquire_lock(genpd);
616 617

	if (genpd->prepared_count++ == 0)
618 619 620
		genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;

	genpd_release_lock(genpd);
621 622

	if (genpd->suspend_power_off) {
623
		pm_runtime_put_noidle(dev);
624 625 626 627
		return 0;
	}

	/*
628 629 630 631
	 * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
	 * so pm_genpd_poweron() will return immediately, but if the device
	 * is suspended (e.g. it's been stopped by .stop_device()), we need
	 * to make it operational.
632
	 */
633
	pm_runtime_resume(dev);
634 635
	__pm_runtime_disable(dev, false);

636 637 638 639 640 641 642 643
	ret = pm_generic_prepare(dev);
	if (ret) {
		mutex_lock(&genpd->lock);

		if (--genpd->prepared_count == 0)
			genpd->suspend_power_off = false;

		mutex_unlock(&genpd->lock);
644
		pm_runtime_enable(dev);
645
	}
646 647

	pm_runtime_put_sync(dev);
648
	return ret;
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
}

/**
 * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
 * @dev: Device to suspend.
 *
 * Suspend a device under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a PM domain consisting of I/O devices.
 */
static int pm_genpd_suspend(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_suspend(dev);
}

/**
 * pm_genpd_suspend_noirq - Late suspend of a device from an I/O PM domain.
 * @dev: Device to suspend.
 *
 * Carry out a late suspend of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 */
static int pm_genpd_suspend_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;
	int ret;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	if (genpd->suspend_power_off)
		return 0;

	ret = pm_generic_suspend_noirq(dev);
	if (ret)
		return ret;

698 699 700 701
	if (device_may_wakeup(dev)
	    && genpd->active_wakeup && genpd->active_wakeup(dev))
		return 0;

702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
	if (genpd->stop_device)
		genpd->stop_device(dev);

	/*
	 * Since all of the "noirq" callbacks are executed sequentially, it is
	 * guaranteed that this function will never run twice in parallel for
	 * the same PM domain, so it is not necessary to use locking here.
	 */
	genpd->suspended_count++;
	pm_genpd_sync_poweroff(genpd);

	return 0;
}

/**
 * pm_genpd_resume_noirq - Early resume of a device from an I/O power domain.
 * @dev: Device to resume.
 *
 * Carry out an early resume of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a power domain consisting of I/O
 * devices.
 */
static int pm_genpd_resume_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	if (genpd->suspend_power_off)
		return 0;

	/*
	 * Since all of the "noirq" callbacks are executed sequentially, it is
	 * guaranteed that this function will never run twice in parallel for
	 * the same PM domain, so it is not necessary to use locking here.
	 */
	pm_genpd_poweron(genpd);
	genpd->suspended_count--;
	if (genpd->start_device)
		genpd->start_device(dev);

	return pm_generic_resume_noirq(dev);
}

/**
 * pm_genpd_resume - Resume a device belonging to an I/O power domain.
 * @dev: Device to resume.
 *
 * Resume a device under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a power domain consisting of I/O devices.
 */
static int pm_genpd_resume(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_resume(dev);
}

/**
 * pm_genpd_freeze - Freeze a device belonging to an I/O power domain.
 * @dev: Device to freeze.
 *
 * Freeze a device under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a power domain consisting of I/O devices.
 */
static int pm_genpd_freeze(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_freeze(dev);
}

/**
 * pm_genpd_freeze_noirq - Late freeze of a device from an I/O power domain.
 * @dev: Device to freeze.
 *
 * Carry out a late freeze of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a power domain consisting of I/O
 * devices.
 */
static int pm_genpd_freeze_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;
	int ret;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	if (genpd->suspend_power_off)
		return 0;

	ret = pm_generic_freeze_noirq(dev);
	if (ret)
		return ret;

	if (genpd->stop_device)
		genpd->stop_device(dev);

	return 0;
}

/**
 * pm_genpd_thaw_noirq - Early thaw of a device from an I/O power domain.
 * @dev: Device to thaw.
 *
 * Carry out an early thaw of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a power domain consisting of I/O
 * devices.
 */
static int pm_genpd_thaw_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	if (genpd->suspend_power_off)
		return 0;

	if (genpd->start_device)
		genpd->start_device(dev);

	return pm_generic_thaw_noirq(dev);
}

/**
 * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
 * @dev: Device to thaw.
 *
 * Thaw a device under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a power domain consisting of I/O devices.
 */
static int pm_genpd_thaw(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_thaw(dev);
}

/**
 * pm_genpd_dev_poweroff - Power off a device belonging to an I/O PM domain.
 * @dev: Device to suspend.
 *
 * Power off a device under the assumption that its pm_domain field points to
 * the domain member of an object of type struct generic_pm_domain representing
 * a PM domain consisting of I/O devices.
 */
static int pm_genpd_dev_poweroff(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_poweroff(dev);
}

/**
 * pm_genpd_dev_poweroff_noirq - Late power off of a device from a PM domain.
 * @dev: Device to suspend.
 *
 * Carry out a late powering off of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 */
static int pm_genpd_dev_poweroff_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;
	int ret;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	if (genpd->suspend_power_off)
		return 0;

	ret = pm_generic_poweroff_noirq(dev);
	if (ret)
		return ret;

922 923 924 925
	if (device_may_wakeup(dev)
	    && genpd->active_wakeup && genpd->active_wakeup(dev))
		return 0;

926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
	if (genpd->stop_device)
		genpd->stop_device(dev);

	/*
	 * Since all of the "noirq" callbacks are executed sequentially, it is
	 * guaranteed that this function will never run twice in parallel for
	 * the same PM domain, so it is not necessary to use locking here.
	 */
	genpd->suspended_count++;
	pm_genpd_sync_poweroff(genpd);

	return 0;
}

/**
 * pm_genpd_restore_noirq - Early restore of a device from an I/O power domain.
 * @dev: Device to resume.
 *
 * Carry out an early restore of a device under the assumption that its
 * pm_domain field points to the domain member of an object of type
 * struct generic_pm_domain representing a power domain consisting of I/O
 * devices.
 */
static int pm_genpd_restore_noirq(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	/*
	 * Since all of the "noirq" callbacks are executed sequentially, it is
	 * guaranteed that this function will never run twice in parallel for
	 * the same PM domain, so it is not necessary to use locking here.
	 */
964
	genpd->status = GPD_STATE_POWER_OFF;
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
	if (genpd->suspend_power_off) {
		/*
		 * The boot kernel might put the domain into the power on state,
		 * so make sure it really is powered off.
		 */
		if (genpd->power_off)
			genpd->power_off(genpd);
		return 0;
	}

	pm_genpd_poweron(genpd);
	genpd->suspended_count--;
	if (genpd->start_device)
		genpd->start_device(dev);

	return pm_generic_restore_noirq(dev);
}

/**
 * pm_genpd_restore - Restore a device belonging to an I/O power domain.
 * @dev: Device to resume.
 *
 * Restore a device under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a power domain consisting of I/O devices.
 */
static int pm_genpd_restore(struct device *dev)
{
	struct generic_pm_domain *genpd;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return -EINVAL;

	return genpd->suspend_power_off ? 0 : pm_generic_restore(dev);
}

/**
 * pm_genpd_complete - Complete power transition of a device in a power domain.
 * @dev: Device to complete the transition of.
 *
 * Complete a power transition of a device (during a system-wide power
 * transition) under the assumption that its pm_domain field points to the
 * domain member of an object of type struct generic_pm_domain representing
 * a power domain consisting of I/O devices.
 */
static void pm_genpd_complete(struct device *dev)
{
	struct generic_pm_domain *genpd;
	bool run_complete;

	dev_dbg(dev, "%s()\n", __func__);

	genpd = dev_to_genpd(dev);
	if (IS_ERR(genpd))
		return;

	mutex_lock(&genpd->lock);

	run_complete = !genpd->suspend_power_off;
	if (--genpd->prepared_count == 0)
		genpd->suspend_power_off = false;

	mutex_unlock(&genpd->lock);

	if (run_complete) {
		pm_generic_complete(dev);
1034
		pm_runtime_set_active(dev);
1035
		pm_runtime_enable(dev);
1036
		pm_runtime_idle(dev);
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
	}
}

#else

#define pm_genpd_prepare		NULL
#define pm_genpd_suspend		NULL
#define pm_genpd_suspend_noirq		NULL
#define pm_genpd_resume_noirq		NULL
#define pm_genpd_resume			NULL
#define pm_genpd_freeze			NULL
#define pm_genpd_freeze_noirq		NULL
#define pm_genpd_thaw_noirq		NULL
#define pm_genpd_thaw			NULL
#define pm_genpd_dev_poweroff_noirq	NULL
#define pm_genpd_dev_poweroff		NULL
#define pm_genpd_restore_noirq		NULL
#define pm_genpd_restore		NULL
#define pm_genpd_complete		NULL

#endif /* CONFIG_PM_SLEEP */

1059 1060 1061 1062 1063 1064 1065
/**
 * pm_genpd_add_device - Add a device to an I/O PM domain.
 * @genpd: PM domain to add the device to.
 * @dev: Device to be added.
 */
int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
{
1066
	struct pm_domain_data *pdd;
1067 1068 1069 1070 1071 1072 1073
	int ret = 0;

	dev_dbg(dev, "%s()\n", __func__);

	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
		return -EINVAL;

1074
	genpd_acquire_lock(genpd);
1075

1076
	if (genpd->status == GPD_STATE_POWER_OFF) {
1077 1078 1079 1080
		ret = -EINVAL;
		goto out;
	}

1081 1082 1083 1084 1085
	if (genpd->prepared_count > 0) {
		ret = -EAGAIN;
		goto out;
	}

1086 1087
	list_for_each_entry(pdd, &genpd->dev_list, list_node)
		if (pdd->dev == dev) {
1088 1089 1090 1091
			ret = -EINVAL;
			goto out;
		}

1092
	genpd->device_count++;
1093 1094

	dev->pm_domain = &genpd->domain;
1095 1096 1097 1098 1099
	dev_pm_get_subsys_data(dev);
	pdd = &dev->power.subsys_data->domain_data;
	pdd->dev = dev;
	pdd->need_restore = false;
	list_add_tail(&pdd->list_node, &genpd->dev_list);
1100 1101

 out:
1102
	genpd_release_lock(genpd);
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114

	return ret;
}

/**
 * pm_genpd_remove_device - Remove a device from an I/O PM domain.
 * @genpd: PM domain to remove the device from.
 * @dev: Device to be removed.
 */
int pm_genpd_remove_device(struct generic_pm_domain *genpd,
			   struct device *dev)
{
1115
	struct pm_domain_data *pdd;
1116 1117 1118 1119 1120 1121 1122
	int ret = -EINVAL;

	dev_dbg(dev, "%s()\n", __func__);

	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
		return -EINVAL;

1123
	genpd_acquire_lock(genpd);
1124

1125 1126 1127 1128 1129
	if (genpd->prepared_count > 0) {
		ret = -EAGAIN;
		goto out;
	}

1130 1131
	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
		if (pdd->dev != dev)
1132 1133
			continue;

1134 1135 1136
		list_del_init(&pdd->list_node);
		pdd->dev = NULL;
		dev_pm_put_subsys_data(dev);
1137 1138
		dev->pm_domain = NULL;

1139
		genpd->device_count--;
1140 1141 1142 1143 1144

		ret = 0;
		break;
	}

1145
 out:
1146
	genpd_release_lock(genpd);
1147 1148 1149 1150 1151 1152 1153

	return ret;
}

/**
 * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
 * @genpd: Master PM domain to add the subdomain to.
1154
 * @subdomain: Subdomain to be added.
1155 1156
 */
int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
1157
			   struct generic_pm_domain *subdomain)
1158
{
1159
	struct gpd_link *link;
1160 1161
	int ret = 0;

1162
	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1163 1164
		return -EINVAL;

1165 1166
 start:
	genpd_acquire_lock(genpd);
1167
	mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1168

1169 1170 1171
	if (subdomain->status != GPD_STATE_POWER_OFF
	    && subdomain->status != GPD_STATE_ACTIVE) {
		mutex_unlock(&subdomain->lock);
1172 1173 1174 1175 1176
		genpd_release_lock(genpd);
		goto start;
	}

	if (genpd->status == GPD_STATE_POWER_OFF
1177
	    &&  subdomain->status != GPD_STATE_POWER_OFF) {
1178 1179 1180 1181
		ret = -EINVAL;
		goto out;
	}

1182
	list_for_each_entry(link, &genpd->slave_links, slave_node) {
1183
		if (link->slave == subdomain && link->master == genpd) {
1184 1185 1186 1187 1188
			ret = -EINVAL;
			goto out;
		}
	}

1189 1190 1191 1192 1193 1194 1195
	link = kzalloc(sizeof(*link), GFP_KERNEL);
	if (!link) {
		ret = -ENOMEM;
		goto out;
	}
	link->master = genpd;
	list_add_tail(&link->master_node, &genpd->master_links);
1196 1197 1198
	link->slave = subdomain;
	list_add_tail(&link->slave_node, &subdomain->slave_links);
	if (subdomain->status != GPD_STATE_POWER_OFF)
1199
		genpd_sd_counter_inc(genpd);
1200 1201

 out:
1202
	mutex_unlock(&subdomain->lock);
1203
	genpd_release_lock(genpd);
1204 1205 1206 1207 1208 1209 1210

	return ret;
}

/**
 * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
 * @genpd: Master PM domain to remove the subdomain from.
1211
 * @subdomain: Subdomain to be removed.
1212 1213
 */
int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
1214
			      struct generic_pm_domain *subdomain)
1215
{
1216
	struct gpd_link *link;
1217 1218
	int ret = -EINVAL;

1219
	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1220 1221
		return -EINVAL;

1222 1223
 start:
	genpd_acquire_lock(genpd);
1224

1225 1226
	list_for_each_entry(link, &genpd->master_links, master_node) {
		if (link->slave != subdomain)
1227 1228 1229 1230
			continue;

		mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);

1231 1232 1233 1234 1235 1236 1237
		if (subdomain->status != GPD_STATE_POWER_OFF
		    && subdomain->status != GPD_STATE_ACTIVE) {
			mutex_unlock(&subdomain->lock);
			genpd_release_lock(genpd);
			goto start;
		}

1238 1239 1240
		list_del(&link->master_node);
		list_del(&link->slave_node);
		kfree(link);
1241
		if (subdomain->status != GPD_STATE_POWER_OFF)
1242 1243 1244 1245 1246 1247 1248 1249
			genpd_sd_counter_dec(genpd);

		mutex_unlock(&subdomain->lock);

		ret = 0;
		break;
	}

1250
	genpd_release_lock(genpd);
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266

	return ret;
}

/**
 * pm_genpd_init - Initialize a generic I/O PM domain object.
 * @genpd: PM domain object to initialize.
 * @gov: PM domain governor to associate with the domain (may be NULL).
 * @is_off: Initial value of the domain's power_is_off field.
 */
void pm_genpd_init(struct generic_pm_domain *genpd,
		   struct dev_power_governor *gov, bool is_off)
{
	if (IS_ERR_OR_NULL(genpd))
		return;

1267 1268
	INIT_LIST_HEAD(&genpd->master_links);
	INIT_LIST_HEAD(&genpd->slave_links);
1269 1270 1271 1272 1273
	INIT_LIST_HEAD(&genpd->dev_list);
	mutex_init(&genpd->lock);
	genpd->gov = gov;
	INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
	genpd->in_progress = 0;
1274
	atomic_set(&genpd->sd_count, 0);
1275 1276
	genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
	init_waitqueue_head(&genpd->status_wait_queue);
1277 1278
	genpd->poweroff_task = NULL;
	genpd->resume_count = 0;
1279 1280
	genpd->device_count = 0;
	genpd->suspended_count = 0;
1281 1282 1283
	genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
	genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
	genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
	genpd->domain.ops.prepare = pm_genpd_prepare;
	genpd->domain.ops.suspend = pm_genpd_suspend;
	genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
	genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
	genpd->domain.ops.resume = pm_genpd_resume;
	genpd->domain.ops.freeze = pm_genpd_freeze;
	genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
	genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
	genpd->domain.ops.thaw = pm_genpd_thaw;
	genpd->domain.ops.poweroff = pm_genpd_dev_poweroff;
	genpd->domain.ops.poweroff_noirq = pm_genpd_dev_poweroff_noirq;
	genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
	genpd->domain.ops.restore = pm_genpd_restore;
	genpd->domain.ops.complete = pm_genpd_complete;
1298 1299 1300 1301
	mutex_lock(&gpd_list_lock);
	list_add(&genpd->gpd_list_node, &gpd_list);
	mutex_unlock(&gpd_list_lock);
}