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-2008 Silicon Graphics, Inc. All Rights Reserved.
11 #include <linux/irq.h>
12 #include <linux/spinlock.h>
13 #include <linux/init.h>
14 #include <linux/rculist.h>
15 #include <asm/sn/addrs.h>
16 #include <asm/sn/arch.h>
17 #include <asm/sn/intr.h>
18 #include <asm/sn/pcibr_provider.h>
19 #include <asm/sn/pcibus_provider_defs.h>
20 #include <asm/sn/pcidev.h>
21 #include <asm/sn/shub_mmr.h>
22 #include <asm/sn/sn_sal.h>
23 #include <asm/sn/sn_feature_sets.h>
25 static void force_interrupt(int irq
);
26 static void register_intr_pda(struct sn_irq_info
*sn_irq_info
);
27 static void unregister_intr_pda(struct sn_irq_info
*sn_irq_info
);
29 int sn_force_interrupt_flag
= 1;
30 extern int sn_ioif_inited
;
31 struct list_head
**sn_irq_lh
;
32 static DEFINE_SPINLOCK(sn_irq_info_lock
); /* non-IRQ lock */
34 u64
sn_intr_alloc(nasid_t local_nasid
, int local_widget
,
35 struct sn_irq_info
*sn_irq_info
,
36 int req_irq
, nasid_t req_nasid
,
39 struct ia64_sal_retval ret_stuff
;
43 SAL_CALL_NOLOCK(ret_stuff
, (u64
) SN_SAL_IOIF_INTERRUPT
,
44 (u64
) SAL_INTR_ALLOC
, (u64
) local_nasid
,
45 (u64
) local_widget
, __pa(sn_irq_info
), (u64
) req_irq
,
46 (u64
) req_nasid
, (u64
) req_slice
);
48 return ret_stuff
.status
;
51 void sn_intr_free(nasid_t local_nasid
, int local_widget
,
52 struct sn_irq_info
*sn_irq_info
)
54 struct ia64_sal_retval ret_stuff
;
58 SAL_CALL_NOLOCK(ret_stuff
, (u64
) SN_SAL_IOIF_INTERRUPT
,
59 (u64
) SAL_INTR_FREE
, (u64
) local_nasid
,
60 (u64
) local_widget
, (u64
) sn_irq_info
->irq_irq
,
61 (u64
) sn_irq_info
->irq_cookie
, 0, 0);
64 u64
sn_intr_redirect(nasid_t local_nasid
, int local_widget
,
65 struct sn_irq_info
*sn_irq_info
,
66 nasid_t req_nasid
, int req_slice
)
68 struct ia64_sal_retval ret_stuff
;
72 SAL_CALL_NOLOCK(ret_stuff
, (u64
) SN_SAL_IOIF_INTERRUPT
,
73 (u64
) SAL_INTR_REDIRECT
, (u64
) local_nasid
,
74 (u64
) local_widget
, __pa(sn_irq_info
),
75 (u64
) req_nasid
, (u64
) req_slice
, 0);
77 return ret_stuff
.status
;
80 static unsigned int sn_startup_irq(unsigned int irq
)
85 static void sn_shutdown_irq(unsigned int irq
)
89 extern void ia64_mca_register_cpev(int);
91 static void sn_disable_irq(unsigned int irq
)
93 if (irq
== local_vector_to_irq(IA64_CPE_VECTOR
))
94 ia64_mca_register_cpev(0);
97 static void sn_enable_irq(unsigned int irq
)
99 if (irq
== local_vector_to_irq(IA64_CPE_VECTOR
))
100 ia64_mca_register_cpev(irq
);
103 static void sn_ack_irq(unsigned int irq
)
105 u64 event_occurred
, mask
;
108 event_occurred
= HUB_L((u64
*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED
));
109 mask
= event_occurred
& SH_ALL_INT_MASK
;
110 HUB_S((u64
*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS
), mask
);
111 __set_bit(irq
, (volatile void *)pda
->sn_in_service_ivecs
);
113 move_native_irq(irq
);
116 static void sn_end_irq(unsigned int irq
)
122 if (ivec
== SGI_UART_VECTOR
) {
123 event_occurred
= HUB_L((u64
*)LOCAL_MMR_ADDR (SH_EVENT_OCCURRED
));
124 /* If the UART bit is set here, we may have received an
125 * interrupt from the UART that the driver missed. To
126 * make sure, we IPI ourselves to force us to look again.
128 if (event_occurred
& SH_EVENT_OCCURRED_UART_INT_MASK
) {
129 platform_send_ipi(smp_processor_id(), SGI_UART_VECTOR
,
133 __clear_bit(ivec
, (volatile void *)pda
->sn_in_service_ivecs
);
134 if (sn_force_interrupt_flag
)
135 force_interrupt(irq
);
138 static void sn_irq_info_free(struct rcu_head
*head
);
140 struct sn_irq_info
*sn_retarget_vector(struct sn_irq_info
*sn_irq_info
,
141 nasid_t nasid
, int slice
)
149 int local_widget
, status
;
151 struct sn_irq_info
*new_irq_info
;
152 struct sn_pcibus_provider
*pci_provider
;
154 bridge
= (u64
) sn_irq_info
->irq_bridge
;
156 return NULL
; /* irq is not a device interrupt */
159 local_nasid
= NASID_GET(bridge
);
162 local_widget
= TIO_SWIN_WIDGETNUM(bridge
);
164 local_widget
= SWIN_WIDGETNUM(bridge
);
165 vector
= sn_irq_info
->irq_irq
;
167 /* Make use of SAL_INTR_REDIRECT if PROM supports it */
168 status
= sn_intr_redirect(local_nasid
, local_widget
, sn_irq_info
, nasid
, slice
);
170 new_irq_info
= sn_irq_info
;
175 * PROM does not support SAL_INTR_REDIRECT, or it failed.
176 * Revert to old method.
178 new_irq_info
= kmalloc(sizeof(struct sn_irq_info
), GFP_ATOMIC
);
179 if (new_irq_info
== NULL
)
182 memcpy(new_irq_info
, sn_irq_info
, sizeof(struct sn_irq_info
));
184 /* Free the old PROM new_irq_info structure */
185 sn_intr_free(local_nasid
, local_widget
, new_irq_info
);
186 unregister_intr_pda(new_irq_info
);
188 /* allocate a new PROM new_irq_info struct */
189 status
= sn_intr_alloc(local_nasid
, local_widget
,
190 new_irq_info
, vector
,
193 /* SAL call failed */
199 register_intr_pda(new_irq_info
);
200 spin_lock(&sn_irq_info_lock
);
201 list_replace_rcu(&sn_irq_info
->list
, &new_irq_info
->list
);
202 spin_unlock(&sn_irq_info_lock
);
203 call_rcu(&sn_irq_info
->rcu
, sn_irq_info_free
);
207 /* Update kernels new_irq_info with new target info */
208 cpuid
= nasid_slice_to_cpuid(new_irq_info
->irq_nasid
,
209 new_irq_info
->irq_slice
);
210 new_irq_info
->irq_cpuid
= cpuid
;
212 pci_provider
= sn_pci_provider
[new_irq_info
->irq_bridge_type
];
215 * If this represents a line interrupt, target it. If it's
216 * an msi (irq_int_bit < 0), it's already targeted.
218 if (new_irq_info
->irq_int_bit
>= 0 &&
219 pci_provider
&& pci_provider
->target_interrupt
)
220 (pci_provider
->target_interrupt
)(new_irq_info
);
223 cpuphys
= cpu_physical_id(cpuid
);
224 set_irq_affinity_info((vector
& 0xff), cpuphys
, 0);
230 static void sn_set_affinity_irq(unsigned int irq
, const struct cpumask
*mask
)
232 struct sn_irq_info
*sn_irq_info
, *sn_irq_info_safe
;
236 nasid
= cpuid_to_nasid(cpumask_first(mask
));
237 slice
= cpuid_to_slice(cpumask_first(mask
));
239 list_for_each_entry_safe(sn_irq_info
, sn_irq_info_safe
,
240 sn_irq_lh
[irq
], list
)
241 (void)sn_retarget_vector(sn_irq_info
, nasid
, slice
);
245 void sn_set_err_irq_affinity(unsigned int irq
)
248 * On systems which support CPU disabling (SHub2), all error interrupts
249 * are targetted at the boot CPU.
251 if (is_shub2() && sn_prom_feature_available(PRF_CPU_DISABLE_SUPPORT
))
252 set_irq_affinity_info(irq
, cpu_physical_id(0), 0);
255 void sn_set_err_irq_affinity(unsigned int irq
) { }
259 sn_mask_irq(unsigned int irq
)
264 sn_unmask_irq(unsigned int irq
)
268 struct irq_chip irq_type_sn
= {
270 .startup
= sn_startup_irq
,
271 .shutdown
= sn_shutdown_irq
,
272 .enable
= sn_enable_irq
,
273 .disable
= sn_disable_irq
,
277 .unmask
= sn_unmask_irq
,
278 .set_affinity
= sn_set_affinity_irq
281 ia64_vector
sn_irq_to_vector(int irq
)
283 if (irq
>= IA64_NUM_VECTORS
)
285 return (ia64_vector
)irq
;
288 unsigned int sn_local_vector_to_irq(u8 vector
)
290 return (CPU_VECTOR_TO_IRQ(smp_processor_id(), vector
));
293 void sn_irq_init(void)
296 irq_desc_t
*base_desc
= irq_desc
;
298 ia64_first_device_vector
= IA64_SN2_FIRST_DEVICE_VECTOR
;
299 ia64_last_device_vector
= IA64_SN2_LAST_DEVICE_VECTOR
;
301 for (i
= 0; i
< NR_IRQS
; i
++) {
302 if (base_desc
[i
].chip
== &no_irq_type
) {
303 base_desc
[i
].chip
= &irq_type_sn
;
308 static void register_intr_pda(struct sn_irq_info
*sn_irq_info
)
310 int irq
= sn_irq_info
->irq_irq
;
311 int cpu
= sn_irq_info
->irq_cpuid
;
313 if (pdacpu(cpu
)->sn_last_irq
< irq
) {
314 pdacpu(cpu
)->sn_last_irq
= irq
;
317 if (pdacpu(cpu
)->sn_first_irq
== 0 || pdacpu(cpu
)->sn_first_irq
> irq
)
318 pdacpu(cpu
)->sn_first_irq
= irq
;
321 static void unregister_intr_pda(struct sn_irq_info
*sn_irq_info
)
323 int irq
= sn_irq_info
->irq_irq
;
324 int cpu
= sn_irq_info
->irq_cpuid
;
325 struct sn_irq_info
*tmp_irq_info
;
329 if (pdacpu(cpu
)->sn_last_irq
== irq
) {
331 for (i
= pdacpu(cpu
)->sn_last_irq
- 1;
332 i
&& !foundmatch
; i
--) {
333 list_for_each_entry_rcu(tmp_irq_info
,
336 if (tmp_irq_info
->irq_cpuid
== cpu
) {
342 pdacpu(cpu
)->sn_last_irq
= i
;
345 if (pdacpu(cpu
)->sn_first_irq
== irq
) {
347 for (i
= pdacpu(cpu
)->sn_first_irq
+ 1;
348 i
< NR_IRQS
&& !foundmatch
; i
++) {
349 list_for_each_entry_rcu(tmp_irq_info
,
352 if (tmp_irq_info
->irq_cpuid
== cpu
) {
358 pdacpu(cpu
)->sn_first_irq
= ((i
== NR_IRQS
) ? 0 : i
);
363 static void sn_irq_info_free(struct rcu_head
*head
)
365 struct sn_irq_info
*sn_irq_info
;
367 sn_irq_info
= container_of(head
, struct sn_irq_info
, rcu
);
371 void sn_irq_fixup(struct pci_dev
*pci_dev
, struct sn_irq_info
*sn_irq_info
)
373 nasid_t nasid
= sn_irq_info
->irq_nasid
;
374 int slice
= sn_irq_info
->irq_slice
;
375 int cpu
= nasid_slice_to_cpuid(nasid
, slice
);
381 pci_dev_get(pci_dev
);
382 sn_irq_info
->irq_cpuid
= cpu
;
383 sn_irq_info
->irq_pciioinfo
= SN_PCIDEV_INFO(pci_dev
);
385 /* link it into the sn_irq[irq] list */
386 spin_lock(&sn_irq_info_lock
);
387 list_add_rcu(&sn_irq_info
->list
, sn_irq_lh
[sn_irq_info
->irq_irq
]);
388 reserve_irq_vector(sn_irq_info
->irq_irq
);
389 spin_unlock(&sn_irq_info_lock
);
391 register_intr_pda(sn_irq_info
);
393 cpuphys
= cpu_physical_id(cpu
);
394 set_irq_affinity_info(sn_irq_info
->irq_irq
, cpuphys
, 0);
395 desc
= irq_to_desc(sn_irq_info
->irq_irq
);
397 * Affinity was set by the PROM, prevent it from
398 * being reset by the request_irq() path.
400 desc
->status
|= IRQ_AFFINITY_SET
;
404 void sn_irq_unfixup(struct pci_dev
*pci_dev
)
406 struct sn_irq_info
*sn_irq_info
;
408 /* Only cleanup IRQ stuff if this device has a host bus context */
409 if (!SN_PCIDEV_BUSSOFT(pci_dev
))
412 sn_irq_info
= SN_PCIDEV_INFO(pci_dev
)->pdi_sn_irq_info
;
415 if (!sn_irq_info
->irq_irq
) {
420 unregister_intr_pda(sn_irq_info
);
421 spin_lock(&sn_irq_info_lock
);
422 list_del_rcu(&sn_irq_info
->list
);
423 spin_unlock(&sn_irq_info_lock
);
424 if (list_empty(sn_irq_lh
[sn_irq_info
->irq_irq
]))
425 free_irq_vector(sn_irq_info
->irq_irq
);
426 call_rcu(&sn_irq_info
->rcu
, sn_irq_info_free
);
427 pci_dev_put(pci_dev
);
432 sn_call_force_intr_provider(struct sn_irq_info
*sn_irq_info
)
434 struct sn_pcibus_provider
*pci_provider
;
436 pci_provider
= sn_pci_provider
[sn_irq_info
->irq_bridge_type
];
438 /* Don't force an interrupt if the irq has been disabled */
439 if (!(irq_desc
[sn_irq_info
->irq_irq
].status
& IRQ_DISABLED
) &&
440 pci_provider
&& pci_provider
->force_interrupt
)
441 (*pci_provider
->force_interrupt
)(sn_irq_info
);
444 static void force_interrupt(int irq
)
446 struct sn_irq_info
*sn_irq_info
;
452 list_for_each_entry_rcu(sn_irq_info
, sn_irq_lh
[irq
], list
)
453 sn_call_force_intr_provider(sn_irq_info
);
459 * Check for lost interrupts. If the PIC int_status reg. says that
460 * an interrupt has been sent, but not handled, and the interrupt
461 * is not pending in either the cpu irr regs or in the soft irr regs,
462 * and the interrupt is not in service, then the interrupt may have
463 * been lost. Force an interrupt on that pin. It is possible that
464 * the interrupt is in flight, so we may generate a spurious interrupt,
465 * but we should never miss a real lost interrupt.
467 static void sn_check_intr(int irq
, struct sn_irq_info
*sn_irq_info
)
470 struct pcidev_info
*pcidev_info
;
471 struct pcibus_info
*pcibus_info
;
474 * Bridge types attached to TIO (anything but PIC) do not need this WAR
475 * since they do not target Shub II interrupt registers. If that
476 * ever changes, this check needs to accomodate.
478 if (sn_irq_info
->irq_bridge_type
!= PCIIO_ASIC_TYPE_PIC
)
481 pcidev_info
= (struct pcidev_info
*)sn_irq_info
->irq_pciioinfo
;
486 (struct pcibus_info
*)pcidev_info
->pdi_host_pcidev_info
->
488 regval
= pcireg_intr_status_get(pcibus_info
);
490 if (!ia64_get_irr(irq_to_vector(irq
))) {
491 if (!test_bit(irq
, pda
->sn_in_service_ivecs
)) {
493 if (sn_irq_info
->irq_int_bit
& regval
&
494 sn_irq_info
->irq_last_intr
) {
495 regval
&= ~(sn_irq_info
->irq_int_bit
& regval
);
496 sn_call_force_intr_provider(sn_irq_info
);
500 sn_irq_info
->irq_last_intr
= regval
;
503 void sn_lb_int_war_check(void)
505 struct sn_irq_info
*sn_irq_info
;
508 if (!sn_ioif_inited
|| pda
->sn_first_irq
== 0)
512 for (i
= pda
->sn_first_irq
; i
<= pda
->sn_last_irq
; i
++) {
513 list_for_each_entry_rcu(sn_irq_info
, sn_irq_lh
[i
], list
) {
514 sn_check_intr(i
, sn_irq_info
);
520 void __init
sn_irq_lh_init(void)
524 sn_irq_lh
= kmalloc(sizeof(struct list_head
*) * NR_IRQS
, GFP_KERNEL
);
526 panic("SN PCI INIT: Failed to allocate memory for PCI init\n");
528 for (i
= 0; i
< NR_IRQS
; i
++) {
529 sn_irq_lh
[i
] = kmalloc(sizeof(struct list_head
), GFP_KERNEL
);
531 panic("SN PCI INIT: Failed IRQ memory allocation\n");
533 INIT_LIST_HEAD(sn_irq_lh
[i
]);