aboutsummaryrefslogtreecommitdiffstats
path: root/arch/x86/kernel/apic
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2009-02-17 12:09:24 -0500
committerIngo Molnar <mingo@elte.hu>2009-02-17 12:17:36 -0500
commitf62bae5009c1ba596cd475cafbc83e0570a36e26 (patch)
tree0c5a3000c566f42a7cc25d6c03d69d20b9bd0166 /arch/x86/kernel/apic
parentbe163a159b223e94b3180afdd47a8d468eb9a492 (diff)
x86, apic: move APIC drivers to arch/x86/kernel/apic/*
arch/x86/kernel/ is getting a bit crowded, and the APIC drivers are scattered into various different files. Move them to arch/x86/kernel/apic/*, and also remove the 'gen' prefix from those which had it. Also move APIC related functionality: the IO-APIC driver, the NMI and the IPI code. Signed-off-by: Ingo Molnar <mingo@elte.hu>
Diffstat (limited to 'arch/x86/kernel/apic')
-rw-r--r--arch/x86/kernel/apic/Makefile15
-rw-r--r--arch/x86/kernel/apic/apic.c2212
-rw-r--r--arch/x86/kernel/apic/apic_64.c89
-rw-r--r--arch/x86/kernel/apic/apic_flat_64.c389
-rw-r--r--arch/x86/kernel/apic/io_apic.c4160
-rw-r--r--arch/x86/kernel/apic/ipi.c164
-rw-r--r--arch/x86/kernel/apic/nmi.c564
-rw-r--r--arch/x86/kernel/apic/x2apic_cluster.c243
-rw-r--r--arch/x86/kernel/apic/x2apic_phys.c229
-rw-r--r--arch/x86/kernel/apic/x2apic_uv_x.c643
10 files changed, 8708 insertions, 0 deletions
diff --git a/arch/x86/kernel/apic/Makefile b/arch/x86/kernel/apic/Makefile
new file mode 100644
index 000000000000..da20b70c4000
--- /dev/null
+++ b/arch/x86/kernel/apic/Makefile
@@ -0,0 +1,15 @@
1#
2# Makefile for local APIC drivers and for the IO-APIC code
3#
4
5obj-y := apic.o ipi.o nmi.o
6obj-$(CONFIG_X86_IO_APIC) += io_apic.o
7obj-$(CONFIG_SMP) += ipi.o
8
9ifeq ($(CONFIG_X86_64),y)
10obj-y += apic_64.o apic_flat_64.o
11obj-$(CONFIG_X86_X2APIC) += x2apic_cluster.o
12obj-$(CONFIG_X86_X2APIC) += x2apic_phys.o
13obj-$(CONFIG_X86_UV) += x2apic_uv_x.o
14endif
15
diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c
new file mode 100644
index 000000000000..c12823eb55b5
--- /dev/null
+++ b/arch/x86/kernel/apic/apic.c
@@ -0,0 +1,2212 @@
1/*
2 * Local APIC handling, local APIC timers
3 *
4 * (c) 1999, 2000, 2009 Ingo Molnar <mingo@redhat.com>
5 *
6 * Fixes
7 * Maciej W. Rozycki : Bits for genuine 82489DX APICs;
8 * thanks to Eric Gilmore
9 * and Rolf G. Tews
10 * for testing these extensively.
11 * Maciej W. Rozycki : Various updates and fixes.
12 * Mikael Pettersson : Power Management for UP-APIC.
13 * Pavel Machek and
14 * Mikael Pettersson : PM converted to driver model.
15 */
16
17#include <linux/kernel_stat.h>
18#include <linux/mc146818rtc.h>
19#include <linux/acpi_pmtmr.h>
20#include <linux/clockchips.h>
21#include <linux/interrupt.h>
22#include <linux/bootmem.h>
23#include <linux/ftrace.h>
24#include <linux/ioport.h>
25#include <linux/module.h>
26#include <linux/sysdev.h>
27#include <linux/delay.h>
28#include <linux/timex.h>
29#include <linux/dmar.h>
30#include <linux/init.h>
31#include <linux/cpu.h>
32#include <linux/dmi.h>
33#include <linux/nmi.h>
34#include <linux/smp.h>
35#include <linux/mm.h>
36
37#include <asm/arch_hooks.h>
38#include <asm/pgalloc.h>
39#include <asm/atomic.h>
40#include <asm/mpspec.h>
41#include <asm/i8253.h>
42#include <asm/i8259.h>
43#include <asm/proto.h>
44#include <asm/apic.h>
45#include <asm/desc.h>
46#include <asm/hpet.h>
47#include <asm/idle.h>
48#include <asm/mtrr.h>
49#include <asm/smp.h>
50
51unsigned int num_processors;
52
53unsigned disabled_cpus __cpuinitdata;
54
55/* Processor that is doing the boot up */
56unsigned int boot_cpu_physical_apicid = -1U;
57
58/*
59 * The highest APIC ID seen during enumeration.
60 *
61 * This determines the messaging protocol we can use: if all APIC IDs
62 * are in the 0 ... 7 range, then we can use logical addressing which
63 * has some performance advantages (better broadcasting).
64 *
65 * If there's an APIC ID above 8, we use physical addressing.
66 */
67unsigned int max_physical_apicid;
68
69/*
70 * Bitmask of physically existing CPUs:
71 */
72physid_mask_t phys_cpu_present_map;
73
74/*
75 * Map cpu index to physical APIC ID
76 */
77DEFINE_EARLY_PER_CPU(u16, x86_cpu_to_apicid, BAD_APICID);
78DEFINE_EARLY_PER_CPU(u16, x86_bios_cpu_apicid, BAD_APICID);
79EXPORT_EARLY_PER_CPU_SYMBOL(x86_cpu_to_apicid);
80EXPORT_EARLY_PER_CPU_SYMBOL(x86_bios_cpu_apicid);
81
82#ifdef CONFIG_X86_32
83/*
84 * Knob to control our willingness to enable the local APIC.
85 *
86 * +1=force-enable
87 */
88static int force_enable_local_apic;
89/*
90 * APIC command line parameters
91 */
92static int __init parse_lapic(char *arg)
93{
94 force_enable_local_apic = 1;
95 return 0;
96}
97early_param("lapic", parse_lapic);
98/* Local APIC was disabled by the BIOS and enabled by the kernel */
99static int enabled_via_apicbase;
100
101#endif
102
103#ifdef CONFIG_X86_64
104static int apic_calibrate_pmtmr __initdata;
105static __init int setup_apicpmtimer(char *s)
106{
107 apic_calibrate_pmtmr = 1;
108 notsc_setup(NULL);
109 return 0;
110}
111__setup("apicpmtimer", setup_apicpmtimer);
112#endif
113
114#ifdef CONFIG_X86_X2APIC
115int x2apic;
116/* x2apic enabled before OS handover */
117static int x2apic_preenabled;
118static int disable_x2apic;
119static __init int setup_nox2apic(char *str)
120{
121 disable_x2apic = 1;
122 setup_clear_cpu_cap(X86_FEATURE_X2APIC);
123 return 0;
124}
125early_param("nox2apic", setup_nox2apic);
126#endif
127
128unsigned long mp_lapic_addr;
129int disable_apic;
130/* Disable local APIC timer from the kernel commandline or via dmi quirk */
131static int disable_apic_timer __cpuinitdata;
132/* Local APIC timer works in C2 */
133int local_apic_timer_c2_ok;
134EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
135
136int first_system_vector = 0xfe;
137
138/*
139 * Debug level, exported for io_apic.c
140 */
141unsigned int apic_verbosity;
142
143int pic_mode;
144
145/* Have we found an MP table */
146int smp_found_config;
147
148static struct resource lapic_resource = {
149 .name = "Local APIC",
150 .flags = IORESOURCE_MEM | IORESOURCE_BUSY,
151};
152
153static unsigned int calibration_result;
154
155static int lapic_next_event(unsigned long delta,
156 struct clock_event_device *evt);
157static void lapic_timer_setup(enum clock_event_mode mode,
158 struct clock_event_device *evt);
159static void lapic_timer_broadcast(const struct cpumask *mask);
160static void apic_pm_activate(void);
161
162/*
163 * The local apic timer can be used for any function which is CPU local.
164 */
165static struct clock_event_device lapic_clockevent = {
166 .name = "lapic",
167 .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT
168 | CLOCK_EVT_FEAT_C3STOP | CLOCK_EVT_FEAT_DUMMY,
169 .shift = 32,
170 .set_mode = lapic_timer_setup,
171 .set_next_event = lapic_next_event,
172 .broadcast = lapic_timer_broadcast,
173 .rating = 100,
174 .irq = -1,
175};
176static DEFINE_PER_CPU(struct clock_event_device, lapic_events);
177
178static unsigned long apic_phys;
179
180/*
181 * Get the LAPIC version
182 */
183static inline int lapic_get_version(void)
184{
185 return GET_APIC_VERSION(apic_read(APIC_LVR));
186}
187
188/*
189 * Check, if the APIC is integrated or a separate chip
190 */
191static inline int lapic_is_integrated(void)
192{
193#ifdef CONFIG_X86_64
194 return 1;
195#else
196 return APIC_INTEGRATED(lapic_get_version());
197#endif
198}
199
200/*
201 * Check, whether this is a modern or a first generation APIC
202 */
203static int modern_apic(void)
204{
205 /* AMD systems use old APIC versions, so check the CPU */
206 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
207 boot_cpu_data.x86 >= 0xf)
208 return 1;
209 return lapic_get_version() >= 0x14;
210}
211
212void native_apic_wait_icr_idle(void)
213{
214 while (apic_read(APIC_ICR) & APIC_ICR_BUSY)
215 cpu_relax();
216}
217
218u32 native_safe_apic_wait_icr_idle(void)
219{
220 u32 send_status;
221 int timeout;
222
223 timeout = 0;
224 do {
225 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
226 if (!send_status)
227 break;
228 udelay(100);
229 } while (timeout++ < 1000);
230
231 return send_status;
232}
233
234void native_apic_icr_write(u32 low, u32 id)
235{
236 apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(id));
237 apic_write(APIC_ICR, low);
238}
239
240u64 native_apic_icr_read(void)
241{
242 u32 icr1, icr2;
243
244 icr2 = apic_read(APIC_ICR2);
245 icr1 = apic_read(APIC_ICR);
246
247 return icr1 | ((u64)icr2 << 32);
248}
249
250/**
251 * enable_NMI_through_LVT0 - enable NMI through local vector table 0
252 */
253void __cpuinit enable_NMI_through_LVT0(void)
254{
255 unsigned int v;
256
257 /* unmask and set to NMI */
258 v = APIC_DM_NMI;
259
260 /* Level triggered for 82489DX (32bit mode) */
261 if (!lapic_is_integrated())
262 v |= APIC_LVT_LEVEL_TRIGGER;
263
264 apic_write(APIC_LVT0, v);
265}
266
267#ifdef CONFIG_X86_32
268/**
269 * get_physical_broadcast - Get number of physical broadcast IDs
270 */
271int get_physical_broadcast(void)
272{
273 return modern_apic() ? 0xff : 0xf;
274}
275#endif
276
277/**
278 * lapic_get_maxlvt - get the maximum number of local vector table entries
279 */
280int lapic_get_maxlvt(void)
281{
282 unsigned int v;
283
284 v = apic_read(APIC_LVR);
285 /*
286 * - we always have APIC integrated on 64bit mode
287 * - 82489DXs do not report # of LVT entries
288 */
289 return APIC_INTEGRATED(GET_APIC_VERSION(v)) ? GET_APIC_MAXLVT(v) : 2;
290}
291
292/*
293 * Local APIC timer
294 */
295
296/* Clock divisor */
297#define APIC_DIVISOR 16
298
299/*
300 * This function sets up the local APIC timer, with a timeout of
301 * 'clocks' APIC bus clock. During calibration we actually call
302 * this function twice on the boot CPU, once with a bogus timeout
303 * value, second time for real. The other (noncalibrating) CPUs
304 * call this function only once, with the real, calibrated value.
305 *
306 * We do reads before writes even if unnecessary, to get around the
307 * P5 APIC double write bug.
308 */
309static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen)
310{
311 unsigned int lvtt_value, tmp_value;
312
313 lvtt_value = LOCAL_TIMER_VECTOR;
314 if (!oneshot)
315 lvtt_value |= APIC_LVT_TIMER_PERIODIC;
316 if (!lapic_is_integrated())
317 lvtt_value |= SET_APIC_TIMER_BASE(APIC_TIMER_BASE_DIV);
318
319 if (!irqen)
320 lvtt_value |= APIC_LVT_MASKED;
321
322 apic_write(APIC_LVTT, lvtt_value);
323
324 /*
325 * Divide PICLK by 16
326 */
327 tmp_value = apic_read(APIC_TDCR);
328 apic_write(APIC_TDCR,
329 (tmp_value & ~(APIC_TDR_DIV_1 | APIC_TDR_DIV_TMBASE)) |
330 APIC_TDR_DIV_16);
331
332 if (!oneshot)
333 apic_write(APIC_TMICT, clocks / APIC_DIVISOR);
334}
335
336/*
337 * Setup extended LVT, AMD specific (K8, family 10h)
338 *
339 * Vector mappings are hard coded. On K8 only offset 0 (APIC500) and
340 * MCE interrupts are supported. Thus MCE offset must be set to 0.
341 *
342 * If mask=1, the LVT entry does not generate interrupts while mask=0
343 * enables the vector. See also the BKDGs.
344 */
345
346#define APIC_EILVT_LVTOFF_MCE 0
347#define APIC_EILVT_LVTOFF_IBS 1
348
349static void setup_APIC_eilvt(u8 lvt_off, u8 vector, u8 msg_type, u8 mask)
350{
351 unsigned long reg = (lvt_off << 4) + APIC_EILVT0;
352 unsigned int v = (mask << 16) | (msg_type << 8) | vector;
353
354 apic_write(reg, v);
355}
356
357u8 setup_APIC_eilvt_mce(u8 vector, u8 msg_type, u8 mask)
358{
359 setup_APIC_eilvt(APIC_EILVT_LVTOFF_MCE, vector, msg_type, mask);
360 return APIC_EILVT_LVTOFF_MCE;
361}
362
363u8 setup_APIC_eilvt_ibs(u8 vector, u8 msg_type, u8 mask)
364{
365 setup_APIC_eilvt(APIC_EILVT_LVTOFF_IBS, vector, msg_type, mask);
366 return APIC_EILVT_LVTOFF_IBS;
367}
368EXPORT_SYMBOL_GPL(setup_APIC_eilvt_ibs);
369
370/*
371 * Program the next event, relative to now
372 */
373static int lapic_next_event(unsigned long delta,
374 struct clock_event_device *evt)
375{
376 apic_write(APIC_TMICT, delta);
377 return 0;
378}
379
380/*
381 * Setup the lapic timer in periodic or oneshot mode
382 */
383static void lapic_timer_setup(enum clock_event_mode mode,
384 struct clock_event_device *evt)
385{
386 unsigned long flags;
387 unsigned int v;
388
389 /* Lapic used as dummy for broadcast ? */
390 if (evt->features & CLOCK_EVT_FEAT_DUMMY)
391 return;
392
393 local_irq_save(flags);
394
395 switch (mode) {
396 case CLOCK_EVT_MODE_PERIODIC:
397 case CLOCK_EVT_MODE_ONESHOT:
398 __setup_APIC_LVTT(calibration_result,
399 mode != CLOCK_EVT_MODE_PERIODIC, 1);
400 break;
401 case CLOCK_EVT_MODE_UNUSED:
402 case CLOCK_EVT_MODE_SHUTDOWN:
403 v = apic_read(APIC_LVTT);
404 v |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
405 apic_write(APIC_LVTT, v);
406 apic_write(APIC_TMICT, 0xffffffff);
407 break;
408 case CLOCK_EVT_MODE_RESUME:
409 /* Nothing to do here */
410 break;
411 }
412
413 local_irq_restore(flags);
414}
415
416/*
417 * Local APIC timer broadcast function
418 */
419static void lapic_timer_broadcast(const struct cpumask *mask)
420{
421#ifdef CONFIG_SMP
422 apic->send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
423#endif
424}
425
426/*
427 * Setup the local APIC timer for this CPU. Copy the initilized values
428 * of the boot CPU and register the clock event in the framework.
429 */
430static void __cpuinit setup_APIC_timer(void)
431{
432 struct clock_event_device *levt = &__get_cpu_var(lapic_events);
433
434 memcpy(levt, &lapic_clockevent, sizeof(*levt));
435 levt->cpumask = cpumask_of(smp_processor_id());
436
437 clockevents_register_device(levt);
438}
439
440/*
441 * In this functions we calibrate APIC bus clocks to the external timer.
442 *
443 * We want to do the calibration only once since we want to have local timer
444 * irqs syncron. CPUs connected by the same APIC bus have the very same bus
445 * frequency.
446 *
447 * This was previously done by reading the PIT/HPET and waiting for a wrap
448 * around to find out, that a tick has elapsed. I have a box, where the PIT
449 * readout is broken, so it never gets out of the wait loop again. This was
450 * also reported by others.
451 *
452 * Monitoring the jiffies value is inaccurate and the clockevents
453 * infrastructure allows us to do a simple substitution of the interrupt
454 * handler.
455 *
456 * The calibration routine also uses the pm_timer when possible, as the PIT
457 * happens to run way too slow (factor 2.3 on my VAIO CoreDuo, which goes
458 * back to normal later in the boot process).
459 */
460
461#define LAPIC_CAL_LOOPS (HZ/10)
462
463static __initdata int lapic_cal_loops = -1;
464static __initdata long lapic_cal_t1, lapic_cal_t2;
465static __initdata unsigned long long lapic_cal_tsc1, lapic_cal_tsc2;
466static __initdata unsigned long lapic_cal_pm1, lapic_cal_pm2;
467static __initdata unsigned long lapic_cal_j1, lapic_cal_j2;
468
469/*
470 * Temporary interrupt handler.
471 */
472static void __init lapic_cal_handler(struct clock_event_device *dev)
473{
474 unsigned long long tsc = 0;
475 long tapic = apic_read(APIC_TMCCT);
476 unsigned long pm = acpi_pm_read_early();
477
478 if (cpu_has_tsc)
479 rdtscll(tsc);
480
481 switch (lapic_cal_loops++) {
482 case 0:
483 lapic_cal_t1 = tapic;
484 lapic_cal_tsc1 = tsc;
485 lapic_cal_pm1 = pm;
486 lapic_cal_j1 = jiffies;
487 break;
488
489 case LAPIC_CAL_LOOPS:
490 lapic_cal_t2 = tapic;
491 lapic_cal_tsc2 = tsc;
492 if (pm < lapic_cal_pm1)
493 pm += ACPI_PM_OVRRUN;
494 lapic_cal_pm2 = pm;
495 lapic_cal_j2 = jiffies;
496 break;
497 }
498}
499
500static int __init
501calibrate_by_pmtimer(long deltapm, long *delta, long *deltatsc)
502{
503 const long pm_100ms = PMTMR_TICKS_PER_SEC / 10;
504 const long pm_thresh = pm_100ms / 100;
505 unsigned long mult;
506 u64 res;
507
508#ifndef CONFIG_X86_PM_TIMER
509 return -1;
510#endif
511
512 apic_printk(APIC_VERBOSE, "... PM-Timer delta = %ld\n", deltapm);
513
514 /* Check, if the PM timer is available */
515 if (!deltapm)
516 return -1;
517
518 mult = clocksource_hz2mult(PMTMR_TICKS_PER_SEC, 22);
519
520 if (deltapm > (pm_100ms - pm_thresh) &&
521 deltapm < (pm_100ms + pm_thresh)) {
522 apic_printk(APIC_VERBOSE, "... PM-Timer result ok\n");
523 return 0;
524 }
525
526 res = (((u64)deltapm) * mult) >> 22;
527 do_div(res, 1000000);
528 pr_warning("APIC calibration not consistent "
529 "with PM-Timer: %ldms instead of 100ms\n",(long)res);
530
531 /* Correct the lapic counter value */
532 res = (((u64)(*delta)) * pm_100ms);
533 do_div(res, deltapm);
534 pr_info("APIC delta adjusted to PM-Timer: "
535 "%lu (%ld)\n", (unsigned long)res, *delta);
536 *delta = (long)res;
537
538 /* Correct the tsc counter value */
539 if (cpu_has_tsc) {
540 res = (((u64)(*deltatsc)) * pm_100ms);
541 do_div(res, deltapm);
542 apic_printk(APIC_VERBOSE, "TSC delta adjusted to "
543 "PM-Timer: %lu (%ld) \n",
544 (unsigned long)res, *deltatsc);
545 *deltatsc = (long)res;
546 }
547
548 return 0;
549}
550
551static int __init calibrate_APIC_clock(void)
552{
553 struct clock_event_device *levt = &__get_cpu_var(lapic_events);
554 void (*real_handler)(struct clock_event_device *dev);
555 unsigned long deltaj;
556 long delta, deltatsc;
557 int pm_referenced = 0;
558
559 local_irq_disable();
560
561 /* Replace the global interrupt handler */
562 real_handler = global_clock_event->event_handler;
563 global_clock_event->event_handler = lapic_cal_handler;
564
565 /*
566 * Setup the APIC counter to maximum. There is no way the lapic
567 * can underflow in the 100ms detection time frame
568 */
569 __setup_APIC_LVTT(0xffffffff, 0, 0);
570
571 /* Let the interrupts run */
572 local_irq_enable();
573
574 while (lapic_cal_loops <= LAPIC_CAL_LOOPS)
575 cpu_relax();
576
577 local_irq_disable();
578
579 /* Restore the real event handler */
580 global_clock_event->event_handler = real_handler;
581
582 /* Build delta t1-t2 as apic timer counts down */
583 delta = lapic_cal_t1 - lapic_cal_t2;
584 apic_printk(APIC_VERBOSE, "... lapic delta = %ld\n", delta);
585
586 deltatsc = (long)(lapic_cal_tsc2 - lapic_cal_tsc1);
587
588 /* we trust the PM based calibration if possible */
589 pm_referenced = !calibrate_by_pmtimer(lapic_cal_pm2 - lapic_cal_pm1,
590 &delta, &deltatsc);
591
592 /* Calculate the scaled math multiplication factor */
593 lapic_clockevent.mult = div_sc(delta, TICK_NSEC * LAPIC_CAL_LOOPS,
594 lapic_clockevent.shift);
595 lapic_clockevent.max_delta_ns =
596 clockevent_delta2ns(0x7FFFFF, &lapic_clockevent);
597 lapic_clockevent.min_delta_ns =
598 clockevent_delta2ns(0xF, &lapic_clockevent);
599
600 calibration_result = (delta * APIC_DIVISOR) / LAPIC_CAL_LOOPS;
601
602 apic_printk(APIC_VERBOSE, "..... delta %ld\n", delta);
603 apic_printk(APIC_VERBOSE, "..... mult: %ld\n", lapic_clockevent.mult);
604 apic_printk(APIC_VERBOSE, "..... calibration result: %u\n",
605 calibration_result);
606
607 if (cpu_has_tsc) {
608 apic_printk(APIC_VERBOSE, "..... CPU clock speed is "
609 "%ld.%04ld MHz.\n",
610 (deltatsc / LAPIC_CAL_LOOPS) / (1000000 / HZ),
611 (deltatsc / LAPIC_CAL_LOOPS) % (1000000 / HZ));
612 }
613
614 apic_printk(APIC_VERBOSE, "..... host bus clock speed is "
615 "%u.%04u MHz.\n",
616 calibration_result / (1000000 / HZ),
617 calibration_result % (1000000 / HZ));
618
619 /*
620 * Do a sanity check on the APIC calibration result
621 */
622 if (calibration_result < (1000000 / HZ)) {
623 local_irq_enable();
624 pr_warning("APIC frequency too slow, disabling apic timer\n");
625 return -1;
626 }
627
628 levt->features &= ~CLOCK_EVT_FEAT_DUMMY;
629
630 /*
631 * PM timer calibration failed or not turned on
632 * so lets try APIC timer based calibration
633 */
634 if (!pm_referenced) {
635 apic_printk(APIC_VERBOSE, "... verify APIC timer\n");
636
637 /*
638 * Setup the apic timer manually
639 */
640 levt->event_handler = lapic_cal_handler;
641 lapic_timer_setup(CLOCK_EVT_MODE_PERIODIC, levt);
642 lapic_cal_loops = -1;
643
644 /* Let the interrupts run */
645 local_irq_enable();
646
647 while (lapic_cal_loops <= LAPIC_CAL_LOOPS)
648 cpu_relax();
649
650 /* Stop the lapic timer */
651 lapic_timer_setup(CLOCK_EVT_MODE_SHUTDOWN, levt);
652
653 /* Jiffies delta */
654 deltaj = lapic_cal_j2 - lapic_cal_j1;
655 apic_printk(APIC_VERBOSE, "... jiffies delta = %lu\n", deltaj);
656
657 /* Check, if the jiffies result is consistent */
658 if (deltaj >= LAPIC_CAL_LOOPS-2 && deltaj <= LAPIC_CAL_LOOPS+2)
659 apic_printk(APIC_VERBOSE, "... jiffies result ok\n");
660 else
661 levt->features |= CLOCK_EVT_FEAT_DUMMY;
662 } else
663 local_irq_enable();
664
665 if (levt->features & CLOCK_EVT_FEAT_DUMMY) {
666 pr_warning("APIC timer disabled due to verification failure\n");
667 return -1;
668 }
669
670 return 0;
671}
672
673/*
674 * Setup the boot APIC
675 *
676 * Calibrate and verify the result.
677 */
678void __init setup_boot_APIC_clock(void)
679{
680 /*
681 * The local apic timer can be disabled via the kernel
682 * commandline or from the CPU detection code. Register the lapic
683 * timer as a dummy clock event source on SMP systems, so the
684 * broadcast mechanism is used. On UP systems simply ignore it.
685 */
686 if (disable_apic_timer) {
687 pr_info("Disabling APIC timer\n");
688 /* No broadcast on UP ! */
689 if (num_possible_cpus() > 1) {
690 lapic_clockevent.mult = 1;
691 setup_APIC_timer();
692 }
693 return;
694 }
695
696 apic_printk(APIC_VERBOSE, "Using local APIC timer interrupts.\n"
697 "calibrating APIC timer ...\n");
698
699 if (calibrate_APIC_clock()) {
700 /* No broadcast on UP ! */
701 if (num_possible_cpus() > 1)
702 setup_APIC_timer();
703 return;
704 }
705
706 /*
707 * If nmi_watchdog is set to IO_APIC, we need the
708 * PIT/HPET going. Otherwise register lapic as a dummy
709 * device.
710 */
711 if (nmi_watchdog != NMI_IO_APIC)
712 lapic_clockevent.features &= ~CLOCK_EVT_FEAT_DUMMY;
713 else
714 pr_warning("APIC timer registered as dummy,"
715 " due to nmi_watchdog=%d!\n", nmi_watchdog);
716
717 /* Setup the lapic or request the broadcast */
718 setup_APIC_timer();
719}
720
721void __cpuinit setup_secondary_APIC_clock(void)
722{
723 setup_APIC_timer();
724}
725
726/*
727 * The guts of the apic timer interrupt
728 */
729static void local_apic_timer_interrupt(void)
730{
731 int cpu = smp_processor_id();
732 struct clock_event_device *evt = &per_cpu(lapic_events, cpu);
733
734 /*
735 * Normally we should not be here till LAPIC has been initialized but
736 * in some cases like kdump, its possible that there is a pending LAPIC
737 * timer interrupt from previous kernel's context and is delivered in
738 * new kernel the moment interrupts are enabled.
739 *
740 * Interrupts are enabled early and LAPIC is setup much later, hence
741 * its possible that when we get here evt->event_handler is NULL.
742 * Check for event_handler being NULL and discard the interrupt as
743 * spurious.
744 */
745 if (!evt->event_handler) {
746 pr_warning("Spurious LAPIC timer interrupt on cpu %d\n", cpu);
747 /* Switch it off */
748 lapic_timer_setup(CLOCK_EVT_MODE_SHUTDOWN, evt);
749 return;
750 }
751
752 /*
753 * the NMI deadlock-detector uses this.
754 */
755 inc_irq_stat(apic_timer_irqs);
756
757 evt->event_handler(evt);
758}
759
760/*
761 * Local APIC timer interrupt. This is the most natural way for doing
762 * local interrupts, but local timer interrupts can be emulated by
763 * broadcast interrupts too. [in case the hw doesn't support APIC timers]
764 *
765 * [ if a single-CPU system runs an SMP kernel then we call the local
766 * interrupt as well. Thus we cannot inline the local irq ... ]
767 */
768void __irq_entry smp_apic_timer_interrupt(struct pt_regs *regs)
769{
770 struct pt_regs *old_regs = set_irq_regs(regs);
771
772 /*
773 * NOTE! We'd better ACK the irq immediately,
774 * because timer handling can be slow.
775 */
776 ack_APIC_irq();
777 /*
778 * update_process_times() expects us to have done irq_enter().
779 * Besides, if we don't timer interrupts ignore the global
780 * interrupt lock, which is the WrongThing (tm) to do.
781 */
782 exit_idle();
783 irq_enter();
784 local_apic_timer_interrupt();
785 irq_exit();
786
787 set_irq_regs(old_regs);
788}
789
790int setup_profiling_timer(unsigned int multiplier)
791{
792 return -EINVAL;
793}
794
795/*
796 * Local APIC start and shutdown
797 */
798
799/**
800 * clear_local_APIC - shutdown the local APIC
801 *
802 * This is called, when a CPU is disabled and before rebooting, so the state of
803 * the local APIC has no dangling leftovers. Also used to cleanout any BIOS
804 * leftovers during boot.
805 */
806void clear_local_APIC(void)
807{
808 int maxlvt;
809 u32 v;
810
811 /* APIC hasn't been mapped yet */
812 if (!apic_phys)
813 return;
814
815 maxlvt = lapic_get_maxlvt();
816 /*
817 * Masking an LVT entry can trigger a local APIC error
818 * if the vector is zero. Mask LVTERR first to prevent this.
819 */
820 if (maxlvt >= 3) {
821 v = ERROR_APIC_VECTOR; /* any non-zero vector will do */
822 apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
823 }
824 /*
825 * Careful: we have to set masks only first to deassert
826 * any level-triggered sources.
827 */
828 v = apic_read(APIC_LVTT);
829 apic_write(APIC_LVTT, v | APIC_LVT_MASKED);
830 v = apic_read(APIC_LVT0);
831 apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
832 v = apic_read(APIC_LVT1);
833 apic_write(APIC_LVT1, v | APIC_LVT_MASKED);
834 if (maxlvt >= 4) {
835 v = apic_read(APIC_LVTPC);
836 apic_write(APIC_LVTPC, v | APIC_LVT_MASKED);
837 }
838
839 /* lets not touch this if we didn't frob it */
840#if defined(CONFIG_X86_MCE_P4THERMAL) || defined(X86_MCE_INTEL)
841 if (maxlvt >= 5) {
842 v = apic_read(APIC_LVTTHMR);
843 apic_write(APIC_LVTTHMR, v | APIC_LVT_MASKED);
844 }
845#endif
846 /*
847 * Clean APIC state for other OSs:
848 */
849 apic_write(APIC_LVTT, APIC_LVT_MASKED);
850 apic_write(APIC_LVT0, APIC_LVT_MASKED);
851 apic_write(APIC_LVT1, APIC_LVT_MASKED);
852 if (maxlvt >= 3)
853 apic_write(APIC_LVTERR, APIC_LVT_MASKED);
854 if (maxlvt >= 4)
855 apic_write(APIC_LVTPC, APIC_LVT_MASKED);
856
857 /* Integrated APIC (!82489DX) ? */
858 if (lapic_is_integrated()) {
859 if (maxlvt > 3)
860 /* Clear ESR due to Pentium errata 3AP and 11AP */
861 apic_write(APIC_ESR, 0);
862 apic_read(APIC_ESR);
863 }
864}
865
866/**
867 * disable_local_APIC - clear and disable the local APIC
868 */
869void disable_local_APIC(void)
870{
871 unsigned int value;
872
873 /* APIC hasn't been mapped yet */
874 if (!apic_phys)
875 return;
876
877 clear_local_APIC();
878
879 /*
880 * Disable APIC (implies clearing of registers
881 * for 82489DX!).
882 */
883 value = apic_read(APIC_SPIV);
884 value &= ~APIC_SPIV_APIC_ENABLED;
885 apic_write(APIC_SPIV, value);
886
887#ifdef CONFIG_X86_32
888 /*
889 * When LAPIC was disabled by the BIOS and enabled by the kernel,
890 * restore the disabled state.
891 */
892 if (enabled_via_apicbase) {
893 unsigned int l, h;
894
895 rdmsr(MSR_IA32_APICBASE, l, h);
896 l &= ~MSR_IA32_APICBASE_ENABLE;
897 wrmsr(MSR_IA32_APICBASE, l, h);
898 }
899#endif
900}
901
902/*
903 * If Linux enabled the LAPIC against the BIOS default disable it down before
904 * re-entering the BIOS on shutdown. Otherwise the BIOS may get confused and
905 * not power-off. Additionally clear all LVT entries before disable_local_APIC
906 * for the case where Linux didn't enable the LAPIC.
907 */
908void lapic_shutdown(void)
909{
910 unsigned long flags;
911
912 if (!cpu_has_apic)
913 return;
914
915 local_irq_save(flags);
916
917#ifdef CONFIG_X86_32
918 if (!enabled_via_apicbase)
919 clear_local_APIC();
920 else
921#endif
922 disable_local_APIC();
923
924
925 local_irq_restore(flags);
926}
927
928/*
929 * This is to verify that we're looking at a real local APIC.
930 * Check these against your board if the CPUs aren't getting
931 * started for no apparent reason.
932 */
933int __init verify_local_APIC(void)
934{
935 unsigned int reg0, reg1;
936
937 /*
938 * The version register is read-only in a real APIC.
939 */
940 reg0 = apic_read(APIC_LVR);
941 apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg0);
942 apic_write(APIC_LVR, reg0 ^ APIC_LVR_MASK);
943 reg1 = apic_read(APIC_LVR);
944 apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg1);
945
946 /*
947 * The two version reads above should print the same
948 * numbers. If the second one is different, then we
949 * poke at a non-APIC.
950 */
951 if (reg1 != reg0)
952 return 0;
953
954 /*
955 * Check if the version looks reasonably.
956 */
957 reg1 = GET_APIC_VERSION(reg0);
958 if (reg1 == 0x00 || reg1 == 0xff)
959 return 0;
960 reg1 = lapic_get_maxlvt();
961 if (reg1 < 0x02 || reg1 == 0xff)
962 return 0;
963
964 /*
965 * The ID register is read/write in a real APIC.
966 */
967 reg0 = apic_read(APIC_ID);
968 apic_printk(APIC_DEBUG, "Getting ID: %x\n", reg0);
969 apic_write(APIC_ID, reg0 ^ apic->apic_id_mask);
970 reg1 = apic_read(APIC_ID);
971 apic_printk(APIC_DEBUG, "Getting ID: %x\n", reg1);
972 apic_write(APIC_ID, reg0);
973 if (reg1 != (reg0 ^ apic->apic_id_mask))
974 return 0;
975
976 /*
977 * The next two are just to see if we have sane values.
978 * They're only really relevant if we're in Virtual Wire
979 * compatibility mode, but most boxes are anymore.
980 */
981 reg0 = apic_read(APIC_LVT0);
982 apic_printk(APIC_DEBUG, "Getting LVT0: %x\n", reg0);
983 reg1 = apic_read(APIC_LVT1);
984 apic_printk(APIC_DEBUG, "Getting LVT1: %x\n", reg1);
985
986 return 1;
987}
988
989/**
990 * sync_Arb_IDs - synchronize APIC bus arbitration IDs
991 */
992void __init sync_Arb_IDs(void)
993{
994 /*
995 * Unsupported on P4 - see Intel Dev. Manual Vol. 3, Ch. 8.6.1 And not
996 * needed on AMD.
997 */
998 if (modern_apic() || boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
999 return;
1000
1001 /*
1002 * Wait for idle.
1003 */
1004 apic_wait_icr_idle();
1005
1006 apic_printk(APIC_DEBUG, "Synchronizing Arb IDs.\n");
1007 apic_write(APIC_ICR, APIC_DEST_ALLINC |
1008 APIC_INT_LEVELTRIG | APIC_DM_INIT);
1009}
1010
1011/*
1012 * An initial setup of the virtual wire mode.
1013 */
1014void __init init_bsp_APIC(void)
1015{
1016 unsigned int value;
1017
1018 /*
1019 * Don't do the setup now if we have a SMP BIOS as the
1020 * through-I/O-APIC virtual wire mode might be active.
1021 */
1022 if (smp_found_config || !cpu_has_apic)
1023 return;
1024
1025 /*
1026 * Do not trust the local APIC being empty at bootup.
1027 */
1028 clear_local_APIC();
1029
1030 /*
1031 * Enable APIC.
1032 */
1033 value = apic_read(APIC_SPIV);
1034 value &= ~APIC_VECTOR_MASK;
1035 value |= APIC_SPIV_APIC_ENABLED;
1036
1037#ifdef CONFIG_X86_32
1038 /* This bit is reserved on P4/Xeon and should be cleared */
1039 if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
1040 (boot_cpu_data.x86 == 15))
1041 value &= ~APIC_SPIV_FOCUS_DISABLED;
1042 else
1043#endif
1044 value |= APIC_SPIV_FOCUS_DISABLED;
1045 value |= SPURIOUS_APIC_VECTOR;
1046 apic_write(APIC_SPIV, value);
1047
1048 /*
1049 * Set up the virtual wire mode.
1050 */
1051 apic_write(APIC_LVT0, APIC_DM_EXTINT);
1052 value = APIC_DM_NMI;
1053 if (!lapic_is_integrated()) /* 82489DX */
1054 value |= APIC_LVT_LEVEL_TRIGGER;
1055 apic_write(APIC_LVT1, value);
1056}
1057
1058static void __cpuinit lapic_setup_esr(void)
1059{
1060 unsigned int oldvalue, value, maxlvt;
1061
1062 if (!lapic_is_integrated()) {
1063 pr_info("No ESR for 82489DX.\n");
1064 return;
1065 }
1066
1067 if (apic->disable_esr) {
1068 /*
1069 * Something untraceable is creating bad interrupts on
1070 * secondary quads ... for the moment, just leave the
1071 * ESR disabled - we can't do anything useful with the
1072 * errors anyway - mbligh
1073 */
1074 pr_info("Leaving ESR disabled.\n");
1075 return;
1076 }
1077
1078 maxlvt = lapic_get_maxlvt();
1079 if (maxlvt > 3) /* Due to the Pentium erratum 3AP. */
1080 apic_write(APIC_ESR, 0);
1081 oldvalue = apic_read(APIC_ESR);
1082
1083 /* enables sending errors */
1084 value = ERROR_APIC_VECTOR;
1085 apic_write(APIC_LVTERR, value);
1086
1087 /*
1088 * spec says clear errors after enabling vector.
1089 */
1090 if (maxlvt > 3)
1091 apic_write(APIC_ESR, 0);
1092 value = apic_read(APIC_ESR);
1093 if (value != oldvalue)
1094 apic_printk(APIC_VERBOSE, "ESR value before enabling "
1095 "vector: 0x%08x after: 0x%08x\n",
1096 oldvalue, value);
1097}
1098
1099
1100/**
1101 * setup_local_APIC - setup the local APIC
1102 */
1103void __cpuinit setup_local_APIC(void)
1104{
1105 unsigned int value;
1106 int i, j;
1107
1108 if (disable_apic) {
1109 arch_disable_smp_support();
1110 return;
1111 }
1112
1113#ifdef CONFIG_X86_32
1114 /* Pound the ESR really hard over the head with a big hammer - mbligh */
1115 if (lapic_is_integrated() && apic->disable_esr) {
1116 apic_write(APIC_ESR, 0);
1117 apic_write(APIC_ESR, 0);
1118 apic_write(APIC_ESR, 0);
1119 apic_write(APIC_ESR, 0);
1120 }
1121#endif
1122
1123 preempt_disable();
1124
1125 /*
1126 * Double-check whether this APIC is really registered.
1127 * This is meaningless in clustered apic mode, so we skip it.
1128 */
1129 if (!apic->apic_id_registered())
1130 BUG();
1131
1132 /*
1133 * Intel recommends to set DFR, LDR and TPR before enabling
1134 * an APIC. See e.g. "AP-388 82489DX User's Manual" (Intel
1135 * document number 292116). So here it goes...
1136 */
1137 apic->init_apic_ldr();
1138
1139 /*
1140 * Set Task Priority to 'accept all'. We never change this
1141 * later on.
1142 */
1143 value = apic_read(APIC_TASKPRI);
1144 value &= ~APIC_TPRI_MASK;
1145 apic_write(APIC_TASKPRI, value);
1146
1147 /*
1148 * After a crash, we no longer service the interrupts and a pending
1149 * interrupt from previous kernel might still have ISR bit set.
1150 *
1151 * Most probably by now CPU has serviced that pending interrupt and
1152 * it might not have done the ack_APIC_irq() because it thought,
1153 * interrupt came from i8259 as ExtInt. LAPIC did not get EOI so it
1154 * does not clear the ISR bit and cpu thinks it has already serivced
1155 * the interrupt. Hence a vector might get locked. It was noticed
1156 * for timer irq (vector 0x31). Issue an extra EOI to clear ISR.
1157 */
1158 for (i = APIC_ISR_NR - 1; i >= 0; i--) {
1159 value = apic_read(APIC_ISR + i*0x10);
1160 for (j = 31; j >= 0; j--) {
1161 if (value & (1<<j))
1162 ack_APIC_irq();
1163 }
1164 }
1165
1166 /*
1167 * Now that we are all set up, enable the APIC
1168 */
1169 value = apic_read(APIC_SPIV);
1170 value &= ~APIC_VECTOR_MASK;
1171 /*
1172 * Enable APIC
1173 */
1174 value |= APIC_SPIV_APIC_ENABLED;
1175
1176#ifdef CONFIG_X86_32
1177 /*
1178 * Some unknown Intel IO/APIC (or APIC) errata is biting us with
1179 * certain networking cards. If high frequency interrupts are
1180 * happening on a particular IOAPIC pin, plus the IOAPIC routing
1181 * entry is masked/unmasked at a high rate as well then sooner or
1182 * later IOAPIC line gets 'stuck', no more interrupts are received
1183 * from the device. If focus CPU is disabled then the hang goes
1184 * away, oh well :-(
1185 *
1186 * [ This bug can be reproduced easily with a level-triggered
1187 * PCI Ne2000 networking cards and PII/PIII processors, dual
1188 * BX chipset. ]
1189 */
1190 /*
1191 * Actually disabling the focus CPU check just makes the hang less
1192 * frequent as it makes the interrupt distributon model be more
1193 * like LRU than MRU (the short-term load is more even across CPUs).
1194 * See also the comment in end_level_ioapic_irq(). --macro
1195 */
1196
1197 /*
1198 * - enable focus processor (bit==0)
1199 * - 64bit mode always use processor focus
1200 * so no need to set it
1201 */
1202 value &= ~APIC_SPIV_FOCUS_DISABLED;
1203#endif
1204
1205 /*
1206 * Set spurious IRQ vector
1207 */
1208 value |= SPURIOUS_APIC_VECTOR;
1209 apic_write(APIC_SPIV, value);
1210
1211 /*
1212 * Set up LVT0, LVT1:
1213 *
1214 * set up through-local-APIC on the BP's LINT0. This is not
1215 * strictly necessary in pure symmetric-IO mode, but sometimes
1216 * we delegate interrupts to the 8259A.
1217 */
1218 /*
1219 * TODO: set up through-local-APIC from through-I/O-APIC? --macro
1220 */
1221 value = apic_read(APIC_LVT0) & APIC_LVT_MASKED;
1222 if (!smp_processor_id() && (pic_mode || !value)) {
1223 value = APIC_DM_EXTINT;
1224 apic_printk(APIC_VERBOSE, "enabled ExtINT on CPU#%d\n",
1225 smp_processor_id());
1226 } else {
1227 value = APIC_DM_EXTINT | APIC_LVT_MASKED;
1228 apic_printk(APIC_VERBOSE, "masked ExtINT on CPU#%d\n",
1229 smp_processor_id());
1230 }
1231 apic_write(APIC_LVT0, value);
1232
1233 /*
1234 * only the BP should see the LINT1 NMI signal, obviously.
1235 */
1236 if (!smp_processor_id())
1237 value = APIC_DM_NMI;
1238 else
1239 value = APIC_DM_NMI | APIC_LVT_MASKED;
1240 if (!lapic_is_integrated()) /* 82489DX */
1241 value |= APIC_LVT_LEVEL_TRIGGER;
1242 apic_write(APIC_LVT1, value);
1243
1244 preempt_enable();
1245}
1246
1247void __cpuinit end_local_APIC_setup(void)
1248{
1249 lapic_setup_esr();
1250
1251#ifdef CONFIG_X86_32
1252 {
1253 unsigned int value;
1254 /* Disable the local apic timer */
1255 value = apic_read(APIC_LVTT);
1256 value |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
1257 apic_write(APIC_LVTT, value);
1258 }
1259#endif
1260
1261 setup_apic_nmi_watchdog(NULL);
1262 apic_pm_activate();
1263}
1264
1265#ifdef CONFIG_X86_X2APIC
1266void check_x2apic(void)
1267{
1268 int msr, msr2;
1269
1270 if (!cpu_has_x2apic)
1271 return;
1272
1273 rdmsr(MSR_IA32_APICBASE, msr, msr2);
1274
1275 if (msr & X2APIC_ENABLE) {
1276 pr_info("x2apic enabled by BIOS, switching to x2apic ops\n");
1277 x2apic_preenabled = x2apic = 1;
1278 }
1279}
1280
1281void enable_x2apic(void)
1282{
1283 int msr, msr2;
1284
1285 if (!x2apic)
1286 return;
1287
1288 rdmsr(MSR_IA32_APICBASE, msr, msr2);
1289 if (!(msr & X2APIC_ENABLE)) {
1290 pr_info("Enabling x2apic\n");
1291 wrmsr(MSR_IA32_APICBASE, msr | X2APIC_ENABLE, 0);
1292 }
1293}
1294
1295void __init enable_IR_x2apic(void)
1296{
1297#ifdef CONFIG_INTR_REMAP
1298 int ret;
1299 unsigned long flags;
1300
1301 if (!cpu_has_x2apic)
1302 return;
1303
1304 if (!x2apic_preenabled && disable_x2apic) {
1305 pr_info("Skipped enabling x2apic and Interrupt-remapping "
1306 "because of nox2apic\n");
1307 return;
1308 }
1309
1310 if (x2apic_preenabled && disable_x2apic)
1311 panic("Bios already enabled x2apic, can't enforce nox2apic");
1312
1313 if (!x2apic_preenabled && skip_ioapic_setup) {
1314 pr_info("Skipped enabling x2apic and Interrupt-remapping "
1315 "because of skipping io-apic setup\n");
1316 return;
1317 }
1318
1319 ret = dmar_table_init();
1320 if (ret) {
1321 pr_info("dmar_table_init() failed with %d:\n", ret);
1322
1323 if (x2apic_preenabled)
1324 panic("x2apic enabled by bios. But IR enabling failed");
1325 else
1326 pr_info("Not enabling x2apic,Intr-remapping\n");
1327 return;
1328 }
1329
1330 local_irq_save(flags);
1331 mask_8259A();
1332
1333 ret = save_mask_IO_APIC_setup();
1334 if (ret) {
1335 pr_info("Saving IO-APIC state failed: %d\n", ret);
1336 goto end;
1337 }
1338
1339 ret = enable_intr_remapping(1);
1340
1341 if (ret && x2apic_preenabled) {
1342 local_irq_restore(flags);
1343 panic("x2apic enabled by bios. But IR enabling failed");
1344 }
1345
1346 if (ret)
1347 goto end_restore;
1348
1349 if (!x2apic) {
1350 x2apic = 1;
1351 enable_x2apic();
1352 }
1353
1354end_restore:
1355 if (ret)
1356 /*
1357 * IR enabling failed
1358 */
1359 restore_IO_APIC_setup();
1360 else
1361 reinit_intr_remapped_IO_APIC(x2apic_preenabled);
1362
1363end:
1364 unmask_8259A();
1365 local_irq_restore(flags);
1366
1367 if (!ret) {
1368 if (!x2apic_preenabled)
1369 pr_info("Enabled x2apic and interrupt-remapping\n");
1370 else
1371 pr_info("Enabled Interrupt-remapping\n");
1372 } else
1373 pr_err("Failed to enable Interrupt-remapping and x2apic\n");
1374#else
1375 if (!cpu_has_x2apic)
1376 return;
1377
1378 if (x2apic_preenabled)
1379 panic("x2apic enabled prior OS handover,"
1380 " enable CONFIG_INTR_REMAP");
1381
1382 pr_info("Enable CONFIG_INTR_REMAP for enabling intr-remapping "
1383 " and x2apic\n");
1384#endif
1385
1386 return;
1387}
1388#endif /* CONFIG_X86_X2APIC */
1389
1390#ifdef CONFIG_X86_64
1391/*
1392 * Detect and enable local APICs on non-SMP boards.
1393 * Original code written by Keir Fraser.
1394 * On AMD64 we trust the BIOS - if it says no APIC it is likely
1395 * not correctly set up (usually the APIC timer won't work etc.)
1396 */
1397static int __init detect_init_APIC(void)
1398{
1399 if (!cpu_has_apic) {
1400 pr_info("No local APIC present\n");
1401 return -1;
1402 }
1403
1404 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
1405 boot_cpu_physical_apicid = 0;
1406 return 0;
1407}
1408#else
1409/*
1410 * Detect and initialize APIC
1411 */
1412static int __init detect_init_APIC(void)
1413{
1414 u32 h, l, features;
1415
1416 /* Disabled by kernel option? */
1417 if (disable_apic)
1418 return -1;
1419
1420 switch (boot_cpu_data.x86_vendor) {
1421 case X86_VENDOR_AMD:
1422 if ((boot_cpu_data.x86 == 6 && boot_cpu_data.x86_model > 1) ||
1423 (boot_cpu_data.x86 >= 15))
1424 break;
1425 goto no_apic;
1426 case X86_VENDOR_INTEL:
1427 if (boot_cpu_data.x86 == 6 || boot_cpu_data.x86 == 15 ||
1428 (boot_cpu_data.x86 == 5 && cpu_has_apic))
1429 break;
1430 goto no_apic;
1431 default:
1432 goto no_apic;
1433 }
1434
1435 if (!cpu_has_apic) {
1436 /*
1437 * Over-ride BIOS and try to enable the local APIC only if
1438 * "lapic" specified.
1439 */
1440 if (!force_enable_local_apic) {
1441 pr_info("Local APIC disabled by BIOS -- "
1442 "you can enable it with \"lapic\"\n");
1443 return -1;
1444 }
1445 /*
1446 * Some BIOSes disable the local APIC in the APIC_BASE
1447 * MSR. This can only be done in software for Intel P6 or later
1448 * and AMD K7 (Model > 1) or later.
1449 */
1450 rdmsr(MSR_IA32_APICBASE, l, h);
1451 if (!(l & MSR_IA32_APICBASE_ENABLE)) {
1452 pr_info("Local APIC disabled by BIOS -- reenabling.\n");
1453 l &= ~MSR_IA32_APICBASE_BASE;
1454 l |= MSR_IA32_APICBASE_ENABLE | APIC_DEFAULT_PHYS_BASE;
1455 wrmsr(MSR_IA32_APICBASE, l, h);
1456 enabled_via_apicbase = 1;
1457 }
1458 }
1459 /*
1460 * The APIC feature bit should now be enabled
1461 * in `cpuid'
1462 */
1463 features = cpuid_edx(1);
1464 if (!(features & (1 << X86_FEATURE_APIC))) {
1465 pr_warning("Could not enable APIC!\n");
1466 return -1;
1467 }
1468 set_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
1469 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
1470
1471 /* The BIOS may have set up the APIC at some other address */
1472 rdmsr(MSR_IA32_APICBASE, l, h);
1473 if (l & MSR_IA32_APICBASE_ENABLE)
1474 mp_lapic_addr = l & MSR_IA32_APICBASE_BASE;
1475
1476 pr_info("Found and enabled local APIC!\n");
1477
1478 apic_pm_activate();
1479
1480 return 0;
1481
1482no_apic:
1483 pr_info("No local APIC present or hardware disabled\n");
1484 return -1;
1485}
1486#endif
1487
1488#ifdef CONFIG_X86_64
1489void __init early_init_lapic_mapping(void)
1490{
1491 unsigned long phys_addr;
1492
1493 /*
1494 * If no local APIC can be found then go out
1495 * : it means there is no mpatable and MADT
1496 */
1497 if (!smp_found_config)
1498 return;
1499
1500 phys_addr = mp_lapic_addr;
1501
1502 set_fixmap_nocache(FIX_APIC_BASE, phys_addr);
1503 apic_printk(APIC_VERBOSE, "mapped APIC to %16lx (%16lx)\n",
1504 APIC_BASE, phys_addr);
1505
1506 /*
1507 * Fetch the APIC ID of the BSP in case we have a
1508 * default configuration (or the MP table is broken).
1509 */
1510 boot_cpu_physical_apicid = read_apic_id();
1511}
1512#endif
1513
1514/**
1515 * init_apic_mappings - initialize APIC mappings
1516 */
1517void __init init_apic_mappings(void)
1518{
1519#ifdef CONFIG_X86_X2APIC
1520 if (x2apic) {
1521 boot_cpu_physical_apicid = read_apic_id();
1522 return;
1523 }
1524#endif
1525
1526 /*
1527 * If no local APIC can be found then set up a fake all
1528 * zeroes page to simulate the local APIC and another
1529 * one for the IO-APIC.
1530 */
1531 if (!smp_found_config && detect_init_APIC()) {
1532 apic_phys = (unsigned long) alloc_bootmem_pages(PAGE_SIZE);
1533 apic_phys = __pa(apic_phys);
1534 } else
1535 apic_phys = mp_lapic_addr;
1536
1537 set_fixmap_nocache(FIX_APIC_BASE, apic_phys);
1538 apic_printk(APIC_VERBOSE, "mapped APIC to %08lx (%08lx)\n",
1539 APIC_BASE, apic_phys);
1540
1541 /*
1542 * Fetch the APIC ID of the BSP in case we have a
1543 * default configuration (or the MP table is broken).
1544 */
1545 if (boot_cpu_physical_apicid == -1U)
1546 boot_cpu_physical_apicid = read_apic_id();
1547}
1548
1549/*
1550 * This initializes the IO-APIC and APIC hardware if this is
1551 * a UP kernel.
1552 */
1553int apic_version[MAX_APICS];
1554
1555int __init APIC_init_uniprocessor(void)
1556{
1557 if (disable_apic) {
1558 pr_info("Apic disabled\n");
1559 return -1;
1560 }
1561#ifdef CONFIG_X86_64
1562 if (!cpu_has_apic) {
1563 disable_apic = 1;
1564 pr_info("Apic disabled by BIOS\n");
1565 return -1;
1566 }
1567#else
1568 if (!smp_found_config && !cpu_has_apic)
1569 return -1;
1570
1571 /*
1572 * Complain if the BIOS pretends there is one.
1573 */
1574 if (!cpu_has_apic &&
1575 APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid])) {
1576 pr_err("BIOS bug, local APIC 0x%x not detected!...\n",
1577 boot_cpu_physical_apicid);
1578 clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
1579 return -1;
1580 }
1581#endif
1582
1583 enable_IR_x2apic();
1584#ifdef CONFIG_X86_64
1585 default_setup_apic_routing();
1586#endif
1587
1588 verify_local_APIC();
1589 connect_bsp_APIC();
1590
1591#ifdef CONFIG_X86_64
1592 apic_write(APIC_ID, SET_APIC_ID(boot_cpu_physical_apicid));
1593#else
1594 /*
1595 * Hack: In case of kdump, after a crash, kernel might be booting
1596 * on a cpu with non-zero lapic id. But boot_cpu_physical_apicid
1597 * might be zero if read from MP tables. Get it from LAPIC.
1598 */
1599# ifdef CONFIG_CRASH_DUMP
1600 boot_cpu_physical_apicid = read_apic_id();
1601# endif
1602#endif
1603 physid_set_mask_of_physid(boot_cpu_physical_apicid, &phys_cpu_present_map);
1604 setup_local_APIC();
1605
1606#ifdef CONFIG_X86_IO_APIC
1607 /*
1608 * Now enable IO-APICs, actually call clear_IO_APIC
1609 * We need clear_IO_APIC before enabling error vector
1610 */
1611 if (!skip_ioapic_setup && nr_ioapics)
1612 enable_IO_APIC();
1613#endif
1614
1615 end_local_APIC_setup();
1616
1617#ifdef CONFIG_X86_IO_APIC
1618 if (smp_found_config && !skip_ioapic_setup && nr_ioapics)
1619 setup_IO_APIC();
1620 else {
1621 nr_ioapics = 0;
1622 localise_nmi_watchdog();
1623 }
1624#else
1625 localise_nmi_watchdog();
1626#endif
1627
1628 setup_boot_clock();
1629#ifdef CONFIG_X86_64
1630 check_nmi_watchdog();
1631#endif
1632
1633 return 0;
1634}
1635
1636/*
1637 * Local APIC interrupts
1638 */
1639
1640/*
1641 * This interrupt should _never_ happen with our APIC/SMP architecture
1642 */
1643void smp_spurious_interrupt(struct pt_regs *regs)
1644{
1645 u32 v;
1646
1647 exit_idle();
1648 irq_enter();
1649 /*
1650 * Check if this really is a spurious interrupt and ACK it
1651 * if it is a vectored one. Just in case...
1652 * Spurious interrupts should not be ACKed.
1653 */
1654 v = apic_read(APIC_ISR + ((SPURIOUS_APIC_VECTOR & ~0x1f) >> 1));
1655 if (v & (1 << (SPURIOUS_APIC_VECTOR & 0x1f)))
1656 ack_APIC_irq();
1657
1658 inc_irq_stat(irq_spurious_count);
1659
1660 /* see sw-dev-man vol 3, chapter 7.4.13.5 */
1661 pr_info("spurious APIC interrupt on CPU#%d, "
1662 "should never happen.\n", smp_processor_id());
1663 irq_exit();
1664}
1665
1666/*
1667 * This interrupt should never happen with our APIC/SMP architecture
1668 */
1669void smp_error_interrupt(struct pt_regs *regs)
1670{
1671 u32 v, v1;
1672
1673 exit_idle();
1674 irq_enter();
1675 /* First tickle the hardware, only then report what went on. -- REW */
1676 v = apic_read(APIC_ESR);
1677 apic_write(APIC_ESR, 0);
1678 v1 = apic_read(APIC_ESR);
1679 ack_APIC_irq();
1680 atomic_inc(&irq_err_count);
1681
1682 /*
1683 * Here is what the APIC error bits mean:
1684 * 0: Send CS error
1685 * 1: Receive CS error
1686 * 2: Send accept error
1687 * 3: Receive accept error
1688 * 4: Reserved
1689 * 5: Send illegal vector
1690 * 6: Received illegal vector
1691 * 7: Illegal register address
1692 */
1693 pr_debug("APIC error on CPU%d: %02x(%02x)\n",
1694 smp_processor_id(), v , v1);
1695 irq_exit();
1696}
1697
1698/**
1699 * connect_bsp_APIC - attach the APIC to the interrupt system
1700 */
1701void __init connect_bsp_APIC(void)
1702{
1703#ifdef CONFIG_X86_32
1704 if (pic_mode) {
1705 /*
1706 * Do not trust the local APIC being empty at bootup.
1707 */
1708 clear_local_APIC();
1709 /*
1710 * PIC mode, enable APIC mode in the IMCR, i.e. connect BSP's
1711 * local APIC to INT and NMI lines.
1712 */
1713 apic_printk(APIC_VERBOSE, "leaving PIC mode, "
1714 "enabling APIC mode.\n");
1715 outb(0x70, 0x22);
1716 outb(0x01, 0x23);
1717 }
1718#endif
1719 if (apic->enable_apic_mode)
1720 apic->enable_apic_mode();
1721}
1722
1723/**
1724 * disconnect_bsp_APIC - detach the APIC from the interrupt system
1725 * @virt_wire_setup: indicates, whether virtual wire mode is selected
1726 *
1727 * Virtual wire mode is necessary to deliver legacy interrupts even when the
1728 * APIC is disabled.
1729 */
1730void disconnect_bsp_APIC(int virt_wire_setup)
1731{
1732 unsigned int value;
1733
1734#ifdef CONFIG_X86_32
1735 if (pic_mode) {
1736 /*
1737 * Put the board back into PIC mode (has an effect only on
1738 * certain older boards). Note that APIC interrupts, including
1739 * IPIs, won't work beyond this point! The only exception are
1740 * INIT IPIs.
1741 */
1742 apic_printk(APIC_VERBOSE, "disabling APIC mode, "
1743 "entering PIC mode.\n");
1744 outb(0x70, 0x22);
1745 outb(0x00, 0x23);
1746 return;
1747 }
1748#endif
1749
1750 /* Go back to Virtual Wire compatibility mode */
1751
1752 /* For the spurious interrupt use vector F, and enable it */
1753 value = apic_read(APIC_SPIV);
1754 value &= ~APIC_VECTOR_MASK;
1755 value |= APIC_SPIV_APIC_ENABLED;
1756 value |= 0xf;
1757 apic_write(APIC_SPIV, value);
1758
1759 if (!virt_wire_setup) {
1760 /*
1761 * For LVT0 make it edge triggered, active high,
1762 * external and enabled
1763 */
1764 value = apic_read(APIC_LVT0);
1765 value &= ~(APIC_MODE_MASK | APIC_SEND_PENDING |
1766 APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
1767 APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED);
1768 value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
1769 value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_EXTINT);
1770 apic_write(APIC_LVT0, value);
1771 } else {
1772 /* Disable LVT0 */
1773 apic_write(APIC_LVT0, APIC_LVT_MASKED);
1774 }
1775
1776 /*
1777 * For LVT1 make it edge triggered, active high,
1778 * nmi and enabled
1779 */
1780 value = apic_read(APIC_LVT1);
1781 value &= ~(APIC_MODE_MASK | APIC_SEND_PENDING |
1782 APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
1783 APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED);
1784 value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
1785 value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_NMI);
1786 apic_write(APIC_LVT1, value);
1787}
1788
1789void __cpuinit generic_processor_info(int apicid, int version)
1790{
1791 int cpu;
1792
1793 /*
1794 * Validate version
1795 */
1796 if (version == 0x0) {
1797 pr_warning("BIOS bug, APIC version is 0 for CPU#%d! "
1798 "fixing up to 0x10. (tell your hw vendor)\n",
1799 version);
1800 version = 0x10;
1801 }
1802 apic_version[apicid] = version;
1803
1804 if (num_processors >= nr_cpu_ids) {
1805 int max = nr_cpu_ids;
1806 int thiscpu = max + disabled_cpus;
1807
1808 pr_warning(
1809 "ACPI: NR_CPUS/possible_cpus limit of %i reached."
1810 " Processor %d/0x%x ignored.\n", max, thiscpu, apicid);
1811
1812 disabled_cpus++;
1813 return;
1814 }
1815
1816 num_processors++;
1817 cpu = cpumask_next_zero(-1, cpu_present_mask);
1818
1819 if (version != apic_version[boot_cpu_physical_apicid])
1820 WARN_ONCE(1,
1821 "ACPI: apic version mismatch, bootcpu: %x cpu %d: %x\n",
1822 apic_version[boot_cpu_physical_apicid], cpu, version);
1823
1824 physid_set(apicid, phys_cpu_present_map);
1825 if (apicid == boot_cpu_physical_apicid) {
1826 /*
1827 * x86_bios_cpu_apicid is required to have processors listed
1828 * in same order as logical cpu numbers. Hence the first
1829 * entry is BSP, and so on.
1830 */
1831 cpu = 0;
1832 }
1833 if (apicid > max_physical_apicid)
1834 max_physical_apicid = apicid;
1835
1836#ifdef CONFIG_X86_32
1837 /*
1838 * Would be preferable to switch to bigsmp when CONFIG_HOTPLUG_CPU=y
1839 * but we need to work other dependencies like SMP_SUSPEND etc
1840 * before this can be done without some confusion.
1841 * if (CPU_HOTPLUG_ENABLED || num_processors > 8)
1842 * - Ashok Raj <ashok.raj@intel.com>
1843 */
1844 if (max_physical_apicid >= 8) {
1845 switch (boot_cpu_data.x86_vendor) {
1846 case X86_VENDOR_INTEL:
1847 if (!APIC_XAPIC(version)) {
1848 def_to_bigsmp = 0;
1849 break;
1850 }
1851 /* If P4 and above fall through */
1852 case X86_VENDOR_AMD:
1853 def_to_bigsmp = 1;
1854 }
1855 }
1856#endif
1857
1858#if defined(CONFIG_SMP) || defined(CONFIG_X86_64)
1859 early_per_cpu(x86_cpu_to_apicid, cpu) = apicid;
1860 early_per_cpu(x86_bios_cpu_apicid, cpu) = apicid;
1861#endif
1862
1863 set_cpu_possible(cpu, true);
1864 set_cpu_present(cpu, true);
1865}
1866
1867int hard_smp_processor_id(void)
1868{
1869 return read_apic_id();
1870}
1871
1872void default_init_apic_ldr(void)
1873{
1874 unsigned long val;
1875
1876 apic_write(APIC_DFR, APIC_DFR_VALUE);
1877 val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
1878 val |= SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
1879 apic_write(APIC_LDR, val);
1880}
1881
1882#ifdef CONFIG_X86_32
1883int default_apicid_to_node(int logical_apicid)
1884{
1885#ifdef CONFIG_SMP
1886 return apicid_2_node[hard_smp_processor_id()];
1887#else
1888 return 0;
1889#endif
1890}
1891#endif
1892
1893/*
1894 * Power management
1895 */
1896#ifdef CONFIG_PM
1897
1898static struct {
1899 /*
1900 * 'active' is true if the local APIC was enabled by us and
1901 * not the BIOS; this signifies that we are also responsible
1902 * for disabling it before entering apm/acpi suspend
1903 */
1904 int active;
1905 /* r/w apic fields */
1906 unsigned int apic_id;
1907 unsigned int apic_taskpri;
1908 unsigned int apic_ldr;
1909 unsigned int apic_dfr;
1910 unsigned int apic_spiv;
1911 unsigned int apic_lvtt;
1912 unsigned int apic_lvtpc;
1913 unsigned int apic_lvt0;
1914 unsigned int apic_lvt1;
1915 unsigned int apic_lvterr;
1916 unsigned int apic_tmict;
1917 unsigned int apic_tdcr;
1918 unsigned int apic_thmr;
1919} apic_pm_state;
1920
1921static int lapic_suspend(struct sys_device *dev, pm_message_t state)
1922{
1923 unsigned long flags;
1924 int maxlvt;
1925
1926 if (!apic_pm_state.active)
1927 return 0;
1928
1929 maxlvt = lapic_get_maxlvt();
1930
1931 apic_pm_state.apic_id = apic_read(APIC_ID);
1932 apic_pm_state.apic_taskpri = apic_read(APIC_TASKPRI);
1933 apic_pm_state.apic_ldr = apic_read(APIC_LDR);
1934 apic_pm_state.apic_dfr = apic_read(APIC_DFR);
1935 apic_pm_state.apic_spiv = apic_read(APIC_SPIV);
1936 apic_pm_state.apic_lvtt = apic_read(APIC_LVTT);
1937 if (maxlvt >= 4)
1938 apic_pm_state.apic_lvtpc = apic_read(APIC_LVTPC);
1939 apic_pm_state.apic_lvt0 = apic_read(APIC_LVT0);
1940 apic_pm_state.apic_lvt1 = apic_read(APIC_LVT1);
1941 apic_pm_state.apic_lvterr = apic_read(APIC_LVTERR);
1942 apic_pm_state.apic_tmict = apic_read(APIC_TMICT);
1943 apic_pm_state.apic_tdcr = apic_read(APIC_TDCR);
1944#if defined(CONFIG_X86_MCE_P4THERMAL) || defined(CONFIG_X86_MCE_INTEL)
1945 if (maxlvt >= 5)
1946 apic_pm_state.apic_thmr = apic_read(APIC_LVTTHMR);
1947#endif
1948
1949 local_irq_save(flags);
1950 disable_local_APIC();
1951 local_irq_restore(flags);
1952 return 0;
1953}
1954
1955static int lapic_resume(struct sys_device *dev)
1956{
1957 unsigned int l, h;
1958 unsigned long flags;
1959 int maxlvt;
1960
1961 if (!apic_pm_state.active)
1962 return 0;
1963
1964 maxlvt = lapic_get_maxlvt();
1965
1966 local_irq_save(flags);
1967
1968#ifdef CONFIG_X86_X2APIC
1969 if (x2apic)
1970 enable_x2apic();
1971 else
1972#endif
1973 {
1974 /*
1975 * Make sure the APICBASE points to the right address
1976 *
1977 * FIXME! This will be wrong if we ever support suspend on
1978 * SMP! We'll need to do this as part of the CPU restore!
1979 */
1980 rdmsr(MSR_IA32_APICBASE, l, h);
1981 l &= ~MSR_IA32_APICBASE_BASE;
1982 l |= MSR_IA32_APICBASE_ENABLE | mp_lapic_addr;
1983 wrmsr(MSR_IA32_APICBASE, l, h);
1984 }
1985
1986 apic_write(APIC_LVTERR, ERROR_APIC_VECTOR | APIC_LVT_MASKED);
1987 apic_write(APIC_ID, apic_pm_state.apic_id);
1988 apic_write(APIC_DFR, apic_pm_state.apic_dfr);
1989 apic_write(APIC_LDR, apic_pm_state.apic_ldr);
1990 apic_write(APIC_TASKPRI, apic_pm_state.apic_taskpri);
1991 apic_write(APIC_SPIV, apic_pm_state.apic_spiv);
1992 apic_write(APIC_LVT0, apic_pm_state.apic_lvt0);
1993 apic_write(APIC_LVT1, apic_pm_state.apic_lvt1);
1994#if defined(CONFIG_X86_MCE_P4THERMAL) || defined(CONFIG_X86_MCE_INTEL)
1995 if (maxlvt >= 5)
1996 apic_write(APIC_LVTTHMR, apic_pm_state.apic_thmr);
1997#endif
1998 if (maxlvt >= 4)
1999 apic_write(APIC_LVTPC, apic_pm_state.apic_lvtpc);
2000 apic_write(APIC_LVTT, apic_pm_state.apic_lvtt);
2001 apic_write(APIC_TDCR, apic_pm_state.apic_tdcr);
2002 apic_write(APIC_TMICT, apic_pm_state.apic_tmict);
2003 apic_write(APIC_ESR, 0);
2004 apic_read(APIC_ESR);
2005 apic_write(APIC_LVTERR, apic_pm_state.apic_lvterr);
2006 apic_write(APIC_ESR, 0);
2007 apic_read(APIC_ESR);
2008
2009 local_irq_restore(flags);
2010
2011 return 0;
2012}
2013
2014/*
2015 * This device has no shutdown method - fully functioning local APICs
2016 * are needed on every CPU up until machine_halt/restart/poweroff.
2017 */
2018
2019static struct sysdev_class lapic_sysclass = {
2020 .name = "lapic",
2021 .resume = lapic_resume,
2022 .suspend = lapic_suspend,
2023};
2024
2025static struct sys_device device_lapic = {
2026 .id = 0,
2027 .cls = &lapic_sysclass,
2028};
2029
2030static void __cpuinit apic_pm_activate(void)
2031{
2032 apic_pm_state.active = 1;
2033}
2034
2035static int __init init_lapic_sysfs(void)
2036{
2037 int error;
2038
2039 if (!cpu_has_apic)
2040 return 0;
2041 /* XXX: remove suspend/resume procs if !apic_pm_state.active? */
2042
2043 error = sysdev_class_register(&lapic_sysclass);
2044 if (!error)
2045 error = sysdev_register(&device_lapic);
2046 return error;
2047}
2048device_initcall(init_lapic_sysfs);
2049
2050#else /* CONFIG_PM */
2051
2052static void apic_pm_activate(void) { }
2053
2054#endif /* CONFIG_PM */
2055
2056#ifdef CONFIG_X86_64
2057/*
2058 * apic_is_clustered_box() -- Check if we can expect good TSC
2059 *
2060 * Thus far, the major user of this is IBM's Summit2 series:
2061 *
2062 * Clustered boxes may have unsynced TSC problems if they are
2063 * multi-chassis. Use available data to take a good guess.
2064 * If in doubt, go HPET.
2065 */
2066__cpuinit int apic_is_clustered_box(void)
2067{
2068 int i, clusters, zeros;
2069 unsigned id;
2070 u16 *bios_cpu_apicid;
2071 DECLARE_BITMAP(clustermap, NUM_APIC_CLUSTERS);
2072
2073 /*
2074 * there is not this kind of box with AMD CPU yet.
2075 * Some AMD box with quadcore cpu and 8 sockets apicid
2076 * will be [4, 0x23] or [8, 0x27] could be thought to
2077 * vsmp box still need checking...
2078 */
2079 if ((boot_cpu_data.x86_vendor == X86_VENDOR_AMD) && !is_vsmp_box())
2080 return 0;
2081
2082 bios_cpu_apicid = early_per_cpu_ptr(x86_bios_cpu_apicid);
2083 bitmap_zero(clustermap, NUM_APIC_CLUSTERS);
2084
2085 for (i = 0; i < nr_cpu_ids; i++) {
2086 /* are we being called early in kernel startup? */
2087 if (bios_cpu_apicid) {
2088 id = bios_cpu_apicid[i];
2089 } else if (i < nr_cpu_ids) {
2090 if (cpu_present(i))
2091 id = per_cpu(x86_bios_cpu_apicid, i);
2092 else
2093 continue;
2094 } else
2095 break;
2096
2097 if (id != BAD_APICID)
2098 __set_bit(APIC_CLUSTERID(id), clustermap);
2099 }
2100
2101 /* Problem: Partially populated chassis may not have CPUs in some of
2102 * the APIC clusters they have been allocated. Only present CPUs have
2103 * x86_bios_cpu_apicid entries, thus causing zeroes in the bitmap.
2104 * Since clusters are allocated sequentially, count zeros only if
2105 * they are bounded by ones.
2106 */
2107 clusters = 0;
2108 zeros = 0;
2109 for (i = 0; i < NUM_APIC_CLUSTERS; i++) {
2110 if (test_bit(i, clustermap)) {
2111 clusters += 1 + zeros;
2112 zeros = 0;
2113 } else
2114 ++zeros;
2115 }
2116
2117 /* ScaleMP vSMPowered boxes have one cluster per board and TSCs are
2118 * not guaranteed to be synced between boards
2119 */
2120 if (is_vsmp_box() && clusters > 1)
2121 return 1;
2122
2123 /*
2124 * If clusters > 2, then should be multi-chassis.
2125 * May have to revisit this when multi-core + hyperthreaded CPUs come
2126 * out, but AFAIK this will work even for them.
2127 */
2128 return (clusters > 2);
2129}
2130#endif
2131
2132/*
2133 * APIC command line parameters
2134 */
2135static int __init setup_disableapic(char *arg)
2136{
2137 disable_apic = 1;
2138 setup_clear_cpu_cap(X86_FEATURE_APIC);
2139 return 0;
2140}
2141early_param("disableapic", setup_disableapic);
2142
2143/* same as disableapic, for compatibility */
2144static int __init setup_nolapic(char *arg)
2145{
2146 return setup_disableapic(arg);
2147}
2148early_param("nolapic", setup_nolapic);
2149
2150static int __init parse_lapic_timer_c2_ok(char *arg)
2151{
2152 local_apic_timer_c2_ok = 1;
2153 return 0;
2154}
2155early_param("lapic_timer_c2_ok", parse_lapic_timer_c2_ok);
2156
2157static int __init parse_disable_apic_timer(char *arg)
2158{
2159 disable_apic_timer = 1;
2160 return 0;
2161}
2162early_param("noapictimer", parse_disable_apic_timer);
2163
2164static int __init parse_nolapic_timer(char *arg)
2165{
2166 disable_apic_timer = 1;
2167 return 0;
2168}
2169early_param("nolapic_timer", parse_nolapic_timer);
2170
2171static int __init apic_set_verbosity(char *arg)
2172{
2173 if (!arg) {
2174#ifdef CONFIG_X86_64
2175 skip_ioapic_setup = 0;
2176 return 0;
2177#endif
2178 return -EINVAL;
2179 }
2180
2181 if (strcmp("debug", arg) == 0)
2182 apic_verbosity = APIC_DEBUG;
2183 else if (strcmp("verbose", arg) == 0)
2184 apic_verbosity = APIC_VERBOSE;
2185 else {
2186 pr_warning("APIC Verbosity level %s not recognised"
2187 " use apic=verbose or apic=debug\n", arg);
2188 return -EINVAL;
2189 }
2190
2191 return 0;
2192}
2193early_param("apic", apic_set_verbosity);
2194
2195static int __init lapic_insert_resource(void)
2196{
2197 if (!apic_phys)
2198 return -1;
2199
2200 /* Put local APIC into the resource map. */
2201 lapic_resource.start = apic_phys;
2202 lapic_resource.end = lapic_resource.start + PAGE_SIZE - 1;
2203 insert_resource(&iomem_resource, &lapic_resource);
2204
2205 return 0;
2206}
2207
2208/*
2209 * need call insert after e820_reserve_resources()
2210 * that is using request_resource
2211 */
2212late_initcall(lapic_insert_resource);
diff --git a/arch/x86/kernel/apic/apic_64.c b/arch/x86/kernel/apic/apic_64.c
new file mode 100644
index 000000000000..70935dd904db
--- /dev/null
+++ b/arch/x86/kernel/apic/apic_64.c
@@ -0,0 +1,89 @@
1/*
2 * Copyright 2004 James Cleverdon, IBM.
3 * Subject to the GNU Public License, v.2
4 *
5 * Generic APIC sub-arch probe layer.
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/threads.h>
12#include <linux/cpumask.h>
13#include <linux/string.h>
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/ctype.h>
17#include <linux/init.h>
18#include <linux/hardirq.h>
19#include <linux/dmar.h>
20
21#include <asm/smp.h>
22#include <asm/apic.h>
23#include <asm/ipi.h>
24#include <asm/setup.h>
25
26extern struct apic apic_flat;
27extern struct apic apic_physflat;
28extern struct apic apic_x2xpic_uv_x;
29extern struct apic apic_x2apic_phys;
30extern struct apic apic_x2apic_cluster;
31
32struct apic __read_mostly *apic = &apic_flat;
33EXPORT_SYMBOL_GPL(apic);
34
35static struct apic *apic_probe[] __initdata = {
36#ifdef CONFIG_X86_UV
37 &apic_x2apic_uv_x,
38#endif
39#ifdef CONFIG_X86_X2APIC
40 &apic_x2apic_phys,
41 &apic_x2apic_cluster,
42#endif
43 &apic_physflat,
44 NULL,
45};
46
47/*
48 * Check the APIC IDs in bios_cpu_apicid and choose the APIC mode.
49 */
50void __init default_setup_apic_routing(void)
51{
52#ifdef CONFIG_X86_X2APIC
53 if (apic == &apic_x2apic_phys || apic == &apic_x2apic_cluster) {
54 if (!intr_remapping_enabled)
55 apic = &apic_flat;
56 }
57#endif
58
59 if (apic == &apic_flat) {
60 if (max_physical_apicid >= 8)
61 apic = &apic_physflat;
62 printk(KERN_INFO "Setting APIC routing to %s\n", apic->name);
63 }
64
65 if (x86_quirks->update_apic)
66 x86_quirks->update_apic();
67}
68
69/* Same for both flat and physical. */
70
71void apic_send_IPI_self(int vector)
72{
73 __default_send_IPI_shortcut(APIC_DEST_SELF, vector, APIC_DEST_PHYSICAL);
74}
75
76int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
77{
78 int i;
79
80 for (i = 0; apic_probe[i]; ++i) {
81 if (apic_probe[i]->acpi_madt_oem_check(oem_id, oem_table_id)) {
82 apic = apic_probe[i];
83 printk(KERN_INFO "Setting APIC routing to %s.\n",
84 apic->name);
85 return 1;
86 }
87 }
88 return 0;
89}
diff --git a/arch/x86/kernel/apic/apic_flat_64.c b/arch/x86/kernel/apic/apic_flat_64.c
new file mode 100644
index 000000000000..3b002995e145
--- /dev/null
+++ b/arch/x86/kernel/apic/apic_flat_64.c
@@ -0,0 +1,389 @@
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
27static int flat_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
28{
29 return 1;
30}
31
32static const struct cpumask *flat_target_cpus(void)
33{
34 return cpu_online_mask;
35}
36
37static 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 */
58static 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
71static 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
80static 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
87static 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
99static 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
122static 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
132static 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
141static unsigned long set_apic_id(unsigned int id)
142{
143 unsigned long x;
144
145 x = ((id & 0xFFu)<<24);
146 return x;
147}
148
149static 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
157static int flat_apic_id_registered(void)
158{
159 return physid_isset(read_xapic_id(), phys_cpu_present_map);
160}
161
162static unsigned int flat_cpu_mask_to_apicid(const struct cpumask *cpumask)
163{
164 return cpumask_bits(cpumask)[0] & APIC_ALL_CPUS;
165}
166
167static unsigned int flat_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
168 const struct cpumask *andmask)
169{
170 unsigned long mask1 = cpumask_bits(cpumask)[0] & APIC_ALL_CPUS;
171 unsigned long mask2 = cpumask_bits(andmask)[0] & APIC_ALL_CPUS;
172
173 return mask1 & mask2;
174}
175
176static int flat_phys_pkg_id(int initial_apic_id, int index_msb)
177{
178 return hard_smp_processor_id() >> index_msb;
179}
180
181struct apic apic_flat = {
182 .name = "flat",
183 .probe = NULL,
184 .acpi_madt_oem_check = flat_acpi_madt_oem_check,
185 .apic_id_registered = flat_apic_id_registered,
186
187 .irq_delivery_mode = dest_LowestPrio,
188 .irq_dest_mode = 1, /* logical */
189
190 .target_cpus = flat_target_cpus,
191 .disable_esr = 0,
192 .dest_logical = APIC_DEST_LOGICAL,
193 .check_apicid_used = NULL,
194 .check_apicid_present = NULL,
195
196 .vector_allocation_domain = flat_vector_allocation_domain,
197 .init_apic_ldr = flat_init_apic_ldr,
198
199 .ioapic_phys_id_map = NULL,
200 .setup_apic_routing = NULL,
201 .multi_timer_check = NULL,
202 .apicid_to_node = NULL,
203 .cpu_to_logical_apicid = NULL,
204 .cpu_present_to_apicid = default_cpu_present_to_apicid,
205 .apicid_to_cpu_present = NULL,
206 .setup_portio_remap = NULL,
207 .check_phys_apicid_present = default_check_phys_apicid_present,
208 .enable_apic_mode = NULL,
209 .phys_pkg_id = flat_phys_pkg_id,
210 .mps_oem_check = NULL,
211
212 .get_apic_id = flat_get_apic_id,
213 .set_apic_id = set_apic_id,
214 .apic_id_mask = 0xFFu << 24,
215
216 .cpu_mask_to_apicid = flat_cpu_mask_to_apicid,
217 .cpu_mask_to_apicid_and = flat_cpu_mask_to_apicid_and,
218
219 .send_IPI_mask = flat_send_IPI_mask,
220 .send_IPI_mask_allbutself = flat_send_IPI_mask_allbutself,
221 .send_IPI_allbutself = flat_send_IPI_allbutself,
222 .send_IPI_all = flat_send_IPI_all,
223 .send_IPI_self = apic_send_IPI_self,
224
225 .wakeup_cpu = NULL,
226 .trampoline_phys_low = DEFAULT_TRAMPOLINE_PHYS_LOW,
227 .trampoline_phys_high = DEFAULT_TRAMPOLINE_PHYS_HIGH,
228 .wait_for_init_deassert = NULL,
229 .smp_callin_clear_local_apic = NULL,
230 .inquire_remote_apic = NULL,
231
232 .read = native_apic_mem_read,
233 .write = native_apic_mem_write,
234 .icr_read = native_apic_icr_read,
235 .icr_write = native_apic_icr_write,
236 .wait_icr_idle = native_apic_wait_icr_idle,
237 .safe_wait_icr_idle = native_safe_apic_wait_icr_idle,
238};
239
240/*
241 * Physflat mode is used when there are more than 8 CPUs on a AMD system.
242 * We cannot use logical delivery in this case because the mask
243 * overflows, so use physical mode.
244 */
245static int physflat_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
246{
247#ifdef CONFIG_ACPI
248 /*
249 * Quirk: some x86_64 machines can only use physical APIC mode
250 * regardless of how many processors are present (x86_64 ES7000
251 * is an example).
252 */
253 if (acpi_gbl_FADT.header.revision > FADT2_REVISION_ID &&
254 (acpi_gbl_FADT.flags & ACPI_FADT_APIC_PHYSICAL)) {
255 printk(KERN_DEBUG "system APIC only can use physical flat");
256 return 1;
257 }
258#endif
259
260 return 0;
261}
262
263static const struct cpumask *physflat_target_cpus(void)
264{
265 return cpu_online_mask;
266}
267
268static void physflat_vector_allocation_domain(int cpu, struct cpumask *retmask)
269{
270 cpumask_clear(retmask);
271 cpumask_set_cpu(cpu, retmask);
272}
273
274static void physflat_send_IPI_mask(const struct cpumask *cpumask, int vector)
275{
276 default_send_IPI_mask_sequence_phys(cpumask, vector);
277}
278
279static void physflat_send_IPI_mask_allbutself(const struct cpumask *cpumask,
280 int vector)
281{
282 default_send_IPI_mask_allbutself_phys(cpumask, vector);
283}
284
285static void physflat_send_IPI_allbutself(int vector)
286{
287 default_send_IPI_mask_allbutself_phys(cpu_online_mask, vector);
288}
289
290static void physflat_send_IPI_all(int vector)
291{
292 physflat_send_IPI_mask(cpu_online_mask, vector);
293}
294
295static unsigned int physflat_cpu_mask_to_apicid(const struct cpumask *cpumask)
296{
297 int cpu;
298
299 /*
300 * We're using fixed IRQ delivery, can only return one phys APIC ID.
301 * May as well be the first.
302 */
303 cpu = cpumask_first(cpumask);
304 if ((unsigned)cpu < nr_cpu_ids)
305 return per_cpu(x86_cpu_to_apicid, cpu);
306 else
307 return BAD_APICID;
308}
309
310static unsigned int
311physflat_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
312 const struct cpumask *andmask)
313{
314 int cpu;
315
316 /*
317 * We're using fixed IRQ delivery, can only return one phys APIC ID.
318 * May as well be the first.
319 */
320 for_each_cpu_and(cpu, cpumask, andmask) {
321 if (cpumask_test_cpu(cpu, cpu_online_mask))
322 break;
323 }
324 if (cpu < nr_cpu_ids)
325 return per_cpu(x86_cpu_to_apicid, cpu);
326
327 return BAD_APICID;
328}
329
330struct apic apic_physflat = {
331
332 .name = "physical flat",
333 .probe = NULL,
334 .acpi_madt_oem_check = physflat_acpi_madt_oem_check,
335 .apic_id_registered = flat_apic_id_registered,
336
337 .irq_delivery_mode = dest_Fixed,
338 .irq_dest_mode = 0, /* physical */
339
340 .target_cpus = physflat_target_cpus,
341 .disable_esr = 0,
342 .dest_logical = 0,
343 .check_apicid_used = NULL,
344 .check_apicid_present = NULL,
345
346 .vector_allocation_domain = physflat_vector_allocation_domain,
347 /* not needed, but shouldn't hurt: */
348 .init_apic_ldr = flat_init_apic_ldr,
349
350 .ioapic_phys_id_map = NULL,
351 .setup_apic_routing = NULL,
352 .multi_timer_check = NULL,
353 .apicid_to_node = NULL,
354 .cpu_to_logical_apicid = NULL,
355 .cpu_present_to_apicid = default_cpu_present_to_apicid,
356 .apicid_to_cpu_present = NULL,
357 .setup_portio_remap = NULL,
358 .check_phys_apicid_present = default_check_phys_apicid_present,
359 .enable_apic_mode = NULL,
360 .phys_pkg_id = flat_phys_pkg_id,
361 .mps_oem_check = NULL,
362
363 .get_apic_id = flat_get_apic_id,
364 .set_apic_id = set_apic_id,
365 .apic_id_mask = 0xFFu << 24,
366
367 .cpu_mask_to_apicid = physflat_cpu_mask_to_apicid,
368 .cpu_mask_to_apicid_and = physflat_cpu_mask_to_apicid_and,
369
370 .send_IPI_mask = physflat_send_IPI_mask,
371 .send_IPI_mask_allbutself = physflat_send_IPI_mask_allbutself,
372 .send_IPI_allbutself = physflat_send_IPI_allbutself,
373 .send_IPI_all = physflat_send_IPI_all,
374 .send_IPI_self = apic_send_IPI_self,
375
376 .wakeup_cpu = NULL,
377 .trampoline_phys_low = DEFAULT_TRAMPOLINE_PHYS_LOW,
378 .trampoline_phys_high = DEFAULT_TRAMPOLINE_PHYS_HIGH,
379 .wait_for_init_deassert = NULL,
380 .smp_callin_clear_local_apic = NULL,
381 .inquire_remote_apic = NULL,
382
383 .read = native_apic_mem_read,
384 .write = native_apic_mem_write,
385 .icr_read = native_apic_icr_read,
386 .icr_write = native_apic_icr_write,
387 .wait_icr_idle = native_apic_wait_icr_idle,
388 .safe_wait_icr_idle = native_safe_apic_wait_icr_idle,
389};
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
new file mode 100644
index 000000000000..00e6071cefc4
--- /dev/null
+++ b/arch/x86/kernel/apic/io_apic.c
@@ -0,0 +1,4160 @@
1/*
2 * Intel IO-APIC support for multi-Pentium hosts.
3 *
4 * Copyright (C) 1997, 1998, 1999, 2000, 2009 Ingo Molnar, Hajnalka Szabo
5 *
6 * Many thanks to Stig Venaas for trying out countless experimental
7 * patches and reporting/debugging problems patiently!
8 *
9 * (c) 1999, Multiple IO-APIC support, developed by
10 * Ken-ichi Yaku <yaku@css1.kbnes.nec.co.jp> and
11 * Hidemi Kishimoto <kisimoto@css1.kbnes.nec.co.jp>,
12 * further tested and cleaned up by Zach Brown <zab@redhat.com>
13 * and Ingo Molnar <mingo@redhat.com>
14 *
15 * Fixes
16 * Maciej W. Rozycki : Bits for genuine 82489DX APICs;
17 * thanks to Eric Gilmore
18 * and Rolf G. Tews
19 * for testing these extensively
20 * Paul Diefenbaugh : Added full ACPI support
21 */
22
23#include <linux/mm.h>
24#include <linux/interrupt.h>
25#include <linux/init.h>
26#include <linux/delay.h>
27#include <linux/sched.h>
28#include <linux/pci.h>
29#include <linux/mc146818rtc.h>
30#include <linux/compiler.h>
31#include <linux/acpi.h>
32#include <linux/module.h>
33#include <linux/sysdev.h>
34#include <linux/msi.h>
35#include <linux/htirq.h>
36#include <linux/freezer.h>
37#include <linux/kthread.h>
38#include <linux/jiffies.h> /* time_after() */
39#ifdef CONFIG_ACPI
40#include <acpi/acpi_bus.h>
41#endif
42#include <linux/bootmem.h>
43#include <linux/dmar.h>
44#include <linux/hpet.h>
45
46#include <asm/idle.h>
47#include <asm/io.h>
48#include <asm/smp.h>
49#include <asm/cpu.h>
50#include <asm/desc.h>
51#include <asm/proto.h>
52#include <asm/acpi.h>
53#include <asm/dma.h>
54#include <asm/timer.h>
55#include <asm/i8259.h>
56#include <asm/nmi.h>
57#include <asm/msidef.h>
58#include <asm/hypertransport.h>
59#include <asm/setup.h>
60#include <asm/irq_remapping.h>
61#include <asm/hpet.h>
62#include <asm/uv/uv_hub.h>
63#include <asm/uv/uv_irq.h>
64
65#include <asm/apic.h>
66
67#define __apicdebuginit(type) static type __init
68
69/*
70 * Is the SiS APIC rmw bug present ?
71 * -1 = don't know, 0 = no, 1 = yes
72 */
73int sis_apic_bug = -1;
74
75static DEFINE_SPINLOCK(ioapic_lock);
76static DEFINE_SPINLOCK(vector_lock);
77
78/*
79 * # of IRQ routing registers
80 */
81int nr_ioapic_registers[MAX_IO_APICS];
82
83/* I/O APIC entries */
84struct mpc_ioapic mp_ioapics[MAX_IO_APICS];
85int nr_ioapics;
86
87/* MP IRQ source entries */
88struct mpc_intsrc mp_irqs[MAX_IRQ_SOURCES];
89
90/* # of MP IRQ source entries */
91int mp_irq_entries;
92
93#if defined (CONFIG_MCA) || defined (CONFIG_EISA)
94int mp_bus_id_to_type[MAX_MP_BUSSES];
95#endif
96
97DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
98
99int skip_ioapic_setup;
100
101void arch_disable_smp_support(void)
102{
103#ifdef CONFIG_PCI
104 noioapicquirk = 1;
105 noioapicreroute = -1;
106#endif
107 skip_ioapic_setup = 1;
108}
109
110static int __init parse_noapic(char *str)
111{
112 /* disable IO-APIC */
113 arch_disable_smp_support();
114 return 0;
115}
116early_param("noapic", parse_noapic);
117
118struct irq_pin_list;
119
120/*
121 * This is performance-critical, we want to do it O(1)
122 *
123 * the indexing order of this array favors 1:1 mappings
124 * between pins and IRQs.
125 */
126
127struct irq_pin_list {
128 int apic, pin;
129 struct irq_pin_list *next;
130};
131
132static struct irq_pin_list *get_one_free_irq_2_pin(int cpu)
133{
134 struct irq_pin_list *pin;
135 int node;
136
137 node = cpu_to_node(cpu);
138
139 pin = kzalloc_node(sizeof(*pin), GFP_ATOMIC, node);
140
141 return pin;
142}
143
144struct irq_cfg {
145 struct irq_pin_list *irq_2_pin;
146 cpumask_var_t domain;
147 cpumask_var_t old_domain;
148 unsigned move_cleanup_count;
149 u8 vector;
150 u8 move_in_progress : 1;
151#ifdef CONFIG_NUMA_MIGRATE_IRQ_DESC
152 u8 move_desc_pending : 1;
153#endif
154};
155
156/* irq_cfg is indexed by the sum of all RTEs in all I/O APICs. */
157#ifdef CONFIG_SPARSE_IRQ
158static struct irq_cfg irq_cfgx[] = {
159#else
160static struct irq_cfg irq_cfgx[NR_IRQS] = {
161#endif
162 [0] = { .vector = IRQ0_VECTOR, },
163 [1] = { .vector = IRQ1_VECTOR, },
164 [2] = { .vector = IRQ2_VECTOR, },
165 [3] = { .vector = IRQ3_VECTOR, },
166 [4] = { .vector = IRQ4_VECTOR, },
167 [5] = { .vector = IRQ5_VECTOR, },
168 [6] = { .vector = IRQ6_VECTOR, },
169 [7] = { .vector = IRQ7_VECTOR, },
170 [8] = { .vector = IRQ8_VECTOR, },
171 [9] = { .vector = IRQ9_VECTOR, },
172 [10] = { .vector = IRQ10_VECTOR, },
173 [11] = { .vector = IRQ11_VECTOR, },
174 [12] = { .vector = IRQ12_VECTOR, },
175 [13] = { .vector = IRQ13_VECTOR, },
176 [14] = { .vector = IRQ14_VECTOR, },
177 [15] = { .vector = IRQ15_VECTOR, },
178};
179
180int __init arch_early_irq_init(void)
181{
182 struct irq_cfg *cfg;
183 struct irq_desc *desc;
184 int count;
185 int i;
186
187 cfg = irq_cfgx;
188 count = ARRAY_SIZE(irq_cfgx);
189
190 for (i = 0; i < count; i++) {
191 desc = irq_to_desc(i);
192 desc->chip_data = &cfg[i];
193 alloc_bootmem_cpumask_var(&cfg[i].domain);
194 alloc_bootmem_cpumask_var(&cfg[i].old_domain);
195 if (i < NR_IRQS_LEGACY)
196 cpumask_setall(cfg[i].domain);
197 }
198
199 return 0;
200}
201
202#ifdef CONFIG_SPARSE_IRQ
203static struct irq_cfg *irq_cfg(unsigned int irq)
204{
205 struct irq_cfg *cfg = NULL;
206 struct irq_desc *desc;
207
208 desc = irq_to_desc(irq);
209 if (desc)
210 cfg = desc->chip_data;
211
212 return cfg;
213}
214
215static struct irq_cfg *get_one_free_irq_cfg(int cpu)
216{
217 struct irq_cfg *cfg;
218 int node;
219
220 node = cpu_to_node(cpu);
221
222 cfg = kzalloc_node(sizeof(*cfg), GFP_ATOMIC, node);
223 if (cfg) {
224 if (!alloc_cpumask_var_node(&cfg->domain, GFP_ATOMIC, node)) {
225 kfree(cfg);
226 cfg = NULL;
227 } else if (!alloc_cpumask_var_node(&cfg->old_domain,
228 GFP_ATOMIC, node)) {
229 free_cpumask_var(cfg->domain);
230 kfree(cfg);
231 cfg = NULL;
232 } else {
233 cpumask_clear(cfg->domain);
234 cpumask_clear(cfg->old_domain);
235 }
236 }
237
238 return cfg;
239}
240
241int arch_init_chip_data(struct irq_desc *desc, int cpu)
242{
243 struct irq_cfg *cfg;
244
245 cfg = desc->chip_data;
246 if (!cfg) {
247 desc->chip_data = get_one_free_irq_cfg(cpu);
248 if (!desc->chip_data) {
249 printk(KERN_ERR "can not alloc irq_cfg\n");
250 BUG_ON(1);
251 }
252 }
253
254 return 0;
255}
256
257#ifdef CONFIG_NUMA_MIGRATE_IRQ_DESC
258
259static void
260init_copy_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg, int cpu)
261{
262 struct irq_pin_list *old_entry, *head, *tail, *entry;
263
264 cfg->irq_2_pin = NULL;
265 old_entry = old_cfg->irq_2_pin;
266 if (!old_entry)
267 return;
268
269 entry = get_one_free_irq_2_pin(cpu);
270 if (!entry)
271 return;
272
273 entry->apic = old_entry->apic;
274 entry->pin = old_entry->pin;
275 head = entry;
276 tail = entry;
277 old_entry = old_entry->next;
278 while (old_entry) {
279 entry = get_one_free_irq_2_pin(cpu);
280 if (!entry) {
281 entry = head;
282 while (entry) {
283 head = entry->next;
284 kfree(entry);
285 entry = head;
286 }
287 /* still use the old one */
288 return;
289 }
290 entry->apic = old_entry->apic;
291 entry->pin = old_entry->pin;
292 tail->next = entry;
293 tail = entry;
294 old_entry = old_entry->next;
295 }
296
297 tail->next = NULL;
298 cfg->irq_2_pin = head;
299}
300
301static void free_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg)
302{
303 struct irq_pin_list *entry, *next;
304
305 if (old_cfg->irq_2_pin == cfg->irq_2_pin)
306 return;
307
308 entry = old_cfg->irq_2_pin;
309
310 while (entry) {
311 next = entry->next;
312 kfree(entry);
313 entry = next;
314 }
315 old_cfg->irq_2_pin = NULL;
316}
317
318void arch_init_copy_chip_data(struct irq_desc *old_desc,
319 struct irq_desc *desc, int cpu)
320{
321 struct irq_cfg *cfg;
322 struct irq_cfg *old_cfg;
323
324 cfg = get_one_free_irq_cfg(cpu);
325
326 if (!cfg)
327 return;
328
329 desc->chip_data = cfg;
330
331 old_cfg = old_desc->chip_data;
332
333 memcpy(cfg, old_cfg, sizeof(struct irq_cfg));
334
335 init_copy_irq_2_pin(old_cfg, cfg, cpu);
336}
337
338static void free_irq_cfg(struct irq_cfg *old_cfg)
339{
340 kfree(old_cfg);
341}
342
343void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc)
344{
345 struct irq_cfg *old_cfg, *cfg;
346
347 old_cfg = old_desc->chip_data;
348 cfg = desc->chip_data;
349
350 if (old_cfg == cfg)
351 return;
352
353 if (old_cfg) {
354 free_irq_2_pin(old_cfg, cfg);
355 free_irq_cfg(old_cfg);
356 old_desc->chip_data = NULL;
357 }
358}
359
360static void
361set_extra_move_desc(struct irq_desc *desc, const struct cpumask *mask)
362{
363 struct irq_cfg *cfg = desc->chip_data;
364
365 if (!cfg->move_in_progress) {
366 /* it means that domain is not changed */
367 if (!cpumask_intersects(desc->affinity, mask))
368 cfg->move_desc_pending = 1;
369 }
370}
371#endif
372
373#else
374static struct irq_cfg *irq_cfg(unsigned int irq)
375{
376 return irq < nr_irqs ? irq_cfgx + irq : NULL;
377}
378
379#endif
380
381#ifndef CONFIG_NUMA_MIGRATE_IRQ_DESC
382static inline void
383set_extra_move_desc(struct irq_desc *desc, const struct cpumask *mask)
384{
385}
386#endif
387
388struct io_apic {
389 unsigned int index;
390 unsigned int unused[3];
391 unsigned int data;
392};
393
394static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx)
395{
396 return (void __iomem *) __fix_to_virt(FIX_IO_APIC_BASE_0 + idx)
397 + (mp_ioapics[idx].apicaddr & ~PAGE_MASK);
398}
399
400static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
401{
402 struct io_apic __iomem *io_apic = io_apic_base(apic);
403 writel(reg, &io_apic->index);
404 return readl(&io_apic->data);
405}
406
407static inline void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value)
408{
409 struct io_apic __iomem *io_apic = io_apic_base(apic);
410 writel(reg, &io_apic->index);
411 writel(value, &io_apic->data);
412}
413
414/*
415 * Re-write a value: to be used for read-modify-write
416 * cycles where the read already set up the index register.
417 *
418 * Older SiS APIC requires we rewrite the index register
419 */
420static inline void io_apic_modify(unsigned int apic, unsigned int reg, unsigned int value)
421{
422 struct io_apic __iomem *io_apic = io_apic_base(apic);
423
424 if (sis_apic_bug)
425 writel(reg, &io_apic->index);
426 writel(value, &io_apic->data);
427}
428
429static bool io_apic_level_ack_pending(struct irq_cfg *cfg)
430{
431 struct irq_pin_list *entry;
432 unsigned long flags;
433
434 spin_lock_irqsave(&ioapic_lock, flags);
435 entry = cfg->irq_2_pin;
436 for (;;) {
437 unsigned int reg;
438 int pin;
439
440 if (!entry)
441 break;
442 pin = entry->pin;
443 reg = io_apic_read(entry->apic, 0x10 + pin*2);
444 /* Is the remote IRR bit set? */
445 if (reg & IO_APIC_REDIR_REMOTE_IRR) {
446 spin_unlock_irqrestore(&ioapic_lock, flags);
447 return true;
448 }
449 if (!entry->next)
450 break;
451 entry = entry->next;
452 }
453 spin_unlock_irqrestore(&ioapic_lock, flags);
454
455 return false;
456}
457
458union entry_union {
459 struct { u32 w1, w2; };
460 struct IO_APIC_route_entry entry;
461};
462
463static struct IO_APIC_route_entry ioapic_read_entry(int apic, int pin)
464{
465 union entry_union eu;
466 unsigned long flags;
467 spin_lock_irqsave(&ioapic_lock, flags);
468 eu.w1 = io_apic_read(apic, 0x10 + 2 * pin);
469 eu.w2 = io_apic_read(apic, 0x11 + 2 * pin);
470 spin_unlock_irqrestore(&ioapic_lock, flags);
471 return eu.entry;
472}
473
474/*
475 * When we write a new IO APIC routing entry, we need to write the high
476 * word first! If the mask bit in the low word is clear, we will enable
477 * the interrupt, and we need to make sure the entry is fully populated
478 * before that happens.
479 */
480static void
481__ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
482{
483 union entry_union eu;
484 eu.entry = e;
485 io_apic_write(apic, 0x11 + 2*pin, eu.w2);
486 io_apic_write(apic, 0x10 + 2*pin, eu.w1);
487}
488
489void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
490{
491 unsigned long flags;
492 spin_lock_irqsave(&ioapic_lock, flags);
493 __ioapic_write_entry(apic, pin, e);
494 spin_unlock_irqrestore(&ioapic_lock, flags);
495}
496
497/*
498 * When we mask an IO APIC routing entry, we need to write the low
499 * word first, in order to set the mask bit before we change the
500 * high bits!
501 */
502static void ioapic_mask_entry(int apic, int pin)
503{
504 unsigned long flags;
505 union entry_union eu = { .entry.mask = 1 };
506
507 spin_lock_irqsave(&ioapic_lock, flags);
508 io_apic_write(apic, 0x10 + 2*pin, eu.w1);
509 io_apic_write(apic, 0x11 + 2*pin, eu.w2);
510 spin_unlock_irqrestore(&ioapic_lock, flags);
511}
512
513#ifdef CONFIG_SMP
514static void send_cleanup_vector(struct irq_cfg *cfg)
515{
516 cpumask_var_t cleanup_mask;
517
518 if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
519 unsigned int i;
520 cfg->move_cleanup_count = 0;
521 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
522 cfg->move_cleanup_count++;
523 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
524 apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
525 } else {
526 cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
527 cfg->move_cleanup_count = cpumask_weight(cleanup_mask);
528 apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
529 free_cpumask_var(cleanup_mask);
530 }
531 cfg->move_in_progress = 0;
532}
533
534static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq_cfg *cfg)
535{
536 int apic, pin;
537 struct irq_pin_list *entry;
538 u8 vector = cfg->vector;
539
540 entry = cfg->irq_2_pin;
541 for (;;) {
542 unsigned int reg;
543
544 if (!entry)
545 break;
546
547 apic = entry->apic;
548 pin = entry->pin;
549#ifdef CONFIG_INTR_REMAP
550 /*
551 * With interrupt-remapping, destination information comes
552 * from interrupt-remapping table entry.
553 */
554 if (!irq_remapped(irq))
555 io_apic_write(apic, 0x11 + pin*2, dest);
556#else
557 io_apic_write(apic, 0x11 + pin*2, dest);
558#endif
559 reg = io_apic_read(apic, 0x10 + pin*2);
560 reg &= ~IO_APIC_REDIR_VECTOR_MASK;
561 reg |= vector;
562 io_apic_modify(apic, 0x10 + pin*2, reg);
563 if (!entry->next)
564 break;
565 entry = entry->next;
566 }
567}
568
569static int
570assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask);
571
572/*
573 * Either sets desc->affinity to a valid value, and returns
574 * ->cpu_mask_to_apicid of that, or returns BAD_APICID and
575 * leaves desc->affinity untouched.
576 */
577static unsigned int
578set_desc_affinity(struct irq_desc *desc, const struct cpumask *mask)
579{
580 struct irq_cfg *cfg;
581 unsigned int irq;
582
583 if (!cpumask_intersects(mask, cpu_online_mask))
584 return BAD_APICID;
585
586 irq = desc->irq;
587 cfg = desc->chip_data;
588 if (assign_irq_vector(irq, cfg, mask))
589 return BAD_APICID;
590
591 cpumask_and(desc->affinity, cfg->domain, mask);
592 set_extra_move_desc(desc, mask);
593
594 return apic->cpu_mask_to_apicid_and(desc->affinity, cpu_online_mask);
595}
596
597static void
598set_ioapic_affinity_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
599{
600 struct irq_cfg *cfg;
601 unsigned long flags;
602 unsigned int dest;
603 unsigned int irq;
604
605 irq = desc->irq;
606 cfg = desc->chip_data;
607
608 spin_lock_irqsave(&ioapic_lock, flags);
609 dest = set_desc_affinity(desc, mask);
610 if (dest != BAD_APICID) {
611 /* Only the high 8 bits are valid. */
612 dest = SET_APIC_LOGICAL_ID(dest);
613 __target_IO_APIC_irq(irq, dest, cfg);
614 }
615 spin_unlock_irqrestore(&ioapic_lock, flags);
616}
617
618static void
619set_ioapic_affinity_irq(unsigned int irq, const struct cpumask *mask)
620{
621 struct irq_desc *desc;
622
623 desc = irq_to_desc(irq);
624
625 set_ioapic_affinity_irq_desc(desc, mask);
626}
627#endif /* CONFIG_SMP */
628
629/*
630 * The common case is 1:1 IRQ<->pin mappings. Sometimes there are
631 * shared ISA-space IRQs, so we have to support them. We are super
632 * fast in the common case, and fast for shared ISA-space IRQs.
633 */
634static void add_pin_to_irq_cpu(struct irq_cfg *cfg, int cpu, int apic, int pin)
635{
636 struct irq_pin_list *entry;
637
638 entry = cfg->irq_2_pin;
639 if (!entry) {
640 entry = get_one_free_irq_2_pin(cpu);
641 if (!entry) {
642 printk(KERN_ERR "can not alloc irq_2_pin to add %d - %d\n",
643 apic, pin);
644 return;
645 }
646 cfg->irq_2_pin = entry;
647 entry->apic = apic;
648 entry->pin = pin;
649 return;
650 }
651
652 while (entry->next) {
653 /* not again, please */
654 if (entry->apic == apic && entry->pin == pin)
655 return;
656
657 entry = entry->next;
658 }
659
660 entry->next = get_one_free_irq_2_pin(cpu);
661 entry = entry->next;
662 entry->apic = apic;
663 entry->pin = pin;
664}
665
666/*
667 * Reroute an IRQ to a different pin.
668 */
669static void __init replace_pin_at_irq_cpu(struct irq_cfg *cfg, int cpu,
670 int oldapic, int oldpin,
671 int newapic, int newpin)
672{
673 struct irq_pin_list *entry = cfg->irq_2_pin;
674 int replaced = 0;
675
676 while (entry) {
677 if (entry->apic == oldapic && entry->pin == oldpin) {
678 entry->apic = newapic;
679 entry->pin = newpin;
680 replaced = 1;
681 /* every one is different, right? */
682 break;
683 }
684 entry = entry->next;
685 }
686
687 /* why? call replace before add? */
688 if (!replaced)
689 add_pin_to_irq_cpu(cfg, cpu, newapic, newpin);
690}
691
692static inline void io_apic_modify_irq(struct irq_cfg *cfg,
693 int mask_and, int mask_or,
694 void (*final)(struct irq_pin_list *entry))
695{
696 int pin;
697 struct irq_pin_list *entry;
698
699 for (entry = cfg->irq_2_pin; entry != NULL; entry = entry->next) {
700 unsigned int reg;
701 pin = entry->pin;
702 reg = io_apic_read(entry->apic, 0x10 + pin * 2);
703 reg &= mask_and;
704 reg |= mask_or;
705 io_apic_modify(entry->apic, 0x10 + pin * 2, reg);
706 if (final)
707 final(entry);
708 }
709}
710
711static void __unmask_IO_APIC_irq(struct irq_cfg *cfg)
712{
713 io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED, 0, NULL);
714}
715
716#ifdef CONFIG_X86_64
717static void io_apic_sync(struct irq_pin_list *entry)
718{
719 /*
720 * Synchronize the IO-APIC and the CPU by doing
721 * a dummy read from the IO-APIC
722 */
723 struct io_apic __iomem *io_apic;
724 io_apic = io_apic_base(entry->apic);
725 readl(&io_apic->data);
726}
727
728static void __mask_IO_APIC_irq(struct irq_cfg *cfg)
729{
730 io_apic_modify_irq(cfg, ~0, IO_APIC_REDIR_MASKED, &io_apic_sync);
731}
732#else /* CONFIG_X86_32 */
733static void __mask_IO_APIC_irq(struct irq_cfg *cfg)
734{
735 io_apic_modify_irq(cfg, ~0, IO_APIC_REDIR_MASKED, NULL);
736}
737
738static void __mask_and_edge_IO_APIC_irq(struct irq_cfg *cfg)
739{
740 io_apic_modify_irq(cfg, ~IO_APIC_REDIR_LEVEL_TRIGGER,
741 IO_APIC_REDIR_MASKED, NULL);
742}
743
744static void __unmask_and_level_IO_APIC_irq(struct irq_cfg *cfg)
745{
746 io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED,
747 IO_APIC_REDIR_LEVEL_TRIGGER, NULL);
748}
749#endif /* CONFIG_X86_32 */
750
751static void mask_IO_APIC_irq_desc(struct irq_desc *desc)
752{
753 struct irq_cfg *cfg = desc->chip_data;
754 unsigned long flags;
755
756 BUG_ON(!cfg);
757
758 spin_lock_irqsave(&ioapic_lock, flags);
759 __mask_IO_APIC_irq(cfg);
760 spin_unlock_irqrestore(&ioapic_lock, flags);
761}
762
763static void unmask_IO_APIC_irq_desc(struct irq_desc *desc)
764{
765 struct irq_cfg *cfg = desc->chip_data;
766 unsigned long flags;
767
768 spin_lock_irqsave(&ioapic_lock, flags);
769 __unmask_IO_APIC_irq(cfg);
770 spin_unlock_irqrestore(&ioapic_lock, flags);
771}
772
773static void mask_IO_APIC_irq(unsigned int irq)
774{
775 struct irq_desc *desc = irq_to_desc(irq);
776
777 mask_IO_APIC_irq_desc(desc);
778}
779static void unmask_IO_APIC_irq(unsigned int irq)
780{
781 struct irq_desc *desc = irq_to_desc(irq);
782
783 unmask_IO_APIC_irq_desc(desc);
784}
785
786static void clear_IO_APIC_pin(unsigned int apic, unsigned int pin)
787{
788 struct IO_APIC_route_entry entry;
789
790 /* Check delivery_mode to be sure we're not clearing an SMI pin */
791 entry = ioapic_read_entry(apic, pin);
792 if (entry.delivery_mode == dest_SMI)
793 return;
794 /*
795 * Disable it in the IO-APIC irq-routing table:
796 */
797 ioapic_mask_entry(apic, pin);
798}
799
800static void clear_IO_APIC (void)
801{
802 int apic, pin;
803
804 for (apic = 0; apic < nr_ioapics; apic++)
805 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
806 clear_IO_APIC_pin(apic, pin);
807}
808
809#ifdef CONFIG_X86_32
810/*
811 * support for broken MP BIOSs, enables hand-redirection of PIRQ0-7 to
812 * specific CPU-side IRQs.
813 */
814
815#define MAX_PIRQS 8
816static int pirq_entries[MAX_PIRQS] = {
817 [0 ... MAX_PIRQS - 1] = -1
818};
819
820static int __init ioapic_pirq_setup(char *str)
821{
822 int i, max;
823 int ints[MAX_PIRQS+1];
824
825 get_options(str, ARRAY_SIZE(ints), ints);
826
827 apic_printk(APIC_VERBOSE, KERN_INFO
828 "PIRQ redirection, working around broken MP-BIOS.\n");
829 max = MAX_PIRQS;
830 if (ints[0] < MAX_PIRQS)
831 max = ints[0];
832
833 for (i = 0; i < max; i++) {
834 apic_printk(APIC_VERBOSE, KERN_DEBUG
835 "... PIRQ%d -> IRQ %d\n", i, ints[i+1]);
836 /*
837 * PIRQs are mapped upside down, usually.
838 */
839 pirq_entries[MAX_PIRQS-i-1] = ints[i+1];
840 }
841 return 1;
842}
843
844__setup("pirq=", ioapic_pirq_setup);
845#endif /* CONFIG_X86_32 */
846
847#ifdef CONFIG_INTR_REMAP
848/* I/O APIC RTE contents at the OS boot up */
849static struct IO_APIC_route_entry *early_ioapic_entries[MAX_IO_APICS];
850
851/*
852 * Saves and masks all the unmasked IO-APIC RTE's
853 */
854int save_mask_IO_APIC_setup(void)
855{
856 union IO_APIC_reg_01 reg_01;
857 unsigned long flags;
858 int apic, pin;
859
860 /*
861 * The number of IO-APIC IRQ registers (== #pins):
862 */
863 for (apic = 0; apic < nr_ioapics; apic++) {
864 spin_lock_irqsave(&ioapic_lock, flags);
865 reg_01.raw = io_apic_read(apic, 1);
866 spin_unlock_irqrestore(&ioapic_lock, flags);
867 nr_ioapic_registers[apic] = reg_01.bits.entries+1;
868 }
869
870 for (apic = 0; apic < nr_ioapics; apic++) {
871 early_ioapic_entries[apic] =
872 kzalloc(sizeof(struct IO_APIC_route_entry) *
873 nr_ioapic_registers[apic], GFP_KERNEL);
874 if (!early_ioapic_entries[apic])
875 goto nomem;
876 }
877
878 for (apic = 0; apic < nr_ioapics; apic++)
879 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
880 struct IO_APIC_route_entry entry;
881
882 entry = early_ioapic_entries[apic][pin] =
883 ioapic_read_entry(apic, pin);
884 if (!entry.mask) {
885 entry.mask = 1;
886 ioapic_write_entry(apic, pin, entry);
887 }
888 }
889
890 return 0;
891
892nomem:
893 while (apic >= 0)
894 kfree(early_ioapic_entries[apic--]);
895 memset(early_ioapic_entries, 0,
896 ARRAY_SIZE(early_ioapic_entries));
897
898 return -ENOMEM;
899}
900
901void restore_IO_APIC_setup(void)
902{
903 int apic, pin;
904
905 for (apic = 0; apic < nr_ioapics; apic++) {
906 if (!early_ioapic_entries[apic])
907 break;
908 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
909 ioapic_write_entry(apic, pin,
910 early_ioapic_entries[apic][pin]);
911 kfree(early_ioapic_entries[apic]);
912 early_ioapic_entries[apic] = NULL;
913 }
914}
915
916void reinit_intr_remapped_IO_APIC(int intr_remapping)
917{
918 /*
919 * for now plain restore of previous settings.
920 * TBD: In the case of OS enabling interrupt-remapping,
921 * IO-APIC RTE's need to be setup to point to interrupt-remapping
922 * table entries. for now, do a plain restore, and wait for
923 * the setup_IO_APIC_irqs() to do proper initialization.
924 */
925 restore_IO_APIC_setup();
926}
927#endif
928
929/*
930 * Find the IRQ entry number of a certain pin.
931 */
932static int find_irq_entry(int apic, int pin, int type)
933{
934 int i;
935
936 for (i = 0; i < mp_irq_entries; i++)
937 if (mp_irqs[i].irqtype == type &&
938 (mp_irqs[i].dstapic == mp_ioapics[apic].apicid ||
939 mp_irqs[i].dstapic == MP_APIC_ALL) &&
940 mp_irqs[i].dstirq == pin)
941 return i;
942
943 return -1;
944}
945
946/*
947 * Find the pin to which IRQ[irq] (ISA) is connected
948 */
949static int __init find_isa_irq_pin(int irq, int type)
950{
951 int i;
952
953 for (i = 0; i < mp_irq_entries; i++) {
954 int lbus = mp_irqs[i].srcbus;
955
956 if (test_bit(lbus, mp_bus_not_pci) &&
957 (mp_irqs[i].irqtype == type) &&
958 (mp_irqs[i].srcbusirq == irq))
959
960 return mp_irqs[i].dstirq;
961 }
962 return -1;
963}
964
965static int __init find_isa_irq_apic(int irq, int type)
966{
967 int i;
968
969 for (i = 0; i < mp_irq_entries; i++) {
970 int lbus = mp_irqs[i].srcbus;
971
972 if (test_bit(lbus, mp_bus_not_pci) &&
973 (mp_irqs[i].irqtype == type) &&
974 (mp_irqs[i].srcbusirq == irq))
975 break;
976 }
977 if (i < mp_irq_entries) {
978 int apic;
979 for(apic = 0; apic < nr_ioapics; apic++) {
980 if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic)
981 return apic;
982 }
983 }
984
985 return -1;
986}
987
988/*
989 * Find a specific PCI IRQ entry.
990 * Not an __init, possibly needed by modules
991 */
992static int pin_2_irq(int idx, int apic, int pin);
993
994int IO_APIC_get_PCI_irq_vector(int bus, int slot, int pin)
995{
996 int apic, i, best_guess = -1;
997
998 apic_printk(APIC_DEBUG, "querying PCI -> IRQ mapping bus:%d, slot:%d, pin:%d.\n",
999 bus, slot, pin);
1000 if (test_bit(bus, mp_bus_not_pci)) {
1001 apic_printk(APIC_VERBOSE, "PCI BIOS passed nonexistent PCI bus %d!\n", bus);
1002 return -1;
1003 }
1004 for (i = 0; i < mp_irq_entries; i++) {
1005 int lbus = mp_irqs[i].srcbus;
1006
1007 for (apic = 0; apic < nr_ioapics; apic++)
1008 if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic ||
1009 mp_irqs[i].dstapic == MP_APIC_ALL)
1010 break;
1011
1012 if (!test_bit(lbus, mp_bus_not_pci) &&
1013 !mp_irqs[i].irqtype &&
1014 (bus == lbus) &&
1015 (slot == ((mp_irqs[i].srcbusirq >> 2) & 0x1f))) {
1016 int irq = pin_2_irq(i, apic, mp_irqs[i].dstirq);
1017
1018 if (!(apic || IO_APIC_IRQ(irq)))
1019 continue;
1020
1021 if (pin == (mp_irqs[i].srcbusirq & 3))
1022 return irq;
1023 /*
1024 * Use the first all-but-pin matching entry as a
1025 * best-guess fuzzy result for broken mptables.
1026 */
1027 if (best_guess < 0)
1028 best_guess = irq;
1029 }
1030 }
1031 return best_guess;
1032}
1033
1034EXPORT_SYMBOL(IO_APIC_get_PCI_irq_vector);
1035
1036#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
1037/*
1038 * EISA Edge/Level control register, ELCR
1039 */
1040static int EISA_ELCR(unsigned int irq)
1041{
1042 if (irq < NR_IRQS_LEGACY) {
1043 unsigned int port = 0x4d0 + (irq >> 3);
1044 return (inb(port) >> (irq & 7)) & 1;
1045 }
1046 apic_printk(APIC_VERBOSE, KERN_INFO
1047 "Broken MPtable reports ISA irq %d\n", irq);
1048 return 0;
1049}
1050
1051#endif
1052
1053/* ISA interrupts are always polarity zero edge triggered,
1054 * when listed as conforming in the MP table. */
1055
1056#define default_ISA_trigger(idx) (0)
1057#define default_ISA_polarity(idx) (0)
1058
1059/* EISA interrupts are always polarity zero and can be edge or level
1060 * trigger depending on the ELCR value. If an interrupt is listed as
1061 * EISA conforming in the MP table, that means its trigger type must
1062 * be read in from the ELCR */
1063
1064#define default_EISA_trigger(idx) (EISA_ELCR(mp_irqs[idx].srcbusirq))
1065#define default_EISA_polarity(idx) default_ISA_polarity(idx)
1066
1067/* PCI interrupts are always polarity one level triggered,
1068 * when listed as conforming in the MP table. */
1069
1070#define default_PCI_trigger(idx) (1)
1071#define default_PCI_polarity(idx) (1)
1072
1073/* MCA interrupts are always polarity zero level triggered,
1074 * when listed as conforming in the MP table. */
1075
1076#define default_MCA_trigger(idx) (1)
1077#define default_MCA_polarity(idx) default_ISA_polarity(idx)
1078
1079static int MPBIOS_polarity(int idx)
1080{
1081 int bus = mp_irqs[idx].srcbus;
1082 int polarity;
1083
1084 /*
1085 * Determine IRQ line polarity (high active or low active):
1086 */
1087 switch (mp_irqs[idx].irqflag & 3)
1088 {
1089 case 0: /* conforms, ie. bus-type dependent polarity */
1090 if (test_bit(bus, mp_bus_not_pci))
1091 polarity = default_ISA_polarity(idx);
1092 else
1093 polarity = default_PCI_polarity(idx);
1094 break;
1095 case 1: /* high active */
1096 {
1097 polarity = 0;
1098 break;
1099 }
1100 case 2: /* reserved */
1101 {
1102 printk(KERN_WARNING "broken BIOS!!\n");
1103 polarity = 1;
1104 break;
1105 }
1106 case 3: /* low active */
1107 {
1108 polarity = 1;
1109 break;
1110 }
1111 default: /* invalid */
1112 {
1113 printk(KERN_WARNING "broken BIOS!!\n");
1114 polarity = 1;
1115 break;
1116 }
1117 }
1118 return polarity;
1119}
1120
1121static int MPBIOS_trigger(int idx)
1122{
1123 int bus = mp_irqs[idx].srcbus;
1124 int trigger;
1125
1126 /*
1127 * Determine IRQ trigger mode (edge or level sensitive):
1128 */
1129 switch ((mp_irqs[idx].irqflag>>2) & 3)
1130 {
1131 case 0: /* conforms, ie. bus-type dependent */
1132 if (test_bit(bus, mp_bus_not_pci))
1133 trigger = default_ISA_trigger(idx);
1134 else
1135 trigger = default_PCI_trigger(idx);
1136#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
1137 switch (mp_bus_id_to_type[bus]) {
1138 case MP_BUS_ISA: /* ISA pin */
1139 {
1140 /* set before the switch */
1141 break;
1142 }
1143 case MP_BUS_EISA: /* EISA pin */
1144 {
1145 trigger = default_EISA_trigger(idx);
1146 break;
1147 }
1148 case MP_BUS_PCI: /* PCI pin */
1149 {
1150 /* set before the switch */
1151 break;
1152 }
1153 case MP_BUS_MCA: /* MCA pin */
1154 {
1155 trigger = default_MCA_trigger(idx);
1156 break;
1157 }
1158 default:
1159 {
1160 printk(KERN_WARNING "broken BIOS!!\n");
1161 trigger = 1;
1162 break;
1163 }
1164 }
1165#endif
1166 break;
1167 case 1: /* edge */
1168 {
1169 trigger = 0;
1170 break;
1171 }
1172 case 2: /* reserved */
1173 {
1174 printk(KERN_WARNING "broken BIOS!!\n");
1175 trigger = 1;
1176 break;
1177 }
1178 case 3: /* level */
1179 {
1180 trigger = 1;
1181 break;
1182 }
1183 default: /* invalid */
1184 {
1185 printk(KERN_WARNING "broken BIOS!!\n");
1186 trigger = 0;
1187 break;
1188 }
1189 }
1190 return trigger;
1191}
1192
1193static inline int irq_polarity(int idx)
1194{
1195 return MPBIOS_polarity(idx);
1196}
1197
1198static inline int irq_trigger(int idx)
1199{
1200 return MPBIOS_trigger(idx);
1201}
1202
1203int (*ioapic_renumber_irq)(int ioapic, int irq);
1204static int pin_2_irq(int idx, int apic, int pin)
1205{
1206 int irq, i;
1207 int bus = mp_irqs[idx].srcbus;
1208
1209 /*
1210 * Debugging check, we are in big trouble if this message pops up!
1211 */
1212 if (mp_irqs[idx].dstirq != pin)
1213 printk(KERN_ERR "broken BIOS or MPTABLE parser, ayiee!!\n");
1214
1215 if (test_bit(bus, mp_bus_not_pci)) {
1216 irq = mp_irqs[idx].srcbusirq;
1217 } else {
1218 /*
1219 * PCI IRQs are mapped in order
1220 */
1221 i = irq = 0;
1222 while (i < apic)
1223 irq += nr_ioapic_registers[i++];
1224 irq += pin;
1225 /*
1226 * For MPS mode, so far only needed by ES7000 platform
1227 */
1228 if (ioapic_renumber_irq)
1229 irq = ioapic_renumber_irq(apic, irq);
1230 }
1231
1232#ifdef CONFIG_X86_32
1233 /*
1234 * PCI IRQ command line redirection. Yes, limits are hardcoded.
1235 */
1236 if ((pin >= 16) && (pin <= 23)) {
1237 if (pirq_entries[pin-16] != -1) {
1238 if (!pirq_entries[pin-16]) {
1239 apic_printk(APIC_VERBOSE, KERN_DEBUG
1240 "disabling PIRQ%d\n", pin-16);
1241 } else {
1242 irq = pirq_entries[pin-16];
1243 apic_printk(APIC_VERBOSE, KERN_DEBUG
1244 "using PIRQ%d -> IRQ %d\n",
1245 pin-16, irq);
1246 }
1247 }
1248 }
1249#endif
1250
1251 return irq;
1252}
1253
1254void lock_vector_lock(void)
1255{
1256 /* Used to the online set of cpus does not change
1257 * during assign_irq_vector.
1258 */
1259 spin_lock(&vector_lock);
1260}
1261
1262void unlock_vector_lock(void)
1263{
1264 spin_unlock(&vector_lock);
1265}
1266
1267static int
1268__assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1269{
1270 /*
1271 * NOTE! The local APIC isn't very good at handling
1272 * multiple interrupts at the same interrupt level.
1273 * As the interrupt level is determined by taking the
1274 * vector number and shifting that right by 4, we
1275 * want to spread these out a bit so that they don't
1276 * all fall in the same interrupt level.
1277 *
1278 * Also, we've got to be careful not to trash gate
1279 * 0x80, because int 0x80 is hm, kind of importantish. ;)
1280 */
1281 static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
1282 unsigned int old_vector;
1283 int cpu, err;
1284 cpumask_var_t tmp_mask;
1285
1286 if ((cfg->move_in_progress) || cfg->move_cleanup_count)
1287 return -EBUSY;
1288
1289 if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
1290 return -ENOMEM;
1291
1292 old_vector = cfg->vector;
1293 if (old_vector) {
1294 cpumask_and(tmp_mask, mask, cpu_online_mask);
1295 cpumask_and(tmp_mask, cfg->domain, tmp_mask);
1296 if (!cpumask_empty(tmp_mask)) {
1297 free_cpumask_var(tmp_mask);
1298 return 0;
1299 }
1300 }
1301
1302 /* Only try and allocate irqs on cpus that are present */
1303 err = -ENOSPC;
1304 for_each_cpu_and(cpu, mask, cpu_online_mask) {
1305 int new_cpu;
1306 int vector, offset;
1307
1308 apic->vector_allocation_domain(cpu, tmp_mask);
1309
1310 vector = current_vector;
1311 offset = current_offset;
1312next:
1313 vector += 8;
1314 if (vector >= first_system_vector) {
1315 /* If out of vectors on large boxen, must share them. */
1316 offset = (offset + 1) % 8;
1317 vector = FIRST_DEVICE_VECTOR + offset;
1318 }
1319 if (unlikely(current_vector == vector))
1320 continue;
1321
1322 if (test_bit(vector, used_vectors))
1323 goto next;
1324
1325 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1326 if (per_cpu(vector_irq, new_cpu)[vector] != -1)
1327 goto next;
1328 /* Found one! */
1329 current_vector = vector;
1330 current_offset = offset;
1331 if (old_vector) {
1332 cfg->move_in_progress = 1;
1333 cpumask_copy(cfg->old_domain, cfg->domain);
1334 }
1335 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1336 per_cpu(vector_irq, new_cpu)[vector] = irq;
1337 cfg->vector = vector;
1338 cpumask_copy(cfg->domain, tmp_mask);
1339 err = 0;
1340 break;
1341 }
1342 free_cpumask_var(tmp_mask);
1343 return err;
1344}
1345
1346static int
1347assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1348{
1349 int err;
1350 unsigned long flags;
1351
1352 spin_lock_irqsave(&vector_lock, flags);
1353 err = __assign_irq_vector(irq, cfg, mask);
1354 spin_unlock_irqrestore(&vector_lock, flags);
1355 return err;
1356}
1357
1358static void __clear_irq_vector(int irq, struct irq_cfg *cfg)
1359{
1360 int cpu, vector;
1361
1362 BUG_ON(!cfg->vector);
1363
1364 vector = cfg->vector;
1365 for_each_cpu_and(cpu, cfg->domain, cpu_online_mask)
1366 per_cpu(vector_irq, cpu)[vector] = -1;
1367
1368 cfg->vector = 0;
1369 cpumask_clear(cfg->domain);
1370
1371 if (likely(!cfg->move_in_progress))
1372 return;
1373 for_each_cpu_and(cpu, cfg->old_domain, cpu_online_mask) {
1374 for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
1375 vector++) {
1376 if (per_cpu(vector_irq, cpu)[vector] != irq)
1377 continue;
1378 per_cpu(vector_irq, cpu)[vector] = -1;
1379 break;
1380 }
1381 }
1382 cfg->move_in_progress = 0;
1383}
1384
1385void __setup_vector_irq(int cpu)
1386{
1387 /* Initialize vector_irq on a new cpu */
1388 /* This function must be called with vector_lock held */
1389 int irq, vector;
1390 struct irq_cfg *cfg;
1391 struct irq_desc *desc;
1392
1393 /* Mark the inuse vectors */
1394 for_each_irq_desc(irq, desc) {
1395 cfg = desc->chip_data;
1396 if (!cpumask_test_cpu(cpu, cfg->domain))
1397 continue;
1398 vector = cfg->vector;
1399 per_cpu(vector_irq, cpu)[vector] = irq;
1400 }
1401 /* Mark the free vectors */
1402 for (vector = 0; vector < NR_VECTORS; ++vector) {
1403 irq = per_cpu(vector_irq, cpu)[vector];
1404 if (irq < 0)
1405 continue;
1406
1407 cfg = irq_cfg(irq);
1408 if (!cpumask_test_cpu(cpu, cfg->domain))
1409 per_cpu(vector_irq, cpu)[vector] = -1;
1410 }
1411}
1412
1413static struct irq_chip ioapic_chip;
1414#ifdef CONFIG_INTR_REMAP
1415static struct irq_chip ir_ioapic_chip;
1416#endif
1417
1418#define IOAPIC_AUTO -1
1419#define IOAPIC_EDGE 0
1420#define IOAPIC_LEVEL 1
1421
1422#ifdef CONFIG_X86_32
1423static inline int IO_APIC_irq_trigger(int irq)
1424{
1425 int apic, idx, pin;
1426
1427 for (apic = 0; apic < nr_ioapics; apic++) {
1428 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
1429 idx = find_irq_entry(apic, pin, mp_INT);
1430 if ((idx != -1) && (irq == pin_2_irq(idx, apic, pin)))
1431 return irq_trigger(idx);
1432 }
1433 }
1434 /*
1435 * nonexistent IRQs are edge default
1436 */
1437 return 0;
1438}
1439#else
1440static inline int IO_APIC_irq_trigger(int irq)
1441{
1442 return 1;
1443}
1444#endif
1445
1446static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long trigger)
1447{
1448
1449 if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
1450 trigger == IOAPIC_LEVEL)
1451 desc->status |= IRQ_LEVEL;
1452 else
1453 desc->status &= ~IRQ_LEVEL;
1454
1455#ifdef CONFIG_INTR_REMAP
1456 if (irq_remapped(irq)) {
1457 desc->status |= IRQ_MOVE_PCNTXT;
1458 if (trigger)
1459 set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
1460 handle_fasteoi_irq,
1461 "fasteoi");
1462 else
1463 set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
1464 handle_edge_irq, "edge");
1465 return;
1466 }
1467#endif
1468 if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
1469 trigger == IOAPIC_LEVEL)
1470 set_irq_chip_and_handler_name(irq, &ioapic_chip,
1471 handle_fasteoi_irq,
1472 "fasteoi");
1473 else
1474 set_irq_chip_and_handler_name(irq, &ioapic_chip,
1475 handle_edge_irq, "edge");
1476}
1477
1478int setup_ioapic_entry(int apic_id, int irq,
1479 struct IO_APIC_route_entry *entry,
1480 unsigned int destination, int trigger,
1481 int polarity, int vector)
1482{
1483 /*
1484 * add it to the IO-APIC irq-routing table:
1485 */
1486 memset(entry,0,sizeof(*entry));
1487
1488#ifdef CONFIG_INTR_REMAP
1489 if (intr_remapping_enabled) {
1490 struct intel_iommu *iommu = map_ioapic_to_ir(apic_id);
1491 struct irte irte;
1492 struct IR_IO_APIC_route_entry *ir_entry =
1493 (struct IR_IO_APIC_route_entry *) entry;
1494 int index;
1495
1496 if (!iommu)
1497 panic("No mapping iommu for ioapic %d\n", apic_id);
1498
1499 index = alloc_irte(iommu, irq, 1);
1500 if (index < 0)
1501 panic("Failed to allocate IRTE for ioapic %d\n", apic_id);
1502
1503 memset(&irte, 0, sizeof(irte));
1504
1505 irte.present = 1;
1506 irte.dst_mode = apic->irq_dest_mode;
1507 irte.trigger_mode = trigger;
1508 irte.dlvry_mode = apic->irq_delivery_mode;
1509 irte.vector = vector;
1510 irte.dest_id = IRTE_DEST(destination);
1511
1512 modify_irte(irq, &irte);
1513
1514 ir_entry->index2 = (index >> 15) & 0x1;
1515 ir_entry->zero = 0;
1516 ir_entry->format = 1;
1517 ir_entry->index = (index & 0x7fff);
1518 } else
1519#endif
1520 {
1521 entry->delivery_mode = apic->irq_delivery_mode;
1522 entry->dest_mode = apic->irq_dest_mode;
1523 entry->dest = destination;
1524 }
1525
1526 entry->mask = 0; /* enable IRQ */
1527 entry->trigger = trigger;
1528 entry->polarity = polarity;
1529 entry->vector = vector;
1530
1531 /* Mask level triggered irqs.
1532 * Use IRQ_DELAYED_DISABLE for edge triggered irqs.
1533 */
1534 if (trigger)
1535 entry->mask = 1;
1536 return 0;
1537}
1538
1539static void setup_IO_APIC_irq(int apic_id, int pin, unsigned int irq, struct irq_desc *desc,
1540 int trigger, int polarity)
1541{
1542 struct irq_cfg *cfg;
1543 struct IO_APIC_route_entry entry;
1544 unsigned int dest;
1545
1546 if (!IO_APIC_IRQ(irq))
1547 return;
1548
1549 cfg = desc->chip_data;
1550
1551 if (assign_irq_vector(irq, cfg, apic->target_cpus()))
1552 return;
1553
1554 dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
1555
1556 apic_printk(APIC_VERBOSE,KERN_DEBUG
1557 "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
1558 "IRQ %d Mode:%i Active:%i)\n",
1559 apic_id, mp_ioapics[apic_id].apicid, pin, cfg->vector,
1560 irq, trigger, polarity);
1561
1562
1563 if (setup_ioapic_entry(mp_ioapics[apic_id].apicid, irq, &entry,
1564 dest, trigger, polarity, cfg->vector)) {
1565 printk("Failed to setup ioapic entry for ioapic %d, pin %d\n",
1566 mp_ioapics[apic_id].apicid, pin);
1567 __clear_irq_vector(irq, cfg);
1568 return;
1569 }
1570
1571 ioapic_register_intr(irq, desc, trigger);
1572 if (irq < NR_IRQS_LEGACY)
1573 disable_8259A_irq(irq);
1574
1575 ioapic_write_entry(apic_id, pin, entry);
1576}
1577
1578static void __init setup_IO_APIC_irqs(void)
1579{
1580 int apic_id, pin, idx, irq;
1581 int notcon = 0;
1582 struct irq_desc *desc;
1583 struct irq_cfg *cfg;
1584 int cpu = boot_cpu_id;
1585
1586 apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
1587
1588 for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
1589 for (pin = 0; pin < nr_ioapic_registers[apic_id]; pin++) {
1590
1591 idx = find_irq_entry(apic_id, pin, mp_INT);
1592 if (idx == -1) {
1593 if (!notcon) {
1594 notcon = 1;
1595 apic_printk(APIC_VERBOSE,
1596 KERN_DEBUG " %d-%d",
1597 mp_ioapics[apic_id].apicid, pin);
1598 } else
1599 apic_printk(APIC_VERBOSE, " %d-%d",
1600 mp_ioapics[apic_id].apicid, pin);
1601 continue;
1602 }
1603 if (notcon) {
1604 apic_printk(APIC_VERBOSE,
1605 " (apicid-pin) not connected\n");
1606 notcon = 0;
1607 }
1608
1609 irq = pin_2_irq(idx, apic_id, pin);
1610
1611 /*
1612 * Skip the timer IRQ if there's a quirk handler
1613 * installed and if it returns 1:
1614 */
1615 if (apic->multi_timer_check &&
1616 apic->multi_timer_check(apic_id, irq))
1617 continue;
1618
1619 desc = irq_to_desc_alloc_cpu(irq, cpu);
1620 if (!desc) {
1621 printk(KERN_INFO "can not get irq_desc for %d\n", irq);
1622 continue;
1623 }
1624 cfg = desc->chip_data;
1625 add_pin_to_irq_cpu(cfg, cpu, apic_id, pin);
1626
1627 setup_IO_APIC_irq(apic_id, pin, irq, desc,
1628 irq_trigger(idx), irq_polarity(idx));
1629 }
1630 }
1631
1632 if (notcon)
1633 apic_printk(APIC_VERBOSE,
1634 " (apicid-pin) not connected\n");
1635}
1636
1637/*
1638 * Set up the timer pin, possibly with the 8259A-master behind.
1639 */
1640static void __init setup_timer_IRQ0_pin(unsigned int apic_id, unsigned int pin,
1641 int vector)
1642{
1643 struct IO_APIC_route_entry entry;
1644
1645#ifdef CONFIG_INTR_REMAP
1646 if (intr_remapping_enabled)
1647 return;
1648#endif
1649
1650 memset(&entry, 0, sizeof(entry));
1651
1652 /*
1653 * We use logical delivery to get the timer IRQ
1654 * to the first CPU.
1655 */
1656 entry.dest_mode = apic->irq_dest_mode;
1657 entry.mask = 0; /* don't mask IRQ for edge */
1658 entry.dest = apic->cpu_mask_to_apicid(apic->target_cpus());
1659 entry.delivery_mode = apic->irq_delivery_mode;
1660 entry.polarity = 0;
1661 entry.trigger = 0;
1662 entry.vector = vector;
1663
1664 /*
1665 * The timer IRQ doesn't have to know that behind the
1666 * scene we may have a 8259A-master in AEOI mode ...
1667 */
1668 set_irq_chip_and_handler_name(0, &ioapic_chip, handle_edge_irq, "edge");
1669
1670 /*
1671 * Add it to the IO-APIC irq-routing table:
1672 */
1673 ioapic_write_entry(apic_id, pin, entry);
1674}
1675
1676
1677__apicdebuginit(void) print_IO_APIC(void)
1678{
1679 int apic, i;
1680 union IO_APIC_reg_00 reg_00;
1681 union IO_APIC_reg_01 reg_01;
1682 union IO_APIC_reg_02 reg_02;
1683 union IO_APIC_reg_03 reg_03;
1684 unsigned long flags;
1685 struct irq_cfg *cfg;
1686 struct irq_desc *desc;
1687 unsigned int irq;
1688
1689 if (apic_verbosity == APIC_QUIET)
1690 return;
1691
1692 printk(KERN_DEBUG "number of MP IRQ sources: %d.\n", mp_irq_entries);
1693 for (i = 0; i < nr_ioapics; i++)
1694 printk(KERN_DEBUG "number of IO-APIC #%d registers: %d.\n",
1695 mp_ioapics[i].apicid, nr_ioapic_registers[i]);
1696
1697 /*
1698 * We are a bit conservative about what we expect. We have to
1699 * know about every hardware change ASAP.
1700 */
1701 printk(KERN_INFO "testing the IO APIC.......................\n");
1702
1703 for (apic = 0; apic < nr_ioapics; apic++) {
1704
1705 spin_lock_irqsave(&ioapic_lock, flags);
1706 reg_00.raw = io_apic_read(apic, 0);
1707 reg_01.raw = io_apic_read(apic, 1);
1708 if (reg_01.bits.version >= 0x10)
1709 reg_02.raw = io_apic_read(apic, 2);
1710 if (reg_01.bits.version >= 0x20)
1711 reg_03.raw = io_apic_read(apic, 3);
1712 spin_unlock_irqrestore(&ioapic_lock, flags);
1713
1714 printk("\n");
1715 printk(KERN_DEBUG "IO APIC #%d......\n", mp_ioapics[apic].apicid);
1716 printk(KERN_DEBUG ".... register #00: %08X\n", reg_00.raw);
1717 printk(KERN_DEBUG "....... : physical APIC id: %02X\n", reg_00.bits.ID);
1718 printk(KERN_DEBUG "....... : Delivery Type: %X\n", reg_00.bits.delivery_type);
1719 printk(KERN_DEBUG "....... : LTS : %X\n", reg_00.bits.LTS);
1720
1721 printk(KERN_DEBUG ".... register #01: %08X\n", *(int *)&reg_01);
1722 printk(KERN_DEBUG "....... : max redirection entries: %04X\n", reg_01.bits.entries);
1723
1724 printk(KERN_DEBUG "....... : PRQ implemented: %X\n", reg_01.bits.PRQ);
1725 printk(KERN_DEBUG "....... : IO APIC version: %04X\n", reg_01.bits.version);
1726
1727 /*
1728 * Some Intel chipsets with IO APIC VERSION of 0x1? don't have reg_02,
1729 * but the value of reg_02 is read as the previous read register
1730 * value, so ignore it if reg_02 == reg_01.
1731 */
1732 if (reg_01.bits.version >= 0x10 && reg_02.raw != reg_01.raw) {
1733 printk(KERN_DEBUG ".... register #02: %08X\n", reg_02.raw);
1734 printk(KERN_DEBUG "....... : arbitration: %02X\n", reg_02.bits.arbitration);
1735 }
1736
1737 /*
1738 * Some Intel chipsets with IO APIC VERSION of 0x2? don't have reg_02
1739 * or reg_03, but the value of reg_0[23] is read as the previous read
1740 * register value, so ignore it if reg_03 == reg_0[12].
1741 */
1742 if (reg_01.bits.version >= 0x20 && reg_03.raw != reg_02.raw &&
1743 reg_03.raw != reg_01.raw) {
1744 printk(KERN_DEBUG ".... register #03: %08X\n", reg_03.raw);
1745 printk(KERN_DEBUG "....... : Boot DT : %X\n", reg_03.bits.boot_DT);
1746 }
1747
1748 printk(KERN_DEBUG ".... IRQ redirection table:\n");
1749
1750 printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol"
1751 " Stat Dmod Deli Vect: \n");
1752
1753 for (i = 0; i <= reg_01.bits.entries; i++) {
1754 struct IO_APIC_route_entry entry;
1755
1756 entry = ioapic_read_entry(apic, i);
1757
1758 printk(KERN_DEBUG " %02x %03X ",
1759 i,
1760 entry.dest
1761 );
1762
1763 printk("%1d %1d %1d %1d %1d %1d %1d %02X\n",
1764 entry.mask,
1765 entry.trigger,
1766 entry.irr,
1767 entry.polarity,
1768 entry.delivery_status,
1769 entry.dest_mode,
1770 entry.delivery_mode,
1771 entry.vector
1772 );
1773 }
1774 }
1775 printk(KERN_DEBUG "IRQ to pin mappings:\n");
1776 for_each_irq_desc(irq, desc) {
1777 struct irq_pin_list *entry;
1778
1779 cfg = desc->chip_data;
1780 entry = cfg->irq_2_pin;
1781 if (!entry)
1782 continue;
1783 printk(KERN_DEBUG "IRQ%d ", irq);
1784 for (;;) {
1785 printk("-> %d:%d", entry->apic, entry->pin);
1786 if (!entry->next)
1787 break;
1788 entry = entry->next;
1789 }
1790 printk("\n");
1791 }
1792
1793 printk(KERN_INFO ".................................... done.\n");
1794
1795 return;
1796}
1797
1798__apicdebuginit(void) print_APIC_bitfield(int base)
1799{
1800 unsigned int v;
1801 int i, j;
1802
1803 if (apic_verbosity == APIC_QUIET)
1804 return;
1805
1806 printk(KERN_DEBUG "0123456789abcdef0123456789abcdef\n" KERN_DEBUG);
1807 for (i = 0; i < 8; i++) {
1808 v = apic_read(base + i*0x10);
1809 for (j = 0; j < 32; j++) {
1810 if (v & (1<<j))
1811 printk("1");
1812 else
1813 printk("0");
1814 }
1815 printk("\n");
1816 }
1817}
1818
1819__apicdebuginit(void) print_local_APIC(void *dummy)
1820{
1821 unsigned int v, ver, maxlvt;
1822 u64 icr;
1823
1824 if (apic_verbosity == APIC_QUIET)
1825 return;
1826
1827 printk("\n" KERN_DEBUG "printing local APIC contents on CPU#%d/%d:\n",
1828 smp_processor_id(), hard_smp_processor_id());
1829 v = apic_read(APIC_ID);
1830 printk(KERN_INFO "... APIC ID: %08x (%01x)\n", v, read_apic_id());
1831 v = apic_read(APIC_LVR);
1832 printk(KERN_INFO "... APIC VERSION: %08x\n", v);
1833 ver = GET_APIC_VERSION(v);
1834 maxlvt = lapic_get_maxlvt();
1835
1836 v = apic_read(APIC_TASKPRI);
1837 printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
1838
1839 if (APIC_INTEGRATED(ver)) { /* !82489DX */
1840 if (!APIC_XAPIC(ver)) {
1841 v = apic_read(APIC_ARBPRI);
1842 printk(KERN_DEBUG "... APIC ARBPRI: %08x (%02x)\n", v,
1843 v & APIC_ARBPRI_MASK);
1844 }
1845 v = apic_read(APIC_PROCPRI);
1846 printk(KERN_DEBUG "... APIC PROCPRI: %08x\n", v);
1847 }
1848
1849 /*
1850 * Remote read supported only in the 82489DX and local APIC for
1851 * Pentium processors.
1852 */
1853 if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
1854 v = apic_read(APIC_RRR);
1855 printk(KERN_DEBUG "... APIC RRR: %08x\n", v);
1856 }
1857
1858 v = apic_read(APIC_LDR);
1859 printk(KERN_DEBUG "... APIC LDR: %08x\n", v);
1860 if (!x2apic_enabled()) {
1861 v = apic_read(APIC_DFR);
1862 printk(KERN_DEBUG "... APIC DFR: %08x\n", v);
1863 }
1864 v = apic_read(APIC_SPIV);
1865 printk(KERN_DEBUG "... APIC SPIV: %08x\n", v);
1866
1867 printk(KERN_DEBUG "... APIC ISR field:\n");
1868 print_APIC_bitfield(APIC_ISR);
1869 printk(KERN_DEBUG "... APIC TMR field:\n");
1870 print_APIC_bitfield(APIC_TMR);
1871 printk(KERN_DEBUG "... APIC IRR field:\n");
1872 print_APIC_bitfield(APIC_IRR);
1873
1874 if (APIC_INTEGRATED(ver)) { /* !82489DX */
1875 if (maxlvt > 3) /* Due to the Pentium erratum 3AP. */
1876 apic_write(APIC_ESR, 0);
1877
1878 v = apic_read(APIC_ESR);
1879 printk(KERN_DEBUG "... APIC ESR: %08x\n", v);
1880 }
1881
1882 icr = apic_icr_read();
1883 printk(KERN_DEBUG "... APIC ICR: %08x\n", (u32)icr);
1884 printk(KERN_DEBUG "... APIC ICR2: %08x\n", (u32)(icr >> 32));
1885
1886 v = apic_read(APIC_LVTT);
1887 printk(KERN_DEBUG "... APIC LVTT: %08x\n", v);
1888
1889 if (maxlvt > 3) { /* PC is LVT#4. */
1890 v = apic_read(APIC_LVTPC);
1891 printk(KERN_DEBUG "... APIC LVTPC: %08x\n", v);
1892 }
1893 v = apic_read(APIC_LVT0);
1894 printk(KERN_DEBUG "... APIC LVT0: %08x\n", v);
1895 v = apic_read(APIC_LVT1);
1896 printk(KERN_DEBUG "... APIC LVT1: %08x\n", v);
1897
1898 if (maxlvt > 2) { /* ERR is LVT#3. */
1899 v = apic_read(APIC_LVTERR);
1900 printk(KERN_DEBUG "... APIC LVTERR: %08x\n", v);
1901 }
1902
1903 v = apic_read(APIC_TMICT);
1904 printk(KERN_DEBUG "... APIC TMICT: %08x\n", v);
1905 v = apic_read(APIC_TMCCT);
1906 printk(KERN_DEBUG "... APIC TMCCT: %08x\n", v);
1907 v = apic_read(APIC_TDCR);
1908 printk(KERN_DEBUG "... APIC TDCR: %08x\n", v);
1909 printk("\n");
1910}
1911
1912__apicdebuginit(void) print_all_local_APICs(void)
1913{
1914 int cpu;
1915
1916 preempt_disable();
1917 for_each_online_cpu(cpu)
1918 smp_call_function_single(cpu, print_local_APIC, NULL, 1);
1919 preempt_enable();
1920}
1921
1922__apicdebuginit(void) print_PIC(void)
1923{
1924 unsigned int v;
1925 unsigned long flags;
1926
1927 if (apic_verbosity == APIC_QUIET)
1928 return;
1929
1930 printk(KERN_DEBUG "\nprinting PIC contents\n");
1931
1932 spin_lock_irqsave(&i8259A_lock, flags);
1933
1934 v = inb(0xa1) << 8 | inb(0x21);
1935 printk(KERN_DEBUG "... PIC IMR: %04x\n", v);
1936
1937 v = inb(0xa0) << 8 | inb(0x20);
1938 printk(KERN_DEBUG "... PIC IRR: %04x\n", v);
1939
1940 outb(0x0b,0xa0);
1941 outb(0x0b,0x20);
1942 v = inb(0xa0) << 8 | inb(0x20);
1943 outb(0x0a,0xa0);
1944 outb(0x0a,0x20);
1945
1946 spin_unlock_irqrestore(&i8259A_lock, flags);
1947
1948 printk(KERN_DEBUG "... PIC ISR: %04x\n", v);
1949
1950 v = inb(0x4d1) << 8 | inb(0x4d0);
1951 printk(KERN_DEBUG "... PIC ELCR: %04x\n", v);
1952}
1953
1954__apicdebuginit(int) print_all_ICs(void)
1955{
1956 print_PIC();
1957 print_all_local_APICs();
1958 print_IO_APIC();
1959
1960 return 0;
1961}
1962
1963fs_initcall(print_all_ICs);
1964
1965
1966/* Where if anywhere is the i8259 connect in external int mode */
1967static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
1968
1969void __init enable_IO_APIC(void)
1970{
1971 union IO_APIC_reg_01 reg_01;
1972 int i8259_apic, i8259_pin;
1973 int apic;
1974 unsigned long flags;
1975
1976 /*
1977 * The number of IO-APIC IRQ registers (== #pins):
1978 */
1979 for (apic = 0; apic < nr_ioapics; apic++) {
1980 spin_lock_irqsave(&ioapic_lock, flags);
1981 reg_01.raw = io_apic_read(apic, 1);
1982 spin_unlock_irqrestore(&ioapic_lock, flags);
1983 nr_ioapic_registers[apic] = reg_01.bits.entries+1;
1984 }
1985 for(apic = 0; apic < nr_ioapics; apic++) {
1986 int pin;
1987 /* See if any of the pins is in ExtINT mode */
1988 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
1989 struct IO_APIC_route_entry entry;
1990 entry = ioapic_read_entry(apic, pin);
1991
1992 /* If the interrupt line is enabled and in ExtInt mode
1993 * I have found the pin where the i8259 is connected.
1994 */
1995 if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
1996 ioapic_i8259.apic = apic;
1997 ioapic_i8259.pin = pin;
1998 goto found_i8259;
1999 }
2000 }
2001 }
2002 found_i8259:
2003 /* Look to see what if the MP table has reported the ExtINT */
2004 /* If we could not find the appropriate pin by looking at the ioapic
2005 * the i8259 probably is not connected the ioapic but give the
2006 * mptable a chance anyway.
2007 */
2008 i8259_pin = find_isa_irq_pin(0, mp_ExtINT);
2009 i8259_apic = find_isa_irq_apic(0, mp_ExtINT);
2010 /* Trust the MP table if nothing is setup in the hardware */
2011 if ((ioapic_i8259.pin == -1) && (i8259_pin >= 0)) {
2012 printk(KERN_WARNING "ExtINT not setup in hardware but reported by MP table\n");
2013 ioapic_i8259.pin = i8259_pin;
2014 ioapic_i8259.apic = i8259_apic;
2015 }
2016 /* Complain if the MP table and the hardware disagree */
2017 if (((ioapic_i8259.apic != i8259_apic) || (ioapic_i8259.pin != i8259_pin)) &&
2018 (i8259_pin >= 0) && (ioapic_i8259.pin >= 0))
2019 {
2020 printk(KERN_WARNING "ExtINT in hardware and MP table differ\n");
2021 }
2022
2023 /*
2024 * Do not trust the IO-APIC being empty at bootup
2025 */
2026 clear_IO_APIC();
2027}
2028
2029/*
2030 * Not an __init, needed by the reboot code
2031 */
2032void disable_IO_APIC(void)
2033{
2034 /*
2035 * Clear the IO-APIC before rebooting:
2036 */
2037 clear_IO_APIC();
2038
2039 /*
2040 * If the i8259 is routed through an IOAPIC
2041 * Put that IOAPIC in virtual wire mode
2042 * so legacy interrupts can be delivered.
2043 */
2044 if (ioapic_i8259.pin != -1) {
2045 struct IO_APIC_route_entry entry;
2046
2047 memset(&entry, 0, sizeof(entry));
2048 entry.mask = 0; /* Enabled */
2049 entry.trigger = 0; /* Edge */
2050 entry.irr = 0;
2051 entry.polarity = 0; /* High */
2052 entry.delivery_status = 0;
2053 entry.dest_mode = 0; /* Physical */
2054 entry.delivery_mode = dest_ExtINT; /* ExtInt */
2055 entry.vector = 0;
2056 entry.dest = read_apic_id();
2057
2058 /*
2059 * Add it to the IO-APIC irq-routing table:
2060 */
2061 ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
2062 }
2063
2064 disconnect_bsp_APIC(ioapic_i8259.pin != -1);
2065}
2066
2067#ifdef CONFIG_X86_32
2068/*
2069 * function to set the IO-APIC physical IDs based on the
2070 * values stored in the MPC table.
2071 *
2072 * by Matt Domsch <Matt_Domsch@dell.com> Tue Dec 21 12:25:05 CST 1999
2073 */
2074
2075static void __init setup_ioapic_ids_from_mpc(void)
2076{
2077 union IO_APIC_reg_00 reg_00;
2078 physid_mask_t phys_id_present_map;
2079 int apic_id;
2080 int i;
2081 unsigned char old_id;
2082 unsigned long flags;
2083
2084 if (x86_quirks->setup_ioapic_ids && x86_quirks->setup_ioapic_ids())
2085 return;
2086
2087 /*
2088 * Don't check I/O APIC IDs for xAPIC systems. They have
2089 * no meaning without the serial APIC bus.
2090 */
2091 if (!(boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
2092 || APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
2093 return;
2094 /*
2095 * This is broken; anything with a real cpu count has to
2096 * circumvent this idiocy regardless.
2097 */
2098 phys_id_present_map = apic->ioapic_phys_id_map(phys_cpu_present_map);
2099
2100 /*
2101 * Set the IOAPIC ID to the value stored in the MPC table.
2102 */
2103 for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
2104
2105 /* Read the register 0 value */
2106 spin_lock_irqsave(&ioapic_lock, flags);
2107 reg_00.raw = io_apic_read(apic_id, 0);
2108 spin_unlock_irqrestore(&ioapic_lock, flags);
2109
2110 old_id = mp_ioapics[apic_id].apicid;
2111
2112 if (mp_ioapics[apic_id].apicid >= get_physical_broadcast()) {
2113 printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
2114 apic_id, mp_ioapics[apic_id].apicid);
2115 printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
2116 reg_00.bits.ID);
2117 mp_ioapics[apic_id].apicid = reg_00.bits.ID;
2118 }
2119
2120 /*
2121 * Sanity check, is the ID really free? Every APIC in a
2122 * system must have a unique ID or we get lots of nice
2123 * 'stuck on smp_invalidate_needed IPI wait' messages.
2124 */
2125 if (apic->check_apicid_used(phys_id_present_map,
2126 mp_ioapics[apic_id].apicid)) {
2127 printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
2128 apic_id, mp_ioapics[apic_id].apicid);
2129 for (i = 0; i < get_physical_broadcast(); i++)
2130 if (!physid_isset(i, phys_id_present_map))
2131 break;
2132 if (i >= get_physical_broadcast())
2133 panic("Max APIC ID exceeded!\n");
2134 printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
2135 i);
2136 physid_set(i, phys_id_present_map);
2137 mp_ioapics[apic_id].apicid = i;
2138 } else {
2139 physid_mask_t tmp;
2140 tmp = apic->apicid_to_cpu_present(mp_ioapics[apic_id].apicid);
2141 apic_printk(APIC_VERBOSE, "Setting %d in the "
2142 "phys_id_present_map\n",
2143 mp_ioapics[apic_id].apicid);
2144 physids_or(phys_id_present_map, phys_id_present_map, tmp);
2145 }
2146
2147
2148 /*
2149 * We need to adjust the IRQ routing table
2150 * if the ID changed.
2151 */
2152 if (old_id != mp_ioapics[apic_id].apicid)
2153 for (i = 0; i < mp_irq_entries; i++)
2154 if (mp_irqs[i].dstapic == old_id)
2155 mp_irqs[i].dstapic
2156 = mp_ioapics[apic_id].apicid;
2157
2158 /*
2159 * Read the right value from the MPC table and
2160 * write it into the ID register.
2161 */
2162 apic_printk(APIC_VERBOSE, KERN_INFO
2163 "...changing IO-APIC physical APIC ID to %d ...",
2164 mp_ioapics[apic_id].apicid);
2165
2166 reg_00.bits.ID = mp_ioapics[apic_id].apicid;
2167 spin_lock_irqsave(&ioapic_lock, flags);
2168 io_apic_write(apic_id, 0, reg_00.raw);
2169 spin_unlock_irqrestore(&ioapic_lock, flags);
2170
2171 /*
2172 * Sanity check
2173 */
2174 spin_lock_irqsave(&ioapic_lock, flags);
2175 reg_00.raw = io_apic_read(apic_id, 0);
2176 spin_unlock_irqrestore(&ioapic_lock, flags);
2177 if (reg_00.bits.ID != mp_ioapics[apic_id].apicid)
2178 printk("could not set ID!\n");
2179 else
2180 apic_printk(APIC_VERBOSE, " ok.\n");
2181 }
2182}
2183#endif
2184
2185int no_timer_check __initdata;
2186
2187static int __init notimercheck(char *s)
2188{
2189 no_timer_check = 1;
2190 return 1;
2191}
2192__setup("no_timer_check", notimercheck);
2193
2194/*
2195 * There is a nasty bug in some older SMP boards, their mptable lies
2196 * about the timer IRQ. We do the following to work around the situation:
2197 *
2198 * - timer IRQ defaults to IO-APIC IRQ
2199 * - if this function detects that timer IRQs are defunct, then we fall
2200 * back to ISA timer IRQs
2201 */
2202static int __init timer_irq_works(void)
2203{
2204 unsigned long t1 = jiffies;
2205 unsigned long flags;
2206
2207 if (no_timer_check)
2208 return 1;
2209
2210 local_save_flags(flags);
2211 local_irq_enable();
2212 /* Let ten ticks pass... */
2213 mdelay((10 * 1000) / HZ);
2214 local_irq_restore(flags);
2215
2216 /*
2217 * Expect a few ticks at least, to be sure some possible
2218 * glue logic does not lock up after one or two first
2219 * ticks in a non-ExtINT mode. Also the local APIC
2220 * might have cached one ExtINT interrupt. Finally, at
2221 * least one tick may be lost due to delays.
2222 */
2223
2224 /* jiffies wrap? */
2225 if (time_after(jiffies, t1 + 4))
2226 return 1;
2227 return 0;
2228}
2229
2230/*
2231 * In the SMP+IOAPIC case it might happen that there are an unspecified
2232 * number of pending IRQ events unhandled. These cases are very rare,
2233 * so we 'resend' these IRQs via IPIs, to the same CPU. It's much
2234 * better to do it this way as thus we do not have to be aware of
2235 * 'pending' interrupts in the IRQ path, except at this point.
2236 */
2237/*
2238 * Edge triggered needs to resend any interrupt
2239 * that was delayed but this is now handled in the device
2240 * independent code.
2241 */
2242
2243/*
2244 * Starting up a edge-triggered IO-APIC interrupt is
2245 * nasty - we need to make sure that we get the edge.
2246 * If it is already asserted for some reason, we need
2247 * return 1 to indicate that is was pending.
2248 *
2249 * This is not complete - we should be able to fake
2250 * an edge even if it isn't on the 8259A...
2251 */
2252
2253static unsigned int startup_ioapic_irq(unsigned int irq)
2254{
2255 int was_pending = 0;
2256 unsigned long flags;
2257 struct irq_cfg *cfg;
2258
2259 spin_lock_irqsave(&ioapic_lock, flags);
2260 if (irq < NR_IRQS_LEGACY) {
2261 disable_8259A_irq(irq);
2262 if (i8259A_irq_pending(irq))
2263 was_pending = 1;
2264 }
2265 cfg = irq_cfg(irq);
2266 __unmask_IO_APIC_irq(cfg);
2267 spin_unlock_irqrestore(&ioapic_lock, flags);
2268
2269 return was_pending;
2270}
2271
2272#ifdef CONFIG_X86_64
2273static int ioapic_retrigger_irq(unsigned int irq)
2274{
2275
2276 struct irq_cfg *cfg = irq_cfg(irq);
2277 unsigned long flags;
2278
2279 spin_lock_irqsave(&vector_lock, flags);
2280 apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
2281 spin_unlock_irqrestore(&vector_lock, flags);
2282
2283 return 1;
2284}
2285#else
2286static int ioapic_retrigger_irq(unsigned int irq)
2287{
2288 apic->send_IPI_self(irq_cfg(irq)->vector);
2289
2290 return 1;
2291}
2292#endif
2293
2294/*
2295 * Level and edge triggered IO-APIC interrupts need different handling,
2296 * so we use two separate IRQ descriptors. Edge triggered IRQs can be
2297 * handled with the level-triggered descriptor, but that one has slightly
2298 * more overhead. Level-triggered interrupts cannot be handled with the
2299 * edge-triggered handler, without risking IRQ storms and other ugly
2300 * races.
2301 */
2302
2303#ifdef CONFIG_SMP
2304
2305#ifdef CONFIG_INTR_REMAP
2306static void ir_irq_migration(struct work_struct *work);
2307
2308static DECLARE_DELAYED_WORK(ir_migration_work, ir_irq_migration);
2309
2310/*
2311 * Migrate the IO-APIC irq in the presence of intr-remapping.
2312 *
2313 * For edge triggered, irq migration is a simple atomic update(of vector
2314 * and cpu destination) of IRTE and flush the hardware cache.
2315 *
2316 * For level triggered, we need to modify the io-apic RTE aswell with the update
2317 * vector information, along with modifying IRTE with vector and destination.
2318 * So irq migration for level triggered is little bit more complex compared to
2319 * edge triggered migration. But the good news is, we use the same algorithm
2320 * for level triggered migration as we have today, only difference being,
2321 * we now initiate the irq migration from process context instead of the
2322 * interrupt context.
2323 *
2324 * In future, when we do a directed EOI (combined with cpu EOI broadcast
2325 * suppression) to the IO-APIC, level triggered irq migration will also be
2326 * as simple as edge triggered migration and we can do the irq migration
2327 * with a simple atomic update to IO-APIC RTE.
2328 */
2329static void
2330migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
2331{
2332 struct irq_cfg *cfg;
2333 struct irte irte;
2334 int modify_ioapic_rte;
2335 unsigned int dest;
2336 unsigned long flags;
2337 unsigned int irq;
2338
2339 if (!cpumask_intersects(mask, cpu_online_mask))
2340 return;
2341
2342 irq = desc->irq;
2343 if (get_irte(irq, &irte))
2344 return;
2345
2346 cfg = desc->chip_data;
2347 if (assign_irq_vector(irq, cfg, mask))
2348 return;
2349
2350 set_extra_move_desc(desc, mask);
2351
2352 dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
2353
2354 modify_ioapic_rte = desc->status & IRQ_LEVEL;
2355 if (modify_ioapic_rte) {
2356 spin_lock_irqsave(&ioapic_lock, flags);
2357 __target_IO_APIC_irq(irq, dest, cfg);
2358 spin_unlock_irqrestore(&ioapic_lock, flags);
2359 }
2360
2361 irte.vector = cfg->vector;
2362 irte.dest_id = IRTE_DEST(dest);
2363
2364 /*
2365 * Modified the IRTE and flushes the Interrupt entry cache.
2366 */
2367 modify_irte(irq, &irte);
2368
2369 if (cfg->move_in_progress)
2370 send_cleanup_vector(cfg);
2371
2372 cpumask_copy(desc->affinity, mask);
2373}
2374
2375static int migrate_irq_remapped_level_desc(struct irq_desc *desc)
2376{
2377 int ret = -1;
2378 struct irq_cfg *cfg = desc->chip_data;
2379
2380 mask_IO_APIC_irq_desc(desc);
2381
2382 if (io_apic_level_ack_pending(cfg)) {
2383 /*
2384 * Interrupt in progress. Migrating irq now will change the
2385 * vector information in the IO-APIC RTE and that will confuse
2386 * the EOI broadcast performed by cpu.
2387 * So, delay the irq migration to the next instance.
2388 */
2389 schedule_delayed_work(&ir_migration_work, 1);
2390 goto unmask;
2391 }
2392
2393 /* everthing is clear. we have right of way */
2394 migrate_ioapic_irq_desc(desc, desc->pending_mask);
2395
2396 ret = 0;
2397 desc->status &= ~IRQ_MOVE_PENDING;
2398 cpumask_clear(desc->pending_mask);
2399
2400unmask:
2401 unmask_IO_APIC_irq_desc(desc);
2402
2403 return ret;
2404}
2405
2406static void ir_irq_migration(struct work_struct *work)
2407{
2408 unsigned int irq;
2409 struct irq_desc *desc;
2410
2411 for_each_irq_desc(irq, desc) {
2412 if (desc->status & IRQ_MOVE_PENDING) {
2413 unsigned long flags;
2414
2415 spin_lock_irqsave(&desc->lock, flags);
2416 if (!desc->chip->set_affinity ||
2417 !(desc->status & IRQ_MOVE_PENDING)) {
2418 desc->status &= ~IRQ_MOVE_PENDING;
2419 spin_unlock_irqrestore(&desc->lock, flags);
2420 continue;
2421 }
2422
2423 desc->chip->set_affinity(irq, desc->pending_mask);
2424 spin_unlock_irqrestore(&desc->lock, flags);
2425 }
2426 }
2427}
2428
2429/*
2430 * Migrates the IRQ destination in the process context.
2431 */
2432static void set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc,
2433 const struct cpumask *mask)
2434{
2435 if (desc->status & IRQ_LEVEL) {
2436 desc->status |= IRQ_MOVE_PENDING;
2437 cpumask_copy(desc->pending_mask, mask);
2438 migrate_irq_remapped_level_desc(desc);
2439 return;
2440 }
2441
2442 migrate_ioapic_irq_desc(desc, mask);
2443}
2444static void set_ir_ioapic_affinity_irq(unsigned int irq,
2445 const struct cpumask *mask)
2446{
2447 struct irq_desc *desc = irq_to_desc(irq);
2448
2449 set_ir_ioapic_affinity_irq_desc(desc, mask);
2450}
2451#endif
2452
2453asmlinkage void smp_irq_move_cleanup_interrupt(void)
2454{
2455 unsigned vector, me;
2456
2457 ack_APIC_irq();
2458 exit_idle();
2459 irq_enter();
2460
2461 me = smp_processor_id();
2462 for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
2463 unsigned int irq;
2464 struct irq_desc *desc;
2465 struct irq_cfg *cfg;
2466 irq = __get_cpu_var(vector_irq)[vector];
2467
2468 if (irq == -1)
2469 continue;
2470
2471 desc = irq_to_desc(irq);
2472 if (!desc)
2473 continue;
2474
2475 cfg = irq_cfg(irq);
2476 spin_lock(&desc->lock);
2477 if (!cfg->move_cleanup_count)
2478 goto unlock;
2479
2480 if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2481 goto unlock;
2482
2483 __get_cpu_var(vector_irq)[vector] = -1;
2484 cfg->move_cleanup_count--;
2485unlock:
2486 spin_unlock(&desc->lock);
2487 }
2488
2489 irq_exit();
2490}
2491
2492static void irq_complete_move(struct irq_desc **descp)
2493{
2494 struct irq_desc *desc = *descp;
2495 struct irq_cfg *cfg = desc->chip_data;
2496 unsigned vector, me;
2497
2498 if (likely(!cfg->move_in_progress)) {
2499#ifdef CONFIG_NUMA_MIGRATE_IRQ_DESC
2500 if (likely(!cfg->move_desc_pending))
2501 return;
2502
2503 /* domain has not changed, but affinity did */
2504 me = smp_processor_id();
2505 if (cpumask_test_cpu(me, desc->affinity)) {
2506 *descp = desc = move_irq_desc(desc, me);
2507 /* get the new one */
2508 cfg = desc->chip_data;
2509 cfg->move_desc_pending = 0;
2510 }
2511#endif
2512 return;
2513 }
2514
2515 vector = ~get_irq_regs()->orig_ax;
2516 me = smp_processor_id();
2517
2518 if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain)) {
2519#ifdef CONFIG_NUMA_MIGRATE_IRQ_DESC
2520 *descp = desc = move_irq_desc(desc, me);
2521 /* get the new one */
2522 cfg = desc->chip_data;
2523#endif
2524 send_cleanup_vector(cfg);
2525 }
2526}
2527#else
2528static inline void irq_complete_move(struct irq_desc **descp) {}
2529#endif
2530
2531#ifdef CONFIG_INTR_REMAP
2532static void ack_x2apic_level(unsigned int irq)
2533{
2534 ack_x2APIC_irq();
2535}
2536
2537static void ack_x2apic_edge(unsigned int irq)
2538{
2539 ack_x2APIC_irq();
2540}
2541
2542#endif
2543
2544static void ack_apic_edge(unsigned int irq)
2545{
2546 struct irq_desc *desc = irq_to_desc(irq);
2547
2548 irq_complete_move(&desc);
2549 move_native_irq(irq);
2550 ack_APIC_irq();
2551}
2552
2553atomic_t irq_mis_count;
2554
2555static void ack_apic_level(unsigned int irq)
2556{
2557 struct irq_desc *desc = irq_to_desc(irq);
2558
2559#ifdef CONFIG_X86_32
2560 unsigned long v;
2561 int i;
2562#endif
2563 struct irq_cfg *cfg;
2564 int do_unmask_irq = 0;
2565
2566 irq_complete_move(&desc);
2567#ifdef CONFIG_GENERIC_PENDING_IRQ
2568 /* If we are moving the irq we need to mask it */
2569 if (unlikely(desc->status & IRQ_MOVE_PENDING)) {
2570 do_unmask_irq = 1;
2571 mask_IO_APIC_irq_desc(desc);
2572 }
2573#endif
2574
2575#ifdef CONFIG_X86_32
2576 /*
2577 * It appears there is an erratum which affects at least version 0x11
2578 * of I/O APIC (that's the 82093AA and cores integrated into various
2579 * chipsets). Under certain conditions a level-triggered interrupt is
2580 * erroneously delivered as edge-triggered one but the respective IRR
2581 * bit gets set nevertheless. As a result the I/O unit expects an EOI
2582 * message but it will never arrive and further interrupts are blocked
2583 * from the source. The exact reason is so far unknown, but the
2584 * phenomenon was observed when two consecutive interrupt requests
2585 * from a given source get delivered to the same CPU and the source is
2586 * temporarily disabled in between.
2587 *
2588 * A workaround is to simulate an EOI message manually. We achieve it
2589 * by setting the trigger mode to edge and then to level when the edge
2590 * trigger mode gets detected in the TMR of a local APIC for a
2591 * level-triggered interrupt. We mask the source for the time of the
2592 * operation to prevent an edge-triggered interrupt escaping meanwhile.
2593 * The idea is from Manfred Spraul. --macro
2594 */
2595 cfg = desc->chip_data;
2596 i = cfg->vector;
2597
2598 v = apic_read(APIC_TMR + ((i & ~0x1f) >> 1));
2599#endif
2600
2601 /*
2602 * We must acknowledge the irq before we move it or the acknowledge will
2603 * not propagate properly.
2604 */
2605 ack_APIC_irq();
2606
2607 /* Now we can move and renable the irq */
2608 if (unlikely(do_unmask_irq)) {
2609 /* Only migrate the irq if the ack has been received.
2610 *
2611 * On rare occasions the broadcast level triggered ack gets
2612 * delayed going to ioapics, and if we reprogram the
2613 * vector while Remote IRR is still set the irq will never
2614 * fire again.
2615 *
2616 * To prevent this scenario we read the Remote IRR bit
2617 * of the ioapic. This has two effects.
2618 * - On any sane system the read of the ioapic will
2619 * flush writes (and acks) going to the ioapic from
2620 * this cpu.
2621 * - We get to see if the ACK has actually been delivered.
2622 *
2623 * Based on failed experiments of reprogramming the
2624 * ioapic entry from outside of irq context starting
2625 * with masking the ioapic entry and then polling until
2626 * Remote IRR was clear before reprogramming the
2627 * ioapic I don't trust the Remote IRR bit to be
2628 * completey accurate.
2629 *
2630 * However there appears to be no other way to plug
2631 * this race, so if the Remote IRR bit is not
2632 * accurate and is causing problems then it is a hardware bug
2633 * and you can go talk to the chipset vendor about it.
2634 */
2635 cfg = desc->chip_data;
2636 if (!io_apic_level_ack_pending(cfg))
2637 move_masked_irq(irq);
2638 unmask_IO_APIC_irq_desc(desc);
2639 }
2640
2641#ifdef CONFIG_X86_32
2642 if (!(v & (1 << (i & 0x1f)))) {
2643 atomic_inc(&irq_mis_count);
2644 spin_lock(&ioapic_lock);
2645 __mask_and_edge_IO_APIC_irq(cfg);
2646 __unmask_and_level_IO_APIC_irq(cfg);
2647 spin_unlock(&ioapic_lock);
2648 }
2649#endif
2650}
2651
2652static struct irq_chip ioapic_chip __read_mostly = {
2653 .name = "IO-APIC",
2654 .startup = startup_ioapic_irq,
2655 .mask = mask_IO_APIC_irq,
2656 .unmask = unmask_IO_APIC_irq,
2657 .ack = ack_apic_edge,
2658 .eoi = ack_apic_level,
2659#ifdef CONFIG_SMP
2660 .set_affinity = set_ioapic_affinity_irq,
2661#endif
2662 .retrigger = ioapic_retrigger_irq,
2663};
2664
2665#ifdef CONFIG_INTR_REMAP
2666static struct irq_chip ir_ioapic_chip __read_mostly = {
2667 .name = "IR-IO-APIC",
2668 .startup = startup_ioapic_irq,
2669 .mask = mask_IO_APIC_irq,
2670 .unmask = unmask_IO_APIC_irq,
2671 .ack = ack_x2apic_edge,
2672 .eoi = ack_x2apic_level,
2673#ifdef CONFIG_SMP
2674 .set_affinity = set_ir_ioapic_affinity_irq,
2675#endif
2676 .retrigger = ioapic_retrigger_irq,
2677};
2678#endif
2679
2680static inline void init_IO_APIC_traps(void)
2681{
2682 int irq;
2683 struct irq_desc *desc;
2684 struct irq_cfg *cfg;
2685
2686 /*
2687 * NOTE! The local APIC isn't very good at handling
2688 * multiple interrupts at the same interrupt level.
2689 * As the interrupt level is determined by taking the
2690 * vector number and shifting that right by 4, we
2691 * want to spread these out a bit so that they don't
2692 * all fall in the same interrupt level.
2693 *
2694 * Also, we've got to be careful not to trash gate
2695 * 0x80, because int 0x80 is hm, kind of importantish. ;)
2696 */
2697 for_each_irq_desc(irq, desc) {
2698 cfg = desc->chip_data;
2699 if (IO_APIC_IRQ(irq) && cfg && !cfg->vector) {
2700 /*
2701 * Hmm.. We don't have an entry for this,
2702 * so default to an old-fashioned 8259
2703 * interrupt if we can..
2704 */
2705 if (irq < NR_IRQS_LEGACY)
2706 make_8259A_irq(irq);
2707 else
2708 /* Strange. Oh, well.. */
2709 desc->chip = &no_irq_chip;
2710 }
2711 }
2712}
2713
2714/*
2715 * The local APIC irq-chip implementation:
2716 */
2717
2718static void mask_lapic_irq(unsigned int irq)
2719{
2720 unsigned long v;
2721
2722 v = apic_read(APIC_LVT0);
2723 apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
2724}
2725
2726static void unmask_lapic_irq(unsigned int irq)
2727{
2728 unsigned long v;
2729
2730 v = apic_read(APIC_LVT0);
2731 apic_write(APIC_LVT0, v & ~APIC_LVT_MASKED);
2732}
2733
2734static void ack_lapic_irq(unsigned int irq)
2735{
2736 ack_APIC_irq();
2737}
2738
2739static struct irq_chip lapic_chip __read_mostly = {
2740 .name = "local-APIC",
2741 .mask = mask_lapic_irq,
2742 .unmask = unmask_lapic_irq,
2743 .ack = ack_lapic_irq,
2744};
2745
2746static void lapic_register_intr(int irq, struct irq_desc *desc)
2747{
2748 desc->status &= ~IRQ_LEVEL;
2749 set_irq_chip_and_handler_name(irq, &lapic_chip, handle_edge_irq,
2750 "edge");
2751}
2752
2753static void __init setup_nmi(void)
2754{
2755 /*
2756 * Dirty trick to enable the NMI watchdog ...
2757 * We put the 8259A master into AEOI mode and
2758 * unmask on all local APICs LVT0 as NMI.
2759 *
2760 * The idea to use the 8259A in AEOI mode ('8259A Virtual Wire')
2761 * is from Maciej W. Rozycki - so we do not have to EOI from
2762 * the NMI handler or the timer interrupt.
2763 */
2764 apic_printk(APIC_VERBOSE, KERN_INFO "activating NMI Watchdog ...");
2765
2766 enable_NMI_through_LVT0();
2767
2768 apic_printk(APIC_VERBOSE, " done.\n");
2769}
2770
2771/*
2772 * This looks a bit hackish but it's about the only one way of sending
2773 * a few INTA cycles to 8259As and any associated glue logic. ICR does
2774 * not support the ExtINT mode, unfortunately. We need to send these
2775 * cycles as some i82489DX-based boards have glue logic that keeps the
2776 * 8259A interrupt line asserted until INTA. --macro
2777 */
2778static inline void __init unlock_ExtINT_logic(void)
2779{
2780 int apic, pin, i;
2781 struct IO_APIC_route_entry entry0, entry1;
2782 unsigned char save_control, save_freq_select;
2783
2784 pin = find_isa_irq_pin(8, mp_INT);
2785 if (pin == -1) {
2786 WARN_ON_ONCE(1);
2787 return;
2788 }
2789 apic = find_isa_irq_apic(8, mp_INT);
2790 if (apic == -1) {
2791 WARN_ON_ONCE(1);
2792 return;
2793 }
2794
2795 entry0 = ioapic_read_entry(apic, pin);
2796 clear_IO_APIC_pin(apic, pin);
2797
2798 memset(&entry1, 0, sizeof(entry1));
2799
2800 entry1.dest_mode = 0; /* physical delivery */
2801 entry1.mask = 0; /* unmask IRQ now */
2802 entry1.dest = hard_smp_processor_id();
2803 entry1.delivery_mode = dest_ExtINT;
2804 entry1.polarity = entry0.polarity;
2805 entry1.trigger = 0;
2806 entry1.vector = 0;
2807
2808 ioapic_write_entry(apic, pin, entry1);
2809
2810 save_control = CMOS_READ(RTC_CONTROL);
2811 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
2812 CMOS_WRITE((save_freq_select & ~RTC_RATE_SELECT) | 0x6,
2813 RTC_FREQ_SELECT);
2814 CMOS_WRITE(save_control | RTC_PIE, RTC_CONTROL);
2815
2816 i = 100;
2817 while (i-- > 0) {
2818 mdelay(10);
2819 if ((CMOS_READ(RTC_INTR_FLAGS) & RTC_PF) == RTC_PF)
2820 i -= 10;
2821 }
2822
2823 CMOS_WRITE(save_control, RTC_CONTROL);
2824 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
2825 clear_IO_APIC_pin(apic, pin);
2826
2827 ioapic_write_entry(apic, pin, entry0);
2828}
2829
2830static int disable_timer_pin_1 __initdata;
2831/* Actually the next is obsolete, but keep it for paranoid reasons -AK */
2832static int __init disable_timer_pin_setup(char *arg)
2833{
2834 disable_timer_pin_1 = 1;
2835 return 0;
2836}
2837early_param("disable_timer_pin_1", disable_timer_pin_setup);
2838
2839int timer_through_8259 __initdata;
2840
2841/*
2842 * This code may look a bit paranoid, but it's supposed to cooperate with
2843 * a wide range of boards and BIOS bugs. Fortunately only the timer IRQ
2844 * is so screwy. Thanks to Brian Perkins for testing/hacking this beast
2845 * fanatically on his truly buggy board.
2846 *
2847 * FIXME: really need to revamp this for all platforms.
2848 */
2849static inline void __init check_timer(void)
2850{
2851 struct irq_desc *desc = irq_to_desc(0);
2852 struct irq_cfg *cfg = desc->chip_data;
2853 int cpu = boot_cpu_id;
2854 int apic1, pin1, apic2, pin2;
2855 unsigned long flags;
2856 int no_pin1 = 0;
2857
2858 local_irq_save(flags);
2859
2860 /*
2861 * get/set the timer IRQ vector:
2862 */
2863 disable_8259A_irq(0);
2864 assign_irq_vector(0, cfg, apic->target_cpus());
2865
2866 /*
2867 * As IRQ0 is to be enabled in the 8259A, the virtual
2868 * wire has to be disabled in the local APIC. Also
2869 * timer interrupts need to be acknowledged manually in
2870 * the 8259A for the i82489DX when using the NMI
2871 * watchdog as that APIC treats NMIs as level-triggered.
2872 * The AEOI mode will finish them in the 8259A
2873 * automatically.
2874 */
2875 apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
2876 init_8259A(1);
2877#ifdef CONFIG_X86_32
2878 {
2879 unsigned int ver;
2880
2881 ver = apic_read(APIC_LVR);
2882 ver = GET_APIC_VERSION(ver);
2883 timer_ack = (nmi_watchdog == NMI_IO_APIC && !APIC_INTEGRATED(ver));
2884 }
2885#endif
2886
2887 pin1 = find_isa_irq_pin(0, mp_INT);
2888 apic1 = find_isa_irq_apic(0, mp_INT);
2889 pin2 = ioapic_i8259.pin;
2890 apic2 = ioapic_i8259.apic;
2891
2892 apic_printk(APIC_QUIET, KERN_INFO "..TIMER: vector=0x%02X "
2893 "apic1=%d pin1=%d apic2=%d pin2=%d\n",
2894 cfg->vector, apic1, pin1, apic2, pin2);
2895
2896 /*
2897 * Some BIOS writers are clueless and report the ExtINTA
2898 * I/O APIC input from the cascaded 8259A as the timer
2899 * interrupt input. So just in case, if only one pin
2900 * was found above, try it both directly and through the
2901 * 8259A.
2902 */
2903 if (pin1 == -1) {
2904#ifdef CONFIG_INTR_REMAP
2905 if (intr_remapping_enabled)
2906 panic("BIOS bug: timer not connected to IO-APIC");
2907#endif
2908 pin1 = pin2;
2909 apic1 = apic2;
2910 no_pin1 = 1;
2911 } else if (pin2 == -1) {
2912 pin2 = pin1;
2913 apic2 = apic1;
2914 }
2915
2916 if (pin1 != -1) {
2917 /*
2918 * Ok, does IRQ0 through the IOAPIC work?
2919 */
2920 if (no_pin1) {
2921 add_pin_to_irq_cpu(cfg, cpu, apic1, pin1);
2922 setup_timer_IRQ0_pin(apic1, pin1, cfg->vector);
2923 } else {
2924 /* for edge trigger, setup_IO_APIC_irq already
2925 * leave it unmasked.
2926 * so only need to unmask if it is level-trigger
2927 * do we really have level trigger timer?
2928 */
2929 int idx;
2930 idx = find_irq_entry(apic1, pin1, mp_INT);
2931 if (idx != -1 && irq_trigger(idx))
2932 unmask_IO_APIC_irq_desc(desc);
2933 }
2934 if (timer_irq_works()) {
2935 if (nmi_watchdog == NMI_IO_APIC) {
2936 setup_nmi();
2937 enable_8259A_irq(0);
2938 }
2939 if (disable_timer_pin_1 > 0)
2940 clear_IO_APIC_pin(0, pin1);
2941 goto out;
2942 }
2943#ifdef CONFIG_INTR_REMAP
2944 if (intr_remapping_enabled)
2945 panic("timer doesn't work through Interrupt-remapped IO-APIC");
2946#endif
2947 local_irq_disable();
2948 clear_IO_APIC_pin(apic1, pin1);
2949 if (!no_pin1)
2950 apic_printk(APIC_QUIET, KERN_ERR "..MP-BIOS bug: "
2951 "8254 timer not connected to IO-APIC\n");
2952
2953 apic_printk(APIC_QUIET, KERN_INFO "...trying to set up timer "
2954 "(IRQ0) through the 8259A ...\n");
2955 apic_printk(APIC_QUIET, KERN_INFO
2956 "..... (found apic %d pin %d) ...\n", apic2, pin2);
2957 /*
2958 * legacy devices should be connected to IO APIC #0
2959 */
2960 replace_pin_at_irq_cpu(cfg, cpu, apic1, pin1, apic2, pin2);
2961 setup_timer_IRQ0_pin(apic2, pin2, cfg->vector);
2962 enable_8259A_irq(0);
2963 if (timer_irq_works()) {
2964 apic_printk(APIC_QUIET, KERN_INFO "....... works.\n");
2965 timer_through_8259 = 1;
2966 if (nmi_watchdog == NMI_IO_APIC) {
2967 disable_8259A_irq(0);
2968 setup_nmi();
2969 enable_8259A_irq(0);
2970 }
2971 goto out;
2972 }
2973 /*
2974 * Cleanup, just in case ...
2975 */
2976 local_irq_disable();
2977 disable_8259A_irq(0);
2978 clear_IO_APIC_pin(apic2, pin2);
2979 apic_printk(APIC_QUIET, KERN_INFO "....... failed.\n");
2980 }
2981
2982 if (nmi_watchdog == NMI_IO_APIC) {
2983 apic_printk(APIC_QUIET, KERN_WARNING "timer doesn't work "
2984 "through the IO-APIC - disabling NMI Watchdog!\n");
2985 nmi_watchdog = NMI_NONE;
2986 }
2987#ifdef CONFIG_X86_32
2988 timer_ack = 0;
2989#endif
2990
2991 apic_printk(APIC_QUIET, KERN_INFO
2992 "...trying to set up timer as Virtual Wire IRQ...\n");
2993
2994 lapic_register_intr(0, desc);
2995 apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector); /* Fixed mode */
2996 enable_8259A_irq(0);
2997
2998 if (timer_irq_works()) {
2999 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
3000 goto out;
3001 }
3002 local_irq_disable();
3003 disable_8259A_irq(0);
3004 apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector);
3005 apic_printk(APIC_QUIET, KERN_INFO "..... failed.\n");
3006
3007 apic_printk(APIC_QUIET, KERN_INFO
3008 "...trying to set up timer as ExtINT IRQ...\n");
3009
3010 init_8259A(0);
3011 make_8259A_irq(0);
3012 apic_write(APIC_LVT0, APIC_DM_EXTINT);
3013
3014 unlock_ExtINT_logic();
3015
3016 if (timer_irq_works()) {
3017 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
3018 goto out;
3019 }
3020 local_irq_disable();
3021 apic_printk(APIC_QUIET, KERN_INFO "..... failed :(.\n");
3022 panic("IO-APIC + timer doesn't work! Boot with apic=debug and send a "
3023 "report. Then try booting with the 'noapic' option.\n");
3024out:
3025 local_irq_restore(flags);
3026}
3027
3028/*
3029 * Traditionally ISA IRQ2 is the cascade IRQ, and is not available
3030 * to devices. However there may be an I/O APIC pin available for
3031 * this interrupt regardless. The pin may be left unconnected, but
3032 * typically it will be reused as an ExtINT cascade interrupt for
3033 * the master 8259A. In the MPS case such a pin will normally be
3034 * reported as an ExtINT interrupt in the MP table. With ACPI
3035 * there is no provision for ExtINT interrupts, and in the absence
3036 * of an override it would be treated as an ordinary ISA I/O APIC
3037 * interrupt, that is edge-triggered and unmasked by default. We
3038 * used to do this, but it caused problems on some systems because
3039 * of the NMI watchdog and sometimes IRQ0 of the 8254 timer using
3040 * the same ExtINT cascade interrupt to drive the local APIC of the
3041 * bootstrap processor. Therefore we refrain from routing IRQ2 to
3042 * the I/O APIC in all cases now. No actual device should request
3043 * it anyway. --macro
3044 */
3045#define PIC_IRQS (1 << PIC_CASCADE_IR)
3046
3047void __init setup_IO_APIC(void)
3048{
3049
3050 /*
3051 * calling enable_IO_APIC() is moved to setup_local_APIC for BP
3052 */
3053
3054 io_apic_irqs = ~PIC_IRQS;
3055
3056 apic_printk(APIC_VERBOSE, "ENABLING IO-APIC IRQs\n");
3057 /*
3058 * Set up IO-APIC IRQ routing.
3059 */
3060#ifdef CONFIG_X86_32
3061 if (!acpi_ioapic)
3062 setup_ioapic_ids_from_mpc();
3063#endif
3064 sync_Arb_IDs();
3065 setup_IO_APIC_irqs();
3066 init_IO_APIC_traps();
3067 check_timer();
3068}
3069
3070/*
3071 * Called after all the initialization is done. If we didnt find any
3072 * APIC bugs then we can allow the modify fast path
3073 */
3074
3075static int __init io_apic_bug_finalize(void)
3076{
3077 if (sis_apic_bug == -1)
3078 sis_apic_bug = 0;
3079 return 0;
3080}
3081
3082late_initcall(io_apic_bug_finalize);
3083
3084struct sysfs_ioapic_data {
3085 struct sys_device dev;
3086 struct IO_APIC_route_entry entry[0];
3087};
3088static struct sysfs_ioapic_data * mp_ioapic_data[MAX_IO_APICS];
3089
3090static int ioapic_suspend(struct sys_device *dev, pm_message_t state)
3091{
3092 struct IO_APIC_route_entry *entry;
3093 struct sysfs_ioapic_data *data;
3094 int i;
3095
3096 data = container_of(dev, struct sysfs_ioapic_data, dev);
3097 entry = data->entry;
3098 for (i = 0; i < nr_ioapic_registers[dev->id]; i ++, entry ++ )
3099 *entry = ioapic_read_entry(dev->id, i);
3100
3101 return 0;
3102}
3103
3104static int ioapic_resume(struct sys_device *dev)
3105{
3106 struct IO_APIC_route_entry *entry;
3107 struct sysfs_ioapic_data *data;
3108 unsigned long flags;
3109 union IO_APIC_reg_00 reg_00;
3110 int i;
3111
3112 data = container_of(dev, struct sysfs_ioapic_data, dev);
3113 entry = data->entry;
3114
3115 spin_lock_irqsave(&ioapic_lock, flags);
3116 reg_00.raw = io_apic_read(dev->id, 0);
3117 if (reg_00.bits.ID != mp_ioapics[dev->id].apicid) {
3118 reg_00.bits.ID = mp_ioapics[dev->id].apicid;
3119 io_apic_write(dev->id, 0, reg_00.raw);
3120 }
3121 spin_unlock_irqrestore(&ioapic_lock, flags);
3122 for (i = 0; i < nr_ioapic_registers[dev->id]; i++)
3123 ioapic_write_entry(dev->id, i, entry[i]);
3124
3125 return 0;
3126}
3127
3128static struct sysdev_class ioapic_sysdev_class = {
3129 .name = "ioapic",
3130 .suspend = ioapic_suspend,
3131 .resume = ioapic_resume,
3132};
3133
3134static int __init ioapic_init_sysfs(void)
3135{
3136 struct sys_device * dev;
3137 int i, size, error;
3138
3139 error = sysdev_class_register(&ioapic_sysdev_class);
3140 if (error)
3141 return error;
3142
3143 for (i = 0; i < nr_ioapics; i++ ) {
3144 size = sizeof(struct sys_device) + nr_ioapic_registers[i]
3145 * sizeof(struct IO_APIC_route_entry);
3146 mp_ioapic_data[i] = kzalloc(size, GFP_KERNEL);
3147 if (!mp_ioapic_data[i]) {
3148 printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
3149 continue;
3150 }
3151 dev = &mp_ioapic_data[i]->dev;
3152 dev->id = i;
3153 dev->cls = &ioapic_sysdev_class;
3154 error = sysdev_register(dev);
3155 if (error) {
3156 kfree(mp_ioapic_data[i]);
3157 mp_ioapic_data[i] = NULL;
3158 printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
3159 continue;
3160 }
3161 }
3162
3163 return 0;
3164}
3165
3166device_initcall(ioapic_init_sysfs);
3167
3168static int nr_irqs_gsi = NR_IRQS_LEGACY;
3169/*
3170 * Dynamic irq allocate and deallocation
3171 */
3172unsigned int create_irq_nr(unsigned int irq_want)
3173{
3174 /* Allocate an unused irq */
3175 unsigned int irq;
3176 unsigned int new;
3177 unsigned long flags;
3178 struct irq_cfg *cfg_new = NULL;
3179 int cpu = boot_cpu_id;
3180 struct irq_desc *desc_new = NULL;
3181
3182 irq = 0;
3183 if (irq_want < nr_irqs_gsi)
3184 irq_want = nr_irqs_gsi;
3185
3186 spin_lock_irqsave(&vector_lock, flags);
3187 for (new = irq_want; new < nr_irqs; new++) {
3188 desc_new = irq_to_desc_alloc_cpu(new, cpu);
3189 if (!desc_new) {
3190 printk(KERN_INFO "can not get irq_desc for %d\n", new);
3191 continue;
3192 }
3193 cfg_new = desc_new->chip_data;
3194
3195 if (cfg_new->vector != 0)
3196 continue;
3197 if (__assign_irq_vector(new, cfg_new, apic->target_cpus()) == 0)
3198 irq = new;
3199 break;
3200 }
3201 spin_unlock_irqrestore(&vector_lock, flags);
3202
3203 if (irq > 0) {
3204 dynamic_irq_init(irq);
3205 /* restore it, in case dynamic_irq_init clear it */
3206 if (desc_new)
3207 desc_new->chip_data = cfg_new;
3208 }
3209 return irq;
3210}
3211
3212int create_irq(void)
3213{
3214 unsigned int irq_want;
3215 int irq;
3216
3217 irq_want = nr_irqs_gsi;
3218 irq = create_irq_nr(irq_want);
3219
3220 if (irq == 0)
3221 irq = -1;
3222
3223 return irq;
3224}
3225
3226void destroy_irq(unsigned int irq)
3227{
3228 unsigned long flags;
3229 struct irq_cfg *cfg;
3230 struct irq_desc *desc;
3231
3232 /* store it, in case dynamic_irq_cleanup clear it */
3233 desc = irq_to_desc(irq);
3234 cfg = desc->chip_data;
3235 dynamic_irq_cleanup(irq);
3236 /* connect back irq_cfg */
3237 if (desc)
3238 desc->chip_data = cfg;
3239
3240#ifdef CONFIG_INTR_REMAP
3241 free_irte(irq);
3242#endif
3243 spin_lock_irqsave(&vector_lock, flags);
3244 __clear_irq_vector(irq, cfg);
3245 spin_unlock_irqrestore(&vector_lock, flags);
3246}
3247
3248/*
3249 * MSI message composition
3250 */
3251#ifdef CONFIG_PCI_MSI
3252static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_msg *msg)
3253{
3254 struct irq_cfg *cfg;
3255 int err;
3256 unsigned dest;
3257
3258 if (disable_apic)
3259 return -ENXIO;
3260
3261 cfg = irq_cfg(irq);
3262 err = assign_irq_vector(irq, cfg, apic->target_cpus());
3263 if (err)
3264 return err;
3265
3266 dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
3267
3268#ifdef CONFIG_INTR_REMAP
3269 if (irq_remapped(irq)) {
3270 struct irte irte;
3271 int ir_index;
3272 u16 sub_handle;
3273
3274 ir_index = map_irq_to_irte_handle(irq, &sub_handle);
3275 BUG_ON(ir_index == -1);
3276
3277 memset (&irte, 0, sizeof(irte));
3278
3279 irte.present = 1;
3280 irte.dst_mode = apic->irq_dest_mode;
3281 irte.trigger_mode = 0; /* edge */
3282 irte.dlvry_mode = apic->irq_delivery_mode;
3283 irte.vector = cfg->vector;
3284 irte.dest_id = IRTE_DEST(dest);
3285
3286 modify_irte(irq, &irte);
3287
3288 msg->address_hi = MSI_ADDR_BASE_HI;
3289 msg->data = sub_handle;
3290 msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
3291 MSI_ADDR_IR_SHV |
3292 MSI_ADDR_IR_INDEX1(ir_index) |
3293 MSI_ADDR_IR_INDEX2(ir_index);
3294 } else
3295#endif
3296 {
3297 msg->address_hi = MSI_ADDR_BASE_HI;
3298 msg->address_lo =
3299 MSI_ADDR_BASE_LO |
3300 ((apic->irq_dest_mode == 0) ?
3301 MSI_ADDR_DEST_MODE_PHYSICAL:
3302 MSI_ADDR_DEST_MODE_LOGICAL) |
3303 ((apic->irq_delivery_mode != dest_LowestPrio) ?
3304 MSI_ADDR_REDIRECTION_CPU:
3305 MSI_ADDR_REDIRECTION_LOWPRI) |
3306 MSI_ADDR_DEST_ID(dest);
3307
3308 msg->data =
3309 MSI_DATA_TRIGGER_EDGE |
3310 MSI_DATA_LEVEL_ASSERT |
3311 ((apic->irq_delivery_mode != dest_LowestPrio) ?
3312 MSI_DATA_DELIVERY_FIXED:
3313 MSI_DATA_DELIVERY_LOWPRI) |
3314 MSI_DATA_VECTOR(cfg->vector);
3315 }
3316 return err;
3317}
3318
3319#ifdef CONFIG_SMP
3320static void set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
3321{
3322 struct irq_desc *desc = irq_to_desc(irq);
3323 struct irq_cfg *cfg;
3324 struct msi_msg msg;
3325 unsigned int dest;
3326
3327 dest = set_desc_affinity(desc, mask);
3328 if (dest == BAD_APICID)
3329 return;
3330
3331 cfg = desc->chip_data;
3332
3333 read_msi_msg_desc(desc, &msg);
3334
3335 msg.data &= ~MSI_DATA_VECTOR_MASK;
3336 msg.data |= MSI_DATA_VECTOR(cfg->vector);
3337 msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3338 msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3339
3340 write_msi_msg_desc(desc, &msg);
3341}
3342#ifdef CONFIG_INTR_REMAP
3343/*
3344 * Migrate the MSI irq to another cpumask. This migration is
3345 * done in the process context using interrupt-remapping hardware.
3346 */
3347static void
3348ir_set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
3349{
3350 struct irq_desc *desc = irq_to_desc(irq);
3351 struct irq_cfg *cfg = desc->chip_data;
3352 unsigned int dest;
3353 struct irte irte;
3354
3355 if (get_irte(irq, &irte))
3356 return;
3357
3358 dest = set_desc_affinity(desc, mask);
3359 if (dest == BAD_APICID)
3360 return;
3361
3362 irte.vector = cfg->vector;
3363 irte.dest_id = IRTE_DEST(dest);
3364
3365 /*
3366 * atomically update the IRTE with the new destination and vector.
3367 */
3368 modify_irte(irq, &irte);
3369
3370 /*
3371 * After this point, all the interrupts will start arriving
3372 * at the new destination. So, time to cleanup the previous
3373 * vector allocation.
3374 */
3375 if (cfg->move_in_progress)
3376 send_cleanup_vector(cfg);
3377}
3378
3379#endif
3380#endif /* CONFIG_SMP */
3381
3382/*
3383 * IRQ Chip for MSI PCI/PCI-X/PCI-Express Devices,
3384 * which implement the MSI or MSI-X Capability Structure.
3385 */
3386static struct irq_chip msi_chip = {
3387 .name = "PCI-MSI",
3388 .unmask = unmask_msi_irq,
3389 .mask = mask_msi_irq,
3390 .ack = ack_apic_edge,
3391#ifdef CONFIG_SMP
3392 .set_affinity = set_msi_irq_affinity,
3393#endif
3394 .retrigger = ioapic_retrigger_irq,
3395};
3396
3397#ifdef CONFIG_INTR_REMAP
3398static struct irq_chip msi_ir_chip = {
3399 .name = "IR-PCI-MSI",
3400 .unmask = unmask_msi_irq,
3401 .mask = mask_msi_irq,
3402 .ack = ack_x2apic_edge,
3403#ifdef CONFIG_SMP
3404 .set_affinity = ir_set_msi_irq_affinity,
3405#endif
3406 .retrigger = ioapic_retrigger_irq,
3407};
3408
3409/*
3410 * Map the PCI dev to the corresponding remapping hardware unit
3411 * and allocate 'nvec' consecutive interrupt-remapping table entries
3412 * in it.
3413 */
3414static int msi_alloc_irte(struct pci_dev *dev, int irq, int nvec)
3415{
3416 struct intel_iommu *iommu;
3417 int index;
3418
3419 iommu = map_dev_to_ir(dev);
3420 if (!iommu) {
3421 printk(KERN_ERR
3422 "Unable to map PCI %s to iommu\n", pci_name(dev));
3423 return -ENOENT;
3424 }
3425
3426 index = alloc_irte(iommu, irq, nvec);
3427 if (index < 0) {
3428 printk(KERN_ERR
3429 "Unable to allocate %d IRTE for PCI %s\n", nvec,
3430 pci_name(dev));
3431 return -ENOSPC;
3432 }
3433 return index;
3434}
3435#endif
3436
3437static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq)
3438{
3439 int ret;
3440 struct msi_msg msg;
3441
3442 ret = msi_compose_msg(dev, irq, &msg);
3443 if (ret < 0)
3444 return ret;
3445
3446 set_irq_msi(irq, msidesc);
3447 write_msi_msg(irq, &msg);
3448
3449#ifdef CONFIG_INTR_REMAP
3450 if (irq_remapped(irq)) {
3451 struct irq_desc *desc = irq_to_desc(irq);
3452 /*
3453 * irq migration in process context
3454 */
3455 desc->status |= IRQ_MOVE_PCNTXT;
3456 set_irq_chip_and_handler_name(irq, &msi_ir_chip, handle_edge_irq, "edge");
3457 } else
3458#endif
3459 set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge");
3460
3461 dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq);
3462
3463 return 0;
3464}
3465
3466int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
3467{
3468 unsigned int irq;
3469 int ret, sub_handle;
3470 struct msi_desc *msidesc;
3471 unsigned int irq_want;
3472
3473#ifdef CONFIG_INTR_REMAP
3474 struct intel_iommu *iommu = 0;
3475 int index = 0;
3476#endif
3477
3478 irq_want = nr_irqs_gsi;
3479 sub_handle = 0;
3480 list_for_each_entry(msidesc, &dev->msi_list, list) {
3481 irq = create_irq_nr(irq_want);
3482 if (irq == 0)
3483 return -1;
3484 irq_want = irq + 1;
3485#ifdef CONFIG_INTR_REMAP
3486 if (!intr_remapping_enabled)
3487 goto no_ir;
3488
3489 if (!sub_handle) {
3490 /*
3491 * allocate the consecutive block of IRTE's
3492 * for 'nvec'
3493 */
3494 index = msi_alloc_irte(dev, irq, nvec);
3495 if (index < 0) {
3496 ret = index;
3497 goto error;
3498 }
3499 } else {
3500 iommu = map_dev_to_ir(dev);
3501 if (!iommu) {
3502 ret = -ENOENT;
3503 goto error;
3504 }
3505 /*
3506 * setup the mapping between the irq and the IRTE
3507 * base index, the sub_handle pointing to the
3508 * appropriate interrupt remap table entry.
3509 */
3510 set_irte_irq(irq, iommu, index, sub_handle);
3511 }
3512no_ir:
3513#endif
3514 ret = setup_msi_irq(dev, msidesc, irq);
3515 if (ret < 0)
3516 goto error;
3517 sub_handle++;
3518 }
3519 return 0;
3520
3521error:
3522 destroy_irq(irq);
3523 return ret;
3524}
3525
3526void arch_teardown_msi_irq(unsigned int irq)
3527{
3528 destroy_irq(irq);
3529}
3530
3531#ifdef CONFIG_DMAR
3532#ifdef CONFIG_SMP
3533static void dmar_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
3534{
3535 struct irq_desc *desc = irq_to_desc(irq);
3536 struct irq_cfg *cfg;
3537 struct msi_msg msg;
3538 unsigned int dest;
3539
3540 dest = set_desc_affinity(desc, mask);
3541 if (dest == BAD_APICID)
3542 return;
3543
3544 cfg = desc->chip_data;
3545
3546 dmar_msi_read(irq, &msg);
3547
3548 msg.data &= ~MSI_DATA_VECTOR_MASK;
3549 msg.data |= MSI_DATA_VECTOR(cfg->vector);
3550 msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3551 msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3552
3553 dmar_msi_write(irq, &msg);
3554}
3555
3556#endif /* CONFIG_SMP */
3557
3558struct irq_chip dmar_msi_type = {
3559 .name = "DMAR_MSI",
3560 .unmask = dmar_msi_unmask,
3561 .mask = dmar_msi_mask,
3562 .ack = ack_apic_edge,
3563#ifdef CONFIG_SMP
3564 .set_affinity = dmar_msi_set_affinity,
3565#endif
3566 .retrigger = ioapic_retrigger_irq,
3567};
3568
3569int arch_setup_dmar_msi(unsigned int irq)
3570{
3571 int ret;
3572 struct msi_msg msg;
3573
3574 ret = msi_compose_msg(NULL, irq, &msg);
3575 if (ret < 0)
3576 return ret;
3577 dmar_msi_write(irq, &msg);
3578 set_irq_chip_and_handler_name(irq, &dmar_msi_type, handle_edge_irq,
3579 "edge");
3580 return 0;
3581}
3582#endif
3583
3584#ifdef CONFIG_HPET_TIMER
3585
3586#ifdef CONFIG_SMP
3587static void hpet_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
3588{
3589 struct irq_desc *desc = irq_to_desc(irq);
3590 struct irq_cfg *cfg;
3591 struct msi_msg msg;
3592 unsigned int dest;
3593
3594 dest = set_desc_affinity(desc, mask);
3595 if (dest == BAD_APICID)
3596 return;
3597
3598 cfg = desc->chip_data;
3599
3600 hpet_msi_read(irq, &msg);
3601
3602 msg.data &= ~MSI_DATA_VECTOR_MASK;
3603 msg.data |= MSI_DATA_VECTOR(cfg->vector);
3604 msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3605 msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3606
3607 hpet_msi_write(irq, &msg);
3608}
3609
3610#endif /* CONFIG_SMP */
3611
3612struct irq_chip hpet_msi_type = {
3613 .name = "HPET_MSI",
3614 .unmask = hpet_msi_unmask,
3615 .mask = hpet_msi_mask,
3616 .ack = ack_apic_edge,
3617#ifdef CONFIG_SMP
3618 .set_affinity = hpet_msi_set_affinity,
3619#endif
3620 .retrigger = ioapic_retrigger_irq,
3621};
3622
3623int arch_setup_hpet_msi(unsigned int irq)
3624{
3625 int ret;
3626 struct msi_msg msg;
3627
3628 ret = msi_compose_msg(NULL, irq, &msg);
3629 if (ret < 0)
3630 return ret;
3631
3632 hpet_msi_write(irq, &msg);
3633 set_irq_chip_and_handler_name(irq, &hpet_msi_type, handle_edge_irq,
3634 "edge");
3635
3636 return 0;
3637}
3638#endif
3639
3640#endif /* CONFIG_PCI_MSI */
3641/*
3642 * Hypertransport interrupt support
3643 */
3644#ifdef CONFIG_HT_IRQ
3645
3646#ifdef CONFIG_SMP
3647
3648static void target_ht_irq(unsigned int irq, unsigned int dest, u8 vector)
3649{
3650 struct ht_irq_msg msg;
3651 fetch_ht_irq_msg(irq, &msg);
3652
3653 msg.address_lo &= ~(HT_IRQ_LOW_VECTOR_MASK | HT_IRQ_LOW_DEST_ID_MASK);
3654 msg.address_hi &= ~(HT_IRQ_HIGH_DEST_ID_MASK);
3655
3656 msg.address_lo |= HT_IRQ_LOW_VECTOR(vector) | HT_IRQ_LOW_DEST_ID(dest);
3657 msg.address_hi |= HT_IRQ_HIGH_DEST_ID(dest);
3658
3659 write_ht_irq_msg(irq, &msg);
3660}
3661
3662static void set_ht_irq_affinity(unsigned int irq, const struct cpumask *mask)
3663{
3664 struct irq_desc *desc = irq_to_desc(irq);
3665 struct irq_cfg *cfg;
3666 unsigned int dest;
3667
3668 dest = set_desc_affinity(desc, mask);
3669 if (dest == BAD_APICID)
3670 return;
3671
3672 cfg = desc->chip_data;
3673
3674 target_ht_irq(irq, dest, cfg->vector);
3675}
3676
3677#endif
3678
3679static struct irq_chip ht_irq_chip = {
3680 .name = "PCI-HT",
3681 .mask = mask_ht_irq,
3682 .unmask = unmask_ht_irq,
3683 .ack = ack_apic_edge,
3684#ifdef CONFIG_SMP
3685 .set_affinity = set_ht_irq_affinity,
3686#endif
3687 .retrigger = ioapic_retrigger_irq,
3688};
3689
3690int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev)
3691{
3692 struct irq_cfg *cfg;
3693 int err;
3694
3695 if (disable_apic)
3696 return -ENXIO;
3697
3698 cfg = irq_cfg(irq);
3699 err = assign_irq_vector(irq, cfg, apic->target_cpus());
3700 if (!err) {
3701 struct ht_irq_msg msg;
3702 unsigned dest;
3703
3704 dest = apic->cpu_mask_to_apicid_and(cfg->domain,
3705 apic->target_cpus());
3706
3707 msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
3708
3709 msg.address_lo =
3710 HT_IRQ_LOW_BASE |
3711 HT_IRQ_LOW_DEST_ID(dest) |
3712 HT_IRQ_LOW_VECTOR(cfg->vector) |
3713 ((apic->irq_dest_mode == 0) ?
3714 HT_IRQ_LOW_DM_PHYSICAL :
3715 HT_IRQ_LOW_DM_LOGICAL) |
3716 HT_IRQ_LOW_RQEOI_EDGE |
3717 ((apic->irq_delivery_mode != dest_LowestPrio) ?
3718 HT_IRQ_LOW_MT_FIXED :
3719 HT_IRQ_LOW_MT_ARBITRATED) |
3720 HT_IRQ_LOW_IRQ_MASKED;
3721
3722 write_ht_irq_msg(irq, &msg);
3723
3724 set_irq_chip_and_handler_name(irq, &ht_irq_chip,
3725 handle_edge_irq, "edge");
3726
3727 dev_printk(KERN_DEBUG, &dev->dev, "irq %d for HT\n", irq);
3728 }
3729 return err;
3730}
3731#endif /* CONFIG_HT_IRQ */
3732
3733#ifdef CONFIG_X86_UV
3734/*
3735 * Re-target the irq to the specified CPU and enable the specified MMR located
3736 * on the specified blade to allow the sending of MSIs to the specified CPU.
3737 */
3738int arch_enable_uv_irq(char *irq_name, unsigned int irq, int cpu, int mmr_blade,
3739 unsigned long mmr_offset)
3740{
3741 const struct cpumask *eligible_cpu = cpumask_of(cpu);
3742 struct irq_cfg *cfg;
3743 int mmr_pnode;
3744 unsigned long mmr_value;
3745 struct uv_IO_APIC_route_entry *entry;
3746 unsigned long flags;
3747 int err;
3748
3749 cfg = irq_cfg(irq);
3750
3751 err = assign_irq_vector(irq, cfg, eligible_cpu);
3752 if (err != 0)
3753 return err;
3754
3755 spin_lock_irqsave(&vector_lock, flags);
3756 set_irq_chip_and_handler_name(irq, &uv_irq_chip, handle_percpu_irq,
3757 irq_name);
3758 spin_unlock_irqrestore(&vector_lock, flags);
3759
3760 mmr_value = 0;
3761 entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
3762 BUG_ON(sizeof(struct uv_IO_APIC_route_entry) != sizeof(unsigned long));
3763
3764 entry->vector = cfg->vector;
3765 entry->delivery_mode = apic->irq_delivery_mode;
3766 entry->dest_mode = apic->irq_dest_mode;
3767 entry->polarity = 0;
3768 entry->trigger = 0;
3769 entry->mask = 0;
3770 entry->dest = apic->cpu_mask_to_apicid(eligible_cpu);
3771
3772 mmr_pnode = uv_blade_to_pnode(mmr_blade);
3773 uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
3774
3775 return irq;
3776}
3777
3778/*
3779 * Disable the specified MMR located on the specified blade so that MSIs are
3780 * longer allowed to be sent.
3781 */
3782void arch_disable_uv_irq(int mmr_blade, unsigned long mmr_offset)
3783{
3784 unsigned long mmr_value;
3785 struct uv_IO_APIC_route_entry *entry;
3786 int mmr_pnode;
3787
3788 mmr_value = 0;
3789 entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
3790 BUG_ON(sizeof(struct uv_IO_APIC_route_entry) != sizeof(unsigned long));
3791
3792 entry->mask = 1;
3793
3794 mmr_pnode = uv_blade_to_pnode(mmr_blade);
3795 uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
3796}
3797#endif /* CONFIG_X86_64 */
3798
3799int __init io_apic_get_redir_entries (int ioapic)
3800{
3801 union IO_APIC_reg_01 reg_01;
3802 unsigned long flags;
3803
3804 spin_lock_irqsave(&ioapic_lock, flags);
3805 reg_01.raw = io_apic_read(ioapic, 1);
3806 spin_unlock_irqrestore(&ioapic_lock, flags);
3807
3808 return reg_01.bits.entries;
3809}
3810
3811void __init probe_nr_irqs_gsi(void)
3812{
3813 int nr = 0;
3814
3815 nr = acpi_probe_gsi();
3816 if (nr > nr_irqs_gsi) {
3817 nr_irqs_gsi = nr;
3818 } else {
3819 /* for acpi=off or acpi is not compiled in */
3820 int idx;
3821
3822 nr = 0;
3823 for (idx = 0; idx < nr_ioapics; idx++)
3824 nr += io_apic_get_redir_entries(idx) + 1;
3825
3826 if (nr > nr_irqs_gsi)
3827 nr_irqs_gsi = nr;
3828 }
3829
3830 printk(KERN_DEBUG "nr_irqs_gsi: %d\n", nr_irqs_gsi);
3831}
3832
3833#ifdef CONFIG_SPARSE_IRQ
3834int __init arch_probe_nr_irqs(void)
3835{
3836 int nr;
3837
3838 if (nr_irqs > (NR_VECTORS * nr_cpu_ids))
3839 nr_irqs = NR_VECTORS * nr_cpu_ids;
3840
3841 nr = nr_irqs_gsi + 8 * nr_cpu_ids;
3842#if defined(CONFIG_PCI_MSI) || defined(CONFIG_HT_IRQ)
3843 /*
3844 * for MSI and HT dyn irq
3845 */
3846 nr += nr_irqs_gsi * 16;
3847#endif
3848 if (nr < nr_irqs)
3849 nr_irqs = nr;
3850
3851 return 0;
3852}
3853#endif
3854
3855/* --------------------------------------------------------------------------
3856 ACPI-based IOAPIC Configuration
3857 -------------------------------------------------------------------------- */
3858
3859#ifdef CONFIG_ACPI
3860
3861#ifdef CONFIG_X86_32
3862int __init io_apic_get_unique_id(int ioapic, int apic_id)
3863{
3864 union IO_APIC_reg_00 reg_00;
3865 static physid_mask_t apic_id_map = PHYSID_MASK_NONE;
3866 physid_mask_t tmp;
3867 unsigned long flags;
3868 int i = 0;
3869
3870 /*
3871 * The P4 platform supports up to 256 APIC IDs on two separate APIC
3872 * buses (one for LAPICs, one for IOAPICs), where predecessors only
3873 * supports up to 16 on one shared APIC bus.
3874 *
3875 * TBD: Expand LAPIC/IOAPIC support on P4-class systems to take full
3876 * advantage of new APIC bus architecture.
3877 */
3878
3879 if (physids_empty(apic_id_map))
3880 apic_id_map = apic->ioapic_phys_id_map(phys_cpu_present_map);
3881
3882 spin_lock_irqsave(&ioapic_lock, flags);
3883 reg_00.raw = io_apic_read(ioapic, 0);
3884 spin_unlock_irqrestore(&ioapic_lock, flags);
3885
3886 if (apic_id >= get_physical_broadcast()) {
3887 printk(KERN_WARNING "IOAPIC[%d]: Invalid apic_id %d, trying "
3888 "%d\n", ioapic, apic_id, reg_00.bits.ID);
3889 apic_id = reg_00.bits.ID;
3890 }
3891
3892 /*
3893 * Every APIC in a system must have a unique ID or we get lots of nice
3894 * 'stuck on smp_invalidate_needed IPI wait' messages.
3895 */
3896 if (apic->check_apicid_used(apic_id_map, apic_id)) {
3897
3898 for (i = 0; i < get_physical_broadcast(); i++) {
3899 if (!apic->check_apicid_used(apic_id_map, i))
3900 break;
3901 }
3902
3903 if (i == get_physical_broadcast())
3904 panic("Max apic_id exceeded!\n");
3905
3906 printk(KERN_WARNING "IOAPIC[%d]: apic_id %d already used, "
3907 "trying %d\n", ioapic, apic_id, i);
3908
3909 apic_id = i;
3910 }
3911
3912 tmp = apic->apicid_to_cpu_present(apic_id);
3913 physids_or(apic_id_map, apic_id_map, tmp);
3914
3915 if (reg_00.bits.ID != apic_id) {
3916 reg_00.bits.ID = apic_id;
3917
3918 spin_lock_irqsave(&ioapic_lock, flags);
3919 io_apic_write(ioapic, 0, reg_00.raw);
3920 reg_00.raw = io_apic_read(ioapic, 0);
3921 spin_unlock_irqrestore(&ioapic_lock, flags);
3922
3923 /* Sanity check */
3924 if (reg_00.bits.ID != apic_id) {
3925 printk("IOAPIC[%d]: Unable to change apic_id!\n", ioapic);
3926 return -1;
3927 }
3928 }
3929
3930 apic_printk(APIC_VERBOSE, KERN_INFO
3931 "IOAPIC[%d]: Assigned apic_id %d\n", ioapic, apic_id);
3932
3933 return apic_id;
3934}
3935
3936int __init io_apic_get_version(int ioapic)
3937{
3938 union IO_APIC_reg_01 reg_01;
3939 unsigned long flags;
3940
3941 spin_lock_irqsave(&ioapic_lock, flags);
3942 reg_01.raw = io_apic_read(ioapic, 1);
3943 spin_unlock_irqrestore(&ioapic_lock, flags);
3944
3945 return reg_01.bits.version;
3946}
3947#endif
3948
3949int io_apic_set_pci_routing (int ioapic, int pin, int irq, int triggering, int polarity)
3950{
3951 struct irq_desc *desc;
3952 struct irq_cfg *cfg;
3953 int cpu = boot_cpu_id;
3954
3955 if (!IO_APIC_IRQ(irq)) {
3956 apic_printk(APIC_QUIET,KERN_ERR "IOAPIC[%d]: Invalid reference to IRQ 0\n",
3957 ioapic);
3958 return -EINVAL;
3959 }
3960
3961 desc = irq_to_desc_alloc_cpu(irq, cpu);
3962 if (!desc) {
3963 printk(KERN_INFO "can not get irq_desc %d\n", irq);
3964 return 0;
3965 }
3966
3967 /*
3968 * IRQs < 16 are already in the irq_2_pin[] map
3969 */
3970 if (irq >= NR_IRQS_LEGACY) {
3971 cfg = desc->chip_data;
3972 add_pin_to_irq_cpu(cfg, cpu, ioapic, pin);
3973 }
3974
3975 setup_IO_APIC_irq(ioapic, pin, irq, desc, triggering, polarity);
3976
3977 return 0;
3978}
3979
3980
3981int acpi_get_override_irq(int bus_irq, int *trigger, int *polarity)
3982{
3983 int i;
3984
3985 if (skip_ioapic_setup)
3986 return -1;
3987
3988 for (i = 0; i < mp_irq_entries; i++)
3989 if (mp_irqs[i].irqtype == mp_INT &&
3990 mp_irqs[i].srcbusirq == bus_irq)
3991 break;
3992 if (i >= mp_irq_entries)
3993 return -1;
3994
3995 *trigger = irq_trigger(i);
3996 *polarity = irq_polarity(i);
3997 return 0;
3998}
3999
4000#endif /* CONFIG_ACPI */
4001
4002/*
4003 * This function currently is only a helper for the i386 smp boot process where
4004 * we need to reprogram the ioredtbls to cater for the cpus which have come online
4005 * so mask in all cases should simply be apic->target_cpus()
4006 */
4007#ifdef CONFIG_SMP
4008void __init setup_ioapic_dest(void)
4009{
4010 int pin, ioapic, irq, irq_entry;
4011 struct irq_desc *desc;
4012 struct irq_cfg *cfg;
4013 const struct cpumask *mask;
4014
4015 if (skip_ioapic_setup == 1)
4016 return;
4017
4018 for (ioapic = 0; ioapic < nr_ioapics; ioapic++) {
4019 for (pin = 0; pin < nr_ioapic_registers[ioapic]; pin++) {
4020 irq_entry = find_irq_entry(ioapic, pin, mp_INT);
4021 if (irq_entry == -1)
4022 continue;
4023 irq = pin_2_irq(irq_entry, ioapic, pin);
4024
4025 /* setup_IO_APIC_irqs could fail to get vector for some device
4026 * when you have too many devices, because at that time only boot
4027 * cpu is online.
4028 */
4029 desc = irq_to_desc(irq);
4030 cfg = desc->chip_data;
4031 if (!cfg->vector) {
4032 setup_IO_APIC_irq(ioapic, pin, irq, desc,
4033 irq_trigger(irq_entry),
4034 irq_polarity(irq_entry));
4035 continue;
4036
4037 }
4038
4039 /*
4040 * Honour affinities which have been set in early boot
4041 */
4042 if (desc->status &
4043 (IRQ_NO_BALANCING | IRQ_AFFINITY_SET))
4044 mask = desc->affinity;
4045 else
4046 mask = apic->target_cpus();
4047
4048#ifdef CONFIG_INTR_REMAP
4049 if (intr_remapping_enabled)
4050 set_ir_ioapic_affinity_irq_desc(desc, mask);
4051 else
4052#endif
4053 set_ioapic_affinity_irq_desc(desc, mask);
4054 }
4055
4056 }
4057}
4058#endif
4059
4060#define IOAPIC_RESOURCE_NAME_SIZE 11
4061
4062static struct resource *ioapic_resources;
4063
4064static struct resource * __init ioapic_setup_resources(void)
4065{
4066 unsigned long n;
4067 struct resource *res;
4068 char *mem;
4069 int i;
4070
4071 if (nr_ioapics <= 0)
4072 return NULL;
4073
4074 n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource);
4075 n *= nr_ioapics;
4076
4077 mem = alloc_bootmem(n);
4078 res = (void *)mem;
4079
4080 if (mem != NULL) {
4081 mem += sizeof(struct resource) * nr_ioapics;
4082
4083 for (i = 0; i < nr_ioapics; i++) {
4084 res[i].name = mem;
4085 res[i].flags = IORESOURCE_MEM | IORESOURCE_BUSY;
4086 sprintf(mem, "IOAPIC %u", i);
4087 mem += IOAPIC_RESOURCE_NAME_SIZE;
4088 }
4089 }
4090
4091 ioapic_resources = res;
4092
4093 return res;
4094}
4095
4096void __init ioapic_init_mappings(void)
4097{
4098 unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
4099 struct resource *ioapic_res;
4100 int i;
4101
4102 ioapic_res = ioapic_setup_resources();
4103 for (i = 0; i < nr_ioapics; i++) {
4104 if (smp_found_config) {
4105 ioapic_phys = mp_ioapics[i].apicaddr;
4106#ifdef CONFIG_X86_32
4107 if (!ioapic_phys) {
4108 printk(KERN_ERR
4109 "WARNING: bogus zero IO-APIC "
4110 "address found in MPTABLE, "
4111 "disabling IO/APIC support!\n");
4112 smp_found_config = 0;
4113 skip_ioapic_setup = 1;
4114 goto fake_ioapic_page;
4115 }
4116#endif
4117 } else {
4118#ifdef CONFIG_X86_32
4119fake_ioapic_page:
4120#endif
4121 ioapic_phys = (unsigned long)
4122 alloc_bootmem_pages(PAGE_SIZE);
4123 ioapic_phys = __pa(ioapic_phys);
4124 }
4125 set_fixmap_nocache(idx, ioapic_phys);
4126 apic_printk(APIC_VERBOSE,
4127 "mapped IOAPIC to %08lx (%08lx)\n",
4128 __fix_to_virt(idx), ioapic_phys);
4129 idx++;
4130
4131 if (ioapic_res != NULL) {
4132 ioapic_res->start = ioapic_phys;
4133 ioapic_res->end = ioapic_phys + (4 * 1024) - 1;
4134 ioapic_res++;
4135 }
4136 }
4137}
4138
4139static int __init ioapic_insert_resources(void)
4140{
4141 int i;
4142 struct resource *r = ioapic_resources;
4143
4144 if (!r) {
4145 printk(KERN_ERR
4146 "IO APIC resources could be not be allocated.\n");
4147 return -1;
4148 }
4149
4150 for (i = 0; i < nr_ioapics; i++) {
4151 insert_resource(&iomem_resource, r);
4152 r++;
4153 }
4154
4155 return 0;
4156}
4157
4158/* Insert the IO APIC resources after PCI initialization has occured to handle
4159 * IO APICS that are mapped in on a BAR in PCI space. */
4160late_initcall(ioapic_insert_resources);
diff --git a/arch/x86/kernel/apic/ipi.c b/arch/x86/kernel/apic/ipi.c
new file mode 100644
index 000000000000..dbf5445727a9
--- /dev/null
+++ b/arch/x86/kernel/apic/ipi.c
@@ -0,0 +1,164 @@
1#include <linux/cpumask.h>
2#include <linux/interrupt.h>
3#include <linux/init.h>
4
5#include <linux/mm.h>
6#include <linux/delay.h>
7#include <linux/spinlock.h>
8#include <linux/kernel_stat.h>
9#include <linux/mc146818rtc.h>
10#include <linux/cache.h>
11#include <linux/cpu.h>
12#include <linux/module.h>
13
14#include <asm/smp.h>
15#include <asm/mtrr.h>
16#include <asm/tlbflush.h>
17#include <asm/mmu_context.h>
18#include <asm/apic.h>
19#include <asm/proto.h>
20#include <asm/ipi.h>
21
22void default_send_IPI_mask_sequence_phys(const struct cpumask *mask, int vector)
23{
24 unsigned long query_cpu;
25 unsigned long flags;
26
27 /*
28 * Hack. The clustered APIC addressing mode doesn't allow us to send
29 * to an arbitrary mask, so I do a unicast to each CPU instead.
30 * - mbligh
31 */
32 local_irq_save(flags);
33 for_each_cpu(query_cpu, mask) {
34 __default_send_IPI_dest_field(per_cpu(x86_cpu_to_apicid,
35 query_cpu), vector, APIC_DEST_PHYSICAL);
36 }
37 local_irq_restore(flags);
38}
39
40void default_send_IPI_mask_allbutself_phys(const struct cpumask *mask,
41 int vector)
42{
43 unsigned int this_cpu = smp_processor_id();
44 unsigned int query_cpu;
45 unsigned long flags;
46
47 /* See Hack comment above */
48
49 local_irq_save(flags);
50 for_each_cpu(query_cpu, mask) {
51 if (query_cpu == this_cpu)
52 continue;
53 __default_send_IPI_dest_field(per_cpu(x86_cpu_to_apicid,
54 query_cpu), vector, APIC_DEST_PHYSICAL);
55 }
56 local_irq_restore(flags);
57}
58
59void default_send_IPI_mask_sequence_logical(const struct cpumask *mask,
60 int vector)
61{
62 unsigned long flags;
63 unsigned int query_cpu;
64
65 /*
66 * Hack. The clustered APIC addressing mode doesn't allow us to send
67 * to an arbitrary mask, so I do a unicasts to each CPU instead. This
68 * should be modified to do 1 message per cluster ID - mbligh
69 */
70
71 local_irq_save(flags);
72 for_each_cpu(query_cpu, mask)
73 __default_send_IPI_dest_field(
74 apic->cpu_to_logical_apicid(query_cpu), vector,
75 apic->dest_logical);
76 local_irq_restore(flags);
77}
78
79void default_send_IPI_mask_allbutself_logical(const struct cpumask *mask,
80 int vector)
81{
82 unsigned long flags;
83 unsigned int query_cpu;
84 unsigned int this_cpu = smp_processor_id();
85
86 /* See Hack comment above */
87
88 local_irq_save(flags);
89 for_each_cpu(query_cpu, mask) {
90 if (query_cpu == this_cpu)
91 continue;
92 __default_send_IPI_dest_field(
93 apic->cpu_to_logical_apicid(query_cpu), vector,
94 apic->dest_logical);
95 }
96 local_irq_restore(flags);
97}
98
99#ifdef CONFIG_X86_32
100
101/*
102 * This is only used on smaller machines.
103 */
104void default_send_IPI_mask_logical(const struct cpumask *cpumask, int vector)
105{
106 unsigned long mask = cpumask_bits(cpumask)[0];
107 unsigned long flags;
108
109 local_irq_save(flags);
110 WARN_ON(mask & ~cpumask_bits(cpu_online_mask)[0]);
111 __default_send_IPI_dest_field(mask, vector, apic->dest_logical);
112 local_irq_restore(flags);
113}
114
115void default_send_IPI_allbutself(int vector)
116{
117 /*
118 * if there are no other CPUs in the system then we get an APIC send
119 * error if we try to broadcast, thus avoid sending IPIs in this case.
120 */
121 if (!(num_online_cpus() > 1))
122 return;
123
124 __default_local_send_IPI_allbutself(vector);
125}
126
127void default_send_IPI_all(int vector)
128{
129 __default_local_send_IPI_all(vector);
130}
131
132void default_send_IPI_self(int vector)
133{
134 __default_send_IPI_shortcut(APIC_DEST_SELF, vector, apic->dest_logical);
135}
136
137/* must come after the send_IPI functions above for inlining */
138static int convert_apicid_to_cpu(int apic_id)
139{
140 int i;
141
142 for_each_possible_cpu(i) {
143 if (per_cpu(x86_cpu_to_apicid, i) == apic_id)
144 return i;
145 }
146 return -1;
147}
148
149int safe_smp_processor_id(void)
150{
151 int apicid, cpuid;
152
153 if (!boot_cpu_has(X86_FEATURE_APIC))
154 return 0;
155
156 apicid = hard_smp_processor_id();
157 if (apicid == BAD_APICID)
158 return 0;
159
160 cpuid = convert_apicid_to_cpu(apicid);
161
162 return cpuid >= 0 ? cpuid : 0;
163}
164#endif
diff --git a/arch/x86/kernel/apic/nmi.c b/arch/x86/kernel/apic/nmi.c
new file mode 100644
index 000000000000..bdfad80c3cf1
--- /dev/null
+++ b/arch/x86/kernel/apic/nmi.c
@@ -0,0 +1,564 @@
1/*
2 * NMI watchdog support on APIC systems
3 *
4 * Started by Ingo Molnar <mingo@redhat.com>
5 *
6 * Fixes:
7 * Mikael Pettersson : AMD K7 support for local APIC NMI watchdog.
8 * Mikael Pettersson : Power Management for local APIC NMI watchdog.
9 * Mikael Pettersson : Pentium 4 support for local APIC NMI watchdog.
10 * Pavel Machek and
11 * Mikael Pettersson : PM converted to driver model. Disable/enable API.
12 */
13
14#include <asm/apic.h>
15
16#include <linux/nmi.h>
17#include <linux/mm.h>
18#include <linux/delay.h>
19#include <linux/interrupt.h>
20#include <linux/module.h>
21#include <linux/sysdev.h>
22#include <linux/sysctl.h>
23#include <linux/percpu.h>
24#include <linux/kprobes.h>
25#include <linux/cpumask.h>
26#include <linux/kernel_stat.h>
27#include <linux/kdebug.h>
28#include <linux/smp.h>
29
30#include <asm/i8259.h>
31#include <asm/io_apic.h>
32#include <asm/proto.h>
33#include <asm/timer.h>
34
35#include <asm/mce.h>
36
37#include <asm/mach_traps.h>
38
39int unknown_nmi_panic;
40int nmi_watchdog_enabled;
41
42static cpumask_t backtrace_mask = CPU_MASK_NONE;
43
44/* nmi_active:
45 * >0: the lapic NMI watchdog is active, but can be disabled
46 * <0: the lapic NMI watchdog has not been set up, and cannot
47 * be enabled
48 * 0: the lapic NMI watchdog is disabled, but can be enabled
49 */
50atomic_t nmi_active = ATOMIC_INIT(0); /* oprofile uses this */
51EXPORT_SYMBOL(nmi_active);
52
53unsigned int nmi_watchdog = NMI_NONE;
54EXPORT_SYMBOL(nmi_watchdog);
55
56static int panic_on_timeout;
57
58static unsigned int nmi_hz = HZ;
59static DEFINE_PER_CPU(short, wd_enabled);
60static int endflag __initdata;
61
62static inline unsigned int get_nmi_count(int cpu)
63{
64 return per_cpu(irq_stat, cpu).__nmi_count;
65}
66
67static inline int mce_in_progress(void)
68{
69#if defined(CONFIG_X86_64) && defined(CONFIG_X86_MCE)
70 return atomic_read(&mce_entry) > 0;
71#endif
72 return 0;
73}
74
75/*
76 * Take the local apic timer and PIT/HPET into account. We don't
77 * know which one is active, when we have highres/dyntick on
78 */
79static inline unsigned int get_timer_irqs(int cpu)
80{
81 return per_cpu(irq_stat, cpu).apic_timer_irqs +
82 per_cpu(irq_stat, cpu).irq0_irqs;
83}
84
85#ifdef CONFIG_SMP
86/*
87 * The performance counters used by NMI_LOCAL_APIC don't trigger when
88 * the CPU is idle. To make sure the NMI watchdog really ticks on all
89 * CPUs during the test make them busy.
90 */
91static __init void nmi_cpu_busy(void *data)
92{
93 local_irq_enable_in_hardirq();
94 /*
95 * Intentionally don't use cpu_relax here. This is
96 * to make sure that the performance counter really ticks,
97 * even if there is a simulator or similar that catches the
98 * pause instruction. On a real HT machine this is fine because
99 * all other CPUs are busy with "useless" delay loops and don't
100 * care if they get somewhat less cycles.
101 */
102 while (endflag == 0)
103 mb();
104}
105#endif
106
107static void report_broken_nmi(int cpu, int *prev_nmi_count)
108{
109 printk(KERN_CONT "\n");
110
111 printk(KERN_WARNING
112 "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n",
113 cpu, prev_nmi_count[cpu], get_nmi_count(cpu));
114
115 printk(KERN_WARNING
116 "Please report this to bugzilla.kernel.org,\n");
117 printk(KERN_WARNING
118 "and attach the output of the 'dmesg' command.\n");
119
120 per_cpu(wd_enabled, cpu) = 0;
121 atomic_dec(&nmi_active);
122}
123
124static void __acpi_nmi_disable(void *__unused)
125{
126 apic_write(APIC_LVT0, APIC_DM_NMI | APIC_LVT_MASKED);
127}
128
129int __init check_nmi_watchdog(void)
130{
131 unsigned int *prev_nmi_count;
132 int cpu;
133
134 if (!nmi_watchdog_active() || !atomic_read(&nmi_active))
135 return 0;
136
137 prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
138 if (!prev_nmi_count)
139 goto error;
140
141 printk(KERN_INFO "Testing NMI watchdog ... ");
142
143#ifdef CONFIG_SMP
144 if (nmi_watchdog == NMI_LOCAL_APIC)
145 smp_call_function(nmi_cpu_busy, (void *)&endflag, 0);
146#endif
147
148 for_each_possible_cpu(cpu)
149 prev_nmi_count[cpu] = get_nmi_count(cpu);
150 local_irq_enable();
151 mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */
152
153 for_each_online_cpu(cpu) {
154 if (!per_cpu(wd_enabled, cpu))
155 continue;
156 if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5)
157 report_broken_nmi(cpu, prev_nmi_count);
158 }
159 endflag = 1;
160 if (!atomic_read(&nmi_active)) {
161 kfree(prev_nmi_count);
162 atomic_set(&nmi_active, -1);
163 goto error;
164 }
165 printk("OK.\n");
166
167 /*
168 * now that we know it works we can reduce NMI frequency to
169 * something more reasonable; makes a difference in some configs
170 */
171 if (nmi_watchdog == NMI_LOCAL_APIC)
172 nmi_hz = lapic_adjust_nmi_hz(1);
173
174 kfree(prev_nmi_count);
175 return 0;
176error:
177 if (nmi_watchdog == NMI_IO_APIC) {
178 if (!timer_through_8259)
179 disable_8259A_irq(0);
180 on_each_cpu(__acpi_nmi_disable, NULL, 1);
181 }
182
183#ifdef CONFIG_X86_32
184 timer_ack = 0;
185#endif
186 return -1;
187}
188
189static int __init setup_nmi_watchdog(char *str)
190{
191 unsigned int nmi;
192
193 if (!strncmp(str, "panic", 5)) {
194 panic_on_timeout = 1;
195 str = strchr(str, ',');
196 if (!str)
197 return 1;
198 ++str;
199 }
200
201 if (!strncmp(str, "lapic", 5))
202 nmi_watchdog = NMI_LOCAL_APIC;
203 else if (!strncmp(str, "ioapic", 6))
204 nmi_watchdog = NMI_IO_APIC;
205 else {
206 get_option(&str, &nmi);
207 if (nmi >= NMI_INVALID)
208 return 0;
209 nmi_watchdog = nmi;
210 }
211
212 return 1;
213}
214__setup("nmi_watchdog=", setup_nmi_watchdog);
215
216/*
217 * Suspend/resume support
218 */
219#ifdef CONFIG_PM
220
221static int nmi_pm_active; /* nmi_active before suspend */
222
223static int lapic_nmi_suspend(struct sys_device *dev, pm_message_t state)
224{
225 /* only CPU0 goes here, other CPUs should be offline */
226 nmi_pm_active = atomic_read(&nmi_active);
227 stop_apic_nmi_watchdog(NULL);
228 BUG_ON(atomic_read(&nmi_active) != 0);
229 return 0;
230}
231
232static int lapic_nmi_resume(struct sys_device *dev)
233{
234 /* only CPU0 goes here, other CPUs should be offline */
235 if (nmi_pm_active > 0) {
236 setup_apic_nmi_watchdog(NULL);
237 touch_nmi_watchdog();
238 }
239 return 0;
240}
241
242static struct sysdev_class nmi_sysclass = {
243 .name = "lapic_nmi",
244 .resume = lapic_nmi_resume,
245 .suspend = lapic_nmi_suspend,
246};
247
248static struct sys_device device_lapic_nmi = {
249 .id = 0,
250 .cls = &nmi_sysclass,
251};
252
253static int __init init_lapic_nmi_sysfs(void)
254{
255 int error;
256
257 /*
258 * should really be a BUG_ON but b/c this is an
259 * init call, it just doesn't work. -dcz
260 */
261 if (nmi_watchdog != NMI_LOCAL_APIC)
262 return 0;
263
264 if (atomic_read(&nmi_active) < 0)
265 return 0;
266
267 error = sysdev_class_register(&nmi_sysclass);
268 if (!error)
269 error = sysdev_register(&device_lapic_nmi);
270 return error;
271}
272
273/* must come after the local APIC's device_initcall() */
274late_initcall(init_lapic_nmi_sysfs);
275
276#endif /* CONFIG_PM */
277
278static void __acpi_nmi_enable(void *__unused)
279{
280 apic_write(APIC_LVT0, APIC_DM_NMI);
281}
282
283/*
284 * Enable timer based NMIs on all CPUs:
285 */
286void acpi_nmi_enable(void)
287{
288 if (atomic_read(&nmi_active) && nmi_watchdog == NMI_IO_APIC)
289 on_each_cpu(__acpi_nmi_enable, NULL, 1);
290}
291
292/*
293 * Disable timer based NMIs on all CPUs:
294 */
295void acpi_nmi_disable(void)
296{
297 if (atomic_read(&nmi_active) && nmi_watchdog == NMI_IO_APIC)
298 on_each_cpu(__acpi_nmi_disable, NULL, 1);
299}
300
301/*
302 * This function is called as soon the LAPIC NMI watchdog driver has everything
303 * in place and it's ready to check if the NMIs belong to the NMI watchdog
304 */
305void cpu_nmi_set_wd_enabled(void)
306{
307 __get_cpu_var(wd_enabled) = 1;
308}
309
310void setup_apic_nmi_watchdog(void *unused)
311{
312 if (__get_cpu_var(wd_enabled))
313 return;
314
315 /* cheap hack to support suspend/resume */
316 /* if cpu0 is not active neither should the other cpus */
317 if (smp_processor_id() != 0 && atomic_read(&nmi_active) <= 0)
318 return;
319
320 switch (nmi_watchdog) {
321 case NMI_LOCAL_APIC:
322 if (lapic_watchdog_init(nmi_hz) < 0) {
323 __get_cpu_var(wd_enabled) = 0;
324 return;
325 }
326 /* FALL THROUGH */
327 case NMI_IO_APIC:
328 __get_cpu_var(wd_enabled) = 1;
329 atomic_inc(&nmi_active);
330 }
331}
332
333void stop_apic_nmi_watchdog(void *unused)
334{
335 /* only support LOCAL and IO APICs for now */
336 if (!nmi_watchdog_active())
337 return;
338 if (__get_cpu_var(wd_enabled) == 0)
339 return;
340 if (nmi_watchdog == NMI_LOCAL_APIC)
341 lapic_watchdog_stop();
342 else
343 __acpi_nmi_disable(NULL);
344 __get_cpu_var(wd_enabled) = 0;
345 atomic_dec(&nmi_active);
346}
347
348/*
349 * the best way to detect whether a CPU has a 'hard lockup' problem
350 * is to check it's local APIC timer IRQ counts. If they are not
351 * changing then that CPU has some problem.
352 *
353 * as these watchdog NMI IRQs are generated on every CPU, we only
354 * have to check the current processor.
355 *
356 * since NMIs don't listen to _any_ locks, we have to be extremely
357 * careful not to rely on unsafe variables. The printk might lock
358 * up though, so we have to break up any console locks first ...
359 * [when there will be more tty-related locks, break them up here too!]
360 */
361
362static DEFINE_PER_CPU(unsigned, last_irq_sum);
363static DEFINE_PER_CPU(local_t, alert_counter);
364static DEFINE_PER_CPU(int, nmi_touch);
365
366void touch_nmi_watchdog(void)
367{
368 if (nmi_watchdog_active()) {
369 unsigned cpu;
370
371 /*
372 * Tell other CPUs to reset their alert counters. We cannot
373 * do it ourselves because the alert count increase is not
374 * atomic.
375 */
376 for_each_present_cpu(cpu) {
377 if (per_cpu(nmi_touch, cpu) != 1)
378 per_cpu(nmi_touch, cpu) = 1;
379 }
380 }
381
382 /*
383 * Tickle the softlockup detector too:
384 */
385 touch_softlockup_watchdog();
386}
387EXPORT_SYMBOL(touch_nmi_watchdog);
388
389notrace __kprobes int
390nmi_watchdog_tick(struct pt_regs *regs, unsigned reason)
391{
392 /*
393 * Since current_thread_info()-> is always on the stack, and we
394 * always switch the stack NMI-atomically, it's safe to use
395 * smp_processor_id().
396 */
397 unsigned int sum;
398 int touched = 0;
399 int cpu = smp_processor_id();
400 int rc = 0;
401
402 /* check for other users first */
403 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT)
404 == NOTIFY_STOP) {
405 rc = 1;
406 touched = 1;
407 }
408
409 sum = get_timer_irqs(cpu);
410
411 if (__get_cpu_var(nmi_touch)) {
412 __get_cpu_var(nmi_touch) = 0;
413 touched = 1;
414 }
415
416 if (cpu_isset(cpu, backtrace_mask)) {
417 static DEFINE_SPINLOCK(lock); /* Serialise the printks */
418
419 spin_lock(&lock);
420 printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
421 dump_stack();
422 spin_unlock(&lock);
423 cpu_clear(cpu, backtrace_mask);
424 }
425
426 /* Could check oops_in_progress here too, but it's safer not to */
427 if (mce_in_progress())
428 touched = 1;
429
430 /* if the none of the timers isn't firing, this cpu isn't doing much */
431 if (!touched && __get_cpu_var(last_irq_sum) == sum) {
432 /*
433 * Ayiee, looks like this CPU is stuck ...
434 * wait a few IRQs (5 seconds) before doing the oops ...
435 */
436 local_inc(&__get_cpu_var(alert_counter));
437 if (local_read(&__get_cpu_var(alert_counter)) == 5 * nmi_hz)
438 /*
439 * die_nmi will return ONLY if NOTIFY_STOP happens..
440 */
441 die_nmi("BUG: NMI Watchdog detected LOCKUP",
442 regs, panic_on_timeout);
443 } else {
444 __get_cpu_var(last_irq_sum) = sum;
445 local_set(&__get_cpu_var(alert_counter), 0);
446 }
447
448 /* see if the nmi watchdog went off */
449 if (!__get_cpu_var(wd_enabled))
450 return rc;
451 switch (nmi_watchdog) {
452 case NMI_LOCAL_APIC:
453 rc |= lapic_wd_event(nmi_hz);
454 break;
455 case NMI_IO_APIC:
456 /*
457 * don't know how to accurately check for this.
458 * just assume it was a watchdog timer interrupt
459 * This matches the old behaviour.
460 */
461 rc = 1;
462 break;
463 }
464 return rc;
465}
466
467#ifdef CONFIG_SYSCTL
468
469static void enable_ioapic_nmi_watchdog_single(void *unused)
470{
471 __get_cpu_var(wd_enabled) = 1;
472 atomic_inc(&nmi_active);
473 __acpi_nmi_enable(NULL);
474}
475
476static void enable_ioapic_nmi_watchdog(void)
477{
478 on_each_cpu(enable_ioapic_nmi_watchdog_single, NULL, 1);
479 touch_nmi_watchdog();
480}
481
482static void disable_ioapic_nmi_watchdog(void)
483{
484 on_each_cpu(stop_apic_nmi_watchdog, NULL, 1);
485}
486
487static int __init setup_unknown_nmi_panic(char *str)
488{
489 unknown_nmi_panic = 1;
490 return 1;
491}
492__setup("unknown_nmi_panic", setup_unknown_nmi_panic);
493
494static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu)
495{
496 unsigned char reason = get_nmi_reason();
497 char buf[64];
498
499 sprintf(buf, "NMI received for unknown reason %02x\n", reason);
500 die_nmi(buf, regs, 1); /* Always panic here */
501 return 0;
502}
503
504/*
505 * proc handler for /proc/sys/kernel/nmi
506 */
507int proc_nmi_enabled(struct ctl_table *table, int write, struct file *file,
508 void __user *buffer, size_t *length, loff_t *ppos)
509{
510 int old_state;
511
512 nmi_watchdog_enabled = (atomic_read(&nmi_active) > 0) ? 1 : 0;
513 old_state = nmi_watchdog_enabled;
514 proc_dointvec(table, write, file, buffer, length, ppos);
515 if (!!old_state == !!nmi_watchdog_enabled)
516 return 0;
517
518 if (atomic_read(&nmi_active) < 0 || !nmi_watchdog_active()) {
519 printk(KERN_WARNING
520 "NMI watchdog is permanently disabled\n");
521 return -EIO;
522 }
523
524 if (nmi_watchdog == NMI_LOCAL_APIC) {
525 if (nmi_watchdog_enabled)
526 enable_lapic_nmi_watchdog();
527 else
528 disable_lapic_nmi_watchdog();
529 } else if (nmi_watchdog == NMI_IO_APIC) {
530 if (nmi_watchdog_enabled)
531 enable_ioapic_nmi_watchdog();
532 else
533 disable_ioapic_nmi_watchdog();
534 } else {
535 printk(KERN_WARNING
536 "NMI watchdog doesn't know what hardware to touch\n");
537 return -EIO;
538 }
539 return 0;
540}
541
542#endif /* CONFIG_SYSCTL */
543
544int do_nmi_callback(struct pt_regs *regs, int cpu)
545{
546#ifdef CONFIG_SYSCTL
547 if (unknown_nmi_panic)
548 return unknown_nmi_panic_callback(regs, cpu);
549#endif
550 return 0;
551}
552
553void __trigger_all_cpu_backtrace(void)
554{
555 int i;
556
557 backtrace_mask = cpu_online_map;
558 /* Wait for up to 10 seconds for all CPUs to do the backtrace */
559 for (i = 0; i < 10 * 1000; i++) {
560 if (cpus_empty(backtrace_mask))
561 break;
562 mdelay(1);
563 }
564}
diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
new file mode 100644
index 000000000000..4e39d9ad4d52
--- /dev/null
+++ b/arch/x86/kernel/apic/x2apic_cluster.c
@@ -0,0 +1,243 @@
1#include <linux/threads.h>
2#include <linux/cpumask.h>
3#include <linux/string.h>
4#include <linux/kernel.h>
5#include <linux/ctype.h>
6#include <linux/init.h>
7#include <linux/dmar.h>
8
9#include <asm/smp.h>
10#include <asm/apic.h>
11#include <asm/ipi.h>
12
13DEFINE_PER_CPU(u32, x86_cpu_to_logical_apicid);
14
15static int x2apic_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
16{
17 if (cpu_has_x2apic)
18 return 1;
19
20 return 0;
21}
22
23/* Start with all IRQs pointing to boot CPU. IRQ balancing will shift them. */
24
25static const struct cpumask *x2apic_target_cpus(void)
26{
27 return cpumask_of(0);
28}
29
30/*
31 * for now each logical cpu is in its own vector allocation domain.
32 */
33static void x2apic_vector_allocation_domain(int cpu, struct cpumask *retmask)
34{
35 cpumask_clear(retmask);
36 cpumask_set_cpu(cpu, retmask);
37}
38
39static void
40 __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest)
41{
42 unsigned long cfg;
43
44 cfg = __prepare_ICR(0, vector, dest);
45
46 /*
47 * send the IPI.
48 */
49 native_x2apic_icr_write(cfg, apicid);
50}
51
52/*
53 * for now, we send the IPI's one by one in the cpumask.
54 * TBD: Based on the cpu mask, we can send the IPI's to the cluster group
55 * at once. We have 16 cpu's in a cluster. This will minimize IPI register
56 * writes.
57 */
58static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector)
59{
60 unsigned long query_cpu;
61 unsigned long flags;
62
63 local_irq_save(flags);
64 for_each_cpu(query_cpu, mask) {
65 __x2apic_send_IPI_dest(
66 per_cpu(x86_cpu_to_logical_apicid, query_cpu),
67 vector, apic->dest_logical);
68 }
69 local_irq_restore(flags);
70}
71
72static void
73 x2apic_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
74{
75 unsigned long this_cpu = smp_processor_id();
76 unsigned long query_cpu;
77 unsigned long flags;
78
79 local_irq_save(flags);
80 for_each_cpu(query_cpu, mask) {
81 if (query_cpu == this_cpu)
82 continue;
83 __x2apic_send_IPI_dest(
84 per_cpu(x86_cpu_to_logical_apicid, query_cpu),
85 vector, apic->dest_logical);
86 }
87 local_irq_restore(flags);
88}
89
90static void x2apic_send_IPI_allbutself(int vector)
91{
92 unsigned long this_cpu = smp_processor_id();
93 unsigned long query_cpu;
94 unsigned long flags;
95
96 local_irq_save(flags);
97 for_each_online_cpu(query_cpu) {
98 if (query_cpu == this_cpu)
99 continue;
100 __x2apic_send_IPI_dest(
101 per_cpu(x86_cpu_to_logical_apicid, query_cpu),
102 vector, apic->dest_logical);
103 }
104 local_irq_restore(flags);
105}
106
107static void x2apic_send_IPI_all(int vector)
108{
109 x2apic_send_IPI_mask(cpu_online_mask, vector);
110}
111
112static int x2apic_apic_id_registered(void)
113{
114 return 1;
115}
116
117static unsigned int x2apic_cpu_mask_to_apicid(const struct cpumask *cpumask)
118{
119 /*
120 * We're using fixed IRQ delivery, can only return one logical APIC ID.
121 * May as well be the first.
122 */
123 int cpu = cpumask_first(cpumask);
124
125 if ((unsigned)cpu < nr_cpu_ids)
126 return per_cpu(x86_cpu_to_logical_apicid, cpu);
127 else
128 return BAD_APICID;
129}
130
131static unsigned int
132x2apic_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
133 const struct cpumask *andmask)
134{
135 int cpu;
136
137 /*
138 * We're using fixed IRQ delivery, can only return one logical APIC ID.
139 * May as well be the first.
140 */
141 for_each_cpu_and(cpu, cpumask, andmask) {
142 if (cpumask_test_cpu(cpu, cpu_online_mask))
143 break;
144 }
145
146 if (cpu < nr_cpu_ids)
147 return per_cpu(x86_cpu_to_logical_apicid, cpu);
148
149 return BAD_APICID;
150}
151
152static unsigned int x2apic_cluster_phys_get_apic_id(unsigned long x)
153{
154 unsigned int id;
155
156 id = x;
157 return id;
158}
159
160static unsigned long set_apic_id(unsigned int id)
161{
162 unsigned long x;
163
164 x = id;
165 return x;
166}
167
168static int x2apic_cluster_phys_pkg_id(int initial_apicid, int index_msb)
169{
170 return current_cpu_data.initial_apicid >> index_msb;
171}
172
173static void x2apic_send_IPI_self(int vector)
174{
175 apic_write(APIC_SELF_IPI, vector);
176}
177
178static void init_x2apic_ldr(void)
179{
180 int cpu = smp_processor_id();
181
182 per_cpu(x86_cpu_to_logical_apicid, cpu) = apic_read(APIC_LDR);
183}
184
185struct apic apic_x2apic_cluster = {
186
187 .name = "cluster x2apic",
188 .probe = NULL,
189 .acpi_madt_oem_check = x2apic_acpi_madt_oem_check,
190 .apic_id_registered = x2apic_apic_id_registered,
191
192 .irq_delivery_mode = dest_LowestPrio,
193 .irq_dest_mode = 1, /* logical */
194
195 .target_cpus = x2apic_target_cpus,
196 .disable_esr = 0,
197 .dest_logical = APIC_DEST_LOGICAL,
198 .check_apicid_used = NULL,
199 .check_apicid_present = NULL,
200
201 .vector_allocation_domain = x2apic_vector_allocation_domain,
202 .init_apic_ldr = init_x2apic_ldr,
203
204 .ioapic_phys_id_map = NULL,
205 .setup_apic_routing = NULL,
206 .multi_timer_check = NULL,
207 .apicid_to_node = NULL,
208 .cpu_to_logical_apicid = NULL,
209 .cpu_present_to_apicid = default_cpu_present_to_apicid,
210 .apicid_to_cpu_present = NULL,
211 .setup_portio_remap = NULL,
212 .check_phys_apicid_present = default_check_phys_apicid_present,
213 .enable_apic_mode = NULL,
214 .phys_pkg_id = x2apic_cluster_phys_pkg_id,
215 .mps_oem_check = NULL,
216
217 .get_apic_id = x2apic_cluster_phys_get_apic_id,
218 .set_apic_id = set_apic_id,
219 .apic_id_mask = 0xFFFFFFFFu,
220
221 .cpu_mask_to_apicid = x2apic_cpu_mask_to_apicid,
222 .cpu_mask_to_apicid_and = x2apic_cpu_mask_to_apicid_and,
223
224 .send_IPI_mask = x2apic_send_IPI_mask,
225 .send_IPI_mask_allbutself = x2apic_send_IPI_mask_allbutself,
226 .send_IPI_allbutself = x2apic_send_IPI_allbutself,
227 .send_IPI_all = x2apic_send_IPI_all,
228 .send_IPI_self = x2apic_send_IPI_self,
229
230 .wakeup_cpu = NULL,
231 .trampoline_phys_low = DEFAULT_TRAMPOLINE_PHYS_LOW,
232 .trampoline_phys_high = DEFAULT_TRAMPOLINE_PHYS_HIGH,
233 .wait_for_init_deassert = NULL,
234 .smp_callin_clear_local_apic = NULL,
235 .inquire_remote_apic = NULL,
236
237 .read = native_apic_msr_read,
238 .write = native_apic_msr_write,
239 .icr_read = native_x2apic_icr_read,
240 .icr_write = native_x2apic_icr_write,
241 .wait_icr_idle = native_x2apic_wait_icr_idle,
242 .safe_wait_icr_idle = native_safe_x2apic_wait_icr_idle,
243};
diff --git a/arch/x86/kernel/apic/x2apic_phys.c b/arch/x86/kernel/apic/x2apic_phys.c
new file mode 100644
index 000000000000..d2d52eb9f7ea
--- /dev/null
+++ b/arch/x86/kernel/apic/x2apic_phys.c
@@ -0,0 +1,229 @@
1#include <linux/threads.h>
2#include <linux/cpumask.h>
3#include <linux/string.h>
4#include <linux/kernel.h>
5#include <linux/ctype.h>
6#include <linux/init.h>
7#include <linux/dmar.h>
8
9#include <asm/smp.h>
10#include <asm/apic.h>
11#include <asm/ipi.h>
12
13static int x2apic_phys;
14
15static int set_x2apic_phys_mode(char *arg)
16{
17 x2apic_phys = 1;
18 return 0;
19}
20early_param("x2apic_phys", set_x2apic_phys_mode);
21
22static int x2apic_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
23{
24 if (cpu_has_x2apic && x2apic_phys)
25 return 1;
26
27 return 0;
28}
29
30/* Start with all IRQs pointing to boot CPU. IRQ balancing will shift them. */
31
32static const struct cpumask *x2apic_target_cpus(void)
33{
34 return cpumask_of(0);
35}
36
37static void x2apic_vector_allocation_domain(int cpu, struct cpumask *retmask)
38{
39 cpumask_clear(retmask);
40 cpumask_set_cpu(cpu, retmask);
41}
42
43static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
44 unsigned int dest)
45{
46 unsigned long cfg;
47
48 cfg = __prepare_ICR(0, vector, dest);
49
50 /*
51 * send the IPI.
52 */
53 native_x2apic_icr_write(cfg, apicid);
54}
55
56static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector)
57{
58 unsigned long query_cpu;
59 unsigned long flags;
60
61 local_irq_save(flags);
62 for_each_cpu(query_cpu, mask) {
63 __x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu),
64 vector, APIC_DEST_PHYSICAL);
65 }
66 local_irq_restore(flags);
67}
68
69static void
70 x2apic_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
71{
72 unsigned long this_cpu = smp_processor_id();
73 unsigned long query_cpu;
74 unsigned long flags;
75
76 local_irq_save(flags);
77 for_each_cpu(query_cpu, mask) {
78 if (query_cpu != this_cpu)
79 __x2apic_send_IPI_dest(
80 per_cpu(x86_cpu_to_apicid, query_cpu),
81 vector, APIC_DEST_PHYSICAL);
82 }
83 local_irq_restore(flags);
84}
85
86static void x2apic_send_IPI_allbutself(int vector)
87{
88 unsigned long this_cpu = smp_processor_id();
89 unsigned long query_cpu;
90 unsigned long flags;
91
92 local_irq_save(flags);
93 for_each_online_cpu(query_cpu) {
94 if (query_cpu == this_cpu)
95 continue;
96 __x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu),
97 vector, APIC_DEST_PHYSICAL);
98 }
99 local_irq_restore(flags);
100}
101
102static void x2apic_send_IPI_all(int vector)
103{
104 x2apic_send_IPI_mask(cpu_online_mask, vector);
105}
106
107static int x2apic_apic_id_registered(void)
108{
109 return 1;
110}
111
112static unsigned int x2apic_cpu_mask_to_apicid(const struct cpumask *cpumask)
113{
114 /*
115 * We're using fixed IRQ delivery, can only return one phys APIC ID.
116 * May as well be the first.
117 */
118 int cpu = cpumask_first(cpumask);
119
120 if ((unsigned)cpu < nr_cpu_ids)
121 return per_cpu(x86_cpu_to_apicid, cpu);
122 else
123 return BAD_APICID;
124}
125
126static unsigned int
127x2apic_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
128 const struct cpumask *andmask)
129{
130 int cpu;
131
132 /*
133 * We're using fixed IRQ delivery, can only return one phys APIC ID.
134 * May as well be the first.
135 */
136 for_each_cpu_and(cpu, cpumask, andmask) {
137 if (cpumask_test_cpu(cpu, cpu_online_mask))
138 break;
139 }
140
141 if (cpu < nr_cpu_ids)
142 return per_cpu(x86_cpu_to_apicid, cpu);
143
144 return BAD_APICID;
145}
146
147static unsigned int x2apic_phys_get_apic_id(unsigned long x)
148{
149 return x;
150}
151
152static unsigned long set_apic_id(unsigned int id)
153{
154 return id;
155}
156
157static int x2apic_phys_pkg_id(int initial_apicid, int index_msb)
158{
159 return current_cpu_data.initial_apicid >> index_msb;
160}
161
162static void x2apic_send_IPI_self(int vector)
163{
164 apic_write(APIC_SELF_IPI, vector);
165}
166
167static void init_x2apic_ldr(void)
168{
169}
170
171struct apic apic_x2apic_phys = {
172
173 .name = "physical x2apic",
174 .probe = NULL,
175 .acpi_madt_oem_check = x2apic_acpi_madt_oem_check,
176 .apic_id_registered = x2apic_apic_id_registered,
177
178 .irq_delivery_mode = dest_Fixed,
179 .irq_dest_mode = 0, /* physical */
180
181 .target_cpus = x2apic_target_cpus,
182 .disable_esr = 0,
183 .dest_logical = 0,
184 .check_apicid_used = NULL,
185 .check_apicid_present = NULL,
186
187 .vector_allocation_domain = x2apic_vector_allocation_domain,
188 .init_apic_ldr = init_x2apic_ldr,
189
190 .ioapic_phys_id_map = NULL,
191 .setup_apic_routing = NULL,
192 .multi_timer_check = NULL,
193 .apicid_to_node = NULL,
194 .cpu_to_logical_apicid = NULL,
195 .cpu_present_to_apicid = default_cpu_present_to_apicid,
196 .apicid_to_cpu_present = NULL,
197 .setup_portio_remap = NULL,
198 .check_phys_apicid_present = default_check_phys_apicid_present,
199 .enable_apic_mode = NULL,
200 .phys_pkg_id = x2apic_phys_pkg_id,
201 .mps_oem_check = NULL,
202
203 .get_apic_id = x2apic_phys_get_apic_id,
204 .set_apic_id = set_apic_id,
205 .apic_id_mask = 0xFFFFFFFFu,
206
207 .cpu_mask_to_apicid = x2apic_cpu_mask_to_apicid,
208 .cpu_mask_to_apicid_and = x2apic_cpu_mask_to_apicid_and,
209
210 .send_IPI_mask = x2apic_send_IPI_mask,
211 .send_IPI_mask_allbutself = x2apic_send_IPI_mask_allbutself,
212 .send_IPI_allbutself = x2apic_send_IPI_allbutself,
213 .send_IPI_all = x2apic_send_IPI_all,
214 .send_IPI_self = x2apic_send_IPI_self,
215
216 .wakeup_cpu = NULL,
217 .trampoline_phys_low = DEFAULT_TRAMPOLINE_PHYS_LOW,
218 .trampoline_phys_high = DEFAULT_TRAMPOLINE_PHYS_HIGH,
219 .wait_for_init_deassert = NULL,
220 .smp_callin_clear_local_apic = NULL,
221 .inquire_remote_apic = NULL,
222
223 .read = native_apic_msr_read,
224 .write = native_apic_msr_write,
225 .icr_read = native_x2apic_icr_read,
226 .icr_write = native_x2apic_icr_write,
227 .wait_icr_idle = native_x2apic_wait_icr_idle,
228 .safe_wait_icr_idle = native_safe_x2apic_wait_icr_idle,
229};
diff --git a/arch/x86/kernel/apic/x2apic_uv_x.c b/arch/x86/kernel/apic/x2apic_uv_x.c
new file mode 100644
index 000000000000..20b4ad07c3a1
--- /dev/null
+++ b/arch/x86/kernel/apic/x2apic_uv_x.c
@@ -0,0 +1,643 @@
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * SGI UV APIC functions (note: not an Intel compatible APIC)
7 *
8 * Copyright (C) 2007-2008 Silicon Graphics, Inc. All rights reserved.
9 */
10
11#include <linux/kernel.h>
12#include <linux/threads.h>
13#include <linux/cpu.h>
14#include <linux/cpumask.h>
15#include <linux/string.h>
16#include <linux/ctype.h>
17#include <linux/init.h>
18#include <linux/sched.h>
19#include <linux/module.h>
20#include <linux/hardirq.h>
21#include <linux/timer.h>
22#include <linux/proc_fs.h>
23#include <asm/current.h>
24#include <asm/smp.h>
25#include <asm/apic.h>
26#include <asm/ipi.h>
27#include <asm/pgtable.h>
28#include <asm/uv/uv.h>
29#include <asm/uv/uv_mmrs.h>
30#include <asm/uv/uv_hub.h>
31#include <asm/uv/bios.h>
32
33DEFINE_PER_CPU(int, x2apic_extra_bits);
34
35static enum uv_system_type uv_system_type;
36
37static int uv_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
38{
39 if (!strcmp(oem_id, "SGI")) {
40 if (!strcmp(oem_table_id, "UVL"))
41 uv_system_type = UV_LEGACY_APIC;
42 else if (!strcmp(oem_table_id, "UVX"))
43 uv_system_type = UV_X2APIC;
44 else if (!strcmp(oem_table_id, "UVH")) {
45 uv_system_type = UV_NON_UNIQUE_APIC;
46 return 1;
47 }
48 }
49 return 0;
50}
51
52enum uv_system_type get_uv_system_type(void)
53{
54 return uv_system_type;
55}
56
57int is_uv_system(void)
58{
59 return uv_system_type != UV_NONE;
60}
61EXPORT_SYMBOL_GPL(is_uv_system);
62
63DEFINE_PER_CPU(struct uv_hub_info_s, __uv_hub_info);
64EXPORT_PER_CPU_SYMBOL_GPL(__uv_hub_info);
65
66struct uv_blade_info *uv_blade_info;
67EXPORT_SYMBOL_GPL(uv_blade_info);
68
69short *uv_node_to_blade;
70EXPORT_SYMBOL_GPL(uv_node_to_blade);
71
72short *uv_cpu_to_blade;
73EXPORT_SYMBOL_GPL(uv_cpu_to_blade);
74
75short uv_possible_blades;
76EXPORT_SYMBOL_GPL(uv_possible_blades);
77
78unsigned long sn_rtc_cycles_per_second;
79EXPORT_SYMBOL(sn_rtc_cycles_per_second);
80
81/* Start with all IRQs pointing to boot CPU. IRQ balancing will shift them. */
82
83static const struct cpumask *uv_target_cpus(void)
84{
85 return cpumask_of(0);
86}
87
88static void uv_vector_allocation_domain(int cpu, struct cpumask *retmask)
89{
90 cpumask_clear(retmask);
91 cpumask_set_cpu(cpu, retmask);
92}
93
94int uv_wakeup_secondary(int phys_apicid, unsigned int start_rip)
95{
96 unsigned long val;
97 int pnode;
98
99 pnode = uv_apicid_to_pnode(phys_apicid);
100 val = (1UL << UVH_IPI_INT_SEND_SHFT) |
101 (phys_apicid << UVH_IPI_INT_APIC_ID_SHFT) |
102 (((long)start_rip << UVH_IPI_INT_VECTOR_SHFT) >> 12) |
103 APIC_DM_INIT;
104 uv_write_global_mmr64(pnode, UVH_IPI_INT, val);
105 mdelay(10);
106
107 val = (1UL << UVH_IPI_INT_SEND_SHFT) |
108 (phys_apicid << UVH_IPI_INT_APIC_ID_SHFT) |
109 (((long)start_rip << UVH_IPI_INT_VECTOR_SHFT) >> 12) |
110 APIC_DM_STARTUP;
111 uv_write_global_mmr64(pnode, UVH_IPI_INT, val);
112 return 0;
113}
114
115static void uv_send_IPI_one(int cpu, int vector)
116{
117 unsigned long val, apicid;
118 int pnode;
119
120 apicid = per_cpu(x86_cpu_to_apicid, cpu);
121 pnode = uv_apicid_to_pnode(apicid);
122
123 val = (1UL << UVH_IPI_INT_SEND_SHFT) |
124 (apicid << UVH_IPI_INT_APIC_ID_SHFT) |
125 (vector << UVH_IPI_INT_VECTOR_SHFT);
126
127 uv_write_global_mmr64(pnode, UVH_IPI_INT, val);
128}
129
130static void uv_send_IPI_mask(const struct cpumask *mask, int vector)
131{
132 unsigned int cpu;
133
134 for_each_cpu(cpu, mask)
135 uv_send_IPI_one(cpu, vector);
136}
137
138static void uv_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
139{
140 unsigned int this_cpu = smp_processor_id();
141 unsigned int cpu;
142
143 for_each_cpu(cpu, mask) {
144 if (cpu != this_cpu)
145 uv_send_IPI_one(cpu, vector);
146 }
147}
148
149static void uv_send_IPI_allbutself(int vector)
150{
151 unsigned int this_cpu = smp_processor_id();
152 unsigned int cpu;
153
154 for_each_online_cpu(cpu) {
155 if (cpu != this_cpu)
156 uv_send_IPI_one(cpu, vector);
157 }
158}
159
160static void uv_send_IPI_all(int vector)
161{
162 uv_send_IPI_mask(cpu_online_mask, vector);
163}
164
165static int uv_apic_id_registered(void)
166{
167 return 1;
168}
169
170static void uv_init_apic_ldr(void)
171{
172}
173
174static unsigned int uv_cpu_mask_to_apicid(const struct cpumask *cpumask)
175{
176 /*
177 * We're using fixed IRQ delivery, can only return one phys APIC ID.
178 * May as well be the first.
179 */
180 int cpu = cpumask_first(cpumask);
181
182 if ((unsigned)cpu < nr_cpu_ids)
183 return per_cpu(x86_cpu_to_apicid, cpu);
184 else
185 return BAD_APICID;
186}
187
188static unsigned int
189uv_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
190 const struct cpumask *andmask)
191{
192 int cpu;
193
194 /*
195 * We're using fixed IRQ delivery, can only return one phys APIC ID.
196 * May as well be the first.
197 */
198 for_each_cpu_and(cpu, cpumask, andmask) {
199 if (cpumask_test_cpu(cpu, cpu_online_mask))
200 break;
201 }
202 if (cpu < nr_cpu_ids)
203 return per_cpu(x86_cpu_to_apicid, cpu);
204
205 return BAD_APICID;
206}
207
208static unsigned int x2apic_get_apic_id(unsigned long x)
209{
210 unsigned int id;
211
212 WARN_ON(preemptible() && num_online_cpus() > 1);
213 id = x | __get_cpu_var(x2apic_extra_bits);
214
215 return id;
216}
217
218static unsigned long set_apic_id(unsigned int id)
219{
220 unsigned long x;
221
222 /* maskout x2apic_extra_bits ? */
223 x = id;
224 return x;
225}
226
227static unsigned int uv_read_apic_id(void)
228{
229
230 return x2apic_get_apic_id(apic_read(APIC_ID));
231}
232
233static int uv_phys_pkg_id(int initial_apicid, int index_msb)
234{
235 return uv_read_apic_id() >> index_msb;
236}
237
238static void uv_send_IPI_self(int vector)
239{
240 apic_write(APIC_SELF_IPI, vector);
241}
242
243struct apic apic_x2apic_uv_x = {
244
245 .name = "UV large system",
246 .probe = NULL,
247 .acpi_madt_oem_check = uv_acpi_madt_oem_check,
248 .apic_id_registered = uv_apic_id_registered,
249
250 .irq_delivery_mode = dest_Fixed,
251 .irq_dest_mode = 1, /* logical */
252
253 .target_cpus = uv_target_cpus,
254 .disable_esr = 0,
255 .dest_logical = APIC_DEST_LOGICAL,
256 .check_apicid_used = NULL,
257 .check_apicid_present = NULL,
258
259 .vector_allocation_domain = uv_vector_allocation_domain,
260 .init_apic_ldr = uv_init_apic_ldr,
261
262 .ioapic_phys_id_map = NULL,
263 .setup_apic_routing = NULL,
264 .multi_timer_check = NULL,
265 .apicid_to_node = NULL,
266 .cpu_to_logical_apicid = NULL,
267 .cpu_present_to_apicid = default_cpu_present_to_apicid,
268 .apicid_to_cpu_present = NULL,
269 .setup_portio_remap = NULL,
270 .check_phys_apicid_present = default_check_phys_apicid_present,
271 .enable_apic_mode = NULL,
272 .phys_pkg_id = uv_phys_pkg_id,
273 .mps_oem_check = NULL,
274
275 .get_apic_id = x2apic_get_apic_id,
276 .set_apic_id = set_apic_id,
277 .apic_id_mask = 0xFFFFFFFFu,
278
279 .cpu_mask_to_apicid = uv_cpu_mask_to_apicid,
280 .cpu_mask_to_apicid_and = uv_cpu_mask_to_apicid_and,
281
282 .send_IPI_mask = uv_send_IPI_mask,
283 .send_IPI_mask_allbutself = uv_send_IPI_mask_allbutself,
284 .send_IPI_allbutself = uv_send_IPI_allbutself,
285 .send_IPI_all = uv_send_IPI_all,
286 .send_IPI_self = uv_send_IPI_self,
287
288 .wakeup_cpu = NULL,
289 .trampoline_phys_low = DEFAULT_TRAMPOLINE_PHYS_LOW,
290 .trampoline_phys_high = DEFAULT_TRAMPOLINE_PHYS_HIGH,
291 .wait_for_init_deassert = NULL,
292 .smp_callin_clear_local_apic = NULL,
293 .inquire_remote_apic = NULL,
294
295 .read = native_apic_msr_read,
296 .write = native_apic_msr_write,
297 .icr_read = native_x2apic_icr_read,
298 .icr_write = native_x2apic_icr_write,
299 .wait_icr_idle = native_x2apic_wait_icr_idle,
300 .safe_wait_icr_idle = native_safe_x2apic_wait_icr_idle,
301};
302
303static __cpuinit void set_x2apic_extra_bits(int pnode)
304{
305 __get_cpu_var(x2apic_extra_bits) = (pnode << 6);
306}
307
308/*
309 * Called on boot cpu.
310 */
311static __init int boot_pnode_to_blade(int pnode)
312{
313 int blade;
314
315 for (blade = 0; blade < uv_num_possible_blades(); blade++)
316 if (pnode == uv_blade_info[blade].pnode)
317 return blade;
318 BUG();
319}
320
321struct redir_addr {
322 unsigned long redirect;
323 unsigned long alias;
324};
325
326#define DEST_SHIFT UVH_RH_GAM_ALIAS210_REDIRECT_CONFIG_0_MMR_DEST_BASE_SHFT
327
328static __initdata struct redir_addr redir_addrs[] = {
329 {UVH_RH_GAM_ALIAS210_REDIRECT_CONFIG_0_MMR, UVH_SI_ALIAS0_OVERLAY_CONFIG},
330 {UVH_RH_GAM_ALIAS210_REDIRECT_CONFIG_1_MMR, UVH_SI_ALIAS1_OVERLAY_CONFIG},
331 {UVH_RH_GAM_ALIAS210_REDIRECT_CONFIG_2_MMR, UVH_SI_ALIAS2_OVERLAY_CONFIG},
332};
333
334static __init void get_lowmem_redirect(unsigned long *base, unsigned long *size)
335{
336 union uvh_si_alias0_overlay_config_u alias;
337 union uvh_rh_gam_alias210_redirect_config_2_mmr_u redirect;
338 int i;
339
340 for (i = 0; i < ARRAY_SIZE(redir_addrs); i++) {
341 alias.v = uv_read_local_mmr(redir_addrs[i].alias);
342 if (alias.s.base == 0) {
343 *size = (1UL << alias.s.m_alias);
344 redirect.v = uv_read_local_mmr(redir_addrs[i].redirect);
345 *base = (unsigned long)redirect.s.dest_base << DEST_SHIFT;
346 return;
347 }
348 }
349 BUG();
350}
351
352static __init void map_low_mmrs(void)
353{
354 init_extra_mapping_uc(UV_GLOBAL_MMR32_BASE, UV_GLOBAL_MMR32_SIZE);
355 init_extra_mapping_uc(UV_LOCAL_MMR_BASE, UV_LOCAL_MMR_SIZE);
356}
357
358enum map_type {map_wb, map_uc};
359
360static __init void map_high(char *id, unsigned long base, int shift,
361 int max_pnode, enum map_type map_type)
362{
363 unsigned long bytes, paddr;
364
365 paddr = base << shift;
366 bytes = (1UL << shift) * (max_pnode + 1);
367 printk(KERN_INFO "UV: Map %s_HI 0x%lx - 0x%lx\n", id, paddr,
368 paddr + bytes);
369 if (map_type == map_uc)
370 init_extra_mapping_uc(paddr, bytes);
371 else
372 init_extra_mapping_wb(paddr, bytes);
373
374}
375static __init void map_gru_high(int max_pnode)
376{
377 union uvh_rh_gam_gru_overlay_config_mmr_u gru;
378 int shift = UVH_RH_GAM_GRU_OVERLAY_CONFIG_MMR_BASE_SHFT;
379
380 gru.v = uv_read_local_mmr(UVH_RH_GAM_GRU_OVERLAY_CONFIG_MMR);
381 if (gru.s.enable)
382 map_high("GRU", gru.s.base, shift, max_pnode, map_wb);
383}
384
385static __init void map_config_high(int max_pnode)
386{
387 union uvh_rh_gam_cfg_overlay_config_mmr_u cfg;
388 int shift = UVH_RH_GAM_CFG_OVERLAY_CONFIG_MMR_BASE_SHFT;
389
390 cfg.v = uv_read_local_mmr(UVH_RH_GAM_CFG_OVERLAY_CONFIG_MMR);
391 if (cfg.s.enable)
392 map_high("CONFIG", cfg.s.base, shift, max_pnode, map_uc);
393}
394
395static __init void map_mmr_high(int max_pnode)
396{
397 union uvh_rh_gam_mmr_overlay_config_mmr_u mmr;
398 int shift = UVH_RH_GAM_MMR_OVERLAY_CONFIG_MMR_BASE_SHFT;
399
400 mmr.v = uv_read_local_mmr(UVH_RH_GAM_MMR_OVERLAY_CONFIG_MMR);
401 if (mmr.s.enable)
402 map_high("MMR", mmr.s.base, shift, max_pnode, map_uc);
403}
404
405static __init void map_mmioh_high(int max_pnode)
406{
407 union uvh_rh_gam_mmioh_overlay_config_mmr_u mmioh;
408 int shift = UVH_RH_GAM_MMIOH_OVERLAY_CONFIG_MMR_BASE_SHFT;
409
410 mmioh.v = uv_read_local_mmr(UVH_RH_GAM_MMIOH_OVERLAY_CONFIG_MMR);
411 if (mmioh.s.enable)
412 map_high("MMIOH", mmioh.s.base, shift, max_pnode, map_uc);
413}
414
415static __init void uv_rtc_init(void)
416{
417 long status;
418 u64 ticks_per_sec;
419
420 status = uv_bios_freq_base(BIOS_FREQ_BASE_REALTIME_CLOCK,
421 &ticks_per_sec);
422 if (status != BIOS_STATUS_SUCCESS || ticks_per_sec < 100000) {
423 printk(KERN_WARNING
424 "unable to determine platform RTC clock frequency, "
425 "guessing.\n");
426 /* BIOS gives wrong value for clock freq. so guess */
427 sn_rtc_cycles_per_second = 1000000000000UL / 30000UL;
428 } else
429 sn_rtc_cycles_per_second = ticks_per_sec;
430}
431
432/*
433 * percpu heartbeat timer
434 */
435static void uv_heartbeat(unsigned long ignored)
436{
437 struct timer_list *timer = &uv_hub_info->scir.timer;
438 unsigned char bits = uv_hub_info->scir.state;
439
440 /* flip heartbeat bit */
441 bits ^= SCIR_CPU_HEARTBEAT;
442
443 /* is this cpu idle? */
444 if (idle_cpu(raw_smp_processor_id()))
445 bits &= ~SCIR_CPU_ACTIVITY;
446 else
447 bits |= SCIR_CPU_ACTIVITY;
448
449 /* update system controller interface reg */
450 uv_set_scir_bits(bits);
451
452 /* enable next timer period */
453 mod_timer(timer, jiffies + SCIR_CPU_HB_INTERVAL);
454}
455
456static void __cpuinit uv_heartbeat_enable(int cpu)
457{
458 if (!uv_cpu_hub_info(cpu)->scir.enabled) {
459 struct timer_list *timer = &uv_cpu_hub_info(cpu)->scir.timer;
460
461 uv_set_cpu_scir_bits(cpu, SCIR_CPU_HEARTBEAT|SCIR_CPU_ACTIVITY);
462 setup_timer(timer, uv_heartbeat, cpu);
463 timer->expires = jiffies + SCIR_CPU_HB_INTERVAL;
464 add_timer_on(timer, cpu);
465 uv_cpu_hub_info(cpu)->scir.enabled = 1;
466 }
467
468 /* check boot cpu */
469 if (!uv_cpu_hub_info(0)->scir.enabled)
470 uv_heartbeat_enable(0);
471}
472
473#ifdef CONFIG_HOTPLUG_CPU
474static void __cpuinit uv_heartbeat_disable(int cpu)
475{
476 if (uv_cpu_hub_info(cpu)->scir.enabled) {
477 uv_cpu_hub_info(cpu)->scir.enabled = 0;
478 del_timer(&uv_cpu_hub_info(cpu)->scir.timer);
479 }
480 uv_set_cpu_scir_bits(cpu, 0xff);
481}
482
483/*
484 * cpu hotplug notifier
485 */
486static __cpuinit int uv_scir_cpu_notify(struct notifier_block *self,
487 unsigned long action, void *hcpu)
488{
489 long cpu = (long)hcpu;
490
491 switch (action) {
492 case CPU_ONLINE:
493 uv_heartbeat_enable(cpu);
494 break;
495 case CPU_DOWN_PREPARE:
496 uv_heartbeat_disable(cpu);
497 break;
498 default:
499 break;
500 }
501 return NOTIFY_OK;
502}
503
504static __init void uv_scir_register_cpu_notifier(void)
505{
506 hotcpu_notifier(uv_scir_cpu_notify, 0);
507}
508
509#else /* !CONFIG_HOTPLUG_CPU */
510
511static __init void uv_scir_register_cpu_notifier(void)
512{
513}
514
515static __init int uv_init_heartbeat(void)
516{
517 int cpu;
518
519 if (is_uv_system())
520 for_each_online_cpu(cpu)
521 uv_heartbeat_enable(cpu);
522 return 0;
523}
524
525late_initcall(uv_init_heartbeat);
526
527#endif /* !CONFIG_HOTPLUG_CPU */
528
529/*
530 * Called on each cpu to initialize the per_cpu UV data area.
531 * ZZZ hotplug not supported yet
532 */
533void __cpuinit uv_cpu_init(void)
534{
535 /* CPU 0 initilization will be done via uv_system_init. */
536 if (!uv_blade_info)
537 return;
538
539 uv_blade_info[uv_numa_blade_id()].nr_online_cpus++;
540
541 if (get_uv_system_type() == UV_NON_UNIQUE_APIC)
542 set_x2apic_extra_bits(uv_hub_info->pnode);
543}
544
545
546void __init uv_system_init(void)
547{
548 union uvh_si_addr_map_config_u m_n_config;
549 union uvh_node_id_u node_id;
550 unsigned long gnode_upper, lowmem_redir_base, lowmem_redir_size;
551 int bytes, nid, cpu, lcpu, pnode, blade, i, j, m_val, n_val;
552 int max_pnode = 0;
553 unsigned long mmr_base, present;
554
555 map_low_mmrs();
556
557 m_n_config.v = uv_read_local_mmr(UVH_SI_ADDR_MAP_CONFIG);
558 m_val = m_n_config.s.m_skt;
559 n_val = m_n_config.s.n_skt;
560 mmr_base =
561 uv_read_local_mmr(UVH_RH_GAM_MMR_OVERLAY_CONFIG_MMR) &
562 ~UV_MMR_ENABLE;
563 printk(KERN_DEBUG "UV: global MMR base 0x%lx\n", mmr_base);
564
565 for(i = 0; i < UVH_NODE_PRESENT_TABLE_DEPTH; i++)
566 uv_possible_blades +=
567 hweight64(uv_read_local_mmr( UVH_NODE_PRESENT_TABLE + i * 8));
568 printk(KERN_DEBUG "UV: Found %d blades\n", uv_num_possible_blades());
569
570 bytes = sizeof(struct uv_blade_info) * uv_num_possible_blades();
571 uv_blade_info = kmalloc(bytes, GFP_KERNEL);
572
573 get_lowmem_redirect(&lowmem_redir_base, &lowmem_redir_size);
574
575 bytes = sizeof(uv_node_to_blade[0]) * num_possible_nodes();
576 uv_node_to_blade = kmalloc(bytes, GFP_KERNEL);
577 memset(uv_node_to_blade, 255, bytes);
578
579 bytes = sizeof(uv_cpu_to_blade[0]) * num_possible_cpus();
580 uv_cpu_to_blade = kmalloc(bytes, GFP_KERNEL);
581 memset(uv_cpu_to_blade, 255, bytes);
582
583 blade = 0;
584 for (i = 0; i < UVH_NODE_PRESENT_TABLE_DEPTH; i++) {
585 present = uv_read_local_mmr(UVH_NODE_PRESENT_TABLE + i * 8);
586 for (j = 0; j < 64; j++) {
587 if (!test_bit(j, &present))
588 continue;
589 uv_blade_info[blade].pnode = (i * 64 + j);
590 uv_blade_info[blade].nr_possible_cpus = 0;
591 uv_blade_info[blade].nr_online_cpus = 0;
592 blade++;
593 }
594 }
595
596 node_id.v = uv_read_local_mmr(UVH_NODE_ID);
597 gnode_upper = (((unsigned long)node_id.s.node_id) &
598 ~((1 << n_val) - 1)) << m_val;
599
600 uv_bios_init();
601 uv_bios_get_sn_info(0, &uv_type, &sn_partition_id,
602 &sn_coherency_id, &sn_region_size);
603 uv_rtc_init();
604
605 for_each_present_cpu(cpu) {
606 nid = cpu_to_node(cpu);
607 pnode = uv_apicid_to_pnode(per_cpu(x86_cpu_to_apicid, cpu));
608 blade = boot_pnode_to_blade(pnode);
609 lcpu = uv_blade_info[blade].nr_possible_cpus;
610 uv_blade_info[blade].nr_possible_cpus++;
611
612 uv_cpu_hub_info(cpu)->lowmem_remap_base = lowmem_redir_base;
613 uv_cpu_hub_info(cpu)->lowmem_remap_top = lowmem_redir_size;
614 uv_cpu_hub_info(cpu)->m_val = m_val;
615 uv_cpu_hub_info(cpu)->n_val = m_val;
616 uv_cpu_hub_info(cpu)->numa_blade_id = blade;
617 uv_cpu_hub_info(cpu)->blade_processor_id = lcpu;
618 uv_cpu_hub_info(cpu)->pnode = pnode;
619 uv_cpu_hub_info(cpu)->pnode_mask = (1 << n_val) - 1;
620 uv_cpu_hub_info(cpu)->gpa_mask = (1 << (m_val + n_val)) - 1;
621 uv_cpu_hub_info(cpu)->gnode_upper = gnode_upper;
622 uv_cpu_hub_info(cpu)->global_mmr_base = mmr_base;
623 uv_cpu_hub_info(cpu)->coherency_domain_number = sn_coherency_id;
624 uv_cpu_hub_info(cpu)->scir.offset = SCIR_LOCAL_MMR_BASE + lcpu;
625 uv_node_to_blade[nid] = blade;
626 uv_cpu_to_blade[cpu] = blade;
627 max_pnode = max(pnode, max_pnode);
628
629 printk(KERN_DEBUG "UV: cpu %d, apicid 0x%x, pnode %d, nid %d, "
630 "lcpu %d, blade %d\n",
631 cpu, per_cpu(x86_cpu_to_apicid, cpu), pnode, nid,
632 lcpu, blade);
633 }
634
635 map_gru_high(max_pnode);
636 map_mmr_high(max_pnode);
637 map_config_high(max_pnode);
638 map_mmioh_high(max_pnode);
639
640 uv_cpu_init();
641 uv_scir_register_cpu_notifier();
642 proc_mkdir("sgi_uv", NULL);
643}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-05 09:55:20 -0500