Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / arch / x86 / kernel / smpboot_32.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  *
7  *      Much of the core SMP work is based on previous work by Thomas Radke, to
8  *      whom a great many thanks are extended.
9  *
10  *      Thanks to Intel for making available several different Pentium,
11  *      Pentium Pro and Pentium-II/Xeon MP machines.
12  *      Original development of Linux SMP code supported by Caldera.
13  *
14  *      This code is released under the GNU General Public License version 2 or
15  *      later.
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 BogoMIPS 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  *              Martin J. Bligh :       Added support for multi-quad systems
33  *              Dave Jones      :       Report invalid combinations of Athlon CPUs.
34 *               Rusty Russell   :       Hacked into shape for new "hotplug" boot process. */
35
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39
40 #include <linux/mm.h>
41 #include <linux/sched.h>
42 #include <linux/kernel_stat.h>
43 #include <linux/bootmem.h>
44 #include <linux/notifier.h>
45 #include <linux/cpu.h>
46 #include <linux/percpu.h>
47 #include <linux/nmi.h>
48
49 #include <linux/delay.h>
50 #include <linux/mc146818rtc.h>
51 #include <asm/tlbflush.h>
52 #include <asm/desc.h>
53 #include <asm/arch_hooks.h>
54 #include <asm/nmi.h>
55
56 #include <mach_apic.h>
57 #include <mach_wakecpu.h>
58 #include <smpboot_hooks.h>
59 #include <asm/vmi.h>
60 #include <asm/mtrr.h>
61
62 /* Set if we find a B stepping CPU */
63 static int __cpuinitdata smp_b_stepping;
64
65 /* Number of siblings per CPU package */
66 int smp_num_siblings = 1;
67 EXPORT_SYMBOL(smp_num_siblings);
68
69 /* Last level cache ID of each logical CPU */
70 DEFINE_PER_CPU(u8, cpu_llc_id) = BAD_APICID;
71
72 /* representing HT siblings of each logical CPU */
73 DEFINE_PER_CPU(cpumask_t, cpu_sibling_map);
74 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
75
76 /* representing HT and core siblings of each logical CPU */
77 DEFINE_PER_CPU(cpumask_t, cpu_core_map);
78 EXPORT_PER_CPU_SYMBOL(cpu_core_map);
79
80 /* bitmap of online cpus */
81 cpumask_t cpu_online_map __read_mostly;
82 EXPORT_SYMBOL(cpu_online_map);
83
84 cpumask_t cpu_callin_map;
85 cpumask_t cpu_callout_map;
86 cpumask_t cpu_possible_map;
87 EXPORT_SYMBOL(cpu_possible_map);
88 static cpumask_t smp_commenced_mask;
89
90 /* Per CPU bogomips and other parameters */
91 DEFINE_PER_CPU_SHARED_ALIGNED(struct cpuinfo_x86, cpu_info);
92 EXPORT_PER_CPU_SYMBOL(cpu_info);
93
94 /* which logical CPU number maps to which CPU (physical APIC ID) */
95 u8 x86_cpu_to_apicid_init[NR_CPUS] __initdata =
96                         { [0 ... NR_CPUS-1] = BAD_APICID };
97 void *x86_cpu_to_apicid_early_ptr;
98 DEFINE_PER_CPU(u8, x86_cpu_to_apicid) = BAD_APICID;
99 EXPORT_PER_CPU_SYMBOL(x86_cpu_to_apicid);
100
101 u8 apicid_2_node[MAX_APICID];
102
103 /*
104  * Trampoline 80x86 program as an array.
105  */
106
107 extern const unsigned char trampoline_data [];
108 extern const unsigned char trampoline_end  [];
109 static unsigned char *trampoline_base;
110
111 static void map_cpu_to_logical_apicid(void);
112
113 /* State of each CPU. */
114 DEFINE_PER_CPU(int, cpu_state) = { 0 };
115
116 /*
117  * Currently trivial. Write the real->protected mode
118  * bootstrap into the page concerned. The caller
119  * has made sure it's suitably aligned.
120  */
121
122 static unsigned long __cpuinit setup_trampoline(void)
123 {
124         memcpy(trampoline_base, trampoline_data, trampoline_end - trampoline_data);
125         return virt_to_phys(trampoline_base);
126 }
127
128 /*
129  * We are called very early to get the low memory for the
130  * SMP bootup trampoline page.
131  */
132 void __init smp_alloc_memory(void)
133 {
134         trampoline_base = alloc_bootmem_low_pages(PAGE_SIZE);
135         /*
136          * Has to be in very low memory so we can execute
137          * real-mode AP code.
138          */
139         if (__pa(trampoline_base) >= 0x9F000)
140                 BUG();
141 }
142
143 /*
144  * The bootstrap kernel entry code has set these up. Save them for
145  * a given CPU
146  */
147
148 void __cpuinit smp_store_cpu_info(int id)
149 {
150         struct cpuinfo_x86 *c = &cpu_data(id);
151
152         *c = boot_cpu_data;
153         c->cpu_index = id;
154         if (id!=0)
155                 identify_secondary_cpu(c);
156         /*
157          * Mask B, Pentium, but not Pentium MMX
158          */
159         if (c->x86_vendor == X86_VENDOR_INTEL &&
160             c->x86 == 5 &&
161             c->x86_mask >= 1 && c->x86_mask <= 4 &&
162             c->x86_model <= 3)
163                 /*
164                  * Remember we have B step Pentia with bugs
165                  */
166                 smp_b_stepping = 1;
167
168         /*
169          * Certain Athlons might work (for various values of 'work') in SMP
170          * but they are not certified as MP capable.
171          */
172         if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) {
173
174                 if (num_possible_cpus() == 1)
175                         goto valid_k7;
176
177                 /* Athlon 660/661 is valid. */  
178                 if ((c->x86_model==6) && ((c->x86_mask==0) || (c->x86_mask==1)))
179                         goto valid_k7;
180
181                 /* Duron 670 is valid */
182                 if ((c->x86_model==7) && (c->x86_mask==0))
183                         goto valid_k7;
184
185                 /*
186                  * Athlon 662, Duron 671, and Athlon >model 7 have capability bit.
187                  * It's worth noting that the A5 stepping (662) of some Athlon XP's
188                  * have the MP bit set.
189                  * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for more.
190                  */
191                 if (((c->x86_model==6) && (c->x86_mask>=2)) ||
192                     ((c->x86_model==7) && (c->x86_mask>=1)) ||
193                      (c->x86_model> 7))
194                         if (cpu_has_mp)
195                                 goto valid_k7;
196
197                 /* If we get here, it's not a certified SMP capable AMD system. */
198                 add_taint(TAINT_UNSAFE_SMP);
199         }
200
201 valid_k7:
202         ;
203 }
204
205 static atomic_t init_deasserted;
206
207 static void __cpuinit smp_callin(void)
208 {
209         int cpuid, phys_id;
210         unsigned long timeout;
211
212         /*
213          * If waken up by an INIT in an 82489DX configuration
214          * we may get here before an INIT-deassert IPI reaches
215          * our local APIC.  We have to wait for the IPI or we'll
216          * lock up on an APIC access.
217          */
218         wait_for_init_deassert(&init_deasserted);
219
220         /*
221          * (This works even if the APIC is not enabled.)
222          */
223         phys_id = GET_APIC_ID(apic_read(APIC_ID));
224         cpuid = smp_processor_id();
225         if (cpu_isset(cpuid, cpu_callin_map)) {
226                 printk("huh, phys CPU#%d, CPU#%d already present??\n",
227                                         phys_id, cpuid);
228                 BUG();
229         }
230         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
231
232         /*
233          * STARTUP IPIs are fragile beasts as they might sometimes
234          * trigger some glue motherboard logic. Complete APIC bus
235          * silence for 1 second, this overestimates the time the
236          * boot CPU is spending to send the up to 2 STARTUP IPIs
237          * by a factor of two. This should be enough.
238          */
239
240         /*
241          * Waiting 2s total for startup (udelay is not yet working)
242          */
243         timeout = jiffies + 2*HZ;
244         while (time_before(jiffies, timeout)) {
245                 /*
246                  * Has the boot CPU finished it's STARTUP sequence?
247                  */
248                 if (cpu_isset(cpuid, cpu_callout_map))
249                         break;
250                 rep_nop();
251         }
252
253         if (!time_before(jiffies, timeout)) {
254                 printk("BUG: CPU%d started up but did not get a callout!\n",
255                         cpuid);
256                 BUG();
257         }
258
259         /*
260          * the boot CPU has finished the init stage and is spinning
261          * on callin_map until we finish. We are free to set up this
262          * CPU, first the APIC. (this is probably redundant on most
263          * boards)
264          */
265
266         Dprintk("CALLIN, before setup_local_APIC().\n");
267         smp_callin_clear_local_apic();
268         setup_local_APIC();
269         map_cpu_to_logical_apicid();
270
271         /*
272          * Get our bogomips.
273          */
274         calibrate_delay();
275         Dprintk("Stack at about %p\n",&cpuid);
276
277         /*
278          * Save our processor parameters
279          */
280         smp_store_cpu_info(cpuid);
281
282         /*
283          * Allow the master to continue.
284          */
285         cpu_set(cpuid, cpu_callin_map);
286 }
287
288 static int cpucount;
289
290 /* maps the cpu to the sched domain representing multi-core */
291 cpumask_t cpu_coregroup_map(int cpu)
292 {
293         struct cpuinfo_x86 *c = &cpu_data(cpu);
294         /*
295          * For perf, we return last level cache shared map.
296          * And for power savings, we return cpu_core_map
297          */
298         if (sched_mc_power_savings || sched_smt_power_savings)
299                 return per_cpu(cpu_core_map, cpu);
300         else
301                 return c->llc_shared_map;
302 }
303
304 /* representing cpus for which sibling maps can be computed */
305 static cpumask_t cpu_sibling_setup_map;
306
307 void __cpuinit set_cpu_sibling_map(int cpu)
308 {
309         int i;
310         struct cpuinfo_x86 *c = &cpu_data(cpu);
311
312         cpu_set(cpu, cpu_sibling_setup_map);
313
314         if (smp_num_siblings > 1) {
315                 for_each_cpu_mask(i, cpu_sibling_setup_map) {
316                         if (c->phys_proc_id == cpu_data(i).phys_proc_id &&
317                             c->cpu_core_id == cpu_data(i).cpu_core_id) {
318                                 cpu_set(i, per_cpu(cpu_sibling_map, cpu));
319                                 cpu_set(cpu, per_cpu(cpu_sibling_map, i));
320                                 cpu_set(i, per_cpu(cpu_core_map, cpu));
321                                 cpu_set(cpu, per_cpu(cpu_core_map, i));
322                                 cpu_set(i, c->llc_shared_map);
323                                 cpu_set(cpu, cpu_data(i).llc_shared_map);
324                         }
325                 }
326         } else {
327                 cpu_set(cpu, per_cpu(cpu_sibling_map, cpu));
328         }
329
330         cpu_set(cpu, c->llc_shared_map);
331
332         if (current_cpu_data.x86_max_cores == 1) {
333                 per_cpu(cpu_core_map, cpu) = per_cpu(cpu_sibling_map, cpu);
334                 c->booted_cores = 1;
335                 return;
336         }
337
338         for_each_cpu_mask(i, cpu_sibling_setup_map) {
339                 if (per_cpu(cpu_llc_id, cpu) != BAD_APICID &&
340                     per_cpu(cpu_llc_id, cpu) == per_cpu(cpu_llc_id, i)) {
341                         cpu_set(i, c->llc_shared_map);
342                         cpu_set(cpu, cpu_data(i).llc_shared_map);
343                 }
344                 if (c->phys_proc_id == cpu_data(i).phys_proc_id) {
345                         cpu_set(i, per_cpu(cpu_core_map, cpu));
346                         cpu_set(cpu, per_cpu(cpu_core_map, i));
347                         /*
348                          *  Does this new cpu bringup a new core?
349                          */
350                         if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1) {
351                                 /*
352                                  * for each core in package, increment
353                                  * the booted_cores for this new cpu
354                                  */
355                                 if (first_cpu(per_cpu(cpu_sibling_map, i)) == i)
356                                         c->booted_cores++;
357                                 /*
358                                  * increment the core count for all
359                                  * the other cpus in this package
360                                  */
361                                 if (i != cpu)
362                                         cpu_data(i).booted_cores++;
363                         } else if (i != cpu && !c->booted_cores)
364                                 c->booted_cores = cpu_data(i).booted_cores;
365                 }
366         }
367 }
368
369 /*
370  * Activate a secondary processor.
371  */
372 static void __cpuinit start_secondary(void *unused)
373 {
374         /*
375          * Don't put *anything* before cpu_init(), SMP booting is too
376          * fragile that we want to limit the things done here to the
377          * most necessary things.
378          */
379 #ifdef CONFIG_VMI
380         vmi_bringup();
381 #endif
382         cpu_init();
383         preempt_disable();
384         smp_callin();
385         while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
386                 rep_nop();
387         /*
388          * Check TSC synchronization with the BP:
389          */
390         check_tsc_sync_target();
391
392         setup_secondary_clock();
393         if (nmi_watchdog == NMI_IO_APIC) {
394                 disable_8259A_irq(0);
395                 enable_NMI_through_LVT0();
396                 enable_8259A_irq(0);
397         }
398         /*
399          * low-memory mappings have been cleared, flush them from
400          * the local TLBs too.
401          */
402         local_flush_tlb();
403
404         /* This must be done before setting cpu_online_map */
405         set_cpu_sibling_map(raw_smp_processor_id());
406         wmb();
407
408         /*
409          * We need to hold call_lock, so there is no inconsistency
410          * between the time smp_call_function() determines number of
411          * IPI recipients, and the time when the determination is made
412          * for which cpus receive the IPI. Holding this
413          * lock helps us to not include this cpu in a currently in progress
414          * smp_call_function().
415          */
416         lock_ipi_call_lock();
417         cpu_set(smp_processor_id(), cpu_online_map);
418         unlock_ipi_call_lock();
419         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
420
421         /* We can take interrupts now: we're officially "up". */
422         local_irq_enable();
423
424         wmb();
425         cpu_idle();
426 }
427
428 /*
429  * Everything has been set up for the secondary
430  * CPUs - they just need to reload everything
431  * from the task structure
432  * This function must not return.
433  */
434 void __devinit initialize_secondary(void)
435 {
436         /*
437          * We don't actually need to load the full TSS,
438          * basically just the stack pointer and the ip.
439          */
440
441         asm volatile(
442                 "movl %0,%%esp\n\t"
443                 "jmp *%1"
444                 :
445                 :"m" (current->thread.sp),"m" (current->thread.ip));
446 }
447
448 /* Static state in head.S used to set up a CPU */
449 extern struct {
450         void * sp;
451         unsigned short ss;
452 } stack_start;
453
454 #ifdef CONFIG_NUMA
455
456 /* which logical CPUs are on which nodes */
457 cpumask_t node_to_cpumask_map[MAX_NUMNODES] __read_mostly =
458                                 { [0 ... MAX_NUMNODES-1] = CPU_MASK_NONE };
459 EXPORT_SYMBOL(node_to_cpumask_map);
460 /* which node each logical CPU is on */
461 int cpu_to_node_map[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = 0 };
462 EXPORT_SYMBOL(cpu_to_node_map);
463
464 /* set up a mapping between cpu and node. */
465 static inline void map_cpu_to_node(int cpu, int node)
466 {
467         printk("Mapping cpu %d to node %d\n", cpu, node);
468         cpu_set(cpu, node_to_cpumask_map[node]);
469         cpu_to_node_map[cpu] = node;
470 }
471
472 /* undo a mapping between cpu and node. */
473 static inline void unmap_cpu_to_node(int cpu)
474 {
475         int node;
476
477         printk("Unmapping cpu %d from all nodes\n", cpu);
478         for (node = 0; node < MAX_NUMNODES; node ++)
479                 cpu_clear(cpu, node_to_cpumask_map[node]);
480         cpu_to_node_map[cpu] = 0;
481 }
482 #else /* !CONFIG_NUMA */
483
484 #define map_cpu_to_node(cpu, node)      ({})
485 #define unmap_cpu_to_node(cpu)  ({})
486
487 #endif /* CONFIG_NUMA */
488
489 u8 cpu_2_logical_apicid[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
490
491 static void map_cpu_to_logical_apicid(void)
492 {
493         int cpu = smp_processor_id();
494         int apicid = logical_smp_processor_id();
495         int node = apicid_to_node(apicid);
496
497         if (!node_online(node))
498                 node = first_online_node;
499
500         cpu_2_logical_apicid[cpu] = apicid;
501         map_cpu_to_node(cpu, node);
502 }
503
504 static void unmap_cpu_to_logical_apicid(int cpu)
505 {
506         cpu_2_logical_apicid[cpu] = BAD_APICID;
507         unmap_cpu_to_node(cpu);
508 }
509
510 static inline void __inquire_remote_apic(int apicid)
511 {
512         int i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
513         char *names[] = { "ID", "VERSION", "SPIV" };
514         int timeout;
515         unsigned long status;
516
517         printk("Inquiring remote APIC #%d...\n", apicid);
518
519         for (i = 0; i < ARRAY_SIZE(regs); i++) {
520                 printk("... APIC #%d %s: ", apicid, names[i]);
521
522                 /*
523                  * Wait for idle.
524                  */
525                 status = safe_apic_wait_icr_idle();
526                 if (status)
527                         printk("a previous APIC delivery may have failed\n");
528
529                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
530                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
531
532                 timeout = 0;
533                 do {
534                         udelay(100);
535                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
536                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
537
538                 switch (status) {
539                 case APIC_ICR_RR_VALID:
540                         status = apic_read(APIC_RRR);
541                         printk("%lx\n", status);
542                         break;
543                 default:
544                         printk("failed\n");
545                 }
546         }
547 }
548
549 #ifdef WAKE_SECONDARY_VIA_NMI
550 /* 
551  * Poke the other CPU in the eye via NMI to wake it up. Remember that the normal
552  * INIT, INIT, STARTUP sequence will reset the chip hard for us, and this
553  * won't ... remember to clear down the APIC, etc later.
554  */
555 static int __devinit
556 wakeup_secondary_cpu(int logical_apicid, unsigned long start_eip)
557 {
558         unsigned long send_status, accept_status = 0;
559         int maxlvt;
560
561         /* Target chip */
562         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(logical_apicid));
563
564         /* Boot on the stack */
565         /* Kick the second */
566         apic_write_around(APIC_ICR, APIC_DM_NMI | APIC_DEST_LOGICAL);
567
568         Dprintk("Waiting for send to finish...\n");
569         send_status = safe_apic_wait_icr_idle();
570
571         /*
572          * Give the other CPU some time to accept the IPI.
573          */
574         udelay(200);
575         /*
576          * Due to the Pentium erratum 3AP.
577          */
578         maxlvt = lapic_get_maxlvt();
579         if (maxlvt > 3) {
580                 apic_read_around(APIC_SPIV);
581                 apic_write(APIC_ESR, 0);
582         }
583         accept_status = (apic_read(APIC_ESR) & 0xEF);
584         Dprintk("NMI sent.\n");
585
586         if (send_status)
587                 printk("APIC never delivered???\n");
588         if (accept_status)
589                 printk("APIC delivery error (%lx).\n", accept_status);
590
591         return (send_status | accept_status);
592 }
593 #endif  /* WAKE_SECONDARY_VIA_NMI */
594
595 #ifdef WAKE_SECONDARY_VIA_INIT
596 static int __devinit
597 wakeup_secondary_cpu(int phys_apicid, unsigned long start_eip)
598 {
599         unsigned long send_status, accept_status = 0;
600         int maxlvt, num_starts, j;
601
602         /*
603          * Be paranoid about clearing APIC errors.
604          */
605         if (APIC_INTEGRATED(apic_version[phys_apicid])) {
606                 apic_read_around(APIC_SPIV);
607                 apic_write(APIC_ESR, 0);
608                 apic_read(APIC_ESR);
609         }
610
611         Dprintk("Asserting INIT.\n");
612
613         /*
614          * Turn INIT on target chip
615          */
616         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
617
618         /*
619          * Send IPI
620          */
621         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
622                                 | APIC_DM_INIT);
623
624         Dprintk("Waiting for send to finish...\n");
625         send_status = safe_apic_wait_icr_idle();
626
627         mdelay(10);
628
629         Dprintk("Deasserting INIT.\n");
630
631         /* Target chip */
632         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
633
634         /* Send IPI */
635         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
636
637         Dprintk("Waiting for send to finish...\n");
638         send_status = safe_apic_wait_icr_idle();
639
640         atomic_set(&init_deasserted, 1);
641
642         /*
643          * Should we send STARTUP IPIs ?
644          *
645          * Determine this based on the APIC version.
646          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
647          */
648         if (APIC_INTEGRATED(apic_version[phys_apicid]))
649                 num_starts = 2;
650         else
651                 num_starts = 0;
652
653         /*
654          * Paravirt / VMI wants a startup IPI hook here to set up the
655          * target processor state.
656          */
657         startup_ipi_hook(phys_apicid, (unsigned long) start_secondary,
658                          (unsigned long) stack_start.sp);
659
660         /*
661          * Run STARTUP IPI loop.
662          */
663         Dprintk("#startup loops: %d.\n", num_starts);
664
665         maxlvt = lapic_get_maxlvt();
666
667         for (j = 1; j <= num_starts; j++) {
668                 Dprintk("Sending STARTUP #%d.\n",j);
669                 apic_read_around(APIC_SPIV);
670                 apic_write(APIC_ESR, 0);
671                 apic_read(APIC_ESR);
672                 Dprintk("After apic_write.\n");
673
674                 /*
675                  * STARTUP IPI
676                  */
677
678                 /* Target chip */
679                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
680
681                 /* Boot on the stack */
682                 /* Kick the second */
683                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
684                                         | (start_eip >> 12));
685
686                 /*
687                  * Give the other CPU some time to accept the IPI.
688                  */
689                 udelay(300);
690
691                 Dprintk("Startup point 1.\n");
692
693                 Dprintk("Waiting for send to finish...\n");
694                 send_status = safe_apic_wait_icr_idle();
695
696                 /*
697                  * Give the other CPU some time to accept the IPI.
698                  */
699                 udelay(200);
700                 /*
701                  * Due to the Pentium erratum 3AP.
702                  */
703                 if (maxlvt > 3) {
704                         apic_read_around(APIC_SPIV);
705                         apic_write(APIC_ESR, 0);
706                 }
707                 accept_status = (apic_read(APIC_ESR) & 0xEF);
708                 if (send_status || accept_status)
709                         break;
710         }
711         Dprintk("After Startup.\n");
712
713         if (send_status)
714                 printk("APIC never delivered???\n");
715         if (accept_status)
716                 printk("APIC delivery error (%lx).\n", accept_status);
717
718         return (send_status | accept_status);
719 }
720 #endif  /* WAKE_SECONDARY_VIA_INIT */
721
722 extern cpumask_t cpu_initialized;
723 static inline int alloc_cpu_id(void)
724 {
725         cpumask_t       tmp_map;
726         int cpu;
727         cpus_complement(tmp_map, cpu_present_map);
728         cpu = first_cpu(tmp_map);
729         if (cpu >= NR_CPUS)
730                 return -ENODEV;
731         return cpu;
732 }
733
734 #ifdef CONFIG_HOTPLUG_CPU
735 static struct task_struct * __cpuinitdata cpu_idle_tasks[NR_CPUS];
736 static inline struct task_struct * __cpuinit alloc_idle_task(int cpu)
737 {
738         struct task_struct *idle;
739
740         if ((idle = cpu_idle_tasks[cpu]) != NULL) {
741                 /* initialize thread_struct.  we really want to avoid destroy
742                  * idle tread
743                  */
744                 idle->thread.sp = (unsigned long)task_pt_regs(idle);
745                 init_idle(idle, cpu);
746                 return idle;
747         }
748         idle = fork_idle(cpu);
749
750         if (!IS_ERR(idle))
751                 cpu_idle_tasks[cpu] = idle;
752         return idle;
753 }
754 #else
755 #define alloc_idle_task(cpu) fork_idle(cpu)
756 #endif
757
758 static int __cpuinit do_boot_cpu(int apicid, int cpu)
759 /*
760  * NOTE - on most systems this is a PHYSICAL apic ID, but on multiquad
761  * (ie clustered apic addressing mode), this is a LOGICAL apic ID.
762  * Returns zero if CPU booted OK, else error code from wakeup_secondary_cpu.
763  */
764 {
765         struct task_struct *idle;
766         unsigned long boot_error;
767         int timeout;
768         unsigned long start_eip;
769         unsigned short nmi_high = 0, nmi_low = 0;
770
771         /*
772          * Save current MTRR state in case it was changed since early boot
773          * (e.g. by the ACPI SMI) to initialize new CPUs with MTRRs in sync:
774          */
775         mtrr_save_state();
776
777         /*
778          * We can't use kernel_thread since we must avoid to
779          * reschedule the child.
780          */
781         idle = alloc_idle_task(cpu);
782         if (IS_ERR(idle))
783                 panic("failed fork for CPU %d", cpu);
784
785         init_gdt(cpu);
786         per_cpu(current_task, cpu) = idle;
787         early_gdt_descr.address = (unsigned long)get_cpu_gdt_table(cpu);
788
789         idle->thread.ip = (unsigned long) start_secondary;
790         /* start_eip had better be page-aligned! */
791         start_eip = setup_trampoline();
792
793         ++cpucount;
794         alternatives_smp_switch(1);
795
796         /* So we see what's up   */
797         printk("Booting processor %d/%d ip %lx\n", cpu, apicid, start_eip);
798         /* Stack for startup_32 can be just as for start_secondary onwards */
799         stack_start.sp = (void *) idle->thread.sp;
800
801         irq_ctx_init(cpu);
802
803         per_cpu(x86_cpu_to_apicid, cpu) = apicid;
804         /*
805          * This grunge runs the startup process for
806          * the targeted processor.
807          */
808
809         atomic_set(&init_deasserted, 0);
810
811         Dprintk("Setting warm reset code and vector.\n");
812
813         store_NMI_vector(&nmi_high, &nmi_low);
814
815         smpboot_setup_warm_reset_vector(start_eip);
816
817         /*
818          * Starting actual IPI sequence...
819          */
820         boot_error = wakeup_secondary_cpu(apicid, start_eip);
821
822         if (!boot_error) {
823                 /*
824                  * allow APs to start initializing.
825                  */
826                 Dprintk("Before Callout %d.\n", cpu);
827                 cpu_set(cpu, cpu_callout_map);
828                 Dprintk("After Callout %d.\n", cpu);
829
830                 /*
831                  * Wait 5s total for a response
832                  */
833                 for (timeout = 0; timeout < 50000; timeout++) {
834                         if (cpu_isset(cpu, cpu_callin_map))
835                                 break;  /* It has booted */
836                         udelay(100);
837                 }
838
839                 if (cpu_isset(cpu, cpu_callin_map)) {
840                         /* number CPUs logically, starting from 1 (BSP is 0) */
841                         Dprintk("OK.\n");
842                         printk("CPU%d: ", cpu);
843                         print_cpu_info(&cpu_data(cpu));
844                         Dprintk("CPU has booted.\n");
845                 } else {
846                         boot_error= 1;
847                         if (*((volatile unsigned char *)trampoline_base)
848                                         == 0xA5)
849                                 /* trampoline started but...? */
850                                 printk("Stuck ??\n");
851                         else
852                                 /* trampoline code not run */
853                                 printk("Not responding.\n");
854                         inquire_remote_apic(apicid);
855                 }
856         }
857
858         if (boot_error) {
859                 /* Try to put things back the way they were before ... */
860                 unmap_cpu_to_logical_apicid(cpu);
861                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
862                 cpu_clear(cpu, cpu_initialized); /* was set by cpu_init() */
863                 cpucount--;
864         } else {
865                 per_cpu(x86_cpu_to_apicid, cpu) = apicid;
866                 cpu_set(cpu, cpu_present_map);
867         }
868
869         /* mark "stuck" area as not stuck */
870         *((volatile unsigned long *)trampoline_base) = 0;
871
872         return boot_error;
873 }
874
875 #ifdef CONFIG_HOTPLUG_CPU
876 void cpu_exit_clear(void)
877 {
878         int cpu = raw_smp_processor_id();
879
880         idle_task_exit();
881
882         cpucount --;
883         cpu_uninit();
884         irq_ctx_exit(cpu);
885
886         cpu_clear(cpu, cpu_callout_map);
887         cpu_clear(cpu, cpu_callin_map);
888
889         cpu_clear(cpu, smp_commenced_mask);
890         unmap_cpu_to_logical_apicid(cpu);
891 }
892
893 struct warm_boot_cpu_info {
894         struct completion *complete;
895         struct work_struct task;
896         int apicid;
897         int cpu;
898 };
899
900 static void __cpuinit do_warm_boot_cpu(struct work_struct *work)
901 {
902         struct warm_boot_cpu_info *info =
903                 container_of(work, struct warm_boot_cpu_info, task);
904         do_boot_cpu(info->apicid, info->cpu);
905         complete(info->complete);
906 }
907
908 static int __cpuinit __smp_prepare_cpu(int cpu)
909 {
910         DECLARE_COMPLETION_ONSTACK(done);
911         struct warm_boot_cpu_info info;
912         int     apicid, ret;
913
914         apicid = per_cpu(x86_cpu_to_apicid, cpu);
915         if (apicid == BAD_APICID) {
916                 ret = -ENODEV;
917                 goto exit;
918         }
919
920         info.complete = &done;
921         info.apicid = apicid;
922         info.cpu = cpu;
923         INIT_WORK(&info.task, do_warm_boot_cpu);
924
925         /* init low mem mapping */
926         clone_pgd_range(swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
927                         min_t(unsigned long, KERNEL_PGD_PTRS, USER_PGD_PTRS));
928         flush_tlb_all();
929         schedule_work(&info.task);
930         wait_for_completion(&done);
931
932         zap_low_mappings();
933         ret = 0;
934 exit:
935         return ret;
936 }
937 #endif
938
939 /*
940  * Cycle through the processors sending APIC IPIs to boot each.
941  */
942
943 static int boot_cpu_logical_apicid;
944 /* Where the IO area was mapped on multiquad, always 0 otherwise */
945 void *xquad_portio;
946 #ifdef CONFIG_X86_NUMAQ
947 EXPORT_SYMBOL(xquad_portio);
948 #endif
949
950 static void __init smp_boot_cpus(unsigned int max_cpus)
951 {
952         int apicid, cpu, bit, kicked;
953         unsigned long bogosum = 0;
954
955         /*
956          * Setup boot CPU information
957          */
958         smp_store_cpu_info(0); /* Final full version of the data */
959         printk("CPU%d: ", 0);
960         print_cpu_info(&cpu_data(0));
961
962         boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
963         boot_cpu_logical_apicid = logical_smp_processor_id();
964         per_cpu(x86_cpu_to_apicid, 0) = boot_cpu_physical_apicid;
965
966         current_thread_info()->cpu = 0;
967
968         set_cpu_sibling_map(0);
969
970         /*
971          * If we couldn't find an SMP configuration at boot time,
972          * get out of here now!
973          */
974         if (!smp_found_config && !acpi_lapic) {
975                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
976                 smpboot_clear_io_apic_irqs();
977                 phys_cpu_present_map = physid_mask_of_physid(0);
978                 if (APIC_init_uniprocessor())
979                         printk(KERN_NOTICE "Local APIC not detected."
980                                            " Using dummy APIC emulation.\n");
981                 map_cpu_to_logical_apicid();
982                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
983                 cpu_set(0, per_cpu(cpu_core_map, 0));
984                 return;
985         }
986
987         /*
988          * Should not be necessary because the MP table should list the boot
989          * CPU too, but we do it for the sake of robustness anyway.
990          * Makes no sense to do this check in clustered apic mode, so skip it
991          */
992         if (!check_phys_apicid_present(boot_cpu_physical_apicid)) {
993                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
994                                 boot_cpu_physical_apicid);
995                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
996         }
997
998         /*
999          * If we couldn't find a local APIC, then get out of here now!
1000          */
1001         if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid]) && !cpu_has_apic) {
1002                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
1003                         boot_cpu_physical_apicid);
1004                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
1005                 smpboot_clear_io_apic_irqs();
1006                 phys_cpu_present_map = physid_mask_of_physid(0);
1007                 map_cpu_to_logical_apicid();
1008                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
1009                 cpu_set(0, per_cpu(cpu_core_map, 0));
1010                 return;
1011         }
1012
1013         verify_local_APIC();
1014
1015         /*
1016          * If SMP should be disabled, then really disable it!
1017          */
1018         if (!max_cpus) {
1019                 smp_found_config = 0;
1020                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
1021
1022                 if (nmi_watchdog == NMI_LOCAL_APIC) {
1023                         printk(KERN_INFO "activating minimal APIC for NMI watchdog use.\n");
1024                         connect_bsp_APIC();
1025                         setup_local_APIC();
1026                 }
1027                 smpboot_clear_io_apic_irqs();
1028                 phys_cpu_present_map = physid_mask_of_physid(0);
1029                 map_cpu_to_logical_apicid();
1030                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
1031                 cpu_set(0, per_cpu(cpu_core_map, 0));
1032                 return;
1033         }
1034
1035         connect_bsp_APIC();
1036         setup_local_APIC();
1037         map_cpu_to_logical_apicid();
1038
1039
1040         setup_portio_remap();
1041
1042         /*
1043          * Scan the CPU present map and fire up the other CPUs via do_boot_cpu
1044          *
1045          * In clustered apic mode, phys_cpu_present_map is a constructed thus:
1046          * bits 0-3 are quad0, 4-7 are quad1, etc. A perverse twist on the 
1047          * clustered apic ID.
1048          */
1049         Dprintk("CPU present map: %lx\n", physids_coerce(phys_cpu_present_map));
1050
1051         kicked = 1;
1052         for (bit = 0; kicked < NR_CPUS && bit < MAX_APICS; bit++) {
1053                 apicid = cpu_present_to_apicid(bit);
1054                 /*
1055                  * Don't even attempt to start the boot CPU!
1056                  */
1057                 if ((apicid == boot_cpu_apicid) || (apicid == BAD_APICID))
1058                         continue;
1059
1060                 if (!check_apicid_present(bit))
1061                         continue;
1062                 if (max_cpus <= cpucount+1)
1063                         continue;
1064
1065                 if (((cpu = alloc_cpu_id()) <= 0) || do_boot_cpu(apicid, cpu))
1066                         printk("CPU #%d not responding - cannot use it.\n",
1067                                                                 apicid);
1068                 else
1069                         ++kicked;
1070         }
1071
1072         /*
1073          * Cleanup possible dangling ends...
1074          */
1075         smpboot_restore_warm_reset_vector();
1076
1077         /*
1078          * Allow the user to impress friends.
1079          */
1080         Dprintk("Before bogomips.\n");
1081         for_each_possible_cpu(cpu)
1082                 if (cpu_isset(cpu, cpu_callout_map))
1083                         bogosum += cpu_data(cpu).loops_per_jiffy;
1084         printk(KERN_INFO
1085                 "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
1086                 cpucount+1,
1087                 bogosum/(500000/HZ),
1088                 (bogosum/(5000/HZ))%100);
1089         
1090         Dprintk("Before bogocount - setting activated=1.\n");
1091
1092         if (smp_b_stepping)
1093                 printk(KERN_WARNING "WARNING: SMP operation may be unreliable with B stepping processors.\n");
1094
1095         /*
1096          * Don't taint if we are running SMP kernel on a single non-MP
1097          * approved Athlon
1098          */
1099         if (tainted & TAINT_UNSAFE_SMP) {
1100                 if (cpucount)
1101                         printk (KERN_INFO "WARNING: This combination of AMD processors is not suitable for SMP.\n");
1102                 else
1103                         tainted &= ~TAINT_UNSAFE_SMP;
1104         }
1105
1106         Dprintk("Boot done.\n");
1107
1108         /*
1109          * construct cpu_sibling_map, so that we can tell sibling CPUs
1110          * efficiently.
1111          */
1112         for_each_possible_cpu(cpu) {
1113                 cpus_clear(per_cpu(cpu_sibling_map, cpu));
1114                 cpus_clear(per_cpu(cpu_core_map, cpu));
1115         }
1116
1117         cpu_set(0, per_cpu(cpu_sibling_map, 0));
1118         cpu_set(0, per_cpu(cpu_core_map, 0));
1119
1120         smpboot_setup_io_apic();
1121
1122         setup_boot_clock();
1123 }
1124
1125 /* These are wrappers to interface to the new boot process.  Someone
1126    who understands all this stuff should rewrite it properly. --RR 15/Jul/02 */
1127 void __init native_smp_prepare_cpus(unsigned int max_cpus)
1128 {
1129         smp_commenced_mask = cpumask_of_cpu(0);
1130         cpu_callin_map = cpumask_of_cpu(0);
1131         mb();
1132         smp_boot_cpus(max_cpus);
1133 }
1134
1135 void __init native_smp_prepare_boot_cpu(void)
1136 {
1137         unsigned int cpu = smp_processor_id();
1138
1139         init_gdt(cpu);
1140         switch_to_new_gdt();
1141
1142         cpu_set(cpu, cpu_online_map);
1143         cpu_set(cpu, cpu_callout_map);
1144         cpu_set(cpu, cpu_present_map);
1145         cpu_set(cpu, cpu_possible_map);
1146         __get_cpu_var(cpu_state) = CPU_ONLINE;
1147 }
1148
1149 #ifdef CONFIG_HOTPLUG_CPU
1150 void remove_siblinginfo(int cpu)
1151 {
1152         int sibling;
1153         struct cpuinfo_x86 *c = &cpu_data(cpu);
1154
1155         for_each_cpu_mask(sibling, per_cpu(cpu_core_map, cpu)) {
1156                 cpu_clear(cpu, per_cpu(cpu_core_map, sibling));
1157                 /*/
1158                  * last thread sibling in this cpu core going down
1159                  */
1160                 if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1)
1161                         cpu_data(sibling).booted_cores--;
1162         }
1163                         
1164         for_each_cpu_mask(sibling, per_cpu(cpu_sibling_map, cpu))
1165                 cpu_clear(cpu, per_cpu(cpu_sibling_map, sibling));
1166         cpus_clear(per_cpu(cpu_sibling_map, cpu));
1167         cpus_clear(per_cpu(cpu_core_map, cpu));
1168         c->phys_proc_id = 0;
1169         c->cpu_core_id = 0;
1170         cpu_clear(cpu, cpu_sibling_setup_map);
1171 }
1172
1173 int __cpu_disable(void)
1174 {
1175         cpumask_t map = cpu_online_map;
1176         int cpu = smp_processor_id();
1177
1178         /*
1179          * Perhaps use cpufreq to drop frequency, but that could go
1180          * into generic code.
1181          *
1182          * We won't take down the boot processor on i386 due to some
1183          * interrupts only being able to be serviced by the BSP.
1184          * Especially so if we're not using an IOAPIC   -zwane
1185          */
1186         if (cpu == 0)
1187                 return -EBUSY;
1188         if (nmi_watchdog == NMI_LOCAL_APIC)
1189                 stop_apic_nmi_watchdog(NULL);
1190         clear_local_APIC();
1191         /* Allow any queued timer interrupts to get serviced */
1192         local_irq_enable();
1193         mdelay(1);
1194         local_irq_disable();
1195
1196         remove_siblinginfo(cpu);
1197
1198         cpu_clear(cpu, map);
1199         fixup_irqs(map);
1200         /* It's now safe to remove this processor from the online map */
1201         cpu_clear(cpu, cpu_online_map);
1202         return 0;
1203 }
1204
1205 void __cpu_die(unsigned int cpu)
1206 {
1207         /* We don't do anything here: idle task is faking death itself. */
1208         unsigned int i;
1209
1210         for (i = 0; i < 10; i++) {
1211                 /* They ack this in play_dead by setting CPU_DEAD */
1212                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1213                         printk ("CPU %d is now offline\n", cpu);
1214                         if (1 == num_online_cpus())
1215                                 alternatives_smp_switch(0);
1216                         return;
1217                 }
1218                 msleep(100);
1219         }
1220         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1221 }
1222 #else /* ... !CONFIG_HOTPLUG_CPU */
1223 int __cpu_disable(void)
1224 {
1225         return -ENOSYS;
1226 }
1227
1228 void __cpu_die(unsigned int cpu)
1229 {
1230         /* We said "no" in __cpu_disable */
1231         BUG();
1232 }
1233 #endif /* CONFIG_HOTPLUG_CPU */
1234
1235 int __cpuinit native_cpu_up(unsigned int cpu)
1236 {
1237         unsigned long flags;
1238 #ifdef CONFIG_HOTPLUG_CPU
1239         int ret = 0;
1240
1241         /*
1242          * We do warm boot only on cpus that had booted earlier
1243          * Otherwise cold boot is all handled from smp_boot_cpus().
1244          * cpu_callin_map is set during AP kickstart process. Its reset
1245          * when a cpu is taken offline from cpu_exit_clear().
1246          */
1247         if (!cpu_isset(cpu, cpu_callin_map))
1248                 ret = __smp_prepare_cpu(cpu);
1249
1250         if (ret)
1251                 return -EIO;
1252 #endif
1253
1254         /* In case one didn't come up */
1255         if (!cpu_isset(cpu, cpu_callin_map)) {
1256                 printk(KERN_DEBUG "skipping cpu%d, didn't come online\n", cpu);
1257                 return -EIO;
1258         }
1259
1260         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1261         /* Unleash the CPU! */
1262         cpu_set(cpu, smp_commenced_mask);
1263
1264         /*
1265          * Check TSC synchronization with the AP (keep irqs disabled
1266          * while doing so):
1267          */
1268         local_irq_save(flags);
1269         check_tsc_sync_source(cpu);
1270         local_irq_restore(flags);
1271
1272         while (!cpu_isset(cpu, cpu_online_map)) {
1273                 cpu_relax();
1274                 touch_nmi_watchdog();
1275         }
1276
1277         return 0;
1278 }
1279
1280 void __init native_smp_cpus_done(unsigned int max_cpus)
1281 {
1282 #ifdef CONFIG_X86_IO_APIC
1283         setup_ioapic_dest();
1284 #endif
1285         zap_low_mappings();
1286 }
1287
1288 void __init smp_intr_init(void)
1289 {
1290         /*
1291          * IRQ0 must be given a fixed assignment and initialized,
1292          * because it's used before the IO-APIC is set up.
1293          */
1294         set_intr_gate(FIRST_DEVICE_VECTOR, interrupt[0]);
1295
1296         /*
1297          * The reschedule interrupt is a CPU-to-CPU reschedule-helper
1298          * IPI, driven by wakeup.
1299          */
1300         set_intr_gate(RESCHEDULE_VECTOR, reschedule_interrupt);
1301
1302         /* IPI for invalidation */
1303         set_intr_gate(INVALIDATE_TLB_VECTOR, invalidate_interrupt);
1304
1305         /* IPI for generic function call */
1306         set_intr_gate(CALL_FUNCTION_VECTOR, call_function_interrupt);
1307 }
1308
1309 /*
1310  * If the BIOS enumerates physical processors before logical,
1311  * maxcpus=N at enumeration-time can be used to disable HT.
1312  */
1313 static int __init parse_maxcpus(char *arg)
1314 {
1315         extern unsigned int maxcpus;
1316
1317         maxcpus = simple_strtoul(arg, NULL, 0);
1318         return 0;
1319 }
1320 early_param("maxcpus", parse_maxcpus);