config ACPI_BGRT

bool "Boottime Graphics Resource Table support"

help

This driver adds support for exposing the ACPI Boottime Graphics

Resource Table, which allows the operating system to obtain

obj-$(CONFIG_ACPI_FAN) += fan.o

fan-objs := fan_core.o

fan-objs += fan_attr.o

obj-$(CONFIG_ACPI_VIDEO) += video.o

obj-$(CONFIG_ACPI_TAD) += acpi_tad.o

return 0;

}

POWER_SUPPLY_PROP_ONLINE,

};

return -ENOMEM;

ac->device = adev;

platform_set_drvdata(pdev, ac);

.fixed_clk_rate = 150000000,

};

static struct property_entry uart_properties[] = {

PROPERTY_ENTRY_U32("reg-io-width", 4),

PROPERTY_ENTRY_U32("reg-shift", 2),

{ "AMD0030", },

{ "AMD0040", APD_ADDR(fch_misc_desc)},

{ "AMDI0010", APD_ADDR(wt_i2c_desc) },

{ "AMDI0019", APD_ADDR(wt_i2c_desc) },

{ "AMDI0020", APD_ADDR(cz_uart_desc) },

{ "AMDI0022", APD_ADDR(cz_uart_desc) },

#define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"

#define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"

#define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80

static DEFINE_MUTEX(isolated_cpus_lock);

static DEFINE_MUTEX(round_robin_lock);

{

struct cpumask *pad_busy_cpus = to_cpumask(pad_busy_cpus_bits);

}

static unsigned int idle_pct = 5; /* percentage */

.length = 4,

.pointer = (void *)&idle_cpus,

};

mutex_lock(&isolated_cpus_lock);

num_cpus = acpi_pad_pur(handle);

if (num_cpus < 0) {

}

idle_cpus = acpi_pad_idle_cpus_num();

mutex_unlock(&isolated_cpus_lock);

}

struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);

acpi_status status;

status = acpi_install_notify_handler(adev->handle,

ACPI_DEVICE_NOTIFY, acpi_pad_notify, adev);

struct acpi_processor_errata errata __read_mostly;

EXPORT_SYMBOL_GPL(errata);

static int acpi_processor_errata_piix4(struct pci_dev *dev)

{

u8 value1 = 0;

#endif /* CONFIG_X86 */

/* Initialization */

#ifdef CONFIG_ACPI_HOTPLUG_CPU

{

int ret;

if (invalid_phys_cpuid(pr->phys_id))

return -ENODEV;

cpu_maps_update_begin();

cpus_write_lock();

if (ret)

goto out;

ret = arch_register_cpu(pr->id);

if (ret) {

acpi_unmap_cpu(pr->id);

goto out;

}

/*

*/

pr_info("CPU%d has been hot-added\n", pr->id);

out:

cpus_write_unlock();

return ret;

}

#else

{

return -ENODEV;

}

acpi_status status = AE_OK;

static int cpu0_initialized;

unsigned long long value;

acpi_processor_errata();

}

/*

*/

/*

* On some boxes several processors use the same processor bus id.

* (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.

* Such things have to be put in and set up by the processor driver's .probe().

*/

static int acpi_processor_add(struct acpi_device *device,

const struct acpi_device_id *id)

{

}

pr->handle = device->handle;

device->driver_data = pr;

result = acpi_processor_get_info(device);

if (result) /* Processor is not physically present or unavailable */

dev = get_cpu_device(pr->id);

if (!dev) {

result = -ENODEV;

}

result = acpi_bind_one(dev, device);

if (result)

pr->dev = dev;

dev_err(dev, "Processor driver could not be attached\n");

acpi_unbind_one(dev);

per_cpu(processors, pr->id) = NULL;

err_free_pr:

kfree(pr);

return result;

#ifdef CONFIG_ACPI_HOTPLUG_CPU

/* Removal */

{

struct acpi_processor *pr;

device_release_driver(pr->dev);

acpi_unbind_one(pr->dev);

cpu_maps_update_begin();

cpus_write_lock();

arch_unregister_cpu(pr->id);

acpi_unmap_cpu(pr->id);

cpus_write_unlock();

cpu_maps_update_done();

void __init acpi_early_processor_control_setup(void)

{

if (acpi_early_processor_osc()) {

} else {

acpi_early_processor_set_pdc();

}

}

.ids = processor_device_ids,

.attach = acpi_processor_add,

#ifdef CONFIG_ACPI_HOTPLUG_CPU

#endif

.hotplug = {

.enabled = true,

memcpy(&info->states[++last_index], &cx, sizeof(cx));

}

info->count = last_index;

#include <linux/pm_runtime.h>

#include <linux/suspend.h>

MODULE_LICENSE("GPL v2");

MODULE_AUTHOR("Rafael J. Wysocki");

return -ENOMEM;

}

data->device_id = device_id;

data->video = video;

}

video->device = device;

device->driver_data = video;

acpi_video_bus_find_cap(video);

u8 acpi_ns_is_locked);

void

acpi_adr_space_type space_id, u32 function);

acpi_status

acpi_ev_execute_reg_method(union acpi_operand_object *region_obj, u32 function);

ACPI_INIT_GLOBAL(u32, acpi_gbl_facs_index, ACPI_INVALID_TABLE_INDEX);

ACPI_INIT_GLOBAL(u32, acpi_gbl_xfacs_index, ACPI_INVALID_TABLE_INDEX);

ACPI_INIT_GLOBAL(u32, acpi_gbl_fadt_index, ACPI_INVALID_TABLE_INDEX);

/* These addresses are calculated from the FADT Event Block addresses */

#define ACPI_ADDRESS_TYPE_IO_RANGE 1

#define ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE 2

/* Resource descriptor types and masks */

#define ACPI_RESOURCE_NAME_LARGE 0x80

{{"_DSM",

METHOD_4ARGS(ACPI_TYPE_BUFFER, ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER,

METHOD_RETURNS(ACPI_RTYPE_ALL)}}, /* Must return a value, but it can be of any type */

{{"_DSS", METHOD_1ARGS(ACPI_TYPE_INTEGER),

elements =

ACPI_ALLOCATE_ZEROED(DB_DEFAULT_PKG_ELEMENTS *

sizeof(union acpi_object));

this = string;

for (i = 0; i < (DB_DEFAULT_PKG_ELEMENTS - 1); i++) {

/* Local prototypes */

static acpi_status

acpi_ev_reg_run(acpi_handle obj_handle,

u32 level, void *context, void **return_value);

acpi_gbl_default_address_spaces

[i])) {

acpi_ev_execute_reg_methods(acpi_gbl_root_node,

acpi_gbl_default_address_spaces

[i], ACPI_REG_CONNECT);

}

* FUNCTION: acpi_ev_execute_reg_methods

*

* PARAMETERS: node - Namespace node for the device

* space_id - The address space ID

* function - Passed to _REG: On (1) or Off (0)

*

******************************************************************************/

void

acpi_adr_space_type space_id, u32 function)

{

struct acpi_reg_walk_info info;

* regions and _REG methods. (i.e. handlers must be installed for all

* regions of this Space ID before we can run any _REG methods)

*/

ACPI_NS_WALK_UNLOCK, acpi_ev_reg_run, NULL,

&info, NULL);

*

******************************************************************************/

acpi_ev_execute_orphan_reg_method(struct acpi_namespace_node *device_node,

acpi_adr_space_type space_id)

{

/* Run all _REG methods for this address space */

if (run_reg) {

}

unlock_and_exit:

* FUNCTION: acpi_execute_reg_methods

*

* PARAMETERS: device - Handle for the device

* space_id - The address space ID

*

* RETURN: Status

*

******************************************************************************/

acpi_status

{

struct acpi_namespace_node *node;

acpi_status status;

/* Run all _REG methods for this address space */

} else {

status = AE_BAD_PARAMETER;

}

}

ACPI_EXPORT_SYMBOL(acpi_execute_reg_methods)

/* Local prototypes */

static u32

/*******************************************************************************

*

* base - ACPI_STRING_DECIMAL or ACPI_STRING_HEX

* string - Where the string is returned

* data_width - Size of data item to be converted, in bytes

*

* RETURN: Actual string length

*

******************************************************************************/

static u32

{

u64 digit;

u32 i;

u32 hex_length;

u32 decimal_length;

u32 remainder;

ACPI_FUNCTION_ENTRY();

break;

}

remainder = 0;

for (i = decimal_length; i > 0; i--) {

/* Get one hex digit, most significant digits first */

acpi_ut_hex_to_ascii_char(integer, ACPI_MUL_4(j));

k++;

}

break;

u32 string_length = 0;

u16 base = 16;

u8 separator = ',';

ACPI_FUNCTION_TRACE_PTR(ex_convert_to_string, obj_desc);

* Make room for the maximum decimal number size

*/

string_length = ACPI_MAX_DECIMAL_DIGITS;

base = 10;

break;

default:

/* Two hex string characters for each integer byte */

string_length = ACPI_MUL_2(acpi_gbl_integer_byte_width);

break;

}

}

new_buf = return_desc->buffer.pointer;

/* Convert integer to string */

string_length =

acpi_ex_convert_to_ascii(obj_desc->integer.value, base,

new_buf,

/* Null terminate at the correct place */

return_desc->string.length = string_length;

new_buf[string_length] = 0;

break;

* From ACPI: "If the input is a buffer, it is converted to a

* a string of decimal values separated by commas."

*/

base = 10;

/*

*

* Each hex number is prefixed with 0x (11/2018)

*/

separator = ' ';

string_length = (obj_desc->buffer.length * 5);

break;

*

* Each hex number is prefixed with 0x (11/2018)

*/

separator = ',';

string_length = (obj_desc->buffer.length * 5);

break;

new_buf += acpi_ex_convert_to_ascii((u64) obj_desc->

buffer.pointer[i],

/* Each digit is separated by either a comma or space */

if (info->connection_node) {

second_desc = info->connection_node->object;

if (!(second_desc->common.flags & AOPOBJ_DATA_VALID)) {

status =

acpi_ds_get_buffer_arguments(second_desc);

* (ACPI specifies 100 usec as max, but this gives some slack in

* order to support existing BIOSs)

*/

status = AE_AML_OPERAND_VALUE;

} else {

if (how_long_us > 100) {

}

acpi_os_stall(how_long_us);

}

ACPI_MODULE_NAME("hwxfsleep")

/* Local prototypes */

static acpi_status

acpi_hw_set_firmware_waking_vector(struct acpi_table_facs *facs,

acpi_physical_address physical_address,

acpi_physical_address physical_address64);

/*******************************************************************************

*

* FUNCTION: acpi_hw_set_firmware_waking_vector

ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)

/*******************************************************************************

*

* FUNCTION: acpi_enter_sleep_state_s4bios

static union acpi_parse_object *acpi_ps_get_next_field(struct acpi_parse_state

*parser_state);

/*******************************************************************************

*

* FUNCTION: acpi_ps_get_next_package_length

/*******************************************************************************

*

* FUNCTION: acpi_ps_get_next_arg

*

* PARAMETERS: walk_state - Current state

while (parser_state->aml < parser_state->pkg_end) {

field = acpi_ps_get_next_field(parser_state);

if (!field) {

return_ACPI_STATUS(AE_NO_MEMORY);

}

acpi_ps_get_next_namepath(walk_state, parser_state,

arg,

ACPI_NOT_METHOD_CALL);

} else {

/* Single complex argument, nothing returned */

acpi_ps_get_next_namepath(walk_state, parser_state,

arg,

ACPI_POSSIBLE_METHOD_CALL);

if (arg->common.aml_opcode == AML_INT_METHODCALL_OP) {

/* Validate the Resource Type */

return (FALSE);

}

static void

acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table);

/*******************************************************************************

*

* FUNCTION: acpi_rs_dump_resource_list

prt_element, prt_element->length);

}

}

/*******************************************************************************

*

static acpi_physical_address

acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size);

/*******************************************************************************

*

* FUNCTION: acpi_tb_initialize_facs

return (AE_OK);

}

/*******************************************************************************

*

(void)

acpi_os_delete_semaphore

(acpi_gbl_global_lock_semaphore);

acpi_os_delete_mutex(object->mutex.os_mutex);

acpi_gbl_global_lock_mutex = NULL;

object, object->event.os_semaphore));

(void)acpi_os_delete_semaphore(object->event.os_semaphore);

break;

case ACPI_TYPE_METHOD:

/* Global Lock support */

acpi_gbl_global_lock_mutex = NULL;

acpi_gbl_global_lock_acquired = FALSE;

acpi_gbl_global_lock_handle = 0;

{"Windows 2019", NULL, 0, ACPI_OSI_WIN_10_19H1}, /* Windows 10 version 1903 - Added 08/2019 */

{"Windows 2020", NULL, 0, ACPI_OSI_WIN_10_20H1}, /* Windows 10 version 2004 - Added 08/2021 */

{"Windows 2021", NULL, 0, ACPI_OSI_WIN_11}, /* Windows 11 - Added 01/2022 */

/* Feature Group Strings */

*/

acpi_gbl_early_initialization = FALSE;

#if (!ACPI_REDUCED_HARDWARE)

/* Enable ACPI mode */

}

/*

* Initialize ACPI Event handling (Fixed and General Purpose)

*

* Note1: We must have the hardware and events initialized before we can

#include <linux/interrupt.h>

#include <linux/debugfs.h>

#include <acpi/apei.h>

#include "apei-internal.h"

#include <linux/delay.h>

#include <linux/mm.h>

#include <linux/platform_device.h>

#include "apei-internal.h"

*

* Author: Ben Cheatham <benjamin.cheatham@amd.com>

*/

#include <linux/seq_file.h>

#include <linux/pci.h>

#include "apei-internal.h"

seg = bridge->domain_nr;

bus = pbus->number;

return 0;

}

.read = erst_dbg_read,

.write = erst_dbg_write,

.unlocked_ioctl = erst_dbg_ioctl,

};

static struct miscdevice erst_dbg_dev = {

#include <linux/timer.h>

#include <linux/cper.h>

#include <linux/cleanup.h>

#include <linux/platform_device.h>

#include <linux/mutex.h>

#include <linux/ratelimit.h>

#include <acpi/apei.h>

#include <asm/fixmap.h>

#include <asm/tlbflush.h>

#include <ras/ras_event.h>

#include "apei-internal.h"

# SPDX-License-Identifier: GPL-2.0-only

obj-$(CONFIG_ACPI_AGDI) += agdi.o

obj-$(CONFIG_ACPI_APMT) += apmt.o

obj-$(CONFIG_ARM_AMBA) += amba.o

obj-y += dma.o init.o

obj-y += thermal_cpufreq.o

static void amba_register_dummy_clk(void)

{

amba_dummy_clk = clk_register_fixed_rate(NULL, "apb_pclk", NULL, 0, 0);

clk_register_clkdev(amba_dummy_clk, "apb_pclk", NULL);

return NULL;

/* Create a copy of SIDs array to associate with this rmr_data */

if (!sids_copy) {

kfree(rmr_data);

return NULL;

static int iort_iommu_xlate(struct device *dev, struct acpi_iort_node *node,

u32 streamid)

{

struct fwnode_handle *iort_fwnode;

return -ENODEV;

iort_fwnode = iort_get_fwnode(node);

return -ENODEV;

/*

*/

}

struct iort_pci_alias_info {

/* HiSilicon Hip09 Platform */

{"HISI ", "HIP09 ", 0, ACPI_SIG_IORT, greater_than_or_equal,

"Erratum #162001900", IORT_SMMU_V3_PMCG_HISI_HIP09},

{ }

};

#define pr_fmt(fmt) "ACPI: battery: " fmt

#include <linux/delay.h>

#include <linux/dmi.h>

#include <linux/jiffies.h>

#include <linux/suspend.h>

#include <linux/types.h>

#include <linux/acpi.h>

#include <linux/power_supply.h>

/* Battery power unit: 0 means mW, 1 means mA */

#define ACPI_BATTERY_POWER_UNIT_MA 1

#define MAX_STRING_LENGTH 64

MODULE_DESCRIPTION("ACPI Battery Driver");

MODULE_LICENSE("GPL");

static int battery_bix_broken_package;

static int battery_notification_delay_ms;

static int battery_ac_is_broken;

static int acpi_battery_is_charged(struct acpi_battery *battery)

{

if (battery->state != 0)

return 0;

val->intval = acpi_battery_handle_discharging(battery);

else if (battery->state & ACPI_BATTERY_STATE_CHARGING)

val->intval = POWER_SUPPLY_STATUS_CHARGING;

else if (acpi_battery_is_charged(battery))

val->intval = POWER_SUPPLY_STATUS_FULL;

else

return ret;

}

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

POWER_SUPPLY_PROP_SERIAL_NUMBER,

};

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

POWER_SUPPLY_PROP_SERIAL_NUMBER,

};

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

POWER_SUPPLY_PROP_SERIAL_NUMBER,

};

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

{

struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));

}

static ssize_t acpi_battery_alarm_store(struct device *dev,

return count;

}

.attr = {.name = "alarm", .mode = 0644},

.show = acpi_battery_alarm_show,

.store = acpi_battery_alarm_store,

};

/*

* The Battery Hooking API

*

static LIST_HEAD(battery_hook_list);

static DEFINE_MUTEX(hook_mutex);

{

struct acpi_battery *battery;

/*

* In order to remove a hook, we first need to

* de-register all the batteries that are registered.

*/

list_for_each_entry(battery, &acpi_battery_list, list) {

if (!hook->remove_battery(battery->bat, hook))

power_supply_changed(battery->bat);

}

pr_info("extension unregistered: %s\n", hook->name);

}

void battery_hook_unregister(struct acpi_battery_hook *hook)

{

}

EXPORT_SYMBOL_GPL(battery_hook_unregister);

struct acpi_battery *battery;

mutex_lock(&hook_mutex);

list_add(&hook->list, &battery_hook_list);

/*

* Now that the driver is registered, we need

* hooks.

*/

pr_err("extension failed to load: %s", hook->name);

goto end;

}

}

EXPORT_SYMBOL_GPL(battery_hook_register);

/*

* This function gets called right after the battery sysfs

* attributes have been added, so that the drivers that

*/

pr_err("error in extension, unloading: %s",

hook_node->name);

}

}

mutex_unlock(&hook_mutex);

* need to remove the hooks.

*/

list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {

}

mutex_destroy(&hook_mutex);

}

static int sysfs_add_battery(struct acpi_battery *battery)

{

bool full_cap_broken = false;

if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&

return result;

}

battery_hook_add_battery(battery);

}

static void sysfs_remove_battery(struct acpi_battery *battery)

return;

}

battery_hook_remove_battery(battery);

power_supply_unregister(battery->bat);

battery->bat = NULL;

mutex_unlock(&battery->sysfs_lock);

static int acpi_battery_add(struct acpi_device *device)

{

int result = 0;

if (!device)

return -EINVAL;

if (!battery)

return -ENOMEM;

battery->device = device;

device->driver_data = battery;

mutex_init(&battery->lock);

mutex_init(&battery->sysfs_lock);

static void acpi_battery_remove(struct acpi_device *device)

{

if (!device || !acpi_driver_data(device))

return;

.remove = acpi_battery_remove,

},

.drv.pm = &acpi_battery_pm,

};

static int __init acpi_battery_init(void)

{

return -ENODEV;

}

static void __exit acpi_battery_exit(void)

{

}

module_init(acpi_battery_init);

capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;

if (IS_ENABLED(CONFIG_ACPI_THERMAL))

capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_FAST_THERMAL_SAMPLING_SUPPORT;

capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;

capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;

ACPI Bus operations

-------------------------------------------------------------------------- */

{

struct acpi_device *acpi_dev = to_acpi_device(dev);

return acpi_dev->flags.match_driver

&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);

case ACPI_IRQ_MODEL_LPIC:

message = "LPIC";

break;

default:

pr_info("Unknown interrupt routing model\n");

return -ENODEV;

acpi_hest_init();

acpi_ghes_init();

acpi_arm_init();

acpi_scan_init();

acpi_ec_init();

acpi_debugfs_init();

},

.driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN,

},

{}

};

!strcmp(hid, ACPI_BUTTON_HID_POWERF)) {

button->type = ACPI_BUTTON_TYPE_POWER;

handler = acpi_button_notify;

sprintf(class, "%s/%s",

ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);

} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||

!strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {

button->type = ACPI_BUTTON_TYPE_SLEEP;

handler = acpi_button_notify;

sprintf(class, "%s/%s",

ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);

} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {

button->type = ACPI_BUTTON_TYPE_LID;

handler = acpi_lid_notify;

sprintf(class, "%s/%s",

ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);

input->open = acpi_lid_input_open;

#include <linux/topology.h>

#include <linux/dmi.h>

#include <linux/units.h>

#include <acpi/cppc_acpi.h>

(cpc)->cpc_entry.reg.space_id == \

ACPI_ADR_SPACE_PLATFORM_COMM)

/* Check if a CPC register is in SystemMemory */

#define CPC_IN_SYSTEM_MEMORY(cpc) ((cpc)->type == ACPI_TYPE_BUFFER && \

(cpc)->cpc_entry.reg.space_id == \

show_cppc_data(cppc_get_perf_caps, cppc_perf_caps, lowest_perf);

show_cppc_data(cppc_get_perf_caps, cppc_perf_caps, nominal_perf);

show_cppc_data(cppc_get_perf_caps, cppc_perf_caps, lowest_nonlinear_perf);

show_cppc_data(cppc_get_perf_caps, cppc_perf_caps, lowest_freq);

show_cppc_data(cppc_get_perf_caps, cppc_perf_caps, nominal_freq);

#define GET_BIT_WIDTH(reg) ((reg)->access_width ? (8 << ((reg)->access_width - 1)) : (reg)->bit_width)

/* Shift and apply the mask for CPC reads/writes */

GENMASK(((reg)->bit_width) - 1, 0))

static ssize_t show_feedback_ctrs(struct kobject *kobj,

struct kobj_attribute *attr, char *buf)

&highest_perf.attr,

&lowest_perf.attr,

&lowest_nonlinear_perf.attr,

&nominal_perf.attr,

&nominal_freq.attr,

&lowest_freq.attr,

* )

*/

/**

* acpi_cppc_processor_probe - Search for per CPU _CPC objects.

* @pr: Ptr to acpi_processor containing this CPU's logical ID.

/* Store CPU Logical ID */

cpc_ptr->cpu_id = pr->id;

/* Parse PSD data for this CPU */

ret = acpi_get_psd(cpc_ptr, handle);

goto out_free;

}

kfree(output.pointer);

return 0;

}

if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)

return 0;

}

{

int ret_val = 0;

int size;

void __iomem *vaddr = NULL;

int pcc_ss_id = per_cpu(cpu_pcc_subspace_idx, cpu);

struct cpc_reg *reg = &reg_res->cpc_entry.reg;

size = GET_BIT_WIDTH(reg);

return acpi_os_write_memory((acpi_physical_address)reg->address,

val, size);

switch (size) {

case 8:

break;

}

return ret_val;

}

/* after writing CPC, transfer the ownership of PCC to platform */

ret = send_pcc_cmd(pcc_ss_id, CMD_WRITE);

up_write(&pcc_ss_data->pcc_lock);

} else {

ret = -ENOTSUPP;

}

return ret;

dm->length >= DMI_ENTRY_PROCESSOR_MIN_LENGTH) {

u16 val = (u16)get_unaligned((const u16 *)

(dmi_data + DMI_PROCESSOR_MAX_SPEED));

}

}

u64 mul, div;

if (caps->lowest_freq && caps->nominal_freq) {

mul *= KHZ_PER_MHZ;

offset = caps->nominal_freq * KHZ_PER_MHZ -

div64_u64(caps->nominal_perf * mul, div);

} else {

{

s64 retval, offset = 0;

static u64 max_khz;

if (caps->lowest_freq && caps->nominal_freq) {

/*

* We don't need to convert to kHz for computing offset and can

* directly use nominal_freq and lowest_freq as the div64_u64

char *buf)

{

struct acpi_device *acpi_dev = to_acpi_device(dev);

int result;

/*

* The _STR object contains a Unicode identifier for a device.

* We need to convert to utf-8 so it can be displayed.

*/

result = utf16s_to_utf8s(

UTF16_LITTLE_ENDIAN, buf,

PAGE_SIZE - 1);

buf[result++] = '\n';

return result;

}

static DEVICE_ATTR_RO(description);

}

static DEVICE_ATTR_RO(status);

/*

* Devices gotten from FADT don't have a "path" attribute

*/

/*

* If device has _EJ0, 'eject' file is created that is used to trigger

* hot-removal function from userland.

*/

}

/**

void acpi_device_remove_files(struct acpi_device *dev)

{

acpi_hide_nondev_subnodes(&dev->data);

}

unsigned long tmp;

int ret = 0;

/* start transaction */

spin_lock_irqsave(&ec->lock, tmp);

/* Enable GPE for command processing (IBF=0/OBF=1) */

if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))

return -EINVAL;

mutex_lock(&ec->mutex);

if (ec->global_lock) {

.wdata = NULL, .rdata = &d,

.wlen = 0, .rlen = 1};

}

static int acpi_ec_burst_disable(struct acpi_ec *ec)

.wlen = 0, .rlen = 0};

return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?

}

static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)

return result;

}

static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)

{

u8 wdata[2] = { address, data };

return acpi_ec_transaction(ec, &t);

}

int ec_read(u8 addr, u8 *val)

{

int err;

struct acpi_ec *ec = handler_context;

int result = 0, i, bytes = bits / 8;

u8 *value = (u8 *)value64;

if ((address > 0xFF) || !value || !handler_context)

return AE_BAD_PARAMETER;

if (function != ACPI_READ && function != ACPI_WRITE)

return AE_BAD_PARAMETER;

if (ec->busy_polling || bits > 8)

acpi_ec_burst_enable(ec);

for (i = 0; i < bytes; ++i, ++address, ++value) {

result = (function == ACPI_READ) ?

if (result < 0)

break;

}

if (ec->busy_polling || bits > 8)

acpi_ec_burst_disable(ec);

switch (result) {

case -EINVAL:

return AE_BAD_PARAMETER;

static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device,

bool call_reg)

{

acpi_status status;

acpi_ec_start(ec, false);

if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {

acpi_ec_enter_noirq(ec);

status = acpi_install_address_space_handler_no_reg(scope_handle,

ACPI_ADR_SPACE_EC,

}

if (call_reg && !test_bit(EC_FLAGS_EC_REG_CALLED, &ec->flags)) {

set_bit(EC_FLAGS_EC_REG_CALLED, &ec->flags);

}

}

}

static acpi_status

ec_parse_io_ports(struct acpi_resource *resource, void *context)

{

#ifndef _ACPI_FAN_H_

#define _ACPI_FAN_H_

#define ACPI_FAN_DEVICE_IDS \

{"INT3404", }, /* Fan */ \

{"INTC1044", }, /* Fan for Tiger Lake generation */ \

int acpi_fan_get_fst(struct acpi_device *device, struct acpi_fan_fst *fst);

int acpi_fan_create_attributes(struct acpi_device *device);

void acpi_fan_delete_attributes(struct acpi_device *device);

#endif

if (result)

return result;

result = acpi_fan_create_attributes(device);

if (result)

return result;

int type, void (*release)(struct device *));

int acpi_tie_acpi_dev(struct acpi_device *adev);

int acpi_device_add(struct acpi_device *device);

void acpi_device_remove_files(struct acpi_device *dev);

void acpi_device_add_finalize(struct acpi_device *device);

void acpi_free_pnp_ids(struct acpi_device_pnp *pnp);

bool acpi_device_is_enabled(const struct acpi_device *adev);

acpi_handle handle, acpi_ec_query_func func,

void *data);

void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit);

#ifdef CONFIG_PM_SLEEP

void acpi_ec_flush_work(void);

module_init(nfit_init);

module_exit(nfit_exit);

MODULE_LICENSE("GPL v2");

MODULE_AUTHOR("Intel Corporation");

# SPDX-License-Identifier: GPL-2.0

config ACPI_NUMA

config ACPI_HMAT

bool "ACPI Heterogeneous Memory Attribute Table Support"

if (target && target->processor_pxm == init_pxm) {

hmat_update_target_access(target, type, value,

ACCESS_COORDINATE_LOCAL);

if (node_state(pxm_to_node(init_pxm), N_CPU))

hmat_update_target_access(target, type, value,

ACCESS_COORDINATE_CPU);

return NOTIFY_OK;

}

{

int rc;

int nid, pxm;

struct memory_target *target;

struct access_coordinate *attrs;

pxm = node_to_pxm(nid);

target = find_mem_target(pxm);

if (!target)

continue;

rc = mt_set_default_dram_perf(nid, attrs, "ACPI HMAT");

if (rc)

return rc;

hmat_update_target_attrs(target, p_nodes, ACCESS_COORDINATE_CPU);

mutex_unlock(&target_lock);

if (mt_perf_to_adistance(perf, adist))

return NOTIFY_OK;

#include <linux/numa.h>

#include <linux/nodemask.h>

#include <linux/topology.h>

static nodemask_t nodes_found_map = NODE_MASK_NONE;

}

}

break;

default:

pr_warn("Found unsupported SRAT entry (type = 0x%x)\n",

header->type);

}

#endif /* defined(CONFIG_X86) || defined (CONFIG_ARM64) */

static int __init acpi_parse_srat(struct acpi_table_header *table)

{

struct acpi_table_srat *srat = (struct acpi_table_srat *)table;

/* SRAT: System Resource Affinity Table */

if (!acpi_table_parse(ACPI_SIG_SRAT, acpi_parse_srat)) {

memset(srat_proc, 0, sizeof(srat_proc));

srat_proc[0].id = ACPI_SRAT_TYPE_CPU_AFFINITY;

srat_proc[2].handler = acpi_parse_gicc_affinity;

srat_proc[3].id = ACPI_SRAT_TYPE_GENERIC_AFFINITY;

srat_proc[3].handler = acpi_parse_gi_affinity;

acpi_table_parse_entries_array(ACPI_SIG_SRAT,

sizeof(struct acpi_table_srat),

}

#endif /* CONFIG_X86_IO_APIC */

{

struct acpi_prt_entry *entry = NULL;

struct pci_dev *bridge;

if (result)

kfree(link);

return result < 0 ? result : 1;

}

LOONGSON_ECAM_MCFG("LOONGSON", 0),

LOONGSON_ECAM_MCFG("\0", 1),

LOONGSON_ECAM_MCFG("LOONGSON", 1),

#endif /* LOONGARCH */

};

}

EXPORT_SYMBOL_GPL(acpi_pci_find_root);

/**

* acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev

* @handle: the handle in question

int node = acpi_get_node(device->handle);

struct pci_bus *bus;

struct pci_host_bridge *host_bridge;

info->root = root;

info->bridge = device;

if (!(root->osc_ext_control_set & OSC_CXL_ERROR_REPORTING_CONTROL))

host_bridge->native_cxl_error = 0;

acpi_dev_power_up_children_with_adr(device);

pci_scan_child_bus(bus);

EXPORT_SYMBOL_GPL(platform_profile_remove);

MODULE_AUTHOR("Mark Pearson <markpearson@lenovo.com>");

MODULE_LICENSE("GPL");

static struct intel_pmic_opregion *intel_pmic_opregion;

int count, int *reg, int *bit)

{

int i;

u32 reg_address, u32 value, u32 mask);

int (*lpat_raw_to_temp)(struct acpi_lpat_conversion_table *lpat_table,

int raw);

int power_table_count;

int thermal_table_count;

/* For generic exec_mipi_pmic_seq_element handling */

int pmic_i2c_address;

#define VSWITCH1_OUTPUT BIT(4)

#define VUSBPHY_CHARGE BIT(1)

{

.address = 0x0,

.reg = 0x63,

} /* MOFF -> MODEMCTRL Bit 0 */

};

{

.address = 0x00,

.reg = 0x4F39

#define PMIC_A0LOCK_REG 0xc5

/* {

.address = 0x00,

.reg = ??,

}, /* V105 -> V1P05S, L2 SRAM */

};

{

.address = 0x00,

.reg = 0x75

*/

#include <linux/acpi.h>

#include <linux/init.h>

#include <linux/mfd/intel_soc_pmic.h>

#include <linux/platform_device.h>

#include "intel_pmic.h"

/* registers stored in 16bit BE (high:low, total 10bit) */

#define CHTDC_TI_VBAT 0x54

#define CHTDC_TI_DIETEMP 0x56

#define CHTDC_TI_BPTHERM 0x58

#define CHTDC_TI_GPADC 0x5a

{ .address = 0x00, .reg = 0x41 }, /* LDO1 */

{ .address = 0x04, .reg = 0x42 }, /* LDO2 */

{ .address = 0x08, .reg = 0x43 }, /* LDO3 */

{ .address = 0x30, .reg = 0x4e }, /* LD14 */

};

{

.address = 0x00,

.reg = CHTDC_TI_GPADC

if (regmap_read(regmap, reg, &data))

return -EIO;

return 0;

}

static int chtdc_ti_pmic_get_raw_temp(struct regmap *regmap, int reg)

{

return -EIO;

}

static const struct intel_pmic_opregion_data chtdc_ti_pmic_opregion_data = {

* "regulator: whiskey_cove: implements Whiskey Cove pmic VRF support"

* https://github.com/intel-aero/meta-intel-aero/blob/master/recipes-kernel/linux/linux-yocto/0019-regulator-whiskey_cove-implements-WhiskeyCove-pmic-V.patch

*/

{

.address = 0x0,

.reg = CHT_WC_V1P8A_CTRL,

u32 reg_address,

u32 value, u32 mask)

{

u32 address;

if (i2c_client_address > 0xff || reg_address > 0xff) {

return -ERANGE;

}

#define AXP288_ADC_TS_CURRENT_ON_ONDEMAND (2 << 0)

#define AXP288_ADC_TS_CURRENT_ON (3 << 0)

{

.address = 0x00,

.reg = 0x13,

};

/* TMP0 - TMP5 are the same, all from GPADC */

{

.address = 0x00,

.reg = XPOWER_GPADC_LOW

if (ret)

return ret;

if (ret == 0)

ret = (buf[0] << 4) + ((buf[1] >> 4) & 0x0f);

u16 i2c_address, u32 reg_address,

u32 value, u32 mask)

{

int ret;

if (i2c_address != 0x34) {

return -ENXIO;

}

struct tps68470_pmic_opregion *opregion;

acpi_status status;

if (!handle) {

dev_warn(dev, "acpi handle is NULL\n");

static LIST_HEAD(prm_module_list);

struct prm_handler_info {

efi_status_t (__efiapi *handler_addr)(u64, void *);

u64 static_data_buffer_addr;

u64 acpi_param_buffer_addr;

struct prm_handler_info handlers[] __counted_by(handler_count);

};

{

efi_memory_desc_t *md;

u64 pa_offset = pa & ~PAGE_MASK;

u64 page = pa & PAGE_MASK;

for_each_efi_memory_desc(md) {

return pa_offset + md->virt_addr + page - md->phys_addr;

}

return 0;

}

th = &tm->handlers[cur_handler];

guid_copy(&th->guid, (guid_t *)handler_info->handler_guid);

} while (++cur_handler < tm->handler_count && (handler_info = get_next_handler(handler_info)));

return 0;

#define UPDATE_LOCK_ALREADY_HELD 4

#define UPDATE_UNLOCK_WITHOUT_LOCK 5

/*

* This is the PlatformRtMechanism opregion space handler.

* @function: indicates the read/write. In fact as the PlatformRtMechanism

if (!handler || !module)

goto invalid_guid;

ACPI_COPY_NAMESEG(context.signature, "PRMC");

context.revision = 0x0;

context.reserved = 0x0;

struct acpi_madt_generic_interrupt *gicc =

container_of(entry, struct acpi_madt_generic_interrupt, header);

return -ENODEV;

/* device_declaration means Device object in DSDT, in the

return rv;

}

static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)

{

struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

MODULE_DESCRIPTION("ACPI Processor Driver");

MODULE_LICENSE("GPL");

static int acpi_processor_stop(struct device *dev);

static const struct acpi_device_id processor_device_ids[] = {

.name = "processor",

.bus = &cpu_subsys,

.acpi_match_table = processor_device_ids,

.remove = acpi_processor_stop,

};

* CPU got physically hotplugged and onlined for the first time:

* Initialize missing things.

*/

int ret;

ret = __acpi_processor_start(device);

WARN(ret, "Failed to start CPU: %d\n", pr->id);

} else {

if (!pr)

return -ENODEV;

result = acpi_cppc_processor_probe(pr);

if (result && !IS_ENABLED(CONFIG_ACPI_CPU_FREQ_PSS))

dev_dbg(&device->dev, "CPPC data invalid or not present\n");

status = acpi_install_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,

acpi_processor_notify, device);

err_power_exit:

acpi_processor_power_exit(pr);

return result;

}

static int acpi_processor_stop(struct device *dev)

{

struct acpi_device *device = ACPI_COMPANION(dev);

.notifier_call = acpi_processor_notifier,

};

/*

* We keep the driver loaded even when ACPI is not running.

* This is needed for the powernow-k8 driver, that works even without

if (result < 0)

return result;

if (result < 0)

goto err;

hp_online = result;

NULL, acpi_soft_cpu_dead);

acpi_processor_throttling_init();

return 0;

err:

driver_unregister(&acpi_processor_driver);

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

DMI_MATCH(DMI_BOARD_NAME, "E1504GA"),

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),

},

},

{

.matches = {

},

},

{

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),

},

},

{ }

*/

static const struct dmi_system_id irq1_edge_low_force_override[] = {

{

/* XMG APEX 17 (M23) */

.matches = {

DMI_MATCH(DMI_BOARD_NAME, "GMxBGxx"),

},

},

{

/* TongFang GMxXGxx sold as Eluktronics Inc. RP-15 */

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "Eluktronics Inc."),

# SPDX-License-Identifier: GPL-2.0-only

obj-$(CONFIG_ACPI_PROCESSOR_IDLE) += cpuidle.o

obj-$(CONFIG_ACPI_CPPC_LIB) += cppc.o

u16 spec;

u8 id;

u8 present:1;

};

#define to_acpi_battery(x) power_supply_get_drvdata(x)

return 0;

}

POWER_SUPPLY_PROP_ONLINE,

};

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

POWER_SUPPLY_PROP_MANUFACTURER,

};

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

return count;

}

.attr = {.name = "alarm", .mode = 0644},

.show = acpi_battery_alarm_show,

.store = acpi_battery_alarm_store,

};

/* --------------------------------------------------------------------------

Driver Interface

-------------------------------------------------------------------------- */

static int acpi_battery_add(struct acpi_sbs *sbs, int id)

{

struct acpi_battery *battery = &sbs->battery[id];

int result;

battery->id = id;

goto end;

}

end:

pr_info("%s [%s]: Battery Slot [%s] (battery %s)\n",

ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),

{

struct acpi_battery *battery = &sbs->battery[id];

power_supply_unregister(battery->bat);

}

static int acpi_charger_add(struct acpi_sbs *sbs)

return 0;

}

{

struct acpi_scan_handler *handler = adev->handler;

acpi_bus_get_status(adev);

/*

* Skip devices that are still there and take the enabled

if (handler) {

if (handler->detach)

handler->detach(adev);

} else {

device_release_driver(&adev->dev);

}

*/

acpi_device_set_power(adev, ACPI_STATE_D3_COLD);

adev->flags.initialized = false;

acpi_device_clear_enumerated(adev);

return 0;

static void acpi_scan_check_subtree(struct acpi_device *adev)

{

}

static int acpi_scan_hot_remove(struct acpi_device *device)

acpi_handle handle = device->handle;

unsigned long long sta;

acpi_status status;

if (device->handler && device->handler->hotplug.demand_offline) {

if (!acpi_scan_is_offline(device, true))

acpi_handle_debug(handle, "Ejecting\n");

acpi_evaluate_lck(handle, 0);

/*

} else if (sta & ACPI_STA_DEVICE_ENABLED) {

acpi_handle_warn(handle,

"Eject incomplete - status 0x%llx\n", sta);

}

return 0;

goto err;

}

return 0;

"INTC1095", /* IVSC (ADL) driver must be loaded to allow i2c access to camera sensors */

"INTC100A", /* IVSC (RPL) driver must be loaded to allow i2c access to camera sensors */

"INTC10CF", /* IVSC (MTL) driver must be loaded to allow i2c access to camera sensors */

NULL

};

#ifdef CONFIG_IOMMU_API

int acpi_iommu_fwspec_init(struct device *dev, u32 id,

{

int ret;

if (ret)

return ret;

return iommu_fwspec_add_ids(dev, &id, 1);

}

static int acpi_iommu_configure_id(struct device *dev, const u32 *id_in)

{

int err;

/* Serialise to make dev->iommu stable under our potential fwspec */

mutex_lock(&iommu_probe_device_lock);

mutex_unlock(&iommu_probe_device_lock);

return 0;

}

if (!err && dev->bus)

err = iommu_probe_device(dev);

}

#else /* !CONFIG_IOMMU_API */

int acpi_iommu_fwspec_init(struct device *dev, u32 id,

{

return -ENODEV;

}

ret = acpi_iommu_configure_id(dev, input_id);

if (ret == -EPROBE_DEFER)

return -EPROBE_DEFER;

arch_setup_dma_ops(dev, attr == DEV_DMA_COHERENT);

device->dev.parent = parent ? &parent->dev : NULL;

device->dev.release = release;

device->dev.bus = &acpi_bus_type;

fwnode_init(&device->fwnode, &acpi_device_fwnode_ops);

acpi_set_device_status(device, ACPI_STA_DEFAULT);

acpi_device_get_busid(device);

mutex_unlock(&acpi_scan_lock);

}

static void acpi_scan_init_hotplug(struct acpi_device *adev)

{

struct acpi_hardware_id *hwid;

}

}

static u32 acpi_scan_check_dep(acpi_handle handle)

{

struct acpi_handle_list dep_devices;

/*

* Check for _HID here to avoid deferring the enumeration of:

* Still, checking for _HID catches more then just these cases ...

*/

if (!acpi_has_method(handle, "_DEP") || !acpi_has_method(handle, "_HID"))

if (!acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices)) {

acpi_handle_debug(handle, "Failed to evaluate _DEP.\n");

}

return count;

}

if (device->handler)

goto ok;

if (!device->flags.initialized) {

device->flags.power_manageable =

device->power.states[ACPI_STATE_D0].flags.valid;

*/

void acpi_bus_trim(struct acpi_device *adev)

{

}

EXPORT_SYMBOL_GPL(acpi_bus_trim);

return 0;

}

int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)

{

int count = 0;

return 0;

mutex_lock(&acpi_probe_mutex);

for (ape = ap_head; nr; ape++, nr--) {

if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT, ape->id)) {

acpi_probe_count = 0;

},

},

/*

* https://bugzilla.kernel.org/show_bug.cgi?id=189431

* Lenovo G50-45 is a platform later than 2012, but needs nvs memory

* saving during S3.

}

break;

case ACPI_MADT_TYPE_CORE_PIC:

{

struct acpi_madt_core_pic *p = (struct acpi_madt_core_pic *)header;

thermal_zone_device_critical(thermal);

}

{

struct acpi_thermal_trip *acpi_trip = trip->priv;

struct acpi_device *cdev_adev = cdev->devdata;

int i;

/* Skip critical and hot trips. */

if (!acpi_trip)

for (i = 0; i < acpi_trip->devices.count; i++) {

acpi_handle handle = acpi_trip->devices.handles[i];

}

static const struct thermal_zone_device_ops acpi_thermal_zone_ops = {

.get_temp = thermal_get_temp,

.get_trend = thermal_get_trend,

.hot = acpi_thermal_zone_device_hot,

EXPORT_SYMBOL(acpi_evaluate_integer);

{

acpi_status status;

if (ACPI_FAILURE(status))

return -ENODATA;

*addr = (u32)adr;

return 0;

}

if (ret != AE_NOT_FOUND)

acpi_handle_warn(handle,

return NULL;

}

acpi_backlight_cmdline = acpi_backlight_nvidia_wmi_ec;

if (!strcmp("apple_gmux", acpi_video_backlight_string))

acpi_backlight_cmdline = acpi_backlight_apple_gmux;

if (!strcmp("none", acpi_video_backlight_string))

acpi_backlight_cmdline = acpi_backlight_none;

}

DMI_MATCH(DMI_PRODUCT_NAME, "PCG-FRV35"),

},

},

/*

* Toshiba models with Transflective display, these need to use

},

},

{

/* https://bugzilla.redhat.com/show_bug.cgi?id=1217249 */

.callback = video_detect_force_native,

/* Apple MacBook Pro 12,1 */

},

{

.callback = video_detect_force_native,

/* Dell Inspiron N4010 */

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),

},

/*

* Models which have nvidia-ec-wmi support, but should not use it.

* Note this indicates a likely firmware bug on these models and should

* be revisited if/when Linux gets support for dynamic mux mode.

/* Lenovo Yoga Tab 3 Pro YT3-X90F */

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),

DMI_MATCH(DMI_PRODUCT_VERSION, "Blade3-10A-001"),

},

},

static DEFINE_MUTEX(init_mutex);

static bool nvidia_wmi_ec_present;

static bool apple_gmux_present;

static bool native_available;

static bool init_done;

static long video_caps;

&video_caps, NULL);

nvidia_wmi_ec_present = nvidia_wmi_ec_supported();

apple_gmux_present = apple_gmux_detect(NULL, NULL);

init_done = true;

}

if (native)

if (apple_gmux_present)

return acpi_backlight_apple_gmux;

/* Use ACPI video if available, except when native should be preferred. */

if ((video_caps & ACPI_VIDEO_BACKLIGHT) &&

!(native_available && prefer_native_over_acpi_video()))

static int viot_dev_iommu_init(struct device *dev, struct viot_iommu *viommu,

u32 epid)

{

return -ENODEV;

/* We're not translating ourself */

if (device_match_fwnode(dev, viommu->fwnode))

return -EINVAL;

}

static int viot_pci_dev_iommu_init(struct pci_dev *pdev, u16 dev_id, void *data)

};

static const struct x86_cpu_id lpss_cpu_ids[] = {

{}

};

unsigned long long status;

};

{ { hid, }, {} }, \

{ { .matches = dmi }, {} }, \

uid, \

path, \

status, \

}

static const struct override_status_id override_status_ids[] = {

/*

* Bay / Cherry Trail PWM directly poked by GPU driver in win10,

* but Linux uses a separate PWM driver, harmless if not used.

*/

/* The Xiaomi Mi Pad 2 uses PWM2 for touchkeys backlight control */

DMI_MATCH(DMI_SYS_VENDOR, "Xiaomi Inc"),

DMI_MATCH(DMI_PRODUCT_NAME, "Mipad2"),

}),

* The INT0002 device is necessary to clear wakeup interrupt sources

* on Cherry Trail devices, without it we get nobody cared IRQ msgs.

*/

/*

* On the Dell Venue 11 Pro 7130 and 7139, the DSDT hides

* the touchscreen ACPI device until a certain time

* after _SB.PCI0.GFX0.LCD.LCD1._ON gets called has passed

* *and* _STA has been called at least 3 times since.

*/

DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),

DMI_MATCH(DMI_PRODUCT_NAME, "Venue 11 Pro 7130"),

}),

DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),

DMI_MATCH(DMI_PRODUCT_NAME, "Venue 11 Pro 7139"),

}),

* The Dell XPS 15 9550 has a SMO8110 accelerometer /

* HDD freefall sensor which is wrongly marked as not present.

*/

DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),

DMI_MATCH(DMI_PRODUCT_NAME, "XPS 15 9550"),

}),

* was copy-pasted from the GPD win, so it has a disabled KIOX000A

* node which we should not enable, thus we also check the BIOS date.

*/

DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),

DMI_MATCH(DMI_BOARD_NAME, "Default string"),

DMI_MATCH(DMI_PRODUCT_NAME, "Default string"),

DMI_MATCH(DMI_BIOS_DATE, "02/21/2017")

}),

DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),

DMI_MATCH(DMI_BOARD_NAME, "Default string"),

DMI_MATCH(DMI_PRODUCT_NAME, "Default string"),

DMI_MATCH(DMI_BIOS_DATE, "03/20/2017")

}),

DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),

DMI_MATCH(DMI_BOARD_NAME, "Default string"),

DMI_MATCH(DMI_PRODUCT_NAME, "Default string"),

* method sets a GPIO causing the PCI wifi card to turn off.

* See above remark about uniqueness of the DMI match.

*/

DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),

DMI_EXACT_MATCH(DMI_BOARD_NAME, "Default string"),

DMI_EXACT_MATCH(DMI_BOARD_SERIAL, "Default string"),

* as both ACCL0001 and MAGN0001. As we can only ever register an

* i2c client for one of them, ignore MAGN0001.

*/

DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),

DMI_MATCH(DMI_PRODUCT_FAMILY, "YOGATablet2"),

}),

/* Lenovo Yoga Tab 3 Pro X90F */

.matches = {

DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),

DMI_MATCH(DMI_PRODUCT_VERSION, "Blade3-10A-001"),

},

.driver_data = (void *)(ACPI_QUIRK_SKIP_I2C_CLIENTS |