cpufreq.h 26.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * linux/include/linux/cpufreq.h
Linus Torvalds's avatar
Linus Torvalds committed
3
 *
4 5
 * Copyright (C) 2001 Russell King
 *           (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6
 *
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9 10 11 12 13
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#ifndef _LINUX_CPUFREQ_H
#define _LINUX_CPUFREQ_H

14
#include <linux/clk.h>
15 16
#include <linux/cpumask.h>
#include <linux/completion.h>
Linus Torvalds's avatar
Linus Torvalds committed
17
#include <linux/kobject.h>
18
#include <linux/notifier.h>
19
#include <linux/spinlock.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22
#include <linux/sysfs.h>

/*********************************************************************
23
 *                        CPUFREQ INTERFACE                          *
Linus Torvalds's avatar
Linus Torvalds committed
24
 *********************************************************************/
25 26 27
/*
 * Frequency values here are CPU kHz
 *
28
 * Maximum transition latency is in nanoseconds - if it's unknown,
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31
 * CPUFREQ_ETERNAL shall be used.
 */

32 33 34 35 36
#define CPUFREQ_ETERNAL			(-1)
#define CPUFREQ_NAME_LEN		16
/* Print length for names. Extra 1 space for accomodating '\n' in prints */
#define CPUFREQ_NAME_PLEN		(CPUFREQ_NAME_LEN + 1)

Linus Torvalds's avatar
Linus Torvalds committed
37 38
struct cpufreq_governor;

39 40 41 42 43 44
enum cpufreq_table_sorting {
	CPUFREQ_TABLE_UNSORTED,
	CPUFREQ_TABLE_SORTED_ASCENDING,
	CPUFREQ_TABLE_SORTED_DESCENDING
};

45 46 47 48 49 50
struct cpufreq_freqs {
	unsigned int cpu;	/* cpu nr */
	unsigned int old;
	unsigned int new;
	u8 flags;		/* flags of cpufreq_driver, see below. */
};
51

Linus Torvalds's avatar
Linus Torvalds committed
52 53 54
struct cpufreq_cpuinfo {
	unsigned int		max_freq;
	unsigned int		min_freq;
55 56 57

	/* in 10^(-9) s = nanoseconds */
	unsigned int		transition_latency;
Linus Torvalds's avatar
Linus Torvalds committed
58 59
};

60
struct cpufreq_user_policy {
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65
	unsigned int		min;    /* in kHz */
	unsigned int		max;    /* in kHz */
};

struct cpufreq_policy {
66 67 68
	/* CPUs sharing clock, require sw coordination */
	cpumask_var_t		cpus;	/* Online CPUs only */
	cpumask_var_t		related_cpus; /* Online + Offline CPUs */
69
	cpumask_var_t		real_cpus; /* Related and present */
70

71
	unsigned int		shared_type; /* ACPI: ANY or ALL affected CPUs
72
						should set cpufreq */
73 74
	unsigned int		cpu;    /* cpu managing this policy, must be online */

75
	struct clk		*clk;
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79 80 81
	struct cpufreq_cpuinfo	cpuinfo;/* see above */

	unsigned int		min;    /* in kHz */
	unsigned int		max;    /* in kHz */
	unsigned int		cur;    /* in kHz, only needed if cpufreq
					 * governors are used */
82
	unsigned int		restore_freq; /* = policy->cur before transition */
83 84
	unsigned int		suspend_freq; /* freq to set during suspend */

85
	unsigned int		policy; /* see above */
86
	unsigned int		last_policy; /* policy before unplug */
Linus Torvalds's avatar
Linus Torvalds committed
87
	struct cpufreq_governor	*governor; /* see below */
88
	void			*governor_data;
89
	char			last_governor[CPUFREQ_NAME_LEN]; /* last governor used */
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92 93

	struct work_struct	update; /* if update_policy() needs to be
					 * called, but you're in IRQ context */

94
	struct cpufreq_user_policy user_policy;
95
	struct cpufreq_frequency_table	*freq_table;
96
	enum cpufreq_table_sorting freq_table_sorted;
Linus Torvalds's avatar
Linus Torvalds committed
97

98
	struct list_head        policy_list;
Linus Torvalds's avatar
Linus Torvalds committed
99 100
	struct kobject		kobj;
	struct completion	kobj_unregister;
101 102 103 104 105 106 107 108 109 110

	/*
	 * The rules for this semaphore:
	 * - Any routine that wants to read from the policy structure will
	 *   do a down_read on this semaphore.
	 * - Any routine that will write to the policy structure and/or may take away
	 *   the policy altogether (eg. CPU hotplug), will hold this lock in write
	 *   mode before doing so.
	 */
	struct rw_semaphore	rwsem;
111

112 113 114 115 116 117 118 119 120 121 122
	/*
	 * Fast switch flags:
	 * - fast_switch_possible should be set by the driver if it can
	 *   guarantee that frequency can be changed on any CPU sharing the
	 *   policy and that the change will affect all of the policy CPUs then.
	 * - fast_switch_enabled is to be set by governors that support fast
	 *   freqnency switching with the help of cpufreq_enable_fast_switch().
	 */
	bool			fast_switch_possible;
	bool			fast_switch_enabled;

123 124 125 126
	 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
	unsigned int cached_target_freq;
	int cached_resolved_idx;

127 128 129 130
	/* Synchronization for frequency transitions */
	bool			transition_ongoing; /* Tracks transition status */
	spinlock_t		transition_lock;
	wait_queue_head_t	transition_wait;
131
	struct task_struct	*transition_task; /* Task which is doing the transition */
132

133 134 135
	/* cpufreq-stats */
	struct cpufreq_stats	*stats;

136 137
	/* For cpufreq driver's internal use */
	void			*driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
138 139
};

140
/* Only for ACPI */
141 142 143 144
#define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
#define CPUFREQ_SHARED_TYPE_HW	 (1) /* HW does needed coordination */
#define CPUFREQ_SHARED_TYPE_ALL	 (2) /* All dependent CPUs should set freq */
#define CPUFREQ_SHARED_TYPE_ANY	 (3) /* Freq can be set from any dependent CPU*/
Linus Torvalds's avatar
Linus Torvalds committed
145

146
#ifdef CONFIG_CPU_FREQ
147
struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu);
148
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
149
void cpufreq_cpu_put(struct cpufreq_policy *policy);
150
#else
151 152 153 154
static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
{
	return NULL;
}
155 156 157 158 159 160
static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
{
	return NULL;
}
static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
#endif
161

162 163 164 165 166
static inline bool policy_is_shared(struct cpufreq_policy *policy)
{
	return cpumask_weight(policy->cpus) > 1;
}

167 168
/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
extern struct kobject *cpufreq_global_kobject;
Linus Torvalds's avatar
Linus Torvalds committed
169

170 171 172 173 174
#ifdef CONFIG_CPU_FREQ
unsigned int cpufreq_get(unsigned int cpu);
unsigned int cpufreq_quick_get(unsigned int cpu);
unsigned int cpufreq_quick_get_max(unsigned int cpu);
void disable_cpufreq(void);
Linus Torvalds's avatar
Linus Torvalds committed
175

176 177 178 179 180
u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
int cpufreq_update_policy(unsigned int cpu);
bool have_governor_per_policy(void);
struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
181
void cpufreq_enable_fast_switch(struct cpufreq_policy *policy);
182
void cpufreq_disable_fast_switch(struct cpufreq_policy *policy);
183 184
#else
static inline unsigned int cpufreq_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
185
{
186 187 188 189 190 191 192 193 194 195 196
	return 0;
}
static inline unsigned int cpufreq_quick_get(unsigned int cpu)
{
	return 0;
}
static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
{
	return 0;
}
static inline void disable_cpufreq(void) { }
Linus Torvalds's avatar
Linus Torvalds committed
197 198
#endif

199 200 201 202 203 204 205 206 207 208 209 210
#ifdef CONFIG_CPU_FREQ_STAT
void cpufreq_stats_create_table(struct cpufreq_policy *policy);
void cpufreq_stats_free_table(struct cpufreq_policy *policy);
void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
				     unsigned int new_freq);
#else
static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { }
static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { }
static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
						   unsigned int new_freq) { }
#endif /* CONFIG_CPU_FREQ_STAT */

Linus Torvalds's avatar
Linus Torvalds committed
211
/*********************************************************************
212
 *                      CPUFREQ DRIVER INTERFACE                     *
Linus Torvalds's avatar
Linus Torvalds committed
213 214
 *********************************************************************/

215 216
#define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
#define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
217
#define CPUFREQ_RELATION_C 2  /* closest frequency to target */
Linus Torvalds's avatar
Linus Torvalds committed
218

219 220 221 222
struct freq_attr {
	struct attribute attr;
	ssize_t (*show)(struct cpufreq_policy *, char *);
	ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
Linus Torvalds's avatar
Linus Torvalds committed
223 224
};

225 226 227
#define cpufreq_freq_attr_ro(_name)		\
static struct freq_attr _name =			\
__ATTR(_name, 0444, show_##_name, NULL)
Linus Torvalds's avatar
Linus Torvalds committed
228

229 230 231
#define cpufreq_freq_attr_ro_perm(_name, _perm)	\
static struct freq_attr _name =			\
__ATTR(_name, _perm, show_##_name, NULL)
Linus Torvalds's avatar
Linus Torvalds committed
232

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
#define cpufreq_freq_attr_rw(_name)		\
static struct freq_attr _name =			\
__ATTR(_name, 0644, show_##_name, store_##_name)

struct global_attr {
	struct attribute attr;
	ssize_t (*show)(struct kobject *kobj,
			struct attribute *attr, char *buf);
	ssize_t (*store)(struct kobject *a, struct attribute *b,
			 const char *c, size_t count);
};

#define define_one_global_ro(_name)		\
static struct global_attr _name =		\
__ATTR(_name, 0444, show_##_name, NULL)

#define define_one_global_rw(_name)		\
static struct global_attr _name =		\
__ATTR(_name, 0644, show_##_name, store_##_name)
Linus Torvalds's avatar
Linus Torvalds committed
252 253 254


struct cpufreq_driver {
255 256 257
	char		name[CPUFREQ_NAME_LEN];
	u8		flags;
	void		*driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
258 259

	/* needed by all drivers */
260 261
	int		(*init)(struct cpufreq_policy *policy);
	int		(*verify)(struct cpufreq_policy *policy);
Linus Torvalds's avatar
Linus Torvalds committed
262 263

	/* define one out of two */
264
	int		(*setpolicy)(struct cpufreq_policy *policy);
265 266 267 268 269

	/*
	 * On failure, should always restore frequency to policy->restore_freq
	 * (i.e. old freq).
	 */
270 271 272 273 274
	int		(*target)(struct cpufreq_policy *policy,
				  unsigned int target_freq,
				  unsigned int relation);	/* Deprecated */
	int		(*target_index)(struct cpufreq_policy *policy,
					unsigned int index);
275 276
	unsigned int	(*fast_switch)(struct cpufreq_policy *policy,
				       unsigned int target_freq);
277 278 279 280 281 282 283 284 285 286

	/*
	 * Caches and returns the lowest driver-supported frequency greater than
	 * or equal to the target frequency, subject to any driver limitations.
	 * Does not set the frequency. Only to be implemented for drivers with
	 * target().
	 */
	unsigned int	(*resolve_freq)(struct cpufreq_policy *policy,
					unsigned int target_freq);

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
	/*
	 * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
	 * unset.
	 *
	 * get_intermediate should return a stable intermediate frequency
	 * platform wants to switch to and target_intermediate() should set CPU
	 * to to that frequency, before jumping to the frequency corresponding
	 * to 'index'. Core will take care of sending notifications and driver
	 * doesn't have to handle them in target_intermediate() or
	 * target_index().
	 *
	 * Drivers can return '0' from get_intermediate() in case they don't
	 * wish to switch to intermediate frequency for some target frequency.
	 * In that case core will directly call ->target_index().
	 */
302 303 304 305
	unsigned int	(*get_intermediate)(struct cpufreq_policy *policy,
					    unsigned int index);
	int		(*target_intermediate)(struct cpufreq_policy *policy,
					       unsigned int index);
Linus Torvalds's avatar
Linus Torvalds committed
306 307

	/* should be defined, if possible */
308
	unsigned int	(*get)(unsigned int cpu);
Linus Torvalds's avatar
Linus Torvalds committed
309 310

	/* optional */
311
	int		(*bios_limit)(int cpu, unsigned int *limit);
312

313 314 315 316
	int		(*exit)(struct cpufreq_policy *policy);
	void		(*stop_cpu)(struct cpufreq_policy *policy);
	int		(*suspend)(struct cpufreq_policy *policy);
	int		(*resume)(struct cpufreq_policy *policy);
317 318 319 320

	/* Will be called after the driver is fully initialized */
	void		(*ready)(struct cpufreq_policy *policy);

321
	struct freq_attr **attr;
322 323

	/* platform specific boost support code */
324 325
	bool		boost_enabled;
	int		(*set_boost)(int state);
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328
};

/* flags */
329 330 331 332 333 334 335 336
#define CPUFREQ_STICKY		(1 << 0)	/* driver isn't removed even if
						   all ->init() calls failed */
#define CPUFREQ_CONST_LOOPS	(1 << 1)	/* loops_per_jiffy or other
						   kernel "constants" aren't
						   affected by frequency
						   transitions */
#define CPUFREQ_PM_NO_WARN	(1 << 2)	/* don't warn on suspend/resume
						   speed mismatches */
Linus Torvalds's avatar
Linus Torvalds committed
337

338 339 340 341 342 343 344 345
/*
 * This should be set by platforms having multiple clock-domains, i.e.
 * supporting multiple policies. With this sysfs directories of governor would
 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
 * governor with different tunables for different clusters.
 */
#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3)

346 347 348 349 350 351 352
/*
 * Driver will do POSTCHANGE notifications from outside of their ->target()
 * routine and so must set cpufreq_driver->flags with this flag, so that core
 * can handle them specially.
 */
#define CPUFREQ_ASYNC_NOTIFICATION  (1 << 4)

353 354 355 356 357 358 359 360 361
/*
 * Set by drivers which want cpufreq core to check if CPU is running at a
 * frequency present in freq-table exposed by the driver. For these drivers if
 * CPU is found running at an out of table freq, we will try to set it to a freq
 * from the table. And if that fails, we will stop further boot process by
 * issuing a BUG_ON().
 */
#define CPUFREQ_NEED_INITIAL_FREQ_CHECK	(1 << 5)

362 363
int cpufreq_register_driver(struct cpufreq_driver *driver_data);
int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
Linus Torvalds's avatar
Linus Torvalds committed
364

365
const char *cpufreq_get_current_driver(void);
366
void *cpufreq_get_driver_data(void);
Linus Torvalds's avatar
Linus Torvalds committed
367

368 369
static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
		unsigned int min, unsigned int max)
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374 375 376 377 378 379 380 381 382 383
{
	if (policy->min < min)
		policy->min = min;
	if (policy->max < min)
		policy->max = min;
	if (policy->min > max)
		policy->min = max;
	if (policy->max > max)
		policy->max = max;
	if (policy->min > policy->max)
		policy->min = policy->max;
	return;
}

384 385 386 387 388 389 390
static inline void
cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
{
	cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
			policy->cpuinfo.max_freq);
}

391 392 393
#ifdef CONFIG_CPU_FREQ
void cpufreq_suspend(void);
void cpufreq_resume(void);
394
int cpufreq_generic_suspend(struct cpufreq_policy *policy);
395 396 397 398 399
#else
static inline void cpufreq_suspend(void) {}
static inline void cpufreq_resume(void) {}
#endif

400 401 402
/*********************************************************************
 *                     CPUFREQ NOTIFIER INTERFACE                    *
 *********************************************************************/
403

404 405
#define CPUFREQ_TRANSITION_NOTIFIER	(0)
#define CPUFREQ_POLICY_NOTIFIER		(1)
Linus Torvalds's avatar
Linus Torvalds committed
406

407 408 409
/* Transition notifiers */
#define CPUFREQ_PRECHANGE		(0)
#define CPUFREQ_POSTCHANGE		(1)
410

411 412
/* Policy Notifiers  */
#define CPUFREQ_ADJUST			(0)
413 414 415 416
#define CPUFREQ_NOTIFY			(1)
#define CPUFREQ_START			(2)
#define CPUFREQ_CREATE_POLICY		(3)
#define CPUFREQ_REMOVE_POLICY		(4)
417

418 419 420
#ifdef CONFIG_CPU_FREQ
int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
421

422 423 424 425
void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs);
void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs, int transition_failed);
Linus Torvalds's avatar
Linus Torvalds committed
426

427 428 429
#else /* CONFIG_CPU_FREQ */
static inline int cpufreq_register_notifier(struct notifier_block *nb,
						unsigned int list)
430 431 432
{
	return 0;
}
433 434
static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
						unsigned int list)
435 436 437
{
	return 0;
}
438 439 440 441 442 443 444 445 446 447 448 449 450 451
#endif /* !CONFIG_CPU_FREQ */

/**
 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
 * safe)
 * @old:   old value
 * @div:   divisor
 * @mult:  multiplier
 *
 *
 * new = old * mult / div
 */
static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
		u_int mult)
452
{
453 454 455 456 457 458 459 460 461
#if BITS_PER_LONG == 32
	u64 result = ((u64) old) * ((u64) mult);
	do_div(result, div);
	return (unsigned long) result;

#elif BITS_PER_LONG == 64
	unsigned long result = old * ((u64) mult);
	result /= div;
	return result;
462
#endif
463
}
464

Linus Torvalds's avatar
Linus Torvalds committed
465
/*********************************************************************
466
 *                          CPUFREQ GOVERNORS                        *
Linus Torvalds's avatar
Linus Torvalds committed
467 468
 *********************************************************************/

469 470 471 472 473 474 475 476
/*
 * If (cpufreq_driver->target) exists, the ->governor decides what frequency
 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
 * two generic policies are available:
 */
#define CPUFREQ_POLICY_POWERSAVE	(1)
#define CPUFREQ_POLICY_PERFORMANCE	(2)

477 478 479 480 481 482 483 484 485 486 487 488 489 490
/*
 * The polling frequency depends on the capability of the processor. Default
 * polling frequency is 1000 times the transition latency of the processor. The
 * ondemand governor will work on any processor with transition latency <= 10ms,
 * using appropriate sampling rate.
 *
 * For CPUs with transition latency > 10ms (mostly drivers with CPUFREQ_ETERNAL)
 * the ondemand governor will not work. All times here are in us (microseconds).
 */
#define MIN_SAMPLING_RATE_RATIO		(2)
#define LATENCY_MULTIPLIER		(1000)
#define MIN_LATENCY_MULTIPLIER		(20)
#define TRANSITION_LATENCY_LIMIT	(10 * 1000 * 1000)

491 492
struct cpufreq_governor {
	char	name[CPUFREQ_NAME_LEN];
493 494 495 496 497
	int	(*init)(struct cpufreq_policy *policy);
	void	(*exit)(struct cpufreq_policy *policy);
	int	(*start)(struct cpufreq_policy *policy);
	void	(*stop)(struct cpufreq_policy *policy);
	void	(*limits)(struct cpufreq_policy *policy);
498 499 500 501 502 503 504 505 506 507 508 509
	ssize_t	(*show_setspeed)	(struct cpufreq_policy *policy,
					 char *buf);
	int	(*store_setspeed)	(struct cpufreq_policy *policy,
					 unsigned int freq);
	unsigned int max_transition_latency; /* HW must be able to switch to
			next freq faster than this value in nano secs or we
			will fallback to performance governor */
	struct list_head	governor_list;
	struct module		*owner;
};

/* Pass a target to the cpufreq driver */
510 511
unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
					unsigned int target_freq);
512 513 514 515 516 517
int cpufreq_driver_target(struct cpufreq_policy *policy,
				 unsigned int target_freq,
				 unsigned int relation);
int __cpufreq_driver_target(struct cpufreq_policy *policy,
				   unsigned int target_freq,
				   unsigned int relation);
518 519
unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
					 unsigned int target_freq);
520 521 522
int cpufreq_register_governor(struct cpufreq_governor *governor);
void cpufreq_unregister_governor(struct cpufreq_governor *governor);

523 524
struct cpufreq_governor *cpufreq_default_governor(void);
struct cpufreq_governor *cpufreq_fallback_governor(void);
Linus Torvalds's avatar
Linus Torvalds committed
525

526 527 528 529 530 531 532 533
static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
{
	if (policy->max < policy->cur)
		__cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
	else if (policy->min > policy->cur)
		__cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
}

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
/* Governor attribute set */
struct gov_attr_set {
	struct kobject kobj;
	struct list_head policy_list;
	struct mutex update_lock;
	int usage_count;
};

/* sysfs ops for cpufreq governors */
extern const struct sysfs_ops governor_sysfs_ops;

void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);

/* Governor sysfs attribute */
struct governor_attr {
	struct attribute attr;
	ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
	ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
			 size_t count);
};

Linus Torvalds's avatar
Linus Torvalds committed
557 558 559 560
/*********************************************************************
 *                     FREQUENCY TABLE HELPERS                       *
 *********************************************************************/

561
/* Special Values of .frequency field */
562 563
#define CPUFREQ_ENTRY_INVALID	~0u
#define CPUFREQ_TABLE_END	~1u
564 565
/* Special Values of .flags field */
#define CPUFREQ_BOOST_FREQ	(1 << 0)
Linus Torvalds's avatar
Linus Torvalds committed
566 567

struct cpufreq_frequency_table {
568
	unsigned int	flags;
569
	unsigned int	driver_data; /* driver specific data, not used by core */
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573
	unsigned int	frequency; /* kHz - doesn't need to be in ascending
				    * order */
};

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
int dev_pm_opp_init_cpufreq_table(struct device *dev,
				  struct cpufreq_frequency_table **table);
void dev_pm_opp_free_cpufreq_table(struct device *dev,
				   struct cpufreq_frequency_table **table);
#else
static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
						struct cpufreq_frequency_table
						**table)
{
	return -EINVAL;
}

static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
						 struct cpufreq_frequency_table
						 **table)
{
}
#endif

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
/*
 * cpufreq_for_each_entry -	iterate over a cpufreq_frequency_table
 * @pos:	the cpufreq_frequency_table * to use as a loop cursor.
 * @table:	the cpufreq_frequency_table * to iterate over.
 */

#define cpufreq_for_each_entry(pos, table)	\
	for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)

/*
 * cpufreq_for_each_valid_entry -     iterate over a cpufreq_frequency_table
 *	excluding CPUFREQ_ENTRY_INVALID frequencies.
 * @pos:        the cpufreq_frequency_table * to use as a loop cursor.
 * @table:      the cpufreq_frequency_table * to iterate over.
 */

610 611 612 613 614
#define cpufreq_for_each_valid_entry(pos, table)			\
	for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)	\
		if (pos->frequency == CPUFREQ_ENTRY_INVALID)		\
			continue;					\
		else
615

Linus Torvalds's avatar
Linus Torvalds committed
616 617 618 619 620
int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
				    struct cpufreq_frequency_table *table);

int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
				   struct cpufreq_frequency_table *table);
621
int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
Linus Torvalds's avatar
Linus Torvalds committed
622

623 624 625
int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
				 unsigned int target_freq,
				 unsigned int relation);
626 627
int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
		unsigned int freq);
Linus Torvalds's avatar
Linus Torvalds committed
628

629 630
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);

631 632 633
#ifdef CONFIG_CPU_FREQ
int cpufreq_boost_trigger_state(int state);
int cpufreq_boost_enabled(void);
634 635
int cpufreq_enable_boost_support(void);
bool policy_has_boost_freq(struct cpufreq_policy *policy);
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856

/* Find lowest freq at or above target in a table in ascending order */
static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq >= target_freq)
			return i;

		best = i;
	}

	return best;
}

/* Find lowest freq at or above target in a table in descending order */
static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq == target_freq)
			return i;

		if (freq > target_freq) {
			best = i;
			continue;
		}

		/* No freq found above target_freq */
		if (best == -1)
			return i;

		return best;
	}

	return best;
}

/* Works only on sorted freq-tables */
static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
					     unsigned int target_freq)
{
	target_freq = clamp_val(target_freq, policy->min, policy->max);

	if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
		return cpufreq_table_find_index_al(policy, target_freq);
	else
		return cpufreq_table_find_index_dl(policy, target_freq);
}

/* Find highest freq at or below target in a table in ascending order */
static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq == target_freq)
			return i;

		if (freq < target_freq) {
			best = i;
			continue;
		}

		/* No freq found below target_freq */
		if (best == -1)
			return i;

		return best;
	}

	return best;
}

/* Find highest freq at or below target in a table in descending order */
static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq <= target_freq)
			return i;

		best = i;
	}

	return best;
}

/* Works only on sorted freq-tables */
static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
					     unsigned int target_freq)
{
	target_freq = clamp_val(target_freq, policy->min, policy->max);

	if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
		return cpufreq_table_find_index_ah(policy, target_freq);
	else
		return cpufreq_table_find_index_dh(policy, target_freq);
}

/* Find closest freq to target in a table in ascending order */
static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq == target_freq)
			return i;

		if (freq < target_freq) {
			best = i;
			continue;
		}

		/* No freq found below target_freq */
		if (best == -1)
			return i;

		/* Choose the closest freq */
		if (target_freq - table[best].frequency > freq - target_freq)
			return i;

		return best;
	}

	return best;
}

/* Find closest freq to target in a table in descending order */
static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
					      unsigned int target_freq)
{
	struct cpufreq_frequency_table *table = policy->freq_table;
	unsigned int freq;
	int i, best = -1;

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
		freq = table[i].frequency;

		if (freq == target_freq)
			return i;

		if (freq > target_freq) {
			best = i;
			continue;
		}

		/* No freq found above target_freq */
		if (best == -1)
			return i;

		/* Choose the closest freq */
		if (table[best].frequency - target_freq > target_freq - freq)
			return i;

		return best;
	}

	return best;
}

/* Works only on sorted freq-tables */
static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
					     unsigned int target_freq)
{
	target_freq = clamp_val(target_freq, policy->min, policy->max);

	if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
		return cpufreq_table_find_index_ac(policy, target_freq);
	else
		return cpufreq_table_find_index_dc(policy, target_freq);
}

static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
						 unsigned int target_freq,
						 unsigned int relation)
{
	if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
		return cpufreq_table_index_unsorted(policy, target_freq,
						    relation);

	switch (relation) {
	case CPUFREQ_RELATION_L:
		return cpufreq_table_find_index_l(policy, target_freq);
	case CPUFREQ_RELATION_H:
		return cpufreq_table_find_index_h(policy, target_freq);
	case CPUFREQ_RELATION_C:
		return cpufreq_table_find_index_c(policy, target_freq);
	default:
		pr_err("%s: Invalid relation: %d\n", __func__, relation);
		return -EINVAL;
	}
}
857 858 859 860 861 862 863 864 865
#else
static inline int cpufreq_boost_trigger_state(int state)
{
	return 0;
}
static inline int cpufreq_boost_enabled(void)
{
	return 0;
}
866 867 868 869 870 871 872 873 874 875

static inline int cpufreq_enable_boost_support(void)
{
	return -EINVAL;
}

static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
{
	return false;
}
876
#endif
Linus Torvalds's avatar
Linus Torvalds committed
877 878 879

/* the following are really really optional */
extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
880
extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
881
extern struct freq_attr *cpufreq_generic_attr[];
882 883
int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
				      struct cpufreq_frequency_table *table);
884

885
unsigned int cpufreq_generic_get(unsigned int cpu);
886 887 888
int cpufreq_generic_init(struct cpufreq_policy *policy,
		struct cpufreq_frequency_table *table,
		unsigned int transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
889
#endif /* _LINUX_CPUFREQ_H */