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