Logo Search packages:      
Sourcecode: linux version File versions  Download package

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/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 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 < 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);

Generated by  Doxygen 1.6.0   Back to index