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