?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Andries Brouwer: final isofs pieces.
[davej-history.git] / drivers / isdn / hisax / config.c
blob499970ea202a96253dc88d4b5672ff4f6ffc4c50
1 /* $Id: config.c,v 2.57.6.3 2000/11/29 17:48:59 kai Exp $
2 *
3 * Author Karsten Keil (keil@isdn4linux.de)
4 * based on the teles driver from Jan den Ouden
5 *
6 * This file is (c) under GNU PUBLIC LICENSE
7 *
8 */
9 #include <linux/types.h>
10 #include <linux/stddef.h>
11 #include <linux/timer.h>
12 #include <linux/config.h>
13 #include <linux/init.h>
14 #include <linux/pci.h>
15 #include "hisax.h"
16 #include <linux/module.h>
17 #include <linux/kernel_stat.h>
18 #include <linux/tqueue.h>
19 #include <linux/interrupt.h>
20 #define HISAX_STATUS_BUFSIZE 4096
21 #define INCLUDE_INLINE_FUNCS
22
23 /*
24 * This structure array contains one entry per card. An entry looks
25 * like this:
26 *
27 * { type, protocol, p0, p1, p2, NULL }
28 *
29 * type
30 * 1 Teles 16.0 p0=irq p1=membase p2=iobase
31 * 2 Teles 8.0 p0=irq p1=membase
32 * 3 Teles 16.3 p0=irq p1=iobase
33 * 4 Creatix PNP p0=irq p1=IO0 (ISAC) p2=IO1 (HSCX)
34 * 5 AVM A1 (Fritz) p0=irq p1=iobase
35 * 6 ELSA PC [p0=iobase] or nothing (autodetect)
36 * 7 ELSA Quickstep p0=irq p1=iobase
37 * 8 Teles PCMCIA p0=irq p1=iobase
38 * 9 ITK ix1-micro p0=irq p1=iobase
39 * 10 ELSA PCMCIA p0=irq p1=iobase
40 * 11 Eicon.Diehl Diva p0=irq p1=iobase
41 * 12 Asuscom ISDNLink p0=irq p1=iobase
42 * 13 Teleint p0=irq p1=iobase
43 * 14 Teles 16.3c p0=irq p1=iobase
44 * 15 Sedlbauer speed p0=irq p1=iobase
45 * 15 Sedlbauer PC/104 p0=irq p1=iobase
46 * 15 Sedlbauer speed pci no parameter
47 * 16 USR Sportster internal p0=irq p1=iobase
48 * 17 MIC card p0=irq p1=iobase
49 * 18 ELSA Quickstep 1000PCI no parameter
50 * 19 Compaq ISDN S0 ISA card p0=irq p1=IO0 (HSCX) p2=IO1 (ISAC) p3=IO2
51 * 20 Travers Technologies NETjet-S PCI card
52 * 21 TELES PCI no parameter
53 * 22 Sedlbauer Speed Star p0=irq p1=iobase
54 * 23 reserved
55 * 24 Dr Neuhaus Niccy PnP/PCI card p0=irq p1=IO0 p2=IO1 (PnP only)
56 * 25 Teles S0Box p0=irq p1=iobase (from isapnp setup)
57 * 26 AVM A1 PCMCIA (Fritz) p0=irq p1=iobase
58 * 27 AVM PnP/PCI p0=irq p1=iobase (PCI no parameter)
59 * 28 Sedlbauer Speed Fax+ p0=irq p1=iobase (from isapnp setup)
60 * 29 Siemens I-Surf p0=irq p1=iobase p2=memory (from isapnp setup)
61 * 30 ACER P10 p0=irq p1=iobase (from isapnp setup)
62 * 31 HST Saphir p0=irq p1=iobase
63 * 32 Telekom A4T none
64 * 33 Scitel Quadro p0=subcontroller (4*S0, subctrl 1...4)
65 * 34 Gazel ISDN cards
66 * 35 HFC 2BDS0 PCI none
67 * 36 Winbond 6692 PCI none
68 * 37 HFC 2BDS0 S+/SP p0=irq p1=iobase
69 * 38 Travers Technologies NETspider-U PCI card
70 * 39 HFC 2BDS0-SP PCMCIA p0=irq p1=iobase
71 *
72 * protocol can be either ISDN_PTYPE_EURO or ISDN_PTYPE_1TR6 or ISDN_PTYPE_NI1
73 *
74 *
75 */
76
77 const char *CardType[] =
78 {"No Card", "Teles 16.0", "Teles 8.0", "Teles 16.3", "Creatix/Teles PnP",
79 "AVM A1", "Elsa ML", "Elsa Quickstep", "Teles PCMCIA", "ITK ix1-micro Rev.2",
80 "Elsa PCMCIA", "Eicon.Diehl Diva", "ISDNLink", "TeleInt", "Teles 16.3c",
81 "Sedlbauer Speed Card", "USR Sportster", "ith mic Linux", "Elsa PCI",
82 "Compaq ISA", "NETjet-S", "Teles PCI", "Sedlbauer Speed Star (PCMCIA)",
83 "AMD 7930", "NICCY", "S0Box", "AVM A1 (PCMCIA)", "AVM Fritz PnP/PCI",
84 "Sedlbauer Speed Fax +", "Siemens I-Surf", "Acer P10", "HST Saphir",
85 "Telekom A4T", "Scitel Quadro", "Gazel", "HFC 2BDS0 PCI", "Winbond 6692",
86 "HFC 2BDS0 SX", "NETspider-U", "HFC-2BDS0-SP PCMCIA",
87 };
88
89 void HiSax_closecard(int cardnr);
90
91 #ifdef CONFIG_HISAX_ELSA
92 #define DEFAULT_CARD ISDN_CTYPE_ELSA
93 #define DEFAULT_CFG {0,0,0,0}
94 int elsa_init_pcmcia(void*, int, int*, int);
95 EXPORT_SYMBOL(elsa_init_pcmcia);
96 #endif /* CONFIG_HISAX_ELSA */
97
98 #ifdef CONFIG_HISAX_AVM_A1
99 #undef DEFAULT_CARD
100 #undef DEFAULT_CFG
101 #define DEFAULT_CARD ISDN_CTYPE_A1
102 #define DEFAULT_CFG {10,0x340,0,0}
103 #endif
104
105 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
106 #undef DEFAULT_CARD
107 #undef DEFAULT_CFG
108 #define DEFAULT_CARD ISDN_CTYPE_A1_PCMCIA
109 #define DEFAULT_CFG {11,0x170,0,0}
110 int avm_a1_init_pcmcia(void*, int, int*, int);
111 EXPORT_SYMBOL(avm_a1_init_pcmcia);
112 #endif /* CONFIG_HISAX_AVM_A1_PCMCIA */
113
114 #ifdef CONFIG_HISAX_FRITZPCI
115 #undef DEFAULT_CARD
116 #undef DEFAULT_CFG
117 #define DEFAULT_CARD ISDN_CTYPE_FRITZPCI
118 #define DEFAULT_CFG {0,0,0,0}
119 #endif
120
121 #ifdef CONFIG_HISAX_16_3
122 #undef DEFAULT_CARD
123 #undef DEFAULT_CFG
124 #define DEFAULT_CARD ISDN_CTYPE_16_3
125 #define DEFAULT_CFG {15,0x180,0,0}
126 #endif
127
128 #ifdef CONFIG_HISAX_S0BOX
129 #undef DEFAULT_CARD
130 #undef DEFAULT_CFG
131 #define DEFAULT_CARD ISDN_CTYPE_S0BOX
132 #define DEFAULT_CFG {7,0x378,0,0}
133 #endif
134
135 #ifdef CONFIG_HISAX_16_0
136 #undef DEFAULT_CARD
137 #undef DEFAULT_CFG
138 #define DEFAULT_CARD ISDN_CTYPE_16_0
139 #define DEFAULT_CFG {15,0xd0000,0xd80,0}
140 #endif
141
142 #ifdef CONFIG_HISAX_TELESPCI
143 #undef DEFAULT_CARD
144 #undef DEFAULT_CFG
145 #define DEFAULT_CARD ISDN_CTYPE_TELESPCI
146 #define DEFAULT_CFG {0,0,0,0}
147 #endif
148
149 #ifdef CONFIG_HISAX_IX1MICROR2
150 #undef DEFAULT_CARD
151 #undef DEFAULT_CFG
152 #define DEFAULT_CARD ISDN_CTYPE_IX1MICROR2
153 #define DEFAULT_CFG {5,0x390,0,0}
154 #endif
155
156 #ifdef CONFIG_HISAX_DIEHLDIVA
157 #undef DEFAULT_CARD
158 #undef DEFAULT_CFG
159 #define DEFAULT_CARD ISDN_CTYPE_DIEHLDIVA
160 #define DEFAULT_CFG {0,0x0,0,0}
161 #endif
162
163 #ifdef CONFIG_HISAX_ASUSCOM
164 #undef DEFAULT_CARD
165 #undef DEFAULT_CFG
166 #define DEFAULT_CARD ISDN_CTYPE_ASUSCOM
167 #define DEFAULT_CFG {5,0x200,0,0}
168 #endif
169
170 #ifdef CONFIG_HISAX_TELEINT
171 #undef DEFAULT_CARD
172 #undef DEFAULT_CFG
173 #define DEFAULT_CARD ISDN_CTYPE_TELEINT
174 #define DEFAULT_CFG {5,0x300,0,0}
175 #endif
176
177 #ifdef CONFIG_HISAX_SEDLBAUER
178 #undef DEFAULT_CARD
179 #undef DEFAULT_CFG
180 #define DEFAULT_CARD ISDN_CTYPE_SEDLBAUER
181 #define DEFAULT_CFG {11,0x270,0,0}
182 int sedl_init_pcmcia(void*, int, int*, int);
183 EXPORT_SYMBOL(sedl_init_pcmcia);
184 #endif /* CONFIG_HISAX_SEDLBAUER */
185
186 #ifdef CONFIG_HISAX_SPORTSTER
187 #undef DEFAULT_CARD
188 #undef DEFAULT_CFG
189 #define DEFAULT_CARD ISDN_CTYPE_SPORTSTER
190 #define DEFAULT_CFG {7,0x268,0,0}
191 #endif
192
193 #ifdef CONFIG_HISAX_MIC
194 #undef DEFAULT_CARD
195 #undef DEFAULT_CFG
196 #define DEFAULT_CARD ISDN_CTYPE_MIC
197 #define DEFAULT_CFG {12,0x3e0,0,0}
198 #endif
199
200 #ifdef CONFIG_HISAX_NETJET
201 #undef DEFAULT_CARD
202 #undef DEFAULT_CFG
203 #define DEFAULT_CARD ISDN_CTYPE_NETJET_S
204 #define DEFAULT_CFG {0,0,0,0}
205 #endif
206
207 #ifdef CONFIG_HISAX_HFCS
208 #undef DEFAULT_CARD
209 #undef DEFAULT_CFG
210 #define DEFAULT_CARD ISDN_CTYPE_TELES3C
211 #define DEFAULT_CFG {5,0x500,0,0}
212 #endif
213
214 #ifdef CONFIG_HISAX_HFC_PCI
215 #undef DEFAULT_CARD
216 #undef DEFAULT_CFG
217 #define DEFAULT_CARD ISDN_CTYPE_HFC_PCI
218 #define DEFAULT_CFG {0,0,0,0}
219 #endif
220
221 #ifdef CONFIG_HISAX_HFC_SX
222 #undef DEFAULT_CARD
223 #undef DEFAULT_CFG
224 #define DEFAULT_CARD ISDN_CTYPE_HFC_SX
225 #define DEFAULT_CFG {5,0x2E0,0,0}
226 int hfc_init_pcmcia(void*, int, int*, int);
227 EXPORT_SYMBOL(hfc_init_pcmcia);
228 #endif
229
230
231 #ifdef CONFIG_HISAX_AMD7930
232 #undef DEFAULT_CARD
233 #undef DEFAULT_CFG
234 #define DEFAULT_CARD ISDN_CTYPE_AMD7930
235 #define DEFAULT_CFG {12,0x3e0,0,0}
236 #endif
237
238 #ifdef CONFIG_HISAX_NICCY
239 #undef DEFAULT_CARD
240 #undef DEFAULT_CFG
241 #define DEFAULT_CARD ISDN_CTYPE_NICCY
242 #define DEFAULT_CFG {0,0x0,0,0}
243 #endif
244
245 #ifdef CONFIG_HISAX_ISURF
246 #undef DEFAULT_CARD
247 #undef DEFAULT_CFG
248 #define DEFAULT_CARD ISDN_CTYPE_ISURF
249 #define DEFAULT_CFG {5,0x100,0xc8000,0}
250 #endif
251
252 #ifdef CONFIG_HISAX_HSTSAPHIR
253 #undef DEFAULT_CARD
254 #undef DEFAULT_CFG
255 #define DEFAULT_CARD ISDN_CTYPE_HSTSAPHIR
256 #define DEFAULT_CFG {5,0x250,0,0}
257 #endif
258
259 #ifdef CONFIG_HISAX_BKM_A4T
260 #undef DEFAULT_CARD
261 #undef DEFAULT_CFG
262 #define DEFAULT_CARD ISDN_CTYPE_BKM_A4T
263 #define DEFAULT_CFG {0,0x0,0,0}
264 #endif
265
266 #ifdef CONFIG_HISAX_SCT_QUADRO
267 #undef DEFAULT_CARD
268 #undef DEFAULT_CFG
269 #define DEFAULT_CARD ISDN_CTYPE_SCT_QUADRO
270 #define DEFAULT_CFG {1,0x0,0,0}
271 #endif
272
273 #ifdef CONFIG_HISAX_GAZEL
274 #undef DEFAULT_CARD
275 #undef DEFAULT_CFG
276 #define DEFAULT_CARD ISDN_CTYPE_GAZEL
277 #define DEFAULT_CFG {15,0x180,0,0}
278 #endif
279
280 #ifdef CONFIG_HISAX_W6692
281 #undef DEFAULT_CARD
282 #undef DEFAULT_CFG
283 #define DEFAULT_CARD ISDN_CTYPE_W6692
284 #define DEFAULT_CFG {0,0,0,0}
285 #endif
286
287 #ifdef CONFIG_HISAX_NETJET_U
288 #undef DEFAULT_CARD
289 #undef DEFAULT_CFG
290 #define DEFAULT_CARD ISDN_CTYPE_NETJET_U
291 #define DEFAULT_CFG {0,0,0,0}
292 #endif
293
294 #ifdef CONFIG_HISAX_1TR6
295 #define DEFAULT_PROTO ISDN_PTYPE_1TR6
296 #define DEFAULT_PROTO_NAME "1TR6"
297 #endif
298 #ifdef CONFIG_HISAX_NI1
299 #undef DEFAULT_PROTO
300 #define DEFAULT_PROTO ISDN_PTYPE_NI1
301 #undef DEFAULT_PROTO_NAME
302 #define DEFAULT_PROTO_NAME "NI1"
303 #endif
304 #ifdef CONFIG_HISAX_EURO
305 #undef DEFAULT_PROTO
306 #define DEFAULT_PROTO ISDN_PTYPE_EURO
307 #undef DEFAULT_PROTO_NAME
308 #define DEFAULT_PROTO_NAME "EURO"
309 #endif
310 #ifndef DEFAULT_PROTO
311 #define DEFAULT_PROTO ISDN_PTYPE_UNKNOWN
312 #define DEFAULT_PROTO_NAME "UNKNOWN"
313 #endif
314 #ifndef DEFAULT_CARD
315 #error "HiSax: No cards configured"
316 #endif
317
318 int hisax_init_pcmcia(void *, int *, struct IsdnCard *);
319 EXPORT_SYMBOL(hisax_init_pcmcia);
320 EXPORT_SYMBOL(HiSax_closecard);
321
322 #define FIRST_CARD { \
323 DEFAULT_CARD, \
324 DEFAULT_PROTO, \
325 DEFAULT_CFG, \
326 NULL, \
327 }
328
329 #define EMPTY_CARD {0, DEFAULT_PROTO, {0, 0, 0, 0}, NULL}
330
331 struct IsdnCard cards[] =
332 {
333 FIRST_CARD,
334 EMPTY_CARD,
335 EMPTY_CARD,
336 EMPTY_CARD,
337 EMPTY_CARD,
338 EMPTY_CARD,
339 EMPTY_CARD,
340 EMPTY_CARD,
341 };
342
343 static char HiSaxID[64] __devinitdata = { 0, };
344
345 char *HiSax_id __devinitdata = HiSaxID;
346 #ifdef MODULE
347 /* Variables for insmod */
348 static int type[8] __devinitdata = { 0, };
349 static int protocol[8] __devinitdata = { 0, };
350 static int io[8] __devinitdata = { 0, };
351 #undef IO0_IO1
352 #ifdef CONFIG_HISAX_16_3
353 #define IO0_IO1
354 #endif
355 #ifdef CONFIG_HISAX_NICCY
356 #undef IO0_IO1
357 #define IO0_IO1
358 #endif
359 #ifdef IO0_IO1
360 static int io0[8] __devinitdata = { 0, };
361 static int io1[8] __devinitdata = { 0, };
362 #endif
363 static int irq[8] __devinitdata = { 0, };
364 static int mem[8] __devinitdata = { 0, };
365 static char *id __devinitdata = HiSaxID;
366
367 MODULE_AUTHOR("Karsten Keil");
368 MODULE_PARM(type, "1-8i");
369 MODULE_PARM(protocol, "1-8i");
370 MODULE_PARM(io, "1-8i");
371 MODULE_PARM(irq, "1-8i");
372 MODULE_PARM(mem, "1-8i");
373 MODULE_PARM(id, "s");
374 #ifdef IO0_IO1
375 MODULE_PARM(io0, "1-8i");
376 MODULE_PARM(io1, "1-8i");
377 #endif /* IO0_IO1 */
378 #endif /* MODULE */
379
380 int nrcards;
381
382 extern char *l1_revision;
383 extern char *l2_revision;
384 extern char *l3_revision;
385 extern char *lli_revision;
386 extern char *tei_revision;
387
388 char *
389 HiSax_getrev(const char *revision)
390 {
391 char *rev;
392 char *p;
393
394 if ((p = strchr(revision, ':'))) {
395 rev = p + 2;
396 p = strchr(rev, '$');
397 *--p = 0;
398 } else
399 rev = "???";
400 return rev;
401 }
402
403 void __init
404 HiSaxVersion(void)
405 {
406 char tmp[64];
407
408 printk(KERN_INFO "HiSax: Linux Driver for passive ISDN cards\n");
409 #ifdef MODULE
410 printk(KERN_INFO "HiSax: Version 3.5 (module)\n");
411 #else
412 printk(KERN_INFO "HiSax: Version 3.5 (kernel)\n");
413 #endif
414 strcpy(tmp, l1_revision);
415 printk(KERN_INFO "HiSax: Layer1 Revision %s\n", HiSax_getrev(tmp));
416 strcpy(tmp, l2_revision);
417 printk(KERN_INFO "HiSax: Layer2 Revision %s\n", HiSax_getrev(tmp));
418 strcpy(tmp, tei_revision);
419 printk(KERN_INFO "HiSax: TeiMgr Revision %s\n", HiSax_getrev(tmp));
420 strcpy(tmp, l3_revision);
421 printk(KERN_INFO "HiSax: Layer3 Revision %s\n", HiSax_getrev(tmp));
422 strcpy(tmp, lli_revision);
423 printk(KERN_INFO "HiSax: LinkLayer Revision %s\n", HiSax_getrev(tmp));
424 certification_check(1);
425 }
426
427 void
428 HiSax_mod_dec_use_count(void)
429 {
430 MOD_DEC_USE_COUNT;
431 }
432
433 void
434 HiSax_mod_inc_use_count(void)
435 {
436 MOD_INC_USE_COUNT;
437 }
438
439 #ifndef MODULE
440 #define MAX_ARG (HISAX_MAX_CARDS*5)
441 static int __init
442 HiSax_setup(char *line)
443 {
444 int i, j, argc;
445 int ints[MAX_ARG + 1];
446 char *str;
447
448 str = get_options(line, MAX_ARG, ints);
449 argc = ints[0];
450 printk(KERN_DEBUG"HiSax_setup: argc(%d) str(%s)\n", argc, str);
451 i = 0;
452 j = 1;
453 while (argc && (i < HISAX_MAX_CARDS)) {
454 if (argc) {
455 cards[i].typ = ints[j];
456 j++;
457 argc--;
458 }
459 if (argc) {
460 cards[i].protocol = ints[j];
461 j++;
462 argc--;
463 }
464 if (argc) {
465 cards[i].para[0] = ints[j];
466 j++;
467 argc--;
468 }
469 if (argc) {
470 cards[i].para[1] = ints[j];
471 j++;
472 argc--;
473 }
474 if (argc) {
475 cards[i].para[2] = ints[j];
476 j++;
477 argc--;
478 }
479 i++;
480 }
481 if (str && *str) {
482 strcpy(HiSaxID, str);
483 HiSax_id = HiSaxID;
484 } else {
485 strcpy(HiSaxID, "HiSax");
486 HiSax_id = HiSaxID;
487 }
488 return(1);
489 }
490
491 __setup("hisax=", HiSax_setup);
492 #endif /* MODULES */
493
494 #if CARD_TELES0
495 extern int setup_teles0(struct IsdnCard *card);
496 #endif
497
498 #if CARD_TELES3
499 extern int setup_teles3(struct IsdnCard *card);
500 #endif
501
502 #if CARD_S0BOX
503 extern int setup_s0box(struct IsdnCard *card);
504 #endif
505
506 #if CARD_TELESPCI
507 extern int setup_telespci(struct IsdnCard *card);
508 #endif
509
510 #if CARD_AVM_A1
511 extern int setup_avm_a1(struct IsdnCard *card);
512 #endif
513
514 #if CARD_AVM_A1_PCMCIA
515 extern int setup_avm_a1_pcmcia(struct IsdnCard *card);
516 #endif
517
518 #if CARD_FRITZPCI
519 extern int setup_avm_pcipnp(struct IsdnCard *card);
520 #endif
521
522 #if CARD_ELSA
523 extern int setup_elsa(struct IsdnCard *card);
524 #endif
525
526 #if CARD_IX1MICROR2
527 extern int setup_ix1micro(struct IsdnCard *card);
528 #endif
529
530 #if CARD_DIEHLDIVA
531 extern int setup_diva(struct IsdnCard *card);
532 #endif
533
534 #if CARD_ASUSCOM
535 extern int setup_asuscom(struct IsdnCard *card);
536 #endif
537
538 #if CARD_TELEINT
539 extern int setup_TeleInt(struct IsdnCard *card);
540 #endif
541
542 #if CARD_SEDLBAUER
543 extern int setup_sedlbauer(struct IsdnCard *card);
544 #endif
545
546 #if CARD_SPORTSTER
547 extern int setup_sportster(struct IsdnCard *card);
548 #endif
549
550 #if CARD_MIC
551 extern int setup_mic(struct IsdnCard *card);
552 #endif
553
554 #if CARD_NETJET_S
555 extern int setup_netjet_s(struct IsdnCard *card);
556 #endif
557
558 #if CARD_HFCS
559 extern int setup_hfcs(struct IsdnCard *card);
560 #endif
561
562 #if CARD_HFC_PCI
563 extern int setup_hfcpci(struct IsdnCard *card);
564 #endif
565
566 #if CARD_HFC_SX
567 extern int setup_hfcsx(struct IsdnCard *card);
568 #endif
569
570 #if CARD_AMD7930
571 extern int setup_amd7930(struct IsdnCard *card);
572 #endif
573
574 #if CARD_NICCY
575 extern int setup_niccy(struct IsdnCard *card);
576 #endif
577
578 #if CARD_ISURF
579 extern int setup_isurf(struct IsdnCard *card);
580 #endif
581
582 #if CARD_HSTSAPHIR
583 extern int setup_saphir(struct IsdnCard *card);
584 #endif
585
586 #if CARD_TESTEMU
587 extern int setup_testemu(struct IsdnCard *card);
588 #endif
589
590 #if CARD_BKM_A4T
591 extern int setup_bkm_a4t(struct IsdnCard *card);
592 #endif
593
594 #if CARD_SCT_QUADRO
595 extern int setup_sct_quadro(struct IsdnCard *card);
596 #endif
597
598 #if CARD_GAZEL
599 extern int setup_gazel(struct IsdnCard *card);
600 #endif
601
602 #if CARD_W6692
603 extern int setup_w6692(struct IsdnCard *card);
604 #endif
605
606 #if CARD_NETJET_U
607 extern int setup_netjet_u(struct IsdnCard *card);
608 #endif
609
610 /*
611 * Find card with given driverId
612 */
613 static inline struct IsdnCardState
614 *hisax_findcard(int driverid)
615 {
616 int i;
617
618 for (i = 0; i < nrcards; i++)
619 if (cards[i].cs)
620 if (cards[i].cs->myid == driverid)
621 return (cards[i].cs);
622 return (NULL);
623 }
624
625 /*
626 * Find card with given card number
627 */
628 struct IsdnCardState
629 *hisax_get_card(int cardnr)
630 {
631 if ((cardnr <= nrcards) && (cardnr>0))
632 if (cards[cardnr-1].cs)
633 return (cards[cardnr-1].cs);
634 return (NULL);
635 }
636
637 int
638 HiSax_readstatus(u_char * buf, int len, int user, int id, int channel)
639 {
640 int count,cnt;
641 u_char *p = buf;
642 struct IsdnCardState *cs = hisax_findcard(id);
643
644 if (cs) {
645 if (len > HISAX_STATUS_BUFSIZE) {
646 printk(KERN_WARNING "HiSax: status overflow readstat %d/%d\n",
647 len, HISAX_STATUS_BUFSIZE);
648 }
649 count = cs->status_end - cs->status_read +1;
650 if (count >= len)
651 count = len;
652 if (user)
653 copy_to_user(p, cs->status_read, count);
654 else
655 memcpy(p, cs->status_read, count);
656 cs->status_read += count;
657 if (cs->status_read > cs->status_end)
658 cs->status_read = cs->status_buf;
659 p += count;
660 count = len - count;
661 while (count) {
662 if (count > HISAX_STATUS_BUFSIZE)
663 cnt = HISAX_STATUS_BUFSIZE;
664 else
665 cnt = count;
666 if (user)
667 copy_to_user(p, cs->status_read, cnt);
668 else
669 memcpy(p, cs->status_read, cnt);
670 p += cnt;
671 cs->status_read += cnt % HISAX_STATUS_BUFSIZE;
672 count -= cnt;
673 }
674 return len;
675 } else {
676 printk(KERN_ERR
677 "HiSax: if_readstatus called with invalid driverId!\n");
678 return -ENODEV;
679 }
680 }
681
682 inline int
683 jiftime(char *s, long mark)
684 {
685 s += 8;
686
687 *s-- = '\0';
688 *s-- = mark % 10 + '0';
689 mark /= 10;
690 *s-- = mark % 10 + '0';
691 mark /= 10;
692 *s-- = '.';
693 *s-- = mark % 10 + '0';
694 mark /= 10;
695 *s-- = mark % 6 + '0';
696 mark /= 6;
697 *s-- = ':';
698 *s-- = mark % 10 + '0';
699 mark /= 10;
700 *s-- = mark % 10 + '0';
701 return(8);
702 }
703
704 static u_char tmpbuf[HISAX_STATUS_BUFSIZE];
705
706 void
707 VHiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, va_list args)
708 {
709 /* if head == NULL the fmt contains the full info */
710
711 long flags;
712 int count, i;
713 u_char *p;
714 isdn_ctrl ic;
715 int len;
716
717 save_flags(flags);
718 cli();
719 p = tmpbuf;
720 if (head) {
721 p += jiftime(p, jiffies);
722 p += sprintf(p, " %s", head);
723 p += vsprintf(p, fmt, args);
724 *p++ = '\n';
725 *p = 0;
726 len = p - tmpbuf;
727 p = tmpbuf;
728 } else {
729 p = fmt;
730 len = strlen(fmt);
731 }
732 if (!cs) {
733 printk(KERN_WARNING "HiSax: No CardStatus for message %s", p);
734 restore_flags(flags);
735 return;
736 }
737 if (len > HISAX_STATUS_BUFSIZE) {
738 printk(KERN_WARNING "HiSax: status overflow %d/%d\n",
739 len, HISAX_STATUS_BUFSIZE);
740 restore_flags(flags);
741 return;
742 }
743 count = len;
744 i = cs->status_end - cs->status_write +1;
745 if (i >= len)
746 i = len;
747 len -= i;
748 memcpy(cs->status_write, p, i);
749 cs->status_write += i;
750 if (cs->status_write > cs->status_end)
751 cs->status_write = cs->status_buf;
752 p += i;
753 if (len) {
754 memcpy(cs->status_write, p, len);
755 cs->status_write += len;
756 }
757 #ifdef KERNELSTACK_DEBUG
758 i = (ulong)&len - current->kernel_stack_page;
759 sprintf(tmpbuf, "kstack %s %lx use %ld\n", current->comm,
760 current->kernel_stack_page, i);
761 len = strlen(tmpbuf);
762 for (p = tmpbuf, i = len; i > 0; i--, p++) {
763 *cs->status_write++ = *p;
764 if (cs->status_write > cs->status_end)
765 cs->status_write = cs->status_buf;
766 count++;
767 }
768 #endif
769 restore_flags(flags);
770 if (count) {
771 ic.command = ISDN_STAT_STAVAIL;
772 ic.driver = cs->myid;
773 ic.arg = count;
774 cs->iif.statcallb(&ic);
775 }
776 }
777
778 void
779 HiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, ...)
780 {
781 va_list args;
782
783 va_start(args, fmt);
784 VHiSax_putstatus(cs, head, fmt, args);
785 va_end(args);
786 }
787
788 int
789 ll_run(struct IsdnCardState *cs, int addfeatures)
790 {
791 long flags;
792 isdn_ctrl ic;
793
794 save_flags(flags);
795 cli();
796 ic.driver = cs->myid;
797 ic.command = ISDN_STAT_RUN;
798 cs->iif.features |= addfeatures;
799 cs->iif.statcallb(&ic);
800 restore_flags(flags);
801 return 0;
802 }
803
804 void
805 ll_stop(struct IsdnCardState *cs)
806 {
807 isdn_ctrl ic;
808
809 ic.command = ISDN_STAT_STOP;
810 ic.driver = cs->myid;
811 cs->iif.statcallb(&ic);
812 // CallcFreeChan(cs);
813 }
814
815 static void
816 ll_unload(struct IsdnCardState *cs)
817 {
818 isdn_ctrl ic;
819
820 ic.command = ISDN_STAT_UNLOAD;
821 ic.driver = cs->myid;
822 cs->iif.statcallb(&ic);
823 if (cs->status_buf)
824 kfree(cs->status_buf);
825 cs->status_read = NULL;
826 cs->status_write = NULL;
827 cs->status_end = NULL;
828 kfree(cs->dlog);
829 }
830
831 static void
832 closecard(int cardnr)
833 {
834 struct IsdnCardState *csta = cards[cardnr].cs;
835
836 if (csta->bcs->BC_Close != NULL) {
837 csta->bcs->BC_Close(csta->bcs + 1);
838 csta->bcs->BC_Close(csta->bcs);
839 }
840
841 discard_queue(&csta->rq);
842 discard_queue(&csta->sq);
843 if (csta->rcvbuf) {
844 kfree(csta->rcvbuf);
845 csta->rcvbuf = NULL;
846 }
847 if (csta->tx_skb) {
848 dev_kfree_skb(csta->tx_skb);
849 csta->tx_skb = NULL;
850 }
851 if (csta->DC_Close != NULL) {
852 csta->DC_Close(csta);
853 }
854 csta->cardmsg(csta, CARD_RELEASE, NULL);
855 if (csta->dbusytimer.function != NULL)
856 del_timer(&csta->dbusytimer);
857 ll_unload(csta);
858 }
859
860 static int __devinit
861 init_card(struct IsdnCardState *cs)
862 {
863 int irq_cnt, cnt = 3;
864 long flags;
865
866 if (!cs->irq)
867 return(cs->cardmsg(cs, CARD_INIT, NULL));
868 save_flags(flags);
869 cli();
870 irq_cnt = kstat_irqs(cs->irq);
871 printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ], cs->irq,
872 irq_cnt);
873 if (request_irq(cs->irq, cs->irq_func, cs->irq_flags, "HiSax", cs)) {
874 printk(KERN_WARNING "HiSax: couldn't get interrupt %d\n",
875 cs->irq);
876 restore_flags(flags);
877 return(1);
878 }
879 while (cnt) {
880 cs->cardmsg(cs, CARD_INIT, NULL);
881 sti();
882 set_current_state(TASK_UNINTERRUPTIBLE);
883 /* Timeout 10ms */
884 schedule_timeout((10*HZ)/1000);
885 restore_flags(flags);
886 printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ],
887 cs->irq, kstat_irqs(cs->irq));
888 if (kstat_irqs(cs->irq) == irq_cnt) {
889 printk(KERN_WARNING
890 "%s: IRQ(%d) getting no interrupts during init %d\n",
891 CardType[cs->typ], cs->irq, 4 - cnt);
892 if (cnt == 1) {
893 free_irq(cs->irq, cs);
894 return (2);
895 } else {
896 cs->cardmsg(cs, CARD_RESET, NULL);
897 cnt--;
898 }
899 } else {
900 cs->cardmsg(cs, CARD_TEST, NULL);
901 return(0);
902 }
903 }
904 restore_flags(flags);
905 return(3);
906 }
907
908 static int __devinit
909 checkcard(int cardnr, char *id, int *busy_flag)
910 {
911 long flags;
912 int ret = 0;
913 struct IsdnCard *card = cards + cardnr;
914 struct IsdnCardState *cs;
915
916 save_flags(flags);
917 cli();
918 if (!(cs = (struct IsdnCardState *)
919 kmalloc(sizeof(struct IsdnCardState), GFP_ATOMIC))) {
920 printk(KERN_WARNING
921 "HiSax: No memory for IsdnCardState(card %d)\n",
922 cardnr + 1);
923 restore_flags(flags);
924 return (0);
925 }
926 memset(cs, 0, sizeof(struct IsdnCardState));
927 card->cs = cs;
928 cs->chanlimit = 2; /* maximum B-channel number */
929 cs->logecho = 0; /* No echo logging */
930 cs->cardnr = cardnr;
931 cs->debug = L1_DEB_WARN;
932 cs->HW_Flags = 0;
933 cs->busy_flag = busy_flag;
934 cs->irq_flags = I4L_IRQ_FLAG;
935 #if TEI_PER_CARD
936 if (card->protocol == ISDN_PTYPE_NI1)
937 test_and_set_bit(FLG_TWO_DCHAN, &cs->HW_Flags);
938 #else
939 test_and_set_bit(FLG_TWO_DCHAN, &cs->HW_Flags);
940 #endif
941 cs->protocol = card->protocol;
942
943 if ((card->typ > 0) && (card->typ <= ISDN_CTYPE_COUNT)) {
944 if (!(cs->dlog = kmalloc(MAX_DLOG_SPACE, GFP_ATOMIC))) {
945 printk(KERN_WARNING
946 "HiSax: No memory for dlog(card %d)\n",
947 cardnr + 1);
948 restore_flags(flags);
949 return (0);
950 }
951 if (!(cs->status_buf = kmalloc(HISAX_STATUS_BUFSIZE, GFP_ATOMIC))) {
952 printk(KERN_WARNING
953 "HiSax: No memory for status_buf(card %d)\n",
954 cardnr + 1);
955 kfree(cs->dlog);
956 restore_flags(flags);
957 return (0);
958 }
959 cs->stlist = NULL;
960 cs->status_read = cs->status_buf;
961 cs->status_write = cs->status_buf;
962 cs->status_end = cs->status_buf + HISAX_STATUS_BUFSIZE - 1;
963 cs->typ = card->typ;
964 strcpy(cs->iif.id, id);
965 cs->iif.channels = 2;
966 cs->iif.maxbufsize = MAX_DATA_SIZE;
967 cs->iif.hl_hdrlen = MAX_HEADER_LEN;
968 cs->iif.features =
969 ISDN_FEATURE_L2_X75I |
970 ISDN_FEATURE_L2_HDLC |
971 ISDN_FEATURE_L2_HDLC_56K |
972 ISDN_FEATURE_L2_TRANS |
973 ISDN_FEATURE_L3_TRANS |
974 #ifdef CONFIG_HISAX_1TR6
975 ISDN_FEATURE_P_1TR6 |
976 #endif
977 #ifdef CONFIG_HISAX_EURO
978 ISDN_FEATURE_P_EURO |
979 #endif
980 #ifdef CONFIG_HISAX_NI1
981 ISDN_FEATURE_P_NI1 |
982 #endif
983 0;
984
985 cs->iif.command = HiSax_command;
986 cs->iif.writecmd = NULL;
987 cs->iif.writebuf_skb = HiSax_writebuf_skb;
988 cs->iif.readstat = HiSax_readstatus;
989 register_isdn(&cs->iif);
990 cs->myid = cs->iif.channels;
991 printk(KERN_INFO
992 "HiSax: Card %d Protocol %s Id=%s (%d)\n", cardnr + 1,
993 (card->protocol == ISDN_PTYPE_1TR6) ? "1TR6" :
994 (card->protocol == ISDN_PTYPE_EURO) ? "EDSS1" :
995 (card->protocol == ISDN_PTYPE_LEASED) ? "LEASED" :
996 (card->protocol == ISDN_PTYPE_NI1) ? "NI1" :
997 "NONE", cs->iif.id, cs->myid);
998 switch (card->typ) {
999 #if CARD_TELES0
1000 case ISDN_CTYPE_16_0:
1001 case ISDN_CTYPE_8_0:
1002 ret = setup_teles0(card);
1003 break;
1004 #endif
1005 #if CARD_TELES3
1006 case ISDN_CTYPE_16_3:
1007 case ISDN_CTYPE_PNP:
1008 case ISDN_CTYPE_TELESPCMCIA:
1009 case ISDN_CTYPE_COMPAQ_ISA:
1010 ret = setup_teles3(card);
1011 break;
1012 #endif
1013 #if CARD_S0BOX
1014 case ISDN_CTYPE_S0BOX:
1015 ret = setup_s0box(card);
1016 break;
1017 #endif
1018 #if CARD_TELESPCI
1019 case ISDN_CTYPE_TELESPCI:
1020 ret = setup_telespci(card);
1021 break;
1022 #endif
1023 #if CARD_AVM_A1
1024 case ISDN_CTYPE_A1:
1025 ret = setup_avm_a1(card);
1026 break;
1027 #endif
1028 #if CARD_AVM_A1_PCMCIA
1029 case ISDN_CTYPE_A1_PCMCIA:
1030 ret = setup_avm_a1_pcmcia(card);
1031 break;
1032 #endif
1033 #if CARD_FRITZPCI
1034 case ISDN_CTYPE_FRITZPCI:
1035 ret = setup_avm_pcipnp(card);
1036 break;
1037 #endif
1038 #if CARD_ELSA
1039 case ISDN_CTYPE_ELSA:
1040 case ISDN_CTYPE_ELSA_PNP:
1041 case ISDN_CTYPE_ELSA_PCMCIA:
1042 case ISDN_CTYPE_ELSA_PCI:
1043 ret = setup_elsa(card);
1044 break;
1045 #endif
1046 #if CARD_IX1MICROR2
1047 case ISDN_CTYPE_IX1MICROR2:
1048 ret = setup_ix1micro(card);
1049 break;
1050 #endif
1051 #if CARD_DIEHLDIVA
1052 case ISDN_CTYPE_DIEHLDIVA:
1053 ret = setup_diva(card);
1054 break;
1055 #endif
1056 #if CARD_ASUSCOM
1057 case ISDN_CTYPE_ASUSCOM:
1058 ret = setup_asuscom(card);
1059 break;
1060 #endif
1061 #if CARD_TELEINT
1062 case ISDN_CTYPE_TELEINT:
1063 ret = setup_TeleInt(card);
1064 break;
1065 #endif
1066 #if CARD_SEDLBAUER
1067 case ISDN_CTYPE_SEDLBAUER:
1068 case ISDN_CTYPE_SEDLBAUER_PCMCIA:
1069 case ISDN_CTYPE_SEDLBAUER_FAX:
1070 ret = setup_sedlbauer(card);
1071 break;
1072 #endif
1073 #if CARD_SPORTSTER
1074 case ISDN_CTYPE_SPORTSTER:
1075 ret = setup_sportster(card);
1076 break;
1077 #endif
1078 #if CARD_MIC
1079 case ISDN_CTYPE_MIC:
1080 ret = setup_mic(card);
1081 break;
1082 #endif
1083 #if CARD_NETJET_S
1084 case ISDN_CTYPE_NETJET_S:
1085 ret = setup_netjet_s(card);
1086 break;
1087 #endif
1088 #if CARD_HFCS
1089 case ISDN_CTYPE_TELES3C:
1090 case ISDN_CTYPE_ACERP10:
1091 ret = setup_hfcs(card);
1092 break;
1093 #endif
1094 #if CARD_HFC_PCI
1095 case ISDN_CTYPE_HFC_PCI:
1096 ret = setup_hfcpci(card);
1097 break;
1098 #endif
1099 #if CARD_HFC_SX
1100 case ISDN_CTYPE_HFC_SX:
1101 ret = setup_hfcsx(card);
1102 break;
1103 #endif
1104 #if CARD_NICCY
1105 case ISDN_CTYPE_NICCY:
1106 ret = setup_niccy(card);
1107 break;
1108 #endif
1109 #if CARD_AMD7930
1110 case ISDN_CTYPE_AMD7930:
1111 ret = setup_amd7930(card);
1112 break;
1113 #endif
1114 #if CARD_ISURF
1115 case ISDN_CTYPE_ISURF:
1116 ret = setup_isurf(card);
1117 break;
1118 #endif
1119 #if CARD_HSTSAPHIR
1120 case ISDN_CTYPE_HSTSAPHIR:
1121 ret = setup_saphir(card);
1122 break;
1123 #endif
1124 #if CARD_TESTEMU
1125 case ISDN_CTYPE_TESTEMU:
1126 ret = setup_testemu(card);
1127 break;
1128 #endif
1129 #if CARD_BKM_A4T
1130 case ISDN_CTYPE_BKM_A4T:
1131 ret = setup_bkm_a4t(card);
1132 break;
1133 #endif
1134 #if CARD_SCT_QUADRO
1135 case ISDN_CTYPE_SCT_QUADRO:
1136 ret = setup_sct_quadro(card);
1137 break;
1138 #endif
1139 #if CARD_GAZEL
1140 case ISDN_CTYPE_GAZEL:
1141 ret = setup_gazel(card);
1142 break;
1143 #endif
1144 #if CARD_W6692
1145 case ISDN_CTYPE_W6692:
1146 ret = setup_w6692(card);
1147 break;
1148 #endif
1149 #if CARD_NETJET_U
1150 case ISDN_CTYPE_NETJET_U:
1151 ret = setup_netjet_u(card);
1152 break;
1153 #endif
1154 default:
1155 printk(KERN_WARNING
1156 "HiSax: Support for %s Card not selected\n",
1157 CardType[card->typ]);
1158 ll_unload(cs);
1159 restore_flags(flags);
1160 return (0);
1161 }
1162 } else {
1163 printk(KERN_WARNING
1164 "HiSax: Card Type %d out of range\n",
1165 card->typ);
1166 restore_flags(flags);
1167 return (0);
1168 }
1169 if (!ret) {
1170 ll_unload(cs);
1171 restore_flags(flags);
1172 return (0);
1173 }
1174 if (!(cs->rcvbuf = kmalloc(MAX_DFRAME_LEN_L1, GFP_ATOMIC))) {
1175 printk(KERN_WARNING
1176 "HiSax: No memory for isac rcvbuf\n");
1177 return (1);
1178 }
1179 cs->rcvidx = 0;
1180 cs->tx_skb = NULL;
1181 cs->tx_cnt = 0;
1182 cs->event = 0;
1183 cs->tqueue.next = 0;
1184 cs->tqueue.sync = 0;
1185 cs->tqueue.data = cs;
1186
1187 skb_queue_head_init(&cs->rq);
1188 skb_queue_head_init(&cs->sq);
1189
1190 init_bcstate(cs, 0);
1191 init_bcstate(cs, 1);
1192 ret = init_card(cs);
1193 if (ret) {
1194 closecard(cardnr);
1195 restore_flags(flags);
1196 return (0);
1197 }
1198 init_tei(cs, cs->protocol);
1199 CallcNewChan(cs);
1200 /* ISAR needs firmware download first */
1201 if (!test_bit(HW_ISAR, &cs->HW_Flags))
1202 ll_run(cs, 0);
1203 restore_flags(flags);
1204 return (1);
1205 }
1206
1207 void __devinit
1208 HiSax_shiftcards(int idx)
1209 {
1210 int i;
1211
1212 for (i = idx; i < (HISAX_MAX_CARDS - 1); i++)
1213 memcpy(&cards[i], &cards[i + 1], sizeof(cards[i]));
1214 }
1215
1216 int __devinit
1217 HiSax_inithardware(int *busy_flag)
1218 {
1219 int foundcards = 0;
1220 int i = 0;
1221 int t = ',';
1222 int flg = 0;
1223 char *id;
1224 char *next_id = HiSax_id;
1225 char ids[20];
1226
1227 if (strchr(HiSax_id, ','))
1228 t = ',';
1229 else if (strchr(HiSax_id, '%'))
1230 t = '%';
1231
1232 while (i < nrcards) {
1233 if (cards[i].typ < 1)
1234 break;
1235 id = next_id;
1236 if ((next_id = strchr(id, t))) {
1237 *next_id++ = 0;
1238 strcpy(ids, id);
1239 flg = i + 1;
1240 } else {
1241 next_id = id;
1242 if (flg >= i)
1243 strcpy(ids, id);
1244 else
1245 sprintf(ids, "%s%d", id, i);
1246 }
1247 if (checkcard(i, ids, busy_flag)) {
1248 foundcards++;
1249 i++;
1250 } else {
1251 printk(KERN_WARNING "HiSax: Card %s not installed !\n",
1252 CardType[cards[i].typ]);
1253 if (cards[i].cs)
1254 kfree((void *) cards[i].cs);
1255 cards[i].cs = NULL;
1256 HiSax_shiftcards(i);
1257 nrcards--;
1258 }
1259 }
1260 return foundcards;
1261 }
1262
1263 void
1264 HiSax_closecard(int cardnr)
1265 {
1266 int i,last=nrcards - 1;
1267
1268 if (cardnr>last)
1269 return;
1270 if (cards[cardnr].cs) {
1271 ll_stop(cards[cardnr].cs);
1272 release_tei(cards[cardnr].cs);
1273
1274 CallcFreeChan(cards[cardnr].cs);
1275
1276 closecard(cardnr);
1277 if (cards[cardnr].cs->irq)
1278 free_irq(cards[cardnr].cs->irq, cards[cardnr].cs);
1279 kfree((void *) cards[cardnr].cs);
1280 cards[cardnr].cs = NULL;
1281 }
1282 i = cardnr;
1283 while (i!=last) {
1284 cards[i] = cards[i+1];
1285 i++;
1286 }
1287 nrcards--;
1288 }
1289
1290 void
1291 HiSax_reportcard(int cardnr, int sel)
1292 {
1293 struct IsdnCardState *cs = cards[cardnr].cs;
1294
1295 printk(KERN_DEBUG "HiSax: reportcard No %d\n", cardnr + 1);
1296 printk(KERN_DEBUG "HiSax: Type %s\n", CardType[cs->typ]);
1297 printk(KERN_DEBUG "HiSax: debuglevel %x\n", cs->debug);
1298 printk(KERN_DEBUG "HiSax: HiSax_reportcard address 0x%lX\n",
1299 (ulong) & HiSax_reportcard);
1300 printk(KERN_DEBUG "HiSax: cs 0x%lX\n", (ulong) cs);
1301 printk(KERN_DEBUG "HiSax: HW_Flags %x bc0 flg %x bc1 flg %x\n",
1302 cs->HW_Flags, cs->bcs[0].Flag, cs->bcs[1].Flag);
1303 printk(KERN_DEBUG "HiSax: bcs 0 mode %d ch%d\n",
1304 cs->bcs[0].mode, cs->bcs[0].channel);
1305 printk(KERN_DEBUG "HiSax: bcs 1 mode %d ch%d\n",
1306 cs->bcs[1].mode, cs->bcs[1].channel);
1307 #ifdef ERROR_STATISTIC
1308 printk(KERN_DEBUG "HiSax: dc errors(rx,crc,tx) %d,%d,%d\n",
1309 cs->err_rx, cs->err_crc, cs->err_tx);
1310 printk(KERN_DEBUG "HiSax: bc0 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1311 cs->bcs[0].err_inv, cs->bcs[0].err_rdo, cs->bcs[0].err_crc, cs->bcs[0].err_tx);
1312 printk(KERN_DEBUG "HiSax: bc1 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n",
1313 cs->bcs[1].err_inv, cs->bcs[1].err_rdo, cs->bcs[1].err_crc, cs->bcs[1].err_tx);
1314 if (sel == 99) {
1315 cs->err_rx = 0;
1316 cs->err_crc = 0;
1317 cs->err_tx = 0;
1318 cs->bcs[0].err_inv = 0;
1319 cs->bcs[0].err_rdo = 0;
1320 cs->bcs[0].err_crc = 0;
1321 cs->bcs[0].err_tx = 0;
1322 cs->bcs[1].err_inv = 0;
1323 cs->bcs[1].err_rdo = 0;
1324 cs->bcs[1].err_crc = 0;
1325 cs->bcs[1].err_tx = 0;
1326 }
1327 #endif
1328 }
1329
1330 int __init
1331 HiSax_init(void)
1332 {
1333 int i,j;
1334 int nzproto = 0;
1335
1336 HiSaxVersion();
1337 CallcNew();
1338 Isdnl3New();
1339 Isdnl2New();
1340 TeiNew();
1341 Isdnl1New();
1342
1343 #ifdef MODULE
1344 if (!type[0]) {
1345 /* We 'll register drivers later, but init basic functions*/
1346 return 0;
1347 }
1348 #ifdef CONFIG_HISAX_ELSA
1349 if (type[0] == ISDN_CTYPE_ELSA_PCMCIA) {
1350 /* we have exported and return in this case */
1351 return 0;
1352 }
1353 #endif
1354 #ifdef CONFIG_HISAX_SEDLBAUER
1355 if (type[0] == ISDN_CTYPE_SEDLBAUER_PCMCIA) {
1356 /* we have to export and return in this case */
1357 return 0;
1358 }
1359 #endif
1360 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
1361 if (type[0] == ISDN_CTYPE_A1_PCMCIA) {
1362 /* we have to export and return in this case */
1363 return 0;
1364 }
1365 #endif
1366 #ifdef CONFIG_HISAX_HFC_SX
1367 if (type[0] == ISDN_CTYPE_HFC_SP_PCMCIA) {
1368 /* we have to export and return in this case */
1369 return 0;
1370 }
1371 #endif
1372 #endif
1373 nrcards = 0;
1374 #ifdef MODULE
1375 if (id) /* If id= string used */
1376 HiSax_id = id;
1377 for (i = j = 0; j < HISAX_MAX_CARDS; i++) {
1378 cards[j].typ = type[i];
1379 if (protocol[i]) {
1380 cards[j].protocol = protocol[i];
1381 nzproto++;
1382 }
1383 switch (type[i]) {
1384 case ISDN_CTYPE_16_0:
1385 cards[j].para[0] = irq[i];
1386 cards[j].para[1] = mem[i];
1387 cards[j].para[2] = io[i];
1388 break;
1389
1390 case ISDN_CTYPE_8_0:
1391 cards[j].para[0] = irq[i];
1392 cards[j].para[1] = mem[i];
1393 break;
1394
1395 #ifdef IO0_IO1
1396 case ISDN_CTYPE_PNP:
1397 case ISDN_CTYPE_NICCY:
1398 cards[j].para[0] = irq[i];
1399 cards[j].para[1] = io0[i];
1400 cards[j].para[2] = io1[i];
1401 break;
1402 case ISDN_CTYPE_COMPAQ_ISA:
1403 cards[j].para[0] = irq[i];
1404 cards[j].para[1] = io0[i];
1405 cards[j].para[2] = io1[i];
1406 cards[j].para[3] = io[i];
1407 break;
1408 #endif
1409 case ISDN_CTYPE_ELSA:
1410 case ISDN_CTYPE_HFC_PCI:
1411 cards[j].para[0] = io[i];
1412 break;
1413 case ISDN_CTYPE_16_3:
1414 case ISDN_CTYPE_TELESPCMCIA:
1415 case ISDN_CTYPE_A1:
1416 case ISDN_CTYPE_A1_PCMCIA:
1417 case ISDN_CTYPE_ELSA_PNP:
1418 case ISDN_CTYPE_ELSA_PCMCIA:
1419 case ISDN_CTYPE_IX1MICROR2:
1420 case ISDN_CTYPE_DIEHLDIVA:
1421 case ISDN_CTYPE_ASUSCOM:
1422 case ISDN_CTYPE_TELEINT:
1423 case ISDN_CTYPE_SEDLBAUER:
1424 case ISDN_CTYPE_SEDLBAUER_PCMCIA:
1425 case ISDN_CTYPE_SEDLBAUER_FAX:
1426 case ISDN_CTYPE_SPORTSTER:
1427 case ISDN_CTYPE_MIC:
1428 case ISDN_CTYPE_TELES3C:
1429 case ISDN_CTYPE_ACERP10:
1430 case ISDN_CTYPE_S0BOX:
1431 case ISDN_CTYPE_FRITZPCI:
1432 case ISDN_CTYPE_HSTSAPHIR:
1433 case ISDN_CTYPE_GAZEL:
1434 case ISDN_CTYPE_HFC_SX:
1435 case ISDN_CTYPE_HFC_SP_PCMCIA:
1436 cards[j].para[0] = irq[i];
1437 cards[j].para[1] = io[i];
1438 break;
1439 case ISDN_CTYPE_ISURF:
1440 cards[j].para[0] = irq[i];
1441 cards[j].para[1] = io[i];
1442 cards[j].para[2] = mem[i];
1443 break;
1444 case ISDN_CTYPE_ELSA_PCI:
1445 case ISDN_CTYPE_NETJET_S:
1446 case ISDN_CTYPE_AMD7930:
1447 case ISDN_CTYPE_TELESPCI:
1448 case ISDN_CTYPE_W6692:
1449 case ISDN_CTYPE_NETJET_U:
1450 break;
1451 case ISDN_CTYPE_BKM_A4T:
1452 break;
1453 case ISDN_CTYPE_SCT_QUADRO:
1454 if (irq[i]) {
1455 cards[j].para[0] = irq[i];
1456 } else {
1457 /* QUADRO is a 4 BRI card */
1458 cards[j++].para[0] = 1;
1459 cards[j].typ = ISDN_CTYPE_SCT_QUADRO;
1460 cards[j].protocol = protocol[i];
1461 cards[j++].para[0] = 2;
1462 cards[j].typ = ISDN_CTYPE_SCT_QUADRO;
1463 cards[j].protocol = protocol[i];
1464 cards[j++].para[0] = 3;
1465 cards[j].typ = ISDN_CTYPE_SCT_QUADRO;
1466 cards[j].protocol = protocol[i];
1467 cards[j].para[0] = 4;
1468 }
1469 break;
1470 }
1471 j++;
1472 }
1473 if (!nzproto) {
1474 printk(KERN_WARNING "HiSax: Warning - no protocol specified\n");
1475 printk(KERN_WARNING "HiSax: using protocol %s\n", DEFAULT_PROTO_NAME);
1476 }
1477 #endif
1478 if (!HiSax_id)
1479 HiSax_id = HiSaxID;
1480 if (!HiSaxID[0])
1481 strcpy(HiSaxID, "HiSax");
1482 for (i = 0; i < HISAX_MAX_CARDS; i++)
1483 if (cards[i].typ > 0)
1484 nrcards++;
1485 printk(KERN_DEBUG "HiSax: Total %d card%s defined\n",
1486 nrcards, (nrcards > 1) ? "s" : "");
1487
1488 if (HiSax_inithardware(NULL)) {
1489 /* Install only, if at least one card found */
1490 return (0);
1491 } else {
1492 Isdnl1Free();
1493 TeiFree();
1494 Isdnl2Free();
1495 Isdnl3Free();
1496 CallcFree();
1497 return -EIO;
1498 }
1499 }
1500
1501 #ifdef MODULE
1502 int init_module(void) { return HiSax_init(); }
1503
1504 void
1505 cleanup_module(void)
1506 {
1507 int cardnr = nrcards -1;
1508 long flags;
1509
1510 save_flags(flags);
1511 cli();
1512 while(cardnr>=0)
1513 HiSax_closecard(cardnr--);
1514 Isdnl1Free();
1515 TeiFree();
1516 Isdnl2Free();
1517 Isdnl3Free();
1518 CallcFree();
1519 restore_flags(flags);
1520 printk(KERN_INFO "HiSax module removed\n");
1521 }
1522 #endif
1523
1524 #ifdef CONFIG_HISAX_ELSA
1525 int elsa_init_pcmcia(void *pcm_iob, int pcm_irq, int *busy_flag, int prot)
1526 {
1527 #ifdef MODULE
1528 int i;
1529
1530 nrcards = 0;
1531 /* Initialize all structs, even though we only accept
1532 two pcmcia cards
1533 */
1534 for (i = 0; i < HISAX_MAX_CARDS; i++) {
1535 cards[i].para[0] = irq[i];
1536 cards[i].para[1] = io[i];
1537 cards[i].typ = type[i];
1538 if (protocol[i]) {
1539 cards[i].protocol = protocol[i];
1540 }
1541 }
1542 cards[0].para[0] = pcm_irq;
1543 cards[0].para[1] = (int)pcm_iob;
1544 cards[0].protocol = prot;
1545 cards[0].typ = ISDN_CTYPE_ELSA_PCMCIA;
1546
1547 if (!HiSax_id)
1548 HiSax_id = HiSaxID;
1549 if (!HiSaxID[0])
1550 strcpy(HiSaxID, "HiSax");
1551 for (i = 0; i < HISAX_MAX_CARDS; i++)
1552 if (cards[i].typ > 0)
1553 nrcards++;
1554 printk(KERN_DEBUG "HiSax: Total %d card%s defined\n",
1555 nrcards, (nrcards > 1) ? "s" : "");
1556
1557 HiSax_inithardware(busy_flag);
1558 printk(KERN_NOTICE "HiSax: module installed\n");
1559 #endif
1560 return (0);
1561 }
1562 #endif
1563
1564 #ifdef CONFIG_HISAX_HFC_SX
1565 int hfc_init_pcmcia(void *pcm_iob, int pcm_irq, int *busy_flag, int prot)
1566 {
1567 #ifdef MODULE
1568 int i;
1569 int nzproto = 0;
1570
1571 nrcards = 0;
1572 /* Initialize all structs, even though we only accept
1573 two pcmcia cards
1574 */
1575 for (i = 0; i < HISAX_MAX_CARDS; i++) {
1576 cards[i].para[0] = irq[i];
1577 cards[i].para[1] = io[i];
1578 cards[i].typ = type[i];
1579 if (protocol[i]) {
1580 cards[i].protocol = protocol[i];
1581 nzproto++;
1582 }
1583 }
1584 cards[0].para[0] = pcm_irq;
1585 cards[0].para[1] = (int)pcm_iob;
1586 cards[0].protocol = prot;
1587 cards[0].typ = ISDN_CTYPE_HFC_SP_PCMCIA;
1588 nzproto = 1;
1589
1590 if (!HiSax_id)
1591 HiSax_id = HiSaxID;
1592 if (!HiSaxID[0])
1593 strcpy(HiSaxID, "HiSax");
1594 for (i = 0; i < HISAX_MAX_CARDS; i++)
1595 if (cards[i].typ > 0)
1596 nrcards++;
1597 printk(KERN_DEBUG "HiSax: Total %d card%s defined\n",
1598 nrcards, (nrcards > 1) ? "s" : "");
1599
1600 HiSax_inithardware(busy_flag);
1601 printk(KERN_NOTICE "HiSax: module installed\n");
1602 #endif
1603 return (0);
1604 }
1605 #endif
1606
1607 #ifdef CONFIG_HISAX_SEDLBAUER
1608 int sedl_init_pcmcia(void *pcm_iob, int pcm_irq, int *busy_flag, int prot)
1609 {
1610 #ifdef MODULE
1611 int i;
1612 int nzproto = 0;
1613
1614 nrcards = 0;
1615 /* Initialize all structs, even though we only accept
1616 two pcmcia cards
1617 */
1618 for (i = 0; i < HISAX_MAX_CARDS; i++) {
1619 cards[i].para[0] = irq[i];
1620 cards[i].para[1] = io[i];
1621 cards[i].typ = type[i];
1622 if (protocol[i]) {
1623 cards[i].protocol = protocol[i];
1624 nzproto++;
1625 }
1626 }
1627 cards[0].para[0] = pcm_irq;
1628 cards[0].para[1] = (int)pcm_iob;
1629 cards[0].protocol = prot;
1630 cards[0].typ = ISDN_CTYPE_SEDLBAUER_PCMCIA;
1631 nzproto = 1;
1632
1633 if (!HiSax_id)
1634 HiSax_id = HiSaxID;
1635 if (!HiSaxID[0])
1636 strcpy(HiSaxID, "HiSax");
1637 for (i = 0; i < HISAX_MAX_CARDS; i++)
1638 if (cards[i].typ > 0)
1639 nrcards++;
1640 printk(KERN_DEBUG "HiSax: Total %d card%s defined\n",
1641 nrcards, (nrcards > 1) ? "s" : "");
1642
1643 HiSax_inithardware(busy_flag);
1644 printk(KERN_NOTICE "HiSax: module installed\n");
1645 #endif
1646 return (0);
1647 }
1648 #endif
1649
1650 #ifdef CONFIG_HISAX_AVM_A1_PCMCIA
1651 int avm_a1_init_pcmcia(void *pcm_iob, int pcm_irq, int *busy_flag, int prot)
1652 {
1653 #ifdef MODULE
1654 int i;
1655 int nzproto = 0;
1656
1657 nrcards = 0;
1658 /* Initialize all structs, even though we only accept
1659 two pcmcia cards
1660 */
1661 for (i = 0; i < HISAX_MAX_CARDS; i++) {
1662 cards[i].para[0] = irq[i];
1663 cards[i].para[1] = io[i];
1664 cards[i].typ = type[i];
1665 if (protocol[i]) {
1666 cards[i].protocol = protocol[i];
1667 nzproto++;
1668 }
1669 }
1670 cards[0].para[0] = pcm_irq;
1671 cards[0].para[1] = (int)pcm_iob;
1672 cards[0].protocol = prot;
1673 cards[0].typ = ISDN_CTYPE_A1_PCMCIA;
1674 nzproto = 1;
1675
1676 if (!HiSax_id)
1677 HiSax_id = HiSaxID;
1678 if (!HiSaxID[0])
1679 strcpy(HiSaxID, "HiSax");
1680 for (i = 0; i < HISAX_MAX_CARDS; i++)
1681 if (cards[i].typ > 0)
1682 nrcards++;
1683 printk(KERN_DEBUG "HiSax: Total %d card%s defined\n",
1684 nrcards, (nrcards > 1) ? "s" : "");
1685
1686 HiSax_inithardware(busy_flag);
1687 printk(KERN_NOTICE "HiSax: module installed\n");
1688 #endif
1689 return (0);
1690 }
1691 #endif
1692
1693 int __devinit hisax_init_pcmcia(void *pcm_iob, int *busy_flag, struct IsdnCard *card)
1694 {
1695 u_char ids[16];
1696 int ret = -1;
1697
1698 cards[nrcards] = *card;
1699 if (nrcards)
1700 sprintf(ids, "HiSax%d", nrcards);
1701 else
1702 sprintf(ids, "HiSax");
1703 if (!checkcard(nrcards, ids, busy_flag)) {
1704 return(-1);
1705 }
1706 ret = nrcards;
1707 nrcards++;
1708 return (ret);
1709 }
1710
1711 static struct pci_device_id hisax_pci_tbl[] __initdata = {
1712 #ifdef CONFIG_HISAX_FRTIZPCI
1713 {PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_FRITZ, PCI_ANY_ID, PCI_ANY_ID},
1714 #endif
1715 #ifdef CONFIG_HISAX_DIEHLDIVA
1716 {PCI_VENDOR_ID_EICON, PCI_DEVICE_ID_EICON_DIVA20, PCI_ANY_ID, PCI_ANY_ID},
1717 {PCI_VENDOR_ID_EICON, PCI_DEVICE_ID_EICON_DIVA20_U, PCI_ANY_ID, PCI_ANY_ID},
1718 {PCI_VENDOR_ID_EICON, PCI_DEVICE_ID_EICON_DIVA201, PCI_ANY_ID, PCI_ANY_ID},
1719 #endif
1720 #ifdef CONFIG_HISAX_ELSA
1721 {PCI_VENDOR_ID_ELSA, PCI_DEVICE_ID_ELSA_MICROLINK, PCI_ANY_ID, PCI_ANY_ID},
1722 {PCI_VENDOR_ID_ELSA, PCI_DEVICE_ID_ELSA_QS3000, PCI_ANY_ID, PCI_ANY_ID},
1723 #endif
1724 #ifdef CONFIG_HISAX_GAZEL
1725 {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_R685, PCI_ANY_ID, PCI_ANY_ID},
1726 {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_R753, PCI_ANY_ID, PCI_ANY_ID},
1727 {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_DJINN_ITOO, PCI_ANY_ID, PCI_ANY_ID},
1728 #endif
1729 #ifdef CONFIG_HISAX_QUADRO
1730 {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_ANY_ID, PCI_ANY_ID},
1731 #endif
1732 #ifdef CONFIG_HISAX_NICCY
1733 {PCI_VENDOR_ID_SATSAGEM, PCI_DEVICE_ID_SATSAGEM_NICCY, PCI_ANY_ID,PCI_ANY_ID},
1734 #endif
1735 #ifdef CONFIG_HISAX_SEDLBAUER
1736 {PCI_VENDOR_ID_TIGERJET, PCI_DEVICE_ID_TIGERJET_100, PCI_ANY_ID,PCI_ANY_ID},
1737 #endif
1738 #if defined(CONFIG_HISAX_NETJET) || defined(CONFIG_HISAX_NETJET_U)
1739 {PCI_VENDOR_ID_TIGERJET, PCI_DEVICE_ID_TIGERJET_300, PCI_ANY_ID,PCI_ANY_ID},
1740 #endif
1741 #if defined(CONFIG_HISAX_TELESPCI) || defined(CONFIG_HISAX_SCT_QUADRO)
1742 {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, PCI_ANY_ID,PCI_ANY_ID},
1743 #endif
1744 #ifdef CONFIG_HISAX_W6692
1745 {PCI_VENDOR_ID_DYNALINK, PCI_DEVICE_ID_DYNALINK_IS64PH, PCI_ANY_ID,PCI_ANY_ID},
1746 {PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_6692, PCI_ANY_ID,PCI_ANY_ID},
1747 #endif
1748 #ifdef CONFIG_HISAX_HFC_PCI
1749 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_2BD0, PCI_ANY_ID, PCI_ANY_ID},
1750 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B000, PCI_ANY_ID, PCI_ANY_ID},
1751 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B006, PCI_ANY_ID, PCI_ANY_ID},
1752 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B007, PCI_ANY_ID, PCI_ANY_ID},
1753 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B008, PCI_ANY_ID, PCI_ANY_ID},
1754 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B009, PCI_ANY_ID, PCI_ANY_ID},
1755 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00A, PCI_ANY_ID, PCI_ANY_ID},
1756 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00B, PCI_ANY_ID, PCI_ANY_ID},
1757 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00C, PCI_ANY_ID, PCI_ANY_ID},
1758 {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B100, PCI_ANY_ID, PCI_ANY_ID},
1759 {PCI_VENDOR_ID_ASUSTEK, PCI_DEVICE_ID_ASUSTEK_0675, PCI_ANY_ID, PCI_ANY_ID},
1760 {PCI_VENDOR_ID_BERKOM, PCI_DEVICE_ID_BERKOM_T_CONCEPT, PCI_ANY_ID, PCI_ANY_ID},
1761 {PCI_VENDOR_ID_BERKOM, PCI_DEVICE_ID_BERKOM_A1T, PCI_ANY_ID, PCI_ANY_ID},
1762 {PCI_VENDOR_ID_ANIGMA, PCI_DEVICE_ID_ANIGMA_MC145575, PCI_ANY_ID, PCI_ANY_ID},
1763 {PCI_VENDOR_ID_ZOLTRIX, PCI_DEVICE_ID_ZOLTRIX_2BD0, PCI_ANY_ID, PCI_ANY_ID},
1764 {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_IOM2_E, PCI_ANY_ID, PCI_ANY_ID},
1765 {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_E, PCI_ANY_ID, PCI_ANY_ID},
1766 {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_IOM2_A, PCI_ANY_ID, PCI_ANY_ID},
1767 {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_A, PCI_ANY_ID, PCI_ANY_ID},
1768 #endif
1769 { } /* Terminating entry */
1770 };
1771
1772 MODULE_DEVICE_TABLE(pci, hisax_pci_tbl);
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux