Subversion Repositories Kolibri OS

Rev

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

  1. /******************************************************************************
  2.  *
  3.  * Name: acutils.h -- prototypes for the common (subsystem-wide) procedures
  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 _ACUTILS_H
  45. #define _ACUTILS_H
  46.  
  47. extern const u8 acpi_gbl_resource_aml_sizes[];
  48. extern const u8 acpi_gbl_resource_aml_serial_bus_sizes[];
  49.  
  50. /* Strings used by the disassembler and debugger resource dump routines */
  51.  
  52. #if defined(ACPI_DEBUG_OUTPUT) || defined (ACPI_DISASSEMBLER) || defined (ACPI_DEBUGGER)
  53.  
  54. extern const char *acpi_gbl_bm_decode[];
  55. extern const char *acpi_gbl_config_decode[];
  56. extern const char *acpi_gbl_consume_decode[];
  57. extern const char *acpi_gbl_dec_decode[];
  58. extern const char *acpi_gbl_he_decode[];
  59. extern const char *acpi_gbl_io_decode[];
  60. extern const char *acpi_gbl_ll_decode[];
  61. extern const char *acpi_gbl_max_decode[];
  62. extern const char *acpi_gbl_mem_decode[];
  63. extern const char *acpi_gbl_min_decode[];
  64. extern const char *acpi_gbl_mtp_decode[];
  65. extern const char *acpi_gbl_rng_decode[];
  66. extern const char *acpi_gbl_rw_decode[];
  67. extern const char *acpi_gbl_shr_decode[];
  68. extern const char *acpi_gbl_siz_decode[];
  69. extern const char *acpi_gbl_trs_decode[];
  70. extern const char *acpi_gbl_ttp_decode[];
  71. extern const char *acpi_gbl_typ_decode[];
  72. extern const char *acpi_gbl_ppc_decode[];
  73. extern const char *acpi_gbl_ior_decode[];
  74. extern const char *acpi_gbl_dts_decode[];
  75. extern const char *acpi_gbl_ct_decode[];
  76. extern const char *acpi_gbl_sbt_decode[];
  77. extern const char *acpi_gbl_am_decode[];
  78. extern const char *acpi_gbl_sm_decode[];
  79. extern const char *acpi_gbl_wm_decode[];
  80. extern const char *acpi_gbl_cph_decode[];
  81. extern const char *acpi_gbl_cpo_decode[];
  82. extern const char *acpi_gbl_dp_decode[];
  83. extern const char *acpi_gbl_ed_decode[];
  84. extern const char *acpi_gbl_bpb_decode[];
  85. extern const char *acpi_gbl_sb_decode[];
  86. extern const char *acpi_gbl_fc_decode[];
  87. extern const char *acpi_gbl_pt_decode[];
  88. #endif
  89.  
  90. /*
  91.  * For the iASL compiler case, the output is redirected to stderr so that
  92.  * any of the various ACPI errors and warnings do not appear in the output
  93.  * files, for either the compiler or disassembler portions of the tool.
  94.  */
  95. #ifdef ACPI_ASL_COMPILER
  96.  
  97. #include <stdio.h>
  98.  
  99. #define ACPI_MSG_REDIRECT_BEGIN \
  100.         FILE                            *output_file = acpi_gbl_output_file; \
  101.         acpi_os_redirect_output (stderr);
  102.  
  103. #define ACPI_MSG_REDIRECT_END \
  104.         acpi_os_redirect_output (output_file);
  105.  
  106. #else
  107. /*
  108.  * non-iASL case - no redirection, nothing to do
  109.  */
  110. #define ACPI_MSG_REDIRECT_BEGIN
  111. #define ACPI_MSG_REDIRECT_END
  112. #endif
  113.  
  114. /*
  115.  * Common error message prefixes
  116.  */
  117. #define ACPI_MSG_ERROR          "ACPI Error: "
  118. #define ACPI_MSG_EXCEPTION      "ACPI Exception: "
  119. #define ACPI_MSG_WARNING        "ACPI Warning: "
  120. #define ACPI_MSG_INFO           "ACPI: "
  121.  
  122. #define ACPI_MSG_BIOS_ERROR     "ACPI BIOS Error (bug): "
  123. #define ACPI_MSG_BIOS_WARNING   "ACPI BIOS Warning (bug): "
  124.  
  125. /*
  126.  * Common message suffix
  127.  */
  128. #define ACPI_MSG_SUFFIX \
  129.         acpi_os_printf (" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, module_name, line_number)
  130.  
  131. /* Types for Resource descriptor entries */
  132.  
  133. #define ACPI_INVALID_RESOURCE           0
  134. #define ACPI_FIXED_LENGTH               1
  135. #define ACPI_VARIABLE_LENGTH            2
  136. #define ACPI_SMALL_VARIABLE_LENGTH      3
  137.  
  138. typedef
  139. acpi_status(*acpi_walk_aml_callback) (u8 *aml,
  140.                                       u32 length,
  141.                                       u32 offset,
  142.                                       u8 resource_index, void **context);
  143.  
  144. typedef
  145. acpi_status(*acpi_pkg_callback) (u8 object_type,
  146.                                  union acpi_operand_object *source_object,
  147.                                  union acpi_generic_state * state,
  148.                                  void *context);
  149.  
  150. struct acpi_pkg_info {
  151.         u8 *free_space;
  152.         acpi_size length;
  153.         u32 object_space;
  154.         u32 num_packages;
  155. };
  156.  
  157. /* Object reference counts */
  158.  
  159. #define REF_INCREMENT       (u16) 0
  160. #define REF_DECREMENT       (u16) 1
  161.  
  162. /* acpi_ut_dump_buffer */
  163.  
  164. #define DB_BYTE_DISPLAY     1
  165. #define DB_WORD_DISPLAY     2
  166. #define DB_DWORD_DISPLAY    4
  167. #define DB_QWORD_DISPLAY    8
  168.  
  169. /*
  170.  * utnonansi - Non-ANSI C library functions
  171.  */
  172. void acpi_ut_strupr(char *src_string);
  173.  
  174. void acpi_ut_strlwr(char *src_string);
  175.  
  176. int acpi_ut_stricmp(char *string1, char *string2);
  177.  
  178. acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer);
  179.  
  180. /*
  181.  * utglobal - Global data structures and procedures
  182.  */
  183. acpi_status acpi_ut_init_globals(void);
  184.  
  185. #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
  186.  
  187. char *acpi_ut_get_mutex_name(u32 mutex_id);
  188.  
  189. const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type);
  190. #endif
  191.  
  192. char *acpi_ut_get_type_name(acpi_object_type type);
  193.  
  194. char *acpi_ut_get_node_name(void *object);
  195.  
  196. char *acpi_ut_get_descriptor_name(void *object);
  197.  
  198. const char *acpi_ut_get_reference_name(union acpi_operand_object *object);
  199.  
  200. char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc);
  201.  
  202. char *acpi_ut_get_region_name(u8 space_id);
  203.  
  204. char *acpi_ut_get_event_name(u32 event_id);
  205.  
  206. char acpi_ut_hex_to_ascii_char(u64 integer, u32 position);
  207.  
  208. u8 acpi_ut_ascii_char_to_hex(int hex_char);
  209.  
  210. u8 acpi_ut_valid_object_type(acpi_object_type type);
  211.  
  212. /*
  213.  * utinit - miscellaneous initialization and shutdown
  214.  */
  215. acpi_status acpi_ut_hardware_initialize(void);
  216.  
  217. void acpi_ut_subsystem_shutdown(void);
  218.  
  219. /*
  220.  * utcopy - Object construction and conversion interfaces
  221.  */
  222. acpi_status
  223. acpi_ut_build_simple_object(union acpi_operand_object *obj,
  224.                             union acpi_object *user_obj,
  225.                             u8 *data_space, u32 *buffer_space_used);
  226.  
  227. acpi_status
  228. acpi_ut_build_package_object(union acpi_operand_object *obj,
  229.                              u8 *buffer, u32 *space_used);
  230.  
  231. acpi_status
  232. acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *obj,
  233.                                 struct acpi_buffer *ret_buffer);
  234.  
  235. acpi_status
  236. acpi_ut_copy_eobject_to_iobject(union acpi_object *obj,
  237.                                 union acpi_operand_object **internal_obj);
  238.  
  239. acpi_status
  240. acpi_ut_copy_isimple_to_isimple(union acpi_operand_object *source_obj,
  241.                                 union acpi_operand_object *dest_obj);
  242.  
  243. acpi_status
  244. acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
  245.                                 union acpi_operand_object **dest_desc,
  246.                                 struct acpi_walk_state *walk_state);
  247.  
  248. /*
  249.  * utcreate - Object creation
  250.  */
  251. acpi_status
  252. acpi_ut_update_object_reference(union acpi_operand_object *object, u16 action);
  253.  
  254. /*
  255.  * utdebug - Debug interfaces
  256.  */
  257. void acpi_ut_init_stack_ptr_trace(void);
  258.  
  259. void acpi_ut_track_stack_ptr(void);
  260.  
  261. void
  262. acpi_ut_trace(u32 line_number,
  263.               const char *function_name,
  264.               const char *module_name, u32 component_id);
  265.  
  266. void
  267. acpi_ut_trace_ptr(u32 line_number,
  268.                   const char *function_name,
  269.                   const char *module_name, u32 component_id, void *pointer);
  270.  
  271. void
  272. acpi_ut_trace_u32(u32 line_number,
  273.                   const char *function_name,
  274.                   const char *module_name, u32 component_id, u32 integer);
  275.  
  276. void
  277. acpi_ut_trace_str(u32 line_number,
  278.                   const char *function_name,
  279.                   const char *module_name, u32 component_id, char *string);
  280.  
  281. void
  282. acpi_ut_exit(u32 line_number,
  283.              const char *function_name,
  284.              const char *module_name, u32 component_id);
  285.  
  286. void
  287. acpi_ut_status_exit(u32 line_number,
  288.                     const char *function_name,
  289.                     const char *module_name,
  290.                     u32 component_id, acpi_status status);
  291.  
  292. void
  293. acpi_ut_value_exit(u32 line_number,
  294.                    const char *function_name,
  295.                    const char *module_name, u32 component_id, u64 value);
  296.  
  297. void
  298. acpi_ut_ptr_exit(u32 line_number,
  299.                  const char *function_name,
  300.                  const char *module_name, u32 component_id, u8 *ptr);
  301.  
  302. void
  303. acpi_ut_debug_dump_buffer(u8 *buffer, u32 count, u32 display, u32 component_id);
  304.  
  305. void acpi_ut_dump_buffer(u8 *buffer, u32 count, u32 display, u32 offset);
  306.  
  307. #ifdef ACPI_APPLICATION
  308. void
  309. acpi_ut_dump_buffer_to_file(ACPI_FILE file,
  310.                             u8 *buffer,
  311.                             u32 count, u32 display, u32 base_offset);
  312. #endif
  313.  
  314. void acpi_ut_report_error(char *module_name, u32 line_number);
  315.  
  316. void acpi_ut_report_info(char *module_name, u32 line_number);
  317.  
  318. void acpi_ut_report_warning(char *module_name, u32 line_number);
  319.  
  320. /*
  321.  * utdelete - Object deletion and reference counts
  322.  */
  323. void acpi_ut_add_reference(union acpi_operand_object *object);
  324.  
  325. void acpi_ut_remove_reference(union acpi_operand_object *object);
  326.  
  327. void acpi_ut_delete_internal_package_object(union acpi_operand_object *object);
  328.  
  329. void acpi_ut_delete_internal_simple_object(union acpi_operand_object *object);
  330.  
  331. void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list);
  332.  
  333. /*
  334.  * uteval - object evaluation
  335.  */
  336. acpi_status
  337. acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
  338.                         char *path,
  339.                         u32 expected_return_btypes,
  340.                         union acpi_operand_object **return_desc);
  341.  
  342. acpi_status
  343. acpi_ut_evaluate_numeric_object(char *object_name,
  344.                                 struct acpi_namespace_node *device_node,
  345.                                 u64 *value);
  346.  
  347. acpi_status
  348. acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 *status_flags);
  349.  
  350. acpi_status
  351. acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
  352.                               const char **method_names,
  353.                               u8 method_count, u8 *out_values);
  354.  
  355. /*
  356.  * utfileio - file operations
  357.  */
  358. #ifdef ACPI_APPLICATION
  359. acpi_status
  360. acpi_ut_read_table_from_file(char *filename, struct acpi_table_header **table);
  361. #endif
  362.  
  363. /*
  364.  * utids - device ID support
  365.  */
  366. acpi_status
  367. acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
  368.                     struct acpi_pnp_device_id ** return_id);
  369.  
  370. acpi_status
  371. acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
  372.                     struct acpi_pnp_device_id ** return_id);
  373.  
  374. acpi_status
  375. acpi_ut_execute_SUB(struct acpi_namespace_node *device_node,
  376.                     struct acpi_pnp_device_id **return_id);
  377.  
  378. acpi_status
  379. acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
  380.                     struct acpi_pnp_device_id_list ** return_cid_list);
  381.  
  382. acpi_status
  383. acpi_ut_execute_CLS(struct acpi_namespace_node *device_node,
  384.                     struct acpi_pnp_device_id **return_id);
  385.  
  386. /*
  387.  * utlock - reader/writer locks
  388.  */
  389. acpi_status acpi_ut_create_rw_lock(struct acpi_rw_lock *lock);
  390.  
  391. void acpi_ut_delete_rw_lock(struct acpi_rw_lock *lock);
  392.  
  393. acpi_status acpi_ut_acquire_read_lock(struct acpi_rw_lock *lock);
  394.  
  395. acpi_status acpi_ut_release_read_lock(struct acpi_rw_lock *lock);
  396.  
  397. acpi_status acpi_ut_acquire_write_lock(struct acpi_rw_lock *lock);
  398.  
  399. void acpi_ut_release_write_lock(struct acpi_rw_lock *lock);
  400.  
  401. /*
  402.  * utobject - internal object create/delete/cache routines
  403.  */
  404. union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
  405.                                                               *module_name,
  406.                                                               u32 line_number,
  407.                                                               u32 component_id,
  408.                                                               acpi_object_type
  409.                                                               type);
  410.  
  411. void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
  412.                                        u32 line_number, u32 component_id);
  413.  
  414. #define acpi_ut_create_internal_object(t) acpi_ut_create_internal_object_dbg (_acpi_module_name,__LINE__,_COMPONENT,t)
  415. #define acpi_ut_allocate_object_desc()  acpi_ut_allocate_object_desc_dbg (_acpi_module_name,__LINE__,_COMPONENT)
  416.  
  417. void acpi_ut_delete_object_desc(union acpi_operand_object *object);
  418.  
  419. u8 acpi_ut_valid_internal_object(void *object);
  420.  
  421. union acpi_operand_object *acpi_ut_create_package_object(u32 count);
  422.  
  423. union acpi_operand_object *acpi_ut_create_integer_object(u64 value);
  424.  
  425. union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size);
  426.  
  427. union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size);
  428.  
  429. acpi_status
  430. acpi_ut_get_object_size(union acpi_operand_object *obj, acpi_size * obj_length);
  431.  
  432. /*
  433.  * utosi - Support for the _OSI predefined control method
  434.  */
  435. acpi_status acpi_ut_initialize_interfaces(void);
  436.  
  437. acpi_status acpi_ut_interface_terminate(void);
  438.  
  439. acpi_status acpi_ut_install_interface(acpi_string interface_name);
  440.  
  441. acpi_status acpi_ut_remove_interface(acpi_string interface_name);
  442.  
  443. acpi_status acpi_ut_update_interfaces(u8 action);
  444.  
  445. struct acpi_interface_info *acpi_ut_get_interface(acpi_string interface_name);
  446.  
  447. acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state);
  448.  
  449. /*
  450.  * utpredef - support for predefined names
  451.  */
  452. const union acpi_predefined_info *acpi_ut_get_next_predefined_method(const union
  453.                                                                      acpi_predefined_info
  454.                                                                      *this_name);
  455.  
  456. const union acpi_predefined_info *acpi_ut_match_predefined_method(char *name);
  457.  
  458. void acpi_ut_get_expected_return_types(char *buffer, u32 expected_btypes);
  459.  
  460. #if (defined ACPI_ASL_COMPILER || defined ACPI_HELP_APP)
  461. const union acpi_predefined_info *acpi_ut_match_resource_name(char *name);
  462.  
  463. void
  464. acpi_ut_display_predefined_method(char *buffer,
  465.                                   const union acpi_predefined_info *this_name,
  466.                                   u8 multi_line);
  467.  
  468. u32 acpi_ut_get_resource_bit_width(char *buffer, u16 types);
  469. #endif
  470.  
  471. /*
  472.  * utstate - Generic state creation/cache routines
  473.  */
  474. void
  475. acpi_ut_push_generic_state(union acpi_generic_state **list_head,
  476.                            union acpi_generic_state *state);
  477.  
  478. union acpi_generic_state *acpi_ut_pop_generic_state(union acpi_generic_state
  479.                                                     **list_head);
  480.  
  481. union acpi_generic_state *acpi_ut_create_generic_state(void);
  482.  
  483. struct acpi_thread_state *acpi_ut_create_thread_state(void);
  484.  
  485. union acpi_generic_state *acpi_ut_create_update_state(union acpi_operand_object
  486.                                                       *object, u16 action);
  487.  
  488. union acpi_generic_state *acpi_ut_create_pkg_state(void *internal_object,
  489.                                                    void *external_object,
  490.                                                    u16 index);
  491.  
  492. acpi_status
  493. acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
  494.                                      u16 action,
  495.                                      union acpi_generic_state **state_list);
  496.  
  497. union acpi_generic_state *acpi_ut_create_control_state(void);
  498.  
  499. void acpi_ut_delete_generic_state(union acpi_generic_state *state);
  500.  
  501. /*
  502.  * utmath
  503.  */
  504. acpi_status
  505. acpi_ut_divide(u64 in_dividend,
  506.                u64 in_divisor, u64 *out_quotient, u64 *out_remainder);
  507.  
  508. acpi_status
  509. acpi_ut_short_divide(u64 in_dividend,
  510.                      u32 divisor, u64 *out_quotient, u32 *out_remainder);
  511.  
  512. /*
  513.  * utmisc
  514.  */
  515. const struct acpi_exception_info *acpi_ut_validate_exception(acpi_status
  516.                                                              status);
  517.  
  518. u8 acpi_ut_is_pci_root_bridge(char *id);
  519.  
  520. #if (defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP || defined ACPI_NAMES_APP)
  521. u8 acpi_ut_is_aml_table(struct acpi_table_header *table);
  522. #endif
  523.  
  524. acpi_status
  525. acpi_ut_walk_package_tree(union acpi_operand_object *source_object,
  526.                           void *target_object,
  527.                           acpi_pkg_callback walk_callback, void *context);
  528.  
  529. /* Values for Base above (16=Hex, 10=Decimal) */
  530.  
  531. #define ACPI_ANY_BASE        0
  532.  
  533. u32 acpi_ut_dword_byte_swap(u32 value);
  534.  
  535. void acpi_ut_set_integer_width(u8 revision);
  536.  
  537. #ifdef ACPI_DEBUG_OUTPUT
  538. void
  539. acpi_ut_display_init_pathname(u8 type,
  540.                               struct acpi_namespace_node *obj_handle,
  541.                               char *path);
  542. #endif
  543.  
  544. /*
  545.  * utownerid - Support for Table/Method Owner IDs
  546.  */
  547. acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id);
  548.  
  549. void acpi_ut_release_owner_id(acpi_owner_id * owner_id);
  550.  
  551. /*
  552.  * utresrc
  553.  */
  554. acpi_status
  555. acpi_ut_walk_aml_resources(struct acpi_walk_state *walk_state,
  556.                            u8 *aml,
  557.                            acpi_size aml_length,
  558.                            acpi_walk_aml_callback user_function,
  559.                            void **context);
  560.  
  561. acpi_status
  562. acpi_ut_validate_resource(struct acpi_walk_state *walk_state,
  563.                           void *aml, u8 *return_index);
  564.  
  565. u32 acpi_ut_get_descriptor_length(void *aml);
  566.  
  567. u16 acpi_ut_get_resource_length(void *aml);
  568.  
  569. u8 acpi_ut_get_resource_header_length(void *aml);
  570.  
  571. u8 acpi_ut_get_resource_type(void *aml);
  572.  
  573. acpi_status
  574. acpi_ut_get_resource_end_tag(union acpi_operand_object *obj_desc, u8 **end_tag);
  575.  
  576. /*
  577.  * utstring - String and character utilities
  578.  */
  579. void acpi_ut_print_string(char *string, u16 max_length);
  580.  
  581. #if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP
  582. void ut_convert_backslashes(char *pathname);
  583. #endif
  584.  
  585. u8 acpi_ut_valid_acpi_name(char *name);
  586.  
  587. u8 acpi_ut_valid_acpi_char(char character, u32 position);
  588.  
  589. void acpi_ut_repair_name(char *name);
  590.  
  591. #if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
  592. u8 acpi_ut_safe_strcpy(char *dest, acpi_size dest_size, char *source);
  593.  
  594. u8 acpi_ut_safe_strcat(char *dest, acpi_size dest_size, char *source);
  595.  
  596. u8
  597. acpi_ut_safe_strncat(char *dest,
  598.                      acpi_size dest_size,
  599.                      char *source, acpi_size max_transfer_length);
  600. #endif
  601.  
  602. /*
  603.  * utmutex - mutex support
  604.  */
  605. acpi_status acpi_ut_mutex_initialize(void);
  606.  
  607. void acpi_ut_mutex_terminate(void);
  608.  
  609. acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id);
  610.  
  611. acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id);
  612.  
  613. /*
  614.  * utalloc - memory allocation and object caching
  615.  */
  616. acpi_status acpi_ut_create_caches(void);
  617.  
  618. acpi_status acpi_ut_delete_caches(void);
  619.  
  620. acpi_status acpi_ut_validate_buffer(struct acpi_buffer *buffer);
  621.  
  622. acpi_status
  623. acpi_ut_initialize_buffer(struct acpi_buffer *buffer,
  624.                           acpi_size required_length);
  625.  
  626. #ifdef ACPI_DBG_TRACK_ALLOCATIONS
  627. void *acpi_ut_allocate_and_track(acpi_size size,
  628.                                  u32 component, const char *module, u32 line);
  629.  
  630. void *acpi_ut_allocate_zeroed_and_track(acpi_size size,
  631.                                         u32 component,
  632.                                         const char *module, u32 line);
  633.  
  634. void
  635. acpi_ut_free_and_track(void *address,
  636.                        u32 component, const char *module, u32 line);
  637.  
  638. void acpi_ut_dump_allocation_info(void);
  639.  
  640. void acpi_ut_dump_allocations(u32 component, const char *module);
  641.  
  642. acpi_status
  643. acpi_ut_create_list(char *list_name,
  644.                     u16 object_size, struct acpi_memory_list **return_cache);
  645.  
  646. #endif                          /* ACPI_DBG_TRACK_ALLOCATIONS */
  647.  
  648. /*
  649.  * utaddress - address range check
  650.  */
  651. acpi_status
  652. acpi_ut_add_address_range(acpi_adr_space_type space_id,
  653.                           acpi_physical_address address,
  654.                           u32 length, struct acpi_namespace_node *region_node);
  655.  
  656. void
  657. acpi_ut_remove_address_range(acpi_adr_space_type space_id,
  658.                              struct acpi_namespace_node *region_node);
  659.  
  660. u32
  661. acpi_ut_check_address_range(acpi_adr_space_type space_id,
  662.                             acpi_physical_address address, u32 length, u8 warn);
  663.  
  664. void acpi_ut_delete_address_lists(void);
  665.  
  666. /*
  667.  * utxferror - various error/warning output functions
  668.  */
  669. void ACPI_INTERNAL_VAR_XFACE
  670. acpi_ut_predefined_warning(const char *module_name,
  671.                            u32 line_number,
  672.                            char *pathname,
  673.                            u8 node_flags, const char *format, ...);
  674.  
  675. void ACPI_INTERNAL_VAR_XFACE
  676. acpi_ut_predefined_info(const char *module_name,
  677.                         u32 line_number,
  678.                         char *pathname, u8 node_flags, const char *format, ...);
  679.  
  680. void ACPI_INTERNAL_VAR_XFACE
  681. acpi_ut_predefined_bios_error(const char *module_name,
  682.                               u32 line_number,
  683.                               char *pathname,
  684.                               u8 node_flags, const char *format, ...);
  685.  
  686. void
  687. acpi_ut_namespace_error(const char *module_name,
  688.                         u32 line_number,
  689.                         const char *internal_name, acpi_status lookup_status);
  690.  
  691. void
  692. acpi_ut_method_error(const char *module_name,
  693.                      u32 line_number,
  694.                      const char *message,
  695.                      struct acpi_namespace_node *node,
  696.                      const char *path, acpi_status lookup_status);
  697.  
  698. /*
  699.  * Utility functions for ACPI names and IDs
  700.  */
  701. const struct ah_predefined_name *acpi_ah_match_predefined_name(char *nameseg);
  702.  
  703. const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
  704.  
  705. const char *acpi_ah_match_uuid(u8 *data);
  706.  
  707. /*
  708.  * utprint - printf/vprintf output functions
  709.  */
  710. const char *acpi_ut_scan_number(const char *string, u64 *number_ptr);
  711.  
  712. const char *acpi_ut_print_number(char *string, u64 number);
  713.  
  714. int
  715. acpi_ut_vsnprintf(char *string,
  716.                   acpi_size size, const char *format, va_list args);
  717.  
  718. int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...);
  719.  
  720. #ifdef ACPI_APPLICATION
  721. int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args);
  722.  
  723. int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...);
  724. #endif
  725.  
  726. /*
  727.  * utuuid -- UUID support functions
  728.  */
  729. #if (defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP || defined ACPI_HELP_APP)
  730. void acpi_ut_convert_string_to_uuid(char *in_string, u8 *uuid_buffer);
  731. #endif
  732.  
  733. #endif                          /* _ACUTILS_H */
  734.