acmacros.h revision 193249
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 */ 755