This source file includes following definitions.
- jailhouse_cpuid_base
- jailhouse_detect
- jailhouse_get_wallclock
- jailhouse_timer_init
- jailhouse_get_tsc
- jailhouse_x2apic_init
- jailhouse_get_smp_config
- jailhouse_no_restart
- jailhouse_pci_arch_init
- jailhouse_init_platform
- jailhouse_paravirt
- jailhouse_x2apic_available
1
2
3
4
5
6
7
8
9
10
11 #include <linux/acpi_pmtmr.h>
12 #include <linux/kernel.h>
13 #include <linux/reboot.h>
14 #include <asm/apic.h>
15 #include <asm/cpu.h>
16 #include <asm/hypervisor.h>
17 #include <asm/i8259.h>
18 #include <asm/irqdomain.h>
19 #include <asm/pci_x86.h>
20 #include <asm/reboot.h>
21 #include <asm/setup.h>
22 #include <asm/jailhouse_para.h>
23
24 static __initdata struct jailhouse_setup_data setup_data;
25 static unsigned int precalibrated_tsc_khz;
26
27 static uint32_t jailhouse_cpuid_base(void)
28 {
29 if (boot_cpu_data.cpuid_level < 0 ||
30 !boot_cpu_has(X86_FEATURE_HYPERVISOR))
31 return 0;
32
33 return hypervisor_cpuid_base("Jailhouse\0\0\0", 0);
34 }
35
36 static uint32_t __init jailhouse_detect(void)
37 {
38 return jailhouse_cpuid_base();
39 }
40
41 static void jailhouse_get_wallclock(struct timespec64 *now)
42 {
43 memset(now, 0, sizeof(*now));
44 }
45
46 static void __init jailhouse_timer_init(void)
47 {
48 lapic_timer_period = setup_data.apic_khz * (1000 / HZ);
49 }
50
51 static unsigned long jailhouse_get_tsc(void)
52 {
53 return precalibrated_tsc_khz;
54 }
55
56 static void __init jailhouse_x2apic_init(void)
57 {
58 #ifdef CONFIG_X86_X2APIC
59 if (!x2apic_enabled())
60 return;
61
62
63
64
65 x2apic_phys = 1;
66
67
68
69
70 default_acpi_madt_oem_check("", "");
71 #endif
72 }
73
74 static void __init jailhouse_get_smp_config(unsigned int early)
75 {
76 struct ioapic_domain_cfg ioapic_cfg = {
77 .type = IOAPIC_DOMAIN_STRICT,
78 .ops = &mp_ioapic_irqdomain_ops,
79 };
80 struct mpc_intsrc mp_irq = {
81 .type = MP_INTSRC,
82 .irqtype = mp_INT,
83 .irqflag = MP_IRQPOL_ACTIVE_HIGH | MP_IRQTRIG_EDGE,
84 };
85 unsigned int cpu;
86
87 jailhouse_x2apic_init();
88
89 register_lapic_address(0xfee00000);
90
91 for (cpu = 0; cpu < setup_data.num_cpus; cpu++) {
92 generic_processor_info(setup_data.cpu_ids[cpu],
93 boot_cpu_apic_version);
94 }
95
96 smp_found_config = 1;
97
98 if (setup_data.standard_ioapic) {
99 mp_register_ioapic(0, 0xfec00000, gsi_top, &ioapic_cfg);
100
101
102 mp_irq.srcbusirq = mp_irq.dstirq = 3;
103 mp_save_irq(&mp_irq);
104
105 mp_irq.srcbusirq = mp_irq.dstirq = 4;
106 mp_save_irq(&mp_irq);
107 }
108 }
109
110 static void jailhouse_no_restart(void)
111 {
112 pr_notice("Jailhouse: Restart not supported, halting\n");
113 machine_halt();
114 }
115
116 static int __init jailhouse_pci_arch_init(void)
117 {
118 pci_direct_init(1);
119
120
121
122
123
124
125 if (pcibios_last_bus < 0)
126 pcibios_last_bus = 0xff;
127
128 #ifdef CONFIG_PCI_MMCONFIG
129 if (setup_data.pci_mmconfig_base) {
130 pci_mmconfig_add(0, 0, pcibios_last_bus,
131 setup_data.pci_mmconfig_base);
132 pci_mmcfg_arch_init();
133 }
134 #endif
135
136 return 0;
137 }
138
139 static void __init jailhouse_init_platform(void)
140 {
141 u64 pa_data = boot_params.hdr.setup_data;
142 struct setup_data header;
143 void *mapping;
144
145 x86_init.irqs.pre_vector_init = x86_init_noop;
146 x86_init.timers.timer_init = jailhouse_timer_init;
147 x86_init.mpparse.get_smp_config = jailhouse_get_smp_config;
148 x86_init.pci.arch_init = jailhouse_pci_arch_init;
149
150 x86_platform.calibrate_cpu = jailhouse_get_tsc;
151 x86_platform.calibrate_tsc = jailhouse_get_tsc;
152 x86_platform.get_wallclock = jailhouse_get_wallclock;
153 x86_platform.legacy.rtc = 0;
154 x86_platform.legacy.warm_reset = 0;
155 x86_platform.legacy.i8042 = X86_LEGACY_I8042_PLATFORM_ABSENT;
156
157 legacy_pic = &null_legacy_pic;
158
159 machine_ops.emergency_restart = jailhouse_no_restart;
160
161 while (pa_data) {
162 mapping = early_memremap(pa_data, sizeof(header));
163 memcpy(&header, mapping, sizeof(header));
164 early_memunmap(mapping, sizeof(header));
165
166 if (header.type == SETUP_JAILHOUSE &&
167 header.len >= sizeof(setup_data)) {
168 pa_data += offsetof(struct setup_data, data);
169
170 mapping = early_memremap(pa_data, sizeof(setup_data));
171 memcpy(&setup_data, mapping, sizeof(setup_data));
172 early_memunmap(mapping, sizeof(setup_data));
173
174 break;
175 }
176
177 pa_data = header.next;
178 }
179
180 if (!pa_data)
181 panic("Jailhouse: No valid setup data found");
182
183 if (setup_data.compatible_version > JAILHOUSE_SETUP_REQUIRED_VERSION)
184 panic("Jailhouse: Unsupported setup data structure");
185
186 pmtmr_ioport = setup_data.pm_timer_address;
187 pr_debug("Jailhouse: PM-Timer IO Port: %#x\n", pmtmr_ioport);
188
189 precalibrated_tsc_khz = setup_data.tsc_khz;
190 setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ);
191
192 pci_probe = 0;
193
194
195
196
197
198 disable_acpi();
199 }
200
201 bool jailhouse_paravirt(void)
202 {
203 return jailhouse_cpuid_base() != 0;
204 }
205
206 static bool __init jailhouse_x2apic_available(void)
207 {
208
209
210
211
212 return x2apic_enabled();
213 }
214
215 const struct hypervisor_x86 x86_hyper_jailhouse __refconst = {
216 .name = "Jailhouse",
217 .detect = jailhouse_detect,
218 .init.init_platform = jailhouse_init_platform,
219 .init.x2apic_available = jailhouse_x2apic_available,
220 .ignore_nopv = true,
221 };