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

icn.c

/* $Id: icn.c,v 1.65.6.8 2001/09/23 22:24:55 kai Exp $
 *
 * ISDN low-level module for the ICN active ISDN-Card.
 *
 * Copyright 1994,95,96 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.
 *
 */

#include "icn.h"
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>

static int portbase = ICN_BASEADDR;
static unsigned long membase = ICN_MEMADDR;
static char *icn_id = "\0";
static char *icn_id2 = "\0";

MODULE_DESCRIPTION("ISDN4Linux: Driver for ICN active ISDN card");
MODULE_AUTHOR("Fritz Elfert");
MODULE_LICENSE("GPL");
module_param(portbase, int, 0);
MODULE_PARM_DESC(portbase, "Port address of first card");
module_param(membase, ulong, 0);
MODULE_PARM_DESC(membase, "Shared memory address of all cards");
module_param(icn_id, charp, 0);
MODULE_PARM_DESC(icn_id, "ID-String of first card");
module_param(icn_id2, charp, 0);
MODULE_PARM_DESC(icn_id2, "ID-String of first card, second S0 (4B only)");

/*
 * Verbose bootcode- and protocol-downloading.
 */
#undef BOOT_DEBUG

/*
 * Verbose Shmem-Mapping.
 */
#undef MAP_DEBUG

static char
*revision = "$Revision: 1.65.6.8 $";

static int icn_addcard(int, char *, char *);

/*
 * Free send-queue completely.
 * Parameter:
 *   card   = pointer to card struct
 *   channel = channel number
 */
static void
icn_free_queue(icn_card * card, int channel)
{
      struct sk_buff_head *queue = &card->spqueue[channel];
      struct sk_buff *skb;

      skb_queue_purge(queue);
      card->xlen[channel] = 0;
      card->sndcount[channel] = 0;
      if ((skb = card->xskb[channel])) {
            card->xskb[channel] = NULL;
            dev_kfree_skb(skb);
      }
}

/* Put a value into a shift-register, highest bit first.
 * Parameters:
 *            port     = port for output (bit 0 is significant)
 *            val      = value to be output
 *            firstbit = Bit-Number of highest bit
 *            bitcount = Number of bits to output
 */
static inline void
icn_shiftout(unsigned short port,
           unsigned long val,
           int firstbit,
           int bitcount)
{

      register u_char s;
      register u_char c;

      for (s = firstbit, c = bitcount; c > 0; s--, c--)
            OUTB_P((u_char) ((val >> s) & 1) ? 0xff : 0, port);
}

/*
 * disable a cards shared memory
 */
static inline void
icn_disable_ram(icn_card * card)
{
      OUTB_P(0, ICN_MAPRAM);
}

/*
 * enable a cards shared memory
 */
static inline void
icn_enable_ram(icn_card * card)
{
      OUTB_P(0xff, ICN_MAPRAM);
}

/*
 * Map a cards channel0 (Bank0/Bank8) or channel1 (Bank4/Bank12)
 *
 * must called with holding the devlock
 */
static inline void
icn_map_channel(icn_card * card, int channel)
{
#ifdef MAP_DEBUG
      printk(KERN_DEBUG "icn_map_channel %d %d\n", dev.channel, channel);
#endif
      if ((channel == dev.channel) && (card == dev.mcard))
            return;
      if (dev.mcard)
            icn_disable_ram(dev.mcard);
      icn_shiftout(ICN_BANK, chan2bank[channel], 3, 4);     /* Select Bank          */
      icn_enable_ram(card);
      dev.mcard = card;
      dev.channel = channel;
#ifdef MAP_DEBUG
      printk(KERN_DEBUG "icn_map_channel done\n");
#endif
}

/*
 * Lock a cards channel.
 * Return 0 if requested card/channel is unmapped (failure).
 * Return 1 on success.
 *
 * must called with holding the devlock
 */
static inline int
icn_lock_channel(icn_card * card, int channel)
{
      register int retval;

#ifdef MAP_DEBUG
      printk(KERN_DEBUG "icn_lock_channel %d\n", channel);
#endif
      if ((dev.channel == channel) && (card == dev.mcard)) {
            dev.chanlock++;
            retval = 1;
#ifdef MAP_DEBUG
            printk(KERN_DEBUG "icn_lock_channel %d OK\n", channel);
#endif
      } else {
            retval = 0;
#ifdef MAP_DEBUG
            printk(KERN_DEBUG "icn_lock_channel %d FAILED, dc=%d\n", channel, dev.channel);
#endif
      }
      return retval;
}

/*
 * Release current card/channel lock
 *
 * must called with holding the devlock
 */
static inline void
__icn_release_channel(void)
{
#ifdef MAP_DEBUG
      printk(KERN_DEBUG "icn_release_channel l=%d\n", dev.chanlock);
#endif
      if (dev.chanlock > 0)
            dev.chanlock--;
}

/*
 * Release current card/channel lock
 */
static inline void
icn_release_channel(void)
{
      ulong flags;

      spin_lock_irqsave(&dev.devlock, flags);
      __icn_release_channel();
      spin_unlock_irqrestore(&dev.devlock, flags);
}

/*
 * Try to map and lock a cards channel.
 * Return 1 on success, 0 on failure.
 */
static inline int
icn_trymaplock_channel(icn_card * card, int channel)
{
      ulong flags;

#ifdef MAP_DEBUG
      printk(KERN_DEBUG "trymaplock c=%d dc=%d l=%d\n", channel, dev.channel,
             dev.chanlock);
#endif
      spin_lock_irqsave(&dev.devlock, flags);
      if ((!dev.chanlock) ||
          ((dev.channel == channel) && (dev.mcard == card))) {
            dev.chanlock++;
            icn_map_channel(card, channel);
            spin_unlock_irqrestore(&dev.devlock, flags);
#ifdef MAP_DEBUG
            printk(KERN_DEBUG "trymaplock %d OK\n", channel);
#endif
            return 1;
      }
      spin_unlock_irqrestore(&dev.devlock, flags);
#ifdef MAP_DEBUG
      printk(KERN_DEBUG "trymaplock %d FAILED\n", channel);
#endif
      return 0;
}

/*
 * Release current card/channel lock,
 * then map same or other channel without locking.
 */
static inline void
icn_maprelease_channel(icn_card * card, int channel)
{
      ulong flags;

#ifdef MAP_DEBUG
      printk(KERN_DEBUG "map_release c=%d l=%d\n", channel, dev.chanlock);
#endif
      spin_lock_irqsave(&dev.devlock, flags);
      if (dev.chanlock > 0)
            dev.chanlock--;
      if (!dev.chanlock)
            icn_map_channel(card, channel);
      spin_unlock_irqrestore(&dev.devlock, flags);
}

/* Get Data from the B-Channel, assemble fragmented packets and put them
 * into receive-queue. Wake up any B-Channel-reading processes.
 * This routine is called via timer-callback from icn_pollbchan().
 */

static void
icn_pollbchan_receive(int channel, icn_card * card)
{
      int mch = channel + ((card->secondhalf) ? 2 : 0);
      int eflag;
      int cnt;
      struct sk_buff *skb;

      if (icn_trymaplock_channel(card, mch)) {
            while (rbavl) {
                  cnt = readb(&rbuf_l);
                  if ((card->rcvidx[channel] + cnt) > 4000) {
                        printk(KERN_WARNING
                               "icn: (%s) bogus packet on ch%d, dropping.\n",
                               CID,
                               channel + 1);
                        card->rcvidx[channel] = 0;
                        eflag = 0;
                  } else {
                        memcpy_fromio(&card->rcvbuf[channel][card->rcvidx[channel]],
                                    &rbuf_d, cnt);
                        card->rcvidx[channel] += cnt;
                        eflag = readb(&rbuf_f);
                  }
                  rbnext;
                  icn_maprelease_channel(card, mch & 2);
                  if (!eflag) {
                        if ((cnt = card->rcvidx[channel])) {
                              if (!(skb = dev_alloc_skb(cnt))) {
                                    printk(KERN_WARNING "icn: receive out of memory\n");
                                    break;
                              }
                              memcpy(skb_put(skb, cnt), card->rcvbuf[channel], cnt);
                              card->rcvidx[channel] = 0;
                              card->interface.rcvcallb_skb(card->myid, channel, skb);
                        }
                  }
                  if (!icn_trymaplock_channel(card, mch))
                        break;
            }
            icn_maprelease_channel(card, mch & 2);
      }
}

/* Send data-packet to B-Channel, split it up into fragments of
 * ICN_FRAGSIZE length. If last fragment is sent out, signal
 * success to upper layers via statcallb with ISDN_STAT_BSENT argument.
 * This routine is called via timer-callback from icn_pollbchan() or
 * directly from icn_sendbuf().
 */

static void
icn_pollbchan_send(int channel, icn_card * card)
{
      int mch = channel + ((card->secondhalf) ? 2 : 0);
      int cnt;
      unsigned long flags;
      struct sk_buff *skb;
      isdn_ctrl cmd;

      if (!(card->sndcount[channel] || card->xskb[channel] ||
            !skb_queue_empty(&card->spqueue[channel])))
            return;
      if (icn_trymaplock_channel(card, mch)) {
            while (sbfree && 
                   (card->sndcount[channel] ||
                  !skb_queue_empty(&card->spqueue[channel]) ||
                  card->xskb[channel])) {
                  spin_lock_irqsave(&card->lock, flags);
                  if (card->xmit_lock[channel]) {
                        spin_unlock_irqrestore(&card->lock, flags);
                        break;
                  }
                  card->xmit_lock[channel]++;
                  spin_unlock_irqrestore(&card->lock, flags);
                  skb = card->xskb[channel];
                  if (!skb) {
                        skb = skb_dequeue(&card->spqueue[channel]);
                        if (skb) {
                              /* Pop ACK-flag off skb.
                               * Store length to xlen.
                               */
                              if (*(skb_pull(skb,1)))
                                    card->xlen[channel] = skb->len;
                              else
                                    card->xlen[channel] = 0;
                        }
                  }
                  if (!skb)
                        break;
                  if (skb->len > ICN_FRAGSIZE) {
                        writeb(0xff, &sbuf_f);
                        cnt = ICN_FRAGSIZE;
                  } else {
                        writeb(0x0, &sbuf_f);
                        cnt = skb->len;
                  }
                  writeb(cnt, &sbuf_l);
                  memcpy_toio(&sbuf_d, skb->data, cnt);
                  skb_pull(skb, cnt);
                  sbnext; /* switch to next buffer        */
                  icn_maprelease_channel(card, mch & 2);
                  spin_lock_irqsave(&card->lock, flags);
                  card->sndcount[channel] -= cnt;
                  if (!skb->len) {
                        if (card->xskb[channel])
                              card->xskb[channel] = NULL;
                        card->xmit_lock[channel] = 0;
                        spin_unlock_irqrestore(&card->lock, flags);
                        dev_kfree_skb(skb);
                        if (card->xlen[channel]) {
                              cmd.command = ISDN_STAT_BSENT;
                              cmd.driver = card->myid;
                              cmd.arg = channel;
                              cmd.parm.length = card->xlen[channel];
                              card->interface.statcallb(&cmd);
                        }
                  } else {
                        card->xskb[channel] = skb;
                        card->xmit_lock[channel] = 0;
                        spin_unlock_irqrestore(&card->lock, flags);
                  }
                  if (!icn_trymaplock_channel(card, mch))
                        break;
            }
            icn_maprelease_channel(card, mch & 2);
      }
}

/* Send/Receive Data to/from the B-Channel.
 * This routine is called via timer-callback.
 * It schedules itself while any B-Channel is open.
 */

static void
icn_pollbchan(unsigned long data)
{
      icn_card *card = (icn_card *) data;
      unsigned long flags;

      if (card->flags & ICN_FLAGS_B1ACTIVE) {
            icn_pollbchan_receive(0, card);
            icn_pollbchan_send(0, card);
      }
      if (card->flags & ICN_FLAGS_B2ACTIVE) {
            icn_pollbchan_receive(1, card);
            icn_pollbchan_send(1, card);
      }
      if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE)) {
            /* schedule b-channel polling again */
            spin_lock_irqsave(&card->lock, flags);
            mod_timer(&card->rb_timer, jiffies+ICN_TIMER_BCREAD);
            card->flags |= ICN_FLAGS_RBTIMER;
            spin_unlock_irqrestore(&card->lock, flags);
      } else
            card->flags &= ~ICN_FLAGS_RBTIMER;
}

typedef struct icn_stat {
      char *statstr;
      int command;
      int action;
} icn_stat;
/* *INDENT-OFF* */
static icn_stat icn_stat_table[] =
{
      {"BCON_",          ISDN_STAT_BCONN, 1},   /* B-Channel connected        */
      {"BDIS_",          ISDN_STAT_BHUP,  2},   /* B-Channel disconnected     */
      /*
      ** add d-channel connect and disconnect support to link-level
      */
      {"DCON_",          ISDN_STAT_DCONN, 10},  /* D-Channel connected        */
      {"DDIS_",          ISDN_STAT_DHUP,  11},  /* D-Channel disconnected     */
      {"DCAL_I",         ISDN_STAT_ICALL, 3},   /* Incoming call dialup-line  */
      {"DSCA_I",         ISDN_STAT_ICALL, 3},   /* Incoming call 1TR6-SPV     */
      {"FCALL",          ISDN_STAT_ICALL, 4},   /* Leased line connection up  */
      {"CIF",            ISDN_STAT_CINF,  5},   /* Charge-info, 1TR6-type     */
      {"AOC",            ISDN_STAT_CINF,  6},   /* Charge-info, DSS1-type     */
      {"CAU",            ISDN_STAT_CAUSE, 7},   /* Cause code                 */
      {"TEI OK",         ISDN_STAT_RUN,   0},   /* Card connected to wallplug */
      {"E_L1: ACT FAIL", ISDN_STAT_BHUP,  8},   /* Layer-1 activation failed  */
      {"E_L2: DATA LIN", ISDN_STAT_BHUP,  8},   /* Layer-2 data link lost     */
      {"E_L1: ACTIVATION FAILED",
                                 ISDN_STAT_BHUP,  8}, /* Layer-1 activation failed  */
      {NULL, 0, -1}
};
/* *INDENT-ON* */


/*
 * Check Statusqueue-Pointer from isdn-cards.
 * If there are new status-replies from the interface, check
 * them against B-Channel-connects/disconnects and set flags accordingly.
 * Wake-Up any processes, who are reading the status-device.
 * If there are B-Channels open, initiate a timer-callback to
 * icn_pollbchan().
 * This routine is called periodically via timer.
 */

static void
icn_parse_status(u_char * status, int channel, icn_card * card)
{
      icn_stat *s = icn_stat_table;
      int action = -1;
      unsigned long flags;
      isdn_ctrl cmd;

      while (s->statstr) {
            if (!strncmp(status, s->statstr, strlen(s->statstr))) {
                  cmd.command = s->command;
                  action = s->action;
                  break;
            }
            s++;
      }
      if (action == -1)
            return;
      cmd.driver = card->myid;
      cmd.arg = channel;
      switch (action) {
            case 11:
                  spin_lock_irqsave(&card->lock, flags);
                  icn_free_queue(card,channel);
                  card->rcvidx[channel] = 0;

                  if (card->flags & 
                      ((channel)?ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE)) {
                        
                        isdn_ctrl ncmd;
                        
                        card->flags &= ~((channel)?
                                     ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE);
                        
                        memset(&ncmd, 0, sizeof(ncmd));
                        
                        ncmd.driver = card->myid;
                        ncmd.arg = channel;
                        ncmd.command = ISDN_STAT_BHUP;
                        spin_unlock_irqrestore(&card->lock, flags);
                        card->interface.statcallb(&cmd);
                  } else
                        spin_unlock_irqrestore(&card->lock, flags);
                  break;
            case 1:
                  spin_lock_irqsave(&card->lock, flags);
                  icn_free_queue(card,channel);
                  card->flags |= (channel) ?
                      ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE;
                  spin_unlock_irqrestore(&card->lock, flags);
                  break;
            case 2:
                  spin_lock_irqsave(&card->lock, flags);
                  card->flags &= ~((channel) ?
                        ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE);
                  icn_free_queue(card, channel);
                  card->rcvidx[channel] = 0;
                  spin_unlock_irqrestore(&card->lock, flags);
                  break;
            case 3:
                  {
                        char *t = status + 6;
                        char *s = strchr(t, ',');

                        *s++ = '\0';
                        strlcpy(cmd.parm.setup.phone, t,
                              sizeof(cmd.parm.setup.phone));
                        s = strchr(t = s, ',');
                        *s++ = '\0';
                        if (!strlen(t))
                              cmd.parm.setup.si1 = 0;
                        else
                              cmd.parm.setup.si1 =
                                  simple_strtoul(t, NULL, 10);
                        s = strchr(t = s, ',');
                        *s++ = '\0';
                        if (!strlen(t))
                              cmd.parm.setup.si2 = 0;
                        else
                              cmd.parm.setup.si2 =
                                  simple_strtoul(t, NULL, 10);
                        strlcpy(cmd.parm.setup.eazmsn, s,
                              sizeof(cmd.parm.setup.eazmsn));
                  }
                  cmd.parm.setup.plan = 0;
                  cmd.parm.setup.screen = 0;
                  break;
            case 4:
                  sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid);
                  sprintf(cmd.parm.setup.eazmsn, "%d", channel + 1);
                  cmd.parm.setup.si1 = 7;
                  cmd.parm.setup.si2 = 0;
                  cmd.parm.setup.plan = 0;
                  cmd.parm.setup.screen = 0;
                  break;
            case 5:
                  strlcpy(cmd.parm.num, status + 3, sizeof(cmd.parm.num));
                  break;
            case 6:
                  snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%d",
                       (int) simple_strtoul(status + 7, NULL, 16));
                  break;
            case 7:
                  status += 3;
                  if (strlen(status) == 4)
                        snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%s%c%c",
                             status + 2, *status, *(status + 1));
                  else
                        strlcpy(cmd.parm.num, status + 1, sizeof(cmd.parm.num));
                  break;
            case 8:
                  spin_lock_irqsave(&card->lock, flags);
                  card->flags &= ~ICN_FLAGS_B1ACTIVE;
                  icn_free_queue(card, 0);
                  card->rcvidx[0] = 0;
                  spin_unlock_irqrestore(&card->lock, flags);
                  cmd.arg = 0;
                  cmd.driver = card->myid;
                  card->interface.statcallb(&cmd);
                  cmd.command = ISDN_STAT_DHUP;
                  cmd.arg = 0;
                  cmd.driver = card->myid;
                  card->interface.statcallb(&cmd);
                  cmd.command = ISDN_STAT_BHUP;
                  spin_lock_irqsave(&card->lock, flags);
                  card->flags &= ~ICN_FLAGS_B2ACTIVE;
                  icn_free_queue(card, 1);
                  card->rcvidx[1] = 0;
                  spin_unlock_irqrestore(&card->lock, flags);
                  cmd.arg = 1;
                  cmd.driver = card->myid;
                  card->interface.statcallb(&cmd);
                  cmd.command = ISDN_STAT_DHUP;
                  cmd.arg = 1;
                  cmd.driver = card->myid;
                  break;
      }
      card->interface.statcallb(&cmd);
      return;
}

static void
icn_putmsg(icn_card * card, unsigned char c)
{
      ulong flags;

      spin_lock_irqsave(&card->lock, flags);
      *card->msg_buf_write++ = (c == 0xff) ? '\n' : c;
      if (card->msg_buf_write == card->msg_buf_read) {
            if (++card->msg_buf_read > card->msg_buf_end)
                  card->msg_buf_read = card->msg_buf;
      }
      if (card->msg_buf_write > card->msg_buf_end)
            card->msg_buf_write = card->msg_buf;
      spin_unlock_irqrestore(&card->lock, flags);
}

static void
icn_polldchan(unsigned long data)
{
      icn_card *card = (icn_card *) data;
      int mch = card->secondhalf ? 2 : 0;
      int avail = 0;
      int left;
      u_char c;
      int ch;
      unsigned long flags;
      int i;
      u_char *p;
      isdn_ctrl cmd;

      if (icn_trymaplock_channel(card, mch)) {
            avail = msg_avail;
            for (left = avail, i = readb(&msg_o); left > 0; i++, left--) {
                  c = readb(&dev.shmem->comm_buffers.iopc_buf[i & 0xff]);
                  icn_putmsg(card, c);
                  if (c == 0xff) {
                        card->imsg[card->iptr] = 0;
                        card->iptr = 0;
                        if (card->imsg[0] == '0' && card->imsg[1] >= '0' &&
                            card->imsg[1] <= '2' && card->imsg[2] == ';') {
                              ch = (card->imsg[1] - '0') - 1;
                              p = &card->imsg[3];
                              icn_parse_status(p, ch, card);
                        } else {
                              p = card->imsg;
                              if (!strncmp(p, "DRV1.", 5)) {
                                    u_char vstr[10];
                                    u_char *q = vstr;

                                    printk(KERN_INFO "icn: (%s) %s\n", CID, p);
                                    if (!strncmp(p + 7, "TC", 2)) {
                                          card->ptype = ISDN_PTYPE_1TR6;
                                          card->interface.features |= ISDN_FEATURE_P_1TR6;
                                          printk(KERN_INFO
                                                 "icn: (%s) 1TR6-Protocol loaded and running\n", CID);
                                    }
                                    if (!strncmp(p + 7, "EC", 2)) {
                                          card->ptype = ISDN_PTYPE_EURO;
                                          card->interface.features |= ISDN_FEATURE_P_EURO;
                                          printk(KERN_INFO
                                                 "icn: (%s) Euro-Protocol loaded and running\n", CID);
                                    }
                                    p = strstr(card->imsg, "BRV") + 3;
                                    while (*p) {
                                          if (*p >= '0' && *p <= '9')
                                                *q++ = *p;
                                          p++;
                                    }
                                    *q = '\0';
                                    strcat(vstr, "000");
                                    vstr[3] = '\0';
                                    card->fw_rev = (int) simple_strtoul(vstr, NULL, 10);
                                    continue;

                              }
                        }
                  } else {
                        card->imsg[card->iptr] = c;
                        if (card->iptr < 59)
                              card->iptr++;
                  }
            }
            writeb((readb(&msg_o) + avail) & 0xff, &msg_o);
            icn_release_channel();
      }
      if (avail) {
            cmd.command = ISDN_STAT_STAVAIL;
            cmd.driver = card->myid;
            cmd.arg = avail;
            card->interface.statcallb(&cmd);
      }
      spin_lock_irqsave(&card->lock, flags);
      if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE))
            if (!(card->flags & ICN_FLAGS_RBTIMER)) {
                  /* schedule b-channel polling */
                  card->flags |= ICN_FLAGS_RBTIMER;
                  del_timer(&card->rb_timer);
                  card->rb_timer.function = icn_pollbchan;
                  card->rb_timer.data = (unsigned long) card;
                  card->rb_timer.expires = jiffies + ICN_TIMER_BCREAD;
                  add_timer(&card->rb_timer);
            }
      /* schedule again */
      mod_timer(&card->st_timer, jiffies+ICN_TIMER_DCREAD);
      spin_unlock_irqrestore(&card->lock, flags);
}

/* Append a packet to the transmit buffer-queue.
 * Parameters:
 *   channel = Number of B-channel
 *   skb     = pointer to sk_buff
 *   card    = pointer to card-struct
 * Return:
 *   Number of bytes transferred, -E??? on error
 */

static int
icn_sendbuf(int channel, int ack, struct sk_buff *skb, icn_card * card)
{
      int len = skb->len;
      unsigned long flags;
      struct sk_buff *nskb;

      if (len > 4000) {
            printk(KERN_WARNING
                   "icn: Send packet too large\n");
            return -EINVAL;
      }
      if (len) {
            if (!(card->flags & (channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE))
                  return 0;
            if (card->sndcount[channel] > ICN_MAX_SQUEUE)
                  return 0;
            #warning TODO test headroom or use skb->nb to flag ACK
            nskb = skb_clone(skb, GFP_ATOMIC);
            if (nskb) {
                  /* Push ACK flag as one
                   * byte in front of data.
                   */
                  *(skb_push(nskb, 1)) = ack?1:0;
                  skb_queue_tail(&card->spqueue[channel], nskb);
                  dev_kfree_skb(skb);
            } else
                  len = 0;
            spin_lock_irqsave(&card->lock, flags);
            card->sndcount[channel] += len;
            spin_unlock_irqrestore(&card->lock, flags);
      }
      return len;
}

/*
 * Check card's status after starting the bootstrap loader.
 * On entry, the card's shared memory has already to be mapped.
 * Return:
 *   0 on success (Boot loader ready)
 *   -EIO on failure (timeout)
 */
static int
icn_check_loader(int cardnumber)
{
      int timer = 0;

      while (1) {
#ifdef BOOT_DEBUG
            printk(KERN_DEBUG "Loader %d ?\n", cardnumber);
#endif
            if (readb(&dev.shmem->data_control.scns) ||
                readb(&dev.shmem->data_control.scnr)) {
                  if (timer++ > 5) {
                        printk(KERN_WARNING
                               "icn: Boot-Loader %d timed out.\n",
                               cardnumber);
                        icn_release_channel();
                        return -EIO;
                  }
#ifdef BOOT_DEBUG
                  printk(KERN_DEBUG "Loader %d TO?\n", cardnumber);
#endif
                  msleep_interruptible(ICN_BOOT_TIMEOUT1);
            } else {
#ifdef BOOT_DEBUG
                  printk(KERN_DEBUG "Loader %d OK\n", cardnumber);
#endif
                  icn_release_channel();
                  return 0;
            }
      }
}

/* Load the boot-code into the interface-card's memory and start it.
 * Always called from user-process.
 *
 * Parameters:
 *            buffer = pointer to packet
 * Return:
 *        0 if successfully loaded
 */

#ifdef BOOT_DEBUG
#define SLEEP(sec) { \
int slsec = sec; \
  printk(KERN_DEBUG "SLEEP(%d)\n",slsec); \
  while (slsec) { \
    msleep_interruptible(1000); \
    slsec--; \
  } \
}
#else
#define SLEEP(sec)
#endif

static int
icn_loadboot(u_char __user * buffer, icn_card * card)
{
      int ret;
      u_char *codebuf;
      unsigned long flags;

#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "icn_loadboot called, buffaddr=%08lx\n", (ulong) buffer);
#endif
      if (!(codebuf = kmalloc(ICN_CODE_STAGE1, GFP_KERNEL))) {
            printk(KERN_WARNING "icn: Could not allocate code buffer\n");
            ret = -ENOMEM;
            goto out;
      }
      if (copy_from_user(codebuf, buffer, ICN_CODE_STAGE1)) {
            ret = -EFAULT;
            goto out_kfree;
      }
      if (!card->rvalid) {
            if (!request_region(card->port, ICN_PORTLEN, card->regname)) {
                  printk(KERN_WARNING
                         "icn: (%s) ports 0x%03x-0x%03x in use.\n",
                         CID,
                         card->port,
                         card->port + ICN_PORTLEN);
                  ret = -EBUSY;
                  goto out_kfree;
            }
            card->rvalid = 1;
            if (card->doubleS0)
                  card->other->rvalid = 1;
      }
      if (!dev.mvalid) {
            if (!request_mem_region(dev.memaddr, 0x4000, "icn-isdn (all cards)")) {
                  printk(KERN_WARNING
                         "icn: memory at 0x%08lx in use.\n", dev.memaddr);
                  ret = -EBUSY;
                  goto out_kfree;
            }
            dev.shmem = ioremap(dev.memaddr, 0x4000);
            dev.mvalid = 1;
      }
      OUTB_P(0, ICN_RUN);     /* Reset Controller */
      OUTB_P(0, ICN_MAPRAM);  /* Disable RAM      */
      icn_shiftout(ICN_CFG, 0x0f, 3, 4);  /* Windowsize= 16k  */
      icn_shiftout(ICN_CFG, dev.memaddr, 23, 10);     /* Set RAM-Addr.    */
#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "shmem=%08lx\n", dev.memaddr);
#endif
      SLEEP(1);
#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "Map Bank 0\n");
#endif
      spin_lock_irqsave(&dev.devlock, flags);
      icn_map_channel(card, 0);     /* Select Bank 0    */
      icn_lock_channel(card, 0);    /* Lock Bank 0      */
      spin_unlock_irqrestore(&dev.devlock, flags);
      SLEEP(1);
      memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1);     /* Copy code        */
#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "Bootloader transferred\n");
#endif
      if (card->doubleS0) {
            SLEEP(1);
#ifdef BOOT_DEBUG
            printk(KERN_DEBUG "Map Bank 8\n");
#endif
            spin_lock_irqsave(&dev.devlock, flags);
            __icn_release_channel();
            icn_map_channel(card, 2);     /* Select Bank 8   */
            icn_lock_channel(card, 2);    /* Lock Bank 8     */
            spin_unlock_irqrestore(&dev.devlock, flags);
            SLEEP(1);
            memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1);     /* Copy code        */
#ifdef BOOT_DEBUG
            printk(KERN_DEBUG "Bootloader transferred\n");
#endif
      }
      SLEEP(1);
      OUTB_P(0xff, ICN_RUN);  /* Start Boot-Code */
      if ((ret = icn_check_loader(card->doubleS0 ? 2 : 1))) {
            goto out_kfree;
      }
      if (!card->doubleS0) {
            ret = 0;
            goto out_kfree;
      }
      /* reached only, if we have a Double-S0-Card */
#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "Map Bank 0\n");
#endif
      spin_lock_irqsave(&dev.devlock, flags);
      icn_map_channel(card, 0);     /* Select Bank 0   */
      icn_lock_channel(card, 0);    /* Lock Bank 0     */
      spin_unlock_irqrestore(&dev.devlock, flags);
      SLEEP(1);
      ret = (icn_check_loader(1));

 out_kfree:
      kfree(codebuf);
 out:
      return ret;
}

static int
icn_loadproto(u_char __user * buffer, icn_card * card)
{
      register u_char __user *p = buffer;
      u_char codebuf[256];
      uint left = ICN_CODE_STAGE2;
      uint cnt;
      int timer;
      unsigned long flags;

#ifdef BOOT_DEBUG
      printk(KERN_DEBUG "icn_loadproto called\n");
#endif
      if (!access_ok(VERIFY_READ, buffer, ICN_CODE_STAGE2))
            return -EFAULT;
      timer = 0;
      spin_lock_irqsave(&dev.devlock, flags);
      if (card->secondhalf) {
            icn_map_channel(card, 2);
            icn_lock_channel(card, 2);
      } else {
            icn_map_channel(card, 0);
            icn_lock_channel(card, 0);
      }
      spin_unlock_irqrestore(&dev.devlock, flags);
      while (left) {
            if (sbfree) {   /* If there is a free buffer...  */
                  cnt = left;
                  if (cnt > 256)
                        cnt = 256;
                  if (copy_from_user(codebuf, p, cnt)) {
                        icn_maprelease_channel(card, 0);
                        return -EFAULT;
                  }
                  memcpy_toio(&sbuf_l, codebuf, cnt); /* copy data                     */
                  sbnext; /* switch to next buffer         */
                  p += cnt;
                  left -= cnt;
                  timer = 0;
            } else {
#ifdef BOOT_DEBUG
                  printk(KERN_DEBUG "boot 2 !sbfree\n");
#endif
                  if (timer++ > 5) {
                        icn_maprelease_channel(card, 0);
                        return -EIO;
                  }
                  schedule_timeout_interruptible(10);
            }
      }
      writeb(0x20, &sbuf_n);
      timer = 0;
      while (1) {
            if (readb(&cmd_o) || readb(&cmd_i)) {
#ifdef BOOT_DEBUG
                  printk(KERN_DEBUG "Proto?\n");
#endif
                  if (timer++ > 5) {
                        printk(KERN_WARNING
                               "icn: (%s) Protocol timed out.\n",
                               CID);
#ifdef BOOT_DEBUG
                        printk(KERN_DEBUG "Proto TO!\n");
#endif
                        icn_maprelease_channel(card, 0);
                        return -EIO;
                  }
#ifdef BOOT_DEBUG
                  printk(KERN_DEBUG "Proto TO?\n");
#endif
                  msleep_interruptible(ICN_BOOT_TIMEOUT1);
            } else {
                  if ((card->secondhalf) || (!card->doubleS0)) {
#ifdef BOOT_DEBUG
                        printk(KERN_DEBUG "Proto loaded, install poll-timer %d\n",
                               card->secondhalf);
#endif
                        spin_lock_irqsave(&card->lock, flags);
                        init_timer(&card->st_timer);
                        card->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
                        card->st_timer.function = icn_polldchan;
                        card->st_timer.data = (unsigned long) card;
                        add_timer(&card->st_timer);
                        card->flags |= ICN_FLAGS_RUNNING;
                        if (card->doubleS0) {
                              init_timer(&card->other->st_timer);
                              card->other->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
                              card->other->st_timer.function = icn_polldchan;
                              card->other->st_timer.data = (unsigned long) card->other;
                              add_timer(&card->other->st_timer);
                              card->other->flags |= ICN_FLAGS_RUNNING;
                        }
                        spin_unlock_irqrestore(&card->lock, flags);
                  }
                  icn_maprelease_channel(card, 0);
                  return 0;
            }
      }
}

/* Read the Status-replies from the Interface */
static int
icn_readstatus(u_char __user *buf, int len, icn_card * card)
{
      int count;
      u_char __user *p;

      for (p = buf, count = 0; count < len; p++, count++) {
            if (card->msg_buf_read == card->msg_buf_write)
                  return count;
            if (put_user(*card->msg_buf_read++, p))
                  return -EFAULT;
            if (card->msg_buf_read > card->msg_buf_end)
                  card->msg_buf_read = card->msg_buf;
      }
      return count;
}

/* Put command-strings into the command-queue of the Interface */
static int
icn_writecmd(const u_char * buf, int len, int user, icn_card * card)
{
      int mch = card->secondhalf ? 2 : 0;
      int pp;
      int i;
      int count;
      int xcount;
      int ocount;
      int loop;
      unsigned long flags;
      int lastmap_channel;
      struct icn_card *lastmap_card;
      u_char *p;
      isdn_ctrl cmd;
      u_char msg[0x100];

      ocount = 1;
      xcount = loop = 0;
      while (len) {
            count = cmd_free;
            if (count > len)
                  count = len;
            if (user) {
                  if (copy_from_user(msg, buf, count))
                        return -EFAULT;
            } else
                  memcpy(msg, buf, count);

            spin_lock_irqsave(&dev.devlock, flags);
            lastmap_card = dev.mcard;
            lastmap_channel = dev.channel;
            icn_map_channel(card, mch);

            icn_putmsg(card, '>');
            for (p = msg, pp = readb(&cmd_i), i = count; i > 0; i--, p++, pp
                 ++) {
                  writeb((*p == '\n') ? 0xff : *p,
                     &dev.shmem->comm_buffers.pcio_buf[pp & 0xff]);
                  len--;
                  xcount++;
                  icn_putmsg(card, *p);
                  if ((*p == '\n') && (i > 1)) {
                        icn_putmsg(card, '>');
                        ocount++;
                  }
                  ocount++;
            }
            writeb((readb(&cmd_i) + count) & 0xff, &cmd_i);
            if (lastmap_card)
                  icn_map_channel(lastmap_card, lastmap_channel);
            spin_unlock_irqrestore(&dev.devlock, flags);
            if (len) {
                  mdelay(1);
                  if (loop++ > 20)
                        break;
            } else
                  break;
      }
      if (len && (!user))
            printk(KERN_WARNING "icn: writemsg incomplete!\n");
      cmd.command = ISDN_STAT_STAVAIL;
      cmd.driver = card->myid;
      cmd.arg = ocount;
      card->interface.statcallb(&cmd);
      return xcount;
}

/*
 * Delete card's pending timers, send STOP to linklevel
 */
static void
icn_stopcard(icn_card * card)
{
      unsigned long flags;
      isdn_ctrl cmd;

      spin_lock_irqsave(&card->lock, flags);
      if (card->flags & ICN_FLAGS_RUNNING) {
            card->flags &= ~ICN_FLAGS_RUNNING;
            del_timer(&card->st_timer);
            del_timer(&card->rb_timer);
            spin_unlock_irqrestore(&card->lock, flags);
            cmd.command = ISDN_STAT_STOP;
            cmd.driver = card->myid;
            card->interface.statcallb(&cmd);
            if (card->doubleS0)
                  icn_stopcard(card->other);
      } else
            spin_unlock_irqrestore(&card->lock, flags);
}

static void
icn_stopallcards(void)
{
      icn_card *p = cards;

      while (p) {
            icn_stopcard(p);
            p = p->next;
      }
}

/*
 * Unmap all cards, because some of them may be mapped accidetly during
 * autoprobing of some network drivers (SMC-driver?)
 */
static void
icn_disable_cards(void)
{
      icn_card *card = cards;

      while (card) {
            if (!request_region(card->port, ICN_PORTLEN, "icn-isdn")) {
                  printk(KERN_WARNING
                         "icn: (%s) ports 0x%03x-0x%03x in use.\n",
                         CID,
                         card->port,
                         card->port + ICN_PORTLEN);
            } else {
                  OUTB_P(0, ICN_RUN);     /* Reset Controller     */
                  OUTB_P(0, ICN_MAPRAM);  /* Disable RAM          */
                  release_region(card->port, ICN_PORTLEN);
            }
            card = card->next;
      }
}

static int
icn_command(isdn_ctrl * c, icn_card * card)
{
      ulong a;
      ulong flags;
      int i;
      char cbuf[60];
      isdn_ctrl cmd;
      icn_cdef cdef;
      char __user *arg;

      switch (c->command) {
            case ISDN_CMD_IOCTL:
                  memcpy(&a, c->parm.num, sizeof(ulong));
                  arg = (char __user *)a;
                  switch (c->arg) {
                        case ICN_IOCTL_SETMMIO:
                              if (dev.memaddr != (a & 0x0ffc000)) {
                                    if (!request_mem_region(a & 0x0ffc000, 0x4000, "icn-isdn (all cards)")) {
                                          printk(KERN_WARNING
                                                 "icn: memory at 0x%08lx in use.\n",
                                                 a & 0x0ffc000);
                                          return -EINVAL;
                                    }
                                    release_mem_region(a & 0x0ffc000, 0x4000);
                                    icn_stopallcards();
                                    spin_lock_irqsave(&card->lock, flags);
                                    if (dev.mvalid) {
                                          iounmap(dev.shmem);
                                          release_mem_region(dev.memaddr, 0x4000);
                                    }
                                    dev.mvalid = 0;
                                    dev.memaddr = a & 0x0ffc000;
                                    spin_unlock_irqrestore(&card->lock, flags);
                                    printk(KERN_INFO
                                           "icn: (%s) mmio set to 0x%08lx\n",
                                           CID,
                                           dev.memaddr);
                              }
                              break;
                        case ICN_IOCTL_GETMMIO:
                              return (long) dev.memaddr;
                        case ICN_IOCTL_SETPORT:
                              if (a == 0x300 || a == 0x310 || a == 0x320 || a == 0x330
                                  || a == 0x340 || a == 0x350 || a == 0x360 ||
                                  a == 0x308 || a == 0x318 || a == 0x328 || a == 0x338
                                  || a == 0x348 || a == 0x358 || a == 0x368) {
                                    if (card->port != (unsigned short) a) {
                                          if (!request_region((unsigned short) a, ICN_PORTLEN, "icn-isdn")) {
                                                printk(KERN_WARNING
                                                       "icn: (%s) ports 0x%03x-0x%03x in use.\n",
                                                       CID, (int) a, (int) a + ICN_PORTLEN);
                                                return -EINVAL;
                                          }
                                          release_region((unsigned short) a, ICN_PORTLEN);
                                          icn_stopcard(card);
                                          spin_lock_irqsave(&card->lock, flags);
                                          if (card->rvalid)
                                                release_region(card->port, ICN_PORTLEN);
                                          card->port = (unsigned short) a;
                                          card->rvalid = 0;
                                          if (card->doubleS0) {
                                                card->other->port = (unsigned short) a;
                                                card->other->rvalid = 0;
                                          }
                                          spin_unlock_irqrestore(&card->lock, flags);
                                          printk(KERN_INFO
                                                 "icn: (%s) port set to 0x%03x\n",
                                          CID, card->port);
                                    }
                              } else
                                    return -EINVAL;
                              break;
                        case ICN_IOCTL_GETPORT:
                              return (int) card->port;
                        case ICN_IOCTL_GETDOUBLE:
                              return (int) card->doubleS0;
                        case ICN_IOCTL_DEBUGVAR:
                              if (copy_to_user(arg,
                                           &card,
                                           sizeof(ulong)))
                                    return -EFAULT;
                              a += sizeof(ulong);
                              {
                                    ulong l = (ulong) & dev;
                                    if (copy_to_user(arg,
                                                 &l,
                                                 sizeof(ulong)))
                                          return -EFAULT;
                              }
                              return 0;
                        case ICN_IOCTL_LOADBOOT:
                              if (dev.firstload) {
                                    icn_disable_cards();
                                    dev.firstload = 0;
                              }
                              icn_stopcard(card);
                              return (icn_loadboot(arg, card));
                        case ICN_IOCTL_LOADPROTO:
                              icn_stopcard(card);
                              if ((i = (icn_loadproto(arg, card))))
                                    return i;
                              if (card->doubleS0)
                                    i = icn_loadproto(arg + ICN_CODE_STAGE2, card->other);
                              return i;
                              break;
                        case ICN_IOCTL_ADDCARD:
                              if (!dev.firstload)
                                    return -EBUSY;
                              if (copy_from_user(&cdef,
                                             arg,
                                             sizeof(cdef)))
                                    return -EFAULT;
                              return (icn_addcard(cdef.port, cdef.id1, cdef.id2));
                              break;
                        case ICN_IOCTL_LEASEDCFG:
                              if (a) {
                                    if (!card->leased) {
                                          card->leased = 1;
                                          while (card->ptype == ISDN_PTYPE_UNKNOWN) {
                                                msleep_interruptible(ICN_BOOT_TIMEOUT1);
                                          }
                                          msleep_interruptible(ICN_BOOT_TIMEOUT1);
                                          sprintf(cbuf, "00;FV2ON\n01;EAZ%c\n02;EAZ%c\n",
                                                (a & 1)?'1':'C', (a & 2)?'2':'C');
                                          i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                                          printk(KERN_INFO
                                                 "icn: (%s) Leased-line mode enabled\n",
                                                 CID);
                                          cmd.command = ISDN_STAT_RUN;
                                          cmd.driver = card->myid;
                                          cmd.arg = 0;
                                          card->interface.statcallb(&cmd);
                                    }
                              } else {
                                    if (card->leased) {
                                          card->leased = 0;
                                          sprintf(cbuf, "00;FV2OFF\n");
                                          i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                                          printk(KERN_INFO
                                                 "icn: (%s) Leased-line mode disabled\n",
                                                 CID);
                                          cmd.command = ISDN_STAT_RUN;
                                          cmd.driver = card->myid;
                                          cmd.arg = 0;
                                          card->interface.statcallb(&cmd);
                                    }
                              }
                              return 0;
                        default:
                              return -EINVAL;
                  }
                  break;
            case ISDN_CMD_DIAL:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (card->leased)
                        break;
                  if ((c->arg & 255) < ICN_BCH) {
                        char *p;
                        char dial[50];
                        char dcode[4];

                        a = c->arg;
                        p = c->parm.setup.phone;
                        if (*p == 's' || *p == 'S') {
                              /* Dial for SPV */
                              p++;
                              strcpy(dcode, "SCA");
                        } else
                              /* Normal Dial */
                              strcpy(dcode, "CAL");
                        strcpy(dial, p);
                        sprintf(cbuf, "%02d;D%s_R%s,%02d,%02d,%s\n", (int) (a + 1),
                              dcode, dial, c->parm.setup.si1,
                        c->parm.setup.si2, c->parm.setup.eazmsn);
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_ACCEPTD:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (c->arg < ICN_BCH) {
                        a = c->arg + 1;
                        if (card->fw_rev >= 300) {
                              switch (card->l2_proto[a - 1]) {
                                    case ISDN_PROTO_L2_X75I:
                                          sprintf(cbuf, "%02d;BX75\n", (int) a);
                                          break;
                                    case ISDN_PROTO_L2_HDLC:
                                          sprintf(cbuf, "%02d;BTRA\n", (int) a);
                                          break;
                              }
                              i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                        }
                        sprintf(cbuf, "%02d;DCON_R\n", (int) a);
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_ACCEPTB:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (c->arg < ICN_BCH) {
                        a = c->arg + 1;
                        if (card->fw_rev >= 300)
                              switch (card->l2_proto[a - 1]) {
                                    case ISDN_PROTO_L2_X75I:
                                          sprintf(cbuf, "%02d;BCON_R,BX75\n", (int) a);
                                          break;
                                    case ISDN_PROTO_L2_HDLC:
                                          sprintf(cbuf, "%02d;BCON_R,BTRA\n", (int) a);
                                          break;
                        } else
                              sprintf(cbuf, "%02d;BCON_R\n", (int) a);
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_HANGUP:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (c->arg < ICN_BCH) {
                        a = c->arg + 1;
                        sprintf(cbuf, "%02d;BDIS_R\n%02d;DDIS_R\n", (int) a, (int) a);
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_SETEAZ:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (card->leased)
                        break;
                  if (c->arg < ICN_BCH) {
                        a = c->arg + 1;
                        if (card->ptype == ISDN_PTYPE_EURO) {
                              sprintf(cbuf, "%02d;MS%s%s\n", (int) a,
                                    c->parm.num[0] ? "N" : "ALL", c->parm.num);
                        } else
                              sprintf(cbuf, "%02d;EAZ%s\n", (int) a,
                                    c->parm.num[0] ? (char *)(c->parm.num) : "0123456789");
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_CLREAZ:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if (card->leased)
                        break;
                  if (c->arg < ICN_BCH) {
                        a = c->arg + 1;
                        if (card->ptype == ISDN_PTYPE_EURO)
                              sprintf(cbuf, "%02d;MSNC\n", (int) a);
                        else
                              sprintf(cbuf, "%02d;EAZC\n", (int) a);
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                  }
                  break;
            case ISDN_CMD_SETL2:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  if ((c->arg & 255) < ICN_BCH) {
                        a = c->arg;
                        switch (a >> 8) {
                              case ISDN_PROTO_L2_X75I:
                                    sprintf(cbuf, "%02d;BX75\n", (int) (a & 255) + 1);
                                    break;
                              case ISDN_PROTO_L2_HDLC:
                                    sprintf(cbuf, "%02d;BTRA\n", (int) (a & 255) + 1);
                                    break;
                              default:
                                    return -EINVAL;
                        }
                        i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
                        card->l2_proto[a & 255] = (a >> 8);
                  }
                  break;
            case ISDN_CMD_SETL3:
                  if (!card->flags & ICN_FLAGS_RUNNING)
                        return -ENODEV;
                  return 0;
            default:
                  return -EINVAL;
      }
      return 0;
}

/*
 * Find card with given driverId
 */
static inline icn_card *
icn_findcard(int driverid)
{
      icn_card *p = cards;

      while (p) {
            if (p->myid == driverid)
                  return p;
            p = p->next;
      }
      return (icn_card *) 0;
}

/*
 * Wrapper functions for interface to linklevel
 */
static int
if_command(isdn_ctrl * c)
{
      icn_card *card = icn_findcard(c->driver);

      if (card)
            return (icn_command(c, card));
      printk(KERN_ERR
             "icn: 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)
{
      icn_card *card = icn_findcard(id);

      if (card) {
            if (!card->flags & ICN_FLAGS_RUNNING)
                  return -ENODEV;
            return (icn_writecmd(buf, len, 1, card));
      }
      printk(KERN_ERR
             "icn: if_writecmd called with invalid driverId!\n");
      return -ENODEV;
}

static int
if_readstatus(u_char __user *buf, int len, int id, int channel)
{
      icn_card *card = icn_findcard(id);

      if (card) {
            if (!card->flags & ICN_FLAGS_RUNNING)
                  return -ENODEV;
            return (icn_readstatus(buf, len, card));
      }
      printk(KERN_ERR
             "icn: if_readstatus called with invalid driverId!\n");
      return -ENODEV;
}

static int
if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
{
      icn_card *card = icn_findcard(id);

      if (card) {
            if (!card->flags & ICN_FLAGS_RUNNING)
                  return -ENODEV;
            return (icn_sendbuf(channel, ack, skb, card));
      }
      printk(KERN_ERR
             "icn: if_sendbuf called with invalid driverId!\n");
      return -ENODEV;
}

/*
 * Allocate a new card-struct, initialize it
 * link it into cards-list and register it at linklevel.
 */
static icn_card *
icn_initcard(int port, char *id)
{
      icn_card *card;
      int i;

      if (!(card = kzalloc(sizeof(icn_card), GFP_KERNEL))) {
            printk(KERN_WARNING
                   "icn: (%s) Could not allocate card-struct.\n", id);
            return (icn_card *) 0;
      }
      spin_lock_init(&card->lock);
      card->port = port;
      card->interface.owner = THIS_MODULE;
      card->interface.hl_hdrlen = 1;
      card->interface.channels = ICN_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->ptype = ISDN_PTYPE_UNKNOWN;
      strlcpy(card->interface.id, id, sizeof(card->interface.id));
      card->msg_buf_write = card->msg_buf;
      card->msg_buf_read = card->msg_buf;
      card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1];
      for (i = 0; i < ICN_BCH; i++) {
            card->l2_proto[i] = ISDN_PROTO_L2_X75I;
            skb_queue_head_init(&card->spqueue[i]);
      }
      card->next = cards;
      cards = card;
      if (!register_isdn(&card->interface)) {
            cards = cards->next;
            printk(KERN_WARNING
                   "icn: Unable to register %s\n", id);
            kfree(card);
            return (icn_card *) 0;
      }
      card->myid = card->interface.channels;
      sprintf(card->regname, "icn-isdn (%s)", card->interface.id);
      return card;
}

static int
icn_addcard(int port, char *id1, char *id2)
{
      icn_card *card;
      icn_card *card2;

      if (!(card = icn_initcard(port, id1))) {
            return -EIO;
      }
      if (!strlen(id2)) {
            printk(KERN_INFO
                   "icn: (%s) ICN-2B, port 0x%x added\n",
                   card->interface.id, port);
            return 0;
      }
      if (!(card2 = icn_initcard(port, id2))) {
            printk(KERN_INFO
                   "icn: (%s) half ICN-4B, port 0x%x added\n",
                   card2->interface.id, port);
            return 0;
      }
      card->doubleS0 = 1;
      card->secondhalf = 0;
      card->other = card2;
      card2->doubleS0 = 1;
      card2->secondhalf = 1;
      card2->other = card;
      printk(KERN_INFO
             "icn: (%s and %s) ICN-4B, port 0x%x added\n",
             card->interface.id, card2->interface.id, port);
      return 0;
}

#ifndef MODULE
static int __init
icn_setup(char *line)
{
      char *p, *str;
      int   ints[3];
      static char sid[20];
      static char sid2[20];

      str = get_options(line, 2, ints);
      if (ints[0])
            portbase = ints[1];
      if (ints[0] > 1)
            membase = (unsigned long)ints[2];
      if (str && *str) {
            strcpy(sid, str);
            icn_id = sid;
            if ((p = strchr(sid, ','))) {
                  *p++ = 0;
                  strcpy(sid2, p);
                  icn_id2 = sid2;
            }
      }
      return(1);
}
__setup("icn=", icn_setup);
#endif /* MODULE */

static int __init icn_init(void)
{
      char *p;
      char rev[10];

      memset(&dev, 0, sizeof(icn_dev));
      dev.memaddr = (membase & 0x0ffc000);
      dev.channel = -1;
      dev.mcard = NULL;
      dev.firstload = 1;
      spin_lock_init(&dev.devlock);

      if ((p = strchr(revision, ':'))) {
            strcpy(rev, p + 1);
            p = strchr(rev, '$');
            *p = 0;
      } else
            strcpy(rev, " ??? ");
      printk(KERN_NOTICE "ICN-ISDN-driver Rev%smem=0x%08lx\n", rev,
             dev.memaddr);
      return (icn_addcard(portbase, icn_id, icn_id2));
}

static void __exit icn_exit(void)
{
      isdn_ctrl cmd;
      icn_card *card = cards;
      icn_card *last, *tmpcard;
      int i;
      unsigned long flags;

      icn_stopallcards();
      while (card) {
            cmd.command = ISDN_STAT_UNLOAD;
            cmd.driver = card->myid;
            card->interface.statcallb(&cmd);
            spin_lock_irqsave(&card->lock, flags);
            if (card->rvalid) {
                  OUTB_P(0, ICN_RUN);     /* Reset Controller     */
                  OUTB_P(0, ICN_MAPRAM);  /* Disable RAM          */
                  if (card->secondhalf || (!card->doubleS0)) {
                        release_region(card->port, ICN_PORTLEN);
                        card->rvalid = 0;
                  }
                  for (i = 0; i < ICN_BCH; i++)
                        icn_free_queue(card, i);
            }
            tmpcard = card->next;
            spin_unlock_irqrestore(&card->lock, flags);
            card = tmpcard;
      }
      card = cards;
      cards = NULL;
      while (card) {
            last = card;
            card = card->next;
            kfree(last);
      }
      if (dev.mvalid) {
            iounmap(dev.shmem);
            release_mem_region(dev.memaddr, 0x4000);
      }
      printk(KERN_NOTICE "ICN-ISDN-driver unloaded\n");
}

module_init(icn_init);
module_exit(icn_exit);

Generated by  Doxygen 1.6.0   Back to index