git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/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  * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
  10  * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
  11  *
  12  *      This program is free software; you can redistribute it and/or
  13  *      modify it under the terms of the GNU General Public License
  14  *      as published by the Free Software Foundation; either version
  15  *      2 of the License, or (at your option) any later version.
  16  */
  17
  18 #undef DEBUG
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/sched.h>
  23 #include <linux/smp.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/delay.h>
  26 #include <linux/init.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/cache.h>
  29 #include <linux/err.h>
  30 #include <linux/sysdev.h>
  31 #include <linux/cpu.h>
  32 #include <linux/notifier.h>
  33 #include <linux/topology.h>
  34
  35 #include <asm/ptrace.h>
  36 #include <asm/atomic.h>
  37 #include <asm/irq.h>
  38 #include <asm/page.h>
  39 #include <asm/pgtable.h>
  40 #include <asm/prom.h>
  41 #include <asm/smp.h>
  42 #include <asm/time.h>
  43 #include <asm/machdep.h>
  44 #include <asm/cputable.h>
  45 #include <asm/system.h>
  46 #include <asm/mpic.h>
  47 #include <asm/vdso_datapage.h>
  48 #ifdef CONFIG_PPC64
  49 #include <asm/paca.h>
  50 #endif
  51
  52 #ifdef DEBUG
  53 #include <asm/udbg.h>
  54 #define DBG(fmt...) udbg_printf(fmt)
  55 #else
  56 #define DBG(fmt...)
  57 #endif
  58
  59 int smp_hw_index[NR_CPUS];
  60 struct thread_info *secondary_ti;
  61
  62 cpumask_t cpu_possible_map = CPU_MASK_NONE;
  63 cpumask_t cpu_online_map = CPU_MASK_NONE;
  64 cpumask_t cpu_sibling_map[NR_CPUS] = { [0 ... NR_CPUS-1] = CPU_MASK_NONE };
  65
  66 EXPORT_SYMBOL(cpu_online_map);
  67 EXPORT_SYMBOL(cpu_possible_map);
  68 EXPORT_SYMBOL(cpu_sibling_map);
  69
  70 /* SMP operations for this machine */
  71 struct smp_ops_t *smp_ops;
  72
  73 static volatile unsigned int cpu_callin_map[NR_CPUS];
  74
  75 void smp_call_function_interrupt(void);
  76
  77 int smt_enabled_at_boot = 1;
  78
  79 static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;
  80
  81 #ifdef CONFIG_MPIC
  82 int __init smp_mpic_probe(void)
  83 {
  84         int nr_cpus;
  85
  86         DBG("smp_mpic_probe()...\n");
  87
  88         nr_cpus = cpus_weight(cpu_possible_map);
  89
  90         DBG("nr_cpus: %d\n", nr_cpus);
  91
  92         if (nr_cpus > 1)
  93                 mpic_request_ipis();
  94
  95         return nr_cpus;
  96 }
  97
  98 void __devinit smp_mpic_setup_cpu(int cpu)
  99 {
 100         mpic_setup_this_cpu();
 101 }
 102 #endif /* CONFIG_MPIC */
 103
 104 #ifdef CONFIG_PPC64
 105 void __devinit smp_generic_kick_cpu(int nr)
 106 {
 107         BUG_ON(nr < 0 || nr >= NR_CPUS);
 108
 109         /*
 110          * The processor is currently spinning, waiting for the
 111          * cpu_start field to become non-zero After we set cpu_start,
 112          * the processor will continue on to secondary_start
 113          */
 114         paca[nr].cpu_start = 1;
 115         smp_mb();
 116 }
 117 #endif
 118
 119 void smp_message_recv(int msg)
 120 {
 121         switch(msg) {
 122         case PPC_MSG_CALL_FUNCTION:
 123                 smp_call_function_interrupt();
 124                 break;
 125         case PPC_MSG_RESCHEDULE:
 126                 /* XXX Do we have to do this? */
 127                 set_need_resched();
 128                 break;
 129         case PPC_MSG_DEBUGGER_BREAK:
 130                 if (crash_ipi_function_ptr) {
 131                         crash_ipi_function_ptr(get_irq_regs());
 132                         break;
 133                 }
 134 #ifdef CONFIG_DEBUGGER
 135                 debugger_ipi(get_irq_regs());
 136                 break;
 137 #endif /* CONFIG_DEBUGGER */
 138                 /* FALLTHROUGH */
 139         default:
 140                 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
 141                        smp_processor_id(), msg);
 142                 break;
 143         }
 144 }
 145
 146 void smp_send_reschedule(int cpu)
 147 {
 148         if (likely(smp_ops))
 149                 smp_ops->message_pass(cpu, PPC_MSG_RESCHEDULE);
 150 }
 151
 152 #ifdef CONFIG_DEBUGGER
 153 void smp_send_debugger_break(int cpu)
 154 {
 155         if (likely(smp_ops))
 156                 smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
 157 }
 158 #endif
 159
 160 #ifdef CONFIG_KEXEC
 161 void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
 162 {
 163         crash_ipi_function_ptr = crash_ipi_callback;
 164         if (crash_ipi_callback && smp_ops) {
 165                 mb();
 166                 smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_DEBUGGER_BREAK);
 167         }
 168 }
 169 #endif
 170
 171 static void stop_this_cpu(void *dummy)
 172 {
 173         local_irq_disable();
 174         while (1)
 175                 ;
 176 }
 177
 178 void smp_send_stop(void)
 179 {
 180         smp_call_function(stop_this_cpu, NULL, 1, 0);
 181 }
 182
 183 /*
 184  * Structure and data for smp_call_function(). This is designed to minimise
 185  * static memory requirements. It also looks cleaner.
 186  * Stolen from the i386 version.
 187  */
 188 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_lock);
 189
 190 static struct call_data_struct {
 191         void (*func) (void *info);
 192         void *info;
 193         atomic_t started;
 194         atomic_t finished;
 195         int wait;
 196 } *call_data;
 197
 198 /* delay of at least 8 seconds */
 199 #define SMP_CALL_TIMEOUT        8
 200
 201 /*
 202  * This function sends a 'generic call function' IPI to all other CPUs
 203  * in the system.
 204  *
 205  * [SUMMARY] Run a function on all other CPUs.
 206  * <func> The function to run. This must be fast and non-blocking.
 207  * <info> An arbitrary pointer to pass to the function.
 208  * <nonatomic> currently unused.
 209  * <wait> If true, wait (atomically) until function has completed on other CPUs.
 210  * [RETURNS] 0 on success, else a negative status code. Does not return until
 211  * remote CPUs are nearly ready to execute <<func>> or are or have executed.
 212  *
 213  * You must not call this function with disabled interrupts or from a
 214  * hardware interrupt handler or from a bottom half handler.
 215  */
 216 int smp_call_function (void (*func) (void *info), void *info, int nonatomic,
 217                        int wait)
 218 {
 219         struct call_data_struct data;
 220         int ret = -1, cpus;
 221         u64 timeout;
 222
 223         /* Can deadlock when called with interrupts disabled */
 224         WARN_ON(irqs_disabled());
 225
 226         if (unlikely(smp_ops == NULL))
 227                 return -1;
 228
 229         data.func = func;
 230         data.info = info;
 231         atomic_set(&data.started, 0);
 232         data.wait = wait;
 233         if (wait)
 234                 atomic_set(&data.finished, 0);
 235
 236         spin_lock(&call_lock);
 237         /* Must grab online cpu count with preempt disabled, otherwise
 238          * it can change. */
 239         cpus = num_online_cpus() - 1;
 240         if (!cpus) {
 241                 ret = 0;
 242                 goto out;
 243         }
 244
 245         call_data = &data;
 246         smp_wmb();
 247         /* Send a message to all other CPUs and wait for them to respond */
 248         smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_CALL_FUNCTION);
 249
 250         timeout = get_tb() + (u64) SMP_CALL_TIMEOUT * tb_ticks_per_sec;
 251
 252         /* Wait for response */
 253         while (atomic_read(&data.started) != cpus) {
 254                 HMT_low();
 255                 if (get_tb() >= timeout) {
 256                         printk("smp_call_function on cpu %d: other cpus not "
 257                                "responding (%d)\n", smp_processor_id(),
 258                                atomic_read(&data.started));
 259                         debugger(NULL);
 260                         goto out;
 261                 }
 262         }
 263
 264         if (wait) {
 265                 while (atomic_read(&data.finished) != cpus) {
 266                         HMT_low();
 267                         if (get_tb() >= timeout) {
 268                                 printk("smp_call_function on cpu %d: other "
 269                                        "cpus not finishing (%d/%d)\n",
 270                                        smp_processor_id(),
 271                                        atomic_read(&data.finished),
 272                                        atomic_read(&data.started));
 273                                 debugger(NULL);
 274                                 goto out;
 275                         }
 276                 }
 277         }
 278
 279         ret = 0;
 280
 281  out:
 282         call_data = NULL;
 283         HMT_medium();
 284         spin_unlock(&call_lock);
 285         return ret;
 286 }
 287
 288 EXPORT_SYMBOL(smp_call_function);
 289
 290 void smp_call_function_interrupt(void)
 291 {
 292         void (*func) (void *info);
 293         void *info;
 294         int wait;
 295
 296         /* call_data will be NULL if the sender timed out while
 297          * waiting on us to receive the call.
 298          */
 299         if (!call_data)
 300                 return;
 301
 302         func = call_data->func;
 303         info = call_data->info;
 304         wait = call_data->wait;
 305
 306         if (!wait)
 307                 smp_mb__before_atomic_inc();
 308
 309         /*
 310          * Notify initiating CPU that I've grabbed the data and am
 311          * about to execute the function
 312          */
 313         atomic_inc(&call_data->started);
 314         /*
 315          * At this point the info structure may be out of scope unless wait==1
 316          */
 317         (*func)(info);
 318         if (wait) {
 319                 smp_mb__before_atomic_inc();
 320                 atomic_inc(&call_data->finished);
 321         }
 322 }
 323
 324 extern struct gettimeofday_struct do_gtod;
 325
 326 struct thread_info *current_set[NR_CPUS];
 327
 328 DECLARE_PER_CPU(unsigned int, pvr);
 329
 330 static void __devinit smp_store_cpu_info(int id)
 331 {
 332         per_cpu(pvr, id) = mfspr(SPRN_PVR);
 333 }
 334
 335 static void __init smp_create_idle(unsigned int cpu)
 336 {
 337         struct task_struct *p;
 338
 339         /* create a process for the processor */
 340         p = fork_idle(cpu);
 341         if (IS_ERR(p))
 342                 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
 343 #ifdef CONFIG_PPC64
 344         paca[cpu].__current = p;
 345 #endif
 346         current_set[cpu] = task_thread_info(p);
 347         task_thread_info(p)->cpu = cpu;
 348 }
 349
 350 void __init smp_prepare_cpus(unsigned int max_cpus)
 351 {
 352         unsigned int cpu;
 353
 354         DBG("smp_prepare_cpus\n");
 355
 356         /*
 357          * setup_cpu may need to be called on the boot cpu. We havent
 358          * spun any cpus up but lets be paranoid.
 359          */
 360         BUG_ON(boot_cpuid != smp_processor_id());
 361
 362         /* Fixup boot cpu */
 363         smp_store_cpu_info(boot_cpuid);
 364         cpu_callin_map[boot_cpuid] = 1;
 365
 366         if (smp_ops)
 367                 max_cpus = smp_ops->probe();
 368         else
 369                 max_cpus = 1;
 370
 371         smp_space_timers(max_cpus);
 372
 373         for_each_possible_cpu(cpu)
 374                 if (cpu != boot_cpuid)
 375                         smp_create_idle(cpu);
 376 }
 377
 378 void __devinit smp_prepare_boot_cpu(void)
 379 {
 380         BUG_ON(smp_processor_id() != boot_cpuid);
 381
 382         cpu_set(boot_cpuid, cpu_online_map);
 383 #ifdef CONFIG_PPC64
 384         paca[boot_cpuid].__current = current;
 385 #endif
 386         current_set[boot_cpuid] = task_thread_info(current);
 387 }
 388
 389 #ifdef CONFIG_HOTPLUG_CPU
 390 /* State of each CPU during hotplug phases */
 391 DEFINE_PER_CPU(int, cpu_state) = { 0 };
 392
 393 int generic_cpu_disable(void)
 394 {
 395         unsigned int cpu = smp_processor_id();
 396
 397         if (cpu == boot_cpuid)
 398                 return -EBUSY;
 399
 400         cpu_clear(cpu, cpu_online_map);
 401 #ifdef CONFIG_PPC64
 402         vdso_data->processorCount--;
 403         fixup_irqs(cpu_online_map);
 404 #endif
 405         return 0;
 406 }
 407
 408 int generic_cpu_enable(unsigned int cpu)
 409 {
 410         /* Do the normal bootup if we haven't
 411          * already bootstrapped. */
 412         if (system_state != SYSTEM_RUNNING)
 413                 return -ENOSYS;
 414
 415         /* get the target out of it's holding state */
 416         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
 417         smp_wmb();
 418
 419         while (!cpu_online(cpu))
 420                 cpu_relax();
 421
 422 #ifdef CONFIG_PPC64
 423         fixup_irqs(cpu_online_map);
 424         /* counter the irq disable in fixup_irqs */
 425         local_irq_enable();
 426 #endif
 427         return 0;
 428 }
 429
 430 void generic_cpu_die(unsigned int cpu)
 431 {
 432         int i;
 433
 434         for (i = 0; i < 100; i++) {
 435                 smp_rmb();
 436                 if (per_cpu(cpu_state, cpu) == CPU_DEAD)
 437                         return;
 438                 msleep(100);
 439         }
 440         printk(KERN_ERR "CPU%d didn't die...\n", cpu);
 441 }
 442
 443 void generic_mach_cpu_die(void)
 444 {
 445         unsigned int cpu;
 446
 447         local_irq_disable();
 448         cpu = smp_processor_id();
 449         printk(KERN_DEBUG "CPU%d offline\n", cpu);
 450         __get_cpu_var(cpu_state) = CPU_DEAD;
 451         smp_wmb();
 452         while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE)
 453                 cpu_relax();
 454
 455 #ifdef CONFIG_PPC64
 456         flush_tlb_pending();
 457 #endif
 458         cpu_set(cpu, cpu_online_map);
 459         local_irq_enable();
 460 }
 461 #endif
 462
 463 static int __devinit cpu_enable(unsigned int cpu)
 464 {
 465         if (smp_ops && smp_ops->cpu_enable)
 466                 return smp_ops->cpu_enable(cpu);
 467
 468         return -ENOSYS;
 469 }
 470
 471 int __cpuinit __cpu_up(unsigned int cpu)
 472 {
 473         int c;
 474
 475         secondary_ti = current_set[cpu];
 476         if (!cpu_enable(cpu))
 477                 return 0;
 478
 479         if (smp_ops == NULL ||
 480             (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
 481                 return -EINVAL;
 482
 483         /* Make sure callin-map entry is 0 (can be leftover a CPU
 484          * hotplug
 485          */
 486         cpu_callin_map[cpu] = 0;
 487
 488         /* The information for processor bringup must
 489          * be written out to main store before we release
 490          * the processor.
 491          */
 492         smp_mb();
 493
 494         /* wake up cpus */
 495         DBG("smp: kicking cpu %d\n", cpu);
 496         smp_ops->kick_cpu(cpu);
 497
 498         /*
 499          * wait to see if the cpu made a callin (is actually up).
 500          * use this value that I found through experimentation.
 501          * -- Cort
 502          */
 503         if (system_state < SYSTEM_RUNNING)
 504                 for (c = 50000; c && !cpu_callin_map[cpu]; c--)
 505                         udelay(100);
 506 #ifdef CONFIG_HOTPLUG_CPU
 507         else
 508                 /*
 509                  * CPUs can take much longer to come up in the
 510                  * hotplug case.  Wait five seconds.
 511                  */
 512                 for (c = 25; c && !cpu_callin_map[cpu]; c--) {
 513                         msleep(200);
 514                 }
 515 #endif
 516
 517         if (!cpu_callin_map[cpu]) {
 518                 printk("Processor %u is stuck.\n", cpu);
 519                 return -ENOENT;
 520         }
 521
 522         printk("Processor %u found.\n", cpu);
 523
 524         if (smp_ops->give_timebase)
 525                 smp_ops->give_timebase();
 526
 527         /* Wait until cpu puts itself in the online map */
 528         while (!cpu_online(cpu))
 529                 cpu_relax();
 530
 531         return 0;
 532 }
 533
 534
 535 /* Activate a secondary processor. */
 536 int __devinit start_secondary(void *unused)
 537 {
 538         unsigned int cpu = smp_processor_id();
 539
 540         atomic_inc(&init_mm.mm_count);
 541         current->active_mm = &init_mm;
 542
 543         smp_store_cpu_info(cpu);
 544         set_dec(tb_ticks_per_jiffy);
 545         preempt_disable();
 546         cpu_callin_map[cpu] = 1;
 547
 548         smp_ops->setup_cpu(cpu);
 549         if (smp_ops->take_timebase)
 550                 smp_ops->take_timebase();
 551
 552         if (system_state > SYSTEM_BOOTING)
 553                 snapshot_timebase();
 554
 555         spin_lock(&call_lock);
 556         cpu_set(cpu, cpu_online_map);
 557         spin_unlock(&call_lock);
 558
 559         local_irq_enable();
 560
 561         cpu_idle();
 562         return 0;
 563 }
 564
 565 int setup_profiling_timer(unsigned int multiplier)
 566 {
 567         return 0;
 568 }
 569
 570 void __init smp_cpus_done(unsigned int max_cpus)
 571 {
 572         cpumask_t old_mask;
 573
 574         /* We want the setup_cpu() here to be called from CPU 0, but our
 575          * init thread may have been "borrowed" by another CPU in the meantime
 576          * se we pin us down to CPU 0 for a short while
 577          */
 578         old_mask = current->cpus_allowed;
 579         set_cpus_allowed(current, cpumask_of_cpu(boot_cpuid));
 580
 581         if (smp_ops)
 582                 smp_ops->setup_cpu(boot_cpuid);
 583
 584         set_cpus_allowed(current, old_mask);
 585
 586         snapshot_timebases();
 587
 588         dump_numa_cpu_topology();
 589 }
 590
 591 #ifdef CONFIG_HOTPLUG_CPU
 592 int __cpu_disable(void)
 593 {
 594         if (smp_ops->cpu_disable)
 595                 return smp_ops->cpu_disable();
 596
 597         return -ENOSYS;
 598 }
 599
 600 void __cpu_die(unsigned int cpu)
 601 {
 602         if (smp_ops->cpu_die)
 603                 smp_ops->cpu_die(cpu);
 604 }
 605 #endif