x86: set cpu_index to nr_cpus instead of 0
[linux-2.6] / arch / x86 / kernel / apic_32.c
1 /*
2  *      Local APIC handling, local APIC timers
3  *
4  *      (c) 1999, 2000 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/init.h>
18
19 #include <linux/mm.h>
20 #include <linux/delay.h>
21 #include <linux/bootmem.h>
22 #include <linux/interrupt.h>
23 #include <linux/mc146818rtc.h>
24 #include <linux/kernel_stat.h>
25 #include <linux/sysdev.h>
26 #include <linux/cpu.h>
27 #include <linux/clockchips.h>
28 #include <linux/acpi_pmtmr.h>
29 #include <linux/module.h>
30 #include <linux/dmi.h>
31
32 #include <asm/atomic.h>
33 #include <asm/smp.h>
34 #include <asm/mtrr.h>
35 #include <asm/mpspec.h>
36 #include <asm/desc.h>
37 #include <asm/arch_hooks.h>
38 #include <asm/hpet.h>
39 #include <asm/i8253.h>
40 #include <asm/nmi.h>
41
42 #include <mach_apic.h>
43 #include <mach_apicdef.h>
44 #include <mach_ipi.h>
45
46 /*
47  * Sanity check
48  */
49 #if (SPURIOUS_APIC_VECTOR & 0x0F) != 0x0F
50 # error SPURIOUS_APIC_VECTOR definition error
51 #endif
52
53 /*
54  * Knob to control our willingness to enable the local APIC.
55  *
56  * -1=force-disable, +1=force-enable
57  */
58 static int enable_local_apic __initdata = 0;
59
60 /* Local APIC timer verification ok */
61 static int local_apic_timer_verify_ok;
62 /* Disable local APIC timer from the kernel commandline or via dmi quirk
63    or using CPU MSR check */
64 int local_apic_timer_disabled;
65 /* Local APIC timer works in C2 */
66 int local_apic_timer_c2_ok;
67 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
68
69 /*
70  * Debug level, exported for io_apic.c
71  */
72 int apic_verbosity;
73
74 static unsigned int calibration_result;
75
76 static int lapic_next_event(unsigned long delta,
77                             struct clock_event_device *evt);
78 static void lapic_timer_setup(enum clock_event_mode mode,
79                               struct clock_event_device *evt);
80 static void lapic_timer_broadcast(cpumask_t mask);
81 static void apic_pm_activate(void);
82
83 /*
84  * The local apic timer can be used for any function which is CPU local.
85  */
86 static struct clock_event_device lapic_clockevent = {
87         .name           = "lapic",
88         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT
89                         | CLOCK_EVT_FEAT_C3STOP | CLOCK_EVT_FEAT_DUMMY,
90         .shift          = 32,
91         .set_mode       = lapic_timer_setup,
92         .set_next_event = lapic_next_event,
93         .broadcast      = lapic_timer_broadcast,
94         .rating         = 100,
95         .irq            = -1,
96 };
97 static DEFINE_PER_CPU(struct clock_event_device, lapic_events);
98
99 /* Local APIC was disabled by the BIOS and enabled by the kernel */
100 static int enabled_via_apicbase;
101
102 /*
103  * Get the LAPIC version
104  */
105 static inline int lapic_get_version(void)
106 {
107         return GET_APIC_VERSION(apic_read(APIC_LVR));
108 }
109
110 /*
111  * Check, if the APIC is integrated or a seperate chip
112  */
113 static inline int lapic_is_integrated(void)
114 {
115         return APIC_INTEGRATED(lapic_get_version());
116 }
117
118 /*
119  * Check, whether this is a modern or a first generation APIC
120  */
121 static int modern_apic(void)
122 {
123         /* AMD systems use old APIC versions, so check the CPU */
124         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
125             boot_cpu_data.x86 >= 0xf)
126                 return 1;
127         return lapic_get_version() >= 0x14;
128 }
129
130 void apic_wait_icr_idle(void)
131 {
132         while (apic_read(APIC_ICR) & APIC_ICR_BUSY)
133                 cpu_relax();
134 }
135
136 u32 safe_apic_wait_icr_idle(void)
137 {
138         u32 send_status;
139         int timeout;
140
141         timeout = 0;
142         do {
143                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
144                 if (!send_status)
145                         break;
146                 udelay(100);
147         } while (timeout++ < 1000);
148
149         return send_status;
150 }
151
152 /**
153  * enable_NMI_through_LVT0 - enable NMI through local vector table 0
154  */
155 void enable_NMI_through_LVT0 (void * dummy)
156 {
157         unsigned int v = APIC_DM_NMI;
158
159         /* Level triggered for 82489DX */
160         if (!lapic_is_integrated())
161                 v |= APIC_LVT_LEVEL_TRIGGER;
162         apic_write_around(APIC_LVT0, v);
163 }
164
165 /**
166  * get_physical_broadcast - Get number of physical broadcast IDs
167  */
168 int get_physical_broadcast(void)
169 {
170         return modern_apic() ? 0xff : 0xf;
171 }
172
173 /**
174  * lapic_get_maxlvt - get the maximum number of local vector table entries
175  */
176 int lapic_get_maxlvt(void)
177 {
178         unsigned int v = apic_read(APIC_LVR);
179
180         /* 82489DXs do not report # of LVT entries. */
181         return APIC_INTEGRATED(GET_APIC_VERSION(v)) ? GET_APIC_MAXLVT(v) : 2;
182 }
183
184 /*
185  * Local APIC timer
186  */
187
188 /* Clock divisor is set to 16 */
189 #define APIC_DIVISOR 16
190
191 /*
192  * This function sets up the local APIC timer, with a timeout of
193  * 'clocks' APIC bus clock. During calibration we actually call
194  * this function twice on the boot CPU, once with a bogus timeout
195  * value, second time for real. The other (noncalibrating) CPUs
196  * call this function only once, with the real, calibrated value.
197  *
198  * We do reads before writes even if unnecessary, to get around the
199  * P5 APIC double write bug.
200  */
201 static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen)
202 {
203         unsigned int lvtt_value, tmp_value;
204
205         lvtt_value = LOCAL_TIMER_VECTOR;
206         if (!oneshot)
207                 lvtt_value |= APIC_LVT_TIMER_PERIODIC;
208         if (!lapic_is_integrated())
209                 lvtt_value |= SET_APIC_TIMER_BASE(APIC_TIMER_BASE_DIV);
210
211         if (!irqen)
212                 lvtt_value |= APIC_LVT_MASKED;
213
214         apic_write_around(APIC_LVTT, lvtt_value);
215
216         /*
217          * Divide PICLK by 16
218          */
219         tmp_value = apic_read(APIC_TDCR);
220         apic_write_around(APIC_TDCR, (tmp_value
221                                 & ~(APIC_TDR_DIV_1 | APIC_TDR_DIV_TMBASE))
222                                 | APIC_TDR_DIV_16);
223
224         if (!oneshot)
225                 apic_write_around(APIC_TMICT, clocks/APIC_DIVISOR);
226 }
227
228 /*
229  * Program the next event, relative to now
230  */
231 static int lapic_next_event(unsigned long delta,
232                             struct clock_event_device *evt)
233 {
234         apic_write_around(APIC_TMICT, delta);
235         return 0;
236 }
237
238 /*
239  * Setup the lapic timer in periodic or oneshot mode
240  */
241 static void lapic_timer_setup(enum clock_event_mode mode,
242                               struct clock_event_device *evt)
243 {
244         unsigned long flags;
245         unsigned int v;
246
247         /* Lapic used for broadcast ? */
248         if (!local_apic_timer_verify_ok)
249                 return;
250
251         local_irq_save(flags);
252
253         switch (mode) {
254         case CLOCK_EVT_MODE_PERIODIC:
255         case CLOCK_EVT_MODE_ONESHOT:
256                 __setup_APIC_LVTT(calibration_result,
257                                   mode != CLOCK_EVT_MODE_PERIODIC, 1);
258                 break;
259         case CLOCK_EVT_MODE_UNUSED:
260         case CLOCK_EVT_MODE_SHUTDOWN:
261                 v = apic_read(APIC_LVTT);
262                 v |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
263                 apic_write_around(APIC_LVTT, v);
264                 break;
265         case CLOCK_EVT_MODE_RESUME:
266                 /* Nothing to do here */
267                 break;
268         }
269
270         local_irq_restore(flags);
271 }
272
273 /*
274  * Local APIC timer broadcast function
275  */
276 static void lapic_timer_broadcast(cpumask_t mask)
277 {
278 #ifdef CONFIG_SMP
279         send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
280 #endif
281 }
282
283 /*
284  * Setup the local APIC timer for this CPU. Copy the initilized values
285  * of the boot CPU and register the clock event in the framework.
286  */
287 static void __devinit setup_APIC_timer(void)
288 {
289         struct clock_event_device *levt = &__get_cpu_var(lapic_events);
290
291         memcpy(levt, &lapic_clockevent, sizeof(*levt));
292         levt->cpumask = cpumask_of_cpu(smp_processor_id());
293
294         clockevents_register_device(levt);
295 }
296
297 /*
298  * In this functions we calibrate APIC bus clocks to the external timer.
299  *
300  * We want to do the calibration only once since we want to have local timer
301  * irqs syncron. CPUs connected by the same APIC bus have the very same bus
302  * frequency.
303  *
304  * This was previously done by reading the PIT/HPET and waiting for a wrap
305  * around to find out, that a tick has elapsed. I have a box, where the PIT
306  * readout is broken, so it never gets out of the wait loop again. This was
307  * also reported by others.
308  *
309  * Monitoring the jiffies value is inaccurate and the clockevents
310  * infrastructure allows us to do a simple substitution of the interrupt
311  * handler.
312  *
313  * The calibration routine also uses the pm_timer when possible, as the PIT
314  * happens to run way too slow (factor 2.3 on my VAIO CoreDuo, which goes
315  * back to normal later in the boot process).
316  */
317
318 #define LAPIC_CAL_LOOPS         (HZ/10)
319
320 static __initdata int lapic_cal_loops = -1;
321 static __initdata long lapic_cal_t1, lapic_cal_t2;
322 static __initdata unsigned long long lapic_cal_tsc1, lapic_cal_tsc2;
323 static __initdata unsigned long lapic_cal_pm1, lapic_cal_pm2;
324 static __initdata unsigned long lapic_cal_j1, lapic_cal_j2;
325
326 /*
327  * Temporary interrupt handler.
328  */
329 static void __init lapic_cal_handler(struct clock_event_device *dev)
330 {
331         unsigned long long tsc = 0;
332         long tapic = apic_read(APIC_TMCCT);
333         unsigned long pm = acpi_pm_read_early();
334
335         if (cpu_has_tsc)
336                 rdtscll(tsc);
337
338         switch (lapic_cal_loops++) {
339         case 0:
340                 lapic_cal_t1 = tapic;
341                 lapic_cal_tsc1 = tsc;
342                 lapic_cal_pm1 = pm;
343                 lapic_cal_j1 = jiffies;
344                 break;
345
346         case LAPIC_CAL_LOOPS:
347                 lapic_cal_t2 = tapic;
348                 lapic_cal_tsc2 = tsc;
349                 if (pm < lapic_cal_pm1)
350                         pm += ACPI_PM_OVRRUN;
351                 lapic_cal_pm2 = pm;
352                 lapic_cal_j2 = jiffies;
353                 break;
354         }
355 }
356
357 /*
358  * Setup the boot APIC
359  *
360  * Calibrate and verify the result.
361  */
362 void __init setup_boot_APIC_clock(void)
363 {
364         struct clock_event_device *levt = &__get_cpu_var(lapic_events);
365         const long pm_100ms = PMTMR_TICKS_PER_SEC/10;
366         const long pm_thresh = pm_100ms/100;
367         void (*real_handler)(struct clock_event_device *dev);
368         unsigned long deltaj;
369         long delta, deltapm;
370         int pm_referenced = 0;
371
372         /*
373          * The local apic timer can be disabled via the kernel
374          * commandline or from the CPU detection code. Register the lapic
375          * timer as a dummy clock event source on SMP systems, so the
376          * broadcast mechanism is used. On UP systems simply ignore it.
377          */
378         if (local_apic_timer_disabled) {
379                 /* No broadcast on UP ! */
380                 if (num_possible_cpus() > 1)
381                         setup_APIC_timer();
382                 return;
383         }
384
385         apic_printk(APIC_VERBOSE, "Using local APIC timer interrupts.\n"
386                     "calibrating APIC timer ...\n");
387
388         local_irq_disable();
389
390         /* Replace the global interrupt handler */
391         real_handler = global_clock_event->event_handler;
392         global_clock_event->event_handler = lapic_cal_handler;
393
394         /*
395          * Setup the APIC counter to 1e9. There is no way the lapic
396          * can underflow in the 100ms detection time frame
397          */
398         __setup_APIC_LVTT(1000000000, 0, 0);
399
400         /* Let the interrupts run */
401         local_irq_enable();
402
403         while (lapic_cal_loops <= LAPIC_CAL_LOOPS)
404                 cpu_relax();
405
406         local_irq_disable();
407
408         /* Restore the real event handler */
409         global_clock_event->event_handler = real_handler;
410
411         /* Build delta t1-t2 as apic timer counts down */
412         delta = lapic_cal_t1 - lapic_cal_t2;
413         apic_printk(APIC_VERBOSE, "... lapic delta = %ld\n", delta);
414
415         /* Check, if the PM timer is available */
416         deltapm = lapic_cal_pm2 - lapic_cal_pm1;
417         apic_printk(APIC_VERBOSE, "... PM timer delta = %ld\n", deltapm);
418
419         if (deltapm) {
420                 unsigned long mult;
421                 u64 res;
422
423                 mult = clocksource_hz2mult(PMTMR_TICKS_PER_SEC, 22);
424
425                 if (deltapm > (pm_100ms - pm_thresh) &&
426                     deltapm < (pm_100ms + pm_thresh)) {
427                         apic_printk(APIC_VERBOSE, "... PM timer result ok\n");
428                 } else {
429                         res = (((u64) deltapm) *  mult) >> 22;
430                         do_div(res, 1000000);
431                         printk(KERN_WARNING "APIC calibration not consistent "
432                                "with PM Timer: %ldms instead of 100ms\n",
433                                (long)res);
434                         /* Correct the lapic counter value */
435                         res = (((u64) delta ) * pm_100ms);
436                         do_div(res, deltapm);
437                         printk(KERN_INFO "APIC delta adjusted to PM-Timer: "
438                                "%lu (%ld)\n", (unsigned long) res, delta);
439                         delta = (long) res;
440                 }
441                 pm_referenced = 1;
442         }
443
444         /* Calculate the scaled math multiplication factor */
445         lapic_clockevent.mult = div_sc(delta, TICK_NSEC * LAPIC_CAL_LOOPS, 32);
446         lapic_clockevent.max_delta_ns =
447                 clockevent_delta2ns(0x7FFFFF, &lapic_clockevent);
448         lapic_clockevent.min_delta_ns =
449                 clockevent_delta2ns(0xF, &lapic_clockevent);
450
451         calibration_result = (delta * APIC_DIVISOR) / LAPIC_CAL_LOOPS;
452
453         apic_printk(APIC_VERBOSE, "..... delta %ld\n", delta);
454         apic_printk(APIC_VERBOSE, "..... mult: %ld\n", lapic_clockevent.mult);
455         apic_printk(APIC_VERBOSE, "..... calibration result: %u\n",
456                     calibration_result);
457
458         if (cpu_has_tsc) {
459                 delta = (long)(lapic_cal_tsc2 - lapic_cal_tsc1);
460                 apic_printk(APIC_VERBOSE, "..... CPU clock speed is "
461                             "%ld.%04ld MHz.\n",
462                             (delta / LAPIC_CAL_LOOPS) / (1000000 / HZ),
463                             (delta / LAPIC_CAL_LOOPS) % (1000000 / HZ));
464         }
465
466         apic_printk(APIC_VERBOSE, "..... host bus clock speed is "
467                     "%u.%04u MHz.\n",
468                     calibration_result / (1000000 / HZ),
469                     calibration_result % (1000000 / HZ));
470
471         local_apic_timer_verify_ok = 1;
472
473         /* We trust the pm timer based calibration */
474         if (!pm_referenced) {
475                 apic_printk(APIC_VERBOSE, "... verify APIC timer\n");
476
477                 /*
478                  * Setup the apic timer manually
479                  */
480                 levt->event_handler = lapic_cal_handler;
481                 lapic_timer_setup(CLOCK_EVT_MODE_PERIODIC, levt);
482                 lapic_cal_loops = -1;
483
484                 /* Let the interrupts run */
485                 local_irq_enable();
486
487                 while (lapic_cal_loops <= LAPIC_CAL_LOOPS)
488                         cpu_relax();
489
490                 local_irq_disable();
491
492                 /* Stop the lapic timer */
493                 lapic_timer_setup(CLOCK_EVT_MODE_SHUTDOWN, levt);
494
495                 local_irq_enable();
496
497                 /* Jiffies delta */
498                 deltaj = lapic_cal_j2 - lapic_cal_j1;
499                 apic_printk(APIC_VERBOSE, "... jiffies delta = %lu\n", deltaj);
500
501                 /* Check, if the jiffies result is consistent */
502                 if (deltaj >= LAPIC_CAL_LOOPS-2 && deltaj <= LAPIC_CAL_LOOPS+2)
503                         apic_printk(APIC_VERBOSE, "... jiffies result ok\n");
504                 else
505                         local_apic_timer_verify_ok = 0;
506         } else
507                 local_irq_enable();
508
509         if (!local_apic_timer_verify_ok) {
510                 printk(KERN_WARNING
511                        "APIC timer disabled due to verification failure.\n");
512                 /* No broadcast on UP ! */
513                 if (num_possible_cpus() == 1)
514                         return;
515         } else {
516                 /*
517                  * If nmi_watchdog is set to IO_APIC, we need the
518                  * PIT/HPET going.  Otherwise register lapic as a dummy
519                  * device.
520                  */
521                 if (nmi_watchdog != NMI_IO_APIC)
522                         lapic_clockevent.features &= ~CLOCK_EVT_FEAT_DUMMY;
523                 else
524                         printk(KERN_WARNING "APIC timer registered as dummy,"
525                                " due to nmi_watchdog=1!\n");
526         }
527
528         /* Setup the lapic or request the broadcast */
529         setup_APIC_timer();
530 }
531
532 void __devinit setup_secondary_APIC_clock(void)
533 {
534         setup_APIC_timer();
535 }
536
537 /*
538  * The guts of the apic timer interrupt
539  */
540 static void local_apic_timer_interrupt(void)
541 {
542         int cpu = smp_processor_id();
543         struct clock_event_device *evt = &per_cpu(lapic_events, cpu);
544
545         /*
546          * Normally we should not be here till LAPIC has been initialized but
547          * in some cases like kdump, its possible that there is a pending LAPIC
548          * timer interrupt from previous kernel's context and is delivered in
549          * new kernel the moment interrupts are enabled.
550          *
551          * Interrupts are enabled early and LAPIC is setup much later, hence
552          * its possible that when we get here evt->event_handler is NULL.
553          * Check for event_handler being NULL and discard the interrupt as
554          * spurious.
555          */
556         if (!evt->event_handler) {
557                 printk(KERN_WARNING
558                        "Spurious LAPIC timer interrupt on cpu %d\n", cpu);
559                 /* Switch it off */
560                 lapic_timer_setup(CLOCK_EVT_MODE_SHUTDOWN, evt);
561                 return;
562         }
563
564         /*
565          * the NMI deadlock-detector uses this.
566          */
567         per_cpu(irq_stat, cpu).apic_timer_irqs++;
568
569         evt->event_handler(evt);
570 }
571
572 /*
573  * Local APIC timer interrupt. This is the most natural way for doing
574  * local interrupts, but local timer interrupts can be emulated by
575  * broadcast interrupts too. [in case the hw doesn't support APIC timers]
576  *
577  * [ if a single-CPU system runs an SMP kernel then we call the local
578  *   interrupt as well. Thus we cannot inline the local irq ... ]
579  */
580
581 void fastcall smp_apic_timer_interrupt(struct pt_regs *regs)
582 {
583         struct pt_regs *old_regs = set_irq_regs(regs);
584
585         /*
586          * NOTE! We'd better ACK the irq immediately,
587          * because timer handling can be slow.
588          */
589         ack_APIC_irq();
590         /*
591          * update_process_times() expects us to have done irq_enter().
592          * Besides, if we don't timer interrupts ignore the global
593          * interrupt lock, which is the WrongThing (tm) to do.
594          */
595         irq_enter();
596         local_apic_timer_interrupt();
597         irq_exit();
598
599         set_irq_regs(old_regs);
600 }
601
602 int setup_profiling_timer(unsigned int multiplier)
603 {
604         return -EINVAL;
605 }
606
607 /*
608  * Local APIC start and shutdown
609  */
610
611 /**
612  * clear_local_APIC - shutdown the local APIC
613  *
614  * This is called, when a CPU is disabled and before rebooting, so the state of
615  * the local APIC has no dangling leftovers. Also used to cleanout any BIOS
616  * leftovers during boot.
617  */
618 void clear_local_APIC(void)
619 {
620         int maxlvt = lapic_get_maxlvt();
621         u32 v;
622
623         /*
624          * Masking an LVT entry can trigger a local APIC error
625          * if the vector is zero. Mask LVTERR first to prevent this.
626          */
627         if (maxlvt >= 3) {
628                 v = ERROR_APIC_VECTOR; /* any non-zero vector will do */
629                 apic_write_around(APIC_LVTERR, v | APIC_LVT_MASKED);
630         }
631         /*
632          * Careful: we have to set masks only first to deassert
633          * any level-triggered sources.
634          */
635         v = apic_read(APIC_LVTT);
636         apic_write_around(APIC_LVTT, v | APIC_LVT_MASKED);
637         v = apic_read(APIC_LVT0);
638         apic_write_around(APIC_LVT0, v | APIC_LVT_MASKED);
639         v = apic_read(APIC_LVT1);
640         apic_write_around(APIC_LVT1, v | APIC_LVT_MASKED);
641         if (maxlvt >= 4) {
642                 v = apic_read(APIC_LVTPC);
643                 apic_write_around(APIC_LVTPC, v | APIC_LVT_MASKED);
644         }
645
646         /* lets not touch this if we didn't frob it */
647 #ifdef CONFIG_X86_MCE_P4THERMAL
648         if (maxlvt >= 5) {
649                 v = apic_read(APIC_LVTTHMR);
650                 apic_write_around(APIC_LVTTHMR, v | APIC_LVT_MASKED);
651         }
652 #endif
653         /*
654          * Clean APIC state for other OSs:
655          */
656         apic_write_around(APIC_LVTT, APIC_LVT_MASKED);
657         apic_write_around(APIC_LVT0, APIC_LVT_MASKED);
658         apic_write_around(APIC_LVT1, APIC_LVT_MASKED);
659         if (maxlvt >= 3)
660                 apic_write_around(APIC_LVTERR, APIC_LVT_MASKED);
661         if (maxlvt >= 4)
662                 apic_write_around(APIC_LVTPC, APIC_LVT_MASKED);
663
664 #ifdef CONFIG_X86_MCE_P4THERMAL
665         if (maxlvt >= 5)
666                 apic_write_around(APIC_LVTTHMR, APIC_LVT_MASKED);
667 #endif
668         /* Integrated APIC (!82489DX) ? */
669         if (lapic_is_integrated()) {
670                 if (maxlvt > 3)
671                         /* Clear ESR due to Pentium errata 3AP and 11AP */
672                         apic_write(APIC_ESR, 0);
673                 apic_read(APIC_ESR);
674         }
675 }
676
677 /**
678  * disable_local_APIC - clear and disable the local APIC
679  */
680 void disable_local_APIC(void)
681 {
682         unsigned long value;
683
684         clear_local_APIC();
685
686         /*
687          * Disable APIC (implies clearing of registers
688          * for 82489DX!).
689          */
690         value = apic_read(APIC_SPIV);
691         value &= ~APIC_SPIV_APIC_ENABLED;
692         apic_write_around(APIC_SPIV, value);
693
694         /*
695          * When LAPIC was disabled by the BIOS and enabled by the kernel,
696          * restore the disabled state.
697          */
698         if (enabled_via_apicbase) {
699                 unsigned int l, h;
700
701                 rdmsr(MSR_IA32_APICBASE, l, h);
702                 l &= ~MSR_IA32_APICBASE_ENABLE;
703                 wrmsr(MSR_IA32_APICBASE, l, h);
704         }
705 }
706
707 /*
708  * If Linux enabled the LAPIC against the BIOS default disable it down before
709  * re-entering the BIOS on shutdown.  Otherwise the BIOS may get confused and
710  * not power-off.  Additionally clear all LVT entries before disable_local_APIC
711  * for the case where Linux didn't enable the LAPIC.
712  */
713 void lapic_shutdown(void)
714 {
715         unsigned long flags;
716
717         if (!cpu_has_apic)
718                 return;
719
720         local_irq_save(flags);
721         clear_local_APIC();
722
723         if (enabled_via_apicbase)
724                 disable_local_APIC();
725
726         local_irq_restore(flags);
727 }
728
729 /*
730  * This is to verify that we're looking at a real local APIC.
731  * Check these against your board if the CPUs aren't getting
732  * started for no apparent reason.
733  */
734 int __init verify_local_APIC(void)
735 {
736         unsigned int reg0, reg1;
737
738         /*
739          * The version register is read-only in a real APIC.
740          */
741         reg0 = apic_read(APIC_LVR);
742         apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg0);
743         apic_write(APIC_LVR, reg0 ^ APIC_LVR_MASK);
744         reg1 = apic_read(APIC_LVR);
745         apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg1);
746
747         /*
748          * The two version reads above should print the same
749          * numbers.  If the second one is different, then we
750          * poke at a non-APIC.
751          */
752         if (reg1 != reg0)
753                 return 0;
754
755         /*
756          * Check if the version looks reasonably.
757          */
758         reg1 = GET_APIC_VERSION(reg0);
759         if (reg1 == 0x00 || reg1 == 0xff)
760                 return 0;
761         reg1 = lapic_get_maxlvt();
762         if (reg1 < 0x02 || reg1 == 0xff)
763                 return 0;
764
765         /*
766          * The ID register is read/write in a real APIC.
767          */
768         reg0 = apic_read(APIC_ID);
769         apic_printk(APIC_DEBUG, "Getting ID: %x\n", reg0);
770
771         /*
772          * The next two are just to see if we have sane values.
773          * They're only really relevant if we're in Virtual Wire
774          * compatibility mode, but most boxes are anymore.
775          */
776         reg0 = apic_read(APIC_LVT0);
777         apic_printk(APIC_DEBUG, "Getting LVT0: %x\n", reg0);
778         reg1 = apic_read(APIC_LVT1);
779         apic_printk(APIC_DEBUG, "Getting LVT1: %x\n", reg1);
780
781         return 1;
782 }
783
784 /**
785  * sync_Arb_IDs - synchronize APIC bus arbitration IDs
786  */
787 void __init sync_Arb_IDs(void)
788 {
789         /*
790          * Unsupported on P4 - see Intel Dev. Manual Vol. 3, Ch. 8.6.1 And not
791          * needed on AMD.
792          */
793         if (modern_apic() || boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
794                 return;
795         /*
796          * Wait for idle.
797          */
798         apic_wait_icr_idle();
799
800         apic_printk(APIC_DEBUG, "Synchronizing Arb IDs.\n");
801         apic_write_around(APIC_ICR, APIC_DEST_ALLINC | APIC_INT_LEVELTRIG
802                                 | APIC_DM_INIT);
803 }
804
805 /*
806  * An initial setup of the virtual wire mode.
807  */
808 void __init init_bsp_APIC(void)
809 {
810         unsigned long value;
811
812         /*
813          * Don't do the setup now if we have a SMP BIOS as the
814          * through-I/O-APIC virtual wire mode might be active.
815          */
816         if (smp_found_config || !cpu_has_apic)
817                 return;
818
819         /*
820          * Do not trust the local APIC being empty at bootup.
821          */
822         clear_local_APIC();
823
824         /*
825          * Enable APIC.
826          */
827         value = apic_read(APIC_SPIV);
828         value &= ~APIC_VECTOR_MASK;
829         value |= APIC_SPIV_APIC_ENABLED;
830
831         /* This bit is reserved on P4/Xeon and should be cleared */
832         if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
833             (boot_cpu_data.x86 == 15))
834                 value &= ~APIC_SPIV_FOCUS_DISABLED;
835         else
836                 value |= APIC_SPIV_FOCUS_DISABLED;
837         value |= SPURIOUS_APIC_VECTOR;
838         apic_write_around(APIC_SPIV, value);
839
840         /*
841          * Set up the virtual wire mode.
842          */
843         apic_write_around(APIC_LVT0, APIC_DM_EXTINT);
844         value = APIC_DM_NMI;
845         if (!lapic_is_integrated())             /* 82489DX */
846                 value |= APIC_LVT_LEVEL_TRIGGER;
847         apic_write_around(APIC_LVT1, value);
848 }
849
850 /**
851  * setup_local_APIC - setup the local APIC
852  */
853 void __cpuinit setup_local_APIC(void)
854 {
855         unsigned long oldvalue, value, maxlvt, integrated;
856         int i, j;
857
858         /* Pound the ESR really hard over the head with a big hammer - mbligh */
859         if (esr_disable) {
860                 apic_write(APIC_ESR, 0);
861                 apic_write(APIC_ESR, 0);
862                 apic_write(APIC_ESR, 0);
863                 apic_write(APIC_ESR, 0);
864         }
865
866         integrated = lapic_is_integrated();
867
868         /*
869          * Double-check whether this APIC is really registered.
870          */
871         if (!apic_id_registered())
872                 BUG();
873
874         /*
875          * Intel recommends to set DFR, LDR and TPR before enabling
876          * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
877          * document number 292116).  So here it goes...
878          */
879         init_apic_ldr();
880
881         /*
882          * Set Task Priority to 'accept all'. We never change this
883          * later on.
884          */
885         value = apic_read(APIC_TASKPRI);
886         value &= ~APIC_TPRI_MASK;
887         apic_write_around(APIC_TASKPRI, value);
888
889         /*
890          * After a crash, we no longer service the interrupts and a pending
891          * interrupt from previous kernel might still have ISR bit set.
892          *
893          * Most probably by now CPU has serviced that pending interrupt and
894          * it might not have done the ack_APIC_irq() because it thought,
895          * interrupt came from i8259 as ExtInt. LAPIC did not get EOI so it
896          * does not clear the ISR bit and cpu thinks it has already serivced
897          * the interrupt. Hence a vector might get locked. It was noticed
898          * for timer irq (vector 0x31). Issue an extra EOI to clear ISR.
899          */
900         for (i = APIC_ISR_NR - 1; i >= 0; i--) {
901                 value = apic_read(APIC_ISR + i*0x10);
902                 for (j = 31; j >= 0; j--) {
903                         if (value & (1<<j))
904                                 ack_APIC_irq();
905                 }
906         }
907
908         /*
909          * Now that we are all set up, enable the APIC
910          */
911         value = apic_read(APIC_SPIV);
912         value &= ~APIC_VECTOR_MASK;
913         /*
914          * Enable APIC
915          */
916         value |= APIC_SPIV_APIC_ENABLED;
917
918         /*
919          * Some unknown Intel IO/APIC (or APIC) errata is biting us with
920          * certain networking cards. If high frequency interrupts are
921          * happening on a particular IOAPIC pin, plus the IOAPIC routing
922          * entry is masked/unmasked at a high rate as well then sooner or
923          * later IOAPIC line gets 'stuck', no more interrupts are received
924          * from the device. If focus CPU is disabled then the hang goes
925          * away, oh well :-(
926          *
927          * [ This bug can be reproduced easily with a level-triggered
928          *   PCI Ne2000 networking cards and PII/PIII processors, dual
929          *   BX chipset. ]
930          */
931         /*
932          * Actually disabling the focus CPU check just makes the hang less
933          * frequent as it makes the interrupt distributon model be more
934          * like LRU than MRU (the short-term load is more even across CPUs).
935          * See also the comment in end_level_ioapic_irq().  --macro
936          */
937
938         /* Enable focus processor (bit==0) */
939         value &= ~APIC_SPIV_FOCUS_DISABLED;
940
941         /*
942          * Set spurious IRQ vector
943          */
944         value |= SPURIOUS_APIC_VECTOR;
945         apic_write_around(APIC_SPIV, value);
946
947         /*
948          * Set up LVT0, LVT1:
949          *
950          * set up through-local-APIC on the BP's LINT0. This is not
951          * strictly necessary in pure symmetric-IO mode, but sometimes
952          * we delegate interrupts to the 8259A.
953          */
954         /*
955          * TODO: set up through-local-APIC from through-I/O-APIC? --macro
956          */
957         value = apic_read(APIC_LVT0) & APIC_LVT_MASKED;
958         if (!smp_processor_id() && (pic_mode || !value)) {
959                 value = APIC_DM_EXTINT;
960                 apic_printk(APIC_VERBOSE, "enabled ExtINT on CPU#%d\n",
961                                 smp_processor_id());
962         } else {
963                 value = APIC_DM_EXTINT | APIC_LVT_MASKED;
964                 apic_printk(APIC_VERBOSE, "masked ExtINT on CPU#%d\n",
965                                 smp_processor_id());
966         }
967         apic_write_around(APIC_LVT0, value);
968
969         /*
970          * only the BP should see the LINT1 NMI signal, obviously.
971          */
972         if (!smp_processor_id())
973                 value = APIC_DM_NMI;
974         else
975                 value = APIC_DM_NMI | APIC_LVT_MASKED;
976         if (!integrated)                /* 82489DX */
977                 value |= APIC_LVT_LEVEL_TRIGGER;
978         apic_write_around(APIC_LVT1, value);
979
980         if (integrated && !esr_disable) {               /* !82489DX */
981                 maxlvt = lapic_get_maxlvt();
982                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP. */
983                         apic_write(APIC_ESR, 0);
984                 oldvalue = apic_read(APIC_ESR);
985
986                 /* enables sending errors */
987                 value = ERROR_APIC_VECTOR;
988                 apic_write_around(APIC_LVTERR, value);
989                 /*
990                  * spec says clear errors after enabling vector.
991                  */
992                 if (maxlvt > 3)
993                         apic_write(APIC_ESR, 0);
994                 value = apic_read(APIC_ESR);
995                 if (value != oldvalue)
996                         apic_printk(APIC_VERBOSE, "ESR value before enabling "
997                                 "vector: 0x%08lx  after: 0x%08lx\n",
998                                 oldvalue, value);
999         } else {
1000                 if (esr_disable)
1001                         /*
1002                          * Something untraceable is creating bad interrupts on
1003                          * secondary quads ... for the moment, just leave the
1004                          * ESR disabled - we can't do anything useful with the
1005                          * errors anyway - mbligh
1006                          */
1007                         printk(KERN_INFO "Leaving ESR disabled.\n");
1008                 else
1009                         printk(KERN_INFO "No ESR for 82489DX.\n");
1010         }
1011
1012         /* Disable the local apic timer */
1013         value = apic_read(APIC_LVTT);
1014         value |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
1015         apic_write_around(APIC_LVTT, value);
1016
1017         setup_apic_nmi_watchdog(NULL);
1018         apic_pm_activate();
1019 }
1020
1021 /*
1022  * Detect and initialize APIC
1023  */
1024 static int __init detect_init_APIC (void)
1025 {
1026         u32 h, l, features;
1027
1028         /* Disabled by kernel option? */
1029         if (enable_local_apic < 0)
1030                 return -1;
1031
1032         switch (boot_cpu_data.x86_vendor) {
1033         case X86_VENDOR_AMD:
1034                 if ((boot_cpu_data.x86 == 6 && boot_cpu_data.x86_model > 1) ||
1035                     (boot_cpu_data.x86 == 15))
1036                         break;
1037                 goto no_apic;
1038         case X86_VENDOR_INTEL:
1039                 if (boot_cpu_data.x86 == 6 || boot_cpu_data.x86 == 15 ||
1040                     (boot_cpu_data.x86 == 5 && cpu_has_apic))
1041                         break;
1042                 goto no_apic;
1043         default:
1044                 goto no_apic;
1045         }
1046
1047         if (!cpu_has_apic) {
1048                 /*
1049                  * Over-ride BIOS and try to enable the local APIC only if
1050                  * "lapic" specified.
1051                  */
1052                 if (enable_local_apic <= 0) {
1053                         printk(KERN_INFO "Local APIC disabled by BIOS -- "
1054                                "you can enable it with \"lapic\"\n");
1055                         return -1;
1056                 }
1057                 /*
1058                  * Some BIOSes disable the local APIC in the APIC_BASE
1059                  * MSR. This can only be done in software for Intel P6 or later
1060                  * and AMD K7 (Model > 1) or later.
1061                  */
1062                 rdmsr(MSR_IA32_APICBASE, l, h);
1063                 if (!(l & MSR_IA32_APICBASE_ENABLE)) {
1064                         printk(KERN_INFO
1065                                "Local APIC disabled by BIOS -- reenabling.\n");
1066                         l &= ~MSR_IA32_APICBASE_BASE;
1067                         l |= MSR_IA32_APICBASE_ENABLE | APIC_DEFAULT_PHYS_BASE;
1068                         wrmsr(MSR_IA32_APICBASE, l, h);
1069                         enabled_via_apicbase = 1;
1070                 }
1071         }
1072         /*
1073          * The APIC feature bit should now be enabled
1074          * in `cpuid'
1075          */
1076         features = cpuid_edx(1);
1077         if (!(features & (1 << X86_FEATURE_APIC))) {
1078                 printk(KERN_WARNING "Could not enable APIC!\n");
1079                 return -1;
1080         }
1081         set_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
1082         mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
1083
1084         /* The BIOS may have set up the APIC at some other address */
1085         rdmsr(MSR_IA32_APICBASE, l, h);
1086         if (l & MSR_IA32_APICBASE_ENABLE)
1087                 mp_lapic_addr = l & MSR_IA32_APICBASE_BASE;
1088
1089         if (nmi_watchdog != NMI_NONE && nmi_watchdog != NMI_DISABLED)
1090                 nmi_watchdog = NMI_LOCAL_APIC;
1091
1092         printk(KERN_INFO "Found and enabled local APIC!\n");
1093
1094         apic_pm_activate();
1095
1096         return 0;
1097
1098 no_apic:
1099         printk(KERN_INFO "No local APIC present or hardware disabled\n");
1100         return -1;
1101 }
1102
1103 /**
1104  * init_apic_mappings - initialize APIC mappings
1105  */
1106 void __init init_apic_mappings(void)
1107 {
1108         unsigned long apic_phys;
1109
1110         /*
1111          * If no local APIC can be found then set up a fake all
1112          * zeroes page to simulate the local APIC and another
1113          * one for the IO-APIC.
1114          */
1115         if (!smp_found_config && detect_init_APIC()) {
1116                 apic_phys = (unsigned long) alloc_bootmem_pages(PAGE_SIZE);
1117                 apic_phys = __pa(apic_phys);
1118         } else
1119                 apic_phys = mp_lapic_addr;
1120
1121         set_fixmap_nocache(FIX_APIC_BASE, apic_phys);
1122         printk(KERN_DEBUG "mapped APIC to %08lx (%08lx)\n", APIC_BASE,
1123                apic_phys);
1124
1125         /*
1126          * Fetch the APIC ID of the BSP in case we have a
1127          * default configuration (or the MP table is broken).
1128          */
1129         if (boot_cpu_physical_apicid == -1U)
1130                 boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
1131
1132 #ifdef CONFIG_X86_IO_APIC
1133         {
1134                 unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
1135                 int i;
1136
1137                 for (i = 0; i < nr_ioapics; i++) {
1138                         if (smp_found_config) {
1139                                 ioapic_phys = mp_ioapics[i].mpc_apicaddr;
1140                                 if (!ioapic_phys) {
1141                                         printk(KERN_ERR
1142                                                "WARNING: bogus zero IO-APIC "
1143                                                "address found in MPTABLE, "
1144                                                "disabling IO/APIC support!\n");
1145                                         smp_found_config = 0;
1146                                         skip_ioapic_setup = 1;
1147                                         goto fake_ioapic_page;
1148                                 }
1149                         } else {
1150 fake_ioapic_page:
1151                                 ioapic_phys = (unsigned long)
1152                                               alloc_bootmem_pages(PAGE_SIZE);
1153                                 ioapic_phys = __pa(ioapic_phys);
1154                         }
1155                         set_fixmap_nocache(idx, ioapic_phys);
1156                         printk(KERN_DEBUG "mapped IOAPIC to %08lx (%08lx)\n",
1157                                __fix_to_virt(idx), ioapic_phys);
1158                         idx++;
1159                 }
1160         }
1161 #endif
1162 }
1163
1164 /*
1165  * This initializes the IO-APIC and APIC hardware if this is
1166  * a UP kernel.
1167  */
1168 int __init APIC_init_uniprocessor (void)
1169 {
1170         if (enable_local_apic < 0)
1171                 clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
1172
1173         if (!smp_found_config && !cpu_has_apic)
1174                 return -1;
1175
1176         /*
1177          * Complain if the BIOS pretends there is one.
1178          */
1179         if (!cpu_has_apic &&
1180             APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid])) {
1181                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
1182                        boot_cpu_physical_apicid);
1183                 clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
1184                 return -1;
1185         }
1186
1187         verify_local_APIC();
1188
1189         connect_bsp_APIC();
1190
1191         /*
1192          * Hack: In case of kdump, after a crash, kernel might be booting
1193          * on a cpu with non-zero lapic id. But boot_cpu_physical_apicid
1194          * might be zero if read from MP tables. Get it from LAPIC.
1195          */
1196 #ifdef CONFIG_CRASH_DUMP
1197         boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
1198 #endif
1199         phys_cpu_present_map = physid_mask_of_physid(boot_cpu_physical_apicid);
1200
1201         setup_local_APIC();
1202
1203 #ifdef CONFIG_X86_IO_APIC
1204         if (smp_found_config)
1205                 if (!skip_ioapic_setup && nr_ioapics)
1206                         setup_IO_APIC();
1207 #endif
1208         setup_boot_clock();
1209
1210         return 0;
1211 }
1212
1213 /*
1214  * Local APIC interrupts
1215  */
1216
1217 /*
1218  * This interrupt should _never_ happen with our APIC/SMP architecture
1219  */
1220 void smp_spurious_interrupt(struct pt_regs *regs)
1221 {
1222         unsigned long v;
1223
1224         irq_enter();
1225         /*
1226          * Check if this really is a spurious interrupt and ACK it
1227          * if it is a vectored one.  Just in case...
1228          * Spurious interrupts should not be ACKed.
1229          */
1230         v = apic_read(APIC_ISR + ((SPURIOUS_APIC_VECTOR & ~0x1f) >> 1));
1231         if (v & (1 << (SPURIOUS_APIC_VECTOR & 0x1f)))
1232                 ack_APIC_irq();
1233
1234         /* see sw-dev-man vol 3, chapter 7.4.13.5 */
1235         printk(KERN_INFO "spurious APIC interrupt on CPU#%d, "
1236                "should never happen.\n", smp_processor_id());
1237         __get_cpu_var(irq_stat).irq_spurious_count++;
1238         irq_exit();
1239 }
1240
1241 /*
1242  * This interrupt should never happen with our APIC/SMP architecture
1243  */
1244 void smp_error_interrupt(struct pt_regs *regs)
1245 {
1246         unsigned long v, v1;
1247
1248         irq_enter();
1249         /* First tickle the hardware, only then report what went on. -- REW */
1250         v = apic_read(APIC_ESR);
1251         apic_write(APIC_ESR, 0);
1252         v1 = apic_read(APIC_ESR);
1253         ack_APIC_irq();
1254         atomic_inc(&irq_err_count);
1255
1256         /* Here is what the APIC error bits mean:
1257            0: Send CS error
1258            1: Receive CS error
1259            2: Send accept error
1260            3: Receive accept error
1261            4: Reserved
1262            5: Send illegal vector
1263            6: Received illegal vector
1264            7: Illegal register address
1265         */
1266         printk (KERN_DEBUG "APIC error on CPU%d: %02lx(%02lx)\n",
1267                 smp_processor_id(), v , v1);
1268         irq_exit();
1269 }
1270
1271 /*
1272  * Initialize APIC interrupts
1273  */
1274 void __init apic_intr_init(void)
1275 {
1276 #ifdef CONFIG_SMP
1277         smp_intr_init();
1278 #endif
1279         /* self generated IPI for local APIC timer */
1280         set_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt);
1281
1282         /* IPI vectors for APIC spurious and error interrupts */
1283         set_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
1284         set_intr_gate(ERROR_APIC_VECTOR, error_interrupt);
1285
1286         /* thermal monitor LVT interrupt */
1287 #ifdef CONFIG_X86_MCE_P4THERMAL
1288         set_intr_gate(THERMAL_APIC_VECTOR, thermal_interrupt);
1289 #endif
1290 }
1291
1292 /**
1293  * connect_bsp_APIC - attach the APIC to the interrupt system
1294  */
1295 void __init connect_bsp_APIC(void)
1296 {
1297         if (pic_mode) {
1298                 /*
1299                  * Do not trust the local APIC being empty at bootup.
1300                  */
1301                 clear_local_APIC();
1302                 /*
1303                  * PIC mode, enable APIC mode in the IMCR, i.e.  connect BSP's
1304                  * local APIC to INT and NMI lines.
1305                  */
1306                 apic_printk(APIC_VERBOSE, "leaving PIC mode, "
1307                                 "enabling APIC mode.\n");
1308                 outb(0x70, 0x22);
1309                 outb(0x01, 0x23);
1310         }
1311         enable_apic_mode();
1312 }
1313
1314 /**
1315  * disconnect_bsp_APIC - detach the APIC from the interrupt system
1316  * @virt_wire_setup:    indicates, whether virtual wire mode is selected
1317  *
1318  * Virtual wire mode is necessary to deliver legacy interrupts even when the
1319  * APIC is disabled.
1320  */
1321 void disconnect_bsp_APIC(int virt_wire_setup)
1322 {
1323         if (pic_mode) {
1324                 /*
1325                  * Put the board back into PIC mode (has an effect only on
1326                  * certain older boards).  Note that APIC interrupts, including
1327                  * IPIs, won't work beyond this point!  The only exception are
1328                  * INIT IPIs.
1329                  */
1330                 apic_printk(APIC_VERBOSE, "disabling APIC mode, "
1331                                 "entering PIC mode.\n");
1332                 outb(0x70, 0x22);
1333                 outb(0x00, 0x23);
1334         } else {
1335                 /* Go back to Virtual Wire compatibility mode */
1336                 unsigned long value;
1337
1338                 /* For the spurious interrupt use vector F, and enable it */
1339                 value = apic_read(APIC_SPIV);
1340                 value &= ~APIC_VECTOR_MASK;
1341                 value |= APIC_SPIV_APIC_ENABLED;
1342                 value |= 0xf;
1343                 apic_write_around(APIC_SPIV, value);
1344
1345                 if (!virt_wire_setup) {
1346                         /*
1347                          * For LVT0 make it edge triggered, active high,
1348                          * external and enabled
1349                          */
1350                         value = apic_read(APIC_LVT0);
1351                         value &= ~(APIC_MODE_MASK | APIC_SEND_PENDING |
1352                                 APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
1353                                 APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED );
1354                         value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
1355                         value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_EXTINT);
1356                         apic_write_around(APIC_LVT0, value);
1357                 } else {
1358                         /* Disable LVT0 */
1359                         apic_write_around(APIC_LVT0, APIC_LVT_MASKED);
1360                 }
1361
1362                 /*
1363                  * For LVT1 make it edge triggered, active high, nmi and
1364                  * enabled
1365                  */
1366                 value = apic_read(APIC_LVT1);
1367                 value &= ~(
1368                         APIC_MODE_MASK | APIC_SEND_PENDING |
1369                         APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
1370                         APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED);
1371                 value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
1372                 value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_NMI);
1373                 apic_write_around(APIC_LVT1, value);
1374         }
1375 }
1376
1377 /*
1378  * Power management
1379  */
1380 #ifdef CONFIG_PM
1381
1382 static struct {
1383         int active;
1384         /* r/w apic fields */
1385         unsigned int apic_id;
1386         unsigned int apic_taskpri;
1387         unsigned int apic_ldr;
1388         unsigned int apic_dfr;
1389         unsigned int apic_spiv;
1390         unsigned int apic_lvtt;
1391         unsigned int apic_lvtpc;
1392         unsigned int apic_lvt0;
1393         unsigned int apic_lvt1;
1394         unsigned int apic_lvterr;
1395         unsigned int apic_tmict;
1396         unsigned int apic_tdcr;
1397         unsigned int apic_thmr;
1398 } apic_pm_state;
1399
1400 static int lapic_suspend(struct sys_device *dev, pm_message_t state)
1401 {
1402         unsigned long flags;
1403         int maxlvt;
1404
1405         if (!apic_pm_state.active)
1406                 return 0;
1407
1408         maxlvt = lapic_get_maxlvt();
1409
1410         apic_pm_state.apic_id = apic_read(APIC_ID);
1411         apic_pm_state.apic_taskpri = apic_read(APIC_TASKPRI);
1412         apic_pm_state.apic_ldr = apic_read(APIC_LDR);
1413         apic_pm_state.apic_dfr = apic_read(APIC_DFR);
1414         apic_pm_state.apic_spiv = apic_read(APIC_SPIV);
1415         apic_pm_state.apic_lvtt = apic_read(APIC_LVTT);
1416         if (maxlvt >= 4)
1417                 apic_pm_state.apic_lvtpc = apic_read(APIC_LVTPC);
1418         apic_pm_state.apic_lvt0 = apic_read(APIC_LVT0);
1419         apic_pm_state.apic_lvt1 = apic_read(APIC_LVT1);
1420         apic_pm_state.apic_lvterr = apic_read(APIC_LVTERR);
1421         apic_pm_state.apic_tmict = apic_read(APIC_TMICT);
1422         apic_pm_state.apic_tdcr = apic_read(APIC_TDCR);
1423 #ifdef CONFIG_X86_MCE_P4THERMAL
1424         if (maxlvt >= 5)
1425                 apic_pm_state.apic_thmr = apic_read(APIC_LVTTHMR);
1426 #endif
1427
1428         local_irq_save(flags);
1429         disable_local_APIC();
1430         local_irq_restore(flags);
1431         return 0;
1432 }
1433
1434 static int lapic_resume(struct sys_device *dev)
1435 {
1436         unsigned int l, h;
1437         unsigned long flags;
1438         int maxlvt;
1439
1440         if (!apic_pm_state.active)
1441                 return 0;
1442
1443         maxlvt = lapic_get_maxlvt();
1444
1445         local_irq_save(flags);
1446
1447         /*
1448          * Make sure the APICBASE points to the right address
1449          *
1450          * FIXME! This will be wrong if we ever support suspend on
1451          * SMP! We'll need to do this as part of the CPU restore!
1452          */
1453         rdmsr(MSR_IA32_APICBASE, l, h);
1454         l &= ~MSR_IA32_APICBASE_BASE;
1455         l |= MSR_IA32_APICBASE_ENABLE | mp_lapic_addr;
1456         wrmsr(MSR_IA32_APICBASE, l, h);
1457
1458         apic_write(APIC_LVTERR, ERROR_APIC_VECTOR | APIC_LVT_MASKED);
1459         apic_write(APIC_ID, apic_pm_state.apic_id);
1460         apic_write(APIC_DFR, apic_pm_state.apic_dfr);
1461         apic_write(APIC_LDR, apic_pm_state.apic_ldr);
1462         apic_write(APIC_TASKPRI, apic_pm_state.apic_taskpri);
1463         apic_write(APIC_SPIV, apic_pm_state.apic_spiv);
1464         apic_write(APIC_LVT0, apic_pm_state.apic_lvt0);
1465         apic_write(APIC_LVT1, apic_pm_state.apic_lvt1);
1466 #ifdef CONFIG_X86_MCE_P4THERMAL
1467         if (maxlvt >= 5)
1468                 apic_write(APIC_LVTTHMR, apic_pm_state.apic_thmr);
1469 #endif
1470         if (maxlvt >= 4)
1471                 apic_write(APIC_LVTPC, apic_pm_state.apic_lvtpc);
1472         apic_write(APIC_LVTT, apic_pm_state.apic_lvtt);
1473         apic_write(APIC_TDCR, apic_pm_state.apic_tdcr);
1474         apic_write(APIC_TMICT, apic_pm_state.apic_tmict);
1475         apic_write(APIC_ESR, 0);
1476         apic_read(APIC_ESR);
1477         apic_write(APIC_LVTERR, apic_pm_state.apic_lvterr);
1478         apic_write(APIC_ESR, 0);
1479         apic_read(APIC_ESR);
1480         local_irq_restore(flags);
1481         return 0;
1482 }
1483
1484 /*
1485  * This device has no shutdown method - fully functioning local APICs
1486  * are needed on every CPU up until machine_halt/restart/poweroff.
1487  */
1488
1489 static struct sysdev_class lapic_sysclass = {
1490         .name           = "lapic",
1491         .resume         = lapic_resume,
1492         .suspend        = lapic_suspend,
1493 };
1494
1495 static struct sys_device device_lapic = {
1496         .id     = 0,
1497         .cls    = &lapic_sysclass,
1498 };
1499
1500 static void __devinit apic_pm_activate(void)
1501 {
1502         apic_pm_state.active = 1;
1503 }
1504
1505 static int __init init_lapic_sysfs(void)
1506 {
1507         int error;
1508
1509         if (!cpu_has_apic)
1510                 return 0;
1511         /* XXX: remove suspend/resume procs if !apic_pm_state.active? */
1512
1513         error = sysdev_class_register(&lapic_sysclass);
1514         if (!error)
1515                 error = sysdev_register(&device_lapic);
1516         return error;
1517 }
1518 device_initcall(init_lapic_sysfs);
1519
1520 #else   /* CONFIG_PM */
1521
1522 static void apic_pm_activate(void) { }
1523
1524 #endif  /* CONFIG_PM */
1525
1526 /*
1527  * APIC command line parameters
1528  */
1529 static int __init parse_lapic(char *arg)
1530 {
1531         enable_local_apic = 1;
1532         return 0;
1533 }
1534 early_param("lapic", parse_lapic);
1535
1536 static int __init parse_nolapic(char *arg)
1537 {
1538         enable_local_apic = -1;
1539         clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
1540         return 0;
1541 }
1542 early_param("nolapic", parse_nolapic);
1543
1544 static int __init parse_disable_lapic_timer(char *arg)
1545 {
1546         local_apic_timer_disabled = 1;
1547         return 0;
1548 }
1549 early_param("nolapic_timer", parse_disable_lapic_timer);
1550
1551 static int __init parse_lapic_timer_c2_ok(char *arg)
1552 {
1553         local_apic_timer_c2_ok = 1;
1554         return 0;
1555 }
1556 early_param("lapic_timer_c2_ok", parse_lapic_timer_c2_ok);
1557
1558 static int __init apic_set_verbosity(char *str)
1559 {
1560         if (strcmp("debug", str) == 0)
1561                 apic_verbosity = APIC_DEBUG;
1562         else if (strcmp("verbose", str) == 0)
1563                 apic_verbosity = APIC_VERBOSE;
1564         return 1;
1565 }
1566 __setup("apic=", apic_set_verbosity);
1567