1 /******************************************************************************
3 * Module Name: tbfadt - FADT table utilities
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2014, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
46 #include <contrib/dev/acpica/include/acpi.h>
47 #include <contrib/dev/acpica/include/accommon.h>
48 #include <contrib/dev/acpica/include/actables.h>
50 #define _COMPONENT ACPI_TABLES
51 ACPI_MODULE_NAME ("tbfadt")
53 /* Local prototypes */
56 AcpiTbInitGenericAddress (
57 ACPI_GENERIC_ADDRESS *GenericAddress,
69 AcpiTbSetupFadtRegisters (
79 /* Table for conversion of FADT to common internal format and FADT validation */
81 typedef struct acpi_fadt_info
92 #define ACPI_FADT_OPTIONAL 0
93 #define ACPI_FADT_REQUIRED 1
94 #define ACPI_FADT_SEPARATE_LENGTH 2
95 #define ACPI_FADT_GPE_REGISTER 4
97 static ACPI_FADT_INFO FadtInfoTable[] =
100 ACPI_FADT_OFFSET (XPm1aEventBlock),
101 ACPI_FADT_OFFSET (Pm1aEventBlock),
102 ACPI_FADT_OFFSET (Pm1EventLength),
103 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */
107 ACPI_FADT_OFFSET (XPm1bEventBlock),
108 ACPI_FADT_OFFSET (Pm1bEventBlock),
109 ACPI_FADT_OFFSET (Pm1EventLength),
110 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */
114 ACPI_FADT_OFFSET (XPm1aControlBlock),
115 ACPI_FADT_OFFSET (Pm1aControlBlock),
116 ACPI_FADT_OFFSET (Pm1ControlLength),
117 ACPI_PM1_REGISTER_WIDTH,
121 ACPI_FADT_OFFSET (XPm1bControlBlock),
122 ACPI_FADT_OFFSET (Pm1bControlBlock),
123 ACPI_FADT_OFFSET (Pm1ControlLength),
124 ACPI_PM1_REGISTER_WIDTH,
128 ACPI_FADT_OFFSET (XPm2ControlBlock),
129 ACPI_FADT_OFFSET (Pm2ControlBlock),
130 ACPI_FADT_OFFSET (Pm2ControlLength),
131 ACPI_PM2_REGISTER_WIDTH,
132 ACPI_FADT_SEPARATE_LENGTH},
135 ACPI_FADT_OFFSET (XPmTimerBlock),
136 ACPI_FADT_OFFSET (PmTimerBlock),
137 ACPI_FADT_OFFSET (PmTimerLength),
139 ACPI_FADT_SEPARATE_LENGTH}, /* ACPI 5.0A: Timer is optional */
142 ACPI_FADT_OFFSET (XGpe0Block),
143 ACPI_FADT_OFFSET (Gpe0Block),
144 ACPI_FADT_OFFSET (Gpe0BlockLength),
146 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER},
149 ACPI_FADT_OFFSET (XGpe1Block),
150 ACPI_FADT_OFFSET (Gpe1Block),
151 ACPI_FADT_OFFSET (Gpe1BlockLength),
153 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER}
156 #define ACPI_FADT_INFO_ENTRIES \
157 (sizeof (FadtInfoTable) / sizeof (ACPI_FADT_INFO))
160 /* Table used to split Event Blocks into separate status/enable registers */
162 typedef struct acpi_fadt_pm_info
164 ACPI_GENERIC_ADDRESS *Target;
170 static ACPI_FADT_PM_INFO FadtPmInfoTable[] =
172 {&AcpiGbl_XPm1aStatus,
173 ACPI_FADT_OFFSET (XPm1aEventBlock),
176 {&AcpiGbl_XPm1aEnable,
177 ACPI_FADT_OFFSET (XPm1aEventBlock),
180 {&AcpiGbl_XPm1bStatus,
181 ACPI_FADT_OFFSET (XPm1bEventBlock),
184 {&AcpiGbl_XPm1bEnable,
185 ACPI_FADT_OFFSET (XPm1bEventBlock),
189 #define ACPI_FADT_PM_INFO_ENTRIES \
190 (sizeof (FadtPmInfoTable) / sizeof (ACPI_FADT_PM_INFO))
193 /*******************************************************************************
195 * FUNCTION: AcpiTbInitGenericAddress
197 * PARAMETERS: GenericAddress - GAS struct to be initialized
198 * SpaceId - ACPI Space ID for this register
199 * ByteWidth - Width of this register
200 * Address - Address of the register
201 * RegisterName - ASCII name of the ACPI register
205 * DESCRIPTION: Initialize a Generic Address Structure (GAS)
206 * See the ACPI specification for a full description and
207 * definition of this structure.
209 ******************************************************************************/
212 AcpiTbInitGenericAddress (
213 ACPI_GENERIC_ADDRESS *GenericAddress,
224 * Bit width field in the GAS is only one byte long, 255 max.
225 * Check for BitWidth overflow in GAS.
227 BitWidth = (UINT8) (ByteWidth * 8);
228 if (ByteWidth > 31) /* (31*8)=248, (32*8)=256 */
231 * No error for GPE blocks, because we do not use the BitWidth
232 * for GPEs, the legacy length (ByteWidth) is used instead to
233 * allow for a large number of GPEs.
235 if (!(Flags & ACPI_FADT_GPE_REGISTER))
237 ACPI_ERROR ((AE_INFO,
238 "%s - 32-bit FADT register is too long (%u bytes, %u bits) "
239 "to convert to GAS struct - 255 bits max, truncating",
240 RegisterName, ByteWidth, (ByteWidth * 8)));
247 * The 64-bit Address field is non-aligned in the byte packed
250 ACPI_MOVE_64_TO_64 (&GenericAddress->Address, &Address);
252 /* All other fields are byte-wide */
254 GenericAddress->SpaceId = SpaceId;
255 GenericAddress->BitWidth = BitWidth;
256 GenericAddress->BitOffset = 0;
257 GenericAddress->AccessWidth = 0; /* Access width ANY */
261 /*******************************************************************************
263 * FUNCTION: AcpiTbSelectAddress
265 * PARAMETERS: RegisterName - ASCII name of the ACPI register
266 * Address32 - 32-bit address of the register
267 * Address64 - 64-bit address of the register
269 * RETURN: The resolved 64-bit address
271 * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within
272 * the FADT. Used for the FACS and DSDT addresses.
276 * Check for FACS and DSDT address mismatches. An address mismatch between
277 * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
278 * DSDT/X_DSDT) could be a corrupted address field or it might indicate
279 * the presence of two FACS or two DSDT tables.
282 * By default, as per the ACPICA specification, a valid 64-bit address is
283 * used regardless of the value of the 32-bit address. However, this
284 * behavior can be overridden via the AcpiGbl_Use32BitFadtAddresses flag.
286 ******************************************************************************/
289 AcpiTbSelectAddress (
297 /* 64-bit address is zero, use 32-bit address */
299 return ((UINT64) Address32);
303 (Address64 != (UINT64) Address32))
305 /* Address mismatch between 32-bit and 64-bit versions */
307 ACPI_BIOS_WARNING ((AE_INFO,
308 "32/64X %s address mismatch in FADT: "
309 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
310 RegisterName, Address32, ACPI_FORMAT_UINT64 (Address64),
311 AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
313 /* 32-bit address override */
315 if (AcpiGbl_Use32BitFadtAddresses)
317 return ((UINT64) Address32);
321 /* Default is to use the 64-bit address */
327 /*******************************************************************************
329 * FUNCTION: AcpiTbParseFadt
331 * PARAMETERS: TableIndex - Index for the FADT
335 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
336 * (FADT contains the addresses of the DSDT and FACS)
338 ******************************************************************************/
345 ACPI_TABLE_HEADER *Table;
349 * The FADT has multiple versions with different lengths,
350 * and it contains pointers to both the DSDT and FACS tables.
352 * Get a local copy of the FADT and convert it to a common format
353 * Map entire FADT, assumed to be smaller than one page.
355 Length = AcpiGbl_RootTableList.Tables[TableIndex].Length;
357 Table = AcpiOsMapMemory (
358 AcpiGbl_RootTableList.Tables[TableIndex].Address, Length);
365 * Validate the FADT checksum before we copy the table. Ignore
366 * checksum error as we want to try to get the DSDT and FACS.
368 (void) AcpiTbVerifyChecksum (Table, Length);
370 /* Create a local copy of the FADT in common ACPI 2.0+ format */
372 AcpiTbCreateLocalFadt (Table, Length);
374 /* All done with the real FADT, unmap it */
376 AcpiOsUnmapMemory (Table, Length);
378 /* Obtain the DSDT and FACS tables via their addresses within the FADT */
380 AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,
381 ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
383 /* If Hardware Reduced flag is set, there is no FACS */
385 if (!AcpiGbl_ReducedHardware)
387 AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,
388 ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS);
393 /*******************************************************************************
395 * FUNCTION: AcpiTbCreateLocalFadt
397 * PARAMETERS: Table - Pointer to BIOS FADT
398 * Length - Length of the table
402 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
403 * Performs validation on some important FADT fields.
405 * NOTE: We create a local copy of the FADT regardless of the version.
407 ******************************************************************************/
410 AcpiTbCreateLocalFadt (
411 ACPI_TABLE_HEADER *Table,
416 * Check if the FADT is larger than the largest table that we expect
417 * (the ACPI 5.0 version). If so, truncate the table, and issue
420 if (Length > sizeof (ACPI_TABLE_FADT))
422 ACPI_BIOS_WARNING ((AE_INFO,
423 "FADT (revision %u) is longer than ACPI 5.0 version, "
424 "truncating length %u to %u",
425 Table->Revision, Length, (UINT32) sizeof (ACPI_TABLE_FADT)));
428 /* Clear the entire local FADT */
430 ACPI_MEMSET (&AcpiGbl_FADT, 0, sizeof (ACPI_TABLE_FADT));
432 /* Copy the original FADT, up to sizeof (ACPI_TABLE_FADT) */
434 ACPI_MEMCPY (&AcpiGbl_FADT, Table,
435 ACPI_MIN (Length, sizeof (ACPI_TABLE_FADT)));
437 /* Take a copy of the Hardware Reduced flag */
439 AcpiGbl_ReducedHardware = FALSE;
440 if (AcpiGbl_FADT.Flags & ACPI_FADT_HW_REDUCED)
442 AcpiGbl_ReducedHardware = TRUE;
445 /* Convert the local copy of the FADT to the common internal format */
447 AcpiTbConvertFadt ();
449 /* Initialize the global ACPI register structures */
451 AcpiTbSetupFadtRegisters ();
455 /*******************************************************************************
457 * FUNCTION: AcpiTbConvertFadt
459 * PARAMETERS: None - AcpiGbl_FADT is used.
463 * DESCRIPTION: Converts all versions of the FADT to a common internal format.
464 * Expand 32-bit addresses to 64-bit as necessary. Also validate
465 * important fields within the FADT.
467 * NOTE: AcpiGbl_FADT must be of size (ACPI_TABLE_FADT), and must
468 * contain a copy of the actual BIOS-provided FADT.
470 * Notes on 64-bit register addresses:
472 * After this FADT conversion, later ACPICA code will only use the 64-bit "X"
473 * fields of the FADT for all ACPI register addresses.
475 * The 64-bit X fields are optional extensions to the original 32-bit FADT
476 * V1.0 fields. Even if they are present in the FADT, they are optional and
477 * are unused if the BIOS sets them to zero. Therefore, we must copy/expand
478 * 32-bit V1.0 fields to the 64-bit X fields if the the 64-bit X field is
481 * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address
482 * fields are expanded to the corresponding 64-bit X fields in the internal
485 * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded
486 * to the corresponding 64-bit X fields, if the 64-bit field is originally
487 * zero. Adhering to the ACPI specification, we completely ignore the 32-bit
488 * field if the 64-bit field is valid, regardless of whether the host OS is
491 * Possible additional checks:
492 * (AcpiGbl_FADT.Pm1EventLength >= 4)
493 * (AcpiGbl_FADT.Pm1ControlLength >= 2)
494 * (AcpiGbl_FADT.PmTimerLength >= 4)
495 * Gpe block lengths must be multiple of 2
497 ******************************************************************************/
504 ACPI_GENERIC_ADDRESS *Address64;
512 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
513 * should be zero are indeed zero. This will workaround BIOSs that
514 * inadvertently place values in these fields.
516 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located
517 * at offset 45, 55, 95, and the word located at offset 109, 110.
519 * Note: The FADT revision value is unreliable. Only the length can be
522 if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
524 AcpiGbl_FADT.PreferredProfile = 0;
525 AcpiGbl_FADT.PstateControl = 0;
526 AcpiGbl_FADT.CstControl = 0;
527 AcpiGbl_FADT.BootFlags = 0;
531 * Now we can update the local FADT length to the length of the
532 * current FADT version as defined by the ACPI specification.
533 * Thus, we will have a common FADT internally.
535 AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT);
538 * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary.
539 * Later ACPICA code will always use the X 64-bit field.
541 AcpiGbl_FADT.XFacs = AcpiTbSelectAddress ("FACS",
542 AcpiGbl_FADT.Facs, AcpiGbl_FADT.XFacs);
544 AcpiGbl_FADT.XDsdt = AcpiTbSelectAddress ("DSDT",
545 AcpiGbl_FADT.Dsdt, AcpiGbl_FADT.XDsdt);
547 /* If Hardware Reduced flag is set, we are all done */
549 if (AcpiGbl_ReducedHardware)
554 /* Examine all of the 64-bit extended address fields (X fields) */
556 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
559 * Get the 32-bit and 64-bit addresses, as well as the register
560 * length and register name.
562 Address32 = *ACPI_ADD_PTR (UINT32,
563 &AcpiGbl_FADT, FadtInfoTable[i].Address32);
565 Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS,
566 &AcpiGbl_FADT, FadtInfoTable[i].Address64);
568 Length = *ACPI_ADD_PTR (UINT8,
569 &AcpiGbl_FADT, FadtInfoTable[i].Length);
571 Name = FadtInfoTable[i].Name;
572 Flags = FadtInfoTable[i].Flags;
575 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
576 * generic address structures as necessary. Later code will always use
577 * the 64-bit address structures.
580 * Now always use the 64-bit address if it is valid (non-zero), in
581 * accordance with the ACPI specification which states that a 64-bit
582 * address supersedes the 32-bit version. This behavior can be
583 * overridden by the AcpiGbl_Use32BitFadtAddresses flag.
585 * During 64-bit address construction and verification,
586 * these cases are handled:
588 * Address32 zero, Address64 [don't care] - Use Address64
590 * Address32 non-zero, Address64 zero - Copy/use Address32
591 * Address32 non-zero == Address64 non-zero - Use Address64
592 * Address32 non-zero != Address64 non-zero - Warning, use Address64
594 * Override: if AcpiGbl_Use32BitFadtAddresses is TRUE, and:
595 * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32
597 * Note: SpaceId is always I/O for 32-bit legacy address fields
601 if (!Address64->Address)
603 /* 64-bit address is zero, use 32-bit address */
605 AcpiTbInitGenericAddress (Address64,
606 ACPI_ADR_SPACE_SYSTEM_IO,
607 *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
608 FadtInfoTable[i].Length),
609 (UINT64) Address32, Name, Flags);
611 else if (Address64->Address != (UINT64) Address32)
613 /* Address mismatch */
615 ACPI_BIOS_WARNING ((AE_INFO,
616 "32/64X address mismatch in FADT/%s: "
617 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
619 ACPI_FORMAT_UINT64 (Address64->Address),
620 AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
622 if (AcpiGbl_Use32BitFadtAddresses)
624 /* 32-bit address override */
626 AcpiTbInitGenericAddress (Address64,
627 ACPI_ADR_SPACE_SYSTEM_IO,
628 *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
629 FadtInfoTable[i].Length),
630 (UINT64) Address32, Name, Flags);
636 * For each extended field, check for length mismatch between the
637 * legacy length field and the corresponding 64-bit X length field.
638 * Note: If the legacy length field is > 0xFF bits, ignore this
639 * check. (GPE registers can be larger than the 64-bit GAS structure
640 * can accomodate, 0xFF bits).
642 if (Address64->Address &&
643 (ACPI_MUL_8 (Length) <= ACPI_UINT8_MAX) &&
644 (Address64->BitWidth != ACPI_MUL_8 (Length)))
646 ACPI_BIOS_WARNING ((AE_INFO,
647 "32/64X length mismatch in FADT/%s: %u/%u",
648 Name, ACPI_MUL_8 (Length), Address64->BitWidth));
651 if (FadtInfoTable[i].Flags & ACPI_FADT_REQUIRED)
654 * Field is required (PM1aEvent, PM1aControl).
655 * Both the address and length must be non-zero.
657 if (!Address64->Address || !Length)
659 ACPI_BIOS_ERROR ((AE_INFO,
660 "Required FADT field %s has zero address and/or length: "
662 Name, ACPI_FORMAT_UINT64 (Address64->Address), Length));
665 else if (FadtInfoTable[i].Flags & ACPI_FADT_SEPARATE_LENGTH)
668 * Field is optional (PM2Control, GPE0, GPE1) AND has its own
669 * length field. If present, both the address and length must
672 if ((Address64->Address && !Length) ||
673 (!Address64->Address && Length))
675 ACPI_BIOS_WARNING ((AE_INFO,
676 "Optional FADT field %s has zero address or length: "
678 Name, ACPI_FORMAT_UINT64 (Address64->Address), Length));
685 /*******************************************************************************
687 * FUNCTION: AcpiTbSetupFadtRegisters
689 * PARAMETERS: None, uses AcpiGbl_FADT.
693 * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally,
694 * force FADT register definitions to their default lengths.
696 ******************************************************************************/
699 AcpiTbSetupFadtRegisters (
702 ACPI_GENERIC_ADDRESS *Target64;
703 ACPI_GENERIC_ADDRESS *Source64;
704 UINT8 Pm1RegisterByteWidth;
709 * Optionally check all register lengths against the default values and
710 * update them if they are incorrect.
712 if (AcpiGbl_UseDefaultRegisterWidths)
714 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
716 Target64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT,
717 FadtInfoTable[i].Address64);
720 * If a valid register (Address != 0) and the (DefaultLength > 0)
721 * (Not a GPE register), then check the width against the default.
723 if ((Target64->Address) &&
724 (FadtInfoTable[i].DefaultLength > 0) &&
725 (FadtInfoTable[i].DefaultLength != Target64->BitWidth))
727 ACPI_BIOS_WARNING ((AE_INFO,
728 "Invalid length for FADT/%s: %u, using default %u",
729 FadtInfoTable[i].Name, Target64->BitWidth,
730 FadtInfoTable[i].DefaultLength));
732 /* Incorrect size, set width to the default */
734 Target64->BitWidth = FadtInfoTable[i].DefaultLength;
740 * Get the length of the individual PM1 registers (enable and status).
741 * Each register is defined to be (event block length / 2). Extra divide
742 * by 8 converts bits to bytes.
744 Pm1RegisterByteWidth = (UINT8)
745 ACPI_DIV_16 (AcpiGbl_FADT.XPm1aEventBlock.BitWidth);
748 * Calculate separate GAS structs for the PM1x (A/B) Status and Enable
749 * registers. These addresses do not appear (directly) in the FADT, so it
750 * is useful to pre-calculate them from the PM1 Event Block definitions.
752 * The PM event blocks are split into two register blocks, first is the
753 * PM Status Register block, followed immediately by the PM Enable
754 * Register block. Each is of length (Pm1EventLength/2)
756 * Note: The PM1A event block is required by the ACPI specification.
757 * However, the PM1B event block is optional and is rarely, if ever,
761 for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++)
763 Source64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT,
764 FadtPmInfoTable[i].Source);
766 if (Source64->Address)
768 AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target,
769 Source64->SpaceId, Pm1RegisterByteWidth,
771 (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth),