File: /usr/src/linux/drivers/isdn/hisax/elsa.c
1 /* $Id: elsa.c,v 2.26.6.5 2001/07/18 16:25:12 kai Exp $
2 *
3 * elsa.c low level stuff for Elsa isdn cards
4 *
5 * Author Karsten Keil (keil@isdn4linux.de)
6 *
7 * This file is (c) under GNU General Public License
8 * For changes and modifications please read
9 * ../../../Documentation/isdn/HiSax.cert
10 *
11 * Thanks to Elsa GmbH for documents and informations
12 *
13 * Klaus Lichtenwalder (Klaus.Lichtenwalder@WebForum.DE)
14 * for ELSA PCMCIA support
15 *
16 */
17
18 #define __NO_VERSION__
19 #include <linux/init.h>
20 #include <linux/config.h>
21 #include "hisax.h"
22 #include "arcofi.h"
23 #include "isac.h"
24 #include "ipac.h"
25 #include "hscx.h"
26 #include "isdnl1.h"
27 #include <linux/pci.h>
28 #include <linux/serial.h>
29 #include <linux/serial_reg.h>
30
31 extern const char *CardType[];
32
33 const char *Elsa_revision = "$Revision: 2.26.6.5 $";
34 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 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 ELSA_TIMER_RUN 0x02 /* Bit 1 des Config-Reg */
87 #define ELSA_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 ELSA_TIMER_AKTIV 1
104 #define ELSA_BAD_PWR 2
105 #define ELSA_ASSIGN 4
106
107 #define RS_ISR_PASS_LIMIT 256
108 #define _INLINE_ inline
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 long flags;
146
147 save_flags(flags);
148 cli();
149 byteout(ale, off);
150 ret = bytein(adr);
151 restore_flags(flags);
152 return (ret);
153 }
154
155 static inline void
156 readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
157 {
158 /* fifo read without cli because it's allready done */
159
160 byteout(ale, off);
161 insb(adr, data, size);
162 }
163
164
165 static inline void
166 writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
167 {
168 long flags;
169
170 save_flags(flags);
171 cli();
172 byteout(ale, off);
173 byteout(adr, data);
174 restore_flags(flags);
175 }
176
177 static inline void
178 writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
179 {
180 /* fifo write without cli because it's allready done */
181 byteout(ale, off);
182 outsb(adr, data, size);
183 }
184
185 /* Interface functions */
186
187 static u_char
188 ReadISAC(struct IsdnCardState *cs, u_char offset)
189 {
190 return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset));
191 }
192
193 static void
194 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
195 {
196 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset, value);
197 }
198
199 static void
200 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
201 {
202 readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
203 }
204
205 static void
206 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
207 {
208 writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
209 }
210
211 static u_char
212 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
213 {
214 return (readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset+0x80));
215 }
216
217 static void
218 WriteISAC_IPAC(struct IsdnCardState *cs, u_char offset, u_char value)
219 {
220 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, offset|0x80, value);
221 }
222
223 static void
224 ReadISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
225 {
226 readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
227 }
228
229 static void
230 WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
231 {
232 writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
233 }
234
235 static u_char
236 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
237 {
238 return (readreg(cs->hw.elsa.ale,
239 cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0)));
240 }
241
242 static void
243 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
244 {
245 writereg(cs->hw.elsa.ale,
246 cs->hw.elsa.hscx, offset + (hscx ? 0x40 : 0), value);
247 }
248
249 static inline u_char
250 readitac(struct IsdnCardState *cs, u_char off)
251 {
252 register u_char ret;
253 long flags;
254
255 save_flags(flags);
256 cli();
257 byteout(cs->hw.elsa.ale, off);
258 ret = bytein(cs->hw.elsa.itac);
259 restore_flags(flags);
260 return (ret);
261 }
262
263 static inline void
264 writeitac(struct IsdnCardState *cs, u_char off, u_char data)
265 {
266 long flags;
267
268 save_flags(flags);
269 cli();
270 byteout(cs->hw.elsa.ale, off);
271 byteout(cs->hw.elsa.itac, data);
272 restore_flags(flags);
273 }
274
275 static inline int
276 TimerRun(struct IsdnCardState *cs)
277 {
278 register u_char v;
279
280 v = bytein(cs->hw.elsa.cfg);
281 if ((cs->subtyp == ELSA_QS1000) || (cs->subtyp == ELSA_QS3000))
282 return (0 == (v & ELSA_TIMER_RUN));
283 else if (cs->subtyp == ELSA_PCC8)
284 return (v & ELSA_TIMER_RUN_PCC8);
285 return (v & ELSA_TIMER_RUN);
286 }
287 /*
288 * fast interrupt HSCX stuff goes here
289 */
290
291 #define READHSCX(cs, nr, reg) readreg(cs->hw.elsa.ale, \
292 cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0))
293 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.elsa.ale, \
294 cs->hw.elsa.hscx, reg + (nr ? 0x40 : 0), data)
295
296 #define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.elsa.ale, \
297 cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)
298
299 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.elsa.ale, \
300 cs->hw.elsa.hscx, (nr ? 0x40 : 0), ptr, cnt)
301
302 #include "hscx_irq.c"
303
304 static void
305 elsa_interrupt(int intno, void *dev_id, struct pt_regs *regs)
306 {
307 struct IsdnCardState *cs = dev_id;
308 u_char val;
309 int icnt=5;
310
311 if (!cs) {
312 printk(KERN_WARNING "Elsa: Spurious interrupt!\n");
313 return;
314 }
315 if ((cs->typ == ISDN_CTYPE_ELSA_PCMCIA) && (*cs->busy_flag == 1)) {
316 /* The card tends to generate interrupts while being removed
317 causing us to just crash the kernel. bad. */
318 printk(KERN_WARNING "Elsa: card not available!\n");
319 return;
320 }
321 #if ARCOFI_USE
322 if (cs->hw.elsa.MFlag) {
323 val = serial_inp(cs, UART_IIR);
324 if (!(val & UART_IIR_NO_INT)) {
325 debugl1(cs,"IIR %02x", val);
326 rs_interrupt_elsa(intno, cs);
327 }
328 }
329 #endif
330 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
331 Start_HSCX:
332 if (val) {
333 hscx_int_main(cs, val);
334 }
335 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
336 Start_ISAC:
337 if (val) {
338 isac_interrupt(cs, val);
339 }
340 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
341 if (val && icnt) {
342 if (cs->debug & L1_DEB_HSCX)
343 debugl1(cs, "HSCX IntStat after IntRoutine");
344 icnt--;
345 goto Start_HSCX;
346 }
347 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA);
348 if (val && icnt) {
349 if (cs->debug & L1_DEB_ISAC)
350 debugl1(cs, "ISAC IntStat after IntRoutine");
351 icnt--;
352 goto Start_ISAC;
353 }
354 if (!icnt)
355 printk(KERN_WARNING"ELSA IRQ LOOP\n");
356 writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0xFF);
357 writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0xFF);
358 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0xFF);
359 if (cs->hw.elsa.status & ELSA_TIMER_AKTIV) {
360 if (!TimerRun(cs)) {
361 /* Timer Restart */
362 byteout(cs->hw.elsa.timer, 0);
363 cs->hw.elsa.counter++;
364 }
365 }
366 #if ARCOFI_USE
367 if (cs->hw.elsa.MFlag) {
368 val = serial_inp(cs, UART_MCR);
369 val ^= 0x8;
370 serial_outp(cs, UART_MCR, val);
371 val = serial_inp(cs, UART_MCR);
372 val ^= 0x8;
373 serial_outp(cs, UART_MCR, val);
374 }
375 #endif
376 if (cs->hw.elsa.trig)
377 byteout(cs->hw.elsa.trig, 0x00);
378 writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK, 0x0);
379 writereg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_MASK + 0x40, 0x0);
380 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_MASK, 0x0);
381 }
382
383 static void
384 elsa_interrupt_ipac(int intno, void *dev_id, struct pt_regs *regs)
385 {
386 struct IsdnCardState *cs = dev_id;
387 u_char ista,val;
388 int icnt=5;
389
390 if (!cs) {
391 printk(KERN_WARNING "Elsa: Spurious interrupt!\n");
392 return;
393 }
394 if (cs->subtyp == ELSA_QS1000PCI || cs->subtyp == ELSA_QS3000PCI) {
395 val = bytein(cs->hw.elsa.cfg + 0x4c); /* PCI IRQ */
396 if (!(val & ELSA_PCI_IRQ_MASK))
397 return;
398 }
399 #if ARCOFI_USE
400 if (cs->hw.elsa.MFlag) {
401 val = serial_inp(cs, UART_IIR);
402 if (!(val & UART_IIR_NO_INT)) {
403 debugl1(cs,"IIR %02x", val);
404 rs_interrupt_elsa(intno, cs);
405 }
406 }
407 #endif
408 ista = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
409 Start_IPAC:
410 if (cs->debug & L1_DEB_IPAC)
411 debugl1(cs, "IPAC ISTA %02X", ista);
412 if (ista & 0x0f) {
413 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.hscx, HSCX_ISTA + 0x40);
414 if (ista & 0x01)
415 val |= 0x01;
416 if (ista & 0x04)
417 val |= 0x02;
418 if (ista & 0x08)
419 val |= 0x04;
420 if (val)
421 hscx_int_main(cs, val);
422 }
423 if (ista & 0x20) {
424 val = 0xfe & readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, ISAC_ISTA + 0x80);
425 if (val) {
426 isac_interrupt(cs, val);
427 }
428 }
429 if (ista & 0x10) {
430 val = 0x01;
431 isac_interrupt(cs, val);
432 }
433 ista = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ISTA);
434 if ((ista & 0x3f) && icnt) {
435 icnt--;
436 goto Start_IPAC;
437 }
438 if (!icnt)
439 printk(KERN_WARNING "ELSA IRQ LOOP\n");
440 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xFF);
441 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xC0);
442 }
443
444 void
445 release_io_elsa(struct IsdnCardState *cs)
446 {
447 int bytecnt = 8;
448
449 del_timer(&cs->hw.elsa.tl);
450 #if ARCOFI_USE
451 clear_arcofi(cs);
452 #endif
453 if (cs->hw.elsa.ctrl)
454 byteout(cs->hw.elsa.ctrl, 0); /* LEDs Out */
455 if (cs->subtyp == ELSA_QS1000PCI) {
456 byteout(cs->hw.elsa.cfg + 0x4c, 0x01); /* disable IRQ */
457 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
458 bytecnt = 2;
459 release_region(cs->hw.elsa.cfg, 0x80);
460 }
461 if (cs->subtyp == ELSA_QS3000PCI) {
462 byteout(cs->hw.elsa.cfg + 0x4c, 0x03); /* disable ELSA PCI IRQ */
463 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
464 release_region(cs->hw.elsa.cfg, 0x80);
465 }
466 if (cs->subtyp == ELSA_PCMCIA_IPAC) {
467 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
468 }
469 if ((cs->subtyp == ELSA_PCFPRO) ||
470 (cs->subtyp == ELSA_QS3000) ||
471 (cs->subtyp == ELSA_PCF) ||
472 (cs->subtyp == ELSA_QS3000PCI)) {
473 bytecnt = 16;
474 #if ARCOFI_USE
475 release_modem(cs);
476 #endif
477 }
478 if (cs->hw.elsa.base)
479 release_region(cs->hw.elsa.base, bytecnt);
480 }
481
482 static void
483 reset_elsa(struct IsdnCardState *cs)
484 {
485 long flags;
486
487 if (cs->hw.elsa.timer) {
488 /* Wait 1 Timer */
489 byteout(cs->hw.elsa.timer, 0);
490 while (TimerRun(cs));
491 cs->hw.elsa.ctrl_reg |= 0x50;
492 cs->hw.elsa.ctrl_reg &= ~ELSA_ISDN_RESET; /* Reset On */
493 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
494 /* Wait 1 Timer */
495 byteout(cs->hw.elsa.timer, 0);
496 while (TimerRun(cs));
497 cs->hw.elsa.ctrl_reg |= ELSA_ISDN_RESET; /* Reset Off */
498 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
499 /* Wait 1 Timer */
500 byteout(cs->hw.elsa.timer, 0);
501 while (TimerRun(cs));
502 if (cs->hw.elsa.trig)
503 byteout(cs->hw.elsa.trig, 0xff);
504 }
505 if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
506 save_flags(flags);
507 sti();
508 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x20);
509 set_current_state(TASK_UNINTERRUPTIBLE);
510 schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
511 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x00);
512 set_current_state(TASK_UNINTERRUPTIBLE);
513 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xc0);
514 schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
515 restore_flags(flags);
516 if (cs->subtyp != ELSA_PCMCIA_IPAC) {
517 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x0);
518 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0x3c);
519 } else {
520 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_PCFG, 0x10);
521 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x4);
522 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0xf8);
523 }
524 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, 0xff);
525 if (cs->subtyp == ELSA_QS1000PCI)
526 byteout(cs->hw.elsa.cfg + 0x4c, 0x41); /* enable ELSA PCI IRQ */
527 else if (cs->subtyp == ELSA_QS3000PCI)
528 byteout(cs->hw.elsa.cfg + 0x4c, 0x43); /* enable ELSA PCI IRQ */
529 }
530 }
531
532 #if ARCOFI_USE
533
534 static void
535 set_arcofi(struct IsdnCardState *cs, int bc) {
536 cs->dc.isac.arcofi_bc = bc;
537 arcofi_fsm(cs, ARCOFI_START, &ARCOFI_COP_5);
538 interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
539 }
540
541 static int
542 check_arcofi(struct IsdnCardState *cs)
543 {
544 int arcofi_present = 0;
545 char tmp[40];
546 char *t;
547 u_char *p;
548
549 if (!cs->dc.isac.mon_tx)
550 if (!(cs->dc.isac.mon_tx=kmalloc(MAX_MON_FRAME, GFP_ATOMIC))) {
551 if (cs->debug & L1_DEB_WARN)
552 debugl1(cs, "ISAC MON TX out of buffers!");
553 return(0);
554 }
555 cs->dc.isac.arcofi_bc = 0;
556 arcofi_fsm(cs, ARCOFI_START, &ARCOFI_VERSION);
557 interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
558 if (!test_and_clear_bit(FLG_ARCOFI_ERROR, &cs->HW_Flags)) {
559 debugl1(cs, "Arcofi response received %d bytes", cs->dc.isac.mon_rxp);
560 p = cs->dc.isac.mon_rx;
561 t = tmp;
562 t += sprintf(tmp, "Arcofi data");
563 QuickHex(t, p, cs->dc.isac.mon_rxp);
564 debugl1(cs, tmp);
565 if ((cs->dc.isac.mon_rxp == 2) && (cs->dc.isac.mon_rx[0] == 0xa0)) {
566 switch(cs->dc.isac.mon_rx[1]) {
567 case 0x80:
568 debugl1(cs, "Arcofi 2160 detected");
569 arcofi_present = 1;
570 break;
571 case 0x82:
572 debugl1(cs, "Arcofi 2165 detected");
573 arcofi_present = 2;
574 break;
575 case 0x84:
576 debugl1(cs, "Arcofi 2163 detected");
577 arcofi_present = 3;
578 break;
579 default:
580 debugl1(cs, "unknown Arcofi response");
581 break;
582 }
583 } else
584 debugl1(cs, "undefined Monitor response");
585 cs->dc.isac.mon_rxp = 0;
586 } else if (cs->dc.isac.mon_tx) {
587 debugl1(cs, "Arcofi not detected");
588 }
589 if (arcofi_present) {
590 if (cs->subtyp==ELSA_QS1000) {
591 cs->subtyp = ELSA_QS3000;
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 release_region(cs->hw.elsa.base, 8);
597 if (check_region(cs->hw.elsa.base, 16)) {
598 printk(KERN_WARNING
599 "HiSax: %s config port %lx-%lx already in use\n",
600 Elsa_Types[cs->subtyp],
601 cs->hw.elsa.base + 8,
602 cs->hw.elsa.base + 16);
603 } else
604 request_region(cs->hw.elsa.base, 16,
605 "elsa isdn modem");
606 } else if (cs->subtyp==ELSA_PCC16) {
607 cs->subtyp = ELSA_PCF;
608 printk(KERN_INFO
609 "Elsa: %s detected modem at 0x%lx\n",
610 Elsa_Types[cs->subtyp],
611 cs->hw.elsa.base+8);
612 release_region(cs->hw.elsa.base, 8);
613 if (check_region(cs->hw.elsa.base, 16)) {
614 printk(KERN_WARNING
615 "HiSax: %s config port %lx-%lx already in use\n",
616 Elsa_Types[cs->subtyp],
617 cs->hw.elsa.base + 8,
618 cs->hw.elsa.base + 16);
619 } else
620 request_region(cs->hw.elsa.base, 16,
621 "elsa isdn modem");
622 } else
623 printk(KERN_INFO
624 "Elsa: %s detected modem at 0x%lx\n",
625 Elsa_Types[cs->subtyp],
626 cs->hw.elsa.base+8);
627 arcofi_fsm(cs, ARCOFI_START, &ARCOFI_XOP_0);
628 interruptible_sleep_on(&cs->dc.isac.arcofi_wait);
629 return(1);
630 }
631 return(0);
632 }
633 #endif /* ARCOFI_USE */
634
635 static void
636 elsa_led_handler(struct IsdnCardState *cs)
637 {
638 int blink = 0;
639
640 if (cs->subtyp == ELSA_PCMCIA || cs->subtyp == ELSA_PCMCIA_IPAC)
641 return;
642 del_timer(&cs->hw.elsa.tl);
643 if (cs->hw.elsa.status & ELSA_ASSIGN)
644 cs->hw.elsa.ctrl_reg |= ELSA_STAT_LED;
645 else if (cs->hw.elsa.status & ELSA_BAD_PWR)
646 cs->hw.elsa.ctrl_reg &= ~ELSA_STAT_LED;
647 else {
648 cs->hw.elsa.ctrl_reg ^= ELSA_STAT_LED;
649 blink = 250;
650 }
651 if (cs->hw.elsa.status & 0xf000)
652 cs->hw.elsa.ctrl_reg |= ELSA_LINE_LED;
653 else if (cs->hw.elsa.status & 0x0f00) {
654 cs->hw.elsa.ctrl_reg ^= ELSA_LINE_LED;
655 blink = 500;
656 } else
657 cs->hw.elsa.ctrl_reg &= ~ELSA_LINE_LED;
658
659 if ((cs->subtyp == ELSA_QS1000PCI) ||
660 (cs->subtyp == ELSA_QS3000PCI)) {
661 u_char led = 0xff;
662 if (cs->hw.elsa.ctrl_reg & ELSA_LINE_LED)
663 led ^= ELSA_IPAC_LINE_LED;
664 if (cs->hw.elsa.ctrl_reg & ELSA_STAT_LED)
665 led ^= ELSA_IPAC_STAT_LED;
666 writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ATX, led);
667 } else
668 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
669 if (blink) {
670 init_timer(&cs->hw.elsa.tl);
671 cs->hw.elsa.tl.expires = jiffies + ((blink * HZ) / 1000);
672 add_timer(&cs->hw.elsa.tl);
673 }
674 }
675
676 static int
677 Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
678 {
679 int ret = 0;
680 long flags;
681
682 switch (mt) {
683 case CARD_RESET:
684 reset_elsa(cs);
685 return(0);
686 case CARD_RELEASE:
687 release_io_elsa(cs);
688 return(0);
689 case CARD_INIT:
690 cs->debug |= L1_DEB_IPAC;
691 inithscxisac(cs, 1);
692 if ((cs->subtyp == ELSA_QS1000) ||
693 (cs->subtyp == ELSA_QS3000))
694 {
695 byteout(cs->hw.elsa.timer, 0);
696 }
697 if (cs->hw.elsa.trig)
698 byteout(cs->hw.elsa.trig, 0xff);
699 inithscxisac(cs, 2);
700 return(0);
701 case CARD_TEST:
702 if ((cs->subtyp == ELSA_PCMCIA) ||
703 (cs->subtyp == ELSA_PCMCIA_IPAC) ||
704 (cs->subtyp == ELSA_QS1000PCI)) {
705 return(0);
706 } else if (cs->subtyp == ELSA_QS3000PCI) {
707 ret = 0;
708 } else {
709 save_flags(flags);
710 cs->hw.elsa.counter = 0;
711 sti();
712 cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
713 cs->hw.elsa.status |= ELSA_TIMER_AKTIV;
714 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
715 byteout(cs->hw.elsa.timer, 0);
716 set_current_state(TASK_UNINTERRUPTIBLE);
717 schedule_timeout((110*HZ)/1000);
718 restore_flags(flags);
719 cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
720 byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
721 cs->hw.elsa.status &= ~ELSA_TIMER_AKTIV;
722 printk(KERN_INFO "Elsa: %d timer tics in 110 msek\n",
723 cs->hw.elsa.counter);
724 if ((cs->hw.elsa.counter > 10) &&
725 (cs->hw.elsa.counter < 16)) {
726 printk(KERN_INFO "Elsa: timer and irq OK\n");
727 ret = 0;
728 } else {
729 printk(KERN_WARNING
730 "Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n",
731 cs->hw.elsa.counter, cs->irq);
732 ret = 1;
733 }
734 }
735 #if ARCOFI_USE
736 if (check_arcofi(cs)) {
737 init_modem(cs);
738 }
739 #endif
740 elsa_led_handler(cs);
741 return(ret);
742 case (MDL_REMOVE | REQUEST):
743 cs->hw.elsa.status &= 0;
744 break;
745 case (MDL_ASSIGN | REQUEST):
746 cs->hw.elsa.status |= ELSA_ASSIGN;
747 break;
748 case MDL_INFO_SETUP:
749 if ((long) arg)
750 cs->hw.elsa.status |= 0x0200;
751 else
752 cs->hw.elsa.status |= 0x0100;
753 break;
754 case MDL_INFO_CONN:
755 if ((long) arg)
756 cs->hw.elsa.status |= 0x2000;
757 else
758 cs->hw.elsa.status |= 0x1000;
759 break;
760 case MDL_INFO_REL:
761 if ((long) arg) {
762 cs->hw.elsa.status &= ~0x2000;
763 cs->hw.elsa.status &= ~0x0200;
764 } else {
765 cs->hw.elsa.status &= ~0x1000;
766 cs->hw.elsa.status &= ~0x0100;
767 }
768 break;
769 #if ARCOFI_USE
770 case CARD_AUX_IND:
771 if (cs->hw.elsa.MFlag) {
772 int len;
773 u_char *msg;
774
775 if (!arg)
776 return(0);
777 msg = arg;
778 len = *msg;
779 msg++;
780 modem_write_cmd(cs, msg, len);
781 }
782 break;
783 #endif
784 }
785 if (cs->typ == ISDN_CTYPE_ELSA) {
786 int pwr = bytein(cs->hw.elsa.ale);
787 if (pwr & 0x08)
788 cs->hw.elsa.status |= ELSA_BAD_PWR;
789 else
790 cs->hw.elsa.status &= ~ELSA_BAD_PWR;
791 }
792 elsa_led_handler(cs);
793 return(ret);
794 }
795
796 static unsigned char
797 probe_elsa_adr(unsigned int adr, int typ)
798 {
799 int i, in1, in2, p16_1 = 0, p16_2 = 0, p8_1 = 0, p8_2 = 0, pc_1 = 0,
800 pc_2 = 0, pfp_1 = 0, pfp_2 = 0;
801 long flags;
802
803 /* In case of the elsa pcmcia card, this region is in use,
804 reserved for us by the card manager. So we do not check it
805 here, it would fail. */
806 if (typ != ISDN_CTYPE_ELSA_PCMCIA && check_region(adr, 8)) {
807 printk(KERN_WARNING
808 "Elsa: Probing Port 0x%x: already in use\n",
809 adr);
810 return (0);
811 }
812 save_flags(flags);
813 cli();
814 for (i = 0; i < 16; i++) {
815 in1 = inb(adr + ELSA_CONFIG); /* 'toggelt' bei */
816 in2 = inb(adr + ELSA_CONFIG); /* jedem Zugriff */
817 p16_1 += 0x04 & in1;
818 p16_2 += 0x04 & in2;
819 p8_1 += 0x02 & in1;
820 p8_2 += 0x02 & in2;
821 pc_1 += 0x01 & in1;
822 pc_2 += 0x01 & in2;
823 pfp_1 += 0x40 & in1;
824 pfp_2 += 0x40 & in2;
825 }
826 restore_flags(flags);
827 printk(KERN_INFO "Elsa: Probing IO 0x%x", adr);
828 if (65 == ++p16_1 * ++p16_2) {
829 printk(" PCC-16/PCF found\n");
830 return (ELSA_PCC16);
831 } else if (1025 == ++pfp_1 * ++pfp_2) {
832 printk(" PCF-Pro found\n");
833 return (ELSA_PCFPRO);
834 } else if (33 == ++p8_1 * ++p8_2) {
835 printk(" PCC8 found\n");
836 return (ELSA_PCC8);
837 } else if (17 == ++pc_1 * ++pc_2) {
838 printk(" PC found\n");
839 return (ELSA_PC);
840 } else {
841 printk(" failed\n");
842 return (0);
843 }
844 }
845
846 static unsigned int
847 probe_elsa(struct IsdnCardState *cs)
848 {
849 int i;
850 unsigned int CARD_portlist[] =
851 {0x160, 0x170, 0x260, 0x360, 0};
852
853 for (i = 0; CARD_portlist[i]; i++) {
854 if ((cs->subtyp = probe_elsa_adr(CARD_portlist[i], cs->typ)))
855 break;
856 }
857 return (CARD_portlist[i]);
858 }
859
860 static struct pci_dev *dev_qs1000 __devinitdata = NULL;
861 static struct pci_dev *dev_qs3000 __devinitdata = NULL;
862
863 int __devinit
864 setup_elsa(struct IsdnCard *card)
865 {
866 long flags;
867 int bytecnt;
868 u_char val;
869 struct IsdnCardState *cs = card->cs;
870 char tmp[64];
871
872 strcpy(tmp, Elsa_revision);
873 printk(KERN_INFO "HiSax: Elsa driver Rev. %s\n", HiSax_getrev(tmp));
874 cs->hw.elsa.ctrl_reg = 0;
875 cs->hw.elsa.status = 0;
876 cs->hw.elsa.MFlag = 0;
877 if (cs->typ == ISDN_CTYPE_ELSA) {
878 cs->hw.elsa.base = card->para[0];
879 printk(KERN_INFO "Elsa: Microlink IO probing\n");
880 if (cs->hw.elsa.base) {
881 if (!(cs->subtyp = probe_elsa_adr(cs->hw.elsa.base,
882 cs->typ))) {
883 printk(KERN_WARNING
884 "Elsa: no Elsa Microlink at %#lx\n",
885 cs->hw.elsa.base);
886 return (0);
887 }
888 } else
889 cs->hw.elsa.base = probe_elsa(cs);
890 if (cs->hw.elsa.base) {
891 cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
892 cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
893 cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
894 cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
895 cs->hw.elsa.itac = cs->hw.elsa.base + ELSA_ITAC;
896 cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
897 cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
898 cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
899 val = bytein(cs->hw.elsa.cfg);
900 if (cs->subtyp == ELSA_PC) {
901 const u_char CARD_IrqTab[8] =
902 {7, 3, 5, 9, 0, 0, 0, 0};
903 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PC) >> 2];
904 } else if (cs->subtyp == ELSA_PCC8) {
905 const u_char CARD_IrqTab[8] =
906 {7, 3, 5, 9, 0, 0, 0, 0};
907 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PCC8) >> 4];
908 } else {
909 const u_char CARD_IrqTab[8] =
910 {15, 10, 15, 3, 11, 5, 11, 9};
911 cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX) >> 3];
912 }
913 val = bytein(cs->hw.elsa.ale) & ELSA_HW_RELEASE;
914 if (val < 3)
915 val |= 8;
916 val += 'A' - 3;
917 if (val == 'B' || val == 'C')
918 val ^= 1;
919 if ((cs->subtyp == ELSA_PCFPRO) && (val = 'G'))
920 val = 'C';
921 printk(KERN_INFO
922 "Elsa: %s found at %#lx Rev.:%c IRQ %d\n",
923 Elsa_Types[cs->subtyp],
924 cs->hw.elsa.base,
925 val, cs->irq);
926 val = bytein(cs->hw.elsa.ale) & ELSA_S0_POWER_BAD;
927 if (val) {
928 printk(KERN_WARNING
929 "Elsa: Microlink S0 bus power bad\n");
930 cs->hw.elsa.status |= ELSA_BAD_PWR;
931 }
932 } else {
933 printk(KERN_WARNING
934 "No Elsa Microlink found\n");
935 return (0);
936 }
937 } else if (cs->typ == ISDN_CTYPE_ELSA_PNP) {
938 cs->hw.elsa.base = card->para[1];
939 cs->irq = card->para[0];
940 cs->subtyp = ELSA_QS1000;
941 cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
942 cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
943 cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
944 cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
945 cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
946 cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
947 cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
948 printk(KERN_INFO
949 "Elsa: %s defined at %#lx IRQ %d\n",
950 Elsa_Types[cs->subtyp],
951 cs->hw.elsa.base,
952 cs->irq);
953 } else if (cs->typ == ISDN_CTYPE_ELSA_PCMCIA) {
954 cs->hw.elsa.base = card->para[1];
955 cs->irq = card->para[0];
956 val = readreg(cs->hw.elsa.base + 0, cs->hw.elsa.base + 2, IPAC_ID);
957 if ((val == 1) || (val == 2)) { /* IPAC version 1.1/1.2 */
958 cs->subtyp = ELSA_PCMCIA_IPAC;
959 cs->hw.elsa.ale = cs->hw.elsa.base + 0;
960 cs->hw.elsa.isac = cs->hw.elsa.base + 2;
961 cs->hw.elsa.hscx = cs->hw.elsa.base + 2;
962 test_and_set_bit(HW_IPAC, &cs->HW_Flags);
963 } else {
964 cs->subtyp = ELSA_PCMCIA;
965 cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE_PCM;
966 cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC_PCM;
967 cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
968 }
969 cs->hw.elsa.timer = 0;
970 cs->hw.elsa.trig = 0;
971 cs->hw.elsa.ctrl = 0;
972 printk(KERN_INFO
973 "Elsa: %s defined at %#lx IRQ %d\n",
974 Elsa_Types[cs->subtyp],
975 cs->hw.elsa.base,
976 cs->irq);
977 } else if (cs->typ == ISDN_CTYPE_ELSA_PCI) {
978 #if CONFIG_PCI
979 if (!pci_present()) {
980 printk(KERN_ERR "Elsa: no PCI bus present\n");
981 return(0);
982 }
983 cs->subtyp = 0;
984 if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
985 PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
986 if (pci_enable_device(dev_qs1000))
987 return(0);
988 cs->subtyp = ELSA_QS1000PCI;
989 cs->irq = dev_qs1000->irq;
990 cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
991 cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
992 } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
993 PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
994 if (pci_enable_device(dev_qs3000))
995 return(0);
996 cs->subtyp = ELSA_QS3000PCI;
997 cs->irq = dev_qs3000->irq;
998 cs->hw.elsa.cfg = pci_resource_start(dev_qs3000, 1);
999 cs->hw.elsa.base = pci_resource_start(dev_qs3000, 3);
1000 } else {
1001 printk(KERN_WARNING "Elsa: No PCI card found\n");
1002 return(0);
1003 }
1004 if (!cs->irq) {
1005 printk(KERN_WARNING "Elsa: No IRQ for PCI card found\n");
1006 return(0);
1007 }
1008
1009 if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
1010 printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found\n");
1011 return(0);
1012 }
1013 if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
1014 printk(KERN_WARNING "Elsa: You may have a wrong PCI bios\n");
1015 printk(KERN_WARNING "Elsa: If your system hangs now, read\n");
1016 printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax\n");
1017 printk(KERN_WARNING "Elsa: Waiting 5 sec to sync discs\n");
1018 save_flags(flags);
1019 sti();
1020 HZDELAY(500); /* wait 500*10 ms */
1021 restore_flags(flags);
1022 }
1023 cs->hw.elsa.ale = cs->hw.elsa.base;
1024 cs->hw.elsa.isac = cs->hw.elsa.base +1;
1025 cs->hw.elsa.hscx = cs->hw.elsa.base +1;
1026 test_and_set_bit(HW_IPAC, &cs->HW_Flags);
1027 cs->hw.elsa.timer = 0;
1028 cs->hw.elsa.trig = 0;
1029 cs->irq_flags |= SA_SHIRQ;
1030 printk(KERN_INFO
1031 "Elsa: %s defined at %#lx/0x%x IRQ %d\n",
1032 Elsa_Types[cs->subtyp],
1033 cs->hw.elsa.base,
1034 cs->hw.elsa.cfg,
1035 cs->irq);
1036 #else
1037 printk(KERN_WARNING "Elsa: Elsa PCI and NO_PCI_BIOS\n");
1038 printk(KERN_WARNING "Elsa: unable to config Elsa PCI\n");
1039 return (0);
1040 #endif /* CONFIG_PCI */
1041 } else
1042 return (0);
1043
1044 switch (cs->subtyp) {
1045 case ELSA_PC:
1046 case ELSA_PCC8:
1047 case ELSA_PCC16:
1048 case ELSA_QS1000:
1049 case ELSA_PCMCIA:
1050 case ELSA_PCMCIA_IPAC:
1051 bytecnt = 8;
1052 break;
1053 case ELSA_PCFPRO:
1054 case ELSA_PCF:
1055 case ELSA_QS3000PCI:
1056 bytecnt = 16;
1057 break;
1058 case ELSA_QS1000PCI:
1059 bytecnt = 2;
1060 break;
1061 default:
1062 printk(KERN_WARNING
1063 "Unknown ELSA subtype %d\n", cs->subtyp);
1064 return (0);
1065 }
1066 /* In case of the elsa pcmcia card, this region is in use,
1067 reserved for us by the card manager. So we do not check it
1068 here, it would fail. */
1069 if (cs->typ != ISDN_CTYPE_ELSA_PCMCIA && check_region(cs->hw.elsa.base, bytecnt)) {
1070 printk(KERN_WARNING
1071 "HiSax: %s config port %#lx-%#lx already in use\n",
1072 CardType[card->typ],
1073 cs->hw.elsa.base,
1074 cs->hw.elsa.base + bytecnt);
1075 return (0);
1076 } else {
1077 request_region(cs->hw.elsa.base, bytecnt, "elsa isdn");
1078 }
1079 if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI)) {
1080 if (check_region(cs->hw.elsa.cfg, 0x80)) {
1081 printk(KERN_WARNING
1082 "HiSax: %s pci port %x-%x already in use\n",
1083 CardType[card->typ],
1084 cs->hw.elsa.cfg,
1085 cs->hw.elsa.cfg + 0x80);
1086 release_region(cs->hw.elsa.base, bytecnt);
1087 return (0);
1088 } else {
1089 request_region(cs->hw.elsa.cfg, 0x80, "elsa isdn pci");
1090 }
1091 }
1092 #if ARCOFI_USE
1093 init_arcofi(cs);
1094 #endif
1095 cs->hw.elsa.tl.function = (void *) elsa_led_handler;
1096 cs->hw.elsa.tl.data = (long) cs;
1097 init_timer(&cs->hw.elsa.tl);
1098 /* Teste Timer */
1099 if (cs->hw.elsa.timer) {
1100 byteout(cs->hw.elsa.trig, 0xff);
1101 byteout(cs->hw.elsa.timer, 0);
1102 if (!TimerRun(cs)) {
1103 byteout(cs->hw.elsa.timer, 0); /* 2. Versuch */
1104 if (!TimerRun(cs)) {
1105 printk(KERN_WARNING
1106 "Elsa: timer do not start\n");
1107 release_io_elsa(cs);
1108 return (0);
1109 }
1110 }
1111 save_flags(flags);
1112 sti();
1113 HZDELAY(1); /* wait >=10 ms */
1114 restore_flags(flags);
1115 if (TimerRun(cs)) {
1116 printk(KERN_WARNING "Elsa: timer do not run down\n");
1117 release_io_elsa(cs);
1118 return (0);
1119 }
1120 printk(KERN_INFO "Elsa: timer OK; resetting card\n");
1121 }
1122 cs->BC_Read_Reg = &ReadHSCX;
1123 cs->BC_Write_Reg = &WriteHSCX;
1124 cs->BC_Send_Data = &hscx_fill_fifo;
1125 cs->cardmsg = &Elsa_card_msg;
1126 reset_elsa(cs);
1127 if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
1128 cs->readisac = &ReadISAC_IPAC;
1129 cs->writeisac = &WriteISAC_IPAC;
1130 cs->readisacfifo = &ReadISACfifo_IPAC;
1131 cs->writeisacfifo = &WriteISACfifo_IPAC;
1132 cs->irq_func = &elsa_interrupt_ipac;
1133 val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ID);
1134 printk(KERN_INFO "Elsa: IPAC version %x\n", val);
1135 } else {
1136 cs->readisac = &ReadISAC;
1137 cs->writeisac = &WriteISAC;
1138 cs->readisacfifo = &ReadISACfifo;
1139 cs->writeisacfifo = &WriteISACfifo;
1140 cs->irq_func = &elsa_interrupt;
1141 ISACVersion(cs, "Elsa:");
1142 if (HscxVersion(cs, "Elsa:")) {
1143 printk(KERN_WARNING
1144 "Elsa: wrong HSCX versions check IO address\n");
1145 release_io_elsa(cs);
1146 return (0);
1147 }
1148 }
1149 if (cs->subtyp == ELSA_PC) {
1150 val = readitac(cs, ITAC_SYS);
1151 printk(KERN_INFO "Elsa: ITAC version %s\n", ITACVer[val & 7]);
1152 writeitac(cs, ITAC_ISEN, 0);
1153 writeitac(cs, ITAC_RFIE, 0);
1154 writeitac(cs, ITAC_XFIE, 0);
1155 writeitac(cs, ITAC_SCIE, 0);
1156 writeitac(cs, ITAC_STIE, 0);
1157 }
1158 return (1);
1159 }
1160