smp.c revision 10b1271875abb9d590c14fa6c8b24b0d6f768ca2
1/* 2 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 * 8 * RajeshwarR: Dec 11, 2007 9 * -- Added support for Inter Processor Interrupts 10 * 11 * Vineetg: Nov 1st, 2007 12 * -- Initial Write (Borrowed heavily from ARM) 13 */ 14 15#include <linux/module.h> 16#include <linux/init.h> 17#include <linux/spinlock.h> 18#include <linux/sched.h> 19#include <linux/interrupt.h> 20#include <linux/profile.h> 21#include <linux/errno.h> 22#include <linux/err.h> 23#include <linux/mm.h> 24#include <linux/cpu.h> 25#include <linux/smp.h> 26#include <linux/irq.h> 27#include <linux/delay.h> 28#include <linux/atomic.h> 29#include <linux/percpu.h> 30#include <linux/cpumask.h> 31#include <linux/spinlock_types.h> 32#include <linux/reboot.h> 33#include <asm/processor.h> 34#include <asm/setup.h> 35#include <asm/mach_desc.h> 36 37arch_spinlock_t smp_atomic_ops_lock = __ARCH_SPIN_LOCK_UNLOCKED; 38arch_spinlock_t smp_bitops_lock = __ARCH_SPIN_LOCK_UNLOCKED; 39 40struct plat_smp_ops plat_smp_ops; 41 42/* XXX: per cpu ? Only needed once in early seconday boot */ 43struct task_struct *secondary_idle_tsk; 44 45/* Called from start_kernel */ 46void __init smp_prepare_boot_cpu(void) 47{ 48} 49 50/* 51 * Initialise the CPU possible map early - this describes the CPUs 52 * which may be present or become present in the system. 53 */ 54void __init smp_init_cpus(void) 55{ 56 unsigned int i; 57 58 for (i = 0; i < NR_CPUS; i++) 59 set_cpu_possible(i, true); 60} 61 62/* called from init ( ) => process 1 */ 63void __init smp_prepare_cpus(unsigned int max_cpus) 64{ 65 int i; 66 67 /* 68 * Initialise the present map, which describes the set of CPUs 69 * actually populated at the present time. 70 */ 71 for (i = 0; i < max_cpus; i++) 72 set_cpu_present(i, true); 73} 74 75void __init smp_cpus_done(unsigned int max_cpus) 76{ 77 78} 79 80/* 81 * After power-up, a non Master CPU needs to wait for Master to kick start it 82 * 83 * The default implementation halts 84 * 85 * This relies on platform specific support allowing Master to directly set 86 * this CPU's PC (to be @first_lines_of_secondary() and kick start it. 87 * 88 * In lack of such h/w assist, platforms can override this function 89 * - make this function busy-spin on a token, eventually set by Master 90 * (from arc_platform_smp_wakeup_cpu()) 91 * - Once token is available, jump to @first_lines_of_secondary 92 * (using inline asm). 93 * 94 * Alert: can NOT use stack here as it has not been determined/setup for CPU. 95 * If it turns out to be elaborate, it's better to code it in assembly 96 * 97 */ 98void __attribute__((weak)) arc_platform_smp_wait_to_boot(int cpu) 99{ 100 /* 101 * As a hack for debugging - since debugger will single-step over the 102 * FLAG insn - wrap the halt itself it in a self loop 103 */ 104 __asm__ __volatile__( 105 "1: \n" 106 " flag 1 \n" 107 " b 1b \n"); 108} 109 110const char *arc_platform_smp_cpuinfo(void) 111{ 112 return plat_smp_ops.info; 113} 114 115/* 116 * The very first "C" code executed by secondary 117 * Called from asm stub in head.S 118 * "current"/R25 already setup by low level boot code 119 */ 120void __cpuinit start_kernel_secondary(void) 121{ 122 struct mm_struct *mm = &init_mm; 123 unsigned int cpu = smp_processor_id(); 124 125 /* MMU, Caches, Vector Table, Interrupts etc */ 126 setup_processor(); 127 128 atomic_inc(&mm->mm_users); 129 atomic_inc(&mm->mm_count); 130 current->active_mm = mm; 131 132 notify_cpu_starting(cpu); 133 set_cpu_online(cpu, true); 134 135 pr_info("## CPU%u LIVE ##: Executing Code...\n", cpu); 136 137 if (machine_desc->init_smp) 138 machine_desc->init_smp(smp_processor_id()); 139 140 arc_local_timer_setup(cpu); 141 142 local_irq_enable(); 143 preempt_disable(); 144 cpu_idle(); 145} 146 147/* 148 * Called from kernel_init( ) -> smp_init( ) - for each CPU 149 * 150 * At this point, Secondary Processor is "HALT"ed: 151 * -It booted, but was halted in head.S 152 * -It was configured to halt-on-reset 153 * So need to wake it up. 154 * 155 * Essential requirements being where to run from (PC) and stack (SP) 156*/ 157int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *idle) 158{ 159 unsigned long wait_till; 160 161 secondary_idle_tsk = idle; 162 163 pr_info("Idle Task [%d] %p", cpu, idle); 164 pr_info("Trying to bring up CPU%u ...\n", cpu); 165 166 if (plat_smp_ops.cpu_kick) 167 plat_smp_ops.cpu_kick(cpu, 168 (unsigned long)first_lines_of_secondary); 169 170 /* wait for 1 sec after kicking the secondary */ 171 wait_till = jiffies + HZ; 172 while (time_before(jiffies, wait_till)) { 173 if (cpu_online(cpu)) 174 break; 175 } 176 177 if (!cpu_online(cpu)) { 178 pr_info("Timeout: CPU%u FAILED to comeup !!!\n", cpu); 179 return -1; 180 } 181 182 secondary_idle_tsk = NULL; 183 184 return 0; 185} 186 187/* 188 * not supported here 189 */ 190int __init setup_profiling_timer(unsigned int multiplier) 191{ 192 return -EINVAL; 193} 194 195/*****************************************************************************/ 196/* Inter Processor Interrupt Handling */ 197/*****************************************************************************/ 198 199/* 200 * structures for inter-processor calls 201 * A Collection of single bit ipi messages 202 * 203 */ 204 205/* 206 * TODO_rajesh investigate tlb message types. 207 * IPI Timer not needed because each ARC has an individual Interrupting Timer 208 */ 209enum ipi_msg_type { 210 IPI_NOP = 0, 211 IPI_RESCHEDULE = 1, 212 IPI_CALL_FUNC, 213 IPI_CALL_FUNC_SINGLE, 214 IPI_CPU_STOP 215}; 216 217struct ipi_data { 218 unsigned long bits; 219}; 220 221static DEFINE_PER_CPU(struct ipi_data, ipi_data); 222 223static void ipi_send_msg(const struct cpumask *callmap, enum ipi_msg_type msg) 224{ 225 unsigned long flags; 226 unsigned int cpu; 227 228 local_irq_save(flags); 229 230 for_each_cpu(cpu, callmap) { 231 struct ipi_data *ipi = &per_cpu(ipi_data, cpu); 232 set_bit(msg, &ipi->bits); 233 } 234 235 /* Call the platform specific cross-CPU call function */ 236 if (plat_smp_ops.ipi_send) 237 plat_smp_ops.ipi_send((void *)callmap); 238 239 local_irq_restore(flags); 240} 241 242void smp_send_reschedule(int cpu) 243{ 244 ipi_send_msg(cpumask_of(cpu), IPI_RESCHEDULE); 245} 246 247void smp_send_stop(void) 248{ 249 struct cpumask targets; 250 cpumask_copy(&targets, cpu_online_mask); 251 cpumask_clear_cpu(smp_processor_id(), &targets); 252 ipi_send_msg(&targets, IPI_CPU_STOP); 253} 254 255void arch_send_call_function_single_ipi(int cpu) 256{ 257 ipi_send_msg(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE); 258} 259 260void arch_send_call_function_ipi_mask(const struct cpumask *mask) 261{ 262 ipi_send_msg(mask, IPI_CALL_FUNC); 263} 264 265/* 266 * ipi_cpu_stop - handle IPI from smp_send_stop() 267 */ 268static void ipi_cpu_stop(unsigned int cpu) 269{ 270 machine_halt(); 271} 272 273static inline void __do_IPI(unsigned long *ops, struct ipi_data *ipi, int cpu) 274{ 275 unsigned long msg = 0; 276 277 do { 278 msg = find_next_bit(ops, BITS_PER_LONG, msg+1); 279 280 switch (msg) { 281 case IPI_RESCHEDULE: 282 scheduler_ipi(); 283 break; 284 285 case IPI_CALL_FUNC: 286 generic_smp_call_function_interrupt(); 287 break; 288 289 case IPI_CALL_FUNC_SINGLE: 290 generic_smp_call_function_single_interrupt(); 291 break; 292 293 case IPI_CPU_STOP: 294 ipi_cpu_stop(cpu); 295 break; 296 } 297 } while (msg < BITS_PER_LONG); 298 299} 300 301/* 302 * arch-common ISR to handle for inter-processor interrupts 303 * Has hooks for platform specific IPI 304 */ 305irqreturn_t do_IPI(int irq, void *dev_id) 306{ 307 int cpu = smp_processor_id(); 308 struct ipi_data *ipi = &per_cpu(ipi_data, cpu); 309 unsigned long ops; 310 311 if (plat_smp_ops.ipi_clear) 312 plat_smp_ops.ipi_clear(cpu, irq); 313 314 /* 315 * XXX: is this loop really needed 316 * And do we need to move ipi_clean inside 317 */ 318 while ((ops = xchg(&ipi->bits, 0)) != 0) 319 __do_IPI(&ops, ipi, cpu); 320 321 return IRQ_HANDLED; 322} 323 324/* 325 * API called by platform code to hookup arch-common ISR to their IPI IRQ 326 */ 327static DEFINE_PER_CPU(int, ipi_dev); 328int smp_ipi_irq_setup(int cpu, int irq) 329{ 330 int *dev_id = &per_cpu(ipi_dev, smp_processor_id()); 331 return request_percpu_irq(irq, do_IPI, "IPI Interrupt", dev_id); 332} 333