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