linux/include/acpi/actypes.h

/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/******************************************************************************
 *
 * Name: actypes.h - Common data types for the entire ACPI subsystem
 *
 * Copyright (C) 2000 - 2023, Intel Corp.
 *
 *****************************************************************************/

#ifndef __ACTYPES_H__
#define __ACTYPES_H__

/* acpisrc:struct_defs -- for acpisrc conversion */

/*
 * ACPI_MACHINE_WIDTH must be specified in an OS- or compiler-dependent
 * header and must be either 32 or 64. 16-bit ACPICA is no longer
 * supported, as of 12/2006.
 */
#ifndef ACPI_MACHINE_WIDTH
#error ACPI_MACHINE_WIDTH not defined
#endif

/*
 * Data type ranges
 * Note: These macros are designed to be compiler independent as well as
 * working around problems that some 32-bit compilers have with 64-bit
 * constants.
 */
#define ACPI_UINT8_MAX
#define ACPI_UINT16_MAX
#define ACPI_UINT32_MAX
#define ACPI_UINT64_MAX
#define ACPI_ASCII_MAX

/*
 * Architecture-specific ACPICA Subsystem Data Types
 *
 * The goal of these types is to provide source code portability across
 * 16-bit, 32-bit, and 64-bit targets.
 *
 * 1) The following types are of fixed size for all targets (16/32/64):
 *
 * u8           Logical boolean
 *
 * u8           8-bit  (1 byte) unsigned value
 * u16          16-bit (2 byte) unsigned value
 * u32          32-bit (4 byte) unsigned value
 * u64          64-bit (8 byte) unsigned value
 *
 * s16          16-bit (2 byte) signed value
 * s32          32-bit (4 byte) signed value
 * s64          64-bit (8 byte) signed value
 *
 * COMPILER_DEPENDENT_UINT64/s64 - These types are defined in the
 * compiler-dependent header(s) and were introduced because there is no
 * common 64-bit integer type across the various compilation models, as
 * shown in the table below.
 *
 * Datatype  LP64 ILP64 LLP64 ILP32 LP32 16bit
 * char      8    8     8     8     8    8
 * short     16   16    16    16    16   16
 * _int32         32
 * int       32   64    32    32    16   16
 * long      64   64    32    32    32   32
 * long long            64    64
 * pointer   64   64    64    32    32   32
 *
 * Note: ILP64 and LP32 are currently not supported.
 *
 *
 * 2) These types represent the native word size of the target mode of the
 * processor, and may be 16-bit, 32-bit, or 64-bit as required. They are
 * usually used for memory allocation, efficient loop counters, and array
 * indexes. The types are similar to the size_t type in the C library and
 * are required because there is no C type that consistently represents the
 * native data width. acpi_size is needed because there is no guarantee
 * that a kernel-level C library is present.
 *
 * acpi_size        16/32/64-bit unsigned value
 * acpi_native_int  16/32/64-bit signed value
 */

/*******************************************************************************
 *
 * Common types for all compilers, all targets
 *
 ******************************************************************************/

#ifndef ACPI_USE_SYSTEM_INTTYPES

typedef unsigned char u8;
typedef unsigned short u16;
typedef short s16;
typedef COMPILER_DEPENDENT_UINT64 u64;
typedef COMPILER_DEPENDENT_INT64 s64;

#endif				/* ACPI_USE_SYSTEM_INTTYPES */

/*
 * Value returned by acpi_os_get_thread_id. There is no standard "thread_id"
 * across operating systems or even the various UNIX systems. Since ACPICA
 * only needs the thread ID as a unique thread identifier, we use a u64
 * as the only common data type - it will accommodate any type of pointer or
 * any type of integer. It is up to the host-dependent OSL to cast the
 * native thread ID type to a u64 (in acpi_os_get_thread_id).
 */
#define acpi_thread_id

/*******************************************************************************
 *
 * Types specific to 64-bit targets
 *
 ******************************************************************************/

#if ACPI_MACHINE_WIDTH == 64

#ifndef ACPI_USE_SYSTEM_INTTYPES

typedef unsigned int u32;
typedef int s32;

#endif				/* ACPI_USE_SYSTEM_INTTYPES */

acpi_native_int;

acpi_size;
acpi_io_address;
acpi_physical_address;

#define ACPI_MAX_PTR
#define ACPI_SIZE_MAX

#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64

/*
 * In the case of the Itanium Processor Family (IPF), the hardware does not
 * support misaligned memory transfers. Set the MISALIGNMENT_NOT_SUPPORTED
 * flag to indicate that special precautions must be taken to avoid alignment
 * faults. (IA64 or ia64 is currently used by existing compilers to indicate
 * IPF.)
 *
 * Note: EM64T and other X86-64 processors support misaligned transfers,
 * so there is no need to define this flag.
 */
#if defined (__IA64__) || defined (__ia64__)
#define ACPI_MISALIGNMENT_NOT_SUPPORTED
#endif

/*******************************************************************************
 *
 * Types specific to 32-bit targets
 *
 ******************************************************************************/

#elif ACPI_MACHINE_WIDTH == 32

#ifndef ACPI_USE_SYSTEM_INTTYPES

typedef unsigned int u32;
typedef int s32;

#endif				/* ACPI_USE_SYSTEM_INTTYPES */

typedef s32 acpi_native_int;

typedef u32 acpi_size;

#ifdef ACPI_32BIT_PHYSICAL_ADDRESS

/*
 * OSPMs can define this to shrink the size of the structures for 32-bit
 * none PAE environment. ASL compiler may always define this to generate
 * 32-bit OSPM compliant tables.
 */
typedef u32 acpi_io_address;
typedef u32 acpi_physical_address;

#else				/* ACPI_32BIT_PHYSICAL_ADDRESS */

/*
 * It is reported that, after some calculations, the physical addresses can
 * wrap over the 32-bit boundary on 32-bit PAE environment.
 * https://bugzilla.kernel.org/show_bug.cgi?id=87971
 */
typedef u64 acpi_io_address;
typedef u64 acpi_physical_address;

#endif				/* ACPI_32BIT_PHYSICAL_ADDRESS */

#define ACPI_MAX_PTR
#define ACPI_SIZE_MAX

#else

/* ACPI_MACHINE_WIDTH must be either 64 or 32 */

#error unknown ACPI_MACHINE_WIDTH
#endif

/*******************************************************************************
 *
 * OS-dependent types
 *
 * If the defaults below are not appropriate for the host system, they can
 * be defined in the OS-specific header, and this will take precedence.
 *
 ******************************************************************************/

/* Flags for acpi_os_acquire_lock/acpi_os_release_lock */

#ifndef acpi_cpu_flags
#define acpi_cpu_flags
#endif

/* Object returned from acpi_os_create_cache */

#ifndef acpi_cache_t
#ifdef ACPI_USE_LOCAL_CACHE
#define acpi_cache_t
#else
#define acpi_cache_t
#endif
#endif

/*
 * Synchronization objects - Mutexes, Semaphores, and spin_locks
 */
#if (ACPI_MUTEX_TYPE == ACPI_BINARY_SEMAPHORE)
/*
 * These macros are used if the host OS does not support a mutex object.
 * Map the OSL Mutex interfaces to binary semaphores.
 */
#define acpi_mutex
#define acpi_os_create_mutex(out_handle)
#define acpi_os_delete_mutex(handle)
#define acpi_os_acquire_mutex(handle,time)
#define acpi_os_release_mutex(handle)
#endif

/* Configurable types for synchronization objects */

#ifndef acpi_spinlock
#define acpi_spinlock
#endif

#ifndef acpi_raw_spinlock
#define acpi_raw_spinlock
#endif

#ifndef acpi_semaphore
#define acpi_semaphore
#endif

#ifndef acpi_mutex
#define acpi_mutex
#endif

/*******************************************************************************
 *
 * Compiler-dependent types
 *
 * If the defaults below are not appropriate for the host compiler, they can
 * be defined in the compiler-specific header, and this will take precedence.
 *
 ******************************************************************************/

/* Use C99 uintptr_t for pointer casting if available, "void *" otherwise */

#ifndef acpi_uintptr_t
#define acpi_uintptr_t
#endif

/*
 * ACPI_PRINTF_LIKE is used to tag functions as "printf-like" because
 * some compilers can catch printf format string problems
 */
#ifndef ACPI_PRINTF_LIKE
#define ACPI_PRINTF_LIKE
#endif

/*
 * Some compilers complain about unused variables. Sometimes we don't want
 * to use all the variables (for example, _acpi_module_name). This allows us
 * to tell the compiler in a per-variable manner that a variable
 * is unused
 */
#ifndef ACPI_UNUSED_VAR
#define ACPI_UNUSED_VAR
#endif

/*
 * All ACPICA external functions that are available to the rest of the
 * kernel are tagged with these macros which can be defined as appropriate
 * for the host.
 *
 * Notes:
 * ACPI_EXPORT_SYMBOL_INIT is used for initialization and termination
 * interfaces that may need special processing.
 * ACPI_EXPORT_SYMBOL is used for all other public external functions.
 */
#ifndef ACPI_EXPORT_SYMBOL_INIT
#define ACPI_EXPORT_SYMBOL_INIT(symbol)
#endif

#ifndef ACPI_EXPORT_SYMBOL
#define ACPI_EXPORT_SYMBOL
#endif

/*
 * Compiler/Clibrary-dependent debug initialization. Used for ACPICA
 * utilities only.
 */
#ifndef ACPI_DEBUG_INITIALIZE
#define ACPI_DEBUG_INITIALIZE()
#endif

/*******************************************************************************
 *
 * Configuration
 *
 ******************************************************************************/

#ifdef ACPI_NO_MEM_ALLOCATIONS

#define ACPI_ALLOCATE
#define ACPI_ALLOCATE_ZEROED
#define ACPI_FREE
#define ACPI_MEM_TRACKING

#else				/* ACPI_NO_MEM_ALLOCATIONS */

#ifdef ACPI_DBG_TRACK_ALLOCATIONS
/*
 * Memory allocation tracking (used by acpi_exec to detect memory leaks)
 */
#define ACPI_MEM_PARAMETERS
#define ACPI_ALLOCATE
#define ACPI_ALLOCATE_ZEROED
#define ACPI_FREE
#define ACPI_MEM_TRACKING

#else
/*
 * Normal memory allocation directly via the OS services layer
 */
#define ACPI_ALLOCATE(a)
#define ACPI_ALLOCATE_ZEROED(a)
#define ACPI_FREE(a)
#define ACPI_MEM_TRACKING(a)

#endif				/* ACPI_DBG_TRACK_ALLOCATIONS */

#endif				/* ACPI_NO_MEM_ALLOCATIONS */

/******************************************************************************
 *
 * ACPI Specification constants (Do not change unless the specification
 * changes)
 *
 *****************************************************************************/

/* Number of distinct FADT-based GPE register blocks (GPE0 and GPE1) */

#define ACPI_MAX_GPE_BLOCKS

/* Default ACPI register widths */

#define ACPI_GPE_REGISTER_WIDTH
#define ACPI_PM1_REGISTER_WIDTH
#define ACPI_PM2_REGISTER_WIDTH
#define ACPI_PM_TIMER_WIDTH
#define ACPI_RESET_REGISTER_WIDTH

/* Names within the namespace are 4 bytes long */

#define ACPI_NAMESEG_SIZE
#define ACPI_PATH_SEGMENT_LENGTH
#define ACPI_PATH_SEPARATOR

/* Sizes for ACPI table headers */

#define ACPI_OEM_ID_SIZE
#define ACPI_OEM_TABLE_ID_SIZE

/* ACPI/PNP hardware IDs */

#define PCI_ROOT_HID_STRING
#define PCI_EXPRESS_ROOT_HID_STRING

/* PM Timer ticks per second (HZ) */

#define ACPI_PM_TIMER_FREQUENCY

/*******************************************************************************
 *
 * Independent types
 *
 ******************************************************************************/

/* Logical defines and NULL */

#ifdef FALSE
#undef FALSE
#endif
#define FALSE

#ifdef TRUE
#undef TRUE
#endif
#define TRUE

#ifndef NULL
#define NULL
#endif

/*
 * Miscellaneous types
 */
acpi_status;	/* All ACPI Exceptions */
acpi_name;		/* 4-byte ACPI name */
acpi_string;	/* Null terminated ASCII string */
acpi_handle;	/* Actually a ptr to a NS Node */

/* Time constants for timer calculations */

#define ACPI_MSEC_PER_SEC

#define ACPI_USEC_PER_MSEC
#define ACPI_USEC_PER_SEC

#define ACPI_100NSEC_PER_USEC
#define ACPI_100NSEC_PER_MSEC
#define ACPI_100NSEC_PER_SEC

#define ACPI_NSEC_PER_USEC
#define ACPI_NSEC_PER_MSEC
#define ACPI_NSEC_PER_SEC

#define ACPI_TIME_AFTER(a, b)

/* Owner IDs are used to track namespace nodes for selective deletion */

acpi_owner_id;
#define ACPI_OWNER_ID_MAX

#define ACPI_INTEGER_BIT_SIZE
#define ACPI_MAX_DECIMAL_DIGITS
#define ACPI_MAX64_DECIMAL_DIGITS
#define ACPI_MAX32_DECIMAL_DIGITS
#define ACPI_MAX16_DECIMAL_DIGITS
#define ACPI_MAX8_DECIMAL_DIGITS

/*
 * Constants with special meanings
 */
#define ACPI_ROOT_OBJECT
#define ACPI_WAIT_FOREVER
#define ACPI_DO_NOT_WAIT

/*
 * Obsolete: Acpi integer width. In ACPI version 1 (1996), integers are
 * 32 bits. In ACPI version 2 (2000) and later, integers are max 64 bits.
 * Note that this pertains to the ACPI integer type only, not to other
 * integers used in the implementation of the ACPICA subsystem.
 *
 * 01/2010: This type is obsolete and has been removed from the entire ACPICA
 * code base. It remains here for compatibility with device drivers that use
 * the type. However, it will be removed in the future.
 */
acpi_integer;
#define ACPI_INTEGER_MAX

/*******************************************************************************
 *
 * Commonly used macros
 *
 ******************************************************************************/

/* Data manipulation */

#define ACPI_LOBYTE(integer)
#define ACPI_HIBYTE(integer)
#define ACPI_LOWORD(integer)
#define ACPI_HIWORD(integer)
#define ACPI_LODWORD(integer64)
#define ACPI_HIDWORD(integer64)

#define ACPI_SET_BIT(target,bit)
#define ACPI_CLEAR_BIT(target,bit)
#define ACPI_MIN(a,b)
#define ACPI_MAX(a,b)

/* Size calculation */

#define ACPI_ARRAY_LENGTH(x)

/* Pointer manipulation */

#define ACPI_CAST_PTR(t, p)
#define ACPI_CAST_INDIRECT_PTR(t, p)
#define ACPI_ADD_PTR(t, a, b)
#define ACPI_SUB_PTR(t, a, b)
#define ACPI_PTR_DIFF(a, b)

/* Pointer/Integer type conversions */

#define ACPI_TO_POINTER(i)
#ifndef ACPI_TO_INTEGER
#define ACPI_TO_INTEGER
#endif
#ifndef ACPI_OFFSET
#define ACPI_OFFSET
#endif
#define ACPI_PTR_TO_PHYSADDR(i)

/* Optimizations for 4-character (32-bit) acpi_name manipulation */

#ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
#define ACPI_COMPARE_NAMESEG(a,b)
#define ACPI_COPY_NAMESEG(dest,src)
#else
#define ACPI_COMPARE_NAMESEG
#define ACPI_COPY_NAMESEG
#endif

/* Support for the special RSDP signature (8 characters) */

#define ACPI_VALIDATE_RSDP_SIG(a)
#define ACPI_MAKE_RSDP_SIG(dest)

/* Support for OEMx signature (x can be any character) */
#define ACPI_IS_OEM_SIG(a)

/*
 * Algorithm to obtain access bit or byte width.
 * Can be used with access_width of struct acpi_generic_address and access_size of
 * struct acpi_resource_generic_register.
 */
#define ACPI_ACCESS_BIT_SHIFT
#define ACPI_ACCESS_BYTE_SHIFT
#define ACPI_ACCESS_BIT_MAX
#define ACPI_ACCESS_BYTE_MAX
#define ACPI_ACCESS_BIT_DEFAULT
#define ACPI_ACCESS_BYTE_DEFAULT
#define ACPI_ACCESS_BIT_WIDTH(size)
#define ACPI_ACCESS_BYTE_WIDTH(size)

/*******************************************************************************
 *
 * Miscellaneous constants
 *
 ******************************************************************************/

/*
 * Initialization sequence options
 */
#define ACPI_FULL_INITIALIZATION
#define ACPI_NO_FACS_INIT
#define ACPI_NO_ACPI_ENABLE
#define ACPI_NO_HARDWARE_INIT
#define ACPI_NO_EVENT_INIT
#define ACPI_NO_HANDLER_INIT
#define ACPI_NO_OBJECT_INIT
#define ACPI_NO_DEVICE_INIT
#define ACPI_NO_ADDRESS_SPACE_INIT

/*
 * Initialization state
 */
#define ACPI_SUBSYSTEM_INITIALIZE
#define ACPI_INITIALIZED_OK

/*
 * Power state values
 */
#define ACPI_STATE_UNKNOWN

#define ACPI_STATE_S0
#define ACPI_STATE_S1
#define ACPI_STATE_S2
#define ACPI_STATE_S3
#define ACPI_STATE_S4
#define ACPI_STATE_S5
#define ACPI_S_STATES_MAX
#define ACPI_S_STATE_COUNT

#define ACPI_STATE_D0
#define ACPI_STATE_D1
#define ACPI_STATE_D2
#define ACPI_STATE_D3_HOT
#define ACPI_STATE_D3
#define ACPI_STATE_D3_COLD
#define ACPI_D_STATES_MAX
#define ACPI_D_STATE_COUNT

#define ACPI_STATE_C0
#define ACPI_STATE_C1
#define ACPI_STATE_C2
#define ACPI_STATE_C3
#define ACPI_C_STATES_MAX
#define ACPI_C_STATE_COUNT

/*
 * Sleep type invalid value
 */
#define ACPI_SLEEP_TYPE_MAX
#define ACPI_SLEEP_TYPE_INVALID

/*
 * Standard notify values
 */
#define ACPI_NOTIFY_BUS_CHECK
#define ACPI_NOTIFY_DEVICE_CHECK
#define ACPI_NOTIFY_DEVICE_WAKE
#define ACPI_NOTIFY_EJECT_REQUEST
#define ACPI_NOTIFY_DEVICE_CHECK_LIGHT
#define ACPI_NOTIFY_FREQUENCY_MISMATCH
#define ACPI_NOTIFY_BUS_MODE_MISMATCH
#define ACPI_NOTIFY_POWER_FAULT
#define ACPI_NOTIFY_CAPABILITIES_CHECK
#define ACPI_NOTIFY_DEVICE_PLD_CHECK
#define ACPI_NOTIFY_RESERVED
#define ACPI_NOTIFY_LOCALITY_UPDATE
#define ACPI_NOTIFY_SHUTDOWN_REQUEST
#define ACPI_NOTIFY_AFFINITY_UPDATE
#define ACPI_NOTIFY_MEMORY_UPDATE
#define ACPI_NOTIFY_DISCONNECT_RECOVER

#define ACPI_GENERIC_NOTIFY_MAX
#define ACPI_SPECIFIC_NOTIFY_MAX

/*
 * Types associated with ACPI names and objects. The first group of
 * values (up to ACPI_TYPE_EXTERNAL_MAX) correspond to the definition
 * of the ACPI object_type() operator (See the ACPI Spec). Therefore,
 * only add to the first group if the spec changes.
 *
 * NOTE: Types must be kept in sync with the global acpi_ns_properties
 * and acpi_ns_type_names arrays.
 */
acpi_object_type;

#define ACPI_TYPE_ANY
#define ACPI_TYPE_INTEGER
#define ACPI_TYPE_STRING
#define ACPI_TYPE_BUFFER
#define ACPI_TYPE_PACKAGE
#define ACPI_TYPE_FIELD_UNIT
#define ACPI_TYPE_DEVICE
#define ACPI_TYPE_EVENT
#define ACPI_TYPE_METHOD
#define ACPI_TYPE_MUTEX
#define ACPI_TYPE_REGION
#define ACPI_TYPE_POWER
#define ACPI_TYPE_PROCESSOR
#define ACPI_TYPE_THERMAL
#define ACPI_TYPE_BUFFER_FIELD
#define ACPI_TYPE_DDB_HANDLE
#define ACPI_TYPE_DEBUG_OBJECT

#define ACPI_TYPE_EXTERNAL_MAX
#define ACPI_NUM_TYPES

/*
 * These are object types that do not map directly to the ACPI
 * object_type() operator. They are used for various internal purposes
 * only. If new predefined ACPI_TYPEs are added (via the ACPI
 * specification), these internal types must move upwards. (There
 * is code that depends on these values being contiguous with the
 * external types above.)
 */
#define ACPI_TYPE_LOCAL_REGION_FIELD
#define ACPI_TYPE_LOCAL_BANK_FIELD
#define ACPI_TYPE_LOCAL_INDEX_FIELD
#define ACPI_TYPE_LOCAL_REFERENCE
#define ACPI_TYPE_LOCAL_ALIAS
#define ACPI_TYPE_LOCAL_METHOD_ALIAS
#define ACPI_TYPE_LOCAL_NOTIFY
#define ACPI_TYPE_LOCAL_ADDRESS_HANDLER
#define ACPI_TYPE_LOCAL_RESOURCE
#define ACPI_TYPE_LOCAL_RESOURCE_FIELD
#define ACPI_TYPE_LOCAL_SCOPE

#define ACPI_TYPE_NS_NODE_MAX
#define ACPI_TOTAL_TYPES

/*
 * These are special object types that never appear in
 * a Namespace node, only in an object of union acpi_operand_object
 */
#define ACPI_TYPE_LOCAL_EXTRA
#define ACPI_TYPE_LOCAL_DATA

#define ACPI_TYPE_LOCAL_MAX

/* All types above here are invalid */

#define ACPI_TYPE_INVALID
#define ACPI_TYPE_NOT_FOUND

#define ACPI_NUM_NS_TYPES

/*
 * All I/O
 */
#define ACPI_READ
#define ACPI_WRITE
#define ACPI_IO_MASK

/*
 * Event Types: Fixed & General Purpose
 */
acpi_event_type;

/*
 * Fixed events
 */
#define ACPI_EVENT_PMTIMER
#define ACPI_EVENT_GLOBAL
#define ACPI_EVENT_POWER_BUTTON
#define ACPI_EVENT_SLEEP_BUTTON
#define ACPI_EVENT_RTC
#define ACPI_EVENT_MAX
#define ACPI_NUM_FIXED_EVENTS

/*
 * Event status - Per event
 * -------------
 * The encoding of acpi_event_status is illustrated below.
 * Note that a set bit (1) indicates the property is TRUE
 * (e.g. if bit 0 is set then the event is enabled).
 * +-------------+-+-+-+-+-+-+
 * |   Bits 31:6 |5|4|3|2|1|0|
 * +-------------+-+-+-+-+-+-+
 *          |     | | | | | |
 *          |     | | | | | +- Enabled?
 *          |     | | | | +--- Enabled for wake?
 *          |     | | | +----- Status bit set?
 *          |     | | +------- Enable bit set?
 *          |     | +--------- Has a handler?
 *          |     +----------- Masked?
 *          +----------------- <Reserved>
 */
acpi_event_status;

#define ACPI_EVENT_FLAG_DISABLED
#define ACPI_EVENT_FLAG_ENABLED
#define ACPI_EVENT_FLAG_WAKE_ENABLED
#define ACPI_EVENT_FLAG_STATUS_SET
#define ACPI_EVENT_FLAG_ENABLE_SET
#define ACPI_EVENT_FLAG_HAS_HANDLER
#define ACPI_EVENT_FLAG_MASKED
#define ACPI_EVENT_FLAG_SET

/* Actions for acpi_set_gpe, acpi_gpe_wakeup, acpi_hw_low_set_gpe */

#define ACPI_GPE_ENABLE
#define ACPI_GPE_DISABLE
#define ACPI_GPE_CONDITIONAL_ENABLE

/*
 * GPE info flags - Per GPE
 * +---+-+-+-+---+
 * |7:6|5|4|3|2:0|
 * +---+-+-+-+---+
 *   |  | | |  |
 *   |  | | |  +-- Type of dispatch:to method, handler, notify, or none
 *   |  | | +----- Interrupt type: edge or level triggered
 *   |  | +------- Is a Wake GPE
 *   |  +--------- Has been enabled automatically at init time
 *   +------------ <Reserved>
 */
#define ACPI_GPE_DISPATCH_NONE
#define ACPI_GPE_DISPATCH_METHOD
#define ACPI_GPE_DISPATCH_HANDLER
#define ACPI_GPE_DISPATCH_NOTIFY
#define ACPI_GPE_DISPATCH_RAW_HANDLER
#define ACPI_GPE_DISPATCH_MASK
#define ACPI_GPE_DISPATCH_TYPE(flags)

#define ACPI_GPE_LEVEL_TRIGGERED
#define ACPI_GPE_EDGE_TRIGGERED
#define ACPI_GPE_XRUPT_TYPE_MASK

#define ACPI_GPE_CAN_WAKE
#define ACPI_GPE_AUTO_ENABLED
#define ACPI_GPE_INITIALIZED

/*
 * Flags for GPE and Lock interfaces
 */
#define ACPI_NOT_ISR
#define ACPI_ISR

/* Notify types */

#define ACPI_SYSTEM_NOTIFY
#define ACPI_DEVICE_NOTIFY
#define ACPI_ALL_NOTIFY
#define ACPI_MAX_NOTIFY_HANDLER_TYPE
#define ACPI_NUM_NOTIFY_TYPES

#define ACPI_MAX_SYS_NOTIFY
#define ACPI_MAX_DEVICE_SPECIFIC_NOTIFY

#define ACPI_SYSTEM_HANDLER_LIST
#define ACPI_DEVICE_HANDLER_LIST

/* Address Space (Operation Region) Types */

acpi_adr_space_type;

#define ACPI_ADR_SPACE_SYSTEM_MEMORY
#define ACPI_ADR_SPACE_SYSTEM_IO
#define ACPI_ADR_SPACE_PCI_CONFIG
#define ACPI_ADR_SPACE_EC
#define ACPI_ADR_SPACE_SMBUS
#define ACPI_ADR_SPACE_CMOS
#define ACPI_ADR_SPACE_PCI_BAR_TARGET
#define ACPI_ADR_SPACE_IPMI
#define ACPI_ADR_SPACE_GPIO
#define ACPI_ADR_SPACE_GSBUS
#define ACPI_ADR_SPACE_PLATFORM_COMM
#define ACPI_ADR_SPACE_PLATFORM_RT

#define ACPI_NUM_PREDEFINED_REGIONS

/*
 * Special Address Spaces
 *
 * Note: A Data Table region is a special type of operation region
 * that has its own AML opcode. However, internally, the AML
 * interpreter simply creates an operation region with an address
 * space type of ACPI_ADR_SPACE_DATA_TABLE.
 */
#define ACPI_ADR_SPACE_DATA_TABLE
#define ACPI_ADR_SPACE_FIXED_HARDWARE

/* Values for _REG connection code */

#define ACPI_REG_DISCONNECT
#define ACPI_REG_CONNECT

/*
 * bit_register IDs
 *
 * These values are intended to be used by the hardware interfaces
 * and are mapped to individual bitfields defined within the ACPI
 * registers. See the acpi_gbl_bit_register_info global table in utglobal.c
 * for this mapping.
 */

/* PM1 Status register */

#define ACPI_BITREG_TIMER_STATUS
#define ACPI_BITREG_BUS_MASTER_STATUS
#define ACPI_BITREG_GLOBAL_LOCK_STATUS
#define ACPI_BITREG_POWER_BUTTON_STATUS
#define ACPI_BITREG_SLEEP_BUTTON_STATUS
#define ACPI_BITREG_RT_CLOCK_STATUS
#define ACPI_BITREG_WAKE_STATUS
#define ACPI_BITREG_PCIEXP_WAKE_STATUS

/* PM1 Enable register */

#define ACPI_BITREG_TIMER_ENABLE
#define ACPI_BITREG_GLOBAL_LOCK_ENABLE
#define ACPI_BITREG_POWER_BUTTON_ENABLE
#define ACPI_BITREG_SLEEP_BUTTON_ENABLE
#define ACPI_BITREG_RT_CLOCK_ENABLE
#define ACPI_BITREG_PCIEXP_WAKE_DISABLE

/* PM1 Control register */

#define ACPI_BITREG_SCI_ENABLE
#define ACPI_BITREG_BUS_MASTER_RLD
#define ACPI_BITREG_GLOBAL_LOCK_RELEASE
#define ACPI_BITREG_SLEEP_TYPE
#define ACPI_BITREG_SLEEP_ENABLE

/* PM2 Control register */

#define ACPI_BITREG_ARB_DISABLE

#define ACPI_BITREG_MAX
#define ACPI_NUM_BITREG

/* Status register values. A 1 clears a status bit. 0 = no effect */

#define ACPI_CLEAR_STATUS

/* Enable and Control register values */

#define ACPI_ENABLE_EVENT
#define ACPI_DISABLE_EVENT

/*
 * External ACPI object definition
 */

/*
 * Note: Type == ACPI_TYPE_ANY (0) is used to indicate a NULL package
 * element or an unresolved named reference.
 */
acpi_object;

/*
 * List of objects, used as a parameter list for control method evaluation
 */
struct acpi_object_list {};

/*
 * Miscellaneous common Data Structures used by the interfaces
 */
#define ACPI_NO_BUFFER

#ifdef ACPI_NO_MEM_ALLOCATIONS

#define ACPI_ALLOCATE_BUFFER
#define ACPI_ALLOCATE_LOCAL_BUFFER

#else				/* ACPI_NO_MEM_ALLOCATIONS */

#define ACPI_ALLOCATE_BUFFER
#define ACPI_ALLOCATE_LOCAL_BUFFER

#endif				/* ACPI_NO_MEM_ALLOCATIONS */

struct acpi_buffer {};

/*
 * name_type for acpi_get_name
 */
#define ACPI_FULL_PATHNAME
#define ACPI_SINGLE_NAME
#define ACPI_FULL_PATHNAME_NO_TRAILING
#define ACPI_NAME_TYPE_MAX

/*
 * Predefined Namespace items
 */
struct acpi_predefined_names {};

/*
 * Structure and flags for acpi_get_system_info
 */
#define ACPI_SYS_MODE_UNKNOWN
#define ACPI_SYS_MODE_ACPI
#define ACPI_SYS_MODE_LEGACY
#define ACPI_SYS_MODES_MASK

/*
 * System info returned by acpi_get_system_info()
 */
struct acpi_system_info {};

/*
 * System statistics returned by acpi_get_statistics()
 */
struct acpi_statistics {};

/*
 * Types specific to the OS service interfaces
 */
acpi_osd_handler;

acpi_osd_exec_callback;

/*
 * Various handlers and callback procedures
 */
acpi_sci_handler;

acpi_gbl_event_handler;

#define ACPI_EVENT_TYPE_GPE
#define ACPI_EVENT_TYPE_FIXED

acpi_event_handler;

acpi_gpe_handler;

acpi_notify_handler;

acpi_object_handler;

acpi_init_handler;

#define ACPI_INIT_DEVICE_INI

acpi_exception_handler;

/* Table Event handler (Load, load_table, etc.) and types */

acpi_table_handler;

/* Table Event Types */

#define ACPI_TABLE_EVENT_LOAD
#define ACPI_TABLE_EVENT_UNLOAD
#define ACPI_TABLE_EVENT_INSTALL
#define ACPI_TABLE_EVENT_UNINSTALL
#define ACPI_NUM_TABLE_EVENTS

/* Address Spaces (For Operation Regions) */

acpi_adr_space_handler;

#define ACPI_DEFAULT_HANDLER

/* Special Context data for generic_serial_bus/general_purpose_io (ACPI 5.0) */

struct acpi_connection_info {};

/* Special Context data for PCC Opregion (ACPI 6.3) */

struct acpi_pcc_info {};

/* Special Context data for FFH Opregion (ACPI 6.5) */

struct acpi_ffh_info {};

acpi_adr_space_setup;

#define ACPI_REGION_ACTIVATE
#define ACPI_REGION_DEACTIVATE

acpi_walk_callback;

acpi_interface_handler;

/* Interrupt handler return values */

#define ACPI_INTERRUPT_NOT_HANDLED
#define ACPI_INTERRUPT_HANDLED

/* GPE handler return values */

#define ACPI_REENABLE_GPE

/* Length of 32-bit EISAID values when converted back to a string */

#define ACPI_EISAID_STRING_SIZE

/* Length of UUID (string) values */

#define ACPI_UUID_LENGTH

/* Length of 3-byte PCI class code values when converted back to a string */

#define ACPI_PCICLS_STRING_SIZE

/* Structures used for device/processor HID, UID, CID */

struct acpi_pnp_device_id {};

struct acpi_pnp_device_id_list {};

/*
 * Structure returned from acpi_get_object_info.
 * Optimized for both 32-bit and 64-bit builds.
 */
struct acpi_device_info {};

/* Values for Flags field above (acpi_get_object_info) */

#define ACPI_PCI_ROOT_BRIDGE

/* Flags for Valid field above (acpi_get_object_info) */

#define ACPI_VALID_ADR
#define ACPI_VALID_HID
#define ACPI_VALID_UID
#define ACPI_VALID_CID
#define ACPI_VALID_CLS
#define ACPI_VALID_SXDS
#define ACPI_VALID_SXWS

/* Flags for _STA method */

#define ACPI_STA_DEVICE_PRESENT
#define ACPI_STA_DEVICE_ENABLED
#define ACPI_STA_DEVICE_UI
#define ACPI_STA_DEVICE_FUNCTIONING
#define ACPI_STA_DEVICE_OK
#define ACPI_STA_BATTERY_PRESENT

/* Context structs for address space handlers */

struct acpi_pci_id {};

struct acpi_mem_mapping {};

struct acpi_mem_space_context {};

struct acpi_data_table_mapping {};

/*
 * struct acpi_memory_list is used only if the ACPICA local cache is enabled
 */
struct acpi_memory_list {};

/* Definitions of trace event types */

acpi_trace_event_type;

/* Definitions of _OSI support */

#define ACPI_VENDOR_STRINGS
#define ACPI_FEATURE_STRINGS
#define ACPI_ENABLE_INTERFACES
#define ACPI_DISABLE_INTERFACES

#define ACPI_DISABLE_ALL_VENDOR_STRINGS
#define ACPI_DISABLE_ALL_FEATURE_STRINGS
#define ACPI_DISABLE_ALL_STRINGS
#define ACPI_ENABLE_ALL_VENDOR_STRINGS
#define ACPI_ENABLE_ALL_FEATURE_STRINGS
#define ACPI_ENABLE_ALL_STRINGS

#define ACPI_OSI_WIN_2000
#define ACPI_OSI_WIN_XP
#define ACPI_OSI_WIN_XP_SP1
#define ACPI_OSI_WINSRV_2003
#define ACPI_OSI_WIN_XP_SP2
#define ACPI_OSI_WINSRV_2003_SP1
#define ACPI_OSI_WIN_VISTA
#define ACPI_OSI_WINSRV_2008
#define ACPI_OSI_WIN_VISTA_SP1
#define ACPI_OSI_WIN_VISTA_SP2
#define ACPI_OSI_WIN_7
#define ACPI_OSI_WIN_8
#define ACPI_OSI_WIN_8_1
#define ACPI_OSI_WIN_10
#define ACPI_OSI_WIN_10_RS1
#define ACPI_OSI_WIN_10_RS2
#define ACPI_OSI_WIN_10_RS3
#define ACPI_OSI_WIN_10_RS4
#define ACPI_OSI_WIN_10_RS5
#define ACPI_OSI_WIN_10_19H1
#define ACPI_OSI_WIN_10_20H1
#define ACPI_OSI_WIN_11
#define ACPI_OSI_WIN_11_22H2

/* Definitions of getopt */

#define ACPI_OPT_END

/* Definitions for explicit fallthrough */

#ifndef ACPI_FALLTHROUGH
#define ACPI_FALLTHROUGH
#endif

#ifndef ACPI_FLEX_ARRAY
#define ACPI_FLEX_ARRAY
#endif

#endif				/* __ACTYPES_H__ */