drivers/base/power/domain.c

   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/init.h>
  10 #include <linux/kernel.h>
  11 #include <linux/io.h>
  12 #include <linux/pm_runtime.h>
  13 #include <linux/pm_domain.h>
  14 #include <linux/slab.h>
  15 #include <linux/err.h>
  16 #include <linux/sched.h>
  17 #include <linux/suspend.h>
  18 #include <linux/export.h>
  19
  20 #define GENPD_DEV_CALLBACK(genpd, type, callback, dev)          \
  21 ({                                                              \
  22         type (*__routine)(struct device *__d);                  \
  23         type __ret = (type)0;                                   \
  24                                                                 \
  25         __routine = genpd->dev_ops.callback;                    \
  26         if (__routine) {                                        \
  27                 __ret = __routine(dev);                         \
  28         } else {                                                \
  29                 __routine = dev_gpd_data(dev)->ops.callback;    \
  30                 if (__routine)                                  \
  31                         __ret = __routine(dev);                 \
  32         }                                                       \
  33         __ret;                                                  \
  34 })
  35
  36 #define GENPD_DEV_TIMED_CALLBACK(genpd, type, callback, dev, field, name)       \
  37 ({                                                                              \
  38         ktime_t __start = ktime_get();                                          \
  39         type __retval = GENPD_DEV_CALLBACK(genpd, type, callback, dev);         \
  40         s64 __elapsed = ktime_to_ns(ktime_sub(ktime_get(), __start));           \
  41         struct generic_pm_domain_data *__gpd_data = dev_gpd_data(dev);          \
  42         if (__elapsed > __gpd_data->td.field) {                                 \
  43                 __gpd_data->td.field = __elapsed;                               \
  44                 dev_warn(dev, name " latency exceeded, new value %lld ns\n",    \
  45                         __elapsed);                                             \
  46         }                                                                       \
  47         __retval;                                                               \
  48 })
  49
  50 static LIST_HEAD(gpd_list);
  51 static DEFINE_MUTEX(gpd_list_lock);
  52
  53 #ifdef CONFIG_PM
  54
  55 struct generic_pm_domain *dev_to_genpd(struct device *dev)
  56 {
  57         if (IS_ERR_OR_NULL(dev->pm_domain))
  58                 return ERR_PTR(-EINVAL);
  59
  60         return pd_to_genpd(dev->pm_domain);
  61 }
  62
  63 static int genpd_stop_dev(struct generic_pm_domain *genpd, struct device *dev)
  64 {
  65         return GENPD_DEV_TIMED_CALLBACK(genpd, int, stop, dev,
  66                                         stop_latency_ns, "stop");
  67 }
  68
  69 static int genpd_start_dev(struct generic_pm_domain *genpd, struct device *dev)
  70 {
  71         return GENPD_DEV_TIMED_CALLBACK(genpd, int, start, dev,
  72                                         start_latency_ns, "start");
  73 }
  74
  75 static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
  76 {
  77         return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
  78                                         save_state_latency_ns, "state save");
  79 }
  80
  81 static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
  82 {
  83         return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
  84                                         restore_state_latency_ns,
  85                                         "state restore");
  86 }
  87
  88 static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
  89 {
  90         bool ret = false;
  91
  92         if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
  93                 ret = !!atomic_dec_and_test(&genpd->sd_count);
  94
  95         return ret;
  96 }
  97
  98 static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
  99 {
 100         atomic_inc(&genpd->sd_count);
 101         smp_mb__after_atomic_inc();
 102 }
 103
 104 static void genpd_acquire_lock(struct generic_pm_domain *genpd)
 105 {
 106         DEFINE_WAIT(wait);
 107
 108         mutex_lock(&genpd->lock);
 109         /*
 110          * Wait for the domain to transition into either the active,
 111          * or the power off state.
 112          */
 113         for (;;) {
 114                 prepare_to_wait(&genpd->status_wait_queue, &wait,
 115                                 TASK_UNINTERRUPTIBLE);
 116                 if (genpd->status == GPD_STATE_ACTIVE
 117                     || genpd->status == GPD_STATE_POWER_OFF)
 118                         break;
 119                 mutex_unlock(&genpd->lock);
 120
 121                 schedule();
 122
 123                 mutex_lock(&genpd->lock);
 124         }
 125         finish_wait(&genpd->status_wait_queue, &wait);
 126 }
 127
 128 static void genpd_release_lock(struct generic_pm_domain *genpd)
 129 {
 130         mutex_unlock(&genpd->lock);
 131 }
 132
 133 static void genpd_set_active(struct generic_pm_domain *genpd)
 134 {
 135         if (genpd->resume_count == 0)
 136                 genpd->status = GPD_STATE_ACTIVE;
 137 }
 138
 139 /**
 140  * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
 141  * @genpd: PM domain to power up.
 142  *
 143  * Restore power to @genpd and all of its masters so that it is possible to
 144  * resume a device belonging to it.
 145  */
 146 int __pm_genpd_poweron(struct generic_pm_domain *genpd)
 147         __releases(&genpd->lock) __acquires(&genpd->lock)
 148 {
 149         struct gpd_link *link;
 150         DEFINE_WAIT(wait);
 151         int ret = 0;
 152
 153         /* If the domain's master is being waited for, we have to wait too. */
 154         for (;;) {
 155                 prepare_to_wait(&genpd->status_wait_queue, &wait,
 156                                 TASK_UNINTERRUPTIBLE);
 157                 if (genpd->status != GPD_STATE_WAIT_MASTER)
 158                         break;
 159                 mutex_unlock(&genpd->lock);
 160
 161                 schedule();
 162
 163                 mutex_lock(&genpd->lock);
 164         }
 165         finish_wait(&genpd->status_wait_queue, &wait);
 166
 167         if (genpd->status == GPD_STATE_ACTIVE
 168             || (genpd->prepared_count > 0 && genpd->suspend_power_off))
 169                 return 0;
 170
 171         if (genpd->status != GPD_STATE_POWER_OFF) {
 172                 genpd_set_active(genpd);
 173                 return 0;
 174         }
 175
 176         /*
 177          * The list is guaranteed not to change while the loop below is being
 178          * executed, unless one of the masters' .power_on() callbacks fiddles
 179          * with it.
 180          */
 181         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 182                 genpd_sd_counter_inc(link->master);
 183                 genpd->status = GPD_STATE_WAIT_MASTER;
 184
 185                 mutex_unlock(&genpd->lock);
 186
 187                 ret = pm_genpd_poweron(link->master);
 188
 189                 mutex_lock(&genpd->lock);
 190
 191                 /*
 192                  * The "wait for parent" status is guaranteed not to change
 193                  * while the master is powering on.
 194                  */
 195                 genpd->status = GPD_STATE_POWER_OFF;
 196                 wake_up_all(&genpd->status_wait_queue);
 197                 if (ret) {
 198                         genpd_sd_counter_dec(link->master);
 199                         goto err;
 200                 }
 201         }
 202
 203         if (genpd->power_on) {
 204                 ktime_t time_start = ktime_get();
 205                 s64 elapsed_ns;
 206
 207                 ret = genpd->power_on(genpd);
 208                 if (ret)
 209                         goto err;
 210
 211                 elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 212                 if (elapsed_ns > genpd->power_on_latency_ns) {
 213                         genpd->power_on_latency_ns = elapsed_ns;
 214                         if (genpd->name)
 215                                 pr_warning("%s: Power-on latency exceeded, "
 216                                         "new value %lld ns\n", genpd->name,
 217                                         elapsed_ns);
 218                 }
 219         }
 220
 221         genpd_set_active(genpd);
 222
 223         return 0;
 224
 225  err:
 226         list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
 227                 genpd_sd_counter_dec(link->master);
 228
 229         return ret;
 230 }
 231
 232 /**
 233  * pm_genpd_poweron - Restore power to a given PM domain and its masters.
 234  * @genpd: PM domain to power up.
 235  */
 236 int pm_genpd_poweron(struct generic_pm_domain *genpd)
 237 {
 238         int ret;
 239
 240         mutex_lock(&genpd->lock);
 241         ret = __pm_genpd_poweron(genpd);
 242         mutex_unlock(&genpd->lock);
 243         return ret;
 244 }
 245
 246 #endif /* CONFIG_PM */
 247
 248 #ifdef CONFIG_PM_RUNTIME
 249
 250 /**
 251  * __pm_genpd_save_device - Save the pre-suspend state of a device.
 252  * @pdd: Domain data of the device to save the state of.
 253  * @genpd: PM domain the device belongs to.
 254  */
 255 static int __pm_genpd_save_device(struct pm_domain_data *pdd,
 256                                   struct generic_pm_domain *genpd)
 257         __releases(&genpd->lock) __acquires(&genpd->lock)
 258 {
 259         struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 260         struct device *dev = pdd->dev;
 261         int ret = 0;
 262
 263         if (gpd_data->need_restore)
 264                 return 0;
 265
 266         mutex_unlock(&genpd->lock);
 267
 268         genpd_start_dev(genpd, dev);
 269         ret = genpd_save_dev(genpd, dev);
 270         genpd_stop_dev(genpd, dev);
 271
 272         mutex_lock(&genpd->lock);
 273
 274         if (!ret)
 275                 gpd_data->need_restore = true;
 276
 277         return ret;
 278 }
 279
 280 /**
 281  * __pm_genpd_restore_device - Restore the pre-suspend state of a device.
 282  * @pdd: Domain data of the device to restore the state of.
 283  * @genpd: PM domain the device belongs to.
 284  */
 285 static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
 286                                       struct generic_pm_domain *genpd)
 287         __releases(&genpd->lock) __acquires(&genpd->lock)
 288 {
 289         struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 290         struct device *dev = pdd->dev;
 291
 292         if (!gpd_data->need_restore)
 293                 return;
 294
 295         mutex_unlock(&genpd->lock);
 296
 297         genpd_start_dev(genpd, dev);
 298         genpd_restore_dev(genpd, dev);
 299         genpd_stop_dev(genpd, dev);
 300
 301         mutex_lock(&genpd->lock);
 302
 303         gpd_data->need_restore = false;
 304 }
 305
 306 /**
 307  * genpd_abort_poweroff - Check if a PM domain power off should be aborted.
 308  * @genpd: PM domain to check.
 309  *
 310  * Return true if a PM domain's status changed to GPD_STATE_ACTIVE during
 311  * a "power off" operation, which means that a "power on" has occured in the
 312  * meantime, or if its resume_count field is different from zero, which means
 313  * that one of its devices has been resumed in the meantime.
 314  */
 315 static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
 316 {
 317         return genpd->status == GPD_STATE_WAIT_MASTER
 318                 || genpd->status == GPD_STATE_ACTIVE || genpd->resume_count > 0;
 319 }
 320
 321 /**
 322  * genpd_queue_power_off_work - Queue up the execution of pm_genpd_poweroff().
 323  * @genpd: PM domait to power off.
 324  *
 325  * Queue up the execution of pm_genpd_poweroff() unless it's already been done
 326  * before.
 327  */
 328 void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
 329 {
 330         if (!work_pending(&genpd->power_off_work))
 331                 queue_work(pm_wq, &genpd->power_off_work);
 332 }
 333
 334 /**
 335  * pm_genpd_poweroff - Remove power from a given PM domain.
 336  * @genpd: PM domain to power down.
 337  *
 338  * If all of the @genpd's devices have been suspended and all of its subdomains
 339  * have been powered down, run the runtime suspend callbacks provided by all of
 340  * the @genpd's devices' drivers and remove power from @genpd.
 341  */
 342 static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
 343         __releases(&genpd->lock) __acquires(&genpd->lock)
 344 {
 345         struct pm_domain_data *pdd;
 346         struct gpd_link *link;
 347         unsigned int not_suspended;
 348         int ret = 0;
 349
 350  start:
 351         /*
 352          * Do not try to power off the domain in the following situations:
 353          * (1) The domain is already in the "power off" state.
 354          * (2) The domain is waiting for its master to power up.
 355          * (3) One of the domain's devices is being resumed right now.
 356          * (4) System suspend is in progress.
 357          */
 358         if (genpd->status == GPD_STATE_POWER_OFF
 359             || genpd->status == GPD_STATE_WAIT_MASTER
 360             || genpd->resume_count > 0 || genpd->prepared_count > 0)
 361                 return 0;
 362
 363         if (atomic_read(&genpd->sd_count) > 0)
 364                 return -EBUSY;
 365
 366         not_suspended = 0;
 367         list_for_each_entry(pdd, &genpd->dev_list, list_node)
 368                 if (pdd->dev->driver && (!pm_runtime_suspended(pdd->dev)
 369                     || pdd->dev->power.irq_safe))
 370                         not_suspended++;
 371
 372         if (not_suspended > genpd->in_progress)
 373                 return -EBUSY;
 374
 375         if (genpd->poweroff_task) {
 376                 /*
 377                  * Another instance of pm_genpd_poweroff() is executing
 378                  * callbacks, so tell it to start over and return.
 379                  */
 380                 genpd->status = GPD_STATE_REPEAT;
 381                 return 0;
 382         }
 383
 384         if (genpd->gov && genpd->gov->power_down_ok) {
 385                 if (!genpd->gov->power_down_ok(&genpd->domain))
 386                         return -EAGAIN;
 387         }
 388
 389         genpd->status = GPD_STATE_BUSY;
 390         genpd->poweroff_task = current;
 391
 392         list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
 393                 ret = atomic_read(&genpd->sd_count) == 0 ?
 394                         __pm_genpd_save_device(pdd, genpd) : -EBUSY;
 395
 396                 if (genpd_abort_poweroff(genpd))
 397                         goto out;
 398
 399                 if (ret) {
 400                         genpd_set_active(genpd);
 401                         goto out;
 402                 }
 403
 404                 if (genpd->status == GPD_STATE_REPEAT) {
 405                         genpd->poweroff_task = NULL;
 406                         goto start;
 407                 }
 408         }
 409
 410         if (genpd->power_off) {
 411                 ktime_t time_start;
 412                 s64 elapsed_ns;
 413
 414                 if (atomic_read(&genpd->sd_count) > 0) {
 415                         ret = -EBUSY;
 416                         goto out;
 417                 }
 418
 419                 time_start = ktime_get();
 420
 421                 /*
 422                  * If sd_count > 0 at this point, one of the subdomains hasn't
 423                  * managed to call pm_genpd_poweron() for the master yet after
 424                  * incrementing it.  In that case pm_genpd_poweron() will wait
 425                  * for us to drop the lock, so we can call .power_off() and let
 426                  * the pm_genpd_poweron() restore power for us (this shouldn't
 427                  * happen very often).
 428                  */
 429                 ret = genpd->power_off(genpd);
 430                 if (ret == -EBUSY) {
 431                         genpd_set_active(genpd);
 432                         goto out;
 433                 }
 434
 435                 elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 436                 if (elapsed_ns > genpd->power_off_latency_ns) {
 437                         genpd->power_off_latency_ns = elapsed_ns;
 438                         if (genpd->name)
 439                                 pr_warning("%s: Power-off latency exceeded, "
 440                                         "new value %lld ns\n", genpd->name,
 441                                         elapsed_ns);
 442                 }
 443         }
 444
 445         genpd->status = GPD_STATE_POWER_OFF;
 446         genpd->power_off_time = ktime_get();
 447
 448         /* Update PM QoS information for devices in the domain. */
 449         list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
 450                 struct gpd_timing_data *td = &to_gpd_data(pdd)->td;
 451
 452                 pm_runtime_update_max_time_suspended(pdd->dev,
 453                                         td->start_latency_ns +
 454                                         td->restore_state_latency_ns +
 455                                         genpd->power_on_latency_ns);
 456         }
 457
 458         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 459                 genpd_sd_counter_dec(link->master);
 460                 genpd_queue_power_off_work(link->master);
 461         }
 462
 463  out:
 464         genpd->poweroff_task = NULL;
 465         wake_up_all(&genpd->status_wait_queue);
 466         return ret;
 467 }
 468
 469 /**
 470  * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
 471  * @work: Work structure used for scheduling the execution of this function.
 472  */
 473 static void genpd_power_off_work_fn(struct work_struct *work)
 474 {
 475         struct generic_pm_domain *genpd;
 476
 477         genpd = container_of(work, struct generic_pm_domain, power_off_work);
 478
 479         genpd_acquire_lock(genpd);
 480         pm_genpd_poweroff(genpd);
 481         genpd_release_lock(genpd);
 482 }
 483
 484 /**
 485  * pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
 486  * @dev: Device to suspend.
 487  *
 488  * Carry out a runtime suspend of a device under the assumption that its
 489  * pm_domain field points to the domain member of an object of type
 490  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 491  */
 492 static int pm_genpd_runtime_suspend(struct device *dev)
 493 {
 494         struct generic_pm_domain *genpd;
 495         bool (*stop_ok)(struct device *__dev);
 496         int ret;
 497
 498         dev_dbg(dev, "%s()\n", __func__);
 499
 500         genpd = dev_to_genpd(dev);
 501         if (IS_ERR(genpd))
 502                 return -EINVAL;
 503
 504         might_sleep_if(!genpd->dev_irq_safe);
 505
 506         stop_ok = genpd->gov ? genpd->gov->stop_ok : NULL;
 507         if (stop_ok && !stop_ok(dev))
 508                 return -EBUSY;
 509
 510         ret = genpd_stop_dev(genpd, dev);
 511         if (ret)
 512                 return ret;
 513
 514         pm_runtime_update_max_time_suspended(dev,
 515                                 dev_gpd_data(dev)->td.start_latency_ns);
 516
 517         /*
 518          * If power.irq_safe is set, this routine will be run with interrupts
 519          * off, so it can't use mutexes.
 520          */
 521         if (dev->power.irq_safe)
 522                 return 0;
 523
 524         mutex_lock(&genpd->lock);
 525         genpd->in_progress++;
 526         pm_genpd_poweroff(genpd);
 527         genpd->in_progress--;
 528         mutex_unlock(&genpd->lock);
 529
 530         return 0;
 531 }
 532
 533 /**
 534  * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
 535  * @dev: Device to resume.
 536  *
 537  * Carry out a runtime resume of a device under the assumption that its
 538  * pm_domain field points to the domain member of an object of type
 539  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 540  */
 541 static int pm_genpd_runtime_resume(struct device *dev)
 542 {
 543         struct generic_pm_domain *genpd;
 544         DEFINE_WAIT(wait);
 545         int ret;
 546
 547         dev_dbg(dev, "%s()\n", __func__);
 548
 549         genpd = dev_to_genpd(dev);
 550         if (IS_ERR(genpd))
 551                 return -EINVAL;
 552
 553         might_sleep_if(!genpd->dev_irq_safe);
 554
 555         /* If power.irq_safe, the PM domain is never powered off. */
 556         if (dev->power.irq_safe)
 557                 goto out;
 558
 559         mutex_lock(&genpd->lock);
 560         ret = __pm_genpd_poweron(genpd);
 561         if (ret) {
 562                 mutex_unlock(&genpd->lock);
 563                 return ret;
 564         }
 565         genpd->status = GPD_STATE_BUSY;
 566         genpd->resume_count++;
 567         for (;;) {
 568                 prepare_to_wait(&genpd->status_wait_queue, &wait,
 569                                 TASK_UNINTERRUPTIBLE);
 570                 /*
 571                  * If current is the powering off task, we have been called
 572                  * reentrantly from one of the device callbacks, so we should
 573                  * not wait.
 574                  */
 575                 if (!genpd->poweroff_task || genpd->poweroff_task == current)
 576                         break;
 577                 mutex_unlock(&genpd->lock);
 578
 579                 schedule();
 580
 581                 mutex_lock(&genpd->lock);
 582         }
 583         finish_wait(&genpd->status_wait_queue, &wait);
 584         __pm_genpd_restore_device(dev->power.subsys_data->domain_data, genpd);
 585         genpd->resume_count--;
 586         genpd_set_active(genpd);
 587         wake_up_all(&genpd->status_wait_queue);
 588         mutex_unlock(&genpd->lock);
 589
 590  out:
 591         genpd_start_dev(genpd, dev);
 592
 593         return 0;
 594 }
 595
 596 /**
 597  * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
 598  */
 599 void pm_genpd_poweroff_unused(void)
 600 {
 601         struct generic_pm_domain *genpd;
 602
 603         mutex_lock(&gpd_list_lock);
 604
 605         list_for_each_entry(genpd, &gpd_list, gpd_list_node)
 606                 genpd_queue_power_off_work(genpd);
 607
 608         mutex_unlock(&gpd_list_lock);
 609 }
 610
 611 #else
 612
 613 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
 614
 615 #define pm_genpd_runtime_suspend        NULL
 616 #define pm_genpd_runtime_resume         NULL
 617
 618 #endif /* CONFIG_PM_RUNTIME */
 619
 620 #ifdef CONFIG_PM_SLEEP
 621
 622 static bool genpd_dev_active_wakeup(struct generic_pm_domain *genpd,
 623                                     struct device *dev)
 624 {
 625         return GENPD_DEV_CALLBACK(genpd, bool, active_wakeup, dev);
 626 }
 627
 628 static int genpd_suspend_dev(struct generic_pm_domain *genpd, struct device *dev)
 629 {
 630         return GENPD_DEV_CALLBACK(genpd, int, suspend, dev);
 631 }
 632
 633 static int genpd_suspend_late(struct generic_pm_domain *genpd, struct device *dev)
 634 {
 635         return GENPD_DEV_CALLBACK(genpd, int, suspend_late, dev);
 636 }
 637
 638 static int genpd_resume_early(struct generic_pm_domain *genpd, struct device *dev)
 639 {
 640         return GENPD_DEV_CALLBACK(genpd, int, resume_early, dev);
 641 }
 642
 643 static int genpd_resume_dev(struct generic_pm_domain *genpd, struct device *dev)
 644 {
 645         return GENPD_DEV_CALLBACK(genpd, int, resume, dev);
 646 }
 647
 648 static int genpd_freeze_dev(struct generic_pm_domain *genpd, struct device *dev)
 649 {
 650         return GENPD_DEV_CALLBACK(genpd, int, freeze, dev);
 651 }
 652
 653 static int genpd_freeze_late(struct generic_pm_domain *genpd, struct device *dev)
 654 {
 655         return GENPD_DEV_CALLBACK(genpd, int, freeze_late, dev);
 656 }
 657
 658 static int genpd_thaw_early(struct generic_pm_domain *genpd, struct device *dev)
 659 {
 660         return GENPD_DEV_CALLBACK(genpd, int, thaw_early, dev);
 661 }
 662
 663 static int genpd_thaw_dev(struct generic_pm_domain *genpd, struct device *dev)
 664 {
 665         return GENPD_DEV_CALLBACK(genpd, int, thaw, dev);
 666 }
 667
 668 /**
 669  * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
 670  * @genpd: PM domain to power off, if possible.
 671  *
 672  * Check if the given PM domain can be powered off (during system suspend or
 673  * hibernation) and do that if so.  Also, in that case propagate to its masters.
 674  *
 675  * This function is only called in "noirq" stages of system power transitions,
 676  * so it need not acquire locks (all of the "noirq" callbacks are executed
 677  * sequentially, so it is guaranteed that it will never run twice in parallel).
 678  */
 679 static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
 680 {
 681         struct gpd_link *link;
 682
 683         if (genpd->status == GPD_STATE_POWER_OFF)
 684                 return;
 685
 686         if (genpd->suspended_count != genpd->device_count
 687             || atomic_read(&genpd->sd_count) > 0)
 688                 return;
 689
 690         if (genpd->power_off)
 691                 genpd->power_off(genpd);
 692
 693         genpd->status = GPD_STATE_POWER_OFF;
 694
 695         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 696                 genpd_sd_counter_dec(link->master);
 697                 pm_genpd_sync_poweroff(link->master);
 698         }
 699 }
 700
 701 /**
 702  * resume_needed - Check whether to resume a device before system suspend.
 703  * @dev: Device to check.
 704  * @genpd: PM domain the device belongs to.
 705  *
 706  * There are two cases in which a device that can wake up the system from sleep
 707  * states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
 708  * to wake up the system and it has to remain active for this purpose while the
 709  * system is in the sleep state and (2) if the device is not enabled to wake up
 710  * the system from sleep states and it generally doesn't generate wakeup signals
 711  * by itself (those signals are generated on its behalf by other parts of the
 712  * system).  In the latter case it may be necessary to reconfigure the device's
 713  * wakeup settings during system suspend, because it may have been set up to
 714  * signal remote wakeup from the system's working state as needed by runtime PM.
 715  * Return 'true' in either of the above cases.
 716  */
 717 static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
 718 {
 719         bool active_wakeup;
 720
 721         if (!device_can_wakeup(dev))
 722                 return false;
 723
 724         active_wakeup = genpd_dev_active_wakeup(genpd, dev);
 725         return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
 726 }
 727
 728 /**
 729  * pm_genpd_prepare - Start power transition of a device in a PM domain.
 730  * @dev: Device to start the transition of.
 731  *
 732  * Start a power transition of a device (during a system-wide power transition)
 733  * under the assumption that its pm_domain field points to the domain member of
 734  * an object of type struct generic_pm_domain representing a PM domain
 735  * consisting of I/O devices.
 736  */
 737 static int pm_genpd_prepare(struct device *dev)
 738 {
 739         struct generic_pm_domain *genpd;
 740         int ret;
 741
 742         dev_dbg(dev, "%s()\n", __func__);
 743
 744         genpd = dev_to_genpd(dev);
 745         if (IS_ERR(genpd))
 746                 return -EINVAL;
 747
 748         /*
 749          * If a wakeup request is pending for the device, it should be woken up
 750          * at this point and a system wakeup event should be reported if it's
 751          * set up to wake up the system from sleep states.
 752          */
 753         pm_runtime_get_noresume(dev);
 754         if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
 755                 pm_wakeup_event(dev, 0);
 756
 757         if (pm_wakeup_pending()) {
 758                 pm_runtime_put_sync(dev);
 759                 return -EBUSY;
 760         }
 761
 762         if (resume_needed(dev, genpd))
 763                 pm_runtime_resume(dev);
 764
 765         genpd_acquire_lock(genpd);
 766
 767         if (genpd->prepared_count++ == 0)
 768                 genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
 769
 770         genpd_release_lock(genpd);
 771
 772         if (genpd->suspend_power_off) {
 773                 pm_runtime_put_noidle(dev);
 774                 return 0;
 775         }
 776
 777         /*
 778          * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
 779          * so pm_genpd_poweron() will return immediately, but if the device
 780          * is suspended (e.g. it's been stopped by genpd_stop_dev()), we need
 781          * to make it operational.
 782          */
 783         pm_runtime_resume(dev);
 784         __pm_runtime_disable(dev, false);
 785
 786         ret = pm_generic_prepare(dev);
 787         if (ret) {
 788                 mutex_lock(&genpd->lock);
 789
 790                 if (--genpd->prepared_count == 0)
 791                         genpd->suspend_power_off = false;
 792
 793                 mutex_unlock(&genpd->lock);
 794                 pm_runtime_enable(dev);
 795         }
 796
 797         pm_runtime_put_sync(dev);
 798         return ret;
 799 }
 800
 801 /**
 802  * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
 803  * @dev: Device to suspend.
 804  *
 805  * Suspend a device under the assumption that its pm_domain field points to the
 806  * domain member of an object of type struct generic_pm_domain representing
 807  * a PM domain consisting of I/O devices.
 808  */
 809 static int pm_genpd_suspend(struct device *dev)
 810 {
 811         struct generic_pm_domain *genpd;
 812
 813         dev_dbg(dev, "%s()\n", __func__);
 814
 815         genpd = dev_to_genpd(dev);
 816         if (IS_ERR(genpd))
 817                 return -EINVAL;
 818
 819         return genpd->suspend_power_off ? 0 : genpd_suspend_dev(genpd, dev);
 820 }
 821
 822 /**
 823  * pm_genpd_suspend_late - Late suspend of a device from an I/O PM domain.
 824  * @dev: Device to suspend.
 825  *
 826  * Carry out a late suspend of a device under the assumption that its
 827  * pm_domain field points to the domain member of an object of type
 828  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 829  */
 830 static int pm_genpd_suspend_late(struct device *dev)
 831 {
 832         struct generic_pm_domain *genpd;
 833
 834         dev_dbg(dev, "%s()\n", __func__);
 835
 836         genpd = dev_to_genpd(dev);
 837         if (IS_ERR(genpd))
 838                 return -EINVAL;
 839
 840         return genpd->suspend_power_off ? 0 : genpd_suspend_late(genpd, dev);
 841 }
 842
 843 /**
 844  * pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain.
 845  * @dev: Device to suspend.
 846  *
 847  * Stop the device and remove power from the domain if all devices in it have
 848  * been stopped.
 849  */
 850 static int pm_genpd_suspend_noirq(struct device *dev)
 851 {
 852         struct generic_pm_domain *genpd;
 853
 854         dev_dbg(dev, "%s()\n", __func__);
 855
 856         genpd = dev_to_genpd(dev);
 857         if (IS_ERR(genpd))
 858                 return -EINVAL;
 859
 860         if (genpd->suspend_power_off
 861             || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
 862                 return 0;
 863
 864         genpd_stop_dev(genpd, dev);
 865
 866         /*
 867          * Since all of the "noirq" callbacks are executed sequentially, it is
 868          * guaranteed that this function will never run twice in parallel for
 869          * the same PM domain, so it is not necessary to use locking here.
 870          */
 871         genpd->suspended_count++;
 872         pm_genpd_sync_poweroff(genpd);
 873
 874         return 0;
 875 }
 876
 877 /**
 878  * pm_genpd_resume_noirq - Start of resume of device in an I/O PM domain.
 879  * @dev: Device to resume.
 880  *
 881  * Restore power to the device's PM domain, if necessary, and start the device.
 882  */
 883 static int pm_genpd_resume_noirq(struct device *dev)
 884 {
 885         struct generic_pm_domain *genpd;
 886
 887         dev_dbg(dev, "%s()\n", __func__);
 888
 889         genpd = dev_to_genpd(dev);
 890         if (IS_ERR(genpd))
 891                 return -EINVAL;
 892
 893         if (genpd->suspend_power_off
 894             || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
 895                 return 0;
 896
 897         /*
 898          * Since all of the "noirq" callbacks are executed sequentially, it is
 899          * guaranteed that this function will never run twice in parallel for
 900          * the same PM domain, so it is not necessary to use locking here.
 901          */
 902         pm_genpd_poweron(genpd);
 903         genpd->suspended_count--;
 904
 905         return genpd_start_dev(genpd, dev);
 906 }
 907
 908 /**
 909  * pm_genpd_resume_early - Early resume of a device in an I/O PM domain.
 910  * @dev: Device to resume.
 911  *
 912  * Carry out an early resume of a device under the assumption that its
 913  * pm_domain field points to the domain member of an object of type
 914  * struct generic_pm_domain representing a power domain consisting of I/O
 915  * devices.
 916  */
 917 static int pm_genpd_resume_early(struct device *dev)
 918 {
 919         struct generic_pm_domain *genpd;
 920
 921         dev_dbg(dev, "%s()\n", __func__);
 922
 923         genpd = dev_to_genpd(dev);
 924         if (IS_ERR(genpd))
 925                 return -EINVAL;
 926
 927         return genpd->suspend_power_off ? 0 : genpd_resume_early(genpd, dev);
 928 }
 929
 930 /**
 931  * pm_genpd_resume - Resume of device in an I/O PM domain.
 932  * @dev: Device to resume.
 933  *
 934  * Resume a device under the assumption that its pm_domain field points to the
 935  * domain member of an object of type struct generic_pm_domain representing
 936  * a power domain consisting of I/O devices.
 937  */
 938 static int pm_genpd_resume(struct device *dev)
 939 {
 940         struct generic_pm_domain *genpd;
 941
 942         dev_dbg(dev, "%s()\n", __func__);
 943
 944         genpd = dev_to_genpd(dev);
 945         if (IS_ERR(genpd))
 946                 return -EINVAL;
 947
 948         return genpd->suspend_power_off ? 0 : genpd_resume_dev(genpd, dev);
 949 }
 950
 951 /**
 952  * pm_genpd_freeze - Freezing a device in an I/O PM domain.
 953  * @dev: Device to freeze.
 954  *
 955  * Freeze a device under the assumption that its pm_domain field points to the
 956  * domain member of an object of type struct generic_pm_domain representing
 957  * a power domain consisting of I/O devices.
 958  */
 959 static int pm_genpd_freeze(struct device *dev)
 960 {
 961         struct generic_pm_domain *genpd;
 962
 963         dev_dbg(dev, "%s()\n", __func__);
 964
 965         genpd = dev_to_genpd(dev);
 966         if (IS_ERR(genpd))
 967                 return -EINVAL;
 968
 969         return genpd->suspend_power_off ? 0 : genpd_freeze_dev(genpd, dev);
 970 }
 971
 972 /**
 973  * pm_genpd_freeze_late - Late freeze of a device in an I/O PM domain.
 974  * @dev: Device to freeze.
 975  *
 976  * Carry out a late freeze of a device under the assumption that its
 977  * pm_domain field points to the domain member of an object of type
 978  * struct generic_pm_domain representing a power domain consisting of I/O
 979  * devices.
 980  */
 981 static int pm_genpd_freeze_late(struct device *dev)
 982 {
 983         struct generic_pm_domain *genpd;
 984
 985         dev_dbg(dev, "%s()\n", __func__);
 986
 987         genpd = dev_to_genpd(dev);
 988         if (IS_ERR(genpd))
 989                 return -EINVAL;
 990
 991         return genpd->suspend_power_off ? 0 : genpd_freeze_late(genpd, dev);
 992 }
 993
 994 /**
 995  * pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain.
 996  * @dev: Device to freeze.
 997  *
 998  * Carry out a late freeze of a device under the assumption that its
 999  * pm_domain field points to the domain member of an object of type
1000  * struct generic_pm_domain representing a power domain consisting of I/O
1001  * devices.
1002  */
1003 static int pm_genpd_freeze_noirq(struct device *dev)
1004 {
1005         struct generic_pm_domain *genpd;
1006
1007         dev_dbg(dev, "%s()\n", __func__);
1008
1009         genpd = dev_to_genpd(dev);
1010         if (IS_ERR(genpd))
1011                 return -EINVAL;
1012
1013         return genpd->suspend_power_off ? 0 : genpd_stop_dev(genpd, dev);
1014 }
1015
1016 /**
1017  * pm_genpd_thaw_noirq - Early thaw of device in an I/O PM domain.
1018  * @dev: Device to thaw.
1019  *
1020  * Start the device, unless power has been removed from the domain already
1021  * before the system transition.
1022  */
1023 static int pm_genpd_thaw_noirq(struct device *dev)
1024 {
1025         struct generic_pm_domain *genpd;
1026
1027         dev_dbg(dev, "%s()\n", __func__);
1028
1029         genpd = dev_to_genpd(dev);
1030         if (IS_ERR(genpd))
1031                 return -EINVAL;
1032
1033         return genpd->suspend_power_off ? 0 : genpd_start_dev(genpd, dev);
1034 }
1035
1036 /**
1037  * pm_genpd_thaw_early - Early thaw of device in an I/O PM domain.
1038  * @dev: Device to thaw.
1039  *
1040  * Carry out an early thaw of a device under the assumption that its
1041  * pm_domain field points to the domain member of an object of type
1042  * struct generic_pm_domain representing a power domain consisting of I/O
1043  * devices.
1044  */
1045 static int pm_genpd_thaw_early(struct device *dev)
1046 {
1047         struct generic_pm_domain *genpd;
1048
1049         dev_dbg(dev, "%s()\n", __func__);
1050
1051         genpd = dev_to_genpd(dev);
1052         if (IS_ERR(genpd))
1053                 return -EINVAL;
1054
1055         return genpd->suspend_power_off ? 0 : genpd_thaw_early(genpd, dev);
1056 }
1057
1058 /**
1059  * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
1060  * @dev: Device to thaw.
1061  *
1062  * Thaw a device under the assumption that its pm_domain field points to the
1063  * domain member of an object of type struct generic_pm_domain representing
1064  * a power domain consisting of I/O devices.
1065  */
1066 static int pm_genpd_thaw(struct device *dev)
1067 {
1068         struct generic_pm_domain *genpd;
1069
1070         dev_dbg(dev, "%s()\n", __func__);
1071
1072         genpd = dev_to_genpd(dev);
1073         if (IS_ERR(genpd))
1074                 return -EINVAL;
1075
1076         return genpd->suspend_power_off ? 0 : genpd_thaw_dev(genpd, dev);
1077 }
1078
1079 /**
1080  * pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain.
1081  * @dev: Device to resume.
1082  *
1083  * Make sure the domain will be in the same power state as before the
1084  * hibernation the system is resuming from and start the device if necessary.
1085  */
1086 static int pm_genpd_restore_noirq(struct device *dev)
1087 {
1088         struct generic_pm_domain *genpd;
1089
1090         dev_dbg(dev, "%s()\n", __func__);
1091
1092         genpd = dev_to_genpd(dev);
1093         if (IS_ERR(genpd))
1094                 return -EINVAL;
1095
1096         /*
1097          * Since all of the "noirq" callbacks are executed sequentially, it is
1098          * guaranteed that this function will never run twice in parallel for
1099          * the same PM domain, so it is not necessary to use locking here.
1100          */
1101         genpd->status = GPD_STATE_POWER_OFF;
1102         if (genpd->suspend_power_off) {
1103                 /*
1104                  * The boot kernel might put the domain into the power on state,
1105                  * so make sure it really is powered off.
1106                  */
1107                 if (genpd->power_off)
1108                         genpd->power_off(genpd);
1109                 return 0;
1110         }
1111
1112         pm_genpd_poweron(genpd);
1113         genpd->suspended_count--;
1114
1115         return genpd_start_dev(genpd, dev);
1116 }
1117
1118 /**
1119  * pm_genpd_complete - Complete power transition of a device in a power domain.
1120  * @dev: Device to complete the transition of.
1121  *
1122  * Complete a power transition of a device (during a system-wide power
1123  * transition) under the assumption that its pm_domain field points to the
1124  * domain member of an object of type struct generic_pm_domain representing
1125  * a power domain consisting of I/O devices.
1126  */
1127 static void pm_genpd_complete(struct device *dev)
1128 {
1129         struct generic_pm_domain *genpd;
1130         bool run_complete;
1131
1132         dev_dbg(dev, "%s()\n", __func__);
1133
1134         genpd = dev_to_genpd(dev);
1135         if (IS_ERR(genpd))
1136                 return;
1137
1138         mutex_lock(&genpd->lock);
1139
1140         run_complete = !genpd->suspend_power_off;
1141         if (--genpd->prepared_count == 0)
1142                 genpd->suspend_power_off = false;
1143
1144         mutex_unlock(&genpd->lock);
1145
1146         if (run_complete) {
1147                 pm_generic_complete(dev);
1148                 pm_runtime_set_active(dev);
1149                 pm_runtime_enable(dev);
1150                 pm_runtime_idle(dev);
1151         }
1152 }
1153
1154 #else
1155
1156 #define pm_genpd_prepare                NULL
1157 #define pm_genpd_suspend                NULL
1158 #define pm_genpd_suspend_late           NULL
1159 #define pm_genpd_suspend_noirq          NULL
1160 #define pm_genpd_resume_early           NULL
1161 #define pm_genpd_resume_noirq           NULL
1162 #define pm_genpd_resume                 NULL
1163 #define pm_genpd_freeze                 NULL
1164 #define pm_genpd_freeze_late            NULL
1165 #define pm_genpd_freeze_noirq           NULL
1166 #define pm_genpd_thaw_early             NULL
1167 #define pm_genpd_thaw_noirq             NULL
1168 #define pm_genpd_thaw                   NULL
1169 #define pm_genpd_restore_noirq          NULL
1170 #define pm_genpd_complete               NULL
1171
1172 #endif /* CONFIG_PM_SLEEP */
1173
1174 /**
1175  * __pm_genpd_add_device - Add a device to an I/O PM domain.
1176  * @genpd: PM domain to add the device to.
1177  * @dev: Device to be added.
1178  * @td: Set of PM QoS timing parameters to attach to the device.
1179  */
1180 int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
1181                           struct gpd_timing_data *td)
1182 {
1183         struct generic_pm_domain_data *gpd_data;
1184         struct pm_domain_data *pdd;
1185         int ret = 0;
1186
1187         dev_dbg(dev, "%s()\n", __func__);
1188
1189         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1190                 return -EINVAL;
1191
1192         genpd_acquire_lock(genpd);
1193
1194         if (genpd->status == GPD_STATE_POWER_OFF) {
1195                 ret = -EINVAL;
1196                 goto out;
1197         }
1198
1199         if (genpd->prepared_count > 0) {
1200                 ret = -EAGAIN;
1201                 goto out;
1202         }
1203
1204         list_for_each_entry(pdd, &genpd->dev_list, list_node)
1205                 if (pdd->dev == dev) {
1206                         ret = -EINVAL;
1207                         goto out;
1208                 }
1209
1210         gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
1211         if (!gpd_data) {
1212                 ret = -ENOMEM;
1213                 goto out;
1214         }
1215
1216         genpd->device_count++;
1217
1218         dev->pm_domain = &genpd->domain;
1219         dev_pm_get_subsys_data(dev);
1220         dev->power.subsys_data->domain_data = &gpd_data->base;
1221         gpd_data->base.dev = dev;
1222         gpd_data->need_restore = false;
1223         list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
1224         if (td)
1225                 gpd_data->td = *td;
1226
1227  out:
1228         genpd_release_lock(genpd);
1229
1230         return ret;
1231 }
1232
1233 /**
1234  * __pm_genpd_of_add_device - Add a device to an I/O PM domain.
1235  * @genpd_node: Device tree node pointer representing a PM domain to which the
1236  *   the device is added to.
1237  * @dev: Device to be added.
1238  * @td: Set of PM QoS timing parameters to attach to the device.
1239  */
1240 int __pm_genpd_of_add_device(struct device_node *genpd_node, struct device *dev,
1241                              struct gpd_timing_data *td)
1242 {
1243         struct generic_pm_domain *genpd = NULL, *gpd;
1244
1245         dev_dbg(dev, "%s()\n", __func__);
1246
1247         if (IS_ERR_OR_NULL(genpd_node) || IS_ERR_OR_NULL(dev))
1248                 return -EINVAL;
1249
1250         mutex_lock(&gpd_list_lock);
1251         list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
1252                 if (gpd->of_node == genpd_node) {
1253                         genpd = gpd;
1254                         break;
1255                 }
1256         }
1257         mutex_unlock(&gpd_list_lock);
1258
1259         if (!genpd)
1260                 return -EINVAL;
1261
1262         return __pm_genpd_add_device(genpd, dev, td);
1263 }
1264
1265 /**
1266  * pm_genpd_remove_device - Remove a device from an I/O PM domain.
1267  * @genpd: PM domain to remove the device from.
1268  * @dev: Device to be removed.
1269  */
1270 int pm_genpd_remove_device(struct generic_pm_domain *genpd,
1271                            struct device *dev)
1272 {
1273         struct pm_domain_data *pdd;
1274         int ret = -EINVAL;
1275
1276         dev_dbg(dev, "%s()\n", __func__);
1277
1278         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1279                 return -EINVAL;
1280
1281         genpd_acquire_lock(genpd);
1282
1283         if (genpd->prepared_count > 0) {
1284                 ret = -EAGAIN;
1285                 goto out;
1286         }
1287
1288         list_for_each_entry(pdd, &genpd->dev_list, list_node) {
1289                 if (pdd->dev != dev)
1290                         continue;
1291
1292                 list_del_init(&pdd->list_node);
1293                 pdd->dev = NULL;
1294                 dev_pm_put_subsys_data(dev);
1295                 dev->pm_domain = NULL;
1296                 kfree(to_gpd_data(pdd));
1297
1298                 genpd->device_count--;
1299
1300                 ret = 0;
1301                 break;
1302         }
1303
1304  out:
1305         genpd_release_lock(genpd);
1306
1307         return ret;
1308 }
1309
1310 /**
1311  * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
1312  * @genpd: Master PM domain to add the subdomain to.
1313  * @subdomain: Subdomain to be added.
1314  */
1315 int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
1316                            struct generic_pm_domain *subdomain)
1317 {
1318         struct gpd_link *link;
1319         int ret = 0;
1320
1321         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1322                 return -EINVAL;
1323
1324  start:
1325         genpd_acquire_lock(genpd);
1326         mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1327
1328         if (subdomain->status != GPD_STATE_POWER_OFF
1329             && subdomain->status != GPD_STATE_ACTIVE) {
1330                 mutex_unlock(&subdomain->lock);
1331                 genpd_release_lock(genpd);
1332                 goto start;
1333         }
1334
1335         if (genpd->status == GPD_STATE_POWER_OFF
1336             &&  subdomain->status != GPD_STATE_POWER_OFF) {
1337                 ret = -EINVAL;
1338                 goto out;
1339         }
1340
1341         list_for_each_entry(link, &genpd->slave_links, slave_node) {
1342                 if (link->slave == subdomain && link->master == genpd) {
1343                         ret = -EINVAL;
1344                         goto out;
1345                 }
1346         }
1347
1348         link = kzalloc(sizeof(*link), GFP_KERNEL);
1349         if (!link) {
1350                 ret = -ENOMEM;
1351                 goto out;
1352         }
1353         link->master = genpd;
1354         list_add_tail(&link->master_node, &genpd->master_links);
1355         link->slave = subdomain;
1356         list_add_tail(&link->slave_node, &subdomain->slave_links);
1357         if (subdomain->status != GPD_STATE_POWER_OFF)
1358                 genpd_sd_counter_inc(genpd);
1359
1360  out:
1361         mutex_unlock(&subdomain->lock);
1362         genpd_release_lock(genpd);
1363
1364         return ret;
1365 }
1366
1367 /**
1368  * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
1369  * @genpd: Master PM domain to remove the subdomain from.
1370  * @subdomain: Subdomain to be removed.
1371  */
1372 int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
1373                               struct generic_pm_domain *subdomain)
1374 {
1375         struct gpd_link *link;
1376         int ret = -EINVAL;
1377
1378         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1379                 return -EINVAL;
1380
1381  start:
1382         genpd_acquire_lock(genpd);
1383
1384         list_for_each_entry(link, &genpd->master_links, master_node) {
1385                 if (link->slave != subdomain)
1386                         continue;
1387
1388                 mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1389
1390                 if (subdomain->status != GPD_STATE_POWER_OFF
1391                     && subdomain->status != GPD_STATE_ACTIVE) {
1392                         mutex_unlock(&subdomain->lock);
1393                         genpd_release_lock(genpd);
1394                         goto start;
1395                 }
1396
1397                 list_del(&link->master_node);
1398                 list_del(&link->slave_node);
1399                 kfree(link);
1400                 if (subdomain->status != GPD_STATE_POWER_OFF)
1401                         genpd_sd_counter_dec(genpd);
1402
1403                 mutex_unlock(&subdomain->lock);
1404
1405                 ret = 0;
1406                 break;
1407         }
1408
1409         genpd_release_lock(genpd);
1410
1411         return ret;
1412 }
1413
1414 /**
1415  * pm_genpd_add_callbacks - Add PM domain callbacks to a given device.
1416  * @dev: Device to add the callbacks to.
1417  * @ops: Set of callbacks to add.
1418  * @td: Timing data to add to the device along with the callbacks (optional).
1419  */
1420 int pm_genpd_add_callbacks(struct device *dev, struct gpd_dev_ops *ops,
1421                            struct gpd_timing_data *td)
1422 {
1423         struct pm_domain_data *pdd;
1424         int ret = 0;
1425
1426         if (!(dev && dev->power.subsys_data && ops))
1427                 return -EINVAL;
1428
1429         pm_runtime_disable(dev);
1430         device_pm_lock();
1431
1432         pdd = dev->power.subsys_data->domain_data;
1433         if (pdd) {
1434                 struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
1435
1436                 gpd_data->ops = *ops;
1437                 if (td)
1438                         gpd_data->td = *td;
1439         } else {
1440                 ret = -EINVAL;
1441         }
1442
1443         device_pm_unlock();
1444         pm_runtime_enable(dev);
1445
1446         return ret;
1447 }
1448 EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
1449
1450 /**
1451  * __pm_genpd_remove_callbacks - Remove PM domain callbacks from a given device.
1452  * @dev: Device to remove the callbacks from.
1453  * @clear_td: If set, clear the device's timing data too.
1454  */
1455 int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
1456 {
1457         struct pm_domain_data *pdd;
1458         int ret = 0;
1459
1460         if (!(dev && dev->power.subsys_data))
1461                 return -EINVAL;
1462
1463         pm_runtime_disable(dev);
1464         device_pm_lock();
1465
1466         pdd = dev->power.subsys_data->domain_data;
1467         if (pdd) {
1468                 struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
1469
1470                 gpd_data->ops = (struct gpd_dev_ops){ 0 };
1471                 if (clear_td)
1472                         gpd_data->td = (struct gpd_timing_data){ 0 };
1473         } else {
1474                 ret = -EINVAL;
1475         }
1476
1477         device_pm_unlock();
1478         pm_runtime_enable(dev);
1479
1480         return ret;
1481 }
1482 EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
1483
1484 /* Default device callbacks for generic PM domains. */
1485
1486 /**
1487  * pm_genpd_default_save_state - Default "save device state" for PM domians.
1488  * @dev: Device to handle.
1489  */
1490 static int pm_genpd_default_save_state(struct device *dev)
1491 {
1492         int (*cb)(struct device *__dev);
1493         struct device_driver *drv = dev->driver;
1494
1495         cb = dev_gpd_data(dev)->ops.save_state;
1496         if (cb)
1497                 return cb(dev);
1498
1499         if (drv && drv->pm && drv->pm->runtime_suspend)
1500                 return drv->pm->runtime_suspend(dev);
1501
1502         return 0;
1503 }
1504
1505 /**
1506  * pm_genpd_default_restore_state - Default PM domians "restore device state".
1507  * @dev: Device to handle.
1508  */
1509 static int pm_genpd_default_restore_state(struct device *dev)
1510 {
1511         int (*cb)(struct device *__dev);
1512         struct device_driver *drv = dev->driver;
1513
1514         cb = dev_gpd_data(dev)->ops.restore_state;
1515         if (cb)
1516                 return cb(dev);
1517
1518         if (drv && drv->pm && drv->pm->runtime_resume)
1519                 return drv->pm->runtime_resume(dev);
1520
1521         return 0;
1522 }
1523
1524 #ifdef CONFIG_PM_SLEEP
1525
1526 /**
1527  * pm_genpd_default_suspend - Default "device suspend" for PM domians.
1528  * @dev: Device to handle.
1529  */
1530 static int pm_genpd_default_suspend(struct device *dev)
1531 {
1532         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend;
1533
1534         return cb ? cb(dev) : pm_generic_suspend(dev);
1535 }
1536
1537 /**
1538  * pm_genpd_default_suspend_late - Default "late device suspend" for PM domians.
1539  * @dev: Device to handle.
1540  */
1541 static int pm_genpd_default_suspend_late(struct device *dev)
1542 {
1543         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend_late;
1544
1545         return cb ? cb(dev) : pm_generic_suspend_late(dev);
1546 }
1547
1548 /**
1549  * pm_genpd_default_resume_early - Default "early device resume" for PM domians.
1550  * @dev: Device to handle.
1551  */
1552 static int pm_genpd_default_resume_early(struct device *dev)
1553 {
1554         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume_early;
1555
1556         return cb ? cb(dev) : pm_generic_resume_early(dev);
1557 }
1558
1559 /**
1560  * pm_genpd_default_resume - Default "device resume" for PM domians.
1561  * @dev: Device to handle.
1562  */
1563 static int pm_genpd_default_resume(struct device *dev)
1564 {
1565         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume;
1566
1567         return cb ? cb(dev) : pm_generic_resume(dev);
1568 }
1569
1570 /**
1571  * pm_genpd_default_freeze - Default "device freeze" for PM domians.
1572  * @dev: Device to handle.
1573  */
1574 static int pm_genpd_default_freeze(struct device *dev)
1575 {
1576         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze;
1577
1578         return cb ? cb(dev) : pm_generic_freeze(dev);
1579 }
1580
1581 /**
1582  * pm_genpd_default_freeze_late - Default "late device freeze" for PM domians.
1583  * @dev: Device to handle.
1584  */
1585 static int pm_genpd_default_freeze_late(struct device *dev)
1586 {
1587         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze_late;
1588
1589         return cb ? cb(dev) : pm_generic_freeze_late(dev);
1590 }
1591
1592 /**
1593  * pm_genpd_default_thaw_early - Default "early device thaw" for PM domians.
1594  * @dev: Device to handle.
1595  */
1596 static int pm_genpd_default_thaw_early(struct device *dev)
1597 {
1598         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw_early;
1599
1600         return cb ? cb(dev) : pm_generic_thaw_early(dev);
1601 }
1602
1603 /**
1604  * pm_genpd_default_thaw - Default "device thaw" for PM domians.
1605  * @dev: Device to handle.
1606  */
1607 static int pm_genpd_default_thaw(struct device *dev)
1608 {
1609         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw;
1610
1611         return cb ? cb(dev) : pm_generic_thaw(dev);
1612 }
1613
1614 #else /* !CONFIG_PM_SLEEP */
1615
1616 #define pm_genpd_default_suspend        NULL
1617 #define pm_genpd_default_suspend_late   NULL
1618 #define pm_genpd_default_resume_early   NULL
1619 #define pm_genpd_default_resume         NULL
1620 #define pm_genpd_default_freeze         NULL
1621 #define pm_genpd_default_freeze_late    NULL
1622 #define pm_genpd_default_thaw_early     NULL
1623 #define pm_genpd_default_thaw           NULL
1624
1625 #endif /* !CONFIG_PM_SLEEP */
1626
1627 /**
1628  * pm_genpd_init - Initialize a generic I/O PM domain object.
1629  * @genpd: PM domain object to initialize.
1630  * @gov: PM domain governor to associate with the domain (may be NULL).
1631  * @is_off: Initial value of the domain's power_is_off field.
1632  */
1633 void pm_genpd_init(struct generic_pm_domain *genpd,
1634                    struct dev_power_governor *gov, bool is_off)
1635 {
1636         if (IS_ERR_OR_NULL(genpd))
1637                 return;
1638
1639         INIT_LIST_HEAD(&genpd->master_links);
1640         INIT_LIST_HEAD(&genpd->slave_links);
1641         INIT_LIST_HEAD(&genpd->dev_list);
1642         mutex_init(&genpd->lock);
1643         genpd->gov = gov;
1644         INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
1645         genpd->in_progress = 0;
1646         atomic_set(&genpd->sd_count, 0);
1647         genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
1648         init_waitqueue_head(&genpd->status_wait_queue);
1649         genpd->poweroff_task = NULL;
1650         genpd->resume_count = 0;
1651         genpd->device_count = 0;
1652         genpd->suspended_count = 0;
1653         genpd->max_off_time_ns = -1;
1654         genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
1655         genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
1656         genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
1657         genpd->domain.ops.prepare = pm_genpd_prepare;
1658         genpd->domain.ops.suspend = pm_genpd_suspend;
1659         genpd->domain.ops.suspend_late = pm_genpd_suspend_late;
1660         genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
1661         genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
1662         genpd->domain.ops.resume_early = pm_genpd_resume_early;
1663         genpd->domain.ops.resume = pm_genpd_resume;
1664         genpd->domain.ops.freeze = pm_genpd_freeze;
1665         genpd->domain.ops.freeze_late = pm_genpd_freeze_late;
1666         genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
1667         genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
1668         genpd->domain.ops.thaw_early = pm_genpd_thaw_early;
1669         genpd->domain.ops.thaw = pm_genpd_thaw;
1670         genpd->domain.ops.poweroff = pm_genpd_suspend;
1671         genpd->domain.ops.poweroff_late = pm_genpd_suspend_late;
1672         genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq;
1673         genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
1674         genpd->domain.ops.restore_early = pm_genpd_resume_early;
1675         genpd->domain.ops.restore = pm_genpd_resume;
1676         genpd->domain.ops.complete = pm_genpd_complete;
1677         genpd->dev_ops.save_state = pm_genpd_default_save_state;
1678         genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
1679         genpd->dev_ops.suspend = pm_genpd_default_suspend;
1680         genpd->dev_ops.suspend_late = pm_genpd_default_suspend_late;
1681         genpd->dev_ops.resume_early = pm_genpd_default_resume_early;
1682         genpd->dev_ops.resume = pm_genpd_default_resume;
1683         genpd->dev_ops.freeze = pm_genpd_default_freeze;
1684         genpd->dev_ops.freeze_late = pm_genpd_default_freeze_late;
1685         genpd->dev_ops.thaw_early = pm_genpd_default_thaw_early;
1686         genpd->dev_ops.thaw = pm_genpd_default_thaw;
1687         mutex_lock(&gpd_list_lock);
1688         list_add(&genpd->gpd_list_node, &gpd_list);
1689         mutex_unlock(&gpd_list_lock);
1690 }