VT-d: adapt device attach and detach functions for IOMMU API
[linux-2.6.git] / include / acpi / acobject.h
1
2 /******************************************************************************
3  *
4  * Name: acobject.h - Definition of union acpi_operand_object  (Internal object only)
5  *
6  *****************************************************************************/
7
8 /*
9  * Copyright (C) 2000 - 2008, Intel Corp.
10  * All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions, and the following disclaimer,
17  *    without modification.
18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19  *    substantially similar to the "NO WARRANTY" disclaimer below
20  *    ("Disclaimer") and any redistribution must be conditioned upon
21  *    including a substantially similar Disclaimer requirement for further
22  *    binary redistribution.
23  * 3. Neither the names of the above-listed copyright holders nor the names
24  *    of any contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  * Alternatively, this software may be distributed under the terms of the
28  * GNU General Public License ("GPL") version 2 as published by the Free
29  * Software Foundation.
30  *
31  * NO WARRANTY
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42  * POSSIBILITY OF SUCH DAMAGES.
43  */
44
45 #ifndef _ACOBJECT_H
46 #define _ACOBJECT_H
47
48 /* acpisrc:struct_defs -- for acpisrc conversion */
49
50 /*
51  * The union 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  * descriptor_type is used to differentiate between internal descriptors, and
75  * must be in the same place across all descriptors
76  *
77  * Note: The descriptor_type and Type fields must appear in the identical
78  * position in both the struct acpi_namespace_node and union acpi_operand_object
79  * structures.
80  */
81 #define ACPI_OBJECT_COMMON_HEADER \
82         union acpi_operand_object       *next_object;       /* Objects linked to parent NS node */\
83         u8                              descriptor_type;    /* To differentiate various internal objs */\
84         u8                              type;               /* acpi_object_type */\
85         u16                             reference_count;    /* For object deletion management */\
86         u8                              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
95 #define AOPOBJ_STATIC_POINTER       0x02
96 #define AOPOBJ_DATA_VALID           0x04
97 #define AOPOBJ_OBJECT_INITIALIZED   0x08
98 #define AOPOBJ_SETUP_COMPLETE       0x10
99 #define AOPOBJ_SINGLE_DATUM         0x20
100 #define AOPOBJ_INVALID              0x40        /* Used if host OS won't allow an op_region address */
101
102 /******************************************************************************
103  *
104  * Basic data types
105  *
106  *****************************************************************************/
107
108 struct acpi_object_common {
109 ACPI_OBJECT_COMMON_HEADER};
110
111 struct acpi_object_integer {
112         ACPI_OBJECT_COMMON_HEADER u8 fill[3];   /* Prevent warning on some compilers */
113         acpi_integer value;
114 };
115
116 /*
117  * Note: The String and Buffer object must be identical through the Pointer
118  * and length elements.  There is code that depends on this.
119  *
120  * Fields common to both Strings and Buffers
121  */
122 #define ACPI_COMMON_BUFFER_INFO(_type) \
123         _type                           *pointer; \
124         u32                             length;
125
126 struct acpi_object_string {     /* Null terminated, ASCII characters only */
127         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_BUFFER_INFO(char) /* String in AML stream or allocated string */
128 };
129
130 struct acpi_object_buffer {
131         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_BUFFER_INFO(u8)   /* Buffer in AML stream or allocated buffer */
132         u32 aml_length;
133         u8 *aml_start;
134         struct acpi_namespace_node *node;       /* Link back to parent node */
135 };
136
137 struct acpi_object_package {
138         ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *node;     /* Link back to parent node */
139         union acpi_operand_object **elements;   /* Array of pointers to acpi_objects */
140         u8 *aml_start;
141         u32 aml_length;
142         u32 count;              /* # of elements in package */
143 };
144
145 /******************************************************************************
146  *
147  * Complex data types
148  *
149  *****************************************************************************/
150
151 struct acpi_object_event {
152         ACPI_OBJECT_COMMON_HEADER acpi_semaphore os_semaphore;  /* Actual OS synchronization object */
153 };
154
155 struct acpi_object_mutex {
156         ACPI_OBJECT_COMMON_HEADER u8 sync_level;        /* 0-15, specified in Mutex() call */
157         u16 acquisition_depth;  /* Allow multiple Acquires, same thread */
158         acpi_mutex os_mutex;    /* Actual OS synchronization object */
159         acpi_thread_id thread_id;       /* Current owner of the mutex */
160         struct acpi_thread_state *owner_thread; /* Current owner of the mutex */
161         union acpi_operand_object *prev;        /* Link for list of acquired mutexes */
162         union acpi_operand_object *next;        /* Link for list of acquired mutexes */
163         struct acpi_namespace_node *node;       /* Containing namespace node */
164         u8 original_sync_level; /* Owner's original sync level (0-15) */
165 };
166
167 struct acpi_object_region {
168         ACPI_OBJECT_COMMON_HEADER u8 space_id;
169         struct acpi_namespace_node *node;       /* Containing namespace node */
170         union acpi_operand_object *handler;     /* Handler for region access */
171         union acpi_operand_object *next;
172         acpi_physical_address address;
173         u32 length;
174 };
175
176 struct acpi_object_method {
177         ACPI_OBJECT_COMMON_HEADER u8 method_flags;
178         u8 param_count;
179         u8 sync_level;
180         union acpi_operand_object *mutex;
181         u8 *aml_start;
182         ACPI_INTERNAL_METHOD implementation;
183         u32 aml_length;
184         u8 thread_count;
185         acpi_owner_id owner_id;
186 };
187
188 /******************************************************************************
189  *
190  * Objects that can be notified.  All share a common notify_info area.
191  *
192  *****************************************************************************/
193
194 /*
195  * Common fields for objects that support ASL notifications
196  */
197 #define ACPI_COMMON_NOTIFY_INFO \
198         union acpi_operand_object       *system_notify;     /* Handler for system notifies */\
199         union acpi_operand_object       *device_notify;     /* Handler for driver notifies */\
200         union acpi_operand_object       *handler;       /* Handler for Address space */
201
202 struct acpi_object_notify_common {      /* COMMON NOTIFY for POWER, PROCESSOR, DEVICE, and THERMAL */
203 ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO};
204
205 struct acpi_object_device {
206         ACPI_OBJECT_COMMON_HEADER
207             ACPI_COMMON_NOTIFY_INFO struct acpi_gpe_block_info *gpe_block;
208 };
209
210 struct acpi_object_power_resource {
211         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO u32 system_level;
212         u32 resource_order;
213 };
214
215 struct acpi_object_processor {
216         ACPI_OBJECT_COMMON_HEADER
217             /* The next two fields take advantage of the 3-byte space before NOTIFY_INFO */
218         u8 proc_id;
219         u8 length;
220         ACPI_COMMON_NOTIFY_INFO acpi_io_address address;
221 };
222
223 struct acpi_object_thermal_zone {
224 ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO};
225
226 /******************************************************************************
227  *
228  * Fields.  All share a common header/info field.
229  *
230  *****************************************************************************/
231
232 /*
233  * Common bitfield for the field objects
234  * "Field Datum"  -- a datum from the actual field object
235  * "Buffer Datum" -- a datum from a user buffer, read from or to be written to the field
236  */
237 #define ACPI_COMMON_FIELD_INFO \
238         u8                              field_flags;        /* Access, update, and lock bits */\
239         u8                              attribute;          /* From access_as keyword */\
240         u8                              access_byte_width;  /* Read/Write size in bytes */\
241         struct acpi_namespace_node      *node;              /* Link back to parent node */\
242         u32                             bit_length;         /* Length of field in bits */\
243         u32                             base_byte_offset;   /* Byte offset within containing object */\
244         u32                             value;              /* Value to store into the Bank or Index register */\
245         u8                              start_field_bit_offset;/* Bit offset within first field datum (0-63) */\
246         u8                              access_bit_width;       /* Read/Write size in bits (8-64) */
247
248 struct acpi_object_field_common {       /* COMMON FIELD (for BUFFER, REGION, BANK, and INDEX fields) */
249         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj; /* Parent Operation Region object (REGION/BANK fields only) */
250 };
251
252 struct acpi_object_region_field {
253         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj; /* Containing op_region object */
254 };
255
256 struct acpi_object_bank_field {
257         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj; /* Containing op_region object */
258         union acpi_operand_object *bank_obj;    /* bank_select Register object */
259 };
260
261 struct acpi_object_index_field {
262         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO
263             /*
264              * No "RegionObj" pointer needed since the Index and Data registers
265              * are each field definitions unto themselves.
266              */
267         union acpi_operand_object *index_obj;   /* Index register */
268         union acpi_operand_object *data_obj;    /* Data register */
269 };
270
271 /* The buffer_field is different in that it is part of a Buffer, not an op_region */
272
273 struct acpi_object_buffer_field {
274         ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *buffer_obj; /* Containing Buffer object */
275 };
276
277 /******************************************************************************
278  *
279  * Objects for handlers
280  *
281  *****************************************************************************/
282
283 struct acpi_object_notify_handler {
284         ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *node;     /* Parent device */
285         acpi_notify_handler handler;
286         void *context;
287 };
288
289 struct acpi_object_addr_handler {
290         ACPI_OBJECT_COMMON_HEADER u8 space_id;
291         u8 handler_flags;
292         acpi_adr_space_handler handler;
293         struct acpi_namespace_node *node;       /* Parent device */
294         void *context;
295         acpi_adr_space_setup setup;
296         union acpi_operand_object *region_list; /* regions using this handler */
297         union acpi_operand_object *next;
298 };
299
300 /* Flags for address handler (handler_flags) */
301
302 #define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED  0x01
303
304 /******************************************************************************
305  *
306  * Special internal objects
307  *
308  *****************************************************************************/
309
310 /*
311  * The Reference object is used for these opcodes:
312  * Arg[0-6], Local[0-7], index_op, name_op, ref_of_op, load_op, load_table_op, debug_op
313  * The Reference.Class differentiates these types.
314  */
315 struct acpi_object_reference {
316         ACPI_OBJECT_COMMON_HEADER u8 class;     /* Reference Class */
317         u8 target_type;         /* Used for Index Op */
318         u8 reserved;
319         void *object;           /* name_op=>HANDLE to obj, index_op=>union acpi_operand_object */
320         struct acpi_namespace_node *node;       /* ref_of or Namepath */
321         union acpi_operand_object **where;      /* Target of Index */
322         u32 value;              /* Used for Local/Arg/Index/ddb_handle */
323 };
324
325 /* Values for Reference.Class above */
326
327 typedef enum {
328         ACPI_REFCLASS_LOCAL = 0,        /* Method local */
329         ACPI_REFCLASS_ARG = 1,  /* Method argument */
330         ACPI_REFCLASS_REFOF = 2,        /* Result of ref_of() TBD: Split to Ref/Node and Ref/operand_obj? */
331         ACPI_REFCLASS_INDEX = 3,        /* Result of Index() */
332         ACPI_REFCLASS_TABLE = 4,        /* ddb_handle - Load(), load_table() */
333         ACPI_REFCLASS_NAME = 5, /* Reference to a named object */
334         ACPI_REFCLASS_DEBUG = 6,        /* Debug object */
335
336         ACPI_REFCLASS_MAX = 6
337 } ACPI_REFERENCE_CLASSES;
338
339 /*
340  * Extra object is used as additional storage for types that
341  * have AML code in their declarations (term_args) that must be
342  * evaluated at run time.
343  *
344  * Currently: Region and field_unit types
345  */
346 struct acpi_object_extra {
347         ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *method_REG;       /* _REG method for this region (if any) */
348         void *region_context;   /* Region-specific data */
349         u8 *aml_start;
350         u32 aml_length;
351 };
352
353 /* Additional data that can be attached to namespace nodes */
354
355 struct acpi_object_data {
356         ACPI_OBJECT_COMMON_HEADER acpi_object_handler handler;
357         void *pointer;
358 };
359
360 /* Structure used when objects are cached for reuse */
361
362 struct acpi_object_cache_list {
363         ACPI_OBJECT_COMMON_HEADER union acpi_operand_object *next;      /* Link for object cache and internal lists */
364 };
365
366 /******************************************************************************
367  *
368  * union acpi_operand_object Descriptor - a giant union of all of the above
369  *
370  *****************************************************************************/
371
372 union acpi_operand_object {
373         struct acpi_object_common common;
374         struct acpi_object_integer integer;
375         struct acpi_object_string string;
376         struct acpi_object_buffer buffer;
377         struct acpi_object_package package;
378         struct acpi_object_event event;
379         struct acpi_object_method method;
380         struct acpi_object_mutex mutex;
381         struct acpi_object_region region;
382         struct acpi_object_notify_common common_notify;
383         struct acpi_object_device device;
384         struct acpi_object_power_resource power_resource;
385         struct acpi_object_processor processor;
386         struct acpi_object_thermal_zone thermal_zone;
387         struct acpi_object_field_common common_field;
388         struct acpi_object_region_field field;
389         struct acpi_object_buffer_field buffer_field;
390         struct acpi_object_bank_field bank_field;
391         struct acpi_object_index_field index_field;
392         struct acpi_object_notify_handler notify;
393         struct acpi_object_addr_handler address_space;
394         struct acpi_object_reference reference;
395         struct acpi_object_extra extra;
396         struct acpi_object_data data;
397         struct acpi_object_cache_list cache;
398
399         /*
400          * Add namespace node to union in order to simplify code that accepts both
401          * ACPI_OPERAND_OBJECTs and ACPI_NAMESPACE_NODEs. The structures share
402          * a common descriptor_type field in order to differentiate them.
403          */
404         struct acpi_namespace_node node;
405 };
406
407 /******************************************************************************
408  *
409  * union acpi_descriptor - objects that share a common descriptor identifier
410  *
411  *****************************************************************************/
412
413 /* Object descriptor types */
414
415 #define ACPI_DESC_TYPE_CACHED           0x01    /* Used only when object is cached */
416 #define ACPI_DESC_TYPE_STATE            0x02
417 #define ACPI_DESC_TYPE_STATE_UPDATE     0x03
418 #define ACPI_DESC_TYPE_STATE_PACKAGE    0x04
419 #define ACPI_DESC_TYPE_STATE_CONTROL    0x05
420 #define ACPI_DESC_TYPE_STATE_RPSCOPE    0x06
421 #define ACPI_DESC_TYPE_STATE_PSCOPE     0x07
422 #define ACPI_DESC_TYPE_STATE_WSCOPE     0x08
423 #define ACPI_DESC_TYPE_STATE_RESULT     0x09
424 #define ACPI_DESC_TYPE_STATE_NOTIFY     0x0A
425 #define ACPI_DESC_TYPE_STATE_THREAD     0x0B
426 #define ACPI_DESC_TYPE_WALK             0x0C
427 #define ACPI_DESC_TYPE_PARSER           0x0D
428 #define ACPI_DESC_TYPE_OPERAND          0x0E
429 #define ACPI_DESC_TYPE_NAMED            0x0F
430 #define ACPI_DESC_TYPE_MAX              0x0F
431
432 struct acpi_common_descriptor {
433         void *common_pointer;
434         u8 descriptor_type;     /* To differentiate various internal objs */
435 };
436
437 union acpi_descriptor {
438         struct acpi_common_descriptor common;
439         union acpi_operand_object object;
440         struct acpi_namespace_node node;
441         union acpi_parse_object op;
442 };
443
444 #pragma pack()
445
446 #endif                          /* _ACOBJECT_H */