arch/x86/xen/apic.c

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