xref: /openbmc/linux/drivers/acpi/scan.c (revision a1e58bbd)
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/kernel.h>
8 #include <linux/acpi.h>
9 
10 #include <acpi/acpi_drivers.h>
11 #include <acpi/acinterp.h>	/* for acpi_ex_eisa_id_to_string() */
12 
13 #define _COMPONENT		ACPI_BUS_COMPONENT
14 ACPI_MODULE_NAME("scan");
15 #define STRUCT_TO_INT(s)	(*((int*)&s))
16 extern struct acpi_device *acpi_root;
17 
18 #define ACPI_BUS_CLASS			"system_bus"
19 #define ACPI_BUS_HID			"LNXSYBUS"
20 #define ACPI_BUS_DEVICE_NAME		"System Bus"
21 
22 static LIST_HEAD(acpi_device_list);
23 static LIST_HEAD(acpi_bus_id_list);
24 DEFINE_SPINLOCK(acpi_device_lock);
25 LIST_HEAD(acpi_wakeup_device_list);
26 
27 struct acpi_device_bus_id{
28 	char bus_id[15];
29 	unsigned int instance_no;
30 	struct list_head node;
31 };
32 
33 /*
34  * Creates hid/cid(s) string needed for modalias and uevent
35  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
36  * char *modalias: "acpi:IBM0001:ACPI0001"
37 */
38 static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
39 			   int size)
40 {
41 	int len;
42 	int count;
43 
44 	if (!acpi_dev->flags.hardware_id && !acpi_dev->flags.compatible_ids)
45 		return -ENODEV;
46 
47 	len = snprintf(modalias, size, "acpi:");
48 	size -= len;
49 
50 	if (acpi_dev->flags.hardware_id) {
51 		count = snprintf(&modalias[len], size, "%s:",
52 				 acpi_dev->pnp.hardware_id);
53 		if (count < 0 || count >= size)
54 			return -EINVAL;
55 		len += count;
56 		size -= count;
57 	}
58 
59 	if (acpi_dev->flags.compatible_ids) {
60 		struct acpi_compatible_id_list *cid_list;
61 		int i;
62 
63 		cid_list = acpi_dev->pnp.cid_list;
64 		for (i = 0; i < cid_list->count; i++) {
65 			count = snprintf(&modalias[len], size, "%s:",
66 					 cid_list->id[i].value);
67 			if (count < 0 || count >= size) {
68 				printk(KERN_ERR PREFIX "%s cid[%i] exceeds event buffer size",
69 				       acpi_dev->pnp.device_name, i);
70 				break;
71 			}
72 			len += count;
73 			size -= count;
74 		}
75 	}
76 
77 	modalias[len] = '\0';
78 	return len;
79 }
80 
81 static ssize_t
82 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
83 	struct acpi_device *acpi_dev = to_acpi_device(dev);
84 	int len;
85 
86 	/* Device has no HID and no CID or string is >1024 */
87 	len = create_modalias(acpi_dev, buf, 1024);
88 	if (len <= 0)
89 		return 0;
90 	buf[len++] = '\n';
91 	return len;
92 }
93 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
94 
95 static int acpi_eject_operation(acpi_handle handle, int lockable)
96 {
97 	struct acpi_object_list arg_list;
98 	union acpi_object arg;
99 	acpi_status status = AE_OK;
100 
101 	/*
102 	 * TBD: evaluate _PS3?
103 	 */
104 
105 	if (lockable) {
106 		arg_list.count = 1;
107 		arg_list.pointer = &arg;
108 		arg.type = ACPI_TYPE_INTEGER;
109 		arg.integer.value = 0;
110 		acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
111 	}
112 
113 	arg_list.count = 1;
114 	arg_list.pointer = &arg;
115 	arg.type = ACPI_TYPE_INTEGER;
116 	arg.integer.value = 1;
117 
118 	/*
119 	 * TBD: _EJD support.
120 	 */
121 
122 	status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
123 	if (ACPI_FAILURE(status)) {
124 		return (-ENODEV);
125 	}
126 
127 	return (0);
128 }
129 
130 static ssize_t
131 acpi_eject_store(struct device *d, struct device_attribute *attr,
132 		const char *buf, size_t count)
133 {
134 	int result;
135 	int ret = count;
136 	int islockable;
137 	acpi_status status;
138 	acpi_handle handle;
139 	acpi_object_type type = 0;
140 	struct acpi_device *acpi_device = to_acpi_device(d);
141 
142 	if ((!count) || (buf[0] != '1')) {
143 		return -EINVAL;
144 	}
145 #ifndef FORCE_EJECT
146 	if (acpi_device->driver == NULL) {
147 		ret = -ENODEV;
148 		goto err;
149 	}
150 #endif
151 	status = acpi_get_type(acpi_device->handle, &type);
152 	if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
153 		ret = -ENODEV;
154 		goto err;
155 	}
156 
157 	islockable = acpi_device->flags.lockable;
158 	handle = acpi_device->handle;
159 
160 	result = acpi_bus_trim(acpi_device, 1);
161 
162 	if (!result)
163 		result = acpi_eject_operation(handle, islockable);
164 
165 	if (result) {
166 		ret = -EBUSY;
167 	}
168       err:
169 	return ret;
170 }
171 
172 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
173 
174 static ssize_t
175 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
176 	struct acpi_device *acpi_dev = to_acpi_device(dev);
177 
178 	return sprintf(buf, "%s\n", acpi_dev->pnp.hardware_id);
179 }
180 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
181 
182 static ssize_t
183 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
184 	struct acpi_device *acpi_dev = to_acpi_device(dev);
185 	struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
186 	int result;
187 
188 	result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
189 	if(result)
190 		goto end;
191 
192 	result = sprintf(buf, "%s\n", (char*)path.pointer);
193 	kfree(path.pointer);
194   end:
195 	return result;
196 }
197 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
198 
199 static int acpi_device_setup_files(struct acpi_device *dev)
200 {
201 	acpi_status status;
202 	acpi_handle temp;
203 	int result = 0;
204 
205 	/*
206 	 * Devices gotten from FADT don't have a "path" attribute
207 	 */
208 	if(dev->handle) {
209 		result = device_create_file(&dev->dev, &dev_attr_path);
210 		if(result)
211 			goto end;
212 	}
213 
214 	if(dev->flags.hardware_id) {
215 		result = device_create_file(&dev->dev, &dev_attr_hid);
216 		if(result)
217 			goto end;
218 	}
219 
220 	if (dev->flags.hardware_id || dev->flags.compatible_ids){
221 		result = device_create_file(&dev->dev, &dev_attr_modalias);
222 		if(result)
223 			goto end;
224 	}
225 
226         /*
227          * If device has _EJ0, 'eject' file is created that is used to trigger
228          * hot-removal function from userland.
229          */
230 	status = acpi_get_handle(dev->handle, "_EJ0", &temp);
231 	if (ACPI_SUCCESS(status))
232 		result = device_create_file(&dev->dev, &dev_attr_eject);
233   end:
234 	return result;
235 }
236 
237 static void acpi_device_remove_files(struct acpi_device *dev)
238 {
239 	acpi_status status;
240 	acpi_handle temp;
241 
242 	/*
243 	 * If device has _EJ0, 'eject' file is created that is used to trigger
244 	 * hot-removal function from userland.
245 	 */
246 	status = acpi_get_handle(dev->handle, "_EJ0", &temp);
247 	if (ACPI_SUCCESS(status))
248 		device_remove_file(&dev->dev, &dev_attr_eject);
249 
250 	if (dev->flags.hardware_id || dev->flags.compatible_ids)
251 		device_remove_file(&dev->dev, &dev_attr_modalias);
252 
253 	if(dev->flags.hardware_id)
254 		device_remove_file(&dev->dev, &dev_attr_hid);
255 	if(dev->handle)
256 		device_remove_file(&dev->dev, &dev_attr_path);
257 }
258 /* --------------------------------------------------------------------------
259 			ACPI Bus operations
260    -------------------------------------------------------------------------- */
261 
262 int acpi_match_device_ids(struct acpi_device *device,
263 			  const struct acpi_device_id *ids)
264 {
265 	const struct acpi_device_id *id;
266 
267 	if (device->flags.hardware_id) {
268 		for (id = ids; id->id[0]; id++) {
269 			if (!strcmp((char*)id->id, device->pnp.hardware_id))
270 				return 0;
271 		}
272 	}
273 
274 	if (device->flags.compatible_ids) {
275 		struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
276 		int i;
277 
278 		for (id = ids; id->id[0]; id++) {
279 			/* compare multiple _CID entries against driver ids */
280 			for (i = 0; i < cid_list->count; i++) {
281 				if (!strcmp((char*)id->id,
282 					    cid_list->id[i].value))
283 					return 0;
284 			}
285 		}
286 	}
287 
288 	return -ENOENT;
289 }
290 EXPORT_SYMBOL(acpi_match_device_ids);
291 
292 static void acpi_device_release(struct device *dev)
293 {
294 	struct acpi_device *acpi_dev = to_acpi_device(dev);
295 
296 	kfree(acpi_dev->pnp.cid_list);
297 	kfree(acpi_dev);
298 }
299 
300 static int acpi_device_suspend(struct device *dev, pm_message_t state)
301 {
302 	struct acpi_device *acpi_dev = to_acpi_device(dev);
303 	struct acpi_driver *acpi_drv = acpi_dev->driver;
304 
305 	if (acpi_drv && acpi_drv->ops.suspend)
306 		return acpi_drv->ops.suspend(acpi_dev, state);
307 	return 0;
308 }
309 
310 static int acpi_device_resume(struct device *dev)
311 {
312 	struct acpi_device *acpi_dev = to_acpi_device(dev);
313 	struct acpi_driver *acpi_drv = acpi_dev->driver;
314 
315 	if (acpi_drv && acpi_drv->ops.resume)
316 		return acpi_drv->ops.resume(acpi_dev);
317 	return 0;
318 }
319 
320 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
321 {
322 	struct acpi_device *acpi_dev = to_acpi_device(dev);
323 	struct acpi_driver *acpi_drv = to_acpi_driver(drv);
324 
325 	return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
326 }
327 
328 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
329 {
330 	struct acpi_device *acpi_dev = to_acpi_device(dev);
331 	int len;
332 
333 	if (add_uevent_var(env, "MODALIAS="))
334 		return -ENOMEM;
335 	len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
336 			      sizeof(env->buf) - env->buflen);
337 	if (len >= (sizeof(env->buf) - env->buflen))
338 		return -ENOMEM;
339 	env->buflen += len;
340 	return 0;
341 }
342 
343 static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
344 static int acpi_start_single_object(struct acpi_device *);
345 static int acpi_device_probe(struct device * dev)
346 {
347 	struct acpi_device *acpi_dev = to_acpi_device(dev);
348 	struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
349 	int ret;
350 
351 	ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
352 	if (!ret) {
353 		if (acpi_dev->bus_ops.acpi_op_start)
354 			acpi_start_single_object(acpi_dev);
355 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
356 			"Found driver [%s] for device [%s]\n",
357 			acpi_drv->name, acpi_dev->pnp.bus_id));
358 		get_device(dev);
359 	}
360 	return ret;
361 }
362 
363 static int acpi_device_remove(struct device * dev)
364 {
365 	struct acpi_device *acpi_dev = to_acpi_device(dev);
366 	struct acpi_driver *acpi_drv = acpi_dev->driver;
367 
368 	if (acpi_drv) {
369 		if (acpi_drv->ops.stop)
370 			acpi_drv->ops.stop(acpi_dev, acpi_dev->removal_type);
371 		if (acpi_drv->ops.remove)
372 			acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
373 	}
374 	acpi_dev->driver = NULL;
375 	acpi_driver_data(dev) = NULL;
376 
377 	put_device(dev);
378 	return 0;
379 }
380 
381 static void acpi_device_shutdown(struct device *dev)
382 {
383 	struct acpi_device *acpi_dev = to_acpi_device(dev);
384 	struct acpi_driver *acpi_drv = acpi_dev->driver;
385 
386 	if (acpi_drv && acpi_drv->ops.shutdown)
387 		acpi_drv->ops.shutdown(acpi_dev);
388 
389 	return ;
390 }
391 
392 struct bus_type acpi_bus_type = {
393 	.name		= "acpi",
394 	.suspend	= acpi_device_suspend,
395 	.resume		= acpi_device_resume,
396 	.shutdown	= acpi_device_shutdown,
397 	.match		= acpi_bus_match,
398 	.probe		= acpi_device_probe,
399 	.remove		= acpi_device_remove,
400 	.uevent		= acpi_device_uevent,
401 };
402 
403 static int acpi_device_register(struct acpi_device *device,
404 				 struct acpi_device *parent)
405 {
406 	int result;
407 	struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
408 	int found = 0;
409 	/*
410 	 * Linkage
411 	 * -------
412 	 * Link this device to its parent and siblings.
413 	 */
414 	INIT_LIST_HEAD(&device->children);
415 	INIT_LIST_HEAD(&device->node);
416 	INIT_LIST_HEAD(&device->g_list);
417 	INIT_LIST_HEAD(&device->wakeup_list);
418 
419 	new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
420 	if (!new_bus_id) {
421 		printk(KERN_ERR PREFIX "Memory allocation error\n");
422 		return -ENOMEM;
423 	}
424 
425 	spin_lock(&acpi_device_lock);
426 	/*
427 	 * Find suitable bus_id and instance number in acpi_bus_id_list
428 	 * If failed, create one and link it into acpi_bus_id_list
429 	 */
430 	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
431 		if(!strcmp(acpi_device_bus_id->bus_id, device->flags.hardware_id? device->pnp.hardware_id : "device")) {
432 			acpi_device_bus_id->instance_no ++;
433 			found = 1;
434 			kfree(new_bus_id);
435 			break;
436 		}
437 	}
438 	if(!found) {
439 		acpi_device_bus_id = new_bus_id;
440 		strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
441 		acpi_device_bus_id->instance_no = 0;
442 		list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
443 	}
444 	sprintf(device->dev.bus_id, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
445 
446 	if (device->parent) {
447 		list_add_tail(&device->node, &device->parent->children);
448 		list_add_tail(&device->g_list, &device->parent->g_list);
449 	} else
450 		list_add_tail(&device->g_list, &acpi_device_list);
451 	if (device->wakeup.flags.valid)
452 		list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
453 	spin_unlock(&acpi_device_lock);
454 
455 	if (device->parent)
456 		device->dev.parent = &parent->dev;
457 	device->dev.bus = &acpi_bus_type;
458 	device_initialize(&device->dev);
459 	device->dev.release = &acpi_device_release;
460 	result = device_add(&device->dev);
461 	if(result) {
462 		printk(KERN_ERR PREFIX "Error adding device %s", device->dev.bus_id);
463 		goto end;
464 	}
465 
466 	result = acpi_device_setup_files(device);
467 	if(result)
468 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error creating sysfs interface for device %s\n", device->dev.bus_id));
469 
470 	device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
471 	return 0;
472   end:
473 	spin_lock(&acpi_device_lock);
474 	if (device->parent) {
475 		list_del(&device->node);
476 		list_del(&device->g_list);
477 	} else
478 		list_del(&device->g_list);
479 	list_del(&device->wakeup_list);
480 	spin_unlock(&acpi_device_lock);
481 	return result;
482 }
483 
484 static void acpi_device_unregister(struct acpi_device *device, int type)
485 {
486 	spin_lock(&acpi_device_lock);
487 	if (device->parent) {
488 		list_del(&device->node);
489 		list_del(&device->g_list);
490 	} else
491 		list_del(&device->g_list);
492 
493 	list_del(&device->wakeup_list);
494 	spin_unlock(&acpi_device_lock);
495 
496 	acpi_detach_data(device->handle, acpi_bus_data_handler);
497 
498 	acpi_device_remove_files(device);
499 	device_unregister(&device->dev);
500 }
501 
502 /* --------------------------------------------------------------------------
503                                  Driver Management
504    -------------------------------------------------------------------------- */
505 /**
506  * acpi_bus_driver_init - add a device to a driver
507  * @device: the device to add and initialize
508  * @driver: driver for the device
509  *
510  * Used to initialize a device via its device driver.  Called whenever a
511  * driver is bound to a device.  Invokes the driver's add() ops.
512  */
513 static int
514 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
515 {
516 	int result = 0;
517 
518 
519 	if (!device || !driver)
520 		return -EINVAL;
521 
522 	if (!driver->ops.add)
523 		return -ENOSYS;
524 
525 	result = driver->ops.add(device);
526 	if (result) {
527 		device->driver = NULL;
528 		acpi_driver_data(device) = NULL;
529 		return result;
530 	}
531 
532 	device->driver = driver;
533 
534 	/*
535 	 * TBD - Configuration Management: Assign resources to device based
536 	 * upon possible configuration and currently allocated resources.
537 	 */
538 
539 	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
540 			  "Driver successfully bound to device\n"));
541 	return 0;
542 }
543 
544 static int acpi_start_single_object(struct acpi_device *device)
545 {
546 	int result = 0;
547 	struct acpi_driver *driver;
548 
549 
550 	if (!(driver = device->driver))
551 		return 0;
552 
553 	if (driver->ops.start) {
554 		result = driver->ops.start(device);
555 		if (result && driver->ops.remove)
556 			driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
557 	}
558 
559 	return result;
560 }
561 
562 /**
563  * acpi_bus_register_driver - register a driver with the ACPI bus
564  * @driver: driver being registered
565  *
566  * Registers a driver with the ACPI bus.  Searches the namespace for all
567  * devices that match the driver's criteria and binds.  Returns zero for
568  * success or a negative error status for failure.
569  */
570 int acpi_bus_register_driver(struct acpi_driver *driver)
571 {
572 	int ret;
573 
574 	if (acpi_disabled)
575 		return -ENODEV;
576 	driver->drv.name = driver->name;
577 	driver->drv.bus = &acpi_bus_type;
578 	driver->drv.owner = driver->owner;
579 
580 	ret = driver_register(&driver->drv);
581 	return ret;
582 }
583 
584 EXPORT_SYMBOL(acpi_bus_register_driver);
585 
586 /**
587  * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
588  * @driver: driver to unregister
589  *
590  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
591  * devices that match the driver's criteria and unbinds.
592  */
593 void acpi_bus_unregister_driver(struct acpi_driver *driver)
594 {
595 	driver_unregister(&driver->drv);
596 }
597 
598 EXPORT_SYMBOL(acpi_bus_unregister_driver);
599 
600 /* --------------------------------------------------------------------------
601                                  Device Enumeration
602    -------------------------------------------------------------------------- */
603 acpi_status
604 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
605 {
606 	acpi_status status;
607 	acpi_handle tmp;
608 	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
609 	union acpi_object *obj;
610 
611 	status = acpi_get_handle(handle, "_EJD", &tmp);
612 	if (ACPI_FAILURE(status))
613 		return status;
614 
615 	status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
616 	if (ACPI_SUCCESS(status)) {
617 		obj = buffer.pointer;
618 		status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
619 					 ejd);
620 		kfree(buffer.pointer);
621 	}
622 	return status;
623 }
624 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
625 
626 void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
627 {
628 
629 	/* TBD */
630 
631 	return;
632 }
633 
634 static int acpi_bus_get_perf_flags(struct acpi_device *device)
635 {
636 	device->performance.state = ACPI_STATE_UNKNOWN;
637 	return 0;
638 }
639 
640 static acpi_status
641 acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
642 					     union acpi_object *package)
643 {
644 	int i = 0;
645 	union acpi_object *element = NULL;
646 
647 	if (!device || !package || (package->package.count < 2))
648 		return AE_BAD_PARAMETER;
649 
650 	element = &(package->package.elements[0]);
651 	if (!element)
652 		return AE_BAD_PARAMETER;
653 	if (element->type == ACPI_TYPE_PACKAGE) {
654 		if ((element->package.count < 2) ||
655 		    (element->package.elements[0].type !=
656 		     ACPI_TYPE_LOCAL_REFERENCE)
657 		    || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
658 			return AE_BAD_DATA;
659 		device->wakeup.gpe_device =
660 		    element->package.elements[0].reference.handle;
661 		device->wakeup.gpe_number =
662 		    (u32) element->package.elements[1].integer.value;
663 	} else if (element->type == ACPI_TYPE_INTEGER) {
664 		device->wakeup.gpe_number = element->integer.value;
665 	} else
666 		return AE_BAD_DATA;
667 
668 	element = &(package->package.elements[1]);
669 	if (element->type != ACPI_TYPE_INTEGER) {
670 		return AE_BAD_DATA;
671 	}
672 	device->wakeup.sleep_state = element->integer.value;
673 
674 	if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
675 		return AE_NO_MEMORY;
676 	}
677 	device->wakeup.resources.count = package->package.count - 2;
678 	for (i = 0; i < device->wakeup.resources.count; i++) {
679 		element = &(package->package.elements[i + 2]);
680 		if (element->type != ACPI_TYPE_ANY) {
681 			return AE_BAD_DATA;
682 		}
683 
684 		device->wakeup.resources.handles[i] = element->reference.handle;
685 	}
686 
687 	return AE_OK;
688 }
689 
690 static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
691 {
692 	acpi_status status = 0;
693 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
694 	union acpi_object *package = NULL;
695 
696 	struct acpi_device_id button_device_ids[] = {
697 		{"PNP0C0D", 0},
698 		{"PNP0C0C", 0},
699 		{"PNP0C0E", 0},
700 		{"", 0},
701 	};
702 
703 
704 	/* _PRW */
705 	status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
706 	if (ACPI_FAILURE(status)) {
707 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
708 		goto end;
709 	}
710 
711 	package = (union acpi_object *)buffer.pointer;
712 	status = acpi_bus_extract_wakeup_device_power_package(device, package);
713 	if (ACPI_FAILURE(status)) {
714 		ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
715 		goto end;
716 	}
717 
718 	kfree(buffer.pointer);
719 
720 	device->wakeup.flags.valid = 1;
721 	/* Power button, Lid switch always enable wakeup */
722 	if (!acpi_match_device_ids(device, button_device_ids))
723 		device->wakeup.flags.run_wake = 1;
724 
725       end:
726 	if (ACPI_FAILURE(status))
727 		device->flags.wake_capable = 0;
728 	return 0;
729 }
730 
731 static int acpi_bus_get_power_flags(struct acpi_device *device)
732 {
733 	acpi_status status = 0;
734 	acpi_handle handle = NULL;
735 	u32 i = 0;
736 
737 
738 	/*
739 	 * Power Management Flags
740 	 */
741 	status = acpi_get_handle(device->handle, "_PSC", &handle);
742 	if (ACPI_SUCCESS(status))
743 		device->power.flags.explicit_get = 1;
744 	status = acpi_get_handle(device->handle, "_IRC", &handle);
745 	if (ACPI_SUCCESS(status))
746 		device->power.flags.inrush_current = 1;
747 
748 	/*
749 	 * Enumerate supported power management states
750 	 */
751 	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
752 		struct acpi_device_power_state *ps = &device->power.states[i];
753 		char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
754 
755 		/* Evaluate "_PRx" to se if power resources are referenced */
756 		acpi_evaluate_reference(device->handle, object_name, NULL,
757 					&ps->resources);
758 		if (ps->resources.count) {
759 			device->power.flags.power_resources = 1;
760 			ps->flags.valid = 1;
761 		}
762 
763 		/* Evaluate "_PSx" to see if we can do explicit sets */
764 		object_name[2] = 'S';
765 		status = acpi_get_handle(device->handle, object_name, &handle);
766 		if (ACPI_SUCCESS(status)) {
767 			ps->flags.explicit_set = 1;
768 			ps->flags.valid = 1;
769 		}
770 
771 		/* State is valid if we have some power control */
772 		if (ps->resources.count || ps->flags.explicit_set)
773 			ps->flags.valid = 1;
774 
775 		ps->power = -1;	/* Unknown - driver assigned */
776 		ps->latency = -1;	/* Unknown - driver assigned */
777 	}
778 
779 	/* Set defaults for D0 and D3 states (always valid) */
780 	device->power.states[ACPI_STATE_D0].flags.valid = 1;
781 	device->power.states[ACPI_STATE_D0].power = 100;
782 	device->power.states[ACPI_STATE_D3].flags.valid = 1;
783 	device->power.states[ACPI_STATE_D3].power = 0;
784 
785 	/* TBD: System wake support and resource requirements. */
786 
787 	device->power.state = ACPI_STATE_UNKNOWN;
788 
789 	return 0;
790 }
791 
792 static int acpi_bus_get_flags(struct acpi_device *device)
793 {
794 	acpi_status status = AE_OK;
795 	acpi_handle temp = NULL;
796 
797 
798 	/* Presence of _STA indicates 'dynamic_status' */
799 	status = acpi_get_handle(device->handle, "_STA", &temp);
800 	if (ACPI_SUCCESS(status))
801 		device->flags.dynamic_status = 1;
802 
803 	/* Presence of _CID indicates 'compatible_ids' */
804 	status = acpi_get_handle(device->handle, "_CID", &temp);
805 	if (ACPI_SUCCESS(status))
806 		device->flags.compatible_ids = 1;
807 
808 	/* Presence of _RMV indicates 'removable' */
809 	status = acpi_get_handle(device->handle, "_RMV", &temp);
810 	if (ACPI_SUCCESS(status))
811 		device->flags.removable = 1;
812 
813 	/* Presence of _EJD|_EJ0 indicates 'ejectable' */
814 	status = acpi_get_handle(device->handle, "_EJD", &temp);
815 	if (ACPI_SUCCESS(status))
816 		device->flags.ejectable = 1;
817 	else {
818 		status = acpi_get_handle(device->handle, "_EJ0", &temp);
819 		if (ACPI_SUCCESS(status))
820 			device->flags.ejectable = 1;
821 	}
822 
823 	/* Presence of _LCK indicates 'lockable' */
824 	status = acpi_get_handle(device->handle, "_LCK", &temp);
825 	if (ACPI_SUCCESS(status))
826 		device->flags.lockable = 1;
827 
828 	/* Presence of _PS0|_PR0 indicates 'power manageable' */
829 	status = acpi_get_handle(device->handle, "_PS0", &temp);
830 	if (ACPI_FAILURE(status))
831 		status = acpi_get_handle(device->handle, "_PR0", &temp);
832 	if (ACPI_SUCCESS(status))
833 		device->flags.power_manageable = 1;
834 
835 	/* Presence of _PRW indicates wake capable */
836 	status = acpi_get_handle(device->handle, "_PRW", &temp);
837 	if (ACPI_SUCCESS(status))
838 		device->flags.wake_capable = 1;
839 
840 	/* TBD: Performance management */
841 
842 	return 0;
843 }
844 
845 static void acpi_device_get_busid(struct acpi_device *device,
846 				  acpi_handle handle, int type)
847 {
848 	char bus_id[5] = { '?', 0 };
849 	struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
850 	int i = 0;
851 
852 	/*
853 	 * Bus ID
854 	 * ------
855 	 * The device's Bus ID is simply the object name.
856 	 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
857 	 */
858 	switch (type) {
859 	case ACPI_BUS_TYPE_SYSTEM:
860 		strcpy(device->pnp.bus_id, "ACPI");
861 		break;
862 	case ACPI_BUS_TYPE_POWER_BUTTON:
863 		strcpy(device->pnp.bus_id, "PWRF");
864 		break;
865 	case ACPI_BUS_TYPE_SLEEP_BUTTON:
866 		strcpy(device->pnp.bus_id, "SLPF");
867 		break;
868 	default:
869 		acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
870 		/* Clean up trailing underscores (if any) */
871 		for (i = 3; i > 1; i--) {
872 			if (bus_id[i] == '_')
873 				bus_id[i] = '\0';
874 			else
875 				break;
876 		}
877 		strcpy(device->pnp.bus_id, bus_id);
878 		break;
879 	}
880 }
881 
882 static int
883 acpi_video_bus_match(struct acpi_device *device)
884 {
885 	acpi_handle h_dummy1;
886 	acpi_handle h_dummy2;
887 	acpi_handle h_dummy3;
888 
889 
890 	if (!device)
891 		return -EINVAL;
892 
893 	/* Since there is no HID, CID for ACPI Video drivers, we have
894 	 * to check well known required nodes for each feature we support.
895 	 */
896 
897 	/* Does this device able to support video switching ? */
898 	if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy1)) &&
899 	    ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy2)))
900 		return 0;
901 
902 	/* Does this device able to retrieve a video ROM ? */
903 	if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy1)))
904 		return 0;
905 
906 	/* Does this device able to configure which video head to be POSTed ? */
907 	if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy1)) &&
908 	    ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy2)) &&
909 	    ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy3)))
910 		return 0;
911 
912 	return -ENODEV;
913 }
914 
915 /*
916  * acpi_bay_match - see if a device is an ejectable driver bay
917  *
918  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
919  * then we can safely call it an ejectable drive bay
920  */
921 static int acpi_bay_match(struct acpi_device *device){
922 	acpi_status status;
923 	acpi_handle handle;
924 	acpi_handle tmp;
925 	acpi_handle phandle;
926 
927 	handle = device->handle;
928 
929 	status = acpi_get_handle(handle, "_EJ0", &tmp);
930 	if (ACPI_FAILURE(status))
931 		return -ENODEV;
932 
933 	if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
934 		(ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
935 		(ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
936 		(ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
937 		return 0;
938 
939 	if (acpi_get_parent(handle, &phandle))
940 		return -ENODEV;
941 
942         if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
943                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
944                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
945                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
946                 return 0;
947 
948 	return -ENODEV;
949 }
950 
951 /*
952  * acpi_dock_match - see if a device has a _DCK method
953  */
954 static int acpi_dock_match(struct acpi_device *device)
955 {
956 	acpi_handle tmp;
957 	return acpi_get_handle(device->handle, "_DCK", &tmp);
958 }
959 
960 static void acpi_device_set_id(struct acpi_device *device,
961 			       struct acpi_device *parent, acpi_handle handle,
962 			       int type)
963 {
964 	struct acpi_device_info *info;
965 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
966 	char *hid = NULL;
967 	char *uid = NULL;
968 	struct acpi_compatible_id_list *cid_list = NULL;
969 	const char *cid_add = NULL;
970 	acpi_status status;
971 
972 	switch (type) {
973 	case ACPI_BUS_TYPE_DEVICE:
974 		status = acpi_get_object_info(handle, &buffer);
975 		if (ACPI_FAILURE(status)) {
976 			printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
977 			return;
978 		}
979 
980 		info = buffer.pointer;
981 		if (info->valid & ACPI_VALID_HID)
982 			hid = info->hardware_id.value;
983 		if (info->valid & ACPI_VALID_UID)
984 			uid = info->unique_id.value;
985 		if (info->valid & ACPI_VALID_CID)
986 			cid_list = &info->compatibility_id;
987 		if (info->valid & ACPI_VALID_ADR) {
988 			device->pnp.bus_address = info->address;
989 			device->flags.bus_address = 1;
990 		}
991 
992 		/* If we have a video/bay/dock device, add our selfdefined
993 		   HID to the CID list. Like that the video/bay/dock drivers
994 		   will get autoloaded and the device might still match
995 		   against another driver.
996 		*/
997 		if (ACPI_SUCCESS(acpi_video_bus_match(device)))
998 			cid_add = ACPI_VIDEO_HID;
999 		else if (ACPI_SUCCESS(acpi_bay_match(device)))
1000 			cid_add = ACPI_BAY_HID;
1001 		else if (ACPI_SUCCESS(acpi_dock_match(device)))
1002 			cid_add = ACPI_DOCK_HID;
1003 
1004 		break;
1005 	case ACPI_BUS_TYPE_POWER:
1006 		hid = ACPI_POWER_HID;
1007 		break;
1008 	case ACPI_BUS_TYPE_PROCESSOR:
1009 		hid = ACPI_PROCESSOR_HID;
1010 		break;
1011 	case ACPI_BUS_TYPE_SYSTEM:
1012 		hid = ACPI_SYSTEM_HID;
1013 		break;
1014 	case ACPI_BUS_TYPE_THERMAL:
1015 		hid = ACPI_THERMAL_HID;
1016 		break;
1017 	case ACPI_BUS_TYPE_POWER_BUTTON:
1018 		hid = ACPI_BUTTON_HID_POWERF;
1019 		break;
1020 	case ACPI_BUS_TYPE_SLEEP_BUTTON:
1021 		hid = ACPI_BUTTON_HID_SLEEPF;
1022 		break;
1023 	}
1024 
1025 	/*
1026 	 * \_SB
1027 	 * ----
1028 	 * Fix for the system root bus device -- the only root-level device.
1029 	 */
1030 	if (((acpi_handle)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
1031 		hid = ACPI_BUS_HID;
1032 		strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1033 		strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1034 	}
1035 
1036 	if (hid) {
1037 		strcpy(device->pnp.hardware_id, hid);
1038 		device->flags.hardware_id = 1;
1039 	}
1040 	if (uid) {
1041 		strcpy(device->pnp.unique_id, uid);
1042 		device->flags.unique_id = 1;
1043 	}
1044 	if (cid_list || cid_add) {
1045 		struct  acpi_compatible_id_list *list;
1046 		int size = 0;
1047 		int count = 0;
1048 
1049 		if (cid_list) {
1050 			size = cid_list->size;
1051 		} else if (cid_add) {
1052 			size = sizeof(struct acpi_compatible_id_list);
1053 			cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
1054 			if (!cid_list) {
1055 				printk(KERN_ERR "Memory allocation error\n");
1056 				kfree(buffer.pointer);
1057 				return;
1058 			} else {
1059 				cid_list->count = 0;
1060 				cid_list->size = size;
1061 			}
1062 		}
1063 		if (cid_add)
1064 			size += sizeof(struct acpi_compatible_id);
1065 		list = kmalloc(size, GFP_KERNEL);
1066 
1067 		if (list) {
1068 			if (cid_list) {
1069 				memcpy(list, cid_list, cid_list->size);
1070 				count = cid_list->count;
1071 			}
1072 			if (cid_add) {
1073 				strncpy(list->id[count].value, cid_add,
1074 					ACPI_MAX_CID_LENGTH);
1075 				count++;
1076 				device->flags.compatible_ids = 1;
1077 			}
1078 			list->size = size;
1079 			list->count = count;
1080 			device->pnp.cid_list = list;
1081 		} else
1082 			printk(KERN_ERR PREFIX "Memory allocation error\n");
1083 	}
1084 
1085 	kfree(buffer.pointer);
1086 }
1087 
1088 static int acpi_device_set_context(struct acpi_device *device, int type)
1089 {
1090 	acpi_status status = AE_OK;
1091 	int result = 0;
1092 	/*
1093 	 * Context
1094 	 * -------
1095 	 * Attach this 'struct acpi_device' to the ACPI object.  This makes
1096 	 * resolutions from handle->device very efficient.  Note that we need
1097 	 * to be careful with fixed-feature devices as they all attach to the
1098 	 * root object.
1099 	 */
1100 	if (type != ACPI_BUS_TYPE_POWER_BUTTON &&
1101 	    type != ACPI_BUS_TYPE_SLEEP_BUTTON) {
1102 		status = acpi_attach_data(device->handle,
1103 					  acpi_bus_data_handler, device);
1104 
1105 		if (ACPI_FAILURE(status)) {
1106 			printk(KERN_ERR PREFIX "Error attaching device data\n");
1107 			result = -ENODEV;
1108 		}
1109 	}
1110 	return result;
1111 }
1112 
1113 static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
1114 {
1115 	if (!dev)
1116 		return -EINVAL;
1117 
1118 	dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
1119 	device_release_driver(&dev->dev);
1120 
1121 	if (!rmdevice)
1122 		return 0;
1123 
1124 	/*
1125 	 * unbind _ADR-Based Devices when hot removal
1126 	 */
1127 	if (dev->flags.bus_address) {
1128 		if ((dev->parent) && (dev->parent->ops.unbind))
1129 			dev->parent->ops.unbind(dev);
1130 	}
1131 	acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1132 
1133 	return 0;
1134 }
1135 
1136 static int
1137 acpi_is_child_device(struct acpi_device *device,
1138 			int (*matcher)(struct acpi_device *))
1139 {
1140 	int result = -ENODEV;
1141 
1142 	do {
1143 		if (ACPI_SUCCESS(matcher(device)))
1144 			return AE_OK;
1145 	} while ((device = device->parent));
1146 
1147 	return result;
1148 }
1149 
1150 static int
1151 acpi_add_single_object(struct acpi_device **child,
1152 		       struct acpi_device *parent, acpi_handle handle, int type,
1153 			struct acpi_bus_ops *ops)
1154 {
1155 	int result = 0;
1156 	struct acpi_device *device = NULL;
1157 
1158 
1159 	if (!child)
1160 		return -EINVAL;
1161 
1162 	device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1163 	if (!device) {
1164 		printk(KERN_ERR PREFIX "Memory allocation error\n");
1165 		return -ENOMEM;
1166 	}
1167 
1168 	device->handle = handle;
1169 	device->parent = parent;
1170 	device->bus_ops = *ops; /* workround for not call .start */
1171 
1172 
1173 	acpi_device_get_busid(device, handle, type);
1174 
1175 	/*
1176 	 * Flags
1177 	 * -----
1178 	 * Get prior to calling acpi_bus_get_status() so we know whether
1179 	 * or not _STA is present.  Note that we only look for object
1180 	 * handles -- cannot evaluate objects until we know the device is
1181 	 * present and properly initialized.
1182 	 */
1183 	result = acpi_bus_get_flags(device);
1184 	if (result)
1185 		goto end;
1186 
1187 	/*
1188 	 * Status
1189 	 * ------
1190 	 * See if the device is present.  We always assume that non-Device
1191 	 * and non-Processor objects (e.g. thermal zones, power resources,
1192 	 * etc.) are present, functioning, etc. (at least when parent object
1193 	 * is present).  Note that _STA has a different meaning for some
1194 	 * objects (e.g. power resources) so we need to be careful how we use
1195 	 * it.
1196 	 */
1197 	switch (type) {
1198 	case ACPI_BUS_TYPE_PROCESSOR:
1199 	case ACPI_BUS_TYPE_DEVICE:
1200 		result = acpi_bus_get_status(device);
1201 		if (ACPI_FAILURE(result)) {
1202 			result = -ENODEV;
1203 			goto end;
1204 		}
1205 		if (!device->status.present) {
1206 			/* Bay and dock should be handled even if absent */
1207 			if (!ACPI_SUCCESS(
1208 			     acpi_is_child_device(device, acpi_bay_match)) &&
1209 			    !ACPI_SUCCESS(
1210 			     acpi_is_child_device(device, acpi_dock_match))) {
1211 					result = -ENODEV;
1212 					goto end;
1213 			}
1214 		}
1215 		break;
1216 	default:
1217 		STRUCT_TO_INT(device->status) =
1218 		    ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
1219 		    ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
1220 		break;
1221 	}
1222 
1223 	/*
1224 	 * Initialize Device
1225 	 * -----------------
1226 	 * TBD: Synch with Core's enumeration/initialization process.
1227 	 */
1228 
1229 	/*
1230 	 * Hardware ID, Unique ID, & Bus Address
1231 	 * -------------------------------------
1232 	 */
1233 	acpi_device_set_id(device, parent, handle, type);
1234 
1235 	/*
1236 	 * Power Management
1237 	 * ----------------
1238 	 */
1239 	if (device->flags.power_manageable) {
1240 		result = acpi_bus_get_power_flags(device);
1241 		if (result)
1242 			goto end;
1243 	}
1244 
1245 	/*
1246 	 * Wakeup device management
1247 	 *-----------------------
1248 	 */
1249 	if (device->flags.wake_capable) {
1250 		result = acpi_bus_get_wakeup_device_flags(device);
1251 		if (result)
1252 			goto end;
1253 	}
1254 
1255 	/*
1256 	 * Performance Management
1257 	 * ----------------------
1258 	 */
1259 	if (device->flags.performance_manageable) {
1260 		result = acpi_bus_get_perf_flags(device);
1261 		if (result)
1262 			goto end;
1263 	}
1264 
1265 	if ((result = acpi_device_set_context(device, type)))
1266 		goto end;
1267 
1268 	result = acpi_device_register(device, parent);
1269 
1270 	/*
1271 	 * Bind _ADR-Based Devices when hot add
1272 	 */
1273 	if (device->flags.bus_address) {
1274 		if (device->parent && device->parent->ops.bind)
1275 			device->parent->ops.bind(device);
1276 	}
1277 
1278       end:
1279 	if (!result)
1280 		*child = device;
1281 	else {
1282 		kfree(device->pnp.cid_list);
1283 		kfree(device);
1284 	}
1285 
1286 	return result;
1287 }
1288 
1289 static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
1290 {
1291 	acpi_status status = AE_OK;
1292 	struct acpi_device *parent = NULL;
1293 	struct acpi_device *child = NULL;
1294 	acpi_handle phandle = NULL;
1295 	acpi_handle chandle = NULL;
1296 	acpi_object_type type = 0;
1297 	u32 level = 1;
1298 
1299 
1300 	if (!start)
1301 		return -EINVAL;
1302 
1303 	parent = start;
1304 	phandle = start->handle;
1305 
1306 	/*
1307 	 * Parse through the ACPI namespace, identify all 'devices', and
1308 	 * create a new 'struct acpi_device' for each.
1309 	 */
1310 	while ((level > 0) && parent) {
1311 
1312 		status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1313 					      chandle, &chandle);
1314 
1315 		/*
1316 		 * If this scope is exhausted then move our way back up.
1317 		 */
1318 		if (ACPI_FAILURE(status)) {
1319 			level--;
1320 			chandle = phandle;
1321 			acpi_get_parent(phandle, &phandle);
1322 			if (parent->parent)
1323 				parent = parent->parent;
1324 			continue;
1325 		}
1326 
1327 		status = acpi_get_type(chandle, &type);
1328 		if (ACPI_FAILURE(status))
1329 			continue;
1330 
1331 		/*
1332 		 * If this is a scope object then parse it (depth-first).
1333 		 */
1334 		if (type == ACPI_TYPE_LOCAL_SCOPE) {
1335 			level++;
1336 			phandle = chandle;
1337 			chandle = NULL;
1338 			continue;
1339 		}
1340 
1341 		/*
1342 		 * We're only interested in objects that we consider 'devices'.
1343 		 */
1344 		switch (type) {
1345 		case ACPI_TYPE_DEVICE:
1346 			type = ACPI_BUS_TYPE_DEVICE;
1347 			break;
1348 		case ACPI_TYPE_PROCESSOR:
1349 			type = ACPI_BUS_TYPE_PROCESSOR;
1350 			break;
1351 		case ACPI_TYPE_THERMAL:
1352 			type = ACPI_BUS_TYPE_THERMAL;
1353 			break;
1354 		case ACPI_TYPE_POWER:
1355 			type = ACPI_BUS_TYPE_POWER;
1356 			break;
1357 		default:
1358 			continue;
1359 		}
1360 
1361 		if (ops->acpi_op_add)
1362 			status = acpi_add_single_object(&child, parent,
1363 				chandle, type, ops);
1364 		else
1365 			status = acpi_bus_get_device(chandle, &child);
1366 
1367 		if (ACPI_FAILURE(status))
1368 			continue;
1369 
1370 		if (ops->acpi_op_start && !(ops->acpi_op_add)) {
1371 			status = acpi_start_single_object(child);
1372 			if (ACPI_FAILURE(status))
1373 				continue;
1374 		}
1375 
1376 		/*
1377 		 * If the device is present, enabled, and functioning then
1378 		 * parse its scope (depth-first).  Note that we need to
1379 		 * represent absent devices to facilitate PnP notifications
1380 		 * -- but only the subtree head (not all of its children,
1381 		 * which will be enumerated when the parent is inserted).
1382 		 *
1383 		 * TBD: Need notifications and other detection mechanisms
1384 		 *      in place before we can fully implement this.
1385 		 */
1386 		if (child->status.present) {
1387 			status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1388 						      NULL, NULL);
1389 			if (ACPI_SUCCESS(status)) {
1390 				level++;
1391 				phandle = chandle;
1392 				chandle = NULL;
1393 				parent = child;
1394 			}
1395 		}
1396 	}
1397 
1398 	return 0;
1399 }
1400 
1401 int
1402 acpi_bus_add(struct acpi_device **child,
1403 	     struct acpi_device *parent, acpi_handle handle, int type)
1404 {
1405 	int result;
1406 	struct acpi_bus_ops ops;
1407 
1408 	memset(&ops, 0, sizeof(ops));
1409 	ops.acpi_op_add = 1;
1410 
1411 	result = acpi_add_single_object(child, parent, handle, type, &ops);
1412 	if (!result)
1413 		result = acpi_bus_scan(*child, &ops);
1414 
1415 	return result;
1416 }
1417 
1418 EXPORT_SYMBOL(acpi_bus_add);
1419 
1420 int acpi_bus_start(struct acpi_device *device)
1421 {
1422 	int result;
1423 	struct acpi_bus_ops ops;
1424 
1425 
1426 	if (!device)
1427 		return -EINVAL;
1428 
1429 	result = acpi_start_single_object(device);
1430 	if (!result) {
1431 		memset(&ops, 0, sizeof(ops));
1432 		ops.acpi_op_start = 1;
1433 		result = acpi_bus_scan(device, &ops);
1434 	}
1435 	return result;
1436 }
1437 
1438 EXPORT_SYMBOL(acpi_bus_start);
1439 
1440 int acpi_bus_trim(struct acpi_device *start, int rmdevice)
1441 {
1442 	acpi_status status;
1443 	struct acpi_device *parent, *child;
1444 	acpi_handle phandle, chandle;
1445 	acpi_object_type type;
1446 	u32 level = 1;
1447 	int err = 0;
1448 
1449 	parent = start;
1450 	phandle = start->handle;
1451 	child = chandle = NULL;
1452 
1453 	while ((level > 0) && parent && (!err)) {
1454 		status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1455 					      chandle, &chandle);
1456 
1457 		/*
1458 		 * If this scope is exhausted then move our way back up.
1459 		 */
1460 		if (ACPI_FAILURE(status)) {
1461 			level--;
1462 			chandle = phandle;
1463 			acpi_get_parent(phandle, &phandle);
1464 			child = parent;
1465 			parent = parent->parent;
1466 
1467 			if (level == 0)
1468 				err = acpi_bus_remove(child, rmdevice);
1469 			else
1470 				err = acpi_bus_remove(child, 1);
1471 
1472 			continue;
1473 		}
1474 
1475 		status = acpi_get_type(chandle, &type);
1476 		if (ACPI_FAILURE(status)) {
1477 			continue;
1478 		}
1479 		/*
1480 		 * If there is a device corresponding to chandle then
1481 		 * parse it (depth-first).
1482 		 */
1483 		if (acpi_bus_get_device(chandle, &child) == 0) {
1484 			level++;
1485 			phandle = chandle;
1486 			chandle = NULL;
1487 			parent = child;
1488 		}
1489 		continue;
1490 	}
1491 	return err;
1492 }
1493 EXPORT_SYMBOL_GPL(acpi_bus_trim);
1494 
1495 
1496 static int acpi_bus_scan_fixed(struct acpi_device *root)
1497 {
1498 	int result = 0;
1499 	struct acpi_device *device = NULL;
1500 	struct acpi_bus_ops ops;
1501 
1502 	if (!root)
1503 		return -ENODEV;
1504 
1505 	memset(&ops, 0, sizeof(ops));
1506 	ops.acpi_op_add = 1;
1507 	ops.acpi_op_start = 1;
1508 
1509 	/*
1510 	 * Enumerate all fixed-feature devices.
1511 	 */
1512 	if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
1513 		result = acpi_add_single_object(&device, acpi_root,
1514 						NULL,
1515 						ACPI_BUS_TYPE_POWER_BUTTON,
1516 						&ops);
1517 	}
1518 
1519 	if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
1520 		result = acpi_add_single_object(&device, acpi_root,
1521 						NULL,
1522 						ACPI_BUS_TYPE_SLEEP_BUTTON,
1523 						&ops);
1524 	}
1525 
1526 	return result;
1527 }
1528 
1529 int __init acpi_boot_ec_enable(void);
1530 
1531 static int __init acpi_scan_init(void)
1532 {
1533 	int result;
1534 	struct acpi_bus_ops ops;
1535 
1536 
1537 	if (acpi_disabled)
1538 		return 0;
1539 
1540 	memset(&ops, 0, sizeof(ops));
1541 	ops.acpi_op_add = 1;
1542 	ops.acpi_op_start = 1;
1543 
1544 	result = bus_register(&acpi_bus_type);
1545 	if (result) {
1546 		/* We don't want to quit even if we failed to add suspend/resume */
1547 		printk(KERN_ERR PREFIX "Could not register bus type\n");
1548 	}
1549 
1550 	/*
1551 	 * Create the root device in the bus's device tree
1552 	 */
1553 	result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
1554 					ACPI_BUS_TYPE_SYSTEM, &ops);
1555 	if (result)
1556 		goto Done;
1557 
1558 	/*
1559 	 * Enumerate devices in the ACPI namespace.
1560 	 */
1561 	result = acpi_bus_scan_fixed(acpi_root);
1562 
1563 	/* EC region might be needed at bus_scan, so enable it now */
1564 	acpi_boot_ec_enable();
1565 
1566 	if (!result)
1567 		result = acpi_bus_scan(acpi_root, &ops);
1568 
1569 	if (result)
1570 		acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1571 
1572       Done:
1573 	return result;
1574 }
1575 
1576 subsys_initcall(acpi_scan_init);
1577