]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/isdn/hisax/hisax_fcpcipnp.c
2 * Driver for AVM Fritz!PCI, Fritz!PCI v2, Fritz!PnP ISDN cards
4 * Author Kai Germaschewski
5 * Copyright 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
6 * 2001 by Karsten Keil <keil@isdn4linux.de>
8 * based upon Karsten Keil's original avm_pci.c driver
10 * This software may be used and distributed according to the terms
11 * of the GNU General Public License, incorporated herein by reference.
13 * Thanks to Wizard Computersysteme GmbH, Bremervoerde and
14 * SoHaNet Technology GmbH, Berlin
15 * for supporting the development of this driver
22 * o clean up debugging
23 * o tx_skb at PH_DEACTIVATE time
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/interrupt.h>
29 #include <linux/pci.h>
30 #include <linux/isapnp.h>
31 #include <linux/kmod.h>
32 #include <linux/slab.h>
33 #include <linux/skbuff.h>
34 #include <linux/netdevice.h>
35 #include <linux/delay.h>
39 #include "hisax_fcpcipnp.h"
42 #define __debug_variable debug
43 #include "hisax_debug.h"
45 #ifdef CONFIG_HISAX_DEBUG
47 /* static int hdlcfifosize = 32; */
48 module_param(debug
, int, 0);
49 /* module_param(hdlcfifosize, int, 0); */
52 MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
53 MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");
55 static const struct pci_device_id fcpci_ids
[] = {
56 { .vendor
= PCI_VENDOR_ID_AVM
,
57 .device
= PCI_DEVICE_ID_AVM_A1
,
58 .subvendor
= PCI_ANY_ID
,
59 .subdevice
= PCI_ANY_ID
,
60 .driver_data
= (unsigned long) "Fritz!Card PCI",
62 { .vendor
= PCI_VENDOR_ID_AVM
,
63 .device
= PCI_DEVICE_ID_AVM_A1_V2
,
64 .subvendor
= PCI_ANY_ID
,
65 .subdevice
= PCI_ANY_ID
,
66 .driver_data
= (unsigned long) "Fritz!Card PCI v2" },
70 MODULE_DEVICE_TABLE(pci
, fcpci_ids
);
73 static struct pnp_device_id fcpnp_ids
[] = {
76 .driver_data
= (unsigned long) "Fritz!Card PnP",
81 MODULE_DEVICE_TABLE(pnp
, fcpnp_ids
);
84 static int protocol
= 2; /* EURO-ISDN Default */
85 module_param(protocol
, int, 0);
86 MODULE_LICENSE("GPL");
88 // ----------------------------------------------------------------------
90 #define AVM_INDEX 0x04
93 #define AVM_IDX_HDLC_1 0x00
94 #define AVM_IDX_HDLC_2 0x01
95 #define AVM_IDX_ISAC_FIFO 0x02
96 #define AVM_IDX_ISAC_REG_LOW 0x04
97 #define AVM_IDX_ISAC_REG_HIGH 0x06
99 #define AVM_STATUS0 0x02
101 #define AVM_STATUS0_IRQ_ISAC 0x01
102 #define AVM_STATUS0_IRQ_HDLC 0x02
103 #define AVM_STATUS0_IRQ_TIMER 0x04
104 #define AVM_STATUS0_IRQ_MASK 0x07
106 #define AVM_STATUS0_RESET 0x01
107 #define AVM_STATUS0_DIS_TIMER 0x02
108 #define AVM_STATUS0_RES_TIMER 0x04
109 #define AVM_STATUS0_ENA_IRQ 0x08
110 #define AVM_STATUS0_TESTBIT 0x10
112 #define AVM_STATUS1 0x03
113 #define AVM_STATUS1_ENA_IOM 0x80
115 #define HDLC_FIFO 0x0
116 #define HDLC_STATUS 0x4
117 #define HDLC_CTRL 0x4
119 #define HDLC_MODE_ITF_FLG 0x01
120 #define HDLC_MODE_TRANS 0x02
121 #define HDLC_MODE_CCR_7 0x04
122 #define HDLC_MODE_CCR_16 0x08
123 #define HDLC_MODE_TESTLOOP 0x80
125 #define HDLC_INT_XPR 0x80
126 #define HDLC_INT_XDU 0x40
127 #define HDLC_INT_RPR 0x20
128 #define HDLC_INT_MASK 0xE0
130 #define HDLC_STAT_RME 0x01
131 #define HDLC_STAT_RDO 0x10
132 #define HDLC_STAT_CRCVFRRAB 0x0E
133 #define HDLC_STAT_CRCVFR 0x06
134 #define HDLC_STAT_RML_MASK 0xff00
136 #define HDLC_CMD_XRS 0x80
137 #define HDLC_CMD_XME 0x01
138 #define HDLC_CMD_RRS 0x20
139 #define HDLC_CMD_XML_MASK 0xff00
141 #define AVM_HDLC_FIFO_1 0x10
142 #define AVM_HDLC_FIFO_2 0x18
144 #define AVM_HDLC_STATUS_1 0x14
145 #define AVM_HDLC_STATUS_2 0x1c
147 #define AVM_ISACSX_INDEX 0x04
148 #define AVM_ISACSX_DATA 0x08
150 // ----------------------------------------------------------------------
153 static unsigned char fcpci_read_isac(struct isac
*isac
, unsigned char offset
)
155 struct fritz_adapter
*adapter
= isac
->priv
;
156 unsigned char idx
= (offset
> 0x2f) ?
157 AVM_IDX_ISAC_REG_HIGH
: AVM_IDX_ISAC_REG_LOW
;
161 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
162 outb(idx
, adapter
->io
+ AVM_INDEX
);
163 val
= inb(adapter
->io
+ AVM_DATA
+ (offset
& 0xf));
164 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
165 DBG(0x1000, " port %#x, value %#x",
170 static void fcpci_write_isac(struct isac
*isac
, unsigned char offset
,
173 struct fritz_adapter
*adapter
= isac
->priv
;
174 unsigned char idx
= (offset
> 0x2f) ?
175 AVM_IDX_ISAC_REG_HIGH
: AVM_IDX_ISAC_REG_LOW
;
178 DBG(0x1000, " port %#x, value %#x",
180 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
181 outb(idx
, adapter
->io
+ AVM_INDEX
);
182 outb(value
, adapter
->io
+ AVM_DATA
+ (offset
& 0xf));
183 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
186 static void fcpci_read_isac_fifo(struct isac
*isac
, unsigned char *data
,
189 struct fritz_adapter
*adapter
= isac
->priv
;
192 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
193 outb(AVM_IDX_ISAC_FIFO
, adapter
->io
+ AVM_INDEX
);
194 insb(adapter
->io
+ AVM_DATA
, data
, size
);
195 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
198 static void fcpci_write_isac_fifo(struct isac
*isac
, unsigned char *data
,
201 struct fritz_adapter
*adapter
= isac
->priv
;
204 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
205 outb(AVM_IDX_ISAC_FIFO
, adapter
->io
+ AVM_INDEX
);
206 outsb(adapter
->io
+ AVM_DATA
, data
, size
);
207 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
210 static u32
fcpci_read_hdlc_status(struct fritz_adapter
*adapter
, int nr
)
213 int idx
= nr
? AVM_IDX_HDLC_2
: AVM_IDX_HDLC_1
;
216 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
217 outl(idx
, adapter
->io
+ AVM_INDEX
);
218 val
= inl(adapter
->io
+ AVM_DATA
+ HDLC_STATUS
);
219 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
223 static void __fcpci_write_ctrl(struct fritz_bcs
*bcs
, int which
)
225 struct fritz_adapter
*adapter
= bcs
->adapter
;
226 int idx
= bcs
->channel
? AVM_IDX_HDLC_2
: AVM_IDX_HDLC_1
;
228 DBG(0x40, "hdlc %c wr%x ctrl %x",
229 'A' + bcs
->channel
, which
, bcs
->ctrl
.ctrl
);
231 outl(idx
, adapter
->io
+ AVM_INDEX
);
232 outl(bcs
->ctrl
.ctrl
, adapter
->io
+ AVM_DATA
+ HDLC_CTRL
);
235 static void fcpci_write_ctrl(struct fritz_bcs
*bcs
, int which
)
237 struct fritz_adapter
*adapter
= bcs
->adapter
;
240 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
241 __fcpci_write_ctrl(bcs
, which
);
242 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
245 // ----------------------------------------------------------------------
248 static unsigned char fcpci2_read_isac(struct isac
*isac
, unsigned char offset
)
250 struct fritz_adapter
*adapter
= isac
->priv
;
254 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
255 outl(offset
, adapter
->io
+ AVM_ISACSX_INDEX
);
256 val
= inl(adapter
->io
+ AVM_ISACSX_DATA
);
257 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
258 DBG(0x1000, " port %#x, value %#x",
264 static void fcpci2_write_isac(struct isac
*isac
, unsigned char offset
,
267 struct fritz_adapter
*adapter
= isac
->priv
;
270 DBG(0x1000, " port %#x, value %#x",
272 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
273 outl(offset
, adapter
->io
+ AVM_ISACSX_INDEX
);
274 outl(value
, adapter
->io
+ AVM_ISACSX_DATA
);
275 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
278 static void fcpci2_read_isac_fifo(struct isac
*isac
, unsigned char *data
,
281 struct fritz_adapter
*adapter
= isac
->priv
;
285 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
286 outl(0, adapter
->io
+ AVM_ISACSX_INDEX
);
287 for (i
= 0; i
< size
; i
++)
288 data
[i
] = inl(adapter
->io
+ AVM_ISACSX_DATA
);
289 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
292 static void fcpci2_write_isac_fifo(struct isac
*isac
, unsigned char *data
,
295 struct fritz_adapter
*adapter
= isac
->priv
;
299 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
300 outl(0, adapter
->io
+ AVM_ISACSX_INDEX
);
301 for (i
= 0; i
< size
; i
++)
302 outl(data
[i
], adapter
->io
+ AVM_ISACSX_DATA
);
303 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
306 static u32
fcpci2_read_hdlc_status(struct fritz_adapter
*adapter
, int nr
)
308 int offset
= nr
? AVM_HDLC_STATUS_2
: AVM_HDLC_STATUS_1
;
310 return inl(adapter
->io
+ offset
);
313 static void fcpci2_write_ctrl(struct fritz_bcs
*bcs
, int which
)
315 struct fritz_adapter
*adapter
= bcs
->adapter
;
316 int offset
= bcs
->channel
? AVM_HDLC_STATUS_2
: AVM_HDLC_STATUS_1
;
318 DBG(0x40, "hdlc %c wr%x ctrl %x",
319 'A' + bcs
->channel
, which
, bcs
->ctrl
.ctrl
);
321 outl(bcs
->ctrl
.ctrl
, adapter
->io
+ offset
);
324 // ----------------------------------------------------------------------
325 // Fritz!PnP (ISAC access as for Fritz!PCI)
327 static u32
fcpnp_read_hdlc_status(struct fritz_adapter
*adapter
, int nr
)
329 unsigned char idx
= nr
? AVM_IDX_HDLC_2
: AVM_IDX_HDLC_1
;
333 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
334 outb(idx
, adapter
->io
+ AVM_INDEX
);
335 val
= inb(adapter
->io
+ AVM_DATA
+ HDLC_STATUS
);
336 if (val
& HDLC_INT_RPR
)
337 val
|= inb(adapter
->io
+ AVM_DATA
+ HDLC_STATUS
+ 1) << 8;
338 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
342 static void __fcpnp_write_ctrl(struct fritz_bcs
*bcs
, int which
)
344 struct fritz_adapter
*adapter
= bcs
->adapter
;
345 unsigned char idx
= bcs
->channel
? AVM_IDX_HDLC_2
: AVM_IDX_HDLC_1
;
347 DBG(0x40, "hdlc %c wr%x ctrl %x",
348 'A' + bcs
->channel
, which
, bcs
->ctrl
.ctrl
);
350 outb(idx
, adapter
->io
+ AVM_INDEX
);
352 outb(bcs
->ctrl
.sr
.mode
,
353 adapter
->io
+ AVM_DATA
+ HDLC_STATUS
+ 2);
355 outb(bcs
->ctrl
.sr
.xml
,
356 adapter
->io
+ AVM_DATA
+ HDLC_STATUS
+ 1);
358 outb(bcs
->ctrl
.sr
.cmd
,
359 adapter
->io
+ AVM_DATA
+ HDLC_STATUS
+ 0);
362 static void fcpnp_write_ctrl(struct fritz_bcs
*bcs
, int which
)
364 struct fritz_adapter
*adapter
= bcs
->adapter
;
367 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
368 __fcpnp_write_ctrl(bcs
, which
);
369 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
372 // ----------------------------------------------------------------------
374 static inline void B_L1L2(struct fritz_bcs
*bcs
, int pr
, void *arg
)
376 struct hisax_if
*ifc
= (struct hisax_if
*) &bcs
->b_if
;
378 DBG(2, "pr %#x", pr
);
379 ifc
->l1l2(ifc
, pr
, arg
);
382 static void hdlc_fill_fifo(struct fritz_bcs
*bcs
)
384 struct fritz_adapter
*adapter
= bcs
->adapter
;
385 struct sk_buff
*skb
= bcs
->tx_skb
;
390 DBG(0x40, "hdlc_fill_fifo");
392 BUG_ON(skb
->len
== 0);
394 bcs
->ctrl
.sr
.cmd
&= ~HDLC_CMD_XME
;
395 if (bcs
->tx_skb
->len
> bcs
->fifo_size
) {
396 count
= bcs
->fifo_size
;
398 count
= bcs
->tx_skb
->len
;
399 if (bcs
->mode
!= L1_MODE_TRANS
)
400 bcs
->ctrl
.sr
.cmd
|= HDLC_CMD_XME
;
402 DBG(0x40, "hdlc_fill_fifo %d/%d", count
, bcs
->tx_skb
->len
);
403 p
= bcs
->tx_skb
->data
;
404 skb_pull(bcs
->tx_skb
, count
);
405 bcs
->tx_cnt
+= count
;
406 bcs
->ctrl
.sr
.xml
= ((count
== bcs
->fifo_size
) ? 0 : count
);
408 switch (adapter
->type
) {
410 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
411 // sets the correct AVM_INDEX, too
412 __fcpci_write_ctrl(bcs
, 3);
413 outsl(adapter
->io
+ AVM_DATA
+ HDLC_FIFO
,
415 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
417 case AVM_FRITZ_PCIV2
:
418 fcpci2_write_ctrl(bcs
, 3);
420 (bcs
->channel
? AVM_HDLC_FIFO_2
: AVM_HDLC_FIFO_1
),
424 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
425 // sets the correct AVM_INDEX, too
426 __fcpnp_write_ctrl(bcs
, 3);
427 outsb(adapter
->io
+ AVM_DATA
, p
, count
);
428 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
433 static inline void hdlc_empty_fifo(struct fritz_bcs
*bcs
, int count
)
435 struct fritz_adapter
*adapter
= bcs
->adapter
;
437 unsigned char idx
= bcs
->channel
? AVM_IDX_HDLC_2
: AVM_IDX_HDLC_1
;
439 DBG(0x10, "hdlc_empty_fifo %d", count
);
440 if (bcs
->rcvidx
+ count
> HSCX_BUFMAX
) {
441 DBG(0x10, "hdlc_empty_fifo: incoming packet too large");
444 p
= bcs
->rcvbuf
+ bcs
->rcvidx
;
445 bcs
->rcvidx
+= count
;
446 switch (adapter
->type
) {
448 spin_lock(&adapter
->hw_lock
);
449 outl(idx
, adapter
->io
+ AVM_INDEX
);
450 insl(adapter
->io
+ AVM_DATA
+ HDLC_FIFO
,
452 spin_unlock(&adapter
->hw_lock
);
454 case AVM_FRITZ_PCIV2
:
456 (bcs
->channel
? AVM_HDLC_FIFO_2
: AVM_HDLC_FIFO_1
),
460 spin_lock(&adapter
->hw_lock
);
461 outb(idx
, adapter
->io
+ AVM_INDEX
);
462 insb(adapter
->io
+ AVM_DATA
, p
, count
);
463 spin_unlock(&adapter
->hw_lock
);
468 static inline void hdlc_rpr_irq(struct fritz_bcs
*bcs
, u32 stat
)
470 struct fritz_adapter
*adapter
= bcs
->adapter
;
474 if (stat
& HDLC_STAT_RDO
) {
476 bcs
->ctrl
.sr
.xml
= 0;
477 bcs
->ctrl
.sr
.cmd
|= HDLC_CMD_RRS
;
478 adapter
->write_ctrl(bcs
, 1);
479 bcs
->ctrl
.sr
.cmd
&= ~HDLC_CMD_RRS
;
480 adapter
->write_ctrl(bcs
, 1);
485 len
= (stat
& HDLC_STAT_RML_MASK
) >> 8;
487 len
= bcs
->fifo_size
;
489 hdlc_empty_fifo(bcs
, len
);
491 if ((stat
& HDLC_STAT_RME
) || (bcs
->mode
== L1_MODE_TRANS
)) {
492 if (((stat
& HDLC_STAT_CRCVFRRAB
) == HDLC_STAT_CRCVFR
) ||
493 (bcs
->mode
== L1_MODE_TRANS
)) {
494 skb
= dev_alloc_skb(bcs
->rcvidx
);
496 printk(KERN_WARNING
"HDLC: receive out of memory\n");
498 skb_put_data(skb
, bcs
->rcvbuf
, bcs
->rcvidx
);
500 B_L1L2(bcs
, PH_DATA
| INDICATION
, skb
);
504 DBG(0x10, "ch%d invalid frame %#x",
511 static inline void hdlc_xdu_irq(struct fritz_bcs
*bcs
)
513 struct fritz_adapter
*adapter
= bcs
->adapter
;
516 /* Here we lost an TX interrupt, so
517 * restart transmitting the whole frame.
519 bcs
->ctrl
.sr
.xml
= 0;
520 bcs
->ctrl
.sr
.cmd
|= HDLC_CMD_XRS
;
521 adapter
->write_ctrl(bcs
, 1);
522 bcs
->ctrl
.sr
.cmd
&= ~HDLC_CMD_XRS
;
525 DBG(0x10, "XDU without skb");
526 adapter
->write_ctrl(bcs
, 1);
529 /* only hdlc restarts the frame, transparent mode must continue */
530 if (bcs
->mode
== L1_MODE_HDLC
) {
531 skb_push(bcs
->tx_skb
, bcs
->tx_cnt
);
536 static inline void hdlc_xpr_irq(struct fritz_bcs
*bcs
)
550 B_L1L2(bcs
, PH_DATA
| CONFIRM
, (void *)(unsigned long)skb
->truesize
);
551 dev_kfree_skb_irq(skb
);
554 static void hdlc_irq_one(struct fritz_bcs
*bcs
, u32 stat
)
556 DBG(0x10, "ch%d stat %#x", bcs
->channel
, stat
);
557 if (stat
& HDLC_INT_RPR
) {
559 hdlc_rpr_irq(bcs
, stat
);
561 if (stat
& HDLC_INT_XDU
) {
567 if (stat
& HDLC_INT_XPR
) {
573 static inline void hdlc_irq(struct fritz_adapter
*adapter
)
578 for (nr
= 0; nr
< 2; nr
++) {
579 stat
= adapter
->read_hdlc_status(adapter
, nr
);
580 DBG(0x10, "HDLC %c stat %#x", 'A' + nr
, stat
);
581 if (stat
& HDLC_INT_MASK
)
582 hdlc_irq_one(&adapter
->bcs
[nr
], stat
);
586 static void modehdlc(struct fritz_bcs
*bcs
, int mode
)
588 struct fritz_adapter
*adapter
= bcs
->adapter
;
590 DBG(0x40, "hdlc %c mode %d --> %d",
591 'A' + bcs
->channel
, bcs
->mode
, mode
);
593 if (bcs
->mode
== mode
)
598 bcs
->ctrl
.sr
.cmd
= HDLC_CMD_XRS
| HDLC_CMD_RRS
;
601 bcs
->ctrl
.sr
.mode
= HDLC_MODE_TRANS
;
602 adapter
->write_ctrl(bcs
, 5);
609 if (mode
== L1_MODE_TRANS
) {
610 bcs
->ctrl
.sr
.mode
= HDLC_MODE_TRANS
;
612 bcs
->ctrl
.sr
.mode
= HDLC_MODE_ITF_FLG
;
614 adapter
->write_ctrl(bcs
, 5);
615 bcs
->ctrl
.sr
.cmd
= HDLC_CMD_XRS
;
616 adapter
->write_ctrl(bcs
, 1);
617 bcs
->ctrl
.sr
.cmd
= 0;
623 static void fritz_b_l2l1(struct hisax_if
*ifc
, int pr
, void *arg
)
625 struct fritz_bcs
*bcs
= ifc
->priv
;
626 struct sk_buff
*skb
= arg
;
629 DBG(0x10, "pr %#x", pr
);
632 case PH_DATA
| REQUEST
:
638 case PH_ACTIVATE
| REQUEST
:
640 DBG(4, "B%d,PH_ACTIVATE_REQUEST %d", bcs
->channel
+ 1, mode
);
642 B_L1L2(bcs
, PH_ACTIVATE
| INDICATION
, NULL
);
644 case PH_DEACTIVATE
| REQUEST
:
645 DBG(4, "B%d,PH_DEACTIVATE_REQUEST", bcs
->channel
+ 1);
646 modehdlc(bcs
, L1_MODE_NULL
);
647 B_L1L2(bcs
, PH_DEACTIVATE
| INDICATION
, NULL
);
652 // ----------------------------------------------------------------------
655 fcpci2_irq(int intno
, void *dev
)
657 struct fritz_adapter
*adapter
= dev
;
660 val
= inb(adapter
->io
+ AVM_STATUS0
);
661 if (!(val
& AVM_STATUS0_IRQ_MASK
))
662 /* hopefully a shared IRQ reqest */
664 DBG(2, "STATUS0 %#x", val
);
665 if (val
& AVM_STATUS0_IRQ_ISAC
)
666 isacsx_irq(&adapter
->isac
);
667 if (val
& AVM_STATUS0_IRQ_HDLC
)
669 if (val
& AVM_STATUS0_IRQ_ISAC
)
670 isacsx_irq(&adapter
->isac
);
675 fcpci_irq(int intno
, void *dev
)
677 struct fritz_adapter
*adapter
= dev
;
680 sval
= inb(adapter
->io
+ 2);
681 if ((sval
& AVM_STATUS0_IRQ_MASK
) == AVM_STATUS0_IRQ_MASK
)
682 /* possibly a shared IRQ reqest */
684 DBG(2, "sval %#x", sval
);
685 if (!(sval
& AVM_STATUS0_IRQ_ISAC
))
686 isac_irq(&adapter
->isac
);
688 if (!(sval
& AVM_STATUS0_IRQ_HDLC
))
693 // ----------------------------------------------------------------------
695 static inline void fcpci2_init(struct fritz_adapter
*adapter
)
697 outb(AVM_STATUS0_RES_TIMER
, adapter
->io
+ AVM_STATUS0
);
698 outb(AVM_STATUS0_ENA_IRQ
, adapter
->io
+ AVM_STATUS0
);
702 static inline void fcpci_init(struct fritz_adapter
*adapter
)
704 outb(AVM_STATUS0_DIS_TIMER
| AVM_STATUS0_RES_TIMER
|
705 AVM_STATUS0_ENA_IRQ
, adapter
->io
+ AVM_STATUS0
);
707 outb(AVM_STATUS1_ENA_IOM
| adapter
->irq
,
708 adapter
->io
+ AVM_STATUS1
);
712 // ----------------------------------------------------------------------
714 static int fcpcipnp_setup(struct fritz_adapter
*adapter
)
721 isac_init(&adapter
->isac
); // FIXME is this okay now
724 if (!request_region(adapter
->io
, 32, "fcpcipnp"))
727 switch (adapter
->type
) {
728 case AVM_FRITZ_PCIV2
:
730 val
= inl(adapter
->io
);
733 val
= inb(adapter
->io
);
734 val
|= inb(adapter
->io
+ 1) << 8;
738 DBG(1, "stat %#x Class %X Rev %d",
739 val
, val
& 0xff, (val
>> 8) & 0xff);
741 spin_lock_init(&adapter
->hw_lock
);
742 adapter
->isac
.priv
= adapter
;
743 switch (adapter
->type
) {
744 case AVM_FRITZ_PCIV2
:
745 adapter
->isac
.read_isac
= &fcpci2_read_isac
;
746 adapter
->isac
.write_isac
= &fcpci2_write_isac
;
747 adapter
->isac
.read_isac_fifo
= &fcpci2_read_isac_fifo
;
748 adapter
->isac
.write_isac_fifo
= &fcpci2_write_isac_fifo
;
750 adapter
->read_hdlc_status
= &fcpci2_read_hdlc_status
;
751 adapter
->write_ctrl
= &fcpci2_write_ctrl
;
754 adapter
->isac
.read_isac
= &fcpci_read_isac
;
755 adapter
->isac
.write_isac
= &fcpci_write_isac
;
756 adapter
->isac
.read_isac_fifo
= &fcpci_read_isac_fifo
;
757 adapter
->isac
.write_isac_fifo
= &fcpci_write_isac_fifo
;
759 adapter
->read_hdlc_status
= &fcpci_read_hdlc_status
;
760 adapter
->write_ctrl
= &fcpci_write_ctrl
;
763 adapter
->isac
.read_isac
= &fcpci_read_isac
;
764 adapter
->isac
.write_isac
= &fcpci_write_isac
;
765 adapter
->isac
.read_isac_fifo
= &fcpci_read_isac_fifo
;
766 adapter
->isac
.write_isac_fifo
= &fcpci_write_isac_fifo
;
768 adapter
->read_hdlc_status
= &fcpnp_read_hdlc_status
;
769 adapter
->write_ctrl
= &fcpnp_write_ctrl
;
774 outb(0, adapter
->io
+ AVM_STATUS0
);
776 outb(AVM_STATUS0_RESET
, adapter
->io
+ AVM_STATUS0
);
778 outb(0, adapter
->io
+ AVM_STATUS0
);
781 switch (adapter
->type
) {
782 case AVM_FRITZ_PCIV2
:
783 retval
= request_irq(adapter
->irq
, fcpci2_irq
, IRQF_SHARED
,
784 "fcpcipnp", adapter
);
787 retval
= request_irq(adapter
->irq
, fcpci_irq
, IRQF_SHARED
,
788 "fcpcipnp", adapter
);
791 retval
= request_irq(adapter
->irq
, fcpci_irq
, 0,
792 "fcpcipnp", adapter
);
798 switch (adapter
->type
) {
799 case AVM_FRITZ_PCIV2
:
800 fcpci2_init(adapter
);
801 isacsx_setup(&adapter
->isac
);
806 isac_setup(&adapter
->isac
);
809 val
= adapter
->read_hdlc_status(adapter
, 0);
810 DBG(0x20, "HDLC A STA %x", val
);
811 val
= adapter
->read_hdlc_status(adapter
, 1);
812 DBG(0x20, "HDLC B STA %x", val
);
814 adapter
->bcs
[0].mode
= -1;
815 adapter
->bcs
[1].mode
= -1;
816 modehdlc(&adapter
->bcs
[0], L1_MODE_NULL
);
817 modehdlc(&adapter
->bcs
[1], L1_MODE_NULL
);
822 release_region(adapter
->io
, 32);
827 static void fcpcipnp_release(struct fritz_adapter
*adapter
)
831 outb(0, adapter
->io
+ AVM_STATUS0
);
832 free_irq(adapter
->irq
, adapter
);
833 release_region(adapter
->io
, 32);
836 // ----------------------------------------------------------------------
838 static struct fritz_adapter
*new_adapter(void)
840 struct fritz_adapter
*adapter
;
841 struct hisax_b_if
*b_if
[2];
844 adapter
= kzalloc(sizeof(struct fritz_adapter
), GFP_KERNEL
);
848 adapter
->isac
.hisax_d_if
.owner
= THIS_MODULE
;
849 adapter
->isac
.hisax_d_if
.ifc
.priv
= &adapter
->isac
;
850 adapter
->isac
.hisax_d_if
.ifc
.l2l1
= isac_d_l2l1
;
852 for (i
= 0; i
< 2; i
++) {
853 adapter
->bcs
[i
].adapter
= adapter
;
854 adapter
->bcs
[i
].channel
= i
;
855 adapter
->bcs
[i
].b_if
.ifc
.priv
= &adapter
->bcs
[i
];
856 adapter
->bcs
[i
].b_if
.ifc
.l2l1
= fritz_b_l2l1
;
859 for (i
= 0; i
< 2; i
++)
860 b_if
[i
] = &adapter
->bcs
[i
].b_if
;
862 if (hisax_register(&adapter
->isac
.hisax_d_if
, b_if
, "fcpcipnp",
871 static void delete_adapter(struct fritz_adapter
*adapter
)
873 hisax_unregister(&adapter
->isac
.hisax_d_if
);
877 static int fcpci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
879 struct fritz_adapter
*adapter
;
883 adapter
= new_adapter();
887 pci_set_drvdata(pdev
, adapter
);
889 if (pdev
->device
== PCI_DEVICE_ID_AVM_A1_V2
)
890 adapter
->type
= AVM_FRITZ_PCIV2
;
892 adapter
->type
= AVM_FRITZ_PCI
;
894 retval
= pci_enable_device(pdev
);
898 adapter
->io
= pci_resource_start(pdev
, 1);
899 adapter
->irq
= pdev
->irq
;
901 printk(KERN_INFO
"hisax_fcpcipnp: found adapter %s at %s\n",
902 (char *) ent
->driver_data
, pci_name(pdev
));
904 retval
= fcpcipnp_setup(adapter
);
911 delete_adapter(adapter
);
917 static int fcpnp_probe(struct pnp_dev
*pdev
, const struct pnp_device_id
*dev_id
)
919 struct fritz_adapter
*adapter
;
926 adapter
= new_adapter();
930 pnp_set_drvdata(pdev
, adapter
);
932 adapter
->type
= AVM_FRITZ_PNP
;
934 pnp_disable_dev(pdev
);
935 retval
= pnp_activate_dev(pdev
);
937 printk(KERN_WARNING
"%s: pnp_activate_dev(%s) ret(%d)\n", __func__
,
938 (char *)dev_id
->driver_data
, retval
);
941 adapter
->io
= pnp_port_start(pdev
, 0);
942 adapter
->irq
= pnp_irq(pdev
, 0);
944 printk(KERN_INFO
"hisax_fcpcipnp: found adapter %s at IO %#x irq %d\n",
945 (char *) dev_id
->driver_data
, adapter
->io
, adapter
->irq
);
947 retval
= fcpcipnp_setup(adapter
);
954 delete_adapter(adapter
);
959 static void fcpnp_remove(struct pnp_dev
*pdev
)
961 struct fritz_adapter
*adapter
= pnp_get_drvdata(pdev
);
964 fcpcipnp_release(adapter
);
965 delete_adapter(adapter
);
967 pnp_disable_dev(pdev
);
970 static struct pnp_driver fcpnp_driver
= {
972 .probe
= fcpnp_probe
,
973 .remove
= fcpnp_remove
,
974 .id_table
= fcpnp_ids
,
978 static void fcpci_remove(struct pci_dev
*pdev
)
980 struct fritz_adapter
*adapter
= pci_get_drvdata(pdev
);
982 fcpcipnp_release(adapter
);
983 pci_disable_device(pdev
);
984 delete_adapter(adapter
);
987 static struct pci_driver fcpci_driver
= {
989 .probe
= fcpci_probe
,
990 .remove
= fcpci_remove
,
991 .id_table
= fcpci_ids
,
994 static int __init
hisax_fcpcipnp_init(void)
998 printk(KERN_INFO
"hisax_fcpcipnp: Fritz!Card PCI/PCIv2/PnP ISDN driver v0.0.1\n");
1000 retval
= pci_register_driver(&fcpci_driver
);
1004 retval
= pnp_register_driver(&fcpnp_driver
);
1006 pci_unregister_driver(&fcpci_driver
);
1013 static void __exit
hisax_fcpcipnp_exit(void)
1016 pnp_unregister_driver(&fcpnp_driver
);
1018 pci_unregister_driver(&fcpci_driver
);
1021 module_init(hisax_fcpcipnp_init
);
1022 module_exit(hisax_fcpcipnp_exit
);