ACPI: Add support for acpi_load_table/acpi_unload_table_id
[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 /*******************************************************************************
53  *
54  * FUNCTION:    acpi_load_tables
55  *
56  * PARAMETERS:  None
57  *
58  * RETURN:      Status
59  *
60  * DESCRIPTION: This function is called to load the ACPI tables from the
61  *              provided RSDT
62  *
63  ******************************************************************************/
64 acpi_status acpi_load_tables(void)
65 {
66         struct acpi_pointer rsdp_address;
67         acpi_status status;
68
69         ACPI_FUNCTION_TRACE(acpi_load_tables);
70
71         /* Get the RSDP */
72
73         status = acpi_os_get_root_pointer(ACPI_LOGICAL_ADDRESSING,
74                                           &rsdp_address);
75         if (ACPI_FAILURE(status)) {
76                 ACPI_EXCEPTION((AE_INFO, status, "Could not get the RSDP"));
77                 goto error_exit;
78         }
79
80         /* Map and validate the RSDP */
81
82         acpi_gbl_table_flags = rsdp_address.pointer_type;
83
84         status = acpi_tb_verify_rsdp(&rsdp_address);
85         if (ACPI_FAILURE(status)) {
86                 ACPI_EXCEPTION((AE_INFO, status, "During RSDP validation"));
87                 goto error_exit;
88         }
89
90         /* Get the RSDT via the RSDP */
91
92         status = acpi_tb_get_table_rsdt();
93         if (ACPI_FAILURE(status)) {
94                 ACPI_EXCEPTION((AE_INFO, status, "Could not load RSDT"));
95                 goto error_exit;
96         }
97
98         /* Now get the tables needed by this subsystem (FADT, DSDT, etc.) */
99
100         status = acpi_tb_get_required_tables();
101         if (ACPI_FAILURE(status)) {
102                 ACPI_EXCEPTION((AE_INFO, status,
103                                 "Could not get all required tables (DSDT/FADT/FACS)"));
104                 goto error_exit;
105         }
106
107         ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
108
109         /* Load the namespace from the tables */
110
111         status = acpi_ns_load_namespace();
112         if (ACPI_FAILURE(status)) {
113                 ACPI_EXCEPTION((AE_INFO, status, "Could not load namespace"));
114                 goto error_exit;
115         }
116
117         return_ACPI_STATUS(AE_OK);
118
119       error_exit:
120         ACPI_EXCEPTION((AE_INFO, status, "Could not load tables"));
121         return_ACPI_STATUS(status);
122 }
123
124 ACPI_EXPORT_SYMBOL(acpi_load_tables)
125
126 /*******************************************************************************
127  *
128  * FUNCTION:    acpi_load_table
129  *
130  * PARAMETERS:  table_ptr       - pointer to a buffer containing the entire
131  *                                table to be loaded
132  *
133  * RETURN:      Status
134  *
135  * DESCRIPTION: This function is called to load a table from the caller's
136  *              buffer. The buffer must contain an entire ACPI Table including
137  *              a valid header. The header fields will be verified, and if it
138  *              is determined that the table is invalid, the call will fail.
139  *
140  ******************************************************************************/
141 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
142 {
143         acpi_status status;
144         struct acpi_table_desc table_info;
145         struct acpi_pointer address;
146
147         ACPI_FUNCTION_TRACE(acpi_load_table);
148
149         if (!table_ptr) {
150                 return_ACPI_STATUS(AE_BAD_PARAMETER);
151         }
152
153         /* Copy the table to a local buffer */
154
155         address.pointer_type = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING;
156         address.pointer.logical = table_ptr;
157
158         status = acpi_tb_get_table_body(&address, table_ptr, &table_info);
159         if (ACPI_FAILURE(status)) {
160                 return_ACPI_STATUS(status);
161         }
162
163         /* Check signature for a valid table type */
164
165         status = acpi_tb_recognize_table(&table_info, ACPI_TABLE_ALL);
166         if (ACPI_FAILURE(status)) {
167                 return_ACPI_STATUS(status);
168         }
169
170         /* Install the new table into the local data structures */
171
172         status = acpi_tb_install_table(&table_info);
173         if (ACPI_FAILURE(status)) {
174                 if (status == AE_ALREADY_EXISTS) {
175
176                         /* Table already exists, no error */
177
178                         status = AE_OK;
179                 }
180
181                 /* Free table allocated by acpi_tb_get_table_body */
182
183                 acpi_tb_delete_single_table(&table_info);
184                 return_ACPI_STATUS(status);
185         }
186
187         /* Convert the table to common format if necessary */
188
189         switch (table_info.type) {
190         case ACPI_TABLE_ID_FADT:
191
192                 status = acpi_tb_convert_table_fadt();
193                 break;
194
195         case ACPI_TABLE_ID_FACS:
196
197                 status = acpi_tb_build_common_facs(&table_info);
198                 break;
199
200         default:
201                 /* Load table into namespace if it contains executable AML */
202
203                 status =
204                     acpi_ns_load_table(table_info.installed_desc,
205                                        acpi_gbl_root_node);
206                 break;
207         }
208
209         if (ACPI_FAILURE(status)) {
210
211                 /* Uninstall table and free the buffer */
212
213                 (void)acpi_tb_uninstall_table(table_info.installed_desc);
214         }
215
216         return_ACPI_STATUS(status);
217 }
218
219 ACPI_EXPORT_SYMBOL(acpi_load_table)
220
221 /*******************************************************************************
222  *
223  * FUNCTION:    acpi_unload_table_id
224  *
225  * PARAMETERS:  table_type    - Type of table to be unloaded
226  *              id            - Owner ID of the table to be removed.
227  *
228  * RETURN:      Status
229  *
230  * DESCRIPTION: This routine is used to force the unload of a table (by id)
231  *
232  ******************************************************************************/
233 acpi_status acpi_unload_table_id(acpi_table_type table_type, acpi_owner_id id)
234 {
235         struct acpi_table_desc *table_desc;
236         acpi_status status;
237
238         ACPI_FUNCTION_TRACE(acpi_unload_table);
239
240         /* Parameter validation */
241         if (table_type > ACPI_TABLE_ID_MAX)
242                 return_ACPI_STATUS(AE_BAD_PARAMETER);
243
244         /* Find table from the requested type list */
245         table_desc = acpi_gbl_table_lists[table_type].next;
246         while (table_desc && table_desc->owner_id != id)
247                 table_desc = table_desc->next;
248
249         if (!table_desc)
250                 return_ACPI_STATUS(AE_NOT_EXIST);
251
252         /*
253          * Delete all namespace objects owned by this table. Note that these
254          * objects can appear anywhere in the namespace by virtue of the AML
255          * "Scope" operator. Thus, we need to track ownership by an ID, not
256          * simply a position within the hierarchy
257          */
258         acpi_ns_delete_namespace_by_owner(table_desc->owner_id);
259
260         status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
261         if (ACPI_FAILURE(status))
262                 return_ACPI_STATUS(status);
263
264         (void)acpi_tb_uninstall_table(table_desc);
265
266         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
267
268         return_ACPI_STATUS(AE_OK);
269 }
270
271 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
272
273 #ifdef ACPI_FUTURE_USAGE
274 /*******************************************************************************
275  *
276  * FUNCTION:    acpi_unload_table
277  *
278  * PARAMETERS:  table_type    - Type of table to be unloaded
279  *
280  * RETURN:      Status
281  *
282  * DESCRIPTION: This routine is used to force the unload of a table
283  *
284  ******************************************************************************/
285 acpi_status acpi_unload_table(acpi_table_type table_type)
286 {
287         struct acpi_table_desc *table_desc;
288
289         ACPI_FUNCTION_TRACE(acpi_unload_table);
290
291         /* Parameter validation */
292
293         if (table_type > ACPI_TABLE_ID_MAX) {
294                 return_ACPI_STATUS(AE_BAD_PARAMETER);
295         }
296
297         /* Find all tables of the requested type */
298
299         table_desc = acpi_gbl_table_lists[table_type].next;
300         if (!table_desc) {
301                 return_ACPI_STATUS(AE_NOT_EXIST);
302         }
303
304         while (table_desc) {
305                 /*
306                  * Delete all namespace objects owned by this table. Note that these
307                  * objects can appear anywhere in the namespace by virtue of the AML
308                  * "Scope" operator. Thus, we need to track ownership by an ID, not
309                  * simply a position within the hierarchy
310                  */
311                 acpi_ns_delete_namespace_by_owner(table_desc->owner_id);
312                 table_desc = table_desc->next;
313         }
314
315         /* Delete (or unmap) all tables of this type */
316
317         acpi_tb_delete_tables_by_type(table_type);
318         return_ACPI_STATUS(AE_OK);
319 }
320
321 ACPI_EXPORT_SYMBOL(acpi_unload_table)
322
323 /*******************************************************************************
324  *
325  * FUNCTION:    acpi_get_table_header
326  *
327  * PARAMETERS:  table_type      - one of the defined table types
328  *              Instance        - the non zero instance of the table, allows
329  *                                support for multiple tables of the same type
330  *                                see acpi_gbl_acpi_table_flag
331  *              out_table_header - pointer to the struct acpi_table_header if successful
332  *
333  * DESCRIPTION: This function is called to get an ACPI table header. The caller
334  *              supplies an pointer to a data area sufficient to contain an ACPI
335  *              struct acpi_table_header structure.
336  *
337  *              The header contains a length field that can be used to determine
338  *              the size of the buffer needed to contain the entire table. This
339  *              function is not valid for the RSD PTR table since it does not
340  *              have a standard header and is fixed length.
341  *
342  ******************************************************************************/
343 acpi_status
344 acpi_get_table_header(acpi_table_type table_type,
345                       u32 instance, struct acpi_table_header *out_table_header)
346 {
347         struct acpi_table_header *tbl_ptr;
348         acpi_status status;
349
350         ACPI_FUNCTION_TRACE(acpi_get_table_header);
351
352         if ((instance == 0) ||
353             (table_type == ACPI_TABLE_ID_RSDP) || (!out_table_header)) {
354                 return_ACPI_STATUS(AE_BAD_PARAMETER);
355         }
356
357         /* Check the table type and instance */
358
359         if ((table_type > ACPI_TABLE_ID_MAX) ||
360             (ACPI_IS_SINGLE_TABLE(acpi_gbl_table_data[table_type].flags) &&
361              instance > 1)) {
362                 return_ACPI_STATUS(AE_BAD_PARAMETER);
363         }
364
365         /* Get a pointer to the entire table */
366
367         status = acpi_tb_get_table_ptr(table_type, instance, &tbl_ptr);
368         if (ACPI_FAILURE(status)) {
369                 return_ACPI_STATUS(status);
370         }
371
372         /* The function will return a NULL pointer if the table is not loaded */
373
374         if (tbl_ptr == NULL) {
375                 return_ACPI_STATUS(AE_NOT_EXIST);
376         }
377
378         /* Copy the header to the caller's buffer */
379
380         ACPI_MEMCPY(ACPI_CAST_PTR(void, out_table_header),
381                     ACPI_CAST_PTR(void, tbl_ptr),
382                     sizeof(struct acpi_table_header));
383
384         return_ACPI_STATUS(status);
385 }
386
387 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
388 #endif                          /*  ACPI_FUTURE_USAGE  */
389
390 /*******************************************************************************
391  *
392  * FUNCTION:    acpi_get_table
393  *
394  * PARAMETERS:  table_type      - one of the defined table types
395  *              Instance        - the non zero instance of the table, allows
396  *                                support for multiple tables of the same type
397  *                                see acpi_gbl_acpi_table_flag
398  *              ret_buffer      - pointer to a structure containing a buffer to
399  *                                receive the table
400  *
401  * RETURN:      Status
402  *
403  * DESCRIPTION: This function is called to get an ACPI table. The caller
404  *              supplies an out_buffer large enough to contain the entire ACPI
405  *              table. The caller should call the acpi_get_table_header function
406  *              first to determine the buffer size needed. Upon completion
407  *              the out_buffer->Length field will indicate the number of bytes
408  *              copied into the out_buffer->buf_ptr buffer. This table will be
409  *              a complete table including the header.
410  *
411  ******************************************************************************/
412 acpi_status
413 acpi_get_table(acpi_table_type table_type,
414                u32 instance, struct acpi_buffer *ret_buffer)
415 {
416         struct acpi_table_header *tbl_ptr;
417         acpi_status status;
418         acpi_size table_length;
419
420         ACPI_FUNCTION_TRACE(acpi_get_table);
421
422         /* Parameter validation */
423
424         if (instance == 0) {
425                 return_ACPI_STATUS(AE_BAD_PARAMETER);
426         }
427
428         status = acpi_ut_validate_buffer(ret_buffer);
429         if (ACPI_FAILURE(status)) {
430                 return_ACPI_STATUS(status);
431         }
432
433         /* Check the table type and instance */
434
435         if ((table_type > ACPI_TABLE_ID_MAX) ||
436             (ACPI_IS_SINGLE_TABLE(acpi_gbl_table_data[table_type].flags) &&
437              instance > 1)) {
438                 return_ACPI_STATUS(AE_BAD_PARAMETER);
439         }
440
441         /* Get a pointer to the entire table */
442
443         status = acpi_tb_get_table_ptr(table_type, instance, &tbl_ptr);
444         if (ACPI_FAILURE(status)) {
445                 return_ACPI_STATUS(status);
446         }
447
448         /*
449          * acpi_tb_get_table_ptr will return a NULL pointer if the
450          * table is not loaded.
451          */
452         if (tbl_ptr == NULL) {
453                 return_ACPI_STATUS(AE_NOT_EXIST);
454         }
455
456         /* Get the table length */
457
458         if (table_type == ACPI_TABLE_ID_RSDP) {
459
460                 /* RSD PTR is the only "table" without a header */
461
462                 table_length = sizeof(struct rsdp_descriptor);
463         } else {
464                 table_length = (acpi_size) tbl_ptr->length;
465         }
466
467         /* Validate/Allocate/Clear caller buffer */
468
469         status = acpi_ut_initialize_buffer(ret_buffer, table_length);
470         if (ACPI_FAILURE(status)) {
471                 return_ACPI_STATUS(status);
472         }
473
474         /* Copy the table to the buffer */
475
476         ACPI_MEMCPY(ACPI_CAST_PTR(void, ret_buffer->pointer),
477                     ACPI_CAST_PTR(void, tbl_ptr), table_length);
478
479         return_ACPI_STATUS(AE_OK);
480 }
481
482 ACPI_EXPORT_SYMBOL(acpi_get_table)