linux/drivers/isdn/act2000/module.c
<<
>>
Prefs
   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
  22static unsigned short act2000_isa_ports[] =
  23{
  24        0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
  25        0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
  26};
  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 < ARRAY_SIZE(act2000_isa_ports); i++)
 691                                if (act2000_isa_detect(act2000_isa_ports[i])) {
 692                                        printk(KERN_INFO "act2000: Detected "
 693                                                "ISA card at port 0x%x\n",
 694                                                act2000_isa_ports[i]);
 695                                        act2000_alloccard(bus,
 696                                                act2000_isa_ports[i], irq, id);
 697                                }
 698                        break;
 699                case ACT2000_BUS_MCA:
 700                case ACT2000_BUS_PCMCIA:
 701                default:
 702                        printk(KERN_WARNING
 703                                "act2000: addcard: Invalid BUS type %d\n", 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