1 /* $Id: isar.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
3 * isar.c ISAR (Siemens PSB 7110) specific routines
5 * Author Karsten Keil (keil@isdn4linux.de)
7 * This file is (c) under GNU General Public License
11 #define __NO_VERSION__
12 #include <linux/init.h>
16 #include <linux/interrupt.h>
18 #define DBG_LOADFIRM 0
19 #define DUMP_MBOXFRAME 2
25 const u_char faxmodulation[] = {3,24,48,72,73,74,96,97,98,121,122,145,146};
26 static u_int modmask = 0x1fff;
27 static int frm_extra_delay = 2;
28 static int para_TOA = 6;
29 const u_char *FC1_CMD[] = {"FAE", "FTS", "FRS", "FTM", "FRM", "FTH", "FRH", "CTRL" };
31 void isar_setup(struct IsdnCardState *cs);
32 static void isar_pump_cmd(struct BCState *bcs, u_char cmd, u_char para);
33 static inline void ll_deliver_faxstat(struct BCState *bcs, u_char status);
36 waitforHIA(struct IsdnCardState *cs, int timeout)
39 while ((cs->BC_Read_Reg(cs, 0, ISAR_HIA) & 1) && timeout) {
44 printk(KERN_WARNING "HiSax: ISAR waitforHIA timeout\n");
50 sendmsg(struct IsdnCardState *cs, u_char his, u_char creg, u_char len,
56 if (!waitforHIA(cs, 4000))
59 if (cs->debug & L1_DEB_HSCX)
60 debugl1(cs, "sendmsg(%02x,%02x,%d)", his, creg, len);
64 cs->BC_Write_Reg(cs, 0, ISAR_CTRL_H, creg);
65 cs->BC_Write_Reg(cs, 0, ISAR_CTRL_L, len);
66 cs->BC_Write_Reg(cs, 0, ISAR_WADR, 0);
68 cs->BC_Write_Reg(cs, 1, ISAR_MBOX, msg[0]);
70 cs->BC_Write_Reg(cs, 2, ISAR_MBOX, msg[i]);
72 if (cs->debug & L1_DEB_HSCX_FIFO) {
78 t += sprintf(t, "sendmbox cnt %d", len);
79 QuickHex(t, &msg[len-i], (i>64) ? 64:i);
86 cs->BC_Write_Reg(cs, 1, ISAR_HIS, his);
88 waitforHIA(cs, 10000);
92 /* Call only with IRQ disabled !!! */
94 rcv_mbox(struct IsdnCardState *cs, struct isar_reg *ireg, u_char *msg)
98 cs->BC_Write_Reg(cs, 1, ISAR_RADR, 0);
99 if (msg && ireg->clsb) {
100 msg[0] = cs->BC_Read_Reg(cs, 1, ISAR_MBOX);
101 for (i=1; i < ireg->clsb; i++)
102 msg[i] = cs->BC_Read_Reg(cs, 2, ISAR_MBOX);
104 if (cs->debug & L1_DEB_HSCX_FIFO) {
110 t += sprintf(t, "rcv_mbox cnt %d", ireg->clsb);
111 QuickHex(t, &msg[ireg->clsb-i], (i>64) ? 64:i);
118 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
121 /* Call only with IRQ disabled !!! */
123 get_irq_infos(struct IsdnCardState *cs, struct isar_reg *ireg)
125 ireg->iis = cs->BC_Read_Reg(cs, 1, ISAR_IIS);
126 ireg->cmsb = cs->BC_Read_Reg(cs, 1, ISAR_CTRL_H);
127 ireg->clsb = cs->BC_Read_Reg(cs, 1, ISAR_CTRL_L);
129 if (cs->debug & L1_DEB_HSCX)
130 debugl1(cs, "irq_stat(%02x,%02x,%d)", ireg->iis, ireg->cmsb,
136 waitrecmsg(struct IsdnCardState *cs, u_char *len,
137 u_char *msg, int maxdelay)
141 struct isar_reg *ir = cs->bcs[0].hw.isar.reg;
144 while((!(cs->BC_Read_Reg(cs, 0, ISAR_IRQBIT) & ISAR_IRQSTA)) &&
145 (timeout++ < maxdelay))
147 if (timeout >= maxdelay) {
148 printk(KERN_WARNING"isar recmsg IRQSTA timeout\n");
153 get_irq_infos(cs, ir);
154 rcv_mbox(cs, ir, msg);
156 restore_flags(flags);
161 ISARVersion(struct IsdnCardState *cs, char *s)
164 u_char msg[] = ISAR_MSG_HWVER;
169 cs->cardmsg(cs, CARD_RESET, NULL);
170 /* disable ISAR IRQ */
171 cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
173 cs->debug &= ~(L1_DEB_HSCX | L1_DEB_HSCX_FIFO);
174 if (!sendmsg(cs, ISAR_HIS_VNR, 0, 3, msg))
176 if (!waitrecmsg(cs, &len, tmp, 100000))
179 if (cs->bcs[0].hw.isar.reg->iis == ISAR_IIS_VNR) {
182 printk(KERN_INFO "%s ISAR version %d\n", s, ver);
191 isar_load_firmware(struct IsdnCardState *cs, u_char *buf)
193 int ret, size, cnt, debug;
194 u_char len, nom, noc;
195 u_short sadr, left, *sp;
197 u_char *msg, *tmpmsg, *mp, tmp[64];
199 struct isar_reg *ireg = cs->bcs[0].hw.isar.reg;
201 struct {u_short sadr;
206 #define BLK_HEAD_SIZE 6
207 if (1 != (ret = ISARVersion(cs, "Testing"))) {
208 printk(KERN_ERR"isar_load_firmware wrong isar version %d\n", ret);
213 cs->debug &= ~(L1_DEB_HSCX | L1_DEB_HSCX_FIFO);
215 printk(KERN_DEBUG"isar_load_firmware buf %#lx\n", (u_long)buf);
216 if ((ret = verify_area(VERIFY_READ, (void *) p, sizeof(int)))) {
217 printk(KERN_ERR"isar_load_firmware verify_area ret %d\n", ret);
220 if ((ret = copy_from_user(&size, p, sizeof(int)))) {
221 printk(KERN_ERR"isar_load_firmware copy_from_user ret %d\n", ret);
225 printk(KERN_DEBUG"isar_load_firmware size: %d\n", size);
226 if ((ret = verify_area(VERIFY_READ, (void *) p, size))) {
227 printk(KERN_ERR"isar_load_firmware verify_area ret %d\n", ret);
231 /* disable ISAR IRQ */
232 cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
233 if (!(msg = kmalloc(256, GFP_KERNEL))) {
234 printk(KERN_ERR"isar_load_firmware no buffer\n");
237 if (!(tmpmsg = kmalloc(256, GFP_KERNEL))) {
238 printk(KERN_ERR"isar_load_firmware no tmp buffer\n");
243 if ((ret = copy_from_user(&blk_head, p, BLK_HEAD_SIZE))) {
244 printk(KERN_ERR"isar_load_firmware copy_from_user ret %d\n", ret);
248 sadr = (blk_head.sadr & 0xff)*256 + blk_head.sadr/256;
249 blk_head.sadr = sadr;
250 sadr = (blk_head.len & 0xff)*256 + blk_head.len/256;
252 sadr = (blk_head.d_key & 0xff)*256 + blk_head.d_key/256;
253 blk_head.d_key = sadr;
254 #endif /* __BIG_ENDIAN */
255 cnt += BLK_HEAD_SIZE;
257 printk(KERN_DEBUG"isar firmware block (%#x,%5d,%#x)\n",
258 blk_head.sadr, blk_head.len, blk_head.d_key & 0xff);
259 sadr = blk_head.sadr;
261 if (!sendmsg(cs, ISAR_HIS_DKEY, blk_head.d_key & 0xff, 0, NULL)) {
262 printk(KERN_ERR"isar sendmsg dkey failed\n");
263 ret = 1;goto reterror;
265 if (!waitrecmsg(cs, &len, tmp, 100000)) {
266 printk(KERN_ERR"isar waitrecmsg dkey failed\n");
267 ret = 1;goto reterror;
269 if ((ireg->iis != ISAR_IIS_DKEY) || ireg->cmsb || len) {
270 printk(KERN_ERR"isar wrong dkey response (%x,%x,%x)\n",
271 ireg->iis, ireg->cmsb, len);
272 ret = 1;goto reterror;
285 if ((ret = copy_from_user(tmpmsg, p, nom))) {
286 printk(KERN_ERR"isar_load_firmware copy_from_user ret %d\n", ret);
292 sp = (u_short *)tmpmsg;
294 printk(KERN_DEBUG"isar: load %3d words at %04x left %d\n",
305 #endif /* __BIG_ENDIAN */
309 if (!sendmsg(cs, ISAR_HIS_FIRM, 0, nom, msg)) {
310 printk(KERN_ERR"isar sendmsg prog failed\n");
311 ret = 1;goto reterror;
313 if (!waitrecmsg(cs, &len, tmp, 100000)) {
314 printk(KERN_ERR"isar waitrecmsg prog failed\n");
315 ret = 1;goto reterror;
317 if ((ireg->iis != ISAR_IIS_FIRM) || ireg->cmsb || len) {
318 printk(KERN_ERR"isar wrong prog response (%x,%x,%x)\n",
319 ireg->iis, ireg->cmsb, len);
320 ret = 1;goto reterror;
323 printk(KERN_DEBUG"isar firmware block %5d words loaded\n",
333 if (!sendmsg(cs, ISAR_HIS_STDSP, 0, 2, msg)) {
334 printk(KERN_ERR"isar sendmsg start dsp failed\n");
335 ret = 1;goto reterror;
337 if (!waitrecmsg(cs, &len, tmp, 100000)) {
338 printk(KERN_ERR"isar waitrecmsg start dsp failed\n");
339 ret = 1;goto reterror;
341 if ((ireg->iis != ISAR_IIS_STDSP) || ireg->cmsb || len) {
342 printk(KERN_ERR"isar wrong start dsp response (%x,%x,%x)\n",
343 ireg->iis, ireg->cmsb, len);
344 ret = 1;goto reterror;
346 printk(KERN_DEBUG"isar start dsp success\n");
347 /* NORMAL mode entered */
348 /* Enable IRQs of ISAR */
349 cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, ISAR_IRQSTA);
352 cnt = 1000; /* max 1s */
353 while ((!ireg->bstat) && cnt) {
358 printk(KERN_ERR"isar no general status event received\n");
359 ret = 1;goto reterrflg;
361 printk(KERN_DEBUG"isar general status event %x\n",
369 if (!sendmsg(cs, ISAR_HIS_DIAG, ISAR_CTRL_STST, 0, NULL)) {
370 printk(KERN_ERR"isar sendmsg self tst failed\n");
371 ret = 1;goto reterrflg;
373 cnt = 10000; /* max 100 ms */
374 while ((ireg->iis != ISAR_IIS_DIAG) && cnt) {
380 printk(KERN_ERR"isar no self tst response\n");
381 ret = 1;goto reterrflg;
383 if ((ireg->cmsb == ISAR_CTRL_STST) && (ireg->clsb == 1)
384 && (ireg->par[0] == 0)) {
385 printk(KERN_DEBUG"isar selftest OK\n");
387 printk(KERN_DEBUG"isar selftest not OK %x/%x/%x\n",
388 ireg->cmsb, ireg->clsb, ireg->par[0]);
389 ret = 1;goto reterrflg;
392 if (!sendmsg(cs, ISAR_HIS_DIAG, ISAR_CTRL_SWVER, 0, NULL)) {
393 printk(KERN_ERR"isar RQST SVN failed\n");
394 ret = 1;goto reterrflg;
396 cnt = 30000; /* max 300 ms */
397 while ((ireg->iis != ISAR_IIS_DIAG) && cnt) {
403 printk(KERN_ERR"isar no SVN response\n");
404 ret = 1;goto reterrflg;
406 if ((ireg->cmsb == ISAR_CTRL_SWVER) && (ireg->clsb == 1))
407 printk(KERN_DEBUG"isar software version %#x\n",
410 printk(KERN_ERR"isar wrong swver response (%x,%x) cnt(%d)\n",
411 ireg->cmsb, ireg->clsb, cnt);
412 ret = 1;goto reterrflg;
420 restore_flags(flags);
424 /* disable ISAR IRQ */
425 cs->BC_Write_Reg(cs, 0, ISAR_IRQBIT, 0);
432 ll_deliver_faxstat(struct BCState *bcs, u_char status)
435 struct Channel *chanp = (struct Channel *) bcs->st->lli.userdata;
437 if (bcs->cs->debug & L1_DEB_HSCX)
438 debugl1(bcs->cs, "HL->LL FAXIND %x", status);
439 ic.driver = bcs->cs->myid;
440 ic.command = ISDN_STAT_FAXIND;
441 ic.arg = chanp->chan;
442 ic.parm.aux.cmd = status;
443 bcs->cs->iif.statcallb(&ic);
446 extern void BChannel_bh(struct BCState *);
447 #define B_LL_NOCARRIER 8
448 #define B_LL_CONNECT 9
452 isar_bh(struct BCState *bcs)
455 if (test_and_clear_bit(B_LL_NOCARRIER, &bcs->event))
456 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_NOCARR);
457 if (test_and_clear_bit(B_LL_CONNECT, &bcs->event))
458 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
459 if (test_and_clear_bit(B_LL_OK, &bcs->event))
460 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_OK);
464 isar_sched_event(struct BCState *bcs, int event)
466 bcs->event |= 1 << event;
467 queue_task(&bcs->tqueue, &tq_immediate);
468 mark_bh(IMMEDIATE_BH);
472 send_DLE_ETX(struct BCState *bcs)
474 u_char dleetx[2] = {DLE,ETX};
477 if ((skb = dev_alloc_skb(2))) {
478 memcpy(skb_put(skb, 2), dleetx, 2);
479 skb_queue_tail(&bcs->rqueue, skb);
480 isar_sched_event(bcs, B_RCVBUFREADY);
482 printk(KERN_WARNING "HiSax: skb out of memory\n");
487 dle_count(unsigned char *buf, int len)
498 insert_dle(unsigned char *dest, unsigned char *src, int count) {
499 /* <DLE> in input stream have to be flagged as <DLE><DLE> */
508 isar_rcv_frame(struct IsdnCardState *cs, struct BCState *bcs)
512 struct isar_reg *ireg = bcs->hw.isar.reg;
515 debugl1(cs, "isar zero len frame");
516 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
521 debugl1(cs, "isar mode 0 spurious IIS_RDATA %x/%x/%x",
522 ireg->iis, ireg->cmsb, ireg->clsb);
523 printk(KERN_WARNING"isar mode 0 spurious IIS_RDATA %x/%x/%x\n",
524 ireg->iis, ireg->cmsb, ireg->clsb);
525 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
529 if ((skb = dev_alloc_skb(ireg->clsb))) {
530 rcv_mbox(cs, ireg, (u_char *)skb_put(skb, ireg->clsb));
531 skb_queue_tail(&bcs->rqueue, skb);
532 isar_sched_event(bcs, B_RCVBUFREADY);
534 printk(KERN_WARNING "HiSax: skb out of memory\n");
535 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
539 if ((bcs->hw.isar.rcvidx + ireg->clsb) > HSCX_BUFMAX) {
540 if (cs->debug & L1_DEB_WARN)
541 debugl1(cs, "isar_rcv_frame: incoming packet too large");
542 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
543 bcs->hw.isar.rcvidx = 0;
544 } else if (ireg->cmsb & HDLC_ERROR) {
545 if (cs->debug & L1_DEB_WARN)
546 debugl1(cs, "isar frame error %x len %d",
547 ireg->cmsb, ireg->clsb);
548 #ifdef ERROR_STATISTIC
549 if (ireg->cmsb & HDLC_ERR_RER)
551 if (ireg->cmsb & HDLC_ERR_CER)
554 bcs->hw.isar.rcvidx = 0;
555 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
557 if (ireg->cmsb & HDLC_FSD)
558 bcs->hw.isar.rcvidx = 0;
559 ptr = bcs->hw.isar.rcvbuf + bcs->hw.isar.rcvidx;
560 bcs->hw.isar.rcvidx += ireg->clsb;
561 rcv_mbox(cs, ireg, ptr);
562 if (ireg->cmsb & HDLC_FED) {
563 if (bcs->hw.isar.rcvidx < 3) { /* last 2 bytes are the FCS */
564 if (cs->debug & L1_DEB_WARN)
565 debugl1(cs, "isar frame to short %d",
566 bcs->hw.isar.rcvidx);
567 } else if (!(skb = dev_alloc_skb(bcs->hw.isar.rcvidx-2))) {
568 printk(KERN_WARNING "ISAR: receive out of memory\n");
570 memcpy(skb_put(skb, bcs->hw.isar.rcvidx-2),
571 bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx-2);
572 skb_queue_tail(&bcs->rqueue, skb);
573 isar_sched_event(bcs, B_RCVBUFREADY);
575 bcs->hw.isar.rcvidx = 0;
580 if (bcs->hw.isar.state != STFAX_ACTIV) {
581 if (cs->debug & L1_DEB_WARN)
582 debugl1(cs, "isar_rcv_frame: not ACTIV");
583 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
584 bcs->hw.isar.rcvidx = 0;
587 if (bcs->hw.isar.cmd == PCTRL_CMD_FRM) {
588 rcv_mbox(cs, ireg, bcs->hw.isar.rcvbuf);
589 bcs->hw.isar.rcvidx = ireg->clsb +
590 dle_count(bcs->hw.isar.rcvbuf, ireg->clsb);
591 if (cs->debug & L1_DEB_HSCX)
592 debugl1(cs, "isar_rcv_frame: raw(%d) dle(%d)",
593 ireg->clsb, bcs->hw.isar.rcvidx);
594 if ((skb = dev_alloc_skb(bcs->hw.isar.rcvidx))) {
595 insert_dle((u_char *)skb_put(skb, bcs->hw.isar.rcvidx),
596 bcs->hw.isar.rcvbuf, ireg->clsb);
597 skb_queue_tail(&bcs->rqueue, skb);
598 isar_sched_event(bcs, B_RCVBUFREADY);
599 if (ireg->cmsb & SART_NMD) { /* ABORT */
600 if (cs->debug & L1_DEB_WARN)
601 debugl1(cs, "isar_rcv_frame: no more data");
602 bcs->hw.isar.rcvidx = 0;
604 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) |
605 ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC,
607 bcs->hw.isar.state = STFAX_ESCAPE;
608 isar_sched_event(bcs, B_LL_NOCARRIER);
611 printk(KERN_WARNING "HiSax: skb out of memory\n");
615 if (bcs->hw.isar.cmd != PCTRL_CMD_FRH) {
616 if (cs->debug & L1_DEB_WARN)
617 debugl1(cs, "isar_rcv_frame: unknown fax mode %x",
619 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
620 bcs->hw.isar.rcvidx = 0;
624 if ((bcs->hw.isar.rcvidx + ireg->clsb) > HSCX_BUFMAX) {
625 if (cs->debug & L1_DEB_WARN)
626 debugl1(cs, "isar_rcv_frame: incoming packet too large");
627 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
628 bcs->hw.isar.rcvidx = 0;
629 } else if (ireg->cmsb & HDLC_ERROR) {
630 if (cs->debug & L1_DEB_WARN)
631 debugl1(cs, "isar frame error %x len %d",
632 ireg->cmsb, ireg->clsb);
633 bcs->hw.isar.rcvidx = 0;
634 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
636 if (ireg->cmsb & HDLC_FSD) {
637 bcs->hw.isar.rcvidx = 0;
639 ptr = bcs->hw.isar.rcvbuf + bcs->hw.isar.rcvidx;
640 bcs->hw.isar.rcvidx += ireg->clsb;
641 rcv_mbox(cs, ireg, ptr);
642 if (ireg->cmsb & HDLC_FED) {
643 int len = bcs->hw.isar.rcvidx +
644 dle_count(bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx);
645 if (bcs->hw.isar.rcvidx < 3) { /* last 2 bytes are the FCS */
646 if (cs->debug & L1_DEB_WARN)
647 debugl1(cs, "isar frame to short %d",
648 bcs->hw.isar.rcvidx);
649 printk(KERN_WARNING "ISAR: frame to short %d\n",
650 bcs->hw.isar.rcvidx);
651 } else if (!(skb = dev_alloc_skb(bcs->hw.isar.rcvidx))) {
652 printk(KERN_WARNING "ISAR: receive out of memory\n");
654 insert_dle((u_char *)skb_put(skb, len),
656 bcs->hw.isar.rcvidx);
657 skb_queue_tail(&bcs->rqueue, skb);
658 isar_sched_event(bcs, B_RCVBUFREADY);
660 isar_sched_event(bcs, B_LL_OK);
661 test_and_clear_bit(BC_FLG_FRH_WAIT, &bcs->Flag);
663 bcs->hw.isar.rcvidx = 0;
666 if (ireg->cmsb & SART_NMD) { /* ABORT */
667 if (cs->debug & L1_DEB_WARN)
668 debugl1(cs, "isar_rcv_frame: no more data");
669 bcs->hw.isar.rcvidx = 0;
670 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) |
671 ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 0, NULL);
672 bcs->hw.isar.state = STFAX_ESCAPE;
673 if (test_and_clear_bit(BC_FLG_FRH_WAIT, &bcs->Flag)) {
675 isar_sched_event(bcs, B_LL_NOCARRIER);
680 printk(KERN_ERR"isar_rcv_frame mode (%x)error\n", bcs->mode);
681 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
687 isar_fill_fifo(struct BCState *bcs)
689 struct IsdnCardState *cs = bcs->cs;
695 if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
696 debugl1(cs, "isar_fill_fifo");
699 if (bcs->tx_skb->len <= 0)
701 if (!(bcs->hw.isar.reg->bstat &
702 (bcs->hw.isar.dpath == 1 ? BSTAT_RDM1 : BSTAT_RDM2)))
704 if (bcs->tx_skb->len > bcs->hw.isar.mml) {
706 count = bcs->hw.isar.mml;
708 count = bcs->tx_skb->len;
713 ptr = bcs->tx_skb->data;
714 if (!bcs->hw.isar.txcnt) {
716 if ((bcs->mode == L1_MODE_FAX) &&
717 (bcs->hw.isar.cmd == PCTRL_CMD_FTH)) {
718 if (bcs->tx_skb->len > 1) {
719 if ((ptr[0]== 0xff) && (ptr[1] == 0x13))
721 test_and_set_bit(BC_FLG_LASTDATA,
726 skb_pull(bcs->tx_skb, count);
727 bcs->tx_cnt -= count;
728 bcs->hw.isar.txcnt += count;
731 printk(KERN_ERR"isar_fill_fifo wrong mode 0\n");
735 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
739 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
743 if (bcs->hw.isar.state != STFAX_ACTIV) {
744 if (cs->debug & L1_DEB_WARN)
745 debugl1(cs, "isar_fill_fifo: not ACTIV");
746 } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) {
747 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
749 } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTM) {
750 sendmsg(cs, SET_DPS(bcs->hw.isar.dpath) | ISAR_HIS_SDATA,
753 if (cs->debug & L1_DEB_WARN)
754 debugl1(cs, "isar_fill_fifo: not FTH/FTM");
759 debugl1(cs, "isar_fill_fifo mode(%x) error", bcs->mode);
760 printk(KERN_ERR"isar_fill_fifo mode(%x) error\n", bcs->mode);
763 restore_flags(flags);
767 struct BCState *sel_bcs_isar(struct IsdnCardState *cs, u_char dpath)
769 if ((!dpath) || (dpath == 3))
771 if (cs->bcs[0].hw.isar.dpath == dpath)
773 if (cs->bcs[1].hw.isar.dpath == dpath)
779 send_frames(struct BCState *bcs)
782 if (bcs->tx_skb->len) {
786 if (bcs->st->lli.l1writewakeup &&
787 (PACKET_NOACK != bcs->tx_skb->pkt_type))
788 bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.isar.txcnt);
789 if (bcs->mode == L1_MODE_FAX) {
790 if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) {
791 if (test_bit(BC_FLG_LASTDATA, &bcs->Flag)) {
792 test_and_set_bit(BC_FLG_NMD_DATA, &bcs->Flag);
794 } else if (bcs->hw.isar.cmd == PCTRL_CMD_FTM) {
795 if (test_bit(BC_FLG_DLEETX, &bcs->Flag)) {
796 test_and_set_bit(BC_FLG_LASTDATA, &bcs->Flag);
797 test_and_set_bit(BC_FLG_NMD_DATA, &bcs->Flag);
801 dev_kfree_skb_any(bcs->tx_skb);
802 bcs->hw.isar.txcnt = 0;
806 if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
807 bcs->hw.isar.txcnt = 0;
808 test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
811 if (test_and_clear_bit(BC_FLG_DLEETX, &bcs->Flag)) {
812 if (test_and_clear_bit(BC_FLG_LASTDATA, &bcs->Flag)) {
813 if (test_and_clear_bit(BC_FLG_NMD_DATA, &bcs->Flag)) {
815 sendmsg(bcs->cs, SET_DPS(bcs->hw.isar.dpath) |
816 ISAR_HIS_SDATA, 0x01, 1, &dummy);
818 test_and_set_bit(BC_FLG_LL_OK, &bcs->Flag);
820 isar_sched_event(bcs, B_LL_CONNECT);
823 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
824 isar_sched_event(bcs, B_XMTBUFREADY);
829 check_send(struct IsdnCardState *cs, u_char rdm)
833 if (rdm & BSTAT_RDM1) {
834 if ((bcs = sel_bcs_isar(cs, 1))) {
840 if (rdm & BSTAT_RDM2) {
841 if ((bcs = sel_bcs_isar(cs, 2))) {
850 const char *dmril[] = {"NO SPEED", "1200/75", "NODEF2", "75/1200", "NODEF4",
851 "300", "600", "1200", "2400", "4800", "7200",
852 "9600nt", "9600t", "12000", "14400", "WRONG"};
853 const char *dmrim[] = {"NO MOD", "NO DEF", "V32/V32b", "V22", "V21",
854 "Bell103", "V23", "Bell202", "V17", "V29", "V27ter"};
857 isar_pump_status_rsp(struct BCState *bcs, struct isar_reg *ireg) {
858 struct IsdnCardState *cs = bcs->cs;
859 u_char ril = ireg->par[0];
862 if (!test_and_clear_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags))
865 if (cs->debug & L1_DEB_WARN)
866 debugl1(cs, "wrong pstrsp ril=%d",ril);
869 switch(ireg->par[1]) {
904 sprintf(bcs->hw.isar.conmsg,"%s %s", dmril[ril], dmrim[rim]);
905 bcs->conmsg = bcs->hw.isar.conmsg;
906 if (cs->debug & L1_DEB_HSCX)
907 debugl1(cs, "pump strsp %s", bcs->conmsg);
911 isar_pump_statev_modem(struct BCState *bcs, u_char devt) {
912 struct IsdnCardState *cs = bcs->cs;
913 u_char dps = SET_DPS(bcs->hw.isar.dpath);
916 case PSEV_10MS_TIMER:
917 if (cs->debug & L1_DEB_HSCX)
918 debugl1(cs, "pump stev TIMER");
921 if (cs->debug & L1_DEB_HSCX)
922 debugl1(cs, "pump stev CONNECT");
923 l1_msg_b(bcs->st, PH_ACTIVATE | REQUEST, NULL);
926 if (cs->debug & L1_DEB_HSCX)
927 debugl1(cs, "pump stev NO CONNECT");
928 sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
929 l1_msg_b(bcs->st, PH_DEACTIVATE | REQUEST, NULL);
932 if (cs->debug & L1_DEB_HSCX)
933 debugl1(cs, "pump stev V24 OFF");
936 if (cs->debug & L1_DEB_HSCX)
937 debugl1(cs, "pump stev CTS ON");
940 if (cs->debug & L1_DEB_HSCX)
941 debugl1(cs, "pump stev CTS OFF");
944 if (cs->debug & L1_DEB_HSCX)
945 debugl1(cs, "pump stev CARRIER ON");
946 test_and_set_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags);
947 sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
950 if (cs->debug & L1_DEB_HSCX)
951 debugl1(cs, "pump stev CARRIER OFF");
954 if (cs->debug & L1_DEB_HSCX)
955 debugl1(cs, "pump stev DSR ON");
958 if (cs->debug & L1_DEB_HSCX)
959 debugl1(cs, "pump stev DSR_OFF");
962 if (cs->debug & L1_DEB_HSCX)
963 debugl1(cs, "pump stev REMOTE RETRAIN");
966 if (cs->debug & L1_DEB_HSCX)
967 debugl1(cs, "pump stev REMOTE RENEGOTIATE");
970 if (cs->debug & L1_DEB_HSCX)
971 debugl1(cs, "pump stev GSTN CLEAR", devt);
974 if (cs->debug & L1_DEB_HSCX)
975 debugl1(cs, "unknown pump stev %x", devt);
981 isar_pump_statev_fax(struct BCState *bcs, u_char devt) {
982 struct IsdnCardState *cs = bcs->cs;
983 u_char dps = SET_DPS(bcs->hw.isar.dpath);
987 case PSEV_10MS_TIMER:
988 if (cs->debug & L1_DEB_HSCX)
989 debugl1(cs, "pump stev TIMER");
992 if (cs->debug & L1_DEB_HSCX)
993 debugl1(cs, "pump stev RSP_READY");
994 bcs->hw.isar.state = STFAX_READY;
995 l1_msg_b(bcs->st, PH_ACTIVATE | REQUEST, NULL);
996 if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
997 isar_pump_cmd(bcs, ISDN_FAX_CLASS1_FRH, 3);
999 isar_pump_cmd(bcs, ISDN_FAX_CLASS1_FTH, 3);
1002 case PSEV_LINE_TX_H:
1003 if (bcs->hw.isar.state == STFAX_LINE) {
1004 if (cs->debug & L1_DEB_HSCX)
1005 debugl1(cs, "pump stev LINE_TX_H");
1006 bcs->hw.isar.state = STFAX_CONT;
1007 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
1009 if (cs->debug & L1_DEB_WARN)
1010 debugl1(cs, "pump stev LINE_TX_H wrong st %x",
1011 bcs->hw.isar.state);
1014 case PSEV_LINE_RX_H:
1015 if (bcs->hw.isar.state == STFAX_LINE) {
1016 if (cs->debug & L1_DEB_HSCX)
1017 debugl1(cs, "pump stev LINE_RX_H");
1018 bcs->hw.isar.state = STFAX_CONT;
1019 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
1021 if (cs->debug & L1_DEB_WARN)
1022 debugl1(cs, "pump stev LINE_RX_H wrong st %x",
1023 bcs->hw.isar.state);
1026 case PSEV_LINE_TX_B:
1027 if (bcs->hw.isar.state == STFAX_LINE) {
1028 if (cs->debug & L1_DEB_HSCX)
1029 debugl1(cs, "pump stev LINE_TX_B");
1030 bcs->hw.isar.state = STFAX_CONT;
1031 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
1033 if (cs->debug & L1_DEB_WARN)
1034 debugl1(cs, "pump stev LINE_TX_B wrong st %x",
1035 bcs->hw.isar.state);
1038 case PSEV_LINE_RX_B:
1039 if (bcs->hw.isar.state == STFAX_LINE) {
1040 if (cs->debug & L1_DEB_HSCX)
1041 debugl1(cs, "pump stev LINE_RX_B");
1042 bcs->hw.isar.state = STFAX_CONT;
1043 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_CONT, 0, NULL);
1045 if (cs->debug & L1_DEB_WARN)
1046 debugl1(cs, "pump stev LINE_RX_B wrong st %x",
1047 bcs->hw.isar.state);
1051 if (bcs->hw.isar.state == STFAX_CONT) {
1052 if (cs->debug & L1_DEB_HSCX)
1053 debugl1(cs, "pump stev RSP_CONN");
1054 bcs->hw.isar.state = STFAX_ACTIV;
1055 test_and_set_bit(ISAR_RATE_REQ, &bcs->hw.isar.reg->Flags);
1056 sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
1057 if (bcs->hw.isar.cmd == PCTRL_CMD_FTH) {
1058 /* 1s Flags before data */
1059 if (test_and_set_bit(BC_FLG_FTI_RUN, &bcs->Flag))
1060 del_timer(&bcs->hw.isar.ftimer);
1062 bcs->hw.isar.ftimer.expires =
1063 jiffies + ((1000 * HZ)/1000);
1064 test_and_set_bit(BC_FLG_LL_CONN,
1066 add_timer(&bcs->hw.isar.ftimer);
1068 isar_sched_event(bcs, B_LL_CONNECT);
1071 if (cs->debug & L1_DEB_WARN)
1072 debugl1(cs, "pump stev RSP_CONN wrong st %x",
1073 bcs->hw.isar.state);
1076 case PSEV_FLAGS_DET:
1077 if (cs->debug & L1_DEB_HSCX)
1078 debugl1(cs, "pump stev FLAGS_DET");
1081 if (cs->debug & L1_DEB_HSCX)
1082 debugl1(cs, "pump stev RSP_DISC");
1083 if (bcs->hw.isar.state == STFAX_ESCAPE) {
1085 switch(bcs->hw.isar.newcmd) {
1087 bcs->hw.isar.state = STFAX_READY;
1092 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
1093 PCTRL_CMD_SILON, 1, &p1);
1094 bcs->hw.isar.state = STFAX_SILDET;
1097 if (frm_extra_delay)
1098 mdelay(frm_extra_delay);
1100 p1 = bcs->hw.isar.mod = bcs->hw.isar.newmod;
1101 bcs->hw.isar.newmod = 0;
1102 bcs->hw.isar.cmd = bcs->hw.isar.newcmd;
1103 bcs->hw.isar.newcmd = 0;
1104 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
1105 bcs->hw.isar.cmd, 1, &p1);
1106 bcs->hw.isar.state = STFAX_LINE;
1107 bcs->hw.isar.try_mod = 3;
1110 if (cs->debug & L1_DEB_HSCX)
1111 debugl1(cs, "RSP_DISC unknown newcmd %x", bcs->hw.isar.newcmd);
1114 } else if (bcs->hw.isar.state == STFAX_ACTIV) {
1115 if (test_and_clear_bit(BC_FLG_LL_OK, &bcs->Flag)) {
1116 isar_sched_event(bcs, B_LL_OK);
1117 } else if (bcs->hw.isar.cmd == PCTRL_CMD_FRM) {
1119 isar_sched_event(bcs, B_LL_NOCARRIER);
1121 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
1123 bcs->hw.isar.state = STFAX_READY;
1125 bcs->hw.isar.state = STFAX_READY;
1126 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
1129 case PSEV_RSP_SILDET:
1130 if (cs->debug & L1_DEB_HSCX)
1131 debugl1(cs, "pump stev RSP_SILDET");
1132 if (bcs->hw.isar.state == STFAX_SILDET) {
1133 p1 = bcs->hw.isar.mod = bcs->hw.isar.newmod;
1134 bcs->hw.isar.newmod = 0;
1135 bcs->hw.isar.cmd = bcs->hw.isar.newcmd;
1136 bcs->hw.isar.newcmd = 0;
1137 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
1138 bcs->hw.isar.cmd, 1, &p1);
1139 bcs->hw.isar.state = STFAX_LINE;
1140 bcs->hw.isar.try_mod = 3;
1143 case PSEV_RSP_SILOFF:
1144 if (cs->debug & L1_DEB_HSCX)
1145 debugl1(cs, "pump stev RSP_SILOFF");
1147 case PSEV_RSP_FCERR:
1148 if (bcs->hw.isar.state == STFAX_LINE) {
1149 if (cs->debug & L1_DEB_HSCX)
1150 debugl1(cs, "pump stev RSP_FCERR try %d",
1151 bcs->hw.isar.try_mod);
1152 if (bcs->hw.isar.try_mod--) {
1153 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL,
1154 bcs->hw.isar.cmd, 1,
1159 if (cs->debug & L1_DEB_HSCX)
1160 debugl1(cs, "pump stev RSP_FCERR");
1161 bcs->hw.isar.state = STFAX_ESCAPE;
1162 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 0, NULL);
1163 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_FCERROR);
1170 static char debbuf[128];
1173 isar_int_main(struct IsdnCardState *cs)
1176 struct isar_reg *ireg = cs->bcs[0].hw.isar.reg;
1177 struct BCState *bcs;
1181 get_irq_infos(cs, ireg);
1182 switch (ireg->iis & ISAR_IIS_MSCMSD) {
1183 case ISAR_IIS_RDATA:
1184 if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
1185 isar_rcv_frame(cs, bcs);
1187 debugl1(cs, "isar spurious IIS_RDATA %x/%x/%x",
1188 ireg->iis, ireg->cmsb, ireg->clsb);
1189 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
1192 case ISAR_IIS_GSTEV:
1193 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
1194 ireg->bstat |= ireg->cmsb;
1195 check_send(cs, ireg->cmsb);
1197 case ISAR_IIS_BSTEV:
1198 #ifdef ERROR_STATISTIC
1199 if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
1200 if (ireg->cmsb == BSTEV_TBO)
1202 if (ireg->cmsb == BSTEV_RBO)
1206 if (cs->debug & L1_DEB_WARN)
1207 debugl1(cs, "Buffer STEV dpath%d msb(%x)",
1208 ireg->iis>>6, ireg->cmsb);
1209 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
1211 case ISAR_IIS_PSTEV:
1212 if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
1213 rcv_mbox(cs, ireg, (u_char *)ireg->par);
1214 if (bcs->mode == L1_MODE_V32) {
1215 isar_pump_statev_modem(bcs, ireg->cmsb);
1216 } else if (bcs->mode == L1_MODE_FAX) {
1217 isar_pump_statev_fax(bcs, ireg->cmsb);
1218 } else if (ireg->cmsb == PSEV_10MS_TIMER) {
1219 if (cs->debug & L1_DEB_HSCX)
1220 debugl1(cs, "pump stev TIMER");
1222 if (cs->debug & L1_DEB_WARN)
1223 debugl1(cs, "isar IIS_PSTEV pmode %d stat %x",
1224 bcs->mode, ireg->cmsb);
1227 debugl1(cs, "isar spurious IIS_PSTEV %x/%x/%x",
1228 ireg->iis, ireg->cmsb, ireg->clsb);
1229 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
1232 case ISAR_IIS_PSTRSP:
1233 if ((bcs = sel_bcs_isar(cs, ireg->iis >> 6))) {
1234 rcv_mbox(cs, ireg, (u_char *)ireg->par);
1235 isar_pump_status_rsp(bcs, ireg);
1237 debugl1(cs, "isar spurious IIS_PSTRSP %x/%x/%x",
1238 ireg->iis, ireg->cmsb, ireg->clsb);
1239 cs->BC_Write_Reg(cs, 1, ISAR_IIA, 0);
1243 case ISAR_IIS_BSTRSP:
1244 case ISAR_IIS_IOM2RSP:
1245 rcv_mbox(cs, ireg, (u_char *)ireg->par);
1246 if ((cs->debug & (L1_DEB_HSCX | L1_DEB_HSCX_FIFO))
1250 tp += sprintf(debbuf, "msg iis(%x) msb(%x)",
1251 ireg->iis, ireg->cmsb);
1252 QuickHex(tp, (u_char *)ireg->par, ireg->clsb);
1253 debugl1(cs, debbuf);
1256 case ISAR_IIS_INVMSG:
1257 rcv_mbox(cs, ireg, debbuf);
1258 if (cs->debug & L1_DEB_WARN)
1259 debugl1(cs, "invalid msg his:%x",
1263 rcv_mbox(cs, ireg, debbuf);
1264 if (cs->debug & L1_DEB_WARN)
1265 debugl1(cs, "unhandled msg iis(%x) ctrl(%x/%x)",
1266 ireg->iis, ireg->cmsb, ireg->clsb);
1269 restore_flags(flags);
1273 ftimer_handler(struct BCState *bcs) {
1275 debugl1(bcs->cs, "ftimer flags %04x",
1277 test_and_clear_bit(BC_FLG_FTI_RUN, &bcs->Flag);
1278 if (test_and_clear_bit(BC_FLG_LL_CONN, &bcs->Flag)) {
1279 isar_sched_event(bcs, B_LL_CONNECT);
1281 if (test_and_clear_bit(BC_FLG_FTI_FTS, &bcs->Flag)) {
1282 isar_sched_event(bcs, B_LL_OK);
1287 setup_pump(struct BCState *bcs) {
1288 struct IsdnCardState *cs = bcs->cs;
1289 u_char dps = SET_DPS(bcs->hw.isar.dpath);
1290 u_char ctrl, param[6];
1292 switch (bcs->mode) {
1296 sendmsg(cs, dps | ISAR_HIS_PUMPCFG, PMOD_BYPASS, 0, NULL);
1299 ctrl = PMOD_DATAMODEM;
1300 if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
1302 param[5] = PV32P6_CTN;
1304 param[5] = PV32P6_ATN;
1306 param[0] = para_TOA; /* 6 db */
1307 param[1] = PV32P2_V23R | PV32P2_V22A | PV32P2_V22B |
1308 PV32P2_V22C | PV32P2_V21 | PV32P2_BEL;
1309 param[2] = PV32P3_AMOD | PV32P3_V32B | PV32P3_V23B;
1310 param[3] = PV32P4_UT144;
1311 param[4] = PV32P5_UT144;
1312 sendmsg(cs, dps | ISAR_HIS_PUMPCFG, ctrl, 6, param);
1316 if (test_bit(BC_FLG_ORIG, &bcs->Flag)) {
1318 param[1] = PFAXP2_CTN;
1320 param[1] = PFAXP2_ATN;
1322 param[0] = para_TOA; /* 6 db */
1323 sendmsg(cs, dps | ISAR_HIS_PUMPCFG, ctrl, 2, param);
1324 bcs->hw.isar.state = STFAX_NULL;
1325 bcs->hw.isar.newcmd = 0;
1326 bcs->hw.isar.newmod = 0;
1327 test_and_set_bit(BC_FLG_FTI_RUN, &bcs->Flag);
1331 sendmsg(cs, dps | ISAR_HIS_PSTREQ, 0, 0, NULL);
1336 setup_sart(struct BCState *bcs) {
1337 struct IsdnCardState *cs = bcs->cs;
1338 u_char dps = SET_DPS(bcs->hw.isar.dpath);
1339 u_char ctrl, param[2];
1341 switch (bcs->mode) {
1343 sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_DISABLE, 0,
1347 sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_BINARY, 2,
1352 sendmsg(cs, dps | ISAR_HIS_SARTCFG, SMODE_HDLC, 1,
1356 ctrl = SMODE_V14 | SCTRL_HDMC_BOTH;
1357 param[0] = S_P1_CHS_8;
1358 param[1] = S_P2_BFT_DEF;
1359 sendmsg(cs, dps | ISAR_HIS_SARTCFG, ctrl, 2,
1363 /* SART must not configured with FAX */
1367 sendmsg(cs, dps | ISAR_HIS_BSTREQ, 0, 0, NULL);
1372 setup_iom2(struct BCState *bcs) {
1373 struct IsdnCardState *cs = bcs->cs;
1374 u_char dps = SET_DPS(bcs->hw.isar.dpath);
1375 u_char cmsb = IOM_CTRL_ENA, msg[5] = {IOM_P1_TXD,0,0,0,0};
1378 msg[1] = msg[3] = 1;
1379 switch (bcs->mode) {
1383 msg[1] = msg[3] = bcs->hw.isar.dpath + 2;
1390 cmsb |= IOM_CTRL_ALAW | IOM_CTRL_RCV;
1393 sendmsg(cs, dps | ISAR_HIS_IOM2CFG, cmsb, 5, msg);
1395 sendmsg(cs, dps | ISAR_HIS_IOM2REQ, 0, 0, NULL);
1400 modeisar(struct BCState *bcs, int mode, int bc)
1402 struct IsdnCardState *cs = bcs->cs;
1404 /* Here we are selecting the best datapath for requested mode */
1405 if(bcs->mode == L1_MODE_NULL) { /* New Setup */
1408 case L1_MODE_NULL: /* init */
1409 if (!bcs->hw.isar.dpath)
1410 /* no init for dpath 0 */
1415 /* best is datapath 2 */
1416 if (!test_and_set_bit(ISAR_DP2_USE,
1417 &bcs->hw.isar.reg->Flags))
1418 bcs->hw.isar.dpath = 2;
1419 else if (!test_and_set_bit(ISAR_DP1_USE,
1420 &bcs->hw.isar.reg->Flags))
1421 bcs->hw.isar.dpath = 1;
1423 printk(KERN_WARNING"isar modeisar both pathes in use\n");
1429 /* only datapath 1 */
1430 if (!test_and_set_bit(ISAR_DP1_USE,
1431 &bcs->hw.isar.reg->Flags))
1432 bcs->hw.isar.dpath = 1;
1434 printk(KERN_WARNING"isar modeisar analog funktions only with DP1\n");
1435 debugl1(cs, "isar modeisar analog funktions only with DP1");
1441 if (cs->debug & L1_DEB_HSCX)
1442 debugl1(cs, "isar dp%d mode %d->%d ichan %d",
1443 bcs->hw.isar.dpath, bcs->mode, mode, bc);
1448 if (bcs->mode == L1_MODE_NULL) {
1449 /* Clear resources */
1450 if (bcs->hw.isar.dpath == 1)
1451 test_and_clear_bit(ISAR_DP1_USE, &bcs->hw.isar.reg->Flags);
1452 else if (bcs->hw.isar.dpath == 2)
1453 test_and_clear_bit(ISAR_DP2_USE, &bcs->hw.isar.reg->Flags);
1454 bcs->hw.isar.dpath = 0;
1460 isar_pump_cmd(struct BCState *bcs, u_char cmd, u_char para)
1462 struct IsdnCardState *cs = bcs->cs;
1463 u_char dps = SET_DPS(bcs->hw.isar.dpath);
1464 u_char ctrl = 0, nom = 0, p1 = 0;
1467 case ISDN_FAX_CLASS1_FTM:
1468 test_and_clear_bit(BC_FLG_FRH_WAIT, &bcs->Flag);
1469 if (bcs->hw.isar.state == STFAX_READY) {
1471 ctrl = PCTRL_CMD_FTM;
1473 bcs->hw.isar.state = STFAX_LINE;
1474 bcs->hw.isar.cmd = ctrl;
1475 bcs->hw.isar.mod = para;
1476 bcs->hw.isar.newmod = 0;
1477 bcs->hw.isar.newcmd = 0;
1478 bcs->hw.isar.try_mod = 3;
1479 } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
1480 (bcs->hw.isar.cmd == PCTRL_CMD_FTM) &&
1481 (bcs->hw.isar.mod == para)) {
1482 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
1484 bcs->hw.isar.newmod = para;
1485 bcs->hw.isar.newcmd = PCTRL_CMD_FTM;
1487 ctrl = PCTRL_CMD_ESC;
1488 bcs->hw.isar.state = STFAX_ESCAPE;
1491 case ISDN_FAX_CLASS1_FTH:
1492 test_and_clear_bit(BC_FLG_FRH_WAIT, &bcs->Flag);
1493 if (bcs->hw.isar.state == STFAX_READY) {
1495 ctrl = PCTRL_CMD_FTH;
1497 bcs->hw.isar.state = STFAX_LINE;
1498 bcs->hw.isar.cmd = ctrl;
1499 bcs->hw.isar.mod = para;
1500 bcs->hw.isar.newmod = 0;
1501 bcs->hw.isar.newcmd = 0;
1502 bcs->hw.isar.try_mod = 3;
1503 } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
1504 (bcs->hw.isar.cmd == PCTRL_CMD_FTH) &&
1505 (bcs->hw.isar.mod == para)) {
1506 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
1508 bcs->hw.isar.newmod = para;
1509 bcs->hw.isar.newcmd = PCTRL_CMD_FTH;
1511 ctrl = PCTRL_CMD_ESC;
1512 bcs->hw.isar.state = STFAX_ESCAPE;
1515 case ISDN_FAX_CLASS1_FRM:
1516 test_and_clear_bit(BC_FLG_FRH_WAIT, &bcs->Flag);
1517 if (bcs->hw.isar.state == STFAX_READY) {
1519 ctrl = PCTRL_CMD_FRM;
1521 bcs->hw.isar.state = STFAX_LINE;
1522 bcs->hw.isar.cmd = ctrl;
1523 bcs->hw.isar.mod = para;
1524 bcs->hw.isar.newmod = 0;
1525 bcs->hw.isar.newcmd = 0;
1526 bcs->hw.isar.try_mod = 3;
1527 } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
1528 (bcs->hw.isar.cmd == PCTRL_CMD_FRM) &&
1529 (bcs->hw.isar.mod == para)) {
1530 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
1532 bcs->hw.isar.newmod = para;
1533 bcs->hw.isar.newcmd = PCTRL_CMD_FRM;
1535 ctrl = PCTRL_CMD_ESC;
1536 bcs->hw.isar.state = STFAX_ESCAPE;
1539 case ISDN_FAX_CLASS1_FRH:
1540 test_and_set_bit(BC_FLG_FRH_WAIT, &bcs->Flag);
1541 if (bcs->hw.isar.state == STFAX_READY) {
1543 ctrl = PCTRL_CMD_FRH;
1545 bcs->hw.isar.state = STFAX_LINE;
1546 bcs->hw.isar.cmd = ctrl;
1547 bcs->hw.isar.mod = para;
1548 bcs->hw.isar.newmod = 0;
1549 bcs->hw.isar.newcmd = 0;
1550 bcs->hw.isar.try_mod = 3;
1551 } else if ((bcs->hw.isar.state == STFAX_ACTIV) &&
1552 (bcs->hw.isar.cmd == PCTRL_CMD_FRH) &&
1553 (bcs->hw.isar.mod == para)) {
1554 ll_deliver_faxstat(bcs, ISDN_FAX_CLASS1_CONNECT);
1556 bcs->hw.isar.newmod = para;
1557 bcs->hw.isar.newcmd = PCTRL_CMD_FRH;
1559 ctrl = PCTRL_CMD_ESC;
1560 bcs->hw.isar.state = STFAX_ESCAPE;
1563 case ISDN_FAXPUMP_HALT:
1564 bcs->hw.isar.state = STFAX_NULL;
1566 ctrl = PCTRL_CMD_HALT;
1570 sendmsg(cs, dps | ISAR_HIS_PUMPCTRL, ctrl, nom, &p1);
1574 isar_setup(struct IsdnCardState *cs)
1581 for (i=0; i<2; i++) {
1583 sendmsg(cs, (i ? ISAR_HIS_DPS2 : ISAR_HIS_DPS1) |
1584 ISAR_HIS_P12CFG, 4, 1, &msg);
1585 cs->bcs[i].hw.isar.mml = msg;
1586 cs->bcs[i].mode = 0;
1587 cs->bcs[i].hw.isar.dpath = i + 1;
1588 modeisar(&cs->bcs[i], 0, 0);
1589 cs->bcs[i].tqueue.routine = (void *) (void *) isar_bh;
1594 isar_l2l1(struct PStack *st, int pr, void *arg)
1596 struct sk_buff *skb = arg;
1600 case (PH_DATA | REQUEST):
1603 if (st->l1.bcs->tx_skb) {
1604 skb_queue_tail(&st->l1.bcs->squeue, skb);
1605 restore_flags(flags);
1607 st->l1.bcs->tx_skb = skb;
1608 test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
1609 if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
1610 debugl1(st->l1.bcs->cs, "DRQ set BC_FLG_BUSY");
1611 st->l1.bcs->hw.isar.txcnt = 0;
1612 restore_flags(flags);
1613 st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
1616 case (PH_PULL | INDICATION):
1617 if (st->l1.bcs->tx_skb) {
1618 printk(KERN_WARNING "isar_l2l1: this shouldn't happen\n");
1621 test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
1622 if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
1623 debugl1(st->l1.bcs->cs, "PUI set BC_FLG_BUSY");
1624 st->l1.bcs->tx_skb = skb;
1625 st->l1.bcs->hw.isar.txcnt = 0;
1626 st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
1628 case (PH_PULL | REQUEST):
1629 if (!st->l1.bcs->tx_skb) {
1630 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
1631 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
1633 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
1635 case (PH_ACTIVATE | REQUEST):
1636 test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
1637 st->l1.bcs->hw.isar.conmsg[0] = 0;
1638 if (test_bit(FLG_ORIG, &st->l2.flag))
1639 test_and_set_bit(BC_FLG_ORIG, &st->l1.bcs->Flag);
1641 test_and_clear_bit(BC_FLG_ORIG, &st->l1.bcs->Flag);
1642 switch(st->l1.mode) {
1645 if (modeisar(st->l1.bcs, st->l1.mode, st->l1.bc))
1646 l1_msg_b(st, PH_DEACTIVATE | REQUEST, arg);
1648 l1_msg_b(st, PH_ACTIVATE | REQUEST, arg);
1652 if (modeisar(st->l1.bcs, st->l1.mode, st->l1.bc))
1653 l1_msg_b(st, PH_DEACTIVATE | REQUEST, arg);
1657 case (PH_DEACTIVATE | REQUEST):
1658 l1_msg_b(st, pr, arg);
1660 case (PH_DEACTIVATE | CONFIRM):
1661 switch(st->l1.mode) {
1667 isar_pump_cmd(st->l1.bcs, ISDN_FAXPUMP_HALT, 0);
1670 test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
1671 test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
1672 if (st->l1.bcs->cs->debug & L1_DEB_HSCX)
1673 debugl1(st->l1.bcs->cs, "PDAC clear BC_FLG_BUSY");
1674 modeisar(st->l1.bcs, 0, st->l1.bc);
1675 st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
1681 close_isarstate(struct BCState *bcs)
1683 modeisar(bcs, 0, bcs->channel);
1684 if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
1685 if (bcs->hw.isar.rcvbuf) {
1686 kfree(bcs->hw.isar.rcvbuf);
1687 bcs->hw.isar.rcvbuf = NULL;
1689 skb_queue_purge(&bcs->rqueue);
1690 skb_queue_purge(&bcs->squeue);
1692 dev_kfree_skb_any(bcs->tx_skb);
1694 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
1695 if (bcs->cs->debug & L1_DEB_HSCX)
1696 debugl1(bcs->cs, "closeisar clear BC_FLG_BUSY");
1699 del_timer(&bcs->hw.isar.ftimer);
1703 open_isarstate(struct IsdnCardState *cs, struct BCState *bcs)
1705 if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
1706 if (!(bcs->hw.isar.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
1708 "HiSax: No memory for isar.rcvbuf\n");
1711 skb_queue_head_init(&bcs->rqueue);
1712 skb_queue_head_init(&bcs->squeue);
1715 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
1716 if (cs->debug & L1_DEB_HSCX)
1717 debugl1(cs, "openisar clear BC_FLG_BUSY");
1719 bcs->hw.isar.rcvidx = 0;
1721 bcs->hw.isar.ftimer.function = (void *) ftimer_handler;
1722 bcs->hw.isar.ftimer.data = (long) bcs;
1723 init_timer(&bcs->hw.isar.ftimer);
1728 setstack_isar(struct PStack *st, struct BCState *bcs)
1730 bcs->channel = st->l1.bc;
1731 if (open_isarstate(st->l1.hardware, bcs))
1734 st->l2.l2l1 = isar_l2l1;
1735 setstack_manager(st);
1742 isar_auxcmd(struct IsdnCardState *cs, isdn_ctrl *ic) {
1745 struct BCState *bcs;
1747 if (cs->debug & L1_DEB_HSCX)
1748 debugl1(cs, "isar_auxcmd cmd/ch %x/%d", ic->command, ic->arg);
1749 switch (ic->command) {
1750 case (ISDN_CMD_FAXCMD):
1751 bcs = cs->channel[ic->arg].bcs;
1752 if (cs->debug & L1_DEB_HSCX)
1753 debugl1(cs, "isar_auxcmd cmd/subcmd %d/%d",
1754 ic->parm.aux.cmd, ic->parm.aux.subcmd);
1755 switch(ic->parm.aux.cmd) {
1756 case ISDN_FAX_CLASS1_CTRL:
1757 if (ic->parm.aux.subcmd == ETX)
1758 test_and_set_bit(BC_FLG_DLEETX,
1761 case ISDN_FAX_CLASS1_FTS:
1762 if (ic->parm.aux.subcmd == AT_QUERY) {
1763 ic->command = ISDN_STAT_FAXIND;
1764 ic->parm.aux.cmd = ISDN_FAX_CLASS1_OK;
1765 cs->iif.statcallb(ic);
1767 } else if (ic->parm.aux.subcmd == AT_EQ_QUERY) {
1768 strcpy(ic->parm.aux.para, "0-255");
1769 ic->command = ISDN_STAT_FAXIND;
1770 ic->parm.aux.cmd = ISDN_FAX_CLASS1_QUERY;
1771 cs->iif.statcallb(ic);
1773 } else if (ic->parm.aux.subcmd == AT_EQ_VALUE) {
1774 if (cs->debug & L1_DEB_HSCX)
1775 debugl1(cs, "isar_auxcmd %s=%d",
1776 FC1_CMD[ic->parm.aux.cmd], ic->parm.aux.para[0]);
1777 if (bcs->hw.isar.state == STFAX_READY) {
1778 if (! ic->parm.aux.para[0]) {
1779 ic->command = ISDN_STAT_FAXIND;
1780 ic->parm.aux.cmd = ISDN_FAX_CLASS1_OK;
1781 cs->iif.statcallb(ic);
1784 if (! test_and_set_bit(BC_FLG_FTI_RUN, &bcs->Flag)) {
1786 bcs->hw.isar.ftimer.expires =
1787 jiffies + ((ic->parm.aux.para[0] * 10 * HZ)/1000);
1788 test_and_set_bit(BC_FLG_FTI_FTS, &bcs->Flag);
1789 add_timer(&bcs->hw.isar.ftimer);
1793 debugl1(cs, "isar FTS=%d and FTI busy",
1794 ic->parm.aux.para[0]);
1798 debugl1(cs, "isar FTS=%d and isar.state not ready(%x)",
1799 ic->parm.aux.para[0],bcs->hw.isar.state);
1801 ic->command = ISDN_STAT_FAXIND;
1802 ic->parm.aux.cmd = ISDN_FAX_CLASS1_ERROR;
1803 cs->iif.statcallb(ic);
1806 case ISDN_FAX_CLASS1_FRM:
1807 case ISDN_FAX_CLASS1_FRH:
1808 case ISDN_FAX_CLASS1_FTM:
1809 case ISDN_FAX_CLASS1_FTH:
1810 if (ic->parm.aux.subcmd == AT_QUERY) {
1811 sprintf(ic->parm.aux.para,
1812 "%d", bcs->hw.isar.mod);
1813 ic->command = ISDN_STAT_FAXIND;
1814 ic->parm.aux.cmd = ISDN_FAX_CLASS1_QUERY;
1815 cs->iif.statcallb(ic);
1817 } else if (ic->parm.aux.subcmd == AT_EQ_QUERY) {
1818 char *p = ic->parm.aux.para;
1819 for(i=0;i<FAXMODCNT;i++)
1820 if ((1<<i) & modmask)
1821 p += sprintf(p, "%d,", faxmodulation[i]);
1824 ic->command = ISDN_STAT_FAXIND;
1825 ic->parm.aux.cmd = ISDN_FAX_CLASS1_QUERY;
1826 cs->iif.statcallb(ic);
1828 } else if (ic->parm.aux.subcmd == AT_EQ_VALUE) {
1829 if (cs->debug & L1_DEB_HSCX)
1830 debugl1(cs, "isar_auxcmd %s=%d",
1831 FC1_CMD[ic->parm.aux.cmd], ic->parm.aux.para[0]);
1832 for(i=0;i<FAXMODCNT;i++)
1833 if (faxmodulation[i]==ic->parm.aux.para[0])
1835 if ((i < FAXMODCNT) && ((1<<i) & modmask) &&
1836 test_bit(BC_FLG_INIT, &bcs->Flag)) {
1839 ic->parm.aux.para[0]);
1843 /* wrong modulation or not activ */
1846 ic->command = ISDN_STAT_FAXIND;
1847 ic->parm.aux.cmd = ISDN_FAX_CLASS1_ERROR;
1848 cs->iif.statcallb(ic);
1851 case (ISDN_CMD_IOCTL):
1853 case 9: /* load firmware */
1854 features = ISDN_FEATURE_L2_MODEM |
1855 ISDN_FEATURE_L2_FAX |
1856 ISDN_FEATURE_L3_FCLASS1;
1857 memcpy(&adr, ic->parm.num, sizeof(ulong));
1858 if (isar_load_firmware(cs, (u_char *)adr))
1861 ll_run(cs, features);
1864 features = *(unsigned int *) ic->parm.num;
1865 printk(KERN_DEBUG "HiSax: max modulation old(%04x) new(%04x)\n",
1870 features = *(unsigned int *) ic->parm.num;
1871 printk(KERN_DEBUG "HiSax: FRM extra delay old(%d) new(%d) ms\n",
1872 frm_extra_delay, features);
1874 frm_extra_delay = features;
1877 features = *(unsigned int *) ic->parm.num;
1878 printk(KERN_DEBUG "HiSax: TOA old(%d) new(%d) db\n",
1879 para_TOA, features);
1880 if (features >= 0 && features < 32)
1881 para_TOA = features;
1884 printk(KERN_DEBUG "HiSax: invalid ioctl %d\n",
1896 initisar(struct IsdnCardState *cs)
1898 cs->bcs[0].BC_SetStack = setstack_isar;
1899 cs->bcs[1].BC_SetStack = setstack_isar;
1900 cs->bcs[0].BC_Close = close_isarstate;
1901 cs->bcs[1].BC_Close = close_isarstate;