Merge branch 'next' into for-linus
[linux-2.6] / arch / x86 / kernel / apic / apic_flat_64.c
1 /*
2  * Copyright 2004 James Cleverdon, IBM.
3  * Subject to the GNU Public License, v.2
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/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>
19 #include <asm/smp.h>
20 #include <asm/apic.h>
21 #include <asm/ipi.h>
22
23 #ifdef CONFIG_ACPI
24 #include <acpi/acpi_bus.h>
25 #endif
26
27 static int flat_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
28 {
29         return 1;
30 }
31
32 static const struct cpumask *flat_target_cpus(void)
33 {
34         return cpu_online_mask;
35 }
36
37 static void flat_vector_allocation_domain(int cpu, struct cpumask *retmask)
38 {
39         /* Careful. Some cpus do not strictly honor the set of cpus
40          * specified in the interrupt destination when using lowest
41          * priority interrupt delivery mode.
42          *
43          * In particular there was a hyperthreading cpu observed to
44          * deliver interrupts to the wrong hyperthread when only one
45          * hyperthread was specified in the interrupt desitination.
46          */
47         cpumask_clear(retmask);
48         cpumask_bits(retmask)[0] = APIC_ALL_CPUS;
49 }
50
51 /*
52  * Set up the logical destination ID.
53  *
54  * Intel recommends to set DFR, LDR and TPR before enabling
55  * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
56  * document number 292116).  So here it goes...
57  */
58 static void flat_init_apic_ldr(void)
59 {
60         unsigned long val;
61         unsigned long num, id;
62
63         num = smp_processor_id();
64         id = 1UL << num;
65         apic_write(APIC_DFR, APIC_DFR_FLAT);
66         val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
67         val |= SET_APIC_LOGICAL_ID(id);
68         apic_write(APIC_LDR, val);
69 }
70
71 static inline void _flat_send_IPI_mask(unsigned long mask, int vector)
72 {
73         unsigned long flags;
74
75         local_irq_save(flags);
76         __default_send_IPI_dest_field(mask, vector, apic->dest_logical);
77         local_irq_restore(flags);
78 }
79
80 static void flat_send_IPI_mask(const struct cpumask *cpumask, int vector)
81 {
82         unsigned long mask = cpumask_bits(cpumask)[0];
83
84         _flat_send_IPI_mask(mask, vector);
85 }
86
87 static void
88  flat_send_IPI_mask_allbutself(const struct cpumask *cpumask, int vector)
89 {
90         unsigned long mask = cpumask_bits(cpumask)[0];
91         int cpu = smp_processor_id();
92
93         if (cpu < BITS_PER_LONG)
94                 clear_bit(cpu, &mask);
95
96         _flat_send_IPI_mask(mask, vector);
97 }
98
99 static void flat_send_IPI_allbutself(int vector)
100 {
101         int cpu = smp_processor_id();
102 #ifdef  CONFIG_HOTPLUG_CPU
103         int hotplug = 1;
104 #else
105         int hotplug = 0;
106 #endif
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];
110
111                         if (cpu < BITS_PER_LONG)
112                                 clear_bit(cpu, &mask);
113
114                         _flat_send_IPI_mask(mask, vector);
115                 }
116         } else if (num_online_cpus() > 1) {
117                 __default_send_IPI_shortcut(APIC_DEST_ALLBUT,
118                                             vector, apic->dest_logical);
119         }
120 }
121
122 static void flat_send_IPI_all(int vector)
123 {
124         if (vector == NMI_VECTOR) {
125                 flat_send_IPI_mask(cpu_online_mask, vector);
126         } else {
127                 __default_send_IPI_shortcut(APIC_DEST_ALLINC,
128                                             vector, apic->dest_logical);
129         }
130 }
131
132 static unsigned int flat_get_apic_id(unsigned long x)
133 {
134         unsigned int id;
135
136         id = (((x)>>24) & 0xFFu);
137
138         return id;
139 }
140
141 static unsigned long set_apic_id(unsigned int id)
142 {
143         unsigned long x;
144
145         x = ((id & 0xFFu)<<24);
146         return x;
147 }
148
149 static unsigned int read_xapic_id(void)
150 {
151         unsigned int id;
152
153         id = flat_get_apic_id(apic_read(APIC_ID));
154         return id;
155 }
156
157 static int flat_apic_id_registered(void)
158 {
159         return physid_isset(read_xapic_id(), phys_cpu_present_map);
160 }
161
162 static int flat_phys_pkg_id(int initial_apic_id, int index_msb)
163 {
164         return hard_smp_processor_id() >> index_msb;
165 }
166
167 struct apic apic_flat =  {
168         .name                           = "flat",
169         .probe                          = NULL,
170         .acpi_madt_oem_check            = flat_acpi_madt_oem_check,
171         .apic_id_registered             = flat_apic_id_registered,
172
173         .irq_delivery_mode              = dest_LowestPrio,
174         .irq_dest_mode                  = 1, /* logical */
175
176         .target_cpus                    = flat_target_cpus,
177         .disable_esr                    = 0,
178         .dest_logical                   = APIC_DEST_LOGICAL,
179         .check_apicid_used              = NULL,
180         .check_apicid_present           = NULL,
181
182         .vector_allocation_domain       = flat_vector_allocation_domain,
183         .init_apic_ldr                  = flat_init_apic_ldr,
184
185         .ioapic_phys_id_map             = NULL,
186         .setup_apic_routing             = NULL,
187         .multi_timer_check              = NULL,
188         .apicid_to_node                 = NULL,
189         .cpu_to_logical_apicid          = NULL,
190         .cpu_present_to_apicid          = default_cpu_present_to_apicid,
191         .apicid_to_cpu_present          = NULL,
192         .setup_portio_remap             = NULL,
193         .check_phys_apicid_present      = default_check_phys_apicid_present,
194         .enable_apic_mode               = NULL,
195         .phys_pkg_id                    = flat_phys_pkg_id,
196         .mps_oem_check                  = NULL,
197
198         .get_apic_id                    = flat_get_apic_id,
199         .set_apic_id                    = set_apic_id,
200         .apic_id_mask                   = 0xFFu << 24,
201
202         .cpu_mask_to_apicid             = default_cpu_mask_to_apicid,
203         .cpu_mask_to_apicid_and         = default_cpu_mask_to_apicid_and,
204
205         .send_IPI_mask                  = flat_send_IPI_mask,
206         .send_IPI_mask_allbutself       = flat_send_IPI_mask_allbutself,
207         .send_IPI_allbutself            = flat_send_IPI_allbutself,
208         .send_IPI_all                   = flat_send_IPI_all,
209         .send_IPI_self                  = apic_send_IPI_self,
210
211         .trampoline_phys_low            = DEFAULT_TRAMPOLINE_PHYS_LOW,
212         .trampoline_phys_high           = DEFAULT_TRAMPOLINE_PHYS_HIGH,
213         .wait_for_init_deassert         = NULL,
214         .smp_callin_clear_local_apic    = NULL,
215         .inquire_remote_apic            = NULL,
216
217         .read                           = native_apic_mem_read,
218         .write                          = native_apic_mem_write,
219         .icr_read                       = native_apic_icr_read,
220         .icr_write                      = native_apic_icr_write,
221         .wait_icr_idle                  = native_apic_wait_icr_idle,
222         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
223 };
224
225 /*
226  * Physflat mode is used when there are more than 8 CPUs on a AMD system.
227  * We cannot use logical delivery in this case because the mask
228  * overflows, so use physical mode.
229  */
230 static int physflat_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
231 {
232 #ifdef CONFIG_ACPI
233         /*
234          * Quirk: some x86_64 machines can only use physical APIC mode
235          * regardless of how many processors are present (x86_64 ES7000
236          * is an example).
237          */
238         if (acpi_gbl_FADT.header.revision > FADT2_REVISION_ID &&
239                 (acpi_gbl_FADT.flags & ACPI_FADT_APIC_PHYSICAL)) {
240                 printk(KERN_DEBUG "system APIC only can use physical flat");
241                 return 1;
242         }
243 #endif
244
245         return 0;
246 }
247
248 static const struct cpumask *physflat_target_cpus(void)
249 {
250         return cpu_online_mask;
251 }
252
253 static void physflat_vector_allocation_domain(int cpu, struct cpumask *retmask)
254 {
255         cpumask_clear(retmask);
256         cpumask_set_cpu(cpu, retmask);
257 }
258
259 static void physflat_send_IPI_mask(const struct cpumask *cpumask, int vector)
260 {
261         default_send_IPI_mask_sequence_phys(cpumask, vector);
262 }
263
264 static void physflat_send_IPI_mask_allbutself(const struct cpumask *cpumask,
265                                               int vector)
266 {
267         default_send_IPI_mask_allbutself_phys(cpumask, vector);
268 }
269
270 static void physflat_send_IPI_allbutself(int vector)
271 {
272         default_send_IPI_mask_allbutself_phys(cpu_online_mask, vector);
273 }
274
275 static void physflat_send_IPI_all(int vector)
276 {
277         physflat_send_IPI_mask(cpu_online_mask, vector);
278 }
279
280 static unsigned int physflat_cpu_mask_to_apicid(const struct cpumask *cpumask)
281 {
282         int cpu;
283
284         /*
285          * We're using fixed IRQ delivery, can only return one phys APIC ID.
286          * May as well be the first.
287          */
288         cpu = cpumask_first(cpumask);
289         if ((unsigned)cpu < nr_cpu_ids)
290                 return per_cpu(x86_cpu_to_apicid, cpu);
291         else
292                 return BAD_APICID;
293 }
294
295 static unsigned int
296 physflat_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
297                                 const struct cpumask *andmask)
298 {
299         int cpu;
300
301         /*
302          * We're using fixed IRQ delivery, can only return one phys APIC ID.
303          * May as well be the first.
304          */
305         for_each_cpu_and(cpu, cpumask, andmask) {
306                 if (cpumask_test_cpu(cpu, cpu_online_mask))
307                         break;
308         }
309         if (cpu < nr_cpu_ids)
310                 return per_cpu(x86_cpu_to_apicid, cpu);
311
312         return BAD_APICID;
313 }
314
315 struct apic apic_physflat =  {
316
317         .name                           = "physical flat",
318         .probe                          = NULL,
319         .acpi_madt_oem_check            = physflat_acpi_madt_oem_check,
320         .apic_id_registered             = flat_apic_id_registered,
321
322         .irq_delivery_mode              = dest_Fixed,
323         .irq_dest_mode                  = 0, /* physical */
324
325         .target_cpus                    = physflat_target_cpus,
326         .disable_esr                    = 0,
327         .dest_logical                   = 0,
328         .check_apicid_used              = NULL,
329         .check_apicid_present           = NULL,
330
331         .vector_allocation_domain       = physflat_vector_allocation_domain,
332         /* not needed, but shouldn't hurt: */
333         .init_apic_ldr                  = flat_init_apic_ldr,
334
335         .ioapic_phys_id_map             = NULL,
336         .setup_apic_routing             = NULL,
337         .multi_timer_check              = NULL,
338         .apicid_to_node                 = NULL,
339         .cpu_to_logical_apicid          = NULL,
340         .cpu_present_to_apicid          = default_cpu_present_to_apicid,
341         .apicid_to_cpu_present          = NULL,
342         .setup_portio_remap             = NULL,
343         .check_phys_apicid_present      = default_check_phys_apicid_present,
344         .enable_apic_mode               = NULL,
345         .phys_pkg_id                    = flat_phys_pkg_id,
346         .mps_oem_check                  = NULL,
347
348         .get_apic_id                    = flat_get_apic_id,
349         .set_apic_id                    = set_apic_id,
350         .apic_id_mask                   = 0xFFu << 24,
351
352         .cpu_mask_to_apicid             = physflat_cpu_mask_to_apicid,
353         .cpu_mask_to_apicid_and         = physflat_cpu_mask_to_apicid_and,
354
355         .send_IPI_mask                  = physflat_send_IPI_mask,
356         .send_IPI_mask_allbutself       = physflat_send_IPI_mask_allbutself,
357         .send_IPI_allbutself            = physflat_send_IPI_allbutself,
358         .send_IPI_all                   = physflat_send_IPI_all,
359         .send_IPI_self                  = apic_send_IPI_self,
360
361         .trampoline_phys_low            = DEFAULT_TRAMPOLINE_PHYS_LOW,
362         .trampoline_phys_high           = DEFAULT_TRAMPOLINE_PHYS_HIGH,
363         .wait_for_init_deassert         = NULL,
364         .smp_callin_clear_local_apic    = NULL,
365         .inquire_remote_apic            = NULL,
366
367         .read                           = native_apic_mem_read,
368         .write                          = native_apic_mem_write,
369         .icr_read                       = native_apic_icr_read,
370         .icr_write                      = native_apic_icr_write,
371         .wait_icr_idle                  = native_apic_wait_icr_idle,
372         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
373 };