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 get_apic_id(unsigned long x
)
133 id
= (((x
)>>24) & 0xFFu
);
137 static unsigned long set_apic_id(unsigned int id
)
141 x
= ((id
& 0xFFu
)<<24);
145 static unsigned int read_xapic_id(void)
149 id
= get_apic_id(apic_read(APIC_ID
));
153 static int flat_apic_id_registered(void)
155 return physid_isset(read_xapic_id(), phys_cpu_present_map
);
158 static unsigned int flat_cpu_mask_to_apicid(const struct cpumask
*cpumask
)
160 return cpumask_bits(cpumask
)[0] & APIC_ALL_CPUS
;
163 static unsigned int flat_cpu_mask_to_apicid_and(const struct cpumask
*cpumask
,
164 const struct cpumask
*andmask
)
166 unsigned long mask1
= cpumask_bits(cpumask
)[0] & APIC_ALL_CPUS
;
167 unsigned long mask2
= cpumask_bits(andmask
)[0] & APIC_ALL_CPUS
;
169 return mask1
& mask2
;
172 static unsigned int phys_pkg_id(int index_msb
)
174 return hard_smp_processor_id() >> index_msb
;
177 struct genapic apic_flat
= {
180 .acpi_madt_oem_check
= flat_acpi_madt_oem_check
,
181 .apic_id_registered
= flat_apic_id_registered
,
183 .irq_delivery_mode
= dest_LowestPrio
,
184 .irq_dest_mode
= (APIC_DEST_LOGICAL
!= 0),
186 .target_cpus
= flat_target_cpus
,
188 .apic_destination_logical
= 0,
189 .check_apicid_used
= NULL
,
190 .check_apicid_present
= NULL
,
193 .no_ioapic_check
= 0,
195 .vector_allocation_domain
= flat_vector_allocation_domain
,
196 .init_apic_ldr
= flat_init_apic_ldr
,
198 .ioapic_phys_id_map
= NULL
,
199 .setup_apic_routing
= NULL
,
200 .multi_timer_check
= NULL
,
201 .apicid_to_node
= NULL
,
202 .cpu_to_logical_apicid
= NULL
,
203 .cpu_present_to_apicid
= NULL
,
204 .apicid_to_cpu_present
= NULL
,
205 .setup_portio_remap
= NULL
,
206 .check_phys_apicid_present
= NULL
,
207 .enable_apic_mode
= NULL
,
208 .phys_pkg_id
= phys_pkg_id
,
209 .mps_oem_check
= NULL
,
211 .get_apic_id
= get_apic_id
,
212 .set_apic_id
= set_apic_id
,
213 .apic_id_mask
= 0xFFu
<< 24,
215 .cpu_mask_to_apicid
= flat_cpu_mask_to_apicid
,
216 .cpu_mask_to_apicid_and
= flat_cpu_mask_to_apicid_and
,
218 .send_IPI_mask
= flat_send_IPI_mask
,
219 .send_IPI_mask_allbutself
= flat_send_IPI_mask_allbutself
,
220 .send_IPI_allbutself
= flat_send_IPI_allbutself
,
221 .send_IPI_all
= flat_send_IPI_all
,
222 .send_IPI_self
= apic_send_IPI_self
,
225 .trampoline_phys_low
= 0,
226 .trampoline_phys_high
= 0,
227 .wait_for_init_deassert
= NULL
,
228 .smp_callin_clear_local_apic
= NULL
,
229 .store_NMI_vector
= NULL
,
230 .restore_NMI_vector
= NULL
,
231 .inquire_remote_apic
= NULL
,
235 * Physflat mode is used when there are more than 8 CPUs on a AMD system.
236 * We cannot use logical delivery in this case because the mask
237 * overflows, so use physical mode.
239 static int physflat_acpi_madt_oem_check(char *oem_id
, char *oem_table_id
)
243 * Quirk: some x86_64 machines can only use physical APIC mode
244 * regardless of how many processors are present (x86_64 ES7000
247 if (acpi_gbl_FADT
.header
.revision
> FADT2_REVISION_ID
&&
248 (acpi_gbl_FADT
.flags
& ACPI_FADT_APIC_PHYSICAL
)) {
249 printk(KERN_DEBUG
"system APIC only can use physical flat");
257 static const struct cpumask
*physflat_target_cpus(void)
259 return cpu_online_mask
;
262 static void physflat_vector_allocation_domain(int cpu
, struct cpumask
*retmask
)
264 cpumask_clear(retmask
);
265 cpumask_set_cpu(cpu
, retmask
);
268 static void physflat_send_IPI_mask(const struct cpumask
*cpumask
, int vector
)
270 send_IPI_mask_sequence(cpumask
, vector
);
273 static void physflat_send_IPI_mask_allbutself(const struct cpumask
*cpumask
,
276 send_IPI_mask_allbutself(cpumask
, vector
);
279 static void physflat_send_IPI_allbutself(int vector
)
281 send_IPI_mask_allbutself(cpu_online_mask
, vector
);
284 static void physflat_send_IPI_all(int vector
)
286 physflat_send_IPI_mask(cpu_online_mask
, vector
);
289 static unsigned int physflat_cpu_mask_to_apicid(const struct cpumask
*cpumask
)
294 * We're using fixed IRQ delivery, can only return one phys APIC ID.
295 * May as well be the first.
297 cpu
= cpumask_first(cpumask
);
298 if ((unsigned)cpu
< nr_cpu_ids
)
299 return per_cpu(x86_cpu_to_apicid
, cpu
);
305 physflat_cpu_mask_to_apicid_and(const struct cpumask
*cpumask
,
306 const struct cpumask
*andmask
)
311 * We're using fixed IRQ delivery, can only return one phys APIC ID.
312 * May as well be the first.
314 for_each_cpu_and(cpu
, cpumask
, andmask
)
315 if (cpumask_test_cpu(cpu
, cpu_online_mask
))
317 if (cpu
< nr_cpu_ids
)
318 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
= (APIC_DEST_PHYSICAL
!= 0),
332 .target_cpus
= physflat_target_cpus
,
334 .apic_destination_logical
= 0,
335 .check_apicid_used
= NULL
,
336 .check_apicid_present
= NULL
,
339 .no_ioapic_check
= 0,
341 .vector_allocation_domain
= physflat_vector_allocation_domain
,
342 /* not needed, but shouldn't hurt: */
343 .init_apic_ldr
= flat_init_apic_ldr
,
345 .ioapic_phys_id_map
= NULL
,
346 .setup_apic_routing
= NULL
,
347 .multi_timer_check
= NULL
,
348 .apicid_to_node
= NULL
,
349 .cpu_to_logical_apicid
= NULL
,
350 .cpu_present_to_apicid
= NULL
,
351 .apicid_to_cpu_present
= NULL
,
352 .setup_portio_remap
= NULL
,
353 .check_phys_apicid_present
= NULL
,
354 .enable_apic_mode
= NULL
,
355 .phys_pkg_id
= phys_pkg_id
,
356 .mps_oem_check
= NULL
,
358 .get_apic_id
= get_apic_id
,
359 .set_apic_id
= set_apic_id
,
360 .apic_id_mask
= 0xFFu
<<24,
362 .cpu_mask_to_apicid
= physflat_cpu_mask_to_apicid
,
363 .cpu_mask_to_apicid_and
= physflat_cpu_mask_to_apicid_and
,
365 .send_IPI_mask
= physflat_send_IPI_mask
,
366 .send_IPI_mask_allbutself
= physflat_send_IPI_mask_allbutself
,
367 .send_IPI_allbutself
= physflat_send_IPI_allbutself
,
368 .send_IPI_all
= physflat_send_IPI_all
,
369 .send_IPI_self
= apic_send_IPI_self
,
372 .trampoline_phys_low
= 0,
373 .trampoline_phys_high
= 0,
374 .wait_for_init_deassert
= NULL
,
375 .smp_callin_clear_local_apic
= NULL
,
376 .store_NMI_vector
= NULL
,
377 .restore_NMI_vector
= NULL
,
378 .inquire_remote_apic
= NULL
,