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

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

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

~ [ 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