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