]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: utxface - External interfaces for "global" ACPI functions | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
a8357b0c | 8 | * Copyright (C) 2000 - 2010, Intel Corp. |
1da177e4 LT |
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 | ||
1da177e4 | 44 | #include <acpi/acpi.h> |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "acevents.h" | |
47 | #include "acnamesp.h" | |
48 | #include "acdebug.h" | |
49 | #include "actables.h" | |
1da177e4 LT |
50 | |
51 | #define _COMPONENT ACPI_UTILITIES | |
4be44fcd | 52 | ACPI_MODULE_NAME("utxface") |
1da177e4 | 53 | |
e20a679b | 54 | #ifndef ACPI_ASL_COMPILER |
1da177e4 LT |
55 | /******************************************************************************* |
56 | * | |
57 | * FUNCTION: acpi_initialize_subsystem | |
58 | * | |
59 | * PARAMETERS: None | |
60 | * | |
61 | * RETURN: Status | |
62 | * | |
63 | * DESCRIPTION: Initializes all global variables. This is the first function | |
64 | * called, so any early initialization belongs here. | |
65 | * | |
66 | ******************************************************************************/ | |
dd272b57 | 67 | acpi_status __init acpi_initialize_subsystem(void) |
1da177e4 | 68 | { |
4be44fcd | 69 | acpi_status status; |
44f6c012 | 70 | |
b229cf92 | 71 | ACPI_FUNCTION_TRACE(acpi_initialize_subsystem); |
1da177e4 | 72 | |
cb219bb6 | 73 | acpi_gbl_startup_flags = ACPI_SUBSYSTEM_INITIALIZE; |
4be44fcd | 74 | ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace()); |
1da177e4 | 75 | |
1da177e4 LT |
76 | /* Initialize the OS-Dependent layer */ |
77 | ||
4be44fcd LB |
78 | status = acpi_os_initialize(); |
79 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 80 | ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization")); |
4be44fcd | 81 | return_ACPI_STATUS(status); |
1da177e4 LT |
82 | } |
83 | ||
73459f73 RM |
84 | /* Initialize all globals used by the subsystem */ |
85 | ||
b417d40b YY |
86 | status = acpi_ut_init_globals(); |
87 | if (ACPI_FAILURE(status)) { | |
88 | ACPI_EXCEPTION((AE_INFO, status, | |
89 | "During initialization of globals")); | |
90 | return_ACPI_STATUS(status); | |
91 | } | |
73459f73 | 92 | |
1da177e4 LT |
93 | /* Create the default mutex objects */ |
94 | ||
4be44fcd LB |
95 | status = acpi_ut_mutex_initialize(); |
96 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
97 | ACPI_EXCEPTION((AE_INFO, status, |
98 | "During Global Mutex creation")); | |
4be44fcd | 99 | return_ACPI_STATUS(status); |
1da177e4 LT |
100 | } |
101 | ||
102 | /* | |
103 | * Initialize the namespace manager and | |
104 | * the root of the namespace tree | |
105 | */ | |
4be44fcd LB |
106 | status = acpi_ns_root_initialize(); |
107 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
108 | ACPI_EXCEPTION((AE_INFO, status, |
109 | "During Namespace initialization")); | |
4be44fcd | 110 | return_ACPI_STATUS(status); |
1da177e4 LT |
111 | } |
112 | ||
b0ed7a91 LM |
113 | /* Initialize the global OSI interfaces list with the static names */ |
114 | ||
115 | status = acpi_ut_initialize_interfaces(); | |
116 | if (ACPI_FAILURE(status)) { | |
117 | ACPI_EXCEPTION((AE_INFO, status, | |
118 | "During OSI interfaces initialization")); | |
119 | return_ACPI_STATUS(status); | |
120 | } | |
121 | ||
1da177e4 LT |
122 | /* If configured, initialize the AML debugger */ |
123 | ||
4be44fcd | 124 | ACPI_DEBUGGER_EXEC(status = acpi_db_initialize()); |
4be44fcd | 125 | return_ACPI_STATUS(status); |
1da177e4 LT |
126 | } |
127 | ||
1da177e4 LT |
128 | /******************************************************************************* |
129 | * | |
130 | * FUNCTION: acpi_enable_subsystem | |
131 | * | |
132 | * PARAMETERS: Flags - Init/enable Options | |
133 | * | |
134 | * RETURN: Status | |
135 | * | |
136 | * DESCRIPTION: Completes the subsystem initialization including hardware. | |
137 | * Puts system into ACPI mode if it isn't already. | |
138 | * | |
139 | ******************************************************************************/ | |
4be44fcd | 140 | acpi_status acpi_enable_subsystem(u32 flags) |
1da177e4 | 141 | { |
4be44fcd | 142 | acpi_status status = AE_OK; |
1da177e4 | 143 | |
b229cf92 | 144 | ACPI_FUNCTION_TRACE(acpi_enable_subsystem); |
1da177e4 | 145 | |
1da177e4 LT |
146 | /* Enable ACPI mode */ |
147 | ||
148 | if (!(flags & ACPI_NO_ACPI_ENABLE)) { | |
4be44fcd LB |
149 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
150 | "[Init] Going into ACPI mode\n")); | |
1da177e4 LT |
151 | |
152 | acpi_gbl_original_mode = acpi_hw_get_mode(); | |
153 | ||
4be44fcd LB |
154 | status = acpi_enable(); |
155 | if (ACPI_FAILURE(status)) { | |
b229cf92 | 156 | ACPI_WARNING((AE_INFO, "AcpiEnable failed")); |
4be44fcd | 157 | return_ACPI_STATUS(status); |
1da177e4 LT |
158 | } |
159 | } | |
160 | ||
009c4cbe BM |
161 | /* |
162 | * Obtain a permanent mapping for the FACS. This is required for the | |
163 | * Global Lock and the Firmware Waking Vector | |
164 | */ | |
165 | status = acpi_tb_initialize_facs(); | |
166 | if (ACPI_FAILURE(status)) { | |
167 | ACPI_WARNING((AE_INFO, "Could not map the FACS table")); | |
168 | return_ACPI_STATUS(status); | |
169 | } | |
170 | ||
1da177e4 LT |
171 | /* |
172 | * Install the default op_region handlers. These are installed unless | |
173 | * other handlers have already been installed via the | |
174 | * install_address_space_handler interface. | |
175 | */ | |
176 | if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) { | |
4be44fcd LB |
177 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
178 | "[Init] Installing default address space handlers\n")); | |
1da177e4 | 179 | |
4be44fcd LB |
180 | status = acpi_ev_install_region_handlers(); |
181 | if (ACPI_FAILURE(status)) { | |
182 | return_ACPI_STATUS(status); | |
1da177e4 LT |
183 | } |
184 | } | |
185 | ||
186 | /* | |
187 | * Initialize ACPI Event handling (Fixed and General Purpose) | |
188 | * | |
96db255c BM |
189 | * Note1: We must have the hardware and events initialized before we can |
190 | * execute any control methods safely. Any control method can require | |
191 | * ACPI hardware support, so the hardware must be fully initialized before | |
192 | * any method execution! | |
193 | * | |
194 | * Note2: Fixed events are initialized and enabled here. GPEs are | |
195 | * initialized, but cannot be enabled until after the hardware is | |
196 | * completely initialized (SCI and global_lock activated) | |
1da177e4 LT |
197 | */ |
198 | if (!(flags & ACPI_NO_EVENT_INIT)) { | |
4be44fcd LB |
199 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
200 | "[Init] Initializing ACPI events\n")); | |
1da177e4 | 201 | |
4be44fcd LB |
202 | status = acpi_ev_initialize_events(); |
203 | if (ACPI_FAILURE(status)) { | |
204 | return_ACPI_STATUS(status); | |
1da177e4 LT |
205 | } |
206 | } | |
207 | ||
96db255c BM |
208 | /* |
209 | * Install the SCI handler and Global Lock handler. This completes the | |
210 | * hardware initialization. | |
211 | */ | |
1da177e4 | 212 | if (!(flags & ACPI_NO_HANDLER_INIT)) { |
4be44fcd LB |
213 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
214 | "[Init] Installing SCI/GL handlers\n")); | |
1da177e4 | 215 | |
4be44fcd LB |
216 | status = acpi_ev_install_xrupt_handlers(); |
217 | if (ACPI_FAILURE(status)) { | |
218 | return_ACPI_STATUS(status); | |
1da177e4 LT |
219 | } |
220 | } | |
221 | ||
4be44fcd | 222 | return_ACPI_STATUS(status); |
1da177e4 LT |
223 | } |
224 | ||
8313524a BM |
225 | ACPI_EXPORT_SYMBOL(acpi_enable_subsystem) |
226 | ||
1da177e4 LT |
227 | /******************************************************************************* |
228 | * | |
229 | * FUNCTION: acpi_initialize_objects | |
230 | * | |
231 | * PARAMETERS: Flags - Init/enable Options | |
232 | * | |
233 | * RETURN: Status | |
234 | * | |
235 | * DESCRIPTION: Completes namespace initialization by initializing device | |
236 | * objects and executing AML code for Regions, buffers, etc. | |
237 | * | |
238 | ******************************************************************************/ | |
4be44fcd | 239 | acpi_status acpi_initialize_objects(u32 flags) |
1da177e4 | 240 | { |
4be44fcd | 241 | acpi_status status = AE_OK; |
1da177e4 | 242 | |
b229cf92 | 243 | ACPI_FUNCTION_TRACE(acpi_initialize_objects); |
1da177e4 LT |
244 | |
245 | /* | |
246 | * Run all _REG methods | |
247 | * | |
96db255c BM |
248 | * Note: Any objects accessed by the _REG methods will be automatically |
249 | * initialized, even if they contain executable AML (see the call to | |
250 | * acpi_ns_initialize_objects below). | |
1da177e4 LT |
251 | */ |
252 | if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) { | |
4be44fcd | 253 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
b229cf92 | 254 | "[Init] Executing _REG OpRegion methods\n")); |
1da177e4 | 255 | |
4be44fcd LB |
256 | status = acpi_ev_initialize_op_regions(); |
257 | if (ACPI_FAILURE(status)) { | |
258 | return_ACPI_STATUS(status); | |
1da177e4 LT |
259 | } |
260 | } | |
261 | ||
7f0c826a LM |
262 | /* |
263 | * Execute any module-level code that was detected during the table load | |
264 | * phase. Although illegal since ACPI 2.0, there are many machines that | |
265 | * contain this type of code. Each block of detected executable AML code | |
266 | * outside of any control method is wrapped with a temporary control | |
267 | * method object and placed on a global list. The methods on this list | |
268 | * are executed below. | |
269 | */ | |
270 | acpi_ns_exec_module_code_list(); | |
271 | ||
1da177e4 | 272 | /* |
96db255c BM |
273 | * Initialize the objects that remain uninitialized. This runs the |
274 | * executable AML that may be part of the declaration of these objects: | |
275 | * operation_regions, buffer_fields, Buffers, and Packages. | |
1da177e4 LT |
276 | */ |
277 | if (!(flags & ACPI_NO_OBJECT_INIT)) { | |
4be44fcd LB |
278 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
279 | "[Init] Completing Initialization of ACPI Objects\n")); | |
1da177e4 | 280 | |
4be44fcd LB |
281 | status = acpi_ns_initialize_objects(); |
282 | if (ACPI_FAILURE(status)) { | |
283 | return_ACPI_STATUS(status); | |
1da177e4 LT |
284 | } |
285 | } | |
286 | ||
287 | /* | |
96db255c BM |
288 | * Initialize all device objects in the namespace. This runs the device |
289 | * _STA and _INI methods. | |
1da177e4 LT |
290 | */ |
291 | if (!(flags & ACPI_NO_DEVICE_INIT)) { | |
4be44fcd LB |
292 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
293 | "[Init] Initializing ACPI Devices\n")); | |
1da177e4 | 294 | |
4be44fcd LB |
295 | status = acpi_ns_initialize_devices(); |
296 | if (ACPI_FAILURE(status)) { | |
297 | return_ACPI_STATUS(status); | |
1da177e4 LT |
298 | } |
299 | } | |
300 | ||
301 | /* | |
302 | * Empty the caches (delete the cached objects) on the assumption that | |
303 | * the table load filled them up more than they will be at runtime -- | |
304 | * thus wasting non-paged memory. | |
305 | */ | |
4be44fcd | 306 | status = acpi_purge_cached_objects(); |
1da177e4 LT |
307 | |
308 | acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK; | |
4be44fcd | 309 | return_ACPI_STATUS(status); |
1da177e4 LT |
310 | } |
311 | ||
8313524a BM |
312 | ACPI_EXPORT_SYMBOL(acpi_initialize_objects) |
313 | ||
e20a679b | 314 | #endif |
1da177e4 LT |
315 | /******************************************************************************* |
316 | * | |
317 | * FUNCTION: acpi_terminate | |
318 | * | |
319 | * PARAMETERS: None | |
320 | * | |
321 | * RETURN: Status | |
322 | * | |
2f977b36 | 323 | * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources. |
1da177e4 LT |
324 | * |
325 | ******************************************************************************/ | |
4be44fcd | 326 | acpi_status acpi_terminate(void) |
1da177e4 | 327 | { |
4be44fcd | 328 | acpi_status status; |
1da177e4 | 329 | |
b229cf92 | 330 | ACPI_FUNCTION_TRACE(acpi_terminate); |
1da177e4 | 331 | |
2f977b36 BM |
332 | /* Just exit if subsystem is already shutdown */ |
333 | ||
334 | if (acpi_gbl_shutdown) { | |
335 | ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated")); | |
336 | return_ACPI_STATUS(AE_OK); | |
337 | } | |
338 | ||
339 | /* Subsystem appears active, go ahead and shut it down */ | |
340 | ||
341 | acpi_gbl_shutdown = TRUE; | |
342 | acpi_gbl_startup_flags = 0; | |
343 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n")); | |
344 | ||
1da177e4 LT |
345 | /* Terminate the AML Debugger if present */ |
346 | ||
347 | ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE); | |
348 | ||
349 | /* Shutdown and free all resources */ | |
350 | ||
4be44fcd | 351 | acpi_ut_subsystem_shutdown(); |
1da177e4 LT |
352 | |
353 | /* Free the mutex objects */ | |
354 | ||
4be44fcd | 355 | acpi_ut_mutex_terminate(); |
1da177e4 LT |
356 | |
357 | #ifdef ACPI_DEBUGGER | |
358 | ||
359 | /* Shut down the debugger */ | |
360 | ||
4be44fcd | 361 | acpi_db_terminate(); |
1da177e4 LT |
362 | #endif |
363 | ||
364 | /* Now we can shutdown the OS-dependent layer */ | |
365 | ||
4be44fcd LB |
366 | status = acpi_os_terminate(); |
367 | return_ACPI_STATUS(status); | |
1da177e4 LT |
368 | } |
369 | ||
8313524a | 370 | ACPI_EXPORT_SYMBOL(acpi_terminate) |
2f977b36 | 371 | |
e20a679b | 372 | #ifndef ACPI_ASL_COMPILER |
1da177e4 | 373 | #ifdef ACPI_FUTURE_USAGE |
44f6c012 | 374 | /******************************************************************************* |
1da177e4 LT |
375 | * |
376 | * FUNCTION: acpi_subsystem_status | |
377 | * | |
378 | * PARAMETERS: None | |
379 | * | |
380 | * RETURN: Status of the ACPI subsystem | |
381 | * | |
382 | * DESCRIPTION: Other drivers that use the ACPI subsystem should call this | |
44f6c012 RM |
383 | * before making any other calls, to ensure the subsystem |
384 | * initialized successfully. | |
1da177e4 | 385 | * |
44f6c012 | 386 | ******************************************************************************/ |
4be44fcd | 387 | acpi_status acpi_subsystem_status(void) |
1da177e4 | 388 | { |
44f6c012 | 389 | |
1da177e4 LT |
390 | if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) { |
391 | return (AE_OK); | |
4be44fcd | 392 | } else { |
1da177e4 LT |
393 | return (AE_ERROR); |
394 | } | |
395 | } | |
396 | ||
8313524a BM |
397 | ACPI_EXPORT_SYMBOL(acpi_subsystem_status) |
398 | ||
44f6c012 | 399 | /******************************************************************************* |
1da177e4 LT |
400 | * |
401 | * FUNCTION: acpi_get_system_info | |
402 | * | |
44f6c012 RM |
403 | * PARAMETERS: out_buffer - A buffer to receive the resources for the |
404 | * device | |
1da177e4 LT |
405 | * |
406 | * RETURN: Status - the status of the call | |
407 | * | |
408 | * DESCRIPTION: This function is called to get information about the current | |
409 | * state of the ACPI subsystem. It will return system information | |
410 | * in the out_buffer. | |
411 | * | |
412 | * If the function fails an appropriate status will be returned | |
413 | * and the value of out_buffer is undefined. | |
414 | * | |
415 | ******************************************************************************/ | |
4be44fcd | 416 | acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer) |
1da177e4 | 417 | { |
4be44fcd LB |
418 | struct acpi_system_info *info_ptr; |
419 | acpi_status status; | |
1da177e4 | 420 | |
b229cf92 | 421 | ACPI_FUNCTION_TRACE(acpi_get_system_info); |
1da177e4 LT |
422 | |
423 | /* Parameter validation */ | |
424 | ||
4be44fcd LB |
425 | status = acpi_ut_validate_buffer(out_buffer); |
426 | if (ACPI_FAILURE(status)) { | |
427 | return_ACPI_STATUS(status); | |
1da177e4 LT |
428 | } |
429 | ||
430 | /* Validate/Allocate/Clear caller buffer */ | |
431 | ||
4be44fcd LB |
432 | status = |
433 | acpi_ut_initialize_buffer(out_buffer, | |
434 | sizeof(struct acpi_system_info)); | |
435 | if (ACPI_FAILURE(status)) { | |
436 | return_ACPI_STATUS(status); | |
1da177e4 LT |
437 | } |
438 | ||
439 | /* | |
440 | * Populate the return buffer | |
441 | */ | |
4be44fcd | 442 | info_ptr = (struct acpi_system_info *)out_buffer->pointer; |
1da177e4 | 443 | |
4be44fcd | 444 | info_ptr->acpi_ca_version = ACPI_CA_VERSION; |
1da177e4 LT |
445 | |
446 | /* System flags (ACPI capabilities) */ | |
447 | ||
4be44fcd | 448 | info_ptr->flags = ACPI_SYS_MODE_ACPI; |
1da177e4 LT |
449 | |
450 | /* Timer resolution - 24 or 32 bits */ | |
451 | ||
f3d2e786 | 452 | if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) { |
1da177e4 | 453 | info_ptr->timer_resolution = 24; |
4be44fcd | 454 | } else { |
1da177e4 LT |
455 | info_ptr->timer_resolution = 32; |
456 | } | |
457 | ||
458 | /* Clear the reserved fields */ | |
459 | ||
4be44fcd LB |
460 | info_ptr->reserved1 = 0; |
461 | info_ptr->reserved2 = 0; | |
1da177e4 LT |
462 | |
463 | /* Current debug levels */ | |
464 | ||
4be44fcd LB |
465 | info_ptr->debug_layer = acpi_dbg_layer; |
466 | info_ptr->debug_level = acpi_dbg_level; | |
1da177e4 | 467 | |
4be44fcd | 468 | return_ACPI_STATUS(AE_OK); |
1da177e4 | 469 | } |
1da177e4 | 470 | |
8313524a | 471 | ACPI_EXPORT_SYMBOL(acpi_get_system_info) |
1da177e4 LT |
472 | |
473 | /***************************************************************************** | |
474 | * | |
475 | * FUNCTION: acpi_install_initialization_handler | |
476 | * | |
477 | * PARAMETERS: Handler - Callback procedure | |
44f6c012 | 478 | * Function - Not (currently) used, see below |
1da177e4 LT |
479 | * |
480 | * RETURN: Status | |
481 | * | |
482 | * DESCRIPTION: Install an initialization handler | |
483 | * | |
484 | * TBD: When a second function is added, must save the Function also. | |
485 | * | |
486 | ****************************************************************************/ | |
1da177e4 | 487 | acpi_status |
4be44fcd | 488 | acpi_install_initialization_handler(acpi_init_handler handler, u32 function) |
1da177e4 LT |
489 | { |
490 | ||
491 | if (!handler) { | |
492 | return (AE_BAD_PARAMETER); | |
493 | } | |
494 | ||
495 | if (acpi_gbl_init_handler) { | |
496 | return (AE_ALREADY_EXISTS); | |
497 | } | |
498 | ||
499 | acpi_gbl_init_handler = handler; | |
500 | return AE_OK; | |
501 | } | |
502 | ||
8313524a | 503 | ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler) |
4be44fcd | 504 | #endif /* ACPI_FUTURE_USAGE */ |
b0ed7a91 | 505 | |
1da177e4 LT |
506 | /***************************************************************************** |
507 | * | |
508 | * FUNCTION: acpi_purge_cached_objects | |
509 | * | |
510 | * PARAMETERS: None | |
511 | * | |
512 | * RETURN: Status | |
513 | * | |
514 | * DESCRIPTION: Empty all caches (delete the cached objects) | |
515 | * | |
516 | ****************************************************************************/ | |
4be44fcd | 517 | acpi_status acpi_purge_cached_objects(void) |
1da177e4 | 518 | { |
b229cf92 | 519 | ACPI_FUNCTION_TRACE(acpi_purge_cached_objects); |
1da177e4 | 520 | |
4be44fcd LB |
521 | (void)acpi_os_purge_cache(acpi_gbl_state_cache); |
522 | (void)acpi_os_purge_cache(acpi_gbl_operand_cache); | |
523 | (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache); | |
524 | (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache); | |
525 | return_ACPI_STATUS(AE_OK); | |
1da177e4 | 526 | } |
8313524a BM |
527 | |
528 | ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects) | |
b0ed7a91 LM |
529 | |
530 | /***************************************************************************** | |
531 | * | |
532 | * FUNCTION: acpi_install_interface | |
533 | * | |
534 | * PARAMETERS: interface_name - The interface to install | |
535 | * | |
536 | * RETURN: Status | |
537 | * | |
538 | * DESCRIPTION: Install an _OSI interface to the global list | |
539 | * | |
540 | ****************************************************************************/ | |
541 | acpi_status acpi_install_interface(acpi_string interface_name) | |
542 | { | |
543 | acpi_status status; | |
544 | struct acpi_interface_info *interface_info; | |
545 | ||
546 | /* Parameter validation */ | |
547 | ||
548 | if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) { | |
549 | return (AE_BAD_PARAMETER); | |
550 | } | |
551 | ||
552 | (void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); | |
553 | ||
554 | /* Check if the interface name is already in the global list */ | |
555 | ||
556 | interface_info = acpi_ut_get_interface(interface_name); | |
557 | if (interface_info) { | |
558 | /* | |
559 | * The interface already exists in the list. This is OK if the | |
560 | * interface has been marked invalid -- just clear the bit. | |
561 | */ | |
562 | if (interface_info->flags & ACPI_OSI_INVALID) { | |
563 | interface_info->flags &= ~ACPI_OSI_INVALID; | |
564 | status = AE_OK; | |
565 | } else { | |
566 | status = AE_ALREADY_EXISTS; | |
567 | } | |
568 | } else { | |
569 | /* New interface name, install into the global list */ | |
570 | ||
571 | status = acpi_ut_install_interface(interface_name); | |
572 | } | |
573 | ||
574 | acpi_os_release_mutex(acpi_gbl_osi_mutex); | |
575 | return (status); | |
576 | } | |
577 | ||
578 | ACPI_EXPORT_SYMBOL(acpi_install_interface) | |
579 | ||
580 | /***************************************************************************** | |
581 | * | |
582 | * FUNCTION: acpi_remove_interface | |
583 | * | |
584 | * PARAMETERS: interface_name - The interface to remove | |
585 | * | |
586 | * RETURN: Status | |
587 | * | |
588 | * DESCRIPTION: Remove an _OSI interface from the global list | |
589 | * | |
590 | ****************************************************************************/ | |
591 | acpi_status acpi_remove_interface(acpi_string interface_name) | |
592 | { | |
593 | acpi_status status; | |
594 | ||
595 | /* Parameter validation */ | |
596 | ||
597 | if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) { | |
598 | return (AE_BAD_PARAMETER); | |
599 | } | |
600 | ||
601 | (void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); | |
602 | ||
603 | status = acpi_ut_remove_interface(interface_name); | |
604 | ||
605 | acpi_os_release_mutex(acpi_gbl_osi_mutex); | |
606 | return (status); | |
607 | } | |
608 | ||
609 | ACPI_EXPORT_SYMBOL(acpi_remove_interface) | |
610 | ||
611 | /***************************************************************************** | |
612 | * | |
613 | * FUNCTION: acpi_install_interface_handler | |
614 | * | |
615 | * PARAMETERS: Handler - The _OSI interface handler to install | |
616 | * NULL means "remove existing handler" | |
617 | * | |
618 | * RETURN: Status | |
619 | * | |
620 | * DESCRIPTION: Install a handler for the predefined _OSI ACPI method. | |
621 | * invoked during execution of the internal implementation of | |
622 | * _OSI. A NULL handler simply removes any existing handler. | |
623 | * | |
624 | ****************************************************************************/ | |
625 | acpi_status acpi_install_interface_handler(acpi_interface_handler handler) | |
626 | { | |
627 | acpi_status status = AE_OK; | |
628 | ||
629 | (void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); | |
630 | ||
631 | if (handler && acpi_gbl_interface_handler) { | |
632 | status = AE_ALREADY_EXISTS; | |
633 | } else { | |
634 | acpi_gbl_interface_handler = handler; | |
635 | } | |
636 | ||
637 | acpi_os_release_mutex(acpi_gbl_osi_mutex); | |
638 | return (status); | |
639 | } | |
640 | ||
641 | ACPI_EXPORT_SYMBOL(acpi_install_interface_handler) | |
642 | #endif /* !ACPI_ASL_COMPILER */ |