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

elsa.c

/* $Id: elsa.c,v 2.32.2.4 2004/01/24 20:47:21 keil Exp $
 *
 * low level stuff for Elsa isdn cards
 *
 * Author       Karsten Keil
 * Copyright    by Karsten Keil      <keil@isdn4linux.de>
 * 
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * For changes and modifications please read
 * Documentation/isdn/HiSax.cert
 *
 * Thanks to    Elsa GmbH for documents and information
 *
 *              Klaus Lichtenwalder (Klaus.Lichtenwalder@WebForum.DE)
 *              for ELSA PCMCIA support
 *
 */

#include <linux/init.h>
#include "hisax.h"
#include "arcofi.h"
#include "isac.h"
#include "ipac.h"
#include "hscx.h"
#include "isdnl1.h"
#include <linux/pci.h>
#include <linux/isapnp.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>

static const char *Elsa_revision = "$Revision: 2.32.2.4 $";
static const char *Elsa_Types[] =
{"None", "PC", "PCC-8", "PCC-16", "PCF", "PCF-Pro",
 "PCMCIA", "QS 1000", "QS 3000", "Microlink PCI", "QS 3000 PCI", 
 "PCMCIA-IPAC" };

static const char *ITACVer[] =
{"?0?", "?1?", "?2?", "?3?", "?4?", "V2.2",
 "B1", "A1"};

#define byteout(addr,val) outb(val,addr)
#define bytein(addr) inb(addr)

#define ELSA_ISAC 0
#define ELSA_ISAC_PCM   1
#define ELSA_ITAC 1
#define ELSA_HSCX 2
#define ELSA_ALE  3
#define ELSA_ALE_PCM    4
#define ELSA_CONTROL    4
#define ELSA_CONFIG     5
#define ELSA_START_TIMER 6
#define ELSA_TRIG_IRQ   7

#define ELSA_PC      1
#define ELSA_PCC8    2
#define ELSA_PCC16   3
#define ELSA_PCF     4
#define ELSA_PCFPRO  5
#define ELSA_PCMCIA  6
#define ELSA_QS1000  7
#define ELSA_QS3000  8
#define ELSA_QS1000PCI 9
#define ELSA_QS3000PCI 10
#define ELSA_PCMCIA_IPAC 11

/* PCI stuff */
#define ELSA_PCI_IRQ_MASK     0x04

/* ITAC Registeradressen (only Microlink PC) */
#define ITAC_SYS  0x34
#define ITAC_ISEN 0x48
#define ITAC_RFIE 0x4A
#define ITAC_XFIE 0x4C
#define ITAC_SCIE 0x4E
#define ITAC_STIE 0x46

/***                                                                    ***
 ***   Makros als Befehle fuer die Kartenregister                       ***
 ***   (mehrere Befehle werden durch Bit-Oderung kombiniert)            ***
 ***                                                                    ***/

/* Config-Register (Read) */
#define ELIRQF_TIMER_RUN       0x02 /* Bit 1 des Config-Reg     */
#define ELIRQF_TIMER_RUN_PCC8  0x01 /* Bit 0 des Config-Reg  bei PCC */
#define ELSA_IRQ_IDX       0x38     /* Bit 3,4,5 des Config-Reg */
#define ELSA_IRQ_IDX_PCC8  0x30     /* Bit 4,5 des Config-Reg */
#define ELSA_IRQ_IDX_PC    0x0c     /* Bit 2,3 des Config-Reg */

/* Control-Register (Write) */
#define ELSA_LINE_LED        0x02   /* Bit 1 Gelbe LED */
#define ELSA_STAT_LED        0x08   /* Bit 3 Gruene LED */
#define ELSA_ISDN_RESET      0x20   /* Bit 5 Reset-Leitung */
#define ELSA_ENA_TIMER_INT   0x80   /* Bit 7 Freigabe Timer Interrupt */

/* ALE-Register (Read) */
#define ELSA_HW_RELEASE      0x07   /* Bit 0-2 Hardwarerkennung */
#define ELSA_S0_POWER_BAD    0x08   /* Bit 3 S0-Bus Spannung fehlt */

/* Status Flags */
#define ELIRQF_TIMER_AKTIV 1
#define ELSA_BAD_PWR     2
#define ELSA_ASSIGN      4

#define RS_ISR_PASS_LIMIT 256
#define FLG_MODEM_ACTIVE 1
/* IPAC AUX */
#define ELSA_IPAC_LINE_LED    0x40  /* Bit 6 Gelbe LED */
#define ELSA_IPAC_STAT_LED    0x80  /* Bit 7 Gruene LED */

#if ARCOFI_USE
static struct arcofi_msg ARCOFI_XOP_F =
      {NULL,0,2,{0xa1,0x3f,0,0,0,0,0,0,0,0}}; /* Normal OP */
static struct arcofi_msg ARCOFI_XOP_1 =
      {&ARCOFI_XOP_F,0,2,{0xa1,0x31,0,0,0,0,0,0,0,0}}; /* PWR UP */
static struct arcofi_msg ARCOFI_SOP_F = 
      {&ARCOFI_XOP_1,0,10,{0xa1,0x1f,0x00,0x50,0x10,0x00,0x00,0x80,0x02,0x12}};
static struct arcofi_msg ARCOFI_COP_9 =
      {&ARCOFI_SOP_F,0,10,{0xa1,0x29,0x80,0xcb,0xe9,0x88,0x00,0xc8,0xd8,0x80}}; /* RX */
static struct arcofi_msg ARCOFI_COP_8 =
      {&ARCOFI_COP_9,0,10,{0xa1,0x28,0x49,0x31,0x8,0x13,0x6e,0x88,0x2a,0x61}}; /* TX */
static struct arcofi_msg ARCOFI_COP_7 =
      {&ARCOFI_COP_8,0,4,{0xa1,0x27,0x80,0x80,0,0,0,0,0,0}}; /* GZ */
static struct arcofi_msg ARCOFI_COP_6 =
      {&ARCOFI_COP_7,0,6,{0xa1,0x26,0,0,0x82,0x7c,0,0,0,0}}; /* GRL GRH */
static struct arcofi_msg ARCOFI_COP_5 =
      {&ARCOFI_COP_6,0,4,{0xa1,0x25,0xbb,0x4a,0,0,0,0,0,0}}; /* GTX */
static struct arcofi_msg ARCOFI_VERSION =
      {NULL,1,2,{0xa0,0,0,0,0,0,0,0,0,0}};
static struct arcofi_msg ARCOFI_XOP_0 =
      {NULL,0,2,{0xa1,0x30,0,0,0,0,0,0,0,0}}; /* PWR Down */

static void set_arcofi(struct IsdnCardState *cs, int bc);

#include "elsa_ser.c"
#endif /* ARCOFI_USE */

static inline u_char
readreg(unsigned int ale, unsigned int adr, u_char off)
{
      register u_char ret;

      byteout(ale, off);
      ret = bytein(adr);
      return (ret);
}

static inline void
readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
{
      byteout(ale, off);
      insb(adr, data, size);
}


static inline void
writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
{
      byteout(ale, off);
      byteout(adr, data);
}

static inline void
writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
{
      byteout(ale, off);
      outsb(adr, data, size);
}

/* Interface functions */

static u_char
ReadISAC(struct IsdnCardState *cs, u_char offset)
{
      return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset));
}

static void
WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
{
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset, value);
}

static void
ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
{
      readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
}

static void
WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
{
      writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
}

static u_char
ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
{
      return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset+0x80));
}

static void
WriteISAC_IPAC(struct IsdnCardState *cs, u_char offset, u_char value)
{
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset|0x80, value);
}

static void
ReadISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
{
      readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
}

static void
WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
{
      writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
}

static u_char
ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
{
      return (readreg(cs->hw.elsa.ale,
                  cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0)));
}

static void
WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
{
      writereg(cs->hw.elsa.ale,
             cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0), value);
}

static inline u_char
readitac(struct IsdnCardState *cs, u_char off)
{
      register u_char ret;

      byteout(cs->hw.elsa.ale, off);
      ret = bytein(cs->hw.elsa.itac);
      return (ret);
}

static inline void
writeitac(struct IsdnCardState *cs, u_char off, u_char data)
{
      byteout(cs->hw.elsa.ale, off);
      byteout(cs->hw.elsa.itac, data);
}

static inline int
TimerRun(struct IsdnCardState *cs)
{
      register u_char v;

      v = bytein(cs->hw.elsa.cfg);
      if ((cs->subtyp == ELSA_QS1000) || (cs->subtyp == ELSA_QS3000))
            return (0 == (v & ELIRQF_TIMER_RUN));
      else if (cs->subtyp == ELSA_PCC8)
            return (v & ELIRQF_TIMER_RUN_PCC8);
      return (v & ELIRQF_TIMER_RUN);
}
/*
 * fast interrupt HSCX stuff goes here
 */

#define READHSCX(cs, nr, reg) readreg(cs->hw.elsa.ale, \
            cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0))
#define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.elsa.ale, \
            cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0), data)

#define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.elsa.ale, \
            cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)

#define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.elsa.ale, \
            cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)

#include "hscx_irq.c"

static irqreturn_t
elsa_interrupt(int intno, void *dev_id)
{
      struct IsdnCardState *cs = dev_id;
      u_long flags;
      u_char val;
      int icnt=5;

      if ((cs->typ == ISDN_CTYPE_ELSA_PCMCIA) && (*cs->busy_flag == 1)) {
      /* The card tends to generate interrupts while being removed
         causing us to just crash the kernel. bad. */
            printk(KERN_WARNING "Elsa: card not available!\n");
            return IRQ_NONE;
      }
      spin_lock_irqsave(&cs->lock, flags);
#if ARCOFI_USE
      if (cs->hw.elsa.MFlag) {
            val = serial_inp(cs, UART_IIR);
            if (!(val & UART_IIR_NO_INT)) {
                  debugl1(cs,"IIR %02x", val);
                  rs_interrupt_elsa(intno, cs);
            }
      }
#endif
      val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
      Start_HSCX:
      if (val) {
            hscx_int_main(cs, val);
      }
      val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
      Start_ISAC:
      if (val) {
            isac_interrupt(cs, val);
      }
      val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
      if (val && icnt) {
            if (cs->debug & L1_DEB_HSCX)
                  debugl1(cs, "HSCX IntStat after IntRoutine");
            icnt--;
            goto Start_HSCX;
      }
      val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
      if (val && icnt) {
            if (cs->debug & L1_DEB_ISAC)
                  debugl1(cs, "ISAC IntStat after IntRoutine");
            icnt--;
            goto Start_ISAC;
      }
      if (!icnt)
            printk(KERN_WARNING"ELSA IRQ LOOP\n");
      writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0xFF);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0xFF);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0xFF);
      if (cs->hw.elsa.status & ELIRQF_TIMER_AKTIV) {
            if (!TimerRun(cs)) {
                  /* Timer Restart */
                  byteout(cs->hw.elsa.timer, 0);
                  cs->hw.elsa.counter++;
            }
      }
#if ARCOFI_USE
      if (cs->hw.elsa.MFlag) {
            val = serial_inp(cs, UART_MCR);
            val ^= 0x8;
            serial_outp(cs, UART_MCR, val);
            val = serial_inp(cs, UART_MCR);
            val ^= 0x8;
            serial_outp(cs, UART_MCR, val);
      }
#endif
      if (cs->hw.elsa.trig)
            byteout(cs->hw.elsa.trig, 0x00);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0x0);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0x0);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0x0);
      spin_unlock_irqrestore(&cs->lock, flags);
      return IRQ_HANDLED;
}

static irqreturn_t
elsa_interrupt_ipac(int intno, void *dev_id)
{
      struct IsdnCardState *cs = dev_id;
      u_long flags;
      u_char ista,val;
      int icnt=5;

      spin_lock_irqsave(&cs->lock, flags);
      if (cs->subtyp == ELSA_QS1000PCI || cs->subtyp == ELSA_QS3000PCI) {
            val = bytein(cs->hw.elsa.cfg + 0x4c); /* PCI IRQ */
            if (!(val & ELSA_PCI_IRQ_MASK)) {
                  spin_unlock_irqrestore(&cs->lock, flags);
                  return IRQ_NONE;
            }
      }
#if ARCOFI_USE
      if (cs->hw.elsa.MFlag) {
            val = serial_inp(cs, UART_IIR);
            if (!(val & UART_IIR_NO_INT)) {
                  debugl1(cs,"IIR %02x", val);
                  rs_interrupt_elsa(intno, cs);
            }
      }
#endif
      ista = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
Start_IPAC:
      if (cs->debug & L1_DEB_IPAC)
            debugl1(cs, "IPAC ISTA %02X", ista);
      if (ista & 0x0f) {
            val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
            if (ista & 0x01)
                  val |= 0x01;
            if (ista & 0x04)
                  val |= 0x02;
            if (ista & 0x08)
                  val |= 0x04;
            if (val)
                  hscx_int_main(cs, val);
      }
      if (ista & 0x20) {
            val = 0xfe & readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA + 0x80);
            if (val) {
                  isac_interrupt(cs, val);
            }
      }
      if (ista & 0x10) {
            val = 0x01;
            isac_interrupt(cs, val);
      }
      ista  = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
      if ((ista & 0x3f) && icnt) {
            icnt--;
            goto Start_IPAC;
      }
      if (!icnt)
            printk(KERN_WARNING "ELSA IRQ LOOP\n");
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xFF);
      writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xC0);
      spin_unlock_irqrestore(&cs->lock, flags);
      return IRQ_HANDLED;
}

static void
release_io_elsa(struct IsdnCardState *cs)
{
      int bytecnt = 8;

      del_timer(&cs->hw.elsa.tl);
#if ARCOFI_USE
      clear_arcofi(cs);
#endif
      if (cs->hw.elsa.ctrl)
            byteout(cs->hw.elsa.ctrl, 0); /* LEDs Out */
      if (cs->subtyp == ELSA_QS1000PCI) {
            byteout(cs->hw.elsa.cfg + 0x4c, 0x01);  /* disable IRQ */
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
            bytecnt = 2;
            release_region(cs->hw.elsa.cfg, 0x80);
      }
      if (cs->subtyp == ELSA_QS3000PCI) {
            byteout(cs->hw.elsa.cfg + 0x4c, 0x03); /* disable ELSA PCI IRQ */
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
            release_region(cs->hw.elsa.cfg, 0x80);
      }
      if (cs->subtyp == ELSA_PCMCIA_IPAC) {
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
      }
      if ((cs->subtyp == ELSA_PCFPRO) ||
            (cs->subtyp == ELSA_QS3000) ||
            (cs->subtyp == ELSA_PCF) ||
            (cs->subtyp == ELSA_QS3000PCI)) {
            bytecnt = 16;
#if ARCOFI_USE
            release_modem(cs);
#endif
      }
      if (cs->hw.elsa.base)
            release_region(cs->hw.elsa.base, bytecnt);
}

static void
reset_elsa(struct IsdnCardState *cs)
{
      if (cs->hw.elsa.timer) {
            /* Wait 1 Timer */
            byteout(cs->hw.elsa.timer, 0);
            while (TimerRun(cs));
            cs->hw.elsa.ctrl_reg |= 0x50;
            cs->hw.elsa.ctrl_reg &= ~ELSA_ISDN_RESET; /* Reset On */
            byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
            /* Wait 1 Timer */
            byteout(cs->hw.elsa.timer, 0);
            while (TimerRun(cs));
            cs->hw.elsa.ctrl_reg |= ELSA_ISDN_RESET;  /* Reset Off */
            byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
            /* Wait 1 Timer */
            byteout(cs->hw.elsa.timer, 0);
            while (TimerRun(cs));
            if (cs->hw.elsa.trig)
                  byteout(cs->hw.elsa.trig, 0xff);
      }
      if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x20);
            mdelay(10);
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x00);
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xc0);
            mdelay(10);
            if (cs->subtyp != ELSA_PCMCIA_IPAC) {
                  writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x0);
                  writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0x3c);
            } else {
                  writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_PCFG, 0x10);
                  writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x4);
                  writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0xf8);
            }
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
            if (cs->subtyp == ELSA_QS1000PCI)
                  byteout(cs->hw.elsa.cfg + 0x4c, 0x41); /* enable ELSA PCI IRQ */
            else if (cs->subtyp == ELSA_QS3000PCI)
                  byteout(cs->hw.elsa.cfg + 0x4c, 0x43); /* enable ELSA PCI IRQ */
      }
}

#if ARCOFI_USE

static void
set_arcofi(struct IsdnCardState *cs, int bc) {
      cs->dc.isac.arcofi_bc = bc;
      arcofi_fsm(cs, ARCOFI_START, &ARCOFI_COP_5);
      interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
}

static int
check_arcofi(struct IsdnCardState *cs)
{
      int arcofi_present = 0;
      char tmp[40];
      char *t;
      u_char *p;

      if (!cs->dc.isac.mon_tx)
            if (!(cs->dc.isac.mon_tx=kmalloc(MAX_MON_FRAME, GFP_ATOMIC))) {
                  if (cs->debug & L1_DEB_WARN)
                        debugl1(cs, "ISAC MON TX out of buffers!");
                  return(0);
            }
      cs->dc.isac.arcofi_bc = 0;
      arcofi_fsm(cs, ARCOFI_START, &ARCOFI_VERSION);
      interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
      if (!test_and_clear_bit(FLG_ARCOFI_ERROR, &cs->HW_Flags)) {
                  debugl1(cs, "Arcofi response received %d bytes", cs->dc.isac.mon_rxp);
                  p = cs->dc.isac.mon_rx;
                  t = tmp;
                  t += sprintf(tmp, "Arcofi data");
                  QuickHex(t, p, cs->dc.isac.mon_rxp);
                  debugl1(cs, tmp);
                  if ((cs->dc.isac.mon_rxp == 2) && (cs->dc.isac.mon_rx[0] == 0xa0)) {
                        switch(cs->dc.isac.mon_rx[1]) {
                              case 0x80:
                                    debugl1(cs, "Arcofi 2160 detected");
                                    arcofi_present = 1;
                                    break;
                              case 0x82:
                                    debugl1(cs, "Arcofi 2165 detected");
                                    arcofi_present = 2;
                                    break;
                              case 0x84:
                                    debugl1(cs, "Arcofi 2163 detected");
                                    arcofi_present = 3;
                                    break;
                              default:
                                    debugl1(cs, "unknown Arcofi response");
                                    break;
                        }
                  } else
                        debugl1(cs, "undefined Monitor response");
                  cs->dc.isac.mon_rxp = 0;
      } else if (cs->dc.isac.mon_tx) {
            debugl1(cs, "Arcofi not detected");
      }
      if (arcofi_present) {
            if (cs->subtyp==ELSA_QS1000) {
                  cs->subtyp = ELSA_QS3000;
                  printk(KERN_INFO
                        "Elsa: %s detected modem at 0x%lx\n",
                        Elsa_Types[cs->subtyp],
                        cs->hw.elsa.base+8);
                  release_region(cs->hw.elsa.base, 8);
                  if (!request_region(cs->hw.elsa.base, 16, "elsa isdn modem")) {
                        printk(KERN_WARNING
                              "HiSax: %s config port %lx-%lx already in use\n",
                              Elsa_Types[cs->subtyp],
                              cs->hw.elsa.base + 8,
                              cs->hw.elsa.base + 16);
                  }
            } else if (cs->subtyp==ELSA_PCC16) {
                  cs->subtyp = ELSA_PCF;
                  printk(KERN_INFO
                        "Elsa: %s detected modem at 0x%lx\n",
                        Elsa_Types[cs->subtyp],
                        cs->hw.elsa.base+8);
                  release_region(cs->hw.elsa.base, 8);
                  if (!request_region(cs->hw.elsa.base, 16, "elsa isdn modem")) {
                        printk(KERN_WARNING
                              "HiSax: %s config port %lx-%lx already in use\n",
                              Elsa_Types[cs->subtyp],
                              cs->hw.elsa.base + 8,
                              cs->hw.elsa.base + 16);
                  }
            } else
                  printk(KERN_INFO
                        "Elsa: %s detected modem at 0x%lx\n",
                        Elsa_Types[cs->subtyp],
                        cs->hw.elsa.base+8);
            arcofi_fsm(cs, ARCOFI_START, &ARCOFI_XOP_0);
            interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
            return(1);
      }
      return(0);
}
#endif /* ARCOFI_USE */

static void
elsa_led_handler(struct IsdnCardState *cs)
{
      int blink = 0;

      if (cs->subtyp == ELSA_PCMCIA || cs->subtyp == ELSA_PCMCIA_IPAC)
            return;
      del_timer(&cs->hw.elsa.tl);
      if (cs->hw.elsa.status & ELSA_ASSIGN)
            cs->hw.elsa.ctrl_reg |= ELSA_STAT_LED;
      else if (cs->hw.elsa.status & ELSA_BAD_PWR)
            cs->hw.elsa.ctrl_reg &= ~ELSA_STAT_LED;
      else {
            cs->hw.elsa.ctrl_reg ^= ELSA_STAT_LED;
            blink = 250;
      }
      if (cs->hw.elsa.status & 0xf000)
            cs->hw.elsa.ctrl_reg |= ELSA_LINE_LED;
      else if (cs->hw.elsa.status & 0x0f00) {
            cs->hw.elsa.ctrl_reg ^= ELSA_LINE_LED;
            blink = 500;
      } else
            cs->hw.elsa.ctrl_reg &= ~ELSA_LINE_LED;

      if ((cs->subtyp == ELSA_QS1000PCI) ||
            (cs->subtyp == ELSA_QS3000PCI)) {
            u_char led = 0xff;
            if (cs->hw.elsa.ctrl_reg & ELSA_LINE_LED)
                  led ^= ELSA_IPAC_LINE_LED;
            if (cs->hw.elsa.ctrl_reg & ELSA_STAT_LED)
                  led ^= ELSA_IPAC_STAT_LED;
            writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, led);
      } else
            byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
      if (blink) {
            init_timer(&cs->hw.elsa.tl);
            cs->hw.elsa.tl.expires = jiffies + ((blink * HZ) / 1000);
            add_timer(&cs->hw.elsa.tl);
      }
}

static int
Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
      int ret = 0;
      u_long flags;

      switch (mt) {
            case CARD_RESET:
                  spin_lock_irqsave(&cs->lock, flags);
                  reset_elsa(cs);
                  spin_unlock_irqrestore(&cs->lock, flags);
                  return(0);
            case CARD_RELEASE:
                  release_io_elsa(cs);
                  return(0);
            case CARD_INIT:
                  spin_lock_irqsave(&cs->lock, flags);
                  cs->debug |= L1_DEB_IPAC;
                  reset_elsa(cs);
                  inithscxisac(cs, 1);
                  if ((cs->subtyp == ELSA_QS1000) ||
                      (cs->subtyp == ELSA_QS3000))
                  {
                        byteout(cs->hw.elsa.timer, 0);
                  }
                  if (cs->hw.elsa.trig)
                        byteout(cs->hw.elsa.trig, 0xff);
                  inithscxisac(cs, 2);
                  spin_unlock_irqrestore(&cs->lock, flags);
                  return(0);
            case CARD_TEST:
                  if ((cs->subtyp == ELSA_PCMCIA) ||
                        (cs->subtyp == ELSA_PCMCIA_IPAC) ||
                        (cs->subtyp == ELSA_QS1000PCI)) {
                        return(0);
                  } else if (cs->subtyp == ELSA_QS3000PCI) {
                        ret = 0;
                  } else {
                        spin_lock_irqsave(&cs->lock, flags);
                        cs->hw.elsa.counter = 0;
                        cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
                        cs->hw.elsa.status |= ELIRQF_TIMER_AKTIV;
                        byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
                        byteout(cs->hw.elsa.timer, 0);
                        spin_unlock_irqrestore(&cs->lock, flags);
                        msleep(110);
                        spin_lock_irqsave(&cs->lock, flags);
                        cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
                        byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
                        cs->hw.elsa.status &= ~ELIRQF_TIMER_AKTIV;
                        spin_unlock_irqrestore(&cs->lock, flags);
                        printk(KERN_INFO "Elsa: %d timer tics in 110 msek\n",
                               cs->hw.elsa.counter);
                        if ((cs->hw.elsa.counter > 10) &&
                              (cs->hw.elsa.counter < 16)) {
                              printk(KERN_INFO "Elsa: timer and irq OK\n");
                              ret = 0;
                        } else {
                              printk(KERN_WARNING
                                     "Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n",
                                     cs->hw.elsa.counter, cs->irq);
                              ret = 1;
                        }
                  }
#if ARCOFI_USE
                  if (check_arcofi(cs)) {
                        init_modem(cs);
                  }
#endif
                  elsa_led_handler(cs);
                  return(ret);
            case (MDL_REMOVE | REQUEST):
                  cs->hw.elsa.status &= 0;
                  break;
            case (MDL_ASSIGN | REQUEST):
                  cs->hw.elsa.status |= ELSA_ASSIGN;
                  break;
            case MDL_INFO_SETUP:
                  if ((long) arg)
                        cs->hw.elsa.status |= 0x0200;
                  else
                        cs->hw.elsa.status |= 0x0100;
                  break;
            case MDL_INFO_CONN:
                  if ((long) arg)
                        cs->hw.elsa.status |= 0x2000;
                  else
                        cs->hw.elsa.status |= 0x1000;
                  break;
            case MDL_INFO_REL:
                  if ((long) arg) {
                        cs->hw.elsa.status &= ~0x2000;
                        cs->hw.elsa.status &= ~0x0200;
                  } else {
                        cs->hw.elsa.status &= ~0x1000;
                        cs->hw.elsa.status &= ~0x0100;
                  }
                  break;
#if ARCOFI_USE
            case CARD_AUX_IND:
                  if (cs->hw.elsa.MFlag) {
                        int len;
                        u_char *msg;

                        if (!arg)
                              return(0);
                        msg = arg;
                        len = *msg;
                        msg++;
                        modem_write_cmd(cs, msg, len);
                  }
                  break;
#endif
      }
      if (cs->typ == ISDN_CTYPE_ELSA) {
            int pwr = bytein(cs->hw.elsa.ale);
            if (pwr & 0x08)
                  cs->hw.elsa.status |= ELSA_BAD_PWR;
            else
                  cs->hw.elsa.status &= ~ELSA_BAD_PWR;
      }
      elsa_led_handler(cs);
      return(ret);
}

static unsigned char
probe_elsa_adr(unsigned int adr, int typ)
{
      int i, in1, in2, p16_1 = 0, p16_2 = 0, p8_1 = 0, p8_2 = 0, pc_1 = 0,
       pc_2 = 0, pfp_1 = 0, pfp_2 = 0;

      /* In case of the elsa pcmcia card, this region is in use,
         reserved for us by the card manager. So we do not check it
         here, it would fail. */
      if (typ != ISDN_CTYPE_ELSA_PCMCIA) {
            if (request_region(adr, 8, "elsa card")) {
                  release_region(adr, 8);
            } else {
                  printk(KERN_WARNING
                         "Elsa: Probing Port 0x%x: already in use\n", adr);
                  return (0);
            }
      }
      for (i = 0; i < 16; i++) {
            in1 = inb(adr + ELSA_CONFIG); /* 'toggelt' bei */
            in2 = inb(adr + ELSA_CONFIG); /* jedem Zugriff */
            p16_1 += 0x04 & in1;
            p16_2 += 0x04 & in2;
            p8_1 += 0x02 & in1;
            p8_2 += 0x02 & in2;
            pc_1 += 0x01 & in1;
            pc_2 += 0x01 & in2;
            pfp_1 += 0x40 & in1;
            pfp_2 += 0x40 & in2;
      }
      printk(KERN_INFO "Elsa: Probing IO 0x%x", adr);
      if (65 == ++p16_1 * ++p16_2) {
            printk(" PCC-16/PCF found\n");
            return (ELSA_PCC16);
      } else if (1025 == ++pfp_1 * ++pfp_2) {
            printk(" PCF-Pro found\n");
            return (ELSA_PCFPRO);
      } else if (33 == ++p8_1 * ++p8_2) {
            printk(" PCC8 found\n");
            return (ELSA_PCC8);
      } else if (17 == ++pc_1 * ++pc_2) {
            printk(" PC found\n");
            return (ELSA_PC);
      } else {
            printk(" failed\n");
            return (0);
      }
}

static unsigned int
probe_elsa(struct IsdnCardState *cs)
{
      int i;
      unsigned int CARD_portlist[] =
      {0x160, 0x170, 0x260, 0x360, 0};

      for (i = 0; CARD_portlist[i]; i++) {
            if ((cs->subtyp = probe_elsa_adr(CARD_portlist[i], cs->typ)))
                  break;
      }
      return (CARD_portlist[i]);
}

static int __devinit
setup_elsa_isa(struct IsdnCard *card)
{
      struct IsdnCardState *cs = card->cs;
      u_char val;

      cs->hw.elsa.base = card->para[0];
      printk(KERN_INFO "Elsa: Microlink IO probing\n");
      if (cs->hw.elsa.base) {
            if (!(cs->subtyp = probe_elsa_adr(cs->hw.elsa.base,
                                      cs->typ))) {
                  printk(KERN_WARNING
                         "Elsa: no Elsa Microlink at %#lx\n",
                         cs->hw.elsa.base);
                  return (0);
            }
      } else
            cs->hw.elsa.base = probe_elsa(cs);

      if (!cs->hw.elsa.base) {
            printk(KERN_WARNING
                   "No Elsa Microlink found\n");
            return (0);
      }

      cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
      cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
      cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
      cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
      cs->hw.elsa.itac = cs->hw.elsa.base + ELSA_ITAC;
      cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
      cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
      cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
      val = bytein(cs->hw.elsa.cfg);
      if (cs->subtyp == ELSA_PC) {
            const u_char CARD_IrqTab[8] =
            {7, 3, 5, 9, 0, 0, 0, 0};
            cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PC) >> 2];
      } else if (cs->subtyp == ELSA_PCC8) {
            const u_char CARD_IrqTab[8] =
            {7, 3, 5, 9, 0, 0, 0, 0};
            cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PCC8) >> 4];
      } else {
            const u_char CARD_IrqTab[8] =
            {15, 10, 15, 3, 11, 5, 11, 9};
            cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX) >> 3];
      }
      val = bytein(cs->hw.elsa.ale) & ELSA_HW_RELEASE;
      if (val < 3)
            val |= 8;
      val += 'A' - 3;
      if (val == 'B' || val == 'C')
            val ^= 1;
      if ((cs->subtyp == ELSA_PCFPRO) && (val == 'G'))
            val = 'C';
      printk(KERN_INFO
             "Elsa: %s found at %#lx Rev.:%c IRQ %d\n",
             Elsa_Types[cs->subtyp],
             cs->hw.elsa.base,
             val, cs->irq);
      val = bytein(cs->hw.elsa.ale) & ELSA_S0_POWER_BAD;
      if (val) {
            printk(KERN_WARNING
               "Elsa: Microlink S0 bus power bad\n");
            cs->hw.elsa.status |= ELSA_BAD_PWR;
      }

      return (1);
}

#ifdef __ISAPNP__
static struct isapnp_device_id elsa_ids[] __devinitdata = {
      { ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0133),
        ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0133), 
        (unsigned long) "Elsa QS1000" },
      { ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0134),
        ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0134), 
        (unsigned long) "Elsa QS3000" },
      { 0, }
};

static struct isapnp_device_id *ipid __devinitdata = &elsa_ids[0];
static struct pnp_card *pnp_c __devinitdata = NULL;
#endif      /* __ISAPNP__ */

static int __devinit
setup_elsa_isapnp(struct IsdnCard *card)
{
      struct IsdnCardState *cs = card->cs;

#ifdef __ISAPNP__
      if (!card->para[1] && isapnp_present()) {
            struct pnp_dev *pnp_d;
            while(ipid->card_vendor) {
                  if ((pnp_c = pnp_find_card(ipid->card_vendor,
                        ipid->card_device, pnp_c))) {
                        pnp_d = NULL;
                        if ((pnp_d = pnp_find_dev(pnp_c,
                              ipid->vendor, ipid->function, pnp_d))) {
                              int err;

                              printk(KERN_INFO "HiSax: %s detected\n",
                                    (char *)ipid->driver_data);
                              pnp_disable_dev(pnp_d);
                              err = pnp_activate_dev(pnp_d);
                              if (err<0) {
                                    printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
                                          __FUNCTION__, err);
                                    return(0);
                              }
                              card->para[1] = pnp_port_start(pnp_d, 0);
                              card->para[0] = pnp_irq(pnp_d, 0);

                              if (!card->para[0] || !card->para[1]) {
                                    printk(KERN_ERR "Elsa PnP:some resources are missing %ld/%lx\n",
                                          card->para[0], card->para[1]);
                                    pnp_disable_dev(pnp_d);
                                    return(0);
                              }
                              if (ipid->function == ISAPNP_FUNCTION(0x133))
                                    cs->subtyp = ELSA_QS1000;
                              else
                                    cs->subtyp = ELSA_QS3000;
                              break;
                        } else {
                              printk(KERN_ERR "Elsa PnP: PnP error card found, no device\n");
                              return(0);
                        }
                  }
                  ipid++;
                  pnp_c=NULL;
            } 
            if (!ipid->card_vendor) {
                  printk(KERN_INFO "Elsa PnP: no ISAPnP card found\n");
                  return(0);
            }
      }
#endif      /* __ISAPNP__ */

      if (card->para[1] && card->para[0]) { 
            cs->hw.elsa.base = card->para[1];
            cs->irq = card->para[0];
            if (!cs->subtyp)
                  cs->subtyp = ELSA_QS1000;
      } else {
            printk(KERN_ERR "Elsa PnP: no parameter\n");
      }
      cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
      cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
      cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
      cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
      cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
      cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
      cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
      printk(KERN_INFO
             "Elsa: %s defined at %#lx IRQ %d\n",
             Elsa_Types[cs->subtyp],
             cs->hw.elsa.base,
             cs->irq);

      return (1);
}

static void __devinit
setup_elsa_pcmcia(struct IsdnCard *card)
{
      struct IsdnCardState *cs = card->cs;
      u_char val;

      cs->hw.elsa.base = card->para[1];
      cs->irq = card->para[0];
      val = readreg(cs->hw.elsa.base + 0, cs->hw.elsa.base + 2, IPAC_ID);
      if ((val == 1) || (val == 2)) { /* IPAC version 1.1/1.2 */
            cs->subtyp = ELSA_PCMCIA_IPAC;
            cs->hw.elsa.ale = cs->hw.elsa.base + 0;
            cs->hw.elsa.isac = cs->hw.elsa.base + 2;
            cs->hw.elsa.hscx = cs->hw.elsa.base + 2;
            test_and_set_bit(HW_IPAC, &cs->HW_Flags);
      } else {
            cs->subtyp = ELSA_PCMCIA;
            cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE_PCM;
            cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC_PCM;
            cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
      }
      cs->hw.elsa.timer = 0;
      cs->hw.elsa.trig = 0;
      cs->hw.elsa.ctrl = 0;
      cs->irq_flags |= IRQF_SHARED;
      printk(KERN_INFO
             "Elsa: %s defined at %#lx IRQ %d\n",
             Elsa_Types[cs->subtyp],
             cs->hw.elsa.base,
             cs->irq);
}

#ifdef CONFIG_PCI_LEGACY
static      struct pci_dev *dev_qs1000 __devinitdata = NULL;
static      struct pci_dev *dev_qs3000 __devinitdata = NULL;

static int __devinit
setup_elsa_pci(struct IsdnCard *card)
{
      struct IsdnCardState *cs = card->cs;

      cs->subtyp = 0;
      if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
            PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
            if (pci_enable_device(dev_qs1000))
                  return(0);
            cs->subtyp = ELSA_QS1000PCI;
            cs->irq = dev_qs1000->irq;
            cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
            cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
      } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
            PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
            if (pci_enable_device(dev_qs3000))
                  return(0);
            cs->subtyp = ELSA_QS3000PCI;
            cs->irq = dev_qs3000->irq;
            cs->hw.elsa.cfg = pci_resource_start(dev_qs3000, 1);
            cs->hw.elsa.base = pci_resource_start(dev_qs3000, 3);
      } else {
            printk(KERN_WARNING "Elsa: No PCI card found\n");
            return(0);
      }
      if (!cs->irq) {
            printk(KERN_WARNING "Elsa: No IRQ for PCI card found\n");
            return(0);
      }

      if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
            printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found\n");
            return(0);
      }
      if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
            printk(KERN_WARNING "Elsa: You may have a wrong PCI bios\n");
            printk(KERN_WARNING "Elsa: If your system hangs now, read\n");
            printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax\n");
      }
      cs->hw.elsa.ale  = cs->hw.elsa.base;
      cs->hw.elsa.isac = cs->hw.elsa.base +1;
      cs->hw.elsa.hscx = cs->hw.elsa.base +1; 
      test_and_set_bit(HW_IPAC, &cs->HW_Flags);
      cs->hw.elsa.timer = 0;
      cs->hw.elsa.trig  = 0;
      cs->irq_flags |= IRQF_SHARED;
      printk(KERN_INFO
             "Elsa: %s defined at %#lx/0x%x IRQ %d\n",
             Elsa_Types[cs->subtyp],
             cs->hw.elsa.base,
             cs->hw.elsa.cfg,
             cs->irq);

      return (1);
}

#else

static int __devinit
setup_elsa_pci(struct IsdnCard *card)
{
      return (1);
}
#endif /* CONFIG_PCI_LEGACY */

static int __devinit
setup_elsa_common(struct IsdnCard *card)
{
      struct IsdnCardState *cs = card->cs;
      u_char val;
      int bytecnt;

      switch (cs->subtyp) {
            case ELSA_PC:
            case ELSA_PCC8:
            case ELSA_PCC16:
            case ELSA_QS1000:
            case ELSA_PCMCIA:
            case ELSA_PCMCIA_IPAC:
                  bytecnt = 8;
                  break;
            case ELSA_PCFPRO:
            case ELSA_PCF:
            case ELSA_QS3000:
            case ELSA_QS3000PCI:
                  bytecnt = 16;
                  break;
            case ELSA_QS1000PCI:
                  bytecnt = 2;
                  break;
            default:
                  printk(KERN_WARNING
                         "Unknown ELSA subtype %d\n", cs->subtyp);
                  return (0);
      }
      /* In case of the elsa pcmcia card, this region is in use,
         reserved for us by the card manager. So we do not check it
         here, it would fail. */
      if (cs->typ != ISDN_CTYPE_ELSA_PCMCIA && !request_region(cs->hw.elsa.base, bytecnt, "elsa isdn")) {
            printk(KERN_WARNING
                   "HiSax: ELSA config port %#lx-%#lx already in use\n",
                   cs->hw.elsa.base,
                   cs->hw.elsa.base + bytecnt);
            return (0);
      }
      if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI)) {
            if (!request_region(cs->hw.elsa.cfg, 0x80, "elsa isdn pci")) {
                  printk(KERN_WARNING
                         "HiSax: ELSA pci port %x-%x already in use\n",
                        cs->hw.elsa.cfg,
                        cs->hw.elsa.cfg + 0x80);
                  release_region(cs->hw.elsa.base, bytecnt);
                  return (0);
            }
      }
#if ARCOFI_USE
      init_arcofi(cs);
#endif
      setup_isac(cs);
      cs->hw.elsa.tl.function = (void *) elsa_led_handler;
      cs->hw.elsa.tl.data = (long) cs;
      init_timer(&cs->hw.elsa.tl);
      /* Teste Timer */
      if (cs->hw.elsa.timer) {
            byteout(cs->hw.elsa.trig, 0xff);
            byteout(cs->hw.elsa.timer, 0);
            if (!TimerRun(cs)) {
                  byteout(cs->hw.elsa.timer, 0);      /* 2. Versuch */
                  if (!TimerRun(cs)) {
                        printk(KERN_WARNING
                               "Elsa: timer do not start\n");
                        release_io_elsa(cs);
                        return (0);
                  }
            }
            HZDELAY((HZ/100) + 1);  /* wait >=10 ms */
            if (TimerRun(cs)) {
                  printk(KERN_WARNING "Elsa: timer do not run down\n");
                  release_io_elsa(cs);
                  return (0);
            }
            printk(KERN_INFO "Elsa: timer OK; resetting card\n");
      }
      cs->BC_Read_Reg = &ReadHSCX;
      cs->BC_Write_Reg = &WriteHSCX;
      cs->BC_Send_Data = &hscx_fill_fifo;
      cs->cardmsg = &Elsa_card_msg;
      if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
            cs->readisac = &ReadISAC_IPAC;
            cs->writeisac = &WriteISAC_IPAC;
            cs->readisacfifo = &ReadISACfifo_IPAC;
            cs->writeisacfifo = &WriteISACfifo_IPAC;
            cs->irq_func = &elsa_interrupt_ipac;
            val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ID);
            printk(KERN_INFO "Elsa: IPAC version %x\n", val);
      } else {
            cs->readisac = &ReadISAC;
            cs->writeisac = &WriteISAC;
            cs->readisacfifo = &ReadISACfifo;
            cs->writeisacfifo = &WriteISACfifo;
            cs->irq_func = &elsa_interrupt;
            ISACVersion(cs, "Elsa:");
            if (HscxVersion(cs, "Elsa:")) {
                  printk(KERN_WARNING
                        "Elsa: wrong HSCX versions check IO address\n");
                  release_io_elsa(cs);
                  return (0);
            }
      }
      if (cs->subtyp == ELSA_PC) {
            val = readitac(cs, ITAC_SYS);
            printk(KERN_INFO "Elsa: ITAC version %s\n", ITACVer[val & 7]);
            writeitac(cs, ITAC_ISEN, 0);
            writeitac(cs, ITAC_RFIE, 0);
            writeitac(cs, ITAC_XFIE, 0);
            writeitac(cs, ITAC_SCIE, 0);
            writeitac(cs, ITAC_STIE, 0);
      }
      return (1);
}

int __devinit
setup_elsa(struct IsdnCard *card)
{
      int rc;
      struct IsdnCardState *cs = card->cs;
      char tmp[64];

      strcpy(tmp, Elsa_revision);
      printk(KERN_INFO "HiSax: Elsa driver Rev. %s\n", HiSax_getrev(tmp));
      cs->hw.elsa.ctrl_reg = 0;
      cs->hw.elsa.status = 0;
      cs->hw.elsa.MFlag = 0;
      cs->subtyp = 0;

      if (cs->typ == ISDN_CTYPE_ELSA) {
            rc = setup_elsa_isa(card);
            if (!rc)
                  return (0);

      } else if (cs->typ == ISDN_CTYPE_ELSA_PNP) {
            rc = setup_elsa_isapnp(card);
            if (!rc)
                  return (0);

      } else if (cs->typ == ISDN_CTYPE_ELSA_PCMCIA)
            setup_elsa_pcmcia(card);

      else if (cs->typ == ISDN_CTYPE_ELSA_PCI) {
            rc = setup_elsa_pci(card);
            if (!rc)
                  return (0);

      } else 
            return (0);

      return setup_elsa_common(card);
}

Generated by  Doxygen 1.6.0   Back to index