Quelle  apic.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <linux/init.h>
#include <linux/thread_info.h>

#include <asm/x86_init.h>
#include <asm/apic.h>
#include <asm/io_apic.h>
#include <asm/xen/hypercall.h>

#include <xen/xen.h>
#include <xen/interface/physdev.h>
#include "xen-ops.h"

static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
{
 struct physdev_apic apic_op;
 int ret;

 apic_op.apic_physbase = mpc_ioapic_addr(apic);
 apic_op.reg = reg;
 ret = HYPERVISOR_physdev_op(PHYSDEVOP_apic_read, &apic_op);
 if (!ret)
  return apic_op.value;

 /* fallback to return an emulated IO_APIC values */
 if (reg == 0x1)
  return 0x00170020;
 else if (reg == 0x0)
  return apic << 24;

 return 0xfd;
}

static u32 xen_get_apic_id(u32 x)
{
 return ((x)>>24) & 0xFFu;
}

static u32 xen_apic_read(u32 reg)
{
 struct xen_platform_op op = {
  .cmd = XENPF_get_cpuinfo,
  .interface_version = XENPF_INTERFACE_VERSION,
 };
 int ret, cpu;

 if (reg == APIC_LVR)
  return 0x14;
 if (reg != APIC_ID)
  return 0;

 cpu = smp_processor_id();
 if (!xen_initial_domain())
  return cpu ? cpuid_to_apicid[cpu] << 24 : 0;

 op.u.pcpu_info.xen_cpuid = cpu;

 ret = HYPERVISOR_platform_op(&op);
 if (ret)
  op.u.pcpu_info.apic_id = BAD_APICID;

 return op.u.pcpu_info.apic_id << 24;
}

static void xen_apic_write(u32 reg, u32 val)
{
 if (reg == APIC_LVTPC) {
  (void)pmu_apic_update(reg);
  return;
 }

 /* Warn to see if there's any stray references */
 WARN(1,"register: %x, value: %x\n", reg, val);
}

static void xen_apic_eoi(void)
{
 WARN_ON_ONCE(1);
}

static u64 xen_apic_icr_read(void)
{
 return 0;
}

static void xen_apic_icr_write(u32 low, u32 id)
{
 /* Warn to see if there's any stray references */
 WARN_ON(1);
}

static int xen_apic_probe_pv(void)
{
 if (xen_pv_domain())
  return 1;

 return 0;
}

static int xen_madt_oem_check(char *oem_id, char *oem_table_id)
{
 return xen_pv_domain();
}

static u32 xen_cpu_present_to_apicid(int cpu)
{
 if (cpu_present(cpu))
  return cpu_data(cpu).topo.apicid;
 else
  return BAD_APICID;
}

static struct apic xen_pv_apic __ro_after_init = {
 .name    = "Xen PV",
 .probe    = xen_apic_probe_pv,
 .acpi_madt_oem_check  = xen_madt_oem_check,

 /* .delivery_mode and .dest_mode_logical not used by XENPV */

 .disable_esr   = 0,

 .cpu_present_to_apicid  = xen_cpu_present_to_apicid,

 .max_apic_id   = UINT_MAX,
 .get_apic_id   = xen_get_apic_id,

 .calc_dest_apicid  = apic_flat_calc_apicid,

#ifdef CONFIG_SMP
 .send_IPI_mask   = xen_send_IPI_mask,
 .send_IPI_mask_allbutself = xen_send_IPI_mask_allbutself,
 .send_IPI_allbutself  = xen_send_IPI_allbutself,
 .send_IPI_all   = xen_send_IPI_all,
 .send_IPI_self   = xen_send_IPI_self,
#endif
 .read    = xen_apic_read,
 .write    = xen_apic_write,
 .eoi    = xen_apic_eoi,

 .icr_read   = xen_apic_icr_read,
 .icr_write   = xen_apic_icr_write,
};
apic_driver(xen_pv_apic);

void __init xen_init_apic(void)
{
 x86_apic_ops.io_apic_read = xen_io_apic_read;
}