1 /*
2 * Interrupt management for most GSC and related devices.
3 *
4 * (c) Copyright 1999 Alex deVries for The Puffin Group
5 * (c) Copyright 1999 Grant Grundler for Hewlett-Packard
6 * (c) Copyright 1999 Matthew Wilcox
7 * (c) Copyright 2000 Helge Deller
8 * (c) Copyright 2001 Matthew Wilcox for Hewlett-Packard
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15
16 #include <linux/bitops.h>
17 #include <linux/config.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/interrupt.h>
21 #include <linux/ioport.h>
22 #include <linux/slab.h>
23 #include <linux/types.h>
24
25 #include <asm/gsc.h>
26 #include <asm/hardware.h>
27 #include <asm/io.h>
28 #include <asm/irq.h>
29
30 #include "busdevice.h"
31
32 #undef DEBUG
33
34 #ifdef DEBUG
35 #define DEBPRINTK printk
36 #else
37 #define DEBPRINTK(x,...)
38 #endif
39
gsc_alloc_irq(struct gsc_irq * i)40 int gsc_alloc_irq(struct gsc_irq *i)
41 {
42 int irq = txn_alloc_irq();
43 if (irq < 0) {
44 printk("cannot get irq\n");
45 return irq;
46 }
47
48 i->txn_addr = txn_alloc_addr(irq);
49 i->txn_data = txn_alloc_data(irq, GSC_EIM_WIDTH);
50 i->irq = irq;
51
52 return irq;
53 }
54
55
gsc_claim_irq(struct gsc_irq * i,int irq)56 int gsc_claim_irq(struct gsc_irq *i, int irq)
57 {
58 int c = irq;
59
60 irq += IRQ_FROM_REGION(CPU_IRQ_REGION); /* virtualize the IRQ first */
61
62 irq = txn_claim_irq(irq);
63 if (irq < 0) {
64 printk("cannot claim irq %d\n", c);
65 return irq;
66 }
67
68 i->txn_addr = txn_alloc_addr(irq);
69 i->txn_data = txn_alloc_data(irq, GSC_EIM_WIDTH);
70 i->irq = irq;
71
72 return irq;
73 }
74
75
76 /* IRQ bits must be numbered from Most Significant Bit */
77 #define GSC_FIX_IRQ(x) (31-(x))
78 #define GSC_MASK_IRQ(x) (1<<(GSC_FIX_IRQ(x)))
79
80 /* Common interrupt demultiplexer used by Asp, Lasi & Wax. */
busdev_barked(int busdev_irq,void * dev,struct pt_regs * regs)81 void busdev_barked(int busdev_irq, void *dev, struct pt_regs *regs)
82 {
83 unsigned long irq;
84 struct busdevice *busdev = (struct busdevice *) dev;
85
86 /*
87 Don't need to protect OFFSET_IRR with spinlock since this is
88 the only place it's touched.
89 Protect busdev_region by disabling this region's interrupts,
90 modifying the region, and then re-enabling the region.
91 */
92
93 irq = gsc_readl(busdev->hpa+OFFSET_IRR);
94 if (irq == 0) {
95 printk(KERN_ERR "%s: barking without apparent reason.\n", busdev->name);
96 } else {
97 DEBPRINTK ("%s (0x%x) barked, mask=0x%x, irq=%d\n",
98 busdev->name, busdev->busdev_region->data.irqbase,
99 irq, GSC_FIX_IRQ(ffs(irq))+1 );
100
101 do_irq_mask(irq, busdev->busdev_region, regs);
102 }
103 }
104
105 static void
busdev_disable_irq(void * irq_dev,int irq)106 busdev_disable_irq(void *irq_dev, int irq)
107 {
108 /* Disable the IRQ line by clearing the bit in the IMR */
109 u32 imr = gsc_readl(BUSDEV_DEV(irq_dev)->hpa+OFFSET_IMR);
110 imr &= ~(GSC_MASK_IRQ(irq));
111
112 DEBPRINTK( KERN_WARNING "%s(%p, %d) %s: IMR 0x%x\n",
113 __FUNCTION__, irq_dev, irq, BUSDEV_DEV(irq_dev)->name, imr);
114
115 gsc_writel(imr, BUSDEV_DEV(irq_dev)->hpa+OFFSET_IMR);
116 }
117
118
119 static void
busdev_enable_irq(void * irq_dev,int irq)120 busdev_enable_irq(void *irq_dev, int irq)
121 {
122 /* Enable the IRQ line by setting the bit in the IMR */
123 unsigned long addr = BUSDEV_DEV(irq_dev)->hpa + OFFSET_IMR;
124 u32 imr = gsc_readl(addr);
125 imr |= GSC_MASK_IRQ(irq);
126
127 DEBPRINTK (KERN_WARNING "%s(%p, %d) %s: IMR 0x%x\n",
128 __FUNCTION__, irq_dev, irq, BUSDEV_DEV(irq_dev)->name, imr);
129
130 gsc_writel(imr, addr);
131 // gsc_writel(~0L, addr);
132
133 /* FIXME: read IPR to make sure the IRQ isn't already pending.
134 ** If so, we need to read IRR and manually call do_irq_mask().
135 ** This code should be shared with busdev_unmask_irq().
136 */
137 }
138
139 static void
busdev_mask_irq(void * irq_dev,int irq)140 busdev_mask_irq(void *irq_dev, int irq)
141 {
142 /* FIXME: Clear the IMR bit in busdev for that IRQ */
143 }
144
145 static void
busdev_unmask_irq(void * irq_dev,int irq)146 busdev_unmask_irq(void *irq_dev, int irq)
147 {
148 /* FIXME: Read IPR. Set the IMR bit in busdev for that IRQ.
149 call do_irq_mask() if IPR is non-zero
150 */
151 }
152
153 struct irq_region_ops busdev_irq_ops = {
154 disable_irq: busdev_disable_irq,
155 enable_irq: busdev_enable_irq,
156 mask_irq: busdev_mask_irq,
157 unmask_irq: busdev_unmask_irq
158 };
159
160
gsc_common_irqsetup(struct parisc_device * parent,struct busdevice * busdev)161 int gsc_common_irqsetup(struct parisc_device *parent, struct busdevice *busdev)
162 {
163 struct resource *res;
164
165 busdev->gsc = parent;
166
167 /* the IRQs we simulate */
168 busdev->busdev_region = alloc_irq_region(32, &busdev_irq_ops,
169 busdev->name, busdev);
170 if (!busdev->busdev_region)
171 return -ENOMEM;
172
173 /* allocate resource region */
174 res = request_mem_region(busdev->hpa, 0x100000, busdev->name);
175 if (res) {
176 res->flags = IORESOURCE_MEM; /* do not mark it busy ! */
177 }
178
179 #if 0
180 printk(KERN_WARNING "%s IRQ %d EIM 0x%x", busdev->name,
181 busdev->parent_irq, busdev->eim);
182 if (gsc_readl(busdev->hpa + OFFSET_IMR))
183 printk(" IMR is non-zero! (0x%x)",
184 gsc_readl(busdev->hpa + OFFSET_IMR));
185 printk("\n");
186 #endif
187
188 return 0;
189 }
190
191 extern struct parisc_driver lasi_driver;
192 extern struct parisc_driver asp_driver;
193 extern struct parisc_driver wax_driver;
194
gsc_init(void)195 void __init gsc_init(void)
196 {
197 #ifdef CONFIG_GSC_LASI
198 register_parisc_driver(&lasi_driver);
199 register_parisc_driver(&asp_driver);
200 #endif
201 #ifdef CONFIG_GSC_WAX
202 register_parisc_driver(&wax_driver);
203 #endif
204 }
205