1/* $Id: module.c,v 1.1.1.1 2007/08/03 18:52:34 Exp $ 2 * 3 * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000. 4 * 5 * Author Fritz Elfert 6 * Copyright by Fritz Elfert <fritz@isdn4linux.de> 7 * 8 * This software may be used and distributed according to the terms 9 * of the GNU General Public License, incorporated herein by reference. 10 * 11 * Thanks to Friedemann Baitinger and IBM Germany 12 * 13 */ 14 15#include "act2000.h" 16#include "act2000_isa.h" 17#include "capi.h" 18#include <linux/module.h> 19#include <linux/init.h> 20 21static unsigned short act2000_isa_ports[] = 22{ 23 0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380, 24 0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60, 25}; 26#define ISA_NRPORTS (sizeof(act2000_isa_ports)/sizeof(unsigned short)) 27 28static act2000_card *cards = (act2000_card *) NULL; 29 30/* Parameters to be set by insmod */ 31static int act_bus = 0; 32static int act_port = -1; /* -1 = Autoprobe */ 33static int act_irq = -1; 34static char *act_id = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; 35 36MODULE_DESCRIPTION( "ISDN4Linux: Driver for IBM Active 2000 ISDN card"); 37MODULE_AUTHOR( "Fritz Elfert"); 38MODULE_LICENSE( "GPL"); 39MODULE_PARM_DESC(act_bus, "BusType of first card, 1=ISA, 2=MCA, 3=PCMCIA, currently only ISA"); 40MODULE_PARM_DESC(membase, "Base port address of first card"); 41MODULE_PARM_DESC(act_irq, "IRQ of first card"); 42MODULE_PARM_DESC(act_id, "ID-String of first card"); 43module_param(act_bus, int, 0); 44module_param(act_port, int, 0); 45module_param(act_irq, int, 0); 46module_param(act_id, charp, 0); 47 48static int act2000_addcard(int, int, int, char *); 49 50static act2000_chan * 51find_channel(act2000_card *card, int channel) 52{ 53 if ((channel >= 0) && (channel < ACT2000_BCH)) 54 return &(card->bch[channel]); 55 printk(KERN_WARNING "act2000: Invalid channel %d\n", channel); 56 return NULL; 57} 58 59/* 60 * Free MSN list 61 */ 62static void 63act2000_clear_msn(act2000_card *card) 64{ 65 struct msn_entry *p = card->msn_list; 66 struct msn_entry *q; 67 unsigned long flags; 68 69 spin_lock_irqsave(&card->lock, flags); 70 card->msn_list = NULL; 71 spin_unlock_irqrestore(&card->lock, flags); 72 while (p) { 73 q = p->next; 74 kfree(p); 75 p = q; 76 } 77} 78 79/* 80 * Find an MSN entry in the list. 81 * If ia5 != 0, return IA5-encoded EAZ, else 82 * return a bitmask with corresponding bit set. 83 */ 84static __u16 85act2000_find_msn(act2000_card *card, char *msn, int ia5) 86{ 87 struct msn_entry *p = card->msn_list; 88 __u8 eaz = '0'; 89 90 while (p) { 91 if (!strcmp(p->msn, msn)) { 92 eaz = p->eaz; 93 break; 94 } 95 p = p->next; 96 } 97 if (!ia5) 98 return (1 << (eaz - '0')); 99 else 100 return eaz; 101} 102 103/* 104 * Find an EAZ entry in the list. 105 * return a string with corresponding msn. 106 */ 107char * 108act2000_find_eaz(act2000_card *card, char eaz) 109{ 110 struct msn_entry *p = card->msn_list; 111 112 while (p) { 113 if (p->eaz == eaz) 114 return(p->msn); 115 p = p->next; 116 } 117 return("\0"); 118} 119 120/* 121 * Add or delete an MSN to the MSN list 122 * 123 * First character of msneaz is EAZ, rest is MSN. 124 * If length of eazmsn is 1, delete that entry. 125 */ 126static int 127act2000_set_msn(act2000_card *card, char *eazmsn) 128{ 129 struct msn_entry *p = card->msn_list; 130 struct msn_entry *q = NULL; 131 unsigned long flags; 132 int i; 133 134 if (!strlen(eazmsn)) 135 return 0; 136 if (strlen(eazmsn) > 16) 137 return -EINVAL; 138 for (i = 0; i < strlen(eazmsn); i++) 139 if (!isdigit(eazmsn[i])) 140 return -EINVAL; 141 if (strlen(eazmsn) == 1) { 142 /* Delete a single MSN */ 143 while (p) { 144 if (p->eaz == eazmsn[0]) { 145 spin_lock_irqsave(&card->lock, flags); 146 if (q) 147 q->next = p->next; 148 else 149 card->msn_list = p->next; 150 spin_unlock_irqrestore(&card->lock, flags); 151 kfree(p); 152 printk(KERN_DEBUG 153 "Mapping for EAZ %c deleted\n", 154 eazmsn[0]); 155 return 0; 156 } 157 q = p; 158 p = p->next; 159 } 160 return 0; 161 } 162 /* Add a single MSN */ 163 while (p) { 164 /* Found in list, replace MSN */ 165 if (p->eaz == eazmsn[0]) { 166 spin_lock_irqsave(&card->lock, flags); 167 strcpy(p->msn, &eazmsn[1]); 168 spin_unlock_irqrestore(&card->lock, flags); 169 printk(KERN_DEBUG 170 "Mapping for EAZ %c changed to %s\n", 171 eazmsn[0], 172 &eazmsn[1]); 173 return 0; 174 } 175 p = p->next; 176 } 177 /* Not found in list, add new entry */ 178 p = kmalloc(sizeof(msn_entry), GFP_KERNEL); 179 if (!p) 180 return -ENOMEM; 181 p->eaz = eazmsn[0]; 182 strcpy(p->msn, &eazmsn[1]); 183 p->next = card->msn_list; 184 spin_lock_irqsave(&card->lock, flags); 185 card->msn_list = p; 186 spin_unlock_irqrestore(&card->lock, flags); 187 printk(KERN_DEBUG 188 "Mapping %c -> %s added\n", 189 eazmsn[0], 190 &eazmsn[1]); 191 return 0; 192} 193 194static void 195act2000_transmit(struct work_struct *work) 196{ 197 struct act2000_card *card = 198 container_of(work, struct act2000_card, snd_tq); 199 200 switch (card->bus) { 201 case ACT2000_BUS_ISA: 202 act2000_isa_send(card); 203 break; 204 case ACT2000_BUS_PCMCIA: 205 case ACT2000_BUS_MCA: 206 default: 207 printk(KERN_WARNING 208 "act2000_transmit: Illegal bustype %d\n", card->bus); 209 } 210} 211 212static void 213act2000_receive(struct work_struct *work) 214{ 215 struct act2000_card *card = 216 container_of(work, struct act2000_card, poll_tq); 217 218 switch (card->bus) { 219 case ACT2000_BUS_ISA: 220 act2000_isa_receive(card); 221 break; 222 case ACT2000_BUS_PCMCIA: 223 case ACT2000_BUS_MCA: 224 default: 225 printk(KERN_WARNING 226 "act2000_receive: Illegal bustype %d\n", card->bus); 227 } 228} 229 230static void 231act2000_poll(unsigned long data) 232{ 233 act2000_card * card = (act2000_card *)data; 234 unsigned long flags; 235 236 act2000_receive(&card->poll_tq); 237 spin_lock_irqsave(&card->lock, flags); 238 mod_timer(&card->ptimer, jiffies+3); 239 spin_unlock_irqrestore(&card->lock, flags); 240} 241 242static int 243act2000_command(act2000_card * card, isdn_ctrl * c) 244{ 245 ulong a; 246 act2000_chan *chan; 247 act2000_cdef cdef; 248 isdn_ctrl cmd; 249 char tmp[17]; 250 int ret; 251 unsigned long flags; 252 void __user *arg; 253 254 switch (c->command) { 255 case ISDN_CMD_IOCTL: 256 memcpy(&a, c->parm.num, sizeof(ulong)); 257 arg = (void __user *)a; 258 switch (c->arg) { 259 case ACT2000_IOCTL_LOADBOOT: 260 switch (card->bus) { 261 case ACT2000_BUS_ISA: 262 ret = act2000_isa_download(card, 263 arg); 264 if (!ret) { 265 card->flags |= ACT2000_FLAGS_LOADED; 266 if (!(card->flags & ACT2000_FLAGS_IVALID)) { 267 card->ptimer.expires = jiffies + 3; 268 card->ptimer.function = act2000_poll; 269 card->ptimer.data = (unsigned long)card; 270 add_timer(&card->ptimer); 271 } 272 actcapi_manufacturer_req_errh(card); 273 } 274 break; 275 default: 276 printk(KERN_WARNING 277 "act2000: Illegal BUS type %d\n", 278 card->bus); 279 ret = -EIO; 280 } 281 return ret; 282 case ACT2000_IOCTL_SETPROTO: 283 card->ptype = a?ISDN_PTYPE_EURO:ISDN_PTYPE_1TR6; 284 if (!(card->flags & ACT2000_FLAGS_RUNNING)) 285 return 0; 286 actcapi_manufacturer_req_net(card); 287 return 0; 288 case ACT2000_IOCTL_SETMSN: 289 if (copy_from_user(tmp, arg, 290 sizeof(tmp))) 291 return -EFAULT; 292 if ((ret = act2000_set_msn(card, tmp))) 293 return ret; 294 if (card->flags & ACT2000_FLAGS_RUNNING) 295 return(actcapi_manufacturer_req_msn(card)); 296 return 0; 297 case ACT2000_IOCTL_ADDCARD: 298 if (copy_from_user(&cdef, arg, 299 sizeof(cdef))) 300 return -EFAULT; 301 if (act2000_addcard(cdef.bus, cdef.port, cdef.irq, cdef.id)) 302 return -EIO; 303 return 0; 304 case ACT2000_IOCTL_TEST: 305 if (!(card->flags & ACT2000_FLAGS_RUNNING)) 306 return -ENODEV; 307 return 0; 308 default: 309 return -EINVAL; 310 } 311 break; 312 case ISDN_CMD_DIAL: 313 if (!card->flags & ACT2000_FLAGS_RUNNING) 314 return -ENODEV; 315 if (!(chan = find_channel(card, c->arg & 0x0f))) 316 break; 317 spin_lock_irqsave(&card->lock, flags); 318 if (chan->fsm_state != ACT2000_STATE_NULL) { 319 spin_unlock_irqrestore(&card->lock, flags); 320 printk(KERN_WARNING "Dial on channel with state %d\n", 321 chan->fsm_state); 322 return -EBUSY; 323 } 324 if (card->ptype == ISDN_PTYPE_EURO) 325 tmp[0] = act2000_find_msn(card, c->parm.setup.eazmsn, 1); 326 else 327 tmp[0] = c->parm.setup.eazmsn[0]; 328 chan->fsm_state = ACT2000_STATE_OCALL; 329 chan->callref = 0xffff; 330 spin_unlock_irqrestore(&card->lock, flags); 331 ret = actcapi_connect_req(card, chan, c->parm.setup.phone, 332 tmp[0], c->parm.setup.si1, 333 c->parm.setup.si2); 334 if (ret) { 335 cmd.driver = card->myid; 336 cmd.command = ISDN_STAT_DHUP; 337 cmd.arg &= 0x0f; 338 card->interface.statcallb(&cmd); 339 } 340 return ret; 341 case ISDN_CMD_ACCEPTD: 342 if (!card->flags & ACT2000_FLAGS_RUNNING) 343 return -ENODEV; 344 if (!(chan = find_channel(card, c->arg & 0x0f))) 345 break; 346 if (chan->fsm_state == ACT2000_STATE_ICALL) 347 actcapi_select_b2_protocol_req(card, chan); 348 return 0; 349 case ISDN_CMD_ACCEPTB: 350 if (!card->flags & ACT2000_FLAGS_RUNNING) 351 return -ENODEV; 352 return 0; 353 case ISDN_CMD_HANGUP: 354 if (!card->flags & ACT2000_FLAGS_RUNNING) 355 return -ENODEV; 356 if (!(chan = find_channel(card, c->arg & 0x0f))) 357 break; 358 switch (chan->fsm_state) { 359 case ACT2000_STATE_ICALL: 360 case ACT2000_STATE_BSETUP: 361 actcapi_connect_resp(card, chan, 0x15); 362 break; 363 case ACT2000_STATE_ACTIVE: 364 actcapi_disconnect_b3_req(card, chan); 365 break; 366 } 367 return 0; 368 case ISDN_CMD_SETEAZ: 369 if (!card->flags & ACT2000_FLAGS_RUNNING) 370 return -ENODEV; 371 if (!(chan = find_channel(card, c->arg & 0x0f))) 372 break; 373 if (strlen(c->parm.num)) { 374 if (card->ptype == ISDN_PTYPE_EURO) { 375 chan->eazmask = act2000_find_msn(card, c->parm.num, 0); 376 } 377 if (card->ptype == ISDN_PTYPE_1TR6) { 378 int i; 379 chan->eazmask = 0; 380 for (i = 0; i < strlen(c->parm.num); i++) 381 if (isdigit(c->parm.num[i])) 382 chan->eazmask |= (1 << (c->parm.num[i] - '0')); 383 } 384 } else 385 chan->eazmask = 0x3ff; 386 actcapi_listen_req(card); 387 return 0; 388 case ISDN_CMD_CLREAZ: 389 if (!card->flags & ACT2000_FLAGS_RUNNING) 390 return -ENODEV; 391 if (!(chan = find_channel(card, c->arg & 0x0f))) 392 break; 393 chan->eazmask = 0; 394 actcapi_listen_req(card); 395 return 0; 396 case ISDN_CMD_SETL2: 397 if (!card->flags & ACT2000_FLAGS_RUNNING) 398 return -ENODEV; 399 if (!(chan = find_channel(card, c->arg & 0x0f))) 400 break; 401 chan->l2prot = (c->arg >> 8); 402 return 0; 403 case ISDN_CMD_SETL3: 404 if (!card->flags & ACT2000_FLAGS_RUNNING) 405 return -ENODEV; 406 if ((c->arg >> 8) != ISDN_PROTO_L3_TRANS) { 407 printk(KERN_WARNING "L3 protocol unknown\n"); 408 return -1; 409 } 410 if (!(chan = find_channel(card, c->arg & 0x0f))) 411 break; 412 chan->l3prot = (c->arg >> 8); 413 return 0; 414 } 415 416 return -EINVAL; 417} 418 419static int 420act2000_sendbuf(act2000_card *card, int channel, int ack, struct sk_buff *skb) 421{ 422 struct sk_buff *xmit_skb; 423 int len; 424 act2000_chan *chan; 425 actcapi_msg *msg; 426 427 if (!(chan = find_channel(card, channel))) 428 return -1; 429 if (chan->fsm_state != ACT2000_STATE_ACTIVE) 430 return -1; 431 len = skb->len; 432 if ((chan->queued + len) >= ACT2000_MAX_QUEUED) 433 return 0; 434 if (!len) 435 return 0; 436 if (skb_headroom(skb) < 19) { 437 printk(KERN_WARNING "act2000_sendbuf: Headroom only %d\n", 438 skb_headroom(skb)); 439 xmit_skb = alloc_skb(len + 19, GFP_ATOMIC); 440 if (!xmit_skb) { 441 printk(KERN_WARNING "act2000_sendbuf: Out of memory\n"); 442 return 0; 443 } 444 skb_reserve(xmit_skb, 19); 445 skb_copy_from_linear_data(skb, skb_put(xmit_skb, len), len); 446 } else { 447 xmit_skb = skb_clone(skb, GFP_ATOMIC); 448 if (!xmit_skb) { 449 printk(KERN_WARNING "act2000_sendbuf: Out of memory\n"); 450 return 0; 451 } 452 } 453 dev_kfree_skb(skb); 454 msg = (actcapi_msg *)skb_push(xmit_skb, 19); 455 msg->hdr.len = 19 + len; 456 msg->hdr.applicationID = 1; 457 msg->hdr.cmd.cmd = 0x86; 458 msg->hdr.cmd.subcmd = 0x00; 459 msg->hdr.msgnum = actcapi_nextsmsg(card); 460 msg->msg.data_b3_req.datalen = len; 461 msg->msg.data_b3_req.blocknr = (msg->hdr.msgnum & 0xff); 462 msg->msg.data_b3_req.fakencci = MAKE_NCCI(chan->plci, 0, chan->ncci); 463 msg->msg.data_b3_req.flags = ack; /* Will be set to 0 on actual sending */ 464 actcapi_debug_msg(xmit_skb, 1); 465 chan->queued += len; 466 skb_queue_tail(&card->sndq, xmit_skb); 467 act2000_schedule_tx(card); 468 return len; 469} 470 471 472/* Read the Status-replies from the Interface */ 473static int 474act2000_readstatus(u_char __user * buf, int len, act2000_card * card) 475{ 476 int count; 477 u_char __user *p; 478 479 for (p = buf, count = 0; count < len; p++, count++) { 480 if (card->status_buf_read == card->status_buf_write) 481 return count; 482 put_user(*card->status_buf_read++, p); 483 if (card->status_buf_read > card->status_buf_end) 484 card->status_buf_read = card->status_buf; 485 } 486 return count; 487} 488 489/* 490 * Find card with given driverId 491 */ 492static inline act2000_card * 493act2000_findcard(int driverid) 494{ 495 act2000_card *p = cards; 496 497 while (p) { 498 if (p->myid == driverid) 499 return p; 500 p = p->next; 501 } 502 return (act2000_card *) 0; 503} 504 505/* 506 * Wrapper functions for interface to linklevel 507 */ 508static int 509if_command(isdn_ctrl * c) 510{ 511 act2000_card *card = act2000_findcard(c->driver); 512 513 if (card) 514 return (act2000_command(card, c)); 515 printk(KERN_ERR 516 "act2000: if_command %d called with invalid driverId %d!\n", 517 c->command, c->driver); 518 return -ENODEV; 519} 520 521static int 522if_writecmd(const u_char __user *buf, int len, int id, int channel) 523{ 524 act2000_card *card = act2000_findcard(id); 525 526 if (card) { 527 if (!card->flags & ACT2000_FLAGS_RUNNING) 528 return -ENODEV; 529 return (len); 530 } 531 printk(KERN_ERR 532 "act2000: if_writecmd called with invalid driverId!\n"); 533 return -ENODEV; 534} 535 536static int 537if_readstatus(u_char __user * buf, int len, int id, int channel) 538{ 539 act2000_card *card = act2000_findcard(id); 540 541 if (card) { 542 if (!card->flags & ACT2000_FLAGS_RUNNING) 543 return -ENODEV; 544 return (act2000_readstatus(buf, len, card)); 545 } 546 printk(KERN_ERR 547 "act2000: if_readstatus called with invalid driverId!\n"); 548 return -ENODEV; 549} 550 551static int 552if_sendbuf(int id, int channel, int ack, struct sk_buff *skb) 553{ 554 act2000_card *card = act2000_findcard(id); 555 556 if (card) { 557 if (!card->flags & ACT2000_FLAGS_RUNNING) 558 return -ENODEV; 559 return (act2000_sendbuf(card, channel, ack, skb)); 560 } 561 printk(KERN_ERR 562 "act2000: if_sendbuf called with invalid driverId!\n"); 563 return -ENODEV; 564} 565 566 567/* 568 * Allocate a new card-struct, initialize it 569 * link it into cards-list. 570 */ 571static void 572act2000_alloccard(int bus, int port, int irq, char *id) 573{ 574 int i; 575 act2000_card *card; 576 if (!(card = kzalloc(sizeof(act2000_card), GFP_KERNEL))) { 577 printk(KERN_WARNING 578 "act2000: (%s) Could not allocate card-struct.\n", id); 579 return; 580 } 581 spin_lock_init(&card->lock); 582 spin_lock_init(&card->mnlock); 583 skb_queue_head_init(&card->sndq); 584 skb_queue_head_init(&card->rcvq); 585 skb_queue_head_init(&card->ackq); 586 INIT_WORK(&card->snd_tq, act2000_transmit); 587 INIT_WORK(&card->rcv_tq, actcapi_dispatch); 588 INIT_WORK(&card->poll_tq, act2000_receive); 589 init_timer(&card->ptimer); 590 card->interface.owner = THIS_MODULE; 591 card->interface.channels = ACT2000_BCH; 592 card->interface.maxbufsize = 4000; 593 card->interface.command = if_command; 594 card->interface.writebuf_skb = if_sendbuf; 595 card->interface.writecmd = if_writecmd; 596 card->interface.readstat = if_readstatus; 597 card->interface.features = 598 ISDN_FEATURE_L2_X75I | 599 ISDN_FEATURE_L2_HDLC | 600 ISDN_FEATURE_L3_TRANS | 601 ISDN_FEATURE_P_UNKNOWN; 602 card->interface.hl_hdrlen = 20; 603 card->ptype = ISDN_PTYPE_EURO; 604 strlcpy(card->interface.id, id, sizeof(card->interface.id)); 605 for (i=0; i<ACT2000_BCH; i++) { 606 card->bch[i].plci = 0x8000; 607 card->bch[i].ncci = 0x8000; 608 card->bch[i].l2prot = ISDN_PROTO_L2_X75I; 609 card->bch[i].l3prot = ISDN_PROTO_L3_TRANS; 610 } 611 card->myid = -1; 612 card->bus = bus; 613 card->port = port; 614 card->irq = irq; 615 card->next = cards; 616 cards = card; 617} 618 619/* 620 * register card at linklevel 621 */ 622static int 623act2000_registercard(act2000_card * card) 624{ 625 switch (card->bus) { 626 case ACT2000_BUS_ISA: 627 break; 628 case ACT2000_BUS_MCA: 629 case ACT2000_BUS_PCMCIA: 630 default: 631 printk(KERN_WARNING 632 "act2000: Illegal BUS type %d\n", 633 card->bus); 634 return -1; 635 } 636 if (!register_isdn(&card->interface)) { 637 printk(KERN_WARNING 638 "act2000: Unable to register %s\n", 639 card->interface.id); 640 return -1; 641 } 642 card->myid = card->interface.channels; 643 sprintf(card->regname, "act2000-isdn (%s)", card->interface.id); 644 return 0; 645} 646 647static void 648unregister_card(act2000_card * card) 649{ 650 isdn_ctrl cmd; 651 652 cmd.command = ISDN_STAT_UNLOAD; 653 cmd.driver = card->myid; 654 card->interface.statcallb(&cmd); 655 switch (card->bus) { 656 case ACT2000_BUS_ISA: 657 act2000_isa_release(card); 658 break; 659 case ACT2000_BUS_MCA: 660 case ACT2000_BUS_PCMCIA: 661 default: 662 printk(KERN_WARNING 663 "act2000: Invalid BUS type %d\n", 664 card->bus); 665 break; 666 } 667} 668 669static int 670act2000_addcard(int bus, int port, int irq, char *id) 671{ 672 act2000_card *p; 673 act2000_card *q = NULL; 674 int initialized; 675 int added = 0; 676 int failed = 0; 677 int i; 678 679 if (!bus) 680 bus = ACT2000_BUS_ISA; 681 if (port != -1) { 682 /* Port defined, do fixed setup */ 683 act2000_alloccard(bus, port, irq, id); 684 } else { 685 /* No port defined, perform autoprobing. 686 * This may result in more than one card detected. 687 */ 688 switch (bus) { 689 case ACT2000_BUS_ISA: 690 for (i = 0; i < ISA_NRPORTS; i++) 691 if (act2000_isa_detect(act2000_isa_ports[i])) { 692 printk(KERN_INFO 693 "act2000: Detected ISA card at port 0x%x\n", 694 act2000_isa_ports[i]); 695 act2000_alloccard(bus, act2000_isa_ports[i], irq, id); 696 } 697 break; 698 case ACT2000_BUS_MCA: 699 case ACT2000_BUS_PCMCIA: 700 default: 701 printk(KERN_WARNING 702 "act2000: addcard: Invalid BUS type %d\n", 703 bus); 704 } 705 } 706 if (!cards) 707 return 1; 708 p = cards; 709 while (p) { 710 initialized = 0; 711 if (!p->interface.statcallb) { 712 /* Not yet registered. 713 * Try to register and activate it. 714 */ 715 added++; 716 switch (p->bus) { 717 case ACT2000_BUS_ISA: 718 if (act2000_isa_detect(p->port)) { 719 if (act2000_registercard(p)) 720 break; 721 if (act2000_isa_config_port(p, p->port)) { 722 printk(KERN_WARNING 723 "act2000: Could not request port 0x%04x\n", 724 p->port); 725 unregister_card(p); 726 p->interface.statcallb = NULL; 727 break; 728 } 729 if (act2000_isa_config_irq(p, p->irq)) { 730 printk(KERN_INFO 731 "act2000: No IRQ available, fallback to polling\n"); 732 /* Fall back to polled operation */ 733 p->irq = 0; 734 } 735 printk(KERN_INFO 736 "act2000: ISA" 737 "-type card at port " 738 "0x%04x ", 739 p->port); 740 if (p->irq) 741 printk("irq %d\n", p->irq); 742 else 743 printk("polled\n"); 744 initialized = 1; 745 } 746 break; 747 case ACT2000_BUS_MCA: 748 case ACT2000_BUS_PCMCIA: 749 default: 750 printk(KERN_WARNING 751 "act2000: addcard: Invalid BUS type %d\n", 752 p->bus); 753 } 754 } else 755 /* Card already initialized */ 756 initialized = 1; 757 if (initialized) { 758 /* Init OK, next card ... */ 759 q = p; 760 p = p->next; 761 } else { 762 /* Init failed, remove card from list, free memory */ 763 printk(KERN_WARNING 764 "act2000: Initialization of %s failed\n", 765 p->interface.id); 766 if (q) { 767 q->next = p->next; 768 kfree(p); 769 p = q->next; 770 } else { 771 cards = p->next; 772 kfree(p); 773 p = cards; 774 } 775 failed++; 776 } 777 } 778 return (added - failed); 779} 780 781#define DRIVERNAME "IBM Active 2000 ISDN driver" 782 783static int __init act2000_init(void) 784{ 785 printk(KERN_INFO "%s\n", DRIVERNAME); 786 if (!cards) 787 act2000_addcard(act_bus, act_port, act_irq, act_id); 788 if (!cards) 789 printk(KERN_INFO "act2000: No cards defined yet\n"); 790 return 0; 791} 792 793static void __exit act2000_exit(void) 794{ 795 act2000_card *card = cards; 796 act2000_card *last; 797 while (card) { 798 unregister_card(card); 799 del_timer(&card->ptimer); 800 card = card->next; 801 } 802 card = cards; 803 while (card) { 804 last = card; 805 card = card->next; 806 act2000_clear_msn(last); 807 kfree(last); 808 } 809 printk(KERN_INFO "%s unloaded\n", DRIVERNAME); 810} 811 812module_init(act2000_init); 813module_exit(act2000_exit); 814