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/smp_lock.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/kernel_stat.h>
  17 #include <linux/init.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/mm.h>
  20 #include <linux/fs.h>
  21 #include <linux/seq_file.h>
  22 #include <linux/cache.h>
  23 #include <linux/delay.h>
  24
  25 #include <asm/ptrace.h>
  26 #include <asm/atomic.h>
  27
  28 #include <asm/irq.h>
  29 #include <asm/page.h>
  30 #include <asm/pgalloc.h>
  31 #include <asm/pgtable.h>
  32 #include <asm/oplib.h>
  33 #include <asm/hardirq.h>
  34 #include <asm/cacheflush.h>
  35 #include <asm/tlbflush.h>
  36 #include <asm/cpudata.h>
  37
  38 volatile int smp_processors_ready = 0;
  39 int smp_num_cpus = 1;
  40 int smp_threads_ready=0;
  41 volatile unsigned long cpu_callin_map[NR_CPUS] __initdata = {0,};
  42 unsigned char boot_cpu_id = 0;
  43 unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
  44 int smp_activated = 0;
  45 volatile int __cpu_number_map[NR_CPUS];
  46 volatile int __cpu_logical_map[NR_CPUS];
  47 cycles_t cacheflush_time = 0; /* XXX */
  48
  49 cpumask_t cpu_online_map = CPU_MASK_NONE;
  50 cpumask_t phys_cpu_present_map = CPU_MASK_NONE;
  51
  52 /* The only guaranteed locking primitive available on all Sparc
  53  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
  54  * places the current byte at the effective address into dest_reg and
  55  * places 0xff there afterwards.  Pretty lame locking primitive
  56  * compared to the Alpha and the Intel no?  Most Sparcs have 'swap'
  57  * instruction which is much better...
  58  */
  59
  60 /* Used to make bitops atomic */
  61 unsigned char bitops_spinlock = 0;
  62
  63 volatile unsigned long ipi_count;
  64
  65 volatile int smp_process_available=0;
  66 volatile int smp_commenced = 0;
  67
  68 void __init smp_store_cpu_info(int id)
  69 {
  70         int cpu_node;
  71
  72         cpu_data(id).udelay_val = loops_per_jiffy;
  73
  74         cpu_find_by_mid(id, &cpu_node);
  75         cpu_data(id).clock_tick = prom_getintdefault(cpu_node,
  76                                                      "clock-frequency", 0);
  77         cpu_data(id).prom_node = cpu_node;
  78         cpu_data(id).mid = cpu_get_hwmid(cpu_node);
  79         if (cpu_data(id).mid < 0)
  80                 panic("No MID found for CPU%d at node 0x%08d", id, cpu_node);
  81 }
  82
  83 void __init smp_cpus_done(unsigned int max_cpus)
  84 {
  85 }
  86
  87 void cpu_panic(void)
  88 {
  89         printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
  90         panic("SMP bolixed\n");
  91 }
  92
  93 struct linux_prom_registers smp_penguin_ctable __initdata = { 0 };
  94
  95 void __init smp_boot_cpus(void)
  96 {
  97         extern void smp4m_boot_cpus(void);
  98         extern void smp4d_boot_cpus(void);
  99
 100         if (sparc_cpu_model == sun4m)
 101                 smp4m_boot_cpus();
 102         else
 103                 smp4d_boot_cpus();
 104 }
 105
 106 void smp_send_reschedule(int cpu)
 107 {
 108         /* See sparc64 */
 109 }
 110
 111 void smp_send_stop(void)
 112 {
 113 }
 114
 115 void smp_flush_cache_all(void)
 116 {
 117         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
 118         local_flush_cache_all();
 119 }
 120
 121 void smp_flush_tlb_all(void)
 122 {
 123         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
 124         local_flush_tlb_all();
 125 }
 126
 127 void smp_flush_cache_mm(struct mm_struct *mm)
 128 {
 129         if(mm->context != NO_CONTEXT) {
 130                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 131                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
 132                 local_flush_cache_mm(mm);
 133         }
 134 }
 135
 136 void smp_flush_tlb_mm(struct mm_struct *mm)
 137 {
 138         if(mm->context != NO_CONTEXT) {
 139                 if(mm->cpu_vm_mask != (1 << smp_processor_id())) {
 140                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
 141                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
 142                                 mm->cpu_vm_mask = (1 << smp_processor_id());
 143                 }
 144                 local_flush_tlb_mm(mm);
 145         }
 146 }
 147
 148 void smp_flush_cache_range(struct vm_area_struct *vma, unsigned long start,
 149                            unsigned long end)
 150 {
 151         struct mm_struct *mm = vma->vm_mm;
 152
 153         if (mm->context != NO_CONTEXT) {
 154                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 155                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) vma, start, end);
 156                 local_flush_cache_range(vma, start, end);
 157         }
 158 }
 159
 160 void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 161                          unsigned long end)
 162 {
 163         struct mm_struct *mm = vma->vm_mm;
 164
 165         if (mm->context != NO_CONTEXT) {
 166                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 167                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) vma, start, end);
 168                 local_flush_tlb_range(vma, start, end);
 169         }
 170 }
 171
 172 void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
 173 {
 174         struct mm_struct *mm = vma->vm_mm;
 175
 176         if(mm->context != NO_CONTEXT) {
 177                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 178                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
 179                 local_flush_cache_page(vma, page);
 180         }
 181 }
 182
 183 void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 184 {
 185         struct mm_struct *mm = vma->vm_mm;
 186
 187         if(mm->context != NO_CONTEXT) {
 188                 if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 189                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
 190                 local_flush_tlb_page(vma, page);
 191         }
 192 }
 193
 194 void smp_flush_page_to_ram(unsigned long page)
 195 {
 196         /* Current theory is that those who call this are the one's
 197          * who have just dirtied their cache with the pages contents
 198          * in kernel space, therefore we only run this on local cpu.
 199          *
 200          * XXX This experiment failed, research further... -DaveM
 201          */
 202 #if 1
 203         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
 204 #endif
 205         local_flush_page_to_ram(page);
 206 }
 207
 208 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
 209 {
 210         if(mm->cpu_vm_mask != (1 << smp_processor_id()))
 211                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
 212         local_flush_sig_insns(mm, insn_addr);
 213 }
 214
 215 extern unsigned int lvl14_resolution;
 216
 217 /* /proc/profile writes can call this, don't __init it please. */
 218 static spinlock_t prof_setup_lock = SPIN_LOCK_UNLOCKED;
 219
 220 int setup_profiling_timer(unsigned int multiplier)
 221 {
 222         int i;
 223         unsigned long flags;
 224
 225         /* Prevent level14 ticker IRQ flooding. */
 226         if((!multiplier) || (lvl14_resolution / multiplier) < 500)
 227                 return -EINVAL;
 228
 229         spin_lock_irqsave(&prof_setup_lock, flags);
 230         for(i = 0; i < NR_CPUS; i++) {
 231                 if (cpu_possible(i))
 232                         load_profile_irq(i, lvl14_resolution / multiplier);
 233                 prof_multiplier(i) = multiplier;
 234         }
 235         spin_unlock_irqrestore(&prof_setup_lock, flags);
 236
 237         return 0;
 238 }
 239
 240 void __init smp_prepare_cpus(unsigned int maxcpus)
 241 {
 242 }
 243
 244 void __devinit smp_prepare_boot_cpu(void)
 245 {
 246         current_thread_info()->cpu = hard_smp_processor_id();
 247         cpu_set(smp_processor_id(), cpu_online_map);
 248         cpu_set(smp_processor_id(), phys_cpu_present_map);
 249 }
 250
 251 int __devinit __cpu_up(unsigned int cpu)
 252 {
 253         panic("smp doesn't work\n");
 254 }
 255
 256 void smp_bogo(struct seq_file *m)
 257 {
 258         int i;
 259
 260         for (i = 0; i < NR_CPUS; i++) {
 261                 if (cpu_online(i))
 262                         seq_printf(m,
 263                                    "Cpu%dBogo\t: %lu.%02lu\n",
 264                                    i,
 265                                    cpu_data(i).udelay_val/(500000/HZ),
 266                                    (cpu_data(i).udelay_val/(5000/HZ))%100);
 267         }
 268 }
 269
 270 void smp_info(struct seq_file *m)
 271 {
 272         int i;
 273
 274         seq_printf(m, "State:\n");
 275         for (i = 0; i < NR_CPUS; i++) {
 276                 if (cpu_online(i))
 277                         seq_printf(m, "CPU%d\t\t: online\n", i);
 278         }
 279 }