home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / acpi / acobject.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  14.8 KB  |  402 lines

  1.  
  2. /******************************************************************************
  3.  *
  4.  * Name: acobject.h - Definition of union acpi_operand_object    (Internal object only)
  5.  *
  6.  *****************************************************************************/
  7.  
  8. /*
  9.  * Copyright (C) 2000 - 2006, R. Byron Moore
  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. /*
  49.  * The union acpi_operand_object    is used to pass AML operands from the dispatcher
  50.  * to the interpreter, and to keep track of the various handlers such as
  51.  * address space handlers and notify handlers.  The object is a constant
  52.  * size in order to allow it to be cached and reused.
  53.  */
  54.  
  55. /*******************************************************************************
  56.  *
  57.  * Common Descriptors
  58.  *
  59.  ******************************************************************************/
  60.  
  61. /*
  62.  * Common area for all objects.
  63.  *
  64.  * data_type is used to differentiate between internal descriptors, and MUST
  65.  * be the first byte in this structure.
  66.  */
  67. #define ACPI_OBJECT_COMMON_HEADER   /* SIZE/ALIGNMENT: 32 bits, one ptr plus trailing 8-bit flag */\
  68.     u8                                      descriptor;         /* To differentiate various internal objs */\
  69.     u8                                      type;               /* acpi_object_type */\
  70.     u16                                     reference_count;    /* For object deletion management */\
  71.     union acpi_operand_object               *next_object;       /* Objects linked to parent NS node */\
  72.     u8                                      flags;
  73.  
  74. /* Values for flag byte above */
  75.  
  76. #define AOPOBJ_AML_CONSTANT         0x01
  77. #define AOPOBJ_STATIC_POINTER       0x02
  78. #define AOPOBJ_DATA_VALID           0x04
  79. #define AOPOBJ_OBJECT_INITIALIZED   0x08
  80. #define AOPOBJ_SETUP_COMPLETE       0x10
  81. #define AOPOBJ_SINGLE_DATUM         0x20
  82.  
  83. /*
  84.  * Common bitfield for the field objects
  85.  * "Field Datum"  -- a datum from the actual field object
  86.  * "Buffer Datum" -- a datum from a user buffer, read from or to be written to the field
  87.  */
  88. #define ACPI_COMMON_FIELD_INFO      /* SIZE/ALIGNMENT: 24 bits + three 32-bit values */\
  89.     u8                                      field_flags;        /* Access, update, and lock bits */\
  90.     u8                                      attribute;          /* From access_as keyword */\
  91.     u8                                      access_byte_width;  /* Read/Write size in bytes */\
  92.     u32                                     bit_length;         /* Length of field in bits */\
  93.     u32                                     base_byte_offset;   /* Byte offset within containing object */\
  94.     u8                                      start_field_bit_offset;/* Bit offset within first field datum (0-63) */\
  95.     u8                                      access_bit_width;   /* Read/Write size in bits (8-64) */\
  96.     u32                                     value;              /* Value to store into the Bank or Index register */\
  97.     struct acpi_namespace_node              *node;    /* Link back to parent node */
  98.  
  99. /*
  100.  * Fields common to both Strings and Buffers
  101.  */
  102. #define ACPI_COMMON_BUFFER_INFO \
  103.     u32                                     length;
  104.  
  105. /*
  106.  * Common fields for objects that support ASL notifications
  107.  */
  108. #define ACPI_COMMON_NOTIFY_INFO \
  109.     union acpi_operand_object               *system_notify;     /* Handler for system notifies */\
  110.     union acpi_operand_object               *device_notify;     /* Handler for driver notifies */\
  111.     union acpi_operand_object               *handler;    /* Handler for Address space */
  112.  
  113. /******************************************************************************
  114.  *
  115.  * Basic data types
  116.  *
  117.  *****************************************************************************/
  118.  
  119. struct acpi_object_common {
  120. ACPI_OBJECT_COMMON_HEADER};
  121.  
  122. struct acpi_object_integer {
  123.     ACPI_OBJECT_COMMON_HEADER acpi_integer value;
  124. };
  125.  
  126. /*
  127.  * Note: The String and Buffer object must be identical through the Pointer
  128.  * element.  There is code that depends on this.
  129.  */
  130. struct acpi_object_string {    /* Null terminated, ASCII characters only */
  131.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_BUFFER_INFO char *pointer;    /* String in AML stream or allocated string */
  132. };
  133.  
  134. struct acpi_object_buffer {
  135.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_BUFFER_INFO u8 * pointer;    /* Buffer in AML stream or allocated buffer */
  136.     struct acpi_namespace_node *node;    /* Link back to parent node */
  137.     u8 *aml_start;
  138.     u32 aml_length;
  139. };
  140.  
  141. struct acpi_object_package {
  142.     ACPI_OBJECT_COMMON_HEADER u32 count;    /* # of elements in package */
  143.     u32 aml_length;
  144.     u8 *aml_start;
  145.     struct acpi_namespace_node *node;    /* Link back to parent node */
  146.     union acpi_operand_object **elements;    /* Array of pointers to acpi_objects */
  147. };
  148.  
  149. /******************************************************************************
  150.  *
  151.  * Complex data types
  152.  *
  153.  *****************************************************************************/
  154.  
  155. struct acpi_object_event {
  156.     ACPI_OBJECT_COMMON_HEADER void *semaphore;
  157. };
  158.  
  159. #define ACPI_INFINITE_CONCURRENCY   0xFF
  160.  
  161. typedef
  162. acpi_status(*ACPI_INTERNAL_METHOD) (struct acpi_walk_state * walk_state);
  163.  
  164. struct acpi_object_method {
  165.     ACPI_OBJECT_COMMON_HEADER u8 method_flags;
  166.     u8 param_count;
  167.     u32 aml_length;
  168.     void *semaphore;
  169.     u8 *aml_start;
  170.     ACPI_INTERNAL_METHOD implementation;
  171.     u8 concurrency;
  172.     u8 thread_count;
  173.     acpi_owner_id owner_id;
  174. };
  175.  
  176. struct acpi_object_mutex {
  177.     ACPI_OBJECT_COMMON_HEADER u8 sync_level;    /* 0-15, specified in Mutex() call */
  178.     u16 acquisition_depth;    /* Allow multiple Acquires, same thread */
  179.     struct acpi_thread_state *owner_thread;    /* Current owner of the mutex */
  180.     void *semaphore;    /* Actual OS synchronization object */
  181.     union acpi_operand_object *prev;    /* Link for list of acquired mutexes */
  182.     union acpi_operand_object *next;    /* Link for list of acquired mutexes */
  183.     struct acpi_namespace_node *node;    /* Containing namespace node */
  184.     u8 original_sync_level;    /* Owner's original sync level (0-15) */
  185. };
  186.  
  187. struct acpi_object_region {
  188.     ACPI_OBJECT_COMMON_HEADER u8 space_id;
  189.     union acpi_operand_object *handler;    /* Handler for region access */
  190.     struct acpi_namespace_node *node;    /* Containing namespace node */
  191.     union acpi_operand_object *next;
  192.     u32 length;
  193.     acpi_physical_address address;
  194. };
  195.  
  196. /******************************************************************************
  197.  *
  198.  * Objects that can be notified.  All share a common notify_info area.
  199.  *
  200.  *****************************************************************************/
  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 ACPI_COMMON_NOTIFY_INFO u32 proc_id;
  217.     u32 length;
  218.     acpi_io_address address;
  219. };
  220.  
  221. struct acpi_object_thermal_zone {
  222. ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO};
  223.  
  224. /******************************************************************************
  225.  *
  226.  * Fields.  All share a common header/info field.
  227.  *
  228.  *****************************************************************************/
  229.  
  230. struct acpi_object_field_common {    /* COMMON FIELD (for BUFFER, REGION, BANK, and INDEX fields) */
  231.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj;    /* Containing Operation Region object */
  232.     /* (REGION/BANK fields only) */
  233. };
  234.  
  235. struct acpi_object_region_field {
  236.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj;    /* Containing op_region object */
  237. };
  238.  
  239. struct acpi_object_bank_field {
  240.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *region_obj;    /* Containing op_region object */
  241.     union acpi_operand_object *bank_obj;    /* bank_select Register object */
  242. };
  243.  
  244. struct acpi_object_index_field {
  245.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO
  246.         /*
  247.          * No "region_obj" pointer needed since the Index and Data registers
  248.          * are each field definitions unto themselves.
  249.          */
  250.     union acpi_operand_object *index_obj;    /* Index register */
  251.     union acpi_operand_object *data_obj;    /* Data register */
  252. };
  253.  
  254. /* The buffer_field is different in that it is part of a Buffer, not an op_region */
  255.  
  256. struct acpi_object_buffer_field {
  257.     ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object *buffer_obj;    /* Containing Buffer object */
  258. };
  259.  
  260. /******************************************************************************
  261.  *
  262.  * Objects for handlers
  263.  *
  264.  *****************************************************************************/
  265.  
  266. struct acpi_object_notify_handler {
  267.     ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *node;    /* Parent device */
  268.     acpi_notify_handler handler;
  269.     void *context;
  270. };
  271.  
  272. /* Flags for address handler */
  273.  
  274. #define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED  0x1
  275.  
  276. struct acpi_object_addr_handler {
  277.     ACPI_OBJECT_COMMON_HEADER u8 space_id;
  278.     u16 hflags;
  279.     acpi_adr_space_handler handler;
  280.     struct acpi_namespace_node *node;    /* Parent device */
  281.     void *context;
  282.     acpi_adr_space_setup setup;
  283.     union acpi_operand_object *region_list;    /* regions using this handler */
  284.     union acpi_operand_object *next;
  285. };
  286.  
  287. /******************************************************************************
  288.  *
  289.  * Special internal objects
  290.  *
  291.  *****************************************************************************/
  292.  
  293. /*
  294.  * The Reference object type is used for these opcodes:
  295.  * Arg[0-6], Local[0-7], index_op, name_op, zero_op, one_op, ones_op, debug_op
  296.  */
  297. struct acpi_object_reference {
  298.     ACPI_OBJECT_COMMON_HEADER u8 target_type;    /* Used for index_op */
  299.     u16 opcode;
  300.     u32 offset;        /* Used for arg_op, local_op, and index_op */
  301.     void *object;        /* name_op=>HANDLE to obj, index_op=>union acpi_operand_object  */
  302.     struct acpi_namespace_node *node;
  303.     union acpi_operand_object **where;
  304. };
  305.  
  306. /*
  307.  * Extra object is used as additional storage for types that
  308.  * have AML code in their declarations (term_args) that must be
  309.  * evaluated at run time.
  310.  *
  311.  * Currently: Region and field_unit types
  312.  */
  313. struct acpi_object_extra {
  314.     ACPI_OBJECT_COMMON_HEADER u8 byte_fill1;
  315.     u16 word_fill1;
  316.     u32 aml_length;
  317.     u8 *aml_start;
  318.     struct acpi_namespace_node *method_REG;    /* _REG method for this region (if any) */
  319.     void *region_context;    /* Region-specific data */
  320. };
  321.  
  322. /* Additional data that can be attached to namespace nodes */
  323.  
  324. struct acpi_object_data {
  325.     ACPI_OBJECT_COMMON_HEADER acpi_object_handler handler;
  326.     void *pointer;
  327. };
  328.  
  329. /* Structure used when objects are cached for reuse */
  330.  
  331. struct acpi_object_cache_list {
  332.     ACPI_OBJECT_COMMON_HEADER union acpi_operand_object *next;    /* Link for object cache and internal lists */
  333. };
  334.  
  335. /******************************************************************************
  336.  *
  337.  * union acpi_operand_object Descriptor - a giant union of all of the above
  338.  *
  339.  *****************************************************************************/
  340.  
  341. union acpi_operand_object {
  342.     struct acpi_object_common common;
  343.     struct acpi_object_integer integer;
  344.     struct acpi_object_string string;
  345.     struct acpi_object_buffer buffer;
  346.     struct acpi_object_package package;
  347.     struct acpi_object_event event;
  348.     struct acpi_object_method method;
  349.     struct acpi_object_mutex mutex;
  350.     struct acpi_object_region region;
  351.     struct acpi_object_notify_common common_notify;
  352.     struct acpi_object_device device;
  353.     struct acpi_object_power_resource power_resource;
  354.     struct acpi_object_processor processor;
  355.     struct acpi_object_thermal_zone thermal_zone;
  356.     struct acpi_object_field_common common_field;
  357.     struct acpi_object_region_field field;
  358.     struct acpi_object_buffer_field buffer_field;
  359.     struct acpi_object_bank_field bank_field;
  360.     struct acpi_object_index_field index_field;
  361.     struct acpi_object_notify_handler notify;
  362.     struct acpi_object_addr_handler address_space;
  363.     struct acpi_object_reference reference;
  364.     struct acpi_object_extra extra;
  365.     struct acpi_object_data data;
  366.     struct acpi_object_cache_list cache;
  367. };
  368.  
  369. /******************************************************************************
  370.  *
  371.  * union acpi_descriptor - objects that share a common descriptor identifier
  372.  *
  373.  *****************************************************************************/
  374.  
  375. /* Object descriptor types */
  376.  
  377. #define ACPI_DESC_TYPE_CACHED           0x01    /* Used only when object is cached */
  378. #define ACPI_DESC_TYPE_STATE            0x02
  379. #define ACPI_DESC_TYPE_STATE_UPDATE     0x03
  380. #define ACPI_DESC_TYPE_STATE_PACKAGE    0x04
  381. #define ACPI_DESC_TYPE_STATE_CONTROL    0x05
  382. #define ACPI_DESC_TYPE_STATE_RPSCOPE    0x06
  383. #define ACPI_DESC_TYPE_STATE_PSCOPE     0x07
  384. #define ACPI_DESC_TYPE_STATE_WSCOPE     0x08
  385. #define ACPI_DESC_TYPE_STATE_RESULT     0x09
  386. #define ACPI_DESC_TYPE_STATE_NOTIFY     0x0A
  387. #define ACPI_DESC_TYPE_STATE_THREAD     0x0B
  388. #define ACPI_DESC_TYPE_WALK             0x0C
  389. #define ACPI_DESC_TYPE_PARSER           0x0D
  390. #define ACPI_DESC_TYPE_OPERAND          0x0E
  391. #define ACPI_DESC_TYPE_NAMED            0x0F
  392. #define ACPI_DESC_TYPE_MAX              0x0F
  393.  
  394. union acpi_descriptor {
  395.     u8 descriptor_id;    /* To differentiate various internal objs */
  396.     union acpi_operand_object object;
  397.     struct acpi_namespace_node node;
  398.     union acpi_parse_object op;
  399. };
  400.  
  401. #endif                /* _ACOBJECT_H */
  402.