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

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

Linux/Unix编程

开发平台：

Unix_Linux

isar.c：源码内容
  1. /* $Id: isar.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * isar.c   ISAR (Siemens PSB 7110) specific routines
  4.  *
  5.  * Author       Karsten Keil (keil@isdn4linux.de)
  6.  *
  7.  * This file is (c) under GNU General Public License
  8.  *
  9.  */
  11. #define __NO_VERSION__
  12. #include <linux/init.h>
  13. #include "hisax.h"
  14. #include "isar.h"
  15. #include "isdnl1.h"
  16. #include <linux/interrupt.h>
  18. #define DBG_LOADFIRM 0
  19. #define DUMP_MBOXFRAME 2
  21. #define DLE 0x10
  22. #define ETX 0x03
  25. const u_char faxmodulation_s[] = "3,24,48,72,73,74,96,97,98,121,122,145,146"; 
  26. const u_char faxmodulation[] = {3,24,48,72,73,74,96,97,98,121,122,145,146}; 
  27. #define FAXMODCNT 13
  29. void isar_setup(struct IsdnCardState *cs);
  30. static void isar_pump_cmd(struct BCState *bcs, u_char cmd, u_char para);
  31. static inline void ll_deliver_faxstat(struct BCState *bcs, u_char status);
  33. static inline int
  34. waitforHIA(struct IsdnCardState *cs, int timeout)
  35. {
  37. while ((cs->BC_Read_Reg(cs, 0, ISAR_HIA) & 1) && timeout) {
  38. udelay(1);
  39. timeout--;
  40. }
  41. if (!timeout)
  42. printk(KERN_WARNING "HiSax: ISAR waitforHIA timeoutn");
  43. return(timeout);
  44. }
  47. int
  48. sendmsg(struct IsdnCardState *cs, u_char his, u_char creg, u_char len,
  49. u_char *msg)
  50. {
  51. long flags;
  52. int i;
  54. if (!waitforHIA(cs, 4000))
  55. return(0);
  56. #if DUMP_MBOXFRAME
  57. if (cs->debug & L1_DEB_HSCX)
  58. debugl1(cs, "sendmsg(%02x,%02x,%d)", his, creg, len);
  59. #endif
  60. save_flags(flags);
  61. cli();
  62. cs->BC_Write_Reg(cs, 0, ISAR_CTRL_H, creg);
  63. cs->BC_Write_Reg(cs, 0, ISAR_CTRL_L, len);
  64. cs->BC_Write_Reg(cs, 0, ISAR_WADR, 0);
  65. if (msg && len) {
  66. cs->BC_Write_Reg(cs, 1, ISAR_MBOX, msg[0]);
  67. for (i=1; i<len; i++)
  68. cs->BC_Write_Reg(cs, 2, ISAR_MBOX, msg[i]);
  69. #if DUMP_MBOXFRAME>1
  70. if (cs->debug & L1_DEB_HSCX_FIFO) {
  71. char tmp[256], *t;
  73. i = len;
  74. while (i>0) {
  75. t = tmp;
  76. t += sprintf(t, "sendmbox cnt %d", len);
  77. QuickHex(t, &msg[len-i], (i>64) ? 64:i);
  78. debugl1(cs, tmp);
  79. i -= 64;
  80. }
  81. }
  82. #endif
  83. }
  84. cs->BC_Write_Reg(cs, 1, ISAR_HIS, his);
  85. restore_flags(flags);
  86. waitforHIA(cs, 10000);
  87. return(1);
  88. }
  90. /* Call only with IRQ disabled !!! */
  91. inline void
  92. rcv_mbox(struct IsdnCardState *cs, struct isar_reg *ireg, u_char *msg)
  93. {
  94. int i;
  96. cs->BC_Write_Reg(cs, 1, ISAR_RADR, 0);
  97. if (msg && ireg->clsb) {
  98. msg[0] = cs->BC_Read_Reg(cs, 1, ISAR_MBOX);
  99. for (i=1; i < ireg->clsb; i++)
  100.  msg[i] = cs->BC_Read_Reg(cs, 2, ISAR_MBOX);
  101. #if DUMP_MBOXFRAME>1
  102. if (cs->debug & L1_DEB_HSCX_FIFO) {
  103. char tmp[256], *t;
  105. i = ireg->clsb;
  106. while (i>0) {
  107. t = tmp;
  108. t += sprintf(t, "rcv_mbox cnt %d", ireg->clsb);
  109. QuickHex(t, &msg[ireg->clsb-i], (i>64) ? 64:i);
  110. debugl1(cs, tmp);
  111. i -= 64;
  112. }
  113. }
  114. #endif
  115. }
  116. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  117. }
  119. /* Call only with IRQ disabled !!! */
  120. inline void
  121. get_irq_infos(struct IsdnCardState *cs, struct isar_reg *ireg)
  122. {
  123. ireg->iis = cs->BC_Read_Reg(cs, 1, ISAR_IIS);
  124. ireg->cmsb = cs->BC_Read_Reg(cs, 1, ISAR_CTRL_H);
  125. ireg->clsb = cs->BC_Read_Reg(cs, 1, ISAR_CTRL_L);
  126. #if DUMP_MBOXFRAME
  127. if (cs->debug & L1_DEB_HSCX)
  128. debugl1(cs, "rcv_mbox(%02x,%02x,%d)", ireg->iis, ireg->cmsb,
  129. ireg->clsb);
  130. #endif
  131. }
  133. int
  134. waitrecmsg(struct IsdnCardState *cs, u_char *len,
  135. u_char *msg, int maxdelay)
  136. {
  137. int timeout = 0;
  138. long flags;
  139. struct isar_reg *ir = cs->bcs[0].hw.isar.reg;
  142. while((!(cs->BC_Read_Reg(cs, 0, ISAR_IRQBIT) & ISAR_IRQSTA)) &&
  143. (timeout++ < maxdelay))
  144. udelay(1);
  145. if (timeout >= maxdelay) {
  146. printk(KERN_WARNING"isar recmsg IRQSTA timeoutn");
  147. return(0);
  148. }
  149. save_flags(flags);
  150. cli();
  151. get_irq_infos(cs, ir);
  152. rcv_mbox(cs, ir, msg);
  153. *len = ir->clsb;
  154. restore_flags(flags);
  155. return(1);
  156. }
  158. int
  159. ISARVersion(struct IsdnCardState *cs, char *s)
  160. {
  161. int ver;
  162. u_char msg[] = ISAR_MSG_HWVER;
  163. u_char tmp[64];
  164. u_char len;
  165. int debug;
  167. cs->cardmsg(cs, CARD_RESET,  NULL);
  168. /* disable ISAR IRQ */
  169. cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
  170. debug = cs->debug;
  171. cs->debug &= ~(L1_DEB_HSCX | L1_DEB_HSCX_FIFO);
  172. if (!sendmsg(cs, ISAR_HIS_VNR, 0, 3, msg))
  173. return(-1);
  174. if (!waitrecmsg(cs, &len, tmp, 100000))
  175.  return(-2);
  176. cs->debug = debug;
  177. if (cs->bcs[0].hw.isar.reg->iis == ISAR_IIS_VNR) {
  178. if (len == 1) {
  179. ver = tmp[0] & 0xf;
  180. printk(KERN_INFO "%s ISAR version %dn", s, ver);
  181. return(ver);
  182. }
  183. return(-3);
  184. }
  185. return(-4);
  186. }
  188. int
  189. isar_load_firmware(struct IsdnCardState *cs, u_char *buf)
  190. {
  191. int ret, size, cnt, debug;
  192. u_char len, nom, noc;
  193. u_short sadr, left, *sp;
  194. u_char *p = buf;
  195. u_char *msg, *tmpmsg, *mp, tmp[64];
  196. long flags;
  197. struct isar_reg *ireg = cs->bcs[0].hw.isar.reg;
  199. struct {u_short sadr;
  200. u_short len;
  201. u_short d_key;
  202. } blk_head;
  204. #define BLK_HEAD_SIZE 6
  205. if (1 != (ret = ISARVersion(cs, "Testing"))) {
  206. printk(KERN_ERR"isar_load_firmware wrong isar version %dn", ret);
  207. return(1);
  208. }
  209. debug = cs->debug;
  210. #if DBG_LOADFIRM<2
  211. cs->debug &= ~(L1_DEB_HSCX | L1_DEB_HSCX_FIFO);
  212. #endif
  213. printk(KERN_DEBUG"isar_load_firmware buf %#lxn", (u_long)buf);
  214. if ((ret = verify_area(VERIFY_READ, (void *) p, sizeof(int)))) {
  215. printk(KERN_ERR"isar_load_firmware verify_area ret %dn", ret);
  216. return ret;
  217. }
  218. if ((ret = copy_from_user(&size, p, sizeof(int)))) {
  219. printk(KERN_ERR"isar_load_firmware copy_from_user ret %dn", ret);
  220. return ret;
  221. }
  222. p += sizeof(int);
  223. printk(KERN_DEBUG"isar_load_firmware size: %dn", size);
  224. if ((ret = verify_area(VERIFY_READ, (void *) p, size))) {
  225. printk(KERN_ERR"isar_load_firmware verify_area ret %dn", ret);
  226. return ret;
  227. }
  228. cnt = 0;
  229. /* disable ISAR IRQ */
  230. cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
  231. if (!(msg = kmalloc(256, GFP_KERNEL))) {
  232. printk(KERN_ERR"isar_load_firmware no buffern");
  233. return (1);
  234. }
  235. if (!(tmpmsg = kmalloc(256, GFP_KERNEL))) {
  236. printk(KERN_ERR"isar_load_firmware no tmp buffern");
  237. kfree(msg);
  238. return (1);
  239. }
  240. while (cnt < size) {
  241. if ((ret = copy_from_user(&blk_head, p, BLK_HEAD_SIZE))) {
  242. printk(KERN_ERR"isar_load_firmware copy_from_user ret %dn", ret);
  243. goto reterror;
  244. }
  245. #ifdef __BIG_ENDIAN
  246. sadr = (blk_head.sadr & 0xff)*256 + blk_head.sadr/256;
  247. blk_head.sadr = sadr;
  248. sadr = (blk_head.len & 0xff)*256 + blk_head.len/256;
  249. blk_head.len = sadr;
  250. sadr = (blk_head.d_key & 0xff)*256 + blk_head.d_key/256;
  251. blk_head.d_key = sadr;
  252. #endif /* __BIG_ENDIAN */
  253. cnt += BLK_HEAD_SIZE;
  254. p += BLK_HEAD_SIZE;
  255. printk(KERN_DEBUG"isar firmware block (%#x,%5d,%#x)n",
  256. blk_head.sadr, blk_head.len, blk_head.d_key & 0xff);
  257. sadr = blk_head.sadr;
  258. left = blk_head.len;
  259. if (!sendmsg(cs, ISAR_HIS_DKEY, blk_head.d_key & 0xff, 0, NULL)) {
  260. printk(KERN_ERR"isar sendmsg dkey failedn");
  261. ret = 1;goto reterror;
  262. }
  263. if (!waitrecmsg(cs, &len, tmp, 100000)) {
  264. printk(KERN_ERR"isar waitrecmsg dkey failedn");
  265. ret = 1;goto reterror;
  266. }
  267. if ((ireg->iis != ISAR_IIS_DKEY) || ireg->cmsb || len) {
  268. printk(KERN_ERR"isar wrong dkey response (%x,%x,%x)n",
  269. ireg->iis, ireg->cmsb, len);
  270. ret = 1;goto reterror;
  271. }
  272. while (left>0) {
  273. if (left > 126)
  274. noc = 126;
  275. else
  276. noc = left;
  277. nom = 2*noc;
  278. mp  = msg;
  279. *mp++ = sadr / 256;
  280. *mp++ = sadr % 256;
  281. left -= noc;
  282. *mp++ = noc;
  283. if ((ret = copy_from_user(tmpmsg, p, nom))) {
  284. printk(KERN_ERR"isar_load_firmware copy_from_user ret %dn", ret);
  285. goto reterror;
  286. }
  287. p += nom;
  288. cnt += nom;
  289. nom += 3;
  290. sp = (u_short *)tmpmsg;
  291. #if DBG_LOADFIRM
  292. printk(KERN_DEBUG"isar: load %3d words at %04x left %dn",
  293.  noc, sadr, left);
  294. #endif
  295. sadr += noc;
  296. while(noc) {
  297. #ifdef __BIG_ENDIAN
  298. *mp++ = *sp % 256;
  299. *mp++ = *sp / 256;
  300. #else
  301. *mp++ = *sp / 256;
  302. *mp++ = *sp % 256;
  303. #endif /* __BIG_ENDIAN */
  304. sp++;
  305. noc--;
  306. }
  307. if (!sendmsg(cs, ISAR_HIS_FIRM, 0, nom, msg)) {
  308. printk(KERN_ERR"isar sendmsg prog failedn");
  309. ret = 1;goto reterror;
  310. }
  311. if (!waitrecmsg(cs, &len, tmp, 100000)) {
  312. printk(KERN_ERR"isar waitrecmsg prog failedn");
  313. ret = 1;goto reterror;
  314. }
  315. if ((ireg->iis != ISAR_IIS_FIRM) || ireg->cmsb || len) {
  316. printk(KERN_ERR"isar wrong prog response (%x,%x,%x)n",
  317. ireg->iis, ireg->cmsb, len);
  318. ret = 1;goto reterror;
  319. }
  320. }
  321. printk(KERN_DEBUG"isar firmware block %5d words loadedn",
  322. blk_head.len);
  323. }
  324. /* 10ms delay */
  325. cnt = 10;
  326. while (cnt--)
  327. udelay(1000);
  328. msg[0] = 0xff;
  329. msg[1] = 0xfe;
  330. ireg->bstat = 0;
  331. if (!sendmsg(cs, ISAR_HIS_STDSP, 0, 2, msg)) {
  332. printk(KERN_ERR"isar sendmsg start dsp failedn");
  333. ret = 1;goto reterror;
  334. }
  335. if (!waitrecmsg(cs, &len, tmp, 100000)) {
  336. printk(KERN_ERR"isar waitrecmsg start dsp failedn");
  337. ret = 1;goto reterror;
  338. }
  339. if ((ireg->iis != ISAR_IIS_STDSP) || ireg->cmsb || len) {
  340. printk(KERN_ERR"isar wrong start dsp response (%x,%x,%x)n",
  341. ireg->iis, ireg->cmsb, len);
  342. ret = 1;goto reterror;
  343. } else
  344. printk(KERN_DEBUG"isar start dsp successn");
  345. /* NORMAL mode entered */
  346. /* Enable IRQs of ISAR */
  347. cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, ISAR_IRQSTA);
  348. save_flags(flags);
  349. sti();
  350. cnt = 1000; /* max 1s */
  351. while ((!ireg->bstat) && cnt) {
  352. udelay(1000);
  353. cnt--;
  354. }
  355. if (!cnt) {
  356. printk(KERN_ERR"isar no general status event receivedn");
  357. ret = 1;goto reterrflg;
  358. } else {
  359. printk(KERN_DEBUG"isar general status event %xn",
  360. ireg->bstat);
  361. }
  362. /* 10ms delay */
  363. cnt = 10;
  364. while (cnt--)
  365. udelay(1000);
  366. ireg->iis = 0;
  367. if (!sendmsg(cs, ISAR_HIS_DIAG, ISAR_CTRL_STST, 0, NULL)) {
  368. printk(KERN_ERR"isar sendmsg self tst failedn");
  369. ret = 1;goto reterrflg;
  370. }
  371. cnt = 10000; /* max 100 ms */
  372. while ((ireg->iis != ISAR_IIS_DIAG) && cnt) {
  373. udelay(10);
  374. cnt--;
  375. }
  376. udelay(1000);
  377. if (!cnt) {
  378. printk(KERN_ERR"isar no self tst responsen");
  379. ret = 1;goto reterrflg;
  380. }
  381. if ((ireg->cmsb == ISAR_CTRL_STST) && (ireg->clsb == 1)
  382. && (ireg->par[0] == 0)) {
  383. printk(KERN_DEBUG"isar selftest OKn");
  384. } else {
  385. printk(KERN_DEBUG"isar selftest not OK %x/%x/%xn",
  386. ireg->cmsb, ireg->clsb, ireg->par[0]);
  387. ret = 1;goto reterrflg;
  388. }
  389. ireg->iis = 0;
  390. if (!sendmsg(cs, ISAR_HIS_DIAG, ISAR_CTRL_SWVER, 0, NULL)) {
  391. printk(KERN_ERR"isar RQST SVN failedn");
  392. ret = 1;goto reterrflg;
  393. }
  394. cnt = 30000; /* max 300 ms */
  395. while ((ireg->iis != ISAR_IIS_DIAG) && cnt) {
  396. udelay(10);
  397. cnt--;
  398. }
  399. udelay(1000);
  400. if (!cnt) {
  401. printk(KERN_ERR"isar no SVN responsen");
  402. ret = 1;goto reterrflg;
  403. } else {
  404. if ((ireg->cmsb == ISAR_CTRL_SWVER) && (ireg->clsb == 1))
  405. printk(KERN_DEBUG"isar software version %#xn",
  406. ireg->par[0]);
  407. else {
  408. printk(KERN_ERR"isar wrong swver response (%x,%x) cnt(%d)n",
  409. ireg->cmsb, ireg->clsb, cnt);
  410. ret = 1;goto reterrflg;
  411. }
  412. }
  413. cs->debug = debug;
  414. isar_setup(cs);
  415. ret = 0;
  416. reterrflg:
  417. restore_flags(flags);
  418. reterror:
  419. cs->debug = debug;
  420. if (ret)
  421. /* disable ISAR IRQ */
  422. cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
  423. kfree(msg);
  424. kfree(tmpmsg);
  425. return(ret);
  426. }
  428. extern void BChannel_bh(struct BCState *);
  429. #define B_LL_NOCARRIER 8
  430. #define B_LL_CONNECT 9
  431. #define B_LL_OK 10
  433. static void
  434. isar_bh(struct BCState *bcs)
  435. {
  436. BChannel_bh(bcs);
  437. if (test_and_clear_bit(B_LL_NOCARRIER, &bcs->event))
  438. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_NOCARR);
  439. if (test_and_clear_bit(B_LL_CONNECT, &bcs->event))
  440. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
  441. if (test_and_clear_bit(B_LL_OK, &bcs->event))
  442. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_OK);
  443. }
  445. static void
  446. isar_sched_event(struct BCState *bcs, int event)
  447. {
  448. bcs->event |= 1 << event;
  449. queue_task(&bcs->tqueue, &tq_immediate);
  450. mark_bh(IMMEDIATE_BH);
  451. }
  453. static inline void
  454. send_DLE_ETX(struct BCState *bcs)
  455. {
  456. u_char dleetx[2] = {DLE,ETX};
  457. struct sk_buff *skb;
  459. if ((skb = dev_alloc_skb(2))) {
  460. memcpy(skb_put(skb, 2), dleetx, 2);
  461. skb_queue_tail(&bcs->rqueue, skb);
  462. isar_sched_event(bcs, B_RCVBUFREADY);
  463. } else {
  464. printk(KERN_WARNING "HiSax: skb out of memoryn");
  465. }
  466. }
  468. static inline int
  469. dle_count(unsigned char *buf, int len)
  470. {
  471. int count = 0;
  473. while (len--)
  474. if (*buf++ == DLE)
  475. count++;
  476. return count;
  477. }
  479. static inline void
  480. insert_dle(unsigned char *dest, unsigned char *src, int count) {
  481. /* <DLE> in input stream have to be flagged as <DLE><DLE> */
  482. while (count--) {
  483. *dest++ = *src;
  484. if (*src++ == DLE)
  485. *dest++ = DLE;
  486. }
  487. }
  488.  
  489. static inline void
  490. isar_rcv_frame(struct IsdnCardState *cs, struct BCState *bcs)
  491. {
  492. u_char *ptr;
  493. struct sk_buff *skb;
  494. struct isar_reg *ireg = bcs->hw.isar.reg;
  496. if (!ireg->clsb) {
  497. debugl1(cs, "isar zero len frame");
  498. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  499. return;
  500. }
  501. switch (bcs->mode) {
  502. case L1_MODE_NULL:
  503. debugl1(cs, "isar mode 0 spurious IIS_RDATA %x/%x/%x",
  504. ireg->iis, ireg->cmsb, ireg->clsb);
  505. printk(KERN_WARNING"isar mode 0 spurious IIS_RDATA %x/%x/%xn",
  506. ireg->iis, ireg->cmsb, ireg->clsb);
  507. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  508. break;
  509. case L1_MODE_TRANS:
  510. case L1_MODE_V32:
  511. if ((skb = dev_alloc_skb(ireg->clsb))) {
  512. rcv_mbox(cs, ireg, (u_char *)skb_put(skb, ireg->clsb));
  513. skb_queue_tail(&bcs->rqueue, skb);
  514. isar_sched_event(bcs, B_RCVBUFREADY);
  515. } else {
  516. printk(KERN_WARNING "HiSax: skb out of memoryn");
  517. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  518. }
  519. break;
  520. case L1_MODE_HDLC:
  521. if ((bcs->hw.isar.rcvidx + ireg->clsb) > HSCX_BUFMAX) {
  522. if (cs->debug & L1_DEB_WARN)
  523. debugl1(cs, "isar_rcv_frame: incoming packet too large");
  524. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  525. bcs->hw.isar.rcvidx = 0;
  526. } else if (ireg->cmsb & HDLC_ERROR) {
  527. if (cs->debug & L1_DEB_WARN)
  528. debugl1(cs, "isar frame error %x len %d",
  529. ireg->cmsb, ireg->clsb);
  530. #ifdef ERROR_STATISTIC
  531. if (ireg->cmsb & HDLC_ERR_RER)
  532. bcs->err_inv++;
  533. if (ireg->cmsb & HDLC_ERR_CER)
  534. bcs->err_crc++;
  535. #endif
  536. bcs->hw.isar.rcvidx = 0;
  537. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  538. } else {
  539. if (ireg->cmsb & HDLC_FSD)
  540. bcs->hw.isar.rcvidx = 0;
  541. ptr = bcs->hw.isar.rcvbuf + bcs->hw.isar.rcvidx;
  542. bcs->hw.isar.rcvidx += ireg->clsb;
  543. rcv_mbox(cs, ireg, ptr);
  544. if (ireg->cmsb & HDLC_FED) {
  545. if (bcs->hw.isar.rcvidx < 3) { /* last 2 bytes are the FCS */
  546. if (cs->debug & L1_DEB_WARN)
  547. debugl1(cs, "isar frame to short %d",
  548. bcs->hw.isar.rcvidx);
  549. } else if (!(skb = dev_alloc_skb(bcs->hw.isar.rcvidx-2))) {
  550. printk(KERN_WARNING "ISAR: receive out of memoryn");
  551. } else {
  552. memcpy(skb_put(skb, bcs->hw.isar.rcvidx-2),
  553. bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx-2);
  554. skb_queue_tail(&bcs->rqueue, skb);
  555. isar_sched_event(bcs, B_RCVBUFREADY);
  556. }
  557. bcs->hw.isar.rcvidx = 0;
  558. }
  559. }
  560. break;
  561. case L1_MODE_FAX:
  562. if (bcs->hw.isar.state != STFAX_ACTIV) {
  563. if (cs->debug & L1_DEB_WARN)
  564. debugl1(cs, "isar_rcv_frame: not ACTIV");
  565. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  566. bcs->hw.isar.rcvidx = 0;
  567. break;
  568. }
  569. if (bcs->hw.isar.cmd == PCTRL_CMD_FRM) {
  570. rcv_mbox(cs, ireg, bcs->hw.isar.rcvbuf);
  571. bcs->hw.isar.rcvidx = ireg->clsb +
  572. dle_count(bcs->hw.isar.rcvbuf, ireg->clsb);
  573. if (cs->debug & L1_DEB_HSCX)
  574. debugl1(cs, "isar_rcv_frame: raw(%d) dle(%d)",
  575. ireg->clsb, bcs->hw.isar.rcvidx);
  576. if ((skb = dev_alloc_skb(bcs->hw.isar.rcvidx))) {
  577. insert_dle((u_char *)skb_put(skb, bcs->hw.isar.rcvidx),
  578. bcs->hw.isar.rcvbuf, ireg->clsb);
  579. skb_queue_tail(&bcs->rqueue, skb);
  580. isar_sched_event(bcs, B_RCVBUFREADY);
  581. if (ireg->cmsb & SART_NMD) { /* ABORT */
  582. if (cs->debug & L1_DEB_WARN)
  583. debugl1(cs, "isar_rcv_frame: no more data");
  584. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  585. bcs->hw.isar.rcvidx = 0;
  586. send_DLE_ETX(bcs);
  587. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) |
  588. ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC,
  589. 0, NULL);
  590. bcs->hw.isar.state = STFAX_ESCAPE;
  591. isar_sched_event(bcs, B_LL_NOCARRIER);
  592. }
  593. } else {
  594. printk(KERN_WARNING "HiSax: skb out of memoryn");
  595. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  596. }
  597. break;
  598. }
  599. if (bcs->hw.isar.cmd != PCTRL_CMD_FRH) {
  600. if (cs->debug & L1_DEB_WARN)
  601. debugl1(cs, "isar_rcv_frame: unknown fax mode %x",
  602. bcs->hw.isar.cmd);
  603. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  604. bcs->hw.isar.rcvidx = 0;
  605. break;
  606. }
  607. /* PCTRL_CMD_FRH */
  608. if ((bcs->hw.isar.rcvidx + ireg->clsb) > HSCX_BUFMAX) {
  609. if (cs->debug & L1_DEB_WARN)
  610. debugl1(cs, "isar_rcv_frame: incoming packet too large");
  611. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  612. bcs->hw.isar.rcvidx = 0;
  613. } else if (ireg->cmsb & HDLC_ERROR) {
  614. if (cs->debug & L1_DEB_WARN)
  615. debugl1(cs, "isar frame error %x len %d",
  616. ireg->cmsb, ireg->clsb);
  617. bcs->hw.isar.rcvidx = 0;
  618. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  619. } else {
  620. if (ireg->cmsb & HDLC_FSD)
  621. bcs->hw.isar.rcvidx = 0;
  622. ptr = bcs->hw.isar.rcvbuf + bcs->hw.isar.rcvidx;
  623. bcs->hw.isar.rcvidx += ireg->clsb;
  624. rcv_mbox(cs, ireg, ptr);
  625. if (ireg->cmsb & HDLC_FED) {
  626. int len = bcs->hw.isar.rcvidx +
  627. dle_count(bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx);
  628. if (bcs->hw.isar.rcvidx < 3) { /* last 2 bytes are the FCS */
  629. if (cs->debug & L1_DEB_WARN)
  630. debugl1(cs, "isar frame to short %d",
  631. bcs->hw.isar.rcvidx);
  632. } else if (!(skb = dev_alloc_skb(bcs->hw.isar.rcvidx))) {
  633. printk(KERN_WARNING "ISAR: receive out of memoryn");
  634. } else {
  635. insert_dle((u_char *)skb_put(skb, len),
  636. bcs->hw.isar.rcvbuf,
  637. bcs->hw.isar.rcvidx);
  638. skb_queue_tail(&bcs->rqueue, skb);
  639. isar_sched_event(bcs, B_RCVBUFREADY);
  640. send_DLE_ETX(bcs);
  641. isar_sched_event(bcs, B_LL_OK);
  642. }
  643. bcs->hw.isar.rcvidx = 0;
  644. }
  645. }
  646. if (ireg->cmsb & SART_NMD) { /* ABORT */
  647. if (cs->debug & L1_DEB_WARN)
  648. debugl1(cs, "isar_rcv_frame: no more data");
  649. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  650. bcs->hw.isar.rcvidx = 0;
  651. send_DLE_ETX(bcs);
  652. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) |
  653. ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 0, NULL);
  654. bcs->hw.isar.state = STFAX_ESCAPE;
  655. isar_sched_event(bcs, B_LL_NOCARRIER);
  656. }
  657. break;
  658. default:
  659. printk(KERN_ERR"isar_rcv_frame mode (%x)errorn", bcs->mode);
  660. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  661. break;
  662. }
  663. }
  665. void
  666. isar_fill_fifo(struct BCState *bcs)
  667. {
  668. struct IsdnCardState *cs = bcs->cs;
  669. int count;
  670. u_char msb;
  671. u_char *ptr;
  672. long flags;
  674. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  675. debugl1(cs, "isar_fill_fifo");
  676. if (!bcs->tx_skb)
  677. return;
  678. if (bcs->tx_skb->len <= 0)
  679. return;
  680. if (!(bcs->hw.isar.reg->bstat & 
  681. (bcs->hw.isar.dpath == 1 ? BSTAT_RDM1 : BSTAT_RDM2)))
  682. return;
  683. if (bcs->tx_skb->len > bcs->hw.isar.mml) {
  684. msb = 0;
  685. count = bcs->hw.isar.mml;
  686. } else {
  687. count = bcs->tx_skb->len;
  688. msb = HDLC_FED;
  689. }
  690. save_flags(flags);
  691. cli();
  692. ptr = bcs->tx_skb->data;
  693. if (!bcs->hw.isar.txcnt) {
  694. msb |= HDLC_FST;
  695. if ((bcs->mode == L1_MODE_FAX) &&
  696. (bcs->hw.isar.cmd == PCTRL_CMD_FTH)) {
  697. if (bcs->tx_skb->len > 1) {
  698. if ((ptr[0]== 0xff) && (ptr[1] == 0x13))
  699. /* last frame */
  700. test_and_set_bit(BC_FLG_LASTDATA,
  701. &bcs->Flag);
  702. }  
  703. }
  704. }
  705. skb_pull(bcs->tx_skb, count);
  706. bcs->tx_cnt -= count;
  707. bcs->hw.isar.txcnt += count;
  708. switch (bcs->mode) {
  709. case L1_MODE_NULL:
  710. printk(KERN_ERR"isar_fill_fifo wrong mode 0n");
  711. break;
  712. case L1_MODE_TRANS:
  713. case L1_MODE_V32:
  714. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
  715. 0, count, ptr);
  716. break;
  717. case L1_MODE_HDLC:
  718. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
  719. msb, count, ptr);
  720. break;
  721. case L1_MODE_FAX:
  722. if (bcs->hw.isar.state != STFAX_ACTIV) {
  723. if (cs->debug & L1_DEB_WARN)
  724. debugl1(cs, "isar_fill_fifo: not ACTIV");
  725. } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) { 
  726. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
  727. msb, count, ptr);
  728. } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTM) {
  729. sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
  730. 0, count, ptr);
  731. } else {
  732. if (cs->debug & L1_DEB_WARN)
  733. debugl1(cs, "isar_fill_fifo: not FTH/FTM");
  734. }
  735. break;
  736. default:
  737. if (cs->debug)
  738. debugl1(cs, "isar_fill_fifo mode(%x) error", bcs->mode);
  739. printk(KERN_ERR"isar_fill_fifo mode(%x) errorn", bcs->mode);
  740. break;
  741. }
  742. restore_flags(flags);
  743. }
  745. inline
  746. struct BCState *sel_bcs_isar(struct IsdnCardState *cs, u_char dpath)
  747. {
  748. if ((!dpath) || (dpath == 3))
  749. return(NULL);
  750. if (cs->bcs[0].hw.isar.dpath == dpath)
  751. return(&cs->bcs[0]);
  752. if (cs->bcs[1].hw.isar.dpath == dpath)
  753. return(&cs->bcs[1]);
  754. return(NULL);
  755. }
  757. inline void
  758. send_frames(struct BCState *bcs)
  759. {
  760. if (bcs->tx_skb) {
  761. if (bcs->tx_skb->len) {
  762. isar_fill_fifo(bcs);
  763. return;
  764. } else {
  765. if (bcs->st->lli.l1writewakeup &&
  766. (PACKET_NOACK != bcs->tx_skb->pkt_type))
  767. bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.isar.txcnt);
  768. if (bcs->mode == L1_MODE_FAX) {
  769. if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) {
  770. if (test_bit(BC_FLG_LASTDATA, &bcs->Flag)) {
  771. test_and_set_bit(BC_FLG_NMD_DATA, &bcs->Flag);
  772. }
  773. } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTM) {
  774. if (test_bit(BC_FLG_DLEETX, &bcs->Flag)) {
  775. test_and_set_bit(BC_FLG_LASTDATA, &bcs->Flag);
  776. test_and_set_bit(BC_FLG_NMD_DATA, &bcs->Flag);
  777. }
  778. }
  779. }
  780. dev_kfree_skb_any(bcs->tx_skb);
  781. bcs->hw.isar.txcnt = 0; 
  782. bcs->tx_skb = NULL;
  783. }
  784. }
  785. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  786. bcs->hw.isar.txcnt = 0;
  787. test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
  788. isar_fill_fifo(bcs);
  789. } else {
  790. if (test_and_clear_bit(BC_FLG_DLEETX, &bcs->Flag)) {
  791. if (test_and_clear_bit(BC_FLG_LASTDATA, &bcs->Flag)) {
  792. if (test_and_clear_bit(BC_FLG_NMD_DATA, &bcs->Flag)) {
  793. u_char dummy = 0;
  794. sendmsg(bcs->cs, SET_DPS(bcs->hw.isar.dpath) |
  795. ISAR_HIS_SDATA, 0x01, 1, &dummy);
  796. }
  797. test_and_set_bit(BC_FLG_LL_OK, &bcs->Flag);
  798. } else {
  799. isar_sched_event(bcs, B_LL_CONNECT);
  800. }
  801. }
  802. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  803. isar_sched_event(bcs, B_XMTBUFREADY);
  804. }
  805. }
  807. inline void
  808. check_send(struct IsdnCardState *cs, u_char rdm)
  809. {
  810. struct BCState *bcs;
  812. if (rdm & BSTAT_RDM1) {
  813. if ((bcs = sel_bcs_isar(cs, 1))) {
  814. if (bcs->mode) {
  815. send_frames(bcs);
  816. }
  817. }
  818. }
  819. if (rdm & BSTAT_RDM2) {
  820. if ((bcs = sel_bcs_isar(cs, 2))) {
  821. if (bcs->mode) {
  822. send_frames(bcs);
  823. }
  824. }
  825. }
  827. }
  829. const char *dmril[] = {"NO SPEED", "1200/75", "NODEF2", "75/1200", "NODEF4",
  830. "300", "600", "1200", "2400", "4800", "7200",
  831. "9600nt", "9600t", "12000", "14400", "WRONG"};
  832. const char *dmrim[] = {"NO MOD", "NO DEF", "V32/V32b", "V22", "V21",
  833. "Bell103", "V23", "Bell202", "V17", "V29", "V27ter"};
  835. static void
  836. isar_pump_status_rsp(struct BCState *bcs, struct isar_reg *ireg) {
  837. struct IsdnCardState *cs = bcs->cs;
  838. u_char ril = ireg->par[0];
  839. u_char rim;
  841. if (!test_and_clear_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags))
  842. return; 
  843. if (ril > 14) {
  844. if (cs->debug & L1_DEB_WARN)
  845. debugl1(cs, "wrong pstrsp ril=%d",ril);
  846. ril = 15;
  847. }
  848. switch(ireg->par[1]) {
  849. case 0:
  850. rim = 0;
  851. break;
  852. case 0x20:
  853. rim = 2;
  854. break;
  855. case 0x40:
  856. rim = 3;
  857. break;
  858. case 0x41:
  859. rim = 4;
  860. break;
  861. case 0x51:
  862. rim = 5;
  863. break;
  864. case 0x61:
  865. rim = 6;
  866. break;
  867. case 0x71:
  868. rim = 7;
  869. break;
  870. case 0x82:
  871. rim = 8;
  872. break;
  873. case 0x92:
  874. rim = 9;
  875. break;
  876. case 0xa2:
  877. rim = 10;
  878. break;
  879. default:
  880. rim = 1;
  881. break;
  882. }
  883. sprintf(bcs->hw.isar.conmsg,"%s %s", dmril[ril], dmrim[rim]);
  884. bcs->conmsg = bcs->hw.isar.conmsg;
  885. if (cs->debug & L1_DEB_HSCX)
  886. debugl1(cs, "pump strsp %s", bcs->conmsg);
  887. }
  889. static void
  890. isar_pump_statev_modem(struct BCState *bcs, u_char devt) {
  891. struct IsdnCardState *cs = bcs->cs;
  892. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  894. switch(devt) {
  895. case PSEV_10MS_TIMER:
  896. if (cs->debug & L1_DEB_HSCX)
  897. debugl1(cs, "pump stev TIMER");
  898. break;
  899. case PSEV_CON_ON:
  900. if (cs->debug & L1_DEB_HSCX)
  901. debugl1(cs, "pump stev CONNECT");
  902. l1_msg_b(bcs->st, PH_ACTIVATE | REQUEST, NULL);
  903. break;
  904. case PSEV_CON_OFF:
  905. if (cs->debug & L1_DEB_HSCX)
  906. debugl1(cs, "pump stev NO CONNECT");
  907. sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
  908. l1_msg_b(bcs->st, PH_DEACTIVATE | REQUEST, NULL);
  909. break;
  910. case PSEV_V24_OFF:
  911. if (cs->debug & L1_DEB_HSCX)
  912. debugl1(cs, "pump stev V24 OFF");
  913. break;
  914. case PSEV_CTS_ON:
  915. if (cs->debug & L1_DEB_HSCX)
  916. debugl1(cs, "pump stev CTS ON");
  917. break;
  918. case PSEV_CTS_OFF:
  919. if (cs->debug & L1_DEB_HSCX)
  920. debugl1(cs, "pump stev CTS OFF");
  921. break;
  922. case PSEV_DCD_ON:
  923. if (cs->debug & L1_DEB_HSCX)
  924. debugl1(cs, "pump stev CARRIER ON");
  925. test_and_set_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags); 
  926. sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
  927. break;
  928. case PSEV_DCD_OFF:
  929. if (cs->debug & L1_DEB_HSCX)
  930. debugl1(cs, "pump stev CARRIER OFF");
  931. break;
  932. case PSEV_DSR_ON:
  933. if (cs->debug & L1_DEB_HSCX)
  934. debugl1(cs, "pump stev DSR ON");
  935. break;
  936. case PSEV_DSR_OFF:
  937. if (cs->debug & L1_DEB_HSCX)
  938. debugl1(cs, "pump stev DSR_OFF");
  939. break;
  940. case PSEV_REM_RET:
  941. if (cs->debug & L1_DEB_HSCX)
  942. debugl1(cs, "pump stev REMOTE RETRAIN");
  943. break;
  944. case PSEV_REM_REN:
  945. if (cs->debug & L1_DEB_HSCX)
  946. debugl1(cs, "pump stev REMOTE RENEGOTIATE");
  947. break;
  948. case PSEV_GSTN_CLR:
  949. if (cs->debug & L1_DEB_HSCX)
  950. debugl1(cs, "pump stev GSTN CLEAR", devt);
  951. break;
  952. default:
  953. if (cs->debug & L1_DEB_HSCX)
  954. debugl1(cs, "unknown pump stev %x", devt);
  955. break;
  956. }
  957. }
  959. static inline void
  960. ll_deliver_faxstat(struct BCState *bcs, u_char status)
  961. {
  962.         isdn_ctrl ic;
  963. struct Channel *chanp = (struct Channel *) bcs->st->lli.userdata;
  964.  
  965. if (bcs->cs->debug & L1_DEB_HSCX)
  966. debugl1(bcs->cs, "HL->LL FAXIND %x", status);
  967. ic.driver = bcs->cs->myid;
  968. ic.command = ISDN_STAT_FAXIND;
  969. ic.arg = chanp->chan;
  970. ic.parm.aux.cmd = status;
  971. bcs->cs->iif.statcallb(&ic);
  972. }
  974. static void
  975. isar_pump_statev_fax(struct BCState *bcs, u_char devt) {
  976. struct IsdnCardState *cs = bcs->cs;
  977. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  978. u_char p1;
  980. switch(devt) {
  981. case PSEV_10MS_TIMER:
  982. if (cs->debug & L1_DEB_HSCX)
  983. debugl1(cs, "pump stev TIMER");
  984. break;
  985. case PSEV_RSP_READY:
  986. if (cs->debug & L1_DEB_HSCX)
  987. debugl1(cs, "pump stev RSP_READY");
  988. bcs->hw.isar.state = STFAX_READY;
  989. l1_msg_b(bcs->st, PH_ACTIVATE | REQUEST, NULL);
  990. if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
  991. isar_pump_cmd(bcs, ISDN_FAX_CLASS1_FRH, 3);
  992. } else {
  993. isar_pump_cmd(bcs, ISDN_FAX_CLASS1_FTH, 3);
  994. }
  995. break;
  996. case PSEV_LINE_TX_H:
  997. if (bcs->hw.isar.state == STFAX_LINE) {
  998. if (cs->debug & L1_DEB_HSCX)
  999. debugl1(cs, "pump stev LINE_TX_H");
  1000. bcs->hw.isar.state = STFAX_CONT;
  1001. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
  1002. } else {
  1003. if (cs->debug & L1_DEB_WARN)
  1004. debugl1(cs, "pump stev LINE_TX_H wrong st %x",
  1005. bcs->hw.isar.state);
  1006. }
  1007. break;
  1008. case PSEV_LINE_RX_H:
  1009. if (bcs->hw.isar.state == STFAX_LINE) {
  1010. if (cs->debug & L1_DEB_HSCX)
  1011. debugl1(cs, "pump stev LINE_RX_H");
  1012. bcs->hw.isar.state = STFAX_CONT;
  1013. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
  1014. } else {
  1015. if (cs->debug & L1_DEB_WARN)
  1016. debugl1(cs, "pump stev LINE_RX_H wrong st %x",
  1017. bcs->hw.isar.state);
  1018. }
  1019. break;
  1020. case PSEV_LINE_TX_B:
  1021. if (bcs->hw.isar.state == STFAX_LINE) {
  1022. if (cs->debug & L1_DEB_HSCX)
  1023. debugl1(cs, "pump stev LINE_TX_B");
  1024. bcs->hw.isar.state = STFAX_CONT;
  1025. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
  1026. } else {
  1027. if (cs->debug & L1_DEB_WARN)
  1028. debugl1(cs, "pump stev LINE_TX_B wrong st %x",
  1029. bcs->hw.isar.state);
  1030. }
  1031. break;
  1032. case PSEV_LINE_RX_B:
  1033. if (bcs->hw.isar.state == STFAX_LINE) {
  1034. if (cs->debug & L1_DEB_HSCX)
  1035. debugl1(cs, "pump stev LINE_RX_B");
  1036. bcs->hw.isar.state = STFAX_CONT;
  1037. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
  1038. } else {
  1039. if (cs->debug & L1_DEB_WARN)
  1040. debugl1(cs, "pump stev LINE_RX_B wrong st %x",
  1041. bcs->hw.isar.state);
  1042. }
  1043. break;
  1044. case PSEV_RSP_CONN:
  1045. if (bcs->hw.isar.state == STFAX_CONT) {
  1046. if (cs->debug & L1_DEB_HSCX)
  1047. debugl1(cs, "pump stev RSP_CONN");
  1048. bcs->hw.isar.state = STFAX_ACTIV;
  1049. test_and_set_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags);
  1050. sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
  1051. if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) {
  1052. /* 1s Flags before data */
  1053. if (test_and_set_bit(BC_FLG_FTI_RUN, &bcs->Flag))
  1054. del_timer(&bcs->hw.isar.ftimer);
  1055. /* 1000 ms */
  1056. bcs->hw.isar.ftimer.expires =
  1057. jiffies + ((1000 * HZ)/1000);
  1058. test_and_set_bit(BC_FLG_LL_CONN,
  1059. &bcs->Flag);
  1060. add_timer(&bcs->hw.isar.ftimer);
  1061. } else {
  1062. isar_sched_event(bcs, B_LL_CONNECT);
  1063. }
  1064. } else {
  1065. if (cs->debug & L1_DEB_WARN)
  1066. debugl1(cs, "pump stev RSP_CONN wrong st %x",
  1067. bcs->hw.isar.state);
  1068. }
  1069. break;
  1070. case PSEV_FLAGS_DET:
  1071. if (cs->debug & L1_DEB_HSCX)
  1072. debugl1(cs, "pump stev FLAGS_DET");
  1073. break;
  1074. case PSEV_RSP_DISC:
  1075. if (cs->debug & L1_DEB_HSCX)
  1076. debugl1(cs, "pump stev RSP_DISC");
  1077. if (bcs->hw.isar.state == STFAX_ESCAPE) {
  1078. switch(bcs->hw.isar.newcmd) {
  1079. case 0:
  1080. bcs->hw.isar.state = STFAX_READY;
  1081. break;
  1082. case PCTRL_CMD_FTH:
  1083. case PCTRL_CMD_FTM:
  1084. p1 = 10;
  1085. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
  1086. PCTRL_CMD_SILON, 1, &p1);
  1087. bcs->hw.isar.state = STFAX_SILDET;
  1088. break;
  1089. case PCTRL_CMD_FRH:
  1090. case PCTRL_CMD_FRM:
  1091. p1 = bcs->hw.isar.mod = bcs->hw.isar.newmod;
  1092. bcs->hw.isar.newmod = 0;
  1093. bcs->hw.isar.cmd = bcs->hw.isar.newcmd;
  1094. bcs->hw.isar.newcmd = 0;
  1095. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
  1096. bcs->hw.isar.cmd, 1, &p1);
  1097. bcs->hw.isar.state = STFAX_LINE;
  1098. bcs->hw.isar.try_mod = 3;
  1099. break;
  1100. default:
  1101. if (cs->debug & L1_DEB_HSCX)
  1102. debugl1(cs, "RSP_DISC unknown newcmd %x", bcs->hw.isar.newcmd);
  1103. break;
  1104. }
  1105. } else if (bcs->hw.isar.state == STFAX_ACTIV) {
  1106. if (test_and_clear_bit(BC_FLG_LL_OK, &bcs->Flag)) {
  1107. isar_sched_event(bcs, B_LL_OK);
  1108. } else if (bcs->hw.isar.cmd == PCTRL_CMD_FRM) {
  1109. send_DLE_ETX(bcs);
  1110. isar_sched_event(bcs, B_LL_NOCARRIER);
  1111. } else {
  1112. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
  1113. }
  1114. bcs->hw.isar.state = STFAX_READY;
  1115. } else {
  1116. bcs->hw.isar.state = STFAX_READY;
  1117. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
  1118. }
  1119. break;
  1120. case PSEV_RSP_SILDET:
  1121. if (cs->debug & L1_DEB_HSCX)
  1122. debugl1(cs, "pump stev RSP_SILDET");
  1123. if (bcs->hw.isar.state == STFAX_SILDET) {
  1124. p1 = bcs->hw.isar.mod = bcs->hw.isar.newmod;
  1125. bcs->hw.isar.newmod = 0;
  1126. bcs->hw.isar.cmd = bcs->hw.isar.newcmd;
  1127. bcs->hw.isar.newcmd = 0;
  1128. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
  1129. bcs->hw.isar.cmd, 1, &p1);
  1130. bcs->hw.isar.state = STFAX_LINE;
  1131. bcs->hw.isar.try_mod = 3;
  1132. }
  1133. break;
  1134. case PSEV_RSP_SILOFF:
  1135. if (cs->debug & L1_DEB_HSCX)
  1136. debugl1(cs, "pump stev RSP_SILOFF");
  1137. break;
  1138. case PSEV_RSP_FCERR:
  1139. if (bcs->hw.isar.state == STFAX_LINE) {
  1140. if (cs->debug & L1_DEB_HSCX)
  1141. debugl1(cs, "pump stev RSP_FCERR try %d",
  1142. bcs->hw.isar.try_mod);
  1143. if (bcs->hw.isar.try_mod--) {
  1144. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
  1145. bcs->hw.isar.cmd, 1,
  1146. &bcs->hw.isar.mod);
  1147. break;
  1148. }
  1149. }
  1150. if (cs->debug & L1_DEB_HSCX)
  1151. debugl1(cs, "pump stev RSP_FCERR");
  1152. bcs->hw.isar.state = STFAX_ESCAPE;
  1153. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 0, NULL);
  1154. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
  1155. break;
  1156. default:
  1157. break;
  1158. }
  1159. }
  1161. static char debbuf[128];
  1163. void
  1164. isar_int_main(struct IsdnCardState *cs)
  1165. {
  1166. long flags;
  1167. struct isar_reg *ireg = cs->bcs[0].hw.isar.reg;
  1168. struct BCState *bcs;
  1170. save_flags(flags);
  1171. cli();
  1172. get_irq_infos(cs, ireg);
  1173. switch (ireg->iis & ISAR_IIS_MSCMSD) {
  1174. case ISAR_IIS_RDATA:
  1175. if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
  1176. isar_rcv_frame(cs, bcs);
  1177. } else {
  1178. debugl1(cs, "isar spurious IIS_RDATA %x/%x/%x",
  1179. ireg->iis, ireg->cmsb, ireg->clsb);
  1180. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  1181. }
  1182. break;
  1183. case ISAR_IIS_GSTEV:
  1184. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  1185. ireg->bstat |= ireg->cmsb;
  1186. check_send(cs, ireg->cmsb);
  1187. break;
  1188. case ISAR_IIS_BSTEV:
  1189. #ifdef ERROR_STATISTIC
  1190. if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
  1191. if (ireg->cmsb == BSTEV_TBO)
  1192. bcs->err_tx++;
  1193. if (ireg->cmsb == BSTEV_RBO)
  1194. bcs->err_rdo++;
  1195. }
  1196. #endif
  1197. if (cs->debug & L1_DEB_WARN)
  1198. debugl1(cs, "Buffer STEV dpath%d msb(%x)",
  1199. ireg->iis>>6, ireg->cmsb);
  1200. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  1201. break;
  1202. case ISAR_IIS_PSTEV:
  1203. if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
  1204. rcv_mbox(cs, ireg, (u_char *)ireg->par);
  1205. if (bcs->mode == L1_MODE_V32) {
  1206. isar_pump_statev_modem(bcs, ireg->cmsb);
  1207. } else if (bcs->mode == L1_MODE_FAX) {
  1208. isar_pump_statev_fax(bcs, ireg->cmsb);
  1209. } else {
  1210. if (cs->debug & L1_DEB_WARN)
  1211. debugl1(cs, "isar IIS_PSTEV pmode %d stat %x",
  1212. bcs->mode, ireg->cmsb);
  1213. }
  1214. } else {
  1215. debugl1(cs, "isar spurious IIS_PSTEV %x/%x/%x",
  1216. ireg->iis, ireg->cmsb, ireg->clsb);
  1217. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  1218. }
  1219. break;
  1220. case ISAR_IIS_PSTRSP:
  1221. if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
  1222. rcv_mbox(cs, ireg, (u_char *)ireg->par);
  1223. isar_pump_status_rsp(bcs, ireg);
  1224. } else {
  1225. debugl1(cs, "isar spurious IIS_PSTRSP %x/%x/%x",
  1226. ireg->iis, ireg->cmsb, ireg->clsb);
  1227. cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
  1228. }
  1229. break;
  1230. case ISAR_IIS_DIAG:
  1231. case ISAR_IIS_BSTRSP:
  1232. case ISAR_IIS_IOM2RSP:
  1233. rcv_mbox(cs, ireg, (u_char *)ireg->par);
  1234. if ((cs->debug & (L1_DEB_HSCX | L1_DEB_HSCX_FIFO))
  1235. == L1_DEB_HSCX) {
  1236. u_char *tp=debbuf;
  1238. tp += sprintf(debbuf, "msg iis(%x) msb(%x)",
  1239. ireg->iis, ireg->cmsb);
  1240. QuickHex(tp, (u_char *)ireg->par, ireg->clsb);
  1241. debugl1(cs, debbuf);
  1242. }
  1243. break;
  1244. case ISAR_IIS_INVMSG:
  1245. rcv_mbox(cs, ireg, debbuf);
  1246. if (cs->debug & L1_DEB_WARN)
  1247. debugl1(cs, "invalid msg his:%x",
  1248. ireg->cmsb);
  1249. break;
  1250. default:
  1251. rcv_mbox(cs, ireg, debbuf);
  1252. if (cs->debug & L1_DEB_WARN)
  1253. debugl1(cs, "unhandled msg iis(%x) ctrl(%x/%x)",
  1254. ireg->iis, ireg->cmsb, ireg->clsb);
  1255. break;
  1256. }
  1257. restore_flags(flags);
  1258. }
  1260. static void
  1261. ftimer_handler(struct BCState *bcs) {
  1262. if (bcs->cs->debug)
  1263. debugl1(bcs->cs, "ftimer flags %04x",
  1264. bcs->Flag);
  1265. test_and_clear_bit(BC_FLG_FTI_RUN, &bcs->Flag);
  1266. if (test_and_clear_bit(BC_FLG_LL_CONN, &bcs->Flag)) {
  1267. isar_sched_event(bcs, B_LL_CONNECT);
  1268. }
  1269. }
  1271. static void
  1272. setup_pump(struct BCState *bcs) {
  1273. struct IsdnCardState *cs = bcs->cs;
  1274. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  1275. u_char ctrl, param[6];
  1277. switch (bcs->mode) {
  1278. case L1_MODE_NULL:
  1279. case L1_MODE_TRANS:
  1280. case L1_MODE_HDLC:
  1281. sendmsg(cs, dps | ISAR_HIS_PUMPCFG, PMOD_BYPASS, 0, NULL);
  1282. break;
  1283. case L1_MODE_V32:
  1284. ctrl = PMOD_DATAMODEM;
  1285. if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
  1286. ctrl |= PCTRL_ORIG;
  1287. param[5] = PV32P6_CTN;
  1288. } else {
  1289. param[5] = PV32P6_ATN;
  1290. }
  1291. param[0] = 6; /* 6 db */
  1292. param[1] = PV32P2_V23R | PV32P2_V22A | PV32P2_V22B |
  1293.    PV32P2_V22C | PV32P2_V21 | PV32P2_BEL; 
  1294. param[2] = PV32P3_AMOD | PV32P3_V32B | PV32P3_V23B;
  1295. param[3] = PV32P4_UT144;
  1296. param[4] = PV32P5_UT144;
  1297. sendmsg(cs, dps | ISAR_HIS_PUMPCFG, ctrl, 6, param);
  1298. break;
  1299. case L1_MODE_FAX:
  1300. ctrl = PMOD_FAX;
  1301. if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
  1302. ctrl |= PCTRL_ORIG;
  1303. param[1] = PFAXP2_CTN;
  1304. } else {
  1305. param[1] = PFAXP2_ATN;
  1306. }
  1307. param[0] = 6; /* 6 db */
  1308. sendmsg(cs, dps | ISAR_HIS_PUMPCFG, ctrl, 2, param);
  1309. bcs->hw.isar.state = STFAX_NULL;
  1310. bcs->hw.isar.newcmd = 0;
  1311. bcs->hw.isar.newmod = 0;
  1312. test_and_set_bit(BC_FLG_FTI_RUN, &bcs->Flag);
  1313. break;
  1314. }
  1315. udelay(1000);
  1316. sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
  1317. udelay(1000);
  1318. }
  1320. static void
  1321. setup_sart(struct BCState *bcs) {
  1322. struct IsdnCardState *cs = bcs->cs;
  1323. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  1324. u_char ctrl, param[2];
  1326. switch (bcs->mode) {
  1327. case L1_MODE_NULL:
  1328. sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_DISABLE, 0,
  1329. NULL);
  1330. break;
  1331. case L1_MODE_TRANS:
  1332. sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_BINARY, 2,
  1333. "");
  1334. break;
  1335. case L1_MODE_HDLC:
  1336. case L1_MODE_FAX:
  1337. param[0] = 0;
  1338. sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_HDLC, 1,
  1339. param);
  1340. break;
  1341. case L1_MODE_V32:
  1342. ctrl = SMODE_V14 | SCTRL_HDMC_BOTH;
  1343. param[0] = S_P1_CHS_8;
  1344. param[1] = S_P2_BFT_DEF;
  1345. sendmsg(cs, dps | ISAR_HIS_SARTCFG, ctrl, 2,
  1346. param);
  1347. break;
  1348. }
  1349. udelay(1000);
  1350. sendmsg(cs, dps | ISAR_HIS_BSTREQ, 0, 0, NULL);
  1351. udelay(1000);
  1352. }
  1354. static void
  1355. setup_iom2(struct BCState *bcs) {
  1356. struct IsdnCardState *cs = bcs->cs;
  1357. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  1358. u_char cmsb = IOM_CTRL_ENA, msg[5] = {IOM_P1_TXD,0,0,0,0};
  1360. if (bcs->channel)
  1361. msg[1] = msg[3] = 1;
  1362. switch (bcs->mode) {
  1363. case L1_MODE_NULL:
  1364. cmsb = 0;
  1365. /* dummy slot */
  1366. msg[1] = msg[3] = bcs->hw.isar.dpath + 2;
  1367. break;
  1368. case L1_MODE_TRANS:
  1369. case L1_MODE_HDLC:
  1370. break;
  1371. case L1_MODE_V32:
  1372. case L1_MODE_FAX:
  1373. cmsb |= IOM_CTRL_ALAW | IOM_CTRL_RCV;
  1374. break;
  1375. }
  1376. sendmsg(cs, dps | ISAR_HIS_IOM2CFG, cmsb, 5, msg);
  1377. udelay(1000);
  1378. sendmsg(cs, dps | ISAR_HIS_IOM2REQ, 0, 0, NULL);
  1379. udelay(1000);
  1380. }
  1382. int
  1383. modeisar(struct BCState *bcs, int mode, int bc)
  1384. {
  1385. struct IsdnCardState *cs = bcs->cs;
  1387. /* Here we are selecting the best datapath for requested mode */
  1388. if(bcs->mode == L1_MODE_NULL) { /* New Setup */
  1389. bcs->channel = bc;
  1390. switch (mode) {
  1391. case L1_MODE_NULL: /* init */
  1392. if (!bcs->hw.isar.dpath)
  1393. /* no init for dpath 0 */
  1394. return(0);
  1395. break;
  1396. case L1_MODE_TRANS:
  1397. case L1_MODE_HDLC:
  1398. /* best is datapath 2 */
  1399. if (!test_and_set_bit(ISAR_DP2_USE, 
  1400. &bcs->hw.isar.reg->Flags))
  1401. bcs->hw.isar.dpath = 2;
  1402. else if (!test_and_set_bit(ISAR_DP1_USE,
  1403. &bcs->hw.isar.reg->Flags))
  1404. bcs->hw.isar.dpath = 1;
  1405. else {
  1406. printk(KERN_WARNING"isar modeisar both pathes in usen");
  1407. return(1);
  1408. }
  1409. break;
  1410. case L1_MODE_V32:
  1411. case L1_MODE_FAX:
  1412. /* only datapath 1 */
  1413. if (!test_and_set_bit(ISAR_DP1_USE, 
  1414. &bcs->hw.isar.reg->Flags))
  1415. bcs->hw.isar.dpath = 1;
  1416. else {
  1417. printk(KERN_WARNING"isar modeisar analog funktions only with DP1n");
  1418. debugl1(cs, "isar modeisar analog funktions only with DP1");
  1419. return(1);
  1420. }
  1421. break;
  1422. }
  1423. }
  1424. if (cs->debug & L1_DEB_HSCX)
  1425. debugl1(cs, "isar dp%d mode %d->%d ichan %d",
  1426. bcs->hw.isar.dpath, bcs->mode, mode, bc);
  1427. bcs->mode = mode;
  1428. setup_pump(bcs);
  1429. setup_iom2(bcs);
  1430. setup_sart(bcs);
  1431. if (bcs->mode == L1_MODE_NULL) {
  1432. /* Clear resources */
  1433. if (bcs->hw.isar.dpath == 1)
  1434. test_and_clear_bit(ISAR_DP1_USE, &bcs->hw.isar.reg->Flags);
  1435. else if (bcs->hw.isar.dpath == 2)
  1436. test_and_clear_bit(ISAR_DP2_USE, &bcs->hw.isar.reg->Flags);
  1437. bcs->hw.isar.dpath = 0;
  1438. }
  1439. return(0);
  1440. }
  1442. static void
  1443. isar_pump_cmd(struct BCState *bcs, u_char cmd, u_char para) 
  1444. {
  1445. struct IsdnCardState *cs = bcs->cs;
  1446. u_char dps = SET_DPS(bcs->hw.isar.dpath);
  1447. u_char ctrl = 0, nom = 0, p1 = 0;
  1449. switch(cmd) {
  1450. case ISDN_FAX_CLASS1_FTM:
  1451. if (bcs->hw.isar.state == STFAX_READY) {
  1452. p1 = para;
  1453. ctrl = PCTRL_CMD_FTM;
  1454. nom = 1;
  1455. bcs->hw.isar.state = STFAX_LINE;
  1456. bcs->hw.isar.cmd = ctrl;
  1457. bcs->hw.isar.mod = para;
  1458. bcs->hw.isar.newmod = 0;
  1459. bcs->hw.isar.newcmd = 0;
  1460. bcs->hw.isar.try_mod = 3; 
  1461. } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
  1462. (bcs->hw.isar.cmd == PCTRL_CMD_FTM) &&
  1463. (bcs->hw.isar.mod == para)) {
  1464. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
  1465. } else {
  1466. bcs->hw.isar.newmod = para;
  1467. bcs->hw.isar.newcmd = PCTRL_CMD_FTM;
  1468. nom = 0;
  1469. ctrl = PCTRL_CMD_ESC;
  1470. bcs->hw.isar.state = STFAX_ESCAPE; 
  1471. }
  1472. break;
  1473. case ISDN_FAX_CLASS1_FTH:
  1474. if (bcs->hw.isar.state == STFAX_READY) {
  1475. p1 = para;
  1476. ctrl = PCTRL_CMD_FTH;
  1477. nom = 1;
  1478. bcs->hw.isar.state = STFAX_LINE;
  1479. bcs->hw.isar.cmd = ctrl;
  1480. bcs->hw.isar.mod = para;
  1481. bcs->hw.isar.newmod = 0;
  1482. bcs->hw.isar.newcmd = 0;
  1483. bcs->hw.isar.try_mod = 3; 
  1484. } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
  1485. (bcs->hw.isar.cmd == PCTRL_CMD_FTH) &&
  1486. (bcs->hw.isar.mod == para)) {
  1487. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
  1488. } else {
  1489. bcs->hw.isar.newmod = para;
  1490. bcs->hw.isar.newcmd = PCTRL_CMD_FTH;
  1491. nom = 0;
  1492. ctrl = PCTRL_CMD_ESC;
  1493. bcs->hw.isar.state = STFAX_ESCAPE; 
  1494. }
  1495. break;
  1496. case ISDN_FAX_CLASS1_FRM:
  1497. if (bcs->hw.isar.state == STFAX_READY) {
  1498. p1 = para;
  1499. ctrl = PCTRL_CMD_FRM;
  1500. nom = 1;
  1501. bcs->hw.isar.state = STFAX_LINE;
  1502. bcs->hw.isar.cmd = ctrl;
  1503. bcs->hw.isar.mod = para;
  1504. bcs->hw.isar.newmod = 0;
  1505. bcs->hw.isar.newcmd = 0;
  1506. bcs->hw.isar.try_mod = 3; 
  1507. } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
  1508. (bcs->hw.isar.cmd == PCTRL_CMD_FRM) &&
  1509. (bcs->hw.isar.mod == para)) {
  1510. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
  1511. } else {
  1512. bcs->hw.isar.newmod = para;
  1513. bcs->hw.isar.newcmd = PCTRL_CMD_FRM;
  1514. nom = 0;
  1515. ctrl = PCTRL_CMD_ESC;
  1516. bcs->hw.isar.state = STFAX_ESCAPE; 
  1517. }
  1518. break;
  1519. case ISDN_FAX_CLASS1_FRH:
  1520. if (bcs->hw.isar.state == STFAX_READY) {
  1521. p1 = para;
  1522. ctrl = PCTRL_CMD_FRH;
  1523. nom = 1;
  1524. bcs->hw.isar.state = STFAX_LINE;
  1525. bcs->hw.isar.cmd = ctrl;
  1526. bcs->hw.isar.mod = para;
  1527. bcs->hw.isar.newmod = 0;
  1528. bcs->hw.isar.newcmd = 0;
  1529. bcs->hw.isar.try_mod = 3; 
  1530. } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
  1531. (bcs->hw.isar.cmd == PCTRL_CMD_FRH) &&
  1532. (bcs->hw.isar.mod == para)) {
  1533. ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
  1534. } else {
  1535. bcs->hw.isar.newmod = para;
  1536. bcs->hw.isar.newcmd = PCTRL_CMD_FRH;
  1537. nom = 0;
  1538. ctrl = PCTRL_CMD_ESC;
  1539. bcs->hw.isar.state = STFAX_ESCAPE; 
  1540. }
  1541. break;
  1542. }
  1543. if (ctrl)
  1544. sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, ctrl, nom, &p1);
  1545. }
  1547. void
  1548. isar_setup(struct IsdnCardState *cs)
  1549. {
  1550. u_char msg;
  1551. int i;
  1553. /* Dpath 1, 2 */
  1554. msg = 61;
  1555. for (i=0; i<2; i++) {
  1556. /* Buffer Config */
  1557. sendmsg(cs, (i ? ISAR_HIS_DPS2 : ISAR_HIS_DPS1) |
  1558. ISAR_HIS_P12CFG, 4, 1, &msg);
  1559. cs->bcs[i].hw.isar.mml = msg;
  1560. cs->bcs[i].mode = 0;
  1561. cs->bcs[i].hw.isar.dpath = i + 1;
  1562. modeisar(&cs->bcs[i], 0, 0);
  1563. cs->bcs[i].tqueue.routine = (void *) (void *) isar_bh;
  1564. }
  1565. }
  1567. void
  1568. isar_l2l1(struct PStack *st, int pr, void *arg)
  1569. {
  1570. struct sk_buff *skb = arg;
  1571. long flags;
  1573. switch (pr) {
  1574. case (PH_DATA | REQUEST):
  1575. save_flags(flags);
  1576. cli();
  1577. if (st->l1.bcs->tx_skb) {
  1578. skb_queue_tail(&st->l1.bcs->squeue, skb);
  1579. restore_flags(flags);
  1580. } else {
  1581. st->l1.bcs->tx_skb = skb;
  1582. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1583. if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
  1584. debugl1(st->l1.bcs->cs, "DRQ set BC_FLG_BUSY");
  1585. st->l1.bcs->hw.isar.txcnt = 0;
  1586. restore_flags(flags);
  1587. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  1588. }
  1589. break;
  1590. case (PH_PULL | INDICATION):
  1591. if (st->l1.bcs->tx_skb) {
  1592. printk(KERN_WARNING "isar_l2l1: this shouldn't happenn");
  1593. break;
  1594. }
  1595. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1596. if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
  1597. debugl1(st->l1.bcs->cs, "PUI set BC_FLG_BUSY");
  1598. st->l1.bcs->tx_skb = skb;
  1599. st->l1.bcs->hw.isar.txcnt = 0;
  1600. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  1601. break;
  1602. case (PH_PULL | REQUEST):
  1603. if (!st->l1.bcs->tx_skb) {
  1604. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1605. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  1606. } else
  1607. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1608. break;
  1609. case (PH_ACTIVATE | REQUEST):
  1610. test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  1611. st->l1.bcs->hw.isar.conmsg[0] = 0;
  1612. if (test_bit(FLG_ORIG, &st->l2.flag))
  1613. test_and_set_bit(BC_FLG_ORIG, &st->l1.bcs->Flag);
  1614. else
  1615. test_and_clear_bit(BC_FLG_ORIG, &st->l1.bcs->Flag);
  1616. switch(st->l1.mode) {
  1617. case L1_MODE_TRANS:
  1618. case L1_MODE_HDLC:
  1619. if (modeisar(st->l1.bcs, st->l1.mode, st->l1.bc))
  1620. l1_msg_b(st, PH_DEACTIVATE | REQUEST, arg);
  1621. else
  1622. l1_msg_b(st, PH_ACTIVATE | REQUEST, arg);
  1623. break;
  1624. case L1_MODE_V32:
  1625. case L1_MODE_FAX:
  1626. if (modeisar(st->l1.bcs, st->l1.mode, st->l1.bc))
  1627. l1_msg_b(st, PH_DEACTIVATE | REQUEST, arg);
  1628. break;
  1629. }
  1630. break;
  1631. case (PH_DEACTIVATE | REQUEST):
  1632. l1_msg_b(st, pr, arg);
  1633. break;
  1634. case (PH_DEACTIVATE | CONFIRM):
  1635. test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  1636. test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1637. if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
  1638. debugl1(st->l1.bcs->cs, "PDAC clear BC_FLG_BUSY");
  1639. modeisar(st->l1.bcs, 0, st->l1.bc);
  1640. st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
  1641. break;
  1642. }
  1643. }
  1645. void
  1646. close_isarstate(struct BCState *bcs)
  1647. {
  1648. modeisar(bcs, 0, bcs->channel);
  1649. if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
  1650. if (bcs->hw.isar.rcvbuf) {
  1651. kfree(bcs->hw.isar.rcvbuf);
  1652. bcs->hw.isar.rcvbuf = NULL;
  1653. }
  1654. skb_queue_purge(&bcs->rqueue);
  1655. skb_queue_purge(&bcs->squeue);
  1656. if (bcs->tx_skb) {
  1657. dev_kfree_skb_any(bcs->tx_skb);
  1658. bcs->tx_skb = NULL;
  1659. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  1660. if (bcs->cs->debug & L1_DEB_HSCX)
  1661. debugl1(bcs->cs, "closeisar clear BC_FLG_BUSY");
  1662. }
  1663. }
  1664. del_timer(&bcs->hw.isar.ftimer);
  1665. }
  1667. int
  1668. open_isarstate(struct IsdnCardState *cs, struct BCState *bcs)
  1669. {
  1670. if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
  1671. if (!(bcs->hw.isar.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
  1672. printk(KERN_WARNING
  1673.        "HiSax: No memory for isar.rcvbufn");
  1674. return (1);
  1675. }
  1676. skb_queue_head_init(&bcs->rqueue);
  1677. skb_queue_head_init(&bcs->squeue);
  1678. }
  1679. bcs->tx_skb = NULL;
  1680. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  1681. if (cs->debug & L1_DEB_HSCX)
  1682. debugl1(cs, "openisar clear BC_FLG_BUSY");
  1683. bcs->event = 0;
  1684. bcs->hw.isar.rcvidx = 0;
  1685. bcs->tx_cnt = 0;
  1686. bcs->hw.isar.ftimer.function = (void *) ftimer_handler;
  1687. bcs->hw.isar.ftimer.data = (long) bcs;
  1688. init_timer(&bcs->hw.isar.ftimer);
  1689. return (0);
  1690. }
  1692. int
  1693. setstack_isar(struct PStack *st, struct BCState *bcs)
  1694. {
  1695. bcs->channel = st->l1.bc;
  1696. if (open_isarstate(st->l1.hardware, bcs))
  1697. return (-1);
  1698. st->l1.bcs = bcs;
  1699. st->l2.l2l1 = isar_l2l1;
  1700. setstack_manager(st);
  1701. bcs->st = st;
  1702. setstack_l1_B(st);
  1703. return (0);
  1704. }
  1706. int
  1707. isar_auxcmd(struct IsdnCardState *cs, isdn_ctrl *ic) {
  1708. u_long adr;
  1709. int features, i;
  1710. struct BCState *bcs;
  1712. if (cs->debug & L1_DEB_HSCX)
  1713. debugl1(cs, "isar_auxcmd cmd/ch %x/%d", ic->command, ic->arg);
  1714. switch (ic->command) {
  1715. case (ISDN_CMD_FAXCMD):
  1716. bcs = cs->channel[ic->arg].bcs;
  1717. if (cs->debug & L1_DEB_HSCX)
  1718. debugl1(cs, "isar_auxcmd cmd/subcmd %d/%d",
  1719. ic->parm.aux.cmd, ic->parm.aux.subcmd);
  1720. switch(ic->parm.aux.cmd) {
  1721. case ISDN_FAX_CLASS1_CTRL:
  1722. if (ic->parm.aux.subcmd == ETX)
  1723. test_and_set_bit(BC_FLG_DLEETX,
  1724. &bcs->Flag);
  1725. break;
  1726. case ISDN_FAX_CLASS1_FRM:
  1727. case ISDN_FAX_CLASS1_FRH:
  1728. case ISDN_FAX_CLASS1_FTM:
  1729. case ISDN_FAX_CLASS1_FTH:
  1730. if (ic->parm.aux.subcmd == AT_QUERY) {
  1731. sprintf(ic->parm.aux.para,
  1732. "%d", bcs->hw.isar.mod);
  1733. ic->command = ISDN_STAT_FAXIND;
  1734. ic->parm.aux.cmd = ISDN_FAX_CLASS1_QUERY;
  1735. cs->iif.statcallb(ic);
  1736. return(0);
  1737. } else if (ic->parm.aux.subcmd == AT_EQ_QUERY) {
  1738. strcpy(ic->parm.aux.para, faxmodulation_s);
  1739. ic->command = ISDN_STAT_FAXIND;
  1740. ic->parm.aux.cmd = ISDN_FAX_CLASS1_QUERY;
  1741. cs->iif.statcallb(ic);
  1742. return(0);
  1743. } else if (ic->parm.aux.subcmd == AT_EQ_VALUE) {
  1744. for(i=0;i<FAXMODCNT;i++)
  1745. if (faxmodulation[i]==ic->parm.aux.para[0])
  1746. break;
  1747. if ((FAXMODCNT > i) && 
  1748. test_bit(BC_FLG_INIT, &bcs->Flag)) {
  1749. isar_pump_cmd(bcs,
  1750. ic->parm.aux.cmd,
  1751. ic->parm.aux.para[0]);
  1752. return(0);
  1753. }
  1754. }
  1755. /* wrong modulation or not activ */
  1756. /* fall through */
  1757. default:
  1758. ic->command = ISDN_STAT_FAXIND;
  1759. ic->parm.aux.cmd = ISDN_FAX_CLASS1_ERROR;
  1760. cs->iif.statcallb(ic);
  1761. }
  1762. break;
  1763. case (ISDN_CMD_IOCTL):
  1764. switch (ic->arg) {
  1765. case (9): /* load firmware */
  1766. features = ISDN_FEATURE_L2_MODEM |
  1767. ISDN_FEATURE_L2_FAX |
  1768. ISDN_FEATURE_L3_FCLASS1;
  1769. memcpy(&adr, ic->parm.num, sizeof(ulong));
  1770. if (isar_load_firmware(cs, (u_char *)adr))
  1771. return(1);
  1772. else 
  1773. ll_run(cs, features);
  1774. break;
  1775. default:
  1776. printk(KERN_DEBUG "HiSax: invalid ioctl %dn",
  1777.        (int) ic->arg);
  1778. return(-EINVAL);
  1779. }
  1780. break;
  1781. default:
  1782. return(-EINVAL);
  1783. }
  1784. return(0);
  1785. }
  1787. void __devinit
  1788. initisar(struct IsdnCardState *cs)
  1789. {
  1790. cs->bcs[0].BC_SetStack = setstack_isar;
  1791. cs->bcs[1].BC_SetStack = setstack_isar;
  1792. cs->bcs[0].BC_Close = close_isarstate;
  1793. cs->bcs[1].BC_Close = close_isarstate;
  1794. }