* Martin Bligh, Andi Kleen, James Bottomley, John Stultz, and
  * James Cleverdon.
  */
-struct genapic {
+struct apic {
        char *name;
 
        int (*probe)(void);
        int (*phys_pkg_id)(int cpuid_apic, int index_msb);
 
        /*
-        * When one of the next two hooks returns 1 the genapic
+        * When one of the next two hooks returns 1 the apic
         * is switched to this. Essentially they are additional
         * probe functions:
         */
        u32 (*safe_wait_icr_idle)(void);
 };
 
-extern struct genapic *apic;
+extern struct apic *apic;
 
 static inline u32 apic_read(u32 reg)
 {
 #define DEFAULT_TRAMPOLINE_PHYS_HIGH           0x469
 
 #ifdef CONFIG_X86_32
-extern void es7000_update_genapic_to_cluster(void);
+extern void es7000_update_apic_to_cluster(void);
 #else
-extern struct genapic apic_flat;
-extern struct genapic apic_physflat;
-extern struct genapic apic_x2apic_cluster;
-extern struct genapic apic_x2apic_phys;
+extern struct apic apic_flat;
+extern struct apic apic_physflat;
+extern struct apic apic_x2apic_cluster;
+extern struct apic apic_x2apic_phys;
 extern int default_acpi_madt_oem_check(char *, char *);
 
 extern void apic_send_IPI_self(int vector);
 
-extern struct genapic apic_x2apic_uv_x;
+extern struct apic apic_x2apic_uv_x;
 DECLARE_PER_CPU(int, x2apic_extra_bits);
 
 extern int default_cpu_present_to_apicid(int mps_cpu);
 
        void (*smp_read_mpc_oem)(struct mpc_oemtable *oemtable,
                                unsigned short oemsize);
        int (*setup_ioapic_ids)(void);
-       int (*update_genapic)(void);
+       int (*update_apic)(void);
 };
 
 #endif /* __ASSEMBLY__ */
 
        return dmi_bigsmp;
 }
 
-struct genapic apic_bigsmp = {
+struct apic apic_bigsmp = {
 
        .name                           = "bigsmp",
        .probe                          = probe_bigsmp,
 
        return 0;
 }
 
-static int __init es7000_update_genapic(void)
+static int __init es7000_update_apic(void)
 {
        apic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
 
        /* MPENTIUMIII */
        if (boot_cpu_data.x86 == 6 &&
            (boot_cpu_data.x86_model >= 7 || boot_cpu_data.x86_model <= 11)) {
-               es7000_update_genapic_to_cluster();
+               es7000_update_apic_to_cluster();
                apic->wait_for_init_deassert = NULL;
                apic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
        }
                es7000_plat = ES7000_CLASSIC;
        ioapic_renumber_irq = es7000_rename_gsi;
 
-       x86_quirks->update_genapic = es7000_update_genapic;
+       x86_quirks->update_apic = es7000_update_apic;
 }
 
 /*
        return cpuid_apic >> index_msb;
 }
 
-void __init es7000_update_genapic_to_cluster(void)
+void __init es7000_update_apic_to_cluster(void)
 {
        apic->target_cpus = target_cpus_cluster;
        apic->irq_delivery_mode = dest_LowestPrio;
 }
 
 
-struct genapic apic_es7000 = {
+struct apic apic_es7000 = {
 
        .name                           = "es7000",
        .probe                          = probe_es7000,
 
 #include <asm/ipi.h>
 #include <asm/setup.h>
 
-extern struct genapic apic_flat;
-extern struct genapic apic_physflat;
-extern struct genapic apic_x2xpic_uv_x;
-extern struct genapic apic_x2apic_phys;
-extern struct genapic apic_x2apic_cluster;
+extern struct apic apic_flat;
+extern struct apic apic_physflat;
+extern struct apic apic_x2xpic_uv_x;
+extern struct apic apic_x2apic_phys;
+extern struct apic apic_x2apic_cluster;
 
-struct genapic __read_mostly *apic = &apic_flat;
+struct apic __read_mostly *apic = &apic_flat;
 EXPORT_SYMBOL_GPL(apic);
 
-static struct genapic *apic_probe[] __initdata = {
+static struct apic *apic_probe[] __initdata = {
 #ifdef CONFIG_X86_UV
        &apic_x2apic_uv_x,
 #endif
                printk(KERN_INFO "Setting APIC routing to %s\n", apic->name);
        }
 
-       if (x86_quirks->update_genapic)
-               x86_quirks->update_genapic();
+       if (x86_quirks->update_apic)
+               x86_quirks->update_apic();
 }
 
 /* Same for both flat and physical. */
 
        return hard_smp_processor_id() >> index_msb;
 }
 
-struct genapic apic_flat =  {
+struct apic apic_flat =  {
        .name                           = "flat",
        .probe                          = NULL,
        .acpi_madt_oem_check            = flat_acpi_madt_oem_check,
        return BAD_APICID;
 }
 
-struct genapic apic_physflat =  {
+struct apic apic_physflat =  {
 
        .name                           = "physical flat",
        .probe                          = NULL,
 
        per_cpu(x86_cpu_to_logical_apicid, cpu) = apic_read(APIC_LDR);
 }
 
-struct genapic apic_x2apic_cluster = {
+struct apic apic_x2apic_cluster = {
 
        .name                           = "cluster x2apic",
        .probe                          = NULL,
 
 {
 }
 
-struct genapic apic_x2apic_phys = {
+struct apic apic_x2apic_phys = {
 
        .name                           = "physical x2apic",
        .probe                          = NULL,
 
        apic_write(APIC_SELF_IPI, vector);
 }
 
-struct genapic apic_x2apic_uv_x = {
+struct apic apic_x2apic_uv_x = {
 
        .name                           = "UV large system",
        .probe                          = NULL,
 
        return 1;
 }
 
-static int __init numaq_update_genapic(void)
+static int __init numaq_update_apic(void)
 {
        apic->wakeup_cpu = wakeup_secondary_cpu_via_nmi;
 
        .mpc_oem_pci_bus                = mpc_oem_pci_bus,
        .smp_read_mpc_oem               = smp_read_mpc_oem,
        .setup_ioapic_ids               = numaq_setup_ioapic_ids,
-       .update_genapic                 = numaq_update_genapic,
+       .update_apic                    = numaq_update_apic,
 };
 
 static __init void early_check_numaq(void)
                (u_long) xquad_portio, (u_long) num_quads*XQUAD_PORTIO_QUAD);
 }
 
-struct genapic apic_numaq = {
+struct apic apic_numaq = {
 
        .name                           = "NUMAQ",
        .probe                          = probe_numaq,
 
        return 1;
 }
 
-struct genapic apic_default = {
+struct apic apic_default = {
 
        .name                           = "default",
        .probe                          = probe_default,
        .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 };
 
-extern struct genapic apic_numaq;
-extern struct genapic apic_summit;
-extern struct genapic apic_bigsmp;
-extern struct genapic apic_es7000;
-extern struct genapic apic_default;
+extern struct apic apic_numaq;
+extern struct apic apic_summit;
+extern struct apic apic_bigsmp;
+extern struct apic apic_es7000;
+extern struct apic apic_default;
 
-struct genapic *apic = &apic_default;
+struct apic *apic = &apic_default;
 EXPORT_SYMBOL_GPL(apic);
 
-static struct genapic *apic_probe[] __initdata = {
+static struct apic *apic_probe[] __initdata = {
 #ifdef CONFIG_X86_NUMAQ
        &apic_numaq,
 #endif
                }
        }
 
-       if (x86_quirks->update_genapic)
-               x86_quirks->update_genapic();
+       if (x86_quirks->update_apic)
+               x86_quirks->update_apic();
 
        /* Parsed again by __setup for debug/verbose */
        return 0;
        if (!cmdline_apic && apic == &apic_default) {
                if (apic_bigsmp.probe()) {
                        apic = &apic_bigsmp;
-                       if (x86_quirks->update_genapic)
-                               x86_quirks->update_genapic();
+                       if (x86_quirks->update_apic)
+                               x86_quirks->update_apic();
                        printk(KERN_INFO "Overriding APIC driver with %s\n",
                               apic->name);
                }
                if (!apic_probe[i])
                        panic("Didn't find an APIC driver");
 
-               if (x86_quirks->update_genapic)
-                       x86_quirks->update_genapic();
+               if (x86_quirks->update_apic)
+                       x86_quirks->update_apic();
        }
        printk(KERN_INFO "Using APIC driver %s\n", apic->name);
 }
 
                if (!cmdline_apic) {
                        apic = apic_probe[i];
-                       if (x86_quirks->update_genapic)
-                               x86_quirks->update_genapic();
+                       if (x86_quirks->update_apic)
+                               x86_quirks->update_apic();
                        printk(KERN_INFO "Switched to APIC driver `%s'.\n",
                               apic->name);
                }
 
                if (!cmdline_apic) {
                        apic = apic_probe[i];
-                       if (x86_quirks->update_genapic)
-                               x86_quirks->update_genapic();
+                       if (x86_quirks->update_apic)
+                               x86_quirks->update_apic();
                        printk(KERN_INFO "Switched to APIC driver `%s'.\n",
                               apic->name);
                }
 
 early_param("elfcorehdr", setup_elfcorehdr);
 #endif
 
-static int __init default_update_genapic(void)
+static int __init default_update_apic(void)
 {
 #ifdef CONFIG_SMP
        if (!apic->wakeup_cpu)
 }
 
 static struct x86_quirks default_x86_quirks __initdata = {
-       .update_genapic         = default_update_genapic,
+       .update_apic         = default_update_apic,
 };
 
 struct x86_quirks *x86_quirks __initdata = &default_x86_quirks;
 
 }
 #endif
 
-struct genapic apic_summit = {
+struct apic apic_summit = {
 
        .name                           = "summit",
        .probe                          = probe_summit,