2 * Copyright 2004 James Cleverdon, IBM.
3 * Subject to the GNU Public License, v.2
5 * Flat APIC subarch code.
7 * Hacked for x86-64 by James Cleverdon from i386 architecture code by
8 * Martin Bligh, Andi Kleen, James Bottomley, John Stultz, and
11 #include <linux/errno.h>
12 #include <linux/threads.h>
13 #include <linux/cpumask.h>
14 #include <linux/string.h>
15 #include <linux/kernel.h>
16 #include <linux/ctype.h>
17 #include <linux/init.h>
18 #include <linux/hardirq.h>
21 #include <asm/genapic.h>
22 #include <mach_apicdef.h>
25 #include <acpi/acpi_bus.h>
28 static int flat_acpi_madt_oem_check(char *oem_id
, char *oem_table_id
)
33 static const struct cpumask
*flat_target_cpus(void)
35 return cpu_online_mask
;
38 static void flat_vector_allocation_domain(int cpu
, struct cpumask
*retmask
)
40 /* Careful. Some cpus do not strictly honor the set of cpus
41 * specified in the interrupt destination when using lowest
42 * priority interrupt delivery mode.
44 * In particular there was a hyperthreading cpu observed to
45 * deliver interrupts to the wrong hyperthread when only one
46 * hyperthread was specified in the interrupt desitination.
48 cpumask_clear(retmask
);
49 cpumask_bits(retmask
)[0] = APIC_ALL_CPUS
;
53 * Set up the logical destination ID.
55 * Intel recommends to set DFR, LDR and TPR before enabling
56 * an APIC. See e.g. "AP-388 82489DX User's Manual" (Intel
57 * document number 292116). So here it goes...
59 static void flat_init_apic_ldr(void)
62 unsigned long num
, id
;
64 num
= smp_processor_id();
66 apic_write(APIC_DFR
, APIC_DFR_FLAT
);
67 val
= apic_read(APIC_LDR
) & ~APIC_LDR_MASK
;
68 val
|= SET_APIC_LOGICAL_ID(id
);
69 apic_write(APIC_LDR
, val
);
72 static inline void _flat_send_IPI_mask(unsigned long mask
, int vector
)
76 local_irq_save(flags
);
77 __send_IPI_dest_field(mask
, vector
, apic
->dest_logical
);
78 local_irq_restore(flags
);
81 static void flat_send_IPI_mask(const struct cpumask
*cpumask
, int vector
)
83 unsigned long mask
= cpumask_bits(cpumask
)[0];
85 _flat_send_IPI_mask(mask
, vector
);
88 static void flat_send_IPI_mask_allbutself(const struct cpumask
*cpumask
,
91 unsigned long mask
= cpumask_bits(cpumask
)[0];
92 int cpu
= smp_processor_id();
94 if (cpu
< BITS_PER_LONG
)
95 clear_bit(cpu
, &mask
);
96 _flat_send_IPI_mask(mask
, vector
);
99 static void flat_send_IPI_allbutself(int vector
)
101 int cpu
= smp_processor_id();
102 #ifdef CONFIG_HOTPLUG_CPU
107 if (hotplug
|| vector
== NMI_VECTOR
) {
108 if (!cpumask_equal(cpu_online_mask
, cpumask_of(cpu
))) {
109 unsigned long mask
= cpumask_bits(cpu_online_mask
)[0];
111 if (cpu
< BITS_PER_LONG
)
112 clear_bit(cpu
, &mask
);
114 _flat_send_IPI_mask(mask
, vector
);
116 } else if (num_online_cpus() > 1) {
117 __send_IPI_shortcut(APIC_DEST_ALLBUT
, vector
, apic
->dest_logical
);
121 static void flat_send_IPI_all(int vector
)
123 if (vector
== NMI_VECTOR
)
124 flat_send_IPI_mask(cpu_online_mask
, vector
);
126 __send_IPI_shortcut(APIC_DEST_ALLINC
, vector
, apic
->dest_logical
);
129 static unsigned int flat_get_apic_id(unsigned long x
)
133 id
= (((x
)>>24) & 0xFFu
);
138 static unsigned long set_apic_id(unsigned int id
)
142 x
= ((id
& 0xFFu
)<<24);
146 static unsigned int read_xapic_id(void)
150 id
= flat_get_apic_id(apic_read(APIC_ID
));
154 static int flat_apic_id_registered(void)
156 return physid_isset(read_xapic_id(), phys_cpu_present_map
);
159 static unsigned int flat_cpu_mask_to_apicid(const struct cpumask
*cpumask
)
161 return cpumask_bits(cpumask
)[0] & APIC_ALL_CPUS
;
164 static unsigned int flat_cpu_mask_to_apicid_and(const struct cpumask
*cpumask
,
165 const struct cpumask
*andmask
)
167 unsigned long mask1
= cpumask_bits(cpumask
)[0] & APIC_ALL_CPUS
;
168 unsigned long mask2
= cpumask_bits(andmask
)[0] & APIC_ALL_CPUS
;
170 return mask1
& mask2
;
173 static int flat_phys_pkg_id(int initial_apic_id
, int index_msb
)
175 return hard_smp_processor_id() >> index_msb
;
178 struct genapic apic_flat
= {
181 .acpi_madt_oem_check
= flat_acpi_madt_oem_check
,
182 .apic_id_registered
= flat_apic_id_registered
,
184 .irq_delivery_mode
= dest_LowestPrio
,
185 .irq_dest_mode
= 1, /* logical */
187 .target_cpus
= flat_target_cpus
,
189 .dest_logical
= APIC_DEST_LOGICAL
,
190 .check_apicid_used
= NULL
,
191 .check_apicid_present
= NULL
,
193 .vector_allocation_domain
= flat_vector_allocation_domain
,
194 .init_apic_ldr
= flat_init_apic_ldr
,
196 .ioapic_phys_id_map
= NULL
,
197 .setup_apic_routing
= NULL
,
198 .multi_timer_check
= NULL
,
199 .apicid_to_node
= NULL
,
200 .cpu_to_logical_apicid
= NULL
,
201 .cpu_present_to_apicid
= default_cpu_present_to_apicid
,
202 .apicid_to_cpu_present
= NULL
,
203 .setup_portio_remap
= NULL
,
204 .check_phys_apicid_present
= default_check_phys_apicid_present
,
205 .enable_apic_mode
= NULL
,
206 .phys_pkg_id
= flat_phys_pkg_id
,
207 .mps_oem_check
= NULL
,
209 .get_apic_id
= flat_get_apic_id
,
210 .set_apic_id
= set_apic_id
,
211 .apic_id_mask
= 0xFFu
<< 24,
213 .cpu_mask_to_apicid
= flat_cpu_mask_to_apicid
,
214 .cpu_mask_to_apicid_and
= flat_cpu_mask_to_apicid_and
,
216 .send_IPI_mask
= flat_send_IPI_mask
,
217 .send_IPI_mask_allbutself
= flat_send_IPI_mask_allbutself
,
218 .send_IPI_allbutself
= flat_send_IPI_allbutself
,
219 .send_IPI_all
= flat_send_IPI_all
,
220 .send_IPI_self
= apic_send_IPI_self
,
223 .trampoline_phys_low
= 0,
224 .trampoline_phys_high
= 0,
225 .wait_for_init_deassert
= NULL
,
226 .smp_callin_clear_local_apic
= NULL
,
227 .store_NMI_vector
= NULL
,
228 .restore_NMI_vector
= NULL
,
229 .inquire_remote_apic
= NULL
,
233 * Physflat mode is used when there are more than 8 CPUs on a AMD system.
234 * We cannot use logical delivery in this case because the mask
235 * overflows, so use physical mode.
237 static int physflat_acpi_madt_oem_check(char *oem_id
, char *oem_table_id
)
241 * Quirk: some x86_64 machines can only use physical APIC mode
242 * regardless of how many processors are present (x86_64 ES7000
245 if (acpi_gbl_FADT
.header
.revision
> FADT2_REVISION_ID
&&
246 (acpi_gbl_FADT
.flags
& ACPI_FADT_APIC_PHYSICAL
)) {
247 printk(KERN_DEBUG
"system APIC only can use physical flat");
255 static const struct cpumask
*physflat_target_cpus(void)
257 return cpu_online_mask
;
260 static void physflat_vector_allocation_domain(int cpu
, struct cpumask
*retmask
)
262 cpumask_clear(retmask
);
263 cpumask_set_cpu(cpu
, retmask
);
266 static void physflat_send_IPI_mask(const struct cpumask
*cpumask
, int vector
)
268 send_IPI_mask_sequence(cpumask
, vector
);
271 static void physflat_send_IPI_mask_allbutself(const struct cpumask
*cpumask
,
274 send_IPI_mask_allbutself(cpumask
, vector
);
277 static void physflat_send_IPI_allbutself(int vector
)
279 send_IPI_mask_allbutself(cpu_online_mask
, vector
);
282 static void physflat_send_IPI_all(int vector
)
284 physflat_send_IPI_mask(cpu_online_mask
, vector
);
287 static unsigned int physflat_cpu_mask_to_apicid(const struct cpumask
*cpumask
)
292 * We're using fixed IRQ delivery, can only return one phys APIC ID.
293 * May as well be the first.
295 cpu
= cpumask_first(cpumask
);
296 if ((unsigned)cpu
< nr_cpu_ids
)
297 return per_cpu(x86_cpu_to_apicid
, cpu
);
303 physflat_cpu_mask_to_apicid_and(const struct cpumask
*cpumask
,
304 const struct cpumask
*andmask
)
309 * We're using fixed IRQ delivery, can only return one phys APIC ID.
310 * May as well be the first.
312 for_each_cpu_and(cpu
, cpumask
, andmask
) {
313 if (cpumask_test_cpu(cpu
, cpu_online_mask
))
316 if (cpu
< nr_cpu_ids
)
317 return per_cpu(x86_cpu_to_apicid
, cpu
);
322 struct genapic apic_physflat
= {
324 .name
= "physical flat",
326 .acpi_madt_oem_check
= physflat_acpi_madt_oem_check
,
327 .apic_id_registered
= flat_apic_id_registered
,
329 .irq_delivery_mode
= dest_Fixed
,
330 .irq_dest_mode
= 0, /* physical */
332 .target_cpus
= physflat_target_cpus
,
335 .check_apicid_used
= NULL
,
336 .check_apicid_present
= NULL
,
338 .vector_allocation_domain
= physflat_vector_allocation_domain
,
339 /* not needed, but shouldn't hurt: */
340 .init_apic_ldr
= flat_init_apic_ldr
,
342 .ioapic_phys_id_map
= NULL
,
343 .setup_apic_routing
= NULL
,
344 .multi_timer_check
= NULL
,
345 .apicid_to_node
= NULL
,
346 .cpu_to_logical_apicid
= NULL
,
347 .cpu_present_to_apicid
= default_cpu_present_to_apicid
,
348 .apicid_to_cpu_present
= NULL
,
349 .setup_portio_remap
= NULL
,
350 .check_phys_apicid_present
= default_check_phys_apicid_present
,
351 .enable_apic_mode
= NULL
,
352 .phys_pkg_id
= flat_phys_pkg_id
,
353 .mps_oem_check
= NULL
,
355 .get_apic_id
= flat_get_apic_id
,
356 .set_apic_id
= set_apic_id
,
357 .apic_id_mask
= 0xFFu
<< 24,
359 .cpu_mask_to_apicid
= physflat_cpu_mask_to_apicid
,
360 .cpu_mask_to_apicid_and
= physflat_cpu_mask_to_apicid_and
,
362 .send_IPI_mask
= physflat_send_IPI_mask
,
363 .send_IPI_mask_allbutself
= physflat_send_IPI_mask_allbutself
,
364 .send_IPI_allbutself
= physflat_send_IPI_allbutself
,
365 .send_IPI_all
= physflat_send_IPI_all
,
366 .send_IPI_self
= apic_send_IPI_self
,
369 .trampoline_phys_low
= 0,
370 .trampoline_phys_high
= 0,
371 .wait_for_init_deassert
= NULL
,
372 .smp_callin_clear_local_apic
= NULL
,
373 .store_NMI_vector
= NULL
,
374 .restore_NMI_vector
= NULL
,
375 .inquire_remote_apic
= NULL
,