94544a60640dd276f5302353bbc2bf8a39abfec5
[sfrench/cifs-2.6.git] / drivers / acpi / tables / tbxface.c
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 - 2006, 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_initialize_tables
58  *
59  * PARAMETERS:  initial_table_array - Pointer to an array of pre-allocated
60  *                                    struct acpi_table_desc structures. If NULL, the
61  *                                    array is dynamically allocated.
62  *              initial_table_count - Size of initial_table_array, in number of
63  *                                    struct acpi_table_desc structures
64  *              allow_realloc       - Flag to tell Table Manager if resize of
65  *                                    pre-allocated array is allowed. Ignored
66  *                                    if initial_table_array is NULL.
67  *
68  * RETURN:      Status
69  *
70  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
71  *
72  * NOTE:        Allows static allocation of the initial table array in order
73  *              to avoid the use of dynamic memory in confined environments
74  *              such as the kernel boot sequence where it may not be available.
75  *
76  *              If the host OS memory managers are initialized, use NULL for
77  *              initial_table_array, and the table will be dynamically allocated.
78  *
79  ******************************************************************************/
80
81 acpi_status __init
82 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
83                        u32 initial_table_count, u8 allow_resize)
84 {
85         acpi_physical_address rsdp_address;
86         acpi_status status;
87
88         ACPI_FUNCTION_TRACE(acpi_initialize_tables);
89
90         /*
91          * Set up the Root Table Array
92          * Allocate the table array if requested
93          */
94         if (!initial_table_array) {
95                 acpi_gbl_root_table_list.size = initial_table_count;
96                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
97
98                 status = acpi_tb_resize_root_table_list();
99                 if (ACPI_FAILURE(status)) {
100                         return_ACPI_STATUS(status);
101                 }
102         } else {
103                 /* Root Table Array has been statically allocated by the host */
104
105                 ACPI_MEMSET(initial_table_array, 0,
106                             initial_table_count *
107                             sizeof(struct acpi_table_desc));
108
109                 acpi_gbl_root_table_list.tables = initial_table_array;
110                 acpi_gbl_root_table_list.size = initial_table_count;
111                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
112                 if (allow_resize) {
113                         acpi_gbl_root_table_list.flags |=
114                             ACPI_ROOT_ALLOW_RESIZE;
115                 }
116         }
117
118         /* Get the address of the RSDP */
119
120         rsdp_address = acpi_os_get_root_pointer();
121         if (!rsdp_address) {
122                 return_ACPI_STATUS(AE_NOT_FOUND);
123         }
124
125         /*
126          * Get the root table (RSDT or XSDT) and extract all entries to the local
127          * Root Table Array. This array contains the information of the RSDT/XSDT
128          * in a common, more useable format.
129          */
130         status =
131             acpi_tb_parse_root_table(rsdp_address, ACPI_TABLE_ORIGIN_MAPPED);
132         return_ACPI_STATUS(status);
133 }
134
135 /*******************************************************************************
136  *
137  * FUNCTION:    acpi_reallocate_root_table
138  *
139  * PARAMETERS:  None
140  *
141  * RETURN:      Status
142  *
143  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
144  *              root list from the previously provided scratch area. Should
145  *              be called once dynamic memory allocation is available in the
146  *              kernel
147  *
148  ******************************************************************************/
149 acpi_status acpi_reallocate_root_table(void)
150 {
151         struct acpi_table_desc *tables;
152         acpi_size new_size;
153
154         ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
155
156         /*
157          * Only reallocate the root table if the host provided a static buffer
158          * for the table array in the call to acpi_initialize_tables.
159          */
160         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
161                 return_ACPI_STATUS(AE_SUPPORT);
162         }
163
164         new_size =
165             (acpi_gbl_root_table_list.count +
166              ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc);
167
168         /* Create new array and copy the old array */
169
170         tables = ACPI_ALLOCATE_ZEROED(new_size);
171         if (!tables) {
172                 return_ACPI_STATUS(AE_NO_MEMORY);
173         }
174
175         ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
176
177         acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
178         acpi_gbl_root_table_list.tables = tables;
179         acpi_gbl_root_table_list.flags =
180             ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
181
182         return_ACPI_STATUS(AE_OK);
183 }
184 /*******************************************************************************
185  *
186  * FUNCTION:    acpi_load_table
187  *
188  * PARAMETERS:  table_ptr       - pointer to a buffer containing the entire
189  *                                table to be loaded
190  *
191  * RETURN:      Status
192  *
193  * DESCRIPTION: This function is called to load a table from the caller's
194  *              buffer. The buffer must contain an entire ACPI Table including
195  *              a valid header. The header fields will be verified, and if it
196  *              is determined that the table is invalid, the call will fail.
197  *
198  ******************************************************************************/
199 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
200 {
201         acpi_status status;
202         acpi_native_uint table_index;
203
204         /*
205          * Install the new table into the local data structures
206          */
207         status = acpi_tb_add_table(table_ptr, &table_index);
208         if (ACPI_FAILURE(status)) {
209                 return_ACPI_STATUS(status);
210         }
211         status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
212         return_ACPI_STATUS(status);
213 }
214
215 ACPI_EXPORT_SYMBOL(acpi_load_table)
216
217 /******************************************************************************
218  *
219  * FUNCTION:    acpi_get_table_header
220  *
221  * PARAMETERS:  Signature           - ACPI signature of needed table
222  *              Instance            - Which instance (for SSDTs)
223  *              out_table_header    - Where the pointer to the table header
224  *                                    is returned
225  *
226  * RETURN:      Status and pointer to mapped table header
227  *
228  * DESCRIPTION: Finds an ACPI table header.
229  *
230  * NOTE:        Caller is responsible in unmapping the header with
231  *              acpi_os_unmap_memory
232  *
233  *****************************************************************************/
234 acpi_status
235 acpi_get_table_header(char *signature,
236                       acpi_native_uint instance,
237                       struct acpi_table_header **out_table_header)
238 {
239         acpi_native_uint i;
240         acpi_native_uint j;
241
242         /* Parameter validation */
243
244         if (!signature || !out_table_header) {
245                 return (AE_BAD_PARAMETER);
246         }
247
248         /*
249          * Walk the root table list
250          */
251         for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
252                 if (!ACPI_COMPARE_NAME
253                     (&(acpi_gbl_root_table_list.tables[i].signature),
254                      signature)) {
255                         continue;
256                 }
257
258                 if (++j < instance) {
259                         continue;
260                 }
261
262                 *out_table_header =
263                     acpi_tb_map(acpi_gbl_root_table_list.tables[i].address,
264                                 (u32) sizeof(struct acpi_table_header),
265                                 acpi_gbl_root_table_list.tables[i].
266                                 flags & ACPI_TABLE_ORIGIN_MASK);
267
268                 if (!(*out_table_header)) {
269                         return (AE_NO_MEMORY);
270                 }
271
272                 return (AE_OK);
273         }
274
275         return (AE_NOT_FOUND);
276 }
277
278 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
279
280
281 /******************************************************************************
282  *
283  * FUNCTION:    acpi_unload_table_id
284  *
285  * PARAMETERS:  id            - Owner ID of the table to be removed.
286  *
287  * RETURN:      Status
288  *
289  * DESCRIPTION: This routine is used to force the unload of a table (by id)
290  *
291  ******************************************************************************/
292 acpi_status acpi_unload_table_id(acpi_owner_id id)
293 {
294         int i;
295         acpi_status status = AE_NOT_EXIST;
296
297         ACPI_FUNCTION_TRACE(acpi_unload_table);
298
299         /* Find table from the requested type list */
300         for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
301                 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
302                         continue;
303                 }
304                 /*
305                 * Delete all namespace objects owned by this table. Note that these
306                 * objects can appear anywhere in the namespace by virtue of the AML
307                 * "Scope" operator. Thus, we need to track ownership by an ID, not
308                 * simply a position within the hierarchy
309                 */
310                 acpi_tb_delete_namespace_by_owner(i);
311                 acpi_tb_release_owner_id(i);
312                 acpi_tb_set_table_loaded_flag(i, FALSE);
313         }
314         return_ACPI_STATUS(status);
315 }
316
317 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
318
319 /*******************************************************************************
320  *
321  * FUNCTION:    acpi_get_table
322  *
323  * PARAMETERS:  Signature           - ACPI signature of needed table
324  *              Instance            - Which instance (for SSDTs)
325  *              out_table           - Where the pointer to the table is returned
326  *
327  * RETURN:      Status and pointer to table
328  *
329  * DESCRIPTION: Finds and verifies an ACPI table.
330  *
331  *****************************************************************************/
332 acpi_status
333 acpi_get_table(char *signature,
334                acpi_native_uint instance, struct acpi_table_header ** out_table)
335 {
336         acpi_native_uint i;
337         acpi_native_uint j;
338         acpi_status status;
339
340         /* Parameter validation */
341
342         if (!signature || !out_table) {
343                 return (AE_BAD_PARAMETER);
344         }
345
346         /*
347          * Walk the root table list
348          */
349         for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
350                 if (!ACPI_COMPARE_NAME
351                     (&(acpi_gbl_root_table_list.tables[i].signature),
352                      signature)) {
353                         continue;
354                 }
355
356                 if (++j < instance) {
357                         continue;
358                 }
359
360                 status =
361                     acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
362                 if (ACPI_SUCCESS(status)) {
363                         *out_table = acpi_gbl_root_table_list.tables[i].pointer;
364                 }
365
366                 if (!acpi_gbl_permanent_mmap) {
367                         acpi_gbl_root_table_list.tables[i].pointer = 0;
368                 }
369
370                 return (status);
371         }
372
373         return (AE_NOT_FOUND);
374 }
375
376 ACPI_EXPORT_SYMBOL(acpi_get_table)
377
378 /*******************************************************************************
379  *
380  * FUNCTION:    acpi_get_table_by_index
381  *
382  * PARAMETERS:  table_index         - Table index
383  *              Table               - Where the pointer to the table is returned
384  *
385  * RETURN:      Status and pointer to the table
386  *
387  * DESCRIPTION: Obtain a table by an index into the global table list.
388  *
389  ******************************************************************************/
390 acpi_status
391 acpi_get_table_by_index(acpi_native_uint table_index,
392                         struct acpi_table_header ** table)
393 {
394         acpi_status status;
395
396         ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
397
398         /* Parameter validation */
399
400         if (!table) {
401                 return_ACPI_STATUS(AE_BAD_PARAMETER);
402         }
403
404         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
405
406         /* Validate index */
407
408         if (table_index >= acpi_gbl_root_table_list.count) {
409                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
410                 return_ACPI_STATUS(AE_BAD_PARAMETER);
411         }
412
413         if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
414
415                 /* Table is not mapped, map it */
416
417                 status =
418                     acpi_tb_verify_table(&acpi_gbl_root_table_list.
419                                          tables[table_index]);
420                 if (ACPI_FAILURE(status)) {
421                         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
422                         return_ACPI_STATUS(status);
423                 }
424         }
425
426         *table = acpi_gbl_root_table_list.tables[table_index].pointer;
427         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
428         return_ACPI_STATUS(AE_OK);
429 }
430
431 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
432
433 /*******************************************************************************
434  *
435  * FUNCTION:    acpi_tb_load_namespace
436  *
437  * PARAMETERS:  None
438  *
439  * RETURN:      Status
440  *
441  * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
442  *              the RSDT/XSDT.
443  *
444  ******************************************************************************/
445 static acpi_status acpi_tb_load_namespace(void)
446 {
447         acpi_status status;
448         struct acpi_table_header *table;
449         acpi_native_uint i;
450
451         ACPI_FUNCTION_TRACE(tb_load_namespace);
452
453         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
454
455         /*
456          * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
457          * are optional.
458          */
459         if (!acpi_gbl_root_table_list.count ||
460             !ACPI_COMPARE_NAME(&
461                                (acpi_gbl_root_table_list.
462                                 tables[ACPI_TABLE_INDEX_DSDT].signature),
463                                ACPI_SIG_DSDT)
464             ||
465             ACPI_FAILURE(acpi_tb_verify_table
466                          (&acpi_gbl_root_table_list.
467                           tables[ACPI_TABLE_INDEX_DSDT]))) {
468                 status = AE_NO_ACPI_TABLES;
469                 goto unlock_and_exit;
470         }
471
472         /*
473          * Find DSDT table
474          */
475         status =
476             acpi_os_table_override(acpi_gbl_root_table_list.
477                                    tables[ACPI_TABLE_INDEX_DSDT].pointer,
478                                    &table);
479         if (ACPI_SUCCESS(status) && table) {
480                 /*
481                  * DSDT table has been found
482                  */
483                 acpi_tb_delete_table(ACPI_TABLE_INDEX_DSDT);
484                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer =
485                     table;
486                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
487                     table->length;
488                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags =
489                     ACPI_TABLE_ORIGIN_UNKNOWN;
490
491                 ACPI_INFO((AE_INFO, "Table DSDT replaced by host OS"));
492                 acpi_tb_print_table_header(0, table);
493         }
494
495         status =
496             acpi_tb_verify_table(&acpi_gbl_root_table_list.
497                                  tables[ACPI_TABLE_INDEX_DSDT]);
498         if (ACPI_FAILURE(status)) {
499
500                 /* A valid DSDT is required */
501
502                 status = AE_NO_ACPI_TABLES;
503                 goto unlock_and_exit;
504         }
505
506         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
507
508         /*
509          * Load and parse tables.
510          */
511         status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
512         if (ACPI_FAILURE(status)) {
513                 return_ACPI_STATUS(status);
514         }
515
516         /*
517          * Load any SSDT or PSDT tables. Note: Loop leaves tables locked
518          */
519         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
520         for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
521                 if ((!ACPI_COMPARE_NAME
522                      (&(acpi_gbl_root_table_list.tables[i].signature),
523                       ACPI_SIG_SSDT)
524                      &&
525                      !ACPI_COMPARE_NAME(&
526                                         (acpi_gbl_root_table_list.tables[i].
527                                          signature), ACPI_SIG_PSDT))
528                     ||
529                     ACPI_FAILURE(acpi_tb_verify_table
530                                  (&acpi_gbl_root_table_list.tables[i]))) {
531                         continue;
532                 }
533
534                 /* Ignore errors while loading tables, get as many as possible */
535
536                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
537                 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
538                 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
539         }
540
541         ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
542
543       unlock_and_exit:
544         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
545         return_ACPI_STATUS(status);
546 }
547
548 /*******************************************************************************
549  *
550  * FUNCTION:    acpi_load_tables
551  *
552  * PARAMETERS:  None
553  *
554  * RETURN:      Status
555  *
556  * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
557  *
558  ******************************************************************************/
559
560 acpi_status acpi_load_tables(void)
561 {
562         acpi_status status;
563
564         ACPI_FUNCTION_TRACE(acpi_load_tables);
565
566         /*
567          * Load the namespace from the tables
568          */
569         status = acpi_tb_load_namespace();
570         if (ACPI_FAILURE(status)) {
571                 ACPI_EXCEPTION((AE_INFO, status,
572                                 "While loading namespace from ACPI tables"));
573         }
574
575         return_ACPI_STATUS(status);
576 }
577
578 ACPI_EXPORT_SYMBOL(acpi_load_tables)