]>
Commit | Line | Data |
---|---|---|
cebf589c | 1 | /* |
f3f66f59 | 2 | * Cell Internal Interrupt Controller |
cebf589c | 3 | * |
0ebfff14 BH |
4 | * Copyright (C) 2006 Benjamin Herrenschmidt (benh@kernel.crashing.org) |
5 | * IBM, Corp. | |
6 | * | |
cebf589c AB |
7 | * (C) Copyright IBM Deutschland Entwicklung GmbH 2005 |
8 | * | |
9 | * Author: Arnd Bergmann <arndb@de.ibm.com> | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License as published by | |
13 | * the Free Software Foundation; either version 2, or (at your option) | |
14 | * any later version. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
2e194583 BH |
24 | * |
25 | * TODO: | |
26 | * - Fix various assumptions related to HW CPU numbers vs. linux CPU numbers | |
27 | * vs node numbers in the setup code | |
28 | * - Implement proper handling of maxcpus=1/2 (that is, routing of irqs from | |
29 | * a non-active node to the active node) | |
cebf589c AB |
30 | */ |
31 | ||
cebf589c AB |
32 | #include <linux/interrupt.h> |
33 | #include <linux/irq.h> | |
4b16f8e2 | 34 | #include <linux/export.h> |
cebf589c AB |
35 | #include <linux/percpu.h> |
36 | #include <linux/types.h> | |
0ebfff14 | 37 | #include <linux/ioport.h> |
5711fe90 | 38 | #include <linux/kernel_stat.h> |
cebf589c AB |
39 | |
40 | #include <asm/io.h> | |
41 | #include <asm/pgtable.h> | |
42 | #include <asm/prom.h> | |
43 | #include <asm/ptrace.h> | |
0ebfff14 | 44 | #include <asm/machdep.h> |
eef686a0 | 45 | #include <asm/cell-regs.h> |
cebf589c | 46 | |
f3f66f59 | 47 | #include "interrupt.h" |
cebf589c AB |
48 | |
49 | struct iic { | |
acf7d768 | 50 | struct cbe_iic_thread_regs __iomem *regs; |
2fb9d206 | 51 | u8 target_id; |
b9e5b4e6 BH |
52 | u8 eoi_stack[16]; |
53 | int eoi_ptr; | |
2e194583 | 54 | struct device_node *node; |
cebf589c AB |
55 | }; |
56 | ||
6b7487fc | 57 | static DEFINE_PER_CPU(struct iic, cpu_iic); |
0ebfff14 | 58 | #define IIC_NODE_COUNT 2 |
2e194583 | 59 | static struct irq_host *iic_host; |
0ebfff14 BH |
60 | |
61 | /* Convert between "pending" bits and hw irq number */ | |
62 | static irq_hw_number_t iic_pending_to_hwnum(struct cbe_iic_pending_bits bits) | |
63 | { | |
64 | unsigned char unit = bits.source & 0xf; | |
2e194583 BH |
65 | unsigned char node = bits.source >> 4; |
66 | unsigned char class = bits.class & 3; | |
0ebfff14 | 67 | |
2e194583 | 68 | /* Decode IPIs */ |
0ebfff14 | 69 | if (bits.flags & CBE_IIC_IRQ_IPI) |
2e194583 | 70 | return IIC_IRQ_TYPE_IPI | (bits.prio >> 4); |
0ebfff14 | 71 | else |
2e194583 | 72 | return (node << IIC_IRQ_NODE_SHIFT) | (class << 4) | unit; |
0ebfff14 | 73 | } |
cebf589c | 74 | |
d1ae63d4 | 75 | static void iic_mask(struct irq_data *d) |
cebf589c | 76 | { |
cebf589c AB |
77 | } |
78 | ||
d1ae63d4 | 79 | static void iic_unmask(struct irq_data *d) |
cebf589c AB |
80 | { |
81 | } | |
82 | ||
d1ae63d4 | 83 | static void iic_eoi(struct irq_data *d) |
cebf589c | 84 | { |
6b7487fc | 85 | struct iic *iic = &__get_cpu_var(cpu_iic); |
b9e5b4e6 BH |
86 | out_be64(&iic->regs->prio, iic->eoi_stack[--iic->eoi_ptr]); |
87 | BUG_ON(iic->eoi_ptr < 0); | |
cebf589c AB |
88 | } |
89 | ||
b9e5b4e6 | 90 | static struct irq_chip iic_chip = { |
fc380c0c | 91 | .name = "CELL-IIC", |
d1ae63d4 LB |
92 | .irq_mask = iic_mask, |
93 | .irq_unmask = iic_unmask, | |
94 | .irq_eoi = iic_eoi, | |
cebf589c AB |
95 | }; |
96 | ||
2e194583 | 97 | |
d1ae63d4 | 98 | static void iic_ioexc_eoi(struct irq_data *d) |
2e194583 BH |
99 | { |
100 | } | |
101 | ||
35a84c2f | 102 | static void iic_ioexc_cascade(unsigned int irq, struct irq_desc *desc) |
2e194583 | 103 | { |
ec775d0e | 104 | struct irq_chip *chip = irq_desc_get_chip(desc); |
d1ae63d4 | 105 | struct cbe_iic_regs __iomem *node_iic = |
ec775d0e | 106 | (void __iomem *)irq_desc_get_handler_data(desc); |
2e194583 BH |
107 | unsigned int base = (irq & 0xffffff00) | IIC_IRQ_TYPE_IOEXC; |
108 | unsigned long bits, ack; | |
109 | int cascade; | |
110 | ||
111 | for (;;) { | |
112 | bits = in_be64(&node_iic->iic_is); | |
113 | if (bits == 0) | |
114 | break; | |
115 | /* pre-ack edge interrupts */ | |
116 | ack = bits & IIC_ISR_EDGE_MASK; | |
117 | if (ack) | |
118 | out_be64(&node_iic->iic_is, ack); | |
119 | /* handle them */ | |
120 | for (cascade = 63; cascade >= 0; cascade--) | |
121 | if (bits & (0x8000000000000000UL >> cascade)) { | |
122 | unsigned int cirq = | |
123 | irq_linear_revmap(iic_host, | |
124 | base | cascade); | |
125 | if (cirq != NO_IRQ) | |
49f19ce4 | 126 | generic_handle_irq(cirq); |
2e194583 BH |
127 | } |
128 | /* post-ack level interrupts */ | |
129 | ack = bits & ~IIC_ISR_EDGE_MASK; | |
130 | if (ack) | |
131 | out_be64(&node_iic->iic_is, ack); | |
132 | } | |
d1ae63d4 | 133 | chip->irq_eoi(&desc->irq_data); |
2e194583 BH |
134 | } |
135 | ||
136 | ||
137 | static struct irq_chip iic_ioexc_chip = { | |
fc380c0c | 138 | .name = "CELL-IOEX", |
d1ae63d4 LB |
139 | .irq_mask = iic_mask, |
140 | .irq_unmask = iic_unmask, | |
141 | .irq_eoi = iic_ioexc_eoi, | |
2e194583 BH |
142 | }; |
143 | ||
cebf589c | 144 | /* Get an IRQ number from the pending state register of the IIC */ |
35a84c2f | 145 | static unsigned int iic_get_irq(void) |
d0e57c68 | 146 | { |
9e6ee340 GL |
147 | struct cbe_iic_pending_bits pending; |
148 | struct iic *iic; | |
2e194583 | 149 | unsigned int virq; |
9e6ee340 | 150 | |
6b7487fc | 151 | iic = &__get_cpu_var(cpu_iic); |
9e6ee340 | 152 | *(unsigned long *) &pending = |
b36ac9e8 | 153 | in_be64((u64 __iomem *) &iic->regs->pending_destr); |
2e194583 BH |
154 | if (!(pending.flags & CBE_IIC_IRQ_VALID)) |
155 | return NO_IRQ; | |
156 | virq = irq_linear_revmap(iic_host, iic_pending_to_hwnum(pending)); | |
157 | if (virq == NO_IRQ) | |
158 | return NO_IRQ; | |
9e6ee340 GL |
159 | iic->eoi_stack[++iic->eoi_ptr] = pending.prio; |
160 | BUG_ON(iic->eoi_ptr > 15); | |
2e194583 | 161 | return virq; |
cebf589c AB |
162 | } |
163 | ||
4bfac368 OJ |
164 | void iic_setup_cpu(void) |
165 | { | |
6b7487fc | 166 | out_be64(&__get_cpu_var(cpu_iic).regs->prio, 0xff); |
4bfac368 OJ |
167 | } |
168 | ||
169 | u8 iic_get_target_id(int cpu) | |
170 | { | |
6b7487fc | 171 | return per_cpu(cpu_iic, cpu).target_id; |
4bfac368 OJ |
172 | } |
173 | ||
174 | EXPORT_SYMBOL_GPL(iic_get_target_id); | |
175 | ||
cebf589c | 176 | #ifdef CONFIG_SMP |
a84195f3 AB |
177 | |
178 | /* Use the highest interrupt priorities for IPI */ | |
d5a1c193 | 179 | static inline int iic_msg_to_irq(int msg) |
a84195f3 | 180 | { |
d5a1c193 | 181 | return IIC_IRQ_TYPE_IPI + 0xf - msg; |
a84195f3 AB |
182 | } |
183 | ||
d5a1c193 | 184 | void iic_message_pass(int cpu, int msg) |
cebf589c | 185 | { |
d5a1c193 | 186 | out_be64(&per_cpu(cpu_iic, cpu).regs->generate, (0xf - msg) << 4); |
cebf589c AB |
187 | } |
188 | ||
0ebfff14 BH |
189 | struct irq_host *iic_get_irq_host(int node) |
190 | { | |
2e194583 | 191 | return iic_host; |
0ebfff14 BH |
192 | } |
193 | EXPORT_SYMBOL_GPL(iic_get_irq_host); | |
194 | ||
d5a1c193 | 195 | static void iic_request_ipi(int msg) |
cebf589c | 196 | { |
2e194583 | 197 | int virq; |
a84195f3 | 198 | |
d5a1c193 | 199 | virq = irq_create_mapping(iic_host, iic_msg_to_irq(msg)); |
2e194583 BH |
200 | if (virq == NO_IRQ) { |
201 | printk(KERN_ERR | |
d5a1c193 | 202 | "iic: failed to map IPI %s\n", smp_ipi_name[msg]); |
2e194583 | 203 | return; |
0ebfff14 | 204 | } |
7ef71d75 MM |
205 | |
206 | /* | |
207 | * If smp_request_message_ipi encounters an error it will notify | |
208 | * the error. If a message is not needed it will return non-zero. | |
209 | */ | |
d5a1c193 | 210 | if (smp_request_message_ipi(virq, msg)) |
7ef71d75 | 211 | irq_dispose_mapping(virq); |
cebf589c AB |
212 | } |
213 | ||
214 | void iic_request_IPIs(void) | |
215 | { | |
7ef71d75 MM |
216 | iic_request_ipi(PPC_MSG_CALL_FUNCTION); |
217 | iic_request_ipi(PPC_MSG_RESCHEDULE); | |
218 | iic_request_ipi(PPC_MSG_CALL_FUNC_SINGLE); | |
219 | iic_request_ipi(PPC_MSG_DEBUGGER_BREAK); | |
cebf589c | 220 | } |
0ebfff14 | 221 | |
cebf589c AB |
222 | #endif /* CONFIG_SMP */ |
223 | ||
0ebfff14 BH |
224 | |
225 | static int iic_host_match(struct irq_host *h, struct device_node *node) | |
226 | { | |
55b61fec | 227 | return of_device_is_compatible(node, |
2e194583 | 228 | "IBM,CBEA-Internal-Interrupt-Controller"); |
0ebfff14 BH |
229 | } |
230 | ||
231 | static int iic_host_map(struct irq_host *h, unsigned int virq, | |
6e99e458 | 232 | irq_hw_number_t hw) |
0ebfff14 | 233 | { |
2e194583 BH |
234 | switch (hw & IIC_IRQ_TYPE_MASK) { |
235 | case IIC_IRQ_TYPE_IPI: | |
ec775d0e | 236 | irq_set_chip_and_handler(virq, &iic_chip, handle_percpu_irq); |
2e194583 BH |
237 | break; |
238 | case IIC_IRQ_TYPE_IOEXC: | |
ec775d0e | 239 | irq_set_chip_and_handler(virq, &iic_ioexc_chip, |
e122996a | 240 | handle_edge_eoi_irq); |
2e194583 BH |
241 | break; |
242 | default: | |
ec775d0e | 243 | irq_set_chip_and_handler(virq, &iic_chip, handle_edge_eoi_irq); |
2e194583 | 244 | } |
0ebfff14 BH |
245 | return 0; |
246 | } | |
247 | ||
248 | static int iic_host_xlate(struct irq_host *h, struct device_node *ct, | |
40d50cf7 | 249 | const u32 *intspec, unsigned int intsize, |
0ebfff14 BH |
250 | irq_hw_number_t *out_hwirq, unsigned int *out_flags) |
251 | ||
cebf589c | 252 | { |
2e194583 BH |
253 | unsigned int node, ext, unit, class; |
254 | const u32 *val; | |
255 | ||
55b61fec | 256 | if (!of_device_is_compatible(ct, |
2e194583 BH |
257 | "IBM,CBEA-Internal-Interrupt-Controller")) |
258 | return -ENODEV; | |
259 | if (intsize != 1) | |
260 | return -ENODEV; | |
e2eb6392 | 261 | val = of_get_property(ct, "#interrupt-cells", NULL); |
2e194583 BH |
262 | if (val == NULL || *val != 1) |
263 | return -ENODEV; | |
264 | ||
265 | node = intspec[0] >> 24; | |
266 | ext = (intspec[0] >> 16) & 0xff; | |
267 | class = (intspec[0] >> 8) & 0xff; | |
268 | unit = intspec[0] & 0xff; | |
269 | ||
270 | /* Check if node is in supported range */ | |
271 | if (node > 1) | |
272 | return -EINVAL; | |
273 | ||
274 | /* Build up interrupt number, special case for IO exceptions */ | |
275 | *out_hwirq = (node << IIC_IRQ_NODE_SHIFT); | |
276 | if (unit == IIC_UNIT_IIC && class == 1) | |
277 | *out_hwirq |= IIC_IRQ_TYPE_IOEXC | ext; | |
278 | else | |
279 | *out_hwirq |= IIC_IRQ_TYPE_NORMAL | | |
280 | (class << IIC_IRQ_CLASS_SHIFT) | unit; | |
281 | ||
282 | /* Dummy flags, ignored by iic code */ | |
283 | *out_flags = IRQ_TYPE_EDGE_RISING; | |
284 | ||
285 | return 0; | |
0ebfff14 BH |
286 | } |
287 | ||
288 | static struct irq_host_ops iic_host_ops = { | |
289 | .match = iic_host_match, | |
290 | .map = iic_host_map, | |
291 | .xlate = iic_host_xlate, | |
292 | }; | |
293 | ||
294 | static void __init init_one_iic(unsigned int hw_cpu, unsigned long addr, | |
2e194583 | 295 | struct device_node *node) |
0ebfff14 BH |
296 | { |
297 | /* XXX FIXME: should locate the linux CPU number from the HW cpu | |
298 | * number properly. We are lucky for now | |
299 | */ | |
6b7487fc | 300 | struct iic *iic = &per_cpu(cpu_iic, hw_cpu); |
cebf589c | 301 | |
0ebfff14 BH |
302 | iic->regs = ioremap(addr, sizeof(struct cbe_iic_thread_regs)); |
303 | BUG_ON(iic->regs == NULL); | |
b9e5b4e6 | 304 | |
0ebfff14 BH |
305 | iic->target_id = ((hw_cpu & 2) << 3) | ((hw_cpu & 1) ? 0xf : 0xe); |
306 | iic->eoi_stack[0] = 0xff; | |
2e194583 | 307 | iic->node = of_node_get(node); |
0ebfff14 BH |
308 | out_be64(&iic->regs->prio, 0); |
309 | ||
2e194583 BH |
310 | printk(KERN_INFO "IIC for CPU %d target id 0x%x : %s\n", |
311 | hw_cpu, iic->target_id, node->full_name); | |
0ebfff14 BH |
312 | } |
313 | ||
314 | static int __init setup_iic(void) | |
315 | { | |
316 | struct device_node *dn; | |
317 | struct resource r0, r1; | |
2e194583 | 318 | unsigned int node, cascade, found = 0; |
43b4f406 | 319 | struct cbe_iic_regs __iomem *node_iic; |
9e6ee340 | 320 | const u32 *np; |
0ebfff14 BH |
321 | |
322 | for (dn = NULL; | |
323 | (dn = of_find_node_by_name(dn,"interrupt-controller")) != NULL;) { | |
55b61fec | 324 | if (!of_device_is_compatible(dn, |
0ebfff14 BH |
325 | "IBM,CBEA-Internal-Interrupt-Controller")) |
326 | continue; | |
e2eb6392 | 327 | np = of_get_property(dn, "ibm,interrupt-server-ranges", NULL); |
9e6ee340 | 328 | if (np == NULL) { |
0ebfff14 BH |
329 | printk(KERN_WARNING "IIC: CPU association not found\n"); |
330 | of_node_put(dn); | |
331 | return -ENODEV; | |
cebf589c | 332 | } |
0ebfff14 BH |
333 | if (of_address_to_resource(dn, 0, &r0) || |
334 | of_address_to_resource(dn, 1, &r1)) { | |
335 | printk(KERN_WARNING "IIC: Can't resolve addresses\n"); | |
336 | of_node_put(dn); | |
337 | return -ENODEV; | |
338 | } | |
2e194583 BH |
339 | found++; |
340 | init_one_iic(np[0], r0.start, dn); | |
341 | init_one_iic(np[1], r1.start, dn); | |
342 | ||
343 | /* Setup cascade for IO exceptions. XXX cleanup tricks to get | |
344 | * node vs CPU etc... | |
345 | * Note that we configure the IIC_IRR here with a hard coded | |
346 | * priority of 1. We might want to improve that later. | |
347 | */ | |
348 | node = np[0] >> 1; | |
349 | node_iic = cbe_get_cpu_iic_regs(np[0]); | |
350 | cascade = node << IIC_IRQ_NODE_SHIFT; | |
351 | cascade |= 1 << IIC_IRQ_CLASS_SHIFT; | |
352 | cascade |= IIC_UNIT_IIC; | |
353 | cascade = irq_create_mapping(iic_host, cascade); | |
354 | if (cascade == NO_IRQ) | |
355 | continue; | |
43b4f406 AB |
356 | /* |
357 | * irq_data is a generic pointer that gets passed back | |
358 | * to us later, so the forced cast is fine. | |
359 | */ | |
ec775d0e TG |
360 | irq_set_handler_data(cascade, (void __force *)node_iic); |
361 | irq_set_chained_handler(cascade, iic_ioexc_cascade); | |
2e194583 BH |
362 | out_be64(&node_iic->iic_ir, |
363 | (1 << 12) /* priority */ | | |
364 | (node << 4) /* dest node */ | | |
365 | IIC_UNIT_THREAD_0 /* route them to thread 0 */); | |
366 | /* Flush pending (make sure it triggers if there is | |
367 | * anything pending | |
368 | */ | |
369 | out_be64(&node_iic->iic_is, 0xfffffffffffffffful); | |
cebf589c | 370 | } |
0ebfff14 BH |
371 | |
372 | if (found) | |
373 | return 0; | |
374 | else | |
375 | return -ENODEV; | |
cebf589c AB |
376 | } |
377 | ||
b9e5b4e6 | 378 | void __init iic_init_IRQ(void) |
cebf589c | 379 | { |
2e194583 | 380 | /* Setup an irq host data structure */ |
52964f87 | 381 | iic_host = irq_alloc_host(NULL, IRQ_HOST_MAP_LINEAR, IIC_SOURCE_COUNT, |
2e194583 BH |
382 | &iic_host_ops, IIC_IRQ_INVALID); |
383 | BUG_ON(iic_host == NULL); | |
384 | irq_set_default_host(iic_host); | |
385 | ||
0ebfff14 | 386 | /* Discover and initialize iics */ |
d0e57c68 | 387 | if (setup_iic() < 0) |
0ebfff14 | 388 | panic("IIC: Failed to initialize !\n"); |
d0e57c68 | 389 | |
0ebfff14 BH |
390 | /* Set master interrupt handling function */ |
391 | ppc_md.get_irq = iic_get_irq; | |
b9e5b4e6 | 392 | |
0ebfff14 BH |
393 | /* Enable on current CPU */ |
394 | iic_setup_cpu(); | |
cebf589c | 395 | } |
0443bbd3 KC |
396 | |
397 | void iic_set_interrupt_routing(int cpu, int thread, int priority) | |
398 | { | |
399 | struct cbe_iic_regs __iomem *iic_regs = cbe_get_cpu_iic_regs(cpu); | |
400 | u64 iic_ir = 0; | |
401 | int node = cpu >> 1; | |
402 | ||
403 | /* Set which node and thread will handle the next interrupt */ | |
404 | iic_ir |= CBE_IIC_IR_PRIO(priority) | | |
405 | CBE_IIC_IR_DEST_NODE(node); | |
406 | if (thread == 0) | |
407 | iic_ir |= CBE_IIC_IR_DEST_UNIT(CBE_IIC_IR_PT_0); | |
408 | else | |
409 | iic_ir |= CBE_IIC_IR_DEST_UNIT(CBE_IIC_IR_PT_1); | |
410 | out_be64(&iic_regs->iic_ir, iic_ir); | |
411 | } |