Commit | Line | Data |
---|---|---|
5213a780 KE |
1 | /* |
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> | |
10 | #include <linux/slab.h> | |
11 | #include <linux/of.h> | |
12 | #include <linux/of_platform.h> | |
13 | #include <linux/interrupt.h> | |
14 | #include <linux/of_device.h> | |
8401707f | 15 | |
5213a780 KE |
16 | #include <asm/oplib.h> |
17 | #include <asm/timer.h> | |
18 | #include <asm/prom.h> | |
19 | #include <asm/leon.h> | |
20 | #include <asm/leon_amba.h> | |
8401707f KE |
21 | #include <asm/traps.h> |
22 | #include <asm/cacheflush.h> | |
5213a780 KE |
23 | |
24 | #include "prom.h" | |
25 | #include "irq.h" | |
26 | ||
27 | struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address, initialized by amba_init() */ | |
28 | struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address, initialized by amba_init() */ | |
29 | struct amba_apb_device leon_percpu_timer_dev[16]; | |
30 | ||
31 | int leondebug_irq_disable; | |
32 | int leon_debug_irqout; | |
33 | static int dummy_master_l10_counter; | |
34 | ||
35 | unsigned long leon3_gptimer_irq; /* interrupt controller irq number, initialized by amba_init() */ | |
36 | unsigned int sparc_leon_eirq; | |
37 | #define LEON_IMASK ((&leon3_irqctrl_regs->mask[0])) | |
38 | ||
39 | /* Return the IRQ of the pending IRQ on the extended IRQ controller */ | |
40 | int sparc_leon_eirq_get(int eirq, int cpu) | |
41 | { | |
42 | return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f; | |
43 | } | |
44 | ||
45 | irqreturn_t sparc_leon_eirq_isr(int dummy, void *dev_id) | |
46 | { | |
47 | printk(KERN_ERR "sparc_leon_eirq_isr: ERROR EXTENDED IRQ\n"); | |
48 | return IRQ_HANDLED; | |
49 | } | |
50 | ||
51 | /* The extended IRQ controller has been found, this function registers it */ | |
52 | void sparc_leon_eirq_register(int eirq) | |
53 | { | |
54 | int irq; | |
55 | ||
56 | /* Register a "BAD" handler for this interrupt, it should never happen */ | |
57 | irq = request_irq(eirq, sparc_leon_eirq_isr, | |
58 | (IRQF_DISABLED | SA_STATIC_ALLOC), "extirq", NULL); | |
59 | ||
60 | if (irq) { | |
61 | printk(KERN_ERR | |
62 | "sparc_leon_eirq_register: unable to attach IRQ%d\n", | |
63 | eirq); | |
64 | } else { | |
65 | sparc_leon_eirq = eirq; | |
66 | } | |
67 | ||
68 | } | |
69 | ||
70 | static inline unsigned long get_irqmask(unsigned int irq) | |
71 | { | |
72 | unsigned long mask; | |
73 | ||
74 | if (!irq || ((irq > 0xf) && !sparc_leon_eirq) | |
75 | || ((irq > 0x1f) && sparc_leon_eirq)) { | |
76 | printk(KERN_ERR | |
77 | "leon_get_irqmask: false irq number: %d\n", irq); | |
78 | mask = 0; | |
79 | } else { | |
80 | mask = LEON_HARD_INT(irq); | |
81 | } | |
82 | return mask; | |
83 | } | |
84 | ||
85 | static void leon_enable_irq(unsigned int irq_nr) | |
86 | { | |
87 | unsigned long mask, flags; | |
88 | mask = get_irqmask(irq_nr); | |
89 | local_irq_save(flags); | |
90 | LEON3_BYPASS_STORE_PA(LEON_IMASK, | |
91 | (LEON3_BYPASS_LOAD_PA(LEON_IMASK) | (mask))); | |
92 | local_irq_restore(flags); | |
93 | } | |
94 | ||
95 | static void leon_disable_irq(unsigned int irq_nr) | |
96 | { | |
97 | unsigned long mask, flags; | |
98 | mask = get_irqmask(irq_nr); | |
99 | local_irq_save(flags); | |
100 | LEON3_BYPASS_STORE_PA(LEON_IMASK, | |
101 | (LEON3_BYPASS_LOAD_PA(LEON_IMASK) & ~(mask))); | |
102 | local_irq_restore(flags); | |
103 | ||
104 | } | |
105 | ||
106 | void __init leon_init_timers(irq_handler_t counter_fn) | |
107 | { | |
108 | int irq; | |
109 | ||
110 | leondebug_irq_disable = 0; | |
111 | leon_debug_irqout = 0; | |
112 | master_l10_counter = (unsigned int *)&dummy_master_l10_counter; | |
113 | dummy_master_l10_counter = 0; | |
114 | ||
115 | if (leon3_gptimer_regs && leon3_irqctrl_regs) { | |
116 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].val, 0); | |
117 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].rld, | |
118 | (((1000000 / 100) - 1))); | |
119 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].ctrl, 0); | |
120 | ||
8401707f KE |
121 | #ifdef CONFIG_SMP |
122 | leon_percpu_timer_dev[0].start = (int)leon3_gptimer_regs; | |
123 | leon_percpu_timer_dev[0].irq = leon3_gptimer_irq+1; | |
124 | ||
125 | if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) & | |
126 | (1<<LEON3_GPTIMER_SEPIRQ))) { | |
127 | prom_printf("irq timer not configured with seperate irqs \n"); | |
128 | BUG(); | |
129 | } | |
130 | ||
131 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].val, 0); | |
132 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].rld, (((1000000/100) - 1))); | |
133 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].ctrl, 0); | |
134 | # endif | |
135 | ||
5213a780 KE |
136 | } else { |
137 | printk(KERN_ERR "No Timer/irqctrl found\n"); | |
138 | BUG(); | |
139 | } | |
140 | ||
141 | irq = request_irq(leon3_gptimer_irq, | |
142 | counter_fn, | |
143 | (IRQF_DISABLED | SA_STATIC_ALLOC), "timer", NULL); | |
144 | ||
145 | if (irq) { | |
146 | printk(KERN_ERR "leon_time_init: unable to attach IRQ%d\n", | |
147 | LEON_INTERRUPT_TIMER1); | |
148 | prom_halt(); | |
149 | } | |
150 | ||
8401707f KE |
151 | # ifdef CONFIG_SMP |
152 | { | |
153 | unsigned long flags; | |
154 | struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (leon_percpu_timer_dev[0].irq - 1)]; | |
155 | ||
156 | /* For SMP we use the level 14 ticker, however the bootup code | |
157 | * has copied the firmwares level 14 vector into boot cpu's | |
158 | * trap table, we must fix this now or we get squashed. | |
159 | */ | |
160 | local_irq_save(flags); | |
161 | ||
162 | patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */ | |
163 | ||
164 | /* Adjust so that we jump directly to smpleon_ticker */ | |
165 | trap_table->inst_three += smpleon_ticker - real_irq_entry; | |
166 | ||
167 | local_flush_cache_all(); | |
168 | local_irq_restore(flags); | |
169 | } | |
170 | # endif | |
171 | ||
5213a780 KE |
172 | if (leon3_gptimer_regs) { |
173 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].ctrl, | |
174 | LEON3_GPTIMER_EN | | |
175 | LEON3_GPTIMER_RL | | |
176 | LEON3_GPTIMER_LD | LEON3_GPTIMER_IRQEN); | |
8401707f KE |
177 | |
178 | #ifdef CONFIG_SMP | |
179 | LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].ctrl, | |
180 | LEON3_GPTIMER_EN | | |
181 | LEON3_GPTIMER_RL | | |
182 | LEON3_GPTIMER_LD | | |
183 | LEON3_GPTIMER_IRQEN); | |
184 | #endif | |
185 | ||
5213a780 KE |
186 | } |
187 | } | |
188 | ||
189 | void leon_clear_clock_irq(void) | |
190 | { | |
191 | } | |
192 | ||
193 | void leon_load_profile_irq(int cpu, unsigned int limit) | |
194 | { | |
195 | BUG(); | |
196 | } | |
197 | ||
198 | ||
199 | ||
200 | ||
201 | void __init leon_trans_init(struct device_node *dp) | |
202 | { | |
203 | if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) { | |
204 | struct property *p; | |
205 | p = of_find_property(dp, "mid", (void *)0); | |
206 | if (p) { | |
207 | int mid; | |
208 | dp->name = prom_early_alloc(5 + 1); | |
209 | memcpy(&mid, p->value, p->length); | |
210 | sprintf((char *)dp->name, "cpu%.2d", mid); | |
211 | } | |
212 | } | |
213 | } | |
214 | ||
215 | void __initdata (*prom_amba_init)(struct device_node *dp, struct device_node ***nextp) = 0; | |
216 | ||
217 | void __init leon_node_init(struct device_node *dp, struct device_node ***nextp) | |
218 | { | |
219 | if (prom_amba_init && | |
220 | strcmp(dp->type, "ambapp") == 0 && | |
221 | strcmp(dp->name, "ambapp0") == 0) { | |
222 | prom_amba_init(dp, nextp); | |
223 | } | |
224 | } | |
225 | ||
8401707f KE |
226 | #ifdef CONFIG_SMP |
227 | ||
228 | void leon_set_cpu_int(int cpu, int level) | |
229 | { | |
230 | unsigned long mask; | |
231 | mask = get_irqmask(level); | |
232 | LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask); | |
233 | } | |
234 | ||
235 | static void leon_clear_ipi(int cpu, int level) | |
236 | { | |
237 | unsigned long mask; | |
238 | mask = get_irqmask(level); | |
239 | LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask<<16); | |
240 | } | |
241 | ||
242 | static void leon_set_udt(int cpu) | |
243 | { | |
244 | } | |
245 | ||
246 | void leon_clear_profile_irq(int cpu) | |
247 | { | |
248 | } | |
249 | ||
250 | void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu) | |
251 | { | |
252 | unsigned long mask, flags, *addr; | |
253 | mask = get_irqmask(irq_nr); | |
254 | local_irq_save(flags); | |
255 | addr = (unsigned long *)&(leon3_irqctrl_regs->mask[cpu]); | |
256 | LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | (mask))); | |
257 | local_irq_restore(flags); | |
258 | } | |
259 | ||
260 | #endif | |
261 | ||
5213a780 KE |
262 | void __init leon_init_IRQ(void) |
263 | { | |
264 | sparc_init_timers = leon_init_timers; | |
265 | ||
266 | BTFIXUPSET_CALL(enable_irq, leon_enable_irq, BTFIXUPCALL_NORM); | |
267 | BTFIXUPSET_CALL(disable_irq, leon_disable_irq, BTFIXUPCALL_NORM); | |
268 | BTFIXUPSET_CALL(enable_pil_irq, leon_enable_irq, BTFIXUPCALL_NORM); | |
269 | BTFIXUPSET_CALL(disable_pil_irq, leon_disable_irq, BTFIXUPCALL_NORM); | |
270 | ||
271 | BTFIXUPSET_CALL(clear_clock_irq, leon_clear_clock_irq, | |
272 | BTFIXUPCALL_NORM); | |
273 | BTFIXUPSET_CALL(load_profile_irq, leon_load_profile_irq, | |
274 | BTFIXUPCALL_NOP); | |
275 | ||
276 | #ifdef CONFIG_SMP | |
277 | BTFIXUPSET_CALL(set_cpu_int, leon_set_cpu_int, BTFIXUPCALL_NORM); | |
278 | BTFIXUPSET_CALL(clear_cpu_int, leon_clear_ipi, BTFIXUPCALL_NORM); | |
279 | BTFIXUPSET_CALL(set_irq_udt, leon_set_udt, BTFIXUPCALL_NORM); | |
280 | #endif | |
281 | ||
282 | } | |
283 | ||
284 | void __init leon_init(void) | |
285 | { | |
286 | prom_build_more = &leon_node_init; | |
287 | } |