| 1 | /* |
| 2 | * processor_driver.c - 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 | * Copyright (C) 2013, Intel Corporation |
| 10 | * Rafael J. Wysocki <rafael.j.wysocki@intel.com> |
| 11 | * |
| 12 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 13 | * |
| 14 | * This program is free software; you can redistribute it and/or modify |
| 15 | * it under the terms of the GNU General Public License as published by |
| 16 | * the Free Software Foundation; either version 2 of the License, or (at |
| 17 | * your option) any later version. |
| 18 | * |
| 19 | * This program is distributed in the hope that it will be useful, but |
| 20 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 22 | * General Public License for more details. |
| 23 | * |
| 24 | * You should have received a copy of the GNU General Public License along |
| 25 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 26 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
| 27 | * |
| 28 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 29 | */ |
| 30 | |
| 31 | #include <linux/kernel.h> |
| 32 | #include <linux/module.h> |
| 33 | #include <linux/init.h> |
| 34 | #include <linux/cpufreq.h> |
| 35 | #include <linux/cpu.h> |
| 36 | #include <linux/cpuidle.h> |
| 37 | #include <linux/slab.h> |
| 38 | #include <linux/acpi.h> |
| 39 | |
| 40 | #include <acpi/processor.h> |
| 41 | |
| 42 | #include "internal.h" |
| 43 | |
| 44 | #define PREFIX "ACPI: " |
| 45 | |
| 46 | #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80 |
| 47 | #define ACPI_PROCESSOR_NOTIFY_POWER 0x81 |
| 48 | #define ACPI_PROCESSOR_NOTIFY_THROTTLING 0x82 |
| 49 | |
| 50 | #define _COMPONENT ACPI_PROCESSOR_COMPONENT |
| 51 | ACPI_MODULE_NAME("processor_driver"); |
| 52 | |
| 53 | MODULE_AUTHOR("Paul Diefenbaugh"); |
| 54 | MODULE_DESCRIPTION("ACPI Processor Driver"); |
| 55 | MODULE_LICENSE("GPL"); |
| 56 | |
| 57 | static int acpi_processor_start(struct device *dev); |
| 58 | static int acpi_processor_stop(struct device *dev); |
| 59 | |
| 60 | static const struct acpi_device_id processor_device_ids[] = { |
| 61 | {ACPI_PROCESSOR_OBJECT_HID, 0}, |
| 62 | {ACPI_PROCESSOR_DEVICE_HID, 0}, |
| 63 | {"", 0}, |
| 64 | }; |
| 65 | MODULE_DEVICE_TABLE(acpi, processor_device_ids); |
| 66 | |
| 67 | static struct device_driver acpi_processor_driver = { |
| 68 | .name = "processor", |
| 69 | .bus = &cpu_subsys, |
| 70 | .acpi_match_table = processor_device_ids, |
| 71 | .probe = acpi_processor_start, |
| 72 | .remove = acpi_processor_stop, |
| 73 | }; |
| 74 | |
| 75 | static void acpi_processor_notify(acpi_handle handle, u32 event, void *data) |
| 76 | { |
| 77 | struct acpi_device *device = data; |
| 78 | struct acpi_processor *pr; |
| 79 | int saved; |
| 80 | |
| 81 | if (device->handle != handle) |
| 82 | return; |
| 83 | |
| 84 | pr = acpi_driver_data(device); |
| 85 | if (!pr) |
| 86 | return; |
| 87 | |
| 88 | switch (event) { |
| 89 | case ACPI_PROCESSOR_NOTIFY_PERFORMANCE: |
| 90 | saved = pr->performance_platform_limit; |
| 91 | acpi_processor_ppc_has_changed(pr, 1); |
| 92 | if (saved == pr->performance_platform_limit) |
| 93 | break; |
| 94 | acpi_bus_generate_netlink_event(device->pnp.device_class, |
| 95 | dev_name(&device->dev), event, |
| 96 | pr->performance_platform_limit); |
| 97 | break; |
| 98 | case ACPI_PROCESSOR_NOTIFY_POWER: |
| 99 | acpi_processor_cst_has_changed(pr); |
| 100 | acpi_bus_generate_netlink_event(device->pnp.device_class, |
| 101 | dev_name(&device->dev), event, 0); |
| 102 | break; |
| 103 | case ACPI_PROCESSOR_NOTIFY_THROTTLING: |
| 104 | acpi_processor_tstate_has_changed(pr); |
| 105 | acpi_bus_generate_netlink_event(device->pnp.device_class, |
| 106 | dev_name(&device->dev), event, 0); |
| 107 | break; |
| 108 | default: |
| 109 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
| 110 | "Unsupported event [0x%x]\n", event)); |
| 111 | break; |
| 112 | } |
| 113 | |
| 114 | return; |
| 115 | } |
| 116 | |
| 117 | static int __acpi_processor_start(struct acpi_device *device); |
| 118 | |
| 119 | static int acpi_cpu_soft_notify(struct notifier_block *nfb, |
| 120 | unsigned long action, void *hcpu) |
| 121 | { |
| 122 | unsigned int cpu = (unsigned long)hcpu; |
| 123 | struct acpi_processor *pr = per_cpu(processors, cpu); |
| 124 | struct acpi_device *device; |
| 125 | |
| 126 | if (!pr || acpi_bus_get_device(pr->handle, &device)) |
| 127 | return NOTIFY_DONE; |
| 128 | |
| 129 | if (action == CPU_ONLINE) { |
| 130 | /* |
| 131 | * CPU got physically hotplugged and onlined for the first time: |
| 132 | * Initialize missing things. |
| 133 | */ |
| 134 | if (pr->flags.need_hotplug_init) { |
| 135 | int ret; |
| 136 | |
| 137 | pr_info("Will online and init hotplugged CPU: %d\n", |
| 138 | pr->id); |
| 139 | pr->flags.need_hotplug_init = 0; |
| 140 | ret = __acpi_processor_start(device); |
| 141 | WARN(ret, "Failed to start CPU: %d\n", pr->id); |
| 142 | } else { |
| 143 | /* Normal CPU soft online event. */ |
| 144 | acpi_processor_ppc_has_changed(pr, 0); |
| 145 | acpi_processor_hotplug(pr); |
| 146 | acpi_processor_reevaluate_tstate(pr, action); |
| 147 | acpi_processor_tstate_has_changed(pr); |
| 148 | } |
| 149 | } else if (action == CPU_DEAD) { |
| 150 | /* Invalidate flag.throttling after the CPU is offline. */ |
| 151 | acpi_processor_reevaluate_tstate(pr, action); |
| 152 | } |
| 153 | return NOTIFY_OK; |
| 154 | } |
| 155 | |
| 156 | static struct notifier_block __refdata acpi_cpu_notifier = |
| 157 | { |
| 158 | .notifier_call = acpi_cpu_soft_notify, |
| 159 | }; |
| 160 | |
| 161 | static int __acpi_processor_start(struct acpi_device *device) |
| 162 | { |
| 163 | struct acpi_processor *pr = acpi_driver_data(device); |
| 164 | acpi_status status; |
| 165 | int result = 0; |
| 166 | |
| 167 | if (!pr) |
| 168 | return -ENODEV; |
| 169 | |
| 170 | if (pr->flags.need_hotplug_init) |
| 171 | return 0; |
| 172 | |
| 173 | #ifdef CONFIG_CPU_FREQ |
| 174 | acpi_processor_ppc_has_changed(pr, 0); |
| 175 | acpi_processor_load_module(pr); |
| 176 | #endif |
| 177 | acpi_processor_get_throttling_info(pr); |
| 178 | |
| 179 | if (pr->flags.throttling) |
| 180 | pr->flags.limit = 1; |
| 181 | |
| 182 | if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver) |
| 183 | acpi_processor_power_init(pr); |
| 184 | |
| 185 | pr->cdev = thermal_cooling_device_register("Processor", device, |
| 186 | &processor_cooling_ops); |
| 187 | if (IS_ERR(pr->cdev)) { |
| 188 | result = PTR_ERR(pr->cdev); |
| 189 | goto err_power_exit; |
| 190 | } |
| 191 | |
| 192 | dev_dbg(&device->dev, "registered as cooling_device%d\n", |
| 193 | pr->cdev->id); |
| 194 | |
| 195 | result = sysfs_create_link(&device->dev.kobj, |
| 196 | &pr->cdev->device.kobj, |
| 197 | "thermal_cooling"); |
| 198 | if (result) { |
| 199 | dev_err(&device->dev, |
| 200 | "Failed to create sysfs link 'thermal_cooling'\n"); |
| 201 | goto err_thermal_unregister; |
| 202 | } |
| 203 | result = sysfs_create_link(&pr->cdev->device.kobj, |
| 204 | &device->dev.kobj, |
| 205 | "device"); |
| 206 | if (result) { |
| 207 | dev_err(&pr->cdev->device, |
| 208 | "Failed to create sysfs link 'device'\n"); |
| 209 | goto err_remove_sysfs_thermal; |
| 210 | } |
| 211 | |
| 212 | status = acpi_install_notify_handler(device->handle, ACPI_DEVICE_NOTIFY, |
| 213 | acpi_processor_notify, device); |
| 214 | if (ACPI_SUCCESS(status)) |
| 215 | return 0; |
| 216 | |
| 217 | sysfs_remove_link(&pr->cdev->device.kobj, "device"); |
| 218 | err_remove_sysfs_thermal: |
| 219 | sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); |
| 220 | err_thermal_unregister: |
| 221 | thermal_cooling_device_unregister(pr->cdev); |
| 222 | err_power_exit: |
| 223 | acpi_processor_power_exit(pr); |
| 224 | return result; |
| 225 | } |
| 226 | |
| 227 | static int acpi_processor_start(struct device *dev) |
| 228 | { |
| 229 | struct acpi_device *device; |
| 230 | |
| 231 | if (acpi_bus_get_device(ACPI_HANDLE(dev), &device)) |
| 232 | return -ENODEV; |
| 233 | |
| 234 | return __acpi_processor_start(device); |
| 235 | } |
| 236 | |
| 237 | static int acpi_processor_stop(struct device *dev) |
| 238 | { |
| 239 | struct acpi_device *device; |
| 240 | struct acpi_processor *pr; |
| 241 | |
| 242 | if (acpi_bus_get_device(ACPI_HANDLE(dev), &device)) |
| 243 | return 0; |
| 244 | |
| 245 | acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY, |
| 246 | acpi_processor_notify); |
| 247 | |
| 248 | pr = acpi_driver_data(device); |
| 249 | if (!pr) |
| 250 | return 0; |
| 251 | |
| 252 | acpi_processor_power_exit(pr); |
| 253 | |
| 254 | if (pr->cdev) { |
| 255 | sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); |
| 256 | sysfs_remove_link(&pr->cdev->device.kobj, "device"); |
| 257 | thermal_cooling_device_unregister(pr->cdev); |
| 258 | pr->cdev = NULL; |
| 259 | } |
| 260 | return 0; |
| 261 | } |
| 262 | |
| 263 | /* |
| 264 | * We keep the driver loaded even when ACPI is not running. |
| 265 | * This is needed for the powernow-k8 driver, that works even without |
| 266 | * ACPI, but needs symbols from this driver |
| 267 | */ |
| 268 | |
| 269 | static int __init acpi_processor_driver_init(void) |
| 270 | { |
| 271 | int result = 0; |
| 272 | |
| 273 | if (acpi_disabled) |
| 274 | return 0; |
| 275 | |
| 276 | result = driver_register(&acpi_processor_driver); |
| 277 | if (result < 0) |
| 278 | return result; |
| 279 | |
| 280 | acpi_processor_syscore_init(); |
| 281 | register_hotcpu_notifier(&acpi_cpu_notifier); |
| 282 | acpi_thermal_cpufreq_init(); |
| 283 | acpi_processor_ppc_init(); |
| 284 | acpi_processor_throttling_init(); |
| 285 | return 0; |
| 286 | } |
| 287 | |
| 288 | static void __exit acpi_processor_driver_exit(void) |
| 289 | { |
| 290 | if (acpi_disabled) |
| 291 | return; |
| 292 | |
| 293 | acpi_processor_ppc_exit(); |
| 294 | acpi_thermal_cpufreq_exit(); |
| 295 | unregister_hotcpu_notifier(&acpi_cpu_notifier); |
| 296 | acpi_processor_syscore_exit(); |
| 297 | driver_unregister(&acpi_processor_driver); |
| 298 | } |
| 299 | |
| 300 | module_init(acpi_processor_driver_init); |
| 301 | module_exit(acpi_processor_driver_exit); |
| 302 | |
| 303 | MODULE_ALIAS("processor"); |