drivers/acpi/include/acobject.h

   1
   2 /******************************************************************************
   3  *
   4  * Name: acobject.h - Definition of ACPI_OPERAND_OBJECT  (Internal object only)
   5  *       $Revision: 75 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #ifndef _ACOBJECT_H
  28 #define _ACOBJECT_H
  29
  30
  31 /*
  32  * The ACPI_OPERAND_OBJECT  is used to pass AML operands from the dispatcher
  33  * to the interpreter, and to keep track of the various handlers such as
  34  * address space handlers and notify handlers.  The object is a constant
  35  * size in order to allow them to be cached and reused.
  36  *
  37  * All variants of the ACPI_OPERAND_OBJECT  are defined with the same
  38  * sequence of field types, with fields that are not used in a particular
  39  * variant being named "Reserved".  This is not strictly necessary, but
  40  * may in some circumstances simplify understanding if these structures
  41  * need to be displayed in a debugger having limited (or no) support for
  42  * union types.  It also simplifies some debug code in Dump_table() which
  43  * dumps multi-level values: fetching Buffer.Pointer suffices to pick up
  44  * the value or next level for any of several types.
  45  */
  46
  47 /******************************************************************************
  48  *
  49  * Common Descriptors
  50  *
  51  *****************************************************************************/
  52
  53 /*
  54  * Common area for all objects.
  55  *
  56  * Data_type is used to differentiate between internal descriptors, and MUST
  57  * be the first byte in this structure.
  58  */
  59
  60
  61 #define ACPI_OBJECT_COMMON_HEADER           /* 32-bits plus 8-bit flag */\
  62         u8                          data_type;          /* To differentiate various internal objs */\
  63         u8                          type;               /* ACPI_OBJECT_TYPE */\
  64         u16                         reference_count;    /* For object deletion management */\
  65         u8                          flags; \
  66
  67 /* Defines for flag byte above */
  68
  69 #define AOPOBJ_STATIC_ALLOCATION    0x1
  70 #define AOPOBJ_DATA_VALID           0x2
  71 #define AOPOBJ_INITIALIZED          0x4
  72
  73
  74 /*
  75  * Common bitfield for the field objects
  76  */
  77 #define ACPI_COMMON_FIELD_INFO              /* Three 32-bit values plus 8*/\
  78         u8                          granularity;\
  79         u16                         length; \
  80         u32                         offset;             /* Byte offset within containing object */\
  81         u8                          bit_offset;         /* Bit offset within min read/write data unit */\
  82         u8                          access;             /* Access_type */\
  83         u8                          lock_rule;\
  84         u8                          update_rule;\
  85         u8                          access_attribute;
  86
  87
  88 /******************************************************************************
  89  *
  90  * Individual Object Descriptors
  91  *
  92  *****************************************************************************/
  93
  94
  95 typedef struct /* COMMON */
  96 {
  97         ACPI_OBJECT_COMMON_HEADER
  98
  99 } ACPI_OBJECT_COMMON;
 100
 101
 102 typedef struct /* CACHE_LIST */
 103 {
 104         ACPI_OBJECT_COMMON_HEADER
 105         union acpi_operand_obj      *next;              /* Link for object cache and internal lists*/
 106
 107 } ACPI_OBJECT_CACHE_LIST;
 108
 109
 110 typedef struct /* NUMBER - has value */
 111 {
 112         ACPI_OBJECT_COMMON_HEADER
 113
 114         ACPI_INTEGER                value;
 115
 116 } ACPI_OBJECT_NUMBER;
 117
 118
 119 typedef struct /* STRING - has length and pointer */
 120 {
 121         ACPI_OBJECT_COMMON_HEADER
 122
 123         u32                         length;
 124         NATIVE_CHAR                 *pointer;       /* String value in AML stream or in allocated space */
 125
 126 } ACPI_OBJECT_STRING;
 127
 128
 129 typedef struct /* BUFFER - has length, sequence, and pointer */
 130 {
 131         ACPI_OBJECT_COMMON_HEADER
 132
 133         u32                         length;
 134         u32                         sequence;       /* Sequential count of buffers created */
 135
 136         u8                          *pointer;       /* points to the buffer in allocated space */
 137
 138 } ACPI_OBJECT_BUFFER;
 139
 140
 141 typedef struct /* PACKAGE - has count, elements, next element */
 142 {
 143         ACPI_OBJECT_COMMON_HEADER
 144
 145         u32                         count;          /* # of elements in package */
 146
 147         union acpi_operand_obj      **elements;     /* Array of pointers to Acpi_objects */
 148         union acpi_operand_obj      **next_element; /* used only while initializing */
 149
 150 } ACPI_OBJECT_PACKAGE;
 151
 152
 153 typedef struct /* FIELD UNIT */
 154 {
 155         ACPI_OBJECT_COMMON_HEADER
 156
 157         ACPI_COMMON_FIELD_INFO
 158
 159         union acpi_operand_obj      *extra;             /* Pointer to executable AML (in field definition) */
 160         ACPI_NAMESPACE_NODE         *node;              /* containing object */
 161         union acpi_operand_obj      *container;         /* Containing object (Buffer) */
 162
 163 } ACPI_OBJECT_FIELD_UNIT;
 164
 165
 166 typedef struct /* DEVICE - has handle and notification handler/context */
 167 {
 168         ACPI_OBJECT_COMMON_HEADER
 169
 170         union acpi_operand_obj      *sys_handler;        /* Handler for system notifies */
 171         union acpi_operand_obj      *drv_handler;        /* Handler for driver notifies */
 172         union acpi_operand_obj      *addr_handler;       /* Handler for Address space */
 173
 174 } ACPI_OBJECT_DEVICE;
 175
 176
 177 typedef struct /* EVENT */
 178 {
 179         ACPI_OBJECT_COMMON_HEADER
 180
 181         void                        *semaphore;
 182
 183 } ACPI_OBJECT_EVENT;
 184
 185
 186 #define INFINITE_CONCURRENCY        0xFF
 187
 188 typedef struct /* METHOD */
 189 {
 190         ACPI_OBJECT_COMMON_HEADER
 191         u8                          method_flags;
 192         u8                          param_count;
 193
 194         u32                         pcode_length;
 195
 196         void                        *semaphore;
 197         u8                          *pcode;
 198
 199         u8                          concurrency;
 200         u8                          thread_count;
 201         ACPI_OWNER_ID               owning_id;
 202
 203 } ACPI_OBJECT_METHOD;
 204
 205
 206 typedef struct /* MUTEX */
 207 {
 208         ACPI_OBJECT_COMMON_HEADER
 209         u16                         sync_level;
 210
 211         void                        *semaphore;
 212
 213 } ACPI_OBJECT_MUTEX;
 214
 215
 216 typedef struct /* REGION */
 217 {
 218         ACPI_OBJECT_COMMON_HEADER
 219
 220         u8                          space_id;
 221         u32                         length;
 222         ACPI_PHYSICAL_ADDRESS       address;
 223         union acpi_operand_obj      *extra;             /* Pointer to executable AML (in region definition) */
 224
 225         union acpi_operand_obj      *addr_handler;      /* Handler for system notifies */
 226         ACPI_NAMESPACE_NODE         *node;              /* containing object */
 227         union acpi_operand_obj      *next;
 228
 229 } ACPI_OBJECT_REGION;
 230
 231
 232 typedef struct /* POWER RESOURCE - has Handle and notification handler/context*/
 233 {
 234         ACPI_OBJECT_COMMON_HEADER
 235
 236         u32                         system_level;
 237         u32                         resource_order;
 238
 239         union acpi_operand_obj      *sys_handler;       /* Handler for system notifies */
 240         union acpi_operand_obj      *drv_handler;       /* Handler for driver notifies */
 241
 242 } ACPI_OBJECT_POWER_RESOURCE;
 243
 244
 245 typedef struct /* PROCESSOR - has Handle and notification handler/context*/
 246 {
 247         ACPI_OBJECT_COMMON_HEADER
 248
 249         u32                         proc_id;
 250         u32                         length;
 251         ACPI_IO_ADDRESS             address;
 252
 253         union acpi_operand_obj      *sys_handler;       /* Handler for system notifies */
 254         union acpi_operand_obj      *drv_handler;       /* Handler for driver notifies */
 255         union acpi_operand_obj      *addr_handler;      /* Handler for Address space */
 256
 257 } ACPI_OBJECT_PROCESSOR;
 258
 259
 260 typedef struct /* THERMAL ZONE - has Handle and Handler/Context */
 261 {
 262         ACPI_OBJECT_COMMON_HEADER
 263
 264         union acpi_operand_obj      *sys_handler;       /* Handler for system notifies */
 265         union acpi_operand_obj      *drv_handler;       /* Handler for driver notifies */
 266         union acpi_operand_obj      *addr_handler;      /* Handler for Address space */
 267
 268 } ACPI_OBJECT_THERMAL_ZONE;
 269
 270
 271 /*
 272  * Internal types
 273  */
 274
 275
 276 typedef struct /* FIELD */
 277 {
 278         ACPI_OBJECT_COMMON_HEADER
 279
 280         ACPI_COMMON_FIELD_INFO
 281
 282         union acpi_operand_obj      *container;         /* Containing object */
 283
 284 } ACPI_OBJECT_FIELD;
 285
 286
 287 typedef struct /* BANK FIELD */
 288 {
 289         ACPI_OBJECT_COMMON_HEADER
 290
 291         ACPI_COMMON_FIELD_INFO
 292         u32                         value;              /* Value to store into Bank_select */
 293
 294         ACPI_HANDLE                 bank_select;        /* Bank select register */
 295         union acpi_operand_obj      *container;         /* Containing object */
 296
 297 } ACPI_OBJECT_BANK_FIELD;
 298
 299
 300 typedef struct /* INDEX FIELD */
 301 {
 302         /*
 303          * No container pointer needed since the index and data register definitions
 304          * will define how to access the respective registers
 305          */
 306         ACPI_OBJECT_COMMON_HEADER
 307
 308         ACPI_COMMON_FIELD_INFO
 309         u32                         value;              /* Value to store into Index register */
 310
 311         ACPI_HANDLE                 index;              /* Index register */
 312         ACPI_HANDLE                 data;               /* Data register */
 313
 314 } ACPI_OBJECT_INDEX_FIELD;
 315
 316
 317 typedef struct /* NOTIFY HANDLER */
 318 {
 319         ACPI_OBJECT_COMMON_HEADER
 320
 321         ACPI_NAMESPACE_NODE         *node;               /* Parent device */
 322         NOTIFY_HANDLER              handler;
 323         void                        *context;
 324
 325 } ACPI_OBJECT_NOTIFY_HANDLER;
 326
 327
 328 /* Flags for address handler */
 329
 330 #define ADDR_HANDLER_DEFAULT_INSTALLED  0x1
 331
 332
 333 typedef struct /* ADDRESS HANDLER */
 334 {
 335         ACPI_OBJECT_COMMON_HEADER
 336
 337         u8                          space_id;
 338         u16                         hflags;
 339         ADDRESS_SPACE_HANDLER       handler;
 340
 341         ACPI_NAMESPACE_NODE         *node;              /* Parent device */
 342         void                        *context;
 343         ADDRESS_SPACE_SETUP         setup;
 344         union acpi_operand_obj      *region_list;       /* regions using this handler */
 345         union acpi_operand_obj      *next;
 346
 347 } ACPI_OBJECT_ADDR_HANDLER;
 348
 349
 350 /*
 351  * The Reference object type is used for these opcodes:
 352  * Arg[0-6], Local[0-7], Index_op, Name_op, Zero_op, One_op, Ones_op, Debug_op
 353  */
 354
 355 typedef struct /* Reference - Local object type */
 356 {
 357         ACPI_OBJECT_COMMON_HEADER
 358
 359         u8                          target_type;        /* Used for Index_op */
 360         u16                         op_code;
 361         u32                         offset;             /* Used for Arg_op, Local_op, and Index_op */
 362
 363         void                        *object;            /* Name_op=>HANDLE to obj, Index_op=>ACPI_OPERAND_OBJECT */
 364         ACPI_NAMESPACE_NODE         *node;
 365         union acpi_operand_obj      **where;
 366
 367 } ACPI_OBJECT_REFERENCE;
 368
 369
 370 /*
 371  * Extra object is used as additional storage for types that
 372  * have AML code in their declarations (Term_args) that must be
 373  * evaluated at run time.
 374  *
 375  * Currently: Region and Field_unit types
 376  */
 377
 378 typedef struct /* EXTRA */
 379 {
 380         ACPI_OBJECT_COMMON_HEADER
 381         u8                          byte_fill1;
 382         u16                         word_fill1;
 383         u32                         pcode_length;
 384         u8                          *pcode;
 385         ACPI_NAMESPACE_NODE         *method_REG;        /* _REG method for this region (if any) */
 386         void                        *region_context;    /* Region-specific data */
 387
 388 } ACPI_OBJECT_EXTRA;
 389
 390
 391 /******************************************************************************
 392  *
 393  * ACPI_OPERAND_OBJECT  Descriptor - a giant union of all of the above
 394  *
 395  *****************************************************************************/
 396
 397 typedef union acpi_operand_obj
 398 {
 399         ACPI_OBJECT_COMMON          common;
 400         ACPI_OBJECT_CACHE_LIST      cache;
 401         ACPI_OBJECT_NUMBER          number;
 402         ACPI_OBJECT_STRING          string;
 403         ACPI_OBJECT_BUFFER          buffer;
 404         ACPI_OBJECT_PACKAGE         package;
 405         ACPI_OBJECT_FIELD_UNIT      field_unit;
 406         ACPI_OBJECT_DEVICE          device;
 407         ACPI_OBJECT_EVENT           event;
 408         ACPI_OBJECT_METHOD          method;
 409         ACPI_OBJECT_MUTEX           mutex;
 410         ACPI_OBJECT_REGION          region;
 411         ACPI_OBJECT_POWER_RESOURCE  power_resource;
 412         ACPI_OBJECT_PROCESSOR       processor;
 413         ACPI_OBJECT_THERMAL_ZONE    thermal_zone;
 414         ACPI_OBJECT_FIELD           field;
 415         ACPI_OBJECT_BANK_FIELD      bank_field;
 416         ACPI_OBJECT_INDEX_FIELD     index_field;
 417         ACPI_OBJECT_REFERENCE       reference;
 418         ACPI_OBJECT_NOTIFY_HANDLER  notify_handler;
 419         ACPI_OBJECT_ADDR_HANDLER    addr_handler;
 420         ACPI_OBJECT_EXTRA           extra;
 421
 422 } ACPI_OPERAND_OBJECT;
 423
 424 #endif /* _ACOBJECT_H */