git.oblomov.eu Git - linux-2.6/blob - arch/x86/kernel/apic_64.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/module.h>
  27 #include <linux/ioport.h>
  28 #include <linux/clockchips.h>
  29
  30 #include <asm/atomic.h>
  31 #include <asm/smp.h>
  32 #include <asm/mtrr.h>
  33 #include <asm/mpspec.h>
  34 #include <asm/pgalloc.h>
  35 #include <asm/mach_apic.h>
  36 #include <asm/nmi.h>
  37 #include <asm/idle.h>
  38 #include <asm/proto.h>
  39 #include <asm/timex.h>
  40 #include <asm/hpet.h>
  41 #include <asm/apic.h>
  42
  43 int apic_verbosity;
  44 int disable_apic_timer __cpuinitdata;
  45 static int apic_calibrate_pmtmr __initdata;
  46
  47 /* Local APIC timer works in C2? */
  48 int local_apic_timer_c2_ok;
  49 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
  50
  51 static struct resource *ioapic_resources;
  52 static struct resource lapic_resource = {
  53         .name = "Local APIC",
  54         .flags = IORESOURCE_MEM | IORESOURCE_BUSY,
  55 };
  56
  57 static unsigned int calibration_result;
  58
  59 static int lapic_next_event(unsigned long delta,
  60                             struct clock_event_device *evt);
  61 static void lapic_timer_setup(enum clock_event_mode mode,
  62                               struct clock_event_device *evt);
  63
  64 static void lapic_timer_broadcast(cpumask_t mask);
  65
  66 static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen);
  67
  68 static struct clock_event_device lapic_clockevent = {
  69         .name           = "lapic",
  70         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT
  71                         | CLOCK_EVT_FEAT_C3STOP | CLOCK_EVT_FEAT_DUMMY,
  72         .shift          = 32,
  73         .set_mode       = lapic_timer_setup,
  74         .set_next_event = lapic_next_event,
  75         .broadcast      = lapic_timer_broadcast,
  76         .rating         = 100,
  77         .irq            = -1,
  78 };
  79 static DEFINE_PER_CPU(struct clock_event_device, lapic_events);
  80
  81 static int lapic_next_event(unsigned long delta,
  82                             struct clock_event_device *evt)
  83 {
  84         apic_write(APIC_TMICT, delta);
  85         return 0;
  86 }
  87
  88 static void lapic_timer_setup(enum clock_event_mode mode,
  89                               struct clock_event_device *evt)
  90 {
  91         unsigned long flags;
  92         unsigned int v;
  93
  94         /* Lapic used as dummy for broadcast ? */
  95         if (evt->features & CLOCK_EVT_FEAT_DUMMY)
  96                 return;
  97
  98         local_irq_save(flags);
  99
 100         switch (mode) {
 101         case CLOCK_EVT_MODE_PERIODIC:
 102         case CLOCK_EVT_MODE_ONESHOT:
 103                 __setup_APIC_LVTT(calibration_result,
 104                                   mode != CLOCK_EVT_MODE_PERIODIC, 1);
 105                 break;
 106         case CLOCK_EVT_MODE_UNUSED:
 107         case CLOCK_EVT_MODE_SHUTDOWN:
 108                 v = apic_read(APIC_LVTT);
 109                 v |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
 110                 apic_write(APIC_LVTT, v);
 111                 break;
 112         case CLOCK_EVT_MODE_RESUME:
 113                 /* Nothing to do here */
 114                 break;
 115         }
 116
 117         local_irq_restore(flags);
 118 }
 119
 120 /*
 121  * Local APIC timer broadcast function
 122  */
 123 static void lapic_timer_broadcast(cpumask_t mask)
 124 {
 125 #ifdef CONFIG_SMP
 126         send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
 127 #endif
 128 }
 129
 130 static void apic_pm_activate(void);
 131
 132 void apic_wait_icr_idle(void)
 133 {
 134         while (apic_read(APIC_ICR) & APIC_ICR_BUSY)
 135                 cpu_relax();
 136 }
 137
 138 unsigned int safe_apic_wait_icr_idle(void)
 139 {
 140         unsigned int send_status;
 141         int timeout;
 142
 143         timeout = 0;
 144         do {
 145                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 146                 if (!send_status)
 147                         break;
 148                 udelay(100);
 149         } while (timeout++ < 1000);
 150
 151         return send_status;
 152 }
 153
 154 void enable_NMI_through_LVT0 (void * dummy)
 155 {
 156         unsigned int v;
 157
 158         /* unmask and set to NMI */
 159         v = APIC_DM_NMI;
 160         apic_write(APIC_LVT0, v);
 161 }
 162
 163 int get_maxlvt(void)
 164 {
 165         unsigned int v, maxlvt;
 166
 167         v = apic_read(APIC_LVR);
 168         maxlvt = GET_APIC_MAXLVT(v);
 169         return maxlvt;
 170 }
 171
 172 /*
 173  * 'what should we do if we get a hw irq event on an illegal vector'.
 174  * each architecture has to answer this themselves.
 175  */
 176 void ack_bad_irq(unsigned int irq)
 177 {
 178         printk("unexpected IRQ trap at vector %02x\n", irq);
 179         /*
 180          * Currently unexpected vectors happen only on SMP and APIC.
 181          * We _must_ ack these because every local APIC has only N
 182          * irq slots per priority level, and a 'hanging, unacked' IRQ
 183          * holds up an irq slot - in excessive cases (when multiple
 184          * unexpected vectors occur) that might lock up the APIC
 185          * completely.
 186          * But don't ack when the APIC is disabled. -AK
 187          */
 188         if (!disable_apic)
 189                 ack_APIC_irq();
 190 }
 191
 192 void clear_local_APIC(void)
 193 {
 194         int maxlvt;
 195         unsigned int v;
 196
 197         maxlvt = get_maxlvt();
 198
 199         /*
 200          * Masking an LVT entry can trigger a local APIC error
 201          * if the vector is zero. Mask LVTERR first to prevent this.
 202          */
 203         if (maxlvt >= 3) {
 204                 v = ERROR_APIC_VECTOR; /* any non-zero vector will do */
 205                 apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
 206         }
 207         /*
 208          * Careful: we have to set masks only first to deassert
 209          * any level-triggered sources.
 210          */
 211         v = apic_read(APIC_LVTT);
 212         apic_write(APIC_LVTT, v | APIC_LVT_MASKED);
 213         v = apic_read(APIC_LVT0);
 214         apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
 215         v = apic_read(APIC_LVT1);
 216         apic_write(APIC_LVT1, v | APIC_LVT_MASKED);
 217         if (maxlvt >= 4) {
 218                 v = apic_read(APIC_LVTPC);
 219                 apic_write(APIC_LVTPC, v | APIC_LVT_MASKED);
 220         }
 221
 222         /*
 223          * Clean APIC state for other OSs:
 224          */
 225         apic_write(APIC_LVTT, APIC_LVT_MASKED);
 226         apic_write(APIC_LVT0, APIC_LVT_MASKED);
 227         apic_write(APIC_LVT1, APIC_LVT_MASKED);
 228         if (maxlvt >= 3)
 229                 apic_write(APIC_LVTERR, APIC_LVT_MASKED);
 230         if (maxlvt >= 4)
 231                 apic_write(APIC_LVTPC, APIC_LVT_MASKED);
 232         apic_write(APIC_ESR, 0);
 233         apic_read(APIC_ESR);
 234 }
 235
 236 void disconnect_bsp_APIC(int virt_wire_setup)
 237 {
 238         /* Go back to Virtual Wire compatibility mode */
 239         unsigned long value;
 240
 241         /* For the spurious interrupt use vector F, and enable it */
 242         value = apic_read(APIC_SPIV);
 243         value &= ~APIC_VECTOR_MASK;
 244         value |= APIC_SPIV_APIC_ENABLED;
 245         value |= 0xf;
 246         apic_write(APIC_SPIV, value);
 247
 248         if (!virt_wire_setup) {
 249                 /*
 250                  * For LVT0 make it edge triggered, active high,
 251                  * external and enabled
 252                  */
 253                 value = apic_read(APIC_LVT0);
 254                 value &= ~(APIC_MODE_MASK | APIC_SEND_PENDING |
 255                         APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
 256                         APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED );
 257                 value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
 258                 value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_EXTINT);
 259                 apic_write(APIC_LVT0, value);
 260         } else {
 261                 /* Disable LVT0 */
 262                 apic_write(APIC_LVT0, APIC_LVT_MASKED);
 263         }
 264
 265         /* For LVT1 make it edge triggered, active high, nmi and enabled */
 266         value = apic_read(APIC_LVT1);
 267         value &= ~(APIC_MODE_MASK | APIC_SEND_PENDING |
 268                         APIC_INPUT_POLARITY | APIC_LVT_REMOTE_IRR |
 269                         APIC_LVT_LEVEL_TRIGGER | APIC_LVT_MASKED);
 270         value |= APIC_LVT_REMOTE_IRR | APIC_SEND_PENDING;
 271         value = SET_APIC_DELIVERY_MODE(value, APIC_MODE_NMI);
 272         apic_write(APIC_LVT1, value);
 273 }
 274
 275 void disable_local_APIC(void)
 276 {
 277         unsigned int value;
 278
 279         clear_local_APIC();
 280
 281         /*
 282          * Disable APIC (implies clearing of registers
 283          * for 82489DX!).
 284          */
 285         value = apic_read(APIC_SPIV);
 286         value &= ~APIC_SPIV_APIC_ENABLED;
 287         apic_write(APIC_SPIV, value);
 288 }
 289
 290 /*
 291  * This is to verify that we're looking at a real local APIC.
 292  * Check these against your board if the CPUs aren't getting
 293  * started for no apparent reason.
 294  */
 295 int __init verify_local_APIC(void)
 296 {
 297         unsigned int reg0, reg1;
 298
 299         /*
 300          * The version register is read-only in a real APIC.
 301          */
 302         reg0 = apic_read(APIC_LVR);
 303         apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg0);
 304         apic_write(APIC_LVR, reg0 ^ APIC_LVR_MASK);
 305         reg1 = apic_read(APIC_LVR);
 306         apic_printk(APIC_DEBUG, "Getting VERSION: %x\n", reg1);
 307
 308         /*
 309          * The two version reads above should print the same
 310          * numbers.  If the second one is different, then we
 311          * poke at a non-APIC.
 312          */
 313         if (reg1 != reg0)
 314                 return 0;
 315
 316         /*
 317          * Check if the version looks reasonably.
 318          */
 319         reg1 = GET_APIC_VERSION(reg0);
 320         if (reg1 == 0x00 || reg1 == 0xff)
 321                 return 0;
 322         reg1 = get_maxlvt();
 323         if (reg1 < 0x02 || reg1 == 0xff)
 324                 return 0;
 325
 326         /*
 327          * The ID register is read/write in a real APIC.
 328          */
 329         reg0 = apic_read(APIC_ID);
 330         apic_printk(APIC_DEBUG, "Getting ID: %x\n", reg0);
 331         apic_write(APIC_ID, reg0 ^ APIC_ID_MASK);
 332         reg1 = apic_read(APIC_ID);
 333         apic_printk(APIC_DEBUG, "Getting ID: %x\n", reg1);
 334         apic_write(APIC_ID, reg0);
 335         if (reg1 != (reg0 ^ APIC_ID_MASK))
 336                 return 0;
 337
 338         /*
 339          * The next two are just to see if we have sane values.
 340          * They're only really relevant if we're in Virtual Wire
 341          * compatibility mode, but most boxes are anymore.
 342          */
 343         reg0 = apic_read(APIC_LVT0);
 344         apic_printk(APIC_DEBUG,"Getting LVT0: %x\n", reg0);
 345         reg1 = apic_read(APIC_LVT1);
 346         apic_printk(APIC_DEBUG, "Getting LVT1: %x\n", reg1);
 347
 348         return 1;
 349 }
 350
 351 void __init sync_Arb_IDs(void)
 352 {
 353         /* Unsupported on P4 - see Intel Dev. Manual Vol. 3, Ch. 8.6.1 */
 354         unsigned int ver = GET_APIC_VERSION(apic_read(APIC_LVR));
 355         if (ver >= 0x14)        /* P4 or higher */
 356                 return;
 357
 358         /*
 359          * Wait for idle.
 360          */
 361         apic_wait_icr_idle();
 362
 363         apic_printk(APIC_DEBUG, "Synchronizing Arb IDs.\n");
 364         apic_write(APIC_ICR, APIC_DEST_ALLINC | APIC_INT_LEVELTRIG
 365                                 | APIC_DM_INIT);
 366 }
 367
 368 /*
 369  * An initial setup of the virtual wire mode.
 370  */
 371 void __init init_bsp_APIC(void)
 372 {
 373         unsigned int value;
 374
 375         /*
 376          * Don't do the setup now if we have a SMP BIOS as the
 377          * through-I/O-APIC virtual wire mode might be active.
 378          */
 379         if (smp_found_config || !cpu_has_apic)
 380                 return;
 381
 382         value = apic_read(APIC_LVR);
 383
 384         /*
 385          * Do not trust the local APIC being empty at bootup.
 386          */
 387         clear_local_APIC();
 388
 389         /*
 390          * Enable APIC.
 391          */
 392         value = apic_read(APIC_SPIV);
 393         value &= ~APIC_VECTOR_MASK;
 394         value |= APIC_SPIV_APIC_ENABLED;
 395         value |= APIC_SPIV_FOCUS_DISABLED;
 396         value |= SPURIOUS_APIC_VECTOR;
 397         apic_write(APIC_SPIV, value);
 398
 399         /*
 400          * Set up the virtual wire mode.
 401          */
 402         apic_write(APIC_LVT0, APIC_DM_EXTINT);
 403         value = APIC_DM_NMI;
 404         apic_write(APIC_LVT1, value);
 405 }
 406
 407 void __cpuinit setup_local_APIC (void)
 408 {
 409         unsigned int value, maxlvt;
 410         int i, j;
 411
 412         value = apic_read(APIC_LVR);
 413
 414         BUILD_BUG_ON((SPURIOUS_APIC_VECTOR & 0x0f) != 0x0f);
 415
 416         /*
 417          * Double-check whether this APIC is really registered.
 418          * This is meaningless in clustered apic mode, so we skip it.
 419          */
 420         if (!apic_id_registered())
 421                 BUG();
 422
 423         /*
 424          * Intel recommends to set DFR, LDR and TPR before enabling
 425          * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
 426          * document number 292116).  So here it goes...
 427          */
 428         init_apic_ldr();
 429
 430         /*
 431          * Set Task Priority to 'accept all'. We never change this
 432          * later on.
 433          */
 434         value = apic_read(APIC_TASKPRI);
 435         value &= ~APIC_TPRI_MASK;
 436         apic_write(APIC_TASKPRI, value);
 437
 438         /*
 439          * After a crash, we no longer service the interrupts and a pending
 440          * interrupt from previous kernel might still have ISR bit set.
 441          *
 442          * Most probably by now CPU has serviced that pending interrupt and
 443          * it might not have done the ack_APIC_irq() because it thought,
 444          * interrupt came from i8259 as ExtInt. LAPIC did not get EOI so it
 445          * does not clear the ISR bit and cpu thinks it has already serivced
 446          * the interrupt. Hence a vector might get locked. It was noticed
 447          * for timer irq (vector 0x31). Issue an extra EOI to clear ISR.
 448          */
 449         for (i = APIC_ISR_NR - 1; i >= 0; i--) {
 450                 value = apic_read(APIC_ISR + i*0x10);
 451                 for (j = 31; j >= 0; j--) {
 452                         if (value & (1<<j))
 453                                 ack_APIC_irq();
 454                 }
 455         }
 456
 457         /*
 458          * Now that we are all set up, enable the APIC
 459          */
 460         value = apic_read(APIC_SPIV);
 461         value &= ~APIC_VECTOR_MASK;
 462         /*
 463          * Enable APIC
 464          */
 465         value |= APIC_SPIV_APIC_ENABLED;
 466
 467         /* We always use processor focus */
 468
 469         /*
 470          * Set spurious IRQ vector
 471          */
 472         value |= SPURIOUS_APIC_VECTOR;
 473         apic_write(APIC_SPIV, value);
 474
 475         /*
 476          * Set up LVT0, LVT1:
 477          *
 478          * set up through-local-APIC on the BP's LINT0. This is not
 479          * strictly necessary in pure symmetric-IO mode, but sometimes
 480          * we delegate interrupts to the 8259A.
 481          */
 482         /*
 483          * TODO: set up through-local-APIC from through-I/O-APIC? --macro
 484          */
 485         value = apic_read(APIC_LVT0) & APIC_LVT_MASKED;
 486         if (!smp_processor_id() && !value) {
 487                 value = APIC_DM_EXTINT;
 488                 apic_printk(APIC_VERBOSE, "enabled ExtINT on CPU#%d\n",
 489                             smp_processor_id());
 490         } else {
 491                 value = APIC_DM_EXTINT | APIC_LVT_MASKED;
 492                 apic_printk(APIC_VERBOSE, "masked ExtINT on CPU#%d\n",
 493                             smp_processor_id());
 494         }
 495         apic_write(APIC_LVT0, value);
 496
 497         /*
 498          * only the BP should see the LINT1 NMI signal, obviously.
 499          */
 500         if (!smp_processor_id())
 501                 value = APIC_DM_NMI;
 502         else
 503                 value = APIC_DM_NMI | APIC_LVT_MASKED;
 504         apic_write(APIC_LVT1, value);
 505
 506         {
 507                 unsigned oldvalue;
 508                 maxlvt = get_maxlvt();
 509                 oldvalue = apic_read(APIC_ESR);
 510                 value = ERROR_APIC_VECTOR;      // enables sending errors
 511                 apic_write(APIC_LVTERR, value);
 512                 /*
 513                  * spec says clear errors after enabling vector.
 514                  */
 515                 if (maxlvt > 3)
 516                         apic_write(APIC_ESR, 0);
 517                 value = apic_read(APIC_ESR);
 518                 if (value != oldvalue)
 519                         apic_printk(APIC_VERBOSE,
 520                         "ESR value after enabling vector: %08x, after %08x\n",
 521                         oldvalue, value);
 522         }
 523
 524         nmi_watchdog_default();
 525         setup_apic_nmi_watchdog(NULL);
 526         apic_pm_activate();
 527 }
 528
 529 #ifdef CONFIG_PM
 530
 531 static struct {
 532         /* 'active' is true if the local APIC was enabled by us and
 533            not the BIOS; this signifies that we are also responsible
 534            for disabling it before entering apm/acpi suspend */
 535         int active;
 536         /* r/w apic fields */
 537         unsigned int apic_id;
 538         unsigned int apic_taskpri;
 539         unsigned int apic_ldr;
 540         unsigned int apic_dfr;
 541         unsigned int apic_spiv;
 542         unsigned int apic_lvtt;
 543         unsigned int apic_lvtpc;
 544         unsigned int apic_lvt0;
 545         unsigned int apic_lvt1;
 546         unsigned int apic_lvterr;
 547         unsigned int apic_tmict;
 548         unsigned int apic_tdcr;
 549         unsigned int apic_thmr;
 550 } apic_pm_state;
 551
 552 static int lapic_suspend(struct sys_device *dev, pm_message_t state)
 553 {
 554         unsigned long flags;
 555         int maxlvt;
 556
 557         if (!apic_pm_state.active)
 558                 return 0;
 559
 560         maxlvt = get_maxlvt();
 561
 562         apic_pm_state.apic_id = apic_read(APIC_ID);
 563         apic_pm_state.apic_taskpri = apic_read(APIC_TASKPRI);
 564         apic_pm_state.apic_ldr = apic_read(APIC_LDR);
 565         apic_pm_state.apic_dfr = apic_read(APIC_DFR);
 566         apic_pm_state.apic_spiv = apic_read(APIC_SPIV);
 567         apic_pm_state.apic_lvtt = apic_read(APIC_LVTT);
 568         if (maxlvt >= 4)
 569                 apic_pm_state.apic_lvtpc = apic_read(APIC_LVTPC);
 570         apic_pm_state.apic_lvt0 = apic_read(APIC_LVT0);
 571         apic_pm_state.apic_lvt1 = apic_read(APIC_LVT1);
 572         apic_pm_state.apic_lvterr = apic_read(APIC_LVTERR);
 573         apic_pm_state.apic_tmict = apic_read(APIC_TMICT);
 574         apic_pm_state.apic_tdcr = apic_read(APIC_TDCR);
 575 #ifdef CONFIG_X86_MCE_INTEL
 576         if (maxlvt >= 5)
 577                 apic_pm_state.apic_thmr = apic_read(APIC_LVTTHMR);
 578 #endif
 579         local_irq_save(flags);
 580         disable_local_APIC();
 581         local_irq_restore(flags);
 582         return 0;
 583 }
 584
 585 static int lapic_resume(struct sys_device *dev)
 586 {
 587         unsigned int l, h;
 588         unsigned long flags;
 589         int maxlvt;
 590
 591         if (!apic_pm_state.active)
 592                 return 0;
 593
 594         maxlvt = get_maxlvt();
 595
 596         local_irq_save(flags);
 597         rdmsr(MSR_IA32_APICBASE, l, h);
 598         l &= ~MSR_IA32_APICBASE_BASE;
 599         l |= MSR_IA32_APICBASE_ENABLE | mp_lapic_addr;
 600         wrmsr(MSR_IA32_APICBASE, l, h);
 601         apic_write(APIC_LVTERR, ERROR_APIC_VECTOR | APIC_LVT_MASKED);
 602         apic_write(APIC_ID, apic_pm_state.apic_id);
 603         apic_write(APIC_DFR, apic_pm_state.apic_dfr);
 604         apic_write(APIC_LDR, apic_pm_state.apic_ldr);
 605         apic_write(APIC_TASKPRI, apic_pm_state.apic_taskpri);
 606         apic_write(APIC_SPIV, apic_pm_state.apic_spiv);
 607         apic_write(APIC_LVT0, apic_pm_state.apic_lvt0);
 608         apic_write(APIC_LVT1, apic_pm_state.apic_lvt1);
 609 #ifdef CONFIG_X86_MCE_INTEL
 610         if (maxlvt >= 5)
 611                 apic_write(APIC_LVTTHMR, apic_pm_state.apic_thmr);
 612 #endif
 613         if (maxlvt >= 4)
 614                 apic_write(APIC_LVTPC, apic_pm_state.apic_lvtpc);
 615         apic_write(APIC_LVTT, apic_pm_state.apic_lvtt);
 616         apic_write(APIC_TDCR, apic_pm_state.apic_tdcr);
 617         apic_write(APIC_TMICT, apic_pm_state.apic_tmict);
 618         apic_write(APIC_ESR, 0);
 619         apic_read(APIC_ESR);
 620         apic_write(APIC_LVTERR, apic_pm_state.apic_lvterr);
 621         apic_write(APIC_ESR, 0);
 622         apic_read(APIC_ESR);
 623         local_irq_restore(flags);
 624         return 0;
 625 }
 626
 627 static struct sysdev_class lapic_sysclass = {
 628         set_kset_name("lapic"),
 629         .resume         = lapic_resume,
 630         .suspend        = lapic_suspend,
 631 };
 632
 633 static struct sys_device device_lapic = {
 634         .id             = 0,
 635         .cls            = &lapic_sysclass,
 636 };
 637
 638 static void __cpuinit apic_pm_activate(void)
 639 {
 640         apic_pm_state.active = 1;
 641 }
 642
 643 static int __init init_lapic_sysfs(void)
 644 {
 645         int error;
 646         if (!cpu_has_apic)
 647                 return 0;
 648         /* XXX: remove suspend/resume procs if !apic_pm_state.active? */
 649         error = sysdev_class_register(&lapic_sysclass);
 650         if (!error)
 651                 error = sysdev_register(&device_lapic);
 652         return error;
 653 }
 654 device_initcall(init_lapic_sysfs);
 655
 656 #else   /* CONFIG_PM */
 657
 658 static void apic_pm_activate(void) { }
 659
 660 #endif  /* CONFIG_PM */
 661
 662 static int __init apic_set_verbosity(char *str)
 663 {
 664         if (str == NULL)  {
 665                 skip_ioapic_setup = 0;
 666                 ioapic_force = 1;
 667                 return 0;
 668         }
 669         if (strcmp("debug", str) == 0)
 670                 apic_verbosity = APIC_DEBUG;
 671         else if (strcmp("verbose", str) == 0)
 672                 apic_verbosity = APIC_VERBOSE;
 673         else {
 674                 printk(KERN_WARNING "APIC Verbosity level %s not recognised"
 675                                 " use apic=verbose or apic=debug\n", str);
 676                 return -EINVAL;
 677         }
 678
 679         return 0;
 680 }
 681 early_param("apic", apic_set_verbosity);
 682
 683 /*
 684  * Detect and enable local APICs on non-SMP boards.
 685  * Original code written by Keir Fraser.
 686  * On AMD64 we trust the BIOS - if it says no APIC it is likely
 687  * not correctly set up (usually the APIC timer won't work etc.)
 688  */
 689
 690 static int __init detect_init_APIC (void)
 691 {
 692         if (!cpu_has_apic) {
 693                 printk(KERN_INFO "No local APIC present\n");
 694                 return -1;
 695         }
 696
 697         mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
 698         boot_cpu_id = 0;
 699         return 0;
 700 }
 701
 702 #ifdef CONFIG_X86_IO_APIC
 703 static struct resource * __init ioapic_setup_resources(void)
 704 {
 705 #define IOAPIC_RESOURCE_NAME_SIZE 11
 706         unsigned long n;
 707         struct resource *res;
 708         char *mem;
 709         int i;
 710
 711         if (nr_ioapics <= 0)
 712                 return NULL;
 713
 714         n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource);
 715         n *= nr_ioapics;
 716
 717         mem = alloc_bootmem(n);
 718         res = (void *)mem;
 719
 720         if (mem != NULL) {
 721                 memset(mem, 0, n);
 722                 mem += sizeof(struct resource) * nr_ioapics;
 723
 724                 for (i = 0; i < nr_ioapics; i++) {
 725                         res[i].name = mem;
 726                         res[i].flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 727                         sprintf(mem,  "IOAPIC %u", i);
 728                         mem += IOAPIC_RESOURCE_NAME_SIZE;
 729                 }
 730         }
 731
 732         ioapic_resources = res;
 733
 734         return res;
 735 }
 736
 737 static int __init ioapic_insert_resources(void)
 738 {
 739         int i;
 740         struct resource *r = ioapic_resources;
 741
 742         if (!r) {
 743                 printk("IO APIC resources could be not be allocated.\n");
 744                 return -1;
 745         }
 746
 747         for (i = 0; i < nr_ioapics; i++) {
 748                 insert_resource(&iomem_resource, r);
 749                 r++;
 750         }
 751
 752         return 0;
 753 }
 754
 755 /* Insert the IO APIC resources after PCI initialization has occured to handle
 756  * IO APICS that are mapped in on a BAR in PCI space. */
 757 late_initcall(ioapic_insert_resources);
 758 #endif
 759
 760 void __init init_apic_mappings(void)
 761 {
 762         unsigned long apic_phys;
 763
 764         /*
 765          * If no local APIC can be found then set up a fake all
 766          * zeroes page to simulate the local APIC and another
 767          * one for the IO-APIC.
 768          */
 769         if (!smp_found_config && detect_init_APIC()) {
 770                 apic_phys = (unsigned long) alloc_bootmem_pages(PAGE_SIZE);
 771                 apic_phys = __pa(apic_phys);
 772         } else
 773                 apic_phys = mp_lapic_addr;
 774
 775         set_fixmap_nocache(FIX_APIC_BASE, apic_phys);
 776         apic_printk(APIC_VERBOSE, "mapped APIC to %16lx (%16lx)\n",
 777                                 APIC_BASE, apic_phys);
 778
 779         /* Put local APIC into the resource map. */
 780         lapic_resource.start = apic_phys;
 781         lapic_resource.end = lapic_resource.start + PAGE_SIZE - 1;
 782         insert_resource(&iomem_resource, &lapic_resource);
 783
 784         /*
 785          * Fetch the APIC ID of the BSP in case we have a
 786          * default configuration (or the MP table is broken).
 787          */
 788         boot_cpu_id = GET_APIC_ID(apic_read(APIC_ID));
 789
 790         {
 791                 unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
 792                 int i;
 793                 struct resource *ioapic_res;
 794
 795                 ioapic_res = ioapic_setup_resources();
 796                 for (i = 0; i < nr_ioapics; i++) {
 797                         if (smp_found_config) {
 798                                 ioapic_phys = mp_ioapics[i].mpc_apicaddr;
 799                         } else {
 800                                 ioapic_phys = (unsigned long)
 801                                         alloc_bootmem_pages(PAGE_SIZE);
 802                                 ioapic_phys = __pa(ioapic_phys);
 803                         }
 804                         set_fixmap_nocache(idx, ioapic_phys);
 805                         apic_printk(APIC_VERBOSE,
 806                                     "mapped IOAPIC to %016lx (%016lx)\n",
 807                                     __fix_to_virt(idx), ioapic_phys);
 808                         idx++;
 809
 810                         if (ioapic_res != NULL) {
 811                                 ioapic_res->start = ioapic_phys;
 812                                 ioapic_res->end = ioapic_phys + (4 * 1024) - 1;
 813                                 ioapic_res++;
 814                         }
 815                 }
 816         }
 817 }
 818
 819 /*
 820  * This function sets up the local APIC timer, with a timeout of
 821  * 'clocks' APIC bus clock. During calibration we actually call
 822  * this function twice on the boot CPU, once with a bogus timeout
 823  * value, second time for real. The other (noncalibrating) CPUs
 824  * call this function only once, with the real, calibrated value.
 825  *
 826  * We do reads before writes even if unnecessary, to get around the
 827  * P5 APIC double write bug.
 828  */
 829
 830 static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen)
 831 {
 832         unsigned int lvtt_value, tmp_value;
 833
 834         lvtt_value = LOCAL_TIMER_VECTOR;
 835         if (!oneshot)
 836                 lvtt_value |= APIC_LVT_TIMER_PERIODIC;
 837         if (!irqen)
 838                 lvtt_value |= APIC_LVT_MASKED;
 839
 840         apic_write(APIC_LVTT, lvtt_value);
 841
 842         /*
 843          * Divide PICLK by 16
 844          */
 845         tmp_value = apic_read(APIC_TDCR);
 846         apic_write(APIC_TDCR, (tmp_value
 847                                 & ~(APIC_TDR_DIV_1 | APIC_TDR_DIV_TMBASE))
 848                                 | APIC_TDR_DIV_16);
 849
 850         if (!oneshot)
 851                 apic_write(APIC_TMICT, clocks);
 852 }
 853
 854 static void setup_APIC_timer(void)
 855 {
 856         struct clock_event_device *levt = &__get_cpu_var(lapic_events);
 857
 858         memcpy(levt, &lapic_clockevent, sizeof(*levt));
 859         levt->cpumask = cpumask_of_cpu(smp_processor_id());
 860
 861         clockevents_register_device(levt);
 862 }
 863
 864 /*
 865  * In this function we calibrate APIC bus clocks to the external
 866  * timer. Unfortunately we cannot use jiffies and the timer irq
 867  * to calibrate, since some later bootup code depends on getting
 868  * the first irq? Ugh.
 869  *
 870  * We want to do the calibration only once since we
 871  * want to have local timer irqs syncron. CPUs connected
 872  * by the same APIC bus have the very same bus frequency.
 873  * And we want to have irqs off anyways, no accidental
 874  * APIC irq that way.
 875  */
 876
 877 #define TICK_COUNT 100000000
 878
 879 static void __init calibrate_APIC_clock(void)
 880 {
 881         unsigned apic, apic_start;
 882         unsigned long tsc, tsc_start;
 883         int result;
 884
 885         local_irq_disable();
 886
 887         /*
 888          * Put whatever arbitrary (but long enough) timeout
 889          * value into the APIC clock, we just want to get the
 890          * counter running for calibration.
 891          *
 892          * No interrupt enable !
 893          */
 894         __setup_APIC_LVTT(250000000, 0, 0);
 895
 896         apic_start = apic_read(APIC_TMCCT);
 897 #ifdef CONFIG_X86_PM_TIMER
 898         if (apic_calibrate_pmtmr && pmtmr_ioport) {
 899                 pmtimer_wait(5000);  /* 5ms wait */
 900                 apic = apic_read(APIC_TMCCT);
 901                 result = (apic_start - apic) * 1000L / 5;
 902         } else
 903 #endif
 904         {
 905                 rdtscll(tsc_start);
 906
 907                 do {
 908                         apic = apic_read(APIC_TMCCT);
 909                         rdtscll(tsc);
 910                 } while ((tsc - tsc_start) < TICK_COUNT &&
 911                                 (apic_start - apic) < TICK_COUNT);
 912
 913                 result = (apic_start - apic) * 1000L * tsc_khz /
 914                                         (tsc - tsc_start);
 915         }
 916
 917         local_irq_enable();
 918
 919         printk(KERN_DEBUG "APIC timer calibration result %d\n", result);
 920
 921         printk(KERN_INFO "Detected %d.%03d MHz APIC timer.\n",
 922                 result / 1000 / 1000, result / 1000 % 1000);
 923
 924         /* Calculate the scaled math multiplication factor */
 925         lapic_clockevent.mult = div_sc(result, NSEC_PER_SEC, 32);
 926         lapic_clockevent.max_delta_ns =
 927                 clockevent_delta2ns(0x7FFFFF, &lapic_clockevent);
 928         lapic_clockevent.min_delta_ns =
 929                 clockevent_delta2ns(0xF, &lapic_clockevent);
 930
 931         calibration_result = result / HZ;
 932 }
 933
 934 void __init setup_boot_APIC_clock (void)
 935 {
 936         /*
 937          * The local apic timer can be disabled via the kernel commandline.
 938          * Register the lapic timer as a dummy clock event source on SMP
 939          * systems, so the broadcast mechanism is used. On UP systems simply
 940          * ignore it.
 941          */
 942         if (disable_apic_timer) {
 943                 printk(KERN_INFO "Disabling APIC timer\n");
 944                 /* No broadcast on UP ! */
 945                 if (num_possible_cpus() > 1)
 946                         setup_APIC_timer();
 947                 return;
 948         }
 949
 950         printk(KERN_INFO "Using local APIC timer interrupts.\n");
 951         calibrate_APIC_clock();
 952
 953         /*
 954          * If nmi_watchdog is set to IO_APIC, we need the
 955          * PIT/HPET going.  Otherwise register lapic as a dummy
 956          * device.
 957          */
 958         if (nmi_watchdog != NMI_IO_APIC)
 959                 lapic_clockevent.features &= ~CLOCK_EVT_FEAT_DUMMY;
 960         else
 961                 printk(KERN_WARNING "APIC timer registered as dummy,"
 962                        " due to nmi_watchdog=1!\n");
 963
 964         setup_APIC_timer();
 965 }
 966
 967 /*
 968  * AMD C1E enabled CPUs have a real nasty problem: Some BIOSes set the
 969  * C1E flag only in the secondary CPU, so when we detect the wreckage
 970  * we already have enabled the boot CPU local apic timer. Check, if
 971  * disable_apic_timer is set and the DUMMY flag is cleared. If yes,
 972  * set the DUMMY flag again and force the broadcast mode in the
 973  * clockevents layer.
 974  */
 975 void __cpuinit check_boot_apic_timer_broadcast(void)
 976 {
 977         struct clock_event_device *levt = &per_cpu(lapic_events, boot_cpu_id);
 978
 979         if (!disable_apic_timer ||
 980             (lapic_clockevent.features & CLOCK_EVT_FEAT_DUMMY))
 981                 return;
 982
 983         printk(KERN_INFO "AMD C1E detected late. Force timer broadcast.\n");
 984         lapic_clockevent.features |= CLOCK_EVT_FEAT_DUMMY;
 985         levt->features |= CLOCK_EVT_FEAT_DUMMY;
 986
 987         local_irq_enable();
 988         clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_FORCE, &boot_cpu_id);
 989         local_irq_disable();
 990 }
 991
 992 void __cpuinit setup_secondary_APIC_clock(void)
 993 {
 994         check_boot_apic_timer_broadcast();
 995         setup_APIC_timer();
 996 }
 997
 998 int setup_profiling_timer(unsigned int multiplier)
 999 {
1000         return -EINVAL;
1001 }
1002
1003 void setup_APIC_extended_lvt(unsigned char lvt_off, unsigned char vector,
1004                              unsigned char msg_type, unsigned char mask)
1005 {
1006         unsigned long reg = (lvt_off << 4) + K8_APIC_EXT_LVT_BASE;
1007         unsigned int  v   = (mask << 16) | (msg_type << 8) | vector;
1008         apic_write(reg, v);
1009 }
1010
1011 /*
1012  * Local timer interrupt handler. It does both profiling and
1013  * process statistics/rescheduling.
1014  *
1015  * We do profiling in every local tick, statistics/rescheduling
1016  * happen only every 'profiling multiplier' ticks. The default
1017  * multiplier is 1 and it can be changed by writing the new multiplier
1018  * value into /proc/profile.
1019  */
1020
1021 void smp_local_timer_interrupt(void)
1022 {
1023         int cpu = smp_processor_id();
1024         struct clock_event_device *evt = &per_cpu(lapic_events, cpu);
1025
1026         /*
1027          * Normally we should not be here till LAPIC has been initialized but
1028          * in some cases like kdump, its possible that there is a pending LAPIC
1029          * timer interrupt from previous kernel's context and is delivered in
1030          * new kernel the moment interrupts are enabled.
1031          *
1032          * Interrupts are enabled early and LAPIC is setup much later, hence
1033          * its possible that when we get here evt->event_handler is NULL.
1034          * Check for event_handler being NULL and discard the interrupt as
1035          * spurious.
1036          */
1037         if (!evt->event_handler) {
1038                 printk(KERN_WARNING
1039                        "Spurious LAPIC timer interrupt on cpu %d\n", cpu);
1040                 /* Switch it off */
1041                 lapic_timer_setup(CLOCK_EVT_MODE_SHUTDOWN, evt);
1042                 return;
1043         }
1044
1045         /*
1046          * the NMI deadlock-detector uses this.
1047          */
1048         add_pda(apic_timer_irqs, 1);
1049
1050         evt->event_handler(evt);
1051 }
1052
1053 /*
1054  * Local APIC timer interrupt. This is the most natural way for doing
1055  * local interrupts, but local timer interrupts can be emulated by
1056  * broadcast interrupts too. [in case the hw doesn't support APIC timers]
1057  *
1058  * [ if a single-CPU system runs an SMP kernel then we call the local
1059  *   interrupt as well. Thus we cannot inline the local irq ... ]
1060  */
1061 void smp_apic_timer_interrupt(struct pt_regs *regs)
1062 {
1063         struct pt_regs *old_regs = set_irq_regs(regs);
1064
1065         /*
1066          * NOTE! We'd better ACK the irq immediately,
1067          * because timer handling can be slow.
1068          */
1069         ack_APIC_irq();
1070         /*
1071          * update_process_times() expects us to have done irq_enter().
1072          * Besides, if we don't timer interrupts ignore the global
1073          * interrupt lock, which is the WrongThing (tm) to do.
1074          */
1075         exit_idle();
1076         irq_enter();
1077         smp_local_timer_interrupt();
1078         irq_exit();
1079         set_irq_regs(old_regs);
1080 }
1081
1082 /*
1083  * apic_is_clustered_box() -- Check if we can expect good TSC
1084  *
1085  * Thus far, the major user of this is IBM's Summit2 series:
1086  *
1087  * Clustered boxes may have unsynced TSC problems if they are
1088  * multi-chassis. Use available data to take a good guess.
1089  * If in doubt, go HPET.
1090  */
1091 __cpuinit int apic_is_clustered_box(void)
1092 {
1093         int i, clusters, zeros;
1094         unsigned id;
1095         DECLARE_BITMAP(clustermap, NUM_APIC_CLUSTERS);
1096
1097         bitmap_zero(clustermap, NUM_APIC_CLUSTERS);
1098
1099         for (i = 0; i < NR_CPUS; i++) {
1100                 id = bios_cpu_apicid[i];
1101                 if (id != BAD_APICID)
1102                         __set_bit(APIC_CLUSTERID(id), clustermap);
1103         }
1104
1105         /* Problem:  Partially populated chassis may not have CPUs in some of
1106          * the APIC clusters they have been allocated.  Only present CPUs have
1107          * bios_cpu_apicid entries, thus causing zeroes in the bitmap.  Since
1108          * clusters are allocated sequentially, count zeros only if they are
1109          * bounded by ones.
1110          */
1111         clusters = 0;
1112         zeros = 0;
1113         for (i = 0; i < NUM_APIC_CLUSTERS; i++) {
1114                 if (test_bit(i, clustermap)) {
1115                         clusters += 1 + zeros;
1116                         zeros = 0;
1117                 } else
1118                         ++zeros;
1119         }
1120
1121         /*
1122          * If clusters > 2, then should be multi-chassis.
1123          * May have to revisit this when multi-core + hyperthreaded CPUs come
1124          * out, but AFAIK this will work even for them.
1125          */
1126         return (clusters > 2);
1127 }
1128
1129 /*
1130  * This interrupt should _never_ happen with our APIC/SMP architecture
1131  */
1132 asmlinkage void smp_spurious_interrupt(void)
1133 {
1134         unsigned int v;
1135         exit_idle();
1136         irq_enter();
1137         /*
1138          * Check if this really is a spurious interrupt and ACK it
1139          * if it is a vectored one.  Just in case...
1140          * Spurious interrupts should not be ACKed.
1141          */
1142         v = apic_read(APIC_ISR + ((SPURIOUS_APIC_VECTOR & ~0x1f) >> 1));
1143         if (v & (1 << (SPURIOUS_APIC_VECTOR & 0x1f)))
1144                 ack_APIC_irq();
1145
1146         irq_exit();
1147 }
1148
1149 /*
1150  * This interrupt should never happen with our APIC/SMP architecture
1151  */
1152
1153 asmlinkage void smp_error_interrupt(void)
1154 {
1155         unsigned int v, v1;
1156
1157         exit_idle();
1158         irq_enter();
1159         /* First tickle the hardware, only then report what went on. -- REW */
1160         v = apic_read(APIC_ESR);
1161         apic_write(APIC_ESR, 0);
1162         v1 = apic_read(APIC_ESR);
1163         ack_APIC_irq();
1164         atomic_inc(&irq_err_count);
1165
1166         /* Here is what the APIC error bits mean:
1167            0: Send CS error
1168            1: Receive CS error
1169            2: Send accept error
1170            3: Receive accept error
1171            4: Reserved
1172            5: Send illegal vector
1173            6: Received illegal vector
1174            7: Illegal register address
1175         */
1176         printk (KERN_DEBUG "APIC error on CPU%d: %02x(%02x)\n",
1177                 smp_processor_id(), v , v1);
1178         irq_exit();
1179 }
1180
1181 int disable_apic;
1182
1183 /*
1184  * This initializes the IO-APIC and APIC hardware if this is
1185  * a UP kernel.
1186  */
1187 int __init APIC_init_uniprocessor (void)
1188 {
1189         if (disable_apic) {
1190                 printk(KERN_INFO "Apic disabled\n");
1191                 return -1;
1192         }
1193         if (!cpu_has_apic) {
1194                 disable_apic = 1;
1195                 printk(KERN_INFO "Apic disabled by BIOS\n");
1196                 return -1;
1197         }
1198
1199         verify_local_APIC();
1200
1201         phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
1202         apic_write(APIC_ID, SET_APIC_ID(boot_cpu_id));
1203
1204         setup_local_APIC();
1205
1206         if (smp_found_config && !skip_ioapic_setup && nr_ioapics)
1207                 setup_IO_APIC();
1208         else
1209                 nr_ioapics = 0;
1210         setup_boot_APIC_clock();
1211         check_nmi_watchdog();
1212         return 0;
1213 }
1214
1215 static __init int setup_disableapic(char *str)
1216 {
1217         disable_apic = 1;
1218         clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
1219         return 0;
1220 }
1221 early_param("disableapic", setup_disableapic);
1222
1223 /* same as disableapic, for compatibility */
1224 static __init int setup_nolapic(char *str)
1225 {
1226         return setup_disableapic(str);
1227 }
1228 early_param("nolapic", setup_nolapic);
1229
1230 static int __init parse_lapic_timer_c2_ok(char *arg)
1231 {
1232         local_apic_timer_c2_ok = 1;
1233         return 0;
1234 }
1235 early_param("lapic_timer_c2_ok", parse_lapic_timer_c2_ok);
1236
1237 static __init int setup_noapictimer(char *str)
1238 {
1239         if (str[0] != ' ' && str[0] != 0)
1240                 return 0;
1241         disable_apic_timer = 1;
1242         return 1;
1243 }
1244 __setup("noapictimer", setup_noapictimer);
1245
1246 static __init int setup_apicpmtimer(char *s)
1247 {
1248         apic_calibrate_pmtmr = 1;
1249         notsc_setup(NULL);
1250         return 0;
1251 }
1252 __setup("apicpmtimer", setup_apicpmtimer);
1253