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

hisax_fcpcipnp.c

/*
 * Driver for AVM Fritz!PCI, Fritz!PCI v2, Fritz!PnP ISDN cards
 *
 * Author       Kai Germaschewski
 * Copyright    2001 by Kai Germaschewski  <kai.germaschewski@gmx.de>
 *              2001 by Karsten Keil       <keil@isdn4linux.de>
 * 
 * based upon Karsten Keil's original avm_pci.c driver
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * Thanks to Wizard Computersysteme GmbH, Bremervoerde and
 *           SoHaNet Technology GmbH, Berlin
 * for supporting the development of this driver
 */


/* TODO:
 *
 * o POWER PC
 * o clean up debugging
 * o tx_skb at PH_DEACTIVATE time
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/isapnp.h>
#include <linux/kmod.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/delay.h>

#include <asm/io.h>

#include "hisax_fcpcipnp.h"

// debugging cruft
#define __debug_variable debug
#include "hisax_debug.h"

#ifdef CONFIG_HISAX_DEBUG
static int debug = 0;
/* static int hdlcfifosize = 32; */
module_param(debug, int, 0);
/* module_param(hdlcfifosize, int, 0); */
#endif

MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");

static struct pci_device_id fcpci_ids[] = {
      { .vendor      = PCI_VENDOR_ID_AVM,
        .device      = PCI_DEVICE_ID_AVM_A1,
        .subvendor   = PCI_ANY_ID,
        .subdevice   = PCI_ANY_ID,
        .driver_data = (unsigned long) "Fritz!Card PCI",
      },
      { .vendor      = PCI_VENDOR_ID_AVM,
        .device      = PCI_DEVICE_ID_AVM_A1_V2,
        .subvendor   = PCI_ANY_ID,
        .subdevice   = PCI_ANY_ID,
        .driver_data = (unsigned long) "Fritz!Card PCI v2" },
      {}
};

MODULE_DEVICE_TABLE(pci, fcpci_ids);

#ifdef __ISAPNP__
static struct pnp_device_id fcpnp_ids[] __devinitdata = {
      { 
            .id         = "AVM0900",
            .driver_data      = (unsigned long) "Fritz!Card PnP",
      },
};

MODULE_DEVICE_TABLE(isapnp, fcpnp_ids);
#endif

static int protocol = 2;       /* EURO-ISDN Default */
module_param(protocol, int, 0);
MODULE_LICENSE("GPL");

// ----------------------------------------------------------------------

#define  AVM_INDEX              0x04
#define  AVM_DATA               0x10

#define      AVM_IDX_HDLC_1         0x00
#define      AVM_IDX_HDLC_2         0x01
#define      AVM_IDX_ISAC_FIFO      0x02
#define      AVM_IDX_ISAC_REG_LOW   0x04
#define      AVM_IDX_ISAC_REG_HIGH  0x06

#define  AVM_STATUS0            0x02

#define  AVM_STATUS0_IRQ_ISAC 0x01
#define  AVM_STATUS0_IRQ_HDLC 0x02
#define  AVM_STATUS0_IRQ_TIMER      0x04
#define  AVM_STATUS0_IRQ_MASK 0x07

#define  AVM_STATUS0_RESET    0x01
#define  AVM_STATUS0_DIS_TIMER      0x02
#define  AVM_STATUS0_RES_TIMER      0x04
#define  AVM_STATUS0_ENA_IRQ  0x08
#define  AVM_STATUS0_TESTBIT  0x10

#define  AVM_STATUS1            0x03
#define  AVM_STATUS1_ENA_IOM  0x80

#define  HDLC_FIFO            0x0
#define  HDLC_STATUS          0x4
#define  HDLC_CTRL            0x4

#define  HDLC_MODE_ITF_FLG    0x01
#define  HDLC_MODE_TRANS      0x02
#define  HDLC_MODE_CCR_7      0x04
#define  HDLC_MODE_CCR_16     0x08
#define  HDLC_MODE_TESTLOOP   0x80

#define  HDLC_INT_XPR         0x80
#define  HDLC_INT_XDU         0x40
#define  HDLC_INT_RPR         0x20
#define  HDLC_INT_MASK        0xE0

#define  HDLC_STAT_RME        0x01
#define  HDLC_STAT_RDO        0x10
#define  HDLC_STAT_CRCVFRRAB  0x0E
#define  HDLC_STAT_CRCVFR     0x06
#define  HDLC_STAT_RML_MASK   0xff00

#define  HDLC_CMD_XRS         0x80
#define  HDLC_CMD_XME         0x01
#define  HDLC_CMD_RRS         0x20
#define  HDLC_CMD_XML_MASK    0xff00

#define  AVM_HDLC_FIFO_1        0x10
#define  AVM_HDLC_FIFO_2        0x18

#define  AVM_HDLC_STATUS_1      0x14
#define  AVM_HDLC_STATUS_2      0x1c

#define  AVM_ISACSX_INDEX       0x04
#define  AVM_ISACSX_DATA        0x08

// ----------------------------------------------------------------------
// Fritz!PCI

static unsigned char fcpci_read_isac(struct isac *isac, unsigned char offset)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned char idx = (offset > 0x2f) ? 
            AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
      unsigned char val;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outb(idx, adapter->io + AVM_INDEX);
      val = inb(adapter->io + AVM_DATA + (offset & 0xf));
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
      DBG(0x1000, " port %#x, value %#x",
          offset, val);
      return val;
}

static void fcpci_write_isac(struct isac *isac, unsigned char offset,
                       unsigned char value)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned char idx = (offset > 0x2f) ? 
            AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
      unsigned long flags;

      DBG(0x1000, " port %#x, value %#x",
          offset, value);
      spin_lock_irqsave(&adapter->hw_lock, flags);
      outb(idx, adapter->io + AVM_INDEX);
      outb(value, adapter->io + AVM_DATA + (offset & 0xf));
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static void fcpci_read_isac_fifo(struct isac *isac, unsigned char * data, 
                         int size)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
      insb(adapter->io + AVM_DATA, data, size);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static void fcpci_write_isac_fifo(struct isac *isac, unsigned char * data, 
                          int size)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
      outsb(adapter->io + AVM_DATA, data, size);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static u32 fcpci_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
      u32 val;
      int idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outl(idx, adapter->io + AVM_INDEX);
      val = inl(adapter->io + AVM_DATA + HDLC_STATUS);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
      return val;
}

static void __fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
{
      struct fritz_adapter *adapter = bcs->adapter;
      int idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;

      DBG(0x40, "hdlc %c wr%x ctrl %x",
          'A' + bcs->channel, which, bcs->ctrl.ctrl);

      outl(idx, adapter->io + AVM_INDEX);
      outl(bcs->ctrl.ctrl, adapter->io + AVM_DATA + HDLC_CTRL);
}

static void fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
{
      struct fritz_adapter *adapter = bcs->adapter;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      __fcpci_write_ctrl(bcs, which);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

// ----------------------------------------------------------------------
// Fritz!PCI v2

static unsigned char fcpci2_read_isac(struct isac *isac, unsigned char offset)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned char val;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outl(offset, adapter->io + AVM_ISACSX_INDEX);
      val = inl(adapter->io + AVM_ISACSX_DATA);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
      DBG(0x1000, " port %#x, value %#x",
          offset, val);

      return val;
}

static void fcpci2_write_isac(struct isac *isac, unsigned char offset, 
                        unsigned char value)
{
      struct fritz_adapter *adapter = isac->priv;
      unsigned long flags;

      DBG(0x1000, " port %#x, value %#x",
          offset, value);
      spin_lock_irqsave(&adapter->hw_lock, flags);
      outl(offset, adapter->io + AVM_ISACSX_INDEX);
      outl(value, adapter->io + AVM_ISACSX_DATA);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static void fcpci2_read_isac_fifo(struct isac *isac, unsigned char * data, 
                          int size)
{
      struct fritz_adapter *adapter = isac->priv;
      int i;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outl(0, adapter->io + AVM_ISACSX_INDEX);
      for (i = 0; i < size; i++)
            data[i] = inl(adapter->io + AVM_ISACSX_DATA);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static void fcpci2_write_isac_fifo(struct isac *isac, unsigned char * data, 
                           int size)
{
      struct fritz_adapter *adapter = isac->priv;
      int i;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outl(0, adapter->io + AVM_ISACSX_INDEX);
      for (i = 0; i < size; i++)
            outl(data[i], adapter->io + AVM_ISACSX_DATA);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

static u32 fcpci2_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
      int offset = nr ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;

      return inl(adapter->io + offset);
}

static void fcpci2_write_ctrl(struct fritz_bcs *bcs, int which)
{
      struct fritz_adapter *adapter = bcs->adapter;
      int offset = bcs->channel ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;

      DBG(0x40, "hdlc %c wr%x ctrl %x",
          'A' + bcs->channel, which, bcs->ctrl.ctrl);

      outl(bcs->ctrl.ctrl, adapter->io + offset);
}

// ----------------------------------------------------------------------
// Fritz!PnP (ISAC access as for Fritz!PCI)

static u32 fcpnp_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
      unsigned char idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
      u32 val;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      outb(idx, adapter->io + AVM_INDEX);
      val = inb(adapter->io + AVM_DATA + HDLC_STATUS);
      if (val & HDLC_INT_RPR)
            val |= inb(adapter->io + AVM_DATA + HDLC_STATUS + 1) << 8;
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
      return val;
}

static void __fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
{
      struct fritz_adapter *adapter = bcs->adapter;
      unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;

      DBG(0x40, "hdlc %c wr%x ctrl %x",
          'A' + bcs->channel, which, bcs->ctrl.ctrl);

      outb(idx, adapter->io + AVM_INDEX);
      if (which & 4)
            outb(bcs->ctrl.sr.mode, 
                 adapter->io + AVM_DATA + HDLC_STATUS + 2);
      if (which & 2)
            outb(bcs->ctrl.sr.xml, 
                 adapter->io + AVM_DATA + HDLC_STATUS + 1);
      if (which & 1)
            outb(bcs->ctrl.sr.cmd,
                 adapter->io + AVM_DATA + HDLC_STATUS + 0);
}

static void fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
{
      struct fritz_adapter *adapter = bcs->adapter;
      unsigned long flags;

      spin_lock_irqsave(&adapter->hw_lock, flags);
      __fcpnp_write_ctrl(bcs, which);
      spin_unlock_irqrestore(&adapter->hw_lock, flags);
}

// ----------------------------------------------------------------------

static inline void B_L1L2(struct fritz_bcs *bcs, int pr, void *arg)
{
      struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;

      DBG(2, "pr %#x", pr);
      ifc->l1l2(ifc, pr, arg);
}

static void hdlc_fill_fifo(struct fritz_bcs *bcs)
{
      struct fritz_adapter *adapter = bcs->adapter;
      struct sk_buff *skb = bcs->tx_skb;
      int count;
      unsigned long flags;
      unsigned char *p;

      DBG(0x40, "hdlc_fill_fifo");

      BUG_ON(skb->len == 0);

      bcs->ctrl.sr.cmd &= ~HDLC_CMD_XME;
      if (bcs->tx_skb->len > bcs->fifo_size) {
            count = bcs->fifo_size;
      } else {
            count = bcs->tx_skb->len;
            if (bcs->mode != L1_MODE_TRANS)
                  bcs->ctrl.sr.cmd |= HDLC_CMD_XME;
      }
      DBG(0x40, "hdlc_fill_fifo %d/%d", count, bcs->tx_skb->len);
      p = bcs->tx_skb->data;
      skb_pull(bcs->tx_skb, count);
      bcs->tx_cnt += count;
      bcs->ctrl.sr.xml = ((count == bcs->fifo_size) ? 0 : count);

      switch (adapter->type) {
      case AVM_FRITZ_PCI:
            spin_lock_irqsave(&adapter->hw_lock, flags);
            // sets the correct AVM_INDEX, too
            __fcpci_write_ctrl(bcs, 3);
            outsl(adapter->io + AVM_DATA + HDLC_FIFO,
                  p, (count + 3) / 4);
            spin_unlock_irqrestore(&adapter->hw_lock, flags);
            break;
      case AVM_FRITZ_PCIV2:
            fcpci2_write_ctrl(bcs, 3);
            outsl(adapter->io + 
                  (bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
                  p, (count + 3) / 4);
            break;
      case AVM_FRITZ_PNP:
            spin_lock_irqsave(&adapter->hw_lock, flags);
            // sets the correct AVM_INDEX, too
            __fcpnp_write_ctrl(bcs, 3);
            outsb(adapter->io + AVM_DATA, p, count);
            spin_unlock_irqrestore(&adapter->hw_lock, flags);
            break;
      }
}

static inline void hdlc_empty_fifo(struct fritz_bcs *bcs, int count)
{
      struct fritz_adapter *adapter = bcs->adapter;
      unsigned char *p;
      unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;

      DBG(0x10, "hdlc_empty_fifo %d", count);
      if (bcs->rcvidx + count > HSCX_BUFMAX) {
            DBG(0x10, "hdlc_empty_fifo: incoming packet too large");
            return;
      }
      p = bcs->rcvbuf + bcs->rcvidx;
      bcs->rcvidx += count;
      switch (adapter->type) {
      case AVM_FRITZ_PCI:
            spin_lock(&adapter->hw_lock);
            outl(idx, adapter->io + AVM_INDEX);
            insl(adapter->io + AVM_DATA + HDLC_FIFO, 
                 p, (count + 3) / 4);
            spin_unlock(&adapter->hw_lock);
            break;
      case AVM_FRITZ_PCIV2:
            insl(adapter->io + 
                 (bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
                 p, (count + 3) / 4);
            break;
      case AVM_FRITZ_PNP:
            spin_lock(&adapter->hw_lock);
            outb(idx, adapter->io + AVM_INDEX);
            insb(adapter->io + AVM_DATA, p, count);
            spin_unlock(&adapter->hw_lock);
            break;
      }
}

static inline void hdlc_rpr_irq(struct fritz_bcs *bcs, u32 stat)
{
      struct fritz_adapter *adapter = bcs->adapter;
      struct sk_buff *skb;
      int len;

      if (stat & HDLC_STAT_RDO) {
            DBG(0x10, "RDO");
            bcs->ctrl.sr.xml = 0;
            bcs->ctrl.sr.cmd |= HDLC_CMD_RRS;
            adapter->write_ctrl(bcs, 1);
            bcs->ctrl.sr.cmd &= ~HDLC_CMD_RRS;
            adapter->write_ctrl(bcs, 1);
            bcs->rcvidx = 0;
            return;
      }

      len = (stat & HDLC_STAT_RML_MASK) >> 8;
      if (len == 0)
            len = bcs->fifo_size;

      hdlc_empty_fifo(bcs, len);

      if ((stat & HDLC_STAT_RME) || (bcs->mode == L1_MODE_TRANS)) {
            if (((stat & HDLC_STAT_CRCVFRRAB)== HDLC_STAT_CRCVFR) ||
                (bcs->mode == L1_MODE_TRANS)) {
                  skb = dev_alloc_skb(bcs->rcvidx);
                  if (!skb) {
                        printk(KERN_WARNING "HDLC: receive out of memory\n");
                  } else {
                        memcpy(skb_put(skb, bcs->rcvidx), bcs->rcvbuf,
                               bcs->rcvidx);
                        DBG_SKB(1, skb);
                        B_L1L2(bcs, PH_DATA | INDICATION, skb);
                  }
                  bcs->rcvidx = 0;
            } else {
                  DBG(0x10, "ch%d invalid frame %#x",
                      bcs->channel, stat);
                  bcs->rcvidx = 0;
            }
      }
}

static inline void hdlc_xdu_irq(struct fritz_bcs *bcs)
{
      struct fritz_adapter *adapter = bcs->adapter;
      

      /* Here we lost an TX interrupt, so
       * restart transmitting the whole frame.
       */
      bcs->ctrl.sr.xml = 0;
      bcs->ctrl.sr.cmd |= HDLC_CMD_XRS;
      adapter->write_ctrl(bcs, 1);
      bcs->ctrl.sr.cmd &= ~HDLC_CMD_XRS;

      if (!bcs->tx_skb) {
            DBG(0x10, "XDU without skb");
            adapter->write_ctrl(bcs, 1);
            return;
      }
      /* only hdlc restarts the frame, transparent mode must continue */
      if (bcs->mode == L1_MODE_HDLC) {
            skb_push(bcs->tx_skb, bcs->tx_cnt);
            bcs->tx_cnt = 0;
      }
}

static inline void hdlc_xpr_irq(struct fritz_bcs *bcs)
{
      struct sk_buff *skb;

      skb = bcs->tx_skb;
      if (!skb)
            return;

      if (skb->len) {
            hdlc_fill_fifo(bcs);
            return;
      }
      bcs->tx_cnt = 0;
      bcs->tx_skb = NULL;
      B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long)skb->truesize);
      dev_kfree_skb_irq(skb);
}

static void hdlc_irq_one(struct fritz_bcs *bcs, u32 stat)
{
      DBG(0x10, "ch%d stat %#x", bcs->channel, stat);
      if (stat & HDLC_INT_RPR) {
            DBG(0x10, "RPR");
            hdlc_rpr_irq(bcs, stat);
      }
      if (stat & HDLC_INT_XDU) {
            DBG(0x10, "XDU");
            hdlc_xdu_irq(bcs);
            hdlc_xpr_irq(bcs);
            return;
      }
      if (stat & HDLC_INT_XPR) {
            DBG(0x10, "XPR");
            hdlc_xpr_irq(bcs);
      }
}

static inline void hdlc_irq(struct fritz_adapter *adapter)
{
      int nr;
      u32 stat;

      for (nr = 0; nr < 2; nr++) {
            stat = adapter->read_hdlc_status(adapter, nr);
            DBG(0x10, "HDLC %c stat %#x", 'A' + nr, stat);
            if (stat & HDLC_INT_MASK)
                  hdlc_irq_one(&adapter->bcs[nr], stat);
      }
}

static void modehdlc(struct fritz_bcs *bcs, int mode)
{
      struct fritz_adapter *adapter = bcs->adapter;
      
      DBG(0x40, "hdlc %c mode %d --> %d",
          'A' + bcs->channel, bcs->mode, mode);

      if (bcs->mode == mode)
            return;

      bcs->fifo_size = 32;
      bcs->ctrl.ctrl = 0;
      bcs->ctrl.sr.cmd  = HDLC_CMD_XRS | HDLC_CMD_RRS;
      switch (mode) {
      case L1_MODE_NULL:
            bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
            adapter->write_ctrl(bcs, 5);
            break;
      case L1_MODE_TRANS:
      case L1_MODE_HDLC:
            bcs->rcvidx = 0;
            bcs->tx_cnt = 0;
            bcs->tx_skb = NULL;
            if (mode == L1_MODE_TRANS) {
                  bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
            } else {
                  bcs->ctrl.sr.mode = HDLC_MODE_ITF_FLG;
            }
            adapter->write_ctrl(bcs, 5);
            bcs->ctrl.sr.cmd = HDLC_CMD_XRS;
            adapter->write_ctrl(bcs, 1);
            bcs->ctrl.sr.cmd = 0;
            break;
      }
      bcs->mode = mode;
}

static void fritz_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
{
      struct fritz_bcs *bcs = ifc->priv;
      struct sk_buff *skb = arg;
      int mode;

      DBG(0x10, "pr %#x", pr);

      switch (pr) {
      case PH_DATA | REQUEST:
            BUG_ON(bcs->tx_skb);
            bcs->tx_skb = skb;
            DBG_SKB(1, skb);
            hdlc_fill_fifo(bcs);
            break;
      case PH_ACTIVATE | REQUEST:
            mode = (long) arg;
            DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
            modehdlc(bcs, mode);
            B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
            break;
      case PH_DEACTIVATE | REQUEST:
            DBG(4,"B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
            modehdlc(bcs, L1_MODE_NULL);
            B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
            break;
      }
}

// ----------------------------------------------------------------------

static irqreturn_t
fcpci2_irq(int intno, void *dev)
{
      struct fritz_adapter *adapter = dev;
      unsigned char val;

      val = inb(adapter->io + AVM_STATUS0);
      if (!(val & AVM_STATUS0_IRQ_MASK))
            /* hopefully a shared  IRQ reqest */
            return IRQ_NONE;
      DBG(2, "STATUS0 %#x", val);
      if (val & AVM_STATUS0_IRQ_ISAC)
            isacsx_irq(&adapter->isac);
      if (val & AVM_STATUS0_IRQ_HDLC)
            hdlc_irq(adapter);
      if (val & AVM_STATUS0_IRQ_ISAC)
            isacsx_irq(&adapter->isac);
      return IRQ_HANDLED;
}

static irqreturn_t
fcpci_irq(int intno, void *dev)
{
      struct fritz_adapter *adapter = dev;
      unsigned char sval;

      sval = inb(adapter->io + 2);
      if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
            /* possibly a shared  IRQ reqest */
            return IRQ_NONE;
      DBG(2, "sval %#x", sval);
      if (!(sval & AVM_STATUS0_IRQ_ISAC))
            isac_irq(&adapter->isac);

      if (!(sval & AVM_STATUS0_IRQ_HDLC))
            hdlc_irq(adapter);
      return IRQ_HANDLED;
}

// ----------------------------------------------------------------------

static inline void fcpci2_init(struct fritz_adapter *adapter)
{
      outb(AVM_STATUS0_RES_TIMER, adapter->io + AVM_STATUS0);
      outb(AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);

}

static inline void fcpci_init(struct fritz_adapter *adapter)
{
      outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER | 
           AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);

      outb(AVM_STATUS1_ENA_IOM | adapter->irq, 
           adapter->io + AVM_STATUS1);
      mdelay(10);
}

// ----------------------------------------------------------------------

static int __devinit fcpcipnp_setup(struct fritz_adapter *adapter)
{
      u32 val = 0;
      int retval;

      DBG(1,"");

      isac_init(&adapter->isac); // FIXME is this okay now

      retval = -EBUSY;
      if (!request_region(adapter->io, 32, "fcpcipnp"))
            goto err;

      switch (adapter->type) {
      case AVM_FRITZ_PCIV2:
            retval = request_irq(adapter->irq, fcpci2_irq, IRQF_SHARED,
                             "fcpcipnp", adapter);
            break;
      case AVM_FRITZ_PCI:
            retval = request_irq(adapter->irq, fcpci_irq, IRQF_SHARED,
                             "fcpcipnp", adapter);
            break;
      case AVM_FRITZ_PNP:
            retval = request_irq(adapter->irq, fcpci_irq, 0,
                             "fcpcipnp", adapter);
            break;
      }
      if (retval)
            goto err_region;

      switch (adapter->type) {
      case AVM_FRITZ_PCIV2:
      case AVM_FRITZ_PCI:
            val = inl(adapter->io);
            break;
      case AVM_FRITZ_PNP:
            val = inb(adapter->io);
            val |= inb(adapter->io + 1) << 8;
            break;
      }

      DBG(1, "stat %#x Class %X Rev %d",
          val, val & 0xff, (val>>8) & 0xff);

      spin_lock_init(&adapter->hw_lock);
      adapter->isac.priv = adapter;
      switch (adapter->type) {
      case AVM_FRITZ_PCIV2:
            adapter->isac.read_isac       = &fcpci2_read_isac;
            adapter->isac.write_isac      = &fcpci2_write_isac;
            adapter->isac.read_isac_fifo  = &fcpci2_read_isac_fifo;
            adapter->isac.write_isac_fifo = &fcpci2_write_isac_fifo;

            adapter->read_hdlc_status     = &fcpci2_read_hdlc_status;
            adapter->write_ctrl           = &fcpci2_write_ctrl;
            break;
      case AVM_FRITZ_PCI:
            adapter->isac.read_isac       = &fcpci_read_isac;
            adapter->isac.write_isac      = &fcpci_write_isac;
            adapter->isac.read_isac_fifo  = &fcpci_read_isac_fifo;
            adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;

            adapter->read_hdlc_status     = &fcpci_read_hdlc_status;
            adapter->write_ctrl           = &fcpci_write_ctrl;
            break;
      case AVM_FRITZ_PNP:
            adapter->isac.read_isac       = &fcpci_read_isac;
            adapter->isac.write_isac      = &fcpci_write_isac;
            adapter->isac.read_isac_fifo  = &fcpci_read_isac_fifo;
            adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;

            adapter->read_hdlc_status     = &fcpnp_read_hdlc_status;
            adapter->write_ctrl           = &fcpnp_write_ctrl;
            break;
      }

      // Reset
      outb(0, adapter->io + AVM_STATUS0);
      mdelay(10);
      outb(AVM_STATUS0_RESET, adapter->io + AVM_STATUS0);
      mdelay(10);
      outb(0, adapter->io + AVM_STATUS0);
      mdelay(10);

      switch (adapter->type) {
      case AVM_FRITZ_PCIV2:
            fcpci2_init(adapter);
            isacsx_setup(&adapter->isac);
            break;
      case AVM_FRITZ_PCI:
      case AVM_FRITZ_PNP:
            fcpci_init(adapter);
            isac_setup(&adapter->isac);
            break;
      }
      val = adapter->read_hdlc_status(adapter, 0);
      DBG(0x20, "HDLC A STA %x", val);
      val = adapter->read_hdlc_status(adapter, 1);
      DBG(0x20, "HDLC B STA %x", val);

      adapter->bcs[0].mode = -1;
      adapter->bcs[1].mode = -1;
      modehdlc(&adapter->bcs[0], L1_MODE_NULL);
      modehdlc(&adapter->bcs[1], L1_MODE_NULL);

      return 0;

 err_region:
      release_region(adapter->io, 32);
 err:
      return retval;
}

static void __devexit fcpcipnp_release(struct fritz_adapter *adapter)
{
      DBG(1,"");

      outb(0, adapter->io + AVM_STATUS0);
      free_irq(adapter->irq, adapter);
      release_region(adapter->io, 32);
}

// ----------------------------------------------------------------------

static struct fritz_adapter * __devinit 
new_adapter(void)
{
      struct fritz_adapter *adapter;
      struct hisax_b_if *b_if[2];
      int i;

      adapter = kzalloc(sizeof(struct fritz_adapter), GFP_KERNEL);
      if (!adapter)
            return NULL;

      adapter->isac.hisax_d_if.owner = THIS_MODULE;
      adapter->isac.hisax_d_if.ifc.priv = &adapter->isac;
      adapter->isac.hisax_d_if.ifc.l2l1 = isac_d_l2l1;
      
      for (i = 0; i < 2; i++) {
            adapter->bcs[i].adapter = adapter;
            adapter->bcs[i].channel = i;
            adapter->bcs[i].b_if.ifc.priv = &adapter->bcs[i];
            adapter->bcs[i].b_if.ifc.l2l1 = fritz_b_l2l1;
      }

      for (i = 0; i < 2; i++)
            b_if[i] = &adapter->bcs[i].b_if;

      if (hisax_register(&adapter->isac.hisax_d_if, b_if, "fcpcipnp",
                  protocol) != 0) {
            kfree(adapter);
            adapter = NULL;
      }

      return adapter;
}

static void delete_adapter(struct fritz_adapter *adapter)
{
      hisax_unregister(&adapter->isac.hisax_d_if);
      kfree(adapter);
}

static int __devinit fcpci_probe(struct pci_dev *pdev,
                         const struct pci_device_id *ent)
{
      struct fritz_adapter *adapter;
      int retval;

      retval = -ENOMEM;
      adapter = new_adapter();
      if (!adapter)
            goto err;

      pci_set_drvdata(pdev, adapter);

      if (pdev->device == PCI_DEVICE_ID_AVM_A1_V2) 
            adapter->type = AVM_FRITZ_PCIV2;
      else
            adapter->type = AVM_FRITZ_PCI;

      retval = pci_enable_device(pdev);
      if (retval)
            goto err_free;

      adapter->io = pci_resource_start(pdev, 1);
      adapter->irq = pdev->irq;

      printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at %s\n",
             (char *) ent->driver_data, pci_name(pdev));

      retval = fcpcipnp_setup(adapter);
      if (retval)
            goto err_free;

      return 0;
      
 err_free:
      delete_adapter(adapter);
 err:
      return retval;
}

#ifdef __ISAPNP__
static int __devinit fcpnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
{
      struct fritz_adapter *adapter;
      int retval;

      if (!pdev)
            return(-ENODEV);

      retval = -ENOMEM;
      adapter = new_adapter();
      if (!adapter)
            goto err;

      pnp_set_drvdata(pdev, adapter);

      adapter->type = AVM_FRITZ_PNP;

      pnp_disable_dev(pdev);
      retval = pnp_activate_dev(pdev);
      if (retval < 0) {
            printk(KERN_WARNING "%s: pnp_activate_dev(%s) ret(%d)\n", __FUNCTION__,
                  (char *)dev_id->driver_data, retval);
            goto err_free;
      }
      adapter->io = pnp_port_start(pdev, 0);
      adapter->irq = pnp_irq(pdev, 0);

      printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at IO %#x irq %d\n",
             (char *) dev_id->driver_data, adapter->io, adapter->irq);

      retval = fcpcipnp_setup(adapter);
      if (retval)
            goto err_free;

      return 0;
      
 err_free:
      delete_adapter(adapter);
 err:
      return retval;
}

static void __devexit fcpnp_remove(struct pnp_dev *pdev)
{
      struct fritz_adapter *adapter = pnp_get_drvdata(pdev);

      if (adapter) {
            fcpcipnp_release(adapter);
            delete_adapter(adapter);
      }
      pnp_disable_dev(pdev);
}

static struct pnp_driver fcpnp_driver = {
      .name       = "fcpnp",
      .probe            = fcpnp_probe,
      .remove           = __devexit_p(fcpnp_remove),
      .id_table   = fcpnp_ids,
};
#endif

static void __devexit fcpci_remove(struct pci_dev *pdev)
{
      struct fritz_adapter *adapter = pci_get_drvdata(pdev);

      fcpcipnp_release(adapter);
      pci_disable_device(pdev);
      delete_adapter(adapter);
}

static struct pci_driver fcpci_driver = {
      .name       = "fcpci",
      .probe            = fcpci_probe,
      .remove           = __devexit_p(fcpci_remove),
      .id_table   = fcpci_ids,
};

static int __init hisax_fcpcipnp_init(void)
{
      int retval;

      printk(KERN_INFO "hisax_fcpcipnp: Fritz!Card PCI/PCIv2/PnP ISDN driver v0.0.1\n");

      retval = pci_register_driver(&fcpci_driver);
      if (retval)
            return retval;
#ifdef __ISAPNP__
      retval = pnp_register_driver(&fcpnp_driver);
      if (retval < 0) {
            pci_unregister_driver(&fcpci_driver);
            return retval;
      }
#endif
      return 0;
}

static void __exit hisax_fcpcipnp_exit(void)
{
#ifdef __ISAPNP__
      pnp_unregister_driver(&fcpnp_driver);
#endif
      pci_unregister_driver(&fcpci_driver);
}

module_init(hisax_fcpcipnp_init);
module_exit(hisax_fcpcipnp_exit);

Generated by  Doxygen 1.6.0   Back to index