blob: 1bcedd8b4616d29e139a74f15886ea119e260e72 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/types.h>
13#include <linux/threads.h>
14#include <linux/kernel.h>
15#include <linux/irq.h>
16#include <linux/smp.h>
17#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/radix-tree.h>
20#include <linux/cpu.h>
Andre Detsch8435b022009-11-04 13:03:19 -020021#include <linux/msi.h>
Milton Miller188bddd2008-10-10 01:56:33 +000022#include <linux/of.h>
Mark Nelson49bd3642009-12-07 20:32:17 +000023#include <linux/percpu.h>
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +100024
Michael Ellerman57cfb812006-03-21 20:45:59 +110025#include <asm/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/io.h>
27#include <asm/pgtable.h>
28#include <asm/smp.h>
29#include <asm/rtas.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/hvcall.h>
31#include <asm/machdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
David Gibson007e8f52005-10-28 15:35:50 +100033#include "xics.h"
Anton Blanchardb9377ff2006-07-19 08:01:28 +100034#include "plpar_wrappers.h"
David Gibson007e8f52005-10-28 15:35:50 +100035
Milton Miller0641cc92008-10-10 01:56:30 +000036static struct irq_host *xics_host;
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#define XICS_IPI 2
39#define XICS_IRQ_SPURIOUS 0
40
41/* Want a priority other than 0. Various HW issues require this. */
42#define DEFAULT_PRIORITY 5
43
David Gibson007e8f52005-10-28 15:35:50 +100044/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Mark IPIs as higher priority so we can take them inside interrupts that
Thomas Gleixner67144652006-07-01 19:29:22 -070046 * arent marked IRQF_DISABLED
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 */
48#define IPI_PRIORITY 4
49
Mark Nelson49bd3642009-12-07 20:32:17 +000050/* The least favored priority */
51#define LOWEST_PRIORITY 0xFF
52
53/* The number of priorities defined above */
54#define MAX_NUM_PRIORITIES 3
55
Milton Miller0641cc92008-10-10 01:56:30 +000056static unsigned int default_server = 0xFF;
57static unsigned int default_distrib_server = 0;
58static unsigned int interrupt_server_size = 8;
59
60/* RTAS service tokens */
61static int ibm_get_xive;
62static int ibm_set_xive;
63static int ibm_int_on;
64static int ibm_int_off;
65
Mark Nelson49bd3642009-12-07 20:32:17 +000066struct xics_cppr {
67 unsigned char stack[MAX_NUM_PRIORITIES];
68 int index;
69};
70
71static DEFINE_PER_CPU(struct xics_cppr, xics_cppr);
Milton Miller0641cc92008-10-10 01:56:30 +000072
73/* Direct hardware low level accessors */
74
75/* The part of the interrupt presentation layer that we care about */
Linus Torvalds1da177e2005-04-16 15:20:36 -070076struct xics_ipl {
77 union {
78 u32 word;
79 u8 bytes[4];
80 } xirr_poll;
81 union {
82 u32 word;
83 u8 bytes[4];
84 } xirr;
85 u32 dummy;
86 union {
87 u32 word;
88 u8 bytes[4];
89 } qirr;
90};
91
92static struct xics_ipl __iomem *xics_per_cpu[NR_CPUS];
93
Milton Millerd7cf0ed2007-12-14 15:52:09 +110094static inline unsigned int direct_xirr_info_get(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Milton Millerd7cf0ed2007-12-14 15:52:09 +110096 int cpu = smp_processor_id();
97
98 return in_be32(&xics_per_cpu[cpu]->xirr.word);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099}
100
Milton Miller9dc2d442008-10-10 01:56:32 +0000101static inline void direct_xirr_info_set(unsigned int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100103 int cpu = smp_processor_id();
104
105 out_be32(&xics_per_cpu[cpu]->xirr.word, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100108static inline void direct_cppr_info(u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100110 int cpu = smp_processor_id();
111
112 out_8(&xics_per_cpu[cpu]->xirr.bytes[0], value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000115static inline void direct_qirr_info(int n_cpu, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 out_8(&xics_per_cpu[n_cpu]->qirr.bytes[0], value);
118}
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000121/* LPAR low level accessors */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Mark Nelsonf09b7b22010-01-31 20:12:58 +0000123static inline unsigned int lpar_xirr_info_get(unsigned char cppr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
125 unsigned long lpar_rc;
David Gibson007e8f52005-10-28 15:35:50 +1000126 unsigned long return_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Mark Nelsonf09b7b22010-01-31 20:12:58 +0000128 lpar_rc = plpar_xirr(&return_value, cppr);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200129 if (lpar_rc != H_SUCCESS)
Frans Pop8354be92010-02-06 07:47:20 +0000130 panic(" bad return code xirr - rc = %lx\n", lpar_rc);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000131 return (unsigned int)return_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
Milton Miller9dc2d442008-10-10 01:56:32 +0000134static inline void lpar_xirr_info_set(unsigned int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
136 unsigned long lpar_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Milton Miller9dc2d442008-10-10 01:56:32 +0000138 lpar_rc = plpar_eoi(value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200139 if (lpar_rc != H_SUCCESS)
Milton Miller9dc2d442008-10-10 01:56:32 +0000140 panic("bad return code EOI - rc = %ld, value=%x\n", lpar_rc,
141 value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100144static inline void lpar_cppr_info(u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
146 unsigned long lpar_rc;
147
148 lpar_rc = plpar_cppr(value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200149 if (lpar_rc != H_SUCCESS)
David Gibson007e8f52005-10-28 15:35:50 +1000150 panic("bad return code cppr - rc = %lx\n", lpar_rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151}
152
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000153static inline void lpar_qirr_info(int n_cpu , u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154{
155 unsigned long lpar_rc;
156
157 lpar_rc = plpar_ipi(get_hard_smp_processor_id(n_cpu), value);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200158 if (lpar_rc != H_SUCCESS)
David Gibson007e8f52005-10-28 15:35:50 +1000159 panic("bad return code qirr - rc = %lx\n", lpar_rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160}
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Milton Miller0641cc92008-10-10 01:56:30 +0000163/* Interface to generic irq subsystem */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165#ifdef CONFIG_SMP
Anton Blanchard92cb3692010-01-04 15:26:33 +0000166static int get_irq_server(unsigned int virq, cpumask_t cpumask,
167 unsigned int strict_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000169 int server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 /* For the moment only implement delivery to all cpus or one cpu */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 cpumask_t tmp = CPU_MASK_NONE;
172
173 if (!distribute_irqs)
174 return default_server;
175
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000176 if (!cpus_equal(cpumask, CPU_MASK_ALL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 cpus_and(tmp, cpu_online_map, cpumask);
178
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000179 server = first_cpu(tmp);
180
181 if (server < NR_CPUS)
182 return get_hard_smp_processor_id(server);
183
184 if (strict_check)
185 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 }
187
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000188 if (cpus_equal(cpu_online_map, cpu_present_map))
189 return default_distrib_server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000191 return default_server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193#else
Benjamin Herrenschmidtbf647fa2010-02-01 13:32:41 +1100194#define get_irq_server(virq, cpumask, strict_check) (default_server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195#endif
196
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000197static void xics_unmask_irq(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 unsigned int irq;
200 int call_status;
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000201 int server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Michael Ellermanb69e9e92009-06-17 18:13:53 +0000203 pr_devel("xics: unmask virq %d\n", virq);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000204
205 irq = (unsigned int)irq_map[virq].hwirq;
Michael Ellermanb69e9e92009-06-17 18:13:53 +0000206 pr_devel(" -> map to hwirq 0x%x\n", irq);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000207 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 return;
209
Anton Blanchard92cb3692010-01-04 15:26:33 +0000210 server = get_irq_server(virq, *(irq_to_desc(virq)->affinity), 0);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server,
213 DEFAULT_PRIORITY);
214 if (call_status != 0) {
Milton Miller2172fe82008-10-10 01:56:39 +0000215 printk(KERN_ERR
216 "%s: ibm_set_xive irq %u server %x returned %d\n",
217 __func__, irq, server, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return;
219 }
220
221 /* Now unmask the interrupt (often a no-op) */
222 call_status = rtas_call(ibm_int_on, 1, 1, NULL, irq);
223 if (call_status != 0) {
Milton Miller2172fe82008-10-10 01:56:39 +0000224 printk(KERN_ERR "%s: ibm_int_on irq=%u returned %d\n",
225 __func__, irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 return;
227 }
228}
229
Milton Miller0641cc92008-10-10 01:56:30 +0000230static unsigned int xics_startup(unsigned int virq)
231{
Andre Detsch8435b022009-11-04 13:03:19 -0200232 /*
233 * The generic MSI code returns with the interrupt disabled on the
234 * card, using the MSI mask bits. Firmware doesn't appear to unmask
235 * at that level, so we do it here by hand.
236 */
237 if (irq_to_desc(virq)->msi_desc)
238 unmask_msi_irq(virq);
239
Milton Miller0641cc92008-10-10 01:56:30 +0000240 /* unmask it */
241 xics_unmask_irq(virq);
242 return 0;
243}
244
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000245static void xics_mask_real_irq(unsigned int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
247 int call_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 if (irq == XICS_IPI)
250 return;
251
252 call_status = rtas_call(ibm_int_off, 1, 1, NULL, irq);
253 if (call_status != 0) {
Milton Miller2172fe82008-10-10 01:56:39 +0000254 printk(KERN_ERR "%s: ibm_int_off irq=%u returned %d\n",
255 __func__, irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 return;
257 }
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 /* Have to set XIVE to 0xff to be able to remove a slot */
Michal Ostrowski673aeb72006-12-20 07:29:40 -0600260 call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq,
261 default_server, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 if (call_status != 0) {
Milton Miller2172fe82008-10-10 01:56:39 +0000263 printk(KERN_ERR "%s: ibm_set_xive(0xff) irq=%u returned %d\n",
264 __func__, irq, call_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return;
266 }
267}
268
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000269static void xics_mask_irq(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270{
271 unsigned int irq;
272
Michael Ellermanb69e9e92009-06-17 18:13:53 +0000273 pr_devel("xics: mask virq %d\n", virq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000275 irq = (unsigned int)irq_map[virq].hwirq;
276 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
277 return;
278 xics_mask_real_irq(irq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000279}
280
Milton Miller0641cc92008-10-10 01:56:30 +0000281static void xics_mask_unknown_vec(unsigned int vec)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000282{
Milton Miller0641cc92008-10-10 01:56:30 +0000283 printk(KERN_ERR "Interrupt %u (real) is invalid, disabling it.\n", vec);
284 xics_mask_real_irq(vec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286
Milton Miller8767e9b2008-10-10 01:56:23 +0000287static inline unsigned int xics_xirr_vector(unsigned int xirr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
Milton Miller8767e9b2008-10-10 01:56:23 +0000289 /*
290 * The top byte is the old cppr, to be restored on EOI.
291 * The remaining 24 bits are the vector.
292 */
293 return xirr & 0x00ffffff;
294}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Mark Nelson49bd3642009-12-07 20:32:17 +0000296static void push_cppr(unsigned int vec)
297{
298 struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
299
300 if (WARN_ON(os_cppr->index >= MAX_NUM_PRIORITIES - 1))
301 return;
302
303 if (vec == XICS_IPI)
304 os_cppr->stack[++os_cppr->index] = IPI_PRIORITY;
305 else
306 os_cppr->stack[++os_cppr->index] = DEFAULT_PRIORITY;
307}
308
Olaf Hering35a84c22006-10-07 22:08:26 +1000309static unsigned int xics_get_irq_direct(void)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000310{
Milton Miller8767e9b2008-10-10 01:56:23 +0000311 unsigned int xirr = direct_xirr_info_get();
312 unsigned int vec = xics_xirr_vector(xirr);
313 unsigned int irq;
314
315 if (vec == XICS_IRQ_SPURIOUS)
316 return NO_IRQ;
317
318 irq = irq_radix_revmap_lookup(xics_host, vec);
Mark Nelson49bd3642009-12-07 20:32:17 +0000319 if (likely(irq != NO_IRQ)) {
320 push_cppr(vec);
Milton Miller8767e9b2008-10-10 01:56:23 +0000321 return irq;
Mark Nelson49bd3642009-12-07 20:32:17 +0000322 }
Milton Miller8767e9b2008-10-10 01:56:23 +0000323
324 /* We don't have a linux mapping, so have rtas mask it. */
325 xics_mask_unknown_vec(vec);
326
327 /* We might learn about it later, so EOI it */
328 direct_xirr_info_set(xirr);
329 return NO_IRQ;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000330}
331
Olaf Hering35a84c22006-10-07 22:08:26 +1000332static unsigned int xics_get_irq_lpar(void)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000333{
Mark Nelsonf09b7b22010-01-31 20:12:58 +0000334 struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
335 unsigned int xirr = lpar_xirr_info_get(os_cppr->stack[os_cppr->index]);
Milton Miller8767e9b2008-10-10 01:56:23 +0000336 unsigned int vec = xics_xirr_vector(xirr);
337 unsigned int irq;
338
339 if (vec == XICS_IRQ_SPURIOUS)
340 return NO_IRQ;
341
342 irq = irq_radix_revmap_lookup(xics_host, vec);
Mark Nelson49bd3642009-12-07 20:32:17 +0000343 if (likely(irq != NO_IRQ)) {
344 push_cppr(vec);
Milton Miller8767e9b2008-10-10 01:56:23 +0000345 return irq;
Mark Nelson49bd3642009-12-07 20:32:17 +0000346 }
Milton Miller8767e9b2008-10-10 01:56:23 +0000347
348 /* We don't have a linux mapping, so have RTAS mask it. */
349 xics_mask_unknown_vec(vec);
350
351 /* We might learn about it later, so EOI it */
352 lpar_xirr_info_set(xirr);
353 return NO_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
Mark Nelson49bd3642009-12-07 20:32:17 +0000356static unsigned char pop_cppr(void)
357{
358 struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
359
360 if (WARN_ON(os_cppr->index < 1))
361 return LOWEST_PRIORITY;
362
363 return os_cppr->stack[--os_cppr->index];
364}
365
Milton Miller0641cc92008-10-10 01:56:30 +0000366static void xics_eoi_direct(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
Milton Miller0641cc92008-10-10 01:56:30 +0000368 unsigned int irq = (unsigned int)irq_map[virq].hwirq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000370 iosync();
Mark Nelson49bd3642009-12-07 20:32:17 +0000371 direct_xirr_info_set((pop_cppr() << 24) | irq);
Milton Miller0641cc92008-10-10 01:56:30 +0000372}
373
374static void xics_eoi_lpar(unsigned int virq)
375{
376 unsigned int irq = (unsigned int)irq_map[virq].hwirq;
377
378 iosync();
Mark Nelson49bd3642009-12-07 20:32:17 +0000379 lpar_xirr_info_set((pop_cppr() << 24) | irq);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000380}
381
Yinghai Lud5dedd42009-04-27 17:59:21 -0700382static int xics_set_affinity(unsigned int virq, const struct cpumask *cpumask)
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000383{
384 unsigned int irq;
385 int status;
386 int xics_status[2];
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000387 int irq_server;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000388
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000389 irq = (unsigned int)irq_map[virq].hwirq;
390 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Yinghai Lud5dedd42009-04-27 17:59:21 -0700391 return -1;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000392
393 status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
394
395 if (status) {
Milton Miller2172fe82008-10-10 01:56:39 +0000396 printk(KERN_ERR "%s: ibm,get-xive irq=%u returns %d\n",
397 __func__, irq, status);
Yinghai Lud5dedd42009-04-27 17:59:21 -0700398 return -1;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000399 }
400
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000401 /*
402 * For the moment only implement delivery to all cpus or one cpu.
403 * Get current irq_server for the given irq
404 */
Anton Blanchard92cb3692010-01-04 15:26:33 +0000405 irq_server = get_irq_server(virq, *cpumask, 1);
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000406 if (irq_server == -1) {
407 char cpulist[128];
408 cpumask_scnprintf(cpulist, sizeof(cpulist), cpumask);
Milton Miller2172fe82008-10-10 01:56:39 +0000409 printk(KERN_WARNING
410 "%s: No online cpus in the mask %s for irq %d\n",
411 __func__, cpulist, virq);
Yinghai Lud5dedd42009-04-27 17:59:21 -0700412 return -1;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000413 }
414
415 status = rtas_call(ibm_set_xive, 3, 1, NULL,
Mohan Kumar M7ccb4a62007-06-13 00:51:57 +1000416 irq, irq_server, xics_status[1]);
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000417
418 if (status) {
Milton Miller2172fe82008-10-10 01:56:39 +0000419 printk(KERN_ERR "%s: ibm,set-xive irq=%u returns %d\n",
420 __func__, irq, status);
Yinghai Lud5dedd42009-04-27 17:59:21 -0700421 return -1;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000422 }
Yinghai Lud5dedd42009-04-27 17:59:21 -0700423
424 return 0;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000425}
426
427static struct irq_chip xics_pic_direct = {
Anton Blanchardfc380c02010-01-31 20:33:41 +0000428 .name = "XICS",
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000429 .startup = xics_startup,
430 .mask = xics_mask_irq,
431 .unmask = xics_unmask_irq,
432 .eoi = xics_eoi_direct,
433 .set_affinity = xics_set_affinity
434};
435
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000436static struct irq_chip xics_pic_lpar = {
Anton Blanchardfc380c02010-01-31 20:33:41 +0000437 .name = "XICS",
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000438 .startup = xics_startup,
439 .mask = xics_mask_irq,
440 .unmask = xics_unmask_irq,
441 .eoi = xics_eoi_lpar,
442 .set_affinity = xics_set_affinity
443};
444
Milton Miller0641cc92008-10-10 01:56:30 +0000445
446/* Interface to arch irq controller subsystem layer */
447
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100448/* Points to the irq_chip we're actually using */
449static struct irq_chip *xics_irq_chip;
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000450
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000451static int xics_host_match(struct irq_host *h, struct device_node *node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000453 /* IBM machines have interrupt parents of various funky types for things
454 * like vdevices, events, etc... The trick we use here is to match
455 * everything here except the legacy 8259 which is compatible "chrp,iic"
Paul Mackerras6c80a212005-05-06 16:28:56 +1000456 */
Stephen Rothwell55b61fe2007-05-03 17:26:52 +1000457 return !of_device_is_compatible(node, "chrp,iic");
Paul Mackerras6c80a212005-05-06 16:28:56 +1000458}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100460static int xics_host_map(struct irq_host *h, unsigned int virq,
461 irq_hw_number_t hw)
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000462{
Michael Ellermanb69e9e92009-06-17 18:13:53 +0000463 pr_devel("xics: map virq %d, hwirq 0x%lx\n", virq, hw);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000464
Sebastien Dugue967e0122008-09-04 22:37:07 +1000465 /* Insert the interrupt mapping into the radix tree for fast lookup */
466 irq_radix_revmap_insert(xics_host, virq, hw);
467
Michael Ellerman6cff46f2009-10-13 19:44:51 +0000468 irq_to_desc(virq)->status |= IRQ_LEVEL;
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100469 set_irq_chip_and_handler(virq, xics_irq_chip, handle_fasteoi_irq);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000470 return 0;
471}
472
473static int xics_host_xlate(struct irq_host *h, struct device_node *ct,
Roman Fietze40d50cf2009-12-08 02:39:50 +0000474 const u32 *intspec, unsigned int intsize,
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000475 irq_hw_number_t *out_hwirq, unsigned int *out_flags)
476
477{
478 /* Current xics implementation translates everything
479 * to level. It is not technically right for MSIs but this
480 * is irrelevant at this point. We might get smarter in the future
481 */
482 *out_hwirq = intspec[0];
483 *out_flags = IRQ_TYPE_LEVEL_LOW;
484
485 return 0;
486}
487
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100488static struct irq_host_ops xics_host_ops = {
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000489 .match = xics_host_match,
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100490 .map = xics_host_map,
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000491 .xlate = xics_host_xlate,
492};
493
494static void __init xics_init_host(void)
495{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000496 if (firmware_has_feature(FW_FEATURE_LPAR))
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100497 xics_irq_chip = &xics_pic_lpar;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000498 else
Michael Ellerman1af9fa82008-04-01 17:42:27 +1100499 xics_irq_chip = &xics_pic_direct;
500
501 xics_host = irq_alloc_host(NULL, IRQ_HOST_MAP_TREE, 0, &xics_host_ops,
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000502 XICS_IRQ_SPURIOUS);
503 BUG_ON(xics_host == NULL);
504 irq_set_default_host(xics_host);
505}
506
Milton Miller0641cc92008-10-10 01:56:30 +0000507
508/* Inter-processor interrupt support */
509
510#ifdef CONFIG_SMP
511/*
512 * XICS only has a single IPI, so encode the messages per CPU
513 */
Anton Blanchardfda9d862010-01-31 20:32:51 +0000514static DEFINE_PER_CPU_SHARED_ALIGNED(unsigned long, xics_ipi_message);
Milton Miller0641cc92008-10-10 01:56:30 +0000515
516static inline void smp_xics_do_message(int cpu, int msg)
517{
Anton Blanchardfda9d862010-01-31 20:32:51 +0000518 unsigned long *tgt = &per_cpu(xics_ipi_message, cpu);
519
520 set_bit(msg, tgt);
Milton Miller0641cc92008-10-10 01:56:30 +0000521 mb();
522 if (firmware_has_feature(FW_FEATURE_LPAR))
523 lpar_qirr_info(cpu, IPI_PRIORITY);
524 else
525 direct_qirr_info(cpu, IPI_PRIORITY);
526}
527
528void smp_xics_message_pass(int target, int msg)
529{
530 unsigned int i;
531
532 if (target < NR_CPUS) {
533 smp_xics_do_message(target, msg);
534 } else {
535 for_each_online_cpu(i) {
536 if (target == MSG_ALL_BUT_SELF
537 && i == smp_processor_id())
538 continue;
539 smp_xics_do_message(i, msg);
540 }
541 }
542}
543
544static irqreturn_t xics_ipi_dispatch(int cpu)
545{
Anton Blanchardfda9d862010-01-31 20:32:51 +0000546 unsigned long *tgt = &per_cpu(xics_ipi_message, cpu);
547
Milton Miller0641cc92008-10-10 01:56:30 +0000548 WARN_ON(cpu_is_offline(cpu));
549
Milton Miller199f45c2008-10-10 01:56:44 +0000550 mb(); /* order mmio clearing qirr */
Anton Blanchardfda9d862010-01-31 20:32:51 +0000551 while (*tgt) {
552 if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION, tgt)) {
Milton Miller0641cc92008-10-10 01:56:30 +0000553 smp_message_recv(PPC_MSG_CALL_FUNCTION);
554 }
Anton Blanchardfda9d862010-01-31 20:32:51 +0000555 if (test_and_clear_bit(PPC_MSG_RESCHEDULE, tgt)) {
Milton Miller0641cc92008-10-10 01:56:30 +0000556 smp_message_recv(PPC_MSG_RESCHEDULE);
557 }
Anton Blanchardfda9d862010-01-31 20:32:51 +0000558 if (test_and_clear_bit(PPC_MSG_CALL_FUNC_SINGLE, tgt)) {
Milton Miller0641cc92008-10-10 01:56:30 +0000559 smp_message_recv(PPC_MSG_CALL_FUNC_SINGLE);
560 }
561#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
Anton Blanchardfda9d862010-01-31 20:32:51 +0000562 if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK, tgt)) {
Milton Miller0641cc92008-10-10 01:56:30 +0000563 smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
564 }
565#endif
566 }
567 return IRQ_HANDLED;
568}
569
570static irqreturn_t xics_ipi_action_direct(int irq, void *dev_id)
571{
572 int cpu = smp_processor_id();
573
574 direct_qirr_info(cpu, 0xff);
575
576 return xics_ipi_dispatch(cpu);
577}
578
579static irqreturn_t xics_ipi_action_lpar(int irq, void *dev_id)
580{
581 int cpu = smp_processor_id();
582
583 lpar_qirr_info(cpu, 0xff);
584
585 return xics_ipi_dispatch(cpu);
586}
587
588static void xics_request_ipi(void)
589{
590 unsigned int ipi;
591 int rc;
592
593 ipi = irq_create_mapping(xics_host, XICS_IPI);
594 BUG_ON(ipi == NO_IRQ);
595
596 /*
597 * IPIs are marked IRQF_DISABLED as they must run with irqs
598 * disabled
599 */
600 set_irq_handler(ipi, handle_percpu_irq);
601 if (firmware_has_feature(FW_FEATURE_LPAR))
Milton Millerd879f382008-10-10 01:56:39 +0000602 rc = request_irq(ipi, xics_ipi_action_lpar,
603 IRQF_DISABLED|IRQF_PERCPU, "IPI", NULL);
Milton Miller0641cc92008-10-10 01:56:30 +0000604 else
Milton Millerd879f382008-10-10 01:56:39 +0000605 rc = request_irq(ipi, xics_ipi_action_direct,
606 IRQF_DISABLED|IRQF_PERCPU, "IPI", NULL);
Milton Miller0641cc92008-10-10 01:56:30 +0000607 BUG_ON(rc);
608}
609
610int __init smp_xics_probe(void)
611{
612 xics_request_ipi();
613
614 return cpus_weight(cpu_possible_map);
615}
616
617#endif /* CONFIG_SMP */
618
619
620/* Initialization */
621
622static void xics_update_irq_servers(void)
623{
624 int i, j;
625 struct device_node *np;
626 u32 ilen;
Sebastien Dugue1ef80142008-10-22 04:36:32 +0000627 const u32 *ireg;
Milton Miller0641cc92008-10-10 01:56:30 +0000628 u32 hcpuid;
629
630 /* Find the server numbers for the boot cpu. */
631 np = of_get_cpu_node(boot_cpuid, NULL);
632 BUG_ON(!np);
633
634 ireg = of_get_property(np, "ibm,ppc-interrupt-gserver#s", &ilen);
635 if (!ireg) {
636 of_node_put(np);
637 return;
638 }
639
640 i = ilen / sizeof(int);
641 hcpuid = get_hard_smp_processor_id(boot_cpuid);
642
643 /* Global interrupt distribution server is specified in the last
644 * entry of "ibm,ppc-interrupt-gserver#s" property. Get the last
645 * entry fom this property for current boot cpu id and use it as
646 * default distribution server
647 */
648 for (j = 0; j < i; j += 2) {
649 if (ireg[j] == hcpuid) {
650 default_server = hcpuid;
651 default_distrib_server = ireg[j+1];
Milton Miller0641cc92008-10-10 01:56:30 +0000652 }
653 }
654
655 of_node_put(np);
656}
657
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000658static void __init xics_map_one_cpu(int hw_id, unsigned long addr,
659 unsigned long size)
660{
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000661 int i;
662
663 /* This may look gross but it's good enough for now, we don't quite
664 * have a hard -> linux processor id matching.
665 */
666 for_each_possible_cpu(i) {
667 if (!cpu_present(i))
668 continue;
669 if (hw_id == get_hard_smp_processor_id(i)) {
670 xics_per_cpu[i] = ioremap(addr, size);
671 return;
672 }
673 }
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000674}
675
676static void __init xics_init_one_node(struct device_node *np,
677 unsigned int *indx)
678{
679 unsigned int ilen;
Jeremy Kerr954a46e2006-07-12 15:39:43 +1000680 const u32 *ireg;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000681
682 /* This code does the theorically broken assumption that the interrupt
683 * server numbers are the same as the hard CPU numbers.
684 * This happens to be the case so far but we are playing with fire...
685 * should be fixed one of these days. -BenH.
686 */
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000687 ireg = of_get_property(np, "ibm,interrupt-server-ranges", NULL);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000688
689 /* Do that ever happen ? we'll know soon enough... but even good'old
690 * f80 does have that property ..
691 */
692 WARN_ON(ireg == NULL);
693 if (ireg) {
694 /*
695 * set node starting index for this node
696 */
697 *indx = *ireg;
698 }
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000699 ireg = of_get_property(np, "reg", &ilen);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000700 if (!ireg)
701 panic("xics_init_IRQ: can't find interrupt reg property");
702
703 while (ilen >= (4 * sizeof(u32))) {
704 unsigned long addr, size;
705
706 /* XXX Use proper OF parsing code here !!! */
707 addr = (unsigned long)*ireg++ << 32;
708 ilen -= sizeof(u32);
709 addr |= *ireg++;
710 ilen -= sizeof(u32);
711 size = (unsigned long)*ireg++ << 32;
712 ilen -= sizeof(u32);
713 size |= *ireg++;
714 ilen -= sizeof(u32);
715 xics_map_one_cpu(*indx, addr, size);
716 (*indx)++;
717 }
718}
719
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000720void __init xics_init_IRQ(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 struct device_node *np;
Nathan Fontenotde0723d2008-02-07 07:37:40 +1100723 u32 indx = 0;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000724 int found = 0;
Sebastien Dugue1ef80142008-10-22 04:36:32 +0000725 const u32 *isize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727 ppc64_boot_msg(0x20, "XICS Init");
728
729 ibm_get_xive = rtas_token("ibm,get-xive");
730 ibm_set_xive = rtas_token("ibm,set-xive");
731 ibm_int_on = rtas_token("ibm,int-on");
732 ibm_int_off = rtas_token("ibm,int-off");
733
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000734 for_each_node_by_type(np, "PowerPC-External-Interrupt-Presentation") {
735 found = 1;
Milton Millera244a952008-10-10 01:56:33 +0000736 if (firmware_has_feature(FW_FEATURE_LPAR)) {
737 of_node_put(np);
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000738 break;
Milton Millera244a952008-10-10 01:56:33 +0000739 }
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000740 xics_init_one_node(np, &indx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000742 if (found == 0)
743 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Sebastien Dugue1ef80142008-10-22 04:36:32 +0000745 /* get the bit size of server numbers */
746 found = 0;
747
748 for_each_compatible_node(np, NULL, "ibm,ppc-xics") {
749 isize = of_get_property(np, "ibm,interrupt-server#-size", NULL);
750
751 if (!isize)
752 continue;
753
754 if (!found) {
755 interrupt_server_size = *isize;
756 found = 1;
757 } else if (*isize != interrupt_server_size) {
758 printk(KERN_WARNING "XICS: "
759 "mismatched ibm,interrupt-server#-size\n");
760 interrupt_server_size = max(*isize,
761 interrupt_server_size);
762 }
763 }
764
Nathan Fontenotde0723d2008-02-07 07:37:40 +1100765 xics_update_irq_servers();
Milton Miller302905a2008-10-10 01:56:28 +0000766 xics_init_host();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000768 if (firmware_has_feature(FW_FEATURE_LPAR))
769 ppc_md.get_irq = xics_get_irq_lpar;
770 else
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000771 ppc_md.get_irq = xics_get_irq_direct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Paul Mackerras6c80a212005-05-06 16:28:56 +1000773 xics_setup_cpu();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
775 ppc64_boot_msg(0x21, "XICS Done");
776}
777
Milton Miller0641cc92008-10-10 01:56:30 +0000778/* Cpu startup, shutdown, and hotplug */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Milton Miller0641cc92008-10-10 01:56:30 +0000780static void xics_set_cpu_priority(unsigned char cppr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
Mark Nelson49bd3642009-12-07 20:32:17 +0000782 struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
783
Mark Nelson36350e02010-02-07 16:45:12 +0000784 /*
785 * we only really want to set the priority when there's
786 * just one cppr value on the stack
787 */
788 WARN_ON(os_cppr->index != 0);
Mark Nelson49bd3642009-12-07 20:32:17 +0000789
Mark Nelson36350e02010-02-07 16:45:12 +0000790 os_cppr->stack[0] = cppr;
Mark Nelson49bd3642009-12-07 20:32:17 +0000791
Milton Miller0641cc92008-10-10 01:56:30 +0000792 if (firmware_has_feature(FW_FEATURE_LPAR))
793 lpar_cppr_info(cppr);
794 else
795 direct_cppr_info(cppr);
796 iosync();
797}
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000798
Milton Millerb4963252008-10-10 01:56:34 +0000799/* Have the calling processor join or leave the specified global queue */
800static void xics_set_cpu_giq(unsigned int gserver, unsigned int join)
801{
Nathan Lynchedc72ac2008-12-11 09:14:25 +0000802 int index;
803 int status;
804
805 if (!rtas_indicator_present(GLOBAL_INTERRUPT_QUEUE, NULL))
806 return;
807
808 index = (1UL << interrupt_server_size) - 1 - gserver;
809
810 status = rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE, index, join);
811
812 WARN(status < 0, "set-indicator(%d, %d, %u) returned %d\n",
813 GLOBAL_INTERRUPT_QUEUE, index, join, status);
Milton Millerb4963252008-10-10 01:56:34 +0000814}
Milton Miller0641cc92008-10-10 01:56:30 +0000815
816void xics_setup_cpu(void)
817{
Mark Nelson49bd3642009-12-07 20:32:17 +0000818 xics_set_cpu_priority(LOWEST_PRIORITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Milton Millerb4963252008-10-10 01:56:34 +0000820 xics_set_cpu_giq(default_distrib_server, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
Milton Millerd13f7202008-10-10 01:56:29 +0000822
Al Virof10095c2008-03-29 03:10:38 +0000823void xics_teardown_cpu(void)
R Sharadafce0d572005-06-25 14:58:10 -0700824{
Mark Nelson36350e02010-02-07 16:45:12 +0000825 struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
R Sharadafce0d572005-06-25 14:58:10 -0700826 int cpu = smp_processor_id();
R Sharadafce0d572005-06-25 14:58:10 -0700827
Mark Nelson36350e02010-02-07 16:45:12 +0000828 /*
829 * we have to reset the cppr index to 0 because we're
830 * not going to return from the IPI
831 */
832 os_cppr->index = 0;
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100833 xics_set_cpu_priority(0);
Haren Myneni81bbbe92006-04-05 21:10:18 -0600834
Milton Millerb4963252008-10-10 01:56:34 +0000835 /* Clear any pending IPI request */
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700836 if (firmware_has_feature(FW_FEATURE_LPAR))
837 lpar_qirr_info(cpu, 0xff);
838 else
839 direct_qirr_info(cpu, 0xff);
Nathan Fontenotc3e85062008-02-07 07:37:31 +1100840}
841
842void xics_kexec_teardown_cpu(int secondary)
843{
Nathan Fontenotc3e85062008-02-07 07:37:31 +1100844 xics_teardown_cpu();
Benjamin Herrenschmidt6e99e452006-07-10 04:44:42 -0700845
846 /*
Milton Miller1a57c922008-10-10 01:56:35 +0000847 * we take the ipi irq but and never return so we
848 * need to EOI the IPI, but want to leave our priority 0
Haren Myneni81bbbe92006-04-05 21:10:18 -0600849 *
Milton Miller1a57c922008-10-10 01:56:35 +0000850 * should we check all the other interrupts too?
Haren Myneni81bbbe92006-04-05 21:10:18 -0600851 * should we be flagging idle loop instead?
852 * or creating some task to be scheduled?
853 */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000854
Milton Miller1a57c922008-10-10 01:56:35 +0000855 if (firmware_has_feature(FW_FEATURE_LPAR))
856 lpar_xirr_info_set((0x00 << 24) | XICS_IPI);
857 else
858 direct_xirr_info_set((0x00 << 24) | XICS_IPI);
Haren Myneni81bbbe92006-04-05 21:10:18 -0600859
R Sharadafce0d572005-06-25 14:58:10 -0700860 /*
Paul Mackerras6d22d852005-08-04 12:53:37 -0700861 * Some machines need to have at least one cpu in the GIQ,
862 * so leave the master cpu in the group.
R Sharadafce0d572005-06-25 14:58:10 -0700863 */
Haren Myneni81bbbe92006-04-05 21:10:18 -0600864 if (secondary)
Milton Millerb4963252008-10-10 01:56:34 +0000865 xics_set_cpu_giq(default_distrib_server, 0);
R Sharadafce0d572005-06-25 14:58:10 -0700866}
867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868#ifdef CONFIG_HOTPLUG_CPU
869
870/* Interrupts are disabled. */
871void xics_migrate_irqs_away(void)
872{
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100873 int cpu = smp_processor_id(), hw_cpu = hard_smp_processor_id();
874 unsigned int irq, virq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
Milton Miller302905a2008-10-10 01:56:28 +0000876 /* If we used to be the default server, move to the new "boot_cpuid" */
877 if (hw_cpu == default_server)
878 xics_update_irq_servers();
879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 /* Reject any interrupt that was queued to us... */
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100881 xics_set_cpu_priority(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Milton Millerb4963252008-10-10 01:56:34 +0000883 /* Remove ourselves from the global interrupt queue */
884 xics_set_cpu_giq(default_distrib_server, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
886 /* Allow IPIs again... */
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100887 xics_set_cpu_priority(DEFAULT_PRIORITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 for_each_irq(virq) {
Benjamin Herrenschmidtb9e5b4e2006-07-03 19:32:51 +1000890 struct irq_desc *desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 int xics_status[2];
Milton Millerb4963252008-10-10 01:56:34 +0000892 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 unsigned long flags;
894
895 /* We cant set affinity on ISA interrupts */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000896 if (virq < NUM_ISA_INTERRUPTS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 continue;
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000898 if (irq_map[virq].host != xics_host)
899 continue;
900 irq = (unsigned int)irq_map[virq].hwirq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 /* We need to get IPIs still. */
Benjamin Herrenschmidt0ebfff12006-07-03 21:36:01 +1000902 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 continue;
Michael Ellerman6cff46f2009-10-13 19:44:51 +0000904 desc = irq_to_desc(virq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
906 /* We only need to migrate enabled IRQS */
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700907 if (desc == NULL || desc->chip == NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 || desc->action == NULL
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700909 || desc->chip->set_affinity == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 continue;
911
Thomas Gleixner239007b2009-11-17 16:46:45 +0100912 raw_spin_lock_irqsave(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
915 if (status) {
Milton Miller2172fe82008-10-10 01:56:39 +0000916 printk(KERN_ERR "%s: ibm,get-xive irq=%u returns %d\n",
917 __func__, irq, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 goto unlock;
919 }
920
921 /*
922 * We only support delivery to all cpus or to one cpu.
923 * The irq has to be migrated only in the single cpu
924 * case.
925 */
Milton Millerd7cf0ed2007-12-14 15:52:09 +1100926 if (xics_status[0] != hw_cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 goto unlock;
928
Anton Blanchard26370322005-09-12 13:12:11 +1000929 printk(KERN_WARNING "IRQ %u affinity broken off cpu %u\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 virq, cpu);
931
932 /* Reset affinity to all cpus */
Michael Ellerman6cff46f2009-10-13 19:44:51 +0000933 cpumask_setall(irq_to_desc(virq)->affinity);
Rusty Russell0de26522008-12-13 21:20:26 +1030934 desc->chip->set_affinity(virq, cpu_all_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935unlock:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100936 raw_spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 }
938}
939#endif