[mirror_ubuntu-artful-kernel.git] / drivers / isdn / act2000 / module.c

/* $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\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 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\n", 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\n", 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\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);
		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\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 = kzalloc(sizeof(act2000_card), GFP_KERNEL))) {
                printk(KERN_WARNING
		       "act2000: (%s) Could not allocate card-struct.\n", 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\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 < 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\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);
Commit	Line	Data
1da177e4 LT	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>
5a0e3ad6	19	#include <linux/slab.h>
1da177e4 LT	20	#include <linux/init.h>
	21
	22	static unsigned short act2000_isa_ports[] =
	23	{
	24	0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
	25	0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
	26	};
1da177e4 LT	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_param(act_bus, int, 0);
	44	module_param(act_port, int, 0);
	45	module_param(act_irq, int, 0);
	46	module_param(act_id, charp, 0);
	47
	48	static int act2000_addcard(int, int, int, char *);
	49
	50	static act2000_chan *
	51	find_channel(act2000_card *card, int channel)
	52	{
	53	if ((channel >= 0) && (channel < ACT2000_BCH))
	54	return &(card->bch[channel]);
	55	printk(KERN_WARNING "act2000: Invalid channel %d\n", channel);
	56	return NULL;
	57	}
	58
	59	/*
	60	* Free MSN list
	61	*/
	62	static void
	63	act2000_clear_msn(act2000_card *card)
	64	{
	65	struct msn_entry *p = card->msn_list;
	66	struct msn_entry *q;
	67	unsigned long flags;
	68
	69	spin_lock_irqsave(&card->lock, flags);
	70	card->msn_list = NULL;
	71	spin_unlock_irqrestore(&card->lock, flags);
	72	while (p) {
	73	q = p->next;
	74	kfree(p);
	75	p = q;
	76	}
	77	}
	78
	79	/*
	80	* Find an MSN entry in the list.
	81	* If ia5 != 0, return IA5-encoded EAZ, else
	82	* return a bitmask with corresponding bit set.
	83	*/
	84	static __u16
	85	act2000_find_msn(act2000_card card, char msn, int ia5)
	86	{
	87	struct msn_entry *p = card->msn_list;
	88	__u8 eaz = '0';
	89
	90	while (p) {
91	if (!strcmp(p->msn, msn)) {
92	eaz = p->eaz;
93	break;
94	}
95	p = p->next;
96	}
97	if (!ia5)
98	return (1 << (eaz - '0'));
99	else
100	return eaz;
101	}
102
103	/*
104	* Find an EAZ entry in the list.
105	* return a string with corresponding msn.
106	*/
107	char *
108	act2000_find_eaz(act2000_card *card, char eaz)
109	{
110	struct msn_entry *p = card->msn_list;
111
112	while (p) {
113	if (p->eaz == eaz)
114	return(p->msn);
115	p = p->next;
116	}
117	return("\0");
118	}
119
120	/*
121	* Add or delete an MSN to the MSN list
122	*
123	* First character of msneaz is EAZ, rest is MSN.
124	* If length of eazmsn is 1, delete that entry.
125	*/
126	static int
127	act2000_set_msn(act2000_card card, char eazmsn)
128	{
129	struct msn_entry *p = card->msn_list;
130	struct msn_entry *q = NULL;
131	unsigned long flags;
132	int i;
133
134	if (!strlen(eazmsn))
135	return 0;
136	if (strlen(eazmsn) > 16)
137	return -EINVAL;
138	for (i = 0; i < strlen(eazmsn); i++)
139	if (!isdigit(eazmsn[i]))
140	return -EINVAL;
141	if (strlen(eazmsn) == 1) {
142	/* Delete a single MSN */
143	while (p) {
144	if (p->eaz == eazmsn[0]) {
145	spin_lock_irqsave(&card->lock, flags);
146	if (q)
147	q->next = p->next;
148	else
149	card->msn_list = p->next;
150	spin_unlock_irqrestore(&card->lock, flags);
151	kfree(p);
152	printk(KERN_DEBUG
153	"Mapping for EAZ %c deleted\n",
154	eazmsn[0]);
155	return 0;
156	}
157	q = p;
158	p = p->next;
159	}
160	return 0;
161	}
162	/* Add a single MSN */
163	while (p) {
164	/* Found in list, replace MSN */
165	if (p->eaz == eazmsn[0]) {
166	spin_lock_irqsave(&card->lock, flags);
167	strcpy(p->msn, &eazmsn[1]);
168	spin_unlock_irqrestore(&card->lock, flags);
169	printk(KERN_DEBUG
170	"Mapping for EAZ %c changed to %s\n",
171	eazmsn[0],
172	&eazmsn[1]);
173	return 0;
174	}
175	p = p->next;
176	}
177	/* Not found in list, add new entry */
178	p = kmalloc(sizeof(msn_entry), GFP_KERNEL);
179	if (!p)
180	return -ENOMEM;
181	p->eaz = eazmsn[0];
182	strcpy(p->msn, &eazmsn[1]);
183	p->next = card->msn_list;
184	spin_lock_irqsave(&card->lock, flags);
185	card->msn_list = p;
186	spin_unlock_irqrestore(&card->lock, flags);
187	printk(KERN_DEBUG
188	"Mapping %c -> %s added\n",
189	eazmsn[0],
190	&eazmsn[1]);
191	return 0;
192	}
193
194	static void
c4028958	195	act2000_transmit(struct work_struct *work)
1da177e4	196	{
c4028958 DH	197	struct act2000_card *card =
	198	container_of(work, struct act2000_card, snd_tq);
	199
1da177e4 LT	200	switch (card->bus) {
	201	case ACT2000_BUS_ISA:
	202	act2000_isa_send(card);
	203	break;
	204	case ACT2000_BUS_PCMCIA:
	205	case ACT2000_BUS_MCA:
	206	default:
	207	printk(KERN_WARNING
	208	"act2000_transmit: Illegal bustype %d\n", card->bus);
	209	}
	210	}
	211
	212	static void
c4028958	213	act2000_receive(struct work_struct *work)
1da177e4	214	{
c4028958 DH	215	struct act2000_card *card =
	216	container_of(work, struct act2000_card, poll_tq);
	217
1da177e4 LT	218	switch (card->bus) {
	219	case ACT2000_BUS_ISA:
	220	act2000_isa_receive(card);
	221	break;
	222	case ACT2000_BUS_PCMCIA:
	223	case ACT2000_BUS_MCA:
	224	default:
	225	printk(KERN_WARNING
	226	"act2000_receive: Illegal bustype %d\n", card->bus);
	227	}
	228	}
	229
	230	static void
	231	act2000_poll(unsigned long data)
	232	{
	233	act2000_card * card = (act2000_card *)data;
	234	unsigned long flags;
	235
c4028958	236	act2000_receive(&card->poll_tq);
1da177e4 LT	237	spin_lock_irqsave(&card->lock, flags);
	238	mod_timer(&card->ptimer, jiffies+3);
	239	spin_unlock_irqrestore(&card->lock, flags);
	240	}
	241
	242	static int
	243	act2000_command(act2000_card * card, isdn_ctrl * c)
	244	{
	245	ulong a;
	246	act2000_chan *chan;
	247	act2000_cdef cdef;
	248	isdn_ctrl cmd;
	249	char tmp[17];
	250	int ret;
	251	unsigned long flags;
	252	void __user *arg;
	253
	254	switch (c->command) {
	255	case ISDN_CMD_IOCTL:
	256	memcpy(&a, c->parm.num, sizeof(ulong));
	257	arg = (void __user *)a;
	258	switch (c->arg) {
	259	case ACT2000_IOCTL_LOADBOOT:
	260	switch (card->bus) {
	261	case ACT2000_BUS_ISA:
	262	ret = act2000_isa_download(card,
	263	arg);
	264	if (!ret) {
	265	card->flags \|= ACT2000_FLAGS_LOADED;
	266	if (!(card->flags & ACT2000_FLAGS_IVALID)) {
	267	card->ptimer.expires = jiffies + 3;
	268	card->ptimer.function = act2000_poll;
	269	card->ptimer.data = (unsigned long)card;
	270	add_timer(&card->ptimer);
	271	}
	272	actcapi_manufacturer_req_errh(card);
	273	}
	274	break;
	275	default:
	276	printk(KERN_WARNING
	277	"act2000: Illegal BUS type %d\n",
	278	card->bus);
	279	ret = -EIO;
	280	}
	281	return ret;
	282	case ACT2000_IOCTL_SETPROTO:
	283	card->ptype = a?ISDN_PTYPE_EURO:ISDN_PTYPE_1TR6;
	284	if (!(card->flags & ACT2000_FLAGS_RUNNING))
	285	return 0;
	286	actcapi_manufacturer_req_net(card);
	287	return 0;
	288	case ACT2000_IOCTL_SETMSN:
	289	if (copy_from_user(tmp, arg,
	290	sizeof(tmp)))
	291	return -EFAULT;
	292	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:
eaa0ff15	313	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	342	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	350	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	351	return -ENODEV;
	352	return 0;
	353	case ISDN_CMD_HANGUP:
eaa0ff15	354	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	369	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	389	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	397	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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:
eaa0ff15	404	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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
	419	static int
	420	act2000_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);
d626f62b	445	skb_copy_from_linear_data(skb, skb_put(xmit_skb, len), len);
1da177e4 LT	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 */
	473	static int
	474	act2000_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	*/
	492	static inline act2000_card *
	493	act2000_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	*/
	508	static int
	509	if_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
521	static int
522	if_writecmd(const u_char __user *buf, int len, int id, int channel)
523	{
524	act2000_card *card = act2000_findcard(id);
525
526	if (card) {
eaa0ff15	527	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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
	536	static int
	537	if_readstatus(u_char __user * buf, int len, int id, int channel)
	538	{
	539	act2000_card *card = act2000_findcard(id);
	540
	541	if (card) {
eaa0ff15	542	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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
	551	static int
	552	if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
	553	{
	554	act2000_card *card = act2000_findcard(id);
	555
	556	if (card) {
eaa0ff15	557	if (!(card->flags & ACT2000_FLAGS_RUNNING))
1da177e4 LT	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	*/
	571	static void
	572	act2000_alloccard(int bus, int port, int irq, char *id)
	573	{
	574	int i;
	575	act2000_card *card;
41f96935	576	if (!(card = kzalloc(sizeof(act2000_card), GFP_KERNEL))) {
1da177e4 LT	577	printk(KERN_WARNING
	578	"act2000: (%s) Could not allocate card-struct.\n", id);
	579	return;
	580	}
1da177e4 LT	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);
c4028958 DH	586	INIT_WORK(&card->snd_tq, act2000_transmit);
	587	INIT_WORK(&card->rcv_tq, actcapi_dispatch);
	588	INIT_WORK(&card->poll_tq, act2000_receive);
1da177e4 LT	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	*/
	622	static int
	623	act2000_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
	647	static void
	648	unregister_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
669	static int
670	act2000_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) {
ba2d6ccb KK	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);
1da177e4 LT	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
783	static 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
793	static 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
812	module_init(act2000_init);
813	module_exit(act2000_exit);