blob: d730a939ead165846c252ea7ed6fea82463677c5 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09007#include <linux/slab.h>
Randy Dunlap9b6d97b2006-07-12 02:08:00 -04008#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/acpi.h>
Alok N Kataria74523c92008-06-13 12:54:24 -040010#include <linux/signal.h>
11#include <linux/kthread.h>
Darrick J. Wong222e82a2010-03-24 14:38:37 +010012#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
14#include <acpi/acpi_drivers.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Bjorn Helgaase60cc7a2009-03-13 12:08:26 -060016#include "internal.h"
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050019ACPI_MODULE_NAME("scan");
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define STRUCT_TO_INT(s) (*((int*)&s))
Len Brown4be44fc2005-08-05 00:44:28 -040021extern struct acpi_device *acpi_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#define ACPI_BUS_CLASS "system_bus"
Thomas Renninger29b71a12007-07-23 14:43:51 +020024#define ACPI_BUS_HID "LNXSYBUS"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#define ACPI_BUS_DEVICE_NAME "System Bus"
26
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +000027#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
28
Thomas Renninger620e1122010-10-01 10:54:00 +020029static const char *dummy_hid = "device";
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +020030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031static LIST_HEAD(acpi_device_list);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080032static LIST_HEAD(acpi_bus_id_list);
Shaohua Li90905892009-04-07 10:24:29 +080033DEFINE_MUTEX(acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034LIST_HEAD(acpi_wakeup_device_list);
35
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080036struct acpi_device_bus_id{
Zhang Ruibb095852007-01-04 15:03:18 +080037 char bus_id[15];
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080038 unsigned int instance_no;
39 struct list_head node;
40};
Thomas Renninger29b71a12007-07-23 14:43:51 +020041
42/*
43 * Creates hid/cid(s) string needed for modalias and uevent
44 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
45 * char *modalias: "acpi:IBM0001:ACPI0001"
46*/
Adrian Bunkb3e572d2007-08-14 23:22:35 +020047static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
48 int size)
49{
Thomas Renninger29b71a12007-07-23 14:43:51 +020050 int len;
Zhang Rui5c9fcb52008-03-20 16:40:32 +080051 int count;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -060052 struct acpi_hardware_id *id;
Thomas Renninger29b71a12007-07-23 14:43:51 +020053
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +020054 if (list_empty(&acpi_dev->pnp.ids))
55 return 0;
56
Zhang Rui5c9fcb52008-03-20 16:40:32 +080057 len = snprintf(modalias, size, "acpi:");
Thomas Renninger29b71a12007-07-23 14:43:51 +020058 size -= len;
59
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -060060 list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
61 count = snprintf(&modalias[len], size, "%s:", id->id);
Zhang Rui5c9fcb52008-03-20 16:40:32 +080062 if (count < 0 || count >= size)
63 return -EINVAL;
64 len += count;
65 size -= count;
66 }
67
Thomas Renninger29b71a12007-07-23 14:43:51 +020068 modalias[len] = '\0';
69 return len;
70}
71
72static ssize_t
73acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
74 struct acpi_device *acpi_dev = to_acpi_device(dev);
75 int len;
76
77 /* Device has no HID and no CID or string is >1024 */
78 len = create_modalias(acpi_dev, buf, 1024);
79 if (len <= 0)
80 return 0;
81 buf[len++] = '\n';
82 return len;
83}
84static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
85
Toshi Kanic4753e52012-05-23 20:25:20 -060086/**
87 * acpi_bus_hot_remove_device: hot-remove a device and its children
88 * @context: struct acpi_eject_event pointer (freed in this func)
89 *
90 * Hot-remove a device and its children. This function frees up the
91 * memory space passed by arg context, so that the caller may call
92 * this function asynchronously through acpi_os_hotplug_execute().
93 */
94void acpi_bus_hot_remove_device(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Toshi Kanic4753e52012-05-23 20:25:20 -060096 struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
Zhang Rui26d46862008-04-29 02:35:48 -040097 struct acpi_device *device;
Toshi Kanic4753e52012-05-23 20:25:20 -060098 acpi_handle handle = ej_event->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 struct acpi_object_list arg_list;
100 union acpi_object arg;
101 acpi_status status = AE_OK;
Toshi Kanic4753e52012-05-23 20:25:20 -0600102 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Zhang Rui26d46862008-04-29 02:35:48 -0400104 if (acpi_bus_get_device(handle, &device))
Toshi Kanic4753e52012-05-23 20:25:20 -0600105 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Zhang Rui26d46862008-04-29 02:35:48 -0400107 if (!device)
Toshi Kanic4753e52012-05-23 20:25:20 -0600108 goto err_out;
Zhang Rui26d46862008-04-29 02:35:48 -0400109
110 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Kay Sievers07944692008-10-30 01:18:59 +0100111 "Hot-removing device %s...\n", dev_name(&device->dev)));
Zhang Rui26d46862008-04-29 02:35:48 -0400112
113 if (acpi_bus_trim(device, 1)) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800114 printk(KERN_ERR PREFIX
115 "Removing device failed\n");
Toshi Kanic4753e52012-05-23 20:25:20 -0600116 goto err_out;
Zhang Rui26d46862008-04-29 02:35:48 -0400117 }
118
119 /* power off device */
120 status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
121 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
Lin Ming55ac9a02008-09-28 14:51:56 +0800122 printk(KERN_WARNING PREFIX
123 "Power-off device failed\n");
Zhang Rui26d46862008-04-29 02:35:48 -0400124
125 if (device->flags.lockable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 arg_list.count = 1;
127 arg_list.pointer = &arg;
128 arg.type = ACPI_TYPE_INTEGER;
129 arg.integer.value = 0;
130 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
131 }
132
133 arg_list.count = 1;
134 arg_list.pointer = &arg;
135 arg.type = ACPI_TYPE_INTEGER;
136 arg.integer.value = 1;
137
138 /*
139 * TBD: _EJD support.
140 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
Toshi Kanic4753e52012-05-23 20:25:20 -0600142 if (ACPI_FAILURE(status)) {
143 if (status != AE_NOT_FOUND)
144 printk(KERN_WARNING PREFIX
145 "Eject device failed\n");
146 goto err_out;
147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Toshi Kanic4753e52012-05-23 20:25:20 -0600149 kfree(context);
150 return;
151
152err_out:
153 /* Inform firmware the hot-remove operation has completed w/ error */
154 (void) acpi_evaluate_hotplug_ost(handle,
155 ej_event->event, ost_code, NULL);
156 kfree(context);
Zhang Ruic8d72a52009-06-22 11:31:16 +0800157 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158}
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160static ssize_t
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800161acpi_eject_store(struct device *d, struct device_attribute *attr,
162 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163{
Len Brown4be44fc2005-08-05 00:44:28 -0400164 int ret = count;
Len Brown4be44fc2005-08-05 00:44:28 -0400165 acpi_status status;
Len Brown4be44fc2005-08-05 00:44:28 -0400166 acpi_object_type type = 0;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800167 struct acpi_device *acpi_device = to_acpi_device(d);
Toshi Kanic4753e52012-05-23 20:25:20 -0600168 struct acpi_eject_event *ej_event;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 if ((!count) || (buf[0] != '1')) {
171 return -EINVAL;
172 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173#ifndef FORCE_EJECT
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800174 if (acpi_device->driver == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 ret = -ENODEV;
176 goto err;
177 }
178#endif
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800179 status = acpi_get_type(acpi_device->handle, &type);
180 if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 ret = -ENODEV;
182 goto err;
183 }
184
Toshi Kanic4753e52012-05-23 20:25:20 -0600185 ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
186 if (!ej_event) {
187 ret = -ENOMEM;
188 goto err;
189 }
190
191 ej_event->handle = acpi_device->handle;
192 if (acpi_device->flags.eject_pending) {
193 /* event originated from ACPI eject notification */
194 ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
195 acpi_device->flags.eject_pending = 0;
196 } else {
197 /* event originated from user */
198 ej_event->event = ACPI_OST_EC_OSPM_EJECT;
199 (void) acpi_evaluate_hotplug_ost(ej_event->handle,
200 ej_event->event, ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
201 }
202
203 acpi_os_hotplug_execute(acpi_bus_hot_remove_device, (void *)ej_event);
Alok N Kataria74523c92008-06-13 12:54:24 -0400204err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800208static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800210static ssize_t
211acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
212 struct acpi_device *acpi_dev = to_acpi_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Bjorn Helgaasea8d82f2009-09-21 13:35:09 -0600214 return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800215}
216static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
217
218static ssize_t
219acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
220 struct acpi_device *acpi_dev = to_acpi_device(dev);
221 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
222 int result;
223
224 result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
Alex Chiang0c526d92009-05-14 08:31:37 -0600225 if (result)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800226 goto end;
227
228 result = sprintf(buf, "%s\n", (char*)path.pointer);
229 kfree(path.pointer);
Alex Chiang0c526d92009-05-14 08:31:37 -0600230end:
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800231 return result;
232}
233static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
234
235static int acpi_device_setup_files(struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800237 acpi_status status;
238 acpi_handle temp;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800239 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800241 /*
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800242 * Devices gotten from FADT don't have a "path" attribute
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800243 */
Alex Chiang0c526d92009-05-14 08:31:37 -0600244 if (dev->handle) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800245 result = device_create_file(&dev->dev, &dev_attr_path);
Alex Chiang0c526d92009-05-14 08:31:37 -0600246 if (result)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800247 goto end;
248 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200250 if (!list_empty(&dev->pnp.ids)) {
251 result = device_create_file(&dev->dev, &dev_attr_hid);
252 if (result)
253 goto end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200255 result = device_create_file(&dev->dev, &dev_attr_modalias);
256 if (result)
257 goto end;
258 }
Thomas Renninger29b71a12007-07-23 14:43:51 +0200259
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800260 /*
261 * If device has _EJ0, 'eject' file is created that is used to trigger
262 * hot-removal function from userland.
263 */
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800264 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
265 if (ACPI_SUCCESS(status))
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800266 result = device_create_file(&dev->dev, &dev_attr_eject);
Alex Chiang0c526d92009-05-14 08:31:37 -0600267end:
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800268 return result;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800269}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800271static void acpi_device_remove_files(struct acpi_device *dev)
272{
273 acpi_status status;
274 acpi_handle temp;
275
276 /*
277 * If device has _EJ0, 'eject' file is created that is used to trigger
278 * hot-removal function from userland.
279 */
280 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
281 if (ACPI_SUCCESS(status))
282 device_remove_file(&dev->dev, &dev_attr_eject);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800283
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600284 device_remove_file(&dev->dev, &dev_attr_modalias);
285 device_remove_file(&dev->dev, &dev_attr_hid);
Alex Chiang0c526d92009-05-14 08:31:37 -0600286 if (dev->handle)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800287 device_remove_file(&dev->dev, &dev_attr_path);
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800288}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289/* --------------------------------------------------------------------------
Zhang Rui9e89dde2006-12-07 20:56:16 +0800290 ACPI Bus operations
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 -------------------------------------------------------------------------- */
Thomas Renninger29b71a12007-07-23 14:43:51 +0200292
293int acpi_match_device_ids(struct acpi_device *device,
294 const struct acpi_device_id *ids)
295{
296 const struct acpi_device_id *id;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600297 struct acpi_hardware_id *hwid;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200298
Zhao Yakui39a0ad82008-08-11 13:40:22 +0800299 /*
300 * If the device is not present, it is unnecessary to load device
301 * driver for it.
302 */
303 if (!device->status.present)
304 return -ENODEV;
305
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600306 for (id = ids; id->id[0]; id++)
307 list_for_each_entry(hwid, &device->pnp.ids, list)
308 if (!strcmp((char *) id->id, hwid->id))
Thomas Renninger29b71a12007-07-23 14:43:51 +0200309 return 0;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200310
311 return -ENOENT;
312}
313EXPORT_SYMBOL(acpi_match_device_ids);
314
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600315static void acpi_free_ids(struct acpi_device *device)
316{
317 struct acpi_hardware_id *id, *tmp;
318
319 list_for_each_entry_safe(id, tmp, &device->pnp.ids, list) {
320 kfree(id->id);
321 kfree(id);
322 }
323}
324
Patrick Mochel1890a972006-12-07 20:56:31 +0800325static void acpi_device_release(struct device *dev)
326{
327 struct acpi_device *acpi_dev = to_acpi_device(dev);
328
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600329 acpi_free_ids(acpi_dev);
Patrick Mochel1890a972006-12-07 20:56:31 +0800330 kfree(acpi_dev);
331}
332
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800333static int acpi_bus_match(struct device *dev, struct device_driver *drv)
334{
335 struct acpi_device *acpi_dev = to_acpi_device(dev);
336 struct acpi_driver *acpi_drv = to_acpi_driver(drv);
337
Thomas Renninger29b71a12007-07-23 14:43:51 +0200338 return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800339}
340
Kay Sievers7eff2e72007-08-14 15:15:12 +0200341static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800342{
343 struct acpi_device *acpi_dev = to_acpi_device(dev);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200344 int len;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800345
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200346 if (list_empty(&acpi_dev->pnp.ids))
347 return 0;
348
Kay Sievers7eff2e72007-08-14 15:15:12 +0200349 if (add_uevent_var(env, "MODALIAS="))
350 return -ENOMEM;
351 len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
352 sizeof(env->buf) - env->buflen);
353 if (len >= (sizeof(env->buf) - env->buflen))
354 return -ENOMEM;
355 env->buflen += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return 0;
357}
358
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000359static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
360{
361 struct acpi_device *device = data;
362
363 device->driver->ops.notify(device, event);
364}
365
366static acpi_status acpi_device_notify_fixed(void *data)
367{
368 struct acpi_device *device = data;
369
Bjorn Helgaas53de5352009-08-31 22:32:20 +0000370 /* Fixed hardware devices have no handles */
371 acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000372 return AE_OK;
373}
374
375static int acpi_device_install_notify_handler(struct acpi_device *device)
376{
377 acpi_status status;
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000378
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000379 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000380 status =
381 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
382 acpi_device_notify_fixed,
383 device);
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000384 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000385 status =
386 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
387 acpi_device_notify_fixed,
388 device);
389 else
390 status = acpi_install_notify_handler(device->handle,
391 ACPI_DEVICE_NOTIFY,
392 acpi_device_notify,
393 device);
394
395 if (ACPI_FAILURE(status))
396 return -EINVAL;
397 return 0;
398}
399
400static void acpi_device_remove_notify_handler(struct acpi_device *device)
401{
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000402 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000403 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
404 acpi_device_notify_fixed);
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000405 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000406 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
407 acpi_device_notify_fixed);
408 else
409 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
410 acpi_device_notify);
411}
412
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800413static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
414static int acpi_start_single_object(struct acpi_device *);
415static int acpi_device_probe(struct device * dev)
Zhang Rui9e89dde2006-12-07 20:56:16 +0800416{
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800417 struct acpi_device *acpi_dev = to_acpi_device(dev);
418 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
419 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800421 ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
422 if (!ret) {
Li Shaohuac4168bf2006-12-07 20:56:41 +0800423 if (acpi_dev->bus_ops.acpi_op_start)
424 acpi_start_single_object(acpi_dev);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000425
426 if (acpi_drv->ops.notify) {
427 ret = acpi_device_install_notify_handler(acpi_dev);
428 if (ret) {
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000429 if (acpi_drv->ops.remove)
430 acpi_drv->ops.remove(acpi_dev,
431 acpi_dev->removal_type);
432 return ret;
433 }
434 }
435
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800436 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
437 "Found driver [%s] for device [%s]\n",
438 acpi_drv->name, acpi_dev->pnp.bus_id));
439 get_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800440 }
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800441 return ret;
442}
443
444static int acpi_device_remove(struct device * dev)
445{
446 struct acpi_device *acpi_dev = to_acpi_device(dev);
447 struct acpi_driver *acpi_drv = acpi_dev->driver;
448
449 if (acpi_drv) {
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000450 if (acpi_drv->ops.notify)
451 acpi_device_remove_notify_handler(acpi_dev);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800452 if (acpi_drv->ops.remove)
Li Shaohua96333572006-12-07 20:56:46 +0800453 acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800454 }
455 acpi_dev->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700456 acpi_dev->driver_data = NULL;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800457
458 put_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800459 return 0;
460}
461
David Brownell55955aa2007-05-08 00:28:35 -0700462struct bus_type acpi_bus_type = {
Zhang Rui9e89dde2006-12-07 20:56:16 +0800463 .name = "acpi",
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800464 .match = acpi_bus_match,
465 .probe = acpi_device_probe,
466 .remove = acpi_device_remove,
467 .uevent = acpi_device_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468};
469
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000470static int acpi_device_register(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800472 int result;
473 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
474 int found = 0;
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 /*
477 * Linkage
478 * -------
479 * Link this device to its parent and siblings.
480 */
481 INIT_LIST_HEAD(&device->children);
482 INIT_LIST_HEAD(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 INIT_LIST_HEAD(&device->wakeup_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800484 INIT_LIST_HEAD(&device->physical_node_list);
485 mutex_init(&device->physical_node_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800487 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
488 if (!new_bus_id) {
489 printk(KERN_ERR PREFIX "Memory allocation error\n");
490 return -ENOMEM;
491 }
492
Shaohua Li90905892009-04-07 10:24:29 +0800493 mutex_lock(&acpi_device_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800494 /*
495 * Find suitable bus_id and instance number in acpi_bus_id_list
496 * If failed, create one and link it into acpi_bus_id_list
497 */
498 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600499 if (!strcmp(acpi_device_bus_id->bus_id,
500 acpi_device_hid(device))) {
501 acpi_device_bus_id->instance_no++;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800502 found = 1;
503 kfree(new_bus_id);
504 break;
505 }
506 }
Alex Chiang0c526d92009-05-14 08:31:37 -0600507 if (!found) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800508 acpi_device_bus_id = new_bus_id;
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600509 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800510 acpi_device_bus_id->instance_no = 0;
511 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
512 }
Kay Sievers07944692008-10-30 01:18:59 +0100513 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 +0800514
Len Brown33b57152008-12-15 22:09:26 -0500515 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 list_add_tail(&device->node, &device->parent->children);
Len Brown33b57152008-12-15 22:09:26 -0500517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (device->wakeup.flags.valid)
519 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
Shaohua Li90905892009-04-07 10:24:29 +0800520 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
Patrick Mochel1890a972006-12-07 20:56:31 +0800522 if (device->parent)
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000523 device->dev.parent = &device->parent->dev;
Patrick Mochel1890a972006-12-07 20:56:31 +0800524 device->dev.bus = &acpi_bus_type;
Patrick Mochel1890a972006-12-07 20:56:31 +0800525 device->dev.release = &acpi_device_release;
Alex Chiang8b12b922009-05-14 08:31:32 -0600526 result = device_register(&device->dev);
Alex Chiang0c526d92009-05-14 08:31:37 -0600527 if (result) {
Alex Chiang8b12b922009-05-14 08:31:32 -0600528 dev_err(&device->dev, "Error registering device\n");
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800529 goto end;
530 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800531
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800532 result = acpi_device_setup_files(device);
Alex Chiang0c526d92009-05-14 08:31:37 -0600533 if (result)
Kay Sievers07944692008-10-30 01:18:59 +0100534 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
535 dev_name(&device->dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800536
Li Shaohua96333572006-12-07 20:56:46 +0800537 device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800538 return 0;
Alex Chiang0c526d92009-05-14 08:31:37 -0600539end:
Shaohua Li90905892009-04-07 10:24:29 +0800540 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500541 if (device->parent)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800542 list_del(&device->node);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800543 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800544 mutex_unlock(&acpi_device_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800545 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
548static void acpi_device_unregister(struct acpi_device *device, int type)
549{
Shaohua Li90905892009-04-07 10:24:29 +0800550 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500551 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 list_del(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800555 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 acpi_detach_data(device->handle, acpi_bus_data_handler);
Patrick Mochel1890a972006-12-07 20:56:31 +0800558
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800559 acpi_device_remove_files(device);
Patrick Mochel1890a972006-12-07 20:56:31 +0800560 device_unregister(&device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
562
Zhang Rui9e89dde2006-12-07 20:56:16 +0800563/* --------------------------------------------------------------------------
564 Driver Management
565 -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500567 * acpi_bus_driver_init - add a device to a driver
568 * @device: the device to add and initialize
569 * @driver: driver for the device
570 *
Alex Chiang0c526d92009-05-14 08:31:37 -0600571 * Used to initialize a device via its device driver. Called whenever a
Patrick Mochel1890a972006-12-07 20:56:31 +0800572 * driver is bound to a device. Invokes the driver's add() ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 */
574static int
Len Brown4be44fc2005-08-05 00:44:28 -0400575acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
Len Brown4be44fc2005-08-05 00:44:28 -0400577 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 if (!device || !driver)
Patrick Mocheld550d982006-06-27 00:41:40 -0400580 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 if (!driver->ops.add)
Patrick Mocheld550d982006-06-27 00:41:40 -0400583 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 result = driver->ops.add(device);
586 if (result) {
587 device->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700588 device->driver_data = NULL;
Patrick Mocheld550d982006-06-27 00:41:40 -0400589 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 }
591
592 device->driver = driver;
593
594 /*
595 * TBD - Configuration Management: Assign resources to device based
596 * upon possible configuration and currently allocated resources.
597 */
598
Len Brown4be44fc2005-08-05 00:44:28 -0400599 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
600 "Driver successfully bound to device\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400601 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -0700602}
603
Adrian Bunk8713cbe2005-09-02 17:16:48 -0400604static int acpi_start_single_object(struct acpi_device *device)
Rajesh Shah3fb02732005-04-28 00:25:52 -0700605{
606 int result = 0;
607 struct acpi_driver *driver;
608
Rajesh Shah3fb02732005-04-28 00:25:52 -0700609
610 if (!(driver = device->driver))
Patrick Mocheld550d982006-06-27 00:41:40 -0400611 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -0700612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 if (driver->ops.start) {
614 result = driver->ops.start(device);
615 if (result && driver->ops.remove)
616 driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618
Patrick Mocheld550d982006-06-27 00:41:40 -0400619 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500623 * acpi_bus_register_driver - register a driver with the ACPI bus
624 * @driver: driver being registered
625 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 * Registers a driver with the ACPI bus. Searches the namespace for all
Bjorn Helgaas9d9f7492006-03-28 17:04:00 -0500627 * devices that match the driver's criteria and binds. Returns zero for
628 * success or a negative error status for failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 */
Len Brown4be44fc2005-08-05 00:44:28 -0400630int acpi_bus_register_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Patrick Mochel1890a972006-12-07 20:56:31 +0800632 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400635 return -ENODEV;
Patrick Mochel1890a972006-12-07 20:56:31 +0800636 driver->drv.name = driver->name;
637 driver->drv.bus = &acpi_bus_type;
638 driver->drv.owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Patrick Mochel1890a972006-12-07 20:56:31 +0800640 ret = driver_register(&driver->drv);
641 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Len Brown4be44fc2005-08-05 00:44:28 -0400644EXPORT_SYMBOL(acpi_bus_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500647 * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
648 * @driver: driver to unregister
649 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 * Unregisters a driver with the ACPI bus. Searches the namespace for all
651 * devices that match the driver's criteria and unbinds.
652 */
Bjorn Helgaas06ea8e082006-04-27 05:25:00 -0400653void acpi_bus_unregister_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
Patrick Mochel1890a972006-12-07 20:56:31 +0800655 driver_unregister(&driver->drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656}
Len Brown4be44fc2005-08-05 00:44:28 -0400657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658EXPORT_SYMBOL(acpi_bus_unregister_driver);
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660/* --------------------------------------------------------------------------
661 Device Enumeration
662 -------------------------------------------------------------------------- */
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000663static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
664{
665 acpi_status status;
666 int ret;
667 struct acpi_device *device;
668
669 /*
670 * Fixed hardware devices do not appear in the namespace and do not
671 * have handles, but we fabricate acpi_devices for them, so we have
672 * to deal with them specially.
673 */
674 if (handle == NULL)
675 return acpi_root;
676
677 do {
678 status = acpi_get_parent(handle, &handle);
679 if (status == AE_NULL_ENTRY)
680 return NULL;
681 if (ACPI_FAILURE(status))
682 return acpi_root;
683
684 ret = acpi_bus_get_device(handle, &device);
685 if (ret == 0)
686 return device;
687 } while (1);
688}
689
Len Brownc8f7a622006-07-09 17:22:28 -0400690acpi_status
691acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
692{
693 acpi_status status;
694 acpi_handle tmp;
695 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
696 union acpi_object *obj;
697
698 status = acpi_get_handle(handle, "_EJD", &tmp);
699 if (ACPI_FAILURE(status))
700 return status;
701
702 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
703 if (ACPI_SUCCESS(status)) {
704 obj = buffer.pointer;
Holger Macht3b5fee52008-02-14 13:40:34 +0100705 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
706 ejd);
Len Brownc8f7a622006-07-09 17:22:28 -0400707 kfree(buffer.pointer);
708 }
709 return status;
710}
711EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
712
Bob Moore8e4319c2009-06-29 13:43:27 +0800713void acpi_bus_data_handler(acpi_handle handle, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715
716 /* TBD */
717
718 return;
719}
720
Zhang Rui9e89dde2006-12-07 20:56:16 +0800721static int acpi_bus_get_perf_flags(struct acpi_device *device)
722{
723 device->performance.state = ACPI_STATE_UNKNOWN;
724 return 0;
725}
726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727static acpi_status
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100728acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
729 struct acpi_device_wakeup *wakeup)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100731 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
732 union acpi_object *package = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 union acpi_object *element = NULL;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100734 acpi_status status;
735 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100737 if (!wakeup)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 return AE_BAD_PARAMETER;
739
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100740 /* _PRW */
741 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
742 if (ACPI_FAILURE(status)) {
743 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
744 return status;
745 }
746
747 package = (union acpi_object *)buffer.pointer;
748
749 if (!package || (package->package.count < 2)) {
750 status = AE_BAD_DATA;
751 goto out;
752 }
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 element = &(package->package.elements[0]);
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100755 if (!element) {
756 status = AE_BAD_DATA;
757 goto out;
758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (element->type == ACPI_TYPE_PACKAGE) {
760 if ((element->package.count < 2) ||
761 (element->package.elements[0].type !=
762 ACPI_TYPE_LOCAL_REFERENCE)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100763 || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) {
764 status = AE_BAD_DATA;
765 goto out;
766 }
767 wakeup->gpe_device =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 element->package.elements[0].reference.handle;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100769 wakeup->gpe_number =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 (u32) element->package.elements[1].integer.value;
771 } else if (element->type == ACPI_TYPE_INTEGER) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100772 wakeup->gpe_device = NULL;
773 wakeup->gpe_number = element->integer.value;
774 } else {
775 status = AE_BAD_DATA;
776 goto out;
777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779 element = &(package->package.elements[1]);
780 if (element->type != ACPI_TYPE_INTEGER) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100781 status = AE_BAD_DATA;
782 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 }
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100784 wakeup->sleep_state = element->integer.value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
786 if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100787 status = AE_NO_MEMORY;
788 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 }
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100790 wakeup->resources.count = package->package.count - 2;
791 for (i = 0; i < wakeup->resources.count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 element = &(package->package.elements[i + 2]);
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100793 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) {
794 status = AE_BAD_DATA;
795 goto out;
796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100798 wakeup->resources.handles[i] = element->reference.handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800
Lin Mingbba63a22010-12-13 13:39:17 +0800801 acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
Rafael J. Wysocki98746472010-07-08 00:43:36 +0200802
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100803 out:
804 kfree(buffer.pointer);
805
806 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807}
808
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100809static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
Thomas Renninger29b71a12007-07-23 14:43:51 +0200811 struct acpi_device_id button_device_ids[] = {
812 {"PNP0C0D", 0},
813 {"PNP0C0C", 0},
814 {"PNP0C0E", 0},
815 {"", 0},
816 };
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100817 acpi_status status;
818 acpi_event_status event_status;
819
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100820 device->wakeup.flags.notifier_present = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100821
822 /* Power button, Lid switch always enable wakeup */
823 if (!acpi_match_device_ids(device, button_device_ids)) {
824 device->wakeup.flags.run_wake = 1;
Rafael J. Wysockif2b56bc2011-01-06 23:34:22 +0100825 device_set_wakeup_capable(&device->dev, true);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100826 return;
827 }
828
Rafael J. Wysockie8e18c92010-07-08 00:42:51 +0200829 status = acpi_get_gpe_status(device->wakeup.gpe_device,
830 device->wakeup.gpe_number,
831 &event_status);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100832 if (status == AE_OK)
833 device->wakeup.flags.run_wake =
834 !!(event_status & ACPI_EVENT_FLAG_HANDLE);
835}
836
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100837static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100838{
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100839 acpi_handle temp;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100840 acpi_status status = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100841 int psw_error;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200842
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100843 /* Presence of _PRW indicates wake capable */
844 status = acpi_get_handle(device->handle, "_PRW", &temp);
845 if (ACPI_FAILURE(status))
846 return;
847
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100848 status = acpi_bus_extract_wakeup_device_power_package(device->handle,
849 &device->wakeup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 if (ACPI_FAILURE(status)) {
851 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100852 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 }
854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 device->wakeup.flags.valid = 1;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200856 device->wakeup.prepare_count = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100857 acpi_bus_set_run_wake_flags(device);
Zhao Yakui729b2bd2008-03-19 13:26:54 +0800858 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
859 * system for the ACPI device with the _PRW object.
860 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
861 * So it is necessary to call _DSW object first. Only when it is not
862 * present will the _PSW object used.
863 */
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200864 psw_error = acpi_device_sleep_wake(device, 0, 0, 0);
865 if (psw_error)
866 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
867 "error in _DSW or _PSW evaluation\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868}
869
Rafael J. Wysockibf325f92010-11-25 00:10:44 +0100870static void acpi_bus_add_power_resource(acpi_handle handle);
871
Zhang Rui9e89dde2006-12-07 20:56:16 +0800872static int acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873{
Zhang Rui9e89dde2006-12-07 20:56:16 +0800874 acpi_status status = 0;
875 acpi_handle handle = NULL;
876 u32 i = 0;
877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800880 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800882 status = acpi_get_handle(device->handle, "_PSC", &handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (ACPI_SUCCESS(status))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800884 device->power.flags.explicit_get = 1;
885 status = acpi_get_handle(device->handle, "_IRC", &handle);
886 if (ACPI_SUCCESS(status))
887 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800890 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 */
Lin Ming1cc0c992012-04-23 09:03:49 +0800892 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
Zhang Rui9e89dde2006-12-07 20:56:16 +0800893 struct acpi_device_power_state *ps = &device->power.states[i];
894 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
Zhang Rui9e89dde2006-12-07 20:56:16 +0800896 /* Evaluate "_PRx" to se if power resources are referenced */
897 acpi_evaluate_reference(device->handle, object_name, NULL,
898 &ps->resources);
899 if (ps->resources.count) {
Rafael J. Wysockibf325f92010-11-25 00:10:44 +0100900 int j;
901
Zhang Rui9e89dde2006-12-07 20:56:16 +0800902 device->power.flags.power_resources = 1;
Rafael J. Wysockibf325f92010-11-25 00:10:44 +0100903 for (j = 0; j < ps->resources.count; j++)
904 acpi_bus_add_power_resource(ps->resources.handles[j]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906
Zhang Rui9e89dde2006-12-07 20:56:16 +0800907 /* Evaluate "_PSx" to see if we can do explicit sets */
908 object_name[2] = 'S';
909 status = acpi_get_handle(device->handle, object_name, &handle);
Alex He37239972012-02-21 16:58:10 +0800910 if (ACPI_SUCCESS(status))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800911 ps->flags.explicit_set = 1;
Zhang Rui9e89dde2006-12-07 20:56:16 +0800912
Lin Ming1cc0c992012-04-23 09:03:49 +0800913 /*
914 * State is valid if there are means to put the device into it.
915 * D3hot is only valid if _PR3 present.
916 */
917 if (ps->resources.count ||
918 (ps->flags.explicit_set && i < ACPI_STATE_D3_HOT))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800919 ps->flags.valid = 1;
920
921 ps->power = -1; /* Unknown - driver assigned */
922 ps->latency = -1; /* Unknown - driver assigned */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Zhang Rui9e89dde2006-12-07 20:56:16 +0800925 /* Set defaults for D0 and D3 states (always valid) */
926 device->power.states[ACPI_STATE_D0].flags.valid = 1;
927 device->power.states[ACPI_STATE_D0].power = 100;
928 device->power.states[ACPI_STATE_D3].flags.valid = 1;
929 device->power.states[ACPI_STATE_D3].power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
Rafael J. Wysocki5c7dd712012-05-18 00:39:35 +0200931 /* Set D3cold's explicit_set flag if _PS3 exists. */
932 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
933 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
934
Rafael J. Wysockiade3e7f2010-11-25 00:08:36 +0100935 acpi_bus_init_power(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 return 0;
938}
939
Len Brown4be44fc2005-08-05 00:44:28 -0400940static int acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
Len Brown4be44fc2005-08-05 00:44:28 -0400942 acpi_status status = AE_OK;
943 acpi_handle temp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 /* Presence of _STA indicates 'dynamic_status' */
947 status = acpi_get_handle(device->handle, "_STA", &temp);
948 if (ACPI_SUCCESS(status))
949 device->flags.dynamic_status = 1;
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 /* Presence of _RMV indicates 'removable' */
952 status = acpi_get_handle(device->handle, "_RMV", &temp);
953 if (ACPI_SUCCESS(status))
954 device->flags.removable = 1;
955
956 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
957 status = acpi_get_handle(device->handle, "_EJD", &temp);
958 if (ACPI_SUCCESS(status))
959 device->flags.ejectable = 1;
960 else {
961 status = acpi_get_handle(device->handle, "_EJ0", &temp);
962 if (ACPI_SUCCESS(status))
963 device->flags.ejectable = 1;
964 }
965
966 /* Presence of _LCK indicates 'lockable' */
967 status = acpi_get_handle(device->handle, "_LCK", &temp);
968 if (ACPI_SUCCESS(status))
969 device->flags.lockable = 1;
970
Rafael J. Wysocki7bed50c2011-04-26 11:33:18 +0200971 /* Power resources cannot be power manageable. */
972 if (device->device_type == ACPI_BUS_TYPE_POWER)
973 return 0;
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 /* Presence of _PS0|_PR0 indicates 'power manageable' */
976 status = acpi_get_handle(device->handle, "_PS0", &temp);
977 if (ACPI_FAILURE(status))
978 status = acpi_get_handle(device->handle, "_PR0", &temp);
979 if (ACPI_SUCCESS(status))
980 device->flags.power_manageable = 1;
981
Joe Perches3c5f9be42008-02-03 17:06:17 +0200982 /* TBD: Performance management */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Patrick Mocheld550d982006-06-27 00:41:40 -0400984 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985}
986
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +0000987static void acpi_device_get_busid(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988{
Len Brown4be44fc2005-08-05 00:44:28 -0400989 char bus_id[5] = { '?', 0 };
990 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
991 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 /*
994 * Bus ID
995 * ------
996 * The device's Bus ID is simply the object name.
997 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
998 */
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +0000999 if (ACPI_IS_ROOT_DEVICE(device)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 strcpy(device->pnp.bus_id, "ACPI");
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001001 return;
1002 }
1003
1004 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 case ACPI_BUS_TYPE_POWER_BUTTON:
1006 strcpy(device->pnp.bus_id, "PWRF");
1007 break;
1008 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1009 strcpy(device->pnp.bus_id, "SLPF");
1010 break;
1011 default:
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001012 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 /* Clean up trailing underscores (if any) */
1014 for (i = 3; i > 1; i--) {
1015 if (bus_id[i] == '_')
1016 bus_id[i] = '\0';
1017 else
1018 break;
1019 }
1020 strcpy(device->pnp.bus_id, bus_id);
1021 break;
1022 }
1023}
1024
Zhang Rui54735262007-01-11 02:09:09 -05001025/*
1026 * acpi_bay_match - see if a device is an ejectable driver bay
1027 *
1028 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1029 * then we can safely call it an ejectable drive bay
1030 */
1031static int acpi_bay_match(struct acpi_device *device){
1032 acpi_status status;
1033 acpi_handle handle;
1034 acpi_handle tmp;
1035 acpi_handle phandle;
1036
1037 handle = device->handle;
1038
1039 status = acpi_get_handle(handle, "_EJ0", &tmp);
1040 if (ACPI_FAILURE(status))
1041 return -ENODEV;
1042
1043 if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
1044 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
1045 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
1046 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
1047 return 0;
1048
1049 if (acpi_get_parent(handle, &phandle))
1050 return -ENODEV;
1051
1052 if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
1053 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
1054 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
1055 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
1056 return 0;
1057
1058 return -ENODEV;
1059}
1060
Frank Seidel3620f2f2007-12-07 13:20:34 +01001061/*
1062 * acpi_dock_match - see if a device has a _DCK method
1063 */
1064static int acpi_dock_match(struct acpi_device *device)
1065{
1066 acpi_handle tmp;
1067 return acpi_get_handle(device->handle, "_DCK", &tmp);
1068}
1069
Thomas Renninger620e1122010-10-01 10:54:00 +02001070const char *acpi_device_hid(struct acpi_device *device)
Bob Moore15b8dd52009-06-29 13:39:29 +08001071{
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001072 struct acpi_hardware_id *hid;
Bob Moore15b8dd52009-06-29 13:39:29 +08001073
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +02001074 if (list_empty(&device->pnp.ids))
1075 return dummy_hid;
1076
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001077 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1078 return hid->id;
1079}
1080EXPORT_SYMBOL(acpi_device_hid);
Bob Moore15b8dd52009-06-29 13:39:29 +08001081
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001082static void acpi_add_id(struct acpi_device *device, const char *dev_id)
1083{
1084 struct acpi_hardware_id *id;
Bob Moore15b8dd52009-06-29 13:39:29 +08001085
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001086 id = kmalloc(sizeof(*id), GFP_KERNEL);
1087 if (!id)
1088 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001089
Thomas Meyer581de592011-08-06 11:32:56 +02001090 id->id = kstrdup(dev_id, GFP_KERNEL);
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001091 if (!id->id) {
1092 kfree(id);
1093 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001094 }
1095
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001096 list_add_tail(&id->list, &device->pnp.ids);
Bob Moore15b8dd52009-06-29 13:39:29 +08001097}
1098
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001099/*
1100 * Old IBM workstations have a DSDT bug wherein the SMBus object
1101 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1102 * prefix. Work around this.
1103 */
1104static int acpi_ibm_smbus_match(struct acpi_device *device)
1105{
1106 acpi_handle h_dummy;
1107 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
1108 int result;
1109
1110 if (!dmi_name_in_vendors("IBM"))
1111 return -ENODEV;
1112
1113 /* Look for SMBS object */
1114 result = acpi_get_name(device->handle, ACPI_SINGLE_NAME, &path);
1115 if (result)
1116 return result;
1117
1118 if (strcmp("SMBS", path.pointer)) {
1119 result = -ENODEV;
1120 goto out;
1121 }
1122
1123 /* Does it have the necessary (but misnamed) methods? */
1124 result = -ENODEV;
1125 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "SBI", &h_dummy)) &&
1126 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBR", &h_dummy)) &&
1127 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBW", &h_dummy)))
1128 result = 0;
1129out:
1130 kfree(path.pointer);
1131 return result;
1132}
1133
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001134static void acpi_device_set_id(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135{
Len Brown4be44fc2005-08-05 00:44:28 -04001136 acpi_status status;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001137 struct acpi_device_info *info;
1138 struct acpica_device_id_list *cid_list;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001139 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001141 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 case ACPI_BUS_TYPE_DEVICE:
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001143 if (ACPI_IS_ROOT_DEVICE(device)) {
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001144 acpi_add_id(device, ACPI_SYSTEM_HID);
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001145 break;
1146 }
1147
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001148 status = acpi_get_object_info(device->handle, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (ACPI_FAILURE(status)) {
Harvey Harrison96b2dd12008-03-05 18:24:51 -08001150 printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 return;
1152 }
1153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 if (info->valid & ACPI_VALID_HID)
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001155 acpi_add_id(device, info->hardware_id.string);
1156 if (info->valid & ACPI_VALID_CID) {
Bob Moore15b8dd52009-06-29 13:39:29 +08001157 cid_list = &info->compatible_id_list;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001158 for (i = 0; i < cid_list->count; i++)
1159 acpi_add_id(device, cid_list->ids[i].string);
1160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 if (info->valid & ACPI_VALID_ADR) {
1162 device->pnp.bus_address = info->address;
1163 device->flags.bus_address = 1;
1164 }
Zhang Ruiae843332006-12-07 20:57:10 +08001165
Bjorn Helgaasa83893ae2009-10-02 11:03:12 -04001166 kfree(info);
1167
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001168 /*
1169 * Some devices don't reliably have _HIDs & _CIDs, so add
1170 * synthetic HIDs to make sure drivers can find them.
1171 */
Thomas Renningerc3d6de62008-08-01 17:37:55 +02001172 if (acpi_is_video_device(device))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001173 acpi_add_id(device, ACPI_VIDEO_HID);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001174 else if (ACPI_SUCCESS(acpi_bay_match(device)))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001175 acpi_add_id(device, ACPI_BAY_HID);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001176 else if (ACPI_SUCCESS(acpi_dock_match(device)))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001177 acpi_add_id(device, ACPI_DOCK_HID);
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001178 else if (!acpi_ibm_smbus_match(device))
1179 acpi_add_id(device, ACPI_SMBUS_IBM_HID);
Bjorn Helgaasb7b30de2010-03-24 10:44:33 -06001180 else if (!acpi_device_hid(device) &&
1181 ACPI_IS_ROOT_DEVICE(device->parent)) {
1182 acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
1183 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1184 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1185 }
Zhang Rui54735262007-01-11 02:09:09 -05001186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 break;
1188 case ACPI_BUS_TYPE_POWER:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001189 acpi_add_id(device, ACPI_POWER_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 break;
1191 case ACPI_BUS_TYPE_PROCESSOR:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001192 acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 case ACPI_BUS_TYPE_THERMAL:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001195 acpi_add_id(device, ACPI_THERMAL_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 break;
1197 case ACPI_BUS_TYPE_POWER_BUTTON:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001198 acpi_add_id(device, ACPI_BUTTON_HID_POWERF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 break;
1200 case ACPI_BUS_TYPE_SLEEP_BUTTON:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001201 acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 break;
1203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204}
1205
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001206static int acpi_device_set_context(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001208 acpi_status status;
1209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 /*
1211 * Context
1212 * -------
1213 * Attach this 'struct acpi_device' to the ACPI object. This makes
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001214 * resolutions from handle->device very efficient. Fixed hardware
1215 * devices have no handles, so we skip them.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 */
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001217 if (!device->handle)
1218 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001220 status = acpi_attach_data(device->handle,
1221 acpi_bus_data_handler, device);
1222 if (ACPI_SUCCESS(status))
1223 return 0;
1224
1225 printk(KERN_ERR PREFIX "Error attaching device data\n");
1226 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227}
1228
Len Brown4be44fc2005-08-05 00:44:28 -04001229static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 if (!dev)
Patrick Mocheld550d982006-06-27 00:41:40 -04001232 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
Li Shaohua96333572006-12-07 20:56:46 +08001234 dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
Patrick Mochel1890a972006-12-07 20:56:31 +08001235 device_release_driver(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
1237 if (!rmdevice)
Patrick Mocheld550d982006-06-27 00:41:40 -04001238 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
Rui Zhang2786f6e2006-12-21 02:21:13 -05001240 /*
1241 * unbind _ADR-Based Devices when hot removal
1242 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 if (dev->flags.bus_address) {
1244 if ((dev->parent) && (dev->parent->ops.unbind))
1245 dev->parent->ops.unbind(dev);
1246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1248
Patrick Mocheld550d982006-06-27 00:41:40 -04001249 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
1251
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001252static int acpi_add_single_object(struct acpi_device **child,
1253 acpi_handle handle, int type,
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001254 unsigned long long sta,
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001255 struct acpi_bus_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256{
Bjorn Helgaas77c24882009-09-21 19:29:30 +00001257 int result;
1258 struct acpi_device *device;
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001259 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Burman Yan36bcbec2006-12-19 12:56:11 -08001261 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001263 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001264 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001267 INIT_LIST_HEAD(&device->pnp.ids);
Bjorn Helgaascaaa6ef2009-09-21 19:29:10 +00001268 device->device_type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 device->handle = handle;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001270 device->parent = acpi_bus_get_parent(handle);
Li Shaohuac4168bf2006-12-07 20:56:41 +08001271 device->bus_ops = *ops; /* workround for not call .start */
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001272 STRUCT_TO_INT(device->status) = sta;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001273
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001274 acpi_device_get_busid(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
1276 /*
1277 * Flags
1278 * -----
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001279 * Note that we only look for object handles -- cannot evaluate objects
1280 * until we know the device is present and properly initialized.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 */
1282 result = acpi_bus_get_flags(device);
1283 if (result)
1284 goto end;
1285
1286 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 * Initialize Device
1288 * -----------------
1289 * TBD: Synch with Core's enumeration/initialization process.
1290 */
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001291 acpi_device_set_id(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
1293 /*
1294 * Power Management
1295 * ----------------
1296 */
1297 if (device->flags.power_manageable) {
1298 result = acpi_bus_get_power_flags(device);
1299 if (result)
1300 goto end;
1301 }
1302
Len Brown4be44fc2005-08-05 00:44:28 -04001303 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 * Wakeup device management
1305 *-----------------------
1306 */
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001307 acpi_bus_get_wakeup_device_flags(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 /*
1310 * Performance Management
1311 * ----------------------
1312 */
1313 if (device->flags.performance_manageable) {
1314 result = acpi_bus_get_perf_flags(device);
1315 if (result)
1316 goto end;
1317 }
1318
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001319 if ((result = acpi_device_set_context(device)))
Len Brownf61f9252009-09-05 13:33:23 -04001320 goto end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001322 result = acpi_device_register(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
1324 /*
Rui Zhang2786f6e2006-12-21 02:21:13 -05001325 * Bind _ADR-Based Devices when hot add
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 */
1327 if (device->flags.bus_address) {
1328 if (device->parent && device->parent->ops.bind)
1329 device->parent->ops.bind(device);
1330 }
1331
Alex Chiang0c526d92009-05-14 08:31:37 -06001332end:
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001333 if (!result) {
1334 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1335 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1336 "Adding %s [%s] parent %s\n", dev_name(&device->dev),
1337 (char *) buffer.pointer,
1338 device->parent ? dev_name(&device->parent->dev) :
1339 "(null)"));
1340 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 *child = device;
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001342 } else
Hugh Dickins718fb0d2009-08-06 23:18:12 +00001343 acpi_device_release(&device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Patrick Mocheld550d982006-06-27 00:41:40 -04001345 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001348#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \
1349 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING)
1350
Rafael J. Wysockibf325f92010-11-25 00:10:44 +01001351static void acpi_bus_add_power_resource(acpi_handle handle)
1352{
1353 struct acpi_bus_ops ops = {
1354 .acpi_op_add = 1,
1355 .acpi_op_start = 1,
1356 };
1357 struct acpi_device *device = NULL;
1358
1359 acpi_bus_get_device(handle, &device);
1360 if (!device)
1361 acpi_add_single_object(&device, handle, ACPI_BUS_TYPE_POWER,
1362 ACPI_STA_DEFAULT, &ops);
1363}
1364
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001365static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1366 unsigned long long *sta)
1367{
1368 acpi_status status;
1369 acpi_object_type acpi_type;
1370
1371 status = acpi_get_type(handle, &acpi_type);
1372 if (ACPI_FAILURE(status))
1373 return -ENODEV;
1374
1375 switch (acpi_type) {
1376 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
1377 case ACPI_TYPE_DEVICE:
1378 *type = ACPI_BUS_TYPE_DEVICE;
1379 status = acpi_bus_get_status_handle(handle, sta);
1380 if (ACPI_FAILURE(status))
1381 return -ENODEV;
1382 break;
1383 case ACPI_TYPE_PROCESSOR:
1384 *type = ACPI_BUS_TYPE_PROCESSOR;
1385 status = acpi_bus_get_status_handle(handle, sta);
1386 if (ACPI_FAILURE(status))
1387 return -ENODEV;
1388 break;
1389 case ACPI_TYPE_THERMAL:
1390 *type = ACPI_BUS_TYPE_THERMAL;
1391 *sta = ACPI_STA_DEFAULT;
1392 break;
1393 case ACPI_TYPE_POWER:
1394 *type = ACPI_BUS_TYPE_POWER;
1395 *sta = ACPI_STA_DEFAULT;
1396 break;
1397 default:
1398 return -ENODEV;
1399 }
1400
1401 return 0;
1402}
1403
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001404static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl,
1405 void *context, void **return_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001407 struct acpi_bus_ops *ops = context;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001408 int type;
1409 unsigned long long sta;
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001410 struct acpi_device *device;
1411 acpi_status status;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001412 int result;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001413
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001414 result = acpi_bus_type_and_status(handle, &type, &sta);
1415 if (result)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001416 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001418 if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001419 !(sta & ACPI_STA_DEVICE_FUNCTIONING)) {
Rafael J. Wysocki86e4e202011-01-06 23:40:00 +01001420 struct acpi_device_wakeup wakeup;
1421 acpi_handle temp;
1422
1423 status = acpi_get_handle(handle, "_PRW", &temp);
1424 if (ACPI_SUCCESS(status))
1425 acpi_bus_extract_wakeup_device_power_package(handle,
1426 &wakeup);
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001427 return AE_CTRL_DEPTH;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001428 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001430 /*
1431 * We may already have an acpi_device from a previous enumeration. If
1432 * so, we needn't add it again, but we may still have to start it.
1433 */
1434 device = NULL;
1435 acpi_bus_get_device(handle, &device);
1436 if (ops->acpi_op_add && !device)
1437 acpi_add_single_object(&device, handle, type, sta, ops);
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001438
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001439 if (!device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001440 return AE_CTRL_DEPTH;
1441
1442 if (ops->acpi_op_start && !(ops->acpi_op_add)) {
1443 status = acpi_start_single_object(device);
1444 if (ACPI_FAILURE(status))
1445 return AE_CTRL_DEPTH;
1446 }
1447
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001448 if (!*return_value)
1449 *return_value = device;
1450 return AE_OK;
1451}
1452
1453static int acpi_bus_scan(acpi_handle handle, struct acpi_bus_ops *ops,
1454 struct acpi_device **child)
1455{
1456 acpi_status status;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001457 void *device = NULL;
1458
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001459 status = acpi_bus_check_add(handle, 0, ops, &device);
1460 if (ACPI_SUCCESS(status))
1461 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Lin Ming22635762009-11-13 10:06:08 +08001462 acpi_bus_check_add, NULL, ops, &device);
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001463
1464 if (child)
1465 *child = device;
Thomas Renninger77796882010-01-29 17:48:52 +01001466
1467 if (device)
1468 return 0;
1469 else
1470 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Thomas Renninger77796882010-01-29 17:48:52 +01001473/*
1474 * acpi_bus_add and acpi_bus_start
1475 *
1476 * scan a given ACPI tree and (probably recently hot-plugged)
1477 * create and add or starts found devices.
1478 *
1479 * If no devices were found -ENODEV is returned which does not
1480 * mean that this is a real error, there just have been no suitable
1481 * ACPI objects in the table trunk from which the kernel could create
1482 * a device and add/start an appropriate driver.
1483 */
1484
Rajesh Shah3fb02732005-04-28 00:25:52 -07001485int
Len Brown4be44fc2005-08-05 00:44:28 -04001486acpi_bus_add(struct acpi_device **child,
1487 struct acpi_device *parent, acpi_handle handle, int type)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001488{
Rajesh Shah3fb02732005-04-28 00:25:52 -07001489 struct acpi_bus_ops ops;
1490
Li Shaohuac4168bf2006-12-07 20:56:41 +08001491 memset(&ops, 0, sizeof(ops));
1492 ops.acpi_op_add = 1;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001493
Thomas Renninger77796882010-01-29 17:48:52 +01001494 return acpi_bus_scan(handle, &ops, child);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001495}
1496EXPORT_SYMBOL(acpi_bus_add);
1497
Len Brown4be44fc2005-08-05 00:44:28 -04001498int acpi_bus_start(struct acpi_device *device)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001499{
Rajesh Shah3fb02732005-04-28 00:25:52 -07001500 struct acpi_bus_ops ops;
Rafael J. Wysockia2100802010-09-16 00:30:43 +02001501 int result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001502
Thomas Renningerd2f66502010-01-29 17:48:51 +01001503 if (!device)
1504 return -EINVAL;
1505
Bjorn Helgaas8e029bf2009-09-21 19:29:40 +00001506 memset(&ops, 0, sizeof(ops));
1507 ops.acpi_op_start = 1;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001508
Rafael J. Wysockia2100802010-09-16 00:30:43 +02001509 result = acpi_bus_scan(device->handle, &ops, NULL);
1510
Lin Ming3a378982010-12-13 13:36:15 +08001511 acpi_update_all_gpes();
Rafael J. Wysockia2100802010-09-16 00:30:43 +02001512
1513 return result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001514}
1515EXPORT_SYMBOL(acpi_bus_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Kristen Accardiceaba662006-02-23 17:56:01 -08001517int acpi_bus_trim(struct acpi_device *start, int rmdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518{
Len Brown4be44fc2005-08-05 00:44:28 -04001519 acpi_status status;
1520 struct acpi_device *parent, *child;
1521 acpi_handle phandle, chandle;
1522 acpi_object_type type;
1523 u32 level = 1;
1524 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
Len Brown4be44fc2005-08-05 00:44:28 -04001526 parent = start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 phandle = start->handle;
1528 child = chandle = NULL;
1529
1530 while ((level > 0) && parent && (!err)) {
1531 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
Len Brown4be44fc2005-08-05 00:44:28 -04001532 chandle, &chandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
1534 /*
1535 * If this scope is exhausted then move our way back up.
1536 */
1537 if (ACPI_FAILURE(status)) {
1538 level--;
1539 chandle = phandle;
1540 acpi_get_parent(phandle, &phandle);
1541 child = parent;
1542 parent = parent->parent;
1543
1544 if (level == 0)
1545 err = acpi_bus_remove(child, rmdevice);
1546 else
1547 err = acpi_bus_remove(child, 1);
1548
1549 continue;
1550 }
1551
1552 status = acpi_get_type(chandle, &type);
1553 if (ACPI_FAILURE(status)) {
1554 continue;
1555 }
1556 /*
1557 * If there is a device corresponding to chandle then
1558 * parse it (depth-first).
1559 */
1560 if (acpi_bus_get_device(chandle, &child) == 0) {
1561 level++;
1562 phandle = chandle;
1563 chandle = NULL;
1564 parent = child;
1565 }
1566 continue;
1567 }
1568 return err;
1569}
Kristen Accardiceaba662006-02-23 17:56:01 -08001570EXPORT_SYMBOL_GPL(acpi_bus_trim);
1571
Bjorn Helgaase8b945c2009-09-21 19:28:59 +00001572static int acpi_bus_scan_fixed(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573{
Len Brown4be44fc2005-08-05 00:44:28 -04001574 int result = 0;
1575 struct acpi_device *device = NULL;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001576 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Li Shaohuac4168bf2006-12-07 20:56:41 +08001578 memset(&ops, 0, sizeof(ops));
1579 ops.acpi_op_add = 1;
1580 ops.acpi_op_start = 1;
1581
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 /*
1583 * Enumerate all fixed-feature devices.
1584 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001585 if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001586 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001587 ACPI_BUS_TYPE_POWER_BUTTON,
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001588 ACPI_STA_DEFAULT,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001589 &ops);
Daniel Drakec10d7a12012-05-10 00:08:43 +01001590 device_init_wakeup(&device->dev, true);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001593 if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001594 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001595 ACPI_BUS_TYPE_SLEEP_BUTTON,
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001596 ACPI_STA_DEFAULT,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001597 &ops);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Patrick Mocheld550d982006-06-27 00:41:40 -04001600 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601}
1602
Bjorn Helgaase747f272009-03-24 16:49:43 -06001603int __init acpi_scan_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604{
1605 int result;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001606 struct acpi_bus_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
Li Shaohuac4168bf2006-12-07 20:56:41 +08001608 memset(&ops, 0, sizeof(ops));
1609 ops.acpi_op_add = 1;
1610 ops.acpi_op_start = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
Patrick Mochel5b327262006-05-10 10:33:00 -04001612 result = bus_register(&acpi_bus_type);
1613 if (result) {
1614 /* We don't want to quit even if we failed to add suspend/resume */
1615 printk(KERN_ERR PREFIX "Could not register bus type\n");
1616 }
1617
Rafael J. Wysocki97d9a9e2010-11-25 00:10:02 +01001618 acpi_power_init();
1619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 * Enumerate devices in the ACPI namespace.
1622 */
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001623 result = acpi_bus_scan(ACPI_ROOT_OBJECT, &ops, &acpi_root);
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001624
Li Shaohuac4168bf2006-12-07 20:56:41 +08001625 if (!result)
Bjorn Helgaasadc08e22009-09-21 19:29:45 +00001626 result = acpi_bus_scan_fixed();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
1628 if (result)
1629 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
Rafael J. Wysockia2100802010-09-16 00:30:43 +02001630 else
Lin Ming3a378982010-12-13 13:36:15 +08001631 acpi_update_all_gpes();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632
Patrick Mocheld550d982006-06-27 00:41:40 -04001633 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634}