Linux-2.6.12-rc2
[linux-3.10.git] / arch / alpha / kernel / sys_wildfire.c
1 /*
2  *  linux/arch/alpha/kernel/sys_wildfire.c
3  *
4  *  Wildfire support.
5  *
6  *  Copyright (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/mm.h>
12 #include <linux/sched.h>
13 #include <linux/pci.h>
14 #include <linux/init.h>
15 #include <linux/bitops.h>
16
17 #include <asm/ptrace.h>
18 #include <asm/system.h>
19 #include <asm/dma.h>
20 #include <asm/irq.h>
21 #include <asm/mmu_context.h>
22 #include <asm/io.h>
23 #include <asm/pgtable.h>
24 #include <asm/core_wildfire.h>
25 #include <asm/hwrpb.h>
26 #include <asm/tlbflush.h>
27
28 #include "proto.h"
29 #include "irq_impl.h"
30 #include "pci_impl.h"
31 #include "machvec_impl.h"
32
33 static unsigned long cached_irq_mask[WILDFIRE_NR_IRQS/(sizeof(long)*8)];
34
35 DEFINE_SPINLOCK(wildfire_irq_lock);
36
37 static int doing_init_irq_hw = 0;
38
39 static void
40 wildfire_update_irq_hw(unsigned int irq)
41 {
42         int qbbno = (irq >> 8) & (WILDFIRE_MAX_QBB - 1);
43         int pcano = (irq >> 6) & (WILDFIRE_PCA_PER_QBB - 1);
44         wildfire_pca *pca;
45         volatile unsigned long * enable0;
46
47         if (!WILDFIRE_PCA_EXISTS(qbbno, pcano)) {
48                 if (!doing_init_irq_hw) {
49                         printk(KERN_ERR "wildfire_update_irq_hw:"
50                                " got irq %d for non-existent PCA %d"
51                                " on QBB %d.\n",
52                                irq, pcano, qbbno);
53                 }
54                 return;
55         }
56
57         pca = WILDFIRE_pca(qbbno, pcano);
58         enable0 = (unsigned long *) &pca->pca_int[0].enable; /* ??? */
59
60         *enable0 = cached_irq_mask[qbbno * WILDFIRE_PCA_PER_QBB + pcano];
61         mb();
62         *enable0;
63 }
64
65 static void __init
66 wildfire_init_irq_hw(void)
67 {
68 #if 0
69         register wildfire_pca * pca = WILDFIRE_pca(0, 0);
70         volatile unsigned long * enable0, * enable1, * enable2, *enable3;
71         volatile unsigned long * target0, * target1, * target2, *target3;
72
73         enable0 = (unsigned long *) &pca->pca_int[0].enable;
74         enable1 = (unsigned long *) &pca->pca_int[1].enable;
75         enable2 = (unsigned long *) &pca->pca_int[2].enable;
76         enable3 = (unsigned long *) &pca->pca_int[3].enable;
77
78         target0 = (unsigned long *) &pca->pca_int[0].target;
79         target1 = (unsigned long *) &pca->pca_int[1].target;
80         target2 = (unsigned long *) &pca->pca_int[2].target;
81         target3 = (unsigned long *) &pca->pca_int[3].target;
82
83         *enable0 = *enable1 = *enable2 = *enable3 = 0;
84
85         *target0 = (1UL<<8) | WILDFIRE_QBB(0);
86         *target1 = *target2 = *target3 = 0;
87
88         mb();
89
90         *enable0; *enable1; *enable2; *enable3;
91         *target0; *target1; *target2; *target3;
92
93 #else
94         int i;
95
96         doing_init_irq_hw = 1;
97
98         /* Need to update only once for every possible PCA. */
99         for (i = 0; i < WILDFIRE_NR_IRQS; i+=WILDFIRE_IRQ_PER_PCA)
100                 wildfire_update_irq_hw(i);
101
102         doing_init_irq_hw = 0;
103 #endif
104 }
105
106 static void
107 wildfire_enable_irq(unsigned int irq)
108 {
109         if (irq < 16)
110                 i8259a_enable_irq(irq);
111
112         spin_lock(&wildfire_irq_lock);
113         set_bit(irq, &cached_irq_mask);
114         wildfire_update_irq_hw(irq);
115         spin_unlock(&wildfire_irq_lock);
116 }
117
118 static void
119 wildfire_disable_irq(unsigned int irq)
120 {
121         if (irq < 16)
122                 i8259a_disable_irq(irq);
123
124         spin_lock(&wildfire_irq_lock);
125         clear_bit(irq, &cached_irq_mask);
126         wildfire_update_irq_hw(irq);
127         spin_unlock(&wildfire_irq_lock);
128 }
129
130 static void
131 wildfire_mask_and_ack_irq(unsigned int irq)
132 {
133         if (irq < 16)
134                 i8259a_mask_and_ack_irq(irq);
135
136         spin_lock(&wildfire_irq_lock);
137         clear_bit(irq, &cached_irq_mask);
138         wildfire_update_irq_hw(irq);
139         spin_unlock(&wildfire_irq_lock);
140 }
141
142 static unsigned int
143 wildfire_startup_irq(unsigned int irq)
144
145         wildfire_enable_irq(irq);
146         return 0; /* never anything pending */
147 }
148
149 static void
150 wildfire_end_irq(unsigned int irq)
151
152 #if 0
153         if (!irq_desc[irq].action)
154                 printk("got irq %d\n", irq);
155 #endif
156         if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
157                 wildfire_enable_irq(irq);
158 }
159
160 static struct hw_interrupt_type wildfire_irq_type = {
161         .typename       = "WILDFIRE",
162         .startup        = wildfire_startup_irq,
163         .shutdown       = wildfire_disable_irq,
164         .enable         = wildfire_enable_irq,
165         .disable        = wildfire_disable_irq,
166         .ack            = wildfire_mask_and_ack_irq,
167         .end            = wildfire_end_irq,
168 };
169
170 static void __init
171 wildfire_init_irq_per_pca(int qbbno, int pcano)
172 {
173         int i, irq_bias;
174         unsigned long io_bias;
175         static struct irqaction isa_enable = {
176                 .handler        = no_action,
177                 .name           = "isa_enable",
178         };
179
180         irq_bias = qbbno * (WILDFIRE_PCA_PER_QBB * WILDFIRE_IRQ_PER_PCA)
181                  + pcano * WILDFIRE_IRQ_PER_PCA;
182
183         /* Only need the following for first PCI bus per PCA. */
184         io_bias = WILDFIRE_IO(qbbno, pcano<<1) - WILDFIRE_IO_BIAS;
185
186 #if 0
187         outb(0, DMA1_RESET_REG + io_bias);
188         outb(0, DMA2_RESET_REG + io_bias);
189         outb(DMA_MODE_CASCADE, DMA2_MODE_REG + io_bias);
190         outb(0, DMA2_MASK_REG + io_bias);
191 #endif
192
193 #if 0
194         /* ??? Not sure how to do this, yet... */
195         init_i8259a_irqs(); /* ??? */
196 #endif
197
198         for (i = 0; i < 16; ++i) {
199                 if (i == 2)
200                         continue;
201                 irq_desc[i+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
202                 irq_desc[i+irq_bias].handler = &wildfire_irq_type;
203         }
204
205         irq_desc[36+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
206         irq_desc[36+irq_bias].handler = &wildfire_irq_type;
207         for (i = 40; i < 64; ++i) {
208                 irq_desc[i+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
209                 irq_desc[i+irq_bias].handler = &wildfire_irq_type;
210         }
211
212         setup_irq(32+irq_bias, &isa_enable);    
213 }
214
215 static void __init
216 wildfire_init_irq(void)
217 {
218         int qbbno, pcano;
219
220 #if 1
221         wildfire_init_irq_hw();
222         init_i8259a_irqs();
223 #endif
224
225         for (qbbno = 0; qbbno < WILDFIRE_MAX_QBB; qbbno++) {
226           if (WILDFIRE_QBB_EXISTS(qbbno)) {
227             for (pcano = 0; pcano < WILDFIRE_PCA_PER_QBB; pcano++) {
228               if (WILDFIRE_PCA_EXISTS(qbbno, pcano)) {
229                 wildfire_init_irq_per_pca(qbbno, pcano);
230               }
231             }
232           }
233         }
234 }
235
236 static void 
237 wildfire_device_interrupt(unsigned long vector, struct pt_regs * regs)
238 {
239         int irq;
240
241         irq = (vector - 0x800) >> 4;
242
243         /*
244          * bits 10-8:   source QBB ID
245          * bits 7-6:    PCA
246          * bits 5-0:    irq in PCA
247          */
248
249         handle_irq(irq, regs);
250         return;
251 }
252
253 /*
254  * PCI Fixup configuration.
255  *
256  * Summary per PCA (2 PCI or HIPPI buses):
257  *
258  * Bit      Meaning
259  * 0-15     ISA
260  *
261  *32        ISA summary
262  *33        SMI
263  *34        NMI
264  *36        builtin QLogic SCSI (or slot 0 if no IO module)
265  *40        Interrupt Line A from slot 2 PCI0
266  *41        Interrupt Line B from slot 2 PCI0
267  *42        Interrupt Line C from slot 2 PCI0
268  *43        Interrupt Line D from slot 2 PCI0
269  *44        Interrupt Line A from slot 3 PCI0
270  *45        Interrupt Line B from slot 3 PCI0
271  *46        Interrupt Line C from slot 3 PCI0
272  *47        Interrupt Line D from slot 3 PCI0
273  *
274  *48        Interrupt Line A from slot 4 PCI1
275  *49        Interrupt Line B from slot 4 PCI1
276  *50        Interrupt Line C from slot 4 PCI1
277  *51        Interrupt Line D from slot 4 PCI1
278  *52        Interrupt Line A from slot 5 PCI1
279  *53        Interrupt Line B from slot 5 PCI1
280  *54        Interrupt Line C from slot 5 PCI1
281  *55        Interrupt Line D from slot 5 PCI1
282  *56        Interrupt Line A from slot 6 PCI1
283  *57        Interrupt Line B from slot 6 PCI1
284  *58        Interrupt Line C from slot 6 PCI1
285  *50        Interrupt Line D from slot 6 PCI1
286  *60        Interrupt Line A from slot 7 PCI1
287  *61        Interrupt Line B from slot 7 PCI1
288  *62        Interrupt Line C from slot 7 PCI1
289  *63        Interrupt Line D from slot 7 PCI1
290  * 
291  *
292  * IdSel        
293  *   0   Cypress Bridge I/O (ISA summary interrupt)
294  *   1   64 bit PCI 0 option slot 1 (SCSI QLogic builtin)
295  *   2   64 bit PCI 0 option slot 2
296  *   3   64 bit PCI 0 option slot 3
297  *   4   64 bit PCI 1 option slot 4
298  *   5   64 bit PCI 1 option slot 5
299  *   6   64 bit PCI 1 option slot 6
300  *   7   64 bit PCI 1 option slot 7
301  */
302
303 static int __init
304 wildfire_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
305 {
306         static char irq_tab[8][5] __initdata = {
307                 /*INT    INTA   INTB   INTC   INTD */
308                 { -1,    -1,    -1,    -1,    -1}, /* IdSel 0 ISA Bridge */
309                 { 36,    36,    36+1, 36+2, 36+3}, /* IdSel 1 SCSI builtin */
310                 { 40,    40,    40+1, 40+2, 40+3}, /* IdSel 2 PCI 0 slot 2 */
311                 { 44,    44,    44+1, 44+2, 44+3}, /* IdSel 3 PCI 0 slot 3 */
312                 { 48,    48,    48+1, 48+2, 48+3}, /* IdSel 4 PCI 1 slot 4 */
313                 { 52,    52,    52+1, 52+2, 52+3}, /* IdSel 5 PCI 1 slot 5 */
314                 { 56,    56,    56+1, 56+2, 56+3}, /* IdSel 6 PCI 1 slot 6 */
315                 { 60,    60,    60+1, 60+2, 60+3}, /* IdSel 7 PCI 1 slot 7 */
316         };
317         long min_idsel = 0, max_idsel = 7, irqs_per_slot = 5;
318
319         struct pci_controller *hose = dev->sysdata;
320         int irq = COMMON_TABLE_LOOKUP;
321
322         if (irq > 0) {
323                 int qbbno = hose->index >> 3;
324                 int pcano = (hose->index >> 1) & 3;
325                 irq += (qbbno << 8) + (pcano << 6);
326         }
327         return irq;
328 }
329
330
331 /*
332  * The System Vectors
333  */
334
335 struct alpha_machine_vector wildfire_mv __initmv = {
336         .vector_name            = "WILDFIRE",
337         DO_EV6_MMU,
338         DO_DEFAULT_RTC,
339         DO_WILDFIRE_IO,
340         .machine_check          = wildfire_machine_check,
341         .max_isa_dma_address    = ALPHA_MAX_ISA_DMA_ADDRESS,
342         .min_io_address         = DEFAULT_IO_BASE,
343         .min_mem_address        = DEFAULT_MEM_BASE,
344
345         .nr_irqs                = WILDFIRE_NR_IRQS,
346         .device_interrupt       = wildfire_device_interrupt,
347
348         .init_arch              = wildfire_init_arch,
349         .init_irq               = wildfire_init_irq,
350         .init_rtc               = common_init_rtc,
351         .init_pci               = common_init_pci,
352         .kill_arch              = wildfire_kill_arch,
353         .pci_map_irq            = wildfire_map_irq,
354         .pci_swizzle            = common_swizzle,
355
356         .pa_to_nid              = wildfire_pa_to_nid,
357         .cpuid_to_nid           = wildfire_cpuid_to_nid,
358         .node_mem_start         = wildfire_node_mem_start,
359         .node_mem_size          = wildfire_node_mem_size,
360 };
361 ALIAS_MV(wildfire)