Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 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> |
Vineet Gupta | 03a6d28 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 35 | #include <asm/mach_desc.h> |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 36 | |
| 37 | arch_spinlock_t smp_atomic_ops_lock = __ARCH_SPIN_LOCK_UNLOCKED; |
| 38 | arch_spinlock_t smp_bitops_lock = __ARCH_SPIN_LOCK_UNLOCKED; |
| 39 | |
Vineet Gupta | 10b1271 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 40 | struct plat_smp_ops plat_smp_ops; |
| 41 | |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 42 | /* XXX: per cpu ? Only needed once in early seconday boot */ |
| 43 | struct task_struct *secondary_idle_tsk; |
| 44 | |
| 45 | /* Called from start_kernel */ |
| 46 | void __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 | */ |
| 54 | void __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 */ |
| 63 | void __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 | |
| 75 | void __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 | */ |
| 98 | void __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 | |
Vineet Gupta | 10b1271 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 110 | const char *arc_platform_smp_cpuinfo(void) |
| 111 | { |
| 112 | return plat_smp_ops.info; |
| 113 | } |
| 114 | |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 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 | */ |
| 120 | void __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 | |
Vineet Gupta | 03a6d28 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 137 | if (machine_desc->init_smp) |
| 138 | machine_desc->init_smp(smp_processor_id()); |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 139 | |
| 140 | arc_local_timer_setup(cpu); |
| 141 | |
| 142 | local_irq_enable(); |
| 143 | preempt_disable(); |
Thomas Gleixner | fa35e42 | 2013-03-21 22:49:36 +0100 | [diff] [blame] | 144 | cpu_startup_entry(CPUHP_ONLINE); |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 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 | */ |
| 157 | int __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 | |
Vineet Gupta | 10b1271 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 166 | if (plat_smp_ops.cpu_kick) |
| 167 | plat_smp_ops.cpu_kick(cpu, |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 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 | */ |
| 190 | int __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 | */ |
| 209 | enum 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 | |
| 217 | struct ipi_data { |
| 218 | unsigned long bits; |
| 219 | }; |
| 220 | |
| 221 | static DEFINE_PER_CPU(struct ipi_data, ipi_data); |
| 222 | |
| 223 | static 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 */ |
Vineet Gupta | 10b1271 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 236 | if (plat_smp_ops.ipi_send) |
| 237 | plat_smp_ops.ipi_send((void *)callmap); |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 238 | |
| 239 | local_irq_restore(flags); |
| 240 | } |
| 241 | |
| 242 | void smp_send_reschedule(int cpu) |
| 243 | { |
| 244 | ipi_send_msg(cpumask_of(cpu), IPI_RESCHEDULE); |
| 245 | } |
| 246 | |
| 247 | void 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 | |
| 255 | void arch_send_call_function_single_ipi(int cpu) |
| 256 | { |
| 257 | ipi_send_msg(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE); |
| 258 | } |
| 259 | |
| 260 | void 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 | */ |
| 268 | static void ipi_cpu_stop(unsigned int cpu) |
| 269 | { |
| 270 | machine_halt(); |
| 271 | } |
| 272 | |
| 273 | static 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 | */ |
| 305 | irqreturn_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 | |
Vineet Gupta | 10b1271 | 2013-01-18 15:12:26 +0530 | [diff] [blame] | 311 | if (plat_smp_ops.ipi_clear) |
| 312 | plat_smp_ops.ipi_clear(cpu, irq); |
Vineet Gupta | 41195d2 | 2013-01-18 15:12:23 +0530 | [diff] [blame] | 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 | */ |
| 327 | static DEFINE_PER_CPU(int, ipi_dev); |
| 328 | int 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 | } |