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         void *data;
 122 };
 123
 124 #ifdef CONFIG_PM_GENERIC_DOMAINS
 125 static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
 126 {
 127         return container_of(pdd, struct generic_pm_domain_data, base);
 128 }
 129
 130 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 131 {
 132         return to_gpd_data(dev->power.subsys_data->domain_data);
 133 }
 134
 135 extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
 136                                  struct device *dev,
 137                                  struct gpd_timing_data *td);
 138
 139 extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 140                                   struct device *dev);
 141 extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
 142                                   struct generic_pm_domain *new_subdomain);
 143 extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 144                                      struct generic_pm_domain *target);
 145 extern int pm_genpd_init(struct generic_pm_domain *genpd,
 146                          struct dev_power_governor *gov, bool is_off);
 147 extern int pm_genpd_remove(struct generic_pm_domain *genpd);
 148
 149 extern struct dev_power_governor simple_qos_governor;
 150 extern struct dev_power_governor pm_domain_always_on_gov;
 151 #else
 152
 153 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 154 {
 155         return ERR_PTR(-ENOSYS);
 156 }
 157 static inline int __pm_genpd_add_device(struct generic_pm_domain *genpd,
 158                                         struct device *dev,
 159                                         struct gpd_timing_data *td)
 160 {
 161         return -ENOSYS;
 162 }
 163 static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 164                                          struct device *dev)
 165 {
 166         return -ENOSYS;
 167 }
 168 static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
 169                                          struct generic_pm_domain *new_sd)
 170 {
 171         return -ENOSYS;
 172 }
 173 static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 174                                             struct generic_pm_domain *target)
 175 {
 176         return -ENOSYS;
 177 }
 178 static inline int pm_genpd_init(struct generic_pm_domain *genpd,
 179                                 struct dev_power_governor *gov, bool is_off)
 180 {
 181         return -ENOSYS;
 182 }
 183 static inline int pm_genpd_remove(struct generic_pm_domain *genpd)
 184 {
 185         return -ENOTSUPP;
 186 }
 187
 188 #define simple_qos_governor             (*(struct dev_power_governor *)(NULL))
 189 #define pm_domain_always_on_gov         (*(struct dev_power_governor *)(NULL))
 190 #endif
 191
 192 static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
 193                                       struct device *dev)
 194 {
 195         return __pm_genpd_add_device(genpd, dev, NULL);
 196 }
 197
 198 #ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
 199 extern void pm_genpd_syscore_poweroff(struct device *dev);
 200 extern void pm_genpd_syscore_poweron(struct device *dev);
 201 #else
 202 static inline void pm_genpd_syscore_poweroff(struct device *dev) {}
 203 static inline void pm_genpd_syscore_poweron(struct device *dev) {}
 204 #endif
 205
 206 /* OF PM domain providers */
 207 struct of_device_id;
 208
 209 typedef struct generic_pm_domain *(*genpd_xlate_t)(struct of_phandle_args *args,
 210                                                    void *data);
 211
 212 struct genpd_onecell_data {
 213         struct generic_pm_domain **domains;
 214         unsigned int num_domains;
 215         genpd_xlate_t xlate;
 216 };
 217
 218 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
 219 int of_genpd_add_provider_simple(struct device_node *np,
 220                                  struct generic_pm_domain *genpd);
 221 int of_genpd_add_provider_onecell(struct device_node *np,
 222                                   struct genpd_onecell_data *data);
 223 void of_genpd_del_provider(struct device_node *np);
 224 extern int of_genpd_add_device(struct of_phandle_args *args,
 225                                struct device *dev);
 226 extern int of_genpd_add_subdomain(struct of_phandle_args *parent,
 227                                   struct of_phandle_args *new_subdomain);
 228 extern struct generic_pm_domain *of_genpd_remove_last(struct device_node *np);
 229 extern int of_genpd_parse_idle_states(struct device_node *dn,
 230                         struct genpd_power_state **states, int *n);
 231
 232 int genpd_dev_pm_attach(struct device *dev);
 233 #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
 234 static inline int of_genpd_add_provider_simple(struct device_node *np,
 235                                         struct generic_pm_domain *genpd)
 236 {
 237         return -ENOTSUPP;
 238 }
 239
 240 static inline int of_genpd_add_provider_onecell(struct device_node *np,
 241                                         struct genpd_onecell_data *data)
 242 {
 243         return -ENOTSUPP;
 244 }
 245
 246 static inline void of_genpd_del_provider(struct device_node *np) {}
 247
 248 static inline int of_genpd_add_device(struct of_phandle_args *args,
 249                                       struct device *dev)
 250 {
 251         return -ENODEV;
 252 }
 253
 254 static inline int of_genpd_add_subdomain(struct of_phandle_args *parent,
 255                                          struct of_phandle_args *new_subdomain)
 256 {
 257         return -ENODEV;
 258 }
 259
 260 static inline int of_genpd_parse_idle_states(struct device_node *dn,
 261                         struct genpd_power_state **states, int *n)
 262 {
 263         return -ENODEV;
 264 }
 265
 266 static inline int genpd_dev_pm_attach(struct device *dev)
 267 {
 268         return -ENODEV;
 269 }
 270
 271 static inline
 272 struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 273 {
 274         return ERR_PTR(-ENOTSUPP);
 275 }
 276 #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
 277
 278 #ifdef CONFIG_PM
 279 extern int dev_pm_domain_attach(struct device *dev, bool power_on);
 280 extern void dev_pm_domain_detach(struct device *dev, bool power_off);
 281 extern void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
 282 #else
 283 static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 284 {
 285         return -ENODEV;
 286 }
 287 static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
 288 static inline void dev_pm_domain_set(struct device *dev,
 289                                      struct dev_pm_domain *pd) {}
 290 #endif
 291
 292 #endif /* _LINUX_PM_DOMAIN_H */