leon_kernel.c 13.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
/*
 * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
 * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/interrupt.h>
#include <linux/of_device.h>
13
14
#include <linux/clocksource.h>
#include <linux/clockchips.h>
15

16
17
18
19
20
#include <asm/oplib.h>
#include <asm/timer.h>
#include <asm/prom.h>
#include <asm/leon.h>
#include <asm/leon_amba.h>
21
22
#include <asm/traps.h>
#include <asm/cacheflush.h>
23
#include <asm/smp.h>
24
#include <asm/setup.h>
25

Sam Ravnborg's avatar
Sam Ravnborg committed
26
#include "kernel.h"
27
28
29
#include "prom.h"
#include "irq.h"

30
31
struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address */
struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address */
32
33
34
35

int leondebug_irq_disable;
int leon_debug_irqout;
static int dummy_master_l10_counter;
36
unsigned long amba_system_id;
37
static DEFINE_SPINLOCK(leon_irq_lock);
38

39
unsigned long leon3_gptimer_irq; /* interrupt controller irq number */
40
unsigned long leon3_gptimer_idx; /* Timer Index (0..6) within Timer Core */
41
int leon3_ticker_irq; /* Timer ticker IRQ */
42
unsigned int sparc_leon_eirq;
43
#define LEON_IMASK(cpu) (&leon3_irqctrl_regs->mask[cpu])
44
45
#define LEON_IACK (&leon3_irqctrl_regs->iclear)
#define LEON_DO_ACK_HW 1
46

47
48
49
50
/* Return the last ACKed IRQ by the Extended IRQ controller. It has already
 * been (automatically) ACKed when the CPU takes the trap.
 */
static inline unsigned int leon_eirq_get(int cpu)
51
52
53
54
{
	return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f;
}

55
56
/* Handle one or multiple IRQs from the extended interrupt controller */
static void leon_handle_ext_irq(unsigned int irq, struct irq_desc *desc)
57
{
58
	unsigned int eirq;
59
	struct irq_bucket *p;
60
	int cpu = sparc_leon3_cpuid();
61
62

	eirq = leon_eirq_get(cpu);
63
64
65
	p = irq_map[eirq];
	if ((eirq & 0x10) && p && p->irq) /* bit4 tells if IRQ happened */
		generic_handle_irq(p->irq);
66
67
68
}

/* The extended IRQ controller has been found, this function registers it */
69
void leon_eirq_setup(unsigned int eirq)
70
{
71
72
	unsigned long mask, oldmask;
	unsigned int veirq;
73

74
75
76
	if (eirq < 1 || eirq > 0xf) {
		printk(KERN_ERR "LEON EXT IRQ NUMBER BAD: %d\n", eirq);
		return;
77
78
	}

79
80
81
82
83
84
85
86
	veirq = leon_build_device_irq(eirq, leon_handle_ext_irq, "extirq", 0);

	/*
	 * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ
	 * controller have a mask-bit of their own, so this is safe.
	 */
	irq_link(veirq);
	mask = 1 << eirq;
87
88
	oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(boot_cpu_id));
	LEON3_BYPASS_STORE_PA(LEON_IMASK(boot_cpu_id), (oldmask | mask));
89
	sparc_leon_eirq = eirq;
90
91
}

92
unsigned long leon_get_irqmask(unsigned int irq)
93
94
95
96
97
98
99
100
101
102
103
104
105
106
{
	unsigned long mask;

	if (!irq || ((irq > 0xf) && !sparc_leon_eirq)
	    || ((irq > 0x1f) && sparc_leon_eirq)) {
		printk(KERN_ERR
		       "leon_get_irqmask: false irq number: %d\n", irq);
		mask = 0;
	} else {
		mask = LEON_HARD_INT(irq);
	}
	return mask;
}

107
108
109
110
111
#ifdef CONFIG_SMP
static int irq_choose_cpu(const struct cpumask *affinity)
{
	cpumask_t mask;

112
113
	cpumask_and(&mask, cpu_online_mask, affinity);
	if (cpumask_equal(&mask, cpu_online_mask) || cpumask_empty(&mask))
114
		return boot_cpu_id;
115
	else
116
		return cpumask_first(&mask);
117
118
}
#else
119
#define irq_choose_cpu(affinity) boot_cpu_id
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#endif

static int leon_set_affinity(struct irq_data *data, const struct cpumask *dest,
			     bool force)
{
	unsigned long mask, oldmask, flags;
	int oldcpu, newcpu;

	mask = (unsigned long)data->chip_data;
	oldcpu = irq_choose_cpu(data->affinity);
	newcpu = irq_choose_cpu(dest);

	if (oldcpu == newcpu)
		goto out;

	/* unmask on old CPU first before enabling on the selected CPU */
	spin_lock_irqsave(&leon_irq_lock, flags);
	oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(oldcpu));
	LEON3_BYPASS_STORE_PA(LEON_IMASK(oldcpu), (oldmask & ~mask));
	oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(newcpu));
	LEON3_BYPASS_STORE_PA(LEON_IMASK(newcpu), (oldmask | mask));
	spin_unlock_irqrestore(&leon_irq_lock, flags);
out:
	return IRQ_SET_MASK_OK;
}

Sam Ravnborg's avatar
Sam Ravnborg committed
146
static void leon_unmask_irq(struct irq_data *data)
147
{
148
	unsigned long mask, oldmask, flags;
149
	int cpu;
Sam Ravnborg's avatar
Sam Ravnborg committed
150
151

	mask = (unsigned long)data->chip_data;
152
	cpu = irq_choose_cpu(data->affinity);
153
	spin_lock_irqsave(&leon_irq_lock, flags);
154
155
	oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
	LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask | mask));
156
	spin_unlock_irqrestore(&leon_irq_lock, flags);
157
158
}

Sam Ravnborg's avatar
Sam Ravnborg committed
159
static void leon_mask_irq(struct irq_data *data)
160
{
161
	unsigned long mask, oldmask, flags;
162
	int cpu;
Sam Ravnborg's avatar
Sam Ravnborg committed
163
164

	mask = (unsigned long)data->chip_data;
165
	cpu = irq_choose_cpu(data->affinity);
166
	spin_lock_irqsave(&leon_irq_lock, flags);
167
168
	oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
	LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask & ~mask));
169
	spin_unlock_irqrestore(&leon_irq_lock, flags);
170
171
}

Sam Ravnborg's avatar
Sam Ravnborg committed
172
173
174
175
176
177
178
179
180
181
182
183
184
static unsigned int leon_startup_irq(struct irq_data *data)
{
	irq_link(data->irq);
	leon_unmask_irq(data);
	return 0;
}

static void leon_shutdown_irq(struct irq_data *data)
{
	leon_mask_irq(data);
	irq_unlink(data->irq);
}

185
186
187
188
189
190
191
192
193
/* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */
static void leon_eoi_irq(struct irq_data *data)
{
	unsigned long mask = (unsigned long)data->chip_data;

	if (mask & LEON_DO_ACK_HW)
		LEON3_BYPASS_STORE_PA(LEON_IACK, mask & ~LEON_DO_ACK_HW);
}

Sam Ravnborg's avatar
Sam Ravnborg committed
194
static struct irq_chip leon_irq = {
195
196
197
198
199
200
201
	.name			= "leon",
	.irq_startup		= leon_startup_irq,
	.irq_shutdown		= leon_shutdown_irq,
	.irq_mask		= leon_mask_irq,
	.irq_unmask		= leon_unmask_irq,
	.irq_eoi		= leon_eoi_irq,
	.irq_set_affinity	= leon_set_affinity,
Sam Ravnborg's avatar
Sam Ravnborg committed
202
203
};

204
205
206
207
208
209
210
211
212
/*
 * Build a LEON IRQ for the edge triggered LEON IRQ controller:
 *  Edge (normal) IRQ           - handle_simple_irq, ack=DONT-CARE, never ack
 *  Level IRQ (PCI|Level-GPIO)  - handle_fasteoi_irq, ack=1, ack after ISR
 *  Per-CPU Edge                - handle_percpu_irq, ack=0
 */
unsigned int leon_build_device_irq(unsigned int real_irq,
				    irq_flow_handler_t flow_handler,
				    const char *name, int do_ack)
Sam Ravnborg's avatar
Sam Ravnborg committed
213
214
215
{
	unsigned int irq;
	unsigned long mask;
216
	struct irq_desc *desc;
Sam Ravnborg's avatar
Sam Ravnborg committed
217
218

	irq = 0;
219
	mask = leon_get_irqmask(real_irq);
Sam Ravnborg's avatar
Sam Ravnborg committed
220
221
222
223
224
225
226
	if (mask == 0)
		goto out;

	irq = irq_alloc(real_irq, real_irq);
	if (irq == 0)
		goto out;

227
228
229
	if (do_ack)
		mask |= LEON_DO_ACK_HW;

230
231
232
233
234
235
	desc = irq_to_desc(irq);
	if (!desc || !desc->handle_irq || desc->handle_irq == handle_bad_irq) {
		irq_set_chip_and_handler_name(irq, &leon_irq,
					      flow_handler, name);
		irq_set_chip_data(irq, (void *)mask);
	}
Sam Ravnborg's avatar
Sam Ravnborg committed
236
237
238
239
240

out:
	return irq;
}

241
242
243
244
245
246
static unsigned int _leon_build_device_irq(struct platform_device *op,
					   unsigned int real_irq)
{
	return leon_build_device_irq(real_irq, handle_simple_irq, "edge", 0);
}

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
void leon_update_virq_handling(unsigned int virq,
			      irq_flow_handler_t flow_handler,
			      const char *name, int do_ack)
{
	unsigned long mask = (unsigned long)irq_get_chip_data(virq);

	mask &= ~LEON_DO_ACK_HW;
	if (do_ack)
		mask |= LEON_DO_ACK_HW;

	irq_set_chip_and_handler_name(virq, &leon_irq,
				      flow_handler, name);
	irq_set_chip_data(virq, (void *)mask);
}

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
static u32 leon_cycles_offset(void)
{
	u32 rld, val, off;
	rld = LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld);
	val = LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val);
	off = rld - val;
	return rld - val;
}

#ifdef CONFIG_SMP

/* smp clockevent irq */
irqreturn_t leon_percpu_timer_ce_interrupt(int irq, void *unused)
{
	struct clock_event_device *ce;
	int cpu = smp_processor_id();

	leon_clear_profile_irq(cpu);

	ce = &per_cpu(sparc32_clockevent, cpu);

	irq_enter();
	if (ce->event_handler)
		ce->event_handler(ce);
	irq_exit();

	return IRQ_HANDLED;
}

#endif /* CONFIG_SMP */

void __init leon_init_timers(void)
294
{
295
	int irq, eirq;
296
	struct device_node *rootnp, *np, *nnp;
297
298
	struct property *pp;
	int len;
299
	int icsel;
300
	int ampopts;
Sam Ravnborg's avatar
Sam Ravnborg committed
301
	int err;
302

303
304
305
306
307
308
309
310
	sparc_config.get_cycles_offset = leon_cycles_offset;
	sparc_config.cs_period = 1000000 / HZ;
	sparc_config.features |= FEAT_L10_CLOCKSOURCE;

#ifndef CONFIG_SMP
	sparc_config.features |= FEAT_L10_CLOCKEVENT;
#endif

311
312
313
314
315
	leondebug_irq_disable = 0;
	leon_debug_irqout = 0;
	master_l10_counter = (unsigned int *)&dummy_master_l10_counter;
	dummy_master_l10_counter = 0;

316
317
318
	rootnp = of_find_node_by_path("/ambapp0");
	if (!rootnp)
		goto bad;
319
320
321
322
323
324
325

	/* Find System ID: GRLIB build ID and optional CHIP ID */
	pp = of_find_property(rootnp, "systemid", &len);
	if (pp)
		amba_system_id = *(unsigned long *)pp->value;

	/* Find IRQMP IRQ Controller Registers base adr otherwise bail out */
326
	np = of_find_node_by_name(rootnp, "GAISLER_IRQMP");
327
328
329
330
331
	if (!np) {
		np = of_find_node_by_name(rootnp, "01_00d");
		if (!np)
			goto bad;
	}
332
333
334
335
336
337
	pp = of_find_property(np, "reg", &len);
	if (!pp)
		goto bad;
	leon3_irqctrl_regs = *(struct leon3_irqctrl_regs_map **)pp->value;

	/* Find GPTIMER Timer Registers base address otherwise bail out. */
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
	nnp = rootnp;
	do {
		np = of_find_node_by_name(nnp, "GAISLER_GPTIMER");
		if (!np) {
			np = of_find_node_by_name(nnp, "01_011");
			if (!np)
				goto bad;
		}

		ampopts = 0;
		pp = of_find_property(np, "ampopts", &len);
		if (pp) {
			ampopts = *(int *)pp->value;
			if (ampopts == 0) {
				/* Skip this instance, resource already
				 * allocated by other OS */
				nnp = np;
				continue;
			}
		}

		/* Select Timer-Instance on Timer Core. Default is zero */
		leon3_gptimer_idx = ampopts & 0x7;

		pp = of_find_property(np, "reg", &len);
		if (pp)
			leon3_gptimer_regs = *(struct leon3_gptimer_regs_map **)
						pp->value;
		pp = of_find_property(np, "interrupts", &len);
		if (pp)
			leon3_gptimer_irq = *(unsigned int *)pp->value;
	} while (0);
370

371
372
373
374
375
376
377
	if (!(leon3_gptimer_regs && leon3_irqctrl_regs && leon3_gptimer_irq))
		goto bad;

	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val, 0);
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld,
				(((1000000 / HZ) - 1)));
	LEON3_BYPASS_STORE_PA(
378
			&leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 0);
379

380
#ifdef CONFIG_SMP
381
	leon3_ticker_irq = leon3_gptimer_irq + 1 + leon3_gptimer_idx;
382

383
384
385
386
	if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
	      (1<<LEON3_GPTIMER_SEPIRQ))) {
		printk(KERN_ERR "timer not configured with separate irqs\n");
		BUG();
387
388
	}

389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].val,
				0);
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].rld,
				(((1000000/HZ) - 1)));
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
				0);
#endif

	/*
	 * The IRQ controller may (if implemented) consist of multiple
	 * IRQ controllers, each mapped on a 4Kb boundary.
	 * Each CPU may be routed to different IRQCTRLs, however
	 * we assume that all CPUs (in SMP system) is routed to the
	 * same IRQ Controller, and for non-SMP only one IRQCTRL is
	 * accessed anyway.
	 * In AMP systems, Linux must run on CPU0 for the time being.
	 */
406
407
	icsel = LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->icsel[boot_cpu_id/8]);
	icsel = (icsel >> ((7 - (boot_cpu_id&0x7)) * 4)) & 0xf;
408
409
	leon3_irqctrl_regs += icsel;

410
411
412
	/* Mask all IRQs on boot-cpu IRQ controller */
	LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->mask[boot_cpu_id], 0);

413
414
415
416
417
418
	/* Probe extended IRQ controller */
	eirq = (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->mpstatus)
		>> 16) & 0xf;
	if (eirq != 0)
		leon_eirq_setup(eirq);

419
	irq = _leon_build_device_irq(NULL, leon3_gptimer_irq+leon3_gptimer_idx);
420
	err = request_irq(irq, timer_interrupt, IRQF_TIMER, "timer", NULL);
Sam Ravnborg's avatar
Sam Ravnborg committed
421
	if (err) {
422
		printk(KERN_ERR "unable to attach timer IRQ%d\n", irq);
423
424
425
		prom_halt();
	}

426
427
428
429
430
431
432
433
434
435
436
#ifdef CONFIG_SMP
	{
		unsigned long flags;

		/*
		 * In SMP, sun4m adds a IPI handler to IRQ trap handler that
		 * LEON never must take, sun4d and LEON overwrites the branch
		 * with a NOP.
		 */
		local_irq_save(flags);
		patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
437
		local_ops->cache_all();
438
439
440
441
		local_irq_restore(flags);
	}
#endif

442
443
444
445
446
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl,
			      LEON3_GPTIMER_EN |
			      LEON3_GPTIMER_RL |
			      LEON3_GPTIMER_LD |
			      LEON3_GPTIMER_IRQEN);
447
448

#ifdef CONFIG_SMP
449
450
451
	/* Install per-cpu IRQ handler for broadcasted ticker */
	irq = leon_build_device_irq(leon3_ticker_irq, handle_percpu_irq,
				    "per-cpu", 0);
452
	err = request_irq(irq, leon_percpu_timer_ce_interrupt,
453
454
455
456
457
458
			  IRQF_PERCPU | IRQF_TIMER, "ticker",
			  NULL);
	if (err) {
		printk(KERN_ERR "unable to attach ticker IRQ%d\n", irq);
		prom_halt();
	}
459

460
461
462
463
464
	LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
			      LEON3_GPTIMER_EN |
			      LEON3_GPTIMER_RL |
			      LEON3_GPTIMER_LD |
			      LEON3_GPTIMER_IRQEN);
465
#endif
466
467
468
469
470
	return;
bad:
	printk(KERN_ERR "No Timer/irqctrl found\n");
	BUG();
	return;
471
472
}

473
static void leon_clear_clock_irq(void)
474
475
476
{
}

477
static void leon_load_profile_irq(int cpu, unsigned int limit)
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
{
}

void __init leon_trans_init(struct device_node *dp)
{
	if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) {
		struct property *p;
		p = of_find_property(dp, "mid", (void *)0);
		if (p) {
			int mid;
			dp->name = prom_early_alloc(5 + 1);
			memcpy(&mid, p->value, p->length);
			sprintf((char *)dp->name, "cpu%.2d", mid);
		}
	}
}

495
496
497
498
499
500
501
502
#ifdef CONFIG_SMP
void leon_clear_profile_irq(int cpu)
{
}

void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu)
{
	unsigned long mask, flags, *addr;
503
	mask = leon_get_irqmask(irq_nr);
504
	spin_lock_irqsave(&leon_irq_lock, flags);
505
506
	addr = (unsigned long *)LEON_IMASK(cpu);
	LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | mask));
507
	spin_unlock_irqrestore(&leon_irq_lock, flags);
508
509
510
511
}

#endif

512
513
void __init leon_init_IRQ(void)
{
514
515
	sparc_config.init_timers      = leon_init_timers;
	sparc_config.build_device_irq = _leon_build_device_irq;
516
517
518
	sparc_config.clock_rate       = 1000000;
	sparc_config.clear_clock_irq  = leon_clear_clock_irq;
	sparc_config.load_profile_irq = leon_load_profile_irq;
519
}