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