[PATCH] 2.5.6-pre2 I: 2.2.19-pre2 SYNC
[opensuse:kernel.git] / arch / i386 / 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  *
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 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  *              Martin J. Bligh :       Added support for multi-quad systems
33  *              Dave Jones      :       Report invalid combinations of Athlon CPUs.
34  */
35
36 #include <linux/config.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39
40 #include <linux/mm.h>
41 #include <linux/kernel_stat.h>
42 #include <linux/smp_lock.h>
43 #include <linux/irq.h>
44 #include <linux/bootmem.h>
45
46 #include <linux/delay.h>
47 #include <linux/mc146818rtc.h>
48 #include <asm/mtrr.h>
49 #include <asm/pgalloc.h>
50 #include <asm/smpboot.h>
51
52 /* Set if we find a B stepping CPU                      */
53 static int smp_b_stepping;
54
55 /* Setup configured maximum number of CPUs to activate */
56 static int max_cpus = -1;
57
58 /* Total count of live CPUs */
59 int smp_num_cpus = 1;
60
61 /* Number of siblings per CPU package */
62 int smp_num_siblings = 1;
63 int __initdata phys_proc_id[NR_CPUS]; /* Package ID of each logical CPU */
64
65 /* Bitmask of currently online CPUs */
66 unsigned long cpu_online_map;
67
68 static volatile unsigned long cpu_callin_map;
69 static volatile unsigned long cpu_callout_map;
70
71 /* Per CPU bogomips and other parameters */
72 struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
73
74 /* Set when the idlers are all forked */
75 int smp_threads_ready;
76
77 /*
78  * Setup routine for controlling SMP activation
79  *
80  * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
81  * activation entirely (the MPS table probe still happens, though).
82  *
83  * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
84  * greater than 0, limits the maximum number of CPUs activated in
85  * SMP mode to <NUM>.
86  */
87
88 static int __init nosmp(char *str)
89 {
90         max_cpus = 0;
91         return 1;
92 }
93
94 __setup("nosmp", nosmp);
95
96 static int __init maxcpus(char *str)
97 {
98         get_option(&str, &max_cpus);
99         return 1;
100 }
101
102 __setup("maxcpus=", maxcpus);
103
104 /*
105  * Trampoline 80x86 program as an array.
106  */
107
108 extern unsigned char trampoline_data [];
109 extern unsigned char trampoline_end  [];
110 static unsigned char *trampoline_base;
111
112 /*
113  * Currently trivial. Write the real->protected mode
114  * bootstrap into the page concerned. The caller
115  * has made sure it's suitably aligned.
116  */
117
118 static unsigned long __init setup_trampoline(void)
119 {
120         memcpy(trampoline_base, trampoline_data, trampoline_end - trampoline_data);
121         return virt_to_phys(trampoline_base);
122 }
123
124 /*
125  * We are called very early to get the low memory for the
126  * SMP bootup trampoline page.
127  */
128 void __init smp_alloc_memory(void)
129 {
130         trampoline_base = (void *) alloc_bootmem_low_pages(PAGE_SIZE);
131         /*
132          * Has to be in very low memory so we can execute
133          * real-mode AP code.
134          */
135         if (__pa(trampoline_base) >= 0x9F000)
136                 BUG();
137 }
138
139 /*
140  * The bootstrap kernel entry code has set these up. Save them for
141  * a given CPU
142  */
143
144 void __init smp_store_cpu_info(int id)
145 {
146         struct cpuinfo_x86 *c = cpu_data + id;
147
148         *c = boot_cpu_data;
149         identify_cpu(c);
150         /*
151          * Mask B, Pentium, but not Pentium MMX
152          */
153         if (c->x86_vendor == X86_VENDOR_INTEL &&
154             c->x86 == 5 &&
155             c->x86_mask >= 1 && c->x86_mask <= 4 &&
156             c->x86_model <= 3)
157                 /*
158                  * Remember we have B step Pentia with bugs
159                  */
160                 smp_b_stepping = 1;
161
162         /*
163          * Certain Athlons might work (for various values of 'work') in SMP
164          * but they are not certified as MP capable.
165          */
166         if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) {
167
168                 /* Athlon 660/661 is valid. */  
169                 if ((c->x86_model==6) && ((c->x86_mask==0) || (c->x86_mask==1)))
170                         goto valid_k7;
171
172                 /* Duron 670 is valid */
173                 if ((c->x86_model==7) && (c->x86_mask==0))
174                         goto valid_k7;
175
176                 /* Athlon 662, Duron 671, and Athlon >model 7 have capability bit */
177                 if (((c->x86_model==6) && (c->x86_mask>=2)) ||
178                     ((c->x86_model==7) && (c->x86_mask>=1)) ||
179                      (c->x86_model> 7))
180                         if (cpu_has_mp)
181                                 goto valid_k7;
182
183                 /* If we get here, it's not a certified SMP capable AMD system. */
184                 printk (KERN_INFO "WARNING: This combination of AMD processors is not suitable for SMP.\n");
185                 tainted |= TAINT_UNSAFE_SMP;
186                 
187         }
188 valid_k7:
189
190 }
191
192 /*
193  * Architecture specific routine called by the kernel just before init is
194  * fired off. This allows the BP to have everything in order [we hope].
195  * At the end of this all the APs will hit the system scheduling and off
196  * we go. Each AP will load the system gdt's and jump through the kernel
197  * init into idle(). At this point the scheduler will one day take over
198  * and give them jobs to do. smp_callin is a standard routine
199  * we use to track CPUs as they power up.
200  */
201
202 static atomic_t smp_commenced = ATOMIC_INIT(0);
203
204 void __init smp_commence(void)
205 {
206         /*
207          * Lets the callins below out of their loop.
208          */
209         Dprintk("Setting commenced=1, go go go\n");
210
211         wmb();
212         atomic_set(&smp_commenced,1);
213 }
214
215 /*
216  * TSC synchronization.
217  *
218  * We first check wether all CPUs have their TSC's synchronized,
219  * then we print a warning if not, and always resync.
220  */
221
222 static atomic_t tsc_start_flag = ATOMIC_INIT(0);
223 static atomic_t tsc_count_start = ATOMIC_INIT(0);
224 static atomic_t tsc_count_stop = ATOMIC_INIT(0);
225 static unsigned long long tsc_values[NR_CPUS];
226
227 #define NR_LOOPS 5
228
229 extern unsigned long fast_gettimeoffset_quotient;
230
231 /*
232  * accurate 64-bit/32-bit division, expanded to 32-bit divisions and 64-bit
233  * multiplication. Not terribly optimized but we need it at boot time only
234  * anyway.
235  *
236  * result == a / b
237  *      == (a1 + a2*(2^32)) / b
238  *      == a1/b + a2*(2^32/b)
239  *      == a1/b + a2*((2^32-1)/b) + a2/b + (a2*((2^32-1) % b))/b
240  *                  ^---- (this multiplication can overflow)
241  */
242
243 static unsigned long long __init div64 (unsigned long long a, unsigned long b0)
244 {
245         unsigned int a1, a2;
246         unsigned long long res;
247
248         a1 = ((unsigned int*)&a)[0];
249         a2 = ((unsigned int*)&a)[1];
250
251         res = a1/b0 +
252                 (unsigned long long)a2 * (unsigned long long)(0xffffffff/b0) +
253                 a2 / b0 +
254                 (a2 * (0xffffffff % b0)) / b0;
255
256         return res;
257 }
258
259 static void __init synchronize_tsc_bp (void)
260 {
261         int i;
262         unsigned long long t0;
263         unsigned long long sum, avg;
264         long long delta;
265         unsigned long one_usec;
266         int buggy = 0;
267
268         printk("checking TSC synchronization across CPUs: ");
269
270         one_usec = ((1<<30)/fast_gettimeoffset_quotient)*(1<<2);
271
272         atomic_set(&tsc_start_flag, 1);
273         wmb();
274
275         /*
276          * We loop a few times to get a primed instruction cache,
277          * then the last pass is more or less synchronized and
278          * the BP and APs set their cycle counters to zero all at
279          * once. This reduces the chance of having random offsets
280          * between the processors, and guarantees that the maximum
281          * delay between the cycle counters is never bigger than
282          * the latency of information-passing (cachelines) between
283          * two CPUs.
284          */
285         for (i = 0; i < NR_LOOPS; i++) {
286                 /*
287                  * all APs synchronize but they loop on '== num_cpus'
288                  */
289                 while (atomic_read(&tsc_count_start) != smp_num_cpus-1) mb();
290                 atomic_set(&tsc_count_stop, 0);
291                 wmb();
292                 /*
293                  * this lets the APs save their current TSC:
294                  */
295                 atomic_inc(&tsc_count_start);
296
297                 rdtscll(tsc_values[smp_processor_id()]);
298                 /*
299                  * We clear the TSC in the last loop:
300                  */
301                 if (i == NR_LOOPS-1)
302                         write_tsc(0, 0);
303
304                 /*
305                  * Wait for all APs to leave the synchronization point:
306                  */
307                 while (atomic_read(&tsc_count_stop) != smp_num_cpus-1) mb();
308                 atomic_set(&tsc_count_start, 0);
309                 wmb();
310                 atomic_inc(&tsc_count_stop);
311         }
312
313         sum = 0;
314         for (i = 0; i < smp_num_cpus; i++) {
315                 t0 = tsc_values[i];
316                 sum += t0;
317         }
318         avg = div64(sum, smp_num_cpus);
319
320         sum = 0;
321         for (i = 0; i < smp_num_cpus; i++) {
322                 delta = tsc_values[i] - avg;
323                 if (delta < 0)
324                         delta = -delta;
325                 /*
326                  * We report bigger than 2 microseconds clock differences.
327                  */
328                 if (delta > 2*one_usec) {
329                         long realdelta;
330                         if (!buggy) {
331                                 buggy = 1;
332                                 printk("\n");
333                         }
334                         realdelta = div64(delta, one_usec);
335                         if (tsc_values[i] < avg)
336                                 realdelta = -realdelta;
337
338                         printk("BIOS BUG: CPU#%d improperly initialized, has %ld usecs TSC skew! FIXED.\n", i, realdelta);
339                 }
340
341                 sum += delta;
342         }
343         if (!buggy)
344                 printk("passed.\n");
345                 ;
346 }
347
348 static void __init synchronize_tsc_ap (void)
349 {
350         int i;
351
352         /*
353          * smp_num_cpus is not necessarily known at the time
354          * this gets called, so we first wait for the BP to
355          * finish SMP initialization:
356          */
357         while (!atomic_read(&tsc_start_flag)) mb();
358
359         for (i = 0; i < NR_LOOPS; i++) {
360                 atomic_inc(&tsc_count_start);
361                 while (atomic_read(&tsc_count_start) != smp_num_cpus) mb();
362
363                 rdtscll(tsc_values[smp_processor_id()]);
364                 if (i == NR_LOOPS-1)
365                         write_tsc(0, 0);
366
367                 atomic_inc(&tsc_count_stop);
368                 while (atomic_read(&tsc_count_stop) != smp_num_cpus) mb();
369         }
370 }
371 #undef NR_LOOPS
372
373 extern void calibrate_delay(void);
374
375 static atomic_t init_deasserted;
376
377 void __init smp_callin(void)
378 {
379         int cpuid, phys_id;
380         unsigned long timeout;
381
382         /*
383          * If waken up by an INIT in an 82489DX configuration
384          * we may get here before an INIT-deassert IPI reaches
385          * our local APIC.  We have to wait for the IPI or we'll
386          * lock up on an APIC access.
387          */
388         if (!clustered_apic_mode) 
389                 while (!atomic_read(&init_deasserted));
390
391         /*
392          * (This works even if the APIC is not enabled.)
393          */
394         phys_id = GET_APIC_ID(apic_read(APIC_ID));
395         cpuid = smp_processor_id();
396         if (test_and_set_bit(cpuid, &cpu_online_map)) {
397                 printk("huh, phys CPU#%d, CPU#%d already present??\n",
398                                         phys_id, cpuid);
399                 BUG();
400         }
401         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
402
403         /*
404          * STARTUP IPIs are fragile beasts as they might sometimes
405          * trigger some glue motherboard logic. Complete APIC bus
406          * silence for 1 second, this overestimates the time the
407          * boot CPU is spending to send the up to 2 STARTUP IPIs
408          * by a factor of two. This should be enough.
409          */
410
411         /*
412          * Waiting 2s total for startup (udelay is not yet working)
413          */
414         timeout = jiffies + 2*HZ;
415         while (time_before(jiffies, timeout)) {
416                 /*
417                  * Has the boot CPU finished it's STARTUP sequence?
418                  */
419                 if (test_bit(cpuid, &cpu_callout_map))
420                         break;
421                 rep_nop();
422         }
423
424         if (!time_before(jiffies, timeout)) {
425                 printk("BUG: CPU%d started up but did not get a callout!\n",
426                         cpuid);
427                 BUG();
428         }
429
430         /*
431          * the boot CPU has finished the init stage and is spinning
432          * on callin_map until we finish. We are free to set up this
433          * CPU, first the APIC. (this is probably redundant on most
434          * boards)
435          */
436
437         Dprintk("CALLIN, before setup_local_APIC().\n");
438         /*
439          * Because we use NMIs rather than the INIT-STARTUP sequence to
440          * bootstrap the CPUs, the APIC may be in a wierd state. Kick it.
441          */
442         if (clustered_apic_mode)
443                 clear_local_APIC();
444         setup_local_APIC();
445
446         __sti();
447
448 #ifdef CONFIG_MTRR
449         /*
450          * Must be done before calibration delay is computed
451          */
452         mtrr_init_secondary_cpu ();
453 #endif
454         /*
455          * Get our bogomips.
456          */
457         calibrate_delay();
458         Dprintk("Stack at about %p\n",&cpuid);
459
460         /*
461          * Save our processor parameters
462          */
463         smp_store_cpu_info(cpuid);
464
465         disable_APIC_timer();
466         /*
467          * Allow the master to continue.
468          */
469         set_bit(cpuid, &cpu_callin_map);
470
471         /*
472          *      Synchronize the TSC with the BP
473          */
474         if (cpu_has_tsc)
475                 synchronize_tsc_ap();
476 }
477
478 int cpucount;
479
480 extern int cpu_idle(void);
481
482 /*
483  * Activate a secondary processor.
484  */
485 int __init start_secondary(void *unused)
486 {
487         /*
488          * Dont put anything before smp_callin(), SMP
489          * booting is too fragile that we want to limit the
490          * things done here to the most necessary things.
491          */
492         cpu_init();
493         smp_callin();
494         while (!atomic_read(&smp_commenced))
495                 rep_nop();
496         enable_APIC_timer();
497         /*
498          * low-memory mappings have been cleared, flush them from
499          * the local TLBs too.
500          */
501         local_flush_tlb();
502
503         return cpu_idle();
504 }
505
506 /*
507  * Everything has been set up for the secondary
508  * CPUs - they just need to reload everything
509  * from the task structure
510  * This function must not return.
511  */
512 void __init initialize_secondary(void)
513 {
514         /*
515          * We don't actually need to load the full TSS,
516          * basically just the stack pointer and the eip.
517          */
518
519         asm volatile(
520                 "movl %0,%%esp\n\t"
521                 "jmp *%1"
522                 :
523                 :"r" (current->thread.esp),"r" (current->thread.eip));
524 }
525
526 extern struct {
527         void * esp;
528         unsigned short ss;
529 } stack_start;
530
531 static int __init fork_by_hand(void)
532 {
533         struct pt_regs regs;
534         /*
535          * don't care about the eip and regs settings since
536          * we'll never reschedule the forked task.
537          */
538         return do_fork(CLONE_VM|CLONE_PID, 0, &regs, 0);
539 }
540
541 /* which physical APIC ID maps to which logical CPU number */
542 volatile int physical_apicid_2_cpu[MAX_APICID];
543 /* which logical CPU number maps to which physical APIC ID */
544 volatile int cpu_2_physical_apicid[NR_CPUS];
545
546 /* which logical APIC ID maps to which logical CPU number */
547 volatile int logical_apicid_2_cpu[MAX_APICID];
548 /* which logical CPU number maps to which logical APIC ID */
549 volatile int cpu_2_logical_apicid[NR_CPUS];
550
551 static inline void init_cpu_to_apicid(void)
552 /* Initialize all maps between cpu number and apicids */
553 {
554         int apicid, cpu;
555
556         for (apicid = 0; apicid < MAX_APICID; apicid++) {
557                 physical_apicid_2_cpu[apicid] = -1;
558                 logical_apicid_2_cpu[apicid] = -1;
559         }
560         for (cpu = 0; cpu < NR_CPUS; cpu++) {
561                 cpu_2_physical_apicid[cpu] = -1;
562                 cpu_2_logical_apicid[cpu] = -1;
563         }
564 }
565
566 static inline void map_cpu_to_boot_apicid(int cpu, int apicid)
567 /* 
568  * set up a mapping between cpu and apicid. Uses logical apicids for multiquad,
569  * else physical apic ids
570  */
571 {
572         if (clustered_apic_mode) {
573                 logical_apicid_2_cpu[apicid] = cpu;     
574                 cpu_2_logical_apicid[cpu] = apicid;
575         } else {
576                 physical_apicid_2_cpu[apicid] = cpu;    
577                 cpu_2_physical_apicid[cpu] = apicid;
578         }
579 }
580
581 static inline void unmap_cpu_to_boot_apicid(int cpu, int apicid)
582 /* 
583  * undo a mapping between cpu and apicid. Uses logical apicids for multiquad,
584  * else physical apic ids
585  */
586 {
587         if (clustered_apic_mode) {
588                 logical_apicid_2_cpu[apicid] = -1;      
589                 cpu_2_logical_apicid[cpu] = -1;
590         } else {
591                 physical_apicid_2_cpu[apicid] = -1;     
592                 cpu_2_physical_apicid[cpu] = -1;
593         }
594 }
595
596 #if APIC_DEBUG
597 static inline void inquire_remote_apic(int apicid)
598 {
599         int i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
600         char *names[] = { "ID", "VERSION", "SPIV" };
601         int timeout, status;
602
603         printk("Inquiring remote APIC #%d...\n", apicid);
604
605         for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
606                 printk("... APIC #%d %s: ", apicid, names[i]);
607
608                 /*
609                  * Wait for idle.
610                  */
611                 apic_wait_icr_idle();
612
613                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
614                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
615
616                 timeout = 0;
617                 do {
618                         udelay(100);
619                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
620                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
621
622                 switch (status) {
623                 case APIC_ICR_RR_VALID:
624                         status = apic_read(APIC_RRR);
625                         printk("%08x\n", status);
626                         break;
627                 default:
628                         printk("failed\n");
629                 }
630         }
631 }
632 #endif
633
634 static int wakeup_secondary_via_NMI(int logical_apicid)
635 /* 
636  * Poke the other CPU in the eye to wake it up. Remember that the normal
637  * INIT, INIT, STARTUP sequence will reset the chip hard for us, and this
638  * won't ... remember to clear down the APIC, etc later.
639  */
640 {
641         unsigned long send_status = 0, accept_status = 0;
642         int timeout, maxlvt;
643
644         /* Target chip */
645         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(logical_apicid));
646
647         /* Boot on the stack */
648         /* Kick the second */
649         apic_write_around(APIC_ICR, APIC_DM_NMI | APIC_DEST_LOGICAL);
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         maxlvt = get_maxlvt();
667         if (maxlvt > 3) {
668                 apic_read_around(APIC_SPIV);
669                 apic_write(APIC_ESR, 0);
670         }
671         accept_status = (apic_read(APIC_ESR) & 0xEF);
672         Dprintk("NMI sent.\n");
673
674         if (send_status)
675                 printk("APIC never delivered???\n");
676         if (accept_status)
677                 printk("APIC delivery error (%lx).\n", accept_status);
678
679         return (send_status | accept_status);
680 }
681
682 static int wakeup_secondary_via_INIT(int phys_apicid, unsigned long start_eip)
683 {
684         unsigned long send_status = 0, accept_status = 0;
685         int maxlvt, timeout, num_starts, j;
686
687         Dprintk("Asserting INIT.\n");
688
689         /*
690          * Turn INIT on target chip
691          */
692         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
693
694         /*
695          * Send IPI
696          */
697         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
698                                 | APIC_DM_INIT);
699
700         Dprintk("Waiting for send to finish...\n");
701         timeout = 0;
702         do {
703                 Dprintk("+");
704                 udelay(100);
705                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
706         } while (send_status && (timeout++ < 1000));
707
708         mdelay(10);
709
710         Dprintk("Deasserting INIT.\n");
711
712         /* Target chip */
713         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
714
715         /* Send IPI */
716         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
717
718         Dprintk("Waiting for send to finish...\n");
719         timeout = 0;
720         do {
721                 Dprintk("+");
722                 udelay(100);
723                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
724         } while (send_status && (timeout++ < 1000));
725
726         atomic_set(&init_deasserted, 1);
727
728         /*
729          * Should we send STARTUP IPIs ?
730          *
731          * Determine this based on the APIC version.
732          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
733          */
734         if (APIC_INTEGRATED(apic_version[phys_apicid]))
735                 num_starts = 2;
736         else
737                 num_starts = 0;
738
739         /*
740          * Run STARTUP IPI loop.
741          */
742         Dprintk("#startup loops: %d.\n", num_starts);
743
744         maxlvt = get_maxlvt();
745
746         for (j = 1; j <= num_starts; j++) {
747                 Dprintk("Sending STARTUP #%d.\n",j);
748                 apic_read_around(APIC_SPIV);
749                 apic_write(APIC_ESR, 0);
750                 apic_read(APIC_ESR);
751                 Dprintk("After apic_write.\n");
752
753                 /*
754                  * STARTUP IPI
755                  */
756
757                 /* Target chip */
758                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
759
760                 /* Boot on the stack */
761                 /* Kick the second */
762                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
763                                         | (start_eip >> 12));
764
765                 /*
766                  * Give the other CPU some time to accept the IPI.
767                  */
768                 udelay(300);
769
770                 Dprintk("Startup point 1.\n");
771
772                 Dprintk("Waiting for send to finish...\n");
773                 timeout = 0;
774                 do {
775                         Dprintk("+");
776                         udelay(100);
777                         send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
778                 } while (send_status && (timeout++ < 1000));
779
780                 /*
781                  * Give the other CPU some time to accept the IPI.
782                  */
783                 udelay(200);
784                 /*
785                  * Due to the Pentium erratum 3AP.
786                  */
787                 if (maxlvt > 3) {
788                         apic_read_around(APIC_SPIV);
789                         apic_write(APIC_ESR, 0);
790                 }
791                 accept_status = (apic_read(APIC_ESR) & 0xEF);
792                 if (send_status || accept_status)
793                         break;
794         }
795         Dprintk("After Startup.\n");
796
797         if (send_status)
798                 printk("APIC never delivered???\n");
799         if (accept_status)
800                 printk("APIC delivery error (%lx).\n", accept_status);
801
802         return (send_status | accept_status);
803 }
804
805 extern unsigned long cpu_initialized;
806
807 static void __init do_boot_cpu (int apicid) 
808 /*
809  * NOTE - on most systems this is a PHYSICAL apic ID, but on multiquad
810  * (ie clustered apic addressing mode), this is a LOGICAL apic ID.
811  */
812 {
813         struct task_struct *idle;
814         unsigned long boot_error = 0;
815         int timeout, cpu;
816         unsigned long start_eip;
817         unsigned short nmi_high, nmi_low;
818
819         cpu = ++cpucount;
820         /*
821          * We can't use kernel_thread since we must avoid to
822          * reschedule the child.
823          */
824         if (fork_by_hand() < 0)
825                 panic("failed fork for CPU %d", cpu);
826
827         /*
828          * We remove it from the pidhash and the runqueue
829          * once we got the process:
830          */
831         idle = init_task.prev_task;
832         if (!idle)
833                 panic("No idle process for CPU %d", cpu);
834
835         init_idle(idle, cpu);
836
837         map_cpu_to_boot_apicid(cpu, apicid);
838
839         idle->thread.eip = (unsigned long) start_secondary;
840
841         unhash_process(idle);
842
843         /* start_eip had better be page-aligned! */
844         start_eip = setup_trampoline();
845
846         /* So we see what's up   */
847         printk("Booting processor %d/%d eip %lx\n", cpu, apicid, start_eip);
848         stack_start.esp = (void *) (1024 + PAGE_SIZE + (char *)idle->thread_info);
849
850         /*
851          * This grunge runs the startup process for
852          * the targeted processor.
853          */
854
855         atomic_set(&init_deasserted, 0);
856
857         Dprintk("Setting warm reset code and vector.\n");
858
859         if (clustered_apic_mode) {
860                 /* stash the current NMI vector, so we can put things back */
861                 nmi_high = *((volatile unsigned short *) TRAMPOLINE_HIGH);
862                 nmi_low = *((volatile unsigned short *) TRAMPOLINE_LOW);
863         } 
864
865         CMOS_WRITE(0xa, 0xf);
866         local_flush_tlb();
867         Dprintk("1.\n");
868         *((volatile unsigned short *) TRAMPOLINE_HIGH) = start_eip >> 4;
869         Dprintk("2.\n");
870         *((volatile unsigned short *) TRAMPOLINE_LOW) = start_eip & 0xf;
871         Dprintk("3.\n");
872
873         /*
874          * Be paranoid about clearing APIC errors.
875          */
876         if (!clustered_apic_mode && APIC_INTEGRATED(apic_version[apicid])) {
877                 apic_read_around(APIC_SPIV);
878                 apic_write(APIC_ESR, 0);
879                 apic_read(APIC_ESR);
880         }
881
882         /*
883          * Status is now clean
884          */
885         boot_error = 0;
886
887         /*
888          * Starting actual IPI sequence...
889          */
890
891         if (clustered_apic_mode)
892                 boot_error = wakeup_secondary_via_NMI(apicid);
893         else 
894                 boot_error = wakeup_secondary_via_INIT(apicid, start_eip);
895
896         if (!boot_error) {
897                 /*
898                  * allow APs to start initializing.
899                  */
900                 Dprintk("Before Callout %d.\n", cpu);
901                 set_bit(cpu, &cpu_callout_map);
902                 Dprintk("After Callout %d.\n", cpu);
903
904                 /*
905                  * Wait 5s total for a response
906                  */
907                 for (timeout = 0; timeout < 50000; timeout++) {
908                         if (test_bit(cpu, &cpu_callin_map))
909                                 break;  /* It has booted */
910                         udelay(100);
911                 }
912
913                 if (test_bit(cpu, &cpu_callin_map)) {
914                         /* number CPUs logically, starting from 1 (BSP is 0) */
915                         Dprintk("OK.\n");
916                         printk("CPU%d: ", cpu);
917                         print_cpu_info(&cpu_data[cpu]);
918                         Dprintk("CPU has booted.\n");
919                 } else {
920                         boot_error= 1;
921                         if (*((volatile unsigned char *)phys_to_virt(8192))
922                                         == 0xA5)
923                                 /* trampoline started but...? */
924                                 printk("Stuck ??\n");
925                         else
926                                 /* trampoline code not run */
927                                 printk("Not responding.\n");
928 #if APIC_DEBUG
929                         if (!clustered_apic_mode)
930                                 inquire_remote_apic(apicid);
931 #endif
932                 }
933         }
934         if (boot_error) {
935                 /* Try to put things back the way they were before ... */
936                 unmap_cpu_to_boot_apicid(cpu, apicid);
937                 clear_bit(cpu, &cpu_callout_map); /* was set here (do_boot_cpu()) */
938                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
939                 clear_bit(cpu, &cpu_online_map);  /* was set in smp_callin() */
940                 cpucount--;
941         }
942
943         /* mark "stuck" area as not stuck */
944         *((volatile unsigned long *)phys_to_virt(8192)) = 0;
945
946         if(clustered_apic_mode) {
947                 printk("Restoring NMI vector\n");
948                 *((volatile unsigned short *) TRAMPOLINE_HIGH) = nmi_high;
949                 *((volatile unsigned short *) TRAMPOLINE_LOW) = nmi_low;
950         }
951 }
952
953 cycles_t cacheflush_time;
954 unsigned long cache_decay_ticks;
955
956 static void smp_tune_scheduling (void)
957 {
958         unsigned long cachesize;       /* kB   */
959         unsigned long bandwidth = 350; /* MB/s */
960         /*
961          * Rough estimation for SMP scheduling, this is the number of
962          * cycles it takes for a fully memory-limited process to flush
963          * the SMP-local cache.
964          *
965          * (For a P5 this pretty much means we will choose another idle
966          *  CPU almost always at wakeup time (this is due to the small
967          *  L1 cache), on PIIs it's around 50-100 usecs, depending on
968          *  the cache size)
969          */
970
971         if (!cpu_khz) {
972                 /*
973                  * this basically disables processor-affinity
974                  * scheduling on SMP without a TSC.
975                  */
976                 cacheflush_time = 0;
977                 return;
978         } else {
979                 cachesize = boot_cpu_data.x86_cache_size;
980                 if (cachesize == -1) {
981                         cachesize = 16; /* Pentiums, 2x8kB cache */
982                         bandwidth = 100;
983                 }
984
985                 cacheflush_time = (cpu_khz>>10) * (cachesize<<10) / bandwidth;
986         }
987
988         cache_decay_ticks = (long)cacheflush_time/cpu_khz * HZ / 1000;
989
990         printk("per-CPU timeslice cutoff: %ld.%02ld usecs.\n",
991                 (long)cacheflush_time/(cpu_khz/1000),
992                 ((long)cacheflush_time*100/(cpu_khz/1000)) % 100);
993         printk("task migration cache decay timeout: %ld msecs.\n",
994                 (cache_decay_ticks + 1) * 1000 / HZ);
995 }
996
997 /*
998  * Cycle through the processors sending APIC IPIs to boot each.
999  */
1000
1001 extern int prof_multiplier[NR_CPUS];
1002 extern int prof_old_multiplier[NR_CPUS];
1003 extern int prof_counter[NR_CPUS];
1004
1005 static int boot_cpu_logical_apicid;
1006 /* Where the IO area was mapped on multiquad, always 0 otherwise */
1007 void *xquad_portio = NULL;
1008
1009 int cpu_sibling_map[NR_CPUS] __cacheline_aligned;
1010
1011 void __init smp_boot_cpus(void)
1012 {
1013         int apicid, cpu, bit;
1014
1015         if (clustered_apic_mode) {
1016                 /* remap the 1st quad's 256k range for cross-quad I/O */
1017                 xquad_portio = ioremap (XQUAD_PORTIO_BASE, XQUAD_PORTIO_LEN);
1018                 printk("Cross quad port I/O vaddr 0x%08lx, len %08lx\n",
1019                         (u_long) xquad_portio, (u_long) XQUAD_PORTIO_LEN);
1020         }
1021
1022 #ifdef CONFIG_MTRR
1023         /*  Must be done before other processors booted  */
1024         mtrr_init_boot_cpu ();
1025 #endif
1026         /*
1027          * Initialize the logical to physical CPU number mapping
1028          * and the per-CPU profiling counter/multiplier
1029          */
1030
1031         for (cpu = 0; cpu < NR_CPUS; cpu++) {
1032                 prof_counter[cpu] = 1;
1033                 prof_old_multiplier[cpu] = 1;
1034                 prof_multiplier[cpu] = 1;
1035         }
1036
1037         init_cpu_to_apicid();
1038
1039         /*
1040          * Setup boot CPU information
1041          */
1042         smp_store_cpu_info(0); /* Final full version of the data */
1043         printk("CPU%d: ", 0);
1044         print_cpu_info(&cpu_data[0]);
1045
1046         /*
1047          * We have the boot CPU online for sure.
1048          */
1049         set_bit(0, &cpu_online_map);
1050         boot_cpu_logical_apicid = logical_smp_processor_id();
1051         map_cpu_to_boot_apicid(0, boot_cpu_apicid);
1052
1053         global_irq_holder = NO_PROC_ID;
1054         current_thread_info()->cpu = 0;
1055         smp_tune_scheduling();
1056
1057         /*
1058          * If we couldnt find an SMP configuration at boot time,
1059          * get out of here now!
1060          */
1061         if (!smp_found_config) {
1062                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
1063 #ifndef CONFIG_VISWS
1064                 io_apic_irqs = 0;
1065 #endif
1066                 cpu_online_map = phys_cpu_present_map = 1;
1067                 smp_num_cpus = 1;
1068                 if (APIC_init_uniprocessor())
1069                         printk(KERN_NOTICE "Local APIC not detected."
1070                                            " Using dummy APIC emulation.\n");
1071                 goto smp_done;
1072         }
1073
1074         /*
1075          * Should not be necessary because the MP table should list the boot
1076          * CPU too, but we do it for the sake of robustness anyway.
1077          * Makes no sense to do this check in clustered apic mode, so skip it
1078          */
1079         if (!clustered_apic_mode && 
1080             !test_bit(boot_cpu_physical_apicid, &phys_cpu_present_map)) {
1081                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
1082                                                         boot_cpu_physical_apicid);
1083                 phys_cpu_present_map |= (1 << hard_smp_processor_id());
1084         }
1085
1086         /*
1087          * If we couldn't find a local APIC, then get out of here now!
1088          */
1089         if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid]) &&
1090             !test_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability)) {
1091                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
1092                         boot_cpu_physical_apicid);
1093                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
1094 #ifndef CONFIG_VISWS
1095                 io_apic_irqs = 0;
1096 #endif
1097                 cpu_online_map = phys_cpu_present_map = 1;
1098                 smp_num_cpus = 1;
1099                 goto smp_done;
1100         }
1101
1102         verify_local_APIC();
1103
1104         /*
1105          * If SMP should be disabled, then really disable it!
1106          */
1107         if (!max_cpus) {
1108                 smp_found_config = 0;
1109                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
1110 #ifndef CONFIG_VISWS
1111                 io_apic_irqs = 0;
1112 #endif
1113                 cpu_online_map = phys_cpu_present_map = 1;
1114                 smp_num_cpus = 1;
1115                 goto smp_done;
1116         }
1117
1118         connect_bsp_APIC();
1119         setup_local_APIC();
1120
1121         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_physical_apicid)
1122                 BUG();
1123
1124         /*
1125          * Scan the CPU present map and fire up the other CPUs via do_boot_cpu
1126          *
1127          * In clustered apic mode, phys_cpu_present_map is a constructed thus:
1128          * bits 0-3 are quad0, 4-7 are quad1, etc. A perverse twist on the 
1129          * clustered apic ID.
1130          */
1131         Dprintk("CPU present map: %lx\n", phys_cpu_present_map);
1132
1133         for (bit = 0; bit < NR_CPUS; bit++) {
1134                 apicid = cpu_present_to_apicid(bit);
1135                 /*
1136                  * Don't even attempt to start the boot CPU!
1137                  */
1138                 if (apicid == boot_cpu_apicid)
1139                         continue;
1140
1141                 if (!(phys_cpu_present_map & (1 << bit)))
1142                         continue;
1143                 if ((max_cpus >= 0) && (max_cpus <= cpucount+1))
1144                         continue;
1145
1146                 do_boot_cpu(apicid);
1147
1148                 /*
1149                  * Make sure we unmap all failed CPUs
1150                  */
1151                 if ((boot_apicid_to_cpu(apicid) == -1) &&
1152                                 (phys_cpu_present_map & (1 << bit)))
1153                         printk("CPU #%d not responding - cannot use it.\n",
1154                                                                 apicid);
1155         }
1156
1157         /*
1158          * Cleanup possible dangling ends...
1159          */
1160 #ifndef CONFIG_VISWS
1161         {
1162                 /*
1163                  * Install writable page 0 entry to set BIOS data area.
1164                  */
1165                 local_flush_tlb();
1166
1167                 /*
1168                  * Paranoid:  Set warm reset code and vector here back
1169                  * to default values.
1170                  */
1171                 CMOS_WRITE(0, 0xf);
1172
1173                 *((volatile long *) phys_to_virt(0x467)) = 0;
1174         }
1175 #endif
1176
1177         /*
1178          * Allow the user to impress friends.
1179          */
1180
1181         Dprintk("Before bogomips.\n");
1182         if (!cpucount) {
1183                 printk(KERN_ERR "Error: only one processor found.\n");
1184         } else {
1185                 unsigned long bogosum = 0;
1186                 for (cpu = 0; cpu < NR_CPUS; cpu++)
1187                         if (cpu_online_map & (1<<cpu))
1188                                 bogosum += cpu_data[cpu].loops_per_jiffy;
1189                 printk(KERN_INFO "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
1190                         cpucount+1,
1191                         bogosum/(500000/HZ),
1192                         (bogosum/(5000/HZ))%100);
1193                 Dprintk("Before bogocount - setting activated=1.\n");
1194         }
1195         smp_num_cpus = cpucount + 1;
1196
1197         if (smp_b_stepping)
1198                 printk(KERN_WARNING "WARNING: SMP operation may be unreliable with B stepping processors.\n");
1199         Dprintk("Boot done.\n");
1200
1201         /*
1202          * If Hyper-Threading is avaialble, construct cpu_sibling_map[], so
1203          * that we can tell the sibling CPU efficiently.
1204          */
1205         if (test_bit(X86_FEATURE_HT, boot_cpu_data.x86_capability)
1206             && smp_num_siblings > 1) {
1207                 for (cpu = 0; cpu < NR_CPUS; cpu++)
1208                         cpu_sibling_map[cpu] = NO_PROC_ID;
1209                 
1210                 for (cpu = 0; cpu < smp_num_cpus; cpu++) {
1211                         int     i;
1212                         
1213                         for (i = 0; i < smp_num_cpus; i++) {
1214                                 if (i == cpu)
1215                                         continue;
1216                                 if (phys_proc_id[cpu] == phys_proc_id[i]) {
1217                                         cpu_sibling_map[cpu] = i;
1218                                         printk("cpu_sibling_map[%d] = %d\n", cpu, cpu_sibling_map[cpu]);
1219                                         break;
1220                                 }
1221                         }
1222                         if (cpu_sibling_map[cpu] == NO_PROC_ID) {
1223                                 smp_num_siblings = 1;
1224                                 printk(KERN_WARNING "WARNING: No sibling found for CPU %d.\n", cpu);
1225                         }
1226                 }
1227         }
1228              
1229 #ifndef CONFIG_VISWS
1230         /*
1231          * Here we can be sure that there is an IO-APIC in the system. Let's
1232          * go and set it up:
1233          */
1234         if (!skip_ioapic_setup && nr_ioapics)
1235                 setup_IO_APIC();
1236 #endif
1237
1238         /*
1239          * Set up all local APIC timers in the system:
1240          */
1241         setup_APIC_clocks();
1242
1243         /*
1244          * Synchronize the TSC with the AP
1245          */
1246         if (cpu_has_tsc && cpucount)
1247                 synchronize_tsc_bp();
1248
1249 smp_done:
1250         zap_low_mappings();
1251 }