blob: b206ce5e1fafe096ea2c8f667b91effbf1580586 [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>
Lance Ortizd1efe3c2012-10-02 12:43:23 -060013#include <linux/nls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
15#include <acpi/acpi_drivers.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Bjorn Helgaase60cc7a2009-03-13 12:08:26 -060017#include "internal.h"
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050020ACPI_MODULE_NAME("scan");
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#define STRUCT_TO_INT(s) (*((int*)&s))
Len Brown4be44fc2005-08-05 00:44:28 -040022extern struct acpi_device *acpi_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#define ACPI_BUS_CLASS "system_bus"
Thomas Renninger29b71a12007-07-23 14:43:51 +020025#define ACPI_BUS_HID "LNXSYBUS"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#define ACPI_BUS_DEVICE_NAME "System Bus"
27
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +000028#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
29
Thomas Renninger620e1122010-10-01 10:54:00 +020030static const char *dummy_hid = "device";
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +020031
Mika Westerberg91e56872012-10-31 22:45:02 +010032/*
33 * The following ACPI IDs are known to be suitable for representing as
34 * platform devices.
35 */
36static const struct acpi_device_id acpi_platform_device_ids[] = {
37
Adrian Hunter142b0072012-11-23 21:11:47 +010038 { "PNP0D40" },
39
Mika Westerberg5e7779f2012-12-07 23:12:01 +010040 /* Haswell LPSS devices */
41 { "INT33C0", 0 },
42 { "INT33C1", 0 },
43 { "INT33C2", 0 },
44 { "INT33C3", 0 },
45 { "INT33C4", 0 },
46 { "INT33C5", 0 },
47 { "INT33C6", 0 },
48 { "INT33C7", 0 },
49
Mika Westerberg91e56872012-10-31 22:45:02 +010050 { }
51};
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053static LIST_HEAD(acpi_device_list);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080054static LIST_HEAD(acpi_bus_id_list);
Shaohua Li90905892009-04-07 10:24:29 +080055DEFINE_MUTEX(acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056LIST_HEAD(acpi_wakeup_device_list);
57
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080058struct acpi_device_bus_id{
Zhang Ruibb095852007-01-04 15:03:18 +080059 char bus_id[15];
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080060 unsigned int instance_no;
61 struct list_head node;
62};
Thomas Renninger29b71a12007-07-23 14:43:51 +020063
64/*
65 * Creates hid/cid(s) string needed for modalias and uevent
66 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
67 * char *modalias: "acpi:IBM0001:ACPI0001"
68*/
Adrian Bunkb3e572d2007-08-14 23:22:35 +020069static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
70 int size)
71{
Thomas Renninger29b71a12007-07-23 14:43:51 +020072 int len;
Zhang Rui5c9fcb52008-03-20 16:40:32 +080073 int count;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -060074 struct acpi_hardware_id *id;
Thomas Renninger29b71a12007-07-23 14:43:51 +020075
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +020076 if (list_empty(&acpi_dev->pnp.ids))
77 return 0;
78
Zhang Rui5c9fcb52008-03-20 16:40:32 +080079 len = snprintf(modalias, size, "acpi:");
Thomas Renninger29b71a12007-07-23 14:43:51 +020080 size -= len;
81
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -060082 list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
83 count = snprintf(&modalias[len], size, "%s:", id->id);
Zhang Rui5c9fcb52008-03-20 16:40:32 +080084 if (count < 0 || count >= size)
85 return -EINVAL;
86 len += count;
87 size -= count;
88 }
89
Thomas Renninger29b71a12007-07-23 14:43:51 +020090 modalias[len] = '\0';
91 return len;
92}
93
94static ssize_t
95acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
96 struct acpi_device *acpi_dev = to_acpi_device(dev);
97 int len;
98
99 /* Device has no HID and no CID or string is >1024 */
100 len = create_modalias(acpi_dev, buf, 1024);
101 if (len <= 0)
102 return 0;
103 buf[len++] = '\n';
104 return len;
105}
106static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
107
Toshi Kanic4753e52012-05-23 20:25:20 -0600108/**
109 * acpi_bus_hot_remove_device: hot-remove a device and its children
110 * @context: struct acpi_eject_event pointer (freed in this func)
111 *
112 * Hot-remove a device and its children. This function frees up the
113 * memory space passed by arg context, so that the caller may call
114 * this function asynchronously through acpi_os_hotplug_execute().
115 */
116void acpi_bus_hot_remove_device(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Toshi Kanic4753e52012-05-23 20:25:20 -0600118 struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
Yinghai Lu5993c462013-01-11 22:40:41 +0000119 struct acpi_device *device = ej_event->device;
120 acpi_handle handle = device->handle;
Toshi Kanib3c450c2012-10-26 13:38:57 +0200121 acpi_handle temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 struct acpi_object_list arg_list;
123 union acpi_object arg;
124 acpi_status status = AE_OK;
Toshi Kanic4753e52012-05-23 20:25:20 -0600125 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Zhang Rui26d46862008-04-29 02:35:48 -0400127 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Kay Sievers07944692008-10-30 01:18:59 +0100128 "Hot-removing device %s...\n", dev_name(&device->dev)));
Zhang Rui26d46862008-04-29 02:35:48 -0400129
Rafael J. Wysockiae281792013-01-15 13:23:53 +0100130 if (acpi_bus_trim(device)) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800131 printk(KERN_ERR PREFIX
132 "Removing device failed\n");
Toshi Kanic4753e52012-05-23 20:25:20 -0600133 goto err_out;
Zhang Rui26d46862008-04-29 02:35:48 -0400134 }
135
Toshi Kanib3c450c2012-10-26 13:38:57 +0200136 /* device has been freed */
137 device = NULL;
138
Zhang Rui26d46862008-04-29 02:35:48 -0400139 /* power off device */
140 status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
141 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
Lin Ming55ac9a02008-09-28 14:51:56 +0800142 printk(KERN_WARNING PREFIX
143 "Power-off device failed\n");
Zhang Rui26d46862008-04-29 02:35:48 -0400144
Toshi Kanib3c450c2012-10-26 13:38:57 +0200145 if (ACPI_SUCCESS(acpi_get_handle(handle, "_LCK", &temp))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 arg_list.count = 1;
147 arg_list.pointer = &arg;
148 arg.type = ACPI_TYPE_INTEGER;
149 arg.integer.value = 0;
150 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
151 }
152
153 arg_list.count = 1;
154 arg_list.pointer = &arg;
155 arg.type = ACPI_TYPE_INTEGER;
156 arg.integer.value = 1;
157
158 /*
159 * TBD: _EJD support.
160 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
Toshi Kanic4753e52012-05-23 20:25:20 -0600162 if (ACPI_FAILURE(status)) {
163 if (status != AE_NOT_FOUND)
164 printk(KERN_WARNING PREFIX
165 "Eject device failed\n");
166 goto err_out;
167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Toshi Kanic4753e52012-05-23 20:25:20 -0600169 kfree(context);
170 return;
171
172err_out:
173 /* Inform firmware the hot-remove operation has completed w/ error */
174 (void) acpi_evaluate_hotplug_ost(handle,
175 ej_event->event, ost_code, NULL);
176 kfree(context);
Zhang Ruic8d72a52009-06-22 11:31:16 +0800177 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
Toshi Kani61622ac2012-11-01 14:42:12 +0000179EXPORT_SYMBOL(acpi_bus_hot_remove_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Rafael J. Wysocki836aedb2013-01-24 12:49:59 +0100181static ssize_t real_power_state_show(struct device *dev,
182 struct device_attribute *attr, char *buf)
183{
184 struct acpi_device *adev = to_acpi_device(dev);
185 int state;
186 int ret;
187
188 ret = acpi_device_get_power(adev, &state);
189 if (ret)
190 return ret;
191
192 return sprintf(buf, "%s\n", acpi_power_state_string(state));
193}
194
195static DEVICE_ATTR(real_power_state, 0444, real_power_state_show, NULL);
196
197static ssize_t power_state_show(struct device *dev,
198 struct device_attribute *attr, char *buf)
199{
200 struct acpi_device *adev = to_acpi_device(dev);
201
202 return sprintf(buf, "%s\n", acpi_power_state_string(adev->power.state));
203}
204
205static DEVICE_ATTR(power_state, 0444, power_state_show, NULL);
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207static ssize_t
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800208acpi_eject_store(struct device *d, struct device_attribute *attr,
209 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
Len Brown4be44fc2005-08-05 00:44:28 -0400211 int ret = count;
Len Brown4be44fc2005-08-05 00:44:28 -0400212 acpi_status status;
Len Brown4be44fc2005-08-05 00:44:28 -0400213 acpi_object_type type = 0;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800214 struct acpi_device *acpi_device = to_acpi_device(d);
Toshi Kanic4753e52012-05-23 20:25:20 -0600215 struct acpi_eject_event *ej_event;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217 if ((!count) || (buf[0] != '1')) {
218 return -EINVAL;
219 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220#ifndef FORCE_EJECT
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800221 if (acpi_device->driver == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 ret = -ENODEV;
223 goto err;
224 }
225#endif
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800226 status = acpi_get_type(acpi_device->handle, &type);
227 if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 ret = -ENODEV;
229 goto err;
230 }
231
Toshi Kanic4753e52012-05-23 20:25:20 -0600232 ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
233 if (!ej_event) {
234 ret = -ENOMEM;
235 goto err;
236 }
237
Yinghai Lu5993c462013-01-11 22:40:41 +0000238 ej_event->device = acpi_device;
Toshi Kanic4753e52012-05-23 20:25:20 -0600239 if (acpi_device->flags.eject_pending) {
240 /* event originated from ACPI eject notification */
241 ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
242 acpi_device->flags.eject_pending = 0;
243 } else {
244 /* event originated from user */
245 ej_event->event = ACPI_OST_EC_OSPM_EJECT;
Yinghai Lu5993c462013-01-11 22:40:41 +0000246 (void) acpi_evaluate_hotplug_ost(acpi_device->handle,
Toshi Kanic4753e52012-05-23 20:25:20 -0600247 ej_event->event, ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
248 }
249
250 acpi_os_hotplug_execute(acpi_bus_hot_remove_device, (void *)ej_event);
Alok N Kataria74523c92008-06-13 12:54:24 -0400251err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800255static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800257static ssize_t
258acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
259 struct acpi_device *acpi_dev = to_acpi_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Bjorn Helgaasea8d82f2009-09-21 13:35:09 -0600261 return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800262}
263static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
264
Lv Zheng923d4a42012-10-30 14:43:26 +0100265static ssize_t acpi_device_uid_show(struct device *dev,
266 struct device_attribute *attr, char *buf)
267{
268 struct acpi_device *acpi_dev = to_acpi_device(dev);
269
270 return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
271}
272static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
273
274static ssize_t acpi_device_adr_show(struct device *dev,
275 struct device_attribute *attr, char *buf)
276{
277 struct acpi_device *acpi_dev = to_acpi_device(dev);
278
279 return sprintf(buf, "0x%08x\n",
280 (unsigned int)(acpi_dev->pnp.bus_address));
281}
282static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
283
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800284static ssize_t
285acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
286 struct acpi_device *acpi_dev = to_acpi_device(dev);
287 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
288 int result;
289
290 result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
Alex Chiang0c526d92009-05-14 08:31:37 -0600291 if (result)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800292 goto end;
293
294 result = sprintf(buf, "%s\n", (char*)path.pointer);
295 kfree(path.pointer);
Alex Chiang0c526d92009-05-14 08:31:37 -0600296end:
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800297 return result;
298}
299static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
300
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600301/* sysfs file that shows description text from the ACPI _STR method */
302static ssize_t description_show(struct device *dev,
303 struct device_attribute *attr,
304 char *buf) {
305 struct acpi_device *acpi_dev = to_acpi_device(dev);
306 int result;
307
308 if (acpi_dev->pnp.str_obj == NULL)
309 return 0;
310
311 /*
312 * The _STR object contains a Unicode identifier for a device.
313 * We need to convert to utf-8 so it can be displayed.
314 */
315 result = utf16s_to_utf8s(
316 (wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
317 acpi_dev->pnp.str_obj->buffer.length,
318 UTF16_LITTLE_ENDIAN, buf,
319 PAGE_SIZE);
320
321 buf[result++] = '\n';
322
323 return result;
324}
325static DEVICE_ATTR(description, 0444, description_show, NULL);
326
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100327static ssize_t
328acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
329 char *buf) {
330 struct acpi_device *acpi_dev = to_acpi_device(dev);
331
332 return sprintf(buf, "%lu\n", acpi_dev->pnp.sun);
333}
334static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
335
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800336static int acpi_device_setup_files(struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600338 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800339 acpi_status status;
340 acpi_handle temp;
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100341 unsigned long long sun;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800342 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800344 /*
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800345 * Devices gotten from FADT don't have a "path" attribute
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800346 */
Alex Chiang0c526d92009-05-14 08:31:37 -0600347 if (dev->handle) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800348 result = device_create_file(&dev->dev, &dev_attr_path);
Alex Chiang0c526d92009-05-14 08:31:37 -0600349 if (result)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800350 goto end;
351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200353 if (!list_empty(&dev->pnp.ids)) {
354 result = device_create_file(&dev->dev, &dev_attr_hid);
355 if (result)
356 goto end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200358 result = device_create_file(&dev->dev, &dev_attr_modalias);
359 if (result)
360 goto end;
361 }
Thomas Renninger29b71a12007-07-23 14:43:51 +0200362
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600363 /*
364 * If device has _STR, 'description' file is created
365 */
366 status = acpi_get_handle(dev->handle, "_STR", &temp);
367 if (ACPI_SUCCESS(status)) {
368 status = acpi_evaluate_object(dev->handle, "_STR",
369 NULL, &buffer);
370 if (ACPI_FAILURE(status))
371 buffer.pointer = NULL;
372 dev->pnp.str_obj = buffer.pointer;
373 result = device_create_file(&dev->dev, &dev_attr_description);
374 if (result)
375 goto end;
376 }
377
Lv Zheng923d4a42012-10-30 14:43:26 +0100378 if (dev->flags.bus_address)
379 result = device_create_file(&dev->dev, &dev_attr_adr);
380 if (dev->pnp.unique_id)
381 result = device_create_file(&dev->dev, &dev_attr_uid);
382
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100383 status = acpi_evaluate_integer(dev->handle, "_SUN", NULL, &sun);
384 if (ACPI_SUCCESS(status)) {
385 dev->pnp.sun = (unsigned long)sun;
386 result = device_create_file(&dev->dev, &dev_attr_sun);
387 if (result)
388 goto end;
389 } else {
390 dev->pnp.sun = (unsigned long)-1;
391 }
392
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800393 /*
394 * If device has _EJ0, 'eject' file is created that is used to trigger
395 * hot-removal function from userland.
396 */
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800397 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
Rafael J. Wysocki836aedb2013-01-24 12:49:59 +0100398 if (ACPI_SUCCESS(status)) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800399 result = device_create_file(&dev->dev, &dev_attr_eject);
Rafael J. Wysocki836aedb2013-01-24 12:49:59 +0100400 if (result)
401 return result;
402 }
403
404 if (dev->flags.power_manageable) {
405 result = device_create_file(&dev->dev, &dev_attr_power_state);
406 if (result)
407 return result;
408
409 if (dev->power.flags.power_resources)
410 result = device_create_file(&dev->dev,
411 &dev_attr_real_power_state);
412 }
413
Alex Chiang0c526d92009-05-14 08:31:37 -0600414end:
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800415 return result;
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800416}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800418static void acpi_device_remove_files(struct acpi_device *dev)
419{
420 acpi_status status;
421 acpi_handle temp;
422
Rafael J. Wysocki836aedb2013-01-24 12:49:59 +0100423 if (dev->flags.power_manageable) {
424 device_remove_file(&dev->dev, &dev_attr_power_state);
425 if (dev->power.flags.power_resources)
426 device_remove_file(&dev->dev,
427 &dev_attr_real_power_state);
428 }
429
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800430 /*
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600431 * If device has _STR, remove 'description' file
432 */
433 status = acpi_get_handle(dev->handle, "_STR", &temp);
434 if (ACPI_SUCCESS(status)) {
435 kfree(dev->pnp.str_obj);
436 device_remove_file(&dev->dev, &dev_attr_description);
437 }
438 /*
439 * If device has _EJ0, remove 'eject' file.
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800440 */
441 status = acpi_get_handle(dev->handle, "_EJ0", &temp);
442 if (ACPI_SUCCESS(status))
443 device_remove_file(&dev->dev, &dev_attr_eject);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800444
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100445 status = acpi_get_handle(dev->handle, "_SUN", &temp);
446 if (ACPI_SUCCESS(status))
447 device_remove_file(&dev->dev, &dev_attr_sun);
448
Lv Zheng923d4a42012-10-30 14:43:26 +0100449 if (dev->pnp.unique_id)
450 device_remove_file(&dev->dev, &dev_attr_uid);
451 if (dev->flags.bus_address)
452 device_remove_file(&dev->dev, &dev_attr_adr);
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600453 device_remove_file(&dev->dev, &dev_attr_modalias);
454 device_remove_file(&dev->dev, &dev_attr_hid);
Alex Chiang0c526d92009-05-14 08:31:37 -0600455 if (dev->handle)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800456 device_remove_file(&dev->dev, &dev_attr_path);
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800457}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458/* --------------------------------------------------------------------------
Zhang Rui9e89dde2006-12-07 20:56:16 +0800459 ACPI Bus operations
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 -------------------------------------------------------------------------- */
Thomas Renninger29b71a12007-07-23 14:43:51 +0200461
Mika Westerbergcf761af2012-10-31 22:44:41 +0100462static const struct acpi_device_id *__acpi_match_device(
463 struct acpi_device *device, const struct acpi_device_id *ids)
Thomas Renninger29b71a12007-07-23 14:43:51 +0200464{
465 const struct acpi_device_id *id;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600466 struct acpi_hardware_id *hwid;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200467
Zhao Yakui39a0ad82008-08-11 13:40:22 +0800468 /*
469 * If the device is not present, it is unnecessary to load device
470 * driver for it.
471 */
472 if (!device->status.present)
Mika Westerbergcf761af2012-10-31 22:44:41 +0100473 return NULL;
Zhao Yakui39a0ad82008-08-11 13:40:22 +0800474
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600475 for (id = ids; id->id[0]; id++)
476 list_for_each_entry(hwid, &device->pnp.ids, list)
477 if (!strcmp((char *) id->id, hwid->id))
Mika Westerbergcf761af2012-10-31 22:44:41 +0100478 return id;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200479
Mika Westerbergcf761af2012-10-31 22:44:41 +0100480 return NULL;
481}
482
483/**
484 * acpi_match_device - Match a struct device against a given list of ACPI IDs
485 * @ids: Array of struct acpi_device_id object to match against.
486 * @dev: The device structure to match.
487 *
488 * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
489 * object for that handle and use that object to match against a given list of
490 * device IDs.
491 *
492 * Return a pointer to the first matching ID on success or %NULL on failure.
493 */
494const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
495 const struct device *dev)
496{
497 struct acpi_device *adev;
498
Rafael J. Wysocki95f8a082012-11-21 00:21:50 +0100499 if (!ids || !ACPI_HANDLE(dev)
500 || ACPI_FAILURE(acpi_bus_get_device(ACPI_HANDLE(dev), &adev)))
Mika Westerbergcf761af2012-10-31 22:44:41 +0100501 return NULL;
502
503 return __acpi_match_device(adev, ids);
504}
505EXPORT_SYMBOL_GPL(acpi_match_device);
506
507int acpi_match_device_ids(struct acpi_device *device,
508 const struct acpi_device_id *ids)
509{
510 return __acpi_match_device(device, ids) ? 0 : -ENOENT;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200511}
512EXPORT_SYMBOL(acpi_match_device_ids);
513
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +0100514void acpi_free_ids(struct acpi_device *device)
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600515{
516 struct acpi_hardware_id *id, *tmp;
517
518 list_for_each_entry_safe(id, tmp, &device->pnp.ids, list) {
519 kfree(id->id);
520 kfree(id);
521 }
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100522 kfree(device->pnp.unique_id);
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600523}
524
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100525static void acpi_free_power_resources_lists(struct acpi_device *device)
526{
527 int i;
528
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100529 if (device->wakeup.flags.valid)
530 acpi_power_resources_list_free(&device->wakeup.resources);
531
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100532 if (!device->flags.power_manageable)
533 return;
534
535 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
536 struct acpi_device_power_state *ps = &device->power.states[i];
537 acpi_power_resources_list_free(&ps->resources);
538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539}
540
Patrick Mochel1890a972006-12-07 20:56:31 +0800541static void acpi_device_release(struct device *dev)
542{
543 struct acpi_device *acpi_dev = to_acpi_device(dev);
544
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600545 acpi_free_ids(acpi_dev);
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100546 acpi_free_power_resources_lists(acpi_dev);
Patrick Mochel1890a972006-12-07 20:56:31 +0800547 kfree(acpi_dev);
548}
549
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800550static int acpi_bus_match(struct device *dev, struct device_driver *drv)
551{
552 struct acpi_device *acpi_dev = to_acpi_device(dev);
553 struct acpi_driver *acpi_drv = to_acpi_driver(drv);
554
Rafael J. Wysocki209d3b12012-12-21 00:36:48 +0100555 return acpi_dev->flags.match_driver
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +0100556 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800557}
558
Kay Sievers7eff2e72007-08-14 15:15:12 +0200559static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800560{
561 struct acpi_device *acpi_dev = to_acpi_device(dev);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200562 int len;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800563
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +0200564 if (list_empty(&acpi_dev->pnp.ids))
565 return 0;
566
Kay Sievers7eff2e72007-08-14 15:15:12 +0200567 if (add_uevent_var(env, "MODALIAS="))
568 return -ENOMEM;
569 len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
570 sizeof(env->buf) - env->buflen);
571 if (len >= (sizeof(env->buf) - env->buflen))
572 return -ENOMEM;
573 env->buflen += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return 0;
575}
576
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000577static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
578{
579 struct acpi_device *device = data;
580
581 device->driver->ops.notify(device, event);
582}
583
584static acpi_status acpi_device_notify_fixed(void *data)
585{
586 struct acpi_device *device = data;
587
Bjorn Helgaas53de5352009-08-31 22:32:20 +0000588 /* Fixed hardware devices have no handles */
589 acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000590 return AE_OK;
591}
592
593static int acpi_device_install_notify_handler(struct acpi_device *device)
594{
595 acpi_status status;
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000596
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000597 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000598 status =
599 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
600 acpi_device_notify_fixed,
601 device);
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000602 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000603 status =
604 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
605 acpi_device_notify_fixed,
606 device);
607 else
608 status = acpi_install_notify_handler(device->handle,
609 ACPI_DEVICE_NOTIFY,
610 acpi_device_notify,
611 device);
612
613 if (ACPI_FAILURE(status))
614 return -EINVAL;
615 return 0;
616}
617
618static void acpi_device_remove_notify_handler(struct acpi_device *device)
619{
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000620 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000621 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
622 acpi_device_notify_fixed);
Bjorn Helgaasccba2a32009-09-21 19:29:15 +0000623 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000624 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
625 acpi_device_notify_fixed);
626 else
627 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
628 acpi_device_notify);
629}
630
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800631static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800632static int acpi_device_probe(struct device * dev)
Zhang Rui9e89dde2006-12-07 20:56:16 +0800633{
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800634 struct acpi_device *acpi_dev = to_acpi_device(dev);
635 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
636 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800638 ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
639 if (!ret) {
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000640 if (acpi_drv->ops.notify) {
641 ret = acpi_device_install_notify_handler(acpi_dev);
642 if (ret) {
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000643 if (acpi_drv->ops.remove)
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100644 acpi_drv->ops.remove(acpi_dev);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000645 return ret;
646 }
647 }
648
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800649 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
650 "Found driver [%s] for device [%s]\n",
651 acpi_drv->name, acpi_dev->pnp.bus_id));
652 get_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800653 }
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800654 return ret;
655}
656
657static int acpi_device_remove(struct device * dev)
658{
659 struct acpi_device *acpi_dev = to_acpi_device(dev);
660 struct acpi_driver *acpi_drv = acpi_dev->driver;
661
662 if (acpi_drv) {
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000663 if (acpi_drv->ops.notify)
664 acpi_device_remove_notify_handler(acpi_dev);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800665 if (acpi_drv->ops.remove)
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100666 acpi_drv->ops.remove(acpi_dev);
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800667 }
668 acpi_dev->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700669 acpi_dev->driver_data = NULL;
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800670
671 put_device(dev);
Zhang Rui9e89dde2006-12-07 20:56:16 +0800672 return 0;
673}
674
David Brownell55955aa2007-05-08 00:28:35 -0700675struct bus_type acpi_bus_type = {
Zhang Rui9e89dde2006-12-07 20:56:16 +0800676 .name = "acpi",
Patrick Mochel5d9464a2006-12-07 20:56:27 +0800677 .match = acpi_bus_match,
678 .probe = acpi_device_probe,
679 .remove = acpi_device_remove,
680 .uevent = acpi_device_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681};
682
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100683int acpi_device_add(struct acpi_device *device,
684 void (*release)(struct device *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800686 int result;
687 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
688 int found = 0;
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000689
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100690 if (device->handle) {
691 acpi_status status;
692
693 status = acpi_attach_data(device->handle, acpi_bus_data_handler,
694 device);
695 if (ACPI_FAILURE(status)) {
696 acpi_handle_err(device->handle,
697 "Unable to attach device data\n");
698 return -ENODEV;
699 }
700 }
701
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 /*
703 * Linkage
704 * -------
705 * Link this device to its parent and siblings.
706 */
707 INIT_LIST_HEAD(&device->children);
708 INIT_LIST_HEAD(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 INIT_LIST_HEAD(&device->wakeup_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800710 INIT_LIST_HEAD(&device->physical_node_list);
711 mutex_init(&device->physical_node_lock);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100712 INIT_LIST_HEAD(&device->power_dependent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800714 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
715 if (!new_bus_id) {
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100716 pr_err(PREFIX "Memory allocation error\n");
717 result = -ENOMEM;
718 goto err_detach;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800719 }
720
Shaohua Li90905892009-04-07 10:24:29 +0800721 mutex_lock(&acpi_device_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800722 /*
723 * Find suitable bus_id and instance number in acpi_bus_id_list
724 * If failed, create one and link it into acpi_bus_id_list
725 */
726 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600727 if (!strcmp(acpi_device_bus_id->bus_id,
728 acpi_device_hid(device))) {
729 acpi_device_bus_id->instance_no++;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800730 found = 1;
731 kfree(new_bus_id);
732 break;
733 }
734 }
Alex Chiang0c526d92009-05-14 08:31:37 -0600735 if (!found) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800736 acpi_device_bus_id = new_bus_id;
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600737 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800738 acpi_device_bus_id->instance_no = 0;
739 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
740 }
Kay Sievers07944692008-10-30 01:18:59 +0100741 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 +0800742
Len Brown33b57152008-12-15 22:09:26 -0500743 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 list_add_tail(&device->node, &device->parent->children);
Len Brown33b57152008-12-15 22:09:26 -0500745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 if (device->wakeup.flags.valid)
747 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
Shaohua Li90905892009-04-07 10:24:29 +0800748 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Patrick Mochel1890a972006-12-07 20:56:31 +0800750 if (device->parent)
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000751 device->dev.parent = &device->parent->dev;
Patrick Mochel1890a972006-12-07 20:56:31 +0800752 device->dev.bus = &acpi_bus_type;
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +0100753 device->dev.release = release;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100754 result = device_add(&device->dev);
Alex Chiang0c526d92009-05-14 08:31:37 -0600755 if (result) {
Alex Chiang8b12b922009-05-14 08:31:32 -0600756 dev_err(&device->dev, "Error registering device\n");
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100757 goto err;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800758 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800759
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800760 result = acpi_device_setup_files(device);
Alex Chiang0c526d92009-05-14 08:31:37 -0600761 if (result)
Kay Sievers07944692008-10-30 01:18:59 +0100762 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
763 dev_name(&device->dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800764
Li Shaohua96333572006-12-07 20:56:46 +0800765 device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800766 return 0;
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100767
768 err:
Shaohua Li90905892009-04-07 10:24:29 +0800769 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500770 if (device->parent)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800771 list_del(&device->node);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800772 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800773 mutex_unlock(&acpi_device_lock);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100774
775 err_detach:
776 acpi_detach_data(device->handle, acpi_bus_data_handler);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800777 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
Rafael J. Wysockib17b5372013-01-15 13:23:44 +0100780static void acpi_device_unregister(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
Shaohua Li90905892009-04-07 10:24:29 +0800782 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500783 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 list_del(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
786 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800787 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 acpi_detach_data(device->handle, acpi_bus_data_handler);
Patrick Mochel1890a972006-12-07 20:56:31 +0800790
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100791 acpi_power_add_remove_device(device, false);
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800792 acpi_device_remove_files(device);
Rafael J. Wysockib1c0f992013-01-24 12:50:09 +0100793 if (device->remove)
794 device->remove(device);
795
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100796 device_del(&device->dev);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100797 /*
798 * Drop the reference counts of all power resources the device depends
799 * on and turn off the ones that have no more references.
800 */
801 acpi_power_transition(device, ACPI_STATE_D3_COLD);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100802 put_device(&device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803}
804
Zhang Rui9e89dde2006-12-07 20:56:16 +0800805/* --------------------------------------------------------------------------
806 Driver Management
807 -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500809 * acpi_bus_driver_init - add a device to a driver
810 * @device: the device to add and initialize
811 * @driver: driver for the device
812 *
Alex Chiang0c526d92009-05-14 08:31:37 -0600813 * Used to initialize a device via its device driver. Called whenever a
Patrick Mochel1890a972006-12-07 20:56:31 +0800814 * driver is bound to a device. Invokes the driver's add() ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 */
816static int
Len Brown4be44fc2005-08-05 00:44:28 -0400817acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
Len Brown4be44fc2005-08-05 00:44:28 -0400819 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (!device || !driver)
Patrick Mocheld550d982006-06-27 00:41:40 -0400822 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824 if (!driver->ops.add)
Patrick Mocheld550d982006-06-27 00:41:40 -0400825 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
827 result = driver->ops.add(device);
828 if (result) {
829 device->driver = NULL;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700830 device->driver_data = NULL;
Patrick Mocheld550d982006-06-27 00:41:40 -0400831 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 }
833
834 device->driver = driver;
835
836 /*
837 * TBD - Configuration Management: Assign resources to device based
838 * upon possible configuration and currently allocated resources.
839 */
840
Len Brown4be44fc2005-08-05 00:44:28 -0400841 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
842 "Driver successfully bound to device\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400843 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -0700844}
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500847 * acpi_bus_register_driver - register a driver with the ACPI bus
848 * @driver: driver being registered
849 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 * Registers a driver with the ACPI bus. Searches the namespace for all
Bjorn Helgaas9d9f7492006-03-28 17:04:00 -0500851 * devices that match the driver's criteria and binds. Returns zero for
852 * success or a negative error status for failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 */
Len Brown4be44fc2005-08-05 00:44:28 -0400854int acpi_bus_register_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
Patrick Mochel1890a972006-12-07 20:56:31 +0800856 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
858 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400859 return -ENODEV;
Patrick Mochel1890a972006-12-07 20:56:31 +0800860 driver->drv.name = driver->name;
861 driver->drv.bus = &acpi_bus_type;
862 driver->drv.owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Patrick Mochel1890a972006-12-07 20:56:31 +0800864 ret = driver_register(&driver->drv);
865 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Len Brown4be44fc2005-08-05 00:44:28 -0400868EXPORT_SYMBOL(acpi_bus_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870/**
Randy Dunlapd758a8f2006-01-06 01:31:00 -0500871 * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
872 * @driver: driver to unregister
873 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 * Unregisters a driver with the ACPI bus. Searches the namespace for all
875 * devices that match the driver's criteria and unbinds.
876 */
Bjorn Helgaas06ea8e082006-04-27 05:25:00 -0400877void acpi_bus_unregister_driver(struct acpi_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Patrick Mochel1890a972006-12-07 20:56:31 +0800879 driver_unregister(&driver->drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880}
Len Brown4be44fc2005-08-05 00:44:28 -0400881
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882EXPORT_SYMBOL(acpi_bus_unregister_driver);
883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884/* --------------------------------------------------------------------------
885 Device Enumeration
886 -------------------------------------------------------------------------- */
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000887static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
888{
889 acpi_status status;
890 int ret;
891 struct acpi_device *device;
892
893 /*
894 * Fixed hardware devices do not appear in the namespace and do not
895 * have handles, but we fabricate acpi_devices for them, so we have
896 * to deal with them specially.
897 */
898 if (handle == NULL)
899 return acpi_root;
900
901 do {
902 status = acpi_get_parent(handle, &handle);
903 if (status == AE_NULL_ENTRY)
904 return NULL;
905 if (ACPI_FAILURE(status))
906 return acpi_root;
907
908 ret = acpi_bus_get_device(handle, &device);
909 if (ret == 0)
910 return device;
911 } while (1);
912}
913
Len Brownc8f7a622006-07-09 17:22:28 -0400914acpi_status
915acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
916{
917 acpi_status status;
918 acpi_handle tmp;
919 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
920 union acpi_object *obj;
921
922 status = acpi_get_handle(handle, "_EJD", &tmp);
923 if (ACPI_FAILURE(status))
924 return status;
925
926 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
927 if (ACPI_SUCCESS(status)) {
928 obj = buffer.pointer;
Holger Macht3b5fee52008-02-14 13:40:34 +0100929 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
930 ejd);
Len Brownc8f7a622006-07-09 17:22:28 -0400931 kfree(buffer.pointer);
932 }
933 return status;
934}
935EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
936
Bob Moore8e4319c2009-06-29 13:43:27 +0800937void acpi_bus_data_handler(acpi_handle handle, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938{
939
940 /* TBD */
941
942 return;
943}
944
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100945static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
946 struct acpi_device_wakeup *wakeup)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947{
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100948 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
949 union acpi_object *package = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 union acpi_object *element = NULL;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100951 acpi_status status;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100952 int err = -ENODATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100954 if (!wakeup)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100955 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100957 INIT_LIST_HEAD(&wakeup->resources);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100959 /* _PRW */
960 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
961 if (ACPI_FAILURE(status)) {
962 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100963 return err;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100964 }
965
966 package = (union acpi_object *)buffer.pointer;
967
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100968 if (!package || package->package.count < 2)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100969 goto out;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 element = &(package->package.elements[0]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100972 if (!element)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100973 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 if (element->type == ACPI_TYPE_PACKAGE) {
976 if ((element->package.count < 2) ||
977 (element->package.elements[0].type !=
978 ACPI_TYPE_LOCAL_REFERENCE)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100979 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100980 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100981
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100982 wakeup->gpe_device =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 element->package.elements[0].reference.handle;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100984 wakeup->gpe_number =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 (u32) element->package.elements[1].integer.value;
986 } else if (element->type == ACPI_TYPE_INTEGER) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100987 wakeup->gpe_device = NULL;
988 wakeup->gpe_number = element->integer.value;
989 } else {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100990 goto out;
991 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 element = &(package->package.elements[1]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100994 if (element->type != ACPI_TYPE_INTEGER)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100995 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100996
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100997 wakeup->sleep_state = element->integer.value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100999 err = acpi_extract_power_resources(package, 2, &wakeup->resources);
1000 if (err)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001001 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002
Rafael J. Wysocki0596a522013-01-17 14:11:07 +01001003 if (!list_empty(&wakeup->resources)) {
1004 int sleep_state;
1005
1006 sleep_state = acpi_power_min_system_level(&wakeup->resources);
1007 if (sleep_state < wakeup->sleep_state) {
1008 acpi_handle_warn(handle, "Overriding _PRW sleep state "
1009 "(S%d) by S%d from power resources\n",
1010 (int)wakeup->sleep_state, sleep_state);
1011 wakeup->sleep_state = sleep_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 }
Lin Mingbba63a22010-12-13 13:39:17 +08001014 acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
Rafael J. Wysocki98746472010-07-08 00:43:36 +02001015
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001016 out:
1017 kfree(buffer.pointer);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +01001018 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019}
1020
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001021static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022{
Thomas Renninger29b71a12007-07-23 14:43:51 +02001023 struct acpi_device_id button_device_ids[] = {
Thomas Renninger29b71a12007-07-23 14:43:51 +02001024 {"PNP0C0C", 0},
Zhang Ruib7e38302012-12-04 23:23:16 +01001025 {"PNP0C0D", 0},
Thomas Renninger29b71a12007-07-23 14:43:51 +02001026 {"PNP0C0E", 0},
1027 {"", 0},
1028 };
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001029 acpi_status status;
1030 acpi_event_status event_status;
1031
Rafael J. Wysockib67ea762010-02-17 23:44:09 +01001032 device->wakeup.flags.notifier_present = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001033
1034 /* Power button, Lid switch always enable wakeup */
1035 if (!acpi_match_device_ids(device, button_device_ids)) {
1036 device->wakeup.flags.run_wake = 1;
Zhang Ruib7e38302012-12-04 23:23:16 +01001037 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
1038 /* Do not use Lid/sleep button for S5 wakeup */
1039 if (device->wakeup.sleep_state == ACPI_STATE_S5)
1040 device->wakeup.sleep_state = ACPI_STATE_S4;
1041 }
Rafael J. Wysockif2b56bc2011-01-06 23:34:22 +01001042 device_set_wakeup_capable(&device->dev, true);
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001043 return;
1044 }
1045
Rafael J. Wysockie8e18c92010-07-08 00:42:51 +02001046 status = acpi_get_gpe_status(device->wakeup.gpe_device,
1047 device->wakeup.gpe_number,
1048 &event_status);
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001049 if (status == AE_OK)
1050 device->wakeup.flags.run_wake =
1051 !!(event_status & ACPI_EVENT_FLAG_HANDLE);
1052}
1053
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001054static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001055{
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001056 acpi_handle temp;
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001057 acpi_status status = 0;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +01001058 int err;
Thomas Renninger29b71a12007-07-23 14:43:51 +02001059
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001060 /* Presence of _PRW indicates wake capable */
1061 status = acpi_get_handle(device->handle, "_PRW", &temp);
1062 if (ACPI_FAILURE(status))
1063 return;
1064
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +01001065 err = acpi_bus_extract_wakeup_device_power_package(device->handle,
1066 &device->wakeup);
1067 if (err) {
1068 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001069 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
1071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 device->wakeup.flags.valid = 1;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +02001073 device->wakeup.prepare_count = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +01001074 acpi_bus_set_run_wake_flags(device);
Zhao Yakui729b2bd2008-03-19 13:26:54 +08001075 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
1076 * system for the ACPI device with the _PRW object.
1077 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
1078 * So it is necessary to call _DSW object first. Only when it is not
1079 * present will the _PSW object used.
1080 */
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +01001081 err = acpi_device_sleep_wake(device, 0, 0, 0);
1082 if (err)
Rafael J. Wysocki77e76602008-07-07 03:33:34 +02001083 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1084 "error in _DSW or _PSW evaluation\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085}
1086
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001087static void acpi_bus_init_power_state(struct acpi_device *device, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088{
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001089 struct acpi_device_power_state *ps = &device->power.states[state];
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001090 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
1091 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001092 acpi_handle handle;
1093 acpi_status status;
Zhang Rui9e89dde2006-12-07 20:56:16 +08001094
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001095 INIT_LIST_HEAD(&ps->resources);
1096
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001097 /* Evaluate "_PRx" to get referenced power resources */
1098 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
1099 if (ACPI_SUCCESS(status)) {
1100 union acpi_object *package = buffer.pointer;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001101
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001102 if (buffer.length && package
1103 && package->type == ACPI_TYPE_PACKAGE
1104 && package->package.count) {
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +01001105 int err = acpi_extract_power_resources(package, 0,
1106 &ps->resources);
1107 if (!err)
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001108 device->power.flags.power_resources = 1;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001109 }
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001110 ACPI_FREE(buffer.pointer);
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001111 }
1112
1113 /* Evaluate "_PSx" to see if we can do explicit sets */
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001114 pathname[2] = 'S';
1115 status = acpi_get_handle(device->handle, pathname, &handle);
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001116 if (ACPI_SUCCESS(status))
1117 ps->flags.explicit_set = 1;
1118
1119 /*
1120 * State is valid if there are means to put the device into it.
1121 * D3hot is only valid if _PR3 present.
1122 */
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +01001123 if (!list_empty(&ps->resources)
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001124 || (ps->flags.explicit_set && state < ACPI_STATE_D3_HOT)) {
1125 ps->flags.valid = 1;
1126 ps->flags.os_accessible = 1;
1127 }
1128
1129 ps->power = -1; /* Unknown - driver assigned */
1130 ps->latency = -1; /* Unknown - driver assigned */
1131}
1132
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001133static void acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134{
Rafael J. Wysocki8bc50532013-01-17 14:11:07 +01001135 acpi_status status;
1136 acpi_handle handle;
1137 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001139 /* Presence of _PS0|_PR0 indicates 'power manageable' */
1140 status = acpi_get_handle(device->handle, "_PS0", &handle);
1141 if (ACPI_FAILURE(status)) {
1142 status = acpi_get_handle(device->handle, "_PR0", &handle);
1143 if (ACPI_FAILURE(status))
1144 return;
1145 }
1146
1147 device->flags.power_manageable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
1149 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +08001150 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 */
Zhang Rui9e89dde2006-12-07 20:56:16 +08001152 status = acpi_get_handle(device->handle, "_PSC", &handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 if (ACPI_SUCCESS(status))
Zhang Rui9e89dde2006-12-07 20:56:16 +08001154 device->power.flags.explicit_get = 1;
1155 status = acpi_get_handle(device->handle, "_IRC", &handle);
1156 if (ACPI_SUCCESS(status))
1157 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
1159 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +08001160 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 */
Rafael J. Wysockif33ce562013-01-17 14:11:06 +01001162 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
1163 acpi_bus_init_power_state(device, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Rafael J. Wysocki0b224522013-01-17 14:11:06 +01001165 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Zhang Rui9e89dde2006-12-07 20:56:16 +08001167 /* Set defaults for D0 and D3 states (always valid) */
1168 device->power.states[ACPI_STATE_D0].flags.valid = 1;
1169 device->power.states[ACPI_STATE_D0].power = 100;
1170 device->power.states[ACPI_STATE_D3].flags.valid = 1;
1171 device->power.states[ACPI_STATE_D3].power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Rafael J. Wysocki5c7dd712012-05-18 00:39:35 +02001173 /* Set D3cold's explicit_set flag if _PS3 exists. */
1174 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
1175 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
1176
Aaron Lu1399dfc2012-11-21 23:33:40 +01001177 /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
1178 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
1179 device->power.flags.power_resources)
1180 device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
1181
Rafael J. Wysockiade3e7f2010-11-25 00:08:36 +01001182 acpi_bus_init_power(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183}
1184
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001185static void acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186{
Len Brown4be44fc2005-08-05 00:44:28 -04001187 acpi_status status = AE_OK;
1188 acpi_handle temp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 /* Presence of _STA indicates 'dynamic_status' */
1191 status = acpi_get_handle(device->handle, "_STA", &temp);
1192 if (ACPI_SUCCESS(status))
1193 device->flags.dynamic_status = 1;
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 /* Presence of _RMV indicates 'removable' */
1196 status = acpi_get_handle(device->handle, "_RMV", &temp);
1197 if (ACPI_SUCCESS(status))
1198 device->flags.removable = 1;
1199
1200 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1201 status = acpi_get_handle(device->handle, "_EJD", &temp);
1202 if (ACPI_SUCCESS(status))
1203 device->flags.ejectable = 1;
1204 else {
1205 status = acpi_get_handle(device->handle, "_EJ0", &temp);
1206 if (ACPI_SUCCESS(status))
1207 device->flags.ejectable = 1;
1208 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209}
1210
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001211static void acpi_device_get_busid(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212{
Len Brown4be44fc2005-08-05 00:44:28 -04001213 char bus_id[5] = { '?', 0 };
1214 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1215 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
1217 /*
1218 * Bus ID
1219 * ------
1220 * The device's Bus ID is simply the object name.
1221 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1222 */
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001223 if (ACPI_IS_ROOT_DEVICE(device)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 strcpy(device->pnp.bus_id, "ACPI");
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001225 return;
1226 }
1227
1228 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 case ACPI_BUS_TYPE_POWER_BUTTON:
1230 strcpy(device->pnp.bus_id, "PWRF");
1231 break;
1232 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1233 strcpy(device->pnp.bus_id, "SLPF");
1234 break;
1235 default:
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001236 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 /* Clean up trailing underscores (if any) */
1238 for (i = 3; i > 1; i--) {
1239 if (bus_id[i] == '_')
1240 bus_id[i] = '\0';
1241 else
1242 break;
1243 }
1244 strcpy(device->pnp.bus_id, bus_id);
1245 break;
1246 }
1247}
1248
Zhang Rui54735262007-01-11 02:09:09 -05001249/*
1250 * acpi_bay_match - see if a device is an ejectable driver bay
1251 *
1252 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1253 * then we can safely call it an ejectable drive bay
1254 */
1255static int acpi_bay_match(struct acpi_device *device){
1256 acpi_status status;
1257 acpi_handle handle;
1258 acpi_handle tmp;
1259 acpi_handle phandle;
1260
1261 handle = device->handle;
1262
1263 status = acpi_get_handle(handle, "_EJ0", &tmp);
1264 if (ACPI_FAILURE(status))
1265 return -ENODEV;
1266
1267 if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
1268 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
1269 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
1270 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
1271 return 0;
1272
1273 if (acpi_get_parent(handle, &phandle))
1274 return -ENODEV;
1275
1276 if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
1277 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
1278 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
1279 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
1280 return 0;
1281
1282 return -ENODEV;
1283}
1284
Frank Seidel3620f2f2007-12-07 13:20:34 +01001285/*
1286 * acpi_dock_match - see if a device has a _DCK method
1287 */
1288static int acpi_dock_match(struct acpi_device *device)
1289{
1290 acpi_handle tmp;
1291 return acpi_get_handle(device->handle, "_DCK", &tmp);
1292}
1293
Thomas Renninger620e1122010-10-01 10:54:00 +02001294const char *acpi_device_hid(struct acpi_device *device)
Bob Moore15b8dd52009-06-29 13:39:29 +08001295{
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001296 struct acpi_hardware_id *hid;
Bob Moore15b8dd52009-06-29 13:39:29 +08001297
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +02001298 if (list_empty(&device->pnp.ids))
1299 return dummy_hid;
1300
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001301 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1302 return hid->id;
1303}
1304EXPORT_SYMBOL(acpi_device_hid);
Bob Moore15b8dd52009-06-29 13:39:29 +08001305
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001306static void acpi_add_id(struct acpi_device *device, const char *dev_id)
1307{
1308 struct acpi_hardware_id *id;
Bob Moore15b8dd52009-06-29 13:39:29 +08001309
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001310 id = kmalloc(sizeof(*id), GFP_KERNEL);
1311 if (!id)
1312 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001313
Thomas Meyer581de592011-08-06 11:32:56 +02001314 id->id = kstrdup(dev_id, GFP_KERNEL);
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001315 if (!id->id) {
1316 kfree(id);
1317 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001318 }
1319
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001320 list_add_tail(&id->list, &device->pnp.ids);
Bob Moore15b8dd52009-06-29 13:39:29 +08001321}
1322
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001323/*
1324 * Old IBM workstations have a DSDT bug wherein the SMBus object
1325 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1326 * prefix. Work around this.
1327 */
1328static int acpi_ibm_smbus_match(struct acpi_device *device)
1329{
1330 acpi_handle h_dummy;
1331 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
1332 int result;
1333
1334 if (!dmi_name_in_vendors("IBM"))
1335 return -ENODEV;
1336
1337 /* Look for SMBS object */
1338 result = acpi_get_name(device->handle, ACPI_SINGLE_NAME, &path);
1339 if (result)
1340 return result;
1341
1342 if (strcmp("SMBS", path.pointer)) {
1343 result = -ENODEV;
1344 goto out;
1345 }
1346
1347 /* Does it have the necessary (but misnamed) methods? */
1348 result = -ENODEV;
1349 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "SBI", &h_dummy)) &&
1350 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBR", &h_dummy)) &&
1351 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBW", &h_dummy)))
1352 result = 0;
1353out:
1354 kfree(path.pointer);
1355 return result;
1356}
1357
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001358static void acpi_device_set_id(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359{
Len Brown4be44fc2005-08-05 00:44:28 -04001360 acpi_status status;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001361 struct acpi_device_info *info;
Lv Zheng78e25fe2012-10-31 02:25:24 +00001362 struct acpi_pnp_device_id_list *cid_list;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001363 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001365 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 case ACPI_BUS_TYPE_DEVICE:
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001367 if (ACPI_IS_ROOT_DEVICE(device)) {
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001368 acpi_add_id(device, ACPI_SYSTEM_HID);
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001369 break;
1370 }
1371
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001372 status = acpi_get_object_info(device->handle, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 if (ACPI_FAILURE(status)) {
Harvey Harrison96b2dd12008-03-05 18:24:51 -08001374 printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 return;
1376 }
1377
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 if (info->valid & ACPI_VALID_HID)
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001379 acpi_add_id(device, info->hardware_id.string);
1380 if (info->valid & ACPI_VALID_CID) {
Bob Moore15b8dd52009-06-29 13:39:29 +08001381 cid_list = &info->compatible_id_list;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001382 for (i = 0; i < cid_list->count; i++)
1383 acpi_add_id(device, cid_list->ids[i].string);
1384 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 if (info->valid & ACPI_VALID_ADR) {
1386 device->pnp.bus_address = info->address;
1387 device->flags.bus_address = 1;
1388 }
Lv Zhengccf78042012-10-30 14:41:07 +01001389 if (info->valid & ACPI_VALID_UID)
1390 device->pnp.unique_id = kstrdup(info->unique_id.string,
1391 GFP_KERNEL);
Zhang Ruiae843332006-12-07 20:57:10 +08001392
Bjorn Helgaasa83893ae2009-10-02 11:03:12 -04001393 kfree(info);
1394
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001395 /*
1396 * Some devices don't reliably have _HIDs & _CIDs, so add
1397 * synthetic HIDs to make sure drivers can find them.
1398 */
Thomas Renningerc3d6de62008-08-01 17:37:55 +02001399 if (acpi_is_video_device(device))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001400 acpi_add_id(device, ACPI_VIDEO_HID);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001401 else if (ACPI_SUCCESS(acpi_bay_match(device)))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001402 acpi_add_id(device, ACPI_BAY_HID);
Frank Seidel3620f2f2007-12-07 13:20:34 +01001403 else if (ACPI_SUCCESS(acpi_dock_match(device)))
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001404 acpi_add_id(device, ACPI_DOCK_HID);
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001405 else if (!acpi_ibm_smbus_match(device))
1406 acpi_add_id(device, ACPI_SMBUS_IBM_HID);
Rafael J. Wysocki4f5f64c2013-01-04 23:00:54 +01001407 else if (list_empty(&device->pnp.ids) &&
Bjorn Helgaasb7b30de2010-03-24 10:44:33 -06001408 ACPI_IS_ROOT_DEVICE(device->parent)) {
1409 acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
1410 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1411 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1412 }
Zhang Rui54735262007-01-11 02:09:09 -05001413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 break;
1415 case ACPI_BUS_TYPE_POWER:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001416 acpi_add_id(device, ACPI_POWER_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 break;
1418 case ACPI_BUS_TYPE_PROCESSOR:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001419 acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 case ACPI_BUS_TYPE_THERMAL:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001422 acpi_add_id(device, ACPI_THERMAL_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 break;
1424 case ACPI_BUS_TYPE_POWER_BUTTON:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001425 acpi_add_id(device, ACPI_BUTTON_HID_POWERF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 break;
1427 case ACPI_BUS_TYPE_SLEEP_BUTTON:
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001428 acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 break;
1430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431}
1432
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001433void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1434 int type, unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435{
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001436 INIT_LIST_HEAD(&device->pnp.ids);
1437 device->device_type = type;
1438 device->handle = handle;
1439 device->parent = acpi_bus_get_parent(handle);
1440 STRUCT_TO_INT(device->status) = sta;
1441 acpi_device_get_busid(device);
1442 acpi_device_set_id(device);
1443 acpi_bus_get_flags(device);
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001444 device->flags.match_driver = false;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001445 device_initialize(&device->dev);
1446 dev_set_uevent_suppress(&device->dev, true);
1447}
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001448
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001449void acpi_device_add_finalize(struct acpi_device *device)
1450{
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001451 device->flags.match_driver = true;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001452 dev_set_uevent_suppress(&device->dev, false);
1453 kobject_uevent(&device->dev.kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
1455
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001456static int acpi_add_single_object(struct acpi_device **child,
1457 acpi_handle handle, int type,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001458 unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459{
Bjorn Helgaas77c24882009-09-21 19:29:30 +00001460 int result;
1461 struct acpi_device *device;
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001462 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
Burman Yan36bcbec2006-12-19 12:56:11 -08001464 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001466 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001467 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001470 acpi_init_device_object(device, handle, type, sta);
1471 acpi_bus_get_power_flags(device);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001472 acpi_bus_get_wakeup_device_flags(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001474 result = acpi_device_add(device, acpi_device_release);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001475 if (result) {
Hugh Dickins718fb0d2009-08-06 23:18:12 +00001476 acpi_device_release(&device->dev);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001477 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 }
1479
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001480 acpi_power_add_remove_device(device, true);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001481 acpi_device_add_finalize(device);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001482 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1483 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1484 dev_name(&device->dev), (char *) buffer.pointer,
1485 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1486 kfree(buffer.pointer);
1487 *child = device;
1488 return 0;
Rafael J. Wysockibf325f92010-11-25 00:10:44 +01001489}
1490
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001491static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1492 unsigned long long *sta)
1493{
1494 acpi_status status;
1495 acpi_object_type acpi_type;
1496
1497 status = acpi_get_type(handle, &acpi_type);
1498 if (ACPI_FAILURE(status))
1499 return -ENODEV;
1500
1501 switch (acpi_type) {
1502 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
1503 case ACPI_TYPE_DEVICE:
1504 *type = ACPI_BUS_TYPE_DEVICE;
1505 status = acpi_bus_get_status_handle(handle, sta);
1506 if (ACPI_FAILURE(status))
1507 return -ENODEV;
1508 break;
1509 case ACPI_TYPE_PROCESSOR:
1510 *type = ACPI_BUS_TYPE_PROCESSOR;
1511 status = acpi_bus_get_status_handle(handle, sta);
1512 if (ACPI_FAILURE(status))
1513 return -ENODEV;
1514 break;
1515 case ACPI_TYPE_THERMAL:
1516 *type = ACPI_BUS_TYPE_THERMAL;
1517 *sta = ACPI_STA_DEFAULT;
1518 break;
1519 case ACPI_TYPE_POWER:
1520 *type = ACPI_BUS_TYPE_POWER;
1521 *sta = ACPI_STA_DEFAULT;
1522 break;
1523 default:
1524 return -ENODEV;
1525 }
1526
1527 return 0;
1528}
1529
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001530static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1531 void *not_used, void **return_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532{
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001533 struct acpi_device *device = NULL;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001534 int type;
1535 unsigned long long sta;
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001536 acpi_status status;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001537 int result;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001538
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001539 acpi_bus_get_device(handle, &device);
1540 if (device)
1541 goto out;
1542
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001543 result = acpi_bus_type_and_status(handle, &type, &sta);
1544 if (result)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001545 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001547 if (type == ACPI_BUS_TYPE_POWER) {
1548 acpi_add_power_resource(handle);
1549 return AE_OK;
1550 }
1551
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001552 if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001553 !(sta & ACPI_STA_DEVICE_FUNCTIONING)) {
Rafael J. Wysocki86e4e202011-01-06 23:40:00 +01001554 struct acpi_device_wakeup wakeup;
1555 acpi_handle temp;
1556
1557 status = acpi_get_handle(handle, "_PRW", &temp);
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +01001558 if (ACPI_SUCCESS(status)) {
Rafael J. Wysocki86e4e202011-01-06 23:40:00 +01001559 acpi_bus_extract_wakeup_device_power_package(handle,
1560 &wakeup);
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +01001561 acpi_power_resources_list_free(&wakeup.resources);
1562 }
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001563 return AE_CTRL_DEPTH;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +01001564 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001566 acpi_add_single_object(&device, handle, type, sta);
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001567 if (!device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001568 return AE_CTRL_DEPTH;
1569
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001570 out:
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001571 if (!*return_value)
1572 *return_value = device;
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001573
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001574 return AE_OK;
1575}
1576
Rafael J. Wysocki0fc300b2012-12-21 00:36:41 +01001577static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
1578 void *not_used, void **ret_not_used)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001579{
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001580 acpi_status status = AE_OK;
1581 struct acpi_device *device;
1582 unsigned long long sta_not_used;
1583 int type_not_used;
1584
1585 /*
1586 * Ignore errors ignored by acpi_bus_check_add() to avoid terminating
1587 * namespace walks prematurely.
1588 */
1589 if (acpi_bus_type_and_status(handle, &type_not_used, &sta_not_used))
1590 return AE_OK;
1591
1592 if (acpi_bus_get_device(handle, &device))
1593 return AE_CTRL_DEPTH;
1594
Rafael J. Wysocki0fc300b2012-12-21 00:36:41 +01001595 if (!acpi_match_device_ids(device, acpi_platform_device_ids)) {
1596 /* This is a known good platform device. */
1597 acpi_create_platform_device(device);
Mika Westerbergabe99212013-01-11 22:08:09 +01001598 } else if (device_attach(&device->dev) < 0) {
Rafael J. Wysocki0fc300b2012-12-21 00:36:41 +01001599 status = AE_CTRL_DEPTH;
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001600 }
1601 return status;
1602}
1603
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001604/**
1605 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1606 * @handle: Root of the namespace scope to scan.
1607 *
1608 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1609 * found devices.
1610 *
1611 * If no devices were found, -ENODEV is returned, but it does not mean that
1612 * there has been a real error. There just have been no suitable ACPI objects
1613 * in the table trunk from which the kernel could create a device and add an
1614 * appropriate driver.
1615 */
1616int acpi_bus_scan(acpi_handle handle)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001617{
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001618 void *device = NULL;
1619
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001620 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001621 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001622 acpi_bus_check_add, NULL, NULL, &device);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001623
Thomas Renningerd2f66502010-01-29 17:48:51 +01001624 if (!device)
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001625 return -ENODEV;
Thomas Renningerd2f66502010-01-29 17:48:51 +01001626
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001627 if (ACPI_SUCCESS(acpi_bus_device_attach(handle, 0, NULL, NULL)))
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001628 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysocki0fc300b2012-12-21 00:36:41 +01001629 acpi_bus_device_attach, NULL, NULL, NULL);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001630
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001631 return 0;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001632}
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001633EXPORT_SYMBOL(acpi_bus_scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001635static acpi_status acpi_bus_device_detach(acpi_handle handle, u32 lvl_not_used,
1636 void *not_used, void **ret_not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637{
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001638 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001640 if (!acpi_bus_get_device(handle, &device)) {
1641 device->removal_type = ACPI_BUS_REMOVAL_EJECT;
1642 device_release_driver(&device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001644 return AE_OK;
1645}
1646
1647static acpi_status acpi_bus_remove(acpi_handle handle, u32 lvl_not_used,
1648 void *not_used, void **ret_not_used)
1649{
1650 struct acpi_device *device = NULL;
1651
1652 if (!acpi_bus_get_device(handle, &device))
1653 acpi_device_unregister(device);
1654
1655 return AE_OK;
1656}
1657
Rafael J. Wysockiae281792013-01-15 13:23:53 +01001658int acpi_bus_trim(struct acpi_device *start)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659{
Rafael J. Wysockicecdb192013-01-15 13:24:02 +01001660 /*
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001661 * Execute acpi_bus_device_detach() as a post-order callback to detach
1662 * all ACPI drivers from the device nodes being removed.
1663 */
1664 acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
1665 acpi_bus_device_detach, NULL, NULL);
1666 acpi_bus_device_detach(start->handle, 0, NULL, NULL);
1667 /*
Rafael J. Wysockicecdb192013-01-15 13:24:02 +01001668 * Execute acpi_bus_remove() as a post-order callback to remove device
1669 * nodes in the given namespace scope.
1670 */
1671 acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
1672 acpi_bus_remove, NULL, NULL);
1673 acpi_bus_remove(start->handle, 0, NULL, NULL);
1674 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675}
Kristen Accardiceaba662006-02-23 17:56:01 -08001676EXPORT_SYMBOL_GPL(acpi_bus_trim);
1677
Bjorn Helgaase8b945c2009-09-21 19:28:59 +00001678static int acpi_bus_scan_fixed(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679{
Len Brown4be44fc2005-08-05 00:44:28 -04001680 int result = 0;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001681
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 /*
1683 * Enumerate all fixed-feature devices.
1684 */
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001685 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
1686 struct acpi_device *device = NULL;
1687
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001688 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001689 ACPI_BUS_TYPE_POWER_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001690 ACPI_STA_DEFAULT);
1691 if (result)
1692 return result;
1693
1694 result = device_attach(&device->dev);
1695 if (result < 0)
1696 return result;
1697
Daniel Drakec10d7a12012-05-10 00:08:43 +01001698 device_init_wakeup(&device->dev, true);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001699 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001701 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
1702 struct acpi_device *device = NULL;
1703
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001704 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001705 ACPI_BUS_TYPE_SLEEP_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001706 ACPI_STA_DEFAULT);
1707 if (result)
1708 return result;
1709
1710 result = device_attach(&device->dev);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001711 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001713 return result < 0 ? result : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714}
1715
Bjorn Helgaase747f272009-03-24 16:49:43 -06001716int __init acpi_scan_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717{
1718 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
Patrick Mochel5b327262006-05-10 10:33:00 -04001720 result = bus_register(&acpi_bus_type);
1721 if (result) {
1722 /* We don't want to quit even if we failed to add suspend/resume */
1723 printk(KERN_ERR PREFIX "Could not register bus type\n");
1724 }
1725
Rafael J. Wysocki92ef2a22012-12-21 00:36:40 +01001726 acpi_pci_root_init();
Rafael J. Wysocki97d9a9e2010-11-25 00:10:02 +01001727
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 * Enumerate devices in the ACPI namespace.
1730 */
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001731 result = acpi_bus_scan(ACPI_ROOT_OBJECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 if (result)
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001733 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001735 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 if (result)
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001737 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001739 result = acpi_bus_scan_fixed();
1740 if (result) {
1741 acpi_device_unregister(acpi_root);
1742 return result;
1743 }
1744
1745 acpi_update_all_gpes();
1746 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747}