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