arch/sparc/kernel/smp_32.c

   1 /* smp.c: Sparc SMP support.
   2  *
   3  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
   4  * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   5  * Copyright (C) 2004 Keith M Wesolowski (wesolows@foobazco.org)
   6  */
   7
   8 #include <asm/head.h>
   9
  10 #include <linux/kernel.h>
  11 #include <linux/sched.h>
  12 #include <linux/threads.h>
  13 #include <linux/smp.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel_stat.h>
  16 #include <linux/init.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/mm.h>
  19 #include <linux/fs.h>
  20 #include <linux/seq_file.h>
  21 #include <linux/cache.h>
  22 #include <linux/delay.h>
  23
  24 #include <asm/ptrace.h>
  25 #include <asm/atomic.h>
  26
  27 #include <asm/irq.h>
  28 #include <asm/page.h>
  29 #include <asm/pgalloc.h>
  30 #include <asm/pgtable.h>
  31 #include <asm/oplib.h>
  32 #include <asm/cacheflush.h>
  33 #include <asm/tlbflush.h>
  34 #include <asm/cpudata.h>
  35 #include <asm/leon.h>
  36
  37 #include "irq.h"
  38
  39 volatile unsigned long cpu_callin_map[NR_CPUS] __cpuinitdata = {0,};
  40
  41 cpumask_t smp_commenced_mask = CPU_MASK_NONE;
  42
  43 /* The only guaranteed locking primitive available on all Sparc
  44  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
  45  * places the current byte at the effective address into dest_reg and
  46  * places 0xff there afterwards.  Pretty lame locking primitive
  47  * compared to the Alpha and the Intel no?  Most Sparcs have 'swap'
  48  * instruction which is much better...
  49  */
  50
  51 void __cpuinit smp_store_cpu_info(int id)
  52 {
  53         int cpu_node;
  54         int mid;
  55
  56         cpu_data(id).udelay_val = loops_per_jiffy;
  57
  58         cpu_find_by_mid(id, &cpu_node);
  59         cpu_data(id).clock_tick = prom_getintdefault(cpu_node,
  60                                                      "clock-frequency", 0);
  61         cpu_data(id).prom_node = cpu_node;
  62         mid = cpu_get_hwmid(cpu_node);
  63
  64         if (mid < 0) {
  65                 printk(KERN_NOTICE "No MID found for CPU%d at node 0x%08d", id, cpu_node);
  66                 mid = 0;
  67         }
  68         cpu_data(id).mid = mid;
  69 }
  70
  71 void __init smp_cpus_done(unsigned int max_cpus)
  72 {
  73         extern void smp4m_smp_done(void);
  74         extern void smp4d_smp_done(void);
  75         unsigned long bogosum = 0;
  76         int cpu, num = 0;
  77
  78         for_each_online_cpu(cpu) {
  79                 num++;
  80                 bogosum += cpu_data(cpu).udelay_val;
  81         }
  82
  83         printk("Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
  84                 num, bogosum/(500000/HZ),
  85                 (bogosum/(5000/HZ))%100);
  86
  87         switch(sparc_cpu_model) {
  88         case sun4:
  89                 printk("SUN4\n");
  90                 BUG();
  91                 break;
  92         case sun4c:
  93                 printk("SUN4C\n");
  94                 BUG();
  95                 break;
  96         case sun4m:
  97                 smp4m_smp_done();
  98                 break;
  99         case sun4d:
 100                 smp4d_smp_done();
 101                 break;
 102         case sparc_leon:
 103                 leon_smp_done();
 104                 break;
 105         case sun4e:
 106                 printk("SUN4E\n");
 107                 BUG();
 108                 break;
 109         case sun4u:
 110                 printk("SUN4U\n");
 111                 BUG();
 112                 break;
 113         default:
 114                 printk("UNKNOWN!\n");
 115                 BUG();
 116                 break;
 117         }
 118 }
 119
 120 void cpu_panic(void)
 121 {
 122         printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
 123         panic("SMP bolixed\n");
 124 }
 125
 126 struct linux_prom_registers smp_penguin_ctable __cpuinitdata = { 0 };
 127
 128 void smp_send_reschedule(int cpu)
 129 {
 130         /*
 131          * CPU model dependent way of implementing IPI generation targeting
 132          * a single CPU. The trap handler needs only to do trap entry/return
 133          * to call schedule.
 134          */
 135         BTFIXUP_CALL(smp_ipi_resched)(cpu);
 136 }
 137
 138 void smp_send_stop(void)
 139 {
 140 }
 141
 142 void arch_send_call_function_single_ipi(int cpu)
 143 {
 144         /* trigger one IPI single call on one CPU */
 145         BTFIXUP_CALL(smp_ipi_single)(cpu);
 146 }
 147
 148 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 149 {
 150         int cpu;
 151
 152         /* trigger IPI mask call on each CPU */
 153         for_each_cpu(cpu, mask)
 154                 BTFIXUP_CALL(smp_ipi_mask_one)(cpu);
 155 }
 156
 157 void smp_resched_interrupt(void)
 158 {
 159         irq_enter();
 160         scheduler_ipi();
 161         local_cpu_data().irq_resched_count++;
 162         irq_exit();
 163         /* re-schedule routine called by interrupt return code. */
 164 }
 165
 166 void smp_call_function_single_interrupt(void)
 167 {
 168         irq_enter();
 169         generic_smp_call_function_single_interrupt();
 170         local_cpu_data().irq_call_count++;
 171         irq_exit();
 172 }
 173
 174 void smp_call_function_interrupt(void)
 175 {
 176         irq_enter();
 177         generic_smp_call_function_interrupt();
 178         local_cpu_data().irq_call_count++;
 179         irq_exit();
 180 }
 181
 182 void smp_flush_cache_all(void)
 183 {
 184         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
 185         local_flush_cache_all();
 186 }
 187
 188 void smp_flush_tlb_all(void)
 189 {
 190         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
 191         local_flush_tlb_all();
 192 }
 193
 194 void smp_flush_cache_mm(struct mm_struct *mm)
 195 {
 196         if(mm->context != NO_CONTEXT) {
 197                 cpumask_t cpu_mask;
 198                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 199                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 200                 if (!cpumask_empty(&cpu_mask))
 201                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
 202                 local_flush_cache_mm(mm);
 203         }
 204 }
 205
 206 void smp_flush_tlb_mm(struct mm_struct *mm)
 207 {
 208         if(mm->context != NO_CONTEXT) {
 209                 cpumask_t cpu_mask;
 210                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 211                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 212                 if (!cpumask_empty(&cpu_mask)) {
 213                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
 214                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
 215                                 cpumask_copy(mm_cpumask(mm),
 216                                              cpumask_of(smp_processor_id()));
 217                 }
 218                 local_flush_tlb_mm(mm);
 219         }
 220 }
 221
 222 void smp_flush_cache_range(struct vm_area_struct *vma, unsigned long start,
 223                            unsigned long end)
 224 {
 225         struct mm_struct *mm = vma->vm_mm;
 226
 227         if (mm->context != NO_CONTEXT) {
 228                 cpumask_t cpu_mask;
 229                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 230                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 231                 if (!cpumask_empty(&cpu_mask))
 232                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) vma, start, end);
 233                 local_flush_cache_range(vma, start, end);
 234         }
 235 }
 236
 237 void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 238                          unsigned long end)
 239 {
 240         struct mm_struct *mm = vma->vm_mm;
 241
 242         if (mm->context != NO_CONTEXT) {
 243                 cpumask_t cpu_mask;
 244                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 245                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 246                 if (!cpumask_empty(&cpu_mask))
 247                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) vma, start, end);
 248                 local_flush_tlb_range(vma, start, end);
 249         }
 250 }
 251
 252 void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
 253 {
 254         struct mm_struct *mm = vma->vm_mm;
 255
 256         if(mm->context != NO_CONTEXT) {
 257                 cpumask_t cpu_mask;
 258                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 259                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 260                 if (!cpumask_empty(&cpu_mask))
 261                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
 262                 local_flush_cache_page(vma, page);
 263         }
 264 }
 265
 266 void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 267 {
 268         struct mm_struct *mm = vma->vm_mm;
 269
 270         if(mm->context != NO_CONTEXT) {
 271                 cpumask_t cpu_mask;
 272                 cpumask_copy(&cpu_mask, mm_cpumask(mm));
 273                 cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 274                 if (!cpumask_empty(&cpu_mask))
 275                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
 276                 local_flush_tlb_page(vma, page);
 277         }
 278 }
 279
 280 void smp_flush_page_to_ram(unsigned long page)
 281 {
 282         /* Current theory is that those who call this are the one's
 283          * who have just dirtied their cache with the pages contents
 284          * in kernel space, therefore we only run this on local cpu.
 285          *
 286          * XXX This experiment failed, research further... -DaveM
 287          */
 288 #if 1
 289         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
 290 #endif
 291         local_flush_page_to_ram(page);
 292 }
 293
 294 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
 295 {
 296         cpumask_t cpu_mask;
 297         cpumask_copy(&cpu_mask, mm_cpumask(mm));
 298         cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
 299         if (!cpumask_empty(&cpu_mask))
 300                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
 301         local_flush_sig_insns(mm, insn_addr);
 302 }
 303
 304 extern unsigned int lvl14_resolution;
 305
 306 /* /proc/profile writes can call this, don't __init it please. */
 307 static DEFINE_SPINLOCK(prof_setup_lock);
 308
 309 int setup_profiling_timer(unsigned int multiplier)
 310 {
 311         int i;
 312         unsigned long flags;
 313
 314         /* Prevent level14 ticker IRQ flooding. */
 315         if((!multiplier) || (lvl14_resolution / multiplier) < 500)
 316                 return -EINVAL;
 317
 318         spin_lock_irqsave(&prof_setup_lock, flags);
 319         for_each_possible_cpu(i) {
 320                 load_profile_irq(i, lvl14_resolution / multiplier);
 321                 prof_multiplier(i) = multiplier;
 322         }
 323         spin_unlock_irqrestore(&prof_setup_lock, flags);
 324
 325         return 0;
 326 }
 327
 328 void __init smp_prepare_cpus(unsigned int max_cpus)
 329 {
 330         extern void __init smp4m_boot_cpus(void);
 331         extern void __init smp4d_boot_cpus(void);
 332         int i, cpuid, extra;
 333
 334         printk("Entering SMP Mode...\n");
 335
 336         extra = 0;
 337         for (i = 0; !cpu_find_by_instance(i, NULL, &cpuid); i++) {
 338                 if (cpuid >= NR_CPUS)
 339                         extra++;
 340         }
 341         /* i = number of cpus */
 342         if (extra && max_cpus > i - extra)
 343                 printk("Warning: NR_CPUS is too low to start all cpus\n");
 344
 345         smp_store_cpu_info(boot_cpu_id);
 346
 347         switch(sparc_cpu_model) {
 348         case sun4:
 349                 printk("SUN4\n");
 350                 BUG();
 351                 break;
 352         case sun4c:
 353                 printk("SUN4C\n");
 354                 BUG();
 355                 break;
 356         case sun4m:
 357                 smp4m_boot_cpus();
 358                 break;
 359         case sun4d:
 360                 smp4d_boot_cpus();
 361                 break;
 362         case sparc_leon:
 363                 leon_boot_cpus();
 364                 break;
 365         case sun4e:
 366                 printk("SUN4E\n");
 367                 BUG();
 368                 break;
 369         case sun4u:
 370                 printk("SUN4U\n");
 371                 BUG();
 372                 break;
 373         default:
 374                 printk("UNKNOWN!\n");
 375                 BUG();
 376                 break;
 377         }
 378 }
 379
 380 /* Set this up early so that things like the scheduler can init
 381  * properly.  We use the same cpu mask for both the present and
 382  * possible cpu map.
 383  */
 384 void __init smp_setup_cpu_possible_map(void)
 385 {
 386         int instance, mid;
 387
 388         instance = 0;
 389         while (!cpu_find_by_instance(instance, NULL, &mid)) {
 390                 if (mid < NR_CPUS) {
 391                         set_cpu_possible(mid, true);
 392                         set_cpu_present(mid, true);
 393                 }
 394                 instance++;
 395         }
 396 }
 397
 398 void __init smp_prepare_boot_cpu(void)
 399 {
 400         int cpuid = hard_smp_processor_id();
 401
 402         if (cpuid >= NR_CPUS) {
 403                 prom_printf("Serious problem, boot cpu id >= NR_CPUS\n");
 404                 prom_halt();
 405         }
 406         if (cpuid != 0)
 407                 printk("boot cpu id != 0, this could work but is untested\n");
 408
 409         current_thread_info()->cpu = cpuid;
 410         set_cpu_online(cpuid, true);
 411         set_cpu_possible(cpuid, true);
 412 }
 413
 414 int __cpuinit __cpu_up(unsigned int cpu)
 415 {
 416         extern int __cpuinit smp4m_boot_one_cpu(int);
 417         extern int __cpuinit smp4d_boot_one_cpu(int);
 418         int ret=0;
 419
 420         switch(sparc_cpu_model) {
 421         case sun4:
 422                 printk("SUN4\n");
 423                 BUG();
 424                 break;
 425         case sun4c:
 426                 printk("SUN4C\n");
 427                 BUG();
 428                 break;
 429         case sun4m:
 430                 ret = smp4m_boot_one_cpu(cpu);
 431                 break;
 432         case sun4d:
 433                 ret = smp4d_boot_one_cpu(cpu);
 434                 break;
 435         case sparc_leon:
 436                 ret = leon_boot_one_cpu(cpu);
 437                 break;
 438         case sun4e:
 439                 printk("SUN4E\n");
 440                 BUG();
 441                 break;
 442         case sun4u:
 443                 printk("SUN4U\n");
 444                 BUG();
 445                 break;
 446         default:
 447                 printk("UNKNOWN!\n");
 448                 BUG();
 449                 break;
 450         }
 451
 452         if (!ret) {
 453                 cpumask_set_cpu(cpu, &smp_commenced_mask);
 454                 while (!cpu_online(cpu))
 455                         mb();
 456         }
 457         return ret;
 458 }
 459
 460 void smp_bogo(struct seq_file *m)
 461 {
 462         int i;
 463
 464         for_each_online_cpu(i) {
 465                 seq_printf(m,
 466                            "Cpu%dBogo\t: %lu.%02lu\n",
 467                            i,
 468                            cpu_data(i).udelay_val/(500000/HZ),
 469                            (cpu_data(i).udelay_val/(5000/HZ))%100);
 470         }
 471 }
 472
 473 void smp_info(struct seq_file *m)
 474 {
 475         int i;
 476
 477         seq_printf(m, "State:\n");
 478         for_each_online_cpu(i)
 479                 seq_printf(m, "CPU%d\t\t: online\n", i);
 480 }