ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utxface.c @ 912:dd42cdb0ab89

[IA64] Build blktap2 driver by default in x86 builds.

add CONFIG_XEN_BLKDEV_TAP2=y to buildconfigs/linux-defconfig_xen_ia64.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Mon Jun 29 12:09:16 2009 +0900 (2009-06-29)
parents 831230e53067
children
line source
1 /******************************************************************************
2 *
3 * Module Name: utxface - External interfaces for "global" ACPI functions
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2006, 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 */
44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/acdebug.h>
49 #define _COMPONENT ACPI_UTILITIES
50 ACPI_MODULE_NAME("utxface")
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 ******************************************************************************/
64 acpi_status acpi_initialize_subsystem(void)
65 {
66 acpi_status status;
68 ACPI_FUNCTION_TRACE(acpi_initialize_subsystem);
70 ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
72 /* Initialize the OS-Dependent layer */
74 status = acpi_os_initialize();
75 if (ACPI_FAILURE(status)) {
76 ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization"));
77 return_ACPI_STATUS(status);
78 }
80 /* Initialize all globals used by the subsystem */
82 acpi_ut_init_globals();
84 /* Create the default mutex objects */
86 status = acpi_ut_mutex_initialize();
87 if (ACPI_FAILURE(status)) {
88 ACPI_EXCEPTION((AE_INFO, status,
89 "During Global Mutex creation"));
90 return_ACPI_STATUS(status);
91 }
93 /*
94 * Initialize the namespace manager and
95 * the root of the namespace tree
96 */
97 status = acpi_ns_root_initialize();
98 if (ACPI_FAILURE(status)) {
99 ACPI_EXCEPTION((AE_INFO, status,
100 "During Namespace initialization"));
101 return_ACPI_STATUS(status);
102 }
104 /* If configured, initialize the AML debugger */
106 ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
107 return_ACPI_STATUS(status);
108 }
110 ACPI_EXPORT_SYMBOL(acpi_initialize_subsystem)
112 /*******************************************************************************
113 *
114 * FUNCTION: acpi_enable_subsystem
115 *
116 * PARAMETERS: Flags - Init/enable Options
117 *
118 * RETURN: Status
119 *
120 * DESCRIPTION: Completes the subsystem initialization including hardware.
121 * Puts system into ACPI mode if it isn't already.
122 *
123 ******************************************************************************/
124 acpi_status acpi_enable_subsystem(u32 flags)
125 {
126 acpi_status status = AE_OK;
128 ACPI_FUNCTION_TRACE(acpi_enable_subsystem);
130 /*
131 * We must initialize the hardware before we can enable ACPI.
132 * The values from the FADT are validated here.
133 */
134 if (!(flags & ACPI_NO_HARDWARE_INIT)) {
135 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
136 "[Init] Initializing ACPI hardware\n"));
138 status = acpi_hw_initialize();
139 if (ACPI_FAILURE(status)) {
140 return_ACPI_STATUS(status);
141 }
142 }
144 /* Enable ACPI mode */
146 if (!(flags & ACPI_NO_ACPI_ENABLE)) {
147 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
148 "[Init] Going into ACPI mode\n"));
150 acpi_gbl_original_mode = acpi_hw_get_mode();
152 status = acpi_enable();
153 if (ACPI_FAILURE(status)) {
154 ACPI_WARNING((AE_INFO, "AcpiEnable failed"));
155 return_ACPI_STATUS(status);
156 }
157 }
159 /*
160 * Install the default op_region handlers. These are installed unless
161 * other handlers have already been installed via the
162 * install_address_space_handler interface.
163 */
164 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
165 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
166 "[Init] Installing default address space handlers\n"));
168 status = acpi_ev_install_region_handlers();
169 if (ACPI_FAILURE(status)) {
170 return_ACPI_STATUS(status);
171 }
172 }
174 /*
175 * Initialize ACPI Event handling (Fixed and General Purpose)
176 *
177 * Note1: We must have the hardware and events initialized before we can
178 * execute any control methods safely. Any control method can require
179 * ACPI hardware support, so the hardware must be fully initialized before
180 * any method execution!
181 *
182 * Note2: Fixed events are initialized and enabled here. GPEs are
183 * initialized, but cannot be enabled until after the hardware is
184 * completely initialized (SCI and global_lock activated)
185 */
186 if (!(flags & ACPI_NO_EVENT_INIT)) {
187 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
188 "[Init] Initializing ACPI events\n"));
190 status = acpi_ev_initialize_events();
191 if (ACPI_FAILURE(status)) {
192 return_ACPI_STATUS(status);
193 }
194 }
196 /*
197 * Install the SCI handler and Global Lock handler. This completes the
198 * hardware initialization.
199 */
200 if (!(flags & ACPI_NO_HANDLER_INIT)) {
201 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
202 "[Init] Installing SCI/GL handlers\n"));
204 status = acpi_ev_install_xrupt_handlers();
205 if (ACPI_FAILURE(status)) {
206 return_ACPI_STATUS(status);
207 }
208 }
210 /*
211 * Complete the GPE initialization for the GPE blocks defined in the FADT
212 * (GPE block 0 and 1).
213 *
214 * Note1: This is where the _PRW methods are executed for the GPEs. These
215 * methods can only be executed after the SCI and Global Lock handlers are
216 * installed and initialized.
217 *
218 * Note2: Currently, there seems to be no need to run the _REG methods
219 * before execution of the _PRW methods and enabling of the GPEs.
220 */
221 if (!(flags & ACPI_NO_EVENT_INIT)) {
222 status = acpi_ev_install_fadt_gpes();
223 if (ACPI_FAILURE(status)) {
224 return (status);
225 }
226 }
228 return_ACPI_STATUS(status);
229 }
231 ACPI_EXPORT_SYMBOL(acpi_enable_subsystem)
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 ******************************************************************************/
245 acpi_status acpi_initialize_objects(u32 flags)
246 {
247 acpi_status status = AE_OK;
249 ACPI_FUNCTION_TRACE(acpi_initialize_objects);
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"));
262 status = acpi_ev_initialize_op_regions();
263 if (ACPI_FAILURE(status)) {
264 return_ACPI_STATUS(status);
265 }
266 }
268 /*
269 * Initialize the objects that remain uninitialized. This runs the
270 * executable AML that may be part of the declaration of these objects:
271 * operation_regions, buffer_fields, Buffers, and Packages.
272 */
273 if (!(flags & ACPI_NO_OBJECT_INIT)) {
274 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
275 "[Init] Completing Initialization of ACPI Objects\n"));
277 status = acpi_ns_initialize_objects();
278 if (ACPI_FAILURE(status)) {
279 return_ACPI_STATUS(status);
280 }
281 }
283 /*
284 * Initialize all device objects in the namespace. This runs the device
285 * _STA and _INI methods.
286 */
287 if (!(flags & ACPI_NO_DEVICE_INIT)) {
288 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
289 "[Init] Initializing ACPI Devices\n"));
291 status = acpi_ns_initialize_devices();
292 if (ACPI_FAILURE(status)) {
293 return_ACPI_STATUS(status);
294 }
295 }
297 /*
298 * Empty the caches (delete the cached objects) on the assumption that
299 * the table load filled them up more than they will be at runtime --
300 * thus wasting non-paged memory.
301 */
302 status = acpi_purge_cached_objects();
304 acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
305 return_ACPI_STATUS(status);
306 }
308 ACPI_EXPORT_SYMBOL(acpi_initialize_objects)
310 /*******************************************************************************
311 *
312 * FUNCTION: acpi_terminate
313 *
314 * PARAMETERS: None
315 *
316 * RETURN: Status
317 *
318 * DESCRIPTION: Shutdown the ACPI subsystem. Release all resources.
319 *
320 ******************************************************************************/
321 acpi_status acpi_terminate(void)
322 {
323 acpi_status status;
325 ACPI_FUNCTION_TRACE(acpi_terminate);
327 /* Terminate the AML Debugger if present */
329 ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
331 /* Shutdown and free all resources */
333 acpi_ut_subsystem_shutdown();
335 /* Free the mutex objects */
337 acpi_ut_mutex_terminate();
339 #ifdef ACPI_DEBUGGER
341 /* Shut down the debugger */
343 acpi_db_terminate();
344 #endif
346 /* Now we can shutdown the OS-dependent layer */
348 status = acpi_os_terminate();
349 return_ACPI_STATUS(status);
350 }
352 ACPI_EXPORT_SYMBOL(acpi_terminate)
354 #ifdef ACPI_FUTURE_USAGE
355 /*******************************************************************************
356 *
357 * FUNCTION: acpi_subsystem_status
358 *
359 * PARAMETERS: None
360 *
361 * RETURN: Status of the ACPI subsystem
362 *
363 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
364 * before making any other calls, to ensure the subsystem
365 * initialized successfully.
366 *
367 ******************************************************************************/
368 acpi_status acpi_subsystem_status(void)
369 {
371 if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
372 return (AE_OK);
373 } else {
374 return (AE_ERROR);
375 }
376 }
378 ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
380 /*******************************************************************************
381 *
382 * FUNCTION: acpi_get_system_info
383 *
384 * PARAMETERS: out_buffer - A buffer to receive the resources for the
385 * device
386 *
387 * RETURN: Status - the status of the call
388 *
389 * DESCRIPTION: This function is called to get information about the current
390 * state of the ACPI subsystem. It will return system information
391 * in the out_buffer.
392 *
393 * If the function fails an appropriate status will be returned
394 * and the value of out_buffer is undefined.
395 *
396 ******************************************************************************/
397 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
398 {
399 struct acpi_system_info *info_ptr;
400 acpi_status status;
401 u32 i;
403 ACPI_FUNCTION_TRACE(acpi_get_system_info);
405 /* Parameter validation */
407 status = acpi_ut_validate_buffer(out_buffer);
408 if (ACPI_FAILURE(status)) {
409 return_ACPI_STATUS(status);
410 }
412 /* Validate/Allocate/Clear caller buffer */
414 status =
415 acpi_ut_initialize_buffer(out_buffer,
416 sizeof(struct acpi_system_info));
417 if (ACPI_FAILURE(status)) {
418 return_ACPI_STATUS(status);
419 }
421 /*
422 * Populate the return buffer
423 */
424 info_ptr = (struct acpi_system_info *)out_buffer->pointer;
426 info_ptr->acpi_ca_version = ACPI_CA_VERSION;
428 /* System flags (ACPI capabilities) */
430 info_ptr->flags = ACPI_SYS_MODE_ACPI;
432 /* Timer resolution - 24 or 32 bits */
434 if (!acpi_gbl_FADT) {
435 info_ptr->timer_resolution = 0;
436 } else if (acpi_gbl_FADT->tmr_val_ext == 0) {
437 info_ptr->timer_resolution = 24;
438 } else {
439 info_ptr->timer_resolution = 32;
440 }
442 /* Clear the reserved fields */
444 info_ptr->reserved1 = 0;
445 info_ptr->reserved2 = 0;
447 /* Current debug levels */
449 info_ptr->debug_layer = acpi_dbg_layer;
450 info_ptr->debug_level = acpi_dbg_level;
452 /* Current status of the ACPI tables, per table type */
454 info_ptr->num_table_types = ACPI_TABLE_ID_MAX + 1;
455 for (i = 0; i < (ACPI_TABLE_ID_MAX + 1); i++) {
456 info_ptr->table_info[i].count = acpi_gbl_table_lists[i].count;
457 }
459 return_ACPI_STATUS(AE_OK);
460 }
462 ACPI_EXPORT_SYMBOL(acpi_get_system_info)
464 /*****************************************************************************
465 *
466 * FUNCTION: acpi_install_initialization_handler
467 *
468 * PARAMETERS: Handler - Callback procedure
469 * Function - Not (currently) used, see below
470 *
471 * RETURN: Status
472 *
473 * DESCRIPTION: Install an initialization handler
474 *
475 * TBD: When a second function is added, must save the Function also.
476 *
477 ****************************************************************************/
478 acpi_status
479 acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
480 {
482 if (!handler) {
483 return (AE_BAD_PARAMETER);
484 }
486 if (acpi_gbl_init_handler) {
487 return (AE_ALREADY_EXISTS);
488 }
490 acpi_gbl_init_handler = handler;
491 return AE_OK;
492 }
494 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
495 #endif /* ACPI_FUTURE_USAGE */
497 /*****************************************************************************
498 *
499 * FUNCTION: acpi_purge_cached_objects
500 *
501 * PARAMETERS: None
502 *
503 * RETURN: Status
504 *
505 * DESCRIPTION: Empty all caches (delete the cached objects)
506 *
507 ****************************************************************************/
508 acpi_status acpi_purge_cached_objects(void)
509 {
510 ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
512 (void)acpi_os_purge_cache(acpi_gbl_state_cache);
513 (void)acpi_os_purge_cache(acpi_gbl_operand_cache);
514 (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
515 (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
516 return_ACPI_STATUS(AE_OK);
517 }
519 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)