Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Name: acpixf.h - External interfaces to the ACPI subsystem
  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 __ACXFACE_H__
  45. #define __ACXFACE_H__
  46.  
  47. /* Current ACPICA subsystem version in YYYYMMDD format */
  48.  
  49. #define ACPI_CA_VERSION                 0x20150930
  50.  
  51. #include <acpi/acconfig.h>
  52. #include <acpi/actypes.h>
  53. #include <acpi/actbl.h>
  54. #include <acpi/acbuffer.h>
  55.  
  56. /*****************************************************************************
  57.  *
  58.  * Macros used for ACPICA globals and configuration
  59.  *
  60.  ****************************************************************************/
  61.  
  62. /*
  63.  * Ensure that global variables are defined and initialized only once.
  64.  *
  65.  * The use of these macros allows for a single list of globals (here)
  66.  * in order to simplify maintenance of the code.
  67.  */
  68. #ifdef DEFINE_ACPI_GLOBALS
  69. #define ACPI_GLOBAL(type,name) \
  70.         extern type name; \
  71.         type name
  72.  
  73. #define ACPI_INIT_GLOBAL(type,name,value) \
  74.         type name=value
  75.  
  76. #else
  77. #ifndef ACPI_GLOBAL
  78. #define ACPI_GLOBAL(type,name) \
  79.         extern type name
  80. #endif
  81.  
  82. #ifndef ACPI_INIT_GLOBAL
  83. #define ACPI_INIT_GLOBAL(type,name,value) \
  84.         extern type name
  85. #endif
  86. #endif
  87.  
  88. /*
  89.  * These macros configure the various ACPICA interfaces. They are
  90.  * useful for generating stub inline functions for features that are
  91.  * configured out of the current kernel or ACPICA application.
  92.  */
  93. #ifndef ACPI_EXTERNAL_RETURN_STATUS
  94. #define ACPI_EXTERNAL_RETURN_STATUS(prototype) \
  95.         prototype;
  96. #endif
  97.  
  98. #ifndef ACPI_EXTERNAL_RETURN_OK
  99. #define ACPI_EXTERNAL_RETURN_OK(prototype) \
  100.         prototype;
  101. #endif
  102.  
  103. #ifndef ACPI_EXTERNAL_RETURN_VOID
  104. #define ACPI_EXTERNAL_RETURN_VOID(prototype) \
  105.         prototype;
  106. #endif
  107.  
  108. #ifndef ACPI_EXTERNAL_RETURN_UINT32
  109. #define ACPI_EXTERNAL_RETURN_UINT32(prototype) \
  110.         prototype;
  111. #endif
  112.  
  113. #ifndef ACPI_EXTERNAL_RETURN_PTR
  114. #define ACPI_EXTERNAL_RETURN_PTR(prototype) \
  115.         prototype;
  116. #endif
  117.  
  118. /*****************************************************************************
  119.  *
  120.  * Public globals and runtime configuration options
  121.  *
  122.  ****************************************************************************/
  123.  
  124. /*
  125.  * Enable "slack mode" of the AML interpreter?  Default is FALSE, and the
  126.  * interpreter strictly follows the ACPI specification. Setting to TRUE
  127.  * allows the interpreter to ignore certain errors and/or bad AML constructs.
  128.  *
  129.  * Currently, these features are enabled by this flag:
  130.  *
  131.  * 1) Allow "implicit return" of last value in a control method
  132.  * 2) Allow access beyond the end of an operation region
  133.  * 3) Allow access to uninitialized locals/args (auto-init to integer 0)
  134.  * 4) Allow ANY object type to be a source operand for the Store() operator
  135.  * 5) Allow unresolved references (invalid target name) in package objects
  136.  * 6) Enable warning messages for behavior that is not ACPI spec compliant
  137.  */
  138. ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_interpreter_slack, FALSE);
  139.  
  140. /*
  141.  * Automatically serialize all methods that create named objects? Default
  142.  * is TRUE, meaning that all non_serialized methods are scanned once at
  143.  * table load time to determine those that create named objects. Methods
  144.  * that create named objects are marked Serialized in order to prevent
  145.  * possible run-time problems if they are entered by more than one thread.
  146.  */
  147. ACPI_INIT_GLOBAL(u8, acpi_gbl_auto_serialize_methods, TRUE);
  148.  
  149. /*
  150.  * Create the predefined _OSI method in the namespace? Default is TRUE
  151.  * because ACPICA is fully compatible with other ACPI implementations.
  152.  * Changing this will revert ACPICA (and machine ASL) to pre-OSI behavior.
  153.  */
  154. ACPI_INIT_GLOBAL(u8, acpi_gbl_create_osi_method, TRUE);
  155.  
  156. /*
  157.  * Optionally use default values for the ACPI register widths. Set this to
  158.  * TRUE to use the defaults, if an FADT contains incorrect widths/lengths.
  159.  */
  160. ACPI_INIT_GLOBAL(u8, acpi_gbl_use_default_register_widths, TRUE);
  161.  
  162. /*
  163.  * Whether or not to verify the table checksum before installation. Set
  164.  * this to TRUE to verify the table checksum before install it to the table
  165.  * manager. Note that enabling this option causes errors to happen in some
  166.  * OSPMs during early initialization stages. Default behavior is to do such
  167.  * verification.
  168.  */
  169. ACPI_INIT_GLOBAL(u8, acpi_gbl_verify_table_checksum, TRUE);
  170.  
  171. /*
  172.  * Optionally enable output from the AML Debug Object.
  173.  */
  174. ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_aml_debug_object, FALSE);
  175.  
  176. /*
  177.  * Optionally copy the entire DSDT to local memory (instead of simply
  178.  * mapping it.) There are some BIOSs that corrupt or replace the original
  179.  * DSDT, creating the need for this option. Default is FALSE, do not copy
  180.  * the DSDT.
  181.  */
  182. ACPI_INIT_GLOBAL(u8, acpi_gbl_copy_dsdt_locally, FALSE);
  183.  
  184. /*
  185.  * Optionally ignore an XSDT if present and use the RSDT instead.
  186.  * Although the ACPI specification requires that an XSDT be used instead
  187.  * of the RSDT, the XSDT has been found to be corrupt or ill-formed on
  188.  * some machines. Default behavior is to use the XSDT if present.
  189.  */
  190. ACPI_INIT_GLOBAL(u8, acpi_gbl_do_not_use_xsdt, FALSE);
  191.  
  192. /*
  193.  * Optionally use 32-bit FADT addresses if and when there is a conflict
  194.  * (address mismatch) between the 32-bit and 64-bit versions of the
  195.  * address. Although ACPICA adheres to the ACPI specification which
  196.  * requires the use of the corresponding 64-bit address if it is non-zero,
  197.  * some machines have been found to have a corrupted non-zero 64-bit
  198.  * address. Default is FALSE, do not favor the 32-bit addresses.
  199.  */
  200. ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, FALSE);
  201.  
  202. /*
  203.  * Optionally use 32-bit FACS table addresses.
  204.  * It is reported that some platforms fail to resume from system suspending
  205.  * if 64-bit FACS table address is selected:
  206.  * https://bugzilla.kernel.org/show_bug.cgi?id=74021
  207.  * Default is TRUE, favor the 32-bit addresses.
  208.  */
  209. ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_facs_addresses, TRUE);
  210.  
  211. /*
  212.  * Optionally truncate I/O addresses to 16 bits. Provides compatibility
  213.  * with other ACPI implementations. NOTE: During ACPICA initialization,
  214.  * this value is set to TRUE if any Windows OSI strings have been
  215.  * requested by the BIOS.
  216.  */
  217. ACPI_INIT_GLOBAL(u8, acpi_gbl_truncate_io_addresses, FALSE);
  218.  
  219. /*
  220.  * Disable runtime checking and repair of values returned by control methods.
  221.  * Use only if the repair is causing a problem on a particular machine.
  222.  */
  223. ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_auto_repair, FALSE);
  224.  
  225. /*
  226.  * Optionally do not install any SSDTs from the RSDT/XSDT during initialization.
  227.  * This can be useful for debugging ACPI problems on some machines.
  228.  */
  229. ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_ssdt_table_install, FALSE);
  230.  
  231. /*
  232.  * Optionally enable runtime namespace override.
  233.  */
  234. ACPI_INIT_GLOBAL(u8, acpi_gbl_runtime_namespace_override, TRUE);
  235.  
  236. /*
  237.  * We keep track of the latest version of Windows that has been requested by
  238.  * the BIOS. ACPI 5.0.
  239.  */
  240. ACPI_INIT_GLOBAL(u8, acpi_gbl_osi_data, 0);
  241.  
  242. /*
  243.  * ACPI 5.0 introduces the concept of a "reduced hardware platform", meaning
  244.  * that the ACPI hardware is no longer required. A flag in the FADT indicates
  245.  * a reduced HW machine, and that flag is duplicated here for convenience.
  246.  */
  247. ACPI_INIT_GLOBAL(u8, acpi_gbl_reduced_hardware, FALSE);
  248.  
  249. /*
  250.  * This mechanism is used to trace a specified AML method. The method is
  251.  * traced each time it is executed.
  252.  */
  253. ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_flags, 0);
  254. ACPI_INIT_GLOBAL(const char *, acpi_gbl_trace_method_name, NULL);
  255. ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_dbg_level, ACPI_TRACE_LEVEL_DEFAULT);
  256. ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_dbg_layer, ACPI_TRACE_LAYER_DEFAULT);
  257.  
  258. /*
  259.  * Runtime configuration of debug output control masks. We want the debug
  260.  * switches statically initialized so they are already set when the debugger
  261.  * is entered.
  262.  */
  263. ACPI_INIT_GLOBAL(u32, acpi_dbg_level, ACPI_DEBUG_DEFAULT);
  264. ACPI_INIT_GLOBAL(u32, acpi_dbg_layer, 0);
  265.  
  266. /*
  267.  * Other miscellaneous globals
  268.  */
  269. ACPI_GLOBAL(struct acpi_table_fadt, acpi_gbl_FADT);
  270. ACPI_GLOBAL(u32, acpi_current_gpe_count);
  271. ACPI_GLOBAL(u8, acpi_gbl_system_awake_and_running);
  272.  
  273. /*****************************************************************************
  274.  *
  275.  * ACPICA public interface configuration.
  276.  *
  277.  * Interfaces that are configured out of the ACPICA build are replaced
  278.  * by inlined stubs by default.
  279.  *
  280.  ****************************************************************************/
  281.  
  282. /*
  283.  * Hardware-reduced prototypes (default: Not hardware reduced).
  284.  *
  285.  * All ACPICA hardware-related interfaces that use these macros will be
  286.  * configured out of the ACPICA build if the ACPI_REDUCED_HARDWARE flag
  287.  * is set to TRUE.
  288.  *
  289.  * Note: This static build option for reduced hardware is intended to
  290.  * reduce ACPICA code size if desired or necessary. However, even if this
  291.  * option is not specified, the runtime behavior of ACPICA is dependent
  292.  * on the actual FADT reduced hardware flag (HW_REDUCED_ACPI). If set,
  293.  * the flag will enable similar behavior -- ACPICA will not attempt
  294.  * to access any ACPI-relate hardware (SCI, GPEs, Fixed Events, etc.)
  295.  */
  296. #if (!ACPI_REDUCED_HARDWARE)
  297. #define ACPI_HW_DEPENDENT_RETURN_STATUS(prototype) \
  298.         ACPI_EXTERNAL_RETURN_STATUS(prototype)
  299.  
  300. #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) \
  301.         ACPI_EXTERNAL_RETURN_OK(prototype)
  302.  
  303. #define ACPI_HW_DEPENDENT_RETURN_VOID(prototype) \
  304.         ACPI_EXTERNAL_RETURN_VOID(prototype)
  305.  
  306. #else
  307. #define ACPI_HW_DEPENDENT_RETURN_STATUS(prototype) \
  308.         static ACPI_INLINE prototype {return(AE_NOT_CONFIGURED);}
  309.  
  310. #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) \
  311.         static ACPI_INLINE prototype {return(AE_OK);}
  312.  
  313. #define ACPI_HW_DEPENDENT_RETURN_VOID(prototype) \
  314.         static ACPI_INLINE prototype {return;}
  315.  
  316. #endif                          /* !ACPI_REDUCED_HARDWARE */
  317.  
  318. /*
  319.  * Error message prototypes (default: error messages enabled).
  320.  *
  321.  * All interfaces related to error and warning messages
  322.  * will be configured out of the ACPICA build if the
  323.  * ACPI_NO_ERROR_MESSAGE flag is defined.
  324.  */
  325. #ifndef ACPI_NO_ERROR_MESSAGES
  326. #define ACPI_MSG_DEPENDENT_RETURN_VOID(prototype) \
  327.         prototype;
  328.  
  329. #else
  330. #define ACPI_MSG_DEPENDENT_RETURN_VOID(prototype) \
  331.         static ACPI_INLINE prototype {return;}
  332.  
  333. #endif                          /* ACPI_NO_ERROR_MESSAGES */
  334.  
  335. /*
  336.  * Debugging output prototypes (default: no debug output).
  337.  *
  338.  * All interfaces related to debug output messages
  339.  * will be configured out of the ACPICA build unless the
  340.  * ACPI_DEBUG_OUTPUT flag is defined.
  341.  */
  342. #ifdef ACPI_DEBUG_OUTPUT
  343. #define ACPI_DBG_DEPENDENT_RETURN_VOID(prototype) \
  344.         prototype;
  345.  
  346. #else
  347. #define ACPI_DBG_DEPENDENT_RETURN_VOID(prototype) \
  348.         static ACPI_INLINE prototype {return;}
  349.  
  350. #endif                          /* ACPI_DEBUG_OUTPUT */
  351.  
  352. /*
  353.  * Application prototypes
  354.  *
  355.  * All interfaces used by application will be configured
  356.  * out of the ACPICA build unless the ACPI_APPLICATION
  357.  * flag is defined.
  358.  */
  359. #ifdef ACPI_APPLICATION
  360. #define ACPI_APP_DEPENDENT_RETURN_VOID(prototype) \
  361.         prototype;
  362.  
  363. #else
  364. #define ACPI_APP_DEPENDENT_RETURN_VOID(prototype) \
  365.         static ACPI_INLINE prototype {return;}
  366.  
  367. #endif                          /* ACPI_APPLICATION */
  368.  
  369. /*****************************************************************************
  370.  *
  371.  * ACPICA public interface prototypes
  372.  *
  373.  ****************************************************************************/
  374.  
  375. /*
  376.  * Initialization
  377.  */
  378. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init
  379.                             acpi_initialize_tables(struct acpi_table_desc
  380.                                                    *initial_storage,
  381.                                                    u32 initial_table_count,
  382.                                                    u8 allow_resize))
  383. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init acpi_initialize_subsystem(void))
  384.  
  385. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init acpi_enable_subsystem(u32 flags))
  386.  
  387. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init
  388.                             acpi_initialize_objects(u32 flags))
  389. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init acpi_terminate(void))
  390.  
  391. /*
  392.  * Miscellaneous global interfaces
  393.  */
  394. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enable(void))
  395. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_disable(void))
  396. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_subsystem_status(void))
  397.  
  398. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  399.                             acpi_get_system_info(struct acpi_buffer
  400.                                                  *ret_buffer))
  401. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  402.                              acpi_get_statistics(struct acpi_statistics *stats))
  403. ACPI_EXTERNAL_RETURN_PTR(const char
  404.                           *acpi_format_exception(acpi_status exception))
  405. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_purge_cached_objects(void))
  406.  
  407. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  408.                             acpi_install_interface(acpi_string interface_name))
  409.  
  410. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  411.                             acpi_remove_interface(acpi_string interface_name))
  412. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_update_interfaces(u8 action))
  413.  
  414. ACPI_EXTERNAL_RETURN_UINT32(u32
  415.                             acpi_check_address_range(acpi_adr_space_type
  416.                                                      space_id,
  417.                                                      acpi_physical_address
  418.                                                      address, acpi_size length,
  419.                                                      u8 warn))
  420. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  421.                              acpi_decode_pld_buffer(u8 *in_buffer,
  422.                                                     acpi_size length,
  423.                                                     struct acpi_pld_info
  424.                                                     **return_buffer))
  425.  
  426. /*
  427.  * ACPI table load/unload interfaces
  428.  */
  429. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init
  430.                             acpi_install_table(acpi_physical_address address,
  431.                                                u8 physical))
  432.  
  433. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  434.                             acpi_load_table(struct acpi_table_header *table))
  435.  
  436. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  437.                             acpi_unload_parent_table(acpi_handle object))
  438. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init acpi_load_tables(void))
  439.  
  440. /*
  441.  * ACPI table manipulation interfaces
  442.  */
  443. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init acpi_reallocate_root_table(void))
  444.  
  445. ACPI_EXTERNAL_RETURN_STATUS(acpi_status __init
  446.                             acpi_find_root_pointer(acpi_physical_address *
  447.                                                    rsdp_address))
  448. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  449.                              acpi_get_table_header(acpi_string signature,
  450.                                                    u32 instance,
  451.                                                    struct acpi_table_header
  452.                                                    *out_table_header))
  453. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  454.                              acpi_get_table(acpi_string signature, u32 instance,
  455.                                             struct acpi_table_header
  456.                                             **out_table))
  457. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  458.                              acpi_get_table_by_index(u32 table_index,
  459.                                                      struct acpi_table_header
  460.                                                      **out_table))
  461. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  462.                              acpi_install_table_handler(acpi_table_handler
  463.                                                         handler, void *context))
  464. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  465.                              acpi_remove_table_handler(acpi_table_handler
  466.                                                        handler))
  467.  
  468. /*
  469.  * Namespace and name interfaces
  470.  */
  471. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  472.                             acpi_walk_namespace(acpi_object_type type,
  473.                                                 acpi_handle start_object,
  474.                                                 u32 max_depth,
  475.                                                 acpi_walk_callback
  476.                                                 descending_callback,
  477.                                                 acpi_walk_callback
  478.                                                 ascending_callback,
  479.                                                 void *context,
  480.                                                 void **return_value))
  481. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  482.                              acpi_get_devices(const char *HID,
  483.                                               acpi_walk_callback user_function,
  484.                                               void *context,
  485.                                               void **return_value))
  486. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  487.                              acpi_get_name(acpi_handle object, u32 name_type,
  488.                                            struct acpi_buffer *ret_path_ptr))
  489. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  490.                              acpi_get_handle(acpi_handle parent,
  491.                                              acpi_string pathname,
  492.                                              acpi_handle * ret_handle))
  493. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  494.                              acpi_attach_data(acpi_handle object,
  495.                                               acpi_object_handler handler,
  496.                                               void *data))
  497. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  498.                              acpi_detach_data(acpi_handle object,
  499.                                               acpi_object_handler handler))
  500. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  501.                              acpi_get_data(acpi_handle object,
  502.                                            acpi_object_handler handler,
  503.                                            void **data))
  504. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  505.                              acpi_debug_trace(const char *name, u32 debug_level,
  506.                                               u32 debug_layer, u32 flags))
  507.  
  508. /*
  509.  * Object manipulation and enumeration
  510.  */
  511. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  512.                             acpi_evaluate_object(acpi_handle object,
  513.                                                  acpi_string pathname,
  514.                                                  struct acpi_object_list
  515.                                                  *parameter_objects,
  516.                                                  struct acpi_buffer
  517.                                                  *return_object_buffer))
  518. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  519.                              acpi_evaluate_object_typed(acpi_handle object,
  520.                                                         acpi_string pathname,
  521.                                                         struct acpi_object_list
  522.                                                         *external_params,
  523.                                                         struct acpi_buffer
  524.                                                         *return_buffer,
  525.                                                         acpi_object_type
  526.                                                         return_type))
  527. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  528.                              acpi_get_object_info(acpi_handle object,
  529.                                                   struct acpi_device_info
  530.                                                   **return_buffer))
  531. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_install_method(u8 *buffer))
  532.  
  533. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  534.                             acpi_get_next_object(acpi_object_type type,
  535.                                                  acpi_handle parent,
  536.                                                  acpi_handle child,
  537.                                                  acpi_handle * out_handle))
  538.  
  539. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  540.                             acpi_get_type(acpi_handle object,
  541.                                           acpi_object_type * out_type))
  542.  
  543. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  544.                             acpi_get_parent(acpi_handle object,
  545.                                             acpi_handle * out_handle))
  546.  
  547. /*
  548.  * Handler interfaces
  549.  */
  550. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  551.                             acpi_install_initialization_handler
  552.                             (acpi_init_handler handler, u32 function))
  553. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  554.                                  acpi_install_sci_handler(acpi_sci_handler
  555.                                                           address,
  556.                                                           void *context))
  557. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  558.                                  acpi_remove_sci_handler(acpi_sci_handler
  559.                                                          address))
  560. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  561.                                  acpi_install_global_event_handler
  562.                                  (acpi_gbl_event_handler handler,
  563.                                   void *context))
  564. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  565.                                  acpi_install_fixed_event_handler(u32
  566.                                                                   acpi_event,
  567.                                                                   acpi_event_handler
  568.                                                                   handler,
  569.                                                                   void
  570.                                                                   *context))
  571. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  572.                                  acpi_remove_fixed_event_handler(u32 acpi_event,
  573.                                                                  acpi_event_handler
  574.                                                                  handler))
  575. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  576.                                  acpi_install_gpe_handler(acpi_handle
  577.                                                           gpe_device,
  578.                                                           u32 gpe_number,
  579.                                                           u32 type,
  580.                                                           acpi_gpe_handler
  581.                                                           address,
  582.                                                           void *context))
  583. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  584.                                  acpi_install_gpe_raw_handler(acpi_handle
  585.                                                               gpe_device,
  586.                                                               u32 gpe_number,
  587.                                                               u32 type,
  588.                                                               acpi_gpe_handler
  589.                                                               address,
  590.                                                               void *context))
  591. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  592.                                  acpi_remove_gpe_handler(acpi_handle gpe_device,
  593.                                                          u32 gpe_number,
  594.                                                          acpi_gpe_handler
  595.                                                          address))
  596. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  597.                              acpi_install_notify_handler(acpi_handle device,
  598.                                                          u32 handler_type,
  599.                                                          acpi_notify_handler
  600.                                                          handler,
  601.                                                          void *context))
  602. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  603.                              acpi_remove_notify_handler(acpi_handle device,
  604.                                                         u32 handler_type,
  605.                                                         acpi_notify_handler
  606.                                                         handler))
  607. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  608.                              acpi_install_address_space_handler(acpi_handle
  609.                                                                 device,
  610.                                                                 acpi_adr_space_type
  611.                                                                 space_id,
  612.                                                                 acpi_adr_space_handler
  613.                                                                 handler,
  614.                                                                 acpi_adr_space_setup
  615.                                                                 setup,
  616.                                                                 void *context))
  617. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  618.                              acpi_remove_address_space_handler(acpi_handle
  619.                                                                device,
  620.                                                                acpi_adr_space_type
  621.                                                                space_id,
  622.                                                                acpi_adr_space_handler
  623.                                                                handler))
  624. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  625.                              acpi_install_exception_handler
  626.                              (acpi_exception_handler handler))
  627. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  628.                              acpi_install_interface_handler
  629.                              (acpi_interface_handler handler))
  630.  
  631. /*
  632.  * Global Lock interfaces
  633.  */
  634. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  635.                                 acpi_acquire_global_lock(u16 timeout,
  636.                                                          u32 *handle))
  637.  
  638. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  639.                                 acpi_release_global_lock(u32 handle))
  640.  
  641. /*
  642.  * Interfaces to AML mutex objects
  643.  */
  644. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  645.                             acpi_acquire_mutex(acpi_handle handle,
  646.                                                acpi_string pathname,
  647.                                                u16 timeout))
  648.  
  649. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  650.                             acpi_release_mutex(acpi_handle handle,
  651.                                                acpi_string pathname))
  652.  
  653. /*
  654.  * Fixed Event interfaces
  655.  */
  656. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  657.                                 acpi_enable_event(u32 event, u32 flags))
  658.  
  659. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  660.                                 acpi_disable_event(u32 event, u32 flags))
  661. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_clear_event(u32 event))
  662.  
  663. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  664.                                 acpi_get_event_status(u32 event,
  665.                                                       acpi_event_status
  666.                                                       *event_status))
  667.  
  668. /*
  669.  * General Purpose Event (GPE) Interfaces
  670.  */
  671. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_update_all_gpes(void))
  672.  
  673. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  674.                                 acpi_enable_gpe(acpi_handle gpe_device,
  675.                                                 u32 gpe_number))
  676.  
  677. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  678.                                 acpi_disable_gpe(acpi_handle gpe_device,
  679.                                                  u32 gpe_number))
  680.  
  681. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  682.                                 acpi_clear_gpe(acpi_handle gpe_device,
  683.                                                u32 gpe_number))
  684.  
  685. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  686.                                 acpi_set_gpe(acpi_handle gpe_device,
  687.                                              u32 gpe_number, u8 action))
  688.  
  689. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  690.                                 acpi_finish_gpe(acpi_handle gpe_device,
  691.                                                 u32 gpe_number))
  692.  
  693. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  694.                                 acpi_mark_gpe_for_wake(acpi_handle gpe_device,
  695.                                                        u32 gpe_number))
  696.  
  697. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  698.                                 acpi_setup_gpe_for_wake(acpi_handle
  699.                                                         parent_device,
  700.                                                         acpi_handle gpe_device,
  701.                                                         u32 gpe_number))
  702. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  703.                                  acpi_set_gpe_wake_mask(acpi_handle gpe_device,
  704.                                                         u32 gpe_number,
  705.                                                         u8 action))
  706. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  707.                                  acpi_get_gpe_status(acpi_handle gpe_device,
  708.                                                      u32 gpe_number,
  709.                                                      acpi_event_status
  710.                                                      *event_status))
  711. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_disable_all_gpes(void))
  712. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enable_all_runtime_gpes(void))
  713. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enable_all_wakeup_gpes(void))
  714.  
  715. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  716.                                 acpi_get_gpe_device(u32 gpe_index,
  717.                                                     acpi_handle * gpe_device))
  718.  
  719. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  720.                                 acpi_install_gpe_block(acpi_handle gpe_device,
  721.                                                        struct
  722.                                                        acpi_generic_address
  723.                                                        *gpe_block_address,
  724.                                                        u32 register_count,
  725.                                                        u32 interrupt_number))
  726. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  727.                                  acpi_remove_gpe_block(acpi_handle gpe_device))
  728.  
  729. /*
  730.  * Resource interfaces
  731.  */
  732. typedef
  733. acpi_status(*acpi_walk_resource_callback) (struct acpi_resource * resource,
  734.                                            void *context);
  735.  
  736. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  737.                             acpi_get_vendor_resource(acpi_handle device,
  738.                                                      char *name,
  739.                                                      struct acpi_vendor_uuid
  740.                                                      *uuid,
  741.                                                      struct acpi_buffer
  742.                                                      *ret_buffer))
  743. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  744.                              acpi_get_current_resources(acpi_handle device,
  745.                                                         struct acpi_buffer
  746.                                                         *ret_buffer))
  747. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  748.                              acpi_get_possible_resources(acpi_handle device,
  749.                                                          struct acpi_buffer
  750.                                                          *ret_buffer))
  751. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  752.                              acpi_get_event_resources(acpi_handle device_handle,
  753.                                                       struct acpi_buffer
  754.                                                       *ret_buffer))
  755. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  756.                              acpi_walk_resource_buffer(struct acpi_buffer
  757.                                                        *buffer,
  758.                                                        acpi_walk_resource_callback
  759.                                                        user_function,
  760.                                                        void *context))
  761. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  762.                              acpi_walk_resources(acpi_handle device, char *name,
  763.                                                  acpi_walk_resource_callback
  764.                                                  user_function, void *context))
  765. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  766.                              acpi_set_current_resources(acpi_handle device,
  767.                                                         struct acpi_buffer
  768.                                                         *in_buffer))
  769. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  770.                              acpi_get_irq_routing_table(acpi_handle device,
  771.                                                         struct acpi_buffer
  772.                                                         *ret_buffer))
  773. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  774.                              acpi_resource_to_address64(struct acpi_resource
  775.                                                         *resource,
  776.                                                         struct
  777.                                                         acpi_resource_address64
  778.                                                         *out))
  779. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  780.                              acpi_buffer_to_resource(u8 *aml_buffer,
  781.                                                      u16 aml_buffer_length,
  782.                                                      struct acpi_resource
  783.                                                      **resource_ptr))
  784.  
  785. /*
  786.  * Hardware (ACPI device) interfaces
  787.  */
  788. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_reset(void))
  789.  
  790. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  791.                             acpi_read(u64 *value,
  792.                                       struct acpi_generic_address *reg))
  793.  
  794. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  795.                             acpi_write(u64 value,
  796.                                        struct acpi_generic_address *reg))
  797.  
  798. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  799.                                 acpi_read_bit_register(u32 register_id,
  800.                                                        u32 *return_value))
  801.  
  802. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  803.                                 acpi_write_bit_register(u32 register_id,
  804.                                                         u32 value))
  805.  
  806. /*
  807.  * Sleep/Wake interfaces
  808.  */
  809. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  810.                             acpi_get_sleep_type_data(u8 sleep_state,
  811.                                                      u8 *slp_typ_a,
  812.                                                      u8 *slp_typ_b))
  813.  
  814. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  815.                             acpi_enter_sleep_state_prep(u8 sleep_state))
  816. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_enter_sleep_state(u8 sleep_state))
  817.  
  818. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enter_sleep_state_s4bios(void))
  819.  
  820. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  821.                             acpi_leave_sleep_state_prep(u8 sleep_state))
  822. ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_leave_sleep_state(u8 sleep_state))
  823.  
  824. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  825.                                 acpi_set_firmware_waking_vectors
  826.                                 (acpi_physical_address physical_address,
  827.                                  acpi_physical_address physical_address64))
  828. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  829.                                  acpi_set_firmware_waking_vector(u32
  830.                                                                  physical_address))
  831. #if ACPI_MACHINE_WIDTH == 64
  832. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  833.                                 acpi_set_firmware_waking_vector64(u64
  834.                                                                   physical_address))
  835. #endif
  836. /*
  837.  * ACPI Timer interfaces
  838.  */
  839. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  840.                                 acpi_get_timer_resolution(u32 *resolution))
  841. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_get_timer(u32 *ticks))
  842.  
  843. ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
  844.                                 acpi_get_timer_duration(u32 start_ticks,
  845.                                                         u32 end_ticks,
  846.                                                         u32 *time_elapsed))
  847.  
  848. /*
  849.  * Error/Warning output
  850.  */
  851. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(3)
  852.                                void ACPI_INTERNAL_VAR_XFACE
  853.                                acpi_error(const char *module_name,
  854.                                           u32 line_number,
  855.                                           const char *format, ...))
  856. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(4)
  857.                                 void ACPI_INTERNAL_VAR_XFACE
  858.                                 acpi_exception(const char *module_name,
  859.                                                u32 line_number,
  860.                                                acpi_status status,
  861.                                                const char *format, ...))
  862. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(3)
  863.                                 void ACPI_INTERNAL_VAR_XFACE
  864.                                 acpi_warning(const char *module_name,
  865.                                              u32 line_number,
  866.                                              const char *format, ...))
  867. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(3)
  868.                                 void ACPI_INTERNAL_VAR_XFACE
  869.                                 acpi_info(const char *module_name,
  870.                                           u32 line_number,
  871.                                           const char *format, ...))
  872. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(3)
  873.                                 void ACPI_INTERNAL_VAR_XFACE
  874.                                 acpi_bios_error(const char *module_name,
  875.                                                 u32 line_number,
  876.                                                 const char *format, ...))
  877. ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(3)
  878.                                 void ACPI_INTERNAL_VAR_XFACE
  879.                                 acpi_bios_warning(const char *module_name,
  880.                                                   u32 line_number,
  881.                                                   const char *format, ...))
  882.  
  883. /*
  884.  * Debug output
  885.  */
  886. ACPI_DBG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(6)
  887.                                void ACPI_INTERNAL_VAR_XFACE
  888.                                acpi_debug_print(u32 requested_debug_level,
  889.                                                 u32 line_number,
  890.                                                 const char *function_name,
  891.                                                 const char *module_name,
  892.                                                 u32 component_id,
  893.                                                 const char *format, ...))
  894. ACPI_DBG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(6)
  895.                                 void ACPI_INTERNAL_VAR_XFACE
  896.                                 acpi_debug_print_raw(u32 requested_debug_level,
  897.                                                      u32 line_number,
  898.                                                      const char *function_name,
  899.                                                      const char *module_name,
  900.                                                      u32 component_id,
  901.                                                      const char *format, ...))
  902.  
  903. ACPI_DBG_DEPENDENT_RETURN_VOID(void
  904.                                acpi_trace_point(acpi_trace_event_type type,
  905.                                                 u8 begin,
  906.                                                 u8 *aml, char *pathname))
  907. ACPI_APP_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIKE(1)
  908.                                 void ACPI_INTERNAL_VAR_XFACE
  909.                                 acpi_log_error(const char *format, ...))
  910.  acpi_status acpi_initialize_debugger(void);
  911.  
  912. void acpi_terminate_debugger(void);
  913.  
  914. /*
  915.  * Divergences
  916.  */
  917. ACPI_GLOBAL(u8, acpi_gbl_permanent_mmap);
  918.  
  919. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  920.                             acpi_get_table_with_size(acpi_string signature,
  921.                                                      u32 instance,
  922.                                                      struct acpi_table_header
  923.                                                      **out_table,
  924.                                                      acpi_size *tbl_size))
  925.  
  926. ACPI_EXTERNAL_RETURN_STATUS(acpi_status
  927.                             acpi_get_data_full(acpi_handle object,
  928.                                                acpi_object_handler handler,
  929.                                                void **data,
  930.                                                void (*callback)(void *)))
  931.  
  932. void acpi_set_debugger_thread_id(acpi_thread_id thread_id);
  933.  
  934. #endif                          /* __ACXFACE_H__ */
  935.