Merge x86-64 update from Andi
[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  *      Ashok Raj                       : CPU hotplug support
38  */
39
40
41 #include <linux/config.h>
42 #include <linux/init.h>
43
44 #include <linux/mm.h>
45 #include <linux/kernel_stat.h>
46 #include <linux/smp_lock.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 #include <asm/irq.h>
61 #include <asm/hw_irq.h>
62
63 /* Number of siblings per CPU package */
64 int smp_num_siblings = 1;
65 /* Package ID of each logical CPU */
66 u8 phys_proc_id[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
67 /* core ID of each logical CPU */
68 u8 cpu_core_id[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
69
70 /* Bitmask of currently online CPUs */
71 cpumask_t cpu_online_map __read_mostly;
72
73 EXPORT_SYMBOL(cpu_online_map);
74
75 /*
76  * Private maps to synchronize booting between AP and BP.
77  * Probably not needed anymore, but it makes for easier debugging. -AK
78  */
79 cpumask_t cpu_callin_map;
80 cpumask_t cpu_callout_map;
81
82 cpumask_t cpu_possible_map;
83 EXPORT_SYMBOL(cpu_possible_map);
84
85 /* Per CPU bogomips and other parameters */
86 struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
87
88 /* Set when the idlers are all forked */
89 int smp_threads_ready;
90
91 /* representing HT siblings of each logical CPU */
92 cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly;
93
94 /* representing HT and core siblings of each logical CPU */
95 cpumask_t cpu_core_map[NR_CPUS] __read_mostly;
96 EXPORT_SYMBOL(cpu_core_map);
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 /* State of each CPU */
106 DEFINE_PER_CPU(int, cpu_state) = { 0 };
107
108 /*
109  * Store all idle threads, this can be reused instead of creating
110  * a new thread. Also avoids complicated thread destroy functionality
111  * for idle threads.
112  */
113 struct task_struct *idle_thread_array[NR_CPUS] __cpuinitdata ;
114
115 #define get_idle_for_cpu(x)     (idle_thread_array[(x)])
116 #define set_idle_for_cpu(x,p)   (idle_thread_array[(x)] = (p))
117
118 /*
119  * Currently trivial. Write the real->protected mode
120  * bootstrap into the page concerned. The caller
121  * has made sure it's suitably aligned.
122  */
123
124 static unsigned long __cpuinit setup_trampoline(void)
125 {
126         void *tramp = __va(SMP_TRAMPOLINE_BASE); 
127         memcpy(tramp, trampoline_data, trampoline_end - trampoline_data);
128         return virt_to_phys(tramp);
129 }
130
131 /*
132  * The bootstrap kernel entry code has set these up. Save them for
133  * a given CPU
134  */
135
136 static void __cpuinit smp_store_cpu_info(int id)
137 {
138         struct cpuinfo_x86 *c = cpu_data + id;
139
140         *c = boot_cpu_data;
141         identify_cpu(c);
142         print_cpu_info(c);
143 }
144
145 /*
146  * New Funky TSC sync algorithm borrowed from IA64.
147  * Main advantage is that it doesn't reset the TSCs fully and
148  * in general looks more robust and it works better than my earlier
149  * attempts. I believe it was written by David Mosberger. Some minor
150  * adjustments for x86-64 by me -AK
151  *
152  * Original comment reproduced below.
153  *
154  * Synchronize TSC of the current (slave) CPU with the TSC of the
155  * MASTER CPU (normally the time-keeper CPU).  We use a closed loop to
156  * eliminate the possibility of unaccounted-for errors (such as
157  * getting a machine check in the middle of a calibration step).  The
158  * basic idea is for the slave to ask the master what itc value it has
159  * and to read its own itc before and after the master responds.  Each
160  * iteration gives us three timestamps:
161  *
162  *      slave           master
163  *
164  *      t0 ---\
165  *             ---\
166  *                 --->
167  *                      tm
168  *                 /---
169  *             /---
170  *      t1 <---
171  *
172  *
173  * The goal is to adjust the slave's TSC such that tm falls exactly
174  * half-way between t0 and t1.  If we achieve this, the clocks are
175  * synchronized provided the interconnect between the slave and the
176  * master is symmetric.  Even if the interconnect were asymmetric, we
177  * would still know that the synchronization error is smaller than the
178  * roundtrip latency (t0 - t1).
179  *
180  * When the interconnect is quiet and symmetric, this lets us
181  * synchronize the TSC to within one or two cycles.  However, we can
182  * only *guarantee* that the synchronization is accurate to within a
183  * round-trip time, which is typically in the range of several hundred
184  * cycles (e.g., ~500 cycles).  In practice, this means that the TSCs
185  * are usually almost perfectly synchronized, but we shouldn't assume
186  * that the accuracy is much better than half a micro second or so.
187  *
188  * [there are other errors like the latency of RDTSC and of the
189  * WRMSR. These can also account to hundreds of cycles. So it's
190  * probably worse. It claims 153 cycles error on a dual Opteron,
191  * but I suspect the numbers are actually somewhat worse -AK]
192  */
193
194 #define MASTER  0
195 #define SLAVE   (SMP_CACHE_BYTES/8)
196
197 /* Intentionally don't use cpu_relax() while TSC synchronization
198    because we don't want to go into funky power save modi or cause
199    hypervisors to schedule us away.  Going to sleep would likely affect
200    latency and low latency is the primary objective here. -AK */
201 #define no_cpu_relax() barrier()
202
203 static __cpuinitdata DEFINE_SPINLOCK(tsc_sync_lock);
204 static volatile __cpuinitdata unsigned long go[SLAVE + 1];
205 static int notscsync __cpuinitdata;
206
207 #undef DEBUG_TSC_SYNC
208
209 #define NUM_ROUNDS      64      /* magic value */
210 #define NUM_ITERS       5       /* likewise */
211
212 /* Callback on boot CPU */
213 static __cpuinit void sync_master(void *arg)
214 {
215         unsigned long flags, i;
216
217         go[MASTER] = 0;
218
219         local_irq_save(flags);
220         {
221                 for (i = 0; i < NUM_ROUNDS*NUM_ITERS; ++i) {
222                         while (!go[MASTER])
223                                 no_cpu_relax();
224                         go[MASTER] = 0;
225                         rdtscll(go[SLAVE]);
226                 }
227         }
228         local_irq_restore(flags);
229 }
230
231 /*
232  * Return the number of cycles by which our tsc differs from the tsc
233  * on the master (time-keeper) CPU.  A positive number indicates our
234  * tsc is ahead of the master, negative that it is behind.
235  */
236 static inline long
237 get_delta(long *rt, long *master)
238 {
239         unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
240         unsigned long tcenter, t0, t1, tm;
241         int i;
242
243         for (i = 0; i < NUM_ITERS; ++i) {
244                 rdtscll(t0);
245                 go[MASTER] = 1;
246                 while (!(tm = go[SLAVE]))
247                         no_cpu_relax();
248                 go[SLAVE] = 0;
249                 rdtscll(t1);
250
251                 if (t1 - t0 < best_t1 - best_t0)
252                         best_t0 = t0, best_t1 = t1, best_tm = tm;
253         }
254
255         *rt = best_t1 - best_t0;
256         *master = best_tm - best_t0;
257
258         /* average best_t0 and best_t1 without overflow: */
259         tcenter = (best_t0/2 + best_t1/2);
260         if (best_t0 % 2 + best_t1 % 2 == 2)
261                 ++tcenter;
262         return tcenter - best_tm;
263 }
264
265 static __cpuinit void sync_tsc(unsigned int master)
266 {
267         int i, done = 0;
268         long delta, adj, adjust_latency = 0;
269         unsigned long flags, rt, master_time_stamp, bound;
270 #ifdef DEBUG_TSC_SYNC
271         static struct syncdebug {
272                 long rt;        /* roundtrip time */
273                 long master;    /* master's timestamp */
274                 long diff;      /* difference between midpoint and master's timestamp */
275                 long lat;       /* estimate of tsc adjustment latency */
276         } t[NUM_ROUNDS] __cpuinitdata;
277 #endif
278
279         printk(KERN_INFO "CPU %d: Syncing TSC to CPU %u.\n",
280                 smp_processor_id(), master);
281
282         go[MASTER] = 1;
283
284         /* It is dangerous to broadcast IPI as cpus are coming up,
285          * as they may not be ready to accept them.  So since
286          * we only need to send the ipi to the boot cpu direct
287          * the message, and avoid the race.
288          */
289         smp_call_function_single(master, sync_master, NULL, 1, 0);
290
291         while (go[MASTER])      /* wait for master to be ready */
292                 no_cpu_relax();
293
294         spin_lock_irqsave(&tsc_sync_lock, flags);
295         {
296                 for (i = 0; i < NUM_ROUNDS; ++i) {
297                         delta = get_delta(&rt, &master_time_stamp);
298                         if (delta == 0) {
299                                 done = 1;       /* let's lock on to this... */
300                                 bound = rt;
301                         }
302
303                         if (!done) {
304                                 unsigned long t;
305                                 if (i > 0) {
306                                         adjust_latency += -delta;
307                                         adj = -delta + adjust_latency/4;
308                                 } else
309                                         adj = -delta;
310
311                                 rdtscll(t);
312                                 wrmsrl(MSR_IA32_TSC, t + adj);
313                         }
314 #ifdef DEBUG_TSC_SYNC
315                         t[i].rt = rt;
316                         t[i].master = master_time_stamp;
317                         t[i].diff = delta;
318                         t[i].lat = adjust_latency/4;
319 #endif
320                 }
321         }
322         spin_unlock_irqrestore(&tsc_sync_lock, flags);
323
324 #ifdef DEBUG_TSC_SYNC
325         for (i = 0; i < NUM_ROUNDS; ++i)
326                 printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
327                        t[i].rt, t[i].master, t[i].diff, t[i].lat);
328 #endif
329
330         printk(KERN_INFO
331                "CPU %d: synchronized TSC with CPU %u (last diff %ld cycles, "
332                "maxerr %lu cycles)\n",
333                smp_processor_id(), master, delta, rt);
334 }
335
336 static void __cpuinit tsc_sync_wait(void)
337 {
338         if (notscsync || !cpu_has_tsc)
339                 return;
340         sync_tsc(0);
341 }
342
343 static __init int notscsync_setup(char *s)
344 {
345         notscsync = 1;
346         return 0;
347 }
348 __setup("notscsync", notscsync_setup);
349
350 static atomic_t init_deasserted __cpuinitdata;
351
352 /*
353  * Report back to the Boot Processor.
354  * Running on AP.
355  */
356 void __cpuinit smp_callin(void)
357 {
358         int cpuid, phys_id;
359         unsigned long timeout;
360
361         /*
362          * If waken up by an INIT in an 82489DX configuration
363          * we may get here before an INIT-deassert IPI reaches
364          * our local APIC.  We have to wait for the IPI or we'll
365          * lock up on an APIC access.
366          */
367         while (!atomic_read(&init_deasserted))
368                 cpu_relax();
369
370         /*
371          * (This works even if the APIC is not enabled.)
372          */
373         phys_id = GET_APIC_ID(apic_read(APIC_ID));
374         cpuid = smp_processor_id();
375         if (cpu_isset(cpuid, cpu_callin_map)) {
376                 panic("smp_callin: phys CPU#%d, CPU#%d already present??\n",
377                                         phys_id, cpuid);
378         }
379         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
380
381         /*
382          * STARTUP IPIs are fragile beasts as they might sometimes
383          * trigger some glue motherboard logic. Complete APIC bus
384          * silence for 1 second, this overestimates the time the
385          * boot CPU is spending to send the up to 2 STARTUP IPIs
386          * by a factor of two. This should be enough.
387          */
388
389         /*
390          * Waiting 2s total for startup (udelay is not yet working)
391          */
392         timeout = jiffies + 2*HZ;
393         while (time_before(jiffies, timeout)) {
394                 /*
395                  * Has the boot CPU finished it's STARTUP sequence?
396                  */
397                 if (cpu_isset(cpuid, cpu_callout_map))
398                         break;
399                 cpu_relax();
400         }
401
402         if (!time_before(jiffies, timeout)) {
403                 panic("smp_callin: CPU%d started up but did not get a callout!\n",
404                         cpuid);
405         }
406
407         /*
408          * the boot CPU has finished the init stage and is spinning
409          * on callin_map until we finish. We are free to set up this
410          * CPU, first the APIC. (this is probably redundant on most
411          * boards)
412          */
413
414         Dprintk("CALLIN, before setup_local_APIC().\n");
415         setup_local_APIC();
416
417         /*
418          * Get our bogomips.
419          *
420          * Need to enable IRQs because it can take longer and then
421          * the NMI watchdog might kill us.
422          */
423         local_irq_enable();
424         calibrate_delay();
425         local_irq_disable();
426         Dprintk("Stack at about %p\n",&cpuid);
427
428         disable_APIC_timer();
429
430         /*
431          * Save our processor parameters
432          */
433         smp_store_cpu_info(cpuid);
434
435         /*
436          * Allow the master to continue.
437          */
438         cpu_set(cpuid, cpu_callin_map);
439 }
440
441 /* representing cpus for which sibling maps can be computed */
442 static cpumask_t cpu_sibling_setup_map;
443
444 static inline void set_cpu_sibling_map(int cpu)
445 {
446         int i;
447         struct cpuinfo_x86 *c = cpu_data;
448
449         cpu_set(cpu, cpu_sibling_setup_map);
450
451         if (smp_num_siblings > 1) {
452                 for_each_cpu_mask(i, cpu_sibling_setup_map) {
453                         if (phys_proc_id[cpu] == phys_proc_id[i] &&
454                             cpu_core_id[cpu] == cpu_core_id[i]) {
455                                 cpu_set(i, cpu_sibling_map[cpu]);
456                                 cpu_set(cpu, cpu_sibling_map[i]);
457                                 cpu_set(i, cpu_core_map[cpu]);
458                                 cpu_set(cpu, cpu_core_map[i]);
459                         }
460                 }
461         } else {
462                 cpu_set(cpu, cpu_sibling_map[cpu]);
463         }
464
465         if (current_cpu_data.x86_max_cores == 1) {
466                 cpu_core_map[cpu] = cpu_sibling_map[cpu];
467                 c[cpu].booted_cores = 1;
468                 return;
469         }
470
471         for_each_cpu_mask(i, cpu_sibling_setup_map) {
472                 if (phys_proc_id[cpu] == phys_proc_id[i]) {
473                         cpu_set(i, cpu_core_map[cpu]);
474                         cpu_set(cpu, cpu_core_map[i]);
475                         /*
476                          *  Does this new cpu bringup a new core?
477                          */
478                         if (cpus_weight(cpu_sibling_map[cpu]) == 1) {
479                                 /*
480                                  * for each core in package, increment
481                                  * the booted_cores for this new cpu
482                                  */
483                                 if (first_cpu(cpu_sibling_map[i]) == i)
484                                         c[cpu].booted_cores++;
485                                 /*
486                                  * increment the core count for all
487                                  * the other cpus in this package
488                                  */
489                                 if (i != cpu)
490                                         c[i].booted_cores++;
491                         } else if (i != cpu && !c[cpu].booted_cores)
492                                 c[cpu].booted_cores = c[i].booted_cores;
493                 }
494         }
495 }
496
497 /*
498  * Setup code on secondary processor (after comming out of the trampoline)
499  */
500 void __cpuinit start_secondary(void)
501 {
502         /*
503          * Dont put anything before smp_callin(), SMP
504          * booting is too fragile that we want to limit the
505          * things done here to the most necessary things.
506          */
507         cpu_init();
508         preempt_disable();
509         smp_callin();
510
511         /* otherwise gcc will move up the smp_processor_id before the cpu_init */
512         barrier();
513
514         Dprintk("cpu %d: setting up apic clock\n", smp_processor_id());         
515         setup_secondary_APIC_clock();
516
517         Dprintk("cpu %d: enabling apic timer\n", smp_processor_id());
518
519         if (nmi_watchdog == NMI_IO_APIC) {
520                 disable_8259A_irq(0);
521                 enable_NMI_through_LVT0(NULL);
522                 enable_8259A_irq(0);
523         }
524
525         enable_APIC_timer();
526
527         /*
528          * The sibling maps must be set before turing the online map on for
529          * this cpu
530          */
531         set_cpu_sibling_map(smp_processor_id());
532
533         /* 
534          * Wait for TSC sync to not schedule things before.
535          * We still process interrupts, which could see an inconsistent
536          * time in that window unfortunately. 
537          * Do this here because TSC sync has global unprotected state.
538          */
539         tsc_sync_wait();
540
541         /*
542          * We need to hold call_lock, so there is no inconsistency
543          * between the time smp_call_function() determines number of
544          * IPI receipients, and the time when the determination is made
545          * for which cpus receive the IPI in genapic_flat.c. Holding this
546          * lock helps us to not include this cpu in a currently in progress
547          * smp_call_function().
548          */
549         lock_ipi_call_lock();
550
551         /*
552          * Allow the master to continue.
553          */
554         cpu_set(smp_processor_id(), cpu_online_map);
555         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
556         unlock_ipi_call_lock();
557
558         cpu_idle();
559 }
560
561 extern volatile unsigned long init_rsp;
562 extern void (*initial_code)(void);
563
564 #ifdef APIC_DEBUG
565 static void inquire_remote_apic(int apicid)
566 {
567         unsigned i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
568         char *names[] = { "ID", "VERSION", "SPIV" };
569         int timeout, status;
570
571         printk(KERN_INFO "Inquiring remote APIC #%d...\n", apicid);
572
573         for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
574                 printk("... APIC #%d %s: ", apicid, names[i]);
575
576                 /*
577                  * Wait for idle.
578                  */
579                 apic_wait_icr_idle();
580
581                 apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
582                 apic_write(APIC_ICR, APIC_DM_REMRD | regs[i]);
583
584                 timeout = 0;
585                 do {
586                         udelay(100);
587                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
588                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
589
590                 switch (status) {
591                 case APIC_ICR_RR_VALID:
592                         status = apic_read(APIC_RRR);
593                         printk("%08x\n", status);
594                         break;
595                 default:
596                         printk("failed\n");
597                 }
598         }
599 }
600 #endif
601
602 /*
603  * Kick the secondary to wake up.
604  */
605 static int __cpuinit wakeup_secondary_via_INIT(int phys_apicid, unsigned int start_rip)
606 {
607         unsigned long send_status = 0, accept_status = 0;
608         int maxlvt, timeout, num_starts, j;
609
610         Dprintk("Asserting INIT.\n");
611
612         /*
613          * Turn INIT on target chip
614          */
615         apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
616
617         /*
618          * Send IPI
619          */
620         apic_write(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
621                                 | APIC_DM_INIT);
622
623         Dprintk("Waiting for send to finish...\n");
624         timeout = 0;
625         do {
626                 Dprintk("+");
627                 udelay(100);
628                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
629         } while (send_status && (timeout++ < 1000));
630
631         mdelay(10);
632
633         Dprintk("Deasserting INIT.\n");
634
635         /* Target chip */
636         apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
637
638         /* Send IPI */
639         apic_write(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
640
641         Dprintk("Waiting for send to finish...\n");
642         timeout = 0;
643         do {
644                 Dprintk("+");
645                 udelay(100);
646                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
647         } while (send_status && (timeout++ < 1000));
648
649         atomic_set(&init_deasserted, 1);
650
651         num_starts = 2;
652
653         /*
654          * Run STARTUP IPI loop.
655          */
656         Dprintk("#startup loops: %d.\n", num_starts);
657
658         maxlvt = get_maxlvt();
659
660         for (j = 1; j <= num_starts; j++) {
661                 Dprintk("Sending STARTUP #%d.\n",j);
662                 apic_read_around(APIC_SPIV);
663                 apic_write(APIC_ESR, 0);
664                 apic_read(APIC_ESR);
665                 Dprintk("After apic_write.\n");
666
667                 /*
668                  * STARTUP IPI
669                  */
670
671                 /* Target chip */
672                 apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
673
674                 /* Boot on the stack */
675                 /* Kick the second */
676                 apic_write(APIC_ICR, APIC_DM_STARTUP | (start_rip >> 12));
677
678                 /*
679                  * Give the other CPU some time to accept the IPI.
680                  */
681                 udelay(300);
682
683                 Dprintk("Startup point 1.\n");
684
685                 Dprintk("Waiting for send to finish...\n");
686                 timeout = 0;
687                 do {
688                         Dprintk("+");
689                         udelay(100);
690                         send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
691                 } while (send_status && (timeout++ < 1000));
692
693                 /*
694                  * Give the other CPU some time to accept the IPI.
695                  */
696                 udelay(200);
697                 /*
698                  * Due to the Pentium erratum 3AP.
699                  */
700                 if (maxlvt > 3) {
701                         apic_read_around(APIC_SPIV);
702                         apic_write(APIC_ESR, 0);
703                 }
704                 accept_status = (apic_read(APIC_ESR) & 0xEF);
705                 if (send_status || accept_status)
706                         break;
707         }
708         Dprintk("After Startup.\n");
709
710         if (send_status)
711                 printk(KERN_ERR "APIC never delivered???\n");
712         if (accept_status)
713                 printk(KERN_ERR "APIC delivery error (%lx).\n", accept_status);
714
715         return (send_status | accept_status);
716 }
717
718 struct create_idle {
719         struct task_struct *idle;
720         struct completion done;
721         int cpu;
722 };
723
724 void do_fork_idle(void *_c_idle)
725 {
726         struct create_idle *c_idle = _c_idle;
727
728         c_idle->idle = fork_idle(c_idle->cpu);
729         complete(&c_idle->done);
730 }
731
732 /*
733  * Boot one CPU.
734  */
735 static int __cpuinit do_boot_cpu(int cpu, int apicid)
736 {
737         unsigned long boot_error;
738         int timeout;
739         unsigned long start_rip;
740         struct create_idle c_idle = {
741                 .cpu = cpu,
742                 .done = COMPLETION_INITIALIZER(c_idle.done),
743         };
744         DECLARE_WORK(work, do_fork_idle, &c_idle);
745
746         c_idle.idle = get_idle_for_cpu(cpu);
747
748         if (c_idle.idle) {
749                 c_idle.idle->thread.rsp = (unsigned long) (((struct pt_regs *)
750                         (THREAD_SIZE + (unsigned long) c_idle.idle->thread_info)) - 1);
751                 init_idle(c_idle.idle, cpu);
752                 goto do_rest;
753         }
754
755         /*
756          * During cold boot process, keventd thread is not spun up yet.
757          * When we do cpu hot-add, we create idle threads on the fly, we should
758          * not acquire any attributes from the calling context. Hence the clean
759          * way to create kernel_threads() is to do that from keventd().
760          * We do the current_is_keventd() due to the fact that ACPI notifier
761          * was also queuing to keventd() and when the caller is already running
762          * in context of keventd(), we would end up with locking up the keventd
763          * thread.
764          */
765         if (!keventd_up() || current_is_keventd())
766                 work.func(work.data);
767         else {
768                 schedule_work(&work);
769                 wait_for_completion(&c_idle.done);
770         }
771
772         if (IS_ERR(c_idle.idle)) {
773                 printk("failed fork for CPU %d\n", cpu);
774                 return PTR_ERR(c_idle.idle);
775         }
776
777         set_idle_for_cpu(cpu, c_idle.idle);
778
779 do_rest:
780
781         cpu_pda[cpu].pcurrent = c_idle.idle;
782
783         start_rip = setup_trampoline();
784
785         init_rsp = c_idle.idle->thread.rsp;
786         per_cpu(init_tss,cpu).rsp0 = init_rsp;
787         initial_code = start_secondary;
788         clear_ti_thread_flag(c_idle.idle->thread_info, TIF_FORK);
789
790         printk(KERN_INFO "Booting processor %d/%d APIC 0x%x\n", cpu,
791                 cpus_weight(cpu_present_map),
792                 apicid);
793
794         /*
795          * This grunge runs the startup process for
796          * the targeted processor.
797          */
798
799         atomic_set(&init_deasserted, 0);
800
801         Dprintk("Setting warm reset code and vector.\n");
802
803         CMOS_WRITE(0xa, 0xf);
804         local_flush_tlb();
805         Dprintk("1.\n");
806         *((volatile unsigned short *) phys_to_virt(0x469)) = start_rip >> 4;
807         Dprintk("2.\n");
808         *((volatile unsigned short *) phys_to_virt(0x467)) = start_rip & 0xf;
809         Dprintk("3.\n");
810
811         /*
812          * Be paranoid about clearing APIC errors.
813          */
814         if (APIC_INTEGRATED(apic_version[apicid])) {
815                 apic_read_around(APIC_SPIV);
816                 apic_write(APIC_ESR, 0);
817                 apic_read(APIC_ESR);
818         }
819
820         /*
821          * Status is now clean
822          */
823         boot_error = 0;
824
825         /*
826          * Starting actual IPI sequence...
827          */
828         boot_error = wakeup_secondary_via_INIT(apicid, start_rip);
829
830         if (!boot_error) {
831                 /*
832                  * allow APs to start initializing.
833                  */
834                 Dprintk("Before Callout %d.\n", cpu);
835                 cpu_set(cpu, cpu_callout_map);
836                 Dprintk("After Callout %d.\n", cpu);
837
838                 /*
839                  * Wait 5s total for a response
840                  */
841                 for (timeout = 0; timeout < 50000; timeout++) {
842                         if (cpu_isset(cpu, cpu_callin_map))
843                                 break;  /* It has booted */
844                         udelay(100);
845                 }
846
847                 if (cpu_isset(cpu, cpu_callin_map)) {
848                         /* number CPUs logically, starting from 1 (BSP is 0) */
849                         Dprintk("CPU has booted.\n");
850                 } else {
851                         boot_error = 1;
852                         if (*((volatile unsigned char *)phys_to_virt(SMP_TRAMPOLINE_BASE))
853                                         == 0xA5)
854                                 /* trampoline started but...? */
855                                 printk("Stuck ??\n");
856                         else
857                                 /* trampoline code not run */
858                                 printk("Not responding.\n");
859 #ifdef APIC_DEBUG
860                         inquire_remote_apic(apicid);
861 #endif
862                 }
863         }
864         if (boot_error) {
865                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
866                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
867                 cpu_clear(cpu, cpu_present_map);
868                 cpu_clear(cpu, cpu_possible_map);
869                 x86_cpu_to_apicid[cpu] = BAD_APICID;
870                 x86_cpu_to_log_apicid[cpu] = BAD_APICID;
871                 return -EIO;
872         }
873
874         return 0;
875 }
876
877 cycles_t cacheflush_time;
878 unsigned long cache_decay_ticks;
879
880 /*
881  * Cleanup possible dangling ends...
882  */
883 static __cpuinit void smp_cleanup_boot(void)
884 {
885         /*
886          * Paranoid:  Set warm reset code and vector here back
887          * to default values.
888          */
889         CMOS_WRITE(0, 0xf);
890
891         /*
892          * Reset trampoline flag
893          */
894         *((volatile int *) phys_to_virt(0x467)) = 0;
895 }
896
897 /*
898  * Fall back to non SMP mode after errors.
899  *
900  * RED-PEN audit/test this more. I bet there is more state messed up here.
901  */
902 static __init void disable_smp(void)
903 {
904         cpu_present_map = cpumask_of_cpu(0);
905         cpu_possible_map = cpumask_of_cpu(0);
906         if (smp_found_config)
907                 phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
908         else
909                 phys_cpu_present_map = physid_mask_of_physid(0);
910         cpu_set(0, cpu_sibling_map[0]);
911         cpu_set(0, cpu_core_map[0]);
912 }
913
914 #ifdef CONFIG_HOTPLUG_CPU
915
916 int additional_cpus __initdata = -1;
917
918 /*
919  * cpu_possible_map should be static, it cannot change as cpu's
920  * are onlined, or offlined. The reason is per-cpu data-structures
921  * are allocated by some modules at init time, and dont expect to
922  * do this dynamically on cpu arrival/departure.
923  * cpu_present_map on the other hand can change dynamically.
924  * In case when cpu_hotplug is not compiled, then we resort to current
925  * behaviour, which is cpu_possible == cpu_present.
926  * - Ashok Raj
927  *
928  * Three ways to find out the number of additional hotplug CPUs:
929  * - If the BIOS specified disabled CPUs in ACPI/mptables use that.
930  * - otherwise use half of the available CPUs or 2, whatever is more.
931  * - The user can overwrite it with additional_cpus=NUM
932  * We do this because additional CPUs waste a lot of memory.
933  * -AK
934  */
935 __init void prefill_possible_map(void)
936 {
937         int i;
938         int possible;
939
940         if (additional_cpus == -1) {
941                 if (disabled_cpus > 0) {
942                         additional_cpus = disabled_cpus;
943                 } else {
944                         additional_cpus = num_processors / 2;
945                         if (additional_cpus == 0)
946                                 additional_cpus = 2;
947                 }
948         }
949         possible = num_processors + additional_cpus;
950         if (possible > NR_CPUS) 
951                 possible = NR_CPUS;
952
953         printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
954                 possible,
955                 max_t(int, possible - num_processors, 0));
956
957         for (i = 0; i < possible; i++)
958                 cpu_set(i, cpu_possible_map);
959 }
960 #endif
961
962 /*
963  * Various sanity checks.
964  */
965 static int __init smp_sanity_check(unsigned max_cpus)
966 {
967         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
968                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
969                        hard_smp_processor_id());
970                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
971         }
972
973         /*
974          * If we couldn't find an SMP configuration at boot time,
975          * get out of here now!
976          */
977         if (!smp_found_config) {
978                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
979                 disable_smp();
980                 if (APIC_init_uniprocessor())
981                         printk(KERN_NOTICE "Local APIC not detected."
982                                            " Using dummy APIC emulation.\n");
983                 return -1;
984         }
985
986         /*
987          * Should not be necessary because the MP table should list the boot
988          * CPU too, but we do it for the sake of robustness anyway.
989          */
990         if (!physid_isset(boot_cpu_id, phys_cpu_present_map)) {
991                 printk(KERN_NOTICE "weird, boot CPU (#%d) not listed by the BIOS.\n",
992                                                                  boot_cpu_id);
993                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
994         }
995
996         /*
997          * If we couldn't find a local APIC, then get out of here now!
998          */
999         if (APIC_INTEGRATED(apic_version[boot_cpu_id]) && !cpu_has_apic) {
1000                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
1001                         boot_cpu_id);
1002                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
1003                 nr_ioapics = 0;
1004                 return -1;
1005         }
1006
1007         /*
1008          * If SMP should be disabled, then really disable it!
1009          */
1010         if (!max_cpus) {
1011                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
1012                 nr_ioapics = 0;
1013                 return -1;
1014         }
1015
1016         return 0;
1017 }
1018
1019 /*
1020  * Prepare for SMP bootup.  The MP table or ACPI has been read
1021  * earlier.  Just do some sanity checking here and enable APIC mode.
1022  */
1023 void __init smp_prepare_cpus(unsigned int max_cpus)
1024 {
1025         nmi_watchdog_default();
1026         current_cpu_data = boot_cpu_data;
1027         current_thread_info()->cpu = 0;  /* needed? */
1028         set_cpu_sibling_map(0);
1029
1030         if (smp_sanity_check(max_cpus) < 0) {
1031                 printk(KERN_INFO "SMP disabled\n");
1032                 disable_smp();
1033                 return;
1034         }
1035
1036
1037         /*
1038          * Switch from PIC to APIC mode.
1039          */
1040         connect_bsp_APIC();
1041         setup_local_APIC();
1042
1043         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
1044                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1045                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
1046                 /* Or can we switch back to PIC here? */
1047         }
1048
1049         /*
1050          * Now start the IO-APICs
1051          */
1052         if (!skip_ioapic_setup && nr_ioapics)
1053                 setup_IO_APIC();
1054         else
1055                 nr_ioapics = 0;
1056
1057         /*
1058          * Set up local APIC timer on boot CPU.
1059          */
1060
1061         setup_boot_APIC_clock();
1062 }
1063
1064 /*
1065  * Early setup to make printk work.
1066  */
1067 void __init smp_prepare_boot_cpu(void)
1068 {
1069         int me = smp_processor_id();
1070         cpu_set(me, cpu_online_map);
1071         cpu_set(me, cpu_callout_map);
1072         per_cpu(cpu_state, me) = CPU_ONLINE;
1073 }
1074
1075 /*
1076  * Entry point to boot a CPU.
1077  */
1078 int __cpuinit __cpu_up(unsigned int cpu)
1079 {
1080         int err;
1081         int apicid = cpu_present_to_apicid(cpu);
1082
1083         WARN_ON(irqs_disabled());
1084
1085         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
1086
1087         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
1088             !physid_isset(apicid, phys_cpu_present_map)) {
1089                 printk("__cpu_up: bad cpu %d\n", cpu);
1090                 return -EINVAL;
1091         }
1092
1093         /*
1094          * Already booted CPU?
1095          */
1096         if (cpu_isset(cpu, cpu_callin_map)) {
1097                 Dprintk("do_boot_cpu %d Already started\n", cpu);
1098                 return -ENOSYS;
1099         }
1100
1101         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1102         /* Boot it! */
1103         err = do_boot_cpu(cpu, apicid);
1104         if (err < 0) {
1105                 Dprintk("do_boot_cpu failed %d\n", err);
1106                 return err;
1107         }
1108
1109         /* Unleash the CPU! */
1110         Dprintk("waiting for cpu %d\n", cpu);
1111
1112         while (!cpu_isset(cpu, cpu_online_map))
1113                 cpu_relax();
1114         err = 0;
1115
1116         return err;
1117 }
1118
1119 /*
1120  * Finish the SMP boot.
1121  */
1122 void __init smp_cpus_done(unsigned int max_cpus)
1123 {
1124         smp_cleanup_boot();
1125
1126 #ifdef CONFIG_X86_IO_APIC
1127         setup_ioapic_dest();
1128 #endif
1129
1130         time_init_gtod();
1131
1132         check_nmi_watchdog();
1133 }
1134
1135 #ifdef CONFIG_HOTPLUG_CPU
1136
1137 static void remove_siblinginfo(int cpu)
1138 {
1139         int sibling;
1140         struct cpuinfo_x86 *c = cpu_data;
1141
1142         for_each_cpu_mask(sibling, cpu_core_map[cpu]) {
1143                 cpu_clear(cpu, cpu_core_map[sibling]);
1144                 /*
1145                  * last thread sibling in this cpu core going down
1146                  */
1147                 if (cpus_weight(cpu_sibling_map[cpu]) == 1)
1148                         c[sibling].booted_cores--;
1149         }
1150                         
1151         for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
1152                 cpu_clear(cpu, cpu_sibling_map[sibling]);
1153         cpus_clear(cpu_sibling_map[cpu]);
1154         cpus_clear(cpu_core_map[cpu]);
1155         phys_proc_id[cpu] = BAD_APICID;
1156         cpu_core_id[cpu] = BAD_APICID;
1157         cpu_clear(cpu, cpu_sibling_setup_map);
1158 }
1159
1160 void remove_cpu_from_maps(void)
1161 {
1162         int cpu = smp_processor_id();
1163
1164         cpu_clear(cpu, cpu_callout_map);
1165         cpu_clear(cpu, cpu_callin_map);
1166         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
1167 }
1168
1169 int __cpu_disable(void)
1170 {
1171         int cpu = smp_processor_id();
1172
1173         /*
1174          * Perhaps use cpufreq to drop frequency, but that could go
1175          * into generic code.
1176          *
1177          * We won't take down the boot processor on i386 due to some
1178          * interrupts only being able to be serviced by the BSP.
1179          * Especially so if we're not using an IOAPIC   -zwane
1180          */
1181         if (cpu == 0)
1182                 return -EBUSY;
1183
1184         disable_APIC_timer();
1185
1186         /*
1187          * HACK:
1188          * Allow any queued timer interrupts to get serviced
1189          * This is only a temporary solution until we cleanup
1190          * fixup_irqs as we do for IA64.
1191          */
1192         local_irq_enable();
1193         mdelay(1);
1194
1195         local_irq_disable();
1196         remove_siblinginfo(cpu);
1197
1198         /* It's now safe to remove this processor from the online map */
1199         cpu_clear(cpu, cpu_online_map);
1200         remove_cpu_from_maps();
1201         fixup_irqs(cpu_online_map);
1202         return 0;
1203 }
1204
1205 void __cpu_die(unsigned int cpu)
1206 {
1207         /* We don't do anything here: idle task is faking death itself. */
1208         unsigned int i;
1209
1210         for (i = 0; i < 10; i++) {
1211                 /* They ack this in play_dead by setting CPU_DEAD */
1212                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1213                         printk ("CPU %d is now offline\n", cpu);
1214                         return;
1215                 }
1216                 msleep(100);
1217         }
1218         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1219 }
1220
1221 static __init int setup_additional_cpus(char *s)
1222 {
1223         return get_option(&s, &additional_cpus);
1224 }
1225 __setup("additional_cpus=", setup_additional_cpus);
1226
1227 #else /* ... !CONFIG_HOTPLUG_CPU */
1228
1229 int __cpu_disable(void)
1230 {
1231         return -ENOSYS;
1232 }
1233
1234 void __cpu_die(unsigned int cpu)
1235 {
1236         /* We said "no" in __cpu_disable */
1237         BUG();
1238 }
1239 #endif /* CONFIG_HOTPLUG_CPU */