2 * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
3 * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB
6 #include <linux/kernel.h>
7 #include <linux/errno.h>
8 #include <linux/mutex.h>
10 #include <linux/of_platform.h>
11 #include <linux/interrupt.h>
12 #include <linux/of_device.h>
13 #include <linux/clocksource.h>
14 #include <linux/clockchips.h>
16 #include <asm/oplib.h>
17 #include <asm/timer.h>
20 #include <asm/leon_amba.h>
21 #include <asm/traps.h>
22 #include <asm/cacheflush.h>
24 #include <asm/setup.h>
30 struct leon3_irqctrl_regs_map
*leon3_irqctrl_regs
; /* interrupt controller base address */
31 struct leon3_gptimer_regs_map
*leon3_gptimer_regs
; /* timer controller base address */
33 int leondebug_irq_disable
;
34 int leon_debug_irqout
;
35 static int dummy_master_l10_counter
;
36 unsigned long amba_system_id
;
37 static DEFINE_SPINLOCK(leon_irq_lock
);
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 #define LEON_IACK (&leon3_irqctrl_regs->iclear)
45 #define LEON_DO_ACK_HW 1
47 /* Return the last ACKed IRQ by the Extended IRQ controller. It has already
48 * been (automatically) ACKed when the CPU takes the trap.
50 static inline unsigned int leon_eirq_get(int cpu
)
52 return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs
->intid
[cpu
]) & 0x1f;
55 /* Handle one or multiple IRQs from the extended interrupt controller */
56 static void leon_handle_ext_irq(unsigned int irq
, struct irq_desc
*desc
)
59 int cpu
= sparc_leon3_cpuid();
61 eirq
= leon_eirq_get(cpu
);
62 if ((eirq
& 0x10) && irq_map
[eirq
]->irq
) /* bit4 tells if IRQ happened */
63 generic_handle_irq(irq_map
[eirq
]->irq
);
66 /* The extended IRQ controller has been found, this function registers it */
67 void leon_eirq_setup(unsigned int eirq
)
69 unsigned long mask
, oldmask
;
72 if (eirq
< 1 || eirq
> 0xf) {
73 printk(KERN_ERR
"LEON EXT IRQ NUMBER BAD: %d\n", eirq
);
77 veirq
= leon_build_device_irq(eirq
, leon_handle_ext_irq
, "extirq", 0);
80 * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ
81 * controller have a mask-bit of their own, so this is safe.
85 oldmask
= LEON3_BYPASS_LOAD_PA(LEON_IMASK(boot_cpu_id
));
86 LEON3_BYPASS_STORE_PA(LEON_IMASK(boot_cpu_id
), (oldmask
| mask
));
87 sparc_leon_eirq
= eirq
;
90 unsigned long leon_get_irqmask(unsigned int irq
)
94 if (!irq
|| ((irq
> 0xf) && !sparc_leon_eirq
)
95 || ((irq
> 0x1f) && sparc_leon_eirq
)) {
97 "leon_get_irqmask: false irq number: %d\n", irq
);
100 mask
= LEON_HARD_INT(irq
);
106 static int irq_choose_cpu(const struct cpumask
*affinity
)
110 cpumask_and(&mask
, cpu_online_mask
, affinity
);
111 if (cpumask_equal(&mask
, cpu_online_mask
) || cpumask_empty(&mask
))
114 return cpumask_first(&mask
);
117 #define irq_choose_cpu(affinity) boot_cpu_id
120 static int leon_set_affinity(struct irq_data
*data
, const struct cpumask
*dest
,
123 unsigned long mask
, oldmask
, flags
;
126 mask
= (unsigned long)data
->chip_data
;
127 oldcpu
= irq_choose_cpu(data
->affinity
);
128 newcpu
= irq_choose_cpu(dest
);
130 if (oldcpu
== newcpu
)
133 /* unmask on old CPU first before enabling on the selected CPU */
134 spin_lock_irqsave(&leon_irq_lock
, flags
);
135 oldmask
= LEON3_BYPASS_LOAD_PA(LEON_IMASK(oldcpu
));
136 LEON3_BYPASS_STORE_PA(LEON_IMASK(oldcpu
), (oldmask
& ~mask
));
137 oldmask
= LEON3_BYPASS_LOAD_PA(LEON_IMASK(newcpu
));
138 LEON3_BYPASS_STORE_PA(LEON_IMASK(newcpu
), (oldmask
| mask
));
139 spin_unlock_irqrestore(&leon_irq_lock
, flags
);
141 return IRQ_SET_MASK_OK
;
144 static void leon_unmask_irq(struct irq_data
*data
)
146 unsigned long mask
, oldmask
, flags
;
149 mask
= (unsigned long)data
->chip_data
;
150 cpu
= irq_choose_cpu(data
->affinity
);
151 spin_lock_irqsave(&leon_irq_lock
, flags
);
152 oldmask
= LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu
));
153 LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu
), (oldmask
| mask
));
154 spin_unlock_irqrestore(&leon_irq_lock
, flags
);
157 static void leon_mask_irq(struct irq_data
*data
)
159 unsigned long mask
, oldmask
, flags
;
162 mask
= (unsigned long)data
->chip_data
;
163 cpu
= irq_choose_cpu(data
->affinity
);
164 spin_lock_irqsave(&leon_irq_lock
, flags
);
165 oldmask
= LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu
));
166 LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu
), (oldmask
& ~mask
));
167 spin_unlock_irqrestore(&leon_irq_lock
, flags
);
170 static unsigned int leon_startup_irq(struct irq_data
*data
)
173 leon_unmask_irq(data
);
177 static void leon_shutdown_irq(struct irq_data
*data
)
180 irq_unlink(data
->irq
);
183 /* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */
184 static void leon_eoi_irq(struct irq_data
*data
)
186 unsigned long mask
= (unsigned long)data
->chip_data
;
188 if (mask
& LEON_DO_ACK_HW
)
189 LEON3_BYPASS_STORE_PA(LEON_IACK
, mask
& ~LEON_DO_ACK_HW
);
192 static struct irq_chip leon_irq
= {
194 .irq_startup
= leon_startup_irq
,
195 .irq_shutdown
= leon_shutdown_irq
,
196 .irq_mask
= leon_mask_irq
,
197 .irq_unmask
= leon_unmask_irq
,
198 .irq_eoi
= leon_eoi_irq
,
199 .irq_set_affinity
= leon_set_affinity
,
203 * Build a LEON IRQ for the edge triggered LEON IRQ controller:
204 * Edge (normal) IRQ - handle_simple_irq, ack=DONT-CARE, never ack
205 * Level IRQ (PCI|Level-GPIO) - handle_fasteoi_irq, ack=1, ack after ISR
206 * Per-CPU Edge - handle_percpu_irq, ack=0
208 unsigned int leon_build_device_irq(unsigned int real_irq
,
209 irq_flow_handler_t flow_handler
,
210 const char *name
, int do_ack
)
216 mask
= leon_get_irqmask(real_irq
);
220 irq
= irq_alloc(real_irq
, real_irq
);
225 mask
|= LEON_DO_ACK_HW
;
227 irq_set_chip_and_handler_name(irq
, &leon_irq
,
229 irq_set_chip_data(irq
, (void *)mask
);
235 static unsigned int _leon_build_device_irq(struct platform_device
*op
,
236 unsigned int real_irq
)
238 return leon_build_device_irq(real_irq
, handle_simple_irq
, "edge", 0);
241 void leon_update_virq_handling(unsigned int virq
,
242 irq_flow_handler_t flow_handler
,
243 const char *name
, int do_ack
)
245 unsigned long mask
= (unsigned long)irq_get_chip_data(virq
);
247 mask
&= ~LEON_DO_ACK_HW
;
249 mask
|= LEON_DO_ACK_HW
;
251 irq_set_chip_and_handler_name(virq
, &leon_irq
,
253 irq_set_chip_data(virq
, (void *)mask
);
256 static u32
leon_cycles_offset(void)
259 rld
= LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
].rld
);
260 val
= LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
].val
);
267 /* smp clockevent irq */
268 irqreturn_t
leon_percpu_timer_ce_interrupt(int irq
, void *unused
)
270 struct clock_event_device
*ce
;
271 int cpu
= smp_processor_id();
273 leon_clear_profile_irq(cpu
);
275 ce
= &per_cpu(sparc32_clockevent
, cpu
);
278 if (ce
->event_handler
)
279 ce
->event_handler(ce
);
285 #endif /* CONFIG_SMP */
287 void __init
leon_init_timers(void)
290 struct device_node
*rootnp
, *np
, *nnp
;
297 sparc_config
.get_cycles_offset
= leon_cycles_offset
;
298 sparc_config
.cs_period
= 1000000 / HZ
;
299 sparc_config
.features
|= FEAT_L10_CLOCKSOURCE
;
302 sparc_config
.features
|= FEAT_L10_CLOCKEVENT
;
305 leondebug_irq_disable
= 0;
306 leon_debug_irqout
= 0;
307 master_l10_counter
= (unsigned int *)&dummy_master_l10_counter
;
308 dummy_master_l10_counter
= 0;
310 rootnp
= of_find_node_by_path("/ambapp0");
314 /* Find System ID: GRLIB build ID and optional CHIP ID */
315 pp
= of_find_property(rootnp
, "systemid", &len
);
317 amba_system_id
= *(unsigned long *)pp
->value
;
319 /* Find IRQMP IRQ Controller Registers base adr otherwise bail out */
320 np
= of_find_node_by_name(rootnp
, "GAISLER_IRQMP");
322 np
= of_find_node_by_name(rootnp
, "01_00d");
326 pp
= of_find_property(np
, "reg", &len
);
329 leon3_irqctrl_regs
= *(struct leon3_irqctrl_regs_map
**)pp
->value
;
331 /* Find GPTIMER Timer Registers base address otherwise bail out. */
334 np
= of_find_node_by_name(nnp
, "GAISLER_GPTIMER");
336 np
= of_find_node_by_name(nnp
, "01_011");
342 pp
= of_find_property(np
, "ampopts", &len
);
344 ampopts
= *(int *)pp
->value
;
346 /* Skip this instance, resource already
347 * allocated by other OS */
353 /* Select Timer-Instance on Timer Core. Default is zero */
354 leon3_gptimer_idx
= ampopts
& 0x7;
356 pp
= of_find_property(np
, "reg", &len
);
358 leon3_gptimer_regs
= *(struct leon3_gptimer_regs_map
**)
360 pp
= of_find_property(np
, "interrupts", &len
);
362 leon3_gptimer_irq
= *(unsigned int *)pp
->value
;
365 if (!(leon3_gptimer_regs
&& leon3_irqctrl_regs
&& leon3_gptimer_irq
))
368 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
].val
, 0);
369 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
].rld
,
370 (((1000000 / HZ
) - 1)));
371 LEON3_BYPASS_STORE_PA(
372 &leon3_gptimer_regs
->e
[leon3_gptimer_idx
].ctrl
, 0);
375 leon3_ticker_irq
= leon3_gptimer_irq
+ 1 + leon3_gptimer_idx
;
377 if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs
->config
) &
378 (1<<LEON3_GPTIMER_SEPIRQ
))) {
379 printk(KERN_ERR
"timer not configured with separate irqs\n");
383 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
+1].val
,
385 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
+1].rld
,
386 (((1000000/HZ
) - 1)));
387 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
+1].ctrl
,
392 * The IRQ controller may (if implemented) consist of multiple
393 * IRQ controllers, each mapped on a 4Kb boundary.
394 * Each CPU may be routed to different IRQCTRLs, however
395 * we assume that all CPUs (in SMP system) is routed to the
396 * same IRQ Controller, and for non-SMP only one IRQCTRL is
398 * In AMP systems, Linux must run on CPU0 for the time being.
400 icsel
= LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs
->icsel
[boot_cpu_id
/8]);
401 icsel
= (icsel
>> ((7 - (boot_cpu_id
&0x7)) * 4)) & 0xf;
402 leon3_irqctrl_regs
+= icsel
;
404 /* Mask all IRQs on boot-cpu IRQ controller */
405 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs
->mask
[boot_cpu_id
], 0);
407 /* Probe extended IRQ controller */
408 eirq
= (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs
->mpstatus
)
411 leon_eirq_setup(eirq
);
413 irq
= _leon_build_device_irq(NULL
, leon3_gptimer_irq
+leon3_gptimer_idx
);
414 err
= request_irq(irq
, timer_interrupt
, IRQF_TIMER
, "timer", NULL
);
416 printk(KERN_ERR
"unable to attach timer IRQ%d\n", irq
);
425 * In SMP, sun4m adds a IPI handler to IRQ trap handler that
426 * LEON never must take, sun4d and LEON overwrites the branch
429 local_irq_save(flags
);
430 patchme_maybe_smp_msg
[0] = 0x01000000; /* NOP out the branch */
431 local_ops
->cache_all();
432 local_irq_restore(flags
);
436 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
].ctrl
,
440 LEON3_GPTIMER_IRQEN
);
443 /* Install per-cpu IRQ handler for broadcasted ticker */
444 irq
= leon_build_device_irq(leon3_ticker_irq
, handle_percpu_irq
,
446 err
= request_irq(irq
, leon_percpu_timer_ce_interrupt
,
447 IRQF_PERCPU
| IRQF_TIMER
, "ticker",
450 printk(KERN_ERR
"unable to attach ticker IRQ%d\n", irq
);
454 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs
->e
[leon3_gptimer_idx
+1].ctrl
,
458 LEON3_GPTIMER_IRQEN
);
462 printk(KERN_ERR
"No Timer/irqctrl found\n");
467 static void leon_clear_clock_irq(void)
471 static void leon_load_profile_irq(int cpu
, unsigned int limit
)
475 void __init
leon_trans_init(struct device_node
*dp
)
477 if (strcmp(dp
->type
, "cpu") == 0 && strcmp(dp
->name
, "<NULL>") == 0) {
479 p
= of_find_property(dp
, "mid", (void *)0);
482 dp
->name
= prom_early_alloc(5 + 1);
483 memcpy(&mid
, p
->value
, p
->length
);
484 sprintf((char *)dp
->name
, "cpu%.2d", mid
);
489 void __initdata (*prom_amba_init
)(struct device_node
*dp
, struct device_node
***nextp
) = 0;
491 void __init
leon_node_init(struct device_node
*dp
, struct device_node
***nextp
)
493 if (prom_amba_init
&&
494 strcmp(dp
->type
, "ambapp") == 0 &&
495 strcmp(dp
->name
, "ambapp0") == 0) {
496 prom_amba_init(dp
, nextp
);
501 void leon_clear_profile_irq(int cpu
)
505 void leon_enable_irq_cpu(unsigned int irq_nr
, unsigned int cpu
)
507 unsigned long mask
, flags
, *addr
;
508 mask
= leon_get_irqmask(irq_nr
);
509 spin_lock_irqsave(&leon_irq_lock
, flags
);
510 addr
= (unsigned long *)LEON_IMASK(cpu
);
511 LEON3_BYPASS_STORE_PA(addr
, (LEON3_BYPASS_LOAD_PA(addr
) | mask
));
512 spin_unlock_irqrestore(&leon_irq_lock
, flags
);
517 void __init
leon_init_IRQ(void)
519 sparc_config
.init_timers
= leon_init_timers
;
520 sparc_config
.build_device_irq
= _leon_build_device_irq
;
521 sparc_config
.clock_rate
= 1000000;
522 sparc_config
.clear_clock_irq
= leon_clear_clock_irq
;
523 sparc_config
.load_profile_irq
= leon_load_profile_irq
;
526 void __init
leon_init(void)
528 of_pdt_build_more
= &leon_node_init
;