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