arch/ppc/kernel/smp.c

   1 /*
   2  * Smp support for ppc.
   3  *
   4  * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
   5  * deal of code from the sparc and intel versions.
   6  *
   7  * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
   8  *
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/sched.h>
  14 #include <linux/smp.h>
  15 #include <linux/smp_lock.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/kernel_stat.h>
  18 #include <linux/delay.h>
  19 #include <linux/init.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/cache.h>
  22
  23 #include <asm/ptrace.h>
  24 #include <asm/atomic.h>
  25 #include <asm/irq.h>
  26 #include <asm/page.h>
  27 #include <asm/pgtable.h>
  28 #include <asm/io.h>
  29 #include <asm/prom.h>
  30 #include <asm/smp.h>
  31 #include <asm/residual.h>
  32 #include <asm/time.h>
  33 #include <asm/thread_info.h>
  34 #include <asm/tlbflush.h>
  35 #include <asm/xmon.h>
  36 #include <asm/machdep.h>
  37
  38 volatile int smp_commenced;
  39 int smp_tb_synchronized;
  40 struct cpuinfo_PPC cpu_data[NR_CPUS];
  41 atomic_t ipi_recv;
  42 atomic_t ipi_sent;
  43 cpumask_t cpu_online_map;
  44 cpumask_t cpu_possible_map;
  45 int smp_hw_index[NR_CPUS];
  46 struct thread_info *secondary_ti;
  47 static struct task_struct *idle_tasks[NR_CPUS];
  48
  49 EXPORT_SYMBOL(cpu_online_map);
  50 EXPORT_SYMBOL(cpu_possible_map);
  51
  52 /* SMP operations for this machine */
  53 struct smp_ops_t *smp_ops;
  54
  55 /* all cpu mappings are 1-1 -- Cort */
  56 volatile unsigned long cpu_callin_map[NR_CPUS];
  57
  58 int start_secondary(void *);
  59 void smp_call_function_interrupt(void);
  60 static int __smp_call_function(void (*func) (void *info), void *info,
  61                                int wait, int target);
  62
  63 /* Low level assembly function used to backup CPU 0 state */
  64 extern void __save_cpu_setup(void);
  65
  66 /* Since OpenPIC has only 4 IPIs, we use slightly different message numbers.
  67  *
  68  * Make sure this matches openpic_request_IPIs in open_pic.c, or what shows up
  69  * in /proc/interrupts will be wrong!!! --Troy */
  70 #define PPC_MSG_CALL_FUNCTION   0
  71 #define PPC_MSG_RESCHEDULE      1
  72 #define PPC_MSG_INVALIDATE_TLB  2
  73 #define PPC_MSG_XMON_BREAK      3
  74
  75 static inline void
  76 smp_message_pass(int target, int msg)
  77 {
  78         if (smp_ops) {
  79                 atomic_inc(&ipi_sent);
  80                 smp_ops->message_pass(target, msg);
  81         }
  82 }
  83
  84 /*
  85  * Common functions
  86  */
  87 void smp_message_recv(int msg)
  88 {
  89         atomic_inc(&ipi_recv);
  90
  91         switch( msg ) {
  92         case PPC_MSG_CALL_FUNCTION:
  93                 smp_call_function_interrupt();
  94                 break;
  95         case PPC_MSG_RESCHEDULE:
  96                 set_need_resched();
  97                 break;
  98         case PPC_MSG_INVALIDATE_TLB:
  99                 _tlbia();
 100                 break;
 101 #ifdef CONFIG_XMON
 102         case PPC_MSG_XMON_BREAK:
 103                 xmon(get_irq_regs());
 104                 break;
 105 #endif /* CONFIG_XMON */
 106         default:
 107                 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
 108                        smp_processor_id(), msg);
 109                 break;
 110         }
 111 }
 112
 113 /*
 114  * 750's don't broadcast tlb invalidates so
 115  * we have to emulate that behavior.
 116  *   -- Cort
 117  */
 118 void smp_send_tlb_invalidate(int cpu)
 119 {
 120         if ( PVR_VER(mfspr(SPRN_PVR)) == 8 )
 121                 smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_INVALIDATE_TLB);
 122 }
 123
 124 void smp_send_reschedule(int cpu)
 125 {
 126         /*
 127          * This is only used if `cpu' is running an idle task,
 128          * so it will reschedule itself anyway...
 129          *
 130          * This isn't the case anymore since the other CPU could be
 131          * sleeping and won't reschedule until the next interrupt (such
 132          * as the timer).
 133          *  -- Cort
 134          */
 135         /* This is only used if `cpu' is running an idle task,
 136            so it will reschedule itself anyway... */
 137         smp_message_pass(cpu, PPC_MSG_RESCHEDULE);
 138 }
 139
 140 #ifdef CONFIG_XMON
 141 void smp_send_xmon_break(int cpu)
 142 {
 143         smp_message_pass(cpu, PPC_MSG_XMON_BREAK);
 144 }
 145 #endif /* CONFIG_XMON */
 146
 147 static void stop_this_cpu(void *dummy)
 148 {
 149         local_irq_disable();
 150         while (1)
 151                 ;
 152 }
 153
 154 void smp_send_stop(void)
 155 {
 156         smp_call_function(stop_this_cpu, NULL, 1, 0);
 157 }
 158
 159 /*
 160  * Structure and data for smp_call_function(). This is designed to minimise
 161  * static memory requirements. It also looks cleaner.
 162  * Stolen from the i386 version.
 163  */
 164 static DEFINE_SPINLOCK(call_lock);
 165
 166 static struct call_data_struct {
 167         void (*func) (void *info);
 168         void *info;
 169         atomic_t started;
 170         atomic_t finished;
 171         int wait;
 172 } *call_data;
 173
 174 /*
 175  * this function sends a 'generic call function' IPI to all other CPUs
 176  * in the system.
 177  */
 178
 179 int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
 180                       int wait)
 181 /*
 182  * [SUMMARY] Run a function on all other CPUs.
 183  * <func> The function to run. This must be fast and non-blocking.
 184  * <info> An arbitrary pointer to pass to the function.
 185  * <nonatomic> currently unused.
 186  * <wait> If true, wait (atomically) until function has completed on other CPUs.
 187  * [RETURNS] 0 on success, else a negative status code. Does not return until
 188  * remote CPUs are nearly ready to execute <<func>> or are or have executed.
 189  *
 190  * You must not call this function with disabled interrupts or from a
 191  * hardware interrupt handler or from a bottom half handler.
 192  */
 193 {
 194         /* FIXME: get cpu lock with hotplug cpus, or change this to
 195            bitmask. --RR */
 196         if (num_online_cpus() <= 1)
 197                 return 0;
 198         /* Can deadlock when called with interrupts disabled */
 199         WARN_ON(irqs_disabled());
 200         return __smp_call_function(func, info, wait, MSG_ALL_BUT_SELF);
 201 }
 202
 203 static int __smp_call_function(void (*func) (void *info), void *info,
 204                                int wait, int target)
 205 {
 206         struct call_data_struct data;
 207         int ret = -1;
 208         int timeout;
 209         int ncpus = 1;
 210
 211         if (target == MSG_ALL_BUT_SELF)
 212                 ncpus = num_online_cpus() - 1;
 213         else if (target == MSG_ALL)
 214                 ncpus = num_online_cpus();
 215
 216         data.func = func;
 217         data.info = info;
 218         atomic_set(&data.started, 0);
 219         data.wait = wait;
 220         if (wait)
 221                 atomic_set(&data.finished, 0);
 222
 223         spin_lock(&call_lock);
 224         call_data = &data;
 225         /* Send a message to all other CPUs and wait for them to respond */
 226         smp_message_pass(target, PPC_MSG_CALL_FUNCTION);
 227
 228         /* Wait for response */
 229         timeout = 1000000;
 230         while (atomic_read(&data.started) != ncpus) {
 231                 if (--timeout == 0) {
 232                         printk("smp_call_function on cpu %d: other cpus not responding (%d)\n",
 233                                smp_processor_id(), atomic_read(&data.started));
 234                         goto out;
 235                 }
 236                 barrier();
 237                 udelay(1);
 238         }
 239
 240         if (wait) {
 241                 timeout = 1000000;
 242                 while (atomic_read(&data.finished) != ncpus) {
 243                         if (--timeout == 0) {
 244                                 printk("smp_call_function on cpu %d: other cpus not finishing (%d/%d)\n",
 245                                        smp_processor_id(), atomic_read(&data.finished), atomic_read(&data.started));
 246                                 goto out;
 247                         }
 248                         barrier();
 249                         udelay(1);
 250                 }
 251         }
 252         ret = 0;
 253
 254  out:
 255         spin_unlock(&call_lock);
 256         return ret;
 257 }
 258
 259 void smp_call_function_interrupt(void)
 260 {
 261         void (*func) (void *info) = call_data->func;
 262         void *info = call_data->info;
 263         int wait = call_data->wait;
 264
 265         /*
 266          * Notify initiating CPU that I've grabbed the data and am
 267          * about to execute the function
 268          */
 269         atomic_inc(&call_data->started);
 270         /*
 271          * At this point the info structure may be out of scope unless wait==1
 272          */
 273         (*func)(info);
 274         if (wait)
 275                 atomic_inc(&call_data->finished);
 276 }
 277
 278 static void __devinit smp_store_cpu_info(int id)
 279 {
 280         struct cpuinfo_PPC *c = &cpu_data[id];
 281
 282         /* assume bogomips are same for everything */
 283         c->loops_per_jiffy = loops_per_jiffy;
 284         c->pvr = mfspr(SPRN_PVR);
 285 }
 286
 287 void __init smp_prepare_cpus(unsigned int max_cpus)
 288 {
 289         int num_cpus, i, cpu;
 290         struct task_struct *p;
 291
 292         /* Fixup boot cpu */
 293         smp_store_cpu_info(smp_processor_id());
 294         cpu_callin_map[smp_processor_id()] = 1;
 295
 296         if (smp_ops == NULL) {
 297                 printk("SMP not supported on this machine.\n");
 298                 return;
 299         }
 300
 301         /* Probe platform for CPUs: always linear. */
 302         num_cpus = smp_ops->probe();
 303
 304         if (num_cpus < 2)
 305                 smp_tb_synchronized = 1;
 306
 307         for (i = 0; i < num_cpus; ++i)
 308                 cpu_set(i, cpu_possible_map);
 309
 310         /* Backup CPU 0 state */
 311         __save_cpu_setup();
 312
 313         for_each_possible_cpu(cpu) {
 314                 if (cpu == smp_processor_id())
 315                         continue;
 316                 /* create a process for the processor */
 317                 p = fork_idle(cpu);
 318                 if (IS_ERR(p))
 319                         panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
 320                 task_thread_info(p)->cpu = cpu;
 321                 idle_tasks[cpu] = p;
 322         }
 323 }
 324
 325 void __devinit smp_prepare_boot_cpu(void)
 326 {
 327         cpu_set(smp_processor_id(), cpu_online_map);
 328         cpu_set(smp_processor_id(), cpu_possible_map);
 329 }
 330
 331 int __init setup_profiling_timer(unsigned int multiplier)
 332 {
 333         return 0;
 334 }
 335
 336 /* Processor coming up starts here */
 337 int __devinit start_secondary(void *unused)
 338 {
 339         int cpu;
 340
 341         atomic_inc(&init_mm.mm_count);
 342         current->active_mm = &init_mm;
 343
 344         cpu = smp_processor_id();
 345         smp_store_cpu_info(cpu);
 346         set_dec(tb_ticks_per_jiffy);
 347         preempt_disable();
 348         cpu_callin_map[cpu] = 1;
 349
 350         printk("CPU %d done callin...\n", cpu);
 351         smp_ops->setup_cpu(cpu);
 352         printk("CPU %d done setup...\n", cpu);
 353         smp_ops->take_timebase();
 354         printk("CPU %d done timebase take...\n", cpu);
 355
 356         spin_lock(&call_lock);
 357         cpu_set(cpu, cpu_online_map);
 358         spin_unlock(&call_lock);
 359
 360         local_irq_enable();
 361
 362         cpu_idle();
 363         return 0;
 364 }
 365
 366 int __cpu_up(unsigned int cpu)
 367 {
 368         char buf[32];
 369         int c;
 370
 371         secondary_ti = task_thread_info(idle_tasks[cpu]);
 372         mb();
 373
 374         /*
 375          * There was a cache flush loop here to flush the cache
 376          * to memory for the first 8MB of RAM.  The cache flush
 377          * has been pushed into the kick_cpu function for those
 378          * platforms that need it.
 379          */
 380
 381         /* wake up cpu */
 382         smp_ops->kick_cpu(cpu);
 383
 384         /*
 385          * wait to see if the cpu made a callin (is actually up).
 386          * use this value that I found through experimentation.
 387          * -- Cort
 388          */
 389         for (c = 1000; c && !cpu_callin_map[cpu]; c--)
 390                 udelay(100);
 391
 392         if (!cpu_callin_map[cpu]) {
 393                 sprintf(buf, "didn't find cpu %u", cpu);
 394                 if (ppc_md.progress) ppc_md.progress(buf, 0x360+cpu);
 395                 printk("Processor %u is stuck.\n", cpu);
 396                 return -ENOENT;
 397         }
 398
 399         sprintf(buf, "found cpu %u", cpu);
 400         if (ppc_md.progress) ppc_md.progress(buf, 0x350+cpu);
 401         printk("Processor %d found.\n", cpu);
 402
 403         smp_ops->give_timebase();
 404
 405         /* Wait until cpu puts itself in the online map */
 406         while (!cpu_online(cpu))
 407                 cpu_relax();
 408
 409         return 0;
 410 }
 411
 412 void smp_cpus_done(unsigned int max_cpus)
 413 {
 414         smp_ops->setup_cpu(0);
 415 }