[IA64-SGI] sn2-move-pci-headers.patch
[linux-2.6.git] / arch / ia64 / sn / pci / pcibr / pcibr_provider.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (C) 2001-2004 Silicon Graphics, Inc. All rights reserved.
7  */
8
9 #include <linux/types.h>
10 #include <linux/interrupt.h>
11 #include <linux/pci.h>
12 #include <asm/sn/sn_sal.h>
13 #include "xtalk/xwidgetdev.h"
14 #include <asm/sn/geo.h>
15 #include "xtalk/hubdev.h"
16 #include <asm/sn/pcibus_provider_defs.h>
17 #include <asm/sn/pcidev.h>
18 #include "pci/pcibr_provider.h"
19 #include <asm/sn/addrs.h>
20
21
22 static int sal_pcibr_error_interrupt(struct pcibus_info *soft)
23 {
24         struct ia64_sal_retval ret_stuff;
25         uint64_t busnum;
26         int segment;
27         ret_stuff.status = 0;
28         ret_stuff.v0 = 0;
29
30         segment = 0;
31         busnum = soft->pbi_buscommon.bs_persist_busnum;
32         SAL_CALL_NOLOCK(ret_stuff,
33                         (u64) SN_SAL_IOIF_ERROR_INTERRUPT,
34                         (u64) segment, (u64) busnum, 0, 0, 0, 0, 0);
35
36         return (int)ret_stuff.v0;
37 }
38
39 /* 
40  * PCI Bridge Error interrupt handler.  Gets invoked whenever a PCI 
41  * bridge sends an error interrupt.
42  */
43 static irqreturn_t
44 pcibr_error_intr_handler(int irq, void *arg, struct pt_regs *regs)
45 {
46         struct pcibus_info *soft = (struct pcibus_info *)arg;
47
48         if (sal_pcibr_error_interrupt(soft) < 0) {
49                 panic("pcibr_error_intr_handler(): Fatal Bridge Error");
50         }
51         return IRQ_HANDLED;
52 }
53
54 void *
55 pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft)
56 {
57         int nasid, cnode, j;
58         struct hubdev_info *hubdev_info;
59         struct pcibus_info *soft;
60         struct sn_flush_device_list *sn_flush_device_list;
61
62         if (! IS_PCI_BRIDGE_ASIC(prom_bussoft->bs_asic_type)) {
63                 return NULL;
64         }
65
66         /*
67          * Allocate kernel bus soft and copy from prom.
68          */
69
70         soft = kmalloc(sizeof(struct pcibus_info), GFP_KERNEL);
71         if (!soft) {
72                 return NULL;
73         }
74
75         memcpy(soft, prom_bussoft, sizeof(struct pcibus_info));
76         soft->pbi_buscommon.bs_base =
77             (((u64) soft->pbi_buscommon.
78               bs_base << 4) >> 4) | __IA64_UNCACHED_OFFSET;
79
80         spin_lock_init(&soft->pbi_lock);
81
82         /*
83          * register the bridge's error interrupt handler
84          */
85         if (request_irq(SGI_PCIBR_ERROR, (void *)pcibr_error_intr_handler,
86                         SA_SHIRQ, "PCIBR error", (void *)(soft))) {
87                 printk(KERN_WARNING
88                        "pcibr cannot allocate interrupt for error handler\n");
89         }
90
91         /* 
92          * Update the Bridge with the "kernel" pagesize 
93          */
94         if (PAGE_SIZE < 16384) {
95                 pcireg_control_bit_clr(soft, PCIBR_CTRL_PAGE_SIZE);
96         } else {
97                 pcireg_control_bit_set(soft, PCIBR_CTRL_PAGE_SIZE);
98         }
99
100         nasid = NASID_GET(soft->pbi_buscommon.bs_base);
101         cnode = nasid_to_cnodeid(nasid);
102         hubdev_info = (struct hubdev_info *)(NODEPDA(cnode)->pdinfo);
103
104         if (hubdev_info->hdi_flush_nasid_list.widget_p) {
105                 sn_flush_device_list = hubdev_info->hdi_flush_nasid_list.
106                     widget_p[(int)soft->pbi_buscommon.bs_xid];
107                 if (sn_flush_device_list) {
108                         for (j = 0; j < DEV_PER_WIDGET;
109                              j++, sn_flush_device_list++) {
110                                 if (sn_flush_device_list->sfdl_slot == -1)
111                                         continue;
112                                 if (sn_flush_device_list->
113                                     sfdl_persistent_busnum ==
114                                     soft->pbi_buscommon.bs_persist_busnum)
115                                         sn_flush_device_list->sfdl_pcibus_info =
116                                             soft;
117                         }
118                 }
119         }
120
121         /* Setup the PMU ATE map */
122         soft->pbi_int_ate_resource.lowest_free_index = 0;
123         soft->pbi_int_ate_resource.ate =
124             kmalloc(soft->pbi_int_ate_size * sizeof(uint64_t), GFP_KERNEL);
125         memset(soft->pbi_int_ate_resource.ate, 0,
126                (soft->pbi_int_ate_size * sizeof(uint64_t)));
127
128         return soft;
129 }
130
131 void pcibr_force_interrupt(struct sn_irq_info *sn_irq_info)
132 {
133         struct pcidev_info *pcidev_info;
134         struct pcibus_info *pcibus_info;
135         int bit = sn_irq_info->irq_int_bit;
136
137         pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
138         if (pcidev_info) {
139                 pcibus_info =
140                     (struct pcibus_info *)pcidev_info->pdi_host_pcidev_info->
141                     pdi_pcibus_info;
142                 pcireg_force_intr_set(pcibus_info, bit);
143         }
144 }
145
146 void pcibr_change_devices_irq(struct sn_irq_info *sn_irq_info)
147 {
148         struct pcidev_info *pcidev_info;
149         struct pcibus_info *pcibus_info;
150         int bit = sn_irq_info->irq_int_bit;
151         uint64_t xtalk_addr = sn_irq_info->irq_xtalkaddr;
152
153         pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
154         if (pcidev_info) {
155                 pcibus_info =
156                     (struct pcibus_info *)pcidev_info->pdi_host_pcidev_info->
157                     pdi_pcibus_info;
158
159                 /* Disable the device's IRQ   */
160                 pcireg_intr_enable_bit_clr(pcibus_info, bit);
161
162                 /* Change the device's IRQ    */
163                 pcireg_intr_addr_addr_set(pcibus_info, bit, xtalk_addr);
164
165                 /* Re-enable the device's IRQ */
166                 pcireg_intr_enable_bit_set(pcibus_info, bit);
167
168                 pcibr_force_interrupt(sn_irq_info);
169         }
170 }
171
172 /*
173  * Provider entries for PIC/CP
174  */
175
176 struct sn_pcibus_provider pcibr_provider = {
177         .dma_map = pcibr_dma_map,
178         .dma_map_consistent = pcibr_dma_map_consistent,
179         .dma_unmap = pcibr_dma_unmap,
180         .bus_fixup = pcibr_bus_fixup,
181 };
182
183 int
184 pcibr_init_provider(void)
185 {
186         sn_pci_provider[PCIIO_ASIC_TYPE_PIC] = &pcibr_provider;
187         sn_pci_provider[PCIIO_ASIC_TYPE_TIOCP] = &pcibr_provider;
188
189         return 0;
190 }