blob: bd5253ee5c858de0af62f409590fee76e80429c7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * scan.c - support for transforming the ACPI namespace into individual objects
3 */
4
5#include <linux/module.h>
6#include <linux/init.h>
Randy Dunlap9b6d97b2006-07-12 02:08:00 -04007#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/acpi.h>
Alok N Kataria74523c92008-06-13 12:54:24 -04009#include <linux/signal.h>
10#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
12#include <acpi/acpi_drivers.h>
13#include <acpi/acinterp.h> /* for acpi_ex_eisa_id_to_string() */
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050016ACPI_MODULE_NAME("scan");
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#define STRUCT_TO_INT(s) (*((int*)&s))
Len Brown4be44fc2005-08-05 00:44:28 -040018extern struct acpi_device *acpi_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20#define ACPI_BUS_CLASS "system_bus"
Thomas Renninger29b71a12007-07-23 14:43:51 +020021#define ACPI_BUS_HID "LNXSYBUS"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#define ACPI_BUS_DEVICE_NAME "System Bus"
23
24static LIST_HEAD(acpi_device_list);
Zhang Ruie49bd2d2006-12-08 17:23:43 +080025static LIST_HEAD(acpi_bus_id_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070026DEFINE_SPINLOCK(acpi_device_lock);
27LIST_HEAD(acpi_wakeup_device_list);
28
Zhang Ruie49bd2d2006-12-08 17:23:43 +080029struct acpi_device_bus_id{
Zhang Ruibb095852007-01-04 15:03:18 +080030 char bus_id[15];
Zhang Ruie49bd2d2006-12-08 17:23:43 +080031 unsigned int instance_no;
32 struct list_head node;
33};
Thomas Renninger29b71a12007-07-23 14:43:51 +020034
35/*
36 * Creates hid/cid(s) string needed for modalias and uevent
37 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
38 * char *modalias: "acpi:IBM0001:ACPI0001"
39*/
Adrian Bunkb3e572d2007-08-14 23:22:35 +020040static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
41 int size)
42{
Thomas Renninger29b71a12007-07-23 14:43:51 +020043 int len;
Zhang Rui5c9fcb52008-03-20 16:40:32 +080044 int count;
Thomas Renninger29b71a12007-07-23 14:43:51 +020045
Zhang Rui5c9fcb52008-03-20 16:40:32 +080046 if (!acpi_dev->flags.hardware_id && !acpi_dev->flags.compatible_ids)
Thomas Renninger29b71a12007-07-23 14:43:51 +020047 return -ENODEV;
48
Zhang Rui5c9fcb52008-03-20 16:40:32 +080049 len = snprintf(modalias, size, "acpi:");
Thomas Renninger29b71a12007-07-23 14:43:51 +020050 size -= len;
51
Zhang Rui5c9fcb52008-03-20 16:40:32 +080052 if (acpi_dev->flags.hardware_id) {
53 count = snprintf(&modalias[len], size, "%s:",
54 acpi_dev->pnp.hardware_id);
55 if (count < 0 || count >= size)
56 return -EINVAL;
57 len += count;
58 size -= count;
59 }
60
Thomas Renninger29b71a12007-07-23 14:43:51 +020061 if (acpi_dev->flags.compatible_ids) {
62 struct acpi_compatible_id_list *cid_list;
63 int i;
Thomas Renninger29b71a12007-07-23 14:43:51 +020064
65 cid_list = acpi_dev->pnp.cid_list;
66 for (i = 0; i < cid_list->count; i++) {
67 count = snprintf(&modalias[len], size, "%s:",
68 cid_list->id[i].value);
69 if (count < 0 || count >= size) {
Len Brown87ecd5c2008-01-01 14:00:00 -050070 printk(KERN_ERR PREFIX "%s cid[%i] exceeds event buffer size",
Thomas Renninger29b71a12007-07-23 14:43:51 +020071 acpi_dev->pnp.device_name, i);
72 break;
73 }
74 len += count;
75 size -= count;
76 }
77 }
78
79 modalias[len] = '\0';
80 return len;
81}
82
83static ssize_t
84acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
85 struct acpi_device *acpi_dev = to_acpi_device(dev);
86 int len;
87
88 /* Device has no HID and no CID or string is >1024 */
89 len = create_modalias(acpi_dev, buf, 1024);
90 if (len <= 0)
91 return 0;
92 buf[len++] = '\n';
93 return len;
94}
95static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
96
Zhang Rui26d46862008-04-29 02:35:48 -040097static int acpi_bus_hot_remove_device(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Zhang Rui26d46862008-04-29 02:35:48 -040099 struct acpi_device *device;
100 acpi_handle handle = context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 struct acpi_object_list arg_list;
102 union acpi_object arg;
103 acpi_status status = AE_OK;
104
Zhang Rui26d46862008-04-29 02:35:48 -0400105 if (acpi_bus_get_device(handle, &device))
106 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Zhang Rui26d46862008-04-29 02:35:48 -0400108 if (!device)
109 return 0;
110
111 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Kay Sievers07944692008-10-30 01:18:59 +0100112 "Hot-removing device %s...\n", dev_name(&device->dev)));
Zhang Rui26d46862008-04-29 02:35:48 -0400113
114 if (acpi_bus_trim(device, 1)) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800115 printk(KERN_ERR PREFIX
116 "Removing device failed\n");
Zhang Rui26d46862008-04-29 02:35:48 -0400117 return -1;
118 }
119
120 /* power off device */
121 status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
122 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
Lin Ming55ac9a02008-09-28 14:51:56 +0800123 printk(KERN_WARNING PREFIX
124 "Power-off device failed\n");
Zhang Rui26d46862008-04-29 02:35:48 -0400125
126 if (device->flags.lockable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 arg_list.count = 1;
128 arg_list.pointer = &arg;
129 arg.type = ACPI_TYPE_INTEGER;
130 arg.integer.value = 0;
131 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
132 }
133
134 arg_list.count = 1;
135 arg_list.pointer = &arg;
136 arg.type = ACPI_TYPE_INTEGER;
137 arg.integer.value = 1;
138
139 /*
140 * TBD: _EJD support.
141 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
Zhang Rui26d46862008-04-29 02:35:48 -0400143 if (ACPI_FAILURE(status))
144 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Zhang Rui26d46862008-04-29 02:35:48 -0400146 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149static ssize_t
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800150acpi_eject_store(struct device *d, struct device_attribute *attr,
151 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Len Brown4be44fc2005-08-05 00:44:28 -0400153 int ret = count;
Len Brown4be44fc2005-08-05 00:44:28 -0400154 acpi_status status;
Len Brown4be44fc2005-08-05 00:44:28 -0400155 acpi_object_type type = 0;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800156 struct acpi_device *acpi_device = to_acpi_device(d);
Alok N Kataria74523c92008-06-13 12:54:24 -0400157 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 if ((!count) || (buf[0] != '1')) {
160 return -EINVAL;
161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162#ifndef FORCE_EJECT
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800163 if (acpi_device->driver == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 ret = -ENODEV;
165 goto err;
166 }
167#endif
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800168 status = acpi_get_type(acpi_device->handle, &type);
169 if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 ret = -ENODEV;
171 goto err;
172 }
173
Zhang Rui26d46862008-04-29 02:35:48 -0400174 /* remove the device in another thread to fix the deadlock issue */
Alok N Kataria74523c92008-06-13 12:54:24 -0400175 task = kthread_run(acpi_bus_hot_remove_device,
176 acpi_device->handle, "acpi_hot_remove_device");
177 if (IS_ERR(task))
178 ret = PTR_ERR(task);
179err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
182
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800183static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800185static ssize_t
186acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
187 struct acpi_device *acpi_dev = to_acpi_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800189 return sprintf(buf, "%s\n", acpi_dev->pnp.hardware_id);
190}
191static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
192
193static ssize_t
194acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
195 struct acpi_device *acpi_dev = to_acpi_device(dev);
196 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
197 int result;
198
199 result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
200 if(result)
201 goto end;
202
203 result = sprintf(buf, "%s\n", (char*)path.pointer);
204 kfree(path.pointer);
205 end:
206 return result;
207}
208static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
209
210static int acpi_device_setup_files(struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800212 acpi_status status;
213 acpi_handle temp;
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800214 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800216 /*
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800217 * Devices gotten from FADT don't have a "path" attribute
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800218 */
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800219 if(dev->handle) {
220 result = device_create_file(&dev->dev, &dev_attr_path);
221 if(result)
222 goto end;
223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800225 if(dev->flags.hardware_id) {
226 result = device_create_file(&dev->dev, &dev_attr_hid);
227 if(result)
228 goto end;
229 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Thomas Renninger29b71a12007-07-23 14:43:51 +0200231 if (dev->flags.hardware_id || dev->flags.compatible_ids){
232 result = device_create_file(&dev->dev, &dev_attr_modalias);
233 if(result)
234 goto end;
235 }
236
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800237 /*
238 * If device has _EJ0, 'eject' file is created that is used to trigger
239 * hot-removal function from userland.
240 */
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800241 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
242 if (ACPI_SUCCESS(status))
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800243 result = device_create_file(&dev->dev, &dev_attr_eject);
244 end:
245 return result;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800246}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800248static void acpi_device_remove_files(struct acpi_device *dev)
249{
250 acpi_status status;
251 acpi_handle temp;
252
253 /*
254 * If device has _EJ0, 'eject' file is created that is used to trigger
255 * hot-removal function from userland.
256 */
257 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
258 if (ACPI_SUCCESS(status))
259 device_remove_file(&dev->dev, &dev_attr_eject);
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800260
Thomas Renninger29b71a12007-07-23 14:43:51 +0200261 if (dev->flags.hardware_id || dev->flags.compatible_ids)
262 device_remove_file(&dev->dev, &dev_attr_modalias);
263
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800264 if(dev->flags.hardware_id)
265 device_remove_file(&dev->dev, &dev_attr_hid);
266 if(dev->handle)
267 device_remove_file(&dev->dev, &dev_attr_path);
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800268}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269/* --------------------------------------------------------------------------
Zhang Rui9e89dde2006-12-07 20:56:16 +0800270 ACPI Bus operations
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 -------------------------------------------------------------------------- */
Thomas Renninger29b71a12007-07-23 14:43:51 +0200272
273int acpi_match_device_ids(struct acpi_device *device,
274 const struct acpi_device_id *ids)
275{
276 const struct acpi_device_id *id;
277
Zhao Yakui39a0ad82008-08-11 13:40:22 +0800278 /*
279 * If the device is not present, it is unnecessary to load device
280 * driver for it.
281 */
282 if (!device->status.present)
283 return -ENODEV;
284
Thomas Renninger29b71a12007-07-23 14:43:51 +0200285 if (device->flags.hardware_id) {
286 for (id = ids; id->id[0]; id++) {
287 if (!strcmp((char*)id->id, device->pnp.hardware_id))
288 return 0;
289 }
290 }
291
292 if (device->flags.compatible_ids) {
293 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
294 int i;
295
296 for (id = ids; id->id[0]; id++) {
297 /* compare multiple _CID entries against driver ids */
298 for (i = 0; i < cid_list->count; i++) {
299 if (!strcmp((char*)id->id,
300 cid_list->id[i].value))
301 return 0;
302 }
303 }
304 }
305
306 return -ENOENT;
307}
308EXPORT_SYMBOL(acpi_match_device_ids);
309
Patrick Mochel1890a972006-12-07 20:56:31 +0800310static void acpi_device_release(struct device *dev)
311{
312 struct acpi_device *acpi_dev = to_acpi_device(dev);
313
314 kfree(acpi_dev->pnp.cid_list);
315 kfree(acpi_dev);
316}
317
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800318static int acpi_device_suspend(struct device *dev, pm_message_t state)
Zhang Rui9e89dde2006-12-07 20:56:16 +0800319{
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800320 struct acpi_device *acpi_dev = to_acpi_device(dev);
321 struct acpi_driver *acpi_drv = acpi_dev->driver;
Zhang Rui9e89dde2006-12-07 20:56:16 +0800322
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800323 if (acpi_drv && acpi_drv->ops.suspend)
324 return acpi_drv->ops.suspend(acpi_dev, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return 0;
326}
327
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800328static int acpi_device_resume(struct device *dev)
329{
330 struct acpi_device *acpi_dev = to_acpi_device(dev);
331 struct acpi_driver *acpi_drv = acpi_dev->driver;
332
333 if (acpi_drv && acpi_drv->ops.resume)
334 return acpi_drv->ops.resume(acpi_dev);
335 return 0;
336}
337
338static int acpi_bus_match(struct device *dev, struct device_driver *drv)
339{
340 struct acpi_device *acpi_dev = to_acpi_device(dev);
341 struct acpi_driver *acpi_drv = to_acpi_driver(drv);
342
Thomas Renninger29b71a12007-07-23 14:43:51 +0200343 return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800344}
345
Kay Sievers7eff2e72007-08-14 15:15:12 +0200346static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800347{
348 struct acpi_device *acpi_dev = to_acpi_device(dev);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200349 int len;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800350
Kay Sievers7eff2e72007-08-14 15:15:12 +0200351 if (add_uevent_var(env, "MODALIAS="))
352 return -ENOMEM;
353 len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
354 sizeof(env->buf) - env->buflen);
355 if (len >= (sizeof(env->buf) - env->buflen))
356 return -ENOMEM;
357 env->buflen += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return 0;
359}
360
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800361static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
362static int acpi_start_single_object(struct acpi_device *);
363static int acpi_device_probe(struct device * dev)
Zhang Rui9e89dde2006-12-07 20:56:16 +0800364{
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800365 struct acpi_device *acpi_dev = to_acpi_device(dev);
366 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
367 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800369 ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
370 if (!ret) {
Li Shaohuac4168bf2006-12-07 20:56:41 +0800371 if (acpi_dev->bus_ops.acpi_op_start)
372 acpi_start_single_object(acpi_dev);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800373 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
374 "Found driver [%s] for device [%s]\n",
375 acpi_drv->name, acpi_dev->pnp.bus_id));
376 get_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800377 }
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800378 return ret;
379}
380
381static int acpi_device_remove(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) {
387 if (acpi_drv->ops.stop)
Li Shaohua96333572006-12-07 20:56:46 +0800388 acpi_drv->ops.stop(acpi_dev, acpi_dev->removal_type);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800389 if (acpi_drv->ops.remove)
Li Shaohua96333572006-12-07 20:56:46 +0800390 acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800391 }
392 acpi_dev->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700393 acpi_dev->driver_data = NULL;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800394
395 put_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800396 return 0;
397}
398
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800399static void acpi_device_shutdown(struct device *dev)
Zhang Rui9e89dde2006-12-07 20:56:16 +0800400{
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800401 struct acpi_device *acpi_dev = to_acpi_device(dev);
402 struct acpi_driver *acpi_drv = acpi_dev->driver;
Zhang Rui9e89dde2006-12-07 20:56:16 +0800403
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800404 if (acpi_drv && acpi_drv->ops.shutdown)
405 acpi_drv->ops.shutdown(acpi_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800407 return ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409
David Brownell55955aa2007-05-08 00:28:35 -0700410struct bus_type acpi_bus_type = {
Zhang Rui9e89dde2006-12-07 20:56:16 +0800411 .name = "acpi",
412 .suspend = acpi_device_suspend,
413 .resume = acpi_device_resume,
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800414 .shutdown = acpi_device_shutdown,
415 .match = acpi_bus_match,
416 .probe = acpi_device_probe,
417 .remove = acpi_device_remove,
418 .uevent = acpi_device_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419};
420
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800421static int acpi_device_register(struct acpi_device *device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct acpi_device *parent)
423{
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800424 int result;
425 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
426 int found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 /*
428 * Linkage
429 * -------
430 * Link this device to its parent and siblings.
431 */
432 INIT_LIST_HEAD(&device->children);
433 INIT_LIST_HEAD(&device->node);
434 INIT_LIST_HEAD(&device->g_list);
435 INIT_LIST_HEAD(&device->wakeup_list);
436
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800437 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
438 if (!new_bus_id) {
439 printk(KERN_ERR PREFIX "Memory allocation error\n");
440 return -ENOMEM;
441 }
442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 spin_lock(&acpi_device_lock);
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800444 /*
445 * Find suitable bus_id and instance number in acpi_bus_id_list
446 * If failed, create one and link it into acpi_bus_id_list
447 */
448 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
Zhang Ruibb095852007-01-04 15:03:18 +0800449 if(!strcmp(acpi_device_bus_id->bus_id, device->flags.hardware_id? device->pnp.hardware_id : "device")) {
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800450 acpi_device_bus_id->instance_no ++;
451 found = 1;
452 kfree(new_bus_id);
453 break;
454 }
455 }
456 if(!found) {
457 acpi_device_bus_id = new_bus_id;
Zhang Ruibb095852007-01-04 15:03:18 +0800458 strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800459 acpi_device_bus_id->instance_no = 0;
460 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
461 }
Kay Sievers07944692008-10-30 01:18:59 +0100462 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 if (device->parent) {
465 list_add_tail(&device->node, &device->parent->children);
466 list_add_tail(&device->g_list, &device->parent->g_list);
467 } else
468 list_add_tail(&device->g_list, &acpi_device_list);
469 if (device->wakeup.flags.valid)
470 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
471 spin_unlock(&acpi_device_lock);
472
Patrick Mochel1890a972006-12-07 20:56:31 +0800473 if (device->parent)
474 device->dev.parent = &parent->dev;
475 device->dev.bus = &acpi_bus_type;
476 device_initialize(&device->dev);
Patrick Mochel1890a972006-12-07 20:56:31 +0800477 device->dev.release = &acpi_device_release;
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800478 result = device_add(&device->dev);
479 if(result) {
Greg Kroah-Hartmanfc3a8822008-05-02 06:02:41 +0200480 dev_err(&device->dev, "Error adding device\n");
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800481 goto end;
482 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800483
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800484 result = acpi_device_setup_files(device);
485 if(result)
Kay Sievers07944692008-10-30 01:18:59 +0100486 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
487 dev_name(&device->dev));
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800488
Li Shaohua96333572006-12-07 20:56:46 +0800489 device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
Zhang Ruie49bd2d2006-12-08 17:23:43 +0800490 return 0;
491 end:
492 spin_lock(&acpi_device_lock);
493 if (device->parent) {
494 list_del(&device->node);
495 list_del(&device->g_list);
496 } else
497 list_del(&device->g_list);
498 list_del(&device->wakeup_list);
499 spin_unlock(&acpi_device_lock);
500 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503static void acpi_device_unregister(struct acpi_device *device, int type)
504{
505 spin_lock(&acpi_device_lock);
506 if (device->parent) {
507 list_del(&device->node);
508 list_del(&device->g_list);
509 } else
510 list_del(&device->g_list);
511
512 list_del(&device->wakeup_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 spin_unlock(&acpi_device_lock);
514
515 acpi_detach_data(device->handle, acpi_bus_data_handler);
Patrick Mochel1890a972006-12-07 20:56:31 +0800516
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800517 acpi_device_remove_files(device);
Patrick Mochel1890a972006-12-07 20:56:31 +0800518 device_unregister(&device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
520
Zhang Rui9e89dde2006-12-07 20:56:16 +0800521/* --------------------------------------------------------------------------
522 Driver Management
523 -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500525 * acpi_bus_driver_init - add a device to a driver
526 * @device: the device to add and initialize
527 * @driver: driver for the device
528 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 * Used to initialize a device via its device driver. Called whenever a
Patrick Mochel1890a972006-12-07 20:56:31 +0800530 * driver is bound to a device. Invokes the driver's add() ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 */
532static int
Len Brown4be44fc2005-08-05 00:44:28 -0400533acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
Len Brown4be44fc2005-08-05 00:44:28 -0400535 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
538 if (!device || !driver)
Patrick Mocheld550d982006-06-27 00:41:40 -0400539 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
541 if (!driver->ops.add)
Patrick Mocheld550d982006-06-27 00:41:40 -0400542 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 result = driver->ops.add(device);
545 if (result) {
546 device->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700547 device->driver_data = NULL;
Patrick Mocheld550d982006-06-27 00:41:40 -0400548 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
550
551 device->driver = driver;
552
553 /*
554 * TBD - Configuration Management: Assign resources to device based
555 * upon possible configuration and currently allocated resources.
556 */
557
Len Brown4be44fc2005-08-05 00:44:28 -0400558 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
559 "Driver successfully bound to device\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400560 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -0700561}
562
Adrian Bunk8713cbe2005-09-02 17:16:48 -0400563static int acpi_start_single_object(struct acpi_device *device)
Rajesh Shah3fb02732005-04-28 00:25:52 -0700564{
565 int result = 0;
566 struct acpi_driver *driver;
567
Rajesh Shah3fb02732005-04-28 00:25:52 -0700568
569 if (!(driver = device->driver))
Patrick Mocheld550d982006-06-27 00:41:40 -0400570 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -0700571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (driver->ops.start) {
573 result = driver->ops.start(device);
574 if (result && driver->ops.remove)
575 driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577
Patrick Mocheld550d982006-06-27 00:41:40 -0400578 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500582 * acpi_bus_register_driver - register a driver with the ACPI bus
583 * @driver: driver being registered
584 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 * Registers a driver with the ACPI bus. Searches the namespace for all
Bjorn Helgaas9d9f7492006-03-28 17:04:00 -0500586 * devices that match the driver's criteria and binds. Returns zero for
587 * success or a negative error status for failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 */
Len Brown4be44fc2005-08-05 00:44:28 -0400589int acpi_bus_register_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
Patrick Mochel1890a972006-12-07 20:56:31 +0800591 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400594 return -ENODEV;
Patrick Mochel1890a972006-12-07 20:56:31 +0800595 driver->drv.name = driver->name;
596 driver->drv.bus = &acpi_bus_type;
597 driver->drv.owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Patrick Mochel1890a972006-12-07 20:56:31 +0800599 ret = driver_register(&driver->drv);
600 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Len Brown4be44fc2005-08-05 00:44:28 -0400603EXPORT_SYMBOL(acpi_bus_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500606 * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
607 * @driver: driver to unregister
608 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 * Unregisters a driver with the ACPI bus. Searches the namespace for all
610 * devices that match the driver's criteria and unbinds.
611 */
Bjorn Helgaas06ea8e02006-04-27 05:25:00 -0400612void acpi_bus_unregister_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
Patrick Mochel1890a972006-12-07 20:56:31 +0800614 driver_unregister(&driver->drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
Len Brown4be44fc2005-08-05 00:44:28 -0400616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617EXPORT_SYMBOL(acpi_bus_unregister_driver);
618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619/* --------------------------------------------------------------------------
620 Device Enumeration
621 -------------------------------------------------------------------------- */
Len Brownc8f7a622006-07-09 17:22:28 -0400622acpi_status
623acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
624{
625 acpi_status status;
626 acpi_handle tmp;
627 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
628 union acpi_object *obj;
629
630 status = acpi_get_handle(handle, "_EJD", &tmp);
631 if (ACPI_FAILURE(status))
632 return status;
633
634 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
635 if (ACPI_SUCCESS(status)) {
636 obj = buffer.pointer;
Holger Macht3b5fee52008-02-14 13:40:34 +0100637 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
638 ejd);
Len Brownc8f7a622006-07-09 17:22:28 -0400639 kfree(buffer.pointer);
640 }
641 return status;
642}
643EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
646{
647
648 /* TBD */
649
650 return;
651}
652
Zhang Rui9e89dde2006-12-07 20:56:16 +0800653static int acpi_bus_get_perf_flags(struct acpi_device *device)
654{
655 device->performance.state = ACPI_STATE_UNKNOWN;
656 return 0;
657}
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659static acpi_status
660acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
661 union acpi_object *package)
662{
663 int i = 0;
664 union acpi_object *element = NULL;
665
666 if (!device || !package || (package->package.count < 2))
667 return AE_BAD_PARAMETER;
668
669 element = &(package->package.elements[0]);
670 if (!element)
671 return AE_BAD_PARAMETER;
672 if (element->type == ACPI_TYPE_PACKAGE) {
673 if ((element->package.count < 2) ||
674 (element->package.elements[0].type !=
675 ACPI_TYPE_LOCAL_REFERENCE)
676 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
677 return AE_BAD_DATA;
678 device->wakeup.gpe_device =
679 element->package.elements[0].reference.handle;
680 device->wakeup.gpe_number =
681 (u32) element->package.elements[1].integer.value;
682 } else if (element->type == ACPI_TYPE_INTEGER) {
683 device->wakeup.gpe_number = element->integer.value;
684 } else
685 return AE_BAD_DATA;
686
687 element = &(package->package.elements[1]);
688 if (element->type != ACPI_TYPE_INTEGER) {
689 return AE_BAD_DATA;
690 }
691 device->wakeup.sleep_state = element->integer.value;
692
693 if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
694 return AE_NO_MEMORY;
695 }
696 device->wakeup.resources.count = package->package.count - 2;
697 for (i = 0; i < device->wakeup.resources.count; i++) {
698 element = &(package->package.elements[i + 2]);
Bob Moorecd0b2242008-04-10 19:06:43 +0400699 if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 return AE_BAD_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 device->wakeup.resources.handles[i] = element->reference.handle;
703 }
704
705 return AE_OK;
706}
707
708static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
709{
710 acpi_status status = 0;
711 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
712 union acpi_object *package = NULL;
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200713 int psw_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Thomas Renninger29b71a12007-07-23 14:43:51 +0200715 struct acpi_device_id button_device_ids[] = {
716 {"PNP0C0D", 0},
717 {"PNP0C0C", 0},
718 {"PNP0C0E", 0},
719 {"", 0},
720 };
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 /* _PRW */
723 status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
724 if (ACPI_FAILURE(status)) {
725 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
726 goto end;
727 }
728
729 package = (union acpi_object *)buffer.pointer;
730 status = acpi_bus_extract_wakeup_device_power_package(device, package);
731 if (ACPI_FAILURE(status)) {
732 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
733 goto end;
734 }
735
736 kfree(buffer.pointer);
737
738 device->wakeup.flags.valid = 1;
Zhao Yakui729b2bd2008-03-19 13:26:54 +0800739 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
740 * system for the ACPI device with the _PRW object.
741 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
742 * So it is necessary to call _DSW object first. Only when it is not
743 * present will the _PSW object used.
744 */
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200745 psw_error = acpi_device_sleep_wake(device, 0, 0, 0);
746 if (psw_error)
747 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
748 "error in _DSW or _PSW evaluation\n"));
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 /* Power button, Lid switch always enable wakeup */
Thomas Renninger29b71a12007-07-23 14:43:51 +0200751 if (!acpi_match_device_ids(device, button_device_ids))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 device->wakeup.flags.run_wake = 1;
753
Zhang Ruifaee816b12008-09-12 11:12:25 +0800754 /*
755 * Don't set Power button GPE as run_wake
756 * if Fixed Power button is used
757 */
758 if (!strcmp(device->pnp.hardware_id, "PNP0C0C") &&
759 !(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
760 device->wakeup.flags.run_wake = 0;
761 device->wakeup.flags.valid = 0;
762 }
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 end:
765 if (ACPI_FAILURE(status))
766 device->flags.wake_capable = 0;
767 return 0;
768}
769
Zhang Rui9e89dde2006-12-07 20:56:16 +0800770static int acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771{
Zhang Rui9e89dde2006-12-07 20:56:16 +0800772 acpi_status status = 0;
773 acpi_handle handle = NULL;
774 u32 i = 0;
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800778 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800780 status = acpi_get_handle(device->handle, "_PSC", &handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (ACPI_SUCCESS(status))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800782 device->power.flags.explicit_get = 1;
783 status = acpi_get_handle(device->handle, "_IRC", &handle);
784 if (ACPI_SUCCESS(status))
785 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
787 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800788 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800790 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
791 struct acpi_device_power_state *ps = &device->power.states[i];
792 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Zhang Rui9e89dde2006-12-07 20:56:16 +0800794 /* Evaluate "_PRx" to se if power resources are referenced */
795 acpi_evaluate_reference(device->handle, object_name, NULL,
796 &ps->resources);
797 if (ps->resources.count) {
798 device->power.flags.power_resources = 1;
799 ps->flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Zhang Rui9e89dde2006-12-07 20:56:16 +0800802 /* Evaluate "_PSx" to see if we can do explicit sets */
803 object_name[2] = 'S';
804 status = acpi_get_handle(device->handle, object_name, &handle);
805 if (ACPI_SUCCESS(status)) {
806 ps->flags.explicit_set = 1;
807 ps->flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 }
Zhang Rui9e89dde2006-12-07 20:56:16 +0800809
810 /* State is valid if we have some power control */
811 if (ps->resources.count || ps->flags.explicit_set)
812 ps->flags.valid = 1;
813
814 ps->power = -1; /* Unknown - driver assigned */
815 ps->latency = -1; /* Unknown - driver assigned */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Zhang Rui9e89dde2006-12-07 20:56:16 +0800818 /* Set defaults for D0 and D3 states (always valid) */
819 device->power.states[ACPI_STATE_D0].flags.valid = 1;
820 device->power.states[ACPI_STATE_D0].power = 100;
821 device->power.states[ACPI_STATE_D3].flags.valid = 1;
822 device->power.states[ACPI_STATE_D3].power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Zhang Rui9e89dde2006-12-07 20:56:16 +0800824 /* TBD: System wake support and resource requirements. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Zhang Rui9e89dde2006-12-07 20:56:16 +0800826 device->power.state = ACPI_STATE_UNKNOWN;
Zhao Yakuia51e1452008-08-11 14:55:05 +0800827 acpi_bus_get_power(device->handle, &(device->power.state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 return 0;
830}
831
Len Brown4be44fc2005-08-05 00:44:28 -0400832static int acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833{
Len Brown4be44fc2005-08-05 00:44:28 -0400834 acpi_status status = AE_OK;
835 acpi_handle temp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 /* Presence of _STA indicates 'dynamic_status' */
839 status = acpi_get_handle(device->handle, "_STA", &temp);
840 if (ACPI_SUCCESS(status))
841 device->flags.dynamic_status = 1;
842
843 /* Presence of _CID indicates 'compatible_ids' */
844 status = acpi_get_handle(device->handle, "_CID", &temp);
845 if (ACPI_SUCCESS(status))
846 device->flags.compatible_ids = 1;
847
848 /* Presence of _RMV indicates 'removable' */
849 status = acpi_get_handle(device->handle, "_RMV", &temp);
850 if (ACPI_SUCCESS(status))
851 device->flags.removable = 1;
852
853 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
854 status = acpi_get_handle(device->handle, "_EJD", &temp);
855 if (ACPI_SUCCESS(status))
856 device->flags.ejectable = 1;
857 else {
858 status = acpi_get_handle(device->handle, "_EJ0", &temp);
859 if (ACPI_SUCCESS(status))
860 device->flags.ejectable = 1;
861 }
862
863 /* Presence of _LCK indicates 'lockable' */
864 status = acpi_get_handle(device->handle, "_LCK", &temp);
865 if (ACPI_SUCCESS(status))
866 device->flags.lockable = 1;
867
868 /* Presence of _PS0|_PR0 indicates 'power manageable' */
869 status = acpi_get_handle(device->handle, "_PS0", &temp);
870 if (ACPI_FAILURE(status))
871 status = acpi_get_handle(device->handle, "_PR0", &temp);
872 if (ACPI_SUCCESS(status))
873 device->flags.power_manageable = 1;
874
875 /* Presence of _PRW indicates wake capable */
876 status = acpi_get_handle(device->handle, "_PRW", &temp);
877 if (ACPI_SUCCESS(status))
878 device->flags.wake_capable = 1;
879
Joe Perches3c5f9be2008-02-03 17:06:17 +0200880 /* TBD: Performance management */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Patrick Mocheld550d982006-06-27 00:41:40 -0400882 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883}
884
Len Brown4be44fc2005-08-05 00:44:28 -0400885static void acpi_device_get_busid(struct acpi_device *device,
886 acpi_handle handle, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887{
Len Brown4be44fc2005-08-05 00:44:28 -0400888 char bus_id[5] = { '?', 0 };
889 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
890 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892 /*
893 * Bus ID
894 * ------
895 * The device's Bus ID is simply the object name.
896 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
897 */
898 switch (type) {
899 case ACPI_BUS_TYPE_SYSTEM:
900 strcpy(device->pnp.bus_id, "ACPI");
901 break;
902 case ACPI_BUS_TYPE_POWER_BUTTON:
903 strcpy(device->pnp.bus_id, "PWRF");
904 break;
905 case ACPI_BUS_TYPE_SLEEP_BUTTON:
906 strcpy(device->pnp.bus_id, "SLPF");
907 break;
908 default:
909 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
910 /* Clean up trailing underscores (if any) */
911 for (i = 3; i > 1; i--) {
912 if (bus_id[i] == '_')
913 bus_id[i] = '\0';
914 else
915 break;
916 }
917 strcpy(device->pnp.bus_id, bus_id);
918 break;
919 }
920}
921
Zhang Rui54735262007-01-11 02:09:09 -0500922/*
923 * acpi_bay_match - see if a device is an ejectable driver bay
924 *
925 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
926 * then we can safely call it an ejectable drive bay
927 */
928static int acpi_bay_match(struct acpi_device *device){
929 acpi_status status;
930 acpi_handle handle;
931 acpi_handle tmp;
932 acpi_handle phandle;
933
934 handle = device->handle;
935
936 status = acpi_get_handle(handle, "_EJ0", &tmp);
937 if (ACPI_FAILURE(status))
938 return -ENODEV;
939
940 if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
941 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
942 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
943 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
944 return 0;
945
946 if (acpi_get_parent(handle, &phandle))
947 return -ENODEV;
948
949 if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
950 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
951 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
952 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
953 return 0;
954
955 return -ENODEV;
956}
957
Frank Seidel3620f2f2007-12-07 13:20:34 +0100958/*
959 * acpi_dock_match - see if a device has a _DCK method
960 */
961static int acpi_dock_match(struct acpi_device *device)
962{
963 acpi_handle tmp;
964 return acpi_get_handle(device->handle, "_DCK", &tmp);
965}
966
Len Brown4be44fc2005-08-05 00:44:28 -0400967static void acpi_device_set_id(struct acpi_device *device,
968 struct acpi_device *parent, acpi_handle handle,
969 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
Len Brown4be44fc2005-08-05 00:44:28 -0400971 struct acpi_device_info *info;
972 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
973 char *hid = NULL;
974 char *uid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 struct acpi_compatible_id_list *cid_list = NULL;
Frank Seidel3620f2f2007-12-07 13:20:34 +0100976 const char *cid_add = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400977 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 switch (type) {
980 case ACPI_BUS_TYPE_DEVICE:
981 status = acpi_get_object_info(handle, &buffer);
982 if (ACPI_FAILURE(status)) {
Harvey Harrison96b2dd12008-03-05 18:24:51 -0800983 printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 return;
985 }
986
987 info = buffer.pointer;
988 if (info->valid & ACPI_VALID_HID)
989 hid = info->hardware_id.value;
990 if (info->valid & ACPI_VALID_UID)
991 uid = info->unique_id.value;
992 if (info->valid & ACPI_VALID_CID)
993 cid_list = &info->compatibility_id;
994 if (info->valid & ACPI_VALID_ADR) {
995 device->pnp.bus_address = info->address;
996 device->flags.bus_address = 1;
997 }
Zhang Ruiae843332006-12-07 20:57:10 +0800998
Frank Seidel3620f2f2007-12-07 13:20:34 +0100999 /* If we have a video/bay/dock device, add our selfdefined
1000 HID to the CID list. Like that the video/bay/dock drivers
1001 will get autoloaded and the device might still match
1002 against another driver.
1003 */
Thomas Renningerc3d6de62008-08-01 17:37:55 +02001004 if (acpi_is_video_device(device))
Frank Seidel3620f2f2007-12-07 13:20:34 +01001005 cid_add = ACPI_VIDEO_HID;
1006 else if (ACPI_SUCCESS(acpi_bay_match(device)))
1007 cid_add = ACPI_BAY_HID;
1008 else if (ACPI_SUCCESS(acpi_dock_match(device)))
1009 cid_add = ACPI_DOCK_HID;
Zhang Rui54735262007-01-11 02:09:09 -05001010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 break;
1012 case ACPI_BUS_TYPE_POWER:
1013 hid = ACPI_POWER_HID;
1014 break;
1015 case ACPI_BUS_TYPE_PROCESSOR:
Myron Stowead93a762008-11-04 14:52:55 -07001016 hid = ACPI_PROCESSOR_OBJECT_HID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 break;
1018 case ACPI_BUS_TYPE_SYSTEM:
1019 hid = ACPI_SYSTEM_HID;
1020 break;
1021 case ACPI_BUS_TYPE_THERMAL:
1022 hid = ACPI_THERMAL_HID;
1023 break;
1024 case ACPI_BUS_TYPE_POWER_BUTTON:
1025 hid = ACPI_BUTTON_HID_POWERF;
1026 break;
1027 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1028 hid = ACPI_BUTTON_HID_SLEEPF;
1029 break;
1030 }
1031
1032 /*
1033 * \_SB
1034 * ----
1035 * Fix for the system root bus device -- the only root-level device.
1036 */
Bob Moorec51a4de2005-11-17 13:07:00 -05001037 if (((acpi_handle)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 hid = ACPI_BUS_HID;
1039 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1040 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1041 }
1042
1043 if (hid) {
1044 strcpy(device->pnp.hardware_id, hid);
1045 device->flags.hardware_id = 1;
1046 }
1047 if (uid) {
1048 strcpy(device->pnp.unique_id, uid);
1049 device->flags.unique_id = 1;
1050 }
Frank Seidel3620f2f2007-12-07 13:20:34 +01001051 if (cid_list || cid_add) {
1052 struct acpi_compatible_id_list *list;
1053 int size = 0;
1054 int count = 0;
1055
1056 if (cid_list) {
1057 size = cid_list->size;
1058 } else if (cid_add) {
1059 size = sizeof(struct acpi_compatible_id_list);
1060 cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
1061 if (!cid_list) {
1062 printk(KERN_ERR "Memory allocation error\n");
1063 kfree(buffer.pointer);
1064 return;
1065 } else {
1066 cid_list->count = 0;
1067 cid_list->size = size;
1068 }
1069 }
1070 if (cid_add)
1071 size += sizeof(struct acpi_compatible_id);
1072 list = kmalloc(size, GFP_KERNEL);
1073
1074 if (list) {
1075 if (cid_list) {
1076 memcpy(list, cid_list, cid_list->size);
1077 count = cid_list->count;
1078 }
1079 if (cid_add) {
1080 strncpy(list->id[count].value, cid_add,
1081 ACPI_MAX_CID_LENGTH);
1082 count++;
1083 device->flags.compatible_ids = 1;
1084 }
1085 list->size = size;
1086 list->count = count;
1087 device->pnp.cid_list = list;
1088 } else
Len Brown87ecd5c2008-01-01 14:00:00 -05001089 printk(KERN_ERR PREFIX "Memory allocation error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 }
1091
Len Brown02438d82006-06-30 03:19:10 -04001092 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093}
1094
Len Brown4be44fc2005-08-05 00:44:28 -04001095static int acpi_device_set_context(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096{
1097 acpi_status status = AE_OK;
1098 int result = 0;
1099 /*
1100 * Context
1101 * -------
1102 * Attach this 'struct acpi_device' to the ACPI object. This makes
1103 * resolutions from handle->device very efficient. Note that we need
1104 * to be careful with fixed-feature devices as they all attach to the
1105 * root object.
1106 */
Len Brown4be44fc2005-08-05 00:44:28 -04001107 if (type != ACPI_BUS_TYPE_POWER_BUTTON &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 type != ACPI_BUS_TYPE_SLEEP_BUTTON) {
1109 status = acpi_attach_data(device->handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001110 acpi_bus_data_handler, device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
1112 if (ACPI_FAILURE(status)) {
Len Brown87ecd5c2008-01-01 14:00:00 -05001113 printk(KERN_ERR PREFIX "Error attaching device data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 result = -ENODEV;
1115 }
1116 }
1117 return result;
1118}
1119
Len Brown4be44fc2005-08-05 00:44:28 -04001120static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 if (!dev)
Patrick Mocheld550d982006-06-27 00:41:40 -04001123 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Li Shaohua96333572006-12-07 20:56:46 +08001125 dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
Patrick Mochel1890a972006-12-07 20:56:31 +08001126 device_release_driver(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
1128 if (!rmdevice)
Patrick Mocheld550d982006-06-27 00:41:40 -04001129 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Rui Zhang2786f6e2006-12-21 02:21:13 -05001131 /*
1132 * unbind _ADR-Based Devices when hot removal
1133 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 if (dev->flags.bus_address) {
1135 if ((dev->parent) && (dev->parent->ops.unbind))
1136 dev->parent->ops.unbind(dev);
1137 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1139
Patrick Mocheld550d982006-06-27 00:41:40 -04001140 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141}
1142
Rajesh Shah3fb02732005-04-28 00:25:52 -07001143static int
Len Brown4be44fc2005-08-05 00:44:28 -04001144acpi_add_single_object(struct acpi_device **child,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001145 struct acpi_device *parent, acpi_handle handle, int type,
1146 struct acpi_bus_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
Len Brown4be44fc2005-08-05 00:44:28 -04001148 int result = 0;
1149 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
1152 if (!child)
Patrick Mocheld550d982006-06-27 00:41:40 -04001153 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
Burman Yan36bcbec2006-12-19 12:56:11 -08001155 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001157 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001158 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
1161 device->handle = handle;
1162 device->parent = parent;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001163 device->bus_ops = *ops; /* workround for not call .start */
1164
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
Len Brown4be44fc2005-08-05 00:44:28 -04001166 acpi_device_get_busid(device, handle, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
1168 /*
1169 * Flags
1170 * -----
1171 * Get prior to calling acpi_bus_get_status() so we know whether
1172 * or not _STA is present. Note that we only look for object
1173 * handles -- cannot evaluate objects until we know the device is
1174 * present and properly initialized.
1175 */
1176 result = acpi_bus_get_flags(device);
1177 if (result)
1178 goto end;
1179
1180 /*
1181 * Status
1182 * ------
Keiichiro Tokunaga6940fab2005-03-30 23:15:47 -05001183 * See if the device is present. We always assume that non-Device
1184 * and non-Processor objects (e.g. thermal zones, power resources,
1185 * etc.) are present, functioning, etc. (at least when parent object
1186 * is present). Note that _STA has a different meaning for some
1187 * objects (e.g. power resources) so we need to be careful how we use
1188 * it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 */
1190 switch (type) {
Keiichiro Tokunaga6940fab2005-03-30 23:15:47 -05001191 case ACPI_BUS_TYPE_PROCESSOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 case ACPI_BUS_TYPE_DEVICE:
1193 result = acpi_bus_get_status(device);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001194 if (ACPI_FAILURE(result)) {
1195 result = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 goto end;
1197 }
Zhao Yakui39a0ad82008-08-11 13:40:22 +08001198 /*
1199 * When the device is neither present nor functional, the
1200 * device should not be added to Linux ACPI device tree.
1201 * When the status of the device is not present but functinal,
1202 * it should be added to Linux ACPI tree. For example : bay
1203 * device , dock device.
1204 * In such conditions it is unncessary to check whether it is
1205 * bay device or dock device.
1206 */
1207 if (!device->status.present && !device->status.functional) {
1208 result = -ENODEV;
1209 goto end;
Frank Seidel3620f2f2007-12-07 13:20:34 +01001210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 break;
1212 default:
Bjorn Helgaas0c0e8922007-04-25 14:20:58 -04001213 STRUCT_TO_INT(device->status) =
1214 ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
1215 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 break;
1217 }
1218
1219 /*
1220 * Initialize Device
1221 * -----------------
1222 * TBD: Synch with Core's enumeration/initialization process.
1223 */
1224
1225 /*
1226 * Hardware ID, Unique ID, & Bus Address
1227 * -------------------------------------
1228 */
Len Brown4be44fc2005-08-05 00:44:28 -04001229 acpi_device_set_id(device, parent, handle, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 /*
Zhao Yakuieab4b642008-08-11 14:54:16 +08001232 * The ACPI device is attached to acpi handle before getting
1233 * the power/wakeup/peformance flags. Otherwise OS can't get
1234 * the corresponding ACPI device by the acpi handle in the course
1235 * of getting the power/wakeup/performance flags.
1236 */
1237 result = acpi_device_set_context(device, type);
1238 if (result)
1239 goto end;
1240
1241 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 * Power Management
1243 * ----------------
1244 */
1245 if (device->flags.power_manageable) {
1246 result = acpi_bus_get_power_flags(device);
1247 if (result)
1248 goto end;
1249 }
1250
Len Brown4be44fc2005-08-05 00:44:28 -04001251 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 * Wakeup device management
1253 *-----------------------
1254 */
1255 if (device->flags.wake_capable) {
1256 result = acpi_bus_get_wakeup_device_flags(device);
1257 if (result)
1258 goto end;
1259 }
1260
1261 /*
1262 * Performance Management
1263 * ----------------------
1264 */
1265 if (device->flags.performance_manageable) {
1266 result = acpi_bus_get_perf_flags(device);
1267 if (result)
1268 goto end;
1269 }
1270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Zhang Ruie49bd2d2006-12-08 17:23:43 +08001272 result = acpi_device_register(device, parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 /*
Rui Zhang2786f6e2006-12-21 02:21:13 -05001275 * Bind _ADR-Based Devices when hot add
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 */
1277 if (device->flags.bus_address) {
1278 if (device->parent && device->parent->ops.bind)
1279 device->parent->ops.bind(device);
1280 }
1281
Len Brown4be44fc2005-08-05 00:44:28 -04001282 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 if (!result)
1284 *child = device;
1285 else {
Jesper Juhl6044ec82005-11-07 01:01:32 -08001286 kfree(device->pnp.cid_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 kfree(device);
1288 }
1289
Patrick Mocheld550d982006-06-27 00:41:40 -04001290 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
Len Brown4be44fc2005-08-05 00:44:28 -04001293static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294{
Len Brown4be44fc2005-08-05 00:44:28 -04001295 acpi_status status = AE_OK;
1296 struct acpi_device *parent = NULL;
1297 struct acpi_device *child = NULL;
1298 acpi_handle phandle = NULL;
1299 acpi_handle chandle = NULL;
1300 acpi_object_type type = 0;
1301 u32 level = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304 if (!start)
Patrick Mocheld550d982006-06-27 00:41:40 -04001305 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
1307 parent = start;
1308 phandle = start->handle;
Len Brown4be44fc2005-08-05 00:44:28 -04001309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 /*
1311 * Parse through the ACPI namespace, identify all 'devices', and
1312 * create a new 'struct acpi_device' for each.
1313 */
1314 while ((level > 0) && parent) {
1315
1316 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
Len Brown4be44fc2005-08-05 00:44:28 -04001317 chandle, &chandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319 /*
1320 * If this scope is exhausted then move our way back up.
1321 */
1322 if (ACPI_FAILURE(status)) {
1323 level--;
1324 chandle = phandle;
1325 acpi_get_parent(phandle, &phandle);
1326 if (parent->parent)
1327 parent = parent->parent;
1328 continue;
1329 }
1330
1331 status = acpi_get_type(chandle, &type);
1332 if (ACPI_FAILURE(status))
1333 continue;
1334
1335 /*
1336 * If this is a scope object then parse it (depth-first).
1337 */
1338 if (type == ACPI_TYPE_LOCAL_SCOPE) {
1339 level++;
1340 phandle = chandle;
1341 chandle = NULL;
1342 continue;
1343 }
1344
1345 /*
1346 * We're only interested in objects that we consider 'devices'.
1347 */
1348 switch (type) {
1349 case ACPI_TYPE_DEVICE:
1350 type = ACPI_BUS_TYPE_DEVICE;
1351 break;
1352 case ACPI_TYPE_PROCESSOR:
1353 type = ACPI_BUS_TYPE_PROCESSOR;
1354 break;
1355 case ACPI_TYPE_THERMAL:
1356 type = ACPI_BUS_TYPE_THERMAL;
1357 break;
1358 case ACPI_TYPE_POWER:
1359 type = ACPI_BUS_TYPE_POWER;
1360 break;
1361 default:
1362 continue;
1363 }
1364
Rajesh Shah3fb02732005-04-28 00:25:52 -07001365 if (ops->acpi_op_add)
1366 status = acpi_add_single_object(&child, parent,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001367 chandle, type, ops);
Len Brown4be44fc2005-08-05 00:44:28 -04001368 else
Rajesh Shah3fb02732005-04-28 00:25:52 -07001369 status = acpi_bus_get_device(chandle, &child);
1370
Len Brown4be44fc2005-08-05 00:44:28 -04001371 if (ACPI_FAILURE(status))
1372 continue;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001373
Li Shaohuac4168bf2006-12-07 20:56:41 +08001374 if (ops->acpi_op_start && !(ops->acpi_op_add)) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001375 status = acpi_start_single_object(child);
1376 if (ACPI_FAILURE(status))
1377 continue;
1378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
1380 /*
1381 * If the device is present, enabled, and functioning then
1382 * parse its scope (depth-first). Note that we need to
1383 * represent absent devices to facilitate PnP notifications
1384 * -- but only the subtree head (not all of its children,
1385 * which will be enumerated when the parent is inserted).
1386 *
1387 * TBD: Need notifications and other detection mechanisms
Len Brown4be44fc2005-08-05 00:44:28 -04001388 * in place before we can fully implement this.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 */
Zhao Yakui39a0ad82008-08-11 13:40:22 +08001390 /*
1391 * When the device is not present but functional, it is also
1392 * necessary to scan the children of this device.
1393 */
1394 if (child->status.present || (!child->status.present &&
1395 child->status.functional)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1397 NULL, NULL);
1398 if (ACPI_SUCCESS(status)) {
1399 level++;
1400 phandle = chandle;
1401 chandle = NULL;
1402 parent = child;
1403 }
1404 }
1405 }
1406
Patrick Mocheld550d982006-06-27 00:41:40 -04001407 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
Rajesh Shah3fb02732005-04-28 00:25:52 -07001410int
Len Brown4be44fc2005-08-05 00:44:28 -04001411acpi_bus_add(struct acpi_device **child,
1412 struct acpi_device *parent, acpi_handle handle, int type)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001413{
1414 int result;
1415 struct acpi_bus_ops ops;
1416
Li Shaohuac4168bf2006-12-07 20:56:41 +08001417 memset(&ops, 0, sizeof(ops));
1418 ops.acpi_op_add = 1;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001419
Li Shaohuac4168bf2006-12-07 20:56:41 +08001420 result = acpi_add_single_object(child, parent, handle, type, &ops);
1421 if (!result)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001422 result = acpi_bus_scan(*child, &ops);
Li Shaohuac4168bf2006-12-07 20:56:41 +08001423
Patrick Mocheld550d982006-06-27 00:41:40 -04001424 return result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001425}
Len Brown4be44fc2005-08-05 00:44:28 -04001426
Rajesh Shah3fb02732005-04-28 00:25:52 -07001427EXPORT_SYMBOL(acpi_bus_add);
1428
Len Brown4be44fc2005-08-05 00:44:28 -04001429int acpi_bus_start(struct acpi_device *device)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001430{
1431 int result;
1432 struct acpi_bus_ops ops;
1433
Rajesh Shah3fb02732005-04-28 00:25:52 -07001434
1435 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001436 return -EINVAL;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001437
1438 result = acpi_start_single_object(device);
1439 if (!result) {
1440 memset(&ops, 0, sizeof(ops));
1441 ops.acpi_op_start = 1;
1442 result = acpi_bus_scan(device, &ops);
1443 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001444 return result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001445}
Len Brown4be44fc2005-08-05 00:44:28 -04001446
Rajesh Shah3fb02732005-04-28 00:25:52 -07001447EXPORT_SYMBOL(acpi_bus_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
Kristen Accardiceaba662006-02-23 17:56:01 -08001449int acpi_bus_trim(struct acpi_device *start, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450{
Len Brown4be44fc2005-08-05 00:44:28 -04001451 acpi_status status;
1452 struct acpi_device *parent, *child;
1453 acpi_handle phandle, chandle;
1454 acpi_object_type type;
1455 u32 level = 1;
1456 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Len Brown4be44fc2005-08-05 00:44:28 -04001458 parent = start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 phandle = start->handle;
1460 child = chandle = NULL;
1461
1462 while ((level > 0) && parent && (!err)) {
1463 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
Len Brown4be44fc2005-08-05 00:44:28 -04001464 chandle, &chandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
1466 /*
1467 * If this scope is exhausted then move our way back up.
1468 */
1469 if (ACPI_FAILURE(status)) {
1470 level--;
1471 chandle = phandle;
1472 acpi_get_parent(phandle, &phandle);
1473 child = parent;
1474 parent = parent->parent;
1475
1476 if (level == 0)
1477 err = acpi_bus_remove(child, rmdevice);
1478 else
1479 err = acpi_bus_remove(child, 1);
1480
1481 continue;
1482 }
1483
1484 status = acpi_get_type(chandle, &type);
1485 if (ACPI_FAILURE(status)) {
1486 continue;
1487 }
1488 /*
1489 * If there is a device corresponding to chandle then
1490 * parse it (depth-first).
1491 */
1492 if (acpi_bus_get_device(chandle, &child) == 0) {
1493 level++;
1494 phandle = chandle;
1495 chandle = NULL;
1496 parent = child;
1497 }
1498 continue;
1499 }
1500 return err;
1501}
Kristen Accardiceaba662006-02-23 17:56:01 -08001502EXPORT_SYMBOL_GPL(acpi_bus_trim);
1503
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Len Brown4be44fc2005-08-05 00:44:28 -04001505static int acpi_bus_scan_fixed(struct acpi_device *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506{
Len Brown4be44fc2005-08-05 00:44:28 -04001507 int result = 0;
1508 struct acpi_device *device = NULL;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001509 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
1511 if (!root)
Patrick Mocheld550d982006-06-27 00:41:40 -04001512 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Li Shaohuac4168bf2006-12-07 20:56:41 +08001514 memset(&ops, 0, sizeof(ops));
1515 ops.acpi_op_add = 1;
1516 ops.acpi_op_start = 1;
1517
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 /*
1519 * Enumerate all fixed-feature devices.
1520 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001521 if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001522 result = acpi_add_single_object(&device, acpi_root,
Len Brown4be44fc2005-08-05 00:44:28 -04001523 NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001524 ACPI_BUS_TYPE_POWER_BUTTON,
1525 &ops);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001528 if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001529 result = acpi_add_single_object(&device, acpi_root,
Len Brown4be44fc2005-08-05 00:44:28 -04001530 NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001531 ACPI_BUS_TYPE_SLEEP_BUTTON,
1532 &ops);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001533 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
Patrick Mocheld550d982006-06-27 00:41:40 -04001535 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536}
1537
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001538
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539static int __init acpi_scan_init(void)
1540{
1541 int result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001542 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544
1545 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -04001546 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Li Shaohuac4168bf2006-12-07 20:56:41 +08001548 memset(&ops, 0, sizeof(ops));
1549 ops.acpi_op_add = 1;
1550 ops.acpi_op_start = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Patrick Mochel5b327262006-05-10 10:33:00 -04001552 result = bus_register(&acpi_bus_type);
1553 if (result) {
1554 /* We don't want to quit even if we failed to add suspend/resume */
1555 printk(KERN_ERR PREFIX "Could not register bus type\n");
1556 }
1557
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 /*
1559 * Create the root device in the bus's device tree
1560 */
Rajesh Shah3fb02732005-04-28 00:25:52 -07001561 result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001562 ACPI_BUS_TYPE_SYSTEM, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 if (result)
1564 goto Done;
1565
1566 /*
1567 * Enumerate devices in the ACPI namespace.
1568 */
1569 result = acpi_bus_scan_fixed(acpi_root);
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001570
Li Shaohuac4168bf2006-12-07 20:56:41 +08001571 if (!result)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001572 result = acpi_bus_scan(acpi_root, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
1574 if (result)
1575 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1576
Len Brown4be44fc2005-08-05 00:44:28 -04001577 Done:
Patrick Mocheld550d982006-06-27 00:41:40 -04001578 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579}
1580
1581subsys_initcall(acpi_scan_init);