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