xref: /titanic_41/usr/src/uts/intel/sys/acpi/acobject.h (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
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 ACPI_OBJECT_COMMON_HEADER \
82     union acpi_operand_object       *NextObject;        /* Objects linked to parent NS node */\
83     UINT8                           DescriptorType;     /* To differentiate various internal objs */\
84     UINT8                           Type;               /* ACPI_OBJECT_TYPE */\
85     UINT16                          ReferenceCount;     /* For object deletion management */\
86     UINT8                           Flags;
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 acpi_object_extra
471 {
472     ACPI_OBJECT_COMMON_HEADER
473     ACPI_NAMESPACE_NODE             *Method_REG;        /* _REG method for this region (if any) */
474     ACPI_NAMESPACE_NODE             *ScopeNode;
475     void                            *RegionContext;     /* Region-specific data */
476     UINT8                           *AmlStart;
477     UINT32                          AmlLength;
478 
479 } ACPI_OBJECT_EXTRA;
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