1
2
3
4
5#include <linux/module.h>
6#include <linux/init.h>
7#include <linux/slab.h>
8#include <linux/kernel.h>
9#include <linux/acpi.h>
10#include <linux/acpi_iort.h>
11#include <linux/signal.h>
12#include <linux/kthread.h>
13#include <linux/dmi.h>
14#include <linux/nls.h>
15#include <linux/dma-mapping.h>
16
17#include <asm/pgtable.h>
18
19#include "internal.h"
20
21#define _COMPONENT ACPI_BUS_COMPONENT
22ACPI_MODULE_NAME("scan");
23extern struct acpi_device *acpi_root;
24
25#define ACPI_BUS_CLASS "system_bus"
26#define ACPI_BUS_HID "LNXSYBUS"
27#define ACPI_BUS_DEVICE_NAME "System Bus"
28
29#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
30
31#define INVALID_ACPI_HANDLE ((acpi_handle)empty_zero_page)
32
33static const char *dummy_hid = "device";
34
35static LIST_HEAD(acpi_dep_list);
36static DEFINE_MUTEX(acpi_dep_list_lock);
37LIST_HEAD(acpi_bus_id_list);
38static DEFINE_MUTEX(acpi_scan_lock);
39static LIST_HEAD(acpi_scan_handlers_list);
40DEFINE_MUTEX(acpi_device_lock);
41LIST_HEAD(acpi_wakeup_device_list);
42static DEFINE_MUTEX(acpi_hp_context_lock);
43
44
45
46
47
48
49static u64 spcr_uart_addr;
50
51struct acpi_dep_data {
52 struct list_head node;
53 acpi_handle master;
54 acpi_handle slave;
55};
56
57void acpi_scan_lock_acquire(void)
58{
59 mutex_lock(&acpi_scan_lock);
60}
61EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
62
63void acpi_scan_lock_release(void)
64{
65 mutex_unlock(&acpi_scan_lock);
66}
67EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
68
69void acpi_lock_hp_context(void)
70{
71 mutex_lock(&acpi_hp_context_lock);
72}
73
74void acpi_unlock_hp_context(void)
75{
76 mutex_unlock(&acpi_hp_context_lock);
77}
78
79void acpi_initialize_hp_context(struct acpi_device *adev,
80 struct acpi_hotplug_context *hp,
81 int (*notify)(struct acpi_device *, u32),
82 void (*uevent)(struct acpi_device *, u32))
83{
84 acpi_lock_hp_context();
85 hp->notify = notify;
86 hp->uevent = uevent;
87 acpi_set_hp_context(adev, hp);
88 acpi_unlock_hp_context();
89}
90EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
91
92int acpi_scan_add_handler(struct acpi_scan_handler *handler)
93{
94 if (!handler)
95 return -EINVAL;
96
97 list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
98 return 0;
99}
100
101int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
102 const char *hotplug_profile_name)
103{
104 int error;
105
106 error = acpi_scan_add_handler(handler);
107 if (error)
108 return error;
109
110 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
111 return 0;
112}
113
114bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
115{
116 struct acpi_device_physical_node *pn;
117 bool offline = true;
118
119
120
121
122
123 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING);
124
125 list_for_each_entry(pn, &adev->physical_node_list, node)
126 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
127 if (uevent)
128 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);
129
130 offline = false;
131 break;
132 }
133
134 mutex_unlock(&adev->physical_node_lock);
135 return offline;
136}
137
138static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
139 void **ret_p)
140{
141 struct acpi_device *device = NULL;
142 struct acpi_device_physical_node *pn;
143 bool second_pass = (bool)data;
144 acpi_status status = AE_OK;
145
146 if (acpi_bus_get_device(handle, &device))
147 return AE_OK;
148
149 if (device->handler && !device->handler->hotplug.enabled) {
150 *ret_p = &device->dev;
151 return AE_SUPPORT;
152 }
153
154 mutex_lock(&device->physical_node_lock);
155
156 list_for_each_entry(pn, &device->physical_node_list, node) {
157 int ret;
158
159 if (second_pass) {
160
161 if (pn->put_online)
162 continue;
163 } else {
164 pn->put_online = false;
165 }
166 ret = device_offline(pn->dev);
167 if (ret >= 0) {
168 pn->put_online = !ret;
169 } else {
170 *ret_p = pn->dev;
171 if (second_pass) {
172 status = AE_ERROR;
173 break;
174 }
175 }
176 }
177
178 mutex_unlock(&device->physical_node_lock);
179
180 return status;
181}
182
183static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
184 void **ret_p)
185{
186 struct acpi_device *device = NULL;
187 struct acpi_device_physical_node *pn;
188
189 if (acpi_bus_get_device(handle, &device))
190 return AE_OK;
191
192 mutex_lock(&device->physical_node_lock);
193
194 list_for_each_entry(pn, &device->physical_node_list, node)
195 if (pn->put_online) {
196 device_online(pn->dev);
197 pn->put_online = false;
198 }
199
200 mutex_unlock(&device->physical_node_lock);
201
202 return AE_OK;
203}
204
205static int acpi_scan_try_to_offline(struct acpi_device *device)
206{
207 acpi_handle handle = device->handle;
208 struct device *errdev = NULL;
209 acpi_status status;
210
211
212
213
214
215
216
217
218
219
220 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
221 NULL, acpi_bus_offline, (void *)false,
222 (void **)&errdev);
223 if (status == AE_SUPPORT) {
224 dev_warn(errdev, "Offline disabled.\n");
225 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
226 acpi_bus_online, NULL, NULL, NULL);
227 return -EPERM;
228 }
229 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
230 if (errdev) {
231 errdev = NULL;
232 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
233 NULL, acpi_bus_offline, (void *)true,
234 (void **)&errdev);
235 if (!errdev)
236 acpi_bus_offline(handle, 0, (void *)true,
237 (void **)&errdev);
238
239 if (errdev) {
240 dev_warn(errdev, "Offline failed.\n");
241 acpi_bus_online(handle, 0, NULL, NULL);
242 acpi_walk_namespace(ACPI_TYPE_ANY, handle,
243 ACPI_UINT32_MAX, acpi_bus_online,
244 NULL, NULL, NULL);
245 return -EBUSY;
246 }
247 }
248 return 0;
249}
250
251static int acpi_scan_hot_remove(struct acpi_device *device)
252{
253 acpi_handle handle = device->handle;
254 unsigned long long sta;
255 acpi_status status;
256
257 if (device->handler && device->handler->hotplug.demand_offline) {
258 if (!acpi_scan_is_offline(device, true))
259 return -EBUSY;
260 } else {
261 int error = acpi_scan_try_to_offline(device);
262 if (error)
263 return error;
264 }
265
266 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
267 "Hot-removing device %s...\n", dev_name(&device->dev)));
268
269 acpi_bus_trim(device);
270
271 acpi_evaluate_lck(handle, 0);
272
273
274
275 status = acpi_evaluate_ej0(handle);
276 if (status == AE_NOT_FOUND)
277 return -ENODEV;
278 else if (ACPI_FAILURE(status))
279 return -EIO;
280
281
282
283
284
285 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
286 if (ACPI_FAILURE(status)) {
287 acpi_handle_warn(handle,
288 "Status check after eject failed (0x%x)\n", status);
289 } else if (sta & ACPI_STA_DEVICE_ENABLED) {
290 acpi_handle_warn(handle,
291 "Eject incomplete - status 0x%llx\n", sta);
292 }
293
294 return 0;
295}
296
297static int acpi_scan_device_not_present(struct acpi_device *adev)
298{
299 if (!acpi_device_enumerated(adev)) {
300 dev_warn(&adev->dev, "Still not present\n");
301 return -EALREADY;
302 }
303 acpi_bus_trim(adev);
304 return 0;
305}
306
307static int acpi_scan_device_check(struct acpi_device *adev)
308{
309 int error;
310
311 acpi_bus_get_status(adev);
312 if (adev->status.present || adev->status.functional) {
313
314
315
316
317
318
319
320
321 if (adev->handler) {
322 dev_warn(&adev->dev, "Already enumerated\n");
323 return -EALREADY;
324 }
325 error = acpi_bus_scan(adev->handle);
326 if (error) {
327 dev_warn(&adev->dev, "Namespace scan failure\n");
328 return error;
329 }
330 if (!adev->handler) {
331 dev_warn(&adev->dev, "Enumeration failure\n");
332 error = -ENODEV;
333 }
334 } else {
335 error = acpi_scan_device_not_present(adev);
336 }
337 return error;
338}
339
340static int acpi_scan_bus_check(struct acpi_device *adev)
341{
342 struct acpi_scan_handler *handler = adev->handler;
343 struct acpi_device *child;
344 int error;
345
346 acpi_bus_get_status(adev);
347 if (!(adev->status.present || adev->status.functional)) {
348 acpi_scan_device_not_present(adev);
349 return 0;
350 }
351 if (handler && handler->hotplug.scan_dependent)
352 return handler->hotplug.scan_dependent(adev);
353
354 error = acpi_bus_scan(adev->handle);
355 if (error) {
356 dev_warn(&adev->dev, "Namespace scan failure\n");
357 return error;
358 }
359 list_for_each_entry(child, &adev->children, node) {
360 error = acpi_scan_bus_check(child);
361 if (error)
362 return error;
363 }
364 return 0;
365}
366
367static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
368{
369 switch (type) {
370 case ACPI_NOTIFY_BUS_CHECK:
371 return acpi_scan_bus_check(adev);
372 case ACPI_NOTIFY_DEVICE_CHECK:
373 return acpi_scan_device_check(adev);
374 case ACPI_NOTIFY_EJECT_REQUEST:
375 case ACPI_OST_EC_OSPM_EJECT:
376 if (adev->handler && !adev->handler->hotplug.enabled) {
377 dev_info(&adev->dev, "Eject disabled\n");
378 return -EPERM;
379 }
380 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
381 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
382 return acpi_scan_hot_remove(adev);
383 }
384 return -EINVAL;
385}
386
387void acpi_device_hotplug(struct acpi_device *adev, u32 src)
388{
389 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
390 int error = -ENODEV;
391
392 lock_device_hotplug();
393 mutex_lock(&acpi_scan_lock);
394
395
396
397
398
399
400 if (adev->handle == INVALID_ACPI_HANDLE)
401 goto err_out;
402
403 if (adev->flags.is_dock_station) {
404 error = dock_notify(adev, src);
405 } else if (adev->flags.hotplug_notify) {
406 error = acpi_generic_hotplug_event(adev, src);
407 } else {
408 int (*notify)(struct acpi_device *, u32);
409
410 acpi_lock_hp_context();
411 notify = adev->hp ? adev->hp->notify : NULL;
412 acpi_unlock_hp_context();
413
414
415
416
417 if (notify)
418 error = notify(adev, src);
419 else
420 goto out;
421 }
422 switch (error) {
423 case 0:
424 ost_code = ACPI_OST_SC_SUCCESS;
425 break;
426 case -EPERM:
427 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
428 break;
429 case -EBUSY:
430 ost_code = ACPI_OST_SC_DEVICE_BUSY;
431 break;
432 default:
433 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
434 break;
435 }
436
437 err_out:
438 acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
439
440 out:
441 acpi_bus_put_acpi_device(adev);
442 mutex_unlock(&acpi_scan_lock);
443 unlock_device_hotplug();
444}
445
446static void acpi_free_power_resources_lists(struct acpi_device *device)
447{
448 int i;
449
450 if (device->wakeup.flags.valid)
451 acpi_power_resources_list_free(&device->wakeup.resources);
452
453 if (!device->power.flags.power_resources)
454 return;
455
456 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
457 struct acpi_device_power_state *ps = &device->power.states[i];
458 acpi_power_resources_list_free(&ps->resources);
459 }
460}
461
462static void acpi_device_release(struct device *dev)
463{
464 struct acpi_device *acpi_dev = to_acpi_device(dev);
465
466 acpi_free_properties(acpi_dev);
467 acpi_free_pnp_ids(&acpi_dev->pnp);
468 acpi_free_power_resources_lists(acpi_dev);
469 kfree(acpi_dev);
470}
471
472static void acpi_device_del(struct acpi_device *device)
473{
474 struct acpi_device_bus_id *acpi_device_bus_id;
475
476 mutex_lock(&acpi_device_lock);
477 if (device->parent)
478 list_del(&device->node);
479
480 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
481 if (!strcmp(acpi_device_bus_id->bus_id,
482 acpi_device_hid(device))) {
483 if (acpi_device_bus_id->instance_no > 0)
484 acpi_device_bus_id->instance_no--;
485 else {
486 list_del(&acpi_device_bus_id->node);
487 kfree(acpi_device_bus_id);
488 }
489 break;
490 }
491
492 list_del(&device->wakeup_list);
493 mutex_unlock(&acpi_device_lock);
494
495 acpi_power_add_remove_device(device, false);
496 acpi_device_remove_files(device);
497 if (device->remove)
498 device->remove(device);
499
500 device_del(&device->dev);
501}
502
503static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
504
505static LIST_HEAD(acpi_device_del_list);
506static DEFINE_MUTEX(acpi_device_del_lock);
507
508static void acpi_device_del_work_fn(struct work_struct *work_not_used)
509{
510 for (;;) {
511 struct acpi_device *adev;
512
513 mutex_lock(&acpi_device_del_lock);
514
515 if (list_empty(&acpi_device_del_list)) {
516 mutex_unlock(&acpi_device_del_lock);
517 break;
518 }
519 adev = list_first_entry(&acpi_device_del_list,
520 struct acpi_device, del_list);
521 list_del(&adev->del_list);
522
523 mutex_unlock(&acpi_device_del_lock);
524
525 blocking_notifier_call_chain(&acpi_reconfig_chain,
526 ACPI_RECONFIG_DEVICE_REMOVE, adev);
527
528 acpi_device_del(adev);
529
530
531
532
533 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
534 put_device(&adev->dev);
535 }
536}
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551static void acpi_scan_drop_device(acpi_handle handle, void *context)
552{
553 static DECLARE_WORK(work, acpi_device_del_work_fn);
554 struct acpi_device *adev = context;
555
556 mutex_lock(&acpi_device_del_lock);
557
558
559
560
561
562
563
564
565
566
567
568 if (list_empty(&acpi_device_del_list))
569 acpi_queue_hotplug_work(&work);
570
571 list_add_tail(&adev->del_list, &acpi_device_del_list);
572
573 adev->handle = INVALID_ACPI_HANDLE;
574
575 mutex_unlock(&acpi_device_del_lock);
576}
577
578static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
579 void (*callback)(void *))
580{
581 acpi_status status;
582
583 if (!device)
584 return -EINVAL;
585
586 status = acpi_get_data_full(handle, acpi_scan_drop_device,
587 (void **)device, callback);
588 if (ACPI_FAILURE(status) || !*device) {
589 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
590 handle));
591 return -ENODEV;
592 }
593 return 0;
594}
595
596int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
597{
598 return acpi_get_device_data(handle, device, NULL);
599}
600EXPORT_SYMBOL(acpi_bus_get_device);
601
602static void get_acpi_device(void *dev)
603{
604 if (dev)
605 get_device(&((struct acpi_device *)dev)->dev);
606}
607
608struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
609{
610 struct acpi_device *adev = NULL;
611
612 acpi_get_device_data(handle, &adev, get_acpi_device);
613 return adev;
614}
615
616void acpi_bus_put_acpi_device(struct acpi_device *adev)
617{
618 put_device(&adev->dev);
619}
620
621int acpi_device_add(struct acpi_device *device,
622 void (*release)(struct device *))
623{
624 int result;
625 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
626 int found = 0;
627
628 if (device->handle) {
629 acpi_status status;
630
631 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
632 device);
633 if (ACPI_FAILURE(status)) {
634 acpi_handle_err(device->handle,
635 "Unable to attach device data\n");
636 return -ENODEV;
637 }
638 }
639
640
641
642
643
644
645 INIT_LIST_HEAD(&device->children);
646 INIT_LIST_HEAD(&device->node);
647 INIT_LIST_HEAD(&device->wakeup_list);
648 INIT_LIST_HEAD(&device->physical_node_list);
649 INIT_LIST_HEAD(&device->del_list);
650 mutex_init(&device->physical_node_lock);
651
652 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
653 if (!new_bus_id) {
654 pr_err(PREFIX "Memory allocation error\n");
655 result = -ENOMEM;
656 goto err_detach;
657 }
658
659 mutex_lock(&acpi_device_lock);
660
661
662
663
664 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
665 if (!strcmp(acpi_device_bus_id->bus_id,
666 acpi_device_hid(device))) {
667 acpi_device_bus_id->instance_no++;
668 found = 1;
669 kfree(new_bus_id);
670 break;
671 }
672 }
673 if (!found) {
674 acpi_device_bus_id = new_bus_id;
675 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
676 acpi_device_bus_id->instance_no = 0;
677 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
678 }
679 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
680
681 if (device->parent)
682 list_add_tail(&device->node, &device->parent->children);
683
684 if (device->wakeup.flags.valid)
685 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
686 mutex_unlock(&acpi_device_lock);
687
688 if (device->parent)
689 device->dev.parent = &device->parent->dev;
690 device->dev.bus = &acpi_bus_type;
691 device->dev.release = release;
692 result = device_add(&device->dev);
693 if (result) {
694 dev_err(&device->dev, "Error registering device\n");
695 goto err;
696 }
697
698 result = acpi_device_setup_files(device);
699 if (result)
700 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
701 dev_name(&device->dev));
702
703 return 0;
704
705 err:
706 mutex_lock(&acpi_device_lock);
707 if (device->parent)
708 list_del(&device->node);
709 list_del(&device->wakeup_list);
710 mutex_unlock(&acpi_device_lock);
711
712 err_detach:
713 acpi_detach_data(device->handle, acpi_scan_drop_device);
714 return result;
715}
716
717
718
719
720static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
721{
722 struct acpi_device *device = NULL;
723 acpi_status status;
724
725
726
727
728
729
730 if (!handle)
731 return acpi_root;
732
733 do {
734 status = acpi_get_parent(handle, &handle);
735 if (ACPI_FAILURE(status))
736 return status == AE_NULL_ENTRY ? NULL : acpi_root;
737 } while (acpi_bus_get_device(handle, &device));
738 return device;
739}
740
741acpi_status
742acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
743{
744 acpi_status status;
745 acpi_handle tmp;
746 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
747 union acpi_object *obj;
748
749 status = acpi_get_handle(handle, "_EJD", &tmp);
750 if (ACPI_FAILURE(status))
751 return status;
752
753 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
754 if (ACPI_SUCCESS(status)) {
755 obj = buffer.pointer;
756 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
757 ejd);
758 kfree(buffer.pointer);
759 }
760 return status;
761}
762EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
763
764static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
765 struct acpi_device_wakeup *wakeup)
766{
767 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
768 union acpi_object *package = NULL;
769 union acpi_object *element = NULL;
770 acpi_status status;
771 int err = -ENODATA;
772
773 if (!wakeup)
774 return -EINVAL;
775
776 INIT_LIST_HEAD(&wakeup->resources);
777
778
779 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
780 if (ACPI_FAILURE(status)) {
781 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
782 return err;
783 }
784
785 package = (union acpi_object *)buffer.pointer;
786
787 if (!package || package->package.count < 2)
788 goto out;
789
790 element = &(package->package.elements[0]);
791 if (!element)
792 goto out;
793
794 if (element->type == ACPI_TYPE_PACKAGE) {
795 if ((element->package.count < 2) ||
796 (element->package.elements[0].type !=
797 ACPI_TYPE_LOCAL_REFERENCE)
798 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
799 goto out;
800
801 wakeup->gpe_device =
802 element->package.elements[0].reference.handle;
803 wakeup->gpe_number =
804 (u32) element->package.elements[1].integer.value;
805 } else if (element->type == ACPI_TYPE_INTEGER) {
806 wakeup->gpe_device = NULL;
807 wakeup->gpe_number = element->integer.value;
808 } else {
809 goto out;
810 }
811
812 element = &(package->package.elements[1]);
813 if (element->type != ACPI_TYPE_INTEGER)
814 goto out;
815
816 wakeup->sleep_state = element->integer.value;
817
818 err = acpi_extract_power_resources(package, 2, &wakeup->resources);
819 if (err)
820 goto out;
821
822 if (!list_empty(&wakeup->resources)) {
823 int sleep_state;
824
825 err = acpi_power_wakeup_list_init(&wakeup->resources,
826 &sleep_state);
827 if (err) {
828 acpi_handle_warn(handle, "Retrieving current states "
829 "of wakeup power resources failed\n");
830 acpi_power_resources_list_free(&wakeup->resources);
831 goto out;
832 }
833 if (sleep_state < wakeup->sleep_state) {
834 acpi_handle_warn(handle, "Overriding _PRW sleep state "
835 "(S%d) by S%d from power resources\n",
836 (int)wakeup->sleep_state, sleep_state);
837 wakeup->sleep_state = sleep_state;
838 }
839 }
840
841 out:
842 kfree(buffer.pointer);
843 return err;
844}
845
846static bool acpi_wakeup_gpe_init(struct acpi_device *device)
847{
848 static const struct acpi_device_id button_device_ids[] = {
849 {"PNP0C0C", 0},
850 {"PNP0C0D", 0},
851 {"PNP0C0E", 0},
852 {"", 0},
853 };
854 struct acpi_device_wakeup *wakeup = &device->wakeup;
855 acpi_status status;
856
857 wakeup->flags.notifier_present = 0;
858
859
860 if (!acpi_match_device_ids(device, button_device_ids)) {
861 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
862
863 if (wakeup->sleep_state == ACPI_STATE_S5)
864 wakeup->sleep_state = ACPI_STATE_S4;
865 }
866 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
867 device_set_wakeup_capable(&device->dev, true);
868 return true;
869 }
870
871 status = acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
872 wakeup->gpe_number);
873 return ACPI_SUCCESS(status);
874}
875
876static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
877{
878 int err;
879
880
881 if (!acpi_has_method(device->handle, "_PRW"))
882 return;
883
884 err = acpi_bus_extract_wakeup_device_power_package(device->handle,
885 &device->wakeup);
886 if (err) {
887 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
888 return;
889 }
890
891 device->wakeup.flags.valid = acpi_wakeup_gpe_init(device);
892 device->wakeup.prepare_count = 0;
893
894
895
896
897
898
899
900 err = acpi_device_sleep_wake(device, 0, 0, 0);
901 if (err)
902 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
903 "error in _DSW or _PSW evaluation\n"));
904}
905
906static void acpi_bus_init_power_state(struct acpi_device *device, int state)
907{
908 struct acpi_device_power_state *ps = &device->power.states[state];
909 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
910 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
911 acpi_status status;
912
913 INIT_LIST_HEAD(&ps->resources);
914
915
916 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
917 if (ACPI_SUCCESS(status)) {
918 union acpi_object *package = buffer.pointer;
919
920 if (buffer.length && package
921 && package->type == ACPI_TYPE_PACKAGE
922 && package->package.count) {
923 int err = acpi_extract_power_resources(package, 0,
924 &ps->resources);
925 if (!err)
926 device->power.flags.power_resources = 1;
927 }
928 ACPI_FREE(buffer.pointer);
929 }
930
931
932 pathname[2] = 'S';
933 if (acpi_has_method(device->handle, pathname))
934 ps->flags.explicit_set = 1;
935
936
937 if (!list_empty(&ps->resources) || ps->flags.explicit_set)
938 ps->flags.valid = 1;
939
940 ps->power = -1;
941 ps->latency = -1;
942}
943
944static void acpi_bus_get_power_flags(struct acpi_device *device)
945{
946 u32 i;
947
948
949 if (!acpi_has_method(device->handle, "_PS0") &&
950 !acpi_has_method(device->handle, "_PR0"))
951 return;
952
953 device->flags.power_manageable = 1;
954
955
956
957
958 if (acpi_has_method(device->handle, "_PSC"))
959 device->power.flags.explicit_get = 1;
960
961 if (acpi_has_method(device->handle, "_IRC"))
962 device->power.flags.inrush_current = 1;
963
964 if (acpi_has_method(device->handle, "_DSW"))
965 device->power.flags.dsw_present = 1;
966
967
968
969
970 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
971 acpi_bus_init_power_state(device, i);
972
973 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
974 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources))
975 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
976
977
978 device->power.states[ACPI_STATE_D0].flags.valid = 1;
979 device->power.states[ACPI_STATE_D0].power = 100;
980 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1;
981
982 if (acpi_bus_init_power(device))
983 device->flags.power_manageable = 0;
984}
985
986static void acpi_bus_get_flags(struct acpi_device *device)
987{
988
989 if (acpi_has_method(device->handle, "_STA"))
990 device->flags.dynamic_status = 1;
991
992
993 if (acpi_has_method(device->handle, "_RMV"))
994 device->flags.removable = 1;
995
996
997 if (acpi_has_method(device->handle, "_EJD") ||
998 acpi_has_method(device->handle, "_EJ0"))
999 device->flags.ejectable = 1;
1000}
1001
1002static void acpi_device_get_busid(struct acpi_device *device)
1003{
1004 char bus_id[5] = { '?', 0 };
1005 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1006 int i = 0;
1007
1008
1009
1010
1011
1012
1013
1014 if (ACPI_IS_ROOT_DEVICE(device)) {
1015 strcpy(device->pnp.bus_id, "ACPI");
1016 return;
1017 }
1018
1019 switch (device->device_type) {
1020 case ACPI_BUS_TYPE_POWER_BUTTON:
1021 strcpy(device->pnp.bus_id, "PWRF");
1022 break;
1023 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1024 strcpy(device->pnp.bus_id, "SLPF");
1025 break;
1026 default:
1027 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
1028
1029 for (i = 3; i > 1; i--) {
1030 if (bus_id[i] == '_')
1031 bus_id[i] = '\0';
1032 else
1033 break;
1034 }
1035 strcpy(device->pnp.bus_id, bus_id);
1036 break;
1037 }
1038}
1039
1040
1041
1042
1043
1044
1045
1046bool acpi_ata_match(acpi_handle handle)
1047{
1048 return acpi_has_method(handle, "_GTF") ||
1049 acpi_has_method(handle, "_GTM") ||
1050 acpi_has_method(handle, "_STM") ||
1051 acpi_has_method(handle, "_SDD");
1052}
1053
1054
1055
1056
1057
1058
1059
1060bool acpi_bay_match(acpi_handle handle)
1061{
1062 acpi_handle phandle;
1063
1064 if (!acpi_has_method(handle, "_EJ0"))
1065 return false;
1066 if (acpi_ata_match(handle))
1067 return true;
1068 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1069 return false;
1070
1071 return acpi_ata_match(phandle);
1072}
1073
1074bool acpi_device_is_battery(struct acpi_device *adev)
1075{
1076 struct acpi_hardware_id *hwid;
1077
1078 list_for_each_entry(hwid, &adev->pnp.ids, list)
1079 if (!strcmp("PNP0C0A", hwid->id))
1080 return true;
1081
1082 return false;
1083}
1084
1085static bool is_ejectable_bay(struct acpi_device *adev)
1086{
1087 acpi_handle handle = adev->handle;
1088
1089 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
1090 return true;
1091
1092 return acpi_bay_match(handle);
1093}
1094
1095
1096
1097
1098bool acpi_dock_match(acpi_handle handle)
1099{
1100 return acpi_has_method(handle, "_DCK");
1101}
1102
1103static acpi_status
1104acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
1105 void **return_value)
1106{
1107 long *cap = context;
1108
1109 if (acpi_has_method(handle, "_BCM") &&
1110 acpi_has_method(handle, "_BCL")) {
1111 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight "
1112 "support\n"));
1113 *cap |= ACPI_VIDEO_BACKLIGHT;
1114
1115 return AE_CTRL_TERMINATE;
1116 }
1117 return 0;
1118}
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128long acpi_is_video_device(acpi_handle handle)
1129{
1130 long video_caps = 0;
1131
1132
1133 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS"))
1134 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
1135
1136
1137 if (acpi_has_method(handle, "_ROM"))
1138 video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
1139
1140
1141 if (acpi_has_method(handle, "_VPO") &&
1142 acpi_has_method(handle, "_GPD") &&
1143 acpi_has_method(handle, "_SPD"))
1144 video_caps |= ACPI_VIDEO_DEVICE_POSTING;
1145
1146
1147 if (video_caps)
1148 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1149 ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL,
1150 &video_caps, NULL);
1151
1152 return video_caps;
1153}
1154EXPORT_SYMBOL(acpi_is_video_device);
1155
1156const char *acpi_device_hid(struct acpi_device *device)
1157{
1158 struct acpi_hardware_id *hid;
1159
1160 if (list_empty(&device->pnp.ids))
1161 return dummy_hid;
1162
1163 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1164 return hid->id;
1165}
1166EXPORT_SYMBOL(acpi_device_hid);
1167
1168static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1169{
1170 struct acpi_hardware_id *id;
1171
1172 id = kmalloc(sizeof(*id), GFP_KERNEL);
1173 if (!id)
1174 return;
1175
1176 id->id = kstrdup_const(dev_id, GFP_KERNEL);
1177 if (!id->id) {
1178 kfree(id);
1179 return;
1180 }
1181
1182 list_add_tail(&id->list, &pnp->ids);
1183 pnp->type.hardware_id = 1;
1184}
1185
1186
1187
1188
1189
1190
1191static bool acpi_ibm_smbus_match(acpi_handle handle)
1192{
1193 char node_name[ACPI_PATH_SEGMENT_LENGTH];
1194 struct acpi_buffer path = { sizeof(node_name), node_name };
1195
1196 if (!dmi_name_in_vendors("IBM"))
1197 return false;
1198
1199
1200 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1201 strcmp("SMBS", path.pointer))
1202 return false;
1203
1204
1205 if (acpi_has_method(handle, "SBI") &&
1206 acpi_has_method(handle, "SBR") &&
1207 acpi_has_method(handle, "SBW"))
1208 return true;
1209
1210 return false;
1211}
1212
1213static bool acpi_object_is_system_bus(acpi_handle handle)
1214{
1215 acpi_handle tmp;
1216
1217 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
1218 tmp == handle)
1219 return true;
1220 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
1221 tmp == handle)
1222 return true;
1223
1224 return false;
1225}
1226
1227static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1228 int device_type)
1229{
1230 acpi_status status;
1231 struct acpi_device_info *info;
1232 struct acpi_pnp_device_id_list *cid_list;
1233 int i;
1234
1235 switch (device_type) {
1236 case ACPI_BUS_TYPE_DEVICE:
1237 if (handle == ACPI_ROOT_OBJECT) {
1238 acpi_add_id(pnp, ACPI_SYSTEM_HID);
1239 break;
1240 }
1241
1242 status = acpi_get_object_info(handle, &info);
1243 if (ACPI_FAILURE(status)) {
1244 pr_err(PREFIX "%s: Error reading device info\n",
1245 __func__);
1246 return;
1247 }
1248
1249 if (info->valid & ACPI_VALID_HID) {
1250 acpi_add_id(pnp, info->hardware_id.string);
1251 pnp->type.platform_id = 1;
1252 }
1253 if (info->valid & ACPI_VALID_CID) {
1254 cid_list = &info->compatible_id_list;
1255 for (i = 0; i < cid_list->count; i++)
1256 acpi_add_id(pnp, cid_list->ids[i].string);
1257 }
1258 if (info->valid & ACPI_VALID_ADR) {
1259 pnp->bus_address = info->address;
1260 pnp->type.bus_address = 1;
1261 }
1262 if (info->valid & ACPI_VALID_UID)
1263 pnp->unique_id = kstrdup(info->unique_id.string,
1264 GFP_KERNEL);
1265 if (info->valid & ACPI_VALID_CLS)
1266 acpi_add_id(pnp, info->class_code.string);
1267
1268 kfree(info);
1269
1270
1271
1272
1273
1274 if (acpi_is_video_device(handle))
1275 acpi_add_id(pnp, ACPI_VIDEO_HID);
1276 else if (acpi_bay_match(handle))
1277 acpi_add_id(pnp, ACPI_BAY_HID);
1278 else if (acpi_dock_match(handle))
1279 acpi_add_id(pnp, ACPI_DOCK_HID);
1280 else if (acpi_ibm_smbus_match(handle))
1281 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
1282 else if (list_empty(&pnp->ids) &&
1283 acpi_object_is_system_bus(handle)) {
1284
1285 acpi_add_id(pnp, ACPI_BUS_HID);
1286 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
1287 strcpy(pnp->device_class, ACPI_BUS_CLASS);
1288 }
1289
1290 break;
1291 case ACPI_BUS_TYPE_POWER:
1292 acpi_add_id(pnp, ACPI_POWER_HID);
1293 break;
1294 case ACPI_BUS_TYPE_PROCESSOR:
1295 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
1296 break;
1297 case ACPI_BUS_TYPE_THERMAL:
1298 acpi_add_id(pnp, ACPI_THERMAL_HID);
1299 break;
1300 case ACPI_BUS_TYPE_POWER_BUTTON:
1301 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
1302 break;
1303 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1304 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
1305 break;
1306 }
1307}
1308
1309void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1310{
1311 struct acpi_hardware_id *id, *tmp;
1312
1313 list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
1314 kfree_const(id->id);
1315 kfree(id);
1316 }
1317 kfree(pnp->unique_id);
1318}
1319
1320
1321
1322
1323
1324
1325
1326bool acpi_dma_supported(struct acpi_device *adev)
1327{
1328 if (!adev)
1329 return false;
1330
1331 if (adev->flags.cca_seen)
1332 return true;
1333
1334
1335
1336
1337
1338
1339 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1340 return true;
1341
1342 return false;
1343}
1344
1345
1346
1347
1348
1349
1350
1351enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
1352{
1353 if (!acpi_dma_supported(adev))
1354 return DEV_DMA_NOT_SUPPORTED;
1355
1356 if (adev->flags.coherent_dma)
1357 return DEV_DMA_COHERENT;
1358 else
1359 return DEV_DMA_NON_COHERENT;
1360}
1361
1362
1363
1364
1365
1366
1367int acpi_dma_configure(struct device *dev, enum dev_dma_attr attr)
1368{
1369 const struct iommu_ops *iommu;
1370 u64 size;
1371
1372 iort_set_dma_mask(dev);
1373
1374 iommu = iort_iommu_configure(dev);
1375 if (IS_ERR(iommu) && PTR_ERR(iommu) == -EPROBE_DEFER)
1376 return -EPROBE_DEFER;
1377
1378 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
1379
1380
1381
1382
1383 arch_setup_dma_ops(dev, 0, size, iommu, attr == DEV_DMA_COHERENT);
1384
1385 return 0;
1386}
1387EXPORT_SYMBOL_GPL(acpi_dma_configure);
1388
1389
1390
1391
1392
1393void acpi_dma_deconfigure(struct device *dev)
1394{
1395 arch_teardown_dma_ops(dev);
1396}
1397EXPORT_SYMBOL_GPL(acpi_dma_deconfigure);
1398
1399static void acpi_init_coherency(struct acpi_device *adev)
1400{
1401 unsigned long long cca = 0;
1402 acpi_status status;
1403 struct acpi_device *parent = adev->parent;
1404
1405 if (parent && parent->flags.cca_seen) {
1406
1407
1408
1409
1410 adev->flags.cca_seen = 1;
1411 cca = parent->flags.coherent_dma;
1412 } else {
1413 status = acpi_evaluate_integer(adev->handle, "_CCA",
1414 NULL, &cca);
1415 if (ACPI_SUCCESS(status))
1416 adev->flags.cca_seen = 1;
1417 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1418
1419
1420
1421
1422
1423 cca = 1;
1424 else
1425 acpi_handle_debug(adev->handle,
1426 "ACPI device is missing _CCA.\n");
1427 }
1428
1429 adev->flags.coherent_dma = cca;
1430}
1431
1432static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
1433{
1434 bool *is_spi_i2c_slave_p = data;
1435
1436 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
1437 return 1;
1438
1439
1440
1441
1442
1443 if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
1444 *is_spi_i2c_slave_p = true;
1445
1446
1447 return -1;
1448}
1449
1450static bool acpi_is_spi_i2c_slave(struct acpi_device *device)
1451{
1452 struct list_head resource_list;
1453 bool is_spi_i2c_slave = false;
1454
1455 INIT_LIST_HEAD(&resource_list);
1456 acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
1457 &is_spi_i2c_slave);
1458 acpi_dev_free_resource_list(&resource_list);
1459
1460 return is_spi_i2c_slave;
1461}
1462
1463void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1464 int type, unsigned long long sta)
1465{
1466 INIT_LIST_HEAD(&device->pnp.ids);
1467 device->device_type = type;
1468 device->handle = handle;
1469 device->parent = acpi_bus_get_parent(handle);
1470 device->fwnode.type = FWNODE_ACPI;
1471 device->fwnode.ops = &acpi_fwnode_ops;
1472 acpi_set_device_status(device, sta);
1473 acpi_device_get_busid(device);
1474 acpi_set_pnp_ids(handle, &device->pnp, type);
1475 acpi_init_properties(device);
1476 acpi_bus_get_flags(device);
1477 device->flags.match_driver = false;
1478 device->flags.initialized = true;
1479 device->flags.spi_i2c_slave = acpi_is_spi_i2c_slave(device);
1480 acpi_device_clear_enumerated(device);
1481 device_initialize(&device->dev);
1482 dev_set_uevent_suppress(&device->dev, true);
1483 acpi_init_coherency(device);
1484}
1485
1486void acpi_device_add_finalize(struct acpi_device *device)
1487{
1488 dev_set_uevent_suppress(&device->dev, false);
1489 kobject_uevent(&device->dev.kobj, KOBJ_ADD);
1490}
1491
1492static int acpi_add_single_object(struct acpi_device **child,
1493 acpi_handle handle, int type,
1494 unsigned long long sta)
1495{
1496 int result;
1497 struct acpi_device *device;
1498 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1499
1500 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1501 if (!device) {
1502 printk(KERN_ERR PREFIX "Memory allocation error\n");
1503 return -ENOMEM;
1504 }
1505
1506 acpi_init_device_object(device, handle, type, sta);
1507 acpi_bus_get_power_flags(device);
1508 acpi_bus_get_wakeup_device_flags(device);
1509
1510 result = acpi_device_add(device, acpi_device_release);
1511 if (result) {
1512 acpi_device_release(&device->dev);
1513 return result;
1514 }
1515
1516 acpi_power_add_remove_device(device, true);
1517 acpi_device_add_finalize(device);
1518 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1519 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1520 dev_name(&device->dev), (char *) buffer.pointer,
1521 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1522 kfree(buffer.pointer);
1523 *child = device;
1524 return 0;
1525}
1526
1527static acpi_status acpi_get_resource_memory(struct acpi_resource *ares,
1528 void *context)
1529{
1530 struct resource *res = context;
1531
1532 if (acpi_dev_resource_memory(ares, res))
1533 return AE_CTRL_TERMINATE;
1534
1535 return AE_OK;
1536}
1537
1538static bool acpi_device_should_be_hidden(acpi_handle handle)
1539{
1540 acpi_status status;
1541 struct resource res;
1542
1543
1544 if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS)))
1545 return false;
1546
1547
1548
1549
1550
1551 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1552 acpi_get_resource_memory, &res);
1553 if (ACPI_FAILURE(status) || res.start != spcr_uart_addr)
1554 return false;
1555
1556 acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n",
1557 &res.start);
1558
1559 return true;
1560}
1561
1562static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1563 unsigned long long *sta)
1564{
1565 acpi_status status;
1566 acpi_object_type acpi_type;
1567
1568 status = acpi_get_type(handle, &acpi_type);
1569 if (ACPI_FAILURE(status))
1570 return -ENODEV;
1571
1572 switch (acpi_type) {
1573 case ACPI_TYPE_ANY:
1574 case ACPI_TYPE_DEVICE:
1575 if (acpi_device_should_be_hidden(handle))
1576 return -ENODEV;
1577
1578 *type = ACPI_BUS_TYPE_DEVICE;
1579 status = acpi_bus_get_status_handle(handle, sta);
1580 if (ACPI_FAILURE(status))
1581 *sta = 0;
1582 break;
1583 case ACPI_TYPE_PROCESSOR:
1584 *type = ACPI_BUS_TYPE_PROCESSOR;
1585 status = acpi_bus_get_status_handle(handle, sta);
1586 if (ACPI_FAILURE(status))
1587 return -ENODEV;
1588 break;
1589 case ACPI_TYPE_THERMAL:
1590 *type = ACPI_BUS_TYPE_THERMAL;
1591 *sta = ACPI_STA_DEFAULT;
1592 break;
1593 case ACPI_TYPE_POWER:
1594 *type = ACPI_BUS_TYPE_POWER;
1595 *sta = ACPI_STA_DEFAULT;
1596 break;
1597 default:
1598 return -ENODEV;
1599 }
1600
1601 return 0;
1602}
1603
1604bool acpi_device_is_present(const struct acpi_device *adev)
1605{
1606 return adev->status.present || adev->status.functional;
1607}
1608
1609static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
1610 const char *idstr,
1611 const struct acpi_device_id **matchid)
1612{
1613 const struct acpi_device_id *devid;
1614
1615 if (handler->match)
1616 return handler->match(idstr, matchid);
1617
1618 for (devid = handler->ids; devid->id[0]; devid++)
1619 if (!strcmp((char *)devid->id, idstr)) {
1620 if (matchid)
1621 *matchid = devid;
1622
1623 return true;
1624 }
1625
1626 return false;
1627}
1628
1629static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr,
1630 const struct acpi_device_id **matchid)
1631{
1632 struct acpi_scan_handler *handler;
1633
1634 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
1635 if (acpi_scan_handler_matching(handler, idstr, matchid))
1636 return handler;
1637
1638 return NULL;
1639}
1640
1641void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
1642{
1643 if (!!hotplug->enabled == !!val)
1644 return;
1645
1646 mutex_lock(&acpi_scan_lock);
1647
1648 hotplug->enabled = val;
1649
1650 mutex_unlock(&acpi_scan_lock);
1651}
1652
1653static void acpi_scan_init_hotplug(struct acpi_device *adev)
1654{
1655 struct acpi_hardware_id *hwid;
1656
1657 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
1658 acpi_dock_add(adev);
1659 return;
1660 }
1661 list_for_each_entry(hwid, &adev->pnp.ids, list) {
1662 struct acpi_scan_handler *handler;
1663
1664 handler = acpi_scan_match_handler(hwid->id, NULL);
1665 if (handler) {
1666 adev->flags.hotplug_notify = true;
1667 break;
1668 }
1669 }
1670}
1671
1672static void acpi_device_dep_initialize(struct acpi_device *adev)
1673{
1674 struct acpi_dep_data *dep;
1675 struct acpi_handle_list dep_devices;
1676 acpi_status status;
1677 int i;
1678
1679 if (!acpi_has_method(adev->handle, "_DEP"))
1680 return;
1681
1682 status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
1683 &dep_devices);
1684 if (ACPI_FAILURE(status)) {
1685 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
1686 return;
1687 }
1688
1689 for (i = 0; i < dep_devices.count; i++) {
1690 struct acpi_device_info *info;
1691 int skip;
1692
1693 status = acpi_get_object_info(dep_devices.handles[i], &info);
1694 if (ACPI_FAILURE(status)) {
1695 dev_dbg(&adev->dev, "Error reading _DEP device info\n");
1696 continue;
1697 }
1698
1699
1700
1701
1702
1703 skip = info->valid & ACPI_VALID_HID &&
1704 !strcmp(info->hardware_id.string, "INT3396");
1705
1706 kfree(info);
1707
1708 if (skip)
1709 continue;
1710
1711 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
1712 if (!dep)
1713 return;
1714
1715 dep->master = dep_devices.handles[i];
1716 dep->slave = adev->handle;
1717 adev->dep_unmet++;
1718
1719 mutex_lock(&acpi_dep_list_lock);
1720 list_add_tail(&dep->node , &acpi_dep_list);
1721 mutex_unlock(&acpi_dep_list_lock);
1722 }
1723}
1724
1725static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1726 void *not_used, void **return_value)
1727{
1728 struct acpi_device *device = NULL;
1729 int type;
1730 unsigned long long sta;
1731 int result;
1732
1733 acpi_bus_get_device(handle, &device);
1734 if (device)
1735 goto out;
1736
1737 result = acpi_bus_type_and_status(handle, &type, &sta);
1738 if (result)
1739 return AE_OK;
1740
1741 if (type == ACPI_BUS_TYPE_POWER) {
1742 acpi_add_power_resource(handle);
1743 return AE_OK;
1744 }
1745
1746 acpi_add_single_object(&device, handle, type, sta);
1747 if (!device)
1748 return AE_CTRL_DEPTH;
1749
1750 acpi_scan_init_hotplug(device);
1751 acpi_device_dep_initialize(device);
1752
1753 out:
1754 if (!*return_value)
1755 *return_value = device;
1756
1757 return AE_OK;
1758}
1759
1760static void acpi_default_enumeration(struct acpi_device *device)
1761{
1762
1763
1764
1765
1766 if (!device->flags.spi_i2c_slave) {
1767 acpi_create_platform_device(device, NULL);
1768 acpi_device_set_enumerated(device);
1769 } else {
1770 blocking_notifier_call_chain(&acpi_reconfig_chain,
1771 ACPI_RECONFIG_DEVICE_ADD, device);
1772 }
1773}
1774
1775static const struct acpi_device_id generic_device_ids[] = {
1776 {ACPI_DT_NAMESPACE_HID, },
1777 {"", },
1778};
1779
1780static int acpi_generic_device_attach(struct acpi_device *adev,
1781 const struct acpi_device_id *not_used)
1782{
1783
1784
1785
1786
1787 if (adev->data.of_compatible)
1788 acpi_default_enumeration(adev);
1789
1790 return 1;
1791}
1792
1793static struct acpi_scan_handler generic_device_handler = {
1794 .ids = generic_device_ids,
1795 .attach = acpi_generic_device_attach,
1796};
1797
1798static int acpi_scan_attach_handler(struct acpi_device *device)
1799{
1800 struct acpi_hardware_id *hwid;
1801 int ret = 0;
1802
1803 list_for_each_entry(hwid, &device->pnp.ids, list) {
1804 const struct acpi_device_id *devid;
1805 struct acpi_scan_handler *handler;
1806
1807 handler = acpi_scan_match_handler(hwid->id, &devid);
1808 if (handler) {
1809 if (!handler->attach) {
1810 device->pnp.type.platform_id = 0;
1811 continue;
1812 }
1813 device->handler = handler;
1814 ret = handler->attach(device, devid);
1815 if (ret > 0)
1816 break;
1817
1818 device->handler = NULL;
1819 if (ret < 0)
1820 break;
1821 }
1822 }
1823
1824 return ret;
1825}
1826
1827static void acpi_bus_attach(struct acpi_device *device)
1828{
1829 struct acpi_device *child;
1830 acpi_handle ejd;
1831 int ret;
1832
1833 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
1834 register_dock_dependent_device(device, ejd);
1835
1836 acpi_bus_get_status(device);
1837
1838 if (!acpi_device_is_present(device)) {
1839 device->flags.initialized = false;
1840 acpi_device_clear_enumerated(device);
1841 device->flags.power_manageable = 0;
1842 return;
1843 }
1844 if (device->handler)
1845 goto ok;
1846
1847 if (!device->flags.initialized) {
1848 device->flags.power_manageable =
1849 device->power.states[ACPI_STATE_D0].flags.valid;
1850 if (acpi_bus_init_power(device))
1851 device->flags.power_manageable = 0;
1852
1853 device->flags.initialized = true;
1854 } else if (device->flags.visited) {
1855 goto ok;
1856 }
1857
1858 ret = acpi_scan_attach_handler(device);
1859 if (ret < 0)
1860 return;
1861
1862 device->flags.match_driver = true;
1863 if (ret > 0 && !device->flags.spi_i2c_slave) {
1864 acpi_device_set_enumerated(device);
1865 goto ok;
1866 }
1867
1868 ret = device_attach(&device->dev);
1869 if (ret < 0)
1870 return;
1871
1872 if (!device->pnp.type.platform_id && !device->flags.spi_i2c_slave)
1873 acpi_device_set_enumerated(device);
1874 else
1875 acpi_default_enumeration(device);
1876
1877 ok:
1878 list_for_each_entry(child, &device->children, node)
1879 acpi_bus_attach(child);
1880
1881 if (device->handler && device->handler->hotplug.notify_online)
1882 device->handler->hotplug.notify_online(device);
1883}
1884
1885void acpi_walk_dep_device_list(acpi_handle handle)
1886{
1887 struct acpi_dep_data *dep, *tmp;
1888 struct acpi_device *adev;
1889
1890 mutex_lock(&acpi_dep_list_lock);
1891 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
1892 if (dep->master == handle) {
1893 acpi_bus_get_device(dep->slave, &adev);
1894 if (!adev)
1895 continue;
1896
1897 adev->dep_unmet--;
1898 if (!adev->dep_unmet)
1899 acpi_bus_attach(adev);
1900 list_del(&dep->node);
1901 kfree(dep);
1902 }
1903 }
1904 mutex_unlock(&acpi_dep_list_lock);
1905}
1906EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922int acpi_bus_scan(acpi_handle handle)
1923{
1924 void *device = NULL;
1925
1926 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
1927 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1928 acpi_bus_check_add, NULL, NULL, &device);
1929
1930 if (device) {
1931 acpi_bus_attach(device);
1932 return 0;
1933 }
1934 return -ENODEV;
1935}
1936EXPORT_SYMBOL(acpi_bus_scan);
1937
1938
1939
1940
1941
1942
1943
1944void acpi_bus_trim(struct acpi_device *adev)
1945{
1946 struct acpi_scan_handler *handler = adev->handler;
1947 struct acpi_device *child;
1948
1949 list_for_each_entry_reverse(child, &adev->children, node)
1950 acpi_bus_trim(child);
1951
1952 adev->flags.match_driver = false;
1953 if (handler) {
1954 if (handler->detach)
1955 handler->detach(adev);
1956
1957 adev->handler = NULL;
1958 } else {
1959 device_release_driver(&adev->dev);
1960 }
1961
1962
1963
1964
1965 acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
1966 adev->flags.initialized = false;
1967 acpi_device_clear_enumerated(adev);
1968}
1969EXPORT_SYMBOL_GPL(acpi_bus_trim);
1970
1971static int acpi_bus_scan_fixed(void)
1972{
1973 int result = 0;
1974
1975
1976
1977
1978 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
1979 struct acpi_device *device = NULL;
1980
1981 result = acpi_add_single_object(&device, NULL,
1982 ACPI_BUS_TYPE_POWER_BUTTON,
1983 ACPI_STA_DEFAULT);
1984 if (result)
1985 return result;
1986
1987 device->flags.match_driver = true;
1988 result = device_attach(&device->dev);
1989 if (result < 0)
1990 return result;
1991
1992 device_init_wakeup(&device->dev, true);
1993 }
1994
1995 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
1996 struct acpi_device *device = NULL;
1997
1998 result = acpi_add_single_object(&device, NULL,
1999 ACPI_BUS_TYPE_SLEEP_BUTTON,
2000 ACPI_STA_DEFAULT);
2001 if (result)
2002 return result;
2003
2004 device->flags.match_driver = true;
2005 result = device_attach(&device->dev);
2006 }
2007
2008 return result < 0 ? result : 0;
2009}
2010
2011static void __init acpi_get_spcr_uart_addr(void)
2012{
2013 acpi_status status;
2014 struct acpi_table_spcr *spcr_ptr;
2015
2016 status = acpi_get_table(ACPI_SIG_SPCR, 0,
2017 (struct acpi_table_header **)&spcr_ptr);
2018 if (ACPI_SUCCESS(status))
2019 spcr_uart_addr = spcr_ptr->serial_port.address;
2020 else
2021 printk(KERN_WARNING PREFIX "STAO table present, but SPCR is missing\n");
2022}
2023
2024static bool acpi_scan_initialized;
2025
2026int __init acpi_scan_init(void)
2027{
2028 int result;
2029 acpi_status status;
2030 struct acpi_table_stao *stao_ptr;
2031
2032 acpi_pci_root_init();
2033 acpi_pci_link_init();
2034 acpi_processor_init();
2035 acpi_lpss_init();
2036 acpi_apd_init();
2037 acpi_cmos_rtc_init();
2038 acpi_container_init();
2039 acpi_memory_hotplug_init();
2040 acpi_pnp_init();
2041 acpi_int340x_thermal_init();
2042 acpi_amba_init();
2043 acpi_watchdog_init();
2044
2045 acpi_scan_add_handler(&generic_device_handler);
2046
2047
2048
2049
2050
2051 status = acpi_get_table(ACPI_SIG_STAO, 0,
2052 (struct acpi_table_header **)&stao_ptr);
2053 if (ACPI_SUCCESS(status)) {
2054 if (stao_ptr->header.length > sizeof(struct acpi_table_stao))
2055 printk(KERN_INFO PREFIX "STAO Name List not yet supported.");
2056
2057 if (stao_ptr->ignore_uart)
2058 acpi_get_spcr_uart_addr();
2059 }
2060
2061 mutex_lock(&acpi_scan_lock);
2062
2063
2064
2065 result = acpi_bus_scan(ACPI_ROOT_OBJECT);
2066 if (result)
2067 goto out;
2068
2069 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
2070 if (result)
2071 goto out;
2072
2073
2074 if (!acpi_gbl_reduced_hardware) {
2075 result = acpi_bus_scan_fixed();
2076 if (result) {
2077 acpi_detach_data(acpi_root->handle,
2078 acpi_scan_drop_device);
2079 acpi_device_del(acpi_root);
2080 put_device(&acpi_root->dev);
2081 goto out;
2082 }
2083 }
2084
2085 acpi_gpe_apply_masked_gpes();
2086 acpi_update_all_gpes();
2087
2088 acpi_scan_initialized = true;
2089
2090 out:
2091 mutex_unlock(&acpi_scan_lock);
2092 return result;
2093}
2094
2095static struct acpi_probe_entry *ape;
2096static int acpi_probe_count;
2097static DEFINE_MUTEX(acpi_probe_mutex);
2098
2099static int __init acpi_match_madt(struct acpi_subtable_header *header,
2100 const unsigned long end)
2101{
2102 if (!ape->subtable_valid || ape->subtable_valid(header, ape))
2103 if (!ape->probe_subtbl(header, end))
2104 acpi_probe_count++;
2105
2106 return 0;
2107}
2108
2109int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
2110{
2111 int count = 0;
2112
2113 if (acpi_disabled)
2114 return 0;
2115
2116 mutex_lock(&acpi_probe_mutex);
2117 for (ape = ap_head; nr; ape++, nr--) {
2118 if (ACPI_COMPARE_NAME(ACPI_SIG_MADT, ape->id)) {
2119 acpi_probe_count = 0;
2120 acpi_table_parse_madt(ape->type, acpi_match_madt, 0);
2121 count += acpi_probe_count;
2122 } else {
2123 int res;
2124 res = acpi_table_parse(ape->id, ape->probe_table);
2125 if (!res)
2126 count++;
2127 }
2128 }
2129 mutex_unlock(&acpi_probe_mutex);
2130
2131 return count;
2132}
2133
2134struct acpi_table_events_work {
2135 struct work_struct work;
2136 void *table;
2137 u32 event;
2138};
2139
2140static void acpi_table_events_fn(struct work_struct *work)
2141{
2142 struct acpi_table_events_work *tew;
2143
2144 tew = container_of(work, struct acpi_table_events_work, work);
2145
2146 if (tew->event == ACPI_TABLE_EVENT_LOAD) {
2147 acpi_scan_lock_acquire();
2148 acpi_bus_scan(ACPI_ROOT_OBJECT);
2149 acpi_scan_lock_release();
2150 }
2151
2152 kfree(tew);
2153}
2154
2155void acpi_scan_table_handler(u32 event, void *table, void *context)
2156{
2157 struct acpi_table_events_work *tew;
2158
2159 if (!acpi_scan_initialized)
2160 return;
2161
2162 if (event != ACPI_TABLE_EVENT_LOAD)
2163 return;
2164
2165 tew = kmalloc(sizeof(*tew), GFP_KERNEL);
2166 if (!tew)
2167 return;
2168
2169 INIT_WORK(&tew->work, acpi_table_events_fn);
2170 tew->table = table;
2171 tew->event = event;
2172
2173 schedule_work(&tew->work);
2174}
2175
2176int acpi_reconfig_notifier_register(struct notifier_block *nb)
2177{
2178 return blocking_notifier_chain_register(&acpi_reconfig_chain, nb);
2179}
2180EXPORT_SYMBOL(acpi_reconfig_notifier_register);
2181
2182int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
2183{
2184 return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb);
2185}
2186EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);
2187