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  */
   6
   7 #include <asm/head.h>
   8
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/threads.h>
  12 #include <linux/smp.h>
  13 #include <linux/smp_lock.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
  20 #include <asm/ptrace.h>
  21 #include <asm/atomic.h>
  22
  23 #include <asm/delay.h>
  24 #include <asm/irq.h>
  25 #include <asm/page.h>
  26 #include <asm/pgalloc.h>
  27 #include <asm/pgtable.h>
  28 #include <asm/oplib.h>
  29 #include <asm/hardirq.h>
  30 #include <asm/softirq.h>
  31
  32 #define __KERNEL_SYSCALLS__
  33 #include <linux/unistd.h>
  34
  35 #define IRQ_RESCHEDULE          13
  36 #define IRQ_STOP_CPU            14
  37 #define IRQ_CROSS_CALL          15
  38
  39 volatile int smp_processors_ready = 0;
  40 unsigned long cpu_present_map = 0;
  41 int smp_num_cpus = 1;
  42 int smp_threads_ready=0;
  43 unsigned char mid_xlate[NR_CPUS] = { 0, 0, 0, 0, };
  44 volatile unsigned long cpu_callin_map[NR_CPUS] __initdata = {0,};
  45 #ifdef NOTUSED
  46 volatile unsigned long smp_spinning[NR_CPUS] = { 0, };
  47 #endif
  48 unsigned long smp_proc_in_lock[NR_CPUS] = { 0, };
  49 struct cpuinfo_sparc cpu_data[NR_CPUS];
  50 unsigned long cpu_offset[NR_CPUS];
  51 unsigned char boot_cpu_id = 0;
  52 unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
  53 int smp_activated = 0;
  54 volatile int __cpu_number_map[NR_CPUS];
  55 volatile int __cpu_logical_map[NR_CPUS];
  56 cycles_t cacheflush_time = 0; /* XXX */
  57
  58 /* The only guaranteed locking primitive available on all Sparc
  59  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
  60  * places the current byte at the effective address into dest_reg and
  61  * places 0xff there afterwards.  Pretty lame locking primitive
  62  * compared to the Alpha and the Intel no?  Most Sparcs have 'swap'
  63  * instruction which is much better...
  64  */
  65
  66 /* Kernel spinlock */
  67 spinlock_t kernel_flag = SPIN_LOCK_UNLOCKED;
  68
  69 /* Used to make bitops atomic */
  70 unsigned char bitops_spinlock = 0;
  71
  72 volatile unsigned long ipi_count;
  73
  74 volatile int smp_process_available=0;
  75 volatile int smp_commenced = 0;
  76
  77 /* Not supported on Sparc yet. */
  78 void __init smp_setup(char *str, int *ints)
  79 {
  80 }
  81
  82 /*
  83  *      The bootstrap kernel entry code has set these up. Save them for
  84  *      a given CPU
  85  */
  86
  87 void __init smp_store_cpu_info(int id)
  88 {
  89         cpu_data[id].udelay_val = loops_per_sec; /* this is it on sparc. */
  90 }
  91
  92 void __init smp_commence(void)
  93 {
  94         /*
  95          *      Lets the callin's below out of their loop.
  96          */
  97         local_flush_cache_all();
  98         local_flush_tlb_all();
  99         smp_commenced = 1;
 100         local_flush_cache_all();
 101         local_flush_tlb_all();
 102 }
 103
 104 /* Only broken Intel needs this, thus it should not even be referenced
 105  * globally...
 106  */
 107 void __init initialize_secondary(void)
 108 {
 109 }
 110
 111 extern int cpu_idle(void);
 112
 113 /* Activate a secondary processor. */
 114 int start_secondary(void *unused)
 115 {
 116         prom_printf("Start secondary called. Should not happen\n");
 117         return cpu_idle();
 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 /*
 127  *      Cycle through the processors asking the PROM to start each one.
 128  */
 129
 130 extern struct prom_cpuinfo linux_cpus[NR_CPUS];
 131 struct linux_prom_registers smp_penguin_ctable __initdata = { 0 };
 132
 133 void __init smp_boot_cpus(void)
 134 {
 135         extern void smp4m_boot_cpus(void);
 136         extern void smp4d_boot_cpus(void);
 137
 138         if (sparc_cpu_model == sun4m)
 139                 smp4m_boot_cpus();
 140         else
 141                 smp4d_boot_cpus();
 142 }
 143
 144 void smp_flush_cache_all(void)
 145 {
 146         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
 147         local_flush_cache_all();
 148 }
 149
 150 void smp_flush_tlb_all(void)
 151 {
 152         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
 153         local_flush_tlb_all();
 154 }
 155
 156 void smp_flush_cache_mm(struct mm_struct *mm)
 157 {
 158         if(mm->context != NO_CONTEXT) {
 159                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 160                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
 161                 local_flush_cache_mm(mm);
 162         }
 163 }
 164
 165 void smp_flush_tlb_mm(struct mm_struct *mm)
 166 {
 167         if(mm->context != NO_CONTEXT) {
 168                 if(mm->cpu_vm_mask != (1 << smp_processor_id())) {
 169                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
 170                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
 171                                 mm->cpu_vm_mask = (1 << smp_processor_id());
 172                 }
 173                 local_flush_tlb_mm(mm);
 174         }
 175 }
 176
 177 void smp_flush_cache_range(struct mm_struct *mm, unsigned long start,
 178                            unsigned long end)
 179 {
 180         if(mm->context != NO_CONTEXT) {
 181                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 182                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) mm, start, end);
 183                 local_flush_cache_range(mm, start, end);
 184         }
 185 }
 186
 187 void smp_flush_tlb_range(struct mm_struct *mm, unsigned long start,
 188                          unsigned long end)
 189 {
 190         if(mm->context != NO_CONTEXT) {
 191                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 192                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) mm, start, end);
 193                 local_flush_tlb_range(mm, start, end);
 194         }
 195 }
 196
 197 void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
 198 {
 199         struct mm_struct *mm = vma->vm_mm;
 200
 201         if(mm->context != NO_CONTEXT) {
 202                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 203                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
 204                 local_flush_cache_page(vma, page);
 205         }
 206 }
 207
 208 void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 209 {
 210         struct mm_struct *mm = vma->vm_mm;
 211
 212         if(mm->context != NO_CONTEXT) {
 213                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 214                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
 215                 local_flush_tlb_page(vma, page);
 216         }
 217 }
 218
 219 void smp_flush_page_to_ram(unsigned long page)
 220 {
 221         /* Current theory is that those who call this are the one's
 222          * who have just dirtied their cache with the pages contents
 223          * in kernel space, therefore we only run this on local cpu.
 224          *
 225          * XXX This experiment failed, research further... -DaveM
 226          */
 227 #if 1
 228         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
 229 #endif
 230         local_flush_page_to_ram(page);
 231 }
 232
 233 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
 234 {
 235         if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 236                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
 237         local_flush_sig_insns(mm, insn_addr);
 238 }
 239
 240 /* Reschedule call back. */
 241 void smp_reschedule_irq(void)
 242 {
 243         current->need_resched = 1;
 244 }
 245
 246 /* Stopping processors. */
 247 void smp_stop_cpu_irq(void)
 248 {
 249         __sti();
 250         while(1)
 251                 barrier();
 252 }
 253
 254 unsigned int prof_multiplier[NR_CPUS];
 255 unsigned int prof_counter[NR_CPUS];
 256 extern unsigned int lvl14_resolution;
 257
 258 int setup_profiling_timer(unsigned int multiplier)
 259 {
 260         int i;
 261         unsigned long flags;
 262
 263         /* Prevent level14 ticker IRQ flooding. */
 264         if((!multiplier) || (lvl14_resolution / multiplier) < 500)
 265                 return -EINVAL;
 266
 267         save_and_cli(flags);
 268         for(i = 0; i < NR_CPUS; i++) {
 269                 if(cpu_present_map & (1 << i)) {
 270                         load_profile_irq(mid_xlate[i], lvl14_resolution / multiplier);
 271                         prof_multiplier[i] = multiplier;
 272                 }
 273         }
 274         restore_flags(flags);
 275
 276         return 0;
 277 }
 278
 279 int smp_bogo_info(char *buf)
 280 {
 281         int len = 0, i;
 282
 283         for (i = 0; i < NR_CPUS; i++)
 284                 if (cpu_present_map & (1 << i))
 285                         len += sprintf(buf + len, "Cpu%dBogo\t: %lu.%02lu\n",
 286                                         i,
 287                                         cpu_data[i].udelay_val/500000,
 288                                         (cpu_data[i].udelay_val/5000)%100);
 289         return len;
 290 }
 291
 292 int smp_info(char *buf)
 293 {
 294         int len = 0, i;
 295
 296         for (i = 0; i < NR_CPUS; i++)
 297                 if (cpu_present_map & (1 << i))
 298                         len += sprintf(buf + len, "CPU%d\t\t: online\n", i);
 299         return len;
 300 }