drivers/acpi/acmacros.h

0001 /******************************************************************************
0002  *
0003  * Name: acmacros.h - C macros for the entire subsystem.
0004  *
0005  *****************************************************************************/
0006
0007 /******************************************************************************
0008  *
0009  * 1. Copyright Notice
0010  *
0011  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
0012  * All rights reserved.
0013  *
0014  * 2. License
0015  *
0016  * 2.1. This is your license from Intel Corp. under its intellectual property
0017  * rights.  You may have additional license terms from the party that provided
0018  * you this software, covering your right to use that party's intellectual
0019  * property rights.
0020  *
0021  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
0022  * copy of the source code appearing in this file ("Covered Code") an
0023  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
0024  * base code distributed originally by Intel ("Original Intel Code") to copy,
0025  * make derivatives, distribute, use and display any portion of the Covered
0026  * Code in any form, with the right to sublicense such rights; and
0027  *
0028  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
0029  * license (with the right to sublicense), under only those claims of Intel
0030  * patents that are infringed by the Original Intel Code, to make, use, sell,
0031  * offer to sell, and import the Covered Code and derivative works thereof
0032  * solely to the minimum extent necessary to exercise the above copyright
0033  * license, and in no event shall the patent license extend to any additions
0034  * to or modifications of the Original Intel Code.  No other license or right
0035  * is granted directly or by implication, estoppel or otherwise;
0036  *
0037  * The above copyright and patent license is granted only if the following
0038  * conditions are met:
0039  *
0040  * 3. Conditions
0041  *
0042  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
0043  * Redistribution of source code of any substantial portion of the Covered
0044  * Code or modification with rights to further distribute source must include
0045  * the above Copyright Notice, the above License, this list of Conditions,
0046  * and the following Disclaimer and Export Compliance provision.  In addition,
0047  * Licensee must cause all Covered Code to which Licensee contributes to
0048  * contain a file documenting the changes Licensee made to create that Covered
0049  * Code and the date of any change.  Licensee must include in that file the
0050  * documentation of any changes made by any predecessor Licensee.  Licensee
0051  * must include a prominent statement that the modification is derived,
0052  * directly or indirectly, from Original Intel Code.
0053  *
0054  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
0055  * Redistribution of source code of any substantial portion of the Covered
0056  * Code or modification without rights to further distribute source must
0057  * include the following Disclaimer and Export Compliance provision in the
0058  * documentation and/or other materials provided with distribution.  In
0059  * addition, Licensee may not authorize further sublicense of source of any
0060  * portion of the Covered Code, and must include terms to the effect that the
0061  * license from Licensee to its licensee is limited to the intellectual
0062  * property embodied in the software Licensee provides to its licensee, and
0063  * not to intellectual property embodied in modifications its licensee may
0064  * make.
0065  *
0066  * 3.3. Redistribution of Executable. Redistribution in executable form of any
0067  * substantial portion of the Covered Code or modification must reproduce the
0068  * above Copyright Notice, and the following Disclaimer and Export Compliance
0069  * provision in the documentation and/or other materials provided with the
0070  * distribution.
0071  *
0072  * 3.4. Intel retains all right, title, and interest in and to the Original
0073  * Intel Code.
0074  *
0075  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
0076  * Intel shall be used in advertising or otherwise to promote the sale, use or
0077  * other dealings in products derived from or relating to the Covered Code
0078  * without prior written authorization from Intel.
0079  *
0080  * 4. Disclaimer and Export Compliance
0081  *
0082  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
0083  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
0084  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
0085  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
0086  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
0087  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
0088  * PARTICULAR PURPOSE.
0089  *
0090  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
0091  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
0092  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
0093  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
0094  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
0095  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
0096  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
0097  * LIMITED REMEDY.
0098  *
0099  * 4.3. Licensee shall not export, either directly or indirectly, any of this
0100  * software or system incorporating such software without first obtaining any
0101  * required license or other approval from the U. S. Department of Commerce or
0102  * any other agency or department of the United States Government.  In the
0103  * event Licensee exports any such software from the United States or
0104  * re-exports any such software from a foreign destination, Licensee shall
0105  * ensure that the distribution and export/re-export of the software is in
0106  * compliance with all laws, regulations, orders, or other restrictions of the
0107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
0108  * any of its subsidiaries will export/re-export any technical data, process,
0109  * software, or service, directly or indirectly, to any country for which the
0110  * United States government or any agency thereof requires an export license,
0111  * other governmental approval, or letter of assurance, without first obtaining
0112  * such license, approval or letter.
0113  *
0114  *****************************************************************************/
0115
0116 #ifndef __ACMACROS_H__
0117 #define __ACMACROS_H__
0118
0119
0120 /*
0121  * Extract data using a pointer. Any more than a byte and we
0122  * get into potential aligment issues -- see the STORE macros below.
0123  * Use with care.
0124  */
0125 #define ACPI_GET8(ptr)                  *ACPI_CAST_PTR (UINT8, ptr)
0126 #define ACPI_GET16(ptr)                 *ACPI_CAST_PTR (UINT16, ptr)
0127 #define ACPI_GET32(ptr)                 *ACPI_CAST_PTR (UINT32, ptr)
0128 #define ACPI_GET64(ptr)                 *ACPI_CAST_PTR (UINT64, ptr)
0129 #define ACPI_SET8(ptr)                  *ACPI_CAST_PTR (UINT8, ptr)
0130 #define ACPI_SET16(ptr)                 *ACPI_CAST_PTR (UINT16, ptr)
0131 #define ACPI_SET32(ptr)                 *ACPI_CAST_PTR (UINT32, ptr)
0132 #define ACPI_SET64(ptr)                 *ACPI_CAST_PTR (UINT64, ptr)
0133
0134 /*
0135  * printf() format helpers
0136  */
0137
0138 /* Split 64-bit integer into two 32-bit values. Use with %8.8X%8.8X */
0139
0140 #define ACPI_FORMAT_UINT64(i)           ACPI_HIDWORD(i), ACPI_LODWORD(i)
0141
0142 #if ACPI_MACHINE_WIDTH == 64
0143 #define ACPI_FORMAT_NATIVE_UINT(i)      ACPI_FORMAT_UINT64(i)
0144 #else
0145 #define ACPI_FORMAT_NATIVE_UINT(i)      0, (i)
0146 #endif
0147
0148
0149 /*
0150  * Macros for moving data around to/from buffers that are possibly unaligned.
0151  * If the hardware supports the transfer of unaligned data, just do the store.
0152  * Otherwise, we have to move one byte at a time.
0153  */
0154 #ifdef ACPI_BIG_ENDIAN
0155 /*
0156  * Macros for big-endian machines
0157  */
0158
0159 /* These macros reverse the bytes during the move, converting little-endian to big endian */
0160
0161                                                      /* Big Endian      <==        Little Endian */
0162                                                      /*  Hi...Lo                     Lo...Hi     */
0163 /* 16-bit source, 16/32/64 destination */
0164
0165 #define ACPI_MOVE_16_TO_16(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[1];\
0166                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[0];}
0167
0168 #define ACPI_MOVE_16_TO_32(d, s)        {(*(UINT32 *)(void *)(d))=0;\
0169                                            ((UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\
0170                                            ((UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];}
0171
0172 #define ACPI_MOVE_16_TO_64(d, s)        {(*(UINT64 *)(void *)(d))=0;\
0173                                            ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
0174                                            ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
0175
0176 /* 32-bit source, 16/32/64 destination */
0177
0178 #define ACPI_MOVE_32_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0179
0180 #define ACPI_MOVE_32_TO_32(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\
0181                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];\
0182                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\
0183                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];}
0184
0185 #define ACPI_MOVE_32_TO_64(d, s)        {(*(UINT64 *)(void *)(d))=0;\
0186                                            ((UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\
0187                                            ((UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\
0188                                            ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
0189                                            ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
0190
0191 /* 64-bit source, 16/32/64 destination */
0192
0193 #define ACPI_MOVE_64_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0194
0195 #define ACPI_MOVE_64_TO_32(d, s)        ACPI_MOVE_32_TO_32(d, s)    /* Truncate to 32 */
0196
0197 #define ACPI_MOVE_64_TO_64(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\
0198                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];\
0199                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[5];\
0200                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[4];\
0201                                          ((  UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\
0202                                          ((  UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\
0203                                          ((  UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
0204                                          ((  UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
0205 #else
0206 /*
0207  * Macros for little-endian machines
0208  */
0209
0210 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
0211
0212 /* The hardware supports unaligned transfers, just do the little-endian move */
0213
0214 /* 16-bit source, 16/32/64 destination */
0215
0216 #define ACPI_MOVE_16_TO_16(d, s)        *(UINT16 *)(void *)(d) = *(UINT16 *)(void *)(s)
0217 #define ACPI_MOVE_16_TO_32(d, s)        *(UINT32 *)(void *)(d) = *(UINT16 *)(void *)(s)
0218 #define ACPI_MOVE_16_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT16 *)(void *)(s)
0219
0220 /* 32-bit source, 16/32/64 destination */
0221
0222 #define ACPI_MOVE_32_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0223 #define ACPI_MOVE_32_TO_32(d, s)        *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s)
0224 #define ACPI_MOVE_32_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s)
0225
0226 /* 64-bit source, 16/32/64 destination */
0227
0228 #define ACPI_MOVE_64_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0229 #define ACPI_MOVE_64_TO_32(d, s)        ACPI_MOVE_32_TO_32(d, s)    /* Truncate to 32 */
0230 #define ACPI_MOVE_64_TO_64(d, s)        *(UINT64 *)(void *)(d) = *(UINT64 *)(void *)(s)
0231
0232 #else
0233 /*
0234  * The hardware does not support unaligned transfers. We must move the
0235  * data one byte at a time. These macros work whether the source or
0236  * the destination (or both) is/are unaligned. (Little-endian move)
0237  */
0238
0239 /* 16-bit source, 16/32/64 destination */
0240
0241 #define ACPI_MOVE_16_TO_16(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
0242                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];}
0243
0244 #define ACPI_MOVE_16_TO_32(d, s)        {(*(UINT32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);}
0245 #define ACPI_MOVE_16_TO_64(d, s)        {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);}
0246
0247 /* 32-bit source, 16/32/64 destination */
0248
0249 #define ACPI_MOVE_32_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0250
0251 #define ACPI_MOVE_32_TO_32(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
0252                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\
0253                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\
0254                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];}
0255
0256 #define ACPI_MOVE_32_TO_64(d, s)        {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_32_TO_32(d, s);}
0257
0258 /* 64-bit source, 16/32/64 destination */
0259
0260 #define ACPI_MOVE_64_TO_16(d, s)        ACPI_MOVE_16_TO_16(d, s)    /* Truncate to 16 */
0261 #define ACPI_MOVE_64_TO_32(d, s)        ACPI_MOVE_32_TO_32(d, s)    /* Truncate to 32 */
0262 #define ACPI_MOVE_64_TO_64(d, s)        {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
0263                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\
0264                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\
0265                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];\
0266                                          ((  UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[4];\
0267                                          ((  UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[5];\
0268                                          ((  UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[6];\
0269                                          ((  UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[7];}
0270 #endif
0271 #endif
0272
0273
0274 /*
0275  * Fast power-of-two math macros for non-optimized compilers
0276  */
0277 #define _ACPI_DIV(value, PowerOf2)      ((UINT32) ((value) >> (PowerOf2)))
0278 #define _ACPI_MUL(value, PowerOf2)      ((UINT32) ((value) << (PowerOf2)))
0279 #define _ACPI_MOD(value, Divisor)       ((UINT32) ((value) & ((Divisor) -1)))
0280
0281 #define ACPI_DIV_2(a)                   _ACPI_DIV(a, 1)
0282 #define ACPI_MUL_2(a)                   _ACPI_MUL(a, 1)
0283 #define ACPI_MOD_2(a)                   _ACPI_MOD(a, 2)
0284
0285 #define ACPI_DIV_4(a)                   _ACPI_DIV(a, 2)
0286 #define ACPI_MUL_4(a)                   _ACPI_MUL(a, 2)
0287 #define ACPI_MOD_4(a)                   _ACPI_MOD(a, 4)
0288
0289 #define ACPI_DIV_8(a)                   _ACPI_DIV(a, 3)
0290 #define ACPI_MUL_8(a)                   _ACPI_MUL(a, 3)
0291 #define ACPI_MOD_8(a)                   _ACPI_MOD(a, 8)
0292
0293 #define ACPI_DIV_16(a)                  _ACPI_DIV(a, 4)
0294 #define ACPI_MUL_16(a)                  _ACPI_MUL(a, 4)
0295 #define ACPI_MOD_16(a)                  _ACPI_MOD(a, 16)
0296
0297 #define ACPI_DIV_32(a)                  _ACPI_DIV(a, 5)
0298 #define ACPI_MUL_32(a)                  _ACPI_MUL(a, 5)
0299 #define ACPI_MOD_32(a)                  _ACPI_MOD(a, 32)
0300
0301 /*
0302  * Rounding macros (Power of two boundaries only)
0303  */
0304 #define ACPI_ROUND_DOWN(value, boundary)    (((ACPI_SIZE)(value)) & \
0305                                                 (~(((ACPI_SIZE) boundary)-1)))
0306
0307 #define ACPI_ROUND_UP(value, boundary)      ((((ACPI_SIZE)(value)) + \
0308                                                 (((ACPI_SIZE) boundary)-1)) & \
0309                                                 (~(((ACPI_SIZE) boundary)-1)))
0310
0311 /* Note: sizeof(ACPI_SIZE) evaluates to either 4 or 8 (32- vs 64-bit mode) */
0312
0313 #define ACPI_ROUND_DOWN_TO_32BIT(a)         ACPI_ROUND_DOWN(a, 4)
0314 #define ACPI_ROUND_DOWN_TO_64BIT(a)         ACPI_ROUND_DOWN(a, 8)
0315 #define ACPI_ROUND_DOWN_TO_NATIVE_WORD(a)   ACPI_ROUND_DOWN(a, sizeof(ACPI_SIZE))
0316
0317 #define ACPI_ROUND_UP_TO_32BIT(a)           ACPI_ROUND_UP(a, 4)
0318 #define ACPI_ROUND_UP_TO_64BIT(a)           ACPI_ROUND_UP(a, 8)
0319 #define ACPI_ROUND_UP_TO_NATIVE_WORD(a)     ACPI_ROUND_UP(a, sizeof(ACPI_SIZE))
0320
0321 #define ACPI_ROUND_BITS_UP_TO_BYTES(a)      ACPI_DIV_8((a) + 7)
0322 #define ACPI_ROUND_BITS_DOWN_TO_BYTES(a)    ACPI_DIV_8((a))
0323
0324 #define ACPI_ROUND_UP_TO_1K(a)              (((a) + 1023) >> 10)
0325
0326 /* Generic (non-power-of-two) rounding */
0327
0328 #define ACPI_ROUND_UP_TO(value, boundary)   (((value) + ((boundary)-1)) / (boundary))
0329
0330 #define ACPI_IS_MISALIGNED(value)           (((ACPI_SIZE) value) & (sizeof(ACPI_SIZE)-1))
0331
0332 /*
0333  * Bitmask creation
0334  * Bit positions start at zero.
0335  * MASK_BITS_ABOVE creates a mask starting AT the position and above
0336  * MASK_BITS_BELOW creates a mask starting one bit BELOW the position
0337  */
0338 #define ACPI_MASK_BITS_ABOVE(position)      (~((ACPI_INTEGER_MAX) << ((UINT32) (position))))
0339 #define ACPI_MASK_BITS_BELOW(position)      ((ACPI_INTEGER_MAX) << ((UINT32) (position)))
0340
0341 /* Bitfields within ACPI registers */
0342
0343 #define ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask)      ((Val << Pos) & Mask)
0344 #define ACPI_REGISTER_INSERT_VALUE(Reg, Pos, Mask, Val)  Reg = (Reg & (~(Mask))) | ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask)
0345
0346 #define ACPI_INSERT_BITS(Target, Mask, Source)          Target = ((Target & (~(Mask))) | (Source & Mask))
0347
0348 /*
0349  * An ACPI_NAMESPACE_NODE can appear in some contexts
0350  * where a pointer to an ACPI_OPERAND_OBJECT can also
0351  * appear. This macro is used to distinguish them.
0352  *
0353  * The "Descriptor" field is the first field in both structures.
0354  */
0355 #define ACPI_GET_DESCRIPTOR_TYPE(d)     (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType)
0356 #define ACPI_SET_DESCRIPTOR_TYPE(d, t)  (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType = t)
0357
0358 /*
0359  * Macros for the master AML opcode table
0360  */
0361 #if defined (ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT)
0362 #define ACPI_OP(Name, PArgs, IArgs, ObjType, Class, Type, Flags) \
0363     {Name, (UINT32)(PArgs), (UINT32)(IArgs), (UINT32)(Flags), ObjType, Class, Type}
0364 #else
0365 #define ACPI_OP(Name, PArgs, IArgs, ObjType, Class, Type, Flags) \
0366     {(UINT32)(PArgs), (UINT32)(IArgs), (UINT32)(Flags), ObjType, Class, Type}
0367 #endif
0368
0369 #define ARG_TYPE_WIDTH                  5
0370 #define ARG_1(x)                        ((UINT32)(x))
0371 #define ARG_2(x)                        ((UINT32)(x) << (1 * ARG_TYPE_WIDTH))
0372 #define ARG_3(x)                        ((UINT32)(x) << (2 * ARG_TYPE_WIDTH))
0373 #define ARG_4(x)                        ((UINT32)(x) << (3 * ARG_TYPE_WIDTH))
0374 #define ARG_5(x)                        ((UINT32)(x) << (4 * ARG_TYPE_WIDTH))
0375 #define ARG_6(x)                        ((UINT32)(x) << (5 * ARG_TYPE_WIDTH))
0376
0377 #define ARGI_LIST1(a)                   (ARG_1(a))
0378 #define ARGI_LIST2(a, b)                (ARG_1(b)|ARG_2(a))
0379 #define ARGI_LIST3(a, b, c)             (ARG_1(c)|ARG_2(b)|ARG_3(a))
0380 #define ARGI_LIST4(a, b, c, d)          (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a))
0381 #define ARGI_LIST5(a, b, c, d, e)       (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a))
0382 #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))
0383
0384 #define ARGP_LIST1(a)                   (ARG_1(a))
0385 #define ARGP_LIST2(a, b)                (ARG_1(a)|ARG_2(b))
0386 #define ARGP_LIST3(a, b, c)             (ARG_1(a)|ARG_2(b)|ARG_3(c))
0387 #define ARGP_LIST4(a, b, c, d)          (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d))
0388 #define ARGP_LIST5(a, b, c, d, e)       (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e))
0389 #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))
0390
0391 #define GET_CURRENT_ARG_TYPE(List)      (List & ((UINT32) 0x1F))
0392 #define INCREMENT_ARG_LIST(List)        (List >>= ((UINT32) ARG_TYPE_WIDTH))
0393
0394 /*
0395  * Ascii error messages can be configured out
0396  */
0397 #ifndef ACPI_NO_ERROR_MESSAGES
0398 /*
0399  * Error reporting. Callers module and line number are inserted by AE_INFO,
0400  * the plist contains a set of parens to allow variable-length lists.
0401  * These macros are used for both the debug and non-debug versions of the code.
0402  */
0403 #define ACPI_ERROR_NAMESPACE(s, e)      AcpiNsReportError (AE_INFO, s, e);
0404 #define ACPI_ERROR_METHOD(s, n, p, e)   AcpiNsReportMethodError (AE_INFO, s, n, p, e);
0405 #define ACPI_WARN_PREDEFINED(plist)     AcpiUtPredefinedWarning plist
0406
0407 #else
0408
0409 /* No error messages */
0410
0411 #define ACPI_ERROR_NAMESPACE(s, e)
0412 #define ACPI_ERROR_METHOD(s, n, p, e)
0413 #define ACPI_WARN_PREDEFINED(plist)
0414
0415 #endif /* ACPI_NO_ERROR_MESSAGES */
0416
0417 /*
0418  * Debug macros that are conditionally compiled
0419  */
0420 #ifdef ACPI_DEBUG_OUTPUT
0421 /*
0422  * Function entry tracing
0423  */
0424 #define ACPI_FUNCTION_TRACE(a)          ACPI_FUNCTION_NAME(a) \
0425                                             AcpiUtTrace(ACPI_DEBUG_PARAMETERS)
0426 #define ACPI_FUNCTION_TRACE_PTR(a, b)   ACPI_FUNCTION_NAME(a) \
0427                                             AcpiUtTracePtr(ACPI_DEBUG_PARAMETERS, (void *)b)
0428 #define ACPI_FUNCTION_TRACE_U32(a, b)   ACPI_FUNCTION_NAME(a) \
0429                                             AcpiUtTraceU32(ACPI_DEBUG_PARAMETERS, (UINT32)b)
0430 #define ACPI_FUNCTION_TRACE_STR(a, b)   ACPI_FUNCTION_NAME(a) \
0431                                             AcpiUtTraceStr(ACPI_DEBUG_PARAMETERS, (char *)b)
0432
0433 #define ACPI_FUNCTION_ENTRY()           AcpiUtTrackStackPtr()
0434
0435 /*
0436  * Function exit tracing.
0437  * WARNING: These macros include a return statement. This is usually considered
0438  * bad form, but having a separate exit macro is very ugly and difficult to maintain.
0439  * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros
0440  * so that "_AcpiFunctionName" is defined.
0441  *
0442  * Note: the DO_WHILE0 macro is used to prevent some compilers from complaining
0443  * about these constructs.
0444  */
0445 #ifdef ACPI_USE_DO_WHILE_0
0446 #define ACPI_DO_WHILE0(a)               do a while(0)
0447 #else
0448 #define ACPI_DO_WHILE0(a)               a
0449 #endif
0450
0451 #define return_VOID                     ACPI_DO_WHILE0 ({ \
0452                                             AcpiUtExit (ACPI_DEBUG_PARAMETERS); \
0453                                             return;})
0454 /*
0455  * There are two versions of most of the return macros. The default version is
0456  * safer, since it avoids side-effects by guaranteeing that the argument will
0457  * not be evaluated twice.
0458  *
0459  * A less-safe version of the macros is provided for optional use if the
0460  * compiler uses excessive CPU stack (for example, this may happen in the
0461  * debug case if code optimzation is disabled.)
0462  */
0463 #ifndef ACPI_SIMPLE_RETURN_MACROS
0464
0465 #define return_ACPI_STATUS(s)           ACPI_DO_WHILE0 ({ \
0466                                             register ACPI_STATUS _s = (s); \
0467                                             AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, _s); \
0468                                             return (_s); })
0469 #define return_PTR(s)                   ACPI_DO_WHILE0 ({ \
0470                                             register void *_s = (void *) (s); \
0471                                             AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) _s); \
0472                                             return (_s); })
0473 #define return_VALUE(s)                 ACPI_DO_WHILE0 ({ \
0474                                             register ACPI_INTEGER _s = (s); \
0475                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, _s); \
0476                                             return (_s); })
0477 #define return_UINT8(s)                 ACPI_DO_WHILE0 ({ \
0478                                             register UINT8 _s = (UINT8) (s); \
0479                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \
0480                                             return (_s); })
0481 #define return_UINT32(s)                ACPI_DO_WHILE0 ({ \
0482                                             register UINT32 _s = (UINT32) (s); \
0483                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \
0484                                             return (_s); })
0485 #else /* Use original less-safe macros */
0486
0487 #define return_ACPI_STATUS(s)           ACPI_DO_WHILE0 ({ \
0488                                             AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, (s)); \
0489                                             return((s)); })
0490 #define return_PTR(s)                   ACPI_DO_WHILE0 ({ \
0491                                             AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) (s)); \
0492                                             return((s)); })
0493 #define return_VALUE(s)                 ACPI_DO_WHILE0 ({ \
0494                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) (s)); \
0495                                             return((s)); })
0496 #define return_UINT8(s)                 return_VALUE(s)
0497 #define return_UINT32(s)                return_VALUE(s)
0498
0499 #endif /* ACPI_SIMPLE_RETURN_MACROS */
0500
0501
0502 /* Conditional execution */
0503
0504 #define ACPI_DEBUG_EXEC(a)              a
0505 #define ACPI_DEBUG_ONLY_MEMBERS(a)      a;
0506 #define _VERBOSE_STRUCTURES
0507
0508
0509 /* Various object display routines for debug */
0510
0511 #define ACPI_DUMP_STACK_ENTRY(a)        AcpiExDumpOperand((a), 0)
0512 #define ACPI_DUMP_OPERANDS(a, b ,c)     AcpiExDumpOperands(a, b, c)
0513 #define ACPI_DUMP_ENTRY(a, b)           AcpiNsDumpEntry (a, b)
0514 #define ACPI_DUMP_PATHNAME(a, b, c, d)  AcpiNsDumpPathname(a, b, c, d)
0515 #define ACPI_DUMP_BUFFER(a, b)          AcpiUtDumpBuffer((UINT8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT)
0516
0517 #else
0518 /*
0519  * This is the non-debug case -- make everything go away,
0520  * leaving no executable debug code!
0521  */
0522 #define ACPI_DEBUG_EXEC(a)
0523 #define ACPI_DEBUG_ONLY_MEMBERS(a)
0524 #define ACPI_FUNCTION_TRACE(a)
0525 #define ACPI_FUNCTION_TRACE_PTR(a, b)
0526 #define ACPI_FUNCTION_TRACE_U32(a, b)
0527 #define ACPI_FUNCTION_TRACE_STR(a, b)
0528 #define ACPI_FUNCTION_EXIT
0529 #define ACPI_FUNCTION_STATUS_EXIT(s)
0530 #define ACPI_FUNCTION_VALUE_EXIT(s)
0531 #define ACPI_FUNCTION_ENTRY()
0532 #define ACPI_DUMP_STACK_ENTRY(a)
0533 #define ACPI_DUMP_OPERANDS(a, b, c)
0534 #define ACPI_DUMP_ENTRY(a, b)
0535 #define ACPI_DUMP_TABLES(a, b)
0536 #define ACPI_DUMP_PATHNAME(a, b, c, d)
0537 #define ACPI_DUMP_BUFFER(a, b)
0538 #define ACPI_DEBUG_PRINT(pl)
0539 #define ACPI_DEBUG_PRINT_RAW(pl)
0540
0541 #define return_VOID                     return
0542 #define return_ACPI_STATUS(s)           return(s)
0543 #define return_VALUE(s)                 return(s)
0544 #define return_UINT8(s)                 return(s)
0545 #define return_UINT32(s)                return(s)
0546 #define return_PTR(s)                   return(s)
0547
0548 #endif /* ACPI_DEBUG_OUTPUT */
0549
0550 /*
0551  * Some code only gets executed when the debugger is built in.
0552  * Note that this is entirely independent of whether the
0553  * DEBUG_PRINT stuff (set by ACPI_DEBUG_OUTPUT) is on, or not.
0554  */
0555 #ifdef ACPI_DEBUGGER
0556 #define ACPI_DEBUGGER_EXEC(a)           a
0557 #else
0558 #define ACPI_DEBUGGER_EXEC(a)
0559 #endif
0560
0561
0562 /*
0563  * Memory allocation tracking (DEBUG ONLY)
0564  */
0565 #define ACPI_MEM_PARAMETERS         _COMPONENT, _AcpiModuleName, __LINE__
0566
0567 #ifndef ACPI_DBG_TRACK_ALLOCATIONS
0568
0569 /* Memory allocation */
0570
0571 #define ACPI_ALLOCATE(a)            AcpiUtAllocate((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS)
0572 #define ACPI_ALLOCATE_ZEROED(a)     AcpiUtAllocateZeroed((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS)
0573 #define ACPI_FREE(a)                AcpiOsFree(a)
0574 #define ACPI_MEM_TRACKING(a)
0575
0576 #else
0577
0578 /* Memory allocation */
0579
0580 #define ACPI_ALLOCATE(a)            AcpiUtAllocateAndTrack((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS)
0581 #define ACPI_ALLOCATE_ZEROED(a)     AcpiUtAllocateZeroedAndTrack((ACPI_SIZE) (a), ACPI_MEM_PARAMETERS)
0582 #define ACPI_FREE(a)                AcpiUtFreeAndTrack(a, ACPI_MEM_PARAMETERS)
0583 #define ACPI_MEM_TRACKING(a)        a
0584
0585 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */
0586
0587
0588 /*
0589  * Macros used for ACPICA utilities only
0590  */
0591
0592 /* Generate a UUID */
0593
0594 #define ACPI_INIT_UUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
0595     (a) & 0xFF, ((a) >> 8) & 0xFF, ((a) >> 16) & 0xFF, ((a) >> 24) & 0xFF, \
0596     (b) & 0xFF, ((b) >> 8) & 0xFF, \
0597     (c) & 0xFF, ((c) >> 8) & 0xFF, \
0598     (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)
0599
0600 #define ACPI_IS_OCTAL_DIGIT(d)              (((char)(d) >= '0') && ((char)(d) <= '7'))
0601
0602
0603 #endif /* ACMACROS_H */