Manual merge with Linus
[linux-2.6] / drivers / acpi / tables / tbget.c
1 /******************************************************************************
2  *
3  * Module Name: tbget - ACPI Table get* routines
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2005, 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  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/actables.h>
46
47 #define _COMPONENT          ACPI_TABLES
48 ACPI_MODULE_NAME("tbget")
49
50 /* Local prototypes */
51 static acpi_status
52 acpi_tb_get_this_table(struct acpi_pointer *address,
53                        struct acpi_table_header *header,
54                        struct acpi_table_desc *table_info);
55
56 static acpi_status
57 acpi_tb_table_override(struct acpi_table_header *header,
58                        struct acpi_table_desc *table_info);
59
60 /*******************************************************************************
61  *
62  * FUNCTION:    acpi_tb_get_table
63  *
64  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
65  *                                    Logical or Physical
66  *              table_info          - Where table info is returned
67  *
68  * RETURN:      None
69  *
70  * DESCRIPTION: Get entire table of unknown size.
71  *
72  ******************************************************************************/
73
74 acpi_status
75 acpi_tb_get_table(struct acpi_pointer *address,
76                   struct acpi_table_desc *table_info)
77 {
78         acpi_status status;
79         struct acpi_table_header header;
80
81         ACPI_FUNCTION_TRACE("tb_get_table");
82
83         /* Get the header in order to get signature and table size */
84
85         status = acpi_tb_get_table_header(address, &header);
86         if (ACPI_FAILURE(status)) {
87                 return_ACPI_STATUS(status);
88         }
89
90         /* Get the entire table */
91
92         status = acpi_tb_get_table_body(address, &header, table_info);
93         if (ACPI_FAILURE(status)) {
94                 ACPI_REPORT_ERROR(("Could not get ACPI table (size %X), %s\n",
95                                    header.length,
96                                    acpi_format_exception(status)));
97                 return_ACPI_STATUS(status);
98         }
99
100         return_ACPI_STATUS(AE_OK);
101 }
102
103 /*******************************************************************************
104  *
105  * FUNCTION:    acpi_tb_get_table_header
106  *
107  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
108  *                                    Logical or Physical
109  *              return_header       - Where the table header is returned
110  *
111  * RETURN:      Status
112  *
113  * DESCRIPTION: Get an ACPI table header.  Works in both physical or virtual
114  *              addressing mode.  Works with both physical or logical pointers.
115  *              Table is either copied or mapped, depending on the pointer
116  *              type and mode of the processor.
117  *
118  ******************************************************************************/
119
120 acpi_status
121 acpi_tb_get_table_header(struct acpi_pointer *address,
122                          struct acpi_table_header *return_header)
123 {
124         acpi_status status = AE_OK;
125         struct acpi_table_header *header = NULL;
126
127         ACPI_FUNCTION_TRACE("tb_get_table_header");
128
129         /*
130          * Flags contains the current processor mode (Virtual or Physical
131          * addressing) The pointer_type is either Logical or Physical
132          */
133         switch (address->pointer_type) {
134         case ACPI_PHYSMODE_PHYSPTR:
135         case ACPI_LOGMODE_LOGPTR:
136
137                 /* Pointer matches processor mode, copy the header */
138
139                 ACPI_MEMCPY(return_header, address->pointer.logical,
140                             sizeof(struct acpi_table_header));
141                 break;
142
143         case ACPI_LOGMODE_PHYSPTR:
144
145                 /* Create a logical address for the physical pointer */
146
147                 status = acpi_os_map_memory(address->pointer.physical,
148                                             sizeof(struct acpi_table_header),
149                                             (void *)&header);
150                 if (ACPI_FAILURE(status)) {
151                         ACPI_REPORT_ERROR(("Could not map memory at %8.8X%8.8X for length %X\n", ACPI_FORMAT_UINT64(address->pointer.physical), sizeof(struct acpi_table_header)));
152                         return_ACPI_STATUS(status);
153                 }
154
155                 /* Copy header and delete mapping */
156
157                 ACPI_MEMCPY(return_header, header,
158                             sizeof(struct acpi_table_header));
159                 acpi_os_unmap_memory(header, sizeof(struct acpi_table_header));
160                 break;
161
162         default:
163
164                 ACPI_REPORT_ERROR(("Invalid address flags %X\n",
165                                    address->pointer_type));
166                 return_ACPI_STATUS(AE_BAD_PARAMETER);
167         }
168
169         ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Table Signature: [%4.4s]\n",
170                           return_header->signature));
171
172         return_ACPI_STATUS(AE_OK);
173 }
174
175 /*******************************************************************************
176  *
177  * FUNCTION:    acpi_tb_get_table_body
178  *
179  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
180  *                                    Logical or Physical
181  *              Header              - Header of the table to retrieve
182  *              table_info          - Where the table info is returned
183  *
184  * RETURN:      Status
185  *
186  * DESCRIPTION: Get an entire ACPI table with support to allow the host OS to
187  *              replace the table with a newer version (table override.)
188  *              Works in both physical or virtual
189  *              addressing mode.  Works with both physical or logical pointers.
190  *              Table is either copied or mapped, depending on the pointer
191  *              type and mode of the processor.
192  *
193  ******************************************************************************/
194
195 acpi_status
196 acpi_tb_get_table_body(struct acpi_pointer *address,
197                        struct acpi_table_header *header,
198                        struct acpi_table_desc *table_info)
199 {
200         acpi_status status;
201
202         ACPI_FUNCTION_TRACE("tb_get_table_body");
203
204         if (!table_info || !address) {
205                 return_ACPI_STATUS(AE_BAD_PARAMETER);
206         }
207
208         /* Attempt table override. */
209
210         status = acpi_tb_table_override(header, table_info);
211         if (ACPI_SUCCESS(status)) {
212                 /* Table was overridden by the host OS */
213
214                 return_ACPI_STATUS(status);
215         }
216
217         /* No override, get the original table */
218
219         status = acpi_tb_get_this_table(address, header, table_info);
220         return_ACPI_STATUS(status);
221 }
222
223 /*******************************************************************************
224  *
225  * FUNCTION:    acpi_tb_table_override
226  *
227  * PARAMETERS:  Header              - Pointer to table header
228  *              table_info          - Return info if table is overridden
229  *
230  * RETURN:      None
231  *
232  * DESCRIPTION: Attempts override of current table with a new one if provided
233  *              by the host OS.
234  *
235  ******************************************************************************/
236
237 static acpi_status
238 acpi_tb_table_override(struct acpi_table_header *header,
239                        struct acpi_table_desc *table_info)
240 {
241         struct acpi_table_header *new_table;
242         acpi_status status;
243         struct acpi_pointer address;
244
245         ACPI_FUNCTION_TRACE("tb_table_override");
246
247         /*
248          * The OSL will examine the header and decide whether to override this
249          * table.  If it decides to override, a table will be returned in new_table,
250          * which we will then copy.
251          */
252         status = acpi_os_table_override(header, &new_table);
253         if (ACPI_FAILURE(status)) {
254                 /* Some severe error from the OSL, but we basically ignore it */
255
256                 ACPI_REPORT_ERROR(("Could not override ACPI table, %s\n",
257                                    acpi_format_exception(status)));
258                 return_ACPI_STATUS(status);
259         }
260
261         if (!new_table) {
262                 /* No table override */
263
264                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
265         }
266
267         /*
268          * We have a new table to override the old one.  Get a copy of
269          * the new one.  We know that the new table has a logical pointer.
270          */
271         address.pointer_type = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING;
272         address.pointer.logical = new_table;
273
274         status = acpi_tb_get_this_table(&address, new_table, table_info);
275         if (ACPI_FAILURE(status)) {
276                 ACPI_REPORT_ERROR(("Could not copy override ACPI table, %s\n",
277                                    acpi_format_exception(status)));
278                 return_ACPI_STATUS(status);
279         }
280
281         /* Copy the table info */
282
283         ACPI_REPORT_INFO(("Table [%4.4s] replaced by host OS\n",
284                           table_info->pointer->signature));
285
286         return_ACPI_STATUS(AE_OK);
287 }
288
289 /*******************************************************************************
290  *
291  * FUNCTION:    acpi_tb_get_this_table
292  *
293  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
294  *                                    Logical or Physical
295  *              Header              - Header of the table to retrieve
296  *              table_info          - Where the table info is returned
297  *
298  * RETURN:      Status
299  *
300  * DESCRIPTION: Get an entire ACPI table.  Works in both physical or virtual
301  *              addressing mode.  Works with both physical or logical pointers.
302  *              Table is either copied or mapped, depending on the pointer
303  *              type and mode of the processor.
304  *
305  ******************************************************************************/
306
307 static acpi_status
308 acpi_tb_get_this_table(struct acpi_pointer *address,
309                        struct acpi_table_header *header,
310                        struct acpi_table_desc *table_info)
311 {
312         struct acpi_table_header *full_table = NULL;
313         u8 allocation;
314         acpi_status status = AE_OK;
315
316         ACPI_FUNCTION_TRACE("tb_get_this_table");
317
318         /*
319          * Flags contains the current processor mode (Virtual or Physical
320          * addressing) The pointer_type is either Logical or Physical
321          */
322         switch (address->pointer_type) {
323         case ACPI_PHYSMODE_PHYSPTR:
324         case ACPI_LOGMODE_LOGPTR:
325
326                 /* Pointer matches processor mode, copy the table to a new buffer */
327
328                 full_table = ACPI_MEM_ALLOCATE(header->length);
329                 if (!full_table) {
330                         ACPI_REPORT_ERROR(("Could not allocate table memory for [%4.4s] length %X\n", header->signature, header->length));
331                         return_ACPI_STATUS(AE_NO_MEMORY);
332                 }
333
334                 /* Copy the entire table (including header) to the local buffer */
335
336                 ACPI_MEMCPY(full_table, address->pointer.logical,
337                             header->length);
338
339                 /* Save allocation type */
340
341                 allocation = ACPI_MEM_ALLOCATED;
342                 break;
343
344         case ACPI_LOGMODE_PHYSPTR:
345
346                 /*
347                  * Just map the table's physical memory
348                  * into our address space.
349                  */
350                 status = acpi_os_map_memory(address->pointer.physical,
351                                             (acpi_size) header->length,
352                                             (void *)&full_table);
353                 if (ACPI_FAILURE(status)) {
354                         ACPI_REPORT_ERROR(("Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X\n", header->signature, ACPI_FORMAT_UINT64(address->pointer.physical), header->length));
355                         return (status);
356                 }
357
358                 /* Save allocation type */
359
360                 allocation = ACPI_MEM_MAPPED;
361                 break;
362
363         default:
364
365                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid address flags %X\n",
366                                   address->pointer_type));
367                 return_ACPI_STATUS(AE_BAD_PARAMETER);
368         }
369
370         /*
371          * Validate checksum for _most_ tables,
372          * even the ones whose signature we don't recognize
373          */
374         if (table_info->type != ACPI_TABLE_FACS) {
375                 status = acpi_tb_verify_table_checksum(full_table);
376
377 #if (!ACPI_CHECKSUM_ABORT)
378                 if (ACPI_FAILURE(status)) {
379                         /* Ignore the error if configuration says so */
380
381                         status = AE_OK;
382                 }
383 #endif
384         }
385
386         /* Return values */
387
388         table_info->pointer = full_table;
389         table_info->length = (acpi_size) header->length;
390         table_info->allocation = allocation;
391
392         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
393                           "Found table [%4.4s] at %8.8X%8.8X, mapped/copied to %p\n",
394                           full_table->signature,
395                           ACPI_FORMAT_UINT64(address->pointer.physical),
396                           full_table));
397
398         return_ACPI_STATUS(status);
399 }
400
401 /*******************************************************************************
402  *
403  * FUNCTION:    acpi_tb_get_table_ptr
404  *
405  * PARAMETERS:  table_type      - one of the defined table types
406  *              Instance        - Which table of this type
407  *              table_ptr_loc   - pointer to location to place the pointer for
408  *                                return
409  *
410  * RETURN:      Status
411  *
412  * DESCRIPTION: This function is called to get the pointer to an ACPI table.
413  *
414  ******************************************************************************/
415
416 acpi_status
417 acpi_tb_get_table_ptr(acpi_table_type table_type,
418                       u32 instance, struct acpi_table_header **table_ptr_loc)
419 {
420         struct acpi_table_desc *table_desc;
421         u32 i;
422
423         ACPI_FUNCTION_TRACE("tb_get_table_ptr");
424
425         if (!acpi_gbl_DSDT) {
426                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
427         }
428
429         if (table_type > ACPI_TABLE_MAX) {
430                 return_ACPI_STATUS(AE_BAD_PARAMETER);
431         }
432
433         /*
434          * For all table types (Single/Multiple), the first
435          * instance is always in the list head.
436          */
437         if (instance == 1) {
438                 /* Get the first */
439
440                 *table_ptr_loc = NULL;
441                 if (acpi_gbl_table_lists[table_type].next) {
442                         *table_ptr_loc =
443                             acpi_gbl_table_lists[table_type].next->pointer;
444                 }
445                 return_ACPI_STATUS(AE_OK);
446         }
447
448         /* Check for instance out of range */
449
450         if (instance > acpi_gbl_table_lists[table_type].count) {
451                 return_ACPI_STATUS(AE_NOT_EXIST);
452         }
453
454         /* Walk the list to get the desired table
455          * Since the if (Instance == 1) check above checked for the
456          * first table, setting table_desc equal to the .Next member
457          * is actually pointing to the second table.  Therefore, we
458          * need to walk from the 2nd table until we reach the Instance
459          * that the user is looking for and return its table pointer.
460          */
461         table_desc = acpi_gbl_table_lists[table_type].next;
462         for (i = 2; i < instance; i++) {
463                 table_desc = table_desc->next;
464         }
465
466         /* We are now pointing to the requested table's descriptor */
467
468         *table_ptr_loc = table_desc->pointer;
469
470         return_ACPI_STATUS(AE_OK);
471 }