projects/linux·blob v5.6-rc4 · refs

422 lines · 13.5 KiB

1/* SPDX-License-Identifier: GPL-2.0-only */
2/*
3 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
4 * for Non-CPU Devices.
5 *
6 * Copyright (C) 2011 Samsung Electronics
7 * MyungJoo Ham <[email protected]>
8 */
9
10#ifndef __LINUX_DEVFREQ_H__
11#define __LINUX_DEVFREQ_H__
12
13#include <linux/device.h>
14#include <linux/notifier.h>
15#include <linux/pm_opp.h>
16#include <linux/pm_qos.h>
17
18#define DEVFREQ_NAME_LEN 16
19
20/* DEVFREQ governor name */
21#define DEVFREQ_GOV_SIMPLE_ONDEMAND "simple_ondemand"
22#define DEVFREQ_GOV_PERFORMANCE "performance"
23#define DEVFREQ_GOV_POWERSAVE "powersave"
24#define DEVFREQ_GOV_USERSPACE "userspace"
25#define DEVFREQ_GOV_PASSIVE "passive"
26
27/* DEVFREQ notifier interface */
28#define DEVFREQ_TRANSITION_NOTIFIER (0)
29
30/* Transition notifiers of DEVFREQ_TRANSITION_NOTIFIER */
31#define DEVFREQ_PRECHANGE (0)
32#define DEVFREQ_POSTCHANGE (1)
33
34struct devfreq;
35struct devfreq_governor;
36
37/**
38 * struct devfreq_dev_status - Data given from devfreq user device to
39 * governors. Represents the performance
40 * statistics.
41 * @total_time: The total time represented by this instance of
42 * devfreq_dev_status
43 * @busy_time: The time that the device was working among the
44 * total_time.
45 * @current_frequency: The operating frequency.
46 * @private_data: An entry not specified by the devfreq framework.
47 * A device and a specific governor may have their
48 * own protocol with private_data. However, because
49 * this is governor-specific, a governor using this
50 * will be only compatible with devices aware of it.
51 */
52struct devfreq_dev_status {
53 /* both since the last measure */
54 unsigned long total_time;
55 unsigned long busy_time;
56 unsigned long current_frequency;
57 void *private_data;
58};
59
60/*
61 * The resulting frequency should be at most this. (this bound is the
62 * least upper bound; thus, the resulting freq should be lower or same)
63 * If the flag is not set, the resulting frequency should be at most the
64 * bound (greatest lower bound)
65 */
66#define DEVFREQ_FLAG_LEAST_UPPER_BOUND 0x1
67
68/**
69 * struct devfreq_dev_profile - Devfreq's user device profile
70 * @initial_freq: The operating frequency when devfreq_add_device() is
71 * called.
72 * @polling_ms: The polling interval in ms. 0 disables polling.
73 * @target: The device should set its operating frequency at
74 * freq or lowest-upper-than-freq value. If freq is
75 * higher than any operable frequency, set maximum.
76 * Before returning, target function should set
77 * freq at the current frequency.
78 * The "flags" parameter's possible values are
79 * explained above with "DEVFREQ_FLAG_*" macros.
80 * @get_dev_status: The device should provide the current performance
81 * status to devfreq. Governors are recommended not to
82 * use this directly. Instead, governors are recommended
83 * to use devfreq_update_stats() along with
84 * devfreq.last_status.
85 * @get_cur_freq: The device should provide the current frequency
86 * at which it is operating.
87 * @exit: An optional callback that is called when devfreq
88 * is removing the devfreq object due to error or
89 * from devfreq_remove_device() call. If the user
90 * has registered devfreq->nb at a notifier-head,
91 * this is the time to unregister it.
92 * @freq_table: Optional list of frequencies to support statistics
93 * and freq_table must be generated in ascending order.
94 * @max_state: The size of freq_table.
95 */
96struct devfreq_dev_profile {
97 unsigned long initial_freq;
98 unsigned int polling_ms;
99
100 int (*target)(struct device *dev, unsigned long *freq, u32 flags);
101 int (*get_dev_status)(struct device *dev,
102 struct devfreq_dev_status *stat);
103 int (*get_cur_freq)(struct device *dev, unsigned long *freq);
104 void (*exit)(struct device *dev);
105
106 unsigned long *freq_table;
107 unsigned int max_state;
108};
109
110/**
111 * struct devfreq_stats - Statistics of devfreq device behavior
112 * @total_trans: Number of devfreq transitions.
113 * @trans_table: Statistics of devfreq transitions.
114 * @time_in_state: Statistics of devfreq states.
115 * @last_update: The last time stats were updated.
116 */
117struct devfreq_stats {
118 unsigned int total_trans;
119 unsigned int *trans_table;
120 u64 *time_in_state;
121 u64 last_update;
122};
123
124/**
125 * struct devfreq - Device devfreq structure
126 * @node: list node - contains the devices with devfreq that have been
127 * registered.
128 * @lock: a mutex to protect accessing devfreq.
129 * @dev: device registered by devfreq class. dev.parent is the device
130 * using devfreq.
131 * @profile: device-specific devfreq profile
132 * @governor: method how to choose frequency based on the usage.
133 * @governor_name: devfreq governor name for use with this devfreq
134 * @nb: notifier block used to notify devfreq object that it should
135 * reevaluate operable frequencies. Devfreq users may use
136 * devfreq.nb to the corresponding register notifier call chain.
137 * @work: delayed work for load monitoring.
138 * @previous_freq: previously configured frequency value.
139 * @last_status: devfreq user device info, performance statistics
140 * @data: Private data of the governor. The devfreq framework does not
141 * touch this.
142 * @user_min_freq_req: PM QoS minimum frequency request from user (via sysfs)
143 * @user_max_freq_req: PM QoS maximum frequency request from user (via sysfs)
144 * @scaling_min_freq: Limit minimum frequency requested by OPP interface
145 * @scaling_max_freq: Limit maximum frequency requested by OPP interface
146 * @stop_polling: devfreq polling status of a device.
147 * @suspend_freq: frequency of a device set during suspend phase.
148 * @resume_freq: frequency of a device set in resume phase.
149 * @suspend_count: suspend requests counter for a device.
150 * @stats: Statistics of devfreq device behavior
151 * @transition_notifier_list: list head of DEVFREQ_TRANSITION_NOTIFIER notifier
152 * @nb_min: Notifier block for DEV_PM_QOS_MIN_FREQUENCY
153 * @nb_max: Notifier block for DEV_PM_QOS_MAX_FREQUENCY
154 *
155 * This structure stores the devfreq information for a given device.
156 *
157 * Note that when a governor accesses entries in struct devfreq in its
158 * functions except for the context of callbacks defined in struct
159 * devfreq_governor, the governor should protect its access with the
160 * struct mutex lock in struct devfreq. A governor may use this mutex
161 * to protect its own private data in void *data as well.
162 */
163struct devfreq {
164 struct list_head node;
165
166 struct mutex lock;
167 struct device dev;
168 struct devfreq_dev_profile *profile;
169 const struct devfreq_governor *governor;
170 char governor_name[DEVFREQ_NAME_LEN];
171 struct notifier_block nb;
172 struct delayed_work work;
173
174 unsigned long previous_freq;
175 struct devfreq_dev_status last_status;
176
177 void *data; /* private data for governors */
178
179 struct dev_pm_qos_request user_min_freq_req;
180 struct dev_pm_qos_request user_max_freq_req;
181 unsigned long scaling_min_freq;
182 unsigned long scaling_max_freq;
183 bool stop_polling;
184
185 unsigned long suspend_freq;
186 unsigned long resume_freq;
187 atomic_t suspend_count;
188
189 /* information for device frequency transitions */
190 struct devfreq_stats stats;
191
192 struct srcu_notifier_head transition_notifier_list;
193
194 struct notifier_block nb_min;
195 struct notifier_block nb_max;
196};
197
198struct devfreq_freqs {
199 unsigned long old;
200 unsigned long new;
201};
202
203#if defined(CONFIG_PM_DEVFREQ)
204extern struct devfreq *devfreq_add_device(struct device *dev,
205 struct devfreq_dev_profile *profile,
206 const char *governor_name,
207 void *data);
208extern int devfreq_remove_device(struct devfreq *devfreq);
209extern struct devfreq *devm_devfreq_add_device(struct device *dev,
210 struct devfreq_dev_profile *profile,
211 const char *governor_name,
212 void *data);
213extern void devm_devfreq_remove_device(struct device *dev,
214 struct devfreq *devfreq);
215
216/* Supposed to be called by PM callbacks */
217extern int devfreq_suspend_device(struct devfreq *devfreq);
218extern int devfreq_resume_device(struct devfreq *devfreq);
219
220extern void devfreq_suspend(void);
221extern void devfreq_resume(void);
222
223/**
224 * update_devfreq() - Reevaluate the device and configure frequency
225 * @devfreq: the devfreq device
226 *
227 * Note: devfreq->lock must be held
228 */
229extern int update_devfreq(struct devfreq *devfreq);
230
231/* Helper functions for devfreq user device driver with OPP. */
232extern struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
233 unsigned long *freq, u32 flags);
234extern int devfreq_register_opp_notifier(struct device *dev,
235 struct devfreq *devfreq);
236extern int devfreq_unregister_opp_notifier(struct device *dev,
237 struct devfreq *devfreq);
238extern int devm_devfreq_register_opp_notifier(struct device *dev,
239 struct devfreq *devfreq);
240extern void devm_devfreq_unregister_opp_notifier(struct device *dev,
241 struct devfreq *devfreq);
242extern int devfreq_register_notifier(struct devfreq *devfreq,
243 struct notifier_block *nb,
244 unsigned int list);
245extern int devfreq_unregister_notifier(struct devfreq *devfreq,
246 struct notifier_block *nb,
247 unsigned int list);
248extern int devm_devfreq_register_notifier(struct device *dev,
249 struct devfreq *devfreq,
250 struct notifier_block *nb,
251 unsigned int list);
252extern void devm_devfreq_unregister_notifier(struct device *dev,
253 struct devfreq *devfreq,
254 struct notifier_block *nb,
255 unsigned int list);
256extern struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
257 int index);
258
259#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND)
260/**
261 * struct devfreq_simple_ondemand_data - void *data fed to struct devfreq
262 * and devfreq_add_device
263 * @upthreshold: If the load is over this value, the frequency jumps.
264 * Specify 0 to use the default. Valid value = 0 to 100.
265 * @downdifferential: If the load is under upthreshold - downdifferential,
266 * the governor may consider slowing the frequency down.
267 * Specify 0 to use the default. Valid value = 0 to 100.
268 * downdifferential < upthreshold must hold.
269 *
270 * If the fed devfreq_simple_ondemand_data pointer is NULL to the governor,
271 * the governor uses the default values.
272 */
273struct devfreq_simple_ondemand_data {
274 unsigned int upthreshold;
275 unsigned int downdifferential;
276};
277#endif
278
279#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE)
280/**
281 * struct devfreq_passive_data - void *data fed to struct devfreq
282 * and devfreq_add_device
283 * @parent: the devfreq instance of parent device.
284 * @get_target_freq: Optional callback, Returns desired operating frequency
285 * for the device using passive governor. That is called
286 * when passive governor should decide the next frequency
287 * by using the new frequency of parent devfreq device
288 * using governors except for passive governor.
289 * If the devfreq device has the specific method to decide
290 * the next frequency, should use this callback.
291 * @this: the devfreq instance of own device.
292 * @nb: the notifier block for DEVFREQ_TRANSITION_NOTIFIER list
293 *
294 * The devfreq_passive_data have to set the devfreq instance of parent
295 * device with governors except for the passive governor. But, don't need to
296 * initialize the 'this' and 'nb' field because the devfreq core will handle
297 * them.
298 */
299struct devfreq_passive_data {
300 /* Should set the devfreq instance of parent device */
301 struct devfreq *parent;
302
303 /* Optional callback to decide the next frequency of passvice device */
304 int (*get_target_freq)(struct devfreq *this, unsigned long *freq);
305
306 /* For passive governor's internal use. Don't need to set them */
307 struct devfreq *this;
308 struct notifier_block nb;
309};
310#endif
311
312#else /* !CONFIG_PM_DEVFREQ */
313static inline struct devfreq *devfreq_add_device(struct device *dev,
314 struct devfreq_dev_profile *profile,
315 const char *governor_name,
316 void *data)
317{
318 return ERR_PTR(-ENOSYS);
319}
320
321static inline int devfreq_remove_device(struct devfreq *devfreq)
322{
323 return 0;
324}
325
326static inline struct devfreq *devm_devfreq_add_device(struct device *dev,
327 struct devfreq_dev_profile *profile,
328 const char *governor_name,
329 void *data)
330{
331 return ERR_PTR(-ENOSYS);
332}
333
334static inline void devm_devfreq_remove_device(struct device *dev,
335 struct devfreq *devfreq)
336{
337}
338
339static inline int devfreq_suspend_device(struct devfreq *devfreq)
340{
341 return 0;
342}
343
344static inline int devfreq_resume_device(struct devfreq *devfreq)
345{
346 return 0;
347}
348
349static inline void devfreq_suspend(void) {}
350static inline void devfreq_resume(void) {}
351
352static inline struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
353 unsigned long *freq, u32 flags)
354{
355 return ERR_PTR(-EINVAL);
356}
357
358static inline int devfreq_register_opp_notifier(struct device *dev,
359 struct devfreq *devfreq)
360{
361 return -EINVAL;
362}
363
364static inline int devfreq_unregister_opp_notifier(struct device *dev,
365 struct devfreq *devfreq)
366{
367 return -EINVAL;
368}
369
370static inline int devm_devfreq_register_opp_notifier(struct device *dev,
371 struct devfreq *devfreq)
372{
373 return -EINVAL;
374}
375
376static inline void devm_devfreq_unregister_opp_notifier(struct device *dev,
377 struct devfreq *devfreq)
378{
379}
380
381static inline int devfreq_register_notifier(struct devfreq *devfreq,
382 struct notifier_block *nb,
383 unsigned int list)
384{
385 return 0;
386}
387
388static inline int devfreq_unregister_notifier(struct devfreq *devfreq,
389 struct notifier_block *nb,
390 unsigned int list)
391{
392 return 0;
393}
394
395static inline int devm_devfreq_register_notifier(struct device *dev,
396 struct devfreq *devfreq,
397 struct notifier_block *nb,
398 unsigned int list)
399{
400 return 0;
401}
402
403static inline void devm_devfreq_unregister_notifier(struct device *dev,
404 struct devfreq *devfreq,
405 struct notifier_block *nb,
406 unsigned int list)
407{
408}
409
410static inline struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
411 int index)
412{
413 return ERR_PTR(-ENODEV);
414}
415
416static inline int devfreq_update_stats(struct devfreq *df)
417{
418 return -EINVAL;
419}
420#endif /* CONFIG_PM_DEVFREQ */
421
422#endif /* __LINUX_DEVFREQ_H__ */