1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Jailhouse paravirt_ops implementation 4 * 5 * Copyright (c) Siemens AG, 2015-2017 6 * 7 * Authors: 8 * Jan Kiszka <jan.kiszka@siemens.com> 9 */ 10 11 #include <linux/acpi_pmtmr.h> 12 #include <linux/kernel.h> 13 #include <linux/reboot.h> 14 #include <linux/serial_8250.h> 15 #include <linux/acpi.h> 16 #include <asm/apic.h> 17 #include <asm/io_apic.h> 18 #include <asm/acpi.h> 19 #include <asm/cpu.h> 20 #include <asm/cpuid/api.h> 21 #include <asm/hypervisor.h> 22 #include <asm/i8259.h> 23 #include <asm/irqdomain.h> 24 #include <asm/pci_x86.h> 25 #include <asm/reboot.h> 26 #include <asm/setup.h> 27 #include <asm/jailhouse_para.h> 28 29 static struct jailhouse_setup_data setup_data; 30 #define SETUP_DATA_V1_LEN (sizeof(setup_data.hdr) + sizeof(setup_data.v1)) 31 #define SETUP_DATA_V2_LEN (SETUP_DATA_V1_LEN + sizeof(setup_data.v2)) 32 33 static unsigned int precalibrated_tsc_khz; 34 35 static void jailhouse_setup_irq(unsigned int irq) 36 { 37 struct mpc_intsrc mp_irq = { 38 .type = MP_INTSRC, 39 .irqtype = mp_INT, 40 .irqflag = MP_IRQPOL_ACTIVE_HIGH | MP_IRQTRIG_EDGE, 41 .srcbusirq = irq, 42 .dstirq = irq, 43 }; 44 mp_save_irq(&mp_irq); 45 } 46 47 static uint32_t jailhouse_cpuid_base(void) 48 { 49 if (boot_cpu_data.cpuid_level < 0 || 50 !boot_cpu_has(X86_FEATURE_HYPERVISOR)) 51 return 0; 52 53 return cpuid_base_hypervisor("Jailhouse\0\0\0", 0); 54 } 55 56 static uint32_t __init jailhouse_detect(void) 57 { 58 return jailhouse_cpuid_base(); 59 } 60 61 static void jailhouse_get_wallclock(struct timespec64 *now) 62 { 63 memset(now, 0, sizeof(*now)); 64 } 65 66 static void __init jailhouse_timer_init(void) 67 { 68 lapic_timer_period = setup_data.v1.apic_khz * (1000 / HZ); 69 } 70 71 static unsigned long jailhouse_get_tsc(void) 72 { 73 return precalibrated_tsc_khz; 74 } 75 76 static void __init jailhouse_x2apic_init(void) 77 { 78 #ifdef CONFIG_X86_X2APIC 79 if (!x2apic_enabled()) 80 return; 81 /* 82 * We do not have access to IR inside Jailhouse non-root cells. So 83 * we have to run in physical mode. 84 */ 85 x2apic_phys = 1; 86 /* 87 * This will trigger the switch to apic_x2apic_phys. Empty OEM IDs 88 * ensure that only this APIC driver picks up the call. 89 */ 90 default_acpi_madt_oem_check("", ""); 91 #endif 92 } 93 94 static void __init jailhouse_parse_smp_config(void) 95 { 96 struct ioapic_domain_cfg ioapic_cfg = { 97 .type = IOAPIC_DOMAIN_STRICT, 98 .ops = &mp_ioapic_irqdomain_ops, 99 }; 100 unsigned int cpu; 101 102 jailhouse_x2apic_init(); 103 104 register_lapic_address(0xfee00000); 105 106 for (cpu = 0; cpu < setup_data.v1.num_cpus; cpu++) 107 topology_register_apic(setup_data.v1.cpu_ids[cpu], CPU_ACPIID_INVALID, true); 108 109 smp_found_config = 1; 110 111 if (setup_data.v1.standard_ioapic) { 112 mp_register_ioapic(0, 0xfec00000, gsi_top, &ioapic_cfg); 113 114 if (IS_ENABLED(CONFIG_SERIAL_8250) && 115 setup_data.hdr.version < 2) { 116 /* Register 1:1 mapping for legacy UART IRQs 3 and 4 */ 117 jailhouse_setup_irq(3); 118 jailhouse_setup_irq(4); 119 } 120 } 121 } 122 123 static void jailhouse_no_restart(void) 124 { 125 pr_notice("Jailhouse: Restart not supported, halting\n"); 126 machine_halt(); 127 } 128 129 static int __init jailhouse_pci_arch_init(void) 130 { 131 pci_direct_init(1); 132 133 /* 134 * There are no bridges on the virtual PCI root bus under Jailhouse, 135 * thus no other way to discover all devices than a full scan. 136 * Respect any overrides via the command line, though. 137 */ 138 if (pcibios_last_bus < 0) 139 pcibios_last_bus = 0xff; 140 141 #ifdef CONFIG_PCI_MMCONFIG 142 if (setup_data.v1.pci_mmconfig_base) { 143 pci_mmconfig_add(0, 0, pcibios_last_bus, 144 setup_data.v1.pci_mmconfig_base); 145 pci_mmcfg_arch_init(); 146 } 147 #endif 148 149 return 0; 150 } 151 152 #ifdef CONFIG_SERIAL_8250 153 static inline bool jailhouse_uart_enabled(unsigned int uart_nr) 154 { 155 return setup_data.v2.flags & BIT(uart_nr); 156 } 157 158 static void jailhouse_serial_fixup(int port, struct uart_port *up, 159 u32 *capabilities) 160 { 161 static const u16 pcuart_base[] = {0x3f8, 0x2f8, 0x3e8, 0x2e8}; 162 unsigned int n; 163 164 for (n = 0; n < ARRAY_SIZE(pcuart_base); n++) { 165 if (pcuart_base[n] != up->iobase) 166 continue; 167 168 if (jailhouse_uart_enabled(n)) { 169 pr_info("Enabling UART%u (port 0x%lx)\n", n, 170 up->iobase); 171 jailhouse_setup_irq(up->irq); 172 } else { 173 /* Deactivate UART if access isn't allowed */ 174 up->iobase = 0; 175 } 176 break; 177 } 178 } 179 180 static void __init jailhouse_serial_workaround(void) 181 { 182 /* 183 * There are flags inside setup_data that indicate availability of 184 * platform UARTs since setup data version 2. 185 * 186 * In case of version 1, we don't know which UARTs belong Linux. In 187 * this case, unconditionally register 1:1 mapping for legacy UART IRQs 188 * 3 and 4. 189 */ 190 if (setup_data.hdr.version > 1) 191 serial8250_set_isa_configurator(jailhouse_serial_fixup); 192 } 193 #else /* !CONFIG_SERIAL_8250 */ 194 static inline void jailhouse_serial_workaround(void) 195 { 196 } 197 #endif /* CONFIG_SERIAL_8250 */ 198 199 static void __init jailhouse_init_platform(void) 200 { 201 u64 pa_data = boot_params.hdr.setup_data; 202 unsigned long setup_data_len; 203 struct setup_data header; 204 void *mapping; 205 206 x86_init.irqs.pre_vector_init = x86_init_noop; 207 x86_init.timers.timer_init = jailhouse_timer_init; 208 x86_init.mpparse.find_mptable = x86_init_noop; 209 x86_init.mpparse.early_parse_smp_cfg = x86_init_noop; 210 x86_init.mpparse.parse_smp_cfg = jailhouse_parse_smp_config; 211 x86_init.pci.arch_init = jailhouse_pci_arch_init; 212 213 x86_platform.calibrate_cpu = jailhouse_get_tsc; 214 x86_platform.calibrate_tsc = jailhouse_get_tsc; 215 x86_platform.get_wallclock = jailhouse_get_wallclock; 216 x86_platform.legacy.rtc = 0; 217 x86_platform.legacy.warm_reset = 0; 218 x86_platform.legacy.i8042 = X86_LEGACY_I8042_PLATFORM_ABSENT; 219 220 legacy_pic = &null_legacy_pic; 221 222 machine_ops.emergency_restart = jailhouse_no_restart; 223 224 while (pa_data) { 225 mapping = early_memremap(pa_data, sizeof(header)); 226 memcpy(&header, mapping, sizeof(header)); 227 early_memunmap(mapping, sizeof(header)); 228 229 if (header.type == SETUP_JAILHOUSE) 230 break; 231 232 pa_data = header.next; 233 } 234 235 if (!pa_data) 236 panic("Jailhouse: No valid setup data found"); 237 238 /* setup data must at least contain the header */ 239 if (header.len < sizeof(setup_data.hdr)) 240 goto unsupported; 241 242 pa_data += offsetof(struct setup_data, data); 243 setup_data_len = min_t(unsigned long, sizeof(setup_data), 244 (unsigned long)header.len); 245 mapping = early_memremap(pa_data, setup_data_len); 246 memcpy(&setup_data, mapping, setup_data_len); 247 early_memunmap(mapping, setup_data_len); 248 249 if (setup_data.hdr.version == 0 || 250 setup_data.hdr.compatible_version != 251 JAILHOUSE_SETUP_REQUIRED_VERSION || 252 (setup_data.hdr.version == 1 && header.len < SETUP_DATA_V1_LEN) || 253 (setup_data.hdr.version >= 2 && header.len < SETUP_DATA_V2_LEN)) 254 goto unsupported; 255 256 pmtmr_ioport = setup_data.v1.pm_timer_address; 257 pr_debug("Jailhouse: PM-Timer IO Port: %#x\n", pmtmr_ioport); 258 259 precalibrated_tsc_khz = setup_data.v1.tsc_khz; 260 setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ); 261 262 pci_probe = 0; 263 264 /* 265 * Avoid that the kernel complains about missing ACPI tables - there 266 * are none in a non-root cell. 267 */ 268 disable_acpi(); 269 270 jailhouse_serial_workaround(); 271 return; 272 273 unsupported: 274 panic("Jailhouse: Unsupported setup data structure"); 275 } 276 277 bool jailhouse_paravirt(void) 278 { 279 return jailhouse_cpuid_base() != 0; 280 } 281 282 static bool __init jailhouse_x2apic_available(void) 283 { 284 /* 285 * The x2APIC is only available if the root cell enabled it. Jailhouse 286 * does not support switching between xAPIC and x2APIC. 287 */ 288 return x2apic_enabled(); 289 } 290 291 const struct hypervisor_x86 x86_hyper_jailhouse __refconst = { 292 .name = "Jailhouse", 293 .detect = jailhouse_detect, 294 .init.init_platform = jailhouse_init_platform, 295 .init.x2apic_available = jailhouse_x2apic_available, 296 .ignore_nopv = true, 297 }; 298