/root/src/xen/xen/include/acpi/acmacros.h
Line | Count | Source (jump to first uncovered line) |
1 | | /****************************************************************************** |
2 | | * |
3 | | * Name: acmacros.h - C macros for the entire subsystem. |
4 | | * |
5 | | *****************************************************************************/ |
6 | | |
7 | | /* |
8 | | * Copyright (C) 2000 - 2007, R. Byron Moore |
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 | | * Data manipulation macros |
49 | | */ |
50 | | #define ACPI_LOWORD(l) ((u16)(u32)(l)) |
51 | | #define ACPI_HIWORD(l) ((u16)((((u32)(l)) >> 16) & 0xFFFF)) |
52 | | #define ACPI_LOBYTE(l) ((u8)(u16)(l)) |
53 | | #define ACPI_HIBYTE(l) ((u8)((((u16)(l)) >> 8) & 0xFF)) |
54 | | |
55 | | #define ACPI_SET_BIT(target,bit) ((target) |= (bit)) |
56 | | #define ACPI_CLEAR_BIT(target,bit) ((target) &= ~(bit)) |
57 | | #define ACPI_MIN(a,b) (((a)<(b))?(a):(b)) |
58 | | #define ACPI_MAX(a,b) (((a)>(b))?(a):(b)) |
59 | | |
60 | | /* Size calculation */ |
61 | | |
62 | | #define ACPI_ARRAY_LENGTH(x) (sizeof(x) / sizeof((x)[0])) |
63 | | |
64 | | #ifdef ACPI_NO_INTEGER64_SUPPORT |
65 | | /* |
66 | | * acpi_integer is 32-bits, no 64-bit support on this platform |
67 | | */ |
68 | | #define ACPI_LODWORD(l) ((u32)(l)) |
69 | | #define ACPI_HIDWORD(l) ((u32)(0)) |
70 | | |
71 | | #else |
72 | | |
73 | | /* |
74 | | * Full 64-bit address/integer on both 32-bit and 64-bit platforms |
75 | | */ |
76 | | #define ACPI_LODWORD(l) ((u32)(u64)(l)) |
77 | | #define ACPI_HIDWORD(l) ((u32)(((*(struct uint64_struct *)(void *)(&l))).hi)) |
78 | | #endif |
79 | | |
80 | | /* |
81 | | * printf() format helpers |
82 | | */ |
83 | | |
84 | | /* Split 64-bit integer into two 32-bit values. Use with %8.8_x%8.8_x */ |
85 | | |
86 | | #define ACPI_FORMAT_UINT64(i) ACPI_HIDWORD(i),ACPI_LODWORD(i) |
87 | | |
88 | | /* |
89 | | * Extract data using a pointer. Any more than a byte and we |
90 | | * get into potential aligment issues -- see the STORE macros below. |
91 | | * Use with care. |
92 | | */ |
93 | | #define ACPI_GET8(ptr) *ACPI_CAST_PTR (u8, ptr) |
94 | | #define ACPI_GET16(ptr) *ACPI_CAST_PTR (u16, ptr) |
95 | | #define ACPI_GET32(ptr) *ACPI_CAST_PTR (u32, ptr) |
96 | | #define ACPI_GET64(ptr) *ACPI_CAST_PTR (u64, ptr) |
97 | | #define ACPI_SET8(ptr) *ACPI_CAST_PTR (u8, ptr) |
98 | | #define ACPI_SET16(ptr) *ACPI_CAST_PTR (u16, ptr) |
99 | | #define ACPI_SET32(ptr) *ACPI_CAST_PTR (u32, ptr) |
100 | | #define ACPI_SET64(ptr) *ACPI_CAST_PTR (u64, ptr) |
101 | | |
102 | | /* |
103 | | * Pointer manipulation |
104 | | */ |
105 | 128 | #define ACPI_CAST_PTR(t, p) ((t *) (acpi_uintptr_t) (p)) |
106 | | #define ACPI_CAST_INDIRECT_PTR(t, p) ((t **) (acpi_uintptr_t) (p)) |
107 | | #define ACPI_ADD_PTR(t,a,b) ACPI_CAST_PTR (t, (ACPI_CAST_PTR (u8,(a)) + (acpi_native_uint)(b))) |
108 | | #define ACPI_PTR_DIFF(a,b) (acpi_native_uint) (ACPI_CAST_PTR (u8,(a)) - ACPI_CAST_PTR (u8,(b))) |
109 | | |
110 | | /* Pointer/Integer type conversions */ |
111 | | |
112 | | #define ACPI_TO_POINTER(i) ACPI_ADD_PTR (void,(void *) NULL,(acpi_native_uint) i) |
113 | | #define ACPI_TO_INTEGER(p) ACPI_PTR_DIFF (p,(void *) NULL) |
114 | | #define ACPI_OFFSET(d,f) (acpi_size) ACPI_PTR_DIFF (&(((d *)0)->f),(void *) NULL) |
115 | | #define ACPI_PHYSADDR_TO_PTR(i) ACPI_TO_POINTER(i) |
116 | | #define ACPI_PTR_TO_PHYSADDR(i) ACPI_TO_INTEGER(i) |
117 | | |
118 | | #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED |
119 | 51 | #define ACPI_COMPARE_NAME(a,b) (*ACPI_CAST_PTR (u32,(a)) == *ACPI_CAST_PTR (u32,(b))) |
120 | | #else |
121 | | #define ACPI_COMPARE_NAME(a,b) (!ACPI_STRNCMP (ACPI_CAST_PTR (char,(a)), ACPI_CAST_PTR (char,(b)), ACPI_NAME_SIZE)) |
122 | | #endif |
123 | | |
124 | | /* |
125 | | * Macros for moving data around to/from buffers that are possibly unaligned. |
126 | | * If the hardware supports the transfer of unaligned data, just do the store. |
127 | | * Otherwise, we have to move one byte at a time. |
128 | | */ |
129 | | #ifdef ACPI_BIG_ENDIAN |
130 | | /* |
131 | | * Macros for big-endian machines |
132 | | */ |
133 | | |
134 | | /* This macro sets a buffer index, starting from the end of the buffer */ |
135 | | |
136 | | #define ACPI_BUFFER_INDEX(buf_len,buf_offset,byte_gran) ((buf_len) - (((buf_offset)+1) * (byte_gran))) |
137 | | |
138 | | /* These macros reverse the bytes during the move, converting little-endian to big endian */ |
139 | | |
140 | | /* Big Endian <== Little Endian */ |
141 | | /* Hi...Lo Lo...Hi */ |
142 | | /* 16-bit source, 16/32/64 destination */ |
143 | | |
144 | | #define ACPI_MOVE_16_TO_16(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[1];\ |
145 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[0];} |
146 | | |
147 | | #define ACPI_MOVE_16_TO_32(d,s) {(*(u32 *)(void *)(d))=0;\ |
148 | | ((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\ |
149 | | ((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];} |
150 | | |
151 | | #define ACPI_MOVE_16_TO_64(d,s) {(*(u64 *)(void *)(d))=0;\ |
152 | | ((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ |
153 | | ((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} |
154 | | |
155 | | /* 32-bit source, 16/32/64 destination */ |
156 | | |
157 | | #define ACPI_MOVE_32_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
158 | | |
159 | | #define ACPI_MOVE_32_TO_32(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[3];\ |
160 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[2];\ |
161 | | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\ |
162 | | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];} |
163 | | |
164 | | #define ACPI_MOVE_32_TO_64(d,s) {(*(u64 *)(void *)(d))=0;\ |
165 | | ((u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3];\ |
166 | | ((u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[2];\ |
167 | | ((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ |
168 | | ((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} |
169 | | |
170 | | /* 64-bit source, 16/32/64 destination */ |
171 | | |
172 | | #define ACPI_MOVE_64_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
173 | | |
174 | | #define ACPI_MOVE_64_TO_32(d,s) ACPI_MOVE_32_TO_32(d,s) /* Truncate to 32 */ |
175 | | |
176 | | #define ACPI_MOVE_64_TO_64(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[7];\ |
177 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[6];\ |
178 | | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[5];\ |
179 | | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[4];\ |
180 | | (( u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3];\ |
181 | | (( u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[2];\ |
182 | | (( u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\ |
183 | | (( u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];} |
184 | | #else |
185 | | /* |
186 | | * Macros for little-endian machines |
187 | | */ |
188 | | |
189 | | /* This macro sets a buffer index, starting from the beginning of the buffer */ |
190 | | |
191 | | #define ACPI_BUFFER_INDEX(buf_len,buf_offset,byte_gran) (buf_offset) |
192 | | |
193 | | #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED |
194 | | |
195 | | /* The hardware supports unaligned transfers, just do the little-endian move */ |
196 | | |
197 | | /* 16-bit source, 16/32/64 destination */ |
198 | | |
199 | | #define ACPI_MOVE_16_TO_16(d,s) *(u16 *)(void *)(d) = *(u16 *)(void *)(s) |
200 | | #define ACPI_MOVE_16_TO_32(d,s) *(u32 *)(void *)(d) = *(u16 *)(void *)(s) |
201 | | #define ACPI_MOVE_16_TO_64(d,s) *(u64 *)(void *)(d) = *(u16 *)(void *)(s) |
202 | | |
203 | | /* 32-bit source, 16/32/64 destination */ |
204 | | |
205 | | #define ACPI_MOVE_32_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
206 | 16 | #define ACPI_MOVE_32_TO_32(d,s) *(u32 *)(void *)(d) = *(u32 *)(void *)(s) |
207 | | #define ACPI_MOVE_32_TO_64(d,s) *(u64 *)(void *)(d) = *(u32 *)(void *)(s) |
208 | | |
209 | | /* 64-bit source, 16/32/64 destination */ |
210 | | |
211 | | #define ACPI_MOVE_64_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
212 | | #define ACPI_MOVE_64_TO_32(d,s) ACPI_MOVE_32_TO_32(d,s) /* Truncate to 32 */ |
213 | 28 | #define ACPI_MOVE_64_TO_64(d,s) *(u64 *)(void *)(d) = *(u64 *)(void *)(s) |
214 | | |
215 | | #else |
216 | | /* |
217 | | * The hardware does not support unaligned transfers. We must move the |
218 | | * data one byte at a time. These macros work whether the source or |
219 | | * the destination (or both) is/are unaligned. (Little-endian move) |
220 | | */ |
221 | | |
222 | | /* 16-bit source, 16/32/64 destination */ |
223 | | |
224 | | #define ACPI_MOVE_16_TO_16(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ |
225 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];} |
226 | | |
227 | | #define ACPI_MOVE_16_TO_32(d,s) {(*(u32 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d,s);} |
228 | | #define ACPI_MOVE_16_TO_64(d,s) {(*(u64 *)(void *)(d)) = 0; ACPI_MOVE_16_TO_16(d,s);} |
229 | | |
230 | | /* 32-bit source, 16/32/64 destination */ |
231 | | |
232 | | #define ACPI_MOVE_32_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
233 | | |
234 | | #define ACPI_MOVE_32_TO_32(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ |
235 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];\ |
236 | | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[2];\ |
237 | | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[3];} |
238 | | |
239 | | #define ACPI_MOVE_32_TO_64(d,s) {(*(u64 *)(void *)(d)) = 0; ACPI_MOVE_32_TO_32(d,s);} |
240 | | |
241 | | /* 64-bit source, 16/32/64 destination */ |
242 | | |
243 | | #define ACPI_MOVE_64_TO_16(d,s) ACPI_MOVE_16_TO_16(d,s) /* Truncate to 16 */ |
244 | | #define ACPI_MOVE_64_TO_32(d,s) ACPI_MOVE_32_TO_32(d,s) /* Truncate to 32 */ |
245 | | #define ACPI_MOVE_64_TO_64(d,s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0];\ |
246 | | (( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1];\ |
247 | | (( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[2];\ |
248 | | (( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[3];\ |
249 | | (( u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[4];\ |
250 | | (( u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[5];\ |
251 | | (( u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[6];\ |
252 | | (( u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[7];} |
253 | | #endif |
254 | | #endif |
255 | | |
256 | | /* Macros based on machine integer width */ |
257 | | |
258 | | #if ACPI_MACHINE_WIDTH == 32 |
259 | | #define ACPI_MOVE_SIZE_TO_16(d,s) ACPI_MOVE_32_TO_16(d,s) |
260 | | |
261 | | #elif ACPI_MACHINE_WIDTH == 64 |
262 | | #define ACPI_MOVE_SIZE_TO_16(d,s) ACPI_MOVE_64_TO_16(d,s) |
263 | | |
264 | | #else |
265 | | #error unknown ACPI_MACHINE_WIDTH |
266 | | #endif |
267 | | |
268 | | /* |
269 | | * Fast power-of-two math macros for non-optimized compilers |
270 | | */ |
271 | | #define _ACPI_DIV(value,power_of2) ((u32) ((value) >> (power_of2))) |
272 | | #define _ACPI_MUL(value,power_of2) ((u32) ((value) << (power_of2))) |
273 | | #define _ACPI_MOD(value,divisor) ((u32) ((value) & ((divisor) -1))) |
274 | | |
275 | | #define ACPI_DIV_2(a) _ACPI_DIV(a,1) |
276 | | #define ACPI_MUL_2(a) _ACPI_MUL(a,1) |
277 | | #define ACPI_MOD_2(a) _ACPI_MOD(a,2) |
278 | | |
279 | | #define ACPI_DIV_4(a) _ACPI_DIV(a,2) |
280 | | #define ACPI_MUL_4(a) _ACPI_MUL(a,2) |
281 | | #define ACPI_MOD_4(a) _ACPI_MOD(a,4) |
282 | | |
283 | | #define ACPI_DIV_8(a) _ACPI_DIV(a,3) |
284 | | #define ACPI_MUL_8(a) _ACPI_MUL(a,3) |
285 | | #define ACPI_MOD_8(a) _ACPI_MOD(a,8) |
286 | | |
287 | | #define ACPI_DIV_16(a) _ACPI_DIV(a,4) |
288 | | #define ACPI_MUL_16(a) _ACPI_MUL(a,4) |
289 | | #define ACPI_MOD_16(a) _ACPI_MOD(a,16) |
290 | | |
291 | | #define ACPI_DIV_32(a) _ACPI_DIV(a,5) |
292 | | #define ACPI_MUL_32(a) _ACPI_MUL(a,5) |
293 | | #define ACPI_MOD_32(a) _ACPI_MOD(a,32) |
294 | | |
295 | | /* |
296 | | * Rounding macros (Power of two boundaries only) |
297 | | */ |
298 | | #define ACPI_ROUND_DOWN(value,boundary) (((acpi_native_uint)(value)) & \ |
299 | | (~(((acpi_native_uint) boundary)-1))) |
300 | | |
301 | | #define ACPI_ROUND_UP(value,boundary) ((((acpi_native_uint)(value)) + \ |
302 | | (((acpi_native_uint) boundary)-1)) & \ |
303 | | (~(((acpi_native_uint) boundary)-1))) |
304 | | |
305 | | /* Note: sizeof(acpi_native_uint) evaluates to either 2, 4, or 8 */ |
306 | | |
307 | | #define ACPI_ROUND_DOWN_TO_32BIT(a) ACPI_ROUND_DOWN(a,4) |
308 | | #define ACPI_ROUND_DOWN_TO_64BIT(a) ACPI_ROUND_DOWN(a,8) |
309 | | #define ACPI_ROUND_DOWN_TO_NATIVE_WORD(a) ACPI_ROUND_DOWN(a,sizeof(acpi_native_uint)) |
310 | | |
311 | | #define ACPI_ROUND_UP_TO_32BIT(a) ACPI_ROUND_UP(a,4) |
312 | | #define ACPI_ROUND_UP_TO_64BIT(a) ACPI_ROUND_UP(a,8) |
313 | | #define ACPI_ROUND_UP_TO_NATIVE_WORD(a) ACPI_ROUND_UP(a,sizeof(acpi_native_uint)) |
314 | | |
315 | | #define ACPI_ROUND_BITS_UP_TO_BYTES(a) ACPI_DIV_8((a) + 7) |
316 | | #define ACPI_ROUND_BITS_DOWN_TO_BYTES(a) ACPI_DIV_8((a)) |
317 | | |
318 | | #define ACPI_ROUND_UP_TO_1K(a) (((a) + 1023) >> 10) |
319 | | |
320 | | /* Generic (non-power-of-two) rounding */ |
321 | | |
322 | | #define ACPI_ROUND_UP_TO(value,boundary) (((value) + ((boundary)-1)) / (boundary)) |
323 | | |
324 | | #define ACPI_IS_MISALIGNED(value) (((acpi_native_uint)value) & (sizeof(acpi_native_uint)-1)) |
325 | | |
326 | | /* |
327 | | * Bitmask creation |
328 | | * Bit positions start at zero. |
329 | | * MASK_BITS_ABOVE creates a mask starting AT the position and above |
330 | | * MASK_BITS_BELOW creates a mask starting one bit BELOW the position |
331 | | */ |
332 | | #define ACPI_MASK_BITS_ABOVE(position) (~((ACPI_INTEGER_MAX) << ((u32) (position)))) |
333 | | #define ACPI_MASK_BITS_BELOW(position) ((ACPI_INTEGER_MAX) << ((u32) (position))) |
334 | | |
335 | | #define ACPI_IS_OCTAL_DIGIT(d) (((char)(d) >= '0') && ((char)(d) <= '7')) |
336 | | |
337 | | /* Bitfields within ACPI registers */ |
338 | | |
339 | 0 | #define ACPI_REGISTER_PREPARE_BITS(val, pos, mask) ((val << pos) & mask) |
340 | 0 | #define ACPI_REGISTER_INSERT_VALUE(reg, pos, mask, val) reg = (reg & (~(mask))) | ACPI_REGISTER_PREPARE_BITS(val, pos, mask) |
341 | | |
342 | 0 | #define ACPI_INSERT_BITS(target, mask, source) target = ((target & (~(mask))) | (source & mask)) |
343 | | |
344 | | /* Generate a UUID */ |
345 | | |
346 | | #define ACPI_INIT_UUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \ |
347 | | (a) & 0xFF, ((a) >> 8) & 0xFF, ((a) >> 16) & 0xFF, ((a) >> 24) & 0xFF, \ |
348 | | (b) & 0xFF, ((b) >> 8) & 0xFF, \ |
349 | | (c) & 0xFF, ((c) >> 8) & 0xFF, \ |
350 | | (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) |
351 | | |
352 | | /* |
353 | | * An struct acpi_namespace_node * can appear in some contexts, |
354 | | * where a pointer to an union acpi_operand_object can also |
355 | | * appear. This macro is used to distinguish them. |
356 | | * |
357 | | * The "Descriptor" field is the first field in both structures. |
358 | | */ |
359 | | #define ACPI_GET_DESCRIPTOR_TYPE(d) (((union acpi_descriptor *)(void *)(d))->common.descriptor_type) |
360 | | #define ACPI_SET_DESCRIPTOR_TYPE(d,t) (((union acpi_descriptor *)(void *)(d))->common.descriptor_type = t) |
361 | | |
362 | | /* Macro to test the object type */ |
363 | | |
364 | | #define ACPI_GET_OBJECT_TYPE(d) (((union acpi_operand_object *)(void *)(d))->common.type) |
365 | | |
366 | | /* Macro to check the table flags for SINGLE or MULTIPLE tables are allowed */ |
367 | | |
368 | | #define ACPI_IS_SINGLE_TABLE(x) (((x) & 0x01) == ACPI_TABLE_SINGLE ? 1 : 0) |
369 | | |
370 | | /* |
371 | | * Macros for the master AML opcode table |
372 | | */ |
373 | | #if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT) |
374 | | #define ACPI_OP(name,Pargs,Iargs,obj_type,class,type,flags) {name,(u32)(Pargs),(u32)(Iargs),(u32)(flags),obj_type,class,type} |
375 | | #else |
376 | | #define ACPI_OP(name,Pargs,Iargs,obj_type,class,type,flags) {(u32)(Pargs),(u32)(Iargs),(u32)(flags),obj_type,class,type} |
377 | | #endif |
378 | | |
379 | | #ifdef ACPI_DISASSEMBLER |
380 | | #define ACPI_DISASM_ONLY_MEMBERS(a) a; |
381 | | #else |
382 | | #define ACPI_DISASM_ONLY_MEMBERS(a) |
383 | | #endif |
384 | | |
385 | | #define ARG_TYPE_WIDTH 5 |
386 | | #define ARG_1(x) ((u32)(x)) |
387 | | #define ARG_2(x) ((u32)(x) << (1 * ARG_TYPE_WIDTH)) |
388 | | #define ARG_3(x) ((u32)(x) << (2 * ARG_TYPE_WIDTH)) |
389 | | #define ARG_4(x) ((u32)(x) << (3 * ARG_TYPE_WIDTH)) |
390 | | #define ARG_5(x) ((u32)(x) << (4 * ARG_TYPE_WIDTH)) |
391 | | #define ARG_6(x) ((u32)(x) << (5 * ARG_TYPE_WIDTH)) |
392 | | |
393 | | #define ARGI_LIST1(a) (ARG_1(a)) |
394 | | #define ARGI_LIST2(a,b) (ARG_1(b)|ARG_2(a)) |
395 | | #define ARGI_LIST3(a,b,c) (ARG_1(c)|ARG_2(b)|ARG_3(a)) |
396 | | #define ARGI_LIST4(a,b,c,d) (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a)) |
397 | | #define ARGI_LIST5(a,b,c,d,e) (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a)) |
398 | | #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)) |
399 | | |
400 | | #define ARGP_LIST1(a) (ARG_1(a)) |
401 | | #define ARGP_LIST2(a,b) (ARG_1(a)|ARG_2(b)) |
402 | | #define ARGP_LIST3(a,b,c) (ARG_1(a)|ARG_2(b)|ARG_3(c)) |
403 | | #define ARGP_LIST4(a,b,c,d) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)) |
404 | | #define ARGP_LIST5(a,b,c,d,e) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)) |
405 | | #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)) |
406 | | |
407 | | #define GET_CURRENT_ARG_TYPE(list) (list & ((u32) 0x1F)) |
408 | | #define INCREMENT_ARG_LIST(list) (list >>= ((u32) ARG_TYPE_WIDTH)) |
409 | | |
410 | | #if defined (ACPI_DEBUG_OUTPUT) || !defined (ACPI_NO_ERROR_MESSAGES) |
411 | | /* |
412 | | * Module name is include in both debug and non-debug versions primarily for |
413 | | * error messages. The __FILE__ macro is not very useful for this, because it |
414 | | * often includes the entire pathname to the module |
415 | | */ |
416 | | #define ACPI_MODULE_NAME(name) static const char ACPI_UNUSED_VAR _acpi_module_name[] = name; |
417 | | #else |
418 | | #define ACPI_MODULE_NAME(name) |
419 | | #endif |
420 | | |
421 | | /* |
422 | | * Ascii error messages can be configured out |
423 | | */ |
424 | | #ifndef ACPI_NO_ERROR_MESSAGES |
425 | | #define AE_INFO _acpi_module_name, __LINE__ |
426 | | |
427 | | /* |
428 | | * Error reporting. Callers module and line number are inserted by AE_INFO, |
429 | | * the plist contains a set of parens to allow variable-length lists. |
430 | | * These macros are used for both the debug and non-debug versions of the code. |
431 | | */ |
432 | 18 | #define ACPI_INFO(plist) acpi_ut_info plist |
433 | 0 | #define ACPI_WARNING(plist) acpi_ut_warning plist |
434 | 0 | #define ACPI_ERROR(plist) acpi_ut_error plist |
435 | | #define ACPI_ERROR_NAMESPACE(s,e) acpi_ns_report_error (AE_INFO, s, e); |
436 | | #define ACPI_ERROR_METHOD(s,n,p,e) acpi_ns_report_method_error (AE_INFO, s, n, p, e); |
437 | | |
438 | | #else |
439 | | |
440 | | /* No error messages */ |
441 | | |
442 | | #define ACPI_INFO(plist) |
443 | | #define ACPI_WARNING(plist) |
444 | | #define ACPI_ERROR(plist) |
445 | | #define ACPI_ERROR_NAMESPACE(s,e) |
446 | | #define ACPI_ERROR_METHOD(s,n,p,e) |
447 | | #endif |
448 | | |
449 | | /* |
450 | | * Debug macros that are conditionally compiled |
451 | | */ |
452 | | #ifdef ACPI_DEBUG_OUTPUT |
453 | | |
454 | | /* |
455 | | * Common parameters used for debug output functions: |
456 | | * line number, function name, module(file) name, component ID |
457 | | */ |
458 | | #define ACPI_DEBUG_PARAMETERS __LINE__, ACPI_GET_FUNCTION_NAME, _acpi_module_name, _COMPONENT |
459 | | |
460 | | /* |
461 | | * Function entry tracing |
462 | | */ |
463 | | |
464 | | /* |
465 | | * If ACPI_GET_FUNCTION_NAME was not defined in the compiler-dependent header, |
466 | | * define it now. This is the case where there the compiler does not support |
467 | | * a __FUNCTION__ macro or equivalent. We save the function name on the |
468 | | * local stack. |
469 | | */ |
470 | | #ifndef ACPI_GET_FUNCTION_NAME |
471 | | #define ACPI_GET_FUNCTION_NAME _acpi_function_name |
472 | | /* |
473 | | * The Name parameter should be the procedure name as a quoted string. |
474 | | * This is declared as a local string ("MyFunctionName") so that it can |
475 | | * be also used by the function exit macros below. |
476 | | * Note: (const char) is used to be compatible with the debug interfaces |
477 | | * and macros such as __FUNCTION__. |
478 | | */ |
479 | | #define ACPI_FUNCTION_NAME(name) const char *_acpi_function_name = #name; |
480 | | |
481 | | #else |
482 | | /* Compiler supports __FUNCTION__ (or equivalent) -- Ignore this macro */ |
483 | | |
484 | | #define ACPI_FUNCTION_NAME(name) |
485 | | #endif |
486 | | |
487 | | #ifdef CONFIG_ACPI_DEBUG_FUNC_TRACE |
488 | | |
489 | | #define ACPI_FUNCTION_TRACE(a) ACPI_FUNCTION_NAME(a) \ |
490 | | acpi_ut_trace(ACPI_DEBUG_PARAMETERS) |
491 | | #define ACPI_FUNCTION_TRACE_PTR(a,b) ACPI_FUNCTION_NAME(a) \ |
492 | | acpi_ut_trace_ptr(ACPI_DEBUG_PARAMETERS,(void *)b) |
493 | | #define ACPI_FUNCTION_TRACE_U32(a,b) ACPI_FUNCTION_NAME(a) \ |
494 | | acpi_ut_trace_u32(ACPI_DEBUG_PARAMETERS,(u32)b) |
495 | | #define ACPI_FUNCTION_TRACE_STR(a,b) ACPI_FUNCTION_NAME(a) \ |
496 | | acpi_ut_trace_str(ACPI_DEBUG_PARAMETERS,(char *)b) |
497 | | |
498 | | #define ACPI_FUNCTION_ENTRY() acpi_ut_track_stack_ptr() |
499 | | |
500 | | /* |
501 | | * Function exit tracing. |
502 | | * WARNING: These macros include a return statement. This is usually considered |
503 | | * bad form, but having a separate exit macro is very ugly and difficult to maintain. |
504 | | * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros |
505 | | * so that "_AcpiFunctionName" is defined. |
506 | | * |
507 | | * Note: the DO_WHILE0 macro is used to prevent some compilers from complaining |
508 | | * about these constructs. |
509 | | */ |
510 | | #ifdef ACPI_USE_DO_WHILE_0 |
511 | | #define ACPI_DO_WHILE0(a) do a while(0) |
512 | | #else |
513 | | #define ACPI_DO_WHILE0(a) a |
514 | | #endif |
515 | | |
516 | | #define return_VOID ACPI_DO_WHILE0 ({ \ |
517 | | acpi_ut_exit (ACPI_DEBUG_PARAMETERS); \ |
518 | | return;}) |
519 | | /* |
520 | | * There are two versions of most of the return macros. The default version is |
521 | | * safer, since it avoids side-effects by guaranteeing that the argument will |
522 | | * not be evaluated twice. |
523 | | * |
524 | | * A less-safe version of the macros is provided for optional use if the |
525 | | * compiler uses excessive CPU stack (for example, this may happen in the |
526 | | * debug case if code optimzation is disabled.) |
527 | | */ |
528 | | #ifndef ACPI_SIMPLE_RETURN_MACROS |
529 | | |
530 | | #define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ |
531 | | register acpi_status _s = (s); \ |
532 | | acpi_ut_status_exit (ACPI_DEBUG_PARAMETERS, _s); \ |
533 | | return (_s); }) |
534 | | #define return_PTR(s) ACPI_DO_WHILE0 ({ \ |
535 | | register void *_s = (void *) (s); \ |
536 | | acpi_ut_ptr_exit (ACPI_DEBUG_PARAMETERS, (u8 *) _s); \ |
537 | | return (_s); }) |
538 | | #define return_VALUE(s) ACPI_DO_WHILE0 ({ \ |
539 | | register acpi_integer _s = (s); \ |
540 | | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, _s); \ |
541 | | return (_s); }) |
542 | | #define return_UINT8(s) ACPI_DO_WHILE0 ({ \ |
543 | | register u8 _s = (u8) (s); \ |
544 | | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \ |
545 | | return (_s); }) |
546 | | #define return_UINT32(s) ACPI_DO_WHILE0 ({ \ |
547 | | register u32 _s = (u32) (s); \ |
548 | | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \ |
549 | | return (_s); }) |
550 | | #else /* Use original less-safe macros */ |
551 | | |
552 | | #define return_ACPI_STATUS(s) ACPI_DO_WHILE0 ({ \ |
553 | | acpi_ut_status_exit (ACPI_DEBUG_PARAMETERS, (s)); \ |
554 | | return((s)); }) |
555 | | #define return_PTR(s) ACPI_DO_WHILE0 ({ \ |
556 | | acpi_ut_ptr_exit (ACPI_DEBUG_PARAMETERS, (u8 *) (s)); \ |
557 | | return((s)); }) |
558 | | #define return_VALUE(s) ACPI_DO_WHILE0 ({ \ |
559 | | acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) (s)); \ |
560 | | return((s)); }) |
561 | | #define return_UINT8(s) return_VALUE(s) |
562 | | #define return_UINT32(s) return_VALUE(s) |
563 | | |
564 | | #endif /* ACPI_SIMPLE_RETURN_MACROS */ |
565 | | |
566 | | #else /* !CONFIG_ACPI_DEBUG_FUNC_TRACE */ |
567 | | |
568 | | #define ACPI_FUNCTION_TRACE(a) |
569 | | #define ACPI_FUNCTION_TRACE_PTR(a,b) |
570 | | #define ACPI_FUNCTION_TRACE_U32(a,b) |
571 | | #define ACPI_FUNCTION_TRACE_STR(a,b) |
572 | | #define ACPI_FUNCTION_EXIT |
573 | | #define ACPI_FUNCTION_STATUS_EXIT(s) |
574 | | #define ACPI_FUNCTION_VALUE_EXIT(s) |
575 | | #define ACPI_FUNCTION_TRACE(a) |
576 | | #define ACPI_FUNCTION_ENTRY() |
577 | | |
578 | | #define return_VOID return |
579 | | #define return_ACPI_STATUS(s) return(s) |
580 | | #define return_VALUE(s) return(s) |
581 | | #define return_UINT8(s) return(s) |
582 | | #define return_UINT32(s) return(s) |
583 | | #define return_PTR(s) return(s) |
584 | | |
585 | | #endif /* CONFIG_ACPI_DEBUG_FUNC_TRACE */ |
586 | | |
587 | | /* Conditional execution */ |
588 | | |
589 | | #define ACPI_DEBUG_EXEC(a) a |
590 | | #define ACPI_NORMAL_EXEC(a) |
591 | | |
592 | | #define ACPI_DEBUG_DEFINE(a) a; |
593 | | #define ACPI_DEBUG_ONLY_MEMBERS(a) a; |
594 | | #define _VERBOSE_STRUCTURES |
595 | | |
596 | | /* |
597 | | * Master debug print macros |
598 | | * Print iff: |
599 | | * 1) Debug print for the current component is enabled |
600 | | * 2) Debug error level or trace level for the print statement is enabled |
601 | | */ |
602 | | #define ACPI_DEBUG_PRINT(plist) acpi_ut_debug_print plist |
603 | | #define ACPI_DEBUG_PRINT_RAW(plist) acpi_ut_debug_print_raw plist |
604 | | |
605 | | #else |
606 | | /* |
607 | | * This is the non-debug case -- make everything go away, |
608 | | * leaving no executable debug code! |
609 | | */ |
610 | | #define ACPI_DEBUG_EXEC(a) |
611 | | #define ACPI_NORMAL_EXEC(a) a; |
612 | | |
613 | | #define ACPI_DEBUG_DEFINE(a) do { } while(0) |
614 | | #define ACPI_DEBUG_ONLY_MEMBERS(a) do { } while(0) |
615 | 0 | #define ACPI_FUNCTION_NAME(a) do { } while(0) |
616 | 1 | #define ACPI_FUNCTION_TRACE(a) do { } while(0) |
617 | | #define ACPI_FUNCTION_TRACE_PTR(a,b) do { } while(0) |
618 | 0 | #define ACPI_FUNCTION_TRACE_U32(a,b) do { } while(0) |
619 | | #define ACPI_FUNCTION_TRACE_STR(a,b) do { } while(0) |
620 | | #define ACPI_FUNCTION_EXIT do { } while(0) |
621 | | #define ACPI_FUNCTION_STATUS_EXIT(s) do { } while(0) |
622 | | #define ACPI_FUNCTION_VALUE_EXIT(s) do { } while(0) |
623 | 0 | #define ACPI_FUNCTION_ENTRY() do { } while(0) |
624 | 0 | #define ACPI_DEBUG_PRINT(pl) do { } while(0) |
625 | | #define ACPI_DEBUG_PRINT_RAW(pl) do { } while(0) |
626 | | |
627 | | #define return_VOID return |
628 | 1 | #define return_ACPI_STATUS(s) return(s) |
629 | | #define return_VALUE(s) return(s) |
630 | | #define return_UINT8(s) return(s) |
631 | | #define return_UINT32(s) return(s) |
632 | | #define return_PTR(s) return(s) |
633 | | |
634 | | #endif |
635 | | |
636 | | #endif /* ACMACROS_H */ |