drivers/cpufreq/ia64-acpi-cpufreq.c

   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 = kzalloc(sizeof(*freq_table) *
 245                                    (data->acpi_data.state_count + 1),
 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         result = cpufreq_table_validate_and_show(policy, freq_table);
 274         if (result) {
 275                 goto err_freqfree;
 276         }
 277
 278         /* notify BIOS that we exist */
 279         acpi_processor_notify_smm(THIS_MODULE);
 280
 281         pr_info("CPU%u - ACPI performance management activated\n", cpu);
 282
 283         for (i = 0; i < data->acpi_data.state_count; i++)
 284                 pr_debug("     %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
 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
 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:
 300         kfree(freq_table);
 301  err_unreg:
 302         acpi_processor_unregister_performance(cpu);
 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
 317         pr_debug("acpi_cpufreq_cpu_exit\n");
 318
 319         if (data) {
 320                 acpi_io_data[policy->cpu] = NULL;
 321                 acpi_processor_unregister_performance(policy->cpu);
 322                 kfree(policy->freq_table);
 323                 kfree(data);
 324         }
 325
 326         return (0);
 327 }
 328
 329
 330 static struct cpufreq_driver acpi_cpufreq_driver = {
 331         .verify         = cpufreq_generic_frequency_table_verify,
 332         .target_index   = acpi_cpufreq_target,
 333         .get            = acpi_cpufreq_get,
 334         .init           = acpi_cpufreq_cpu_init,
 335         .exit           = acpi_cpufreq_cpu_exit,
 336         .name           = "acpi-cpufreq",
 337         .attr           = cpufreq_generic_attr,
 338 };
 339
 340
 341 static int __init
 342 acpi_cpufreq_init (void)
 343 {
 344         pr_debug("acpi_cpufreq_init\n");
 345
 346         return cpufreq_register_driver(&acpi_cpufreq_driver);
 347 }
 348
 349
 350 static void __exit
 351 acpi_cpufreq_exit (void)
 352 {
 353         pr_debug("acpi_cpufreq_exit\n");
 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