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