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 <asm/apic.h> 16 #include <asm/io_apic.h> 17 #include <asm/acpi.h> 18 #include <asm/cpu.h> 19 #include <asm/hypervisor.h> 20 #include <asm/i8259.h> 21 #include <asm/irqdomain.h> 22 #include <asm/pci_x86.h> 23 #include <asm/reboot.h> 24 #include <asm/setup.h> 25 #include <asm/jailhouse_para.h> 26 27 static struct jailhouse_setup_data setup_data; 28 #define SETUP_DATA_V1_LEN (sizeof(setup_data.hdr) + sizeof(setup_data.v1)) 29 #define SETUP_DATA_V2_LEN (SETUP_DATA_V1_LEN + sizeof(setup_data.v2)) 30 31 static unsigned int precalibrated_tsc_khz; 32 33 static void jailhouse_setup_irq(unsigned int irq) 34 { 35 struct mpc_intsrc mp_irq = { 36 .type = MP_INTSRC, 37 .irqtype = mp_INT, 38 .irqflag = MP_IRQPOL_ACTIVE_HIGH | MP_IRQTRIG_EDGE, 39 .srcbusirq = irq, 40 .dstirq = irq, 41 }; 42 mp_save_irq(&mp_irq); 43 } 44 45 static uint32_t jailhouse_cpuid_base(void) 46 { 47 if (boot_cpu_data.cpuid_level < 0 || 48 !boot_cpu_has(X86_FEATURE_HYPERVISOR)) 49 return 0; 50 51 return hypervisor_cpuid_base("Jailhouse\0\0\0", 0); 52 } 53 54 static uint32_t __init jailhouse_detect(void) 55 { 56 return jailhouse_cpuid_base(); 57 } 58 59 static void jailhouse_get_wallclock(struct timespec64 *now) 60 { 61 memset(now, 0, sizeof(*now)); 62 } 63 64 static void __init jailhouse_timer_init(void) 65 { 66 lapic_timer_period = setup_data.v1.apic_khz * (1000 / HZ); 67 } 68 69 static unsigned long jailhouse_get_tsc(void) 70 { 71 return precalibrated_tsc_khz; 72 } 73 74 static void __init jailhouse_x2apic_init(void) 75 { 76 #ifdef CONFIG_X86_X2APIC 77 if (!x2apic_enabled()) 78 return; 79 /* 80 * We do not have access to IR inside Jailhouse non-root cells. So 81 * we have to run in physical mode. 82 */ 83 x2apic_phys = 1; 84 /* 85 * This will trigger the switch to apic_x2apic_phys. Empty OEM IDs 86 * ensure that only this APIC driver picks up the call. 87 */ 88 default_acpi_madt_oem_check("", ""); 89 #endif 90 } 91 92 static void __init jailhouse_get_smp_config(unsigned int early) 93 { 94 struct ioapic_domain_cfg ioapic_cfg = { 95 .type = IOAPIC_DOMAIN_STRICT, 96 .ops = &mp_ioapic_irqdomain_ops, 97 }; 98 unsigned int cpu; 99 100 jailhouse_x2apic_init(); 101 102 register_lapic_address(0xfee00000); 103 104 for (cpu = 0; cpu < setup_data.v1.num_cpus; cpu++) { 105 generic_processor_info(setup_data.v1.cpu_ids[cpu], 106 boot_cpu_apic_version); 107 } 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.get_smp_config = jailhouse_get_smp_config; 209 x86_init.pci.arch_init = jailhouse_pci_arch_init; 210 211 x86_platform.calibrate_cpu = jailhouse_get_tsc; 212 x86_platform.calibrate_tsc = jailhouse_get_tsc; 213 x86_platform.get_wallclock = jailhouse_get_wallclock; 214 x86_platform.legacy.rtc = 0; 215 x86_platform.legacy.warm_reset = 0; 216 x86_platform.legacy.i8042 = X86_LEGACY_I8042_PLATFORM_ABSENT; 217 218 legacy_pic = &null_legacy_pic; 219 220 machine_ops.emergency_restart = jailhouse_no_restart; 221 222 while (pa_data) { 223 mapping = early_memremap(pa_data, sizeof(header)); 224 memcpy(&header, mapping, sizeof(header)); 225 early_memunmap(mapping, sizeof(header)); 226 227 if (header.type == SETUP_JAILHOUSE) 228 break; 229 230 pa_data = header.next; 231 } 232 233 if (!pa_data) 234 panic("Jailhouse: No valid setup data found"); 235 236 /* setup data must at least contain the header */ 237 if (header.len < sizeof(setup_data.hdr)) 238 goto unsupported; 239 240 pa_data += offsetof(struct setup_data, data); 241 setup_data_len = min_t(unsigned long, sizeof(setup_data), 242 (unsigned long)header.len); 243 mapping = early_memremap(pa_data, setup_data_len); 244 memcpy(&setup_data, mapping, setup_data_len); 245 early_memunmap(mapping, setup_data_len); 246 247 if (setup_data.hdr.version == 0 || 248 setup_data.hdr.compatible_version != 249 JAILHOUSE_SETUP_REQUIRED_VERSION || 250 (setup_data.hdr.version == 1 && header.len < SETUP_DATA_V1_LEN) || 251 (setup_data.hdr.version >= 2 && header.len < SETUP_DATA_V2_LEN)) 252 goto unsupported; 253 254 pmtmr_ioport = setup_data.v1.pm_timer_address; 255 pr_debug("Jailhouse: PM-Timer IO Port: %#x\n", pmtmr_ioport); 256 257 precalibrated_tsc_khz = setup_data.v1.tsc_khz; 258 setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ); 259 260 pci_probe = 0; 261 262 /* 263 * Avoid that the kernel complains about missing ACPI tables - there 264 * are none in a non-root cell. 265 */ 266 disable_acpi(); 267 268 jailhouse_serial_workaround(); 269 return; 270 271 unsupported: 272 panic("Jailhouse: Unsupported setup data structure"); 273 } 274 275 bool jailhouse_paravirt(void) 276 { 277 return jailhouse_cpuid_base() != 0; 278 } 279 280 static bool __init jailhouse_x2apic_available(void) 281 { 282 /* 283 * The x2APIC is only available if the root cell enabled it. Jailhouse 284 * does not support switching between xAPIC and x2APIC. 285 */ 286 return x2apic_enabled(); 287 } 288 289 const struct hypervisor_x86 x86_hyper_jailhouse __refconst = { 290 .name = "Jailhouse", 291 .detect = jailhouse_detect, 292 .init.init_platform = jailhouse_init_platform, 293 .init.x2apic_available = jailhouse_x2apic_available, 294 .ignore_nopv = true, 295 }; 296