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