/****************************************************************************** * * Name: actypes.h - Common data types for the entire ACPI subsystem * *****************************************************************************/ /* * Copyright (C) 2000 - 2011, Intel Corp. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions, and the following disclaimer, *    without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer *    substantially similar to the "NO WARRANTY" disclaimer below *    ("Disclaimer") and any redistribution must be conditioned upon *    including a substantially similar Disclaimer requirement for further *    binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names *    of any contributors may be used to endorse or promote products derived *    from this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #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 /*! [Begin] no source code translation */ /* * 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                  (UINT8) (~((UINT8)  0))	/* 0xFF               */#define ACPI_UINT16_MAX                 (UINT16)(~((UINT16) 0))	/* 0xFFFF             */#define ACPI_UINT32_MAX                 (UINT32)(~((UINT32) 0))	/* 0xFFFFFFFF         */#define ACPI_UINT64_MAX                 (UINT64)(~((UINT64) 0))	/* 0xFFFFFFFFFFFFFFFF */#define ACPI_ASCII_MAX                  0x7F /* * 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): * * BOOLEAN      Logical boolean * * UINT8        8-bit  (1 byte) unsigned value * UINT16       16-bit (2 byte) unsigned value * UINT32       32-bit (4 byte) unsigned value * UINT64       64-bit (8 byte) unsigned value * * INT16        16-bit (2 byte) signed value * INT32        32-bit (4 byte) signed value * INT64        64-bit (8 byte) signed value * * COMPILER_DEPENDENT_UINT64/INT64 - 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 * ******************************************************************************/ typedef unsigned char BOOLEAN;typedef unsigned char UINT8;typedef unsigned short UINT16;typedef COMPILER_DEPENDENT_UINT64 UINT64;typedef COMPILER_DEPENDENT_INT64 INT64; /*! [End] no source code translation !*/ /* * 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                  u64 /******************************************************************************* * * Types specific to 64-bit targets * ******************************************************************************/ #if ACPI_MACHINE_WIDTH == 64 /*! [Begin] no source code translation (keep the typedefs as-is) */ typedef unsigned int UINT32;typedef int INT32; /*! [End] no source code translation !*/ typedef s64 acpi_native_int; typedef u64 acpi_size;typedef u64 acpi_io_address;typedef u64 acpi_physical_address; #define ACPI_MAX_PTR                    ACPI_UINT64_MAX#define ACPI_SIZE_MAX                   ACPI_UINT64_MAX #define ACPI_USE_NATIVE_DIVIDE	/* Has native 64-bit integer support */ /* * 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: Em64_t 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 /*! [Begin] no source code translation (keep the typedefs as-is) */ typedef unsigned int UINT32;typedef int INT32; /*! [End] no source code translation !*/ typedef s32 acpi_native_int; typedef u32 acpi_size;typedef u32 acpi_io_address;typedef u32 acpi_physical_address; #define ACPI_MAX_PTR                    ACPI_UINT32_MAX#define ACPI_SIZE_MAX                   ACPI_UINT32_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			acpi_size#endif /* Object returned from acpi_os_create_cache */ #ifndef acpi_cache_t#ifdef ACPI_USE_LOCAL_CACHE#define acpi_cache_t                    struct acpi_memory_list#else#define acpi_cache_t                    void *#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                      acpi_semaphore#define acpi_os_create_mutex(out_handle) acpi_os_create_semaphore (1, 1, out_handle)#define acpi_os_delete_mutex(handle)    (void) acpi_os_delete_semaphore (handle)#define acpi_os_acquire_mutex(handle,time) acpi_os_wait_semaphore (handle, 1, time)#define acpi_os_release_mutex(handle)   (void) acpi_os_signal_semaphore (handle, 1)#endif /* Configurable types for synchronization objects */ #ifndef acpi_spinlock#define acpi_spinlock                   void *#endif #ifndef acpi_semaphore#define acpi_semaphore                  void *#endif #ifndef acpi_mutex#define acpi_mutex                      void *#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                  void *#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(c)#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 functions that are available to the rest of the kernel are * tagged with this macro which can be defined as appropriate for the host. */#ifndef ACPI_EXPORT_SYMBOL#define ACPI_EXPORT_SYMBOL(symbol)#endif /****************************************************************************** * * 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             2 /* Default ACPI register widths */ #define ACPI_GPE_REGISTER_WIDTH         8#define ACPI_PM1_REGISTER_WIDTH         16#define ACPI_PM2_REGISTER_WIDTH         8#define ACPI_PM_TIMER_WIDTH             32 /* Names within the namespace are 4 bytes long */ #define ACPI_NAME_SIZE                  4#define ACPI_PATH_SEGMENT_LENGTH        5	/* 4 chars for name + 1 char for separator */#define ACPI_PATH_SEPARATOR             '.' /* Sizes for ACPI table headers */ #define ACPI_OEM_ID_SIZE                6#define ACPI_OEM_TABLE_ID_SIZE          8 /* ACPI/PNP hardware IDs */ #define PCI_ROOT_HID_STRING             "PNP0A03"#define PCI_EXPRESS_ROOT_HID_STRING     "PNP0A08" /* PM Timer ticks per second (HZ) */ #define PM_TIMER_FREQUENCY              3579545 /******************************************************************************* * * Independent types * ******************************************************************************/ /* Logical defines and NULL */ #ifdef FALSE#undef FALSE#endif#define FALSE                           (1 == 0) #ifdef TRUE#undef TRUE#endif#define TRUE                            (1 == 1) #ifndef NULL#define NULL                            (void *) 0#endif /* * Miscellaneous types */typedef u32 acpi_status;	/* All ACPI Exceptions */typedef u32 acpi_name;		/* 4-byte ACPI name */typedef char *acpi_string;	/* Null terminated ASCII string */typedef void *acpi_handle;	/* Actually a ptr to a NS Node */ /* Owner IDs are used to track namespace nodes for selective deletion */ typedef u8 acpi_owner_id;#define ACPI_OWNER_ID_MAX               0xFF #define ACPI_INTEGER_BIT_SIZE           64#define ACPI_MAX_DECIMAL_DIGITS         20	/* 2^64 = 18,446,744,073,709,551,616 */ #if ACPI_MACHINE_WIDTH == 64#define ACPI_USE_NATIVE_DIVIDE	/* Use compiler native 64-bit divide */#endif #define ACPI_MAX64_DECIMAL_DIGITS       20#define ACPI_MAX32_DECIMAL_DIGITS       10#define ACPI_MAX16_DECIMAL_DIGITS        5#define ACPI_MAX8_DECIMAL_DIGITS         3 /* PM Timer ticks per second (HZ) */ #define PM_TIMER_FREQUENCY  3579545 /* * Constants with special meanings */#define ACPI_ROOT_OBJECT                ACPI_ADD_PTR (acpi_handle, NULL, ACPI_MAX_PTR)#define ACPI_WAIT_FOREVER               0xFFFF	/* u16, as per ACPI spec */#define ACPI_DO_NOT_WAIT                0 /* * Obsolete: Acpi integer width. In ACPI version 1 (1996), integers are 32 bits. * In ACPI version 2 (2000) and later, integers are 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. */typedef u64 acpi_integer;#define ACPI_INTEGER_MAX                ACPI_UINT64_MAX /******************************************************************************* * * Commonly used macros * ******************************************************************************/ /* Data manipulation */ #define ACPI_LOBYTE(integer)            ((u8)   (u16)(integer))#define ACPI_HIBYTE(integer)            ((u8) (((u16)(integer)) >> 8))#define ACPI_LOWORD(integer)            ((u16)  (u32)(integer))#define ACPI_HIWORD(integer)            ((u16)(((u32)(integer)) >> 16))#define ACPI_LODWORD(integer64)         ((u32)  (u64)(integer64))#define ACPI_HIDWORD(integer64)         ((u32)(((u64)(integer64)) >> 32)) #define ACPI_SET_BIT(target,bit)        ((target) |= (bit))#define ACPI_CLEAR_BIT(target,bit)      ((target) &= ~(bit))#define ACPI_MIN(a,b)                   (((a)<(b))?(a):(b))#define ACPI_MAX(a,b)                   (((a)>(b))?(a):(b)) /* Size calculation */ #define ACPI_ARRAY_LENGTH(x)            (sizeof(x) / sizeof((x)[0])) /* Pointer manipulation */ #define ACPI_CAST_PTR(t, p)             ((t *) (acpi_uintptr_t) (p))#define ACPI_CAST_INDIRECT_PTR(t, p)    ((t **) (acpi_uintptr_t) (p))#define ACPI_ADD_PTR(t, a, b)           ACPI_CAST_PTR (t, (ACPI_CAST_PTR (u8, (a)) + (acpi_size)(b)))#define ACPI_PTR_DIFF(a, b)             (acpi_size) (ACPI_CAST_PTR (u8, (a)) - ACPI_CAST_PTR (u8, (b))) /* Pointer/Integer type conversions */ #define ACPI_TO_POINTER(i)              ACPI_ADD_PTR (void, (void *) NULL,(acpi_size) i)#define ACPI_TO_INTEGER(p)              ACPI_PTR_DIFF (p, (void *) NULL)#define ACPI_OFFSET(d, f)               (acpi_size) ACPI_PTR_DIFF (&(((d *)0)->f), (void *) NULL)#define ACPI_PHYSADDR_TO_PTR(i)         ACPI_TO_POINTER(i)#define ACPI_PTR_TO_PHYSADDR(i)         ACPI_TO_INTEGER(i) #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED#define ACPI_COMPARE_NAME(a,b)          (*ACPI_CAST_PTR (u32, (a)) == *ACPI_CAST_PTR (u32, (b)))#else#define ACPI_COMPARE_NAME(a,b)          (!ACPI_STRNCMP (ACPI_CAST_PTR (char, (a)), ACPI_CAST_PTR (char, (b)), ACPI_NAME_SIZE))#endif /******************************************************************************* * * Miscellaneous constants * ******************************************************************************/ /* * Initialization sequence */#define ACPI_FULL_INITIALIZATION        0x00#define ACPI_NO_ADDRESS_SPACE_INIT      0x01#define ACPI_NO_EVENT_INIT              0x04#define ACPI_NO_HANDLER_INIT            0x08#define ACPI_NO_ACPI_ENABLE             0x10#define ACPI_NO_DEVICE_INIT             0x20#define ACPI_NO_OBJECT_INIT             0x40 /* * Initialization state */#define ACPI_SUBSYSTEM_INITIALIZE       0x01#define ACPI_INITIALIZED_OK             0x02 /* * Power state values */#define ACPI_STATE_UNKNOWN              (u8) 0xFF #define ACPI_STATE_S0                   (u8) 0#define ACPI_STATE_S1                   (u8) 1#define ACPI_STATE_S2                   (u8) 2#define ACPI_STATE_S3                   (u8) 3#define ACPI_STATE_S4                   (u8) 4#define ACPI_STATE_S5                   (u8) 5#define ACPI_S_STATES_MAX               ACPI_STATE_S5#define ACPI_S_STATE_COUNT              6 #define ACPI_STATE_D0                   (u8) 0#define ACPI_STATE_D1                   (u8) 1

Lines 1–500 of 1092. Load more