1 /* $Id: avm_pci.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
3 * low level stuff for AVM Fritz!PCI and ISA PnP isdn cards
6 * Copyright by Karsten Keil <keil@isdn4linux.de>
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
11 * Thanks to AVM, Berlin for information
15 #define __NO_VERSION__
16 #include <linux/config.h>
17 #include <linux/init.h>
21 #include <linux/pci.h>
22 #include <linux/isapnp.h>
23 #include <linux/interrupt.h>
25 extern const char *CardType[];
26 static const char *avm_pci_rev = "$Revision: 1.1.4.1 $";
28 #define AVM_FRITZ_PCI 1
29 #define AVM_FRITZ_PNP 2
32 #define HDLC_STATUS 0x4
34 #define AVM_HDLC_1 0x00
35 #define AVM_HDLC_2 0x01
36 #define AVM_ISAC_FIFO 0x02
37 #define AVM_ISAC_REG_LOW 0x04
38 #define AVM_ISAC_REG_HIGH 0x06
40 #define AVM_STATUS0_IRQ_ISAC 0x01
41 #define AVM_STATUS0_IRQ_HDLC 0x02
42 #define AVM_STATUS0_IRQ_TIMER 0x04
43 #define AVM_STATUS0_IRQ_MASK 0x07
45 #define AVM_STATUS0_RESET 0x01
46 #define AVM_STATUS0_DIS_TIMER 0x02
47 #define AVM_STATUS0_RES_TIMER 0x04
48 #define AVM_STATUS0_ENA_IRQ 0x08
49 #define AVM_STATUS0_TESTBIT 0x10
51 #define AVM_STATUS1_INT_SEL 0x0f
52 #define AVM_STATUS1_ENA_IOM 0x80
54 #define HDLC_MODE_ITF_FLG 0x01
55 #define HDLC_MODE_TRANS 0x02
56 #define HDLC_MODE_CCR_7 0x04
57 #define HDLC_MODE_CCR_16 0x08
58 #define HDLC_MODE_TESTLOOP 0x80
60 #define HDLC_INT_XPR 0x80
61 #define HDLC_INT_XDU 0x40
62 #define HDLC_INT_RPR 0x20
63 #define HDLC_INT_MASK 0xE0
65 #define HDLC_STAT_RME 0x01
66 #define HDLC_STAT_RDO 0x10
67 #define HDLC_STAT_CRCVFRRAB 0x0E
68 #define HDLC_STAT_CRCVFR 0x06
69 #define HDLC_STAT_RML_MASK 0x3f00
71 #define HDLC_CMD_XRS 0x80
72 #define HDLC_CMD_XME 0x01
73 #define HDLC_CMD_RRS 0x20
74 #define HDLC_CMD_XML_MASK 0x3f00
77 /* Interface functions */
80 ReadISAC(struct IsdnCardState *cs, u_char offset)
82 register u_char idx = (offset > 0x2f) ? AVM_ISAC_REG_HIGH : AVM_ISAC_REG_LOW;
88 outb(idx, cs->hw.avm.cfg_reg + 4);
89 val = inb(cs->hw.avm.isac + (offset & 0xf));
95 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
97 register u_char idx = (offset > 0x2f) ? AVM_ISAC_REG_HIGH : AVM_ISAC_REG_LOW;
102 outb(idx, cs->hw.avm.cfg_reg + 4);
103 outb(value, cs->hw.avm.isac + (offset & 0xf));
104 restore_flags(flags);
108 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
110 outb(AVM_ISAC_FIFO, cs->hw.avm.cfg_reg + 4);
111 insb(cs->hw.avm.isac, data, size);
115 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
117 outb(AVM_ISAC_FIFO, cs->hw.avm.cfg_reg + 4);
118 outsb(cs->hw.avm.isac, data, size);
122 ReadHDLCPCI(struct IsdnCardState *cs, int chan, u_char offset)
124 register u_int idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
130 outl(idx, cs->hw.avm.cfg_reg + 4);
131 val = inl(cs->hw.avm.isac + offset);
132 restore_flags(flags);
137 WriteHDLCPCI(struct IsdnCardState *cs, int chan, u_char offset, u_int value)
139 register u_int idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
144 outl(idx, cs->hw.avm.cfg_reg + 4);
145 outl(value, cs->hw.avm.isac + offset);
146 restore_flags(flags);
150 ReadHDLCPnP(struct IsdnCardState *cs, int chan, u_char offset)
152 register u_char idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
158 outb(idx, cs->hw.avm.cfg_reg + 4);
159 val = inb(cs->hw.avm.isac + offset);
160 restore_flags(flags);
165 WriteHDLCPnP(struct IsdnCardState *cs, int chan, u_char offset, u_char value)
167 register u_char idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
172 outb(idx, cs->hw.avm.cfg_reg + 4);
173 outb(value, cs->hw.avm.isac + offset);
174 restore_flags(flags);
178 ReadHDLC_s(struct IsdnCardState *cs, int chan, u_char offset)
180 return(0xff & ReadHDLCPCI(cs, chan, offset));
184 WriteHDLC_s(struct IsdnCardState *cs, int chan, u_char offset, u_char value)
186 WriteHDLCPCI(cs, chan, offset, value);
190 struct BCState *Sel_BCS(struct IsdnCardState *cs, int channel)
192 if (cs->bcs[0].mode && (cs->bcs[0].channel == channel))
194 else if (cs->bcs[1].mode && (cs->bcs[1].channel == channel))
201 hdlc_sched_event(struct BCState *bcs, int event)
203 bcs->event |= 1 << event;
204 queue_task(&bcs->tqueue, &tq_immediate);
205 mark_bh(IMMEDIATE_BH);
209 write_ctrl(struct BCState *bcs, int which) {
211 if (bcs->cs->debug & L1_DEB_HSCX)
212 debugl1(bcs->cs, "hdlc %c wr%x ctrl %x",
213 'A' + bcs->channel, which, bcs->hw.hdlc.ctrl.ctrl);
214 if (bcs->cs->subtyp == AVM_FRITZ_PCI) {
215 WriteHDLCPCI(bcs->cs, bcs->channel, HDLC_STATUS, bcs->hw.hdlc.ctrl.ctrl);
218 WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS + 2,
219 bcs->hw.hdlc.ctrl.sr.mode);
221 WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS + 1,
222 bcs->hw.hdlc.ctrl.sr.xml);
224 WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS,
225 bcs->hw.hdlc.ctrl.sr.cmd);
230 modehdlc(struct BCState *bcs, int mode, int bc)
232 struct IsdnCardState *cs = bcs->cs;
233 int hdlc = bcs->channel;
235 if (cs->debug & L1_DEB_HSCX)
236 debugl1(cs, "hdlc %c mode %d --> %d ichan %d --> %d",
237 'A' + hdlc, bcs->mode, mode, hdlc, bc);
238 bcs->hw.hdlc.ctrl.ctrl = 0;
240 case (-1): /* used for init */
245 if (bcs->mode == L1_MODE_NULL)
247 bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS | HDLC_CMD_RRS;
248 bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_TRANS;
250 bcs->mode = L1_MODE_NULL;
253 case (L1_MODE_TRANS):
256 bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS | HDLC_CMD_RRS;
257 bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_TRANS;
259 bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS;
261 bcs->hw.hdlc.ctrl.sr.cmd = 0;
262 hdlc_sched_event(bcs, B_XMTBUFREADY);
267 bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS | HDLC_CMD_RRS;
268 bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_ITF_FLG;
270 bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS;
272 bcs->hw.hdlc.ctrl.sr.cmd = 0;
273 hdlc_sched_event(bcs, B_XMTBUFREADY);
279 hdlc_empty_fifo(struct BCState *bcs, int count)
283 u_char idx = bcs->channel ? AVM_HDLC_2 : AVM_HDLC_1;
285 struct IsdnCardState *cs = bcs->cs;
287 if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
288 debugl1(cs, "hdlc_empty_fifo %d", count);
289 if (bcs->hw.hdlc.rcvidx + count > HSCX_BUFMAX) {
290 if (cs->debug & L1_DEB_WARN)
291 debugl1(cs, "hdlc_empty_fifo: incoming packet too large");
294 p = bcs->hw.hdlc.rcvbuf + bcs->hw.hdlc.rcvidx;
296 bcs->hw.hdlc.rcvidx += count;
297 if (cs->subtyp == AVM_FRITZ_PCI) {
298 outl(idx, cs->hw.avm.cfg_reg + 4);
299 while (cnt < count) {
302 *ptr++ = in_le32((unsigned *)(cs->hw.avm.isac +_IO_BASE));
304 *ptr++ = in_be32((unsigned *)(cs->hw.avm.isac +_IO_BASE));
305 #endif /* CONFIG_APUS */
307 *ptr++ = inl(cs->hw.avm.isac);
308 #endif /* __powerpc__ */
312 outb(idx, cs->hw.avm.cfg_reg + 4);
313 while (cnt < count) {
314 *p++ = inb(cs->hw.avm.isac);
318 if (cs->debug & L1_DEB_HSCX_FIFO) {
321 if (cs->subtyp == AVM_FRITZ_PNP)
323 t += sprintf(t, "hdlc_empty_fifo %c cnt %d",
324 bcs->channel ? 'B' : 'A', count);
325 QuickHex(t, p, count);
326 debugl1(cs, bcs->blog);
331 hdlc_fill_fifo(struct BCState *bcs)
333 struct IsdnCardState *cs = bcs->cs;
339 if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
340 debugl1(cs, "hdlc_fill_fifo");
343 if (bcs->tx_skb->len <= 0)
346 bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_XME;
347 if (bcs->tx_skb->len > fifo_size) {
350 count = bcs->tx_skb->len;
351 if (bcs->mode != L1_MODE_TRANS)
352 bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_XME;
354 if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
355 debugl1(cs, "hdlc_fill_fifo %d/%ld", count, bcs->tx_skb->len);
356 p = bcs->tx_skb->data;
358 skb_pull(bcs->tx_skb, count);
359 bcs->tx_cnt -= count;
360 bcs->hw.hdlc.count += count;
361 bcs->hw.hdlc.ctrl.sr.xml = ((count == fifo_size) ? 0 : count);
362 write_ctrl(bcs, 3); /* sets the correct index too */
363 if (cs->subtyp == AVM_FRITZ_PCI) {
367 out_le32((unsigned *)(cs->hw.avm.isac +_IO_BASE), *ptr++);
369 out_be32((unsigned *)(cs->hw.avm.isac +_IO_BASE), *ptr++);
370 #endif /* CONFIG_APUS */
372 outl(*ptr++, cs->hw.avm.isac);
373 #endif /* __powerpc__ */
378 outb(*p++, cs->hw.avm.isac);
382 if (cs->debug & L1_DEB_HSCX_FIFO) {
385 if (cs->subtyp == AVM_FRITZ_PNP)
387 t += sprintf(t, "hdlc_fill_fifo %c cnt %d",
388 bcs->channel ? 'B' : 'A', count);
389 QuickHex(t, p, count);
390 debugl1(cs, bcs->blog);
395 fill_hdlc(struct BCState *bcs)
401 restore_flags(flags);
405 HDLC_irq(struct BCState *bcs, u_int stat) {
409 if (bcs->cs->debug & L1_DEB_HSCX)
410 debugl1(bcs->cs, "ch%d stat %#x", bcs->channel, stat);
411 if (stat & HDLC_INT_RPR) {
412 if (stat & HDLC_STAT_RDO) {
413 if (bcs->cs->debug & L1_DEB_HSCX)
414 debugl1(bcs->cs, "RDO");
416 debugl1(bcs->cs, "ch%d stat %#x", bcs->channel, stat);
417 bcs->hw.hdlc.ctrl.sr.xml = 0;
418 bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_RRS;
420 bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_RRS;
422 bcs->hw.hdlc.rcvidx = 0;
424 if (!(len = (stat & HDLC_STAT_RML_MASK)>>8))
426 hdlc_empty_fifo(bcs, len);
427 if ((stat & HDLC_STAT_RME) || (bcs->mode == L1_MODE_TRANS)) {
428 if (((stat & HDLC_STAT_CRCVFRRAB)==HDLC_STAT_CRCVFR) ||
429 (bcs->mode == L1_MODE_TRANS)) {
430 if (!(skb = dev_alloc_skb(bcs->hw.hdlc.rcvidx)))
431 printk(KERN_WARNING "HDLC: receive out of memory\n");
433 memcpy(skb_put(skb, bcs->hw.hdlc.rcvidx),
434 bcs->hw.hdlc.rcvbuf, bcs->hw.hdlc.rcvidx);
435 skb_queue_tail(&bcs->rqueue, skb);
437 bcs->hw.hdlc.rcvidx = 0;
438 hdlc_sched_event(bcs, B_RCVBUFREADY);
440 if (bcs->cs->debug & L1_DEB_HSCX)
441 debugl1(bcs->cs, "invalid frame");
443 debugl1(bcs->cs, "ch%d invalid frame %#x", bcs->channel, stat);
444 bcs->hw.hdlc.rcvidx = 0;
449 if (stat & HDLC_INT_XDU) {
450 /* Here we lost an TX interrupt, so
451 * restart transmitting the whole frame.
454 skb_push(bcs->tx_skb, bcs->hw.hdlc.count);
455 bcs->tx_cnt += bcs->hw.hdlc.count;
456 bcs->hw.hdlc.count = 0;
457 // hdlc_sched_event(bcs, B_XMTBUFREADY);
458 if (bcs->cs->debug & L1_DEB_WARN)
459 debugl1(bcs->cs, "ch%d XDU", bcs->channel);
460 } else if (bcs->cs->debug & L1_DEB_WARN)
461 debugl1(bcs->cs, "ch%d XDU without skb", bcs->channel);
462 bcs->hw.hdlc.ctrl.sr.xml = 0;
463 bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_XRS;
465 bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_XRS;
468 } else if (stat & HDLC_INT_XPR) {
470 if (bcs->tx_skb->len) {
474 if (bcs->st->lli.l1writewakeup &&
475 (PACKET_NOACK != bcs->tx_skb->pkt_type))
476 bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.hdlc.count);
477 dev_kfree_skb_irq(bcs->tx_skb);
478 bcs->hw.hdlc.count = 0;
482 if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
483 bcs->hw.hdlc.count = 0;
484 test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
487 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
488 hdlc_sched_event(bcs, B_XMTBUFREADY);
494 HDLC_irq_main(struct IsdnCardState *cs)
502 if (cs->subtyp == AVM_FRITZ_PCI) {
503 stat = ReadHDLCPCI(cs, 0, HDLC_STATUS);
505 stat = ReadHDLCPnP(cs, 0, HDLC_STATUS);
506 if (stat & HDLC_INT_RPR)
507 stat |= (ReadHDLCPnP(cs, 0, HDLC_STATUS+1))<<8;
509 if (stat & HDLC_INT_MASK) {
510 if (!(bcs = Sel_BCS(cs, 0))) {
512 debugl1(cs, "hdlc spurious channel 0 IRQ");
516 if (cs->subtyp == AVM_FRITZ_PCI) {
517 stat = ReadHDLCPCI(cs, 1, HDLC_STATUS);
519 stat = ReadHDLCPnP(cs, 1, HDLC_STATUS);
520 if (stat & HDLC_INT_RPR)
521 stat |= (ReadHDLCPnP(cs, 1, HDLC_STATUS+1))<<8;
523 if (stat & HDLC_INT_MASK) {
524 if (!(bcs = Sel_BCS(cs, 1))) {
526 debugl1(cs, "hdlc spurious channel 1 IRQ");
530 restore_flags(flags);
534 hdlc_l2l1(struct PStack *st, int pr, void *arg)
536 struct sk_buff *skb = arg;
540 case (PH_DATA | REQUEST):
543 if (st->l1.bcs->tx_skb) {
544 skb_queue_tail(&st->l1.bcs->squeue, skb);
545 restore_flags(flags);
547 st->l1.bcs->tx_skb = skb;
548 test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
549 st->l1.bcs->hw.hdlc.count = 0;
550 restore_flags(flags);
551 st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
554 case (PH_PULL | INDICATION):
555 if (st->l1.bcs->tx_skb) {
556 printk(KERN_WARNING "hdlc_l2l1: this shouldn't happen\n");
559 test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
560 st->l1.bcs->tx_skb = skb;
561 st->l1.bcs->hw.hdlc.count = 0;
562 st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
564 case (PH_PULL | REQUEST):
565 if (!st->l1.bcs->tx_skb) {
566 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
567 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
569 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
571 case (PH_ACTIVATE | REQUEST):
572 test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
573 modehdlc(st->l1.bcs, st->l1.mode, st->l1.bc);
574 l1_msg_b(st, pr, arg);
576 case (PH_DEACTIVATE | REQUEST):
577 l1_msg_b(st, pr, arg);
579 case (PH_DEACTIVATE | CONFIRM):
580 test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
581 test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
582 modehdlc(st->l1.bcs, 0, st->l1.bc);
583 st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
589 close_hdlcstate(struct BCState *bcs)
592 if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
593 if (bcs->hw.hdlc.rcvbuf) {
594 kfree(bcs->hw.hdlc.rcvbuf);
595 bcs->hw.hdlc.rcvbuf = NULL;
601 skb_queue_purge(&bcs->rqueue);
602 skb_queue_purge(&bcs->squeue);
604 dev_kfree_skb_any(bcs->tx_skb);
606 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
612 open_hdlcstate(struct IsdnCardState *cs, struct BCState *bcs)
614 if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
615 if (!(bcs->hw.hdlc.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
617 "HiSax: No memory for hdlc.rcvbuf\n");
620 if (!(bcs->blog = kmalloc(MAX_BLOG_SPACE, GFP_ATOMIC))) {
622 "HiSax: No memory for bcs->blog\n");
623 test_and_clear_bit(BC_FLG_INIT, &bcs->Flag);
624 kfree(bcs->hw.hdlc.rcvbuf);
625 bcs->hw.hdlc.rcvbuf = NULL;
628 skb_queue_head_init(&bcs->rqueue);
629 skb_queue_head_init(&bcs->squeue);
632 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
634 bcs->hw.hdlc.rcvidx = 0;
640 setstack_hdlc(struct PStack *st, struct BCState *bcs)
642 bcs->channel = st->l1.bc;
643 if (open_hdlcstate(st->l1.hardware, bcs))
646 st->l2.l2l1 = hdlc_l2l1;
647 setstack_manager(st);
654 clear_pending_hdlc_ints(struct IsdnCardState *cs)
658 if (cs->subtyp == AVM_FRITZ_PCI) {
659 val = ReadHDLCPCI(cs, 0, HDLC_STATUS);
660 debugl1(cs, "HDLC 1 STA %x", val);
661 val = ReadHDLCPCI(cs, 1, HDLC_STATUS);
662 debugl1(cs, "HDLC 2 STA %x", val);
664 val = ReadHDLCPnP(cs, 0, HDLC_STATUS);
665 debugl1(cs, "HDLC 1 STA %x", val);
666 val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 1);
667 debugl1(cs, "HDLC 1 RML %x", val);
668 val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 2);
669 debugl1(cs, "HDLC 1 MODE %x", val);
670 val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 3);
671 debugl1(cs, "HDLC 1 VIN %x", val);
672 val = ReadHDLCPnP(cs, 1, HDLC_STATUS);
673 debugl1(cs, "HDLC 2 STA %x", val);
674 val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 1);
675 debugl1(cs, "HDLC 2 RML %x", val);
676 val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 2);
677 debugl1(cs, "HDLC 2 MODE %x", val);
678 val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 3);
679 debugl1(cs, "HDLC 2 VIN %x", val);
684 inithdlc(struct IsdnCardState *cs)
686 cs->bcs[0].BC_SetStack = setstack_hdlc;
687 cs->bcs[1].BC_SetStack = setstack_hdlc;
688 cs->bcs[0].BC_Close = close_hdlcstate;
689 cs->bcs[1].BC_Close = close_hdlcstate;
690 modehdlc(cs->bcs, -1, 0);
691 modehdlc(cs->bcs + 1, -1, 1);
695 avm_pcipnp_interrupt(int intno, void *dev_id, struct pt_regs *regs)
697 struct IsdnCardState *cs = dev_id;
702 printk(KERN_WARNING "AVM PCI: Spurious interrupt!\n");
705 sval = inb(cs->hw.avm.cfg_reg + 2);
706 if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
707 /* possible a shared IRQ reqest */
709 if (!(sval & AVM_STATUS0_IRQ_ISAC)) {
710 val = ReadISAC(cs, ISAC_ISTA);
711 isac_interrupt(cs, val);
713 if (!(sval & AVM_STATUS0_IRQ_HDLC)) {
716 WriteISAC(cs, ISAC_MASK, 0xFF);
717 WriteISAC(cs, ISAC_MASK, 0x0);
721 reset_avmpcipnp(struct IsdnCardState *cs)
725 printk(KERN_INFO "AVM PCI/PnP: reset\n");
728 outb(AVM_STATUS0_RESET | AVM_STATUS0_DIS_TIMER, cs->hw.avm.cfg_reg + 2);
729 set_current_state(TASK_UNINTERRUPTIBLE);
730 schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
731 outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER | AVM_STATUS0_ENA_IRQ, cs->hw.avm.cfg_reg + 2);
732 outb(AVM_STATUS1_ENA_IOM | cs->irq, cs->hw.avm.cfg_reg + 3);
733 set_current_state(TASK_UNINTERRUPTIBLE);
734 schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
735 printk(KERN_INFO "AVM PCI/PnP: S1 %x\n", inb(cs->hw.avm.cfg_reg + 3));
739 AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
746 outb(0, cs->hw.avm.cfg_reg + 2);
747 release_region(cs->hw.avm.cfg_reg, 32);
750 clear_pending_isac_ints(cs);
752 clear_pending_hdlc_ints(cs);
754 outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER,
755 cs->hw.avm.cfg_reg + 2);
756 WriteISAC(cs, ISAC_MASK, 0);
757 outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER |
758 AVM_STATUS0_ENA_IRQ, cs->hw.avm.cfg_reg + 2);
759 /* RESET Receiver and Transmitter */
760 WriteISAC(cs, ISAC_CMDR, 0x41);
768 static struct pci_dev *dev_avm __initdata = NULL;
770 static struct pci_bus *bus_avm __initdata = NULL;
771 static struct pci_dev *pnp_avm __initdata = NULL;
775 setup_avm_pcipnp(struct IsdnCard *card)
778 struct IsdnCardState *cs = card->cs;
781 strcpy(tmp, avm_pci_rev);
782 printk(KERN_INFO "HiSax: AVM PCI driver Rev. %s\n", HiSax_getrev(tmp));
783 if (cs->typ != ISDN_CTYPE_FRITZPCI)
786 /* old manual method */
787 cs->hw.avm.cfg_reg = card->para[1];
788 cs->irq = card->para[0];
789 cs->subtyp = AVM_FRITZ_PNP;
792 if (isapnp_present()) {
794 if ((ba = isapnp_find_card(
795 ISAPNP_VENDOR('A', 'V', 'M'),
796 ISAPNP_FUNCTION(0x0900), bus_avm))) {
799 if ((pnp_avm = isapnp_find_dev(bus_avm,
800 ISAPNP_VENDOR('A', 'V', 'M'),
801 ISAPNP_FUNCTION(0x0900), pnp_avm))) {
802 pnp_avm->prepare(pnp_avm);
803 pnp_avm->deactivate(pnp_avm);
804 pnp_avm->activate(pnp_avm);
806 pnp_avm->resource[0].start;
808 pnp_avm->irq_resource[0].start;
810 printk(KERN_ERR "FritzPnP:No IRQ\n");
811 pnp_avm->deactivate(pnp_avm);
814 if (!cs->hw.avm.cfg_reg) {
815 printk(KERN_ERR "FritzPnP:No IO address\n");
816 pnp_avm->deactivate(pnp_avm);
819 cs->subtyp = AVM_FRITZ_PNP;
824 printk(KERN_INFO "FritzPnP: no ISA PnP present\n");
828 if (!pci_present()) {
829 printk(KERN_ERR "FritzPCI: no PCI bus present\n");
832 if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
833 PCI_DEVICE_ID_AVM_A1, dev_avm))) {
834 cs->irq = dev_avm->irq;
836 printk(KERN_ERR "FritzPCI: No IRQ for PCI card found\n");
839 if (pci_enable_device(dev_avm))
841 cs->hw.avm.cfg_reg = pci_resource_start(dev_avm, 1);
842 if (!cs->hw.avm.cfg_reg) {
843 printk(KERN_ERR "FritzPCI: No IO-Adr for PCI card found\n");
846 cs->subtyp = AVM_FRITZ_PCI;
848 printk(KERN_WARNING "FritzPCI: No PCI card found\n");
851 cs->irq_flags |= SA_SHIRQ;
853 printk(KERN_WARNING "FritzPCI: NO_PCI_BIOS\n");
855 #endif /* CONFIG_PCI */
858 cs->hw.avm.isac = cs->hw.avm.cfg_reg + 0x10;
859 if (check_region((cs->hw.avm.cfg_reg), 32)) {
861 "HiSax: %s config port %x-%x already in use\n",
864 cs->hw.avm.cfg_reg + 31);
867 request_region(cs->hw.avm.cfg_reg, 32,
868 (cs->subtyp == AVM_FRITZ_PCI) ? "avm PCI" : "avm PnP");
870 switch (cs->subtyp) {
872 val = inl(cs->hw.avm.cfg_reg);
873 printk(KERN_INFO "AVM PCI: stat %#x\n", val);
874 printk(KERN_INFO "AVM PCI: Class %X Rev %d\n",
875 val & 0xff, (val>>8) & 0xff);
876 cs->BC_Read_Reg = &ReadHDLC_s;
877 cs->BC_Write_Reg = &WriteHDLC_s;
880 val = inb(cs->hw.avm.cfg_reg);
881 ver = inb(cs->hw.avm.cfg_reg + 1);
882 printk(KERN_INFO "AVM PnP: Class %X Rev %d\n", val, ver);
884 cs->BC_Read_Reg = &ReadHDLCPnP;
885 cs->BC_Write_Reg = &WriteHDLCPnP;
888 printk(KERN_WARNING "AVM unknown subtype %d\n", cs->subtyp);
891 printk(KERN_INFO "HiSax: %s config irq:%d base:0x%X\n",
892 (cs->subtyp == AVM_FRITZ_PCI) ? "AVM Fritz!PCI" : "AVM Fritz!PnP",
893 cs->irq, cs->hw.avm.cfg_reg);
895 cs->readisac = &ReadISAC;
896 cs->writeisac = &WriteISAC;
897 cs->readisacfifo = &ReadISACfifo;
898 cs->writeisacfifo = &WriteISACfifo;
899 cs->BC_Send_Data = &fill_hdlc;
900 cs->cardmsg = &AVM_card_msg;
901 cs->irq_func = &avm_pcipnp_interrupt;
902 ISACVersion(cs, (cs->subtyp == AVM_FRITZ_PCI) ? "AVM PCI:" : "AVM PnP:");