linux/drivers/isdn/hisax/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 <linux/slab.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(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(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);
	wait_event_interruptible(cs->dc.isac.arcofi_wait,
				 cs->dc.isac.arcofi_state == ARCOFI_NOP);
}

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);
	wait_event_interruptible(cs->dc.isac.arcofi_wait,
				 cs->dc.isac.arcofi_state == ARCOFI_NOP);
	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, "%s", 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);
		wait_event_interruptible(cs->dc.isac.arcofi_wait,
				 cs->dc.isac.arcofi_state == ARCOFI_NOP);
		return (1);
	}
	return (0);
}
#endif /* ARCOFI_USE */

static void
elsa_led_handler(struct timer_list *t)
{
	struct IsdnCardState *cs = from_timer(cs, t, hw.elsa.tl);
	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) {
		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->hw.elsa.tl);
		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->hw.elsa.tl);
	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 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[] = {
	{ 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 = &elsa_ids[0];
static struct pnp_card *pnp_c = NULL;
#endif	/* __ISAPNP__ */

static int 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",
						       __func__, err);
						return (0);
					}
					card->para[1] = pnp_port_start(pnp_d, 0);
					card->para[0] = pnp_irq(pnp_d, 0);

					if (card->para[0] == -1 || !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 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
static	struct pci_dev *dev_qs1000 = NULL;
static	struct pci_dev *dev_qs3000 = NULL;

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

	cs->subtyp = 0;
	if ((dev_qs1000 = hisax_find_pci_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 = hisax_find_pci_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 setup_elsa_pci(struct IsdnCard *card)
{
	return (1);
}
#endif /* CONFIG_PCI */

static int 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);
	timer_setup(&cs->hw.elsa.tl, elsa_led_handler, 0);
	/* 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 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);
}