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 */
686