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