blob: 78d5f02a073bb1c9e84beaeaf2f38b6f54125333 [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>
Suthikulpanit, Suraveed0562672015-06-10 11:08:52 -050014#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Rafael J. Wysockid7831562013-11-22 21:52:12 +010016#include <asm/pgtable.h>
17
Bjorn Helgaase60cc7a2009-03-13 12:08:26 -060018#include "internal.h"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050021ACPI_MODULE_NAME("scan");
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
Rafael J. Wysockid7831562013-11-22 21:52:12 +010030#define INVALID_ACPI_HANDLE ((acpi_handle)empty_zero_page)
31
Rafael J. Wysocki683058e2013-05-03 00:26:16 +020032/*
33 * If set, devices will be hot-removed even if they cannot be put offline
34 * gracefully (from the kernel's standpoint).
35 */
36bool acpi_force_hot_remove;
37
Thomas Renninger620e1122010-10-01 10:54:00 +020038static const char *dummy_hid = "device";
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +020039
Lan Tianyu40e7fcb2014-11-23 21:22:54 +080040static LIST_HEAD(acpi_dep_list);
41static DEFINE_MUTEX(acpi_dep_list_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080042static LIST_HEAD(acpi_bus_id_list);
Rafael J. Wysockic511cc12013-01-27 21:17:29 +010043static DEFINE_MUTEX(acpi_scan_lock);
Rafael J. Wysockica589f92013-01-30 14:27:29 +010044static LIST_HEAD(acpi_scan_handlers_list);
Shaohua Li90905892009-04-07 10:24:29 +080045DEFINE_MUTEX(acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046LIST_HEAD(acpi_wakeup_device_list);
Rafael J. Wysockie5255062014-02-04 00:43:17 +010047static DEFINE_MUTEX(acpi_hp_context_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Lan Tianyu40e7fcb2014-11-23 21:22:54 +080049struct acpi_dep_data {
50 struct list_head node;
51 acpi_handle master;
52 acpi_handle slave;
53};
54
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080055struct acpi_device_bus_id{
Zhang Ruibb095852007-01-04 15:03:18 +080056 char bus_id[15];
Zhang Ruie49bd2dd2006-12-08 17:23:43 +080057 unsigned int instance_no;
58 struct list_head node;
59};
Thomas Renninger29b71a12007-07-23 14:43:51 +020060
Rafael J. Wysocki3757b942013-02-13 14:36:47 +010061void acpi_scan_lock_acquire(void)
62{
63 mutex_lock(&acpi_scan_lock);
64}
65EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
66
67void acpi_scan_lock_release(void)
68{
69 mutex_unlock(&acpi_scan_lock);
70}
71EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
72
Rafael J. Wysockie5255062014-02-04 00:43:17 +010073void acpi_lock_hp_context(void)
74{
75 mutex_lock(&acpi_hp_context_lock);
76}
77
78void acpi_unlock_hp_context(void)
79{
80 mutex_unlock(&acpi_hp_context_lock);
81}
82
Rafael J. Wysocki5d513202014-02-22 00:48:31 +010083void acpi_initialize_hp_context(struct acpi_device *adev,
84 struct acpi_hotplug_context *hp,
85 int (*notify)(struct acpi_device *, u32),
86 void (*uevent)(struct acpi_device *, u32))
87{
88 acpi_lock_hp_context();
Rafael J. Wysockiba574dc2014-07-15 22:03:22 +020089 hp->notify = notify;
90 hp->uevent = uevent;
91 acpi_set_hp_context(adev, hp);
Rafael J. Wysocki5d513202014-02-22 00:48:31 +010092 acpi_unlock_hp_context();
93}
94EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
95
Rafael J. Wysockica589f92013-01-30 14:27:29 +010096int acpi_scan_add_handler(struct acpi_scan_handler *handler)
97{
Rafael J. Wysockid34afa92014-05-30 04:27:31 +020098 if (!handler)
Rafael J. Wysockica589f92013-01-30 14:27:29 +010099 return -EINVAL;
100
101 list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
102 return 0;
103}
104
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +0100105int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
106 const char *hotplug_profile_name)
107{
108 int error;
109
110 error = acpi_scan_add_handler(handler);
111 if (error)
112 return error;
113
114 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
115 return 0;
116}
117
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100118bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100119{
120 struct acpi_device_physical_node *pn;
121 bool offline = true;
122
Rafael J. Wysocki4c533c82015-04-18 01:25:46 +0200123 /*
124 * acpi_container_offline() calls this for all of the container's
125 * children under the container's physical_node_lock lock.
126 */
127 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING);
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100128
129 list_for_each_entry(pn, &adev->physical_node_list, node)
130 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100131 if (uevent)
132 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);
133
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100134 offline = false;
135 break;
136 }
137
138 mutex_unlock(&adev->physical_node_lock);
139 return offline;
140}
141
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100142static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
143 void **ret_p)
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200144{
145 struct acpi_device *device = NULL;
146 struct acpi_device_physical_node *pn;
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200147 bool second_pass = (bool)data;
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200148 acpi_status status = AE_OK;
149
150 if (acpi_bus_get_device(handle, &device))
151 return AE_OK;
152
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100153 if (device->handler && !device->handler->hotplug.enabled) {
154 *ret_p = &device->dev;
155 return AE_SUPPORT;
156 }
157
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200158 mutex_lock(&device->physical_node_lock);
159
160 list_for_each_entry(pn, &device->physical_node_list, node) {
161 int ret;
162
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200163 if (second_pass) {
164 /* Skip devices offlined by the first pass. */
165 if (pn->put_online)
166 continue;
167 } else {
168 pn->put_online = false;
169 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200170 ret = device_offline(pn->dev);
171 if (acpi_force_hot_remove)
172 continue;
173
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200174 if (ret >= 0) {
175 pn->put_online = !ret;
176 } else {
177 *ret_p = pn->dev;
178 if (second_pass) {
179 status = AE_ERROR;
180 break;
181 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200182 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200183 }
184
185 mutex_unlock(&device->physical_node_lock);
186
187 return status;
188}
189
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100190static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
191 void **ret_p)
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200192{
193 struct acpi_device *device = NULL;
194 struct acpi_device_physical_node *pn;
195
196 if (acpi_bus_get_device(handle, &device))
197 return AE_OK;
198
199 mutex_lock(&device->physical_node_lock);
200
201 list_for_each_entry(pn, &device->physical_node_list, node)
202 if (pn->put_online) {
203 device_online(pn->dev);
204 pn->put_online = false;
205 }
206
207 mutex_unlock(&device->physical_node_lock);
208
209 return AE_OK;
210}
211
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100212static int acpi_scan_try_to_offline(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Yinghai Lu5993c462013-01-11 22:40:41 +0000214 acpi_handle handle = device->handle;
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100215 struct device *errdev = NULL;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100216 acpi_status status;
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100217
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200218 /*
219 * Carry out two passes here and ignore errors in the first pass,
220 * because if the devices in question are memory blocks and
221 * CONFIG_MEMCG is set, one of the blocks may hold data structures
222 * that the other blocks depend on, but it is not known in advance which
223 * block holds them.
224 *
225 * If the first pass is successful, the second one isn't needed, though.
226 */
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100227 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
228 NULL, acpi_bus_offline, (void *)false,
229 (void **)&errdev);
230 if (status == AE_SUPPORT) {
231 dev_warn(errdev, "Offline disabled.\n");
232 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
233 acpi_bus_online, NULL, NULL, NULL);
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100234 return -EPERM;
235 }
236 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200237 if (errdev) {
238 errdev = NULL;
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200239 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100240 NULL, acpi_bus_offline, (void *)true,
241 (void **)&errdev);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200242 if (!errdev || acpi_force_hot_remove)
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100243 acpi_bus_offline(handle, 0, (void *)true,
244 (void **)&errdev);
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200245
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200246 if (errdev && !acpi_force_hot_remove) {
247 dev_warn(errdev, "Offline failed.\n");
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100248 acpi_bus_online(handle, 0, NULL, NULL);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200249 acpi_walk_namespace(ACPI_TYPE_ANY, handle,
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100250 ACPI_UINT32_MAX, acpi_bus_online,
251 NULL, NULL, NULL);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200252 return -EBUSY;
253 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200254 }
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100255 return 0;
256}
257
258static int acpi_scan_hot_remove(struct acpi_device *device)
259{
260 acpi_handle handle = device->handle;
261 unsigned long long sta;
262 acpi_status status;
263
Tang Chendee15922014-08-08 10:30:45 +0800264 if (device->handler && device->handler->hotplug.demand_offline
265 && !acpi_force_hot_remove) {
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100266 if (!acpi_scan_is_offline(device, true))
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100267 return -EBUSY;
268 } else {
269 int error = acpi_scan_try_to_offline(device);
270 if (error)
271 return error;
272 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200273
Zhang Rui26d46862008-04-29 02:35:48 -0400274 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Kay Sievers07944692008-10-30 01:18:59 +0100275 "Hot-removing device %s...\n", dev_name(&device->dev)));
Zhang Rui26d46862008-04-29 02:35:48 -0400276
Rafael J. Wysockibfee26d2013-01-26 00:27:44 +0100277 acpi_bus_trim(device);
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200278
Jiang Liu7d2421f2013-06-29 00:24:40 +0800279 acpi_evaluate_lck(handle, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 /*
281 * TBD: _EJD support.
282 */
Jiang Liu7d2421f2013-06-29 00:24:40 +0800283 status = acpi_evaluate_ej0(handle);
284 if (status == AE_NOT_FOUND)
285 return -ENODEV;
286 else if (ACPI_FAILURE(status))
287 return -EIO;
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100288
Toshi Kani882fd122013-03-13 19:29:26 +0000289 /*
290 * Verify if eject was indeed successful. If not, log an error
291 * message. No need to call _OST since _EJ0 call was made OK.
292 */
293 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
294 if (ACPI_FAILURE(status)) {
295 acpi_handle_warn(handle,
296 "Status check after eject failed (0x%x)\n", status);
297 } else if (sta & ACPI_STA_DEVICE_ENABLED) {
298 acpi_handle_warn(handle,
299 "Eject incomplete - status 0x%llx\n", sta);
300 }
301
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100302 return 0;
303}
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100304
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100305static int acpi_scan_device_not_present(struct acpi_device *adev)
306{
307 if (!acpi_device_enumerated(adev)) {
308 dev_warn(&adev->dev, "Still not present\n");
309 return -EALREADY;
310 }
311 acpi_bus_trim(adev);
312 return 0;
313}
314
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100315static int acpi_scan_device_check(struct acpi_device *adev)
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100316{
Rafael J. Wysockif943db42013-08-28 21:41:07 +0200317 int error;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100318
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100319 acpi_bus_get_status(adev);
320 if (adev->status.present || adev->status.functional) {
321 /*
322 * This function is only called for device objects for which
323 * matching scan handlers exist. The only situation in which
324 * the scan handler is not attached to this device object yet
325 * is when the device has just appeared (either it wasn't
326 * present at all before or it was removed and then added
327 * again).
328 */
329 if (adev->handler) {
330 dev_warn(&adev->dev, "Already enumerated\n");
331 return -EALREADY;
332 }
333 error = acpi_bus_scan(adev->handle);
334 if (error) {
335 dev_warn(&adev->dev, "Namespace scan failure\n");
336 return error;
337 }
338 if (!adev->handler) {
339 dev_warn(&adev->dev, "Enumeration failure\n");
340 error = -ENODEV;
341 }
342 } else {
343 error = acpi_scan_device_not_present(adev);
344 }
345 return error;
346}
347
348static int acpi_scan_bus_check(struct acpi_device *adev)
349{
350 struct acpi_scan_handler *handler = adev->handler;
351 struct acpi_device *child;
352 int error;
353
354 acpi_bus_get_status(adev);
355 if (!(adev->status.present || adev->status.functional)) {
356 acpi_scan_device_not_present(adev);
357 return 0;
358 }
359 if (handler && handler->hotplug.scan_dependent)
360 return handler->hotplug.scan_dependent(adev);
361
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100362 error = acpi_bus_scan(adev->handle);
363 if (error) {
364 dev_warn(&adev->dev, "Namespace scan failure\n");
365 return error;
366 }
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100367 list_for_each_entry(child, &adev->children, node) {
368 error = acpi_scan_bus_check(child);
369 if (error)
370 return error;
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100371 }
372 return 0;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100373}
374
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100375static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
376{
377 switch (type) {
378 case ACPI_NOTIFY_BUS_CHECK:
379 return acpi_scan_bus_check(adev);
380 case ACPI_NOTIFY_DEVICE_CHECK:
381 return acpi_scan_device_check(adev);
382 case ACPI_NOTIFY_EJECT_REQUEST:
383 case ACPI_OST_EC_OSPM_EJECT:
Rafael J. Wysockidd2151b2014-02-04 00:44:02 +0100384 if (adev->handler && !adev->handler->hotplug.enabled) {
385 dev_info(&adev->dev, "Eject disabled\n");
386 return -EPERM;
387 }
Rafael J. Wysocki700b8422014-02-21 01:07:17 +0100388 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
389 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100390 return acpi_scan_hot_remove(adev);
391 }
392 return -EINVAL;
393}
394
Rafael J. Wysocki1e3bcb52014-03-03 00:40:38 +0100395void acpi_device_hotplug(struct acpi_device *adev, u32 src)
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100396{
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100397 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100398 int error = -ENODEV;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100399
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200400 lock_device_hotplug();
Rafael J. Wysockie0ae8fe2013-08-30 14:19:29 +0200401 mutex_lock(&acpi_scan_lock);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100402
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100403 /*
404 * The device object's ACPI handle cannot become invalid as long as we
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100405 * are holding acpi_scan_lock, but it might have become invalid before
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100406 * that lock was acquired.
407 */
408 if (adev->handle == INVALID_ACPI_HANDLE)
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100409 goto err_out;
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100410
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +0100411 if (adev->flags.is_dock_station) {
412 error = dock_notify(adev, src);
413 } else if (adev->flags.hotplug_notify) {
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100414 error = acpi_generic_hotplug_event(adev, src);
Rafael J. Wysockidd2151b2014-02-04 00:44:02 +0100415 if (error == -EPERM) {
416 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
417 goto err_out;
418 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100419 } else {
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100420 int (*notify)(struct acpi_device *, u32);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100421
422 acpi_lock_hp_context();
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100423 notify = adev->hp ? adev->hp->notify : NULL;
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100424 acpi_unlock_hp_context();
425 /*
426 * There may be additional notify handlers for device objects
427 * without the .event() callback, so ignore them here.
428 */
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100429 if (notify)
430 error = notify(adev, src);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100431 else
432 goto out;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100433 }
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100434 if (!error)
435 ost_code = ACPI_OST_SC_SUCCESS;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100436
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100437 err_out:
Rafael J. Wysocki700b8422014-02-21 01:07:17 +0100438 acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100439
440 out:
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100441 acpi_bus_put_acpi_device(adev);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100442 mutex_unlock(&acpi_scan_lock);
Rafael J. Wysockie0ae8fe2013-08-30 14:19:29 +0200443 unlock_device_hotplug();
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100444}
445
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100446static void acpi_free_power_resources_lists(struct acpi_device *device)
447{
448 int i;
449
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100450 if (device->wakeup.flags.valid)
451 acpi_power_resources_list_free(&device->wakeup.resources);
452
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +0100453 if (!device->power.flags.power_resources)
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100454 return;
455
456 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
457 struct acpi_device_power_state *ps = &device->power.states[i];
458 acpi_power_resources_list_free(&ps->resources);
459 }
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600460}
461
Patrick Mochel1890a972006-12-07 20:56:31 +0800462static void acpi_device_release(struct device *dev)
463{
464 struct acpi_device *acpi_dev = to_acpi_device(dev);
465
Mika Westerbergffdcd952014-10-21 13:33:55 +0200466 acpi_free_properties(acpi_dev);
Toshi Kanic0af4172013-03-04 21:30:42 +0000467 acpi_free_pnp_ids(&acpi_dev->pnp);
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100468 acpi_free_power_resources_lists(acpi_dev);
Patrick Mochel1890a972006-12-07 20:56:31 +0800469 kfree(acpi_dev);
470}
471
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100472static void acpi_device_del(struct acpi_device *device)
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200473{
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100474 mutex_lock(&acpi_device_lock);
475 if (device->parent)
476 list_del(&device->node);
477
478 list_del(&device->wakeup_list);
479 mutex_unlock(&acpi_device_lock);
480
481 acpi_power_add_remove_device(device, false);
482 acpi_device_remove_files(device);
483 if (device->remove)
484 device->remove(device);
485
486 device_del(&device->dev);
487}
488
489static LIST_HEAD(acpi_device_del_list);
490static DEFINE_MUTEX(acpi_device_del_lock);
491
492static void acpi_device_del_work_fn(struct work_struct *work_not_used)
493{
494 for (;;) {
495 struct acpi_device *adev;
496
497 mutex_lock(&acpi_device_del_lock);
498
499 if (list_empty(&acpi_device_del_list)) {
500 mutex_unlock(&acpi_device_del_lock);
501 break;
502 }
503 adev = list_first_entry(&acpi_device_del_list,
504 struct acpi_device, del_list);
505 list_del(&adev->del_list);
506
507 mutex_unlock(&acpi_device_del_lock);
508
509 acpi_device_del(adev);
510 /*
511 * Drop references to all power resources that might have been
512 * used by the device.
513 */
514 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
515 put_device(&adev->dev);
516 }
517}
518
519/**
520 * acpi_scan_drop_device - Drop an ACPI device object.
521 * @handle: Handle of an ACPI namespace node, not used.
522 * @context: Address of the ACPI device object to drop.
523 *
524 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
525 * namespace node the device object pointed to by @context is attached to.
526 *
527 * The unregistration is carried out asynchronously to avoid running
528 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
529 * ensure the correct ordering (the device objects must be unregistered in the
530 * same order in which the corresponding namespace nodes are deleted).
531 */
532static void acpi_scan_drop_device(acpi_handle handle, void *context)
533{
534 static DECLARE_WORK(work, acpi_device_del_work_fn);
535 struct acpi_device *adev = context;
536
537 mutex_lock(&acpi_device_del_lock);
538
539 /*
540 * Use the ACPI hotplug workqueue which is ordered, so this work item
541 * won't run after any hotplug work items submitted subsequently. That
542 * prevents attempts to register device objects identical to those being
543 * deleted from happening concurrently (such attempts result from
544 * hotplug events handled via the ACPI hotplug workqueue). It also will
545 * run after all of the work items submitted previosuly, which helps
546 * those work items to ensure that they are not accessing stale device
547 * objects.
548 */
549 if (list_empty(&acpi_device_del_list))
550 acpi_queue_hotplug_work(&work);
551
552 list_add_tail(&adev->del_list, &acpi_device_del_list);
553 /* Make acpi_ns_validate_handle() return NULL for this handle. */
554 adev->handle = INVALID_ACPI_HANDLE;
555
556 mutex_unlock(&acpi_device_del_lock);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200557}
558
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100559static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
560 void (*callback)(void *))
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200561{
562 acpi_status status;
563
564 if (!device)
565 return -EINVAL;
566
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100567 status = acpi_get_data_full(handle, acpi_scan_drop_device,
568 (void **)device, callback);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200569 if (ACPI_FAILURE(status) || !*device) {
570 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
571 handle));
572 return -ENODEV;
573 }
574 return 0;
575}
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100576
577int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
578{
579 return acpi_get_device_data(handle, device, NULL);
580}
Rafael J. Wysocki65859252013-10-01 23:02:43 +0200581EXPORT_SYMBOL(acpi_bus_get_device);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200582
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100583static void get_acpi_device(void *dev)
584{
585 if (dev)
586 get_device(&((struct acpi_device *)dev)->dev);
587}
588
589struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
590{
591 struct acpi_device *adev = NULL;
592
593 acpi_get_device_data(handle, &adev, get_acpi_device);
594 return adev;
595}
596
597void acpi_bus_put_acpi_device(struct acpi_device *adev)
598{
599 put_device(&adev->dev);
600}
601
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100602int acpi_device_add(struct acpi_device *device,
603 void (*release)(struct device *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800605 int result;
606 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
607 int found = 0;
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000608
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100609 if (device->handle) {
610 acpi_status status;
611
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100612 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100613 device);
614 if (ACPI_FAILURE(status)) {
615 acpi_handle_err(device->handle,
616 "Unable to attach device data\n");
617 return -ENODEV;
618 }
619 }
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 /*
622 * Linkage
623 * -------
624 * Link this device to its parent and siblings.
625 */
626 INIT_LIST_HEAD(&device->children);
627 INIT_LIST_HEAD(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 INIT_LIST_HEAD(&device->wakeup_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800629 INIT_LIST_HEAD(&device->physical_node_list);
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100630 INIT_LIST_HEAD(&device->del_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800631 mutex_init(&device->physical_node_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800633 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
634 if (!new_bus_id) {
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100635 pr_err(PREFIX "Memory allocation error\n");
636 result = -ENOMEM;
637 goto err_detach;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800638 }
639
Shaohua Li90905892009-04-07 10:24:29 +0800640 mutex_lock(&acpi_device_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800641 /*
642 * Find suitable bus_id and instance number in acpi_bus_id_list
643 * If failed, create one and link it into acpi_bus_id_list
644 */
645 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600646 if (!strcmp(acpi_device_bus_id->bus_id,
647 acpi_device_hid(device))) {
648 acpi_device_bus_id->instance_no++;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800649 found = 1;
650 kfree(new_bus_id);
651 break;
652 }
653 }
Alex Chiang0c526d92009-05-14 08:31:37 -0600654 if (!found) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800655 acpi_device_bus_id = new_bus_id;
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600656 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800657 acpi_device_bus_id->instance_no = 0;
658 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
659 }
Kay Sievers07944692008-10-30 01:18:59 +0100660 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 +0800661
Len Brown33b57152008-12-15 22:09:26 -0500662 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 list_add_tail(&device->node, &device->parent->children);
Len Brown33b57152008-12-15 22:09:26 -0500664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (device->wakeup.flags.valid)
666 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
Shaohua Li90905892009-04-07 10:24:29 +0800667 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Patrick Mochel1890a972006-12-07 20:56:31 +0800669 if (device->parent)
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000670 device->dev.parent = &device->parent->dev;
Patrick Mochel1890a972006-12-07 20:56:31 +0800671 device->dev.bus = &acpi_bus_type;
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +0100672 device->dev.release = release;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100673 result = device_add(&device->dev);
Alex Chiang0c526d92009-05-14 08:31:37 -0600674 if (result) {
Alex Chiang8b12b922009-05-14 08:31:32 -0600675 dev_err(&device->dev, "Error registering device\n");
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100676 goto err;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800677 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800678
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800679 result = acpi_device_setup_files(device);
Alex Chiang0c526d92009-05-14 08:31:37 -0600680 if (result)
Kay Sievers07944692008-10-30 01:18:59 +0100681 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
682 dev_name(&device->dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800683
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800684 return 0;
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100685
686 err:
Shaohua Li90905892009-04-07 10:24:29 +0800687 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500688 if (device->parent)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800689 list_del(&device->node);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800690 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800691 mutex_unlock(&acpi_device_lock);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100692
693 err_detach:
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100694 acpi_detach_data(device->handle, acpi_scan_drop_device);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800695 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
Zhang Rui9e89dde2006-12-07 20:56:16 +0800698/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 Device Enumeration
700 -------------------------------------------------------------------------- */
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000701static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
702{
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100703 struct acpi_device *device = NULL;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000704 acpi_status status;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000705
706 /*
707 * Fixed hardware devices do not appear in the namespace and do not
708 * have handles, but we fabricate acpi_devices for them, so we have
709 * to deal with them specially.
710 */
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100711 if (!handle)
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000712 return acpi_root;
713
714 do {
715 status = acpi_get_parent(handle, &handle);
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000716 if (ACPI_FAILURE(status))
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100717 return status == AE_NULL_ENTRY ? NULL : acpi_root;
718 } while (acpi_bus_get_device(handle, &device));
719 return device;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000720}
721
Len Brownc8f7a622006-07-09 17:22:28 -0400722acpi_status
723acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
724{
725 acpi_status status;
726 acpi_handle tmp;
727 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
728 union acpi_object *obj;
729
730 status = acpi_get_handle(handle, "_EJD", &tmp);
731 if (ACPI_FAILURE(status))
732 return status;
733
734 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
735 if (ACPI_SUCCESS(status)) {
736 obj = buffer.pointer;
Holger Macht3b5fee52008-02-14 13:40:34 +0100737 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
738 ejd);
Len Brownc8f7a622006-07-09 17:22:28 -0400739 kfree(buffer.pointer);
740 }
741 return status;
742}
743EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
744
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100745static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
746 struct acpi_device_wakeup *wakeup)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100748 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
749 union acpi_object *package = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 union acpi_object *element = NULL;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100751 acpi_status status;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100752 int err = -ENODATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100754 if (!wakeup)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100755 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100757 INIT_LIST_HEAD(&wakeup->resources);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100759 /* _PRW */
760 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
761 if (ACPI_FAILURE(status)) {
762 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100763 return err;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100764 }
765
766 package = (union acpi_object *)buffer.pointer;
767
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100768 if (!package || package->package.count < 2)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100769 goto out;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 element = &(package->package.elements[0]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100772 if (!element)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100773 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 if (element->type == ACPI_TYPE_PACKAGE) {
776 if ((element->package.count < 2) ||
777 (element->package.elements[0].type !=
778 ACPI_TYPE_LOCAL_REFERENCE)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100779 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100780 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100781
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100782 wakeup->gpe_device =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 element->package.elements[0].reference.handle;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100784 wakeup->gpe_number =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 (u32) element->package.elements[1].integer.value;
786 } else if (element->type == ACPI_TYPE_INTEGER) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100787 wakeup->gpe_device = NULL;
788 wakeup->gpe_number = element->integer.value;
789 } else {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100790 goto out;
791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 element = &(package->package.elements[1]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100794 if (element->type != ACPI_TYPE_INTEGER)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100795 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100796
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100797 wakeup->sleep_state = element->integer.value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100799 err = acpi_extract_power_resources(package, 2, &wakeup->resources);
800 if (err)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100801 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Rafael J. Wysocki0596a522013-01-17 14:11:07 +0100803 if (!list_empty(&wakeup->resources)) {
804 int sleep_state;
805
Rafael J. Wysockib5d667e2013-02-23 23:15:21 +0100806 err = acpi_power_wakeup_list_init(&wakeup->resources,
807 &sleep_state);
808 if (err) {
809 acpi_handle_warn(handle, "Retrieving current states "
810 "of wakeup power resources failed\n");
811 acpi_power_resources_list_free(&wakeup->resources);
812 goto out;
813 }
Rafael J. Wysocki0596a522013-01-17 14:11:07 +0100814 if (sleep_state < wakeup->sleep_state) {
815 acpi_handle_warn(handle, "Overriding _PRW sleep state "
816 "(S%d) by S%d from power resources\n",
817 (int)wakeup->sleep_state, sleep_state);
818 wakeup->sleep_state = sleep_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
Rafael J. Wysocki98746472010-07-08 00:43:36 +0200821
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100822 out:
823 kfree(buffer.pointer);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100824 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200827static void acpi_wakeup_gpe_init(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
Mathias Krause0519ade2015-06-13 14:26:58 +0200829 static const struct acpi_device_id button_device_ids[] = {
Thomas Renninger29b71a12007-07-23 14:43:51 +0200830 {"PNP0C0C", 0},
Zhang Ruib7e38302012-12-04 23:23:16 +0100831 {"PNP0C0D", 0},
Thomas Renninger29b71a12007-07-23 14:43:51 +0200832 {"PNP0C0E", 0},
833 {"", 0},
834 };
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200835 struct acpi_device_wakeup *wakeup = &device->wakeup;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100836 acpi_status status;
837 acpi_event_status event_status;
838
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200839 wakeup->flags.notifier_present = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100840
841 /* Power button, Lid switch always enable wakeup */
842 if (!acpi_match_device_ids(device, button_device_ids)) {
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200843 wakeup->flags.run_wake = 1;
Zhang Ruib7e38302012-12-04 23:23:16 +0100844 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
845 /* Do not use Lid/sleep button for S5 wakeup */
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200846 if (wakeup->sleep_state == ACPI_STATE_S5)
847 wakeup->sleep_state = ACPI_STATE_S4;
Zhang Ruib7e38302012-12-04 23:23:16 +0100848 }
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200849 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
Rafael J. Wysockif2b56bc2011-01-06 23:34:22 +0100850 device_set_wakeup_capable(&device->dev, true);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100851 return;
852 }
853
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200854 acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
855 wakeup->gpe_number);
856 status = acpi_get_gpe_status(wakeup->gpe_device, wakeup->gpe_number,
857 &event_status);
858 if (ACPI_FAILURE(status))
859 return;
860
Lv Zheng2f857232014-10-10 10:40:05 +0800861 wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100862}
863
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100864static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100865{
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100866 int err;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200867
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100868 /* Presence of _PRW indicates wake capable */
Jiang Liu952c63e2013-06-29 00:24:38 +0800869 if (!acpi_has_method(device->handle, "_PRW"))
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100870 return;
871
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100872 err = acpi_bus_extract_wakeup_device_power_package(device->handle,
873 &device->wakeup);
874 if (err) {
875 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100876 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 }
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 device->wakeup.flags.valid = 1;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200880 device->wakeup.prepare_count = 0;
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200881 acpi_wakeup_gpe_init(device);
Zhao Yakui729b2bd2008-03-19 13:26:54 +0800882 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
883 * system for the ACPI device with the _PRW object.
884 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
885 * So it is necessary to call _DSW object first. Only when it is not
886 * present will the _PSW object used.
887 */
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100888 err = acpi_device_sleep_wake(device, 0, 0, 0);
889 if (err)
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200890 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
891 "error in _DSW or _PSW evaluation\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892}
893
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100894static void acpi_bus_init_power_state(struct acpi_device *device, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895{
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100896 struct acpi_device_power_state *ps = &device->power.states[state];
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100897 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
898 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100899 acpi_status status;
Zhang Rui9e89dde2006-12-07 20:56:16 +0800900
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100901 INIT_LIST_HEAD(&ps->resources);
902
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100903 /* Evaluate "_PRx" to get referenced power resources */
904 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
905 if (ACPI_SUCCESS(status)) {
906 union acpi_object *package = buffer.pointer;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100907
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100908 if (buffer.length && package
909 && package->type == ACPI_TYPE_PACKAGE
910 && package->package.count) {
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100911 int err = acpi_extract_power_resources(package, 0,
912 &ps->resources);
913 if (!err)
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100914 device->power.flags.power_resources = 1;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100915 }
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100916 ACPI_FREE(buffer.pointer);
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100917 }
918
919 /* Evaluate "_PSx" to see if we can do explicit sets */
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100920 pathname[2] = 'S';
Jiang Liu952c63e2013-06-29 00:24:38 +0800921 if (acpi_has_method(device->handle, pathname))
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100922 ps->flags.explicit_set = 1;
923
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200924 /* State is valid if there are means to put the device into it. */
925 if (!list_empty(&ps->resources) || ps->flags.explicit_set)
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100926 ps->flags.valid = 1;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100927
928 ps->power = -1; /* Unknown - driver assigned */
929 ps->latency = -1; /* Unknown - driver assigned */
930}
931
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100932static void acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933{
Rafael J. Wysocki8bc50532013-01-17 14:11:07 +0100934 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100936 /* Presence of _PS0|_PR0 indicates 'power manageable' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800937 if (!acpi_has_method(device->handle, "_PS0") &&
938 !acpi_has_method(device->handle, "_PR0"))
939 return;
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100940
941 device->flags.power_manageable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
943 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800944 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 */
Jiang Liu952c63e2013-06-29 00:24:38 +0800946 if (acpi_has_method(device->handle, "_PSC"))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800947 device->power.flags.explicit_get = 1;
Rafael J. Wysockif25c0ae2014-05-17 00:18:13 +0200948
Jiang Liu952c63e2013-06-29 00:24:38 +0800949 if (acpi_has_method(device->handle, "_IRC"))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800950 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
Rafael J. Wysockif25c0ae2014-05-17 00:18:13 +0200952 if (acpi_has_method(device->handle, "_DSW"))
953 device->power.flags.dsw_present = 1;
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800956 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 */
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100958 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
959 acpi_bus_init_power_state(device, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100961 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200962 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources))
963 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200965 /* Set defaults for D0 and D3hot states (always valid) */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800966 device->power.states[ACPI_STATE_D0].flags.valid = 1;
967 device->power.states[ACPI_STATE_D0].power = 100;
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200968 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1;
Aaron Lu1399dfc2012-11-21 23:33:40 +0100969
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +0100970 if (acpi_bus_init_power(device))
Rafael J. Wysockib3785492013-02-01 23:43:02 +0100971 device->flags.power_manageable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972}
973
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100974static void acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 /* Presence of _STA indicates 'dynamic_status' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800977 if (acpi_has_method(device->handle, "_STA"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 device->flags.dynamic_status = 1;
979
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 /* Presence of _RMV indicates 'removable' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800981 if (acpi_has_method(device->handle, "_RMV"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 device->flags.removable = 1;
983
984 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800985 if (acpi_has_method(device->handle, "_EJD") ||
986 acpi_has_method(device->handle, "_EJ0"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 device->flags.ejectable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988}
989
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +0000990static void acpi_device_get_busid(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991{
Len Brown4be44fc2005-08-05 00:44:28 -0400992 char bus_id[5] = { '?', 0 };
993 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
994 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
996 /*
997 * Bus ID
998 * ------
999 * The device's Bus ID is simply the object name.
1000 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1001 */
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001002 if (ACPI_IS_ROOT_DEVICE(device)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 strcpy(device->pnp.bus_id, "ACPI");
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001004 return;
1005 }
1006
1007 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 case ACPI_BUS_TYPE_POWER_BUTTON:
1009 strcpy(device->pnp.bus_id, "PWRF");
1010 break;
1011 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1012 strcpy(device->pnp.bus_id, "SLPF");
1013 break;
1014 default:
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001015 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 /* Clean up trailing underscores (if any) */
1017 for (i = 3; i > 1; i--) {
1018 if (bus_id[i] == '_')
1019 bus_id[i] = '\0';
1020 else
1021 break;
1022 }
1023 strcpy(device->pnp.bus_id, bus_id);
1024 break;
1025 }
1026}
1027
Zhang Rui54735262007-01-11 02:09:09 -05001028/*
Jiang Liuebf4df82013-06-29 00:24:41 +08001029 * acpi_ata_match - see if an acpi object is an ATA device
1030 *
1031 * If an acpi object has one of the ACPI ATA methods defined,
1032 * then we can safely call it an ATA device.
1033 */
1034bool acpi_ata_match(acpi_handle handle)
1035{
1036 return acpi_has_method(handle, "_GTF") ||
1037 acpi_has_method(handle, "_GTM") ||
1038 acpi_has_method(handle, "_STM") ||
1039 acpi_has_method(handle, "_SDD");
1040}
1041
1042/*
Toshi Kanid4e1a692013-03-04 21:30:41 +00001043 * acpi_bay_match - see if an acpi object is an ejectable driver bay
Zhang Rui54735262007-01-11 02:09:09 -05001044 *
1045 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1046 * then we can safely call it an ejectable drive bay
1047 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001048bool acpi_bay_match(acpi_handle handle)
Toshi Kanid4e1a692013-03-04 21:30:41 +00001049{
Zhang Rui54735262007-01-11 02:09:09 -05001050 acpi_handle phandle;
1051
Jiang Liu952c63e2013-06-29 00:24:38 +08001052 if (!acpi_has_method(handle, "_EJ0"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001053 return false;
1054 if (acpi_ata_match(handle))
1055 return true;
1056 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1057 return false;
Zhang Rui54735262007-01-11 02:09:09 -05001058
Jiang Liuebf4df82013-06-29 00:24:41 +08001059 return acpi_ata_match(phandle);
Zhang Rui54735262007-01-11 02:09:09 -05001060}
1061
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001062bool acpi_device_is_battery(struct acpi_device *adev)
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001063{
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001064 struct acpi_hardware_id *hwid;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001065
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001066 list_for_each_entry(hwid, &adev->pnp.ids, list)
1067 if (!strcmp("PNP0C0A", hwid->id))
1068 return true;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001069
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001070 return false;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001071}
1072
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001073static bool is_ejectable_bay(struct acpi_device *adev)
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001074{
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001075 acpi_handle handle = adev->handle;
1076
1077 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001078 return true;
1079
1080 return acpi_bay_match(handle);
1081}
1082
Frank Seidel3620f2f2007-12-07 13:20:34 +01001083/*
Toshi Kanid4e1a692013-03-04 21:30:41 +00001084 * acpi_dock_match - see if an acpi object has a _DCK method
Frank Seidel3620f2f2007-12-07 13:20:34 +01001085 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001086bool acpi_dock_match(acpi_handle handle)
Frank Seidel3620f2f2007-12-07 13:20:34 +01001087{
Jiang Liuebf4df82013-06-29 00:24:41 +08001088 return acpi_has_method(handle, "_DCK");
Frank Seidel3620f2f2007-12-07 13:20:34 +01001089}
1090
Hans de Goedeadc8bb82015-06-16 16:27:45 +02001091static acpi_status
1092acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
1093 void **return_value)
1094{
1095 long *cap = context;
1096
1097 if (acpi_has_method(handle, "_BCM") &&
1098 acpi_has_method(handle, "_BCL")) {
1099 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight "
1100 "support\n"));
1101 *cap |= ACPI_VIDEO_BACKLIGHT;
1102 if (!acpi_has_method(handle, "_BQC"))
1103 printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, "
1104 "cannot determine initial brightness\n");
1105 /* We have backlight support, no need to scan further */
1106 return AE_CTRL_TERMINATE;
1107 }
1108 return 0;
1109}
1110
1111/* Returns true if the ACPI object is a video device which can be
1112 * handled by video.ko.
1113 * The device will get a Linux specific CID added in scan.c to
1114 * identify the device as an ACPI graphics device
1115 * Be aware that the graphics device may not be physically present
1116 * Use acpi_video_get_capabilities() to detect general ACPI video
1117 * capabilities of present cards
1118 */
1119long acpi_is_video_device(acpi_handle handle)
1120{
1121 long video_caps = 0;
1122
1123 /* Is this device able to support video switching ? */
1124 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS"))
1125 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
1126
1127 /* Is this device able to retrieve a video ROM ? */
1128 if (acpi_has_method(handle, "_ROM"))
1129 video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
1130
1131 /* Is this device able to configure which video head to be POSTed ? */
1132 if (acpi_has_method(handle, "_VPO") &&
1133 acpi_has_method(handle, "_GPD") &&
1134 acpi_has_method(handle, "_SPD"))
1135 video_caps |= ACPI_VIDEO_DEVICE_POSTING;
1136
1137 /* Only check for backlight functionality if one of the above hit. */
1138 if (video_caps)
1139 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1140 ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL,
1141 &video_caps, NULL);
1142
1143 return video_caps;
1144}
1145EXPORT_SYMBOL(acpi_is_video_device);
1146
Thomas Renninger620e1122010-10-01 10:54:00 +02001147const char *acpi_device_hid(struct acpi_device *device)
Bob Moore15b8dd52009-06-29 13:39:29 +08001148{
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001149 struct acpi_hardware_id *hid;
Bob Moore15b8dd52009-06-29 13:39:29 +08001150
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +02001151 if (list_empty(&device->pnp.ids))
1152 return dummy_hid;
1153
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001154 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1155 return hid->id;
1156}
1157EXPORT_SYMBOL(acpi_device_hid);
Bob Moore15b8dd52009-06-29 13:39:29 +08001158
Toshi Kanid4e1a692013-03-04 21:30:41 +00001159static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001160{
1161 struct acpi_hardware_id *id;
Bob Moore15b8dd52009-06-29 13:39:29 +08001162
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001163 id = kmalloc(sizeof(*id), GFP_KERNEL);
1164 if (!id)
1165 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001166
Rasmus Villemoes6a0d12e2015-09-09 23:59:43 +02001167 id->id = kstrdup_const(dev_id, GFP_KERNEL);
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001168 if (!id->id) {
1169 kfree(id);
1170 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001171 }
1172
Toshi Kanid4e1a692013-03-04 21:30:41 +00001173 list_add_tail(&id->list, &pnp->ids);
1174 pnp->type.hardware_id = 1;
Bob Moore15b8dd52009-06-29 13:39:29 +08001175}
1176
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001177/*
1178 * Old IBM workstations have a DSDT bug wherein the SMBus object
1179 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1180 * prefix. Work around this.
1181 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001182static bool acpi_ibm_smbus_match(acpi_handle handle)
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001183{
Jiang Liuebf4df82013-06-29 00:24:41 +08001184 char node_name[ACPI_PATH_SEGMENT_LENGTH];
1185 struct acpi_buffer path = { sizeof(node_name), node_name };
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001186
1187 if (!dmi_name_in_vendors("IBM"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001188 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001189
1190 /* Look for SMBS object */
Jiang Liuebf4df82013-06-29 00:24:41 +08001191 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1192 strcmp("SMBS", path.pointer))
1193 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001194
1195 /* Does it have the necessary (but misnamed) methods? */
Jiang Liu952c63e2013-06-29 00:24:38 +08001196 if (acpi_has_method(handle, "SBI") &&
1197 acpi_has_method(handle, "SBR") &&
1198 acpi_has_method(handle, "SBW"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001199 return true;
1200
1201 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001202}
1203
Jiang Liuae3caa82014-02-19 14:02:19 +08001204static bool acpi_object_is_system_bus(acpi_handle handle)
1205{
1206 acpi_handle tmp;
1207
1208 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
1209 tmp == handle)
1210 return true;
1211 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
1212 tmp == handle)
1213 return true;
1214
1215 return false;
1216}
1217
Toshi Kanic0af4172013-03-04 21:30:42 +00001218static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1219 int device_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220{
Len Brown4be44fc2005-08-05 00:44:28 -04001221 acpi_status status;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001222 struct acpi_device_info *info;
Lv Zheng78e25fe2012-10-31 02:25:24 +00001223 struct acpi_pnp_device_id_list *cid_list;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001224 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
Toshi Kanic0af4172013-03-04 21:30:42 +00001226 switch (device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 case ACPI_BUS_TYPE_DEVICE:
Toshi Kanic0af4172013-03-04 21:30:42 +00001228 if (handle == ACPI_ROOT_OBJECT) {
1229 acpi_add_id(pnp, ACPI_SYSTEM_HID);
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001230 break;
1231 }
1232
Toshi Kanic0af4172013-03-04 21:30:42 +00001233 status = acpi_get_object_info(handle, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 if (ACPI_FAILURE(status)) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001235 pr_err(PREFIX "%s: Error reading device info\n",
1236 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 return;
1238 }
1239
Rafael J. Wysocki549e6842014-05-30 04:26:18 +02001240 if (info->valid & ACPI_VALID_HID) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001241 acpi_add_id(pnp, info->hardware_id.string);
Rafael J. Wysocki549e6842014-05-30 04:26:18 +02001242 pnp->type.platform_id = 1;
1243 }
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001244 if (info->valid & ACPI_VALID_CID) {
Bob Moore15b8dd52009-06-29 13:39:29 +08001245 cid_list = &info->compatible_id_list;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001246 for (i = 0; i < cid_list->count; i++)
Toshi Kanic0af4172013-03-04 21:30:42 +00001247 acpi_add_id(pnp, cid_list->ids[i].string);
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001248 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 if (info->valid & ACPI_VALID_ADR) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001250 pnp->bus_address = info->address;
1251 pnp->type.bus_address = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 }
Lv Zhengccf78042012-10-30 14:41:07 +01001253 if (info->valid & ACPI_VALID_UID)
Toshi Kanic0af4172013-03-04 21:30:42 +00001254 pnp->unique_id = kstrdup(info->unique_id.string,
Lv Zhengccf78042012-10-30 14:41:07 +01001255 GFP_KERNEL);
Suthikulpanit, Suravee26095a02015-07-07 01:55:20 +02001256 if (info->valid & ACPI_VALID_CLS)
1257 acpi_add_id(pnp, info->class_code.string);
Zhang Ruiae843332006-12-07 20:57:10 +08001258
Bjorn Helgaasa83893ae2009-10-02 11:03:12 -04001259 kfree(info);
1260
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001261 /*
1262 * Some devices don't reliably have _HIDs & _CIDs, so add
1263 * synthetic HIDs to make sure drivers can find them.
1264 */
Toshi Kanic0af4172013-03-04 21:30:42 +00001265 if (acpi_is_video_device(handle))
1266 acpi_add_id(pnp, ACPI_VIDEO_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001267 else if (acpi_bay_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001268 acpi_add_id(pnp, ACPI_BAY_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001269 else if (acpi_dock_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001270 acpi_add_id(pnp, ACPI_DOCK_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001271 else if (acpi_ibm_smbus_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001272 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
Jiang Liuae3caa82014-02-19 14:02:19 +08001273 else if (list_empty(&pnp->ids) &&
1274 acpi_object_is_system_bus(handle)) {
1275 /* \_SB, \_TZ, LNXSYBUS */
1276 acpi_add_id(pnp, ACPI_BUS_HID);
Toshi Kanic0af4172013-03-04 21:30:42 +00001277 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
1278 strcpy(pnp->device_class, ACPI_BUS_CLASS);
Bjorn Helgaasb7b30de2010-03-24 10:44:33 -06001279 }
Zhang Rui54735262007-01-11 02:09:09 -05001280
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 break;
1282 case ACPI_BUS_TYPE_POWER:
Toshi Kanic0af4172013-03-04 21:30:42 +00001283 acpi_add_id(pnp, ACPI_POWER_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 break;
1285 case ACPI_BUS_TYPE_PROCESSOR:
Toshi Kanic0af4172013-03-04 21:30:42 +00001286 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 case ACPI_BUS_TYPE_THERMAL:
Toshi Kanic0af4172013-03-04 21:30:42 +00001289 acpi_add_id(pnp, ACPI_THERMAL_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 break;
1291 case ACPI_BUS_TYPE_POWER_BUTTON:
Toshi Kanic0af4172013-03-04 21:30:42 +00001292 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 break;
1294 case ACPI_BUS_TYPE_SLEEP_BUTTON:
Toshi Kanic0af4172013-03-04 21:30:42 +00001295 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 break;
1297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298}
1299
Toshi Kanic0af4172013-03-04 21:30:42 +00001300void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1301{
1302 struct acpi_hardware_id *id, *tmp;
1303
1304 list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
Rasmus Villemoes6a0d12e2015-09-09 23:59:43 +02001305 kfree_const(id->id);
Toshi Kanic0af4172013-03-04 21:30:42 +00001306 kfree(id);
1307 }
1308 kfree(pnp->unique_id);
1309}
1310
Suthikulpanit, Suraveeb84f1962015-10-28 15:50:48 -07001311/**
1312 * acpi_dma_supported - Check DMA support for the specified device.
1313 * @adev: The pointer to acpi device
1314 *
1315 * Return false if DMA is not supported. Otherwise, return true
1316 */
1317bool acpi_dma_supported(struct acpi_device *adev)
1318{
1319 if (!adev)
1320 return false;
1321
1322 if (adev->flags.cca_seen)
1323 return true;
1324
1325 /*
1326 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent
1327 * DMA on "Intel platforms". Presumably that includes all x86 and
1328 * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y.
1329 */
1330 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1331 return true;
1332
1333 return false;
1334}
1335
1336/**
1337 * acpi_get_dma_attr - Check the supported DMA attr for the specified device.
1338 * @adev: The pointer to acpi device
1339 *
1340 * Return enum dev_dma_attr.
1341 */
1342enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
1343{
1344 if (!acpi_dma_supported(adev))
1345 return DEV_DMA_NOT_SUPPORTED;
1346
1347 if (adev->flags.coherent_dma)
1348 return DEV_DMA_COHERENT;
1349 else
1350 return DEV_DMA_NON_COHERENT;
1351}
1352
Suthikulpanit, Suraveed0562672015-06-10 11:08:52 -05001353static void acpi_init_coherency(struct acpi_device *adev)
1354{
1355 unsigned long long cca = 0;
1356 acpi_status status;
1357 struct acpi_device *parent = adev->parent;
1358
1359 if (parent && parent->flags.cca_seen) {
1360 /*
1361 * From ACPI spec, OSPM will ignore _CCA if an ancestor
1362 * already saw one.
1363 */
1364 adev->flags.cca_seen = 1;
1365 cca = parent->flags.coherent_dma;
1366 } else {
1367 status = acpi_evaluate_integer(adev->handle, "_CCA",
1368 NULL, &cca);
1369 if (ACPI_SUCCESS(status))
1370 adev->flags.cca_seen = 1;
1371 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1372 /*
1373 * If architecture does not specify that _CCA is
1374 * required for DMA-able devices (e.g. x86),
1375 * we default to _CCA=1.
1376 */
1377 cca = 1;
1378 else
1379 acpi_handle_debug(adev->handle,
1380 "ACPI device is missing _CCA.\n");
1381 }
1382
1383 adev->flags.coherent_dma = cca;
1384}
1385
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001386void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1387 int type, unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388{
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001389 INIT_LIST_HEAD(&device->pnp.ids);
1390 device->device_type = type;
1391 device->handle = handle;
1392 device->parent = acpi_bus_get_parent(handle);
Rafael J. Wysocki8a0662d2014-11-04 14:03:59 +01001393 device->fwnode.type = FWNODE_ACPI;
Rafael J. Wysocki25db1152013-11-22 21:56:06 +01001394 acpi_set_device_status(device, sta);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001395 acpi_device_get_busid(device);
Toshi Kanic0af4172013-03-04 21:30:42 +00001396 acpi_set_pnp_ids(handle, &device->pnp, type);
Mika Westerbergffdcd952014-10-21 13:33:55 +02001397 acpi_init_properties(device);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001398 acpi_bus_get_flags(device);
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001399 device->flags.match_driver = false;
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001400 device->flags.initialized = true;
1401 device->flags.visited = false;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001402 device_initialize(&device->dev);
1403 dev_set_uevent_suppress(&device->dev, true);
Suthikulpanit, Suraveed0562672015-06-10 11:08:52 -05001404 acpi_init_coherency(device);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001405}
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001406
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001407void acpi_device_add_finalize(struct acpi_device *device)
1408{
1409 dev_set_uevent_suppress(&device->dev, false);
1410 kobject_uevent(&device->dev.kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411}
1412
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001413static int acpi_add_single_object(struct acpi_device **child,
1414 acpi_handle handle, int type,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001415 unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416{
Bjorn Helgaas77c24882009-09-21 19:29:30 +00001417 int result;
1418 struct acpi_device *device;
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001419 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Burman Yan36bcbec2006-12-19 12:56:11 -08001421 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001423 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001424 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001427 acpi_init_device_object(device, handle, type, sta);
1428 acpi_bus_get_power_flags(device);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001429 acpi_bus_get_wakeup_device_flags(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001431 result = acpi_device_add(device, acpi_device_release);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001432 if (result) {
Hugh Dickins718fb0d2009-08-06 23:18:12 +00001433 acpi_device_release(&device->dev);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001434 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
1436
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001437 acpi_power_add_remove_device(device, true);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001438 acpi_device_add_finalize(device);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001439 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1440 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1441 dev_name(&device->dev), (char *) buffer.pointer,
1442 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1443 kfree(buffer.pointer);
1444 *child = device;
1445 return 0;
Rafael J. Wysockibf325f92010-11-25 00:10:44 +01001446}
1447
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001448static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1449 unsigned long long *sta)
1450{
1451 acpi_status status;
1452 acpi_object_type acpi_type;
1453
1454 status = acpi_get_type(handle, &acpi_type);
1455 if (ACPI_FAILURE(status))
1456 return -ENODEV;
1457
1458 switch (acpi_type) {
1459 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
1460 case ACPI_TYPE_DEVICE:
1461 *type = ACPI_BUS_TYPE_DEVICE;
1462 status = acpi_bus_get_status_handle(handle, sta);
1463 if (ACPI_FAILURE(status))
1464 return -ENODEV;
1465 break;
1466 case ACPI_TYPE_PROCESSOR:
1467 *type = ACPI_BUS_TYPE_PROCESSOR;
1468 status = acpi_bus_get_status_handle(handle, sta);
1469 if (ACPI_FAILURE(status))
1470 return -ENODEV;
1471 break;
1472 case ACPI_TYPE_THERMAL:
1473 *type = ACPI_BUS_TYPE_THERMAL;
1474 *sta = ACPI_STA_DEFAULT;
1475 break;
1476 case ACPI_TYPE_POWER:
1477 *type = ACPI_BUS_TYPE_POWER;
1478 *sta = ACPI_STA_DEFAULT;
1479 break;
1480 default:
1481 return -ENODEV;
1482 }
1483
1484 return 0;
1485}
1486
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001487bool acpi_device_is_present(struct acpi_device *adev)
1488{
1489 if (adev->status.present || adev->status.functional)
1490 return true;
1491
1492 adev->flags.initialized = false;
1493 return false;
1494}
1495
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001496static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
Rasmus Villemoes844142c2015-09-09 23:59:42 +02001497 const char *idstr,
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001498 const struct acpi_device_id **matchid)
1499{
1500 const struct acpi_device_id *devid;
1501
Rafael J. Wysockiaca0a4e2014-05-30 04:21:52 +02001502 if (handler->match)
1503 return handler->match(idstr, matchid);
1504
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001505 for (devid = handler->ids; devid->id[0]; devid++)
1506 if (!strcmp((char *)devid->id, idstr)) {
1507 if (matchid)
1508 *matchid = devid;
1509
1510 return true;
1511 }
1512
1513 return false;
1514}
1515
Rasmus Villemoes844142c2015-09-09 23:59:42 +02001516static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr,
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001517 const struct acpi_device_id **matchid)
1518{
1519 struct acpi_scan_handler *handler;
1520
1521 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
1522 if (acpi_scan_handler_matching(handler, idstr, matchid))
1523 return handler;
1524
1525 return NULL;
1526}
1527
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001528void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
1529{
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001530 if (!!hotplug->enabled == !!val)
1531 return;
1532
1533 mutex_lock(&acpi_scan_lock);
1534
1535 hotplug->enabled = val;
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001536
1537 mutex_unlock(&acpi_scan_lock);
1538}
1539
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001540static void acpi_scan_init_hotplug(struct acpi_device *adev)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001541{
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001542 struct acpi_hardware_id *hwid;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001543
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001544 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001545 acpi_dock_add(adev);
1546 return;
1547 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001548 list_for_each_entry(hwid, &adev->pnp.ids, list) {
1549 struct acpi_scan_handler *handler;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001550
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001551 handler = acpi_scan_match_handler(hwid->id, NULL);
Rafael J. Wysocki1a699472014-02-06 13:58:13 +01001552 if (handler) {
1553 adev->flags.hotplug_notify = true;
1554 break;
1555 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001556 }
Rafael J. Wysockia33ec392013-03-03 23:05:29 +01001557}
1558
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001559static void acpi_device_dep_initialize(struct acpi_device *adev)
1560{
1561 struct acpi_dep_data *dep;
1562 struct acpi_handle_list dep_devices;
1563 acpi_status status;
1564 int i;
1565
1566 if (!acpi_has_method(adev->handle, "_DEP"))
1567 return;
1568
1569 status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
1570 &dep_devices);
1571 if (ACPI_FAILURE(status)) {
Rafael J. Wysocki80167a22014-12-12 22:48:44 +01001572 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001573 return;
1574 }
1575
1576 for (i = 0; i < dep_devices.count; i++) {
1577 struct acpi_device_info *info;
1578 int skip;
1579
1580 status = acpi_get_object_info(dep_devices.handles[i], &info);
1581 if (ACPI_FAILURE(status)) {
Rafael J. Wysocki80167a22014-12-12 22:48:44 +01001582 dev_dbg(&adev->dev, "Error reading _DEP device info\n");
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001583 continue;
1584 }
1585
1586 /*
1587 * Skip the dependency of Windows System Power
1588 * Management Controller
1589 */
1590 skip = info->valid & ACPI_VALID_HID &&
1591 !strcmp(info->hardware_id.string, "INT3396");
1592
1593 kfree(info);
1594
1595 if (skip)
1596 continue;
1597
1598 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
1599 if (!dep)
1600 return;
1601
1602 dep->master = dep_devices.handles[i];
1603 dep->slave = adev->handle;
1604 adev->dep_unmet++;
1605
1606 mutex_lock(&acpi_dep_list_lock);
1607 list_add_tail(&dep->node , &acpi_dep_list);
1608 mutex_unlock(&acpi_dep_list_lock);
1609 }
1610}
1611
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001612static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1613 void *not_used, void **return_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001615 struct acpi_device *device = NULL;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001616 int type;
1617 unsigned long long sta;
1618 int result;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001619
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001620 acpi_bus_get_device(handle, &device);
1621 if (device)
1622 goto out;
1623
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001624 result = acpi_bus_type_and_status(handle, &type, &sta);
1625 if (result)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001626 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001628 if (type == ACPI_BUS_TYPE_POWER) {
1629 acpi_add_power_resource(handle);
1630 return AE_OK;
1631 }
1632
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001633 acpi_add_single_object(&device, handle, type, sta);
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001634 if (!device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001635 return AE_CTRL_DEPTH;
1636
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001637 acpi_scan_init_hotplug(device);
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001638 acpi_device_dep_initialize(device);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001639
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001640 out:
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001641 if (!*return_value)
1642 *return_value = device;
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001643
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001644 return AE_OK;
1645}
1646
Zhang Rui48459342014-05-30 14:35:34 +02001647static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
1648{
1649 bool *is_spi_i2c_slave_p = data;
1650
1651 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
1652 return 1;
1653
1654 /*
1655 * devices that are connected to UART still need to be enumerated to
1656 * platform bus
1657 */
1658 if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
1659 *is_spi_i2c_slave_p = true;
1660
1661 /* no need to do more checking */
1662 return -1;
1663}
1664
1665static void acpi_default_enumeration(struct acpi_device *device)
1666{
1667 struct list_head resource_list;
1668 bool is_spi_i2c_slave = false;
1669
Zhang Rui48459342014-05-30 14:35:34 +02001670 /*
1671 * Do not enemerate SPI/I2C slaves as they will be enuerated by their
1672 * respective parents.
1673 */
1674 INIT_LIST_HEAD(&resource_list);
1675 acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
1676 &is_spi_i2c_slave);
1677 acpi_dev_free_resource_list(&resource_list);
1678 if (!is_spi_i2c_slave)
1679 acpi_create_platform_device(device);
1680}
1681
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001682static const struct acpi_device_id generic_device_ids[] = {
Rafael J. Wysockiee892092015-05-22 04:24:34 +02001683 {ACPI_DT_NAMESPACE_HID, },
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001684 {"", },
1685};
1686
1687static int acpi_generic_device_attach(struct acpi_device *adev,
1688 const struct acpi_device_id *not_used)
1689{
1690 /*
Rafael J. Wysockiee892092015-05-22 04:24:34 +02001691 * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test
1692 * below can be unconditional.
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001693 */
1694 if (adev->data.of_compatible)
1695 acpi_default_enumeration(adev);
1696
1697 return 1;
1698}
1699
1700static struct acpi_scan_handler generic_device_handler = {
1701 .ids = generic_device_ids,
1702 .attach = acpi_generic_device_attach,
1703};
1704
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001705static int acpi_scan_attach_handler(struct acpi_device *device)
1706{
1707 struct acpi_hardware_id *hwid;
1708 int ret = 0;
1709
1710 list_for_each_entry(hwid, &device->pnp.ids, list) {
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001711 const struct acpi_device_id *devid;
1712 struct acpi_scan_handler *handler;
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001713
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001714 handler = acpi_scan_match_handler(hwid->id, &devid);
1715 if (handler) {
Rafael J. Wysockid34afa92014-05-30 04:27:31 +02001716 if (!handler->attach) {
1717 device->pnp.type.platform_id = 0;
1718 continue;
1719 }
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001720 device->handler = handler;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001721 ret = handler->attach(device, devid);
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001722 if (ret > 0)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001723 break;
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001724
1725 device->handler = NULL;
1726 if (ret < 0)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001727 break;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001728 }
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001729 }
Zhang Rui48459342014-05-30 14:35:34 +02001730
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001731 return ret;
1732}
1733
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001734static void acpi_bus_attach(struct acpi_device *device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001735{
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001736 struct acpi_device *child;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001737 acpi_handle ejd;
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001738 int ret;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001739
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001740 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
1741 register_dock_dependent_device(device, ejd);
1742
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001743 acpi_bus_get_status(device);
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001744 /* Skip devices that are not present. */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001745 if (!acpi_device_is_present(device)) {
1746 device->flags.visited = false;
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +01001747 device->flags.power_manageable = 0;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001748 return;
1749 }
Rafael J. Wysocki3a391a32013-07-12 13:45:59 +02001750 if (device->handler)
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001751 goto ok;
Rafael J. Wysocki3a391a32013-07-12 13:45:59 +02001752
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001753 if (!device->flags.initialized) {
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +01001754 device->flags.power_manageable =
1755 device->power.states[ACPI_STATE_D0].flags.valid;
1756 if (acpi_bus_init_power(device))
1757 device->flags.power_manageable = 0;
1758
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001759 device->flags.initialized = true;
1760 }
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001761 device->flags.visited = false;
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001762 ret = acpi_scan_attach_handler(device);
Rafael J. Wysocki69310072013-11-07 01:41:01 +01001763 if (ret < 0)
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001764 return;
Rafael J. Wysocki69310072013-11-07 01:41:01 +01001765
1766 device->flags.match_driver = true;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001767 if (!ret) {
1768 ret = device_attach(&device->dev);
1769 if (ret < 0)
1770 return;
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001771
1772 if (!ret && device->pnp.type.platform_id)
1773 acpi_default_enumeration(device);
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001774 }
1775 device->flags.visited = true;
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001776
1777 ok:
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001778 list_for_each_entry(child, &device->children, node)
1779 acpi_bus_attach(child);
Rafael J. Wysocki8ab17fc2014-09-21 02:58:18 +02001780
1781 if (device->handler && device->handler->hotplug.notify_online)
1782 device->handler->hotplug.notify_online(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001785void acpi_walk_dep_device_list(acpi_handle handle)
1786{
1787 struct acpi_dep_data *dep, *tmp;
1788 struct acpi_device *adev;
1789
1790 mutex_lock(&acpi_dep_list_lock);
1791 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
1792 if (dep->master == handle) {
1793 acpi_bus_get_device(dep->slave, &adev);
1794 if (!adev)
1795 continue;
1796
1797 adev->dep_unmet--;
1798 if (!adev->dep_unmet)
1799 acpi_bus_attach(adev);
1800 list_del(&dep->node);
1801 kfree(dep);
1802 }
1803 }
1804 mutex_unlock(&acpi_dep_list_lock);
1805}
1806EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
1807
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001808/**
1809 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1810 * @handle: Root of the namespace scope to scan.
Thomas Renninger77796882010-01-29 17:48:52 +01001811 *
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001812 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1813 * found devices.
Thomas Renninger77796882010-01-29 17:48:52 +01001814 *
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001815 * If no devices were found, -ENODEV is returned, but it does not mean that
1816 * there has been a real error. There just have been no suitable ACPI objects
1817 * in the table trunk from which the kernel could create a device and add an
1818 * appropriate driver.
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001819 *
1820 * Must be called under acpi_scan_lock.
Thomas Renninger77796882010-01-29 17:48:52 +01001821 */
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001822int acpi_bus_scan(acpi_handle handle)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001823{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 void *device = NULL;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001825
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001826 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001828 acpi_bus_check_add, NULL, NULL, &device);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001829
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001830 if (device) {
1831 acpi_bus_attach(device);
1832 return 0;
1833 }
1834 return -ENODEV;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001835}
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001836EXPORT_SYMBOL(acpi_bus_scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001838/**
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001839 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
1840 * @adev: Root of the ACPI namespace scope to walk.
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001841 *
1842 * Must be called under acpi_scan_lock.
1843 */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001844void acpi_bus_trim(struct acpi_device *adev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845{
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001846 struct acpi_scan_handler *handler = adev->handler;
1847 struct acpi_device *child;
1848
1849 list_for_each_entry_reverse(child, &adev->children, node)
1850 acpi_bus_trim(child);
1851
Rafael J. Wysockia951c772014-01-27 23:08:09 +01001852 adev->flags.match_driver = false;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001853 if (handler) {
1854 if (handler->detach)
1855 handler->detach(adev);
1856
1857 adev->handler = NULL;
1858 } else {
1859 device_release_driver(&adev->dev);
1860 }
Rafael J. Wysockicecdb192013-01-15 13:24:02 +01001861 /*
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001862 * Most likely, the device is going away, so put it into D3cold before
1863 * that.
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001864 */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001865 acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
1866 adev->flags.initialized = false;
1867 adev->flags.visited = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868}
Kristen Accardiceaba662006-02-23 17:56:01 -08001869EXPORT_SYMBOL_GPL(acpi_bus_trim);
1870
Bjorn Helgaase8b945c2009-09-21 19:28:59 +00001871static int acpi_bus_scan_fixed(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872{
Len Brown4be44fc2005-08-05 00:44:28 -04001873 int result = 0;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001874
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 /*
1876 * Enumerate all fixed-feature devices.
1877 */
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001878 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
1879 struct acpi_device *device = NULL;
1880
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001881 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001882 ACPI_BUS_TYPE_POWER_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001883 ACPI_STA_DEFAULT);
1884 if (result)
1885 return result;
1886
Rafael J. Wysocki88346162013-11-18 14:18:47 +01001887 device->flags.match_driver = true;
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001888 result = device_attach(&device->dev);
1889 if (result < 0)
1890 return result;
1891
Daniel Drakec10d7a12012-05-10 00:08:43 +01001892 device_init_wakeup(&device->dev, true);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001893 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001895 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
1896 struct acpi_device *device = NULL;
1897
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001898 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001899 ACPI_BUS_TYPE_SLEEP_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001900 ACPI_STA_DEFAULT);
1901 if (result)
1902 return result;
1903
Rafael J. Wysocki88346162013-11-18 14:18:47 +01001904 device->flags.match_driver = true;
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001905 result = device_attach(&device->dev);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001906 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001908 return result < 0 ? result : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909}
1910
Bjorn Helgaase747f272009-03-24 16:49:43 -06001911int __init acpi_scan_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912{
1913 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
Rafael J. Wysocki92ef2a22012-12-21 00:36:40 +01001915 acpi_pci_root_init();
Rafael J. Wysocki4daeaf62013-01-30 14:27:37 +01001916 acpi_pci_link_init();
Rafael J. Wysockiac212b62013-05-03 00:26:22 +02001917 acpi_processor_init();
Rafael J. Wysockif58b0822013-03-06 23:46:20 +01001918 acpi_lpss_init();
Ken Xue92082a82015-02-06 08:27:51 +08001919 acpi_apd_init();
Lan Tianyu2fa97fe2013-06-05 02:27:50 +00001920 acpi_cmos_rtc_init();
Rafael J. Wysocki737f1a92013-02-08 23:52:39 +01001921 acpi_container_init();
Rafael J. Wysocki0a347642013-03-03 23:18:03 +01001922 acpi_memory_hotplug_init();
Zhang Ruieec15ed2014-05-30 04:23:01 +02001923 acpi_pnp_init();
Zhang Rui3230bbf2014-03-14 00:34:05 +08001924 acpi_int340x_thermal_init();
Rafael J. Wysocki97d9a9e2010-11-25 00:10:02 +01001925
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001926 acpi_scan_add_handler(&generic_device_handler);
1927
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001928 mutex_lock(&acpi_scan_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 * Enumerate devices in the ACPI namespace.
1931 */
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001932 result = acpi_bus_scan(ACPI_ROOT_OBJECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 if (result)
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001934 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001936 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 if (result)
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001938 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
Aaron Lu2650ef42014-04-28 10:38:04 +08001940 /* Fixed feature devices do not exist on HW-reduced platform */
1941 if (!acpi_gbl_reduced_hardware) {
1942 result = acpi_bus_scan_fixed();
1943 if (result) {
1944 acpi_detach_data(acpi_root->handle,
1945 acpi_scan_drop_device);
1946 acpi_device_del(acpi_root);
1947 put_device(&acpi_root->dev);
1948 goto out;
1949 }
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001950 }
1951
1952 acpi_update_all_gpes();
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001953
1954 out:
1955 mutex_unlock(&acpi_scan_lock);
1956 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957}
Marc Zyngiere647b532015-09-28 15:49:12 +01001958
1959static struct acpi_probe_entry *ape;
1960static int acpi_probe_count;
1961static DEFINE_SPINLOCK(acpi_probe_lock);
1962
1963static int __init acpi_match_madt(struct acpi_subtable_header *header,
1964 const unsigned long end)
1965{
1966 if (!ape->subtable_valid || ape->subtable_valid(header, ape))
1967 if (!ape->probe_subtbl(header, end))
1968 acpi_probe_count++;
1969
1970 return 0;
1971}
1972
1973int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
1974{
1975 int count = 0;
1976
1977 if (acpi_disabled)
1978 return 0;
1979
1980 spin_lock(&acpi_probe_lock);
1981 for (ape = ap_head; nr; ape++, nr--) {
1982 if (ACPI_COMPARE_NAME(ACPI_SIG_MADT, ape->id)) {
1983 acpi_probe_count = 0;
1984 acpi_table_parse_madt(ape->type, acpi_match_madt, 0);
1985 count += acpi_probe_count;
1986 } else {
1987 int res;
1988 res = acpi_table_parse(ape->id, ape->probe_table);
1989 if (!res)
1990 count++;
1991 }
1992 }
1993 spin_unlock(&acpi_probe_lock);
1994
1995 return count;
1996}