1 /* $Id: config.c,v 2.84.2.5 2004/02/11 13:21:33 keil Exp $
4 * Copyright by Karsten Keil <keil@isdn4linux.de>
5 * by Kai Germaschewski <kai.germaschewski@gmx.de>
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
10 * For changes and modifications please read
11 * Documentation/isdn/HiSax.cert
13 * based on the teles driver from Jan den Ouden
17 #include <linux/types.h>
18 #include <linux/stddef.h>
19 #include <linux/timer.h>
20 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/kernel_stat.h>
24 #include <linux/workqueue.h>
25 #include <linux/interrupt.h>
26 #define HISAX_STATUS_BUFSIZE 4096
29 * This structure array contains one entry per card. An entry looks
32 * { type, protocol, p0, p1, p2, NULL }
35 * 1 Teles 16.0 p0=irq p1=membase p2=iobase
36 * 2 Teles 8.0 p0=irq p1=membase
37 * 3 Teles 16.3 p0=irq p1=iobase
38 * 4 Creatix PNP p0=irq p1=IO0 (ISAC) p2=IO1 (HSCX)
39 * 5 AVM A1 (Fritz) p0=irq p1=iobase
40 * 6 ELSA PC [p0=iobase] or nothing (autodetect)
41 * 7 ELSA Quickstep p0=irq p1=iobase
42 * 8 Teles PCMCIA p0=irq p1=iobase
43 * 9 ITK ix1-micro p0=irq p1=iobase
44 * 10 ELSA PCMCIA p0=irq p1=iobase
45 * 11 Eicon.Diehl Diva p0=irq p1=iobase
46 * 12 Asuscom ISDNLink p0=irq p1=iobase
47 * 13 Teleint p0=irq p1=iobase
48 * 14 Teles 16.3c p0=irq p1=iobase
49 * 15 Sedlbauer speed p0=irq p1=iobase
50 * 15 Sedlbauer PC/104 p0=irq p1=iobase
51 * 15 Sedlbauer speed pci no parameter
52 * 16 USR Sportster internal p0=irq p1=iobase
53 * 17 MIC card p0=irq p1=iobase
54 * 18 ELSA Quickstep 1000PCI no parameter
55 * 19 Compaq ISDN S0 ISA card p0=irq p1=IO0 (HSCX) p2=IO1 (ISAC) p3=IO2
56 * 20 Travers Technologies NETjet-S PCI card
57 * 21 TELES PCI no parameter
58 * 22 Sedlbauer Speed Star p0=irq p1=iobase
60 * 24 Dr Neuhaus Niccy PnP/PCI card p0=irq p1=IO0 p2=IO1 (PnP only)
61 * 25 Teles S0Box p0=irq p1=iobase (from isapnp setup)
62 * 26 AVM A1 PCMCIA (Fritz) p0=irq p1=iobase
63 * 27 AVM PnP/PCI p0=irq p1=iobase (PCI no parameter)
64 * 28 Sedlbauer Speed Fax+ p0=irq p1=iobase (from isapnp setup)
65 * 29 Siemens I-Surf p0=irq p1=iobase p2=memory (from isapnp setup)
66 * 30 ACER P10 p0=irq p1=iobase (from isapnp setup)
67 * 31 HST Saphir p0=irq p1=iobase
69 * 33 Scitel Quadro p0=subcontroller (4*S0, subctrl 1...4)
71 * 35 HFC 2BDS0 PCI none
72 * 36 Winbond 6692 PCI none
73 * 37 HFC 2BDS0 S+/SP p0=irq p1=iobase
74 * 38 Travers Technologies NETspider-U PCI card
75 * 39 HFC 2BDS0-SP PCMCIA p0=irq p1=iobase
76 * 40 hotplug interface
77 * 41 Formula-n enter:now ISDN PCI a/b none
79 * protocol can be either ISDN_PTYPE_EURO or ISDN_PTYPE_1TR6 or ISDN_PTYPE_NI1
84 const char *CardType
[] = {
85 "No Card", "Teles 16.0", "Teles 8.0", "Teles 16.3",
86 "Creatix/Teles PnP", "AVM A1", "Elsa ML", "Elsa Quickstep",
87 "Teles PCMCIA", "ITK ix1-micro Rev.2", "Elsa PCMCIA",
88 "Eicon.Diehl Diva", "ISDNLink", "TeleInt", "Teles 16.3c",
89 "Sedlbauer Speed Card", "USR Sportster", "ith mic Linux",
90 "Elsa PCI", "Compaq ISA", "NETjet-S", "Teles PCI",
91 "Sedlbauer Speed Star (PCMCIA)", "AMD 7930", "NICCY", "S0Box",
92 "AVM A1 (PCMCIA)", "AVM Fritz PnP/PCI", "Sedlbauer Speed Fax +",
93 "Siemens I-Surf", "Acer P10", "HST Saphir", "Telekom A4T",
94 "Scitel Quadro", "Gazel", "HFC 2BDS0 PCI", "Winbond 6692",
95 "HFC 2BDS0 SX", "NETspider-U", "HFC-2BDS0-SP PCMCIA",
96 "Hotplug", "Formula-n enter:now PCI a/b",
99 #ifdef CONFIG_HISAX_ELSA
100 #define DEFAULT_CARD ISDN_CTYPE_ELSA
101 #define DEFAULT_CFG {0,0,0,0}
104 #ifdef CONFIG_HISAX_AVM_A1
107 #define DEFAULT_CARD ISDN_CTYPE_A1
108 #define DEFAULT_CFG {10,0x340,0,0}
111 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
114 #define DEFAULT_CARD ISDN_CTYPE_A1_PCMCIA
115 #define DEFAULT_CFG {11,0x170,0,0}
118 #ifdef CONFIG_HISAX_FRITZPCI
121 #define DEFAULT_CARD ISDN_CTYPE_FRITZPCI
122 #define DEFAULT_CFG {0,0,0,0}
125 #ifdef CONFIG_HISAX_16_3
128 #define DEFAULT_CARD ISDN_CTYPE_16_3
129 #define DEFAULT_CFG {15,0x180,0,0}
132 #ifdef CONFIG_HISAX_S0BOX
135 #define DEFAULT_CARD ISDN_CTYPE_S0BOX
136 #define DEFAULT_CFG {7,0x378,0,0}
139 #ifdef CONFIG_HISAX_16_0
142 #define DEFAULT_CARD ISDN_CTYPE_16_0
143 #define DEFAULT_CFG {15,0xd0000,0xd80,0}
146 #ifdef CONFIG_HISAX_TELESPCI
149 #define DEFAULT_CARD ISDN_CTYPE_TELESPCI
150 #define DEFAULT_CFG {0,0,0,0}
153 #ifdef CONFIG_HISAX_IX1MICROR2
156 #define DEFAULT_CARD ISDN_CTYPE_IX1MICROR2
157 #define DEFAULT_CFG {5,0x390,0,0}
160 #ifdef CONFIG_HISAX_DIEHLDIVA
163 #define DEFAULT_CARD ISDN_CTYPE_DIEHLDIVA
164 #define DEFAULT_CFG {0,0x0,0,0}
167 #ifdef CONFIG_HISAX_ASUSCOM
170 #define DEFAULT_CARD ISDN_CTYPE_ASUSCOM
171 #define DEFAULT_CFG {5,0x200,0,0}
174 #ifdef CONFIG_HISAX_TELEINT
177 #define DEFAULT_CARD ISDN_CTYPE_TELEINT
178 #define DEFAULT_CFG {5,0x300,0,0}
181 #ifdef CONFIG_HISAX_SEDLBAUER
184 #define DEFAULT_CARD ISDN_CTYPE_SEDLBAUER
185 #define DEFAULT_CFG {11,0x270,0,0}
188 #ifdef CONFIG_HISAX_SPORTSTER
191 #define DEFAULT_CARD ISDN_CTYPE_SPORTSTER
192 #define DEFAULT_CFG {7,0x268,0,0}
195 #ifdef CONFIG_HISAX_MIC
198 #define DEFAULT_CARD ISDN_CTYPE_MIC
199 #define DEFAULT_CFG {12,0x3e0,0,0}
202 #ifdef CONFIG_HISAX_NETJET
205 #define DEFAULT_CARD ISDN_CTYPE_NETJET_S
206 #define DEFAULT_CFG {0,0,0,0}
209 #ifdef CONFIG_HISAX_HFCS
212 #define DEFAULT_CARD ISDN_CTYPE_TELES3C
213 #define DEFAULT_CFG {5,0x500,0,0}
216 #ifdef CONFIG_HISAX_HFC_PCI
219 #define DEFAULT_CARD ISDN_CTYPE_HFC_PCI
220 #define DEFAULT_CFG {0,0,0,0}
223 #ifdef CONFIG_HISAX_HFC_SX
226 #define DEFAULT_CARD ISDN_CTYPE_HFC_SX
227 #define DEFAULT_CFG {5,0x2E0,0,0}
231 #ifdef CONFIG_HISAX_AMD7930
234 #define DEFAULT_CARD ISDN_CTYPE_AMD7930
235 #define DEFAULT_CFG {12,0x3e0,0,0}
238 #ifdef CONFIG_HISAX_NICCY
241 #define DEFAULT_CARD ISDN_CTYPE_NICCY
242 #define DEFAULT_CFG {0,0x0,0,0}
245 #ifdef CONFIG_HISAX_ISURF
248 #define DEFAULT_CARD ISDN_CTYPE_ISURF
249 #define DEFAULT_CFG {5,0x100,0xc8000,0}
252 #ifdef CONFIG_HISAX_HSTSAPHIR
255 #define DEFAULT_CARD ISDN_CTYPE_HSTSAPHIR
256 #define DEFAULT_CFG {5,0x250,0,0}
259 #ifdef CONFIG_HISAX_BKM_A4T
262 #define DEFAULT_CARD ISDN_CTYPE_BKM_A4T
263 #define DEFAULT_CFG {0,0x0,0,0}
266 #ifdef CONFIG_HISAX_SCT_QUADRO
269 #define DEFAULT_CARD ISDN_CTYPE_SCT_QUADRO
270 #define DEFAULT_CFG {1,0x0,0,0}
273 #ifdef CONFIG_HISAX_GAZEL
276 #define DEFAULT_CARD ISDN_CTYPE_GAZEL
277 #define DEFAULT_CFG {15,0x180,0,0}
280 #ifdef CONFIG_HISAX_W6692
283 #define DEFAULT_CARD ISDN_CTYPE_W6692
284 #define DEFAULT_CFG {0,0,0,0}
287 #ifdef CONFIG_HISAX_NETJET_U
290 #define DEFAULT_CARD ISDN_CTYPE_NETJET_U
291 #define DEFAULT_CFG {0,0,0,0}
294 #ifdef CONFIG_HISAX_1TR6
295 #define DEFAULT_PROTO ISDN_PTYPE_1TR6
296 #define DEFAULT_PROTO_NAME "1TR6"
298 #ifdef CONFIG_HISAX_NI1
300 #define DEFAULT_PROTO ISDN_PTYPE_NI1
301 #undef DEFAULT_PROTO_NAME
302 #define DEFAULT_PROTO_NAME "NI1"
304 #ifdef CONFIG_HISAX_EURO
306 #define DEFAULT_PROTO ISDN_PTYPE_EURO
307 #undef DEFAULT_PROTO_NAME
308 #define DEFAULT_PROTO_NAME "EURO"
310 #ifndef DEFAULT_PROTO
311 #define DEFAULT_PROTO ISDN_PTYPE_UNKNOWN
312 #define DEFAULT_PROTO_NAME "UNKNOWN"
315 #define DEFAULT_CARD 0
316 #define DEFAULT_CFG {0,0,0,0}
319 #define FIRST_CARD { \
326 struct IsdnCard cards
[HISAX_MAX_CARDS
] = {
330 #define HISAX_IDSIZE (HISAX_MAX_CARDS*8)
331 static char HiSaxID
[HISAX_IDSIZE
] = { 0, };
333 static char *HiSax_id
= HiSaxID
;
335 /* Variables for insmod */
336 static int type
[HISAX_MAX_CARDS
] = { 0, };
337 static int protocol
[HISAX_MAX_CARDS
] = { 0, };
338 static int io
[HISAX_MAX_CARDS
] = { 0, };
340 #ifdef CONFIG_HISAX_16_3
343 #ifdef CONFIG_HISAX_NICCY
348 static int io0
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
349 static int io1
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
351 static int irq
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
352 static int mem
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
353 static char *id
= HiSaxID
;
355 MODULE_DESCRIPTION("ISDN4Linux: Driver for passive ISDN cards");
356 MODULE_AUTHOR("Karsten Keil");
357 MODULE_LICENSE("GPL");
358 module_param_array(type
, int, NULL
, 0);
359 module_param_array(protocol
, int, NULL
, 0);
360 module_param_array(io
, int, NULL
, 0);
361 module_param_array(irq
, int, NULL
, 0);
362 module_param_array(mem
, int, NULL
, 0);
363 module_param(id
, charp
, 0);
365 module_param_array(io0
, int, NULL
, 0);
366 module_param_array(io1
, int, NULL
, 0);
372 extern char *l1_revision
;
373 extern char *l2_revision
;
374 extern char *l3_revision
;
375 extern char *lli_revision
;
376 extern char *tei_revision
;
378 char *HiSax_getrev(const char *revision
)
383 if ((p
= strchr(revision
, ':'))) {
385 p
= strchr(rev
, '$');
392 static void __init
HiSaxVersion(void)
396 printk(KERN_INFO
"HiSax: Linux Driver for passive ISDN cards\n");
398 printk(KERN_INFO
"HiSax: Version 3.5 (module)\n");
400 printk(KERN_INFO
"HiSax: Version 3.5 (kernel)\n");
402 strcpy(tmp
, l1_revision
);
403 printk(KERN_INFO
"HiSax: Layer1 Revision %s\n", HiSax_getrev(tmp
));
404 strcpy(tmp
, l2_revision
);
405 printk(KERN_INFO
"HiSax: Layer2 Revision %s\n", HiSax_getrev(tmp
));
406 strcpy(tmp
, tei_revision
);
407 printk(KERN_INFO
"HiSax: TeiMgr Revision %s\n", HiSax_getrev(tmp
));
408 strcpy(tmp
, l3_revision
);
409 printk(KERN_INFO
"HiSax: Layer3 Revision %s\n", HiSax_getrev(tmp
));
410 strcpy(tmp
, lli_revision
);
411 printk(KERN_INFO
"HiSax: LinkLayer Revision %s\n",
416 #define MAX_ARG (HISAX_MAX_CARDS*5)
417 static int __init
HiSax_setup(char *line
)
420 int ints
[MAX_ARG
+ 1];
423 str
= get_options(line
, MAX_ARG
, ints
);
425 printk(KERN_DEBUG
"HiSax_setup: argc(%d) str(%s)\n", argc
, str
);
428 while (argc
&& (i
< HISAX_MAX_CARDS
)) {
429 cards
[i
].protocol
= DEFAULT_PROTO
;
431 cards
[i
].typ
= ints
[j
];
436 cards
[i
].protocol
= ints
[j
];
441 cards
[i
].para
[0] = ints
[j
];
446 cards
[i
].para
[1] = ints
[j
];
451 cards
[i
].para
[2] = ints
[j
];
458 if (strlen(str
) < HISAX_IDSIZE
)
459 strcpy(HiSaxID
, str
);
461 printk(KERN_WARNING
"HiSax: ID too long!");
463 strcpy(HiSaxID
, "HiSax");
469 __setup("hisax=", HiSax_setup
);
473 extern int setup_teles0(struct IsdnCard
*card
);
477 extern int setup_teles3(struct IsdnCard
*card
);
481 extern int setup_s0box(struct IsdnCard
*card
);
485 extern int setup_telespci(struct IsdnCard
*card
);
489 extern int setup_avm_a1(struct IsdnCard
*card
);
492 #if CARD_AVM_A1_PCMCIA
493 extern int setup_avm_a1_pcmcia(struct IsdnCard
*card
);
497 extern int setup_avm_pcipnp(struct IsdnCard
*card
);
501 extern int setup_elsa(struct IsdnCard
*card
);
505 extern int setup_ix1micro(struct IsdnCard
*card
);
509 extern int setup_diva(struct IsdnCard
*card
);
513 extern int setup_asuscom(struct IsdnCard
*card
);
517 extern int setup_TeleInt(struct IsdnCard
*card
);
521 extern int setup_sedlbauer(struct IsdnCard
*card
);
525 extern int setup_sportster(struct IsdnCard
*card
);
529 extern int setup_mic(struct IsdnCard
*card
);
533 extern int setup_netjet_s(struct IsdnCard
*card
);
537 extern int setup_hfcs(struct IsdnCard
*card
);
541 extern int setup_hfcpci(struct IsdnCard
*card
);
545 extern int setup_hfcsx(struct IsdnCard
*card
);
549 extern int setup_amd7930(struct IsdnCard
*card
);
553 extern int setup_niccy(struct IsdnCard
*card
);
557 extern int setup_isurf(struct IsdnCard
*card
);
561 extern int setup_saphir(struct IsdnCard
*card
);
565 extern int setup_testemu(struct IsdnCard
*card
);
569 extern int setup_bkm_a4t(struct IsdnCard
*card
);
573 extern int setup_sct_quadro(struct IsdnCard
*card
);
577 extern int setup_gazel(struct IsdnCard
*card
);
581 extern int setup_w6692(struct IsdnCard
*card
);
585 extern int setup_netjet_u(struct IsdnCard
*card
);
588 #if CARD_FN_ENTERNOW_PCI
589 extern int setup_enternow_pci(struct IsdnCard
*card
);
593 * Find card with given driverId
595 static inline struct IsdnCardState
*hisax_findcard(int driverid
)
599 for (i
= 0; i
< nrcards
; i
++)
601 if (cards
[i
].cs
->myid
== driverid
)
607 * Find card with given card number
610 struct IsdnCardState
*hisax_get_card(int cardnr
)
612 if ((cardnr
<= nrcards
) && (cardnr
> 0))
613 if (cards
[cardnr
- 1].cs
)
614 return cards
[cardnr
- 1].cs
;
619 static int HiSax_readstatus(u_char __user
*buf
, int len
, int id
, int channel
)
622 u_char __user
*p
= buf
;
623 struct IsdnCardState
*cs
= hisax_findcard(id
);
626 if (len
> HISAX_STATUS_BUFSIZE
) {
628 "HiSax: status overflow readstat %d/%d\n",
629 len
, HISAX_STATUS_BUFSIZE
);
631 count
= cs
->status_end
- cs
->status_read
+ 1;
634 copy_to_user(p
, cs
->status_read
, count
);
635 cs
->status_read
+= count
;
636 if (cs
->status_read
> cs
->status_end
)
637 cs
->status_read
= cs
->status_buf
;
641 if (count
> HISAX_STATUS_BUFSIZE
)
642 cnt
= HISAX_STATUS_BUFSIZE
;
645 copy_to_user(p
, cs
->status_read
, cnt
);
647 cs
->status_read
+= cnt
% HISAX_STATUS_BUFSIZE
;
653 "HiSax: if_readstatus called with invalid driverId!\n");
658 int jiftime(char *s
, long mark
)
663 *s
-- = mark
% 10 + '0';
665 *s
-- = mark
% 10 + '0';
668 *s
-- = mark
% 10 + '0';
670 *s
-- = mark
% 6 + '0';
673 *s
-- = mark
% 10 + '0';
675 *s
-- = mark
% 10 + '0';
679 static u_char tmpbuf
[HISAX_STATUS_BUFSIZE
];
681 void VHiSax_putstatus(struct IsdnCardState
*cs
, char *head
, char *fmt
,
684 /* if head == NULL the fmt contains the full info */
693 printk(KERN_WARNING
"HiSax: No CardStatus for message");
696 spin_lock_irqsave(&cs
->statlock
, flags
);
699 p
+= jiftime(p
, jiffies
);
700 p
+= sprintf(p
, " %s", head
);
701 p
+= vsprintf(p
, fmt
, args
);
710 if (len
> HISAX_STATUS_BUFSIZE
) {
711 spin_unlock_irqrestore(&cs
->statlock
, flags
);
712 printk(KERN_WARNING
"HiSax: status overflow %d/%d\n",
713 len
, HISAX_STATUS_BUFSIZE
);
717 i
= cs
->status_end
- cs
->status_write
+ 1;
721 memcpy(cs
->status_write
, p
, i
);
722 cs
->status_write
+= i
;
723 if (cs
->status_write
> cs
->status_end
)
724 cs
->status_write
= cs
->status_buf
;
727 memcpy(cs
->status_write
, p
, len
);
728 cs
->status_write
+= len
;
730 #ifdef KERNELSTACK_DEBUG
731 i
= (ulong
) & len
- current
->kernel_stack_page
;
732 sprintf(tmpbuf
, "kstack %s %lx use %ld\n", current
->comm
,
733 current
->kernel_stack_page
, i
);
734 len
= strlen(tmpbuf
);
735 for (p
= tmpbuf
, i
= len
; i
> 0; i
--, p
++) {
736 *cs
->status_write
++ = *p
;
737 if (cs
->status_write
> cs
->status_end
)
738 cs
->status_write
= cs
->status_buf
;
742 spin_unlock_irqrestore(&cs
->statlock
, flags
);
744 ic
.command
= ISDN_STAT_STAVAIL
;
745 ic
.driver
= cs
->myid
;
747 cs
->iif
.statcallb(&ic
);
751 void HiSax_putstatus(struct IsdnCardState
*cs
, char *head
, char *fmt
, ...)
756 VHiSax_putstatus(cs
, head
, fmt
, args
);
760 int ll_run(struct IsdnCardState
*cs
, int addfeatures
)
764 ic
.driver
= cs
->myid
;
765 ic
.command
= ISDN_STAT_RUN
;
766 cs
->iif
.features
|= addfeatures
;
767 cs
->iif
.statcallb(&ic
);
771 static void ll_stop(struct IsdnCardState
*cs
)
775 ic
.command
= ISDN_STAT_STOP
;
776 ic
.driver
= cs
->myid
;
777 cs
->iif
.statcallb(&ic
);
778 // CallcFreeChan(cs);
781 static void ll_unload(struct IsdnCardState
*cs
)
785 ic
.command
= ISDN_STAT_UNLOAD
;
786 ic
.driver
= cs
->myid
;
787 cs
->iif
.statcallb(&ic
);
788 kfree(cs
->status_buf
);
789 cs
->status_read
= NULL
;
790 cs
->status_write
= NULL
;
791 cs
->status_end
= NULL
;
796 static void closecard(int cardnr
)
798 struct IsdnCardState
*csta
= cards
[cardnr
].cs
;
800 if (csta
->bcs
->BC_Close
!= NULL
) {
801 csta
->bcs
->BC_Close(csta
->bcs
+ 1);
802 csta
->bcs
->BC_Close(csta
->bcs
);
805 skb_queue_purge(&csta
->rq
);
806 skb_queue_purge(&csta
->sq
);
810 dev_kfree_skb(csta
->tx_skb
);
813 if (csta
->DC_Close
!= NULL
) {
814 csta
->DC_Close(csta
);
817 csta
->cardmsg(csta
, CARD_RELEASE
, NULL
);
818 if (csta
->dbusytimer
.function
!= NULL
) // FIXME?
819 del_timer(&csta
->dbusytimer
);
823 static int init_card(struct IsdnCardState
*cs
)
825 int irq_cnt
, cnt
= 3, ret
;
828 ret
= cs
->cardmsg(cs
, CARD_INIT
, NULL
);
831 irq_cnt
= kstat_irqs(cs
->irq
);
832 printk(KERN_INFO
"%s: IRQ %d count %d\n", CardType
[cs
->typ
],
834 if (request_irq(cs
->irq
, cs
->irq_func
, cs
->irq_flags
, "HiSax", cs
)) {
835 printk(KERN_WARNING
"HiSax: couldn't get interrupt %d\n",
840 cs
->cardmsg(cs
, CARD_INIT
, NULL
);
843 printk(KERN_INFO
"%s: IRQ %d count %d\n",
844 CardType
[cs
->typ
], cs
->irq
, kstat_irqs(cs
->irq
));
845 if (kstat_irqs(cs
->irq
) == irq_cnt
) {
847 "%s: IRQ(%d) getting no interrupts during init %d\n",
848 CardType
[cs
->typ
], cs
->irq
, 4 - cnt
);
850 free_irq(cs
->irq
, cs
);
853 cs
->cardmsg(cs
, CARD_RESET
, NULL
);
857 cs
->cardmsg(cs
, CARD_TEST
, NULL
);
864 static int checkcard(int cardnr
, char *id
, int *busy_flag
, struct module
*lockowner
)
867 struct IsdnCard
*card
= cards
+ cardnr
;
868 struct IsdnCardState
*cs
;
870 cs
= kmalloc(sizeof(struct IsdnCardState
), GFP_ATOMIC
);
873 "HiSax: No memory for IsdnCardState(card %d)\n",
877 memset(cs
, 0, sizeof(struct IsdnCardState
));
879 spin_lock_init(&cs
->statlock
);
880 spin_lock_init(&cs
->lock
);
881 cs
->chanlimit
= 2; /* maximum B-channel number */
882 cs
->logecho
= 0; /* No echo logging */
884 cs
->debug
= L1_DEB_WARN
;
886 cs
->busy_flag
= busy_flag
;
887 cs
->irq_flags
= I4L_IRQ_FLAG
;
889 if (card
->protocol
== ISDN_PTYPE_NI1
)
890 test_and_set_bit(FLG_TWO_DCHAN
, &cs
->HW_Flags
);
892 test_and_set_bit(FLG_TWO_DCHAN
, &cs
->HW_Flags
);
894 cs
->protocol
= card
->protocol
;
896 if (card
->typ
<= 0 || card
->typ
> ISDN_CTYPE_COUNT
) {
898 "HiSax: Card Type %d out of range\n", card
->typ
);
901 if (!(cs
->dlog
= kmalloc(MAX_DLOG_SPACE
, GFP_ATOMIC
))) {
903 "HiSax: No memory for dlog(card %d)\n", cardnr
+ 1);
906 if (!(cs
->status_buf
= kmalloc(HISAX_STATUS_BUFSIZE
, GFP_ATOMIC
))) {
908 "HiSax: No memory for status_buf(card %d)\n",
913 cs
->status_read
= cs
->status_buf
;
914 cs
->status_write
= cs
->status_buf
;
915 cs
->status_end
= cs
->status_buf
+ HISAX_STATUS_BUFSIZE
- 1;
918 cs
->iif
.owner
= lockowner
;
920 strcpy(cs
->iif
.id
, id
);
921 cs
->iif
.channels
= 2;
922 cs
->iif
.maxbufsize
= MAX_DATA_SIZE
;
923 cs
->iif
.hl_hdrlen
= MAX_HEADER_LEN
;
925 ISDN_FEATURE_L2_X75I
|
926 ISDN_FEATURE_L2_HDLC
|
927 ISDN_FEATURE_L2_HDLC_56K
|
928 ISDN_FEATURE_L2_TRANS
|
929 ISDN_FEATURE_L3_TRANS
|
930 #ifdef CONFIG_HISAX_1TR6
931 ISDN_FEATURE_P_1TR6
|
933 #ifdef CONFIG_HISAX_EURO
934 ISDN_FEATURE_P_EURO
|
936 #ifdef CONFIG_HISAX_NI1
941 cs
->iif
.command
= HiSax_command
;
942 cs
->iif
.writecmd
= NULL
;
943 cs
->iif
.writebuf_skb
= HiSax_writebuf_skb
;
944 cs
->iif
.readstat
= HiSax_readstatus
;
945 register_isdn(&cs
->iif
);
946 cs
->myid
= cs
->iif
.channels
;
948 "HiSax: Card %d Protocol %s Id=%s (%d)\n", cardnr
+ 1,
949 (card
->protocol
== ISDN_PTYPE_1TR6
) ? "1TR6" :
950 (card
->protocol
== ISDN_PTYPE_EURO
) ? "EDSS1" :
951 (card
->protocol
== ISDN_PTYPE_LEASED
) ? "LEASED" :
952 (card
->protocol
== ISDN_PTYPE_NI1
) ? "NI1" :
953 "NONE", cs
->iif
.id
, cs
->myid
);
956 case ISDN_CTYPE_16_0
:
958 ret
= setup_teles0(card
);
962 case ISDN_CTYPE_16_3
:
964 case ISDN_CTYPE_TELESPCMCIA
:
965 case ISDN_CTYPE_COMPAQ_ISA
:
966 ret
= setup_teles3(card
);
970 case ISDN_CTYPE_S0BOX
:
971 ret
= setup_s0box(card
);
975 case ISDN_CTYPE_TELESPCI
:
976 ret
= setup_telespci(card
);
981 ret
= setup_avm_a1(card
);
984 #if CARD_AVM_A1_PCMCIA
985 case ISDN_CTYPE_A1_PCMCIA
:
986 ret
= setup_avm_a1_pcmcia(card
);
990 case ISDN_CTYPE_FRITZPCI
:
991 ret
= setup_avm_pcipnp(card
);
995 case ISDN_CTYPE_ELSA
:
996 case ISDN_CTYPE_ELSA_PNP
:
997 case ISDN_CTYPE_ELSA_PCMCIA
:
998 case ISDN_CTYPE_ELSA_PCI
:
999 ret
= setup_elsa(card
);
1003 case ISDN_CTYPE_IX1MICROR2
:
1004 ret
= setup_ix1micro(card
);
1008 case ISDN_CTYPE_DIEHLDIVA
:
1009 ret
= setup_diva(card
);
1013 case ISDN_CTYPE_ASUSCOM
:
1014 ret
= setup_asuscom(card
);
1018 case ISDN_CTYPE_TELEINT
:
1019 ret
= setup_TeleInt(card
);
1023 case ISDN_CTYPE_SEDLBAUER
:
1024 case ISDN_CTYPE_SEDLBAUER_PCMCIA
:
1025 case ISDN_CTYPE_SEDLBAUER_FAX
:
1026 ret
= setup_sedlbauer(card
);
1030 case ISDN_CTYPE_SPORTSTER
:
1031 ret
= setup_sportster(card
);
1035 case ISDN_CTYPE_MIC
:
1036 ret
= setup_mic(card
);
1040 case ISDN_CTYPE_NETJET_S
:
1041 ret
= setup_netjet_s(card
);
1045 case ISDN_CTYPE_TELES3C
:
1046 case ISDN_CTYPE_ACERP10
:
1047 ret
= setup_hfcs(card
);
1051 case ISDN_CTYPE_HFC_PCI
:
1052 ret
= setup_hfcpci(card
);
1056 case ISDN_CTYPE_HFC_SX
:
1057 ret
= setup_hfcsx(card
);
1061 case ISDN_CTYPE_NICCY
:
1062 ret
= setup_niccy(card
);
1066 case ISDN_CTYPE_AMD7930
:
1067 ret
= setup_amd7930(card
);
1071 case ISDN_CTYPE_ISURF
:
1072 ret
= setup_isurf(card
);
1076 case ISDN_CTYPE_HSTSAPHIR
:
1077 ret
= setup_saphir(card
);
1081 case ISDN_CTYPE_TESTEMU
:
1082 ret
= setup_testemu(card
);
1086 case ISDN_CTYPE_BKM_A4T
:
1087 ret
= setup_bkm_a4t(card
);
1091 case ISDN_CTYPE_SCT_QUADRO
:
1092 ret
= setup_sct_quadro(card
);
1096 case ISDN_CTYPE_GAZEL
:
1097 ret
= setup_gazel(card
);
1101 case ISDN_CTYPE_W6692
:
1102 ret
= setup_w6692(card
);
1106 case ISDN_CTYPE_NETJET_U
:
1107 ret
= setup_netjet_u(card
);
1110 #if CARD_FN_ENTERNOW_PCI
1111 case ISDN_CTYPE_ENTERNOW
:
1112 ret
= setup_enternow_pci(card
);
1115 case ISDN_CTYPE_DYNAMIC
:
1120 "HiSax: Support for %s Card not selected\n",
1121 CardType
[card
->typ
]);
1129 if (!(cs
->rcvbuf
= kmalloc(MAX_DFRAME_LEN_L1
, GFP_ATOMIC
))) {
1130 printk(KERN_WARNING
"HiSax: No memory for isac rcvbuf\n");
1138 cs
->tqueue
.data
= cs
;
1140 skb_queue_head_init(&cs
->rq
);
1141 skb_queue_head_init(&cs
->sq
);
1143 init_bcstate(cs
, 0);
1144 init_bcstate(cs
, 1);
1146 /* init_card only handles interrupts which are not */
1147 /* used here for the loadable driver */
1148 switch (card
->typ
) {
1149 case ISDN_CTYPE_DYNAMIC
:
1153 ret
= init_card(cs
);
1161 init_tei(cs
, cs
->protocol
);
1162 ret
= CallcNewChan(cs
);
1168 /* ISAR needs firmware download first */
1169 if (!test_bit(HW_ISAR
, &cs
->HW_Flags
))
1184 static void HiSax_shiftcards(int idx
)
1188 for (i
= idx
; i
< (HISAX_MAX_CARDS
- 1); i
++)
1189 memcpy(&cards
[i
], &cards
[i
+ 1], sizeof(cards
[i
]));
1192 static int HiSax_inithardware(int *busy_flag
)
1199 char *next_id
= HiSax_id
;
1202 if (strchr(HiSax_id
, ','))
1204 else if (strchr(HiSax_id
, '%'))
1207 while (i
< nrcards
) {
1208 if (cards
[i
].typ
< 1)
1211 if ((next_id
= strchr(id
, t
))) {
1220 sprintf(ids
, "%s%d", id
, i
);
1222 if (checkcard(i
, ids
, busy_flag
, THIS_MODULE
)) {
1226 /* make sure we don't oops the module */
1227 if (cards
[i
].typ
> 0 && cards
[i
].typ
<= ISDN_CTYPE_COUNT
) {
1229 "HiSax: Card %s not installed !\n",
1230 CardType
[cards
[i
].typ
]);
1232 HiSax_shiftcards(i
);
1239 void HiSax_closecard(int cardnr
)
1241 int i
, last
= nrcards
- 1;
1243 if (cardnr
> last
|| cardnr
< 0)
1245 if (cards
[cardnr
].cs
) {
1246 ll_stop(cards
[cardnr
].cs
);
1247 release_tei(cards
[cardnr
].cs
);
1248 CallcFreeChan(cards
[cardnr
].cs
);
1251 if (cards
[cardnr
].cs
->irq
)
1252 free_irq(cards
[cardnr
].cs
->irq
, cards
[cardnr
].cs
);
1253 kfree((void *) cards
[cardnr
].cs
);
1254 cards
[cardnr
].cs
= NULL
;
1258 cards
[i
] = cards
[i
+ 1];
1264 void HiSax_reportcard(int cardnr
, int sel
)
1266 struct IsdnCardState
*cs
= cards
[cardnr
].cs
;
1268 printk(KERN_DEBUG
"HiSax: reportcard No %d\n", cardnr
+ 1);
1269 printk(KERN_DEBUG
"HiSax: Type %s\n", CardType
[cs
->typ
]);
1270 printk(KERN_DEBUG
"HiSax: debuglevel %x\n", cs
->debug
);
1271 printk(KERN_DEBUG
"HiSax: HiSax_reportcard address 0x%lX\n",
1272 (ulong
) & HiSax_reportcard
);
1273 printk(KERN_DEBUG
"HiSax: cs 0x%lX\n", (ulong
) cs
);
1274 printk(KERN_DEBUG
"HiSax: HW_Flags %lx bc0 flg %lx bc1 flg %lx\n",
1275 cs
->HW_Flags
, cs
->bcs
[0].Flag
, cs
->bcs
[1].Flag
);
1276 printk(KERN_DEBUG
"HiSax: bcs 0 mode %d ch%d\n",
1277 cs
->bcs
[0].mode
, cs
->bcs
[0].channel
);
1278 printk(KERN_DEBUG
"HiSax: bcs 1 mode %d ch%d\n",
1279 cs
->bcs
[1].mode
, cs
->bcs
[1].channel
);
1280 #ifdef ERROR_STATISTIC
1281 printk(KERN_DEBUG
"HiSax: dc errors(rx,crc,tx) %d,%d,%d\n",
1282 cs
->err_rx
, cs
->err_crc
, cs
->err_tx
);
1284 "HiSax: bc0 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1285 cs
->bcs
[0].err_inv
, cs
->bcs
[0].err_rdo
, cs
->bcs
[0].err_crc
,
1288 "HiSax: bc1 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1289 cs
->bcs
[1].err_inv
, cs
->bcs
[1].err_rdo
, cs
->bcs
[1].err_crc
,
1295 cs
->bcs
[0].err_inv
= 0;
1296 cs
->bcs
[0].err_rdo
= 0;
1297 cs
->bcs
[0].err_crc
= 0;
1298 cs
->bcs
[0].err_tx
= 0;
1299 cs
->bcs
[1].err_inv
= 0;
1300 cs
->bcs
[1].err_rdo
= 0;
1301 cs
->bcs
[1].err_crc
= 0;
1302 cs
->bcs
[1].err_tx
= 0;
1307 static int __init
HiSax_init(void)
1316 retval
= CallcNew();
1319 retval
= Isdnl3New();
1322 retval
= Isdnl2New();
1328 retval
= Isdnl1New();
1334 /* We 'll register drivers later, but init basic functions */
1335 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++)
1339 #ifdef CONFIG_HISAX_ELSA
1340 if (type
[0] == ISDN_CTYPE_ELSA_PCMCIA
) {
1341 /* we have exported and return in this case */
1345 #ifdef CONFIG_HISAX_SEDLBAUER
1346 if (type
[0] == ISDN_CTYPE_SEDLBAUER_PCMCIA
) {
1347 /* we have to export and return in this case */
1351 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
1352 if (type
[0] == ISDN_CTYPE_A1_PCMCIA
) {
1353 /* we have to export and return in this case */
1357 #ifdef CONFIG_HISAX_HFC_SX
1358 if (type
[0] == ISDN_CTYPE_HFC_SP_PCMCIA
) {
1359 /* we have to export and return in this case */
1366 if (id
) /* If id= string used */
1368 for (i
= j
= 0; j
< HISAX_MAX_CARDS
; i
++) {
1369 cards
[j
].typ
= type
[i
];
1371 cards
[j
].protocol
= protocol
[i
];
1374 cards
[j
].protocol
= DEFAULT_PROTO
;
1377 case ISDN_CTYPE_16_0
:
1378 cards
[j
].para
[0] = irq
[i
];
1379 cards
[j
].para
[1] = mem
[i
];
1380 cards
[j
].para
[2] = io
[i
];
1383 case ISDN_CTYPE_8_0
:
1384 cards
[j
].para
[0] = irq
[i
];
1385 cards
[j
].para
[1] = mem
[i
];
1389 case ISDN_CTYPE_PNP
:
1390 case ISDN_CTYPE_NICCY
:
1391 cards
[j
].para
[0] = irq
[i
];
1392 cards
[j
].para
[1] = io0
[i
];
1393 cards
[j
].para
[2] = io1
[i
];
1395 case ISDN_CTYPE_COMPAQ_ISA
:
1396 cards
[j
].para
[0] = irq
[i
];
1397 cards
[j
].para
[1] = io0
[i
];
1398 cards
[j
].para
[2] = io1
[i
];
1399 cards
[j
].para
[3] = io
[i
];
1402 case ISDN_CTYPE_ELSA
:
1403 case ISDN_CTYPE_HFC_PCI
:
1404 cards
[j
].para
[0] = io
[i
];
1406 case ISDN_CTYPE_16_3
:
1407 case ISDN_CTYPE_TELESPCMCIA
:
1409 case ISDN_CTYPE_A1_PCMCIA
:
1410 case ISDN_CTYPE_ELSA_PNP
:
1411 case ISDN_CTYPE_ELSA_PCMCIA
:
1412 case ISDN_CTYPE_IX1MICROR2
:
1413 case ISDN_CTYPE_DIEHLDIVA
:
1414 case ISDN_CTYPE_ASUSCOM
:
1415 case ISDN_CTYPE_TELEINT
:
1416 case ISDN_CTYPE_SEDLBAUER
:
1417 case ISDN_CTYPE_SEDLBAUER_PCMCIA
:
1418 case ISDN_CTYPE_SEDLBAUER_FAX
:
1419 case ISDN_CTYPE_SPORTSTER
:
1420 case ISDN_CTYPE_MIC
:
1421 case ISDN_CTYPE_TELES3C
:
1422 case ISDN_CTYPE_ACERP10
:
1423 case ISDN_CTYPE_S0BOX
:
1424 case ISDN_CTYPE_FRITZPCI
:
1425 case ISDN_CTYPE_HSTSAPHIR
:
1426 case ISDN_CTYPE_GAZEL
:
1427 case ISDN_CTYPE_HFC_SX
:
1428 case ISDN_CTYPE_HFC_SP_PCMCIA
:
1429 cards
[j
].para
[0] = irq
[i
];
1430 cards
[j
].para
[1] = io
[i
];
1432 case ISDN_CTYPE_ISURF
:
1433 cards
[j
].para
[0] = irq
[i
];
1434 cards
[j
].para
[1] = io
[i
];
1435 cards
[j
].para
[2] = mem
[i
];
1437 case ISDN_CTYPE_ELSA_PCI
:
1438 case ISDN_CTYPE_NETJET_S
:
1439 case ISDN_CTYPE_AMD7930
:
1440 case ISDN_CTYPE_TELESPCI
:
1441 case ISDN_CTYPE_W6692
:
1442 case ISDN_CTYPE_NETJET_U
:
1444 case ISDN_CTYPE_BKM_A4T
:
1446 case ISDN_CTYPE_SCT_QUADRO
:
1448 cards
[j
].para
[0] = irq
[i
];
1450 /* QUADRO is a 4 BRI card */
1451 cards
[j
++].para
[0] = 1;
1452 /* we need to check if further cards can be added */
1453 if (j
< HISAX_MAX_CARDS
) {
1454 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1455 cards
[j
].protocol
= protocol
[i
];
1456 cards
[j
++].para
[0] = 2;
1458 if (j
< HISAX_MAX_CARDS
) {
1459 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1460 cards
[j
].protocol
= protocol
[i
];
1461 cards
[j
++].para
[0] = 3;
1463 if (j
< HISAX_MAX_CARDS
) {
1464 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1465 cards
[j
].protocol
= protocol
[i
];
1466 cards
[j
].para
[0] = 4;
1475 "HiSax: Warning - no protocol specified\n");
1476 printk(KERN_WARNING
"HiSax: using protocol %s\n",
1477 DEFAULT_PROTO_NAME
);
1483 strcpy(HiSaxID
, "HiSax");
1484 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++)
1485 if (cards
[i
].typ
> 0)
1487 printk(KERN_DEBUG
"HiSax: Total %d card%s defined\n",
1488 nrcards
, (nrcards
> 1) ? "s" : "");
1490 /* Install only, if at least one card found */
1491 if (!HiSax_inithardware(NULL
))
1507 static void __exit
HiSax_exit(void)
1509 int cardnr
= nrcards
- 1;
1512 HiSax_closecard(cardnr
--);
1518 printk(KERN_INFO
"HiSax module removed\n");
1521 int hisax_init_pcmcia(void *pcm_iob
, int *busy_flag
, struct IsdnCard
*card
)
1526 cards
[nrcards
] = *card
;
1528 sprintf(ids
, "HiSax%d", nrcards
);
1530 sprintf(ids
, "HiSax");
1531 if (!checkcard(nrcards
, ids
, busy_flag
, THIS_MODULE
))
1540 EXPORT_SYMBOL(hisax_init_pcmcia
);
1541 EXPORT_SYMBOL(HiSax_closecard
);
1543 #include "hisax_if.h"
1545 EXPORT_SYMBOL(hisax_register
);
1546 EXPORT_SYMBOL(hisax_unregister
);
1548 static void hisax_d_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
);
1549 static void hisax_b_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
);
1550 static void hisax_d_l2l1(struct PStack
*st
, int pr
, void *arg
);
1551 static void hisax_b_l2l1(struct PStack
*st
, int pr
, void *arg
);
1552 static int hisax_cardmsg(struct IsdnCardState
*cs
, int mt
, void *arg
);
1553 static int hisax_bc_setstack(struct PStack
*st
, struct BCState
*bcs
);
1554 static void hisax_bc_close(struct BCState
*bcs
);
1555 static void hisax_bh(struct IsdnCardState
*cs
);
1556 static void EChannel_proc_rcv(struct hisax_d_if
*d_if
);
1558 int hisax_register(struct hisax_d_if
*hisax_d_if
, struct hisax_b_if
*b_if
[],
1559 char *name
, int protocol
)
1563 struct IsdnCardState
*cs
;
1565 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++) {
1570 if (i
>= HISAX_MAX_CARDS
)
1573 cards
[i
].typ
= ISDN_CTYPE_DYNAMIC
;
1574 cards
[i
].protocol
= protocol
;
1575 sprintf(id
, "%s%d", name
, i
);
1577 retval
= checkcard(i
, id
, NULL
, hisax_d_if
->owner
);
1578 if (retval
== 0) { // yuck
1584 hisax_d_if
->cs
= cs
;
1585 cs
->hw
.hisax_d_if
= hisax_d_if
;
1586 cs
->cardmsg
= hisax_cardmsg
;
1587 INIT_WORK(&cs
->tqueue
, (void *)(void *)hisax_bh
, cs
);
1588 cs
->channel
[0].d_st
->l2
.l2l1
= hisax_d_l2l1
;
1589 for (i
= 0; i
< 2; i
++) {
1590 cs
->bcs
[i
].BC_SetStack
= hisax_bc_setstack
;
1591 cs
->bcs
[i
].BC_Close
= hisax_bc_close
;
1593 b_if
[i
]->ifc
.l1l2
= hisax_b_l1l2
;
1595 hisax_d_if
->b_if
[i
] = b_if
[i
];
1597 hisax_d_if
->ifc
.l1l2
= hisax_d_l1l2
;
1598 skb_queue_head_init(&hisax_d_if
->erq
);
1599 clear_bit(0, &hisax_d_if
->ph_state
);
1604 void hisax_unregister(struct hisax_d_if
*hisax_d_if
)
1606 cards
[hisax_d_if
->cs
->cardnr
].typ
= 0;
1607 HiSax_closecard(hisax_d_if
->cs
->cardnr
);
1608 skb_queue_purge(&hisax_d_if
->erq
);
1613 static void hisax_sched_event(struct IsdnCardState
*cs
, int event
)
1615 test_and_set_bit(event
, &cs
->event
);
1616 schedule_work(&cs
->tqueue
);
1619 static void hisax_bh(struct IsdnCardState
*cs
)
1624 if (test_and_clear_bit(D_RCVBUFREADY
, &cs
->event
))
1625 DChannel_proc_rcv(cs
);
1626 if (test_and_clear_bit(E_RCVBUFREADY
, &cs
->event
))
1627 EChannel_proc_rcv(cs
->hw
.hisax_d_if
);
1628 if (test_and_clear_bit(D_L1STATECHANGE
, &cs
->event
)) {
1629 if (test_bit(0, &cs
->hw
.hisax_d_if
->ph_state
))
1630 pr
= PH_ACTIVATE
| INDICATION
;
1632 pr
= PH_DEACTIVATE
| INDICATION
;
1633 for (st
= cs
->stlist
; st
; st
= st
->next
)
1634 st
->l1
.l1l2(st
, pr
, NULL
);
1639 static void hisax_b_sched_event(struct BCState
*bcs
, int event
)
1641 test_and_set_bit(event
, &bcs
->event
);
1642 schedule_work(&bcs
->tqueue
);
1645 static inline void D_L2L1(struct hisax_d_if
*d_if
, int pr
, void *arg
)
1647 struct hisax_if
*ifc
= (struct hisax_if
*) d_if
;
1648 ifc
->l2l1(ifc
, pr
, arg
);
1651 static inline void B_L2L1(struct hisax_b_if
*b_if
, int pr
, void *arg
)
1653 struct hisax_if
*ifc
= (struct hisax_if
*) b_if
;
1654 ifc
->l2l1(ifc
, pr
, arg
);
1657 static void hisax_d_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
)
1659 struct hisax_d_if
*d_if
= (struct hisax_d_if
*) ifc
;
1660 struct IsdnCardState
*cs
= d_if
->cs
;
1662 struct sk_buff
*skb
;
1665 case PH_ACTIVATE
| INDICATION
:
1666 set_bit(0, &d_if
->ph_state
);
1667 hisax_sched_event(cs
, D_L1STATECHANGE
);
1669 case PH_DEACTIVATE
| INDICATION
:
1670 clear_bit(0, &d_if
->ph_state
);
1671 hisax_sched_event(cs
, D_L1STATECHANGE
);
1673 case PH_DATA
| INDICATION
:
1674 skb_queue_tail(&cs
->rq
, arg
);
1675 hisax_sched_event(cs
, D_RCVBUFREADY
);
1677 case PH_DATA
| CONFIRM
:
1678 skb
= skb_dequeue(&cs
->sq
);
1680 D_L2L1(d_if
, PH_DATA
| REQUEST
, skb
);
1683 clear_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
);
1684 for (st
= cs
->stlist
; st
; st
= st
->next
) {
1685 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
)) {
1686 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1691 case PH_DATA_E
| INDICATION
:
1692 skb_queue_tail(&d_if
->erq
, arg
);
1693 hisax_sched_event(cs
, E_RCVBUFREADY
);
1696 printk("pr %#x\n", pr
);
1701 static void hisax_b_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
)
1703 struct hisax_b_if
*b_if
= (struct hisax_b_if
*) ifc
;
1704 struct BCState
*bcs
= b_if
->bcs
;
1705 struct PStack
*st
= bcs
->st
;
1706 struct sk_buff
*skb
;
1708 // FIXME use isdnl1?
1710 case PH_ACTIVATE
| INDICATION
:
1711 st
->l1
.l1l2(st
, pr
, NULL
);
1713 case PH_DEACTIVATE
| INDICATION
:
1714 st
->l1
.l1l2(st
, pr
, NULL
);
1715 clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1716 skb_queue_purge(&bcs
->squeue
);
1717 bcs
->hw
.b_if
= NULL
;
1719 case PH_DATA
| INDICATION
:
1720 skb_queue_tail(&bcs
->rqueue
, arg
);
1721 hisax_b_sched_event(bcs
, B_RCVBUFREADY
);
1723 case PH_DATA
| CONFIRM
:
1724 bcs
->tx_cnt
-= (int) arg
;
1725 if (test_bit(FLG_LLI_L1WAKEUP
,&bcs
->st
->lli
.flag
)) {
1727 spin_lock_irqsave(&bcs
->aclock
, flags
);
1728 bcs
->ackcnt
+= (int) arg
;
1729 spin_unlock_irqrestore(&bcs
->aclock
, flags
);
1730 schedule_event(bcs
, B_ACKPENDING
);
1732 skb
= skb_dequeue(&bcs
->squeue
);
1734 B_L2L1(b_if
, PH_DATA
| REQUEST
, skb
);
1737 clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1738 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
)) {
1739 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1743 printk("hisax_b_l1l2 pr %#x\n", pr
);
1748 static void hisax_d_l2l1(struct PStack
*st
, int pr
, void *arg
)
1750 struct IsdnCardState
*cs
= st
->l1
.hardware
;
1751 struct hisax_d_if
*hisax_d_if
= cs
->hw
.hisax_d_if
;
1752 struct sk_buff
*skb
= arg
;
1755 case PH_DATA
| REQUEST
:
1756 case PH_PULL
| INDICATION
:
1757 if (cs
->debug
& DEB_DLOG_HEX
)
1758 LogFrame(cs
, skb
->data
, skb
->len
);
1759 if (cs
->debug
& DEB_DLOG_VERBOSE
)
1760 dlogframe(cs
, skb
, 0);
1761 Logl2Frame(cs
, skb
, "PH_DATA_REQ", 0);
1763 if (!test_and_set_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
))
1764 D_L2L1(hisax_d_if
, PH_DATA
| REQUEST
, skb
);
1766 skb_queue_tail(&cs
->sq
, skb
);
1768 case PH_PULL
| REQUEST
:
1769 if (!test_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
))
1770 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1772 set_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
);
1775 D_L2L1(hisax_d_if
, pr
, arg
);
1780 static int hisax_cardmsg(struct IsdnCardState
*cs
, int mt
, void *arg
)
1785 static void hisax_b_l2l1(struct PStack
*st
, int pr
, void *arg
)
1787 struct BCState
*bcs
= st
->l1
.bcs
;
1788 struct hisax_b_if
*b_if
= bcs
->hw
.b_if
;
1791 case PH_ACTIVATE
| REQUEST
:
1792 B_L2L1(b_if
, pr
, (void *) st
->l1
.mode
);
1794 case PH_DATA
| REQUEST
:
1795 case PH_PULL
| INDICATION
:
1797 if (!test_and_set_bit(BC_FLG_BUSY
, &bcs
->Flag
)) {
1798 B_L2L1(b_if
, PH_DATA
| REQUEST
, arg
);
1800 skb_queue_tail(&bcs
->squeue
, arg
);
1803 case PH_PULL
| REQUEST
:
1804 if (!test_bit(BC_FLG_BUSY
, &bcs
->Flag
))
1805 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1807 set_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
);
1809 case PH_DEACTIVATE
| REQUEST
:
1810 test_and_clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1811 skb_queue_purge(&bcs
->squeue
);
1813 B_L2L1(b_if
, pr
, arg
);
1818 static int hisax_bc_setstack(struct PStack
*st
, struct BCState
*bcs
)
1820 struct IsdnCardState
*cs
= st
->l1
.hardware
;
1821 struct hisax_d_if
*hisax_d_if
= cs
->hw
.hisax_d_if
;
1823 bcs
->channel
= st
->l1
.bc
;
1825 bcs
->hw
.b_if
= hisax_d_if
->b_if
[st
->l1
.bc
];
1826 hisax_d_if
->b_if
[st
->l1
.bc
]->bcs
= bcs
;
1829 st
->l2
.l2l1
= hisax_b_l2l1
;
1830 setstack_manager(st
);
1833 skb_queue_head_init(&bcs
->rqueue
);
1834 skb_queue_head_init(&bcs
->squeue
);
1838 static void hisax_bc_close(struct BCState
*bcs
)
1840 struct hisax_b_if
*b_if
= bcs
->hw
.b_if
;
1843 B_L2L1(b_if
, PH_DEACTIVATE
| REQUEST
, NULL
);
1846 static void EChannel_proc_rcv(struct hisax_d_if
*d_if
)
1848 struct IsdnCardState
*cs
= d_if
->cs
;
1850 struct sk_buff
*skb
;
1852 while ((skb
= skb_dequeue(&d_if
->erq
)) != NULL
) {
1853 if (cs
->debug
& DEB_DLOG_HEX
) {
1855 if ((skb
->len
) < MAX_DLOG_SPACE
/ 3 - 10) {
1861 ptr
+= QuickHex(ptr
, skb
->data
, skb
->len
);
1865 HiSax_putstatus(cs
, NULL
, cs
->dlog
);
1867 HiSax_putstatus(cs
, "LogEcho: ",
1868 "warning Frame too big (%d)",
1871 dev_kfree_skb_any(skb
);
1876 #include <linux/pci.h>
1878 static struct pci_device_id hisax_pci_tbl
[] __devinitdata
= {
1879 #ifdef CONFIG_HISAX_FRITZPCI
1880 {PCI_VENDOR_ID_AVM
, PCI_DEVICE_ID_AVM_A1
, PCI_ANY_ID
, PCI_ANY_ID
},
1882 #ifdef CONFIG_HISAX_DIEHLDIVA
1883 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA20
, PCI_ANY_ID
, PCI_ANY_ID
},
1884 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA20_U
, PCI_ANY_ID
, PCI_ANY_ID
},
1885 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA201
, PCI_ANY_ID
, PCI_ANY_ID
},
1886 //#########################################################################################
1887 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA202
, PCI_ANY_ID
, PCI_ANY_ID
},
1888 //#########################################################################################
1890 #ifdef CONFIG_HISAX_ELSA
1891 {PCI_VENDOR_ID_ELSA
, PCI_DEVICE_ID_ELSA_MICROLINK
, PCI_ANY_ID
, PCI_ANY_ID
},
1892 {PCI_VENDOR_ID_ELSA
, PCI_DEVICE_ID_ELSA_QS3000
, PCI_ANY_ID
, PCI_ANY_ID
},
1894 #ifdef CONFIG_HISAX_GAZEL
1895 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_R685
, PCI_ANY_ID
, PCI_ANY_ID
},
1896 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_R753
, PCI_ANY_ID
, PCI_ANY_ID
},
1897 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_DJINN_ITOO
, PCI_ANY_ID
, PCI_ANY_ID
},
1898 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_OLITEC
, PCI_ANY_ID
, PCI_ANY_ID
},
1900 #ifdef CONFIG_HISAX_QUADRO
1901 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_9050
, PCI_ANY_ID
, PCI_ANY_ID
},
1903 #ifdef CONFIG_HISAX_NICCY
1904 {PCI_VENDOR_ID_SATSAGEM
, PCI_DEVICE_ID_SATSAGEM_NICCY
, PCI_ANY_ID
,PCI_ANY_ID
},
1906 #ifdef CONFIG_HISAX_SEDLBAUER
1907 {PCI_VENDOR_ID_TIGERJET
, PCI_DEVICE_ID_TIGERJET_100
, PCI_ANY_ID
,PCI_ANY_ID
},
1909 #if defined(CONFIG_HISAX_NETJET) || defined(CONFIG_HISAX_NETJET_U)
1910 {PCI_VENDOR_ID_TIGERJET
, PCI_DEVICE_ID_TIGERJET_300
, PCI_ANY_ID
,PCI_ANY_ID
},
1912 #if defined(CONFIG_HISAX_TELESPCI) || defined(CONFIG_HISAX_SCT_QUADRO)
1913 {PCI_VENDOR_ID_ZORAN
, PCI_DEVICE_ID_ZORAN_36120
, PCI_ANY_ID
,PCI_ANY_ID
},
1915 #ifdef CONFIG_HISAX_W6692
1916 {PCI_VENDOR_ID_DYNALINK
, PCI_DEVICE_ID_DYNALINK_IS64PH
, PCI_ANY_ID
,PCI_ANY_ID
},
1917 {PCI_VENDOR_ID_WINBOND2
, PCI_DEVICE_ID_WINBOND2_6692
, PCI_ANY_ID
,PCI_ANY_ID
},
1919 #ifdef CONFIG_HISAX_HFC_PCI
1920 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_2BD0
, PCI_ANY_ID
, PCI_ANY_ID
},
1921 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B000
, PCI_ANY_ID
, PCI_ANY_ID
},
1922 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B006
, PCI_ANY_ID
, PCI_ANY_ID
},
1923 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B007
, PCI_ANY_ID
, PCI_ANY_ID
},
1924 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B008
, PCI_ANY_ID
, PCI_ANY_ID
},
1925 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B009
, PCI_ANY_ID
, PCI_ANY_ID
},
1926 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00A
, PCI_ANY_ID
, PCI_ANY_ID
},
1927 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00B
, PCI_ANY_ID
, PCI_ANY_ID
},
1928 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00C
, PCI_ANY_ID
, PCI_ANY_ID
},
1929 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B100
, PCI_ANY_ID
, PCI_ANY_ID
},
1930 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B700
, PCI_ANY_ID
, PCI_ANY_ID
},
1931 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B701
, PCI_ANY_ID
, PCI_ANY_ID
},
1932 {PCI_VENDOR_ID_ABOCOM
, PCI_DEVICE_ID_ABOCOM_2BD1
, PCI_ANY_ID
, PCI_ANY_ID
},
1933 {PCI_VENDOR_ID_ASUSTEK
, PCI_DEVICE_ID_ASUSTEK_0675
, PCI_ANY_ID
, PCI_ANY_ID
},
1934 {PCI_VENDOR_ID_BERKOM
, PCI_DEVICE_ID_BERKOM_T_CONCEPT
, PCI_ANY_ID
, PCI_ANY_ID
},
1935 {PCI_VENDOR_ID_BERKOM
, PCI_DEVICE_ID_BERKOM_A1T
, PCI_ANY_ID
, PCI_ANY_ID
},
1936 {PCI_VENDOR_ID_ANIGMA
, PCI_DEVICE_ID_ANIGMA_MC145575
, PCI_ANY_ID
, PCI_ANY_ID
},
1937 {PCI_VENDOR_ID_ZOLTRIX
, PCI_DEVICE_ID_ZOLTRIX_2BD0
, PCI_ANY_ID
, PCI_ANY_ID
},
1938 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_IOM2_E
, PCI_ANY_ID
, PCI_ANY_ID
},
1939 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_E
, PCI_ANY_ID
, PCI_ANY_ID
},
1940 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_IOM2_A
, PCI_ANY_ID
, PCI_ANY_ID
},
1941 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_A
, PCI_ANY_ID
, PCI_ANY_ID
},
1943 { } /* Terminating entry */
1946 MODULE_DEVICE_TABLE(pci
, hisax_pci_tbl
);
1947 #endif /* CONFIG_PCI */
1949 module_init(HiSax_init
);
1950 module_exit(HiSax_exit
);
1952 EXPORT_SYMBOL(FsmNew
);
1953 EXPORT_SYMBOL(FsmFree
);
1954 EXPORT_SYMBOL(FsmEvent
);
1955 EXPORT_SYMBOL(FsmChangeState
);
1956 EXPORT_SYMBOL(FsmInitTimer
);
1957 EXPORT_SYMBOL(FsmDelTimer
);
1958 EXPORT_SYMBOL(FsmRestartTimer
);