?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: Fix sparse warnings
[linux-2.6/kvm.git] / drivers / acpi / tables / tbxface.c
blob81937003fd538c5b480418da6056c620294f22a2
1 /******************************************************************************
2 *
3 * Module Name: tbxface - Public interfaces to the ACPI subsystem
4 * ACPI table oriented interfaces
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2007, R. Byron Moore
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45 #include <acpi/acpi.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/actables.h>
48
49 #define _COMPONENT ACPI_TABLES
50 ACPI_MODULE_NAME("tbxface")
51
52 /* Local prototypes */
53 static acpi_status acpi_tb_load_namespace(void);
54
55 /*******************************************************************************
56 *
57 * FUNCTION: acpi_allocate_root_table
58 *
59 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of
60 * struct acpi_table_desc structures
61 *
62 * RETURN: Status
63 *
64 * DESCRIPTION: Allocate a root table array. Used by i_aSL compiler and
65 * acpi_initialize_tables.
66 *
67 ******************************************************************************/
68
69 acpi_status acpi_allocate_root_table(u32 initial_table_count)
70 {
71
72 acpi_gbl_root_table_list.size = initial_table_count;
73 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
74
75 return (acpi_tb_resize_root_table_list());
76 }
77
78 /*******************************************************************************
79 *
80 * FUNCTION: acpi_initialize_tables
81 *
82 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated
83 * struct acpi_table_desc structures. If NULL, the
84 * array is dynamically allocated.
85 * initial_table_count - Size of initial_table_array, in number of
86 * struct acpi_table_desc structures
87 * allow_realloc - Flag to tell Table Manager if resize of
88 * pre-allocated array is allowed. Ignored
89 * if initial_table_array is NULL.
90 *
91 * RETURN: Status
92 *
93 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
94 *
95 * NOTE: Allows static allocation of the initial table array in order
96 * to avoid the use of dynamic memory in confined environments
97 * such as the kernel boot sequence where it may not be available.
98 *
99 * If the host OS memory managers are initialized, use NULL for
100 * initial_table_array, and the table will be dynamically allocated.
101 *
102 ******************************************************************************/
103
104 acpi_status __init
105 acpi_initialize_tables(struct acpi_table_desc * initial_table_array,
106 u32 initial_table_count, u8 allow_resize)
107 {
108 acpi_physical_address rsdp_address;
109 acpi_status status;
110
111 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
112
113 /*
114 * Set up the Root Table Array
115 * Allocate the table array if requested
116 */
117 if (!initial_table_array) {
118 status = acpi_allocate_root_table(initial_table_count);
119 if (ACPI_FAILURE(status)) {
120 return_ACPI_STATUS(status);
121 }
122 } else {
123 /* Root Table Array has been statically allocated by the host */
124
125 ACPI_MEMSET(initial_table_array, 0,
126 initial_table_count *
127 sizeof(struct acpi_table_desc));
128
129 acpi_gbl_root_table_list.tables = initial_table_array;
130 acpi_gbl_root_table_list.size = initial_table_count;
131 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
132 if (allow_resize) {
133 acpi_gbl_root_table_list.flags |=
134 ACPI_ROOT_ALLOW_RESIZE;
135 }
136 }
137
138 /* Get the address of the RSDP */
139
140 rsdp_address = acpi_os_get_root_pointer();
141 if (!rsdp_address) {
142 return_ACPI_STATUS(AE_NOT_FOUND);
143 }
144
145 /*
146 * Get the root table (RSDT or XSDT) and extract all entries to the local
147 * Root Table Array. This array contains the information of the RSDT/XSDT
148 * in a common, more useable format.
149 */
150 status =
151 acpi_tb_parse_root_table(rsdp_address, ACPI_TABLE_ORIGIN_MAPPED);
152 return_ACPI_STATUS(status);
153 }
154
155 /*******************************************************************************
156 *
157 * FUNCTION: acpi_reallocate_root_table
158 *
159 * PARAMETERS: None
160 *
161 * RETURN: Status
162 *
163 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
164 * root list from the previously provided scratch area. Should
165 * be called once dynamic memory allocation is available in the
166 * kernel
167 *
168 ******************************************************************************/
169 acpi_status acpi_reallocate_root_table(void)
170 {
171 struct acpi_table_desc *tables;
172 acpi_size new_size;
173
174 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
175
176 /*
177 * Only reallocate the root table if the host provided a static buffer
178 * for the table array in the call to acpi_initialize_tables.
179 */
180 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
181 return_ACPI_STATUS(AE_SUPPORT);
182 }
183
184 new_size =
185 (acpi_gbl_root_table_list.count +
186 ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc);
187
188 /* Create new array and copy the old array */
189
190 tables = ACPI_ALLOCATE_ZEROED(new_size);
191 if (!tables) {
192 return_ACPI_STATUS(AE_NO_MEMORY);
193 }
194
195 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
196
197 acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
198 acpi_gbl_root_table_list.tables = tables;
199 acpi_gbl_root_table_list.flags =
200 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
201
202 return_ACPI_STATUS(AE_OK);
203 }
204 /*******************************************************************************
205 *
206 * FUNCTION: acpi_load_table
207 *
208 * PARAMETERS: table_ptr - pointer to a buffer containing the entire
209 * table to be loaded
210 *
211 * RETURN: Status
212 *
213 * DESCRIPTION: This function is called to load a table from the caller's
214 * buffer. The buffer must contain an entire ACPI Table including
215 * a valid header. The header fields will be verified, and if it
216 * is determined that the table is invalid, the call will fail.
217 *
218 ******************************************************************************/
219 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
220 {
221 acpi_status status;
222 acpi_native_uint table_index;
223 struct acpi_table_desc table_desc;
224
225 if (!table_ptr)
226 return AE_BAD_PARAMETER;
227
228 ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
229 table_desc.pointer = table_ptr;
230 table_desc.length = table_ptr->length;
231 table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN;
232
233 /*
234 * Install the new table into the local data structures
235 */
236 status = acpi_tb_add_table(&table_desc, &table_index);
237 if (ACPI_FAILURE(status)) {
238 return status;
239 }
240 status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
241 return status;
242 }
243
244 ACPI_EXPORT_SYMBOL(acpi_load_table)
245
246 /******************************************************************************
247 *
248 * FUNCTION: acpi_get_table_header
249 *
250 * PARAMETERS: Signature - ACPI signature of needed table
251 * Instance - Which instance (for SSDTs)
252 * out_table_header - The pointer to the table header to fill
253 *
254 * RETURN: Status and pointer to mapped table header
255 *
256 * DESCRIPTION: Finds an ACPI table header.
257 *
258 * NOTE: Caller is responsible in unmapping the header with
259 * acpi_os_unmap_memory
260 *
261 *****************************************************************************/
262 acpi_status
263 acpi_get_table_header(char *signature,
264 acpi_native_uint instance,
265 struct acpi_table_header *out_table_header)
266 {
267 acpi_native_uint i;
268 acpi_native_uint j;
269 struct acpi_table_header *header;
270
271 /* Parameter validation */
272
273 if (!signature || !out_table_header) {
274 return (AE_BAD_PARAMETER);
275 }
276
277 /*
278 * Walk the root table list
279 */
280 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
281 if (!ACPI_COMPARE_NAME
282 (&(acpi_gbl_root_table_list.tables[i].signature),
283 signature)) {
284 continue;
285 }
286
287 if (++j < instance) {
288 continue;
289 }
290
291 if (!acpi_gbl_root_table_list.tables[i].pointer) {
292 if ((acpi_gbl_root_table_list.tables[i].
293 flags & ACPI_TABLE_ORIGIN_MASK) ==
294 ACPI_TABLE_ORIGIN_MAPPED) {
295 header =
296 acpi_os_map_memory(acpi_gbl_root_table_list.
297 tables[i].address,
298 sizeof(struct
299 acpi_table_header));
300 if (!header) {
301 return AE_NO_MEMORY;
302 }
303 ACPI_MEMCPY(out_table_header, header,
304 sizeof(struct acpi_table_header));
305 acpi_os_unmap_memory(header,
306 sizeof(struct
307 acpi_table_header));
308 } else {
309 return AE_NOT_FOUND;
310 }
311 } else {
312 ACPI_MEMCPY(out_table_header,
313 acpi_gbl_root_table_list.tables[i].pointer,
314 sizeof(struct acpi_table_header));
315 }
316 return (AE_OK);
317 }
318
319 return (AE_NOT_FOUND);
320 }
321
322 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
323
324
325 /******************************************************************************
326 *
327 * FUNCTION: acpi_unload_table_id
328 *
329 * PARAMETERS: id - Owner ID of the table to be removed.
330 *
331 * RETURN: Status
332 *
333 * DESCRIPTION: This routine is used to force the unload of a table (by id)
334 *
335 ******************************************************************************/
336 acpi_status acpi_unload_table_id(acpi_owner_id id)
337 {
338 int i;
339 acpi_status status = AE_NOT_EXIST;
340
341 ACPI_FUNCTION_TRACE(acpi_unload_table);
342
343 /* Find table from the requested type list */
344 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
345 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
346 continue;
347 }
348 /*
349 * Delete all namespace objects owned by this table. Note that these
350 * objects can appear anywhere in the namespace by virtue of the AML
351 * "Scope" operator. Thus, we need to track ownership by an ID, not
352 * simply a position within the hierarchy
353 */
354 acpi_tb_delete_namespace_by_owner(i);
355 acpi_tb_release_owner_id(i);
356 acpi_tb_set_table_loaded_flag(i, FALSE);
357 }
358 return_ACPI_STATUS(status);
359 }
360
361 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
362
363 /*******************************************************************************
364 *
365 * FUNCTION: acpi_get_table
366 *
367 * PARAMETERS: Signature - ACPI signature of needed table
368 * Instance - Which instance (for SSDTs)
369 * out_table - Where the pointer to the table is returned
370 *
371 * RETURN: Status and pointer to table
372 *
373 * DESCRIPTION: Finds and verifies an ACPI table.
374 *
375 *****************************************************************************/
376 acpi_status
377 acpi_get_table(char *signature,
378 acpi_native_uint instance, struct acpi_table_header ** out_table)
379 {
380 acpi_native_uint i;
381 acpi_native_uint j;
382 acpi_status status;
383
384 /* Parameter validation */
385
386 if (!signature || !out_table) {
387 return (AE_BAD_PARAMETER);
388 }
389
390 /*
391 * Walk the root table list
392 */
393 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
394 if (!ACPI_COMPARE_NAME
395 (&(acpi_gbl_root_table_list.tables[i].signature),
396 signature)) {
397 continue;
398 }
399
400 if (++j < instance) {
401 continue;
402 }
403
404 status =
405 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
406 if (ACPI_SUCCESS(status)) {
407 *out_table = acpi_gbl_root_table_list.tables[i].pointer;
408 }
409
410 if (!acpi_gbl_permanent_mmap) {
411 acpi_gbl_root_table_list.tables[i].pointer = NULL;
412 }
413
414 return (status);
415 }
416
417 return (AE_NOT_FOUND);
418 }
419
420 ACPI_EXPORT_SYMBOL(acpi_get_table)
421
422 /*******************************************************************************
423 *
424 * FUNCTION: acpi_get_table_by_index
425 *
426 * PARAMETERS: table_index - Table index
427 * Table - Where the pointer to the table is returned
428 *
429 * RETURN: Status and pointer to the table
430 *
431 * DESCRIPTION: Obtain a table by an index into the global table list.
432 *
433 ******************************************************************************/
434 acpi_status
435 acpi_get_table_by_index(acpi_native_uint table_index,
436 struct acpi_table_header ** table)
437 {
438 acpi_status status;
439
440 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
441
442 /* Parameter validation */
443
444 if (!table) {
445 return_ACPI_STATUS(AE_BAD_PARAMETER);
446 }
447
448 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
449
450 /* Validate index */
451
452 if (table_index >= acpi_gbl_root_table_list.count) {
453 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
454 return_ACPI_STATUS(AE_BAD_PARAMETER);
455 }
456
457 if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
458
459 /* Table is not mapped, map it */
460
461 status =
462 acpi_tb_verify_table(&acpi_gbl_root_table_list.
463 tables[table_index]);
464 if (ACPI_FAILURE(status)) {
465 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
466 return_ACPI_STATUS(status);
467 }
468 }
469
470 *table = acpi_gbl_root_table_list.tables[table_index].pointer;
471 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
472 return_ACPI_STATUS(AE_OK);
473 }
474
475 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
476
477 /*******************************************************************************
478 *
479 * FUNCTION: acpi_tb_load_namespace
480 *
481 * PARAMETERS: None
482 *
483 * RETURN: Status
484 *
485 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
486 * the RSDT/XSDT.
487 *
488 ******************************************************************************/
489 static acpi_status acpi_tb_load_namespace(void)
490 {
491 acpi_status status;
492 struct acpi_table_header *table;
493 acpi_native_uint i;
494
495 ACPI_FUNCTION_TRACE(tb_load_namespace);
496
497 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
498
499 /*
500 * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
501 * are optional.
502 */
503 if (!acpi_gbl_root_table_list.count ||
504 !ACPI_COMPARE_NAME(&
505 (acpi_gbl_root_table_list.
506 tables[ACPI_TABLE_INDEX_DSDT].signature),
507 ACPI_SIG_DSDT)
508 ||
509 ACPI_FAILURE(acpi_tb_verify_table
510 (&acpi_gbl_root_table_list.
511 tables[ACPI_TABLE_INDEX_DSDT]))) {
512 status = AE_NO_ACPI_TABLES;
513 goto unlock_and_exit;
514 }
515
516 /*
517 * Find DSDT table
518 */
519 status =
520 acpi_os_table_override(acpi_gbl_root_table_list.
521 tables[ACPI_TABLE_INDEX_DSDT].pointer,
522 &table);
523 if (ACPI_SUCCESS(status) && table) {
524 /*
525 * DSDT table has been found
526 */
527 acpi_tb_delete_table(&acpi_gbl_root_table_list.
528 tables[ACPI_TABLE_INDEX_DSDT]);
529 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer =
530 table;
531 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
532 table->length;
533 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags =
534 ACPI_TABLE_ORIGIN_UNKNOWN;
535
536 ACPI_INFO((AE_INFO, "Table DSDT replaced by host OS"));
537 acpi_tb_print_table_header(0, table);
538 }
539
540 status =
541 acpi_tb_verify_table(&acpi_gbl_root_table_list.
542 tables[ACPI_TABLE_INDEX_DSDT]);
543 if (ACPI_FAILURE(status)) {
544
545 /* A valid DSDT is required */
546
547 status = AE_NO_ACPI_TABLES;
548 goto unlock_and_exit;
549 }
550
551 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
552
553 /*
554 * Load and parse tables.
555 */
556 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
557 if (ACPI_FAILURE(status)) {
558 return_ACPI_STATUS(status);
559 }
560
561 /*
562 * Load any SSDT or PSDT tables. Note: Loop leaves tables locked
563 */
564 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
565 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
566 if ((!ACPI_COMPARE_NAME
567 (&(acpi_gbl_root_table_list.tables[i].signature),
568 ACPI_SIG_SSDT)
569 &&
570 !ACPI_COMPARE_NAME(&
571 (acpi_gbl_root_table_list.tables[i].
572 signature), ACPI_SIG_PSDT))
573 ||
574 ACPI_FAILURE(acpi_tb_verify_table
575 (&acpi_gbl_root_table_list.tables[i]))) {
576 continue;
577 }
578
579 /* Ignore errors while loading tables, get as many as possible */
580
581 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
582 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
583 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
584 }
585
586 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
587
588 unlock_and_exit:
589 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
590 return_ACPI_STATUS(status);
591 }
592
593 /*******************************************************************************
594 *
595 * FUNCTION: acpi_load_tables
596 *
597 * PARAMETERS: None
598 *
599 * RETURN: Status
600 *
601 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
602 *
603 ******************************************************************************/
604
605 acpi_status acpi_load_tables(void)
606 {
607 acpi_status status;
608
609 ACPI_FUNCTION_TRACE(acpi_load_tables);
610
611 /*
612 * Load the namespace from the tables
613 */
614 status = acpi_tb_load_namespace();
615 if (ACPI_FAILURE(status)) {
616 ACPI_EXCEPTION((AE_INFO, status,
617 "While loading namespace from ACPI tables"));
618 }
619
620 return_ACPI_STATUS(status);
621 }
622
623 ACPI_EXPORT_SYMBOL(acpi_load_tables)
kernel-based virtual machine