git.oblomov.eu Git - linux-2.6/blob - arch/sparc/kernel/smp.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
  36 int smp_num_cpus = 1;
  37 volatile unsigned long cpu_callin_map[NR_CPUS] __initdata = {0,};
  38 unsigned char boot_cpu_id = 0;
  39 unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
  40 int smp_activated = 0;
  41 volatile int __cpu_number_map[NR_CPUS];
  42 volatile int __cpu_logical_map[NR_CPUS];
  43
  44 cpumask_t cpu_online_map = CPU_MASK_NONE;
  45 cpumask_t phys_cpu_present_map = CPU_MASK_NONE;
  46 cpumask_t smp_commenced_mask = CPU_MASK_NONE;
  47
  48 /* The only guaranteed locking primitive available on all Sparc
  49  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
  50  * places the current byte at the effective address into dest_reg and
  51  * places 0xff there afterwards.  Pretty lame locking primitive
  52  * compared to the Alpha and the Intel no?  Most Sparcs have 'swap'
  53  * instruction which is much better...
  54  */
  55
  56 /* Used to make bitops atomic */
  57 unsigned char bitops_spinlock = 0;
  58
  59 void __cpuinit smp_store_cpu_info(int id)
  60 {
  61         int cpu_node;
  62
  63         cpu_data(id).udelay_val = loops_per_jiffy;
  64
  65         cpu_find_by_mid(id, &cpu_node);
  66         cpu_data(id).clock_tick = prom_getintdefault(cpu_node,
  67                                                      "clock-frequency", 0);
  68         cpu_data(id).prom_node = cpu_node;
  69         cpu_data(id).mid = cpu_get_hwmid(cpu_node);
  70
  71         if (cpu_data(id).mid < 0)
  72                 panic("No MID found for CPU%d at node 0x%08d", id, cpu_node);
  73 }
  74
  75 void __init smp_cpus_done(unsigned int max_cpus)
  76 {
  77         extern void smp4m_smp_done(void);
  78         extern void smp4d_smp_done(void);
  79         unsigned long bogosum = 0;
  80         int cpu, num;
  81
  82         for (cpu = 0, num = 0; cpu < NR_CPUS; cpu++)
  83                 if (cpu_online(cpu)) {
  84                         num++;
  85                         bogosum += cpu_data(cpu).udelay_val;
  86                 }
  87
  88         printk("Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
  89                 num, bogosum/(500000/HZ),
  90                 (bogosum/(5000/HZ))%100);
  91
  92         switch(sparc_cpu_model) {
  93         case sun4:
  94                 printk("SUN4\n");
  95                 BUG();
  96                 break;
  97         case sun4c:
  98                 printk("SUN4C\n");
  99                 BUG();
 100                 break;
 101         case sun4m:
 102                 smp4m_smp_done();
 103                 break;
 104         case sun4d:
 105                 smp4d_smp_done();
 106                 break;
 107         case sun4e:
 108                 printk("SUN4E\n");
 109                 BUG();
 110                 break;
 111         case sun4u:
 112                 printk("SUN4U\n");
 113                 BUG();
 114                 break;
 115         default:
 116                 printk("UNKNOWN!\n");
 117                 BUG();
 118                 break;
 119         };
 120 }
 121
 122 void cpu_panic(void)
 123 {
 124         printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
 125         panic("SMP bolixed\n");
 126 }
 127
 128 struct linux_prom_registers smp_penguin_ctable __initdata = { 0 };
 129
 130 void smp_send_reschedule(int cpu)
 131 {
 132         /* See sparc64 */
 133 }
 134
 135 void smp_send_stop(void)
 136 {
 137 }
 138
 139 void smp_flush_cache_all(void)
 140 {
 141         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
 142         local_flush_cache_all();
 143 }
 144
 145 void smp_flush_tlb_all(void)
 146 {
 147         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
 148         local_flush_tlb_all();
 149 }
 150
 151 void smp_flush_cache_mm(struct mm_struct *mm)
 152 {
 153         if(mm->context != NO_CONTEXT) {
 154                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 155                 cpu_clear(smp_processor_id(), cpu_mask);
 156                 if (!cpus_empty(cpu_mask))
 157                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
 158                 local_flush_cache_mm(mm);
 159         }
 160 }
 161
 162 void smp_flush_tlb_mm(struct mm_struct *mm)
 163 {
 164         if(mm->context != NO_CONTEXT) {
 165                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 166                 cpu_clear(smp_processor_id(), cpu_mask);
 167                 if (!cpus_empty(cpu_mask)) {
 168                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
 169                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
 170                                 mm->cpu_vm_mask = cpumask_of_cpu(smp_processor_id());
 171                 }
 172                 local_flush_tlb_mm(mm);
 173         }
 174 }
 175
 176 void smp_flush_cache_range(struct vm_area_struct *vma, unsigned long start,
 177                            unsigned long end)
 178 {
 179         struct mm_struct *mm = vma->vm_mm;
 180
 181         if (mm->context != NO_CONTEXT) {
 182                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 183                 cpu_clear(smp_processor_id(), cpu_mask);
 184                 if (!cpus_empty(cpu_mask))
 185                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) vma, start, end);
 186                 local_flush_cache_range(vma, start, end);
 187         }
 188 }
 189
 190 void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 191                          unsigned long end)
 192 {
 193         struct mm_struct *mm = vma->vm_mm;
 194
 195         if (mm->context != NO_CONTEXT) {
 196                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 197                 cpu_clear(smp_processor_id(), cpu_mask);
 198                 if (!cpus_empty(cpu_mask))
 199                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) vma, start, end);
 200                 local_flush_tlb_range(vma, start, end);
 201         }
 202 }
 203
 204 void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
 205 {
 206         struct mm_struct *mm = vma->vm_mm;
 207
 208         if(mm->context != NO_CONTEXT) {
 209                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 210                 cpu_clear(smp_processor_id(), cpu_mask);
 211                 if (!cpus_empty(cpu_mask))
 212                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
 213                 local_flush_cache_page(vma, page);
 214         }
 215 }
 216
 217 void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 218 {
 219         struct mm_struct *mm = vma->vm_mm;
 220
 221         if(mm->context != NO_CONTEXT) {
 222                 cpumask_t cpu_mask = mm->cpu_vm_mask;
 223                 cpu_clear(smp_processor_id(), cpu_mask);
 224                 if (!cpus_empty(cpu_mask))
 225                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
 226                 local_flush_tlb_page(vma, page);
 227         }
 228 }
 229
 230 void smp_reschedule_irq(void)
 231 {
 232         set_need_resched();
 233 }
 234
 235 void smp_flush_page_to_ram(unsigned long page)
 236 {
 237         /* Current theory is that those who call this are the one's
 238          * who have just dirtied their cache with the pages contents
 239          * in kernel space, therefore we only run this on local cpu.
 240          *
 241          * XXX This experiment failed, research further... -DaveM
 242          */
 243 #if 1
 244         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
 245 #endif
 246         local_flush_page_to_ram(page);
 247 }
 248
 249 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
 250 {
 251         cpumask_t cpu_mask = mm->cpu_vm_mask;
 252         cpu_clear(smp_processor_id(), cpu_mask);
 253         if (!cpus_empty(cpu_mask))
 254                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
 255         local_flush_sig_insns(mm, insn_addr);
 256 }
 257
 258 extern unsigned int lvl14_resolution;
 259
 260 /* /proc/profile writes can call this, don't __init it please. */
 261 static DEFINE_SPINLOCK(prof_setup_lock);
 262
 263 int setup_profiling_timer(unsigned int multiplier)
 264 {
 265         int i;
 266         unsigned long flags;
 267
 268         /* Prevent level14 ticker IRQ flooding. */
 269         if((!multiplier) || (lvl14_resolution / multiplier) < 500)
 270                 return -EINVAL;
 271
 272         spin_lock_irqsave(&prof_setup_lock, flags);
 273         for_each_possible_cpu(i) {
 274                 load_profile_irq(i, lvl14_resolution / multiplier);
 275                 prof_multiplier(i) = multiplier;
 276         }
 277         spin_unlock_irqrestore(&prof_setup_lock, flags);
 278
 279         return 0;
 280 }
 281
 282 void __init smp_prepare_cpus(unsigned int max_cpus)
 283 {
 284         extern void __init smp4m_boot_cpus(void);
 285         extern void __init smp4d_boot_cpus(void);
 286         int i, cpuid, extra;
 287
 288         printk("Entering SMP Mode...\n");
 289
 290         extra = 0;
 291         for (i = 0; !cpu_find_by_instance(i, NULL, &cpuid); i++) {
 292                 if (cpuid >= NR_CPUS)
 293                         extra++;
 294         }
 295         /* i = number of cpus */
 296         if (extra && max_cpus > i - extra)
 297                 printk("Warning: NR_CPUS is too low to start all cpus\n");
 298
 299         smp_store_cpu_info(boot_cpu_id);
 300
 301         switch(sparc_cpu_model) {
 302         case sun4:
 303                 printk("SUN4\n");
 304                 BUG();
 305                 break;
 306         case sun4c:
 307                 printk("SUN4C\n");
 308                 BUG();
 309                 break;
 310         case sun4m:
 311                 smp4m_boot_cpus();
 312                 break;
 313         case sun4d:
 314                 smp4d_boot_cpus();
 315                 break;
 316         case sun4e:
 317                 printk("SUN4E\n");
 318                 BUG();
 319                 break;
 320         case sun4u:
 321                 printk("SUN4U\n");
 322                 BUG();
 323                 break;
 324         default:
 325                 printk("UNKNOWN!\n");
 326                 BUG();
 327                 break;
 328         };
 329 }
 330
 331 /* Set this up early so that things like the scheduler can init
 332  * properly.  We use the same cpu mask for both the present and
 333  * possible cpu map.
 334  */
 335 void __init smp_setup_cpu_possible_map(void)
 336 {
 337         int instance, mid;
 338
 339         instance = 0;
 340         while (!cpu_find_by_instance(instance, NULL, &mid)) {
 341                 if (mid < NR_CPUS) {
 342                         cpu_set(mid, phys_cpu_present_map);
 343                         cpu_set(mid, cpu_present_map);
 344                 }
 345                 instance++;
 346         }
 347 }
 348
 349 void __init smp_prepare_boot_cpu(void)
 350 {
 351         int cpuid = hard_smp_processor_id();
 352
 353         if (cpuid >= NR_CPUS) {
 354                 prom_printf("Serious problem, boot cpu id >= NR_CPUS\n");
 355                 prom_halt();
 356         }
 357         if (cpuid != 0)
 358                 printk("boot cpu id != 0, this could work but is untested\n");
 359
 360         current_thread_info()->cpu = cpuid;
 361         cpu_set(cpuid, cpu_online_map);
 362         cpu_set(cpuid, phys_cpu_present_map);
 363 }
 364
 365 int __cpuinit __cpu_up(unsigned int cpu)
 366 {
 367         extern int __cpuinit smp4m_boot_one_cpu(int);
 368         extern int __cpuinit smp4d_boot_one_cpu(int);
 369         int ret=0;
 370
 371         switch(sparc_cpu_model) {
 372         case sun4:
 373                 printk("SUN4\n");
 374                 BUG();
 375                 break;
 376         case sun4c:
 377                 printk("SUN4C\n");
 378                 BUG();
 379                 break;
 380         case sun4m:
 381                 ret = smp4m_boot_one_cpu(cpu);
 382                 break;
 383         case sun4d:
 384                 ret = smp4d_boot_one_cpu(cpu);
 385                 break;
 386         case sun4e:
 387                 printk("SUN4E\n");
 388                 BUG();
 389                 break;
 390         case sun4u:
 391                 printk("SUN4U\n");
 392                 BUG();
 393                 break;
 394         default:
 395                 printk("UNKNOWN!\n");
 396                 BUG();
 397                 break;
 398         };
 399
 400         if (!ret) {
 401                 cpu_set(cpu, smp_commenced_mask);
 402                 while (!cpu_online(cpu))
 403                         mb();
 404         }
 405         return ret;
 406 }
 407
 408 void smp_bogo(struct seq_file *m)
 409 {
 410         int i;
 411
 412         for_each_online_cpu(i) {
 413                 seq_printf(m,
 414                            "Cpu%dBogo\t: %lu.%02lu\n",
 415                            i,
 416                            cpu_data(i).udelay_val/(500000/HZ),
 417                            (cpu_data(i).udelay_val/(5000/HZ))%100);
 418         }
 419 }
 420
 421 void smp_info(struct seq_file *m)
 422 {
 423         int i;
 424
 425         seq_printf(m, "State:\n");
 426         for_each_online_cpu(i)
 427                 seq_printf(m, "CPU%d\t\t: online\n", i);
 428 }