drivers/base/power/domain.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
genpd_lock_mtx
genpd_lock_nested_mtx
genpd_lock_interruptible_mtx
genpd_unlock_mtx
genpd_lock_spin
genpd_lock_nested_spin
genpd_lock_interruptible_spin
genpd_unlock_spin
irq_safe_dev_in_no_sleep_domain
dev_to_genpd_safe
dev_to_genpd
genpd_stop_dev
genpd_start_dev
genpd_sd_counter_dec
genpd_sd_counter_inc
genpd_update_accounting
genpd_update_accounting
_genpd_reeval_performance_state
_genpd_set_performance_state
dev_pm_genpd_set_performance_state
_genpd_power_on
_genpd_power_off
genpd_queue_power_off_work
genpd_power_off
genpd_power_on
genpd_dev_pm_qos_notifier
genpd_power_off_work_fn
__genpd_runtime_suspend
__genpd_runtime_resume
genpd_runtime_suspend
genpd_runtime_resume
pd_ignore_unused_setup
genpd_power_off_unused
genpd_present
genpd_sync_power_off
genpd_sync_power_on
resume_needed
genpd_prepare
genpd_finish_suspend
genpd_suspend_noirq
genpd_resume_noirq
genpd_freeze_noirq
genpd_thaw_noirq
genpd_poweroff_noirq
genpd_restore_noirq
genpd_complete
genpd_syscore_switch
pm_genpd_syscore_poweroff
pm_genpd_syscore_poweron
genpd_alloc_dev_data
genpd_free_dev_data
genpd_update_cpumask
genpd_set_cpumask
genpd_clear_cpumask
genpd_get_cpu
genpd_add_device
pm_genpd_add_device
genpd_remove_device
pm_genpd_remove_device
genpd_add_subdomain
pm_genpd_add_subdomain
pm_genpd_remove_subdomain
genpd_free_default_power_state
genpd_set_default_power_state
genpd_lock_init
pm_genpd_init
genpd_remove
pm_genpd_remove
genpd_xlate_simple
genpd_xlate_onecell
genpd_add_provider
of_genpd_add_provider_simple
of_genpd_add_provider_onecell
of_genpd_del_provider
genpd_get_from_provider
of_genpd_add_device
of_genpd_add_subdomain
of_genpd_remove_last
genpd_release_dev
genpd_dev_pm_detach
genpd_dev_pm_sync
__genpd_dev_pm_attach
genpd_dev_pm_attach
genpd_dev_pm_attach_by_id
genpd_dev_pm_attach_by_name
genpd_parse_state
genpd_iterate_idle_states
of_genpd_parse_idle_states
pm_genpd_opp_to_performance_state
genpd_bus_init
rtpm_status_str
genpd_summary_one
summary_show
status_show
sub_domains_show
idle_states_show
active_time_show
total_idle_time_show
devices_show
perf_state_show
genpd_debug_init
genpd_debug_exit
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * drivers/base/power/domain.c - Common code related to device power domains.
   4  *
   5  * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
   6  */
   7 #define pr_fmt(fmt) "PM: " fmt
   8 
   9 #include <linux/delay.h>
  10 #include <linux/kernel.h>
  11 #include <linux/io.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/pm_opp.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/pm_domain.h>
  16 #include <linux/pm_qos.h>
  17 #include <linux/pm_clock.h>
  18 #include <linux/slab.h>
  19 #include <linux/err.h>
  20 #include <linux/sched.h>
  21 #include <linux/suspend.h>
  22 #include <linux/export.h>
  23 #include <linux/cpu.h>
  24 
  25 #include "power.h"
  26 
  27 #define GENPD_RETRY_MAX_MS      250             /* Approximate */
  28 
  29 #define GENPD_DEV_CALLBACK(genpd, type, callback, dev)          \
  30 ({                                                              \
  31         type (*__routine)(struct device *__d);                  \
  32         type __ret = (type)0;                                   \
  33                                                                 \
  34         __routine = genpd->dev_ops.callback;                    \
  35         if (__routine) {                                        \
  36                 __ret = __routine(dev);                         \
  37         }                                                       \
  38         __ret;                                                  \
  39 })
  40 
  41 static LIST_HEAD(gpd_list);
  42 static DEFINE_MUTEX(gpd_list_lock);
  43 
  44 struct genpd_lock_ops {
  45         void (*lock)(struct generic_pm_domain *genpd);
  46         void (*lock_nested)(struct generic_pm_domain *genpd, int depth);
  47         int (*lock_interruptible)(struct generic_pm_domain *genpd);
  48         void (*unlock)(struct generic_pm_domain *genpd);
  49 };
  50 
  51 static void genpd_lock_mtx(struct generic_pm_domain *genpd)
  52 {
  53         mutex_lock(&genpd->mlock);
  54 }
  55 
  56 static void genpd_lock_nested_mtx(struct generic_pm_domain *genpd,
  57                                         int depth)
  58 {
  59         mutex_lock_nested(&genpd->mlock, depth);
  60 }
  61 
  62 static int genpd_lock_interruptible_mtx(struct generic_pm_domain *genpd)
  63 {
  64         return mutex_lock_interruptible(&genpd->mlock);
  65 }
  66 
  67 static void genpd_unlock_mtx(struct generic_pm_domain *genpd)
  68 {
  69         return mutex_unlock(&genpd->mlock);
  70 }
  71 
  72 static const struct genpd_lock_ops genpd_mtx_ops = {
  73         .lock = genpd_lock_mtx,
  74         .lock_nested = genpd_lock_nested_mtx,
  75         .lock_interruptible = genpd_lock_interruptible_mtx,
  76         .unlock = genpd_unlock_mtx,
  77 };
  78 
  79 static void genpd_lock_spin(struct generic_pm_domain *genpd)
  80         __acquires(&genpd->slock)
  81 {
  82         unsigned long flags;
  83 
  84         spin_lock_irqsave(&genpd->slock, flags);
  85         genpd->lock_flags = flags;
  86 }
  87 
  88 static void genpd_lock_nested_spin(struct generic_pm_domain *genpd,
  89                                         int depth)
  90         __acquires(&genpd->slock)
  91 {
  92         unsigned long flags;
  93 
  94         spin_lock_irqsave_nested(&genpd->slock, flags, depth);
  95         genpd->lock_flags = flags;
  96 }
  97 
  98 static int genpd_lock_interruptible_spin(struct generic_pm_domain *genpd)
  99         __acquires(&genpd->slock)
 100 {
 101         unsigned long flags;
 102 
 103         spin_lock_irqsave(&genpd->slock, flags);
 104         genpd->lock_flags = flags;
 105         return 0;
 106 }
 107 
 108 static void genpd_unlock_spin(struct generic_pm_domain *genpd)
 109         __releases(&genpd->slock)
 110 {
 111         spin_unlock_irqrestore(&genpd->slock, genpd->lock_flags);
 112 }
 113 
 114 static const struct genpd_lock_ops genpd_spin_ops = {
 115         .lock = genpd_lock_spin,
 116         .lock_nested = genpd_lock_nested_spin,
 117         .lock_interruptible = genpd_lock_interruptible_spin,
 118         .unlock = genpd_unlock_spin,
 119 };
 120 
 121 #define genpd_lock(p)                   p->lock_ops->lock(p)
 122 #define genpd_lock_nested(p, d)         p->lock_ops->lock_nested(p, d)
 123 #define genpd_lock_interruptible(p)     p->lock_ops->lock_interruptible(p)
 124 #define genpd_unlock(p)                 p->lock_ops->unlock(p)
 125 
 126 #define genpd_status_on(genpd)          (genpd->status == GPD_STATE_ACTIVE)
 127 #define genpd_is_irq_safe(genpd)        (genpd->flags & GENPD_FLAG_IRQ_SAFE)
 128 #define genpd_is_always_on(genpd)       (genpd->flags & GENPD_FLAG_ALWAYS_ON)
 129 #define genpd_is_active_wakeup(genpd)   (genpd->flags & GENPD_FLAG_ACTIVE_WAKEUP)
 130 #define genpd_is_cpu_domain(genpd)      (genpd->flags & GENPD_FLAG_CPU_DOMAIN)
 131 #define genpd_is_rpm_always_on(genpd)   (genpd->flags & GENPD_FLAG_RPM_ALWAYS_ON)
 132 
 133 static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev,
 134                 const struct generic_pm_domain *genpd)
 135 {
 136         bool ret;
 137 
 138         ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd);
 139 
 140         /*
 141          * Warn once if an IRQ safe device is attached to a no sleep domain, as
 142          * to indicate a suboptimal configuration for PM. For an always on
 143          * domain this isn't case, thus don't warn.
 144          */
 145         if (ret && !genpd_is_always_on(genpd))
 146                 dev_warn_once(dev, "PM domain %s will not be powered off\n",
 147                                 genpd->name);
 148 
 149         return ret;
 150 }
 151 
 152 static int genpd_runtime_suspend(struct device *dev);
 153 
 154 /*
 155  * Get the generic PM domain for a particular struct device.
 156  * This validates the struct device pointer, the PM domain pointer,
 157  * and checks that the PM domain pointer is a real generic PM domain.
 158  * Any failure results in NULL being returned.
 159  */
 160 static struct generic_pm_domain *dev_to_genpd_safe(struct device *dev)
 161 {
 162         if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain))
 163                 return NULL;
 164 
 165         /* A genpd's always have its ->runtime_suspend() callback assigned. */
 166         if (dev->pm_domain->ops.runtime_suspend == genpd_runtime_suspend)
 167                 return pd_to_genpd(dev->pm_domain);
 168 
 169         return NULL;
 170 }
 171 
 172 /*
 173  * This should only be used where we are certain that the pm_domain
 174  * attached to the device is a genpd domain.
 175  */
 176 static struct generic_pm_domain *dev_to_genpd(struct device *dev)
 177 {
 178         if (IS_ERR_OR_NULL(dev->pm_domain))
 179                 return ERR_PTR(-EINVAL);
 180 
 181         return pd_to_genpd(dev->pm_domain);
 182 }
 183 
 184 static int genpd_stop_dev(const struct generic_pm_domain *genpd,
 185                           struct device *dev)
 186 {
 187         return GENPD_DEV_CALLBACK(genpd, int, stop, dev);
 188 }
 189 
 190 static int genpd_start_dev(const struct generic_pm_domain *genpd,
 191                            struct device *dev)
 192 {
 193         return GENPD_DEV_CALLBACK(genpd, int, start, dev);
 194 }
 195 
 196 static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
 197 {
 198         bool ret = false;
 199 
 200         if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
 201                 ret = !!atomic_dec_and_test(&genpd->sd_count);
 202 
 203         return ret;
 204 }
 205 
 206 static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
 207 {
 208         atomic_inc(&genpd->sd_count);
 209         smp_mb__after_atomic();
 210 }
 211 
 212 #ifdef CONFIG_DEBUG_FS
 213 static void genpd_update_accounting(struct generic_pm_domain *genpd)
 214 {
 215         ktime_t delta, now;
 216 
 217         now = ktime_get();
 218         delta = ktime_sub(now, genpd->accounting_time);
 219 
 220         /*
 221          * If genpd->status is active, it means we are just
 222          * out of off and so update the idle time and vice
 223          * versa.
 224          */
 225         if (genpd->status == GPD_STATE_ACTIVE) {
 226                 int state_idx = genpd->state_idx;
 227 
 228                 genpd->states[state_idx].idle_time =
 229                         ktime_add(genpd->states[state_idx].idle_time, delta);
 230         } else {
 231                 genpd->on_time = ktime_add(genpd->on_time, delta);
 232         }
 233 
 234         genpd->accounting_time = now;
 235 }
 236 #else
 237 static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {}
 238 #endif
 239 
 240 static int _genpd_reeval_performance_state(struct generic_pm_domain *genpd,
 241                                            unsigned int state)
 242 {
 243         struct generic_pm_domain_data *pd_data;
 244         struct pm_domain_data *pdd;
 245         struct gpd_link *link;
 246 
 247         /* New requested state is same as Max requested state */
 248         if (state == genpd->performance_state)
 249                 return state;
 250 
 251         /* New requested state is higher than Max requested state */
 252         if (state > genpd->performance_state)
 253                 return state;
 254 
 255         /* Traverse all devices within the domain */
 256         list_for_each_entry(pdd, &genpd->dev_list, list_node) {
 257                 pd_data = to_gpd_data(pdd);
 258 
 259                 if (pd_data->performance_state > state)
 260                         state = pd_data->performance_state;
 261         }
 262 
 263         /*
 264          * Traverse all sub-domains within the domain. This can be
 265          * done without any additional locking as the link->performance_state
 266          * field is protected by the master genpd->lock, which is already taken.
 267          *
 268          * Also note that link->performance_state (subdomain's performance state
 269          * requirement to master domain) is different from
 270          * link->slave->performance_state (current performance state requirement
 271          * of the devices/sub-domains of the subdomain) and so can have a
 272          * different value.
 273          *
 274          * Note that we also take vote from powered-off sub-domains into account
 275          * as the same is done for devices right now.
 276          */
 277         list_for_each_entry(link, &genpd->master_links, master_node) {
 278                 if (link->performance_state > state)
 279                         state = link->performance_state;
 280         }
 281 
 282         return state;
 283 }
 284 
 285 static int _genpd_set_performance_state(struct generic_pm_domain *genpd,
 286                                         unsigned int state, int depth)
 287 {
 288         struct generic_pm_domain *master;
 289         struct gpd_link *link;
 290         int master_state, ret;
 291 
 292         if (state == genpd->performance_state)
 293                 return 0;
 294 
 295         /* Propagate to masters of genpd */
 296         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 297                 master = link->master;
 298 
 299                 if (!master->set_performance_state)
 300                         continue;
 301 
 302                 /* Find master's performance state */
 303                 ret = dev_pm_opp_xlate_performance_state(genpd->opp_table,
 304                                                          master->opp_table,
 305                                                          state);
 306                 if (unlikely(ret < 0))
 307                         goto err;
 308 
 309                 master_state = ret;
 310 
 311                 genpd_lock_nested(master, depth + 1);
 312 
 313                 link->prev_performance_state = link->performance_state;
 314                 link->performance_state = master_state;
 315                 master_state = _genpd_reeval_performance_state(master,
 316                                                 master_state);
 317                 ret = _genpd_set_performance_state(master, master_state, depth + 1);
 318                 if (ret)
 319                         link->performance_state = link->prev_performance_state;
 320 
 321                 genpd_unlock(master);
 322 
 323                 if (ret)
 324                         goto err;
 325         }
 326 
 327         ret = genpd->set_performance_state(genpd, state);
 328         if (ret)
 329                 goto err;
 330 
 331         genpd->performance_state = state;
 332         return 0;
 333 
 334 err:
 335         /* Encountered an error, lets rollback */
 336         list_for_each_entry_continue_reverse(link, &genpd->slave_links,
 337                                              slave_node) {
 338                 master = link->master;
 339 
 340                 if (!master->set_performance_state)
 341                         continue;
 342 
 343                 genpd_lock_nested(master, depth + 1);
 344 
 345                 master_state = link->prev_performance_state;
 346                 link->performance_state = master_state;
 347 
 348                 master_state = _genpd_reeval_performance_state(master,
 349                                                 master_state);
 350                 if (_genpd_set_performance_state(master, master_state, depth + 1)) {
 351                         pr_err("%s: Failed to roll back to %d performance state\n",
 352                                master->name, master_state);
 353                 }
 354 
 355                 genpd_unlock(master);
 356         }
 357 
 358         return ret;
 359 }
 360 
 361 /**
 362  * dev_pm_genpd_set_performance_state- Set performance state of device's power
 363  * domain.
 364  *
 365  * @dev: Device for which the performance-state needs to be set.
 366  * @state: Target performance state of the device. This can be set as 0 when the
 367  *         device doesn't have any performance state constraints left (And so
 368  *         the device wouldn't participate anymore to find the target
 369  *         performance state of the genpd).
 370  *
 371  * It is assumed that the users guarantee that the genpd wouldn't be detached
 372  * while this routine is getting called.
 373  *
 374  * Returns 0 on success and negative error values on failures.
 375  */
 376 int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state)
 377 {
 378         struct generic_pm_domain *genpd;
 379         struct generic_pm_domain_data *gpd_data;
 380         unsigned int prev;
 381         int ret;
 382 
 383         genpd = dev_to_genpd_safe(dev);
 384         if (!genpd)
 385                 return -ENODEV;
 386 
 387         if (unlikely(!genpd->set_performance_state))
 388                 return -EINVAL;
 389 
 390         if (WARN_ON(!dev->power.subsys_data ||
 391                      !dev->power.subsys_data->domain_data))
 392                 return -EINVAL;
 393 
 394         genpd_lock(genpd);
 395 
 396         gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
 397         prev = gpd_data->performance_state;
 398         gpd_data->performance_state = state;
 399 
 400         state = _genpd_reeval_performance_state(genpd, state);
 401         ret = _genpd_set_performance_state(genpd, state, 0);
 402         if (ret)
 403                 gpd_data->performance_state = prev;
 404 
 405         genpd_unlock(genpd);
 406 
 407         return ret;
 408 }
 409 EXPORT_SYMBOL_GPL(dev_pm_genpd_set_performance_state);
 410 
 411 static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed)
 412 {
 413         unsigned int state_idx = genpd->state_idx;
 414         ktime_t time_start;
 415         s64 elapsed_ns;
 416         int ret;
 417 
 418         if (!genpd->power_on)
 419                 return 0;
 420 
 421         if (!timed)
 422                 return genpd->power_on(genpd);
 423 
 424         time_start = ktime_get();
 425         ret = genpd->power_on(genpd);
 426         if (ret)
 427                 return ret;
 428 
 429         elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 430         if (elapsed_ns <= genpd->states[state_idx].power_on_latency_ns)
 431                 return ret;
 432 
 433         genpd->states[state_idx].power_on_latency_ns = elapsed_ns;
 434         genpd->max_off_time_changed = true;
 435         pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",
 436                  genpd->name, "on", elapsed_ns);
 437 
 438         return ret;
 439 }
 440 
 441 static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed)
 442 {
 443         unsigned int state_idx = genpd->state_idx;
 444         ktime_t time_start;
 445         s64 elapsed_ns;
 446         int ret;
 447 
 448         if (!genpd->power_off)
 449                 return 0;
 450 
 451         if (!timed)
 452                 return genpd->power_off(genpd);
 453 
 454         time_start = ktime_get();
 455         ret = genpd->power_off(genpd);
 456         if (ret)
 457                 return ret;
 458 
 459         elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 460         if (elapsed_ns <= genpd->states[state_idx].power_off_latency_ns)
 461                 return 0;
 462 
 463         genpd->states[state_idx].power_off_latency_ns = elapsed_ns;
 464         genpd->max_off_time_changed = true;
 465         pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",
 466                  genpd->name, "off", elapsed_ns);
 467 
 468         return 0;
 469 }
 470 
 471 /**
 472  * genpd_queue_power_off_work - Queue up the execution of genpd_power_off().
 473  * @genpd: PM domain to power off.
 474  *
 475  * Queue up the execution of genpd_power_off() unless it's already been done
 476  * before.
 477  */
 478 static void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
 479 {
 480         queue_work(pm_wq, &genpd->power_off_work);
 481 }
 482 
 483 /**
 484  * genpd_power_off - Remove power from a given PM domain.
 485  * @genpd: PM domain to power down.
 486  * @one_dev_on: If invoked from genpd's ->runtime_suspend|resume() callback, the
 487  * RPM status of the releated device is in an intermediate state, not yet turned
 488  * into RPM_SUSPENDED. This means genpd_power_off() must allow one device to not
 489  * be RPM_SUSPENDED, while it tries to power off the PM domain.
 490  *
 491  * If all of the @genpd's devices have been suspended and all of its subdomains
 492  * have been powered down, remove power from @genpd.
 493  */
 494 static int genpd_power_off(struct generic_pm_domain *genpd, bool one_dev_on,
 495                            unsigned int depth)
 496 {
 497         struct pm_domain_data *pdd;
 498         struct gpd_link *link;
 499         unsigned int not_suspended = 0;
 500 
 501         /*
 502          * Do not try to power off the domain in the following situations:
 503          * (1) The domain is already in the "power off" state.
 504          * (2) System suspend is in progress.
 505          */
 506         if (!genpd_status_on(genpd) || genpd->prepared_count > 0)
 507                 return 0;
 508 
 509         /*
 510          * Abort power off for the PM domain in the following situations:
 511          * (1) The domain is configured as always on.
 512          * (2) When the domain has a subdomain being powered on.
 513          */
 514         if (genpd_is_always_on(genpd) ||
 515                         genpd_is_rpm_always_on(genpd) ||
 516                         atomic_read(&genpd->sd_count) > 0)
 517                 return -EBUSY;
 518 
 519         list_for_each_entry(pdd, &genpd->dev_list, list_node) {
 520                 enum pm_qos_flags_status stat;
 521 
 522                 stat = dev_pm_qos_flags(pdd->dev, PM_QOS_FLAG_NO_POWER_OFF);
 523                 if (stat > PM_QOS_FLAGS_NONE)
 524                         return -EBUSY;
 525 
 526                 /*
 527                  * Do not allow PM domain to be powered off, when an IRQ safe
 528                  * device is part of a non-IRQ safe domain.
 529                  */
 530                 if (!pm_runtime_suspended(pdd->dev) ||
 531                         irq_safe_dev_in_no_sleep_domain(pdd->dev, genpd))
 532                         not_suspended++;
 533         }
 534 
 535         if (not_suspended > 1 || (not_suspended == 1 && !one_dev_on))
 536                 return -EBUSY;
 537 
 538         if (genpd->gov && genpd->gov->power_down_ok) {
 539                 if (!genpd->gov->power_down_ok(&genpd->domain))
 540                         return -EAGAIN;
 541         }
 542 
 543         /* Default to shallowest state. */
 544         if (!genpd->gov)
 545                 genpd->state_idx = 0;
 546 
 547         if (genpd->power_off) {
 548                 int ret;
 549 
 550                 if (atomic_read(&genpd->sd_count) > 0)
 551                         return -EBUSY;
 552 
 553                 /*
 554                  * If sd_count > 0 at this point, one of the subdomains hasn't
 555                  * managed to call genpd_power_on() for the master yet after
 556                  * incrementing it.  In that case genpd_power_on() will wait
 557                  * for us to drop the lock, so we can call .power_off() and let
 558                  * the genpd_power_on() restore power for us (this shouldn't
 559                  * happen very often).
 560                  */
 561                 ret = _genpd_power_off(genpd, true);
 562                 if (ret)
 563                         return ret;
 564         }
 565 
 566         genpd->status = GPD_STATE_POWER_OFF;
 567         genpd_update_accounting(genpd);
 568 
 569         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 570                 genpd_sd_counter_dec(link->master);
 571                 genpd_lock_nested(link->master, depth + 1);
 572                 genpd_power_off(link->master, false, depth + 1);
 573                 genpd_unlock(link->master);
 574         }
 575 
 576         return 0;
 577 }
 578 
 579 /**
 580  * genpd_power_on - Restore power to a given PM domain and its masters.
 581  * @genpd: PM domain to power up.
 582  * @depth: nesting count for lockdep.
 583  *
 584  * Restore power to @genpd and all of its masters so that it is possible to
 585  * resume a device belonging to it.
 586  */
 587 static int genpd_power_on(struct generic_pm_domain *genpd, unsigned int depth)
 588 {
 589         struct gpd_link *link;
 590         int ret = 0;
 591 
 592         if (genpd_status_on(genpd))
 593                 return 0;
 594 
 595         /*
 596          * The list is guaranteed not to change while the loop below is being
 597          * executed, unless one of the masters' .power_on() callbacks fiddles
 598          * with it.
 599          */
 600         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 601                 struct generic_pm_domain *master = link->master;
 602 
 603                 genpd_sd_counter_inc(master);
 604 
 605                 genpd_lock_nested(master, depth + 1);
 606                 ret = genpd_power_on(master, depth + 1);
 607                 genpd_unlock(master);
 608 
 609                 if (ret) {
 610                         genpd_sd_counter_dec(master);
 611                         goto err;
 612                 }
 613         }
 614 
 615         ret = _genpd_power_on(genpd, true);
 616         if (ret)
 617                 goto err;
 618 
 619         genpd->status = GPD_STATE_ACTIVE;
 620         genpd_update_accounting(genpd);
 621 
 622         return 0;
 623 
 624  err:
 625         list_for_each_entry_continue_reverse(link,
 626                                         &genpd->slave_links,
 627                                         slave_node) {
 628                 genpd_sd_counter_dec(link->master);
 629                 genpd_lock_nested(link->master, depth + 1);
 630                 genpd_power_off(link->master, false, depth + 1);
 631                 genpd_unlock(link->master);
 632         }
 633 
 634         return ret;
 635 }
 636 
 637 static int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
 638                                      unsigned long val, void *ptr)
 639 {
 640         struct generic_pm_domain_data *gpd_data;
 641         struct device *dev;
 642 
 643         gpd_data = container_of(nb, struct generic_pm_domain_data, nb);
 644         dev = gpd_data->base.dev;
 645 
 646         for (;;) {
 647                 struct generic_pm_domain *genpd;
 648                 struct pm_domain_data *pdd;
 649 
 650                 spin_lock_irq(&dev->power.lock);
 651 
 652                 pdd = dev->power.subsys_data ?
 653                                 dev->power.subsys_data->domain_data : NULL;
 654                 if (pdd) {
 655                         to_gpd_data(pdd)->td.constraint_changed = true;
 656                         genpd = dev_to_genpd(dev);
 657                 } else {
 658                         genpd = ERR_PTR(-ENODATA);
 659                 }
 660 
 661                 spin_unlock_irq(&dev->power.lock);
 662 
 663                 if (!IS_ERR(genpd)) {
 664                         genpd_lock(genpd);
 665                         genpd->max_off_time_changed = true;
 666                         genpd_unlock(genpd);
 667                 }
 668 
 669                 dev = dev->parent;
 670                 if (!dev || dev->power.ignore_children)
 671                         break;
 672         }
 673 
 674         return NOTIFY_DONE;
 675 }
 676 
 677 /**
 678  * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
 679  * @work: Work structure used for scheduling the execution of this function.
 680  */
 681 static void genpd_power_off_work_fn(struct work_struct *work)
 682 {
 683         struct generic_pm_domain *genpd;
 684 
 685         genpd = container_of(work, struct generic_pm_domain, power_off_work);
 686 
 687         genpd_lock(genpd);
 688         genpd_power_off(genpd, false, 0);
 689         genpd_unlock(genpd);
 690 }
 691 
 692 /**
 693  * __genpd_runtime_suspend - walk the hierarchy of ->runtime_suspend() callbacks
 694  * @dev: Device to handle.
 695  */
 696 static int __genpd_runtime_suspend(struct device *dev)
 697 {
 698         int (*cb)(struct device *__dev);
 699 
 700         if (dev->type && dev->type->pm)
 701                 cb = dev->type->pm->runtime_suspend;
 702         else if (dev->class && dev->class->pm)
 703                 cb = dev->class->pm->runtime_suspend;
 704         else if (dev->bus && dev->bus->pm)
 705                 cb = dev->bus->pm->runtime_suspend;
 706         else
 707                 cb = NULL;
 708 
 709         if (!cb && dev->driver && dev->driver->pm)
 710                 cb = dev->driver->pm->runtime_suspend;
 711 
 712         return cb ? cb(dev) : 0;
 713 }
 714 
 715 /**
 716  * __genpd_runtime_resume - walk the hierarchy of ->runtime_resume() callbacks
 717  * @dev: Device to handle.
 718  */
 719 static int __genpd_runtime_resume(struct device *dev)
 720 {
 721         int (*cb)(struct device *__dev);
 722 
 723         if (dev->type && dev->type->pm)
 724                 cb = dev->type->pm->runtime_resume;
 725         else if (dev->class && dev->class->pm)
 726                 cb = dev->class->pm->runtime_resume;
 727         else if (dev->bus && dev->bus->pm)
 728                 cb = dev->bus->pm->runtime_resume;
 729         else
 730                 cb = NULL;
 731 
 732         if (!cb && dev->driver && dev->driver->pm)
 733                 cb = dev->driver->pm->runtime_resume;
 734 
 735         return cb ? cb(dev) : 0;
 736 }
 737 
 738 /**
 739  * genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
 740  * @dev: Device to suspend.
 741  *
 742  * Carry out a runtime suspend of a device under the assumption that its
 743  * pm_domain field points to the domain member of an object of type
 744  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 745  */
 746 static int genpd_runtime_suspend(struct device *dev)
 747 {
 748         struct generic_pm_domain *genpd;
 749         bool (*suspend_ok)(struct device *__dev);
 750         struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
 751         bool runtime_pm = pm_runtime_enabled(dev);
 752         ktime_t time_start;
 753         s64 elapsed_ns;
 754         int ret;
 755 
 756         dev_dbg(dev, "%s()\n", __func__);
 757 
 758         genpd = dev_to_genpd(dev);
 759         if (IS_ERR(genpd))
 760                 return -EINVAL;
 761 
 762         /*
 763          * A runtime PM centric subsystem/driver may re-use the runtime PM
 764          * callbacks for other purposes than runtime PM. In those scenarios
 765          * runtime PM is disabled. Under these circumstances, we shall skip
 766          * validating/measuring the PM QoS latency.
 767          */
 768         suspend_ok = genpd->gov ? genpd->gov->suspend_ok : NULL;
 769         if (runtime_pm && suspend_ok && !suspend_ok(dev))
 770                 return -EBUSY;
 771 
 772         /* Measure suspend latency. */
 773         time_start = 0;
 774         if (runtime_pm)
 775                 time_start = ktime_get();
 776 
 777         ret = __genpd_runtime_suspend(dev);
 778         if (ret)
 779                 return ret;
 780 
 781         ret = genpd_stop_dev(genpd, dev);
 782         if (ret) {
 783                 __genpd_runtime_resume(dev);
 784                 return ret;
 785         }
 786 
 787         /* Update suspend latency value if the measured time exceeds it. */
 788         if (runtime_pm) {
 789                 elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 790                 if (elapsed_ns > td->suspend_latency_ns) {
 791                         td->suspend_latency_ns = elapsed_ns;
 792                         dev_dbg(dev, "suspend latency exceeded, %lld ns\n",
 793                                 elapsed_ns);
 794                         genpd->max_off_time_changed = true;
 795                         td->constraint_changed = true;
 796                 }
 797         }
 798 
 799         /*
 800          * If power.irq_safe is set, this routine may be run with
 801          * IRQs disabled, so suspend only if the PM domain also is irq_safe.
 802          */
 803         if (irq_safe_dev_in_no_sleep_domain(dev, genpd))
 804                 return 0;
 805 
 806         genpd_lock(genpd);
 807         genpd_power_off(genpd, true, 0);
 808         genpd_unlock(genpd);
 809 
 810         return 0;
 811 }
 812 
 813 /**
 814  * genpd_runtime_resume - Resume a device belonging to I/O PM domain.
 815  * @dev: Device to resume.
 816  *
 817  * Carry out a runtime resume of a device under the assumption that its
 818  * pm_domain field points to the domain member of an object of type
 819  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
 820  */
 821 static int genpd_runtime_resume(struct device *dev)
 822 {
 823         struct generic_pm_domain *genpd;
 824         struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
 825         bool runtime_pm = pm_runtime_enabled(dev);
 826         ktime_t time_start;
 827         s64 elapsed_ns;
 828         int ret;
 829         bool timed = true;
 830 
 831         dev_dbg(dev, "%s()\n", __func__);
 832 
 833         genpd = dev_to_genpd(dev);
 834         if (IS_ERR(genpd))
 835                 return -EINVAL;
 836 
 837         /*
 838          * As we don't power off a non IRQ safe domain, which holds
 839          * an IRQ safe device, we don't need to restore power to it.
 840          */
 841         if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) {
 842                 timed = false;
 843                 goto out;
 844         }
 845 
 846         genpd_lock(genpd);
 847         ret = genpd_power_on(genpd, 0);
 848         genpd_unlock(genpd);
 849 
 850         if (ret)
 851                 return ret;
 852 
 853  out:
 854         /* Measure resume latency. */
 855         time_start = 0;
 856         if (timed && runtime_pm)
 857                 time_start = ktime_get();
 858 
 859         ret = genpd_start_dev(genpd, dev);
 860         if (ret)
 861                 goto err_poweroff;
 862 
 863         ret = __genpd_runtime_resume(dev);
 864         if (ret)
 865                 goto err_stop;
 866 
 867         /* Update resume latency value if the measured time exceeds it. */
 868         if (timed && runtime_pm) {
 869                 elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 870                 if (elapsed_ns > td->resume_latency_ns) {
 871                         td->resume_latency_ns = elapsed_ns;
 872                         dev_dbg(dev, "resume latency exceeded, %lld ns\n",
 873                                 elapsed_ns);
 874                         genpd->max_off_time_changed = true;
 875                         td->constraint_changed = true;
 876                 }
 877         }
 878 
 879         return 0;
 880 
 881 err_stop:
 882         genpd_stop_dev(genpd, dev);
 883 err_poweroff:
 884         if (!pm_runtime_is_irq_safe(dev) ||
 885                 (pm_runtime_is_irq_safe(dev) && genpd_is_irq_safe(genpd))) {
 886                 genpd_lock(genpd);
 887                 genpd_power_off(genpd, true, 0);
 888                 genpd_unlock(genpd);
 889         }
 890 
 891         return ret;
 892 }
 893 
 894 static bool pd_ignore_unused;
 895 static int __init pd_ignore_unused_setup(char *__unused)
 896 {
 897         pd_ignore_unused = true;
 898         return 1;
 899 }
 900 __setup("pd_ignore_unused", pd_ignore_unused_setup);
 901 
 902 /**
 903  * genpd_power_off_unused - Power off all PM domains with no devices in use.
 904  */
 905 static int __init genpd_power_off_unused(void)
 906 {
 907         struct generic_pm_domain *genpd;
 908 
 909         if (pd_ignore_unused) {
 910                 pr_warn("genpd: Not disabling unused power domains\n");
 911                 return 0;
 912         }
 913 
 914         mutex_lock(&gpd_list_lock);
 915 
 916         list_for_each_entry(genpd, &gpd_list, gpd_list_node)
 917                 genpd_queue_power_off_work(genpd);
 918 
 919         mutex_unlock(&gpd_list_lock);
 920 
 921         return 0;
 922 }
 923 late_initcall(genpd_power_off_unused);
 924 
 925 #if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_GENERIC_DOMAINS_OF)
 926 
 927 static bool genpd_present(const struct generic_pm_domain *genpd)
 928 {
 929         const struct generic_pm_domain *gpd;
 930 
 931         if (IS_ERR_OR_NULL(genpd))
 932                 return false;
 933 
 934         list_for_each_entry(gpd, &gpd_list, gpd_list_node)
 935                 if (gpd == genpd)
 936                         return true;
 937 
 938         return false;
 939 }
 940 
 941 #endif
 942 
 943 #ifdef CONFIG_PM_SLEEP
 944 
 945 /**
 946  * genpd_sync_power_off - Synchronously power off a PM domain and its masters.
 947  * @genpd: PM domain to power off, if possible.
 948  * @use_lock: use the lock.
 949  * @depth: nesting count for lockdep.
 950  *
 951  * Check if the given PM domain can be powered off (during system suspend or
 952  * hibernation) and do that if so.  Also, in that case propagate to its masters.
 953  *
 954  * This function is only called in "noirq" and "syscore" stages of system power
 955  * transitions. The "noirq" callbacks may be executed asynchronously, thus in
 956  * these cases the lock must be held.
 957  */
 958 static void genpd_sync_power_off(struct generic_pm_domain *genpd, bool use_lock,
 959                                  unsigned int depth)
 960 {
 961         struct gpd_link *link;
 962 
 963         if (!genpd_status_on(genpd) || genpd_is_always_on(genpd))
 964                 return;
 965 
 966         if (genpd->suspended_count != genpd->device_count
 967             || atomic_read(&genpd->sd_count) > 0)
 968                 return;
 969 
 970         /* Choose the deepest state when suspending */
 971         genpd->state_idx = genpd->state_count - 1;
 972         if (_genpd_power_off(genpd, false))
 973                 return;
 974 
 975         genpd->status = GPD_STATE_POWER_OFF;
 976 
 977         list_for_each_entry(link, &genpd->slave_links, slave_node) {
 978                 genpd_sd_counter_dec(link->master);
 979 
 980                 if (use_lock)
 981                         genpd_lock_nested(link->master, depth + 1);
 982 
 983                 genpd_sync_power_off(link->master, use_lock, depth + 1);
 984 
 985                 if (use_lock)
 986                         genpd_unlock(link->master);
 987         }
 988 }
 989 
 990 /**
 991  * genpd_sync_power_on - Synchronously power on a PM domain and its masters.
 992  * @genpd: PM domain to power on.
 993  * @use_lock: use the lock.
 994  * @depth: nesting count for lockdep.
 995  *
 996  * This function is only called in "noirq" and "syscore" stages of system power
 997  * transitions. The "noirq" callbacks may be executed asynchronously, thus in
 998  * these cases the lock must be held.
 999  */
1000 static void genpd_sync_power_on(struct generic_pm_domain *genpd, bool use_lock,
1001                                 unsigned int depth)
1002 {
1003         struct gpd_link *link;
1004 
1005         if (genpd_status_on(genpd))
1006                 return;
1007 
1008         list_for_each_entry(link, &genpd->slave_links, slave_node) {
1009                 genpd_sd_counter_inc(link->master);
1010 
1011                 if (use_lock)
1012                         genpd_lock_nested(link->master, depth + 1);
1013 
1014                 genpd_sync_power_on(link->master, use_lock, depth + 1);
1015 
1016                 if (use_lock)
1017                         genpd_unlock(link->master);
1018         }
1019 
1020         _genpd_power_on(genpd, false);
1021 
1022         genpd->status = GPD_STATE_ACTIVE;
1023 }
1024 
1025 /**
1026  * resume_needed - Check whether to resume a device before system suspend.
1027  * @dev: Device to check.
1028  * @genpd: PM domain the device belongs to.
1029  *
1030  * There are two cases in which a device that can wake up the system from sleep
1031  * states should be resumed by genpd_prepare(): (1) if the device is enabled
1032  * to wake up the system and it has to remain active for this purpose while the
1033  * system is in the sleep state and (2) if the device is not enabled to wake up
1034  * the system from sleep states and it generally doesn't generate wakeup signals
1035  * by itself (those signals are generated on its behalf by other parts of the
1036  * system).  In the latter case it may be necessary to reconfigure the device's
1037  * wakeup settings during system suspend, because it may have been set up to
1038  * signal remote wakeup from the system's working state as needed by runtime PM.
1039  * Return 'true' in either of the above cases.
1040  */
1041 static bool resume_needed(struct device *dev,
1042                           const struct generic_pm_domain *genpd)
1043 {
1044         bool active_wakeup;
1045 
1046         if (!device_can_wakeup(dev))
1047                 return false;
1048 
1049         active_wakeup = genpd_is_active_wakeup(genpd);
1050         return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
1051 }
1052 
1053 /**
1054  * genpd_prepare - Start power transition of a device in a PM domain.
1055  * @dev: Device to start the transition of.
1056  *
1057  * Start a power transition of a device (during a system-wide power transition)
1058  * under the assumption that its pm_domain field points to the domain member of
1059  * an object of type struct generic_pm_domain representing a PM domain
1060  * consisting of I/O devices.
1061  */
1062 static int genpd_prepare(struct device *dev)
1063 {
1064         struct generic_pm_domain *genpd;
1065         int ret;
1066 
1067         dev_dbg(dev, "%s()\n", __func__);
1068 
1069         genpd = dev_to_genpd(dev);
1070         if (IS_ERR(genpd))
1071                 return -EINVAL;
1072 
1073         /*
1074          * If a wakeup request is pending for the device, it should be woken up
1075          * at this point and a system wakeup event should be reported if it's
1076          * set up to wake up the system from sleep states.
1077          */
1078         if (resume_needed(dev, genpd))
1079                 pm_runtime_resume(dev);
1080 
1081         genpd_lock(genpd);
1082 
1083         if (genpd->prepared_count++ == 0)
1084                 genpd->suspended_count = 0;
1085 
1086         genpd_unlock(genpd);
1087 
1088         ret = pm_generic_prepare(dev);
1089         if (ret < 0) {
1090                 genpd_lock(genpd);
1091 
1092                 genpd->prepared_count--;
1093 
1094                 genpd_unlock(genpd);
1095         }
1096 
1097         /* Never return 1, as genpd don't cope with the direct_complete path. */
1098         return ret >= 0 ? 0 : ret;
1099 }
1100 
1101 /**
1102  * genpd_finish_suspend - Completion of suspend or hibernation of device in an
1103  *   I/O pm domain.
1104  * @dev: Device to suspend.
1105  * @poweroff: Specifies if this is a poweroff_noirq or suspend_noirq callback.
1106  *
1107  * Stop the device and remove power from the domain if all devices in it have
1108  * been stopped.
1109  */
1110 static int genpd_finish_suspend(struct device *dev, bool poweroff)
1111 {
1112         struct generic_pm_domain *genpd;
1113         int ret = 0;
1114 
1115         genpd = dev_to_genpd(dev);
1116         if (IS_ERR(genpd))
1117                 return -EINVAL;
1118 
1119         if (poweroff)
1120                 ret = pm_generic_poweroff_noirq(dev);
1121         else
1122                 ret = pm_generic_suspend_noirq(dev);
1123         if (ret)
1124                 return ret;
1125 
1126         if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd))
1127                 return 0;
1128 
1129         if (genpd->dev_ops.stop && genpd->dev_ops.start &&
1130             !pm_runtime_status_suspended(dev)) {
1131                 ret = genpd_stop_dev(genpd, dev);
1132                 if (ret) {
1133                         if (poweroff)
1134                                 pm_generic_restore_noirq(dev);
1135                         else
1136                                 pm_generic_resume_noirq(dev);
1137                         return ret;
1138                 }
1139         }
1140 
1141         genpd_lock(genpd);
1142         genpd->suspended_count++;
1143         genpd_sync_power_off(genpd, true, 0);
1144         genpd_unlock(genpd);
1145 
1146         return 0;
1147 }
1148 
1149 /**
1150  * genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain.
1151  * @dev: Device to suspend.
1152  *
1153  * Stop the device and remove power from the domain if all devices in it have
1154  * been stopped.
1155  */
1156 static int genpd_suspend_noirq(struct device *dev)
1157 {
1158         dev_dbg(dev, "%s()\n", __func__);
1159 
1160         return genpd_finish_suspend(dev, false);
1161 }
1162 
1163 /**
1164  * genpd_resume_noirq - Start of resume of device in an I/O PM domain.
1165  * @dev: Device to resume.
1166  *
1167  * Restore power to the device's PM domain, if necessary, and start the device.
1168  */
1169 static int genpd_resume_noirq(struct device *dev)
1170 {
1171         struct generic_pm_domain *genpd;
1172         int ret;
1173 
1174         dev_dbg(dev, "%s()\n", __func__);
1175 
1176         genpd = dev_to_genpd(dev);
1177         if (IS_ERR(genpd))
1178                 return -EINVAL;
1179 
1180         if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd))
1181                 return pm_generic_resume_noirq(dev);
1182 
1183         genpd_lock(genpd);
1184         genpd_sync_power_on(genpd, true, 0);
1185         genpd->suspended_count--;
1186         genpd_unlock(genpd);
1187 
1188         if (genpd->dev_ops.stop && genpd->dev_ops.start &&
1189             !pm_runtime_status_suspended(dev)) {
1190                 ret = genpd_start_dev(genpd, dev);
1191                 if (ret)
1192                         return ret;
1193         }
1194 
1195         return pm_generic_resume_noirq(dev);
1196 }
1197 
1198 /**
1199  * genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain.
1200  * @dev: Device to freeze.
1201  *
1202  * Carry out a late freeze of a device under the assumption that its
1203  * pm_domain field points to the domain member of an object of type
1204  * struct generic_pm_domain representing a power domain consisting of I/O
1205  * devices.
1206  */
1207 static int genpd_freeze_noirq(struct device *dev)
1208 {
1209         const struct generic_pm_domain *genpd;
1210         int ret = 0;
1211 
1212         dev_dbg(dev, "%s()\n", __func__);
1213 
1214         genpd = dev_to_genpd(dev);
1215         if (IS_ERR(genpd))
1216                 return -EINVAL;
1217 
1218         ret = pm_generic_freeze_noirq(dev);
1219         if (ret)
1220                 return ret;
1221 
1222         if (genpd->dev_ops.stop && genpd->dev_ops.start &&
1223             !pm_runtime_status_suspended(dev))
1224                 ret = genpd_stop_dev(genpd, dev);
1225 
1226         return ret;
1227 }
1228 
1229 /**
1230  * genpd_thaw_noirq - Early thaw of device in an I/O PM domain.
1231  * @dev: Device to thaw.
1232  *
1233  * Start the device, unless power has been removed from the domain already
1234  * before the system transition.
1235  */
1236 static int genpd_thaw_noirq(struct device *dev)
1237 {
1238         const struct generic_pm_domain *genpd;
1239         int ret = 0;
1240 
1241         dev_dbg(dev, "%s()\n", __func__);
1242 
1243         genpd = dev_to_genpd(dev);
1244         if (IS_ERR(genpd))
1245                 return -EINVAL;
1246 
1247         if (genpd->dev_ops.stop && genpd->dev_ops.start &&
1248             !pm_runtime_status_suspended(dev)) {
1249                 ret = genpd_start_dev(genpd, dev);
1250                 if (ret)
1251                         return ret;
1252         }
1253 
1254         return pm_generic_thaw_noirq(dev);
1255 }
1256 
1257 /**
1258  * genpd_poweroff_noirq - Completion of hibernation of device in an
1259  *   I/O PM domain.
1260  * @dev: Device to poweroff.
1261  *
1262  * Stop the device and remove power from the domain if all devices in it have
1263  * been stopped.
1264  */
1265 static int genpd_poweroff_noirq(struct device *dev)
1266 {
1267         dev_dbg(dev, "%s()\n", __func__);
1268 
1269         return genpd_finish_suspend(dev, true);
1270 }
1271 
1272 /**
1273  * genpd_restore_noirq - Start of restore of device in an I/O PM domain.
1274  * @dev: Device to resume.
1275  *
1276  * Make sure the domain will be in the same power state as before the
1277  * hibernation the system is resuming from and start the device if necessary.
1278  */
1279 static int genpd_restore_noirq(struct device *dev)
1280 {
1281         struct generic_pm_domain *genpd;
1282         int ret = 0;
1283 
1284         dev_dbg(dev, "%s()\n", __func__);
1285 
1286         genpd = dev_to_genpd(dev);
1287         if (IS_ERR(genpd))
1288                 return -EINVAL;
1289 
1290         /*
1291          * At this point suspended_count == 0 means we are being run for the
1292          * first time for the given domain in the present cycle.
1293          */
1294         genpd_lock(genpd);
1295         if (genpd->suspended_count++ == 0)
1296                 /*
1297                  * The boot kernel might put the domain into arbitrary state,
1298                  * so make it appear as powered off to genpd_sync_power_on(),
1299                  * so that it tries to power it on in case it was really off.
1300                  */
1301                 genpd->status = GPD_STATE_POWER_OFF;
1302 
1303         genpd_sync_power_on(genpd, true, 0);
1304         genpd_unlock(genpd);
1305 
1306         if (genpd->dev_ops.stop && genpd->dev_ops.start &&
1307             !pm_runtime_status_suspended(dev)) {
1308                 ret = genpd_start_dev(genpd, dev);
1309                 if (ret)
1310                         return ret;
1311         }
1312 
1313         return pm_generic_restore_noirq(dev);
1314 }
1315 
1316 /**
1317  * genpd_complete - Complete power transition of a device in a power domain.
1318  * @dev: Device to complete the transition of.
1319  *
1320  * Complete a power transition of a device (during a system-wide power
1321  * transition) under the assumption that its pm_domain field points to the
1322  * domain member of an object of type struct generic_pm_domain representing
1323  * a power domain consisting of I/O devices.
1324  */
1325 static void genpd_complete(struct device *dev)
1326 {
1327         struct generic_pm_domain *genpd;
1328 
1329         dev_dbg(dev, "%s()\n", __func__);
1330 
1331         genpd = dev_to_genpd(dev);
1332         if (IS_ERR(genpd))
1333                 return;
1334 
1335         pm_generic_complete(dev);
1336 
1337         genpd_lock(genpd);
1338 
1339         genpd->prepared_count--;
1340         if (!genpd->prepared_count)
1341                 genpd_queue_power_off_work(genpd);
1342 
1343         genpd_unlock(genpd);
1344 }
1345 
1346 /**
1347  * genpd_syscore_switch - Switch power during system core suspend or resume.
1348  * @dev: Device that normally is marked as "always on" to switch power for.
1349  *
1350  * This routine may only be called during the system core (syscore) suspend or
1351  * resume phase for devices whose "always on" flags are set.
1352  */
1353 static void genpd_syscore_switch(struct device *dev, bool suspend)
1354 {
1355         struct generic_pm_domain *genpd;
1356 
1357         genpd = dev_to_genpd(dev);
1358         if (!genpd_present(genpd))
1359                 return;
1360 
1361         if (suspend) {
1362                 genpd->suspended_count++;
1363                 genpd_sync_power_off(genpd, false, 0);
1364         } else {
1365                 genpd_sync_power_on(genpd, false, 0);
1366                 genpd->suspended_count--;
1367         }
1368 }
1369 
1370 void pm_genpd_syscore_poweroff(struct device *dev)
1371 {
1372         genpd_syscore_switch(dev, true);
1373 }
1374 EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff);
1375 
1376 void pm_genpd_syscore_poweron(struct device *dev)
1377 {
1378         genpd_syscore_switch(dev, false);
1379 }
1380 EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron);
1381 
1382 #else /* !CONFIG_PM_SLEEP */
1383 
1384 #define genpd_prepare           NULL
1385 #define genpd_suspend_noirq     NULL
1386 #define genpd_resume_noirq      NULL
1387 #define genpd_freeze_noirq      NULL
1388 #define genpd_thaw_noirq        NULL
1389 #define genpd_poweroff_noirq    NULL
1390 #define genpd_restore_noirq     NULL
1391 #define genpd_complete          NULL
1392 
1393 #endif /* CONFIG_PM_SLEEP */
1394 
1395 static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev)
1396 {
1397         struct generic_pm_domain_data *gpd_data;
1398         int ret;
1399 
1400         ret = dev_pm_get_subsys_data(dev);
1401         if (ret)
1402                 return ERR_PTR(ret);
1403 
1404         gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
1405         if (!gpd_data) {
1406                 ret = -ENOMEM;
1407                 goto err_put;
1408         }
1409 
1410         gpd_data->base.dev = dev;
1411         gpd_data->td.constraint_changed = true;
1412         gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;
1413         gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;
1414 
1415         spin_lock_irq(&dev->power.lock);
1416 
1417         if (dev->power.subsys_data->domain_data) {
1418                 ret = -EINVAL;
1419                 goto err_free;
1420         }
1421 
1422         dev->power.subsys_data->domain_data = &gpd_data->base;
1423 
1424         spin_unlock_irq(&dev->power.lock);
1425 
1426         return gpd_data;
1427 
1428  err_free:
1429         spin_unlock_irq(&dev->power.lock);
1430         kfree(gpd_data);
1431  err_put:
1432         dev_pm_put_subsys_data(dev);
1433         return ERR_PTR(ret);
1434 }
1435 
1436 static void genpd_free_dev_data(struct device *dev,
1437                                 struct generic_pm_domain_data *gpd_data)
1438 {
1439         spin_lock_irq(&dev->power.lock);
1440 
1441         dev->power.subsys_data->domain_data = NULL;
1442 
1443         spin_unlock_irq(&dev->power.lock);
1444 
1445         kfree(gpd_data);
1446         dev_pm_put_subsys_data(dev);
1447 }
1448 
1449 static void genpd_update_cpumask(struct generic_pm_domain *genpd,
1450                                  int cpu, bool set, unsigned int depth)
1451 {
1452         struct gpd_link *link;
1453 
1454         if (!genpd_is_cpu_domain(genpd))
1455                 return;
1456 
1457         list_for_each_entry(link, &genpd->slave_links, slave_node) {
1458                 struct generic_pm_domain *master = link->master;
1459 
1460                 genpd_lock_nested(master, depth + 1);
1461                 genpd_update_cpumask(master, cpu, set, depth + 1);
1462                 genpd_unlock(master);
1463         }
1464 
1465         if (set)
1466                 cpumask_set_cpu(cpu, genpd->cpus);
1467         else
1468                 cpumask_clear_cpu(cpu, genpd->cpus);
1469 }
1470 
1471 static void genpd_set_cpumask(struct generic_pm_domain *genpd, int cpu)
1472 {
1473         if (cpu >= 0)
1474                 genpd_update_cpumask(genpd, cpu, true, 0);
1475 }
1476 
1477 static void genpd_clear_cpumask(struct generic_pm_domain *genpd, int cpu)
1478 {
1479         if (cpu >= 0)
1480                 genpd_update_cpumask(genpd, cpu, false, 0);
1481 }
1482 
1483 static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev)
1484 {
1485         int cpu;
1486 
1487         if (!genpd_is_cpu_domain(genpd))
1488                 return -1;
1489 
1490         for_each_possible_cpu(cpu) {
1491                 if (get_cpu_device(cpu) == dev)
1492                         return cpu;
1493         }
1494 
1495         return -1;
1496 }
1497 
1498 static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
1499                             struct device *base_dev)
1500 {
1501         struct generic_pm_domain_data *gpd_data;
1502         int ret;
1503 
1504         dev_dbg(dev, "%s()\n", __func__);
1505 
1506         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
1507                 return -EINVAL;
1508 
1509         gpd_data = genpd_alloc_dev_data(dev);
1510         if (IS_ERR(gpd_data))
1511                 return PTR_ERR(gpd_data);
1512 
1513         gpd_data->cpu = genpd_get_cpu(genpd, base_dev);
1514 
1515         ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0;
1516         if (ret)
1517                 goto out;
1518 
1519         genpd_lock(genpd);
1520 
1521         genpd_set_cpumask(genpd, gpd_data->cpu);
1522         dev_pm_domain_set(dev, &genpd->domain);
1523 
1524         genpd->device_count++;
1525         genpd->max_off_time_changed = true;
1526 
1527         list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
1528 
1529         genpd_unlock(genpd);
1530  out:
1531         if (ret)
1532                 genpd_free_dev_data(dev, gpd_data);
1533         else
1534                 dev_pm_qos_add_notifier(dev, &gpd_data->nb,
1535                                         DEV_PM_QOS_RESUME_LATENCY);
1536 
1537         return ret;
1538 }
1539 
1540 /**
1541  * pm_genpd_add_device - Add a device to an I/O PM domain.
1542  * @genpd: PM domain to add the device to.
1543  * @dev: Device to be added.
1544  */
1545 int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
1546 {
1547         int ret;
1548 
1549         mutex_lock(&gpd_list_lock);
1550         ret = genpd_add_device(genpd, dev, dev);
1551         mutex_unlock(&gpd_list_lock);
1552 
1553         return ret;
1554 }
1555 EXPORT_SYMBOL_GPL(pm_genpd_add_device);
1556 
1557 static int genpd_remove_device(struct generic_pm_domain *genpd,
1558                                struct device *dev)
1559 {
1560         struct generic_pm_domain_data *gpd_data;
1561         struct pm_domain_data *pdd;
1562         int ret = 0;
1563 
1564         dev_dbg(dev, "%s()\n", __func__);
1565 
1566         pdd = dev->power.subsys_data->domain_data;
1567         gpd_data = to_gpd_data(pdd);
1568         dev_pm_qos_remove_notifier(dev, &gpd_data->nb,
1569                                    DEV_PM_QOS_RESUME_LATENCY);
1570 
1571         genpd_lock(genpd);
1572 
1573         if (genpd->prepared_count > 0) {
1574                 ret = -EAGAIN;
1575                 goto out;
1576         }
1577 
1578         genpd->device_count--;
1579         genpd->max_off_time_changed = true;
1580 
1581         genpd_clear_cpumask(genpd, gpd_data->cpu);
1582         dev_pm_domain_set(dev, NULL);
1583 
1584         list_del_init(&pdd->list_node);
1585 
1586         genpd_unlock(genpd);
1587 
1588         if (genpd->detach_dev)
1589                 genpd->detach_dev(genpd, dev);
1590 
1591         genpd_free_dev_data(dev, gpd_data);
1592 
1593         return 0;
1594 
1595  out:
1596         genpd_unlock(genpd);
1597         dev_pm_qos_add_notifier(dev, &gpd_data->nb, DEV_PM_QOS_RESUME_LATENCY);
1598 
1599         return ret;
1600 }
1601 
1602 /**
1603  * pm_genpd_remove_device - Remove a device from an I/O PM domain.
1604  * @dev: Device to be removed.
1605  */
1606 int pm_genpd_remove_device(struct device *dev)
1607 {
1608         struct generic_pm_domain *genpd = dev_to_genpd_safe(dev);
1609 
1610         if (!genpd)
1611                 return -EINVAL;
1612 
1613         return genpd_remove_device(genpd, dev);
1614 }
1615 EXPORT_SYMBOL_GPL(pm_genpd_remove_device);
1616 
1617 static int genpd_add_subdomain(struct generic_pm_domain *genpd,
1618                                struct generic_pm_domain *subdomain)
1619 {
1620         struct gpd_link *link, *itr;
1621         int ret = 0;
1622 
1623         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)
1624             || genpd == subdomain)
1625                 return -EINVAL;
1626 
1627         /*
1628          * If the domain can be powered on/off in an IRQ safe
1629          * context, ensure that the subdomain can also be
1630          * powered on/off in that context.
1631          */
1632         if (!genpd_is_irq_safe(genpd) && genpd_is_irq_safe(subdomain)) {
1633                 WARN(1, "Parent %s of subdomain %s must be IRQ safe\n",
1634                                 genpd->name, subdomain->name);
1635                 return -EINVAL;
1636         }
1637 
1638         link = kzalloc(sizeof(*link), GFP_KERNEL);
1639         if (!link)
1640                 return -ENOMEM;
1641 
1642         genpd_lock(subdomain);
1643         genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING);
1644 
1645         if (!genpd_status_on(genpd) && genpd_status_on(subdomain)) {
1646                 ret = -EINVAL;
1647                 goto out;
1648         }
1649 
1650         list_for_each_entry(itr, &genpd->master_links, master_node) {
1651                 if (itr->slave == subdomain && itr->master == genpd) {
1652                         ret = -EINVAL;
1653                         goto out;
1654                 }
1655         }
1656 
1657         link->master = genpd;
1658         list_add_tail(&link->master_node, &genpd->master_links);
1659         link->slave = subdomain;
1660         list_add_tail(&link->slave_node, &subdomain->slave_links);
1661         if (genpd_status_on(subdomain))
1662                 genpd_sd_counter_inc(genpd);
1663 
1664  out:
1665         genpd_unlock(genpd);
1666         genpd_unlock(subdomain);
1667         if (ret)
1668                 kfree(link);
1669         return ret;
1670 }
1671 
1672 /**
1673  * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
1674  * @genpd: Master PM domain to add the subdomain to.
1675  * @subdomain: Subdomain to be added.
1676  */
1677 int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
1678                            struct generic_pm_domain *subdomain)
1679 {
1680         int ret;
1681 
1682         mutex_lock(&gpd_list_lock);
1683         ret = genpd_add_subdomain(genpd, subdomain);
1684         mutex_unlock(&gpd_list_lock);
1685 
1686         return ret;
1687 }
1688 EXPORT_SYMBOL_GPL(pm_genpd_add_subdomain);
1689 
1690 /**
1691  * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
1692  * @genpd: Master PM domain to remove the subdomain from.
1693  * @subdomain: Subdomain to be removed.
1694  */
1695 int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
1696                               struct generic_pm_domain *subdomain)
1697 {
1698         struct gpd_link *l, *link;
1699         int ret = -EINVAL;
1700 
1701         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
1702                 return -EINVAL;
1703 
1704         genpd_lock(subdomain);
1705         genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING);
1706 
1707         if (!list_empty(&subdomain->master_links) || subdomain->device_count) {
1708                 pr_warn("%s: unable to remove subdomain %s\n",
1709                         genpd->name, subdomain->name);
1710                 ret = -EBUSY;
1711                 goto out;
1712         }
1713 
1714         list_for_each_entry_safe(link, l, &genpd->master_links, master_node) {
1715                 if (link->slave != subdomain)
1716                         continue;
1717 
1718                 list_del(&link->master_node);
1719                 list_del(&link->slave_node);
1720                 kfree(link);
1721                 if (genpd_status_on(subdomain))
1722                         genpd_sd_counter_dec(genpd);
1723 
1724                 ret = 0;
1725                 break;
1726         }
1727 
1728 out:
1729         genpd_unlock(genpd);
1730         genpd_unlock(subdomain);
1731 
1732         return ret;
1733 }
1734 EXPORT_SYMBOL_GPL(pm_genpd_remove_subdomain);
1735 
1736 static void genpd_free_default_power_state(struct genpd_power_state *states,
1737                                            unsigned int state_count)
1738 {
1739         kfree(states);
1740 }
1741 
1742 static int genpd_set_default_power_state(struct generic_pm_domain *genpd)
1743 {
1744         struct genpd_power_state *state;
1745 
1746         state = kzalloc(sizeof(*state), GFP_KERNEL);
1747         if (!state)
1748                 return -ENOMEM;
1749 
1750         genpd->states = state;
1751         genpd->state_count = 1;
1752         genpd->free_states = genpd_free_default_power_state;
1753 
1754         return 0;
1755 }
1756 
1757 static void genpd_lock_init(struct generic_pm_domain *genpd)
1758 {
1759         if (genpd->flags & GENPD_FLAG_IRQ_SAFE) {
1760                 spin_lock_init(&genpd->slock);
1761                 genpd->lock_ops = &genpd_spin_ops;
1762         } else {
1763                 mutex_init(&genpd->mlock);
1764                 genpd->lock_ops = &genpd_mtx_ops;
1765         }
1766 }
1767 
1768 /**
1769  * pm_genpd_init - Initialize a generic I/O PM domain object.
1770  * @genpd: PM domain object to initialize.
1771  * @gov: PM domain governor to associate with the domain (may be NULL).
1772  * @is_off: Initial value of the domain's power_is_off field.
1773  *
1774  * Returns 0 on successful initialization, else a negative error code.
1775  */
1776 int pm_genpd_init(struct generic_pm_domain *genpd,
1777                   struct dev_power_governor *gov, bool is_off)
1778 {
1779         int ret;
1780 
1781         if (IS_ERR_OR_NULL(genpd))
1782                 return -EINVAL;
1783 
1784         INIT_LIST_HEAD(&genpd->master_links);
1785         INIT_LIST_HEAD(&genpd->slave_links);
1786         INIT_LIST_HEAD(&genpd->dev_list);
1787         genpd_lock_init(genpd);
1788         genpd->gov = gov;
1789         INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
1790         atomic_set(&genpd->sd_count, 0);
1791         genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
1792         genpd->device_count = 0;
1793         genpd->max_off_time_ns = -1;
1794         genpd->max_off_time_changed = true;
1795         genpd->provider = NULL;
1796         genpd->has_provider = false;
1797         genpd->accounting_time = ktime_get();
1798         genpd->domain.ops.runtime_suspend = genpd_runtime_suspend;
1799         genpd->domain.ops.runtime_resume = genpd_runtime_resume;
1800         genpd->domain.ops.prepare = genpd_prepare;
1801         genpd->domain.ops.suspend_noirq = genpd_suspend_noirq;
1802         genpd->domain.ops.resume_noirq = genpd_resume_noirq;
1803         genpd->domain.ops.freeze_noirq = genpd_freeze_noirq;
1804         genpd->domain.ops.thaw_noirq = genpd_thaw_noirq;
1805         genpd->domain.ops.poweroff_noirq = genpd_poweroff_noirq;
1806         genpd->domain.ops.restore_noirq = genpd_restore_noirq;
1807         genpd->domain.ops.complete = genpd_complete;
1808 
1809         if (genpd->flags & GENPD_FLAG_PM_CLK) {
1810                 genpd->dev_ops.stop = pm_clk_suspend;
1811                 genpd->dev_ops.start = pm_clk_resume;
1812         }
1813 
1814         /* Always-on domains must be powered on at initialization. */
1815         if ((genpd_is_always_on(genpd) || genpd_is_rpm_always_on(genpd)) &&
1816                         !genpd_status_on(genpd))
1817                 return -EINVAL;
1818 
1819         if (genpd_is_cpu_domain(genpd) &&
1820             !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL))
1821                 return -ENOMEM;
1822 
1823         /* Use only one "off" state if there were no states declared */
1824         if (genpd->state_count == 0) {
1825                 ret = genpd_set_default_power_state(genpd);
1826                 if (ret) {
1827                         if (genpd_is_cpu_domain(genpd))
1828                                 free_cpumask_var(genpd->cpus);
1829                         return ret;
1830                 }
1831         } else if (!gov && genpd->state_count > 1) {
1832                 pr_warn("%s: no governor for states\n", genpd->name);
1833         }
1834 
1835         device_initialize(&genpd->dev);
1836         dev_set_name(&genpd->dev, "%s", genpd->name);
1837 
1838         mutex_lock(&gpd_list_lock);
1839         list_add(&genpd->gpd_list_node, &gpd_list);
1840         mutex_unlock(&gpd_list_lock);
1841 
1842         return 0;
1843 }
1844 EXPORT_SYMBOL_GPL(pm_genpd_init);
1845 
1846 static int genpd_remove(struct generic_pm_domain *genpd)
1847 {
1848         struct gpd_link *l, *link;
1849 
1850         if (IS_ERR_OR_NULL(genpd))
1851                 return -EINVAL;
1852 
1853         genpd_lock(genpd);
1854 
1855         if (genpd->has_provider) {
1856                 genpd_unlock(genpd);
1857                 pr_err("Provider present, unable to remove %s\n", genpd->name);
1858                 return -EBUSY;
1859         }
1860 
1861         if (!list_empty(&genpd->master_links) || genpd->device_count) {
1862                 genpd_unlock(genpd);
1863                 pr_err("%s: unable to remove %s\n", __func__, genpd->name);
1864                 return -EBUSY;
1865         }
1866 
1867         list_for_each_entry_safe(link, l, &genpd->slave_links, slave_node) {
1868                 list_del(&link->master_node);
1869                 list_del(&link->slave_node);
1870                 kfree(link);
1871         }
1872 
1873         list_del(&genpd->gpd_list_node);
1874         genpd_unlock(genpd);
1875         cancel_work_sync(&genpd->power_off_work);
1876         if (genpd_is_cpu_domain(genpd))
1877                 free_cpumask_var(genpd->cpus);
1878         if (genpd->free_states)
1879                 genpd->free_states(genpd->states, genpd->state_count);
1880 
1881         pr_debug("%s: removed %s\n", __func__, genpd->name);
1882 
1883         return 0;
1884 }
1885 
1886 /**
1887  * pm_genpd_remove - Remove a generic I/O PM domain
1888  * @genpd: Pointer to PM domain that is to be removed.
1889  *
1890  * To remove the PM domain, this function:
1891  *  - Removes the PM domain as a subdomain to any parent domains,
1892  *    if it was added.
1893  *  - Removes the PM domain from the list of registered PM domains.
1894  *
1895  * The PM domain will only be removed, if the associated provider has
1896  * been removed, it is not a parent to any other PM domain and has no
1897  * devices associated with it.
1898  */
1899 int pm_genpd_remove(struct generic_pm_domain *genpd)
1900 {
1901         int ret;
1902 
1903         mutex_lock(&gpd_list_lock);
1904         ret = genpd_remove(genpd);
1905         mutex_unlock(&gpd_list_lock);
1906 
1907         return ret;
1908 }
1909 EXPORT_SYMBOL_GPL(pm_genpd_remove);
1910 
1911 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
1912 
1913 /*
1914  * Device Tree based PM domain providers.
1915  *
1916  * The code below implements generic device tree based PM domain providers that
1917  * bind device tree nodes with generic PM domains registered in the system.
1918  *
1919  * Any driver that registers generic PM domains and needs to support binding of
1920  * devices to these domains is supposed to register a PM domain provider, which
1921  * maps a PM domain specifier retrieved from the device tree to a PM domain.
1922  *
1923  * Two simple mapping functions have been provided for convenience:
1924  *  - genpd_xlate_simple() for 1:1 device tree node to PM domain mapping.
1925  *  - genpd_xlate_onecell() for mapping of multiple PM domains per node by
1926  *    index.
1927  */
1928 
1929 /**
1930  * struct of_genpd_provider - PM domain provider registration structure
1931  * @link: Entry in global list of PM domain providers
1932  * @node: Pointer to device tree node of PM domain provider
1933  * @xlate: Provider-specific xlate callback mapping a set of specifier cells
1934  *         into a PM domain.
1935  * @data: context pointer to be passed into @xlate callback
1936  */
1937 struct of_genpd_provider {
1938         struct list_head link;
1939         struct device_node *node;
1940         genpd_xlate_t xlate;
1941         void *data;
1942 };
1943 
1944 /* List of registered PM domain providers. */
1945 static LIST_HEAD(of_genpd_providers);
1946 /* Mutex to protect the list above. */
1947 static DEFINE_MUTEX(of_genpd_mutex);
1948 
1949 /**
1950  * genpd_xlate_simple() - Xlate function for direct node-domain mapping
1951  * @genpdspec: OF phandle args to map into a PM domain
1952  * @data: xlate function private data - pointer to struct generic_pm_domain
1953  *
1954  * This is a generic xlate function that can be used to model PM domains that
1955  * have their own device tree nodes. The private data of xlate function needs
1956  * to be a valid pointer to struct generic_pm_domain.
1957  */
1958 static struct generic_pm_domain *genpd_xlate_simple(
1959                                         struct of_phandle_args *genpdspec,
1960                                         void *data)
1961 {
1962         return data;
1963 }
1964 
1965 /**
1966  * genpd_xlate_onecell() - Xlate function using a single index.
1967  * @genpdspec: OF phandle args to map into a PM domain
1968  * @data: xlate function private data - pointer to struct genpd_onecell_data
1969  *
1970  * This is a generic xlate function that can be used to model simple PM domain
1971  * controllers that have one device tree node and provide multiple PM domains.
1972  * A single cell is used as an index into an array of PM domains specified in
1973  * the genpd_onecell_data struct when registering the provider.
1974  */
1975 static struct generic_pm_domain *genpd_xlate_onecell(
1976                                         struct of_phandle_args *genpdspec,
1977                                         void *data)
1978 {
1979         struct genpd_onecell_data *genpd_data = data;
1980         unsigned int idx = genpdspec->args[0];
1981 
1982         if (genpdspec->args_count != 1)
1983                 return ERR_PTR(-EINVAL);
1984 
1985         if (idx >= genpd_data->num_domains) {
1986                 pr_err("%s: invalid domain index %u\n", __func__, idx);
1987                 return ERR_PTR(-EINVAL);
1988         }
1989 
1990         if (!genpd_data->domains[idx])
1991                 return ERR_PTR(-ENOENT);
1992 
1993         return genpd_data->domains[idx];
1994 }
1995 
1996 /**
1997  * genpd_add_provider() - Register a PM domain provider for a node
1998  * @np: Device node pointer associated with the PM domain provider.
1999  * @xlate: Callback for decoding PM domain from phandle arguments.
2000  * @data: Context pointer for @xlate callback.
2001  */
2002 static int genpd_add_provider(struct device_node *np, genpd_xlate_t xlate,
2003                               void *data)
2004 {
2005         struct of_genpd_provider *cp;
2006 
2007         cp = kzalloc(sizeof(*cp), GFP_KERNEL);
2008         if (!cp)
2009                 return -ENOMEM;
2010 
2011         cp->node = of_node_get(np);
2012         cp->data = data;
2013         cp->xlate = xlate;
2014 
2015         mutex_lock(&of_genpd_mutex);
2016         list_add(&cp->link, &of_genpd_providers);
2017         mutex_unlock(&of_genpd_mutex);
2018         pr_debug("Added domain provider from %pOF\n", np);
2019 
2020         return 0;
2021 }
2022 
2023 /**
2024  * of_genpd_add_provider_simple() - Register a simple PM domain provider
2025  * @np: Device node pointer associated with the PM domain provider.
2026  * @genpd: Pointer to PM domain associated with the PM domain provider.
2027  */
2028 int of_genpd_add_provider_simple(struct device_node *np,
2029                                  struct generic_pm_domain *genpd)
2030 {
2031         int ret = -EINVAL;
2032 
2033         if (!np || !genpd)
2034                 return -EINVAL;
2035 
2036         mutex_lock(&gpd_list_lock);
2037 
2038         if (!genpd_present(genpd))
2039                 goto unlock;
2040 
2041         genpd->dev.of_node = np;
2042 
2043         /* Parse genpd OPP table */
2044         if (genpd->set_performance_state) {
2045                 ret = dev_pm_opp_of_add_table(&genpd->dev);
2046                 if (ret) {
2047                         dev_err(&genpd->dev, "Failed to add OPP table: %d\n",
2048                                 ret);
2049                         goto unlock;
2050                 }
2051 
2052                 /*
2053                  * Save table for faster processing while setting performance
2054                  * state.
2055                  */
2056                 genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev);
2057                 WARN_ON(!genpd->opp_table);
2058         }
2059 
2060         ret = genpd_add_provider(np, genpd_xlate_simple, genpd);
2061         if (ret) {
2062                 if (genpd->set_performance_state) {
2063                         dev_pm_opp_put_opp_table(genpd->opp_table);
2064                         dev_pm_opp_of_remove_table(&genpd->dev);
2065                 }
2066 
2067                 goto unlock;
2068         }
2069 
2070         genpd->provider = &np->fwnode;
2071         genpd->has_provider = true;
2072 
2073 unlock:
2074         mutex_unlock(&gpd_list_lock);
2075 
2076         return ret;
2077 }
2078 EXPORT_SYMBOL_GPL(of_genpd_add_provider_simple);
2079 
2080 /**
2081  * of_genpd_add_provider_onecell() - Register a onecell PM domain provider
2082  * @np: Device node pointer associated with the PM domain provider.
2083  * @data: Pointer to the data associated with the PM domain provider.
2084  */
2085 int of_genpd_add_provider_onecell(struct device_node *np,
2086                                   struct genpd_onecell_data *data)
2087 {
2088         struct generic_pm_domain *genpd;
2089         unsigned int i;
2090         int ret = -EINVAL;
2091 
2092         if (!np || !data)
2093                 return -EINVAL;
2094 
2095         mutex_lock(&gpd_list_lock);
2096 
2097         if (!data->xlate)
2098                 data->xlate = genpd_xlate_onecell;
2099 
2100         for (i = 0; i < data->num_domains; i++) {
2101                 genpd = data->domains[i];
2102 
2103                 if (!genpd)
2104                         continue;
2105                 if (!genpd_present(genpd))
2106                         goto error;
2107 
2108                 genpd->dev.of_node = np;
2109 
2110                 /* Parse genpd OPP table */
2111                 if (genpd->set_performance_state) {
2112                         ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i);
2113                         if (ret) {
2114                                 dev_err(&genpd->dev, "Failed to add OPP table for index %d: %d\n",
2115                                         i, ret);
2116                                 goto error;
2117                         }
2118 
2119                         /*
2120                          * Save table for faster processing while setting
2121                          * performance state.
2122                          */
2123                         genpd->opp_table = dev_pm_opp_get_opp_table_indexed(&genpd->dev, i);
2124                         WARN_ON(!genpd->opp_table);
2125                 }
2126 
2127                 genpd->provider = &np->fwnode;
2128                 genpd->has_provider = true;
2129         }
2130 
2131         ret = genpd_add_provider(np, data->xlate, data);
2132         if (ret < 0)
2133                 goto error;
2134 
2135         mutex_unlock(&gpd_list_lock);
2136 
2137         return 0;
2138 
2139 error:
2140         while (i--) {
2141                 genpd = data->domains[i];
2142 
2143                 if (!genpd)
2144                         continue;
2145 
2146                 genpd->provider = NULL;
2147                 genpd->has_provider = false;
2148 
2149                 if (genpd->set_performance_state) {
2150                         dev_pm_opp_put_opp_table(genpd->opp_table);
2151                         dev_pm_opp_of_remove_table(&genpd->dev);
2152                 }
2153         }
2154 
2155         mutex_unlock(&gpd_list_lock);
2156 
2157         return ret;
2158 }
2159 EXPORT_SYMBOL_GPL(of_genpd_add_provider_onecell);
2160 
2161 /**
2162  * of_genpd_del_provider() - Remove a previously registered PM domain provider
2163  * @np: Device node pointer associated with the PM domain provider
2164  */
2165 void of_genpd_del_provider(struct device_node *np)
2166 {
2167         struct of_genpd_provider *cp, *tmp;
2168         struct generic_pm_domain *gpd;
2169 
2170         mutex_lock(&gpd_list_lock);
2171         mutex_lock(&of_genpd_mutex);
2172         list_for_each_entry_safe(cp, tmp, &of_genpd_providers, link) {
2173                 if (cp->node == np) {
2174                         /*
2175                          * For each PM domain associated with the
2176                          * provider, set the 'has_provider' to false
2177                          * so that the PM domain can be safely removed.
2178                          */
2179                         list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
2180                                 if (gpd->provider == &np->fwnode) {
2181                                         gpd->has_provider = false;
2182 
2183                                         if (!gpd->set_performance_state)
2184                                                 continue;
2185 
2186                                         dev_pm_opp_put_opp_table(gpd->opp_table);
2187                                         dev_pm_opp_of_remove_table(&gpd->dev);
2188                                 }
2189                         }
2190 
2191                         list_del(&cp->link);
2192                         of_node_put(cp->node);
2193                         kfree(cp);
2194                         break;
2195                 }
2196         }
2197         mutex_unlock(&of_genpd_mutex);
2198         mutex_unlock(&gpd_list_lock);
2199 }
2200 EXPORT_SYMBOL_GPL(of_genpd_del_provider);
2201 
2202 /**
2203  * genpd_get_from_provider() - Look-up PM domain
2204  * @genpdspec: OF phandle args to use for look-up
2205  *
2206  * Looks for a PM domain provider under the node specified by @genpdspec and if
2207  * found, uses xlate function of the provider to map phandle args to a PM
2208  * domain.
2209  *
2210  * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR()
2211  * on failure.
2212  */
2213 static struct generic_pm_domain *genpd_get_from_provider(
2214                                         struct of_phandle_args *genpdspec)
2215 {
2216         struct generic_pm_domain *genpd = ERR_PTR(-ENOENT);
2217         struct of_genpd_provider *provider;
2218 
2219         if (!genpdspec)
2220                 return ERR_PTR(-EINVAL);
2221 
2222         mutex_lock(&of_genpd_mutex);
2223 
2224         /* Check if we have such a provider in our array */
2225         list_for_each_entry(provider, &of_genpd_providers, link) {
2226                 if (provider->node == genpdspec->np)
2227                         genpd = provider->xlate(genpdspec, provider->data);
2228                 if (!IS_ERR(genpd))
2229                         break;
2230         }
2231 
2232         mutex_unlock(&of_genpd_mutex);
2233 
2234         return genpd;
2235 }
2236 
2237 /**
2238  * of_genpd_add_device() - Add a device to an I/O PM domain
2239  * @genpdspec: OF phandle args to use for look-up PM domain
2240  * @dev: Device to be added.
2241  *
2242  * Looks-up an I/O PM domain based upon phandle args provided and adds
2243  * the device to the PM domain. Returns a negative error code on failure.
2244  */
2245 int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev)
2246 {
2247         struct generic_pm_domain *genpd;
2248         int ret;
2249 
2250         mutex_lock(&gpd_list_lock);
2251 
2252         genpd = genpd_get_from_provider(genpdspec);
2253         if (IS_ERR(genpd)) {
2254                 ret = PTR_ERR(genpd);
2255                 goto out;
2256         }
2257 
2258         ret = genpd_add_device(genpd, dev, dev);
2259 
2260 out:
2261         mutex_unlock(&gpd_list_lock);
2262 
2263         return ret;
2264 }
2265 EXPORT_SYMBOL_GPL(of_genpd_add_device);
2266 
2267 /**
2268  * of_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
2269  * @parent_spec: OF phandle args to use for parent PM domain look-up
2270  * @subdomain_spec: OF phandle args to use for subdomain look-up
2271  *
2272  * Looks-up a parent PM domain and subdomain based upon phandle args
2273  * provided and adds the subdomain to the parent PM domain. Returns a
2274  * negative error code on failure.
2275  */
2276 int of_genpd_add_subdomain(struct of_phandle_args *parent_spec,
2277                            struct of_phandle_args *subdomain_spec)
2278 {
2279         struct generic_pm_domain *parent, *subdomain;
2280         int ret;
2281 
2282         mutex_lock(&gpd_list_lock);
2283 
2284         parent = genpd_get_from_provider(parent_spec);
2285         if (IS_ERR(parent)) {
2286                 ret = PTR_ERR(parent);
2287                 goto out;
2288         }
2289 
2290         subdomain = genpd_get_from_provider(subdomain_spec);
2291         if (IS_ERR(subdomain)) {
2292                 ret = PTR_ERR(subdomain);
2293                 goto out;
2294         }
2295 
2296         ret = genpd_add_subdomain(parent, subdomain);
2297 
2298 out:
2299         mutex_unlock(&gpd_list_lock);
2300 
2301         return ret;
2302 }
2303 EXPORT_SYMBOL_GPL(of_genpd_add_subdomain);
2304 
2305 /**
2306  * of_genpd_remove_last - Remove the last PM domain registered for a provider
2307  * @provider: Pointer to device structure associated with provider
2308  *
2309  * Find the last PM domain that was added by a particular provider and
2310  * remove this PM domain from the list of PM domains. The provider is
2311  * identified by the 'provider' device structure that is passed. The PM
2312  * domain will only be removed, if the provider associated with domain
2313  * has been removed.
2314  *
2315  * Returns a valid pointer to struct generic_pm_domain on success or
2316  * ERR_PTR() on failure.
2317  */
2318 struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
2319 {
2320         struct generic_pm_domain *gpd, *tmp, *genpd = ERR_PTR(-ENOENT);
2321         int ret;
2322 
2323         if (IS_ERR_OR_NULL(np))
2324                 return ERR_PTR(-EINVAL);
2325 
2326         mutex_lock(&gpd_list_lock);
2327         list_for_each_entry_safe(gpd, tmp, &gpd_list, gpd_list_node) {
2328                 if (gpd->provider == &np->fwnode) {
2329                         ret = genpd_remove(gpd);
2330                         genpd = ret ? ERR_PTR(ret) : gpd;
2331                         break;
2332                 }
2333         }
2334         mutex_unlock(&gpd_list_lock);
2335 
2336         return genpd;
2337 }
2338 EXPORT_SYMBOL_GPL(of_genpd_remove_last);
2339 
2340 static void genpd_release_dev(struct device *dev)
2341 {
2342         of_node_put(dev->of_node);
2343         kfree(dev);
2344 }
2345 
2346 static struct bus_type genpd_bus_type = {
2347         .name           = "genpd",
2348 };
2349 
2350 /**
2351  * genpd_dev_pm_detach - Detach a device from its PM domain.
2352  * @dev: Device to detach.
2353  * @power_off: Currently not used
2354  *
2355  * Try to locate a corresponding generic PM domain, which the device was
2356  * attached to previously. If such is found, the device is detached from it.
2357  */
2358 static void genpd_dev_pm_detach(struct device *dev, bool power_off)
2359 {
2360         struct generic_pm_domain *pd;
2361         unsigned int i;
2362         int ret = 0;
2363 
2364         pd = dev_to_genpd(dev);
2365         if (IS_ERR(pd))
2366                 return;
2367 
2368         dev_dbg(dev, "removing from PM domain %s\n", pd->name);
2369 
2370         for (i = 1; i < GENPD_RETRY_MAX_MS; i <<= 1) {
2371                 ret = genpd_remove_device(pd, dev);
2372                 if (ret != -EAGAIN)
2373                         break;
2374 
2375                 mdelay(i);
2376                 cond_resched();
2377         }
2378 
2379         if (ret < 0) {
2380                 dev_err(dev, "failed to remove from PM domain %s: %d",
2381                         pd->name, ret);
2382                 return;
2383         }
2384 
2385         /* Check if PM domain can be powered off after removing this device. */
2386         genpd_queue_power_off_work(pd);
2387 
2388         /* Unregister the device if it was created by genpd. */
2389         if (dev->bus == &genpd_bus_type)
2390                 device_unregister(dev);
2391 }
2392 
2393 static void genpd_dev_pm_sync(struct device *dev)
2394 {
2395         struct generic_pm_domain *pd;
2396 
2397         pd = dev_to_genpd(dev);
2398         if (IS_ERR(pd))
2399                 return;
2400 
2401         genpd_queue_power_off_work(pd);
2402 }
2403 
2404 static int __genpd_dev_pm_attach(struct device *dev, struct device *base_dev,
2405                                  unsigned int index, bool power_on)
2406 {
2407         struct of_phandle_args pd_args;
2408         struct generic_pm_domain *pd;
2409         int ret;
2410 
2411         ret = of_parse_phandle_with_args(dev->of_node, "power-domains",
2412                                 "#power-domain-cells", index, &pd_args);
2413         if (ret < 0)
2414                 return ret;
2415 
2416         mutex_lock(&gpd_list_lock);
2417         pd = genpd_get_from_provider(&pd_args);
2418         of_node_put(pd_args.np);
2419         if (IS_ERR(pd)) {
2420                 mutex_unlock(&gpd_list_lock);
2421                 dev_dbg(dev, "%s() failed to find PM domain: %ld\n",
2422                         __func__, PTR_ERR(pd));
2423                 return driver_deferred_probe_check_state(base_dev);
2424         }
2425 
2426         dev_dbg(dev, "adding to PM domain %s\n", pd->name);
2427 
2428         ret = genpd_add_device(pd, dev, base_dev);
2429         mutex_unlock(&gpd_list_lock);
2430 
2431         if (ret < 0) {
2432                 if (ret != -EPROBE_DEFER)
2433                         dev_err(dev, "failed to add to PM domain %s: %d",
2434                                 pd->name, ret);
2435                 return ret;
2436         }
2437 
2438         dev->pm_domain->detach = genpd_dev_pm_detach;
2439         dev->pm_domain->sync = genpd_dev_pm_sync;
2440 
2441         if (power_on) {
2442                 genpd_lock(pd);
2443                 ret = genpd_power_on(pd, 0);
2444                 genpd_unlock(pd);
2445         }
2446 
2447         if (ret)
2448                 genpd_remove_device(pd, dev);
2449 
2450         return ret ? -EPROBE_DEFER : 1;
2451 }
2452 
2453 /**
2454  * genpd_dev_pm_attach - Attach a device to its PM domain using DT.
2455  * @dev: Device to attach.
2456  *
2457  * Parse device's OF node to find a PM domain specifier. If such is found,
2458  * attaches the device to retrieved pm_domain ops.
2459  *
2460  * Returns 1 on successfully attached PM domain, 0 when the device don't need a
2461  * PM domain or when multiple power-domains exists for it, else a negative error
2462  * code. Note that if a power-domain exists for the device, but it cannot be
2463  * found or turned on, then return -EPROBE_DEFER to ensure that the device is
2464  * not probed and to re-try again later.
2465  */
2466 int genpd_dev_pm_attach(struct device *dev)
2467 {
2468         if (!dev->of_node)
2469                 return 0;
2470 
2471         /*
2472          * Devices with multiple PM domains must be attached separately, as we
2473          * can only attach one PM domain per device.
2474          */
2475         if (of_count_phandle_with_args(dev->of_node, "power-domains",
2476                                        "#power-domain-cells") != 1)
2477                 return 0;
2478 
2479         return __genpd_dev_pm_attach(dev, dev, 0, true);
2480 }
2481 EXPORT_SYMBOL_GPL(genpd_dev_pm_attach);
2482 
2483 /**
2484  * genpd_dev_pm_attach_by_id - Associate a device with one of its PM domains.
2485  * @dev: The device used to lookup the PM domain.
2486  * @index: The index of the PM domain.
2487  *
2488  * Parse device's OF node to find a PM domain specifier at the provided @index.
2489  * If such is found, creates a virtual device and attaches it to the retrieved
2490  * pm_domain ops. To deal with detaching of the virtual device, the ->detach()
2491  * callback in the struct dev_pm_domain are assigned to genpd_dev_pm_detach().
2492  *
2493  * Returns the created virtual device if successfully attached PM domain, NULL
2494  * when the device don't need a PM domain, else an ERR_PTR() in case of
2495  * failures. If a power-domain exists for the device, but cannot be found or
2496  * turned on, then ERR_PTR(-EPROBE_DEFER) is returned to ensure that the device
2497  * is not probed and to re-try again later.
2498  */
2499 struct device *genpd_dev_pm_attach_by_id(struct device *dev,
2500                                          unsigned int index)
2501 {
2502         struct device *virt_dev;
2503         int num_domains;
2504         int ret;
2505 
2506         if (!dev->of_node)
2507                 return NULL;
2508 
2509         /* Verify that the index is within a valid range. */
2510         num_domains = of_count_phandle_with_args(dev->of_node, "power-domains",
2511                                                  "#power-domain-cells");
2512         if (index >= num_domains)
2513                 return NULL;
2514 
2515         /* Allocate and register device on the genpd bus. */
2516         virt_dev = kzalloc(sizeof(*virt_dev), GFP_KERNEL);
2517         if (!virt_dev)
2518                 return ERR_PTR(-ENOMEM);
2519 
2520         dev_set_name(virt_dev, "genpd:%u:%s", index, dev_name(dev));
2521         virt_dev->bus = &genpd_bus_type;
2522         virt_dev->release = genpd_release_dev;
2523         virt_dev->of_node = of_node_get(dev->of_node);
2524 
2525         ret = device_register(virt_dev);
2526         if (ret) {
2527                 put_device(virt_dev);
2528                 return ERR_PTR(ret);
2529         }
2530 
2531         /* Try to attach the device to the PM domain at the specified index. */
2532         ret = __genpd_dev_pm_attach(virt_dev, dev, index, false);
2533         if (ret < 1) {
2534                 device_unregister(virt_dev);
2535                 return ret ? ERR_PTR(ret) : NULL;
2536         }
2537 
2538         pm_runtime_enable(virt_dev);
2539         genpd_queue_power_off_work(dev_to_genpd(virt_dev));
2540 
2541         return virt_dev;
2542 }
2543 EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id);
2544 
2545 /**
2546  * genpd_dev_pm_attach_by_name - Associate a device with one of its PM domains.
2547  * @dev: The device used to lookup the PM domain.
2548  * @name: The name of the PM domain.
2549  *
2550  * Parse device's OF node to find a PM domain specifier using the
2551  * power-domain-names DT property. For further description see
2552  * genpd_dev_pm_attach_by_id().
2553  */
2554 struct device *genpd_dev_pm_attach_by_name(struct device *dev, const char *name)
2555 {
2556         int index;
2557 
2558         if (!dev->of_node)
2559                 return NULL;
2560 
2561         index = of_property_match_string(dev->of_node, "power-domain-names",
2562                                          name);
2563         if (index < 0)
2564                 return NULL;
2565 
2566         return genpd_dev_pm_attach_by_id(dev, index);
2567 }
2568 
2569 static const struct of_device_id idle_state_match[] = {
2570         { .compatible = "domain-idle-state", },
2571         { }
2572 };
2573 
2574 static int genpd_parse_state(struct genpd_power_state *genpd_state,
2575                                     struct device_node *state_node)
2576 {
2577         int err;
2578         u32 residency;
2579         u32 entry_latency, exit_latency;
2580 
2581         err = of_property_read_u32(state_node, "entry-latency-us",
2582                                                 &entry_latency);
2583         if (err) {
2584                 pr_debug(" * %pOF missing entry-latency-us property\n",
2585                          state_node);
2586                 return -EINVAL;
2587         }
2588 
2589         err = of_property_read_u32(state_node, "exit-latency-us",
2590                                                 &exit_latency);
2591         if (err) {
2592                 pr_debug(" * %pOF missing exit-latency-us property\n",
2593                          state_node);
2594                 return -EINVAL;
2595         }
2596 
2597         err = of_property_read_u32(state_node, "min-residency-us", &residency);
2598         if (!err)
2599                 genpd_state->residency_ns = 1000 * residency;
2600 
2601         genpd_state->power_on_latency_ns = 1000 * exit_latency;
2602         genpd_state->power_off_latency_ns = 1000 * entry_latency;
2603         genpd_state->fwnode = &state_node->fwnode;
2604 
2605         return 0;
2606 }
2607 
2608 static int genpd_iterate_idle_states(struct device_node *dn,
2609                                      struct genpd_power_state *states)
2610 {
2611         int ret;
2612         struct of_phandle_iterator it;
2613         struct device_node *np;
2614         int i = 0;
2615 
2616         ret = of_count_phandle_with_args(dn, "domain-idle-states", NULL);
2617         if (ret <= 0)
2618                 return ret == -ENOENT ? 0 : ret;
2619 
2620         /* Loop over the phandles until all the requested entry is found */
2621         of_for_each_phandle(&it, ret, dn, "domain-idle-states", NULL, 0) {
2622                 np = it.node;
2623                 if (!of_match_node(idle_state_match, np))
2624                         continue;
2625                 if (states) {
2626                         ret = genpd_parse_state(&states[i], np);
2627                         if (ret) {
2628                                 pr_err("Parsing idle state node %pOF failed with err %d\n",
2629                                        np, ret);
2630                                 of_node_put(np);
2631                                 return ret;
2632                         }
2633                 }
2634                 i++;
2635         }
2636 
2637         return i;
2638 }
2639 
2640 /**
2641  * of_genpd_parse_idle_states: Return array of idle states for the genpd.
2642  *
2643  * @dn: The genpd device node
2644  * @states: The pointer to which the state array will be saved.
2645  * @n: The count of elements in the array returned from this function.
2646  *
2647  * Returns the device states parsed from the OF node. The memory for the states
2648  * is allocated by this function and is the responsibility of the caller to
2649  * free the memory after use. If any or zero compatible domain idle states is
2650  * found it returns 0 and in case of errors, a negative error code is returned.
2651  */
2652 int of_genpd_parse_idle_states(struct device_node *dn,
2653                         struct genpd_power_state **states, int *n)
2654 {
2655         struct genpd_power_state *st;
2656         int ret;
2657 
2658         ret = genpd_iterate_idle_states(dn, NULL);
2659         if (ret < 0)
2660                 return ret;
2661 
2662         if (!ret) {
2663                 *states = NULL;
2664                 *n = 0;
2665                 return 0;
2666         }
2667 
2668         st = kcalloc(ret, sizeof(*st), GFP_KERNEL);
2669         if (!st)
2670                 return -ENOMEM;
2671 
2672         ret = genpd_iterate_idle_states(dn, st);
2673         if (ret <= 0) {
2674                 kfree(st);
2675                 return ret < 0 ? ret : -EINVAL;
2676         }
2677 
2678         *states = st;
2679         *n = ret;
2680 
2681         return 0;
2682 }
2683 EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states);
2684 
2685 /**
2686  * pm_genpd_opp_to_performance_state - Gets performance state of the genpd from its OPP node.
2687  *
2688  * @genpd_dev: Genpd's device for which the performance-state needs to be found.
2689  * @opp: struct dev_pm_opp of the OPP for which we need to find performance
2690  *      state.
2691  *
2692  * Returns performance state encoded in the OPP of the genpd. This calls
2693  * platform specific genpd->opp_to_performance_state() callback to translate
2694  * power domain OPP to performance state.
2695  *
2696  * Returns performance state on success and 0 on failure.
2697  */
2698 unsigned int pm_genpd_opp_to_performance_state(struct device *genpd_dev,
2699                                                struct dev_pm_opp *opp)
2700 {
2701         struct generic_pm_domain *genpd = NULL;
2702         int state;
2703 
2704         genpd = container_of(genpd_dev, struct generic_pm_domain, dev);
2705 
2706         if (unlikely(!genpd->opp_to_performance_state))
2707                 return 0;
2708 
2709         genpd_lock(genpd);
2710         state = genpd->opp_to_performance_state(genpd, opp);
2711         genpd_unlock(genpd);
2712 
2713         return state;
2714 }
2715 EXPORT_SYMBOL_GPL(pm_genpd_opp_to_performance_state);
2716 
2717 static int __init genpd_bus_init(void)
2718 {
2719         return bus_register(&genpd_bus_type);
2720 }
2721 core_initcall(genpd_bus_init);
2722 
2723 #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
2724 
2725 
2726 /***        debugfs support        ***/
2727 
2728 #ifdef CONFIG_DEBUG_FS
2729 #include <linux/pm.h>
2730 #include <linux/device.h>
2731 #include <linux/debugfs.h>
2732 #include <linux/seq_file.h>
2733 #include <linux/init.h>
2734 #include <linux/kobject.h>
2735 static struct dentry *genpd_debugfs_dir;
2736 
2737 /*
2738  * TODO: This function is a slightly modified version of rtpm_status_show
2739  * from sysfs.c, so generalize it.
2740  */
2741 static void rtpm_status_str(struct seq_file *s, struct device *dev)
2742 {
2743         static const char * const status_lookup[] = {
2744                 [RPM_ACTIVE] = "active",
2745                 [RPM_RESUMING] = "resuming",
2746                 [RPM_SUSPENDED] = "suspended",
2747                 [RPM_SUSPENDING] = "suspending"
2748         };
2749         const char *p = "";
2750 
2751         if (dev->power.runtime_error)
2752                 p = "error";
2753         else if (dev->power.disable_depth)
2754                 p = "unsupported";
2755         else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup))
2756                 p = status_lookup[dev->power.runtime_status];
2757         else
2758                 WARN_ON(1);
2759 
2760         seq_puts(s, p);
2761 }
2762 
2763 static int genpd_summary_one(struct seq_file *s,
2764                         struct generic_pm_domain *genpd)
2765 {
2766         static const char * const status_lookup[] = {
2767                 [GPD_STATE_ACTIVE] = "on",
2768                 [GPD_STATE_POWER_OFF] = "off"
2769         };
2770         struct pm_domain_data *pm_data;
2771         const char *kobj_path;
2772         struct gpd_link *link;
2773         char state[16];
2774         int ret;
2775 
2776         ret = genpd_lock_interruptible(genpd);
2777         if (ret)
2778                 return -ERESTARTSYS;
2779 
2780         if (WARN_ON(genpd->status >= ARRAY_SIZE(status_lookup)))
2781                 goto exit;
2782         if (!genpd_status_on(genpd))
2783                 snprintf(state, sizeof(state), "%s-%u",
2784                          status_lookup[genpd->status], genpd->state_idx);
2785         else
2786                 snprintf(state, sizeof(state), "%s",
2787                          status_lookup[genpd->status]);
2788         seq_printf(s, "%-30s  %-15s ", genpd->name, state);
2789 
2790         /*
2791          * Modifications on the list require holding locks on both
2792          * master and slave, so we are safe.
2793          * Also genpd->name is immutable.
2794          */
2795         list_for_each_entry(link, &genpd->master_links, master_node) {
2796                 seq_printf(s, "%s", link->slave->name);
2797                 if (!list_is_last(&link->master_node, &genpd->master_links))
2798                         seq_puts(s, ", ");
2799         }
2800 
2801         list_for_each_entry(pm_data, &genpd->dev_list, list_node) {
2802                 kobj_path = kobject_get_path(&pm_data->dev->kobj,
2803                                 genpd_is_irq_safe(genpd) ?
2804                                 GFP_ATOMIC : GFP_KERNEL);
2805                 if (kobj_path == NULL)
2806                         continue;
2807 
2808                 seq_printf(s, "\n    %-50s  ", kobj_path);
2809                 rtpm_status_str(s, pm_data->dev);
2810                 kfree(kobj_path);
2811         }
2812 
2813         seq_puts(s, "\n");
2814 exit:
2815         genpd_unlock(genpd);
2816 
2817         return 0;
2818 }
2819 
2820 static int summary_show(struct seq_file *s, void *data)
2821 {
2822         struct generic_pm_domain *genpd;
2823         int ret = 0;
2824 
2825         seq_puts(s, "domain                          status          slaves\n");
2826         seq_puts(s, "    /device                                             runtime status\n");
2827         seq_puts(s, "----------------------------------------------------------------------\n");
2828 
2829         ret = mutex_lock_interruptible(&gpd_list_lock);
2830         if (ret)
2831                 return -ERESTARTSYS;
2832 
2833         list_for_each_entry(genpd, &gpd_list, gpd_list_node) {
2834                 ret = genpd_summary_one(s, genpd);
2835                 if (ret)
2836                         break;
2837         }
2838         mutex_unlock(&gpd_list_lock);
2839 
2840         return ret;
2841 }
2842 
2843 static int status_show(struct seq_file *s, void *data)
2844 {
2845         static const char * const status_lookup[] = {
2846                 [GPD_STATE_ACTIVE] = "on",
2847                 [GPD_STATE_POWER_OFF] = "off"
2848         };
2849 
2850         struct generic_pm_domain *genpd = s->private;
2851         int ret = 0;
2852 
2853         ret = genpd_lock_interruptible(genpd);
2854         if (ret)
2855                 return -ERESTARTSYS;
2856 
2857         if (WARN_ON_ONCE(genpd->status >= ARRAY_SIZE(status_lookup)))
2858                 goto exit;
2859 
2860         if (genpd->status == GPD_STATE_POWER_OFF)
2861                 seq_printf(s, "%s-%u\n", status_lookup[genpd->status],
2862                         genpd->state_idx);
2863         else
2864                 seq_printf(s, "%s\n", status_lookup[genpd->status]);
2865 exit:
2866         genpd_unlock(genpd);
2867         return ret;
2868 }
2869 
2870 static int sub_domains_show(struct seq_file *s, void *data)
2871 {
2872         struct generic_pm_domain *genpd = s->private;
2873         struct gpd_link *link;
2874         int ret = 0;
2875 
2876         ret = genpd_lock_interruptible(genpd);
2877         if (ret)
2878                 return -ERESTARTSYS;
2879 
2880         list_for_each_entry(link, &genpd->master_links, master_node)
2881                 seq_printf(s, "%s\n", link->slave->name);
2882 
2883         genpd_unlock(genpd);
2884         return ret;
2885 }
2886 
2887 static int idle_states_show(struct seq_file *s, void *data)
2888 {
2889         struct generic_pm_domain *genpd = s->private;
2890         unsigned int i;
2891         int ret = 0;
2892 
2893         ret = genpd_lock_interruptible(genpd);
2894         if (ret)
2895                 return -ERESTARTSYS;
2896 
2897         seq_puts(s, "State          Time Spent(ms)\n");
2898 
2899         for (i = 0; i < genpd->state_count; i++) {
2900                 ktime_t delta = 0;
2901                 s64 msecs;
2902 
2903                 if ((genpd->status == GPD_STATE_POWER_OFF) &&
2904                                 (genpd->state_idx == i))
2905                         delta = ktime_sub(ktime_get(), genpd->accounting_time);
2906 
2907                 msecs = ktime_to_ms(
2908                         ktime_add(genpd->states[i].idle_time, delta));
2909                 seq_printf(s, "S%-13i %lld\n", i, msecs);
2910         }
2911 
2912         genpd_unlock(genpd);
2913         return ret;
2914 }
2915 
2916 static int active_time_show(struct seq_file *s, void *data)
2917 {
2918         struct generic_pm_domain *genpd = s->private;
2919         ktime_t delta = 0;
2920         int ret = 0;
2921 
2922         ret = genpd_lock_interruptible(genpd);
2923         if (ret)
2924                 return -ERESTARTSYS;
2925 
2926         if (genpd->status == GPD_STATE_ACTIVE)
2927                 delta = ktime_sub(ktime_get(), genpd->accounting_time);
2928 
2929         seq_printf(s, "%lld ms\n", ktime_to_ms(
2930                                 ktime_add(genpd->on_time, delta)));
2931 
2932         genpd_unlock(genpd);
2933         return ret;
2934 }
2935 
2936 static int total_idle_time_show(struct seq_file *s, void *data)
2937 {
2938         struct generic_pm_domain *genpd = s->private;
2939         ktime_t delta = 0, total = 0;
2940         unsigned int i;
2941         int ret = 0;
2942 
2943         ret = genpd_lock_interruptible(genpd);
2944         if (ret)
2945                 return -ERESTARTSYS;
2946 
2947         for (i = 0; i < genpd->state_count; i++) {
2948 
2949                 if ((genpd->status == GPD_STATE_POWER_OFF) &&
2950                                 (genpd->state_idx == i))
2951                         delta = ktime_sub(ktime_get(), genpd->accounting_time);
2952 
2953                 total = ktime_add(total, genpd->states[i].idle_time);
2954         }
2955         total = ktime_add(total, delta);
2956 
2957         seq_printf(s, "%lld ms\n", ktime_to_ms(total));
2958 
2959         genpd_unlock(genpd);
2960         return ret;
2961 }
2962 
2963 
2964 static int devices_show(struct seq_file *s, void *data)
2965 {
2966         struct generic_pm_domain *genpd = s->private;
2967         struct pm_domain_data *pm_data;
2968         const char *kobj_path;
2969         int ret = 0;
2970 
2971         ret = genpd_lock_interruptible(genpd);
2972         if (ret)
2973                 return -ERESTARTSYS;
2974 
2975         list_for_each_entry(pm_data, &genpd->dev_list, list_node) {
2976                 kobj_path = kobject_get_path(&pm_data->dev->kobj,
2977                                 genpd_is_irq_safe(genpd) ?
2978                                 GFP_ATOMIC : GFP_KERNEL);
2979                 if (kobj_path == NULL)
2980                         continue;
2981 
2982                 seq_printf(s, "%s\n", kobj_path);
2983                 kfree(kobj_path);
2984         }
2985 
2986         genpd_unlock(genpd);
2987         return ret;
2988 }
2989 
2990 static int perf_state_show(struct seq_file *s, void *data)
2991 {
2992         struct generic_pm_domain *genpd = s->private;
2993 
2994         if (genpd_lock_interruptible(genpd))
2995                 return -ERESTARTSYS;
2996 
2997         seq_printf(s, "%u\n", genpd->performance_state);
2998 
2999         genpd_unlock(genpd);
3000         return 0;
3001 }
3002 
3003 DEFINE_SHOW_ATTRIBUTE(summary);
3004 DEFINE_SHOW_ATTRIBUTE(status);
3005 DEFINE_SHOW_ATTRIBUTE(sub_domains);
3006 DEFINE_SHOW_ATTRIBUTE(idle_states);
3007 DEFINE_SHOW_ATTRIBUTE(active_time);
3008 DEFINE_SHOW_ATTRIBUTE(total_idle_time);
3009 DEFINE_SHOW_ATTRIBUTE(devices);
3010 DEFINE_SHOW_ATTRIBUTE(perf_state);
3011 
3012 static int __init genpd_debug_init(void)
3013 {
3014         struct dentry *d;
3015         struct generic_pm_domain *genpd;
3016 
3017         genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL);
3018 
3019         debugfs_create_file("pm_genpd_summary", S_IRUGO, genpd_debugfs_dir,
3020                             NULL, &summary_fops);
3021 
3022         list_for_each_entry(genpd, &gpd_list, gpd_list_node) {
3023                 d = debugfs_create_dir(genpd->name, genpd_debugfs_dir);
3024 
3025                 debugfs_create_file("current_state", 0444,
3026                                 d, genpd, &status_fops);
3027                 debugfs_create_file("sub_domains", 0444,
3028                                 d, genpd, &sub_domains_fops);
3029                 debugfs_create_file("idle_states", 0444,
3030                                 d, genpd, &idle_states_fops);
3031                 debugfs_create_file("active_time", 0444,
3032                                 d, genpd, &active_time_fops);
3033                 debugfs_create_file("total_idle_time", 0444,
3034                                 d, genpd, &total_idle_time_fops);
3035                 debugfs_create_file("devices", 0444,
3036                                 d, genpd, &devices_fops);
3037                 if (genpd->set_performance_state)
3038                         debugfs_create_file("perf_state", 0444,
3039                                             d, genpd, &perf_state_fops);
3040         }
3041 
3042         return 0;
3043 }
3044 late_initcall(genpd_debug_init);
3045 
3046 static void __exit genpd_debug_exit(void)
3047 {
3048         debugfs_remove_recursive(genpd_debugfs_dir);
3049 }
3050 __exitcall(genpd_debug_exit);
3051 #endif /* CONFIG_DEBUG_FS */
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/base/power/domain.c

DEFINITIONS
