Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * pm_domain.h - Definitions and headers related to device power domains.
4 : : *
5 : : * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
6 : : */
7 : :
8 : : #ifndef _LINUX_PM_DOMAIN_H
9 : : #define _LINUX_PM_DOMAIN_H
10 : :
11 : : #include <linux/device.h>
12 : : #include <linux/mutex.h>
13 : : #include <linux/pm.h>
14 : : #include <linux/err.h>
15 : : #include <linux/of.h>
16 : : #include <linux/notifier.h>
17 : : #include <linux/spinlock.h>
18 : : #include <linux/cpumask.h>
19 : :
20 : : /*
21 : : * Flags to control the behaviour of a genpd.
22 : : *
23 : : * These flags may be set in the struct generic_pm_domain's flags field by a
24 : : * genpd backend driver. The flags must be set before it calls pm_genpd_init(),
25 : : * which initializes a genpd.
26 : : *
27 : : * GENPD_FLAG_PM_CLK: Instructs genpd to use the PM clk framework,
28 : : * while powering on/off attached devices.
29 : : *
30 : : * GENPD_FLAG_IRQ_SAFE: This informs genpd that its backend callbacks,
31 : : * ->power_on|off(), doesn't sleep. Hence, these
32 : : * can be invoked from within atomic context, which
33 : : * enables genpd to power on/off the PM domain,
34 : : * even when pm_runtime_is_irq_safe() returns true,
35 : : * for any of its attached devices. Note that, a
36 : : * genpd having this flag set, requires its
37 : : * masterdomains to also have it set.
38 : : *
39 : : * GENPD_FLAG_ALWAYS_ON: Instructs genpd to always keep the PM domain
40 : : * powered on.
41 : : *
42 : : * GENPD_FLAG_ACTIVE_WAKEUP: Instructs genpd to keep the PM domain powered
43 : : * on, in case any of its attached devices is used
44 : : * in the wakeup path to serve system wakeups.
45 : : *
46 : : * GENPD_FLAG_CPU_DOMAIN: Instructs genpd that it should expect to get
47 : : * devices attached, which may belong to CPUs or
48 : : * possibly have subdomains with CPUs attached.
49 : : * This flag enables the genpd backend driver to
50 : : * deploy idle power management support for CPUs
51 : : * and groups of CPUs. Note that, the backend
52 : : * driver must then comply with the so called,
53 : : * last-man-standing algorithm, for the CPUs in the
54 : : * PM domain.
55 : : *
56 : : * GENPD_FLAG_RPM_ALWAYS_ON: Instructs genpd to always keep the PM domain
57 : : * powered on except for system suspend.
58 : : */
59 : : #define GENPD_FLAG_PM_CLK (1U << 0)
60 : : #define GENPD_FLAG_IRQ_SAFE (1U << 1)
61 : : #define GENPD_FLAG_ALWAYS_ON (1U << 2)
62 : : #define GENPD_FLAG_ACTIVE_WAKEUP (1U << 3)
63 : : #define GENPD_FLAG_CPU_DOMAIN (1U << 4)
64 : : #define GENPD_FLAG_RPM_ALWAYS_ON (1U << 5)
65 : :
66 : : enum gpd_status {
67 : : GPD_STATE_ACTIVE = 0, /* PM domain is active */
68 : : GPD_STATE_POWER_OFF, /* PM domain is off */
69 : : };
70 : :
71 : : struct dev_power_governor {
72 : : bool (*power_down_ok)(struct dev_pm_domain *domain);
73 : : bool (*suspend_ok)(struct device *dev);
74 : : };
75 : :
76 : : struct gpd_dev_ops {
77 : : int (*start)(struct device *dev);
78 : : int (*stop)(struct device *dev);
79 : : };
80 : :
81 : : struct genpd_power_state {
82 : : s64 power_off_latency_ns;
83 : : s64 power_on_latency_ns;
84 : : s64 residency_ns;
85 : : struct fwnode_handle *fwnode;
86 : : ktime_t idle_time;
87 : : void *data;
88 : : };
89 : :
90 : : struct genpd_lock_ops;
91 : : struct dev_pm_opp;
92 : : struct opp_table;
93 : :
94 : : struct generic_pm_domain {
95 : : struct device dev;
96 : : struct dev_pm_domain domain; /* PM domain operations */
97 : : struct list_head gpd_list_node; /* Node in the global PM domains list */
98 : : struct list_head master_links; /* Links with PM domain as a master */
99 : : struct list_head slave_links; /* Links with PM domain as a slave */
100 : : struct list_head dev_list; /* List of devices */
101 : : struct dev_power_governor *gov;
102 : : struct work_struct power_off_work;
103 : : struct fwnode_handle *provider; /* Identity of the domain provider */
104 : : bool has_provider;
105 : : const char *name;
106 : : atomic_t sd_count; /* Number of subdomains with power "on" */
107 : : enum gpd_status status; /* Current state of the domain */
108 : : unsigned int device_count; /* Number of devices */
109 : : unsigned int suspended_count; /* System suspend device counter */
110 : : unsigned int prepared_count; /* Suspend counter of prepared devices */
111 : : unsigned int performance_state; /* Aggregated max performance state */
112 : : cpumask_var_t cpus; /* A cpumask of the attached CPUs */
113 : : int (*power_off)(struct generic_pm_domain *domain);
114 : : int (*power_on)(struct generic_pm_domain *domain);
115 : : struct opp_table *opp_table; /* OPP table of the genpd */
116 : : unsigned int (*opp_to_performance_state)(struct generic_pm_domain *genpd,
117 : : struct dev_pm_opp *opp);
118 : : int (*set_performance_state)(struct generic_pm_domain *genpd,
119 : : unsigned int state);
120 : : struct gpd_dev_ops dev_ops;
121 : : s64 max_off_time_ns; /* Maximum allowed "suspended" time. */
122 : : bool max_off_time_changed;
123 : : bool cached_power_down_ok;
124 : : bool cached_power_down_state_idx;
125 : : int (*attach_dev)(struct generic_pm_domain *domain,
126 : : struct device *dev);
127 : : void (*detach_dev)(struct generic_pm_domain *domain,
128 : : struct device *dev);
129 : : unsigned int flags; /* Bit field of configs for genpd */
130 : : struct genpd_power_state *states;
131 : : void (*free_states)(struct genpd_power_state *states,
132 : : unsigned int state_count);
133 : : unsigned int state_count; /* number of states */
134 : : unsigned int state_idx; /* state that genpd will go to when off */
135 : : ktime_t on_time;
136 : : ktime_t accounting_time;
137 : : const struct genpd_lock_ops *lock_ops;
138 : : union {
139 : : struct mutex mlock;
140 : : struct {
141 : : spinlock_t slock;
142 : : unsigned long lock_flags;
143 : : };
144 : : };
145 : :
146 : : };
147 : :
148 : : static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
149 : : {
150 : : return container_of(pd, struct generic_pm_domain, domain);
151 : : }
152 : :
153 : : struct gpd_link {
154 : : struct generic_pm_domain *master;
155 : : struct list_head master_node;
156 : : struct generic_pm_domain *slave;
157 : : struct list_head slave_node;
158 : :
159 : : /* Sub-domain's per-master domain performance state */
160 : : unsigned int performance_state;
161 : : unsigned int prev_performance_state;
162 : : };
163 : :
164 : : struct gpd_timing_data {
165 : : s64 suspend_latency_ns;
166 : : s64 resume_latency_ns;
167 : : s64 effective_constraint_ns;
168 : : bool constraint_changed;
169 : : bool cached_suspend_ok;
170 : : };
171 : :
172 : : struct pm_domain_data {
173 : : struct list_head list_node;
174 : : struct device *dev;
175 : : };
176 : :
177 : : struct generic_pm_domain_data {
178 : : struct pm_domain_data base;
179 : : struct gpd_timing_data td;
180 : : struct notifier_block nb;
181 : : int cpu;
182 : : unsigned int performance_state;
183 : : void *data;
184 : : };
185 : :
186 : : #ifdef CONFIG_PM_GENERIC_DOMAINS
187 : : static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
188 : : {
189 : : return container_of(pdd, struct generic_pm_domain_data, base);
190 : : }
191 : :
192 : : static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
193 : : {
194 : : return to_gpd_data(dev->power.subsys_data->domain_data);
195 : : }
196 : :
197 : : int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev);
198 : : int pm_genpd_remove_device(struct device *dev);
199 : : int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
200 : : struct generic_pm_domain *subdomain);
201 : : int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
202 : : struct generic_pm_domain *subdomain);
203 : : int pm_genpd_init(struct generic_pm_domain *genpd,
204 : : struct dev_power_governor *gov, bool is_off);
205 : : int pm_genpd_remove(struct generic_pm_domain *genpd);
206 : : int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state);
207 : :
208 : : extern struct dev_power_governor simple_qos_governor;
209 : : extern struct dev_power_governor pm_domain_always_on_gov;
210 : : #ifdef CONFIG_CPU_IDLE
211 : : extern struct dev_power_governor pm_domain_cpu_gov;
212 : : #endif
213 : : #else
214 : :
215 : : static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
216 : : {
217 : : return ERR_PTR(-ENOSYS);
218 : : }
219 : : static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
220 : : struct device *dev)
221 : : {
222 : : return -ENOSYS;
223 : : }
224 : : static inline int pm_genpd_remove_device(struct device *dev)
225 : : {
226 : : return -ENOSYS;
227 : : }
228 : : static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
229 : : struct generic_pm_domain *subdomain)
230 : : {
231 : : return -ENOSYS;
232 : : }
233 : : static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
234 : : struct generic_pm_domain *subdomain)
235 : : {
236 : : return -ENOSYS;
237 : : }
238 : : static inline int pm_genpd_init(struct generic_pm_domain *genpd,
239 : : struct dev_power_governor *gov, bool is_off)
240 : : {
241 : : return -ENOSYS;
242 : : }
243 : : static inline int pm_genpd_remove(struct generic_pm_domain *genpd)
244 : : {
245 : : return -ENOTSUPP;
246 : : }
247 : :
248 : : static inline int dev_pm_genpd_set_performance_state(struct device *dev,
249 : : unsigned int state)
250 : : {
251 : : return -ENOTSUPP;
252 : : }
253 : :
254 : : #define simple_qos_governor (*(struct dev_power_governor *)(NULL))
255 : : #define pm_domain_always_on_gov (*(struct dev_power_governor *)(NULL))
256 : : #endif
257 : :
258 : : #ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
259 : : void pm_genpd_syscore_poweroff(struct device *dev);
260 : : void pm_genpd_syscore_poweron(struct device *dev);
261 : : #else
262 : : static inline void pm_genpd_syscore_poweroff(struct device *dev) {}
263 : : static inline void pm_genpd_syscore_poweron(struct device *dev) {}
264 : : #endif
265 : :
266 : : /* OF PM domain providers */
267 : : struct of_device_id;
268 : :
269 : : typedef struct generic_pm_domain *(*genpd_xlate_t)(struct of_phandle_args *args,
270 : : void *data);
271 : :
272 : : struct genpd_onecell_data {
273 : : struct generic_pm_domain **domains;
274 : : unsigned int num_domains;
275 : : genpd_xlate_t xlate;
276 : : };
277 : :
278 : : #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
279 : : int of_genpd_add_provider_simple(struct device_node *np,
280 : : struct generic_pm_domain *genpd);
281 : : int of_genpd_add_provider_onecell(struct device_node *np,
282 : : struct genpd_onecell_data *data);
283 : : void of_genpd_del_provider(struct device_node *np);
284 : : int of_genpd_add_device(struct of_phandle_args *args, struct device *dev);
285 : : int of_genpd_add_subdomain(struct of_phandle_args *parent_spec,
286 : : struct of_phandle_args *subdomain_spec);
287 : : int of_genpd_remove_subdomain(struct of_phandle_args *parent_spec,
288 : : struct of_phandle_args *subdomain_spec);
289 : : struct generic_pm_domain *of_genpd_remove_last(struct device_node *np);
290 : : int of_genpd_parse_idle_states(struct device_node *dn,
291 : : struct genpd_power_state **states, int *n);
292 : : unsigned int pm_genpd_opp_to_performance_state(struct device *genpd_dev,
293 : : struct dev_pm_opp *opp);
294 : :
295 : : int genpd_dev_pm_attach(struct device *dev);
296 : : struct device *genpd_dev_pm_attach_by_id(struct device *dev,
297 : : unsigned int index);
298 : : struct device *genpd_dev_pm_attach_by_name(struct device *dev,
299 : : const char *name);
300 : : #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
301 : : static inline int of_genpd_add_provider_simple(struct device_node *np,
302 : : struct generic_pm_domain *genpd)
303 : : {
304 : : return -ENOTSUPP;
305 : : }
306 : :
307 : : static inline int of_genpd_add_provider_onecell(struct device_node *np,
308 : : struct genpd_onecell_data *data)
309 : : {
310 : : return -ENOTSUPP;
311 : : }
312 : :
313 : : static inline void of_genpd_del_provider(struct device_node *np) {}
314 : :
315 : : static inline int of_genpd_add_device(struct of_phandle_args *args,
316 : : struct device *dev)
317 : : {
318 : : return -ENODEV;
319 : : }
320 : :
321 : : static inline int of_genpd_add_subdomain(struct of_phandle_args *parent_spec,
322 : : struct of_phandle_args *subdomain_spec)
323 : : {
324 : : return -ENODEV;
325 : : }
326 : :
327 : : static inline int of_genpd_remove_subdomain(struct of_phandle_args *parent_spec,
328 : : struct of_phandle_args *subdomain_spec)
329 : : {
330 : : return -ENODEV;
331 : : }
332 : :
333 : : static inline int of_genpd_parse_idle_states(struct device_node *dn,
334 : : struct genpd_power_state **states, int *n)
335 : : {
336 : : return -ENODEV;
337 : : }
338 : :
339 : : static inline unsigned int
340 : : pm_genpd_opp_to_performance_state(struct device *genpd_dev,
341 : : struct dev_pm_opp *opp)
342 : : {
343 : : return 0;
344 : : }
345 : :
346 : 90 : static inline int genpd_dev_pm_attach(struct device *dev)
347 : : {
348 : 90 : return 0;
349 : : }
350 : :
351 : : static inline struct device *genpd_dev_pm_attach_by_id(struct device *dev,
352 : : unsigned int index)
353 : : {
354 : : return NULL;
355 : : }
356 : :
357 : : static inline struct device *genpd_dev_pm_attach_by_name(struct device *dev,
358 : : const char *name)
359 : : {
360 : : return NULL;
361 : : }
362 : :
363 : : static inline
364 : : struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
365 : : {
366 : : return ERR_PTR(-ENOTSUPP);
367 : : }
368 : : #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
369 : :
370 : : #ifdef CONFIG_PM
371 : : int dev_pm_domain_attach(struct device *dev, bool power_on);
372 : : struct device *dev_pm_domain_attach_by_id(struct device *dev,
373 : : unsigned int index);
374 : : struct device *dev_pm_domain_attach_by_name(struct device *dev,
375 : : const char *name);
376 : : void dev_pm_domain_detach(struct device *dev, bool power_off);
377 : : int dev_pm_domain_start(struct device *dev);
378 : : void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
379 : : #else
380 : : static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
381 : : {
382 : : return 0;
383 : : }
384 : : static inline struct device *dev_pm_domain_attach_by_id(struct device *dev,
385 : : unsigned int index)
386 : : {
387 : : return NULL;
388 : : }
389 : : static inline struct device *dev_pm_domain_attach_by_name(struct device *dev,
390 : : const char *name)
391 : : {
392 : : return NULL;
393 : : }
394 : : static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
395 : : static inline int dev_pm_domain_start(struct device *dev)
396 : : {
397 : : return 0;
398 : : }
399 : : static inline void dev_pm_domain_set(struct device *dev,
400 : : struct dev_pm_domain *pd) {}
401 : : #endif
402 : :
403 : : #endif /* _LINUX_PM_DOMAIN_H */
|
