/* SPDX-License-Identifier: GPL-2.0 */ /* * Core ACPI (Advanced Configuration and Power Interface) support * * Copyright 2019 Google LLC * * Modified from coreboot file acpigen.h */ #ifndef __ACPI_ACPIGEN_H #define __ACPI_ACPIGEN_H #include #include struct acpi_cstate; struct acpi_ctx; struct acpi_gen_regaddr; struct acpi_gpio; /* Top 4 bits of the value used to indicate a three-byte length value */ #define ACPI_PKG_LEN_3_BYTES 0x80 #define ACPI_METHOD_NARGS_MASK 0x7 #define ACPI_METHOD_SERIALIZED_MASK BIT(3) #define ACPI_END_TAG 0x79 /* ACPI Op/Prefix codes */ enum { ZERO_OP = 0x00, ONE_OP = 0x01, NAME_OP = 0x08, BYTE_PREFIX = 0x0a, WORD_PREFIX = 0x0b, DWORD_PREFIX = 0x0c, STRING_PREFIX = 0x0d, QWORD_PREFIX = 0x0e, SCOPE_OP = 0x10, BUFFER_OP = 0x11, PACKAGE_OP = 0x12, METHOD_OP = 0x14, SLEEP_OP = 0x22, DUAL_NAME_PREFIX = 0x2e, MULTI_NAME_PREFIX = 0x2f, DEBUG_OP = 0x31, EXT_OP_PREFIX = 0x5b, ROOT_PREFIX = 0x5c, LOCAL0_OP = 0x60, LOCAL1_OP = 0x61, LOCAL2_OP = 0x62, LOCAL3_OP = 0x63, LOCAL4_OP = 0x64, LOCAL5_OP = 0x65, LOCAL6_OP = 0x66, LOCAL7_OP = 0x67, ARG0_OP = 0x68, ARG1_OP = 0x69, ARG2_OP = 0x6a, ARG3_OP = 0x6b, ARG4_OP = 0x6c, ARG5_OP = 0x6d, ARG6_OP = 0x6e, STORE_OP = 0x70, AND_OP = 0x7b, OR_OP = 0x7d, NOT_OP = 0x80, DEVICE_OP = 0x82, PROCESSOR_OP = 0x83, POWER_RES_OP = 0x84, NOTIFY_OP = 0x86, LEQUAL_OP = 0x93, TO_BUFFER_OP = 0x96, TO_INTEGER_OP = 0x99, IF_OP = 0xa0, ELSE_OP = 0xa1, RETURN_OP = 0xa4, }; /** * enum psd_coord - Coordination types for P-states * * The type of coordination that exists (hardware) or is required (software) as * a result of the underlying hardware dependency */ enum psd_coord { SW_ALL = 0xfc, SW_ANY = 0xfd, HW_ALL = 0xfe }; /** * enum csd_coord - Coordination types for C-states * * The type of coordination that exists (hardware) or is required (software) as * a result of the underlying hardware dependency */ enum csd_coord { CSD_HW_ALL = 0xfe, }; /** * struct acpi_cstate - Information about a C-State * * @ctype: C State type (1=C1, 2=C2, 3=C3) * @latency: Worst-case latency to enter and exit the C State (in uS) * @power: Average power consumption of the processor when in this C-State (mW) * @resource: Register to read to place the processor in this state */ struct acpi_cstate { uint ctype; uint latency; uint power; struct acpi_gen_regaddr resource; }; /** * struct acpi_tstate - Information about a Throttling Supported State * * See ACPI v6.3 section 8.4.5.2: _TSS (Throttling Supported States) * * @percent: Percent of the core CPU operating frequency that will be * available when this throttling state is invoked * @power: Throttling state’s maximum power dissipation (mw) * @latency: Worst-case latency (uS) that the CPU is unavailable during a * transition from any throttling state to this throttling state * @control: Value to be written to the Processor Control Register * (THROTTLE_CTRL) to initiate a transition to this throttling state * @status: Value in THROTTLE_STATUS when in this state */ struct acpi_tstate { uint percent; uint power; uint latency; uint control; uint status; }; /** * acpigen_get_current() - Get the current ACPI code output pointer * * @ctx: ACPI context pointer * @return output pointer */ u8 *acpigen_get_current(struct acpi_ctx *ctx); /** * acpigen_emit_byte() - Emit a byte to the ACPI code * * @ctx: ACPI context pointer * @data: Value to output */ void acpigen_emit_byte(struct acpi_ctx *ctx, uint data); /** * acpigen_emit_word() - Emit a 16-bit word to the ACPI code * * @ctx: ACPI context pointer * @data: Value to output */ void acpigen_emit_word(struct acpi_ctx *ctx, uint data); /** * acpigen_emit_dword() - Emit a 32-bit 'double word' to the ACPI code * * @ctx: ACPI context pointer * @data: Value to output */ void acpigen_emit_dword(struct acpi_ctx *ctx, uint data); /** * acpigen_emit_stream() - Emit a stream of bytes * * @ctx: ACPI context pointer * @data: Data to output * @size: Size of data in bytes */ void acpigen_emit_stream(struct acpi_ctx *ctx, const char *data, int size); /** * acpigen_emit_string() - Emit a string * * Emit a string with a null terminator * * @ctx: ACPI context pointer * @str: String to output, or NULL for an empty string */ void acpigen_emit_string(struct acpi_ctx *ctx, const char *str); /** * acpigen_write_len_f() - Write a 'forward' length placeholder * * This adds space for a length value in the ACPI stream and pushes the current * position (before the length) on the stack. After calling this you can write * some data and then call acpigen_pop_len() to update the length value. * * Usage: * * acpigen_write_len_f() ------\ * acpigen_write...() | * acpigen_write...() | * acpigen_write_len_f() --\ | * acpigen_write...() | | * acpigen_write...() | | * acpigen_pop_len() ------/ | * acpigen_write...() | * acpigen_pop_len() ----------/ * * See ACPI 6.3 section 20.2.4 Package Length Encoding * * This implementation always uses a 3-byte packet length for simplicity. It * could be adjusted to support other lengths. * * @ctx: ACPI context pointer */ void acpigen_write_len_f(struct acpi_ctx *ctx); /** * acpigen_pop_len() - Update the previously stacked length placeholder * * Call this after the data for the block has been written. It updates the * top length value in the stack and pops it off. * * @ctx: ACPI context pointer */ void acpigen_pop_len(struct acpi_ctx *ctx); /** * acpigen_write_package() - Start writing a package * * A package collects together a number of elements in the ACPI code. To write * a package use: * * acpigen_write_package(ctx, 3); * ...write things * acpigen_pop_len() * * If you don't know the number of elements in advance, acpigen_write_package() * returns a pointer to the value so you can update it later: * * char *num_elements = acpigen_write_package(ctx, 0); * ...write things * *num_elements += 1; * ...write things * *num_elements += 1; * acpigen_pop_len() * * @ctx: ACPI context pointer * @nr_el: Number of elements (0 if not known) * @returns pointer to the number of elements, which can be updated by the * caller if needed */ char *acpigen_write_package(struct acpi_ctx *ctx, int nr_el); /** * acpigen_write_byte() - Write a byte * * @ctx: ACPI context pointer * @data: Value to write */ void acpigen_write_byte(struct acpi_ctx *ctx, unsigned int data); /** * acpigen_write_word() - Write a word * * @ctx: ACPI context pointer * @data: Value to write */ void acpigen_write_word(struct acpi_ctx *ctx, unsigned int data); /** * acpigen_write_dword() - Write a dword * * @ctx: ACPI context pointer * @data: Value to write */ void acpigen_write_dword(struct acpi_ctx *ctx, unsigned int data); /** * acpigen_write_qword() - Write a qword * * @ctx: ACPI context pointer * @data: Value to write */ void acpigen_write_qword(struct acpi_ctx *ctx, u64 data); /** * acpigen_write_zero() - Write zero * * @ctx: ACPI context pointer */ void acpigen_write_zero(struct acpi_ctx *ctx); /** * acpigen_write_one() - Write one * * @ctx: ACPI context pointer */ void acpigen_write_one(struct acpi_ctx *ctx); /** * acpigen_write_integer() - Write an integer * * This writes an operation (BYTE_OP, WORD_OP, DWORD_OP, QWORD_OP depending on * the integer size) and an integer value. Note that WORD means 16 bits in ACPI. * * @ctx: ACPI context pointer * @data: Integer to write */ void acpigen_write_integer(struct acpi_ctx *ctx, u64 data); /** * acpigen_write_name_zero() - Write a named zero value * * @ctx: ACPI context pointer * @name: Name of the value */ void acpigen_write_name_zero(struct acpi_ctx *ctx, const char *name); /** * acpigen_write_name_one() - Write a named one value * * @ctx: ACPI context pointer * @name: Name of the value */ void acpigen_write_name_one(struct acpi_ctx *ctx, const char *name); /** * acpigen_write_name_byte() - Write a named byte value * * @ctx: ACPI context pointer * @name: Name of the value * @val: Value to write */ void acpigen_write_name_byte(struct acpi_ctx *ctx, const char *name, uint val); /** * acpigen_write_name_word() - Write a named word value * * @ctx: ACPI context pointer * @name: Name of the value * @val: Value to write */ void acpigen_write_name_word(struct acpi_ctx *ctx, const char *name, uint val); /** * acpigen_write_name_dword() - Write a named dword value * * @ctx: ACPI context pointer * @name: Name of the value * @val: Value to write */ void acpigen_write_name_dword(struct acpi_ctx *ctx, const char *name, uint val); /** * acpigen_write_name_qword() - Write a named qword value * * @ctx: ACPI context pointer * @name: Name of the value * @val: Value to write */ void acpigen_write_name_qword(struct acpi_ctx *ctx, const char *name, u64 val); /** * acpigen_write_name_integer() - Write a named integer value * * @ctx: ACPI context pointer * @name: Name of the value * @val: Value to write */ void acpigen_write_name_integer(struct acpi_ctx *ctx, const char *name, u64 val); /** * acpigen_write_name_string() - Write a named string value * * @ctx: ACPI context pointer * @name: Name of the value * @string: String to write */ void acpigen_write_name_string(struct acpi_ctx *ctx, const char *name, const char *string); /** * acpigen_write_string() - Write a string * * This writes a STRING_PREFIX followed by a null-terminated string * * @ctx: ACPI context pointer * @str: String to write */ void acpigen_write_string(struct acpi_ctx *ctx, const char *str); /** * acpigen_emit_namestring() - Emit an ACPI name * * This writes out an ACPI name or path in the required special format. It does * not add the NAME_OP prefix. * * @ctx: ACPI context pointer * @namepath: Name / path to emit */ void acpigen_emit_namestring(struct acpi_ctx *ctx, const char *namepath); /** * acpigen_write_name() - Write out an ACPI name * * This writes out an ACPI name or path in the required special format with a * NAME_OP prefix. * * @ctx: ACPI context pointer * @namepath: Name / path to emit */ void acpigen_write_name(struct acpi_ctx *ctx, const char *namepath); /** * acpigen_write_scope() - Write a scope * * @ctx: ACPI context pointer * @scope: Scope to write (e.g. "\\_SB.ABCD") */ void acpigen_write_scope(struct acpi_ctx *ctx, const char *scope); /** * acpigen_write_uuid() - Write a UUID * * This writes out a UUID in the format used by ACPI, with a BUFFER_OP prefix. * * @ctx: ACPI context pointer * @uuid: UUID to write in the form aabbccdd-eeff-gghh-iijj-kkllmmnnoopp * @return 0 if OK, -EINVAL if the format is incorrect */ int acpigen_write_uuid(struct acpi_ctx *ctx, const char *uuid); /** * acpigen_emit_ext_op() - Emit an extended op with the EXT_OP_PREFIX prefix * * @ctx: ACPI context pointer * @op: Operation code (e.g. SLEEP_OP) */ void acpigen_emit_ext_op(struct acpi_ctx *ctx, uint op); /** * acpigen_write_method() - Write a method header * * @ctx: ACPI context pointer * @name: Method name (4 characters) * @nargs: Number of method arguments (0 if none) */ void acpigen_write_method(struct acpi_ctx *ctx, const char *name, int nargs); /** * acpigen_write_method_serialized() - Write a method header * * This sets the 'serialized' flag so that the method is thread-safe * * @ctx: ACPI context pointer * @name: Method name (4 characters) * @nargs: Number of method arguments (0 if none) */ void acpigen_write_method_serialized(struct acpi_ctx *ctx, const char *name, int nargs); /** * acpigen_write_device() - Write an ACPI device * * @ctx: ACPI context pointer * @name: Device name to write */ void acpigen_write_device(struct acpi_ctx *ctx, const char *name); /** * acpigen_write_sta() - Write a _STA method * * @ctx: ACPI context pointer * @status: Status value to return */ void acpigen_write_sta(struct acpi_ctx *ctx, uint status); /** * acpigen_write_resourcetemplate_header() - Write a ResourceTemplate header * * @ctx: ACPI context pointer */ void acpigen_write_resourcetemplate_header(struct acpi_ctx *ctx); /** * acpigen_write_resourcetemplate_footer() - Write a ResourceTemplate footer * * @ctx: ACPI context pointer */ void acpigen_write_resourcetemplate_footer(struct acpi_ctx *ctx); /** * acpigen_write_register_resource() - Write a register resource * * This writes a header, the address information and a footer * * @ctx: ACPI context pointer * @addr: Address to write */ void acpigen_write_register_resource(struct acpi_ctx *ctx, const struct acpi_gen_regaddr *addr); /** * acpigen_write_sleep() - Write a sleep operation * * @ctx: ACPI context pointer * @sleep_ms: Number of milliseconds to sleep for */ void acpigen_write_sleep(struct acpi_ctx *ctx, u64 sleep_ms); /** * acpigen_write_store() - Write a store operation * * @ctx: ACPI context pointer */ void acpigen_write_store(struct acpi_ctx *ctx); /** * acpigen_write_debug_string() - Write a debug string * * This writes a debug operation with an associated string * * @ctx: ACPI context pointer * @str: String to write */ void acpigen_write_debug_string(struct acpi_ctx *ctx, const char *str); /** * acpigen_write_or() - Write a bitwise OR operation * * res = arg1 | arg2 * * @ctx: ACPI context pointer * @arg1: ACPI opcode for operand 1 (e.g. LOCAL0_OP) * @arg2: ACPI opcode for operand 2 (e.g. LOCAL1_OP) * @res: ACPI opcode for result (e.g. LOCAL2_OP) */ void acpigen_write_or(struct acpi_ctx *ctx, u8 arg1, u8 arg2, u8 res); /** * acpigen_write_and() - Write a bitwise AND operation * * res = arg1 & arg2 * * @ctx: ACPI context pointer * @arg1: ACPI opcode for operand 1 (e.g. LOCAL0_OP) * @arg2: ACPI opcode for operand 2 (e.g. LOCAL1_OP) * @res: ACPI opcode for result (e.g. LOCAL2_OP) */ void acpigen_write_and(struct acpi_ctx *ctx, u8 arg1, u8 arg2, u8 res); /** * acpigen_write_not() - Write a bitwise NOT operation * * res = ~arg1 * * @ctx: ACPI context pointer * @arg: ACPI opcode for operand (e.g. LOCAL0_OP) * @res: ACPI opcode for result (e.g. LOCAL2_OP) */ void acpigen_write_not(struct acpi_ctx *ctx, u8 arg, u8 res); /** * acpigen_write_power_res() - Write a power resource * * Name (_PRx, Package(One) { name }) * ... * PowerResource (name, level, order) * * The caller should fill in the rest of the power resource and then call * acpigen_pop_len() to close it off * * @ctx: ACPI context pointer * @name: Name of power resource (e.g. "PRIC") * @level: Deepest sleep level that this resource must be kept on (0=S0, 3=S3) * @order: Order that this must be enabled/disabled (e.g. 0) * @dev_stats: List of states to define, e.g. {"_PR0", "_PR3"} * @dev_states_count: Number of dev states */ void acpigen_write_power_res(struct acpi_ctx *ctx, const char *name, uint level, uint order, const char *const dev_states[], size_t dev_states_count); /** * acpigen_set_enable_tx_gpio() - Emit ACPI code to enable/disable a GPIO * * This emits code to either enable to disable a Tx GPIO. It takes account of * the GPIO polarity. * * The code needs access to the DW0 register for the pad being used. This is * provided by gpio->pin0_addr and ACPI methods must be defined for the board * which can read and write the pad's DW0 register given this address: * @dw0_read: takes a single argument, the DW0 address * returns the DW0 value * @dw0:write: takes two arguments, the DW0 address and the value to write * no return value * * Example code (-- means comment): * * -- Get Pad Configuration DW0 register value * Method (GPC0, 0x1, Serialized) * { * -- Arg0 - GPIO DW0 address * Store (Arg0, Local0) * OperationRegion (PDW0, SystemMemory, Local0, 4) * Field (PDW0, AnyAcc, NoLock, Preserve) { * TEMP, 32 * } * Return (TEMP) * } * * -- Set Pad Configuration DW0 register value * Method (SPC0, 0x2, Serialized) * { * -- Arg0 - GPIO DW0 address * -- Arg1 - Value for DW0 register * Store (Arg0, Local0) * OperationRegion (PDW0, SystemMemory, Local0, 4) * Field (PDW0, AnyAcc, NoLock, Preserve) { * TEMP,32 * } * Store (Arg1, TEMP) * } * * * @ctx: ACPI context pointer * @tx_state_val: Mask to use to toggle the TX state on the GPIO pin, e,g. * PAD_CFG0_TX_STATE * @dw0_read: Method name to use to read dw0, e.g. "\\_SB.GPC0" * @dw0_write: Method name to use to read dw0, e.g. "\\_SB.SPC0" * @gpio: GPIO to change * @enable: true to enable GPIO, false to disable * Returns 0 on success, -ve on error. */ int acpigen_set_enable_tx_gpio(struct acpi_ctx *ctx, u32 tx_state_val, const char *dw0_read, const char *dw0_write, struct acpi_gpio *gpio, bool enable); /** * acpigen_write_prw() - Write a power resource for wake (_PRW) * * @ctx: ACPI context pointer * @wake: GPE that wakes up the device * @level: Deepest power system sleeping state that can be entered while still * providing wake functionality */ void acpigen_write_prw(struct acpi_ctx *ctx, uint wake, uint level); /** * acpigen_write_if() - Write an If block * * This requires a call to acpigen_pop_len() to complete the block * * @ctx: ACPI context pointer */ void acpigen_write_if(struct acpi_ctx *ctx); /** * acpigen_write_if_lequal_op_int() - Write comparison between op and integer * * Generates ACPI code for checking if operand1 and operand2 are equal * * If (Lequal (op, val)) * * @ctx: ACPI context pointer * @op: Operand to check * @val: Value to check against */ void acpigen_write_if_lequal_op_int(struct acpi_ctx *ctx, uint op, u64 val); /** * acpigen_write_else() - Write an Ef block * * This requires a call to acpigen_pop_len() to complete the block * * @ctx: ACPI context pointer */ void acpigen_write_else(struct acpi_ctx *ctx); /** * acpigen_write_to_buffer() - Write a ToBuffer operation * * E.g.: to generate: ToBuffer (Arg0, Local0) * use acpigen_write_to_buffer(ctx, ARG0_OP, LOCAL0_OP) * * @ctx: ACPI context pointer * @src: Source argument * @dst: Destination argument */ void acpigen_write_to_buffer(struct acpi_ctx *ctx, uint src, uint dst); /** * acpigen_write_to_integer() - Write a ToInteger operation * * E.g.: to generate: ToInteger (Arg0, Local0) * use acpigen_write_to_integer(ctx, ARG0_OP, LOCAL0_OP) * * @ctx: ACPI context pointer * @src: Source argument * @dst: Destination argument */ void acpigen_write_to_integer(struct acpi_ctx *ctx, uint src, uint dst); /** * acpigen_write_return_byte_buffer() - Write a return of a byte buffer * * @ctx: ACPI context pointer * @arr: Array of bytes to return * @size: Number of bytes */ void acpigen_write_return_byte_buffer(struct acpi_ctx *ctx, u8 *arr, size_t size); /** * acpigen_write_return_singleton_buffer() - Write a return of a 1-byte buffer * * @ctx: ACPI context pointer * @arg: Byte to return */ void acpigen_write_return_singleton_buffer(struct acpi_ctx *ctx, uint arg); /** * acpigen_write_return_byte() - Write a return of a byte * * @ctx: ACPI context pointer * @arg: Byte to return */ void acpigen_write_return_byte(struct acpi_ctx *ctx, uint arg); /** * acpigen_write_dsm_start() - Start a _DSM method * * Generate ACPI AML code to start the _DSM method. * * The functions need to be called in the correct sequence as below. * * Within the region, Local0 and Local1 must be are left * untouched, but Local2-Local7 can be used * * Arguments passed into _DSM method: * Arg0 = UUID * Arg1 = Revision * Arg2 = Function index * Arg3 = Function-specific arguments * * AML code generated looks like this: * Method (_DSM, 4, Serialized) { -- acpigen_write_dsm_start) * ToBuffer (Arg0, Local0) * If (LEqual (Local0, ToUUID(uuid))) { -- acpigen_write_dsm_uuid_start * ToInteger (Arg2, Local1) * If (LEqual (Local1, 0)) { -- acpigen_write_dsm_uuid_start_cond * * } -- acpigen_write_dsm_uuid_end_cond * ... * If (LEqual (Local1, n)) { -- acpigen_write_dsm_uuid_start_cond * * } -- acpigen_write_dsm_uuid_end_cond * Return (Buffer (One) { 0x0 }) * } -- acpigen_write_dsm_uuid_end * ... * If (LEqual (Local0, ToUUID(uuidn))) { * ... * } * Return (Buffer (One) { 0x0 }) -- acpigen_write_dsm_end * } * * @ctx: ACPI context pointer */ void acpigen_write_dsm_start(struct acpi_ctx *ctx); /** * acpigen_write_dsm_uuid_start() - Start a new UUID block * * This starts generation of code to handle a particular UUID: * * If (LEqual (Local0, ToUUID(uuid))) { * ToInteger (Arg2, Local1) * * @ctx: ACPI context pointer */ int acpigen_write_dsm_uuid_start(struct acpi_ctx *ctx, const char *uuid); /** * acpigen_write_dsm_uuid_start_cond() - Start a new condition block * * This starts generation of condition-checking code to handle a particular * function: * * If (LEqual (Local1, i)) * * @ctx: ACPI context pointer */ void acpigen_write_dsm_uuid_start_cond(struct acpi_ctx *ctx, int seq); /** * acpigen_write_dsm_uuid_end_cond() - Start a new condition block * * This ends generation of condition-checking code to handle a particular * function: * * } * * @ctx: ACPI context pointer */ void acpigen_write_dsm_uuid_end_cond(struct acpi_ctx *ctx); /** * acpigen_write_dsm_uuid_end() - End a UUID block * * This ends generation of code to handle a particular UUID: * * Return (Buffer (One) { 0x0 }) * * @ctx: ACPI context pointer */ void acpigen_write_dsm_uuid_end(struct acpi_ctx *ctx); /** * acpigen_write_dsm_end() - End a _DSM method * * This ends generates of the _DSM block: * * Return (Buffer (One) { 0x0 }) * * @ctx: ACPI context pointer */ void acpigen_write_dsm_end(struct acpi_ctx *ctx); /** * acpigen_write_processor() - Write a Processor package * * This emits a Processor package header with the required information. The * caller must complete the information and call acpigen_pop_len() at the end * * @ctx: ACPI context pointer * @cpuindex: CPU number * @pblock_addr: PBlk system IO address * @pblock_len: PBlk length */ void acpigen_write_processor(struct acpi_ctx *ctx, uint cpuindex, u32 pblock_addr, uint pblock_len); /** * acpigen_write_processor_package() - Write a package containing the processors * * The package containins the name of each processor in the SoC * * @ctx: ACPI context pointer * @name: Package name (.e.g "PPKG") * @first_core: Number of the first core (e.g. 0) * @core_count: Number of cores (e.g. 4) */ void acpigen_write_processor_package(struct acpi_ctx *ctx, const char *name, uint first_core, uint core_count); /** * acpigen_write_processor_cnot() - Write a processor notification method * * This writes a method that notifies all CPU cores * * @ctx: ACPI context pointer * @num_cores: Number of CPU cores */ void acpigen_write_processor_cnot(struct acpi_ctx *ctx, const uint num_cores); /** * acpigen_write_ppc() - generates a function returning max P-states * * @ctx: ACPI context pointer * @num_pstates: Number of pstates to return */ void acpigen_write_ppc(struct acpi_ctx *ctx, uint num_pstates); /** * acpigen_write_ppc() - generates a function returning PPCM * * This returns the maximum number of supported P-states, as saved in the * variable PPCM * * @ctx: ACPI context pointer */ void acpigen_write_ppc_nvs(struct acpi_ctx *ctx); /** * acpigen_write_tpc() - Write a _TPC method that returns the TPC limit * * @ctx: ACPI context pointer * @gnvs_tpc_limit: Variable that holds the TPC limit */ void acpigen_write_tpc(struct acpi_ctx *ctx, const char *gnvs_tpc_limit); /** * acpigen_write_pss_package() - Write a PSS package * * See ACPI v6.3 section 8.4.6: Processor Performance Control * * @ctx: ACPI context pointer * @corefreq: CPU core frequency in MHz * @translat: worst-case latency in uS that the CPU is unavailable during a * transition from any performance state to this performance state * @busmlat: worst-case latency in microseconds that Bus Masters are prevented * from accessing memory during a transition from any performance state to * this performance state * @control: Value to write to PERF_CTRL to move to this performance state * @status: Expected PERF_STATUS value when in this state */ void acpigen_write_pss_package(struct acpi_ctx *ctx, uint corefreq, uint power, uint translat, uint busmlat, uint control, uint status); /** * acpigen_write_psd_package() - Write a PSD package * * Writes a P-State dependency package * * See ACPI v6.3 section 8.4.6.5: _PSD (P-State Dependency) * * @ctx: ACPI context pointer * @domain: Dependency domain number to which this P state entry belongs * @numprocs: Number of processors belonging to the domain for this logical * processor’s P-states * @coordtype: Coordination type */ void acpigen_write_psd_package(struct acpi_ctx *ctx, uint domain, uint numprocs, enum psd_coord coordtype); /** * acpigen_write_cst_package() - Write a _CST package * * See ACPI v6.3 section 8.4.2.1: _CST (C States) * * @ctx: ACPI context pointer * @entry: Array of entries * @nentries; Number of entries */ void acpigen_write_cst_package(struct acpi_ctx *ctx, const struct acpi_cstate *entry, int nentries); /** * acpigen_write_csd_package() - Write a _CSD Package * * See ACPI v6.3 section 8.4.2.2: _CSD (C-State Dependency) * * @ctx: ACPI context pointer * @domain: dependency domain number to which this C state entry belongs * @numprocs: number of processors belonging to the domain for the particular * C-state * @coordtype: Co-ordination type * @index: Index of the C-State entry in the _CST object for which the * dependency applies */ void acpigen_write_csd_package(struct acpi_ctx *ctx, uint domain, uint numprocs, enum csd_coord coordtype, uint index); /** * acpigen_write_tss_package() - Write a _TSS package * * @ctx: ACPI context pointer * @entry: Entries to write * @nentries: Number of entries to write */ void acpigen_write_tss_package(struct acpi_ctx *ctx, struct acpi_tstate *entry, int nentries); /** * acpigen_write_tsd_package() - Write a _TSD package * * See ACPI v6.3 section 8.4.5.4: _TSD (T-State Dependency) * * @ctx: ACPI context pointer * @domain: dependency domain number to which this T state entry belongs * @numprocs: Number of processors belonging to the domain for this logical * processor’s T-states * @coordtype: Coordination type */ void acpigen_write_tsd_package(struct acpi_ctx *ctx, uint domain, uint numprocs, enum psd_coord coordtype); #endif