?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.10pre5
[davej-history.git] / drivers / isdn / hisax / avm_a1.c
blobe782708fb74472f65e5be7edb98d20460c6d78c3
1 /* $Id: avm_a1.c,v 2.10 1998/11/15 23:54:21 keil Exp $
2
3 * avm_a1.c low level stuff for AVM A1 (Fritz) isdn cards
4 *
5 * Author Karsten Keil (keil@isdn4linux.de)
6 *
7 *
8 * $Log: avm_a1.c,v $
9 * Revision 2.10 1998/11/15 23:54:21 keil
10 * changes from 2.0
11 *
12 * Revision 2.9 1998/08/13 23:36:12 keil
13 * HiSax 3.1 - don't work stable with current LinkLevel
14 *
15 * Revision 2.8 1998/04/15 16:44:27 keil
16 * new init code
17 *
18 * Revision 2.7 1998/02/02 13:29:37 keil
19 * fast io
20 *
21 * Revision 2.6 1998/01/13 23:09:46 keil
22 * really disable timer
23 *
24 * Revision 2.5 1998/01/02 06:50:29 calle
25 * Perodic timer of A1 now disabled, no need for linux driver.
26 *
27 * Revision 2.4 1997/11/08 21:35:42 keil
28 * new l1 init
29 *
30 * Revision 2.3 1997/11/06 17:13:32 keil
31 * New 2.1 init code
32 *
33 * Revision 2.2 1997/10/29 18:55:48 keil
34 * changes for 2.1.60 (irq2dev_map)
35 *
36 * Revision 2.1 1997/07/27 21:47:13 keil
37 * new interface structures
38 *
39 * Revision 2.0 1997/06/26 11:02:48 keil
40 * New Layer and card interface
41 *
42 * Revision 1.6 1997/04/13 19:54:07 keil
43 * Change in IRQ check delay for SMP
44 *
45 * Revision 1.5 1997/04/06 22:54:10 keil
46 * Using SKB's
47 *
48 * Revision 1.4 1997/01/27 15:50:21 keil
49 * SMP proof,cosmetics
50 *
51 * Revision 1.3 1997/01/21 22:14:20 keil
52 * cleanups
53 *
54 * Revision 1.2 1996/10/27 22:07:31 keil
55 * cosmetic changes
56 *
57 * Revision 1.1 1996/10/13 20:04:49 keil
58 * Initial revision
59 *
60 *
61 */
62 #define __NO_VERSION__
63 #include "hisax.h"
64 #include "isac.h"
65 #include "hscx.h"
66 #include "isdnl1.h"
67
68 extern const char *CardType[];
69 static const char *avm_revision = "$Revision: 2.10 $";
70
71 #define AVM_A1_STAT_ISAC 0x01
72 #define AVM_A1_STAT_HSCX 0x02
73 #define AVM_A1_STAT_TIMER 0x04
74
75 #define byteout(addr,val) outb(val,addr)
76 #define bytein(addr) inb(addr)
77
78 static inline u_char
79 readreg(unsigned int adr, u_char off)
80 {
81 return (bytein(adr + off));
82 }
83
84 static inline void
85 writereg(unsigned int adr, u_char off, u_char data)
86 {
87 byteout(adr + off, data);
88 }
89
90
91 static inline void
92 read_fifo(unsigned int adr, u_char * data, int size)
93 {
94 insb(adr, data, size);
95 }
96
97 static void
98 write_fifo(unsigned int adr, u_char * data, int size)
99 {
100 outsb(adr, data, size);
101 }
102
103 /* Interface functions */
104
105 static u_char
106 ReadISAC(struct IsdnCardState *cs, u_char offset)
107 {
108 return (readreg(cs->hw.avm.isac, offset));
109 }
110
111 static void
112 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
113 {
114 writereg(cs->hw.avm.isac, offset, value);
115 }
116
117 static void
118 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
119 {
120 read_fifo(cs->hw.avm.isacfifo, data, size);
121 }
122
123 static void
124 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
125 {
126 write_fifo(cs->hw.avm.isacfifo, data, size);
127 }
128
129 static u_char
130 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
131 {
132 return (readreg(cs->hw.avm.hscx[hscx], offset));
133 }
134
135 static void
136 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
137 {
138 writereg(cs->hw.avm.hscx[hscx], offset, value);
139 }
140
141 /*
142 * fast interrupt HSCX stuff goes here
143 */
144
145 #define READHSCX(cs, nr, reg) readreg(cs->hw.avm.hscx[nr], reg)
146 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.avm.hscx[nr], reg, data)
147 #define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
148 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
149
150 #include "hscx_irq.c"
151
152 static void
153 avm_a1_interrupt(int intno, void *dev_id, struct pt_regs *regs)
154 {
155 struct IsdnCardState *cs = dev_id;
156 u_char val, sval, stat = 0;
157
158 if (!cs) {
159 printk(KERN_WARNING "AVM A1: Spurious interrupt!\n");
160 return;
161 }
162 while (((sval = bytein(cs->hw.avm.cfg_reg)) & 0xf) != 0x7) {
163 if (!(sval & AVM_A1_STAT_TIMER)) {
164 byteout(cs->hw.avm.cfg_reg, 0x1E);
165 sval = bytein(cs->hw.avm.cfg_reg);
166 } else if (cs->debug & L1_DEB_INTSTAT)
167 debugl1(cs, "avm IntStatus %x", sval);
168 if (!(sval & AVM_A1_STAT_HSCX)) {
169 val = readreg(cs->hw.avm.hscx[1], HSCX_ISTA);
170 if (val) {
171 hscx_int_main(cs, val);
172 stat |= 1;
173 }
174 }
175 if (!(sval & AVM_A1_STAT_ISAC)) {
176 val = readreg(cs->hw.avm.isac, ISAC_ISTA);
177 if (val) {
178 isac_interrupt(cs, val);
179 stat |= 2;
180 }
181 }
182 }
183 if (stat & 1) {
184 writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0xFF);
185 writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0xFF);
186 writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0x0);
187 writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0x0);
188 }
189 if (stat & 2) {
190 writereg(cs->hw.avm.isac, ISAC_MASK, 0xFF);
191 writereg(cs->hw.avm.isac, ISAC_MASK, 0x0);
192 }
193 }
194
195 inline static void
196 release_ioregs(struct IsdnCardState *cs, int mask)
197 {
198 release_region(cs->hw.avm.cfg_reg, 8);
199 if (mask & 1)
200 release_region(cs->hw.avm.isac + 32, 32);
201 if (mask & 2)
202 release_region(cs->hw.avm.isacfifo, 1);
203 if (mask & 4)
204 release_region(cs->hw.avm.hscx[0] + 32, 32);
205 if (mask & 8)
206 release_region(cs->hw.avm.hscxfifo[0], 1);
207 if (mask & 0x10)
208 release_region(cs->hw.avm.hscx[1] + 32, 32);
209 if (mask & 0x20)
210 release_region(cs->hw.avm.hscxfifo[1], 1);
211 }
212
213 static int
214 AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
215 {
216 switch (mt) {
217 case CARD_RESET:
218 return(0);
219 case CARD_RELEASE:
220 release_ioregs(cs, 0x3f);
221 return(0);
222 case CARD_SETIRQ:
223 return(request_irq(cs->irq, &avm_a1_interrupt,
224 I4L_IRQ_FLAG, "HiSax", cs));
225 case CARD_INIT:
226 inithscxisac(cs, 1);
227 byteout(cs->hw.avm.cfg_reg, 0x16);
228 byteout(cs->hw.avm.cfg_reg, 0x1E);
229 inithscxisac(cs, 2);
230 return(0);
231 case CARD_TEST:
232 return(0);
233 }
234 return(0);
235 }
236
237 int __init
238 setup_avm_a1(struct IsdnCard *card)
239 {
240 u_char val;
241 struct IsdnCardState *cs = card->cs;
242 long flags;
243 char tmp[64];
244
245 strcpy(tmp, avm_revision);
246 printk(KERN_INFO "HiSax: AVM driver Rev. %s\n", HiSax_getrev(tmp));
247 if (cs->typ != ISDN_CTYPE_A1)
248 return (0);
249
250 cs->hw.avm.cfg_reg = card->para[1] + 0x1800;
251 cs->hw.avm.isac = card->para[1] + 0x1400 - 0x20;
252 cs->hw.avm.hscx[0] = card->para[1] + 0x400 - 0x20;
253 cs->hw.avm.hscx[1] = card->para[1] + 0xc00 - 0x20;
254 cs->hw.avm.isacfifo = card->para[1] + 0x1000;
255 cs->hw.avm.hscxfifo[0] = card->para[1];
256 cs->hw.avm.hscxfifo[1] = card->para[1] + 0x800;
257 cs->irq = card->para[0];
258 if (check_region((cs->hw.avm.cfg_reg), 8)) {
259 printk(KERN_WARNING
260 "HiSax: %s config port %x-%x already in use\n",
261 CardType[card->typ],
262 cs->hw.avm.cfg_reg,
263 cs->hw.avm.cfg_reg + 8);
264 return (0);
265 } else {
266 request_region(cs->hw.avm.cfg_reg, 8, "avm cfg");
267 }
268 if (check_region((cs->hw.avm.isac + 32), 32)) {
269 printk(KERN_WARNING
270 "HiSax: %s isac ports %x-%x already in use\n",
271 CardType[cs->typ],
272 cs->hw.avm.isac + 32,
273 cs->hw.avm.isac + 64);
274 release_ioregs(cs, 0);
275 return (0);
276 } else {
277 request_region(cs->hw.avm.isac + 32, 32, "HiSax isac");
278 }
279 if (check_region((cs->hw.avm.isacfifo), 1)) {
280 printk(KERN_WARNING
281 "HiSax: %s isac fifo port %x already in use\n",
282 CardType[cs->typ],
283 cs->hw.avm.isacfifo);
284 release_ioregs(cs, 1);
285 return (0);
286 } else {
287 request_region(cs->hw.avm.isacfifo, 1, "HiSax isac fifo");
288 }
289 if (check_region((cs->hw.avm.hscx[0]) + 32, 32)) {
290 printk(KERN_WARNING
291 "HiSax: %s hscx A ports %x-%x already in use\n",
292 CardType[cs->typ],
293 cs->hw.avm.hscx[0] + 32,
294 cs->hw.avm.hscx[0] + 64);
295 release_ioregs(cs, 3);
296 return (0);
297 } else {
298 request_region(cs->hw.avm.hscx[0] + 32, 32, "HiSax hscx A");
299 }
300 if (check_region(cs->hw.avm.hscxfifo[0], 1)) {
301 printk(KERN_WARNING
302 "HiSax: %s hscx A fifo port %x already in use\n",
303 CardType[cs->typ],
304 cs->hw.avm.hscxfifo[0]);
305 release_ioregs(cs, 7);
306 return (0);
307 } else {
308 request_region(cs->hw.avm.hscxfifo[0], 1, "HiSax hscx A fifo");
309 }
310 if (check_region(cs->hw.avm.hscx[1] + 32, 32)) {
311 printk(KERN_WARNING
312 "HiSax: %s hscx B ports %x-%x already in use\n",
313 CardType[cs->typ],
314 cs->hw.avm.hscx[1] + 32,
315 cs->hw.avm.hscx[1] + 64);
316 release_ioregs(cs, 0xf);
317 return (0);
318 } else {
319 request_region(cs->hw.avm.hscx[1] + 32, 32, "HiSax hscx B");
320 }
321 if (check_region(cs->hw.avm.hscxfifo[1], 1)) {
322 printk(KERN_WARNING
323 "HiSax: %s hscx B fifo port %x already in use\n",
324 CardType[cs->typ],
325 cs->hw.avm.hscxfifo[1]);
326 release_ioregs(cs, 0x1f);
327 return (0);
328 } else {
329 request_region(cs->hw.avm.hscxfifo[1], 1, "HiSax hscx B fifo");
330 }
331 save_flags(flags);
332 byteout(cs->hw.avm.cfg_reg, 0x0);
333 sti();
334 HZDELAY(HZ / 5 + 1);
335 byteout(cs->hw.avm.cfg_reg, 0x1);
336 HZDELAY(HZ / 5 + 1);
337 byteout(cs->hw.avm.cfg_reg, 0x0);
338 HZDELAY(HZ / 5 + 1);
339 val = cs->irq;
340 if (val == 9)
341 val = 2;
342 byteout(cs->hw.avm.cfg_reg + 1, val);
343 HZDELAY(HZ / 5 + 1);
344 byteout(cs->hw.avm.cfg_reg, 0x0);
345 HZDELAY(HZ / 5 + 1);
346 restore_flags(flags);
347
348 val = bytein(cs->hw.avm.cfg_reg);
349 printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
350 cs->hw.avm.cfg_reg, val);
351 val = bytein(cs->hw.avm.cfg_reg + 3);
352 printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
353 cs->hw.avm.cfg_reg + 3, val);
354 val = bytein(cs->hw.avm.cfg_reg + 2);
355 printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
356 cs->hw.avm.cfg_reg + 2, val);
357 val = bytein(cs->hw.avm.cfg_reg);
358 printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
359 cs->hw.avm.cfg_reg, val);
360
361 printk(KERN_INFO
362 "HiSax: %s config irq:%d cfg:0x%X\n",
363 CardType[cs->typ], cs->irq,
364 cs->hw.avm.cfg_reg);
365 printk(KERN_INFO
366 "HiSax: isac:0x%X/0x%X\n",
367 cs->hw.avm.isac + 32, cs->hw.avm.isacfifo);
368 printk(KERN_INFO
369 "HiSax: hscx A:0x%X/0x%X hscx B:0x%X/0x%X\n",
370 cs->hw.avm.hscx[0] + 32, cs->hw.avm.hscxfifo[0],
371 cs->hw.avm.hscx[1] + 32, cs->hw.avm.hscxfifo[1]);
372
373 cs->readisac = &ReadISAC;
374 cs->writeisac = &WriteISAC;
375 cs->readisacfifo = &ReadISACfifo;
376 cs->writeisacfifo = &WriteISACfifo;
377 cs->BC_Read_Reg = &ReadHSCX;
378 cs->BC_Write_Reg = &WriteHSCX;
379 cs->BC_Send_Data = &hscx_fill_fifo;
380 cs->cardmsg = &AVM_card_msg;
381 ISACVersion(cs, "AVM A1:");
382 if (HscxVersion(cs, "AVM A1:")) {
383 printk(KERN_WARNING
384 "AVM A1: wrong HSCX versions check IO address\n");
385 release_ioregs(cs, 0x3f);
386 return (0);
387 }
388 return (1);
389 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux