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