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 || to_gpd_data(pdd)->always_on))
 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         if (dev_gpd_data(dev)->always_on)
 507                 return -EBUSY;
 508
 509         dev_gpd_data(dev)->td.effective_constraint_ns = -1;
 510         stop_ok = genpd->gov ? genpd->gov->stop_ok : NULL;
 511         if (stop_ok && !stop_ok(dev))
 512                 return -EBUSY;
 513
 514         ret = genpd_stop_dev(genpd, dev);
 515         if (ret)
 516                 return ret;
 517
 518         pm_runtime_update_max_time_suspended(dev,
 519                                 dev_gpd_data(dev)->td.start_latency_ns);
 520
 521         /*
 522          * If power.irq_safe is set, this routine will be run with interrupts
 523          * off, so it can't use mutexes.
 524          */
 525         if (dev->power.irq_safe)
 526                 return 0;
 527
 528         mutex_lock(&genpd->lock);
 529         genpd->in_progress++;
 530         pm_genpd_poweroff(genpd);
 531         genpd->in_progress--;
 532         mutex_unlock(&genpd->lock);
 533
 534         return 0;
 535 }
 536
 537 /**
 538  * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
 539  * @dev: Device to resume.
 540  *
 541  * Carry out a runtime resume of a device under the assumption that its
 542  * pm_domain field points to the domain member of an object of type
 543  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 544  */
 545 static int pm_genpd_runtime_resume(struct device *dev)
 546 {
 547         struct generic_pm_domain *genpd;
 548         DEFINE_WAIT(wait);
 549         int ret;
 550
 551         dev_dbg(dev, "%s()\n", __func__);
 552
 553         genpd = dev_to_genpd(dev);
 554         if (IS_ERR(genpd))
 555                 return -EINVAL;
 556
 557         might_sleep_if(!genpd->dev_irq_safe);
 558
 559         /* If power.irq_safe, the PM domain is never powered off. */
 560         if (dev->power.irq_safe)
 561                 goto out;
 562
 563         mutex_lock(&genpd->lock);
 564         ret = __pm_genpd_poweron(genpd);
 565         if (ret) {
 566                 mutex_unlock(&genpd->lock);
 567                 return ret;
 568         }
 569         genpd->status = GPD_STATE_BUSY;
 570         genpd->resume_count++;
 571         for (;;) {
 572                 prepare_to_wait(&genpd->status_wait_queue, &wait,
 573                                 TASK_UNINTERRUPTIBLE);
 574                 /*
 575                  * If current is the powering off task, we have been called
 576                  * reentrantly from one of the device callbacks, so we should
 577                  * not wait.
 578                  */
 579                 if (!genpd->poweroff_task || genpd->poweroff_task == current)
 580                         break;
 581                 mutex_unlock(&genpd->lock);
 582
 583                 schedule();
 584
 585                 mutex_lock(&genpd->lock);
 586         }
 587         finish_wait(&genpd->status_wait_queue, &wait);
 588         __pm_genpd_restore_device(dev->power.subsys_data->domain_data, genpd);
 589         genpd->resume_count--;
 590         genpd_set_active(genpd);
 591         wake_up_all(&genpd->status_wait_queue);
 592         mutex_unlock(&genpd->lock);
 593
 594  out:
 595         genpd_start_dev(genpd, dev);
 596
 597         return 0;
 598 }
 599
 600 /**
 601  * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
 602  */
 603 void pm_genpd_poweroff_unused(void)
 604 {
 605         struct generic_pm_domain *genpd;
 606
 607         mutex_lock(&gpd_list_lock);
 608
 609         list_for_each_entry(genpd, &gpd_list, gpd_list_node)
 610                 genpd_queue_power_off_work(genpd);
 611
 612         mutex_unlock(&gpd_list_lock);
 613 }
 614
 615 #else
 616
 617 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
 618
 619 #define pm_genpd_runtime_suspend        NULL
 620 #define pm_genpd_runtime_resume         NULL
 621
 622 #endif /* CONFIG_PM_RUNTIME */
 623
 624 #ifdef CONFIG_PM_SLEEP
 625
 626 static bool genpd_dev_active_wakeup(struct generic_pm_domain *genpd,
 627                                     struct device *dev)
 628 {
 629         return GENPD_DEV_CALLBACK(genpd, bool, active_wakeup, dev);
 630 }
 631
 632 static int genpd_suspend_dev(struct generic_pm_domain *genpd, struct device *dev)
 633 {
 634         return GENPD_DEV_CALLBACK(genpd, int, suspend, dev);
 635 }
 636
 637 static int genpd_suspend_late(struct generic_pm_domain *genpd, struct device *dev)
 638 {
 639         return GENPD_DEV_CALLBACK(genpd, int, suspend_late, dev);
 640 }
 641
 642 static int genpd_resume_early(struct generic_pm_domain *genpd, struct device *dev)
 643 {
 644         return GENPD_DEV_CALLBACK(genpd, int, resume_early, dev);
 645 }
 646
 647 static int genpd_resume_dev(struct generic_pm_domain *genpd, struct device *dev)
 648 {
 649         return GENPD_DEV_CALLBACK(genpd, int, resume, dev);
 650 }
 651
 652 static int genpd_freeze_dev(struct generic_pm_domain *genpd, struct device *dev)
 653 {
 654         return GENPD_DEV_CALLBACK(genpd, int, freeze, dev);
 655 }
 656
 657 static int genpd_freeze_late(struct generic_pm_domain *genpd, struct device *dev)
 658 {
 659         return GENPD_DEV_CALLBACK(genpd, int, freeze_late, dev);
 660 }
 661
 662 static int genpd_thaw_early(struct generic_pm_domain *genpd, struct device *dev)
 663 {
 664         return GENPD_DEV_CALLBACK(genpd, int, thaw_early, dev);
 665 }
 666
 667 static int genpd_thaw_dev(struct generic_pm_domain *genpd, struct device *dev)
 668 {
 669         return GENPD_DEV_CALLBACK(genpd, int, thaw, dev);
 670 }
 671
 672 /**
 673  * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
 674  * @genpd: PM domain to power off, if possible.
 675  *
 676  * Check if the given PM domain can be powered off (during system suspend or
 677  * hibernation) and do that if so.  Also, in that case propagate to its masters.
 678  *
 679  * This function is only called in "noirq" stages of system power transitions,
 680  * so it need not acquire locks (all of the "noirq" callbacks are executed
 681  * sequentially, so it is guaranteed that it will never run twice in parallel).
 682  */
 683 static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
 684 {
 685         struct gpd_link *link;
 686
 687         if (genpd->status == GPD_STATE_POWER_OFF)
 688                 return;
 689
 690         if (genpd->suspended_count != genpd->device_count
 691             || atomic_read(&genpd->sd_count) > 0)
 692                 return;
 693
 694         if (genpd->power_off)
 695                 genpd->power_off(genpd);
 696
 697         genpd->status = GPD_STATE_POWER_OFF;
 698
 699         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 700                 genpd_sd_counter_dec(link->master);
 701                 pm_genpd_sync_poweroff(link->master);
 702         }
 703 }
 704
 705 /**
 706  * resume_needed - Check whether to resume a device before system suspend.
 707  * @dev: Device to check.
 708  * @genpd: PM domain the device belongs to.
 709  *
 710  * There are two cases in which a device that can wake up the system from sleep
 711  * states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
 712  * to wake up the system and it has to remain active for this purpose while the
 713  * system is in the sleep state and (2) if the device is not enabled to wake up
 714  * the system from sleep states and it generally doesn't generate wakeup signals
 715  * by itself (those signals are generated on its behalf by other parts of the
 716  * system).  In the latter case it may be necessary to reconfigure the device's
 717  * wakeup settings during system suspend, because it may have been set up to
 718  * signal remote wakeup from the system's working state as needed by runtime PM.
 719  * Return 'true' in either of the above cases.
 720  */
 721 static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
 722 {
 723         bool active_wakeup;
 724
 725         if (!device_can_wakeup(dev))
 726                 return false;
 727
 728         active_wakeup = genpd_dev_active_wakeup(genpd, dev);
 729         return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
 730 }
 731
 732 /**
 733  * pm_genpd_prepare - Start power transition of a device in a PM domain.
 734  * @dev: Device to start the transition of.
 735  *
 736  * Start a power transition of a device (during a system-wide power transition)
 737  * under the assumption that its pm_domain field points to the domain member of
 738  * an object of type struct generic_pm_domain representing a PM domain
 739  * consisting of I/O devices.
 740  */
 741 static int pm_genpd_prepare(struct device *dev)
 742 {
 743         struct generic_pm_domain *genpd;
 744         int ret;
 745
 746         dev_dbg(dev, "%s()\n", __func__);
 747
 748         genpd = dev_to_genpd(dev);
 749         if (IS_ERR(genpd))
 750                 return -EINVAL;
 751
 752         /*
 753          * If a wakeup request is pending for the device, it should be woken up
 754          * at this point and a system wakeup event should be reported if it's
 755          * set up to wake up the system from sleep states.
 756          */
 757         pm_runtime_get_noresume(dev);
 758         if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
 759                 pm_wakeup_event(dev, 0);
 760
 761         if (pm_wakeup_pending()) {
 762                 pm_runtime_put_sync(dev);
 763                 return -EBUSY;
 764         }
 765
 766         if (resume_needed(dev, genpd))
 767                 pm_runtime_resume(dev);
 768
 769         genpd_acquire_lock(genpd);
 770
 771         if (genpd->prepared_count++ == 0) {
 772                 genpd->suspended_count = 0;
 773                 genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
 774         }
 775
 776         genpd_release_lock(genpd);
 777
 778         if (genpd->suspend_power_off) {
 779                 pm_runtime_put_noidle(dev);
 780                 return 0;
 781         }
 782
 783         /*
 784          * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
 785          * so pm_genpd_poweron() will return immediately, but if the device
 786          * is suspended (e.g. it's been stopped by genpd_stop_dev()), we need
 787          * to make it operational.
 788          */
 789         pm_runtime_resume(dev);
 790         __pm_runtime_disable(dev, false);
 791
 792         ret = pm_generic_prepare(dev);
 793         if (ret) {
 794                 mutex_lock(&genpd->lock);
 795
 796                 if (--genpd->prepared_count == 0)
 797                         genpd->suspend_power_off = false;
 798
 799                 mutex_unlock(&genpd->lock);
 800                 pm_runtime_enable(dev);
 801         }
 802
 803         pm_runtime_put_sync(dev);
 804         return ret;
 805 }
 806
 807 /**
 808  * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
 809  * @dev: Device to suspend.
 810  *
 811  * Suspend a device under the assumption that its pm_domain field points to the
 812  * domain member of an object of type struct generic_pm_domain representing
 813  * a PM domain consisting of I/O devices.
 814  */
 815 static int pm_genpd_suspend(struct device *dev)
 816 {
 817         struct generic_pm_domain *genpd;
 818
 819         dev_dbg(dev, "%s()\n", __func__);
 820
 821         genpd = dev_to_genpd(dev);
 822         if (IS_ERR(genpd))
 823                 return -EINVAL;
 824
 825         return genpd->suspend_power_off ? 0 : genpd_suspend_dev(genpd, dev);
 826 }
 827
 828 /**
 829  * pm_genpd_suspend_late - Late suspend of a device from an I/O PM domain.
 830  * @dev: Device to suspend.
 831  *
 832  * Carry out a late suspend of a device under the assumption that its
 833  * pm_domain field points to the domain member of an object of type
 834  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 835  */
 836 static int pm_genpd_suspend_late(struct device *dev)
 837 {
 838         struct generic_pm_domain *genpd;
 839
 840         dev_dbg(dev, "%s()\n", __func__);
 841
 842         genpd = dev_to_genpd(dev);
 843         if (IS_ERR(genpd))
 844                 return -EINVAL;
 845
 846         return genpd->suspend_power_off ? 0 : genpd_suspend_late(genpd, dev);
 847 }
 848
 849 /**
 850  * pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain.
 851  * @dev: Device to suspend.
 852  *
 853  * Stop the device and remove power from the domain if all devices in it have
 854  * been stopped.
 855  */
 856 static int pm_genpd_suspend_noirq(struct device *dev)
 857 {
 858         struct generic_pm_domain *genpd;
 859
 860         dev_dbg(dev, "%s()\n", __func__);
 861
 862         genpd = dev_to_genpd(dev);
 863         if (IS_ERR(genpd))
 864                 return -EINVAL;
 865
 866         if (genpd->suspend_power_off || dev_gpd_data(dev)->always_on
 867             || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
 868                 return 0;
 869
 870         genpd_stop_dev(genpd, dev);
 871
 872         /*
 873          * Since all of the "noirq" callbacks are executed sequentially, it is
 874          * guaranteed that this function will never run twice in parallel for
 875          * the same PM domain, so it is not necessary to use locking here.
 876          */
 877         genpd->suspended_count++;
 878         pm_genpd_sync_poweroff(genpd);
 879
 880         return 0;
 881 }
 882
 883 /**
 884  * pm_genpd_resume_noirq - Start of resume of device in an I/O PM domain.
 885  * @dev: Device to resume.
 886  *
 887  * Restore power to the device's PM domain, if necessary, and start the device.
 888  */
 889 static int pm_genpd_resume_noirq(struct device *dev)
 890 {
 891         struct generic_pm_domain *genpd;
 892
 893         dev_dbg(dev, "%s()\n", __func__);
 894
 895         genpd = dev_to_genpd(dev);
 896         if (IS_ERR(genpd))
 897                 return -EINVAL;
 898
 899         if (genpd->suspend_power_off || dev_gpd_data(dev)->always_on
 900             || (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
 901                 return 0;
 902
 903         /*
 904          * Since all of the "noirq" callbacks are executed sequentially, it is
 905          * guaranteed that this function will never run twice in parallel for
 906          * the same PM domain, so it is not necessary to use locking here.
 907          */
 908         pm_genpd_poweron(genpd);
 909         genpd->suspended_count--;
 910
 911         return genpd_start_dev(genpd, dev);
 912 }
 913
 914 /**
 915  * pm_genpd_resume_early - Early resume of a device in an I/O PM domain.
 916  * @dev: Device to resume.
 917  *
 918  * Carry out an early resume of a device under the assumption that its
 919  * pm_domain field points to the domain member of an object of type
 920  * struct generic_pm_domain representing a power domain consisting of I/O
 921  * devices.
 922  */
 923 static int pm_genpd_resume_early(struct device *dev)
 924 {
 925         struct generic_pm_domain *genpd;
 926
 927         dev_dbg(dev, "%s()\n", __func__);
 928
 929         genpd = dev_to_genpd(dev);
 930         if (IS_ERR(genpd))
 931                 return -EINVAL;
 932
 933         return genpd->suspend_power_off ? 0 : genpd_resume_early(genpd, dev);
 934 }
 935
 936 /**
 937  * pm_genpd_resume - Resume of device in an I/O PM domain.
 938  * @dev: Device to resume.
 939  *
 940  * Resume a device under the assumption that its pm_domain field points to the
 941  * domain member of an object of type struct generic_pm_domain representing
 942  * a power domain consisting of I/O devices.
 943  */
 944 static int pm_genpd_resume(struct device *dev)
 945 {
 946         struct generic_pm_domain *genpd;
 947
 948         dev_dbg(dev, "%s()\n", __func__);
 949
 950         genpd = dev_to_genpd(dev);
 951         if (IS_ERR(genpd))
 952                 return -EINVAL;
 953
 954         return genpd->suspend_power_off ? 0 : genpd_resume_dev(genpd, dev);
 955 }
 956
 957 /**
 958  * pm_genpd_freeze - Freezing a device in an I/O PM domain.
 959  * @dev: Device to freeze.
 960  *
 961  * Freeze a device under the assumption that its pm_domain field points to the
 962  * domain member of an object of type struct generic_pm_domain representing
 963  * a power domain consisting of I/O devices.
 964  */
 965 static int pm_genpd_freeze(struct device *dev)
 966 {
 967         struct generic_pm_domain *genpd;
 968
 969         dev_dbg(dev, "%s()\n", __func__);
 970
 971         genpd = dev_to_genpd(dev);
 972         if (IS_ERR(genpd))
 973                 return -EINVAL;
 974
 975         return genpd->suspend_power_off ? 0 : genpd_freeze_dev(genpd, dev);
 976 }
 977
 978 /**
 979  * pm_genpd_freeze_late - Late freeze of a device in an I/O PM domain.
 980  * @dev: Device to freeze.
 981  *
 982  * Carry out a late freeze of a device under the assumption that its
 983  * pm_domain field points to the domain member of an object of type
 984  * struct generic_pm_domain representing a power domain consisting of I/O
 985  * devices.
 986  */
 987 static int pm_genpd_freeze_late(struct device *dev)
 988 {
 989         struct generic_pm_domain *genpd;
 990
 991         dev_dbg(dev, "%s()\n", __func__);
 992
 993         genpd = dev_to_genpd(dev);
 994         if (IS_ERR(genpd))
 995                 return -EINVAL;
 996
 997         return genpd->suspend_power_off ? 0 : genpd_freeze_late(genpd, dev);
 998 }
 999
1000 /**
1001  * pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain.
1002  * @dev: Device to freeze.
1003  *
1004  * Carry out a late freeze of a device under the assumption that its
1005  * pm_domain field points to the domain member of an object of type
1006  * struct generic_pm_domain representing a power domain consisting of I/O
1007  * devices.
1008  */
1009 static int pm_genpd_freeze_noirq(struct device *dev)
1010 {
1011         struct generic_pm_domain *genpd;
1012
1013         dev_dbg(dev, "%s()\n", __func__);
1014
1015         genpd = dev_to_genpd(dev);
1016         if (IS_ERR(genpd))
1017                 return -EINVAL;
1018
1019         return genpd->suspend_power_off || dev_gpd_data(dev)->always_on ?
1020                 0 : genpd_stop_dev(genpd, dev);
1021 }
1022
1023 /**
1024  * pm_genpd_thaw_noirq - Early thaw of device in an I/O PM domain.
1025  * @dev: Device to thaw.
1026  *
1027  * Start the device, unless power has been removed from the domain already
1028  * before the system transition.
1029  */
1030 static int pm_genpd_thaw_noirq(struct device *dev)
1031 {
1032         struct generic_pm_domain *genpd;
1033
1034         dev_dbg(dev, "%s()\n", __func__);
1035
1036         genpd = dev_to_genpd(dev);
1037         if (IS_ERR(genpd))
1038                 return -EINVAL;
1039
1040         return genpd->suspend_power_off || dev_gpd_data(dev)->always_on ?
1041                 0 : genpd_start_dev(genpd, dev);
1042 }
1043
1044 /**
1045  * pm_genpd_thaw_early - Early thaw of device in an I/O PM domain.
1046  * @dev: Device to thaw.
1047  *
1048  * Carry out an early thaw of a device under the assumption that its
1049  * pm_domain field points to the domain member of an object of type
1050  * struct generic_pm_domain representing a power domain consisting of I/O
1051  * devices.
1052  */
1053 static int pm_genpd_thaw_early(struct device *dev)
1054 {
1055         struct generic_pm_domain *genpd;
1056
1057         dev_dbg(dev, "%s()\n", __func__);
1058
1059         genpd = dev_to_genpd(dev);
1060         if (IS_ERR(genpd))
1061                 return -EINVAL;
1062
1063         return genpd->suspend_power_off ? 0 : genpd_thaw_early(genpd, dev);
1064 }
1065
1066 /**
1067  * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
1068  * @dev: Device to thaw.
1069  *
1070  * Thaw a device under the assumption that its pm_domain field points to the
1071  * domain member of an object of type struct generic_pm_domain representing
1072  * a power domain consisting of I/O devices.
1073  */
1074 static int pm_genpd_thaw(struct device *dev)
1075 {
1076         struct generic_pm_domain *genpd;
1077
1078         dev_dbg(dev, "%s()\n", __func__);
1079
1080         genpd = dev_to_genpd(dev);
1081         if (IS_ERR(genpd))
1082                 return -EINVAL;
1083
1084         return genpd->suspend_power_off ? 0 : genpd_thaw_dev(genpd, dev);
1085 }
1086
1087 /**
1088  * pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain.
1089  * @dev: Device to resume.
1090  *
1091  * Make sure the domain will be in the same power state as before the
1092  * hibernation the system is resuming from and start the device if necessary.
1093  */
1094 static int pm_genpd_restore_noirq(struct device *dev)
1095 {
1096         struct generic_pm_domain *genpd;
1097
1098         dev_dbg(dev, "%s()\n", __func__);
1099
1100         genpd = dev_to_genpd(dev);
1101         if (IS_ERR(genpd))
1102                 return -EINVAL;
1103
1104         /*
1105          * Since all of the "noirq" callbacks are executed sequentially, it is
1106          * guaranteed that this function will never run twice in parallel for
1107          * the same PM domain, so it is not necessary to use locking here.
1108          *
1109          * At this point suspended_count == 0 means we are being run for the
1110          * first time for the given domain in the present cycle.
1111          */
1112         if (genpd->suspended_count++ == 0) {
1113                 /*
1114                  * The boot kernel might put the domain into arbitrary state,
1115                  * so make it appear as powered off to pm_genpd_poweron(), so
1116                  * that it tries to power it on in case it was really off.
1117                  */
1118                 genpd->status = GPD_STATE_POWER_OFF;
1119                 if (genpd->suspend_power_off) {
1120                         /*
1121                          * If the domain was off before the hibernation, make
1122                          * sure it will be off going forward.
1123                          */
1124                         if (genpd->power_off)
1125                                 genpd->power_off(genpd);
1126
1127                         return 0;
1128                 }
1129         }
1130
1131         if (genpd->suspend_power_off)
1132                 return 0;
1133
1134         pm_genpd_poweron(genpd);
1135
1136         return dev_gpd_data(dev)->always_on ? 0 : genpd_start_dev(genpd, dev);
1137 }
1138
1139 /**
1140  * pm_genpd_complete - Complete power transition of a device in a power domain.
1141  * @dev: Device to complete the transition of.
1142  *
1143  * Complete a power transition of a device (during a system-wide power
1144  * transition) under the assumption that its pm_domain field points to the
1145  * domain member of an object of type struct generic_pm_domain representing
1146  * a power domain consisting of I/O devices.
1147  */
1148 static void pm_genpd_complete(struct device *dev)
1149 {
1150         struct generic_pm_domain *genpd;
1151         bool run_complete;
1152
1153         dev_dbg(dev, "%s()\n", __func__);
1154
1155         genpd = dev_to_genpd(dev);
1156         if (IS_ERR(genpd))
1157                 return;
1158
1159         mutex_lock(&genpd->lock);
1160
1161         run_complete = !genpd->suspend_power_off;
1162         if (--genpd->prepared_count == 0)
1163                 genpd->suspend_power_off = false;
1164
1165         mutex_unlock(&genpd->lock);
1166
1167         if (run_complete) {
1168                 pm_generic_complete(dev);
1169                 pm_runtime_set_active(dev);
1170                 pm_runtime_enable(dev);
1171                 pm_runtime_idle(dev);
1172         }
1173 }
1174
1175 #else
1176
1177 #define pm_genpd_prepare                NULL
1178 #define pm_genpd_suspend                NULL
1179 #define pm_genpd_suspend_late           NULL
1180 #define pm_genpd_suspend_noirq          NULL
1181 #define pm_genpd_resume_early           NULL
1182 #define pm_genpd_resume_noirq           NULL
1183 #define pm_genpd_resume                 NULL
1184 #define pm_genpd_freeze                 NULL
1185 #define pm_genpd_freeze_late            NULL
1186 #define pm_genpd_freeze_noirq           NULL
1187 #define pm_genpd_thaw_early             NULL
1188 #define pm_genpd_thaw_noirq             NULL
1189 #define pm_genpd_thaw                   NULL
1190 #define pm_genpd_restore_noirq          NULL
1191 #define pm_genpd_complete               NULL
1192
1193 #endif /* CONFIG_PM_SLEEP */
1194
1195 /**
1196  * __pm_genpd_add_device - Add a device to an I/O PM domain.
1197  * @genpd: PM domain to add the device to.
1198  * @dev: Device to be added.
1199  * @td: Set of PM QoS timing parameters to attach to the device.
1200  */
1201 int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
1202                           struct gpd_timing_data *td)
1203 {
1204         struct generic_pm_domain_data *gpd_data;
1205         struct pm_domain_data *pdd;
1206         int ret = 0;
1207
1208         dev_dbg(dev, "%s()\n", __func__);
1209
1210         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1211                 return -EINVAL;
1212
1213         genpd_acquire_lock(genpd);
1214
1215         if (genpd->status == GPD_STATE_POWER_OFF) {
1216                 ret = -EINVAL;
1217                 goto out;
1218         }
1219
1220         if (genpd->prepared_count > 0) {
1221                 ret = -EAGAIN;
1222                 goto out;
1223         }
1224
1225         list_for_each_entry(pdd, &genpd->dev_list, list_node)
1226                 if (pdd->dev == dev) {
1227                         ret = -EINVAL;
1228                         goto out;
1229                 }
1230
1231         gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
1232         if (!gpd_data) {
1233                 ret = -ENOMEM;
1234                 goto out;
1235         }
1236
1237         genpd->device_count++;
1238
1239         dev->pm_domain = &genpd->domain;
1240         dev_pm_get_subsys_data(dev);
1241         dev->power.subsys_data->domain_data = &gpd_data->base;
1242         gpd_data->base.dev = dev;
1243         gpd_data->need_restore = false;
1244         list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
1245         if (td)
1246                 gpd_data->td = *td;
1247
1248  out:
1249         genpd_release_lock(genpd);
1250
1251         return ret;
1252 }
1253
1254 /**
1255  * __pm_genpd_of_add_device - Add a device to an I/O PM domain.
1256  * @genpd_node: Device tree node pointer representing a PM domain to which the
1257  *   the device is added to.
1258  * @dev: Device to be added.
1259  * @td: Set of PM QoS timing parameters to attach to the device.
1260  */
1261 int __pm_genpd_of_add_device(struct device_node *genpd_node, struct device *dev,
1262                              struct gpd_timing_data *td)
1263 {
1264         struct generic_pm_domain *genpd = NULL, *gpd;
1265
1266         dev_dbg(dev, "%s()\n", __func__);
1267
1268         if (IS_ERR_OR_NULL(genpd_node) || IS_ERR_OR_NULL(dev))
1269                 return -EINVAL;
1270
1271         mutex_lock(&gpd_list_lock);
1272         list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
1273                 if (gpd->of_node == genpd_node) {
1274                         genpd = gpd;
1275                         break;
1276                 }
1277         }
1278         mutex_unlock(&gpd_list_lock);
1279
1280         if (!genpd)
1281                 return -EINVAL;
1282
1283         return __pm_genpd_add_device(genpd, dev, td);
1284 }
1285
1286 /**
1287  * pm_genpd_remove_device - Remove a device from an I/O PM domain.
1288  * @genpd: PM domain to remove the device from.
1289  * @dev: Device to be removed.
1290  */
1291 int pm_genpd_remove_device(struct generic_pm_domain *genpd,
1292                            struct device *dev)
1293 {
1294         struct pm_domain_data *pdd;
1295         int ret = -EINVAL;
1296
1297         dev_dbg(dev, "%s()\n", __func__);
1298
1299         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1300                 return -EINVAL;
1301
1302         genpd_acquire_lock(genpd);
1303
1304         if (genpd->prepared_count > 0) {
1305                 ret = -EAGAIN;
1306                 goto out;
1307         }
1308
1309         list_for_each_entry(pdd, &genpd->dev_list, list_node) {
1310                 if (pdd->dev != dev)
1311                         continue;
1312
1313                 list_del_init(&pdd->list_node);
1314                 pdd->dev = NULL;
1315                 dev_pm_put_subsys_data(dev);
1316                 dev->pm_domain = NULL;
1317                 kfree(to_gpd_data(pdd));
1318
1319                 genpd->device_count--;
1320
1321                 ret = 0;
1322                 break;
1323         }
1324
1325  out:
1326         genpd_release_lock(genpd);
1327
1328         return ret;
1329 }
1330
1331 /**
1332  * pm_genpd_dev_always_on - Set/unset the "always on" flag for a given device.
1333  * @dev: Device to set/unset the flag for.
1334  * @val: The new value of the device's "always on" flag.
1335  */
1336 void pm_genpd_dev_always_on(struct device *dev, bool val)
1337 {
1338         struct pm_subsys_data *psd;
1339         unsigned long flags;
1340
1341         spin_lock_irqsave(&dev->power.lock, flags);
1342
1343         psd = dev_to_psd(dev);
1344         if (psd && psd->domain_data)
1345                 to_gpd_data(psd->domain_data)->always_on = val;
1346
1347         spin_unlock_irqrestore(&dev->power.lock, flags);
1348 }
1349 EXPORT_SYMBOL_GPL(pm_genpd_dev_always_on);
1350
1351 /**
1352  * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
1353  * @genpd: Master PM domain to add the subdomain to.
1354  * @subdomain: Subdomain to be added.
1355  */
1356 int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
1357                            struct generic_pm_domain *subdomain)
1358 {
1359         struct gpd_link *link;
1360         int ret = 0;
1361
1362         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1363                 return -EINVAL;
1364
1365  start:
1366         genpd_acquire_lock(genpd);
1367         mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1368
1369         if (subdomain->status != GPD_STATE_POWER_OFF
1370             && subdomain->status != GPD_STATE_ACTIVE) {
1371                 mutex_unlock(&subdomain->lock);
1372                 genpd_release_lock(genpd);
1373                 goto start;
1374         }
1375
1376         if (genpd->status == GPD_STATE_POWER_OFF
1377             &&  subdomain->status != GPD_STATE_POWER_OFF) {
1378                 ret = -EINVAL;
1379                 goto out;
1380         }
1381
1382         list_for_each_entry(link, &genpd->slave_links, slave_node) {
1383                 if (link->slave == subdomain && link->master == genpd) {
1384                         ret = -EINVAL;
1385                         goto out;
1386                 }
1387         }
1388
1389         link = kzalloc(sizeof(*link), GFP_KERNEL);
1390         if (!link) {
1391                 ret = -ENOMEM;
1392                 goto out;
1393         }
1394         link->master = genpd;
1395         list_add_tail(&link->master_node, &genpd->master_links);
1396         link->slave = subdomain;
1397         list_add_tail(&link->slave_node, &subdomain->slave_links);
1398         if (subdomain->status != GPD_STATE_POWER_OFF)
1399                 genpd_sd_counter_inc(genpd);
1400
1401  out:
1402         mutex_unlock(&subdomain->lock);
1403         genpd_release_lock(genpd);
1404
1405         return ret;
1406 }
1407
1408 /**
1409  * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
1410  * @genpd: Master PM domain to remove the subdomain from.
1411  * @subdomain: Subdomain to be removed.
1412  */
1413 int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
1414                               struct generic_pm_domain *subdomain)
1415 {
1416         struct gpd_link *link;
1417         int ret = -EINVAL;
1418
1419         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1420                 return -EINVAL;
1421
1422  start:
1423         genpd_acquire_lock(genpd);
1424
1425         list_for_each_entry(link, &genpd->master_links, master_node) {
1426                 if (link->slave != subdomain)
1427                         continue;
1428
1429                 mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
1430
1431                 if (subdomain->status != GPD_STATE_POWER_OFF
1432                     && subdomain->status != GPD_STATE_ACTIVE) {
1433                         mutex_unlock(&subdomain->lock);
1434                         genpd_release_lock(genpd);
1435                         goto start;
1436                 }
1437
1438                 list_del(&link->master_node);
1439                 list_del(&link->slave_node);
1440                 kfree(link);
1441                 if (subdomain->status != GPD_STATE_POWER_OFF)
1442                         genpd_sd_counter_dec(genpd);
1443
1444                 mutex_unlock(&subdomain->lock);
1445
1446                 ret = 0;
1447                 break;
1448         }
1449
1450         genpd_release_lock(genpd);
1451
1452         return ret;
1453 }
1454
1455 /**
1456  * pm_genpd_add_callbacks - Add PM domain callbacks to a given device.
1457  * @dev: Device to add the callbacks to.
1458  * @ops: Set of callbacks to add.
1459  * @td: Timing data to add to the device along with the callbacks (optional).
1460  */
1461 int pm_genpd_add_callbacks(struct device *dev, struct gpd_dev_ops *ops,
1462                            struct gpd_timing_data *td)
1463 {
1464         struct pm_domain_data *pdd;
1465         int ret = 0;
1466
1467         if (!(dev && dev->power.subsys_data && ops))
1468                 return -EINVAL;
1469
1470         pm_runtime_disable(dev);
1471         device_pm_lock();
1472
1473         pdd = dev->power.subsys_data->domain_data;
1474         if (pdd) {
1475                 struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
1476
1477                 gpd_data->ops = *ops;
1478                 if (td)
1479                         gpd_data->td = *td;
1480         } else {
1481                 ret = -EINVAL;
1482         }
1483
1484         device_pm_unlock();
1485         pm_runtime_enable(dev);
1486
1487         return ret;
1488 }
1489 EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
1490
1491 /**
1492  * __pm_genpd_remove_callbacks - Remove PM domain callbacks from a given device.
1493  * @dev: Device to remove the callbacks from.
1494  * @clear_td: If set, clear the device's timing data too.
1495  */
1496 int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
1497 {
1498         struct pm_domain_data *pdd;
1499         int ret = 0;
1500
1501         if (!(dev && dev->power.subsys_data))
1502                 return -EINVAL;
1503
1504         pm_runtime_disable(dev);
1505         device_pm_lock();
1506
1507         pdd = dev->power.subsys_data->domain_data;
1508         if (pdd) {
1509                 struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
1510
1511                 gpd_data->ops = (struct gpd_dev_ops){ 0 };
1512                 if (clear_td)
1513                         gpd_data->td = (struct gpd_timing_data){ 0 };
1514         } else {
1515                 ret = -EINVAL;
1516         }
1517
1518         device_pm_unlock();
1519         pm_runtime_enable(dev);
1520
1521         return ret;
1522 }
1523 EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
1524
1525 /* Default device callbacks for generic PM domains. */
1526
1527 /**
1528  * pm_genpd_default_save_state - Default "save device state" for PM domians.
1529  * @dev: Device to handle.
1530  */
1531 static int pm_genpd_default_save_state(struct device *dev)
1532 {
1533         int (*cb)(struct device *__dev);
1534         struct device_driver *drv = dev->driver;
1535
1536         cb = dev_gpd_data(dev)->ops.save_state;
1537         if (cb)
1538                 return cb(dev);
1539
1540         if (drv && drv->pm && drv->pm->runtime_suspend)
1541                 return drv->pm->runtime_suspend(dev);
1542
1543         return 0;
1544 }
1545
1546 /**
1547  * pm_genpd_default_restore_state - Default PM domians "restore device state".
1548  * @dev: Device to handle.
1549  */
1550 static int pm_genpd_default_restore_state(struct device *dev)
1551 {
1552         int (*cb)(struct device *__dev);
1553         struct device_driver *drv = dev->driver;
1554
1555         cb = dev_gpd_data(dev)->ops.restore_state;
1556         if (cb)
1557                 return cb(dev);
1558
1559         if (drv && drv->pm && drv->pm->runtime_resume)
1560                 return drv->pm->runtime_resume(dev);
1561
1562         return 0;
1563 }
1564
1565 #ifdef CONFIG_PM_SLEEP
1566
1567 /**
1568  * pm_genpd_default_suspend - Default "device suspend" for PM domians.
1569  * @dev: Device to handle.
1570  */
1571 static int pm_genpd_default_suspend(struct device *dev)
1572 {
1573         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend;
1574
1575         return cb ? cb(dev) : pm_generic_suspend(dev);
1576 }
1577
1578 /**
1579  * pm_genpd_default_suspend_late - Default "late device suspend" for PM domians.
1580  * @dev: Device to handle.
1581  */
1582 static int pm_genpd_default_suspend_late(struct device *dev)
1583 {
1584         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend_late;
1585
1586         return cb ? cb(dev) : pm_generic_suspend_late(dev);
1587 }
1588
1589 /**
1590  * pm_genpd_default_resume_early - Default "early device resume" for PM domians.
1591  * @dev: Device to handle.
1592  */
1593 static int pm_genpd_default_resume_early(struct device *dev)
1594 {
1595         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume_early;
1596
1597         return cb ? cb(dev) : pm_generic_resume_early(dev);
1598 }
1599
1600 /**
1601  * pm_genpd_default_resume - Default "device resume" for PM domians.
1602  * @dev: Device to handle.
1603  */
1604 static int pm_genpd_default_resume(struct device *dev)
1605 {
1606         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume;
1607
1608         return cb ? cb(dev) : pm_generic_resume(dev);
1609 }
1610
1611 /**
1612  * pm_genpd_default_freeze - Default "device freeze" for PM domians.
1613  * @dev: Device to handle.
1614  */
1615 static int pm_genpd_default_freeze(struct device *dev)
1616 {
1617         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze;
1618
1619         return cb ? cb(dev) : pm_generic_freeze(dev);
1620 }
1621
1622 /**
1623  * pm_genpd_default_freeze_late - Default "late device freeze" for PM domians.
1624  * @dev: Device to handle.
1625  */
1626 static int pm_genpd_default_freeze_late(struct device *dev)
1627 {
1628         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze_late;
1629
1630         return cb ? cb(dev) : pm_generic_freeze_late(dev);
1631 }
1632
1633 /**
1634  * pm_genpd_default_thaw_early - Default "early device thaw" for PM domians.
1635  * @dev: Device to handle.
1636  */
1637 static int pm_genpd_default_thaw_early(struct device *dev)
1638 {
1639         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw_early;
1640
1641         return cb ? cb(dev) : pm_generic_thaw_early(dev);
1642 }
1643
1644 /**
1645  * pm_genpd_default_thaw - Default "device thaw" for PM domians.
1646  * @dev: Device to handle.
1647  */
1648 static int pm_genpd_default_thaw(struct device *dev)
1649 {
1650         int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw;
1651
1652         return cb ? cb(dev) : pm_generic_thaw(dev);
1653 }
1654
1655 #else /* !CONFIG_PM_SLEEP */
1656
1657 #define pm_genpd_default_suspend        NULL
1658 #define pm_genpd_default_suspend_late   NULL
1659 #define pm_genpd_default_resume_early   NULL
1660 #define pm_genpd_default_resume         NULL
1661 #define pm_genpd_default_freeze         NULL
1662 #define pm_genpd_default_freeze_late    NULL
1663 #define pm_genpd_default_thaw_early     NULL
1664 #define pm_genpd_default_thaw           NULL
1665
1666 #endif /* !CONFIG_PM_SLEEP */
1667
1668 /**
1669  * pm_genpd_init - Initialize a generic I/O PM domain object.
1670  * @genpd: PM domain object to initialize.
1671  * @gov: PM domain governor to associate with the domain (may be NULL).
1672  * @is_off: Initial value of the domain's power_is_off field.
1673  */
1674 void pm_genpd_init(struct generic_pm_domain *genpd,
1675                    struct dev_power_governor *gov, bool is_off)
1676 {
1677         if (IS_ERR_OR_NULL(genpd))
1678                 return;
1679
1680         INIT_LIST_HEAD(&genpd->master_links);
1681         INIT_LIST_HEAD(&genpd->slave_links);
1682         INIT_LIST_HEAD(&genpd->dev_list);
1683         mutex_init(&genpd->lock);
1684         genpd->gov = gov;
1685         INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
1686         genpd->in_progress = 0;
1687         atomic_set(&genpd->sd_count, 0);
1688         genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
1689         init_waitqueue_head(&genpd->status_wait_queue);
1690         genpd->poweroff_task = NULL;
1691         genpd->resume_count = 0;
1692         genpd->device_count = 0;
1693         genpd->max_off_time_ns = -1;
1694         genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
1695         genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
1696         genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
1697         genpd->domain.ops.prepare = pm_genpd_prepare;
1698         genpd->domain.ops.suspend = pm_genpd_suspend;
1699         genpd->domain.ops.suspend_late = pm_genpd_suspend_late;
1700         genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
1701         genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
1702         genpd->domain.ops.resume_early = pm_genpd_resume_early;
1703         genpd->domain.ops.resume = pm_genpd_resume;
1704         genpd->domain.ops.freeze = pm_genpd_freeze;
1705         genpd->domain.ops.freeze_late = pm_genpd_freeze_late;
1706         genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
1707         genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
1708         genpd->domain.ops.thaw_early = pm_genpd_thaw_early;
1709         genpd->domain.ops.thaw = pm_genpd_thaw;
1710         genpd->domain.ops.poweroff = pm_genpd_suspend;
1711         genpd->domain.ops.poweroff_late = pm_genpd_suspend_late;
1712         genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq;
1713         genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
1714         genpd->domain.ops.restore_early = pm_genpd_resume_early;
1715         genpd->domain.ops.restore = pm_genpd_resume;
1716         genpd->domain.ops.complete = pm_genpd_complete;
1717         genpd->dev_ops.save_state = pm_genpd_default_save_state;
1718         genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
1719         genpd->dev_ops.suspend = pm_genpd_default_suspend;
1720         genpd->dev_ops.suspend_late = pm_genpd_default_suspend_late;
1721         genpd->dev_ops.resume_early = pm_genpd_default_resume_early;
1722         genpd->dev_ops.resume = pm_genpd_default_resume;
1723         genpd->dev_ops.freeze = pm_genpd_default_freeze;
1724         genpd->dev_ops.freeze_late = pm_genpd_default_freeze_late;
1725         genpd->dev_ops.thaw_early = pm_genpd_default_thaw_early;
1726         genpd->dev_ops.thaw = pm_genpd_default_thaw;
1727         mutex_lock(&gpd_list_lock);
1728         list_add(&genpd->gpd_list_node, &gpd_list);
1729         mutex_unlock(&gpd_list_lock);
1730 }