1 /* 2 * linux/include/linux/cpufreq.h 3 * 4 * Copyright (C) 2001 Russell King 5 * (C) 2002 - 2003 Dominik Brodowski <[email protected]> 6 * 7 * 8 * $Id: cpufreq.h,v 1.36 2003/01/20 17:31:48 db Exp $ 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 #ifndef _LINUX_CPUFREQ_H 15 #define _LINUX_CPUFREQ_H 16 17 #include <linux/mutex.h> 18 #include <linux/notifier.h> 19 #include <linux/threads.h> 20 #include <linux/device.h> 21 #include <linux/kobject.h> 22 #include <linux/sysfs.h> 23 #include <linux/completion.h> 24 #include <linux/workqueue.h> 25 #include <linux/cpumask.h> 26 #include <asm/div64.h> 27 28 #define CPUFREQ_NAME_LEN 16 29 30 31 /********************************************************************* 32 * CPUFREQ NOTIFIER INTERFACE * 33 *********************************************************************/ 34 35 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); 36 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); 37 38 #define CPUFREQ_TRANSITION_NOTIFIER (0) 39 #define CPUFREQ_POLICY_NOTIFIER (1) 40 41 42 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency 43 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these 44 * two generic policies are available: 45 */ 46 47 #define CPUFREQ_POLICY_POWERSAVE (1) 48 #define CPUFREQ_POLICY_PERFORMANCE (2) 49 50 /* Frequency values here are CPU kHz so that hardware which doesn't run 51 * with some frequencies can complain without having to guess what per 52 * cent / per mille means. 53 * Maximum transition latency is in nanoseconds - if it's unknown, 54 * CPUFREQ_ETERNAL shall be used. 55 */ 56 57 struct cpufreq_governor; 58 59 #define CPUFREQ_ETERNAL (-1) 60 struct cpufreq_cpuinfo { 61 unsigned int max_freq; 62 unsigned int min_freq; 63 unsigned int transition_latency; /* in 10^(-9) s = nanoseconds */ 64 }; 65 66 struct cpufreq_real_policy { 67 unsigned int min; /* in kHz */ 68 unsigned int max; /* in kHz */ 69 unsigned int policy; /* see above */ 70 struct cpufreq_governor *governor; /* see below */ 71 }; 72 73 struct cpufreq_policy { 74 cpumask_t cpus; /* affected CPUs */ 75 unsigned int shared_type; /* ANY or ALL affected CPUs 76 should set cpufreq */ 77 unsigned int cpu; /* cpu nr of registered CPU */ 78 struct cpufreq_cpuinfo cpuinfo;/* see above */ 79 80 unsigned int min; /* in kHz */ 81 unsigned int max; /* in kHz */ 82 unsigned int cur; /* in kHz, only needed if cpufreq 83 * governors are used */ 84 unsigned int policy; /* see above */ 85 struct cpufreq_governor *governor; /* see below */ 86 87 struct work_struct update; /* if update_policy() needs to be 88 * called, but you're in IRQ context */ 89 90 struct cpufreq_real_policy user_policy; 91 92 struct kobject kobj; 93 struct completion kobj_unregister; 94 }; 95 96 #define CPUFREQ_ADJUST (0) 97 #define CPUFREQ_INCOMPATIBLE (1) 98 #define CPUFREQ_NOTIFY (2) 99 100 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 101 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 102 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 103 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 104 105 /******************** cpufreq transition notifiers *******************/ 106 107 #define CPUFREQ_PRECHANGE (0) 108 #define CPUFREQ_POSTCHANGE (1) 109 #define CPUFREQ_RESUMECHANGE (8) 110 #define CPUFREQ_SUSPENDCHANGE (9) 111 112 struct cpufreq_freqs { 113 unsigned int cpu; /* cpu nr */ 114 unsigned int old; 115 unsigned int new; 116 u8 flags; /* flags of cpufreq_driver, see below. */ 117 }; 118 119 120 /** 121 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe) 122 * @old: old value 123 * @div: divisor 124 * @mult: multiplier 125 * 126 * 127 * new = old * mult / div 128 */ 129 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult) 130 { 131 #if BITS_PER_LONG == 32 132 133 u64 result = ((u64) old) * ((u64) mult); 134 do_div(result, div); 135 return (unsigned long) result; 136 137 #elif BITS_PER_LONG == 64 138 139 unsigned long result = old * ((u64) mult); 140 result /= div; 141 return result; 142 143 #endif 144 }; 145 146 /********************************************************************* 147 * CPUFREQ GOVERNORS * 148 *********************************************************************/ 149 150 #define CPUFREQ_GOV_START 1 151 #define CPUFREQ_GOV_STOP 2 152 #define CPUFREQ_GOV_LIMITS 3 153 154 struct cpufreq_governor { 155 char name[CPUFREQ_NAME_LEN]; 156 int (*governor) (struct cpufreq_policy *policy, 157 unsigned int event); 158 struct list_head governor_list; 159 struct module *owner; 160 }; 161 162 /* pass a target to the cpufreq driver 163 */ 164 extern int cpufreq_driver_target(struct cpufreq_policy *policy, 165 unsigned int target_freq, 166 unsigned int relation); 167 extern int __cpufreq_driver_target(struct cpufreq_policy *policy, 168 unsigned int target_freq, 169 unsigned int relation); 170 171 172 extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy); 173 174 int cpufreq_register_governor(struct cpufreq_governor *governor); 175 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 176 177 int lock_policy_rwsem_read(int cpu); 178 int lock_policy_rwsem_write(int cpu); 179 void unlock_policy_rwsem_read(int cpu); 180 void unlock_policy_rwsem_write(int cpu); 181 182 183 /********************************************************************* 184 * CPUFREQ DRIVER INTERFACE * 185 *********************************************************************/ 186 187 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 188 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 189 190 struct freq_attr; 191 192 struct cpufreq_driver { 193 struct module *owner; 194 char name[CPUFREQ_NAME_LEN]; 195 u8 flags; 196 197 /* needed by all drivers */ 198 int (*init) (struct cpufreq_policy *policy); 199 int (*verify) (struct cpufreq_policy *policy); 200 201 /* define one out of two */ 202 int (*setpolicy) (struct cpufreq_policy *policy); 203 int (*target) (struct cpufreq_policy *policy, 204 unsigned int target_freq, 205 unsigned int relation); 206 207 /* should be defined, if possible */ 208 unsigned int (*get) (unsigned int cpu); 209 210 /* optional */ 211 unsigned int (*getavg) (unsigned int cpu); 212 int (*exit) (struct cpufreq_policy *policy); 213 int (*suspend) (struct cpufreq_policy *policy, pm_message_t pmsg); 214 int (*resume) (struct cpufreq_policy *policy); 215 struct freq_attr **attr; 216 }; 217 218 /* flags */ 219 220 #define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if 221 * all ->init() calls failed */ 222 #define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel 223 * "constants" aren't affected by 224 * frequency transitions */ 225 #define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed 226 * mismatches */ 227 228 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 229 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 230 231 232 void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state); 233 234 235 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 236 { 237 if (policy->min < min) 238 policy->min = min; 239 if (policy->max < min) 240 policy->max = min; 241 if (policy->min > max) 242 policy->min = max; 243 if (policy->max > max) 244 policy->max = max; 245 if (policy->min > policy->max) 246 policy->min = policy->max; 247 return; 248 } 249 250 struct freq_attr { 251 struct attribute attr; 252 ssize_t (*show)(struct cpufreq_policy *, char *); 253 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 254 }; 255 256 257 /********************************************************************* 258 * CPUFREQ 2.6. INTERFACE * 259 *********************************************************************/ 260 int cpufreq_set_policy(struct cpufreq_policy *policy); 261 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 262 int cpufreq_update_policy(unsigned int cpu); 263 264 /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */ 265 unsigned int cpufreq_get(unsigned int cpu); 266 267 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */ 268 #ifdef CONFIG_CPU_FREQ 269 unsigned int cpufreq_quick_get(unsigned int cpu); 270 #else 271 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 272 { 273 return 0; 274 } 275 #endif 276 277 278 /********************************************************************* 279 * CPUFREQ DEFAULT GOVERNOR * 280 *********************************************************************/ 281 282 283 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE 284 extern struct cpufreq_governor cpufreq_gov_performance; 285 #define CPUFREQ_DEFAULT_GOVERNOR &cpufreq_gov_performance 286 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE) 287 extern struct cpufreq_governor cpufreq_gov_userspace; 288 #define CPUFREQ_DEFAULT_GOVERNOR &cpufreq_gov_userspace 289 #endif 290 291 292 /********************************************************************* 293 * FREQUENCY TABLE HELPERS * 294 *********************************************************************/ 295 296 #define CPUFREQ_ENTRY_INVALID ~0 297 #define CPUFREQ_TABLE_END ~1 298 299 struct cpufreq_frequency_table { 300 unsigned int index; /* any */ 301 unsigned int frequency; /* kHz - doesn't need to be in ascending 302 * order */ 303 }; 304 305 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 306 struct cpufreq_frequency_table *table); 307 308 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 309 struct cpufreq_frequency_table *table); 310 311 int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 312 struct cpufreq_frequency_table *table, 313 unsigned int target_freq, 314 unsigned int relation, 315 unsigned int *index); 316 317 /* the following 3 funtions are for cpufreq core use only */ 318 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu); 319 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 320 void cpufreq_cpu_put (struct cpufreq_policy *data); 321 322 /* the following are really really optional */ 323 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 324 325 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 326 unsigned int cpu); 327 328 void cpufreq_frequency_table_put_attr(unsigned int cpu); 329 330 331 /********************************************************************* 332 * UNIFIED DEBUG HELPERS * 333 *********************************************************************/ 334 335 #define CPUFREQ_DEBUG_CORE 1 336 #define CPUFREQ_DEBUG_DRIVER 2 337 #define CPUFREQ_DEBUG_GOVERNOR 4 338 339 #ifdef CONFIG_CPU_FREQ_DEBUG 340 341 extern void cpufreq_debug_printk(unsigned int type, const char *prefix, 342 const char *fmt, ...); 343 344 #else 345 346 #define cpufreq_debug_printk(msg...) do { } while(0) 347 348 #endif /* CONFIG_CPU_FREQ_DEBUG */ 349 350 #endif /* _LINUX_CPUFREQ_H */ 351