Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 1 | /* |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 2 | * This file provides the ACPI based P-state support. This |
| 3 | * module works with generic cpufreq infrastructure. Most of |
| 4 | * the code is based on i386 version |
| 5 | * (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c) |
| 6 | * |
| 7 | * Copyright (C) 2005 Intel Corp |
| 8 | * Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> |
| 9 | */ |
| 10 | |
Joe Perches | 1c5864e | 2016-04-05 13:28:25 -0700 | [diff] [blame] | 11 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 12 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 13 | #include <linux/kernel.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 14 | #include <linux/slab.h> |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 15 | #include <linux/module.h> |
| 16 | #include <linux/init.h> |
| 17 | #include <linux/cpufreq.h> |
| 18 | #include <linux/proc_fs.h> |
| 19 | #include <linux/seq_file.h> |
| 20 | #include <asm/io.h> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 21 | #include <linux/uaccess.h> |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 22 | #include <asm/pal.h> |
| 23 | |
| 24 | #include <linux/acpi.h> |
| 25 | #include <acpi/processor.h> |
| 26 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 27 | MODULE_AUTHOR("Venkatesh Pallipadi"); |
| 28 | MODULE_DESCRIPTION("ACPI Processor P-States Driver"); |
| 29 | MODULE_LICENSE("GPL"); |
| 30 | |
| 31 | |
| 32 | struct cpufreq_acpi_io { |
| 33 | struct acpi_processor_performance acpi_data; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 34 | unsigned int resume; |
| 35 | }; |
| 36 | |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 37 | struct cpufreq_acpi_req { |
| 38 | unsigned int cpu; |
| 39 | unsigned int state; |
| 40 | }; |
| 41 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 42 | static struct cpufreq_acpi_io *acpi_io_data[NR_CPUS]; |
| 43 | |
| 44 | static struct cpufreq_driver acpi_cpufreq_driver; |
| 45 | |
| 46 | |
| 47 | static int |
| 48 | processor_set_pstate ( |
| 49 | u32 value) |
| 50 | { |
| 51 | s64 retval; |
| 52 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 53 | pr_debug("processor_set_pstate\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 54 | |
| 55 | retval = ia64_pal_set_pstate((u64)value); |
| 56 | |
| 57 | if (retval) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 58 | pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n", |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 59 | value, retval); |
| 60 | return -ENODEV; |
| 61 | } |
| 62 | return (int)retval; |
| 63 | } |
| 64 | |
| 65 | |
| 66 | static int |
| 67 | processor_get_pstate ( |
| 68 | u32 *value) |
| 69 | { |
| 70 | u64 pstate_index = 0; |
| 71 | s64 retval; |
| 72 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 73 | pr_debug("processor_get_pstate\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 74 | |
Venkatesh Pallipadi | 17e77b1 | 2006-12-01 15:28:14 -0800 | [diff] [blame] | 75 | retval = ia64_pal_get_pstate(&pstate_index, |
| 76 | PAL_GET_PSTATE_TYPE_INSTANT); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 77 | *value = (u32) pstate_index; |
| 78 | |
| 79 | if (retval) |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 80 | pr_debug("Failed to get current freq with " |
Denis V. Lunev | 60192db | 2008-07-17 11:11:17 -0700 | [diff] [blame] | 81 | "error 0x%lx, idx 0x%x\n", retval, *value); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 82 | |
| 83 | return (int)retval; |
| 84 | } |
| 85 | |
| 86 | |
| 87 | /* To be used only after data->acpi_data is initialized */ |
| 88 | static unsigned |
| 89 | extract_clock ( |
| 90 | struct cpufreq_acpi_io *data, |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 91 | unsigned value) |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 92 | { |
| 93 | unsigned long i; |
| 94 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 95 | pr_debug("extract_clock\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 96 | |
| 97 | for (i = 0; i < data->acpi_data.state_count; i++) { |
Venkatesh Pallipadi | 17e77b1 | 2006-12-01 15:28:14 -0800 | [diff] [blame] | 98 | if (value == data->acpi_data.states[i].status) |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 99 | return data->acpi_data.states[i].core_frequency; |
| 100 | } |
| 101 | return data->acpi_data.states[i-1].core_frequency; |
| 102 | } |
| 103 | |
| 104 | |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 105 | static long |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 106 | processor_get_freq ( |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 107 | void *arg) |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 108 | { |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 109 | struct cpufreq_acpi_req *req = arg; |
| 110 | unsigned int cpu = req->cpu; |
| 111 | struct cpufreq_acpi_io *data = acpi_io_data[cpu]; |
| 112 | u32 value; |
| 113 | int ret; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 114 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 115 | pr_debug("processor_get_freq\n"); |
Alex Williamson | 182fdd2 | 2007-08-13 15:49:46 -0600 | [diff] [blame] | 116 | if (smp_processor_id() != cpu) |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 117 | return -EAGAIN; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 118 | |
Venkatesh Pallipadi | 17e77b1 | 2006-12-01 15:28:14 -0800 | [diff] [blame] | 119 | /* processor_get_pstate gets the instantaneous frequency */ |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 120 | ret = processor_get_pstate(&value); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 121 | if (ret) { |
Joe Perches | b49c22a | 2016-04-05 13:28:24 -0700 | [diff] [blame] | 122 | pr_warn("get performance failed with error %d\n", ret); |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 123 | return ret; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 124 | } |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 125 | return 1000 * extract_clock(data, value); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 129 | static long |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 130 | processor_set_freq ( |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 131 | void *arg) |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 132 | { |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 133 | struct cpufreq_acpi_req *req = arg; |
| 134 | unsigned int cpu = req->cpu; |
| 135 | struct cpufreq_acpi_io *data = acpi_io_data[cpu]; |
| 136 | int ret, state = req->state; |
| 137 | u32 value; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 138 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 139 | pr_debug("processor_set_freq\n"); |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 140 | if (smp_processor_id() != cpu) |
| 141 | return -EAGAIN; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 142 | |
| 143 | if (state == data->acpi_data.state) { |
| 144 | if (unlikely(data->resume)) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 145 | pr_debug("Called after resume, resetting to P%d\n", state); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 146 | data->resume = 0; |
| 147 | } else { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 148 | pr_debug("Already at target state (P%d)\n", state); |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 149 | return 0; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 150 | } |
| 151 | } |
| 152 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 153 | pr_debug("Transitioning from P%d to P%d\n", |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 154 | data->acpi_data.state, state); |
| 155 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 156 | /* |
| 157 | * First we write the target state's 'control' value to the |
| 158 | * control_register. |
| 159 | */ |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 160 | value = (u32) data->acpi_data.states[state].control; |
| 161 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 162 | pr_debug("Transitioning to state: 0x%08x\n", value); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 163 | |
| 164 | ret = processor_set_pstate(value); |
| 165 | if (ret) { |
Joe Perches | b49c22a | 2016-04-05 13:28:24 -0700 | [diff] [blame] | 166 | pr_warn("Transition failed with error %d\n", ret); |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 167 | return -ENODEV; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 168 | } |
| 169 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 170 | data->acpi_data.state = state; |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 171 | return 0; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | |
| 175 | static unsigned int |
| 176 | acpi_cpufreq_get ( |
| 177 | unsigned int cpu) |
| 178 | { |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 179 | struct cpufreq_acpi_req req; |
| 180 | long ret; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 181 | |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 182 | req.cpu = cpu; |
| 183 | ret = work_on_cpu(cpu, processor_get_freq, &req); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 184 | |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 185 | return ret > 0 ? (unsigned int) ret : 0; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | |
| 189 | static int |
| 190 | acpi_cpufreq_target ( |
| 191 | struct cpufreq_policy *policy, |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 192 | unsigned int index) |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 193 | { |
Thomas Gleixner | 38f05ed | 2017-04-12 22:55:03 +0200 | [diff] [blame] | 194 | struct cpufreq_acpi_req req; |
| 195 | |
| 196 | req.cpu = policy->cpu; |
| 197 | req.state = index; |
| 198 | |
| 199 | return work_on_cpu(req.cpu, processor_set_freq, &req); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 200 | } |
| 201 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 202 | static int |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 203 | acpi_cpufreq_cpu_init ( |
| 204 | struct cpufreq_policy *policy) |
| 205 | { |
| 206 | unsigned int i; |
| 207 | unsigned int cpu = policy->cpu; |
| 208 | struct cpufreq_acpi_io *data; |
| 209 | unsigned int result = 0; |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 210 | struct cpufreq_frequency_table *freq_table; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 211 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 212 | pr_debug("acpi_cpufreq_cpu_init\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 213 | |
Viresh Kumar | d5b73cd | 2013-08-06 22:53:06 +0530 | [diff] [blame] | 214 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 215 | if (!data) |
| 216 | return (-ENOMEM); |
| 217 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 218 | acpi_io_data[cpu] = data; |
| 219 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 220 | result = acpi_processor_register_performance(&data->acpi_data, cpu); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 221 | |
| 222 | if (result) |
| 223 | goto err_free; |
| 224 | |
| 225 | /* capability check */ |
| 226 | if (data->acpi_data.state_count <= 1) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 227 | pr_debug("No P-States\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 228 | result = -ENODEV; |
| 229 | goto err_unreg; |
| 230 | } |
| 231 | |
| 232 | if ((data->acpi_data.control_register.space_id != |
| 233 | ACPI_ADR_SPACE_FIXED_HARDWARE) || |
| 234 | (data->acpi_data.status_register.space_id != |
| 235 | ACPI_ADR_SPACE_FIXED_HARDWARE)) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 236 | pr_debug("Unsupported address space [%d, %d]\n", |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 237 | (u32) (data->acpi_data.control_register.space_id), |
| 238 | (u32) (data->acpi_data.status_register.space_id)); |
| 239 | result = -ENODEV; |
| 240 | goto err_unreg; |
| 241 | } |
| 242 | |
| 243 | /* alloc freq_table */ |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 244 | freq_table = kzalloc(sizeof(*freq_table) * |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 245 | (data->acpi_data.state_count + 1), |
| 246 | GFP_KERNEL); |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 247 | if (!freq_table) { |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 248 | result = -ENOMEM; |
| 249 | goto err_unreg; |
| 250 | } |
| 251 | |
| 252 | /* detect transition latency */ |
| 253 | policy->cpuinfo.transition_latency = 0; |
| 254 | for (i=0; i<data->acpi_data.state_count; i++) { |
| 255 | if ((data->acpi_data.states[i].transition_latency * 1000) > |
| 256 | policy->cpuinfo.transition_latency) { |
| 257 | policy->cpuinfo.transition_latency = |
| 258 | data->acpi_data.states[i].transition_latency * 1000; |
| 259 | } |
| 260 | } |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 261 | |
| 262 | /* table init */ |
| 263 | for (i = 0; i <= data->acpi_data.state_count; i++) |
| 264 | { |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 265 | if (i < data->acpi_data.state_count) { |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 266 | freq_table[i].frequency = |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 267 | data->acpi_data.states[i].core_frequency * 1000; |
| 268 | } else { |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 269 | freq_table[i].frequency = CPUFREQ_TABLE_END; |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 270 | } |
| 271 | } |
| 272 | |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 273 | result = cpufreq_table_validate_and_show(policy, freq_table); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 274 | if (result) { |
| 275 | goto err_freqfree; |
| 276 | } |
| 277 | |
| 278 | /* notify BIOS that we exist */ |
| 279 | acpi_processor_notify_smm(THIS_MODULE); |
| 280 | |
Joe Perches | 1c5864e | 2016-04-05 13:28:25 -0700 | [diff] [blame] | 281 | pr_info("CPU%u - ACPI performance management activated\n", cpu); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 282 | |
| 283 | for (i = 0; i < data->acpi_data.state_count; i++) |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 284 | pr_debug(" %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n", |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 285 | (i == data->acpi_data.state?'*':' '), i, |
| 286 | (u32) data->acpi_data.states[i].core_frequency, |
| 287 | (u32) data->acpi_data.states[i].power, |
| 288 | (u32) data->acpi_data.states[i].transition_latency, |
| 289 | (u32) data->acpi_data.states[i].bus_master_latency, |
| 290 | (u32) data->acpi_data.states[i].status, |
| 291 | (u32) data->acpi_data.states[i].control); |
| 292 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 293 | /* the first call to ->target() should result in us actually |
| 294 | * writing something to the appropriate registers. */ |
| 295 | data->resume = 1; |
| 296 | |
| 297 | return (result); |
| 298 | |
| 299 | err_freqfree: |
Pan Xinhui | 946c14f | 2015-07-20 14:22:46 +0800 | [diff] [blame] | 300 | kfree(freq_table); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 301 | err_unreg: |
Rafael J. Wysocki | b2f8dc4 | 2015-07-22 22:11:16 +0200 | [diff] [blame] | 302 | acpi_processor_unregister_performance(cpu); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 303 | err_free: |
| 304 | kfree(data); |
| 305 | acpi_io_data[cpu] = NULL; |
| 306 | |
| 307 | return (result); |
| 308 | } |
| 309 | |
| 310 | |
| 311 | static int |
| 312 | acpi_cpufreq_cpu_exit ( |
| 313 | struct cpufreq_policy *policy) |
| 314 | { |
| 315 | struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu]; |
| 316 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 317 | pr_debug("acpi_cpufreq_cpu_exit\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 318 | |
| 319 | if (data) { |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 320 | acpi_io_data[policy->cpu] = NULL; |
Rafael J. Wysocki | b2f8dc4 | 2015-07-22 22:11:16 +0200 | [diff] [blame] | 321 | acpi_processor_unregister_performance(policy->cpu); |
Pan Xinhui | 555f3fe9 | 2015-07-20 14:24:36 +0800 | [diff] [blame] | 322 | kfree(policy->freq_table); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 323 | kfree(data); |
| 324 | } |
| 325 | |
| 326 | return (0); |
| 327 | } |
| 328 | |
| 329 | |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 330 | static struct cpufreq_driver acpi_cpufreq_driver = { |
Viresh Kumar | 59b2413 | 2013-10-03 20:28:07 +0530 | [diff] [blame] | 331 | .verify = cpufreq_generic_frequency_table_verify, |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 332 | .target_index = acpi_cpufreq_target, |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 333 | .get = acpi_cpufreq_get, |
| 334 | .init = acpi_cpufreq_cpu_init, |
| 335 | .exit = acpi_cpufreq_cpu_exit, |
| 336 | .name = "acpi-cpufreq", |
Viresh Kumar | 59b2413 | 2013-10-03 20:28:07 +0530 | [diff] [blame] | 337 | .attr = cpufreq_generic_attr, |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 338 | }; |
| 339 | |
| 340 | |
| 341 | static int __init |
| 342 | acpi_cpufreq_init (void) |
| 343 | { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 344 | pr_debug("acpi_cpufreq_init\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 345 | |
| 346 | return cpufreq_register_driver(&acpi_cpufreq_driver); |
| 347 | } |
| 348 | |
| 349 | |
| 350 | static void __exit |
| 351 | acpi_cpufreq_exit (void) |
| 352 | { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 353 | pr_debug("acpi_cpufreq_exit\n"); |
Venkatesh Pallipadi | 4db8699 | 2005-07-29 16:15:00 -0700 | [diff] [blame] | 354 | |
| 355 | cpufreq_unregister_driver(&acpi_cpufreq_driver); |
| 356 | return; |
| 357 | } |
| 358 | |
| 359 | |
| 360 | late_initcall(acpi_cpufreq_init); |
| 361 | module_exit(acpi_cpufreq_exit); |
| 362 | |