1 /* SMP support routines.
3 * Copyright (C) 2006-2008 Panasonic Corporation
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.
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.
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 <asm/tlbflush.h>
28 #include <asm/system.h>
29 #include <asm/bitops.h>
30 #include <asm/processor.h>
32 #include <asm/exceptions.h>
33 #include <asm/hardirq.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>
41 #ifdef CONFIG_HOTPLUG_CPU
42 #include <linux/cpu.h>
43 #include <asm/cacheflush.h>
45 static unsigned long sleep_mode[NR_CPUS];
47 static void run_sleep_cpu(unsigned int cpu);
48 static void run_wakeup_cpu(unsigned int cpu);
49 #endif /* CONFIG_HOTPLUG_CPU */
52 * Debug Message function
57 #define Dprintk(fmt, ...) printk(KERN_DEBUG fmt, ##__VA_ARGS__)
59 #define Dprintk(fmt, ...) no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
62 /* timeout value in msec for smp_nmi_call_function. zero is no timeout. */
63 #define CALL_FUNCTION_NMI_IPI_TIMEOUT 0
66 * Structure and data for smp_nmi_call_function().
68 struct nmi_call_data_struct {
74 char size_alignment[0]
75 __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
76 } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
78 static DEFINE_SPINLOCK(smp_nmi_call_lock);
79 static struct nmi_call_data_struct *nmi_call_data;
82 * Data structures and variables
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];
92 struct mn10300_cpuinfo cpu_data[NR_CPUS] __cacheline_aligned;
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;
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);
112 * IPI Initialization interrupt definitions
114 static void mn10300_ipi_disable(unsigned int irq);
115 static void mn10300_ipi_enable(unsigned int irq);
116 static void mn10300_ipi_ack(unsigned int irq);
117 static void mn10300_ipi_nop(unsigned int irq);
119 static struct irq_chip mn10300_ipi_type = {
121 .disable = mn10300_ipi_disable,
122 .enable = mn10300_ipi_enable,
123 .ack = mn10300_ipi_ack,
124 .eoi = mn10300_ipi_nop
127 static irqreturn_t smp_reschedule_interrupt(int irq, void *dev_id);
128 static irqreturn_t smp_call_function_interrupt(int irq, void *dev_id);
129 static irqreturn_t smp_ipi_timer_interrupt(int irq, void *dev_id);
131 static struct irqaction reschedule_ipi = {
132 .handler = smp_reschedule_interrupt,
133 .name = "smp reschedule IPI"
135 static struct irqaction call_function_ipi = {
136 .handler = smp_call_function_interrupt,
137 .name = "smp call function IPI"
139 static struct irqaction local_timer_ipi = {
140 .handler = smp_ipi_timer_interrupt,
141 .flags = IRQF_DISABLED,
142 .name = "smp local timer IPI"
146 * init_ipi - Initialise the IPI mechanism
148 static void init_ipi(void)
153 /* set up the reschedule IPI */
154 set_irq_chip_and_handler(RESCHEDULE_IPI,
155 &mn10300_ipi_type, handle_percpu_irq);
156 setup_irq(RESCHEDULE_IPI, &reschedule_ipi);
157 set_intr_level(RESCHEDULE_IPI, RESCHEDULE_GxICR_LV);
158 mn10300_ipi_enable(RESCHEDULE_IPI);
160 /* set up the call function IPI */
161 set_irq_chip_and_handler(CALL_FUNC_SINGLE_IPI,
162 &mn10300_ipi_type, handle_percpu_irq);
163 setup_irq(CALL_FUNC_SINGLE_IPI, &call_function_ipi);
164 set_intr_level(CALL_FUNC_SINGLE_IPI, CALL_FUNCTION_GxICR_LV);
165 mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
167 /* set up the local timer IPI */
168 set_irq_chip_and_handler(LOCAL_TIMER_IPI,
169 &mn10300_ipi_type, handle_percpu_irq);
170 setup_irq(LOCAL_TIMER_IPI, &local_timer_ipi);
171 set_intr_level(LOCAL_TIMER_IPI, LOCAL_TIMER_GxICR_LV);
172 mn10300_ipi_enable(LOCAL_TIMER_IPI);
174 #ifdef CONFIG_MN10300_CACHE_ENABLED
175 /* set up the cache flush IPI */
176 flags = arch_local_cli_save();
177 __set_intr_stub(NUM2EXCEP_IRQ_LEVEL(FLUSH_CACHE_GxICR_LV),
178 mn10300_low_ipi_handler);
179 GxICR(FLUSH_CACHE_IPI) = FLUSH_CACHE_GxICR_LV | GxICR_DETECT;
180 mn10300_ipi_enable(FLUSH_CACHE_IPI);
181 arch_local_irq_restore(flags);
184 /* set up the NMI call function IPI */
185 flags = arch_local_cli_save();
186 GxICR(CALL_FUNCTION_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
187 tmp16 = GxICR(CALL_FUNCTION_NMI_IPI);
188 arch_local_irq_restore(flags);
190 /* set up the SMP boot IPI */
191 flags = arch_local_cli_save();
192 __set_intr_stub(NUM2EXCEP_IRQ_LEVEL(SMP_BOOT_GxICR_LV),
193 mn10300_low_ipi_handler);
194 arch_local_irq_restore(flags);
198 * mn10300_ipi_shutdown - Shut down handling of an IPI
199 * @irq: The IPI to be shut down.
201 static void mn10300_ipi_shutdown(unsigned int irq)
206 flags = arch_local_cli_save();
209 GxICR(irq) = (tmp & GxICR_LEVEL) | GxICR_DETECT;
212 arch_local_irq_restore(flags);
216 * mn10300_ipi_enable - Enable an IPI
217 * @irq: The IPI to be enabled.
219 static void mn10300_ipi_enable(unsigned int irq)
224 flags = arch_local_cli_save();
227 GxICR(irq) = (tmp & GxICR_LEVEL) | GxICR_ENABLE;
230 arch_local_irq_restore(flags);
234 * mn10300_ipi_disable - Disable an IPI
235 * @irq: The IPI to be disabled.
237 static void mn10300_ipi_disable(unsigned int irq)
242 flags = arch_local_cli_save();
245 GxICR(irq) = tmp & GxICR_LEVEL;
248 arch_local_irq_restore(flags);
252 * mn10300_ipi_ack - Acknowledge an IPI interrupt in the PIC
253 * @irq: The IPI to be acknowledged.
255 * Clear the interrupt detection flag for the IPI on the appropriate interrupt
256 * channel in the PIC.
258 static void mn10300_ipi_ack(unsigned int irq)
263 flags = arch_local_cli_save();
264 GxICR_u8(irq) = GxICR_DETECT;
266 arch_local_irq_restore(flags);
270 * mn10300_ipi_nop - Dummy IPI action
271 * @irq: The IPI to be acted upon.
273 static void mn10300_ipi_nop(unsigned int irq)
278 * send_IPI_mask - Send IPIs to all CPUs in list
279 * @cpumask: The list of CPUs to target.
280 * @irq: The IPI request to be sent.
282 * Send the specified IPI to all the CPUs in the list, not waiting for them to
283 * finish before returning. The caller is responsible for synchronisation if
286 static void send_IPI_mask(const cpumask_t *cpumask, int irq)
291 for (i = 0; i < NR_CPUS; i++) {
292 if (cpu_isset(i, *cpumask)) {
294 tmp = CROSS_GxICR(irq, i);
295 CROSS_GxICR(irq, i) =
296 tmp | GxICR_REQUEST | GxICR_DETECT;
297 tmp = CROSS_GxICR(irq, i); /* flush write buffer */
303 * send_IPI_self - Send an IPI to this CPU.
304 * @irq: The IPI request to be sent.
306 * Send the specified IPI to the current CPU.
308 void send_IPI_self(int irq)
310 send_IPI_mask(cpumask_of(smp_processor_id()), irq);
314 * send_IPI_allbutself - Send IPIs to all the other CPUs.
315 * @irq: The IPI request to be sent.
317 * Send the specified IPI to all CPUs in the system barring the current one,
318 * not waiting for them to finish before returning. The caller is responsible
319 * for synchronisation if that is needed.
321 void send_IPI_allbutself(int irq)
325 cpumask = cpu_online_map;
326 cpu_clear(smp_processor_id(), cpumask);
327 send_IPI_mask(&cpumask, irq);
330 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
333 /*send_IPI_mask(mask, CALL_FUNCTION_IPI);*/
336 void arch_send_call_function_single_ipi(int cpu)
338 send_IPI_mask(cpumask_of(cpu), CALL_FUNC_SINGLE_IPI);
342 * smp_send_reschedule - Send reschedule IPI to a CPU
343 * @cpu: The CPU to target.
345 void smp_send_reschedule(int cpu)
347 send_IPI_mask(cpumask_of(cpu), RESCHEDULE_IPI);
351 * smp_nmi_call_function - Send a call function NMI IPI to all CPUs
352 * @func: The function to ask to be run.
353 * @info: The context data to pass to that function.
354 * @wait: If true, wait (atomically) until function is run on all CPUs.
356 * Send a non-maskable request to all CPUs in the system, requesting them to
357 * run the specified function with the given context data, and, potentially, to
358 * wait for completion of that function on all CPUs.
360 * Returns 0 if successful, -ETIMEDOUT if we were asked to wait, but hit the
363 int smp_nmi_call_function(smp_call_func_t func, void *info, int wait)
365 struct nmi_call_data_struct data;
370 cpus = num_online_cpus() - 1;
376 data.started = cpu_online_map;
377 cpu_clear(smp_processor_id(), data.started);
380 data.finished = data.started;
382 spin_lock_irqsave(&smp_nmi_call_lock, flags);
383 nmi_call_data = &data;
386 /* Send a message to all other CPUs and wait for them to respond */
387 send_IPI_allbutself(CALL_FUNCTION_NMI_IPI);
389 /* Wait for response */
390 if (CALL_FUNCTION_NMI_IPI_TIMEOUT > 0) {
392 cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT &&
393 !cpus_empty(data.started);
397 if (wait && cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT) {
399 cnt < CALL_FUNCTION_NMI_IPI_TIMEOUT &&
400 !cpus_empty(data.finished);
405 if (cnt >= CALL_FUNCTION_NMI_IPI_TIMEOUT)
409 /* If timeout value is zero, wait until cpumask has been
411 while (!cpus_empty(data.started))
414 while (!cpus_empty(data.finished))
418 spin_unlock_irqrestore(&smp_nmi_call_lock, flags);
423 * stop_this_cpu - Callback to stop a CPU.
424 * @unused: Callback context (ignored).
426 void stop_this_cpu(void *unused)
428 static volatile int stopflag;
431 #ifdef CONFIG_GDBSTUB
432 /* In case of single stepping smp_send_stop by other CPU,
433 * clear procindebug to avoid deadlock.
435 atomic_set(&procindebug[smp_processor_id()], 0);
436 #endif /* CONFIG_GDBSTUB */
438 flags = arch_local_cli_save();
439 cpu_clear(smp_processor_id(), cpu_online_map);
444 cpu_set(smp_processor_id(), cpu_online_map);
445 arch_local_irq_restore(flags);
449 * smp_send_stop - Send a stop request to all CPUs.
451 void smp_send_stop(void)
453 smp_nmi_call_function(stop_this_cpu, NULL, 0);
457 * smp_reschedule_interrupt - Reschedule IPI handler
458 * @irq: The interrupt number.
459 * @dev_id: The device ID.
461 * We need do nothing here, since the scheduling will be effected on our way
462 * back through entry.S.
464 * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
466 static irqreturn_t smp_reschedule_interrupt(int irq, void *dev_id)
473 * smp_call_function_interrupt - Call function IPI handler
474 * @irq: The interrupt number.
475 * @dev_id: The device ID.
477 * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
479 static irqreturn_t smp_call_function_interrupt(int irq, void *dev_id)
481 /* generic_smp_call_function_interrupt(); */
482 generic_smp_call_function_single_interrupt();
487 * smp_nmi_call_function_interrupt - Non-maskable call function IPI handler
489 void smp_nmi_call_function_interrupt(void)
491 smp_call_func_t func = nmi_call_data->func;
492 void *info = nmi_call_data->info;
493 int wait = nmi_call_data->wait;
495 /* Notify the initiating CPU that I've grabbed the data and am about to
496 * execute the function
499 cpu_clear(smp_processor_id(), nmi_call_data->started);
504 cpu_clear(smp_processor_id(), nmi_call_data->finished);
509 * smp_ipi_timer_interrupt - Local timer IPI handler
510 * @irq: The interrupt number.
511 * @dev_id: The device ID.
513 * Returns IRQ_HANDLED to indicate we handled the interrupt successfully.
515 static irqreturn_t smp_ipi_timer_interrupt(int irq, void *dev_id)
517 return local_timer_interrupt();
520 void __init smp_init_cpus(void)
523 for (i = 0; i < NR_CPUS; i++) {
524 set_cpu_possible(i, true);
525 set_cpu_present(i, true);
530 * smp_cpu_init - Initialise AP in start_secondary.
532 * For this Application Processor, set up init_mm, initialise FPU and set
533 * interrupt level 0-6 setting.
535 static void __init smp_cpu_init(void)
538 int cpu_id = smp_processor_id();
541 if (test_and_set_bit(cpu_id, &cpu_initialized)) {
542 printk(KERN_WARNING "CPU#%d already initialized!\n", cpu_id);
546 printk(KERN_INFO "Initializing CPU#%d\n", cpu_id);
548 atomic_inc(&init_mm.mm_count);
549 current->active_mm = &init_mm;
552 enter_lazy_tlb(&init_mm, current);
554 /* Force FPU initialization */
555 clear_using_fpu(current);
557 GxICR(CALL_FUNC_SINGLE_IPI) = CALL_FUNCTION_GxICR_LV | GxICR_DETECT;
558 mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
560 GxICR(LOCAL_TIMER_IPI) = LOCAL_TIMER_GxICR_LV | GxICR_DETECT;
561 mn10300_ipi_enable(LOCAL_TIMER_IPI);
563 GxICR(RESCHEDULE_IPI) = RESCHEDULE_GxICR_LV | GxICR_DETECT;
564 mn10300_ipi_enable(RESCHEDULE_IPI);
566 #ifdef CONFIG_MN10300_CACHE_ENABLED
567 GxICR(FLUSH_CACHE_IPI) = FLUSH_CACHE_GxICR_LV | GxICR_DETECT;
568 mn10300_ipi_enable(FLUSH_CACHE_IPI);
571 mn10300_ipi_shutdown(SMP_BOOT_IRQ);
573 /* Set up the non-maskable call function IPI */
574 flags = arch_local_cli_save();
575 GxICR(CALL_FUNCTION_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
576 tmp16 = GxICR(CALL_FUNCTION_NMI_IPI);
577 arch_local_irq_restore(flags);
581 * smp_prepare_cpu_init - Initialise CPU in startup_secondary
583 * Set interrupt level 0-6 setting and init ICR of gdbstub.
585 void smp_prepare_cpu_init(void)
589 /* Set the interrupt vector registers */
590 IVAR0 = EXCEP_IRQ_LEVEL0;
591 IVAR1 = EXCEP_IRQ_LEVEL1;
592 IVAR2 = EXCEP_IRQ_LEVEL2;
593 IVAR3 = EXCEP_IRQ_LEVEL3;
594 IVAR4 = EXCEP_IRQ_LEVEL4;
595 IVAR5 = EXCEP_IRQ_LEVEL5;
596 IVAR6 = EXCEP_IRQ_LEVEL6;
598 /* Disable all interrupts and set to priority 6 (lowest) */
599 for (loop = 0; loop < GxICR_NUM_IRQS; loop++)
600 GxICR(loop) = GxICR_LEVEL_6 | GxICR_DETECT;
602 #ifdef CONFIG_GDBSTUB
603 /* initialise GDB-stub */
608 flags = arch_local_cli_save();
609 GxICR(GDB_NMI_IPI) = GxICR_NMI | GxICR_ENABLE | GxICR_DETECT;
610 tmp16 = GxICR(GDB_NMI_IPI);
611 arch_local_irq_restore(flags);
617 * start_secondary - Activate a secondary CPU (AP)
618 * @unused: Thread parameter (ignored).
620 int __init start_secondary(void *unused)
625 while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
637 * smp_prepare_cpus - Boot up secondary CPUs (APs)
638 * @max_cpus: Maximum number of CPUs to boot.
640 * Call do_boot_cpu, and boot up APs.
642 void __init smp_prepare_cpus(unsigned int max_cpus)
646 /* Setup boot CPU information */
647 smp_store_cpu_info(0);
648 smp_tune_scheduling();
652 /* If SMP should be disabled, then finish */
654 printk(KERN_INFO "SMP mode deactivated.\n");
658 /* Boot secondary CPUs (for which phy_id > 0) */
659 for (phy_id = 0; phy_id < NR_CPUS; phy_id++) {
660 /* Don't boot primary CPU */
661 if (max_cpus <= cpucount + 1)
665 set_cpu_possible(phy_id, true);
666 smp_show_cpu_info(phy_id);
670 Dprintk("Boot done.\n");
674 * smp_store_cpu_info - Save a CPU's information
675 * @cpu: The CPU to save for.
677 * Save boot_cpu_data and jiffy for the specified CPU.
679 static void __init smp_store_cpu_info(int cpu)
681 struct mn10300_cpuinfo *ci = &cpu_data[cpu];
684 ci->loops_per_jiffy = loops_per_jiffy;
689 * smp_tune_scheduling - Set time slice value
691 * Nothing to do here.
693 static void __init smp_tune_scheduling(void)
698 * do_boot_cpu: Boot up one CPU
699 * @phy_id: Physical ID of CPU to boot.
701 * Send an IPI to a secondary CPU to boot it. Returns 0 on success, 1
704 static int __init do_boot_cpu(int phy_id)
706 struct task_struct *idle;
707 unsigned long send_status, callin_status;
710 send_status = GxICR_REQUEST;
717 /* Create idle thread for this CPU */
718 idle = fork_idle(cpu_id);
720 panic("Failed fork for CPU#%d.", cpu_id);
722 idle->thread.pc = (unsigned long)start_secondary;
724 printk(KERN_NOTICE "Booting CPU#%d\n", cpu_id);
725 start_stack[cpu_id - 1] = idle->thread.sp;
727 task_thread_info(idle)->cpu = cpu_id;
729 /* Send boot IPI to AP */
730 send_IPI_mask(cpumask_of(phy_id), SMP_BOOT_IRQ);
732 Dprintk("Waiting for send to finish...\n");
734 /* Wait for AP's IPI receive in 100[ms] */
738 CROSS_GxICR(SMP_BOOT_IRQ, phy_id) & GxICR_REQUEST;
739 } while (send_status == GxICR_REQUEST && timeout++ < 100);
741 Dprintk("Waiting for cpu_callin_map.\n");
743 if (send_status == 0) {
744 /* Allow AP to start initializing */
745 cpu_set(cpu_id, cpu_callout_map);
747 /* Wait for setting cpu_callin_map */
751 callin_status = cpu_isset(cpu_id, cpu_callin_map);
752 } while (callin_status == 0 && timeout++ < 5000);
754 if (callin_status == 0)
755 Dprintk("Not responding.\n");
757 printk(KERN_WARNING "IPI not delivered.\n");
760 if (send_status == GxICR_REQUEST || callin_status == 0) {
761 cpu_clear(cpu_id, cpu_callout_map);
762 cpu_clear(cpu_id, cpu_callin_map);
763 cpu_clear(cpu_id, cpu_initialized);
771 * smp_show_cpu_info - Show SMP CPU information
772 * @cpu: The CPU of interest.
774 static void __init smp_show_cpu_info(int cpu)
776 struct mn10300_cpuinfo *ci = &cpu_data[cpu];
779 "CPU#%d : ioclk speed: %lu.%02luMHz : bogomips : %lu.%02lu\n",
781 MN10300_IOCLK / 1000000,
782 (MN10300_IOCLK / 10000) % 100,
783 ci->loops_per_jiffy / (500000 / HZ),
784 (ci->loops_per_jiffy / (5000 / HZ)) % 100);
788 * smp_callin - Set cpu_callin_map of the current CPU ID
790 static void __init smp_callin(void)
792 unsigned long timeout;
795 cpu = smp_processor_id();
796 timeout = jiffies + (2 * HZ);
798 if (cpu_isset(cpu, cpu_callin_map)) {
799 printk(KERN_ERR "CPU#%d already present.\n", cpu);
802 Dprintk("CPU#%d waiting for CALLOUT\n", cpu);
804 /* Wait for AP startup 2s total */
805 while (time_before(jiffies, timeout)) {
806 if (cpu_isset(cpu, cpu_callout_map))
811 if (!time_before(jiffies, timeout)) {
813 "BUG: CPU#%d started up but did not get a callout!\n",
818 #ifdef CONFIG_CALIBRATE_DELAY
819 calibrate_delay(); /* Get our bogomips */
822 /* Save our processor parameters */
823 smp_store_cpu_info(cpu);
825 /* Allow the boot processor to continue */
826 cpu_set(cpu, cpu_callin_map);
830 * smp_online - Set cpu_online_map
832 static void __init smp_online(void)
836 cpu = smp_processor_id();
840 cpu_set(cpu, cpu_online_map);
846 * @max_cpus: Maximum CPU count.
850 void __init smp_cpus_done(unsigned int max_cpus)
855 * smp_prepare_boot_cpu - Set up stuff for the boot processor.
857 * Set up the cpu_online_map, cpu_callout_map and cpu_callin_map of the boot
860 void __devinit smp_prepare_boot_cpu(void)
862 cpu_set(0, cpu_callout_map);
863 cpu_set(0, cpu_callin_map);
864 current_thread_info()->cpu = 0;
868 * initialize_secondary - Initialise a secondary CPU (Application Processor).
870 * Set SP register and jump to thread's PC address.
872 void initialize_secondary(void)
878 : "a"(current->thread.sp), "a"(current->thread.pc));
882 * __cpu_up - Set smp_commenced_mask for the nominated CPU
883 * @cpu: The target CPU.
885 int __devinit __cpu_up(unsigned int cpu)
889 #ifdef CONFIG_HOTPLUG_CPU
890 if (num_online_cpus() == 1)
894 #endif /* CONFIG_HOTPLUG_CPU */
896 cpu_set(cpu, smp_commenced_mask);
898 /* Wait 5s total for a response */
899 for (timeout = 0 ; timeout < 5000 ; timeout++) {
900 if (cpu_isset(cpu, cpu_online_map))
905 BUG_ON(!cpu_isset(cpu, cpu_online_map));
910 * setup_profiling_timer - Set up the profiling timer
911 * @multiplier - The frequency multiplier to use
913 * The frequency of the profiling timer can be changed by writing a multiplier
914 * value into /proc/profile.
916 int setup_profiling_timer(unsigned int multiplier)
922 * CPU hotplug routines
924 #ifdef CONFIG_HOTPLUG_CPU
926 static DEFINE_PER_CPU(struct cpu, cpu_devices);
928 static int __init topology_init(void)
933 ret = register_cpu(&per_cpu(cpu_devices, cpu), cpu, NULL);
936 "topology_init: register_cpu %d failed (%d)\n",
942 subsys_initcall(topology_init);
944 int __cpu_disable(void)
946 int cpu = smp_processor_id();
951 cpu_clear(cpu, current->active_mm->cpu_vm_mask);
955 void __cpu_die(unsigned int cpu)
959 if (num_online_cpus() == 1)
963 #ifdef CONFIG_MN10300_CACHE_ENABLED
964 static inline void hotplug_cpu_disable_cache(void)
971 "1: movhu (%1),%0 \n"
976 "i"(~(CHCTR_ICEN | CHCTR_DCEN)),
977 "i"(CHCTR_ICBUSY | CHCTR_DCBUSY)
981 static inline void hotplug_cpu_enable_cache(void)
990 "i"(CHCTR_ICEN | CHCTR_DCEN)
994 static inline void hotplug_cpu_invalidate_cache(void)
1003 "i"(CHCTR_ICINV | CHCTR_DCINV)
1007 #else /* CONFIG_MN10300_CACHE_ENABLED */
1008 #define hotplug_cpu_disable_cache() do {} while (0)
1009 #define hotplug_cpu_enable_cache() do {} while (0)
1010 #define hotplug_cpu_invalidate_cache() do {} while (0)
1011 #endif /* CONFIG_MN10300_CACHE_ENABLED */
1014 * hotplug_cpu_nmi_call_function - Call a function on other CPUs for hotplug
1015 * @cpumask: List of target CPUs.
1016 * @func: The function to call on those CPUs.
1017 * @info: The context data for the function to be called.
1018 * @wait: Whether to wait for the calls to complete.
1020 * Non-maskably call a function on another CPU for hotplug purposes.
1022 * This function must be called with maskable interrupts disabled.
1024 static int hotplug_cpu_nmi_call_function(cpumask_t cpumask,
1025 smp_call_func_t func, void *info,
1029 * The address and the size of nmi_call_func_mask_data
1030 * need to be aligned on L1_CACHE_BYTES.
1032 static struct nmi_call_data_struct nmi_call_func_mask_data
1033 __cacheline_aligned;
1034 unsigned long start, end;
1036 start = (unsigned long)&nmi_call_func_mask_data;
1037 end = start + sizeof(struct nmi_call_data_struct);
1039 nmi_call_func_mask_data.func = func;
1040 nmi_call_func_mask_data.info = info;
1041 nmi_call_func_mask_data.started = cpumask;
1042 nmi_call_func_mask_data.wait = wait;
1044 nmi_call_func_mask_data.finished = cpumask;
1046 spin_lock(&smp_nmi_call_lock);
1047 nmi_call_data = &nmi_call_func_mask_data;
1048 mn10300_local_dcache_flush_range(start, end);
1051 send_IPI_mask(cpumask, CALL_FUNCTION_NMI_IPI);
1054 mn10300_local_dcache_inv_range(start, end);
1056 } while (!cpus_empty(nmi_call_func_mask_data.started));
1060 mn10300_local_dcache_inv_range(start, end);
1062 } while (!cpus_empty(nmi_call_func_mask_data.finished));
1065 spin_unlock(&smp_nmi_call_lock);
1069 static void restart_wakeup_cpu(void)
1071 unsigned int cpu = smp_processor_id();
1073 cpu_set(cpu, cpu_callin_map);
1075 cpu_set(cpu, cpu_online_map);
1079 static void prepare_sleep_cpu(void *unused)
1081 sleep_mode[smp_processor_id()] = 1;
1083 mn10300_local_dcache_flush_inv();
1084 hotplug_cpu_disable_cache();
1085 hotplug_cpu_invalidate_cache();
1088 /* when this function called, IE=0, NMID=0. */
1089 static void sleep_cpu(void *unused)
1091 unsigned int cpu_id = smp_processor_id();
1093 * CALL_FUNCTION_NMI_IPI for wakeup_cpu() shall not be requested,
1094 * before this cpu goes in SLEEP mode.
1099 } while (sleep_mode[cpu_id]);
1100 restart_wakeup_cpu();
1103 static void run_sleep_cpu(unsigned int cpu)
1105 unsigned long flags;
1106 cpumask_t cpumask = cpumask_of(cpu);
1108 flags = arch_local_cli_save();
1109 hotplug_cpu_nmi_call_function(cpumask, prepare_sleep_cpu, NULL, 1);
1110 hotplug_cpu_nmi_call_function(cpumask, sleep_cpu, NULL, 0);
1111 udelay(1); /* delay for the cpu to sleep. */
1112 arch_local_irq_restore(flags);
1115 static void wakeup_cpu(void)
1117 hotplug_cpu_invalidate_cache();
1118 hotplug_cpu_enable_cache();
1120 sleep_mode[smp_processor_id()] = 0;
1123 static void run_wakeup_cpu(unsigned int cpu)
1125 unsigned long flags;
1127 flags = arch_local_cli_save();
1129 mn10300_local_dcache_flush_inv();
1132 * Before waking up the cpu,
1133 * all online cpus should stop and flush D-Cache for global data.
1135 #error not support NR_CPUS > 2, when CONFIG_HOTPLUG_CPU=y.
1137 hotplug_cpu_nmi_call_function(cpumask_of(cpu), wakeup_cpu, NULL, 1);
1138 arch_local_irq_restore(flags);
1141 #endif /* CONFIG_HOTPLUG_CPU */