/* $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!
  ");
  		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
  ");
  	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
  ");
  	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, "%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
  ",
  			       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
  ",
  				       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
  ",
  			       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
  ",
  				       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
  ",
  			       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
  ",
  			       cs->hw.elsa.counter);
  			if ((cs->hw.elsa.counter > 10) &&
  			    (cs->hw.elsa.counter < 16)) {
  				printk(KERN_INFO "Elsa: timer and irq OK
  ");
  				ret = 0;
  			} else {
  				printk(KERN_WARNING
  				       "Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict
  ",
  				       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
  ", 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
  ");
  		return (ELSA_PCC16);
  	} else if (1025 == ++pfp_1 * ++pfp_2) {
  		printk(" PCF-Pro found
  ");
  		return (ELSA_PCFPRO);
  	} else if (33 == ++p8_1 * ++p8_2) {
  		printk(" PCC8 found
  ");
  		return (ELSA_PCC8);
  	} else if (17 == ++pc_1 * ++pc_2) {
  		printk(" PC found
  ");
  		return (ELSA_PC);
  	} else {
  		printk(" failed
  ");
  		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
  ");
  	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
  ",
  			       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
  ");
  		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
  ",
  	       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
  ");
  		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
  ",
  					       (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)
  ",
  						       __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] || !card->para[1]) {
  						printk(KERN_ERR "Elsa PnP:some resources are missing %ld/%lx
  ",
  						       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
  ");
  					return (0);
  				}
  			}
  			ipid++;
  			pnp_c = NULL;
  		}
  		if (!ipid->card_vendor) {
  			printk(KERN_INFO "Elsa PnP: no ISAPnP card found
  ");
  			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
  ");
  	}
  	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
  ",
  	       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
  ",
  	       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
  ");
  		return (0);
  	}
  	if (!cs->irq) {
  		printk(KERN_WARNING "Elsa: No IRQ for PCI card found
  ");
  		return (0);
  	}
  
  	if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
  		printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found
  ");
  		return (0);
  	}
  	if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
  		printk(KERN_WARNING "Elsa: You may have a wrong PCI bios
  ");
  		printk(KERN_WARNING "Elsa: If your system hangs now, read
  ");
  		printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax
  ");
  	}
  	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
  ",
  	       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
  ", 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
  ",
  		       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
  ",
  			       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
  ");
  				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
  ");
  			release_io_elsa(cs);
  			return (0);
  		}
  		printk(KERN_INFO "Elsa: timer OK; resetting card
  ");
  	}
  	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
  ", 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
  ");
  			release_io_elsa(cs);
  			return (0);
  		}
  	}
  	if (cs->subtyp == ELSA_PC) {
  		val = readitac(cs, ITAC_SYS);
  		printk(KERN_INFO "Elsa: ITAC version %s
  ", 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
  ", 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);
  }