blob: cf725d581cae48100d4c1c84762e5cb47f8d3898 [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);
Lukas Wunner2d12b6b2015-11-25 21:19:55 +010042LIST_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
Shannon Zhaoa4e081b2016-04-07 20:03:18 +080049/*
50 * The UART device described by the SPCR table is the only object which needs
51 * special-casing. Everything else is covered by ACPI namespace paths in STAO
52 * table.
53 */
54static u64 spcr_uart_addr;
55
Lan Tianyu40e7fcb2014-11-23 21:22:54 +080056struct acpi_dep_data {
57 struct list_head node;
58 acpi_handle master;
59 acpi_handle slave;
60};
61
Rafael J. Wysocki3757b942013-02-13 14:36:47 +010062void acpi_scan_lock_acquire(void)
63{
64 mutex_lock(&acpi_scan_lock);
65}
66EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
67
68void acpi_scan_lock_release(void)
69{
70 mutex_unlock(&acpi_scan_lock);
71}
72EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
73
Rafael J. Wysockie5255062014-02-04 00:43:17 +010074void acpi_lock_hp_context(void)
75{
76 mutex_lock(&acpi_hp_context_lock);
77}
78
79void acpi_unlock_hp_context(void)
80{
81 mutex_unlock(&acpi_hp_context_lock);
82}
83
Rafael J. Wysocki5d513202014-02-22 00:48:31 +010084void acpi_initialize_hp_context(struct acpi_device *adev,
85 struct acpi_hotplug_context *hp,
86 int (*notify)(struct acpi_device *, u32),
87 void (*uevent)(struct acpi_device *, u32))
88{
89 acpi_lock_hp_context();
Rafael J. Wysockiba574dc2014-07-15 22:03:22 +020090 hp->notify = notify;
91 hp->uevent = uevent;
92 acpi_set_hp_context(adev, hp);
Rafael J. Wysocki5d513202014-02-22 00:48:31 +010093 acpi_unlock_hp_context();
94}
95EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
96
Rafael J. Wysockica589f92013-01-30 14:27:29 +010097int acpi_scan_add_handler(struct acpi_scan_handler *handler)
98{
Rafael J. Wysockid34afa92014-05-30 04:27:31 +020099 if (!handler)
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100100 return -EINVAL;
101
102 list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
103 return 0;
104}
105
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +0100106int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
107 const char *hotplug_profile_name)
108{
109 int error;
110
111 error = acpi_scan_add_handler(handler);
112 if (error)
113 return error;
114
115 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
116 return 0;
117}
118
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100119bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100120{
121 struct acpi_device_physical_node *pn;
122 bool offline = true;
123
Rafael J. Wysocki4c533c82015-04-18 01:25:46 +0200124 /*
125 * acpi_container_offline() calls this for all of the container's
126 * children under the container's physical_node_lock lock.
127 */
128 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING);
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100129
130 list_for_each_entry(pn, &adev->physical_node_list, node)
131 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100132 if (uevent)
133 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);
134
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100135 offline = false;
136 break;
137 }
138
139 mutex_unlock(&adev->physical_node_lock);
140 return offline;
141}
142
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100143static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
144 void **ret_p)
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200145{
146 struct acpi_device *device = NULL;
147 struct acpi_device_physical_node *pn;
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200148 bool second_pass = (bool)data;
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200149 acpi_status status = AE_OK;
150
151 if (acpi_bus_get_device(handle, &device))
152 return AE_OK;
153
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100154 if (device->handler && !device->handler->hotplug.enabled) {
155 *ret_p = &device->dev;
156 return AE_SUPPORT;
157 }
158
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200159 mutex_lock(&device->physical_node_lock);
160
161 list_for_each_entry(pn, &device->physical_node_list, node) {
162 int ret;
163
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200164 if (second_pass) {
165 /* Skip devices offlined by the first pass. */
166 if (pn->put_online)
167 continue;
168 } else {
169 pn->put_online = false;
170 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200171 ret = device_offline(pn->dev);
172 if (acpi_force_hot_remove)
173 continue;
174
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200175 if (ret >= 0) {
176 pn->put_online = !ret;
177 } else {
178 *ret_p = pn->dev;
179 if (second_pass) {
180 status = AE_ERROR;
181 break;
182 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200183 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200184 }
185
186 mutex_unlock(&device->physical_node_lock);
187
188 return status;
189}
190
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100191static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
192 void **ret_p)
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200193{
194 struct acpi_device *device = NULL;
195 struct acpi_device_physical_node *pn;
196
197 if (acpi_bus_get_device(handle, &device))
198 return AE_OK;
199
200 mutex_lock(&device->physical_node_lock);
201
202 list_for_each_entry(pn, &device->physical_node_list, node)
203 if (pn->put_online) {
204 device_online(pn->dev);
205 pn->put_online = false;
206 }
207
208 mutex_unlock(&device->physical_node_lock);
209
210 return AE_OK;
211}
212
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100213static int acpi_scan_try_to_offline(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
Yinghai Lu5993c462013-01-11 22:40:41 +0000215 acpi_handle handle = device->handle;
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100216 struct device *errdev = NULL;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100217 acpi_status status;
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100218
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200219 /*
220 * Carry out two passes here and ignore errors in the first pass,
221 * because if the devices in question are memory blocks and
222 * CONFIG_MEMCG is set, one of the blocks may hold data structures
223 * that the other blocks depend on, but it is not known in advance which
224 * block holds them.
225 *
226 * If the first pass is successful, the second one isn't needed, though.
227 */
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100228 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
229 NULL, acpi_bus_offline, (void *)false,
230 (void **)&errdev);
231 if (status == AE_SUPPORT) {
232 dev_warn(errdev, "Offline disabled.\n");
233 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
234 acpi_bus_online, NULL, NULL, NULL);
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100235 return -EPERM;
236 }
237 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200238 if (errdev) {
239 errdev = NULL;
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200240 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100241 NULL, acpi_bus_offline, (void *)true,
242 (void **)&errdev);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200243 if (!errdev || acpi_force_hot_remove)
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100244 acpi_bus_offline(handle, 0, (void *)true,
245 (void **)&errdev);
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200246
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200247 if (errdev && !acpi_force_hot_remove) {
248 dev_warn(errdev, "Offline failed.\n");
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100249 acpi_bus_online(handle, 0, NULL, NULL);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200250 acpi_walk_namespace(ACPI_TYPE_ANY, handle,
Rafael J. Wysocki7f28dde2013-11-07 01:41:14 +0100251 ACPI_UINT32_MAX, acpi_bus_online,
252 NULL, NULL, NULL);
Rafael J. Wysocki303bfdb2013-05-23 10:43:13 +0200253 return -EBUSY;
254 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200255 }
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100256 return 0;
257}
258
259static int acpi_scan_hot_remove(struct acpi_device *device)
260{
261 acpi_handle handle = device->handle;
262 unsigned long long sta;
263 acpi_status status;
264
Tang Chendee15922014-08-08 10:30:45 +0800265 if (device->handler && device->handler->hotplug.demand_offline
266 && !acpi_force_hot_remove) {
Rafael J. Wysockicaa73ea2013-12-29 15:25:48 +0100267 if (!acpi_scan_is_offline(device, true))
Rafael J. Wysockid22ddcb2013-12-29 15:25:35 +0100268 return -EBUSY;
269 } else {
270 int error = acpi_scan_try_to_offline(device);
271 if (error)
272 return error;
273 }
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200274
Zhang Rui26d46862008-04-29 02:35:48 -0400275 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Kay Sievers07944692008-10-30 01:18:59 +0100276 "Hot-removing device %s...\n", dev_name(&device->dev)));
Zhang Rui26d46862008-04-29 02:35:48 -0400277
Rafael J. Wysockibfee26d2013-01-26 00:27:44 +0100278 acpi_bus_trim(device);
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200279
Jiang Liu7d2421f2013-06-29 00:24:40 +0800280 acpi_evaluate_lck(handle, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 /*
282 * TBD: _EJD support.
283 */
Jiang Liu7d2421f2013-06-29 00:24:40 +0800284 status = acpi_evaluate_ej0(handle);
285 if (status == AE_NOT_FOUND)
286 return -ENODEV;
287 else if (ACPI_FAILURE(status))
288 return -EIO;
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100289
Toshi Kani882fd122013-03-13 19:29:26 +0000290 /*
291 * Verify if eject was indeed successful. If not, log an error
292 * message. No need to call _OST since _EJ0 call was made OK.
293 */
294 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
295 if (ACPI_FAILURE(status)) {
296 acpi_handle_warn(handle,
297 "Status check after eject failed (0x%x)\n", status);
298 } else if (sta & ACPI_STA_DEVICE_ENABLED) {
299 acpi_handle_warn(handle,
300 "Eject incomplete - status 0x%llx\n", sta);
301 }
302
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100303 return 0;
304}
Rafael J. Wysockif058cdf2013-02-09 15:29:11 +0100305
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100306static int acpi_scan_device_not_present(struct acpi_device *adev)
307{
308 if (!acpi_device_enumerated(adev)) {
309 dev_warn(&adev->dev, "Still not present\n");
310 return -EALREADY;
311 }
312 acpi_bus_trim(adev);
313 return 0;
314}
315
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100316static int acpi_scan_device_check(struct acpi_device *adev)
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100317{
Rafael J. Wysockif943db42013-08-28 21:41:07 +0200318 int error;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100319
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100320 acpi_bus_get_status(adev);
321 if (adev->status.present || adev->status.functional) {
322 /*
323 * This function is only called for device objects for which
324 * matching scan handlers exist. The only situation in which
325 * the scan handler is not attached to this device object yet
326 * is when the device has just appeared (either it wasn't
327 * present at all before or it was removed and then added
328 * again).
329 */
330 if (adev->handler) {
331 dev_warn(&adev->dev, "Already enumerated\n");
332 return -EALREADY;
333 }
334 error = acpi_bus_scan(adev->handle);
335 if (error) {
336 dev_warn(&adev->dev, "Namespace scan failure\n");
337 return error;
338 }
339 if (!adev->handler) {
340 dev_warn(&adev->dev, "Enumeration failure\n");
341 error = -ENODEV;
342 }
343 } else {
344 error = acpi_scan_device_not_present(adev);
345 }
346 return error;
347}
348
349static int acpi_scan_bus_check(struct acpi_device *adev)
350{
351 struct acpi_scan_handler *handler = adev->handler;
352 struct acpi_device *child;
353 int error;
354
355 acpi_bus_get_status(adev);
356 if (!(adev->status.present || adev->status.functional)) {
357 acpi_scan_device_not_present(adev);
358 return 0;
359 }
360 if (handler && handler->hotplug.scan_dependent)
361 return handler->hotplug.scan_dependent(adev);
362
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100363 error = acpi_bus_scan(adev->handle);
364 if (error) {
365 dev_warn(&adev->dev, "Namespace scan failure\n");
366 return error;
367 }
Rafael J. Wysocki443fc822013-11-22 21:55:43 +0100368 list_for_each_entry(child, &adev->children, node) {
369 error = acpi_scan_bus_check(child);
370 if (error)
371 return error;
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100372 }
373 return 0;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100374}
375
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100376static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
377{
378 switch (type) {
379 case ACPI_NOTIFY_BUS_CHECK:
380 return acpi_scan_bus_check(adev);
381 case ACPI_NOTIFY_DEVICE_CHECK:
382 return acpi_scan_device_check(adev);
383 case ACPI_NOTIFY_EJECT_REQUEST:
384 case ACPI_OST_EC_OSPM_EJECT:
Rafael J. Wysockidd2151b2014-02-04 00:44:02 +0100385 if (adev->handler && !adev->handler->hotplug.enabled) {
386 dev_info(&adev->dev, "Eject disabled\n");
387 return -EPERM;
388 }
Rafael J. Wysocki700b8422014-02-21 01:07:17 +0100389 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
390 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100391 return acpi_scan_hot_remove(adev);
392 }
393 return -EINVAL;
394}
395
Rafael J. Wysocki1e3bcb52014-03-03 00:40:38 +0100396void acpi_device_hotplug(struct acpi_device *adev, u32 src)
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100397{
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100398 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100399 int error = -ENODEV;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100400
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200401 lock_device_hotplug();
Rafael J. Wysockie0ae8fe2013-08-30 14:19:29 +0200402 mutex_lock(&acpi_scan_lock);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100403
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100404 /*
405 * The device object's ACPI handle cannot become invalid as long as we
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100406 * are holding acpi_scan_lock, but it might have become invalid before
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100407 * that lock was acquired.
408 */
409 if (adev->handle == INVALID_ACPI_HANDLE)
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100410 goto err_out;
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100411
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +0100412 if (adev->flags.is_dock_station) {
413 error = dock_notify(adev, src);
414 } else if (adev->flags.hotplug_notify) {
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100415 error = acpi_generic_hotplug_event(adev, src);
Rafael J. Wysockidd2151b2014-02-04 00:44:02 +0100416 if (error == -EPERM) {
417 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
418 goto err_out;
419 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100420 } else {
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100421 int (*notify)(struct acpi_device *, u32);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100422
423 acpi_lock_hp_context();
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100424 notify = adev->hp ? adev->hp->notify : NULL;
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100425 acpi_unlock_hp_context();
426 /*
427 * There may be additional notify handlers for device objects
428 * without the .event() callback, so ignore them here.
429 */
Rafael J. Wysockibe27b3d2014-02-21 01:10:27 +0100430 if (notify)
431 error = notify(adev, src);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100432 else
433 goto out;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100434 }
Rafael J. Wysockic27b2c32013-11-22 21:55:07 +0100435 if (!error)
436 ost_code = ACPI_OST_SC_SUCCESS;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100437
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100438 err_out:
Rafael J. Wysocki700b8422014-02-21 01:07:17 +0100439 acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +0100440
441 out:
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100442 acpi_bus_put_acpi_device(adev);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100443 mutex_unlock(&acpi_scan_lock);
Rafael J. Wysockie0ae8fe2013-08-30 14:19:29 +0200444 unlock_device_hotplug();
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100445}
446
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100447static void acpi_free_power_resources_lists(struct acpi_device *device)
448{
449 int i;
450
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100451 if (device->wakeup.flags.valid)
452 acpi_power_resources_list_free(&device->wakeup.resources);
453
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +0100454 if (!device->power.flags.power_resources)
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100455 return;
456
457 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
458 struct acpi_device_power_state *ps = &device->power.states[i];
459 acpi_power_resources_list_free(&ps->resources);
460 }
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600461}
462
Patrick Mochel1890a972006-12-07 20:56:31 +0800463static void acpi_device_release(struct device *dev)
464{
465 struct acpi_device *acpi_dev = to_acpi_device(dev);
466
Mika Westerbergffdcd952014-10-21 13:33:55 +0200467 acpi_free_properties(acpi_dev);
Toshi Kanic0af4172013-03-04 21:30:42 +0000468 acpi_free_pnp_ids(&acpi_dev->pnp);
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100469 acpi_free_power_resources_lists(acpi_dev);
Patrick Mochel1890a972006-12-07 20:56:31 +0800470 kfree(acpi_dev);
471}
472
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100473static void acpi_device_del(struct acpi_device *device)
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200474{
Lukas Wunnerca9dc8d2015-11-25 21:19:55 +0100475 struct acpi_device_bus_id *acpi_device_bus_id;
476
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100477 mutex_lock(&acpi_device_lock);
478 if (device->parent)
479 list_del(&device->node);
480
Lukas Wunnerca9dc8d2015-11-25 21:19:55 +0100481 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
482 if (!strcmp(acpi_device_bus_id->bus_id,
483 acpi_device_hid(device))) {
484 if (acpi_device_bus_id->instance_no > 0)
485 acpi_device_bus_id->instance_no--;
486 else {
487 list_del(&acpi_device_bus_id->node);
488 kfree(acpi_device_bus_id);
489 }
490 break;
491 }
492
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100493 list_del(&device->wakeup_list);
494 mutex_unlock(&acpi_device_lock);
495
496 acpi_power_add_remove_device(device, false);
497 acpi_device_remove_files(device);
498 if (device->remove)
499 device->remove(device);
500
501 device_del(&device->dev);
502}
503
Octavian Purdila68bdb672016-07-08 19:13:09 +0300504static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
505
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100506static LIST_HEAD(acpi_device_del_list);
507static DEFINE_MUTEX(acpi_device_del_lock);
508
509static void acpi_device_del_work_fn(struct work_struct *work_not_used)
510{
511 for (;;) {
512 struct acpi_device *adev;
513
514 mutex_lock(&acpi_device_del_lock);
515
516 if (list_empty(&acpi_device_del_list)) {
517 mutex_unlock(&acpi_device_del_lock);
518 break;
519 }
520 adev = list_first_entry(&acpi_device_del_list,
521 struct acpi_device, del_list);
522 list_del(&adev->del_list);
523
524 mutex_unlock(&acpi_device_del_lock);
525
Octavian Purdila68bdb672016-07-08 19:13:09 +0300526 blocking_notifier_call_chain(&acpi_reconfig_chain,
527 ACPI_RECONFIG_DEVICE_REMOVE, adev);
528
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100529 acpi_device_del(adev);
530 /*
531 * Drop references to all power resources that might have been
532 * used by the device.
533 */
534 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
535 put_device(&adev->dev);
536 }
537}
538
539/**
540 * acpi_scan_drop_device - Drop an ACPI device object.
541 * @handle: Handle of an ACPI namespace node, not used.
542 * @context: Address of the ACPI device object to drop.
543 *
544 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
545 * namespace node the device object pointed to by @context is attached to.
546 *
547 * The unregistration is carried out asynchronously to avoid running
548 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
549 * ensure the correct ordering (the device objects must be unregistered in the
550 * same order in which the corresponding namespace nodes are deleted).
551 */
552static void acpi_scan_drop_device(acpi_handle handle, void *context)
553{
554 static DECLARE_WORK(work, acpi_device_del_work_fn);
555 struct acpi_device *adev = context;
556
557 mutex_lock(&acpi_device_del_lock);
558
559 /*
560 * Use the ACPI hotplug workqueue which is ordered, so this work item
561 * won't run after any hotplug work items submitted subsequently. That
562 * prevents attempts to register device objects identical to those being
563 * deleted from happening concurrently (such attempts result from
564 * hotplug events handled via the ACPI hotplug workqueue). It also will
565 * run after all of the work items submitted previosuly, which helps
566 * those work items to ensure that they are not accessing stale device
567 * objects.
568 */
569 if (list_empty(&acpi_device_del_list))
570 acpi_queue_hotplug_work(&work);
571
572 list_add_tail(&adev->del_list, &acpi_device_del_list);
573 /* Make acpi_ns_validate_handle() return NULL for this handle. */
574 adev->handle = INVALID_ACPI_HANDLE;
575
576 mutex_unlock(&acpi_device_del_lock);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200577}
578
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100579static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
580 void (*callback)(void *))
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200581{
582 acpi_status status;
583
584 if (!device)
585 return -EINVAL;
586
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100587 status = acpi_get_data_full(handle, acpi_scan_drop_device,
588 (void **)device, callback);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200589 if (ACPI_FAILURE(status) || !*device) {
590 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
591 handle));
592 return -ENODEV;
593 }
594 return 0;
595}
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100596
597int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
598{
599 return acpi_get_device_data(handle, device, NULL);
600}
Rafael J. Wysocki65859252013-10-01 23:02:43 +0200601EXPORT_SYMBOL(acpi_bus_get_device);
Rafael J. Wysockicaf5c032013-07-30 14:38:34 +0200602
Rafael J. Wysocki78ea4632014-02-04 00:43:05 +0100603static void get_acpi_device(void *dev)
604{
605 if (dev)
606 get_device(&((struct acpi_device *)dev)->dev);
607}
608
609struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
610{
611 struct acpi_device *adev = NULL;
612
613 acpi_get_device_data(handle, &adev, get_acpi_device);
614 return adev;
615}
616
617void acpi_bus_put_acpi_device(struct acpi_device *adev)
618{
619 put_device(&adev->dev);
620}
621
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100622int acpi_device_add(struct acpi_device *device,
623 void (*release)(struct device *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800625 int result;
626 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
627 int found = 0;
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000628
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100629 if (device->handle) {
630 acpi_status status;
631
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100632 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100633 device);
634 if (ACPI_FAILURE(status)) {
635 acpi_handle_err(device->handle,
636 "Unable to attach device data\n");
637 return -ENODEV;
638 }
639 }
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 /*
642 * Linkage
643 * -------
644 * Link this device to its parent and siblings.
645 */
646 INIT_LIST_HEAD(&device->children);
647 INIT_LIST_HEAD(&device->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 INIT_LIST_HEAD(&device->wakeup_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800649 INIT_LIST_HEAD(&device->physical_node_list);
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100650 INIT_LIST_HEAD(&device->del_list);
Lan Tianyu1033f902012-08-17 14:44:09 +0800651 mutex_init(&device->physical_node_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800653 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
654 if (!new_bus_id) {
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100655 pr_err(PREFIX "Memory allocation error\n");
656 result = -ENOMEM;
657 goto err_detach;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800658 }
659
Shaohua Li90905892009-04-07 10:24:29 +0800660 mutex_lock(&acpi_device_lock);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800661 /*
662 * Find suitable bus_id and instance number in acpi_bus_id_list
663 * If failed, create one and link it into acpi_bus_id_list
664 */
665 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600666 if (!strcmp(acpi_device_bus_id->bus_id,
667 acpi_device_hid(device))) {
668 acpi_device_bus_id->instance_no++;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800669 found = 1;
670 kfree(new_bus_id);
671 break;
672 }
673 }
Alex Chiang0c526d92009-05-14 08:31:37 -0600674 if (!found) {
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800675 acpi_device_bus_id = new_bus_id;
Bjorn Helgaas1131b932009-09-21 13:35:29 -0600676 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800677 acpi_device_bus_id->instance_no = 0;
678 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
679 }
Kay Sievers07944692008-10-30 01:18:59 +0100680 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 +0800681
Len Brown33b57152008-12-15 22:09:26 -0500682 if (device->parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 list_add_tail(&device->node, &device->parent->children);
Len Brown33b57152008-12-15 22:09:26 -0500684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 if (device->wakeup.flags.valid)
686 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
Shaohua Li90905892009-04-07 10:24:29 +0800687 mutex_unlock(&acpi_device_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Patrick Mochel1890a972006-12-07 20:56:31 +0800689 if (device->parent)
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +0000690 device->dev.parent = &device->parent->dev;
Patrick Mochel1890a972006-12-07 20:56:31 +0800691 device->dev.bus = &acpi_bus_type;
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +0100692 device->dev.release = release;
Rafael J. Wysockicf860be2013-01-24 12:49:49 +0100693 result = device_add(&device->dev);
Alex Chiang0c526d92009-05-14 08:31:37 -0600694 if (result) {
Alex Chiang8b12b922009-05-14 08:31:32 -0600695 dev_err(&device->dev, "Error registering device\n");
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100696 goto err;
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800697 }
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800698
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800699 result = acpi_device_setup_files(device);
Alex Chiang0c526d92009-05-14 08:31:37 -0600700 if (result)
Kay Sievers07944692008-10-30 01:18:59 +0100701 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
702 dev_name(&device->dev));
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800703
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800704 return 0;
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100705
706 err:
Shaohua Li90905892009-04-07 10:24:29 +0800707 mutex_lock(&acpi_device_lock);
Len Brown33b57152008-12-15 22:09:26 -0500708 if (device->parent)
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800709 list_del(&device->node);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800710 list_del(&device->wakeup_list);
Shaohua Li90905892009-04-07 10:24:29 +0800711 mutex_unlock(&acpi_device_lock);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100712
713 err_detach:
Rafael J. Wysockid7831562013-11-22 21:52:12 +0100714 acpi_detach_data(device->handle, acpi_scan_drop_device);
Zhang Ruie49bd2dd2006-12-08 17:23:43 +0800715 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
Zhang Rui9e89dde2006-12-07 20:56:16 +0800718/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 Device Enumeration
720 -------------------------------------------------------------------------- */
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000721static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
722{
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100723 struct acpi_device *device = NULL;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000724 acpi_status status;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000725
726 /*
727 * Fixed hardware devices do not appear in the namespace and do not
728 * have handles, but we fabricate acpi_devices for them, so we have
729 * to deal with them specially.
730 */
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100731 if (!handle)
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000732 return acpi_root;
733
734 do {
735 status = acpi_get_parent(handle, &handle);
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000736 if (ACPI_FAILURE(status))
Rafael J. Wysocki456de892013-01-31 20:57:40 +0100737 return status == AE_NULL_ENTRY ? NULL : acpi_root;
738 } while (acpi_bus_get_device(handle, &device));
739 return device;
Bjorn Helgaas5c478f42009-09-21 19:29:35 +0000740}
741
Len Brownc8f7a622006-07-09 17:22:28 -0400742acpi_status
743acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
744{
745 acpi_status status;
746 acpi_handle tmp;
747 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
748 union acpi_object *obj;
749
750 status = acpi_get_handle(handle, "_EJD", &tmp);
751 if (ACPI_FAILURE(status))
752 return status;
753
754 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
755 if (ACPI_SUCCESS(status)) {
756 obj = buffer.pointer;
Holger Macht3b5fee52008-02-14 13:40:34 +0100757 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
758 ejd);
Len Brownc8f7a622006-07-09 17:22:28 -0400759 kfree(buffer.pointer);
760 }
761 return status;
762}
763EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
764
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100765static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
766 struct acpi_device_wakeup *wakeup)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767{
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100768 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
769 union acpi_object *package = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 union acpi_object *element = NULL;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100771 acpi_status status;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100772 int err = -ENODATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100774 if (!wakeup)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100775 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100777 INIT_LIST_HEAD(&wakeup->resources);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100779 /* _PRW */
780 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
781 if (ACPI_FAILURE(status)) {
782 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100783 return err;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100784 }
785
786 package = (union acpi_object *)buffer.pointer;
787
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100788 if (!package || package->package.count < 2)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100789 goto out;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 element = &(package->package.elements[0]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100792 if (!element)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100793 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100794
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (element->type == ACPI_TYPE_PACKAGE) {
796 if ((element->package.count < 2) ||
797 (element->package.elements[0].type !=
798 ACPI_TYPE_LOCAL_REFERENCE)
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100799 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100800 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100801
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100802 wakeup->gpe_device =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 element->package.elements[0].reference.handle;
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100804 wakeup->gpe_number =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 (u32) element->package.elements[1].integer.value;
806 } else if (element->type == ACPI_TYPE_INTEGER) {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100807 wakeup->gpe_device = NULL;
808 wakeup->gpe_number = element->integer.value;
809 } else {
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100810 goto out;
811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
813 element = &(package->package.elements[1]);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100814 if (element->type != ACPI_TYPE_INTEGER)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100815 goto out;
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100816
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100817 wakeup->sleep_state = element->integer.value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100819 err = acpi_extract_power_resources(package, 2, &wakeup->resources);
820 if (err)
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100821 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Rafael J. Wysocki0596a522013-01-17 14:11:07 +0100823 if (!list_empty(&wakeup->resources)) {
824 int sleep_state;
825
Rafael J. Wysockib5d667e2013-02-23 23:15:21 +0100826 err = acpi_power_wakeup_list_init(&wakeup->resources,
827 &sleep_state);
828 if (err) {
829 acpi_handle_warn(handle, "Retrieving current states "
830 "of wakeup power resources failed\n");
831 acpi_power_resources_list_free(&wakeup->resources);
832 goto out;
833 }
Rafael J. Wysocki0596a522013-01-17 14:11:07 +0100834 if (sleep_state < wakeup->sleep_state) {
835 acpi_handle_warn(handle, "Overriding _PRW sleep state "
836 "(S%d) by S%d from power resources\n",
837 (int)wakeup->sleep_state, sleep_state);
838 wakeup->sleep_state = sleep_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
Rafael J. Wysocki98746472010-07-08 00:43:36 +0200841
Rafael J. Wysockib581a7f2010-12-17 22:34:01 +0100842 out:
843 kfree(buffer.pointer);
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100844 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845}
846
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200847static void acpi_wakeup_gpe_init(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
Mathias Krause0519ade2015-06-13 14:26:58 +0200849 static const struct acpi_device_id button_device_ids[] = {
Thomas Renninger29b71a12007-07-23 14:43:51 +0200850 {"PNP0C0C", 0},
Zhang Ruib7e38302012-12-04 23:23:16 +0100851 {"PNP0C0D", 0},
Thomas Renninger29b71a12007-07-23 14:43:51 +0200852 {"PNP0C0E", 0},
853 {"", 0},
854 };
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200855 struct acpi_device_wakeup *wakeup = &device->wakeup;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100856 acpi_status status;
857 acpi_event_status event_status;
858
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200859 wakeup->flags.notifier_present = 0;
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100860
861 /* Power button, Lid switch always enable wakeup */
862 if (!acpi_match_device_ids(device, button_device_ids)) {
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200863 wakeup->flags.run_wake = 1;
Zhang Ruib7e38302012-12-04 23:23:16 +0100864 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
865 /* Do not use Lid/sleep button for S5 wakeup */
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200866 if (wakeup->sleep_state == ACPI_STATE_S5)
867 wakeup->sleep_state = ACPI_STATE_S4;
Zhang Ruib7e38302012-12-04 23:23:16 +0100868 }
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200869 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
Rafael J. Wysockif2b56bc2011-01-06 23:34:22 +0100870 device_set_wakeup_capable(&device->dev, true);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100871 return;
872 }
873
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200874 acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
875 wakeup->gpe_number);
876 status = acpi_get_gpe_status(wakeup->gpe_device, wakeup->gpe_number,
877 &event_status);
878 if (ACPI_FAILURE(status))
879 return;
880
Lv Zheng2f857232014-10-10 10:40:05 +0800881 wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER);
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100882}
883
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100884static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
Rafael J. Wysockif5177092010-02-17 23:41:49 +0100885{
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100886 int err;
Thomas Renninger29b71a12007-07-23 14:43:51 +0200887
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100888 /* Presence of _PRW indicates wake capable */
Jiang Liu952c63e2013-06-29 00:24:38 +0800889 if (!acpi_has_method(device->handle, "_PRW"))
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100890 return;
891
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100892 err = acpi_bus_extract_wakeup_device_power_package(device->handle,
893 &device->wakeup);
894 if (err) {
895 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +0100896 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 device->wakeup.flags.valid = 1;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200900 device->wakeup.prepare_count = 0;
Rafael J. Wysockibd9b2f92014-07-14 22:41:41 +0200901 acpi_wakeup_gpe_init(device);
Zhao Yakui729b2bd2008-03-19 13:26:54 +0800902 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
903 * system for the ACPI device with the _PRW object.
904 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
905 * So it is necessary to call _DSW object first. Only when it is not
906 * present will the _PSW object used.
907 */
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100908 err = acpi_device_sleep_wake(device, 0, 0, 0);
909 if (err)
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200910 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
911 "error in _DSW or _PSW evaluation\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912}
913
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100914static void acpi_bus_init_power_state(struct acpi_device *device, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100916 struct acpi_device_power_state *ps = &device->power.states[state];
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100917 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
918 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100919 acpi_status status;
Zhang Rui9e89dde2006-12-07 20:56:16 +0800920
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100921 INIT_LIST_HEAD(&ps->resources);
922
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100923 /* Evaluate "_PRx" to get referenced power resources */
924 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
925 if (ACPI_SUCCESS(status)) {
926 union acpi_object *package = buffer.pointer;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100927
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100928 if (buffer.length && package
929 && package->type == ACPI_TYPE_PACKAGE
930 && package->package.count) {
Rafael J. Wysockie88c9c62013-01-17 14:11:07 +0100931 int err = acpi_extract_power_resources(package, 0,
932 &ps->resources);
933 if (!err)
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100934 device->power.flags.power_resources = 1;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100935 }
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100936 ACPI_FREE(buffer.pointer);
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100937 }
938
939 /* Evaluate "_PSx" to see if we can do explicit sets */
Rafael J. Wysockief85bdb2013-01-17 14:11:07 +0100940 pathname[2] = 'S';
Jiang Liu952c63e2013-06-29 00:24:38 +0800941 if (acpi_has_method(device->handle, pathname))
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100942 ps->flags.explicit_set = 1;
943
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200944 /* State is valid if there are means to put the device into it. */
945 if (!list_empty(&ps->resources) || ps->flags.explicit_set)
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100946 ps->flags.valid = 1;
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100947
948 ps->power = -1; /* Unknown - driver assigned */
949 ps->latency = -1; /* Unknown - driver assigned */
950}
951
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100952static void acpi_bus_get_power_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953{
Rafael J. Wysocki8bc50532013-01-17 14:11:07 +0100954 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100956 /* Presence of _PS0|_PR0 indicates 'power manageable' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800957 if (!acpi_has_method(device->handle, "_PS0") &&
958 !acpi_has_method(device->handle, "_PR0"))
959 return;
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100960
961 device->flags.power_manageable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800964 * Power Management Flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 */
Jiang Liu952c63e2013-06-29 00:24:38 +0800966 if (acpi_has_method(device->handle, "_PSC"))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800967 device->power.flags.explicit_get = 1;
Rafael J. Wysockif25c0ae2014-05-17 00:18:13 +0200968
Jiang Liu952c63e2013-06-29 00:24:38 +0800969 if (acpi_has_method(device->handle, "_IRC"))
Zhang Rui9e89dde2006-12-07 20:56:16 +0800970 device->power.flags.inrush_current = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
Rafael J. Wysockif25c0ae2014-05-17 00:18:13 +0200972 if (acpi_has_method(device->handle, "_DSW"))
973 device->power.flags.dsw_present = 1;
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 /*
Zhang Rui9e89dde2006-12-07 20:56:16 +0800976 * Enumerate supported power management states
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 */
Rafael J. Wysockif33ce562013-01-17 14:11:06 +0100978 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
979 acpi_bus_init_power_state(device, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100981 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200982 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources))
983 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200985 /* Set defaults for D0 and D3hot states (always valid) */
Zhang Rui9e89dde2006-12-07 20:56:16 +0800986 device->power.states[ACPI_STATE_D0].flags.valid = 1;
987 device->power.states[ACPI_STATE_D0].power = 100;
Rafael J. Wysocki20dacb72015-05-16 01:55:35 +0200988 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1;
Aaron Lu1399dfc2012-11-21 23:33:40 +0100989
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +0100990 if (acpi_bus_init_power(device))
Rafael J. Wysockib3785492013-02-01 23:43:02 +0100991 device->flags.power_manageable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992}
993
Rafael J. Wysockid43e1672013-01-17 14:11:05 +0100994static void acpi_bus_get_flags(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 /* Presence of _STA indicates 'dynamic_status' */
Jiang Liu952c63e2013-06-29 00:24:38 +0800997 if (acpi_has_method(device->handle, "_STA"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 device->flags.dynamic_status = 1;
999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 /* Presence of _RMV indicates 'removable' */
Jiang Liu952c63e2013-06-29 00:24:38 +08001001 if (acpi_has_method(device->handle, "_RMV"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 device->flags.removable = 1;
1003
1004 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
Jiang Liu952c63e2013-06-29 00:24:38 +08001005 if (acpi_has_method(device->handle, "_EJD") ||
1006 acpi_has_method(device->handle, "_EJ0"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 device->flags.ejectable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
Bjorn Helgaasc7bcb4e2009-09-21 19:29:25 +00001010static void acpi_device_get_busid(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011{
Len Brown4be44fc2005-08-05 00:44:28 -04001012 char bus_id[5] = { '?', 0 };
1013 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1014 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 /*
1017 * Bus ID
1018 * ------
1019 * The device's Bus ID is simply the object name.
1020 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1021 */
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001022 if (ACPI_IS_ROOT_DEVICE(device)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 strcpy(device->pnp.bus_id, "ACPI");
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001024 return;
1025 }
1026
1027 switch (device->device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 case ACPI_BUS_TYPE_POWER_BUTTON:
1029 strcpy(device->pnp.bus_id, "PWRF");
1030 break;
1031 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1032 strcpy(device->pnp.bus_id, "SLPF");
1033 break;
1034 default:
Bjorn Helgaas66b7ed42009-09-21 19:29:05 +00001035 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 /* Clean up trailing underscores (if any) */
1037 for (i = 3; i > 1; i--) {
1038 if (bus_id[i] == '_')
1039 bus_id[i] = '\0';
1040 else
1041 break;
1042 }
1043 strcpy(device->pnp.bus_id, bus_id);
1044 break;
1045 }
1046}
1047
Zhang Rui54735262007-01-11 02:09:09 -05001048/*
Jiang Liuebf4df82013-06-29 00:24:41 +08001049 * acpi_ata_match - see if an acpi object is an ATA device
1050 *
1051 * If an acpi object has one of the ACPI ATA methods defined,
1052 * then we can safely call it an ATA device.
1053 */
1054bool acpi_ata_match(acpi_handle handle)
1055{
1056 return acpi_has_method(handle, "_GTF") ||
1057 acpi_has_method(handle, "_GTM") ||
1058 acpi_has_method(handle, "_STM") ||
1059 acpi_has_method(handle, "_SDD");
1060}
1061
1062/*
Toshi Kanid4e1a692013-03-04 21:30:41 +00001063 * acpi_bay_match - see if an acpi object is an ejectable driver bay
Zhang Rui54735262007-01-11 02:09:09 -05001064 *
1065 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1066 * then we can safely call it an ejectable drive bay
1067 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001068bool acpi_bay_match(acpi_handle handle)
Toshi Kanid4e1a692013-03-04 21:30:41 +00001069{
Zhang Rui54735262007-01-11 02:09:09 -05001070 acpi_handle phandle;
1071
Jiang Liu952c63e2013-06-29 00:24:38 +08001072 if (!acpi_has_method(handle, "_EJ0"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001073 return false;
1074 if (acpi_ata_match(handle))
1075 return true;
1076 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1077 return false;
Zhang Rui54735262007-01-11 02:09:09 -05001078
Jiang Liuebf4df82013-06-29 00:24:41 +08001079 return acpi_ata_match(phandle);
Zhang Rui54735262007-01-11 02:09:09 -05001080}
1081
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001082bool acpi_device_is_battery(struct acpi_device *adev)
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001083{
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001084 struct acpi_hardware_id *hwid;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001085
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001086 list_for_each_entry(hwid, &adev->pnp.ids, list)
1087 if (!strcmp("PNP0C0A", hwid->id))
1088 return true;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001089
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001090 return false;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001091}
1092
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001093static bool is_ejectable_bay(struct acpi_device *adev)
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001094{
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001095 acpi_handle handle = adev->handle;
1096
1097 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001098 return true;
1099
1100 return acpi_bay_match(handle);
1101}
1102
Frank Seidel3620f2f2007-12-07 13:20:34 +01001103/*
Toshi Kanid4e1a692013-03-04 21:30:41 +00001104 * acpi_dock_match - see if an acpi object has a _DCK method
Frank Seidel3620f2f2007-12-07 13:20:34 +01001105 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001106bool acpi_dock_match(acpi_handle handle)
Frank Seidel3620f2f2007-12-07 13:20:34 +01001107{
Jiang Liuebf4df82013-06-29 00:24:41 +08001108 return acpi_has_method(handle, "_DCK");
Frank Seidel3620f2f2007-12-07 13:20:34 +01001109}
1110
Hans de Goedeadc8bb82015-06-16 16:27:45 +02001111static acpi_status
1112acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
1113 void **return_value)
1114{
1115 long *cap = context;
1116
1117 if (acpi_has_method(handle, "_BCM") &&
1118 acpi_has_method(handle, "_BCL")) {
1119 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight "
1120 "support\n"));
1121 *cap |= ACPI_VIDEO_BACKLIGHT;
1122 if (!acpi_has_method(handle, "_BQC"))
1123 printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, "
1124 "cannot determine initial brightness\n");
1125 /* We have backlight support, no need to scan further */
1126 return AE_CTRL_TERMINATE;
1127 }
1128 return 0;
1129}
1130
1131/* Returns true if the ACPI object is a video device which can be
1132 * handled by video.ko.
1133 * The device will get a Linux specific CID added in scan.c to
1134 * identify the device as an ACPI graphics device
1135 * Be aware that the graphics device may not be physically present
1136 * Use acpi_video_get_capabilities() to detect general ACPI video
1137 * capabilities of present cards
1138 */
1139long acpi_is_video_device(acpi_handle handle)
1140{
1141 long video_caps = 0;
1142
1143 /* Is this device able to support video switching ? */
1144 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS"))
1145 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
1146
1147 /* Is this device able to retrieve a video ROM ? */
1148 if (acpi_has_method(handle, "_ROM"))
1149 video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
1150
1151 /* Is this device able to configure which video head to be POSTed ? */
1152 if (acpi_has_method(handle, "_VPO") &&
1153 acpi_has_method(handle, "_GPD") &&
1154 acpi_has_method(handle, "_SPD"))
1155 video_caps |= ACPI_VIDEO_DEVICE_POSTING;
1156
1157 /* Only check for backlight functionality if one of the above hit. */
1158 if (video_caps)
1159 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1160 ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL,
1161 &video_caps, NULL);
1162
1163 return video_caps;
1164}
1165EXPORT_SYMBOL(acpi_is_video_device);
1166
Thomas Renninger620e1122010-10-01 10:54:00 +02001167const char *acpi_device_hid(struct acpi_device *device)
Bob Moore15b8dd52009-06-29 13:39:29 +08001168{
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001169 struct acpi_hardware_id *hid;
Bob Moore15b8dd52009-06-29 13:39:29 +08001170
Thomas Renninger2b2ae7c2010-10-01 10:53:59 +02001171 if (list_empty(&device->pnp.ids))
1172 return dummy_hid;
1173
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001174 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1175 return hid->id;
1176}
1177EXPORT_SYMBOL(acpi_device_hid);
Bob Moore15b8dd52009-06-29 13:39:29 +08001178
Toshi Kanid4e1a692013-03-04 21:30:41 +00001179static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001180{
1181 struct acpi_hardware_id *id;
Bob Moore15b8dd52009-06-29 13:39:29 +08001182
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001183 id = kmalloc(sizeof(*id), GFP_KERNEL);
1184 if (!id)
1185 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001186
Rasmus Villemoes6a0d12e2015-09-09 23:59:43 +02001187 id->id = kstrdup_const(dev_id, GFP_KERNEL);
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001188 if (!id->id) {
1189 kfree(id);
1190 return;
Bob Moore15b8dd52009-06-29 13:39:29 +08001191 }
1192
Toshi Kanid4e1a692013-03-04 21:30:41 +00001193 list_add_tail(&id->list, &pnp->ids);
1194 pnp->type.hardware_id = 1;
Bob Moore15b8dd52009-06-29 13:39:29 +08001195}
1196
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001197/*
1198 * Old IBM workstations have a DSDT bug wherein the SMBus object
1199 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1200 * prefix. Work around this.
1201 */
Jiang Liuebf4df82013-06-29 00:24:41 +08001202static bool acpi_ibm_smbus_match(acpi_handle handle)
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001203{
Jiang Liuebf4df82013-06-29 00:24:41 +08001204 char node_name[ACPI_PATH_SEGMENT_LENGTH];
1205 struct acpi_buffer path = { sizeof(node_name), node_name };
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001206
1207 if (!dmi_name_in_vendors("IBM"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001208 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001209
1210 /* Look for SMBS object */
Jiang Liuebf4df82013-06-29 00:24:41 +08001211 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1212 strcmp("SMBS", path.pointer))
1213 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001214
1215 /* Does it have the necessary (but misnamed) methods? */
Jiang Liu952c63e2013-06-29 00:24:38 +08001216 if (acpi_has_method(handle, "SBI") &&
1217 acpi_has_method(handle, "SBR") &&
1218 acpi_has_method(handle, "SBW"))
Jiang Liuebf4df82013-06-29 00:24:41 +08001219 return true;
1220
1221 return false;
Darrick J. Wong222e82a2010-03-24 14:38:37 +01001222}
1223
Jiang Liuae3caa82014-02-19 14:02:19 +08001224static bool acpi_object_is_system_bus(acpi_handle handle)
1225{
1226 acpi_handle tmp;
1227
1228 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
1229 tmp == handle)
1230 return true;
1231 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
1232 tmp == handle)
1233 return true;
1234
1235 return false;
1236}
1237
Toshi Kanic0af4172013-03-04 21:30:42 +00001238static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1239 int device_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240{
Len Brown4be44fc2005-08-05 00:44:28 -04001241 acpi_status status;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001242 struct acpi_device_info *info;
Lv Zheng78e25fe2012-10-31 02:25:24 +00001243 struct acpi_pnp_device_id_list *cid_list;
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -06001244 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Toshi Kanic0af4172013-03-04 21:30:42 +00001246 switch (device_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 case ACPI_BUS_TYPE_DEVICE:
Toshi Kanic0af4172013-03-04 21:30:42 +00001248 if (handle == ACPI_ROOT_OBJECT) {
1249 acpi_add_id(pnp, ACPI_SYSTEM_HID);
Bjorn Helgaas859ac9a42009-09-21 19:29:50 +00001250 break;
1251 }
1252
Toshi Kanic0af4172013-03-04 21:30:42 +00001253 status = acpi_get_object_info(handle, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 if (ACPI_FAILURE(status)) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001255 pr_err(PREFIX "%s: Error reading device info\n",
1256 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 return;
1258 }
1259
Rafael J. Wysocki549e6842014-05-30 04:26:18 +02001260 if (info->valid & ACPI_VALID_HID) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001261 acpi_add_id(pnp, info->hardware_id.string);
Rafael J. Wysocki549e6842014-05-30 04:26:18 +02001262 pnp->type.platform_id = 1;
1263 }
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001264 if (info->valid & ACPI_VALID_CID) {
Bob Moore15b8dd52009-06-29 13:39:29 +08001265 cid_list = &info->compatible_id_list;
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001266 for (i = 0; i < cid_list->count; i++)
Toshi Kanic0af4172013-03-04 21:30:42 +00001267 acpi_add_id(pnp, cid_list->ids[i].string);
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 if (info->valid & ACPI_VALID_ADR) {
Toshi Kanic0af4172013-03-04 21:30:42 +00001270 pnp->bus_address = info->address;
1271 pnp->type.bus_address = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 }
Lv Zhengccf78042012-10-30 14:41:07 +01001273 if (info->valid & ACPI_VALID_UID)
Toshi Kanic0af4172013-03-04 21:30:42 +00001274 pnp->unique_id = kstrdup(info->unique_id.string,
Lv Zhengccf78042012-10-30 14:41:07 +01001275 GFP_KERNEL);
Suthikulpanit, Suravee26095a02015-07-07 01:55:20 +02001276 if (info->valid & ACPI_VALID_CLS)
1277 acpi_add_id(pnp, info->class_code.string);
Zhang Ruiae843332006-12-07 20:57:10 +08001278
Bjorn Helgaasa83893ae2009-10-02 11:03:12 -04001279 kfree(info);
1280
Bjorn Helgaas57f36742009-09-21 13:35:40 -06001281 /*
1282 * Some devices don't reliably have _HIDs & _CIDs, so add
1283 * synthetic HIDs to make sure drivers can find them.
1284 */
Toshi Kanic0af4172013-03-04 21:30:42 +00001285 if (acpi_is_video_device(handle))
1286 acpi_add_id(pnp, ACPI_VIDEO_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001287 else if (acpi_bay_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001288 acpi_add_id(pnp, ACPI_BAY_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001289 else if (acpi_dock_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001290 acpi_add_id(pnp, ACPI_DOCK_HID);
Jiang Liuebf4df82013-06-29 00:24:41 +08001291 else if (acpi_ibm_smbus_match(handle))
Toshi Kanic0af4172013-03-04 21:30:42 +00001292 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
Jiang Liuae3caa82014-02-19 14:02:19 +08001293 else if (list_empty(&pnp->ids) &&
1294 acpi_object_is_system_bus(handle)) {
1295 /* \_SB, \_TZ, LNXSYBUS */
1296 acpi_add_id(pnp, ACPI_BUS_HID);
Toshi Kanic0af4172013-03-04 21:30:42 +00001297 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
1298 strcpy(pnp->device_class, ACPI_BUS_CLASS);
Bjorn Helgaasb7b30de2010-03-24 10:44:33 -06001299 }
Zhang Rui54735262007-01-11 02:09:09 -05001300
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 break;
1302 case ACPI_BUS_TYPE_POWER:
Toshi Kanic0af4172013-03-04 21:30:42 +00001303 acpi_add_id(pnp, ACPI_POWER_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 break;
1305 case ACPI_BUS_TYPE_PROCESSOR:
Toshi Kanic0af4172013-03-04 21:30:42 +00001306 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 case ACPI_BUS_TYPE_THERMAL:
Toshi Kanic0af4172013-03-04 21:30:42 +00001309 acpi_add_id(pnp, ACPI_THERMAL_HID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 break;
1311 case ACPI_BUS_TYPE_POWER_BUTTON:
Toshi Kanic0af4172013-03-04 21:30:42 +00001312 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 break;
1314 case ACPI_BUS_TYPE_SLEEP_BUTTON:
Toshi Kanic0af4172013-03-04 21:30:42 +00001315 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 break;
1317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318}
1319
Toshi Kanic0af4172013-03-04 21:30:42 +00001320void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1321{
1322 struct acpi_hardware_id *id, *tmp;
1323
1324 list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
Rasmus Villemoes6a0d12e2015-09-09 23:59:43 +02001325 kfree_const(id->id);
Toshi Kanic0af4172013-03-04 21:30:42 +00001326 kfree(id);
1327 }
1328 kfree(pnp->unique_id);
1329}
1330
Suthikulpanit, Suraveeb84f1962015-10-28 15:50:48 -07001331/**
1332 * acpi_dma_supported - Check DMA support for the specified device.
1333 * @adev: The pointer to acpi device
1334 *
1335 * Return false if DMA is not supported. Otherwise, return true
1336 */
1337bool acpi_dma_supported(struct acpi_device *adev)
1338{
1339 if (!adev)
1340 return false;
1341
1342 if (adev->flags.cca_seen)
1343 return true;
1344
1345 /*
1346 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent
1347 * DMA on "Intel platforms". Presumably that includes all x86 and
1348 * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y.
1349 */
1350 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1351 return true;
1352
1353 return false;
1354}
1355
1356/**
1357 * acpi_get_dma_attr - Check the supported DMA attr for the specified device.
1358 * @adev: The pointer to acpi device
1359 *
1360 * Return enum dev_dma_attr.
1361 */
1362enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
1363{
1364 if (!acpi_dma_supported(adev))
1365 return DEV_DMA_NOT_SUPPORTED;
1366
1367 if (adev->flags.coherent_dma)
1368 return DEV_DMA_COHERENT;
1369 else
1370 return DEV_DMA_NON_COHERENT;
1371}
1372
Suthikulpanit, Suraveed0562672015-06-10 11:08:52 -05001373static void acpi_init_coherency(struct acpi_device *adev)
1374{
1375 unsigned long long cca = 0;
1376 acpi_status status;
1377 struct acpi_device *parent = adev->parent;
1378
1379 if (parent && parent->flags.cca_seen) {
1380 /*
1381 * From ACPI spec, OSPM will ignore _CCA if an ancestor
1382 * already saw one.
1383 */
1384 adev->flags.cca_seen = 1;
1385 cca = parent->flags.coherent_dma;
1386 } else {
1387 status = acpi_evaluate_integer(adev->handle, "_CCA",
1388 NULL, &cca);
1389 if (ACPI_SUCCESS(status))
1390 adev->flags.cca_seen = 1;
1391 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1392 /*
1393 * If architecture does not specify that _CCA is
1394 * required for DMA-able devices (e.g. x86),
1395 * we default to _CCA=1.
1396 */
1397 cca = 1;
1398 else
1399 acpi_handle_debug(adev->handle,
1400 "ACPI device is missing _CCA.\n");
1401 }
1402
1403 adev->flags.coherent_dma = cca;
1404}
1405
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001406void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1407 int type, unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408{
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001409 INIT_LIST_HEAD(&device->pnp.ids);
1410 device->device_type = type;
1411 device->handle = handle;
1412 device->parent = acpi_bus_get_parent(handle);
Rafael J. Wysocki8a0662d2014-11-04 14:03:59 +01001413 device->fwnode.type = FWNODE_ACPI;
Rafael J. Wysocki25db1152013-11-22 21:56:06 +01001414 acpi_set_device_status(device, sta);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001415 acpi_device_get_busid(device);
Toshi Kanic0af4172013-03-04 21:30:42 +00001416 acpi_set_pnp_ids(handle, &device->pnp, type);
Mika Westerbergffdcd952014-10-21 13:33:55 +02001417 acpi_init_properties(device);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001418 acpi_bus_get_flags(device);
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001419 device->flags.match_driver = false;
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001420 device->flags.initialized = true;
Octavian Purdila10c7e202016-07-08 19:13:08 +03001421 acpi_device_clear_enumerated(device);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001422 device_initialize(&device->dev);
1423 dev_set_uevent_suppress(&device->dev, true);
Suthikulpanit, Suraveed0562672015-06-10 11:08:52 -05001424 acpi_init_coherency(device);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001425}
Bjorn Helgaasbc3b0772009-09-21 19:29:20 +00001426
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001427void acpi_device_add_finalize(struct acpi_device *device)
1428{
1429 dev_set_uevent_suppress(&device->dev, false);
1430 kobject_uevent(&device->dev.kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431}
1432
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001433static int acpi_add_single_object(struct acpi_device **child,
1434 acpi_handle handle, int type,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001435 unsigned long long sta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436{
Bjorn Helgaas77c24882009-09-21 19:29:30 +00001437 int result;
1438 struct acpi_device *device;
Bjorn Helgaas29aaefa2009-09-21 19:28:54 +00001439 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Burman Yan36bcbec2006-12-19 12:56:11 -08001441 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 if (!device) {
Len Brown64684632006-06-26 23:41:38 -04001443 printk(KERN_ERR PREFIX "Memory allocation error\n");
Patrick Mocheld550d982006-06-27 00:41:40 -04001444 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001447 acpi_init_device_object(device, handle, type, sta);
1448 acpi_bus_get_power_flags(device);
Rafael J. Wysockid57d09a2011-01-06 23:41:27 +01001449 acpi_bus_get_wakeup_device_flags(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001451 result = acpi_device_add(device, acpi_device_release);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001452 if (result) {
Hugh Dickins718fb0d2009-08-06 23:18:12 +00001453 acpi_device_release(&device->dev);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001454 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 }
1456
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001457 acpi_power_add_remove_device(device, true);
Rafael J. Wysockicf860be2013-01-24 12:49:49 +01001458 acpi_device_add_finalize(device);
Rafael J. Wysockid43e1672013-01-17 14:11:05 +01001459 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1460 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1461 dev_name(&device->dev), (char *) buffer.pointer,
1462 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1463 kfree(buffer.pointer);
1464 *child = device;
1465 return 0;
Rafael J. Wysockibf325f92010-11-25 00:10:44 +01001466}
1467
Shannon Zhaoa4e081b2016-04-07 20:03:18 +08001468static acpi_status acpi_get_resource_memory(struct acpi_resource *ares,
1469 void *context)
1470{
1471 struct resource *res = context;
1472
1473 if (acpi_dev_resource_memory(ares, res))
1474 return AE_CTRL_TERMINATE;
1475
1476 return AE_OK;
1477}
1478
1479static bool acpi_device_should_be_hidden(acpi_handle handle)
1480{
1481 acpi_status status;
1482 struct resource res;
1483
1484 /* Check if it should ignore the UART device */
1485 if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS)))
1486 return false;
1487
1488 /*
1489 * The UART device described in SPCR table is assumed to have only one
1490 * memory resource present. So we only look for the first one here.
1491 */
1492 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1493 acpi_get_resource_memory, &res);
1494 if (ACPI_FAILURE(status) || res.start != spcr_uart_addr)
1495 return false;
1496
1497 acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n",
1498 &res.start);
1499
1500 return true;
1501}
1502
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001503static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1504 unsigned long long *sta)
1505{
1506 acpi_status status;
1507 acpi_object_type acpi_type;
1508
1509 status = acpi_get_type(handle, &acpi_type);
1510 if (ACPI_FAILURE(status))
1511 return -ENODEV;
1512
1513 switch (acpi_type) {
1514 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
1515 case ACPI_TYPE_DEVICE:
Shannon Zhaoa4e081b2016-04-07 20:03:18 +08001516 if (acpi_device_should_be_hidden(handle))
1517 return -ENODEV;
1518
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001519 *type = ACPI_BUS_TYPE_DEVICE;
1520 status = acpi_bus_get_status_handle(handle, sta);
1521 if (ACPI_FAILURE(status))
Aaron Lue3990372015-11-19 11:05:25 +08001522 *sta = 0;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001523 break;
1524 case ACPI_TYPE_PROCESSOR:
1525 *type = ACPI_BUS_TYPE_PROCESSOR;
1526 status = acpi_bus_get_status_handle(handle, sta);
1527 if (ACPI_FAILURE(status))
1528 return -ENODEV;
1529 break;
1530 case ACPI_TYPE_THERMAL:
1531 *type = ACPI_BUS_TYPE_THERMAL;
1532 *sta = ACPI_STA_DEFAULT;
1533 break;
1534 case ACPI_TYPE_POWER:
1535 *type = ACPI_BUS_TYPE_POWER;
1536 *sta = ACPI_STA_DEFAULT;
1537 break;
1538 default:
1539 return -ENODEV;
1540 }
1541
1542 return 0;
1543}
1544
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001545bool acpi_device_is_present(struct acpi_device *adev)
1546{
1547 if (adev->status.present || adev->status.functional)
1548 return true;
1549
1550 adev->flags.initialized = false;
1551 return false;
1552}
1553
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001554static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
Rasmus Villemoes844142c2015-09-09 23:59:42 +02001555 const char *idstr,
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001556 const struct acpi_device_id **matchid)
1557{
1558 const struct acpi_device_id *devid;
1559
Rafael J. Wysockiaca0a4e2014-05-30 04:21:52 +02001560 if (handler->match)
1561 return handler->match(idstr, matchid);
1562
Rafael J. Wysocki4b59cc12013-03-03 23:06:21 +01001563 for (devid = handler->ids; devid->id[0]; devid++)
1564 if (!strcmp((char *)devid->id, idstr)) {
1565 if (matchid)
1566 *matchid = devid;
1567
1568 return true;
1569 }
1570
1571 return false;
1572}
1573
Rasmus Villemoes844142c2015-09-09 23:59:42 +02001574static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr,
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001575 const struct acpi_device_id **matchid)
1576{
1577 struct acpi_scan_handler *handler;
1578
1579 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
1580 if (acpi_scan_handler_matching(handler, idstr, matchid))
1581 return handler;
1582
1583 return NULL;
1584}
1585
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001586void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
1587{
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001588 if (!!hotplug->enabled == !!val)
1589 return;
1590
1591 mutex_lock(&acpi_scan_lock);
1592
1593 hotplug->enabled = val;
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +01001594
1595 mutex_unlock(&acpi_scan_lock);
1596}
1597
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001598static void acpi_scan_init_hotplug(struct acpi_device *adev)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001599{
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001600 struct acpi_hardware_id *hwid;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001601
Rafael J. Wysockib43109f2014-02-16 00:09:34 +01001602 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001603 acpi_dock_add(adev);
1604 return;
1605 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001606 list_for_each_entry(hwid, &adev->pnp.ids, list) {
1607 struct acpi_scan_handler *handler;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001608
Toshi Kani6b772e8f2013-03-04 21:30:43 +00001609 handler = acpi_scan_match_handler(hwid->id, NULL);
Rafael J. Wysocki1a699472014-02-06 13:58:13 +01001610 if (handler) {
1611 adev->flags.hotplug_notify = true;
1612 break;
1613 }
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001614 }
Rafael J. Wysockia33ec392013-03-03 23:05:29 +01001615}
1616
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001617static void acpi_device_dep_initialize(struct acpi_device *adev)
1618{
1619 struct acpi_dep_data *dep;
1620 struct acpi_handle_list dep_devices;
1621 acpi_status status;
1622 int i;
1623
1624 if (!acpi_has_method(adev->handle, "_DEP"))
1625 return;
1626
1627 status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
1628 &dep_devices);
1629 if (ACPI_FAILURE(status)) {
Rafael J. Wysocki80167a22014-12-12 22:48:44 +01001630 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001631 return;
1632 }
1633
1634 for (i = 0; i < dep_devices.count; i++) {
1635 struct acpi_device_info *info;
1636 int skip;
1637
1638 status = acpi_get_object_info(dep_devices.handles[i], &info);
1639 if (ACPI_FAILURE(status)) {
Rafael J. Wysocki80167a22014-12-12 22:48:44 +01001640 dev_dbg(&adev->dev, "Error reading _DEP device info\n");
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001641 continue;
1642 }
1643
1644 /*
1645 * Skip the dependency of Windows System Power
1646 * Management Controller
1647 */
1648 skip = info->valid & ACPI_VALID_HID &&
1649 !strcmp(info->hardware_id.string, "INT3396");
1650
1651 kfree(info);
1652
1653 if (skip)
1654 continue;
1655
1656 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
1657 if (!dep)
1658 return;
1659
1660 dep->master = dep_devices.handles[i];
1661 dep->slave = adev->handle;
1662 adev->dep_unmet++;
1663
1664 mutex_lock(&acpi_dep_list_lock);
1665 list_add_tail(&dep->node , &acpi_dep_list);
1666 mutex_unlock(&acpi_dep_list_lock);
1667 }
1668}
1669
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001670static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1671 void *not_used, void **return_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672{
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001673 struct acpi_device *device = NULL;
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001674 int type;
1675 unsigned long long sta;
1676 int result;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001677
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001678 acpi_bus_get_device(handle, &device);
1679 if (device)
1680 goto out;
1681
Bjorn Helgaas778cbc12009-09-21 19:30:06 +00001682 result = acpi_bus_type_and_status(handle, &type, &sta);
1683 if (result)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001684 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
Rafael J. Wysocki82c7d5e2013-01-17 14:11:05 +01001686 if (type == ACPI_BUS_TYPE_POWER) {
1687 acpi_add_power_resource(handle);
1688 return AE_OK;
1689 }
1690
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001691 acpi_add_single_object(&device, handle, type, sta);
Bjorn Helgaase3b87f82009-09-21 19:30:11 +00001692 if (!device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001693 return AE_CTRL_DEPTH;
1694
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001695 acpi_scan_init_hotplug(device);
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001696 acpi_device_dep_initialize(device);
Rafael J. Wysocki3c2cc7f2014-02-06 17:31:37 +01001697
Rafael J. Wysocki4002bf32012-12-21 00:36:44 +01001698 out:
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001699 if (!*return_value)
1700 *return_value = device;
Rafael J. Wysocki805d410f2012-12-21 00:36:39 +01001701
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001702 return AE_OK;
1703}
1704
Zhang Rui48459342014-05-30 14:35:34 +02001705static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
1706{
1707 bool *is_spi_i2c_slave_p = data;
1708
1709 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
1710 return 1;
1711
1712 /*
1713 * devices that are connected to UART still need to be enumerated to
1714 * platform bus
1715 */
1716 if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
1717 *is_spi_i2c_slave_p = true;
1718
1719 /* no need to do more checking */
1720 return -1;
1721}
1722
1723static void acpi_default_enumeration(struct acpi_device *device)
1724{
1725 struct list_head resource_list;
1726 bool is_spi_i2c_slave = false;
1727
Zhang Rui48459342014-05-30 14:35:34 +02001728 /*
Octavian Purdila68bdb672016-07-08 19:13:09 +03001729 * Do not enumerate SPI/I2C slaves as they will be enumerated by their
Zhang Rui48459342014-05-30 14:35:34 +02001730 * respective parents.
1731 */
1732 INIT_LIST_HEAD(&resource_list);
1733 acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
1734 &is_spi_i2c_slave);
1735 acpi_dev_free_resource_list(&resource_list);
Octavian Purdila10c7e202016-07-08 19:13:08 +03001736 if (!is_spi_i2c_slave) {
Heikki Krogerus15718752016-11-03 16:21:26 +02001737 acpi_create_platform_device(device, NULL);
Octavian Purdila10c7e202016-07-08 19:13:08 +03001738 acpi_device_set_enumerated(device);
Octavian Purdila68bdb672016-07-08 19:13:09 +03001739 } else {
1740 blocking_notifier_call_chain(&acpi_reconfig_chain,
1741 ACPI_RECONFIG_DEVICE_ADD, device);
Octavian Purdila10c7e202016-07-08 19:13:08 +03001742 }
Zhang Rui48459342014-05-30 14:35:34 +02001743}
1744
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001745static const struct acpi_device_id generic_device_ids[] = {
Rafael J. Wysockiee892092015-05-22 04:24:34 +02001746 {ACPI_DT_NAMESPACE_HID, },
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001747 {"", },
1748};
1749
1750static int acpi_generic_device_attach(struct acpi_device *adev,
1751 const struct acpi_device_id *not_used)
1752{
1753 /*
Rafael J. Wysockiee892092015-05-22 04:24:34 +02001754 * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test
1755 * below can be unconditional.
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02001756 */
1757 if (adev->data.of_compatible)
1758 acpi_default_enumeration(adev);
1759
1760 return 1;
1761}
1762
1763static struct acpi_scan_handler generic_device_handler = {
1764 .ids = generic_device_ids,
1765 .attach = acpi_generic_device_attach,
1766};
1767
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001768static int acpi_scan_attach_handler(struct acpi_device *device)
1769{
1770 struct acpi_hardware_id *hwid;
1771 int ret = 0;
1772
1773 list_for_each_entry(hwid, &device->pnp.ids, list) {
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001774 const struct acpi_device_id *devid;
1775 struct acpi_scan_handler *handler;
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001776
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001777 handler = acpi_scan_match_handler(hwid->id, &devid);
1778 if (handler) {
Rafael J. Wysockid34afa92014-05-30 04:27:31 +02001779 if (!handler->attach) {
1780 device->pnp.type.platform_id = 0;
1781 continue;
1782 }
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001783 device->handler = handler;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001784 ret = handler->attach(device, devid);
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001785 if (ret > 0)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001786 break;
Rafael J. Wysocki9cb32ac2014-02-11 00:35:46 +01001787
1788 device->handler = NULL;
1789 if (ret < 0)
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001790 break;
Rafael J. Wysockic5698072013-03-03 23:05:14 +01001791 }
Rafael J. Wysocki87b85b32013-02-06 13:05:22 +01001792 }
Zhang Rui48459342014-05-30 14:35:34 +02001793
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001794 return ret;
1795}
1796
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001797static void acpi_bus_attach(struct acpi_device *device)
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001798{
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001799 struct acpi_device *child;
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001800 acpi_handle ejd;
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001801 int ret;
Bjorn Helgaas51a85fa2009-09-21 19:29:56 +00001802
Rafael J. Wysocki1e2380c2014-02-16 01:51:01 +01001803 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
1804 register_dock_dependent_device(device, ejd);
1805
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001806 acpi_bus_get_status(device);
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001807 /* Skip devices that are not present. */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001808 if (!acpi_device_is_present(device)) {
Octavian Purdila10c7e202016-07-08 19:13:08 +03001809 acpi_device_clear_enumerated(device);
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +01001810 device->flags.power_manageable = 0;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001811 return;
1812 }
Rafael J. Wysocki3a391a32013-07-12 13:45:59 +02001813 if (device->handler)
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001814 goto ok;
Rafael J. Wysocki3a391a32013-07-12 13:45:59 +02001815
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001816 if (!device->flags.initialized) {
Rafael J. Wysocki1b1f3e12015-01-01 23:38:28 +01001817 device->flags.power_manageable =
1818 device->power.states[ACPI_STATE_D0].flags.valid;
1819 if (acpi_bus_init_power(device))
1820 device->flags.power_manageable = 0;
1821
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001822 device->flags.initialized = true;
1823 }
Octavian Purdila10c7e202016-07-08 19:13:08 +03001824
Rafael J. Wysockica589f92013-01-30 14:27:29 +01001825 ret = acpi_scan_attach_handler(device);
Rafael J. Wysocki69310072013-11-07 01:41:01 +01001826 if (ret < 0)
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001827 return;
Rafael J. Wysocki69310072013-11-07 01:41:01 +01001828
1829 device->flags.match_driver = true;
Rafael J. Wysocki6ef2f012017-04-11 00:23:42 +02001830 if (ret > 0) {
1831 acpi_device_set_enumerated(device);
1832 goto ok;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001833 }
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001834
Rafael J. Wysocki6ef2f012017-04-11 00:23:42 +02001835 ret = device_attach(&device->dev);
1836 if (ret < 0)
1837 return;
1838
1839 if (ret > 0 || !device->pnp.type.platform_id)
1840 acpi_device_set_enumerated(device);
1841 else
1842 acpi_default_enumeration(device);
1843
Rafael J. Wysocki202317a2013-11-22 21:54:37 +01001844 ok:
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001845 list_for_each_entry(child, &device->children, node)
1846 acpi_bus_attach(child);
Rafael J. Wysocki8ab17fc2014-09-21 02:58:18 +02001847
1848 if (device->handler && device->handler->hotplug.notify_online)
1849 device->handler->hotplug.notify_online(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001852void acpi_walk_dep_device_list(acpi_handle handle)
1853{
1854 struct acpi_dep_data *dep, *tmp;
1855 struct acpi_device *adev;
1856
1857 mutex_lock(&acpi_dep_list_lock);
1858 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
1859 if (dep->master == handle) {
1860 acpi_bus_get_device(dep->slave, &adev);
1861 if (!adev)
1862 continue;
1863
1864 adev->dep_unmet--;
1865 if (!adev->dep_unmet)
1866 acpi_bus_attach(adev);
1867 list_del(&dep->node);
1868 kfree(dep);
1869 }
1870 }
1871 mutex_unlock(&acpi_dep_list_lock);
1872}
1873EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
1874
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001875/**
1876 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1877 * @handle: Root of the namespace scope to scan.
Thomas Renninger77796882010-01-29 17:48:52 +01001878 *
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001879 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1880 * found devices.
Thomas Renninger77796882010-01-29 17:48:52 +01001881 *
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001882 * If no devices were found, -ENODEV is returned, but it does not mean that
1883 * there has been a real error. There just have been no suitable ACPI objects
1884 * in the table trunk from which the kernel could create a device and add an
1885 * appropriate driver.
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001886 *
1887 * Must be called under acpi_scan_lock.
Thomas Renninger77796882010-01-29 17:48:52 +01001888 */
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001889int acpi_bus_scan(acpi_handle handle)
Rajesh Shah3fb02732005-04-28 00:25:52 -07001890{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 void *device = NULL;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001892
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01001893 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
Rafael J. Wysockie3863092012-12-21 00:36:47 +01001895 acpi_bus_check_add, NULL, NULL, &device);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001896
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001897 if (device) {
1898 acpi_bus_attach(device);
1899 return 0;
1900 }
1901 return -ENODEV;
Rajesh Shah3fb02732005-04-28 00:25:52 -07001902}
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01001903EXPORT_SYMBOL(acpi_bus_scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001905/**
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001906 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
1907 * @adev: Root of the ACPI namespace scope to walk.
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01001908 *
1909 * Must be called under acpi_scan_lock.
1910 */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001911void acpi_bus_trim(struct acpi_device *adev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912{
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001913 struct acpi_scan_handler *handler = adev->handler;
1914 struct acpi_device *child;
1915
1916 list_for_each_entry_reverse(child, &adev->children, node)
1917 acpi_bus_trim(child);
1918
Rafael J. Wysockia951c772014-01-27 23:08:09 +01001919 adev->flags.match_driver = false;
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001920 if (handler) {
1921 if (handler->detach)
1922 handler->detach(adev);
1923
1924 adev->handler = NULL;
1925 } else {
1926 device_release_driver(&adev->dev);
1927 }
Rafael J. Wysockicecdb192013-01-15 13:24:02 +01001928 /*
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001929 * Most likely, the device is going away, so put it into D3cold before
1930 * that.
Rafael J. Wysocki05404d82013-01-15 13:24:13 +01001931 */
Rafael J. Wysocki2c22e652013-11-25 00:52:21 +01001932 acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
1933 adev->flags.initialized = false;
Octavian Purdila10c7e202016-07-08 19:13:08 +03001934 acpi_device_clear_enumerated(adev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935}
Kristen Accardiceaba662006-02-23 17:56:01 -08001936EXPORT_SYMBOL_GPL(acpi_bus_trim);
1937
Bjorn Helgaase8b945c2009-09-21 19:28:59 +00001938static int acpi_bus_scan_fixed(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939{
Len Brown4be44fc2005-08-05 00:44:28 -04001940 int result = 0;
Li Shaohuac4168bf2006-12-07 20:56:41 +08001941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 /*
1943 * Enumerate all fixed-feature devices.
1944 */
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001945 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
1946 struct acpi_device *device = NULL;
1947
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001948 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001949 ACPI_BUS_TYPE_POWER_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001950 ACPI_STA_DEFAULT);
1951 if (result)
1952 return result;
1953
Rafael J. Wysocki88346162013-11-18 14:18:47 +01001954 device->flags.match_driver = true;
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001955 result = device_attach(&device->dev);
1956 if (result < 0)
1957 return result;
1958
Daniel Drakec10d7a12012-05-10 00:08:43 +01001959 device_init_wakeup(&device->dev, true);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001960 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001962 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
1963 struct acpi_device *device = NULL;
1964
Bjorn Helgaas5c478f42009-09-21 19:29:35 +00001965 result = acpi_add_single_object(&device, NULL,
Li Shaohuac4168bf2006-12-07 20:56:41 +08001966 ACPI_BUS_TYPE_SLEEP_BUTTON,
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001967 ACPI_STA_DEFAULT);
1968 if (result)
1969 return result;
1970
Rafael J. Wysocki88346162013-11-18 14:18:47 +01001971 device->flags.match_driver = true;
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001972 result = device_attach(&device->dev);
Rajesh Shah3fb02732005-04-28 00:25:52 -07001973 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974
Rafael J. Wysocki2c0d4fe2013-01-29 13:57:20 +01001975 return result < 0 ? result : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976}
1977
Shannon Zhaoa4e081b2016-04-07 20:03:18 +08001978static void __init acpi_get_spcr_uart_addr(void)
1979{
1980 acpi_status status;
1981 struct acpi_table_spcr *spcr_ptr;
1982
1983 status = acpi_get_table(ACPI_SIG_SPCR, 0,
1984 (struct acpi_table_header **)&spcr_ptr);
1985 if (ACPI_SUCCESS(status))
1986 spcr_uart_addr = spcr_ptr->serial_port.address;
1987 else
1988 printk(KERN_WARNING PREFIX "STAO table present, but SPCR is missing\n");
1989}
1990
Octavian Purdila68bdb672016-07-08 19:13:09 +03001991static bool acpi_scan_initialized;
1992
Bjorn Helgaase747f272009-03-24 16:49:43 -06001993int __init acpi_scan_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994{
1995 int result;
Shannon Zhaoa4e081b2016-04-07 20:03:18 +08001996 acpi_status status;
1997 struct acpi_table_stao *stao_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998
Rafael J. Wysocki92ef2a22012-12-21 00:36:40 +01001999 acpi_pci_root_init();
Rafael J. Wysocki4daeaf62013-01-30 14:27:37 +01002000 acpi_pci_link_init();
Rafael J. Wysockiac212b62013-05-03 00:26:22 +02002001 acpi_processor_init();
Rafael J. Wysockif58b0822013-03-06 23:46:20 +01002002 acpi_lpss_init();
Ken Xue92082a82015-02-06 08:27:51 +08002003 acpi_apd_init();
Lan Tianyu2fa97fe2013-06-05 02:27:50 +00002004 acpi_cmos_rtc_init();
Rafael J. Wysocki737f1a92013-02-08 23:52:39 +01002005 acpi_container_init();
Rafael J. Wysocki0a347642013-03-03 23:18:03 +01002006 acpi_memory_hotplug_init();
Zhang Ruieec15ed2014-05-30 04:23:01 +02002007 acpi_pnp_init();
Zhang Rui3230bbf2014-03-14 00:34:05 +08002008 acpi_int340x_thermal_init();
Graeme Gregory6ce2e182016-01-20 20:29:27 +06002009 acpi_amba_init();
Mika Westerberg058dfc72016-09-20 15:30:51 +03002010 acpi_watchdog_init();
Rafael J. Wysocki97d9a9e2010-11-25 00:10:02 +01002011
Rafael J. Wysocki7d284352015-04-24 02:18:01 +02002012 acpi_scan_add_handler(&generic_device_handler);
2013
Shannon Zhaoa4e081b2016-04-07 20:03:18 +08002014 /*
2015 * If there is STAO table, check whether it needs to ignore the UART
2016 * device in SPCR table.
2017 */
2018 status = acpi_get_table(ACPI_SIG_STAO, 0,
2019 (struct acpi_table_header **)&stao_ptr);
2020 if (ACPI_SUCCESS(status)) {
2021 if (stao_ptr->header.length > sizeof(struct acpi_table_stao))
2022 printk(KERN_INFO PREFIX "STAO Name List not yet supported.");
2023
2024 if (stao_ptr->ignore_uart)
2025 acpi_get_spcr_uart_addr();
2026 }
2027
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01002028 mutex_lock(&acpi_scan_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 * Enumerate devices in the ACPI namespace.
2031 */
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01002032 result = acpi_bus_scan(ACPI_ROOT_OBJECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 if (result)
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01002034 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
Rafael J. Wysocki0cd6ac52012-12-21 00:36:49 +01002036 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 if (result)
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01002038 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
Aaron Lu2650ef42014-04-28 10:38:04 +08002040 /* Fixed feature devices do not exist on HW-reduced platform */
2041 if (!acpi_gbl_reduced_hardware) {
2042 result = acpi_bus_scan_fixed();
2043 if (result) {
2044 acpi_detach_data(acpi_root->handle,
2045 acpi_scan_drop_device);
2046 acpi_device_del(acpi_root);
2047 put_device(&acpi_root->dev);
2048 goto out;
2049 }
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01002050 }
2051
Lv Zhengc1e94142017-04-04 19:32:17 +00002052 acpi_gpe_apply_masked_gpes();
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +01002053 acpi_update_all_gpes();
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01002054
Octavian Purdila68bdb672016-07-08 19:13:09 +03002055 acpi_scan_initialized = true;
2056
Rafael J. Wysocki3757b942013-02-13 14:36:47 +01002057 out:
2058 mutex_unlock(&acpi_scan_lock);
2059 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060}
Marc Zyngiere647b532015-09-28 15:49:12 +01002061
2062static struct acpi_probe_entry *ape;
2063static int acpi_probe_count;
Lorenzo Pieralisi5331d9c2016-08-16 16:59:53 +01002064static DEFINE_MUTEX(acpi_probe_mutex);
Marc Zyngiere647b532015-09-28 15:49:12 +01002065
2066static int __init acpi_match_madt(struct acpi_subtable_header *header,
2067 const unsigned long end)
2068{
2069 if (!ape->subtable_valid || ape->subtable_valid(header, ape))
2070 if (!ape->probe_subtbl(header, end))
2071 acpi_probe_count++;
2072
2073 return 0;
2074}
2075
2076int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
2077{
2078 int count = 0;
2079
2080 if (acpi_disabled)
2081 return 0;
2082
Lorenzo Pieralisi5331d9c2016-08-16 16:59:53 +01002083 mutex_lock(&acpi_probe_mutex);
Marc Zyngiere647b532015-09-28 15:49:12 +01002084 for (ape = ap_head; nr; ape++, nr--) {
2085 if (ACPI_COMPARE_NAME(ACPI_SIG_MADT, ape->id)) {
2086 acpi_probe_count = 0;
2087 acpi_table_parse_madt(ape->type, acpi_match_madt, 0);
2088 count += acpi_probe_count;
2089 } else {
2090 int res;
2091 res = acpi_table_parse(ape->id, ape->probe_table);
2092 if (!res)
2093 count++;
2094 }
2095 }
Lorenzo Pieralisi5331d9c2016-08-16 16:59:53 +01002096 mutex_unlock(&acpi_probe_mutex);
Marc Zyngiere647b532015-09-28 15:49:12 +01002097
2098 return count;
2099}
Octavian Purdila68bdb672016-07-08 19:13:09 +03002100
2101struct acpi_table_events_work {
2102 struct work_struct work;
2103 void *table;
2104 u32 event;
2105};
2106
2107static void acpi_table_events_fn(struct work_struct *work)
2108{
2109 struct acpi_table_events_work *tew;
2110
2111 tew = container_of(work, struct acpi_table_events_work, work);
2112
2113 if (tew->event == ACPI_TABLE_EVENT_LOAD) {
2114 acpi_scan_lock_acquire();
2115 acpi_bus_scan(ACPI_ROOT_OBJECT);
2116 acpi_scan_lock_release();
2117 }
2118
2119 kfree(tew);
2120}
2121
2122void acpi_scan_table_handler(u32 event, void *table, void *context)
2123{
2124 struct acpi_table_events_work *tew;
2125
2126 if (!acpi_scan_initialized)
2127 return;
2128
2129 if (event != ACPI_TABLE_EVENT_LOAD)
2130 return;
2131
2132 tew = kmalloc(sizeof(*tew), GFP_KERNEL);
2133 if (!tew)
2134 return;
2135
2136 INIT_WORK(&tew->work, acpi_table_events_fn);
2137 tew->table = table;
2138 tew->event = event;
2139
2140 schedule_work(&tew->work);
2141}
2142
2143int acpi_reconfig_notifier_register(struct notifier_block *nb)
2144{
2145 return blocking_notifier_chain_register(&acpi_reconfig_chain, nb);
2146}
2147EXPORT_SYMBOL(acpi_reconfig_notifier_register);
2148
2149int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
2150{
2151 return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb);
2152}
2153EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);