drivers/staging/i4l/act2000/module.c

   1 /* $Id: module.c,v 1.14.6.4 2001/09/23 22:24:32 kai 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/slab.h>
  20 #include <linux/init.h>
  21
  22 static unsigned short act2000_isa_ports[] =
  23 {
  24         0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
  25         0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
  26 };
  27
  28 static act2000_card *cards = (act2000_card *) NULL;
  29
  30 /* Parameters to be set by insmod */
  31 static int   act_bus;
  32 static int   act_port = -1;  /* -1 = Autoprobe  */
  33 static int   act_irq  = -1;
  34 static char *act_id   = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
  35
  36 MODULE_DESCRIPTION("ISDN4Linux: Driver for IBM Active 2000 ISDN card");
  37 MODULE_AUTHOR("Fritz Elfert");
  38 MODULE_LICENSE("GPL");
  39 MODULE_PARM_DESC(act_bus, "BusType of first card, 1=ISA, 2=MCA, 3=PCMCIA, currently only ISA");
  40 MODULE_PARM_DESC(act_port, "Base port address of first card");
  41 MODULE_PARM_DESC(act_irq, "IRQ of first card");
  42 MODULE_PARM_DESC(act_id, "ID-String of first card");
  43 module_param(act_bus, int, 0);
  44 module_param(act_port, int, 0);
  45 module_param(act_irq, int, 0);
  46 module_param(act_id, charp, 0);
  47
  48 static int act2000_addcard(int, int, int, char *);
  49
  50 static act2000_chan *
  51 find_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  */
  62 static void
  63 act2000_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  */
  84 static __u16
  85 act2000_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  */
 107 char *
 108 act2000_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  */
 126 static int
 127 act2000_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
 194 static void
 195 act2000_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
 212 static void
 213 act2000_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
 230 static void
 231 act2000_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
 242 static int
 243 act2000_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                         ret = act2000_set_msn(card, tmp);
 293                         if (ret)
 294                                 return ret;
 295                         if (card->flags & ACT2000_FLAGS_RUNNING)
 296                                 return (actcapi_manufacturer_req_msn(card));
 297                         return 0;
 298                 case ACT2000_IOCTL_ADDCARD:
 299                         if (copy_from_user(&cdef, arg,
 300                                            sizeof(cdef)))
 301                                 return -EFAULT;
 302                         if (act2000_addcard(cdef.bus, cdef.port, cdef.irq, cdef.id))
 303                                 return -EIO;
 304                         return 0;
 305                 case ACT2000_IOCTL_TEST:
 306                         if (!(card->flags & ACT2000_FLAGS_RUNNING))
 307                                 return -ENODEV;
 308                         return 0;
 309                 default:
 310                         return -EINVAL;
 311                 }
 312                 break;
 313         case ISDN_CMD_DIAL:
 314                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 315                         return -ENODEV;
 316                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 317                         break;
 318                 spin_lock_irqsave(&card->lock, flags);
 319                 if (chan->fsm_state != ACT2000_STATE_NULL) {
 320                         spin_unlock_irqrestore(&card->lock, flags);
 321                         printk(KERN_WARNING "Dial on channel with state %d\n",
 322                                chan->fsm_state);
 323                         return -EBUSY;
 324                 }
 325                 if (card->ptype == ISDN_PTYPE_EURO)
 326                         tmp[0] = act2000_find_msn(card, c->parm.setup.eazmsn, 1);
 327                 else
 328                         tmp[0] = c->parm.setup.eazmsn[0];
 329                 chan->fsm_state = ACT2000_STATE_OCALL;
 330                 chan->callref = 0xffff;
 331                 spin_unlock_irqrestore(&card->lock, flags);
 332                 ret = actcapi_connect_req(card, chan, c->parm.setup.phone,
 333                                           tmp[0], c->parm.setup.si1,
 334                                           c->parm.setup.si2);
 335                 if (ret) {
 336                         cmd.driver = card->myid;
 337                         cmd.command = ISDN_STAT_DHUP;
 338                         cmd.arg &= 0x0f;
 339                         card->interface.statcallb(&cmd);
 340                 }
 341                 return ret;
 342         case ISDN_CMD_ACCEPTD:
 343                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 344                         return -ENODEV;
 345                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 346                         break;
 347                 if (chan->fsm_state == ACT2000_STATE_ICALL)
 348                         actcapi_select_b2_protocol_req(card, chan);
 349                 return 0;
 350         case ISDN_CMD_ACCEPTB:
 351                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 352                         return -ENODEV;
 353                 return 0;
 354         case ISDN_CMD_HANGUP:
 355                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 356                         return -ENODEV;
 357                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 358                         break;
 359                 switch (chan->fsm_state) {
 360                 case ACT2000_STATE_ICALL:
 361                 case ACT2000_STATE_BSETUP:
 362                         actcapi_connect_resp(card, chan, 0x15);
 363                         break;
 364                 case ACT2000_STATE_ACTIVE:
 365                         actcapi_disconnect_b3_req(card, chan);
 366                         break;
 367                 }
 368                 return 0;
 369         case ISDN_CMD_SETEAZ:
 370                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 371                         return -ENODEV;
 372                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 373                         break;
 374                 if (strlen(c->parm.num)) {
 375                         if (card->ptype == ISDN_PTYPE_EURO) {
 376                                 chan->eazmask = act2000_find_msn(card, c->parm.num, 0);
 377                         }
 378                         if (card->ptype == ISDN_PTYPE_1TR6) {
 379                                 int i;
 380                                 chan->eazmask = 0;
 381                                 for (i = 0; i < strlen(c->parm.num); i++)
 382                                         if (isdigit(c->parm.num[i]))
 383                                                 chan->eazmask |= (1 << (c->parm.num[i] - '0'));
 384                         }
 385                 } else
 386                         chan->eazmask = 0x3ff;
 387                 actcapi_listen_req(card);
 388                 return 0;
 389         case ISDN_CMD_CLREAZ:
 390                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 391                         return -ENODEV;
 392                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 393                         break;
 394                 chan->eazmask = 0;
 395                 actcapi_listen_req(card);
 396                 return 0;
 397         case ISDN_CMD_SETL2:
 398                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 399                         return -ENODEV;
 400                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 401                         break;
 402                 chan->l2prot = (c->arg >> 8);
 403                 return 0;
 404         case ISDN_CMD_SETL3:
 405                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 406                         return -ENODEV;
 407                 if ((c->arg >> 8) != ISDN_PROTO_L3_TRANS) {
 408                         printk(KERN_WARNING "L3 protocol unknown\n");
 409                         return -1;
 410                 }
 411                 if (!(chan = find_channel(card, c->arg & 0x0f)))
 412                         break;
 413                 chan->l3prot = (c->arg >> 8);
 414                 return 0;
 415         }
 416
 417         return -EINVAL;
 418 }
 419
 420 static int
 421 act2000_sendbuf(act2000_card *card, int channel, int ack, struct sk_buff *skb)
 422 {
 423         struct sk_buff *xmit_skb;
 424         int len;
 425         act2000_chan *chan;
 426         actcapi_msg *msg;
 427
 428         if (!(chan = find_channel(card, channel)))
 429                 return -1;
 430         if (chan->fsm_state != ACT2000_STATE_ACTIVE)
 431                 return -1;
 432         len = skb->len;
 433         if ((chan->queued + len) >= ACT2000_MAX_QUEUED)
 434                 return 0;
 435         if (!len)
 436                 return 0;
 437         if (skb_headroom(skb) < 19) {
 438                 printk(KERN_WARNING "act2000_sendbuf: Headroom only %d\n",
 439                        skb_headroom(skb));
 440                 xmit_skb = alloc_skb(len + 19, GFP_ATOMIC);
 441                 if (!xmit_skb) {
 442                         printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
 443                         return 0;
 444                 }
 445                 skb_reserve(xmit_skb, 19);
 446                 skb_copy_from_linear_data(skb, skb_put(xmit_skb, len), len);
 447         } else {
 448                 xmit_skb = skb_clone(skb, GFP_ATOMIC);
 449                 if (!xmit_skb) {
 450                         printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
 451                         return 0;
 452                 }
 453         }
 454         dev_kfree_skb(skb);
 455         msg = (actcapi_msg *)skb_push(xmit_skb, 19);
 456         msg->hdr.len = 19 + len;
 457         msg->hdr.applicationID = 1;
 458         msg->hdr.cmd.cmd = 0x86;
 459         msg->hdr.cmd.subcmd = 0x00;
 460         msg->hdr.msgnum = actcapi_nextsmsg(card);
 461         msg->msg.data_b3_req.datalen = len;
 462         msg->msg.data_b3_req.blocknr = (msg->hdr.msgnum & 0xff);
 463         msg->msg.data_b3_req.fakencci = MAKE_NCCI(chan->plci, 0, chan->ncci);
 464         msg->msg.data_b3_req.flags = ack; /* Will be set to 0 on actual sending */
 465         actcapi_debug_msg(xmit_skb, 1);
 466         chan->queued += len;
 467         skb_queue_tail(&card->sndq, xmit_skb);
 468         act2000_schedule_tx(card);
 469         return len;
 470 }
 471
 472
 473 /* Read the Status-replies from the Interface */
 474 static int
 475 act2000_readstatus(u_char __user *buf, int len, act2000_card *card)
 476 {
 477         int count;
 478         u_char __user *p;
 479
 480         for (p = buf, count = 0; count < len; p++, count++) {
 481                 if (card->status_buf_read == card->status_buf_write)
 482                         return count;
 483                 put_user(*card->status_buf_read++, p);
 484                 if (card->status_buf_read > card->status_buf_end)
 485                         card->status_buf_read = card->status_buf;
 486         }
 487         return count;
 488 }
 489
 490 /*
 491  * Find card with given driverId
 492  */
 493 static inline act2000_card *
 494 act2000_findcard(int driverid)
 495 {
 496         act2000_card *p = cards;
 497
 498         while (p) {
 499                 if (p->myid == driverid)
 500                         return p;
 501                 p = p->next;
 502         }
 503         return (act2000_card *) 0;
 504 }
 505
 506 /*
 507  * Wrapper functions for interface to linklevel
 508  */
 509 static int
 510 if_command(isdn_ctrl *c)
 511 {
 512         act2000_card *card = act2000_findcard(c->driver);
 513
 514         if (card)
 515                 return (act2000_command(card, c));
 516         printk(KERN_ERR
 517                "act2000: if_command %d called with invalid driverId %d!\n",
 518                c->command, c->driver);
 519         return -ENODEV;
 520 }
 521
 522 static int
 523 if_writecmd(const u_char __user *buf, int len, int id, int channel)
 524 {
 525         act2000_card *card = act2000_findcard(id);
 526
 527         if (card) {
 528                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 529                         return -ENODEV;
 530                 return (len);
 531         }
 532         printk(KERN_ERR
 533                "act2000: if_writecmd called with invalid driverId!\n");
 534         return -ENODEV;
 535 }
 536
 537 static int
 538 if_readstatus(u_char __user *buf, int len, int id, int channel)
 539 {
 540         act2000_card *card = act2000_findcard(id);
 541
 542         if (card) {
 543                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 544                         return -ENODEV;
 545                 return (act2000_readstatus(buf, len, card));
 546         }
 547         printk(KERN_ERR
 548                "act2000: if_readstatus called with invalid driverId!\n");
 549         return -ENODEV;
 550 }
 551
 552 static int
 553 if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
 554 {
 555         act2000_card *card = act2000_findcard(id);
 556
 557         if (card) {
 558                 if (!(card->flags & ACT2000_FLAGS_RUNNING))
 559                         return -ENODEV;
 560                 return (act2000_sendbuf(card, channel, ack, skb));
 561         }
 562         printk(KERN_ERR
 563                "act2000: if_sendbuf called with invalid driverId!\n");
 564         return -ENODEV;
 565 }
 566
 567
 568 /*
 569  * Allocate a new card-struct, initialize it
 570  * link it into cards-list.
 571  */
 572 static void
 573 act2000_alloccard(int bus, int port, int irq, char *id)
 574 {
 575         int i;
 576         act2000_card *card;
 577         if (!(card = kzalloc(sizeof(act2000_card), GFP_KERNEL))) {
 578                 printk(KERN_WARNING
 579                        "act2000: (%s) Could not allocate card-struct.\n", id);
 580                 return;
 581         }
 582         spin_lock_init(&card->lock);
 583         spin_lock_init(&card->mnlock);
 584         skb_queue_head_init(&card->sndq);
 585         skb_queue_head_init(&card->rcvq);
 586         skb_queue_head_init(&card->ackq);
 587         INIT_WORK(&card->snd_tq, act2000_transmit);
 588         INIT_WORK(&card->rcv_tq, actcapi_dispatch);
 589         INIT_WORK(&card->poll_tq, act2000_receive);
 590         init_timer(&card->ptimer);
 591         card->interface.owner = THIS_MODULE;
 592         card->interface.channels = ACT2000_BCH;
 593         card->interface.maxbufsize = 4000;
 594         card->interface.command = if_command;
 595         card->interface.writebuf_skb = if_sendbuf;
 596         card->interface.writecmd = if_writecmd;
 597         card->interface.readstat = if_readstatus;
 598         card->interface.features =
 599                 ISDN_FEATURE_L2_X75I |
 600                 ISDN_FEATURE_L2_HDLC |
 601                 ISDN_FEATURE_L3_TRANS |
 602                 ISDN_FEATURE_P_UNKNOWN;
 603         card->interface.hl_hdrlen = 20;
 604         card->ptype = ISDN_PTYPE_EURO;
 605         strlcpy(card->interface.id, id, sizeof(card->interface.id));
 606         for (i = 0; i < ACT2000_BCH; i++) {
 607                 card->bch[i].plci = 0x8000;
 608                 card->bch[i].ncci = 0x8000;
 609                 card->bch[i].l2prot = ISDN_PROTO_L2_X75I;
 610                 card->bch[i].l3prot = ISDN_PROTO_L3_TRANS;
 611         }
 612         card->myid = -1;
 613         card->bus = bus;
 614         card->port = port;
 615         card->irq = irq;
 616         card->next = cards;
 617         cards = card;
 618 }
 619
 620 /*
 621  * register card at linklevel
 622  */
 623 static int
 624 act2000_registercard(act2000_card *card)
 625 {
 626         switch (card->bus) {
 627         case ACT2000_BUS_ISA:
 628                 break;
 629         case ACT2000_BUS_MCA:
 630         case ACT2000_BUS_PCMCIA:
 631         default:
 632                 printk(KERN_WARNING
 633                        "act2000: Illegal BUS type %d\n",
 634                        card->bus);
 635                 return -1;
 636         }
 637         if (!register_isdn(&card->interface)) {
 638                 printk(KERN_WARNING
 639                        "act2000: Unable to register %s\n",
 640                        card->interface.id);
 641                 return -1;
 642         }
 643         card->myid = card->interface.channels;
 644         sprintf(card->regname, "act2000-isdn (%s)", card->interface.id);
 645         return 0;
 646 }
 647
 648 static void
 649 unregister_card(act2000_card *card)
 650 {
 651         isdn_ctrl cmd;
 652
 653         cmd.command = ISDN_STAT_UNLOAD;
 654         cmd.driver = card->myid;
 655         card->interface.statcallb(&cmd);
 656         switch (card->bus) {
 657         case ACT2000_BUS_ISA:
 658                 act2000_isa_release(card);
 659                 break;
 660         case ACT2000_BUS_MCA:
 661         case ACT2000_BUS_PCMCIA:
 662         default:
 663                 printk(KERN_WARNING
 664                        "act2000: Invalid BUS type %d\n",
 665                        card->bus);
 666                 break;
 667         }
 668 }
 669
 670 static int
 671 act2000_addcard(int bus, int port, int irq, char *id)
 672 {
 673         act2000_card *p;
 674         act2000_card *q = NULL;
 675         int initialized;
 676         int added = 0;
 677         int failed = 0;
 678         int i;
 679
 680         if (!bus)
 681                 bus = ACT2000_BUS_ISA;
 682         if (port != -1) {
 683                 /* Port defined, do fixed setup */
 684                 act2000_alloccard(bus, port, irq, id);
 685         } else {
 686                 /* No port defined, perform autoprobing.
 687                  * This may result in more than one card detected.
 688                  */
 689                 switch (bus) {
 690                 case ACT2000_BUS_ISA:
 691                         for (i = 0; i < ARRAY_SIZE(act2000_isa_ports); i++)
 692                                 if (act2000_isa_detect(act2000_isa_ports[i])) {
 693                                         printk(KERN_INFO "act2000: Detected "
 694                                                "ISA card at port 0x%x\n",
 695                                                act2000_isa_ports[i]);
 696                                         act2000_alloccard(bus,
 697                                                           act2000_isa_ports[i], irq, id);
 698                                 }
 699                         break;
 700                 case ACT2000_BUS_MCA:
 701                 case ACT2000_BUS_PCMCIA:
 702                 default:
 703                         printk(KERN_WARNING
 704                                "act2000: addcard: Invalid BUS type %d\n", bus);
 705                 }
 706         }
 707         if (!cards)
 708                 return 1;
 709         p = cards;
 710         while (p) {
 711                 initialized = 0;
 712                 if (!p->interface.statcallb) {
 713                         /* Not yet registered.
 714                          * Try to register and activate it.
 715                          */
 716                         added++;
 717                         switch (p->bus) {
 718                         case ACT2000_BUS_ISA:
 719                                 if (act2000_isa_detect(p->port)) {
 720                                         if (act2000_registercard(p))
 721                                                 break;
 722                                         if (act2000_isa_config_port(p, p->port)) {
 723                                                 printk(KERN_WARNING
 724                                                        "act2000: Could not request port 0x%04x\n",
 725                                                        p->port);
 726                                                 unregister_card(p);
 727                                                 p->interface.statcallb = NULL;
 728                                                 break;
 729                                         }
 730                                         if (act2000_isa_config_irq(p, p->irq)) {
 731                                                 printk(KERN_INFO
 732                                                        "act2000: No IRQ available, fallback to polling\n");
 733                                                 /* Fall back to polled operation */
 734                                                 p->irq = 0;
 735                                         }
 736                                         printk(KERN_INFO
 737                                                "act2000: ISA"
 738                                                "-type card at port "
 739                                                "0x%04x ",
 740                                                p->port);
 741                                         if (p->irq)
 742                                                 printk("irq %d\n", p->irq);
 743                                         else
 744                                                 printk("polled\n");
 745                                         initialized = 1;
 746                                 }
 747                                 break;
 748                         case ACT2000_BUS_MCA:
 749                         case ACT2000_BUS_PCMCIA:
 750                         default:
 751                                 printk(KERN_WARNING
 752                                        "act2000: addcard: Invalid BUS type %d\n",
 753                                        p->bus);
 754                         }
 755                 } else
 756                         /* Card already initialized */
 757                         initialized = 1;
 758                 if (initialized) {
 759                         /* Init OK, next card ... */
 760                         q = p;
 761                         p = p->next;
 762                 } else {
 763                         /* Init failed, remove card from list, free memory */
 764                         printk(KERN_WARNING
 765                                "act2000: Initialization of %s failed\n",
 766                                p->interface.id);
 767                         if (q) {
 768                                 q->next = p->next;
 769                                 kfree(p);
 770                                 p = q->next;
 771                         } else {
 772                                 cards = p->next;
 773                                 kfree(p);
 774                                 p = cards;
 775                         }
 776                         failed++;
 777                 }
 778         }
 779         return (added - failed);
 780 }
 781
 782 #define DRIVERNAME "IBM Active 2000 ISDN driver"
 783
 784 static int __init act2000_init(void)
 785 {
 786         printk(KERN_INFO "%s\n", DRIVERNAME);
 787         if (!cards)
 788                 act2000_addcard(act_bus, act_port, act_irq, act_id);
 789         if (!cards)
 790                 printk(KERN_INFO "act2000: No cards defined yet\n");
 791         return 0;
 792 }
 793
 794 static void __exit act2000_exit(void)
 795 {
 796         act2000_card *card = cards;
 797         act2000_card *last;
 798         while (card) {
 799                 unregister_card(card);
 800                 del_timer_sync(&card->ptimer);
 801                 card = card->next;
 802         }
 803         card = cards;
 804         while (card) {
 805                 last = card;
 806                 card = card->next;
 807                 act2000_clear_msn(last);
 808                 kfree(last);
 809         }
 810         printk(KERN_INFO "%s unloaded\n", DRIVERNAME);
 811 }
 812
 813 module_init(act2000_init);
 814 module_exit(act2000_exit);