1 /* SPDX-License-Identifier: BSD-3-Clause OR GP <<
2 /********************************************* 1 /******************************************************************************
3 * 2 *
4 * Name: acpixf.h - External interfaces to the 3 * Name: acpixf.h - External interfaces to the ACPI subsystem
5 * 4 *
6 * Copyright (C) 2000 - 2023, Intel Corp. <<
7 * <<
8 ********************************************* 5 *****************************************************************************/
9 6
>> 7 /*
>> 8 * Copyright (C) 2000 - 2013, 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
10 #ifndef __ACXFACE_H__ 44 #ifndef __ACXFACE_H__
11 #define __ACXFACE_H__ 45 #define __ACXFACE_H__
12 46
13 /* Current ACPICA subsystem version in YYYYMMD 47 /* Current ACPICA subsystem version in YYYYMMDD format */
14 48
15 #define ACPI_CA_VERSION 0x2024 !! 49 #define ACPI_CA_VERSION 0x20130328
16 50
17 #include <acpi/acconfig.h> 51 #include <acpi/acconfig.h>
18 #include <acpi/actypes.h> 52 #include <acpi/actypes.h>
19 #include <acpi/actbl.h> 53 #include <acpi/actbl.h>
20 #include <acpi/acbuffer.h> 54 #include <acpi/acbuffer.h>
21 55
22 /********************************************* !! 56 extern u8 acpi_gbl_permanent_mmap;
23 * <<
24 * Macros used for ACPICA globals and configur <<
25 * <<
26 ********************************************* <<
27 <<
28 /* <<
29 * Ensure that global variables are defined an <<
30 * <<
31 * The use of these macros allows for a single <<
32 * in order to simplify maintenance of the cod <<
33 */ <<
34 #ifdef DEFINE_ACPI_GLOBALS <<
35 #define ACPI_GLOBAL(type,name) \ <<
36 extern type name; \ <<
37 type name <<
38 <<
39 #define ACPI_INIT_GLOBAL(type,name,value) \ <<
40 type name=value <<
41 <<
42 #else <<
43 #ifndef ACPI_GLOBAL <<
44 #define ACPI_GLOBAL(type,name) \ <<
45 extern type name <<
46 #endif <<
47 <<
48 #ifndef ACPI_INIT_GLOBAL <<
49 #define ACPI_INIT_GLOBAL(type,name,value) \ <<
50 extern type name <<
51 #endif <<
52 #endif <<
53 <<
54 /* <<
55 * These macros configure the various ACPICA i <<
56 * useful for generating stub inline functions <<
57 * configured out of the current kernel or ACP <<
58 */ <<
59 #ifndef ACPI_EXTERNAL_RETURN_STATUS <<
60 #define ACPI_EXTERNAL_RETURN_STATUS(prototype) <<
61 prototype; <<
62 #endif <<
63 <<
64 #ifndef ACPI_EXTERNAL_RETURN_OK <<
65 #define ACPI_EXTERNAL_RETURN_OK(prototype) \ <<
66 prototype; <<
67 #endif <<
68 <<
69 #ifndef ACPI_EXTERNAL_RETURN_VOID <<
70 #define ACPI_EXTERNAL_RETURN_VOID(prototype) \ <<
71 prototype; <<
72 #endif <<
73 <<
74 #ifndef ACPI_EXTERNAL_RETURN_UINT32 <<
75 #define ACPI_EXTERNAL_RETURN_UINT32(prototype) <<
76 prototype; <<
77 #endif <<
78 <<
79 #ifndef ACPI_EXTERNAL_RETURN_PTR <<
80 #define ACPI_EXTERNAL_RETURN_PTR(prototype) \ <<
81 prototype; <<
82 #endif <<
83 <<
84 /********************************************* <<
85 * <<
86 * Public globals and runtime configuration op <<
87 * <<
88 ********************************************* <<
89 <<
90 /* <<
91 * Enable "slack mode" of the AML interpreter? <<
92 * interpreter strictly follows the ACPI speci <<
93 * allows the interpreter to ignore certain er <<
94 * <<
95 * Currently, these features are enabled by th <<
96 * <<
97 * 1) Allow "implicit return" of last value in <<
98 * 2) Allow access beyond the end of an operat <<
99 * 3) Allow access to uninitialized locals/arg <<
100 * 4) Allow ANY object type to be a source ope <<
101 * 5) Allow unresolved references (invalid tar <<
102 * 6) Enable warning messages for behavior tha <<
103 */ <<
104 ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_interpret <<
105 <<
106 /* <<
107 * Automatically serialize all methods that cr <<
108 * is TRUE, meaning that all non_serialized me <<
109 * table load time to determine those that cre <<
110 * that create named objects are marked Serial <<
111 * possible run-time problems if they are ente <<
112 */ <<
113 ACPI_INIT_GLOBAL(u8, acpi_gbl_auto_serialize_m <<
114 <<
115 /* <<
116 * Create the predefined _OSI method in the na <<
117 * because ACPICA is fully compatible with oth <<
118 * Changing this will revert ACPICA (and machi <<
119 */ <<
120 ACPI_INIT_GLOBAL(u8, acpi_gbl_create_osi_metho <<
121 <<
122 /* <<
123 * Optionally use default values for the ACPI <<
124 * TRUE to use the defaults, if an FADT contai <<
125 */ <<
126 ACPI_INIT_GLOBAL(u8, acpi_gbl_use_default_regi <<
127 57
128 /* 58 /*
129 * Whether or not to validate (map) an entire !! 59 * Globals that are publically available
130 * checksum/duplication in early stage before <<
131 * allow early table validation before install <<
132 * Note that enabling this option causes error <<
133 * during early initialization stages. Default <<
134 * validation. <<
135 */ 60 */
136 ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_table_val !! 61 extern u32 acpi_current_gpe_count;
137 !! 62 extern struct acpi_table_fadt acpi_gbl_FADT;
138 /* !! 63 extern u8 acpi_gbl_system_awake_and_running;
139 * Optionally enable output from the AML Debug !! 64 extern u8 acpi_gbl_reduced_hardware; /* ACPI 5.0 */
140 */ <<
141 ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_aml_debug <<
142 <<
143 /* <<
144 * Optionally copy the entire DSDT to local me <<
145 * mapping it.) There are some BIOSs that corr <<
146 * DSDT, creating the need for this option. De <<
147 * the DSDT. <<
148 */ <<
149 ACPI_INIT_GLOBAL(u8, acpi_gbl_copy_dsdt_locall <<
150 <<
151 /* <<
152 * Optionally ignore an XSDT if present and us <<
153 * Although the ACPI specification requires th <<
154 * of the RSDT, the XSDT has been found to be <<
155 * some machines. Default behavior is to use t <<
156 */ <<
157 ACPI_INIT_GLOBAL(u8, acpi_gbl_do_not_use_xsdt, <<
158 <<
159 /* <<
160 * Optionally use 32-bit FADT addresses if and <<
161 * (address mismatch) between the 32-bit and 6 <<
162 * address. Although ACPICA adheres to the ACP <<
163 * requires the use of the corresponding 64-bi <<
164 * some machines have been found to have a cor <<
165 * address. Default is FALSE, do not favor the <<
166 */ <<
167 ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_a <<
168 <<
169 /* <<
170 * Optionally use 32-bit FACS table addresses. <<
171 * It is reported that some platforms fail to <<
172 * if 64-bit FACS table address is selected: <<
173 * https://bugzilla.kernel.org/show_bug.cgi?id <<
174 * Default is TRUE, favor the 32-bit addresses <<
175 */ <<
176 ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_facs_a <<
177 <<
178 /* <<
179 * Optionally truncate I/O addresses to 16 bit <<
180 * with other ACPI implementations. NOTE: Duri <<
181 * this value is set to TRUE if any Windows OS <<
182 * requested by the BIOS. <<
183 */ <<
184 ACPI_INIT_GLOBAL(u8, acpi_gbl_truncate_io_addr <<
185 <<
186 /* <<
187 * Disable runtime checking and repair of valu <<
188 * Use only if the repair is causing a problem <<
189 */ <<
190 ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_auto_rep <<
191 <<
192 /* <<
193 * Optionally do not install any SSDTs from th <<
194 * This can be useful for debugging ACPI probl <<
195 */ <<
196 ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_ssdt_tab <<
197 <<
198 /* <<
199 * Optionally enable runtime namespace overrid <<
200 */ <<
201 ACPI_INIT_GLOBAL(u8, acpi_gbl_runtime_namespac <<
202 <<
203 /* <<
204 * We keep track of the latest version of Wind <<
205 * the BIOS. ACPI 5.0. <<
206 */ <<
207 ACPI_INIT_GLOBAL(u8, acpi_gbl_osi_data, 0); <<
208 <<
209 /* <<
210 * ACPI 5.0 introduces the concept of a "reduc <<
211 * that the ACPI hardware is no longer require <<
212 * a reduced HW machine, and that flag is dupl <<
213 */ <<
214 ACPI_INIT_GLOBAL(u8, acpi_gbl_reduced_hardware <<
215 <<
216 /* <<
217 * Maximum timeout for While() loop iterations <<
218 * This mechanism is intended to prevent infin <<
219 * execution within a host kernel. <<
220 */ <<
221 ACPI_INIT_GLOBAL(u32, acpi_gbl_max_loop_iterat <<
222 <<
223 /* <<
224 * Optionally ignore AE_NOT_FOUND errors from <<
225 * during DSDT/SSDT table loading. This reduce <<
226 * whose firmware is carrying around a bunch o <<
227 * refer to non-existent named objects. Howeve <<
228 * use such a package, the unresolved element( <<
229 * elements. <<
230 */ <<
231 ACPI_INIT_GLOBAL(u8, acpi_gbl_ignore_package_r <<
232 <<
233 /* <<
234 * This mechanism is used to trace a specified <<
235 * traced each time it is executed. <<
236 */ <<
237 ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_flags, 0) <<
238 ACPI_INIT_GLOBAL(const char *, acpi_gbl_trace_ <<
239 ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_dbg_level <<
240 ACPI_INIT_GLOBAL(u32, acpi_gbl_trace_dbg_layer <<
241 <<
242 /* <<
243 * Runtime configuration of debug output contr <<
244 * switches statically initialized so they are <<
245 * is entered. <<
246 */ <<
247 ACPI_INIT_GLOBAL(u32, acpi_dbg_level, ACPI_DEB <<
248 ACPI_INIT_GLOBAL(u32, acpi_dbg_layer, 0); <<
249 <<
250 /* Optionally enable timer output with Debug O <<
251 65
252 ACPI_INIT_GLOBAL(u8, acpi_gbl_display_debug_ti !! 66 /* Runtime configuration of debug print levels */
253 67
254 /* !! 68 extern u32 acpi_dbg_level;
255 * Debugger command handshake globals. Host OS !! 69 extern u32 acpi_dbg_layer;
256 * variables to implement their own command ha <<
257 */ <<
258 #ifdef ACPI_DEBUGGER <<
259 ACPI_INIT_GLOBAL(u8, acpi_gbl_method_executing <<
260 ACPI_GLOBAL(char, acpi_gbl_db_line_buf[ACPI_DB <<
261 #endif <<
262 70
263 /* !! 71 /* ACPICA runtime options */
264 * Other miscellaneous globals <<
265 */ <<
266 ACPI_GLOBAL(struct acpi_table_fadt, acpi_gbl_F <<
267 ACPI_GLOBAL(u32, acpi_current_gpe_count); <<
268 ACPI_GLOBAL(u8, acpi_gbl_system_awake_and_runn <<
269 72
270 /********************************************* !! 73 extern u8 acpi_gbl_enable_interpreter_slack;
271 * !! 74 extern u8 acpi_gbl_all_methods_serialized;
272 * ACPICA public interface configuration. !! 75 extern u8 acpi_gbl_create_osi_method;
273 * !! 76 extern u8 acpi_gbl_use_default_register_widths;
274 * Interfaces that are configured out of the A !! 77 extern acpi_name acpi_gbl_trace_method_name;
275 * by inlined stubs by default. !! 78 extern u32 acpi_gbl_trace_flags;
276 * !! 79 extern bool acpi_gbl_enable_aml_debug_object;
277 ********************************************* !! 80 extern u8 acpi_gbl_copy_dsdt_locally;
>> 81 extern u8 acpi_gbl_truncate_io_addresses;
>> 82 extern u8 acpi_gbl_disable_auto_repair;
278 83
279 /* 84 /*
280 * Hardware-reduced prototypes (default: Not h !! 85 * Hardware-reduced prototypes. All interfaces that use these macros will
281 * !! 86 * be configured out of the ACPICA build if the ACPI_REDUCED_HARDWARE flag
282 * All ACPICA hardware-related interfaces that <<
283 * configured out of the ACPICA build if the A <<
284 * is set to TRUE. 87 * is set to TRUE.
285 * <<
286 * Note: This static build option for reduced <<
287 * reduce ACPICA code size if desired or neces <<
288 * option is not specified, the runtime behavi <<
289 * on the actual FADT reduced hardware flag (H <<
290 * the flag will enable similar behavior -- AC <<
291 * to access any ACPI-relate hardware (SCI, GP <<
292 */ 88 */
293 #if (!ACPI_REDUCED_HARDWARE) 89 #if (!ACPI_REDUCED_HARDWARE)
294 #define ACPI_HW_DEPENDENT_RETURN_STATUS(protot 90 #define ACPI_HW_DEPENDENT_RETURN_STATUS(prototype) \
295 ACPI_EXTERNAL_RETURN_STATUS(prototype) !! 91 prototype;
296 92
297 #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) 93 #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) \
298 ACPI_EXTERNAL_RETURN_OK(prototype) !! 94 prototype;
299 <<
300 #define ACPI_HW_DEPENDENT_RETURN_UINT32(protot <<
301 ACPI_EXTERNAL_RETURN_UINT32(prototype) <<
302 95
303 #define ACPI_HW_DEPENDENT_RETURN_VOID(prototyp 96 #define ACPI_HW_DEPENDENT_RETURN_VOID(prototype) \
304 ACPI_EXTERNAL_RETURN_VOID(prototype) !! 97 prototype;
305 98
306 #else 99 #else
307 #define ACPI_HW_DEPENDENT_RETURN_STATUS(protot 100 #define ACPI_HW_DEPENDENT_RETURN_STATUS(prototype) \
308 static ACPI_INLINE prototype {return(A 101 static ACPI_INLINE prototype {return(AE_NOT_CONFIGURED);}
309 102
310 #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) 103 #define ACPI_HW_DEPENDENT_RETURN_OK(prototype) \
311 static ACPI_INLINE prototype {return(A 104 static ACPI_INLINE prototype {return(AE_OK);}
312 105
313 #define ACPI_HW_DEPENDENT_RETURN_UINT32(protot <<
314 static ACPI_INLINE prototype {return(0 <<
315 <<
316 #define ACPI_HW_DEPENDENT_RETURN_VOID(prototyp 106 #define ACPI_HW_DEPENDENT_RETURN_VOID(prototype) \
317 static ACPI_INLINE prototype {return;} !! 107 static ACPI_INLINE prototype {}
318 108
319 #endif /* !ACPI_REDUC 109 #endif /* !ACPI_REDUCED_HARDWARE */
320 110
>> 111 extern u32 acpi_rsdt_forced;
321 /* 112 /*
322 * Error message prototypes (default: error me !! 113 * Initialization
323 * <<
324 * All interfaces related to error and warning <<
325 * will be configured out of the ACPICA build <<
326 * ACPI_NO_ERROR_MESSAGE flag is defined. <<
327 */ 114 */
328 #ifndef ACPI_NO_ERROR_MESSAGES !! 115 acpi_status
329 #define ACPI_MSG_DEPENDENT_RETURN_VOID(prototy !! 116 acpi_initialize_tables(struct acpi_table_desc *initial_storage,
330 prototype; !! 117 u32 initial_table_count, u8 allow_resize);
331 118
332 #else !! 119 acpi_status __init acpi_initialize_subsystem(void);
333 #define ACPI_MSG_DEPENDENT_RETURN_VOID(prototy <<
334 static ACPI_INLINE prototype {return;} <<
335 120
336 #endif /* ACPI_NO_ERR !! 121 acpi_status acpi_enable_subsystem(u32 flags);
337 122
338 /* !! 123 acpi_status acpi_initialize_objects(u32 flags);
339 * Debugging output prototypes (default: no de <<
340 * <<
341 * All interfaces related to debug output mess <<
342 * will be configured out of the ACPICA build <<
343 * ACPI_DEBUG_OUTPUT flag is defined. <<
344 */ <<
345 #ifdef ACPI_DEBUG_OUTPUT <<
346 #define ACPI_DBG_DEPENDENT_RETURN_VOID(prototy <<
347 prototype; <<
348 124
349 #else !! 125 acpi_status acpi_terminate(void);
350 #define ACPI_DBG_DEPENDENT_RETURN_VOID(prototy <<
351 static ACPI_INLINE prototype {return;} <<
352 <<
353 #endif /* ACPI_DEBUG_ <<
354 126
355 /* 127 /*
356 * Application prototypes !! 128 * Miscellaneous global interfaces
357 * <<
358 * All interfaces used by application will be <<
359 * out of the ACPICA build unless the ACPI_APP <<
360 * flag is defined. <<
361 */ 129 */
362 #ifdef ACPI_APPLICATION !! 130 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enable(void))
363 #define ACPI_APP_DEPENDENT_RETURN_VOID(prototy !! 131 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_disable(void))
364 prototype; !! 132 #ifdef ACPI_FUTURE_USAGE
365 !! 133 acpi_status acpi_subsystem_status(void);
366 #else !! 134 #endif
367 #define ACPI_APP_DEPENDENT_RETURN_VOID(prototy <<
368 static ACPI_INLINE prototype {return;} <<
369 135
370 #endif /* ACPI_APPLIC !! 136 #ifdef ACPI_FUTURE_USAGE
>> 137 acpi_status acpi_get_system_info(struct acpi_buffer *ret_buffer);
>> 138 #endif
371 139
372 /* !! 140 const char *acpi_format_exception(acpi_status exception);
373 * Debugger prototypes <<
374 * <<
375 * All interfaces used by debugger will be con <<
376 * out of the ACPICA build unless the ACPI_DEB <<
377 * flag is defined. <<
378 */ <<
379 #ifdef ACPI_DEBUGGER <<
380 #define ACPI_DBR_DEPENDENT_RETURN_OK(prototype <<
381 ACPI_EXTERNAL_RETURN_OK(prototype) <<
382 141
383 #define ACPI_DBR_DEPENDENT_RETURN_VOID(prototy !! 142 acpi_status acpi_purge_cached_objects(void);
384 ACPI_EXTERNAL_RETURN_VOID(prototype) <<
385 143
386 #else !! 144 acpi_status acpi_install_interface(acpi_string interface_name);
387 #define ACPI_DBR_DEPENDENT_RETURN_OK(prototype <<
388 static ACPI_INLINE prototype {return(A <<
389 145
390 #define ACPI_DBR_DEPENDENT_RETURN_VOID(prototy !! 146 acpi_status acpi_remove_interface(acpi_string interface_name);
391 static ACPI_INLINE prototype {return;} <<
392 147
393 #endif /* ACPI_DEBUGG !! 148 u32
>> 149 acpi_check_address_range(acpi_adr_space_type space_id,
>> 150 acpi_physical_address address,
>> 151 acpi_size length, u8 warn);
394 152
395 /********************************************* !! 153 acpi_status
396 * !! 154 acpi_decode_pld_buffer(u8 *in_buffer,
397 * ACPICA public interface prototypes !! 155 acpi_size length, struct acpi_pld_info **return_buffer);
398 * <<
399 ********************************************* <<
400 156
401 /* 157 /*
402 * Initialization !! 158 * ACPI Memory management
403 */ 159 */
404 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I !! 160 void *acpi_allocate(u32 size);
405 acpi_initialize_ta <<
406 <<
407 <<
408 <<
409 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I <<
410 acpi_initialize_s <<
411 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I <<
412 acpi_enable_subsy <<
413 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I <<
414 acpi_initialize_o <<
415 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I <<
416 acpi_terminate(vo <<
417 161
418 /* !! 162 void *acpi_callocate(u32 size);
419 * Miscellaneous global interfaces <<
420 */ <<
421 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac <<
422 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac <<
423 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_s <<
424 163
425 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 164 void acpi_free(void *address);
426 acpi_get_system_in <<
427 <<
428 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
429 acpi_get_statisti <<
430 ACPI_EXTERNAL_RETURN_PTR(const char <<
431 *acpi_format_excepti <<
432 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_p <<
433 <<
434 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
435 acpi_install_inter <<
436 <<
437 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
438 acpi_remove_interf <<
439 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_u <<
440 <<
441 ACPI_EXTERNAL_RETURN_UINT32(u32 <<
442 acpi_check_address <<
443 <<
444 <<
445 <<
446 <<
447 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
448 acpi_decode_pld_b <<
449 <<
450 <<
451 <<
452 165
453 /* 166 /*
454 * ACPI table load/unload interfaces 167 * ACPI table load/unload interfaces
455 */ 168 */
456 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I !! 169 acpi_status acpi_load_table(struct acpi_table_header *table);
457 acpi_install_table <<
458 <<
459 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I <<
460 acpi_install_physi <<
461 <<
462 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
463 acpi_load_table(st <<
464 u3 <<
465 <<
466 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
467 acpi_unload_table( <<
468 170
469 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 171 acpi_status acpi_unload_parent_table(acpi_handle object);
470 acpi_unload_parent <<
471 172
472 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I !! 173 acpi_status acpi_load_tables(void);
473 acpi_load_tables(v <<
474 174
475 /* 175 /*
476 * ACPI table manipulation interfaces 176 * ACPI table manipulation interfaces
477 */ 177 */
478 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I !! 178 acpi_status acpi_reallocate_root_table(void);
479 acpi_reallocate_ro <<
480 179
481 ACPI_EXTERNAL_RETURN_STATUS(acpi_status ACPI_I !! 180 acpi_status acpi_find_root_pointer(acpi_physical_address *rsdp_address);
482 acpi_find_root_poi !! 181
483 !! 182 acpi_status acpi_unload_table_id(acpi_owner_id id);
484 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 183
485 acpi_get_table_he !! 184 acpi_status
486 !! 185 acpi_get_table_header(acpi_string signature,
487 !! 186 u32 instance, struct acpi_table_header *out_table_header);
488 !! 187
489 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 188 acpi_status
490 acpi_get_table(ac !! 189 acpi_get_table_with_size(acpi_string signature,
491 st !! 190 u32 instance, struct acpi_table_header **out_table,
492 ** !! 191 acpi_size *tbl_size);
493 ACPI_EXTERNAL_RETURN_VOID(void acpi_put_table( !! 192 acpi_status
494 !! 193 acpi_get_table(acpi_string signature,
495 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 194 u32 instance, struct acpi_table_header **out_table);
496 acpi_get_table_by_ !! 195
497 !! 196 acpi_status
498 !! 197 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table);
499 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 198
500 acpi_install_tabl !! 199 acpi_status
501 !! 200 acpi_install_table_handler(acpi_table_handler handler, void *context);
502 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 201
503 acpi_remove_table !! 202 acpi_status acpi_remove_table_handler(acpi_table_handler handler);
504 <<
505 203
506 /* 204 /*
507 * Namespace and name interfaces 205 * Namespace and name interfaces
508 */ 206 */
509 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 207 acpi_status
510 acpi_walk_namespac !! 208 acpi_walk_namespace(acpi_object_type type,
511 !! 209 acpi_handle start_object,
512 !! 210 u32 max_depth,
513 !! 211 acpi_walk_callback pre_order_visit,
514 !! 212 acpi_walk_callback post_order_visit,
515 !! 213 void *context, void **return_value);
516 !! 214
517 !! 215 acpi_status
518 !! 216 acpi_get_devices(const char *HID,
519 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 217 acpi_walk_callback user_function,
520 acpi_get_devices( !! 218 void *context, void **return_value);
521 !! 219
522 !! 220 acpi_status
523 !! 221 acpi_get_name(acpi_handle object,
524 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 222 u32 name_type, struct acpi_buffer *ret_path_ptr);
525 acpi_get_name(acp !! 223
526 str !! 224 acpi_status
527 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 225 acpi_get_handle(acpi_handle parent,
528 acpi_get_handle(a !! 226 acpi_string pathname, acpi_handle * ret_handle);
529 c !! 227
530 a !! 228 acpi_status
531 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 229 acpi_attach_data(acpi_handle object, acpi_object_handler handler, void *data);
532 acpi_attach_data( !! 230
533 !! 231 acpi_status acpi_detach_data(acpi_handle object, acpi_object_handler handler);
534 !! 232
535 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 233 acpi_status
536 acpi_detach_data( !! 234 acpi_get_data(acpi_handle object, acpi_object_handler handler, void **data);
537 !! 235
538 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 236 acpi_status
539 acpi_get_data(acp !! 237 acpi_debug_trace(char *name, u32 debug_level, u32 debug_layer, u32 flags);
540 acp <<
541 voi <<
542 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
543 acpi_debug_trace( <<
544 <<
545 238
546 /* 239 /*
547 * Object manipulation and enumeration 240 * Object manipulation and enumeration
548 */ 241 */
549 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 242 acpi_status
550 acpi_evaluate_obje !! 243 acpi_evaluate_object(acpi_handle object,
551 !! 244 acpi_string pathname,
552 !! 245 struct acpi_object_list *parameter_objects,
553 !! 246 struct acpi_buffer *return_object_buffer);
554 !! 247
555 !! 248 acpi_status
556 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 249 acpi_evaluate_object_typed(acpi_handle object,
557 acpi_evaluate_obj !! 250 acpi_string pathname,
558 !! 251 struct acpi_object_list *external_params,
559 !! 252 struct acpi_buffer *return_buffer,
560 !! 253 acpi_object_type return_type);
561 !! 254
562 !! 255 acpi_status
563 !! 256 acpi_get_object_info(acpi_handle object,
564 !! 257 struct acpi_device_info **return_buffer);
565 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 258
566 acpi_get_object_i !! 259 acpi_status acpi_install_method(u8 *buffer);
567 !! 260
568 !! 261 acpi_status
569 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_i !! 262 acpi_get_next_object(acpi_object_type type,
570 !! 263 acpi_handle parent,
571 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 264 acpi_handle child, acpi_handle * out_handle);
572 acpi_get_next_obje !! 265
573 !! 266 acpi_status acpi_get_type(acpi_handle object, acpi_object_type * out_type);
574 !! 267
575 !! 268 acpi_status acpi_get_id(acpi_handle object, acpi_owner_id * out_type);
576 !! 269
577 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 270 acpi_status acpi_get_parent(acpi_handle object, acpi_handle * out_handle);
578 acpi_get_type(acpi <<
579 acpi <<
580 <<
581 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
582 acpi_get_parent(ac <<
583 ac <<
584 271
585 /* 272 /*
586 * Handler interfaces 273 * Handler interfaces
587 */ 274 */
588 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 275 acpi_status
589 acpi_install_initi !! 276 acpi_install_initialization_handler(acpi_init_handler handler, u32 function);
590 (acpi_init_handler !! 277
591 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status <<
592 acpi_install_s <<
593 <<
594 <<
595 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status <<
596 acpi_remove_sc <<
597 <<
598 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 278 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
599 acpi_install_g 279 acpi_install_global_event_handler
600 (acpi_gbl_even !! 280 (acpi_gbl_event_handler handler, void *context))
601 void *context !! 281
>> 282 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
>> 283 acpi_install_fixed_event_handler(u32
>> 284 acpi_event,
>> 285 acpi_event_handler
>> 286 handler,
>> 287 void
>> 288 *context))
602 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 289 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
603 acpi_install_f !! 290 acpi_remove_fixed_event_handler(u32 acpi_event,
604 <<
605 291 acpi_event_handler
606 !! 292 handler))
607 <<
608 <<
609 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status <<
610 acpi_remove_fi <<
611 <<
612 <<
613 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 293 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
614 acpi_install_g !! 294 acpi_install_gpe_handler(acpi_handle
615 !! 295 gpe_device,
>> 296 u32 gpe_number,
>> 297 u32 type,
>> 298 acpi_gpe_handler
>> 299 address,
>> 300 void *context))
>> 301 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
>> 302 acpi_remove_gpe_handler(acpi_handle gpe_device,
616 303 u32 gpe_number,
617 <<
618 304 acpi_gpe_handler
619 !! 305 address))
620 !! 306 acpi_status acpi_install_notify_handler(acpi_handle device, u32 handler_type,
621 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status !! 307 acpi_notify_handler handler,
622 acpi_install_g !! 308 void *context);
623 !! 309
624 !! 310 acpi_status
625 !! 311 acpi_remove_notify_handler(acpi_handle device,
626 !! 312 u32 handler_type, acpi_notify_handler handler);
627 !! 313
628 !! 314 acpi_status
629 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status !! 315 acpi_install_address_space_handler(acpi_handle device,
630 acpi_remove_gp !! 316 acpi_adr_space_type space_id,
631 !! 317 acpi_adr_space_handler handler,
632 !! 318 acpi_adr_space_setup setup, void *context);
633 !! 319
634 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 320 acpi_status
635 acpi_install_notif !! 321 acpi_remove_address_space_handler(acpi_handle device,
636 !! 322 acpi_adr_space_type space_id,
637 !! 323 acpi_adr_space_handler handler);
638 !! 324
639 !! 325 #ifdef ACPI_FUTURE_USAGE
640 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 326 acpi_status acpi_install_exception_handler(acpi_exception_handler handler);
641 acpi_remove_notify !! 327 #endif
642 !! 328
643 !! 329 acpi_status acpi_install_interface_handler(acpi_interface_handler handler);
644 <<
645 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
646 acpi_install_addre <<
647 <<
648 <<
649 <<
650 <<
651 <<
652 <<
653 <<
654 <<
655 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
656 acpi_install_addre <<
657 (acpi_handle devic <<
658 acpi_adr_space_ha <<
659 acpi_adr_space_se <<
660 void *context)) <<
661 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
662 acpi_execute_reg_m <<
663 <<
664 <<
665 <<
666 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
667 acpi_remove_addres <<
668 <<
669 <<
670 <<
671 <<
672 <<
673 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
674 acpi_install_excep <<
675 (acpi_exception_ha <<
676 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
677 acpi_install_inter <<
678 (acpi_interface_ha <<
679 330
680 /* 331 /*
681 * Global Lock interfaces 332 * Global Lock interfaces
682 */ 333 */
683 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 334 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
684 acpi_acquire_g 335 acpi_acquire_global_lock(u16 timeout,
685 336 u32 *handle))
686 <<
687 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 337 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
688 acpi_release_g 338 acpi_release_global_lock(u32 handle))
689 339
690 /* 340 /*
691 * Interfaces to AML mutex objects 341 * Interfaces to AML mutex objects
692 */ 342 */
693 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 343 acpi_status
694 acpi_acquire_mutex !! 344 acpi_acquire_mutex(acpi_handle handle, acpi_string pathname, u16 timeout);
695 !! 345
696 !! 346 acpi_status acpi_release_mutex(acpi_handle handle, acpi_string pathname);
697 <<
698 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
699 acpi_release_mutex <<
700 <<
701 347
702 /* 348 /*
703 * Fixed Event interfaces 349 * Fixed Event interfaces
704 */ 350 */
705 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 351 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
706 acpi_enable_ev 352 acpi_enable_event(u32 event, u32 flags))
707 353
708 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 354 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
709 acpi_disable_e 355 acpi_disable_event(u32 event, u32 flags))
>> 356
710 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac 357 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_clear_event(u32 event))
711 358
712 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 359 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
713 acpi_get_event 360 acpi_get_event_status(u32 event,
714 361 acpi_event_status
715 362 *event_status))
716 <<
717 /* 363 /*
718 * General Purpose Event (GPE) Interfaces 364 * General Purpose Event (GPE) Interfaces
719 */ 365 */
720 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac 366 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_update_all_gpes(void))
721 367
722 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 368 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
723 acpi_enable_gp 369 acpi_enable_gpe(acpi_handle gpe_device,
724 370 u32 gpe_number))
725 371
726 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 372 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
727 acpi_disable_g 373 acpi_disable_gpe(acpi_handle gpe_device,
728 374 u32 gpe_number))
729 375
730 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 376 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
731 acpi_clear_gpe 377 acpi_clear_gpe(acpi_handle gpe_device,
732 378 u32 gpe_number))
733 379
734 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 380 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
735 acpi_set_gpe(a 381 acpi_set_gpe(acpi_handle gpe_device,
736 u 382 u32 gpe_number, u8 action))
737 383
738 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 384 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
739 acpi_finish_gp 385 acpi_finish_gpe(acpi_handle gpe_device,
740 386 u32 gpe_number))
741 387
742 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 388 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
743 acpi_mask_gpe( <<
744 <<
745 <<
746 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status <<
747 acpi_mark_gpe_ <<
748 <<
749 <<
750 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status <<
751 acpi_setup_gpe 389 acpi_setup_gpe_for_wake(acpi_handle
752 390 parent_device,
753 391 acpi_handle gpe_device,
754 392 u32 gpe_number))
755 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 393 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
756 acpi_set_gpe_ 394 acpi_set_gpe_wake_mask(acpi_handle gpe_device,
757 395 u32 gpe_number,
758 396 u8 action))
759 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 397 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
760 acpi_get_gpe_ 398 acpi_get_gpe_status(acpi_handle gpe_device,
761 399 u32 gpe_number,
762 400 acpi_event_status
763 401 *event_status))
764 ACPI_HW_DEPENDENT_RETURN_UINT32(u32 acpi_dispa !! 402
765 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac <<
766 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac 403 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_disable_all_gpes(void))
>> 404
767 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac 405 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_enable_all_runtime_gpes(void))
768 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac <<
769 ACPI_HW_DEPENDENT_RETURN_UINT32(u32 acpi_any_g <<
770 ACPI_HW_DEPENDENT_RETURN_UINT32(u32 acpi_any_f <<
771 406
772 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 407 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
773 acpi_get_gpe_d 408 acpi_get_gpe_device(u32 gpe_index,
774 !! 409 acpi_handle * gpe_device))
775 410
776 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 411 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
777 acpi_install_g 412 acpi_install_gpe_block(acpi_handle gpe_device,
778 413 struct
779 414 acpi_generic_address
780 415 *gpe_block_address,
781 416 u32 register_count,
782 417 u32 interrupt_number))
783 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 418 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
784 acpi_remove_g 419 acpi_remove_gpe_block(acpi_handle gpe_device))
785 420
786 /* 421 /*
787 * Resource interfaces 422 * Resource interfaces
788 */ 423 */
789 typedef 424 typedef
790 acpi_status (*acpi_walk_resource_callback) (st !! 425 acpi_status(*acpi_walk_resource_callback) (struct acpi_resource * resource,
791 vo !! 426 void *context);
>> 427
>> 428 acpi_status
>> 429 acpi_get_vendor_resource(acpi_handle device,
>> 430 char *name,
>> 431 struct acpi_vendor_uuid *uuid,
>> 432 struct acpi_buffer *ret_buffer);
>> 433
>> 434 acpi_status
>> 435 acpi_get_current_resources(acpi_handle device, struct acpi_buffer *ret_buffer);
>> 436
>> 437 #ifdef ACPI_FUTURE_USAGE
>> 438 acpi_status
>> 439 acpi_get_possible_resources(acpi_handle device, struct acpi_buffer *ret_buffer);
>> 440 #endif
792 441
793 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 442 acpi_status
794 acpi_get_vendor_re !! 443 acpi_get_event_resources(acpi_handle device_handle,
795 !! 444 struct acpi_buffer *ret_buffer);
796 !! 445
797 !! 446 acpi_status
798 !! 447 acpi_walk_resource_buffer(struct acpi_buffer *buffer,
799 !! 448 acpi_walk_resource_callback user_function,
800 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 449 void *context);
801 acpi_get_current_ !! 450
802 !! 451 acpi_status
803 !! 452 acpi_walk_resources(acpi_handle device,
804 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 453 char *name,
805 acpi_get_possible !! 454 acpi_walk_resource_callback user_function, void *context);
806 !! 455
807 !! 456 acpi_status
808 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 457 acpi_set_current_resources(acpi_handle device, struct acpi_buffer *in_buffer);
809 acpi_get_event_re !! 458
810 !! 459 acpi_status
811 !! 460 acpi_get_irq_routing_table(acpi_handle device, struct acpi_buffer *ret_buffer);
812 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 461
813 acpi_walk_resourc !! 462 acpi_status
814 !! 463 acpi_resource_to_address64(struct acpi_resource *resource,
815 !! 464 struct acpi_resource_address64 *out);
816 !! 465
817 !! 466 acpi_status
818 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 467 acpi_buffer_to_resource(u8 *aml_buffer,
819 acpi_walk_resourc !! 468 u16 aml_buffer_length,
820 !! 469 struct acpi_resource **resource_ptr);
821 <<
822 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
823 acpi_set_current_ <<
824 <<
825 <<
826 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
827 acpi_get_irq_rout <<
828 <<
829 <<
830 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
831 acpi_resource_to_ <<
832 <<
833 <<
834 <<
835 <<
836 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
837 acpi_buffer_to_re <<
838 <<
839 <<
840 <<
841 470
842 /* 471 /*
843 * Hardware (ACPI device) interfaces 472 * Hardware (ACPI device) interfaces
844 */ 473 */
845 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_r !! 474 acpi_status acpi_reset(void);
>> 475
>> 476 acpi_status acpi_read(u64 *value, struct acpi_generic_address *reg);
846 477
847 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 478 acpi_status acpi_write(u64 value, struct acpi_generic_address *reg);
848 acpi_read(u64 *val <<
849 struct a <<
850 <<
851 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
852 acpi_write(u64 val <<
853 struct <<
854 479
855 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 480 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
856 acpi_read_bit_ 481 acpi_read_bit_register(u32 register_id,
857 482 u32 *return_value))
858 483
859 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 484 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
860 acpi_write_bit 485 acpi_write_bit_register(u32 register_id,
861 486 u32 value))
862 487
863 /* 488 /*
864 * Sleep/Wake interfaces 489 * Sleep/Wake interfaces
865 */ 490 */
866 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 491 acpi_status
867 acpi_get_sleep_typ !! 492 acpi_get_sleep_type_data(u8 sleep_state, u8 * slp_typ_a, u8 * slp_typ_b);
868 !! 493
869 !! 494 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state);
870 !! 495
871 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 496 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state);
872 acpi_enter_sleep_s !! 497
873 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_e !! 498 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void))
874 !! 499
875 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac !! 500 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state);
876 !! 501
877 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 502 acpi_status acpi_leave_sleep_state(u8 sleep_state);
878 acpi_leave_sleep_s !! 503
879 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_l !! 504 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
880 !! 505 acpi_set_firmware_waking_vector(u32
881 ACPI_EXTERNAL_RETURN_STATUS(acpi_status !! 506 physical_address))
882 acpi_set_firmware_ !! 507
883 (acpi_physical_add !! 508 #if ACPI_MACHINE_WIDTH == 64
884 acpi_physical_add !! 509 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
>> 510 acpi_set_firmware_waking_vector64(u64
>> 511 physical_address))
>> 512 #endif
885 /* 513 /*
886 * ACPI Timer interfaces 514 * ACPI Timer interfaces
887 */ 515 */
>> 516 #ifdef ACPI_FUTURE_USAGE
888 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 517 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
889 acpi_get_timer 518 acpi_get_timer_resolution(u32 *resolution))
>> 519
890 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status ac 520 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status acpi_get_timer(u32 *ticks))
891 521
892 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status 522 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
893 acpi_get_timer 523 acpi_get_timer_duration(u32 start_ticks,
894 524 u32 end_ticks,
895 525 u32 *time_elapsed))
>> 526 #endif /* ACPI_FUTURE_USAGE */
896 527
897 /* 528 /*
898 * Error/Warning output 529 * Error/Warning output
899 */ 530 */
900 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 531 void ACPI_INTERNAL_VAR_XFACE
901 void ACPI_INTER !! 532 acpi_error(const char *module_name,
902 acpi_error(cons !! 533 u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
903 u32 !! 534
904 cons !! 535 void ACPI_INTERNAL_VAR_XFACE
905 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 536 acpi_exception(const char *module_name,
906 void ACPI_INTE !! 537 u32 line_number,
907 acpi_exception !! 538 acpi_status status, const char *format, ...) ACPI_PRINTF_LIKE(4);
908 !! 539
909 !! 540 void ACPI_INTERNAL_VAR_XFACE
910 !! 541 acpi_warning(const char *module_name,
911 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 542 u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
912 void ACPI_INTE !! 543
913 acpi_warning(c !! 544 void ACPI_INTERNAL_VAR_XFACE
914 u !! 545 acpi_info(const char *module_name,
915 c !! 546 u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
916 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 547
917 void ACPI_INTE !! 548 void ACPI_INTERNAL_VAR_XFACE
918 acpi_info(cons !! 549 acpi_bios_error(const char *module_name,
919 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 550 u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
920 void ACPI_INTE !! 551
921 acpi_bios_erro !! 552 void ACPI_INTERNAL_VAR_XFACE
922 !! 553 acpi_bios_warning(const char *module_name,
923 !! 554 u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
924 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK <<
925 void ACPI_INTE <<
926 acpi_bios_exce <<
927 <<
928 <<
929 <<
930 ACPI_MSG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK <<
931 void ACPI_INTE <<
932 acpi_bios_warn <<
933 <<
934 <<
935 555
936 /* 556 /*
937 * Debug output 557 * Debug output
938 */ 558 */
939 ACPI_DBG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK !! 559 #ifdef ACPI_DEBUG_OUTPUT
940 void ACPI_INTER <<
941 acpi_debug_prin <<
942 <<
943 <<
944 <<
945 <<
946 <<
947 ACPI_DBG_DEPENDENT_RETURN_VOID(ACPI_PRINTF_LIK <<
948 void ACPI_INTE <<
949 acpi_debug_pri <<
950 <<
951 <<
952 <<
953 <<
954 <<
955 <<
956 ACPI_DBG_DEPENDENT_RETURN_VOID(void <<
957 acpi_trace_poin <<
958 <<
959 <<
960 <<
961 acpi_status acpi_initialize_debugger(void); <<
962 <<
963 void acpi_terminate_debugger(void); <<
964 <<
965 /* <<
966 * Divergences <<
967 */ <<
968 ACPI_EXTERNAL_RETURN_STATUS(acpi_status <<
969 acpi_get_data_full <<
970 <<
971 <<
972 <<
973 560
974 void acpi_set_debugger_thread_id(acpi_thread_i !! 561 void ACPI_INTERNAL_VAR_XFACE
>> 562 acpi_debug_print(u32 requested_debug_level,
>> 563 u32 line_number,
>> 564 const char *function_name,
>> 565 const char *module_name,
>> 566 u32 component_id, const char *format, ...) ACPI_PRINTF_LIKE(6);
>> 567
>> 568 void ACPI_INTERNAL_VAR_XFACE
>> 569 acpi_debug_print_raw(u32 requested_debug_level,
>> 570 u32 line_number,
>> 571 const char *function_name,
>> 572 const char *module_name,
>> 573 u32 component_id,
>> 574 const char *format, ...) ACPI_PRINTF_LIKE(6);
>> 575 #endif
975 576
976 #endif /* __ACXFACE_H 577 #endif /* __ACXFACE_H__ */
977 578
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.