acmacros.h revision 193267
1119895Sanholt/****************************************************************************** 2152909Sanholt * 3152909Sanholt * Name: acmacros.h - C macros for the entire subsystem. 4119895Sanholt * 5119895Sanholt *****************************************************************************/ 6119895Sanholt 7119895Sanholt/****************************************************************************** 8119895Sanholt * 9119895Sanholt * 1. Copyright Notice 10119895Sanholt * 11119895Sanholt * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 12119895Sanholt * All rights reserved. 13145132Sanholt * 14119895Sanholt * 2. License 15119895Sanholt * 16119895Sanholt * 2.1. This is your license from Intel Corp. under its intellectual property 17145132Sanholt * rights. You may have additional license terms from the party that provided 18119895Sanholt * you this software, covering your right to use that party's intellectual 19119895Sanholt * property rights. 20119895Sanholt * 21119895Sanholt * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22119895Sanholt * copy of the source code appearing in this file ("Covered Code") an 23119895Sanholt * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24119895Sanholt * base code distributed originally by Intel ("Original Intel Code") to copy, 25145132Sanholt * make derivatives, distribute, use and display any portion of the Covered 26119895Sanholt * Code in any form, with the right to sublicense such rights; and 27119895Sanholt * 28145132Sanholt * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29119895Sanholt * license (with the right to sublicense), under only those claims of Intel 30119895Sanholt * patents that are infringed by the Original Intel Code, to make, use, sell, 31152909Sanholt * offer to sell, and import the Covered Code and derivative works thereof 32152909Sanholt * solely to the minimum extent necessary to exercise the above copyright 33152909Sanholt * license, and in no event shall the patent license extend to any additions 34119895Sanholt * to or modifications of the Original Intel Code. No other license or right 35119895Sanholt * is granted directly or by implication, estoppel or otherwise; 36119895Sanholt * 37119895Sanholt * The above copyright and patent license is granted only if the following 38119895Sanholt * conditions are met: 39119895Sanholt * 40119895Sanholt * 3. Conditions 41119895Sanholt * 42119895Sanholt * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43119895Sanholt * Redistribution of source code of any substantial portion of the Covered 44119895Sanholt * Code or modification with rights to further distribute source must include 45119895Sanholt * the above Copyright Notice, the above License, this list of Conditions, 46119895Sanholt * and the following Disclaimer and Export Compliance provision. In addition, 47145132Sanholt * Licensee must cause all Covered Code to which Licensee contributes to 48119895Sanholt * contain a file documenting the changes Licensee made to create that Covered 49119895Sanholt * Code and the date of any change. Licensee must include in that file the 50145132Sanholt * documentation of any changes made by any predecessor Licensee. Licensee 51119895Sanholt * must include a prominent statement that the modification is derived, 52119895Sanholt * directly or indirectly, from Original Intel Code. 53145132Sanholt * 54119895Sanholt * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55119895Sanholt * Redistribution of source code of any substantial portion of the Covered 56119895Sanholt * Code or modification without rights to further distribute source must 57119895Sanholt * include the following Disclaimer and Export Compliance provision in the 58119895Sanholt * documentation and/or other materials provided with distribution. In 59119895Sanholt * addition, Licensee may not authorize further sublicense of source of any 60119895Sanholt * portion of the Covered Code, and must include terms to the effect that the 61145132Sanholt * license from Licensee to its licensee is limited to the intellectual 62119895Sanholt * property embodied in the software Licensee provides to its licensee, and 63119895Sanholt * not to intellectual property embodied in modifications its licensee may 64145132Sanholt * make. 65119895Sanholt * 66119895Sanholt * 3.3. Redistribution of Executable. Redistribution in executable form of any 67119895Sanholt * substantial portion of the Covered Code or modification must reproduce the 68119895Sanholt * above Copyright Notice, and the following Disclaimer and Export Compliance 69119895Sanholt * provision in the documentation and/or other materials provided with the 70119895Sanholt * distribution. 71119895Sanholt * 72119895Sanholt * 3.4. Intel retains all right, title, and interest in and to the Original 73145132Sanholt * Intel Code. 74145132Sanholt * 75119895Sanholt * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76119895Sanholt * Intel shall be used in advertising or otherwise to promote the sale, use or 77119895Sanholt * other dealings in products derived from or relating to the Covered Code 78119895Sanholt * without prior written authorization from Intel. 79145132Sanholt * 80119895Sanholt * 4. Disclaimer and Export Compliance 81119895Sanholt * 82145132Sanholt * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83119895Sanholt * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84119895Sanholt * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85119895Sanholt * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86119895Sanholt * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87119895Sanholt * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88119895Sanholt * PARTICULAR PURPOSE. 89119895Sanholt * 90119895Sanholt * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91119895Sanholt * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92119895Sanholt * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93119895Sanholt * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94119895Sanholt * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95119895Sanholt * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96119895Sanholt * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97119895Sanholt * LIMITED REMEDY. 98119895Sanholt * 99119895Sanholt * 4.3. Licensee shall not export, either directly or indirectly, any of this 100119895Sanholt * software or system incorporating such software without first obtaining any 101119895Sanholt * required license or other approval from the U. S. Department of Commerce or 102119895Sanholt * any other agency or department of the United States Government. In the 103119895Sanholt * event Licensee exports any such software from the United States or 104119895Sanholt * re-exports any such software from a foreign destination, Licensee shall 105119895Sanholt * ensure that the distribution and export/re-export of the software is in 106119895Sanholt * compliance with all laws, regulations, orders, or other restrictions of the 107119895Sanholt * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108119895Sanholt * any of its subsidiaries will export/re-export any technical data, process, 109145132Sanholt * software, or service, directly or indirectly, to any country for which the 110119895Sanholt * United States government or any agency thereof requires an export license, 111119895Sanholt * other governmental approval, or letter of assurance, without first obtaining 112119895Sanholt * such license, approval or letter. 113119895Sanholt * 114119895Sanholt *****************************************************************************/ 115119895Sanholt 116119895Sanholt#ifndef __ACMACROS_H__ 117119895Sanholt#define __ACMACROS_H__ 118119895Sanholt 119119895Sanholt 120145132Sanholt/* 121119895Sanholt * Extract data using a pointer. Any more than a byte and we 122119895Sanholt * get into potential aligment issues -- see the STORE macros below. 123119895Sanholt * Use with care. 124119895Sanholt */ 125119895Sanholt#define ACPI_GET8(ptr) *ACPI_CAST_PTR (UINT8, ptr) 126119895Sanholt#define ACPI_GET16(ptr) *ACPI_CAST_PTR (UINT16, ptr) 127119895Sanholt#define ACPI_GET32(ptr) *ACPI_CAST_PTR (UINT32, ptr) 128119895Sanholt#define ACPI_GET64(ptr) *ACPI_CAST_PTR (UINT64, ptr) 129119895Sanholt#define ACPI_SET8(ptr) *ACPI_CAST_PTR (UINT8, ptr) 130119895Sanholt#define ACPI_SET16(ptr) *ACPI_CAST_PTR (UINT16, ptr) 131145132Sanholt#define ACPI_SET32(ptr) *ACPI_CAST_PTR (UINT32, ptr) 132119895Sanholt#define ACPI_SET64(ptr) *ACPI_CAST_PTR (UINT64, ptr) 133145132Sanholt 134119895Sanholt/* 135119895Sanholt * printf() format helpers 136119895Sanholt */ 137119895Sanholt 138119895Sanholt/* Split 64-bit integer into two 32-bit values. Use with %8.8X%8.8X */ 139119895Sanholt 140145132Sanholt#define ACPI_FORMAT_UINT64(i) ACPI_HIDWORD(i), ACPI_LODWORD(i) 141119895Sanholt 142119895Sanholt#if ACPI_MACHINE_WIDTH == 64 143119895Sanholt#define ACPI_FORMAT_NATIVE_UINT(i) ACPI_FORMAT_UINT64(i) 144119895Sanholt#else 145119895Sanholt#define ACPI_FORMAT_NATIVE_UINT(i) 0, (i) 146119895Sanholt#endif 147119895Sanholt 148119895Sanholt 149119895Sanholt/* 150119895Sanholt * Macros for moving data around to/from buffers that are possibly unaligned. 151119895Sanholt * If the hardware supports the transfer of unaligned data, just do the store. 152119895Sanholt * Otherwise, we have to move one byte at a time. 153119895Sanholt */ 154119895Sanholt#ifdef ACPI_BIG_ENDIAN 155157617Sanholt/* 156145132Sanholt * Macros for big-endian machines 157145132Sanholt */ 158119895Sanholt 159119895Sanholt/* These macros reverse the bytes during the move, converting little-endian to big endian */ 160119895Sanholt 161119895Sanholt /* Big Endian <== Little Endian */ 162119895Sanholt /* Hi...Lo Lo...Hi */ 163119895Sanholt/* 16-bit source, 16/32/64 destination */ 164145132Sanholt 165119895Sanholt#define ACPI_MOVE_16_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[1];\ 166119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[0];} 167119895Sanholt 168119895Sanholt#define ACPI_MOVE_16_TO_32(d, s) {(*(UINT32 *)(void *)(d))=0;\ 169145132Sanholt ((UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\ 170119895Sanholt ((UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];} 171145132Sanholt 172119895Sanholt#define ACPI_MOVE_16_TO_64(d, s) {(*(UINT64 *)(void *)(d))=0;\ 173119895Sanholt ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\ 174119895Sanholt ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];} 175119895Sanholt 176145132Sanholt/* 32-bit source, 16/32/64 destination */ 177119895Sanholt 178145132Sanholt#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 179119895Sanholt 180119895Sanholt#define ACPI_MOVE_32_TO_32(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\ 181119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];\ 182145132Sanholt (( UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\ 183119895Sanholt (( UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];} 184119895Sanholt 185119895Sanholt#define ACPI_MOVE_32_TO_64(d, s) {(*(UINT64 *)(void *)(d))=0;\ 186119895Sanholt ((UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\ 187119895Sanholt ((UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\ 188119895Sanholt ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\ 189119895Sanholt ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];} 190119895Sanholt 191119895Sanholt/* 64-bit source, 16/32/64 destination */ 192119895Sanholt 193119895Sanholt#define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 194119895Sanholt 195119895Sanholt#define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ 196119895Sanholt 197119895Sanholt#define ACPI_MOVE_64_TO_64(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\ 198119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];\ 199145132Sanholt (( UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[5];\ 200145132Sanholt (( UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[4];\ 201119895Sanholt (( UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\ 202119895Sanholt (( UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\ 203119895Sanholt (( UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\ 204119895Sanholt (( UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];} 205119895Sanholt#else 206119895Sanholt/* 207145132Sanholt * Macros for little-endian machines 208145132Sanholt */ 209119895Sanholt 210119895Sanholt#ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED 211119895Sanholt 212119895Sanholt/* The hardware supports unaligned transfers, just do the little-endian move */ 213119895Sanholt 214119895Sanholt/* 16-bit source, 16/32/64 destination */ 215119895Sanholt 216119895Sanholt#define ACPI_MOVE_16_TO_16(d, s) *(UINT16 *)(void *)(d) = *(UINT16 *)(void *)(s) 217119895Sanholt#define ACPI_MOVE_16_TO_32(d, s) *(UINT32 *)(void *)(d) = *(UINT16 *)(void *)(s) 218119895Sanholt#define ACPI_MOVE_16_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT16 *)(void *)(s) 219119895Sanholt 220145132Sanholt/* 32-bit source, 16/32/64 destination */ 221145132Sanholt 222119895Sanholt#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 223119895Sanholt#define ACPI_MOVE_32_TO_32(d, s) *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s) 224119895Sanholt#define ACPI_MOVE_32_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s) 225119895Sanholt 226119895Sanholt/* 64-bit source, 16/32/64 destination */ 227119895Sanholt 228119895Sanholt#define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 229119895Sanholt#define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ 230119895Sanholt#define ACPI_MOVE_64_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT64 *)(void *)(s) 231119895Sanholt 232119895Sanholt#else 233119895Sanholt/* 234119895Sanholt * The hardware does not support unaligned transfers. We must move the 235119895Sanholt * data one byte at a time. These macros work whether the source or 236119895Sanholt * the destination (or both) is/are unaligned. (Little-endian move) 237145132Sanholt */ 238119895Sanholt 239145132Sanholt/* 16-bit source, 16/32/64 destination */ 240119895Sanholt 241145132Sanholt#define ACPI_MOVE_16_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\ 242119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];} 243119895Sanholt 244119895Sanholt#define ACPI_MOVE_16_TO_32(d, s) {(*(UINT32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} 245145132Sanholt#define ACPI_MOVE_16_TO_64(d, s) {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} 246119895Sanholt 247145132Sanholt/* 32-bit source, 16/32/64 destination */ 248119895Sanholt 249119895Sanholt#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 250119895Sanholt 251145132Sanholt#define ACPI_MOVE_32_TO_32(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\ 252119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\ 253119895Sanholt (( UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\ 254145132Sanholt (( UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];} 255145132Sanholt 256119895Sanholt#define ACPI_MOVE_32_TO_64(d, s) {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_32_TO_32(d, s);} 257119895Sanholt 258119895Sanholt/* 64-bit source, 16/32/64 destination */ 259119895Sanholt 260119895Sanholt#define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ 261119895Sanholt#define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ 262145132Sanholt#define ACPI_MOVE_64_TO_64(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\ 263119895Sanholt (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\ 264119895Sanholt (( UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\ 265119895Sanholt (( UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];\ 266119895Sanholt (( UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[4];\ 267145132Sanholt (( UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[5];\ 268119895Sanholt (( UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[6];\ 269119895Sanholt (( UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[7];} 270119895Sanholt#endif 271119895Sanholt#endif 272119895Sanholt 273145132Sanholt 274119895Sanholt/* 275119895Sanholt * Fast power-of-two math macros for non-optimized compilers 276119895Sanholt */ 277119895Sanholt#define _ACPI_DIV(value, PowerOf2) ((UINT32) ((value) >> (PowerOf2))) 278119895Sanholt#define _ACPI_MUL(value, PowerOf2) ((UINT32) ((value) << (PowerOf2))) 279119895Sanholt#define _ACPI_MOD(value, Divisor) ((UINT32) ((value) & ((Divisor) -1))) 280119895Sanholt 281119895Sanholt#define ACPI_DIV_2(a) _ACPI_DIV(a, 1) 282119895Sanholt#define ACPI_MUL_2(a) _ACPI_MUL(a, 1) 283119895Sanholt#define ACPI_MOD_2(a) _ACPI_MOD(a, 2) 284119895Sanholt 285119895Sanholt#define ACPI_DIV_4(a) _ACPI_DIV(a, 2) 286119895Sanholt#define ACPI_MUL_4(a) _ACPI_MUL(a, 2) 287119895Sanholt#define ACPI_MOD_4(a) _ACPI_MOD(a, 4) 288119895Sanholt 289119895Sanholt#define ACPI_DIV_8(a) _ACPI_DIV(a, 3) 290119895Sanholt#define ACPI_MUL_8(a) _ACPI_MUL(a, 3) 291119895Sanholt#define ACPI_MOD_8(a) _ACPI_MOD(a, 8) 292119895Sanholt 293119895Sanholt#define ACPI_DIV_16(a) _ACPI_DIV(a, 4) 294119895Sanholt#define ACPI_MUL_16(a) _ACPI_MUL(a, 4) 295119895Sanholt#define ACPI_MOD_16(a) _ACPI_MOD(a, 16) 296119895Sanholt 297119895Sanholt#define ACPI_DIV_32(a) _ACPI_DIV(a, 5) 298119895Sanholt#define ACPI_MUL_32(a) _ACPI_MUL(a, 5) 299119895Sanholt#define ACPI_MOD_32(a) _ACPI_MOD(a, 32) 300119895Sanholt 301119895Sanholt/* 302119895Sanholt * Rounding macros (Power of two boundaries only) 303 */ 304#define ACPI_ROUND_DOWN(value, boundary) (((ACPI_SIZE)(value)) & \ 305 (~(((ACPI_SIZE) boundary)-1))) 306 307#define ACPI_ROUND_UP(value, boundary) ((((ACPI_SIZE)(value)) + \ 308 (((ACPI_SIZE) boundary)-1)) & \ 309 (~(((ACPI_SIZE) boundary)-1))) 310 311/* Note: sizeof(ACPI_SIZE) evaluates to either 4 or 8 (32- vs 64-bit mode) */ 312 313#define ACPI_ROUND_DOWN_TO_32BIT(a) ACPI_ROUND_DOWN(a, 4) 314#define ACPI_ROUND_DOWN_TO_64BIT(a) ACPI_ROUND_DOWN(a, 8) 315#define ACPI_ROUND_DOWN_TO_NATIVE_WORD(a) ACPI_ROUND_DOWN(a, sizeof(ACPI_SIZE)) 316 317#define ACPI_ROUND_UP_TO_32BIT(a) ACPI_ROUND_UP(a, 4) 318#define ACPI_ROUND_UP_TO_64BIT(a) ACPI_ROUND_UP(a, 8) 319#define ACPI_ROUND_UP_TO_NATIVE_WORD(a) ACPI_ROUND_UP(a, sizeof(ACPI_SIZE)) 320 321#define ACPI_ROUND_BITS_UP_TO_BYTES(a) ACPI_DIV_8((a) + 7) 322#define ACPI_ROUND_BITS_DOWN_TO_BYTES(a) ACPI_DIV_8((a)) 323 324#define ACPI_ROUND_UP_TO_1K(a) (((a) + 1023) >> 10) 325 326/* Generic (non-power-of-two) rounding */ 327 328#define ACPI_ROUND_UP_TO(value, boundary) (((value) + ((boundary)-1)) / (boundary)) 329 330#define ACPI_IS_MISALIGNED(value) (((ACPI_SIZE) value) & (sizeof(ACPI_SIZE)-1)) 331 332/* 333 * Bitmask creation 334 * Bit positions start at zero. 335 * MASK_BITS_ABOVE creates a mask starting AT the position and above 336 * MASK_BITS_BELOW creates a mask starting one bit BELOW the position 337 */ 338#define ACPI_MASK_BITS_ABOVE(position) (~((ACPI_INTEGER_MAX) << ((UINT32) (position)))) 339#define ACPI_MASK_BITS_BELOW(position) ((ACPI_INTEGER_MAX) << ((UINT32) (position))) 340 341/* Bitfields within ACPI registers */ 342 343#define ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask) ((Val << Pos) & Mask) 344#define ACPI_REGISTER_INSERT_VALUE(Reg, Pos, Mask, Val) Reg = (Reg & (~(Mask))) | ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask) 345 346#define ACPI_INSERT_BITS(Target, Mask, Source) Target = ((Target & (~(Mask))) | (Source & Mask)) 347 348/* 349 * An ACPI_NAMESPACE_NODE can appear in some contexts 350 * where a pointer to an ACPI_OPERAND_OBJECT can also 351 * appear. This macro is used to distinguish them. 352 * 353 * The "Descriptor" field is the first field in both structures. 354 */ 355#define ACPI_GET_DESCRIPTOR_TYPE(d) (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType) 356#define ACPI_SET_DESCRIPTOR_TYPE(d, t) (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType = t) 357 358/* 359 * Macros for the master AML opcode table 360 */ 361#if defined (ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT) 362#define ACPI_OP(Name, PArgs, IArgs, ObjType, Class, Type, Flags) \ 363 {Name, (UINT32)(PArgs), (UINT32)(IArgs), (UINT32)(Flags), ObjType, Class, Type} 364#else 365#define ACPI_OP(Name, PArgs, IArgs, ObjType, Class, Type, Flags) \ 366 {(UINT32)(PArgs), (UINT32)(IArgs), (UINT32)(Flags), ObjType, Class, Type} 367#endif 368 369#define ARG_TYPE_WIDTH 5 370#define ARG_1(x) ((UINT32)(x)) 371#define ARG_2(x) ((UINT32)(x) << (1 * ARG_TYPE_WIDTH)) 372#define ARG_3(x) ((UINT32)(x) << (2 * ARG_TYPE_WIDTH)) 373#define ARG_4(x) ((UINT32)(x) << (3 * ARG_TYPE_WIDTH)) 374#define ARG_5(x) ((UINT32)(x) << (4 * ARG_TYPE_WIDTH)) 375#define ARG_6(x) ((UINT32)(x) << (5 * ARG_TYPE_WIDTH)) 376 377#define ARGI_LIST1(a) (ARG_1(a)) 378#define ARGI_LIST2(a, b) (ARG_1(b)|ARG_2(a)) 379#define ARGI_LIST3(a, b, c) (ARG_1(c)|ARG_2(b)|ARG_3(a)) 380#define ARGI_LIST4(a, b, c, d) (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a)) 381#define ARGI_LIST5(a, b, c, d, e) (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a)) 382#define ARGI_LIST6(a, b, c, d, e, f) (ARG_1(f)|ARG_2(e)|ARG_3(d)|ARG_4(c)|ARG_5(b)|ARG_6(a)) 383 384#define ARGP_LIST1(a) (ARG_1(a)) 385#define ARGP_LIST2(a, b) (ARG_1(a)|ARG_2(b)) 386#define ARGP_LIST3(a, b, c) (ARG_1(a)|ARG_2(b)|ARG_3(c)) 387#define ARGP_LIST4(a, b, c, d) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)) 388#define ARGP_LIST5(a, b, c, d, e) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)) 389#define ARGP_LIST6(a, b, c, d, e, f) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)|ARG_6(f)) 390 391#define GET_CURRENT_ARG_TYPE(List) (List & ((UINT32) 0x1F)) 392#define INCREMENT_ARG_LIST(List) (List >>= ((UINT32) ARG_TYPE_WIDTH)) 393 394/* 395 * Ascii error messages can be configured out 396 */ 397#ifndef ACPI_NO_ERROR_MESSAGES 398/* 399 * Error reporting. Callers module and line number are inserted by AE_INFO, 400 * the plist contains a set of parens to allow variable-length lists. 401 * These macros are used for both the debug and non-debug versions of the code. 402 */ 403#define ACPI_ERROR_NAMESPACE(s, e) AcpiNsReportError (AE_INFO, s, e); 404#define ACPI_ERROR_METHOD(s, n, p, e) AcpiNsReportMethodError (AE_INFO, s, n, p, e); 405 406#else 407 408/* No error messages */ 409 410#define ACPI_ERROR_NAMESPACE(s, e) 411#define ACPI_ERROR_METHOD(s, n, p, e) 412 413#endif /* ACPI_NO_ERROR_MESSAGES */ 414 415/* 416 * Debug macros that are conditionally compiled 417 */ 418#ifdef ACPI_DEBUG_OUTPUT 419/* 420 * Function entry tracing 421 */ 422#define ACPI_FUNCTION_TRACE(a) ACPI_FUNCTION_NAME(a) \ 423 AcpiUtTrace(ACPI_DEBUG_PARAMETERS) 424#define ACPI_FUNCTION_TRACE_PTR(a, b) ACPI_FUNCTION_NAME(a) \ 425 AcpiUtTracePtr(ACPI_DEBUG_PARAMETERS, (void *)b) 426#define ACPI_FUNCTION_TRACE_U32(a, b) ACPI_FUNCTION_NAME(a) \ 427 AcpiUtTraceU32(ACPI_DEBUG_PARAMETERS, (UINT32)b) 428#define ACPI_FUNCTION_TRACE_STR(a, b) ACPI_FUNCTION_NAME(a) \ 429 AcpiUtTraceStr(ACPI_DEBUG_PARAMETERS, (char *)b) 430 431#define ACPI_FUNCTION_ENTRY() AcpiUtTrackStackPtr() 432 433/* 434 * Function exit tracing. 435 * WARNING: These macros include a return statement. This is usually considered 436 * bad form, but having a separate exit macro is very ugly and difficult to maintain. 437 * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros 438 * so that "_AcpiFunctionName" is defined. 439 * 440 * Note: the DO_WHILE0 macro is used to prevent some compilers from complaining 441 * about these constructs. 442 */ 443#ifdef ACPI_USE_DO_WHILE_0 444#define ACPI_DO_WHILE0(a) do a while(0) 445#else 446#define ACPI_DO_WHILE0(a) a 447#endif 448 449#define return_VOID ACPI_DO_WHILE0 ({ \ 450 AcpiUtExit (ACPI_DEBUG_PARAMETERS); \ 451 return;}) 452/* 453 * There are two versions of most of the return macros. The default version is 454 * safer, since it avoids side-effects by guaranteeing that the argument will 455 * not be evaluated twice. 456 * 457 * A less-safe version of the macros is provided for optional use if the 458 * compiler uses excessive CPU stack (for example, this may happen in the 459 * debug case if code optimzation is disabled.) 460 */ 461#ifndef ACPI_SIMPLE_RETURN_MACROS 462 463#define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ 464 register ACPI_STATUS _s = (s); \ 465 AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, _s); \ 466 return (_s); }) 467#define return_PTR(s) ACPI_DO_WHILE0 ({ \ 468 register void *_s = (void *) (s); \ 469 AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) _s); \ 470 return (_s); }) 471#define return_VALUE(s) ACPI_DO_WHILE0 ({ \ 472 register ACPI_INTEGER _s = (s); \ 473 AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, _s); \ 474 return (_s); }) 475#define return_UINT8(s) ACPI_DO_WHILE0 ({ \ 476 register UINT8 _s = (UINT8) (s); \ 477 AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \ 478 return (_s); }) 479#define return_UINT32(s) ACPI_DO_WHILE0 ({ \ 480 register UINT32 _s = (UINT32) (s); \ 481 AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \ 482 return (_s); }) 483#else /* Use original less-safe macros */ 484 485#define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ 486 AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, (s)); \ 487 return((s)); }) 488#define return_PTR(s) ACPI_DO_WHILE0 ({ \ 489 AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) (s)); \ 490 return((s)); }) 491#define return_VALUE(s) ACPI_DO_WHILE0 ({ \ 492 AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) (s)); \ 493 return((s)); }) 494#define return_UINT8(s) return_VALUE(s) 495#define return_UINT32(s) return_VALUE(s) 496 497#endif /* ACPI_SIMPLE_RETURN_MACROS */ 498 499 500/* Conditional execution */ 501 502#define ACPI_DEBUG_EXEC(a) a 503#define ACPI_DEBUG_ONLY_MEMBERS(a) a; 504#define _VERBOSE_STRUCTURES 505 506 507/* Various object display routines for debug */ 508 509#define ACPI_DUMP_STACK_ENTRY(a) AcpiExDumpOperand((a), 0) 510#define ACPI_DUMP_OPERANDS(a, b ,c) AcpiExDumpOperands(a, b, c) 511#define ACPI_DUMP_ENTRY(a, b) AcpiNsDumpEntry (a, b) 512#define ACPI_DUMP_PATHNAME(a, b, c, d) AcpiNsDumpPathname(a, b, c, d) 513#define ACPI_DUMP_BUFFER(a, b) AcpiUtDumpBuffer((UINT8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT) 514 515#else 516/* 517 * This is the non-debug case -- make everything go away, 518 * leaving no executable debug code! 519 */ 520#define ACPI_DEBUG_EXEC(a) 521#define ACPI_DEBUG_ONLY_MEMBERS(a) 522#define ACPI_FUNCTION_TRACE(a) 523#define ACPI_FUNCTION_TRACE_PTR(a, b) 524#define ACPI_FUNCTION_TRACE_U32(a, b) 525#define ACPI_FUNCTION_TRACE_STR(a, b) 526#define ACPI_FUNCTION_EXIT 527#define ACPI_FUNCTION_STATUS_EXIT(s) 528#define ACPI_FUNCTION_VALUE_EXIT(s) 529#define ACPI_FUNCTION_ENTRY() 530#define ACPI_DUMP_STACK_ENTRY(a) 531#define ACPI_DUMP_OPERANDS(a, b, c) 532#define ACPI_DUMP_ENTRY(a, b) 533#define ACPI_DUMP_TABLES(a, b) 534#define ACPI_DUMP_PATHNAME(a, b, c, d) 535#define ACPI_DUMP_BUFFER(a, b) 536#define ACPI_DEBUG_PRINT(pl) 537#define ACPI_DEBUG_PRINT_RAW(pl) 538 539#define return_VOID return 540#define return_ACPI_STATUS(s) return(s) 541#define return_VALUE(s) return(s) 542#define return_UINT8(s) return(s) 543#define return_UINT32(s) return(s) 544#define return_PTR(s) return(s) 545 546#endif /* ACPI_DEBUG_OUTPUT */ 547 548/* 549 * Some code only gets executed when the debugger is built in. 550 * Note that this is entirely independent of whether the 551 * DEBUG_PRINT stuff (set by ACPI_DEBUG_OUTPUT) is on, or not. 552 */ 553#ifdef ACPI_DEBUGGER 554#define ACPI_DEBUGGER_EXEC(a) a 555#else 556#define ACPI_DEBUGGER_EXEC(a) 557#endif 558 559 560/* 561 * Memory allocation tracking (DEBUG ONLY) 562 */ 563#define ACPI_MEM_PARAMETERS _COMPONENT, _AcpiModuleName, __LINE__ 564 565#ifndef ACPI_DBG_TRACK_ALLOCATIONS 566 567/* Memory allocation */ 568 569#define ACPI_ALLOCATE(a) AcpiUtAllocate((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS) 570#define ACPI_ALLOCATE_ZEROED(a) AcpiUtAllocateZeroed((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS) 571#define ACPI_FREE(a) AcpiOsFree(a) 572#define ACPI_MEM_TRACKING(a) 573 574#else 575 576/* Memory allocation */ 577 578#define ACPI_ALLOCATE(a) AcpiUtAllocateAndTrack((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS) 579#define ACPI_ALLOCATE_ZEROED(a) AcpiUtAllocateZeroedAndTrack((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS) 580#define ACPI_FREE(a) AcpiUtFreeAndTrack(a, ACPI_MEM_PARAMETERS) 581#define ACPI_MEM_TRACKING(a) a 582 583#endif /* ACPI_DBG_TRACK_ALLOCATIONS */ 584 585 586/* 587 * Macros used for ACPICA utilities only 588 */ 589 590/* Generate a UUID */ 591 592#define ACPI_INIT_UUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ 593 (a) & 0xFF, ((a) >> 8) & 0xFF, ((a) >> 16) & 0xFF, ((a) >> 24) & 0xFF, \ 594 (b) & 0xFF, ((b) >> 8) & 0xFF, \ 595 (c) & 0xFF, ((c) >> 8) & 0xFF, \ 596 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) 597 598#define ACPI_IS_OCTAL_DIGIT(d) (((char)(d) >= '0') && ((char)(d) <= '7')) 599 600 601#endif /* ACMACROS_H */ 602