Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/acpi/scan.c

  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
 21 ACPI_MODULE_NAME("scan");
 22 extern 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  */
 36 bool acpi_force_hot_remove;
 37 
 38 static const char *dummy_hid = "device";
 39 
 40 static LIST_HEAD(acpi_dep_list);
 41 static DEFINE_MUTEX(acpi_dep_list_lock);
 42 LIST_HEAD(acpi_bus_id_list);
 43 static DEFINE_MUTEX(acpi_scan_lock);
 44 static LIST_HEAD(acpi_scan_handlers_list);
 45 DEFINE_MUTEX(acpi_device_lock);
 46 LIST_HEAD(acpi_wakeup_device_list);
 47 static 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  */
 54 static u64 spcr_uart_addr;
 55 
 56 struct acpi_dep_data {
 57         struct list_head node;
 58         acpi_handle master;
 59         acpi_handle slave;
 60 };
 61 
 62 void acpi_scan_lock_acquire(void)
 63 {
 64         mutex_lock(&acpi_scan_lock);
 65 }
 66 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
 67 
 68 void acpi_scan_lock_release(void)
 69 {
 70         mutex_unlock(&acpi_scan_lock);
 71 }
 72 EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
 73 
 74 void acpi_lock_hp_context(void)
 75 {
 76         mutex_lock(&acpi_hp_context_lock);
 77 }
 78 
 79 void acpi_unlock_hp_context(void)
 80 {
 81         mutex_unlock(&acpi_hp_context_lock);
 82 }
 83 
 84 void 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 }
 95 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
 96 
 97 int 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 
106 int 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 
119 bool 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 
143 static 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 
191 static 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 
213 static 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 
259 static 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 
306 static 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 
316 static 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 
349 static 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 
376 static 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 
396 void 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 
447 static 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 
463 static 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 
473 static 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 
504 static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
505 
506 static LIST_HEAD(acpi_device_del_list);
507 static DEFINE_MUTEX(acpi_device_del_lock);
508 
509 static 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  */
552 static 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 
579 static 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 
597 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
598 {
599         return acpi_get_device_data(handle, device, NULL);
600 }
601 EXPORT_SYMBOL(acpi_bus_get_device);
602 
603 static void get_acpi_device(void *dev)
604 {
605         if (dev)
606                 get_device(&((struct acpi_device *)dev)->dev);
607 }
608 
609 struct 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 
617 void acpi_bus_put_acpi_device(struct acpi_device *adev)
618 {
619         put_device(&adev->dev);
620 }
621 
622 int 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    -------------------------------------------------------------------------- */
721 static 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 
742 acpi_status
743 acpi_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 }
763 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
764 
765 static 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 
847 static 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 
884 static 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 
914 static 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', '' + 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 
952 static 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 
994 static 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 
1010 static 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  */
1054 bool 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  */
1068 bool 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 
1082 bool 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 
1093 static 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  */
1106 bool acpi_dock_match(acpi_handle handle)
1107 {
1108         return acpi_has_method(handle, "_DCK");
1109 }
1110 
1111 static acpi_status
1112 acpi_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  */
1139 long 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 }
1165 EXPORT_SYMBOL(acpi_is_video_device);
1166 
1167 const 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 }
1177 EXPORT_SYMBOL(acpi_device_hid);
1178 
1179 static 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  */
1202 static 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 
1224 static 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 
1238 static 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 
1320 void 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  */
1337 bool 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  */
1362 enum 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 
1373 static 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 
1406 void 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 
1427 void 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 
1433 static 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 
1468 static 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 
1479 static 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 
1503 static 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 
1545 bool 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 
1554 static 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 
1574 static 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 
1586 void 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 
1598 static 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 
1617 static 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 
1670 static 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 
1705 static 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 
1723 static 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);
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 
1745 static const struct acpi_device_id generic_device_ids[] = {
1746         {ACPI_DT_NAMESPACE_HID, },
1747         {"", },
1748 };
1749 
1750 static 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 
1763 static struct acpi_scan_handler generic_device_handler = {
1764         .ids = generic_device_ids,
1765         .attach = acpi_generic_device_attach,
1766 };
1767 
1768 static 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 
1797 static 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) {
1831                 ret = device_attach(&device->dev);
1832                 if (ret < 0)
1833                         return;
1834 
1835                 if (!ret && device->pnp.type.platform_id)
1836                         acpi_default_enumeration(device);
1837         }
1838 
1839  ok:
1840         list_for_each_entry(child, &device->children, node)
1841                 acpi_bus_attach(child);
1842 
1843         if (device->handler && device->handler->hotplug.notify_online)
1844                 device->handler->hotplug.notify_online(device);
1845 }
1846 
1847 void acpi_walk_dep_device_list(acpi_handle handle)
1848 {
1849         struct acpi_dep_data *dep, *tmp;
1850         struct acpi_device *adev;
1851 
1852         mutex_lock(&acpi_dep_list_lock);
1853         list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
1854                 if (dep->master == handle) {
1855                         acpi_bus_get_device(dep->slave, &adev);
1856                         if (!adev)
1857                                 continue;
1858 
1859                         adev->dep_unmet--;
1860                         if (!adev->dep_unmet)
1861                                 acpi_bus_attach(adev);
1862                         list_del(&dep->node);
1863                         kfree(dep);
1864                 }
1865         }
1866         mutex_unlock(&acpi_dep_list_lock);
1867 }
1868 EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
1869 
1870 /**
1871  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1872  * @handle: Root of the namespace scope to scan.
1873  *
1874  * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1875  * found devices.
1876  *
1877  * If no devices were found, -ENODEV is returned, but it does not mean that
1878  * there has been a real error.  There just have been no suitable ACPI objects
1879  * in the table trunk from which the kernel could create a device and add an
1880  * appropriate driver.
1881  *
1882  * Must be called under acpi_scan_lock.
1883  */
1884 int acpi_bus_scan(acpi_handle handle)
1885 {
1886         void *device = NULL;
1887 
1888         if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
1889                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1890                                     acpi_bus_check_add, NULL, NULL, &device);
1891 
1892         if (device) {
1893                 acpi_bus_attach(device);
1894                 return 0;
1895         }
1896         return -ENODEV;
1897 }
1898 EXPORT_SYMBOL(acpi_bus_scan);
1899 
1900 /**
1901  * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
1902  * @adev: Root of the ACPI namespace scope to walk.
1903  *
1904  * Must be called under acpi_scan_lock.
1905  */
1906 void acpi_bus_trim(struct acpi_device *adev)
1907 {
1908         struct acpi_scan_handler *handler = adev->handler;
1909         struct acpi_device *child;
1910 
1911         list_for_each_entry_reverse(child, &adev->children, node)
1912                 acpi_bus_trim(child);
1913 
1914         adev->flags.match_driver = false;
1915         if (handler) {
1916                 if (handler->detach)
1917                         handler->detach(adev);
1918 
1919                 adev->handler = NULL;
1920         } else {
1921                 device_release_driver(&adev->dev);
1922         }
1923         /*
1924          * Most likely, the device is going away, so put it into D3cold before
1925          * that.
1926          */
1927         acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
1928         adev->flags.initialized = false;
1929         acpi_device_clear_enumerated(adev);
1930 }
1931 EXPORT_SYMBOL_GPL(acpi_bus_trim);
1932 
1933 static int acpi_bus_scan_fixed(void)
1934 {
1935         int result = 0;
1936 
1937         /*
1938          * Enumerate all fixed-feature devices.
1939          */
1940         if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
1941                 struct acpi_device *device = NULL;
1942 
1943                 result = acpi_add_single_object(&device, NULL,
1944                                                 ACPI_BUS_TYPE_POWER_BUTTON,
1945                                                 ACPI_STA_DEFAULT);
1946                 if (result)
1947                         return result;
1948 
1949                 device->flags.match_driver = true;
1950                 result = device_attach(&device->dev);
1951                 if (result < 0)
1952                         return result;
1953 
1954                 device_init_wakeup(&device->dev, true);
1955         }
1956 
1957         if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
1958                 struct acpi_device *device = NULL;
1959 
1960                 result = acpi_add_single_object(&device, NULL,
1961                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
1962                                                 ACPI_STA_DEFAULT);
1963                 if (result)
1964                         return result;
1965 
1966                 device->flags.match_driver = true;
1967                 result = device_attach(&device->dev);
1968         }
1969 
1970         return result < 0 ? result : 0;
1971 }
1972 
1973 static void __init acpi_get_spcr_uart_addr(void)
1974 {
1975         acpi_status status;
1976         struct acpi_table_spcr *spcr_ptr;
1977 
1978         status = acpi_get_table(ACPI_SIG_SPCR, 0,
1979                                 (struct acpi_table_header **)&spcr_ptr);
1980         if (ACPI_SUCCESS(status))
1981                 spcr_uart_addr = spcr_ptr->serial_port.address;
1982         else
1983                 printk(KERN_WARNING PREFIX "STAO table present, but SPCR is missing\n");
1984 }
1985 
1986 static bool acpi_scan_initialized;
1987 
1988 int __init acpi_scan_init(void)
1989 {
1990         int result;
1991         acpi_status status;
1992         struct acpi_table_stao *stao_ptr;
1993 
1994         acpi_pci_root_init();
1995         acpi_pci_link_init();
1996         acpi_processor_init();
1997         acpi_lpss_init();
1998         acpi_apd_init();
1999         acpi_cmos_rtc_init();
2000         acpi_container_init();
2001         acpi_memory_hotplug_init();
2002         acpi_pnp_init();
2003         acpi_int340x_thermal_init();
2004         acpi_amba_init();
2005 
2006         acpi_scan_add_handler(&generic_device_handler);
2007 
2008         /*
2009          * If there is STAO table, check whether it needs to ignore the UART
2010          * device in SPCR table.
2011          */
2012         status = acpi_get_table(ACPI_SIG_STAO, 0,
2013                                 (struct acpi_table_header **)&stao_ptr);
2014         if (ACPI_SUCCESS(status)) {
2015                 if (stao_ptr->header.length > sizeof(struct acpi_table_stao))
2016                         printk(KERN_INFO PREFIX "STAO Name List not yet supported.");
2017 
2018                 if (stao_ptr->ignore_uart)
2019                         acpi_get_spcr_uart_addr();
2020         }
2021 
2022         mutex_lock(&acpi_scan_lock);
2023         /*
2024          * Enumerate devices in the ACPI namespace.
2025          */
2026         result = acpi_bus_scan(ACPI_ROOT_OBJECT);
2027         if (result)
2028                 goto out;
2029 
2030         result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
2031         if (result)
2032                 goto out;
2033 
2034         /* Fixed feature devices do not exist on HW-reduced platform */
2035         if (!acpi_gbl_reduced_hardware) {
2036                 result = acpi_bus_scan_fixed();
2037                 if (result) {
2038                         acpi_detach_data(acpi_root->handle,
2039                                          acpi_scan_drop_device);
2040                         acpi_device_del(acpi_root);
2041                         put_device(&acpi_root->dev);
2042                         goto out;
2043                 }
2044         }
2045 
2046         acpi_update_all_gpes();
2047 
2048         acpi_scan_initialized = true;
2049 
2050  out:
2051         mutex_unlock(&acpi_scan_lock);
2052         return result;
2053 }
2054 
2055 static struct acpi_probe_entry *ape;
2056 static int acpi_probe_count;
2057 static DEFINE_MUTEX(acpi_probe_mutex);
2058 
2059 static int __init acpi_match_madt(struct acpi_subtable_header *header,
2060                                   const unsigned long end)
2061 {
2062         if (!ape->subtable_valid || ape->subtable_valid(header, ape))
2063                 if (!ape->probe_subtbl(header, end))
2064                         acpi_probe_count++;
2065 
2066         return 0;
2067 }
2068 
2069 int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
2070 {
2071         int count = 0;
2072 
2073         if (acpi_disabled)
2074                 return 0;
2075 
2076         mutex_lock(&acpi_probe_mutex);
2077         for (ape = ap_head; nr; ape++, nr--) {
2078                 if (ACPI_COMPARE_NAME(ACPI_SIG_MADT, ape->id)) {
2079                         acpi_probe_count = 0;
2080                         acpi_table_parse_madt(ape->type, acpi_match_madt, 0);
2081                         count += acpi_probe_count;
2082                 } else {
2083                         int res;
2084                         res = acpi_table_parse(ape->id, ape->probe_table);
2085                         if (!res)
2086                                 count++;
2087                 }
2088         }
2089         mutex_unlock(&acpi_probe_mutex);
2090 
2091         return count;
2092 }
2093 
2094 struct acpi_table_events_work {
2095         struct work_struct work;
2096         void *table;
2097         u32 event;
2098 };
2099 
2100 static void acpi_table_events_fn(struct work_struct *work)
2101 {
2102         struct acpi_table_events_work *tew;
2103 
2104         tew = container_of(work, struct acpi_table_events_work, work);
2105 
2106         if (tew->event == ACPI_TABLE_EVENT_LOAD) {
2107                 acpi_scan_lock_acquire();
2108                 acpi_bus_scan(ACPI_ROOT_OBJECT);
2109                 acpi_scan_lock_release();
2110         }
2111 
2112         kfree(tew);
2113 }
2114 
2115 void acpi_scan_table_handler(u32 event, void *table, void *context)
2116 {
2117         struct acpi_table_events_work *tew;
2118 
2119         if (!acpi_scan_initialized)
2120                 return;
2121 
2122         if (event != ACPI_TABLE_EVENT_LOAD)
2123                 return;
2124 
2125         tew = kmalloc(sizeof(*tew), GFP_KERNEL);
2126         if (!tew)
2127                 return;
2128 
2129         INIT_WORK(&tew->work, acpi_table_events_fn);
2130         tew->table = table;
2131         tew->event = event;
2132 
2133         schedule_work(&tew->work);
2134 }
2135 
2136 int acpi_reconfig_notifier_register(struct notifier_block *nb)
2137 {
2138         return blocking_notifier_chain_register(&acpi_reconfig_chain, nb);
2139 }
2140 EXPORT_SYMBOL(acpi_reconfig_notifier_register);
2141 
2142 int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
2143 {
2144         return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb);
2145 }
2146 EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);
2147 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us