1/******************************************************************************
2 *
3 * Module Name: utxface - External interfaces for "global" ACPI functions
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2007, R. Byron Moore
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 <acpi/acevents.h>
46#include <acpi/acnamesp.h>
47#include <acpi/acdebug.h>
48
49#define _COMPONENT          ACPI_UTILITIES
50ACPI_MODULE_NAME("utxface")
51
52/*******************************************************************************
53 *
54 * FUNCTION:    acpi_initialize_subsystem
55 *
56 * PARAMETERS:  None
57 *
58 * RETURN:      Status
59 *
60 * DESCRIPTION: Initializes all global variables.  This is the first function
61 *              called, so any early initialization belongs here.
62 *
63 ******************************************************************************/
64acpi_status __init acpi_initialize_subsystem(void)
65{
66	acpi_status status;
67
68	ACPI_FUNCTION_TRACE(acpi_initialize_subsystem);
69
70	acpi_gbl_startup_flags = ACPI_SUBSYSTEM_INITIALIZE;
71	ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
72
73	/* Initialize the OS-Dependent layer */
74
75	status = acpi_os_initialize();
76	if (ACPI_FAILURE(status)) {
77		ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization"));
78		return_ACPI_STATUS(status);
79	}
80
81	/* Initialize all globals used by the subsystem */
82
83	acpi_ut_init_globals();
84
85	/* Create the default mutex objects */
86
87	status = acpi_ut_mutex_initialize();
88	if (ACPI_FAILURE(status)) {
89		ACPI_EXCEPTION((AE_INFO, status,
90				"During Global Mutex creation"));
91		return_ACPI_STATUS(status);
92	}
93
94	/*
95	 * Initialize the namespace manager and
96	 * the root of the namespace tree
97	 */
98	status = acpi_ns_root_initialize();
99	if (ACPI_FAILURE(status)) {
100		ACPI_EXCEPTION((AE_INFO, status,
101				"During Namespace initialization"));
102		return_ACPI_STATUS(status);
103	}
104
105	/* If configured, initialize the AML debugger */
106
107	ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
108	return_ACPI_STATUS(status);
109}
110
111/*******************************************************************************
112 *
113 * FUNCTION:    acpi_enable_subsystem
114 *
115 * PARAMETERS:  Flags           - Init/enable Options
116 *
117 * RETURN:      Status
118 *
119 * DESCRIPTION: Completes the subsystem initialization including hardware.
120 *              Puts system into ACPI mode if it isn't already.
121 *
122 ******************************************************************************/
123acpi_status acpi_enable_subsystem(u32 flags)
124{
125	acpi_status status = AE_OK;
126
127	ACPI_FUNCTION_TRACE(acpi_enable_subsystem);
128
129	/* Enable ACPI mode */
130
131	if (!(flags & ACPI_NO_ACPI_ENABLE)) {
132		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
133				  "[Init] Going into ACPI mode\n"));
134
135		acpi_gbl_original_mode = acpi_hw_get_mode();
136
137		status = acpi_enable();
138		if (ACPI_FAILURE(status)) {
139			ACPI_WARNING((AE_INFO, "AcpiEnable failed"));
140			return_ACPI_STATUS(status);
141		}
142	}
143
144	/*
145	 * Install the default op_region handlers. These are installed unless
146	 * other handlers have already been installed via the
147	 * install_address_space_handler interface.
148	 */
149	if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
150		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
151				  "[Init] Installing default address space handlers\n"));
152
153		status = acpi_ev_install_region_handlers();
154		if (ACPI_FAILURE(status)) {
155			return_ACPI_STATUS(status);
156		}
157	}
158
159	/*
160	 * Initialize ACPI Event handling (Fixed and General Purpose)
161	 *
162	 * Note1: We must have the hardware and events initialized before we can
163	 * execute any control methods safely. Any control method can require
164	 * ACPI hardware support, so the hardware must be fully initialized before
165	 * any method execution!
166	 *
167	 * Note2: Fixed events are initialized and enabled here. GPEs are
168	 * initialized, but cannot be enabled until after the hardware is
169	 * completely initialized (SCI and global_lock activated)
170	 */
171	if (!(flags & ACPI_NO_EVENT_INIT)) {
172		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
173				  "[Init] Initializing ACPI events\n"));
174
175		status = acpi_ev_initialize_events();
176		if (ACPI_FAILURE(status)) {
177			return_ACPI_STATUS(status);
178		}
179	}
180
181	/*
182	 * Install the SCI handler and Global Lock handler. This completes the
183	 * hardware initialization.
184	 */
185	if (!(flags & ACPI_NO_HANDLER_INIT)) {
186		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
187				  "[Init] Installing SCI/GL handlers\n"));
188
189		status = acpi_ev_install_xrupt_handlers();
190		if (ACPI_FAILURE(status)) {
191			return_ACPI_STATUS(status);
192		}
193	}
194
195	/*
196	 * Complete the GPE initialization for the GPE blocks defined in the FADT
197	 * (GPE block 0 and 1).
198	 *
199	 * Note1: This is where the _PRW methods are executed for the GPEs. These
200	 * methods can only be executed after the SCI and Global Lock handlers are
201	 * installed and initialized.
202	 *
203	 * Note2: Currently, there seems to be no need to run the _REG methods
204	 * before execution of the _PRW methods and enabling of the GPEs.
205	 */
206	if (!(flags & ACPI_NO_EVENT_INIT)) {
207		status = acpi_ev_install_fadt_gpes();
208		if (ACPI_FAILURE(status)) {
209			return (status);
210		}
211	}
212
213	return_ACPI_STATUS(status);
214}
215
216ACPI_EXPORT_SYMBOL(acpi_enable_subsystem)
217
218/*******************************************************************************
219 *
220 * FUNCTION:    acpi_initialize_objects
221 *
222 * PARAMETERS:  Flags           - Init/enable Options
223 *
224 * RETURN:      Status
225 *
226 * DESCRIPTION: Completes namespace initialization by initializing device
227 *              objects and executing AML code for Regions, buffers, etc.
228 *
229 ******************************************************************************/
230acpi_status acpi_initialize_objects(u32 flags)
231{
232	acpi_status status = AE_OK;
233
234	ACPI_FUNCTION_TRACE(acpi_initialize_objects);
235
236	/*
237	 * Run all _REG methods
238	 *
239	 * Note: Any objects accessed by the _REG methods will be automatically
240	 * initialized, even if they contain executable AML (see the call to
241	 * acpi_ns_initialize_objects below).
242	 */
243	if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
244		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
245				  "[Init] Executing _REG OpRegion methods\n"));
246
247		status = acpi_ev_initialize_op_regions();
248		if (ACPI_FAILURE(status)) {
249			return_ACPI_STATUS(status);
250		}
251	}
252
253	/*
254	 * Initialize the objects that remain uninitialized. This runs the
255	 * executable AML that may be part of the declaration of these objects:
256	 * operation_regions, buffer_fields, Buffers, and Packages.
257	 */
258	if (!(flags & ACPI_NO_OBJECT_INIT)) {
259		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
260				  "[Init] Completing Initialization of ACPI Objects\n"));
261
262		status = acpi_ns_initialize_objects();
263		if (ACPI_FAILURE(status)) {
264			return_ACPI_STATUS(status);
265		}
266	}
267
268	/*
269	 * Initialize all device objects in the namespace. This runs the device
270	 * _STA and _INI methods.
271	 */
272	if (!(flags & ACPI_NO_DEVICE_INIT)) {
273		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
274				  "[Init] Initializing ACPI Devices\n"));
275
276		status = acpi_ns_initialize_devices();
277		if (ACPI_FAILURE(status)) {
278			return_ACPI_STATUS(status);
279		}
280	}
281
282	/*
283	 * Empty the caches (delete the cached objects) on the assumption that
284	 * the table load filled them up more than they will be at runtime --
285	 * thus wasting non-paged memory.
286	 */
287	status = acpi_purge_cached_objects();
288
289	acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
290	return_ACPI_STATUS(status);
291}
292
293ACPI_EXPORT_SYMBOL(acpi_initialize_objects)
294
295/*******************************************************************************
296 *
297 * FUNCTION:    acpi_terminate
298 *
299 * PARAMETERS:  None
300 *
301 * RETURN:      Status
302 *
303 * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
304 *
305 ******************************************************************************/
306acpi_status acpi_terminate(void)
307{
308	acpi_status status;
309
310	ACPI_FUNCTION_TRACE(acpi_terminate);
311
312	/* Terminate the AML Debugger if present */
313
314	ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
315
316	/* Shutdown and free all resources */
317
318	acpi_ut_subsystem_shutdown();
319
320	/* Free the mutex objects */
321
322	acpi_ut_mutex_terminate();
323
324#ifdef ACPI_DEBUGGER
325
326	/* Shut down the debugger */
327
328	acpi_db_terminate();
329#endif
330
331	/* Now we can shutdown the OS-dependent layer */
332
333	status = acpi_os_terminate();
334	return_ACPI_STATUS(status);
335}
336
337ACPI_EXPORT_SYMBOL(acpi_terminate)
338#ifdef ACPI_FUTURE_USAGE
339/*******************************************************************************
340 *
341 * FUNCTION:    acpi_subsystem_status
342 *
343 * PARAMETERS:  None
344 *
345 * RETURN:      Status of the ACPI subsystem
346 *
347 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
348 *              before making any other calls, to ensure the subsystem
349 *              initialized successfully.
350 *
351 ******************************************************************************/
352acpi_status acpi_subsystem_status(void)
353{
354
355	if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
356		return (AE_OK);
357	} else {
358		return (AE_ERROR);
359	}
360}
361
362ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
363
364/*******************************************************************************
365 *
366 * FUNCTION:    acpi_get_system_info
367 *
368 * PARAMETERS:  out_buffer      - A buffer to receive the resources for the
369 *                                device
370 *
371 * RETURN:      Status          - the status of the call
372 *
373 * DESCRIPTION: This function is called to get information about the current
374 *              state of the ACPI subsystem.  It will return system information
375 *              in the out_buffer.
376 *
377 *              If the function fails an appropriate status will be returned
378 *              and the value of out_buffer is undefined.
379 *
380 ******************************************************************************/
381acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
382{
383	struct acpi_system_info *info_ptr;
384	acpi_status status;
385
386	ACPI_FUNCTION_TRACE(acpi_get_system_info);
387
388	/* Parameter validation */
389
390	status = acpi_ut_validate_buffer(out_buffer);
391	if (ACPI_FAILURE(status)) {
392		return_ACPI_STATUS(status);
393	}
394
395	/* Validate/Allocate/Clear caller buffer */
396
397	status =
398	    acpi_ut_initialize_buffer(out_buffer,
399				      sizeof(struct acpi_system_info));
400	if (ACPI_FAILURE(status)) {
401		return_ACPI_STATUS(status);
402	}
403
404	/*
405	 * Populate the return buffer
406	 */
407	info_ptr = (struct acpi_system_info *)out_buffer->pointer;
408
409	info_ptr->acpi_ca_version = ACPI_CA_VERSION;
410
411	/* System flags (ACPI capabilities) */
412
413	info_ptr->flags = ACPI_SYS_MODE_ACPI;
414
415	/* Timer resolution - 24 or 32 bits  */
416
417	if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) {
418		info_ptr->timer_resolution = 24;
419	} else {
420		info_ptr->timer_resolution = 32;
421	}
422
423	/* Clear the reserved fields */
424
425	info_ptr->reserved1 = 0;
426	info_ptr->reserved2 = 0;
427
428	/* Current debug levels */
429
430	info_ptr->debug_layer = acpi_dbg_layer;
431	info_ptr->debug_level = acpi_dbg_level;
432
433	return_ACPI_STATUS(AE_OK);
434}
435
436ACPI_EXPORT_SYMBOL(acpi_get_system_info)
437
438/*****************************************************************************
439 *
440 * FUNCTION:    acpi_install_initialization_handler
441 *
442 * PARAMETERS:  Handler             - Callback procedure
443 *              Function            - Not (currently) used, see below
444 *
445 * RETURN:      Status
446 *
447 * DESCRIPTION: Install an initialization handler
448 *
449 * TBD: When a second function is added, must save the Function also.
450 *
451 ****************************************************************************/
452acpi_status
453acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
454{
455
456	if (!handler) {
457		return (AE_BAD_PARAMETER);
458	}
459
460	if (acpi_gbl_init_handler) {
461		return (AE_ALREADY_EXISTS);
462	}
463
464	acpi_gbl_init_handler = handler;
465	return AE_OK;
466}
467
468ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
469#endif				/*  ACPI_FUTURE_USAGE  */
470/*****************************************************************************
471 *
472 * FUNCTION:    acpi_purge_cached_objects
473 *
474 * PARAMETERS:  None
475 *
476 * RETURN:      Status
477 *
478 * DESCRIPTION: Empty all caches (delete the cached objects)
479 *
480 ****************************************************************************/
481acpi_status acpi_purge_cached_objects(void)
482{
483	ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
484
485	(void)acpi_os_purge_cache(acpi_gbl_state_cache);
486	(void)acpi_os_purge_cache(acpi_gbl_operand_cache);
487	(void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
488	(void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
489	return_ACPI_STATUS(AE_OK);
490}
491
492ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)
493