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