/* SPDX-License-Identifier: GPL-2.0-only */

#ifndef __ACPI_ACPIGEN_H__
#define __ACPI_ACPIGEN_H__

#include <stddef.h>
#include <stdint.h>
#include <acpi/acpi.h>
#include <acpi/acpi_device.h>
#include <acpi/acpi_pld.h>
#include <device/pci_type.h>

/* Values that can be returned for ACPI Device _STA method */
#define ACPI_STATUS_DEVICE_PRESENT	(1 << 0)
#define ACPI_STATUS_DEVICE_ENABLED	(1 << 1)
#define ACPI_STATUS_DEVICE_SHOW_IN_UI	(1 << 2)
#define ACPI_STATUS_DEVICE_STATE_OK	(1 << 3)

#define ACPI_STATUS_DEVICE_ALL_OFF	0
#define ACPI_STATUS_DEVICE_ALL_ON	(ACPI_STATUS_DEVICE_PRESENT |\
					 ACPI_STATUS_DEVICE_ENABLED |\
					 ACPI_STATUS_DEVICE_SHOW_IN_UI |\
					 ACPI_STATUS_DEVICE_STATE_OK)
#define ACPI_STATUS_DEVICE_HIDDEN_ON	(ACPI_STATUS_DEVICE_PRESENT |\
					 ACPI_STATUS_DEVICE_ENABLED |\
					 ACPI_STATUS_DEVICE_STATE_OK)

/* ACPI Op/Prefix Codes */
enum {
	ZERO_OP			= 0x00,
	ONE_OP			= 0x01,
	ALIAS_OP		= 0x06,
	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,
	VARIABLE_PACKAGE_OP	= 0x13,
	METHOD_OP		= 0x14,
	EXTERNAL_OP		= 0x15,
	DUAL_NAME_PREFIX	= 0x2E,
	MULTI_NAME_PREFIX	= 0x2F,
	EXT_OP_PREFIX		= 0x5B,
	 MUTEX_OP		= 0x01,
	 EVENT_OP		= 0x01,
	 SF_RIGHT_OP		= 0x10,
	 SF_LEFT_OP		= 0x11,
	 COND_REFOF_OP		= 0x12,
	 CREATEFIELD_OP		= 0x13,
	 LOAD_TABLE_OP		= 0x1f,
	 LOAD_OP		= 0x20,
	 STALL_OP		= 0x21,
	 SLEEP_OP		= 0x22,
	 ACQUIRE_OP		= 0x23,
	 SIGNAL_OP		= 0x24,
	 WAIT_OP		= 0x25,
	 RST_OP			= 0x26,
	 RELEASE_OP		= 0x27,
	 FROM_BCD_OP		= 0x28,
	 TO_BCD_OP		= 0x29,
	 UNLOAD_OP		= 0x2A,
	 REVISON_OP		= 0x30,
	 DEBUG_OP		= 0x31,
	 FATAL_OP		= 0x32,
	 TIMER_OP		= 0x33,
	 OPREGION_OP		= 0x80,
	 FIELD_OP		= 0x81,
	 DEVICE_OP		= 0x82,
	 PROCESSOR_OP		= 0x83,
	 POWER_RES_OP		= 0x84,
	 THERMAL_ZONE_OP	= 0x85,
	 INDEX_FIELD_OP		= 0x86,
	 BANK_FIELD_OP		= 0x87,
	 DATA_REGION_OP		= 0x88,
	ROOT_PREFIX		= 0x5C,
	PARENT_PREFIX		= 0x5E,
	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,
	REF_OF_OP		= 0x71,
	ADD_OP			= 0x72,
	CONCATENATE_OP		= 0x73,
	SUBTRACT_OP		= 0x74,
	INCREMENT_OP		= 0x75,
	DECREMENT_OP		= 0x76,
	MULTIPLY_OP		= 0x77,
	DIVIDE_OP		= 0x78,
	SHIFT_LEFT_OP		= 0x79,
	SHIFT_RIGHT_OP		= 0x7A,
	AND_OP			= 0x7B,
	NAND_OP			= 0x7C,
	OR_OP			= 0x7D,
	NOR_OP			= 0x7E,
	XOR_OP			= 0x7F,
	NOT_OP			= 0x80,
	FD_SHIFT_LEFT_BIT_OR	= 0x81,
	FD_SHIFT_RIGHT_BIT_OR	= 0x82,
	DEREF_OP		= 0x83,
	CONCATENATE_TEMP_OP	= 0x84,
	MOD_OP			= 0x85,
	NOTIFY_OP		= 0x86,
	SIZEOF_OP		= 0x87,
	INDEX_OP		= 0x88,
	MATCH_OP		= 0x89,
	CREATE_DWORD_OP		= 0x8A,
	CREATE_WORD_OP		= 0x8B,
	CREATE_BYTE_OP		= 0x8C,
	CREATE_BIT_OP		= 0x8D,
	OBJ_TYPE_OP		= 0x8E,
	CREATE_QWORD_OP		= 0x8F,
	LAND_OP			= 0x90,
	LOR_OP			= 0x91,
	LNOT_OP			= 0x92,
	LEQUAL_OP		= 0x93,
	LGREATER_OP		= 0x94,
	LLESS_OP		= 0x95,
	TO_BUFFER_OP		= 0x96,
	TO_DEC_STRING_OP	= 0x97,
	TO_HEX_STRING_OP	= 0x98,
	TO_INTEGER_OP		= 0x99,
	TO_STRING_OP		= 0x9C,
	CP_OBJ_OP		= 0x9D,
	MID_OP			= 0x9E,
	CONTINUE_OP		= 0x9F,
	IF_OP			= 0xA0,
	ELSE_OP			= 0xA1,
	WHILE_OP		= 0xA2,
	NOOP_OP			= 0xA3,
	RETURN_OP		= 0xA4,
	BREAK_OP		= 0xA5,
	COMMENT_OP		= 0xA9,
	BREAKPIONT_OP		= 0xCC,
	ONES_OP			= 0xFF,
};

#define FIELDLIST_OFFSET(X)		{ .type = OFFSET, \
					  .name = "",\
					  .bits = X * 8, \
					}
#define FIELDLIST_NAMESTR(X, Y)		{ .type = NAME_STRING, \
					  .name = X, \
					  .bits = Y, \
					}
#define FIELDLIST_RESERVED(X)		{ .type = RESERVED, \
					  .name = "", \
					  .bits = X, \
					}

#define FIELD_ANYACC			0
#define FIELD_BYTEACC			1
#define FIELD_WORDACC			2
#define FIELD_DWORDACC			3
#define FIELD_QWORDACC			4
#define FIELD_BUFFERACC			5
#define FIELD_NOLOCK			(0<<4)
#define FIELD_LOCK			(1<<4)
#define FIELD_PRESERVE			(0<<5)
#define FIELD_WRITEASONES		(1<<5)
#define FIELD_WRITEASZEROS		(2<<5)

enum field_type {
	OFFSET,
	NAME_STRING,
	RESERVED,
	FIELD_TYPE_MAX,
};

struct fieldlist {
	enum field_type type;
	const char *name;
	u32 bits;
};

#define OPREGION(rname, space, offset, len)	{.name = rname, \
						 .regionspace = space, \
						 .regionoffset = offset, \
						 .regionlen = len, \
						}

enum region_space {
	SYSTEMMEMORY,
	SYSTEMIO,
	PCI_CONFIG,
	EMBEDDEDCONTROL,
	SMBUS,
	CMOS,
	PCIBARTARGET,
	IPMI,
	GPIO_REGION,
	GPSERIALBUS,
	PCC,
	FIXED_HARDWARE = 0x7F,
	REGION_SPACE_MAX,
};

struct opregion {
	const char *name;
	enum region_space regionspace;
	unsigned long regionoffset;
	unsigned long regionlen;
};

#define DSM_UUID(DSM_UUID, DSM_CALLBACKS, DSM_COUNT, DSM_ARG) \
	{ .uuid = DSM_UUID, \
	.callbacks = DSM_CALLBACKS, \
	.count = DSM_COUNT, \
	.arg = DSM_ARG, \
	}

struct dsm_uuid {
	const char *uuid;
	void (**callbacks)(void *);
	size_t count;
	void *arg;
};

#define CPPC_VERSION_1	1
#define CPPC_VERSION_2	2
#define CPPC_VERSION_3	3

/*version 1 has 15 fields, version 2 has 19, and version 3 has 21 */
enum cppc_fields {
	CPPC_HIGHEST_PERF, /* can be DWORD */
	CPPC_NOMINAL_PERF, /* can be DWORD */
	CPPC_LOWEST_NONL_PERF, /* can be DWORD */
	CPPC_LOWEST_PERF, /* can be DWORD */
	CPPC_GUARANTEED_PERF,
	CPPC_DESIRED_PERF,
	CPPC_MIN_PERF,
	CPPC_MAX_PERF,
	CPPC_PERF_REDUCE_TOLERANCE,
	CPPC_TIME_WINDOW,
	CPPC_COUNTER_WRAP, /* can be DWORD */
	CPPC_REF_PERF_COUNTER,
	CPPC_DELIVERED_PERF_COUNTER,
	CPPC_PERF_LIMITED,
	CPPC_ENABLE, /* can be System I/O */
	CPPC_MAX_FIELDS_VER_1,
	CPPC_AUTO_SELECT = /* can be DWORD */
		CPPC_MAX_FIELDS_VER_1,
	CPPC_AUTO_ACTIVITY_WINDOW,
	CPPC_PERF_PREF,
	CPPC_REF_PERF, /* can be DWORD */
	CPPC_MAX_FIELDS_VER_2,
	CPPC_LOWEST_FREQ = /* can be DWORD */
		CPPC_MAX_FIELDS_VER_2,
	CPPC_NOMINAL_FREQ, /* can be DWORD */
	CPPC_MAX_FIELDS_VER_3,
};

struct cppc_config {
	u32 version; /* must be 1, 2, or 3 */
	/*
	 * The generic acpi_addr_t structure is being used, though
	 * anything besides PPC or FFIXED generally requires checking
	 * if the OS has advertised support for it (via _OSC).
	 *
	 * NOTE: some fields permit DWORDs to be used.  If you
	 * provide a System Memory register with all zeros (which
	 * represents unsupported) then this will be used as-is.
	 * Otherwise, a System Memory register with a 32-bit
	 * width will be converted into a DWORD field (the value
	 * of which will be the value of 'addrl'.  Any other use
	 * of System Memory register is currently undefined.
	 * (i.e., if you have an actual need for System Memory
	 * then you'll need to adjust this kludge).
	 */
	acpi_addr_t regs[CPPC_MAX_FIELDS_VER_3];
};

void acpigen_write_return_integer(uint64_t arg);
void acpigen_write_return_namestr(const char *arg);
void acpigen_write_return_string(const char *arg);
void acpigen_write_len_f(void);
void acpigen_pop_len(void);
void acpigen_set_current(char *curr);
char *acpigen_get_current(void);
char *acpigen_write_package(int nr_el);
void acpigen_write_zero(void);
void acpigen_write_one(void);
void acpigen_write_ones(void);
void acpigen_write_byte(unsigned int data);
void acpigen_emit_byte(unsigned char data);
void acpigen_emit_ext_op(uint8_t op);
void acpigen_emit_word(unsigned int data);
void acpigen_emit_dword(unsigned int data);
void acpigen_emit_stream(const char *data, int size);
void acpigen_emit_string(const char *string);
void acpigen_emit_namestring(const char *namepath);
void acpigen_emit_eisaid(const char *eisaid);
void acpigen_write_word(unsigned int data);
void acpigen_write_dword(unsigned int data);
void acpigen_write_qword(uint64_t data);
void acpigen_write_integer(uint64_t data);
void acpigen_write_string(const char *string);
void acpigen_write_name_unicode(const char *name, const char *string);
void acpigen_write_name(const char *name);
void acpigen_write_name_zero(const char *name);
void acpigen_write_name_one(const char *name);
void acpigen_write_name_string(const char *name, const char *string);
void acpigen_write_name_dword(const char *name, uint32_t val);
void acpigen_write_name_qword(const char *name, uint64_t val);
void acpigen_write_name_byte(const char *name, uint8_t val);
void acpigen_write_name_integer(const char *name, uint64_t val);
void acpigen_write_coreboot_hid(enum coreboot_acpi_ids id);
void acpigen_write_scope(const char *name);
void acpigen_write_method(const char *name, int nargs);
void acpigen_write_method_serialized(const char *name, int nargs);
void acpigen_write_device(const char *name);
void acpigen_write_PPC(u8 nr);
void acpigen_write_PPC_NVS(void);
void acpigen_write_empty_PCT(void);
void acpigen_write_empty_PTC(void);
void acpigen_write_PRW(u32 wake, u32 level);
void acpigen_write_STA(uint8_t status);
void acpigen_write_STA_ext(const char *namestring);
void acpigen_write_TPC(const char *gnvs_tpc_limit);
void acpigen_write_PSS_package(u32 coreFreq, u32 power, u32 transLat,
			u32 busmLat, u32 control, u32 status);
void acpigen_write_pss_object(const struct acpi_sw_pstate *pstate_values, size_t nentries);
typedef enum { SW_ALL = 0xfc, SW_ANY = 0xfd, HW_ALL = 0xfe } PSD_coord;
void acpigen_write_PSD_package(u32 domain, u32 numprocs, PSD_coord coordtype);
void acpigen_write_CST_package_entry(acpi_cstate_t *cstate);
void acpigen_write_CST_package(acpi_cstate_t *entry, int nentries);
typedef enum { CSD_HW_ALL = 0xfe } CSD_coord;
void acpigen_write_CSD_package(u32 domain, u32 numprocs, CSD_coord coordtype,
				u32 index);
void acpigen_write_pct_package(const acpi_addr_t *perf_ctrl, const acpi_addr_t *perf_sts);
void acpigen_write_xpss_package(const struct acpi_xpss_sw_pstate *pstate_value);
void acpigen_write_xpss_object(const struct acpi_xpss_sw_pstate *pstate_values,
			       size_t nentries);
void acpigen_write_processor(u8 cpuindex, u32 pblock_addr, u8 pblock_len);
void acpigen_write_processor_package(const char *name,
				     unsigned int first_core,
				     unsigned int core_count);
void acpigen_write_processor_cnot(const unsigned int number_of_cores);
void acpigen_write_TSS_package(int entries, acpi_tstate_t *tstate_list);
void acpigen_write_TSD_package(u32 domain, u32 numprocs, PSD_coord coordtype);
void acpigen_write_mem32fixed(int readwrite, u32 base, u32 size);
void acpigen_write_io16(u16 min, u16 max, u8 align, u8 len, u8 decode16);
void acpigen_write_register_resource(const acpi_addr_t *addr);
void acpigen_write_resourcetemplate_header(void);
void acpigen_write_resourcetemplate_footer(void);
void acpigen_write_mainboard_resource_template(void);
void acpigen_write_mainboard_resources(const char *scope, const char *name);
void acpigen_write_irq(u16 mask);
void acpigen_write_uuid(const char *uuid);
void acpigen_write_power_res(const char *name, uint8_t level, uint16_t order,
			     const char * const dev_states[], size_t dev_states_count);
void acpigen_write_sleep(uint64_t sleep_ms);
void acpigen_write_store(void);
void acpigen_write_store_int_to_namestr(uint64_t src, const char *dst);
void acpigen_write_store_int_to_op(uint64_t src, uint8_t dst);
void acpigen_write_store_ops(uint8_t src, uint8_t dst);
void acpigen_write_store_op_to_namestr(uint8_t src, const char *dst);
void acpigen_write_or(uint8_t arg1, uint8_t arg2, uint8_t res);
void acpigen_write_xor(uint8_t arg1, uint8_t arg2, uint8_t res);
void acpigen_write_and(uint8_t arg1, uint8_t arg2, uint8_t res);
void acpigen_write_not(uint8_t arg, uint8_t res);
void acpigen_write_debug_string(const char *str);
void acpigen_write_debug_namestr(const char *str);
void acpigen_write_debug_integer(uint64_t val);
void acpigen_write_debug_op(uint8_t op);
void acpigen_write_if(void);
void acpigen_write_if_and(uint8_t arg1, uint8_t arg2);
void acpigen_write_if_lequal_op_op(uint8_t op, uint8_t val);
void acpigen_write_if_lequal_op_int(uint8_t op, uint64_t val);
void acpigen_write_if_lequal_namestr_int(const char *namestr, uint64_t val);
void acpigen_write_else(void);
void acpigen_write_shiftleft_op_int(uint8_t src_result, uint64_t count);
void acpigen_write_to_buffer(uint8_t src, uint8_t dst);
void acpigen_write_to_integer(uint8_t src, uint8_t dst);
void acpigen_write_to_integer_from_namestring(const char *source, uint8_t dst_op);
void acpigen_write_byte_buffer(uint8_t *arr, size_t size);
void acpigen_write_return_byte_buffer(uint8_t *arr, size_t size);
void acpigen_write_return_singleton_buffer(uint8_t arg);
void acpigen_write_return_op(uint8_t arg);
void acpigen_write_return_byte(uint8_t arg);
void acpigen_write_upc(enum acpi_upc_type type);
void acpigen_write_pld(const struct acpi_pld *pld);
void acpigen_write_ADR(uint64_t adr);
void acpigen_write_ADR_pci_devfn(pci_devfn_t devfn);
void acpigen_write_ADR_pci_device(const struct device *dev);
struct soundwire_address;
void acpigen_write_ADR_soundwire_device(const struct soundwire_address *address);
void acpigen_write_create_byte_field(uint8_t op, size_t byte_offset, const char *name);
void acpigen_write_create_word_field(uint8_t op, size_t byte_offset, const char *name);
void acpigen_write_create_dword_field(uint8_t op, size_t byte_offset, const char *name);
void acpigen_write_create_qword_field(uint8_t op, size_t byte_offset, const char *name);
/*
 * Generate ACPI AML code for _DSM method.
 * This function takes as input uuid for the device, set of callbacks and
 * argument to pass into the callbacks. Callbacks should ensure that Local0 and
 * Local1 are left untouched. Use of Local2-Local7 is permitted in callbacks.
 */
void acpigen_write_dsm(const char *uuid, void (**callbacks)(void *),
		       size_t count, void *arg);
void acpigen_write_dsm_uuid_arr(struct dsm_uuid *ids, size_t count);

/*
 * Generate ACPI AML code for _CPC (Continuous Performance Control).
 * Execute the package function once to create a global table, then
 * execute the method function within each processor object to
 * create a method that points to the global table.
 */
void acpigen_write_CPPC_package(const struct cppc_config *config);
void acpigen_write_CPPC_method(void);

/*
 * Generate ACPI AML code for _ROM method.
 * This function takes as input ROM data and ROM length.
 * The ROM length has to be multiple of 4096 and has to be less
 * than the current implementation limit of 0x40000.
 */
void acpigen_write_rom(void *bios, const size_t length);
/*
 * Generate ACPI AML code for OperationRegion
 * This function takes input region name, region space, region offset & region
 * length.
 */
void acpigen_write_opregion(const struct opregion *opreg);
/*
 * Generate ACPI AML code for Mutex
 * This function takes mutex name and initial value.
 */
void acpigen_write_mutex(const char *name, const uint8_t flags);
/*
 * Generate ACPI AML code for Acquire
 * This function takes mutex name and privilege value.
 */
void acpigen_write_acquire(const char *name, const uint16_t val);
/*
 * Generate ACPI AML code for Release
 * This function takes mutex name.
 */
void acpigen_write_release(const char *name);
/*
 * Generate ACPI AML code for Field
 * This function takes input region name, fieldlist, count & flags.
 */
void acpigen_write_field(const char *name, const struct fieldlist *l, size_t count,
			 uint8_t flags);
/*
 * Generate ACPI AML code for IndexField
 * This function takes input index name, data name, fieldlist, count & flags.
 */
void acpigen_write_indexfield(const char *idx, const char *data,
			      struct fieldlist *l, size_t count, uint8_t flags);

int get_cst_entries(acpi_cstate_t **);

/*
 * Get element from package into specified destination op:
 *   <dest_op> = DeRefOf (<package_op>[<element>])
 *
 * Example:
 *  acpigen_get_package_op_element(ARG0_OP, 0, LOCAL0_OP)
 *  Local0 = DeRefOf (Arg0[0])
 */
void acpigen_get_package_op_element(uint8_t package_op, unsigned int element, uint8_t dest_op);

/* Set element of package op to specified op:  DeRefOf (<package>[<element>]) = <src> */
void acpigen_set_package_op_element_int(uint8_t package_op, unsigned int element, uint64_t src);

/* Get element from package to specified op:  <dest_op> = <package>[<element>] */
void acpigen_get_package_element(const char *package, unsigned int element, uint8_t dest_op);

/* Set element of package to specified op:  <package>[<element>] = <src> */
void acpigen_set_package_element_int(const char *package, unsigned int element, uint64_t src);

/* Set element of package to specified namestr:  <package>[<element>] = <src> */
void acpigen_set_package_element_namestr(const char *package, unsigned int element,
					 const char *src);

/*
 * Delay up to wait_ms milliseconds until the provided name matches the expected value.
 * If wait_ms is >= 32ms then it will wait in 16ms chunks.  This function uses LOCAL7_OP.
 */
void acpigen_write_delay_until_namestr_int(uint32_t wait_ms, const char *name, uint64_t value);

/*
 * Soc-implemented functions for generating ACPI AML code for GPIO handling. All
 * these functions are expected to use only Local5, Local6 and Local7
 * variables. If the functions call into another ACPI method, then there is no
 * restriction on the use of Local variables. In case of get/read functions,
 * return value is expected to be stored in Local0 variable.
 *
 * All functions return 0 on success and -1 on error.
 */

/* Generate ACPI AML code to return Rx value of GPIO in Local0. */
int acpigen_soc_read_rx_gpio(unsigned int gpio_num);

/* Generate ACPI AML code to return Tx value of GPIO in Local0. */
int acpigen_soc_get_tx_gpio(unsigned int gpio_num);

/* Generate ACPI AML code to set Tx value of GPIO to 1. */
int acpigen_soc_set_tx_gpio(unsigned int gpio_num);

/* Generate ACPI AML code to set Tx value of GPIO to 0. */
int acpigen_soc_clear_tx_gpio(unsigned int gpio_num);

/*
 * Helper functions for enabling/disabling Tx GPIOs based on the GPIO
 * polarity. These functions end up calling acpigen_soc_{set,clear}_tx_gpio to
 * make callbacks into SoC acpigen code.
 *
 * Returns 0 on success and -1 on error.
 */
int acpigen_enable_tx_gpio(const struct acpi_gpio *gpio);
int acpigen_disable_tx_gpio(const struct acpi_gpio *gpio);

/*
 *  Helper function for getting a RX GPIO value based on the GPIO polarity.
 *  The return value is stored in Local0 variable.
 *  This function ends up calling acpigen_soc_get_rx_gpio to make callbacks
 *  into SoC acpigen code
 */
void acpigen_get_rx_gpio(const struct acpi_gpio *gpio);

/*
 *  Helper function for getting a TX GPIO value based on the GPIO polarity.
 *  The return value is stored in Local0 variable.
 *  This function ends up calling acpigen_soc_get_tx_gpio to make callbacks
 *  into SoC acpigen code
 */
void acpigen_get_tx_gpio(const struct acpi_gpio *gpio);

/* refer to ACPI 6.4.3.5.3 Word Address Space Descriptor section for details */
void acpigen_resource_word(u16 res_type, u16 gen_flags, u16 type_flags, u16 gran,
	u16 range_min, u16 range_max, u16 translation, u16 length);
/* refer to ACPI 6.4.3.5.2 DWord Address Space Descriptor section for details */
void acpigen_resource_dword(u16 res_type, u16 gen_flags, u16 type_flags,
	u32 gran, u32 range_min, u32 range_max, u32 translation, u32 length);
/* refer to ACPI 6.4.3.5.1 QWord Address Space Descriptor section for details */
void acpigen_resource_qword(u16 res_type, u16 gen_flags, u16 type_flags,
	u64 gran, u64 range_min, u64 range_max, u64 translation, u64 length);

/* Emits Notify(namestr, value) */
void acpigen_notify(const char *namestr, int value);

#endif /* __ACPI_ACPIGEN_H__ */
