git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/hisax/elsa.c

   1 /* $Id: elsa.c,v 2.32.2.4 2004/01/24 20:47:21 keil Exp $
   2  *
   3  * low level stuff for Elsa isdn cards
   4  *
   5  * Author       Karsten Keil
   6  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  * For changes and modifications please read
  12  * Documentation/isdn/HiSax.cert
  13  *
  14  * Thanks to    Elsa GmbH for documents and information
  15  *
  16  *              Klaus Lichtenwalder (Klaus.Lichtenwalder@WebForum.DE)
  17  *              for ELSA PCMCIA support
  18  *
  19  */
  20
  21 #include <linux/init.h>
  22 #include "hisax.h"
  23 #include "arcofi.h"
  24 #include "isac.h"
  25 #include "ipac.h"
  26 #include "hscx.h"
  27 #include "isdnl1.h"
  28 #include <linux/pci.h>
  29 #include <linux/isapnp.h>
  30 #include <linux/serial.h>
  31 #include <linux/serial_reg.h>
  32
  33 static const char *Elsa_revision = "$Revision: 2.32.2.4 $";
  34 static const char *Elsa_Types[] =
  35 {"None", "PC", "PCC-8", "PCC-16", "PCF", "PCF-Pro",
  36  "PCMCIA", "QS 1000", "QS 3000", "Microlink PCI", "QS 3000 PCI",
  37  "PCMCIA-IPAC" };
  38
  39 static const char *ITACVer[] =
  40 {"?0?", "?1?", "?2?", "?3?", "?4?", "V2.2",
  41  "B1", "A1"};
  42
  43 #define byteout(addr,val) outb(val,addr)
  44 #define bytein(addr) inb(addr)
  45
  46 #define ELSA_ISAC       0
  47 #define ELSA_ISAC_PCM   1
  48 #define ELSA_ITAC       1
  49 #define ELSA_HSCX       2
  50 #define ELSA_ALE        3
  51 #define ELSA_ALE_PCM    4
  52 #define ELSA_CONTROL    4
  53 #define ELSA_CONFIG     5
  54 #define ELSA_START_TIMER 6
  55 #define ELSA_TRIG_IRQ   7
  56
  57 #define ELSA_PC      1
  58 #define ELSA_PCC8    2
  59 #define ELSA_PCC16   3
  60 #define ELSA_PCF     4
  61 #define ELSA_PCFPRO  5
  62 #define ELSA_PCMCIA  6
  63 #define ELSA_QS1000  7
  64 #define ELSA_QS3000  8
  65 #define ELSA_QS1000PCI 9
  66 #define ELSA_QS3000PCI 10
  67 #define ELSA_PCMCIA_IPAC 11
  68
  69 /* PCI stuff */
  70 #define ELSA_PCI_IRQ_MASK       0x04
  71
  72 /* ITAC Registeradressen (only Microlink PC) */
  73 #define ITAC_SYS        0x34
  74 #define ITAC_ISEN       0x48
  75 #define ITAC_RFIE       0x4A
  76 #define ITAC_XFIE       0x4C
  77 #define ITAC_SCIE       0x4E
  78 #define ITAC_STIE       0x46
  79
  80 /***                                                                    ***
  81  ***   Makros als Befehle fuer die Kartenregister                       ***
  82  ***   (mehrere Befehle werden durch Bit-Oderung kombiniert)            ***
  83  ***                                                                    ***/
  84
  85 /* Config-Register (Read) */
  86 #define ELIRQF_TIMER_RUN       0x02     /* Bit 1 des Config-Reg     */
  87 #define ELIRQF_TIMER_RUN_PCC8  0x01     /* Bit 0 des Config-Reg  bei PCC */
  88 #define ELSA_IRQ_IDX       0x38 /* Bit 3,4,5 des Config-Reg */
  89 #define ELSA_IRQ_IDX_PCC8  0x30 /* Bit 4,5 des Config-Reg */
  90 #define ELSA_IRQ_IDX_PC    0x0c /* Bit 2,3 des Config-Reg */
  91
  92 /* Control-Register (Write) */
  93 #define ELSA_LINE_LED        0x02       /* Bit 1 Gelbe LED */
  94 #define ELSA_STAT_LED        0x08       /* Bit 3 Gruene LED */
  95 #define ELSA_ISDN_RESET      0x20       /* Bit 5 Reset-Leitung */
  96 #define ELSA_ENA_TIMER_INT   0x80       /* Bit 7 Freigabe Timer Interrupt */
  97
  98 /* ALE-Register (Read) */
  99 #define ELSA_HW_RELEASE      0x07       /* Bit 0-2 Hardwarerkennung */
 100 #define ELSA_S0_POWER_BAD    0x08       /* Bit 3 S0-Bus Spannung fehlt */
 101
 102 /* Status Flags */
 103 #define ELIRQF_TIMER_AKTIV 1
 104 #define ELSA_BAD_PWR     2
 105 #define ELSA_ASSIGN      4
 106
 107 #define RS_ISR_PASS_LIMIT 256
 108 #define FLG_MODEM_ACTIVE 1
 109 /* IPAC AUX */
 110 #define ELSA_IPAC_LINE_LED      0x40    /* Bit 6 Gelbe LED */
 111 #define ELSA_IPAC_STAT_LED      0x80    /* Bit 7 Gruene LED */
 112
 113 #if ARCOFI_USE
 114 static struct arcofi_msg ARCOFI_XOP_F =
 115         {NULL,0,2,{0xa1,0x3f,0,0,0,0,0,0,0,0}}; /* Normal OP */
 116 static struct arcofi_msg ARCOFI_XOP_1 =
 117         {&ARCOFI_XOP_F,0,2,{0xa1,0x31,0,0,0,0,0,0,0,0}}; /* PWR UP */
 118 static struct arcofi_msg ARCOFI_SOP_F =
 119         {&ARCOFI_XOP_1,0,10,{0xa1,0x1f,0x00,0x50,0x10,0x00,0x00,0x80,0x02,0x12}};
 120 static struct arcofi_msg ARCOFI_COP_9 =
 121         {&ARCOFI_SOP_F,0,10,{0xa1,0x29,0x80,0xcb,0xe9,0x88,0x00,0xc8,0xd8,0x80}}; /* RX */
 122 static struct arcofi_msg ARCOFI_COP_8 =
 123         {&ARCOFI_COP_9,0,10,{0xa1,0x28,0x49,0x31,0x8,0x13,0x6e,0x88,0x2a,0x61}}; /* TX */
 124 static struct arcofi_msg ARCOFI_COP_7 =
 125         {&ARCOFI_COP_8,0,4,{0xa1,0x27,0x80,0x80,0,0,0,0,0,0}}; /* GZ */
 126 static struct arcofi_msg ARCOFI_COP_6 =
 127         {&ARCOFI_COP_7,0,6,{0xa1,0x26,0,0,0x82,0x7c,0,0,0,0}}; /* GRL GRH */
 128 static struct arcofi_msg ARCOFI_COP_5 =
 129         {&ARCOFI_COP_6,0,4,{0xa1,0x25,0xbb,0x4a,0,0,0,0,0,0}}; /* GTX */
 130 static struct arcofi_msg ARCOFI_VERSION =
 131         {NULL,1,2,{0xa0,0,0,0,0,0,0,0,0,0}};
 132 static struct arcofi_msg ARCOFI_XOP_0 =
 133         {NULL,0,2,{0xa1,0x30,0,0,0,0,0,0,0,0}}; /* PWR Down */
 134
 135 static void set_arcofi(struct IsdnCardState *cs, int bc);
 136
 137 #include "elsa_ser.c"
 138 #endif /* ARCOFI_USE */
 139
 140 static inline u_char
 141 readreg(unsigned int ale, unsigned int adr, u_char off)
 142 {
 143         register u_char ret;
 144
 145         byteout(ale, off);
 146         ret = bytein(adr);
 147         return (ret);
 148 }
 149
 150 static inline void
 151 readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
 152 {
 153         byteout(ale, off);
 154         insb(adr, data, size);
 155 }
 156
 157
 158 static inline void
 159 writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
 160 {
 161         byteout(ale, off);
 162         byteout(adr, data);
 163 }
 164
 165 static inline void
 166 writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
 167 {
 168         byteout(ale, off);
 169         outsb(adr, data, size);
 170 }
 171
 172 /* Interface functions */
 173
 174 static u_char
 175 ReadISAC(struct IsdnCardState *cs, u_char offset)
 176 {
 177         return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset));
 178 }
 179
 180 static void
 181 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
 182 {
 183         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset, value);
 184 }
 185
 186 static void
 187 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 188 {
 189         readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
 190 }
 191
 192 static void
 193 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 194 {
 195         writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
 196 }
 197
 198 static u_char
 199 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
 200 {
 201         return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset+0x80));
 202 }
 203
 204 static void
 205 WriteISAC_IPAC(struct IsdnCardState *cs, u_char offset, u_char value)
 206 {
 207         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset|0x80, value);
 208 }
 209
 210 static void
 211 ReadISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 212 {
 213         readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
 214 }
 215
 216 static void
 217 WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 218 {
 219         writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
 220 }
 221
 222 static u_char
 223 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 224 {
 225         return (readreg(cs->hw.elsa.ale,
 226                         cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0)));
 227 }
 228
 229 static void
 230 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
 231 {
 232         writereg(cs->hw.elsa.ale,
 233                  cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0), value);
 234 }
 235
 236 static inline u_char
 237 readitac(struct IsdnCardState *cs, u_char off)
 238 {
 239         register u_char ret;
 240
 241         byteout(cs->hw.elsa.ale, off);
 242         ret = bytein(cs->hw.elsa.itac);
 243         return (ret);
 244 }
 245
 246 static inline void
 247 writeitac(struct IsdnCardState *cs, u_char off, u_char data)
 248 {
 249         byteout(cs->hw.elsa.ale, off);
 250         byteout(cs->hw.elsa.itac, data);
 251 }
 252
 253 static inline int
 254 TimerRun(struct IsdnCardState *cs)
 255 {
 256         register u_char v;
 257
 258         v = bytein(cs->hw.elsa.cfg);
 259         if ((cs->subtyp == ELSA_QS1000) || (cs->subtyp == ELSA_QS3000))
 260                 return (0 == (v & ELIRQF_TIMER_RUN));
 261         else if (cs->subtyp == ELSA_PCC8)
 262                 return (v & ELIRQF_TIMER_RUN_PCC8);
 263         return (v & ELIRQF_TIMER_RUN);
 264 }
 265 /*
 266  * fast interrupt HSCX stuff goes here
 267  */
 268
 269 #define READHSCX(cs, nr, reg) readreg(cs->hw.elsa.ale, \
 270                 cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0))
 271 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.elsa.ale, \
 272                 cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0), data)
 273
 274 #define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.elsa.ale, \
 275                 cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)
 276
 277 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.elsa.ale, \
 278                 cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)
 279
 280 #include "hscx_irq.c"
 281
 282 static irqreturn_t
 283 elsa_interrupt(int intno, void *dev_id)
 284 {
 285         struct IsdnCardState *cs = dev_id;
 286         u_long flags;
 287         u_char val;
 288         int icnt=5;
 289
 290         if ((cs->typ == ISDN_CTYPE_ELSA_PCMCIA) && (*cs->busy_flag == 1)) {
 291         /* The card tends to generate interrupts while being removed
 292            causing us to just crash the kernel. bad. */
 293                 printk(KERN_WARNING "Elsa: card not available!\n");
 294                 return IRQ_NONE;
 295         }
 296         spin_lock_irqsave(&cs->lock, flags);
 297 #if ARCOFI_USE
 298         if (cs->hw.elsa.MFlag) {
 299                 val = serial_inp(cs, UART_IIR);
 300                 if (!(val & UART_IIR_NO_INT)) {
 301                         debugl1(cs,"IIR %02x", val);
 302                         rs_interrupt_elsa(intno, cs);
 303                 }
 304         }
 305 #endif
 306         val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
 307       Start_HSCX:
 308         if (val) {
 309                 hscx_int_main(cs, val);
 310         }
 311         val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
 312       Start_ISAC:
 313         if (val) {
 314                 isac_interrupt(cs, val);
 315         }
 316         val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
 317         if (val && icnt) {
 318                 if (cs->debug & L1_DEB_HSCX)
 319                         debugl1(cs, "HSCX IntStat after IntRoutine");
 320                 icnt--;
 321                 goto Start_HSCX;
 322         }
 323         val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
 324         if (val && icnt) {
 325                 if (cs->debug & L1_DEB_ISAC)
 326                         debugl1(cs, "ISAC IntStat after IntRoutine");
 327                 icnt--;
 328                 goto Start_ISAC;
 329         }
 330         if (!icnt)
 331                 printk(KERN_WARNING"ELSA IRQ LOOP\n");
 332         writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0xFF);
 333         writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0xFF);
 334         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0xFF);
 335         if (cs->hw.elsa.status & ELIRQF_TIMER_AKTIV) {
 336                 if (!TimerRun(cs)) {
 337                         /* Timer Restart */
 338                         byteout(cs->hw.elsa.timer, 0);
 339                         cs->hw.elsa.counter++;
 340                 }
 341         }
 342 #if ARCOFI_USE
 343         if (cs->hw.elsa.MFlag) {
 344                 val = serial_inp(cs, UART_MCR);
 345                 val ^= 0x8;
 346                 serial_outp(cs, UART_MCR, val);
 347                 val = serial_inp(cs, UART_MCR);
 348                 val ^= 0x8;
 349                 serial_outp(cs, UART_MCR, val);
 350         }
 351 #endif
 352         if (cs->hw.elsa.trig)
 353                 byteout(cs->hw.elsa.trig, 0x00);
 354         writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0x0);
 355         writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0x0);
 356         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0x0);
 357         spin_unlock_irqrestore(&cs->lock, flags);
 358         return IRQ_HANDLED;
 359 }
 360
 361 static irqreturn_t
 362 elsa_interrupt_ipac(int intno, void *dev_id)
 363 {
 364         struct IsdnCardState *cs = dev_id;
 365         u_long flags;
 366         u_char ista,val;
 367         int icnt=5;
 368
 369         spin_lock_irqsave(&cs->lock, flags);
 370         if (cs->subtyp == ELSA_QS1000PCI || cs->subtyp == ELSA_QS3000PCI) {
 371                 val = bytein(cs->hw.elsa.cfg + 0x4c); /* PCI IRQ */
 372                 if (!(val & ELSA_PCI_IRQ_MASK)) {
 373                         spin_unlock_irqrestore(&cs->lock, flags);
 374                         return IRQ_NONE;
 375                 }
 376         }
 377 #if ARCOFI_USE
 378         if (cs->hw.elsa.MFlag) {
 379                 val = serial_inp(cs, UART_IIR);
 380                 if (!(val & UART_IIR_NO_INT)) {
 381                         debugl1(cs,"IIR %02x", val);
 382                         rs_interrupt_elsa(intno, cs);
 383                 }
 384         }
 385 #endif
 386         ista = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
 387 Start_IPAC:
 388         if (cs->debug & L1_DEB_IPAC)
 389                 debugl1(cs, "IPAC ISTA %02X", ista);
 390         if (ista & 0x0f) {
 391                 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
 392                 if (ista & 0x01)
 393                         val |= 0x01;
 394                 if (ista & 0x04)
 395                         val |= 0x02;
 396                 if (ista & 0x08)
 397                         val |= 0x04;
 398                 if (val)
 399                         hscx_int_main(cs, val);
 400         }
 401         if (ista & 0x20) {
 402                 val = 0xfe & readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA + 0x80);
 403                 if (val) {
 404                         isac_interrupt(cs, val);
 405                 }
 406         }
 407         if (ista & 0x10) {
 408                 val = 0x01;
 409                 isac_interrupt(cs, val);
 410         }
 411         ista  = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
 412         if ((ista & 0x3f) && icnt) {
 413                 icnt--;
 414                 goto Start_IPAC;
 415         }
 416         if (!icnt)
 417                 printk(KERN_WARNING "ELSA IRQ LOOP\n");
 418         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xFF);
 419         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xC0);
 420         spin_unlock_irqrestore(&cs->lock, flags);
 421         return IRQ_HANDLED;
 422 }
 423
 424 static void
 425 release_io_elsa(struct IsdnCardState *cs)
 426 {
 427         int bytecnt = 8;
 428
 429         del_timer(&cs->hw.elsa.tl);
 430 #if ARCOFI_USE
 431         clear_arcofi(cs);
 432 #endif
 433         if (cs->hw.elsa.ctrl)
 434                 byteout(cs->hw.elsa.ctrl, 0);   /* LEDs Out */
 435         if (cs->subtyp == ELSA_QS1000PCI) {
 436                 byteout(cs->hw.elsa.cfg + 0x4c, 0x01);  /* disable IRQ */
 437                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
 438                 bytecnt = 2;
 439                 release_region(cs->hw.elsa.cfg, 0x80);
 440         }
 441         if (cs->subtyp == ELSA_QS3000PCI) {
 442                 byteout(cs->hw.elsa.cfg + 0x4c, 0x03); /* disable ELSA PCI IRQ */
 443                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
 444                 release_region(cs->hw.elsa.cfg, 0x80);
 445         }
 446         if (cs->subtyp == ELSA_PCMCIA_IPAC) {
 447                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
 448         }
 449         if ((cs->subtyp == ELSA_PCFPRO) ||
 450                 (cs->subtyp == ELSA_QS3000) ||
 451                 (cs->subtyp == ELSA_PCF) ||
 452                 (cs->subtyp == ELSA_QS3000PCI)) {
 453                 bytecnt = 16;
 454 #if ARCOFI_USE
 455                 release_modem(cs);
 456 #endif
 457         }
 458         if (cs->hw.elsa.base)
 459                 release_region(cs->hw.elsa.base, bytecnt);
 460 }
 461
 462 static void
 463 reset_elsa(struct IsdnCardState *cs)
 464 {
 465         if (cs->hw.elsa.timer) {
 466                 /* Wait 1 Timer */
 467                 byteout(cs->hw.elsa.timer, 0);
 468                 while (TimerRun(cs));
 469                 cs->hw.elsa.ctrl_reg |= 0x50;
 470                 cs->hw.elsa.ctrl_reg &= ~ELSA_ISDN_RESET;       /* Reset On */
 471                 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 472                 /* Wait 1 Timer */
 473                 byteout(cs->hw.elsa.timer, 0);
 474                 while (TimerRun(cs));
 475                 cs->hw.elsa.ctrl_reg |= ELSA_ISDN_RESET;        /* Reset Off */
 476                 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 477                 /* Wait 1 Timer */
 478                 byteout(cs->hw.elsa.timer, 0);
 479                 while (TimerRun(cs));
 480                 if (cs->hw.elsa.trig)
 481                         byteout(cs->hw.elsa.trig, 0xff);
 482         }
 483         if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
 484                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x20);
 485                 mdelay(10);
 486                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x00);
 487                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xc0);
 488                 mdelay(10);
 489                 if (cs->subtyp != ELSA_PCMCIA_IPAC) {
 490                         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x0);
 491                         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0x3c);
 492                 } else {
 493                         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_PCFG, 0x10);
 494                         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x4);
 495                         writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0xf8);
 496                 }
 497                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
 498                 if (cs->subtyp == ELSA_QS1000PCI)
 499                         byteout(cs->hw.elsa.cfg + 0x4c, 0x41); /* enable ELSA PCI IRQ */
 500                 else if (cs->subtyp == ELSA_QS3000PCI)
 501                         byteout(cs->hw.elsa.cfg + 0x4c, 0x43); /* enable ELSA PCI IRQ */
 502         }
 503 }
 504
 505 #if ARCOFI_USE
 506
 507 static void
 508 set_arcofi(struct IsdnCardState *cs, int bc) {
 509         cs->dc.isac.arcofi_bc = bc;
 510         arcofi_fsm(cs, ARCOFI_START, &ARCOFI_COP_5);
 511         interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
 512 }
 513
 514 static int
 515 check_arcofi(struct IsdnCardState *cs)
 516 {
 517         int arcofi_present = 0;
 518         char tmp[40];
 519         char *t;
 520         u_char *p;
 521
 522         if (!cs->dc.isac.mon_tx)
 523                 if (!(cs->dc.isac.mon_tx=kmalloc(MAX_MON_FRAME, GFP_ATOMIC))) {
 524                         if (cs->debug & L1_DEB_WARN)
 525                                 debugl1(cs, "ISAC MON TX out of buffers!");
 526                         return(0);
 527                 }
 528         cs->dc.isac.arcofi_bc = 0;
 529         arcofi_fsm(cs, ARCOFI_START, &ARCOFI_VERSION);
 530         interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
 531         if (!test_and_clear_bit(FLG_ARCOFI_ERROR, &cs->HW_Flags)) {
 532                         debugl1(cs, "Arcofi response received %d bytes", cs->dc.isac.mon_rxp);
 533                         p = cs->dc.isac.mon_rx;
 534                         t = tmp;
 535                         t += sprintf(tmp, "Arcofi data");
 536                         QuickHex(t, p, cs->dc.isac.mon_rxp);
 537                         debugl1(cs, tmp);
 538                         if ((cs->dc.isac.mon_rxp == 2) && (cs->dc.isac.mon_rx[0] == 0xa0)) {
 539                                 switch(cs->dc.isac.mon_rx[1]) {
 540                                         case 0x80:
 541                                                 debugl1(cs, "Arcofi 2160 detected");
 542                                                 arcofi_present = 1;
 543                                                 break;
 544                                         case 0x82:
 545                                                 debugl1(cs, "Arcofi 2165 detected");
 546                                                 arcofi_present = 2;
 547                                                 break;
 548                                         case 0x84:
 549                                                 debugl1(cs, "Arcofi 2163 detected");
 550                                                 arcofi_present = 3;
 551                                                 break;
 552                                         default:
 553                                                 debugl1(cs, "unknown Arcofi response");
 554                                                 break;
 555                                 }
 556                         } else
 557                                 debugl1(cs, "undefined Monitor response");
 558                         cs->dc.isac.mon_rxp = 0;
 559         } else if (cs->dc.isac.mon_tx) {
 560                 debugl1(cs, "Arcofi not detected");
 561         }
 562         if (arcofi_present) {
 563                 if (cs->subtyp==ELSA_QS1000) {
 564                         cs->subtyp = ELSA_QS3000;
 565                         printk(KERN_INFO
 566                                 "Elsa: %s detected modem at 0x%lx\n",
 567                                 Elsa_Types[cs->subtyp],
 568                                 cs->hw.elsa.base+8);
 569                         release_region(cs->hw.elsa.base, 8);
 570                         if (!request_region(cs->hw.elsa.base, 16, "elsa isdn modem")) {
 571                                 printk(KERN_WARNING
 572                                         "HiSax: %s config port %lx-%lx already in use\n",
 573                                         Elsa_Types[cs->subtyp],
 574                                         cs->hw.elsa.base + 8,
 575                                         cs->hw.elsa.base + 16);
 576                         }
 577                 } else if (cs->subtyp==ELSA_PCC16) {
 578                         cs->subtyp = ELSA_PCF;
 579                         printk(KERN_INFO
 580                                 "Elsa: %s detected modem at 0x%lx\n",
 581                                 Elsa_Types[cs->subtyp],
 582                                 cs->hw.elsa.base+8);
 583                         release_region(cs->hw.elsa.base, 8);
 584                         if (!request_region(cs->hw.elsa.base, 16, "elsa isdn modem")) {
 585                                 printk(KERN_WARNING
 586                                         "HiSax: %s config port %lx-%lx already in use\n",
 587                                         Elsa_Types[cs->subtyp],
 588                                         cs->hw.elsa.base + 8,
 589                                         cs->hw.elsa.base + 16);
 590                         }
 591                 } else
 592                         printk(KERN_INFO
 593                                 "Elsa: %s detected modem at 0x%lx\n",
 594                                 Elsa_Types[cs->subtyp],
 595                                 cs->hw.elsa.base+8);
 596                 arcofi_fsm(cs, ARCOFI_START, &ARCOFI_XOP_0);
 597                 interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
 598                 return(1);
 599         }
 600         return(0);
 601 }
 602 #endif /* ARCOFI_USE */
 603
 604 static void
 605 elsa_led_handler(struct IsdnCardState *cs)
 606 {
 607         int blink = 0;
 608
 609         if (cs->subtyp == ELSA_PCMCIA || cs->subtyp == ELSA_PCMCIA_IPAC)
 610                 return;
 611         del_timer(&cs->hw.elsa.tl);
 612         if (cs->hw.elsa.status & ELSA_ASSIGN)
 613                 cs->hw.elsa.ctrl_reg |= ELSA_STAT_LED;
 614         else if (cs->hw.elsa.status & ELSA_BAD_PWR)
 615                 cs->hw.elsa.ctrl_reg &= ~ELSA_STAT_LED;
 616         else {
 617                 cs->hw.elsa.ctrl_reg ^= ELSA_STAT_LED;
 618                 blink = 250;
 619         }
 620         if (cs->hw.elsa.status & 0xf000)
 621                 cs->hw.elsa.ctrl_reg |= ELSA_LINE_LED;
 622         else if (cs->hw.elsa.status & 0x0f00) {
 623                 cs->hw.elsa.ctrl_reg ^= ELSA_LINE_LED;
 624                 blink = 500;
 625         } else
 626                 cs->hw.elsa.ctrl_reg &= ~ELSA_LINE_LED;
 627
 628         if ((cs->subtyp == ELSA_QS1000PCI) ||
 629                 (cs->subtyp == ELSA_QS3000PCI)) {
 630                 u_char led = 0xff;
 631                 if (cs->hw.elsa.ctrl_reg & ELSA_LINE_LED)
 632                         led ^= ELSA_IPAC_LINE_LED;
 633                 if (cs->hw.elsa.ctrl_reg & ELSA_STAT_LED)
 634                         led ^= ELSA_IPAC_STAT_LED;
 635                 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, led);
 636         } else
 637                 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 638         if (blink) {
 639                 init_timer(&cs->hw.elsa.tl);
 640                 cs->hw.elsa.tl.expires = jiffies + ((blink * HZ) / 1000);
 641                 add_timer(&cs->hw.elsa.tl);
 642         }
 643 }
 644
 645 static int
 646 Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 647 {
 648         int ret = 0;
 649         u_long flags;
 650
 651         switch (mt) {
 652                 case CARD_RESET:
 653                         spin_lock_irqsave(&cs->lock, flags);
 654                         reset_elsa(cs);
 655                         spin_unlock_irqrestore(&cs->lock, flags);
 656                         return(0);
 657                 case CARD_RELEASE:
 658                         release_io_elsa(cs);
 659                         return(0);
 660                 case CARD_INIT:
 661                         spin_lock_irqsave(&cs->lock, flags);
 662                         cs->debug |= L1_DEB_IPAC;
 663                         reset_elsa(cs);
 664                         inithscxisac(cs, 1);
 665                         if ((cs->subtyp == ELSA_QS1000) ||
 666                             (cs->subtyp == ELSA_QS3000))
 667                         {
 668                                 byteout(cs->hw.elsa.timer, 0);
 669                         }
 670                         if (cs->hw.elsa.trig)
 671                                 byteout(cs->hw.elsa.trig, 0xff);
 672                         inithscxisac(cs, 2);
 673                         spin_unlock_irqrestore(&cs->lock, flags);
 674                         return(0);
 675                 case CARD_TEST:
 676                         if ((cs->subtyp == ELSA_PCMCIA) ||
 677                                 (cs->subtyp == ELSA_PCMCIA_IPAC) ||
 678                                 (cs->subtyp == ELSA_QS1000PCI)) {
 679                                 return(0);
 680                         } else if (cs->subtyp == ELSA_QS3000PCI) {
 681                                 ret = 0;
 682                         } else {
 683                                 spin_lock_irqsave(&cs->lock, flags);
 684                                 cs->hw.elsa.counter = 0;
 685                                 cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
 686                                 cs->hw.elsa.status |= ELIRQF_TIMER_AKTIV;
 687                                 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 688                                 byteout(cs->hw.elsa.timer, 0);
 689                                 spin_unlock_irqrestore(&cs->lock, flags);
 690                                 msleep(110);
 691                                 spin_lock_irqsave(&cs->lock, flags);
 692                                 cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
 693                                 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 694                                 cs->hw.elsa.status &= ~ELIRQF_TIMER_AKTIV;
 695                                 spin_unlock_irqrestore(&cs->lock, flags);
 696                                 printk(KERN_INFO "Elsa: %d timer tics in 110 msek\n",
 697                                        cs->hw.elsa.counter);
 698                                 if ((cs->hw.elsa.counter > 10) &&
 699                                         (cs->hw.elsa.counter < 16)) {
 700                                         printk(KERN_INFO "Elsa: timer and irq OK\n");
 701                                         ret = 0;
 702                                 } else {
 703                                         printk(KERN_WARNING
 704                                                "Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n",
 705                                                cs->hw.elsa.counter, cs->irq);
 706                                         ret = 1;
 707                                 }
 708                         }
 709 #if ARCOFI_USE
 710                         if (check_arcofi(cs)) {
 711                                 init_modem(cs);
 712                         }
 713 #endif
 714                         elsa_led_handler(cs);
 715                         return(ret);
 716                 case (MDL_REMOVE | REQUEST):
 717                         cs->hw.elsa.status &= 0;
 718                         break;
 719                 case (MDL_ASSIGN | REQUEST):
 720                         cs->hw.elsa.status |= ELSA_ASSIGN;
 721                         break;
 722                 case MDL_INFO_SETUP:
 723                         if ((long) arg)
 724                                 cs->hw.elsa.status |= 0x0200;
 725                         else
 726                                 cs->hw.elsa.status |= 0x0100;
 727                         break;
 728                 case MDL_INFO_CONN:
 729                         if ((long) arg)
 730                                 cs->hw.elsa.status |= 0x2000;
 731                         else
 732                                 cs->hw.elsa.status |= 0x1000;
 733                         break;
 734                 case MDL_INFO_REL:
 735                         if ((long) arg) {
 736                                 cs->hw.elsa.status &= ~0x2000;
 737                                 cs->hw.elsa.status &= ~0x0200;
 738                         } else {
 739                                 cs->hw.elsa.status &= ~0x1000;
 740                                 cs->hw.elsa.status &= ~0x0100;
 741                         }
 742                         break;
 743 #if ARCOFI_USE
 744                 case CARD_AUX_IND:
 745                         if (cs->hw.elsa.MFlag) {
 746                                 int len;
 747                                 u_char *msg;
 748
 749                                 if (!arg)
 750                                         return(0);
 751                                 msg = arg;
 752                                 len = *msg;
 753                                 msg++;
 754                                 modem_write_cmd(cs, msg, len);
 755                         }
 756                         break;
 757 #endif
 758         }
 759         if (cs->typ == ISDN_CTYPE_ELSA) {
 760                 int pwr = bytein(cs->hw.elsa.ale);
 761                 if (pwr & 0x08)
 762                         cs->hw.elsa.status |= ELSA_BAD_PWR;
 763                 else
 764                         cs->hw.elsa.status &= ~ELSA_BAD_PWR;
 765         }
 766         elsa_led_handler(cs);
 767         return(ret);
 768 }
 769
 770 static unsigned char
 771 probe_elsa_adr(unsigned int adr, int typ)
 772 {
 773         int i, in1, in2, p16_1 = 0, p16_2 = 0, p8_1 = 0, p8_2 = 0, pc_1 = 0,
 774          pc_2 = 0, pfp_1 = 0, pfp_2 = 0;
 775
 776         /* In case of the elsa pcmcia card, this region is in use,
 777            reserved for us by the card manager. So we do not check it
 778            here, it would fail. */
 779         if (typ != ISDN_CTYPE_ELSA_PCMCIA) {
 780                 if (request_region(adr, 8, "elsa card")) {
 781                         release_region(adr, 8);
 782                 } else {
 783                         printk(KERN_WARNING
 784                                "Elsa: Probing Port 0x%x: already in use\n", adr);
 785                         return (0);
 786                 }
 787         }
 788         for (i = 0; i < 16; i++) {
 789                 in1 = inb(adr + ELSA_CONFIG);   /* 'toggelt' bei */
 790                 in2 = inb(adr + ELSA_CONFIG);   /* jedem Zugriff */
 791                 p16_1 += 0x04 & in1;
 792                 p16_2 += 0x04 & in2;
 793                 p8_1 += 0x02 & in1;
 794                 p8_2 += 0x02 & in2;
 795                 pc_1 += 0x01 & in1;
 796                 pc_2 += 0x01 & in2;
 797                 pfp_1 += 0x40 & in1;
 798                 pfp_2 += 0x40 & in2;
 799         }
 800         printk(KERN_INFO "Elsa: Probing IO 0x%x", adr);
 801         if (65 == ++p16_1 * ++p16_2) {
 802                 printk(" PCC-16/PCF found\n");
 803                 return (ELSA_PCC16);
 804         } else if (1025 == ++pfp_1 * ++pfp_2) {
 805                 printk(" PCF-Pro found\n");
 806                 return (ELSA_PCFPRO);
 807         } else if (33 == ++p8_1 * ++p8_2) {
 808                 printk(" PCC8 found\n");
 809                 return (ELSA_PCC8);
 810         } else if (17 == ++pc_1 * ++pc_2) {
 811                 printk(" PC found\n");
 812                 return (ELSA_PC);
 813         } else {
 814                 printk(" failed\n");
 815                 return (0);
 816         }
 817 }
 818
 819 static unsigned int
 820 probe_elsa(struct IsdnCardState *cs)
 821 {
 822         int i;
 823         unsigned int CARD_portlist[] =
 824         {0x160, 0x170, 0x260, 0x360, 0};
 825
 826         for (i = 0; CARD_portlist[i]; i++) {
 827                 if ((cs->subtyp = probe_elsa_adr(CARD_portlist[i], cs->typ)))
 828                         break;
 829         }
 830         return (CARD_portlist[i]);
 831 }
 832
 833 static int __devinit
 834 setup_elsa_isa(struct IsdnCard *card)
 835 {
 836         struct IsdnCardState *cs = card->cs;
 837         u_char val;
 838
 839         cs->hw.elsa.base = card->para[0];
 840         printk(KERN_INFO "Elsa: Microlink IO probing\n");
 841         if (cs->hw.elsa.base) {
 842                 if (!(cs->subtyp = probe_elsa_adr(cs->hw.elsa.base,
 843                                                   cs->typ))) {
 844                         printk(KERN_WARNING
 845                                "Elsa: no Elsa Microlink at %#lx\n",
 846                                cs->hw.elsa.base);
 847                         return (0);
 848                 }
 849         } else
 850                 cs->hw.elsa.base = probe_elsa(cs);
 851
 852         if (!cs->hw.elsa.base) {
 853                 printk(KERN_WARNING
 854                        "No Elsa Microlink found\n");
 855                 return (0);
 856         }
 857
 858         cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
 859         cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
 860         cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
 861         cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
 862         cs->hw.elsa.itac = cs->hw.elsa.base + ELSA_ITAC;
 863         cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
 864         cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
 865         cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
 866         val = bytein(cs->hw.elsa.cfg);
 867         if (cs->subtyp == ELSA_PC) {
 868                 const u_char CARD_IrqTab[8] =
 869                 {7, 3, 5, 9, 0, 0, 0, 0};
 870                 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PC) >> 2];
 871         } else if (cs->subtyp == ELSA_PCC8) {
 872                 const u_char CARD_IrqTab[8] =
 873                 {7, 3, 5, 9, 0, 0, 0, 0};
 874                 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PCC8) >> 4];
 875         } else {
 876                 const u_char CARD_IrqTab[8] =
 877                 {15, 10, 15, 3, 11, 5, 11, 9};
 878                 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX) >> 3];
 879         }
 880         val = bytein(cs->hw.elsa.ale) & ELSA_HW_RELEASE;
 881         if (val < 3)
 882                 val |= 8;
 883         val += 'A' - 3;
 884         if (val == 'B' || val == 'C')
 885                 val ^= 1;
 886         if ((cs->subtyp == ELSA_PCFPRO) && (val = 'G'))
 887                 val = 'C';
 888         printk(KERN_INFO
 889                "Elsa: %s found at %#lx Rev.:%c IRQ %d\n",
 890                Elsa_Types[cs->subtyp],
 891                cs->hw.elsa.base,
 892                val, cs->irq);
 893         val = bytein(cs->hw.elsa.ale) & ELSA_S0_POWER_BAD;
 894         if (val) {
 895                 printk(KERN_WARNING
 896                    "Elsa: Microlink S0 bus power bad\n");
 897                 cs->hw.elsa.status |= ELSA_BAD_PWR;
 898         }
 899
 900         return (1);
 901 }
 902
 903 #ifdef __ISAPNP__
 904 static struct isapnp_device_id elsa_ids[] __devinitdata = {
 905         { ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0133),
 906           ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0133),
 907           (unsigned long) "Elsa QS1000" },
 908         { ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0134),
 909           ISAPNP_VENDOR('E', 'L', 'S'), ISAPNP_FUNCTION(0x0134),
 910           (unsigned long) "Elsa QS3000" },
 911         { 0, }
 912 };
 913
 914 static struct isapnp_device_id *ipid __devinitdata = &elsa_ids[0];
 915 static struct pnp_card *pnp_c __devinitdata = NULL;
 916 #endif  /* __ISAPNP__ */
 917
 918 static int __devinit
 919 setup_elsa_isapnp(struct IsdnCard *card)
 920 {
 921         struct IsdnCardState *cs = card->cs;
 922
 923 #ifdef __ISAPNP__
 924         if (!card->para[1] && isapnp_present()) {
 925                 struct pnp_dev *pnp_d;
 926                 while(ipid->card_vendor) {
 927                         if ((pnp_c = pnp_find_card(ipid->card_vendor,
 928                                 ipid->card_device, pnp_c))) {
 929                                 pnp_d = NULL;
 930                                 if ((pnp_d = pnp_find_dev(pnp_c,
 931                                         ipid->vendor, ipid->function, pnp_d))) {
 932                                         int err;
 933
 934                                         printk(KERN_INFO "HiSax: %s detected\n",
 935                                                 (char *)ipid->driver_data);
 936                                         pnp_disable_dev(pnp_d);
 937                                         err = pnp_activate_dev(pnp_d);
 938                                         if (err<0) {
 939                                                 printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
 940                                                         __FUNCTION__, err);
 941                                                 return(0);
 942                                         }
 943                                         card->para[1] = pnp_port_start(pnp_d, 0);
 944                                         card->para[0] = pnp_irq(pnp_d, 0);
 945
 946                                         if (!card->para[0] || !card->para[1]) {
 947                                                 printk(KERN_ERR "Elsa PnP:some resources are missing %ld/%lx\n",
 948                                                         card->para[0], card->para[1]);
 949                                                 pnp_disable_dev(pnp_d);
 950                                                 return(0);
 951                                         }
 952                                         if (ipid->function == ISAPNP_FUNCTION(0x133))
 953                                                 cs->subtyp = ELSA_QS1000;
 954                                         else
 955                                                 cs->subtyp = ELSA_QS3000;
 956                                         break;
 957                                 } else {
 958                                         printk(KERN_ERR "Elsa PnP: PnP error card found, no device\n");
 959                                         return(0);
 960                                 }
 961                         }
 962                         ipid++;
 963                         pnp_c=NULL;
 964                 }
 965                 if (!ipid->card_vendor) {
 966                         printk(KERN_INFO "Elsa PnP: no ISAPnP card found\n");
 967                         return(0);
 968                 }
 969         }
 970 #endif  /* __ISAPNP__ */
 971
 972         if (card->para[1] && card->para[0]) {
 973                 cs->hw.elsa.base = card->para[1];
 974                 cs->irq = card->para[0];
 975                 if (!cs->subtyp)
 976                         cs->subtyp = ELSA_QS1000;
 977         } else {
 978                 printk(KERN_ERR "Elsa PnP: no parameter\n");
 979         }
 980         cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
 981         cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
 982         cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
 983         cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
 984         cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
 985         cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
 986         cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
 987         printk(KERN_INFO
 988                "Elsa: %s defined at %#lx IRQ %d\n",
 989                Elsa_Types[cs->subtyp],
 990                cs->hw.elsa.base,
 991                cs->irq);
 992
 993         return (1);
 994 }
 995
 996 static void __devinit
 997 setup_elsa_pcmcia(struct IsdnCard *card)
 998 {
 999         struct IsdnCardState *cs = card->cs;
1000         u_char val;
1001
1002         cs->hw.elsa.base = card->para[1];
1003         cs->irq = card->para[0];
1004         val = readreg(cs->hw.elsa.base + 0, cs->hw.elsa.base + 2, IPAC_ID);
1005         if ((val == 1) || (val == 2)) { /* IPAC version 1.1/1.2 */
1006                 cs->subtyp = ELSA_PCMCIA_IPAC;
1007                 cs->hw.elsa.ale = cs->hw.elsa.base + 0;
1008                 cs->hw.elsa.isac = cs->hw.elsa.base + 2;
1009                 cs->hw.elsa.hscx = cs->hw.elsa.base + 2;
1010                 test_and_set_bit(HW_IPAC, &cs->HW_Flags);
1011         } else {
1012                 cs->subtyp = ELSA_PCMCIA;
1013                 cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE_PCM;
1014                 cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC_PCM;
1015                 cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
1016         }
1017         cs->hw.elsa.timer = 0;
1018         cs->hw.elsa.trig = 0;
1019         cs->hw.elsa.ctrl = 0;
1020         cs->irq_flags |= IRQF_SHARED;
1021         printk(KERN_INFO
1022                "Elsa: %s defined at %#lx IRQ %d\n",
1023                Elsa_Types[cs->subtyp],
1024                cs->hw.elsa.base,
1025                cs->irq);
1026 }
1027
1028 #ifdef CONFIG_PCI
1029 static  struct pci_dev *dev_qs1000 __devinitdata = NULL;
1030 static  struct pci_dev *dev_qs3000 __devinitdata = NULL;
1031
1032 static int __devinit
1033 setup_elsa_pci(struct IsdnCard *card)
1034 {
1035         struct IsdnCardState *cs = card->cs;
1036
1037         cs->subtyp = 0;
1038         if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
1039                 PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
1040                 if (pci_enable_device(dev_qs1000))
1041                         return(0);
1042                 cs->subtyp = ELSA_QS1000PCI;
1043                 cs->irq = dev_qs1000->irq;
1044                 cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
1045                 cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
1046         } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
1047                 PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
1048                 if (pci_enable_device(dev_qs3000))
1049                         return(0);
1050                 cs->subtyp = ELSA_QS3000PCI;
1051                 cs->irq = dev_qs3000->irq;
1052                 cs->hw.elsa.cfg = pci_resource_start(dev_qs3000, 1);
1053                 cs->hw.elsa.base = pci_resource_start(dev_qs3000, 3);
1054         } else {
1055                 printk(KERN_WARNING "Elsa: No PCI card found\n");
1056                 return(0);
1057         }
1058         if (!cs->irq) {
1059                 printk(KERN_WARNING "Elsa: No IRQ for PCI card found\n");
1060                 return(0);
1061         }
1062
1063         if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
1064                 printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found\n");
1065                 return(0);
1066         }
1067         if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
1068                 printk(KERN_WARNING "Elsa: You may have a wrong PCI bios\n");
1069                 printk(KERN_WARNING "Elsa: If your system hangs now, read\n");
1070                 printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax\n");
1071         }
1072         cs->hw.elsa.ale  = cs->hw.elsa.base;
1073         cs->hw.elsa.isac = cs->hw.elsa.base +1;
1074         cs->hw.elsa.hscx = cs->hw.elsa.base +1;
1075         test_and_set_bit(HW_IPAC, &cs->HW_Flags);
1076         cs->hw.elsa.timer = 0;
1077         cs->hw.elsa.trig  = 0;
1078         cs->irq_flags |= IRQF_SHARED;
1079         printk(KERN_INFO
1080                "Elsa: %s defined at %#lx/0x%x IRQ %d\n",
1081                Elsa_Types[cs->subtyp],
1082                cs->hw.elsa.base,
1083                cs->hw.elsa.cfg,
1084                cs->irq);
1085
1086         return (1);
1087 }
1088
1089 #else
1090
1091 static void __devinit
1092 setup_elsa_pci(struct IsdnCard *card)
1093 {
1094         return (1);
1095 }
1096 #endif /* CONFIG_PCI */
1097
1098 static int __devinit
1099 setup_elsa_common(struct IsdnCard *card)
1100 {
1101         struct IsdnCardState *cs = card->cs;
1102         u_char val;
1103         int bytecnt;
1104
1105         switch (cs->subtyp) {
1106                 case ELSA_PC:
1107                 case ELSA_PCC8:
1108                 case ELSA_PCC16:
1109                 case ELSA_QS1000:
1110                 case ELSA_PCMCIA:
1111                 case ELSA_PCMCIA_IPAC:
1112                         bytecnt = 8;
1113                         break;
1114                 case ELSA_PCFPRO:
1115                 case ELSA_PCF:
1116                 case ELSA_QS3000:
1117                 case ELSA_QS3000PCI:
1118                         bytecnt = 16;
1119                         break;
1120                 case ELSA_QS1000PCI:
1121                         bytecnt = 2;
1122                         break;
1123                 default:
1124                         printk(KERN_WARNING
1125                                "Unknown ELSA subtype %d\n", cs->subtyp);
1126                         return (0);
1127         }
1128         /* In case of the elsa pcmcia card, this region is in use,
1129            reserved for us by the card manager. So we do not check it
1130            here, it would fail. */
1131         if (cs->typ != ISDN_CTYPE_ELSA_PCMCIA && !request_region(cs->hw.elsa.base, bytecnt, "elsa isdn")) {
1132                 printk(KERN_WARNING
1133                        "HiSax: ELSA config port %#lx-%#lx already in use\n",
1134                        cs->hw.elsa.base,
1135                        cs->hw.elsa.base + bytecnt);
1136                 return (0);
1137         }
1138         if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI)) {
1139                 if (!request_region(cs->hw.elsa.cfg, 0x80, "elsa isdn pci")) {
1140                         printk(KERN_WARNING
1141                                "HiSax: ELSA pci port %x-%x already in use\n",
1142                                 cs->hw.elsa.cfg,
1143                                 cs->hw.elsa.cfg + 0x80);
1144                         release_region(cs->hw.elsa.base, bytecnt);
1145                         return (0);
1146                 }
1147         }
1148 #if ARCOFI_USE
1149         init_arcofi(cs);
1150 #endif
1151         setup_isac(cs);
1152         cs->hw.elsa.tl.function = (void *) elsa_led_handler;
1153         cs->hw.elsa.tl.data = (long) cs;
1154         init_timer(&cs->hw.elsa.tl);
1155         /* Teste Timer */
1156         if (cs->hw.elsa.timer) {
1157                 byteout(cs->hw.elsa.trig, 0xff);
1158                 byteout(cs->hw.elsa.timer, 0);
1159                 if (!TimerRun(cs)) {
1160                         byteout(cs->hw.elsa.timer, 0);  /* 2. Versuch */
1161                         if (!TimerRun(cs)) {
1162                                 printk(KERN_WARNING
1163                                        "Elsa: timer do not start\n");
1164                                 release_io_elsa(cs);
1165                                 return (0);
1166                         }
1167                 }
1168                 HZDELAY((HZ/100) + 1);  /* wait >=10 ms */
1169                 if (TimerRun(cs)) {
1170                         printk(KERN_WARNING "Elsa: timer do not run down\n");
1171                         release_io_elsa(cs);
1172                         return (0);
1173                 }
1174                 printk(KERN_INFO "Elsa: timer OK; resetting card\n");
1175         }
1176         cs->BC_Read_Reg = &ReadHSCX;
1177         cs->BC_Write_Reg = &WriteHSCX;
1178         cs->BC_Send_Data = &hscx_fill_fifo;
1179         cs->cardmsg = &Elsa_card_msg;
1180         if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
1181                 cs->readisac = &ReadISAC_IPAC;
1182                 cs->writeisac = &WriteISAC_IPAC;
1183                 cs->readisacfifo = &ReadISACfifo_IPAC;
1184                 cs->writeisacfifo = &WriteISACfifo_IPAC;
1185                 cs->irq_func = &elsa_interrupt_ipac;
1186                 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ID);
1187                 printk(KERN_INFO "Elsa: IPAC version %x\n", val);
1188         } else {
1189                 cs->readisac = &ReadISAC;
1190                 cs->writeisac = &WriteISAC;
1191                 cs->readisacfifo = &ReadISACfifo;
1192                 cs->writeisacfifo = &WriteISACfifo;
1193                 cs->irq_func = &elsa_interrupt;
1194                 ISACVersion(cs, "Elsa:");
1195                 if (HscxVersion(cs, "Elsa:")) {
1196                         printk(KERN_WARNING
1197                                 "Elsa: wrong HSCX versions check IO address\n");
1198                         release_io_elsa(cs);
1199                         return (0);
1200                 }
1201         }
1202         if (cs->subtyp == ELSA_PC) {
1203                 val = readitac(cs, ITAC_SYS);
1204                 printk(KERN_INFO "Elsa: ITAC version %s\n", ITACVer[val & 7]);
1205                 writeitac(cs, ITAC_ISEN, 0);
1206                 writeitac(cs, ITAC_RFIE, 0);
1207                 writeitac(cs, ITAC_XFIE, 0);
1208                 writeitac(cs, ITAC_SCIE, 0);
1209                 writeitac(cs, ITAC_STIE, 0);
1210         }
1211         return (1);
1212 }
1213
1214 int __devinit
1215 setup_elsa(struct IsdnCard *card)
1216 {
1217         int rc;
1218         struct IsdnCardState *cs = card->cs;
1219         char tmp[64];
1220
1221         strcpy(tmp, Elsa_revision);
1222         printk(KERN_INFO "HiSax: Elsa driver Rev. %s\n", HiSax_getrev(tmp));
1223         cs->hw.elsa.ctrl_reg = 0;
1224         cs->hw.elsa.status = 0;
1225         cs->hw.elsa.MFlag = 0;
1226         cs->subtyp = 0;
1227
1228         if (cs->typ == ISDN_CTYPE_ELSA) {
1229                 rc = setup_elsa_isa(card);
1230                 if (!rc)
1231                         return (0);
1232
1233         } else if (cs->typ == ISDN_CTYPE_ELSA_PNP) {
1234                 rc = setup_elsa_isapnp(card);
1235                 if (!rc)
1236                         return (0);
1237
1238         } else if (cs->typ == ISDN_CTYPE_ELSA_PCMCIA)
1239                 setup_elsa_pcmcia(card);
1240
1241         else if (cs->typ == ISDN_CTYPE_ELSA_PCI) {
1242                 rc = setup_elsa_pci(card);
1243                 if (!rc)
1244                         return (0);
1245
1246         } else
1247                 return (0);
1248
1249         return setup_elsa_common(card);
1250 }