int     (*probe)(void);
        int     (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
        int     (*apic_id_valid)(u32 apicid);
-       int     (*apic_id_registered)(void);
+       bool    (*apic_id_registered)(void);
 
        bool    (*check_apicid_used)(physid_mask_t *map, int apicid);
        void    (*init_apic_ldr)(void);
 
                apic_write(APIC_ESR, 0);
        }
 #endif
-       /*
-        * Double-check whether this APIC is really registered.
-        * This is meaningless in clustered apic mode, so we skip it.
-        */
-       BUG_ON(!apic->apic_id_registered());
+       /* Validate that the APIC is registered if required */
+       BUG_ON(apic->apic_id_registered && !apic->apic_id_registered());
 
        /*
         * Intel recommends to set DFR, LDR and TPR before enabling
 
        return (apicid < 255);
 }
 
+bool default_apic_id_registered(void)
+{
+       return physid_isset(read_apic_id(), phys_cpu_present_map);
+}
+
 /*
  * Set up the logical destination ID when the APIC operates in logical
  * destination mode.
 
        return (id & 0xFF) << 24;
 }
 
-static unsigned int read_xapic_id(void)
-{
-       return flat_get_apic_id(apic_read(APIC_ID));
-}
-
-static int flat_apic_id_registered(void)
-{
-       return physid_isset(read_xapic_id(), phys_cpu_present_map);
-}
-
 static int flat_phys_pkg_id(int initial_apic_id, int index_msb)
 {
        return initial_apic_id >> index_msb;
        .probe                          = flat_probe,
        .acpi_madt_oem_check            = flat_acpi_madt_oem_check,
        .apic_id_valid                  = default_apic_id_valid,
-       .apic_id_registered             = flat_apic_id_registered,
+       .apic_id_registered             = default_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = true,
        .probe                          = physflat_probe,
        .acpi_madt_oem_check            = physflat_acpi_madt_oem_check,
        .apic_id_valid                  = default_apic_id_valid,
-       .apic_id_registered             = flat_apic_id_registered,
+       .apic_id_registered             = default_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
 
        return 0;
 }
 
-static int noop_apic_id_registered(void)
-{
-       /*
-        * if we would be really "pedantic"
-        * we should pass read_apic_id() here
-        * but since NOOP suppose APIC ID = 0
-        * lets save a few cycles
-        */
-       return physid_isset(0, phys_cpu_present_map);
-}
-
 static u32 noop_apic_read(u32 reg)
 {
        WARN_ON_ONCE(boot_cpu_has(X86_FEATURE_APIC) && !apic_is_disabled);
        .acpi_madt_oem_check            = NULL,
 
        .apic_id_valid                  = default_apic_id_valid,
-       .apic_id_registered             = noop_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = true,
 
        return 1;
 }
 
-static int numachip_apic_id_registered(void)
-{
-       return 1;
-}
-
 static int numachip_phys_pkg_id(int initial_apic_id, int index_msb)
 {
        return initial_apic_id >> index_msb;
        .probe                          = numachip1_probe,
        .acpi_madt_oem_check            = numachip1_acpi_madt_oem_check,
        .apic_id_valid                  = numachip_apic_id_valid,
-       .apic_id_registered             = numachip_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
        .probe                          = numachip2_probe,
        .acpi_madt_oem_check            = numachip2_acpi_madt_oem_check,
        .apic_id_valid                  = numachip_apic_id_valid,
-       .apic_id_registered             = numachip_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
 
        return (x >> 24) & 0xFF;
 }
 
-static int bigsmp_apic_id_registered(void)
-{
-       return 1;
-}
-
 static bool bigsmp_check_apicid_used(physid_mask_t *map, int apicid)
 {
        return false;
        .name                           = "bigsmp",
        .probe                          = probe_bigsmp,
        .apic_id_valid                  = default_apic_id_valid,
-       .apic_id_registered             = bigsmp_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
 
 
 /* X2APIC */
 int x2apic_apic_id_valid(u32 apicid);
-int x2apic_apic_id_registered(void);
 void __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest);
 unsigned int x2apic_get_apic_id(unsigned long id);
 u32 x2apic_set_apic_id(unsigned int id);
 void default_send_IPI_all(int vector);
 void default_send_IPI_self(int vector);
 
+bool default_apic_id_registered(void);
+
 #ifdef CONFIG_X86_32
 void default_send_IPI_mask_sequence_logical(const struct cpumask *mask, int vector);
 void default_send_IPI_mask_allbutself_logical(const struct cpumask *mask, int vector);
 
 
 #include "local.h"
 
-static int default_apic_id_registered(void)
-{
-       return physid_isset(read_apic_id(), phys_cpu_present_map);
-}
-
 static int default_phys_pkg_id(int cpuid_apic, int index_msb)
 {
        return cpuid_apic >> index_msb;
 
        .probe                          = x2apic_cluster_probe,
        .acpi_madt_oem_check            = x2apic_acpi_madt_oem_check,
        .apic_id_valid                  = x2apic_apic_id_valid,
-       .apic_id_registered             = x2apic_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = true,
 
        return 1;
 }
 
-int x2apic_apic_id_registered(void)
-{
-       return 1;
-}
-
 void __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest)
 {
        unsigned long cfg = __prepare_ICR(0, vector, dest);
        .probe                          = x2apic_phys_probe,
        .acpi_madt_oem_check            = x2apic_acpi_madt_oem_check,
        .apic_id_valid                  = x2apic_apic_id_valid,
-       .apic_id_registered             = x2apic_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
 
        return 1;
 }
 
-static int uv_apic_id_registered(void)
-{
-       return 1;
-}
-
 static u32 apic_uv_calc_apicid(unsigned int cpu)
 {
        return apic_default_calc_apicid(cpu);
        .probe                          = uv_probe,
        .acpi_madt_oem_check            = uv_acpi_madt_oem_check,
        .apic_id_valid                  = uv_apic_id_valid,
-       .apic_id_registered             = uv_apic_id_registered,
 
        .delivery_mode                  = APIC_DELIVERY_MODE_FIXED,
        .dest_mode_logical              = false,
 
        return 1;
 }
 
-static int xen_id_always_registered(void)
-{
-       return 1;
-}
-
 static int xen_phys_pkg_id(int initial_apic_id, int index_msb)
 {
        return initial_apic_id >> index_msb;
        .probe                          = xen_apic_probe_pv,
        .acpi_madt_oem_check            = xen_madt_oem_check,
        .apic_id_valid                  = xen_id_always_valid,
-       .apic_id_registered             = xen_id_always_registered,
 
        /* .delivery_mode and .dest_mode_logical not used by XENPV */