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