arch/x86/kernel/apic/probe_32.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Default generic APIC driver. This handles up to 8 CPUs.
   4  *
   5  * Copyright 2003 Andi Kleen, SuSE Labs.
   6  *
   7  * Generic x86 APIC driver probe layer.
   8  */
   9 #include <linux/export.h>
  10 #include <linux/errno.h>
  11 #include <linux/smp.h>
  12
  13 #include <asm/io_apic.h>
  14 #include <asm/apic.h>
  15 #include <asm/acpi.h>
  16
  17 #include "local.h"
  18
  19 static int default_x86_32_early_logical_apicid(int cpu)
  20 {
  21         return 1 << cpu;
  22 }
  23
  24 static void setup_apic_flat_routing(void)
  25 {
  26 #ifdef CONFIG_X86_IO_APIC
  27         printk(KERN_INFO
  28                 "Enabling APIC mode:  Flat.  Using %d I/O APICs\n",
  29                 nr_ioapics);
  30 #endif
  31 }
  32
  33 static int default_apic_id_registered(void)
  34 {
  35         return physid_isset(read_apic_id(), phys_cpu_present_map);
  36 }
  37
  38 /*
  39  * Set up the logical destination ID.  Intel recommends to set DFR, LDR and
  40  * TPR before enabling an APIC.  See e.g. "AP-388 82489DX User's Manual"
  41  * (Intel document number 292116).
  42  */
  43 static void default_init_apic_ldr(void)
  44 {
  45         unsigned long val;
  46
  47         apic_write(APIC_DFR, APIC_DFR_VALUE);
  48         val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
  49         val |= SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
  50         apic_write(APIC_LDR, val);
  51 }
  52
  53 static int default_phys_pkg_id(int cpuid_apic, int index_msb)
  54 {
  55         return cpuid_apic >> index_msb;
  56 }
  57
  58 /* should be called last. */
  59 static int probe_default(void)
  60 {
  61         return 1;
  62 }
  63
  64 static struct apic apic_default __ro_after_init = {
  65
  66         .name                           = "default",
  67         .probe                          = probe_default,
  68         .acpi_madt_oem_check            = NULL,
  69         .apic_id_valid                  = default_apic_id_valid,
  70         .apic_id_registered             = default_apic_id_registered,
  71
  72         .irq_delivery_mode              = dest_Fixed,
  73         /* logical delivery broadcast to all CPUs: */
  74         .irq_dest_mode                  = 1,
  75
  76         .disable_esr                    = 0,
  77         .dest_logical                   = APIC_DEST_LOGICAL,
  78         .check_apicid_used              = default_check_apicid_used,
  79
  80         .init_apic_ldr                  = default_init_apic_ldr,
  81
  82         .ioapic_phys_id_map             = default_ioapic_phys_id_map,
  83         .setup_apic_routing             = setup_apic_flat_routing,
  84         .cpu_present_to_apicid          = default_cpu_present_to_apicid,
  85         .apicid_to_cpu_present          = physid_set_mask_of_physid,
  86         .check_phys_apicid_present      = default_check_phys_apicid_present,
  87         .phys_pkg_id                    = default_phys_pkg_id,
  88
  89         .get_apic_id                    = default_get_apic_id,
  90         .set_apic_id                    = NULL,
  91
  92         .calc_dest_apicid               = apic_flat_calc_apicid,
  93
  94         .send_IPI                       = default_send_IPI_single,
  95         .send_IPI_mask                  = default_send_IPI_mask_logical,
  96         .send_IPI_mask_allbutself       = default_send_IPI_mask_allbutself_logical,
  97         .send_IPI_allbutself            = default_send_IPI_allbutself,
  98         .send_IPI_all                   = default_send_IPI_all,
  99         .send_IPI_self                  = default_send_IPI_self,
 100
 101         .inquire_remote_apic            = default_inquire_remote_apic,
 102
 103         .read                           = native_apic_mem_read,
 104         .write                          = native_apic_mem_write,
 105         .eoi_write                      = native_apic_mem_write,
 106         .icr_read                       = native_apic_icr_read,
 107         .icr_write                      = native_apic_icr_write,
 108         .wait_icr_idle                  = native_apic_wait_icr_idle,
 109         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 110
 111         .x86_32_early_logical_apicid    = default_x86_32_early_logical_apicid,
 112 };
 113
 114 apic_driver(apic_default);
 115
 116 struct apic *apic __ro_after_init = &apic_default;
 117 EXPORT_SYMBOL_GPL(apic);
 118
 119 static int cmdline_apic __initdata;
 120 static int __init parse_apic(char *arg)
 121 {
 122         struct apic **drv;
 123
 124         if (!arg)
 125                 return -EINVAL;
 126
 127         for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
 128                 if (!strcmp((*drv)->name, arg)) {
 129                         apic = *drv;
 130                         cmdline_apic = 1;
 131                         return 0;
 132                 }
 133         }
 134
 135         /* Parsed again by __setup for debug/verbose */
 136         return 0;
 137 }
 138 early_param("apic", parse_apic);
 139
 140 void __init default_setup_apic_routing(void)
 141 {
 142         int version = boot_cpu_apic_version;
 143
 144         if (num_possible_cpus() > 8) {
 145                 switch (boot_cpu_data.x86_vendor) {
 146                 case X86_VENDOR_INTEL:
 147                         if (!APIC_XAPIC(version)) {
 148                                 def_to_bigsmp = 0;
 149                                 break;
 150                         }
 151                         /* P4 and above */
 152                         /* fall through */
 153                 case X86_VENDOR_HYGON:
 154                 case X86_VENDOR_AMD:
 155                         def_to_bigsmp = 1;
 156                 }
 157         }
 158
 159 #ifdef CONFIG_X86_BIGSMP
 160         /*
 161          * This is used to switch to bigsmp mode when
 162          * - There is no apic= option specified by the user
 163          * - generic_apic_probe() has chosen apic_default as the sub_arch
 164          * - we find more than 8 CPUs in acpi LAPIC listing with xAPIC support
 165          */
 166
 167         if (!cmdline_apic && apic == &apic_default)
 168                 generic_bigsmp_probe();
 169 #endif
 170
 171         if (apic->setup_apic_routing)
 172                 apic->setup_apic_routing();
 173
 174         if (x86_platform.apic_post_init)
 175                 x86_platform.apic_post_init();
 176 }
 177
 178 void __init generic_apic_probe(void)
 179 {
 180         if (!cmdline_apic) {
 181                 struct apic **drv;
 182
 183                 for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
 184                         if ((*drv)->probe()) {
 185                                 apic = *drv;
 186                                 break;
 187                         }
 188                 }
 189                 /* Not visible without early console */
 190                 if (drv == __apicdrivers_end)
 191                         panic("Didn't find an APIC driver");
 192         }
 193         printk(KERN_INFO "Using APIC driver %s\n", apic->name);
 194 }
 195
 196 /* This function can switch the APIC even after the initial ->probe() */
 197 int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
 198 {
 199         struct apic **drv;
 200
 201         for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
 202                 if (!(*drv)->acpi_madt_oem_check)
 203                         continue;
 204                 if (!(*drv)->acpi_madt_oem_check(oem_id, oem_table_id))
 205                         continue;
 206
 207                 if (!cmdline_apic) {
 208                         apic = *drv;
 209                         printk(KERN_INFO "Switched to APIC driver `%s'.\n",
 210                                apic->name);
 211                 }
 212                 return 1;
 213         }
 214         return 0;
 215 }