sys/contrib/dev/acpica/acmacros.h

   1 /******************************************************************************
   2  *
   3  * Name: acmacros.h - C macros for the entire subsystem.
   4  *       $Revision: 1.195 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #ifndef __ACMACROS_H__
 118 #define __ACMACROS_H__
 119
 120
 121 /*
 122  * Data manipulation macros
 123  */
 124 #define ACPI_LOWORD(l)                  ((UINT16)(UINT32)(l))
 125 #define ACPI_HIWORD(l)                  ((UINT16)((((UINT32)(l)) >> 16) & 0xFFFF))
 126 #define ACPI_LOBYTE(l)                  ((UINT8)(UINT16)(l))
 127 #define ACPI_HIBYTE(l)                  ((UINT8)((((UINT16)(l)) >> 8) & 0xFF))
 128
 129 #define ACPI_SET_BIT(target,bit)        ((target) |= (bit))
 130 #define ACPI_CLEAR_BIT(target,bit)      ((target) &= ~(bit))
 131 #define ACPI_MIN(a,b)                   (((a)<(b))?(a):(b))
 132 #define ACPI_MAX(a,b)                   (((a)>(b))?(a):(b))
 133
 134 /* Size calculation */
 135
 136 #define ACPI_ARRAY_LENGTH(x)            (sizeof(x) / sizeof((x)[0]))
 137
 138
 139 /*
 140  * Full 64-bit integer must be available on both 32-bit and 64-bit platforms
 141  */
 142 #define ACPI_LODWORD(l)                 ((UINT32)(UINT64)(l))
 143 #define ACPI_HIDWORD(l)                 ((UINT32)(((*(UINT64_STRUCT *)(void *)(&l))).Hi))
 144
 145
 146 /*
 147  * printf() format helpers
 148  */
 149
 150 /* Split 64-bit integer into two 32-bit values. Use with %8.8X%8.8X */
 151
 152 #define ACPI_FORMAT_UINT64(i)           ACPI_HIDWORD(i),ACPI_LODWORD(i)
 153
 154 /*
 155  * Extract data using a pointer.  Any more than a byte and we
 156  * get into potential aligment issues -- see the STORE macros below.
 157  * Use with care.
 158  */
 159 #define ACPI_GET8(ptr)                  *ACPI_CAST_PTR (UINT8, ptr)
 160 #define ACPI_GET16(ptr)                 *ACPI_CAST_PTR (UINT16, ptr)
 161 #define ACPI_GET32(ptr)                 *ACPI_CAST_PTR (UINT32, ptr)
 162 #define ACPI_GET64(ptr)                 *ACPI_CAST_PTR (UINT64, ptr)
 163 #define ACPI_SET8(ptr)                  *ACPI_CAST_PTR (UINT8, ptr)
 164 #define ACPI_SET16(ptr)                 *ACPI_CAST_PTR (UINT16, ptr)
 165 #define ACPI_SET32(ptr)                 *ACPI_CAST_PTR (UINT32, ptr)
 166 #define ACPI_SET64(ptr)                 *ACPI_CAST_PTR (UINT64, ptr)
 167
 168 /*
 169  * Pointer manipulation
 170  */
 171 #define ACPI_CAST_PTR(t, p)             ((t *) (ACPI_UINTPTR_T) (p))
 172 #define ACPI_CAST_INDIRECT_PTR(t, p)    ((t **) (ACPI_UINTPTR_T) (p))
 173 #define ACPI_ADD_PTR(t,a,b)             ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8,(a)) + (ACPI_NATIVE_UINT)(b)))
 174 #define ACPI_PTR_DIFF(a,b)              (ACPI_NATIVE_UINT) (ACPI_CAST_PTR (UINT8,(a)) - ACPI_CAST_PTR (UINT8,(b)))
 175
 176 /* Pointer/Integer type conversions */
 177
 178 #define ACPI_TO_POINTER(i)              ACPI_ADD_PTR (void,(void *) NULL,(ACPI_NATIVE_UINT) i)
 179 #define ACPI_TO_INTEGER(p)              ACPI_PTR_DIFF (p,(void *) NULL)
 180 #define ACPI_OFFSET(d,f)                (ACPI_SIZE) ACPI_PTR_DIFF (&(((d *)0)->f),(void *) NULL)
 181 #define ACPI_PHYSADDR_TO_PTR(i)         ACPI_TO_POINTER(i)
 182 #define ACPI_PTR_TO_PHYSADDR(i)         ACPI_TO_INTEGER(i)
 183
 184 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
 185 #define ACPI_COMPARE_NAME(a,b)          (*ACPI_CAST_PTR (UINT32,(a)) == *ACPI_CAST_PTR (UINT32,(b)))
 186 #else
 187 #define ACPI_COMPARE_NAME(a,b)          (!ACPI_STRNCMP (ACPI_CAST_PTR (char,(a)), ACPI_CAST_PTR (char,(b)), ACPI_NAME_SIZE))
 188 #endif
 189
 190 /*
 191  * Macros for moving data around to/from buffers that are possibly unaligned.
 192  * If the hardware supports the transfer of unaligned data, just do the store.
 193  * Otherwise, we have to move one byte at a time.
 194  */
 195 #ifdef ACPI_BIG_ENDIAN
 196 /*
 197  * Macros for big-endian machines
 198  */
 199
 200 /* This macro sets a buffer index, starting from the end of the buffer */
 201
 202 #define ACPI_BUFFER_INDEX(BufLen,BufOffset,ByteGran)  ((BufLen) - (((BufOffset)+1) * (ByteGran)))
 203
 204 /* These macros reverse the bytes during the move, converting little-endian to big endian */
 205
 206                                                      /* Big Endian      <==        Little Endian */
 207                                                      /*  Hi...Lo                     Lo...Hi     */
 208 /* 16-bit source, 16/32/64 destination */
 209
 210 #define ACPI_MOVE_16_TO_16(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[1];\
 211                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[0];}
 212
 213 #define ACPI_MOVE_16_TO_32(d,s)         {(*(UINT32 *)(void *)(d))=0;\
 214                                            ((UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\
 215                                            ((UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];}
 216
 217 #define ACPI_MOVE_16_TO_64(d,s)         {(*(UINT64 *)(void *)(d))=0;\
 218                                            ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
 219                                            ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
 220
 221 /* 32-bit source, 16/32/64 destination */
 222
 223 #define ACPI_MOVE_32_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 224
 225 #define ACPI_MOVE_32_TO_32(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\
 226                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];\
 227                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[1];\
 228                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[0];}
 229
 230 #define ACPI_MOVE_32_TO_64(d,s)         {(*(UINT64 *)(void *)(d))=0;\
 231                                            ((UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\
 232                                            ((UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\
 233                                            ((UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
 234                                            ((UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
 235
 236 /* 64-bit source, 16/32/64 destination */
 237
 238 #define ACPI_MOVE_64_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 239
 240 #define ACPI_MOVE_64_TO_32(d,s)         ACPI_MOVE_32_TO_32(d,s)    /* Truncate to 32 */
 241
 242 #define ACPI_MOVE_64_TO_64(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\
 243                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];\
 244                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[5];\
 245                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[4];\
 246                                          ((  UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[3];\
 247                                          ((  UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[2];\
 248                                          ((  UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[1];\
 249                                          ((  UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[0];}
 250 #else
 251 /*
 252  * Macros for little-endian machines
 253  */
 254
 255 /* This macro sets a buffer index, starting from the beginning of the buffer */
 256
 257 #define ACPI_BUFFER_INDEX(BufLen,BufOffset,ByteGran)  (BufOffset)
 258
 259 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
 260
 261 /* The hardware supports unaligned transfers, just do the little-endian move */
 262
 263 /* 16-bit source, 16/32/64 destination */
 264
 265 #define ACPI_MOVE_16_TO_16(d,s)         *(UINT16 *)(void *)(d) = *(UINT16 *)(void *)(s)
 266 #define ACPI_MOVE_16_TO_32(d,s)         *(UINT32 *)(void *)(d) = *(UINT16 *)(void *)(s)
 267 #define ACPI_MOVE_16_TO_64(d,s)         *(UINT64 *)(void *)(d) = *(UINT16 *)(void *)(s)
 268
 269 /* 32-bit source, 16/32/64 destination */
 270
 271 #define ACPI_MOVE_32_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 272 #define ACPI_MOVE_32_TO_32(d,s)         *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s)
 273 #define ACPI_MOVE_32_TO_64(d,s)         *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s)
 274
 275 /* 64-bit source, 16/32/64 destination */
 276
 277 #define ACPI_MOVE_64_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 278 #define ACPI_MOVE_64_TO_32(d,s)         ACPI_MOVE_32_TO_32(d,s)    /* Truncate to 32 */
 279 #define ACPI_MOVE_64_TO_64(d,s)         *(UINT64 *)(void *)(d) = *(UINT64 *)(void *)(s)
 280
 281 #else
 282 /*
 283  * The hardware does not support unaligned transfers.  We must move the
 284  * data one byte at a time.  These macros work whether the source or
 285  * the destination (or both) is/are unaligned.  (Little-endian move)
 286  */
 287
 288 /* 16-bit source, 16/32/64 destination */
 289
 290 #define ACPI_MOVE_16_TO_16(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
 291                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];}
 292
 293 #define ACPI_MOVE_16_TO_32(d,s)         {(*(UINT32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d,s);}
 294 #define ACPI_MOVE_16_TO_64(d,s)         {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d,s);}
 295
 296 /* 32-bit source, 16/32/64 destination */
 297
 298 #define ACPI_MOVE_32_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 299
 300 #define ACPI_MOVE_32_TO_32(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
 301                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\
 302                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\
 303                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];}
 304
 305 #define ACPI_MOVE_32_TO_64(d,s)         {(*(UINT64 *)(void *)(d)) = 0; ACPI_MOVE_32_TO_32(d,s);}
 306
 307 /* 64-bit source, 16/32/64 destination */
 308
 309 #define ACPI_MOVE_64_TO_16(d,s)         ACPI_MOVE_16_TO_16(d,s)    /* Truncate to 16 */
 310 #define ACPI_MOVE_64_TO_32(d,s)         ACPI_MOVE_32_TO_32(d,s)    /* Truncate to 32 */
 311 #define ACPI_MOVE_64_TO_64(d,s)         {((  UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\
 312                                          ((  UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];\
 313                                          ((  UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[2];\
 314                                          ((  UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[3];\
 315                                          ((  UINT8 *)(void *)(d))[4] = ((UINT8 *)(void *)(s))[4];\
 316                                          ((  UINT8 *)(void *)(d))[5] = ((UINT8 *)(void *)(s))[5];\
 317                                          ((  UINT8 *)(void *)(d))[6] = ((UINT8 *)(void *)(s))[6];\
 318                                          ((  UINT8 *)(void *)(d))[7] = ((UINT8 *)(void *)(s))[7];}
 319 #endif
 320 #endif
 321
 322 /* Macros based on machine integer width */
 323
 324 #if ACPI_MACHINE_WIDTH == 32
 325 #define ACPI_MOVE_SIZE_TO_16(d,s)       ACPI_MOVE_32_TO_16(d,s)
 326
 327 #elif ACPI_MACHINE_WIDTH == 64
 328 #define ACPI_MOVE_SIZE_TO_16(d,s)       ACPI_MOVE_64_TO_16(d,s)
 329
 330 #else
 331 #error unknown ACPI_MACHINE_WIDTH
 332 #endif
 333
 334
 335 /*
 336  * Fast power-of-two math macros for non-optimized compilers
 337  */
 338 #define _ACPI_DIV(value,PowerOf2)       ((UINT32) ((value) >> (PowerOf2)))
 339 #define _ACPI_MUL(value,PowerOf2)       ((UINT32) ((value) << (PowerOf2)))
 340 #define _ACPI_MOD(value,Divisor)        ((UINT32) ((value) & ((Divisor) -1)))
 341
 342 #define ACPI_DIV_2(a)                   _ACPI_DIV(a,1)
 343 #define ACPI_MUL_2(a)                   _ACPI_MUL(a,1)
 344 #define ACPI_MOD_2(a)                   _ACPI_MOD(a,2)
 345
 346 #define ACPI_DIV_4(a)                   _ACPI_DIV(a,2)
 347 #define ACPI_MUL_4(a)                   _ACPI_MUL(a,2)
 348 #define ACPI_MOD_4(a)                   _ACPI_MOD(a,4)
 349
 350 #define ACPI_DIV_8(a)                   _ACPI_DIV(a,3)
 351 #define ACPI_MUL_8(a)                   _ACPI_MUL(a,3)
 352 #define ACPI_MOD_8(a)                   _ACPI_MOD(a,8)
 353
 354 #define ACPI_DIV_16(a)                  _ACPI_DIV(a,4)
 355 #define ACPI_MUL_16(a)                  _ACPI_MUL(a,4)
 356 #define ACPI_MOD_16(a)                  _ACPI_MOD(a,16)
 357
 358 #define ACPI_DIV_32(a)                  _ACPI_DIV(a,5)
 359 #define ACPI_MUL_32(a)                  _ACPI_MUL(a,5)
 360 #define ACPI_MOD_32(a)                  _ACPI_MOD(a,32)
 361
 362 /*
 363  * Rounding macros (Power of two boundaries only)
 364  */
 365 #define ACPI_ROUND_DOWN(value,boundary)     (((ACPI_NATIVE_UINT)(value)) & \
 366                                                 (~(((ACPI_NATIVE_UINT) boundary)-1)))
 367
 368 #define ACPI_ROUND_UP(value,boundary)       ((((ACPI_NATIVE_UINT)(value)) + \
 369                                                 (((ACPI_NATIVE_UINT) boundary)-1)) & \
 370                                                 (~(((ACPI_NATIVE_UINT) boundary)-1)))
 371
 372 /* Note: sizeof(ACPI_NATIVE_UINT) evaluates to either 2, 4, or 8 */
 373
 374 #define ACPI_ROUND_DOWN_TO_32BIT(a)         ACPI_ROUND_DOWN(a,4)
 375 #define ACPI_ROUND_DOWN_TO_64BIT(a)         ACPI_ROUND_DOWN(a,8)
 376 #define ACPI_ROUND_DOWN_TO_NATIVE_WORD(a)   ACPI_ROUND_DOWN(a,sizeof(ACPI_NATIVE_UINT))
 377
 378 #define ACPI_ROUND_UP_TO_32BIT(a)           ACPI_ROUND_UP(a,4)
 379 #define ACPI_ROUND_UP_TO_64BIT(a)           ACPI_ROUND_UP(a,8)
 380 #define ACPI_ROUND_UP_TO_NATIVE_WORD(a)     ACPI_ROUND_UP(a,sizeof(ACPI_NATIVE_UINT))
 381
 382 #define ACPI_ROUND_BITS_UP_TO_BYTES(a)      ACPI_DIV_8((a) + 7)
 383 #define ACPI_ROUND_BITS_DOWN_TO_BYTES(a)    ACPI_DIV_8((a))
 384
 385 #define ACPI_ROUND_UP_TO_1K(a)              (((a) + 1023) >> 10)
 386
 387 /* Generic (non-power-of-two) rounding */
 388
 389 #define ACPI_ROUND_UP_TO(value,boundary)    (((value) + ((boundary)-1)) / (boundary))
 390
 391 #define ACPI_IS_MISALIGNED(value)           (((ACPI_NATIVE_UINT)value) & (sizeof(ACPI_NATIVE_UINT)-1))
 392
 393 /*
 394  * Bitmask creation
 395  * Bit positions start at zero.
 396  * MASK_BITS_ABOVE creates a mask starting AT the position and above
 397  * MASK_BITS_BELOW creates a mask starting one bit BELOW the position
 398  */
 399 #define ACPI_MASK_BITS_ABOVE(position)      (~((ACPI_INTEGER_MAX) << ((UINT32) (position))))
 400 #define ACPI_MASK_BITS_BELOW(position)      ((ACPI_INTEGER_MAX) << ((UINT32) (position)))
 401
 402 #define ACPI_IS_OCTAL_DIGIT(d)              (((char)(d) >= '0') && ((char)(d) <= '7'))
 403
 404
 405 /* Bitfields within ACPI registers */
 406
 407 #define ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask)      ((Val << Pos) & Mask)
 408 #define ACPI_REGISTER_INSERT_VALUE(Reg, Pos, Mask, Val)  Reg = (Reg & (~(Mask))) | ACPI_REGISTER_PREPARE_BITS(Val, Pos, Mask)
 409
 410 #define ACPI_INSERT_BITS(Target, Mask, Source)          Target = ((Target & (~(Mask))) | (Source & Mask))
 411
 412 /* Generate a UUID */
 413
 414 #define ACPI_INIT_UUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
 415     (a) & 0xFF, ((a) >> 8) & 0xFF, ((a) >> 16) & 0xFF, ((a) >> 24) & 0xFF, \
 416     (b) & 0xFF, ((b) >> 8) & 0xFF, \
 417     (c) & 0xFF, ((c) >> 8) & 0xFF, \
 418     (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)
 419
 420 /*
 421  * An ACPI_NAMESPACE_NODE * can appear in some contexts,
 422  * where a pointer to an ACPI_OPERAND_OBJECT  can also
 423  * appear.  This macro is used to distinguish them.
 424  *
 425  * The "Descriptor" field is the first field in both structures.
 426  */
 427 #define ACPI_GET_DESCRIPTOR_TYPE(d)     (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType)
 428 #define ACPI_SET_DESCRIPTOR_TYPE(d,t)   (((ACPI_DESCRIPTOR *)(void *)(d))->Common.DescriptorType = t)
 429
 430
 431 /* Macro to test the object type */
 432
 433 #define ACPI_GET_OBJECT_TYPE(d)         (((ACPI_OPERAND_OBJECT *)(void *)(d))->Common.Type)
 434
 435 /* Macro to check the table flags for SINGLE or MULTIPLE tables are allowed */
 436
 437 #define ACPI_IS_SINGLE_TABLE(x)         (((x) & 0x01) == ACPI_TABLE_SINGLE ? 1 : 0)
 438
 439 /*
 440  * Macros for the master AML opcode table
 441  */
 442 #if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT)
 443 #define ACPI_OP(Name,PArgs,IArgs,ObjType,Class,Type,Flags)     {Name,(UINT32)(PArgs),(UINT32)(IArgs),(UINT32)(Flags),ObjType,Class,Type}
 444 #else
 445 #define ACPI_OP(Name,PArgs,IArgs,ObjType,Class,Type,Flags)     {(UINT32)(PArgs),(UINT32)(IArgs),(UINT32)(Flags),ObjType,Class,Type}
 446 #endif
 447
 448 #ifdef ACPI_DISASSEMBLER
 449 #define ACPI_DISASM_ONLY_MEMBERS(a)     a;
 450 #else
 451 #define ACPI_DISASM_ONLY_MEMBERS(a)
 452 #endif
 453
 454 #define ARG_TYPE_WIDTH                  5
 455 #define ARG_1(x)                        ((UINT32)(x))
 456 #define ARG_2(x)                        ((UINT32)(x) << (1 * ARG_TYPE_WIDTH))
 457 #define ARG_3(x)                        ((UINT32)(x) << (2 * ARG_TYPE_WIDTH))
 458 #define ARG_4(x)                        ((UINT32)(x) << (3 * ARG_TYPE_WIDTH))
 459 #define ARG_5(x)                        ((UINT32)(x) << (4 * ARG_TYPE_WIDTH))
 460 #define ARG_6(x)                        ((UINT32)(x) << (5 * ARG_TYPE_WIDTH))
 461
 462 #define ARGI_LIST1(a)                   (ARG_1(a))
 463 #define ARGI_LIST2(a,b)                 (ARG_1(b)|ARG_2(a))
 464 #define ARGI_LIST3(a,b,c)               (ARG_1(c)|ARG_2(b)|ARG_3(a))
 465 #define ARGI_LIST4(a,b,c,d)             (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a))
 466 #define ARGI_LIST5(a,b,c,d,e)           (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a))
 467 #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))
 468
 469 #define ARGP_LIST1(a)                   (ARG_1(a))
 470 #define ARGP_LIST2(a,b)                 (ARG_1(a)|ARG_2(b))
 471 #define ARGP_LIST3(a,b,c)               (ARG_1(a)|ARG_2(b)|ARG_3(c))
 472 #define ARGP_LIST4(a,b,c,d)             (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d))
 473 #define ARGP_LIST5(a,b,c,d,e)           (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e))
 474 #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))
 475
 476 #define GET_CURRENT_ARG_TYPE(List)      (List & ((UINT32) 0x1F))
 477 #define INCREMENT_ARG_LIST(List)        (List >>= ((UINT32) ARG_TYPE_WIDTH))
 478
 479
 480 #if defined (ACPI_DEBUG_OUTPUT) || !defined (ACPI_NO_ERROR_MESSAGES)
 481 /*
 482  * Module name is include in both debug and non-debug versions primarily for
 483  * error messages. The __FILE__ macro is not very useful for this, because it
 484  * often includes the entire pathname to the module
 485  */
 486 #define ACPI_MODULE_NAME(Name)          static char ACPI_UNUSED_VAR *_AcpiModuleName = Name;
 487 #else
 488 #define ACPI_MODULE_NAME(Name)
 489 #endif
 490
 491 /*
 492  * Ascii error messages can be configured out
 493  */
 494 #ifndef ACPI_NO_ERROR_MESSAGES
 495 #define AE_INFO                         _AcpiModuleName, __LINE__
 496
 497 /*
 498  * Error reporting. Callers module and line number are inserted by AE_INFO,
 499  * the plist contains a set of parens to allow variable-length lists.
 500  * These macros are used for both the debug and non-debug versions of the code.
 501  */
 502 #define ACPI_INFO(plist)                AcpiUtInfo plist
 503 #define ACPI_WARNING(plist)             AcpiUtWarning plist
 504 #define ACPI_EXCEPTION(plist)           AcpiUtException plist
 505 #define ACPI_ERROR(plist)               AcpiUtError plist
 506 #define ACPI_ERROR_NAMESPACE(s,e)       AcpiNsReportError (AE_INFO, s, e);
 507 #define ACPI_ERROR_METHOD(s,n,p,e)      AcpiNsReportMethodError (AE_INFO, s, n, p, e);
 508
 509 #else
 510
 511 /* No error messages */
 512
 513 #define ACPI_INFO(plist)
 514 #define ACPI_WARNING(plist)
 515 #define ACPI_EXCEPTION(plist)
 516 #define ACPI_ERROR(plist)
 517 #define ACPI_ERROR_NAMESPACE(s,e)
 518 #define ACPI_ERROR_METHOD(s,n,p,e)
 519 #endif
 520
 521 /*
 522  * Debug macros that are conditionally compiled
 523  */
 524 #ifdef ACPI_DEBUG_OUTPUT
 525
 526 /*
 527  * Common parameters used for debug output functions:
 528  * line number, function name, module(file) name, component ID
 529  */
 530 #define ACPI_DEBUG_PARAMETERS           __LINE__, ACPI_GET_FUNCTION_NAME, _AcpiModuleName, _COMPONENT
 531
 532 /*
 533  * Function entry tracing
 534  */
 535
 536 /*
 537  * If ACPI_GET_FUNCTION_NAME was not defined in the compiler-dependent header,
 538  * define it now. This is the case where there the compiler does not support
 539  * a __FUNCTION__ macro or equivalent. We save the function name on the
 540  * local stack.
 541  */
 542 #ifndef ACPI_GET_FUNCTION_NAME
 543 #define ACPI_GET_FUNCTION_NAME          _AcpiFunctionName
 544 /*
 545  * The Name parameter should be the procedure name as a quoted string.
 546  * This is declared as a local string ("MyFunctionName") so that it can
 547  * be also used by the function exit macros below.
 548  * Note: (const char) is used to be compatible with the debug interfaces
 549  * and macros such as __FUNCTION__.
 550  */
 551 #define ACPI_FUNCTION_NAME(Name)        const char *_AcpiFunctionName = #Name;
 552
 553 #else
 554 /* Compiler supports __FUNCTION__ (or equivalent) -- Ignore this macro */
 555
 556 #define ACPI_FUNCTION_NAME(Name)
 557 #endif
 558
 559 #define ACPI_FUNCTION_TRACE(a)          ACPI_FUNCTION_NAME(a) \
 560                                             AcpiUtTrace(ACPI_DEBUG_PARAMETERS)
 561 #define ACPI_FUNCTION_TRACE_PTR(a,b)    ACPI_FUNCTION_NAME(a) \
 562                                             AcpiUtTracePtr(ACPI_DEBUG_PARAMETERS,(void *)b)
 563 #define ACPI_FUNCTION_TRACE_U32(a,b)    ACPI_FUNCTION_NAME(a) \
 564                                             AcpiUtTraceU32(ACPI_DEBUG_PARAMETERS,(UINT32)b)
 565 #define ACPI_FUNCTION_TRACE_STR(a,b)    ACPI_FUNCTION_NAME(a) \
 566                                             AcpiUtTraceStr(ACPI_DEBUG_PARAMETERS,(char *)b)
 567
 568 #define ACPI_FUNCTION_ENTRY()           AcpiUtTrackStackPtr()
 569
 570 /*
 571  * Function exit tracing.
 572  * WARNING: These macros include a return statement.  This is usually considered
 573  * bad form, but having a separate exit macro is very ugly and difficult to maintain.
 574  * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros
 575  * so that "_AcpiFunctionName" is defined.
 576  *
 577  * Note: the DO_WHILE0 macro is used to prevent some compilers from complaining
 578  * about these constructs.
 579  */
 580 #ifdef ACPI_USE_DO_WHILE_0
 581 #define ACPI_DO_WHILE0(a)               do a while(0)
 582 #else
 583 #define ACPI_DO_WHILE0(a)               a
 584 #endif
 585
 586 #define return_VOID                     ACPI_DO_WHILE0 ({ \
 587                                             AcpiUtExit (ACPI_DEBUG_PARAMETERS); \
 588                                             return;})
 589 /*
 590  * There are two versions of most of the return macros. The default version is
 591  * safer, since it avoids side-effects by guaranteeing that the argument will
 592  * not be evaluated twice.
 593  *
 594  * A less-safe version of the macros is provided for optional use if the
 595  * compiler uses excessive CPU stack (for example, this may happen in the
 596  * debug case if code optimzation is disabled.)
 597  */
 598 #ifndef ACPI_SIMPLE_RETURN_MACROS
 599
 600 #define return_ACPI_STATUS(s)           ACPI_DO_WHILE0 ({ \
 601                                             register ACPI_STATUS _s = (s); \
 602                                             AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, _s); \
 603                                             return (_s); })
 604 #define return_PTR(s)                   ACPI_DO_WHILE0 ({ \
 605                                             register void *_s = (void *) (s); \
 606                                             AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) _s); \
 607                                             return (_s); })
 608 #define return_VALUE(s)                 ACPI_DO_WHILE0 ({ \
 609                                             register ACPI_INTEGER _s = (s); \
 610                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, _s); \
 611                                             return (_s); })
 612 #define return_UINT8(s)                 ACPI_DO_WHILE0 ({ \
 613                                             register UINT8 _s = (UINT8) (s); \
 614                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \
 615                                             return (_s); })
 616 #define return_UINT32(s)                ACPI_DO_WHILE0 ({ \
 617                                             register UINT32 _s = (UINT32) (s); \
 618                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) _s); \
 619                                             return (_s); })
 620 #else /* Use original less-safe macros */
 621
 622 #define return_ACPI_STATUS(s)           ACPI_DO_WHILE0 ({ \
 623                                             AcpiUtStatusExit (ACPI_DEBUG_PARAMETERS, (s)); \
 624                                             return((s)); })
 625 #define return_PTR(s)                   ACPI_DO_WHILE0 ({ \
 626                                             AcpiUtPtrExit (ACPI_DEBUG_PARAMETERS, (UINT8 *) (s)); \
 627                                             return((s)); })
 628 #define return_VALUE(s)                 ACPI_DO_WHILE0 ({ \
 629                                             AcpiUtValueExit (ACPI_DEBUG_PARAMETERS, (ACPI_INTEGER) (s)); \
 630                                             return((s)); })
 631 #define return_UINT8(s)                 return_VALUE(s)
 632 #define return_UINT32(s)                return_VALUE(s)
 633
 634 #endif /* ACPI_SIMPLE_RETURN_MACROS */
 635
 636
 637 /* Conditional execution */
 638
 639 #define ACPI_DEBUG_EXEC(a)              a
 640 #define ACPI_NORMAL_EXEC(a)
 641
 642 #define ACPI_DEBUG_DEFINE(a)            a;
 643 #define ACPI_DEBUG_ONLY_MEMBERS(a)      a;
 644 #define _VERBOSE_STRUCTURES
 645
 646
 647 /* Stack and buffer dumping */
 648
 649 #define ACPI_DUMP_STACK_ENTRY(a)        AcpiExDumpOperand((a),0)
 650 #define ACPI_DUMP_OPERANDS(a,b,c,d,e)   AcpiExDumpOperands(a,b,c,d,e,_AcpiModuleName,__LINE__)
 651
 652
 653 #define ACPI_DUMP_ENTRY(a,b)            AcpiNsDumpEntry (a,b)
 654 #define ACPI_DUMP_PATHNAME(a,b,c,d)     AcpiNsDumpPathname(a,b,c,d)
 655 #define ACPI_DUMP_RESOURCE_LIST(a)      AcpiRsDumpResourceList(a)
 656 #define ACPI_DUMP_BUFFER(a,b)           AcpiUtDumpBuffer((UINT8 *)a,b,DB_BYTE_DISPLAY,_COMPONENT)
 657
 658 /*
 659  * Master debug print macros
 660  * Print iff:
 661  *    1) Debug print for the current component is enabled
 662  *    2) Debug error level or trace level for the print statement is enabled
 663  */
 664 #define ACPI_DEBUG_PRINT(plist)         AcpiUtDebugPrint plist
 665 #define ACPI_DEBUG_PRINT_RAW(plist)     AcpiUtDebugPrintRaw plist
 666
 667
 668 #else
 669 /*
 670  * This is the non-debug case -- make everything go away,
 671  * leaving no executable debug code!
 672  */
 673 #define ACPI_DEBUG_EXEC(a)
 674 #define ACPI_NORMAL_EXEC(a)             a;
 675
 676 #define ACPI_DEBUG_DEFINE(a)
 677 #define ACPI_DEBUG_ONLY_MEMBERS(a)
 678 #define ACPI_FUNCTION_NAME(a)
 679 #define ACPI_FUNCTION_TRACE(a)
 680 #define ACPI_FUNCTION_TRACE_PTR(a,b)
 681 #define ACPI_FUNCTION_TRACE_U32(a,b)
 682 #define ACPI_FUNCTION_TRACE_STR(a,b)
 683 #define ACPI_FUNCTION_EXIT
 684 #define ACPI_FUNCTION_STATUS_EXIT(s)
 685 #define ACPI_FUNCTION_VALUE_EXIT(s)
 686 #define ACPI_FUNCTION_ENTRY()
 687 #define ACPI_DUMP_STACK_ENTRY(a)
 688 #define ACPI_DUMP_OPERANDS(a,b,c,d,e)
 689 #define ACPI_DUMP_ENTRY(a,b)
 690 #define ACPI_DUMP_TABLES(a,b)
 691 #define ACPI_DUMP_PATHNAME(a,b,c,d)
 692 #define ACPI_DUMP_RESOURCE_LIST(a)
 693 #define ACPI_DUMP_BUFFER(a,b)
 694 #define ACPI_DEBUG_PRINT(pl)
 695 #define ACPI_DEBUG_PRINT_RAW(pl)
 696
 697 #define return_VOID                     return
 698 #define return_ACPI_STATUS(s)           return(s)
 699 #define return_VALUE(s)                 return(s)
 700 #define return_UINT8(s)                 return(s)
 701 #define return_UINT32(s)                return(s)
 702 #define return_PTR(s)                   return(s)
 703
 704 #endif
 705
 706 /*
 707  * Some code only gets executed when the debugger is built in.
 708  * Note that this is entirely independent of whether the
 709  * DEBUG_PRINT stuff (set by ACPI_DEBUG_OUTPUT) is on, or not.
 710  */
 711 #ifdef ACPI_DEBUGGER
 712 #define ACPI_DEBUGGER_EXEC(a)           a
 713 #else
 714 #define ACPI_DEBUGGER_EXEC(a)
 715 #endif
 716
 717
 718 #ifdef ACPI_DEBUG_OUTPUT
 719 /*
 720  * 1) Set name to blanks
 721  * 2) Copy the object name
 722  */
 723 #define ACPI_ADD_OBJECT_NAME(a,b)       ACPI_MEMSET (a->Common.Name, ' ', sizeof (a->Common.Name));\
 724                                         ACPI_STRNCPY (a->Common.Name, AcpiGbl_NsTypeNames[b], sizeof (a->Common.Name))
 725 #else
 726
 727 #define ACPI_ADD_OBJECT_NAME(a,b)
 728 #endif
 729
 730
 731 /*
 732  * Memory allocation tracking (DEBUG ONLY)
 733  */
 734 #ifndef ACPI_DBG_TRACK_ALLOCATIONS
 735
 736 /* Memory allocation */
 737
 738 #define ACPI_ALLOCATE(a)            AcpiUtAllocate((ACPI_SIZE)(a),_COMPONENT,_AcpiModuleName,__LINE__)
 739 #define ACPI_ALLOCATE_ZEROED(a)     AcpiUtAllocateZeroed((ACPI_SIZE)(a), _COMPONENT,_AcpiModuleName,__LINE__)
 740 #define ACPI_FREE(a)                AcpiOsFree(a)
 741 #define ACPI_MEM_TRACKING(a)
 742
 743 #else
 744
 745 /* Memory allocation */
 746
 747 #define ACPI_ALLOCATE(a)            AcpiUtAllocateAndTrack((ACPI_SIZE)(a),_COMPONENT,_AcpiModuleName,__LINE__)
 748 #define ACPI_ALLOCATE_ZEROED(a)     AcpiUtAllocateZeroedAndTrack((ACPI_SIZE)(a), _COMPONENT,_AcpiModuleName,__LINE__)
 749 #define ACPI_FREE(a)                AcpiUtFreeAndTrack(a,_COMPONENT,_AcpiModuleName,__LINE__)
 750 #define ACPI_MEM_TRACKING(a)        a
 751
 752 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */
 753
 754 #endif /* ACMACROS_H */