Diff markup
1 /********************************************* 1 /******************************************************************************
2 * 2 *
3 * Module Name: utxface - External interfaces 3 * Module Name: utxface - External interfaces for "global" ACPI functions
4 * 4 *
5 ********************************************* 5 *****************************************************************************/
6 6
7 /* 7 /*
8 * Copyright (C) 2000 - 2007, R. Byron Moore 8 * Copyright (C) 2000 - 2007, R. Byron Moore
9 * All rights reserved. 9 * All rights reserved.
10 * 10 *
11 * Redistribution and use in source and binary 11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that t 12 * modification, are permitted provided that the following conditions
13 * are met: 13 * are met:
14 * 1. Redistributions of source code must reta 14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the 15 * notice, this list of conditions, and the following disclaimer,
16 * without modification. 16 * without modification.
17 * 2. Redistributions in binary form must repr 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANT 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution mu 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Discla 20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution. 21 * binary redistribution.
22 * 3. Neither the names of the above-listed co 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endor 23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prio 24 * from this software without specific prior written permission.
25 * 25 *
26 * Alternatively, this software may be distrib 26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation. 28 * Software Foundation.
29 * 29 *
30 * NO WARRANTY 30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTI 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCH 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECI 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PRO 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILI 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIG 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES. 41 * POSSIBILITY OF SUCH DAMAGES.
42 */ 42 */
43 43
44 #include <acpi/acpi.h> 44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h> 45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h> 46 #include <acpi/acnamesp.h>
47 #include <acpi/acdebug.h> 47 #include <acpi/acdebug.h>
48 48
49 #define _COMPONENT ACPI_UTILITIES 49 #define _COMPONENT ACPI_UTILITIES
50 ACPI_MODULE_NAME("utxface") 50 ACPI_MODULE_NAME("utxface")
51 51
52 /********************************************* 52 /*******************************************************************************
53 * 53 *
54 * FUNCTION: acpi_initialize_subsystem 54 * FUNCTION: acpi_initialize_subsystem
55 * 55 *
56 * PARAMETERS: None 56 * PARAMETERS: None
57 * 57 *
58 * RETURN: Status 58 * RETURN: Status
59 * 59 *
60 * DESCRIPTION: Initializes all global variabl 60 * DESCRIPTION: Initializes all global variables. This is the first function
61 * called, so any early initializ 61 * called, so any early initialization belongs here.
62 * 62 *
63 ********************************************* 63 ******************************************************************************/
64 acpi_status __init acpi_initialize_subsystem(v 64 acpi_status __init acpi_initialize_subsystem(void)
65 { 65 {
66 acpi_status status; 66 acpi_status status;
67 67
68 ACPI_FUNCTION_TRACE(acpi_initialize_su 68 ACPI_FUNCTION_TRACE(acpi_initialize_subsystem);
69 69
70 acpi_gbl_startup_flags = ACPI_SUBSYSTE 70 acpi_gbl_startup_flags = ACPI_SUBSYSTEM_INITIALIZE;
71 ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr 71 ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
72 72
73 /* Initialize the OS-Dependent layer * 73 /* Initialize the OS-Dependent layer */
74 74
75 status = acpi_os_initialize(); 75 status = acpi_os_initialize();
76 if (ACPI_FAILURE(status)) { 76 if (ACPI_FAILURE(status)) {
77 ACPI_EXCEPTION((AE_INFO, statu 77 ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization"));
78 return_ACPI_STATUS(status); 78 return_ACPI_STATUS(status);
79 } 79 }
80 80
81 /* Initialize all globals used by the 81 /* Initialize all globals used by the subsystem */
82 82
83 acpi_ut_init_globals(); 83 acpi_ut_init_globals();
84 84
85 /* Create the default mutex objects */ 85 /* Create the default mutex objects */
86 86
87 status = acpi_ut_mutex_initialize(); 87 status = acpi_ut_mutex_initialize();
88 if (ACPI_FAILURE(status)) { 88 if (ACPI_FAILURE(status)) {
89 ACPI_EXCEPTION((AE_INFO, statu 89 ACPI_EXCEPTION((AE_INFO, status,
90 "During Global 90 "During Global Mutex creation"));
91 return_ACPI_STATUS(status); 91 return_ACPI_STATUS(status);
92 } 92 }
93 93
94 /* 94 /*
95 * Initialize the namespace manager an 95 * Initialize the namespace manager and
96 * the root of the namespace tree 96 * the root of the namespace tree
97 */ 97 */
98 status = acpi_ns_root_initialize(); 98 status = acpi_ns_root_initialize();
99 if (ACPI_FAILURE(status)) { 99 if (ACPI_FAILURE(status)) {
100 ACPI_EXCEPTION((AE_INFO, statu 100 ACPI_EXCEPTION((AE_INFO, status,
101 "During Namesp 101 "During Namespace initialization"));
102 return_ACPI_STATUS(status); 102 return_ACPI_STATUS(status);
103 } 103 }
104 104
105 /* If configured, initialize the AML d 105 /* If configured, initialize the AML debugger */
106 106
107 ACPI_DEBUGGER_EXEC(status = acpi_db_in 107 ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
108 return_ACPI_STATUS(status); 108 return_ACPI_STATUS(status);
109 } 109 }
110 110
111 /********************************************* 111 /*******************************************************************************
112 * 112 *
113 * FUNCTION: acpi_enable_subsystem 113 * FUNCTION: acpi_enable_subsystem
114 * 114 *
115 * PARAMETERS: Flags - Init/enable 115 * PARAMETERS: Flags - Init/enable Options
116 * 116 *
117 * RETURN: Status 117 * RETURN: Status
118 * 118 *
119 * DESCRIPTION: Completes the subsystem initia 119 * DESCRIPTION: Completes the subsystem initialization including hardware.
120 * Puts system into ACPI mode if 120 * Puts system into ACPI mode if it isn't already.
121 * 121 *
122 ********************************************* 122 ******************************************************************************/
123 acpi_status acpi_enable_subsystem(u32 flags) 123 acpi_status acpi_enable_subsystem(u32 flags)
124 { 124 {
125 acpi_status status = AE_OK; 125 acpi_status status = AE_OK;
126 126
127 ACPI_FUNCTION_TRACE(acpi_enable_subsys 127 ACPI_FUNCTION_TRACE(acpi_enable_subsystem);
128 128
129 /* Enable ACPI mode */ 129 /* Enable ACPI mode */
130 130
131 if (!(flags & ACPI_NO_ACPI_ENABLE)) { 131 if (!(flags & ACPI_NO_ACPI_ENABLE)) {
132 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 132 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
133 "[Init] Goin 133 "[Init] Going into ACPI mode\n"));
134 134
135 acpi_gbl_original_mode = acpi_ 135 acpi_gbl_original_mode = acpi_hw_get_mode();
136 136
137 status = acpi_enable(); 137 status = acpi_enable();
138 if (ACPI_FAILURE(status)) { 138 if (ACPI_FAILURE(status)) {
139 ACPI_WARNING((AE_INFO, 139 ACPI_WARNING((AE_INFO, "AcpiEnable failed"));
140 return_ACPI_STATUS(sta 140 return_ACPI_STATUS(status);
141 } 141 }
142 } 142 }
143 143
144 /* 144 /*
145 * Install the default op_region handl 145 * Install the default op_region handlers. These are installed unless
146 * other handlers have already been in 146 * other handlers have already been installed via the
147 * install_address_space_handler inter 147 * install_address_space_handler interface.
148 */ 148 */
149 if (!(flags & ACPI_NO_ADDRESS_SPACE_IN 149 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
150 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 150 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
151 "[Init] Inst 151 "[Init] Installing default address space handlers\n"));
152 152
153 status = acpi_ev_install_regio 153 status = acpi_ev_install_region_handlers();
154 if (ACPI_FAILURE(status)) { 154 if (ACPI_FAILURE(status)) {
155 return_ACPI_STATUS(sta 155 return_ACPI_STATUS(status);
156 } 156 }
157 } 157 }
158 158
159 /* 159 /*
160 * Initialize ACPI Event handling (Fix 160 * Initialize ACPI Event handling (Fixed and General Purpose)
161 * 161 *
162 * Note1: We must have the hardware an 162 * Note1: We must have the hardware and events initialized before we can
163 * execute any control methods safely. 163 * execute any control methods safely. Any control method can require
164 * ACPI hardware support, so the hardw 164 * ACPI hardware support, so the hardware must be fully initialized before
165 * any method execution! 165 * any method execution!
166 * 166 *
167 * Note2: Fixed events are initialized 167 * Note2: Fixed events are initialized and enabled here. GPEs are
168 * initialized, but cannot be enabled 168 * initialized, but cannot be enabled until after the hardware is
169 * completely initialized (SCI and glo 169 * completely initialized (SCI and global_lock activated)
170 */ 170 */
171 if (!(flags & ACPI_NO_EVENT_INIT)) { 171 if (!(flags & ACPI_NO_EVENT_INIT)) {
172 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 172 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
173 "[Init] Init 173 "[Init] Initializing ACPI events\n"));
174 174
175 status = acpi_ev_initialize_ev 175 status = acpi_ev_initialize_events();
176 if (ACPI_FAILURE(status)) { 176 if (ACPI_FAILURE(status)) {
177 return_ACPI_STATUS(sta 177 return_ACPI_STATUS(status);
178 } 178 }
179 } 179 }
180 180
181 /* 181 /*
182 * Install the SCI handler and Global 182 * Install the SCI handler and Global Lock handler. This completes the
183 * hardware initialization. 183 * hardware initialization.
184 */ 184 */
185 if (!(flags & ACPI_NO_HANDLER_INIT)) { 185 if (!(flags & ACPI_NO_HANDLER_INIT)) {
186 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 186 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
187 "[Init] Inst 187 "[Init] Installing SCI/GL handlers\n"));
188 188
189 status = acpi_ev_install_xrupt 189 status = acpi_ev_install_xrupt_handlers();
190 if (ACPI_FAILURE(status)) { 190 if (ACPI_FAILURE(status)) {
191 return_ACPI_STATUS(sta 191 return_ACPI_STATUS(status);
192 } 192 }
193 } 193 }
194 194
195 /* 195 /*
196 * Complete the GPE initialization for 196 * Complete the GPE initialization for the GPE blocks defined in the FADT
197 * (GPE block 0 and 1). 197 * (GPE block 0 and 1).
198 * 198 *
199 * Note1: This is where the _PRW metho 199 * Note1: This is where the _PRW methods are executed for the GPEs. These
200 * methods can only be executed after 200 * methods can only be executed after the SCI and Global Lock handlers are
201 * installed and initialized. 201 * installed and initialized.
202 * 202 *
203 * Note2: Currently, there seems to be 203 * Note2: Currently, there seems to be no need to run the _REG methods
204 * before execution of the _PRW method 204 * before execution of the _PRW methods and enabling of the GPEs.
205 */ 205 */
206 if (!(flags & ACPI_NO_EVENT_INIT)) { 206 if (!(flags & ACPI_NO_EVENT_INIT)) {
207 status = acpi_ev_install_fadt_ 207 status = acpi_ev_install_fadt_gpes();
208 if (ACPI_FAILURE(status)) { 208 if (ACPI_FAILURE(status)) {
209 return (status); 209 return (status);
210 } 210 }
211 } 211 }
212 212
213 return_ACPI_STATUS(status); 213 return_ACPI_STATUS(status);
214 } 214 }
215 215
216 ACPI_EXPORT_SYMBOL(acpi_enable_subsystem) 216 ACPI_EXPORT_SYMBOL(acpi_enable_subsystem)
217 217
218 /********************************************* 218 /*******************************************************************************
219 * 219 *
220 * FUNCTION: acpi_initialize_objects 220 * FUNCTION: acpi_initialize_objects
221 * 221 *
222 * PARAMETERS: Flags - Init/enable 222 * PARAMETERS: Flags - Init/enable Options
223 * 223 *
224 * RETURN: Status 224 * RETURN: Status
225 * 225 *
226 * DESCRIPTION: Completes namespace initializa 226 * DESCRIPTION: Completes namespace initialization by initializing device
227 * objects and executing AML code 227 * objects and executing AML code for Regions, buffers, etc.
228 * 228 *
229 ********************************************* 229 ******************************************************************************/
230 acpi_status acpi_initialize_objects(u32 flags) 230 acpi_status acpi_initialize_objects(u32 flags)
231 { 231 {
232 acpi_status status = AE_OK; 232 acpi_status status = AE_OK;
233 233
234 ACPI_FUNCTION_TRACE(acpi_initialize_ob 234 ACPI_FUNCTION_TRACE(acpi_initialize_objects);
235 235
236 /* 236 /*
237 * Run all _REG methods 237 * Run all _REG methods
238 * 238 *
239 * Note: Any objects accessed by the _ 239 * Note: Any objects accessed by the _REG methods will be automatically
240 * initialized, even if they contain e 240 * initialized, even if they contain executable AML (see the call to
241 * acpi_ns_initialize_objects below). 241 * acpi_ns_initialize_objects below).
242 */ 242 */
243 if (!(flags & ACPI_NO_ADDRESS_SPACE_IN 243 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
244 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 244 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
245 "[Init] Exec 245 "[Init] Executing _REG OpRegion methods\n"));
246 246
247 status = acpi_ev_initialize_op 247 status = acpi_ev_initialize_op_regions();
248 if (ACPI_FAILURE(status)) { 248 if (ACPI_FAILURE(status)) {
249 return_ACPI_STATUS(sta 249 return_ACPI_STATUS(status);
250 } 250 }
251 } 251 }
252 252
253 /* 253 /*
254 * Initialize the objects that remain 254 * Initialize the objects that remain uninitialized. This runs the
255 * executable AML that may be part of 255 * executable AML that may be part of the declaration of these objects:
256 * operation_regions, buffer_fields, B 256 * operation_regions, buffer_fields, Buffers, and Packages.
257 */ 257 */
258 if (!(flags & ACPI_NO_OBJECT_INIT)) { 258 if (!(flags & ACPI_NO_OBJECT_INIT)) {
259 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 259 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
260 "[Init] Comp 260 "[Init] Completing Initialization of ACPI Objects\n"));
261 261
262 status = acpi_ns_initialize_ob 262 status = acpi_ns_initialize_objects();
263 if (ACPI_FAILURE(status)) { 263 if (ACPI_FAILURE(status)) {
264 return_ACPI_STATUS(sta 264 return_ACPI_STATUS(status);
265 } 265 }
266 } 266 }
267 267
268 /* 268 /*
269 * Initialize all device objects in th 269 * Initialize all device objects in the namespace. This runs the device
270 * _STA and _INI methods. 270 * _STA and _INI methods.
271 */ 271 */
272 if (!(flags & ACPI_NO_DEVICE_INIT)) { 272 if (!(flags & ACPI_NO_DEVICE_INIT)) {
273 ACPI_DEBUG_PRINT((ACPI_DB_EXEC 273 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
274 "[Init] Init 274 "[Init] Initializing ACPI Devices\n"));
275 275
276 status = acpi_ns_initialize_de 276 status = acpi_ns_initialize_devices();
277 if (ACPI_FAILURE(status)) { 277 if (ACPI_FAILURE(status)) {
278 return_ACPI_STATUS(sta 278 return_ACPI_STATUS(status);
279 } 279 }
280 } 280 }
281 281
282 /* 282 /*
283 * Empty the caches (delete the cached 283 * Empty the caches (delete the cached objects) on the assumption that
284 * the table load filled them up more 284 * the table load filled them up more than they will be at runtime --
285 * thus wasting non-paged memory. 285 * thus wasting non-paged memory.
286 */ 286 */
287 status = acpi_purge_cached_objects(); 287 status = acpi_purge_cached_objects();
288 288
289 acpi_gbl_startup_flags |= ACPI_INITIAL 289 acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
290 return_ACPI_STATUS(status); 290 return_ACPI_STATUS(status);
291 } 291 }
292 292
293 ACPI_EXPORT_SYMBOL(acpi_initialize_objects) 293 ACPI_EXPORT_SYMBOL(acpi_initialize_objects)
294 294
295 /********************************************* 295 /*******************************************************************************
296 * 296 *
297 * FUNCTION: acpi_terminate 297 * FUNCTION: acpi_terminate
298 * 298 *
299 * PARAMETERS: None 299 * PARAMETERS: None
300 * 300 *
301 * RETURN: Status 301 * RETURN: Status
302 * 302 *
303 * DESCRIPTION: Shutdown the ACPI subsystem. 303 * DESCRIPTION: Shutdown the ACPI subsystem. Release all resources.
304 * 304 *
305 ********************************************* 305 ******************************************************************************/
306 acpi_status acpi_terminate(void) 306 acpi_status acpi_terminate(void)
307 { 307 {
308 acpi_status status; 308 acpi_status status;
309 309
310 ACPI_FUNCTION_TRACE(acpi_terminate); 310 ACPI_FUNCTION_TRACE(acpi_terminate);
311 311
312 /* Terminate the AML Debugger if prese 312 /* Terminate the AML Debugger if present */
313 313
314 ACPI_DEBUGGER_EXEC(acpi_gbl_db_termina 314 ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
315 315
316 /* Shutdown and free all resources */ 316 /* Shutdown and free all resources */
317 317
318 acpi_ut_subsystem_shutdown(); 318 acpi_ut_subsystem_shutdown();
319 319
320 /* Free the mutex objects */ 320 /* Free the mutex objects */
321 321
322 acpi_ut_mutex_terminate(); 322 acpi_ut_mutex_terminate();
323 323
324 #ifdef ACPI_DEBUGGER 324 #ifdef ACPI_DEBUGGER
325 325
326 /* Shut down the debugger */ 326 /* Shut down the debugger */
327 327
328 acpi_db_terminate(); 328 acpi_db_terminate();
329 #endif 329 #endif
330 330
331 /* Now we can shutdown the OS-dependen 331 /* Now we can shutdown the OS-dependent layer */
332 332
333 status = acpi_os_terminate(); 333 status = acpi_os_terminate();
334 return_ACPI_STATUS(status); 334 return_ACPI_STATUS(status);
335 } 335 }
336 336
337 ACPI_EXPORT_SYMBOL(acpi_terminate) 337 ACPI_EXPORT_SYMBOL(acpi_terminate)
338 #ifdef ACPI_FUTURE_USAGE 338 #ifdef ACPI_FUTURE_USAGE
339 /********************************************* 339 /*******************************************************************************
340 * 340 *
341 * FUNCTION: acpi_subsystem_status 341 * FUNCTION: acpi_subsystem_status
342 * 342 *
343 * PARAMETERS: None 343 * PARAMETERS: None
344 * 344 *
345 * RETURN: Status of the ACPI subsystem 345 * RETURN: Status of the ACPI subsystem
346 * 346 *
347 * DESCRIPTION: Other drivers that use the ACP 347 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
348 * before making any other calls, 348 * before making any other calls, to ensure the subsystem
349 * initialized successfully. 349 * initialized successfully.
350 * 350 *
351 ********************************************* 351 ******************************************************************************/
352 acpi_status acpi_subsystem_status(void) 352 acpi_status acpi_subsystem_status(void)
353 { 353 {
354 354
355 if (acpi_gbl_startup_flags & ACPI_INIT 355 if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
356 return (AE_OK); 356 return (AE_OK);
357 } else { 357 } else {
358 return (AE_ERROR); 358 return (AE_ERROR);
359 } 359 }
360 } 360 }
361 361
362 ACPI_EXPORT_SYMBOL(acpi_subsystem_status) 362 ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
363 363
364 /********************************************* 364 /*******************************************************************************
365 * 365 *
366 * FUNCTION: acpi_get_system_info 366 * FUNCTION: acpi_get_system_info
367 * 367 *
368 * PARAMETERS: out_buffer - A buffer to 368 * PARAMETERS: out_buffer - A buffer to receive the resources for the
369 * device 369 * device
370 * 370 *
371 * RETURN: Status - the status o 371 * RETURN: Status - the status of the call
372 * 372 *
373 * DESCRIPTION: This function is called to get 373 * DESCRIPTION: This function is called to get information about the current
374 * state of the ACPI subsystem. 374 * state of the ACPI subsystem. It will return system information
375 * in the out_buffer. 375 * in the out_buffer.
376 * 376 *
377 * If the function fails an appro 377 * If the function fails an appropriate status will be returned
378 * and the value of out_buffer is 378 * and the value of out_buffer is undefined.
379 * 379 *
380 ********************************************* 380 ******************************************************************************/
381 acpi_status acpi_get_system_info(struct acpi_b 381 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
382 { 382 {
383 struct acpi_system_info *info_ptr; 383 struct acpi_system_info *info_ptr;
384 acpi_status status; 384 acpi_status status;
385 385
386 ACPI_FUNCTION_TRACE(acpi_get_system_in 386 ACPI_FUNCTION_TRACE(acpi_get_system_info);
387 387
388 /* Parameter validation */ 388 /* Parameter validation */
389 389
390 status = acpi_ut_validate_buffer(out_b 390 status = acpi_ut_validate_buffer(out_buffer);
391 if (ACPI_FAILURE(status)) { 391 if (ACPI_FAILURE(status)) {
392 return_ACPI_STATUS(status); 392 return_ACPI_STATUS(status);
393 } 393 }
394 394
395 /* Validate/Allocate/Clear caller buff 395 /* Validate/Allocate/Clear caller buffer */
396 396
397 status = 397 status =
398 acpi_ut_initialize_buffer(out_buff 398 acpi_ut_initialize_buffer(out_buffer,
399 sizeof(s 399 sizeof(struct acpi_system_info));
400 if (ACPI_FAILURE(status)) { 400 if (ACPI_FAILURE(status)) {
401 return_ACPI_STATUS(status); 401 return_ACPI_STATUS(status);
402 } 402 }
403 403
404 /* 404 /*
405 * Populate the return buffer 405 * Populate the return buffer
406 */ 406 */
407 info_ptr = (struct acpi_system_info *) 407 info_ptr = (struct acpi_system_info *)out_buffer->pointer;
408 408
409 info_ptr->acpi_ca_version = ACPI_CA_VE 409 info_ptr->acpi_ca_version = ACPI_CA_VERSION;
410 410
411 /* System flags (ACPI capabilities) */ 411 /* System flags (ACPI capabilities) */
412 412
413 info_ptr->flags = ACPI_SYS_MODE_ACPI; 413 info_ptr->flags = ACPI_SYS_MODE_ACPI;
414 414
415 /* Timer resolution - 24 or 32 bits * 415 /* Timer resolution - 24 or 32 bits */
416 416
417 if (acpi_gbl_FADT.flags & ACPI_FADT_32 417 if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) {
418 info_ptr->timer_resolution = 2 418 info_ptr->timer_resolution = 24;
419 } else { 419 } else {
420 info_ptr->timer_resolution = 3 420 info_ptr->timer_resolution = 32;
421 } 421 }
422 422
423 /* Clear the reserved fields */ 423 /* Clear the reserved fields */
424 424
425 info_ptr->reserved1 = 0; 425 info_ptr->reserved1 = 0;
426 info_ptr->reserved2 = 0; 426 info_ptr->reserved2 = 0;
427 427
428 /* Current debug levels */ 428 /* Current debug levels */
429 429
430 info_ptr->debug_layer = acpi_dbg_layer 430 info_ptr->debug_layer = acpi_dbg_layer;
431 info_ptr->debug_level = acpi_dbg_level 431 info_ptr->debug_level = acpi_dbg_level;
432 432
433 return_ACPI_STATUS(AE_OK); 433 return_ACPI_STATUS(AE_OK);
434 } 434 }
435 435
436 ACPI_EXPORT_SYMBOL(acpi_get_system_info) 436 ACPI_EXPORT_SYMBOL(acpi_get_system_info)
437 437
438 /********************************************* 438 /*****************************************************************************
439 * 439 *
440 * FUNCTION: acpi_install_initialization_ha 440 * FUNCTION: acpi_install_initialization_handler
441 * 441 *
442 * PARAMETERS: Handler - Callback 442 * PARAMETERS: Handler - Callback procedure
443 * Function - Not (cur 443 * Function - Not (currently) used, see below
444 * 444 *
445 * RETURN: Status 445 * RETURN: Status
446 * 446 *
447 * DESCRIPTION: Install an initialization hand 447 * DESCRIPTION: Install an initialization handler
448 * 448 *
449 * TBD: When a second function is added, must 449 * TBD: When a second function is added, must save the Function also.
450 * 450 *
451 ********************************************* 451 ****************************************************************************/
452 acpi_status 452 acpi_status
453 acpi_install_initialization_handler(acpi_init_ 453 acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
454 { 454 {
455 455
456 if (!handler) { 456 if (!handler) {
457 return (AE_BAD_PARAMETER); 457 return (AE_BAD_PARAMETER);
458 } 458 }
459 459
460 if (acpi_gbl_init_handler) { 460 if (acpi_gbl_init_handler) {
461 return (AE_ALREADY_EXISTS); 461 return (AE_ALREADY_EXISTS);
462 } 462 }
463 463
464 acpi_gbl_init_handler = handler; 464 acpi_gbl_init_handler = handler;
465 return AE_OK; 465 return AE_OK;
466 } 466 }
467 467
468 ACPI_EXPORT_SYMBOL(acpi_install_initialization 468 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
469 #endif /* ACPI_FUTUR 469 #endif /* ACPI_FUTURE_USAGE */
470 /********************************************* 470 /*****************************************************************************
471 * 471 *
472 * FUNCTION: acpi_purge_cached_objects 472 * FUNCTION: acpi_purge_cached_objects
473 * 473 *
474 * PARAMETERS: None 474 * PARAMETERS: None
475 * 475 *
476 * RETURN: Status 476 * RETURN: Status
477 * 477 *
478 * DESCRIPTION: Empty all caches (delete the c 478 * DESCRIPTION: Empty all caches (delete the cached objects)
479 * 479 *
480 ********************************************* 480 ****************************************************************************/
481 acpi_status acpi_purge_cached_objects(void) 481 acpi_status acpi_purge_cached_objects(void)
482 { 482 {
483 ACPI_FUNCTION_TRACE(acpi_purge_cached_ 483 ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
484 484
485 (void)acpi_os_purge_cache(acpi_gbl_sta 485 (void)acpi_os_purge_cache(acpi_gbl_state_cache);
486 (void)acpi_os_purge_cache(acpi_gbl_ope 486 (void)acpi_os_purge_cache(acpi_gbl_operand_cache);
487 (void)acpi_os_purge_cache(acpi_gbl_ps_ 487 (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
488 (void)acpi_os_purge_cache(acpi_gbl_ps_ 488 (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
489 return_ACPI_STATUS(AE_OK); 489 return_ACPI_STATUS(AE_OK);
490 } 490 }
491 491
492 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects) 492 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)
493 493
|
This page was automatically generated by the
LXR engine.
|