source: src/linux/universal/linux-4.9/drivers/acpi/scan.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

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