开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
elsa.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：32k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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