Kernel

Kernel Git Source Tree

Root/drivers/acpi/scan.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/acpi/scan.c

interactive