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