1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * SMP support for Hexagon 4 * 5 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved. 6 */ 7 8 #include <linux/err.h> 9 #include <linux/errno.h> 10 #include <linux/kernel.h> 11 #include <linux/init.h> 12 #include <linux/interrupt.h> 13 #include <linux/module.h> 14 #include <linux/percpu.h> 15 #include <linux/sched/mm.h> 16 #include <linux/smp.h> 17 #include <linux/spinlock.h> 18 #include <linux/cpu.h> 19 #include <linux/mm_types.h> 20 21 #include <asm/time.h> /* timer_interrupt */ 22 #include <asm/hexagon_vm.h> 23 24 #define BASE_IPI_IRQ 26 25 26 /* 27 * cpu_possible_mask needs to be filled out prior to setup_per_cpu_areas 28 * (which is prior to any of our smp_prepare_cpu crap), in order to set 29 * up the... per_cpu areas. 30 */ 31 32 struct ipi_data { 33 unsigned long bits; 34 }; 35 36 static DEFINE_PER_CPU(struct ipi_data, ipi_data); 37 38 static inline void __handle_ipi(unsigned long *ops, struct ipi_data *ipi, 39 int cpu) 40 { 41 unsigned long msg = 0; 42 do { 43 msg = find_next_bit(ops, BITS_PER_LONG, msg+1); 44 45 switch (msg) { 46 47 case IPI_TIMER: 48 ipi_timer(); 49 break; 50 51 case IPI_CALL_FUNC: 52 generic_smp_call_function_interrupt(); 53 break; 54 55 case IPI_CPU_STOP: 56 /* 57 * call vmstop() 58 */ 59 __vmstop(); 60 break; 61 62 case IPI_RESCHEDULE: 63 scheduler_ipi(); 64 break; 65 } 66 } while (msg < BITS_PER_LONG); 67 } 68 69 /* Used for IPI call from other CPU's to unmask int */ 70 void smp_vm_unmask_irq(void *info) 71 { 72 __vmintop_locen((long) info); 73 } 74 75 76 /* 77 * This is based on Alpha's IPI stuff. 78 * Supposed to take (int, void*) as args now. 79 * Specifically, first arg is irq, second is the irq_desc. 80 */ 81 82 irqreturn_t handle_ipi(int irq, void *desc) 83 { 84 int cpu = smp_processor_id(); 85 struct ipi_data *ipi = &per_cpu(ipi_data, cpu); 86 unsigned long ops; 87 88 while ((ops = xchg(&ipi->bits, 0)) != 0) 89 __handle_ipi(&ops, ipi, cpu); 90 return IRQ_HANDLED; 91 } 92 93 void send_ipi(const struct cpumask *cpumask, enum ipi_message_type msg) 94 { 95 unsigned long flags; 96 unsigned long cpu; 97 unsigned long retval; 98 99 local_irq_save(flags); 100 101 for_each_cpu(cpu, cpumask) { 102 struct ipi_data *ipi = &per_cpu(ipi_data, cpu); 103 104 set_bit(msg, &ipi->bits); 105 /* Possible barrier here */ 106 retval = __vmintop_post(BASE_IPI_IRQ+cpu); 107 108 if (retval != 0) { 109 printk(KERN_ERR "interrupt %ld not configured?\n", 110 BASE_IPI_IRQ+cpu); 111 } 112 } 113 114 local_irq_restore(flags); 115 } 116 117 void __init smp_prepare_boot_cpu(void) 118 { 119 } 120 121 /* 122 * interrupts should already be disabled from the VM 123 * SP should already be correct; need to set THREADINFO_REG 124 * to point to current thread info 125 */ 126 127 void start_secondary(void) 128 { 129 unsigned long thread_ptr; 130 unsigned int cpu, irq; 131 132 /* Calculate thread_info pointer from stack pointer */ 133 __asm__ __volatile__( 134 "%0 = SP;\n" 135 : "=r" (thread_ptr) 136 ); 137 138 thread_ptr = thread_ptr & ~(THREAD_SIZE-1); 139 140 __asm__ __volatile__( 141 QUOTED_THREADINFO_REG " = %0;\n" 142 : 143 : "r" (thread_ptr) 144 ); 145 146 /* Set the memory struct */ 147 mmgrab(&init_mm); 148 current->active_mm = &init_mm; 149 150 cpu = smp_processor_id(); 151 152 irq = BASE_IPI_IRQ + cpu; 153 if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, "ipi_handler", 154 NULL)) 155 pr_err("Failed to request irq %u (ipi_handler)\n", irq); 156 157 /* Register the clock_event dummy */ 158 setup_percpu_clockdev(); 159 160 printk(KERN_INFO "%s cpu %d\n", __func__, current_thread_info()->cpu); 161 162 notify_cpu_starting(cpu); 163 164 set_cpu_online(cpu, true); 165 166 local_irq_enable(); 167 168 cpu_startup_entry(CPUHP_AP_ONLINE_IDLE); 169 } 170 171 172 /* 173 * called once for each present cpu 174 * apparently starts up the CPU and then 175 * maintains control until "cpu_online(cpu)" is set. 176 */ 177 178 int __cpu_up(unsigned int cpu, struct task_struct *idle) 179 { 180 struct thread_info *thread = (struct thread_info *)idle->stack; 181 void *stack_start; 182 183 thread->cpu = cpu; 184 185 /* Boot to the head. */ 186 stack_start = ((void *) thread) + THREAD_SIZE; 187 __vmstart(start_secondary, stack_start); 188 189 while (!cpu_online(cpu)) 190 barrier(); 191 192 return 0; 193 } 194 195 void __init smp_cpus_done(unsigned int max_cpus) 196 { 197 } 198 199 void __init smp_prepare_cpus(unsigned int max_cpus) 200 { 201 int i, irq = BASE_IPI_IRQ; 202 203 /* 204 * should eventually have some sort of machine 205 * descriptor that has this stuff 206 */ 207 208 /* Right now, let's just fake it. */ 209 for (i = 0; i < max_cpus; i++) 210 set_cpu_present(i, true); 211 212 /* Also need to register the interrupts for IPI */ 213 if (max_cpus > 1) { 214 if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, 215 "ipi_handler", NULL)) 216 pr_err("Failed to request irq %d (ipi_handler)\n", irq); 217 } 218 } 219 220 void smp_send_reschedule(int cpu) 221 { 222 send_ipi(cpumask_of(cpu), IPI_RESCHEDULE); 223 } 224 225 void smp_send_stop(void) 226 { 227 struct cpumask targets; 228 cpumask_copy(&targets, cpu_online_mask); 229 cpumask_clear_cpu(smp_processor_id(), &targets); 230 send_ipi(&targets, IPI_CPU_STOP); 231 } 232 233 void arch_send_call_function_single_ipi(int cpu) 234 { 235 send_ipi(cpumask_of(cpu), IPI_CALL_FUNC); 236 } 237 238 void arch_send_call_function_ipi_mask(const struct cpumask *mask) 239 { 240 send_ipi(mask, IPI_CALL_FUNC); 241 } 242 243 void smp_start_cpus(void) 244 { 245 int i; 246 247 for (i = 0; i < NR_CPUS; i++) 248 set_cpu_possible(i, true); 249 } 250