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
36int smp_num_cpus = 1;
37volatile unsigned long cpu_callin_map[NR_CPUS] __initdata = {0,};
38unsigned char boot_cpu_id = 0;
39unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
40int smp_activated = 0;
41volatile int __cpu_number_map[NR_CPUS];
42volatile int __cpu_logical_map[NR_CPUS];
43
44cpumask_t cpu_online_map = CPU_MASK_NONE;
45cpumask_t phys_cpu_present_map = CPU_MASK_NONE;
46cpumask_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 */
57unsigned char bitops_spinlock = 0;
58
59void __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
75void __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
122void cpu_panic(void)
123{
124	printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
125	panic("SMP bolixed\n");
126}
127
128struct linux_prom_registers smp_penguin_ctable __initdata = { 0 };
129
130void smp_send_reschedule(int cpu)
131{
132	/* See sparc64 */
133}
134
135void smp_send_stop(void)
136{
137}
138
139void smp_flush_cache_all(void)
140{
141	xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
142	local_flush_cache_all();
143}
144
145void smp_flush_tlb_all(void)
146{
147	xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
148	local_flush_tlb_all();
149}
150
151void 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
162void 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
176void 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
190void 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
204void 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
217void 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
230void smp_reschedule_irq(void)
231{
232	set_need_resched();
233}
234
235void smp_flush_page_to_ram(unsigned long page)
236{
237	xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
238	local_flush_page_to_ram(page);
239}
240
241void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
242{
243	cpumask_t cpu_mask = mm->cpu_vm_mask;
244	cpu_clear(smp_processor_id(), cpu_mask);
245	if (!cpus_empty(cpu_mask))
246		xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
247	local_flush_sig_insns(mm, insn_addr);
248}
249
250extern unsigned int lvl14_resolution;
251
252/* /proc/profile writes can call this, don't __init it please. */
253static DEFINE_SPINLOCK(prof_setup_lock);
254
255int setup_profiling_timer(unsigned int multiplier)
256{
257	int i;
258	unsigned long flags;
259
260	/* Prevent level14 ticker IRQ flooding. */
261	if((!multiplier) || (lvl14_resolution / multiplier) < 500)
262		return -EINVAL;
263
264	spin_lock_irqsave(&prof_setup_lock, flags);
265	for_each_possible_cpu(i) {
266		load_profile_irq(i, lvl14_resolution / multiplier);
267		prof_multiplier(i) = multiplier;
268	}
269	spin_unlock_irqrestore(&prof_setup_lock, flags);
270
271	return 0;
272}
273
274void __init smp_prepare_cpus(unsigned int max_cpus)
275{
276	extern void __init smp4m_boot_cpus(void);
277	extern void __init smp4d_boot_cpus(void);
278	int i, cpuid, extra;
279
280	printk("Entering SMP Mode...\n");
281
282	extra = 0;
283	for (i = 0; !cpu_find_by_instance(i, NULL, &cpuid); i++) {
284		if (cpuid >= NR_CPUS)
285			extra++;
286	}
287	/* i = number of cpus */
288	if (extra && max_cpus > i - extra)
289		printk("Warning: NR_CPUS is too low to start all cpus\n");
290
291	smp_store_cpu_info(boot_cpu_id);
292
293	switch(sparc_cpu_model) {
294	case sun4:
295		printk("SUN4\n");
296		BUG();
297		break;
298	case sun4c:
299		printk("SUN4C\n");
300		BUG();
301		break;
302	case sun4m:
303		smp4m_boot_cpus();
304		break;
305	case sun4d:
306		smp4d_boot_cpus();
307		break;
308	case sun4e:
309		printk("SUN4E\n");
310		BUG();
311		break;
312	case sun4u:
313		printk("SUN4U\n");
314		BUG();
315		break;
316	default:
317		printk("UNKNOWN!\n");
318		BUG();
319		break;
320	};
321}
322
323/* Set this up early so that things like the scheduler can init
324 * properly.  We use the same cpu mask for both the present and
325 * possible cpu map.
326 */
327void __init smp_setup_cpu_possible_map(void)
328{
329	int instance, mid;
330
331	instance = 0;
332	while (!cpu_find_by_instance(instance, NULL, &mid)) {
333		if (mid < NR_CPUS) {
334			cpu_set(mid, phys_cpu_present_map);
335			cpu_set(mid, cpu_present_map);
336		}
337		instance++;
338	}
339}
340
341void __init smp_prepare_boot_cpu(void)
342{
343	int cpuid = hard_smp_processor_id();
344
345	if (cpuid >= NR_CPUS) {
346		prom_printf("Serious problem, boot cpu id >= NR_CPUS\n");
347		prom_halt();
348	}
349	if (cpuid != 0)
350		printk("boot cpu id != 0, this could work but is untested\n");
351
352	current_thread_info()->cpu = cpuid;
353	cpu_set(cpuid, cpu_online_map);
354	cpu_set(cpuid, phys_cpu_present_map);
355}
356
357int __cpuinit __cpu_up(unsigned int cpu)
358{
359	extern int __cpuinit smp4m_boot_one_cpu(int);
360	extern int __cpuinit smp4d_boot_one_cpu(int);
361	int ret=0;
362
363	switch(sparc_cpu_model) {
364	case sun4:
365		printk("SUN4\n");
366		BUG();
367		break;
368	case sun4c:
369		printk("SUN4C\n");
370		BUG();
371		break;
372	case sun4m:
373		ret = smp4m_boot_one_cpu(cpu);
374		break;
375	case sun4d:
376		ret = smp4d_boot_one_cpu(cpu);
377		break;
378	case sun4e:
379		printk("SUN4E\n");
380		BUG();
381		break;
382	case sun4u:
383		printk("SUN4U\n");
384		BUG();
385		break;
386	default:
387		printk("UNKNOWN!\n");
388		BUG();
389		break;
390	};
391
392	if (!ret) {
393		cpu_set(cpu, smp_commenced_mask);
394		while (!cpu_online(cpu))
395			mb();
396	}
397	return ret;
398}
399
400void smp_bogo(struct seq_file *m)
401{
402	int i;
403
404	for_each_online_cpu(i) {
405		seq_printf(m,
406			   "Cpu%dBogo\t: %lu.%02lu\n",
407			   i,
408			   cpu_data(i).udelay_val/(500000/HZ),
409			   (cpu_data(i).udelay_val/(5000/HZ))%100);
410	}
411}
412
413void smp_info(struct seq_file *m)
414{
415	int i;
416
417	seq_printf(m, "State:\n");
418	for_each_online_cpu(i)
419		seq_printf(m, "CPU%d\t\t: online\n", i);
420}
421