1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/types.h>
20#include <linux/spinlock.h>
21
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/sched.h>
25#include <linux/init.h>
26#include <linux/interrupt.h>
27#include <linux/smp.h>
28#include <linux/kernel_stat.h>
29#include <linux/mm.h>
30#include <linux/err.h>
31#include <linux/delay.h>
32#include <linux/bitops.h>
33#include <linux/ftrace.h>
34
35#include <asm/system.h>
36#include <asm/atomic.h>
37#include <asm/current.h>
38#include <asm/delay.h>
39#include <asm/tlbflush.h>
40
41#include <asm/io.h>
42#include <asm/irq.h>
43#include <asm/mmu_context.h>
44#include <asm/page.h>
45#include <asm/pgtable.h>
46#include <asm/pgalloc.h>
47#include <asm/processor.h>
48#include <asm/ptrace.h>
49#include <asm/unistd.h>
50#include <asm/cacheflush.h>
51
52#undef DEBUG_SMP
53#ifdef DEBUG_SMP
54static int smp_debug_lvl = 0;
55#define smp_debug(lvl, printargs...) \
56 if (lvl >= smp_debug_lvl) \
57 printk(printargs);
58#else
59#define smp_debug(lvl, ...) do { } while(0)
60#endif
61
62volatile struct task_struct *smp_init_current_idle_task;
63
64
65static volatile int cpu_now_booting __cpuinitdata;
66
67static int parisc_max_cpus __cpuinitdata = 1;
68
69static DEFINE_PER_CPU(spinlock_t, ipi_lock);
70
71enum ipi_message_type {
72 IPI_NOP=0,
73 IPI_RESCHEDULE=1,
74 IPI_CALL_FUNC,
75 IPI_CALL_FUNC_SINGLE,
76 IPI_CPU_START,
77 IPI_CPU_STOP,
78 IPI_CPU_TEST
79};
80
81
82
83
84#undef PER_CPU_IRQ_REGION
85#ifdef PER_CPU_IRQ_REGION
86
87
88
89
90static void
91ipi_init(int cpuid)
92{
93#error verify IRQ_OFFSET(IPI_IRQ) is ipi_interrupt() in new IRQ region
94
95 if(cpu_online(cpuid) )
96 {
97 switch_to_idle_task(current);
98 }
99
100 return;
101}
102#endif
103
104
105
106
107
108
109static void
110halt_processor(void)
111{
112
113
114 set_cpu_online(smp_processor_id(), false);
115 local_irq_disable();
116 for (;;)
117 ;
118}
119
120
121irqreturn_t __irq_entry
122ipi_interrupt(int irq, void *dev_id)
123{
124 int this_cpu = smp_processor_id();
125 struct cpuinfo_parisc *p = &per_cpu(cpu_data, this_cpu);
126 unsigned long ops;
127 unsigned long flags;
128
129
130 p->ipi_count++;
131
132 mb();
133
134 for (;;) {
135 spinlock_t *lock = &per_cpu(ipi_lock, this_cpu);
136 spin_lock_irqsave(lock, flags);
137 ops = p->pending_ipi;
138 p->pending_ipi = 0;
139 spin_unlock_irqrestore(lock, flags);
140
141 mb();
142
143 if (!ops)
144 break;
145
146 while (ops) {
147 unsigned long which = ffz(~ops);
148
149 ops &= ~(1 << which);
150
151 switch (which) {
152 case IPI_NOP:
153 smp_debug(100, KERN_DEBUG "CPU%d IPI_NOP\n", this_cpu);
154 break;
155
156 case IPI_RESCHEDULE:
157 smp_debug(100, KERN_DEBUG "CPU%d IPI_RESCHEDULE\n", this_cpu);
158
159
160
161
162 break;
163
164 case IPI_CALL_FUNC:
165 smp_debug(100, KERN_DEBUG "CPU%d IPI_CALL_FUNC\n", this_cpu);
166 generic_smp_call_function_interrupt();
167 break;
168
169 case IPI_CALL_FUNC_SINGLE:
170 smp_debug(100, KERN_DEBUG "CPU%d IPI_CALL_FUNC_SINGLE\n", this_cpu);
171 generic_smp_call_function_single_interrupt();
172 break;
173
174 case IPI_CPU_START:
175 smp_debug(100, KERN_DEBUG "CPU%d IPI_CPU_START\n", this_cpu);
176 break;
177
178 case IPI_CPU_STOP:
179 smp_debug(100, KERN_DEBUG "CPU%d IPI_CPU_STOP\n", this_cpu);
180 halt_processor();
181 break;
182
183 case IPI_CPU_TEST:
184 smp_debug(100, KERN_DEBUG "CPU%d is alive!\n", this_cpu);
185 break;
186
187 default:
188 printk(KERN_CRIT "Unknown IPI num on CPU%d: %lu\n",
189 this_cpu, which);
190 return IRQ_NONE;
191 }
192
193 local_irq_enable();
194 local_irq_disable();
195 }
196 }
197 return IRQ_HANDLED;
198}
199
200
201static inline void
202ipi_send(int cpu, enum ipi_message_type op)
203{
204 struct cpuinfo_parisc *p = &per_cpu(cpu_data, cpu);
205 spinlock_t *lock = &per_cpu(ipi_lock, cpu);
206 unsigned long flags;
207
208 spin_lock_irqsave(lock, flags);
209 p->pending_ipi |= 1 << op;
210 gsc_writel(IPI_IRQ - CPU_IRQ_BASE, p->hpa);
211 spin_unlock_irqrestore(lock, flags);
212}
213
214static void
215send_IPI_mask(const struct cpumask *mask, enum ipi_message_type op)
216{
217 int cpu;
218
219 for_each_cpu(cpu, mask)
220 ipi_send(cpu, op);
221}
222
223static inline void
224send_IPI_single(int dest_cpu, enum ipi_message_type op)
225{
226 BUG_ON(dest_cpu == NO_PROC_ID);
227
228 ipi_send(dest_cpu, op);
229}
230
231static inline void
232send_IPI_allbutself(enum ipi_message_type op)
233{
234 int i;
235
236 for_each_online_cpu(i) {
237 if (i != smp_processor_id())
238 send_IPI_single(i, op);
239 }
240}
241
242
243inline void
244smp_send_stop(void) { send_IPI_allbutself(IPI_CPU_STOP); }
245
246static inline void
247smp_send_start(void) { send_IPI_allbutself(IPI_CPU_START); }
248
249void
250smp_send_reschedule(int cpu) { send_IPI_single(cpu, IPI_RESCHEDULE); }
251
252void
253smp_send_all_nop(void)
254{
255 send_IPI_allbutself(IPI_NOP);
256}
257
258void arch_send_call_function_ipi_mask(const struct cpumask *mask)
259{
260 send_IPI_mask(mask, IPI_CALL_FUNC);
261}
262
263void arch_send_call_function_single_ipi(int cpu)
264{
265 send_IPI_single(cpu, IPI_CALL_FUNC_SINGLE);
266}
267
268
269
270
271
272
273void
274smp_flush_tlb_all(void)
275{
276 on_each_cpu(flush_tlb_all_local, NULL, 1);
277}
278
279
280
281
282static void __init
283smp_cpu_init(int cpunum)
284{
285 extern int init_per_cpu(int);
286 extern void init_IRQ(void);
287 extern void start_cpu_itimer(void);
288
289
290 (void) init_per_cpu(cpunum);
291
292 disable_sr_hashing();
293
294 mb();
295
296
297 if (cpu_isset(cpunum, cpu_online_map))
298 {
299 extern void machine_halt(void);
300
301 printk(KERN_CRIT "CPU#%d already initialized!\n", cpunum);
302 machine_halt();
303 }
304 set_cpu_online(cpunum, true);
305
306
307 atomic_inc(&init_mm.mm_count);
308 current->active_mm = &init_mm;
309 BUG_ON(current->mm);
310 enter_lazy_tlb(&init_mm, current);
311
312 init_IRQ();
313 start_cpu_itimer();
314}
315
316
317
318
319
320
321void __init smp_callin(void)
322{
323 int slave_id = cpu_now_booting;
324
325 smp_cpu_init(slave_id);
326 preempt_disable();
327
328 flush_cache_all_local();
329 flush_tlb_all_local(NULL);
330
331 local_irq_enable();
332
333 cpu_idle();
334
335
336 panic("smp_callin() AAAAaaaaahhhh....\n");
337}
338
339
340
341
342int __cpuinit smp_boot_one_cpu(int cpuid)
343{
344 const struct cpuinfo_parisc *p = &per_cpu(cpu_data, cpuid);
345 struct task_struct *idle;
346 long timeout;
347
348
349
350
351
352
353
354
355
356
357
358 idle = fork_idle(cpuid);
359 if (IS_ERR(idle))
360 panic("SMP: fork failed for CPU:%d", cpuid);
361
362 task_thread_info(idle)->cpu = cpuid;
363
364
365
366
367 cpu_now_booting = cpuid;
368
369
370
371
372
373 smp_init_current_idle_task = idle ;
374 mb();
375
376 printk(KERN_INFO "Releasing cpu %d now, hpa=%lx\n", cpuid, p->hpa);
377
378
379
380
381
382
383
384
385
386
387 gsc_writel(TIMER_IRQ - CPU_IRQ_BASE, p->hpa);
388 mb();
389
390
391
392
393
394
395 for (timeout = 0; timeout < 10000; timeout++) {
396 if(cpu_online(cpuid)) {
397
398 cpu_now_booting = 0;
399 smp_init_current_idle_task = NULL;
400 goto alive ;
401 }
402 udelay(100);
403 barrier();
404 }
405
406 put_task_struct(idle);
407 idle = NULL;
408
409 printk(KERN_CRIT "SMP: CPU:%d is stuck.\n", cpuid);
410 return -1;
411
412alive:
413
414 smp_debug(100, KERN_DEBUG "SMP: CPU:%d came alive after %ld _us\n",
415 cpuid, timeout * 100);
416 return 0;
417}
418
419void __init smp_prepare_boot_cpu(void)
420{
421 int bootstrap_processor = per_cpu(cpu_data, 0).cpuid;
422
423
424 printk(KERN_INFO "SMP: bootstrap CPU ID is %d\n", bootstrap_processor);
425
426 set_cpu_online(bootstrap_processor, true);
427 set_cpu_present(bootstrap_processor, true);
428}
429
430
431
432
433
434
435
436void __init smp_prepare_cpus(unsigned int max_cpus)
437{
438 int cpu;
439
440 for_each_possible_cpu(cpu)
441 spin_lock_init(&per_cpu(ipi_lock, cpu));
442
443 init_cpu_present(cpumask_of(0));
444
445 parisc_max_cpus = max_cpus;
446 if (!max_cpus)
447 printk(KERN_INFO "SMP mode deactivated.\n");
448}
449
450
451void smp_cpus_done(unsigned int cpu_max)
452{
453 return;
454}
455
456
457int __cpuinit __cpu_up(unsigned int cpu)
458{
459 if (cpu != 0 && cpu < parisc_max_cpus)
460 smp_boot_one_cpu(cpu);
461
462 return cpu_online(cpu) ? 0 : -ENOSYS;
463}
464
465#ifdef CONFIG_PROC_FS
466int __init
467setup_profiling_timer(unsigned int multiplier)
468{
469 return -EINVAL;
470}
471#endif
472