arch/x86/xen/apic.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/init.h>
   3
   4 #include <asm/x86_init.h>
   5 #include <asm/apic.h>
   6 #include <asm/xen/hypercall.h>
   7
   8 #include <xen/xen.h>
   9 #include <xen/interface/physdev.h>
  10 #include "xen-ops.h"
  11 #include "pmu.h"
  12 #include "smp.h"
  13
  14 static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
  15 {
  16         struct physdev_apic apic_op;
  17         int ret;
  18
  19         apic_op.apic_physbase = mpc_ioapic_addr(apic);
  20         apic_op.reg = reg;
  21         ret = HYPERVISOR_physdev_op(PHYSDEVOP_apic_read, &apic_op);
  22         if (!ret)
  23                 return apic_op.value;
  24
  25         /* fallback to return an emulated IO_APIC values */
  26         if (reg == 0x1)
  27                 return 0x00170020;
  28         else if (reg == 0x0)
  29                 return apic << 24;
  30
  31         return 0xfd;
  32 }
  33
  34 static unsigned long xen_set_apic_id(unsigned int x)
  35 {
  36         WARN_ON(1);
  37         return x;
  38 }
  39
  40 static unsigned int xen_get_apic_id(unsigned long x)
  41 {
  42         return ((x)>>24) & 0xFFu;
  43 }
  44
  45 static u32 xen_apic_read(u32 reg)
  46 {
  47         struct xen_platform_op op = {
  48                 .cmd = XENPF_get_cpuinfo,
  49                 .interface_version = XENPF_INTERFACE_VERSION,
  50                 .u.pcpu_info.xen_cpuid = 0,
  51         };
  52         int ret = 0;
  53
  54         /* Shouldn't need this as APIC is turned off for PV, and we only
  55          * get called on the bootup processor. But just in case. */
  56         if (!xen_initial_domain() || smp_processor_id())
  57                 return 0;
  58
  59         if (reg == APIC_LVR)
  60                 return 0x10;
  61 #ifdef CONFIG_X86_32
  62         if (reg == APIC_LDR)
  63                 return SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
  64 #endif
  65         if (reg != APIC_ID)
  66                 return 0;
  67
  68         ret = HYPERVISOR_platform_op(&op);
  69         if (ret)
  70                 op.u.pcpu_info.apic_id = BAD_APICID;
  71
  72         return op.u.pcpu_info.apic_id << 24;
  73 }
  74
  75 static void xen_apic_write(u32 reg, u32 val)
  76 {
  77         if (reg == APIC_LVTPC) {
  78                 (void)pmu_apic_update(reg);
  79                 return;
  80         }
  81
  82         /* Warn to see if there's any stray references */
  83         WARN(1,"register: %x, value: %x\n", reg, val);
  84 }
  85
  86 static u64 xen_apic_icr_read(void)
  87 {
  88         return 0;
  89 }
  90
  91 static void xen_apic_icr_write(u32 low, u32 id)
  92 {
  93         /* Warn to see if there's any stray references */
  94         WARN_ON(1);
  95 }
  96
  97 static u32 xen_safe_apic_wait_icr_idle(void)
  98 {
  99         return 0;
 100 }
 101
 102 static int xen_apic_probe_pv(void)
 103 {
 104         if (xen_pv_domain())
 105                 return 1;
 106
 107         return 0;
 108 }
 109
 110 static int xen_madt_oem_check(char *oem_id, char *oem_table_id)
 111 {
 112         return xen_pv_domain();
 113 }
 114
 115 static int xen_id_always_valid(int apicid)
 116 {
 117         return 1;
 118 }
 119
 120 static int xen_id_always_registered(void)
 121 {
 122         return 1;
 123 }
 124
 125 static int xen_phys_pkg_id(int initial_apic_id, int index_msb)
 126 {
 127         return initial_apic_id >> index_msb;
 128 }
 129
 130 #ifdef CONFIG_X86_32
 131 static int xen_x86_32_early_logical_apicid(int cpu)
 132 {
 133         /* Match with APIC_LDR read. Otherwise setup_local_APIC complains. */
 134         return 1 << cpu;
 135 }
 136 #endif
 137
 138 static void xen_noop(void)
 139 {
 140 }
 141
 142 static void xen_silent_inquire(int apicid)
 143 {
 144 }
 145
 146 static int xen_cpu_present_to_apicid(int cpu)
 147 {
 148         if (cpu_present(cpu))
 149                 return cpu_data(cpu).apicid;
 150         else
 151                 return BAD_APICID;
 152 }
 153
 154 static struct apic xen_pv_apic = {
 155         .name                           = "Xen PV",
 156         .probe                          = xen_apic_probe_pv,
 157         .acpi_madt_oem_check            = xen_madt_oem_check,
 158         .apic_id_valid                  = xen_id_always_valid,
 159         .apic_id_registered             = xen_id_always_registered,
 160
 161         /* .irq_delivery_mode - used in native_compose_msi_msg only */
 162         /* .irq_dest_mode     - used in native_compose_msi_msg only */
 163
 164         .target_cpus                    = default_target_cpus,
 165         .disable_esr                    = 0,
 166         /* .dest_logical      -  default_send_IPI_ use it but we use our own. */
 167         .check_apicid_used              = default_check_apicid_used, /* Used on 32-bit */
 168
 169         .vector_allocation_domain       = flat_vector_allocation_domain,
 170         .init_apic_ldr                  = xen_noop, /* setup_local_APIC calls it */
 171
 172         .ioapic_phys_id_map             = default_ioapic_phys_id_map, /* Used on 32-bit */
 173         .setup_apic_routing             = NULL,
 174         .cpu_present_to_apicid          = xen_cpu_present_to_apicid,
 175         .apicid_to_cpu_present          = physid_set_mask_of_physid, /* Used on 32-bit */
 176         .check_phys_apicid_present      = default_check_phys_apicid_present, /* smp_sanity_check needs it */
 177         .phys_pkg_id                    = xen_phys_pkg_id, /* detect_ht */
 178
 179         .get_apic_id                    = xen_get_apic_id,
 180         .set_apic_id                    = xen_set_apic_id, /* Can be NULL on 32-bit. */
 181
 182         .cpu_mask_to_apicid             = flat_cpu_mask_to_apicid,
 183
 184 #ifdef CONFIG_SMP
 185         .send_IPI_mask                  = xen_send_IPI_mask,
 186         .send_IPI_mask_allbutself       = xen_send_IPI_mask_allbutself,
 187         .send_IPI_allbutself            = xen_send_IPI_allbutself,
 188         .send_IPI_all                   = xen_send_IPI_all,
 189         .send_IPI_self                  = xen_send_IPI_self,
 190 #endif
 191         /* .wait_for_init_deassert- used  by AP bootup - smp_callin which we don't use */
 192         .inquire_remote_apic            = xen_silent_inquire,
 193
 194         .read                           = xen_apic_read,
 195         .write                          = xen_apic_write,
 196         .eoi_write                      = xen_apic_write,
 197
 198         .icr_read                       = xen_apic_icr_read,
 199         .icr_write                      = xen_apic_icr_write,
 200         .wait_icr_idle                  = xen_noop,
 201         .safe_wait_icr_idle             = xen_safe_apic_wait_icr_idle,
 202
 203 #ifdef CONFIG_X86_32
 204         /* generic_processor_info and setup_local_APIC. */
 205         .x86_32_early_logical_apicid    = xen_x86_32_early_logical_apicid,
 206 #endif
 207 };
 208
 209 static void __init xen_apic_check(void)
 210 {
 211         if (apic == &xen_pv_apic)
 212                 return;
 213
 214         pr_info("Switched APIC routing from %s to %s.\n", apic->name,
 215                 xen_pv_apic.name);
 216         apic = &xen_pv_apic;
 217 }
 218 void __init xen_init_apic(void)
 219 {
 220         x86_io_apic_ops.read = xen_io_apic_read;
 221         /* On PV guests the APIC CPUID bit is disabled so none of the
 222          * routines end up executing. */
 223         if (!xen_initial_domain())
 224                 apic = &xen_pv_apic;
 225
 226         x86_platform.apic_post_init = xen_apic_check;
 227 }
 228 apic_driver(xen_pv_apic);