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

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

嵌入式Linux

开发平台：

Unix_Linux

w6692.c：源码内容
  1. /* $Id: w6692.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * Winbond W6692 specific routines
  4.  *
  5.  * Author       Petr Novak
  6.  * Copyright    by Petr Novak        <petr.novak@i.cz>
  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.  */
  13. #include <linux/config.h>
  14. #include <linux/init.h>
  15. #define __NO_VERSION__
  16. #include "hisax.h"
  17. #include "w6692.h"
  18. #include "isdnl1.h"
  19. #include <linux/interrupt.h>
  20. #include <linux/pci.h>
  22. /* table entry in the PCI devices list */
  23. typedef struct {
  24. int vendor_id;
  25. int device_id;
  26. char *vendor_name;
  27. char *card_name;
  28. } PCI_ENTRY;
  30. static const PCI_ENTRY id_list[] =
  31. {
  32. {PCI_VENDOR_ID_DYNALINK, PCI_DEVICE_ID_DYNALINK_IS64PH, "Dynalink/AsusCom", "IS64PH"},
  33. {PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_6692, "Winbond", "W6692"},
  34. {0, 0, NULL, NULL}
  35. };
  37. extern const char *CardType[];
  39. const char *w6692_revision = "$Revision: 1.1.4.1 $";
  41. #define DBUSY_TIMER_VALUE 80
  43. static char *W6692Ver[] __initdata =
  44. {"W6692 V00", "W6692 V01", "W6692 V10",
  45.  "W6692 V11"};
  47. static void
  48. W6692Version(struct IsdnCardState *cs, char *s)
  49. {
  50. int val;
  52. val = cs->readW6692(cs, W_D_RBCH);
  53. printk(KERN_INFO "%s Winbond W6692 version (%x): %sn", s, val, W6692Ver[(val >> 6) & 3]);
  54. }
  56. static void
  57. ph_command(struct IsdnCardState *cs, unsigned int command)
  58. {
  59. if (cs->debug & L1_DEB_ISAC)
  60. debugl1(cs, "ph_command %x", command);
  61. cs->writeisac(cs, W_CIX, command);
  62. }
  65. static void
  66. W6692_new_ph(struct IsdnCardState *cs)
  67. {
  68. switch (cs->dc.w6692.ph_state) {
  69. case (W_L1CMD_RST):
  70. ph_command(cs, W_L1CMD_DRC);
  71. l1_msg(cs, HW_RESET | INDICATION, NULL);
  72. /* fallthru */
  73. case (W_L1IND_CD):
  74. l1_msg(cs, HW_DEACTIVATE | CONFIRM, NULL);
  75. break;
  76. case (W_L1IND_DRD):
  77. l1_msg(cs, HW_DEACTIVATE | INDICATION, NULL);
  78. break;
  79. case (W_L1IND_CE):
  80. l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
  81. break;
  82. case (W_L1IND_LD):
  83. l1_msg(cs, HW_RSYNC | INDICATION, NULL);
  84. break;
  85. case (W_L1IND_ARD):
  86. l1_msg(cs, HW_INFO2 | INDICATION, NULL);
  87. break;
  88. case (W_L1IND_AI8):
  89. l1_msg(cs, HW_INFO4_P8 | INDICATION, NULL);
  90. break;
  91. case (W_L1IND_AI10):
  92. l1_msg(cs, HW_INFO4_P10 | INDICATION, NULL);
  93. break;
  94. default:
  95. break;
  96. }
  97. }
  99. static void
  100. W6692_bh(struct IsdnCardState *cs)
  101. {
  102. struct PStack *stptr;
  104. if (!cs)
  105. return;
  106. if (test_and_clear_bit(D_CLEARBUSY, &cs->event)) {
  107. if (cs->debug)
  108. debugl1(cs, "D-Channel Busy cleared");
  109. stptr = cs->stlist;
  110. while (stptr != NULL) {
  111. stptr->l1.l1l2(stptr, PH_PAUSE | CONFIRM, NULL);
  112. stptr = stptr->next;
  113. }
  114. }
  115. if (test_and_clear_bit(D_L1STATECHANGE, &cs->event))
  116. W6692_new_ph(cs);
  117. if (test_and_clear_bit(D_RCVBUFREADY, &cs->event))
  118. DChannel_proc_rcv(cs);
  119. if (test_and_clear_bit(D_XMTBUFREADY, &cs->event))
  120. DChannel_proc_xmt(cs);
  121. /*
  122.    if (test_and_clear_bit(D_RX_MON1, &cs->event))
  123.    arcofi_fsm(cs, ARCOFI_RX_END, NULL);
  124.    if (test_and_clear_bit(D_TX_MON1, &cs->event))
  125.    arcofi_fsm(cs, ARCOFI_TX_END, NULL);
  126.  */
  127. }
  129. void
  130. W6692_sched_event(struct IsdnCardState *cs, int event)
  131. {
  132. test_and_set_bit(event, &cs->event);
  133. queue_task(&cs->tqueue, &tq_immediate);
  134. mark_bh(IMMEDIATE_BH);
  135. }
  137. static void
  138. W6692B_sched_event(struct BCState *bcs, int event)
  139. {
  140. bcs->event |= 1 << event;
  141. queue_task(&bcs->tqueue, &tq_immediate);
  142. mark_bh(IMMEDIATE_BH);
  143. }
  145. static void
  146. W6692_empty_fifo(struct IsdnCardState *cs, int count)
  147. {
  148. u_char *ptr;
  149. long flags;
  151. if ((cs->debug & L1_DEB_ISAC) && !(cs->debug & L1_DEB_ISAC_FIFO))
  152. debugl1(cs, "W6692_empty_fifo");
  154. if ((cs->rcvidx + count) >= MAX_DFRAME_LEN_L1) {
  155. if (cs->debug & L1_DEB_WARN)
  156. debugl1(cs, "W6692_empty_fifo overrun %d",
  157. cs->rcvidx + count);
  158. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RACK);
  159. cs->rcvidx = 0;
  160. return;
  161. }
  162. ptr = cs->rcvbuf + cs->rcvidx;
  163. cs->rcvidx += count;
  164. save_flags(flags);
  165. cli();
  166. cs->readW6692fifo(cs, ptr, count);
  167. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RACK);
  168. restore_flags(flags);
  169. if (cs->debug & L1_DEB_ISAC_FIFO) {
  170. char *t = cs->dlog;
  172. t += sprintf(t, "W6692_empty_fifo cnt %d", count);
  173. QuickHex(t, ptr, count);
  174. debugl1(cs, cs->dlog);
  175. }
  176. }
  178. static void
  179. W6692_fill_fifo(struct IsdnCardState *cs)
  180. {
  181. int count, more;
  182. u_char *ptr;
  183. long flags;
  185. if ((cs->debug & L1_DEB_ISAC) && !(cs->debug & L1_DEB_ISAC_FIFO))
  186. debugl1(cs, "W6692_fill_fifo");
  188. if (!cs->tx_skb)
  189. return;
  191. count = cs->tx_skb->len;
  192. if (count <= 0)
  193. return;
  195. more = 0;
  196. if (count > W_D_FIFO_THRESH) {
  197. more = !0;
  198. count = W_D_FIFO_THRESH;
  199. }
  200. save_flags(flags);
  201. cli();
  202. ptr = cs->tx_skb->data;
  203. skb_pull(cs->tx_skb, count);
  204. cs->tx_cnt += count;
  205. cs->writeW6692fifo(cs, ptr, count);
  206. cs->writeW6692(cs, W_D_CMDR, more ? W_D_CMDR_XMS : (W_D_CMDR_XMS | W_D_CMDR_XME));
  207. restore_flags(flags);
  208. if (test_and_set_bit(FLG_DBUSY_TIMER, &cs->HW_Flags)) {
  209. debugl1(cs, "W6692_fill_fifo dbusytimer running");
  210. del_timer(&cs->dbusytimer);
  211. }
  212. init_timer(&cs->dbusytimer);
  213. cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
  214. add_timer(&cs->dbusytimer);
  215. if (cs->debug & L1_DEB_ISAC_FIFO) {
  216. char *t = cs->dlog;
  218. t += sprintf(t, "W6692_fill_fifo cnt %d", count);
  219. QuickHex(t, ptr, count);
  220. debugl1(cs, cs->dlog);
  221. }
  222. }
  224. static void
  225. W6692B_empty_fifo(struct BCState *bcs, int count)
  226. {
  227. u_char *ptr;
  228. struct IsdnCardState *cs = bcs->cs;
  229. long flags;
  231. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  232. debugl1(cs, "W6692B_empty_fifo");
  234. if (bcs->hw.w6692.rcvidx + count > HSCX_BUFMAX) {
  235. if (cs->debug & L1_DEB_WARN)
  236. debugl1(cs, "W6692B_empty_fifo: incoming packet too large");
  237. cs->BC_Write_Reg(cs, bcs->channel, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
  238. bcs->hw.w6692.rcvidx = 0;
  239. return;
  240. }
  241. ptr = bcs->hw.w6692.rcvbuf + bcs->hw.w6692.rcvidx;
  242. bcs->hw.w6692.rcvidx += count;
  243. save_flags(flags);
  244. cli();
  245. READW6692BFIFO(cs, bcs->channel, ptr, count);
  246. cs->BC_Write_Reg(cs, bcs->channel, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
  247. restore_flags(flags);
  248. if (cs->debug & L1_DEB_HSCX_FIFO) {
  249. char *t = bcs->blog;
  251. t += sprintf(t, "W6692B_empty_fifo %c cnt %d",
  252.      bcs->channel + '1', count);
  253. QuickHex(t, ptr, count);
  254. debugl1(cs, bcs->blog);
  255. }
  256. }
  258. static void
  259. W6692B_fill_fifo(struct BCState *bcs)
  260. {
  261. struct IsdnCardState *cs = bcs->cs;
  262. int more, count;
  263. u_char *ptr;
  264. long flags;
  267. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  268. debugl1(cs, "W6692B_fill_fifo");
  270. if (!bcs->tx_skb)
  271. return;
  272. if (bcs->tx_skb->len <= 0)
  273. return;
  275. more = (bcs->mode == L1_MODE_TRANS) ? 1 : 0;
  276. if (bcs->tx_skb->len > W_B_FIFO_THRESH) {
  277. more = !0;
  278. count = W_B_FIFO_THRESH;
  279. } else
  280. count = bcs->tx_skb->len;
  282. save_flags(flags);
  283. cli();
  284. ptr = bcs->tx_skb->data;
  285. skb_pull(bcs->tx_skb, count);
  286. bcs->tx_cnt -= count;
  287. bcs->hw.w6692.count += count;
  288. WRITEW6692BFIFO(cs, bcs->channel, ptr, count);
  289. cs->BC_Write_Reg(cs, bcs->channel, W_B_CMDR, W_B_CMDR_RACT | W_B_CMDR_XMS | (more ? 0 : W_B_CMDR_XME));
  290. restore_flags(flags);
  291. if (cs->debug & L1_DEB_HSCX_FIFO) {
  292. char *t = bcs->blog;
  294. t += sprintf(t, "W6692B_fill_fifo %c cnt %d",
  295.      bcs->channel + '1', count);
  296. QuickHex(t, ptr, count);
  297. debugl1(cs, bcs->blog);
  298. }
  299. }
  301. static void
  302. W6692B_interrupt(struct IsdnCardState *cs, u_char bchan)
  303. {
  304. u_char val;
  305. u_char r;
  306. struct BCState *bcs;
  307. struct sk_buff *skb;
  308. int count;
  310. bcs = (cs->bcs->channel == bchan) ? cs->bcs : (cs->bcs+1);
  311. val = cs->BC_Read_Reg(cs, bchan, W_B_EXIR);
  312. debugl1(cs, "W6692B chan %d B_EXIR 0x%02X", bchan, val);
  314. if (!test_bit(BC_FLG_INIT, &bcs->Flag)) {
  315. debugl1(cs, "W6692B not INIT yet");
  316. return;
  317. }
  318. if (val & W_B_EXI_RME) { /* RME */
  319. r = cs->BC_Read_Reg(cs, bchan, W_B_STAR);
  320. if (r & (W_B_STAR_RDOV | W_B_STAR_CRCE | W_B_STAR_RMB | W_B_STAR_XDOW)) {
  321. if ((r & W_B_STAR_RDOV) && bcs->mode)
  322. if (cs->debug & L1_DEB_WARN)
  323. debugl1(cs, "W6692 B RDOV mode=%d",
  324. bcs->mode);
  325. if (r & W_B_STAR_CRCE)
  326. if (cs->debug & L1_DEB_WARN)
  327. debugl1(cs, "W6692 B CRC error");
  328. cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RRST | W_B_CMDR_RACT);
  329. } else {
  330. count = cs->BC_Read_Reg(cs, bchan, W_B_RBCL) & (W_B_FIFO_THRESH - 1);
  331. if (count == 0)
  332. count = W_B_FIFO_THRESH;
  333. W6692B_empty_fifo(bcs, count);
  334. if ((count = bcs->hw.w6692.rcvidx) > 0) {
  335. if (cs->debug & L1_DEB_HSCX_FIFO)
  336. debugl1(cs, "W6692 Bchan Frame %d", count);
  337. if (!(skb = dev_alloc_skb(count)))
  338. printk(KERN_WARNING "W6692: Bchan receive out of memoryn");
  339. else {
  340. memcpy(skb_put(skb, count), bcs->hw.w6692.rcvbuf, count);
  341. skb_queue_tail(&bcs->rqueue, skb);
  342. }
  343. }
  344. }
  345. bcs->hw.w6692.rcvidx = 0;
  346. W6692B_sched_event(bcs, B_RCVBUFREADY);
  347. }
  348. if (val & W_B_EXI_RMR) { /* RMR */
  349. W6692B_empty_fifo(bcs, W_B_FIFO_THRESH);
  350. if (bcs->mode == L1_MODE_TRANS) {
  351. /* receive audio data */
  352. if (!(skb = dev_alloc_skb(W_B_FIFO_THRESH)))
  353. printk(KERN_WARNING "HiSax: receive out of memoryn");
  354. else {
  355. memcpy(skb_put(skb, W_B_FIFO_THRESH), bcs->hw.w6692.rcvbuf, W_B_FIFO_THRESH);
  356. skb_queue_tail(&bcs->rqueue, skb);
  357. }
  358. bcs->hw.w6692.rcvidx = 0;
  359. W6692B_sched_event(bcs, B_RCVBUFREADY);
  360. }
  361. }
  362. if (val & W_B_EXI_XFR) { /* XFR */
  363. if (bcs->tx_skb) {
  364. if (bcs->tx_skb->len) {
  365. W6692B_fill_fifo(bcs);
  366. return;
  367. } else {
  368. if (bcs->st->lli.l1writewakeup &&
  369.  (PACKET_NOACK != bcs->tx_skb->pkt_type))
  370. bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.w6692.count);
  371. dev_kfree_skb_irq(bcs->tx_skb);
  372. bcs->hw.w6692.count = 0;
  373. bcs->tx_skb = NULL;
  374. }
  375. }
  376. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  377. bcs->hw.w6692.count = 0;
  378. test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
  379. W6692B_fill_fifo(bcs);
  380. } else {
  381. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  382. W6692B_sched_event(bcs, B_XMTBUFREADY);
  383. }
  384. }
  385. if (val & W_B_EXI_XDUN) { /* XDUN */
  386. if (bcs->mode == 1)
  387. W6692B_fill_fifo(bcs);
  388. else {
  389. /* Here we lost an TX interrupt, so
  390.    * restart transmitting the whole frame.
  391.  */
  392. if (bcs->tx_skb) {
  393. skb_push(bcs->tx_skb, bcs->hw.w6692.count);
  394. bcs->tx_cnt += bcs->hw.w6692.count;
  395. bcs->hw.w6692.count = 0;
  396. }
  397. cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_XRST | W_B_CMDR_RACT);
  398. if (cs->debug & L1_DEB_WARN)
  399. debugl1(cs, "W6692 B EXIR %x Lost TX", val);
  400. }
  401. }
  402. }
  404. static void
  405. W6692_interrupt(int intno, void *dev_id, struct pt_regs *regs)
  406. {
  407. struct IsdnCardState *cs = dev_id;
  408. u_char val, exval, v1;
  409. struct sk_buff *skb;
  410. unsigned int count;
  411. long flags;
  412. int icnt = 5;
  414. if (!cs) {
  415. printk(KERN_WARNING "W6692: Spurious interrupt!n");
  416. return;
  417. }
  418. val = cs->readW6692(cs, W_ISTA);
  420.       StartW6692:
  421. if (cs->debug & L1_DEB_ISAC)
  422. debugl1(cs, "W6692 ISTA %x", val);
  424. if (val & W_INT_D_RME) { /* RME */
  425. exval = cs->readW6692(cs, W_D_RSTA);
  426. if (exval & (W_D_RSTA_RDOV | W_D_RSTA_CRCE | W_D_RSTA_RMB)) {
  427. if (exval & W_D_RSTA_RDOV)
  428. if (cs->debug & L1_DEB_WARN)
  429. debugl1(cs, "W6692 RDOV");
  430. if (exval & W_D_RSTA_CRCE)
  431. if (cs->debug & L1_DEB_WARN)
  432. debugl1(cs, "W6692 D-channel CRC error");
  433. if (exval & W_D_RSTA_RMB)
  434. if (cs->debug & L1_DEB_WARN)
  435. debugl1(cs, "W6692 D-channel ABORT");
  436. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RACK | W_D_CMDR_RRST);
  437. } else {
  438. count = cs->readW6692(cs, W_D_RBCL) & (W_D_FIFO_THRESH - 1);
  439. if (count == 0)
  440. count = W_D_FIFO_THRESH;
  441. W6692_empty_fifo(cs, count);
  442. save_flags(flags);
  443. cli();
  444. if ((count = cs->rcvidx) > 0) {
  445. cs->rcvidx = 0;
  446. if (!(skb = alloc_skb(count, GFP_ATOMIC)))
  447. printk(KERN_WARNING "HiSax: D receive out of memoryn");
  448. else {
  449. memcpy(skb_put(skb, count), cs->rcvbuf, count);
  450. skb_queue_tail(&cs->rq, skb);
  451. }
  452. }
  453. restore_flags(flags);
  454. }
  455. cs->rcvidx = 0;
  456. W6692_sched_event(cs, D_RCVBUFREADY);
  457. }
  458. if (val & W_INT_D_RMR) { /* RMR */
  459. W6692_empty_fifo(cs, W_D_FIFO_THRESH);
  460. }
  461. if (val & W_INT_D_XFR) { /* XFR */
  462. if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
  463. del_timer(&cs->dbusytimer);
  464. if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
  465. W6692_sched_event(cs, D_CLEARBUSY);
  466. if (cs->tx_skb) {
  467. if (cs->tx_skb->len) {
  468. W6692_fill_fifo(cs);
  469. goto afterXFR;
  470. } else {
  471. dev_kfree_skb_irq(cs->tx_skb);
  472. cs->tx_cnt = 0;
  473. cs->tx_skb = NULL;
  474. }
  475. }
  476. if ((cs->tx_skb = skb_dequeue(&cs->sq))) {
  477. cs->tx_cnt = 0;
  478. W6692_fill_fifo(cs);
  479. } else
  480. W6692_sched_event(cs, D_XMTBUFREADY);
  481. }
  482.       afterXFR:
  483. if (val & (W_INT_XINT0 | W_INT_XINT1)) { /* XINT0/1 - never */
  484. if (cs->debug & L1_DEB_ISAC)
  485. debugl1(cs, "W6692 spurious XINT!");
  486. }
  487. if (val & W_INT_D_EXI) { /* EXI */
  488. exval = cs->readW6692(cs, W_D_EXIR);
  489. if (cs->debug & L1_DEB_WARN)
  490. debugl1(cs, "W6692 D_EXIR %02x", exval);
  491. if (exval & (W_D_EXI_XDUN | W_D_EXI_XCOL)) { /* Transmit underrun/collision */
  492. debugl1(cs, "W6692 D-chan underrun/collision");
  493. printk(KERN_WARNING "HiSax: W6692 XDUN/XCOLn");
  494. if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
  495. del_timer(&cs->dbusytimer);
  496. if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
  497. W6692_sched_event(cs, D_CLEARBUSY);
  498. if (cs->tx_skb) { /* Restart frame */
  499. skb_push(cs->tx_skb, cs->tx_cnt);
  500. cs->tx_cnt = 0;
  501. W6692_fill_fifo(cs);
  502. } else {
  503. printk(KERN_WARNING "HiSax: W6692 XDUN/XCOL no skbn");
  504. debugl1(cs, "W6692 XDUN/XCOL no skb");
  505. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_XRST);
  506. }
  507. }
  508. if (exval & W_D_EXI_RDOV) { /* RDOV */
  509. debugl1(cs, "W6692 D-channel RDOV");
  510. printk(KERN_WARNING "HiSax: W6692 D-RDOVn");
  511. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RRST);
  512. }
  513. if (exval & W_D_EXI_TIN2) { /* TIN2 - never */
  514. debugl1(cs, "W6692 spurious TIN2 interrupt");
  515. }
  516. if (exval & W_D_EXI_MOC) { /* MOC - not supported */
  517. debugl1(cs, "W6692 spurious MOC interrupt");
  518. v1 = cs->readW6692(cs, W_MOSR);
  519. debugl1(cs, "W6692 MOSR %02x", v1);
  520. }
  521. if (exval & W_D_EXI_ISC) { /* ISC - Level1 change */
  522. v1 = cs->readW6692(cs, W_CIR);
  523. if (cs->debug & L1_DEB_ISAC)
  524. debugl1(cs, "W6692 ISC CIR=0x%02X", v1);
  525. if (v1 & W_CIR_ICC) {
  526. cs->dc.w6692.ph_state = v1 & W_CIR_COD_MASK;
  527. if (cs->debug & L1_DEB_ISAC)
  528. debugl1(cs, "ph_state_change %x", cs->dc.w6692.ph_state);
  529. W6692_sched_event(cs, D_L1STATECHANGE);
  530. }
  531. if (v1 & W_CIR_SCC) {
  532. v1 = cs->readW6692(cs, W_SQR);
  533. debugl1(cs, "W6692 SCC SQR=0x%02X", v1);
  534. }
  535. }
  536. if (exval & W_D_EXI_WEXP) {
  537. debugl1(cs, "W6692 spurious WEXP interrupt!");
  538. }
  539. if (exval & W_D_EXI_TEXP) {
  540. debugl1(cs, "W6692 spurious TEXP interrupt!");
  541. }
  542. }
  543. if (val & W_INT_B1_EXI) {
  544. debugl1(cs, "W6692 B channel 1 interrupt");
  545. W6692B_interrupt(cs, 0);
  546. }
  547. if (val & W_INT_B2_EXI) {
  548. debugl1(cs, "W6692 B channel 2 interrupt");
  549. W6692B_interrupt(cs, 1);
  550. }
  551. val = cs->readW6692(cs, W_ISTA);
  552. if (val && icnt) {
  553. icnt--;
  554. goto StartW6692;
  555. }
  556. if (!icnt) {
  557. printk(KERN_WARNING "W6692 IRQ LOOPn");
  558. cs->writeW6692(cs, W_IMASK, 0xff);
  559. }
  560. }
  562. static void
  563. W6692_l1hw(struct PStack *st, int pr, void *arg)
  564. {
  565. struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
  566. struct sk_buff *skb = arg;
  567. int val;
  569. switch (pr) {
  570. case (PH_DATA | REQUEST):
  571. if (cs->debug & DEB_DLOG_HEX)
  572. LogFrame(cs, skb->data, skb->len);
  573. if (cs->debug & DEB_DLOG_VERBOSE)
  574. dlogframe(cs, skb, 0);
  575. if (cs->tx_skb) {
  576. skb_queue_tail(&cs->sq, skb);
  577. #ifdef L2FRAME_DEBUG /* psa */
  578. if (cs->debug & L1_DEB_LAPD)
  579. Logl2Frame(cs, skb, "PH_DATA Queued", 0);
  580. #endif
  581. } else {
  582. cs->tx_skb = skb;
  583. cs->tx_cnt = 0;
  584. #ifdef L2FRAME_DEBUG /* psa */
  585. if (cs->debug & L1_DEB_LAPD)
  586. Logl2Frame(cs, skb, "PH_DATA", 0);
  587. #endif
  588. W6692_fill_fifo(cs);
  589. }
  590. break;
  591. case (PH_PULL | INDICATION):
  592. if (cs->tx_skb) {
  593. if (cs->debug & L1_DEB_WARN)
  594. debugl1(cs, " l2l1 tx_skb exist this shouldn't happen");
  595. skb_queue_tail(&cs->sq, skb);
  596. break;
  597. }
  598. if (cs->debug & DEB_DLOG_HEX)
  599. LogFrame(cs, skb->data, skb->len);
  600. if (cs->debug & DEB_DLOG_VERBOSE)
  601. dlogframe(cs, skb, 0);
  602. cs->tx_skb = skb;
  603. cs->tx_cnt = 0;
  604. #ifdef L2FRAME_DEBUG /* psa */
  605. if (cs->debug & L1_DEB_LAPD)
  606. Logl2Frame(cs, skb, "PH_DATA_PULLED", 0);
  607. #endif
  608. W6692_fill_fifo(cs);
  609. break;
  610. case (PH_PULL | REQUEST):
  611. #ifdef L2FRAME_DEBUG /* psa */
  612. if (cs->debug & L1_DEB_LAPD)
  613. debugl1(cs, "-> PH_REQUEST_PULL");
  614. #endif
  615. if (!cs->tx_skb) {
  616. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  617. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  618. } else
  619. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  620. break;
  621. case (HW_RESET | REQUEST):
  622. if ((cs->dc.w6692.ph_state == W_L1IND_DRD))
  623. ph_command(cs, W_L1CMD_ECK);
  624. else {
  625. ph_command(cs, W_L1CMD_RST);
  626. cs->dc.w6692.ph_state = W_L1CMD_RST;
  627. W6692_new_ph(cs);
  628. }
  629. break;
  630. case (HW_ENABLE | REQUEST):
  631. ph_command(cs, W_L1CMD_ECK);
  632. break;
  633. case (HW_INFO3 | REQUEST):
  634. ph_command(cs, W_L1CMD_AR8);
  635. break;
  636. case (HW_TESTLOOP | REQUEST):
  637. val = 0;
  638. if (1 & (long) arg)
  639. val |= 0x0c;
  640. if (2 & (long) arg)
  641. val |= 0x3;
  642. /* !!! not implemented yet */
  643. break;
  644. case (HW_DEACTIVATE | RESPONSE):
  645. skb_queue_purge(&cs->rq);
  646. skb_queue_purge(&cs->sq);
  647. if (cs->tx_skb) {
  648. dev_kfree_skb_any(cs->tx_skb);
  649. cs->tx_skb = NULL;
  650. }
  651. if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
  652. del_timer(&cs->dbusytimer);
  653. if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
  654. W6692_sched_event(cs, D_CLEARBUSY);
  655. break;
  656. default:
  657. if (cs->debug & L1_DEB_WARN)
  658. debugl1(cs, "W6692_l1hw unknown %04x", pr);
  659. break;
  660. }
  661. }
  663. static void
  664. setstack_W6692(struct PStack *st, struct IsdnCardState *cs)
  665. {
  666. st->l1.l1hw = W6692_l1hw;
  667. }
  669. static void
  670. DC_Close_W6692(struct IsdnCardState *cs)
  671. {
  672. }
  674. static void
  675. dbusy_timer_handler(struct IsdnCardState *cs)
  676. {
  677. struct PStack *stptr;
  678. int rbch, star;
  680. if (test_bit(FLG_DBUSY_TIMER, &cs->HW_Flags)) {
  681. rbch = cs->readW6692(cs, W_D_RBCH);
  682. star = cs->readW6692(cs, W_D_STAR);
  683. if (cs->debug)
  684. debugl1(cs, "D-Channel Busy D_RBCH %02x D_STAR %02x",
  685. rbch, star);
  686. if (star & W_D_STAR_XBZ) { /* D-Channel Busy */
  687. test_and_set_bit(FLG_L1_DBUSY, &cs->HW_Flags);
  688. stptr = cs->stlist;
  689. while (stptr != NULL) {
  690. stptr->l1.l1l2(stptr, PH_PAUSE | INDICATION, NULL);
  691. stptr = stptr->next;
  692. }
  693. } else {
  694. /* discard frame; reset transceiver */
  695. test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags);
  696. if (cs->tx_skb) {
  697. dev_kfree_skb_any(cs->tx_skb);
  698. cs->tx_cnt = 0;
  699. cs->tx_skb = NULL;
  700. } else {
  701. printk(KERN_WARNING "HiSax: W6692 D-Channel Busy no skbn");
  702. debugl1(cs, "D-Channel Busy no skb");
  703. }
  704. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_XRST); /* Transmitter reset */
  705. cs->irq_func(cs->irq, cs, NULL);
  706. }
  707. }
  708. }
  710. static void
  711. W6692Bmode(struct BCState *bcs, int mode, int bchan)
  712. {
  713. struct IsdnCardState *cs = bcs->cs;
  715. if (cs->debug & L1_DEB_HSCX)
  716. debugl1(cs, "w6692 %c mode %d ichan %d",
  717. '1' + bchan, mode, bchan);
  718. bcs->mode = mode;
  719. bcs->channel = bchan;
  720. bcs->hw.w6692.bchan = bchan;
  722. switch (mode) {
  723. case (L1_MODE_NULL):
  724. cs->BC_Write_Reg(cs, bchan, W_B_MODE, 0);
  725. break;
  726. case (L1_MODE_TRANS):
  727. cs->BC_Write_Reg(cs, bchan, W_B_MODE, W_B_MODE_MMS);
  728. break;
  729. case (L1_MODE_HDLC):
  730. cs->BC_Write_Reg(cs, bchan, W_B_MODE, W_B_MODE_ITF);
  731. cs->BC_Write_Reg(cs, bchan, W_B_ADM1, 0xff);
  732. cs->BC_Write_Reg(cs, bchan, W_B_ADM2, 0xff);
  733. break;
  734. }
  735. if (mode)
  736. cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_RRST |
  737.  W_B_CMDR_RACT | W_B_CMDR_XRST);
  738. cs->BC_Write_Reg(cs, bchan, W_B_EXIM, 0x00);
  739. }
  741. static void
  742. W6692_l2l1(struct PStack *st, int pr, void *arg)
  743. {
  744. struct sk_buff *skb = arg;
  745. long flags;
  747. switch (pr) {
  748. case (PH_DATA | REQUEST):
  749. save_flags(flags);
  750. cli();
  751. if (st->l1.bcs->tx_skb) {
  752. skb_queue_tail(&st->l1.bcs->squeue, skb);
  753. restore_flags(flags);
  754. } else {
  755. st->l1.bcs->tx_skb = skb;
  756. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  757. st->l1.bcs->hw.w6692.count = 0;
  758. restore_flags(flags);
  759. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  760. }
  761. break;
  762. case (PH_PULL | INDICATION):
  763. if (st->l1.bcs->tx_skb) {
  764. printk(KERN_WARNING "W6692_l2l1: this shouldn't happenn");
  765. break;
  766. }
  767. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  768. st->l1.bcs->tx_skb = skb;
  769. st->l1.bcs->hw.w6692.count = 0;
  770. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  771. break;
  772. case (PH_PULL | REQUEST):
  773. if (!st->l1.bcs->tx_skb) {
  774. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  775. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  776. } else
  777. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  778. break;
  779. case (PH_ACTIVATE | REQUEST):
  780. test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  781. W6692Bmode(st->l1.bcs, st->l1.mode, st->l1.bc);
  782. l1_msg_b(st, pr, arg);
  783. break;
  784. case (PH_DEACTIVATE | REQUEST):
  785. l1_msg_b(st, pr, arg);
  786. break;
  787. case (PH_DEACTIVATE | CONFIRM):
  788. test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  789. test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  790. W6692Bmode(st->l1.bcs, 0, st->l1.bc);
  791. st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
  792. break;
  793. }
  794. }
  796. static void
  797. close_w6692state(struct BCState *bcs)
  798. {
  799. W6692Bmode(bcs, 0, bcs->channel);
  800. if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
  801. if (bcs->hw.w6692.rcvbuf) {
  802. kfree(bcs->hw.w6692.rcvbuf);
  803. bcs->hw.w6692.rcvbuf = NULL;
  804. }
  805. if (bcs->blog) {
  806. kfree(bcs->blog);
  807. bcs->blog = NULL;
  808. }
  809. skb_queue_purge(&bcs->rqueue);
  810. skb_queue_purge(&bcs->squeue);
  811. if (bcs->tx_skb) {
  812. dev_kfree_skb_any(bcs->tx_skb);
  813. bcs->tx_skb = NULL;
  814. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  815. }
  816. }
  817. }
  819. static int
  820. open_w6692state(struct IsdnCardState *cs, struct BCState *bcs)
  821. {
  822. if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
  823. if (!(bcs->hw.w6692.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
  824. printk(KERN_WARNING
  825.        "HiSax: No memory for w6692.rcvbufn");
  826. test_and_clear_bit(BC_FLG_INIT, &bcs->Flag);
  827. return (1);
  828. }
  829. if (!(bcs->blog = kmalloc(MAX_BLOG_SPACE, GFP_ATOMIC))) {
  830. printk(KERN_WARNING
  831.        "HiSax: No memory for bcs->blogn");
  832. test_and_clear_bit(BC_FLG_INIT, &bcs->Flag);
  833. kfree(bcs->hw.w6692.rcvbuf);
  834. bcs->hw.w6692.rcvbuf = NULL;
  835. return (2);
  836. }
  837. skb_queue_head_init(&bcs->rqueue);
  838. skb_queue_head_init(&bcs->squeue);
  839. }
  840. bcs->tx_skb = NULL;
  841. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  842. bcs->event = 0;
  843. bcs->hw.w6692.rcvidx = 0;
  844. bcs->tx_cnt = 0;
  845. return (0);
  846. }
  848. static int
  849. setstack_w6692(struct PStack *st, struct BCState *bcs)
  850. {
  851. bcs->channel = st->l1.bc;
  852. if (open_w6692state(st->l1.hardware, bcs))
  853. return (-1);
  854. st->l1.bcs = bcs;
  855. st->l2.l2l1 = W6692_l2l1;
  856. setstack_manager(st);
  857. bcs->st = st;
  858. setstack_l1_B(st);
  859. return (0);
  860. }
  862. void __init initW6692(struct IsdnCardState *cs, int part)
  863. {
  864. if (part & 1) {
  865. cs->tqueue.routine = (void *) (void *) W6692_bh;
  866. cs->setstack_d = setstack_W6692;
  867. cs->DC_Close = DC_Close_W6692;
  868. cs->dbusytimer.function = (void *) dbusy_timer_handler;
  869. cs->dbusytimer.data = (long) cs;
  870. init_timer(&cs->dbusytimer);
  872. cs->writeW6692(cs, W_D_CTL, W_D_CTL_SRST);
  873. cs->writeW6692(cs, W_D_CTL, 0x00);
  874. cs->writeW6692(cs, W_IMASK, 0xff);
  875. cs->writeW6692(cs, W_D_SAM, 0xff);
  876. cs->writeW6692(cs, W_D_TAM, 0xff);
  877. cs->writeW6692(cs, W_D_EXIM, 0x00);
  878. cs->writeW6692(cs, W_D_MODE, W_D_MODE_RACT);
  879. cs->writeW6692(cs, W_IMASK, 0x18);
  880. ph_command(cs, W_L1CMD_RST);
  881. cs->dc.w6692.ph_state = W_L1CMD_RST;
  882. W6692_new_ph(cs);
  883. ph_command(cs, W_L1CMD_ECK);
  885. cs->bcs[0].BC_SetStack = setstack_w6692;
  886. cs->bcs[1].BC_SetStack = setstack_w6692;
  887. cs->bcs[0].BC_Close = close_w6692state;
  888. cs->bcs[1].BC_Close = close_w6692state;
  889. W6692Bmode(cs->bcs, 0, 0);
  890. W6692Bmode(cs->bcs + 1, 0, 0);
  891. }
  892. if (part & 2) {
  893. /* Reenable all IRQ */
  894. cs->writeW6692(cs, W_IMASK, 0x18);
  895. cs->writeW6692(cs, W_D_EXIM, 0x00);
  896. cs->BC_Write_Reg(cs, 0, W_B_EXIM, 0x00);
  897. cs->BC_Write_Reg(cs, 1, W_B_EXIM, 0x00);
  898. /* Reset D-chan receiver and transmitter */
  899. cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RRST | W_D_CMDR_XRST);
  900. }
  901. }
  903. /* Interface functions */
  905. static u_char
  906. ReadW6692(struct IsdnCardState *cs, u_char offset)
  907. {
  908. return (inb(cs->hw.w6692.iobase + offset));
  909. }
  911. static void
  912. WriteW6692(struct IsdnCardState *cs, u_char offset, u_char value)
  913. {
  914. outb(value, cs->hw.w6692.iobase + offset);
  915. }
  917. static void
  918. ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  919. {
  920. insb(cs->hw.w6692.iobase + W_D_RFIFO, data, size);
  921. }
  923. static void
  924. WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  925. {
  926. outsb(cs->hw.w6692.iobase + W_D_XFIFO, data, size);
  927. }
  929. static u_char
  930. ReadW6692B(struct IsdnCardState *cs, int bchan, u_char offset)
  931. {
  932. return (inb(cs->hw.w6692.iobase + (bchan ? 0x40 : 0) + offset));
  933. }
  935. static void
  936. WriteW6692B(struct IsdnCardState *cs, int bchan, u_char offset, u_char value)
  937. {
  938. outb(value, cs->hw.w6692.iobase + (bchan ? 0x40 : 0) + offset);
  939. }
  941. static int
  942. w6692_card_msg(struct IsdnCardState *cs, int mt, void *arg)
  943. {
  944. switch (mt) {
  945. case CARD_RESET:
  946. return (0);
  947. case CARD_RELEASE:
  948. release_region(cs->hw.w6692.iobase, 256);
  949. return (0);
  950. case CARD_INIT:
  951. initW6692(cs, 3);
  952. return (0);
  953. case CARD_TEST:
  954. return (0);
  955. }
  956. return (0);
  957. }
  959. static int id_idx ;
  961. static struct pci_dev *dev_w6692 __initdata = NULL;
  963. int __init 
  964. setup_w6692(struct IsdnCard *card)
  965. {
  966. struct IsdnCardState *cs = card->cs;
  967. char tmp[64];
  968. u_char found = 0;
  969. u_char pci_irq = 0;
  970. u_int pci_ioaddr = 0;
  972. #ifdef __BIG_ENDIAN
  973. #error "not running on big endian machines now"
  974. #endif
  975. strcpy(tmp, w6692_revision);
  976. printk(KERN_INFO "HiSax: W6692 driver Rev. %sn", HiSax_getrev(tmp));
  977. if (cs->typ != ISDN_CTYPE_W6692)
  978. return (0);
  979. #if CONFIG_PCI
  980. if (!pci_present()) {
  981. printk(KERN_ERR "W6692: no PCI bus presentn");
  982. return (0);
  983. }
  984. while (id_list[id_idx].vendor_id) {
  985. dev_w6692 = pci_find_device(id_list[id_idx].vendor_id,
  986.     id_list[id_idx].device_id,
  987.     dev_w6692);
  988. if (dev_w6692) {
  989. if (pci_enable_device(dev_w6692))
  990. continue;
  991. break;
  992. }
  993. id_idx++;
  994. }
  995. if (dev_w6692) {
  996. found = 1;
  997. pci_irq = dev_w6692->irq;
  998. /* I think address 0 is allways the configuration area */
  999. /* and address 1 is the real IO space KKe 03.09.99 */
  1000. pci_ioaddr = pci_resource_start(dev_w6692, 1);
  1001. }
  1002. if (!found) {
  1003. printk(KERN_WARNING "W6692: No PCI card foundn");
  1004. return (0);
  1005. }
  1006. cs->irq = pci_irq;
  1007. if (!cs->irq) {
  1008. printk(KERN_WARNING "W6692: No IRQ for PCI card foundn");
  1009. return (0);
  1010. }
  1011. if (!pci_ioaddr) {
  1012. printk(KERN_WARNING "W6692: NO I/O Base Address foundn");
  1013. return (0);
  1014. }
  1015. cs->hw.w6692.iobase = pci_ioaddr;
  1016. printk(KERN_INFO "Found: %s %s, I/O base: 0x%x, irq: %dn",
  1017.        id_list[id_idx].vendor_name, id_list[id_idx].card_name,
  1018.        pci_ioaddr, dev_w6692->irq);
  1019. if (check_region((cs->hw.w6692.iobase), 256)) {
  1020. printk(KERN_WARNING
  1021.        "HiSax: %s I/O ports %x-%x already in usen",
  1022.        id_list[id_idx].card_name,
  1023.        cs->hw.w6692.iobase,
  1024.        cs->hw.w6692.iobase + 255);
  1025. return (0);
  1026. } else {
  1027. request_region(cs->hw.w6692.iobase, 256,
  1028.        id_list[id_idx].card_name);
  1029. }
  1030. #else
  1031. printk(KERN_WARNING "HiSax: W6692 and NO_PCI_BIOSn");
  1032. printk(KERN_WARNING "HiSax: W6692 unable to confign");
  1033. return (0);
  1034. #endif /* CONFIG_PCI */
  1036. printk(KERN_INFO
  1037.        "HiSax: %s config irq:%d I/O:%xn",
  1038.        id_list[id_idx].card_name, cs->irq,
  1039.        cs->hw.w6692.iobase);
  1041. cs->readW6692 = &ReadW6692;
  1042. cs->writeW6692 = &WriteW6692;
  1043. cs->readisacfifo = &ReadISACfifo;
  1044. cs->writeisacfifo = &WriteISACfifo;
  1045. cs->BC_Read_Reg = &ReadW6692B;
  1046. cs->BC_Write_Reg = &WriteW6692B;
  1047. cs->BC_Send_Data = &W6692B_fill_fifo;
  1048. cs->cardmsg = &w6692_card_msg;
  1049. cs->irq_func = &W6692_interrupt;
  1050. cs->irq_flags |= SA_SHIRQ;
  1051. W6692Version(cs, "W6692:");
  1052. printk(KERN_INFO "W6692 ISTA=0x%Xn", ReadW6692(cs, W_ISTA));
  1053. printk(KERN_INFO "W6692 IMASK=0x%Xn", ReadW6692(cs, W_IMASK));
  1054. printk(KERN_INFO "W6692 D_EXIR=0x%Xn", ReadW6692(cs, W_D_EXIR));
  1055. printk(KERN_INFO "W6692 D_EXIM=0x%Xn", ReadW6692(cs, W_D_EXIM));
  1056. printk(KERN_INFO "W6692 D_RSTA=0x%Xn", ReadW6692(cs, W_D_RSTA));
  1057. return (1);
  1058. }