blob: 39b7233c348592670ef86b1df5747f3d90151dc9 [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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-12-08 17:23:43 +080029struct acpi_device_bus_id{
Zhang Ruibb095852007-01-04 15:03:18 +080030 char bus_id[15];
Zhang Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-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 Ruie49bd2dd2006-12-08 17:23:43 +0800481 goto end;
482 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800483
Zhang Ruie49bd2dd2006-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 Ruie49bd2dd2006-12-08 17:23:43 +0800488
Li Shaohua96333572006-12-07 20:56:46 +0800489 device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
Zhang Ruie49bd2dd2006-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 Helgaas06ea8e082006-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
754 end:
755 if (ACPI_FAILURE(status))
756 device->flags.wake_capable = 0;
757 return 0;
758}
759
Zhang Rui9e89dde2006-12-07 20:56:16 +0800760static int acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
Zhang Rui9e89dde2006-12-07 20:56:16 +0800762 acpi_status status = 0;
763 acpi_handle handle = NULL;
764 u32 i = 0;
765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800768 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800770 status = acpi_get_handle(device->handle, "_PSC", &handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 if (ACPI_SUCCESS(status))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800772 device->power.flags.explicit_get = 1;
773 status = acpi_get_handle(device->handle, "_IRC", &handle);
774 if (ACPI_SUCCESS(status))
775 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800778 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800780 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
781 struct acpi_device_power_state *ps = &device->power.states[i];
782 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Zhang Rui9e89dde2006-12-07 20:56:16 +0800784 /* Evaluate "_PRx" to se if power resources are referenced */
785 acpi_evaluate_reference(device->handle, object_name, NULL,
786 &ps->resources);
787 if (ps->resources.count) {
788 device->power.flags.power_resources = 1;
789 ps->flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Zhang Rui9e89dde2006-12-07 20:56:16 +0800792 /* Evaluate "_PSx" to see if we can do explicit sets */
793 object_name[2] = 'S';
794 status = acpi_get_handle(device->handle, object_name, &handle);
795 if (ACPI_SUCCESS(status)) {
796 ps->flags.explicit_set = 1;
797 ps->flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 }
Zhang Rui9e89dde2006-12-07 20:56:16 +0800799
800 /* State is valid if we have some power control */
801 if (ps->resources.count || ps->flags.explicit_set)
802 ps->flags.valid = 1;
803
804 ps->power = -1; /* Unknown - driver assigned */
805 ps->latency = -1; /* Unknown - driver assigned */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Zhang Rui9e89dde2006-12-07 20:56:16 +0800808 /* Set defaults for D0 and D3 states (always valid) */
809 device->power.states[ACPI_STATE_D0].flags.valid = 1;
810 device->power.states[ACPI_STATE_D0].power = 100;
811 device->power.states[ACPI_STATE_D3].flags.valid = 1;
812 device->power.states[ACPI_STATE_D3].power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Zhang Rui9e89dde2006-12-07 20:56:16 +0800814 /* TBD: System wake support and resource requirements. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Zhang Rui9e89dde2006-12-07 20:56:16 +0800816 device->power.state = ACPI_STATE_UNKNOWN;
Zhao Yakuia51e1452008-08-11 14:55:05 +0800817 acpi_bus_get_power(device->handle, &(device->power.state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 return 0;
820}
821
Len Brown4be44fc2005-08-05 00:44:28 -0400822static int acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823{
Len Brown4be44fc2005-08-05 00:44:28 -0400824 acpi_status status = AE_OK;
825 acpi_handle temp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 /* Presence of _STA indicates 'dynamic_status' */
829 status = acpi_get_handle(device->handle, "_STA", &temp);
830 if (ACPI_SUCCESS(status))
831 device->flags.dynamic_status = 1;
832
833 /* Presence of _CID indicates 'compatible_ids' */
834 status = acpi_get_handle(device->handle, "_CID", &temp);
835 if (ACPI_SUCCESS(status))
836 device->flags.compatible_ids = 1;
837
838 /* Presence of _RMV indicates 'removable' */
839 status = acpi_get_handle(device->handle, "_RMV", &temp);
840 if (ACPI_SUCCESS(status))
841 device->flags.removable = 1;
842
843 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
844 status = acpi_get_handle(device->handle, "_EJD", &temp);
845 if (ACPI_SUCCESS(status))
846 device->flags.ejectable = 1;
847 else {
848 status = acpi_get_handle(device->handle, "_EJ0", &temp);
849 if (ACPI_SUCCESS(status))
850 device->flags.ejectable = 1;
851 }
852
853 /* Presence of _LCK indicates 'lockable' */
854 status = acpi_get_handle(device->handle, "_LCK", &temp);
855 if (ACPI_SUCCESS(status))
856 device->flags.lockable = 1;
857
858 /* Presence of _PS0|_PR0 indicates 'power manageable' */
859 status = acpi_get_handle(device->handle, "_PS0", &temp);
860 if (ACPI_FAILURE(status))
861 status = acpi_get_handle(device->handle, "_PR0", &temp);
862 if (ACPI_SUCCESS(status))
863 device->flags.power_manageable = 1;
864
865 /* Presence of _PRW indicates wake capable */
866 status = acpi_get_handle(device->handle, "_PRW", &temp);
867 if (ACPI_SUCCESS(status))
868 device->flags.wake_capable = 1;
869
Joe Perches3c5f9be42008-02-03 17:06:17 +0200870 /* TBD: Performance management */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Patrick Mocheld550d982006-06-27 00:41:40 -0400872 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873}
874
Len Brown4be44fc2005-08-05 00:44:28 -0400875static void acpi_device_get_busid(struct acpi_device *device,
876 acpi_handle handle, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
Len Brown4be44fc2005-08-05 00:44:28 -0400878 char bus_id[5] = { '?', 0 };
879 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
880 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 /*
883 * Bus ID
884 * ------
885 * The device's Bus ID is simply the object name.
886 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
887 */
888 switch (type) {
889 case ACPI_BUS_TYPE_SYSTEM:
890 strcpy(device->pnp.bus_id, "ACPI");
891 break;
892 case ACPI_BUS_TYPE_POWER_BUTTON:
893 strcpy(device->pnp.bus_id, "PWRF");
894 break;
895 case ACPI_BUS_TYPE_SLEEP_BUTTON:
896 strcpy(device->pnp.bus_id, "SLPF");
897 break;
898 default:
899 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
900 /* Clean up trailing underscores (if any) */
901 for (i = 3; i > 1; i--) {
902 if (bus_id[i] == '_')
903 bus_id[i] = '\0';
904 else
905 break;
906 }
907 strcpy(device->pnp.bus_id, bus_id);
908 break;
909 }
910}
911
Zhang Rui54735262007-01-11 02:09:09 -0500912/*
913 * acpi_bay_match - see if a device is an ejectable driver bay
914 *
915 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
916 * then we can safely call it an ejectable drive bay
917 */
918static int acpi_bay_match(struct acpi_device *device){
919 acpi_status status;
920 acpi_handle handle;
921 acpi_handle tmp;
922 acpi_handle phandle;
923
924 handle = device->handle;
925
926 status = acpi_get_handle(handle, "_EJ0", &tmp);
927 if (ACPI_FAILURE(status))
928 return -ENODEV;
929
930 if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
931 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
932 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
933 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
934 return 0;
935
936 if (acpi_get_parent(handle, &phandle))
937 return -ENODEV;
938
939 if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
940 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
941 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
942 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
943 return 0;
944
945 return -ENODEV;
946}
947
Frank Seidel3620f2f2007-12-07 13:20:34 +0100948/*
949 * acpi_dock_match - see if a device has a _DCK method
950 */
951static int acpi_dock_match(struct acpi_device *device)
952{
953 acpi_handle tmp;
954 return acpi_get_handle(device->handle, "_DCK", &tmp);
955}
956
Len Brown4be44fc2005-08-05 00:44:28 -0400957static void acpi_device_set_id(struct acpi_device *device,
958 struct acpi_device *parent, acpi_handle handle,
959 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
Len Brown4be44fc2005-08-05 00:44:28 -0400961 struct acpi_device_info *info;
962 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
963 char *hid = NULL;
964 char *uid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 struct acpi_compatible_id_list *cid_list = NULL;
Frank Seidel3620f2f2007-12-07 13:20:34 +0100966 const char *cid_add = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400967 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
969 switch (type) {
970 case ACPI_BUS_TYPE_DEVICE:
971 status = acpi_get_object_info(handle, &buffer);
972 if (ACPI_FAILURE(status)) {
Harvey Harrison96b2dd12008-03-05 18:24:51 -0800973 printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 return;
975 }
976
977 info = buffer.pointer;
978 if (info->valid & ACPI_VALID_HID)
979 hid = info->hardware_id.value;
980 if (info->valid & ACPI_VALID_UID)
981 uid = info->unique_id.value;
982 if (info->valid & ACPI_VALID_CID)
983 cid_list = &info->compatibility_id;
984 if (info->valid & ACPI_VALID_ADR) {
985 device->pnp.bus_address = info->address;
986 device->flags.bus_address = 1;
987 }
Zhang Ruiae843332006-12-07 20:57:10 +0800988
Frank Seidel3620f2f2007-12-07 13:20:34 +0100989 /* If we have a video/bay/dock device, add our selfdefined
990 HID to the CID list. Like that the video/bay/dock drivers
991 will get autoloaded and the device might still match
992 against another driver.
993 */
Thomas Renningerc3d6de62008-08-01 17:37:55 +0200994 if (acpi_is_video_device(device))
Frank Seidel3620f2f2007-12-07 13:20:34 +0100995 cid_add = ACPI_VIDEO_HID;
996 else if (ACPI_SUCCESS(acpi_bay_match(device)))
997 cid_add = ACPI_BAY_HID;
998 else if (ACPI_SUCCESS(acpi_dock_match(device)))
999 cid_add = ACPI_DOCK_HID;
Zhang Rui54735262007-01-11 02:09:09 -05001000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 break;
1002 case ACPI_BUS_TYPE_POWER:
1003 hid = ACPI_POWER_HID;
1004 break;
1005 case ACPI_BUS_TYPE_PROCESSOR:
Myron Stowead93a762008-11-04 14:52:55 -07001006 hid = ACPI_PROCESSOR_OBJECT_HID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 break;
1008 case ACPI_BUS_TYPE_SYSTEM:
1009 hid = ACPI_SYSTEM_HID;
1010 break;
1011 case ACPI_BUS_TYPE_THERMAL:
1012 hid = ACPI_THERMAL_HID;
1013 break;
1014 case ACPI_BUS_TYPE_POWER_BUTTON:
1015 hid = ACPI_BUTTON_HID_POWERF;
1016 break;
1017 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1018 hid = ACPI_BUTTON_HID_SLEEPF;
1019 break;
1020 }
1021
1022 /*
1023 * \_SB
1024 * ----
1025 * Fix for the system root bus device -- the only root-level device.
1026 */
Bob Moorec51a4de2005-11-17 13:07:00 -05001027 if (((acpi_handle)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 hid = ACPI_BUS_HID;
1029 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1030 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1031 }
1032
1033 if (hid) {
1034 strcpy(device->pnp.hardware_id, hid);
1035 device->flags.hardware_id = 1;
1036 }
1037 if (uid) {
1038 strcpy(device->pnp.unique_id, uid);
1039 device->flags.unique_id = 1;
1040 }
Frank Seidel3620f2f2007-12-07 13:20:34 +01001041 if (cid_list || cid_add) {
1042 struct acpi_compatible_id_list *list;
1043 int size = 0;
1044 int count = 0;
1045
1046 if (cid_list) {
1047 size = cid_list->size;
1048 } else if (cid_add) {
1049 size = sizeof(struct acpi_compatible_id_list);
1050 cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
1051 if (!cid_list) {
1052 printk(KERN_ERR "Memory allocation error\n");
1053 kfree(buffer.pointer);
1054 return;
1055 } else {
1056 cid_list->count = 0;
1057 cid_list->size = size;
1058 }
1059 }
1060 if (cid_add)
1061 size += sizeof(struct acpi_compatible_id);
1062 list = kmalloc(size, GFP_KERNEL);
1063
1064 if (list) {
1065 if (cid_list) {
1066 memcpy(list, cid_list, cid_list->size);
1067 count = cid_list->count;
1068 }
1069 if (cid_add) {
1070 strncpy(list->id[count].value, cid_add,
1071 ACPI_MAX_CID_LENGTH);
1072 count++;
1073 device->flags.compatible_ids = 1;
1074 }
1075 list->size = size;
1076 list->count = count;
1077 device->pnp.cid_list = list;
1078 } else
Len Brown87ecd5c2008-01-01 14:00:00 -05001079 printk(KERN_ERR PREFIX "Memory allocation error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 }
1081
Len Brown02438d82006-06-30 03:19:10 -04001082 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083}
1084
Len Brown4be44fc2005-08-05 00:44:28 -04001085static int acpi_device_set_context(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086{
1087 acpi_status status = AE_OK;
1088 int result = 0;
1089 /*
1090 * Context
1091 * -------
1092 * Attach this 'struct acpi_device' to the ACPI object. This makes
1093 * resolutions from handle->device very efficient. Note that we need
1094 * to be careful with fixed-feature devices as they all attach to the
1095 * root object.
1096 */
Len Brown4be44fc2005-08-05 00:44:28 -04001097 if (type != ACPI_BUS_TYPE_POWER_BUTTON &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 type != ACPI_BUS_TYPE_SLEEP_BUTTON) {
1099 status = acpi_attach_data(device->handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001100 acpi_bus_data_handler, device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
1102 if (ACPI_FAILURE(status)) {
Len Brown87ecd5c2008-01-01 14:00:00 -05001103 printk(KERN_ERR PREFIX "Error attaching device data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 result = -ENODEV;
1105 }
1106 }
1107 return result;
1108}
1109
Len Brown4be44fc2005-08-05 00:44:28 -04001110static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 if (!dev)
Patrick Mocheld550d982006-06-27 00:41:40 -04001113 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Li Shaohua96333572006-12-07 20:56:46 +08001115 dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
Patrick Mochel1890a972006-12-07 20:56:31 +08001116 device_release_driver(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
1118 if (!rmdevice)
Patrick Mocheld550d982006-06-27 00:41:40 -04001119 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Rui Zhang2786f6e2006-12-21 02:21:13 -05001121 /*
1122 * unbind _ADR-Based Devices when hot removal
1123 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 if (dev->flags.bus_address) {
1125 if ((dev->parent) && (dev->parent->ops.unbind))
1126 dev->parent->ops.unbind(dev);
1127 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1129
Patrick Mocheld550d982006-06-27 00:41:40 -04001130 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131}
1132
Rajesh Shah3fb02732005-04-28 00:25:52 -07001133static int
Len Brown4be44fc2005-08-05 00:44:28 -04001134acpi_add_single_object(struct acpi_device **child,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001135 struct acpi_device *parent, acpi_handle handle, int type,
1136 struct acpi_bus_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
Len Brown4be44fc2005-08-05 00:44:28 -04001138 int result = 0;
1139 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 if (!child)
Patrick Mocheld550d982006-06-27 00:41:40 -04001143 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Burman Yan36bcbec2006-12-19 12:56:11 -08001145 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001147 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001148 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 device->handle = handle;
1152 device->parent = parent;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001153 device->bus_ops = *ops; /* workround for not call .start */
1154
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Len Brown4be44fc2005-08-05 00:44:28 -04001156 acpi_device_get_busid(device, handle, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 /*
1159 * Flags
1160 * -----
1161 * Get prior to calling acpi_bus_get_status() so we know whether
1162 * or not _STA is present. Note that we only look for object
1163 * handles -- cannot evaluate objects until we know the device is
1164 * present and properly initialized.
1165 */
1166 result = acpi_bus_get_flags(device);
1167 if (result)
1168 goto end;
1169
1170 /*
1171 * Status
1172 * ------
Keiichiro Tokunaga6940fab2005-03-30 23:15:47 -05001173 * See if the device is present. We always assume that non-Device
1174 * and non-Processor objects (e.g. thermal zones, power resources,
1175 * etc.) are present, functioning, etc. (at least when parent object
1176 * is present). Note that _STA has a different meaning for some
1177 * objects (e.g. power resources) so we need to be careful how we use
1178 * it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 */
1180 switch (type) {
Keiichiro Tokunaga6940fab2005-03-30 23:15:47 -05001181 case ACPI_BUS_TYPE_PROCESSOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 case ACPI_BUS_TYPE_DEVICE:
1183 result = acpi_bus_get_status(device);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001184 if (ACPI_FAILURE(result)) {
1185 result = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 goto end;
1187 }
Zhao Yakui39a0ad82008-08-11 13:40:22 +08001188 /*
1189 * When the device is neither present nor functional, the
1190 * device should not be added to Linux ACPI device tree.
1191 * When the status of the device is not present but functinal,
1192 * it should be added to Linux ACPI tree. For example : bay
1193 * device , dock device.
1194 * In such conditions it is unncessary to check whether it is
1195 * bay device or dock device.
1196 */
1197 if (!device->status.present && !device->status.functional) {
1198 result = -ENODEV;
1199 goto end;
Frank Seidel3620f2f2007-12-07 13:20:34 +01001200 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 break;
1202 default:
Bjorn Helgaas0c0e8922007-04-25 14:20:58 -04001203 STRUCT_TO_INT(device->status) =
1204 ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
1205 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 break;
1207 }
1208
1209 /*
1210 * Initialize Device
1211 * -----------------
1212 * TBD: Synch with Core's enumeration/initialization process.
1213 */
1214
1215 /*
1216 * Hardware ID, Unique ID, & Bus Address
1217 * -------------------------------------
1218 */
Len Brown4be44fc2005-08-05 00:44:28 -04001219 acpi_device_set_id(device, parent, handle, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
1221 /*
Zhao Yakuieab4b642008-08-11 14:54:16 +08001222 * The ACPI device is attached to acpi handle before getting
1223 * the power/wakeup/peformance flags. Otherwise OS can't get
1224 * the corresponding ACPI device by the acpi handle in the course
1225 * of getting the power/wakeup/performance flags.
1226 */
1227 result = acpi_device_set_context(device, type);
1228 if (result)
1229 goto end;
1230
1231 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 * Power Management
1233 * ----------------
1234 */
1235 if (device->flags.power_manageable) {
1236 result = acpi_bus_get_power_flags(device);
1237 if (result)
1238 goto end;
1239 }
1240
Len Brown4be44fc2005-08-05 00:44:28 -04001241 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 * Wakeup device management
1243 *-----------------------
1244 */
1245 if (device->flags.wake_capable) {
1246 result = acpi_bus_get_wakeup_device_flags(device);
1247 if (result)
1248 goto end;
1249 }
1250
1251 /*
1252 * Performance Management
1253 * ----------------------
1254 */
1255 if (device->flags.performance_manageable) {
1256 result = acpi_bus_get_perf_flags(device);
1257 if (result)
1258 goto end;
1259 }
1260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
Zhang Ruie49bd2dd2006-12-08 17:23:43 +08001262 result = acpi_device_register(device, parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264 /*
Rui Zhang2786f6e2006-12-21 02:21:13 -05001265 * Bind _ADR-Based Devices when hot add
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 */
1267 if (device->flags.bus_address) {
1268 if (device->parent && device->parent->ops.bind)
1269 device->parent->ops.bind(device);
1270 }
1271
Len Brown4be44fc2005-08-05 00:44:28 -04001272 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if (!result)
1274 *child = device;
1275 else {
Jesper Juhl6044ec82005-11-07 01:01:32 -08001276 kfree(device->pnp.cid_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 kfree(device);
1278 }
1279
Patrick Mocheld550d982006-06-27 00:41:40 -04001280 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
Len Brown4be44fc2005-08-05 00:44:28 -04001283static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284{
Len Brown4be44fc2005-08-05 00:44:28 -04001285 acpi_status status = AE_OK;
1286 struct acpi_device *parent = NULL;
1287 struct acpi_device *child = NULL;
1288 acpi_handle phandle = NULL;
1289 acpi_handle chandle = NULL;
1290 acpi_object_type type = 0;
1291 u32 level = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293
1294 if (!start)
Patrick Mocheld550d982006-06-27 00:41:40 -04001295 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297 parent = start;
1298 phandle = start->handle;
Len Brown4be44fc2005-08-05 00:44:28 -04001299
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 /*
1301 * Parse through the ACPI namespace, identify all 'devices', and
1302 * create a new 'struct acpi_device' for each.
1303 */
1304 while ((level > 0) && parent) {
1305
1306 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
Len Brown4be44fc2005-08-05 00:44:28 -04001307 chandle, &chandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 /*
1310 * If this scope is exhausted then move our way back up.
1311 */
1312 if (ACPI_FAILURE(status)) {
1313 level--;
1314 chandle = phandle;
1315 acpi_get_parent(phandle, &phandle);
1316 if (parent->parent)
1317 parent = parent->parent;
1318 continue;
1319 }
1320
1321 status = acpi_get_type(chandle, &type);
1322 if (ACPI_FAILURE(status))
1323 continue;
1324
1325 /*
1326 * If this is a scope object then parse it (depth-first).
1327 */
1328 if (type == ACPI_TYPE_LOCAL_SCOPE) {
1329 level++;
1330 phandle = chandle;
1331 chandle = NULL;
1332 continue;
1333 }
1334
1335 /*
1336 * We're only interested in objects that we consider 'devices'.
1337 */
1338 switch (type) {
1339 case ACPI_TYPE_DEVICE:
1340 type = ACPI_BUS_TYPE_DEVICE;
1341 break;
1342 case ACPI_TYPE_PROCESSOR:
1343 type = ACPI_BUS_TYPE_PROCESSOR;
1344 break;
1345 case ACPI_TYPE_THERMAL:
1346 type = ACPI_BUS_TYPE_THERMAL;
1347 break;
1348 case ACPI_TYPE_POWER:
1349 type = ACPI_BUS_TYPE_POWER;
1350 break;
1351 default:
1352 continue;
1353 }
1354
Rajesh Shah3fb02732005-04-28 00:25:52 -07001355 if (ops->acpi_op_add)
1356 status = acpi_add_single_object(&child, parent,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001357 chandle, type, ops);
Len Brown4be44fc2005-08-05 00:44:28 -04001358 else
Rajesh Shah3fb02732005-04-28 00:25:52 -07001359 status = acpi_bus_get_device(chandle, &child);
1360
Len Brown4be44fc2005-08-05 00:44:28 -04001361 if (ACPI_FAILURE(status))
1362 continue;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001363
Li Shaohuac4168bf2006-12-07 20:56:41 +08001364 if (ops->acpi_op_start && !(ops->acpi_op_add)) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001365 status = acpi_start_single_object(child);
1366 if (ACPI_FAILURE(status))
1367 continue;
1368 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 /*
1371 * If the device is present, enabled, and functioning then
1372 * parse its scope (depth-first). Note that we need to
1373 * represent absent devices to facilitate PnP notifications
1374 * -- but only the subtree head (not all of its children,
1375 * which will be enumerated when the parent is inserted).
1376 *
1377 * TBD: Need notifications and other detection mechanisms
Len Brown4be44fc2005-08-05 00:44:28 -04001378 * in place before we can fully implement this.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 */
Zhao Yakui39a0ad82008-08-11 13:40:22 +08001380 /*
1381 * When the device is not present but functional, it is also
1382 * necessary to scan the children of this device.
1383 */
1384 if (child->status.present || (!child->status.present &&
1385 child->status.functional)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1387 NULL, NULL);
1388 if (ACPI_SUCCESS(status)) {
1389 level++;
1390 phandle = chandle;
1391 chandle = NULL;
1392 parent = child;
1393 }
1394 }
1395 }
1396
Patrick Mocheld550d982006-06-27 00:41:40 -04001397 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Rajesh Shah3fb02732005-04-28 00:25:52 -07001400int
Len Brown4be44fc2005-08-05 00:44:28 -04001401acpi_bus_add(struct acpi_device **child,
1402 struct acpi_device *parent, acpi_handle handle, int type)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001403{
1404 int result;
1405 struct acpi_bus_ops ops;
1406
Li Shaohuac4168bf2006-12-07 20:56:41 +08001407 memset(&ops, 0, sizeof(ops));
1408 ops.acpi_op_add = 1;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001409
Li Shaohuac4168bf2006-12-07 20:56:41 +08001410 result = acpi_add_single_object(child, parent, handle, type, &ops);
1411 if (!result)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001412 result = acpi_bus_scan(*child, &ops);
Li Shaohuac4168bf2006-12-07 20:56:41 +08001413
Patrick Mocheld550d982006-06-27 00:41:40 -04001414 return result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001415}
Len Brown4be44fc2005-08-05 00:44:28 -04001416
Rajesh Shah3fb02732005-04-28 00:25:52 -07001417EXPORT_SYMBOL(acpi_bus_add);
1418
Len Brown4be44fc2005-08-05 00:44:28 -04001419int acpi_bus_start(struct acpi_device *device)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001420{
1421 int result;
1422 struct acpi_bus_ops ops;
1423
Rajesh Shah3fb02732005-04-28 00:25:52 -07001424
1425 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001426 return -EINVAL;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001427
1428 result = acpi_start_single_object(device);
1429 if (!result) {
1430 memset(&ops, 0, sizeof(ops));
1431 ops.acpi_op_start = 1;
1432 result = acpi_bus_scan(device, &ops);
1433 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001434 return result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001435}
Len Brown4be44fc2005-08-05 00:44:28 -04001436
Rajesh Shah3fb02732005-04-28 00:25:52 -07001437EXPORT_SYMBOL(acpi_bus_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
Kristen Accardiceaba662006-02-23 17:56:01 -08001439int acpi_bus_trim(struct acpi_device *start, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440{
Len Brown4be44fc2005-08-05 00:44:28 -04001441 acpi_status status;
1442 struct acpi_device *parent, *child;
1443 acpi_handle phandle, chandle;
1444 acpi_object_type type;
1445 u32 level = 1;
1446 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Len Brown4be44fc2005-08-05 00:44:28 -04001448 parent = start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 phandle = start->handle;
1450 child = chandle = NULL;
1451
1452 while ((level > 0) && parent && (!err)) {
1453 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
Len Brown4be44fc2005-08-05 00:44:28 -04001454 chandle, &chandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
1456 /*
1457 * If this scope is exhausted then move our way back up.
1458 */
1459 if (ACPI_FAILURE(status)) {
1460 level--;
1461 chandle = phandle;
1462 acpi_get_parent(phandle, &phandle);
1463 child = parent;
1464 parent = parent->parent;
1465
1466 if (level == 0)
1467 err = acpi_bus_remove(child, rmdevice);
1468 else
1469 err = acpi_bus_remove(child, 1);
1470
1471 continue;
1472 }
1473
1474 status = acpi_get_type(chandle, &type);
1475 if (ACPI_FAILURE(status)) {
1476 continue;
1477 }
1478 /*
1479 * If there is a device corresponding to chandle then
1480 * parse it (depth-first).
1481 */
1482 if (acpi_bus_get_device(chandle, &child) == 0) {
1483 level++;
1484 phandle = chandle;
1485 chandle = NULL;
1486 parent = child;
1487 }
1488 continue;
1489 }
1490 return err;
1491}
Kristen Accardiceaba662006-02-23 17:56:01 -08001492EXPORT_SYMBOL_GPL(acpi_bus_trim);
1493
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Len Brown4be44fc2005-08-05 00:44:28 -04001495static int acpi_bus_scan_fixed(struct acpi_device *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496{
Len Brown4be44fc2005-08-05 00:44:28 -04001497 int result = 0;
1498 struct acpi_device *device = NULL;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001499 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
1501 if (!root)
Patrick Mocheld550d982006-06-27 00:41:40 -04001502 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
Li Shaohuac4168bf2006-12-07 20:56:41 +08001504 memset(&ops, 0, sizeof(ops));
1505 ops.acpi_op_add = 1;
1506 ops.acpi_op_start = 1;
1507
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 /*
1509 * Enumerate all fixed-feature devices.
1510 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001511 if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001512 result = acpi_add_single_object(&device, acpi_root,
Len Brown4be44fc2005-08-05 00:44:28 -04001513 NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001514 ACPI_BUS_TYPE_POWER_BUTTON,
1515 &ops);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001516 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001518 if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
Rajesh Shah3fb02732005-04-28 00:25:52 -07001519 result = acpi_add_single_object(&device, acpi_root,
Len Brown4be44fc2005-08-05 00:44:28 -04001520 NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001521 ACPI_BUS_TYPE_SLEEP_BUTTON,
1522 &ops);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001523 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Patrick Mocheld550d982006-06-27 00:41:40 -04001525 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
1527
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529static int __init acpi_scan_init(void)
1530{
1531 int result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001532 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
1535 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -04001536 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Li Shaohuac4168bf2006-12-07 20:56:41 +08001538 memset(&ops, 0, sizeof(ops));
1539 ops.acpi_op_add = 1;
1540 ops.acpi_op_start = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
Patrick Mochel5b327262006-05-10 10:33:00 -04001542 result = bus_register(&acpi_bus_type);
1543 if (result) {
1544 /* We don't want to quit even if we failed to add suspend/resume */
1545 printk(KERN_ERR PREFIX "Could not register bus type\n");
1546 }
1547
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 /*
1549 * Create the root device in the bus's device tree
1550 */
Rajesh Shah3fb02732005-04-28 00:25:52 -07001551 result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001552 ACPI_BUS_TYPE_SYSTEM, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 if (result)
1554 goto Done;
1555
1556 /*
1557 * Enumerate devices in the ACPI namespace.
1558 */
1559 result = acpi_bus_scan_fixed(acpi_root);
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001560
Li Shaohuac4168bf2006-12-07 20:56:41 +08001561 if (!result)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001562 result = acpi_bus_scan(acpi_root, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563
1564 if (result)
1565 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1566
Len Brown4be44fc2005-08-05 00:44:28 -04001567 Done:
Patrick Mocheld550d982006-06-27 00:41:40 -04001568 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569}
1570
1571subsys_initcall(acpi_scan_init);