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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
netjet.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

netjet.c：源码内容
  1. /* $Id: netjet.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * low level stuff for Traverse Technologie NETJet 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.  * Thanks to Traverse Technologies Australia for documents and information
  12.  *
  13.  * 16-Apr-2002 - led code added - Guy Ellis (guy@traverse.com.au)
  14.  *
  15.  */
  17. #define __NO_VERSION__
  18. #include <linux/init.h>
  19. #include "hisax.h"
  20. #include "isac.h"
  21. #include "hscx.h"
  22. #include "isdnl1.h"
  23. #include <linux/pci.h>
  24. #include <linux/interrupt.h>
  25. #include <linux/ppp_defs.h>
  26. #include <asm/io.h>
  27. #include "netjet.h"
  29. const char *NETjet_revision = "$Revision: 1.1.4.1 $";
  31. /* Interface functions */
  33. u_char
  34. NETjet_ReadIC(struct IsdnCardState *cs, u_char offset)
  35. {
  36. long flags;
  37. u_char ret;
  39. save_flags(flags);
  40. cli();
  41. cs->hw.njet.auxd &= 0xfc;
  42. cs->hw.njet.auxd |= (offset>>4) & 3;
  43. byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  44. ret = bytein(cs->hw.njet.isac + ((offset & 0xf)<<2));
  45. restore_flags(flags);
  46. return(ret);
  47. }
  49. void
  50. NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value)
  51. {
  52. long flags;
  54. save_flags(flags);
  55. cli();
  56. cs->hw.njet.auxd &= 0xfc;
  57. cs->hw.njet.auxd |= (offset>>4) & 3;
  58. byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  59. byteout(cs->hw.njet.isac + ((offset & 0xf)<<2), value);
  60. restore_flags(flags);
  61. }
  63. void
  64. NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
  65. {
  66. cs->hw.njet.auxd &= 0xfc;
  67. byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  68. insb(cs->hw.njet.isac, data, size);
  69. }
  71. __u16 fcstab[256] =
  72. {
  73. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  74. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  75. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  76. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  77. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  78. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  79. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  80. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  81. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  82. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  83. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  84. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  85. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  86. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  87. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  88. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  89. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  90. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  91. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  92. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  93. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  94. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  95. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  96. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  97. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  98. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  99. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  100. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  101. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  102. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  103. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  104. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  105. };
  107. void 
  108. NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
  109. {
  110. cs->hw.njet.auxd &= 0xfc;
  111. byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  112. outsb(cs->hw.njet.isac, data, size);
  113. }
  115. void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
  116. {
  117. u_int mask=0x000000ff, val = 0, *p=pos;
  118. u_int i;
  120. val |= fill;
  121. if (chan) {
  122. val  <<= 8;
  123. mask <<= 8;
  124. }
  125. mask ^= 0xffffffff;
  126. for (i=0; i<cnt; i++) {
  127. *p   &= mask;
  128. *p++ |= val;
  129. if (p > bcs->hw.tiger.s_end)
  130. p = bcs->hw.tiger.send;
  131. }
  132. }
  134. void
  135. mode_tiger(struct BCState *bcs, int mode, int bc)
  136. {
  137. struct IsdnCardState *cs = bcs->cs;
  138.         u_char led;
  140. if (cs->debug & L1_DEB_HSCX)
  141. debugl1(cs, "Tiger mode %d bchan %d/%d",
  142. mode, bc, bcs->channel);
  143. bcs->mode = mode;
  144. bcs->channel = bc;
  145. switch (mode) {
  146. case (L1_MODE_NULL):
  147. fill_mem(bcs, bcs->hw.tiger.send,
  148. NETJET_DMA_TXSIZE, bc, 0xff);
  149. if (cs->debug & L1_DEB_HSCX)
  150. debugl1(cs, "Tiger stat rec %d/%d send %d",
  151. bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
  152. bcs->hw.tiger.s_tot); 
  153. if ((cs->bcs[0].mode == L1_MODE_NULL) &&
  154. (cs->bcs[1].mode == L1_MODE_NULL)) {
  155. cs->hw.njet.dmactrl = 0;
  156. byteout(cs->hw.njet.base + NETJET_DMACTRL,
  157. cs->hw.njet.dmactrl);
  158. byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
  159. }
  160.                         if (cs->typ == ISDN_CTYPE_NETJET_S)
  161.                         {
  162.                                 // led off
  163.                                 led = bc & 0x01;
  164.                                 led = 0x01 << (6 + led); // convert to mask
  165.                                 led = ~led;
  166.                                 cs->hw.njet.auxd &= led;
  167.                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  168.                         }
  169. break;
  170. case (L1_MODE_TRANS):
  171. break;
  172. case (L1_MODE_HDLC_56K):
  173. case (L1_MODE_HDLC):
  174. fill_mem(bcs, bcs->hw.tiger.send,
  175. NETJET_DMA_TXSIZE, bc, 0xff);
  176. bcs->hw.tiger.r_state = HDLC_ZERO_SEARCH;
  177. bcs->hw.tiger.r_tot = 0;
  178. bcs->hw.tiger.r_bitcnt = 0;
  179. bcs->hw.tiger.r_one = 0;
  180. bcs->hw.tiger.r_err = 0;
  181. bcs->hw.tiger.s_tot = 0;
  182. if (! cs->hw.njet.dmactrl) {
  183. fill_mem(bcs, bcs->hw.tiger.send,
  184. NETJET_DMA_TXSIZE, !bc, 0xff);
  185. cs->hw.njet.dmactrl = 1;
  186. byteout(cs->hw.njet.base + NETJET_DMACTRL,
  187. cs->hw.njet.dmactrl);
  188. byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0x0f);
  189. /* was 0x3f now 0x0f for TJ300 and TJ320  GE 13/07/00 */
  190. }
  191. bcs->hw.tiger.sendp = bcs->hw.tiger.send;
  192. bcs->hw.tiger.free = NETJET_DMA_TXSIZE;
  193. test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
  194.                         if (cs->typ == ISDN_CTYPE_NETJET_S)
  195.                         {
  196.                                 // led on
  197.                                 led = bc & 0x01;
  198.                                 led = 0x01 << (6 + led); // convert to mask
  199.                                 cs->hw.njet.auxd |= led;
  200.                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  201.                         }
  202. break;
  203. }
  204. if (cs->debug & L1_DEB_HSCX)
  205. debugl1(cs, "tiger: set %x %x %x  %x/%x  pulse=%d",
  206. bytein(cs->hw.njet.base + NETJET_DMACTRL),
  207. bytein(cs->hw.njet.base + NETJET_IRQMASK0),
  208. bytein(cs->hw.njet.base + NETJET_IRQSTAT0),
  209. inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
  210. inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
  211. bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
  212. }
  214. static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) {
  215. char tmp[128];
  216. char *t = tmp;
  217. int i=count,j;
  218. u_char *p = buf;
  220. t += sprintf(t, "tiger %s(%4d)", s, count);
  221. while (i>0) {
  222. if (i>16)
  223. j=16;
  224. else
  225. j=i;
  226. QuickHex(t, p, j);
  227. debugl1(cs, tmp);
  228. p += j;
  229. i -= j;
  230. t = tmp;
  231. t += sprintf(t, "tiger %s      ", s);
  232. }
  233. }
  235. // macro for 64k
  237. #define MAKE_RAW_BYTE for (j=0; j<8; j++) { 
  238. bitcnt++;
  239. s_val >>= 1;
  240. if (val & 1) {
  241. s_one++;
  242. s_val |= 0x80;
  243. } else {
  244. s_one = 0;
  245. s_val &= 0x7f;
  246. }
  247. if (bitcnt==8) {
  248. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  249. bitcnt = 0;
  250. }
  251. if (s_one == 5) {
  252. s_val >>= 1;
  253. s_val &= 0x7f;
  254. bitcnt++;
  255. s_one = 0;
  256. }
  257. if (bitcnt==8) {
  258. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  259. bitcnt = 0;
  260. }
  261. val >>= 1;
  262. }
  264. static int make_raw_data(struct BCState *bcs) {
  265. // this make_raw is for 64k
  266. register u_int i,s_cnt=0;
  267. register u_char j;
  268. register u_char val;
  269. register u_char s_one = 0;
  270. register u_char s_val = 0;
  271. register u_char bitcnt = 0;
  272. u_int fcs;
  274. if (!bcs->tx_skb) {
  275. debugl1(bcs->cs, "tiger make_raw: NULL skb");
  276. return(1);
  277. }
  278. bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
  279. fcs = PPP_INITFCS;
  280. for (i=0; i<bcs->tx_skb->len; i++) {
  281. val = bcs->tx_skb->data[i];
  282. fcs = PPP_FCS (fcs, val);
  283. MAKE_RAW_BYTE;
  284. }
  285. fcs ^= 0xffff;
  286. val = fcs & 0xff;
  287. MAKE_RAW_BYTE;
  288. val = (fcs>>8) & 0xff;
  289. MAKE_RAW_BYTE;
  290. val = HDLC_FLAG_VALUE;
  291. for (j=0; j<8; j++) { 
  292. bitcnt++;
  293. s_val >>= 1;
  294. if (val & 1)
  295. s_val |= 0x80;
  296. else
  297. s_val &= 0x7f;
  298. if (bitcnt==8) {
  299. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  300. bitcnt = 0;
  301. }
  302. val >>= 1;
  303. }
  304. if (bcs->cs->debug & L1_DEB_HSCX)
  305. debugl1(bcs->cs,"tiger make_raw: in %ld out %d.%d",
  306. bcs->tx_skb->len, s_cnt, bitcnt);
  307. if (bitcnt) {
  308. while (8>bitcnt++) {
  309. s_val >>= 1;
  310. s_val |= 0x80;
  311. }
  312. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  313. bcs->hw.tiger.sendbuf[s_cnt++] = 0xff; // NJ<->NJ thoughput bug fix
  314. }
  315. bcs->hw.tiger.sendcnt = s_cnt;
  316. bcs->tx_cnt -= bcs->tx_skb->len;
  317. bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
  318. return(0);
  319. }
  321. // macro for 56k
  323. #define MAKE_RAW_BYTE_56K for (j=0; j<8; j++) { 
  324. bitcnt++;
  325. s_val >>= 1;
  326. if (val & 1) {
  327. s_one++;
  328. s_val |= 0x80;
  329. } else {
  330. s_one = 0;
  331. s_val &= 0x7f;
  332. }
  333. if (bitcnt==7) {
  334. s_val >>= 1;
  335. s_val |= 0x80;
  336. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  337. bitcnt = 0;
  338. }
  339. if (s_one == 5) {
  340. s_val >>= 1;
  341. s_val &= 0x7f;
  342. bitcnt++;
  343. s_one = 0;
  344. }
  345. if (bitcnt==7) {
  346. s_val >>= 1;
  347. s_val |= 0x80;
  348. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  349. bitcnt = 0;
  350. }
  351. val >>= 1;
  352. }
  354. static int make_raw_data_56k(struct BCState *bcs) {
  355. // this make_raw is for 56k
  356. register u_int i,s_cnt=0;
  357. register u_char j;
  358. register u_char val;
  359. register u_char s_one = 0;
  360. register u_char s_val = 0;
  361. register u_char bitcnt = 0;
  362. u_int fcs;
  364. if (!bcs->tx_skb) {
  365. debugl1(bcs->cs, "tiger make_raw_56k: NULL skb");
  366. return(1);
  367. }
  368. val = HDLC_FLAG_VALUE;
  369. for (j=0; j<8; j++) { 
  370. bitcnt++;
  371. s_val >>= 1;
  372. if (val & 1)
  373. s_val |= 0x80;
  374. else
  375. s_val &= 0x7f;
  376. if (bitcnt==7) {
  377. s_val >>= 1;
  378. s_val |= 0x80;
  379. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  380. bitcnt = 0;
  381. }
  382. val >>= 1;
  383. };
  384. fcs = PPP_INITFCS;
  385. for (i=0; i<bcs->tx_skb->len; i++) {
  386. val = bcs->tx_skb->data[i];
  387. fcs = PPP_FCS (fcs, val);
  388. MAKE_RAW_BYTE_56K;
  389. }
  390. fcs ^= 0xffff;
  391. val = fcs & 0xff;
  392. MAKE_RAW_BYTE_56K;
  393. val = (fcs>>8) & 0xff;
  394. MAKE_RAW_BYTE_56K;
  395. val = HDLC_FLAG_VALUE;
  396. for (j=0; j<8; j++) { 
  397. bitcnt++;
  398. s_val >>= 1;
  399. if (val & 1)
  400. s_val |= 0x80;
  401. else
  402. s_val &= 0x7f;
  403. if (bitcnt==7) {
  404. s_val >>= 1;
  405. s_val |= 0x80;
  406. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  407. bitcnt = 0;
  408. }
  409. val >>= 1;
  410. }
  411. if (bcs->cs->debug & L1_DEB_HSCX)
  412. debugl1(bcs->cs,"tiger make_raw_56k: in %ld out %d.%d",
  413. bcs->tx_skb->len, s_cnt, bitcnt);
  414. if (bitcnt) {
  415. while (8>bitcnt++) {
  416. s_val >>= 1;
  417. s_val |= 0x80;
  418. }
  419. bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
  420. bcs->hw.tiger.sendbuf[s_cnt++] = 0xff; // NJ<->NJ thoughput bug fix
  421. }
  422. bcs->hw.tiger.sendcnt = s_cnt;
  423. bcs->tx_cnt -= bcs->tx_skb->len;
  424. bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
  425. return(0);
  426. }
  428. static void got_frame(struct BCState *bcs, int count) {
  429. struct sk_buff *skb;
  431. if (!(skb = dev_alloc_skb(count)))
  432. printk(KERN_WARNING "TIGER: receive out of memoryn");
  433. else {
  434. memcpy(skb_put(skb, count), bcs->hw.tiger.rcvbuf, count);
  435. skb_queue_tail(&bcs->rqueue, skb);
  436. }
  437. bcs->event |= 1 << B_RCVBUFREADY;
  438. queue_task(&bcs->tqueue, &tq_immediate);
  439. mark_bh(IMMEDIATE_BH);
  441. if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME)
  442. printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec");
  443. }
  447. static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
  448. int i;
  449. register u_char j;
  450. register u_char val;
  451. u_int  *pend = bcs->hw.tiger.rec +NETJET_DMA_RXSIZE -1;
  452. register u_char state = bcs->hw.tiger.r_state;
  453. register u_char r_one = bcs->hw.tiger.r_one;
  454. register u_char r_val = bcs->hw.tiger.r_val;
  455. register u_int bitcnt = bcs->hw.tiger.r_bitcnt;
  456. u_int *p = buf;
  457. int bits;
  458. u_char mask;
  460.         if (bcs->mode == L1_MODE_HDLC) { // it's 64k
  461. mask = 0xff;
  462. bits = 8;
  463. }
  464. else { // it's 56K
  465. mask = 0x7f;
  466. bits = 7;
  467. };
  468. for (i=0;i<cnt;i++) {
  469. val = bcs->channel ? ((*p>>8) & 0xff) : (*p & 0xff);
  470. p++;
  471. if (p > pend)
  472. p = bcs->hw.tiger.rec;
  473. if ((val & mask) == mask) {
  474. state = HDLC_ZERO_SEARCH;
  475. bcs->hw.tiger.r_tot++;
  476. bitcnt = 0;
  477. r_one = 0;
  478. continue;
  479. }
  480. for (j=0;j<bits;j++) {
  481. if (state == HDLC_ZERO_SEARCH) {
  482. if (val & 1) {
  483. r_one++;
  484. } else {
  485. r_one=0;
  486. state= HDLC_FLAG_SEARCH;
  487. if (bcs->cs->debug & L1_DEB_HSCX)
  488. debugl1(bcs->cs,"tiger read_raw: zBit(%d,%d,%d) %x",
  489. bcs->hw.tiger.r_tot,i,j,val);
  490. }
  491. } else if (state == HDLC_FLAG_SEARCH) { 
  492. if (val & 1) {
  493. r_one++;
  494. if (r_one>6) {
  495. state=HDLC_ZERO_SEARCH;
  496. }
  497. } else {
  498. if (r_one==6) {
  499. bitcnt=0;
  500. r_val=0;
  501. state=HDLC_FLAG_FOUND;
  502. if (bcs->cs->debug & L1_DEB_HSCX)
  503. debugl1(bcs->cs,"tiger read_raw: flag(%d,%d,%d) %x",
  504. bcs->hw.tiger.r_tot,i,j,val);
  505. }
  506. r_one=0;
  507. }
  508. } else if (state ==  HDLC_FLAG_FOUND) {
  509. if (val & 1) {
  510. r_one++;
  511. if (r_one>6) {
  512. state=HDLC_ZERO_SEARCH;
  513. } else {
  514. r_val >>= 1;
  515. r_val |= 0x80;
  516. bitcnt++;
  517. }
  518. } else {
  519. if (r_one==6) {
  520. bitcnt=0;
  521. r_val=0;
  522. r_one=0;
  523. val >>= 1;
  524. continue;
  525. } else if (r_one!=5) {
  526. r_val >>= 1;
  527. r_val &= 0x7f;
  528. bitcnt++;
  529. }
  530. r_one=0;
  531. }
  532. if ((state != HDLC_ZERO_SEARCH) &&
  533. !(bitcnt & 7)) {
  534. state=HDLC_FRAME_FOUND;
  535. bcs->hw.tiger.r_fcs = PPP_INITFCS;
  536. bcs->hw.tiger.rcvbuf[0] = r_val;
  537. bcs->hw.tiger.r_fcs = PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
  538. if (bcs->cs->debug & L1_DEB_HSCX)
  539. debugl1(bcs->cs,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
  540. bcs->hw.tiger.r_tot,i,j,r_val,val,
  541. bcs->cs->hw.njet.irqstat0);
  542. }
  543. } else if (state ==  HDLC_FRAME_FOUND) {
  544. if (val & 1) {
  545. r_one++;
  546. if (r_one>6) {
  547. state=HDLC_ZERO_SEARCH;
  548. bitcnt=0;
  549. } else {
  550. r_val >>= 1;
  551. r_val |= 0x80;
  552. bitcnt++;
  553. }
  554. } else {
  555. if (r_one==6) {
  556. r_val=0; 
  557. r_one=0;
  558. bitcnt++;
  559. if (bitcnt & 7) {
  560. debugl1(bcs->cs, "tiger: frame not byte aligned");
  561. state=HDLC_FLAG_SEARCH;
  562. bcs->hw.tiger.r_err++;
  563. #ifdef ERROR_STATISTIC
  564. bcs->err_inv++;
  565. #endif
  566. } else {
  567. if (bcs->cs->debug & L1_DEB_HSCX)
  568. debugl1(bcs->cs,"tiger frame end(%d,%d): fcs(%x) i %x",
  569. i,j,bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0);
  570. if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
  571. got_frame(bcs, (bitcnt>>3)-3);
  572. } else {
  573. if (bcs->cs->debug) {
  574. debugl1(bcs->cs, "tiger FCS error");
  575. printframe(bcs->cs, bcs->hw.tiger.rcvbuf,
  576. (bitcnt>>3)-1, "rec");
  577. bcs->hw.tiger.r_err++;
  578. }
  579. #ifdef ERROR_STATISTIC
  580. bcs->err_crc++;
  581. #endif
  582. }
  583. state=HDLC_FLAG_FOUND;
  584. }
  585. bitcnt=0;
  586. } else if (r_one==5) {
  587. val >>= 1;
  588. r_one=0;
  589. continue;
  590. } else {
  591. r_val >>= 1;
  592. r_val &= 0x7f;
  593. bitcnt++;
  594. }
  595. r_one=0;
  596. }
  597. if ((state == HDLC_FRAME_FOUND) &&
  598. !(bitcnt & 7)) {
  599. if ((bitcnt>>3)>=HSCX_BUFMAX) {
  600. debugl1(bcs->cs, "tiger: frame too big");
  601. r_val=0; 
  602. state=HDLC_FLAG_SEARCH;
  603. bcs->hw.tiger.r_err++;
  604. #ifdef ERROR_STATISTIC
  605. bcs->err_inv++;
  606. #endif
  607. } else {
  608. bcs->hw.tiger.rcvbuf[(bitcnt>>3)-1] = r_val;
  609. bcs->hw.tiger.r_fcs = 
  610. PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
  611. }
  612. }
  613. }
  614. val >>= 1;
  615. }
  616. bcs->hw.tiger.r_tot++;
  617. }
  618. bcs->hw.tiger.r_state = state;
  619. bcs->hw.tiger.r_one = r_one;
  620. bcs->hw.tiger.r_val = r_val;
  621. bcs->hw.tiger.r_bitcnt = bitcnt;
  622. }
  624. void read_tiger(struct IsdnCardState *cs) {
  625. u_int *p;
  626. int cnt = NETJET_DMA_RXSIZE/2;
  628. if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
  629. debugl1(cs,"tiger warn read double dma %x/%x",
  630. cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
  631. #ifdef ERROR_STATISTIC
  632. if (cs->bcs[0].mode)
  633. cs->bcs[0].err_rdo++;
  634. if (cs->bcs[1].mode)
  635. cs->bcs[1].err_rdo++;
  636. #endif
  637. return;
  638. } else {
  639. cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
  640. cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
  641. }
  642. if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
  643. p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
  644. else
  645. p = cs->bcs[0].hw.tiger.rec + cnt - 1;
  646. if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
  647. read_raw(cs->bcs, p, cnt);
  649. if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
  650. read_raw(cs->bcs + 1, p, cnt);
  651. cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_READ;
  652. }
  654. static void write_raw(struct BCState *bcs, u_int *buf, int cnt);
  656. void netjet_fill_dma(struct BCState *bcs)
  657. {
  658. register u_int *p, *sp;
  659. register int cnt;
  661. if (!bcs->tx_skb)
  662. return;
  663. if (bcs->cs->debug & L1_DEB_HSCX)
  664. debugl1(bcs->cs,"tiger fill_dma1: c%d %4x", bcs->channel,
  665. bcs->Flag);
  666. if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
  667. return;
  668. if (bcs->mode == L1_MODE_HDLC) { // it's 64k
  669. if (make_raw_data(bcs))
  670. return;
  671. }
  672. else { // it's 56k
  673. if (make_raw_data_56k(bcs))
  674. return;
  675. };
  676. if (bcs->cs->debug & L1_DEB_HSCX)
  677. debugl1(bcs->cs,"tiger fill_dma2: c%d %4x", bcs->channel,
  678. bcs->Flag);
  679. if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
  680. write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
  681. } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
  682. p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
  683. sp = bcs->hw.tiger.sendp;
  684. if (p == bcs->hw.tiger.s_end)
  685. p = bcs->hw.tiger.send -1;
  686. if (sp == bcs->hw.tiger.s_end)
  687. sp = bcs->hw.tiger.send -1;
  688. cnt = p - sp;
  689. if (cnt <0) {
  690. write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
  691. } else {
  692. p++;
  693. cnt++;
  694. if (p > bcs->hw.tiger.s_end)
  695. p = bcs->hw.tiger.send;
  696. p++;
  697. cnt++;
  698. if (p > bcs->hw.tiger.s_end)
  699. p = bcs->hw.tiger.send;
  700. write_raw(bcs, p, bcs->hw.tiger.free - cnt);
  701. }
  702. } else if (test_and_clear_bit(BC_FLG_EMPTY, &bcs->Flag)) {
  703. p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
  704. cnt = bcs->hw.tiger.s_end - p;
  705. if (cnt < 2) {
  706. p = bcs->hw.tiger.send + 1;
  707. cnt = NETJET_DMA_TXSIZE/2 - 2;
  708. } else {
  709. p++;
  710. p++;
  711. if (cnt <= (NETJET_DMA_TXSIZE/2))
  712. cnt += NETJET_DMA_TXSIZE/2;
  713. cnt--;
  714. cnt--;
  715. }
  716. write_raw(bcs, p, cnt);
  717. }
  718. if (bcs->cs->debug & L1_DEB_HSCX)
  719. debugl1(bcs->cs,"tiger fill_dma3: c%d %4x", bcs->channel,
  720. bcs->Flag);
  721. }
  723. static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
  724. u_int mask, val, *p=buf;
  725. u_int i, s_cnt;
  726.         
  727.         if (cnt <= 0)
  728.          return;
  729. if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
  730. if (bcs->hw.tiger.sendcnt> cnt) {
  731. s_cnt = cnt;
  732. bcs->hw.tiger.sendcnt -= cnt;
  733. } else {
  734. s_cnt = bcs->hw.tiger.sendcnt;
  735. bcs->hw.tiger.sendcnt = 0;
  736. }
  737. if (bcs->channel)
  738. mask = 0xffff00ff;
  739. else
  740. mask = 0xffffff00;
  741. for (i=0; i<s_cnt; i++) {
  742. val = bcs->channel ? ((bcs->hw.tiger.sp[i] <<8) & 0xff00) :
  743. (bcs->hw.tiger.sp[i]);
  744. *p   &= mask;
  745. *p++ |= val;
  746. if (p>bcs->hw.tiger.s_end)
  747. p = bcs->hw.tiger.send;
  748. }
  749. bcs->hw.tiger.s_tot += s_cnt;
  750. if (bcs->cs->debug & L1_DEB_HSCX)
  751. debugl1(bcs->cs,"tiger write_raw: c%d %x-%x %d/%d %d %x", bcs->channel,
  752. (u_int)buf, (u_int)p, s_cnt, cnt,
  753. bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
  754. if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
  755. printframe(bcs->cs, bcs->hw.tiger.sp, s_cnt, "snd");
  756. bcs->hw.tiger.sp += s_cnt;
  757. bcs->hw.tiger.sendp = p;
  758. if (!bcs->hw.tiger.sendcnt) {
  759. if (!bcs->tx_skb) {
  760. debugl1(bcs->cs,"tiger write_raw: NULL skb s_cnt %d", s_cnt);
  761. } else {
  762. if (bcs->st->lli.l1writewakeup &&
  763. (PACKET_NOACK != bcs->tx_skb->pkt_type))
  764. bcs->st->lli.l1writewakeup(bcs->st, bcs->tx_skb->len);
  765. dev_kfree_skb_any(bcs->tx_skb);
  766. bcs->tx_skb = NULL;
  767. }
  768. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  769. bcs->hw.tiger.free = cnt - s_cnt;
  770. if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE/2))
  771. test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
  772. else {
  773. test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
  774. test_and_set_bit(BC_FLG_NOFRAME, &bcs->Flag);
  775. }
  776. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  777. netjet_fill_dma(bcs);
  778. } else {
  779. mask ^= 0xffffffff;
  780. if (s_cnt < cnt) {
  781. for (i=s_cnt; i<cnt;i++) {
  782. *p++ |= mask;
  783. if (p>bcs->hw.tiger.s_end)
  784. p = bcs->hw.tiger.send;
  785. }
  786. if (bcs->cs->debug & L1_DEB_HSCX)
  787. debugl1(bcs->cs, "tiger write_raw: fill rest %d",
  788. cnt - s_cnt);
  789. }
  790. bcs->event |= 1 << B_XMTBUFREADY;
  791. queue_task(&bcs->tqueue, &tq_immediate);
  792. mark_bh(IMMEDIATE_BH);
  793. }
  794. }
  795. } else if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
  796. test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
  797. fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
  798. bcs->hw.tiger.free += cnt;
  799. if (bcs->cs->debug & L1_DEB_HSCX)
  800. debugl1(bcs->cs,"tiger write_raw: fill half");
  801. } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
  802. test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
  803. fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
  804. if (bcs->cs->debug & L1_DEB_HSCX)
  805. debugl1(bcs->cs,"tiger write_raw: fill full");
  806. }
  807. }
  809. void write_tiger(struct IsdnCardState *cs) {
  810. u_int *p, cnt = NETJET_DMA_TXSIZE/2;
  812. if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
  813. debugl1(cs,"tiger warn write double dma %x/%x",
  814. cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
  815. #ifdef ERROR_STATISTIC
  816. if (cs->bcs[0].mode)
  817. cs->bcs[0].err_tx++;
  818. if (cs->bcs[1].mode)
  819. cs->bcs[1].err_tx++;
  820. #endif
  821. return;
  822. } else {
  823. cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
  824. cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
  825. }
  826. if (cs->hw.njet.irqstat0  & NETJET_IRQM0_WRITE_1)
  827. p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
  828. else
  829. p = cs->bcs[0].hw.tiger.send + cnt - 1;
  830. if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
  831. write_raw(cs->bcs, p, cnt);
  832. if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
  833. write_raw(cs->bcs + 1, p, cnt);
  834. cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_WRITE;
  835. }
  837. static void
  838. tiger_l2l1(struct PStack *st, int pr, void *arg)
  839. {
  840. struct sk_buff *skb = arg;
  841. long flags;
  843. switch (pr) {
  844. case (PH_DATA | REQUEST):
  845. save_flags(flags);
  846. cli();
  847. if (st->l1.bcs->tx_skb) {
  848. skb_queue_tail(&st->l1.bcs->squeue, skb);
  849. restore_flags(flags);
  850. } else {
  851. st->l1.bcs->tx_skb = skb;
  852. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  853. restore_flags(flags);
  854. }
  855. break;
  856. case (PH_PULL | INDICATION):
  857. if (st->l1.bcs->tx_skb) {
  858. printk(KERN_WARNING "tiger_l2l1: this shouldn't happenn");
  859. break;
  860. }
  861. save_flags(flags);
  862. cli();
  863. st->l1.bcs->tx_skb = skb;
  864. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  865. restore_flags(flags);
  866. break;
  867. case (PH_PULL | REQUEST):
  868. if (!st->l1.bcs->tx_skb) {
  869. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  870. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  871. } else
  872. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  873. break;
  874. case (PH_ACTIVATE | REQUEST):
  875. test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  876. mode_tiger(st->l1.bcs, st->l1.mode, st->l1.bc);
  877. /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
  878. st->l1.bcs->cs->cardmsg(st->l1.bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc));
  879. l1_msg_b(st, pr, arg);
  880. break;
  881. case (PH_DEACTIVATE | REQUEST):
  882. /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
  883. st->l1.bcs->cs->cardmsg(st->l1.bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc));
  884. l1_msg_b(st, pr, arg);
  885. break;
  886. case (PH_DEACTIVATE | CONFIRM):
  887. test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  888. test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  889. mode_tiger(st->l1.bcs, 0, st->l1.bc);
  890. st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
  891. break;
  892. }
  893. }
  896. void
  897. close_tigerstate(struct BCState *bcs)
  898. {
  899. mode_tiger(bcs, 0, bcs->channel);
  900. if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
  901. if (bcs->hw.tiger.rcvbuf) {
  902. kfree(bcs->hw.tiger.rcvbuf);
  903. bcs->hw.tiger.rcvbuf = NULL;
  904. }
  905. if (bcs->hw.tiger.sendbuf) {
  906. kfree(bcs->hw.tiger.sendbuf);
  907. bcs->hw.tiger.sendbuf = NULL;
  908. }
  909. skb_queue_purge(&bcs->rqueue);
  910. skb_queue_purge(&bcs->squeue);
  911. if (bcs->tx_skb) {
  912. dev_kfree_skb_any(bcs->tx_skb);
  913. bcs->tx_skb = NULL;
  914. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  915. }
  916. }
  917. }
  919. static int
  920. open_tigerstate(struct IsdnCardState *cs, struct BCState *bcs)
  921. {
  922. if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
  923. if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
  924. printk(KERN_WARNING
  925.        "HiSax: No memory for tiger.rcvbufn");
  926. return (1);
  927. }
  928. if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_ATOMIC))) {
  929. printk(KERN_WARNING
  930.        "HiSax: No memory for tiger.sendbufn");
  931. return (1);
  932. }
  933. skb_queue_head_init(&bcs->rqueue);
  934. skb_queue_head_init(&bcs->squeue);
  935. }
  936. bcs->tx_skb = NULL;
  937. bcs->hw.tiger.sendcnt = 0;
  938. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  939. bcs->event = 0;
  940. bcs->tx_cnt = 0;
  941. return (0);
  942. }
  944. int
  945. setstack_tiger(struct PStack *st, struct BCState *bcs)
  946. {
  947. bcs->channel = st->l1.bc;
  948. if (open_tigerstate(st->l1.hardware, bcs))
  949. return (-1);
  950. st->l1.bcs = bcs;
  951. st->l2.l2l1 = tiger_l2l1;
  952. setstack_manager(st);
  953. bcs->st = st;
  954. setstack_l1_B(st);
  955. return (0);
  956. }
  958.  
  959. void __init
  960. inittiger(struct IsdnCardState *cs)
  961. {
  962. if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int),
  963. GFP_KERNEL | GFP_DMA))) {
  964. printk(KERN_WARNING
  965.        "HiSax: No memory for tiger.sendn");
  966. return;
  967. }
  968. cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE/2 - 1;
  969. cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
  970. cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send;
  971. cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq;
  972. cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end;
  974. memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int));
  975. debugl1(cs, "tiger: send buf %x - %x", (u_int)cs->bcs[0].hw.tiger.send,
  976. (u_int)(cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1));
  977. outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
  978. cs->hw.njet.base + NETJET_DMA_READ_START);
  979. outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
  980. cs->hw.njet.base + NETJET_DMA_READ_IRQ);
  981. outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end),
  982. cs->hw.njet.base + NETJET_DMA_READ_END);
  983. if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int),
  984. GFP_KERNEL | GFP_DMA))) {
  985. printk(KERN_WARNING
  986.        "HiSax: No memory for tiger.recn");
  987. return;
  988. }
  989. debugl1(cs, "tiger: rec buf %x - %x", (u_int)cs->bcs[0].hw.tiger.rec,
  990. (u_int)(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1));
  991. cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec;
  992. memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_RXSIZE * sizeof(unsigned int));
  993. outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
  994. cs->hw.njet.base + NETJET_DMA_WRITE_START);
  995. outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE/2 - 1),
  996. cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
  997. outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1),
  998. cs->hw.njet.base + NETJET_DMA_WRITE_END);
  999. debugl1(cs, "tiger: dmacfg  %x/%x  pulse=%d",
  1000. inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
  1001. inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
  1002. bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
  1003. cs->hw.njet.last_is0 = 0;
  1004. cs->bcs[0].BC_SetStack = setstack_tiger;
  1005. cs->bcs[1].BC_SetStack = setstack_tiger;
  1006. cs->bcs[0].BC_Close = close_tigerstate;
  1007. cs->bcs[1].BC_Close = close_tigerstate;
  1008. }
  1010. void
  1011. releasetiger(struct IsdnCardState *cs)
  1012. {
  1013. if (cs->bcs[0].hw.tiger.send) {
  1014. kfree(cs->bcs[0].hw.tiger.send);
  1015. cs->bcs[0].hw.tiger.send = NULL;
  1016. }
  1017. if (cs->bcs[1].hw.tiger.send) {
  1018. cs->bcs[1].hw.tiger.send = NULL;
  1019. }
  1020. if (cs->bcs[0].hw.tiger.rec) {
  1021. kfree(cs->bcs[0].hw.tiger.rec);
  1022. cs->bcs[0].hw.tiger.rec = NULL;
  1023. }
  1024. if (cs->bcs[1].hw.tiger.rec) {
  1025. cs->bcs[1].hw.tiger.rec = NULL;
  1026. }
  1027. }
  1029. void
  1030. release_io_netjet(struct IsdnCardState *cs)
  1031. {
  1032. byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
  1033. byteout(cs->hw.njet.base + NETJET_IRQMASK1, 0);
  1034. releasetiger(cs);
  1035. release_region(cs->hw.njet.base, 256);
  1036. }