1 /* 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 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #include <linux/kernel.h> 14 #include <linux/slab.h> 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> 21 #include <linux/uaccess.h> 22 #include <asm/pal.h> 23 24 #include <linux/acpi.h> 25 #include <acpi/processor.h> 26 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; 34 unsigned int resume; 35 }; 36 37 struct cpufreq_acpi_req { 38 unsigned int cpu; 39 unsigned int state; 40 }; 41 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 53 pr_debug("processor_set_pstate\n"); 54 55 retval = ia64_pal_set_pstate((u64)value); 56 57 if (retval) { 58 pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n", 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 73 pr_debug("processor_get_pstate\n"); 74 75 retval = ia64_pal_get_pstate(&pstate_index, 76 PAL_GET_PSTATE_TYPE_INSTANT); 77 *value = (u32) pstate_index; 78 79 if (retval) 80 pr_debug("Failed to get current freq with " 81 "error 0x%lx, idx 0x%x\n", retval, *value); 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, 91 unsigned value) 92 { 93 unsigned long i; 94 95 pr_debug("extract_clock\n"); 96 97 for (i = 0; i < data->acpi_data.state_count; i++) { 98 if (value == data->acpi_data.states[i].status) 99 return data->acpi_data.states[i].core_frequency; 100 } 101 return data->acpi_data.states[i-1].core_frequency; 102 } 103 104 105 static long 106 processor_get_freq ( 107 void *arg) 108 { 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; 114 115 pr_debug("processor_get_freq\n"); 116 if (smp_processor_id() != cpu) 117 return -EAGAIN; 118 119 /* processor_get_pstate gets the instantaneous frequency */ 120 ret = processor_get_pstate(&value); 121 if (ret) { 122 pr_warn("get performance failed with error %d\n", ret); 123 return ret; 124 } 125 return 1000 * extract_clock(data, value); 126 } 127 128 129 static long 130 processor_set_freq ( 131 void *arg) 132 { 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; 138 139 pr_debug("processor_set_freq\n"); 140 if (smp_processor_id() != cpu) 141 return -EAGAIN; 142 143 if (state == data->acpi_data.state) { 144 if (unlikely(data->resume)) { 145 pr_debug("Called after resume, resetting to P%d\n", state); 146 data->resume = 0; 147 } else { 148 pr_debug("Already at target state (P%d)\n", state); 149 return 0; 150 } 151 } 152 153 pr_debug("Transitioning from P%d to P%d\n", 154 data->acpi_data.state, state); 155 156 /* 157 * First we write the target state's 'control' value to the 158 * control_register. 159 */ 160 value = (u32) data->acpi_data.states[state].control; 161 162 pr_debug("Transitioning to state: 0x%08x\n", value); 163 164 ret = processor_set_pstate(value); 165 if (ret) { 166 pr_warn("Transition failed with error %d\n", ret); 167 return -ENODEV; 168 } 169 170 data->acpi_data.state = state; 171 return 0; 172 } 173 174 175 static unsigned int 176 acpi_cpufreq_get ( 177 unsigned int cpu) 178 { 179 struct cpufreq_acpi_req req; 180 long ret; 181 182 req.cpu = cpu; 183 ret = work_on_cpu(cpu, processor_get_freq, &req); 184 185 return ret > 0 ? (unsigned int) ret : 0; 186 } 187 188 189 static int 190 acpi_cpufreq_target ( 191 struct cpufreq_policy *policy, 192 unsigned int index) 193 { 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); 200 } 201 202 static int 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; 210 struct cpufreq_frequency_table *freq_table; 211 212 pr_debug("acpi_cpufreq_cpu_init\n"); 213 214 data = kzalloc(sizeof(*data), GFP_KERNEL); 215 if (!data) 216 return (-ENOMEM); 217 218 acpi_io_data[cpu] = data; 219 220 result = acpi_processor_register_performance(&data->acpi_data, cpu); 221 222 if (result) 223 goto err_free; 224 225 /* capability check */ 226 if (data->acpi_data.state_count <= 1) { 227 pr_debug("No P-States\n"); 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)) { 236 pr_debug("Unsupported address space [%d, %d]\n", 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 */ 244 freq_table = kcalloc(data->acpi_data.state_count + 1, 245 sizeof(*freq_table), 246 GFP_KERNEL); 247 if (!freq_table) { 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 } 261 262 /* table init */ 263 for (i = 0; i <= data->acpi_data.state_count; i++) 264 { 265 if (i < data->acpi_data.state_count) { 266 freq_table[i].frequency = 267 data->acpi_data.states[i].core_frequency * 1000; 268 } else { 269 freq_table[i].frequency = CPUFREQ_TABLE_END; 270 } 271 } 272 273 policy->freq_table = freq_table; 274 275 /* notify BIOS that we exist */ 276 acpi_processor_notify_smm(THIS_MODULE); 277 278 pr_info("CPU%u - ACPI performance management activated\n", cpu); 279 280 for (i = 0; i < data->acpi_data.state_count; i++) 281 pr_debug(" %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n", 282 (i == data->acpi_data.state?'*':' '), i, 283 (u32) data->acpi_data.states[i].core_frequency, 284 (u32) data->acpi_data.states[i].power, 285 (u32) data->acpi_data.states[i].transition_latency, 286 (u32) data->acpi_data.states[i].bus_master_latency, 287 (u32) data->acpi_data.states[i].status, 288 (u32) data->acpi_data.states[i].control); 289 290 /* the first call to ->target() should result in us actually 291 * writing something to the appropriate registers. */ 292 data->resume = 1; 293 294 return (result); 295 296 err_unreg: 297 acpi_processor_unregister_performance(cpu); 298 err_free: 299 kfree(data); 300 acpi_io_data[cpu] = NULL; 301 302 return (result); 303 } 304 305 306 static int 307 acpi_cpufreq_cpu_exit ( 308 struct cpufreq_policy *policy) 309 { 310 struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu]; 311 312 pr_debug("acpi_cpufreq_cpu_exit\n"); 313 314 if (data) { 315 acpi_io_data[policy->cpu] = NULL; 316 acpi_processor_unregister_performance(policy->cpu); 317 kfree(policy->freq_table); 318 kfree(data); 319 } 320 321 return (0); 322 } 323 324 325 static struct cpufreq_driver acpi_cpufreq_driver = { 326 .verify = cpufreq_generic_frequency_table_verify, 327 .target_index = acpi_cpufreq_target, 328 .get = acpi_cpufreq_get, 329 .init = acpi_cpufreq_cpu_init, 330 .exit = acpi_cpufreq_cpu_exit, 331 .name = "acpi-cpufreq", 332 .attr = cpufreq_generic_attr, 333 }; 334 335 336 static int __init 337 acpi_cpufreq_init (void) 338 { 339 pr_debug("acpi_cpufreq_init\n"); 340 341 return cpufreq_register_driver(&acpi_cpufreq_driver); 342 } 343 344 345 static void __exit 346 acpi_cpufreq_exit (void) 347 { 348 pr_debug("acpi_cpufreq_exit\n"); 349 350 cpufreq_unregister_driver(&acpi_cpufreq_driver); 351 return; 352 } 353 354 355 late_initcall(acpi_cpufreq_init); 356 module_exit(acpi_cpufreq_exit); 357 358