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

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

嵌入式Linux

开发平台：

Unix_Linux

sedlbauer.c：源码内容
  1. /* $Id: sedlbauer.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * low level stuff for Sedlbauer cards
  4.  * includes support for the Sedlbauer speed star (speed star II),
  5.  * support for the Sedlbauer speed fax+,
  6.  * support for the Sedlbauer ISDN-Controller PC/104 and
  7.  * support for the Sedlbauer speed pci
  8.  * derived from the original file asuscom.c from Karsten Keil
  9.  *
  10.  * Author       Marcus Niemann
  11.  * Copyright    by Marcus Niemann    <niemann@www-bib.fh-bielefeld.de>
  12.  * 
  13.  * This software may be used and distributed according to the terms
  14.  * of the GNU General Public License, incorporated herein by reference.
  15.  *
  16.  * Thanks to  Karsten Keil
  17.  *            Sedlbauer AG for informations
  18.  *            Edgar Toernig
  19.  *
  20.  */
  22. /* Supported cards:
  23.  * Card: Chip: Configuration: Comment:
  24.  * ---------------------------------------------------------------------
  25.  * Speed Card ISAC_HSCX DIP-SWITCH
  26.  * Speed Win ISAC_HSCX ISAPNP
  27.  * Speed Fax+ ISAC_ISAR ISAPNP Full analog support
  28.  * Speed Star ISAC_HSCX CARDMGR
  29.  * Speed Win2 IPAC ISAPNP
  30.  * ISDN PC/104 IPAC DIP-SWITCH
  31.  * Speed Star2 IPAC CARDMGR
  32.  * Speed PCI IPAC PCI PNP
  33.  * Speed Fax+  ISAC_ISAR PCI PNP Full analog support
  34.  *
  35.  * Important:
  36.  * For the sedlbauer speed fax+ to work properly you have to download
  37.  * the firmware onto the card.
  38.  * For example: hisaxctrl <DriverID> 9 ISAR.BIN
  39. */
  41. #define __NO_VERSION__
  42. #include <linux/init.h>
  43. #include <linux/config.h>
  44. #include "hisax.h"
  45. #include "isac.h"
  46. #include "ipac.h"
  47. #include "hscx.h"
  48. #include "isar.h"
  49. #include "isdnl1.h"
  50. #include <linux/pci.h>
  52. extern const char *CardType[];
  54. const char *Sedlbauer_revision = "$Revision: 1.1.4.1 $";
  56. const char *Sedlbauer_Types[] =
  57. {"None", "speed card/win", "speed star", "speed fax+",
  58. "speed win II / ISDN PC/104", "speed star II", "speed pci",
  59. "speed fax+ pyramid", "speed fax+ pci"};
  61. #define PCI_SUBVENDOR_SPEEDFAX_PYRAMID 0x51
  62. #define PCI_SUBVENDOR_SEDLBAUER_PCI 0x53
  63. #define PCI_SUBVENDOR_SPEEDFAX_PCI 0x54
  64. #define PCI_SUB_ID_SEDLBAUER 0x01
  66. #define SEDL_SPEED_CARD_WIN 1
  67. #define SEDL_SPEED_STAR  2
  68. #define SEDL_SPEED_FAX 3
  69. #define SEDL_SPEED_WIN2_PC104  4
  70. #define SEDL_SPEED_STAR2  5
  71. #define SEDL_SPEED_PCI    6
  72. #define SEDL_SPEEDFAX_PYRAMID 7
  73. #define SEDL_SPEEDFAX_PCI 8
  75. #define SEDL_CHIP_TEST 0
  76. #define SEDL_CHIP_ISAC_HSCX 1
  77. #define SEDL_CHIP_ISAC_ISAR 2
  78. #define SEDL_CHIP_IPAC 3
  80. #define SEDL_BUS_ISA 1
  81. #define SEDL_BUS_PCI 2
  82. #define SEDL_BUS_PCMCIA 3
  84. #define byteout(addr,val) outb(val,addr)
  85. #define bytein(addr) inb(addr)
  87. #define SEDL_HSCX_ISA_RESET_ON 0
  88. #define SEDL_HSCX_ISA_RESET_OFF 1
  89. #define SEDL_HSCX_ISA_ISAC 2
  90. #define SEDL_HSCX_ISA_HSCX 3
  91. #define SEDL_HSCX_ISA_ADR 4
  93. #define SEDL_HSCX_PCMCIA_RESET 0
  94. #define SEDL_HSCX_PCMCIA_ISAC 1
  95. #define SEDL_HSCX_PCMCIA_HSCX 2
  96. #define SEDL_HSCX_PCMCIA_ADR 4
  98. #define SEDL_ISAR_ISA_ISAC 4
  99. #define SEDL_ISAR_ISA_ISAR 6
  100. #define SEDL_ISAR_ISA_ADR 8
  101. #define SEDL_ISAR_ISA_ISAR_RESET_ON 10
  102. #define SEDL_ISAR_ISA_ISAR_RESET_OFF 12
  104. #define SEDL_IPAC_ANY_ADR 0
  105. #define SEDL_IPAC_ANY_IPAC 2
  107. #define SEDL_IPAC_PCI_BASE 0
  108. #define SEDL_IPAC_PCI_ADR 0xc0
  109. #define SEDL_IPAC_PCI_IPAC 0xc8
  110. #define SEDL_ISAR_PCI_ADR 0xc8
  111. #define SEDL_ISAR_PCI_ISAC 0xd0
  112. #define SEDL_ISAR_PCI_ISAR 0xe0
  113. #define SEDL_ISAR_PCI_ISAR_RESET_ON 0x01
  114. #define SEDL_ISAR_PCI_ISAR_RESET_OFF 0x18
  115. #define SEDL_ISAR_PCI_LED1 0x08
  116. #define SEDL_ISAR_PCI_LED2 0x10
  118. #define SEDL_RESET      0x3 /* same as DOS driver */
  120. static inline u_char
  121. readreg(unsigned int ale, unsigned int adr, u_char off)
  122. {
  123. register u_char ret;
  124. long flags;
  126. save_flags(flags);
  127. cli();
  128. byteout(ale, off);
  129. ret = bytein(adr);
  130. restore_flags(flags);
  131. return (ret);
  132. }
  134. static inline void
  135. readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  136. {
  137. /* fifo read without cli because it's allready done  */
  139. byteout(ale, off);
  140. insb(adr, data, size);
  141. }
  144. static inline void
  145. writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
  146. {
  147. long flags;
  149. save_flags(flags);
  150. cli();
  151. byteout(ale, off);
  152. byteout(adr, data);
  153. restore_flags(flags);
  154. }
  156. static inline void
  157. writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  158. {
  159. /* fifo write without cli because it's allready done  */
  160. byteout(ale, off);
  161. outsb(adr, data, size);
  162. }
  164. /* Interface functions */
  166. static u_char
  167. ReadISAC(struct IsdnCardState *cs, u_char offset)
  168. {
  169. return (readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, offset));
  170. }
  172. static void
  173. WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
  174. {
  175. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, offset, value);
  176. }
  178. static void
  179. ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  180. {
  181. readfifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0, data, size);
  182. }
  184. static void
  185. WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  186. {
  187. writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0, data, size);
  188. }
  190. static u_char
  191. ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
  192. {
  193. return (readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, offset|0x80));
  194. }
  196. static void
  197. WriteISAC_IPAC(struct IsdnCardState *cs, u_char offset, u_char value)
  198. {
  199. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, offset|0x80, value);
  200. }
  202. static void
  203. ReadISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
  204. {
  205. readfifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0x80, data, size);
  206. }
  208. static void
  209. WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
  210. {
  211. writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0x80, data, size);
  212. }
  214. static u_char
  215. ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
  216. {
  217. return (readreg(cs->hw.sedl.adr,
  218. cs->hw.sedl.hscx, offset + (hscx ? 0x40 : 0)));
  219. }
  221. static void
  222. WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
  223. {
  224. writereg(cs->hw.sedl.adr,
  225.  cs->hw.sedl.hscx, offset + (hscx ? 0x40 : 0), value);
  226. }
  228. /* ISAR access routines
  229.  * mode = 0 access with IRQ on
  230.  * mode = 1 access with IRQ off
  231.  * mode = 2 access with IRQ off and using last offset
  232.  */
  234. static u_char
  235. ReadISAR(struct IsdnCardState *cs, int mode, u_char offset)
  236. {
  237. if (mode == 0)
  238. return (readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, offset));
  239. else if (mode == 1)
  240. byteout(cs->hw.sedl.adr, offset);
  241. return(bytein(cs->hw.sedl.hscx));
  242. }
  244. static void
  245. WriteISAR(struct IsdnCardState *cs, int mode, u_char offset, u_char value)
  246. {
  247. if (mode == 0)
  248. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, offset, value);
  249. else {
  250. if (mode == 1)
  251. byteout(cs->hw.sedl.adr, offset);
  252. byteout(cs->hw.sedl.hscx, value);
  253. }
  254. }
  256. /*
  257.  * fast interrupt HSCX stuff goes here
  258.  */
  260. #define READHSCX(cs, nr, reg) readreg(cs->hw.sedl.adr, 
  261. cs->hw.sedl.hscx, reg + (nr ? 0x40 : 0))
  262. #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.sedl.adr, 
  263. cs->hw.sedl.hscx, reg + (nr ? 0x40 : 0), data)
  265. #define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.sedl.adr, 
  266. cs->hw.sedl.hscx, (nr ? 0x40 : 0), ptr, cnt)
  268. #define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.sedl.adr, 
  269. cs->hw.sedl.hscx, (nr ? 0x40 : 0), ptr, cnt)
  271. #include "hscx_irq.c"
  273. static void
  274. sedlbauer_interrupt(int intno, void *dev_id, struct pt_regs *regs)
  275. {
  276. struct IsdnCardState *cs = dev_id;
  277. u_char val;
  279. if (!cs) {
  280. printk(KERN_WARNING "Sedlbauer: Spurious interrupt!n");
  281. return;
  282. }
  284. if ((cs->hw.sedl.bus == SEDL_BUS_PCMCIA) && (*cs->busy_flag == 1)) {
  285. /* The card tends to generate interrupts while being removed
  286.    causing us to just crash the kernel. bad. */
  287. printk(KERN_WARNING "Sedlbauer: card not available!n");
  288. return;
  289. }
  291. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_ISTA + 0x40);
  292.       Start_HSCX:
  293. if (val)
  294. hscx_int_main(cs, val);
  295. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_ISTA);
  296.       Start_ISAC:
  297. if (val)
  298. isac_interrupt(cs, val);
  299. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_ISTA + 0x40);
  300. if (val) {
  301. if (cs->debug & L1_DEB_HSCX)
  302. debugl1(cs, "HSCX IntStat after IntRoutine");
  303. goto Start_HSCX;
  304. }
  305. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_ISTA);
  306. if (val) {
  307. if (cs->debug & L1_DEB_ISAC)
  308. debugl1(cs, "ISAC IntStat after IntRoutine");
  309. goto Start_ISAC;
  310. }
  311. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_MASK, 0xFF);
  312. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_MASK + 0x40, 0xFF);
  313. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_MASK, 0xFF);
  314. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_MASK, 0x0);
  315. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_MASK, 0x0);
  316. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_MASK + 0x40, 0x0);
  317. }
  319. static void
  320. sedlbauer_interrupt_ipac(int intno, void *dev_id, struct pt_regs *regs)
  321. {
  322. struct IsdnCardState *cs = dev_id;
  323. u_char ista, val, icnt = 5;
  325. if (!cs) {
  326. printk(KERN_WARNING "Sedlbauer: Spurious interrupt!n");
  327. return;
  328. }
  329. ista = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_ISTA);
  330. Start_IPAC:
  331. if (cs->debug & L1_DEB_IPAC)
  332. debugl1(cs, "IPAC ISTA %02X", ista);
  333. if (ista & 0x0f) {
  334. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, HSCX_ISTA + 0x40);
  335. if (ista & 0x01)
  336. val |= 0x01;
  337. if (ista & 0x04)
  338. val |= 0x02;
  339. if (ista & 0x08)
  340. val |= 0x04;
  341. if (val)
  342. hscx_int_main(cs, val);
  343. }
  344. if (ista & 0x20) {
  345. val = 0xfe & readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_ISTA | 0x80);
  346. if (val) {
  347. isac_interrupt(cs, val);
  348. }
  349. }
  350. if (ista & 0x10) {
  351. val = 0x01;
  352. isac_interrupt(cs, val);
  353. }
  354. ista  = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_ISTA);
  355. if ((ista & 0x3f) && icnt) {
  356. icnt--;
  357. goto Start_IPAC;
  358. }
  359. if (!icnt)
  360. if (cs->debug & L1_DEB_ISAC)
  361. debugl1(cs, "Sedlbauer IRQ LOOP");
  362. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_MASK, 0xFF);
  363. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_MASK, 0xC0);
  364. }
  366. static void
  367. sedlbauer_interrupt_isar(int intno, void *dev_id, struct pt_regs *regs)
  368. {
  369. struct IsdnCardState *cs = dev_id;
  370. u_char val;
  371. int cnt = 5;
  373. if (!cs) {
  374. printk(KERN_WARNING "Sedlbauer: Spurious interrupt!n");
  375. return;
  376. }
  378. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, ISAR_IRQBIT);
  379.       Start_ISAR:
  380. if (val & ISAR_IRQSTA)
  381. isar_int_main(cs);
  382. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_ISTA);
  383.       Start_ISAC:
  384. if (val)
  385. isac_interrupt(cs, val);
  386. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.hscx, ISAR_IRQBIT);
  387. if ((val & ISAR_IRQSTA) && --cnt) {
  388. if (cs->debug & L1_DEB_HSCX)
  389. debugl1(cs, "ISAR IntStat after IntRoutine");
  390. goto Start_ISAR;
  391. }
  392. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_ISTA);
  393. if (val && --cnt) {
  394. if (cs->debug & L1_DEB_ISAC)
  395. debugl1(cs, "ISAC IntStat after IntRoutine");
  396. goto Start_ISAC;
  397. }
  398. if (!cnt)
  399. if (cs->debug & L1_DEB_ISAC)
  400. debugl1(cs, "Sedlbauer IRQ LOOP");
  402. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, ISAR_IRQBIT, 0);
  403. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_MASK, 0xFF);
  404. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, ISAC_MASK, 0x0);
  405. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx, ISAR_IRQBIT, ISAR_IRQMSK);
  406. }
  408. void
  409. release_io_sedlbauer(struct IsdnCardState *cs)
  410. {
  411. int bytecnt = 8;
  413. if (cs->subtyp == SEDL_SPEED_FAX) {
  414. bytecnt = 16;
  415. } else if (cs->hw.sedl.bus == SEDL_BUS_PCI) {
  416. bytecnt = 256;
  417. }
  418. if (cs->hw.sedl.cfg_reg)
  419. release_region(cs->hw.sedl.cfg_reg, bytecnt);
  420. }
  422. static void
  423. reset_sedlbauer(struct IsdnCardState *cs)
  424. {
  425. long flags;
  427. printk(KERN_INFO "Sedlbauer: resetting cardn");
  429. if (!((cs->hw.sedl.bus == SEDL_BUS_PCMCIA) &&
  430.    (cs->hw.sedl.chip == SEDL_CHIP_ISAC_HSCX))) {
  431. if (cs->hw.sedl.chip == SEDL_CHIP_IPAC) {
  432. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_POTA2, 0x20);
  433. save_flags(flags);
  434. sti();
  435. set_current_state(TASK_UNINTERRUPTIBLE);
  436. schedule_timeout((10*HZ)/1000);
  437. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_POTA2, 0x0);
  438. set_current_state(TASK_UNINTERRUPTIBLE);
  439. schedule_timeout((10*HZ)/1000);
  440. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_CONF, 0x0);
  441. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_ACFG, 0xff);
  442. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_AOE, 0x0);
  443. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_MASK, 0xc0);
  444. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_PCFG, 0x12);
  445. restore_flags(flags);
  446. } else if ((cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) &&
  447. (cs->hw.sedl.bus == SEDL_BUS_PCI)) {
  448. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
  449. save_flags(flags);
  450. sti();
  451. current->state = TASK_UNINTERRUPTIBLE;
  452. schedule_timeout((20*HZ)/1000);
  453. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
  454. current->state = TASK_UNINTERRUPTIBLE;
  455. schedule_timeout((20*HZ)/1000);
  456. restore_flags(flags);
  457. } else {
  458. byteout(cs->hw.sedl.reset_on, SEDL_RESET); /* Reset On */
  459. save_flags(flags);
  460. sti();
  461. set_current_state(TASK_UNINTERRUPTIBLE);
  462. schedule_timeout((10*HZ)/1000);
  463. byteout(cs->hw.sedl.reset_off, 0); /* Reset Off */
  464. set_current_state(TASK_UNINTERRUPTIBLE);
  465. schedule_timeout((10*HZ)/1000);
  466. restore_flags(flags);
  467. }
  468. }
  469. }
  471. static int
  472. Sedl_card_msg(struct IsdnCardState *cs, int mt, void *arg)
  473. {
  474. switch (mt) {
  475. case CARD_RESET:
  476. reset_sedlbauer(cs);
  477. return(0);
  478. case CARD_RELEASE:
  479. if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
  480. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx,
  481. ISAR_IRQBIT, 0);
  482. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac,
  483. ISAC_MASK, 0xFF);
  484. reset_sedlbauer(cs);
  485. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx,
  486. ISAR_IRQBIT, 0);
  487. writereg(cs->hw.sedl.adr, cs->hw.sedl.isac,
  488. ISAC_MASK, 0xFF);
  489. }
  490. release_io_sedlbauer(cs);
  491. return(0);
  492. case CARD_INIT:
  493. if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
  494. clear_pending_isac_ints(cs);
  495. writereg(cs->hw.sedl.adr, cs->hw.sedl.hscx,
  496. ISAR_IRQBIT, 0);
  497. initisac(cs);
  498. initisar(cs);
  499. /* Reenable all IRQ */
  500. cs->writeisac(cs, ISAC_MASK, 0);
  501. /* RESET Receiver and Transmitter */
  502. cs->writeisac(cs, ISAC_CMDR, 0x41);
  503. } else {
  504. inithscxisac(cs, 3);
  505. }
  506. return(0);
  507. case CARD_TEST:
  508. return(0);
  509. case MDL_INFO_CONN:
  510. if (cs->subtyp != SEDL_SPEEDFAX_PYRAMID)
  511. return(0);
  512. if ((long) arg)
  513. cs->hw.sedl.reset_off &= ~SEDL_ISAR_PCI_LED2;
  514. else
  515. cs->hw.sedl.reset_off &= ~SEDL_ISAR_PCI_LED1;
  516. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
  517. break;
  518. case MDL_INFO_REL:
  519. if (cs->subtyp != SEDL_SPEEDFAX_PYRAMID)
  520. return(0);
  521. if ((long) arg)
  522. cs->hw.sedl.reset_off |= SEDL_ISAR_PCI_LED2;
  523. else
  524. cs->hw.sedl.reset_off |= SEDL_ISAR_PCI_LED1;
  525. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
  526. break;
  527. }
  528. return(0);
  529. }
  531. static struct pci_dev *dev_sedl __devinitdata = NULL;
  533. int __devinit
  534. setup_sedlbauer(struct IsdnCard *card)
  535. {
  536. int bytecnt, ver, val;
  537. struct IsdnCardState *cs = card->cs;
  538. char tmp[64];
  539. u16 sub_vendor_id, sub_id;
  540. long flags;
  542. strcpy(tmp, Sedlbauer_revision);
  543. printk(KERN_INFO "HiSax: Sedlbauer driver Rev. %sn", HiSax_getrev(tmp));
  545.   if (cs->typ == ISDN_CTYPE_SEDLBAUER) {
  546.   cs->subtyp = SEDL_SPEED_CARD_WIN;
  547. cs->hw.sedl.bus = SEDL_BUS_ISA;
  548. cs->hw.sedl.chip = SEDL_CHIP_TEST;
  549.   } else if (cs->typ == ISDN_CTYPE_SEDLBAUER_PCMCIA) {
  550.   cs->subtyp = SEDL_SPEED_STAR;
  551. cs->hw.sedl.bus = SEDL_BUS_PCMCIA;
  552. cs->hw.sedl.chip = SEDL_CHIP_TEST;
  553.   } else if (cs->typ == ISDN_CTYPE_SEDLBAUER_FAX) {
  554.   cs->subtyp = SEDL_SPEED_FAX;
  555. cs->hw.sedl.bus = SEDL_BUS_ISA;
  556. cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
  557.   } else
  558. return (0);
  560. bytecnt = 8;
  561. if (card->para[1]) {
  562. cs->hw.sedl.cfg_reg = card->para[1];
  563. cs->irq = card->para[0];
  564. if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
  565. bytecnt = 16;
  566. }
  567. } else {
  568. /* Probe for Sedlbauer speed pci */
  569. #if CONFIG_PCI
  570. if (!pci_present()) {
  571. printk(KERN_ERR "Sedlbauer: no PCI bus presentn");
  572. return(0);
  573. }
  574. if ((dev_sedl = pci_find_device(PCI_VENDOR_ID_TIGERJET,
  575. PCI_DEVICE_ID_TIGERJET_100, dev_sedl))) {
  576. if (pci_enable_device(dev_sedl))
  577. return(0);
  578. cs->irq = dev_sedl->irq;
  579. if (!cs->irq) {
  580. printk(KERN_WARNING "Sedlbauer: No IRQ for PCI card foundn");
  581. return(0);
  582. }
  583. cs->hw.sedl.cfg_reg = pci_resource_start(dev_sedl, 0);
  584. } else {
  585. printk(KERN_WARNING "Sedlbauer: No PCI card foundn");
  586. return(0);
  587. }
  588. cs->irq_flags |= SA_SHIRQ;
  589. cs->hw.sedl.bus = SEDL_BUS_PCI;
  590. sub_vendor_id = dev_sedl->subsystem_vendor;
  591. sub_id = dev_sedl->subsystem_device;
  592. printk(KERN_INFO "Sedlbauer: PCI subvendor:%x subid %xn",
  593. sub_vendor_id, sub_id);
  594. printk(KERN_INFO "Sedlbauer: PCI base adr %#xn",
  595. cs->hw.sedl.cfg_reg);
  596. if (sub_id != PCI_SUB_ID_SEDLBAUER) {
  597. printk(KERN_ERR "Sedlbauer: unknown sub id %#xn", sub_id);
  598. return(0);
  599. }
  600. if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PYRAMID) {
  601. cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
  602. cs->subtyp = SEDL_SPEEDFAX_PYRAMID;
  603. } else if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PCI) {
  604. cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
  605. cs->subtyp = SEDL_SPEEDFAX_PCI;
  606. } else if (sub_vendor_id == PCI_SUBVENDOR_SEDLBAUER_PCI) {
  607. cs->hw.sedl.chip = SEDL_CHIP_IPAC;
  608. cs->subtyp = SEDL_SPEED_PCI;
  609. } else {
  610. printk(KERN_ERR "Sedlbauer: unknown sub vendor id %#xn",
  611. sub_vendor_id);
  612. return(0);
  613. }
  614. bytecnt = 256;
  615. cs->hw.sedl.reset_on = SEDL_ISAR_PCI_ISAR_RESET_ON;
  616. cs->hw.sedl.reset_off = SEDL_ISAR_PCI_ISAR_RESET_OFF;
  617. byteout(cs->hw.sedl.cfg_reg, 0xff);
  618. byteout(cs->hw.sedl.cfg_reg, 0x00);
  619. byteout(cs->hw.sedl.cfg_reg+ 2, 0xdd);
  620. byteout(cs->hw.sedl.cfg_reg+ 5, 0x02);
  621. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
  622. save_flags(flags);
  623. sti();
  624. current->state = TASK_UNINTERRUPTIBLE;
  625. schedule_timeout((10*HZ)/1000);
  626. byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
  627. restore_flags(flags);
  628. #else
  629. printk(KERN_WARNING "Sedlbauer: NO_PCI_BIOSn");
  630. return (0);
  631. #endif /* CONFIG_PCI */
  632. }
  634. /* In case of the sedlbauer pcmcia card, this region is in use,
  635.  * reserved for us by the card manager. So we do not check it
  636.  * here, it would fail.
  637.  */
  638. if (cs->hw.sedl.bus != SEDL_BUS_PCMCIA &&
  639. check_region((cs->hw.sedl.cfg_reg), bytecnt)) {
  640. printk(KERN_WARNING
  641. "HiSax: %s config port %x-%x already in usen",
  642. CardType[card->typ],
  643. cs->hw.sedl.cfg_reg,
  644. cs->hw.sedl.cfg_reg + bytecnt);
  645. return (0);
  646. } else {
  647. request_region(cs->hw.sedl.cfg_reg, bytecnt, "sedlbauer isdn");
  648. }
  650. printk(KERN_INFO
  651.        "Sedlbauer: defined at 0x%x-0x%x IRQ %dn",
  652.        cs->hw.sedl.cfg_reg,
  653.        cs->hw.sedl.cfg_reg + bytecnt,
  654.        cs->irq);
  656. cs->BC_Read_Reg = &ReadHSCX;
  657. cs->BC_Write_Reg = &WriteHSCX;
  658. cs->BC_Send_Data = &hscx_fill_fifo;
  659. cs->cardmsg = &Sedl_card_msg;
  661. /*
  662.  * testing ISA and PCMCIA Cards for IPAC, default is ISAC
  663.  * do not test for PCI card, because ports are different
  664.  * and PCI card uses only IPAC (for the moment)
  665.  */
  666. if (cs->hw.sedl.bus != SEDL_BUS_PCI) {
  667. val = readreg(cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_ADR,
  668. cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_IPAC, IPAC_ID);
  669. printk(KERN_DEBUG "Sedlbauer: testing IPAC version %xn", val);
  670.         if ((val == 1) || (val == 2)) {
  671. /* IPAC */
  672. cs->subtyp = SEDL_SPEED_WIN2_PC104;
  673. if (cs->hw.sedl.bus == SEDL_BUS_PCMCIA) {
  674. cs->subtyp = SEDL_SPEED_STAR2;
  675. }
  676. cs->hw.sedl.chip = SEDL_CHIP_IPAC;
  677. } else {
  678. /* ISAC_HSCX oder ISAC_ISAR */
  679. if (cs->hw.sedl.chip == SEDL_CHIP_TEST) {
  680. cs->hw.sedl.chip = SEDL_CHIP_ISAC_HSCX;
  681. }
  682. }
  683. }
  685. /*
  686.  * hw.sedl.chip is now properly set
  687.  */
  688. printk(KERN_INFO "Sedlbauer: %s detectedn",
  689. Sedlbauer_Types[cs->subtyp]);
  692. if (cs->hw.sedl.chip == SEDL_CHIP_IPAC) {
  693. if (cs->hw.sedl.bus == SEDL_BUS_PCI) {
  694.                 cs->hw.sedl.adr  = cs->hw.sedl.cfg_reg + SEDL_IPAC_PCI_ADR;
  695. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + SEDL_IPAC_PCI_IPAC;
  696. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + SEDL_IPAC_PCI_IPAC;
  697. } else {
  698.                 cs->hw.sedl.adr  = cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_ADR;
  699. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_IPAC;
  700. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_IPAC;
  701. }
  702. test_and_set_bit(HW_IPAC, &cs->HW_Flags);
  703. cs->readisac = &ReadISAC_IPAC;
  704. cs->writeisac = &WriteISAC_IPAC;
  705. cs->readisacfifo = &ReadISACfifo_IPAC;
  706. cs->writeisacfifo = &WriteISACfifo_IPAC;
  707. cs->irq_func = &sedlbauer_interrupt_ipac;
  709. val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_ID);
  710. printk(KERN_INFO "Sedlbauer: IPAC version %xn", val);
  711. reset_sedlbauer(cs);
  712. } else {
  713. /* ISAC_HSCX oder ISAC_ISAR */
  714. cs->readisac = &ReadISAC;
  715. cs->writeisac = &WriteISAC;
  716. cs->readisacfifo = &ReadISACfifo;
  717. cs->writeisacfifo = &WriteISACfifo;
  718. if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
  719. if (cs->hw.sedl.bus == SEDL_BUS_PCI) {
  720. cs->hw.sedl.adr = cs->hw.sedl.cfg_reg +
  721. SEDL_ISAR_PCI_ADR;
  722. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg +
  723. SEDL_ISAR_PCI_ISAC;
  724. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg +
  725. SEDL_ISAR_PCI_ISAR;
  726. } else {
  727. cs->hw.sedl.adr = cs->hw.sedl.cfg_reg +
  728. SEDL_ISAR_ISA_ADR;
  729. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg +
  730. SEDL_ISAR_ISA_ISAC;
  731. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg +
  732. SEDL_ISAR_ISA_ISAR;
  733. cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg +
  734. SEDL_ISAR_ISA_ISAR_RESET_ON;
  735. cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg +
  736. SEDL_ISAR_ISA_ISAR_RESET_OFF;
  737. }
  738. cs->bcs[0].hw.isar.reg = &cs->hw.sedl.isar;
  739. cs->bcs[1].hw.isar.reg = &cs->hw.sedl.isar;
  740. test_and_set_bit(HW_ISAR, &cs->HW_Flags);
  741. cs->irq_func = &sedlbauer_interrupt_isar;
  742. cs->auxcmd = &isar_auxcmd;
  743. ISACVersion(cs, "Sedlbauer:");
  744. cs->BC_Read_Reg = &ReadISAR;
  745. cs->BC_Write_Reg = &WriteISAR;
  746. cs->BC_Send_Data = &isar_fill_fifo;
  747. ver = ISARVersion(cs, "Sedlbauer:");
  748. if (ver < 0) {
  749. printk(KERN_WARNING
  750. "Sedlbauer: wrong ISAR version (ret = %d)n", ver);
  751. release_io_sedlbauer(cs);
  752. return (0);
  753. }
  754. } else {
  755. if (cs->hw.sedl.bus == SEDL_BUS_PCMCIA) {
  756. cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + SEDL_HSCX_PCMCIA_ADR;
  757. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + SEDL_HSCX_PCMCIA_ISAC;
  758. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + SEDL_HSCX_PCMCIA_HSCX;
  759. cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg + SEDL_HSCX_PCMCIA_RESET;
  760. cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg + SEDL_HSCX_PCMCIA_RESET;
  761. } else {
  762. cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + SEDL_HSCX_ISA_ADR;
  763. cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + SEDL_HSCX_ISA_ISAC;
  764. cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + SEDL_HSCX_ISA_HSCX;
  765. cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg + SEDL_HSCX_ISA_RESET_ON;
  766. cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg + SEDL_HSCX_ISA_RESET_OFF;
  767. }
  768. cs->irq_func = &sedlbauer_interrupt;
  769. ISACVersion(cs, "Sedlbauer:");
  771. if (HscxVersion(cs, "Sedlbauer:")) {
  772. printk(KERN_WARNING
  773. "Sedlbauer: wrong HSCX versions check IO addressn");
  774. release_io_sedlbauer(cs);
  775. return (0);
  776. }
  777. reset_sedlbauer(cs);
  778. }
  779. }
  780. return (1);
  781. }