1 /* $Id: avm_a1.c,v 1.6 1997/04/13 19:54:07 keil Exp $
3 * avm_a1.c low level stuff for AVM A1 (Fritz) isdn cards
5 * Author Karsten Keil (keil@temic-ech.spacenet.de)
9 * Revision 1.6 1997/04/13 19:54:07 keil
10 * Change in IRQ check delay for SMP
12 * Revision 1.5 1997/04/06 22:54:10 keil
15 * Revision 1.4 1997/01/27 15:50:21 keil
18 * Revision 1.3 1997/01/21 22:14:20 keil
21 * Revision 1.2 1996/10/27 22:07:31 keil
24 * Revision 1.1 1996/10/13 20:04:49 keil
29 #define __NO_VERSION__
34 #include <linux/kernel_stat.h>
36 extern const char *CardType
[];
37 const char *avm_revision
= "$Revision: 1.6 $";
39 #define byteout(addr,val) outb_p(val,addr)
40 #define bytein(addr) inb_p(addr)
43 readreg(unsigned int adr
, u_char off
)
45 return (bytein(adr
+ off
));
49 writereg(unsigned int adr
, u_char off
, u_char data
)
51 byteout(adr
+ off
, data
);
56 read_fifo(unsigned int adr
, u_char
* data
, int size
)
58 insb(adr
- 0x400, data
, size
);
62 write_fifo(unsigned int adr
, u_char
* data
, int size
)
64 outsb(adr
- 0x400, data
, size
);
72 while ((readreg(adr
, HSCX_STAR
) & 0x04) && to
) {
77 printk(KERN_WARNING
"AVM A1: waitforCEC timeout\n");
86 while ((!(readreg(adr
, HSCX_STAR
) & 0x44) == 0x40) && to
) {
91 printk(KERN_WARNING
"AVM A1: waitforXFW timeout\n");
95 writehscxCMDR(int adr
, u_char data
)
102 writereg(adr
, HSCX_CMDR
, data
);
103 restore_flags(flags
);
107 * fast interrupt here
111 hscxreport(struct IsdnCardState
*sp
, int hscx
)
113 printk(KERN_DEBUG
"HSCX %d\n", hscx
);
114 printk(KERN_DEBUG
"ISTA %x\n", readreg(sp
->hscx
[hscx
], HSCX_ISTA
));
115 printk(KERN_DEBUG
"STAR %x\n", readreg(sp
->hscx
[hscx
], HSCX_STAR
));
116 printk(KERN_DEBUG
"EXIR %x\n", readreg(sp
->hscx
[hscx
], HSCX_EXIR
));
120 avm_a1_report(struct IsdnCardState
*sp
)
122 printk(KERN_DEBUG
"ISAC\n");
123 printk(KERN_DEBUG
"ISTA %x\n", readreg(sp
->isac
, ISAC_ISTA
));
124 printk(KERN_DEBUG
"STAR %x\n", readreg(sp
->isac
, ISAC_STAR
));
125 printk(KERN_DEBUG
"EXIR %x\n", readreg(sp
->isac
, ISAC_EXIR
));
131 * HSCX stuff goes here
135 hscx_empty_fifo(struct HscxState
*hsp
, int count
)
138 struct IsdnCardState
*sp
= hsp
->sp
;
141 if ((sp
->debug
& L1_DEB_HSCX
) && !(sp
->debug
& L1_DEB_HSCX_FIFO
))
142 debugl1(sp
, "hscx_empty_fifo");
144 if (hsp
->rcvidx
+ count
> HSCX_BUFMAX
) {
145 if (sp
->debug
& L1_DEB_WARN
)
146 debugl1(sp
, "hscx_empty_fifo: incoming packet too large");
147 writehscxCMDR(sp
->hscx
[hsp
->hscx
], 0x80);
151 ptr
= hsp
->rcvbuf
+ hsp
->rcvidx
;
152 hsp
->rcvidx
+= count
;
155 read_fifo(sp
->hscx
[hsp
->hscx
], ptr
, count
);
156 writehscxCMDR(sp
->hscx
[hsp
->hscx
], 0x80);
157 restore_flags(flags
);
158 if (sp
->debug
& L1_DEB_HSCX_FIFO
) {
162 t
+= sprintf(t
, "hscx_empty_fifo %c cnt %d",
163 hsp
->hscx
? 'B' : 'A', count
);
164 QuickHex(t
, ptr
, count
);
170 hscx_fill_fifo(struct HscxState
*hsp
)
172 struct IsdnCardState
*sp
= hsp
->sp
;
177 if ((sp
->debug
& L1_DEB_HSCX
) && !(sp
->debug
& L1_DEB_HSCX_FIFO
))
178 debugl1(sp
, "hscx_fill_fifo");
182 if (hsp
->tx_skb
->len
<= 0)
185 more
= (hsp
->mode
== 1) ? 1 : 0;
186 if (hsp
->tx_skb
->len
> 32) {
190 count
= hsp
->tx_skb
->len
;
192 waitforXFW(sp
->hscx
[hsp
->hscx
]);
195 ptr
= hsp
->tx_skb
->data
;
196 skb_pull(hsp
->tx_skb
, count
);
197 hsp
->tx_cnt
-= count
;
199 write_fifo(sp
->hscx
[hsp
->hscx
], ptr
, count
);
200 writehscxCMDR(sp
->hscx
[hsp
->hscx
], more
? 0x8 : 0xa);
201 restore_flags(flags
);
202 if (sp
->debug
& L1_DEB_HSCX_FIFO
) {
206 t
+= sprintf(t
, "hscx_fill_fifo %c cnt %d",
207 hsp
->hscx
? 'B' : 'A', count
);
208 QuickHex(t
, ptr
, count
);
214 hscx_interrupt(struct IsdnCardState
*sp
, u_char val
, u_char hscx
)
217 struct HscxState
*hsp
= sp
->hs
+ hscx
;
225 if (val
& 0x80) { /* RME */
227 r
= readreg(sp
->hscx
[hsp
->hscx
], HSCX_RSTA
);
228 if ((r
& 0xf0) != 0xa0) {
230 if (sp
->debug
& L1_DEB_WARN
)
231 debugl1(sp
, "HSCX invalid frame");
232 if ((r
& 0x40) && hsp
->mode
)
233 if (sp
->debug
& L1_DEB_WARN
) {
234 sprintf(tmp
, "HSCX RDO mode=%d",
239 if (sp
->debug
& L1_DEB_WARN
)
240 debugl1(sp
, "HSCX CRC error");
241 writehscxCMDR(sp
->hscx
[hsp
->hscx
], 0x80);
243 count
= readreg(sp
->hscx
[hsp
->hscx
], HSCX_RBCL
) & 0x1f;
246 hscx_empty_fifo(hsp
, count
);
247 if ((count
= hsp
->rcvidx
- 1) > 0) {
248 if (!(skb
= dev_alloc_skb(count
)))
249 printk(KERN_WARNING
"AVM: receive out of memory\n");
251 memcpy(skb_put(skb
, count
), hsp
->rcvbuf
, count
);
252 skb_queue_tail(&hsp
->rqueue
, skb
);
257 hscx_sched_event(hsp
, HSCX_RCVBUFREADY
);
259 if (val
& 0x40) { /* RPF */
260 hscx_empty_fifo(hsp
, 32);
261 if (hsp
->mode
== 1) {
262 /* receive audio data */
263 if (!(skb
= dev_alloc_skb(32)))
264 printk(KERN_WARNING
"AVM: receive out of memory\n");
266 memcpy(skb_put(skb
, 32), hsp
->rcvbuf
, 32);
267 skb_queue_tail(&hsp
->rqueue
, skb
);
270 hscx_sched_event(hsp
, HSCX_RCVBUFREADY
);
273 if (val
& 0x10) { /* XPR */
275 if (hsp
->tx_skb
->len
) {
279 SET_SKB_FREE(hsp
->tx_skb
);
280 dev_kfree_skb(hsp
->tx_skb
, FREE_WRITE
);
282 if (hsp
->st
->l4
.l1writewakeup
)
283 hsp
->st
->l4
.l1writewakeup(hsp
->st
);
286 if ((hsp
->tx_skb
= skb_dequeue(&hsp
->squeue
))) {
290 hscx_sched_event(hsp
, HSCX_XMTBUFREADY
);
295 * ISAC stuff goes here
299 isac_empty_fifo(struct IsdnCardState
*sp
, int count
)
304 if ((sp
->debug
& L1_DEB_ISAC
) && !(sp
->debug
& L1_DEB_ISAC_FIFO
))
305 if (sp
->debug
& L1_DEB_ISAC
)
306 debugl1(sp
, "isac_empty_fifo");
308 if ((sp
->rcvidx
+ count
) >= MAX_DFRAME_LEN
) {
309 if (sp
->debug
& L1_DEB_WARN
) {
311 sprintf(tmp
, "isac_empty_fifo overrun %d",
315 writereg(sp
->isac
, ISAC_CMDR
, 0x80);
319 ptr
= sp
->rcvbuf
+ sp
->rcvidx
;
323 read_fifo(sp
->isac
, ptr
, count
);
324 writereg(sp
->isac
, ISAC_CMDR
, 0x80);
325 restore_flags(flags
);
326 if (sp
->debug
& L1_DEB_ISAC_FIFO
) {
330 t
+= sprintf(t
, "isac_empty_fifo cnt %d", count
);
331 QuickHex(t
, ptr
, count
);
337 isac_fill_fifo(struct IsdnCardState
*sp
)
343 if ((sp
->debug
& L1_DEB_ISAC
) && !(sp
->debug
& L1_DEB_ISAC_FIFO
))
344 debugl1(sp
, "isac_fill_fifo");
349 count
= sp
->tx_skb
->len
;
360 ptr
= sp
->tx_skb
->data
;
361 skb_pull(sp
->tx_skb
, count
);
363 write_fifo(sp
->isac
, ptr
, count
);
364 writereg(sp
->isac
, ISAC_CMDR
, more
? 0x8 : 0xa);
365 restore_flags(flags
);
366 if (sp
->debug
& L1_DEB_ISAC_FIFO
) {
370 t
+= sprintf(t
, "isac_fill_fifo cnt %d", count
);
371 QuickHex(t
, ptr
, count
);
377 ph_command(struct IsdnCardState
*sp
, unsigned int command
)
379 if (sp
->debug
& L1_DEB_ISAC
) {
381 sprintf(tmp
, "ph_command %d", command
);
384 writereg(sp
->isac
, ISAC_CIX0
, (command
<< 2) | 3);
389 isac_interrupt(struct IsdnCardState
*sp
, u_char val
)
396 if (sp
->debug
& L1_DEB_ISAC
) {
397 sprintf(tmp
, "ISAC interrupt %x", val
);
400 if (val
& 0x80) { /* RME */
401 exval
= readreg(sp
->isac
, ISAC_RSTA
);
402 if ((exval
& 0x70) != 0x20) {
404 if (sp
->debug
& L1_DEB_WARN
)
405 debugl1(sp
, "ISAC RDO");
407 if (sp
->debug
& L1_DEB_WARN
)
408 debugl1(sp
, "ISAC CRC error");
409 writereg(sp
->isac
, ISAC_CMDR
, 0x80);
411 count
= readreg(sp
->isac
, ISAC_RBCL
) & 0x1f;
414 isac_empty_fifo(sp
, count
);
415 if ((count
= sp
->rcvidx
) > 0) {
416 if (!(skb
= alloc_skb(count
, GFP_ATOMIC
)))
417 printk(KERN_WARNING
"AVM: D receive out of memory\n");
419 memcpy(skb_put(skb
, count
), sp
->rcvbuf
, count
);
420 skb_queue_tail(&sp
->rq
, skb
);
425 isac_sched_event(sp
, ISAC_RCVBUFREADY
);
427 if (val
& 0x40) { /* RPF */
428 isac_empty_fifo(sp
, 32);
430 if (val
& 0x20) { /* RSC */
432 if (sp
->debug
& L1_DEB_WARN
)
433 debugl1(sp
, "ISAC RSC interrupt");
435 if (val
& 0x10) { /* XPR */
437 if (sp
->tx_skb
->len
) {
441 SET_SKB_FREE(sp
->tx_skb
);
442 dev_kfree_skb(sp
->tx_skb
, FREE_WRITE
);
446 if ((sp
->tx_skb
= skb_dequeue(&sp
->sq
))) {
450 isac_sched_event(sp
, ISAC_XMTBUFREADY
);
453 if (val
& 0x04) { /* CISQ */
454 sp
->ph_state
= (readreg(sp
->isac
, ISAC_CIX0
) >> 2)
456 if (sp
->debug
& L1_DEB_ISAC
) {
457 sprintf(tmp
, "l1state %d", sp
->ph_state
);
462 if (val
& 0x02) { /* SIN */
464 if (sp
->debug
& L1_DEB_WARN
)
465 debugl1(sp
, "ISAC SIN interrupt");
467 if (val
& 0x01) { /* EXI */
468 exval
= readreg(sp
->isac
, ISAC_EXIR
);
469 if (sp
->debug
& L1_DEB_WARN
) {
470 sprintf(tmp
, "ISAC EXIR %02x", exval
);
477 hscx_int_main(struct IsdnCardState
*sp
, u_char val
)
481 struct HscxState
*hsp
;
487 exval
= readreg(sp
->hscx
[1], HSCX_EXIR
);
492 /* Here we lost an TX interrupt, so
493 * restart transmitting the whole frame.
496 skb_push(hsp
->tx_skb
, hsp
->count
);
497 hsp
->tx_cnt
+= hsp
->count
;
500 writehscxCMDR(sp
->hscx
[hsp
->hscx
], 0x01);
501 if (sp
->debug
& L1_DEB_WARN
) {
502 sprintf(tmp
, "HSCX B EXIR %x Lost TX", exval
);
506 } else if (sp
->debug
& L1_DEB_HSCX
) {
507 sprintf(tmp
, "HSCX B EXIR %x", exval
);
512 if (sp
->debug
& L1_DEB_HSCX
) {
513 sprintf(tmp
, "HSCX B interrupt %x", val
);
516 hscx_interrupt(sp
, val
, 1);
520 exval
= readreg(sp
->hscx
[0], HSCX_EXIR
);
525 /* Here we lost an TX interrupt, so
526 * restart transmitting the whole frame.
529 skb_push(hsp
->tx_skb
, hsp
->count
);
530 hsp
->tx_cnt
+= hsp
->count
;
533 writehscxCMDR(sp
->hscx
[hsp
->hscx
], 0x01);
534 if (sp
->debug
& L1_DEB_WARN
) {
535 sprintf(tmp
, "HSCX A EXIR %x Lost TX", exval
);
539 } else if (sp
->debug
& L1_DEB_HSCX
) {
540 sprintf(tmp
, "HSCX A EXIR %x", exval
);
545 exval
= readreg(sp
->hscx
[0], HSCX_ISTA
);
546 if (sp
->debug
& L1_DEB_HSCX
) {
547 sprintf(tmp
, "HSCX A interrupt %x", exval
);
550 hscx_interrupt(sp
, exval
, 0);
555 avm_a1_interrupt(int intno
, void *dev_id
, struct pt_regs
*regs
)
557 struct IsdnCardState
*sp
;
558 u_char val
, sval
, stat
= 0;
561 sp
= (struct IsdnCardState
*) dev_id
;
564 printk(KERN_WARNING
"AVM A1: Spurious interrupt!\n");
567 while (((sval
= bytein(sp
->cfg_reg
)) & 0xf) != 0x7) {
568 if (!(sval
& AVM_A1_STAT_TIMER
)) {
569 byteout(sp
->cfg_reg
, 0x14);
570 byteout(sp
->cfg_reg
, 0x18);
571 sval
= bytein(sp
->cfg_reg
);
572 } else if (sp
->debug
& L1_DEB_INTSTAT
) {
573 sprintf(tmp
, "avm IntStatus %x", sval
);
576 if (!(sval
& AVM_A1_STAT_HSCX
)) {
577 val
= readreg(sp
->hscx
[1], HSCX_ISTA
);
579 hscx_int_main(sp
, val
);
583 if (!(sval
& AVM_A1_STAT_ISAC
)) {
584 val
= readreg(sp
->isac
, ISAC_ISTA
);
586 isac_interrupt(sp
, val
);
592 writereg(sp
->hscx
[0], HSCX_MASK
, 0xFF);
593 writereg(sp
->hscx
[1], HSCX_MASK
, 0xFF);
594 writereg(sp
->hscx
[0], HSCX_MASK
, 0x0);
595 writereg(sp
->hscx
[1], HSCX_MASK
, 0x0);
598 writereg(sp
->isac
, ISAC_MASK
, 0xFF);
599 writereg(sp
->isac
, ISAC_MASK
, 0x0);
605 initisac(struct IsdnCardState
*sp
)
607 unsigned int adr
= sp
->isac
;
609 /* 16.3 IOM 2 Mode */
610 writereg(adr
, ISAC_MASK
, 0xff);
611 writereg(adr
, ISAC_ADF2
, 0x80);
612 writereg(adr
, ISAC_SQXR
, 0x2f);
613 writereg(adr
, ISAC_SPCR
, 0x0);
614 writereg(adr
, ISAC_ADF1
, 0x2);
615 writereg(adr
, ISAC_STCR
, 0x70);
616 writereg(adr
, ISAC_MODE
, 0xc9);
617 writereg(adr
, ISAC_TIMR
, 0x0);
618 writereg(adr
, ISAC_ADF1
, 0x0);
619 writereg(adr
, ISAC_CMDR
, 0x41);
620 writereg(adr
, ISAC_CIX0
, (1 << 2) | 3);
621 writereg(adr
, ISAC_MASK
, 0xff);
622 writereg(adr
, ISAC_MASK
, 0x0);
626 modehscx(struct HscxState
*hs
, int mode
, int ichan
)
628 struct IsdnCardState
*sp
= hs
->sp
;
631 if (sp
->debug
& L1_DEB_HSCX
) {
633 sprintf(tmp
, "hscx %c mode %d ichan %d",
634 'A' + hscx
, mode
, ichan
);
638 writereg(sp
->hscx
[hscx
], HSCX_CCR1
, 0x85);
639 writereg(sp
->hscx
[hscx
], HSCX_XAD1
, 0xFF);
640 writereg(sp
->hscx
[hscx
], HSCX_XAD2
, 0xFF);
641 writereg(sp
->hscx
[hscx
], HSCX_RAH2
, 0xFF);
642 writereg(sp
->hscx
[hscx
], HSCX_XBCH
, 0x0);
643 writereg(sp
->hscx
[hscx
], HSCX_RLCR
, 0x0);
647 writereg(sp
->hscx
[hscx
], HSCX_CCR2
, 0x30);
648 writereg(sp
->hscx
[hscx
], HSCX_TSAX
, 0xff);
649 writereg(sp
->hscx
[hscx
], HSCX_TSAR
, 0xff);
650 writereg(sp
->hscx
[hscx
], HSCX_XCCR
, 7);
651 writereg(sp
->hscx
[hscx
], HSCX_RCCR
, 7);
652 writereg(sp
->hscx
[hscx
], HSCX_MODE
, 0x84);
656 writereg(sp
->hscx
[hscx
], HSCX_CCR2
, 0x30);
657 writereg(sp
->hscx
[hscx
], HSCX_TSAX
, 0x2f);
658 writereg(sp
->hscx
[hscx
], HSCX_TSAR
, 0x2f);
659 writereg(sp
->hscx
[hscx
], HSCX_XCCR
, 7);
660 writereg(sp
->hscx
[hscx
], HSCX_RCCR
, 7);
662 writereg(sp
->hscx
[hscx
], HSCX_CCR2
, 0x30);
663 writereg(sp
->hscx
[hscx
], HSCX_TSAX
, 0x3);
664 writereg(sp
->hscx
[hscx
], HSCX_TSAR
, 0x3);
665 writereg(sp
->hscx
[hscx
], HSCX_XCCR
, 7);
666 writereg(sp
->hscx
[hscx
], HSCX_RCCR
, 7);
668 writereg(sp
->hscx
[hscx
], HSCX_MODE
, 0xe4);
669 writereg(sp
->hscx
[hscx
], HSCX_CMDR
, 0x41);
673 writereg(sp
->hscx
[hscx
], HSCX_CCR2
, 0x30);
674 writereg(sp
->hscx
[hscx
], HSCX_TSAX
, 0x2f);
675 writereg(sp
->hscx
[hscx
], HSCX_TSAR
, 0x2f);
676 writereg(sp
->hscx
[hscx
], HSCX_XCCR
, 7);
677 writereg(sp
->hscx
[hscx
], HSCX_RCCR
, 7);
679 writereg(sp
->hscx
[hscx
], HSCX_CCR2
, 0x30);
680 writereg(sp
->hscx
[hscx
], HSCX_TSAX
, 0x3);
681 writereg(sp
->hscx
[hscx
], HSCX_TSAR
, 0x3);
682 writereg(sp
->hscx
[hscx
], HSCX_XCCR
, 7);
683 writereg(sp
->hscx
[hscx
], HSCX_RCCR
, 7);
685 writereg(sp
->hscx
[hscx
], HSCX_MODE
, 0x8c);
686 writereg(sp
->hscx
[hscx
], HSCX_CMDR
, 0x41);
689 writereg(sp
->hscx
[hscx
], HSCX_ISTA
, 0x00);
693 release_ioregs(struct IsdnCard
*card
, int mask
)
695 release_region(card
->sp
->cfg_reg
, 8);
697 release_region(card
->sp
->isac
, 32);
699 release_region(card
->sp
->isac
- 0x400, 1);
701 release_region(card
->sp
->hscx
[0], 32);
703 release_region(card
->sp
->hscx
[0] - 0x400, 1);
705 release_region(card
->sp
->hscx
[1], 32);
707 release_region(card
->sp
->hscx
[1] - 0x400, 1);
711 release_io_avm_a1(struct IsdnCard
*card
)
713 release_ioregs(card
, 0x3f);
717 clear_pending_ints(struct IsdnCardState
*sp
)
722 val
= readreg(sp
->hscx
[1], HSCX_ISTA
);
723 sprintf(tmp
, "HSCX B ISTA %x", val
);
726 val
= readreg(sp
->hscx
[1], HSCX_EXIR
);
727 sprintf(tmp
, "HSCX B EXIR %x", val
);
729 } else if (val
& 0x02) {
730 val
= readreg(sp
->hscx
[0], HSCX_EXIR
);
731 sprintf(tmp
, "HSCX A EXIR %x", val
);
734 val
= readreg(sp
->hscx
[0], HSCX_ISTA
);
735 sprintf(tmp
, "HSCX A ISTA %x", val
);
737 val
= readreg(sp
->hscx
[1], HSCX_STAR
);
738 sprintf(tmp
, "HSCX B STAR %x", val
);
740 val
= readreg(sp
->hscx
[0], HSCX_STAR
);
741 sprintf(tmp
, "HSCX A STAR %x", val
);
743 val
= readreg(sp
->isac
, ISAC_STAR
);
744 sprintf(tmp
, "ISAC STAR %x", val
);
746 val
= readreg(sp
->isac
, ISAC_MODE
);
747 sprintf(tmp
, "ISAC MODE %x", val
);
749 val
= readreg(sp
->isac
, ISAC_ADF2
);
750 sprintf(tmp
, "ISAC ADF2 %x", val
);
752 val
= readreg(sp
->isac
, ISAC_ISTA
);
753 sprintf(tmp
, "ISAC ISTA %x", val
);
756 val
= readreg(sp
->isac
, ISAC_EXIR
);
757 sprintf(tmp
, "ISAC EXIR %x", val
);
759 } else if (val
& 0x04) {
760 val
= readreg(sp
->isac
, ISAC_CIR0
);
761 sprintf(tmp
, "ISAC CIR0 %x", val
);
764 writereg(sp
->isac
, ISAC_MASK
, 0);
765 writereg(sp
->isac
, ISAC_CMDR
, 0x41);
769 initavm_a1(struct IsdnCardState
*sp
)
775 sp
->counter
= kstat_irqs(sp
->irq
);
776 sprintf(tmp
, "IRQ %d count %d", sp
->irq
, sp
->counter
);
778 clear_pending_ints(sp
);
779 ret
= get_irq(sp
->cardnr
, &avm_a1_interrupt
);
782 sp
->modehscx(sp
->hs
, 0, 0);
783 sp
->modehscx(sp
->hs
+ 1, 0, 0);
784 while (loop
++ < 10) {
785 /* At least 1-3 irqs must happen
786 * (one from HSCX A, one from HSCX B, 3rd from ISAC)
788 if (kstat_irqs(sp
->irq
) > sp
->counter
)
790 current
->state
= TASK_INTERRUPTIBLE
;
791 current
->timeout
= jiffies
+ 1;
794 sprintf(tmp
, "IRQ %d count %d", sp
->irq
,
795 kstat_irqs(sp
->irq
));
797 if (kstat_irqs(sp
->irq
) == sp
->counter
) {
799 "AVM A1: IRQ(%d) getting no interrupts during init\n",
801 free_irq(sp
->irq
, sp
);
809 setup_avm_a1(struct IsdnCard
*card
)
811 u_char val
, verA
, verB
;
812 struct IsdnCardState
*sp
= card
->sp
;
816 strcpy(tmp
, avm_revision
);
817 printk(KERN_NOTICE
"HiSax: AVM driver Rev. %s\n", HiSax_getrev(tmp
));
818 if (sp
->typ
!= ISDN_CTYPE_A1
)
821 sp
->cfg_reg
= card
->para
[1] + 0x1800;
822 sp
->isac
= card
->para
[1] + 0x1400;
823 sp
->hscx
[0] = card
->para
[1] + 0x400;
824 sp
->hscx
[1] = card
->para
[1] + 0xc00;
825 sp
->irq
= card
->para
[0];
826 if (check_region((sp
->cfg_reg
), 8)) {
828 "HiSax: %s config port %x-%x already in use\n",
834 request_region(sp
->cfg_reg
, 8, "avm cfg");
836 if (check_region((sp
->isac
), 32)) {
838 "HiSax: %s isac ports %x-%x already in use\n",
842 release_ioregs(card
, 0);
845 request_region(sp
->isac
, 32, "HiSax isac");
847 if (check_region((sp
->isac
- 0x400), 1)) {
849 "HiSax: %s isac fifo port %x already in use\n",
852 release_ioregs(card
, 1);
855 request_region(sp
->isac
- 0x400, 1, "HiSax isac fifo");
857 if (check_region((sp
->hscx
[0]), 32)) {
859 "HiSax: %s hscx A ports %x-%x already in use\n",
863 release_ioregs(card
, 3);
866 request_region(sp
->hscx
[0], 32, "HiSax hscx A");
868 if (check_region((sp
->hscx
[0] - 0x400), 1)) {
870 "HiSax: %s hscx A fifo port %x already in use\n",
872 sp
->hscx
[0] - 0x400);
873 release_ioregs(card
, 7);
876 request_region(sp
->hscx
[0] - 0x400, 1, "HiSax hscx A fifo");
878 if (check_region((sp
->hscx
[1]), 32)) {
880 "HiSax: %s hscx B ports %x-%x already in use\n",
884 release_ioregs(card
, 0xf);
887 request_region(sp
->hscx
[1], 32, "HiSax hscx B");
889 if (check_region((sp
->hscx
[1] - 0x400), 1)) {
891 "HiSax: %s hscx B fifo port %x already in use\n",
893 sp
->hscx
[1] - 0x400);
894 release_ioregs(card
, 0x1f);
897 request_region(sp
->hscx
[1] - 0x400, 1, "HiSax hscx B fifo");
900 byteout(sp
->cfg_reg
, 0x0);
903 byteout(sp
->cfg_reg
, 0x1);
905 byteout(sp
->cfg_reg
, 0x0);
910 byteout(sp
->cfg_reg
+ 1, val
);
912 byteout(sp
->cfg_reg
, 0x0);
914 restore_flags(flags
);
916 val
= bytein(sp
->cfg_reg
);
917 printk(KERN_INFO
"AVM A1: Byte at %x is %x\n",
919 val
= bytein(sp
->cfg_reg
+ 3);
920 printk(KERN_INFO
"AVM A1: Byte at %x is %x\n",
921 sp
->cfg_reg
+ 3, val
);
922 val
= bytein(sp
->cfg_reg
+ 2);
923 printk(KERN_INFO
"AVM A1: Byte at %x is %x\n",
924 sp
->cfg_reg
+ 2, val
);
925 byteout(sp
->cfg_reg
, 0x14);
926 byteout(sp
->cfg_reg
, 0x18);
927 val
= bytein(sp
->cfg_reg
);
928 printk(KERN_INFO
"AVM A1: Byte at %x is %x\n",
932 "HiSax: %s config irq:%d cfg:%x\n",
933 CardType
[sp
->typ
], sp
->irq
,
936 "HiSax: isac:%x/%x\n",
937 sp
->isac
, sp
->isac
- 0x400);
939 "HiSax: hscx A:%x/%x hscx B:%x/%x\n",
940 sp
->hscx
[0], sp
->hscx
[0] - 0x400,
941 sp
->hscx
[1], sp
->hscx
[1] - 0x400);
942 verA
= readreg(sp
->hscx
[0], HSCX_VSTR
) & 0xf;
943 verB
= readreg(sp
->hscx
[1], HSCX_VSTR
) & 0xf;
944 printk(KERN_INFO
"AVM A1: HSCX version A: %s B: %s\n",
945 HscxVersion(verA
), HscxVersion(verB
));
946 val
= readreg(sp
->isac
, ISAC_RBCH
);
947 printk(KERN_INFO
"AVM A1: ISAC %s\n",
949 if ((verA
== 0) | (verA
== 0xf) | (verB
== 0) | (verB
== 0xf)) {
951 "AVM A1: wrong HSCX versions check IO address\n");
952 release_io_avm_a1(card
);
955 sp
->modehscx
= &modehscx
;
956 sp
->ph_command
= &ph_command
;
957 sp
->hscx_fill_fifo
= &hscx_fill_fifo
;
958 sp
->isac_fill_fifo
= &isac_fill_fifo
;