arch/x86_64/kernel/smpboot.c

   1 /*
   2  *      x86 SMP booting functions
   3  *
   4  *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
   5  *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
   6  *      Copyright 2001 Andi Kleen, SuSE Labs.
   7  *
   8  *      Much of the core SMP work is based on previous work by Thomas Radke, to
   9  *      whom a great many thanks are extended.
  10  *
  11  *      Thanks to Intel for making available several different Pentium,
  12  *      Pentium Pro and Pentium-II/Xeon MP machines.
  13  *      Original development of Linux SMP code supported by Caldera.
  14  *
  15  *      This code is released under the GNU General Public License version 2
  16  *
  17  *      Fixes
  18  *              Felix Koop      :       NR_CPUS used properly
  19  *              Jose Renau      :       Handle single CPU case.
  20  *              Alan Cox        :       By repeated request 8) - Total BogoMIP report.
  21  *              Greg Wright     :       Fix for kernel stacks panic.
  22  *              Erich Boleyn    :       MP v1.4 and additional changes.
  23  *      Matthias Sattler        :       Changes for 2.1 kernel map.
  24  *      Michel Lespinasse       :       Changes for 2.1 kernel map.
  25  *      Michael Chastain        :       Change trampoline.S to gnu as.
  26  *              Alan Cox        :       Dumb bug: 'B' step PPro's are fine
  27  *              Ingo Molnar     :       Added APIC timers, based on code
  28  *                                      from Jose Renau
  29  *              Ingo Molnar     :       various cleanups and rewrites
  30  *              Tigran Aivazian :       fixed "0.00 in /proc/uptime on SMP" bug.
  31  *      Maciej W. Rozycki       :       Bits for genuine 82489DX APICs
  32  *      Andi Kleen              :       Changed for SMP boot into long mode.
  33  *              Rusty Russell   :       Hacked into shape for new "hotplug" boot process.
  34  *      Andi Kleen              :       Converted to new state machine.
  35  *                                      Various cleanups.
  36  *                                      Probably mostly hotplug CPU ready now.
  37  */
  38
  39
  40 #include <linux/config.h>
  41 #include <linux/init.h>
  42
  43 #include <linux/mm.h>
  44 #include <linux/kernel_stat.h>
  45 #include <linux/smp_lock.h>
  46 #include <linux/irq.h>
  47 #include <linux/bootmem.h>
  48 #include <linux/thread_info.h>
  49 #include <linux/module.h>
  50
  51 #include <linux/delay.h>
  52 #include <linux/mc146818rtc.h>
  53 #include <asm/mtrr.h>
  54 #include <asm/pgalloc.h>
  55 #include <asm/desc.h>
  56 #include <asm/kdebug.h>
  57 #include <asm/tlbflush.h>
  58 #include <asm/proto.h>
  59 #include <asm/nmi.h>
  60
  61 /* Change for real CPU hotplug. Note other files need to be fixed
  62    first too. */
  63 #define __cpuinit __init
  64 #define __cpuinitdata __initdata
  65
  66 /* Number of siblings per CPU package */
  67 int smp_num_siblings = 1;
  68 /* Package ID of each logical CPU */
  69 u8 phys_proc_id[NR_CPUS] = { [0 ... NR_CPUS-1] = BAD_APICID };
  70 u8 cpu_core_id[NR_CPUS] = { [0 ... NR_CPUS-1] = BAD_APICID };
  71 EXPORT_SYMBOL(phys_proc_id);
  72 EXPORT_SYMBOL(cpu_core_id);
  73
  74 /* Bitmask of currently online CPUs */
  75 cpumask_t cpu_online_map;
  76
  77 EXPORT_SYMBOL(cpu_online_map);
  78
  79 /*
  80  * Private maps to synchronize booting between AP and BP.
  81  * Probably not needed anymore, but it makes for easier debugging. -AK
  82  */
  83 cpumask_t cpu_callin_map;
  84 cpumask_t cpu_callout_map;
  85
  86 cpumask_t cpu_possible_map;
  87 EXPORT_SYMBOL(cpu_possible_map);
  88
  89 /* Per CPU bogomips and other parameters */
  90 struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
  91
  92 /* Set when the idlers are all forked */
  93 int smp_threads_ready;
  94
  95 cpumask_t cpu_sibling_map[NR_CPUS] __cacheline_aligned;
  96 cpumask_t cpu_core_map[NR_CPUS] __cacheline_aligned;
  97
  98 /*
  99  * Trampoline 80x86 program as an array.
 100  */
 101
 102 extern unsigned char trampoline_data[];
 103 extern unsigned char trampoline_end[];
 104
 105 /*
 106  * Currently trivial. Write the real->protected mode
 107  * bootstrap into the page concerned. The caller
 108  * has made sure it's suitably aligned.
 109  */
 110
 111 static unsigned long __cpuinit setup_trampoline(void)
 112 {
 113         void *tramp = __va(SMP_TRAMPOLINE_BASE);
 114         memcpy(tramp, trampoline_data, trampoline_end - trampoline_data);
 115         return virt_to_phys(tramp);
 116 }
 117
 118 /*
 119  * The bootstrap kernel entry code has set these up. Save them for
 120  * a given CPU
 121  */
 122
 123 static void __cpuinit smp_store_cpu_info(int id)
 124 {
 125         struct cpuinfo_x86 *c = cpu_data + id;
 126
 127         *c = boot_cpu_data;
 128         identify_cpu(c);
 129         print_cpu_info(c);
 130 }
 131
 132 /*
 133  * New Funky TSC sync algorithm borrowed from IA64.
 134  * Main advantage is that it doesn't reset the TSCs fully and
 135  * in general looks more robust and it works better than my earlier
 136  * attempts. I believe it was written by David Mosberger. Some minor
 137  * adjustments for x86-64 by me -AK
 138  *
 139  * Original comment reproduced below.
 140  *
 141  * Synchronize TSC of the current (slave) CPU with the TSC of the
 142  * MASTER CPU (normally the time-keeper CPU).  We use a closed loop to
 143  * eliminate the possibility of unaccounted-for errors (such as
 144  * getting a machine check in the middle of a calibration step).  The
 145  * basic idea is for the slave to ask the master what itc value it has
 146  * and to read its own itc before and after the master responds.  Each
 147  * iteration gives us three timestamps:
 148  *
 149  *      slave           master
 150  *
 151  *      t0 ---\
 152  *             ---\
 153  *                 --->
 154  *                      tm
 155  *                 /---
 156  *             /---
 157  *      t1 <---
 158  *
 159  *
 160  * The goal is to adjust the slave's TSC such that tm falls exactly
 161  * half-way between t0 and t1.  If we achieve this, the clocks are
 162  * synchronized provided the interconnect between the slave and the
 163  * master is symmetric.  Even if the interconnect were asymmetric, we
 164  * would still know that the synchronization error is smaller than the
 165  * roundtrip latency (t0 - t1).
 166  *
 167  * When the interconnect is quiet and symmetric, this lets us
 168  * synchronize the TSC to within one or two cycles.  However, we can
 169  * only *guarantee* that the synchronization is accurate to within a
 170  * round-trip time, which is typically in the range of several hundred
 171  * cycles (e.g., ~500 cycles).  In practice, this means that the TSCs
 172  * are usually almost perfectly synchronized, but we shouldn't assume
 173  * that the accuracy is much better than half a micro second or so.
 174  *
 175  * [there are other errors like the latency of RDTSC and of the
 176  * WRMSR. These can also account to hundreds of cycles. So it's
 177  * probably worse. It claims 153 cycles error on a dual Opteron,
 178  * but I suspect the numbers are actually somewhat worse -AK]
 179  */
 180
 181 #define MASTER  0
 182 #define SLAVE   (SMP_CACHE_BYTES/8)
 183
 184 /* Intentionally don't use cpu_relax() while TSC synchronization
 185    because we don't want to go into funky power save modi or cause
 186    hypervisors to schedule us away.  Going to sleep would likely affect
 187    latency and low latency is the primary objective here. -AK */
 188 #define no_cpu_relax() barrier()
 189
 190 static __cpuinitdata DEFINE_SPINLOCK(tsc_sync_lock);
 191 static volatile __cpuinitdata unsigned long go[SLAVE + 1];
 192 static int notscsync __cpuinitdata;
 193
 194 #undef DEBUG_TSC_SYNC
 195
 196 #define NUM_ROUNDS      64      /* magic value */
 197 #define NUM_ITERS       5       /* likewise */
 198
 199 /* Callback on boot CPU */
 200 static __cpuinit void sync_master(void *arg)
 201 {
 202         unsigned long flags, i;
 203
 204         if (smp_processor_id() != boot_cpu_id)
 205                 return;
 206
 207         go[MASTER] = 0;
 208
 209         local_irq_save(flags);
 210         {
 211                 for (i = 0; i < NUM_ROUNDS*NUM_ITERS; ++i) {
 212                         while (!go[MASTER])
 213                                 no_cpu_relax();
 214                         go[MASTER] = 0;
 215                         rdtscll(go[SLAVE]);
 216                 }
 217         }
 218         local_irq_restore(flags);
 219 }
 220
 221 /*
 222  * Return the number of cycles by which our tsc differs from the tsc
 223  * on the master (time-keeper) CPU.  A positive number indicates our
 224  * tsc is ahead of the master, negative that it is behind.
 225  */
 226 static inline long
 227 get_delta(long *rt, long *master)
 228 {
 229         unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
 230         unsigned long tcenter, t0, t1, tm;
 231         int i;
 232
 233         for (i = 0; i < NUM_ITERS; ++i) {
 234                 rdtscll(t0);
 235                 go[MASTER] = 1;
 236                 while (!(tm = go[SLAVE]))
 237                         no_cpu_relax();
 238                 go[SLAVE] = 0;
 239                 rdtscll(t1);
 240
 241                 if (t1 - t0 < best_t1 - best_t0)
 242                         best_t0 = t0, best_t1 = t1, best_tm = tm;
 243         }
 244
 245         *rt = best_t1 - best_t0;
 246         *master = best_tm - best_t0;
 247
 248         /* average best_t0 and best_t1 without overflow: */
 249         tcenter = (best_t0/2 + best_t1/2);
 250         if (best_t0 % 2 + best_t1 % 2 == 2)
 251                 ++tcenter;
 252         return tcenter - best_tm;
 253 }
 254
 255 static __cpuinit void sync_tsc(void)
 256 {
 257         int i, done = 0;
 258         long delta, adj, adjust_latency = 0;
 259         unsigned long flags, rt, master_time_stamp, bound;
 260 #if DEBUG_TSC_SYNC
 261         static struct syncdebug {
 262                 long rt;        /* roundtrip time */
 263                 long master;    /* master's timestamp */
 264                 long diff;      /* difference between midpoint and master's timestamp */
 265                 long lat;       /* estimate of tsc adjustment latency */
 266         } t[NUM_ROUNDS] __cpuinitdata;
 267 #endif
 268
 269         go[MASTER] = 1;
 270
 271         smp_call_function(sync_master, NULL, 1, 0);
 272
 273         while (go[MASTER])      /* wait for master to be ready */
 274                 no_cpu_relax();
 275
 276         spin_lock_irqsave(&tsc_sync_lock, flags);
 277         {
 278                 for (i = 0; i < NUM_ROUNDS; ++i) {
 279                         delta = get_delta(&rt, &master_time_stamp);
 280                         if (delta == 0) {
 281                                 done = 1;       /* let's lock on to this... */
 282                                 bound = rt;
 283                         }
 284
 285                         if (!done) {
 286                                 unsigned long t;
 287                                 if (i > 0) {
 288                                         adjust_latency += -delta;
 289                                         adj = -delta + adjust_latency/4;
 290                                 } else
 291                                         adj = -delta;
 292
 293                                 rdtscll(t);
 294                                 wrmsrl(MSR_IA32_TSC, t + adj);
 295                         }
 296 #if DEBUG_TSC_SYNC
 297                         t[i].rt = rt;
 298                         t[i].master = master_time_stamp;
 299                         t[i].diff = delta;
 300                         t[i].lat = adjust_latency/4;
 301 #endif
 302                 }
 303         }
 304         spin_unlock_irqrestore(&tsc_sync_lock, flags);
 305
 306 #if DEBUG_TSC_SYNC
 307         for (i = 0; i < NUM_ROUNDS; ++i)
 308                 printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
 309                        t[i].rt, t[i].master, t[i].diff, t[i].lat);
 310 #endif
 311
 312         printk(KERN_INFO
 313                "CPU %d: synchronized TSC with CPU %u (last diff %ld cycles, "
 314                "maxerr %lu cycles)\n",
 315                smp_processor_id(), boot_cpu_id, delta, rt);
 316 }
 317
 318 static void __cpuinit tsc_sync_wait(void)
 319 {
 320         if (notscsync || !cpu_has_tsc)
 321                 return;
 322         printk(KERN_INFO "CPU %d: Syncing TSC to CPU %u.\n", smp_processor_id(),
 323                         boot_cpu_id);
 324         sync_tsc();
 325 }
 326
 327 static __init int notscsync_setup(char *s)
 328 {
 329         notscsync = 1;
 330         return 0;
 331 }
 332 __setup("notscsync", notscsync_setup);
 333
 334 static atomic_t init_deasserted __cpuinitdata;
 335
 336 /*
 337  * Report back to the Boot Processor.
 338  * Running on AP.
 339  */
 340 void __cpuinit smp_callin(void)
 341 {
 342         int cpuid, phys_id;
 343         unsigned long timeout;
 344
 345         /*
 346          * If waken up by an INIT in an 82489DX configuration
 347          * we may get here before an INIT-deassert IPI reaches
 348          * our local APIC.  We have to wait for the IPI or we'll
 349          * lock up on an APIC access.
 350          */
 351         while (!atomic_read(&init_deasserted))
 352                 cpu_relax();
 353
 354         /*
 355          * (This works even if the APIC is not enabled.)
 356          */
 357         phys_id = GET_APIC_ID(apic_read(APIC_ID));
 358         cpuid = smp_processor_id();
 359         if (cpu_isset(cpuid, cpu_callin_map)) {
 360                 panic("smp_callin: phys CPU#%d, CPU#%d already present??\n",
 361                                         phys_id, cpuid);
 362         }
 363         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
 364
 365         /*
 366          * STARTUP IPIs are fragile beasts as they might sometimes
 367          * trigger some glue motherboard logic. Complete APIC bus
 368          * silence for 1 second, this overestimates the time the
 369          * boot CPU is spending to send the up to 2 STARTUP IPIs
 370          * by a factor of two. This should be enough.
 371          */
 372
 373         /*
 374          * Waiting 2s total for startup (udelay is not yet working)
 375          */
 376         timeout = jiffies + 2*HZ;
 377         while (time_before(jiffies, timeout)) {
 378                 /*
 379                  * Has the boot CPU finished it's STARTUP sequence?
 380                  */
 381                 if (cpu_isset(cpuid, cpu_callout_map))
 382                         break;
 383                 cpu_relax();
 384         }
 385
 386         if (!time_before(jiffies, timeout)) {
 387                 panic("smp_callin: CPU%d started up but did not get a callout!\n",
 388                         cpuid);
 389         }
 390
 391         /*
 392          * the boot CPU has finished the init stage and is spinning
 393          * on callin_map until we finish. We are free to set up this
 394          * CPU, first the APIC. (this is probably redundant on most
 395          * boards)
 396          */
 397
 398         Dprintk("CALLIN, before setup_local_APIC().\n");
 399         setup_local_APIC();
 400
 401         /*
 402          * Get our bogomips.
 403          */
 404         calibrate_delay();
 405         Dprintk("Stack at about %p\n",&cpuid);
 406
 407         disable_APIC_timer();
 408
 409         /*
 410          * Save our processor parameters
 411          */
 412         smp_store_cpu_info(cpuid);
 413
 414         /*
 415          * Allow the master to continue.
 416          */
 417         cpu_set(cpuid, cpu_callin_map);
 418 }
 419
 420 /*
 421  * Setup code on secondary processor (after comming out of the trampoline)
 422  */
 423 void __cpuinit start_secondary(void)
 424 {
 425         /*
 426          * Dont put anything before smp_callin(), SMP
 427          * booting is too fragile that we want to limit the
 428          * things done here to the most necessary things.
 429          */
 430         cpu_init();
 431         smp_callin();
 432
 433         /* otherwise gcc will move up the smp_processor_id before the cpu_init */
 434         barrier();
 435
 436         Dprintk("cpu %d: setting up apic clock\n", smp_processor_id());
 437         setup_secondary_APIC_clock();
 438
 439         Dprintk("cpu %d: enabling apic timer\n", smp_processor_id());
 440
 441         if (nmi_watchdog == NMI_IO_APIC) {
 442                 disable_8259A_irq(0);
 443                 enable_NMI_through_LVT0(NULL);
 444                 enable_8259A_irq(0);
 445         }
 446
 447         enable_APIC_timer();
 448
 449         /*
 450          * Allow the master to continue.
 451          */
 452         cpu_set(smp_processor_id(), cpu_online_map);
 453         mb();
 454
 455         /* Wait for TSC sync to not schedule things before.
 456            We still process interrupts, which could see an inconsistent
 457            time in that window unfortunately. */
 458         tsc_sync_wait();
 459
 460         cpu_idle();
 461 }
 462
 463 extern volatile unsigned long init_rsp;
 464 extern void (*initial_code)(void);
 465
 466 #if APIC_DEBUG
 467 static void inquire_remote_apic(int apicid)
 468 {
 469         unsigned i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
 470         char *names[] = { "ID", "VERSION", "SPIV" };
 471         int timeout, status;
 472
 473         printk(KERN_INFO "Inquiring remote APIC #%d...\n", apicid);
 474
 475         for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
 476                 printk("... APIC #%d %s: ", apicid, names[i]);
 477
 478                 /*
 479                  * Wait for idle.
 480                  */
 481                 apic_wait_icr_idle();
 482
 483                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
 484                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
 485
 486                 timeout = 0;
 487                 do {
 488                         udelay(100);
 489                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
 490                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
 491
 492                 switch (status) {
 493                 case APIC_ICR_RR_VALID:
 494                         status = apic_read(APIC_RRR);
 495                         printk("%08x\n", status);
 496                         break;
 497                 default:
 498                         printk("failed\n");
 499                 }
 500         }
 501 }
 502 #endif
 503
 504 /*
 505  * Kick the secondary to wake up.
 506  */
 507 static int __cpuinit wakeup_secondary_via_INIT(int phys_apicid, unsigned int start_rip)
 508 {
 509         unsigned long send_status = 0, accept_status = 0;
 510         int maxlvt, timeout, num_starts, j;
 511
 512         Dprintk("Asserting INIT.\n");
 513
 514         /*
 515          * Turn INIT on target chip
 516          */
 517         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 518
 519         /*
 520          * Send IPI
 521          */
 522         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
 523                                 | APIC_DM_INIT);
 524
 525         Dprintk("Waiting for send to finish...\n");
 526         timeout = 0;
 527         do {
 528                 Dprintk("+");
 529                 udelay(100);
 530                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 531         } while (send_status && (timeout++ < 1000));
 532
 533         mdelay(10);
 534
 535         Dprintk("Deasserting INIT.\n");
 536
 537         /* Target chip */
 538         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 539
 540         /* Send IPI */
 541         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
 542
 543         Dprintk("Waiting for send to finish...\n");
 544         timeout = 0;
 545         do {
 546                 Dprintk("+");
 547                 udelay(100);
 548                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 549         } while (send_status && (timeout++ < 1000));
 550
 551         atomic_set(&init_deasserted, 1);
 552
 553         /*
 554          * Should we send STARTUP IPIs ?
 555          *
 556          * Determine this based on the APIC version.
 557          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
 558          */
 559         if (APIC_INTEGRATED(apic_version[phys_apicid]))
 560                 num_starts = 2;
 561         else
 562                 num_starts = 0;
 563
 564         /*
 565          * Run STARTUP IPI loop.
 566          */
 567         Dprintk("#startup loops: %d.\n", num_starts);
 568
 569         maxlvt = get_maxlvt();
 570
 571         for (j = 1; j <= num_starts; j++) {
 572                 Dprintk("Sending STARTUP #%d.\n",j);
 573                 apic_read_around(APIC_SPIV);
 574                 apic_write(APIC_ESR, 0);
 575                 apic_read(APIC_ESR);
 576                 Dprintk("After apic_write.\n");
 577
 578                 /*
 579                  * STARTUP IPI
 580                  */
 581
 582                 /* Target chip */
 583                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 584
 585                 /* Boot on the stack */
 586                 /* Kick the second */
 587                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
 588                                         | (start_rip >> 12));
 589
 590                 /*
 591                  * Give the other CPU some time to accept the IPI.
 592                  */
 593                 udelay(300);
 594
 595                 Dprintk("Startup point 1.\n");
 596
 597                 Dprintk("Waiting for send to finish...\n");
 598                 timeout = 0;
 599                 do {
 600                         Dprintk("+");
 601                         udelay(100);
 602                         send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 603                 } while (send_status && (timeout++ < 1000));
 604
 605                 /*
 606                  * Give the other CPU some time to accept the IPI.
 607                  */
 608                 udelay(200);
 609                 /*
 610                  * Due to the Pentium erratum 3AP.
 611                  */
 612                 if (maxlvt > 3) {
 613                         apic_read_around(APIC_SPIV);
 614                         apic_write(APIC_ESR, 0);
 615                 }
 616                 accept_status = (apic_read(APIC_ESR) & 0xEF);
 617                 if (send_status || accept_status)
 618                         break;
 619         }
 620         Dprintk("After Startup.\n");
 621
 622         if (send_status)
 623                 printk(KERN_ERR "APIC never delivered???\n");
 624         if (accept_status)
 625                 printk(KERN_ERR "APIC delivery error (%lx).\n", accept_status);
 626
 627         return (send_status | accept_status);
 628 }
 629
 630 /*
 631  * Boot one CPU.
 632  */
 633 static int __cpuinit do_boot_cpu(int cpu, int apicid)
 634 {
 635         struct task_struct *idle;
 636         unsigned long boot_error;
 637         int timeout;
 638         unsigned long start_rip;
 639         /*
 640          * We can't use kernel_thread since we must avoid to
 641          * reschedule the child.
 642          */
 643         idle = fork_idle(cpu);
 644         if (IS_ERR(idle)) {
 645                 printk("failed fork for CPU %d\n", cpu);
 646                 return PTR_ERR(idle);
 647         }
 648
 649         cpu_pda[cpu].pcurrent = idle;
 650
 651         start_rip = setup_trampoline();
 652
 653         init_rsp = idle->thread.rsp;
 654         per_cpu(init_tss,cpu).rsp0 = init_rsp;
 655         initial_code = start_secondary;
 656         clear_ti_thread_flag(idle->thread_info, TIF_FORK);
 657
 658         printk(KERN_INFO "Booting processor %d/%d rip %lx rsp %lx\n", cpu, apicid,
 659                start_rip, init_rsp);
 660
 661         /*
 662          * This grunge runs the startup process for
 663          * the targeted processor.
 664          */
 665
 666         atomic_set(&init_deasserted, 0);
 667
 668         Dprintk("Setting warm reset code and vector.\n");
 669
 670         CMOS_WRITE(0xa, 0xf);
 671         local_flush_tlb();
 672         Dprintk("1.\n");
 673         *((volatile unsigned short *) phys_to_virt(0x469)) = start_rip >> 4;
 674         Dprintk("2.\n");
 675         *((volatile unsigned short *) phys_to_virt(0x467)) = start_rip & 0xf;
 676         Dprintk("3.\n");
 677
 678         /*
 679          * Be paranoid about clearing APIC errors.
 680          */
 681         if (APIC_INTEGRATED(apic_version[apicid])) {
 682                 apic_read_around(APIC_SPIV);
 683                 apic_write(APIC_ESR, 0);
 684                 apic_read(APIC_ESR);
 685         }
 686
 687         /*
 688          * Status is now clean
 689          */
 690         boot_error = 0;
 691
 692         /*
 693          * Starting actual IPI sequence...
 694          */
 695         boot_error = wakeup_secondary_via_INIT(apicid, start_rip);
 696
 697         if (!boot_error) {
 698                 /*
 699                  * allow APs to start initializing.
 700                  */
 701                 Dprintk("Before Callout %d.\n", cpu);
 702                 cpu_set(cpu, cpu_callout_map);
 703                 Dprintk("After Callout %d.\n", cpu);
 704
 705                 /*
 706                  * Wait 5s total for a response
 707                  */
 708                 for (timeout = 0; timeout < 50000; timeout++) {
 709                         if (cpu_isset(cpu, cpu_callin_map))
 710                                 break;  /* It has booted */
 711                         udelay(100);
 712                 }
 713
 714                 if (cpu_isset(cpu, cpu_callin_map)) {
 715                         /* number CPUs logically, starting from 1 (BSP is 0) */
 716                         Dprintk("CPU has booted.\n");
 717                 } else {
 718                         boot_error = 1;
 719                         if (*((volatile unsigned char *)phys_to_virt(SMP_TRAMPOLINE_BASE))
 720                                         == 0xA5)
 721                                 /* trampoline started but...? */
 722                                 printk("Stuck ??\n");
 723                         else
 724                                 /* trampoline code not run */
 725                                 printk("Not responding.\n");
 726 #if APIC_DEBUG
 727                         inquire_remote_apic(apicid);
 728 #endif
 729                 }
 730         }
 731         if (boot_error) {
 732                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
 733                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
 734                 cpu_clear(cpu, cpu_present_map);
 735                 cpu_clear(cpu, cpu_possible_map);
 736                 x86_cpu_to_apicid[cpu] = BAD_APICID;
 737                 x86_cpu_to_log_apicid[cpu] = BAD_APICID;
 738                 return -EIO;
 739         }
 740
 741         return 0;
 742 }
 743
 744 cycles_t cacheflush_time;
 745 unsigned long cache_decay_ticks;
 746
 747 /*
 748  * Construct cpu_sibling_map[], so that we can tell the sibling CPU
 749  * on SMT systems efficiently.
 750  */
 751 static __cpuinit void detect_siblings(void)
 752 {
 753         int cpu;
 754
 755         for (cpu = 0; cpu < NR_CPUS; cpu++) {
 756                 cpus_clear(cpu_sibling_map[cpu]);
 757                 cpus_clear(cpu_core_map[cpu]);
 758         }
 759
 760         for_each_online_cpu (cpu) {
 761                 struct cpuinfo_x86 *c = cpu_data + cpu;
 762                 int siblings = 0;
 763                 int i;
 764                 if (smp_num_siblings > 1) {
 765                         for_each_online_cpu (i) {
 766                                 if (cpu_core_id[cpu] == cpu_core_id[i]) {
 767                                         siblings++;
 768                                         cpu_set(i, cpu_sibling_map[cpu]);
 769                                 }
 770                         }
 771                 } else {
 772                         siblings++;
 773                         cpu_set(cpu, cpu_sibling_map[cpu]);
 774                 }
 775
 776                 if (siblings != smp_num_siblings) {
 777                         printk(KERN_WARNING
 778                "WARNING: %d siblings found for CPU%d, should be %d\n",
 779                                siblings, cpu, smp_num_siblings);
 780                         smp_num_siblings = siblings;
 781                 }
 782                 if (c->x86_num_cores > 1) {
 783                         for_each_online_cpu(i) {
 784                                 if (phys_proc_id[cpu] == phys_proc_id[i])
 785                                         cpu_set(i, cpu_core_map[cpu]);
 786                         }
 787                 } else
 788                         cpu_core_map[cpu] = cpu_sibling_map[cpu];
 789         }
 790 }
 791
 792 /*
 793  * Cleanup possible dangling ends...
 794  */
 795 static __cpuinit void smp_cleanup_boot(void)
 796 {
 797         /*
 798          * Paranoid:  Set warm reset code and vector here back
 799          * to default values.
 800          */
 801         CMOS_WRITE(0, 0xf);
 802
 803         /*
 804          * Reset trampoline flag
 805          */
 806         *((volatile int *) phys_to_virt(0x467)) = 0;
 807
 808 #ifndef CONFIG_HOTPLUG_CPU
 809         /*
 810          * Free pages reserved for SMP bootup.
 811          * When you add hotplug CPU support later remove this
 812          * Note there is more work to be done for later CPU bootup.
 813          */
 814
 815         free_page((unsigned long) __va(PAGE_SIZE));
 816         free_page((unsigned long) __va(SMP_TRAMPOLINE_BASE));
 817 #endif
 818 }
 819
 820 /*
 821  * Fall back to non SMP mode after errors.
 822  *
 823  * RED-PEN audit/test this more. I bet there is more state messed up here.
 824  */
 825 static __cpuinit void disable_smp(void)
 826 {
 827         cpu_present_map = cpumask_of_cpu(0);
 828         cpu_possible_map = cpumask_of_cpu(0);
 829         if (smp_found_config)
 830                 phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
 831         else
 832                 phys_cpu_present_map = physid_mask_of_physid(0);
 833         cpu_set(0, cpu_sibling_map[0]);
 834         cpu_set(0, cpu_core_map[0]);
 835 }
 836
 837 /*
 838  * Handle user cpus=... parameter.
 839  */
 840 static __cpuinit void enforce_max_cpus(unsigned max_cpus)
 841 {
 842         int i, k;
 843         k = 0;
 844         for (i = 0; i < NR_CPUS; i++) {
 845                 if (!cpu_possible(i))
 846                         continue;
 847                 if (++k > max_cpus) {
 848                         cpu_clear(i, cpu_possible_map);
 849                         cpu_clear(i, cpu_present_map);
 850                 }
 851         }
 852 }
 853
 854 /*
 855  * Various sanity checks.
 856  */
 857 static int __cpuinit smp_sanity_check(unsigned max_cpus)
 858 {
 859         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
 860                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
 861                        hard_smp_processor_id());
 862                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
 863         }
 864
 865         /*
 866          * If we couldn't find an SMP configuration at boot time,
 867          * get out of here now!
 868          */
 869         if (!smp_found_config) {
 870                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
 871                 disable_smp();
 872                 if (APIC_init_uniprocessor())
 873                         printk(KERN_NOTICE "Local APIC not detected."
 874                                            " Using dummy APIC emulation.\n");
 875                 return -1;
 876         }
 877
 878         /*
 879          * Should not be necessary because the MP table should list the boot
 880          * CPU too, but we do it for the sake of robustness anyway.
 881          */
 882         if (!physid_isset(boot_cpu_id, phys_cpu_present_map)) {
 883                 printk(KERN_NOTICE "weird, boot CPU (#%d) not listed by the BIOS.\n",
 884                                                                  boot_cpu_id);
 885                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
 886         }
 887
 888         /*
 889          * If we couldn't find a local APIC, then get out of here now!
 890          */
 891         if (APIC_INTEGRATED(apic_version[boot_cpu_id]) && !cpu_has_apic) {
 892                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
 893                         boot_cpu_id);
 894                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
 895                 nr_ioapics = 0;
 896                 return -1;
 897         }
 898
 899         /*
 900          * If SMP should be disabled, then really disable it!
 901          */
 902         if (!max_cpus) {
 903                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
 904                 nr_ioapics = 0;
 905                 return -1;
 906         }
 907
 908         return 0;
 909 }
 910
 911 /*
 912  * Prepare for SMP bootup.  The MP table or ACPI has been read
 913  * earlier.  Just do some sanity checking here and enable APIC mode.
 914  */
 915 void __cpuinit smp_prepare_cpus(unsigned int max_cpus)
 916 {
 917         int i;
 918
 919         nmi_watchdog_default();
 920         current_cpu_data = boot_cpu_data;
 921         current_thread_info()->cpu = 0;  /* needed? */
 922
 923         enforce_max_cpus(max_cpus);
 924
 925         /*
 926          * Fill in cpu_present_mask
 927          */
 928         for (i = 0; i < NR_CPUS; i++) {
 929                 int apicid = cpu_present_to_apicid(i);
 930                 if (physid_isset(apicid, phys_cpu_present_map)) {
 931                         cpu_set(i, cpu_present_map);
 932                         /* possible map would be different if we supported real
 933                            CPU hotplug. */
 934                         cpu_set(i, cpu_possible_map);
 935                 }
 936         }
 937
 938         if (smp_sanity_check(max_cpus) < 0) {
 939                 printk(KERN_INFO "SMP disabled\n");
 940                 disable_smp();
 941                 return;
 942         }
 943
 944
 945         /*
 946          * Switch from PIC to APIC mode.
 947          */
 948         connect_bsp_APIC();
 949         setup_local_APIC();
 950
 951         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
 952                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
 953                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
 954                 /* Or can we switch back to PIC here? */
 955         }
 956
 957         /*
 958          * Now start the IO-APICs
 959          */
 960         if (!skip_ioapic_setup && nr_ioapics)
 961                 setup_IO_APIC();
 962         else
 963                 nr_ioapics = 0;
 964
 965         /*
 966          * Set up local APIC timer on boot CPU.
 967          */
 968
 969         setup_boot_APIC_clock();
 970 }
 971
 972 /*
 973  * Early setup to make printk work.
 974  */
 975 void __init smp_prepare_boot_cpu(void)
 976 {
 977         int me = smp_processor_id();
 978         cpu_set(me, cpu_online_map);
 979         cpu_set(me, cpu_callout_map);
 980 }
 981
 982 /*
 983  * Entry point to boot a CPU.
 984  *
 985  * This is all __cpuinit, not __devinit for now because we don't support
 986  * CPU hotplug (yet).
 987  */
 988 int __cpuinit __cpu_up(unsigned int cpu)
 989 {
 990         int err;
 991         int apicid = cpu_present_to_apicid(cpu);
 992
 993         WARN_ON(irqs_disabled());
 994
 995         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
 996
 997         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
 998             !physid_isset(apicid, phys_cpu_present_map)) {
 999                 printk("__cpu_up: bad cpu %d\n", cpu);
1000                 return -EINVAL;
1001         }
1002
1003         /* Boot it! */
1004         err = do_boot_cpu(cpu, apicid);
1005         if (err < 0) {
1006                 Dprintk("do_boot_cpu failed %d\n", err);
1007                 return err;
1008         }
1009
1010         /* Unleash the CPU! */
1011         Dprintk("waiting for cpu %d\n", cpu);
1012
1013         while (!cpu_isset(cpu, cpu_online_map))
1014                 cpu_relax();
1015         return 0;
1016 }
1017
1018 /*
1019  * Finish the SMP boot.
1020  */
1021 void __cpuinit smp_cpus_done(unsigned int max_cpus)
1022 {
1023         zap_low_mappings();
1024         smp_cleanup_boot();
1025
1026 #ifdef CONFIG_X86_IO_APIC
1027         setup_ioapic_dest();
1028 #endif
1029
1030         detect_siblings();
1031         time_init_gtod();
1032
1033         check_nmi_watchdog();
1034 }