1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright 2004 James Cleverdon, IBM. |
4 | * |
5 | * Flat APIC subarch code. |
6 | * |
7 | * Hacked for x86-64 by James Cleverdon from i386 architecture code by |
8 | * Martin Bligh, Andi Kleen, James Bottomley, John Stultz, and |
9 | * James Cleverdon. |
10 | */ |
11 | #include <linux/cpumask.h> |
12 | #include <linux/export.h> |
13 | #include <linux/acpi.h> |
14 | |
15 | #include <asm/jailhouse_para.h> |
16 | #include <asm/apic.h> |
17 | |
18 | #include "local.h" |
19 | |
20 | static struct apic apic_physflat; |
21 | static struct apic apic_flat; |
22 | |
23 | struct apic *apic __ro_after_init = &apic_flat; |
24 | EXPORT_SYMBOL_GPL(apic); |
25 | |
26 | static int flat_acpi_madt_oem_check(char *oem_id, char *oem_table_id) |
27 | { |
28 | return 1; |
29 | } |
30 | |
31 | static void _flat_send_IPI_mask(unsigned long mask, int vector) |
32 | { |
33 | unsigned long flags; |
34 | |
35 | local_irq_save(flags); |
36 | __default_send_IPI_dest_field(mask, vector, APIC_DEST_LOGICAL); |
37 | local_irq_restore(flags); |
38 | } |
39 | |
40 | static void flat_send_IPI_mask(const struct cpumask *cpumask, int vector) |
41 | { |
42 | unsigned long mask = cpumask_bits(cpumask)[0]; |
43 | |
44 | _flat_send_IPI_mask(mask, vector); |
45 | } |
46 | |
47 | static void |
48 | flat_send_IPI_mask_allbutself(const struct cpumask *cpumask, int vector) |
49 | { |
50 | unsigned long mask = cpumask_bits(cpumask)[0]; |
51 | int cpu = smp_processor_id(); |
52 | |
53 | if (cpu < BITS_PER_LONG) |
54 | __clear_bit(cpu, &mask); |
55 | |
56 | _flat_send_IPI_mask(mask, vector); |
57 | } |
58 | |
59 | static u32 flat_get_apic_id(u32 x) |
60 | { |
61 | return (x >> 24) & 0xFF; |
62 | } |
63 | |
64 | static u32 set_apic_id(u32 id) |
65 | { |
66 | return (id & 0xFF) << 24; |
67 | } |
68 | |
69 | static u32 flat_phys_pkg_id(u32 initial_apic_id, int index_msb) |
70 | { |
71 | return initial_apic_id >> index_msb; |
72 | } |
73 | |
74 | static int flat_probe(void) |
75 | { |
76 | return 1; |
77 | } |
78 | |
79 | static struct apic apic_flat __ro_after_init = { |
80 | .name = "flat" , |
81 | .probe = flat_probe, |
82 | .acpi_madt_oem_check = flat_acpi_madt_oem_check, |
83 | .apic_id_registered = default_apic_id_registered, |
84 | |
85 | .delivery_mode = APIC_DELIVERY_MODE_FIXED, |
86 | .dest_mode_logical = true, |
87 | |
88 | .disable_esr = 0, |
89 | |
90 | .init_apic_ldr = default_init_apic_ldr, |
91 | .cpu_present_to_apicid = default_cpu_present_to_apicid, |
92 | .phys_pkg_id = flat_phys_pkg_id, |
93 | |
94 | .max_apic_id = 0xFE, |
95 | .get_apic_id = flat_get_apic_id, |
96 | .set_apic_id = set_apic_id, |
97 | |
98 | .calc_dest_apicid = apic_flat_calc_apicid, |
99 | |
100 | .send_IPI = default_send_IPI_single, |
101 | .send_IPI_mask = flat_send_IPI_mask, |
102 | .send_IPI_mask_allbutself = flat_send_IPI_mask_allbutself, |
103 | .send_IPI_allbutself = default_send_IPI_allbutself, |
104 | .send_IPI_all = default_send_IPI_all, |
105 | .send_IPI_self = default_send_IPI_self, |
106 | .nmi_to_offline_cpu = true, |
107 | |
108 | .read = native_apic_mem_read, |
109 | .write = native_apic_mem_write, |
110 | .eoi = native_apic_mem_eoi, |
111 | .icr_read = native_apic_icr_read, |
112 | .icr_write = native_apic_icr_write, |
113 | .wait_icr_idle = apic_mem_wait_icr_idle, |
114 | .safe_wait_icr_idle = apic_mem_wait_icr_idle_timeout, |
115 | }; |
116 | |
117 | /* |
118 | * Physflat mode is used when there are more than 8 CPUs on a system. |
119 | * We cannot use logical delivery in this case because the mask |
120 | * overflows, so use physical mode. |
121 | */ |
122 | static int physflat_acpi_madt_oem_check(char *oem_id, char *oem_table_id) |
123 | { |
124 | #ifdef CONFIG_ACPI |
125 | /* |
126 | * Quirk: some x86_64 machines can only use physical APIC mode |
127 | * regardless of how many processors are present (x86_64 ES7000 |
128 | * is an example). |
129 | */ |
130 | if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID && |
131 | (acpi_gbl_FADT.flags & ACPI_FADT_APIC_PHYSICAL)) { |
132 | printk(KERN_DEBUG "system APIC only can use physical flat" ); |
133 | return 1; |
134 | } |
135 | |
136 | if (!strncmp(oem_id, "IBM" , 3) && !strncmp(oem_table_id, "EXA" , 3)) { |
137 | printk(KERN_DEBUG "IBM Summit detected, will use apic physical" ); |
138 | return 1; |
139 | } |
140 | #endif |
141 | |
142 | return 0; |
143 | } |
144 | |
145 | static int physflat_probe(void) |
146 | { |
147 | return apic == &apic_physflat || num_possible_cpus() > 8 || jailhouse_paravirt(); |
148 | } |
149 | |
150 | static struct apic apic_physflat __ro_after_init = { |
151 | |
152 | .name = "physical flat" , |
153 | .probe = physflat_probe, |
154 | .acpi_madt_oem_check = physflat_acpi_madt_oem_check, |
155 | .apic_id_registered = default_apic_id_registered, |
156 | |
157 | .delivery_mode = APIC_DELIVERY_MODE_FIXED, |
158 | .dest_mode_logical = false, |
159 | |
160 | .disable_esr = 0, |
161 | |
162 | .cpu_present_to_apicid = default_cpu_present_to_apicid, |
163 | .phys_pkg_id = flat_phys_pkg_id, |
164 | |
165 | .max_apic_id = 0xFE, |
166 | .get_apic_id = flat_get_apic_id, |
167 | .set_apic_id = set_apic_id, |
168 | |
169 | .calc_dest_apicid = apic_default_calc_apicid, |
170 | |
171 | .send_IPI = default_send_IPI_single_phys, |
172 | .send_IPI_mask = default_send_IPI_mask_sequence_phys, |
173 | .send_IPI_mask_allbutself = default_send_IPI_mask_allbutself_phys, |
174 | .send_IPI_allbutself = default_send_IPI_allbutself, |
175 | .send_IPI_all = default_send_IPI_all, |
176 | .send_IPI_self = default_send_IPI_self, |
177 | .nmi_to_offline_cpu = true, |
178 | |
179 | .read = native_apic_mem_read, |
180 | .write = native_apic_mem_write, |
181 | .eoi = native_apic_mem_eoi, |
182 | .icr_read = native_apic_icr_read, |
183 | .icr_write = native_apic_icr_write, |
184 | .wait_icr_idle = apic_mem_wait_icr_idle, |
185 | .safe_wait_icr_idle = apic_mem_wait_icr_idle_timeout, |
186 | }; |
187 | |
188 | /* |
189 | * We need to check for physflat first, so this order is important. |
190 | */ |
191 | apic_drivers(apic_physflat, apic_flat); |
192 | |