xref: /titanic_52/usr/src/uts/intel/sys/acpi/acobject.h (revision 6cefaae1e90a413ba01560575bb3998e1a3df40e)
1 
2 /******************************************************************************
3  *
4  * Name: acobject.h - Definition of ACPI_OPERAND_OBJECT  (Internal object only)
5  *       $Revision: 1.144 $
6  *
7  *****************************************************************************/
8 
9 /******************************************************************************
10  *
11  * 1. Copyright Notice
12  *
13  * Some or all of this work - Copyright (c) 1999 - 2008, Intel Corp.
14  * All rights reserved.
15  *
16  * 2. License
17  *
18  * 2.1. This is your license from Intel Corp. under its intellectual property
19  * rights.  You may have additional license terms from the party that provided
20  * you this software, covering your right to use that party's intellectual
21  * property rights.
22  *
23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24  * copy of the source code appearing in this file ("Covered Code") an
25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26  * base code distributed originally by Intel ("Original Intel Code") to copy,
27  * make derivatives, distribute, use and display any portion of the Covered
28  * Code in any form, with the right to sublicense such rights; and
29  *
30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31  * license (with the right to sublicense), under only those claims of Intel
32  * patents that are infringed by the Original Intel Code, to make, use, sell,
33  * offer to sell, and import the Covered Code and derivative works thereof
34  * solely to the minimum extent necessary to exercise the above copyright
35  * license, and in no event shall the patent license extend to any additions
36  * to or modifications of the Original Intel Code.  No other license or right
37  * is granted directly or by implication, estoppel or otherwise;
38  *
39  * The above copyright and patent license is granted only if the following
40  * conditions are met:
41  *
42  * 3. Conditions
43  *
44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45  * Redistribution of source code of any substantial portion of the Covered
46  * Code or modification with rights to further distribute source must include
47  * the above Copyright Notice, the above License, this list of Conditions,
48  * and the following Disclaimer and Export Compliance provision.  In addition,
49  * Licensee must cause all Covered Code to which Licensee contributes to
50  * contain a file documenting the changes Licensee made to create that Covered
51  * Code and the date of any change.  Licensee must include in that file the
52  * documentation of any changes made by any predecessor Licensee.  Licensee
53  * must include a prominent statement that the modification is derived,
54  * directly or indirectly, from Original Intel Code.
55  *
56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57  * Redistribution of source code of any substantial portion of the Covered
58  * Code or modification without rights to further distribute source must
59  * include the following Disclaimer and Export Compliance provision in the
60  * documentation and/or other materials provided with distribution.  In
61  * addition, Licensee may not authorize further sublicense of source of any
62  * portion of the Covered Code, and must include terms to the effect that the
63  * license from Licensee to its licensee is limited to the intellectual
64  * property embodied in the software Licensee provides to its licensee, and
65  * not to intellectual property embodied in modifications its licensee may
66  * make.
67  *
68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
69  * substantial portion of the Covered Code or modification must reproduce the
70  * above Copyright Notice, and the following Disclaimer and Export Compliance
71  * provision in the documentation and/or other materials provided with the
72  * distribution.
73  *
74  * 3.4. Intel retains all right, title, and interest in and to the Original
75  * Intel Code.
76  *
77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78  * Intel shall be used in advertising or otherwise to promote the sale, use or
79  * other dealings in products derived from or relating to the Covered Code
80  * without prior written authorization from Intel.
81  *
82  * 4. Disclaimer and Export Compliance
83  *
84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90  * PARTICULAR PURPOSE.
91  *
92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99  * LIMITED REMEDY.
100  *
101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
102  * software or system incorporating such software without first obtaining any
103  * required license or other approval from the U. S. Department of Commerce or
104  * any other agency or department of the United States Government.  In the
105  * event Licensee exports any such software from the United States or
106  * re-exports any such software from a foreign destination, Licensee shall
107  * ensure that the distribution and export/re-export of the software is in
108  * compliance with all laws, regulations, orders, or other restrictions of the
109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110  * any of its subsidiaries will export/re-export any technical data, process,
111  * software, or service, directly or indirectly, to any country for which the
112  * United States government or any agency thereof requires an export license,
113  * other governmental approval, or letter of assurance, without first obtaining
114  * such license, approval or letter.
115  *
116  *****************************************************************************/
117 
118 #ifndef _ACOBJECT_H
119 #define _ACOBJECT_H
120 
121 /* acpisrc:StructDefs -- for acpisrc conversion */
122 
123 
124 /*
125  * The ACPI_OPERAND_OBJECT is used to pass AML operands from the dispatcher
126  * to the interpreter, and to keep track of the various handlers such as
127  * address space handlers and notify handlers. The object is a constant
128  * size in order to allow it to be cached and reused.
129  *
130  * Note: The object is optimized to be aligned and will not work if it is
131  * byte-packed.
132  */
133 #if ACPI_MACHINE_WIDTH == 64
134 #pragma pack(8)
135 #else
136 #pragma pack(4)
137 #endif
138 
139 /*******************************************************************************
140  *
141  * Common Descriptors
142  *
143  ******************************************************************************/
144 
145 /*
146  * Common area for all objects.
147  *
148  * DescriptorType is used to differentiate between internal descriptors, and
149  * must be in the same place across all descriptors
150  *
151  * Note: The DescriptorType and Type fields must appear in the identical
152  * position in both the ACPI_NAMESPACE_NODE and ACPI_OPERAND_OBJECT
153  * structures.
154  */
155 #define ACPI_OBJECT_COMMON_HEADER \
156     union acpi_operand_object       *NextObject;        /* Objects linked to parent NS node */\
157     UINT8                           DescriptorType;     /* To differentiate various internal objs */\
158     UINT8                           Type;               /* ACPI_OBJECT_TYPE */\
159     UINT16                          ReferenceCount;     /* For object deletion management */\
160     UINT8                           Flags;
161     /*
162      * Note: There are 3 bytes available here before the
163      * next natural alignment boundary (for both 32/64 cases)
164      */
165 
166 /* Values for Flag byte above */
167 
168 #define AOPOBJ_AML_CONSTANT         0x01
169 #define AOPOBJ_STATIC_POINTER       0x02
170 #define AOPOBJ_DATA_VALID           0x04
171 #define AOPOBJ_OBJECT_INITIALIZED   0x08
172 #define AOPOBJ_SETUP_COMPLETE       0x10
173 #define AOPOBJ_SINGLE_DATUM         0x20
174 #define AOPOBJ_INVALID              0x40 /* Used if host OS won't allow an OpRegion address */
175 
176 
177 /******************************************************************************
178  *
179  * Basic data types
180  *
181  *****************************************************************************/
182 
183 typedef struct acpi_object_common
184 {
185     ACPI_OBJECT_COMMON_HEADER
186 
187 } ACPI_OBJECT_COMMON;
188 
189 
190 typedef struct acpi_object_integer
191 {
192     ACPI_OBJECT_COMMON_HEADER
193     UINT8                           Fill[3];            /* Prevent warning on some compilers */
194     ACPI_INTEGER                    Value;
195 
196 } ACPI_OBJECT_INTEGER;
197 
198 
199 /*
200  * Note: The String and Buffer object must be identical through the Pointer
201  * and length elements.  There is code that depends on this.
202  *
203  * Fields common to both Strings and Buffers
204  */
205 #define ACPI_COMMON_BUFFER_INFO(_Type) \
206     _Type                           *Pointer; \
207     UINT32                          Length;
208 
209 
210 typedef struct acpi_object_string   /* Null terminated, ASCII characters only */
211 {
212     ACPI_OBJECT_COMMON_HEADER
213     ACPI_COMMON_BUFFER_INFO         (char)              /* String in AML stream or allocated string */
214 
215 } ACPI_OBJECT_STRING;
216 
217 
218 typedef struct acpi_object_buffer
219 {
220     ACPI_OBJECT_COMMON_HEADER
221     ACPI_COMMON_BUFFER_INFO         (UINT8)             /* Buffer in AML stream or allocated buffer */
222     UINT32                          AmlLength;
223     UINT8                           *AmlStart;
224     ACPI_NAMESPACE_NODE             *Node;              /* Link back to parent node */
225 
226 } ACPI_OBJECT_BUFFER;
227 
228 
229 typedef struct acpi_object_package
230 {
231     ACPI_OBJECT_COMMON_HEADER
232     ACPI_NAMESPACE_NODE             *Node;              /* Link back to parent node */
233     union acpi_operand_object       **Elements;         /* Array of pointers to AcpiObjects */
234     UINT8                           *AmlStart;
235     UINT32                          AmlLength;
236     UINT32                          Count;              /* # of elements in package */
237 
238 } ACPI_OBJECT_PACKAGE;
239 
240 
241 /******************************************************************************
242  *
243  * Complex data types
244  *
245  *****************************************************************************/
246 
247 typedef struct acpi_object_event
248 {
249     ACPI_OBJECT_COMMON_HEADER
250     ACPI_SEMAPHORE                  OsSemaphore;        /* Actual OS synchronization object */
251 
252 } ACPI_OBJECT_EVENT;
253 
254 
255 typedef struct acpi_object_mutex
256 {
257     ACPI_OBJECT_COMMON_HEADER
258     UINT8                           SyncLevel;          /* 0-15, specified in Mutex() call */
259     UINT16                          AcquisitionDepth;   /* Allow multiple Acquires, same thread */
260     ACPI_MUTEX                      OsMutex;            /* Actual OS synchronization object */
261     ACPI_THREAD_ID                  ThreadId;           /* Current owner of the mutex */
262     struct acpi_thread_state        *OwnerThread;       /* Current owner of the mutex */
263     union acpi_operand_object       *Prev;              /* Link for list of acquired mutexes */
264     union acpi_operand_object       *Next;              /* Link for list of acquired mutexes */
265     ACPI_NAMESPACE_NODE             *Node;              /* Containing namespace node */
266     UINT8                           OriginalSyncLevel;  /* Owner's original sync level (0-15) */
267 
268 } ACPI_OBJECT_MUTEX;
269 
270 
271 typedef struct acpi_object_region
272 {
273     ACPI_OBJECT_COMMON_HEADER
274     UINT8                           SpaceId;
275     ACPI_NAMESPACE_NODE             *Node;              /* Containing namespace node */
276     union acpi_operand_object       *Handler;           /* Handler for region access */
277     union acpi_operand_object       *Next;
278     ACPI_PHYSICAL_ADDRESS           Address;
279     UINT32                          Length;
280 
281 } ACPI_OBJECT_REGION;
282 
283 
284 typedef struct acpi_object_method
285 {
286     ACPI_OBJECT_COMMON_HEADER
287     UINT8                           MethodFlags;
288     UINT8                           ParamCount;
289     UINT8                           SyncLevel;
290     union acpi_operand_object       *Mutex;
291     UINT8                           *AmlStart;
292     ACPI_INTERNAL_METHOD            Implementation;
293     UINT32                          AmlLength;
294     UINT8                           ThreadCount;
295     ACPI_OWNER_ID                   OwnerId;
296 
297 } ACPI_OBJECT_METHOD;
298 
299 
300 /******************************************************************************
301  *
302  * Objects that can be notified.  All share a common NotifyInfo area.
303  *
304  *****************************************************************************/
305 
306 /*
307  * Common fields for objects that support ASL notifications
308  */
309 #define ACPI_COMMON_NOTIFY_INFO \
310     union acpi_operand_object       *SystemNotify;      /* Handler for system notifies */\
311     union acpi_operand_object       *DeviceNotify;      /* Handler for driver notifies */\
312     union acpi_operand_object       *Handler;           /* Handler for Address space */
313 
314 
315 typedef struct acpi_object_notify_common    /* COMMON NOTIFY for POWER, PROCESSOR, DEVICE, and THERMAL */
316 {
317     ACPI_OBJECT_COMMON_HEADER
318     ACPI_COMMON_NOTIFY_INFO
319 
320 } ACPI_OBJECT_NOTIFY_COMMON;
321 
322 
323 typedef struct acpi_object_device
324 {
325     ACPI_OBJECT_COMMON_HEADER
326     ACPI_COMMON_NOTIFY_INFO
327     ACPI_GPE_BLOCK_INFO             *GpeBlock;
328 
329 } ACPI_OBJECT_DEVICE;
330 
331 
332 typedef struct acpi_object_power_resource
333 {
334     ACPI_OBJECT_COMMON_HEADER
335     ACPI_COMMON_NOTIFY_INFO
336     UINT32                          SystemLevel;
337     UINT32                          ResourceOrder;
338 
339 } ACPI_OBJECT_POWER_RESOURCE;
340 
341 
342 typedef struct acpi_object_processor
343 {
344     ACPI_OBJECT_COMMON_HEADER
345 
346     /* The next two fields take advantage of the 3-byte space before NOTIFY_INFO */
347 
348     UINT8                           ProcId;
349     UINT8                           Length;
350     ACPI_COMMON_NOTIFY_INFO
351     ACPI_IO_ADDRESS                 Address;
352 
353 } ACPI_OBJECT_PROCESSOR;
354 
355 
356 typedef struct acpi_object_thermal_zone
357 {
358     ACPI_OBJECT_COMMON_HEADER
359     ACPI_COMMON_NOTIFY_INFO
360 
361 } ACPI_OBJECT_THERMAL_ZONE;
362 
363 
364 /******************************************************************************
365  *
366  * Fields.  All share a common header/info field.
367  *
368  *****************************************************************************/
369 
370 /*
371  * Common bitfield for the field objects
372  * "Field Datum"  -- a datum from the actual field object
373  * "Buffer Datum" -- a datum from a user buffer, read from or to be written to the field
374  */
375 #define ACPI_COMMON_FIELD_INFO \
376     UINT8                           FieldFlags;         /* Access, update, and lock bits */\
377     UINT8                           Attribute;          /* From AccessAs keyword */\
378     UINT8                           AccessByteWidth;    /* Read/Write size in bytes */\
379     ACPI_NAMESPACE_NODE             *Node;              /* Link back to parent node */\
380     UINT32                          BitLength;          /* Length of field in bits */\
381     UINT32                          BaseByteOffset;     /* Byte offset within containing object */\
382     UINT32                          Value;              /* Value to store into the Bank or Index register */\
383     UINT8                           StartFieldBitOffset;/* Bit offset within first field datum (0-63) */\
384     UINT8                           AccessBitWidth;     /* Read/Write size in bits (8-64) */
385 
386 
387 typedef struct acpi_object_field_common                 /* COMMON FIELD (for BUFFER, REGION, BANK, and INDEX fields) */
388 {
389     ACPI_OBJECT_COMMON_HEADER
390     ACPI_COMMON_FIELD_INFO
391     union acpi_operand_object       *RegionObj;         /* Parent Operation Region object (REGION/BANK fields only) */
392 
393 } ACPI_OBJECT_FIELD_COMMON;
394 
395 
396 typedef struct acpi_object_region_field
397 {
398     ACPI_OBJECT_COMMON_HEADER
399     ACPI_COMMON_FIELD_INFO
400     union acpi_operand_object       *RegionObj;         /* Containing OpRegion object */
401 
402 } ACPI_OBJECT_REGION_FIELD;
403 
404 
405 typedef struct acpi_object_bank_field
406 {
407     ACPI_OBJECT_COMMON_HEADER
408     ACPI_COMMON_FIELD_INFO
409     union acpi_operand_object       *RegionObj;         /* Containing OpRegion object */
410     union acpi_operand_object       *BankObj;           /* BankSelect Register object */
411 
412 } ACPI_OBJECT_BANK_FIELD;
413 
414 
415 typedef struct acpi_object_index_field
416 {
417     ACPI_OBJECT_COMMON_HEADER
418     ACPI_COMMON_FIELD_INFO
419 
420     /*
421      * No "RegionObj" pointer needed since the Index and Data registers
422      * are each field definitions unto themselves.
423      */
424     union acpi_operand_object       *IndexObj;          /* Index register */
425     union acpi_operand_object       *DataObj;           /* Data register */
426 
427 } ACPI_OBJECT_INDEX_FIELD;
428 
429 
430 /* The BufferField is different in that it is part of a Buffer, not an OpRegion */
431 
432 typedef struct acpi_object_buffer_field
433 {
434     ACPI_OBJECT_COMMON_HEADER
435     ACPI_COMMON_FIELD_INFO
436     union acpi_operand_object       *BufferObj;         /* Containing Buffer object */
437 
438 } ACPI_OBJECT_BUFFER_FIELD;
439 
440 
441 /******************************************************************************
442  *
443  * Objects for handlers
444  *
445  *****************************************************************************/
446 
447 typedef struct acpi_object_notify_handler
448 {
449     ACPI_OBJECT_COMMON_HEADER
450     ACPI_NAMESPACE_NODE             *Node;              /* Parent device */
451     ACPI_NOTIFY_HANDLER             Handler;
452     void                            *Context;
453 
454 } ACPI_OBJECT_NOTIFY_HANDLER;
455 
456 
457 typedef struct acpi_object_addr_handler
458 {
459     ACPI_OBJECT_COMMON_HEADER
460     UINT8                           SpaceId;
461     UINT8                           HandlerFlags;
462     ACPI_ADR_SPACE_HANDLER          Handler;
463     ACPI_NAMESPACE_NODE             *Node;              /* Parent device */
464     void                            *Context;
465     ACPI_ADR_SPACE_SETUP            Setup;
466     union acpi_operand_object       *RegionList;        /* regions using this handler */
467     union acpi_operand_object       *Next;
468 
469 } ACPI_OBJECT_ADDR_HANDLER;
470 
471 /* Flags for address handler (HandlerFlags) */
472 
473 #define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED  0x01
474 
475 
476 /******************************************************************************
477  *
478  * Special internal objects
479  *
480  *****************************************************************************/
481 
482 /*
483  * The Reference object is used for these opcodes:
484  * Arg[0-6], Local[0-7], IndexOp, NameOp, RefOfOp, LoadOp, LoadTableOp, DebugOp
485  * The Reference.Class differentiates these types.
486  */
487 typedef struct acpi_object_reference
488 {
489     ACPI_OBJECT_COMMON_HEADER
490      UINT8                           Class;              /* Reference Class */
491      UINT8                           TargetType;         /* Used for Index Op */
492      UINT8                           Reserved;
493      void                            *Object;            /* NameOp=>HANDLE to obj, IndexOp=>ACPI_OPERAND_OBJECT */
494      ACPI_NAMESPACE_NODE             *Node;              /* RefOf or Namepath */
495      union acpi_operand_object       **Where;            /* Target of Index */
496      UINT32                          Value;              /* Used for Local/Arg/Index/DdbHandle */
497 
498 } ACPI_OBJECT_REFERENCE;
499 
500 /* Values for Reference.Class above */
501 
502 typedef enum
503 {
504     ACPI_REFCLASS_LOCAL             = 0,        /* Method local */
505     ACPI_REFCLASS_ARG               = 1,        /* Method argument */
506     ACPI_REFCLASS_REFOF             = 2,        /* Result of RefOf() TBD: Split to Ref/Node and Ref/OperandObj? */
507     ACPI_REFCLASS_INDEX             = 3,        /* Result of Index() */
508     ACPI_REFCLASS_TABLE             = 4,        /* DdbHandle - Load(), LoadTable() */
509     ACPI_REFCLASS_NAME              = 5,        /* Reference to a named object */
510     ACPI_REFCLASS_DEBUG             = 6,        /* Debug object */
511 
512     ACPI_REFCLASS_MAX               = 6
513 
514 } ACPI_REFERENCE_CLASSES;
515 
516 
517 /*
518  * Extra object is used as additional storage for types that
519  * have AML code in their declarations (TermArgs) that must be
520  * evaluated at run time.
521  *
522  * Currently: Region and FieldUnit types
523  */
524 typedef struct acpi_object_extra
525 {
526     ACPI_OBJECT_COMMON_HEADER
527     ACPI_NAMESPACE_NODE             *Method_REG;        /* _REG method for this region (if any) */
528     void                            *RegionContext;     /* Region-specific data */
529     UINT8                           *AmlStart;
530     UINT32                          AmlLength;
531 
532 } ACPI_OBJECT_EXTRA;
533 
534 
535 /* Additional data that can be attached to namespace nodes */
536 
537 typedef struct acpi_object_data
538 {
539     ACPI_OBJECT_COMMON_HEADER
540     ACPI_OBJECT_HANDLER             Handler;
541     void                            *Pointer;
542 
543 } ACPI_OBJECT_DATA;
544 
545 
546 /* Structure used when objects are cached for reuse */
547 
548 typedef struct acpi_object_cache_list
549 {
550     ACPI_OBJECT_COMMON_HEADER
551     union acpi_operand_object       *Next;              /* Link for object cache and internal lists*/
552 
553 } ACPI_OBJECT_CACHE_LIST;
554 
555 
556 /******************************************************************************
557  *
558  * ACPI_OPERAND_OBJECT Descriptor - a giant union of all of the above
559  *
560  *****************************************************************************/
561 
562 typedef union acpi_operand_object
563 {
564     ACPI_OBJECT_COMMON                  Common;
565     ACPI_OBJECT_INTEGER                 Integer;
566     ACPI_OBJECT_STRING                  String;
567     ACPI_OBJECT_BUFFER                  Buffer;
568     ACPI_OBJECT_PACKAGE                 Package;
569     ACPI_OBJECT_EVENT                   Event;
570     ACPI_OBJECT_METHOD                  Method;
571     ACPI_OBJECT_MUTEX                   Mutex;
572     ACPI_OBJECT_REGION                  Region;
573     ACPI_OBJECT_NOTIFY_COMMON           CommonNotify;
574     ACPI_OBJECT_DEVICE                  Device;
575     ACPI_OBJECT_POWER_RESOURCE          PowerResource;
576     ACPI_OBJECT_PROCESSOR               Processor;
577     ACPI_OBJECT_THERMAL_ZONE            ThermalZone;
578     ACPI_OBJECT_FIELD_COMMON            CommonField;
579     ACPI_OBJECT_REGION_FIELD            Field;
580     ACPI_OBJECT_BUFFER_FIELD            BufferField;
581     ACPI_OBJECT_BANK_FIELD              BankField;
582     ACPI_OBJECT_INDEX_FIELD             IndexField;
583     ACPI_OBJECT_NOTIFY_HANDLER          Notify;
584     ACPI_OBJECT_ADDR_HANDLER            AddressSpace;
585     ACPI_OBJECT_REFERENCE               Reference;
586     ACPI_OBJECT_EXTRA                   Extra;
587     ACPI_OBJECT_DATA                    Data;
588     ACPI_OBJECT_CACHE_LIST              Cache;
589 
590     /*
591      * Add namespace node to union in order to simplify code that accepts both
592      * ACPI_OPERAND_OBJECTs and ACPI_NAMESPACE_NODEs. The structures share
593      * a common DescriptorType field in order to differentiate them.
594      */
595     ACPI_NAMESPACE_NODE                 Node;
596 
597 } ACPI_OPERAND_OBJECT;
598 
599 
600 /******************************************************************************
601  *
602  * ACPI_DESCRIPTOR - objects that share a common descriptor identifier
603  *
604  *****************************************************************************/
605 
606 /* Object descriptor types */
607 
608 #define ACPI_DESC_TYPE_CACHED           0x01        /* Used only when object is cached */
609 #define ACPI_DESC_TYPE_STATE            0x02
610 #define ACPI_DESC_TYPE_STATE_UPDATE     0x03
611 #define ACPI_DESC_TYPE_STATE_PACKAGE    0x04
612 #define ACPI_DESC_TYPE_STATE_CONTROL    0x05
613 #define ACPI_DESC_TYPE_STATE_RPSCOPE    0x06
614 #define ACPI_DESC_TYPE_STATE_PSCOPE     0x07
615 #define ACPI_DESC_TYPE_STATE_WSCOPE     0x08
616 #define ACPI_DESC_TYPE_STATE_RESULT     0x09
617 #define ACPI_DESC_TYPE_STATE_NOTIFY     0x0A
618 #define ACPI_DESC_TYPE_STATE_THREAD     0x0B
619 #define ACPI_DESC_TYPE_WALK             0x0C
620 #define ACPI_DESC_TYPE_PARSER           0x0D
621 #define ACPI_DESC_TYPE_OPERAND          0x0E
622 #define ACPI_DESC_TYPE_NAMED            0x0F
623 #define ACPI_DESC_TYPE_MAX              0x0F
624 
625 
626 typedef struct acpi_common_descriptor
627 {
628     void                            *CommonPointer;
629     UINT8                           DescriptorType; /* To differentiate various internal objs */
630 
631 } ACPI_COMMON_DESCRIPTOR;
632 
633 typedef union acpi_descriptor
634 {
635     ACPI_COMMON_DESCRIPTOR          Common;
636     ACPI_OPERAND_OBJECT             Object;
637     ACPI_NAMESPACE_NODE             Node;
638     ACPI_PARSE_OBJECT               Op;
639 
640 } ACPI_DESCRIPTOR;
641 
642 #pragma pack()
643 
644 #endif /* _ACOBJECT_H */
645