Revert "ARM: tegra: tegratab: dummy change"
[linux-2.6.git] / drivers / acpi / acpica / tbfadt.c
1 /******************************************************************************
2  *
3  * Module Name: tbfadt   - FADT table utilities
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2012, Intel Corp.
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 "accommon.h"
46 #include "actables.h"
47
48 #define _COMPONENT          ACPI_TABLES
49 ACPI_MODULE_NAME("tbfadt")
50
51 /* Local prototypes */
52 static ACPI_INLINE void
53 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
54                              u8 space_id, u8 byte_width, u64 address);
55
56 static void acpi_tb_convert_fadt(void);
57
58 static void acpi_tb_validate_fadt(void);
59
60 static void acpi_tb_setup_fadt_registers(void);
61
62 /* Table for conversion of FADT to common internal format and FADT validation */
63
64 typedef struct acpi_fadt_info {
65         char *name;
66         u16 address64;
67         u16 address32;
68         u16 length;
69         u8 default_length;
70         u8 type;
71
72 } acpi_fadt_info;
73
74 #define ACPI_FADT_OPTIONAL          0
75 #define ACPI_FADT_REQUIRED          1
76 #define ACPI_FADT_SEPARATE_LENGTH   2
77
78 static struct acpi_fadt_info fadt_info_table[] = {
79         {"Pm1aEventBlock",
80          ACPI_FADT_OFFSET(xpm1a_event_block),
81          ACPI_FADT_OFFSET(pm1a_event_block),
82          ACPI_FADT_OFFSET(pm1_event_length),
83          ACPI_PM1_REGISTER_WIDTH * 2,   /* Enable + Status register */
84          ACPI_FADT_REQUIRED},
85
86         {"Pm1bEventBlock",
87          ACPI_FADT_OFFSET(xpm1b_event_block),
88          ACPI_FADT_OFFSET(pm1b_event_block),
89          ACPI_FADT_OFFSET(pm1_event_length),
90          ACPI_PM1_REGISTER_WIDTH * 2,   /* Enable + Status register */
91          ACPI_FADT_OPTIONAL},
92
93         {"Pm1aControlBlock",
94          ACPI_FADT_OFFSET(xpm1a_control_block),
95          ACPI_FADT_OFFSET(pm1a_control_block),
96          ACPI_FADT_OFFSET(pm1_control_length),
97          ACPI_PM1_REGISTER_WIDTH,
98          ACPI_FADT_REQUIRED},
99
100         {"Pm1bControlBlock",
101          ACPI_FADT_OFFSET(xpm1b_control_block),
102          ACPI_FADT_OFFSET(pm1b_control_block),
103          ACPI_FADT_OFFSET(pm1_control_length),
104          ACPI_PM1_REGISTER_WIDTH,
105          ACPI_FADT_OPTIONAL},
106
107         {"Pm2ControlBlock",
108          ACPI_FADT_OFFSET(xpm2_control_block),
109          ACPI_FADT_OFFSET(pm2_control_block),
110          ACPI_FADT_OFFSET(pm2_control_length),
111          ACPI_PM2_REGISTER_WIDTH,
112          ACPI_FADT_SEPARATE_LENGTH},
113
114         {"PmTimerBlock",
115          ACPI_FADT_OFFSET(xpm_timer_block),
116          ACPI_FADT_OFFSET(pm_timer_block),
117          ACPI_FADT_OFFSET(pm_timer_length),
118          ACPI_PM_TIMER_WIDTH,
119          ACPI_FADT_REQUIRED},
120
121         {"Gpe0Block",
122          ACPI_FADT_OFFSET(xgpe0_block),
123          ACPI_FADT_OFFSET(gpe0_block),
124          ACPI_FADT_OFFSET(gpe0_block_length),
125          0,
126          ACPI_FADT_SEPARATE_LENGTH},
127
128         {"Gpe1Block",
129          ACPI_FADT_OFFSET(xgpe1_block),
130          ACPI_FADT_OFFSET(gpe1_block),
131          ACPI_FADT_OFFSET(gpe1_block_length),
132          0,
133          ACPI_FADT_SEPARATE_LENGTH}
134 };
135
136 #define ACPI_FADT_INFO_ENTRIES \
137                         (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info))
138
139 /* Table used to split Event Blocks into separate status/enable registers */
140
141 typedef struct acpi_fadt_pm_info {
142         struct acpi_generic_address *target;
143         u16 source;
144         u8 register_num;
145
146 } acpi_fadt_pm_info;
147
148 static struct acpi_fadt_pm_info fadt_pm_info_table[] = {
149         {&acpi_gbl_xpm1a_status,
150          ACPI_FADT_OFFSET(xpm1a_event_block),
151          0},
152
153         {&acpi_gbl_xpm1a_enable,
154          ACPI_FADT_OFFSET(xpm1a_event_block),
155          1},
156
157         {&acpi_gbl_xpm1b_status,
158          ACPI_FADT_OFFSET(xpm1b_event_block),
159          0},
160
161         {&acpi_gbl_xpm1b_enable,
162          ACPI_FADT_OFFSET(xpm1b_event_block),
163          1}
164 };
165
166 #define ACPI_FADT_PM_INFO_ENTRIES \
167                         (sizeof (fadt_pm_info_table) / sizeof (struct acpi_fadt_pm_info))
168
169 /*******************************************************************************
170  *
171  * FUNCTION:    acpi_tb_init_generic_address
172  *
173  * PARAMETERS:  generic_address     - GAS struct to be initialized
174  *              byte_width          - Width of this register
175  *              Address             - Address of the register
176  *
177  * RETURN:      None
178  *
179  * DESCRIPTION: Initialize a Generic Address Structure (GAS)
180  *              See the ACPI specification for a full description and
181  *              definition of this structure.
182  *
183  ******************************************************************************/
184
185 static ACPI_INLINE void
186 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
187                              u8 space_id, u8 byte_width, u64 address)
188 {
189
190         /*
191          * The 64-bit Address field is non-aligned in the byte packed
192          * GAS struct.
193          */
194         ACPI_MOVE_64_TO_64(&generic_address->address, &address);
195
196         /* All other fields are byte-wide */
197
198         generic_address->space_id = space_id;
199         generic_address->bit_width = (u8)ACPI_MUL_8(byte_width);
200         generic_address->bit_offset = 0;
201         generic_address->access_width = 0;      /* Access width ANY */
202 }
203
204 /*******************************************************************************
205  *
206  * FUNCTION:    acpi_tb_parse_fadt
207  *
208  * PARAMETERS:  table_index         - Index for the FADT
209  *
210  * RETURN:      None
211  *
212  * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
213  *              (FADT contains the addresses of the DSDT and FACS)
214  *
215  ******************************************************************************/
216
217 void acpi_tb_parse_fadt(u32 table_index)
218 {
219         u32 length;
220         struct acpi_table_header *table;
221
222         /*
223          * The FADT has multiple versions with different lengths,
224          * and it contains pointers to both the DSDT and FACS tables.
225          *
226          * Get a local copy of the FADT and convert it to a common format
227          * Map entire FADT, assumed to be smaller than one page.
228          */
229         length = acpi_gbl_root_table_list.tables[table_index].length;
230
231         table =
232             acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index].
233                                address, length);
234         if (!table) {
235                 return;
236         }
237
238         /*
239          * Validate the FADT checksum before we copy the table. Ignore
240          * checksum error as we want to try to get the DSDT and FACS.
241          */
242         (void)acpi_tb_verify_checksum(table, length);
243
244         /* Create a local copy of the FADT in common ACPI 2.0+ format */
245
246         acpi_tb_create_local_fadt(table, length);
247
248         /* All done with the real FADT, unmap it */
249
250         acpi_os_unmap_memory(table, length);
251
252         /* Obtain the DSDT and FACS tables via their addresses within the FADT */
253
254         acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt,
255                               ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
256
257         /* If Hardware Reduced flag is set, there is no FACS */
258
259         if (!acpi_gbl_reduced_hardware) {
260                 acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.
261                                       Xfacs, ACPI_SIG_FACS,
262                                       ACPI_TABLE_INDEX_FACS);
263         }
264 }
265
266 /*******************************************************************************
267  *
268  * FUNCTION:    acpi_tb_create_local_fadt
269  *
270  * PARAMETERS:  Table               - Pointer to BIOS FADT
271  *              Length              - Length of the table
272  *
273  * RETURN:      None
274  *
275  * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
276  *              Performs validation on some important FADT fields.
277  *
278  * NOTE:        We create a local copy of the FADT regardless of the version.
279  *
280  ******************************************************************************/
281
282 void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
283 {
284         /*
285          * Check if the FADT is larger than the largest table that we expect
286          * (the ACPI 5.0 version). If so, truncate the table, and issue
287          * a warning.
288          */
289         if (length > sizeof(struct acpi_table_fadt)) {
290                 ACPI_WARNING((AE_INFO,
291                               "FADT (revision %u) is longer than ACPI 5.0 version, "
292                               "truncating length %u to %u",
293                               table->revision, length,
294                               (u32)sizeof(struct acpi_table_fadt)));
295         }
296
297         /* Clear the entire local FADT */
298
299         ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt));
300
301         /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */
302
303         ACPI_MEMCPY(&acpi_gbl_FADT, table,
304                     ACPI_MIN(length, sizeof(struct acpi_table_fadt)));
305
306         /* Take a copy of the Hardware Reduced flag */
307
308         acpi_gbl_reduced_hardware = FALSE;
309         if (acpi_gbl_FADT.flags & ACPI_FADT_HW_REDUCED) {
310                 acpi_gbl_reduced_hardware = TRUE;
311         }
312
313         /* Convert the local copy of the FADT to the common internal format */
314
315         acpi_tb_convert_fadt();
316
317         /* Validate FADT values now, before we make any changes */
318
319         acpi_tb_validate_fadt();
320
321         /* Initialize the global ACPI register structures */
322
323         acpi_tb_setup_fadt_registers();
324 }
325
326 /*******************************************************************************
327  *
328  * FUNCTION:    acpi_tb_convert_fadt
329  *
330  * PARAMETERS:  None, uses acpi_gbl_FADT
331  *
332  * RETURN:      None
333  *
334  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
335  *              Expand 32-bit addresses to 64-bit as necessary.
336  *
337  * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt),
338  *              and must contain a copy of the actual FADT.
339  *
340  * Notes on 64-bit register addresses:
341  *
342  * After this FADT conversion, later ACPICA code will only use the 64-bit "X"
343  * fields of the FADT for all ACPI register addresses.
344  *
345  * The 64-bit "X" fields are optional extensions to the original 32-bit FADT
346  * V1.0 fields. Even if they are present in the FADT, they are optional and
347  * are unused if the BIOS sets them to zero. Therefore, we must copy/expand
348  * 32-bit V1.0 fields if the corresponding X field is zero.
349  *
350  * For ACPI 1.0 FADTs, all 32-bit address fields are expanded to the
351  * corresponding "X" fields in the internal FADT.
352  *
353  * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded
354  * to the corresponding 64-bit X fields. For compatibility with other ACPI
355  * implementations, we ignore the 64-bit field if the 32-bit field is valid,
356  * regardless of whether the host OS is 32-bit or 64-bit.
357  *
358  ******************************************************************************/
359
360 static void acpi_tb_convert_fadt(void)
361 {
362         struct acpi_generic_address *address64;
363         u32 address32;
364         u32 i;
365
366         /*
367          * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary.
368          * Later code will always use the X 64-bit field. Also, check for an
369          * address mismatch between the 32-bit and 64-bit address fields
370          * (FIRMWARE_CTRL/X_FIRMWARE_CTRL, DSDT/X_DSDT) which would indicate
371          * the presence of two FACS or two DSDT tables.
372          */
373         if (!acpi_gbl_FADT.Xfacs) {
374                 acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
375         } else if (acpi_gbl_FADT.facs &&
376                    (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) {
377                 ACPI_WARNING((AE_INFO,
378                     "32/64 FACS address mismatch in FADT - two FACS tables!"));
379         }
380
381         if (!acpi_gbl_FADT.Xdsdt) {
382                 acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
383         } else if (acpi_gbl_FADT.dsdt &&
384                    (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) {
385                 ACPI_WARNING((AE_INFO,
386                     "32/64 DSDT address mismatch in FADT - two DSDT tables!"));
387         }
388
389         /*
390          * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
391          * should be zero are indeed zero. This will workaround BIOSs that
392          * inadvertently place values in these fields.
393          *
394          * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at
395          * offset 45, 55, 95, and the word located at offset 109, 110.
396          *
397          * Note: The FADT revision value is unreliable. Only the length can be
398          * trusted.
399          */
400         if (acpi_gbl_FADT.header.length <= ACPI_FADT_V2_SIZE) {
401                 acpi_gbl_FADT.preferred_profile = 0;
402                 acpi_gbl_FADT.pstate_control = 0;
403                 acpi_gbl_FADT.cst_control = 0;
404                 acpi_gbl_FADT.boot_flags = 0;
405         }
406
407         /* Update the local FADT table header length */
408
409         acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
410
411         /*
412          * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
413          * generic address structures as necessary. Later code will always use
414          * the 64-bit address structures.
415          *
416          * March 2009:
417          * We now always use the 32-bit address if it is valid (non-null). This
418          * is not in accordance with the ACPI specification which states that
419          * the 64-bit address supersedes the 32-bit version, but we do this for
420          * compatibility with other ACPI implementations. Most notably, in the
421          * case where both the 32 and 64 versions are non-null, we use the 32-bit
422          * version. This is the only address that is guaranteed to have been
423          * tested by the BIOS manufacturer.
424          */
425         for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
426                 address32 = *ACPI_ADD_PTR(u32,
427                                           &acpi_gbl_FADT,
428                                           fadt_info_table[i].address32);
429
430                 address64 = ACPI_ADD_PTR(struct acpi_generic_address,
431                                          &acpi_gbl_FADT,
432                                          fadt_info_table[i].address64);
433
434                 /*
435                  * If both 32- and 64-bit addresses are valid (non-zero),
436                  * they must match.
437                  */
438                 if (address64->address && address32 &&
439                     (address64->address != (u64) address32)) {
440                         ACPI_ERROR((AE_INFO,
441                                     "32/64X address mismatch in %s: 0x%8.8X/0x%8.8X%8.8X, using 32",
442                                     fadt_info_table[i].name, address32,
443                                     ACPI_FORMAT_UINT64(address64->address)));
444                 }
445
446                 /* Always use 32-bit address if it is valid (non-null) */
447
448                 if (address32) {
449                         /*
450                          * Copy the 32-bit address to the 64-bit GAS structure. The
451                          * Space ID is always I/O for 32-bit legacy address fields
452                         */
453                         acpi_tb_init_generic_address(address64,
454                                                      ACPI_ADR_SPACE_SYSTEM_IO,
455                                                      *ACPI_ADD_PTR(u8,
456                                                                    &acpi_gbl_FADT,
457                                                                    fadt_info_table
458                                                                    [i].length),
459                                                      (u64) address32);
460                 }
461         }
462 }
463
464 /*******************************************************************************
465  *
466  * FUNCTION:    acpi_tb_validate_fadt
467  *
468  * PARAMETERS:  Table           - Pointer to the FADT to be validated
469  *
470  * RETURN:      None
471  *
472  * DESCRIPTION: Validate various important fields within the FADT. If a problem
473  *              is found, issue a message, but no status is returned.
474  *              Used by both the table manager and the disassembler.
475  *
476  * Possible additional checks:
477  * (acpi_gbl_FADT.pm1_event_length >= 4)
478  * (acpi_gbl_FADT.pm1_control_length >= 2)
479  * (acpi_gbl_FADT.pm_timer_length >= 4)
480  * Gpe block lengths must be multiple of 2
481  *
482  ******************************************************************************/
483
484 static void acpi_tb_validate_fadt(void)
485 {
486         char *name;
487         struct acpi_generic_address *address64;
488         u8 length;
489         u32 i;
490
491         /*
492          * Check for FACS and DSDT address mismatches. An address mismatch between
493          * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
494          * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables.
495          */
496         if (acpi_gbl_FADT.facs &&
497             (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) {
498                 ACPI_WARNING((AE_INFO,
499                               "32/64X FACS address mismatch in FADT - "
500                               "0x%8.8X/0x%8.8X%8.8X, using 32",
501                               acpi_gbl_FADT.facs,
502                               ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs)));
503
504                 acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
505         }
506
507         if (acpi_gbl_FADT.dsdt &&
508             (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) {
509                 ACPI_WARNING((AE_INFO,
510                               "32/64X DSDT address mismatch in FADT - "
511                               "0x%8.8X/0x%8.8X%8.8X, using 32",
512                               acpi_gbl_FADT.dsdt,
513                               ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt)));
514
515                 acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
516         }
517
518         /* If Hardware Reduced flag is set, we are all done */
519
520         if (acpi_gbl_reduced_hardware) {
521                 return;
522         }
523
524         /* Examine all of the 64-bit extended address fields (X fields) */
525
526         for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
527                 /*
528                  * Generate pointer to the 64-bit address, get the register
529                  * length (width) and the register name
530                  */
531                 address64 = ACPI_ADD_PTR(struct acpi_generic_address,
532                                          &acpi_gbl_FADT,
533                                          fadt_info_table[i].address64);
534                 length =
535                     *ACPI_ADD_PTR(u8, &acpi_gbl_FADT,
536                                   fadt_info_table[i].length);
537                 name = fadt_info_table[i].name;
538
539                 /*
540                  * For each extended field, check for length mismatch between the
541                  * legacy length field and the corresponding 64-bit X length field.
542                  */
543                 if (address64->address &&
544                     (address64->bit_width != ACPI_MUL_8(length))) {
545                         ACPI_WARNING((AE_INFO,
546                                       "32/64X length mismatch in %s: %u/%u",
547                                       name, ACPI_MUL_8(length),
548                                       address64->bit_width));
549                 }
550
551                 if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
552                         /*
553                          * Field is required (Pm1a_event, Pm1a_control, pm_timer).
554                          * Both the address and length must be non-zero.
555                          */
556                         if (!address64->address || !length) {
557                                 ACPI_ERROR((AE_INFO,
558                                             "Required field %s has zero address and/or length:"
559                                             " 0x%8.8X%8.8X/0x%X",
560                                             name,
561                                             ACPI_FORMAT_UINT64(address64->
562                                                                address),
563                                             length));
564                         }
565                 } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) {
566                         /*
567                          * Field is optional (PM2Control, GPE0, GPE1) AND has its own
568                          * length field. If present, both the address and length must
569                          * be valid.
570                          */
571                         if ((address64->address && !length) ||
572                             (!address64->address && length)) {
573                                 ACPI_WARNING((AE_INFO,
574                                               "Optional field %s has zero address or length: "
575                                               "0x%8.8X%8.8X/0x%X",
576                                               name,
577                                               ACPI_FORMAT_UINT64(address64->
578                                                                  address),
579                                               length));
580                         }
581                 }
582         }
583 }
584
585 /*******************************************************************************
586  *
587  * FUNCTION:    acpi_tb_setup_fadt_registers
588  *
589  * PARAMETERS:  None, uses acpi_gbl_FADT.
590  *
591  * RETURN:      None
592  *
593  * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally,
594  *              force FADT register definitions to their default lengths.
595  *
596  ******************************************************************************/
597
598 static void acpi_tb_setup_fadt_registers(void)
599 {
600         struct acpi_generic_address *target64;
601         struct acpi_generic_address *source64;
602         u8 pm1_register_byte_width;
603         u32 i;
604
605         /*
606          * Optionally check all register lengths against the default values and
607          * update them if they are incorrect.
608          */
609         if (acpi_gbl_use_default_register_widths) {
610                 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
611                         target64 =
612                             ACPI_ADD_PTR(struct acpi_generic_address,
613                                          &acpi_gbl_FADT,
614                                          fadt_info_table[i].address64);
615
616                         /*
617                          * If a valid register (Address != 0) and the (default_length > 0)
618                          * (Not a GPE register), then check the width against the default.
619                          */
620                         if ((target64->address) &&
621                             (fadt_info_table[i].default_length > 0) &&
622                             (fadt_info_table[i].default_length !=
623                              target64->bit_width)) {
624                                 ACPI_WARNING((AE_INFO,
625                                               "Invalid length for %s: %u, using default %u",
626                                               fadt_info_table[i].name,
627                                               target64->bit_width,
628                                               fadt_info_table[i].
629                                               default_length));
630
631                                 /* Incorrect size, set width to the default */
632
633                                 target64->bit_width =
634                                     fadt_info_table[i].default_length;
635                         }
636                 }
637         }
638
639         /*
640          * Get the length of the individual PM1 registers (enable and status).
641          * Each register is defined to be (event block length / 2). Extra divide
642          * by 8 converts bits to bytes.
643          */
644         pm1_register_byte_width = (u8)
645             ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width);
646
647         /*
648          * Calculate separate GAS structs for the PM1x (A/B) Status and Enable
649          * registers. These addresses do not appear (directly) in the FADT, so it
650          * is useful to pre-calculate them from the PM1 Event Block definitions.
651          *
652          * The PM event blocks are split into two register blocks, first is the
653          * PM Status Register block, followed immediately by the PM Enable
654          * Register block. Each is of length (pm1_event_length/2)
655          *
656          * Note: The PM1A event block is required by the ACPI specification.
657          * However, the PM1B event block is optional and is rarely, if ever,
658          * used.
659          */
660
661         for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) {
662                 source64 =
663                     ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,
664                                  fadt_pm_info_table[i].source);
665
666                 if (source64->address) {
667                         acpi_tb_init_generic_address(fadt_pm_info_table[i].
668                                                      target, source64->space_id,
669                                                      pm1_register_byte_width,
670                                                      source64->address +
671                                                      (fadt_pm_info_table[i].
672                                                       register_num *
673                                                       pm1_register_byte_width));
674                 }
675         }
676 }