Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
4 : : *
5 : : * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 : : */
7 : :
8 : : #include <linux/module.h>
9 : : #include <linux/init.h>
10 : : #include <linux/ioport.h>
11 : : #include <linux/kernel.h>
12 : : #include <linux/list.h>
13 : : #include <linux/sched.h>
14 : : #include <linux/pm.h>
15 : : #include <linux/device.h>
16 : : #include <linux/proc_fs.h>
17 : : #include <linux/acpi.h>
18 : : #include <linux/slab.h>
19 : : #include <linux/regulator/machine.h>
20 : : #include <linux/workqueue.h>
21 : : #include <linux/reboot.h>
22 : : #include <linux/delay.h>
23 : : #ifdef CONFIG_X86
24 : : #include <asm/mpspec.h>
25 : : #include <linux/dmi.h>
26 : : #endif
27 : : #include <linux/acpi_iort.h>
28 : : #include <linux/pci.h>
29 : : #include <acpi/apei.h>
30 : : #include <linux/suspend.h>
31 : :
32 : : #include "internal.h"
33 : :
34 : : #define _COMPONENT ACPI_BUS_COMPONENT
35 : : ACPI_MODULE_NAME("bus");
36 : :
37 : : struct acpi_device *acpi_root;
38 : : struct proc_dir_entry *acpi_root_dir;
39 : : EXPORT_SYMBOL(acpi_root_dir);
40 : :
41 : : #ifdef CONFIG_X86
42 : : #ifdef CONFIG_ACPI_CUSTOM_DSDT
43 : : static inline int set_copy_dsdt(const struct dmi_system_id *id)
44 : : {
45 : : return 0;
46 : : }
47 : : #else
48 : 0 : static int set_copy_dsdt(const struct dmi_system_id *id)
49 : : {
50 : 0 : printk(KERN_NOTICE "%s detected - "
51 : : "force copy of DSDT to local memory\n", id->ident);
52 : 0 : acpi_gbl_copy_dsdt_locally = 1;
53 : 0 : return 0;
54 : : }
55 : : #endif
56 : :
57 : : static const struct dmi_system_id dsdt_dmi_table[] __initconst = {
58 : : /*
59 : : * Invoke DSDT corruption work-around on all Toshiba Satellite.
60 : : * https://bugzilla.kernel.org/show_bug.cgi?id=14679
61 : : */
62 : : {
63 : : .callback = set_copy_dsdt,
64 : : .ident = "TOSHIBA Satellite",
65 : : .matches = {
66 : : DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
67 : : DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
68 : : },
69 : : },
70 : : {}
71 : : };
72 : : #endif
73 : :
74 : : /* --------------------------------------------------------------------------
75 : : Device Management
76 : : -------------------------------------------------------------------------- */
77 : :
78 : 1870 : acpi_status acpi_bus_get_status_handle(acpi_handle handle,
79 : : unsigned long long *sta)
80 : : {
81 : 1870 : acpi_status status;
82 : :
83 : 616 : status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
84 [ + + + + ]: 1870 : if (ACPI_SUCCESS(status))
85 : : return AE_OK;
86 : :
87 [ + - + - ]: 1375 : if (status == AE_NOT_FOUND) {
88 : 1375 : *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
89 : : ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
90 : 451 : return AE_OK;
91 : : }
92 : : return status;
93 : : }
94 : : EXPORT_SYMBOL_GPL(acpi_bus_get_status_handle);
95 : :
96 : 1254 : int acpi_bus_get_status(struct acpi_device *device)
97 : : {
98 : 1254 : acpi_status status;
99 : 1254 : unsigned long long sta;
100 : :
101 [ - + ]: 1254 : if (acpi_device_always_present(device)) {
102 : 0 : acpi_set_device_status(device, ACPI_STA_DEFAULT);
103 : 0 : return 0;
104 : : }
105 : :
106 : : /* Battery devices must have their deps met before calling _STA */
107 [ - + - - ]: 1254 : if (acpi_device_is_battery(device) && device->dep_unmet) {
108 : 0 : acpi_set_device_status(device, 0);
109 : 0 : return 0;
110 : : }
111 : :
112 : 1254 : status = acpi_bus_get_status_handle(device->handle, &sta);
113 : 924 : if (ACPI_FAILURE(status))
114 : : return -ENODEV;
115 : :
116 : 1254 : acpi_set_device_status(device, sta);
117 : :
118 : 1254 : if (device->status.functional && !device->status.present) {
119 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
120 : : "functional but not present;\n",
121 : 1254 : device->pnp.bus_id, (u32)sta));
122 : : }
123 : :
124 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
125 : 1254 : device->pnp.bus_id, (u32)sta));
126 : 1254 : return 0;
127 : : }
128 : : EXPORT_SYMBOL(acpi_bus_get_status);
129 : :
130 : 0 : void acpi_bus_private_data_handler(acpi_handle handle,
131 : : void *context)
132 : : {
133 : 0 : return;
134 : : }
135 : : EXPORT_SYMBOL(acpi_bus_private_data_handler);
136 : :
137 : 0 : int acpi_bus_attach_private_data(acpi_handle handle, void *data)
138 : : {
139 : 0 : acpi_status status;
140 : :
141 : 0 : status = acpi_attach_data(handle,
142 : : acpi_bus_private_data_handler, data);
143 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
144 : 0 : acpi_handle_debug(handle, "Error attaching device data\n");
145 : 0 : return -ENODEV;
146 : : }
147 : :
148 : : return 0;
149 : : }
150 : : EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
151 : :
152 : 0 : int acpi_bus_get_private_data(acpi_handle handle, void **data)
153 : : {
154 : 0 : acpi_status status;
155 : :
156 [ # # ]: 0 : if (!data)
157 : : return -EINVAL;
158 : :
159 : 0 : status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
160 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
161 : 0 : acpi_handle_debug(handle, "No context for object\n");
162 : 0 : return -ENODEV;
163 : : }
164 : :
165 : : return 0;
166 : : }
167 : : EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
168 : :
169 : 0 : void acpi_bus_detach_private_data(acpi_handle handle)
170 : : {
171 : 0 : acpi_detach_data(handle, acpi_bus_private_data_handler);
172 : 0 : }
173 : : EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
174 : :
175 : 0 : static void acpi_print_osc_error(acpi_handle handle,
176 : : struct acpi_osc_context *context, char *error)
177 : : {
178 : : int i;
179 : :
180 : : acpi_handle_debug(handle, "(%s): %s\n", context->uuid_str, error);
181 : :
182 : : pr_debug("_OSC request data:");
183 [ # # # # : 0 : for (i = 0; i < context->cap.length; i += sizeof(u32))
# # # # ]
184 : 0 : pr_debug(" %x", *((u32 *)(context->cap.pointer + i)));
185 : :
186 : 0 : pr_debug("\n");
187 : : }
188 : :
189 : 22 : acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
190 : : {
191 : 22 : acpi_status status;
192 : 22 : struct acpi_object_list input;
193 : 22 : union acpi_object in_params[4];
194 : 22 : union acpi_object *out_obj;
195 : 22 : guid_t guid;
196 : 22 : u32 errors;
197 : 22 : struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
198 : :
199 [ + - ]: 22 : if (!context)
200 : : return AE_ERROR;
201 [ + - ]: 22 : if (guid_parse(context->uuid_str, &guid))
202 : : return AE_ERROR;
203 : 22 : context->ret.length = ACPI_ALLOCATE_BUFFER;
204 : 22 : context->ret.pointer = NULL;
205 : :
206 : : /* Setting up input parameters */
207 : 22 : input.count = 4;
208 : 22 : input.pointer = in_params;
209 : 22 : in_params[0].type = ACPI_TYPE_BUFFER;
210 : 22 : in_params[0].buffer.length = 16;
211 : 22 : in_params[0].buffer.pointer = (u8 *)&guid;
212 : 22 : in_params[1].type = ACPI_TYPE_INTEGER;
213 : 22 : in_params[1].integer.value = context->rev;
214 : 22 : in_params[2].type = ACPI_TYPE_INTEGER;
215 : 22 : in_params[2].integer.value = context->cap.length/sizeof(u32);
216 : 22 : in_params[3].type = ACPI_TYPE_BUFFER;
217 : 22 : in_params[3].buffer.length = context->cap.length;
218 : 22 : in_params[3].buffer.pointer = context->cap.pointer;
219 : :
220 : 22 : status = acpi_evaluate_object(handle, "_OSC", &input, &output);
221 [ - + ]: 22 : if (ACPI_FAILURE(status))
222 : : return status;
223 : :
224 [ # # ]: 0 : if (!output.length)
225 : : return AE_NULL_OBJECT;
226 : :
227 : 0 : out_obj = output.pointer;
228 [ # # ]: 0 : if (out_obj->type != ACPI_TYPE_BUFFER
229 [ # # ]: 0 : || out_obj->buffer.length != context->cap.length) {
230 : 0 : acpi_print_osc_error(handle, context,
231 : : "_OSC evaluation returned wrong type");
232 : 0 : status = AE_TYPE;
233 : 0 : goto out_kfree;
234 : : }
235 : : /* Need to ignore the bit0 in result code */
236 : 0 : errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
237 [ # # ]: 0 : if (errors) {
238 [ # # ]: 0 : if (errors & OSC_REQUEST_ERROR)
239 : : acpi_print_osc_error(handle, context,
240 : : "_OSC request failed");
241 [ # # ]: 0 : if (errors & OSC_INVALID_UUID_ERROR)
242 : : acpi_print_osc_error(handle, context,
243 : : "_OSC invalid UUID");
244 [ # # ]: 0 : if (errors & OSC_INVALID_REVISION_ERROR)
245 : : acpi_print_osc_error(handle, context,
246 : : "_OSC invalid revision");
247 [ # # ]: 0 : if (errors & OSC_CAPABILITIES_MASK_ERROR) {
248 : 0 : if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
249 [ # # ]: 0 : & OSC_QUERY_ENABLE)
250 : 0 : goto out_success;
251 : 0 : status = AE_SUPPORT;
252 : 0 : goto out_kfree;
253 : : }
254 : 0 : status = AE_ERROR;
255 : 0 : goto out_kfree;
256 : : }
257 : 0 : out_success:
258 : 0 : context->ret.length = out_obj->buffer.length;
259 : 0 : context->ret.pointer = kmemdup(out_obj->buffer.pointer,
260 : : context->ret.length, GFP_KERNEL);
261 [ # # ]: 0 : if (!context->ret.pointer) {
262 : 0 : status = AE_NO_MEMORY;
263 : 0 : goto out_kfree;
264 : : }
265 : : status = AE_OK;
266 : :
267 : 0 : out_kfree:
268 : 0 : kfree(output.pointer);
269 [ # # ]: 0 : if (status != AE_OK)
270 : 0 : context->ret.pointer = NULL;
271 : : return status;
272 : : }
273 : : EXPORT_SYMBOL(acpi_run_osc);
274 : :
275 : : bool osc_sb_apei_support_acked;
276 : :
277 : : /*
278 : : * ACPI 6.0 Section 8.4.4.2 Idle State Coordination
279 : : * OSPM supports platform coordinated low power idle(LPI) states
280 : : */
281 : : bool osc_pc_lpi_support_confirmed;
282 : : EXPORT_SYMBOL_GPL(osc_pc_lpi_support_confirmed);
283 : :
284 : : static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
285 : 11 : static void acpi_bus_osc_support(void)
286 : : {
287 : 11 : u32 capbuf[2];
288 : 11 : struct acpi_osc_context context = {
289 : : .uuid_str = sb_uuid_str,
290 : : .rev = 1,
291 : : .cap.length = 8,
292 : : .cap.pointer = capbuf,
293 : : };
294 : 11 : acpi_handle handle;
295 : :
296 : 11 : capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
297 : 11 : capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
298 : 11 : if (IS_ENABLED(CONFIG_ACPI_PROCESSOR_AGGREGATOR))
299 : : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
300 : 11 : if (IS_ENABLED(CONFIG_ACPI_PROCESSOR))
301 : 11 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
302 : :
303 : 11 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
304 : 11 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;
305 : :
306 : : #ifdef CONFIG_X86
307 [ - + ]: 11 : if (boot_cpu_has(X86_FEATURE_HWP)) {
308 : 0 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_SUPPORT;
309 : 0 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPCV2_SUPPORT;
310 : : }
311 : : #endif
312 : :
313 : 11 : if (IS_ENABLED(CONFIG_SCHED_MC_PRIO))
314 : 11 : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_DIVERSE_HIGH_SUPPORT;
315 : :
316 : 11 : if (!ghes_disable)
317 : : capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
318 [ - + ]: 11 : if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
319 : 0 : return;
320 [ - + ]: 11 : if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
321 : 0 : u32 *capbuf_ret = context.ret.pointer;
322 [ # # ]: 0 : if (context.ret.length > OSC_SUPPORT_DWORD) {
323 : 0 : osc_sb_apei_support_acked =
324 : 0 : capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
325 : 0 : osc_pc_lpi_support_confirmed =
326 : 0 : capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
327 : : }
328 : 0 : kfree(context.ret.pointer);
329 : : }
330 : : /* do we need to check other returned cap? Sounds no */
331 : : }
332 : :
333 : : /* --------------------------------------------------------------------------
334 : : Notification Handling
335 : : -------------------------------------------------------------------------- */
336 : :
337 : : /**
338 : : * acpi_bus_notify
339 : : * ---------------
340 : : * Callback for all 'system-level' device notifications (values 0x00-0x7F).
341 : : */
342 : 0 : static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
343 : : {
344 : 0 : struct acpi_device *adev;
345 : 0 : struct acpi_driver *driver;
346 : 0 : u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
347 : 0 : bool hotplug_event = false;
348 : :
349 [ # # # # : 0 : switch (type) {
# # # ]
350 : : case ACPI_NOTIFY_BUS_CHECK:
351 : : acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
352 : : hotplug_event = true;
353 : : break;
354 : :
355 : : case ACPI_NOTIFY_DEVICE_CHECK:
356 : : acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
357 : : hotplug_event = true;
358 : : break;
359 : :
360 : : case ACPI_NOTIFY_DEVICE_WAKE:
361 : 0 : acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
362 : 0 : break;
363 : :
364 : : case ACPI_NOTIFY_EJECT_REQUEST:
365 : : acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
366 : : hotplug_event = true;
367 : : break;
368 : :
369 : : case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
370 : 0 : acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
371 : : /* TBD: Exactly what does 'light' mean? */
372 : 0 : break;
373 : :
374 : 0 : case ACPI_NOTIFY_FREQUENCY_MISMATCH:
375 : 0 : acpi_handle_err(handle, "Device cannot be configured due "
376 : : "to a frequency mismatch\n");
377 : 0 : break;
378 : :
379 : 0 : case ACPI_NOTIFY_BUS_MODE_MISMATCH:
380 : 0 : acpi_handle_err(handle, "Device cannot be configured due "
381 : : "to a bus mode mismatch\n");
382 : 0 : break;
383 : :
384 : 0 : case ACPI_NOTIFY_POWER_FAULT:
385 : 0 : acpi_handle_err(handle, "Device has suffered a power fault\n");
386 : 0 : break;
387 : :
388 : : default:
389 : 0 : acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
390 : 0 : break;
391 : : }
392 : :
393 : 0 : adev = acpi_bus_get_acpi_device(handle);
394 [ # # ]: 0 : if (!adev)
395 : 0 : goto err;
396 : :
397 : 0 : driver = adev->driver;
398 [ # # # # ]: 0 : if (driver && driver->ops.notify &&
399 [ # # ]: 0 : (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
400 : 0 : driver->ops.notify(adev, type);
401 : :
402 [ # # ]: 0 : if (!hotplug_event) {
403 : 0 : acpi_bus_put_acpi_device(adev);
404 : 0 : return;
405 : : }
406 : :
407 [ # # ]: 0 : if (ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
408 : : return;
409 : :
410 : 0 : acpi_bus_put_acpi_device(adev);
411 : :
412 : 0 : err:
413 : 0 : acpi_evaluate_ost(handle, type, ost_code, NULL);
414 : : }
415 : :
416 : 0 : static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
417 : : {
418 : 0 : struct acpi_device *device = data;
419 : :
420 : 0 : device->driver->ops.notify(device, event);
421 : 0 : }
422 : :
423 : 0 : static void acpi_device_notify_fixed(void *data)
424 : : {
425 : 0 : struct acpi_device *device = data;
426 : :
427 : : /* Fixed hardware devices have no handles */
428 : 0 : acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
429 : 0 : }
430 : :
431 : 0 : static u32 acpi_device_fixed_event(void *data)
432 : : {
433 : 0 : acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
434 : 0 : return ACPI_INTERRUPT_HANDLED;
435 : : }
436 : :
437 : 11 : static int acpi_device_install_notify_handler(struct acpi_device *device)
438 : : {
439 : 11 : acpi_status status;
440 : :
441 [ + - ]: 11 : if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
442 : 11 : status =
443 : 11 : acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
444 : : acpi_device_fixed_event,
445 : : device);
446 [ # # ]: 0 : else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
447 : 0 : status =
448 : 0 : acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
449 : : acpi_device_fixed_event,
450 : : device);
451 : : else
452 : 0 : status = acpi_install_notify_handler(device->handle,
453 : : ACPI_DEVICE_NOTIFY,
454 : : acpi_device_notify,
455 : : device);
456 : :
457 [ - + ]: 11 : if (ACPI_FAILURE(status))
458 : 0 : return -EINVAL;
459 : : return 0;
460 : : }
461 : :
462 : : static void acpi_device_remove_notify_handler(struct acpi_device *device)
463 : : {
464 : : if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
465 : : acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
466 : : acpi_device_fixed_event);
467 : : else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
468 : : acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
469 : : acpi_device_fixed_event);
470 : : else
471 : : acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
472 : : acpi_device_notify);
473 : : }
474 : :
475 : : /* Handle events targeting \_SB device (at present only graceful shutdown) */
476 : :
477 : : #define ACPI_SB_NOTIFY_SHUTDOWN_REQUEST 0x81
478 : : #define ACPI_SB_INDICATE_INTERVAL 10000
479 : :
480 : 0 : static void sb_notify_work(struct work_struct *dummy)
481 : : {
482 : 0 : acpi_handle sb_handle;
483 : :
484 : 0 : orderly_poweroff(true);
485 : :
486 : : /*
487 : : * After initiating graceful shutdown, the ACPI spec requires OSPM
488 : : * to evaluate _OST method once every 10seconds to indicate that
489 : : * the shutdown is in progress
490 : : */
491 : 0 : acpi_get_handle(NULL, "\\_SB", &sb_handle);
492 : 0 : while (1) {
493 : 0 : pr_info("Graceful shutdown in progress.\n");
494 : 0 : acpi_evaluate_ost(sb_handle, ACPI_OST_EC_OSPM_SHUTDOWN,
495 : : ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS, NULL);
496 : 0 : msleep(ACPI_SB_INDICATE_INTERVAL);
497 : : }
498 : : }
499 : :
500 : 0 : static void acpi_sb_notify(acpi_handle handle, u32 event, void *data)
501 : : {
502 : 0 : static DECLARE_WORK(acpi_sb_work, sb_notify_work);
503 : :
504 [ # # ]: 0 : if (event == ACPI_SB_NOTIFY_SHUTDOWN_REQUEST) {
505 [ # # ]: 0 : if (!work_busy(&acpi_sb_work))
506 : 0 : schedule_work(&acpi_sb_work);
507 : : } else
508 : 0 : pr_warn("event %x is not supported by \\_SB device\n", event);
509 : 0 : }
510 : :
511 : 11 : static int __init acpi_setup_sb_notify_handler(void)
512 : : {
513 : 11 : acpi_handle sb_handle;
514 : :
515 [ + - ]: 11 : if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &sb_handle)))
516 : : return -ENXIO;
517 : :
518 [ - + ]: 11 : if (ACPI_FAILURE(acpi_install_notify_handler(sb_handle, ACPI_DEVICE_NOTIFY,
519 : : acpi_sb_notify, NULL)))
520 : 0 : return -EINVAL;
521 : :
522 : : return 0;
523 : : }
524 : :
525 : : /* --------------------------------------------------------------------------
526 : : Device Matching
527 : : -------------------------------------------------------------------------- */
528 : :
529 : : /**
530 : : * acpi_get_first_physical_node - Get first physical node of an ACPI device
531 : : * @adev: ACPI device in question
532 : : *
533 : : * Return: First physical node of ACPI device @adev
534 : : */
535 : 198 : struct device *acpi_get_first_physical_node(struct acpi_device *adev)
536 : : {
537 : 198 : struct mutex *physical_node_lock = &adev->physical_node_lock;
538 : 198 : struct device *phys_dev;
539 : :
540 : 198 : mutex_lock(physical_node_lock);
541 [ + + ]: 198 : if (list_empty(&adev->physical_node_list)) {
542 : : phys_dev = NULL;
543 : : } else {
544 : 176 : const struct acpi_device_physical_node *node;
545 : :
546 : 176 : node = list_first_entry(&adev->physical_node_list,
547 : : struct acpi_device_physical_node, node);
548 : :
549 : 176 : phys_dev = node->dev;
550 : : }
551 : 198 : mutex_unlock(physical_node_lock);
552 : 198 : return phys_dev;
553 : : }
554 : :
555 : 154 : static struct acpi_device *acpi_primary_dev_companion(struct acpi_device *adev,
556 : : const struct device *dev)
557 : : {
558 : 154 : const struct device *phys_dev = acpi_get_first_physical_node(adev);
559 : :
560 [ - + - - ]: 154 : return phys_dev && phys_dev == dev ? adev : NULL;
561 : : }
562 : :
563 : : /**
564 : : * acpi_device_is_first_physical_node - Is given dev first physical node
565 : : * @adev: ACPI companion device
566 : : * @dev: Physical device to check
567 : : *
568 : : * Function checks if given @dev is the first physical devices attached to
569 : : * the ACPI companion device. This distinction is needed in some cases
570 : : * where the same companion device is shared between many physical devices.
571 : : *
572 : : * Note that the caller have to provide valid @adev pointer.
573 : : */
574 : 0 : bool acpi_device_is_first_physical_node(struct acpi_device *adev,
575 : : const struct device *dev)
576 : : {
577 : 0 : return !!acpi_primary_dev_companion(adev, dev);
578 : : }
579 : :
580 : : /*
581 : : * acpi_companion_match() - Can we match via ACPI companion device
582 : : * @dev: Device in question
583 : : *
584 : : * Check if the given device has an ACPI companion and if that companion has
585 : : * a valid list of PNP IDs, and if the device is the first (primary) physical
586 : : * device associated with it. Return the companion pointer if that's the case
587 : : * or NULL otherwise.
588 : : *
589 : : * If multiple physical devices are attached to a single ACPI companion, we need
590 : : * to be careful. The usage scenario for this kind of relationship is that all
591 : : * of the physical devices in question use resources provided by the ACPI
592 : : * companion. A typical case is an MFD device where all the sub-devices share
593 : : * the parent's ACPI companion. In such cases we can only allow the primary
594 : : * (first) physical device to be matched with the help of the companion's PNP
595 : : * IDs.
596 : : *
597 : : * Additional physical devices sharing the ACPI companion can still use
598 : : * resources available from it but they will be matched normally using functions
599 : : * provided by their bus types (and analogously for their modalias).
600 : : */
601 : 671 : struct acpi_device *acpi_companion_match(const struct device *dev)
602 : : {
603 : 671 : struct acpi_device *adev;
604 : :
605 [ + + ]: 671 : adev = ACPI_COMPANION(dev);
606 [ + - ]: 154 : if (!adev)
607 : : return NULL;
608 : :
609 [ + - ]: 154 : if (list_empty(&adev->pnp.ids))
610 : : return NULL;
611 : :
612 : 154 : return acpi_primary_dev_companion(adev, dev);
613 : : }
614 : :
615 : : /**
616 : : * acpi_of_match_device - Match device object using the "compatible" property.
617 : : * @adev: ACPI device object to match.
618 : : * @of_match_table: List of device IDs to match against.
619 : : * @of_id: OF ID if matched
620 : : *
621 : : * If @dev has an ACPI companion which has ACPI_DT_NAMESPACE_HID in its list of
622 : : * identifiers and a _DSD object with the "compatible" property, use that
623 : : * property to match against the given list of identifiers.
624 : : */
625 : 726 : static bool acpi_of_match_device(struct acpi_device *adev,
626 : : const struct of_device_id *of_match_table,
627 : : const struct of_device_id **of_id)
628 : : {
629 : 726 : const union acpi_object *of_compatible, *obj;
630 : 726 : int i, nval;
631 : :
632 [ + + ]: 726 : if (!adev)
633 : : return false;
634 : :
635 : 198 : of_compatible = adev->data.of_compatible;
636 [ - + ]: 198 : if (!of_match_table || !of_compatible)
637 : : return false;
638 : :
639 [ # # ]: 0 : if (of_compatible->type == ACPI_TYPE_PACKAGE) {
640 : 0 : nval = of_compatible->package.count;
641 : 0 : obj = of_compatible->package.elements;
642 : : } else { /* Must be ACPI_TYPE_STRING. */
643 : : nval = 1;
644 : : obj = of_compatible;
645 : : }
646 : : /* Now we can look for the driver DT compatible strings */
647 [ # # ]: 0 : for (i = 0; i < nval; i++, obj++) {
648 : : const struct of_device_id *id;
649 : :
650 [ # # ]: 0 : for (id = of_match_table; id->compatible[0]; id++)
651 [ # # ]: 0 : if (!strcasecmp(obj->string.pointer, id->compatible)) {
652 [ # # ]: 0 : if (of_id)
653 : 0 : *of_id = id;
654 : 0 : return true;
655 : : }
656 : : }
657 : :
658 : : return false;
659 : : }
660 : :
661 : : static bool acpi_of_modalias(struct acpi_device *adev,
662 : : char *modalias, size_t len)
663 : : {
664 : : const union acpi_object *of_compatible;
665 : : const union acpi_object *obj;
666 : : const char *str, *chr;
667 : :
668 : : of_compatible = adev->data.of_compatible;
669 : : if (!of_compatible)
670 : : return false;
671 : :
672 : : if (of_compatible->type == ACPI_TYPE_PACKAGE)
673 : : obj = of_compatible->package.elements;
674 : : else /* Must be ACPI_TYPE_STRING. */
675 : : obj = of_compatible;
676 : :
677 : : str = obj->string.pointer;
678 : : chr = strchr(str, ',');
679 : : strlcpy(modalias, chr ? chr + 1 : str, len);
680 : :
681 : : return true;
682 : : }
683 : :
684 : : /**
685 : : * acpi_set_modalias - Set modalias using "compatible" property or supplied ID
686 : : * @adev: ACPI device object to match
687 : : * @default_id: ID string to use as default if no compatible string found
688 : : * @modalias: Pointer to buffer that modalias value will be copied into
689 : : * @len: Length of modalias buffer
690 : : *
691 : : * This is a counterpart of of_modalias_node() for struct acpi_device objects.
692 : : * If there is a compatible string for @adev, it will be copied to @modalias
693 : : * with the vendor prefix stripped; otherwise, @default_id will be used.
694 : : */
695 : 0 : void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
696 : : char *modalias, size_t len)
697 : : {
698 [ # # ]: 0 : if (!acpi_of_modalias(adev, modalias, len))
699 : 0 : strlcpy(modalias, default_id, len);
700 : 0 : }
701 : : EXPORT_SYMBOL_GPL(acpi_set_modalias);
702 : :
703 : : static bool __acpi_match_device_cls(const struct acpi_device_id *id,
704 : : struct acpi_hardware_id *hwid)
705 : : {
706 : : int i, msk, byte_shift;
707 : : char buf[3];
708 : :
709 : : if (!id->cls)
710 : : return false;
711 : :
712 : : /* Apply class-code bitmask, before checking each class-code byte */
713 : : for (i = 1; i <= 3; i++) {
714 : : byte_shift = 8 * (3 - i);
715 : : msk = (id->cls_msk >> byte_shift) & 0xFF;
716 : : if (!msk)
717 : : continue;
718 : :
719 : : sprintf(buf, "%02x", (id->cls >> byte_shift) & msk);
720 : : if (strncmp(buf, &hwid->id[(i - 1) * 2], 2))
721 : : return false;
722 : : }
723 : : return true;
724 : : }
725 : :
726 : 20284 : static bool __acpi_match_device(struct acpi_device *device,
727 : : const struct acpi_device_id *acpi_ids,
728 : : const struct of_device_id *of_ids,
729 : : const struct acpi_device_id **acpi_id,
730 : : const struct of_device_id **of_id)
731 : : {
732 : 20284 : const struct acpi_device_id *id;
733 : 20284 : struct acpi_hardware_id *hwid;
734 : :
735 : : /*
736 : : * If the device is not present, it is unnecessary to load device
737 : : * driver for it.
738 : : */
739 [ + + + + ]: 20284 : if (!device || !device->status.present)
740 : : return false;
741 : :
742 [ + + ]: 28644 : list_for_each_entry(hwid, &device->pnp.ids, list) {
743 : : /* First, check the ACPI/PNP IDs provided by the caller. */
744 [ + - ]: 8723 : if (acpi_ids) {
745 [ + + - + ]: 19954 : for (id = acpi_ids; id->id[0] || id->cls; id++) {
746 [ + - + + ]: 11352 : if (id->id[0] && !strcmp((char *)id->id, hwid->id))
747 : 121 : goto out_acpi_match;
748 [ - + - - ]: 11231 : if (id->cls && __acpi_match_device_cls(id, hwid))
749 : 0 : goto out_acpi_match;
750 : : }
751 : : }
752 : :
753 : : /*
754 : : * Next, check ACPI_DT_NAMESPACE_HID and try to match the
755 : : * "compatible" property if found.
756 : : */
757 [ - + ]: 8602 : if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id))
758 : 0 : return acpi_of_match_device(device, of_ids, of_id);
759 : : }
760 : : return false;
761 : :
762 : 121 : out_acpi_match:
763 [ - + ]: 121 : if (acpi_id)
764 : 0 : *acpi_id = id;
765 : : return true;
766 : : }
767 : :
768 : : /**
769 : : * acpi_match_device - Match a struct device against a given list of ACPI IDs
770 : : * @ids: Array of struct acpi_device_id object to match against.
771 : : * @dev: The device structure to match.
772 : : *
773 : : * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
774 : : * object for that handle and use that object to match against a given list of
775 : : * device IDs.
776 : : *
777 : : * Return a pointer to the first matching ID on success or %NULL on failure.
778 : : */
779 : 0 : const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
780 : : const struct device *dev)
781 : : {
782 : 0 : const struct acpi_device_id *id = NULL;
783 : :
784 : 0 : __acpi_match_device(acpi_companion_match(dev), ids, NULL, &id, NULL);
785 : 0 : return id;
786 : : }
787 : : EXPORT_SYMBOL_GPL(acpi_match_device);
788 : :
789 : : static const void *acpi_of_device_get_match_data(const struct device *dev)
790 : : {
791 : : struct acpi_device *adev = ACPI_COMPANION(dev);
792 : : const struct of_device_id *match = NULL;
793 : :
794 : : if (!acpi_of_match_device(adev, dev->driver->of_match_table, &match))
795 : : return NULL;
796 : :
797 : : return match->data;
798 : : }
799 : :
800 : 0 : const void *acpi_device_get_match_data(const struct device *dev)
801 : : {
802 : 0 : const struct acpi_device_id *match;
803 : :
804 [ # # ]: 0 : if (!dev->driver->acpi_match_table)
805 : 0 : return acpi_of_device_get_match_data(dev);
806 : :
807 : 0 : match = acpi_match_device(dev->driver->acpi_match_table, dev);
808 [ # # ]: 0 : if (!match)
809 : : return NULL;
810 : :
811 : 0 : return (const void *)match->driver_data;
812 : : }
813 : : EXPORT_SYMBOL_GPL(acpi_device_get_match_data);
814 : :
815 : 20119 : int acpi_match_device_ids(struct acpi_device *device,
816 : : const struct acpi_device_id *ids)
817 : : {
818 [ + + + + ]: 20119 : return __acpi_match_device(device, ids, NULL, NULL, NULL) ? 0 : -ENOENT;
819 : : }
820 : : EXPORT_SYMBOL(acpi_match_device_ids);
821 : :
822 : 891 : bool acpi_driver_match_device(struct device *dev,
823 : : const struct device_driver *drv)
824 : : {
825 [ + + ]: 891 : if (!drv->acpi_match_table)
826 [ + + ]: 726 : return acpi_of_match_device(ACPI_COMPANION(dev),
827 : : drv->of_match_table,
828 : : NULL);
829 : :
830 : 165 : return __acpi_match_device(acpi_companion_match(dev),
831 : : drv->acpi_match_table, drv->of_match_table,
832 : : NULL, NULL);
833 : : }
834 : : EXPORT_SYMBOL_GPL(acpi_driver_match_device);
835 : :
836 : : /* --------------------------------------------------------------------------
837 : : ACPI Driver Management
838 : : -------------------------------------------------------------------------- */
839 : :
840 : : /**
841 : : * acpi_bus_register_driver - register a driver with the ACPI bus
842 : : * @driver: driver being registered
843 : : *
844 : : * Registers a driver with the ACPI bus. Searches the namespace for all
845 : : * devices that match the driver's criteria and binds. Returns zero for
846 : : * success or a negative error status for failure.
847 : : */
848 : 88 : int acpi_bus_register_driver(struct acpi_driver *driver)
849 : : {
850 : 88 : int ret;
851 : :
852 [ + - ]: 88 : if (acpi_disabled)
853 : : return -ENODEV;
854 : 88 : driver->drv.name = driver->name;
855 : 88 : driver->drv.bus = &acpi_bus_type;
856 : 88 : driver->drv.owner = driver->owner;
857 : :
858 : 88 : ret = driver_register(&driver->drv);
859 : 88 : return ret;
860 : : }
861 : :
862 : : EXPORT_SYMBOL(acpi_bus_register_driver);
863 : :
864 : : /**
865 : : * acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
866 : : * @driver: driver to unregister
867 : : *
868 : : * Unregisters a driver with the ACPI bus. Searches the namespace for all
869 : : * devices that match the driver's criteria and unbinds.
870 : : */
871 : 11 : void acpi_bus_unregister_driver(struct acpi_driver *driver)
872 : : {
873 : 11 : driver_unregister(&driver->drv);
874 : 11 : }
875 : :
876 : : EXPORT_SYMBOL(acpi_bus_unregister_driver);
877 : :
878 : : /* --------------------------------------------------------------------------
879 : : ACPI Bus operations
880 : : -------------------------------------------------------------------------- */
881 : :
882 : 5104 : static int acpi_bus_match(struct device *dev, struct device_driver *drv)
883 : : {
884 : 5104 : struct acpi_device *acpi_dev = to_acpi_device(dev);
885 : 5104 : struct acpi_driver *acpi_drv = to_acpi_driver(drv);
886 : :
887 : 5104 : return acpi_dev->flags.match_driver
888 [ + + ]: 5104 : && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
889 : : }
890 : :
891 : 3487 : static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
892 : : {
893 : 3487 : return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
894 : : }
895 : :
896 : 22 : static int acpi_device_probe(struct device *dev)
897 : : {
898 : 22 : struct acpi_device *acpi_dev = to_acpi_device(dev);
899 : 22 : struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
900 : 22 : int ret;
901 : :
902 [ - + - - ]: 22 : if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
903 : : return -EINVAL;
904 : :
905 [ + - ]: 22 : if (!acpi_drv->ops.add)
906 : : return -ENOSYS;
907 : :
908 : 22 : ret = acpi_drv->ops.add(acpi_dev);
909 [ + + ]: 22 : if (ret)
910 : : return ret;
911 : :
912 : 11 : acpi_dev->driver = acpi_drv;
913 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
914 : : "Driver [%s] successfully bound to device [%s]\n",
915 : 11 : acpi_drv->name, acpi_dev->pnp.bus_id));
916 : :
917 [ + - ]: 11 : if (acpi_drv->ops.notify) {
918 : 11 : ret = acpi_device_install_notify_handler(acpi_dev);
919 [ - + ]: 11 : if (ret) {
920 [ # # ]: 0 : if (acpi_drv->ops.remove)
921 : 0 : acpi_drv->ops.remove(acpi_dev);
922 : :
923 : 0 : acpi_dev->driver = NULL;
924 : 0 : acpi_dev->driver_data = NULL;
925 : 0 : return ret;
926 : : }
927 : : }
928 : :
929 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
930 : 11 : acpi_drv->name, acpi_dev->pnp.bus_id));
931 : 11 : get_device(dev);
932 : 11 : return 0;
933 : : }
934 : :
935 : 0 : static int acpi_device_remove(struct device *dev)
936 : : {
937 : 0 : struct acpi_device *acpi_dev = to_acpi_device(dev);
938 : 0 : struct acpi_driver *acpi_drv = acpi_dev->driver;
939 : :
940 [ # # ]: 0 : if (acpi_drv) {
941 [ # # ]: 0 : if (acpi_drv->ops.notify)
942 : 0 : acpi_device_remove_notify_handler(acpi_dev);
943 [ # # ]: 0 : if (acpi_drv->ops.remove)
944 : 0 : acpi_drv->ops.remove(acpi_dev);
945 : : }
946 : 0 : acpi_dev->driver = NULL;
947 : 0 : acpi_dev->driver_data = NULL;
948 : :
949 : 0 : put_device(dev);
950 : 0 : return 0;
951 : : }
952 : :
953 : : struct bus_type acpi_bus_type = {
954 : : .name = "acpi",
955 : : .match = acpi_bus_match,
956 : : .probe = acpi_device_probe,
957 : : .remove = acpi_device_remove,
958 : : .uevent = acpi_device_uevent,
959 : : };
960 : :
961 : : /* --------------------------------------------------------------------------
962 : : Initialization/Cleanup
963 : : -------------------------------------------------------------------------- */
964 : :
965 : 11 : static int __init acpi_bus_init_irq(void)
966 : : {
967 : 11 : acpi_status status;
968 : 11 : char *message = NULL;
969 : :
970 : :
971 : : /*
972 : : * Let the system know what interrupt model we are using by
973 : : * evaluating the \_PIC object, if exists.
974 : : */
975 : :
976 [ + - ]: 11 : switch (acpi_irq_model) {
977 : : case ACPI_IRQ_MODEL_PIC:
978 : : message = "PIC";
979 : : break;
980 : : case ACPI_IRQ_MODEL_IOAPIC:
981 : : message = "IOAPIC";
982 : : break;
983 : : case ACPI_IRQ_MODEL_IOSAPIC:
984 : : message = "IOSAPIC";
985 : : break;
986 : : case ACPI_IRQ_MODEL_GIC:
987 : : message = "GIC";
988 : : break;
989 : : case ACPI_IRQ_MODEL_PLATFORM:
990 : : message = "platform specific model";
991 : : break;
992 : 0 : default:
993 : 0 : printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
994 : 0 : return -ENODEV;
995 : : }
996 : :
997 : 11 : printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
998 : :
999 : 11 : status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
1000 [ - + ]: 11 : if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
1001 : 0 : ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
1002 : 0 : return -ENODEV;
1003 : : }
1004 : :
1005 : : return 0;
1006 : : }
1007 : :
1008 : : /**
1009 : : * acpi_early_init - Initialize ACPICA and populate the ACPI namespace.
1010 : : *
1011 : : * The ACPI tables are accessible after this, but the handling of events has not
1012 : : * been initialized and the global lock is not available yet, so AML should not
1013 : : * be executed at this point.
1014 : : *
1015 : : * Doing this before switching the EFI runtime services to virtual mode allows
1016 : : * the EfiBootServices memory to be freed slightly earlier on boot.
1017 : : */
1018 : 11 : void __init acpi_early_init(void)
1019 : : {
1020 : 11 : acpi_status status;
1021 : :
1022 [ + - ]: 11 : if (acpi_disabled)
1023 : : return;
1024 : :
1025 : 11 : printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
1026 : :
1027 : : /* enable workarounds, unless strict ACPI spec. compliance */
1028 [ + - ]: 11 : if (!acpi_strict)
1029 : 11 : acpi_gbl_enable_interpreter_slack = TRUE;
1030 : :
1031 : 11 : acpi_permanent_mmap = true;
1032 : :
1033 : : #ifdef CONFIG_X86
1034 : : /*
1035 : : * If the machine falls into the DMI check table,
1036 : : * DSDT will be copied to memory.
1037 : : * Note that calling dmi_check_system() here on other architectures
1038 : : * would not be OK because only x86 initializes dmi early enough.
1039 : : * Thankfully only x86 systems need such quirks for now.
1040 : : */
1041 : 11 : dmi_check_system(dsdt_dmi_table);
1042 : : #endif
1043 : :
1044 : 11 : status = acpi_reallocate_root_table();
1045 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1046 : 0 : printk(KERN_ERR PREFIX
1047 : : "Unable to reallocate ACPI tables\n");
1048 : 0 : goto error0;
1049 : : }
1050 : :
1051 : 11 : status = acpi_initialize_subsystem();
1052 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1053 : 0 : printk(KERN_ERR PREFIX
1054 : : "Unable to initialize the ACPI Interpreter\n");
1055 : 0 : goto error0;
1056 : : }
1057 : :
1058 : : #ifdef CONFIG_X86
1059 [ - + ]: 11 : if (!acpi_ioapic) {
1060 : : /* compatible (0) means level (3) */
1061 [ # # ]: 0 : if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
1062 : 0 : acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
1063 : 0 : acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
1064 : : }
1065 : : /* Set PIC-mode SCI trigger type */
1066 : 0 : acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
1067 : 0 : (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
1068 : : } else {
1069 : : /*
1070 : : * now that acpi_gbl_FADT is initialized,
1071 : : * update it with result from INT_SRC_OVR parsing
1072 : : */
1073 : 11 : acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
1074 : : }
1075 : : #endif
1076 : : return;
1077 : :
1078 : 0 : error0:
1079 : 0 : disable_acpi();
1080 : : }
1081 : :
1082 : : /**
1083 : : * acpi_subsystem_init - Finalize the early initialization of ACPI.
1084 : : *
1085 : : * Switch over the platform to the ACPI mode (if possible).
1086 : : *
1087 : : * Doing this too early is generally unsafe, but at the same time it needs to be
1088 : : * done before all things that really depend on ACPI. The right spot appears to
1089 : : * be before finalizing the EFI initialization.
1090 : : */
1091 : 11 : void __init acpi_subsystem_init(void)
1092 : : {
1093 : 11 : acpi_status status;
1094 : :
1095 [ + - ]: 11 : if (acpi_disabled)
1096 : : return;
1097 : :
1098 : 11 : status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
1099 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1100 : 0 : printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
1101 : 0 : disable_acpi();
1102 : : } else {
1103 : : /*
1104 : : * If the system is using ACPI then we can be reasonably
1105 : : * confident that any regulators are managed by the firmware
1106 : : * so tell the regulator core it has everything it needs to
1107 : : * know.
1108 : : */
1109 : : regulator_has_full_constraints();
1110 : : }
1111 : : }
1112 : :
1113 : 0 : static acpi_status acpi_bus_table_handler(u32 event, void *table, void *context)
1114 : : {
1115 : 0 : acpi_scan_table_handler(event, table, context);
1116 : :
1117 : 0 : return acpi_sysfs_table_handler(event, table, context);
1118 : : }
1119 : :
1120 : 11 : static int __init acpi_bus_init(void)
1121 : : {
1122 : 11 : int result;
1123 : 11 : acpi_status status;
1124 : :
1125 : 11 : acpi_os_initialize1();
1126 : :
1127 : 11 : status = acpi_load_tables();
1128 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1129 : 0 : printk(KERN_ERR PREFIX
1130 : : "Unable to load the System Description Tables\n");
1131 : 0 : goto error1;
1132 : : }
1133 : :
1134 : : /*
1135 : : * ACPI 2.0 requires the EC driver to be loaded and work before the EC
1136 : : * device is found in the namespace.
1137 : : *
1138 : : * This is accomplished by looking for the ECDT table and getting the EC
1139 : : * parameters out of that.
1140 : : *
1141 : : * Do that before calling acpi_initialize_objects() which may trigger EC
1142 : : * address space accesses.
1143 : : */
1144 : 11 : acpi_ec_ecdt_probe();
1145 : :
1146 : 11 : status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
1147 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1148 : 0 : printk(KERN_ERR PREFIX
1149 : : "Unable to start the ACPI Interpreter\n");
1150 : 0 : goto error1;
1151 : : }
1152 : :
1153 : 11 : status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
1154 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1155 : 0 : printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
1156 : 0 : goto error1;
1157 : : }
1158 : :
1159 : : /* Set capability bits for _OSC under processor scope */
1160 : 11 : acpi_early_processor_osc();
1161 : :
1162 : : /*
1163 : : * _OSC method may exist in module level code,
1164 : : * so it must be run after ACPI_FULL_INITIALIZATION
1165 : : */
1166 : 11 : acpi_bus_osc_support();
1167 : :
1168 : : /*
1169 : : * _PDC control method may load dynamic SSDT tables,
1170 : : * and we need to install the table handler before that.
1171 : : */
1172 : 11 : status = acpi_install_table_handler(acpi_bus_table_handler, NULL);
1173 : :
1174 : 11 : acpi_sysfs_init();
1175 : :
1176 : 11 : acpi_early_processor_set_pdc();
1177 : :
1178 : : /*
1179 : : * Maybe EC region is required at bus_scan/acpi_get_devices. So it
1180 : : * is necessary to enable it as early as possible.
1181 : : */
1182 : 11 : acpi_ec_dsdt_probe();
1183 : :
1184 : 11 : printk(KERN_INFO PREFIX "Interpreter enabled\n");
1185 : :
1186 : : /* Initialize sleep structures */
1187 : 11 : acpi_sleep_init();
1188 : :
1189 : : /*
1190 : : * Get the system interrupt model and evaluate \_PIC.
1191 : : */
1192 : 11 : result = acpi_bus_init_irq();
1193 [ - + ]: 11 : if (result)
1194 : 0 : goto error1;
1195 : :
1196 : : /*
1197 : : * Register the for all standard device notifications.
1198 : : */
1199 : 11 : status =
1200 : 11 : acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
1201 : : &acpi_bus_notify, NULL);
1202 [ - + ]: 11 : if (ACPI_FAILURE(status)) {
1203 : 0 : printk(KERN_ERR PREFIX
1204 : : "Unable to register for device notifications\n");
1205 : 0 : goto error1;
1206 : : }
1207 : :
1208 : : /*
1209 : : * Create the top ACPI proc directory
1210 : : */
1211 : 11 : acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
1212 : :
1213 : 11 : result = bus_register(&acpi_bus_type);
1214 [ - + ]: 11 : if (!result)
1215 : : return 0;
1216 : :
1217 : : /* Mimic structured exception handling */
1218 : 0 : error1:
1219 : 0 : acpi_terminate();
1220 : 0 : return -ENODEV;
1221 : : }
1222 : :
1223 : : struct kobject *acpi_kobj;
1224 : : EXPORT_SYMBOL_GPL(acpi_kobj);
1225 : :
1226 : 11 : static int __init acpi_init(void)
1227 : : {
1228 : 11 : int result;
1229 : :
1230 [ - + ]: 11 : if (acpi_disabled) {
1231 : 0 : printk(KERN_INFO PREFIX "Interpreter disabled.\n");
1232 : 0 : return -ENODEV;
1233 : : }
1234 : :
1235 : 11 : acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
1236 [ - + ]: 11 : if (!acpi_kobj) {
1237 : 0 : printk(KERN_WARNING "%s: kset create error\n", __func__);
1238 : 0 : acpi_kobj = NULL;
1239 : : }
1240 : :
1241 : 11 : result = acpi_bus_init();
1242 [ - + ]: 11 : if (result) {
1243 : 0 : disable_acpi();
1244 : 0 : return result;
1245 : : }
1246 : :
1247 : 11 : pci_mmcfg_late_init();
1248 : 11 : acpi_iort_init();
1249 : 11 : acpi_scan_init();
1250 : 11 : acpi_ec_init();
1251 : 11 : acpi_debugfs_init();
1252 : 11 : acpi_sleep_proc_init();
1253 : 11 : acpi_wakeup_device_init();
1254 : 11 : acpi_debugger_init();
1255 : 11 : acpi_setup_sb_notify_handler();
1256 : 11 : return 0;
1257 : : }
1258 : :
1259 : : subsys_initcall(acpi_init);
|
