![Julia Lawall](/assets/img/avatar_default.png)
Use del_timer_sync to ensure that the timer is stopped on all CPUs before the driver exists. This change was suggested by Thomas Gleixner. The semantic patch that makes this change is as follows: (http://coccinelle.lip6.fr/) // <smpl> @r@ declarer name module_exit; identifier ex; @@ module_exit(ex); @@ identifier r.ex; @@ ex(...) { <... - del_timer + del_timer_sync (...) ...> } // </smpl> Signed-off-by: Julia Lawall <Julia.Lawall@lip6.fr> Signed-off-by: David S. Miller <davem@davemloft.net>
814 lines
19 KiB
C
814 lines
19 KiB
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_sync(&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);
|