1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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
51ACPI_MODULE_NAME("processor_driver");
52
53MODULE_AUTHOR("Paul Diefenbaugh");
54MODULE_DESCRIPTION("ACPI Processor Driver");
55MODULE_LICENSE("GPL");
56
57static int acpi_processor_start(struct device *dev);
58static int acpi_processor_stop(struct device *dev);
59
60static const struct acpi_device_id processor_device_ids[] = {
61 {ACPI_PROCESSOR_OBJECT_HID, 0},
62 {ACPI_PROCESSOR_DEVICE_HID, 0},
63 {"", 0},
64};
65MODULE_DEVICE_TABLE(acpi, processor_device_ids);
66
67static 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
75static 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_proc_event(device, event,
95 pr->performance_platform_limit);
96 acpi_bus_generate_netlink_event(device->pnp.device_class,
97 dev_name(&device->dev), event,
98 pr->performance_platform_limit);
99 break;
100 case ACPI_PROCESSOR_NOTIFY_POWER:
101 acpi_processor_cst_has_changed(pr);
102 acpi_bus_generate_proc_event(device, event, 0);
103 acpi_bus_generate_netlink_event(device->pnp.device_class,
104 dev_name(&device->dev), event, 0);
105 break;
106 case ACPI_PROCESSOR_NOTIFY_THROTTLING:
107 acpi_processor_tstate_has_changed(pr);
108 acpi_bus_generate_proc_event(device, event, 0);
109 acpi_bus_generate_netlink_event(device->pnp.device_class,
110 dev_name(&device->dev), event, 0);
111 break;
112 default:
113 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
114 "Unsupported event [0x%x]\n", event));
115 break;
116 }
117
118 return;
119}
120
121static int __acpi_processor_start(struct acpi_device *device);
122
123static int acpi_cpu_soft_notify(struct notifier_block *nfb,
124 unsigned long action, void *hcpu)
125{
126 unsigned int cpu = (unsigned long)hcpu;
127 struct acpi_processor *pr = per_cpu(processors, cpu);
128 struct acpi_device *device;
129
130 if (!pr || acpi_bus_get_device(pr->handle, &device))
131 return NOTIFY_DONE;
132
133 if (action == CPU_ONLINE) {
134
135
136
137
138 if (pr->flags.need_hotplug_init) {
139 int ret;
140
141 pr_info("Will online and init hotplugged CPU: %d\n",
142 pr->id);
143 pr->flags.need_hotplug_init = 0;
144 ret = __acpi_processor_start(device);
145 WARN(ret, "Failed to start CPU: %d\n", pr->id);
146 } else {
147
148 acpi_processor_ppc_has_changed(pr, 0);
149 acpi_processor_hotplug(pr);
150 acpi_processor_reevaluate_tstate(pr, action);
151 acpi_processor_tstate_has_changed(pr);
152 }
153 } else if (action == CPU_DEAD) {
154
155 acpi_processor_reevaluate_tstate(pr, action);
156 }
157 return NOTIFY_OK;
158}
159
160static struct notifier_block __refdata acpi_cpu_notifier =
161{
162 .notifier_call = acpi_cpu_soft_notify,
163};
164
165static int __acpi_processor_start(struct acpi_device *device)
166{
167 struct acpi_processor *pr = acpi_driver_data(device);
168 acpi_status status;
169 int result = 0;
170
171 if (!pr)
172 return -ENODEV;
173
174 if (pr->flags.need_hotplug_init)
175 return 0;
176
177#ifdef CONFIG_CPU_FREQ
178 acpi_processor_ppc_has_changed(pr, 0);
179 acpi_processor_load_module(pr);
180#endif
181 acpi_processor_get_throttling_info(pr);
182 acpi_processor_get_limit_info(pr);
183
184 if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver)
185 acpi_processor_power_init(pr);
186
187 pr->cdev = thermal_cooling_device_register("Processor", device,
188 &processor_cooling_ops);
189 if (IS_ERR(pr->cdev)) {
190 result = PTR_ERR(pr->cdev);
191 goto err_power_exit;
192 }
193
194 dev_dbg(&device->dev, "registered as cooling_device%d\n",
195 pr->cdev->id);
196
197 result = sysfs_create_link(&device->dev.kobj,
198 &pr->cdev->device.kobj,
199 "thermal_cooling");
200 if (result) {
201 dev_err(&device->dev,
202 "Failed to create sysfs link 'thermal_cooling'\n");
203 goto err_thermal_unregister;
204 }
205 result = sysfs_create_link(&pr->cdev->device.kobj,
206 &device->dev.kobj,
207 "device");
208 if (result) {
209 dev_err(&pr->cdev->device,
210 "Failed to create sysfs link 'device'\n");
211 goto err_remove_sysfs_thermal;
212 }
213
214 status = acpi_install_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
215 acpi_processor_notify, device);
216 if (ACPI_SUCCESS(status))
217 return 0;
218
219 sysfs_remove_link(&pr->cdev->device.kobj, "device");
220 err_remove_sysfs_thermal:
221 sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
222 err_thermal_unregister:
223 thermal_cooling_device_unregister(pr->cdev);
224 err_power_exit:
225 acpi_processor_power_exit(pr);
226 return result;
227}
228
229static int acpi_processor_start(struct device *dev)
230{
231 struct acpi_device *device;
232
233 if (acpi_bus_get_device(ACPI_HANDLE(dev), &device))
234 return -ENODEV;
235
236 return __acpi_processor_start(device);
237}
238
239static int acpi_processor_stop(struct device *dev)
240{
241 struct acpi_device *device;
242 struct acpi_processor *pr;
243
244 if (acpi_bus_get_device(ACPI_HANDLE(dev), &device))
245 return 0;
246
247 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
248 acpi_processor_notify);
249
250 pr = acpi_driver_data(device);
251 if (!pr)
252 return 0;
253
254 acpi_processor_power_exit(pr);
255
256 if (pr->cdev) {
257 sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
258 sysfs_remove_link(&pr->cdev->device.kobj, "device");
259 thermal_cooling_device_unregister(pr->cdev);
260 pr->cdev = NULL;
261 }
262 return 0;
263}
264
265
266
267
268
269
270
271static int __init acpi_processor_driver_init(void)
272{
273 int result = 0;
274
275 if (acpi_disabled)
276 return 0;
277
278 result = driver_register(&acpi_processor_driver);
279 if (result < 0)
280 return result;
281
282 acpi_processor_syscore_init();
283 register_hotcpu_notifier(&acpi_cpu_notifier);
284 acpi_thermal_cpufreq_init();
285 acpi_processor_ppc_init();
286 acpi_processor_throttling_init();
287 return 0;
288}
289
290static void __exit acpi_processor_driver_exit(void)
291{
292 if (acpi_disabled)
293 return;
294
295 acpi_processor_ppc_exit();
296 acpi_thermal_cpufreq_exit();
297 unregister_hotcpu_notifier(&acpi_cpu_notifier);
298 acpi_processor_syscore_exit();
299 driver_unregister(&acpi_processor_driver);
300}
301
302module_init(acpi_processor_driver_init);
303module_exit(acpi_processor_driver_exit);
304
305MODULE_ALIAS("processor");
306
