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