2 * Platform dependent support for SGI SN
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
8 * Copyright (c) 2000-2006 Silicon Graphics, Inc. All Rights Reserved.
11 #include <linux/irq.h>
12 #include <linux/spinlock.h>
13 #include <linux/init.h>
14 #include <asm/sn/addrs.h>
15 #include <asm/sn/arch.h>
16 #include <asm/sn/intr.h>
17 #include <asm/sn/pcibr_provider.h>
18 #include <asm/sn/pcibus_provider_defs.h>
19 #include <asm/sn/pcidev.h>
20 #include <asm/sn/shub_mmr.h>
21 #include <asm/sn/sn_sal.h>
23 static void force_interrupt(int irq
);
24 static void register_intr_pda(struct sn_irq_info
*sn_irq_info
);
25 static void unregister_intr_pda(struct sn_irq_info
*sn_irq_info
);
27 int sn_force_interrupt_flag
= 1;
28 extern int sn_ioif_inited
;
29 struct list_head
**sn_irq_lh
;
30 static DEFINE_SPINLOCK(sn_irq_info_lock
); /* non-IRQ lock */
32 u64
sn_intr_alloc(nasid_t local_nasid
, int local_widget
,
33 struct sn_irq_info
*sn_irq_info
,
34 int req_irq
, nasid_t req_nasid
,
37 struct ia64_sal_retval ret_stuff
;
41 SAL_CALL_NOLOCK(ret_stuff
, (u64
) SN_SAL_IOIF_INTERRUPT
,
42 (u64
) SAL_INTR_ALLOC
, (u64
) local_nasid
,
43 (u64
) local_widget
, __pa(sn_irq_info
), (u64
) req_irq
,
44 (u64
) req_nasid
, (u64
) req_slice
);
46 return ret_stuff
.status
;
49 void sn_intr_free(nasid_t local_nasid
, int local_widget
,
50 struct sn_irq_info
*sn_irq_info
)
52 struct ia64_sal_retval ret_stuff
;
56 SAL_CALL_NOLOCK(ret_stuff
, (u64
) SN_SAL_IOIF_INTERRUPT
,
57 (u64
) SAL_INTR_FREE
, (u64
) local_nasid
,
58 (u64
) local_widget
, (u64
) sn_irq_info
->irq_irq
,
59 (u64
) sn_irq_info
->irq_cookie
, 0, 0);
62 static unsigned int sn_startup_irq(unsigned int irq
)
67 static void sn_shutdown_irq(unsigned int irq
)
71 static void sn_disable_irq(unsigned int irq
)
75 static void sn_enable_irq(unsigned int irq
)
79 static void sn_ack_irq(unsigned int irq
)
81 u64 event_occurred
, mask
;
84 event_occurred
= HUB_L((u64
*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED
));
85 mask
= event_occurred
& SH_ALL_INT_MASK
;
86 HUB_S((u64
*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS
), mask
);
87 __set_bit(irq
, (volatile void *)pda
->sn_in_service_ivecs
);
92 static void sn_end_irq(unsigned int irq
)
98 if (ivec
== SGI_UART_VECTOR
) {
99 event_occurred
= HUB_L((u64
*)LOCAL_MMR_ADDR (SH_EVENT_OCCURRED
));
100 /* If the UART bit is set here, we may have received an
101 * interrupt from the UART that the driver missed. To
102 * make sure, we IPI ourselves to force us to look again.
104 if (event_occurred
& SH_EVENT_OCCURRED_UART_INT_MASK
) {
105 platform_send_ipi(smp_processor_id(), SGI_UART_VECTOR
,
109 __clear_bit(ivec
, (volatile void *)pda
->sn_in_service_ivecs
);
110 if (sn_force_interrupt_flag
)
111 force_interrupt(irq
);
114 static void sn_irq_info_free(struct rcu_head
*head
);
116 struct sn_irq_info
*sn_retarget_vector(struct sn_irq_info
*sn_irq_info
,
117 nasid_t nasid
, int slice
)
125 int local_widget
, status
;
127 struct sn_irq_info
*new_irq_info
;
128 struct sn_pcibus_provider
*pci_provider
;
130 new_irq_info
= kmalloc(sizeof(struct sn_irq_info
), GFP_ATOMIC
);
131 if (new_irq_info
== NULL
)
134 memcpy(new_irq_info
, sn_irq_info
, sizeof(struct sn_irq_info
));
136 bridge
= (u64
) new_irq_info
->irq_bridge
;
139 return NULL
; /* irq is not a device interrupt */
142 local_nasid
= NASID_GET(bridge
);
145 local_widget
= TIO_SWIN_WIDGETNUM(bridge
);
147 local_widget
= SWIN_WIDGETNUM(bridge
);
149 vector
= sn_irq_info
->irq_irq
;
150 /* Free the old PROM new_irq_info structure */
151 sn_intr_free(local_nasid
, local_widget
, new_irq_info
);
152 unregister_intr_pda(new_irq_info
);
154 /* allocate a new PROM new_irq_info struct */
155 status
= sn_intr_alloc(local_nasid
, local_widget
,
156 new_irq_info
, vector
,
159 /* SAL call failed */
165 /* Update kernels new_irq_info with new target info */
166 cpuid
= nasid_slice_to_cpuid(new_irq_info
->irq_nasid
,
167 new_irq_info
->irq_slice
);
168 new_irq_info
->irq_cpuid
= cpuid
;
169 register_intr_pda(new_irq_info
);
171 pci_provider
= sn_pci_provider
[new_irq_info
->irq_bridge_type
];
174 * If this represents a line interrupt, target it. If it's
175 * an msi (irq_int_bit < 0), it's already targeted.
177 if (new_irq_info
->irq_int_bit
>= 0 &&
178 pci_provider
&& pci_provider
->target_interrupt
)
179 (pci_provider
->target_interrupt
)(new_irq_info
);
181 spin_lock(&sn_irq_info_lock
);
182 list_replace_rcu(&sn_irq_info
->list
, &new_irq_info
->list
);
183 spin_unlock(&sn_irq_info_lock
);
184 call_rcu(&sn_irq_info
->rcu
, sn_irq_info_free
);
187 cpuphys
= cpu_physical_id(cpuid
);
188 set_irq_affinity_info((vector
& 0xff), cpuphys
, 0);
194 static void sn_set_affinity_irq(unsigned int irq
, cpumask_t mask
)
196 struct sn_irq_info
*sn_irq_info
, *sn_irq_info_safe
;
200 nasid
= cpuid_to_nasid(first_cpu(mask
));
201 slice
= cpuid_to_slice(first_cpu(mask
));
203 list_for_each_entry_safe(sn_irq_info
, sn_irq_info_safe
,
204 sn_irq_lh
[irq
], list
)
205 (void)sn_retarget_vector(sn_irq_info
, nasid
, slice
);
209 sn_mask_irq(unsigned int irq
)
214 sn_unmask_irq(unsigned int irq
)
218 struct irq_chip irq_type_sn
= {
220 .startup
= sn_startup_irq
,
221 .shutdown
= sn_shutdown_irq
,
222 .enable
= sn_enable_irq
,
223 .disable
= sn_disable_irq
,
227 .unmask
= sn_unmask_irq
,
228 .set_affinity
= sn_set_affinity_irq
231 unsigned int sn_local_vector_to_irq(u8 vector
)
233 return (CPU_VECTOR_TO_IRQ(smp_processor_id(), vector
));
236 void sn_irq_init(void)
239 irq_desc_t
*base_desc
= irq_desc
;
241 ia64_first_device_vector
= IA64_SN2_FIRST_DEVICE_VECTOR
;
242 ia64_last_device_vector
= IA64_SN2_LAST_DEVICE_VECTOR
;
244 for (i
= 0; i
< NR_IRQS
; i
++) {
245 if (base_desc
[i
].chip
== &no_irq_type
) {
246 base_desc
[i
].chip
= &irq_type_sn
;
251 static void register_intr_pda(struct sn_irq_info
*sn_irq_info
)
253 int irq
= sn_irq_info
->irq_irq
;
254 int cpu
= sn_irq_info
->irq_cpuid
;
256 if (pdacpu(cpu
)->sn_last_irq
< irq
) {
257 pdacpu(cpu
)->sn_last_irq
= irq
;
260 if (pdacpu(cpu
)->sn_first_irq
== 0 || pdacpu(cpu
)->sn_first_irq
> irq
)
261 pdacpu(cpu
)->sn_first_irq
= irq
;
264 static void unregister_intr_pda(struct sn_irq_info
*sn_irq_info
)
266 int irq
= sn_irq_info
->irq_irq
;
267 int cpu
= sn_irq_info
->irq_cpuid
;
268 struct sn_irq_info
*tmp_irq_info
;
272 if (pdacpu(cpu
)->sn_last_irq
== irq
) {
274 for (i
= pdacpu(cpu
)->sn_last_irq
- 1;
275 i
&& !foundmatch
; i
--) {
276 list_for_each_entry_rcu(tmp_irq_info
,
279 if (tmp_irq_info
->irq_cpuid
== cpu
) {
285 pdacpu(cpu
)->sn_last_irq
= i
;
288 if (pdacpu(cpu
)->sn_first_irq
== irq
) {
290 for (i
= pdacpu(cpu
)->sn_first_irq
+ 1;
291 i
< NR_IRQS
&& !foundmatch
; i
++) {
292 list_for_each_entry_rcu(tmp_irq_info
,
295 if (tmp_irq_info
->irq_cpuid
== cpu
) {
301 pdacpu(cpu
)->sn_first_irq
= ((i
== NR_IRQS
) ? 0 : i
);
306 static void sn_irq_info_free(struct rcu_head
*head
)
308 struct sn_irq_info
*sn_irq_info
;
310 sn_irq_info
= container_of(head
, struct sn_irq_info
, rcu
);
314 void sn_irq_fixup(struct pci_dev
*pci_dev
, struct sn_irq_info
*sn_irq_info
)
316 nasid_t nasid
= sn_irq_info
->irq_nasid
;
317 int slice
= sn_irq_info
->irq_slice
;
318 int cpu
= nasid_slice_to_cpuid(nasid
, slice
);
323 pci_dev_get(pci_dev
);
324 sn_irq_info
->irq_cpuid
= cpu
;
325 sn_irq_info
->irq_pciioinfo
= SN_PCIDEV_INFO(pci_dev
);
327 /* link it into the sn_irq[irq] list */
328 spin_lock(&sn_irq_info_lock
);
329 list_add_rcu(&sn_irq_info
->list
, sn_irq_lh
[sn_irq_info
->irq_irq
]);
330 reserve_irq_vector(sn_irq_info
->irq_irq
);
331 spin_unlock(&sn_irq_info_lock
);
333 register_intr_pda(sn_irq_info
);
335 cpuphys
= cpu_physical_id(cpu
);
336 set_irq_affinity_info(sn_irq_info
->irq_irq
, cpuphys
, 0);
340 void sn_irq_unfixup(struct pci_dev
*pci_dev
)
342 struct sn_irq_info
*sn_irq_info
;
344 /* Only cleanup IRQ stuff if this device has a host bus context */
345 if (!SN_PCIDEV_BUSSOFT(pci_dev
))
348 sn_irq_info
= SN_PCIDEV_INFO(pci_dev
)->pdi_sn_irq_info
;
351 if (!sn_irq_info
->irq_irq
) {
356 unregister_intr_pda(sn_irq_info
);
357 spin_lock(&sn_irq_info_lock
);
358 list_del_rcu(&sn_irq_info
->list
);
359 spin_unlock(&sn_irq_info_lock
);
360 if (list_empty(sn_irq_lh
[sn_irq_info
->irq_irq
]))
361 free_irq_vector(sn_irq_info
->irq_irq
);
362 call_rcu(&sn_irq_info
->rcu
, sn_irq_info_free
);
363 pci_dev_put(pci_dev
);
368 sn_call_force_intr_provider(struct sn_irq_info
*sn_irq_info
)
370 struct sn_pcibus_provider
*pci_provider
;
372 pci_provider
= sn_pci_provider
[sn_irq_info
->irq_bridge_type
];
373 if (pci_provider
&& pci_provider
->force_interrupt
)
374 (*pci_provider
->force_interrupt
)(sn_irq_info
);
377 static void force_interrupt(int irq
)
379 struct sn_irq_info
*sn_irq_info
;
385 list_for_each_entry_rcu(sn_irq_info
, sn_irq_lh
[irq
], list
)
386 sn_call_force_intr_provider(sn_irq_info
);
392 * Check for lost interrupts. If the PIC int_status reg. says that
393 * an interrupt has been sent, but not handled, and the interrupt
394 * is not pending in either the cpu irr regs or in the soft irr regs,
395 * and the interrupt is not in service, then the interrupt may have
396 * been lost. Force an interrupt on that pin. It is possible that
397 * the interrupt is in flight, so we may generate a spurious interrupt,
398 * but we should never miss a real lost interrupt.
400 static void sn_check_intr(int irq
, struct sn_irq_info
*sn_irq_info
)
403 struct pcidev_info
*pcidev_info
;
404 struct pcibus_info
*pcibus_info
;
407 * Bridge types attached to TIO (anything but PIC) do not need this WAR
408 * since they do not target Shub II interrupt registers. If that
409 * ever changes, this check needs to accomodate.
411 if (sn_irq_info
->irq_bridge_type
!= PCIIO_ASIC_TYPE_PIC
)
414 pcidev_info
= (struct pcidev_info
*)sn_irq_info
->irq_pciioinfo
;
419 (struct pcibus_info
*)pcidev_info
->pdi_host_pcidev_info
->
421 regval
= pcireg_intr_status_get(pcibus_info
);
423 if (!ia64_get_irr(irq_to_vector(irq
))) {
424 if (!test_bit(irq
, pda
->sn_in_service_ivecs
)) {
426 if (sn_irq_info
->irq_int_bit
& regval
&
427 sn_irq_info
->irq_last_intr
) {
428 regval
&= ~(sn_irq_info
->irq_int_bit
& regval
);
429 sn_call_force_intr_provider(sn_irq_info
);
433 sn_irq_info
->irq_last_intr
= regval
;
436 void sn_lb_int_war_check(void)
438 struct sn_irq_info
*sn_irq_info
;
441 if (!sn_ioif_inited
|| pda
->sn_first_irq
== 0)
445 for (i
= pda
->sn_first_irq
; i
<= pda
->sn_last_irq
; i
++) {
446 list_for_each_entry_rcu(sn_irq_info
, sn_irq_lh
[i
], list
) {
447 sn_check_intr(i
, sn_irq_info
);
453 void __init
sn_irq_lh_init(void)
457 sn_irq_lh
= kmalloc(sizeof(struct list_head
*) * NR_IRQS
, GFP_KERNEL
);
459 panic("SN PCI INIT: Failed to allocate memory for PCI init\n");
461 for (i
= 0; i
< NR_IRQS
; i
++) {
462 sn_irq_lh
[i
] = kmalloc(sizeof(struct list_head
), GFP_KERNEL
);
464 panic("SN PCI INIT: Failed IRQ memory allocation\n");
466 INIT_LIST_HEAD(sn_irq_lh
[i
]);