~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mn10300/kernel/smp.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SMP support routines.
  2  *
  3  * Copyright (C) 2006-2008 Panasonic Corporation
  4  * All Rights Reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License
  8  * version 2 as published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 13  * GNU General Public License for more details.
 14  */
 15 
 16 #include <linux/interrupt.h>
 17 #include <linux/spinlock.h>
 18 #include <linux/init.h>
 19 #include <linux/jiffies.h>
 20 #include <linux/cpumask.h>
 21 #include <linux/err.h>
 22 #include <linux/kernel.h>
 23 #include <linux/delay.h>
 24 #include <linux/sched.h>
 25 #include <linux/profile.h>
 26 #include <linux/smp.h>
 27 #include <linux/cpu.h>
 28 #include <asm/tlbflush.h>
 29 #include <asm/bitops.h>
 30 #include <asm/processor.h>
 31 #include <asm/bug.h>
 32 #include <asm/exceptions.h>
 33 #include <asm/hardirq.h>
 34 #include <asm/fpu.h>
 35 #include <asm/mmu_context.h>
 36 #include <asm/thread_info.h>
 37 #include <asm/cpu-regs.h>
 38 #include <asm/intctl-regs.h>
 39 #include "internal.h"
 40 
 41 #ifdef CONFIG_HOTPLUG_CPU
 42 #include <asm/cacheflush.h>
 43 
 44 static unsigned long sleep_mode[NR_CPUS];
 45 
 46 static void run_sleep_cpu(unsigned int cpu);
 47 static void run_wakeup_cpu(unsigned int cpu);
 48 #endif /* CONFIG_HOTPLUG_CPU */
 49 
 50 /*
 51  * Debug Message function
 52  */
 53 
 54 #undef DEBUG_SMP
 55 #ifdef DEBUG_SMP
 56 #define Dprintk(fmt, ...) printk(KERN_DEBUG fmt, ##__VA_ARGS__)
 57 #else
 58 #define Dprintk(fmt, ...) no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
 59 #endif
 60 
 61 /* timeout value in msec for smp_nmi_call_function. zero is no timeout. */
 62 #define CALL_FUNCTION_NMI_IPI_TIMEOUT   0
 63 
 64 /*
 65  * Structure and data for smp_nmi_call_function().
 66  */
 67 struct nmi_call_data_struct {
 68         smp_call_func_t func;
 69         void            *info;
 70         cpumask_t       started;
 71         cpumask_t       finished;
 72         int             wait;
 73         char            size_alignment[0]
 74         __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
 75 } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
 76 
 77 static DEFINE_SPINLOCK(smp_nmi_call_lock);
 78 static struct nmi_call_data_struct *nmi_call_data;
 79 
 80 /*
 81  * Data structures and variables
 82  */
 83 static cpumask_t cpu_callin_map;        /* Bitmask of callin CPUs */
 84 static cpumask_t cpu_callout_map;       /* Bitmask of callout CPUs */
 85 cpumask_t cpu_boot_map;                 /* Bitmask of boot APs */
 86 unsigned long start_stack[NR_CPUS - 1];
 87 
 88 /*
 89  * Per CPU parameters
 90  */
 91 struct mn10300_cpuinfo cpu_data[NR_CPUS] __cacheline_aligned;
 92 
 93 static int cpucount;                    /* The count of boot CPUs */
 94 static cpumask_t smp_commenced_mask;
 95 cpumask_t cpu_initialized __initdata = CPU_MASK_NONE;
 96 
 97 /*
 98  * Function Prototypes
 99  */
100 static int do_boot_cpu(int);
101 static void smp_show_cpu_info(int cpu_id);
102 static void smp_callin(void);
103 static void smp_online(void);
104 static void smp_store_cpu_info(int);
105 static void smp_cpu_init(void);
106 static void smp_tune_scheduling(void);
107 static void send_IPI_mask(const cpumask_t *cpumask, int irq);
108 static void init_ipi(void);
109 
110 /*
111  * IPI Initialization interrupt definitions
112  */
113 static void mn10300_ipi_disable(unsigned int irq);
114 static void mn10300_ipi_enable(unsigned int irq);
115 static void mn10300_ipi_chip_disable(struct irq_data *d);
116 static void mn10300_ipi_chip_enable(struct irq_data *d);
117 static void mn10300_ipi_ack(struct irq_data *d);
118 static void mn10300_ipi_nop(struct irq_data *d);
119 
120 static struct irq_chip mn10300_ipi_type = {
121         .name           = "cpu_ipi",
122         .irq_disable    = mn10300_ipi_chip_disable,
123         .irq_enable     = mn10300_ipi_chip_enable,
124         .irq_ack        = mn10300_ipi_ack,
125         .irq_eoi        = mn10300_ipi_nop
126 };
127 
128 static irqreturn_t smp_reschedule_interrupt(int irq, void *dev_id);
129 static irqreturn_t smp_call_function_interrupt(int irq, void *dev_id);
130 
131 static struct irqaction reschedule_ipi = {
132         .handler        = smp_reschedule_interrupt,
133         .flags          = IRQF_NOBALANCING,
134         .name           = "smp reschedule IPI"
135 };
136 static struct irqaction call_function_ipi = {
137         .handler        = smp_call_function_interrupt,
138         .flags          = IRQF_NOBALANCING,
139         .name           = "smp call function IPI"
140 };
141 
142 #if !defined(CONFIG_GENERIC_CLOCKEVENTS) || defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
143 static irqreturn_t smp_ipi_timer_interrupt(int irq, void *dev_id);
144 static struct irqaction local_timer_ipi = {
145         .handler        = smp_ipi_timer_interrupt,
146         .flags          = IRQF_DISABLED | IRQF_NOBALANCING,
147         .name           = "smp local timer IPI"
148 };
149 #endif
150 
151 /**
152  * init_ipi - Initialise the IPI mechanism
153  */
154 static void init_ipi(void)
155 {
156         unsigned long flags;
157         u16 tmp16;
158 
159         /* set up the reschedule IPI */
160         irq_set_chip_and_handler(RESCHEDULE_IPI, &mn10300_ipi_type,
161                                  handle_percpu_irq);
162         setup_irq(RESCHEDULE_IPI, &reschedule_ipi);
163         set_intr_level(RESCHEDULE_IPI, RESCHEDULE_GxICR_LV);
164         mn10300_ipi_enable(RESCHEDULE_IPI);
165 
166         /* set up the call function IPI */
167         irq_set_chip_and_handler(CALL_FUNC_SINGLE_IPI, &mn10300_ipi_type,
168                                  handle_percpu_irq);
169         setup_irq(CALL_FUNC_SINGLE_IPI, &call_function_ipi);
170         set_intr_level(CALL_FUNC_SINGLE_IPI, CALL_FUNCTION_GxICR_LV);
171         mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
172 
173         /* set up the local timer IPI */
174 #if !defined(CONFIG_GENERIC_CLOCKEVENTS) || \
175     defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
176         irq_set_chip_and_handler(LOCAL_TIMER_IPI, &mn10300_ipi_type,
177                                  handle_percpu_irq);
178         setup_irq(LOCAL_TIMER_IPI, &local_timer_ipi);
179         set_intr_level(LOCAL_TIMER_IPI, LOCAL_TIMER_GxICR_LV);
180         mn10300_ipi_enable(LOCAL_TIMER_IPI);
181 #endif
182 
183 #ifdef CONFIG_MN10300_CACHE_ENABLED
184         /* set up the cache flush IPI */
185         irq_set_chip(FLUSH_CACHE_IPI, &mn10300_ipi_type);
186         flags = arch_local_cli_save();
187         __set_intr_stub(NUM2EXCEP_IRQ_LEVEL(FLUSH_CACHE_GxICR_LV),
188                         mn10300_low_ipi_handler);
189         GxICR(FLUSH_CACHE_IPI) = FLUSH_CACHE_GxICR_LV | GxICR_DETECT;
190         mn10300_ipi_enable(FLUSH_CACHE_IPI);
191         arch_local_irq_restore(flags);
192 #endif
193 
194         /* set up the NMI call function IPI */
195         irq_set_chip(CALL_FUNCTION_NMI_IPI, &mn10300_ipi_type);
196         flags = arch_local_cli_save();
197         GxICR(CALL_FUNCTION_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
198         tmp16 = GxICR(CALL_FUNCTION_NMI_IPI);
199         arch_local_irq_restore(flags);
200 
201         /* set up the SMP boot IPI */
202         flags = arch_local_cli_save();
203         __set_intr_stub(NUM2EXCEP_IRQ_LEVEL(SMP_BOOT_GxICR_LV),
204                         mn10300_low_ipi_handler);
205         arch_local_irq_restore(flags);
206 
207 #ifdef CONFIG_KERNEL_DEBUGGER
208         irq_set_chip(DEBUGGER_NMI_IPI, &mn10300_ipi_type);
209 #endif
210 }
211 
212 /**
213  * mn10300_ipi_shutdown - Shut down handling of an IPI
214  * @irq: The IPI to be shut down.
215  */
216 static void mn10300_ipi_shutdown(unsigned int irq)
217 {
218         unsigned long flags;
219         u16 tmp;
220 
221         flags = arch_local_cli_save();
222 
223         tmp = GxICR(irq);
224         GxICR(irq) = (tmp & GxICR_LEVEL) | GxICR_DETECT;
225         tmp = GxICR(irq);
226 
227         arch_local_irq_restore(flags);
228 }
229 
230 /**
231  * mn10300_ipi_enable - Enable an IPI
232  * @irq: The IPI to be enabled.
233  */
234 static void mn10300_ipi_enable(unsigned int irq)
235 {
236         unsigned long flags;
237         u16 tmp;
238 
239         flags = arch_local_cli_save();
240 
241         tmp = GxICR(irq);
242         GxICR(irq) = (tmp & GxICR_LEVEL) | GxICR_ENABLE;
243         tmp = GxICR(irq);
244 
245         arch_local_irq_restore(flags);
246 }
247 
248 static void mn10300_ipi_chip_enable(struct irq_data *d)
249 {
250         mn10300_ipi_enable(d->irq);
251 }
252 
253 /**
254  * mn10300_ipi_disable - Disable an IPI
255  * @irq: The IPI to be disabled.
256  */
257 static void mn10300_ipi_disable(unsigned int irq)
258 {
259         unsigned long flags;
260         u16 tmp;
261 
262         flags = arch_local_cli_save();
263 
264         tmp = GxICR(irq);
265         GxICR(irq) = tmp & GxICR_LEVEL;
266         tmp = GxICR(irq);
267 
268         arch_local_irq_restore(flags);
269 }
270 
271 static void mn10300_ipi_chip_disable(struct irq_data *d)
272 {
273         mn10300_ipi_disable(d->irq);
274 }
275 
276 
277 /**
278  * mn10300_ipi_ack - Acknowledge an IPI interrupt in the PIC
279  * @irq: The IPI to be acknowledged.
280  *
281  * Clear the interrupt detection flag for the IPI on the appropriate interrupt
282  * channel in the PIC.
283  */
284 static void mn10300_ipi_ack(struct irq_data *d)
285 {
286         unsigned int irq = d->irq;
287         unsigned long flags;
288         u16 tmp;
289 
290         flags = arch_local_cli_save();
291         GxICR_u8(irq) = GxICR_DETECT;
292         tmp = GxICR(irq);
293         arch_local_irq_restore(flags);
294 }
295 
296 /**
297  * mn10300_ipi_nop - Dummy IPI action
298  * @irq: The IPI to be acted upon.
299  */
300 static void mn10300_ipi_nop(struct irq_data *d)
301 {
302 }
303 
304 /**
305  * send_IPI_mask - Send IPIs to all CPUs in list
306  * @cpumask: The list of CPUs to target.
307  * @irq: The IPI request to be sent.
308  *
309  * Send the specified IPI to all the CPUs in the list, not waiting for them to
310  * finish before returning.  The caller is responsible for synchronisation if
311  * that is needed.
312  */
313 static void send_IPI_mask(const cpumask_t *cpumask, int irq)
314 {
315         int i;
316         u16 tmp;
317 
318         for (i = 0; i < NR_CPUS; i++) {
319                 if (cpumask_test_cpu(i, cpumask)) {
320                         /* send IPI */
321                         tmp = CROSS_GxICR(irq, i);
322                         CROSS_GxICR(irq, i) =
323                                 tmp | GxICR_REQUEST | GxICR_DETECT;
324                         tmp = CROSS_GxICR(irq, i); /* flush write buffer */
325                 }
326         }
327 }
328 
329 /**
330  * send_IPI_self - Send an IPI to this CPU.
331  * @irq: The IPI request to be sent.
332  *
333  * Send the specified IPI to the current CPU.
334  */
335 void send_IPI_self(int irq)
336 {
337         send_IPI_mask(cpumask_of(smp_processor_id()), irq);
338 }
339 
340 /**
341  * send_IPI_allbutself - Send IPIs to all the other CPUs.
342  * @irq: The IPI request to be sent.
343  *
344  * Send the specified IPI to all CPUs in the system barring the current one,
345  * not waiting for them to finish before returning.  The caller is responsible
346  * for synchronisation if that is needed.
347  */
348 void send_IPI_allbutself(int irq)
349 {
350         cpumask_t cpumask;
351 
352         cpumask_copy(&cpumask, cpu_online_mask);
353         cpumask_clear_cpu(smp_processor_id(), &cpumask);
354         send_IPI_mask(&cpumask, irq);
355 }
356 
357 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
358 {
359         BUG();
360         /*send_IPI_mask(mask, CALL_FUNCTION_IPI);*/
361 }
362 
363 void arch_send_call_function_single_ipi(int cpu)
364 {
365         send_IPI_mask(cpumask_of(cpu), CALL_FUNC_SINGLE_IPI);
366 }
367 
368 /**
369  * smp_send_reschedule - Send reschedule IPI to a CPU
370  * @cpu: The CPU to target.
371  */
372 void smp_send_reschedule(int cpu)
373 {
374         send_IPI_mask(cpumask_of(cpu), RESCHEDULE_IPI);
375 }
376 
377 /**
378  * smp_nmi_call_function - Send a call function NMI IPI to all CPUs
379  * @func: The function to ask to be run.
380  * @info: The context data to pass to that function.
381  * @wait: If true, wait (atomically) until function is run on all CPUs.
382  *
383  * Send a non-maskable request to all CPUs in the system, requesting them to
384  * run the specified function with the given context data, and, potentially, to
385  * wait for completion of that function on all CPUs.
386  *
387  * Returns 0 if successful, -ETIMEDOUT if we were asked to wait, but hit the
388  * timeout.
389  */
390 int smp_nmi_call_function(smp_call_func_t func, void *info, int wait)
391 {
392         struct nmi_call_data_struct data;
393         unsigned long flags;
394         unsigned int cnt;
395         int cpus, ret = 0;
396 
397         cpus = num_online_cpus() - 1;
398         if (cpus < 1)
399                 return 0;
400 
401         data.func = func;
402         data.info = info;
403         cpumask_copy(&data.started, cpu_online_mask);
404         cpumask_clear_cpu(smp_processor_id(), &data.started);
405         data.wait = wait;
406         if (wait)
407                 data.finished = data.started;
408 
409         spin_lock_irqsave(&smp_nmi_call_lock, flags);
410         nmi_call_data = &data;
411         smp_mb();
412 
413         /* Send a message to all other CPUs and wait for them to respond */
414         send_IPI_allbutself(CALL_FUNCTION_NMI_IPI);
415 
416         /* Wait for response */
417         if (CALL_FUNCTION_NMI_IPI_TIMEOUT > 0) {
418                 for (cnt = 0;
419                      cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT &&
420                              !cpumask_empty(&data.started);
421                      cnt++)
422                         mdelay(1);
423 
424                 if (wait && cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT) {
425                         for (cnt = 0;
426                              cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT &&
427                                      !cpumask_empty(&data.finished);
428                              cnt++)
429                                 mdelay(1);
430                 }
431 
432                 if (cnt >= CALL_FUNCTION_NMI_IPI_TIMEOUT)
433                         ret = -ETIMEDOUT;
434 
435         } else {
436                 /* If timeout value is zero, wait until cpumask has been
437                  * cleared */
438                 while (!cpumask_empty(&data.started))
439                         barrier();
440                 if (wait)
441                         while (!cpumask_empty(&data.finished))
442                                 barrier();
443         }
444 
445         spin_unlock_irqrestore(&smp_nmi_call_lock, flags);
446         return ret;
447 }
448 
449 /**
450  * smp_jump_to_debugger - Make other CPUs enter the debugger by sending an IPI
451  *
452  * Send a non-maskable request to all other CPUs in the system, instructing
453  * them to jump into the debugger.  The caller is responsible for checking that
454  * the other CPUs responded to the instruction.
455  *
456  * The caller should make sure that this CPU's debugger IPI is disabled.
457  */
458 void smp_jump_to_debugger(void)
459 {
460         if (num_online_cpus() > 1)
461                 /* Send a message to all other CPUs */
462                 send_IPI_allbutself(DEBUGGER_NMI_IPI);
463 }
464 
465 /**
466  * stop_this_cpu - Callback to stop a CPU.
467  * @unused: Callback context (ignored).
468  */
469 void stop_this_cpu(void *unused)
470 {
471         static volatile int stopflag;
472         unsigned long flags;
473 
474 #ifdef CONFIG_GDBSTUB
475         /* In case of single stepping smp_send_stop by other CPU,
476          * clear procindebug to avoid deadlock.
477          */
478         atomic_set(&procindebug[smp_processor_id()], 0);
479 #endif  /* CONFIG_GDBSTUB */
480 
481         flags = arch_local_cli_save();
482         set_cpu_online(smp_processor_id(), false);
483 
484         while (!stopflag)
485                 cpu_relax();
486 
487         set_cpu_online(smp_processor_id(), true);
488         arch_local_irq_restore(flags);
489 }
490 
491 /**
492  * smp_send_stop - Send a stop request to all CPUs.
493  */
494 void smp_send_stop(void)
495 {
496         smp_nmi_call_function(stop_this_cpu, NULL, 0);
497 }
498 
499 /**
500  * smp_reschedule_interrupt - Reschedule IPI handler
501  * @irq: The interrupt number.
502  * @dev_id: The device ID.
503  *
504  * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
505  */
506 static irqreturn_t smp_reschedule_interrupt(int irq, void *dev_id)
507 {
508         scheduler_ipi();
509         return IRQ_HANDLED;
510 }
511 
512 /**
513  * smp_call_function_interrupt - Call function IPI handler
514  * @irq: The interrupt number.
515  * @dev_id: The device ID.
516  *
517  * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
518  */
519 static irqreturn_t smp_call_function_interrupt(int irq, void *dev_id)
520 {
521         /* generic_smp_call_function_interrupt(); */
522         generic_smp_call_function_single_interrupt();
523         return IRQ_HANDLED;
524 }
525 
526 /**
527  * smp_nmi_call_function_interrupt - Non-maskable call function IPI handler
528  */
529 void smp_nmi_call_function_interrupt(void)
530 {
531         smp_call_func_t func = nmi_call_data->func;
532         void *info = nmi_call_data->info;
533         int wait = nmi_call_data->wait;
534 
535         /* Notify the initiating CPU that I've grabbed the data and am about to
536          * execute the function
537          */
538         smp_mb();
539         cpumask_clear_cpu(smp_processor_id(), &nmi_call_data->started);
540         (*func)(info);
541 
542         if (wait) {
543                 smp_mb();
544                 cpumask_clear_cpu(smp_processor_id(),
545                                   &nmi_call_data->finished);
546         }
547 }
548 
549 #if !defined(CONFIG_GENERIC_CLOCKEVENTS) || \
550     defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
551 /**
552  * smp_ipi_timer_interrupt - Local timer IPI handler
553  * @irq: The interrupt number.
554  * @dev_id: The device ID.
555  *
556  * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
557  */
558 static irqreturn_t smp_ipi_timer_interrupt(int irq, void *dev_id)
559 {
560         return local_timer_interrupt();
561 }
562 #endif
563 
564 void __init smp_init_cpus(void)
565 {
566         int i;
567         for (i = 0; i < NR_CPUS; i++) {
568                 set_cpu_possible(i, true);
569                 set_cpu_present(i, true);
570         }
571 }
572 
573 /**
574  * smp_cpu_init - Initialise AP in start_secondary.
575  *
576  * For this Application Processor, set up init_mm, initialise FPU and set
577  * interrupt level 0-6 setting.
578  */
579 static void __init smp_cpu_init(void)
580 {
581         unsigned long flags;
582         int cpu_id = smp_processor_id();
583         u16 tmp16;
584 
585         if (test_and_set_bit(cpu_id, &cpu_initialized)) {
586                 printk(KERN_WARNING "CPU#%d already initialized!\n", cpu_id);
587                 for (;;)
588                         local_irq_enable();
589         }
590         printk(KERN_INFO "Initializing CPU#%d\n", cpu_id);
591 
592         atomic_inc(&init_mm.mm_count);
593         current->active_mm = &init_mm;
594         BUG_ON(current->mm);
595 
596         enter_lazy_tlb(&init_mm, current);
597 
598         /* Force FPU initialization */
599         clear_using_fpu(current);
600 
601         GxICR(CALL_FUNC_SINGLE_IPI) = CALL_FUNCTION_GxICR_LV | GxICR_DETECT;
602         mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
603 
604         GxICR(LOCAL_TIMER_IPI) = LOCAL_TIMER_GxICR_LV | GxICR_DETECT;
605         mn10300_ipi_enable(LOCAL_TIMER_IPI);
606 
607         GxICR(RESCHEDULE_IPI) = RESCHEDULE_GxICR_LV | GxICR_DETECT;
608         mn10300_ipi_enable(RESCHEDULE_IPI);
609 
610 #ifdef CONFIG_MN10300_CACHE_ENABLED
611         GxICR(FLUSH_CACHE_IPI) = FLUSH_CACHE_GxICR_LV | GxICR_DETECT;
612         mn10300_ipi_enable(FLUSH_CACHE_IPI);
613 #endif
614 
615         mn10300_ipi_shutdown(SMP_BOOT_IRQ);
616 
617         /* Set up the non-maskable call function IPI */
618         flags = arch_local_cli_save();
619         GxICR(CALL_FUNCTION_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
620         tmp16 = GxICR(CALL_FUNCTION_NMI_IPI);
621         arch_local_irq_restore(flags);
622 }
623 
624 /**
625  * smp_prepare_cpu_init - Initialise CPU in startup_secondary
626  *
627  * Set interrupt level 0-6 setting and init ICR of the kernel debugger.
628  */
629 void smp_prepare_cpu_init(void)
630 {
631         int loop;
632 
633         /* Set the interrupt vector registers */
634         IVAR0 = EXCEP_IRQ_LEVEL0;
635         IVAR1 = EXCEP_IRQ_LEVEL1;
636         IVAR2 = EXCEP_IRQ_LEVEL2;
637         IVAR3 = EXCEP_IRQ_LEVEL3;
638         IVAR4 = EXCEP_IRQ_LEVEL4;
639         IVAR5 = EXCEP_IRQ_LEVEL5;
640         IVAR6 = EXCEP_IRQ_LEVEL6;
641 
642         /* Disable all interrupts and set to priority 6 (lowest) */
643         for (loop = 0; loop < GxICR_NUM_IRQS; loop++)
644                 GxICR(loop) = GxICR_LEVEL_6 | GxICR_DETECT;
645 
646 #ifdef CONFIG_KERNEL_DEBUGGER
647         /* initialise the kernel debugger interrupt */
648         do {
649                 unsigned long flags;
650                 u16 tmp16;
651 
652                 flags = arch_local_cli_save();
653                 GxICR(DEBUGGER_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
654                 tmp16 = GxICR(DEBUGGER_NMI_IPI);
655                 arch_local_irq_restore(flags);
656         } while (0);
657 #endif
658 }
659 
660 /**
661  * start_secondary - Activate a secondary CPU (AP)
662  * @unused: Thread parameter (ignored).
663  */
664 int __init start_secondary(void *unused)
665 {
666         smp_cpu_init();
667         smp_callin();
668         while (!cpumask_test_cpu(smp_processor_id(), &smp_commenced_mask))
669                 cpu_relax();
670 
671         local_flush_tlb();
672         preempt_disable();
673         smp_online();
674 
675 #ifdef CONFIG_GENERIC_CLOCKEVENTS
676         init_clockevents();
677 #endif
678         cpu_startup_entry(CPUHP_ONLINE);
679         return 0;
680 }
681 
682 /**
683  * smp_prepare_cpus - Boot up secondary CPUs (APs)
684  * @max_cpus: Maximum number of CPUs to boot.
685  *
686  * Call do_boot_cpu, and boot up APs.
687  */
688 void __init smp_prepare_cpus(unsigned int max_cpus)
689 {
690         int phy_id;
691 
692         /* Setup boot CPU information */
693         smp_store_cpu_info(0);
694         smp_tune_scheduling();
695 
696         init_ipi();
697 
698         /* If SMP should be disabled, then finish */
699         if (max_cpus == 0) {
700                 printk(KERN_INFO "SMP mode deactivated.\n");
701                 goto smp_done;
702         }
703 
704         /* Boot secondary CPUs (for which phy_id > 0) */
705         for (phy_id = 0; phy_id < NR_CPUS; phy_id++) {
706                 /* Don't boot primary CPU */
707                 if (max_cpus <= cpucount + 1)
708                         continue;
709                 if (phy_id != 0)
710                         do_boot_cpu(phy_id);
711                 set_cpu_possible(phy_id, true);
712                 smp_show_cpu_info(phy_id);
713         }
714 
715 smp_done:
716         Dprintk("Boot done.\n");
717 }
718 
719 /**
720  * smp_store_cpu_info - Save a CPU's information
721  * @cpu: The CPU to save for.
722  *
723  * Save boot_cpu_data and jiffy for the specified CPU.
724  */
725 static void __init smp_store_cpu_info(int cpu)
726 {
727         struct mn10300_cpuinfo *ci = &cpu_data[cpu];
728 
729         *ci = boot_cpu_data;
730         ci->loops_per_jiffy = loops_per_jiffy;
731         ci->type = CPUREV;
732 }
733 
734 /**
735  * smp_tune_scheduling - Set time slice value
736  *
737  * Nothing to do here.
738  */
739 static void __init smp_tune_scheduling(void)
740 {
741 }
742 
743 /**
744  * do_boot_cpu: Boot up one CPU
745  * @phy_id: Physical ID of CPU to boot.
746  *
747  * Send an IPI to a secondary CPU to boot it.  Returns 0 on success, 1
748  * otherwise.
749  */
750 static int __init do_boot_cpu(int phy_id)
751 {
752         struct task_struct *idle;
753         unsigned long send_status, callin_status;
754         int timeout, cpu_id;
755 
756         send_status = GxICR_REQUEST;
757         callin_status = 0;
758         timeout = 0;
759         cpu_id = phy_id;
760 
761         cpucount++;
762 
763         /* Create idle thread for this CPU */
764         idle = fork_idle(cpu_id);
765         if (IS_ERR(idle))
766                 panic("Failed fork for CPU#%d.", cpu_id);
767 
768         idle->thread.pc = (unsigned long)start_secondary;
769 
770         printk(KERN_NOTICE "Booting CPU#%d\n", cpu_id);
771         start_stack[cpu_id - 1] = idle->thread.sp;
772 
773         task_thread_info(idle)->cpu = cpu_id;
774 
775         /* Send boot IPI to AP */
776         send_IPI_mask(cpumask_of(phy_id), SMP_BOOT_IRQ);
777 
778         Dprintk("Waiting for send to finish...\n");
779 
780         /* Wait for AP's IPI receive in 100[ms] */
781         do {
782                 udelay(1000);
783                 send_status =
784                         CROSS_GxICR(SMP_BOOT_IRQ, phy_id) & GxICR_REQUEST;
785         } while (send_status == GxICR_REQUEST && timeout++ < 100);
786 
787         Dprintk("Waiting for cpu_callin_map.\n");
788 
789         if (send_status == 0) {
790                 /* Allow AP to start initializing */
791                 cpumask_set_cpu(cpu_id, &cpu_callout_map);
792 
793                 /* Wait for setting cpu_callin_map */
794                 timeout = 0;
795                 do {
796                         udelay(1000);
797                         callin_status = cpumask_test_cpu(cpu_id,
798                                                          &cpu_callin_map);
799                 } while (callin_status == 0 && timeout++ < 5000);
800 
801                 if (callin_status == 0)
802                         Dprintk("Not responding.\n");
803         } else {
804                 printk(KERN_WARNING "IPI not delivered.\n");
805         }
806 
807         if (send_status == GxICR_REQUEST || callin_status == 0) {
808                 cpumask_clear_cpu(cpu_id, &cpu_callout_map);
809                 cpumask_clear_cpu(cpu_id, &cpu_callin_map);
810                 cpumask_clear_cpu(cpu_id, &cpu_initialized);
811                 cpucount--;
812                 return 1;
813         }
814         return 0;
815 }
816 
817 /**
818  * smp_show_cpu_info - Show SMP CPU information
819  * @cpu: The CPU of interest.
820  */
821 static void __init smp_show_cpu_info(int cpu)
822 {
823         struct mn10300_cpuinfo *ci = &cpu_data[cpu];
824 
825         printk(KERN_INFO
826                "CPU#%d : ioclk speed: %lu.%02luMHz : bogomips : %lu.%02lu\n",
827                cpu,
828                MN10300_IOCLK / 1000000,
829                (MN10300_IOCLK / 10000) % 100,
830                ci->loops_per_jiffy / (500000 / HZ),
831                (ci->loops_per_jiffy / (5000 / HZ)) % 100);
832 }
833 
834 /**
835  * smp_callin - Set cpu_callin_map of the current CPU ID
836  */
837 static void __init smp_callin(void)
838 {
839         unsigned long timeout;
840         int cpu;
841 
842         cpu = smp_processor_id();
843         timeout = jiffies + (2 * HZ);
844 
845         if (cpumask_test_cpu(cpu, &cpu_callin_map)) {
846                 printk(KERN_ERR "CPU#%d already present.\n", cpu);
847                 BUG();
848         }
849         Dprintk("CPU#%d waiting for CALLOUT\n", cpu);
850 
851         /* Wait for AP startup 2s total */
852         while (time_before(jiffies, timeout)) {
853                 if (cpumask_test_cpu(cpu, &cpu_callout_map))
854                         break;
855                 cpu_relax();
856         }
857 
858         if (!time_before(jiffies, timeout)) {
859                 printk(KERN_ERR
860                        "BUG: CPU#%d started up but did not get a callout!\n",
861                        cpu);
862                 BUG();
863         }
864 
865 #ifdef CONFIG_CALIBRATE_DELAY
866         calibrate_delay();              /* Get our bogomips */
867 #endif
868 
869         /* Save our processor parameters */
870         smp_store_cpu_info(cpu);
871 
872         /* Allow the boot processor to continue */
873         cpumask_set_cpu(cpu, &cpu_callin_map);
874 }
875 
876 /**
877  * smp_online - Set cpu_online_mask
878  */
879 static void __init smp_online(void)
880 {
881         int cpu;
882 
883         cpu = smp_processor_id();
884 
885         notify_cpu_starting(cpu);
886 
887         set_cpu_online(cpu, true);
888 
889         local_irq_enable();
890 }
891 
892 /**
893  * smp_cpus_done -
894  * @max_cpus: Maximum CPU count.
895  *
896  * Do nothing.
897  */
898 void __init smp_cpus_done(unsigned int max_cpus)
899 {
900 }
901 
902 /*
903  * smp_prepare_boot_cpu - Set up stuff for the boot processor.
904  *
905  * Set up the cpu_online_mask, cpu_callout_map and cpu_callin_map of the boot
906  * processor (CPU 0).
907  */
908 void smp_prepare_boot_cpu(void)
909 {
910         cpumask_set_cpu(0, &cpu_callout_map);
911         cpumask_set_cpu(0, &cpu_callin_map);
912         current_thread_info()->cpu = 0;
913 }
914 
915 /*
916  * initialize_secondary - Initialise a secondary CPU (Application Processor).
917  *
918  * Set SP register and jump to thread's PC address.
919  */
920 void initialize_secondary(void)
921 {
922         asm volatile (
923                 "mov    %0,sp   \n"
924                 "jmp    (%1)    \n"
925                 :
926                 : "a"(current->thread.sp), "a"(current->thread.pc));
927 }
928 
929 /**
930  * __cpu_up - Set smp_commenced_mask for the nominated CPU
931  * @cpu: The target CPU.
932  */
933 int __cpu_up(unsigned int cpu, struct task_struct *tidle)
934 {
935         int timeout;
936 
937 #ifdef CONFIG_HOTPLUG_CPU
938         if (sleep_mode[cpu])
939                 run_wakeup_cpu(cpu);
940 #endif /* CONFIG_HOTPLUG_CPU */
941 
942         cpumask_set_cpu(cpu, &smp_commenced_mask);
943 
944         /* Wait 5s total for a response */
945         for (timeout = 0 ; timeout < 5000 ; timeout++) {
946                 if (cpu_online(cpu))
947                         break;
948                 udelay(1000);
949         }
950 
951         BUG_ON(!cpu_online(cpu));
952         return 0;
953 }
954 
955 /**
956  * setup_profiling_timer - Set up the profiling timer
957  * @multiplier - The frequency multiplier to use
958  *
959  * The frequency of the profiling timer can be changed by writing a multiplier
960  * value into /proc/profile.
961  */
962 int setup_profiling_timer(unsigned int multiplier)
963 {
964         return -EINVAL;
965 }
966 
967 /*
968  * CPU hotplug routines
969  */
970 #ifdef CONFIG_HOTPLUG_CPU
971 
972 static DEFINE_PER_CPU(struct cpu, cpu_devices);
973 
974 static int __init topology_init(void)
975 {
976         int cpu, ret;
977 
978         for_each_cpu(cpu) {
979                 ret = register_cpu(&per_cpu(cpu_devices, cpu), cpu, NULL);
980                 if (ret)
981                         printk(KERN_WARNING
982                                "topology_init: register_cpu %d failed (%d)\n",
983                                cpu, ret);
984         }
985         return 0;
986 }
987 
988 subsys_initcall(topology_init);
989 
990 int __cpu_disable(void)
991 {
992         int cpu = smp_processor_id();
993         if (cpu == 0)
994                 return -EBUSY;
995 
996         migrate_irqs();
997         cpumask_clear_cpu(cpu, &mm_cpumask(current->active_mm));
998         return 0;
999 }
1000 
1001 void __cpu_die(unsigned int cpu)
1002 {
1003         run_sleep_cpu(cpu);
1004 }
1005 
1006 #ifdef CONFIG_MN10300_CACHE_ENABLED
1007 static inline void hotplug_cpu_disable_cache(void)
1008 {
1009         int tmp;
1010         asm volatile(
1011                 "       movhu   (%1),%0 \n"
1012                 "       and     %2,%0   \n"
1013                 "       movhu   %0,(%1) \n"
1014                 "1:     movhu   (%1),%0 \n"
1015                 "       btst    %3,%0   \n"
1016                 "       bne     1b      \n"
1017                 : "=&r"(tmp)
1018                 : "a"(&CHCTR),
1019                   "i"(~(CHCTR_ICEN | CHCTR_DCEN)),
1020                   "i"(CHCTR_ICBUSY | CHCTR_DCBUSY)
1021                 : "memory", "cc");
1022 }
1023 
1024 static inline void hotplug_cpu_enable_cache(void)
1025 {
1026         int tmp;
1027         asm volatile(
1028                 "movhu  (%1),%0 \n"
1029                 "or     %2,%0   \n"
1030                 "movhu  %0,(%1) \n"
1031                 : "=&r"(tmp)
1032                 : "a"(&CHCTR),
1033                   "i"(CHCTR_ICEN | CHCTR_DCEN)
1034                 : "memory", "cc");
1035 }
1036 
1037 static inline void hotplug_cpu_invalidate_cache(void)
1038 {
1039         int tmp;
1040         asm volatile (
1041                 "movhu  (%1),%0 \n"
1042                 "or     %2,%0   \n"
1043                 "movhu  %0,(%1) \n"
1044                 : "=&r"(tmp)
1045                 : "a"(&CHCTR),
1046                   "i"(CHCTR_ICINV | CHCTR_DCINV)
1047                 : "cc");
1048 }
1049 
1050 #else /* CONFIG_MN10300_CACHE_ENABLED */
1051 #define hotplug_cpu_disable_cache()     do {} while (0)
1052 #define hotplug_cpu_enable_cache()      do {} while (0)
1053 #define hotplug_cpu_invalidate_cache()  do {} while (0)
1054 #endif /* CONFIG_MN10300_CACHE_ENABLED */
1055 
1056 /**
1057  * hotplug_cpu_nmi_call_function - Call a function on other CPUs for hotplug
1058  * @cpumask: List of target CPUs.
1059  * @func: The function to call on those CPUs.
1060  * @info: The context data for the function to be called.
1061  * @wait: Whether to wait for the calls to complete.
1062  *
1063  * Non-maskably call a function on another CPU for hotplug purposes.
1064  *
1065  * This function must be called with maskable interrupts disabled.
1066  */
1067 static int hotplug_cpu_nmi_call_function(cpumask_t cpumask,
1068                                          smp_call_func_t func, void *info,
1069                                          int wait)
1070 {
1071         /*
1072          * The address and the size of nmi_call_func_mask_data
1073          * need to be aligned on L1_CACHE_BYTES.
1074          */
1075         static struct nmi_call_data_struct nmi_call_func_mask_data
1076                 __cacheline_aligned;
1077         unsigned long start, end;
1078 
1079         start = (unsigned long)&nmi_call_func_mask_data;
1080         end = start + sizeof(struct nmi_call_data_struct);
1081 
1082         nmi_call_func_mask_data.func = func;
1083         nmi_call_func_mask_data.info = info;
1084         nmi_call_func_mask_data.started = cpumask;
1085         nmi_call_func_mask_data.wait = wait;
1086         if (wait)
1087                 nmi_call_func_mask_data.finished = cpumask;
1088 
1089         spin_lock(&smp_nmi_call_lock);
1090         nmi_call_data = &nmi_call_func_mask_data;
1091         mn10300_local_dcache_flush_range(start, end);
1092         smp_wmb();
1093 
1094         send_IPI_mask(cpumask, CALL_FUNCTION_NMI_IPI);
1095 
1096         do {
1097                 mn10300_local_dcache_inv_range(start, end);
1098                 barrier();
1099         } while (!cpumask_empty(&nmi_call_func_mask_data.started));
1100 
1101         if (wait) {
1102                 do {
1103                         mn10300_local_dcache_inv_range(start, end);
1104                         barrier();
1105                 } while (!cpumask_empty(&nmi_call_func_mask_data.finished));
1106         }
1107 
1108         spin_unlock(&smp_nmi_call_lock);
1109         return 0;
1110 }
1111 
1112 static void restart_wakeup_cpu(void)
1113 {
1114         unsigned int cpu = smp_processor_id();
1115 
1116         cpumask_set_cpu(cpu, &cpu_callin_map);
1117         local_flush_tlb();
1118         set_cpu_online(cpu, true);
1119         smp_wmb();
1120 }
1121 
1122 static void prepare_sleep_cpu(void *unused)
1123 {
1124         sleep_mode[smp_processor_id()] = 1;
1125         smp_mb();
1126         mn10300_local_dcache_flush_inv();
1127         hotplug_cpu_disable_cache();
1128         hotplug_cpu_invalidate_cache();
1129 }
1130 
1131 /* when this function called, IE=0, NMID=0. */
1132 static void sleep_cpu(void *unused)
1133 {
1134         unsigned int cpu_id = smp_processor_id();
1135         /*
1136          * CALL_FUNCTION_NMI_IPI for wakeup_cpu() shall not be requested,
1137          * before this cpu goes in SLEEP mode.
1138          */
1139         do {
1140                 smp_mb();
1141                 __sleep_cpu();
1142         } while (sleep_mode[cpu_id]);
1143         restart_wakeup_cpu();
1144 }
1145 
1146 static void run_sleep_cpu(unsigned int cpu)
1147 {
1148         unsigned long flags;
1149         cpumask_t cpumask;
1150 
1151         cpumask_copy(&cpumask, &cpumask_of(cpu));
1152         flags = arch_local_cli_save();
1153         hotplug_cpu_nmi_call_function(cpumask, prepare_sleep_cpu, NULL, 1);
1154         hotplug_cpu_nmi_call_function(cpumask, sleep_cpu, NULL, 0);
1155         udelay(1);              /* delay for the cpu to sleep. */
1156         arch_local_irq_restore(flags);
1157 }
1158 
1159 static void wakeup_cpu(void)
1160 {
1161         hotplug_cpu_invalidate_cache();
1162         hotplug_cpu_enable_cache();
1163         smp_mb();
1164         sleep_mode[smp_processor_id()] = 0;
1165 }
1166 
1167 static void run_wakeup_cpu(unsigned int cpu)
1168 {
1169         unsigned long flags;
1170 
1171         flags = arch_local_cli_save();
1172 #if NR_CPUS == 2
1173         mn10300_local_dcache_flush_inv();
1174 #else
1175         /*
1176          * Before waking up the cpu,
1177          * all online cpus should stop and flush D-Cache for global data.
1178          */
1179 #error not support NR_CPUS > 2, when CONFIG_HOTPLUG_CPU=y.
1180 #endif
1181         hotplug_cpu_nmi_call_function(cpumask_of(cpu), wakeup_cpu, NULL, 1);
1182         arch_local_irq_restore(flags);
1183 }
1184 
1185 #endif /* CONFIG_HOTPLUG_CPU */
1186 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp