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