blob: 210f4a0a84573947b7d22ef0a37c690bab17fe14 [file] [log] [blame]
Konrad Eisele5213a782009-08-17 00:13:29 +00001/*
2 * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
3 * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB
4 */
5
6#include <linux/kernel.h>
7#include <linux/module.h>
8#include <linux/errno.h>
9#include <linux/mutex.h>
Konrad Eisele5213a782009-08-17 00:13:29 +000010#include <linux/of.h>
11#include <linux/of_platform.h>
12#include <linux/interrupt.h>
13#include <linux/of_device.h>
Konrad Eisele84017072009-08-31 22:08:13 +000014
Konrad Eisele5213a782009-08-17 00:13:29 +000015#include <asm/oplib.h>
16#include <asm/timer.h>
17#include <asm/prom.h>
18#include <asm/leon.h>
19#include <asm/leon_amba.h>
Konrad Eisele84017072009-08-31 22:08:13 +000020#include <asm/traps.h>
21#include <asm/cacheflush.h>
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000022#include <asm/smp.h>
Konrad Eisele5213a782009-08-17 00:13:29 +000023
24#include "prom.h"
25#include "irq.h"
26
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +000027struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address */
28struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address */
Konrad Eisele5213a782009-08-17 00:13:29 +000029struct amba_apb_device leon_percpu_timer_dev[16];
30
31int leondebug_irq_disable;
32int leon_debug_irqout;
33static int dummy_master_l10_counter;
Daniel Hellstrom7279b822011-01-27 01:26:58 +000034unsigned long amba_system_id;
Daniel Hellstromd61a38b2011-04-19 23:41:21 +000035static DEFINE_SPINLOCK(leon_irq_lock);
Konrad Eisele5213a782009-08-17 00:13:29 +000036
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +000037unsigned long leon3_gptimer_irq; /* interrupt controller irq number */
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +000038unsigned long leon3_gptimer_idx; /* Timer Index (0..6) within Timer Core */
Konrad Eisele5213a782009-08-17 00:13:29 +000039unsigned int sparc_leon_eirq;
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000040#define LEON_IMASK (&leon3_irqctrl_regs->mask[0])
41#define LEON_IACK (&leon3_irqctrl_regs->iclear)
42#define LEON_DO_ACK_HW 1
Konrad Eisele5213a782009-08-17 00:13:29 +000043
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000044/* Return the last ACKed IRQ by the Extended IRQ controller. It has already
45 * been (automatically) ACKed when the CPU takes the trap.
46 */
47static inline unsigned int leon_eirq_get(int cpu)
Konrad Eisele5213a782009-08-17 00:13:29 +000048{
49 return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f;
50}
51
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000052/* Handle one or multiple IRQs from the extended interrupt controller */
53static void leon_handle_ext_irq(unsigned int irq, struct irq_desc *desc)
Konrad Eisele5213a782009-08-17 00:13:29 +000054{
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000055 unsigned int eirq;
56 int cpu = hard_smp_processor_id();
57
58 eirq = leon_eirq_get(cpu);
59 if ((eirq & 0x10) && irq_map[eirq]->irq) /* bit4 tells if IRQ happened */
60 generic_handle_irq(irq_map[eirq]->irq);
Konrad Eisele5213a782009-08-17 00:13:29 +000061}
62
63/* The extended IRQ controller has been found, this function registers it */
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000064void leon_eirq_setup(unsigned int eirq)
Konrad Eisele5213a782009-08-17 00:13:29 +000065{
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000066 unsigned long mask, oldmask;
67 unsigned int veirq;
Konrad Eisele5213a782009-08-17 00:13:29 +000068
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000069 if (eirq < 1 || eirq > 0xf) {
70 printk(KERN_ERR "LEON EXT IRQ NUMBER BAD: %d\n", eirq);
71 return;
Konrad Eisele5213a782009-08-17 00:13:29 +000072 }
73
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +000074 veirq = leon_build_device_irq(eirq, leon_handle_ext_irq, "extirq", 0);
75
76 /*
77 * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ
78 * controller have a mask-bit of their own, so this is safe.
79 */
80 irq_link(veirq);
81 mask = 1 << eirq;
82 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK);
83 LEON3_BYPASS_STORE_PA(LEON_IMASK, (oldmask | mask));
84 sparc_leon_eirq = eirq;
Konrad Eisele5213a782009-08-17 00:13:29 +000085}
86
87static inline unsigned long get_irqmask(unsigned int irq)
88{
89 unsigned long mask;
90
91 if (!irq || ((irq > 0xf) && !sparc_leon_eirq)
92 || ((irq > 0x1f) && sparc_leon_eirq)) {
93 printk(KERN_ERR
94 "leon_get_irqmask: false irq number: %d\n", irq);
95 mask = 0;
96 } else {
97 mask = LEON_HARD_INT(irq);
98 }
99 return mask;
100}
101
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000102static void leon_unmask_irq(struct irq_data *data)
Konrad Eisele5213a782009-08-17 00:13:29 +0000103{
104 unsigned long mask, flags;
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000105
106 mask = (unsigned long)data->chip_data;
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000107 spin_lock_irqsave(&leon_irq_lock, flags);
Konrad Eisele5213a782009-08-17 00:13:29 +0000108 LEON3_BYPASS_STORE_PA(LEON_IMASK,
109 (LEON3_BYPASS_LOAD_PA(LEON_IMASK) | (mask)));
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000110 spin_unlock_irqrestore(&leon_irq_lock, flags);
Konrad Eisele5213a782009-08-17 00:13:29 +0000111}
112
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000113static void leon_mask_irq(struct irq_data *data)
Konrad Eisele5213a782009-08-17 00:13:29 +0000114{
115 unsigned long mask, flags;
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000116
117 mask = (unsigned long)data->chip_data;
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000118 spin_lock_irqsave(&leon_irq_lock, flags);
Konrad Eisele5213a782009-08-17 00:13:29 +0000119 LEON3_BYPASS_STORE_PA(LEON_IMASK,
120 (LEON3_BYPASS_LOAD_PA(LEON_IMASK) & ~(mask)));
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000121 spin_unlock_irqrestore(&leon_irq_lock, flags);
Konrad Eisele5213a782009-08-17 00:13:29 +0000122}
123
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000124static unsigned int leon_startup_irq(struct irq_data *data)
125{
126 irq_link(data->irq);
127 leon_unmask_irq(data);
128 return 0;
129}
130
131static void leon_shutdown_irq(struct irq_data *data)
132{
133 leon_mask_irq(data);
134 irq_unlink(data->irq);
135}
136
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000137/* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */
138static void leon_eoi_irq(struct irq_data *data)
139{
140 unsigned long mask = (unsigned long)data->chip_data;
141
142 if (mask & LEON_DO_ACK_HW)
143 LEON3_BYPASS_STORE_PA(LEON_IACK, mask & ~LEON_DO_ACK_HW);
144}
145
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000146static struct irq_chip leon_irq = {
147 .name = "leon",
148 .irq_startup = leon_startup_irq,
149 .irq_shutdown = leon_shutdown_irq,
150 .irq_mask = leon_mask_irq,
151 .irq_unmask = leon_unmask_irq,
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000152 .irq_eoi = leon_eoi_irq,
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000153};
154
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000155/*
156 * Build a LEON IRQ for the edge triggered LEON IRQ controller:
157 * Edge (normal) IRQ - handle_simple_irq, ack=DONT-CARE, never ack
158 * Level IRQ (PCI|Level-GPIO) - handle_fasteoi_irq, ack=1, ack after ISR
159 * Per-CPU Edge - handle_percpu_irq, ack=0
160 */
161unsigned int leon_build_device_irq(unsigned int real_irq,
162 irq_flow_handler_t flow_handler,
163 const char *name, int do_ack)
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000164{
165 unsigned int irq;
166 unsigned long mask;
167
168 irq = 0;
169 mask = get_irqmask(real_irq);
170 if (mask == 0)
171 goto out;
172
173 irq = irq_alloc(real_irq, real_irq);
174 if (irq == 0)
175 goto out;
176
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000177 if (do_ack)
178 mask |= LEON_DO_ACK_HW;
179
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000180 irq_set_chip_and_handler_name(irq, &leon_irq,
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000181 flow_handler, name);
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000182 irq_set_chip_data(irq, (void *)mask);
183
184out:
185 return irq;
186}
187
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000188static unsigned int _leon_build_device_irq(struct platform_device *op,
189 unsigned int real_irq)
190{
191 return leon_build_device_irq(real_irq, handle_simple_irq, "edge", 0);
192}
193
Konrad Eisele5213a782009-08-17 00:13:29 +0000194void __init leon_init_timers(irq_handler_t counter_fn)
195{
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000196 int irq, eirq;
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000197 struct device_node *rootnp, *np, *nnp;
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000198 struct property *pp;
199 int len;
Daniel Hellstrome2305e32011-01-04 01:41:30 +0000200 int cpu, icsel;
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000201 int ampopts;
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000202 int err;
Konrad Eisele5213a782009-08-17 00:13:29 +0000203
204 leondebug_irq_disable = 0;
205 leon_debug_irqout = 0;
206 master_l10_counter = (unsigned int *)&dummy_master_l10_counter;
207 dummy_master_l10_counter = 0;
208
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000209 rootnp = of_find_node_by_path("/ambapp0");
210 if (!rootnp)
211 goto bad;
Daniel Hellstrom7279b822011-01-27 01:26:58 +0000212
213 /* Find System ID: GRLIB build ID and optional CHIP ID */
214 pp = of_find_property(rootnp, "systemid", &len);
215 if (pp)
216 amba_system_id = *(unsigned long *)pp->value;
217
218 /* Find IRQMP IRQ Controller Registers base adr otherwise bail out */
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000219 np = of_find_node_by_name(rootnp, "GAISLER_IRQMP");
Daniel Hellstrom9742e722011-01-04 01:41:31 +0000220 if (!np) {
221 np = of_find_node_by_name(rootnp, "01_00d");
222 if (!np)
223 goto bad;
224 }
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000225 pp = of_find_property(np, "reg", &len);
226 if (!pp)
227 goto bad;
228 leon3_irqctrl_regs = *(struct leon3_irqctrl_regs_map **)pp->value;
229
230 /* Find GPTIMER Timer Registers base address otherwise bail out. */
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000231 nnp = rootnp;
232 do {
233 np = of_find_node_by_name(nnp, "GAISLER_GPTIMER");
234 if (!np) {
235 np = of_find_node_by_name(nnp, "01_011");
236 if (!np)
237 goto bad;
238 }
239
240 ampopts = 0;
241 pp = of_find_property(np, "ampopts", &len);
242 if (pp) {
243 ampopts = *(int *)pp->value;
244 if (ampopts == 0) {
245 /* Skip this instance, resource already
246 * allocated by other OS */
247 nnp = np;
248 continue;
249 }
250 }
251
252 /* Select Timer-Instance on Timer Core. Default is zero */
253 leon3_gptimer_idx = ampopts & 0x7;
254
255 pp = of_find_property(np, "reg", &len);
256 if (pp)
257 leon3_gptimer_regs = *(struct leon3_gptimer_regs_map **)
258 pp->value;
259 pp = of_find_property(np, "interrupts", &len);
260 if (pp)
261 leon3_gptimer_irq = *(unsigned int *)pp->value;
262 } while (0);
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000263
264 if (leon3_gptimer_regs && leon3_irqctrl_regs && leon3_gptimer_irq) {
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000265 LEON3_BYPASS_STORE_PA(
266 &leon3_gptimer_regs->e[leon3_gptimer_idx].val, 0);
267 LEON3_BYPASS_STORE_PA(
268 &leon3_gptimer_regs->e[leon3_gptimer_idx].rld,
269 (((1000000 / HZ) - 1)));
270 LEON3_BYPASS_STORE_PA(
271 &leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 0);
Konrad Eisele5213a782009-08-17 00:13:29 +0000272
Konrad Eisele84017072009-08-31 22:08:13 +0000273#ifdef CONFIG_SMP
274 leon_percpu_timer_dev[0].start = (int)leon3_gptimer_regs;
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000275 leon_percpu_timer_dev[0].irq = leon3_gptimer_irq + 1 +
276 leon3_gptimer_idx;
Konrad Eisele84017072009-08-31 22:08:13 +0000277
278 if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
279 (1<<LEON3_GPTIMER_SEPIRQ))) {
Frans Pop0da2b302010-02-12 12:08:51 -0800280 prom_printf("irq timer not configured with separate irqs\n");
Konrad Eisele84017072009-08-31 22:08:13 +0000281 BUG();
282 }
283
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000284 LEON3_BYPASS_STORE_PA(
285 &leon3_gptimer_regs->e[leon3_gptimer_idx+1].val, 0);
286 LEON3_BYPASS_STORE_PA(
287 &leon3_gptimer_regs->e[leon3_gptimer_idx+1].rld,
288 (((1000000/HZ) - 1)));
289 LEON3_BYPASS_STORE_PA(
290 &leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl, 0);
Konrad Eisele84017072009-08-31 22:08:13 +0000291# endif
292
Daniel Hellstrome2305e32011-01-04 01:41:30 +0000293 /*
294 * The IRQ controller may (if implemented) consist of multiple
295 * IRQ controllers, each mapped on a 4Kb boundary.
296 * Each CPU may be routed to different IRQCTRLs, however
297 * we assume that all CPUs (in SMP system) is routed to the
298 * same IRQ Controller, and for non-SMP only one IRQCTRL is
299 * accessed anyway.
300 * In AMP systems, Linux must run on CPU0 for the time being.
301 */
302 cpu = sparc_leon3_cpuid();
303 icsel = LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->icsel[cpu/8]);
304 icsel = (icsel >> ((7 - (cpu&0x7)) * 4)) & 0xf;
305 leon3_irqctrl_regs += icsel;
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000306
307 /* Probe extended IRQ controller */
308 eirq = (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->mpstatus)
309 >> 16) & 0xf;
310 if (eirq != 0)
311 leon_eirq_setup(eirq);
Konrad Eisele5213a782009-08-17 00:13:29 +0000312 } else {
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000313 goto bad;
Konrad Eisele5213a782009-08-17 00:13:29 +0000314 }
315
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000316 irq = _leon_build_device_irq(NULL, leon3_gptimer_irq+leon3_gptimer_idx);
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000317 err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL);
Konrad Eisele5213a782009-08-17 00:13:29 +0000318
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000319 if (err) {
Konrad Eisele5213a782009-08-17 00:13:29 +0000320 printk(KERN_ERR "leon_time_init: unable to attach IRQ%d\n",
321 LEON_INTERRUPT_TIMER1);
322 prom_halt();
323 }
324
Konrad Eisele84017072009-08-31 22:08:13 +0000325# ifdef CONFIG_SMP
326 {
327 unsigned long flags;
328 struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (leon_percpu_timer_dev[0].irq - 1)];
329
330 /* For SMP we use the level 14 ticker, however the bootup code
331 * has copied the firmwares level 14 vector into boot cpu's
332 * trap table, we must fix this now or we get squashed.
333 */
334 local_irq_save(flags);
335
336 patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
337
338 /* Adjust so that we jump directly to smpleon_ticker */
339 trap_table->inst_three += smpleon_ticker - real_irq_entry;
340
341 local_flush_cache_all();
342 local_irq_restore(flags);
343 }
344# endif
345
Konrad Eisele5213a782009-08-17 00:13:29 +0000346 if (leon3_gptimer_regs) {
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000347 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl,
Konrad Eisele5213a782009-08-17 00:13:29 +0000348 LEON3_GPTIMER_EN |
349 LEON3_GPTIMER_RL |
350 LEON3_GPTIMER_LD | LEON3_GPTIMER_IRQEN);
Konrad Eisele84017072009-08-31 22:08:13 +0000351
352#ifdef CONFIG_SMP
Daniel Hellstrom2791c1a2011-01-04 01:41:32 +0000353 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
Konrad Eisele84017072009-08-31 22:08:13 +0000354 LEON3_GPTIMER_EN |
355 LEON3_GPTIMER_RL |
356 LEON3_GPTIMER_LD |
357 LEON3_GPTIMER_IRQEN);
358#endif
359
Konrad Eisele5213a782009-08-17 00:13:29 +0000360 }
Daniel Hellstrom53aea7c2011-01-04 01:41:29 +0000361 return;
362bad:
363 printk(KERN_ERR "No Timer/irqctrl found\n");
364 BUG();
365 return;
Konrad Eisele5213a782009-08-17 00:13:29 +0000366}
367
368void leon_clear_clock_irq(void)
369{
370}
371
372void leon_load_profile_irq(int cpu, unsigned int limit)
373{
374 BUG();
375}
376
377
378
379
380void __init leon_trans_init(struct device_node *dp)
381{
382 if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) {
383 struct property *p;
384 p = of_find_property(dp, "mid", (void *)0);
385 if (p) {
386 int mid;
387 dp->name = prom_early_alloc(5 + 1);
388 memcpy(&mid, p->value, p->length);
389 sprintf((char *)dp->name, "cpu%.2d", mid);
390 }
391 }
392}
393
394void __initdata (*prom_amba_init)(struct device_node *dp, struct device_node ***nextp) = 0;
395
396void __init leon_node_init(struct device_node *dp, struct device_node ***nextp)
397{
398 if (prom_amba_init &&
399 strcmp(dp->type, "ambapp") == 0 &&
400 strcmp(dp->name, "ambapp0") == 0) {
401 prom_amba_init(dp, nextp);
402 }
403}
404
Konrad Eisele84017072009-08-31 22:08:13 +0000405#ifdef CONFIG_SMP
406
407void leon_set_cpu_int(int cpu, int level)
408{
409 unsigned long mask;
410 mask = get_irqmask(level);
411 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask);
412}
413
414static void leon_clear_ipi(int cpu, int level)
415{
416 unsigned long mask;
417 mask = get_irqmask(level);
418 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask<<16);
419}
420
421static void leon_set_udt(int cpu)
422{
423}
424
425void leon_clear_profile_irq(int cpu)
426{
427}
428
429void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu)
430{
431 unsigned long mask, flags, *addr;
432 mask = get_irqmask(irq_nr);
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000433 spin_lock_irqsave(&leon_irq_lock, flags);
Konrad Eisele84017072009-08-31 22:08:13 +0000434 addr = (unsigned long *)&(leon3_irqctrl_regs->mask[cpu]);
435 LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | (mask)));
Daniel Hellstromd61a38b2011-04-19 23:41:21 +0000436 spin_unlock_irqrestore(&leon_irq_lock, flags);
Konrad Eisele84017072009-08-31 22:08:13 +0000437}
438
439#endif
440
Konrad Eisele5213a782009-08-17 00:13:29 +0000441void __init leon_init_IRQ(void)
442{
Sam Ravnborg6baa9b22011-04-18 11:25:44 +0000443 sparc_irq_config.init_timers = leon_init_timers;
Daniel Hellstrom4c6773c2011-04-19 23:41:22 +0000444 sparc_irq_config.build_device_irq = _leon_build_device_irq;
Konrad Eisele5213a782009-08-17 00:13:29 +0000445
446 BTFIXUPSET_CALL(clear_clock_irq, leon_clear_clock_irq,
447 BTFIXUPCALL_NORM);
448 BTFIXUPSET_CALL(load_profile_irq, leon_load_profile_irq,
449 BTFIXUPCALL_NOP);
450
451#ifdef CONFIG_SMP
452 BTFIXUPSET_CALL(set_cpu_int, leon_set_cpu_int, BTFIXUPCALL_NORM);
453 BTFIXUPSET_CALL(clear_cpu_int, leon_clear_ipi, BTFIXUPCALL_NORM);
454 BTFIXUPSET_CALL(set_irq_udt, leon_set_udt, BTFIXUPCALL_NORM);
455#endif
456
457}
458
459void __init leon_init(void)
460{
Andres Salomoned418502010-10-10 21:51:25 -0600461 of_pdt_build_more = &leon_node_init;
Konrad Eisele5213a782009-08-17 00:13:29 +0000462}