kernel/cpu.c: create a CPU_STARTING cpu_chain notifier
[linux-2.6.git] / arch / m32r / kernel / smpboot.c
1 /*
2  *  linux/arch/m32r/kernel/smpboot.c
3  *    orig : i386 2.4.10
4  *
5  *  M32R SMP booting functions
6  *
7  *  Copyright (c) 2001, 2002, 2003  Hitoshi Yamamoto
8  *
9  *  Taken from i386 version.
10  *        (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
11  *        (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
12  *
13  *      Much of the core SMP work is based on previous work by Thomas Radke, to
14  *      whom a great many thanks are extended.
15  *
16  *      Thanks to Intel for making available several different Pentium,
17  *      Pentium Pro and Pentium-II/Xeon MP machines.
18  *      Original development of Linux SMP code supported by Caldera.
19  *
20  *      This code is released under the GNU General Public License version 2 or
21  *      later.
22  *
23  *      Fixes
24  *              Felix Koop      :       NR_CPUS used properly
25  *              Jose Renau      :       Handle single CPU case.
26  *              Alan Cox        :       By repeated request
27  *                                      8) - Total BogoMIP report.
28  *              Greg Wright     :       Fix for kernel stacks panic.
29  *              Erich Boleyn    :       MP v1.4 and additional changes.
30  *      Matthias Sattler        :       Changes for 2.1 kernel map.
31  *      Michel Lespinasse       :       Changes for 2.1 kernel map.
32  *      Michael Chastain        :       Change trampoline.S to gnu as.
33  *              Alan Cox        :       Dumb bug: 'B' step PPro's are fine
34  *              Ingo Molnar     :       Added APIC timers, based on code
35  *                                      from Jose Renau
36  *              Ingo Molnar     :       various cleanups and rewrites
37  *              Tigran Aivazian :       fixed "0.00 in /proc/uptime on SMP" bug.
38  *      Maciej W. Rozycki       :       Bits for genuine 82489DX APICs
39  *              Martin J. Bligh :       Added support for multi-quad systems
40  */
41
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/kernel.h>
45 #include <linux/mm.h>
46 #include <linux/sched.h>
47 #include <linux/err.h>
48 #include <linux/irq.h>
49 #include <linux/bootmem.h>
50 #include <linux/delay.h>
51
52 #include <asm/io.h>
53 #include <asm/pgalloc.h>
54 #include <asm/tlbflush.h>
55
56 #define DEBUG_SMP
57 #ifdef DEBUG_SMP
58 #define Dprintk(x...) printk(x)
59 #else
60 #define Dprintk(x...)
61 #endif
62
63 extern cpumask_t cpu_initialized;
64
65 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
66 /* Data structures and variables                                             */
67 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
68
69 /* Processor that is doing the boot up */
70 static unsigned int bsp_phys_id = -1;
71
72 /* Bitmask of physically existing CPUs */
73 physid_mask_t phys_cpu_present_map;
74
75 /* Bitmask of currently online CPUs */
76 cpumask_t cpu_online_map;
77 EXPORT_SYMBOL(cpu_online_map);
78
79 cpumask_t cpu_bootout_map;
80 cpumask_t cpu_bootin_map;
81 static cpumask_t cpu_callin_map;
82 cpumask_t cpu_callout_map;
83 EXPORT_SYMBOL(cpu_callout_map);
84 cpumask_t cpu_possible_map = CPU_MASK_ALL;
85 EXPORT_SYMBOL(cpu_possible_map);
86
87 /* Per CPU bogomips and other parameters */
88 struct cpuinfo_m32r cpu_data[NR_CPUS] __cacheline_aligned;
89
90 static int cpucount;
91 static cpumask_t smp_commenced_mask;
92
93 extern struct {
94         void * spi;
95         unsigned short ss;
96 } stack_start;
97
98 /* which physical physical ID maps to which logical CPU number */
99 static volatile int physid_2_cpu[NR_CPUS];
100 #define physid_to_cpu(physid)   physid_2_cpu[physid]
101
102 /* which logical CPU number maps to which physical ID */
103 volatile int cpu_2_physid[NR_CPUS];
104
105 DEFINE_PER_CPU(int, prof_multiplier) = 1;
106 DEFINE_PER_CPU(int, prof_old_multiplier) = 1;
107 DEFINE_PER_CPU(int, prof_counter) = 1;
108
109 spinlock_t ipi_lock[NR_IPIS];
110
111 static unsigned int calibration_result;
112
113 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
114 /* Function Prototypes                                                       */
115 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
116
117 void smp_prepare_boot_cpu(void);
118 void smp_prepare_cpus(unsigned int);
119 static void init_ipi_lock(void);
120 static void do_boot_cpu(int);
121 int __cpu_up(unsigned int);
122 void smp_cpus_done(unsigned int);
123
124 int start_secondary(void *);
125 static void smp_callin(void);
126 static void smp_online(void);
127
128 static void show_mp_info(int);
129 static void smp_store_cpu_info(int);
130 static void show_cpu_info(int);
131 int setup_profiling_timer(unsigned int);
132 static void init_cpu_to_physid(void);
133 static void map_cpu_to_physid(int, int);
134 static void unmap_cpu_to_physid(int, int);
135
136 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
137 /* Boot up APs Routines : BSP                                                */
138 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
139 void __devinit smp_prepare_boot_cpu(void)
140 {
141         bsp_phys_id = hard_smp_processor_id();
142         physid_set(bsp_phys_id, phys_cpu_present_map);
143         cpu_set(0, cpu_online_map);     /* BSP's cpu_id == 0 */
144         cpu_set(0, cpu_callout_map);
145         cpu_set(0, cpu_callin_map);
146
147         /*
148          * Initialize the logical to physical CPU number mapping
149          */
150         init_cpu_to_physid();
151         map_cpu_to_physid(0, bsp_phys_id);
152         current_thread_info()->cpu = 0;
153 }
154
155 /*==========================================================================*
156  * Name:         smp_prepare_cpus (old smp_boot_cpus)
157  *
158  * Description:  This routine boot up APs.
159  *
160  * Born on Date: 2002.02.05
161  *
162  * Arguments:    NONE
163  *
164  * Returns:      void (cannot fail)
165  *
166  * Modification log:
167  * Date       Who Description
168  * ---------- --- --------------------------------------------------------
169  * 2003-06-24 hy  modify for linux-2.5.69
170  *
171  *==========================================================================*/
172 void __init smp_prepare_cpus(unsigned int max_cpus)
173 {
174         int phys_id;
175         unsigned long nr_cpu;
176
177         nr_cpu = inl(M32R_FPGA_NUM_OF_CPUS_PORTL);
178         if (nr_cpu > NR_CPUS) {
179                 printk(KERN_INFO "NUM_OF_CPUS reg. value [%ld] > NR_CPU [%d]",
180                         nr_cpu, NR_CPUS);
181                 goto smp_done;
182         }
183         for (phys_id = 0 ; phys_id < nr_cpu ; phys_id++)
184                 physid_set(phys_id, phys_cpu_present_map);
185 #ifndef CONFIG_HOTPLUG_CPU
186         cpu_present_map = cpu_possible_map;
187 #endif
188
189         show_mp_info(nr_cpu);
190
191         init_ipi_lock();
192
193         /*
194          * Setup boot CPU information
195          */
196         smp_store_cpu_info(0); /* Final full version of the data */
197
198         /*
199          * If SMP should be disabled, then really disable it!
200          */
201         if (!max_cpus) {
202                 printk(KERN_INFO "SMP mode deactivated by commandline.\n");
203                 goto smp_done;
204         }
205
206         /*
207          * Now scan the CPU present map and fire up the other CPUs.
208          */
209         Dprintk("CPU present map : %lx\n", physids_coerce(phys_cpu_present_map));
210
211         for (phys_id = 0 ; phys_id < NR_CPUS ; phys_id++) {
212                 /*
213                  * Don't even attempt to start the boot CPU!
214                  */
215                 if (phys_id == bsp_phys_id)
216                         continue;
217
218                 if (!physid_isset(phys_id, phys_cpu_present_map))
219                         continue;
220
221                 if ((max_cpus >= 0) && (max_cpus <= cpucount + 1))
222                         continue;
223
224                 do_boot_cpu(phys_id);
225
226                 /*
227                  * Make sure we unmap all failed CPUs
228                  */
229                 if (physid_to_cpu(phys_id) == -1) {
230                         physid_clear(phys_id, phys_cpu_present_map);
231                         printk("phys CPU#%d not responding - " \
232                                 "cannot use it.\n", phys_id);
233                 }
234         }
235
236 smp_done:
237         Dprintk("Boot done.\n");
238 }
239
240 /*
241  * init_ipi_lock : Initialize IPI locks.
242  */
243 static void __init init_ipi_lock(void)
244 {
245         int ipi;
246
247         for (ipi = 0 ; ipi < NR_IPIS ; ipi++)
248                 spin_lock_init(&ipi_lock[ipi]);
249 }
250
251 /*==========================================================================*
252  * Name:         do_boot_cpu
253  *
254  * Description:  This routine boot up one AP.
255  *
256  * Born on Date: 2002.02.05
257  *
258  * Arguments:    phys_id - Target CPU physical ID
259  *
260  * Returns:      void (cannot fail)
261  *
262  * Modification log:
263  * Date       Who Description
264  * ---------- --- --------------------------------------------------------
265  * 2003-06-24 hy  modify for linux-2.5.69
266  *
267  *==========================================================================*/
268 static void __init do_boot_cpu(int phys_id)
269 {
270         struct task_struct *idle;
271         unsigned long send_status, boot_status;
272         int timeout, cpu_id;
273
274         cpu_id = ++cpucount;
275
276         /*
277          * We can't use kernel_thread since we must avoid to
278          * reschedule the child.
279          */
280         idle = fork_idle(cpu_id);
281         if (IS_ERR(idle))
282                 panic("failed fork for CPU#%d.", cpu_id);
283
284         idle->thread.lr = (unsigned long)start_secondary;
285
286         map_cpu_to_physid(cpu_id, phys_id);
287
288         /* So we see what's up   */
289         printk("Booting processor %d/%d\n", phys_id, cpu_id);
290         stack_start.spi = (void *)idle->thread.sp;
291         task_thread_info(idle)->cpu = cpu_id;
292
293         /*
294          * Send Startup IPI
295          *   1.IPI received by CPU#(phys_id).
296          *   2.CPU#(phys_id) enter startup_AP (arch/m32r/kernel/head.S)
297          *   3.CPU#(phys_id) enter start_secondary()
298          */
299         send_status = 0;
300         boot_status = 0;
301
302         cpu_set(phys_id, cpu_bootout_map);
303
304         /* Send Startup IPI */
305         send_IPI_mask_phys(cpumask_of_cpu(phys_id), CPU_BOOT_IPI, 0);
306
307         Dprintk("Waiting for send to finish...\n");
308         timeout = 0;
309
310         /* Wait 100[ms] */
311         do {
312                 Dprintk("+");
313                 udelay(1000);
314                 send_status = !cpu_isset(phys_id, cpu_bootin_map);
315         } while (send_status && (timeout++ < 100));
316
317         Dprintk("After Startup.\n");
318
319         if (!send_status) {
320                 /*
321                  * allow APs to start initializing.
322                  */
323                 Dprintk("Before Callout %d.\n", cpu_id);
324                 cpu_set(cpu_id, cpu_callout_map);
325                 Dprintk("After Callout %d.\n", cpu_id);
326
327                 /*
328                  * Wait 5s total for a response
329                  */
330                 for (timeout = 0; timeout < 5000; timeout++) {
331                         if (cpu_isset(cpu_id, cpu_callin_map))
332                                 break;  /* It has booted */
333                         udelay(1000);
334                 }
335
336                 if (cpu_isset(cpu_id, cpu_callin_map)) {
337                         /* number CPUs logically, starting from 1 (BSP is 0) */
338                         Dprintk("OK.\n");
339                 } else {
340                         boot_status = 1;
341                         printk("Not responding.\n");
342                 }
343         } else
344                 printk("IPI never delivered???\n");
345
346         if (send_status || boot_status) {
347                 unmap_cpu_to_physid(cpu_id, phys_id);
348                 cpu_clear(cpu_id, cpu_callout_map);
349                 cpu_clear(cpu_id, cpu_callin_map);
350                 cpu_clear(cpu_id, cpu_initialized);
351                 cpucount--;
352         }
353 }
354
355 int __cpuinit __cpu_up(unsigned int cpu_id)
356 {
357         int timeout;
358
359         cpu_set(cpu_id, smp_commenced_mask);
360
361         /*
362          * Wait 5s total for a response
363          */
364         for (timeout = 0; timeout < 5000; timeout++) {
365                 if (cpu_isset(cpu_id, cpu_online_map))
366                         break;
367                 udelay(1000);
368         }
369         if (!cpu_isset(cpu_id, cpu_online_map))
370                 BUG();
371
372         return 0;
373 }
374
375 void __init smp_cpus_done(unsigned int max_cpus)
376 {
377         int cpu_id, timeout;
378         unsigned long bogosum = 0;
379
380         for (timeout = 0; timeout < 5000; timeout++) {
381                 if (cpus_equal(cpu_callin_map, cpu_online_map))
382                         break;
383                 udelay(1000);
384         }
385         if (!cpus_equal(cpu_callin_map, cpu_online_map))
386                 BUG();
387
388         for (cpu_id = 0 ; cpu_id < num_online_cpus() ; cpu_id++)
389                 show_cpu_info(cpu_id);
390
391         /*
392          * Allow the user to impress friends.
393          */
394         Dprintk("Before bogomips.\n");
395         if (cpucount) {
396                 for_each_cpu_mask(cpu_id, cpu_online_map)
397                         bogosum += cpu_data[cpu_id].loops_per_jiffy;
398
399                 printk(KERN_INFO "Total of %d processors activated " \
400                         "(%lu.%02lu BogoMIPS).\n", cpucount + 1,
401                         bogosum / (500000 / HZ),
402                         (bogosum / (5000 / HZ)) % 100);
403                 Dprintk("Before bogocount - setting activated=1.\n");
404         }
405 }
406
407 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
408 /* Activate a secondary processor Routines                                   */
409 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
410
411 /*==========================================================================*
412  * Name:         start_secondary
413  *
414  * Description:  This routine activate a secondary processor.
415  *
416  * Born on Date: 2002.02.05
417  *
418  * Arguments:    *unused - currently unused.
419  *
420  * Returns:      void (cannot fail)
421  *
422  * Modification log:
423  * Date       Who Description
424  * ---------- --- --------------------------------------------------------
425  * 2003-06-24 hy  modify for linux-2.5.69
426  *
427  *==========================================================================*/
428 int __init start_secondary(void *unused)
429 {
430         cpu_init();
431         preempt_disable();
432         smp_callin();
433         while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
434                 cpu_relax();
435
436         smp_online();
437
438         /*
439          * low-memory mappings have been cleared, flush them from
440          * the local TLBs too.
441          */
442         local_flush_tlb_all();
443
444         cpu_idle();
445         return 0;
446 }
447
448 /*==========================================================================*
449  * Name:         smp_callin
450  *
451  * Description:  This routine activate a secondary processor.
452  *
453  * Born on Date: 2002.02.05
454  *
455  * Arguments:    NONE
456  *
457  * Returns:      void (cannot fail)
458  *
459  * Modification log:
460  * Date       Who Description
461  * ---------- --- --------------------------------------------------------
462  * 2003-06-24 hy  modify for linux-2.5.69
463  *
464  *==========================================================================*/
465 static void __init smp_callin(void)
466 {
467         int phys_id = hard_smp_processor_id();
468         int cpu_id = smp_processor_id();
469         unsigned long timeout;
470
471         if (cpu_isset(cpu_id, cpu_callin_map)) {
472                 printk("huh, phys CPU#%d, CPU#%d already present??\n",
473                         phys_id, cpu_id);
474                 BUG();
475         }
476         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpu_id, phys_id);
477
478         /* Waiting 2s total for startup (udelay is not yet working) */
479         timeout = jiffies + (2 * HZ);
480         while (time_before(jiffies, timeout)) {
481                 /* Has the boot CPU finished it's STARTUP sequence ? */
482                 if (cpu_isset(cpu_id, cpu_callout_map))
483                         break;
484                 cpu_relax();
485         }
486
487         if (!time_before(jiffies, timeout)) {
488                 printk("BUG: CPU#%d started up but did not get a callout!\n",
489                         cpu_id);
490                 BUG();
491         }
492
493         /* Allow the master to continue. */
494         cpu_set(cpu_id, cpu_callin_map);
495 }
496
497 static void __init smp_online(void)
498 {
499         int cpu_id = smp_processor_id();
500
501         notify_cpu_starting(cpu_id);
502
503         local_irq_enable();
504
505         /* Get our bogomips. */
506         calibrate_delay();
507
508         /* Save our processor parameters */
509         smp_store_cpu_info(cpu_id);
510
511         cpu_set(cpu_id, cpu_online_map);
512 }
513
514 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
515 /* Boot up CPUs common Routines                                              */
516 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
517 static void __init show_mp_info(int nr_cpu)
518 {
519         int i;
520         char cpu_model0[17], cpu_model1[17], cpu_ver[9];
521
522         strncpy(cpu_model0, (char *)M32R_FPGA_CPU_NAME_ADDR, 16);
523         strncpy(cpu_model1, (char *)M32R_FPGA_MODEL_ID_ADDR, 16);
524         strncpy(cpu_ver, (char *)M32R_FPGA_VERSION_ADDR, 8);
525
526         cpu_model0[16] = '\0';
527         for (i = 15 ; i >= 0 ; i--) {
528                 if (cpu_model0[i] != ' ')
529                         break;
530                 cpu_model0[i] = '\0';
531         }
532         cpu_model1[16] = '\0';
533         for (i = 15 ; i >= 0 ; i--) {
534                 if (cpu_model1[i] != ' ')
535                         break;
536                 cpu_model1[i] = '\0';
537         }
538         cpu_ver[8] = '\0';
539         for (i = 7 ; i >= 0 ; i--) {
540                 if (cpu_ver[i] != ' ')
541                         break;
542                 cpu_ver[i] = '\0';
543         }
544
545         printk(KERN_INFO "M32R-mp information\n");
546         printk(KERN_INFO "  On-chip CPUs : %d\n", nr_cpu);
547         printk(KERN_INFO "  CPU model : %s/%s(%s)\n", cpu_model0,
548                 cpu_model1, cpu_ver);
549 }
550
551 /*
552  * The bootstrap kernel entry code has set these up. Save them for
553  * a given CPU
554  */
555 static void __init smp_store_cpu_info(int cpu_id)
556 {
557         struct cpuinfo_m32r *ci = cpu_data + cpu_id;
558
559         *ci = boot_cpu_data;
560         ci->loops_per_jiffy = loops_per_jiffy;
561 }
562
563 static void __init show_cpu_info(int cpu_id)
564 {
565         struct cpuinfo_m32r *ci = &cpu_data[cpu_id];
566
567         printk("CPU#%d : ", cpu_id);
568
569 #define PRINT_CLOCK(name, value) \
570         printk(name " clock %d.%02dMHz", \
571                 ((value) / 1000000), ((value) % 1000000) / 10000)
572
573         PRINT_CLOCK("CPU", (int)ci->cpu_clock);
574         PRINT_CLOCK(", Bus", (int)ci->bus_clock);
575         printk(", loops_per_jiffy[%ld]\n", ci->loops_per_jiffy);
576 }
577
578 /*
579  * the frequency of the profiling timer can be changed
580  * by writing a multiplier value into /proc/profile.
581  */
582 int setup_profiling_timer(unsigned int multiplier)
583 {
584         int i;
585
586         /*
587          * Sanity check. [at least 500 APIC cycles should be
588          * between APIC interrupts as a rule of thumb, to avoid
589          * irqs flooding us]
590          */
591         if ( (!multiplier) || (calibration_result / multiplier < 500))
592                 return -EINVAL;
593
594         /*
595          * Set the new multiplier for each CPU. CPUs don't start using the
596          * new values until the next timer interrupt in which they do process
597          * accounting. At that time they also adjust their APIC timers
598          * accordingly.
599          */
600         for (i = 0; i < NR_CPUS; ++i)
601                 per_cpu(prof_multiplier, i) = multiplier;
602
603         return 0;
604 }
605
606 /* Initialize all maps between cpu number and apicids */
607 static void __init init_cpu_to_physid(void)
608 {
609         int  i;
610
611         for (i = 0 ; i < NR_CPUS ; i++) {
612                 cpu_2_physid[i] = -1;
613                 physid_2_cpu[i] = -1;
614         }
615 }
616
617 /*
618  * set up a mapping between cpu and apicid. Uses logical apicids for multiquad,
619  * else physical apic ids
620  */
621 static void __init map_cpu_to_physid(int cpu_id, int phys_id)
622 {
623         physid_2_cpu[phys_id] = cpu_id;
624         cpu_2_physid[cpu_id] = phys_id;
625 }
626
627 /*
628  * undo a mapping between cpu and apicid. Uses logical apicids for multiquad,
629  * else physical apic ids
630  */
631 static void __init unmap_cpu_to_physid(int cpu_id, int phys_id)
632 {
633         physid_2_cpu[phys_id] = -1;
634         cpu_2_physid[cpu_id] = -1;
635 }