2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2013-06-19 16:49:33 +08:00
|
|
|
* linux/include/linux/cpufreq.h
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2013-06-19 16:49:33 +08:00
|
|
|
* Copyright (C) 2001 Russell King
|
|
|
|
* (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
|
2011-04-29 07:42:53 +08:00
|
|
|
*
|
2005-04-17 06:20:36 +08:00
|
|
|
* 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
|
|
|
|
|
2012-10-23 07:28:05 +08:00
|
|
|
#include <asm/cputime.h>
|
2006-01-14 23:01:49 +08:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/kobject.h>
|
|
|
|
#include <linux/sysfs.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/cpumask.h>
|
2005-10-31 07:03:48 +08:00
|
|
|
#include <asm/div64.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#define CPUFREQ_NAME_LEN 16
|
2012-10-23 07:23:43 +08:00
|
|
|
/* Print length for names. Extra 1 space for accomodating '\n' in prints */
|
|
|
|
#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
* CPUFREQ NOTIFIER INTERFACE *
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
#define CPUFREQ_TRANSITION_NOTIFIER (0)
|
|
|
|
#define CPUFREQ_POLICY_NOTIFIER (1)
|
|
|
|
|
2007-10-03 04:28:15 +08:00
|
|
|
#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);
|
2012-03-14 07:18:39 +08:00
|
|
|
extern void disable_cpufreq(void);
|
2007-10-03 04:28:15 +08:00
|
|
|
#else /* CONFIG_CPU_FREQ */
|
|
|
|
static inline int cpufreq_register_notifier(struct notifier_block *nb,
|
|
|
|
unsigned int list)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
|
|
|
|
unsigned int list)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2012-03-14 07:18:39 +08:00
|
|
|
static inline void disable_cpufreq(void) { }
|
2007-10-03 04:28:15 +08:00
|
|
|
#endif /* CONFIG_CPU_FREQ */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
2011-04-29 07:42:53 +08:00
|
|
|
/* Frequency values here are CPU kHz so that hardware which doesn't run
|
|
|
|
* with some frequencies can complain without having to guess what per
|
|
|
|
* cent / per mille means.
|
2005-06-01 10:03:47 +08:00
|
|
|
* Maximum transition latency is in nanoseconds - if it's unknown,
|
2005-04-17 06:20:36 +08:00
|
|
|
* CPUFREQ_ETERNAL shall be used.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct cpufreq_governor;
|
|
|
|
|
2009-07-24 21:25:05 +08:00
|
|
|
/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
|
|
|
|
extern struct kobject *cpufreq_global_kobject;
|
2013-05-17 18:39:09 +08:00
|
|
|
int cpufreq_get_global_kobject(void);
|
|
|
|
void cpufreq_put_global_kobject(void);
|
|
|
|
int cpufreq_sysfs_create_file(const struct attribute *attr);
|
|
|
|
void cpufreq_sysfs_remove_file(const struct attribute *attr);
|
2009-07-24 21:25:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define CPUFREQ_ETERNAL (-1)
|
|
|
|
struct cpufreq_cpuinfo {
|
|
|
|
unsigned int max_freq;
|
|
|
|
unsigned int min_freq;
|
2011-04-29 07:42:53 +08:00
|
|
|
|
|
|
|
/* in 10^(-9) s = nanoseconds */
|
|
|
|
unsigned int transition_latency;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct cpufreq_real_policy {
|
|
|
|
unsigned int min; /* in kHz */
|
|
|
|
unsigned int max; /* in kHz */
|
2011-04-29 07:42:53 +08:00
|
|
|
unsigned int policy; /* see above */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_governor *governor; /* see below */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cpufreq_policy {
|
2013-01-31 10:03:53 +08:00
|
|
|
/* CPUs sharing clock, require sw coordination */
|
|
|
|
cpumask_var_t cpus; /* Online CPUs only */
|
|
|
|
cpumask_var_t related_cpus; /* Online + Offline CPUs */
|
|
|
|
|
2013-02-01 14:40:02 +08:00
|
|
|
unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
|
2005-12-15 04:05:00 +08:00
|
|
|
should set cpufreq */
|
2013-01-14 21:23:03 +08:00
|
|
|
unsigned int cpu; /* cpu nr of CPU managing this policy */
|
|
|
|
unsigned int last_cpu; /* cpu nr of previous CPU that managed
|
|
|
|
* this policy */
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
2011-04-29 07:42:53 +08:00
|
|
|
unsigned int policy; /* see above */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_governor *governor; /* see below */
|
2013-03-27 23:58:57 +08:00
|
|
|
void *governor_data;
|
cpufreq: Fix governor start/stop race condition
Cpufreq governors' stop and start operations should be carried out
in sequence. Otherwise, there will be unexpected behavior, like in
the example below.
Suppose there are 4 CPUs and policy->cpu=CPU0, CPU1/2/3 are linked
to CPU0. The normal sequence is:
1) Current governor is userspace. An application tries to set the
governor to ondemand. It will call __cpufreq_set_policy() in
which it will stop the userspace governor and then start the
ondemand governor.
2) Current governor is userspace. The online of CPU3 runs on CPU0.
It will call cpufreq_add_policy_cpu() in which it will first
stop the userspace governor, and then start it again.
If the sequence of the above two cases interleaves, it becomes:
1) Application stops userspace governor
2) Hotplug stops userspace governor
which is a problem, because the governor shouldn't be stopped twice
in a row. What happens next is:
3) Application starts ondemand governor
4) Hotplug starts a governor
In step 4, the hotplug is supposed to start the userspace governor,
but now the governor has been changed by the application to ondemand,
so the ondemand governor is started once again, which is incorrect.
The solution is to prevent policy governors from being stopped
multiple times in a row. A governor should only be stopped once for
one policy. After it has been stopped, no more governor stop
operations should be executed.
Also add a mutex to serialize governor operations.
[rjw: Changelog. And you owe me a beverage of my choice.]
Signed-off-by: Xiaoguang Chen <chenxg@marvell.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-19 15:00:07 +08:00
|
|
|
bool governor_enabled; /* governor start/stop flag */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
struct work_struct update; /* if update_policy() needs to be
|
|
|
|
* called, but you're in IRQ context */
|
|
|
|
|
|
|
|
struct cpufreq_real_policy user_policy;
|
|
|
|
|
|
|
|
struct kobject kobj;
|
|
|
|
struct completion kobj_unregister;
|
2013-07-02 19:06:28 +08:00
|
|
|
int transition_ongoing; /* Tracks transition status */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2013-01-14 21:23:03 +08:00
|
|
|
#define CPUFREQ_ADJUST (0)
|
|
|
|
#define CPUFREQ_INCOMPATIBLE (1)
|
|
|
|
#define CPUFREQ_NOTIFY (2)
|
|
|
|
#define CPUFREQ_START (3)
|
|
|
|
#define CPUFREQ_UPDATE_POLICY_CPU (4)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-02-01 14:40:02 +08:00
|
|
|
/* Only for ACPI */
|
2006-06-26 12:34:43 +08:00
|
|
|
#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*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-01-31 17:44:40 +08:00
|
|
|
static inline bool policy_is_shared(struct cpufreq_policy *policy)
|
|
|
|
{
|
|
|
|
return cpumask_weight(policy->cpus) > 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/******************** cpufreq transition notifiers *******************/
|
|
|
|
|
|
|
|
#define CPUFREQ_PRECHANGE (0)
|
|
|
|
#define CPUFREQ_POSTCHANGE (1)
|
|
|
|
#define CPUFREQ_RESUMECHANGE (8)
|
2005-04-29 22:40:12 +08:00
|
|
|
#define CPUFREQ_SUSPENDCHANGE (9)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
struct cpufreq_freqs {
|
|
|
|
unsigned int cpu; /* cpu nr */
|
|
|
|
unsigned int old;
|
|
|
|
unsigned int new;
|
|
|
|
u8 flags; /* flags of cpufreq_driver, see below. */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2013-06-19 16:49:33 +08:00
|
|
|
* cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
|
|
|
|
* safe)
|
2005-04-17 06:20:36 +08:00
|
|
|
* @old: old value
|
|
|
|
* @div: divisor
|
|
|
|
* @mult: multiplier
|
|
|
|
*
|
|
|
|
*
|
2013-06-19 16:49:33 +08:00
|
|
|
* new = old * mult / div
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2013-06-19 16:49:33 +08:00
|
|
|
static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
|
|
|
|
u_int mult)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
#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;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
* CPUFREQ GOVERNORS *
|
|
|
|
*********************************************************************/
|
|
|
|
|
2013-03-27 23:58:57 +08:00
|
|
|
#define CPUFREQ_GOV_START 1
|
|
|
|
#define CPUFREQ_GOV_STOP 2
|
|
|
|
#define CPUFREQ_GOV_LIMITS 3
|
|
|
|
#define CPUFREQ_GOV_POLICY_INIT 4
|
|
|
|
#define CPUFREQ_GOV_POLICY_EXIT 5
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
struct cpufreq_governor {
|
|
|
|
char name[CPUFREQ_NAME_LEN];
|
2013-02-01 13:42:58 +08:00
|
|
|
int initialized;
|
2011-04-29 07:42:53 +08:00
|
|
|
int (*governor) (struct cpufreq_policy *policy,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int event);
|
2007-10-27 01:18:21 +08:00
|
|
|
ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
|
|
|
|
char *buf);
|
2011-04-29 07:42:53 +08:00
|
|
|
int (*store_setspeed) (struct cpufreq_policy *policy,
|
2007-10-27 01:18:21 +08:00
|
|
|
unsigned int freq);
|
2007-10-03 04:28:12 +08:00
|
|
|
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 */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head governor_list;
|
|
|
|
struct module *owner;
|
|
|
|
};
|
|
|
|
|
2011-04-29 07:42:53 +08:00
|
|
|
/*
|
|
|
|
* Pass a target to the cpufreq driver.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
extern int cpufreq_driver_target(struct cpufreq_policy *policy,
|
|
|
|
unsigned int target_freq,
|
|
|
|
unsigned int relation);
|
|
|
|
extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
|
|
|
|
unsigned int target_freq,
|
|
|
|
unsigned int relation);
|
|
|
|
|
2008-08-05 02:59:07 +08:00
|
|
|
extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy,
|
|
|
|
unsigned int cpu);
|
2006-10-04 03:38:45 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int cpufreq_register_governor(struct cpufreq_governor *governor);
|
|
|
|
void cpufreq_unregister_governor(struct cpufreq_governor *governor);
|
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
* CPUFREQ DRIVER INTERFACE *
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
#define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
|
|
|
|
#define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
|
|
|
|
|
|
|
|
struct freq_attr;
|
|
|
|
|
|
|
|
struct cpufreq_driver {
|
2013-06-19 16:49:33 +08:00
|
|
|
struct module *owner;
|
2005-04-17 06:20:36 +08:00
|
|
|
char name[CPUFREQ_NAME_LEN];
|
|
|
|
u8 flags;
|
2013-03-27 23:58:58 +08:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
bool have_governor_per_policy;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* needed by all drivers */
|
|
|
|
int (*init) (struct cpufreq_policy *policy);
|
|
|
|
int (*verify) (struct cpufreq_policy *policy);
|
|
|
|
|
|
|
|
/* define one out of two */
|
|
|
|
int (*setpolicy) (struct cpufreq_policy *policy);
|
|
|
|
int (*target) (struct cpufreq_policy *policy,
|
|
|
|
unsigned int target_freq,
|
|
|
|
unsigned int relation);
|
|
|
|
|
|
|
|
/* should be defined, if possible */
|
|
|
|
unsigned int (*get) (unsigned int cpu);
|
|
|
|
|
|
|
|
/* optional */
|
2008-08-05 02:59:07 +08:00
|
|
|
unsigned int (*getavg) (struct cpufreq_policy *policy,
|
|
|
|
unsigned int cpu);
|
2009-11-19 19:31:01 +08:00
|
|
|
int (*bios_limit) (int cpu, unsigned int *limit);
|
2008-08-05 02:59:07 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int (*exit) (struct cpufreq_policy *policy);
|
2011-03-11 04:13:05 +08:00
|
|
|
int (*suspend) (struct cpufreq_policy *policy);
|
2005-04-17 06:20:36 +08:00
|
|
|
int (*resume) (struct cpufreq_policy *policy);
|
|
|
|
struct freq_attr **attr;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* flags */
|
|
|
|
|
2011-04-29 07:42:53 +08:00
|
|
|
#define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if
|
2005-04-17 06:20:36 +08:00
|
|
|
* all ->init() calls failed */
|
2011-04-29 07:42:53 +08:00
|
|
|
#define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel
|
2005-04-17 06:20:36 +08:00
|
|
|
* "constants" aren't affected by
|
|
|
|
* frequency transitions */
|
2005-04-29 22:40:12 +08:00
|
|
|
#define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed
|
|
|
|
* mismatches */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-27 06:55:48 +08:00
|
|
|
int cpufreq_register_driver(struct cpufreq_driver *driver_data);
|
|
|
|
int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-03-24 14:26:43 +08:00
|
|
|
void cpufreq_notify_transition(struct cpufreq_policy *policy,
|
|
|
|
struct cpufreq_freqs *freqs, unsigned int state);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-19 16:49:33 +08:00
|
|
|
static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
|
|
|
|
unsigned int min, unsigned int max)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct freq_attr {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct cpufreq_policy *, char *);
|
|
|
|
ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
|
|
|
|
};
|
|
|
|
|
2010-04-01 03:56:46 +08:00
|
|
|
#define cpufreq_freq_attr_ro(_name) \
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
__ATTR(_name, 0444, show_##_name, NULL)
|
|
|
|
|
|
|
|
#define cpufreq_freq_attr_ro_perm(_name, _perm) \
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
__ATTR(_name, _perm, show_##_name, NULL)
|
|
|
|
|
|
|
|
#define cpufreq_freq_attr_rw(_name) \
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
__ATTR(_name, 0644, show_##_name, store_##_name)
|
|
|
|
|
2009-07-24 21:25:05 +08:00
|
|
|
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);
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-04-01 03:56:46 +08:00
|
|
|
#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)
|
|
|
|
|
2013-01-28 21:50:39 +08:00
|
|
|
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
|
|
|
|
void cpufreq_cpu_put(struct cpufreq_policy *data);
|
|
|
|
const char *cpufreq_get_current_driver(void);
|
2010-04-01 03:56:46 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*********************************************************************
|
|
|
|
* CPUFREQ 2.6. INTERFACE *
|
|
|
|
*********************************************************************/
|
2013-05-17 19:26:32 +08:00
|
|
|
u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
|
2005-04-17 06:20:36 +08:00
|
|
|
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
|
|
|
|
int cpufreq_update_policy(unsigned int cpu);
|
2013-03-27 23:58:58 +08:00
|
|
|
bool have_governor_per_policy(void);
|
2013-05-16 13:09:57 +08:00
|
|
|
struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-10-27 07:49:29 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ
|
2013-06-19 16:49:33 +08:00
|
|
|
/*
|
|
|
|
* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it
|
|
|
|
*/
|
2007-09-27 06:52:17 +08:00
|
|
|
unsigned int cpufreq_get(unsigned int cpu);
|
2009-10-27 07:49:29 +08:00
|
|
|
#else
|
|
|
|
static inline unsigned int cpufreq_get(unsigned int cpu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-19 16:49:33 +08:00
|
|
|
/*
|
|
|
|
* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it
|
|
|
|
*/
|
2005-12-03 02:43:20 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ
|
|
|
|
unsigned int cpufreq_quick_get(unsigned int cpu);
|
2011-06-29 01:59:12 +08:00
|
|
|
unsigned int cpufreq_quick_get_max(unsigned int cpu);
|
2005-12-03 02:43:20 +08:00
|
|
|
#else
|
|
|
|
static inline unsigned int cpufreq_quick_get(unsigned int cpu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2011-06-29 01:59:12 +08:00
|
|
|
static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-12-03 02:43:20 +08:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*********************************************************************
|
|
|
|
* CPUFREQ DEFAULT GOVERNOR *
|
|
|
|
*********************************************************************/
|
|
|
|
|
2007-10-03 04:28:12 +08:00
|
|
|
/*
|
2013-06-19 16:49:33 +08:00
|
|
|
* Performance governor is fallback governor if any other gov failed to auto
|
|
|
|
* load due latency restrictions
|
|
|
|
*/
|
2007-10-03 04:28:13 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
|
2005-04-17 06:20:36 +08:00
|
|
|
extern struct cpufreq_governor cpufreq_gov_performance;
|
2007-10-03 04:28:13 +08:00
|
|
|
#endif
|
2007-10-03 04:28:12 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance)
|
2008-04-19 04:31:13 +08:00
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_powersave;
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave)
|
2005-04-17 06:20:36 +08:00
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_userspace;
|
2007-10-03 04:28:12 +08:00
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace)
|
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_ondemand;
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand)
|
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_conservative;
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative)
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
* FREQUENCY TABLE HELPERS *
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
#define CPUFREQ_ENTRY_INVALID ~0
|
|
|
|
#define CPUFREQ_TABLE_END ~1
|
|
|
|
|
|
|
|
struct cpufreq_frequency_table {
|
2013-03-30 18:55:15 +08:00
|
|
|
unsigned int driver_data; /* driver specific data, not used by core */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int frequency; /* kHz - doesn't need to be in ascending
|
|
|
|
* order */
|
|
|
|
};
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
|
|
|
|
struct cpufreq_frequency_table *table,
|
|
|
|
unsigned int target_freq,
|
|
|
|
unsigned int relation,
|
|
|
|
unsigned int *index);
|
|
|
|
|
|
|
|
/* the following 3 funtions are for cpufreq core use only */
|
|
|
|
struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
|
|
|
|
|
|
|
|
/* the following are really really optional */
|
|
|
|
extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
|
|
|
|
|
2011-04-29 07:42:53 +08:00
|
|
|
void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int cpu);
|
2013-01-14 21:23:03 +08:00
|
|
|
void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
void cpufreq_frequency_table_put_attr(unsigned int cpu);
|
2013-06-27 15:08:54 +08:00
|
|
|
|
|
|
|
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* _LINUX_CPUFREQ_H */
|