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