Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 808 insertions, 0 deletions

diff --git a/drivers/isdn/act2000/module.c b/drivers/isdn/act2000/module.c
new file mode 100644
index 000000000000..d89dcde4eade
--- /dev/null
+++ b/drivers/isdn/act2000/module.c
@@ -0,0 +1,808 @@
+/* $Id: module.c,v 1.14.6.4 2001/09/23 22:24:32 kai Exp $
+ *
+ * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000.
+ *
+ * Author       Fritz Elfert
+ * Copyright    by Fritz Elfert      <fritz@isdn4linux.de>
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ * Thanks to Friedemann Baitinger and IBM Germany
+ *
+ */
+
+#include "act2000.h"
+#include "act2000_isa.h"
+#include "capi.h"
+#include <linux/module.h>
+#include <linux/init.h>
+
+static unsigned short act2000_isa_ports[] =
+{
+        0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
+        0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
+};
+#define ISA_NRPORTS (sizeof(act2000_isa_ports)/sizeof(unsigned short))
+
+static act2000_card *cards = (act2000_card *) NULL;
+
+/* Parameters to be set by insmod */
+static int   act_bus  =  0;
+static int   act_port = -1;  /* -1 = Autoprobe  */
+static int   act_irq  = -1;
+static char *act_id   = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+
+MODULE_DESCRIPTION(       "ISDN4Linux: Driver for IBM Active 2000 ISDN card");
+MODULE_AUTHOR(            "Fritz Elfert");
+MODULE_LICENSE(           "GPL");
+MODULE_PARM_DESC(act_bus, "BusType of first card, 1=ISA, 2=MCA, 3=PCMCIA, currently only ISA");
+MODULE_PARM_DESC(membase, "Base port address of first card");
+MODULE_PARM_DESC(act_irq, "IRQ of first card");
+MODULE_PARM_DESC(act_id,  "ID-String of first card");
+module_param(act_bus,  int, 0);
+module_param(act_port, int, 0);
+module_param(act_irq, int, 0);
+module_param(act_id, charp, 0);
+
+static int act2000_addcard(int, int, int, char *);
+
+static act2000_chan *
+find_channel(act2000_card *card, int channel)
+{
+        if ((channel >= 0) && (channel < ACT2000_BCH))
+                return &(card->bch[channel]);
+        printk(KERN_WARNING "act2000: Invalid channel %d\n", channel);
+        return NULL;
+}
+
+/*
+ * Free MSN list
+ */
+static void
+act2000_clear_msn(act2000_card *card)
+{
+        struct msn_entry *p = card->msn_list;
+        struct msn_entry *q;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->lock, flags);
+        card->msn_list = NULL;
+        spin_unlock_irqrestore(&card->lock, flags);
+        while (p) {
+                q  = p->next;
+                kfree(p);
+                p = q;
+        }
+}
+
+/*
+ * Find an MSN entry in the list.
+ * If ia5 != 0, return IA5-encoded EAZ, else
+ * return a bitmask with corresponding bit set.
+ */
+static __u16
+act2000_find_msn(act2000_card *card, char *msn, int ia5)
+{
+        struct msn_entry *p = card->msn_list;
+        __u8 eaz = '0';
+
+        while (p) {
+                if (!strcmp(p->msn, msn)) {
+                        eaz = p->eaz;
+                        break;
+                }
+                p = p->next;
+        }
+        if (!ia5)
+                return (1 << (eaz - '0'));
+        else
+                return eaz;
+}
+
+/*
+ * Find an EAZ entry in the list.
+ * return a string with corresponding msn.
+ */
+char *
+act2000_find_eaz(act2000_card *card, char eaz)
+{
+        struct msn_entry *p = card->msn_list;
+
+        while (p) {
+                if (p->eaz == eaz)
+                        return(p->msn);
+                p = p->next;
+        }
+        return("\0");
+}
+
+/*
+ * Add or delete an MSN to the MSN list
+ *
+ * First character of msneaz is EAZ, rest is MSN.
+ * If length of eazmsn is 1, delete that entry.
+ */
+static int
+act2000_set_msn(act2000_card *card, char *eazmsn)
+{
+        struct msn_entry *p = card->msn_list;
+        struct msn_entry *q = NULL;
+        unsigned long flags;
+        int i;
+        
+        if (!strlen(eazmsn))
+                return 0;
+        if (strlen(eazmsn) > 16)
+                return -EINVAL;
+        for (i = 0; i < strlen(eazmsn); i++)
+                if (!isdigit(eazmsn[i]))
+                        return -EINVAL;
+        if (strlen(eazmsn) == 1) {
+                /* Delete a single MSN */
+                while (p) {
+                        if (p->eaz == eazmsn[0]) {
+                                spin_lock_irqsave(&card->lock, flags);
+                                if (q)
+                                        q->next = p->next;
+                                else
+                                        card->msn_list = p->next;
+                                spin_unlock_irqrestore(&card->lock, flags);
+                                kfree(p);
+                                printk(KERN_DEBUG
+                                       "Mapping for EAZ %c deleted\n",
+                                       eazmsn[0]);
+                                return 0;
+                        }
+                        q = p;
+                        p = p->next;
+                }
+                return 0;
+        }
+        /* Add a single MSN */
+        while (p) {
+                /* Found in list, replace MSN */
+                if (p->eaz == eazmsn[0]) {
+                        spin_lock_irqsave(&card->lock, flags);
+                        strcpy(p->msn, &eazmsn[1]);
+                        spin_unlock_irqrestore(&card->lock, flags);
+                        printk(KERN_DEBUG
+                               "Mapping for EAZ %c changed to %s\n",
+                               eazmsn[0],
+                               &eazmsn[1]);
+                        return 0;
+                }
+                p = p->next;
+        }
+        /* Not found in list, add new entry */
+        p = kmalloc(sizeof(msn_entry), GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+        p->eaz = eazmsn[0];
+        strcpy(p->msn, &eazmsn[1]);
+        p->next = card->msn_list;
+        spin_lock_irqsave(&card->lock, flags);
+        card->msn_list = p;
+        spin_unlock_irqrestore(&card->lock, flags);
+        printk(KERN_DEBUG
+               "Mapping %c -> %s added\n",
+               eazmsn[0],
+               &eazmsn[1]);
+        return 0;
+}
+
+static void
+act2000_transmit(struct act2000_card *card)
+{
+        switch (card->bus) {
+                case ACT2000_BUS_ISA:
+                        act2000_isa_send(card);
+                        break;
+                case ACT2000_BUS_PCMCIA:
+                case ACT2000_BUS_MCA:
+                default:
+                        printk(KERN_WARNING
+                               "act2000_transmit: Illegal bustype %d\n", card->bus);
+        }
+}
+
+static void
+act2000_receive(struct act2000_card *card)
+{
+        switch (card->bus) {
+                case ACT2000_BUS_ISA:
+                        act2000_isa_receive(card);
+                        break;
+                case ACT2000_BUS_PCMCIA:
+                case ACT2000_BUS_MCA:
+                default:
+                        printk(KERN_WARNING
+                               "act2000_receive: Illegal bustype %d\n", card->bus);
+        }
+}
+
+static void
+act2000_poll(unsigned long data)
+{
+        act2000_card * card = (act2000_card *)data;
+        unsigned long flags;
+
+        act2000_receive(card);
+        spin_lock_irqsave(&card->lock, flags);
+        mod_timer(&card->ptimer, jiffies+3);
+        spin_unlock_irqrestore(&card->lock, flags);
+}
+
+static int
+act2000_command(act2000_card * card, isdn_ctrl * c)
+{
+        ulong a;
+        act2000_chan *chan;
+        act2000_cdef cdef;
+        isdn_ctrl cmd;
+        char tmp[17];
+        int ret;
+        unsigned long flags;
+        void __user *arg;
+ 
+        switch (c->command) {
+                case ISDN_CMD_IOCTL:
+                        memcpy(&a, c->parm.num, sizeof(ulong));
+                        arg = (void __user *)a;
+                        switch (c->arg) {
+                                case ACT2000_IOCTL_LOADBOOT:
+                                        switch (card->bus) {
+                                                case ACT2000_BUS_ISA:
+                                                        ret = act2000_isa_download(card,
+                                                                           arg);
+                                                        if (!ret) {
+                                                                card->flags |= ACT2000_FLAGS_LOADED;
+                                                                if (!(card->flags & ACT2000_FLAGS_IVALID)) {
+                                                                        card->ptimer.expires = jiffies + 3;
+                                                                        card->ptimer.function = act2000_poll;
+                                                                        card->ptimer.data = (unsigned long)card;
+                                                                        add_timer(&card->ptimer);
+                                                                }
+                                                                actcapi_manufacturer_req_errh(card);
+                                                        }
+                                                        break;
+                                                default:
+                                                        printk(KERN_WARNING
+                                                               "act2000: Illegal BUS type %d\n",
+                                                               card->bus);
+                                                        ret = -EIO;
+                                        }
+                                        return ret;
+                                case ACT2000_IOCTL_SETPROTO:
+                                        card->ptype = a?ISDN_PTYPE_EURO:ISDN_PTYPE_1TR6;
+                                        if (!(card->flags & ACT2000_FLAGS_RUNNING))
+                                                return 0;
+                                        actcapi_manufacturer_req_net(card);
+                                        return 0;
+                                case ACT2000_IOCTL_SETMSN:
+                                        if (copy_from_user(tmp, arg,
+                                                           sizeof(tmp)))
+                                                return -EFAULT;
+                                        if ((ret = act2000_set_msn(card, tmp)))
+                                                return ret;
+                                        if (card->flags & ACT2000_FLAGS_RUNNING)
+                                                return(actcapi_manufacturer_req_msn(card));
+                                        return 0;
+                                case ACT2000_IOCTL_ADDCARD:
+                                        if (copy_from_user(&cdef, arg,
+                                                           sizeof(cdef)))
+                                                return -EFAULT;
+                                        if (act2000_addcard(cdef.bus, cdef.port, cdef.irq, cdef.id))
+                                                return -EIO;
+                                        return 0;
+                                case ACT2000_IOCTL_TEST:
+                                        if (!(card->flags & ACT2000_FLAGS_RUNNING))
+                                                return -ENODEV;
+                                        return 0;
+                                default:
+                                        return -EINVAL;
+                        }
+                        break;
+                case ISDN_CMD_DIAL:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        spin_lock_irqsave(&card->lock, flags);
+                        if (chan->fsm_state != ACT2000_STATE_NULL) {
+                                spin_unlock_irqrestore(&card->lock, flags);
+                                printk(KERN_WARNING "Dial on channel with state %d\n",
+                                        chan->fsm_state);
+                                return -EBUSY;
+                        }
+                        if (card->ptype == ISDN_PTYPE_EURO)
+                                tmp[0] = act2000_find_msn(card, c->parm.setup.eazmsn, 1);
+                        else
+                                tmp[0] = c->parm.setup.eazmsn[0];
+                        chan->fsm_state = ACT2000_STATE_OCALL;
+                        chan->callref = 0xffff;
+                        spin_unlock_irqrestore(&card->lock, flags);
+                        ret = actcapi_connect_req(card, chan, c->parm.setup.phone,
+                                                  tmp[0], c->parm.setup.si1,
+                                                  c->parm.setup.si2);
+                        if (ret) {
+                                cmd.driver = card->myid;
+                                cmd.command = ISDN_STAT_DHUP;
+                                cmd.arg &= 0x0f;
+                                card->interface.statcallb(&cmd);
+                        }
+                        return ret;
+                case ISDN_CMD_ACCEPTD:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        if (chan->fsm_state == ACT2000_STATE_ICALL)
+                                actcapi_select_b2_protocol_req(card, chan);
+                        return 0;
+                case ISDN_CMD_ACCEPTB:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        return 0;
+                case ISDN_CMD_HANGUP:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        switch (chan->fsm_state) {
+                                case ACT2000_STATE_ICALL:
+                                case ACT2000_STATE_BSETUP:
+                                        actcapi_connect_resp(card, chan, 0x15);
+                                        break;
+                                case ACT2000_STATE_ACTIVE:
+                                        actcapi_disconnect_b3_req(card, chan);
+                                        break;
+                        }
+                        return 0;
+                case ISDN_CMD_SETEAZ:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        if (strlen(c->parm.num)) {
+                                if (card->ptype == ISDN_PTYPE_EURO) {
+                                        chan->eazmask = act2000_find_msn(card, c->parm.num, 0);
+                                }
+                                if (card->ptype == ISDN_PTYPE_1TR6) {
+                                        int i;
+                                        chan->eazmask = 0;
+                                        for (i = 0; i < strlen(c->parm.num); i++)
+                                                if (isdigit(c->parm.num[i]))
+                                                        chan->eazmask |= (1 << (c->parm.num[i] - '0'));
+                                }
+                        } else
+                                chan->eazmask = 0x3ff;
+                        actcapi_listen_req(card);
+                        return 0;
+                case ISDN_CMD_CLREAZ:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        chan->eazmask = 0;
+                        actcapi_listen_req(card);
+                        return 0;
+                case ISDN_CMD_SETL2:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        chan->l2prot = (c->arg >> 8);
+                        return 0;
+                case ISDN_CMD_SETL3:
+                        if (!card->flags & ACT2000_FLAGS_RUNNING)
+                                return -ENODEV;
+                        if ((c->arg >> 8) != ISDN_PROTO_L3_TRANS) {
+                                printk(KERN_WARNING "L3 protocol unknown\n");
+                                return -1;
+                        }
+                        if (!(chan = find_channel(card, c->arg & 0x0f)))
+                                break;
+                        chan->l3prot = (c->arg >> 8);
+                        return 0;
+        }
+        
+        return -EINVAL;
+}
+
+static int
+act2000_sendbuf(act2000_card *card, int channel, int ack, struct sk_buff *skb)
+{
+        struct sk_buff *xmit_skb;
+        int len;
+        act2000_chan *chan;
+        actcapi_msg *msg;
+
+        if (!(chan = find_channel(card, channel)))
+                return -1;
+        if (chan->fsm_state != ACT2000_STATE_ACTIVE)
+                return -1;
+        len = skb->len;
+        if ((chan->queued + len) >= ACT2000_MAX_QUEUED)
+                return 0;
+        if (!len)
+                return 0;
+        if (skb_headroom(skb) < 19) {
+                printk(KERN_WARNING "act2000_sendbuf: Headroom only %d\n",
+                       skb_headroom(skb));
+                xmit_skb = alloc_skb(len + 19, GFP_ATOMIC);
+                if (!xmit_skb) {
+                        printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
+                        return 0;
+                }
+                skb_reserve(xmit_skb, 19);
+                memcpy(skb_put(xmit_skb, len), skb->data, len);
+        } else {
+                xmit_skb = skb_clone(skb, GFP_ATOMIC);
+                if (!xmit_skb) {
+                        printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
+                        return 0;
+                }
+        }
+        dev_kfree_skb(skb);
+        msg = (actcapi_msg *)skb_push(xmit_skb, 19);
+        msg->hdr.len = 19 + len;
+        msg->hdr.applicationID = 1;
+        msg->hdr.cmd.cmd = 0x86;
+        msg->hdr.cmd.subcmd = 0x00;
+        msg->hdr.msgnum = actcapi_nextsmsg(card);
+        msg->msg.data_b3_req.datalen = len;
+        msg->msg.data_b3_req.blocknr = (msg->hdr.msgnum & 0xff);
+        msg->msg.data_b3_req.fakencci = MAKE_NCCI(chan->plci, 0, chan->ncci);
+        msg->msg.data_b3_req.flags = ack; /* Will be set to 0 on actual sending */
+        actcapi_debug_msg(xmit_skb, 1);
+        chan->queued += len;
+        skb_queue_tail(&card->sndq, xmit_skb);
+        act2000_schedule_tx(card);
+        return len;
+}
+
+
+/* Read the Status-replies from the Interface */
+static int
+act2000_readstatus(u_char __user * buf, int len, act2000_card * card)
+{
+        int count;
+        u_char __user *p;
+
+        for (p = buf, count = 0; count < len; p++, count++) {
+                if (card->status_buf_read == card->status_buf_write)
+                        return count;
+                put_user(*card->status_buf_read++, p);
+                if (card->status_buf_read > card->status_buf_end)
+                        card->status_buf_read = card->status_buf;
+        }
+        return count;
+}
+
+/*
+ * Find card with given driverId
+ */
+static inline act2000_card *
+act2000_findcard(int driverid)
+{
+        act2000_card *p = cards;
+
+        while (p) {
+                if (p->myid == driverid)
+                        return p;
+                p = p->next;
+        }
+        return (act2000_card *) 0;
+}
+
+/*
+ * Wrapper functions for interface to linklevel
+ */
+static int
+if_command(isdn_ctrl * c)
+{
+        act2000_card *card = act2000_findcard(c->driver);
+
+        if (card)
+                return (act2000_command(card, c));
+        printk(KERN_ERR
+             "act2000: if_command %d called with invalid driverId %d!\n",
+               c->command, c->driver);
+        return -ENODEV;
+}
+
+static int
+if_writecmd(const u_char __user *buf, int len, int id, int channel)
+{
+        act2000_card *card = act2000_findcard(id);
+
+        if (card) {
+                if (!card->flags & ACT2000_FLAGS_RUNNING)
+                        return -ENODEV;
+                return (len);
+        }
+        printk(KERN_ERR
+               "act2000: if_writecmd called with invalid driverId!\n");
+        return -ENODEV;
+}
+
+static int
+if_readstatus(u_char __user * buf, int len, int id, int channel)
+{
+        act2000_card *card = act2000_findcard(id);
+        
+        if (card) {
+                if (!card->flags & ACT2000_FLAGS_RUNNING)
+                        return -ENODEV;
+                return (act2000_readstatus(buf, len, card));
+        }
+        printk(KERN_ERR
+               "act2000: if_readstatus called with invalid driverId!\n");
+        return -ENODEV;
+}
+
+static int
+if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
+{
+        act2000_card *card = act2000_findcard(id);
+        
+        if (card) {
+                if (!card->flags & ACT2000_FLAGS_RUNNING)
+                        return -ENODEV;
+                return (act2000_sendbuf(card, channel, ack, skb));
+        }
+        printk(KERN_ERR
+               "act2000: if_sendbuf called with invalid driverId!\n");
+        return -ENODEV;
+}
+
+
+/*
+ * Allocate a new card-struct, initialize it
+ * link it into cards-list.
+ */
+static void
+act2000_alloccard(int bus, int port, int irq, char *id)
+{
+        int i;
+        act2000_card *card;
+        if (!(card = (act2000_card *) kmalloc(sizeof(act2000_card), GFP_KERNEL))) {
+                printk(KERN_WARNING
+                       "act2000: (%s) Could not allocate card-struct.\n", id);
+                return;
+        }
+        memset((char *) card, 0, sizeof(act2000_card));
+        spin_lock_init(&card->lock);
+        spin_lock_init(&card->mnlock);
+        skb_queue_head_init(&card->sndq);
+        skb_queue_head_init(&card->rcvq);
+        skb_queue_head_init(&card->ackq);
+        INIT_WORK(&card->snd_tq, (void *) (void *) act2000_transmit, card);
+        INIT_WORK(&card->rcv_tq, (void *) (void *) actcapi_dispatch, card);
+        INIT_WORK(&card->poll_tq, (void *) (void *) act2000_receive, card);
+        init_timer(&card->ptimer);
+        card->interface.owner = THIS_MODULE;
+        card->interface.channels = ACT2000_BCH;
+        card->interface.maxbufsize = 4000;
+        card->interface.command = if_command;
+        card->interface.writebuf_skb = if_sendbuf;
+        card->interface.writecmd = if_writecmd;
+        card->interface.readstat = if_readstatus;
+        card->interface.features =
+                ISDN_FEATURE_L2_X75I |
+                ISDN_FEATURE_L2_HDLC |
+                ISDN_FEATURE_L3_TRANS |
+                ISDN_FEATURE_P_UNKNOWN;
+        card->interface.hl_hdrlen = 20;
+        card->ptype = ISDN_PTYPE_EURO;
+        strlcpy(card->interface.id, id, sizeof(card->interface.id));
+        for (i=0; i<ACT2000_BCH; i++) {
+                card->bch[i].plci = 0x8000;
+                card->bch[i].ncci = 0x8000;
+                card->bch[i].l2prot = ISDN_PROTO_L2_X75I;
+                card->bch[i].l3prot = ISDN_PROTO_L3_TRANS;
+        }
+        card->myid = -1;
+        card->bus = bus;
+        card->port = port;
+        card->irq = irq;
+        card->next = cards;
+        cards = card;
+}
+
+/*
+ * register card at linklevel
+ */
+static int
+act2000_registercard(act2000_card * card)
+{
+        switch (card->bus) {
+                case ACT2000_BUS_ISA:
+                        break;
+                case ACT2000_BUS_MCA:
+                case ACT2000_BUS_PCMCIA:
+                default:
+                        printk(KERN_WARNING
+                               "act2000: Illegal BUS type %d\n",
+                               card->bus);
+                        return -1;
+        }
+        if (!register_isdn(&card->interface)) {
+                printk(KERN_WARNING
+                       "act2000: Unable to register %s\n",
+                       card->interface.id);
+                return -1;
+        }
+        card->myid = card->interface.channels;
+        sprintf(card->regname, "act2000-isdn (%s)", card->interface.id);
+        return 0;
+}
+
+static void
+unregister_card(act2000_card * card)
+{
+        isdn_ctrl cmd;
+
+        cmd.command = ISDN_STAT_UNLOAD;
+        cmd.driver = card->myid;
+        card->interface.statcallb(&cmd);
+        switch (card->bus) {
+                case ACT2000_BUS_ISA:
+                        act2000_isa_release(card);
+                        break;
+                case ACT2000_BUS_MCA:
+                case ACT2000_BUS_PCMCIA:
+                default:
+                        printk(KERN_WARNING
+                               "act2000: Invalid BUS type %d\n",
+                               card->bus);
+                        break;
+        }
+}
+
+static int
+act2000_addcard(int bus, int port, int irq, char *id)
+{
+        act2000_card *p;
+        act2000_card *q = NULL;
+        int initialized;
+        int added = 0;
+        int failed = 0;
+        int i;
+
+        if (!bus)
+                bus = ACT2000_BUS_ISA;
+        if (port != -1) {
+                /* Port defined, do fixed setup */
+                act2000_alloccard(bus, port, irq, id);
+        } else {
+                /* No port defined, perform autoprobing.
+                 * This may result in more than one card detected.
+                 */
+                switch (bus) {
+                        case ACT2000_BUS_ISA:
+                                for (i = 0; i < ISA_NRPORTS; i++)
+                                        if (act2000_isa_detect(act2000_isa_ports[i])) {
+                                                printk(KERN_INFO
+                                                       "act2000: Detected ISA card at port 0x%x\n",
+                                                       act2000_isa_ports[i]);
+                                                act2000_alloccard(bus, act2000_isa_ports[i], irq, id);
+                                        }
+                                break;
+                        case ACT2000_BUS_MCA:
+                        case ACT2000_BUS_PCMCIA:
+                        default:
+                                printk(KERN_WARNING
+                                       "act2000: addcard: Invalid BUS type %d\n",
+                                       bus);
+                }
+        }
+        if (!cards)
+                return 1;
+        p = cards;
+        while (p) {
+                initialized = 0;
+                if (!p->interface.statcallb) {
+                        /* Not yet registered.
+                         * Try to register and activate it.
+                         */
+                        added++;
+                        switch (p->bus) {
+                                case ACT2000_BUS_ISA:
+                                        if (act2000_isa_detect(p->port)) {
+                                                if (act2000_registercard(p))
+                                                        break;
+                                                if (act2000_isa_config_port(p, p->port)) {
+                                                        printk(KERN_WARNING
+                                                               "act2000: Could not request port 0x%04x\n",
+                                                               p->port);
+                                                        unregister_card(p);
+                                                        p->interface.statcallb = NULL;
+                                                        break;
+                                                }
+                                                if (act2000_isa_config_irq(p, p->irq)) {
+                                                        printk(KERN_INFO
+                                                               "act2000: No IRQ available, fallback to polling\n");
+                                                        /* Fall back to polled operation */
+                                                        p->irq = 0;
+                                                }
+                                                printk(KERN_INFO
+                                                       "act2000: ISA"
+                                                       "-type card at port "
+                                                       "0x%04x ",
+                                                       p->port);
+                                                if (p->irq)
+                                                        printk("irq %d\n", p->irq);
+                                                else
+                                                        printk("polled\n");
+                                                initialized = 1;
+                                        }
+                                        break;
+                                case ACT2000_BUS_MCA:
+                                case ACT2000_BUS_PCMCIA:
+                                default:
+                                        printk(KERN_WARNING
+                                               "act2000: addcard: Invalid BUS type %d\n",
+                                               p->bus);
+                        }
+                } else
+                        /* Card already initialized */
+                        initialized = 1;
+                if (initialized) {
+                        /* Init OK, next card ... */
+                        q = p;
+                        p = p->next;
+                } else {
+                        /* Init failed, remove card from list, free memory */
+                        printk(KERN_WARNING
+                               "act2000: Initialization of %s failed\n",
+                               p->interface.id);
+                        if (q) {
+                                q->next = p->next;
+                                kfree(p);
+                                p = q->next;
+                        } else {
+                                cards = p->next;
+                                kfree(p);
+                                p = cards;
+                        }
+                        failed++;
+                }
+        }
+        return (added - failed);
+}
+
+#define DRIVERNAME "IBM Active 2000 ISDN driver"
+
+static int __init act2000_init(void)
+{
+        printk(KERN_INFO "%s\n", DRIVERNAME);
+        if (!cards)
+                act2000_addcard(act_bus, act_port, act_irq, act_id);
+        if (!cards)
+                printk(KERN_INFO "act2000: No cards defined yet\n");
+        return 0;
+}
+
+static void __exit act2000_exit(void)
+{
+        act2000_card *card = cards;
+        act2000_card *last;
+        while (card) {
+                unregister_card(card);
+                del_timer(&card->ptimer);
+                card = card->next;
+        }
+        card = cards;
+        while (card) {
+                last = card;
+                card = card->next;
+                act2000_clear_msn(last);
+                kfree(last);
+        }
+        printk(KERN_INFO "%s unloaded\n", DRIVERNAME);
+}
+
+module_init(act2000_init);
+module_exit(act2000_exit);