Remove obsolete #include <linux/config.h>
[linux-2.6.git] / arch / sh / boards / overdrive / irq.c
1 /* 
2  * Copyright (C) 2000 David J. Mckay (david.mckay@st.com)
3  *
4  * May be copied or modified under the terms of the GNU General Public
5  * License.  See linux/COPYING for more information.                            
6  *
7  * Looks after interrupts on the overdrive board.
8  *
9  * Bases on the IPR irq system
10  */
11
12 #include <linux/init.h>
13 #include <linux/irq.h>
14
15 #include <asm/system.h>
16 #include <asm/io.h>
17
18 #include <asm/overdrive/overdrive.h>
19
20 struct od_data {
21         int overdrive_irq;
22         int irq_mask;
23 };
24
25 #define NUM_EXTERNAL_IRQS 16
26 #define EXTERNAL_IRQ_NOT_IN_USE (-1)
27 #define EXTERNAL_IRQ_NOT_ASSIGNED (-1)
28
29 /*
30  * This table is used to determine what to program into the FPGA's CT register
31  * for the specified Linux IRQ.
32  *
33  * The irq_mask gives the interrupt number from the PCI board (PCI_Int(6:0))
34  * but is one greater than that because the because the FPGA treats 0
35  * as disabled, a value of 1 asserts PCI_Int0, and so on.
36  *
37  * The overdrive_irq specifies which of the eight interrupt sources generates
38  * that interrupt, and but is multiplied by four to give the bit offset into
39  * the CT register.
40  *
41  * The seven interrupts levels (SH4 IRL's) we have available here is hardwired
42  * by the EPLD. The assignments here of which PCI interrupt generates each
43  * level is arbitary.
44  */
45 static struct od_data od_data_table[NUM_EXTERNAL_IRQS] = {
46         /*    overdrive_irq       , irq_mask */
47         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 0 */
48         {EXTERNAL_IRQ_NOT_ASSIGNED, 7}, /* 1 */
49         {EXTERNAL_IRQ_NOT_ASSIGNED, 6}, /* 2 */
50         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 3 */
51         {EXTERNAL_IRQ_NOT_ASSIGNED, 5}, /* 4 */
52         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 5 */
53         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 6 */
54         {EXTERNAL_IRQ_NOT_ASSIGNED, 4}, /* 7 */
55         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 8 */
56         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 9 */
57         {EXTERNAL_IRQ_NOT_ASSIGNED, 3}, /* 10 */
58         {EXTERNAL_IRQ_NOT_ASSIGNED, 2}, /* 11 */
59         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 12 */
60         {EXTERNAL_IRQ_NOT_ASSIGNED, 1}, /* 13 */
61         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE},   /* 14 */
62         {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}    /* 15 */
63 };
64
65 static void set_od_data(int overdrive_irq, int irq)
66 {
67         if (irq >= NUM_EXTERNAL_IRQS || irq < 0)
68                 return;
69         od_data_table[irq].overdrive_irq = overdrive_irq << 2;
70 }
71
72 static void enable_od_irq(unsigned int irq);
73 void disable_od_irq(unsigned int irq);
74
75 /* shutdown is same as "disable" */
76 #define shutdown_od_irq disable_od_irq
77
78 static void mask_and_ack_od(unsigned int);
79 static void end_od_irq(unsigned int irq);
80
81 static unsigned int startup_od_irq(unsigned int irq)
82 {
83         enable_od_irq(irq);
84         return 0;               /* never anything pending */
85 }
86
87 static struct hw_interrupt_type od_irq_type = {
88         .typename = "Overdrive-IRQ",
89         .startup = startup_od_irq,
90         .shutdown = shutdown_od_irq,
91         .enable = enable_od_irq,
92         .disable = disable_od_irq,
93         .ack = mask_and_ack_od,
94         .end = end_od_irq
95 };
96
97 static void disable_od_irq(unsigned int irq)
98 {
99         unsigned val, flags;
100         int overdrive_irq;
101         unsigned mask;
102
103         /* Not a valid interrupt */
104         if (irq < 0 || irq >= NUM_EXTERNAL_IRQS)
105                 return;
106
107         /* Is is necessary to use a cli here? Would a spinlock not be 
108          * mroe efficient?
109          */
110         local_irq_save(flags);
111         overdrive_irq = od_data_table[irq].overdrive_irq;
112         if (overdrive_irq != EXTERNAL_IRQ_NOT_ASSIGNED) {
113                 mask = ~(0x7 << overdrive_irq);
114                 val = ctrl_inl(OVERDRIVE_INT_CT);
115                 val &= mask;
116                 ctrl_outl(val, OVERDRIVE_INT_CT);
117         }
118         local_irq_restore(flags);
119 }
120
121 static void enable_od_irq(unsigned int irq)
122 {
123         unsigned val, flags;
124         int overdrive_irq;
125         unsigned mask;
126
127         /* Not a valid interrupt */
128         if (irq < 0 || irq >= NUM_EXTERNAL_IRQS)
129                 return;
130
131         /* Set priority in OD back to original value */
132         local_irq_save(flags);
133         /* This one is not in use currently */
134         overdrive_irq = od_data_table[irq].overdrive_irq;
135         if (overdrive_irq != EXTERNAL_IRQ_NOT_ASSIGNED) {
136                 val = ctrl_inl(OVERDRIVE_INT_CT);
137                 mask = ~(0x7 << overdrive_irq);
138                 val &= mask;
139                 mask = od_data_table[irq].irq_mask << overdrive_irq;
140                 val |= mask;
141                 ctrl_outl(val, OVERDRIVE_INT_CT);
142         }
143         local_irq_restore(flags);
144 }
145
146
147
148 /* this functions sets the desired irq handler to be an overdrive type */
149 static void __init make_od_irq(unsigned int irq)
150 {
151         disable_irq_nosync(irq);
152         irq_desc[irq].chip = &od_irq_type;
153         disable_od_irq(irq);
154 }
155
156
157 static void mask_and_ack_od(unsigned int irq)
158 {
159         disable_od_irq(irq);
160 }
161
162 static void end_od_irq(unsigned int irq)
163 {
164         enable_od_irq(irq);
165 }
166
167 void __init init_overdrive_irq(void)
168 {
169         int i;
170
171         /* Disable all interrupts */
172         ctrl_outl(0, OVERDRIVE_INT_CT);
173
174         /* Update interrupt pin mode to use encoded interrupts */
175         i = ctrl_inw(INTC_ICR);
176         i &= ~INTC_ICR_IRLM;
177         ctrl_outw(i, INTC_ICR);
178
179         for (i = 0; i < NUM_EXTERNAL_IRQS; i++) {
180                 if (od_data_table[i].irq_mask != EXTERNAL_IRQ_NOT_IN_USE) {
181                         make_od_irq(i);
182                 } else if (i != 15) {   // Cannot use imask on level 15
183                         make_imask_irq(i);
184                 }
185         }
186
187         /* Set up the interrupts */
188         set_od_data(OVERDRIVE_PCI_INTA, OVERDRIVE_PCI_IRQ1);
189         set_od_data(OVERDRIVE_PCI_INTB, OVERDRIVE_PCI_IRQ2);
190         set_od_data(OVERDRIVE_AUDIO_INT, OVERDRIVE_ESS_IRQ);
191 }