| 1 | /* |
| 2 | * processor_thermal.c - Passive cooling submodule of the ACPI processor driver |
| 3 | * |
| 4 | * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> |
| 5 | * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> |
| 6 | * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de> |
| 7 | * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> |
| 8 | * - Added processor hotplug support |
| 9 | * |
| 10 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 11 | * |
| 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License as published by |
| 14 | * the Free Software Foundation; either version 2 of the License, or (at |
| 15 | * your option) any later version. |
| 16 | * |
| 17 | * This program is distributed in the hope that it will be useful, but |
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 20 | * General Public License for more details. |
| 21 | * |
| 22 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 23 | */ |
| 24 | |
| 25 | #include <linux/kernel.h> |
| 26 | #include <linux/module.h> |
| 27 | #include <linux/init.h> |
| 28 | #include <linux/cpufreq.h> |
| 29 | #include <linux/acpi.h> |
| 30 | #include <acpi/processor.h> |
| 31 | #include <asm/uaccess.h> |
| 32 | |
| 33 | #define PREFIX "ACPI: " |
| 34 | |
| 35 | #define ACPI_PROCESSOR_CLASS "processor" |
| 36 | #define _COMPONENT ACPI_PROCESSOR_COMPONENT |
| 37 | ACPI_MODULE_NAME("processor_thermal"); |
| 38 | |
| 39 | #ifdef CONFIG_CPU_FREQ |
| 40 | |
| 41 | /* If a passive cooling situation is detected, primarily CPUfreq is used, as it |
| 42 | * offers (in most cases) voltage scaling in addition to frequency scaling, and |
| 43 | * thus a cubic (instead of linear) reduction of energy. Also, we allow for |
| 44 | * _any_ cpufreq driver and not only the acpi-cpufreq driver. |
| 45 | */ |
| 46 | |
| 47 | #define CPUFREQ_THERMAL_MIN_STEP 0 |
| 48 | #define CPUFREQ_THERMAL_MAX_STEP 3 |
| 49 | |
| 50 | static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg); |
| 51 | static unsigned int acpi_thermal_cpufreq_is_init = 0; |
| 52 | |
| 53 | #define reduction_pctg(cpu) \ |
| 54 | per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu)) |
| 55 | |
| 56 | /* |
| 57 | * Emulate "per package data" using per cpu data (which should really be |
| 58 | * provided elsewhere) |
| 59 | * |
| 60 | * Note we can lose a CPU on cpu hotunplug, in this case we forget the state |
| 61 | * temporarily. Fortunately that's not a big issue here (I hope) |
| 62 | */ |
| 63 | static int phys_package_first_cpu(int cpu) |
| 64 | { |
| 65 | int i; |
| 66 | int id = topology_physical_package_id(cpu); |
| 67 | |
| 68 | for_each_online_cpu(i) |
| 69 | if (topology_physical_package_id(i) == id) |
| 70 | return i; |
| 71 | return 0; |
| 72 | } |
| 73 | |
| 74 | static int cpu_has_cpufreq(unsigned int cpu) |
| 75 | { |
| 76 | struct cpufreq_policy policy; |
| 77 | if (!acpi_thermal_cpufreq_is_init || cpufreq_get_policy(&policy, cpu)) |
| 78 | return 0; |
| 79 | return 1; |
| 80 | } |
| 81 | |
| 82 | static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb, |
| 83 | unsigned long event, void *data) |
| 84 | { |
| 85 | struct cpufreq_policy *policy = data; |
| 86 | unsigned long max_freq = 0; |
| 87 | |
| 88 | if (event != CPUFREQ_ADJUST) |
| 89 | goto out; |
| 90 | |
| 91 | max_freq = ( |
| 92 | policy->cpuinfo.max_freq * |
| 93 | (100 - reduction_pctg(policy->cpu) * 20) |
| 94 | ) / 100; |
| 95 | |
| 96 | cpufreq_verify_within_limits(policy, 0, max_freq); |
| 97 | |
| 98 | out: |
| 99 | return 0; |
| 100 | } |
| 101 | |
| 102 | static struct notifier_block acpi_thermal_cpufreq_notifier_block = { |
| 103 | .notifier_call = acpi_thermal_cpufreq_notifier, |
| 104 | }; |
| 105 | |
| 106 | static int cpufreq_get_max_state(unsigned int cpu) |
| 107 | { |
| 108 | if (!cpu_has_cpufreq(cpu)) |
| 109 | return 0; |
| 110 | |
| 111 | return CPUFREQ_THERMAL_MAX_STEP; |
| 112 | } |
| 113 | |
| 114 | static int cpufreq_get_cur_state(unsigned int cpu) |
| 115 | { |
| 116 | if (!cpu_has_cpufreq(cpu)) |
| 117 | return 0; |
| 118 | |
| 119 | return reduction_pctg(cpu); |
| 120 | } |
| 121 | |
| 122 | static int cpufreq_set_cur_state(unsigned int cpu, int state) |
| 123 | { |
| 124 | int i; |
| 125 | |
| 126 | if (!cpu_has_cpufreq(cpu)) |
| 127 | return 0; |
| 128 | |
| 129 | reduction_pctg(cpu) = state; |
| 130 | |
| 131 | /* |
| 132 | * Update all the CPUs in the same package because they all |
| 133 | * contribute to the temperature and often share the same |
| 134 | * frequency. |
| 135 | */ |
| 136 | for_each_online_cpu(i) { |
| 137 | if (topology_physical_package_id(i) == |
| 138 | topology_physical_package_id(cpu)) |
| 139 | cpufreq_update_policy(i); |
| 140 | } |
| 141 | return 0; |
| 142 | } |
| 143 | |
| 144 | void acpi_thermal_cpufreq_init(void) |
| 145 | { |
| 146 | int i; |
| 147 | |
| 148 | i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block, |
| 149 | CPUFREQ_POLICY_NOTIFIER); |
| 150 | if (!i) |
| 151 | acpi_thermal_cpufreq_is_init = 1; |
| 152 | } |
| 153 | |
| 154 | void acpi_thermal_cpufreq_exit(void) |
| 155 | { |
| 156 | if (acpi_thermal_cpufreq_is_init) |
| 157 | cpufreq_unregister_notifier |
| 158 | (&acpi_thermal_cpufreq_notifier_block, |
| 159 | CPUFREQ_POLICY_NOTIFIER); |
| 160 | |
| 161 | acpi_thermal_cpufreq_is_init = 0; |
| 162 | } |
| 163 | |
| 164 | #else /* ! CONFIG_CPU_FREQ */ |
| 165 | static int cpufreq_get_max_state(unsigned int cpu) |
| 166 | { |
| 167 | return 0; |
| 168 | } |
| 169 | |
| 170 | static int cpufreq_get_cur_state(unsigned int cpu) |
| 171 | { |
| 172 | return 0; |
| 173 | } |
| 174 | |
| 175 | static int cpufreq_set_cur_state(unsigned int cpu, int state) |
| 176 | { |
| 177 | return 0; |
| 178 | } |
| 179 | |
| 180 | #endif |
| 181 | |
| 182 | /* thermal cooling device callbacks */ |
| 183 | static int acpi_processor_max_state(struct acpi_processor *pr) |
| 184 | { |
| 185 | int max_state = 0; |
| 186 | |
| 187 | /* |
| 188 | * There exists four states according to |
| 189 | * cpufreq_thermal_reduction_pctg. 0, 1, 2, 3 |
| 190 | */ |
| 191 | max_state += cpufreq_get_max_state(pr->id); |
| 192 | if (pr->flags.throttling) |
| 193 | max_state += (pr->throttling.state_count -1); |
| 194 | |
| 195 | return max_state; |
| 196 | } |
| 197 | static int |
| 198 | processor_get_max_state(struct thermal_cooling_device *cdev, |
| 199 | unsigned long *state) |
| 200 | { |
| 201 | struct acpi_device *device = cdev->devdata; |
| 202 | struct acpi_processor *pr; |
| 203 | |
| 204 | if (!device) |
| 205 | return -EINVAL; |
| 206 | |
| 207 | pr = acpi_driver_data(device); |
| 208 | if (!pr) |
| 209 | return -EINVAL; |
| 210 | |
| 211 | *state = acpi_processor_max_state(pr); |
| 212 | return 0; |
| 213 | } |
| 214 | |
| 215 | static int |
| 216 | processor_get_cur_state(struct thermal_cooling_device *cdev, |
| 217 | unsigned long *cur_state) |
| 218 | { |
| 219 | struct acpi_device *device = cdev->devdata; |
| 220 | struct acpi_processor *pr; |
| 221 | |
| 222 | if (!device) |
| 223 | return -EINVAL; |
| 224 | |
| 225 | pr = acpi_driver_data(device); |
| 226 | if (!pr) |
| 227 | return -EINVAL; |
| 228 | |
| 229 | *cur_state = cpufreq_get_cur_state(pr->id); |
| 230 | if (pr->flags.throttling) |
| 231 | *cur_state += pr->throttling.state; |
| 232 | return 0; |
| 233 | } |
| 234 | |
| 235 | static int |
| 236 | processor_set_cur_state(struct thermal_cooling_device *cdev, |
| 237 | unsigned long state) |
| 238 | { |
| 239 | struct acpi_device *device = cdev->devdata; |
| 240 | struct acpi_processor *pr; |
| 241 | int result = 0; |
| 242 | int max_pstate; |
| 243 | |
| 244 | if (!device) |
| 245 | return -EINVAL; |
| 246 | |
| 247 | pr = acpi_driver_data(device); |
| 248 | if (!pr) |
| 249 | return -EINVAL; |
| 250 | |
| 251 | max_pstate = cpufreq_get_max_state(pr->id); |
| 252 | |
| 253 | if (state > acpi_processor_max_state(pr)) |
| 254 | return -EINVAL; |
| 255 | |
| 256 | if (state <= max_pstate) { |
| 257 | if (pr->flags.throttling && pr->throttling.state) |
| 258 | result = acpi_processor_set_throttling(pr, 0, false); |
| 259 | cpufreq_set_cur_state(pr->id, state); |
| 260 | } else { |
| 261 | cpufreq_set_cur_state(pr->id, max_pstate); |
| 262 | result = acpi_processor_set_throttling(pr, |
| 263 | state - max_pstate, false); |
| 264 | } |
| 265 | return result; |
| 266 | } |
| 267 | |
| 268 | const struct thermal_cooling_device_ops processor_cooling_ops = { |
| 269 | .get_max_state = processor_get_max_state, |
| 270 | .get_cur_state = processor_get_cur_state, |
| 271 | .set_cur_state = processor_set_cur_state, |
| 272 | }; |