?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / isdn / hisax / teles3.c
blob6a5e379e077418a385b7aaa453c17e9df9ee8d41
1 /* $Id: teles3.c,v 2.19.2.4 2004/01/13 23:48:39 keil Exp $
2 *
3 * low level stuff for Teles 16.3 & PNP isdn cards
4 *
5 * Author Karsten Keil
6 * Copyright by Karsten Keil <keil@isdn4linux.de>
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Thanks to Jan den Ouden
12 * Fritz Elfert
13 * Beat Doebeli
14 *
15 */
16 #include <linux/init.h>
17 #include <linux/isapnp.h>
18 #include "hisax.h"
19 #include "isac.h"
20 #include "hscx.h"
21 #include "isdnl1.h"
22
23 extern const char *CardType[];
24 static const char *teles3_revision = "$Revision: 2.19.2.4 $";
25
26 #define byteout(addr,val) outb(val,addr)
27 #define bytein(addr) inb(addr)
28
29 static inline u_char
30 readreg(unsigned int adr, u_char off)
31 {
32 return (bytein(adr + off));
33 }
34
35 static inline void
36 writereg(unsigned int adr, u_char off, u_char data)
37 {
38 byteout(adr + off, data);
39 }
40
41
42 static inline void
43 read_fifo(unsigned int adr, u_char * data, int size)
44 {
45 insb(adr, data, size);
46 }
47
48 static void
49 write_fifo(unsigned int adr, u_char * data, int size)
50 {
51 outsb(adr, data, size);
52 }
53
54 /* Interface functions */
55
56 static u_char
57 ReadISAC(struct IsdnCardState *cs, u_char offset)
58 {
59 return (readreg(cs->hw.teles3.isac, offset));
60 }
61
62 static void
63 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
64 {
65 writereg(cs->hw.teles3.isac, offset, value);
66 }
67
68 static void
69 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
70 {
71 read_fifo(cs->hw.teles3.isacfifo, data, size);
72 }
73
74 static void
75 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
76 {
77 write_fifo(cs->hw.teles3.isacfifo, data, size);
78 }
79
80 static u_char
81 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
82 {
83 return (readreg(cs->hw.teles3.hscx[hscx], offset));
84 }
85
86 static void
87 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
88 {
89 writereg(cs->hw.teles3.hscx[hscx], offset, value);
90 }
91
92 /*
93 * fast interrupt HSCX stuff goes here
94 */
95
96 #define READHSCX(cs, nr, reg) readreg(cs->hw.teles3.hscx[nr], reg)
97 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.teles3.hscx[nr], reg, data)
98 #define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.teles3.hscxfifo[nr], ptr, cnt)
99 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.teles3.hscxfifo[nr], ptr, cnt)
100
101 #include "hscx_irq.c"
102
103 static irqreturn_t
104 teles3_interrupt(int intno, void *dev_id)
105 {
106 #define MAXCOUNT 5
107 struct IsdnCardState *cs = dev_id;
108 u_char val;
109 u_long flags;
110 int count = 0;
111
112 spin_lock_irqsave(&cs->lock, flags);
113 val = readreg(cs->hw.teles3.hscx[1], HSCX_ISTA);
114 Start_HSCX:
115 if (val)
116 hscx_int_main(cs, val);
117 val = readreg(cs->hw.teles3.isac, ISAC_ISTA);
118 Start_ISAC:
119 if (val)
120 isac_interrupt(cs, val);
121 count++;
122 val = readreg(cs->hw.teles3.hscx[1], HSCX_ISTA);
123 if (val && count < MAXCOUNT) {
124 if (cs->debug & L1_DEB_HSCX)
125 debugl1(cs, "HSCX IntStat after IntRoutine");
126 goto Start_HSCX;
127 }
128 val = readreg(cs->hw.teles3.isac, ISAC_ISTA);
129 if (val && count < MAXCOUNT) {
130 if (cs->debug & L1_DEB_ISAC)
131 debugl1(cs, "ISAC IntStat after IntRoutine");
132 goto Start_ISAC;
133 }
134 if (count >= MAXCOUNT)
135 printk(KERN_WARNING "Teles3: more than %d loops in teles3_interrupt\n", count);
136 writereg(cs->hw.teles3.hscx[0], HSCX_MASK, 0xFF);
137 writereg(cs->hw.teles3.hscx[1], HSCX_MASK, 0xFF);
138 writereg(cs->hw.teles3.isac, ISAC_MASK, 0xFF);
139 writereg(cs->hw.teles3.isac, ISAC_MASK, 0x0);
140 writereg(cs->hw.teles3.hscx[0], HSCX_MASK, 0x0);
141 writereg(cs->hw.teles3.hscx[1], HSCX_MASK, 0x0);
142 spin_unlock_irqrestore(&cs->lock, flags);
143 return IRQ_HANDLED;
144 }
145
146 static inline void
147 release_ioregs(struct IsdnCardState *cs, int mask)
148 {
149 if (mask & 1)
150 release_region(cs->hw.teles3.isac + 32, 32);
151 if (mask & 2)
152 release_region(cs->hw.teles3.hscx[0] + 32, 32);
153 if (mask & 4)
154 release_region(cs->hw.teles3.hscx[1] + 32, 32);
155 }
156
157 static void
158 release_io_teles3(struct IsdnCardState *cs)
159 {
160 if (cs->typ == ISDN_CTYPE_TELESPCMCIA) {
161 release_region(cs->hw.teles3.hscx[1], 96);
162 } else {
163 if (cs->hw.teles3.cfg_reg) {
164 if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
165 release_region(cs->hw.teles3.cfg_reg, 1);
166 } else {
167 release_region(cs->hw.teles3.cfg_reg, 8);
168 }
169 }
170 release_ioregs(cs, 0x7);
171 }
172 }
173
174 static int
175 reset_teles3(struct IsdnCardState *cs)
176 {
177 u_char irqcfg;
178
179 if (cs->typ != ISDN_CTYPE_TELESPCMCIA) {
180 if ((cs->hw.teles3.cfg_reg) && (cs->typ != ISDN_CTYPE_COMPAQ_ISA)) {
181 switch (cs->irq) {
182 case 2:
183 case 9:
184 irqcfg = 0x00;
185 break;
186 case 3:
187 irqcfg = 0x02;
188 break;
189 case 4:
190 irqcfg = 0x04;
191 break;
192 case 5:
193 irqcfg = 0x06;
194 break;
195 case 10:
196 irqcfg = 0x08;
197 break;
198 case 11:
199 irqcfg = 0x0A;
200 break;
201 case 12:
202 irqcfg = 0x0C;
203 break;
204 case 15:
205 irqcfg = 0x0E;
206 break;
207 default:
208 return(1);
209 }
210 byteout(cs->hw.teles3.cfg_reg + 4, irqcfg);
211 HZDELAY(HZ / 10 + 1);
212 byteout(cs->hw.teles3.cfg_reg + 4, irqcfg | 1);
213 HZDELAY(HZ / 10 + 1);
214 } else if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
215 byteout(cs->hw.teles3.cfg_reg, 0xff);
216 HZDELAY(2);
217 byteout(cs->hw.teles3.cfg_reg, 0x00);
218 HZDELAY(2);
219 } else {
220 /* Reset off for 16.3 PnP , thanks to Georg Acher */
221 byteout(cs->hw.teles3.isac + 0x3c, 0);
222 HZDELAY(2);
223 byteout(cs->hw.teles3.isac + 0x3c, 1);
224 HZDELAY(2);
225 }
226 }
227 return(0);
228 }
229
230 static int
231 Teles_card_msg(struct IsdnCardState *cs, int mt, void *arg)
232 {
233 u_long flags;
234
235 switch (mt) {
236 case CARD_RESET:
237 spin_lock_irqsave(&cs->lock, flags);
238 reset_teles3(cs);
239 spin_unlock_irqrestore(&cs->lock, flags);
240 return(0);
241 case CARD_RELEASE:
242 release_io_teles3(cs);
243 return(0);
244 case CARD_INIT:
245 spin_lock_irqsave(&cs->lock, flags);
246 inithscxisac(cs, 3);
247 spin_unlock_irqrestore(&cs->lock, flags);
248 return(0);
249 case CARD_TEST:
250 return(0);
251 }
252 return(0);
253 }
254
255 #ifdef __ISAPNP__
256
257 static struct isapnp_device_id teles_ids[] __devinitdata = {
258 { ISAPNP_VENDOR('T', 'A', 'G'), ISAPNP_FUNCTION(0x2110),
259 ISAPNP_VENDOR('T', 'A', 'G'), ISAPNP_FUNCTION(0x2110),
260 (unsigned long) "Teles 16.3 PnP" },
261 { ISAPNP_VENDOR('C', 'T', 'X'), ISAPNP_FUNCTION(0x0),
262 ISAPNP_VENDOR('C', 'T', 'X'), ISAPNP_FUNCTION(0x0),
263 (unsigned long) "Creatix 16.3 PnP" },
264 { ISAPNP_VENDOR('C', 'P', 'Q'), ISAPNP_FUNCTION(0x1002),
265 ISAPNP_VENDOR('C', 'P', 'Q'), ISAPNP_FUNCTION(0x1002),
266 (unsigned long) "Compaq ISDN S0" },
267 { 0, }
268 };
269
270 static struct isapnp_device_id *ipid __devinitdata = &teles_ids[0];
271 static struct pnp_card *pnp_c __devinitdata = NULL;
272 #endif
273
274 int __devinit
275 setup_teles3(struct IsdnCard *card)
276 {
277 u_char val;
278 struct IsdnCardState *cs = card->cs;
279 char tmp[64];
280
281 strcpy(tmp, teles3_revision);
282 printk(KERN_INFO "HiSax: Teles IO driver Rev. %s\n", HiSax_getrev(tmp));
283 if ((cs->typ != ISDN_CTYPE_16_3) && (cs->typ != ISDN_CTYPE_PNP)
284 && (cs->typ != ISDN_CTYPE_TELESPCMCIA) && (cs->typ != ISDN_CTYPE_COMPAQ_ISA))
285 return (0);
286
287 #ifdef __ISAPNP__
288 if (!card->para[1] && isapnp_present()) {
289 struct pnp_dev *pnp_d;
290 while(ipid->card_vendor) {
291 if ((pnp_c = pnp_find_card(ipid->card_vendor,
292 ipid->card_device, pnp_c))) {
293 pnp_d = NULL;
294 if ((pnp_d = pnp_find_dev(pnp_c,
295 ipid->vendor, ipid->function, pnp_d))) {
296 int err;
297
298 printk(KERN_INFO "HiSax: %s detected\n",
299 (char *)ipid->driver_data);
300 pnp_disable_dev(pnp_d);
301 err = pnp_activate_dev(pnp_d);
302 if (err<0) {
303 printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
304 __FUNCTION__, err);
305 return(0);
306 }
307 card->para[3] = pnp_port_start(pnp_d, 2);
308 card->para[2] = pnp_port_start(pnp_d, 1);
309 card->para[1] = pnp_port_start(pnp_d, 0);
310 card->para[0] = pnp_irq(pnp_d, 0);
311 if (!card->para[0] || !card->para[1] || !card->para[2]) {
312 printk(KERN_ERR "Teles PnP:some resources are missing %ld/%lx/%lx\n",
313 card->para[0], card->para[1], card->para[2]);
314 pnp_disable_dev(pnp_d);
315 return(0);
316 }
317 break;
318 } else {
319 printk(KERN_ERR "Teles PnP: PnP error card found, no device\n");
320 }
321 }
322 ipid++;
323 pnp_c = NULL;
324 }
325 if (!ipid->card_vendor) {
326 printk(KERN_INFO "Teles PnP: no ISAPnP card found\n");
327 return(0);
328 }
329 }
330 #endif
331 if (cs->typ == ISDN_CTYPE_16_3) {
332 cs->hw.teles3.cfg_reg = card->para[1];
333 switch (cs->hw.teles3.cfg_reg) {
334 case 0x180:
335 case 0x280:
336 case 0x380:
337 cs->hw.teles3.cfg_reg |= 0xc00;
338 break;
339 }
340 cs->hw.teles3.isac = cs->hw.teles3.cfg_reg - 0x420;
341 cs->hw.teles3.hscx[0] = cs->hw.teles3.cfg_reg - 0xc20;
342 cs->hw.teles3.hscx[1] = cs->hw.teles3.cfg_reg - 0x820;
343 } else if (cs->typ == ISDN_CTYPE_TELESPCMCIA) {
344 cs->hw.teles3.cfg_reg = 0;
345 cs->hw.teles3.hscx[0] = card->para[1] - 0x20;
346 cs->hw.teles3.hscx[1] = card->para[1];
347 cs->hw.teles3.isac = card->para[1] + 0x20;
348 } else if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
349 cs->hw.teles3.cfg_reg = card->para[3];
350 cs->hw.teles3.isac = card->para[2] - 32;
351 cs->hw.teles3.hscx[0] = card->para[1] - 32;
352 cs->hw.teles3.hscx[1] = card->para[1];
353 } else { /* PNP */
354 cs->hw.teles3.cfg_reg = 0;
355 cs->hw.teles3.isac = card->para[1] - 32;
356 cs->hw.teles3.hscx[0] = card->para[2] - 32;
357 cs->hw.teles3.hscx[1] = card->para[2];
358 }
359 cs->irq = card->para[0];
360 cs->hw.teles3.isacfifo = cs->hw.teles3.isac + 0x3e;
361 cs->hw.teles3.hscxfifo[0] = cs->hw.teles3.hscx[0] + 0x3e;
362 cs->hw.teles3.hscxfifo[1] = cs->hw.teles3.hscx[1] + 0x3e;
363 if (cs->typ == ISDN_CTYPE_TELESPCMCIA) {
364 if (!request_region(cs->hw.teles3.hscx[1], 96, "HiSax Teles PCMCIA")) {
365 printk(KERN_WARNING
366 "HiSax: %s ports %x-%x already in use\n",
367 CardType[cs->typ],
368 cs->hw.teles3.hscx[1],
369 cs->hw.teles3.hscx[1] + 96);
370 return (0);
371 }
372 cs->irq_flags |= IRQF_SHARED; /* cardbus can share */
373 } else {
374 if (cs->hw.teles3.cfg_reg) {
375 if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
376 if (!request_region(cs->hw.teles3.cfg_reg, 1, "teles3 cfg")) {
377 printk(KERN_WARNING
378 "HiSax: %s config port %x already in use\n",
379 CardType[card->typ],
380 cs->hw.teles3.cfg_reg);
381 return (0);
382 }
383 } else {
384 if (!request_region(cs->hw.teles3.cfg_reg, 8, "teles3 cfg")) {
385 printk(KERN_WARNING
386 "HiSax: %s config port %x-%x already in use\n",
387 CardType[card->typ],
388 cs->hw.teles3.cfg_reg,
389 cs->hw.teles3.cfg_reg + 8);
390 return (0);
391 }
392 }
393 }
394 if (!request_region(cs->hw.teles3.isac + 32, 32, "HiSax isac")) {
395 printk(KERN_WARNING
396 "HiSax: %s isac ports %x-%x already in use\n",
397 CardType[cs->typ],
398 cs->hw.teles3.isac + 32,
399 cs->hw.teles3.isac + 64);
400 if (cs->hw.teles3.cfg_reg) {
401 if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
402 release_region(cs->hw.teles3.cfg_reg, 1);
403 } else {
404 release_region(cs->hw.teles3.cfg_reg, 8);
405 }
406 }
407 return (0);
408 }
409 if (!request_region(cs->hw.teles3.hscx[0] + 32, 32, "HiSax hscx A")) {
410 printk(KERN_WARNING
411 "HiSax: %s hscx A ports %x-%x already in use\n",
412 CardType[cs->typ],
413 cs->hw.teles3.hscx[0] + 32,
414 cs->hw.teles3.hscx[0] + 64);
415 if (cs->hw.teles3.cfg_reg) {
416 if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
417 release_region(cs->hw.teles3.cfg_reg, 1);
418 } else {
419 release_region(cs->hw.teles3.cfg_reg, 8);
420 }
421 }
422 release_ioregs(cs, 1);
423 return (0);
424 }
425 if (!request_region(cs->hw.teles3.hscx[1] + 32, 32, "HiSax hscx B")) {
426 printk(KERN_WARNING
427 "HiSax: %s hscx B ports %x-%x already in use\n",
428 CardType[cs->typ],
429 cs->hw.teles3.hscx[1] + 32,
430 cs->hw.teles3.hscx[1] + 64);
431 if (cs->hw.teles3.cfg_reg) {
432 if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
433 release_region(cs->hw.teles3.cfg_reg, 1);
434 } else {
435 release_region(cs->hw.teles3.cfg_reg, 8);
436 }
437 }
438 release_ioregs(cs, 3);
439 return (0);
440 }
441 }
442 if ((cs->hw.teles3.cfg_reg) && (cs->typ != ISDN_CTYPE_COMPAQ_ISA)) {
443 if ((val = bytein(cs->hw.teles3.cfg_reg + 0)) != 0x51) {
444 printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
445 cs->hw.teles3.cfg_reg + 0, val);
446 release_io_teles3(cs);
447 return (0);
448 }
449 if ((val = bytein(cs->hw.teles3.cfg_reg + 1)) != 0x93) {
450 printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
451 cs->hw.teles3.cfg_reg + 1, val);
452 release_io_teles3(cs);
453 return (0);
454 }
455 val = bytein(cs->hw.teles3.cfg_reg + 2);/* 0x1e=without AB
456 * 0x1f=with AB
457 * 0x1c 16.3 ???
458 * 0x39 16.3 1.1
459 * 0x38 16.3 1.3
460 * 0x46 16.3 with AB + Video (Teles-Vision)
461 */
462 if (val != 0x46 && val != 0x39 && val != 0x38 && val != 0x1c && val != 0x1e && val != 0x1f) {
463 printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
464 cs->hw.teles3.cfg_reg + 2, val);
465 release_io_teles3(cs);
466 return (0);
467 }
468 }
469 printk(KERN_INFO
470 "HiSax: %s config irq:%d isac:0x%X cfg:0x%X\n",
471 CardType[cs->typ], cs->irq,
472 cs->hw.teles3.isac + 32, cs->hw.teles3.cfg_reg);
473 printk(KERN_INFO
474 "HiSax: hscx A:0x%X hscx B:0x%X\n",
475 cs->hw.teles3.hscx[0] + 32, cs->hw.teles3.hscx[1] + 32);
476
477 setup_isac(cs);
478 if (reset_teles3(cs)) {
479 printk(KERN_WARNING "Teles3: wrong IRQ\n");
480 release_io_teles3(cs);
481 return (0);
482 }
483 cs->readisac = &ReadISAC;
484 cs->writeisac = &WriteISAC;
485 cs->readisacfifo = &ReadISACfifo;
486 cs->writeisacfifo = &WriteISACfifo;
487 cs->BC_Read_Reg = &ReadHSCX;
488 cs->BC_Write_Reg = &WriteHSCX;
489 cs->BC_Send_Data = &hscx_fill_fifo;
490 cs->cardmsg = &Teles_card_msg;
491 cs->irq_func = &teles3_interrupt;
492 ISACVersion(cs, "Teles3:");
493 if (HscxVersion(cs, "Teles3:")) {
494 printk(KERN_WARNING
495 "Teles3: wrong HSCX versions check IO address\n");
496 release_io_teles3(cs);
497 return (0);
498 }
499 return (1);
500 }
mah project overlay