blob: 896cbf340c429fd74615522532695d4b76880c7b [file] [log] [blame]
David Gibson007e8f52005-10-28 15:35:50 +10001/*
2 * arch/powerpc/platforms/pseries/xics.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright 2000 IBM Corporation.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +100011
12#undef DEBUG
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/types.h>
15#include <linux/threads.h>
16#include <linux/kernel.h>
17#include <linux/irq.h>
18#include <linux/smp.h>
19#include <linux/interrupt.h>
20#include <linux/signal.h>
21#include <linux/init.h>
22#include <linux/gfp.h>
23#include <linux/radix-tree.h>
24#include <linux/cpu.h>
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +100025
Michael Ellerman57cfb812006-03-21 20:45:59 +110026#include <asm/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <asm/prom.h>
28#include <asm/io.h>
29#include <asm/pgtable.h>
30#include <asm/smp.h>
31#include <asm/rtas.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/hvcall.h>
33#include <asm/machdep.h>
Paul Mackerras22277182005-10-28 11:47:17 +100034#include <asm/i8259.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
David Gibson007e8f52005-10-28 15:35:50 +100036#include "xics.h"
Anton Blanchardb9377ff2006-07-19 08:01:28 +100037#include "plpar_wrappers.h"
David Gibson007e8f52005-10-28 15:35:50 +100038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#define XICS_IPI 2
40#define XICS_IRQ_SPURIOUS 0
41
42/* Want a priority other than 0. Various HW issues require this. */
43#define DEFAULT_PRIORITY 5
44
David Gibson007e8f52005-10-28 15:35:50 +100045/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 * Mark IPIs as higher priority so we can take them inside interrupts that
Thomas Gleixner67144652006-07-01 19:29:22 -070047 * arent marked IRQF_DISABLED
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 */
49#define IPI_PRIORITY 4
50
51struct xics_ipl {
52 union {
53 u32 word;
54 u8 bytes[4];
55 } xirr_poll;
56 union {
57 u32 word;
58 u8 bytes[4];
59 } xirr;
60 u32 dummy;
61 union {
62 u32 word;
63 u8 bytes[4];
64 } qirr;
65};
66
67static struct xics_ipl __iomem *xics_per_cpu[NR_CPUS];
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static unsigned int default_server = 0xFF;
Anton Blanchard26370322005-09-12 13:12:11 +100070static unsigned int default_distrib_server = 0;
71static unsigned int interrupt_server_size = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +100073static struct irq_host *xics_host;
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075/*
76 * XICS only has a single IPI, so encode the messages per CPU
77 */
78struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned;
79
80/* RTAS service tokens */
Anton Blanchard26370322005-09-12 13:12:11 +100081static int ibm_get_xive;
82static int ibm_set_xive;
83static int ibm_int_on;
84static int ibm_int_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +100086
87/* Direct HW low level accessors */
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +100090static inline unsigned int direct_xirr_info_get(int n_cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
92 return in_be32(&xics_per_cpu[n_cpu]->xirr.word);
93}
94
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +100095static inline void direct_xirr_info_set(int n_cpu, int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
97 out_be32(&xics_per_cpu[n_cpu]->xirr.word, value);
98}
99
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000100static inline void direct_cppr_info(int n_cpu, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 out_8(&xics_per_cpu[n_cpu]->xirr.bytes[0], value);
103}
104
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000105static inline void direct_qirr_info(int n_cpu, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
107 out_8(&xics_per_cpu[n_cpu]->qirr.bytes[0], value);
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000111/* LPAR low level accessors */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
113
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000114static inline unsigned int lpar_xirr_info_get(int n_cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
116 unsigned long lpar_rc;
David Gibson007e8f52005-10-28 15:35:50 +1000117 unsigned long return_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119 lpar_rc = plpar_xirr(&return_value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200120 if (lpar_rc != H_SUCCESS)
David Gibson007e8f52005-10-28 15:35:50 +1000121 panic(" bad return code xirr - rc = %lx \n", lpar_rc);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000122 return (unsigned int)return_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000125static inline void lpar_xirr_info_set(int n_cpu, int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
127 unsigned long lpar_rc;
128 unsigned long val64 = value & 0xffffffff;
129
130 lpar_rc = plpar_eoi(val64);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200131 if (lpar_rc != H_SUCCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 panic("bad return code EOI - rc = %ld, value=%lx\n", lpar_rc,
David Gibson007e8f52005-10-28 15:35:50 +1000133 val64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134}
135
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000136static inline void lpar_cppr_info(int n_cpu, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
138 unsigned long lpar_rc;
139
140 lpar_rc = plpar_cppr(value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200141 if (lpar_rc != H_SUCCESS)
David Gibson007e8f52005-10-28 15:35:50 +1000142 panic("bad return code cppr - rc = %lx\n", lpar_rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143}
144
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000145static inline void lpar_qirr_info(int n_cpu , u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
147 unsigned long lpar_rc;
148
149 lpar_rc = plpar_ipi(get_hard_smp_processor_id(n_cpu), value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200150 if (lpar_rc != H_SUCCESS)
David Gibson007e8f52005-10-28 15:35:50 +1000151 panic("bad return code qirr - rc = %lx\n", lpar_rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000155/* High level handlers and init code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158#ifdef CONFIG_SMP
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000159static int get_irq_server(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 unsigned int server;
162 /* For the moment only implement delivery to all cpus or one cpu */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000163 cpumask_t cpumask = irq_desc[virq].affinity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 cpumask_t tmp = CPU_MASK_NONE;
165
166 if (!distribute_irqs)
167 return default_server;
168
169 if (cpus_equal(cpumask, CPU_MASK_ALL)) {
170 server = default_distrib_server;
171 } else {
172 cpus_and(tmp, cpu_online_map, cpumask);
173
174 if (cpus_empty(tmp))
175 server = default_distrib_server;
176 else
177 server = get_hard_smp_processor_id(first_cpu(tmp));
178 }
179
180 return server;
181
182}
183#else
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000184static int get_irq_server(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
186 return default_server;
187}
188#endif
189
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000190
191static void xics_unmask_irq(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 unsigned int irq;
194 int call_status;
195 unsigned int server;
196
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000197 pr_debug("xics: unmask virq %d\n", virq);
198
199 irq = (unsigned int)irq_map[virq].hwirq;
200 pr_debug(" -> map to hwirq 0x%x\n", irq);
201 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return;
203
204 server = get_irq_server(virq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server,
207 DEFAULT_PRIORITY);
208 if (call_status != 0) {
Anton Blanchard26370322005-09-12 13:12:11 +1000209 printk(KERN_ERR "xics_enable_irq: irq=%u: ibm_set_xive "
210 "returned %d\n", irq, call_status);
211 printk("set_xive %x, server %x\n", ibm_set_xive, server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return;
213 }
214
215 /* Now unmask the interrupt (often a no-op) */
216 call_status = rtas_call(ibm_int_on, 1, 1, NULL, irq);
217 if (call_status != 0) {
Anton Blanchard26370322005-09-12 13:12:11 +1000218 printk(KERN_ERR "xics_enable_irq: irq=%u: ibm_int_on "
219 "returned %d\n", irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 return;
221 }
222}
223
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000224static void xics_mask_real_irq(unsigned int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 int call_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 if (irq == XICS_IPI)
229 return;
230
231 call_status = rtas_call(ibm_int_off, 1, 1, NULL, irq);
232 if (call_status != 0) {
Anton Blanchard26370322005-09-12 13:12:11 +1000233 printk(KERN_ERR "xics_disable_real_irq: irq=%u: "
234 "ibm_int_off returned %d\n", irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 return;
236 }
237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 /* Have to set XIVE to 0xff to be able to remove a slot */
Michal Ostrowski673aeb72006-12-20 07:29:40 -0600239 call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq,
240 default_server, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (call_status != 0) {
Anton Blanchard26370322005-09-12 13:12:11 +1000242 printk(KERN_ERR "xics_disable_irq: irq=%u: ibm_set_xive(0xff)"
243 " returned %d\n", irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return;
245 }
246}
247
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000248static void xics_mask_irq(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
250 unsigned int irq;
251
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000252 pr_debug("xics: mask virq %d\n", virq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000254 irq = (unsigned int)irq_map[virq].hwirq;
255 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
256 return;
257 xics_mask_real_irq(irq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000258}
259
260static unsigned int xics_startup(unsigned int virq)
261{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000262 unsigned int irq;
263
264 /* force a reverse mapping of the interrupt so it gets in the cache */
265 irq = (unsigned int)irq_map[virq].hwirq;
266 irq_radix_revmap(xics_host, irq);
267
268 /* unmask it */
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000269 xics_unmask_irq(virq);
270 return 0;
271}
272
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000273static void xics_eoi_direct(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 int cpu = smp_processor_id();
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000276 unsigned int irq = (unsigned int)irq_map[virq].hwirq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 iosync();
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000279 direct_xirr_info_set(cpu, (0xff << 24) | irq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000280}
281
282
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000283static void xics_eoi_lpar(unsigned int virq)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000284{
285 int cpu = smp_processor_id();
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000286 unsigned int irq = (unsigned int)irq_map[virq].hwirq;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000287
288 iosync();
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000289 lpar_xirr_info_set(cpu, (0xff << 24) | irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000292static inline unsigned int xics_remap_irq(unsigned int vec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000294 unsigned int irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 vec &= 0x00ffffff;
297
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000298 if (vec == XICS_IRQ_SPURIOUS)
299 return NO_IRQ;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000300 irq = irq_radix_revmap(xics_host, vec);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000301 if (likely(irq != NO_IRQ))
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000302 return irq;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000303
304 printk(KERN_ERR "Interrupt %u (real) is invalid,"
305 " disabling it.\n", vec);
306 xics_mask_real_irq(vec);
307 return NO_IRQ;
308}
309
Olaf Hering35a84c22006-10-07 22:08:26 +1000310static unsigned int xics_get_irq_direct(void)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000311{
312 unsigned int cpu = smp_processor_id();
313
314 return xics_remap_irq(direct_xirr_info_get(cpu));
315}
316
Olaf Hering35a84c22006-10-07 22:08:26 +1000317static unsigned int xics_get_irq_lpar(void)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000318{
319 unsigned int cpu = smp_processor_id();
320
321 return xics_remap_irq(lpar_xirr_info_get(cpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
324#ifdef CONFIG_SMP
325
David Howells7d12e782006-10-05 14:55:46 +0100326static irqreturn_t xics_ipi_dispatch(int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 WARN_ON(cpu_is_offline(cpu));
329
330 while (xics_ipi_message[cpu].value) {
331 if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION,
332 &xics_ipi_message[cpu].value)) {
333 mb();
David Howells7d12e782006-10-05 14:55:46 +0100334 smp_message_recv(PPC_MSG_CALL_FUNCTION);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
336 if (test_and_clear_bit(PPC_MSG_RESCHEDULE,
337 &xics_ipi_message[cpu].value)) {
338 mb();
David Howells7d12e782006-10-05 14:55:46 +0100339 smp_message_recv(PPC_MSG_RESCHEDULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341#if 0
342 if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK,
343 &xics_ipi_message[cpu].value)) {
344 mb();
David Howells7d12e782006-10-05 14:55:46 +0100345 smp_message_recv(PPC_MSG_MIGRATE_TASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
347#endif
Michael Ellermancc532912005-12-04 18:39:43 +1100348#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK,
350 &xics_ipi_message[cpu].value)) {
351 mb();
David Howells7d12e782006-10-05 14:55:46 +0100352 smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
354#endif
355 }
356 return IRQ_HANDLED;
357}
358
David Howells7d12e782006-10-05 14:55:46 +0100359static irqreturn_t xics_ipi_action_direct(int irq, void *dev_id)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000360{
361 int cpu = smp_processor_id();
362
363 direct_qirr_info(cpu, 0xff);
364
David Howells7d12e782006-10-05 14:55:46 +0100365 return xics_ipi_dispatch(cpu);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000366}
367
David Howells7d12e782006-10-05 14:55:46 +0100368static irqreturn_t xics_ipi_action_lpar(int irq, void *dev_id)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000369{
370 int cpu = smp_processor_id();
371
372 lpar_qirr_info(cpu, 0xff);
373
David Howells7d12e782006-10-05 14:55:46 +0100374 return xics_ipi_dispatch(cpu);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000375}
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377void xics_cause_IPI(int cpu)
378{
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000379 if (firmware_has_feature(FW_FEATURE_LPAR))
380 lpar_qirr_info(cpu, IPI_PRIORITY);
381 else
382 direct_qirr_info(cpu, IPI_PRIORITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383}
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000384
Paul Mackerras6c80a212005-05-06 16:28:56 +1000385#endif /* CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000387static void xics_set_cpu_priority(int cpu, unsigned char cppr)
388{
389 if (firmware_has_feature(FW_FEATURE_LPAR))
390 lpar_cppr_info(cpu, cppr);
391 else
392 direct_cppr_info(cpu, cppr);
393 iosync();
394}
395
396static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
397{
398 unsigned int irq;
399 int status;
400 int xics_status[2];
401 unsigned long newmask;
402 cpumask_t tmp = CPU_MASK_NONE;
403
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000404 irq = (unsigned int)irq_map[virq].hwirq;
405 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000406 return;
407
408 status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
409
410 if (status) {
411 printk(KERN_ERR "xics_set_affinity: irq=%u ibm,get-xive "
412 "returns %d\n", irq, status);
413 return;
414 }
415
416 /* For the moment only implement delivery to all cpus or one cpu */
417 if (cpus_equal(cpumask, CPU_MASK_ALL)) {
418 newmask = default_distrib_server;
419 } else {
420 cpus_and(tmp, cpu_online_map, cpumask);
421 if (cpus_empty(tmp))
422 return;
423 newmask = get_hard_smp_processor_id(first_cpu(tmp));
424 }
425
426 status = rtas_call(ibm_set_xive, 3, 1, NULL,
427 irq, newmask, xics_status[1]);
428
429 if (status) {
430 printk(KERN_ERR "xics_set_affinity: irq=%u ibm,set-xive "
431 "returns %d\n", irq, status);
432 return;
433 }
434}
435
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000436void xics_setup_cpu(void)
437{
438 int cpu = smp_processor_id();
439
440 xics_set_cpu_priority(cpu, 0xff);
441
442 /*
443 * Put the calling processor into the GIQ. This is really only
444 * necessary from a secondary thread as the OF start-cpu interface
445 * performs this function for us on primary threads.
446 *
447 * XXX: undo of teardown on kexec needs this too, as may hotplug
448 */
Haren Myneni81b73dd2006-07-27 14:29:00 -0700449 rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000450 (1UL << interrupt_server_size) - 1 - default_distrib_server, 1);
451}
452
453
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000454static struct irq_chip xics_pic_direct = {
455 .typename = " XICS ",
456 .startup = xics_startup,
457 .mask = xics_mask_irq,
458 .unmask = xics_unmask_irq,
459 .eoi = xics_eoi_direct,
460 .set_affinity = xics_set_affinity
461};
462
463
464static struct irq_chip xics_pic_lpar = {
465 .typename = " XICS ",
466 .startup = xics_startup,
467 .mask = xics_mask_irq,
468 .unmask = xics_unmask_irq,
469 .eoi = xics_eoi_lpar,
470 .set_affinity = xics_set_affinity
471};
472
473
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000474static int xics_host_match(struct irq_host *h, struct device_node *node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000476 /* IBM machines have interrupt parents of various funky types for things
477 * like vdevices, events, etc... The trick we use here is to match
478 * everything here except the legacy 8259 which is compatible "chrp,iic"
Paul Mackerras6c80a212005-05-06 16:28:56 +1000479 */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000480 return !device_is_compatible(node, "chrp,iic");
Paul Mackerras6c80a212005-05-06 16:28:56 +1000481}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000483static int xics_host_map_direct(struct irq_host *h, unsigned int virq,
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700484 irq_hw_number_t hw)
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000485{
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700486 pr_debug("xics: map_direct virq %d, hwirq 0x%lx\n", virq, hw);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000487
488 get_irq_desc(virq)->status |= IRQ_LEVEL;
489 set_irq_chip_and_handler(virq, &xics_pic_direct, handle_fasteoi_irq);
490 return 0;
491}
492
493static int xics_host_map_lpar(struct irq_host *h, unsigned int virq,
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700494 irq_hw_number_t hw)
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000495{
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700496 pr_debug("xics: map_direct virq %d, hwirq 0x%lx\n", virq, hw);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000497
498 get_irq_desc(virq)->status |= IRQ_LEVEL;
499 set_irq_chip_and_handler(virq, &xics_pic_lpar, handle_fasteoi_irq);
500 return 0;
501}
502
503static int xics_host_xlate(struct irq_host *h, struct device_node *ct,
504 u32 *intspec, unsigned int intsize,
505 irq_hw_number_t *out_hwirq, unsigned int *out_flags)
506
507{
508 /* Current xics implementation translates everything
509 * to level. It is not technically right for MSIs but this
510 * is irrelevant at this point. We might get smarter in the future
511 */
512 *out_hwirq = intspec[0];
513 *out_flags = IRQ_TYPE_LEVEL_LOW;
514
515 return 0;
516}
517
518static struct irq_host_ops xics_host_direct_ops = {
519 .match = xics_host_match,
520 .map = xics_host_map_direct,
521 .xlate = xics_host_xlate,
522};
523
524static struct irq_host_ops xics_host_lpar_ops = {
525 .match = xics_host_match,
526 .map = xics_host_map_lpar,
527 .xlate = xics_host_xlate,
528};
529
530static void __init xics_init_host(void)
531{
532 struct irq_host_ops *ops;
533
534 if (firmware_has_feature(FW_FEATURE_LPAR))
535 ops = &xics_host_lpar_ops;
536 else
537 ops = &xics_host_direct_ops;
538 xics_host = irq_alloc_host(IRQ_HOST_MAP_TREE, 0, ops,
539 XICS_IRQ_SPURIOUS);
540 BUG_ON(xics_host == NULL);
541 irq_set_default_host(xics_host);
542}
543
544static void __init xics_map_one_cpu(int hw_id, unsigned long addr,
545 unsigned long size)
546{
547#ifdef CONFIG_SMP
548 int i;
549
550 /* This may look gross but it's good enough for now, we don't quite
551 * have a hard -> linux processor id matching.
552 */
553 for_each_possible_cpu(i) {
554 if (!cpu_present(i))
555 continue;
556 if (hw_id == get_hard_smp_processor_id(i)) {
557 xics_per_cpu[i] = ioremap(addr, size);
558 return;
559 }
560 }
561#else
562 if (hw_id != 0)
563 return;
564 xics_per_cpu[0] = ioremap(addr, size);
565#endif /* CONFIG_SMP */
566}
567
568static void __init xics_init_one_node(struct device_node *np,
569 unsigned int *indx)
570{
571 unsigned int ilen;
Jeremy Kerr954a46e2006-07-12 15:39:43 +1000572 const u32 *ireg;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000573
574 /* This code does the theorically broken assumption that the interrupt
575 * server numbers are the same as the hard CPU numbers.
576 * This happens to be the case so far but we are playing with fire...
577 * should be fixed one of these days. -BenH.
578 */
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000579 ireg = of_get_property(np, "ibm,interrupt-server-ranges", NULL);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000580
581 /* Do that ever happen ? we'll know soon enough... but even good'old
582 * f80 does have that property ..
583 */
584 WARN_ON(ireg == NULL);
585 if (ireg) {
586 /*
587 * set node starting index for this node
588 */
589 *indx = *ireg;
590 }
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000591 ireg = of_get_property(np, "reg", &ilen);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000592 if (!ireg)
593 panic("xics_init_IRQ: can't find interrupt reg property");
594
595 while (ilen >= (4 * sizeof(u32))) {
596 unsigned long addr, size;
597
598 /* XXX Use proper OF parsing code here !!! */
599 addr = (unsigned long)*ireg++ << 32;
600 ilen -= sizeof(u32);
601 addr |= *ireg++;
602 ilen -= sizeof(u32);
603 size = (unsigned long)*ireg++ << 32;
604 ilen -= sizeof(u32);
605 size |= *ireg++;
606 ilen -= sizeof(u32);
607 xics_map_one_cpu(*indx, addr, size);
608 (*indx)++;
609 }
610}
611
612
613static void __init xics_setup_8259_cascade(void)
614{
615 struct device_node *np, *old, *found = NULL;
616 int cascade, naddr;
Jeremy Kerr954a46e2006-07-12 15:39:43 +1000617 const u32 *addrp;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000618 unsigned long intack = 0;
619
620 for_each_node_by_type(np, "interrupt-controller")
621 if (device_is_compatible(np, "chrp,iic")) {
622 found = np;
623 break;
624 }
625 if (found == NULL) {
626 printk(KERN_DEBUG "xics: no ISA interrupt controller\n");
627 return;
628 }
629 cascade = irq_of_parse_and_map(found, 0);
630 if (cascade == NO_IRQ) {
631 printk(KERN_ERR "xics: failed to map cascade interrupt");
632 return;
633 }
634 pr_debug("xics: cascade mapped to irq %d\n", cascade);
635
636 for (old = of_node_get(found); old != NULL ; old = np) {
637 np = of_get_parent(old);
638 of_node_put(old);
639 if (np == NULL)
640 break;
641 if (strcmp(np->name, "pci") != 0)
642 continue;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000643 addrp = of_get_property(np, "8259-interrupt-acknowledge", NULL);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000644 if (addrp == NULL)
645 continue;
Stephen Rothwella8bda5d2007-04-03 10:56:50 +1000646 naddr = of_n_addr_cells(np);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000647 intack = addrp[naddr-1];
648 if (naddr > 1)
649 intack |= ((unsigned long)addrp[naddr-2]) << 32;
650 }
651 if (intack)
652 printk(KERN_DEBUG "xics: PCI 8259 intack at 0x%016lx\n", intack);
653 i8259_init(found, intack);
654 of_node_put(found);
655 set_irq_chained_handler(cascade, pseries_8259_cascade);
656}
657
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530658static struct device_node *cpuid_to_of_node(int cpu)
659{
660 struct device_node *np;
661 u32 hcpuid = get_hard_smp_processor_id(cpu);
662
663 for_each_node_by_type(np, "cpu") {
664 int i, len;
665 const u32 *intserv;
666
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000667 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
668 &len);
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530669
670 if (!intserv)
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000671 intserv = of_get_property(np, "reg", &len);
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530672
673 i = len / sizeof(u32);
674
675 while (i--)
676 if (intserv[i] == hcpuid)
677 return np;
678 }
679
680 return NULL;
681}
682
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000683void __init xics_init_IRQ(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530685 int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 struct device_node *np;
Jeremy Kerr954a46e2006-07-12 15:39:43 +1000687 u32 ilen, indx = 0;
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530688 const u32 *ireg, *isize;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000689 int found = 0;
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530690 u32 hcpuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692 ppc64_boot_msg(0x20, "XICS Init");
693
694 ibm_get_xive = rtas_token("ibm,get-xive");
695 ibm_set_xive = rtas_token("ibm,set-xive");
696 ibm_int_on = rtas_token("ibm,int-on");
697 ibm_int_off = rtas_token("ibm,int-off");
698
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000699 for_each_node_by_type(np, "PowerPC-External-Interrupt-Presentation") {
700 found = 1;
701 if (firmware_has_feature(FW_FEATURE_LPAR))
702 break;
703 xics_init_one_node(np, &indx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000705 if (found == 0)
706 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000708 xics_init_host();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
710 /* Find the server numbers for the boot cpu. */
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530711 np = cpuid_to_of_node(boot_cpuid);
712 BUG_ON(!np);
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000713 ireg = of_get_property(np, "ibm,ppc-interrupt-gserver#s", &ilen);
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530714 if (!ireg)
715 goto skip_gserver_check;
716 i = ilen / sizeof(int);
717 hcpuid = get_hard_smp_processor_id(boot_cpuid);
718
719 /* Global interrupt distribution server is specified in the last
720 * entry of "ibm,ppc-interrupt-gserver#s" property. Get the last
721 * entry fom this property for current boot cpu id and use it as
722 * default distribution server
723 */
724 for (j = 0; j < i; j += 2) {
725 if (ireg[j] == hcpuid) {
726 default_server = hcpuid;
727 default_distrib_server = ireg[j+1];
728
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000729 isize = of_get_property(np,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 "ibm,interrupt-server#-size", NULL);
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530731 if (isize)
732 interrupt_server_size = *isize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 }
734 }
Mohan Kumar Ma5715d62006-11-17 17:42:24 +0530735skip_gserver_check:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 of_node_put(np);
737
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000738 if (firmware_has_feature(FW_FEATURE_LPAR))
739 ppc_md.get_irq = xics_get_irq_lpar;
740 else
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000741 ppc_md.get_irq = xics_get_irq_direct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Paul Mackerras6c80a212005-05-06 16:28:56 +1000743 xics_setup_cpu();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000745 xics_setup_8259_cascade();
746
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 ppc64_boot_msg(0x21, "XICS Done");
748}
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751#ifdef CONFIG_SMP
752void xics_request_IPIs(void)
753{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000754 unsigned int ipi;
755
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700756 ipi = irq_create_mapping(xics_host, XICS_IPI);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000757 BUG_ON(ipi == NO_IRQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Thomas Gleixner67144652006-07-01 19:29:22 -0700759 /*
760 * IPIs are marked IRQF_DISABLED as they must run with irqs
761 * disabled
762 */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000763 set_irq_handler(ipi, handle_percpu_irq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000764 if (firmware_has_feature(FW_FEATURE_LPAR))
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000765 request_irq(ipi, xics_ipi_action_lpar, IRQF_DISABLED,
766 "IPI", NULL);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000767 else
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000768 request_irq(ipi, xics_ipi_action_direct, IRQF_DISABLED,
769 "IPI", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770}
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000771#endif /* CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Paul Mackerras6d22d852005-08-04 12:53:37 -0700773void xics_teardown_cpu(int secondary)
R Sharadafce0d572005-06-25 14:58:10 -0700774{
775 int cpu = smp_processor_id();
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000776 unsigned int ipi;
777 struct irq_desc *desc;
R Sharadafce0d572005-06-25 14:58:10 -0700778
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000779 xics_set_cpu_priority(cpu, 0);
Haren Myneni81bbbe92006-04-05 21:10:18 -0600780
781 /*
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700782 * Clear IPI
783 */
784 if (firmware_has_feature(FW_FEATURE_LPAR))
785 lpar_qirr_info(cpu, 0xff);
786 else
787 direct_qirr_info(cpu, 0xff);
788
789 /*
Haren Myneni81bbbe92006-04-05 21:10:18 -0600790 * we need to EOI the IPI if we got here from kexec down IPI
791 *
792 * probably need to check all the other interrupts too
793 * should we be flagging idle loop instead?
794 * or creating some task to be scheduled?
795 */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000796
797 ipi = irq_find_mapping(xics_host, XICS_IPI);
798 if (ipi == XICS_IRQ_SPURIOUS)
799 return;
800 desc = get_irq_desc(ipi);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000801 if (desc->chip && desc->chip->eoi)
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700802 desc->chip->eoi(ipi);
Haren Myneni81bbbe92006-04-05 21:10:18 -0600803
R Sharadafce0d572005-06-25 14:58:10 -0700804 /*
Paul Mackerras6d22d852005-08-04 12:53:37 -0700805 * Some machines need to have at least one cpu in the GIQ,
806 * so leave the master cpu in the group.
R Sharadafce0d572005-06-25 14:58:10 -0700807 */
Haren Myneni81bbbe92006-04-05 21:10:18 -0600808 if (secondary)
Haren Myneni81b73dd2006-07-27 14:29:00 -0700809 rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000810 (1UL << interrupt_server_size) - 1 -
811 default_distrib_server, 0);
R Sharadafce0d572005-06-25 14:58:10 -0700812}
813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814#ifdef CONFIG_HOTPLUG_CPU
815
816/* Interrupts are disabled. */
817void xics_migrate_irqs_away(void)
818{
819 int status;
820 unsigned int irq, virq, cpu = smp_processor_id();
821
822 /* Reject any interrupt that was queued to us... */
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000823 xics_set_cpu_priority(cpu, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 /* remove ourselves from the global interrupt queue */
Haren Myneni81b73dd2006-07-27 14:29:00 -0700826 status = rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 (1UL << interrupt_server_size) - 1 - default_distrib_server, 0);
828 WARN_ON(status < 0);
829
830 /* Allow IPIs again... */
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000831 xics_set_cpu_priority(cpu, DEFAULT_PRIORITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 for_each_irq(virq) {
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000834 struct irq_desc *desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 int xics_status[2];
836 unsigned long flags;
837
838 /* We cant set affinity on ISA interrupts */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000839 if (virq < NUM_ISA_INTERRUPTS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 continue;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000841 if (irq_map[virq].host != xics_host)
842 continue;
843 irq = (unsigned int)irq_map[virq].hwirq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 /* We need to get IPIs still. */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000845 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 continue;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000847 desc = get_irq_desc(virq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 /* We only need to migrate enabled IRQS */
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700850 if (desc == NULL || desc->chip == NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 || desc->action == NULL
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700852 || desc->chip->set_affinity == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 continue;
854
855 spin_lock_irqsave(&desc->lock, flags);
856
857 status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
858 if (status) {
Anton Blanchard26370322005-09-12 13:12:11 +1000859 printk(KERN_ERR "migrate_irqs_away: irq=%u "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 "ibm,get-xive returns %d\n",
861 virq, status);
862 goto unlock;
863 }
864
865 /*
866 * We only support delivery to all cpus or to one cpu.
867 * The irq has to be migrated only in the single cpu
868 * case.
869 */
870 if (xics_status[0] != get_hard_smp_processor_id(cpu))
871 goto unlock;
872
Anton Blanchard26370322005-09-12 13:12:11 +1000873 printk(KERN_WARNING "IRQ %u affinity broken off cpu %u\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 virq, cpu);
875
876 /* Reset affinity to all cpus */
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700877 desc->chip->set_affinity(virq, CPU_MASK_ALL);
Ingo Molnara53da522006-06-29 02:24:38 -0700878 irq_desc[irq].affinity = CPU_MASK_ALL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879unlock:
880 spin_unlock_irqrestore(&desc->lock, flags);
881 }
882}
883#endif