diff options
author | Len Brown <len.brown@intel.com> | 2009-01-09 00:30:03 -0500 |
---|---|---|
committer | Len Brown <len.brown@intel.com> | 2009-01-09 03:31:01 -0500 |
commit | e2f7a7772880458edff1b1cc5a988947229fac26 (patch) | |
tree | 049be58c6b7de3d8453deaaa606d2080ade7d51f /include/acpi/acmacros.h | |
parent | 95b482a8d31116f3f5c2a5089569393234d06385 (diff) |
ACPICA: hide private headers
Signed-off-by: Len Brown <len.brown@intel.com>
Diffstat (limited to 'include/acpi/acmacros.h')
-rw-r--r-- | include/acpi/acmacros.h | 577 |
1 files changed, 0 insertions, 577 deletions
diff --git a/include/acpi/acmacros.h b/include/acpi/acmacros.h deleted file mode 100644 index c57286a3aceb..000000000000 --- a/include/acpi/acmacros.h +++ /dev/null | |||
@@ -1,577 +0,0 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * Name: acmacros.h - C macros for the entire subsystem. | ||
4 | * | ||
5 | *****************************************************************************/ | ||
6 | |||
7 | /* | ||
8 | * Copyright (C) 2000 - 2008, Intel Corp. | ||
9 | * All rights reserved. | ||
10 | * | ||
11 | * Redistribution and use in source and binary forms, with or without | ||
12 | * modification, are permitted provided that the following conditions | ||
13 | * are met: | ||
14 | * 1. Redistributions of source code must retain the above copyright | ||
15 | * notice, this list of conditions, and the following disclaimer, | ||
16 | * without modification. | ||
17 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | ||
18 | * substantially similar to the "NO WARRANTY" disclaimer below | ||
19 | * ("Disclaimer") and any redistribution must be conditioned upon | ||
20 | * including a substantially similar Disclaimer requirement for further | ||
21 | * binary redistribution. | ||
22 | * 3. Neither the names of the above-listed copyright holders nor the names | ||
23 | * of any contributors may be used to endorse or promote products derived | ||
24 | * from this software without specific prior written permission. | ||
25 | * | ||
26 | * Alternatively, this software may be distributed under the terms of the | ||
27 | * GNU General Public License ("GPL") version 2 as published by the Free | ||
28 | * Software Foundation. | ||
29 | * | ||
30 | * NO WARRANTY | ||
31 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
32 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
33 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | ||
34 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
35 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
36 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
37 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
38 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
39 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | ||
40 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | ||
41 | * POSSIBILITY OF SUCH DAMAGES. | ||
42 | */ | ||
43 | |||
44 | #ifndef __ACMACROS_H__ | ||
45 | #define __ACMACROS_H__ | ||
46 | |||
47 | /* | ||
48 | * Extract data using a pointer. Any more than a byte and we | ||
49 | * get into potential aligment issues -- see the STORE macros below. | ||
50 | * Use with care. | ||
51 | */ | ||
52 | #define ACPI_GET8(ptr) *ACPI_CAST_PTR (u8, ptr) | ||
53 | #define ACPI_GET16(ptr) *ACPI_CAST_PTR (u16, ptr) | ||
54 | #define ACPI_GET32(ptr) *ACPI_CAST_PTR (u32, ptr) | ||
55 | #define ACPI_GET64(ptr) *ACPI_CAST_PTR (u64, ptr) | ||
56 | #define ACPI_SET8(ptr) *ACPI_CAST_PTR (u8, ptr) | ||
57 | #define ACPI_SET16(ptr) *ACPI_CAST_PTR (u16, ptr) | ||
58 | #define ACPI_SET32(ptr) *ACPI_CAST_PTR (u32, ptr) | ||
59 | #define ACPI_SET64(ptr) *ACPI_CAST_PTR (u64, ptr) | ||
60 | |||
61 | /* | ||
62 | * printf() format helpers | ||
63 | */ | ||
64 | |||
65 | /* Split 64-bit integer into two 32-bit values. Use with %8.8_x%8.8_x */ | ||
66 | |||
67 | #define ACPI_FORMAT_UINT64(i) ACPI_HIDWORD(i), ACPI_LODWORD(i) | ||
68 | |||
69 | #if ACPI_MACHINE_WIDTH == 64 | ||
70 | #define ACPI_FORMAT_NATIVE_UINT(i) ACPI_FORMAT_UINT64(i) | ||
71 | #else | ||
72 | #define ACPI_FORMAT_NATIVE_UINT(i) 0, (i) | ||
73 | #endif | ||
74 | |||
75 | /* | ||
76 | * Macros for moving data around to/from buffers that are possibly unaligned. | ||
77 | * If the hardware supports the transfer of unaligned data, just do the store. | ||
78 | * Otherwise, we have to move one byte at a time. | ||
79 | */ | ||
80 | #ifdef ACPI_BIG_ENDIAN | ||
81 | /* | ||
82 | * Macros for big-endian machines | ||
83 | */ | ||
84 | |||
85 | /* These macros reverse the bytes during the move, converting little-endian to big endian */ | ||
86 | |||
87 | /* Big Endian <== Little Endian */ | ||
88 | /* Hi...Lo Lo...Hi */ | ||
89 | /* 16-bit source, 16/32/64 destination */ | ||
90 | |||
91 | #define ACPI_MOVE_16_TO_16(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[1];\ | ||
92 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[0];} | ||
93 | |||
94 | #define ACPI_MOVE_16_TO_32(d, s) {(*(u32 *)(void *)(d))=0;\ | ||
95 | ((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\ | ||
96 | ((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];} | ||
97 | |||
98 | #define ACPI_MOVE_16_TO_64(d, s) {(*(u64 *)(void *)(d))=0;\ | ||
99 | ((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ | ||
100 | ((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} | ||
101 | |||
102 | /* 32-bit source, 16/32/64 destination */ | ||
103 | |||
104 | #define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
105 | |||
106 | #define ACPI_MOVE_32_TO_32(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[3];\ | ||
107 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[2];\ | ||
108 | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\ | ||
109 | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];} | ||
110 | |||
111 | #define ACPI_MOVE_32_TO_64(d, s) {(*(u64 *)(void *)(d))=0;\ | ||
112 | ((u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3];\ | ||
113 | ((u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[2];\ | ||
114 | ((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ | ||
115 | ((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} | ||
116 | |||
117 | /* 64-bit source, 16/32/64 destination */ | ||
118 | |||
119 | #define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
120 | |||
121 | #define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ | ||
122 | |||
123 | #define ACPI_MOVE_64_TO_64(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[7];\ | ||
124 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[6];\ | ||
125 | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[5];\ | ||
126 | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[4];\ | ||
127 | (( u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3];\ | ||
128 | (( u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[2];\ | ||
129 | (( u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ | ||
130 | (( u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} | ||
131 | #else | ||
132 | /* | ||
133 | * Macros for little-endian machines | ||
134 | */ | ||
135 | |||
136 | #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED | ||
137 | |||
138 | /* The hardware supports unaligned transfers, just do the little-endian move */ | ||
139 | |||
140 | /* 16-bit source, 16/32/64 destination */ | ||
141 | |||
142 | #define ACPI_MOVE_16_TO_16(d, s) *(u16 *)(void *)(d) = *(u16 *)(void *)(s) | ||
143 | #define ACPI_MOVE_16_TO_32(d, s) *(u32 *)(void *)(d) = *(u16 *)(void *)(s) | ||
144 | #define ACPI_MOVE_16_TO_64(d, s) *(u64 *)(void *)(d) = *(u16 *)(void *)(s) | ||
145 | |||
146 | /* 32-bit source, 16/32/64 destination */ | ||
147 | |||
148 | #define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
149 | #define ACPI_MOVE_32_TO_32(d, s) *(u32 *)(void *)(d) = *(u32 *)(void *)(s) | ||
150 | #define ACPI_MOVE_32_TO_64(d, s) *(u64 *)(void *)(d) = *(u32 *)(void *)(s) | ||
151 | |||
152 | /* 64-bit source, 16/32/64 destination */ | ||
153 | |||
154 | #define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
155 | #define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ | ||
156 | #define ACPI_MOVE_64_TO_64(d, s) *(u64 *)(void *)(d) = *(u64 *)(void *)(s) | ||
157 | |||
158 | #else | ||
159 | /* | ||
160 | * The hardware does not support unaligned transfers. We must move the | ||
161 | * data one byte at a time. These macros work whether the source or | ||
162 | * the destination (or both) is/are unaligned. (Little-endian move) | ||
163 | */ | ||
164 | |||
165 | /* 16-bit source, 16/32/64 destination */ | ||
166 | |||
167 | #define ACPI_MOVE_16_TO_16(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ | ||
168 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];} | ||
169 | |||
170 | #define ACPI_MOVE_16_TO_32(d, s) {(*(u32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} | ||
171 | #define ACPI_MOVE_16_TO_64(d, s) {(*(u64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d, s);} | ||
172 | |||
173 | /* 32-bit source, 16/32/64 destination */ | ||
174 | |||
175 | #define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
176 | |||
177 | #define ACPI_MOVE_32_TO_32(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ | ||
178 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];\ | ||
179 | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[2];\ | ||
180 | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[3];} | ||
181 | |||
182 | #define ACPI_MOVE_32_TO_64(d, s) {(*(u64 *)(void *)(d)) = 0; ACPI_MOVE_32_TO_32(d, s);} | ||
183 | |||
184 | /* 64-bit source, 16/32/64 destination */ | ||
185 | |||
186 | #define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ | ||
187 | #define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ | ||
188 | #define ACPI_MOVE_64_TO_64(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ | ||
189 | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];\ | ||
190 | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[2];\ | ||
191 | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[3];\ | ||
192 | (( u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[4];\ | ||
193 | (( u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[5];\ | ||
194 | (( u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[6];\ | ||
195 | (( u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[7];} | ||
196 | #endif | ||
197 | #endif | ||
198 | |||
199 | /* Macros based on machine integer width */ | ||
200 | |||
201 | #if ACPI_MACHINE_WIDTH == 32 | ||
202 | #define ACPI_MOVE_SIZE_TO_16(d, s) ACPI_MOVE_32_TO_16(d, s) | ||
203 | |||
204 | #elif ACPI_MACHINE_WIDTH == 64 | ||
205 | #define ACPI_MOVE_SIZE_TO_16(d, s) ACPI_MOVE_64_TO_16(d, s) | ||
206 | |||
207 | #else | ||
208 | #error unknown ACPI_MACHINE_WIDTH | ||
209 | #endif | ||
210 | |||
211 | /* | ||
212 | * Fast power-of-two math macros for non-optimized compilers | ||
213 | */ | ||
214 | #define _ACPI_DIV(value, power_of2) ((u32) ((value) >> (power_of2))) | ||
215 | #define _ACPI_MUL(value, power_of2) ((u32) ((value) << (power_of2))) | ||
216 | #define _ACPI_MOD(value, divisor) ((u32) ((value) & ((divisor) -1))) | ||
217 | |||
218 | #define ACPI_DIV_2(a) _ACPI_DIV(a, 1) | ||
219 | #define ACPI_MUL_2(a) _ACPI_MUL(a, 1) | ||
220 | #define ACPI_MOD_2(a) _ACPI_MOD(a, 2) | ||
221 | |||
222 | #define ACPI_DIV_4(a) _ACPI_DIV(a, 2) | ||
223 | #define ACPI_MUL_4(a) _ACPI_MUL(a, 2) | ||
224 | #define ACPI_MOD_4(a) _ACPI_MOD(a, 4) | ||
225 | |||
226 | #define ACPI_DIV_8(a) _ACPI_DIV(a, 3) | ||
227 | #define ACPI_MUL_8(a) _ACPI_MUL(a, 3) | ||
228 | #define ACPI_MOD_8(a) _ACPI_MOD(a, 8) | ||
229 | |||
230 | #define ACPI_DIV_16(a) _ACPI_DIV(a, 4) | ||
231 | #define ACPI_MUL_16(a) _ACPI_MUL(a, 4) | ||
232 | #define ACPI_MOD_16(a) _ACPI_MOD(a, 16) | ||
233 | |||
234 | #define ACPI_DIV_32(a) _ACPI_DIV(a, 5) | ||
235 | #define ACPI_MUL_32(a) _ACPI_MUL(a, 5) | ||
236 | #define ACPI_MOD_32(a) _ACPI_MOD(a, 32) | ||
237 | |||
238 | /* | ||
239 | * Rounding macros (Power of two boundaries only) | ||
240 | */ | ||
241 | #define ACPI_ROUND_DOWN(value, boundary) (((acpi_size)(value)) & \ | ||
242 | (~(((acpi_size) boundary)-1))) | ||
243 | |||
244 | #define ACPI_ROUND_UP(value, boundary) ((((acpi_size)(value)) + \ | ||
245 | (((acpi_size) boundary)-1)) & \ | ||
246 | (~(((acpi_size) boundary)-1))) | ||
247 | |||
248 | /* Note: sizeof(acpi_size) evaluates to either 4 or 8 (32- vs 64-bit mode) */ | ||
249 | |||
250 | #define ACPI_ROUND_DOWN_TO_32BIT(a) ACPI_ROUND_DOWN(a, 4) | ||
251 | #define ACPI_ROUND_DOWN_TO_64BIT(a) ACPI_ROUND_DOWN(a, 8) | ||
252 | #define ACPI_ROUND_DOWN_TO_NATIVE_WORD(a) ACPI_ROUND_DOWN(a, sizeof(acpi_size)) | ||
253 | |||
254 | #define ACPI_ROUND_UP_TO_32BIT(a) ACPI_ROUND_UP(a, 4) | ||
255 | #define ACPI_ROUND_UP_TO_64BIT(a) ACPI_ROUND_UP(a, 8) | ||
256 | #define ACPI_ROUND_UP_TO_NATIVE_WORD(a) ACPI_ROUND_UP(a, sizeof(acpi_size)) | ||
257 | |||
258 | #define ACPI_ROUND_BITS_UP_TO_BYTES(a) ACPI_DIV_8((a) + 7) | ||
259 | #define ACPI_ROUND_BITS_DOWN_TO_BYTES(a) ACPI_DIV_8((a)) | ||
260 | |||
261 | #define ACPI_ROUND_UP_TO_1K(a) (((a) + 1023) >> 10) | ||
262 | |||
263 | /* Generic (non-power-of-two) rounding */ | ||
264 | |||
265 | #define ACPI_ROUND_UP_TO(value, boundary) (((value) + ((boundary)-1)) / (boundary)) | ||
266 | |||
267 | #define ACPI_IS_MISALIGNED(value) (((acpi_size) value) & (sizeof(acpi_size)-1)) | ||
268 | |||
269 | /* | ||
270 | * Bitmask creation | ||
271 | * Bit positions start at zero. | ||
272 | * MASK_BITS_ABOVE creates a mask starting AT the position and above | ||
273 | * MASK_BITS_BELOW creates a mask starting one bit BELOW the position | ||
274 | */ | ||
275 | #define ACPI_MASK_BITS_ABOVE(position) (~((ACPI_INTEGER_MAX) << ((u32) (position)))) | ||
276 | #define ACPI_MASK_BITS_BELOW(position) ((ACPI_INTEGER_MAX) << ((u32) (position))) | ||
277 | |||
278 | /* Bitfields within ACPI registers */ | ||
279 | |||
280 | #define ACPI_REGISTER_PREPARE_BITS(val, pos, mask) ((val << pos) & mask) | ||
281 | #define ACPI_REGISTER_INSERT_VALUE(reg, pos, mask, val) reg = (reg & (~(mask))) | ACPI_REGISTER_PREPARE_BITS(val, pos, mask) | ||
282 | |||
283 | #define ACPI_INSERT_BITS(target, mask, source) target = ((target & (~(mask))) | (source & mask)) | ||
284 | |||
285 | /* | ||
286 | * An struct acpi_namespace_node can appear in some contexts | ||
287 | * where a pointer to an union acpi_operand_object can also | ||
288 | * appear. This macro is used to distinguish them. | ||
289 | * | ||
290 | * The "Descriptor" field is the first field in both structures. | ||
291 | */ | ||
292 | #define ACPI_GET_DESCRIPTOR_TYPE(d) (((union acpi_descriptor *)(void *)(d))->common.descriptor_type) | ||
293 | #define ACPI_SET_DESCRIPTOR_TYPE(d, t) (((union acpi_descriptor *)(void *)(d))->common.descriptor_type = t) | ||
294 | |||
295 | /* Macro to test the object type */ | ||
296 | |||
297 | #define ACPI_GET_OBJECT_TYPE(d) (((union acpi_operand_object *)(void *)(d))->common.type) | ||
298 | |||
299 | /* | ||
300 | * Macros for the master AML opcode table | ||
301 | */ | ||
302 | #if defined (ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT) | ||
303 | #define ACPI_OP(name, Pargs, Iargs, obj_type, class, type, flags) \ | ||
304 | {name, (u32)(Pargs), (u32)(Iargs), (u32)(flags), obj_type, class, type} | ||
305 | #else | ||
306 | #define ACPI_OP(name, Pargs, Iargs, obj_type, class, type, flags) \ | ||
307 | {(u32)(Pargs), (u32)(Iargs), (u32)(flags), obj_type, class, type} | ||
308 | #endif | ||
309 | |||
310 | #define ARG_TYPE_WIDTH 5 | ||
311 | #define ARG_1(x) ((u32)(x)) | ||
312 | #define ARG_2(x) ((u32)(x) << (1 * ARG_TYPE_WIDTH)) | ||
313 | #define ARG_3(x) ((u32)(x) << (2 * ARG_TYPE_WIDTH)) | ||
314 | #define ARG_4(x) ((u32)(x) << (3 * ARG_TYPE_WIDTH)) | ||
315 | #define ARG_5(x) ((u32)(x) << (4 * ARG_TYPE_WIDTH)) | ||
316 | #define ARG_6(x) ((u32)(x) << (5 * ARG_TYPE_WIDTH)) | ||
317 | |||
318 | #define ARGI_LIST1(a) (ARG_1(a)) | ||
319 | #define ARGI_LIST2(a, b) (ARG_1(b)|ARG_2(a)) | ||
320 | #define ARGI_LIST3(a, b, c) (ARG_1(c)|ARG_2(b)|ARG_3(a)) | ||
321 | #define ARGI_LIST4(a, b, c, d) (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a)) | ||
322 | #define ARGI_LIST5(a, b, c, d, e) (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a)) | ||
323 | #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)) | ||
324 | |||
325 | #define ARGP_LIST1(a) (ARG_1(a)) | ||
326 | #define ARGP_LIST2(a, b) (ARG_1(a)|ARG_2(b)) | ||
327 | #define ARGP_LIST3(a, b, c) (ARG_1(a)|ARG_2(b)|ARG_3(c)) | ||
328 | #define ARGP_LIST4(a, b, c, d) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)) | ||
329 | #define ARGP_LIST5(a, b, c, d, e) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)) | ||
330 | #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)) | ||
331 | |||
332 | #define GET_CURRENT_ARG_TYPE(list) (list & ((u32) 0x1F)) | ||
333 | #define INCREMENT_ARG_LIST(list) (list >>= ((u32) ARG_TYPE_WIDTH)) | ||
334 | |||
335 | /* | ||
336 | * Ascii error messages can be configured out | ||
337 | */ | ||
338 | #ifndef ACPI_NO_ERROR_MESSAGES | ||
339 | |||
340 | /* | ||
341 | * Error reporting. Callers module and line number are inserted by AE_INFO, | ||
342 | * the plist contains a set of parens to allow variable-length lists. | ||
343 | * These macros are used for both the debug and non-debug versions of the code. | ||
344 | */ | ||
345 | #define ACPI_ERROR_NAMESPACE(s, e) acpi_ns_report_error (AE_INFO, s, e); | ||
346 | #define ACPI_ERROR_METHOD(s, n, p, e) acpi_ns_report_method_error (AE_INFO, s, n, p, e); | ||
347 | |||
348 | #else | ||
349 | |||
350 | /* No error messages */ | ||
351 | |||
352 | #define ACPI_ERROR_NAMESPACE(s, e) | ||
353 | #define ACPI_ERROR_METHOD(s, n, p, e) | ||
354 | #endif /* ACPI_NO_ERROR_MESSAGES */ | ||
355 | |||
356 | /* | ||
357 | * Debug macros that are conditionally compiled | ||
358 | */ | ||
359 | #ifdef ACPI_DEBUG_OUTPUT | ||
360 | |||
361 | /* | ||
362 | * Function entry tracing | ||
363 | */ | ||
364 | #ifdef CONFIG_ACPI_DEBUG_FUNC_TRACE | ||
365 | |||
366 | #define ACPI_FUNCTION_TRACE(a) ACPI_FUNCTION_NAME(a) \ | ||
367 | acpi_ut_trace(ACPI_DEBUG_PARAMETERS) | ||
368 | #define ACPI_FUNCTION_TRACE_PTR(a, b) ACPI_FUNCTION_NAME(a) \ | ||
369 | acpi_ut_trace_ptr(ACPI_DEBUG_PARAMETERS, (void *)b) | ||
370 | #define ACPI_FUNCTION_TRACE_U32(a, b) ACPI_FUNCTION_NAME(a) \ | ||
371 | acpi_ut_trace_u32(ACPI_DEBUG_PARAMETERS, (u32)b) | ||
372 | #define ACPI_FUNCTION_TRACE_STR(a, b) ACPI_FUNCTION_NAME(a) \ | ||
373 | acpi_ut_trace_str(ACPI_DEBUG_PARAMETERS, (char *)b) | ||
374 | |||
375 | #define ACPI_FUNCTION_ENTRY() acpi_ut_track_stack_ptr() | ||
376 | |||
377 | /* | ||
378 | * Function exit tracing. | ||
379 | * WARNING: These macros include a return statement. This is usually considered | ||
380 | * bad form, but having a separate exit macro is very ugly and difficult to maintain. | ||
381 | * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros | ||
382 | * so that "_AcpiFunctionName" is defined. | ||
383 | * | ||
384 | * Note: the DO_WHILE0 macro is used to prevent some compilers from complaining | ||
385 | * about these constructs. | ||
386 | */ | ||
387 | #ifdef ACPI_USE_DO_WHILE_0 | ||
388 | #define ACPI_DO_WHILE0(a) do a while(0) | ||
389 | #else | ||
390 | #define ACPI_DO_WHILE0(a) a | ||
391 | #endif | ||
392 | |||
393 | #define return_VOID ACPI_DO_WHILE0 ({ \ | ||
394 | acpi_ut_exit (ACPI_DEBUG_PARAMETERS); \ | ||
395 | return;}) | ||
396 | /* | ||
397 | * There are two versions of most of the return macros. The default version is | ||
398 | * safer, since it avoids side-effects by guaranteeing that the argument will | ||
399 | * not be evaluated twice. | ||
400 | * | ||
401 | * A less-safe version of the macros is provided for optional use if the | ||
402 | * compiler uses excessive CPU stack (for example, this may happen in the | ||
403 | * debug case if code optimzation is disabled.) | ||
404 | */ | ||
405 | #ifndef ACPI_SIMPLE_RETURN_MACROS | ||
406 | |||
407 | #define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ | ||
408 | register acpi_status _s = (s); \ | ||
409 | acpi_ut_status_exit (ACPI_DEBUG_PARAMETERS, _s); \ | ||
410 | return (_s); }) | ||
411 | #define return_PTR(s) ACPI_DO_WHILE0 ({ \ | ||
412 | register void *_s = (void *) (s); \ | ||
413 | acpi_ut_ptr_exit (ACPI_DEBUG_PARAMETERS, (u8 *) _s); \ | ||
414 | return (_s); }) | ||
415 | #define return_VALUE(s) ACPI_DO_WHILE0 ({ \ | ||
416 | register acpi_integer _s = (s); \ | ||
417 | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, _s); \ | ||
418 | return (_s); }) | ||
419 | #define return_UINT8(s) ACPI_DO_WHILE0 ({ \ | ||
420 | register u8 _s = (u8) (s); \ | ||
421 | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \ | ||
422 | return (_s); }) | ||
423 | #define return_UINT32(s) ACPI_DO_WHILE0 ({ \ | ||
424 | register u32 _s = (u32) (s); \ | ||
425 | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \ | ||
426 | return (_s); }) | ||
427 | #else /* Use original less-safe macros */ | ||
428 | |||
429 | #define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ | ||
430 | acpi_ut_status_exit (ACPI_DEBUG_PARAMETERS, (s)); \ | ||
431 | return((s)); }) | ||
432 | #define return_PTR(s) ACPI_DO_WHILE0 ({ \ | ||
433 | acpi_ut_ptr_exit (ACPI_DEBUG_PARAMETERS, (u8 *) (s)); \ | ||
434 | return((s)); }) | ||
435 | #define return_VALUE(s) ACPI_DO_WHILE0 ({ \ | ||
436 | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) (s)); \ | ||
437 | return((s)); }) | ||
438 | #define return_UINT8(s) return_VALUE(s) | ||
439 | #define return_UINT32(s) return_VALUE(s) | ||
440 | |||
441 | #endif /* ACPI_SIMPLE_RETURN_MACROS */ | ||
442 | |||
443 | #else /* !CONFIG_ACPI_DEBUG_FUNC_TRACE */ | ||
444 | |||
445 | #define ACPI_FUNCTION_TRACE(a) | ||
446 | #define ACPI_FUNCTION_TRACE_PTR(a,b) | ||
447 | #define ACPI_FUNCTION_TRACE_U32(a,b) | ||
448 | #define ACPI_FUNCTION_TRACE_STR(a,b) | ||
449 | #define ACPI_FUNCTION_EXIT | ||
450 | #define ACPI_FUNCTION_STATUS_EXIT(s) | ||
451 | #define ACPI_FUNCTION_VALUE_EXIT(s) | ||
452 | #define ACPI_FUNCTION_TRACE(a) | ||
453 | #define ACPI_FUNCTION_ENTRY() | ||
454 | |||
455 | #define return_VOID return | ||
456 | #define return_ACPI_STATUS(s) return(s) | ||
457 | #define return_VALUE(s) return(s) | ||
458 | #define return_UINT8(s) return(s) | ||
459 | #define return_UINT32(s) return(s) | ||
460 | #define return_PTR(s) return(s) | ||
461 | |||
462 | #endif /* CONFIG_ACPI_DEBUG_FUNC_TRACE */ | ||
463 | |||
464 | /* Conditional execution */ | ||
465 | |||
466 | #define ACPI_DEBUG_EXEC(a) a | ||
467 | #define ACPI_NORMAL_EXEC(a) | ||
468 | |||
469 | #define ACPI_DEBUG_DEFINE(a) a; | ||
470 | #define ACPI_DEBUG_ONLY_MEMBERS(a) a; | ||
471 | #define _VERBOSE_STRUCTURES | ||
472 | |||
473 | /* Stack and buffer dumping */ | ||
474 | |||
475 | #define ACPI_DUMP_STACK_ENTRY(a) acpi_ex_dump_operand((a), 0) | ||
476 | #define ACPI_DUMP_OPERANDS(a, b, c) acpi_ex_dump_operands(a, b, c) | ||
477 | |||
478 | #define ACPI_DUMP_ENTRY(a, b) acpi_ns_dump_entry (a, b) | ||
479 | #define ACPI_DUMP_PATHNAME(a, b, c, d) acpi_ns_dump_pathname(a, b, c, d) | ||
480 | #define ACPI_DUMP_RESOURCE_LIST(a) acpi_rs_dump_resource_list(a) | ||
481 | #define ACPI_DUMP_BUFFER(a, b) acpi_ut_dump_buffer((u8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT) | ||
482 | |||
483 | #else | ||
484 | /* | ||
485 | * This is the non-debug case -- make everything go away, | ||
486 | * leaving no executable debug code! | ||
487 | */ | ||
488 | #define ACPI_DEBUG_EXEC(a) | ||
489 | #define ACPI_NORMAL_EXEC(a) a; | ||
490 | |||
491 | #define ACPI_DEBUG_DEFINE(a) do { } while(0) | ||
492 | #define ACPI_DEBUG_ONLY_MEMBERS(a) do { } while(0) | ||
493 | #define ACPI_FUNCTION_TRACE(a) do { } while(0) | ||
494 | #define ACPI_FUNCTION_TRACE_PTR(a, b) do { } while(0) | ||
495 | #define ACPI_FUNCTION_TRACE_U32(a, b) do { } while(0) | ||
496 | #define ACPI_FUNCTION_TRACE_STR(a, b) do { } while(0) | ||
497 | #define ACPI_FUNCTION_EXIT do { } while(0) | ||
498 | #define ACPI_FUNCTION_STATUS_EXIT(s) do { } while(0) | ||
499 | #define ACPI_FUNCTION_VALUE_EXIT(s) do { } while(0) | ||
500 | #define ACPI_FUNCTION_ENTRY() do { } while(0) | ||
501 | #define ACPI_DUMP_STACK_ENTRY(a) do { } while(0) | ||
502 | #define ACPI_DUMP_OPERANDS(a, b, c) do { } while(0) | ||
503 | #define ACPI_DUMP_ENTRY(a, b) do { } while(0) | ||
504 | #define ACPI_DUMP_TABLES(a, b) do { } while(0) | ||
505 | #define ACPI_DUMP_PATHNAME(a, b, c, d) do { } while(0) | ||
506 | #define ACPI_DUMP_RESOURCE_LIST(a) do { } while(0) | ||
507 | #define ACPI_DUMP_BUFFER(a, b) do { } while(0) | ||
508 | |||
509 | #define return_VOID return | ||
510 | #define return_ACPI_STATUS(s) return(s) | ||
511 | #define return_VALUE(s) return(s) | ||
512 | #define return_UINT8(s) return(s) | ||
513 | #define return_UINT32(s) return(s) | ||
514 | #define return_PTR(s) return(s) | ||
515 | |||
516 | #endif /* ACPI_DEBUG_OUTPUT */ | ||
517 | |||
518 | /* | ||
519 | * Some code only gets executed when the debugger is built in. | ||
520 | * Note that this is entirely independent of whether the | ||
521 | * DEBUG_PRINT stuff (set by ACPI_DEBUG_OUTPUT) is on, or not. | ||
522 | */ | ||
523 | #ifdef ACPI_DEBUGGER | ||
524 | #define ACPI_DEBUGGER_EXEC(a) a | ||
525 | #else | ||
526 | #define ACPI_DEBUGGER_EXEC(a) | ||
527 | #endif | ||
528 | |||
529 | #ifdef ACPI_DEBUG_OUTPUT | ||
530 | /* | ||
531 | * 1) Set name to blanks | ||
532 | * 2) Copy the object name | ||
533 | */ | ||
534 | #define ACPI_ADD_OBJECT_NAME(a,b) ACPI_MEMSET (a->common.name, ' ', sizeof (a->common.name));\ | ||
535 | ACPI_STRNCPY (a->common.name, acpi_gbl_ns_type_names[b], sizeof (a->common.name)) | ||
536 | #else | ||
537 | |||
538 | #define ACPI_ADD_OBJECT_NAME(a,b) | ||
539 | #endif | ||
540 | |||
541 | /* | ||
542 | * Memory allocation tracking (DEBUG ONLY) | ||
543 | */ | ||
544 | #define ACPI_MEM_PARAMETERS _COMPONENT, _acpi_module_name, __LINE__ | ||
545 | |||
546 | #ifndef ACPI_DBG_TRACK_ALLOCATIONS | ||
547 | |||
548 | /* Memory allocation */ | ||
549 | |||
550 | #ifndef ACPI_ALLOCATE | ||
551 | #define ACPI_ALLOCATE(a) acpi_ut_allocate((acpi_size)(a), ACPI_MEM_PARAMETERS) | ||
552 | #endif | ||
553 | #ifndef ACPI_ALLOCATE_ZEROED | ||
554 | #define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed((acpi_size)(a), ACPI_MEM_PARAMETERS) | ||
555 | #endif | ||
556 | #ifndef ACPI_FREE | ||
557 | #define ACPI_FREE(a) acpio_os_free(a) | ||
558 | #endif | ||
559 | #define ACPI_MEM_TRACKING(a) | ||
560 | |||
561 | #else | ||
562 | |||
563 | /* Memory allocation */ | ||
564 | |||
565 | #define ACPI_ALLOCATE(a) acpi_ut_allocate_and_track((acpi_size)(a), ACPI_MEM_PARAMETERS) | ||
566 | #define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed_and_track((acpi_size)(a), ACPI_MEM_PARAMETERS) | ||
567 | #define ACPI_FREE(a) acpi_ut_free_and_track(a, ACPI_MEM_PARAMETERS) | ||
568 | #define ACPI_MEM_TRACKING(a) a | ||
569 | |||
570 | #endif /* ACPI_DBG_TRACK_ALLOCATIONS */ | ||
571 | |||
572 | /* Preemption point */ | ||
573 | #ifndef ACPI_PREEMPTION_POINT | ||
574 | #define ACPI_PREEMPTION_POINT() /* no preemption */ | ||
575 | #endif | ||
576 | |||
577 | #endif /* ACMACROS_H */ | ||