blob: 85d095154902453fb5896734597e849af07ea74e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Platform dependent support for SGI SN
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
6 * for more details.
7 *
John Kellerff740fb2008-12-08 11:44:11 -06008 * Copyright (c) 2000-2008 Silicon Graphics, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11#include <linux/irq.h>
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -070012#include <linux/spinlock.h>
Jes Sorensen2fcc3db2006-02-02 05:15:51 -050013#include <linux/init.h>
Franck Bui-Huu82524742008-05-12 21:21:05 +020014#include <linux/rculist.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090015#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <asm/sn/addrs.h>
17#include <asm/sn/arch.h>
Prarit Bhargavac13cf372005-07-06 15:26:51 -070018#include <asm/sn/intr.h>
19#include <asm/sn/pcibr_provider.h>
Mark Maule9b08ebd2005-04-25 11:32:16 -070020#include <asm/sn/pcibus_provider_defs.h>
21#include <asm/sn/pcidev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <asm/sn/shub_mmr.h>
23#include <asm/sn/sn_sal.h>
John Keller6e9de182007-08-22 19:32:06 -050024#include <asm/sn/sn_feature_sets.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026static void register_intr_pda(struct sn_irq_info *sn_irq_info);
27static void unregister_intr_pda(struct sn_irq_info *sn_irq_info);
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029extern int sn_ioif_inited;
Mark Maule83821d32006-04-14 16:03:54 -050030struct list_head **sn_irq_lh;
Ingo Molnar34af9462006-06-27 02:53:55 -070031static DEFINE_SPINLOCK(sn_irq_info_lock); /* non-IRQ lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Mark Maule83821d32006-04-14 16:03:54 -050033u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
34 struct sn_irq_info *sn_irq_info,
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 int req_irq, nasid_t req_nasid,
36 int req_slice)
37{
38 struct ia64_sal_retval ret_stuff;
39 ret_stuff.status = 0;
40 ret_stuff.v0 = 0;
41
42 SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
43 (u64) SAL_INTR_ALLOC, (u64) local_nasid,
Mark Maule83821d32006-04-14 16:03:54 -050044 (u64) local_widget, __pa(sn_irq_info), (u64) req_irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 (u64) req_nasid, (u64) req_slice);
Mark Maule83821d32006-04-14 16:03:54 -050046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 return ret_stuff.status;
48}
49
Mark Maule83821d32006-04-14 16:03:54 -050050void sn_intr_free(nasid_t local_nasid, int local_widget,
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 struct sn_irq_info *sn_irq_info)
52{
53 struct ia64_sal_retval ret_stuff;
54 ret_stuff.status = 0;
55 ret_stuff.v0 = 0;
56
57 SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
58 (u64) SAL_INTR_FREE, (u64) local_nasid,
59 (u64) local_widget, (u64) sn_irq_info->irq_irq,
60 (u64) sn_irq_info->irq_cookie, 0, 0);
61}
62
John Keller0e17b562007-05-02 09:09:18 -050063u64 sn_intr_redirect(nasid_t local_nasid, int local_widget,
64 struct sn_irq_info *sn_irq_info,
65 nasid_t req_nasid, int req_slice)
66{
67 struct ia64_sal_retval ret_stuff;
68 ret_stuff.status = 0;
69 ret_stuff.v0 = 0;
70
71 SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
72 (u64) SAL_INTR_REDIRECT, (u64) local_nasid,
73 (u64) local_widget, __pa(sn_irq_info),
74 (u64) req_nasid, (u64) req_slice, 0);
75
76 return ret_stuff.status;
77}
78
Thomas Gleixner545c8d82011-02-04 20:08:36 +010079static unsigned int sn_startup_irq(struct irq_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
81 return 0;
82}
83
Thomas Gleixner545c8d82011-02-04 20:08:36 +010084static void sn_shutdown_irq(struct irq_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86}
87
Russ Anderson1f3b6042007-10-31 11:10:38 -050088extern void ia64_mca_register_cpev(int);
89
Thomas Gleixner545c8d82011-02-04 20:08:36 +010090static void sn_disable_irq(struct irq_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Thomas Gleixner545c8d82011-02-04 20:08:36 +010092 if (data->irq == local_vector_to_irq(IA64_CPE_VECTOR))
Russ Anderson1f3b6042007-10-31 11:10:38 -050093 ia64_mca_register_cpev(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
95
Thomas Gleixner545c8d82011-02-04 20:08:36 +010096static void sn_enable_irq(struct irq_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
Thomas Gleixner545c8d82011-02-04 20:08:36 +010098 if (data->irq == local_vector_to_irq(IA64_CPE_VECTOR))
99 ia64_mca_register_cpev(data->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100102static void sn_ack_irq(struct irq_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103{
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500104 u64 event_occurred, mask;
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100105 unsigned int irq = data->irq & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500107 event_occurred = HUB_L((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED));
Colin Ngambe539c72005-04-25 13:06:28 -0700108 mask = event_occurred & SH_ALL_INT_MASK;
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500109 HUB_S((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS), mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 __set_bit(irq, (volatile void *)pda->sn_in_service_ivecs);
111
Thomas Gleixnerb5f01492011-03-25 20:35:17 +0100112 irq_move_irq(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
Mark Maule83821d32006-04-14 16:03:54 -0500115struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *sn_irq_info,
116 nasid_t nasid, int slice)
117{
118 int vector;
John Kellerc6957772006-11-06 14:10:50 -0600119 int cpuid;
120#ifdef CONFIG_SMP
Mark Maule83821d32006-04-14 16:03:54 -0500121 int cpuphys;
John Kellerc6957772006-11-06 14:10:50 -0600122#endif
Mark Maule83821d32006-04-14 16:03:54 -0500123 int64_t bridge;
124 int local_widget, status;
125 nasid_t local_nasid;
126 struct sn_irq_info *new_irq_info;
127 struct sn_pcibus_provider *pci_provider;
128
John Keller0e17b562007-05-02 09:09:18 -0500129 bridge = (u64) sn_irq_info->irq_bridge;
Mark Maule83821d32006-04-14 16:03:54 -0500130 if (!bridge) {
Mark Maule83821d32006-04-14 16:03:54 -0500131 return NULL; /* irq is not a device interrupt */
132 }
133
134 local_nasid = NASID_GET(bridge);
135
136 if (local_nasid & 1)
137 local_widget = TIO_SWIN_WIDGETNUM(bridge);
138 else
139 local_widget = SWIN_WIDGETNUM(bridge);
Mark Maule83821d32006-04-14 16:03:54 -0500140 vector = sn_irq_info->irq_irq;
John Keller0e17b562007-05-02 09:09:18 -0500141
142 /* Make use of SAL_INTR_REDIRECT if PROM supports it */
143 status = sn_intr_redirect(local_nasid, local_widget, sn_irq_info, nasid, slice);
144 if (!status) {
145 new_irq_info = sn_irq_info;
146 goto finish_up;
147 }
148
149 /*
150 * PROM does not support SAL_INTR_REDIRECT, or it failed.
151 * Revert to old method.
152 */
Thomas Meyerb82a3ec2011-11-17 23:43:40 +0100153 new_irq_info = kmemdup(sn_irq_info, sizeof(struct sn_irq_info),
154 GFP_ATOMIC);
John Keller0e17b562007-05-02 09:09:18 -0500155 if (new_irq_info == NULL)
156 return NULL;
157
Mark Maule83821d32006-04-14 16:03:54 -0500158 /* Free the old PROM new_irq_info structure */
159 sn_intr_free(local_nasid, local_widget, new_irq_info);
Mark Maule83821d32006-04-14 16:03:54 -0500160 unregister_intr_pda(new_irq_info);
161
162 /* allocate a new PROM new_irq_info struct */
163 status = sn_intr_alloc(local_nasid, local_widget,
164 new_irq_info, vector,
165 nasid, slice);
166
167 /* SAL call failed */
168 if (status) {
169 kfree(new_irq_info);
170 return NULL;
171 }
172
John Keller0e17b562007-05-02 09:09:18 -0500173 register_intr_pda(new_irq_info);
174 spin_lock(&sn_irq_info_lock);
175 list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
176 spin_unlock(&sn_irq_info_lock);
Lai Jiangshanf218a7e2011-03-18 11:48:01 +0800177 kfree_rcu(sn_irq_info, rcu);
John Keller0e17b562007-05-02 09:09:18 -0500178
179
180finish_up:
John Kellerc6957772006-11-06 14:10:50 -0600181 /* Update kernels new_irq_info with new target info */
182 cpuid = nasid_slice_to_cpuid(new_irq_info->irq_nasid,
183 new_irq_info->irq_slice);
184 new_irq_info->irq_cpuid = cpuid;
Mark Maule83821d32006-04-14 16:03:54 -0500185
186 pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
187
188 /*
189 * If this represents a line interrupt, target it. If it's
190 * an msi (irq_int_bit < 0), it's already targeted.
191 */
192 if (new_irq_info->irq_int_bit >= 0 &&
193 pci_provider && pci_provider->target_interrupt)
194 (pci_provider->target_interrupt)(new_irq_info);
195
Mark Maule83821d32006-04-14 16:03:54 -0500196#ifdef CONFIG_SMP
John Kellerc6957772006-11-06 14:10:50 -0600197 cpuphys = cpu_physical_id(cpuid);
Mark Maule83821d32006-04-14 16:03:54 -0500198 set_irq_affinity_info((vector & 0xff), cpuphys, 0);
199#endif
200
201 return new_irq_info;
202}
203
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100204static int sn_set_affinity_irq(struct irq_data *data,
205 const struct cpumask *mask, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700207 struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100208 unsigned int irq = data->irq;
Mark Maule83821d32006-04-14 16:03:54 -0500209 nasid_t nasid;
210 int slice;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Thomas Gleixner785aebd2014-03-04 20:43:38 +0000212 nasid = cpuid_to_nasid(cpumask_first_and(mask, cpu_online_mask));
213 slice = cpuid_to_slice(cpumask_first_and(mask, cpu_online_mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700215 list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
Mark Maule83821d32006-04-14 16:03:54 -0500216 sn_irq_lh[irq], list)
217 (void)sn_retarget_vector(sn_irq_info, nasid, slice);
Yinghai Lud5dedd42009-04-27 17:59:21 -0700218
219 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
John Keller6e9de182007-08-22 19:32:06 -0500222#ifdef CONFIG_SMP
223void sn_set_err_irq_affinity(unsigned int irq)
224{
225 /*
226 * On systems which support CPU disabling (SHub2), all error interrupts
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300227 * are targeted at the boot CPU.
John Keller6e9de182007-08-22 19:32:06 -0500228 */
229 if (is_shub2() && sn_prom_feature_available(PRF_CPU_DISABLE_SUPPORT))
230 set_irq_affinity_info(irq, cpu_physical_id(0), 0);
231}
232#else
233void sn_set_err_irq_affinity(unsigned int irq) { }
234#endif
235
KAMEZAWA Hiroyukie253eb02007-03-07 14:57:35 -0800236static void
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100237sn_mask_irq(struct irq_data *data)
KAMEZAWA Hiroyukie253eb02007-03-07 14:57:35 -0800238{
239}
240
241static void
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100242sn_unmask_irq(struct irq_data *data)
KAMEZAWA Hiroyukie253eb02007-03-07 14:57:35 -0800243{
244}
245
246struct irq_chip irq_type_sn = {
Thomas Gleixner545c8d82011-02-04 20:08:36 +0100247 .name = "SN hub",
248 .irq_startup = sn_startup_irq,
249 .irq_shutdown = sn_shutdown_irq,
250 .irq_enable = sn_enable_irq,
251 .irq_disable = sn_disable_irq,
252 .irq_ack = sn_ack_irq,
253 .irq_mask = sn_mask_irq,
254 .irq_unmask = sn_unmask_irq,
255 .irq_set_affinity = sn_set_affinity_irq
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
Kenji Kaneshige11152002007-08-13 10:31:26 -0700258ia64_vector sn_irq_to_vector(int irq)
259{
260 if (irq >= IA64_NUM_VECTORS)
261 return 0;
262 return (ia64_vector)irq;
263}
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265unsigned int sn_local_vector_to_irq(u8 vector)
266{
267 return (CPU_VECTOR_TO_IRQ(smp_processor_id(), vector));
268}
269
270void sn_irq_init(void)
271{
272 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Mark Maule10083072006-04-14 16:03:49 -0500274 ia64_first_device_vector = IA64_SN2_FIRST_DEVICE_VECTOR;
275 ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR;
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 for (i = 0; i < NR_IRQS; i++) {
Thomas Gleixnera2178332011-03-24 16:44:38 +0100278 if (irq_get_chip(i) == &no_irq_chip)
279 irq_set_chip(i, &irq_type_sn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
281}
282
283static void register_intr_pda(struct sn_irq_info *sn_irq_info)
284{
285 int irq = sn_irq_info->irq_irq;
286 int cpu = sn_irq_info->irq_cpuid;
287
288 if (pdacpu(cpu)->sn_last_irq < irq) {
289 pdacpu(cpu)->sn_last_irq = irq;
290 }
291
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500292 if (pdacpu(cpu)->sn_first_irq == 0 || pdacpu(cpu)->sn_first_irq > irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 pdacpu(cpu)->sn_first_irq = irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
296static void unregister_intr_pda(struct sn_irq_info *sn_irq_info)
297{
298 int irq = sn_irq_info->irq_irq;
299 int cpu = sn_irq_info->irq_cpuid;
300 struct sn_irq_info *tmp_irq_info;
301 int i, foundmatch;
302
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700303 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (pdacpu(cpu)->sn_last_irq == irq) {
305 foundmatch = 0;
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700306 for (i = pdacpu(cpu)->sn_last_irq - 1;
307 i && !foundmatch; i--) {
308 list_for_each_entry_rcu(tmp_irq_info,
309 sn_irq_lh[i],
310 list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (tmp_irq_info->irq_cpuid == cpu) {
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700312 foundmatch = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 break;
314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
316 }
317 pdacpu(cpu)->sn_last_irq = i;
318 }
319
320 if (pdacpu(cpu)->sn_first_irq == irq) {
321 foundmatch = 0;
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700322 for (i = pdacpu(cpu)->sn_first_irq + 1;
323 i < NR_IRQS && !foundmatch; i++) {
324 list_for_each_entry_rcu(tmp_irq_info,
325 sn_irq_lh[i],
326 list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (tmp_irq_info->irq_cpuid == cpu) {
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700328 foundmatch = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 break;
330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 }
332 }
333 pdacpu(cpu)->sn_first_irq = ((i == NR_IRQS) ? 0 : i);
334 }
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700335 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
339{
340 nasid_t nasid = sn_irq_info->irq_nasid;
341 int slice = sn_irq_info->irq_slice;
342 int cpu = nasid_slice_to_cpuid(nasid, slice);
John Kellerc6957772006-11-06 14:10:50 -0600343#ifdef CONFIG_SMP
344 int cpuphys;
345#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700347 pci_dev_get(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 sn_irq_info->irq_cpuid = cpu;
349 sn_irq_info->irq_pciioinfo = SN_PCIDEV_INFO(pci_dev);
350
351 /* link it into the sn_irq[irq] list */
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700352 spin_lock(&sn_irq_info_lock);
353 list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
Mark Maule10083072006-04-14 16:03:49 -0500354 reserve_irq_vector(sn_irq_info->irq_irq);
Dimitri Sivanich48e30fa2012-02-22 11:11:06 -0800355 if (sn_irq_info->irq_int_bit != -1)
356 irq_set_handler(sn_irq_info->irq_irq, handle_level_irq);
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700357 spin_unlock(&sn_irq_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500359 register_intr_pda(sn_irq_info);
John Kellerc6957772006-11-06 14:10:50 -0600360#ifdef CONFIG_SMP
361 cpuphys = cpu_physical_id(cpu);
362 set_irq_affinity_info(sn_irq_info->irq_irq, cpuphys, 0);
John Kellerff740fb2008-12-08 11:44:11 -0600363 /*
364 * Affinity was set by the PROM, prevent it from
365 * being reset by the request_irq() path.
366 */
Thomas Gleixner33776b02011-03-25 20:43:34 +0100367 irqd_mark_affinity_was_set(irq_get_irq_data(sn_irq_info->irq_irq));
John Kellerc6957772006-11-06 14:10:50 -0600368#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700371void sn_irq_unfixup(struct pci_dev *pci_dev)
372{
373 struct sn_irq_info *sn_irq_info;
374
375 /* Only cleanup IRQ stuff if this device has a host bus context */
376 if (!SN_PCIDEV_BUSSOFT(pci_dev))
377 return;
378
379 sn_irq_info = SN_PCIDEV_INFO(pci_dev)->pdi_sn_irq_info;
Prarit Bhargava8b34ff42006-02-09 14:12:24 -0800380 if (!sn_irq_info)
381 return;
382 if (!sn_irq_info->irq_irq) {
Prarit Bhargava6f354b02005-07-06 15:29:53 -0700383 kfree(sn_irq_info);
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700384 return;
Prarit Bhargava6f354b02005-07-06 15:29:53 -0700385 }
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700386
387 unregister_intr_pda(sn_irq_info);
388 spin_lock(&sn_irq_info_lock);
389 list_del_rcu(&sn_irq_info->list);
390 spin_unlock(&sn_irq_info_lock);
Mark Maule10083072006-04-14 16:03:49 -0500391 if (list_empty(sn_irq_lh[sn_irq_info->irq_irq]))
392 free_irq_vector(sn_irq_info->irq_irq);
Lai Jiangshanf218a7e2011-03-18 11:48:01 +0800393 kfree_rcu(sn_irq_info, rcu);
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700394 pci_dev_put(pci_dev);
Mark Maule10083072006-04-14 16:03:49 -0500395
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700396}
397
Mark Maule735e60f2005-08-03 14:06:00 -0700398static inline void
399sn_call_force_intr_provider(struct sn_irq_info *sn_irq_info)
400{
401 struct sn_pcibus_provider *pci_provider;
402
403 pci_provider = sn_pci_provider[sn_irq_info->irq_bridge_type];
Mike Habeck352b0ef2007-08-13 17:13:08 -0500404
405 /* Don't force an interrupt if the irq has been disabled */
Tony Luck4275f4c2011-04-01 10:56:03 -0700406 if (!irqd_irq_disabled(irq_get_irq_data(sn_irq_info->irq_irq)) &&
Mike Habeck352b0ef2007-08-13 17:13:08 -0500407 pci_provider && pci_provider->force_interrupt)
Mark Maule735e60f2005-08-03 14:06:00 -0700408 (*pci_provider->force_interrupt)(sn_irq_info);
409}
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/*
412 * Check for lost interrupts. If the PIC int_status reg. says that
413 * an interrupt has been sent, but not handled, and the interrupt
414 * is not pending in either the cpu irr regs or in the soft irr regs,
415 * and the interrupt is not in service, then the interrupt may have
416 * been lost. Force an interrupt on that pin. It is possible that
417 * the interrupt is in flight, so we may generate a spurious interrupt,
418 * but we should never miss a real lost interrupt.
419 */
420static void sn_check_intr(int irq, struct sn_irq_info *sn_irq_info)
421{
Prarit Bhargava53493dc2006-01-16 19:54:40 -0800422 u64 regval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 struct pcidev_info *pcidev_info;
424 struct pcibus_info *pcibus_info;
425
Mark Maule735e60f2005-08-03 14:06:00 -0700426 /*
427 * Bridge types attached to TIO (anything but PIC) do not need this WAR
428 * since they do not target Shub II interrupt registers. If that
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300429 * ever changes, this check needs to accommodate.
Mark Maule735e60f2005-08-03 14:06:00 -0700430 */
431 if (sn_irq_info->irq_bridge_type != PCIIO_ASIC_TYPE_PIC)
432 return;
433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
435 if (!pcidev_info)
436 return;
437
438 pcibus_info =
439 (struct pcibus_info *)pcidev_info->pdi_host_pcidev_info->
440 pdi_pcibus_info;
441 regval = pcireg_intr_status_get(pcibus_info);
442
Bjorn Helgaas9a4e5542006-03-21 10:44:07 -0700443 if (!ia64_get_irr(irq_to_vector(irq))) {
Mark Maule735e60f2005-08-03 14:06:00 -0700444 if (!test_bit(irq, pda->sn_in_service_ivecs)) {
445 regval &= 0xff;
446 if (sn_irq_info->irq_int_bit & regval &
447 sn_irq_info->irq_last_intr) {
448 regval &= ~(sn_irq_info->irq_int_bit & regval);
449 sn_call_force_intr_provider(sn_irq_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
451 }
452 }
453 sn_irq_info->irq_last_intr = regval;
454}
455
456void sn_lb_int_war_check(void)
457{
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700458 struct sn_irq_info *sn_irq_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 int i;
460
461 if (!sn_ioif_inited || pda->sn_first_irq == 0)
462 return;
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700463
464 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 for (i = pda->sn_first_irq; i <= pda->sn_last_irq; i++) {
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700466 list_for_each_entry_rcu(sn_irq_info, sn_irq_lh[i], list) {
Mark Maule735e60f2005-08-03 14:06:00 -0700467 sn_check_intr(i, sn_irq_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
469 }
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700470 rcu_read_unlock();
471}
472
Jes Sorensen2fcc3db2006-02-02 05:15:51 -0500473void __init sn_irq_lh_init(void)
Prarit Bhargavacb4cb2cb2005-07-06 14:59:44 -0700474{
475 int i;
476
477 sn_irq_lh = kmalloc(sizeof(struct list_head *) * NR_IRQS, GFP_KERNEL);
478 if (!sn_irq_lh)
479 panic("SN PCI INIT: Failed to allocate memory for PCI init\n");
480
481 for (i = 0; i < NR_IRQS; i++) {
482 sn_irq_lh[i] = kmalloc(sizeof(struct list_head), GFP_KERNEL);
483 if (!sn_irq_lh[i])
484 panic("SN PCI INIT: Failed IRQ memory allocation\n");
485
486 INIT_LIST_HEAD(sn_irq_lh[i]);
487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}