include/linux/pm_domain.h

   1 /*
   2  * pm_domain.h - Definitions and headers related to device power domains.
   3  *
   4  * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
   5  *
   6  * This file is released under the GPLv2.
   7  */
   8
   9 #ifndef _LINUX_PM_DOMAIN_H
  10 #define _LINUX_PM_DOMAIN_H
  11
  12 #include <linux/device.h>
  13 #include <linux/mutex.h>
  14 #include <linux/pm.h>
  15 #include <linux/err.h>
  16 #include <linux/of.h>
  17 #include <linux/notifier.h>
  18 #include <linux/spinlock.h>
  19
  20 /* Defines used for the flags field in the struct generic_pm_domain */
  21 #define GENPD_FLAG_PM_CLK       (1U << 0) /* PM domain uses PM clk */
  22 #define GENPD_FLAG_IRQ_SAFE     (1U << 1) /* PM domain operates in atomic */
  23 #define GENPD_FLAG_ALWAYS_ON    (1U << 2) /* PM domain is always powered on */
  24
  25 enum gpd_status {
  26         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
  27         GPD_STATE_POWER_OFF,    /* PM domain is off */
  28 };
  29
  30 struct dev_power_governor {
  31         bool (*power_down_ok)(struct dev_pm_domain *domain);
  32         bool (*suspend_ok)(struct device *dev);
  33 };
  34
  35 struct gpd_dev_ops {
  36         int (*start)(struct device *dev);
  37         int (*stop)(struct device *dev);
  38         bool (*active_wakeup)(struct device *dev);
  39 };
  40
  41 struct genpd_power_state {
  42         s64 power_off_latency_ns;
  43         s64 power_on_latency_ns;
  44         s64 residency_ns;
  45         struct fwnode_handle *fwnode;
  46 };
  47
  48 struct genpd_lock_ops;
  49
  50 struct generic_pm_domain {
  51         struct dev_pm_domain domain;    /* PM domain operations */
  52         struct list_head gpd_list_node; /* Node in the global PM domains list */
  53         struct list_head master_links;  /* Links with PM domain as a master */
  54         struct list_head slave_links;   /* Links with PM domain as a slave */
  55         struct list_head dev_list;      /* List of devices */
  56         struct dev_power_governor *gov;
  57         struct work_struct power_off_work;
  58         struct fwnode_handle *provider; /* Identity of the domain provider */
  59         bool has_provider;
  60         const char *name;
  61         atomic_t sd_count;      /* Number of subdomains with power "on" */
  62         enum gpd_status status; /* Current state of the domain */
  63         unsigned int device_count;      /* Number of devices */
  64         unsigned int suspended_count;   /* System suspend device counter */
  65         unsigned int prepared_count;    /* Suspend counter of prepared devices */
  66         int (*power_off)(struct generic_pm_domain *domain);
  67         int (*power_on)(struct generic_pm_domain *domain);
  68         struct gpd_dev_ops dev_ops;
  69         s64 max_off_time_ns;    /* Maximum allowed "suspended" time. */
  70         bool max_off_time_changed;
  71         bool cached_power_down_ok;
  72         int (*attach_dev)(struct generic_pm_domain *domain,
  73                           struct device *dev);
  74         void (*detach_dev)(struct generic_pm_domain *domain,
  75                            struct device *dev);
  76         unsigned int flags;             /* Bit field of configs for genpd */
  77         struct genpd_power_state *states;
  78         unsigned int state_count; /* number of states */
  79         unsigned int state_idx; /* state that genpd will go to when off */
  80         void *free; /* Free the state that was allocated for default */
  81         const struct genpd_lock_ops *lock_ops;
  82         union {
  83                 struct mutex mlock;
  84                 struct {
  85                         spinlock_t slock;
  86                         unsigned long lock_flags;
  87                 };
  88         };
  89
  90 };
  91
  92 static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
  93 {
  94         return container_of(pd, struct generic_pm_domain, domain);
  95 }
  96
  97 struct gpd_link {
  98         struct generic_pm_domain *master;
  99         struct list_head master_node;
 100         struct generic_pm_domain *slave;
 101         struct list_head slave_node;
 102 };
 103
 104 struct gpd_timing_data {
 105         s64 suspend_latency_ns;
 106         s64 resume_latency_ns;
 107         s64 effective_constraint_ns;
 108         bool constraint_changed;
 109         bool cached_suspend_ok;
 110 };
 111
 112 struct pm_domain_data {
 113         struct list_head list_node;
 114         struct device *dev;
 115 };
 116
 117 struct generic_pm_domain_data {
 118         struct pm_domain_data base;
 119         struct gpd_timing_data td;
 120         struct notifier_block nb;
 121 };
 122
 123 #ifdef CONFIG_PM_GENERIC_DOMAINS
 124 static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
 125 {
 126         return container_of(pdd, struct generic_pm_domain_data, base);
 127 }
 128
 129 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 130 {
 131         return to_gpd_data(dev->power.subsys_data->domain_data);
 132 }
 133
 134 extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
 135                                  struct device *dev,
 136                                  struct gpd_timing_data *td);
 137
 138 extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 139                                   struct device *dev);
 140 extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
 141                                   struct generic_pm_domain *new_subdomain);
 142 extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 143                                      struct generic_pm_domain *target);
 144 extern int pm_genpd_init(struct generic_pm_domain *genpd,
 145                          struct dev_power_governor *gov, bool is_off);
 146 extern int pm_genpd_remove(struct generic_pm_domain *genpd);
 147
 148 extern struct dev_power_governor simple_qos_governor;
 149 extern struct dev_power_governor pm_domain_always_on_gov;
 150 #else
 151
 152 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 153 {
 154         return ERR_PTR(-ENOSYS);
 155 }
 156 static inline int __pm_genpd_add_device(struct generic_pm_domain *genpd,
 157                                         struct device *dev,
 158                                         struct gpd_timing_data *td)
 159 {
 160         return -ENOSYS;
 161 }
 162 static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 163                                          struct device *dev)
 164 {
 165         return -ENOSYS;
 166 }
 167 static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
 168                                          struct generic_pm_domain *new_sd)
 169 {
 170         return -ENOSYS;
 171 }
 172 static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 173                                             struct generic_pm_domain *target)
 174 {
 175         return -ENOSYS;
 176 }
 177 static inline int pm_genpd_init(struct generic_pm_domain *genpd,
 178                                 struct dev_power_governor *gov, bool is_off)
 179 {
 180         return -ENOSYS;
 181 }
 182 static inline int pm_genpd_remove(struct generic_pm_domain *genpd)
 183 {
 184         return -ENOTSUPP;
 185 }
 186
 187 #define simple_qos_governor             (*(struct dev_power_governor *)(NULL))
 188 #define pm_domain_always_on_gov         (*(struct dev_power_governor *)(NULL))
 189 #endif
 190
 191 static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
 192                                       struct device *dev)
 193 {
 194         return __pm_genpd_add_device(genpd, dev, NULL);
 195 }
 196
 197 #ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
 198 extern void pm_genpd_syscore_poweroff(struct device *dev);
 199 extern void pm_genpd_syscore_poweron(struct device *dev);
 200 #else
 201 static inline void pm_genpd_syscore_poweroff(struct device *dev) {}
 202 static inline void pm_genpd_syscore_poweron(struct device *dev) {}
 203 #endif
 204
 205 /* OF PM domain providers */
 206 struct of_device_id;
 207
 208 struct genpd_onecell_data {
 209         struct generic_pm_domain **domains;
 210         unsigned int num_domains;
 211 };
 212
 213 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
 214 int of_genpd_add_provider_simple(struct device_node *np,
 215                                  struct generic_pm_domain *genpd);
 216 int of_genpd_add_provider_onecell(struct device_node *np,
 217                                   struct genpd_onecell_data *data);
 218 void of_genpd_del_provider(struct device_node *np);
 219 extern int of_genpd_add_device(struct of_phandle_args *args,
 220                                struct device *dev);
 221 extern int of_genpd_add_subdomain(struct of_phandle_args *parent,
 222                                   struct of_phandle_args *new_subdomain);
 223 extern struct generic_pm_domain *of_genpd_remove_last(struct device_node *np);
 224 extern int of_genpd_parse_idle_states(struct device_node *dn,
 225                         struct genpd_power_state **states, int *n);
 226
 227 int genpd_dev_pm_attach(struct device *dev);
 228 #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
 229 static inline int of_genpd_add_provider_simple(struct device_node *np,
 230                                         struct generic_pm_domain *genpd)
 231 {
 232         return -ENOTSUPP;
 233 }
 234
 235 static inline int of_genpd_add_provider_onecell(struct device_node *np,
 236                                         struct genpd_onecell_data *data)
 237 {
 238         return -ENOTSUPP;
 239 }
 240
 241 static inline void of_genpd_del_provider(struct device_node *np) {}
 242
 243 static inline int of_genpd_add_device(struct of_phandle_args *args,
 244                                       struct device *dev)
 245 {
 246         return -ENODEV;
 247 }
 248
 249 static inline int of_genpd_add_subdomain(struct of_phandle_args *parent,
 250                                          struct of_phandle_args *new_subdomain)
 251 {
 252         return -ENODEV;
 253 }
 254
 255 static inline int of_genpd_parse_idle_states(struct device_node *dn,
 256                         struct genpd_power_state **states, int *n)
 257 {
 258         return -ENODEV;
 259 }
 260
 261 static inline int genpd_dev_pm_attach(struct device *dev)
 262 {
 263         return -ENODEV;
 264 }
 265
 266 static inline
 267 struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 268 {
 269         return ERR_PTR(-ENOTSUPP);
 270 }
 271 #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
 272
 273 #ifdef CONFIG_PM
 274 extern int dev_pm_domain_attach(struct device *dev, bool power_on);
 275 extern void dev_pm_domain_detach(struct device *dev, bool power_off);
 276 extern void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
 277 #else
 278 static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 279 {
 280         return -ENODEV;
 281 }
 282 static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
 283 static inline void dev_pm_domain_set(struct device *dev,
 284                                      struct dev_pm_domain *pd) {}
 285 #endif
 286
 287 #endif /* _LINUX_PM_DOMAIN_H */