drivers/acpi/processor_driver.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * processor_driver.c - ACPI Processor Driver
   4  *
   5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   7  *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
   8  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
   9  *                      - Added processor hotplug support
  10  *  Copyright (C) 2013, Intel Corporation
  11  *                      Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/cpufreq.h>
  18 #include <linux/cpu.h>
  19 #include <linux/cpuidle.h>
  20 #include <linux/slab.h>
  21 #include <linux/acpi.h>
  22
  23 #include <acpi/processor.h>
  24
  25 #include "internal.h"
  26
  27 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
  28 #define ACPI_PROCESSOR_NOTIFY_POWER     0x81
  29 #define ACPI_PROCESSOR_NOTIFY_THROTTLING        0x82
  30
  31 MODULE_AUTHOR("Paul Diefenbaugh");
  32 MODULE_DESCRIPTION("ACPI Processor Driver");
  33 MODULE_LICENSE("GPL");
  34
  35 static int acpi_processor_start(struct device *dev);
  36 static int acpi_processor_stop(struct device *dev);
  37
  38 static const struct acpi_device_id processor_device_ids[] = {
  39         {ACPI_PROCESSOR_OBJECT_HID, 0},
  40         {ACPI_PROCESSOR_DEVICE_HID, 0},
  41         {"", 0},
  42 };
  43 MODULE_DEVICE_TABLE(acpi, processor_device_ids);
  44
  45 static struct device_driver acpi_processor_driver = {
  46         .name = "processor",
  47         .bus = &cpu_subsys,
  48         .acpi_match_table = processor_device_ids,
  49         .probe = acpi_processor_start,
  50         .remove = acpi_processor_stop,
  51 };
  52
  53 static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
  54 {
  55         struct acpi_device *device = data;
  56         struct acpi_processor *pr;
  57         int saved;
  58
  59         if (device->handle != handle)
  60                 return;
  61
  62         pr = acpi_driver_data(device);
  63         if (!pr)
  64                 return;
  65
  66         switch (event) {
  67         case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
  68                 saved = pr->performance_platform_limit;
  69                 acpi_processor_ppc_has_changed(pr, 1);
  70                 if (saved == pr->performance_platform_limit)
  71                         break;
  72                 acpi_bus_generate_netlink_event(device->pnp.device_class,
  73                                                   dev_name(&device->dev), event,
  74                                                   pr->performance_platform_limit);
  75                 break;
  76         case ACPI_PROCESSOR_NOTIFY_POWER:
  77                 acpi_processor_power_state_has_changed(pr);
  78                 acpi_bus_generate_netlink_event(device->pnp.device_class,
  79                                                   dev_name(&device->dev), event, 0);
  80                 break;
  81         case ACPI_PROCESSOR_NOTIFY_THROTTLING:
  82                 acpi_processor_tstate_has_changed(pr);
  83                 acpi_bus_generate_netlink_event(device->pnp.device_class,
  84                                                   dev_name(&device->dev), event, 0);
  85                 break;
  86         default:
  87                 acpi_handle_debug(handle, "Unsupported event [0x%x]\n", event);
  88                 break;
  89         }
  90
  91         return;
  92 }
  93
  94 static int __acpi_processor_start(struct acpi_device *device);
  95
  96 static int acpi_soft_cpu_online(unsigned int cpu)
  97 {
  98         struct acpi_processor *pr = per_cpu(processors, cpu);
  99         struct acpi_device *device;
 100
 101         if (!pr)
 102                 return 0;
 103
 104         device = acpi_fetch_acpi_dev(pr->handle);
 105         if (!device)
 106                 return 0;
 107
 108         /*
 109          * CPU got physically hotplugged and onlined for the first time:
 110          * Initialize missing things.
 111          */
 112         if (pr->flags.need_hotplug_init) {
 113                 int ret;
 114
 115                 pr_info("Will online and init hotplugged CPU: %d\n",
 116                         pr->id);
 117                 pr->flags.need_hotplug_init = 0;
 118                 ret = __acpi_processor_start(device);
 119                 WARN(ret, "Failed to start CPU: %d\n", pr->id);
 120         } else {
 121                 /* Normal CPU soft online event. */
 122                 acpi_processor_ppc_has_changed(pr, 0);
 123                 acpi_processor_hotplug(pr);
 124                 acpi_processor_reevaluate_tstate(pr, false);
 125                 acpi_processor_tstate_has_changed(pr);
 126         }
 127         return 0;
 128 }
 129
 130 static int acpi_soft_cpu_dead(unsigned int cpu)
 131 {
 132         struct acpi_processor *pr = per_cpu(processors, cpu);
 133
 134         if (!pr || !acpi_fetch_acpi_dev(pr->handle))
 135                 return 0;
 136
 137         acpi_processor_reevaluate_tstate(pr, true);
 138         return 0;
 139 }
 140
 141 #ifdef CONFIG_ACPI_CPU_FREQ_PSS
 142 static void acpi_pss_perf_init(struct acpi_processor *pr)
 143 {
 144         acpi_processor_ppc_has_changed(pr, 0);
 145
 146         acpi_processor_get_throttling_info(pr);
 147
 148         if (pr->flags.throttling)
 149                 pr->flags.limit = 1;
 150 }
 151 #else
 152 static inline void acpi_pss_perf_init(struct acpi_processor *pr) {}
 153 #endif /* CONFIG_ACPI_CPU_FREQ_PSS */
 154
 155 static int __acpi_processor_start(struct acpi_device *device)
 156 {
 157         struct acpi_processor *pr = acpi_driver_data(device);
 158         acpi_status status;
 159         int result = 0;
 160
 161         if (!pr)
 162                 return -ENODEV;
 163
 164         if (pr->flags.need_hotplug_init)
 165                 return 0;
 166
 167         result = acpi_cppc_processor_probe(pr);
 168         if (result && !IS_ENABLED(CONFIG_ACPI_CPU_FREQ_PSS))
 169                 dev_dbg(&device->dev, "CPPC data invalid or not present\n");
 170
 171         if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver)
 172                 acpi_processor_power_init(pr);
 173
 174         acpi_pss_perf_init(pr);
 175
 176         result = acpi_processor_thermal_init(pr, device);
 177         if (result)
 178                 goto err_power_exit;
 179
 180         status = acpi_install_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
 181                                              acpi_processor_notify, device);
 182         if (ACPI_SUCCESS(status))
 183                 return 0;
 184
 185         result = -ENODEV;
 186         acpi_processor_thermal_exit(pr, device);
 187
 188 err_power_exit:
 189         acpi_processor_power_exit(pr);
 190         return result;
 191 }
 192
 193 static int acpi_processor_start(struct device *dev)
 194 {
 195         struct acpi_device *device = ACPI_COMPANION(dev);
 196         int ret;
 197
 198         if (!device)
 199                 return -ENODEV;
 200
 201         /* Protect against concurrent CPU hotplug operations */
 202         cpu_hotplug_disable();
 203         ret = __acpi_processor_start(device);
 204         cpu_hotplug_enable();
 205         return ret;
 206 }
 207
 208 static int acpi_processor_stop(struct device *dev)
 209 {
 210         struct acpi_device *device = ACPI_COMPANION(dev);
 211         struct acpi_processor *pr;
 212
 213         if (!device)
 214                 return 0;
 215
 216         acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
 217                                    acpi_processor_notify);
 218
 219         pr = acpi_driver_data(device);
 220         if (!pr)
 221                 return 0;
 222         acpi_processor_power_exit(pr);
 223
 224         acpi_cppc_processor_exit(pr);
 225
 226         acpi_processor_thermal_exit(pr, device);
 227
 228         return 0;
 229 }
 230
 231 bool acpi_processor_cpufreq_init;
 232
 233 static int acpi_processor_notifier(struct notifier_block *nb,
 234                                    unsigned long event, void *data)
 235 {
 236         struct cpufreq_policy *policy = data;
 237
 238         if (event == CPUFREQ_CREATE_POLICY) {
 239                 acpi_thermal_cpufreq_init(policy);
 240                 acpi_processor_ppc_init(policy);
 241         } else if (event == CPUFREQ_REMOVE_POLICY) {
 242                 acpi_processor_ppc_exit(policy);
 243                 acpi_thermal_cpufreq_exit(policy);
 244         }
 245
 246         return 0;
 247 }
 248
 249 static struct notifier_block acpi_processor_notifier_block = {
 250         .notifier_call = acpi_processor_notifier,
 251 };
 252
 253 /*
 254  * We keep the driver loaded even when ACPI is not running.
 255  * This is needed for the powernow-k8 driver, that works even without
 256  * ACPI, but needs symbols from this driver
 257  */
 258 static enum cpuhp_state hp_online;
 259 static int __init acpi_processor_driver_init(void)
 260 {
 261         int result = 0;
 262
 263         if (acpi_disabled)
 264                 return 0;
 265
 266         result = driver_register(&acpi_processor_driver);
 267         if (result < 0)
 268                 return result;
 269
 270         result = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
 271                                            "acpi/cpu-drv:online",
 272                                            acpi_soft_cpu_online, NULL);
 273         if (result < 0)
 274                 goto err;
 275         hp_online = result;
 276         cpuhp_setup_state_nocalls(CPUHP_ACPI_CPUDRV_DEAD, "acpi/cpu-drv:dead",
 277                                   NULL, acpi_soft_cpu_dead);
 278
 279         if (!cpufreq_register_notifier(&acpi_processor_notifier_block,
 280                                        CPUFREQ_POLICY_NOTIFIER)) {
 281                 acpi_processor_cpufreq_init = true;
 282                 acpi_processor_ignore_ppc_init();
 283         }
 284
 285         acpi_processor_throttling_init();
 286         return 0;
 287 err:
 288         driver_unregister(&acpi_processor_driver);
 289         return result;
 290 }
 291
 292 static void __exit acpi_processor_driver_exit(void)
 293 {
 294         if (acpi_disabled)
 295                 return;
 296
 297         if (acpi_processor_cpufreq_init) {
 298                 cpufreq_unregister_notifier(&acpi_processor_notifier_block,
 299                                             CPUFREQ_POLICY_NOTIFIER);
 300                 acpi_processor_cpufreq_init = false;
 301         }
 302
 303         cpuhp_remove_state_nocalls(hp_online);
 304         cpuhp_remove_state_nocalls(CPUHP_ACPI_CPUDRV_DEAD);
 305         driver_unregister(&acpi_processor_driver);
 306 }
 307
 308 module_init(acpi_processor_driver_init);
 309 module_exit(acpi_processor_driver_exit);
 310
 311 MODULE_ALIAS("processor");