1
2
3
4
5
6
7
8#define pr_fmt(fmt) "ACPI: " fmt
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/ioport.h>
13#include <linux/kernel.h>
14#include <linux/list.h>
15#include <linux/sched.h>
16#include <linux/pm.h>
17#include <linux/device.h>
18#include <linux/proc_fs.h>
19#include <linux/acpi.h>
20#include <linux/slab.h>
21#include <linux/regulator/machine.h>
22#include <linux/workqueue.h>
23#include <linux/reboot.h>
24#include <linux/delay.h>
25#ifdef CONFIG_X86
26#include <asm/mpspec.h>
27#include <linux/dmi.h>
28#endif
29#include <linux/acpi_iort.h>
30#include <linux/acpi_viot.h>
31#include <linux/pci.h>
32#include <acpi/apei.h>
33#include <linux/suspend.h>
34#include <linux/prmt.h>
35
36#include "internal.h"
37
38struct acpi_device *acpi_root;
39struct proc_dir_entry *acpi_root_dir;
40EXPORT_SYMBOL(acpi_root_dir);
41
42#ifdef CONFIG_X86
43#ifdef CONFIG_ACPI_CUSTOM_DSDT
44static inline int set_copy_dsdt(const struct dmi_system_id *id)
45{
46 return 0;
47}
48#else
49static int set_copy_dsdt(const struct dmi_system_id *id)
50{
51 pr_notice("%s detected - force copy of DSDT to local memory\n", id->ident);
52 acpi_gbl_copy_dsdt_locally = 1;
53 return 0;
54}
55#endif
56
57static const struct dmi_system_id dsdt_dmi_table[] __initconst = {
58
59
60
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
76
77
78acpi_status acpi_bus_get_status_handle(acpi_handle handle,
79 unsigned long long *sta)
80{
81 acpi_status status;
82
83 status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
84 if (ACPI_SUCCESS(status))
85 return AE_OK;
86
87 if (status == AE_NOT_FOUND) {
88 *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
89 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
90 return AE_OK;
91 }
92 return status;
93}
94EXPORT_SYMBOL_GPL(acpi_bus_get_status_handle);
95
96int acpi_bus_get_status(struct acpi_device *device)
97{
98 acpi_status status;
99 unsigned long long sta;
100
101 if (acpi_device_always_present(device)) {
102 acpi_set_device_status(device, ACPI_STA_DEFAULT);
103 return 0;
104 }
105
106
107 if (acpi_device_is_battery(device) && device->dep_unmet) {
108 acpi_set_device_status(device, 0);
109 return 0;
110 }
111
112 status = acpi_bus_get_status_handle(device->handle, &sta);
113 if (ACPI_FAILURE(status))
114 return -ENODEV;
115
116 acpi_set_device_status(device, sta);
117
118 if (device->status.functional && !device->status.present) {
119 pr_debug("Device [%s] status [%08x]: functional but not present\n",
120 device->pnp.bus_id, (u32)sta);
121 }
122
123 pr_debug("Device [%s] status [%08x]\n", device->pnp.bus_id, (u32)sta);
124 return 0;
125}
126EXPORT_SYMBOL(acpi_bus_get_status);
127
128void acpi_bus_private_data_handler(acpi_handle handle,
129 void *context)
130{
131 return;
132}
133EXPORT_SYMBOL(acpi_bus_private_data_handler);
134
135int acpi_bus_attach_private_data(acpi_handle handle, void *data)
136{
137 acpi_status status;
138
139 status = acpi_attach_data(handle,
140 acpi_bus_private_data_handler, data);
141 if (ACPI_FAILURE(status)) {
142 acpi_handle_debug(handle, "Error attaching device data\n");
143 return -ENODEV;
144 }
145
146 return 0;
147}
148EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
149
150int acpi_bus_get_private_data(acpi_handle handle, void **data)
151{
152 acpi_status status;
153
154 if (!data)
155 return -EINVAL;
156
157 status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
158 if (ACPI_FAILURE(status)) {
159 acpi_handle_debug(handle, "No context for object\n");
160 return -ENODEV;
161 }
162
163 return 0;
164}
165EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
166
167void acpi_bus_detach_private_data(acpi_handle handle)
168{
169 acpi_detach_data(handle, acpi_bus_private_data_handler);
170}
171EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
172
173static void acpi_print_osc_error(acpi_handle handle,
174 struct acpi_osc_context *context, char *error)
175{
176 int i;
177
178 acpi_handle_debug(handle, "(%s): %s\n", context->uuid_str, error);
179
180 pr_debug("_OSC request data:");
181 for (i = 0; i < context->cap.length; i += sizeof(u32))
182 pr_debug(" %x", *((u32 *)(context->cap.pointer + i)));
183
184 pr_debug("\n");
185}
186
187acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
188{
189 acpi_status status;
190 struct acpi_object_list input;
191 union acpi_object in_params[4];
192 union acpi_object *out_obj;
193 guid_t guid;
194 u32 errors;
195 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
196
197 if (!context)
198 return AE_ERROR;
199 if (guid_parse(context->uuid_str, &guid))
200 return AE_ERROR;
201 context->ret.length = ACPI_ALLOCATE_BUFFER;
202 context->ret.pointer = NULL;
203
204
205 input.count = 4;
206 input.pointer = in_params;
207 in_params[0].type = ACPI_TYPE_BUFFER;
208 in_params[0].buffer.length = 16;
209 in_params[0].buffer.pointer = (u8 *)&guid;
210 in_params[1].type = ACPI_TYPE_INTEGER;
211 in_params[1].integer.value = context->rev;
212 in_params[2].type = ACPI_TYPE_INTEGER;
213 in_params[2].integer.value = context->cap.length/sizeof(u32);
214 in_params[3].type = ACPI_TYPE_BUFFER;
215 in_params[3].buffer.length = context->cap.length;
216 in_params[3].buffer.pointer = context->cap.pointer;
217
218 status = acpi_evaluate_object(handle, "_OSC", &input, &output);
219 if (ACPI_FAILURE(status))
220 return status;
221
222 if (!output.length)
223 return AE_NULL_OBJECT;
224
225 out_obj = output.pointer;
226 if (out_obj->type != ACPI_TYPE_BUFFER
227 || out_obj->buffer.length != context->cap.length) {
228 acpi_print_osc_error(handle, context,
229 "_OSC evaluation returned wrong type");
230 status = AE_TYPE;
231 goto out_kfree;
232 }
233
234 errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
235 if (errors) {
236 if (errors & OSC_REQUEST_ERROR)
237 acpi_print_osc_error(handle, context,
238 "_OSC request failed");
239 if (errors & OSC_INVALID_UUID_ERROR)
240 acpi_print_osc_error(handle, context,
241 "_OSC invalid UUID");
242 if (errors & OSC_INVALID_REVISION_ERROR)
243 acpi_print_osc_error(handle, context,
244 "_OSC invalid revision");
245 if (errors & OSC_CAPABILITIES_MASK_ERROR) {
246 if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
247 & OSC_QUERY_ENABLE)
248 goto out_success;
249 status = AE_SUPPORT;
250 goto out_kfree;
251 }
252 status = AE_ERROR;
253 goto out_kfree;
254 }
255out_success:
256 context->ret.length = out_obj->buffer.length;
257 context->ret.pointer = kmemdup(out_obj->buffer.pointer,
258 context->ret.length, GFP_KERNEL);
259 if (!context->ret.pointer) {
260 status = AE_NO_MEMORY;
261 goto out_kfree;
262 }
263 status = AE_OK;
264
265out_kfree:
266 kfree(output.pointer);
267 return status;
268}
269EXPORT_SYMBOL(acpi_run_osc);
270
271bool osc_sb_apei_support_acked;
272
273
274
275
276
277bool osc_pc_lpi_support_confirmed;
278EXPORT_SYMBOL_GPL(osc_pc_lpi_support_confirmed);
279
280
281
282
283bool osc_sb_native_usb4_support_confirmed;
284EXPORT_SYMBOL_GPL(osc_sb_native_usb4_support_confirmed);
285
286static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
287static void acpi_bus_osc_negotiate_platform_control(void)
288{
289 u32 capbuf[2], *capbuf_ret;
290 struct acpi_osc_context context = {
291 .uuid_str = sb_uuid_str,
292 .rev = 1,
293 .cap.length = 8,
294 .cap.pointer = capbuf,
295 };
296 acpi_handle handle;
297
298 capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
299 capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT;
300 if (IS_ENABLED(CONFIG_ACPI_PROCESSOR_AGGREGATOR))
301 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
302 if (IS_ENABLED(CONFIG_ACPI_PROCESSOR))
303 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
304
305 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
306 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;
307 if (IS_ENABLED(CONFIG_ACPI_PRMT))
308 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PRM_SUPPORT;
309
310#ifdef CONFIG_ARM64
311 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_GENERIC_INITIATOR_SUPPORT;
312#endif
313#ifdef CONFIG_X86
314 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_GENERIC_INITIATOR_SUPPORT;
315 if (boot_cpu_has(X86_FEATURE_HWP)) {
316 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_SUPPORT;
317 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPCV2_SUPPORT;
318 }
319#endif
320
321 if (IS_ENABLED(CONFIG_SCHED_MC_PRIO))
322 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_DIVERSE_HIGH_SUPPORT;
323
324 if (IS_ENABLED(CONFIG_USB4))
325 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_NATIVE_USB4_SUPPORT;
326
327 if (!ghes_disable)
328 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
329 if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
330 return;
331
332 if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
333 return;
334
335 kfree(context.ret.pointer);
336
337
338 capbuf[OSC_QUERY_DWORD] = 0;
339
340 if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
341 return;
342
343 capbuf_ret = context.ret.pointer;
344 osc_sb_apei_support_acked =
345 capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
346 osc_pc_lpi_support_confirmed =
347 capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
348 osc_sb_native_usb4_support_confirmed =
349 capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_NATIVE_USB4_SUPPORT;
350
351 kfree(context.ret.pointer);
352}
353
354
355
356
357
358
359u32 osc_sb_native_usb4_control;
360EXPORT_SYMBOL_GPL(osc_sb_native_usb4_control);
361
362static void acpi_bus_decode_usb_osc(const char *msg, u32 bits)
363{
364 pr_info("%s USB3%c DisplayPort%c PCIe%c XDomain%c\n", msg,
365 (bits & OSC_USB_USB3_TUNNELING) ? '+' : '-',
366 (bits & OSC_USB_DP_TUNNELING) ? '+' : '-',
367 (bits & OSC_USB_PCIE_TUNNELING) ? '+' : '-',
368 (bits & OSC_USB_XDOMAIN) ? '+' : '-');
369}
370
371static u8 sb_usb_uuid_str[] = "23A0D13A-26AB-486C-9C5F-0FFA525A575A";
372static void acpi_bus_osc_negotiate_usb_control(void)
373{
374 u32 capbuf[3];
375 struct acpi_osc_context context = {
376 .uuid_str = sb_usb_uuid_str,
377 .rev = 1,
378 .cap.length = sizeof(capbuf),
379 .cap.pointer = capbuf,
380 };
381 acpi_handle handle;
382 acpi_status status;
383 u32 control;
384
385 if (!osc_sb_native_usb4_support_confirmed)
386 return;
387
388 if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
389 return;
390
391 control = OSC_USB_USB3_TUNNELING | OSC_USB_DP_TUNNELING |
392 OSC_USB_PCIE_TUNNELING | OSC_USB_XDOMAIN;
393
394 capbuf[OSC_QUERY_DWORD] = 0;
395 capbuf[OSC_SUPPORT_DWORD] = 0;
396 capbuf[OSC_CONTROL_DWORD] = control;
397
398 status = acpi_run_osc(handle, &context);
399 if (ACPI_FAILURE(status))
400 return;
401
402 if (context.ret.length != sizeof(capbuf)) {
403 pr_info("USB4 _OSC: returned invalid length buffer\n");
404 goto out_free;
405 }
406
407 osc_sb_native_usb4_control =
408 control & ((u32 *)context.ret.pointer)[OSC_CONTROL_DWORD];
409
410 acpi_bus_decode_usb_osc("USB4 _OSC: OS supports", control);
411 acpi_bus_decode_usb_osc("USB4 _OSC: OS controls",
412 osc_sb_native_usb4_control);
413
414out_free:
415 kfree(context.ret.pointer);
416}
417
418
419
420
421
422
423
424
425
426
427static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
428{
429 struct acpi_device *adev;
430 struct acpi_driver *driver;
431 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
432 bool hotplug_event = false;
433
434 switch (type) {
435 case ACPI_NOTIFY_BUS_CHECK:
436 acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
437 hotplug_event = true;
438 break;
439
440 case ACPI_NOTIFY_DEVICE_CHECK:
441 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
442 hotplug_event = true;
443 break;
444
445 case ACPI_NOTIFY_DEVICE_WAKE:
446 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
447 break;
448
449 case ACPI_NOTIFY_EJECT_REQUEST:
450 acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
451 hotplug_event = true;
452 break;
453
454 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
455 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
456
457 break;
458
459 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
460 acpi_handle_err(handle, "Device cannot be configured due "
461 "to a frequency mismatch\n");
462 break;
463
464 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
465 acpi_handle_err(handle, "Device cannot be configured due "
466 "to a bus mode mismatch\n");
467 break;
468
469 case ACPI_NOTIFY_POWER_FAULT:
470 acpi_handle_err(handle, "Device has suffered a power fault\n");
471 break;
472
473 default:
474 acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
475 break;
476 }
477
478 adev = acpi_bus_get_acpi_device(handle);
479 if (!adev)
480 goto err;
481
482 driver = adev->driver;
483 if (driver && driver->ops.notify &&
484 (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
485 driver->ops.notify(adev, type);
486
487 if (!hotplug_event) {
488 acpi_bus_put_acpi_device(adev);
489 return;
490 }
491
492 if (ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
493 return;
494
495 acpi_bus_put_acpi_device(adev);
496
497 err:
498 acpi_evaluate_ost(handle, type, ost_code, NULL);
499}
500
501static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
502{
503 struct acpi_device *device = data;
504
505 device->driver->ops.notify(device, event);
506}
507
508static void acpi_device_notify_fixed(void *data)
509{
510 struct acpi_device *device = data;
511
512
513 acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
514}
515
516static u32 acpi_device_fixed_event(void *data)
517{
518 acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
519 return ACPI_INTERRUPT_HANDLED;
520}
521
522static int acpi_device_install_notify_handler(struct acpi_device *device)
523{
524 acpi_status status;
525
526 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
527 status =
528 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
529 acpi_device_fixed_event,
530 device);
531 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
532 status =
533 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
534 acpi_device_fixed_event,
535 device);
536 else
537 status = acpi_install_notify_handler(device->handle,
538 ACPI_DEVICE_NOTIFY,
539 acpi_device_notify,
540 device);
541
542 if (ACPI_FAILURE(status))
543 return -EINVAL;
544 return 0;
545}
546
547static void acpi_device_remove_notify_handler(struct acpi_device *device)
548{
549 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
550 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
551 acpi_device_fixed_event);
552 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
553 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
554 acpi_device_fixed_event);
555 else
556 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
557 acpi_device_notify);
558}
559
560
561
562#define ACPI_SB_NOTIFY_SHUTDOWN_REQUEST 0x81
563#define ACPI_SB_INDICATE_INTERVAL 10000
564
565static void sb_notify_work(struct work_struct *dummy)
566{
567 acpi_handle sb_handle;
568
569 orderly_poweroff(true);
570
571
572
573
574
575
576 acpi_get_handle(NULL, "\\_SB", &sb_handle);
577 while (1) {
578 pr_info("Graceful shutdown in progress.\n");
579 acpi_evaluate_ost(sb_handle, ACPI_OST_EC_OSPM_SHUTDOWN,
580 ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS, NULL);
581 msleep(ACPI_SB_INDICATE_INTERVAL);
582 }
583}
584
585static void acpi_sb_notify(acpi_handle handle, u32 event, void *data)
586{
587 static DECLARE_WORK(acpi_sb_work, sb_notify_work);
588
589 if (event == ACPI_SB_NOTIFY_SHUTDOWN_REQUEST) {
590 if (!work_busy(&acpi_sb_work))
591 schedule_work(&acpi_sb_work);
592 } else
593 pr_warn("event %x is not supported by \\_SB device\n", event);
594}
595
596static int __init acpi_setup_sb_notify_handler(void)
597{
598 acpi_handle sb_handle;
599
600 if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &sb_handle)))
601 return -ENXIO;
602
603 if (ACPI_FAILURE(acpi_install_notify_handler(sb_handle, ACPI_DEVICE_NOTIFY,
604 acpi_sb_notify, NULL)))
605 return -EINVAL;
606
607 return 0;
608}
609
610
611
612
613
614
615
616
617
618
619
620struct device *acpi_get_first_physical_node(struct acpi_device *adev)
621{
622 struct mutex *physical_node_lock = &adev->physical_node_lock;
623 struct device *phys_dev;
624
625 mutex_lock(physical_node_lock);
626 if (list_empty(&adev->physical_node_list)) {
627 phys_dev = NULL;
628 } else {
629 const struct acpi_device_physical_node *node;
630
631 node = list_first_entry(&adev->physical_node_list,
632 struct acpi_device_physical_node, node);
633
634 phys_dev = node->dev;
635 }
636 mutex_unlock(physical_node_lock);
637 return phys_dev;
638}
639EXPORT_SYMBOL_GPL(acpi_get_first_physical_node);
640
641static struct acpi_device *acpi_primary_dev_companion(struct acpi_device *adev,
642 const struct device *dev)
643{
644 const struct device *phys_dev = acpi_get_first_physical_node(adev);
645
646 return phys_dev && phys_dev == dev ? adev : NULL;
647}
648
649
650
651
652
653
654
655
656
657
658
659
660bool acpi_device_is_first_physical_node(struct acpi_device *adev,
661 const struct device *dev)
662{
663 return !!acpi_primary_dev_companion(adev, dev);
664}
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687struct acpi_device *acpi_companion_match(const struct device *dev)
688{
689 struct acpi_device *adev;
690
691 adev = ACPI_COMPANION(dev);
692 if (!adev)
693 return NULL;
694
695 if (list_empty(&adev->pnp.ids))
696 return NULL;
697
698 return acpi_primary_dev_companion(adev, dev);
699}
700
701
702
703
704
705
706
707
708
709
710
711static bool acpi_of_match_device(struct acpi_device *adev,
712 const struct of_device_id *of_match_table,
713 const struct of_device_id **of_id)
714{
715 const union acpi_object *of_compatible, *obj;
716 int i, nval;
717
718 if (!adev)
719 return false;
720
721 of_compatible = adev->data.of_compatible;
722 if (!of_match_table || !of_compatible)
723 return false;
724
725 if (of_compatible->type == ACPI_TYPE_PACKAGE) {
726 nval = of_compatible->package.count;
727 obj = of_compatible->package.elements;
728 } else {
729 nval = 1;
730 obj = of_compatible;
731 }
732
733 for (i = 0; i < nval; i++, obj++) {
734 const struct of_device_id *id;
735
736 for (id = of_match_table; id->compatible[0]; id++)
737 if (!strcasecmp(obj->string.pointer, id->compatible)) {
738 if (of_id)
739 *of_id = id;
740 return true;
741 }
742 }
743
744 return false;
745}
746
747static bool acpi_of_modalias(struct acpi_device *adev,
748 char *modalias, size_t len)
749{
750 const union acpi_object *of_compatible;
751 const union acpi_object *obj;
752 const char *str, *chr;
753
754 of_compatible = adev->data.of_compatible;
755 if (!of_compatible)
756 return false;
757
758 if (of_compatible->type == ACPI_TYPE_PACKAGE)
759 obj = of_compatible->package.elements;
760 else
761 obj = of_compatible;
762
763 str = obj->string.pointer;
764 chr = strchr(str, ',');
765 strlcpy(modalias, chr ? chr + 1 : str, len);
766
767 return true;
768}
769
770
771
772
773
774
775
776
777
778
779
780
781void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
782 char *modalias, size_t len)
783{
784 if (!acpi_of_modalias(adev, modalias, len))
785 strlcpy(modalias, default_id, len);
786}
787EXPORT_SYMBOL_GPL(acpi_set_modalias);
788
789static bool __acpi_match_device_cls(const struct acpi_device_id *id,
790 struct acpi_hardware_id *hwid)
791{
792 int i, msk, byte_shift;
793 char buf[3];
794
795 if (!id->cls)
796 return false;
797
798
799 for (i = 1; i <= 3; i++) {
800 byte_shift = 8 * (3 - i);
801 msk = (id->cls_msk >> byte_shift) & 0xFF;
802 if (!msk)
803 continue;
804
805 sprintf(buf, "%02x", (id->cls >> byte_shift) & msk);
806 if (strncmp(buf, &hwid->id[(i - 1) * 2], 2))
807 return false;
808 }
809 return true;
810}
811
812static bool __acpi_match_device(struct acpi_device *device,
813 const struct acpi_device_id *acpi_ids,
814 const struct of_device_id *of_ids,
815 const struct acpi_device_id **acpi_id,
816 const struct of_device_id **of_id)
817{
818 const struct acpi_device_id *id;
819 struct acpi_hardware_id *hwid;
820
821
822
823
824
825 if (!device || !device->status.present)
826 return false;
827
828 list_for_each_entry(hwid, &device->pnp.ids, list) {
829
830 if (acpi_ids) {
831 for (id = acpi_ids; id->id[0] || id->cls; id++) {
832 if (id->id[0] && !strcmp((char *)id->id, hwid->id))
833 goto out_acpi_match;
834 if (id->cls && __acpi_match_device_cls(id, hwid))
835 goto out_acpi_match;
836 }
837 }
838
839
840
841
842
843 if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id))
844 return acpi_of_match_device(device, of_ids, of_id);
845 }
846 return false;
847
848out_acpi_match:
849 if (acpi_id)
850 *acpi_id = id;
851 return true;
852}
853
854
855
856
857
858
859
860
861
862
863
864
865const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
866 const struct device *dev)
867{
868 const struct acpi_device_id *id = NULL;
869
870 __acpi_match_device(acpi_companion_match(dev), ids, NULL, &id, NULL);
871 return id;
872}
873EXPORT_SYMBOL_GPL(acpi_match_device);
874
875static const void *acpi_of_device_get_match_data(const struct device *dev)
876{
877 struct acpi_device *adev = ACPI_COMPANION(dev);
878 const struct of_device_id *match = NULL;
879
880 if (!acpi_of_match_device(adev, dev->driver->of_match_table, &match))
881 return NULL;
882
883 return match->data;
884}
885
886const void *acpi_device_get_match_data(const struct device *dev)
887{
888 const struct acpi_device_id *match;
889
890 if (!dev->driver->acpi_match_table)
891 return acpi_of_device_get_match_data(dev);
892
893 match = acpi_match_device(dev->driver->acpi_match_table, dev);
894 if (!match)
895 return NULL;
896
897 return (const void *)match->driver_data;
898}
899EXPORT_SYMBOL_GPL(acpi_device_get_match_data);
900
901int acpi_match_device_ids(struct acpi_device *device,
902 const struct acpi_device_id *ids)
903{
904 return __acpi_match_device(device, ids, NULL, NULL, NULL) ? 0 : -ENOENT;
905}
906EXPORT_SYMBOL(acpi_match_device_ids);
907
908bool acpi_driver_match_device(struct device *dev,
909 const struct device_driver *drv)
910{
911 if (!drv->acpi_match_table)
912 return acpi_of_match_device(ACPI_COMPANION(dev),
913 drv->of_match_table,
914 NULL);
915
916 return __acpi_match_device(acpi_companion_match(dev),
917 drv->acpi_match_table, drv->of_match_table,
918 NULL, NULL);
919}
920EXPORT_SYMBOL_GPL(acpi_driver_match_device);
921
922
923
924
925
926
927
928
929
930
931
932
933
934int acpi_bus_register_driver(struct acpi_driver *driver)
935{
936 int ret;
937
938 if (acpi_disabled)
939 return -ENODEV;
940 driver->drv.name = driver->name;
941 driver->drv.bus = &acpi_bus_type;
942 driver->drv.owner = driver->owner;
943
944 ret = driver_register(&driver->drv);
945 return ret;
946}
947
948EXPORT_SYMBOL(acpi_bus_register_driver);
949
950
951
952
953
954
955
956
957void acpi_bus_unregister_driver(struct acpi_driver *driver)
958{
959 driver_unregister(&driver->drv);
960}
961
962EXPORT_SYMBOL(acpi_bus_unregister_driver);
963
964
965
966
967
968static int acpi_bus_match(struct device *dev, struct device_driver *drv)
969{
970 struct acpi_device *acpi_dev = to_acpi_device(dev);
971 struct acpi_driver *acpi_drv = to_acpi_driver(drv);
972
973 return acpi_dev->flags.match_driver
974 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
975}
976
977static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
978{
979 return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
980}
981
982static int acpi_device_probe(struct device *dev)
983{
984 struct acpi_device *acpi_dev = to_acpi_device(dev);
985 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
986 int ret;
987
988 if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
989 return -EINVAL;
990
991 if (!acpi_drv->ops.add)
992 return -ENOSYS;
993
994 ret = acpi_drv->ops.add(acpi_dev);
995 if (ret)
996 return ret;
997
998 acpi_dev->driver = acpi_drv;
999
1000 pr_debug("Driver [%s] successfully bound to device [%s]\n",
1001 acpi_drv->name, acpi_dev->pnp.bus_id);
1002
1003 if (acpi_drv->ops.notify) {
1004 ret = acpi_device_install_notify_handler(acpi_dev);
1005 if (ret) {
1006 if (acpi_drv->ops.remove)
1007 acpi_drv->ops.remove(acpi_dev);
1008
1009 acpi_dev->driver = NULL;
1010 acpi_dev->driver_data = NULL;
1011 return ret;
1012 }
1013 }
1014
1015 pr_debug("Found driver [%s] for device [%s]\n", acpi_drv->name,
1016 acpi_dev->pnp.bus_id);
1017
1018 get_device(dev);
1019 return 0;
1020}
1021
1022static int acpi_device_remove(struct device *dev)
1023{
1024 struct acpi_device *acpi_dev = to_acpi_device(dev);
1025 struct acpi_driver *acpi_drv = acpi_dev->driver;
1026
1027 if (acpi_drv) {
1028 if (acpi_drv->ops.notify)
1029 acpi_device_remove_notify_handler(acpi_dev);
1030 if (acpi_drv->ops.remove)
1031 acpi_drv->ops.remove(acpi_dev);
1032 }
1033 acpi_dev->driver = NULL;
1034 acpi_dev->driver_data = NULL;
1035
1036 put_device(dev);
1037 return 0;
1038}
1039
1040struct bus_type acpi_bus_type = {
1041 .name = "acpi",
1042 .match = acpi_bus_match,
1043 .probe = acpi_device_probe,
1044 .remove = acpi_device_remove,
1045 .uevent = acpi_device_uevent,
1046};
1047
1048
1049
1050
1051
1052static int __init acpi_bus_init_irq(void)
1053{
1054 acpi_status status;
1055 char *message = NULL;
1056
1057
1058
1059
1060
1061
1062
1063 switch (acpi_irq_model) {
1064 case ACPI_IRQ_MODEL_PIC:
1065 message = "PIC";
1066 break;
1067 case ACPI_IRQ_MODEL_IOAPIC:
1068 message = "IOAPIC";
1069 break;
1070 case ACPI_IRQ_MODEL_IOSAPIC:
1071 message = "IOSAPIC";
1072 break;
1073 case ACPI_IRQ_MODEL_GIC:
1074 message = "GIC";
1075 break;
1076 case ACPI_IRQ_MODEL_PLATFORM:
1077 message = "platform specific model";
1078 break;
1079 default:
1080 pr_info("Unknown interrupt routing model\n");
1081 return -ENODEV;
1082 }
1083
1084 pr_info("Using %s for interrupt routing\n", message);
1085
1086 status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
1087 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
1088 pr_info("_PIC evaluation failed: %s\n", acpi_format_exception(status));
1089 return -ENODEV;
1090 }
1091
1092 return 0;
1093}
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105void __init acpi_early_init(void)
1106{
1107 acpi_status status;
1108
1109 if (acpi_disabled)
1110 return;
1111
1112 pr_info("Core revision %08x\n", ACPI_CA_VERSION);
1113
1114
1115 if (!acpi_strict)
1116 acpi_gbl_enable_interpreter_slack = TRUE;
1117
1118 acpi_permanent_mmap = true;
1119
1120#ifdef CONFIG_X86
1121
1122
1123
1124
1125
1126
1127
1128 dmi_check_system(dsdt_dmi_table);
1129#endif
1130
1131 status = acpi_reallocate_root_table();
1132 if (ACPI_FAILURE(status)) {
1133 pr_err("Unable to reallocate ACPI tables\n");
1134 goto error0;
1135 }
1136
1137 status = acpi_initialize_subsystem();
1138 if (ACPI_FAILURE(status)) {
1139 pr_err("Unable to initialize the ACPI Interpreter\n");
1140 goto error0;
1141 }
1142
1143#ifdef CONFIG_X86
1144 if (!acpi_ioapic) {
1145
1146 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
1147 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
1148 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
1149 }
1150
1151 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
1152 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
1153 } else {
1154
1155
1156
1157
1158 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
1159 }
1160#endif
1161 return;
1162
1163 error0:
1164 disable_acpi();
1165}
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176void __init acpi_subsystem_init(void)
1177{
1178 acpi_status status;
1179
1180 if (acpi_disabled)
1181 return;
1182
1183 status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
1184 if (ACPI_FAILURE(status)) {
1185 pr_err("Unable to enable ACPI\n");
1186 disable_acpi();
1187 } else {
1188
1189
1190
1191
1192
1193
1194 regulator_has_full_constraints();
1195 }
1196}
1197
1198static acpi_status acpi_bus_table_handler(u32 event, void *table, void *context)
1199{
1200 if (event == ACPI_TABLE_EVENT_LOAD)
1201 acpi_scan_table_notify();
1202
1203 return acpi_sysfs_table_handler(event, table, context);
1204}
1205
1206static int __init acpi_bus_init(void)
1207{
1208 int result;
1209 acpi_status status;
1210
1211 acpi_os_initialize1();
1212
1213 status = acpi_load_tables();
1214 if (ACPI_FAILURE(status)) {
1215 pr_err("Unable to load the System Description Tables\n");
1216 goto error1;
1217 }
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229 acpi_ec_ecdt_probe();
1230
1231 status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
1232 if (ACPI_FAILURE(status)) {
1233 pr_err("Unable to start the ACPI Interpreter\n");
1234 goto error1;
1235 }
1236
1237 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
1238 if (ACPI_FAILURE(status)) {
1239 pr_err("Unable to initialize ACPI objects\n");
1240 goto error1;
1241 }
1242
1243
1244 acpi_early_processor_osc();
1245
1246
1247
1248
1249
1250 acpi_bus_osc_negotiate_platform_control();
1251 acpi_bus_osc_negotiate_usb_control();
1252
1253
1254
1255
1256
1257 status = acpi_install_table_handler(acpi_bus_table_handler, NULL);
1258
1259 acpi_sysfs_init();
1260
1261 acpi_early_processor_set_pdc();
1262
1263
1264
1265
1266
1267 acpi_ec_dsdt_probe();
1268
1269 pr_info("Interpreter enabled\n");
1270
1271
1272 acpi_sleep_init();
1273
1274
1275
1276
1277 result = acpi_bus_init_irq();
1278 if (result)
1279 goto error1;
1280
1281
1282
1283
1284 status =
1285 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
1286 &acpi_bus_notify, NULL);
1287 if (ACPI_FAILURE(status)) {
1288 pr_err("Unable to register for system notifications\n");
1289 goto error1;
1290 }
1291
1292
1293
1294
1295 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
1296
1297 result = bus_register(&acpi_bus_type);
1298 if (!result)
1299 return 0;
1300
1301
1302 error1:
1303 acpi_terminate();
1304 return -ENODEV;
1305}
1306
1307struct kobject *acpi_kobj;
1308EXPORT_SYMBOL_GPL(acpi_kobj);
1309
1310static int __init acpi_init(void)
1311{
1312 int result;
1313
1314 if (acpi_disabled) {
1315 pr_info("Interpreter disabled.\n");
1316 return -ENODEV;
1317 }
1318
1319 acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
1320 if (!acpi_kobj)
1321 pr_debug("%s: kset create error\n", __func__);
1322
1323 init_prmt();
1324 result = acpi_bus_init();
1325 if (result) {
1326 kobject_put(acpi_kobj);
1327 disable_acpi();
1328 return result;
1329 }
1330
1331 pci_mmcfg_late_init();
1332 acpi_iort_init();
1333 acpi_scan_init();
1334 acpi_ec_init();
1335 acpi_debugfs_init();
1336 acpi_sleep_proc_init();
1337 acpi_wakeup_device_init();
1338 acpi_debugger_init();
1339 acpi_setup_sb_notify_handler();
1340 acpi_viot_init();
1341 return 0;
1342}
1343
1344subsys_initcall(acpi_init);
1345