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