Pull cpuidle into release branch
[linux-2.6] / drivers / acpi / tables / tbutils.c
1 /******************************************************************************
2  *
3  * Module Name: tbutils   - table utilities
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2007, 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("tbutils")
49
50 /* Local prototypes */
51 static acpi_physical_address
52 acpi_tb_get_root_table_entry(u8 * table_entry,
53                              acpi_native_uint table_entry_size);
54 /*******************************************************************************
55  *
56  * FUNCTION:    acpi_tb_check_xsdt
57  *
58  * PARAMETERS:  address                    - Pointer to the XSDT
59  *
60  * RETURN:      status
61  *              AE_OK - XSDT is okay
62  *              AE_NO_MEMORY - can't map XSDT
63  *              AE_INVALID_TABLE_LENGTH - invalid table length
64  *              AE_NULL_ENTRY - XSDT has NULL entry
65  *
66  * DESCRIPTION: validate XSDT
67 ******************************************************************************/
68
69 static acpi_status
70 acpi_tb_check_xsdt(acpi_physical_address address)
71 {
72         struct acpi_table_header *table;
73         u32 length;
74         u64 xsdt_entry_address;
75         u8 *table_entry;
76         u32 table_count;
77         int i;
78
79         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
80         if (!table)
81                 return AE_NO_MEMORY;
82
83         length = table->length;
84         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
85         if (length < sizeof(struct acpi_table_header))
86                 return AE_INVALID_TABLE_LENGTH;
87
88         table = acpi_os_map_memory(address, length);
89         if (!table)
90                 return AE_NO_MEMORY;
91
92         /* Calculate the number of tables described in XSDT */
93         table_count =
94                 (u32) ((table->length -
95                 sizeof(struct acpi_table_header)) / sizeof(u64));
96         table_entry =
97                 ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
98         for (i = 0; i < table_count; i++) {
99                 ACPI_MOVE_64_TO_64(&xsdt_entry_address, table_entry);
100                 if (!xsdt_entry_address) {
101                         /* XSDT has NULL entry */
102                         break;
103                 }
104                 table_entry += sizeof(u64);
105         }
106         acpi_os_unmap_memory(table, length);
107
108         if (i < table_count)
109                 return AE_NULL_ENTRY;
110         else
111                 return AE_OK;
112 }
113
114 /*******************************************************************************
115  *
116  * FUNCTION:    acpi_tb_tables_loaded
117  *
118  * PARAMETERS:  None
119  *
120  * RETURN:      TRUE if required ACPI tables are loaded
121  *
122  * DESCRIPTION: Determine if the minimum required ACPI tables are present
123  *              (FADT, FACS, DSDT)
124  *
125  ******************************************************************************/
126
127 u8 acpi_tb_tables_loaded(void)
128 {
129
130         if (acpi_gbl_root_table_list.count >= 3) {
131                 return (TRUE);
132         }
133
134         return (FALSE);
135 }
136
137 /*******************************************************************************
138  *
139  * FUNCTION:    acpi_tb_print_table_header
140  *
141  * PARAMETERS:  Address             - Table physical address
142  *              Header              - Table header
143  *
144  * RETURN:      None
145  *
146  * DESCRIPTION: Print an ACPI table header. Special cases for FACS and RSDP.
147  *
148  ******************************************************************************/
149
150 void
151 acpi_tb_print_table_header(acpi_physical_address address,
152                            struct acpi_table_header *header)
153 {
154
155         if (ACPI_COMPARE_NAME(header->signature, ACPI_SIG_FACS)) {
156
157                 /* FACS only has signature and length fields of common table header */
158
159                 ACPI_INFO((AE_INFO, "%4.4s %08lX, %04X",
160                            header->signature, (unsigned long)address,
161                            header->length));
162         } else if (ACPI_COMPARE_NAME(header->signature, ACPI_SIG_RSDP)) {
163
164                 /* RSDP has no common fields */
165
166                 ACPI_INFO((AE_INFO, "RSDP %08lX, %04X (r%d %6.6s)",
167                            (unsigned long)address,
168                            (ACPI_CAST_PTR(struct acpi_table_rsdp, header)->
169                             revision >
170                             0) ? ACPI_CAST_PTR(struct acpi_table_rsdp,
171                                                header)->length : 20,
172                            ACPI_CAST_PTR(struct acpi_table_rsdp,
173                                          header)->revision,
174                            ACPI_CAST_PTR(struct acpi_table_rsdp,
175                                          header)->oem_id));
176         } else {
177                 /* Standard ACPI table with full common header */
178
179                 ACPI_INFO((AE_INFO,
180                            "%4.4s %08lX, %04X (r%d %6.6s %8.8s %8X %4.4s %8X)",
181                            header->signature, (unsigned long)address,
182                            header->length, header->revision, header->oem_id,
183                            header->oem_table_id, header->oem_revision,
184                            header->asl_compiler_id,
185                            header->asl_compiler_revision));
186         }
187 }
188
189 /*******************************************************************************
190  *
191  * FUNCTION:    acpi_tb_validate_checksum
192  *
193  * PARAMETERS:  Table               - ACPI table to verify
194  *              Length              - Length of entire table
195  *
196  * RETURN:      Status
197  *
198  * DESCRIPTION: Verifies that the table checksums to zero. Optionally returns
199  *              exception on bad checksum.
200  *
201  ******************************************************************************/
202
203 acpi_status acpi_tb_verify_checksum(struct acpi_table_header *table, u32 length)
204 {
205         u8 checksum;
206
207         /* Compute the checksum on the table */
208
209         checksum = acpi_tb_checksum(ACPI_CAST_PTR(u8, table), length);
210
211         /* Checksum ok? (should be zero) */
212
213         if (checksum) {
214                 ACPI_WARNING((AE_INFO,
215                               "Incorrect checksum in table [%4.4s] -  %2.2X, should be %2.2X",
216                               table->signature, table->checksum,
217                               (u8) (table->checksum - checksum)));
218
219 #if (ACPI_CHECKSUM_ABORT)
220
221                 return (AE_BAD_CHECKSUM);
222 #endif
223         }
224
225         return (AE_OK);
226 }
227
228 /*******************************************************************************
229  *
230  * FUNCTION:    acpi_tb_checksum
231  *
232  * PARAMETERS:  Buffer          - Pointer to memory region to be checked
233  *              Length          - Length of this memory region
234  *
235  * RETURN:      Checksum (u8)
236  *
237  * DESCRIPTION: Calculates circular checksum of memory region.
238  *
239  ******************************************************************************/
240
241 u8 acpi_tb_checksum(u8 * buffer, acpi_native_uint length)
242 {
243         u8 sum = 0;
244         u8 *end = buffer + length;
245
246         while (buffer < end) {
247                 sum = (u8) (sum + *(buffer++));
248         }
249
250         return sum;
251 }
252
253 /*******************************************************************************
254  *
255  * FUNCTION:    acpi_tb_install_table
256  *
257  * PARAMETERS:  Address                 - Physical address of DSDT or FACS
258  *              Flags                   - Flags
259  *              Signature               - Table signature, NULL if no need to
260  *                                        match
261  *              table_index             - Index into root table array
262  *
263  * RETURN:      None
264  *
265  * DESCRIPTION: Install an ACPI table into the global data structure.
266  *
267  ******************************************************************************/
268
269 void
270 acpi_tb_install_table(acpi_physical_address address,
271                       u8 flags, char *signature, acpi_native_uint table_index)
272 {
273         struct acpi_table_header *table;
274
275         if (!address) {
276                 ACPI_ERROR((AE_INFO,
277                             "Null physical address for ACPI table [%s]",
278                             signature));
279                 return;
280         }
281
282         /* Map just the table header */
283
284         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
285         if (!table) {
286                 return;
287         }
288
289         /* If a particular signature is expected, signature must match */
290
291         if (signature && !ACPI_COMPARE_NAME(table->signature, signature)) {
292                 ACPI_ERROR((AE_INFO,
293                             "Invalid signature 0x%X for ACPI table [%s]",
294                             *ACPI_CAST_PTR(u32, table->signature), signature));
295                 goto unmap_and_exit;
296         }
297
298         /* Initialize the table entry */
299
300         acpi_gbl_root_table_list.tables[table_index].address = address;
301         acpi_gbl_root_table_list.tables[table_index].length = table->length;
302         acpi_gbl_root_table_list.tables[table_index].flags = flags;
303
304         ACPI_MOVE_32_TO_32(&
305                            (acpi_gbl_root_table_list.tables[table_index].
306                             signature), table->signature);
307
308         acpi_tb_print_table_header(address, table);
309
310         if (table_index == ACPI_TABLE_INDEX_DSDT) {
311
312                 /* Global integer width is based upon revision of the DSDT */
313
314                 acpi_ut_set_integer_width(table->revision);
315         }
316
317       unmap_and_exit:
318         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
319 }
320
321 /*******************************************************************************
322  *
323  * FUNCTION:    acpi_tb_get_root_table_entry
324  *
325  * PARAMETERS:  table_entry         - Pointer to the RSDT/XSDT table entry
326  *              table_entry_size    - sizeof 32 or 64 (RSDT or XSDT)
327  *
328  * RETURN:      Physical address extracted from the root table
329  *
330  * DESCRIPTION: Get one root table entry. Handles 32-bit and 64-bit cases on
331  *              both 32-bit and 64-bit platforms
332  *
333  * NOTE:        acpi_physical_address is 32-bit on 32-bit platforms, 64-bit on
334  *              64-bit platforms.
335  *
336  ******************************************************************************/
337
338 static acpi_physical_address
339 acpi_tb_get_root_table_entry(u8 * table_entry,
340                              acpi_native_uint table_entry_size)
341 {
342         u64 address64;
343
344         /*
345          * Get the table physical address (32-bit for RSDT, 64-bit for XSDT):
346          * Note: Addresses are 32-bit aligned (not 64) in both RSDT and XSDT
347          */
348         if (table_entry_size == sizeof(u32)) {
349                 /*
350                  * 32-bit platform, RSDT: Return 32-bit table entry
351                  * 64-bit platform, RSDT: Expand 32-bit to 64-bit and return
352                  */
353                 return ((acpi_physical_address)
354                         (*ACPI_CAST_PTR(u32, table_entry)));
355         } else {
356                 /*
357                  * 32-bit platform, XSDT: Truncate 64-bit to 32-bit and return
358                  * 64-bit platform, XSDT: Move (unaligned) 64-bit to local, return 64-bit
359                  */
360                 ACPI_MOVE_64_TO_64(&address64, table_entry);
361
362 #if ACPI_MACHINE_WIDTH == 32
363                 if (address64 > ACPI_UINT32_MAX) {
364
365                         /* Will truncate 64-bit address to 32 bits, issue warning */
366
367                         ACPI_WARNING((AE_INFO,
368                                       "64-bit Physical Address in XSDT is too large (%8.8X%8.8X), truncating",
369                                       ACPI_FORMAT_UINT64(address64)));
370                 }
371 #endif
372                 return ((acpi_physical_address) (address64));
373         }
374 }
375
376 /*******************************************************************************
377  *
378  * FUNCTION:    acpi_tb_parse_root_table
379  *
380  * PARAMETERS:  Rsdp                    - Pointer to the RSDP
381  *              Flags                   - Flags
382  *
383  * RETURN:      Status
384  *
385  * DESCRIPTION: This function is called to parse the Root System Description
386  *              Table (RSDT or XSDT)
387  *
388  * NOTE:        Tables are mapped (not copied) for efficiency. The FACS must
389  *              be mapped and cannot be copied because it contains the actual
390  *              memory location of the ACPI Global Lock.
391  *
392  ******************************************************************************/
393
394 acpi_status __init
395 acpi_tb_parse_root_table(acpi_physical_address rsdp_address, u8 flags)
396 {
397         struct acpi_table_rsdp *rsdp;
398         acpi_native_uint table_entry_size;
399         acpi_native_uint i;
400         u32 table_count;
401         struct acpi_table_header *table;
402         acpi_physical_address address;
403         acpi_physical_address uninitialized_var(rsdt_address);
404         u32 length;
405         u8 *table_entry;
406         acpi_status status;
407
408         ACPI_FUNCTION_TRACE(tb_parse_root_table);
409
410         /*
411          * Map the entire RSDP and extract the address of the RSDT or XSDT
412          */
413         rsdp = acpi_os_map_memory(rsdp_address, sizeof(struct acpi_table_rsdp));
414         if (!rsdp) {
415                 return_ACPI_STATUS(AE_NO_MEMORY);
416         }
417
418         acpi_tb_print_table_header(rsdp_address,
419                                    ACPI_CAST_PTR(struct acpi_table_header,
420                                                  rsdp));
421
422         /* Differentiate between RSDT and XSDT root tables */
423
424         if (rsdp->revision > 1 && rsdp->xsdt_physical_address) {
425                 /*
426                  * Root table is an XSDT (64-bit physical addresses). We must use the
427                  * XSDT if the revision is > 1 and the XSDT pointer is present, as per
428                  * the ACPI specification.
429                  */
430                 address = (acpi_physical_address) rsdp->xsdt_physical_address;
431                 table_entry_size = sizeof(u64);
432                 rsdt_address = (acpi_physical_address)
433                                         rsdp->rsdt_physical_address;
434         } else {
435                 /* Root table is an RSDT (32-bit physical addresses) */
436
437                 address = (acpi_physical_address) rsdp->rsdt_physical_address;
438                 table_entry_size = sizeof(u32);
439         }
440
441         /*
442          * It is not possible to map more than one entry in some environments,
443          * so unmap the RSDP here before mapping other tables
444          */
445         acpi_os_unmap_memory(rsdp, sizeof(struct acpi_table_rsdp));
446
447         if (table_entry_size == sizeof(u64)) {
448                 if (acpi_tb_check_xsdt(address) == AE_NULL_ENTRY) {
449                         /* XSDT has NULL entry, RSDT is used */
450                         address = rsdt_address;
451                         table_entry_size = sizeof(u32);
452                         ACPI_WARNING((AE_INFO, "BIOS XSDT has NULL entry,"
453                                         "using RSDT"));
454                 }
455         }
456         /* Map the RSDT/XSDT table header to get the full table length */
457
458         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
459         if (!table) {
460                 return_ACPI_STATUS(AE_NO_MEMORY);
461         }
462
463         acpi_tb_print_table_header(address, table);
464
465         /* Get the length of the full table, verify length and map entire table */
466
467         length = table->length;
468         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
469
470         if (length < sizeof(struct acpi_table_header)) {
471                 ACPI_ERROR((AE_INFO, "Invalid length 0x%X in RSDT/XSDT",
472                             length));
473                 return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
474         }
475
476         table = acpi_os_map_memory(address, length);
477         if (!table) {
478                 return_ACPI_STATUS(AE_NO_MEMORY);
479         }
480
481         /* Validate the root table checksum */
482
483         status = acpi_tb_verify_checksum(table, length);
484         if (ACPI_FAILURE(status)) {
485                 acpi_os_unmap_memory(table, length);
486                 return_ACPI_STATUS(status);
487         }
488
489         /* Calculate the number of tables described in the root table */
490
491         table_count =
492             (u32) ((table->length -
493                     sizeof(struct acpi_table_header)) / table_entry_size);
494
495         /*
496          * First two entries in the table array are reserved for the DSDT and FACS,
497          * which are not actually present in the RSDT/XSDT - they come from the FADT
498          */
499         table_entry =
500             ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
501         acpi_gbl_root_table_list.count = 2;
502
503         /*
504          * Initialize the root table array from the RSDT/XSDT
505          */
506         for (i = 0; i < table_count; i++) {
507                 if (acpi_gbl_root_table_list.count >=
508                     acpi_gbl_root_table_list.size) {
509
510                         /* There is no more room in the root table array, attempt resize */
511
512                         status = acpi_tb_resize_root_table_list();
513                         if (ACPI_FAILURE(status)) {
514                                 ACPI_WARNING((AE_INFO,
515                                               "Truncating %u table entries!",
516                                               (unsigned)
517                                               (acpi_gbl_root_table_list.size -
518                                                acpi_gbl_root_table_list.
519                                                count)));
520                                 break;
521                         }
522                 }
523
524                 /* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */
525
526                 acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count].
527                     address =
528                     acpi_tb_get_root_table_entry(table_entry, table_entry_size);
529
530                 table_entry += table_entry_size;
531                 acpi_gbl_root_table_list.count++;
532         }
533
534         /*
535          * It is not possible to map more than one entry in some environments,
536          * so unmap the root table here before mapping other tables
537          */
538         acpi_os_unmap_memory(table, length);
539
540         /*
541          * Complete the initialization of the root table array by examining
542          * the header of each table
543          */
544         for (i = 2; i < acpi_gbl_root_table_list.count; i++) {
545                 acpi_tb_install_table(acpi_gbl_root_table_list.tables[i].
546                                       address, flags, NULL, i);
547
548                 /* Special case for FADT - get the DSDT and FACS */
549
550                 if (ACPI_COMPARE_NAME
551                     (&acpi_gbl_root_table_list.tables[i].signature,
552                      ACPI_SIG_FADT)) {
553                         acpi_tb_parse_fadt(i, flags);
554                 }
555         }
556
557         return_ACPI_STATUS(AE_OK);
558 }