2019-05-27 14:55:06 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
*/
|
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
#define pr_fmt(fmt) "ACPI: " fmt
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/ioport.h>
|
2006-07-12 13:47:00 +08:00
|
|
|
#include <linux/kernel.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2008-02-10 06:24:08 +08:00
|
|
|
#include <linux/acpi.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2014-01-27 08:32:14 +08:00
|
|
|
#include <linux/regulator/machine.h>
|
2016-06-24 02:24:26 +08:00
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/delay.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
#include <asm/mpspec.h>
|
2018-09-04 20:55:26 +08:00
|
|
|
#include <linux/dmi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2022-03-09 10:07:50 +08:00
|
|
|
#include <linux/acpi_agdi.h>
|
2016-09-13 02:54:20 +08:00
|
|
|
#include <linux/acpi_iort.h>
|
ACPI: Add driver for the VIOT table
The ACPI Virtual I/O Translation Table describes topology of
para-virtual platforms, similarly to vendor tables DMAR, IVRS and IORT.
For now it describes the relation between virtio-iommu and the endpoints
it manages.
Three steps are needed to configure DMA of endpoints:
(1) acpi_viot_init(): parse the VIOT table, find or create the fwnode
associated to each vIOMMU device. This needs to happen after
acpi_scan_init(), because it relies on the struct device and their
fwnode to be available.
(2) When probing the vIOMMU device, the driver registers its IOMMU ops
within the IOMMU subsystem. This step doesn't require any
intervention from the VIOT driver.
(3) viot_iommu_configure(): before binding the endpoint to a driver,
find the associated IOMMU ops. Register them, along with the
endpoint ID, into the device's iommu_fwspec.
If step (3) happens before step (2), it is deferred until the IOMMU is
initialized, then retried.
Tested-by: Eric Auger <eric.auger@redhat.com>
Reviewed-by: Eric Auger <eric.auger@redhat.com>
Signed-off-by: Jean-Philippe Brucker <jean-philippe@linaro.org>
Acked-by: Rafael J. Wysocki <rafael@kernel.org>
Link: https://lore.kernel.org/r/20210618152059.1194210-4-jean-philippe@linaro.org
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2021-06-18 23:20:58 +08:00
|
|
|
#include <linux/acpi_viot.h>
|
2008-02-15 17:27:20 +08:00
|
|
|
#include <linux/pci.h>
|
2011-07-13 13:14:20 +08:00
|
|
|
#include <acpi/apei.h>
|
2011-02-11 07:04:52 +08:00
|
|
|
#include <linux/suspend.h>
|
ACPI: PRM: implement OperationRegion handler for the PlatformRtMechanism subtype
Platform Runtime Mechanism (PRM) is a firmware interface that exposes
a set of binary executables that can either be called from the AML
interpreter or device drivers by bypassing the AML interpreter.
This change implements the AML interpreter path.
According to the specification [1], PRM services are listed in an
ACPI table called the PRMT. This patch parses module and handler
information listed in the PRMT and registers the PlatformRtMechanism
OpRegion handler before ACPI tables are loaded.
Each service is defined by a 16-byte GUID and called from writing a
26-byte ASL buffer containing the identifier to a FieldUnit object
defined inside a PlatformRtMechanism OperationRegion.
OperationRegion (PRMR, PlatformRtMechanism, 0, 26)
Field (PRMR, BufferAcc, NoLock, Preserve)
{
PRMF, 208 // Write to this field to invoke the OperationRegion Handler
}
The 26-byte ASL buffer is defined as the following:
Byte Offset Byte Length Description
=============================================================
0 1 PRM OperationRegion handler status
1 8 PRM service status
9 1 PRM command
10 16 PRM handler GUID
The ASL caller fills out a 26-byte buffer containing the PRM command
and the PRM handler GUID like so:
/* Local0 is the PRM data buffer */
Local0 = buffer (26){}
/* Create byte fields over the buffer */
CreateByteField (Local0, 0x9, CMD)
CreateField (Local0, 0x50, 0x80, GUID)
/* Fill in the command and data fields of the data buffer */
CMD = 0 // run command
GUID = ToUUID("xxxx-xx-xxx-xxxx")
/*
* Invoke PRM service with an ID that matches GUID and save the
* result.
*/
Local0 = (\_SB.PRMT.PRMF = Local0)
Byte offset 0 - 8 are written by the handler as a status passed back to AML
and used by ASL like so:
/* Create byte fields over the buffer */
CreateByteField (Local0, 0x0, PSTA)
CreateQWordField (Local0, 0x1, USTA)
In this ASL code, PSTA contains a status from the OperationRegion and
USTA contains a status from the PRM service.
The 26-byte buffer is recieved by acpi_platformrt_space_handler. This
handler will look at the command value and the handler guid and take
the approperiate actions.
Command value Action
=====================================================================
0 Run the PRM service indicated by the PRM handler
GUID (bytes 10-26)
1 Prevent PRM runtime updates from happening to the
service's parent module
2 Allow PRM updates from happening to the service's parent module
This patch enables command value 0.
Link: https://uefi.org/sites/default/files/resources/Platform%20Runtime%20Mechanism%20-%20with%20legal%20notice.pdf # [1]
Signed-off-by: Erik Kaneda <erik.kaneda@intel.com>
[ rjw: Subject and changelog edits ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-06-10 11:41:52 +08:00
|
|
|
#include <linux/prmt.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-03-14 02:08:26 +08:00
|
|
|
#include "internal.h"
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
struct acpi_device *acpi_root;
|
|
|
|
struct proc_dir_entry *acpi_root_dir;
|
2005-04-17 06:20:36 +08:00
|
|
|
EXPORT_SYMBOL(acpi_root_dir);
|
|
|
|
|
2010-05-12 09:26:48 +08:00
|
|
|
#ifdef CONFIG_X86
|
2014-05-12 15:50:16 +08:00
|
|
|
#ifdef CONFIG_ACPI_CUSTOM_DSDT
|
|
|
|
static inline int set_copy_dsdt(const struct dmi_system_id *id)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
2010-04-08 14:34:27 +08:00
|
|
|
static int set_copy_dsdt(const struct dmi_system_id *id)
|
|
|
|
{
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_notice("%s detected - force copy of DSDT to local memory\n", id->ident);
|
2010-04-08 14:34:27 +08:00
|
|
|
acpi_gbl_copy_dsdt_locally = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2014-05-12 15:50:16 +08:00
|
|
|
#endif
|
2010-04-08 14:34:27 +08:00
|
|
|
|
2018-07-19 19:00:30 +08:00
|
|
|
static const struct dmi_system_id dsdt_dmi_table[] __initconst = {
|
2010-04-08 14:34:27 +08:00
|
|
|
/*
|
2010-09-29 10:57:02 +08:00
|
|
|
* Invoke DSDT corruption work-around on all Toshiba Satellite.
|
2010-04-08 14:34:27 +08:00
|
|
|
* https://bugzilla.kernel.org/show_bug.cgi?id=14679
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = set_copy_dsdt,
|
2010-09-29 10:57:02 +08:00
|
|
|
.ident = "TOSHIBA Satellite",
|
2010-04-08 14:34:27 +08:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
2010-09-29 10:57:02 +08:00
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
|
2010-04-08 14:34:27 +08:00
|
|
|
},
|
2010-05-12 09:26:48 +08:00
|
|
|
},
|
|
|
|
{}
|
2010-04-08 14:34:27 +08:00
|
|
|
};
|
2010-05-12 09:26:48 +08:00
|
|
|
#endif
|
2010-04-08 14:34:27 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2009-09-22 03:30:01 +08:00
|
|
|
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
|
|
|
|
unsigned long long *sta)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-22 03:30:01 +08:00
|
|
|
acpi_status status;
|
2005-08-05 12:44:28 +08:00
|
|
|
|
2009-09-22 03:30:01 +08:00
|
|
|
status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
|
|
|
|
if (ACPI_SUCCESS(status))
|
|
|
|
return AE_OK;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-22 03:30:01 +08:00
|
|
|
if (status == AE_NOT_FOUND) {
|
|
|
|
*sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
|
|
|
|
ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
|
|
|
|
return AE_OK;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-09-22 03:30:01 +08:00
|
|
|
return status;
|
|
|
|
}
|
2018-01-26 23:02:56 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_get_status_handle);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-22 03:30:01 +08:00
|
|
|
int acpi_bus_get_status(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
unsigned long long sta;
|
|
|
|
|
2021-11-23 01:05:31 +08:00
|
|
|
if (acpi_device_override_status(device, &sta)) {
|
|
|
|
acpi_set_device_status(device, sta);
|
2017-04-21 18:47:40 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-26 23:02:58 +08:00
|
|
|
/* Battery devices must have their deps met before calling _STA */
|
|
|
|
if (acpi_device_is_battery(device) && device->dep_unmet) {
|
|
|
|
acpi_set_device_status(device, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-22 03:30:01 +08:00
|
|
|
status = acpi_bus_get_status_handle(device->handle, &sta);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-11-23 04:56:06 +08:00
|
|
|
acpi_set_device_status(device, sta);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (device->status.functional && !device->status.present) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_debug("Device [%s] status [%08x]: functional but not present\n",
|
|
|
|
device->pnp.bus_id, (u32)sta);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_debug("Device [%s] status [%08x]\n", device->pnp.bus_id, (u32)sta);
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-08-05 12:44:28 +08:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_status);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-17 15:51:21 +08:00
|
|
|
void acpi_bus_private_data_handler(acpi_handle handle,
|
2009-06-29 13:43:27 +08:00
|
|
|
void *context)
|
2008-01-17 15:51:21 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_private_data_handler);
|
|
|
|
|
2014-05-20 20:59:21 +08:00
|
|
|
int acpi_bus_attach_private_data(acpi_handle handle, void *data)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_attach_data(handle,
|
|
|
|
acpi_bus_private_data_handler, data);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_handle_debug(handle, "Error attaching device data\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
|
|
|
|
|
2008-01-17 15:51:21 +08:00
|
|
|
int acpi_bus_get_private_data(acpi_handle handle, void **data)
|
|
|
|
{
|
2013-06-04 02:20:24 +08:00
|
|
|
acpi_status status;
|
2008-01-17 15:51:21 +08:00
|
|
|
|
2019-11-28 18:28:29 +08:00
|
|
|
if (!data)
|
2008-01-17 15:51:21 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
|
2014-05-20 20:59:21 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_handle_debug(handle, "No context for object\n");
|
2008-01-17 15:51:21 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-05-20 20:59:21 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
|
|
|
|
|
|
|
|
void acpi_bus_detach_private_data(acpi_handle handle)
|
|
|
|
{
|
|
|
|
acpi_detach_data(handle, acpi_bus_private_data_handler);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
|
2008-01-17 15:51:21 +08:00
|
|
|
|
2009-10-29 11:04:28 +08:00
|
|
|
static void acpi_print_osc_error(acpi_handle handle,
|
2016-06-16 23:23:09 +08:00
|
|
|
struct acpi_osc_context *context, char *error)
|
2009-10-29 11:04:28 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2016-06-16 23:23:09 +08:00
|
|
|
acpi_handle_debug(handle, "(%s): %s\n", context->uuid_str, error);
|
|
|
|
|
|
|
|
pr_debug("_OSC request data:");
|
2009-10-29 11:04:28 +08:00
|
|
|
for (i = 0; i < context->cap.length; i += sizeof(u32))
|
2016-06-16 23:23:09 +08:00
|
|
|
pr_debug(" %x", *((u32 *)(context->cap.pointer + i)));
|
|
|
|
|
|
|
|
pr_debug("\n");
|
2009-10-29 11:04:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
struct acpi_object_list input;
|
|
|
|
union acpi_object in_params[4];
|
|
|
|
union acpi_object *out_obj;
|
2017-06-06 00:40:44 +08:00
|
|
|
guid_t guid;
|
2009-10-29 11:04:28 +08:00
|
|
|
u32 errors;
|
2009-12-23 17:04:11 +08:00
|
|
|
struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
|
2009-10-29 11:04:28 +08:00
|
|
|
|
|
|
|
if (!context)
|
|
|
|
return AE_ERROR;
|
2017-06-06 00:40:44 +08:00
|
|
|
if (guid_parse(context->uuid_str, &guid))
|
2009-10-29 11:04:28 +08:00
|
|
|
return AE_ERROR;
|
|
|
|
context->ret.length = ACPI_ALLOCATE_BUFFER;
|
|
|
|
context->ret.pointer = NULL;
|
|
|
|
|
|
|
|
/* Setting up input parameters */
|
|
|
|
input.count = 4;
|
|
|
|
input.pointer = in_params;
|
|
|
|
in_params[0].type = ACPI_TYPE_BUFFER;
|
|
|
|
in_params[0].buffer.length = 16;
|
2017-06-06 00:40:44 +08:00
|
|
|
in_params[0].buffer.pointer = (u8 *)&guid;
|
2009-10-29 11:04:28 +08:00
|
|
|
in_params[1].type = ACPI_TYPE_INTEGER;
|
|
|
|
in_params[1].integer.value = context->rev;
|
|
|
|
in_params[2].type = ACPI_TYPE_INTEGER;
|
|
|
|
in_params[2].integer.value = context->cap.length/sizeof(u32);
|
|
|
|
in_params[3].type = ACPI_TYPE_BUFFER;
|
|
|
|
in_params[3].buffer.length = context->cap.length;
|
|
|
|
in_params[3].buffer.pointer = context->cap.pointer;
|
|
|
|
|
2009-12-23 17:04:11 +08:00
|
|
|
status = acpi_evaluate_object(handle, "_OSC", &input, &output);
|
2009-10-29 11:04:28 +08:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
|
|
|
|
2009-12-23 17:04:11 +08:00
|
|
|
if (!output.length)
|
2009-10-29 11:04:28 +08:00
|
|
|
return AE_NULL_OBJECT;
|
|
|
|
|
2009-12-23 17:04:11 +08:00
|
|
|
out_obj = output.pointer;
|
|
|
|
if (out_obj->type != ACPI_TYPE_BUFFER
|
|
|
|
|| out_obj->buffer.length != context->cap.length) {
|
2009-10-29 11:04:28 +08:00
|
|
|
acpi_print_osc_error(handle, context,
|
|
|
|
"_OSC evaluation returned wrong type");
|
|
|
|
status = AE_TYPE;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
/* Need to ignore the bit0 in result code */
|
|
|
|
errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
|
|
|
|
if (errors) {
|
|
|
|
if (errors & OSC_REQUEST_ERROR)
|
|
|
|
acpi_print_osc_error(handle, context,
|
|
|
|
"_OSC request failed");
|
|
|
|
if (errors & OSC_INVALID_UUID_ERROR)
|
|
|
|
acpi_print_osc_error(handle, context,
|
|
|
|
"_OSC invalid UUID");
|
|
|
|
if (errors & OSC_INVALID_REVISION_ERROR)
|
|
|
|
acpi_print_osc_error(handle, context,
|
|
|
|
"_OSC invalid revision");
|
|
|
|
if (errors & OSC_CAPABILITIES_MASK_ERROR) {
|
2013-09-06 05:05:54 +08:00
|
|
|
if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
|
2009-10-29 11:04:28 +08:00
|
|
|
& OSC_QUERY_ENABLE)
|
|
|
|
goto out_success;
|
|
|
|
status = AE_SUPPORT;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
status = AE_ERROR;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
out_success:
|
2009-12-23 17:04:11 +08:00
|
|
|
context->ret.length = out_obj->buffer.length;
|
2013-03-11 16:20:16 +08:00
|
|
|
context->ret.pointer = kmemdup(out_obj->buffer.pointer,
|
|
|
|
context->ret.length, GFP_KERNEL);
|
2009-12-23 17:04:11 +08:00
|
|
|
if (!context->ret.pointer) {
|
|
|
|
status = AE_NO_MEMORY;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
status = AE_OK;
|
2009-10-29 11:04:28 +08:00
|
|
|
|
|
|
|
out_kfree:
|
2009-12-23 17:04:11 +08:00
|
|
|
kfree(output.pointer);
|
2009-10-29 11:04:28 +08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_run_osc);
|
|
|
|
|
2011-07-13 13:14:20 +08:00
|
|
|
bool osc_sb_apei_support_acked;
|
2016-07-22 00:18:07 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI 6.0 Section 8.4.4.2 Idle State Coordination
|
|
|
|
* OSPM supports platform coordinated low power idle(LPI) states
|
|
|
|
*/
|
|
|
|
bool osc_pc_lpi_support_confirmed;
|
|
|
|
EXPORT_SYMBOL_GPL(osc_pc_lpi_support_confirmed);
|
|
|
|
|
2022-05-18 17:08:57 +08:00
|
|
|
/*
|
|
|
|
* ACPI 6.2 Section 6.2.11.2 'Platform-Wide OSPM Capabilities':
|
|
|
|
* Starting with ACPI Specification 6.2, all _CPC registers can be in
|
|
|
|
* PCC, System Memory, System IO, or Functional Fixed Hardware address
|
|
|
|
* spaces. OSPM support for this more flexible register space scheme is
|
|
|
|
* indicated by the “Flexible Address Space for CPPC Registers” _OSC bit.
|
|
|
|
*
|
|
|
|
* Otherwise (cf ACPI 6.1, s8.4.7.1.1.X), _CPC registers must be in:
|
|
|
|
* - PCC or Functional Fixed Hardware address space if defined
|
|
|
|
* - SystemMemory address space (NULL register) if not defined
|
|
|
|
*/
|
|
|
|
bool osc_cpc_flexible_adr_space_confirmed;
|
|
|
|
EXPORT_SYMBOL_GPL(osc_cpc_flexible_adr_space_confirmed);
|
|
|
|
|
2020-02-18 22:02:45 +08:00
|
|
|
/*
|
|
|
|
* ACPI 6.4 Operating System Capabilities for USB.
|
|
|
|
*/
|
|
|
|
bool osc_sb_native_usb4_support_confirmed;
|
|
|
|
EXPORT_SYMBOL_GPL(osc_sb_native_usb4_support_confirmed);
|
|
|
|
|
2022-07-06 02:29:14 +08:00
|
|
|
bool osc_sb_cppc2_support_acked;
|
2022-03-16 20:39:03 +08:00
|
|
|
|
2009-10-29 11:05:05 +08:00
|
|
|
static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
|
2020-10-26 23:01:05 +08:00
|
|
|
static void acpi_bus_osc_negotiate_platform_control(void)
|
2009-10-29 11:05:05 +08:00
|
|
|
{
|
2020-10-26 23:01:05 +08:00
|
|
|
u32 capbuf[2], *capbuf_ret;
|
2009-10-29 11:05:05 +08:00
|
|
|
struct acpi_osc_context context = {
|
|
|
|
.uuid_str = sb_uuid_str,
|
|
|
|
.rev = 1,
|
|
|
|
.cap.length = 8,
|
|
|
|
.cap.pointer = capbuf,
|
|
|
|
};
|
|
|
|
acpi_handle handle;
|
|
|
|
|
2013-09-06 05:05:54 +08:00
|
|
|
capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
|
2015-09-14 23:01:55 +08:00
|
|
|
if (IS_ENABLED(CONFIG_ACPI_PROCESSOR_AGGREGATOR))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
|
|
|
|
if (IS_ENABLED(CONFIG_ACPI_PROCESSOR))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
|
2011-07-13 13:14:20 +08:00
|
|
|
|
2013-09-06 05:05:54 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
|
2016-07-22 00:18:07 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;
|
2021-07-02 15:03:50 +08:00
|
|
|
if (IS_ENABLED(CONFIG_ACPI_PRMT))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PRM_SUPPORT;
|
2012-05-24 10:25:24 +08:00
|
|
|
|
2020-09-30 22:05:44 +08:00
|
|
|
#ifdef CONFIG_ARM64
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_GENERIC_INITIATOR_SUPPORT;
|
|
|
|
#endif
|
2016-11-23 04:23:58 +08:00
|
|
|
#ifdef CONFIG_X86
|
2020-09-30 22:05:44 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_GENERIC_INITIATOR_SUPPORT;
|
2016-11-23 04:23:58 +08:00
|
|
|
#endif
|
|
|
|
|
2022-05-18 17:08:58 +08:00
|
|
|
#ifdef CONFIG_ACPI_CPPC_LIB
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_SUPPORT;
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPCV2_SUPPORT;
|
2016-11-23 04:23:58 +08:00
|
|
|
#endif
|
|
|
|
|
2022-05-18 17:08:57 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_FLEXIBLE_ADR_SPACE;
|
|
|
|
|
2016-11-30 02:43:27 +08:00
|
|
|
if (IS_ENABLED(CONFIG_SCHED_MC_PRIO))
|
2016-11-23 04:23:59 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_DIVERSE_HIGH_SUPPORT;
|
|
|
|
|
2020-02-18 22:02:45 +08:00
|
|
|
if (IS_ENABLED(CONFIG_USB4))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_NATIVE_USB4_SUPPORT;
|
|
|
|
|
2011-07-13 13:14:20 +08:00
|
|
|
if (!ghes_disable)
|
2013-09-06 05:05:54 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
|
2009-10-29 11:05:05 +08:00
|
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
|
|
|
|
return;
|
2020-10-26 23:01:05 +08:00
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
|
|
|
|
return;
|
|
|
|
|
2022-03-16 20:37:44 +08:00
|
|
|
capbuf_ret = context.ret.pointer;
|
|
|
|
if (context.ret.length <= OSC_SUPPORT_DWORD) {
|
|
|
|
kfree(context.ret.pointer);
|
|
|
|
return;
|
|
|
|
}
|
2020-10-26 23:01:05 +08:00
|
|
|
|
2022-03-16 20:37:44 +08:00
|
|
|
/*
|
|
|
|
* Now run _OSC again with query flag clear and with the caps
|
|
|
|
* supported by both the OS and the platform.
|
|
|
|
*/
|
2020-10-26 23:01:05 +08:00
|
|
|
capbuf[OSC_QUERY_DWORD] = 0;
|
2022-03-16 20:37:44 +08:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] = capbuf_ret[OSC_SUPPORT_DWORD];
|
|
|
|
kfree(context.ret.pointer);
|
2020-10-26 23:01:05 +08:00
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
capbuf_ret = context.ret.pointer;
|
2022-03-16 20:37:44 +08:00
|
|
|
if (context.ret.length > OSC_SUPPORT_DWORD) {
|
2022-07-06 02:29:14 +08:00
|
|
|
#ifdef CONFIG_ACPI_CPPC_LIB
|
|
|
|
osc_sb_cppc2_support_acked = capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_CPCV2_SUPPORT;
|
|
|
|
#endif
|
|
|
|
|
2022-03-16 20:37:44 +08:00
|
|
|
osc_sb_apei_support_acked =
|
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
|
|
|
|
osc_pc_lpi_support_confirmed =
|
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
|
|
|
|
osc_sb_native_usb4_support_confirmed =
|
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_NATIVE_USB4_SUPPORT;
|
2022-05-18 17:08:57 +08:00
|
|
|
osc_cpc_flexible_adr_space_confirmed =
|
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_CPC_FLEXIBLE_ADR_SPACE;
|
2022-03-16 20:37:44 +08:00
|
|
|
}
|
2020-02-18 22:02:45 +08:00
|
|
|
|
|
|
|
kfree(context.ret.pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Native control of USB4 capabilities. If any of the tunneling bits is
|
|
|
|
* set it means OS is in control and we use software based connection
|
|
|
|
* manager.
|
|
|
|
*/
|
|
|
|
u32 osc_sb_native_usb4_control;
|
|
|
|
EXPORT_SYMBOL_GPL(osc_sb_native_usb4_control);
|
|
|
|
|
|
|
|
static void acpi_bus_decode_usb_osc(const char *msg, u32 bits)
|
|
|
|
{
|
2021-06-02 16:54:25 +08:00
|
|
|
pr_info("%s USB3%c DisplayPort%c PCIe%c XDomain%c\n", msg,
|
2020-02-18 22:02:45 +08:00
|
|
|
(bits & OSC_USB_USB3_TUNNELING) ? '+' : '-',
|
|
|
|
(bits & OSC_USB_DP_TUNNELING) ? '+' : '-',
|
|
|
|
(bits & OSC_USB_PCIE_TUNNELING) ? '+' : '-',
|
|
|
|
(bits & OSC_USB_XDOMAIN) ? '+' : '-');
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 sb_usb_uuid_str[] = "23A0D13A-26AB-486C-9C5F-0FFA525A575A";
|
|
|
|
static void acpi_bus_osc_negotiate_usb_control(void)
|
|
|
|
{
|
|
|
|
u32 capbuf[3];
|
|
|
|
struct acpi_osc_context context = {
|
|
|
|
.uuid_str = sb_usb_uuid_str,
|
|
|
|
.rev = 1,
|
|
|
|
.cap.length = sizeof(capbuf),
|
|
|
|
.cap.pointer = capbuf,
|
|
|
|
};
|
|
|
|
acpi_handle handle;
|
|
|
|
acpi_status status;
|
|
|
|
u32 control;
|
|
|
|
|
|
|
|
if (!osc_sb_native_usb4_support_confirmed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
control = OSC_USB_USB3_TUNNELING | OSC_USB_DP_TUNNELING |
|
|
|
|
OSC_USB_PCIE_TUNNELING | OSC_USB_XDOMAIN;
|
|
|
|
|
|
|
|
capbuf[OSC_QUERY_DWORD] = 0;
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] = 0;
|
|
|
|
capbuf[OSC_CONTROL_DWORD] = control;
|
|
|
|
|
|
|
|
status = acpi_run_osc(handle, &context);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (context.ret.length != sizeof(capbuf)) {
|
2021-06-02 16:54:25 +08:00
|
|
|
pr_info("USB4 _OSC: returned invalid length buffer\n");
|
2020-02-18 22:02:45 +08:00
|
|
|
goto out_free;
|
2020-10-26 23:01:05 +08:00
|
|
|
}
|
|
|
|
|
2020-02-18 22:02:45 +08:00
|
|
|
osc_sb_native_usb4_control =
|
2022-04-13 15:36:16 +08:00
|
|
|
control & acpi_osc_ctx_get_pci_control(&context);
|
2020-02-18 22:02:45 +08:00
|
|
|
|
|
|
|
acpi_bus_decode_usb_osc("USB4 _OSC: OS supports", control);
|
|
|
|
acpi_bus_decode_usb_osc("USB4 _OSC: OS controls",
|
|
|
|
osc_sb_native_usb4_control);
|
|
|
|
|
|
|
|
out_free:
|
2020-10-26 23:01:05 +08:00
|
|
|
kfree(context.ret.pointer);
|
2009-10-29 11:05:05 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Notification Handling
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_notify
|
|
|
|
* ---------------
|
|
|
|
* Callback for all 'system-level' device notifications (values 0x00-0x7F).
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-02-06 20:58:13 +08:00
|
|
|
struct acpi_device *adev;
|
|
|
|
u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
|
2014-05-01 07:16:06 +08:00
|
|
|
bool hotplug_event = false;
|
2009-05-23 01:43:41 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (type) {
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
|
2014-05-01 07:16:06 +08:00
|
|
|
hotplug_event = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
|
2014-05-01 07:16:06 +08:00
|
|
|
hotplug_event = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_WAKE:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
|
2014-05-01 07:16:06 +08:00
|
|
|
hotplug_event = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
/* TBD: Exactly what does 'light' mean? */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_FREQUENCY_MISMATCH:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_err(handle, "Device cannot be configured due "
|
|
|
|
"to a frequency mismatch\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_BUS_MODE_MISMATCH:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_err(handle, "Device cannot be configured due "
|
|
|
|
"to a bus mode mismatch\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_POWER_FAULT:
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_handle_err(handle, "Device has suffered a power fault\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2014-04-25 01:27:49 +08:00
|
|
|
acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2014-02-06 20:58:13 +08:00
|
|
|
adev = acpi_bus_get_acpi_device(handle);
|
|
|
|
if (!adev)
|
|
|
|
goto err;
|
2014-02-04 07:43:05 +08:00
|
|
|
|
2022-06-18 19:23:11 +08:00
|
|
|
if (adev->dev.driver) {
|
|
|
|
struct acpi_driver *driver = to_acpi_driver(adev->dev.driver);
|
|
|
|
|
|
|
|
if (driver && driver->ops.notify &&
|
|
|
|
(driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
|
|
|
|
driver->ops.notify(adev, type);
|
|
|
|
}
|
2014-02-06 20:58:13 +08:00
|
|
|
|
2017-06-30 15:25:38 +08:00
|
|
|
if (!hotplug_event) {
|
|
|
|
acpi_bus_put_acpi_device(adev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
|
2014-05-01 07:16:06 +08:00
|
|
|
return;
|
|
|
|
|
2014-02-06 20:58:13 +08:00
|
|
|
acpi_bus_put_acpi_device(adev);
|
|
|
|
|
|
|
|
err:
|
2014-02-21 08:07:17 +08:00
|
|
|
acpi_evaluate_ost(handle, type, ost_code, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2021-07-13 01:24:50 +08:00
|
|
|
static void acpi_notify_device(acpi_handle handle, u32 event, void *data)
|
2015-07-18 04:54:01 +08:00
|
|
|
{
|
|
|
|
struct acpi_device *device = data;
|
2022-06-18 19:23:11 +08:00
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(device->dev.driver);
|
2015-07-18 04:54:01 +08:00
|
|
|
|
2022-06-18 19:23:11 +08:00
|
|
|
acpi_drv->ops.notify(device, event);
|
2015-07-18 04:54:01 +08:00
|
|
|
}
|
|
|
|
|
2021-07-13 01:24:50 +08:00
|
|
|
static void acpi_notify_device_fixed(void *data)
|
2015-07-18 04:54:01 +08:00
|
|
|
{
|
|
|
|
struct acpi_device *device = data;
|
|
|
|
|
|
|
|
/* Fixed hardware devices have no handles */
|
2021-07-13 01:24:50 +08:00
|
|
|
acpi_notify_device(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
|
2015-07-18 04:54:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static u32 acpi_device_fixed_event(void *data)
|
|
|
|
{
|
2021-07-13 01:24:50 +08:00
|
|
|
acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_notify_device_fixed, data);
|
2015-07-18 04:54:01 +08:00
|
|
|
return ACPI_INTERRUPT_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_install_notify_handler(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
|
|
|
|
status =
|
|
|
|
acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
|
|
|
acpi_device_fixed_event,
|
|
|
|
device);
|
|
|
|
else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
|
|
|
|
status =
|
|
|
|
acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
|
|
|
acpi_device_fixed_event,
|
|
|
|
device);
|
|
|
|
else
|
|
|
|
status = acpi_install_notify_handler(device->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY,
|
2021-07-13 01:24:50 +08:00
|
|
|
acpi_notify_device,
|
2015-07-18 04:54:01 +08:00
|
|
|
device);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_device_remove_notify_handler(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
|
|
|
|
acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
|
|
|
acpi_device_fixed_event);
|
|
|
|
else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
|
|
|
|
acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
|
|
|
acpi_device_fixed_event);
|
|
|
|
else
|
|
|
|
acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
|
2021-07-13 01:24:50 +08:00
|
|
|
acpi_notify_device);
|
2015-07-18 04:54:01 +08:00
|
|
|
}
|
|
|
|
|
2016-06-24 02:24:26 +08:00
|
|
|
/* Handle events targeting \_SB device (at present only graceful shutdown) */
|
|
|
|
|
|
|
|
#define ACPI_SB_NOTIFY_SHUTDOWN_REQUEST 0x81
|
|
|
|
#define ACPI_SB_INDICATE_INTERVAL 10000
|
|
|
|
|
|
|
|
static void sb_notify_work(struct work_struct *dummy)
|
|
|
|
{
|
|
|
|
acpi_handle sb_handle;
|
|
|
|
|
|
|
|
orderly_poweroff(true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After initiating graceful shutdown, the ACPI spec requires OSPM
|
|
|
|
* to evaluate _OST method once every 10seconds to indicate that
|
|
|
|
* the shutdown is in progress
|
|
|
|
*/
|
|
|
|
acpi_get_handle(NULL, "\\_SB", &sb_handle);
|
|
|
|
while (1) {
|
|
|
|
pr_info("Graceful shutdown in progress.\n");
|
|
|
|
acpi_evaluate_ost(sb_handle, ACPI_OST_EC_OSPM_SHUTDOWN,
|
|
|
|
ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS, NULL);
|
|
|
|
msleep(ACPI_SB_INDICATE_INTERVAL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_sb_notify(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
static DECLARE_WORK(acpi_sb_work, sb_notify_work);
|
|
|
|
|
|
|
|
if (event == ACPI_SB_NOTIFY_SHUTDOWN_REQUEST) {
|
|
|
|
if (!work_busy(&acpi_sb_work))
|
|
|
|
schedule_work(&acpi_sb_work);
|
|
|
|
} else
|
|
|
|
pr_warn("event %x is not supported by \\_SB device\n", event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init acpi_setup_sb_notify_handler(void)
|
|
|
|
{
|
|
|
|
acpi_handle sb_handle;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &sb_handle)))
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_install_notify_handler(sb_handle, ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_sb_notify, NULL)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-18 04:53:52 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Matching
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2016-02-16 20:52:38 +08:00
|
|
|
/**
|
|
|
|
* acpi_get_first_physical_node - Get first physical node of an ACPI device
|
|
|
|
* @adev: ACPI device in question
|
|
|
|
*
|
|
|
|
* Return: First physical node of ACPI device @adev
|
|
|
|
*/
|
|
|
|
struct device *acpi_get_first_physical_node(struct acpi_device *adev)
|
2015-08-01 08:39:43 +08:00
|
|
|
{
|
|
|
|
struct mutex *physical_node_lock = &adev->physical_node_lock;
|
2016-02-16 20:52:38 +08:00
|
|
|
struct device *phys_dev;
|
2015-08-01 08:39:43 +08:00
|
|
|
|
|
|
|
mutex_lock(physical_node_lock);
|
|
|
|
if (list_empty(&adev->physical_node_list)) {
|
2016-02-16 20:52:38 +08:00
|
|
|
phys_dev = NULL;
|
2015-08-01 08:39:43 +08:00
|
|
|
} else {
|
|
|
|
const struct acpi_device_physical_node *node;
|
|
|
|
|
|
|
|
node = list_first_entry(&adev->physical_node_list,
|
|
|
|
struct acpi_device_physical_node, node);
|
2016-02-16 20:52:38 +08:00
|
|
|
|
|
|
|
phys_dev = node->dev;
|
2015-08-01 08:39:43 +08:00
|
|
|
}
|
|
|
|
mutex_unlock(physical_node_lock);
|
2016-02-16 20:52:38 +08:00
|
|
|
return phys_dev;
|
|
|
|
}
|
2020-05-19 20:34:21 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_get_first_physical_node);
|
2016-02-16 20:52:38 +08:00
|
|
|
|
|
|
|
static struct acpi_device *acpi_primary_dev_companion(struct acpi_device *adev,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
|
|
|
const struct device *phys_dev = acpi_get_first_physical_node(adev);
|
|
|
|
|
|
|
|
return phys_dev && phys_dev == dev ? adev : NULL;
|
2015-08-01 08:39:43 +08:00
|
|
|
}
|
|
|
|
|
2015-07-30 05:57:51 +08:00
|
|
|
/**
|
|
|
|
* acpi_device_is_first_physical_node - Is given dev first physical node
|
|
|
|
* @adev: ACPI companion device
|
|
|
|
* @dev: Physical device to check
|
|
|
|
*
|
|
|
|
* Function checks if given @dev is the first physical devices attached to
|
|
|
|
* the ACPI companion device. This distinction is needed in some cases
|
|
|
|
* where the same companion device is shared between many physical devices.
|
|
|
|
*
|
|
|
|
* Note that the caller have to provide valid @adev pointer.
|
|
|
|
*/
|
|
|
|
bool acpi_device_is_first_physical_node(struct acpi_device *adev,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
2015-08-01 08:39:43 +08:00
|
|
|
return !!acpi_primary_dev_companion(adev, dev);
|
2015-07-30 05:57:51 +08:00
|
|
|
}
|
|
|
|
|
2015-07-18 04:53:52 +08:00
|
|
|
/*
|
|
|
|
* acpi_companion_match() - Can we match via ACPI companion device
|
|
|
|
* @dev: Device in question
|
|
|
|
*
|
|
|
|
* Check if the given device has an ACPI companion and if that companion has
|
|
|
|
* a valid list of PNP IDs, and if the device is the first (primary) physical
|
|
|
|
* device associated with it. Return the companion pointer if that's the case
|
|
|
|
* or NULL otherwise.
|
|
|
|
*
|
|
|
|
* If multiple physical devices are attached to a single ACPI companion, we need
|
|
|
|
* to be careful. The usage scenario for this kind of relationship is that all
|
|
|
|
* of the physical devices in question use resources provided by the ACPI
|
|
|
|
* companion. A typical case is an MFD device where all the sub-devices share
|
|
|
|
* the parent's ACPI companion. In such cases we can only allow the primary
|
|
|
|
* (first) physical device to be matched with the help of the companion's PNP
|
|
|
|
* IDs.
|
|
|
|
*
|
|
|
|
* Additional physical devices sharing the ACPI companion can still use
|
|
|
|
* resources available from it but they will be matched normally using functions
|
|
|
|
* provided by their bus types (and analogously for their modalias).
|
|
|
|
*/
|
|
|
|
struct acpi_device *acpi_companion_match(const struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *adev;
|
|
|
|
|
|
|
|
adev = ACPI_COMPANION(dev);
|
|
|
|
if (!adev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (list_empty(&adev->pnp.ids))
|
|
|
|
return NULL;
|
|
|
|
|
2015-08-01 08:39:43 +08:00
|
|
|
return acpi_primary_dev_companion(adev, dev);
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_of_match_device - Match device object using the "compatible" property.
|
|
|
|
* @adev: ACPI device object to match.
|
|
|
|
* @of_match_table: List of device IDs to match against.
|
2018-02-09 23:38:33 +08:00
|
|
|
* @of_id: OF ID if matched
|
2015-07-18 04:53:52 +08:00
|
|
|
*
|
|
|
|
* If @dev has an ACPI companion which has ACPI_DT_NAMESPACE_HID in its list of
|
|
|
|
* identifiers and a _DSD object with the "compatible" property, use that
|
|
|
|
* property to match against the given list of identifiers.
|
|
|
|
*/
|
|
|
|
static bool acpi_of_match_device(struct acpi_device *adev,
|
2018-02-09 23:38:33 +08:00
|
|
|
const struct of_device_id *of_match_table,
|
|
|
|
const struct of_device_id **of_id)
|
2015-07-18 04:53:52 +08:00
|
|
|
{
|
|
|
|
const union acpi_object *of_compatible, *obj;
|
|
|
|
int i, nval;
|
|
|
|
|
|
|
|
if (!adev)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
of_compatible = adev->data.of_compatible;
|
|
|
|
if (!of_match_table || !of_compatible)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (of_compatible->type == ACPI_TYPE_PACKAGE) {
|
|
|
|
nval = of_compatible->package.count;
|
|
|
|
obj = of_compatible->package.elements;
|
|
|
|
} else { /* Must be ACPI_TYPE_STRING. */
|
|
|
|
nval = 1;
|
|
|
|
obj = of_compatible;
|
|
|
|
}
|
|
|
|
/* Now we can look for the driver DT compatible strings */
|
|
|
|
for (i = 0; i < nval; i++, obj++) {
|
|
|
|
const struct of_device_id *id;
|
|
|
|
|
|
|
|
for (id = of_match_table; id->compatible[0]; id++)
|
2018-02-09 23:38:33 +08:00
|
|
|
if (!strcasecmp(obj->string.pointer, id->compatible)) {
|
|
|
|
if (of_id)
|
|
|
|
*of_id = id;
|
2015-07-18 04:53:52 +08:00
|
|
|
return true;
|
2018-02-09 23:38:33 +08:00
|
|
|
}
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-02-06 00:30:12 +08:00
|
|
|
static bool acpi_of_modalias(struct acpi_device *adev,
|
|
|
|
char *modalias, size_t len)
|
|
|
|
{
|
|
|
|
const union acpi_object *of_compatible;
|
|
|
|
const union acpi_object *obj;
|
|
|
|
const char *str, *chr;
|
|
|
|
|
|
|
|
of_compatible = adev->data.of_compatible;
|
|
|
|
if (!of_compatible)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (of_compatible->type == ACPI_TYPE_PACKAGE)
|
|
|
|
obj = of_compatible->package.elements;
|
|
|
|
else /* Must be ACPI_TYPE_STRING. */
|
|
|
|
obj = of_compatible;
|
|
|
|
|
|
|
|
str = obj->string.pointer;
|
|
|
|
chr = strchr(str, ',');
|
|
|
|
strlcpy(modalias, chr ? chr + 1 : str, len);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_set_modalias - Set modalias using "compatible" property or supplied ID
|
|
|
|
* @adev: ACPI device object to match
|
|
|
|
* @default_id: ID string to use as default if no compatible string found
|
|
|
|
* @modalias: Pointer to buffer that modalias value will be copied into
|
|
|
|
* @len: Length of modalias buffer
|
|
|
|
*
|
|
|
|
* This is a counterpart of of_modalias_node() for struct acpi_device objects.
|
|
|
|
* If there is a compatible string for @adev, it will be copied to @modalias
|
|
|
|
* with the vendor prefix stripped; otherwise, @default_id will be used.
|
|
|
|
*/
|
|
|
|
void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
|
|
|
|
char *modalias, size_t len)
|
|
|
|
{
|
|
|
|
if (!acpi_of_modalias(adev, modalias, len))
|
|
|
|
strlcpy(modalias, default_id, len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_set_modalias);
|
|
|
|
|
2015-07-18 04:53:52 +08:00
|
|
|
static bool __acpi_match_device_cls(const struct acpi_device_id *id,
|
|
|
|
struct acpi_hardware_id *hwid)
|
|
|
|
{
|
|
|
|
int i, msk, byte_shift;
|
|
|
|
char buf[3];
|
|
|
|
|
|
|
|
if (!id->cls)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Apply class-code bitmask, before checking each class-code byte */
|
|
|
|
for (i = 1; i <= 3; i++) {
|
|
|
|
byte_shift = 8 * (3 - i);
|
|
|
|
msk = (id->cls_msk >> byte_shift) & 0xFF;
|
|
|
|
if (!msk)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sprintf(buf, "%02x", (id->cls >> byte_shift) & msk);
|
|
|
|
if (strncmp(buf, &hwid->id[(i - 1) * 2], 2))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-09 23:38:33 +08:00
|
|
|
static bool __acpi_match_device(struct acpi_device *device,
|
|
|
|
const struct acpi_device_id *acpi_ids,
|
|
|
|
const struct of_device_id *of_ids,
|
|
|
|
const struct acpi_device_id **acpi_id,
|
|
|
|
const struct of_device_id **of_id)
|
2015-07-18 04:53:52 +08:00
|
|
|
{
|
|
|
|
const struct acpi_device_id *id;
|
|
|
|
struct acpi_hardware_id *hwid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device is not present, it is unnecessary to load device
|
|
|
|
* driver for it.
|
|
|
|
*/
|
|
|
|
if (!device || !device->status.present)
|
2018-02-09 23:38:33 +08:00
|
|
|
return false;
|
2015-07-18 04:53:52 +08:00
|
|
|
|
|
|
|
list_for_each_entry(hwid, &device->pnp.ids, list) {
|
|
|
|
/* First, check the ACPI/PNP IDs provided by the caller. */
|
2018-02-09 23:38:33 +08:00
|
|
|
if (acpi_ids) {
|
|
|
|
for (id = acpi_ids; id->id[0] || id->cls; id++) {
|
|
|
|
if (id->id[0] && !strcmp((char *)id->id, hwid->id))
|
|
|
|
goto out_acpi_match;
|
|
|
|
if (id->cls && __acpi_match_device_cls(id, hwid))
|
|
|
|
goto out_acpi_match;
|
|
|
|
}
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Next, check ACPI_DT_NAMESPACE_HID and try to match the
|
|
|
|
* "compatible" property if found.
|
|
|
|
*/
|
2018-02-09 23:38:33 +08:00
|
|
|
if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id))
|
|
|
|
return acpi_of_match_device(device, of_ids, of_id);
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
2018-02-09 23:38:33 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
out_acpi_match:
|
|
|
|
if (acpi_id)
|
|
|
|
*acpi_id = id;
|
|
|
|
return true;
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_match_device - Match a struct device against a given list of ACPI IDs
|
|
|
|
* @ids: Array of struct acpi_device_id object to match against.
|
|
|
|
* @dev: The device structure to match.
|
|
|
|
*
|
|
|
|
* Check if @dev has a valid ACPI handle and if there is a struct acpi_device
|
|
|
|
* object for that handle and use that object to match against a given list of
|
|
|
|
* device IDs.
|
|
|
|
*
|
|
|
|
* Return a pointer to the first matching ID on success or %NULL on failure.
|
|
|
|
*/
|
|
|
|
const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
2018-02-09 23:38:33 +08:00
|
|
|
const struct acpi_device_id *id = NULL;
|
|
|
|
|
|
|
|
__acpi_match_device(acpi_companion_match(dev), ids, NULL, &id, NULL);
|
|
|
|
return id;
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_match_device);
|
|
|
|
|
2019-02-25 23:05:39 +08:00
|
|
|
static const void *acpi_of_device_get_match_data(const struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *adev = ACPI_COMPANION(dev);
|
|
|
|
const struct of_device_id *match = NULL;
|
|
|
|
|
|
|
|
if (!acpi_of_match_device(adev, dev->driver->of_match_table, &match))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return match->data;
|
|
|
|
}
|
|
|
|
|
2018-02-09 23:38:36 +08:00
|
|
|
const void *acpi_device_get_match_data(const struct device *dev)
|
2017-12-13 15:20:48 +08:00
|
|
|
{
|
|
|
|
const struct acpi_device_id *match;
|
|
|
|
|
2019-02-25 23:05:39 +08:00
|
|
|
if (!dev->driver->acpi_match_table)
|
|
|
|
return acpi_of_device_get_match_data(dev);
|
|
|
|
|
2017-12-13 15:20:48 +08:00
|
|
|
match = acpi_match_device(dev->driver->acpi_match_table, dev);
|
|
|
|
if (!match)
|
|
|
|
return NULL;
|
|
|
|
|
2018-02-09 23:38:36 +08:00
|
|
|
return (const void *)match->driver_data;
|
2017-12-13 15:20:48 +08:00
|
|
|
}
|
2018-02-09 23:38:35 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_device_get_match_data);
|
2017-12-13 15:20:48 +08:00
|
|
|
|
2015-07-18 04:53:52 +08:00
|
|
|
int acpi_match_device_ids(struct acpi_device *device,
|
|
|
|
const struct acpi_device_id *ids)
|
|
|
|
{
|
2018-02-09 23:38:33 +08:00
|
|
|
return __acpi_match_device(device, ids, NULL, NULL, NULL) ? 0 : -ENOENT;
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_match_device_ids);
|
|
|
|
|
|
|
|
bool acpi_driver_match_device(struct device *dev,
|
|
|
|
const struct device_driver *drv)
|
|
|
|
{
|
|
|
|
if (!drv->acpi_match_table)
|
|
|
|
return acpi_of_match_device(ACPI_COMPANION(dev),
|
2018-02-09 23:38:33 +08:00
|
|
|
drv->of_match_table,
|
|
|
|
NULL);
|
2015-07-18 04:53:52 +08:00
|
|
|
|
2018-02-09 23:38:33 +08:00
|
|
|
return __acpi_match_device(acpi_companion_match(dev),
|
|
|
|
drv->acpi_match_table, drv->of_match_table,
|
|
|
|
NULL, NULL);
|
2015-07-18 04:53:52 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_driver_match_device);
|
|
|
|
|
2015-07-18 04:54:01 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
ACPI Driver Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_register_driver - register a driver with the ACPI bus
|
|
|
|
* @driver: driver being registered
|
|
|
|
*
|
|
|
|
* Registers a driver with the ACPI bus. Searches the namespace for all
|
|
|
|
* devices that match the driver's criteria and binds. Returns zero for
|
|
|
|
* success or a negative error status for failure.
|
|
|
|
*/
|
|
|
|
int acpi_bus_register_driver(struct acpi_driver *driver)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return -ENODEV;
|
|
|
|
driver->drv.name = driver->name;
|
|
|
|
driver->drv.bus = &acpi_bus_type;
|
|
|
|
driver->drv.owner = driver->owner;
|
|
|
|
|
|
|
|
ret = driver_register(&driver->drv);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(acpi_bus_register_driver);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
|
|
|
|
* @driver: driver to unregister
|
|
|
|
*
|
|
|
|
* Unregisters a driver with the ACPI bus. Searches the namespace for all
|
|
|
|
* devices that match the driver's criteria and unbinds.
|
|
|
|
*/
|
|
|
|
void acpi_bus_unregister_driver(struct acpi_driver *driver)
|
|
|
|
{
|
|
|
|
driver_unregister(&driver->drv);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(acpi_bus_unregister_driver);
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
ACPI Bus operations
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int acpi_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(drv);
|
|
|
|
|
|
|
|
return acpi_dev->flags.match_driver
|
|
|
|
&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!acpi_drv->ops.add)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
ret = acpi_drv->ops.add(acpi_dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_debug("Driver [%s] successfully bound to device [%s]\n",
|
|
|
|
acpi_drv->name, acpi_dev->pnp.bus_id);
|
2015-07-18 04:54:01 +08:00
|
|
|
|
|
|
|
if (acpi_drv->ops.notify) {
|
|
|
|
ret = acpi_device_install_notify_handler(acpi_dev);
|
|
|
|
if (ret) {
|
|
|
|
if (acpi_drv->ops.remove)
|
|
|
|
acpi_drv->ops.remove(acpi_dev);
|
|
|
|
|
|
|
|
acpi_dev->driver_data = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_debug("Found driver [%s] for device [%s]\n", acpi_drv->name,
|
|
|
|
acpi_dev->pnp.bus_id);
|
|
|
|
|
2015-07-18 04:54:01 +08:00
|
|
|
get_device(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-07-14 03:35:22 +08:00
|
|
|
static void acpi_device_remove(struct device *dev)
|
2015-07-18 04:54:01 +08:00
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
2022-06-18 19:23:11 +08:00
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
|
2015-07-18 04:54:01 +08:00
|
|
|
|
2022-06-18 19:23:10 +08:00
|
|
|
if (acpi_drv->ops.notify)
|
|
|
|
acpi_device_remove_notify_handler(acpi_dev);
|
|
|
|
|
|
|
|
if (acpi_drv->ops.remove)
|
|
|
|
acpi_drv->ops.remove(acpi_dev);
|
2015-07-18 04:54:01 +08:00
|
|
|
|
|
|
|
acpi_dev->driver_data = NULL;
|
|
|
|
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct bus_type acpi_bus_type = {
|
|
|
|
.name = "acpi",
|
|
|
|
.match = acpi_bus_match,
|
|
|
|
.probe = acpi_device_probe,
|
|
|
|
.remove = acpi_device_remove,
|
|
|
|
.uevent = acpi_device_uevent,
|
|
|
|
};
|
2022-02-23 03:51:42 +08:00
|
|
|
|
|
|
|
int acpi_bus_for_each_dev(int (*fn)(struct device *, void *), void *data)
|
|
|
|
{
|
|
|
|
return bus_for_each_dev(&acpi_bus_type, NULL, data, fn);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_for_each_dev);
|
2015-07-18 04:54:01 +08:00
|
|
|
|
2022-04-22 23:13:48 +08:00
|
|
|
struct acpi_dev_walk_context {
|
|
|
|
int (*fn)(struct acpi_device *, void *);
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int acpi_dev_for_one_check(struct device *dev, void *context)
|
|
|
|
{
|
|
|
|
struct acpi_dev_walk_context *adwc = context;
|
|
|
|
|
|
|
|
if (dev->bus != &acpi_bus_type)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return adwc->fn(to_acpi_device(dev), adwc->data);
|
|
|
|
}
|
2022-06-14 02:26:03 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_dev_for_each_child);
|
2022-04-22 23:13:48 +08:00
|
|
|
|
2022-04-04 23:21:50 +08:00
|
|
|
int acpi_dev_for_each_child(struct acpi_device *adev,
|
2022-04-22 23:13:48 +08:00
|
|
|
int (*fn)(struct acpi_device *, void *), void *data)
|
2022-04-04 23:21:50 +08:00
|
|
|
{
|
2022-04-22 23:13:48 +08:00
|
|
|
struct acpi_dev_walk_context adwc = {
|
|
|
|
.fn = fn,
|
|
|
|
.data = data,
|
|
|
|
};
|
|
|
|
|
|
|
|
return device_for_each_child(&adev->dev, &adwc, acpi_dev_for_one_check);
|
2022-04-04 23:21:50 +08:00
|
|
|
}
|
|
|
|
|
2022-06-14 02:26:47 +08:00
|
|
|
int acpi_dev_for_each_child_reverse(struct acpi_device *adev,
|
|
|
|
int (*fn)(struct acpi_device *, void *),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct acpi_dev_walk_context adwc = {
|
|
|
|
.fn = fn,
|
|
|
|
.data = data,
|
|
|
|
};
|
|
|
|
|
|
|
|
return device_for_each_child_reverse(&adev->dev, &adwc, acpi_dev_for_one_check);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Initialization/Cleanup
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
static int __init acpi_bus_init_irq(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-06-04 02:20:24 +08:00
|
|
|
acpi_status status;
|
2005-08-05 12:44:28 +08:00
|
|
|
char *message = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
2007-02-10 14:32:16 +08:00
|
|
|
/*
|
2005-04-17 06:20:36 +08:00
|
|
|
* Let the system know what interrupt model we are using by
|
|
|
|
* evaluating the \_PIC object, if exists.
|
|
|
|
*/
|
|
|
|
|
|
|
|
switch (acpi_irq_model) {
|
|
|
|
case ACPI_IRQ_MODEL_PIC:
|
|
|
|
message = "PIC";
|
|
|
|
break;
|
|
|
|
case ACPI_IRQ_MODEL_IOAPIC:
|
|
|
|
message = "IOAPIC";
|
|
|
|
break;
|
|
|
|
case ACPI_IRQ_MODEL_IOSAPIC:
|
|
|
|
message = "IOSAPIC";
|
|
|
|
break;
|
2015-03-24 22:02:48 +08:00
|
|
|
case ACPI_IRQ_MODEL_GIC:
|
|
|
|
message = "GIC";
|
|
|
|
break;
|
2006-12-23 01:50:04 +08:00
|
|
|
case ACPI_IRQ_MODEL_PLATFORM:
|
|
|
|
message = "platform specific model";
|
|
|
|
break;
|
2022-07-20 18:51:32 +08:00
|
|
|
case ACPI_IRQ_MODEL_LPIC:
|
|
|
|
message = "LPIC";
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("Unknown interrupt routing model\n");
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("Using %s for interrupt routing\n", message);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-29 00:24:39 +08:00
|
|
|
status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("_PIC evaluation failed: %s\n", acpi_format_exception(status));
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-10 07:33:36 +08:00
|
|
|
/**
|
|
|
|
* acpi_early_init - Initialize ACPICA and populate the ACPI namespace.
|
|
|
|
*
|
|
|
|
* The ACPI tables are accessible after this, but the handling of events has not
|
|
|
|
* been initialized and the global lock is not available yet, so AML should not
|
|
|
|
* be executed at this point.
|
|
|
|
*
|
|
|
|
* Doing this before switching the EFI runtime services to virtual mode allows
|
|
|
|
* the EfiBootServices memory to be freed slightly earlier on boot.
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
void __init acpi_early_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-06-04 02:20:24 +08:00
|
|
|
acpi_status status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
2006-06-27 12:41:40 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("Core revision %08x\n", ACPI_CA_VERSION);
|
2006-03-18 05:44:00 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* enable workarounds, unless strict ACPI spec. compliance */
|
|
|
|
if (!acpi_strict)
|
|
|
|
acpi_gbl_enable_interpreter_slack = TRUE;
|
|
|
|
|
2016-12-14 15:04:46 +08:00
|
|
|
acpi_permanent_mmap = true;
|
2007-02-03 00:48:19 +08:00
|
|
|
|
2018-09-04 20:55:26 +08:00
|
|
|
#ifdef CONFIG_X86
|
2018-07-19 19:00:30 +08:00
|
|
|
/*
|
|
|
|
* If the machine falls into the DMI check table,
|
2018-09-04 20:55:26 +08:00
|
|
|
* DSDT will be copied to memory.
|
|
|
|
* Note that calling dmi_check_system() here on other architectures
|
|
|
|
* would not be OK because only x86 initializes dmi early enough.
|
|
|
|
* Thankfully only x86 systems need such quirks for now.
|
2018-07-19 19:00:30 +08:00
|
|
|
*/
|
|
|
|
dmi_check_system(dsdt_dmi_table);
|
2018-09-04 20:55:26 +08:00
|
|
|
#endif
|
2010-04-08 14:34:27 +08:00
|
|
|
|
2007-02-03 00:48:19 +08:00
|
|
|
status = acpi_reallocate_root_table();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to reallocate ACPI tables\n");
|
2007-02-03 00:48:19 +08:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
status = acpi_initialize_subsystem();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to initialize the ACPI Interpreter\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (!acpi_ioapic) {
|
|
|
|
/* compatible (0) means level (3) */
|
2007-02-03 00:48:22 +08:00
|
|
|
if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
|
|
|
|
acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
|
|
|
|
acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Set PIC-mode SCI trigger type */
|
2007-02-03 00:48:22 +08:00
|
|
|
acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
|
2007-02-03 00:48:22 +08:00
|
|
|
(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
/*
|
2007-02-03 00:48:22 +08:00
|
|
|
* now that acpi_gbl_FADT is initialized,
|
2005-04-17 06:20:36 +08:00
|
|
|
* update it with result from INT_SRC_OVR parsing
|
|
|
|
*/
|
2007-02-03 00:48:22 +08:00
|
|
|
acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-10 07:33:36 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
error0:
|
|
|
|
disable_acpi();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_subsystem_init - Finalize the early initialization of ACPI.
|
|
|
|
*
|
2016-07-04 11:13:59 +08:00
|
|
|
* Switch over the platform to the ACPI mode (if possible).
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-10 07:33:36 +08:00
|
|
|
*
|
|
|
|
* Doing this too early is generally unsafe, but at the same time it needs to be
|
|
|
|
* done before all things that really depend on ACPI. The right spot appears to
|
|
|
|
* be before finalizing the EFI initialization.
|
|
|
|
*/
|
|
|
|
void __init acpi_subsystem_init(void)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-11-06 21:20:42 +08:00
|
|
|
status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to enable ACPI\n");
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-10 07:33:36 +08:00
|
|
|
disable_acpi();
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If the system is using ACPI then we can be reasonably
|
|
|
|
* confident that any regulators are managed by the firmware
|
|
|
|
* so tell the regulator core it has everything it needs to
|
|
|
|
* know.
|
|
|
|
*/
|
|
|
|
regulator_has_full_constraints();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-09 00:13:09 +08:00
|
|
|
static acpi_status acpi_bus_table_handler(u32 event, void *table, void *context)
|
|
|
|
{
|
2021-06-16 22:05:50 +08:00
|
|
|
if (event == ACPI_TABLE_EVENT_LOAD)
|
|
|
|
acpi_scan_table_notify();
|
2016-07-09 00:13:09 +08:00
|
|
|
|
|
|
|
return acpi_sysfs_table_handler(event, table, context);
|
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
static int __init acpi_bus_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-06-04 02:20:24 +08:00
|
|
|
int result;
|
|
|
|
acpi_status status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-03-05 03:55:27 +08:00
|
|
|
acpi_os_initialize1();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-10-18 06:41:21 +08:00
|
|
|
status = acpi_load_tables();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to load the System Description Tables\n");
|
2018-10-18 06:41:21 +08:00
|
|
|
goto error1;
|
2016-03-24 10:43:00 +08:00
|
|
|
}
|
|
|
|
|
ACPI: EC: Look for ECDT EC after calling acpi_load_tables()
Some systems have had functional issues since commit 5a8361f7ecce
(ACPICA: Integrate package handling with module-level code) that,
among other things, changed the initial values of the
acpi_gbl_group_module_level_code and acpi_gbl_parse_table_as_term_list
global flags in ACPICA which implicitly caused acpi_ec_ecdt_probe() to
be called before acpi_load_tables() on the vast majority of platforms.
Namely, before commit 5a8361f7ecce, acpi_load_tables() was called from
acpi_early_init() if acpi_gbl_parse_table_as_term_list was FALSE and
acpi_gbl_group_module_level_code was TRUE, which almost always was
the case as FALSE and TRUE were their initial values, respectively.
The acpi_gbl_parse_table_as_term_list value would be changed to TRUE
for a couple of platforms in acpi_quirks_dmi_table[], but it remained
FALSE in the vast majority of cases.
After commit 5a8361f7ecce, the initial values of the two flags have
been reversed, so in effect acpi_load_tables() has not been called
from acpi_early_init() any more. That, in turn, affects
acpi_ec_ecdt_probe() which is invoked before acpi_load_tables() now
and it is not possible to evaluate the _REG method for the EC address
space handler installed by it. That effectively causes the EC address
space to be inaccessible to AML on platforms with an ECDT matching the
EC device definition in the DSDT and functional problems ensue in
there.
Because the default behavior before commit 5a8361f7ecce was to call
acpi_ec_ecdt_probe() after acpi_load_tables(), it should be safe to
do that again. Moreover, the EC address space handler installed by
acpi_ec_ecdt_probe() is only needed for AML to be able to access the
EC address space and the only AML that can run during acpi_load_tables()
is module-level code which only is allowed to access address spaces
with default handlers (memory, I/O and PCI config space).
For this reason, move the acpi_ec_ecdt_probe() invocation back to
acpi_bus_init(), from where it was taken away by commit d737f333b211
(ACPI: probe ECDT before loading AML tables regardless of module-level
code flag), and put it after the invocation of acpi_load_tables() to
restore the original code ordering from before commit 5a8361f7ecce.
Fixes: 5a8361f7ecce ("ACPICA: Integrate package handling with module-level code")
Link: https://bugzilla.kernel.org/show_bug.cgi?id=199981
Reported-by: step-ali <sunmooon15@gmail.com>
Reported-by: Charles Stanhope <charles.stanhope@gmail.com>
Tested-by: Charles Stanhope <charles.stanhope@gmail.com>
Reported-by: Paulo Nascimento <paulo.ulusu@googlemail.com>
Reported-by: David Purton <dcpurton@marshwiggle.net>
Reported-by: Adam Harvey <adam@adamharvey.name>
Reported-by: Zhang Rui <rui.zhang@intel.com>
Tested-by: Zhang Rui <rui.zhang@intel.com>
Tested-by: Jean-Marc Lenoir <archlinux@jihemel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2019-01-09 07:34:37 +08:00
|
|
|
/*
|
|
|
|
* ACPI 2.0 requires the EC driver to be loaded and work before the EC
|
|
|
|
* device is found in the namespace.
|
|
|
|
*
|
|
|
|
* This is accomplished by looking for the ECDT table and getting the EC
|
|
|
|
* parameters out of that.
|
|
|
|
*
|
|
|
|
* Do that before calling acpi_initialize_objects() which may trigger EC
|
|
|
|
* address space accesses.
|
|
|
|
*/
|
|
|
|
acpi_ec_ecdt_probe();
|
|
|
|
|
2016-03-24 10:43:00 +08:00
|
|
|
status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to start the ACPI Interpreter\n");
|
2016-03-24 10:43:00 +08:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to initialize ACPI objects\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
2016-03-24 12:07:39 +08:00
|
|
|
/* Set capability bits for _OSC under processor scope */
|
|
|
|
acpi_early_processor_osc();
|
|
|
|
|
2012-07-16 16:30:21 +08:00
|
|
|
/*
|
|
|
|
* _OSC method may exist in module level code,
|
|
|
|
* so it must be run after ACPI_FULL_INITIALIZATION
|
|
|
|
*/
|
2020-10-26 23:01:05 +08:00
|
|
|
acpi_bus_osc_negotiate_platform_control();
|
2020-02-18 22:02:45 +08:00
|
|
|
acpi_bus_osc_negotiate_usb_control();
|
2012-07-16 16:30:21 +08:00
|
|
|
|
2010-10-26 10:06:54 +08:00
|
|
|
/*
|
|
|
|
* _PDC control method may load dynamic SSDT tables,
|
|
|
|
* and we need to install the table handler before that.
|
|
|
|
*/
|
2016-07-09 00:13:09 +08:00
|
|
|
status = acpi_install_table_handler(acpi_bus_table_handler, NULL);
|
|
|
|
|
2010-10-26 10:06:54 +08:00
|
|
|
acpi_sysfs_init();
|
|
|
|
|
2009-12-21 03:19:09 +08:00
|
|
|
acpi_early_processor_set_pdc();
|
|
|
|
|
2008-10-06 10:31:36 +08:00
|
|
|
/*
|
|
|
|
* Maybe EC region is required at bus_scan/acpi_get_devices. So it
|
|
|
|
* is necessary to enable it as early as possible.
|
|
|
|
*/
|
2016-06-03 10:26:12 +08:00
|
|
|
acpi_ec_dsdt_probe();
|
2008-10-06 10:31:36 +08:00
|
|
|
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("Interpreter enabled\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-10 14:32:16 +08:00
|
|
|
/* Initialize sleep structures */
|
|
|
|
acpi_sleep_init();
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Get the system interrupt model and evaluate \_PIC.
|
|
|
|
*/
|
|
|
|
result = acpi_bus_init_irq();
|
|
|
|
if (result)
|
|
|
|
goto error1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register the for all standard device notifications.
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
status =
|
|
|
|
acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
|
|
|
|
&acpi_bus_notify, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_err("Unable to register for system notifications\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the top ACPI proc directory
|
|
|
|
*/
|
|
|
|
acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
|
|
|
|
|
2015-07-18 04:54:09 +08:00
|
|
|
result = bus_register(&acpi_bus_type);
|
|
|
|
if (!result)
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Mimic structured exception handling */
|
2005-08-05 12:44:28 +08:00
|
|
|
error1:
|
2005-04-17 06:20:36 +08:00
|
|
|
acpi_terminate();
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-11-03 07:19:59 +08:00
|
|
|
struct kobject *acpi_kobj;
|
2012-02-01 02:19:19 +08:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_kobj);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
static int __init acpi_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-02-16 04:22:24 +08:00
|
|
|
int result;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (acpi_disabled) {
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_info("Interpreter disabled.\n");
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-11-06 05:16:15 +08:00
|
|
|
acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
|
2021-06-02 17:36:49 +08:00
|
|
|
if (!acpi_kobj)
|
2021-01-21 02:59:05 +08:00
|
|
|
pr_debug("%s: kset create error\n", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ACPI: PRM: implement OperationRegion handler for the PlatformRtMechanism subtype
Platform Runtime Mechanism (PRM) is a firmware interface that exposes
a set of binary executables that can either be called from the AML
interpreter or device drivers by bypassing the AML interpreter.
This change implements the AML interpreter path.
According to the specification [1], PRM services are listed in an
ACPI table called the PRMT. This patch parses module and handler
information listed in the PRMT and registers the PlatformRtMechanism
OpRegion handler before ACPI tables are loaded.
Each service is defined by a 16-byte GUID and called from writing a
26-byte ASL buffer containing the identifier to a FieldUnit object
defined inside a PlatformRtMechanism OperationRegion.
OperationRegion (PRMR, PlatformRtMechanism, 0, 26)
Field (PRMR, BufferAcc, NoLock, Preserve)
{
PRMF, 208 // Write to this field to invoke the OperationRegion Handler
}
The 26-byte ASL buffer is defined as the following:
Byte Offset Byte Length Description
=============================================================
0 1 PRM OperationRegion handler status
1 8 PRM service status
9 1 PRM command
10 16 PRM handler GUID
The ASL caller fills out a 26-byte buffer containing the PRM command
and the PRM handler GUID like so:
/* Local0 is the PRM data buffer */
Local0 = buffer (26){}
/* Create byte fields over the buffer */
CreateByteField (Local0, 0x9, CMD)
CreateField (Local0, 0x50, 0x80, GUID)
/* Fill in the command and data fields of the data buffer */
CMD = 0 // run command
GUID = ToUUID("xxxx-xx-xxx-xxxx")
/*
* Invoke PRM service with an ID that matches GUID and save the
* result.
*/
Local0 = (\_SB.PRMT.PRMF = Local0)
Byte offset 0 - 8 are written by the handler as a status passed back to AML
and used by ASL like so:
/* Create byte fields over the buffer */
CreateByteField (Local0, 0x0, PSTA)
CreateQWordField (Local0, 0x1, USTA)
In this ASL code, PSTA contains a status from the OperationRegion and
USTA contains a status from the PRM service.
The 26-byte buffer is recieved by acpi_platformrt_space_handler. This
handler will look at the command value and the handler guid and take
the approperiate actions.
Command value Action
=====================================================================
0 Run the PRM service indicated by the PRM handler
GUID (bytes 10-26)
1 Prevent PRM runtime updates from happening to the
service's parent module
2 Allow PRM updates from happening to the service's parent module
This patch enables command value 0.
Link: https://uefi.org/sites/default/files/resources/Platform%20Runtime%20Mechanism%20-%20with%20legal%20notice.pdf # [1]
Signed-off-by: Erik Kaneda <erik.kaneda@intel.com>
[ rjw: Subject and changelog edits ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-06-10 11:41:52 +08:00
|
|
|
init_prmt();
|
ACPI: PCC: Implement OperationRegion handler for the PCC Type 3 subtype
PCC OpRegion provides a mechanism to communicate with the platform
directly from the AML. PCCT provides the list of PCC channel available
in the platform, a subset or all of them can be used in PCC Opregion.
This patch registers the PCC OpRegion handler before ACPI tables are
loaded. This relies on the special context data passed to identify and
set up the PCC channel before the OpRegion handler is executed for the
first time.
Typical PCC Opregion declaration looks like this:
OperationRegion (PFRM, PCC, 2, 0x74)
Field (PFRM, ByteAcc, NoLock, Preserve)
{
SIGN, 32,
FLGS, 32,
LEN, 32,
CMD, 32,
DATA, 800
}
It contains four named double words followed by 100 bytes of buffer
names DATA.
ASL can fill out the buffer something like:
/* Create global or local buffer */
Name (BUFF, Buffer (0x0C){})
/* Create double word fields over the buffer */
CreateDWordField (BUFF, 0x0, WD0)
CreateDWordField (BUFF, 0x04, WD1)
CreateDWordField (BUFF, 0x08, WD2)
/* Fill the named fields */
WD0 = 0x50434300
SIGN = BUFF
WD0 = 1
FLGS = BUFF
WD0 = 0x10
LEN = BUFF
/* Fill the payload in the DATA buffer */
WD0 = 0
WD1 = 0x08
WD2 = 0
DATA = BUFF
/* Write to CMD field to trigger handler */
WD0 = 0x4404
CMD = BUFF
This buffer is received by acpi_pcc_opregion_space_handler. This
handler will fetch the complete buffer via internal_pcc_buffer.
The setup handler will receive the special PCC context data which will
contain the PCC channel index which used to set up the channel. The
buffer pointer and length is saved in region context which is then used
in the handler.
(kernel test robot: Build failure with CONFIG_ACPI_DEBUGGER)
Link: https://lore.kernel.org/r/202201041539.feAV0l27-lkp@intel.com
Reported-by: kernel test robot <lkp@intel.com>
Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2022-01-05 03:51:08 +08:00
|
|
|
acpi_init_pcc();
|
2005-04-17 06:20:36 +08:00
|
|
|
result = acpi_bus_init();
|
2011-02-16 04:22:24 +08:00
|
|
|
if (result) {
|
2021-06-02 17:36:50 +08:00
|
|
|
kobject_put(acpi_kobj);
|
2005-04-17 06:20:36 +08:00
|
|
|
disable_acpi();
|
2009-03-25 06:49:38 +08:00
|
|
|
return result;
|
2011-02-16 04:22:24 +08:00
|
|
|
}
|
2009-03-25 06:49:38 +08:00
|
|
|
|
2011-02-16 04:22:24 +08:00
|
|
|
pci_mmcfg_late_init();
|
2016-09-13 02:54:20 +08:00
|
|
|
acpi_iort_init();
|
2022-06-30 17:40:59 +08:00
|
|
|
acpi_viot_early_init();
|
2022-02-27 20:25:45 +08:00
|
|
|
acpi_hest_init();
|
2022-02-27 20:25:46 +08:00
|
|
|
acpi_ghes_init();
|
2009-03-25 06:49:43 +08:00
|
|
|
acpi_scan_init();
|
2009-03-25 06:49:48 +08:00
|
|
|
acpi_ec_init();
|
2010-07-15 10:46:15 +08:00
|
|
|
acpi_debugfs_init();
|
2009-03-25 06:50:14 +08:00
|
|
|
acpi_sleep_proc_init();
|
2009-03-25 06:50:19 +08:00
|
|
|
acpi_wakeup_device_init();
|
2015-12-03 10:43:14 +08:00
|
|
|
acpi_debugger_init();
|
2016-06-24 02:24:26 +08:00
|
|
|
acpi_setup_sb_notify_handler();
|
ACPI: Add driver for the VIOT table
The ACPI Virtual I/O Translation Table describes topology of
para-virtual platforms, similarly to vendor tables DMAR, IVRS and IORT.
For now it describes the relation between virtio-iommu and the endpoints
it manages.
Three steps are needed to configure DMA of endpoints:
(1) acpi_viot_init(): parse the VIOT table, find or create the fwnode
associated to each vIOMMU device. This needs to happen after
acpi_scan_init(), because it relies on the struct device and their
fwnode to be available.
(2) When probing the vIOMMU device, the driver registers its IOMMU ops
within the IOMMU subsystem. This step doesn't require any
intervention from the VIOT driver.
(3) viot_iommu_configure(): before binding the endpoint to a driver,
find the associated IOMMU ops. Register them, along with the
endpoint ID, into the device's iommu_fwspec.
If step (3) happens before step (2), it is deferred until the IOMMU is
initialized, then retried.
Tested-by: Eric Auger <eric.auger@redhat.com>
Reviewed-by: Eric Auger <eric.auger@redhat.com>
Signed-off-by: Jean-Philippe Brucker <jean-philippe@linaro.org>
Acked-by: Rafael J. Wysocki <rafael@kernel.org>
Link: https://lore.kernel.org/r/20210618152059.1194210-4-jean-philippe@linaro.org
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2021-06-18 23:20:58 +08:00
|
|
|
acpi_viot_init();
|
2022-03-09 10:07:50 +08:00
|
|
|
acpi_agdi_init();
|
2011-02-16 04:22:24 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_init);
|