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