mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 05:48:40 +00:00
![Leo Yan](/assets/img/avatar_default.png)
If cpuidle init fails, the code misses to unregister the driver for
current CPU. Furthermore, we also need to rollback to cancel all
previous CPUs registration; but the code retrieves driver handler by
using function cpuidle_get_driver(), this function returns back
current CPU driver handler but not previous CPU's handler, which leads
to the failure handling code cannot unregister previous CPUs driver.
This commit fixes two mentioned issues, it adds error handling path
'goto out_unregister_drv' for current CPU driver unregistration; and
it is to replace cpuidle_get_driver() with cpuidle_get_cpu_driver(),
the later function can retrieve driver handler for previous CPUs
according to the CPU device handler so can unregister the driver
properly.
This patch also adds extra error handling paths 'goto out_kfree_dev'
and 'goto out_kfree_drv' and adjusts the freeing sentences for previous
CPUs; so make the code more readable for freeing 'dev' and 'drv'
structures.
Suggested-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Signed-off-by: Leo Yan <leo.yan@linaro.org>
Fixes: d50a7d8acd
(ARM: cpuidle: Support asymmetric idle definition)
Acked-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
170 lines
4.1 KiB
C
170 lines
4.1 KiB
C
/*
|
|
* ARM/ARM64 generic CPU idle driver.
|
|
*
|
|
* Copyright (C) 2014 ARM Ltd.
|
|
* Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "CPUidle arm: " fmt
|
|
|
|
#include <linux/cpuidle.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/cpu_pm.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/topology.h>
|
|
|
|
#include <asm/cpuidle.h>
|
|
|
|
#include "dt_idle_states.h"
|
|
|
|
/*
|
|
* arm_enter_idle_state - Programs CPU to enter the specified state
|
|
*
|
|
* dev: cpuidle device
|
|
* drv: cpuidle driver
|
|
* idx: state index
|
|
*
|
|
* Called from the CPUidle framework to program the device to the
|
|
* specified target state selected by the governor.
|
|
*/
|
|
static int arm_enter_idle_state(struct cpuidle_device *dev,
|
|
struct cpuidle_driver *drv, int idx)
|
|
{
|
|
/*
|
|
* Pass idle state index to arm_cpuidle_suspend which in turn
|
|
* will call the CPU ops suspend protocol with idle index as a
|
|
* parameter.
|
|
*/
|
|
return CPU_PM_CPU_IDLE_ENTER(arm_cpuidle_suspend, idx);
|
|
}
|
|
|
|
static struct cpuidle_driver arm_idle_driver __initdata = {
|
|
.name = "arm_idle",
|
|
.owner = THIS_MODULE,
|
|
/*
|
|
* State at index 0 is standby wfi and considered standard
|
|
* on all ARM platforms. If in some platforms simple wfi
|
|
* can't be used as "state 0", DT bindings must be implemented
|
|
* to work around this issue and allow installing a special
|
|
* handler for idle state index 0.
|
|
*/
|
|
.states[0] = {
|
|
.enter = arm_enter_idle_state,
|
|
.exit_latency = 1,
|
|
.target_residency = 1,
|
|
.power_usage = UINT_MAX,
|
|
.name = "WFI",
|
|
.desc = "ARM WFI",
|
|
}
|
|
};
|
|
|
|
static const struct of_device_id arm_idle_state_match[] __initconst = {
|
|
{ .compatible = "arm,idle-state",
|
|
.data = arm_enter_idle_state },
|
|
{ },
|
|
};
|
|
|
|
/*
|
|
* arm_idle_init
|
|
*
|
|
* Registers the arm specific cpuidle driver with the cpuidle
|
|
* framework. It relies on core code to parse the idle states
|
|
* and initialize them using driver data structures accordingly.
|
|
*/
|
|
static int __init arm_idle_init(void)
|
|
{
|
|
int cpu, ret;
|
|
struct cpuidle_driver *drv;
|
|
struct cpuidle_device *dev;
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
drv = kmemdup(&arm_idle_driver, sizeof(*drv), GFP_KERNEL);
|
|
if (!drv) {
|
|
ret = -ENOMEM;
|
|
goto out_fail;
|
|
}
|
|
|
|
drv->cpumask = (struct cpumask *)cpumask_of(cpu);
|
|
|
|
/*
|
|
* Initialize idle states data, starting at index 1. This
|
|
* driver is DT only, if no DT idle states are detected (ret
|
|
* == 0) let the driver initialization fail accordingly since
|
|
* there is no reason to initialize the idle driver if only
|
|
* wfi is supported.
|
|
*/
|
|
ret = dt_init_idle_driver(drv, arm_idle_state_match, 1);
|
|
if (ret <= 0) {
|
|
ret = ret ? : -ENODEV;
|
|
goto out_kfree_drv;
|
|
}
|
|
|
|
ret = cpuidle_register_driver(drv);
|
|
if (ret) {
|
|
pr_err("Failed to register cpuidle driver\n");
|
|
goto out_kfree_drv;
|
|
}
|
|
|
|
/*
|
|
* Call arch CPU operations in order to initialize
|
|
* idle states suspend back-end specific data
|
|
*/
|
|
ret = arm_cpuidle_init(cpu);
|
|
|
|
/*
|
|
* Skip the cpuidle device initialization if the reported
|
|
* failure is a HW misconfiguration/breakage (-ENXIO).
|
|
*/
|
|
if (ret == -ENXIO)
|
|
continue;
|
|
|
|
if (ret) {
|
|
pr_err("CPU %d failed to init idle CPU ops\n", cpu);
|
|
goto out_unregister_drv;
|
|
}
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
if (!dev) {
|
|
pr_err("Failed to allocate cpuidle device\n");
|
|
ret = -ENOMEM;
|
|
goto out_unregister_drv;
|
|
}
|
|
dev->cpu = cpu;
|
|
|
|
ret = cpuidle_register_device(dev);
|
|
if (ret) {
|
|
pr_err("Failed to register cpuidle device for CPU %d\n",
|
|
cpu);
|
|
goto out_kfree_dev;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_kfree_dev:
|
|
kfree(dev);
|
|
out_unregister_drv:
|
|
cpuidle_unregister_driver(drv);
|
|
out_kfree_drv:
|
|
kfree(drv);
|
|
out_fail:
|
|
while (--cpu >= 0) {
|
|
dev = per_cpu(cpuidle_devices, cpu);
|
|
drv = cpuidle_get_cpu_driver(dev);
|
|
cpuidle_unregister_device(dev);
|
|
cpuidle_unregister_driver(drv);
|
|
kfree(dev);
|
|
kfree(drv);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
device_initcall(arm_idle_init);
|