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/config.h>
21 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/kernel_stat.h>
25 #include <linux/workqueue.h>
26 #include <linux/interrupt.h>
27 #define HISAX_STATUS_BUFSIZE 4096
30 * This structure array contains one entry per card. An entry looks
33 * { type, protocol, p0, p1, p2, NULL }
36 * 1 Teles 16.0 p0=irq p1=membase p2=iobase
37 * 2 Teles 8.0 p0=irq p1=membase
38 * 3 Teles 16.3 p0=irq p1=iobase
39 * 4 Creatix PNP p0=irq p1=IO0 (ISAC) p2=IO1 (HSCX)
40 * 5 AVM A1 (Fritz) p0=irq p1=iobase
41 * 6 ELSA PC [p0=iobase] or nothing (autodetect)
42 * 7 ELSA Quickstep p0=irq p1=iobase
43 * 8 Teles PCMCIA p0=irq p1=iobase
44 * 9 ITK ix1-micro p0=irq p1=iobase
45 * 10 ELSA PCMCIA p0=irq p1=iobase
46 * 11 Eicon.Diehl Diva p0=irq p1=iobase
47 * 12 Asuscom ISDNLink p0=irq p1=iobase
48 * 13 Teleint p0=irq p1=iobase
49 * 14 Teles 16.3c p0=irq p1=iobase
50 * 15 Sedlbauer speed p0=irq p1=iobase
51 * 15 Sedlbauer PC/104 p0=irq p1=iobase
52 * 15 Sedlbauer speed pci no parameter
53 * 16 USR Sportster internal p0=irq p1=iobase
54 * 17 MIC card p0=irq p1=iobase
55 * 18 ELSA Quickstep 1000PCI no parameter
56 * 19 Compaq ISDN S0 ISA card p0=irq p1=IO0 (HSCX) p2=IO1 (ISAC) p3=IO2
57 * 20 Travers Technologies NETjet-S PCI card
58 * 21 TELES PCI no parameter
59 * 22 Sedlbauer Speed Star p0=irq p1=iobase
61 * 24 Dr Neuhaus Niccy PnP/PCI card p0=irq p1=IO0 p2=IO1 (PnP only)
62 * 25 Teles S0Box p0=irq p1=iobase (from isapnp setup)
63 * 26 AVM A1 PCMCIA (Fritz) p0=irq p1=iobase
64 * 27 AVM PnP/PCI p0=irq p1=iobase (PCI no parameter)
65 * 28 Sedlbauer Speed Fax+ p0=irq p1=iobase (from isapnp setup)
66 * 29 Siemens I-Surf p0=irq p1=iobase p2=memory (from isapnp setup)
67 * 30 ACER P10 p0=irq p1=iobase (from isapnp setup)
68 * 31 HST Saphir p0=irq p1=iobase
70 * 33 Scitel Quadro p0=subcontroller (4*S0, subctrl 1...4)
72 * 35 HFC 2BDS0 PCI none
73 * 36 Winbond 6692 PCI none
74 * 37 HFC 2BDS0 S+/SP p0=irq p1=iobase
75 * 38 Travers Technologies NETspider-U PCI card
76 * 39 HFC 2BDS0-SP PCMCIA p0=irq p1=iobase
77 * 40 hotplug interface
78 * 41 Formula-n enter:now ISDN PCI a/b none
80 * protocol can be either ISDN_PTYPE_EURO or ISDN_PTYPE_1TR6 or ISDN_PTYPE_NI1
85 const char *CardType
[] = {
86 "No Card", "Teles 16.0", "Teles 8.0", "Teles 16.3",
87 "Creatix/Teles PnP", "AVM A1", "Elsa ML", "Elsa Quickstep",
88 "Teles PCMCIA", "ITK ix1-micro Rev.2", "Elsa PCMCIA",
89 "Eicon.Diehl Diva", "ISDNLink", "TeleInt", "Teles 16.3c",
90 "Sedlbauer Speed Card", "USR Sportster", "ith mic Linux",
91 "Elsa PCI", "Compaq ISA", "NETjet-S", "Teles PCI",
92 "Sedlbauer Speed Star (PCMCIA)", "AMD 7930", "NICCY", "S0Box",
93 "AVM A1 (PCMCIA)", "AVM Fritz PnP/PCI", "Sedlbauer Speed Fax +",
94 "Siemens I-Surf", "Acer P10", "HST Saphir", "Telekom A4T",
95 "Scitel Quadro", "Gazel", "HFC 2BDS0 PCI", "Winbond 6692",
96 "HFC 2BDS0 SX", "NETspider-U", "HFC-2BDS0-SP PCMCIA",
97 "Hotplug", "Formula-n enter:now PCI a/b",
100 #ifdef CONFIG_HISAX_ELSA
101 #define DEFAULT_CARD ISDN_CTYPE_ELSA
102 #define DEFAULT_CFG {0,0,0,0}
105 #ifdef CONFIG_HISAX_AVM_A1
108 #define DEFAULT_CARD ISDN_CTYPE_A1
109 #define DEFAULT_CFG {10,0x340,0,0}
112 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
115 #define DEFAULT_CARD ISDN_CTYPE_A1_PCMCIA
116 #define DEFAULT_CFG {11,0x170,0,0}
119 #ifdef CONFIG_HISAX_FRITZPCI
122 #define DEFAULT_CARD ISDN_CTYPE_FRITZPCI
123 #define DEFAULT_CFG {0,0,0,0}
126 #ifdef CONFIG_HISAX_16_3
129 #define DEFAULT_CARD ISDN_CTYPE_16_3
130 #define DEFAULT_CFG {15,0x180,0,0}
133 #ifdef CONFIG_HISAX_S0BOX
136 #define DEFAULT_CARD ISDN_CTYPE_S0BOX
137 #define DEFAULT_CFG {7,0x378,0,0}
140 #ifdef CONFIG_HISAX_16_0
143 #define DEFAULT_CARD ISDN_CTYPE_16_0
144 #define DEFAULT_CFG {15,0xd0000,0xd80,0}
147 #ifdef CONFIG_HISAX_TELESPCI
150 #define DEFAULT_CARD ISDN_CTYPE_TELESPCI
151 #define DEFAULT_CFG {0,0,0,0}
154 #ifdef CONFIG_HISAX_IX1MICROR2
157 #define DEFAULT_CARD ISDN_CTYPE_IX1MICROR2
158 #define DEFAULT_CFG {5,0x390,0,0}
161 #ifdef CONFIG_HISAX_DIEHLDIVA
164 #define DEFAULT_CARD ISDN_CTYPE_DIEHLDIVA
165 #define DEFAULT_CFG {0,0x0,0,0}
168 #ifdef CONFIG_HISAX_ASUSCOM
171 #define DEFAULT_CARD ISDN_CTYPE_ASUSCOM
172 #define DEFAULT_CFG {5,0x200,0,0}
175 #ifdef CONFIG_HISAX_TELEINT
178 #define DEFAULT_CARD ISDN_CTYPE_TELEINT
179 #define DEFAULT_CFG {5,0x300,0,0}
182 #ifdef CONFIG_HISAX_SEDLBAUER
185 #define DEFAULT_CARD ISDN_CTYPE_SEDLBAUER
186 #define DEFAULT_CFG {11,0x270,0,0}
189 #ifdef CONFIG_HISAX_SPORTSTER
192 #define DEFAULT_CARD ISDN_CTYPE_SPORTSTER
193 #define DEFAULT_CFG {7,0x268,0,0}
196 #ifdef CONFIG_HISAX_MIC
199 #define DEFAULT_CARD ISDN_CTYPE_MIC
200 #define DEFAULT_CFG {12,0x3e0,0,0}
203 #ifdef CONFIG_HISAX_NETJET
206 #define DEFAULT_CARD ISDN_CTYPE_NETJET_S
207 #define DEFAULT_CFG {0,0,0,0}
210 #ifdef CONFIG_HISAX_HFCS
213 #define DEFAULT_CARD ISDN_CTYPE_TELES3C
214 #define DEFAULT_CFG {5,0x500,0,0}
217 #ifdef CONFIG_HISAX_HFC_PCI
220 #define DEFAULT_CARD ISDN_CTYPE_HFC_PCI
221 #define DEFAULT_CFG {0,0,0,0}
224 #ifdef CONFIG_HISAX_HFC_SX
227 #define DEFAULT_CARD ISDN_CTYPE_HFC_SX
228 #define DEFAULT_CFG {5,0x2E0,0,0}
232 #ifdef CONFIG_HISAX_AMD7930
235 #define DEFAULT_CARD ISDN_CTYPE_AMD7930
236 #define DEFAULT_CFG {12,0x3e0,0,0}
239 #ifdef CONFIG_HISAX_NICCY
242 #define DEFAULT_CARD ISDN_CTYPE_NICCY
243 #define DEFAULT_CFG {0,0x0,0,0}
246 #ifdef CONFIG_HISAX_ISURF
249 #define DEFAULT_CARD ISDN_CTYPE_ISURF
250 #define DEFAULT_CFG {5,0x100,0xc8000,0}
253 #ifdef CONFIG_HISAX_HSTSAPHIR
256 #define DEFAULT_CARD ISDN_CTYPE_HSTSAPHIR
257 #define DEFAULT_CFG {5,0x250,0,0}
260 #ifdef CONFIG_HISAX_BKM_A4T
263 #define DEFAULT_CARD ISDN_CTYPE_BKM_A4T
264 #define DEFAULT_CFG {0,0x0,0,0}
267 #ifdef CONFIG_HISAX_SCT_QUADRO
270 #define DEFAULT_CARD ISDN_CTYPE_SCT_QUADRO
271 #define DEFAULT_CFG {1,0x0,0,0}
274 #ifdef CONFIG_HISAX_GAZEL
277 #define DEFAULT_CARD ISDN_CTYPE_GAZEL
278 #define DEFAULT_CFG {15,0x180,0,0}
281 #ifdef CONFIG_HISAX_W6692
284 #define DEFAULT_CARD ISDN_CTYPE_W6692
285 #define DEFAULT_CFG {0,0,0,0}
288 #ifdef CONFIG_HISAX_NETJET_U
291 #define DEFAULT_CARD ISDN_CTYPE_NETJET_U
292 #define DEFAULT_CFG {0,0,0,0}
295 #ifdef CONFIG_HISAX_1TR6
296 #define DEFAULT_PROTO ISDN_PTYPE_1TR6
297 #define DEFAULT_PROTO_NAME "1TR6"
299 #ifdef CONFIG_HISAX_NI1
301 #define DEFAULT_PROTO ISDN_PTYPE_NI1
302 #undef DEFAULT_PROTO_NAME
303 #define DEFAULT_PROTO_NAME "NI1"
305 #ifdef CONFIG_HISAX_EURO
307 #define DEFAULT_PROTO ISDN_PTYPE_EURO
308 #undef DEFAULT_PROTO_NAME
309 #define DEFAULT_PROTO_NAME "EURO"
311 #ifndef DEFAULT_PROTO
312 #define DEFAULT_PROTO ISDN_PTYPE_UNKNOWN
313 #define DEFAULT_PROTO_NAME "UNKNOWN"
316 #define DEFAULT_CARD 0
317 #define DEFAULT_CFG {0,0,0,0}
320 #define FIRST_CARD { \
327 struct IsdnCard cards
[HISAX_MAX_CARDS
] = {
331 #define HISAX_IDSIZE (HISAX_MAX_CARDS*8)
332 static char HiSaxID
[HISAX_IDSIZE
] = { 0, };
334 static char *HiSax_id
= HiSaxID
;
336 /* Variables for insmod */
337 static int type
[HISAX_MAX_CARDS
] = { 0, };
338 static int protocol
[HISAX_MAX_CARDS
] = { 0, };
339 static int io
[HISAX_MAX_CARDS
] = { 0, };
341 #ifdef CONFIG_HISAX_16_3
344 #ifdef CONFIG_HISAX_NICCY
349 static int io0
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
350 static int io1
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
352 static int irq
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
353 static int mem
[HISAX_MAX_CARDS
] __devinitdata
= { 0, };
354 static char *id
= HiSaxID
;
356 MODULE_DESCRIPTION("ISDN4Linux: Driver for passive ISDN cards");
357 MODULE_AUTHOR("Karsten Keil");
358 MODULE_LICENSE("GPL");
359 module_param_array(type
, int, NULL
, 0);
360 module_param_array(protocol
, int, NULL
, 0);
361 module_param_array(io
, int, NULL
, 0);
362 module_param_array(irq
, int, NULL
, 0);
363 module_param_array(mem
, int, NULL
, 0);
364 module_param(id
, charp
, 0);
366 module_param_array(io0
, int, NULL
, 0);
367 module_param_array(io1
, int, NULL
, 0);
373 extern char *l1_revision
;
374 extern char *l2_revision
;
375 extern char *l3_revision
;
376 extern char *lli_revision
;
377 extern char *tei_revision
;
379 char *HiSax_getrev(const char *revision
)
384 if ((p
= strchr(revision
, ':'))) {
386 p
= strchr(rev
, '$');
393 static void __init
HiSaxVersion(void)
397 printk(KERN_INFO
"HiSax: Linux Driver for passive ISDN cards\n");
399 printk(KERN_INFO
"HiSax: Version 3.5 (module)\n");
401 printk(KERN_INFO
"HiSax: Version 3.5 (kernel)\n");
403 strcpy(tmp
, l1_revision
);
404 printk(KERN_INFO
"HiSax: Layer1 Revision %s\n", HiSax_getrev(tmp
));
405 strcpy(tmp
, l2_revision
);
406 printk(KERN_INFO
"HiSax: Layer2 Revision %s\n", HiSax_getrev(tmp
));
407 strcpy(tmp
, tei_revision
);
408 printk(KERN_INFO
"HiSax: TeiMgr Revision %s\n", HiSax_getrev(tmp
));
409 strcpy(tmp
, l3_revision
);
410 printk(KERN_INFO
"HiSax: Layer3 Revision %s\n", HiSax_getrev(tmp
));
411 strcpy(tmp
, lli_revision
);
412 printk(KERN_INFO
"HiSax: LinkLayer Revision %s\n",
417 #define MAX_ARG (HISAX_MAX_CARDS*5)
418 static int __init
HiSax_setup(char *line
)
421 int ints
[MAX_ARG
+ 1];
424 str
= get_options(line
, MAX_ARG
, ints
);
426 printk(KERN_DEBUG
"HiSax_setup: argc(%d) str(%s)\n", argc
, str
);
429 while (argc
&& (i
< HISAX_MAX_CARDS
)) {
430 cards
[i
].protocol
= DEFAULT_PROTO
;
432 cards
[i
].typ
= ints
[j
];
437 cards
[i
].protocol
= ints
[j
];
442 cards
[i
].para
[0] = ints
[j
];
447 cards
[i
].para
[1] = ints
[j
];
452 cards
[i
].para
[2] = ints
[j
];
459 if (strlen(str
) < HISAX_IDSIZE
)
460 strcpy(HiSaxID
, str
);
462 printk(KERN_WARNING
"HiSax: ID too long!");
464 strcpy(HiSaxID
, "HiSax");
470 __setup("hisax=", HiSax_setup
);
474 extern int setup_teles0(struct IsdnCard
*card
);
478 extern int setup_teles3(struct IsdnCard
*card
);
482 extern int setup_s0box(struct IsdnCard
*card
);
486 extern int setup_telespci(struct IsdnCard
*card
);
490 extern int setup_avm_a1(struct IsdnCard
*card
);
493 #if CARD_AVM_A1_PCMCIA
494 extern int setup_avm_a1_pcmcia(struct IsdnCard
*card
);
498 extern int setup_avm_pcipnp(struct IsdnCard
*card
);
502 extern int setup_elsa(struct IsdnCard
*card
);
506 extern int setup_ix1micro(struct IsdnCard
*card
);
510 extern int setup_diva(struct IsdnCard
*card
);
514 extern int setup_asuscom(struct IsdnCard
*card
);
518 extern int setup_TeleInt(struct IsdnCard
*card
);
522 extern int setup_sedlbauer(struct IsdnCard
*card
);
526 extern int setup_sportster(struct IsdnCard
*card
);
530 extern int setup_mic(struct IsdnCard
*card
);
534 extern int setup_netjet_s(struct IsdnCard
*card
);
538 extern int setup_hfcs(struct IsdnCard
*card
);
542 extern int setup_hfcpci(struct IsdnCard
*card
);
546 extern int setup_hfcsx(struct IsdnCard
*card
);
550 extern int setup_amd7930(struct IsdnCard
*card
);
554 extern int setup_niccy(struct IsdnCard
*card
);
558 extern int setup_isurf(struct IsdnCard
*card
);
562 extern int setup_saphir(struct IsdnCard
*card
);
566 extern int setup_testemu(struct IsdnCard
*card
);
570 extern int setup_bkm_a4t(struct IsdnCard
*card
);
574 extern int setup_sct_quadro(struct IsdnCard
*card
);
578 extern int setup_gazel(struct IsdnCard
*card
);
582 extern int setup_w6692(struct IsdnCard
*card
);
586 extern int setup_netjet_u(struct IsdnCard
*card
);
589 #if CARD_FN_ENTERNOW_PCI
590 extern int setup_enternow_pci(struct IsdnCard
*card
);
594 * Find card with given driverId
596 static inline struct IsdnCardState
*hisax_findcard(int driverid
)
600 for (i
= 0; i
< nrcards
; i
++)
602 if (cards
[i
].cs
->myid
== driverid
)
608 * Find card with given card number
611 struct IsdnCardState
*hisax_get_card(int cardnr
)
613 if ((cardnr
<= nrcards
) && (cardnr
> 0))
614 if (cards
[cardnr
- 1].cs
)
615 return cards
[cardnr
- 1].cs
;
620 static int HiSax_readstatus(u_char __user
*buf
, int len
, int id
, int channel
)
623 u_char __user
*p
= buf
;
624 struct IsdnCardState
*cs
= hisax_findcard(id
);
627 if (len
> HISAX_STATUS_BUFSIZE
) {
629 "HiSax: status overflow readstat %d/%d\n",
630 len
, HISAX_STATUS_BUFSIZE
);
632 count
= cs
->status_end
- cs
->status_read
+ 1;
635 copy_to_user(p
, cs
->status_read
, count
);
636 cs
->status_read
+= count
;
637 if (cs
->status_read
> cs
->status_end
)
638 cs
->status_read
= cs
->status_buf
;
642 if (count
> HISAX_STATUS_BUFSIZE
)
643 cnt
= HISAX_STATUS_BUFSIZE
;
646 copy_to_user(p
, cs
->status_read
, cnt
);
648 cs
->status_read
+= cnt
% HISAX_STATUS_BUFSIZE
;
654 "HiSax: if_readstatus called with invalid driverId!\n");
659 int jiftime(char *s
, long mark
)
664 *s
-- = mark
% 10 + '0';
666 *s
-- = mark
% 10 + '0';
669 *s
-- = mark
% 10 + '0';
671 *s
-- = mark
% 6 + '0';
674 *s
-- = mark
% 10 + '0';
676 *s
-- = mark
% 10 + '0';
680 static u_char tmpbuf
[HISAX_STATUS_BUFSIZE
];
682 void VHiSax_putstatus(struct IsdnCardState
*cs
, char *head
, char *fmt
,
685 /* if head == NULL the fmt contains the full info */
694 printk(KERN_WARNING
"HiSax: No CardStatus for message");
697 spin_lock_irqsave(&cs
->statlock
, flags
);
700 p
+= jiftime(p
, jiffies
);
701 p
+= sprintf(p
, " %s", head
);
702 p
+= vsprintf(p
, fmt
, args
);
711 if (len
> HISAX_STATUS_BUFSIZE
) {
712 spin_unlock_irqrestore(&cs
->statlock
, flags
);
713 printk(KERN_WARNING
"HiSax: status overflow %d/%d\n",
714 len
, HISAX_STATUS_BUFSIZE
);
718 i
= cs
->status_end
- cs
->status_write
+ 1;
722 memcpy(cs
->status_write
, p
, i
);
723 cs
->status_write
+= i
;
724 if (cs
->status_write
> cs
->status_end
)
725 cs
->status_write
= cs
->status_buf
;
728 memcpy(cs
->status_write
, p
, len
);
729 cs
->status_write
+= len
;
731 #ifdef KERNELSTACK_DEBUG
732 i
= (ulong
) & len
- current
->kernel_stack_page
;
733 sprintf(tmpbuf
, "kstack %s %lx use %ld\n", current
->comm
,
734 current
->kernel_stack_page
, i
);
735 len
= strlen(tmpbuf
);
736 for (p
= tmpbuf
, i
= len
; i
> 0; i
--, p
++) {
737 *cs
->status_write
++ = *p
;
738 if (cs
->status_write
> cs
->status_end
)
739 cs
->status_write
= cs
->status_buf
;
743 spin_unlock_irqrestore(&cs
->statlock
, flags
);
745 ic
.command
= ISDN_STAT_STAVAIL
;
746 ic
.driver
= cs
->myid
;
748 cs
->iif
.statcallb(&ic
);
752 void HiSax_putstatus(struct IsdnCardState
*cs
, char *head
, char *fmt
, ...)
757 VHiSax_putstatus(cs
, head
, fmt
, args
);
761 int ll_run(struct IsdnCardState
*cs
, int addfeatures
)
765 ic
.driver
= cs
->myid
;
766 ic
.command
= ISDN_STAT_RUN
;
767 cs
->iif
.features
|= addfeatures
;
768 cs
->iif
.statcallb(&ic
);
772 static void ll_stop(struct IsdnCardState
*cs
)
776 ic
.command
= ISDN_STAT_STOP
;
777 ic
.driver
= cs
->myid
;
778 cs
->iif
.statcallb(&ic
);
779 // CallcFreeChan(cs);
782 static void ll_unload(struct IsdnCardState
*cs
)
786 ic
.command
= ISDN_STAT_UNLOAD
;
787 ic
.driver
= cs
->myid
;
788 cs
->iif
.statcallb(&ic
);
789 kfree(cs
->status_buf
);
790 cs
->status_read
= NULL
;
791 cs
->status_write
= NULL
;
792 cs
->status_end
= NULL
;
797 static void closecard(int cardnr
)
799 struct IsdnCardState
*csta
= cards
[cardnr
].cs
;
801 if (csta
->bcs
->BC_Close
!= NULL
) {
802 csta
->bcs
->BC_Close(csta
->bcs
+ 1);
803 csta
->bcs
->BC_Close(csta
->bcs
);
806 skb_queue_purge(&csta
->rq
);
807 skb_queue_purge(&csta
->sq
);
811 dev_kfree_skb(csta
->tx_skb
);
814 if (csta
->DC_Close
!= NULL
) {
815 csta
->DC_Close(csta
);
818 csta
->cardmsg(csta
, CARD_RELEASE
, NULL
);
819 if (csta
->dbusytimer
.function
!= NULL
) // FIXME?
820 del_timer(&csta
->dbusytimer
);
824 static int init_card(struct IsdnCardState
*cs
)
826 int irq_cnt
, cnt
= 3, ret
;
829 ret
= cs
->cardmsg(cs
, CARD_INIT
, NULL
);
832 irq_cnt
= kstat_irqs(cs
->irq
);
833 printk(KERN_INFO
"%s: IRQ %d count %d\n", CardType
[cs
->typ
],
835 if (request_irq(cs
->irq
, cs
->irq_func
, cs
->irq_flags
, "HiSax", cs
)) {
836 printk(KERN_WARNING
"HiSax: couldn't get interrupt %d\n",
841 cs
->cardmsg(cs
, CARD_INIT
, NULL
);
844 printk(KERN_INFO
"%s: IRQ %d count %d\n",
845 CardType
[cs
->typ
], cs
->irq
, kstat_irqs(cs
->irq
));
846 if (kstat_irqs(cs
->irq
) == irq_cnt
) {
848 "%s: IRQ(%d) getting no interrupts during init %d\n",
849 CardType
[cs
->typ
], cs
->irq
, 4 - cnt
);
851 free_irq(cs
->irq
, cs
);
854 cs
->cardmsg(cs
, CARD_RESET
, NULL
);
858 cs
->cardmsg(cs
, CARD_TEST
, NULL
);
865 static int checkcard(int cardnr
, char *id
, int *busy_flag
, struct module
*lockowner
)
868 struct IsdnCard
*card
= cards
+ cardnr
;
869 struct IsdnCardState
*cs
;
871 cs
= kmalloc(sizeof(struct IsdnCardState
), GFP_ATOMIC
);
874 "HiSax: No memory for IsdnCardState(card %d)\n",
878 memset(cs
, 0, sizeof(struct IsdnCardState
));
880 spin_lock_init(&cs
->statlock
);
881 spin_lock_init(&cs
->lock
);
882 cs
->chanlimit
= 2; /* maximum B-channel number */
883 cs
->logecho
= 0; /* No echo logging */
885 cs
->debug
= L1_DEB_WARN
;
887 cs
->busy_flag
= busy_flag
;
888 cs
->irq_flags
= I4L_IRQ_FLAG
;
890 if (card
->protocol
== ISDN_PTYPE_NI1
)
891 test_and_set_bit(FLG_TWO_DCHAN
, &cs
->HW_Flags
);
893 test_and_set_bit(FLG_TWO_DCHAN
, &cs
->HW_Flags
);
895 cs
->protocol
= card
->protocol
;
897 if (card
->typ
<= 0 || card
->typ
> ISDN_CTYPE_COUNT
) {
899 "HiSax: Card Type %d out of range\n", card
->typ
);
902 if (!(cs
->dlog
= kmalloc(MAX_DLOG_SPACE
, GFP_ATOMIC
))) {
904 "HiSax: No memory for dlog(card %d)\n", cardnr
+ 1);
907 if (!(cs
->status_buf
= kmalloc(HISAX_STATUS_BUFSIZE
, GFP_ATOMIC
))) {
909 "HiSax: No memory for status_buf(card %d)\n",
914 cs
->status_read
= cs
->status_buf
;
915 cs
->status_write
= cs
->status_buf
;
916 cs
->status_end
= cs
->status_buf
+ HISAX_STATUS_BUFSIZE
- 1;
919 cs
->iif
.owner
= lockowner
;
921 strcpy(cs
->iif
.id
, id
);
922 cs
->iif
.channels
= 2;
923 cs
->iif
.maxbufsize
= MAX_DATA_SIZE
;
924 cs
->iif
.hl_hdrlen
= MAX_HEADER_LEN
;
926 ISDN_FEATURE_L2_X75I
|
927 ISDN_FEATURE_L2_HDLC
|
928 ISDN_FEATURE_L2_HDLC_56K
|
929 ISDN_FEATURE_L2_TRANS
|
930 ISDN_FEATURE_L3_TRANS
|
931 #ifdef CONFIG_HISAX_1TR6
932 ISDN_FEATURE_P_1TR6
|
934 #ifdef CONFIG_HISAX_EURO
935 ISDN_FEATURE_P_EURO
|
937 #ifdef CONFIG_HISAX_NI1
942 cs
->iif
.command
= HiSax_command
;
943 cs
->iif
.writecmd
= NULL
;
944 cs
->iif
.writebuf_skb
= HiSax_writebuf_skb
;
945 cs
->iif
.readstat
= HiSax_readstatus
;
946 register_isdn(&cs
->iif
);
947 cs
->myid
= cs
->iif
.channels
;
949 "HiSax: Card %d Protocol %s Id=%s (%d)\n", cardnr
+ 1,
950 (card
->protocol
== ISDN_PTYPE_1TR6
) ? "1TR6" :
951 (card
->protocol
== ISDN_PTYPE_EURO
) ? "EDSS1" :
952 (card
->protocol
== ISDN_PTYPE_LEASED
) ? "LEASED" :
953 (card
->protocol
== ISDN_PTYPE_NI1
) ? "NI1" :
954 "NONE", cs
->iif
.id
, cs
->myid
);
957 case ISDN_CTYPE_16_0
:
959 ret
= setup_teles0(card
);
963 case ISDN_CTYPE_16_3
:
965 case ISDN_CTYPE_TELESPCMCIA
:
966 case ISDN_CTYPE_COMPAQ_ISA
:
967 ret
= setup_teles3(card
);
971 case ISDN_CTYPE_S0BOX
:
972 ret
= setup_s0box(card
);
976 case ISDN_CTYPE_TELESPCI
:
977 ret
= setup_telespci(card
);
982 ret
= setup_avm_a1(card
);
985 #if CARD_AVM_A1_PCMCIA
986 case ISDN_CTYPE_A1_PCMCIA
:
987 ret
= setup_avm_a1_pcmcia(card
);
991 case ISDN_CTYPE_FRITZPCI
:
992 ret
= setup_avm_pcipnp(card
);
996 case ISDN_CTYPE_ELSA
:
997 case ISDN_CTYPE_ELSA_PNP
:
998 case ISDN_CTYPE_ELSA_PCMCIA
:
999 case ISDN_CTYPE_ELSA_PCI
:
1000 ret
= setup_elsa(card
);
1004 case ISDN_CTYPE_IX1MICROR2
:
1005 ret
= setup_ix1micro(card
);
1009 case ISDN_CTYPE_DIEHLDIVA
:
1010 ret
= setup_diva(card
);
1014 case ISDN_CTYPE_ASUSCOM
:
1015 ret
= setup_asuscom(card
);
1019 case ISDN_CTYPE_TELEINT
:
1020 ret
= setup_TeleInt(card
);
1024 case ISDN_CTYPE_SEDLBAUER
:
1025 case ISDN_CTYPE_SEDLBAUER_PCMCIA
:
1026 case ISDN_CTYPE_SEDLBAUER_FAX
:
1027 ret
= setup_sedlbauer(card
);
1031 case ISDN_CTYPE_SPORTSTER
:
1032 ret
= setup_sportster(card
);
1036 case ISDN_CTYPE_MIC
:
1037 ret
= setup_mic(card
);
1041 case ISDN_CTYPE_NETJET_S
:
1042 ret
= setup_netjet_s(card
);
1046 case ISDN_CTYPE_TELES3C
:
1047 case ISDN_CTYPE_ACERP10
:
1048 ret
= setup_hfcs(card
);
1052 case ISDN_CTYPE_HFC_PCI
:
1053 ret
= setup_hfcpci(card
);
1057 case ISDN_CTYPE_HFC_SX
:
1058 ret
= setup_hfcsx(card
);
1062 case ISDN_CTYPE_NICCY
:
1063 ret
= setup_niccy(card
);
1067 case ISDN_CTYPE_AMD7930
:
1068 ret
= setup_amd7930(card
);
1072 case ISDN_CTYPE_ISURF
:
1073 ret
= setup_isurf(card
);
1077 case ISDN_CTYPE_HSTSAPHIR
:
1078 ret
= setup_saphir(card
);
1082 case ISDN_CTYPE_TESTEMU
:
1083 ret
= setup_testemu(card
);
1087 case ISDN_CTYPE_BKM_A4T
:
1088 ret
= setup_bkm_a4t(card
);
1092 case ISDN_CTYPE_SCT_QUADRO
:
1093 ret
= setup_sct_quadro(card
);
1097 case ISDN_CTYPE_GAZEL
:
1098 ret
= setup_gazel(card
);
1102 case ISDN_CTYPE_W6692
:
1103 ret
= setup_w6692(card
);
1107 case ISDN_CTYPE_NETJET_U
:
1108 ret
= setup_netjet_u(card
);
1111 #if CARD_FN_ENTERNOW_PCI
1112 case ISDN_CTYPE_ENTERNOW
:
1113 ret
= setup_enternow_pci(card
);
1116 case ISDN_CTYPE_DYNAMIC
:
1121 "HiSax: Support for %s Card not selected\n",
1122 CardType
[card
->typ
]);
1130 if (!(cs
->rcvbuf
= kmalloc(MAX_DFRAME_LEN_L1
, GFP_ATOMIC
))) {
1131 printk(KERN_WARNING
"HiSax: No memory for isac rcvbuf\n");
1139 cs
->tqueue
.data
= cs
;
1141 skb_queue_head_init(&cs
->rq
);
1142 skb_queue_head_init(&cs
->sq
);
1144 init_bcstate(cs
, 0);
1145 init_bcstate(cs
, 1);
1147 /* init_card only handles interrupts which are not */
1148 /* used here for the loadable driver */
1149 switch (card
->typ
) {
1150 case ISDN_CTYPE_DYNAMIC
:
1154 ret
= init_card(cs
);
1162 init_tei(cs
, cs
->protocol
);
1163 ret
= CallcNewChan(cs
);
1169 /* ISAR needs firmware download first */
1170 if (!test_bit(HW_ISAR
, &cs
->HW_Flags
))
1185 static void HiSax_shiftcards(int idx
)
1189 for (i
= idx
; i
< (HISAX_MAX_CARDS
- 1); i
++)
1190 memcpy(&cards
[i
], &cards
[i
+ 1], sizeof(cards
[i
]));
1193 static int HiSax_inithardware(int *busy_flag
)
1200 char *next_id
= HiSax_id
;
1203 if (strchr(HiSax_id
, ','))
1205 else if (strchr(HiSax_id
, '%'))
1208 while (i
< nrcards
) {
1209 if (cards
[i
].typ
< 1)
1212 if ((next_id
= strchr(id
, t
))) {
1221 sprintf(ids
, "%s%d", id
, i
);
1223 if (checkcard(i
, ids
, busy_flag
, THIS_MODULE
)) {
1227 /* make sure we don't oops the module */
1228 if (cards
[i
].typ
> 0 && cards
[i
].typ
<= ISDN_CTYPE_COUNT
) {
1230 "HiSax: Card %s not installed !\n",
1231 CardType
[cards
[i
].typ
]);
1233 HiSax_shiftcards(i
);
1240 void HiSax_closecard(int cardnr
)
1242 int i
, last
= nrcards
- 1;
1244 if (cardnr
> last
|| cardnr
< 0)
1246 if (cards
[cardnr
].cs
) {
1247 ll_stop(cards
[cardnr
].cs
);
1248 release_tei(cards
[cardnr
].cs
);
1249 CallcFreeChan(cards
[cardnr
].cs
);
1252 if (cards
[cardnr
].cs
->irq
)
1253 free_irq(cards
[cardnr
].cs
->irq
, cards
[cardnr
].cs
);
1254 kfree((void *) cards
[cardnr
].cs
);
1255 cards
[cardnr
].cs
= NULL
;
1259 cards
[i
] = cards
[i
+ 1];
1265 void HiSax_reportcard(int cardnr
, int sel
)
1267 struct IsdnCardState
*cs
= cards
[cardnr
].cs
;
1269 printk(KERN_DEBUG
"HiSax: reportcard No %d\n", cardnr
+ 1);
1270 printk(KERN_DEBUG
"HiSax: Type %s\n", CardType
[cs
->typ
]);
1271 printk(KERN_DEBUG
"HiSax: debuglevel %x\n", cs
->debug
);
1272 printk(KERN_DEBUG
"HiSax: HiSax_reportcard address 0x%lX\n",
1273 (ulong
) & HiSax_reportcard
);
1274 printk(KERN_DEBUG
"HiSax: cs 0x%lX\n", (ulong
) cs
);
1275 printk(KERN_DEBUG
"HiSax: HW_Flags %lx bc0 flg %lx bc1 flg %lx\n",
1276 cs
->HW_Flags
, cs
->bcs
[0].Flag
, cs
->bcs
[1].Flag
);
1277 printk(KERN_DEBUG
"HiSax: bcs 0 mode %d ch%d\n",
1278 cs
->bcs
[0].mode
, cs
->bcs
[0].channel
);
1279 printk(KERN_DEBUG
"HiSax: bcs 1 mode %d ch%d\n",
1280 cs
->bcs
[1].mode
, cs
->bcs
[1].channel
);
1281 #ifdef ERROR_STATISTIC
1282 printk(KERN_DEBUG
"HiSax: dc errors(rx,crc,tx) %d,%d,%d\n",
1283 cs
->err_rx
, cs
->err_crc
, cs
->err_tx
);
1285 "HiSax: bc0 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1286 cs
->bcs
[0].err_inv
, cs
->bcs
[0].err_rdo
, cs
->bcs
[0].err_crc
,
1289 "HiSax: bc1 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1290 cs
->bcs
[1].err_inv
, cs
->bcs
[1].err_rdo
, cs
->bcs
[1].err_crc
,
1296 cs
->bcs
[0].err_inv
= 0;
1297 cs
->bcs
[0].err_rdo
= 0;
1298 cs
->bcs
[0].err_crc
= 0;
1299 cs
->bcs
[0].err_tx
= 0;
1300 cs
->bcs
[1].err_inv
= 0;
1301 cs
->bcs
[1].err_rdo
= 0;
1302 cs
->bcs
[1].err_crc
= 0;
1303 cs
->bcs
[1].err_tx
= 0;
1308 static int __init
HiSax_init(void)
1317 retval
= CallcNew();
1320 retval
= Isdnl3New();
1323 retval
= Isdnl2New();
1329 retval
= Isdnl1New();
1335 /* We 'll register drivers later, but init basic functions */
1336 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++)
1340 #ifdef CONFIG_HISAX_ELSA
1341 if (type
[0] == ISDN_CTYPE_ELSA_PCMCIA
) {
1342 /* we have exported and return in this case */
1346 #ifdef CONFIG_HISAX_SEDLBAUER
1347 if (type
[0] == ISDN_CTYPE_SEDLBAUER_PCMCIA
) {
1348 /* we have to export and return in this case */
1352 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
1353 if (type
[0] == ISDN_CTYPE_A1_PCMCIA
) {
1354 /* we have to export and return in this case */
1358 #ifdef CONFIG_HISAX_HFC_SX
1359 if (type
[0] == ISDN_CTYPE_HFC_SP_PCMCIA
) {
1360 /* we have to export and return in this case */
1367 if (id
) /* If id= string used */
1369 for (i
= j
= 0; j
< HISAX_MAX_CARDS
; i
++) {
1370 cards
[j
].typ
= type
[i
];
1372 cards
[j
].protocol
= protocol
[i
];
1375 cards
[j
].protocol
= DEFAULT_PROTO
;
1378 case ISDN_CTYPE_16_0
:
1379 cards
[j
].para
[0] = irq
[i
];
1380 cards
[j
].para
[1] = mem
[i
];
1381 cards
[j
].para
[2] = io
[i
];
1384 case ISDN_CTYPE_8_0
:
1385 cards
[j
].para
[0] = irq
[i
];
1386 cards
[j
].para
[1] = mem
[i
];
1390 case ISDN_CTYPE_PNP
:
1391 case ISDN_CTYPE_NICCY
:
1392 cards
[j
].para
[0] = irq
[i
];
1393 cards
[j
].para
[1] = io0
[i
];
1394 cards
[j
].para
[2] = io1
[i
];
1396 case ISDN_CTYPE_COMPAQ_ISA
:
1397 cards
[j
].para
[0] = irq
[i
];
1398 cards
[j
].para
[1] = io0
[i
];
1399 cards
[j
].para
[2] = io1
[i
];
1400 cards
[j
].para
[3] = io
[i
];
1403 case ISDN_CTYPE_ELSA
:
1404 case ISDN_CTYPE_HFC_PCI
:
1405 cards
[j
].para
[0] = io
[i
];
1407 case ISDN_CTYPE_16_3
:
1408 case ISDN_CTYPE_TELESPCMCIA
:
1410 case ISDN_CTYPE_A1_PCMCIA
:
1411 case ISDN_CTYPE_ELSA_PNP
:
1412 case ISDN_CTYPE_ELSA_PCMCIA
:
1413 case ISDN_CTYPE_IX1MICROR2
:
1414 case ISDN_CTYPE_DIEHLDIVA
:
1415 case ISDN_CTYPE_ASUSCOM
:
1416 case ISDN_CTYPE_TELEINT
:
1417 case ISDN_CTYPE_SEDLBAUER
:
1418 case ISDN_CTYPE_SEDLBAUER_PCMCIA
:
1419 case ISDN_CTYPE_SEDLBAUER_FAX
:
1420 case ISDN_CTYPE_SPORTSTER
:
1421 case ISDN_CTYPE_MIC
:
1422 case ISDN_CTYPE_TELES3C
:
1423 case ISDN_CTYPE_ACERP10
:
1424 case ISDN_CTYPE_S0BOX
:
1425 case ISDN_CTYPE_FRITZPCI
:
1426 case ISDN_CTYPE_HSTSAPHIR
:
1427 case ISDN_CTYPE_GAZEL
:
1428 case ISDN_CTYPE_HFC_SX
:
1429 case ISDN_CTYPE_HFC_SP_PCMCIA
:
1430 cards
[j
].para
[0] = irq
[i
];
1431 cards
[j
].para
[1] = io
[i
];
1433 case ISDN_CTYPE_ISURF
:
1434 cards
[j
].para
[0] = irq
[i
];
1435 cards
[j
].para
[1] = io
[i
];
1436 cards
[j
].para
[2] = mem
[i
];
1438 case ISDN_CTYPE_ELSA_PCI
:
1439 case ISDN_CTYPE_NETJET_S
:
1440 case ISDN_CTYPE_AMD7930
:
1441 case ISDN_CTYPE_TELESPCI
:
1442 case ISDN_CTYPE_W6692
:
1443 case ISDN_CTYPE_NETJET_U
:
1445 case ISDN_CTYPE_BKM_A4T
:
1447 case ISDN_CTYPE_SCT_QUADRO
:
1449 cards
[j
].para
[0] = irq
[i
];
1451 /* QUADRO is a 4 BRI card */
1452 cards
[j
++].para
[0] = 1;
1453 /* we need to check if further cards can be added */
1454 if (j
< HISAX_MAX_CARDS
) {
1455 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1456 cards
[j
].protocol
= protocol
[i
];
1457 cards
[j
++].para
[0] = 2;
1459 if (j
< HISAX_MAX_CARDS
) {
1460 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1461 cards
[j
].protocol
= protocol
[i
];
1462 cards
[j
++].para
[0] = 3;
1464 if (j
< HISAX_MAX_CARDS
) {
1465 cards
[j
].typ
= ISDN_CTYPE_SCT_QUADRO
;
1466 cards
[j
].protocol
= protocol
[i
];
1467 cards
[j
].para
[0] = 4;
1476 "HiSax: Warning - no protocol specified\n");
1477 printk(KERN_WARNING
"HiSax: using protocol %s\n",
1478 DEFAULT_PROTO_NAME
);
1484 strcpy(HiSaxID
, "HiSax");
1485 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++)
1486 if (cards
[i
].typ
> 0)
1488 printk(KERN_DEBUG
"HiSax: Total %d card%s defined\n",
1489 nrcards
, (nrcards
> 1) ? "s" : "");
1491 /* Install only, if at least one card found */
1492 if (!HiSax_inithardware(NULL
))
1508 static void __exit
HiSax_exit(void)
1510 int cardnr
= nrcards
- 1;
1513 HiSax_closecard(cardnr
--);
1519 printk(KERN_INFO
"HiSax module removed\n");
1522 int hisax_init_pcmcia(void *pcm_iob
, int *busy_flag
, struct IsdnCard
*card
)
1527 cards
[nrcards
] = *card
;
1529 sprintf(ids
, "HiSax%d", nrcards
);
1531 sprintf(ids
, "HiSax");
1532 if (!checkcard(nrcards
, ids
, busy_flag
, THIS_MODULE
))
1541 EXPORT_SYMBOL(hisax_init_pcmcia
);
1542 EXPORT_SYMBOL(HiSax_closecard
);
1544 #include "hisax_if.h"
1546 EXPORT_SYMBOL(hisax_register
);
1547 EXPORT_SYMBOL(hisax_unregister
);
1549 static void hisax_d_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
);
1550 static void hisax_b_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
);
1551 static void hisax_d_l2l1(struct PStack
*st
, int pr
, void *arg
);
1552 static void hisax_b_l2l1(struct PStack
*st
, int pr
, void *arg
);
1553 static int hisax_cardmsg(struct IsdnCardState
*cs
, int mt
, void *arg
);
1554 static int hisax_bc_setstack(struct PStack
*st
, struct BCState
*bcs
);
1555 static void hisax_bc_close(struct BCState
*bcs
);
1556 static void hisax_bh(struct IsdnCardState
*cs
);
1557 static void EChannel_proc_rcv(struct hisax_d_if
*d_if
);
1559 int hisax_register(struct hisax_d_if
*hisax_d_if
, struct hisax_b_if
*b_if
[],
1560 char *name
, int protocol
)
1564 struct IsdnCardState
*cs
;
1566 for (i
= 0; i
< HISAX_MAX_CARDS
; i
++) {
1571 if (i
>= HISAX_MAX_CARDS
)
1574 cards
[i
].typ
= ISDN_CTYPE_DYNAMIC
;
1575 cards
[i
].protocol
= protocol
;
1576 sprintf(id
, "%s%d", name
, i
);
1578 retval
= checkcard(i
, id
, NULL
, hisax_d_if
->owner
);
1579 if (retval
== 0) { // yuck
1585 hisax_d_if
->cs
= cs
;
1586 cs
->hw
.hisax_d_if
= hisax_d_if
;
1587 cs
->cardmsg
= hisax_cardmsg
;
1588 INIT_WORK(&cs
->tqueue
, (void *)(void *)hisax_bh
, cs
);
1589 cs
->channel
[0].d_st
->l2
.l2l1
= hisax_d_l2l1
;
1590 for (i
= 0; i
< 2; i
++) {
1591 cs
->bcs
[i
].BC_SetStack
= hisax_bc_setstack
;
1592 cs
->bcs
[i
].BC_Close
= hisax_bc_close
;
1594 b_if
[i
]->ifc
.l1l2
= hisax_b_l1l2
;
1596 hisax_d_if
->b_if
[i
] = b_if
[i
];
1598 hisax_d_if
->ifc
.l1l2
= hisax_d_l1l2
;
1599 skb_queue_head_init(&hisax_d_if
->erq
);
1600 clear_bit(0, &hisax_d_if
->ph_state
);
1605 void hisax_unregister(struct hisax_d_if
*hisax_d_if
)
1607 cards
[hisax_d_if
->cs
->cardnr
].typ
= 0;
1608 HiSax_closecard(hisax_d_if
->cs
->cardnr
);
1609 skb_queue_purge(&hisax_d_if
->erq
);
1614 static void hisax_sched_event(struct IsdnCardState
*cs
, int event
)
1616 test_and_set_bit(event
, &cs
->event
);
1617 schedule_work(&cs
->tqueue
);
1620 static void hisax_bh(struct IsdnCardState
*cs
)
1625 if (test_and_clear_bit(D_RCVBUFREADY
, &cs
->event
))
1626 DChannel_proc_rcv(cs
);
1627 if (test_and_clear_bit(E_RCVBUFREADY
, &cs
->event
))
1628 EChannel_proc_rcv(cs
->hw
.hisax_d_if
);
1629 if (test_and_clear_bit(D_L1STATECHANGE
, &cs
->event
)) {
1630 if (test_bit(0, &cs
->hw
.hisax_d_if
->ph_state
))
1631 pr
= PH_ACTIVATE
| INDICATION
;
1633 pr
= PH_DEACTIVATE
| INDICATION
;
1634 for (st
= cs
->stlist
; st
; st
= st
->next
)
1635 st
->l1
.l1l2(st
, pr
, NULL
);
1640 static void hisax_b_sched_event(struct BCState
*bcs
, int event
)
1642 test_and_set_bit(event
, &bcs
->event
);
1643 schedule_work(&bcs
->tqueue
);
1646 static inline void D_L2L1(struct hisax_d_if
*d_if
, int pr
, void *arg
)
1648 struct hisax_if
*ifc
= (struct hisax_if
*) d_if
;
1649 ifc
->l2l1(ifc
, pr
, arg
);
1652 static inline void B_L2L1(struct hisax_b_if
*b_if
, int pr
, void *arg
)
1654 struct hisax_if
*ifc
= (struct hisax_if
*) b_if
;
1655 ifc
->l2l1(ifc
, pr
, arg
);
1658 static void hisax_d_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
)
1660 struct hisax_d_if
*d_if
= (struct hisax_d_if
*) ifc
;
1661 struct IsdnCardState
*cs
= d_if
->cs
;
1663 struct sk_buff
*skb
;
1666 case PH_ACTIVATE
| INDICATION
:
1667 set_bit(0, &d_if
->ph_state
);
1668 hisax_sched_event(cs
, D_L1STATECHANGE
);
1670 case PH_DEACTIVATE
| INDICATION
:
1671 clear_bit(0, &d_if
->ph_state
);
1672 hisax_sched_event(cs
, D_L1STATECHANGE
);
1674 case PH_DATA
| INDICATION
:
1675 skb_queue_tail(&cs
->rq
, arg
);
1676 hisax_sched_event(cs
, D_RCVBUFREADY
);
1678 case PH_DATA
| CONFIRM
:
1679 skb
= skb_dequeue(&cs
->sq
);
1681 D_L2L1(d_if
, PH_DATA
| REQUEST
, skb
);
1684 clear_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
);
1685 for (st
= cs
->stlist
; st
; st
= st
->next
) {
1686 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
)) {
1687 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1692 case PH_DATA_E
| INDICATION
:
1693 skb_queue_tail(&d_if
->erq
, arg
);
1694 hisax_sched_event(cs
, E_RCVBUFREADY
);
1697 printk("pr %#x\n", pr
);
1702 static void hisax_b_l1l2(struct hisax_if
*ifc
, int pr
, void *arg
)
1704 struct hisax_b_if
*b_if
= (struct hisax_b_if
*) ifc
;
1705 struct BCState
*bcs
= b_if
->bcs
;
1706 struct PStack
*st
= bcs
->st
;
1707 struct sk_buff
*skb
;
1709 // FIXME use isdnl1?
1711 case PH_ACTIVATE
| INDICATION
:
1712 st
->l1
.l1l2(st
, pr
, NULL
);
1714 case PH_DEACTIVATE
| INDICATION
:
1715 st
->l1
.l1l2(st
, pr
, NULL
);
1716 clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1717 skb_queue_purge(&bcs
->squeue
);
1718 bcs
->hw
.b_if
= NULL
;
1720 case PH_DATA
| INDICATION
:
1721 skb_queue_tail(&bcs
->rqueue
, arg
);
1722 hisax_b_sched_event(bcs
, B_RCVBUFREADY
);
1724 case PH_DATA
| CONFIRM
:
1725 bcs
->tx_cnt
-= (int) arg
;
1726 if (test_bit(FLG_LLI_L1WAKEUP
,&bcs
->st
->lli
.flag
)) {
1728 spin_lock_irqsave(&bcs
->aclock
, flags
);
1729 bcs
->ackcnt
+= (int) arg
;
1730 spin_unlock_irqrestore(&bcs
->aclock
, flags
);
1731 schedule_event(bcs
, B_ACKPENDING
);
1733 skb
= skb_dequeue(&bcs
->squeue
);
1735 B_L2L1(b_if
, PH_DATA
| REQUEST
, skb
);
1738 clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1739 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
)) {
1740 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1744 printk("hisax_b_l1l2 pr %#x\n", pr
);
1749 static void hisax_d_l2l1(struct PStack
*st
, int pr
, void *arg
)
1751 struct IsdnCardState
*cs
= st
->l1
.hardware
;
1752 struct hisax_d_if
*hisax_d_if
= cs
->hw
.hisax_d_if
;
1753 struct sk_buff
*skb
= arg
;
1756 case PH_DATA
| REQUEST
:
1757 case PH_PULL
| INDICATION
:
1758 if (cs
->debug
& DEB_DLOG_HEX
)
1759 LogFrame(cs
, skb
->data
, skb
->len
);
1760 if (cs
->debug
& DEB_DLOG_VERBOSE
)
1761 dlogframe(cs
, skb
, 0);
1762 Logl2Frame(cs
, skb
, "PH_DATA_REQ", 0);
1764 if (!test_and_set_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
))
1765 D_L2L1(hisax_d_if
, PH_DATA
| REQUEST
, skb
);
1767 skb_queue_tail(&cs
->sq
, skb
);
1769 case PH_PULL
| REQUEST
:
1770 if (!test_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
))
1771 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1773 set_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
);
1776 D_L2L1(hisax_d_if
, pr
, arg
);
1781 static int hisax_cardmsg(struct IsdnCardState
*cs
, int mt
, void *arg
)
1786 static void hisax_b_l2l1(struct PStack
*st
, int pr
, void *arg
)
1788 struct BCState
*bcs
= st
->l1
.bcs
;
1789 struct hisax_b_if
*b_if
= bcs
->hw
.b_if
;
1792 case PH_ACTIVATE
| REQUEST
:
1793 B_L2L1(b_if
, pr
, (void *) st
->l1
.mode
);
1795 case PH_DATA
| REQUEST
:
1796 case PH_PULL
| INDICATION
:
1798 if (!test_and_set_bit(BC_FLG_BUSY
, &bcs
->Flag
)) {
1799 B_L2L1(b_if
, PH_DATA
| REQUEST
, arg
);
1801 skb_queue_tail(&bcs
->squeue
, arg
);
1804 case PH_PULL
| REQUEST
:
1805 if (!test_bit(BC_FLG_BUSY
, &bcs
->Flag
))
1806 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
1808 set_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
);
1810 case PH_DEACTIVATE
| REQUEST
:
1811 test_and_clear_bit(BC_FLG_BUSY
, &bcs
->Flag
);
1812 skb_queue_purge(&bcs
->squeue
);
1814 B_L2L1(b_if
, pr
, arg
);
1819 static int hisax_bc_setstack(struct PStack
*st
, struct BCState
*bcs
)
1821 struct IsdnCardState
*cs
= st
->l1
.hardware
;
1822 struct hisax_d_if
*hisax_d_if
= cs
->hw
.hisax_d_if
;
1824 bcs
->channel
= st
->l1
.bc
;
1826 bcs
->hw
.b_if
= hisax_d_if
->b_if
[st
->l1
.bc
];
1827 hisax_d_if
->b_if
[st
->l1
.bc
]->bcs
= bcs
;
1830 st
->l2
.l2l1
= hisax_b_l2l1
;
1831 setstack_manager(st
);
1834 skb_queue_head_init(&bcs
->rqueue
);
1835 skb_queue_head_init(&bcs
->squeue
);
1839 static void hisax_bc_close(struct BCState
*bcs
)
1841 struct hisax_b_if
*b_if
= bcs
->hw
.b_if
;
1844 B_L2L1(b_if
, PH_DEACTIVATE
| REQUEST
, NULL
);
1847 static void EChannel_proc_rcv(struct hisax_d_if
*d_if
)
1849 struct IsdnCardState
*cs
= d_if
->cs
;
1851 struct sk_buff
*skb
;
1853 while ((skb
= skb_dequeue(&d_if
->erq
)) != NULL
) {
1854 if (cs
->debug
& DEB_DLOG_HEX
) {
1856 if ((skb
->len
) < MAX_DLOG_SPACE
/ 3 - 10) {
1862 ptr
+= QuickHex(ptr
, skb
->data
, skb
->len
);
1866 HiSax_putstatus(cs
, NULL
, cs
->dlog
);
1868 HiSax_putstatus(cs
, "LogEcho: ",
1869 "warning Frame too big (%d)",
1872 dev_kfree_skb_any(skb
);
1877 #include <linux/pci.h>
1879 static struct pci_device_id hisax_pci_tbl
[] __initdata
= {
1880 #ifdef CONFIG_HISAX_FRITZPCI
1881 {PCI_VENDOR_ID_AVM
, PCI_DEVICE_ID_AVM_A1
, PCI_ANY_ID
, PCI_ANY_ID
},
1883 #ifdef CONFIG_HISAX_DIEHLDIVA
1884 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA20
, PCI_ANY_ID
, PCI_ANY_ID
},
1885 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA20_U
, PCI_ANY_ID
, PCI_ANY_ID
},
1886 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA201
, PCI_ANY_ID
, PCI_ANY_ID
},
1887 //#########################################################################################
1888 {PCI_VENDOR_ID_EICON
, PCI_DEVICE_ID_EICON_DIVA202
, PCI_ANY_ID
, PCI_ANY_ID
},
1889 //#########################################################################################
1891 #ifdef CONFIG_HISAX_ELSA
1892 {PCI_VENDOR_ID_ELSA
, PCI_DEVICE_ID_ELSA_MICROLINK
, PCI_ANY_ID
, PCI_ANY_ID
},
1893 {PCI_VENDOR_ID_ELSA
, PCI_DEVICE_ID_ELSA_QS3000
, PCI_ANY_ID
, PCI_ANY_ID
},
1895 #ifdef CONFIG_HISAX_GAZEL
1896 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_R685
, PCI_ANY_ID
, PCI_ANY_ID
},
1897 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_R753
, PCI_ANY_ID
, PCI_ANY_ID
},
1898 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_DJINN_ITOO
, PCI_ANY_ID
, PCI_ANY_ID
},
1899 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_OLITEC
, PCI_ANY_ID
, PCI_ANY_ID
},
1901 #ifdef CONFIG_HISAX_QUADRO
1902 {PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_9050
, PCI_ANY_ID
, PCI_ANY_ID
},
1904 #ifdef CONFIG_HISAX_NICCY
1905 {PCI_VENDOR_ID_SATSAGEM
, PCI_DEVICE_ID_SATSAGEM_NICCY
, PCI_ANY_ID
,PCI_ANY_ID
},
1907 #ifdef CONFIG_HISAX_SEDLBAUER
1908 {PCI_VENDOR_ID_TIGERJET
, PCI_DEVICE_ID_TIGERJET_100
, PCI_ANY_ID
,PCI_ANY_ID
},
1910 #if defined(CONFIG_HISAX_NETJET) || defined(CONFIG_HISAX_NETJET_U)
1911 {PCI_VENDOR_ID_TIGERJET
, PCI_DEVICE_ID_TIGERJET_300
, PCI_ANY_ID
,PCI_ANY_ID
},
1913 #if defined(CONFIG_HISAX_TELESPCI) || defined(CONFIG_HISAX_SCT_QUADRO)
1914 {PCI_VENDOR_ID_ZORAN
, PCI_DEVICE_ID_ZORAN_36120
, PCI_ANY_ID
,PCI_ANY_ID
},
1916 #ifdef CONFIG_HISAX_W6692
1917 {PCI_VENDOR_ID_DYNALINK
, PCI_DEVICE_ID_DYNALINK_IS64PH
, PCI_ANY_ID
,PCI_ANY_ID
},
1918 {PCI_VENDOR_ID_WINBOND2
, PCI_DEVICE_ID_WINBOND2_6692
, PCI_ANY_ID
,PCI_ANY_ID
},
1920 #ifdef CONFIG_HISAX_HFC_PCI
1921 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_2BD0
, PCI_ANY_ID
, PCI_ANY_ID
},
1922 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B000
, PCI_ANY_ID
, PCI_ANY_ID
},
1923 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B006
, PCI_ANY_ID
, PCI_ANY_ID
},
1924 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B007
, PCI_ANY_ID
, PCI_ANY_ID
},
1925 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B008
, PCI_ANY_ID
, PCI_ANY_ID
},
1926 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B009
, PCI_ANY_ID
, PCI_ANY_ID
},
1927 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00A
, PCI_ANY_ID
, PCI_ANY_ID
},
1928 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00B
, PCI_ANY_ID
, PCI_ANY_ID
},
1929 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B00C
, PCI_ANY_ID
, PCI_ANY_ID
},
1930 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B100
, PCI_ANY_ID
, PCI_ANY_ID
},
1931 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B700
, PCI_ANY_ID
, PCI_ANY_ID
},
1932 {PCI_VENDOR_ID_CCD
, PCI_DEVICE_ID_CCD_B701
, PCI_ANY_ID
, PCI_ANY_ID
},
1933 {PCI_VENDOR_ID_ABOCOM
, PCI_DEVICE_ID_ABOCOM_2BD1
, PCI_ANY_ID
, PCI_ANY_ID
},
1934 {PCI_VENDOR_ID_ASUSTEK
, PCI_DEVICE_ID_ASUSTEK_0675
, PCI_ANY_ID
, PCI_ANY_ID
},
1935 {PCI_VENDOR_ID_BERKOM
, PCI_DEVICE_ID_BERKOM_T_CONCEPT
, PCI_ANY_ID
, PCI_ANY_ID
},
1936 {PCI_VENDOR_ID_BERKOM
, PCI_DEVICE_ID_BERKOM_A1T
, PCI_ANY_ID
, PCI_ANY_ID
},
1937 {PCI_VENDOR_ID_ANIGMA
, PCI_DEVICE_ID_ANIGMA_MC145575
, PCI_ANY_ID
, PCI_ANY_ID
},
1938 {PCI_VENDOR_ID_ZOLTRIX
, PCI_DEVICE_ID_ZOLTRIX_2BD0
, PCI_ANY_ID
, PCI_ANY_ID
},
1939 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_IOM2_E
, PCI_ANY_ID
, PCI_ANY_ID
},
1940 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_E
, PCI_ANY_ID
, PCI_ANY_ID
},
1941 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_IOM2_A
, PCI_ANY_ID
, PCI_ANY_ID
},
1942 {PCI_VENDOR_ID_DIGI
, PCI_DEVICE_ID_DIGI_DF_M_A
, PCI_ANY_ID
, PCI_ANY_ID
},
1944 { } /* Terminating entry */
1947 MODULE_DEVICE_TABLE(pci
, hisax_pci_tbl
);
1948 #endif /* CONFIG_PCI */
1950 module_init(HiSax_init
);
1951 module_exit(HiSax_exit
);
1953 EXPORT_SYMBOL(FsmNew
);
1954 EXPORT_SYMBOL(FsmFree
);
1955 EXPORT_SYMBOL(FsmEvent
);
1956 EXPORT_SYMBOL(FsmChangeState
);
1957 EXPORT_SYMBOL(FsmInitTimer
);
1958 EXPORT_SYMBOL(FsmDelTimer
);
1959 EXPORT_SYMBOL(FsmRestartTimer
);