/* $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/slab.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,
  };
  
  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
  ", 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
  ",
  				       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
  ",
  			       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
  ",
  	       eazmsn[0],
  	       &eazmsn[1]);
  	return 0;
  }
  
  static void
  act2000_transmit(struct work_struct *work)
  {
  	struct act2000_card *card =
  		container_of(work, struct act2000_card, snd_tq);
  
  	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
  ", card->bus);
  	}
  }
  
  static void
  act2000_receive(struct work_struct *work)
  {
  	struct act2000_card *card =
  		container_of(work, struct act2000_card, poll_tq);
  
  	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
  ", card->bus);
  	}
  }
  
  static void
  act2000_poll(unsigned long data)
  {
  	act2000_card *card = (act2000_card *)data;
  	unsigned long flags;
  
  	act2000_receive(&card->poll_tq);
  	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
  ",
  				       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
  ",
  			       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
  ");
  			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
  ",
  		       skb_headroom(skb));
  		xmit_skb = alloc_skb(len + 19, GFP_ATOMIC);
  		if (!xmit_skb) {
  			printk(KERN_WARNING "act2000_sendbuf: Out of memory
  ");
  			return 0;
  		}
  		skb_reserve(xmit_skb, 19);
  		skb_copy_from_linear_data(skb, skb_put(xmit_skb, len), len);
  	} else {
  		xmit_skb = skb_clone(skb, GFP_ATOMIC);
  		if (!xmit_skb) {
  			printk(KERN_WARNING "act2000_sendbuf: Out of memory
  ");
  			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!
  ",
  	       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!
  ");
  	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!
  ");
  	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!
  ");
  	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 = kzalloc(sizeof(act2000_card), GFP_KERNEL))) {
  		printk(KERN_WARNING
  		       "act2000: (%s) Could not allocate card-struct.
  ", id);
  		return;
  	}
  	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, act2000_transmit);
  	INIT_WORK(&card->rcv_tq, actcapi_dispatch);
  	INIT_WORK(&card->poll_tq, act2000_receive);
  	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
  ",
  		       card->bus);
  		return -1;
  	}
  	if (!register_isdn(&card->interface)) {
  		printk(KERN_WARNING
  		       "act2000: Unable to register %s
  ",
  		       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
  ",
  		       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 < ARRAY_SIZE(act2000_isa_ports); i++)
  				if (act2000_isa_detect(act2000_isa_ports[i])) {
  					printk(KERN_INFO "act2000: Detected "
  					       "ISA card at port 0x%x
  ",
  					       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
  ", 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
  ",
  						       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
  ");
  						/* 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
  ", p->irq);
  					else
  						printk("polled
  ");
  					initialized = 1;
  				}
  				break;
  			case ACT2000_BUS_MCA:
  			case ACT2000_BUS_PCMCIA:
  			default:
  				printk(KERN_WARNING
  				       "act2000: addcard: Invalid BUS type %d
  ",
  				       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
  ",
  			       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
  ", DRIVERNAME);
  	if (!cards)
  		act2000_addcard(act_bus, act_port, act_irq, act_id);
  	if (!cards)
  		printk(KERN_INFO "act2000: No cards defined yet
  ");
  	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
  ", DRIVERNAME);
  }
  
  module_init(act2000_init);
  module_exit(act2000_exit);