xref: /openbmc/linux/drivers/acpi/bus.c (revision 0edbfea5)
1 /*
2  *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
3  *
4  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5  *
6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or (at
11  *  your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful, but
14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  General Public License for more details.
17  *
18  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19  */
20 
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/ioport.h>
24 #include <linux/kernel.h>
25 #include <linux/list.h>
26 #include <linux/sched.h>
27 #include <linux/pm.h>
28 #include <linux/device.h>
29 #include <linux/proc_fs.h>
30 #include <linux/acpi.h>
31 #include <linux/slab.h>
32 #include <linux/regulator/machine.h>
33 #ifdef CONFIG_X86
34 #include <asm/mpspec.h>
35 #endif
36 #include <linux/pci.h>
37 #include <acpi/apei.h>
38 #include <linux/dmi.h>
39 #include <linux/suspend.h>
40 
41 #include "internal.h"
42 
43 #define _COMPONENT		ACPI_BUS_COMPONENT
44 ACPI_MODULE_NAME("bus");
45 
46 struct acpi_device *acpi_root;
47 struct proc_dir_entry *acpi_root_dir;
48 EXPORT_SYMBOL(acpi_root_dir);
49 
50 #ifdef CONFIG_X86
51 #ifdef CONFIG_ACPI_CUSTOM_DSDT
52 static inline int set_copy_dsdt(const struct dmi_system_id *id)
53 {
54 	return 0;
55 }
56 #else
57 static int set_copy_dsdt(const struct dmi_system_id *id)
58 {
59 	printk(KERN_NOTICE "%s detected - "
60 		"force copy of DSDT to local memory\n", id->ident);
61 	acpi_gbl_copy_dsdt_locally = 1;
62 	return 0;
63 }
64 #endif
65 
66 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
67 	/*
68 	 * Invoke DSDT corruption work-around on all Toshiba Satellite.
69 	 * https://bugzilla.kernel.org/show_bug.cgi?id=14679
70 	 */
71 	{
72 	 .callback = set_copy_dsdt,
73 	 .ident = "TOSHIBA Satellite",
74 	 .matches = {
75 		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
76 		DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
77 		},
78 	},
79 	{}
80 };
81 #else
82 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
83 	{}
84 };
85 #endif
86 
87 /* --------------------------------------------------------------------------
88                                 Device Management
89    -------------------------------------------------------------------------- */
90 
91 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
92 				       unsigned long long *sta)
93 {
94 	acpi_status status;
95 
96 	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
97 	if (ACPI_SUCCESS(status))
98 		return AE_OK;
99 
100 	if (status == AE_NOT_FOUND) {
101 		*sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
102 		       ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
103 		return AE_OK;
104 	}
105 	return status;
106 }
107 
108 int acpi_bus_get_status(struct acpi_device *device)
109 {
110 	acpi_status status;
111 	unsigned long long sta;
112 
113 	status = acpi_bus_get_status_handle(device->handle, &sta);
114 	if (ACPI_FAILURE(status))
115 		return -ENODEV;
116 
117 	acpi_set_device_status(device, sta);
118 
119 	if (device->status.functional && !device->status.present) {
120 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
121 		       "functional but not present;\n",
122 			device->pnp.bus_id, (u32)sta));
123 	}
124 
125 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
126 			  device->pnp.bus_id, (u32)sta));
127 	return 0;
128 }
129 EXPORT_SYMBOL(acpi_bus_get_status);
130 
131 void acpi_bus_private_data_handler(acpi_handle handle,
132 				   void *context)
133 {
134 	return;
135 }
136 EXPORT_SYMBOL(acpi_bus_private_data_handler);
137 
138 int acpi_bus_attach_private_data(acpi_handle handle, void *data)
139 {
140 	acpi_status status;
141 
142 	status = acpi_attach_data(handle,
143 			acpi_bus_private_data_handler, data);
144 	if (ACPI_FAILURE(status)) {
145 		acpi_handle_debug(handle, "Error attaching device data\n");
146 		return -ENODEV;
147 	}
148 
149 	return 0;
150 }
151 EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
152 
153 int acpi_bus_get_private_data(acpi_handle handle, void **data)
154 {
155 	acpi_status status;
156 
157 	if (!*data)
158 		return -EINVAL;
159 
160 	status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
161 	if (ACPI_FAILURE(status)) {
162 		acpi_handle_debug(handle, "No context for object\n");
163 		return -ENODEV;
164 	}
165 
166 	return 0;
167 }
168 EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
169 
170 void acpi_bus_detach_private_data(acpi_handle handle)
171 {
172 	acpi_detach_data(handle, acpi_bus_private_data_handler);
173 }
174 EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
175 
176 static void acpi_print_osc_error(acpi_handle handle,
177 	struct acpi_osc_context *context, char *error)
178 {
179 	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
180 	int i;
181 
182 	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
183 		printk(KERN_DEBUG "%s: %s\n", context->uuid_str, error);
184 	else {
185 		printk(KERN_DEBUG "%s (%s): %s\n",
186 		       (char *)buffer.pointer, context->uuid_str, error);
187 		kfree(buffer.pointer);
188 	}
189 	printk(KERN_DEBUG "_OSC request data:");
190 	for (i = 0; i < context->cap.length; i += sizeof(u32))
191 		printk(" %x", *((u32 *)(context->cap.pointer + i)));
192 	printk("\n");
193 }
194 
195 acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
196 {
197 	int i;
198 	static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
199 		24, 26, 28, 30, 32, 34};
200 
201 	if (strlen(str) != 36)
202 		return AE_BAD_PARAMETER;
203 	for (i = 0; i < 36; i++) {
204 		if (i == 8 || i == 13 || i == 18 || i == 23) {
205 			if (str[i] != '-')
206 				return AE_BAD_PARAMETER;
207 		} else if (!isxdigit(str[i]))
208 			return AE_BAD_PARAMETER;
209 	}
210 	for (i = 0; i < 16; i++) {
211 		uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4;
212 		uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]);
213 	}
214 	return AE_OK;
215 }
216 EXPORT_SYMBOL_GPL(acpi_str_to_uuid);
217 
218 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
219 {
220 	acpi_status status;
221 	struct acpi_object_list input;
222 	union acpi_object in_params[4];
223 	union acpi_object *out_obj;
224 	u8 uuid[16];
225 	u32 errors;
226 	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
227 
228 	if (!context)
229 		return AE_ERROR;
230 	if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid)))
231 		return AE_ERROR;
232 	context->ret.length = ACPI_ALLOCATE_BUFFER;
233 	context->ret.pointer = NULL;
234 
235 	/* Setting up input parameters */
236 	input.count = 4;
237 	input.pointer = in_params;
238 	in_params[0].type 		= ACPI_TYPE_BUFFER;
239 	in_params[0].buffer.length 	= 16;
240 	in_params[0].buffer.pointer	= uuid;
241 	in_params[1].type 		= ACPI_TYPE_INTEGER;
242 	in_params[1].integer.value 	= context->rev;
243 	in_params[2].type 		= ACPI_TYPE_INTEGER;
244 	in_params[2].integer.value	= context->cap.length/sizeof(u32);
245 	in_params[3].type		= ACPI_TYPE_BUFFER;
246 	in_params[3].buffer.length 	= context->cap.length;
247 	in_params[3].buffer.pointer 	= context->cap.pointer;
248 
249 	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
250 	if (ACPI_FAILURE(status))
251 		return status;
252 
253 	if (!output.length)
254 		return AE_NULL_OBJECT;
255 
256 	out_obj = output.pointer;
257 	if (out_obj->type != ACPI_TYPE_BUFFER
258 		|| out_obj->buffer.length != context->cap.length) {
259 		acpi_print_osc_error(handle, context,
260 			"_OSC evaluation returned wrong type");
261 		status = AE_TYPE;
262 		goto out_kfree;
263 	}
264 	/* Need to ignore the bit0 in result code */
265 	errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
266 	if (errors) {
267 		if (errors & OSC_REQUEST_ERROR)
268 			acpi_print_osc_error(handle, context,
269 				"_OSC request failed");
270 		if (errors & OSC_INVALID_UUID_ERROR)
271 			acpi_print_osc_error(handle, context,
272 				"_OSC invalid UUID");
273 		if (errors & OSC_INVALID_REVISION_ERROR)
274 			acpi_print_osc_error(handle, context,
275 				"_OSC invalid revision");
276 		if (errors & OSC_CAPABILITIES_MASK_ERROR) {
277 			if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
278 			    & OSC_QUERY_ENABLE)
279 				goto out_success;
280 			status = AE_SUPPORT;
281 			goto out_kfree;
282 		}
283 		status = AE_ERROR;
284 		goto out_kfree;
285 	}
286 out_success:
287 	context->ret.length = out_obj->buffer.length;
288 	context->ret.pointer = kmemdup(out_obj->buffer.pointer,
289 				       context->ret.length, GFP_KERNEL);
290 	if (!context->ret.pointer) {
291 		status =  AE_NO_MEMORY;
292 		goto out_kfree;
293 	}
294 	status =  AE_OK;
295 
296 out_kfree:
297 	kfree(output.pointer);
298 	if (status != AE_OK)
299 		context->ret.pointer = NULL;
300 	return status;
301 }
302 EXPORT_SYMBOL(acpi_run_osc);
303 
304 bool osc_sb_apei_support_acked;
305 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
306 static void acpi_bus_osc_support(void)
307 {
308 	u32 capbuf[2];
309 	struct acpi_osc_context context = {
310 		.uuid_str = sb_uuid_str,
311 		.rev = 1,
312 		.cap.length = 8,
313 		.cap.pointer = capbuf,
314 	};
315 	acpi_handle handle;
316 
317 	capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
318 	capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
319 	if (IS_ENABLED(CONFIG_ACPI_PROCESSOR_AGGREGATOR))
320 		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
321 	if (IS_ENABLED(CONFIG_ACPI_PROCESSOR))
322 		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
323 
324 	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
325 
326 	if (!ghes_disable)
327 		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
328 	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
329 		return;
330 	if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
331 		u32 *capbuf_ret = context.ret.pointer;
332 		if (context.ret.length > OSC_SUPPORT_DWORD)
333 			osc_sb_apei_support_acked =
334 				capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
335 		kfree(context.ret.pointer);
336 	}
337 	/* do we need to check other returned cap? Sounds no */
338 }
339 
340 /* --------------------------------------------------------------------------
341                              Notification Handling
342    -------------------------------------------------------------------------- */
343 
344 /**
345  * acpi_bus_notify
346  * ---------------
347  * Callback for all 'system-level' device notifications (values 0x00-0x7F).
348  */
349 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
350 {
351 	struct acpi_device *adev;
352 	struct acpi_driver *driver;
353 	u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
354 	bool hotplug_event = false;
355 
356 	switch (type) {
357 	case ACPI_NOTIFY_BUS_CHECK:
358 		acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
359 		hotplug_event = true;
360 		break;
361 
362 	case ACPI_NOTIFY_DEVICE_CHECK:
363 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
364 		hotplug_event = true;
365 		break;
366 
367 	case ACPI_NOTIFY_DEVICE_WAKE:
368 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
369 		break;
370 
371 	case ACPI_NOTIFY_EJECT_REQUEST:
372 		acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
373 		hotplug_event = true;
374 		break;
375 
376 	case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
377 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
378 		/* TBD: Exactly what does 'light' mean? */
379 		break;
380 
381 	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
382 		acpi_handle_err(handle, "Device cannot be configured due "
383 				"to a frequency mismatch\n");
384 		break;
385 
386 	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
387 		acpi_handle_err(handle, "Device cannot be configured due "
388 				"to a bus mode mismatch\n");
389 		break;
390 
391 	case ACPI_NOTIFY_POWER_FAULT:
392 		acpi_handle_err(handle, "Device has suffered a power fault\n");
393 		break;
394 
395 	default:
396 		acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
397 		break;
398 	}
399 
400 	adev = acpi_bus_get_acpi_device(handle);
401 	if (!adev)
402 		goto err;
403 
404 	driver = adev->driver;
405 	if (driver && driver->ops.notify &&
406 	    (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
407 		driver->ops.notify(adev, type);
408 
409 	if (hotplug_event && ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
410 		return;
411 
412 	acpi_bus_put_acpi_device(adev);
413 	return;
414 
415  err:
416 	acpi_evaluate_ost(handle, type, ost_code, NULL);
417 }
418 
419 static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
420 {
421 	struct acpi_device *device = data;
422 
423 	device->driver->ops.notify(device, event);
424 }
425 
426 static void acpi_device_notify_fixed(void *data)
427 {
428 	struct acpi_device *device = data;
429 
430 	/* Fixed hardware devices have no handles */
431 	acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
432 }
433 
434 static u32 acpi_device_fixed_event(void *data)
435 {
436 	acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
437 	return ACPI_INTERRUPT_HANDLED;
438 }
439 
440 static int acpi_device_install_notify_handler(struct acpi_device *device)
441 {
442 	acpi_status status;
443 
444 	if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
445 		status =
446 		    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
447 						     acpi_device_fixed_event,
448 						     device);
449 	else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
450 		status =
451 		    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
452 						     acpi_device_fixed_event,
453 						     device);
454 	else
455 		status = acpi_install_notify_handler(device->handle,
456 						     ACPI_DEVICE_NOTIFY,
457 						     acpi_device_notify,
458 						     device);
459 
460 	if (ACPI_FAILURE(status))
461 		return -EINVAL;
462 	return 0;
463 }
464 
465 static void acpi_device_remove_notify_handler(struct acpi_device *device)
466 {
467 	if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
468 		acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
469 						acpi_device_fixed_event);
470 	else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
471 		acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
472 						acpi_device_fixed_event);
473 	else
474 		acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
475 					   acpi_device_notify);
476 }
477 
478 /* --------------------------------------------------------------------------
479                              Device Matching
480    -------------------------------------------------------------------------- */
481 
482 /**
483  * acpi_get_first_physical_node - Get first physical node of an ACPI device
484  * @adev:	ACPI device in question
485  *
486  * Return: First physical node of ACPI device @adev
487  */
488 struct device *acpi_get_first_physical_node(struct acpi_device *adev)
489 {
490 	struct mutex *physical_node_lock = &adev->physical_node_lock;
491 	struct device *phys_dev;
492 
493 	mutex_lock(physical_node_lock);
494 	if (list_empty(&adev->physical_node_list)) {
495 		phys_dev = NULL;
496 	} else {
497 		const struct acpi_device_physical_node *node;
498 
499 		node = list_first_entry(&adev->physical_node_list,
500 					struct acpi_device_physical_node, node);
501 
502 		phys_dev = node->dev;
503 	}
504 	mutex_unlock(physical_node_lock);
505 	return phys_dev;
506 }
507 
508 static struct acpi_device *acpi_primary_dev_companion(struct acpi_device *adev,
509 						      const struct device *dev)
510 {
511 	const struct device *phys_dev = acpi_get_first_physical_node(adev);
512 
513 	return phys_dev && phys_dev == dev ? adev : NULL;
514 }
515 
516 /**
517  * acpi_device_is_first_physical_node - Is given dev first physical node
518  * @adev: ACPI companion device
519  * @dev: Physical device to check
520  *
521  * Function checks if given @dev is the first physical devices attached to
522  * the ACPI companion device. This distinction is needed in some cases
523  * where the same companion device is shared between many physical devices.
524  *
525  * Note that the caller have to provide valid @adev pointer.
526  */
527 bool acpi_device_is_first_physical_node(struct acpi_device *adev,
528 					const struct device *dev)
529 {
530 	return !!acpi_primary_dev_companion(adev, dev);
531 }
532 
533 /*
534  * acpi_companion_match() - Can we match via ACPI companion device
535  * @dev: Device in question
536  *
537  * Check if the given device has an ACPI companion and if that companion has
538  * a valid list of PNP IDs, and if the device is the first (primary) physical
539  * device associated with it.  Return the companion pointer if that's the case
540  * or NULL otherwise.
541  *
542  * If multiple physical devices are attached to a single ACPI companion, we need
543  * to be careful.  The usage scenario for this kind of relationship is that all
544  * of the physical devices in question use resources provided by the ACPI
545  * companion.  A typical case is an MFD device where all the sub-devices share
546  * the parent's ACPI companion.  In such cases we can only allow the primary
547  * (first) physical device to be matched with the help of the companion's PNP
548  * IDs.
549  *
550  * Additional physical devices sharing the ACPI companion can still use
551  * resources available from it but they will be matched normally using functions
552  * provided by their bus types (and analogously for their modalias).
553  */
554 struct acpi_device *acpi_companion_match(const struct device *dev)
555 {
556 	struct acpi_device *adev;
557 
558 	adev = ACPI_COMPANION(dev);
559 	if (!adev)
560 		return NULL;
561 
562 	if (list_empty(&adev->pnp.ids))
563 		return NULL;
564 
565 	return acpi_primary_dev_companion(adev, dev);
566 }
567 
568 /**
569  * acpi_of_match_device - Match device object using the "compatible" property.
570  * @adev: ACPI device object to match.
571  * @of_match_table: List of device IDs to match against.
572  *
573  * If @dev has an ACPI companion which has ACPI_DT_NAMESPACE_HID in its list of
574  * identifiers and a _DSD object with the "compatible" property, use that
575  * property to match against the given list of identifiers.
576  */
577 static bool acpi_of_match_device(struct acpi_device *adev,
578 				 const struct of_device_id *of_match_table)
579 {
580 	const union acpi_object *of_compatible, *obj;
581 	int i, nval;
582 
583 	if (!adev)
584 		return false;
585 
586 	of_compatible = adev->data.of_compatible;
587 	if (!of_match_table || !of_compatible)
588 		return false;
589 
590 	if (of_compatible->type == ACPI_TYPE_PACKAGE) {
591 		nval = of_compatible->package.count;
592 		obj = of_compatible->package.elements;
593 	} else { /* Must be ACPI_TYPE_STRING. */
594 		nval = 1;
595 		obj = of_compatible;
596 	}
597 	/* Now we can look for the driver DT compatible strings */
598 	for (i = 0; i < nval; i++, obj++) {
599 		const struct of_device_id *id;
600 
601 		for (id = of_match_table; id->compatible[0]; id++)
602 			if (!strcasecmp(obj->string.pointer, id->compatible))
603 				return true;
604 	}
605 
606 	return false;
607 }
608 
609 static bool __acpi_match_device_cls(const struct acpi_device_id *id,
610 				    struct acpi_hardware_id *hwid)
611 {
612 	int i, msk, byte_shift;
613 	char buf[3];
614 
615 	if (!id->cls)
616 		return false;
617 
618 	/* Apply class-code bitmask, before checking each class-code byte */
619 	for (i = 1; i <= 3; i++) {
620 		byte_shift = 8 * (3 - i);
621 		msk = (id->cls_msk >> byte_shift) & 0xFF;
622 		if (!msk)
623 			continue;
624 
625 		sprintf(buf, "%02x", (id->cls >> byte_shift) & msk);
626 		if (strncmp(buf, &hwid->id[(i - 1) * 2], 2))
627 			return false;
628 	}
629 	return true;
630 }
631 
632 static const struct acpi_device_id *__acpi_match_device(
633 	struct acpi_device *device,
634 	const struct acpi_device_id *ids,
635 	const struct of_device_id *of_ids)
636 {
637 	const struct acpi_device_id *id;
638 	struct acpi_hardware_id *hwid;
639 
640 	/*
641 	 * If the device is not present, it is unnecessary to load device
642 	 * driver for it.
643 	 */
644 	if (!device || !device->status.present)
645 		return NULL;
646 
647 	list_for_each_entry(hwid, &device->pnp.ids, list) {
648 		/* First, check the ACPI/PNP IDs provided by the caller. */
649 		for (id = ids; id->id[0] || id->cls; id++) {
650 			if (id->id[0] && !strcmp((char *) id->id, hwid->id))
651 				return id;
652 			else if (id->cls && __acpi_match_device_cls(id, hwid))
653 				return id;
654 		}
655 
656 		/*
657 		 * Next, check ACPI_DT_NAMESPACE_HID and try to match the
658 		 * "compatible" property if found.
659 		 *
660 		 * The id returned by the below is not valid, but the only
661 		 * caller passing non-NULL of_ids here is only interested in
662 		 * whether or not the return value is NULL.
663 		 */
664 		if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id)
665 		    && acpi_of_match_device(device, of_ids))
666 			return id;
667 	}
668 	return NULL;
669 }
670 
671 /**
672  * acpi_match_device - Match a struct device against a given list of ACPI IDs
673  * @ids: Array of struct acpi_device_id object to match against.
674  * @dev: The device structure to match.
675  *
676  * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
677  * object for that handle and use that object to match against a given list of
678  * device IDs.
679  *
680  * Return a pointer to the first matching ID on success or %NULL on failure.
681  */
682 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
683 					       const struct device *dev)
684 {
685 	return __acpi_match_device(acpi_companion_match(dev), ids, NULL);
686 }
687 EXPORT_SYMBOL_GPL(acpi_match_device);
688 
689 int acpi_match_device_ids(struct acpi_device *device,
690 			  const struct acpi_device_id *ids)
691 {
692 	return __acpi_match_device(device, ids, NULL) ? 0 : -ENOENT;
693 }
694 EXPORT_SYMBOL(acpi_match_device_ids);
695 
696 bool acpi_driver_match_device(struct device *dev,
697 			      const struct device_driver *drv)
698 {
699 	if (!drv->acpi_match_table)
700 		return acpi_of_match_device(ACPI_COMPANION(dev),
701 					    drv->of_match_table);
702 
703 	return !!__acpi_match_device(acpi_companion_match(dev),
704 				     drv->acpi_match_table, drv->of_match_table);
705 }
706 EXPORT_SYMBOL_GPL(acpi_driver_match_device);
707 
708 /* --------------------------------------------------------------------------
709                               ACPI Driver Management
710    -------------------------------------------------------------------------- */
711 
712 /**
713  * acpi_bus_register_driver - register a driver with the ACPI bus
714  * @driver: driver being registered
715  *
716  * Registers a driver with the ACPI bus.  Searches the namespace for all
717  * devices that match the driver's criteria and binds.  Returns zero for
718  * success or a negative error status for failure.
719  */
720 int acpi_bus_register_driver(struct acpi_driver *driver)
721 {
722 	int ret;
723 
724 	if (acpi_disabled)
725 		return -ENODEV;
726 	driver->drv.name = driver->name;
727 	driver->drv.bus = &acpi_bus_type;
728 	driver->drv.owner = driver->owner;
729 
730 	ret = driver_register(&driver->drv);
731 	return ret;
732 }
733 
734 EXPORT_SYMBOL(acpi_bus_register_driver);
735 
736 /**
737  * acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
738  * @driver: driver to unregister
739  *
740  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
741  * devices that match the driver's criteria and unbinds.
742  */
743 void acpi_bus_unregister_driver(struct acpi_driver *driver)
744 {
745 	driver_unregister(&driver->drv);
746 }
747 
748 EXPORT_SYMBOL(acpi_bus_unregister_driver);
749 
750 /* --------------------------------------------------------------------------
751                               ACPI Bus operations
752    -------------------------------------------------------------------------- */
753 
754 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
755 {
756 	struct acpi_device *acpi_dev = to_acpi_device(dev);
757 	struct acpi_driver *acpi_drv = to_acpi_driver(drv);
758 
759 	return acpi_dev->flags.match_driver
760 		&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
761 }
762 
763 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
764 {
765 	return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
766 }
767 
768 static int acpi_device_probe(struct device *dev)
769 {
770 	struct acpi_device *acpi_dev = to_acpi_device(dev);
771 	struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
772 	int ret;
773 
774 	if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
775 		return -EINVAL;
776 
777 	if (!acpi_drv->ops.add)
778 		return -ENOSYS;
779 
780 	ret = acpi_drv->ops.add(acpi_dev);
781 	if (ret)
782 		return ret;
783 
784 	acpi_dev->driver = acpi_drv;
785 	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
786 			  "Driver [%s] successfully bound to device [%s]\n",
787 			  acpi_drv->name, acpi_dev->pnp.bus_id));
788 
789 	if (acpi_drv->ops.notify) {
790 		ret = acpi_device_install_notify_handler(acpi_dev);
791 		if (ret) {
792 			if (acpi_drv->ops.remove)
793 				acpi_drv->ops.remove(acpi_dev);
794 
795 			acpi_dev->driver = NULL;
796 			acpi_dev->driver_data = NULL;
797 			return ret;
798 		}
799 	}
800 
801 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
802 			  acpi_drv->name, acpi_dev->pnp.bus_id));
803 	get_device(dev);
804 	return 0;
805 }
806 
807 static int acpi_device_remove(struct device * dev)
808 {
809 	struct acpi_device *acpi_dev = to_acpi_device(dev);
810 	struct acpi_driver *acpi_drv = acpi_dev->driver;
811 
812 	if (acpi_drv) {
813 		if (acpi_drv->ops.notify)
814 			acpi_device_remove_notify_handler(acpi_dev);
815 		if (acpi_drv->ops.remove)
816 			acpi_drv->ops.remove(acpi_dev);
817 	}
818 	acpi_dev->driver = NULL;
819 	acpi_dev->driver_data = NULL;
820 
821 	put_device(dev);
822 	return 0;
823 }
824 
825 struct bus_type acpi_bus_type = {
826 	.name		= "acpi",
827 	.match		= acpi_bus_match,
828 	.probe		= acpi_device_probe,
829 	.remove		= acpi_device_remove,
830 	.uevent		= acpi_device_uevent,
831 };
832 
833 /* --------------------------------------------------------------------------
834                              Initialization/Cleanup
835    -------------------------------------------------------------------------- */
836 
837 static int __init acpi_bus_init_irq(void)
838 {
839 	acpi_status status;
840 	char *message = NULL;
841 
842 
843 	/*
844 	 * Let the system know what interrupt model we are using by
845 	 * evaluating the \_PIC object, if exists.
846 	 */
847 
848 	switch (acpi_irq_model) {
849 	case ACPI_IRQ_MODEL_PIC:
850 		message = "PIC";
851 		break;
852 	case ACPI_IRQ_MODEL_IOAPIC:
853 		message = "IOAPIC";
854 		break;
855 	case ACPI_IRQ_MODEL_IOSAPIC:
856 		message = "IOSAPIC";
857 		break;
858 	case ACPI_IRQ_MODEL_GIC:
859 		message = "GIC";
860 		break;
861 	case ACPI_IRQ_MODEL_PLATFORM:
862 		message = "platform specific model";
863 		break;
864 	default:
865 		printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
866 		return -ENODEV;
867 	}
868 
869 	printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
870 
871 	status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
872 	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
873 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
874 		return -ENODEV;
875 	}
876 
877 	return 0;
878 }
879 
880 /**
881  * acpi_early_init - Initialize ACPICA and populate the ACPI namespace.
882  *
883  * The ACPI tables are accessible after this, but the handling of events has not
884  * been initialized and the global lock is not available yet, so AML should not
885  * be executed at this point.
886  *
887  * Doing this before switching the EFI runtime services to virtual mode allows
888  * the EfiBootServices memory to be freed slightly earlier on boot.
889  */
890 void __init acpi_early_init(void)
891 {
892 	acpi_status status;
893 
894 	if (acpi_disabled)
895 		return;
896 
897 	printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
898 
899 	/* It's safe to verify table checksums during late stage */
900 	acpi_gbl_verify_table_checksum = TRUE;
901 
902 	/* enable workarounds, unless strict ACPI spec. compliance */
903 	if (!acpi_strict)
904 		acpi_gbl_enable_interpreter_slack = TRUE;
905 
906 	acpi_gbl_permanent_mmap = 1;
907 
908 	/*
909 	 * If the machine falls into the DMI check table,
910 	 * DSDT will be copied to memory
911 	 */
912 	dmi_check_system(dsdt_dmi_table);
913 
914 	status = acpi_reallocate_root_table();
915 	if (ACPI_FAILURE(status)) {
916 		printk(KERN_ERR PREFIX
917 		       "Unable to reallocate ACPI tables\n");
918 		goto error0;
919 	}
920 
921 	status = acpi_initialize_subsystem();
922 	if (ACPI_FAILURE(status)) {
923 		printk(KERN_ERR PREFIX
924 		       "Unable to initialize the ACPI Interpreter\n");
925 		goto error0;
926 	}
927 
928 	if (acpi_gbl_group_module_level_code) {
929 		status = acpi_load_tables();
930 		if (ACPI_FAILURE(status)) {
931 			printk(KERN_ERR PREFIX
932 			       "Unable to load the System Description Tables\n");
933 			goto error0;
934 		}
935 	}
936 
937 #ifdef CONFIG_X86
938 	if (!acpi_ioapic) {
939 		/* compatible (0) means level (3) */
940 		if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
941 			acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
942 			acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
943 		}
944 		/* Set PIC-mode SCI trigger type */
945 		acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
946 					 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
947 	} else {
948 		/*
949 		 * now that acpi_gbl_FADT is initialized,
950 		 * update it with result from INT_SRC_OVR parsing
951 		 */
952 		acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
953 	}
954 #endif
955 	return;
956 
957  error0:
958 	disable_acpi();
959 }
960 
961 /**
962  * acpi_subsystem_init - Finalize the early initialization of ACPI.
963  *
964  * Switch over the platform to the ACPI mode (if possible), initialize the
965  * handling of ACPI events, install the interrupt and global lock handlers.
966  *
967  * Doing this too early is generally unsafe, but at the same time it needs to be
968  * done before all things that really depend on ACPI.  The right spot appears to
969  * be before finalizing the EFI initialization.
970  */
971 void __init acpi_subsystem_init(void)
972 {
973 	acpi_status status;
974 
975 	if (acpi_disabled)
976 		return;
977 
978 	status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
979 	if (ACPI_FAILURE(status)) {
980 		printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
981 		disable_acpi();
982 	} else {
983 		/*
984 		 * If the system is using ACPI then we can be reasonably
985 		 * confident that any regulators are managed by the firmware
986 		 * so tell the regulator core it has everything it needs to
987 		 * know.
988 		 */
989 		regulator_has_full_constraints();
990 	}
991 }
992 
993 static int __init acpi_bus_init(void)
994 {
995 	int result;
996 	acpi_status status;
997 
998 	acpi_os_initialize1();
999 
1000 	/*
1001 	 * ACPI 2.0 requires the EC driver to be loaded and work before
1002 	 * the EC device is found in the namespace (i.e. before
1003 	 * acpi_load_tables() is called).
1004 	 *
1005 	 * This is accomplished by looking for the ECDT table, and getting
1006 	 * the EC parameters out of that.
1007 	 */
1008 	status = acpi_ec_ecdt_probe();
1009 	/* Ignore result. Not having an ECDT is not fatal. */
1010 
1011 	if (!acpi_gbl_group_module_level_code) {
1012 		status = acpi_load_tables();
1013 		if (ACPI_FAILURE(status)) {
1014 			printk(KERN_ERR PREFIX
1015 			       "Unable to load the System Description Tables\n");
1016 			goto error1;
1017 		}
1018 	}
1019 
1020 	status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
1021 	if (ACPI_FAILURE(status)) {
1022 		printk(KERN_ERR PREFIX
1023 		       "Unable to start the ACPI Interpreter\n");
1024 		goto error1;
1025 	}
1026 
1027 	status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
1028 	if (ACPI_FAILURE(status)) {
1029 		printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
1030 		goto error1;
1031 	}
1032 
1033 	/* Set capability bits for _OSC under processor scope */
1034 	acpi_early_processor_osc();
1035 
1036 	/*
1037 	 * _OSC method may exist in module level code,
1038 	 * so it must be run after ACPI_FULL_INITIALIZATION
1039 	 */
1040 	acpi_bus_osc_support();
1041 
1042 	/*
1043 	 * _PDC control method may load dynamic SSDT tables,
1044 	 * and we need to install the table handler before that.
1045 	 */
1046 	acpi_sysfs_init();
1047 
1048 	acpi_early_processor_set_pdc();
1049 
1050 	/*
1051 	 * Maybe EC region is required at bus_scan/acpi_get_devices. So it
1052 	 * is necessary to enable it as early as possible.
1053 	 */
1054 	acpi_boot_ec_enable();
1055 
1056 	printk(KERN_INFO PREFIX "Interpreter enabled\n");
1057 
1058 	/* Initialize sleep structures */
1059 	acpi_sleep_init();
1060 
1061 	/*
1062 	 * Get the system interrupt model and evaluate \_PIC.
1063 	 */
1064 	result = acpi_bus_init_irq();
1065 	if (result)
1066 		goto error1;
1067 
1068 	/*
1069 	 * Register the for all standard device notifications.
1070 	 */
1071 	status =
1072 	    acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
1073 					&acpi_bus_notify, NULL);
1074 	if (ACPI_FAILURE(status)) {
1075 		printk(KERN_ERR PREFIX
1076 		       "Unable to register for device notifications\n");
1077 		goto error1;
1078 	}
1079 
1080 	/*
1081 	 * Create the top ACPI proc directory
1082 	 */
1083 	acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
1084 
1085 	result = bus_register(&acpi_bus_type);
1086 	if (!result)
1087 		return 0;
1088 
1089 	/* Mimic structured exception handling */
1090       error1:
1091 	acpi_terminate();
1092 	return -ENODEV;
1093 }
1094 
1095 struct kobject *acpi_kobj;
1096 EXPORT_SYMBOL_GPL(acpi_kobj);
1097 
1098 static int __init acpi_init(void)
1099 {
1100 	int result;
1101 
1102 	if (acpi_disabled) {
1103 		printk(KERN_INFO PREFIX "Interpreter disabled.\n");
1104 		return -ENODEV;
1105 	}
1106 
1107 	acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
1108 	if (!acpi_kobj) {
1109 		printk(KERN_WARNING "%s: kset create error\n", __func__);
1110 		acpi_kobj = NULL;
1111 	}
1112 
1113 	init_acpi_device_notify();
1114 	result = acpi_bus_init();
1115 	if (result) {
1116 		disable_acpi();
1117 		return result;
1118 	}
1119 
1120 	pci_mmcfg_late_init();
1121 	acpi_scan_init();
1122 	acpi_ec_init();
1123 	acpi_debugfs_init();
1124 	acpi_sleep_proc_init();
1125 	acpi_wakeup_device_init();
1126 	acpi_debugger_init();
1127 	return 0;
1128 }
1129 
1130 subsys_initcall(acpi_init);
1131