1 | /****************************************************************************** |
2 | * |
3 | * Name: acobject.h - Definition of ACPI_OPERAND_OBJECT (Internal object only) |
4 | * |
5 | *****************************************************************************/ |
6 | |
7 | /* |
8 | * Copyright (C) 2000 - 2016, 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 _ACOBJECT_H |
45 | #define _ACOBJECT_H |
46 | |
47 | /* acpisrc:StructDefs -- for acpisrc conversion */ |
48 | |
49 | |
50 | /* |
51 | * The ACPI_OPERAND_OBJECT is used to pass AML operands from the dispatcher |
52 | * to the interpreter, and to keep track of the various handlers such as |
53 | * address space handlers and notify handlers. The object is a constant |
54 | * size in order to allow it to be cached and reused. |
55 | * |
56 | * Note: The object is optimized to be aligned and will not work if it is |
57 | * byte-packed. |
58 | */ |
59 | #if ACPI_MACHINE_WIDTH == 64 |
60 | #pragma pack(8) |
61 | #else |
62 | #pragma pack(4) |
63 | #endif |
64 | |
65 | /******************************************************************************* |
66 | * |
67 | * Common Descriptors |
68 | * |
69 | ******************************************************************************/ |
70 | |
71 | /* |
72 | * Common area for all objects. |
73 | * |
74 | * DescriptorType is used to differentiate between internal descriptors, and |
75 | * must be in the same place across all descriptors |
76 | * |
77 | * Note: The DescriptorType and Type fields must appear in the identical |
78 | * position in both the ACPI_NAMESPACE_NODE and ACPI_OPERAND_OBJECT |
79 | * structures. |
80 | */ |
81 | #define \ |
82 | union acpi_operand_object *; /* Objects linked to parent NS node */\ |
83 | UINT8 ; /* To differentiate various internal objs */\ |
84 | UINT8 ; /* ACPI_OBJECT_TYPE */\ |
85 | UINT16 ; /* For object deletion management */\ |
86 | UINT8 ; |
87 | /* |
88 | * Note: There are 3 bytes available here before the |
89 | * next natural alignment boundary (for both 32/64 cases) |
90 | */ |
91 | |
92 | /* Values for Flag byte above */ |
93 | |
94 | #define AOPOBJ_AML_CONSTANT 0x01 /* Integer is an AML constant */ |
95 | #define AOPOBJ_STATIC_POINTER 0x02 /* Data is part of an ACPI table, don't delete */ |
96 | #define AOPOBJ_DATA_VALID 0x04 /* Object is initialized and data is valid */ |
97 | #define AOPOBJ_OBJECT_INITIALIZED 0x08 /* Region is initialized */ |
98 | #define AOPOBJ_REG_CONNECTED 0x10 /* _REG was run */ |
99 | #define AOPOBJ_SETUP_COMPLETE 0x20 /* Region setup is complete */ |
100 | #define AOPOBJ_INVALID 0x40 /* Host OS won't allow a Region address */ |
101 | |
102 | |
103 | /****************************************************************************** |
104 | * |
105 | * Basic data types |
106 | * |
107 | *****************************************************************************/ |
108 | |
109 | typedef struct acpi_object_common |
110 | { |
111 | ACPI_OBJECT_COMMON_HEADER |
112 | |
113 | } ACPI_OBJECT_COMMON; |
114 | |
115 | |
116 | typedef struct acpi_object_integer |
117 | { |
118 | ACPI_OBJECT_COMMON_HEADER |
119 | UINT8 Fill[3]; /* Prevent warning on some compilers */ |
120 | UINT64 Value; |
121 | |
122 | } ACPI_OBJECT_INTEGER; |
123 | |
124 | |
125 | /* |
126 | * Note: The String and Buffer object must be identical through the |
127 | * pointer and length elements. There is code that depends on this. |
128 | * |
129 | * Fields common to both Strings and Buffers |
130 | */ |
131 | #define ACPI_COMMON_BUFFER_INFO(_Type) \ |
132 | _Type *Pointer; \ |
133 | UINT32 Length; |
134 | |
135 | |
136 | typedef struct acpi_object_string /* Null terminated, ASCII characters only */ |
137 | { |
138 | ACPI_OBJECT_COMMON_HEADER |
139 | ACPI_COMMON_BUFFER_INFO (char) /* String in AML stream or allocated string */ |
140 | |
141 | } ACPI_OBJECT_STRING; |
142 | |
143 | |
144 | typedef struct acpi_object_buffer |
145 | { |
146 | ACPI_OBJECT_COMMON_HEADER |
147 | ACPI_COMMON_BUFFER_INFO (UINT8) /* Buffer in AML stream or allocated buffer */ |
148 | UINT32 AmlLength; |
149 | UINT8 *AmlStart; |
150 | ACPI_NAMESPACE_NODE *Node; /* Link back to parent node */ |
151 | |
152 | } ACPI_OBJECT_BUFFER; |
153 | |
154 | |
155 | typedef struct acpi_object_package |
156 | { |
157 | ACPI_OBJECT_COMMON_HEADER |
158 | ACPI_NAMESPACE_NODE *Node; /* Link back to parent node */ |
159 | union acpi_operand_object **Elements; /* Array of pointers to AcpiObjects */ |
160 | UINT8 *AmlStart; |
161 | UINT32 AmlLength; |
162 | UINT32 Count; /* # of elements in package */ |
163 | |
164 | } ACPI_OBJECT_PACKAGE; |
165 | |
166 | |
167 | /****************************************************************************** |
168 | * |
169 | * Complex data types |
170 | * |
171 | *****************************************************************************/ |
172 | |
173 | typedef struct acpi_object_event |
174 | { |
175 | ACPI_OBJECT_COMMON_HEADER |
176 | ACPI_SEMAPHORE OsSemaphore; /* Actual OS synchronization object */ |
177 | |
178 | } ACPI_OBJECT_EVENT; |
179 | |
180 | |
181 | typedef struct acpi_object_mutex |
182 | { |
183 | ACPI_OBJECT_COMMON_HEADER |
184 | UINT8 SyncLevel; /* 0-15, specified in Mutex() call */ |
185 | UINT16 AcquisitionDepth; /* Allow multiple Acquires, same thread */ |
186 | ACPI_MUTEX OsMutex; /* Actual OS synchronization object */ |
187 | ACPI_THREAD_ID ThreadId; /* Current owner of the mutex */ |
188 | struct acpi_thread_state *OwnerThread; /* Current owner of the mutex */ |
189 | union acpi_operand_object *Prev; /* Link for list of acquired mutexes */ |
190 | union acpi_operand_object *Next; /* Link for list of acquired mutexes */ |
191 | ACPI_NAMESPACE_NODE *Node; /* Containing namespace node */ |
192 | UINT8 OriginalSyncLevel; /* Owner's original sync level (0-15) */ |
193 | |
194 | } ACPI_OBJECT_MUTEX; |
195 | |
196 | |
197 | typedef struct acpi_object_region |
198 | { |
199 | ACPI_OBJECT_COMMON_HEADER |
200 | UINT8 SpaceId; |
201 | ACPI_NAMESPACE_NODE *Node; /* Containing namespace node */ |
202 | union acpi_operand_object *Handler; /* Handler for region access */ |
203 | union acpi_operand_object *Next; |
204 | ACPI_PHYSICAL_ADDRESS Address; |
205 | UINT32 Length; |
206 | |
207 | } ACPI_OBJECT_REGION; |
208 | |
209 | |
210 | typedef struct acpi_object_method |
211 | { |
212 | ACPI_OBJECT_COMMON_HEADER |
213 | UINT8 InfoFlags; |
214 | UINT8 ParamCount; |
215 | UINT8 SyncLevel; |
216 | union acpi_operand_object *Mutex; |
217 | union acpi_operand_object *Node; |
218 | UINT8 *AmlStart; |
219 | union |
220 | { |
221 | ACPI_INTERNAL_METHOD Implementation; |
222 | union acpi_operand_object *Handler; |
223 | } Dispatch; |
224 | |
225 | UINT32 AmlLength; |
226 | UINT8 ThreadCount; |
227 | ACPI_OWNER_ID OwnerId; |
228 | |
229 | } ACPI_OBJECT_METHOD; |
230 | |
231 | /* Flags for InfoFlags field above */ |
232 | |
233 | #define ACPI_METHOD_MODULE_LEVEL 0x01 /* Method is actually module-level code */ |
234 | #define ACPI_METHOD_INTERNAL_ONLY 0x02 /* Method is implemented internally (_OSI) */ |
235 | #define ACPI_METHOD_SERIALIZED 0x04 /* Method is serialized */ |
236 | #define ACPI_METHOD_SERIALIZED_PENDING 0x08 /* Method is to be marked serialized */ |
237 | #define ACPI_METHOD_IGNORE_SYNC_LEVEL 0x10 /* Method was auto-serialized at table load time */ |
238 | #define ACPI_METHOD_MODIFIED_NAMESPACE 0x20 /* Method modified the namespace */ |
239 | |
240 | |
241 | /****************************************************************************** |
242 | * |
243 | * Objects that can be notified. All share a common NotifyInfo area. |
244 | * |
245 | *****************************************************************************/ |
246 | |
247 | /* |
248 | * Common fields for objects that support ASL notifications |
249 | */ |
250 | #define ACPI_COMMON_NOTIFY_INFO \ |
251 | union acpi_operand_object *NotifyList[2]; /* Handlers for system/device notifies */\ |
252 | union acpi_operand_object *Handler; /* Handler for Address space */ |
253 | |
254 | |
255 | typedef struct acpi_object_notify_common /* COMMON NOTIFY for POWER, PROCESSOR, DEVICE, and THERMAL */ |
256 | { |
257 | ACPI_OBJECT_COMMON_HEADER |
258 | ACPI_COMMON_NOTIFY_INFO |
259 | |
260 | } ACPI_OBJECT_NOTIFY_COMMON; |
261 | |
262 | |
263 | typedef struct acpi_object_device |
264 | { |
265 | ACPI_OBJECT_COMMON_HEADER |
266 | ACPI_COMMON_NOTIFY_INFO |
267 | ACPI_GPE_BLOCK_INFO *GpeBlock; |
268 | |
269 | } ACPI_OBJECT_DEVICE; |
270 | |
271 | |
272 | typedef struct acpi_object_power_resource |
273 | { |
274 | ACPI_OBJECT_COMMON_HEADER |
275 | ACPI_COMMON_NOTIFY_INFO |
276 | UINT32 SystemLevel; |
277 | UINT32 ResourceOrder; |
278 | |
279 | } ACPI_OBJECT_POWER_RESOURCE; |
280 | |
281 | |
282 | typedef struct acpi_object_processor |
283 | { |
284 | ACPI_OBJECT_COMMON_HEADER |
285 | |
286 | /* The next two fields take advantage of the 3-byte space before NOTIFY_INFO */ |
287 | |
288 | UINT8 ProcId; |
289 | UINT8 Length; |
290 | ACPI_COMMON_NOTIFY_INFO |
291 | ACPI_IO_ADDRESS Address; |
292 | |
293 | } ACPI_OBJECT_PROCESSOR; |
294 | |
295 | |
296 | typedef struct acpi_object_thermal_zone |
297 | { |
298 | ACPI_OBJECT_COMMON_HEADER |
299 | ACPI_COMMON_NOTIFY_INFO |
300 | |
301 | } ACPI_OBJECT_THERMAL_ZONE; |
302 | |
303 | |
304 | /****************************************************************************** |
305 | * |
306 | * Fields. All share a common header/info field. |
307 | * |
308 | *****************************************************************************/ |
309 | |
310 | /* |
311 | * Common bitfield for the field objects |
312 | * "Field Datum" -- a datum from the actual field object |
313 | * "Buffer Datum" -- a datum from a user buffer, read from or to be written to the field |
314 | */ |
315 | #define ACPI_COMMON_FIELD_INFO \ |
316 | UINT8 FieldFlags; /* Access, update, and lock bits */\ |
317 | UINT8 Attribute; /* From AccessAs keyword */\ |
318 | UINT8 AccessByteWidth; /* Read/Write size in bytes */\ |
319 | ACPI_NAMESPACE_NODE *Node; /* Link back to parent node */\ |
320 | UINT32 BitLength; /* Length of field in bits */\ |
321 | UINT32 BaseByteOffset; /* Byte offset within containing object */\ |
322 | UINT32 Value; /* Value to store into the Bank or Index register */\ |
323 | UINT8 StartFieldBitOffset;/* Bit offset within first field datum (0-63) */\ |
324 | UINT8 AccessLength; /* For serial regions/fields */ |
325 | |
326 | |
327 | typedef struct acpi_object_field_common /* COMMON FIELD (for BUFFER, REGION, BANK, and INDEX fields) */ |
328 | { |
329 | ACPI_OBJECT_COMMON_HEADER |
330 | ACPI_COMMON_FIELD_INFO |
331 | union acpi_operand_object *RegionObj; /* Parent Operation Region object (REGION/BANK fields only) */ |
332 | |
333 | } ACPI_OBJECT_FIELD_COMMON; |
334 | |
335 | |
336 | typedef struct acpi_object_region_field |
337 | { |
338 | ACPI_OBJECT_COMMON_HEADER |
339 | ACPI_COMMON_FIELD_INFO |
340 | UINT16 ResourceLength; |
341 | union acpi_operand_object *RegionObj; /* Containing OpRegion object */ |
342 | UINT8 *ResourceBuffer; /* ResourceTemplate for serial regions/fields */ |
343 | UINT16 PinNumberIndex; /* Index relative to previous Connection/Template */ |
344 | |
345 | } ACPI_OBJECT_REGION_FIELD; |
346 | |
347 | |
348 | typedef struct acpi_object_bank_field |
349 | { |
350 | ACPI_OBJECT_COMMON_HEADER |
351 | ACPI_COMMON_FIELD_INFO |
352 | union acpi_operand_object *RegionObj; /* Containing OpRegion object */ |
353 | union acpi_operand_object *BankObj; /* BankSelect Register object */ |
354 | |
355 | } ACPI_OBJECT_BANK_FIELD; |
356 | |
357 | |
358 | typedef struct acpi_object_index_field |
359 | { |
360 | ACPI_OBJECT_COMMON_HEADER |
361 | ACPI_COMMON_FIELD_INFO |
362 | |
363 | /* |
364 | * No "RegionObj" pointer needed since the Index and Data registers |
365 | * are each field definitions unto themselves. |
366 | */ |
367 | union acpi_operand_object *IndexObj; /* Index register */ |
368 | union acpi_operand_object *DataObj; /* Data register */ |
369 | |
370 | } ACPI_OBJECT_INDEX_FIELD; |
371 | |
372 | |
373 | /* The BufferField is different in that it is part of a Buffer, not an OpRegion */ |
374 | |
375 | typedef struct acpi_object_buffer_field |
376 | { |
377 | ACPI_OBJECT_COMMON_HEADER |
378 | ACPI_COMMON_FIELD_INFO |
379 | union acpi_operand_object *BufferObj; /* Containing Buffer object */ |
380 | |
381 | } ACPI_OBJECT_BUFFER_FIELD; |
382 | |
383 | |
384 | /****************************************************************************** |
385 | * |
386 | * Objects for handlers |
387 | * |
388 | *****************************************************************************/ |
389 | |
390 | typedef struct acpi_object_notify_handler |
391 | { |
392 | ACPI_OBJECT_COMMON_HEADER |
393 | ACPI_NAMESPACE_NODE *Node; /* Parent device */ |
394 | UINT32 HandlerType; /* Type: Device/System/Both */ |
395 | ACPI_NOTIFY_HANDLER Handler; /* Handler address */ |
396 | void *Context; |
397 | union acpi_operand_object *Next[2]; /* Device and System handler lists */ |
398 | |
399 | } ACPI_OBJECT_NOTIFY_HANDLER; |
400 | |
401 | |
402 | typedef struct acpi_object_addr_handler |
403 | { |
404 | ACPI_OBJECT_COMMON_HEADER |
405 | UINT8 SpaceId; |
406 | UINT8 HandlerFlags; |
407 | ACPI_ADR_SPACE_HANDLER Handler; |
408 | ACPI_NAMESPACE_NODE *Node; /* Parent device */ |
409 | void *Context; |
410 | ACPI_ADR_SPACE_SETUP Setup; |
411 | union acpi_operand_object *RegionList; /* Regions using this handler */ |
412 | union acpi_operand_object *Next; |
413 | |
414 | } ACPI_OBJECT_ADDR_HANDLER; |
415 | |
416 | /* Flags for address handler (HandlerFlags) */ |
417 | |
418 | #define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED 0x01 |
419 | |
420 | |
421 | /****************************************************************************** |
422 | * |
423 | * Special internal objects |
424 | * |
425 | *****************************************************************************/ |
426 | |
427 | /* |
428 | * The Reference object is used for these opcodes: |
429 | * Arg[0-6], Local[0-7], IndexOp, NameOp, RefOfOp, LoadOp, LoadTableOp, DebugOp |
430 | * The Reference.Class differentiates these types. |
431 | */ |
432 | typedef struct acpi_object_reference |
433 | { |
434 | ACPI_OBJECT_COMMON_HEADER |
435 | UINT8 Class; /* Reference Class */ |
436 | UINT8 TargetType; /* Used for Index Op */ |
437 | UINT8 Reserved; |
438 | void *Object; /* NameOp=>HANDLE to obj, IndexOp=>ACPI_OPERAND_OBJECT */ |
439 | ACPI_NAMESPACE_NODE *Node; /* RefOf or Namepath */ |
440 | union acpi_operand_object **Where; /* Target of Index */ |
441 | UINT8 *IndexPointer; /* Used for Buffers and Strings */ |
442 | UINT32 Value; /* Used for Local/Arg/Index/DdbHandle */ |
443 | |
444 | } ACPI_OBJECT_REFERENCE; |
445 | |
446 | /* Values for Reference.Class above */ |
447 | |
448 | typedef enum |
449 | { |
450 | ACPI_REFCLASS_LOCAL = 0, /* Method local */ |
451 | ACPI_REFCLASS_ARG = 1, /* Method argument */ |
452 | ACPI_REFCLASS_REFOF = 2, /* Result of RefOf() TBD: Split to Ref/Node and Ref/OperandObj? */ |
453 | ACPI_REFCLASS_INDEX = 3, /* Result of Index() */ |
454 | ACPI_REFCLASS_TABLE = 4, /* DdbHandle - Load(), LoadTable() */ |
455 | ACPI_REFCLASS_NAME = 5, /* Reference to a named object */ |
456 | ACPI_REFCLASS_DEBUG = 6, /* Debug object */ |
457 | |
458 | ACPI_REFCLASS_MAX = 6 |
459 | |
460 | } ACPI_REFERENCE_CLASSES; |
461 | |
462 | |
463 | /* |
464 | * Extra object is used as additional storage for types that |
465 | * have AML code in their declarations (TermArgs) that must be |
466 | * evaluated at run time. |
467 | * |
468 | * Currently: Region and FieldUnit types |
469 | */ |
470 | typedef struct |
471 | { |
472 | ACPI_OBJECT_COMMON_HEADER |
473 | ACPI_NAMESPACE_NODE *; /* _REG method for this region (if any) */ |
474 | ACPI_NAMESPACE_NODE *; |
475 | void *; /* Region-specific data */ |
476 | UINT8 *; |
477 | UINT32 ; |
478 | |
479 | } ; |
480 | |
481 | |
482 | /* Additional data that can be attached to namespace nodes */ |
483 | |
484 | typedef struct acpi_object_data |
485 | { |
486 | ACPI_OBJECT_COMMON_HEADER |
487 | ACPI_OBJECT_HANDLER Handler; |
488 | void *Pointer; |
489 | |
490 | } ACPI_OBJECT_DATA; |
491 | |
492 | |
493 | /* Structure used when objects are cached for reuse */ |
494 | |
495 | typedef struct acpi_object_cache_list |
496 | { |
497 | ACPI_OBJECT_COMMON_HEADER |
498 | union acpi_operand_object *Next; /* Link for object cache and internal lists*/ |
499 | |
500 | } ACPI_OBJECT_CACHE_LIST; |
501 | |
502 | |
503 | /****************************************************************************** |
504 | * |
505 | * ACPI_OPERAND_OBJECT Descriptor - a giant union of all of the above |
506 | * |
507 | *****************************************************************************/ |
508 | |
509 | typedef union acpi_operand_object |
510 | { |
511 | ACPI_OBJECT_COMMON Common; |
512 | ACPI_OBJECT_INTEGER Integer; |
513 | ACPI_OBJECT_STRING String; |
514 | ACPI_OBJECT_BUFFER Buffer; |
515 | ACPI_OBJECT_PACKAGE Package; |
516 | ACPI_OBJECT_EVENT Event; |
517 | ACPI_OBJECT_METHOD Method; |
518 | ACPI_OBJECT_MUTEX Mutex; |
519 | ACPI_OBJECT_REGION Region; |
520 | ACPI_OBJECT_NOTIFY_COMMON CommonNotify; |
521 | ACPI_OBJECT_DEVICE Device; |
522 | ACPI_OBJECT_POWER_RESOURCE PowerResource; |
523 | ACPI_OBJECT_PROCESSOR Processor; |
524 | ACPI_OBJECT_THERMAL_ZONE ThermalZone; |
525 | ACPI_OBJECT_FIELD_COMMON CommonField; |
526 | ACPI_OBJECT_REGION_FIELD Field; |
527 | ACPI_OBJECT_BUFFER_FIELD BufferField; |
528 | ACPI_OBJECT_BANK_FIELD BankField; |
529 | ACPI_OBJECT_INDEX_FIELD IndexField; |
530 | ACPI_OBJECT_NOTIFY_HANDLER Notify; |
531 | ACPI_OBJECT_ADDR_HANDLER AddressSpace; |
532 | ACPI_OBJECT_REFERENCE Reference; |
533 | ACPI_OBJECT_EXTRA Extra; |
534 | ACPI_OBJECT_DATA Data; |
535 | ACPI_OBJECT_CACHE_LIST Cache; |
536 | |
537 | /* |
538 | * Add namespace node to union in order to simplify code that accepts both |
539 | * ACPI_OPERAND_OBJECTs and ACPI_NAMESPACE_NODEs. The structures share |
540 | * a common DescriptorType field in order to differentiate them. |
541 | */ |
542 | ACPI_NAMESPACE_NODE Node; |
543 | |
544 | } ACPI_OPERAND_OBJECT; |
545 | |
546 | |
547 | /****************************************************************************** |
548 | * |
549 | * ACPI_DESCRIPTOR - objects that share a common descriptor identifier |
550 | * |
551 | *****************************************************************************/ |
552 | |
553 | /* Object descriptor types */ |
554 | |
555 | #define ACPI_DESC_TYPE_CACHED 0x01 /* Used only when object is cached */ |
556 | #define ACPI_DESC_TYPE_STATE 0x02 |
557 | #define ACPI_DESC_TYPE_STATE_UPDATE 0x03 |
558 | #define ACPI_DESC_TYPE_STATE_PACKAGE 0x04 |
559 | #define ACPI_DESC_TYPE_STATE_CONTROL 0x05 |
560 | #define ACPI_DESC_TYPE_STATE_RPSCOPE 0x06 |
561 | #define ACPI_DESC_TYPE_STATE_PSCOPE 0x07 |
562 | #define ACPI_DESC_TYPE_STATE_WSCOPE 0x08 |
563 | #define ACPI_DESC_TYPE_STATE_RESULT 0x09 |
564 | #define ACPI_DESC_TYPE_STATE_NOTIFY 0x0A |
565 | #define ACPI_DESC_TYPE_STATE_THREAD 0x0B |
566 | #define ACPI_DESC_TYPE_WALK 0x0C |
567 | #define ACPI_DESC_TYPE_PARSER 0x0D |
568 | #define ACPI_DESC_TYPE_OPERAND 0x0E |
569 | #define ACPI_DESC_TYPE_NAMED 0x0F |
570 | #define ACPI_DESC_TYPE_MAX 0x0F |
571 | |
572 | |
573 | typedef struct acpi_common_descriptor |
574 | { |
575 | void *CommonPointer; |
576 | UINT8 DescriptorType; /* To differentiate various internal objs */ |
577 | |
578 | } ACPI_COMMON_DESCRIPTOR; |
579 | |
580 | typedef union acpi_descriptor |
581 | { |
582 | ACPI_COMMON_DESCRIPTOR Common; |
583 | ACPI_OPERAND_OBJECT Object; |
584 | ACPI_NAMESPACE_NODE Node; |
585 | ACPI_PARSE_OBJECT Op; |
586 | |
587 | } ACPI_DESCRIPTOR; |
588 | |
589 | #pragma pack() |
590 | |
591 | #endif /* _ACOBJECT_H */ |
592 | |