xref: /titanic_41/usr/src/uts/intel/io/acpica/tables/tbfadt.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: tbfadt   - FADT table utilities
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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.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 
53 static void
54 AcpiTbInitGenericAddress (
55     ACPI_GENERIC_ADDRESS    *GenericAddress,
56     UINT8                   SpaceId,
57     UINT8                   ByteWidth,
58     UINT64                  Address,
59     const char              *RegisterName,
60     UINT8                   Flags);
61 
62 static void
63 AcpiTbConvertFadt (
64     void);
65 
66 static void
67 AcpiTbSetupFadtRegisters (
68     void);
69 
70 static UINT64
71 AcpiTbSelectAddress (
72     char                    *RegisterName,
73     UINT32                  Address32,
74     UINT64                  Address64);
75 
76 
77 /* Table for conversion of FADT to common internal format and FADT validation */
78 
79 typedef struct acpi_fadt_info
80 {
81     const char              *Name;
82     UINT16                  Address64;
83     UINT16                  Address32;
84     UINT16                  Length;
85     UINT8                   DefaultLength;
86     UINT8                   Flags;
87 
88 } ACPI_FADT_INFO;
89 
90 #define ACPI_FADT_OPTIONAL          0
91 #define ACPI_FADT_REQUIRED          1
92 #define ACPI_FADT_SEPARATE_LENGTH   2
93 #define ACPI_FADT_GPE_REGISTER      4
94 
95 static ACPI_FADT_INFO     FadtInfoTable[] =
96 {
97     {"Pm1aEventBlock",
98         ACPI_FADT_OFFSET (XPm1aEventBlock),
99         ACPI_FADT_OFFSET (Pm1aEventBlock),
100         ACPI_FADT_OFFSET (Pm1EventLength),
101         ACPI_PM1_REGISTER_WIDTH * 2,        /* Enable + Status register */
102         ACPI_FADT_REQUIRED},
103 
104     {"Pm1bEventBlock",
105         ACPI_FADT_OFFSET (XPm1bEventBlock),
106         ACPI_FADT_OFFSET (Pm1bEventBlock),
107         ACPI_FADT_OFFSET (Pm1EventLength),
108         ACPI_PM1_REGISTER_WIDTH * 2,        /* Enable + Status register */
109         ACPI_FADT_OPTIONAL},
110 
111     {"Pm1aControlBlock",
112         ACPI_FADT_OFFSET (XPm1aControlBlock),
113         ACPI_FADT_OFFSET (Pm1aControlBlock),
114         ACPI_FADT_OFFSET (Pm1ControlLength),
115         ACPI_PM1_REGISTER_WIDTH,
116         ACPI_FADT_REQUIRED},
117 
118     {"Pm1bControlBlock",
119         ACPI_FADT_OFFSET (XPm1bControlBlock),
120         ACPI_FADT_OFFSET (Pm1bControlBlock),
121         ACPI_FADT_OFFSET (Pm1ControlLength),
122         ACPI_PM1_REGISTER_WIDTH,
123         ACPI_FADT_OPTIONAL},
124 
125     {"Pm2ControlBlock",
126         ACPI_FADT_OFFSET (XPm2ControlBlock),
127         ACPI_FADT_OFFSET (Pm2ControlBlock),
128         ACPI_FADT_OFFSET (Pm2ControlLength),
129         ACPI_PM2_REGISTER_WIDTH,
130         ACPI_FADT_SEPARATE_LENGTH},
131 
132     {"PmTimerBlock",
133         ACPI_FADT_OFFSET (XPmTimerBlock),
134         ACPI_FADT_OFFSET (PmTimerBlock),
135         ACPI_FADT_OFFSET (PmTimerLength),
136         ACPI_PM_TIMER_WIDTH,
137         ACPI_FADT_SEPARATE_LENGTH},         /* ACPI 5.0A: Timer is optional */
138 
139     {"Gpe0Block",
140         ACPI_FADT_OFFSET (XGpe0Block),
141         ACPI_FADT_OFFSET (Gpe0Block),
142         ACPI_FADT_OFFSET (Gpe0BlockLength),
143         0,
144         ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER},
145 
146     {"Gpe1Block",
147         ACPI_FADT_OFFSET (XGpe1Block),
148         ACPI_FADT_OFFSET (Gpe1Block),
149         ACPI_FADT_OFFSET (Gpe1BlockLength),
150         0,
151         ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER}
152 };
153 
154 #define ACPI_FADT_INFO_ENTRIES \
155             (sizeof (FadtInfoTable) / sizeof (ACPI_FADT_INFO))
156 
157 
158 /* Table used to split Event Blocks into separate status/enable registers */
159 
160 typedef struct acpi_fadt_pm_info
161 {
162     ACPI_GENERIC_ADDRESS    *Target;
163     UINT16                  Source;
164     UINT8                   RegisterNum;
165 
166 } ACPI_FADT_PM_INFO;
167 
168 static ACPI_FADT_PM_INFO    FadtPmInfoTable[] =
169 {
170     {&AcpiGbl_XPm1aStatus,
171         ACPI_FADT_OFFSET (XPm1aEventBlock),
172         0},
173 
174     {&AcpiGbl_XPm1aEnable,
175         ACPI_FADT_OFFSET (XPm1aEventBlock),
176         1},
177 
178     {&AcpiGbl_XPm1bStatus,
179         ACPI_FADT_OFFSET (XPm1bEventBlock),
180         0},
181 
182     {&AcpiGbl_XPm1bEnable,
183         ACPI_FADT_OFFSET (XPm1bEventBlock),
184         1}
185 };
186 
187 #define ACPI_FADT_PM_INFO_ENTRIES \
188             (sizeof (FadtPmInfoTable) / sizeof (ACPI_FADT_PM_INFO))
189 
190 
191 /*******************************************************************************
192  *
193  * FUNCTION:    AcpiTbInitGenericAddress
194  *
195  * PARAMETERS:  GenericAddress      - GAS struct to be initialized
196  *              SpaceId             - ACPI Space ID for this register
197  *              ByteWidth           - Width of this register
198  *              Address             - Address of the register
199  *              RegisterName        - ASCII name of the ACPI register
200  *
201  * RETURN:      None
202  *
203  * DESCRIPTION: Initialize a Generic Address Structure (GAS)
204  *              See the ACPI specification for a full description and
205  *              definition of this structure.
206  *
207  ******************************************************************************/
208 
209 static void
AcpiTbInitGenericAddress(ACPI_GENERIC_ADDRESS * GenericAddress,UINT8 SpaceId,UINT8 ByteWidth,UINT64 Address,const char * RegisterName,UINT8 Flags)210 AcpiTbInitGenericAddress (
211     ACPI_GENERIC_ADDRESS    *GenericAddress,
212     UINT8                   SpaceId,
213     UINT8                   ByteWidth,
214     UINT64                  Address,
215     const char              *RegisterName,
216     UINT8                   Flags)
217 {
218     UINT8                   BitWidth;
219 
220 
221     /*
222      * Bit width field in the GAS is only one byte long, 255 max.
223      * Check for BitWidth overflow in GAS.
224      */
225     BitWidth = (UINT8) (ByteWidth * 8);
226     if (ByteWidth > 31)     /* (31*8)=248, (32*8)=256 */
227     {
228         /*
229          * No error for GPE blocks, because we do not use the BitWidth
230          * for GPEs, the legacy length (ByteWidth) is used instead to
231          * allow for a large number of GPEs.
232          */
233         if (!(Flags & ACPI_FADT_GPE_REGISTER))
234         {
235             ACPI_ERROR ((AE_INFO,
236                 "%s - 32-bit FADT register is too long (%u bytes, %u bits) "
237                 "to convert to GAS struct - 255 bits max, truncating",
238                 RegisterName, ByteWidth, (ByteWidth * 8)));
239         }
240 
241         BitWidth = 255;
242     }
243 
244     /*
245      * The 64-bit Address field is non-aligned in the byte packed
246      * GAS struct.
247      */
248     ACPI_MOVE_64_TO_64 (&GenericAddress->Address, &Address);
249 
250     /* All other fields are byte-wide */
251 
252     GenericAddress->SpaceId = SpaceId;
253     GenericAddress->BitWidth = BitWidth;
254     GenericAddress->BitOffset = 0;
255     GenericAddress->AccessWidth = 0; /* Access width ANY */
256 }
257 
258 
259 /*******************************************************************************
260  *
261  * FUNCTION:    AcpiTbSelectAddress
262  *
263  * PARAMETERS:  RegisterName        - ASCII name of the ACPI register
264  *              Address32           - 32-bit address of the register
265  *              Address64           - 64-bit address of the register
266  *
267  * RETURN:      The resolved 64-bit address
268  *
269  * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within
270  *              the FADT. Used for the FACS and DSDT addresses.
271  *
272  * NOTES:
273  *
274  * Check for FACS and DSDT address mismatches. An address mismatch between
275  * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
276  * DSDT/X_DSDT) could be a corrupted address field or it might indicate
277  * the presence of two FACS or two DSDT tables.
278  *
279  * November 2013:
280  * By default, as per the ACPICA specification, a valid 64-bit address is
281  * used regardless of the value of the 32-bit address. However, this
282  * behavior can be overridden via the AcpiGbl_Use32BitFadtAddresses flag.
283  *
284  ******************************************************************************/
285 
286 static UINT64
AcpiTbSelectAddress(char * RegisterName,UINT32 Address32,UINT64 Address64)287 AcpiTbSelectAddress (
288     char                    *RegisterName,
289     UINT32                  Address32,
290     UINT64                  Address64)
291 {
292 
293     if (!Address64)
294     {
295         /* 64-bit address is zero, use 32-bit address */
296 
297         return ((UINT64) Address32);
298     }
299 
300     if (Address32 &&
301        (Address64 != (UINT64) Address32))
302     {
303         /* Address mismatch between 32-bit and 64-bit versions */
304 
305         ACPI_BIOS_WARNING ((AE_INFO,
306             "32/64X %s address mismatch in FADT: "
307             "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
308             RegisterName, Address32, ACPI_FORMAT_UINT64 (Address64),
309             AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
310 
311         /* 32-bit address override */
312 
313         if (AcpiGbl_Use32BitFadtAddresses)
314         {
315             return ((UINT64) Address32);
316         }
317     }
318 
319     /* Default is to use the 64-bit address */
320 
321     return (Address64);
322 }
323 
324 
325 /*******************************************************************************
326  *
327  * FUNCTION:    AcpiTbParseFadt
328  *
329  * PARAMETERS:  None
330  *
331  * RETURN:      None
332  *
333  * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
334  *              (FADT contains the addresses of the DSDT and FACS)
335  *
336  ******************************************************************************/
337 
338 void
AcpiTbParseFadt(void)339 AcpiTbParseFadt (
340     void)
341 {
342     UINT32                  Length;
343     ACPI_TABLE_HEADER       *Table;
344 
345 
346     /*
347      * The FADT has multiple versions with different lengths,
348      * and it contains pointers to both the DSDT and FACS tables.
349      *
350      * Get a local copy of the FADT and convert it to a common format
351      * Map entire FADT, assumed to be smaller than one page.
352      */
353     Length = AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Length;
354 
355     Table = AcpiOsMapMemory (
356         AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Address, Length);
357     if (!Table)
358     {
359         return;
360     }
361 
362     /*
363      * Validate the FADT checksum before we copy the table. Ignore
364      * checksum error as we want to try to get the DSDT and FACS.
365      */
366     (void) AcpiTbVerifyChecksum (Table, Length);
367 
368     /* Create a local copy of the FADT in common ACPI 2.0+ format */
369 
370     AcpiTbCreateLocalFadt (Table, Length);
371 
372     /* All done with the real FADT, unmap it */
373 
374     AcpiOsUnmapMemory (Table, Length);
375 
376     /* Obtain the DSDT and FACS tables via their addresses within the FADT */
377 
378     AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,
379         ACPI_SIG_DSDT, &AcpiGbl_DsdtIndex);
380 
381     /* If Hardware Reduced flag is set, there is no FACS */
382 
383     if (!AcpiGbl_ReducedHardware)
384     {
385         if (AcpiGbl_FADT.Facs)
386         {
387             AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.Facs,
388                 ACPI_SIG_FACS, &AcpiGbl_FacsIndex);
389         }
390         if (AcpiGbl_FADT.XFacs)
391         {
392             AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,
393                 ACPI_SIG_FACS, &AcpiGbl_XFacsIndex);
394         }
395     }
396 }
397 
398 
399 /*******************************************************************************
400  *
401  * FUNCTION:    AcpiTbCreateLocalFadt
402  *
403  * PARAMETERS:  Table               - Pointer to BIOS FADT
404  *              Length              - Length of the table
405  *
406  * RETURN:      None
407  *
408  * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
409  *              Performs validation on some important FADT fields.
410  *
411  * NOTE:        We create a local copy of the FADT regardless of the version.
412  *
413  ******************************************************************************/
414 
415 void
AcpiTbCreateLocalFadt(ACPI_TABLE_HEADER * Table,UINT32 Length)416 AcpiTbCreateLocalFadt (
417     ACPI_TABLE_HEADER       *Table,
418     UINT32                  Length)
419 {
420 
421     /*
422      * Check if the FADT is larger than the largest table that we expect
423      * (typically the current ACPI specification version). If so, truncate
424      * the table, and issue a warning.
425      */
426     if (Length > sizeof (ACPI_TABLE_FADT))
427     {
428         ACPI_BIOS_WARNING ((AE_INFO,
429             "FADT (revision %u) is longer than %s length, "
430             "truncating length %u to %u",
431             Table->Revision, ACPI_FADT_CONFORMANCE, Length,
432             (UINT32) sizeof (ACPI_TABLE_FADT)));
433     }
434 
435     /* Clear the entire local FADT */
436 
437     memset (&AcpiGbl_FADT, 0, sizeof (ACPI_TABLE_FADT));
438 
439     /* Copy the original FADT, up to sizeof (ACPI_TABLE_FADT) */
440 
441     memcpy (&AcpiGbl_FADT, Table,
442         ACPI_MIN (Length, sizeof (ACPI_TABLE_FADT)));
443 
444     /* Take a copy of the Hardware Reduced flag */
445 
446     AcpiGbl_ReducedHardware = FALSE;
447     if (AcpiGbl_FADT.Flags & ACPI_FADT_HW_REDUCED)
448     {
449         AcpiGbl_ReducedHardware = TRUE;
450     }
451 
452     /* Convert the local copy of the FADT to the common internal format */
453 
454     AcpiTbConvertFadt ();
455 
456     /* Initialize the global ACPI register structures */
457 
458     AcpiTbSetupFadtRegisters ();
459 }
460 
461 
462 /*******************************************************************************
463  *
464  * FUNCTION:    AcpiTbConvertFadt
465  *
466  * PARAMETERS:  None - AcpiGbl_FADT is used.
467  *
468  * RETURN:      None
469  *
470  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
471  *              Expand 32-bit addresses to 64-bit as necessary. Also validate
472  *              important fields within the FADT.
473  *
474  * NOTE:        AcpiGbl_FADT must be of size (ACPI_TABLE_FADT), and must
475  *              contain a copy of the actual BIOS-provided FADT.
476  *
477  * Notes on 64-bit register addresses:
478  *
479  * After this FADT conversion, later ACPICA code will only use the 64-bit "X"
480  * fields of the FADT for all ACPI register addresses.
481  *
482  * The 64-bit X fields are optional extensions to the original 32-bit FADT
483  * V1.0 fields. Even if they are present in the FADT, they are optional and
484  * are unused if the BIOS sets them to zero. Therefore, we must copy/expand
485  * 32-bit V1.0 fields to the 64-bit X fields if the the 64-bit X field is
486  * originally zero.
487  *
488  * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address
489  * fields are expanded to the corresponding 64-bit X fields in the internal
490  * common FADT.
491  *
492  * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded
493  * to the corresponding 64-bit X fields, if the 64-bit field is originally
494  * zero. Adhering to the ACPI specification, we completely ignore the 32-bit
495  * field if the 64-bit field is valid, regardless of whether the host OS is
496  * 32-bit or 64-bit.
497  *
498  * Possible additional checks:
499  *  (AcpiGbl_FADT.Pm1EventLength >= 4)
500  *  (AcpiGbl_FADT.Pm1ControlLength >= 2)
501  *  (AcpiGbl_FADT.PmTimerLength >= 4)
502  *  Gpe block lengths must be multiple of 2
503  *
504  ******************************************************************************/
505 
506 static void
AcpiTbConvertFadt(void)507 AcpiTbConvertFadt (
508     void)
509 {
510     const char              *Name;
511     ACPI_GENERIC_ADDRESS    *Address64;
512     UINT32                  Address32;
513     UINT8                   Length;
514     UINT8                   Flags;
515     UINT32                  i;
516 
517 
518     /*
519      * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
520      * should be zero are indeed zero. This will workaround BIOSs that
521      * inadvertently place values in these fields.
522      *
523      * The ACPI 1.0 reserved fields that will be zeroed are the bytes located
524      * at offset 45, 55, 95, and the word located at offset 109, 110.
525      *
526      * Note: The FADT revision value is unreliable. Only the length can be
527      * trusted.
528      */
529     if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
530     {
531         AcpiGbl_FADT.PreferredProfile = 0;
532         AcpiGbl_FADT.PstateControl = 0;
533         AcpiGbl_FADT.CstControl = 0;
534         AcpiGbl_FADT.BootFlags = 0;
535     }
536 
537     /*
538      * Now we can update the local FADT length to the length of the
539      * current FADT version as defined by the ACPI specification.
540      * Thus, we will have a common FADT internally.
541      */
542     AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT);
543 
544     /*
545      * Expand the 32-bit DSDT addresses to 64-bit as necessary.
546      * Later ACPICA code will always use the X 64-bit field.
547      */
548     AcpiGbl_FADT.XDsdt = AcpiTbSelectAddress ("DSDT",
549         AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
550 
551     /* If Hardware Reduced flag is set, we are all done */
552 
553     if (AcpiGbl_ReducedHardware)
554     {
555         return;
556     }
557 
558     /* Examine all of the 64-bit extended address fields (X fields) */
559 
560     for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
561     {
562         /*
563          * Get the 32-bit and 64-bit addresses, as well as the register
564          * length and register name.
565          */
566         Address32 = *ACPI_ADD_PTR (UINT32,
567             &AcpiGbl_FADT, FadtInfoTable[i].Address32);
568 
569         Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS,
570             &AcpiGbl_FADT, FadtInfoTable[i].Address64);
571 
572         Length = *ACPI_ADD_PTR (UINT8,
573             &AcpiGbl_FADT, FadtInfoTable[i].Length);
574 
575         Name = FadtInfoTable[i].Name;
576         Flags = FadtInfoTable[i].Flags;
577 
578         /*
579          * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
580          * generic address structures as necessary. Later code will always use
581          * the 64-bit address structures.
582          *
583          * November 2013:
584          * Now always use the 64-bit address if it is valid (non-zero), in
585          * accordance with the ACPI specification which states that a 64-bit
586          * address supersedes the 32-bit version. This behavior can be
587          * overridden by the AcpiGbl_Use32BitFadtAddresses flag.
588          *
589          * During 64-bit address construction and verification,
590          * these cases are handled:
591          *
592          * Address32 zero, Address64 [don't care]   - Use Address64
593          *
594          * Address32 non-zero, Address64 zero       - Copy/use Address32
595          * Address32 non-zero == Address64 non-zero - Use Address64
596          * Address32 non-zero != Address64 non-zero - Warning, use Address64
597          *
598          * Override: if AcpiGbl_Use32BitFadtAddresses is TRUE, and:
599          * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32
600          *
601          * Note: SpaceId is always I/O for 32-bit legacy address fields
602          */
603         if (Address32)
604         {
605             if (!Address64->Address)
606             {
607                 /* 64-bit address is zero, use 32-bit address */
608 
609                 AcpiTbInitGenericAddress (Address64,
610                     ACPI_ADR_SPACE_SYSTEM_IO,
611                     *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
612                         FadtInfoTable[i].Length),
613                     (UINT64) Address32, Name, Flags);
614             }
615             else if (Address64->Address != (UINT64) Address32)
616             {
617                 /* Address mismatch */
618 
619                 ACPI_BIOS_WARNING ((AE_INFO,
620                     "32/64X address mismatch in FADT/%s: "
621                     "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
622                     Name, Address32,
623                     ACPI_FORMAT_UINT64 (Address64->Address),
624                     AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
625 
626                 if (AcpiGbl_Use32BitFadtAddresses)
627                 {
628                     /* 32-bit address override */
629 
630                     AcpiTbInitGenericAddress (Address64,
631                         ACPI_ADR_SPACE_SYSTEM_IO,
632                         *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
633                             FadtInfoTable[i].Length),
634                         (UINT64) Address32, Name, Flags);
635                 }
636             }
637         }
638 
639         /*
640          * For each extended field, check for length mismatch between the
641          * legacy length field and the corresponding 64-bit X length field.
642          * Note: If the legacy length field is > 0xFF bits, ignore this
643          * check. (GPE registers can be larger than the 64-bit GAS structure
644          * can accomodate, 0xFF bits).
645          */
646         if (Address64->Address &&
647            (ACPI_MUL_8 (Length) <= ACPI_UINT8_MAX) &&
648            (Address64->BitWidth != ACPI_MUL_8 (Length)))
649         {
650             ACPI_BIOS_WARNING ((AE_INFO,
651                 "32/64X length mismatch in FADT/%s: %u/%u",
652                 Name, ACPI_MUL_8 (Length), Address64->BitWidth));
653         }
654 
655         if (FadtInfoTable[i].Flags & ACPI_FADT_REQUIRED)
656         {
657             /*
658              * Field is required (PM1aEvent, PM1aControl).
659              * Both the address and length must be non-zero.
660              */
661             if (!Address64->Address || !Length)
662             {
663                 ACPI_BIOS_ERROR ((AE_INFO,
664                     "Required FADT field %s has zero address and/or length: "
665                     "0x%8.8X%8.8X/0x%X",
666                     Name, ACPI_FORMAT_UINT64 (Address64->Address), Length));
667             }
668         }
669         else if (FadtInfoTable[i].Flags & ACPI_FADT_SEPARATE_LENGTH)
670         {
671             /*
672              * Field is optional (PM2Control, GPE0, GPE1) AND has its own
673              * length field. If present, both the address and length must
674              * be valid.
675              */
676             if ((Address64->Address && !Length) ||
677                 (!Address64->Address && Length))
678             {
679                 ACPI_BIOS_WARNING ((AE_INFO,
680                     "Optional FADT field %s has valid %s but zero %s: "
681                     "0x%8.8X%8.8X/0x%X", Name,
682                     (Length ? "Length" : "Address"),
683                     (Length ? "Address": "Length"),
684                     ACPI_FORMAT_UINT64 (Address64->Address), Length));
685             }
686         }
687     }
688 }
689 
690 
691 /*******************************************************************************
692  *
693  * FUNCTION:    AcpiTbSetupFadtRegisters
694  *
695  * PARAMETERS:  None, uses AcpiGbl_FADT.
696  *
697  * RETURN:      None
698  *
699  * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally,
700  *              force FADT register definitions to their default lengths.
701  *
702  ******************************************************************************/
703 
704 static void
AcpiTbSetupFadtRegisters(void)705 AcpiTbSetupFadtRegisters (
706     void)
707 {
708     ACPI_GENERIC_ADDRESS    *Target64;
709     ACPI_GENERIC_ADDRESS    *Source64;
710     UINT8                   Pm1RegisterByteWidth;
711     UINT32                  i;
712 
713 
714     /*
715      * Optionally check all register lengths against the default values and
716      * update them if they are incorrect.
717      */
718     if (AcpiGbl_UseDefaultRegisterWidths)
719     {
720         for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
721         {
722             Target64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT,
723                 FadtInfoTable[i].Address64);
724 
725             /*
726              * If a valid register (Address != 0) and the (DefaultLength > 0)
727              * (Not a GPE register), then check the width against the default.
728              */
729             if ((Target64->Address) &&
730                 (FadtInfoTable[i].DefaultLength > 0) &&
731                 (FadtInfoTable[i].DefaultLength != Target64->BitWidth))
732             {
733                 ACPI_BIOS_WARNING ((AE_INFO,
734                     "Invalid length for FADT/%s: %u, using default %u",
735                     FadtInfoTable[i].Name, Target64->BitWidth,
736                     FadtInfoTable[i].DefaultLength));
737 
738                 /* Incorrect size, set width to the default */
739 
740                 Target64->BitWidth = FadtInfoTable[i].DefaultLength;
741             }
742         }
743     }
744 
745     /*
746      * Get the length of the individual PM1 registers (enable and status).
747      * Each register is defined to be (event block length / 2). Extra divide
748      * by 8 converts bits to bytes.
749      */
750     Pm1RegisterByteWidth = (UINT8)
751         ACPI_DIV_16 (AcpiGbl_FADT.XPm1aEventBlock.BitWidth);
752 
753     /*
754      * Calculate separate GAS structs for the PM1x (A/B) Status and Enable
755      * registers. These addresses do not appear (directly) in the FADT, so it
756      * is useful to pre-calculate them from the PM1 Event Block definitions.
757      *
758      * The PM event blocks are split into two register blocks, first is the
759      * PM Status Register block, followed immediately by the PM Enable
760      * Register block. Each is of length (Pm1EventLength/2)
761      *
762      * Note: The PM1A event block is required by the ACPI specification.
763      * However, the PM1B event block is optional and is rarely, if ever,
764      * used.
765      */
766 
767     for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++)
768     {
769         Source64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT,
770             FadtPmInfoTable[i].Source);
771 
772         if (Source64->Address)
773         {
774             AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target,
775                 Source64->SpaceId, Pm1RegisterByteWidth,
776                 Source64->Address +
777                     (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth),
778                 "PmRegisters", 0);
779         }
780     }
781 }
782