Merge branch 'pm-cpuidle'
* pm-cpuidle: cpuidle: Fix ARCH_NEEDS_CPU_IDLE_COUPLED dependency warning cpuidle: Comment the driver's framework code cpuidle: simplify multiple driver support ARM: zynq: Add cpuidle support cpuidle: improve governor Kconfig options
This commit is contained in:
commit
93bc11c3cc
|
@ -1311,6 +1311,7 @@ W: http://wiki.xilinx.com
|
||||||
T: git git://git.xilinx.com/linux-xlnx.git
|
T: git git://git.xilinx.com/linux-xlnx.git
|
||||||
S: Supported
|
S: Supported
|
||||||
F: arch/arm/mach-zynq/
|
F: arch/arm/mach-zynq/
|
||||||
|
F: drivers/cpuidle/cpuidle-zynq.c
|
||||||
|
|
||||||
ARM64 PORT (AARCH64 ARCHITECTURE)
|
ARM64 PORT (AARCH64 ARCHITECTURE)
|
||||||
M: Catalin Marinas <catalin.marinas@arm.com>
|
M: Catalin Marinas <catalin.marinas@arm.com>
|
||||||
|
|
|
@ -1,7 +1,9 @@
|
||||||
|
|
||||||
config CPU_IDLE
|
menuconfig CPU_IDLE
|
||||||
bool "CPU idle PM support"
|
bool "CPU idle PM support"
|
||||||
default y if ACPI || PPC_PSERIES
|
default y if ACPI || PPC_PSERIES
|
||||||
|
select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE)
|
||||||
|
select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE)
|
||||||
help
|
help
|
||||||
CPU idle is a generic framework for supporting software-controlled
|
CPU idle is a generic framework for supporting software-controlled
|
||||||
idle processor power management. It includes modular cross-platform
|
idle processor power management. It includes modular cross-platform
|
||||||
|
@ -9,9 +11,10 @@ config CPU_IDLE
|
||||||
|
|
||||||
If you're using an ACPI-enabled platform, you should say Y here.
|
If you're using an ACPI-enabled platform, you should say Y here.
|
||||||
|
|
||||||
|
if CPU_IDLE
|
||||||
|
|
||||||
config CPU_IDLE_MULTIPLE_DRIVERS
|
config CPU_IDLE_MULTIPLE_DRIVERS
|
||||||
bool "Support multiple cpuidle drivers"
|
bool "Support multiple cpuidle drivers"
|
||||||
depends on CPU_IDLE
|
|
||||||
default n
|
default n
|
||||||
help
|
help
|
||||||
Allows the cpuidle framework to use different drivers for each CPU.
|
Allows the cpuidle framework to use different drivers for each CPU.
|
||||||
|
@ -19,24 +22,26 @@ config CPU_IDLE_MULTIPLE_DRIVERS
|
||||||
states. If unsure say N.
|
states. If unsure say N.
|
||||||
|
|
||||||
config CPU_IDLE_GOV_LADDER
|
config CPU_IDLE_GOV_LADDER
|
||||||
bool
|
bool "Ladder governor (for periodic timer tick)"
|
||||||
depends on CPU_IDLE
|
|
||||||
default y
|
default y
|
||||||
|
|
||||||
config CPU_IDLE_GOV_MENU
|
config CPU_IDLE_GOV_MENU
|
||||||
bool
|
bool "Menu governor (for tickless system)"
|
||||||
depends on CPU_IDLE && NO_HZ
|
|
||||||
default y
|
default y
|
||||||
|
|
||||||
config ARCH_NEEDS_CPU_IDLE_COUPLED
|
|
||||||
def_bool n
|
|
||||||
|
|
||||||
if CPU_IDLE
|
|
||||||
|
|
||||||
config CPU_IDLE_CALXEDA
|
config CPU_IDLE_CALXEDA
|
||||||
bool "CPU Idle Driver for Calxeda processors"
|
bool "CPU Idle Driver for Calxeda processors"
|
||||||
depends on ARCH_HIGHBANK
|
depends on ARCH_HIGHBANK
|
||||||
help
|
help
|
||||||
Select this to enable cpuidle on Calxeda processors.
|
Select this to enable cpuidle on Calxeda processors.
|
||||||
|
|
||||||
|
config CPU_IDLE_ZYNQ
|
||||||
|
bool "CPU Idle Driver for Xilinx Zynq processors"
|
||||||
|
depends on ARCH_ZYNQ
|
||||||
|
help
|
||||||
|
Select this to enable cpuidle on Xilinx Zynq processors.
|
||||||
|
|
||||||
endif
|
endif
|
||||||
|
|
||||||
|
config ARCH_NEEDS_CPU_IDLE_COUPLED
|
||||||
|
def_bool n
|
||||||
|
|
|
@ -7,3 +7,4 @@ obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
|
||||||
|
|
||||||
obj-$(CONFIG_CPU_IDLE_CALXEDA) += cpuidle-calxeda.o
|
obj-$(CONFIG_CPU_IDLE_CALXEDA) += cpuidle-calxeda.o
|
||||||
obj-$(CONFIG_ARCH_KIRKWOOD) += cpuidle-kirkwood.o
|
obj-$(CONFIG_ARCH_KIRKWOOD) += cpuidle-kirkwood.o
|
||||||
|
obj-$(CONFIG_CPU_IDLE_ZYNQ) += cpuidle-zynq.o
|
||||||
|
|
|
@ -0,0 +1,83 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2012-2013 Xilinx
|
||||||
|
*
|
||||||
|
* CPU idle support for Xilinx Zynq
|
||||||
|
*
|
||||||
|
* based on arch/arm/mach-at91/cpuidle.c
|
||||||
|
*
|
||||||
|
* This program is free software; you can redistribute it and/or modify it
|
||||||
|
* under the terms and conditions of the GNU General Public License,
|
||||||
|
* version 2, as published by the Free Software Foundation.
|
||||||
|
*
|
||||||
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||||
|
* more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License along with
|
||||||
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*
|
||||||
|
* The cpu idle uses wait-for-interrupt and RAM self refresh in order
|
||||||
|
* to implement two idle states -
|
||||||
|
* #1 wait-for-interrupt
|
||||||
|
* #2 wait-for-interrupt and RAM self refresh
|
||||||
|
*
|
||||||
|
* Maintainer: Michal Simek <michal.simek@xilinx.com>
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <linux/init.h>
|
||||||
|
#include <linux/cpu_pm.h>
|
||||||
|
#include <linux/cpuidle.h>
|
||||||
|
#include <linux/of.h>
|
||||||
|
#include <asm/proc-fns.h>
|
||||||
|
#include <asm/cpuidle.h>
|
||||||
|
|
||||||
|
#define ZYNQ_MAX_STATES 2
|
||||||
|
|
||||||
|
/* Actual code that puts the SoC in different idle states */
|
||||||
|
static int zynq_enter_idle(struct cpuidle_device *dev,
|
||||||
|
struct cpuidle_driver *drv, int index)
|
||||||
|
{
|
||||||
|
/* Devices must be stopped here */
|
||||||
|
cpu_pm_enter();
|
||||||
|
|
||||||
|
/* Add code for DDR self refresh start */
|
||||||
|
cpu_do_idle();
|
||||||
|
|
||||||
|
/* Add code for DDR self refresh stop */
|
||||||
|
cpu_pm_exit();
|
||||||
|
|
||||||
|
return index;
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct cpuidle_driver zynq_idle_driver = {
|
||||||
|
.name = "zynq_idle",
|
||||||
|
.owner = THIS_MODULE,
|
||||||
|
.states = {
|
||||||
|
ARM_CPUIDLE_WFI_STATE,
|
||||||
|
{
|
||||||
|
.enter = zynq_enter_idle,
|
||||||
|
.exit_latency = 10,
|
||||||
|
.target_residency = 10000,
|
||||||
|
.flags = CPUIDLE_FLAG_TIME_VALID |
|
||||||
|
CPUIDLE_FLAG_TIMER_STOP,
|
||||||
|
.name = "RAM_SR",
|
||||||
|
.desc = "WFI and RAM Self Refresh",
|
||||||
|
},
|
||||||
|
},
|
||||||
|
.safe_state_index = 0,
|
||||||
|
.state_count = ZYNQ_MAX_STATES,
|
||||||
|
};
|
||||||
|
|
||||||
|
/* Initialize CPU idle by registering the idle states */
|
||||||
|
static int __init zynq_cpuidle_init(void)
|
||||||
|
{
|
||||||
|
if (!of_machine_is_compatible("xlnx,zynq-7000"))
|
||||||
|
return -ENODEV;
|
||||||
|
|
||||||
|
pr_info("Xilinx Zynq CpuIdle Driver started\n");
|
||||||
|
|
||||||
|
return cpuidle_register(&zynq_idle_driver, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
device_initcall(zynq_cpuidle_init);
|
|
@ -466,7 +466,7 @@ void cpuidle_unregister(struct cpuidle_driver *drv)
|
||||||
int cpu;
|
int cpu;
|
||||||
struct cpuidle_device *device;
|
struct cpuidle_device *device;
|
||||||
|
|
||||||
for_each_possible_cpu(cpu) {
|
for_each_cpu(cpu, drv->cpumask) {
|
||||||
device = &per_cpu(cpuidle_dev, cpu);
|
device = &per_cpu(cpuidle_dev, cpu);
|
||||||
cpuidle_unregister_device(device);
|
cpuidle_unregister_device(device);
|
||||||
}
|
}
|
||||||
|
@ -498,7 +498,7 @@ int cpuidle_register(struct cpuidle_driver *drv,
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
for_each_possible_cpu(cpu) {
|
for_each_cpu(cpu, drv->cpumask) {
|
||||||
device = &per_cpu(cpuidle_dev, cpu);
|
device = &per_cpu(cpuidle_dev, cpu);
|
||||||
device->cpu = cpu;
|
device->cpu = cpu;
|
||||||
|
|
||||||
|
|
|
@ -18,182 +18,249 @@
|
||||||
|
|
||||||
DEFINE_SPINLOCK(cpuidle_driver_lock);
|
DEFINE_SPINLOCK(cpuidle_driver_lock);
|
||||||
|
|
||||||
static void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu);
|
|
||||||
static struct cpuidle_driver * __cpuidle_get_cpu_driver(int cpu);
|
|
||||||
|
|
||||||
static void cpuidle_setup_broadcast_timer(void *arg)
|
|
||||||
{
|
|
||||||
int cpu = smp_processor_id();
|
|
||||||
clockevents_notify((long)(arg), &cpu);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __cpuidle_driver_init(struct cpuidle_driver *drv, int cpu)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
drv->refcnt = 0;
|
|
||||||
|
|
||||||
for (i = drv->state_count - 1; i >= 0 ; i--) {
|
|
||||||
|
|
||||||
if (!(drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
drv->bctimer = 1;
|
|
||||||
on_each_cpu_mask(get_cpu_mask(cpu), cpuidle_setup_broadcast_timer,
|
|
||||||
(void *)CLOCK_EVT_NOTIFY_BROADCAST_ON, 1);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static int __cpuidle_register_driver(struct cpuidle_driver *drv, int cpu)
|
|
||||||
{
|
|
||||||
if (!drv || !drv->state_count)
|
|
||||||
return -EINVAL;
|
|
||||||
|
|
||||||
if (cpuidle_disabled())
|
|
||||||
return -ENODEV;
|
|
||||||
|
|
||||||
if (__cpuidle_get_cpu_driver(cpu))
|
|
||||||
return -EBUSY;
|
|
||||||
|
|
||||||
__cpuidle_driver_init(drv, cpu);
|
|
||||||
|
|
||||||
__cpuidle_set_cpu_driver(drv, cpu);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __cpuidle_unregister_driver(struct cpuidle_driver *drv, int cpu)
|
|
||||||
{
|
|
||||||
if (drv != __cpuidle_get_cpu_driver(cpu))
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (!WARN_ON(drv->refcnt > 0))
|
|
||||||
__cpuidle_set_cpu_driver(NULL, cpu);
|
|
||||||
|
|
||||||
if (drv->bctimer) {
|
|
||||||
drv->bctimer = 0;
|
|
||||||
on_each_cpu_mask(get_cpu_mask(cpu), cpuidle_setup_broadcast_timer,
|
|
||||||
(void *)CLOCK_EVT_NOTIFY_BROADCAST_OFF, 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
|
#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
|
||||||
|
|
||||||
static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);
|
static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);
|
||||||
|
|
||||||
static void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu)
|
/**
|
||||||
{
|
* __cpuidle_get_cpu_driver - return the cpuidle driver tied to a CPU.
|
||||||
per_cpu(cpuidle_drivers, cpu) = drv;
|
* @cpu: the CPU handled by the driver
|
||||||
}
|
*
|
||||||
|
* Returns a pointer to struct cpuidle_driver or NULL if no driver has been
|
||||||
|
* registered for @cpu.
|
||||||
|
*/
|
||||||
static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
|
static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
|
||||||
{
|
{
|
||||||
return per_cpu(cpuidle_drivers, cpu);
|
return per_cpu(cpuidle_drivers, cpu);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void __cpuidle_unregister_all_cpu_driver(struct cpuidle_driver *drv)
|
/**
|
||||||
|
* __cpuidle_unset_driver - unset per CPU driver variables.
|
||||||
|
* @drv: a valid pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* For each CPU in the driver's CPU mask, unset the registered driver per CPU
|
||||||
|
* variable. If @drv is different from the registered driver, the corresponding
|
||||||
|
* variable is not cleared.
|
||||||
|
*/
|
||||||
|
static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
|
||||||
{
|
{
|
||||||
int cpu;
|
int cpu;
|
||||||
for_each_present_cpu(cpu)
|
|
||||||
__cpuidle_unregister_driver(drv, cpu);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int __cpuidle_register_all_cpu_driver(struct cpuidle_driver *drv)
|
for_each_cpu(cpu, drv->cpumask) {
|
||||||
{
|
|
||||||
int ret = 0;
|
|
||||||
int i, cpu;
|
|
||||||
|
|
||||||
for_each_present_cpu(cpu) {
|
if (drv != __cpuidle_get_cpu_driver(cpu))
|
||||||
ret = __cpuidle_register_driver(drv, cpu);
|
continue;
|
||||||
if (ret)
|
|
||||||
break;
|
per_cpu(cpuidle_drivers, cpu) = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ret)
|
|
||||||
for_each_present_cpu(i) {
|
|
||||||
if (i == cpu)
|
|
||||||
break;
|
|
||||||
__cpuidle_unregister_driver(drv, i);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int cpuidle_register_cpu_driver(struct cpuidle_driver *drv, int cpu)
|
|
||||||
{
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
|
||||||
ret = __cpuidle_register_driver(drv, cpu);
|
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
void cpuidle_unregister_cpu_driver(struct cpuidle_driver *drv, int cpu)
|
|
||||||
{
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
|
||||||
__cpuidle_unregister_driver(drv, cpu);
|
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* cpuidle_register_driver - registers a driver
|
* __cpuidle_set_driver - set per CPU driver variables the the given driver.
|
||||||
* @drv: the driver
|
* @drv: a valid pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* For each CPU in the driver's cpumask, unset the registered driver per CPU
|
||||||
|
* to @drv.
|
||||||
|
*
|
||||||
|
* Returns 0 on success, -EBUSY if the CPUs have driver(s) already.
|
||||||
*/
|
*/
|
||||||
int cpuidle_register_driver(struct cpuidle_driver *drv)
|
static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
|
||||||
{
|
{
|
||||||
int ret;
|
int cpu;
|
||||||
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
for_each_cpu(cpu, drv->cpumask) {
|
||||||
ret = __cpuidle_register_all_cpu_driver(drv);
|
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
|
||||||
|
|
||||||
return ret;
|
if (__cpuidle_get_cpu_driver(cpu)) {
|
||||||
|
__cpuidle_unset_driver(drv);
|
||||||
|
return -EBUSY;
|
||||||
|
}
|
||||||
|
|
||||||
|
per_cpu(cpuidle_drivers, cpu) = drv;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(cpuidle_register_driver);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* cpuidle_unregister_driver - unregisters a driver
|
|
||||||
* @drv: the driver
|
|
||||||
*/
|
|
||||||
void cpuidle_unregister_driver(struct cpuidle_driver *drv)
|
|
||||||
{
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
|
||||||
__cpuidle_unregister_all_cpu_driver(drv);
|
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
|
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
static struct cpuidle_driver *cpuidle_curr_driver;
|
static struct cpuidle_driver *cpuidle_curr_driver;
|
||||||
|
|
||||||
static inline void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu)
|
/**
|
||||||
{
|
* __cpuidle_get_cpu_driver - return the global cpuidle driver pointer.
|
||||||
cpuidle_curr_driver = drv;
|
* @cpu: ignored without the multiple driver support
|
||||||
}
|
*
|
||||||
|
* Return a pointer to a struct cpuidle_driver object or NULL if no driver was
|
||||||
|
* previously registered.
|
||||||
|
*/
|
||||||
static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
|
static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
|
||||||
{
|
{
|
||||||
return cpuidle_curr_driver;
|
return cpuidle_curr_driver;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* __cpuidle_set_driver - assign the global cpuidle driver variable.
|
||||||
|
* @drv: pointer to a struct cpuidle_driver object
|
||||||
|
*
|
||||||
|
* Returns 0 on success, -EBUSY if the driver is already registered.
|
||||||
|
*/
|
||||||
|
static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
|
||||||
|
{
|
||||||
|
if (cpuidle_curr_driver)
|
||||||
|
return -EBUSY;
|
||||||
|
|
||||||
|
cpuidle_curr_driver = drv;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* __cpuidle_unset_driver - unset the global cpuidle driver variable.
|
||||||
|
* @drv: a pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Reset the global cpuidle variable to NULL. If @drv does not match the
|
||||||
|
* registered driver, do nothing.
|
||||||
|
*/
|
||||||
|
static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
|
||||||
|
{
|
||||||
|
if (drv == cpuidle_curr_driver)
|
||||||
|
cpuidle_curr_driver = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* cpuidle_setup_broadcast_timer - enable/disable the broadcast timer
|
||||||
|
* @arg: a void pointer used to match the SMP cross call API
|
||||||
|
*
|
||||||
|
* @arg is used as a value of type 'long' with on of the two values:
|
||||||
|
* - CLOCK_EVT_NOTIFY_BROADCAST_ON
|
||||||
|
* - CLOCK_EVT_NOTIFY_BROADCAST_OFF
|
||||||
|
*
|
||||||
|
* Set the broadcast timer notification for the current CPU. This function
|
||||||
|
* is executed per CPU by an SMP cross call. It not supposed to be called
|
||||||
|
* directly.
|
||||||
|
*/
|
||||||
|
static void cpuidle_setup_broadcast_timer(void *arg)
|
||||||
|
{
|
||||||
|
int cpu = smp_processor_id();
|
||||||
|
clockevents_notify((long)(arg), &cpu);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* __cpuidle_driver_init - initialize the driver's internal data
|
||||||
|
* @drv: a valid pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Returns 0 on success, a negative error code otherwise.
|
||||||
|
*/
|
||||||
|
static int __cpuidle_driver_init(struct cpuidle_driver *drv)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
drv->refcnt = 0;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Use all possible CPUs as the default, because if the kernel boots
|
||||||
|
* with some CPUs offline and then we online one of them, the CPU
|
||||||
|
* notifier has to know which driver to assign.
|
||||||
|
*/
|
||||||
|
if (!drv->cpumask)
|
||||||
|
drv->cpumask = (struct cpumask *)cpu_possible_mask;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Look for the timer stop flag in the different states, so that we know
|
||||||
|
* if the broadcast timer has to be set up. The loop is in the reverse
|
||||||
|
* order, because usually on of the the deeper states has this flag set.
|
||||||
|
*/
|
||||||
|
for (i = drv->state_count - 1; i >= 0 ; i--) {
|
||||||
|
|
||||||
|
if (!(drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
drv->bctimer = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* __cpuidle_register_driver: register the driver
|
||||||
|
* @drv: a valid pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Do some sanity checks, initialize the driver, assign the driver to the
|
||||||
|
* global cpuidle driver variable(s) and set up the broadcast timer if the
|
||||||
|
* cpuidle driver has some states that shut down the local timer.
|
||||||
|
*
|
||||||
|
* Returns 0 on success, a negative error code otherwise:
|
||||||
|
* * -EINVAL if the driver pointer is NULL or no idle states are available
|
||||||
|
* * -ENODEV if the cpuidle framework is disabled
|
||||||
|
* * -EBUSY if the driver is already assigned to the global variable(s)
|
||||||
|
*/
|
||||||
|
static int __cpuidle_register_driver(struct cpuidle_driver *drv)
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (!drv || !drv->state_count)
|
||||||
|
return -EINVAL;
|
||||||
|
|
||||||
|
if (cpuidle_disabled())
|
||||||
|
return -ENODEV;
|
||||||
|
|
||||||
|
ret = __cpuidle_driver_init(drv);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
ret = __cpuidle_set_driver(drv);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
if (drv->bctimer)
|
||||||
|
on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
|
||||||
|
(void *)CLOCK_EVT_NOTIFY_BROADCAST_ON, 1);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* __cpuidle_unregister_driver - unregister the driver
|
||||||
|
* @drv: a valid pointer to a struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Check if the driver is no longer in use, reset the global cpuidle driver
|
||||||
|
* variable(s) and disable the timer broadcast notification mechanism if it was
|
||||||
|
* in use.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void __cpuidle_unregister_driver(struct cpuidle_driver *drv)
|
||||||
|
{
|
||||||
|
if (WARN_ON(drv->refcnt > 0))
|
||||||
|
return;
|
||||||
|
|
||||||
|
if (drv->bctimer) {
|
||||||
|
drv->bctimer = 0;
|
||||||
|
on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
|
||||||
|
(void *)CLOCK_EVT_NOTIFY_BROADCAST_OFF, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
__cpuidle_unset_driver(drv);
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* cpuidle_register_driver - registers a driver
|
* cpuidle_register_driver - registers a driver
|
||||||
* @drv: the driver
|
* @drv: a pointer to a valid struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Register the driver under a lock to prevent concurrent attempts to
|
||||||
|
* [un]register the driver from occuring at the same time.
|
||||||
|
*
|
||||||
|
* Returns 0 on success, a negative error code (returned by
|
||||||
|
* __cpuidle_register_driver()) otherwise.
|
||||||
*/
|
*/
|
||||||
int cpuidle_register_driver(struct cpuidle_driver *drv)
|
int cpuidle_register_driver(struct cpuidle_driver *drv)
|
||||||
{
|
{
|
||||||
int ret, cpu;
|
int ret;
|
||||||
|
|
||||||
cpu = get_cpu();
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
spin_lock(&cpuidle_driver_lock);
|
||||||
ret = __cpuidle_register_driver(drv, cpu);
|
ret = __cpuidle_register_driver(drv);
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
spin_unlock(&cpuidle_driver_lock);
|
||||||
put_cpu();
|
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
@ -201,23 +268,24 @@ EXPORT_SYMBOL_GPL(cpuidle_register_driver);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* cpuidle_unregister_driver - unregisters a driver
|
* cpuidle_unregister_driver - unregisters a driver
|
||||||
* @drv: the driver
|
* @drv: a pointer to a valid struct cpuidle_driver
|
||||||
|
*
|
||||||
|
* Unregisters the cpuidle driver under a lock to prevent concurrent attempts
|
||||||
|
* to [un]register the driver from occuring at the same time. @drv has to
|
||||||
|
* match the currently registered driver.
|
||||||
*/
|
*/
|
||||||
void cpuidle_unregister_driver(struct cpuidle_driver *drv)
|
void cpuidle_unregister_driver(struct cpuidle_driver *drv)
|
||||||
{
|
{
|
||||||
int cpu;
|
|
||||||
|
|
||||||
cpu = get_cpu();
|
|
||||||
spin_lock(&cpuidle_driver_lock);
|
spin_lock(&cpuidle_driver_lock);
|
||||||
__cpuidle_unregister_driver(drv, cpu);
|
__cpuidle_unregister_driver(drv);
|
||||||
spin_unlock(&cpuidle_driver_lock);
|
spin_unlock(&cpuidle_driver_lock);
|
||||||
put_cpu();
|
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
|
EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
|
||||||
#endif
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* cpuidle_get_driver - return the current driver
|
* cpuidle_get_driver - return the driver tied to the current CPU.
|
||||||
|
*
|
||||||
|
* Returns a struct cpuidle_driver pointer, or NULL if no driver is registered.
|
||||||
*/
|
*/
|
||||||
struct cpuidle_driver *cpuidle_get_driver(void)
|
struct cpuidle_driver *cpuidle_get_driver(void)
|
||||||
{
|
{
|
||||||
|
@ -233,7 +301,11 @@ struct cpuidle_driver *cpuidle_get_driver(void)
|
||||||
EXPORT_SYMBOL_GPL(cpuidle_get_driver);
|
EXPORT_SYMBOL_GPL(cpuidle_get_driver);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* cpuidle_get_cpu_driver - return the driver tied with a cpu
|
* cpuidle_get_cpu_driver - return the driver registered for a CPU.
|
||||||
|
* @dev: a valid pointer to a struct cpuidle_device
|
||||||
|
*
|
||||||
|
* Returns a struct cpuidle_driver pointer, or NULL if no driver is registered
|
||||||
|
* for the CPU associated with @dev.
|
||||||
*/
|
*/
|
||||||
struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
|
struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
|
||||||
{
|
{
|
||||||
|
@ -244,6 +316,14 @@ struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver);
|
EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* cpuidle_driver_ref - get a reference to the driver.
|
||||||
|
*
|
||||||
|
* Increment the reference counter of the cpuidle driver associated with
|
||||||
|
* the current CPU.
|
||||||
|
*
|
||||||
|
* Returns a pointer to the driver, or NULL if the current CPU has no driver.
|
||||||
|
*/
|
||||||
struct cpuidle_driver *cpuidle_driver_ref(void)
|
struct cpuidle_driver *cpuidle_driver_ref(void)
|
||||||
{
|
{
|
||||||
struct cpuidle_driver *drv;
|
struct cpuidle_driver *drv;
|
||||||
|
@ -257,6 +337,12 @@ struct cpuidle_driver *cpuidle_driver_ref(void)
|
||||||
return drv;
|
return drv;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* cpuidle_driver_unref - puts down the refcount for the driver
|
||||||
|
*
|
||||||
|
* Decrement the reference counter of the cpuidle driver associated with
|
||||||
|
* the current CPU.
|
||||||
|
*/
|
||||||
void cpuidle_driver_unref(void)
|
void cpuidle_driver_unref(void)
|
||||||
{
|
{
|
||||||
struct cpuidle_driver *drv = cpuidle_get_driver();
|
struct cpuidle_driver *drv = cpuidle_get_driver();
|
||||||
|
|
|
@ -111,6 +111,9 @@ struct cpuidle_driver {
|
||||||
struct cpuidle_state states[CPUIDLE_STATE_MAX];
|
struct cpuidle_state states[CPUIDLE_STATE_MAX];
|
||||||
int state_count;
|
int state_count;
|
||||||
int safe_state_index;
|
int safe_state_index;
|
||||||
|
|
||||||
|
/* the driver handles the cpus in cpumask */
|
||||||
|
struct cpumask *cpumask;
|
||||||
};
|
};
|
||||||
|
|
||||||
#ifdef CONFIG_CPU_IDLE
|
#ifdef CONFIG_CPU_IDLE
|
||||||
|
@ -135,9 +138,6 @@ extern void cpuidle_disable_device(struct cpuidle_device *dev);
|
||||||
extern int cpuidle_play_dead(void);
|
extern int cpuidle_play_dead(void);
|
||||||
|
|
||||||
extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
|
extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
|
||||||
extern int cpuidle_register_cpu_driver(struct cpuidle_driver *drv, int cpu);
|
|
||||||
extern void cpuidle_unregister_cpu_driver(struct cpuidle_driver *drv, int cpu);
|
|
||||||
|
|
||||||
#else
|
#else
|
||||||
static inline void disable_cpuidle(void) { }
|
static inline void disable_cpuidle(void) { }
|
||||||
static inline int cpuidle_idle_call(void) { return -ENODEV; }
|
static inline int cpuidle_idle_call(void) { return -ENODEV; }
|
||||||
|
|
Loading…
Reference in New Issue