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

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

嵌入式Linux

开发平台：

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