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