* a warning.
         */
        if (length > sizeof(struct acpi_table_fadt)) {
-               ACPI_WARNING((AE_INFO,
-                             "FADT (revision %u) is longer than ACPI 5.0 version, "
-                             "truncating length %u to %u",
-                             table->revision, length,
-                             (u32)sizeof(struct acpi_table_fadt)));
+               ACPI_BIOS_WARNING((AE_INFO,
+                                  "FADT (revision %u) is longer than ACPI 5.0 version, "
+                                  "truncating length %u to %u",
+                                  table->revision, length,
+                                  (u32)sizeof(struct acpi_table_fadt)));
        }
 
        /* Clear the entire local FADT */
                 * they must match.
                 */
                if (address64->address && address32 &&
-                   (address64->address != (u64) address32)) {
-                       ACPI_ERROR((AE_INFO,
-                                   "32/64X address mismatch in %s: 0x%8.8X/0x%8.8X%8.8X, using 32",
-                                   fadt_info_table[i].name, address32,
-                                   ACPI_FORMAT_UINT64(address64->address)));
+                   (address64->address != (u64)address32)) {
+                       ACPI_BIOS_ERROR((AE_INFO,
+                                        "32/64X address mismatch in FADT/%s: "
+                                        "0x%8.8X/0x%8.8X%8.8X, using 32",
+                                        fadt_info_table[i].name, address32,
+                                        ACPI_FORMAT_UINT64(address64->
+                                                           address)));
                }
 
                /* Always use 32-bit address if it is valid (non-null) */
         * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables.
         */
        if (acpi_gbl_FADT.facs &&
-           (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) {
-               ACPI_WARNING((AE_INFO,
-                             "32/64X FACS address mismatch in FADT - "
-                             "0x%8.8X/0x%8.8X%8.8X, using 32",
-                             acpi_gbl_FADT.facs,
-                             ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs)));
-
-               acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
+           (acpi_gbl_FADT.Xfacs != (u64)acpi_gbl_FADT.facs)) {
+               ACPI_BIOS_WARNING((AE_INFO,
+                                  "32/64X FACS address mismatch in FADT - "
+                                  "0x%8.8X/0x%8.8X%8.8X, using 32",
+                                  acpi_gbl_FADT.facs,
+                                  ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs)));
+
+               acpi_gbl_FADT.Xfacs = (u64)acpi_gbl_FADT.facs;
        }
 
        if (acpi_gbl_FADT.dsdt &&
-           (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) {
-               ACPI_WARNING((AE_INFO,
-                             "32/64X DSDT address mismatch in FADT - "
-                             "0x%8.8X/0x%8.8X%8.8X, using 32",
-                             acpi_gbl_FADT.dsdt,
-                             ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt)));
-
-               acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
+           (acpi_gbl_FADT.Xdsdt != (u64)acpi_gbl_FADT.dsdt)) {
+               ACPI_BIOS_WARNING((AE_INFO,
+                                  "32/64X DSDT address mismatch in FADT - "
+                                  "0x%8.8X/0x%8.8X%8.8X, using 32",
+                                  acpi_gbl_FADT.dsdt,
+                                  ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt)));
+
+               acpi_gbl_FADT.Xdsdt = (u64)acpi_gbl_FADT.dsdt;
        }
 
        /* If Hardware Reduced flag is set, we are all done */
                 */
                if (address64->address &&
                    (address64->bit_width != ACPI_MUL_8(length))) {
-                       ACPI_WARNING((AE_INFO,
-                                     "32/64X length mismatch in %s: %u/%u",
-                                     name, ACPI_MUL_8(length),
-                                     address64->bit_width));
+                       ACPI_BIOS_WARNING((AE_INFO,
+                                          "32/64X length mismatch in FADT/%s: %u/%u",
+                                          name, ACPI_MUL_8(length),
+                                          address64->bit_width));
                }
 
                if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
                         * Both the address and length must be non-zero.
                         */
                        if (!address64->address || !length) {
-                               ACPI_ERROR((AE_INFO,
-                                           "Required field %s has zero address and/or length:"
-                                           " 0x%8.8X%8.8X/0x%X",
-                                           name,
-                                           ACPI_FORMAT_UINT64(address64->
-                                                              address),
-                                           length));
+                               ACPI_BIOS_ERROR((AE_INFO,
+                                                "Required FADT field %s has zero address and/or length: "
+                                                "0x%8.8X%8.8X/0x%X",
+                                                name,
+                                                ACPI_FORMAT_UINT64(address64->
+                                                                   address),
+                                                length));
                        }
                } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) {
                        /*
                         */
                        if ((address64->address && !length) ||
                            (!address64->address && length)) {
-                               ACPI_WARNING((AE_INFO,
-                                             "Optional field %s has zero address or length: "
-                                             "0x%8.8X%8.8X/0x%X",
-                                             name,
-                                             ACPI_FORMAT_UINT64(address64->
-                                                                address),
-                                             length));
+                               ACPI_BIOS_WARNING((AE_INFO,
+                                                  "Optional FADT field %s has zero address or length: "
+                                                  "0x%8.8X%8.8X/0x%X",
+                                                  name,
+                                                  ACPI_FORMAT_UINT64
+                                                  (address64->address),
+                                                  length));
                        }
                }
        }
                            (fadt_info_table[i].default_length > 0) &&
                            (fadt_info_table[i].default_length !=
                             target64->bit_width)) {
-                               ACPI_WARNING((AE_INFO,
-                                             "Invalid length for %s: %u, using default %u",
-                                             fadt_info_table[i].name,
-                                             target64->bit_width,
-                                             fadt_info_table[i].
-                                             default_length));
+                               ACPI_BIOS_WARNING((AE_INFO,
+                                                  "Invalid length for FADT/%s: %u, using default %u",
+                                                  fadt_info_table[i].name,
+                                                  target64->bit_width,
+                                                  fadt_info_table[i].
+                                                  default_length));
 
                                /* Incorrect size, set width to the default */
 
 
        /* Checksum ok? (should be zero) */
 
        if (checksum) {
-               ACPI_WARNING((AE_INFO,
-                             "Incorrect checksum in table [%4.4s] - 0x%2.2X, should be 0x%2.2X",
-                             table->signature, table->checksum,
-                             (u8) (table->checksum - checksum)));
+               ACPI_BIOS_WARNING((AE_INFO,
+                                  "Incorrect checksum in table [%4.4s] - 0x%2.2X, "
+                                  "should be 0x%2.2X",
+                                  table->signature, table->checksum,
+                                  (u8)(table->checksum - checksum)));
 
 #if (ACPI_CHECKSUM_ABORT)
 
 
        if (acpi_gbl_original_dsdt_header.length != acpi_gbl_DSDT->length ||
            acpi_gbl_original_dsdt_header.checksum != acpi_gbl_DSDT->checksum) {
-               ACPI_ERROR((AE_INFO,
-                           "The DSDT has been corrupted or replaced - old, new headers below"));
+               ACPI_BIOS_ERROR((AE_INFO,
+                                "The DSDT has been corrupted or replaced - "
+                                "old, new headers below"));
                acpi_tb_print_table_header(0, &acpi_gbl_original_dsdt_header);
                acpi_tb_print_table_header(0, acpi_gbl_DSDT);
 
        /* If a particular signature is expected (DSDT/FACS), it must match */
 
        if (signature && !ACPI_COMPARE_NAME(table->signature, signature)) {
-               ACPI_ERROR((AE_INFO,
-                           "Invalid signature 0x%X for ACPI table, expected [%s]",
-                           *ACPI_CAST_PTR(u32, table->signature), signature));
+               ACPI_BIOS_ERROR((AE_INFO,
+                                "Invalid signature 0x%X for ACPI table, expected [%s]",
+                                *ACPI_CAST_PTR(u32, table->signature),
+                                signature));
                goto unmap_and_exit;
        }
 
 
                        /* Will truncate 64-bit address to 32 bits, issue warning */
 
-                       ACPI_WARNING((AE_INFO,
-                                     "64-bit Physical Address in XSDT is too large (0x%8.8X%8.8X),"
-                                     " truncating",
-                                     ACPI_FORMAT_UINT64(address64)));
+                       ACPI_BIOS_WARNING((AE_INFO,
+                                          "64-bit Physical Address in XSDT is too large (0x%8.8X%8.8X),"
+                                          " truncating",
+                                          ACPI_FORMAT_UINT64(address64)));
                }
 #endif
                return ((acpi_physical_address) (address64));
        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
 
        if (length < sizeof(struct acpi_table_header)) {
-               ACPI_ERROR((AE_INFO, "Invalid length 0x%X in RSDT/XSDT",
-                           length));
+               ACPI_BIOS_ERROR((AE_INFO,
+                                "Invalid table length 0x%X in RSDT/XSDT",
+                                length));
                return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
        }