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