[NET]: Transform skb_queue_len() binary tests into skb_queue_empty()
[linux-3.10.git] / drivers / isdn / i4l / isdn_tty.c
1 /* $Id: isdn_tty.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $
2  *
3  * Linux ISDN subsystem, tty functions and AT-command emulator (linklevel).
4  *
5  * Copyright 1994-1999  by Fritz Elfert (fritz@isdn4linux.de)
6  * Copyright 1995,96    by Thinking Objects Software GmbH Wuerzburg
7  *
8  * This software may be used and distributed according to the terms
9  * of the GNU General Public License, incorporated herein by reference.
10  *
11  */
12 #undef ISDN_TTY_STAT_DEBUG
13
14 #include <linux/config.h>
15 #include <linux/isdn.h>
16 #include <linux/delay.h>
17 #include "isdn_common.h"
18 #include "isdn_tty.h"
19 #ifdef CONFIG_ISDN_AUDIO
20 #include "isdn_audio.h"
21 #define VBUF 0x3e0
22 #define VBUFX (VBUF/16)
23 #endif
24
25 #define FIX_FILE_TRANSFER
26 #define DUMMY_HAYES_AT
27
28 /* Prototypes */
29
30 static int isdn_tty_edit_at(const char *, int, modem_info *);
31 static void isdn_tty_check_esc(const u_char *, u_char, int, int *, u_long *);
32 static void isdn_tty_modem_reset_regs(modem_info *, int);
33 static void isdn_tty_cmd_ATA(modem_info *);
34 static void isdn_tty_flush_buffer(struct tty_struct *);
35 static void isdn_tty_modem_result(int, modem_info *);
36 #ifdef CONFIG_ISDN_AUDIO
37 static int isdn_tty_countDLE(unsigned char *, int);
38 #endif
39
40 /* Leave this unchanged unless you know what you do! */
41 #define MODEM_PARANOIA_CHECK
42 #define MODEM_DO_RESTART
43
44 static int bit2si[8] =
45 {1, 5, 7, 7, 7, 7, 7, 7};
46 static int si2bit[8] =
47 {4, 1, 4, 4, 4, 4, 4, 4};
48
49 char *isdn_tty_revision = "$Revision: 1.1.2.3 $";
50
51
52 /* isdn_tty_try_read() is called from within isdn_tty_rcv_skb()
53  * to stuff incoming data directly into a tty's flip-buffer. This
54  * is done to speed up tty-receiving if the receive-queue is empty.
55  * This routine MUST be called with interrupts off.
56  * Return:
57  *  1 = Success
58  *  0 = Failure, data has to be buffered and later processed by
59  *      isdn_tty_readmodem().
60  */
61 static int
62 isdn_tty_try_read(modem_info * info, struct sk_buff *skb)
63 {
64         int c;
65         int len;
66         struct tty_struct *tty;
67
68         if (info->online) {
69                 if ((tty = info->tty)) {
70                         if (info->mcr & UART_MCR_RTS) {
71                                 c = TTY_FLIPBUF_SIZE - tty->flip.count;
72                                 len = skb->len
73 #ifdef CONFIG_ISDN_AUDIO
74                                         + ISDN_AUDIO_SKB_DLECOUNT(skb)
75 #endif
76                                         ;
77                                 if (c >= len) {
78 #ifdef CONFIG_ISDN_AUDIO
79                                         if (ISDN_AUDIO_SKB_DLECOUNT(skb))
80                                                 while (skb->len--) {
81                                                         if (*skb->data == DLE)
82                                                                 tty_insert_flip_char(tty, DLE, 0);
83                                                         tty_insert_flip_char(tty, *skb->data++, 0);
84                                         } else {
85 #endif
86                                                 memcpy(tty->flip.char_buf_ptr,
87                                                        skb->data, len);
88                                                 tty->flip.count += len;
89                                                 tty->flip.char_buf_ptr += len;
90                                                 memset(tty->flip.flag_buf_ptr, 0, len);
91                                                 tty->flip.flag_buf_ptr += len;
92 #ifdef CONFIG_ISDN_AUDIO
93                                         }
94 #endif
95                                         if (info->emu.mdmreg[REG_CPPP] & BIT_CPPP)
96                                                 tty->flip.flag_buf_ptr[len - 1] = 0xff;
97                                         schedule_delayed_work(&tty->flip.work, 1);
98                                         kfree_skb(skb);
99                                         return 1;
100                                 }
101                         }
102                 }
103         }
104         return 0;
105 }
106
107 /* isdn_tty_readmodem() is called periodically from within timer-interrupt.
108  * It tries getting received data from the receive queue an stuff it into
109  * the tty's flip-buffer.
110  */
111 void
112 isdn_tty_readmodem(void)
113 {
114         int resched = 0;
115         int midx;
116         int i;
117         int c;
118         int r;
119         struct tty_struct *tty;
120         modem_info *info;
121
122         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
123                 if ((midx = dev->m_idx[i]) >= 0) {
124                         info = &dev->mdm.info[midx];
125                         if (info->online) {
126                                 r = 0;
127 #ifdef CONFIG_ISDN_AUDIO
128                                 isdn_audio_eval_dtmf(info);
129                                 if ((info->vonline & 1) && (info->emu.vpar[1]))
130                                         isdn_audio_eval_silence(info);
131 #endif
132                                 if ((tty = info->tty)) {
133                                         if (info->mcr & UART_MCR_RTS) {
134                                                 c = TTY_FLIPBUF_SIZE - tty->flip.count;
135                                                 if (c > 0) {
136                                                         r = isdn_readbchan(info->isdn_driver, info->isdn_channel,
137                                                                            tty->flip.char_buf_ptr,
138                                                                            tty->flip.flag_buf_ptr, c, NULL);
139                                                         /* CISCO AsyncPPP Hack */
140                                                         if (!(info->emu.mdmreg[REG_CPPP] & BIT_CPPP))
141                                                                 memset(tty->flip.flag_buf_ptr, 0, r);
142                                                         tty->flip.count += r;
143                                                         tty->flip.flag_buf_ptr += r;
144                                                         tty->flip.char_buf_ptr += r;
145                                                         if (r)
146                                                                 schedule_delayed_work(&tty->flip.work, 1);
147                                                 }
148                                         } else
149                                                 r = 1;
150                                 } else
151                                         r = 1;
152                                 if (r) {
153                                         info->rcvsched = 0;
154                                         resched = 1;
155                                 } else
156                                         info->rcvsched = 1;
157                         }
158                 }
159         }
160         if (!resched)
161                 isdn_timer_ctrl(ISDN_TIMER_MODEMREAD, 0);
162 }
163
164 int
165 isdn_tty_rcv_skb(int i, int di, int channel, struct sk_buff *skb)
166 {
167         ulong flags;
168         int midx;
169 #ifdef CONFIG_ISDN_AUDIO
170         int ifmt;
171 #endif
172         modem_info *info;
173
174         if ((midx = dev->m_idx[i]) < 0) {
175                 /* if midx is invalid, packet is not for tty */
176                 return 0;
177         }
178         info = &dev->mdm.info[midx];
179 #ifdef CONFIG_ISDN_AUDIO
180         ifmt = 1;
181         
182         if ((info->vonline) && (!info->emu.vpar[4]))
183                 isdn_audio_calc_dtmf(info, skb->data, skb->len, ifmt);
184         if ((info->vonline & 1) && (info->emu.vpar[1]))
185                 isdn_audio_calc_silence(info, skb->data, skb->len, ifmt);
186 #endif
187         if ((info->online < 2)
188 #ifdef CONFIG_ISDN_AUDIO
189             && (!(info->vonline & 1))
190 #endif
191                 ) {
192                 /* If Modem not listening, drop data */
193                 kfree_skb(skb);
194                 return 1;
195         }
196         if (info->emu.mdmreg[REG_T70] & BIT_T70) {
197                 if (info->emu.mdmreg[REG_T70] & BIT_T70_EXT) {
198                         /* T.70 decoding: throw away the T.70 header (2 or 4 bytes)   */
199                         if (skb->data[0] == 3) /* pure data packet -> 4 byte headers  */
200                                 skb_pull(skb, 4);
201                         else
202                                 if (skb->data[0] == 1) /* keepalive packet -> 2 byte hdr  */
203                                         skb_pull(skb, 2);
204                 } else
205                         /* T.70 decoding: Simply throw away the T.70 header (4 bytes) */
206                         if ((skb->data[0] == 1) && ((skb->data[1] == 0) || (skb->data[1] == 1)))
207                                 skb_pull(skb, 4);
208         }
209 #ifdef CONFIG_ISDN_AUDIO
210         ISDN_AUDIO_SKB_DLECOUNT(skb) = 0;
211         ISDN_AUDIO_SKB_LOCK(skb) = 0;
212         if (info->vonline & 1) {
213                 /* voice conversion/compression */
214                 switch (info->emu.vpar[3]) {
215                         case 2:
216                         case 3:
217                         case 4:
218                                 /* adpcm
219                                  * Since compressed data takes less
220                                  * space, we can overwrite the buffer.
221                                  */
222                                 skb_trim(skb, isdn_audio_xlaw2adpcm(info->adpcmr,
223                                                                     ifmt,
224                                                                     skb->data,
225                                                                     skb->data,
226                                                                     skb->len));
227                                 break;
228                         case 5:
229                                 /* a-law */
230                                 if (!ifmt)
231                                         isdn_audio_ulaw2alaw(skb->data, skb->len);
232                                 break;
233                         case 6:
234                                 /* u-law */
235                                 if (ifmt)
236                                         isdn_audio_alaw2ulaw(skb->data, skb->len);
237                                 break;
238                 }
239                 ISDN_AUDIO_SKB_DLECOUNT(skb) =
240                         isdn_tty_countDLE(skb->data, skb->len);
241         }
242 #ifdef CONFIG_ISDN_TTY_FAX
243         else {
244                 if (info->faxonline & 2) {
245                         isdn_tty_fax_bitorder(info, skb);
246                         ISDN_AUDIO_SKB_DLECOUNT(skb) =
247                                 isdn_tty_countDLE(skb->data, skb->len);
248                 }
249         }
250 #endif
251 #endif
252         /* Try to deliver directly via tty-flip-buf if queue is empty */
253         spin_lock_irqsave(&info->readlock, flags);
254         if (skb_queue_empty(&dev->drv[di]->rpqueue[channel]))
255                 if (isdn_tty_try_read(info, skb)) {
256                         spin_unlock_irqrestore(&info->readlock, flags);
257                         return 1;
258                 }
259         /* Direct deliver failed or queue wasn't empty.
260          * Queue up for later dequeueing via timer-irq.
261          */
262         __skb_queue_tail(&dev->drv[di]->rpqueue[channel], skb);
263         dev->drv[di]->rcvcount[channel] +=
264                 (skb->len
265 #ifdef CONFIG_ISDN_AUDIO
266                  + ISDN_AUDIO_SKB_DLECOUNT(skb)
267 #endif
268                         );
269         spin_unlock_irqrestore(&info->readlock, flags);
270         /* Schedule dequeuing */
271         if ((dev->modempoll) && (info->rcvsched))
272                 isdn_timer_ctrl(ISDN_TIMER_MODEMREAD, 1);
273         return 1;
274 }
275
276 static void
277 isdn_tty_cleanup_xmit(modem_info * info)
278 {
279         skb_queue_purge(&info->xmit_queue);
280 #ifdef CONFIG_ISDN_AUDIO
281         skb_queue_purge(&info->dtmf_queue);
282 #endif
283 }
284
285 static void
286 isdn_tty_tint(modem_info * info)
287 {
288         struct sk_buff *skb = skb_dequeue(&info->xmit_queue);
289         int len, slen;
290
291         if (!skb)
292                 return;
293         len = skb->len;
294         if ((slen = isdn_writebuf_skb_stub(info->isdn_driver,
295                                            info->isdn_channel, 1, skb)) == len) {
296                 struct tty_struct *tty = info->tty;
297                 info->send_outstanding++;
298                 info->msr &= ~UART_MSR_CTS;
299                 info->lsr &= ~UART_LSR_TEMT;
300                 tty_wakeup(tty);
301                 return;
302         }
303         if (slen < 0) {
304                 /* Error: no channel, already shutdown, or wrong parameter */
305                 dev_kfree_skb(skb);
306                 return;
307         }
308         skb_queue_head(&info->xmit_queue, skb);
309 }
310
311 #ifdef CONFIG_ISDN_AUDIO
312 static int
313 isdn_tty_countDLE(unsigned char *buf, int len)
314 {
315         int count = 0;
316
317         while (len--)
318                 if (*buf++ == DLE)
319                         count++;
320         return count;
321 }
322
323 /* This routine is called from within isdn_tty_write() to perform
324  * DLE-decoding when sending audio-data.
325  */
326 static int
327 isdn_tty_handleDLEdown(modem_info * info, atemu * m, int len)
328 {
329         unsigned char *p = &info->xmit_buf[info->xmit_count];
330         int count = 0;
331
332         while (len > 0) {
333                 if (m->lastDLE) {
334                         m->lastDLE = 0;
335                         switch (*p) {
336                                 case DLE:
337                                         /* Escape code */
338                                         if (len > 1)
339                                                 memmove(p, p + 1, len - 1);
340                                         p--;
341                                         count++;
342                                         break;
343                                 case ETX:
344                                         /* End of data */
345                                         info->vonline |= 4;
346                                         return count;
347                                 case DC4:
348                                         /* Abort RX */
349                                         info->vonline &= ~1;
350 #ifdef ISDN_DEBUG_MODEM_VOICE
351                                         printk(KERN_DEBUG
352                                                "DLEdown: got DLE-DC4, send DLE-ETX on ttyI%d\n",
353                                                info->line);
354 #endif
355                                         isdn_tty_at_cout("\020\003", info);
356                                         if (!info->vonline) {
357 #ifdef ISDN_DEBUG_MODEM_VOICE
358                                                 printk(KERN_DEBUG
359                                                        "DLEdown: send VCON on ttyI%d\n",
360                                                        info->line);
361 #endif
362                                                 isdn_tty_at_cout("\r\nVCON\r\n", info);
363                                         }
364                                         /* Fall through */
365                                 case 'q':
366                                 case 's':
367                                         /* Silence */
368                                         if (len > 1)
369                                                 memmove(p, p + 1, len - 1);
370                                         p--;
371                                         break;
372                         }
373                 } else {
374                         if (*p == DLE)
375                                 m->lastDLE = 1;
376                         else
377                                 count++;
378                 }
379                 p++;
380                 len--;
381         }
382         if (len < 0) {
383                 printk(KERN_WARNING "isdn_tty: len<0 in DLEdown\n");
384                 return 0;
385         }
386         return count;
387 }
388
389 /* This routine is called from within isdn_tty_write() when receiving
390  * audio-data. It interrupts receiving, if an character other than
391  * ^S or ^Q is sent.
392  */
393 static int
394 isdn_tty_end_vrx(const char *buf, int c)
395 {
396         char ch;
397
398         while (c--) {
399                 ch = *buf;
400                 if ((ch != 0x11) && (ch != 0x13))
401                         return 1;
402                 buf++;
403         }
404         return 0;
405 }
406
407 static int voice_cf[7] =
408 {0, 0, 4, 3, 2, 0, 0};
409
410 #endif                          /* CONFIG_ISDN_AUDIO */
411
412 /* isdn_tty_senddown() is called either directly from within isdn_tty_write()
413  * or via timer-interrupt from within isdn_tty_modem_xmit(). It pulls
414  * outgoing data from the tty's xmit-buffer, handles voice-decompression or
415  * T.70 if necessary, and finally queues it up for sending via isdn_tty_tint.
416  */
417 static void
418 isdn_tty_senddown(modem_info * info)
419 {
420         int buflen;
421         int skb_res;
422 #ifdef CONFIG_ISDN_AUDIO
423         int audio_len;
424 #endif
425         struct sk_buff *skb;
426
427 #ifdef CONFIG_ISDN_AUDIO
428         if (info->vonline & 4) {
429                 info->vonline &= ~6;
430                 if (!info->vonline) {
431 #ifdef ISDN_DEBUG_MODEM_VOICE
432                         printk(KERN_DEBUG
433                                "senddown: send VCON on ttyI%d\n",
434                                info->line);
435 #endif
436                         isdn_tty_at_cout("\r\nVCON\r\n", info);
437                 }
438         }
439 #endif
440         if (!(buflen = info->xmit_count))
441                 return;
442         if ((info->emu.mdmreg[REG_CTS] & BIT_CTS) != 0)
443                 info->msr &= ~UART_MSR_CTS;
444         info->lsr &= ~UART_LSR_TEMT;    
445         /* info->xmit_count is modified here and in isdn_tty_write().
446          * So we return here if isdn_tty_write() is in the
447          * critical section.
448          */
449         atomic_inc(&info->xmit_lock);
450         if (!(atomic_dec_and_test(&info->xmit_lock)))
451                 return;
452         if (info->isdn_driver < 0) {
453                 info->xmit_count = 0;
454                 return;
455         }
456         skb_res = dev->drv[info->isdn_driver]->interface->hl_hdrlen + 4;
457 #ifdef CONFIG_ISDN_AUDIO
458         if (info->vonline & 2)
459                 audio_len = buflen * voice_cf[info->emu.vpar[3]];
460         else
461                 audio_len = 0;
462         skb = dev_alloc_skb(skb_res + buflen + audio_len);
463 #else
464         skb = dev_alloc_skb(skb_res + buflen);
465 #endif
466         if (!skb) {
467                 printk(KERN_WARNING
468                        "isdn_tty: Out of memory in ttyI%d senddown\n",
469                        info->line);
470                 return;
471         }
472         skb_reserve(skb, skb_res);
473         memcpy(skb_put(skb, buflen), info->xmit_buf, buflen);
474         info->xmit_count = 0;
475 #ifdef CONFIG_ISDN_AUDIO
476         if (info->vonline & 2) {
477                 /* For now, ifmt is fixed to 1 (alaw), since this
478                  * is used with ISDN everywhere in the world, except
479                  * US, Canada and Japan.
480                  * Later, when US-ISDN protocols are implemented,
481                  * this setting will depend on the D-channel protocol.
482                  */
483                 int ifmt = 1;
484
485                 /* voice conversion/decompression */
486                 switch (info->emu.vpar[3]) {
487                         case 2:
488                         case 3:
489                         case 4:
490                                 /* adpcm, compatible to ZyXel 1496 modem
491                                  * with ROM revision 6.01
492                                  */
493                                 audio_len = isdn_audio_adpcm2xlaw(info->adpcms,
494                                                                   ifmt,
495                                                                   skb->data,
496                                                     skb_put(skb, audio_len),
497                                                                   buflen);
498                                 skb_pull(skb, buflen);
499                                 skb_trim(skb, audio_len);
500                                 break;
501                         case 5:
502                                 /* a-law */
503                                 if (!ifmt)
504                                         isdn_audio_alaw2ulaw(skb->data,
505                                                              buflen);
506                                 break;
507                         case 6:
508                                 /* u-law */
509                                 if (ifmt)
510                                         isdn_audio_ulaw2alaw(skb->data,
511                                                              buflen);
512                                 break;
513                 }
514         }
515 #endif                          /* CONFIG_ISDN_AUDIO */
516         if (info->emu.mdmreg[REG_T70] & BIT_T70) {
517                 /* Add T.70 simplified header */
518                 if (info->emu.mdmreg[REG_T70] & BIT_T70_EXT)
519                         memcpy(skb_push(skb, 2), "\1\0", 2);
520                 else
521                         memcpy(skb_push(skb, 4), "\1\0\1\0", 4);
522         }
523         skb_queue_tail(&info->xmit_queue, skb);
524 }
525
526 /************************************************************
527  *
528  * Modem-functions
529  *
530  * mostly "stolen" from original Linux-serial.c and friends.
531  *
532  ************************************************************/
533
534 /* The next routine is called once from within timer-interrupt
535  * triggered within isdn_tty_modem_ncarrier(). It calls
536  * isdn_tty_modem_result() to stuff a "NO CARRIER" Message
537  * into the tty's flip-buffer.
538  */
539 static void
540 isdn_tty_modem_do_ncarrier(unsigned long data)
541 {
542         modem_info *info = (modem_info *) data;
543         isdn_tty_modem_result(RESULT_NO_CARRIER, info);
544 }
545
546 /* Next routine is called, whenever the DTR-signal is raised.
547  * It checks the ncarrier-flag, and triggers the above routine
548  * when necessary. The ncarrier-flag is set, whenever DTR goes
549  * low.
550  */
551 static void
552 isdn_tty_modem_ncarrier(modem_info * info)
553 {
554         if (info->ncarrier) {
555                 info->nc_timer.expires = jiffies + HZ;
556                 add_timer(&info->nc_timer);
557         }
558 }
559
560 /*
561  * return the usage calculated by si and layer 2 protocol
562  */
563 static int
564 isdn_calc_usage(int si, int l2)
565 {
566         int usg = ISDN_USAGE_MODEM;
567
568 #ifdef CONFIG_ISDN_AUDIO
569         if (si == 1) {
570                 switch(l2) {
571                         case ISDN_PROTO_L2_MODEM: 
572                                 usg = ISDN_USAGE_MODEM;
573                                 break;
574 #ifdef CONFIG_ISDN_TTY_FAX
575                         case ISDN_PROTO_L2_FAX: 
576                                 usg = ISDN_USAGE_FAX;
577                                 break;
578 #endif
579                         case ISDN_PROTO_L2_TRANS: 
580                         default:
581                                 usg = ISDN_USAGE_VOICE;
582                                 break;
583                 }
584         }
585 #endif
586         return(usg);
587 }
588
589 /* isdn_tty_dial() performs dialing of a tty an the necessary
590  * setup of the lower levels before that.
591  */
592 static void
593 isdn_tty_dial(char *n, modem_info * info, atemu * m)
594 {
595         int usg = ISDN_USAGE_MODEM;
596         int si = 7;
597         int l2 = m->mdmreg[REG_L2PROT];
598         u_long flags;
599         isdn_ctrl cmd;
600         int i;
601         int j;
602
603         for (j = 7; j >= 0; j--)
604                 if (m->mdmreg[REG_SI1] & (1 << j)) {
605                         si = bit2si[j];
606                         break;
607                 }
608         usg = isdn_calc_usage(si, l2);
609 #ifdef CONFIG_ISDN_AUDIO
610         if ((si == 1) && 
611                 (l2 != ISDN_PROTO_L2_MODEM)
612 #ifdef CONFIG_ISDN_TTY_FAX
613                 && (l2 != ISDN_PROTO_L2_FAX)
614 #endif
615                 ) {
616                 l2 = ISDN_PROTO_L2_TRANS;
617                 usg = ISDN_USAGE_VOICE;
618         }
619 #endif
620         m->mdmreg[REG_SI1I] = si2bit[si];
621         spin_lock_irqsave(&dev->lock, flags);
622         i = isdn_get_free_channel(usg, l2, m->mdmreg[REG_L3PROT], -1, -1, m->msn);
623         if (i < 0) {
624                 spin_unlock_irqrestore(&dev->lock, flags);
625                 isdn_tty_modem_result(RESULT_NO_DIALTONE, info);
626         } else {
627                 info->isdn_driver = dev->drvmap[i];
628                 info->isdn_channel = dev->chanmap[i];
629                 info->drv_index = i;
630                 dev->m_idx[i] = info->line;
631                 dev->usage[i] |= ISDN_USAGE_OUTGOING;
632                 info->last_dir = 1;
633                 strcpy(info->last_num, n);
634                 isdn_info_update();
635                 spin_unlock_irqrestore(&dev->lock, flags);
636                 cmd.driver = info->isdn_driver;
637                 cmd.arg = info->isdn_channel;
638                 cmd.command = ISDN_CMD_CLREAZ;
639                 isdn_command(&cmd);
640                 strcpy(cmd.parm.num, isdn_map_eaz2msn(m->msn, info->isdn_driver));
641                 cmd.driver = info->isdn_driver;
642                 cmd.command = ISDN_CMD_SETEAZ;
643                 isdn_command(&cmd);
644                 cmd.driver = info->isdn_driver;
645                 cmd.command = ISDN_CMD_SETL2;
646                 info->last_l2 = l2;
647                 cmd.arg = info->isdn_channel + (l2 << 8);
648                 isdn_command(&cmd);
649                 cmd.driver = info->isdn_driver;
650                 cmd.command = ISDN_CMD_SETL3;
651                 cmd.arg = info->isdn_channel + (m->mdmreg[REG_L3PROT] << 8);
652 #ifdef CONFIG_ISDN_TTY_FAX
653                 if (l2 == ISDN_PROTO_L2_FAX) {
654                         cmd.parm.fax = info->fax;
655                         info->fax->direction = ISDN_TTY_FAX_CONN_OUT;
656                 }
657 #endif
658                 isdn_command(&cmd);
659                 cmd.driver = info->isdn_driver;
660                 cmd.arg = info->isdn_channel;
661                 sprintf(cmd.parm.setup.phone, "%s", n);
662                 sprintf(cmd.parm.setup.eazmsn, "%s",
663                         isdn_map_eaz2msn(m->msn, info->isdn_driver));
664                 cmd.parm.setup.si1 = si;
665                 cmd.parm.setup.si2 = m->mdmreg[REG_SI2];
666                 cmd.command = ISDN_CMD_DIAL;
667                 info->dialing = 1;
668                 info->emu.carrierwait = 0;
669                 strcpy(dev->num[i], n);
670                 isdn_info_update();
671                 isdn_command(&cmd);
672                 isdn_timer_ctrl(ISDN_TIMER_CARRIER, 1);
673         }
674 }
675
676 /* isdn_tty_hangup() disassociates a tty from the real
677  * ISDN-line (hangup). The usage-status is cleared
678  * and some cleanup is done also.
679  */
680 void
681 isdn_tty_modem_hup(modem_info * info, int local)
682 {
683         isdn_ctrl cmd;
684         int di, ch;
685
686         if (!info)
687                 return;
688
689         di = info->isdn_driver;
690         ch = info->isdn_channel;
691         if (di < 0 || ch < 0)
692                 return;
693
694         info->isdn_driver = -1;
695         info->isdn_channel = -1;
696
697 #ifdef ISDN_DEBUG_MODEM_HUP
698         printk(KERN_DEBUG "Mhup ttyI%d\n", info->line);
699 #endif
700         info->rcvsched = 0;
701         isdn_tty_flush_buffer(info->tty);
702         if (info->online) {
703                 info->last_lhup = local;
704                 info->online = 0;
705                 isdn_tty_modem_result(RESULT_NO_CARRIER, info);
706         }
707 #ifdef CONFIG_ISDN_AUDIO
708         info->vonline = 0;
709 #ifdef CONFIG_ISDN_TTY_FAX
710         info->faxonline = 0;
711         info->fax->phase = ISDN_FAX_PHASE_IDLE;
712 #endif
713         info->emu.vpar[4] = 0;
714         info->emu.vpar[5] = 8;
715         if (info->dtmf_state) {
716                 kfree(info->dtmf_state);
717                 info->dtmf_state = NULL;
718         }
719         if (info->silence_state) {
720                 kfree(info->silence_state);
721                 info->silence_state = NULL;
722         }
723         if (info->adpcms) {
724                 kfree(info->adpcms);
725                 info->adpcms = NULL;
726         }
727         if (info->adpcmr) {
728                 kfree(info->adpcmr);
729                 info->adpcmr = NULL;
730         }
731 #endif
732         if ((info->msr & UART_MSR_RI) &&
733                 (info->emu.mdmreg[REG_RUNG] & BIT_RUNG))
734                 isdn_tty_modem_result(RESULT_RUNG, info);
735         info->msr &= ~(UART_MSR_DCD | UART_MSR_RI);
736         info->lsr |= UART_LSR_TEMT;
737
738         if (local) {
739                 cmd.driver = di;
740                 cmd.command = ISDN_CMD_HANGUP;
741                 cmd.arg = ch;
742                 isdn_command(&cmd);
743         }
744
745         isdn_all_eaz(di, ch);
746         info->emu.mdmreg[REG_RINGCNT] = 0;
747         isdn_free_channel(di, ch, 0);
748
749         if (info->drv_index >= 0) {
750                 dev->m_idx[info->drv_index] = -1;
751                 info->drv_index = -1;
752         }
753 }
754
755 /*
756  * Begin of a CAPI like interface, currently used only for 
757  * supplementary service (CAPI 2.0 part III)
758  */
759 #include <linux/isdn/capicmd.h>
760
761 int
762 isdn_tty_capi_facility(capi_msg *cm) {
763         return(-1); /* dummy */
764 }
765
766 /* isdn_tty_suspend() tries to suspend the current tty connection
767  */
768 static void
769 isdn_tty_suspend(char *id, modem_info * info, atemu * m)
770 {
771         isdn_ctrl cmd;
772         
773         int l;
774
775         if (!info)
776                 return;
777
778 #ifdef ISDN_DEBUG_MODEM_SERVICES
779         printk(KERN_DEBUG "Msusp ttyI%d\n", info->line);
780 #endif
781         l = strlen(id);
782         if ((info->isdn_driver >= 0)) {
783                 cmd.parm.cmsg.Length = l+18;
784                 cmd.parm.cmsg.Command = CAPI_FACILITY;
785                 cmd.parm.cmsg.Subcommand = CAPI_REQ;
786                 cmd.parm.cmsg.adr.Controller = info->isdn_driver + 1;
787                 cmd.parm.cmsg.para[0] = 3; /* 16 bit 0x0003 suplementary service */
788                 cmd.parm.cmsg.para[1] = 0;
789                 cmd.parm.cmsg.para[2] = l + 3;
790                 cmd.parm.cmsg.para[3] = 4; /* 16 bit 0x0004 Suspend */
791                 cmd.parm.cmsg.para[4] = 0;
792                 cmd.parm.cmsg.para[5] = l;
793                 strncpy(&cmd.parm.cmsg.para[6], id, l);
794                 cmd.command = CAPI_PUT_MESSAGE;
795                 cmd.driver = info->isdn_driver;
796                 cmd.arg = info->isdn_channel;
797                 isdn_command(&cmd);
798         }
799 }
800
801 /* isdn_tty_resume() tries to resume a suspended call
802  * setup of the lower levels before that. unfortunatly here is no
803  * checking for compatibility of used protocols implemented by Q931
804  * It does the same things like isdn_tty_dial, the last command
805  * is different, may be we can merge it.
806  */
807
808 static void
809 isdn_tty_resume(char *id, modem_info * info, atemu * m)
810 {
811         int usg = ISDN_USAGE_MODEM;
812         int si = 7;
813         int l2 = m->mdmreg[REG_L2PROT];
814         isdn_ctrl cmd;
815         ulong flags;
816         int i;
817         int j;
818         int l;
819
820         l = strlen(id);
821         for (j = 7; j >= 0; j--)
822                 if (m->mdmreg[REG_SI1] & (1 << j)) {
823                         si = bit2si[j];
824                         break;
825                 }
826         usg = isdn_calc_usage(si, l2);
827 #ifdef CONFIG_ISDN_AUDIO
828         if ((si == 1) && 
829                 (l2 != ISDN_PROTO_L2_MODEM)
830 #ifdef CONFIG_ISDN_TTY_FAX
831                 && (l2 != ISDN_PROTO_L2_FAX)
832 #endif
833                 ) {
834                 l2 = ISDN_PROTO_L2_TRANS;
835                 usg = ISDN_USAGE_VOICE;
836         }
837 #endif
838         m->mdmreg[REG_SI1I] = si2bit[si];
839         spin_lock_irqsave(&dev->lock, flags);
840         i = isdn_get_free_channel(usg, l2, m->mdmreg[REG_L3PROT], -1, -1, m->msn);
841         if (i < 0) {
842                 spin_unlock_irqrestore(&dev->lock, flags);
843                 isdn_tty_modem_result(RESULT_NO_DIALTONE, info);
844         } else {
845                 info->isdn_driver = dev->drvmap[i];
846                 info->isdn_channel = dev->chanmap[i];
847                 info->drv_index = i;
848                 dev->m_idx[i] = info->line;
849                 dev->usage[i] |= ISDN_USAGE_OUTGOING;
850                 info->last_dir = 1;
851 //              strcpy(info->last_num, n);
852                 isdn_info_update();
853                 spin_unlock_irqrestore(&dev->lock, flags);
854                 cmd.driver = info->isdn_driver;
855                 cmd.arg = info->isdn_channel;
856                 cmd.command = ISDN_CMD_CLREAZ;
857                 isdn_command(&cmd);
858                 strcpy(cmd.parm.num, isdn_map_eaz2msn(m->msn, info->isdn_driver));
859                 cmd.driver = info->isdn_driver;
860                 cmd.command = ISDN_CMD_SETEAZ;
861                 isdn_command(&cmd);
862                 cmd.driver = info->isdn_driver;
863                 cmd.command = ISDN_CMD_SETL2;
864                 info->last_l2 = l2;
865                 cmd.arg = info->isdn_channel + (l2 << 8);
866                 isdn_command(&cmd);
867                 cmd.driver = info->isdn_driver;
868                 cmd.command = ISDN_CMD_SETL3;
869                 cmd.arg = info->isdn_channel + (m->mdmreg[REG_L3PROT] << 8);
870                 isdn_command(&cmd);
871                 cmd.driver = info->isdn_driver;
872                 cmd.arg = info->isdn_channel;
873                 cmd.parm.cmsg.Length = l+18;
874                 cmd.parm.cmsg.Command = CAPI_FACILITY;
875                 cmd.parm.cmsg.Subcommand = CAPI_REQ;
876                 cmd.parm.cmsg.adr.Controller = info->isdn_driver + 1;
877                 cmd.parm.cmsg.para[0] = 3; /* 16 bit 0x0003 suplementary service */
878                 cmd.parm.cmsg.para[1] = 0;
879                 cmd.parm.cmsg.para[2] = l+3;
880                 cmd.parm.cmsg.para[3] = 5; /* 16 bit 0x0005 Resume */
881                 cmd.parm.cmsg.para[4] = 0;
882                 cmd.parm.cmsg.para[5] = l;
883                 strncpy(&cmd.parm.cmsg.para[6], id, l);
884                 cmd.command =CAPI_PUT_MESSAGE;
885                 info->dialing = 1;
886 //              strcpy(dev->num[i], n);
887                 isdn_info_update();
888                 isdn_command(&cmd);
889                 isdn_timer_ctrl(ISDN_TIMER_CARRIER, 1);
890         }
891 }
892
893 /* isdn_tty_send_msg() sends a message to a HL driver
894  * This is used for hybrid modem cards to send AT commands to it
895  */
896
897 static void
898 isdn_tty_send_msg(modem_info * info, atemu * m, char *msg)
899 {
900         int usg = ISDN_USAGE_MODEM;
901         int si = 7;
902         int l2 = m->mdmreg[REG_L2PROT];
903         isdn_ctrl cmd;
904         ulong flags;
905         int i;
906         int j;
907         int l;
908
909         l = strlen(msg);
910         if (!l) {
911                 isdn_tty_modem_result(RESULT_ERROR, info);
912                 return;
913         }
914         for (j = 7; j >= 0; j--)
915                 if (m->mdmreg[REG_SI1] & (1 << j)) {
916                         si = bit2si[j];
917                         break;
918                 }
919         usg = isdn_calc_usage(si, l2);
920 #ifdef CONFIG_ISDN_AUDIO
921         if ((si == 1) && 
922                 (l2 != ISDN_PROTO_L2_MODEM)
923 #ifdef CONFIG_ISDN_TTY_FAX
924                 && (l2 != ISDN_PROTO_L2_FAX)
925 #endif
926                 ) {
927                 l2 = ISDN_PROTO_L2_TRANS;
928                 usg = ISDN_USAGE_VOICE;
929         }
930 #endif
931         m->mdmreg[REG_SI1I] = si2bit[si];
932         spin_lock_irqsave(&dev->lock, flags);
933         i = isdn_get_free_channel(usg, l2, m->mdmreg[REG_L3PROT], -1, -1, m->msn);
934         if (i < 0) {
935                 spin_unlock_irqrestore(&dev->lock, flags);
936                 isdn_tty_modem_result(RESULT_NO_DIALTONE, info);
937         } else {
938                 info->isdn_driver = dev->drvmap[i];
939                 info->isdn_channel = dev->chanmap[i];
940                 info->drv_index = i;
941                 dev->m_idx[i] = info->line;
942                 dev->usage[i] |= ISDN_USAGE_OUTGOING;
943                 info->last_dir = 1;
944                 isdn_info_update();
945                 spin_unlock_irqrestore(&dev->lock, flags);
946                 cmd.driver = info->isdn_driver;
947                 cmd.arg = info->isdn_channel;
948                 cmd.command = ISDN_CMD_CLREAZ;
949                 isdn_command(&cmd);
950                 strcpy(cmd.parm.num, isdn_map_eaz2msn(m->msn, info->isdn_driver));
951                 cmd.driver = info->isdn_driver;
952                 cmd.command = ISDN_CMD_SETEAZ;
953                 isdn_command(&cmd);
954                 cmd.driver = info->isdn_driver;
955                 cmd.command = ISDN_CMD_SETL2;
956                 info->last_l2 = l2;
957                 cmd.arg = info->isdn_channel + (l2 << 8);
958                 isdn_command(&cmd);
959                 cmd.driver = info->isdn_driver;
960                 cmd.command = ISDN_CMD_SETL3;
961                 cmd.arg = info->isdn_channel + (m->mdmreg[REG_L3PROT] << 8);
962                 isdn_command(&cmd);
963                 cmd.driver = info->isdn_driver;
964                 cmd.arg = info->isdn_channel;
965                 cmd.parm.cmsg.Length = l+14;
966                 cmd.parm.cmsg.Command = CAPI_MANUFACTURER;
967                 cmd.parm.cmsg.Subcommand = CAPI_REQ;
968                 cmd.parm.cmsg.adr.Controller = info->isdn_driver + 1;
969                 cmd.parm.cmsg.para[0] = l+1;
970                 strncpy(&cmd.parm.cmsg.para[1], msg, l);
971                 cmd.parm.cmsg.para[l+1] = 0xd;
972                 cmd.command =CAPI_PUT_MESSAGE;
973 /*              info->dialing = 1;
974                 strcpy(dev->num[i], n);
975                 isdn_info_update();
976 */
977                 isdn_command(&cmd);
978         }
979 }
980
981 static inline int
982 isdn_tty_paranoia_check(modem_info *info, char *name, const char *routine)
983 {
984 #ifdef MODEM_PARANOIA_CHECK
985         if (!info) {
986                 printk(KERN_WARNING "isdn_tty: null info_struct for %s in %s\n",
987                         name, routine);
988                 return 1;
989         }
990         if (info->magic != ISDN_ASYNC_MAGIC) {
991                 printk(KERN_WARNING "isdn_tty: bad magic for modem struct %s in %s\n",
992                        name, routine);
993                 return 1;
994         }
995 #endif
996         return 0;
997 }
998
999 /*
1000  * This routine is called to set the UART divisor registers to match
1001  * the specified baud rate for a serial port.
1002  */
1003 static void
1004 isdn_tty_change_speed(modem_info * info)
1005 {
1006         uint cflag,
1007          cval,
1008          fcr,
1009          quot;
1010         int i;
1011
1012         if (!info->tty || !info->tty->termios)
1013                 return;
1014         cflag = info->tty->termios->c_cflag;
1015
1016         quot = i = cflag & CBAUD;
1017         if (i & CBAUDEX) {
1018                 i &= ~CBAUDEX;
1019                 if (i < 1 || i > 2)
1020                         info->tty->termios->c_cflag &= ~CBAUDEX;
1021                 else
1022                         i += 15;
1023         }
1024         if (quot) {
1025                 info->mcr |= UART_MCR_DTR;
1026                 isdn_tty_modem_ncarrier(info);
1027         } else {
1028                 info->mcr &= ~UART_MCR_DTR;
1029                 if (info->emu.mdmreg[REG_DTRHUP] & BIT_DTRHUP) {
1030 #ifdef ISDN_DEBUG_MODEM_HUP
1031                         printk(KERN_DEBUG "Mhup in changespeed\n");
1032 #endif
1033                         if (info->online)
1034                                 info->ncarrier = 1;
1035                         isdn_tty_modem_reset_regs(info, 0);
1036                         isdn_tty_modem_hup(info, 1);
1037                 }
1038                 return;
1039         }
1040         /* byte size and parity */
1041         cval = cflag & (CSIZE | CSTOPB);
1042         cval >>= 4;
1043         if (cflag & PARENB)
1044                 cval |= UART_LCR_PARITY;
1045         if (!(cflag & PARODD))
1046                 cval |= UART_LCR_EPAR;
1047         fcr = 0;
1048
1049         /* CTS flow control flag and modem status interrupts */
1050         if (cflag & CRTSCTS) {
1051                 info->flags |= ISDN_ASYNC_CTS_FLOW;
1052         } else
1053                 info->flags &= ~ISDN_ASYNC_CTS_FLOW;
1054         if (cflag & CLOCAL)
1055                 info->flags &= ~ISDN_ASYNC_CHECK_CD;
1056         else {
1057                 info->flags |= ISDN_ASYNC_CHECK_CD;
1058         }
1059 }
1060
1061 static int
1062 isdn_tty_startup(modem_info * info)
1063 {
1064         if (info->flags & ISDN_ASYNC_INITIALIZED)
1065                 return 0;
1066         isdn_lock_drivers();
1067 #ifdef ISDN_DEBUG_MODEM_OPEN
1068         printk(KERN_DEBUG "starting up ttyi%d ...\n", info->line);
1069 #endif
1070         /*
1071          * Now, initialize the UART
1072          */
1073         info->mcr = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2;
1074         if (info->tty)
1075                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
1076         /*
1077          * and set the speed of the serial port
1078          */
1079         isdn_tty_change_speed(info);
1080
1081         info->flags |= ISDN_ASYNC_INITIALIZED;
1082         info->msr |= (UART_MSR_DSR | UART_MSR_CTS);
1083         info->send_outstanding = 0;
1084         return 0;
1085 }
1086
1087 /*
1088  * This routine will shutdown a serial port; interrupts are disabled, and
1089  * DTR is dropped if the hangup on close termio flag is on.
1090  */
1091 static void
1092 isdn_tty_shutdown(modem_info * info)
1093 {
1094         if (!(info->flags & ISDN_ASYNC_INITIALIZED))
1095                 return;
1096 #ifdef ISDN_DEBUG_MODEM_OPEN
1097         printk(KERN_DEBUG "Shutting down isdnmodem port %d ....\n", info->line);
1098 #endif
1099         isdn_unlock_drivers();
1100         info->msr &= ~UART_MSR_RI;
1101         if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
1102                 info->mcr &= ~(UART_MCR_DTR | UART_MCR_RTS);
1103                 if (info->emu.mdmreg[REG_DTRHUP] & BIT_DTRHUP) {
1104                         isdn_tty_modem_reset_regs(info, 0);
1105 #ifdef ISDN_DEBUG_MODEM_HUP
1106                         printk(KERN_DEBUG "Mhup in isdn_tty_shutdown\n");
1107 #endif
1108                         isdn_tty_modem_hup(info, 1);
1109                 }
1110         }
1111         if (info->tty)
1112                 set_bit(TTY_IO_ERROR, &info->tty->flags);
1113
1114         info->flags &= ~ISDN_ASYNC_INITIALIZED;
1115 }
1116
1117 /* isdn_tty_write() is the main send-routine. It is called from the upper
1118  * levels within the kernel to perform sending data. Depending on the
1119  * online-flag it either directs output to the at-command-interpreter or
1120  * to the lower level. Additional tasks done here:
1121  *  - If online, check for escape-sequence (+++)
1122  *  - If sending audio-data, call isdn_tty_DLEdown() to parse DLE-codes.
1123  *  - If receiving audio-data, call isdn_tty_end_vrx() to abort if needed.
1124  *  - If dialing, abort dial.
1125  */
1126 static int
1127 isdn_tty_write(struct tty_struct *tty, const u_char * buf, int count)
1128 {
1129         int c;
1130         int total = 0;
1131         modem_info *info = (modem_info *) tty->driver_data;
1132         atemu *m = &info->emu;
1133
1134         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_write"))
1135                 return 0;
1136         /* See isdn_tty_senddown() */
1137         atomic_inc(&info->xmit_lock);
1138         while (1) {
1139                 c = count;
1140                 if (c > info->xmit_size - info->xmit_count)
1141                         c = info->xmit_size - info->xmit_count;
1142                 if (info->isdn_driver >= 0 && c > dev->drv[info->isdn_driver]->maxbufsize)
1143                         c = dev->drv[info->isdn_driver]->maxbufsize;
1144                 if (c <= 0)
1145                         break;
1146                 if ((info->online > 1)
1147 #ifdef CONFIG_ISDN_AUDIO
1148                     || (info->vonline & 3)
1149 #endif
1150                         ) {
1151 #ifdef CONFIG_ISDN_AUDIO
1152                         if (!info->vonline)
1153 #endif
1154                                 isdn_tty_check_esc(buf, m->mdmreg[REG_ESC], c,
1155                                                    &(m->pluscount),
1156                                                    &(m->lastplus));
1157                         memcpy(&(info->xmit_buf[info->xmit_count]), buf, c);
1158 #ifdef CONFIG_ISDN_AUDIO
1159                         if (info->vonline) {
1160                                 int cc = isdn_tty_handleDLEdown(info, m, c);
1161                                 if (info->vonline & 2) {
1162                                         if (!cc) {
1163                                                 /* If DLE decoding results in zero-transmit, but
1164                                                  * c originally was non-zero, do a wakeup.
1165                                                  */
1166                                                 tty_wakeup(tty);
1167                                                 info->msr |= UART_MSR_CTS;
1168                                                 info->lsr |= UART_LSR_TEMT;
1169                                         }
1170                                         info->xmit_count += cc;
1171                                 }
1172                                 if ((info->vonline & 3) == 1) {
1173                                         /* Do NOT handle Ctrl-Q or Ctrl-S
1174                                          * when in full-duplex audio mode.
1175                                          */
1176                                         if (isdn_tty_end_vrx(buf, c)) {
1177                                                 info->vonline &= ~1;
1178 #ifdef ISDN_DEBUG_MODEM_VOICE
1179                                                 printk(KERN_DEBUG
1180                                                        "got !^Q/^S, send DLE-ETX,VCON on ttyI%d\n",
1181                                                        info->line);
1182 #endif
1183                                                 isdn_tty_at_cout("\020\003\r\nVCON\r\n", info);
1184                                         }
1185                                 }
1186                         } else
1187                         if (TTY_IS_FCLASS1(info)) {
1188                                 int cc = isdn_tty_handleDLEdown(info, m, c);
1189                                 
1190                                 if (info->vonline & 4) { /* ETX seen */
1191                                         isdn_ctrl c;
1192
1193                                         c.command = ISDN_CMD_FAXCMD;
1194                                         c.driver = info->isdn_driver;
1195                                         c.arg = info->isdn_channel;
1196                                         c.parm.aux.cmd = ISDN_FAX_CLASS1_CTRL;
1197                                         c.parm.aux.subcmd = ETX;
1198                                         isdn_command(&c);
1199                                 }
1200                                 info->vonline = 0;
1201 #ifdef ISDN_DEBUG_MODEM_VOICE
1202                                 printk(KERN_DEBUG "fax dle cc/c %d/%d\n", cc, c);
1203 #endif
1204                                 info->xmit_count += cc;
1205                         } else
1206 #endif
1207                                 info->xmit_count += c;
1208                 } else {
1209                         info->msr |= UART_MSR_CTS;
1210                         info->lsr |= UART_LSR_TEMT;
1211                         if (info->dialing) {
1212                                 info->dialing = 0;
1213 #ifdef ISDN_DEBUG_MODEM_HUP
1214                                 printk(KERN_DEBUG "Mhup in isdn_tty_write\n");
1215 #endif
1216                                 isdn_tty_modem_result(RESULT_NO_CARRIER, info);
1217                                 isdn_tty_modem_hup(info, 1);
1218                         } else
1219                                 c = isdn_tty_edit_at(buf, c, info);
1220                 }
1221                 buf += c;
1222                 count -= c;
1223                 total += c;
1224         }
1225         atomic_dec(&info->xmit_lock);
1226         if ((info->xmit_count) || !skb_queue_empty(&info->xmit_queue)) {
1227                 if (m->mdmreg[REG_DXMT] & BIT_DXMT) {
1228                         isdn_tty_senddown(info);
1229                         isdn_tty_tint(info);
1230                 }
1231                 isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT, 1);
1232         }
1233         return total;
1234 }
1235
1236 static int
1237 isdn_tty_write_room(struct tty_struct *tty)
1238 {
1239         modem_info *info = (modem_info *) tty->driver_data;
1240         int ret;
1241
1242         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_write_room"))
1243                 return 0;
1244         if (!info->online)
1245                 return info->xmit_size;
1246         ret = info->xmit_size - info->xmit_count;
1247         return (ret < 0) ? 0 : ret;
1248 }
1249
1250 static int
1251 isdn_tty_chars_in_buffer(struct tty_struct *tty)
1252 {
1253         modem_info *info = (modem_info *) tty->driver_data;
1254
1255         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_chars_in_buffer"))
1256                 return 0;
1257         if (!info->online)
1258                 return 0;
1259         return (info->xmit_count);
1260 }
1261
1262 static void
1263 isdn_tty_flush_buffer(struct tty_struct *tty)
1264 {
1265         modem_info *info;
1266
1267         if (!tty) {
1268                 return;
1269         }
1270         info = (modem_info *) tty->driver_data;
1271         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_flush_buffer")) {
1272                 return;
1273         }
1274         isdn_tty_cleanup_xmit(info);
1275         info->xmit_count = 0;
1276         wake_up_interruptible(&tty->write_wait);
1277         tty_wakeup(tty);
1278 }
1279
1280 static void
1281 isdn_tty_flush_chars(struct tty_struct *tty)
1282 {
1283         modem_info *info = (modem_info *) tty->driver_data;
1284
1285         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_flush_chars"))
1286                 return;
1287         if ((info->xmit_count) || !skb_queue_empty(&info->xmit_queue))
1288                 isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT, 1);
1289 }
1290
1291 /*
1292  * ------------------------------------------------------------
1293  * isdn_tty_throttle()
1294  *
1295  * This routine is called by the upper-layer tty layer to signal that
1296  * incoming characters should be throttled.
1297  * ------------------------------------------------------------
1298  */
1299 static void
1300 isdn_tty_throttle(struct tty_struct *tty)
1301 {
1302         modem_info *info = (modem_info *) tty->driver_data;
1303
1304         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_throttle"))
1305                 return;
1306         if (I_IXOFF(tty))
1307                 info->x_char = STOP_CHAR(tty);
1308         info->mcr &= ~UART_MCR_RTS;
1309 }
1310
1311 static void
1312 isdn_tty_unthrottle(struct tty_struct *tty)
1313 {
1314         modem_info *info = (modem_info *) tty->driver_data;
1315
1316         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_unthrottle"))
1317                 return;
1318         if (I_IXOFF(tty)) {
1319                 if (info->x_char)
1320                         info->x_char = 0;
1321                 else
1322                         info->x_char = START_CHAR(tty);
1323         }
1324         info->mcr |= UART_MCR_RTS;
1325 }
1326
1327 /*
1328  * ------------------------------------------------------------
1329  * isdn_tty_ioctl() and friends
1330  * ------------------------------------------------------------
1331  */
1332
1333 /*
1334  * isdn_tty_get_lsr_info - get line status register info
1335  *
1336  * Purpose: Let user call ioctl() to get info when the UART physically
1337  *          is emptied.  On bus types like RS485, the transmitter must
1338  *          release the bus after transmitting. This must be done when
1339  *          the transmit shift register is empty, not be done when the
1340  *          transmit holding register is empty.  This functionality
1341  *          allows RS485 driver to be written in user space.
1342  */
1343 static int
1344 isdn_tty_get_lsr_info(modem_info * info, uint __user * value)
1345 {
1346         u_char status;
1347         uint result;
1348
1349         status = info->lsr;
1350         result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
1351         return put_user(result, value);
1352 }
1353
1354
1355 static int
1356 isdn_tty_tiocmget(struct tty_struct *tty, struct file *file)
1357 {
1358         modem_info *info = (modem_info *) tty->driver_data;
1359         u_char control, status;
1360
1361         if (isdn_tty_paranoia_check(info, tty->name, __FUNCTION__))
1362                 return -ENODEV;
1363         if (tty->flags & (1 << TTY_IO_ERROR))
1364                 return -EIO;
1365
1366 #ifdef ISDN_DEBUG_MODEM_IOCTL
1367         printk(KERN_DEBUG "ttyI%d ioctl TIOCMGET\n", info->line);
1368 #endif
1369
1370         control = info->mcr;
1371         status = info->msr;
1372         return ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
1373             | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
1374             | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0)
1375             | ((status & UART_MSR_RI) ? TIOCM_RNG : 0)
1376             | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0)
1377             | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
1378 }
1379
1380 static int
1381 isdn_tty_tiocmset(struct tty_struct *tty, struct file *file,
1382                 unsigned int set, unsigned int clear)
1383 {
1384         modem_info *info = (modem_info *) tty->driver_data;
1385
1386         if (isdn_tty_paranoia_check(info, tty->name, __FUNCTION__))
1387                 return -ENODEV;
1388         if (tty->flags & (1 << TTY_IO_ERROR))
1389                 return -EIO;
1390
1391 #ifdef ISDN_DEBUG_MODEM_IOCTL
1392         printk(KERN_DEBUG "ttyI%d ioctl TIOCMxxx: %x %x\n", info->line, set, clear);
1393 #endif
1394
1395         if (set & TIOCM_RTS)
1396                 info->mcr |= UART_MCR_RTS;
1397         if (set & TIOCM_DTR) {
1398                 info->mcr |= UART_MCR_DTR;
1399                 isdn_tty_modem_ncarrier(info);
1400         }
1401
1402         if (clear & TIOCM_RTS)
1403                 info->mcr &= ~UART_MCR_RTS;
1404         if (clear & TIOCM_DTR) {
1405                 info->mcr &= ~UART_MCR_DTR;
1406                 if (info->emu.mdmreg[REG_DTRHUP] & BIT_DTRHUP) {
1407                         isdn_tty_modem_reset_regs(info, 0);
1408 #ifdef ISDN_DEBUG_MODEM_HUP
1409                         printk(KERN_DEBUG "Mhup in TIOCMSET\n");
1410 #endif
1411                         if (info->online)
1412                                 info->ncarrier = 1;
1413                         isdn_tty_modem_hup(info, 1);
1414                 }
1415         }
1416         return 0;
1417 }
1418
1419 static int
1420 isdn_tty_ioctl(struct tty_struct *tty, struct file *file,
1421                uint cmd, ulong arg)
1422 {
1423         modem_info *info = (modem_info *) tty->driver_data;
1424         int retval;
1425
1426         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_ioctl"))
1427                 return -ENODEV;
1428         if (tty->flags & (1 << TTY_IO_ERROR))
1429                 return -EIO;
1430         switch (cmd) {
1431                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
1432 #ifdef ISDN_DEBUG_MODEM_IOCTL
1433                         printk(KERN_DEBUG "ttyI%d ioctl TCSBRK\n", info->line);
1434 #endif
1435                         retval = tty_check_change(tty);
1436                         if (retval)
1437                                 return retval;
1438                         tty_wait_until_sent(tty, 0);
1439                         return 0;
1440                 case TCSBRKP:  /* support for POSIX tcsendbreak() */
1441 #ifdef ISDN_DEBUG_MODEM_IOCTL
1442                         printk(KERN_DEBUG "ttyI%d ioctl TCSBRKP\n", info->line);
1443 #endif
1444                         retval = tty_check_change(tty);
1445                         if (retval)
1446                                 return retval;
1447                         tty_wait_until_sent(tty, 0);
1448                         return 0;
1449                 case TIOCGSOFTCAR:
1450 #ifdef ISDN_DEBUG_MODEM_IOCTL
1451                         printk(KERN_DEBUG "ttyI%d ioctl TIOCGSOFTCAR\n", info->line);
1452 #endif
1453                         return put_user(C_CLOCAL(tty) ? 1 : 0, (ulong __user *) arg);
1454                 case TIOCSSOFTCAR:
1455 #ifdef ISDN_DEBUG_MODEM_IOCTL
1456                         printk(KERN_DEBUG "ttyI%d ioctl TIOCSSOFTCAR\n", info->line);
1457 #endif
1458                         if (get_user(arg, (ulong __user *) arg))
1459                                 return -EFAULT;
1460                         tty->termios->c_cflag =
1461                             ((tty->termios->c_cflag & ~CLOCAL) |
1462                              (arg ? CLOCAL : 0));
1463                         return 0;
1464                 case TIOCSERGETLSR:     /* Get line status register */
1465 #ifdef ISDN_DEBUG_MODEM_IOCTL
1466                         printk(KERN_DEBUG "ttyI%d ioctl TIOCSERGETLSR\n", info->line);
1467 #endif
1468                         return isdn_tty_get_lsr_info(info, (uint __user *) arg);
1469                 default:
1470 #ifdef ISDN_DEBUG_MODEM_IOCTL
1471                         printk(KERN_DEBUG "UNKNOWN ioctl 0x%08x on ttyi%d\n", cmd, info->line);
1472 #endif
1473                         return -ENOIOCTLCMD;
1474         }
1475         return 0;
1476 }
1477
1478 static void
1479 isdn_tty_set_termios(struct tty_struct *tty, struct termios *old_termios)
1480 {
1481         modem_info *info = (modem_info *) tty->driver_data;
1482
1483         if (!old_termios)
1484                 isdn_tty_change_speed(info);
1485         else {
1486                 if (tty->termios->c_cflag == old_termios->c_cflag)
1487                         return;
1488                 isdn_tty_change_speed(info);
1489                 if ((old_termios->c_cflag & CRTSCTS) &&
1490                     !(tty->termios->c_cflag & CRTSCTS)) {
1491                         tty->hw_stopped = 0;
1492                 }
1493         }
1494 }
1495
1496 /*
1497  * ------------------------------------------------------------
1498  * isdn_tty_open() and friends
1499  * ------------------------------------------------------------
1500  */
1501 static int
1502 isdn_tty_block_til_ready(struct tty_struct *tty, struct file *filp, modem_info * info)
1503 {
1504         DECLARE_WAITQUEUE(wait, NULL);
1505         int do_clocal = 0;
1506         int retval;
1507
1508         /*
1509          * If the device is in the middle of being closed, then block
1510          * until it's done, and then try again.
1511          */
1512         if (tty_hung_up_p(filp) ||
1513             (info->flags & ISDN_ASYNC_CLOSING)) {
1514                 if (info->flags & ISDN_ASYNC_CLOSING)
1515                         interruptible_sleep_on(&info->close_wait);
1516 #ifdef MODEM_DO_RESTART
1517                 if (info->flags & ISDN_ASYNC_HUP_NOTIFY)
1518                         return -EAGAIN;
1519                 else
1520                         return -ERESTARTSYS;
1521 #else
1522                 return -EAGAIN;
1523 #endif
1524         }
1525         /*
1526          * If non-blocking mode is set, then make the check up front
1527          * and then exit.
1528          */
1529         if ((filp->f_flags & O_NONBLOCK) ||
1530             (tty->flags & (1 << TTY_IO_ERROR))) {
1531                 if (info->flags & ISDN_ASYNC_CALLOUT_ACTIVE)
1532                         return -EBUSY;
1533                 info->flags |= ISDN_ASYNC_NORMAL_ACTIVE;
1534                 return 0;
1535         }
1536         if (info->flags & ISDN_ASYNC_CALLOUT_ACTIVE) {
1537                 if (info->normal_termios.c_cflag & CLOCAL)
1538                         do_clocal = 1;
1539         } else {
1540                 if (tty->termios->c_cflag & CLOCAL)
1541                         do_clocal = 1;
1542         }
1543         /*
1544          * Block waiting for the carrier detect and the line to become
1545          * free (i.e., not in use by the callout).  While we are in
1546          * this loop, info->count is dropped by one, so that
1547          * isdn_tty_close() knows when to free things.  We restore it upon
1548          * exit, either normal or abnormal.
1549          */
1550         retval = 0;
1551         add_wait_queue(&info->open_wait, &wait);
1552 #ifdef ISDN_DEBUG_MODEM_OPEN
1553         printk(KERN_DEBUG "isdn_tty_block_til_ready before block: ttyi%d, count = %d\n",
1554                info->line, info->count);
1555 #endif
1556         if (!(tty_hung_up_p(filp)))
1557                 info->count--;
1558         info->blocked_open++;
1559         while (1) {
1560                 set_current_state(TASK_INTERRUPTIBLE);
1561                 if (tty_hung_up_p(filp) ||
1562                     !(info->flags & ISDN_ASYNC_INITIALIZED)) {
1563 #ifdef MODEM_DO_RESTART
1564                         if (info->flags & ISDN_ASYNC_HUP_NOTIFY)
1565                                 retval = -EAGAIN;
1566                         else
1567                                 retval = -ERESTARTSYS;
1568 #else
1569                         retval = -EAGAIN;
1570 #endif
1571                         break;
1572                 }
1573                 if (!(info->flags & ISDN_ASYNC_CALLOUT_ACTIVE) &&
1574                     !(info->flags & ISDN_ASYNC_CLOSING) &&
1575                     (do_clocal || (info->msr & UART_MSR_DCD))) {
1576                         break;
1577                 }
1578                 if (signal_pending(current)) {
1579                         retval = -ERESTARTSYS;
1580                         break;
1581                 }
1582 #ifdef ISDN_DEBUG_MODEM_OPEN
1583                 printk(KERN_DEBUG "isdn_tty_block_til_ready blocking: ttyi%d, count = %d\n",
1584                        info->line, info->count);
1585 #endif
1586                 schedule();
1587         }
1588         current->state = TASK_RUNNING;
1589         remove_wait_queue(&info->open_wait, &wait);
1590         if (!tty_hung_up_p(filp))
1591                 info->count++;
1592         info->blocked_open--;
1593 #ifdef ISDN_DEBUG_MODEM_OPEN
1594         printk(KERN_DEBUG "isdn_tty_block_til_ready after blocking: ttyi%d, count = %d\n",
1595                info->line, info->count);
1596 #endif
1597         if (retval)
1598                 return retval;
1599         info->flags |= ISDN_ASYNC_NORMAL_ACTIVE;
1600         return 0;
1601 }
1602
1603 /*
1604  * This routine is called whenever a serial port is opened.  It
1605  * enables interrupts for a serial port, linking in its async structure into
1606  * the IRQ chain.   It also performs the serial-specific
1607  * initialization for the tty structure.
1608  */
1609 static int
1610 isdn_tty_open(struct tty_struct *tty, struct file *filp)
1611 {
1612         modem_info *info;
1613         int retval, line;
1614
1615         line = tty->index;
1616         if (line < 0 || line > ISDN_MAX_CHANNELS)
1617                 return -ENODEV;
1618         info = &dev->mdm.info[line];
1619         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_open"))
1620                 return -ENODEV;
1621         if (!try_module_get(info->owner)) {
1622                 printk(KERN_WARNING "%s: cannot reserve module\n", __FUNCTION__);
1623                 return -ENODEV;
1624         }
1625 #ifdef ISDN_DEBUG_MODEM_OPEN
1626         printk(KERN_DEBUG "isdn_tty_open %s, count = %d\n", tty->name, 
1627                info->count);
1628 #endif
1629         info->count++;
1630         tty->driver_data = info;
1631         info->tty = tty;
1632         /*
1633          * Start up serial port
1634          */
1635         retval = isdn_tty_startup(info);
1636         if (retval) {
1637 #ifdef ISDN_DEBUG_MODEM_OPEN
1638                 printk(KERN_DEBUG "isdn_tty_open return after startup\n");
1639 #endif
1640                 module_put(info->owner);
1641                 return retval;
1642         }
1643         retval = isdn_tty_block_til_ready(tty, filp, info);
1644         if (retval) {
1645 #ifdef ISDN_DEBUG_MODEM_OPEN
1646                 printk(KERN_DEBUG "isdn_tty_open return after isdn_tty_block_til_ready \n");
1647 #endif
1648                 module_put(info->owner);
1649                 return retval;
1650         }
1651 #ifdef ISDN_DEBUG_MODEM_OPEN
1652         printk(KERN_DEBUG "isdn_tty_open ttyi%d successful...\n", info->line);
1653 #endif
1654         dev->modempoll++;
1655 #ifdef ISDN_DEBUG_MODEM_OPEN
1656         printk(KERN_DEBUG "isdn_tty_open normal exit\n");
1657 #endif
1658         return 0;
1659 }
1660
1661 static void
1662 isdn_tty_close(struct tty_struct *tty, struct file *filp)
1663 {
1664         modem_info *info = (modem_info *) tty->driver_data;
1665         ulong timeout;
1666
1667         if (!info || isdn_tty_paranoia_check(info, tty->name, "isdn_tty_close"))
1668                 return;
1669         if (tty_hung_up_p(filp)) {
1670 #ifdef ISDN_DEBUG_MODEM_OPEN
1671                 printk(KERN_DEBUG "isdn_tty_close return after tty_hung_up_p\n");
1672 #endif
1673                 return;
1674         }
1675         if ((tty->count == 1) && (info->count != 1)) {
1676                 /*
1677                  * Uh, oh.  tty->count is 1, which means that the tty
1678                  * structure will be freed.  Info->count should always
1679                  * be one in these conditions.  If it's greater than
1680                  * one, we've got real problems, since it means the
1681                  * serial port won't be shutdown.
1682                  */
1683                 printk(KERN_ERR "isdn_tty_close: bad port count; tty->count is 1, "
1684                        "info->count is %d\n", info->count);
1685                 info->count = 1;
1686         }
1687         if (--info->count < 0) {
1688                 printk(KERN_ERR "isdn_tty_close: bad port count for ttyi%d: %d\n",
1689                        info->line, info->count);
1690                 info->count = 0;
1691         }
1692         if (info->count) {
1693 #ifdef ISDN_DEBUG_MODEM_OPEN
1694                 printk(KERN_DEBUG "isdn_tty_close after info->count != 0\n");
1695 #endif
1696                 return;
1697         }
1698         info->flags |= ISDN_ASYNC_CLOSING;
1699         /*
1700          * Save the termios structure, since this port may have
1701          * separate termios for callout and dialin.
1702          */
1703         if (info->flags & ISDN_ASYNC_NORMAL_ACTIVE)
1704                 info->normal_termios = *tty->termios;
1705         if (info->flags & ISDN_ASYNC_CALLOUT_ACTIVE)
1706                 info->callout_termios = *tty->termios;
1707
1708         tty->closing = 1;
1709         /*
1710          * At this point we stop accepting input.  To do this, we
1711          * disable the receive line status interrupts, and tell the
1712          * interrupt driver to stop checking the data ready bit in the
1713          * line status register.
1714          */
1715         if (info->flags & ISDN_ASYNC_INITIALIZED) {
1716                 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
1717                 /*
1718                  * Before we drop DTR, make sure the UART transmitter
1719                  * has completely drained; this is especially
1720                  * important if there is a transmit FIFO!
1721                  */
1722                 timeout = jiffies + HZ;
1723                 while (!(info->lsr & UART_LSR_TEMT)) {
1724                         set_current_state(TASK_INTERRUPTIBLE);
1725                         schedule_timeout(20);
1726                         if (time_after(jiffies,timeout))
1727                                 break;
1728                 }
1729         }
1730         dev->modempoll--;
1731         isdn_tty_shutdown(info);
1732         
1733         if (tty->driver->flush_buffer)
1734                 tty->driver->flush_buffer(tty);
1735         tty_ldisc_flush(tty);
1736         info->tty = NULL;
1737         info->ncarrier = 0;
1738         tty->closing = 0;
1739         module_put(info->owner);
1740         if (info->blocked_open) {
1741                 msleep_interruptible(500);
1742                 wake_up_interruptible(&info->open_wait);
1743         }
1744         info->flags &= ~(ISDN_ASYNC_NORMAL_ACTIVE | ISDN_ASYNC_CLOSING);
1745         wake_up_interruptible(&info->close_wait);
1746 #ifdef ISDN_DEBUG_MODEM_OPEN
1747         printk(KERN_DEBUG "isdn_tty_close normal exit\n");
1748 #endif
1749 }
1750
1751 /*
1752  * isdn_tty_hangup() --- called by tty_hangup() when a hangup is signaled.
1753  */
1754 static void
1755 isdn_tty_hangup(struct tty_struct *tty)
1756 {
1757         modem_info *info = (modem_info *) tty->driver_data;
1758
1759         if (isdn_tty_paranoia_check(info, tty->name, "isdn_tty_hangup"))
1760                 return;
1761         isdn_tty_shutdown(info);
1762         info->count = 0;
1763         info->flags &= ~(ISDN_ASYNC_NORMAL_ACTIVE | ISDN_ASYNC_CALLOUT_ACTIVE);
1764         info->tty = NULL;
1765         wake_up_interruptible(&info->open_wait);
1766 }
1767
1768 /* This routine initializes all emulator-data.
1769  */
1770 static void
1771 isdn_tty_reset_profile(atemu * m)
1772 {
1773         m->profile[0] = 0;
1774         m->profile[1] = 0;
1775         m->profile[2] = 43;
1776         m->profile[3] = 13;
1777         m->profile[4] = 10;
1778         m->profile[5] = 8;
1779         m->profile[6] = 3;
1780         m->profile[7] = 60;
1781         m->profile[8] = 2;
1782         m->profile[9] = 6;
1783         m->profile[10] = 7;
1784         m->profile[11] = 70;
1785         m->profile[12] = 0x45;
1786         m->profile[13] = 4;
1787         m->profile[14] = ISDN_PROTO_L2_X75I;
1788         m->profile[15] = ISDN_PROTO_L3_TRANS;
1789         m->profile[16] = ISDN_SERIAL_XMIT_SIZE / 16;
1790         m->profile[17] = ISDN_MODEM_WINSIZE;
1791         m->profile[18] = 4;
1792         m->profile[19] = 0;
1793         m->profile[20] = 0;
1794         m->profile[23] = 0;
1795         m->pmsn[0] = '\0';
1796         m->plmsn[0] = '\0';
1797 }
1798
1799 #ifdef CONFIG_ISDN_AUDIO
1800 static void
1801 isdn_tty_modem_reset_vpar(atemu * m)
1802 {
1803         m->vpar[0] = 2;         /* Voice-device            (2 = phone line) */
1804         m->vpar[1] = 0;         /* Silence detection level (0 = none      ) */
1805         m->vpar[2] = 70;        /* Silence interval        (7 sec.        ) */
1806         m->vpar[3] = 2;         /* Compression type        (1 = ADPCM-2   ) */
1807         m->vpar[4] = 0;         /* DTMF detection level    (0 = softcode  ) */
1808         m->vpar[5] = 8;         /* DTMF interval           (8 * 5 ms.     ) */
1809 }
1810 #endif
1811
1812 #ifdef CONFIG_ISDN_TTY_FAX
1813 static void
1814 isdn_tty_modem_reset_faxpar(modem_info * info)
1815 {
1816         T30_s *f = info->fax;
1817
1818         f->code = 0;
1819         f->phase = ISDN_FAX_PHASE_IDLE;
1820         f->direction = 0;
1821         f->resolution = 1;      /* fine */
1822         f->rate = 5;            /* 14400 bit/s */
1823         f->width = 0;
1824         f->length = 0;
1825         f->compression = 0;
1826         f->ecm = 0;
1827         f->binary = 0;
1828         f->scantime = 0;
1829         memset(&f->id[0], 32, FAXIDLEN - 1);
1830         f->id[FAXIDLEN - 1] = 0;
1831         f->badlin = 0;
1832         f->badmul = 0;
1833         f->bor = 0;
1834         f->nbc = 0;
1835         f->cq = 0;
1836         f->cr = 0;
1837         f->ctcrty = 0;
1838         f->minsp = 0;
1839         f->phcto = 30;
1840         f->rel = 0;
1841         memset(&f->pollid[0], 32, FAXIDLEN - 1);
1842         f->pollid[FAXIDLEN - 1] = 0;
1843 }
1844 #endif
1845
1846 static void
1847 isdn_tty_modem_reset_regs(modem_info * info, int force)
1848 {
1849         atemu *m = &info->emu;
1850         if ((m->mdmreg[REG_DTRR] & BIT_DTRR) || force) {
1851                 memcpy(m->mdmreg, m->profile, ISDN_MODEM_NUMREG);
1852                 memcpy(m->msn, m->pmsn, ISDN_MSNLEN);
1853                 memcpy(m->lmsn, m->plmsn, ISDN_LMSNLEN);
1854                 info->xmit_size = m->mdmreg[REG_PSIZE] * 16;
1855         }
1856 #ifdef CONFIG_ISDN_AUDIO
1857         isdn_tty_modem_reset_vpar(m);
1858 #endif
1859 #ifdef CONFIG_ISDN_TTY_FAX
1860         isdn_tty_modem_reset_faxpar(info);
1861 #endif
1862         m->mdmcmdl = 0;
1863 }
1864
1865 static void
1866 modem_write_profile(atemu * m)
1867 {
1868         memcpy(m->profile, m->mdmreg, ISDN_MODEM_NUMREG);
1869         memcpy(m->pmsn, m->msn, ISDN_MSNLEN);
1870         memcpy(m->plmsn, m->lmsn, ISDN_LMSNLEN);
1871         if (dev->profd)
1872                 send_sig(SIGIO, dev->profd, 1);
1873 }
1874
1875 static struct tty_operations modem_ops = {
1876         .open = isdn_tty_open,
1877         .close = isdn_tty_close,
1878         .write = isdn_tty_write,
1879         .flush_chars = isdn_tty_flush_chars,
1880         .write_room = isdn_tty_write_room,
1881         .chars_in_buffer = isdn_tty_chars_in_buffer,
1882         .flush_buffer = isdn_tty_flush_buffer,
1883         .ioctl = isdn_tty_ioctl,
1884         .throttle = isdn_tty_throttle,
1885         .unthrottle = isdn_tty_unthrottle,
1886         .set_termios = isdn_tty_set_termios,
1887         .hangup = isdn_tty_hangup,
1888         .tiocmget = isdn_tty_tiocmget,
1889         .tiocmset = isdn_tty_tiocmset,
1890 };
1891
1892 int
1893 isdn_tty_modem_init(void)
1894 {
1895         isdn_modem_t    *m;
1896         int             i, retval;
1897         modem_info      *info;
1898
1899         m = &dev->mdm;
1900         m->tty_modem = alloc_tty_driver(ISDN_MAX_CHANNELS);
1901         if (!m->tty_modem)
1902                 return -ENOMEM;
1903         m->tty_modem->name = "ttyI";
1904         m->tty_modem->devfs_name = "isdn/ttyI";
1905         m->tty_modem->major = ISDN_TTY_MAJOR;
1906         m->tty_modem->minor_start = 0;
1907         m->tty_modem->type = TTY_DRIVER_TYPE_SERIAL;
1908         m->tty_modem->subtype = SERIAL_TYPE_NORMAL;
1909         m->tty_modem->init_termios = tty_std_termios;
1910         m->tty_modem->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1911         m->tty_modem->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
1912         m->tty_modem->driver_name = "isdn_tty";
1913         tty_set_operations(m->tty_modem, &modem_ops);
1914         retval = tty_register_driver(m->tty_modem);
1915         if (retval) {
1916                 printk(KERN_WARNING "isdn_tty: Couldn't register modem-device\n");
1917                 goto err;
1918         }
1919         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
1920                 info = &m->info[i];
1921 #ifdef CONFIG_ISDN_TTY_FAX
1922                 if (!(info->fax = kmalloc(sizeof(T30_s), GFP_KERNEL))) {
1923                         printk(KERN_ERR "Could not allocate fax t30-buffer\n");
1924                         retval = -ENOMEM;
1925                         goto err_unregister;
1926                 }
1927 #endif
1928 #ifdef MODULE
1929                 info->owner = THIS_MODULE;
1930 #endif
1931                 spin_lock_init(&info->readlock);
1932                 init_MUTEX(&info->write_sem);
1933                 sprintf(info->last_cause, "0000");
1934                 sprintf(info->last_num, "none");
1935                 info->last_dir = 0;
1936                 info->last_lhup = 1;
1937                 info->last_l2 = -1;
1938                 info->last_si = 0;
1939                 isdn_tty_reset_profile(&info->emu);
1940                 isdn_tty_modem_reset_regs(info, 1);
1941                 info->magic = ISDN_ASYNC_MAGIC;
1942                 info->line = i;
1943                 info->tty = NULL;
1944                 info->x_char = 0;
1945                 info->count = 0;
1946                 info->blocked_open = 0;
1947                 init_waitqueue_head(&info->open_wait);
1948                 init_waitqueue_head(&info->close_wait);
1949                 info->isdn_driver = -1;
1950                 info->isdn_channel = -1;
1951                 info->drv_index = -1;
1952                 info->xmit_size = ISDN_SERIAL_XMIT_SIZE;
1953                 init_timer(&info->nc_timer);
1954                 info->nc_timer.function = isdn_tty_modem_do_ncarrier;
1955                 info->nc_timer.data = (unsigned long) info;
1956                 skb_queue_head_init(&info->xmit_queue);
1957 #ifdef CONFIG_ISDN_AUDIO
1958                 skb_queue_head_init(&info->dtmf_queue);
1959 #endif
1960                 if (!(info->xmit_buf = kmalloc(ISDN_SERIAL_XMIT_MAX + 5, GFP_KERNEL))) {
1961                         printk(KERN_ERR "Could not allocate modem xmit-buffer\n");
1962                         retval = -ENOMEM;
1963                         goto err_unregister;
1964                 }
1965                 /* Make room for T.70 header */
1966                 info->xmit_buf += 4;
1967         }
1968         return 0;
1969 err_unregister:
1970         for (i--; i >= 0; i--) {
1971                 info = &m->info[i];
1972 #ifdef CONFIG_ISDN_TTY_FAX
1973                 kfree(info->fax);
1974 #endif
1975                 kfree(info->xmit_buf - 4);
1976         }
1977         tty_unregister_driver(m->tty_modem);
1978  err:
1979         put_tty_driver(m->tty_modem);
1980         m->tty_modem = NULL;
1981         return retval;
1982 }
1983
1984 void
1985 isdn_tty_exit(void)
1986 {
1987         modem_info *info;
1988         int i;
1989
1990         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
1991                 info = &dev->mdm.info[i];
1992                 isdn_tty_cleanup_xmit(info);
1993 #ifdef CONFIG_ISDN_TTY_FAX
1994                 kfree(info->fax);
1995 #endif
1996                 kfree(info->xmit_buf - 4);
1997         }
1998         tty_unregister_driver(dev->mdm.tty_modem);
1999         put_tty_driver(dev->mdm.tty_modem);
2000         dev->mdm.tty_modem = NULL;
2001 }
2002
2003
2004 /*
2005  * isdn_tty_match_icall(char *MSN, atemu *tty_emulator, int dev_idx)
2006  *      match the MSN against the MSNs (glob patterns) defined for tty_emulator,
2007  *      and return 0 for match, 1 for no match, 2 if MSN could match if longer.
2008  */
2009
2010 static int
2011 isdn_tty_match_icall(char *cid, atemu *emu, int di)
2012 {
2013 #ifdef ISDN_DEBUG_MODEM_ICALL
2014         printk(KERN_DEBUG "m_fi: msn=%s lmsn=%s mmsn=%s mreg[SI1]=%d mreg[SI2]=%d\n",
2015                emu->msn, emu->lmsn, isdn_map_eaz2msn(emu->msn, di),
2016                emu->mdmreg[REG_SI1], emu->mdmreg[REG_SI2]);
2017 #endif
2018         if (strlen(emu->lmsn)) {
2019                 char *p = emu->lmsn;
2020                 char *q;
2021                 int  tmp;
2022                 int  ret = 0;
2023
2024                 while (1) {
2025                         if ((q = strchr(p, ';')))
2026                                 *q = '\0';
2027                         if ((tmp = isdn_msncmp(cid, isdn_map_eaz2msn(p, di))) > ret)
2028                                 ret = tmp;
2029 #ifdef ISDN_DEBUG_MODEM_ICALL
2030                         printk(KERN_DEBUG "m_fi: lmsnX=%s mmsn=%s -> tmp=%d\n",
2031                                p, isdn_map_eaz2msn(emu->msn, di), tmp);
2032 #endif
2033                         if (q) {
2034                                 *q = ';';
2035                                 p = q;
2036                                 p++;
2037                         }
2038                         if (!tmp)
2039                                 return 0;
2040                         if (!q)
2041                                 break;
2042                 }
2043                 return ret;
2044         } else {
2045                 int tmp;
2046                 tmp = isdn_msncmp(cid, isdn_map_eaz2msn(emu->msn, di));
2047 #ifdef ISDN_DEBUG_MODEM_ICALL
2048                         printk(KERN_DEBUG "m_fi: mmsn=%s -> tmp=%d\n",
2049                                isdn_map_eaz2msn(emu->msn, di), tmp);
2050 #endif
2051                 return tmp;
2052         }
2053 }
2054
2055 /*
2056  * An incoming call-request has arrived.
2057  * Search the tty-devices for an appropriate device and bind
2058  * it to the ISDN-Channel.
2059  * Return:
2060  *
2061  *  0 = No matching device found.
2062  *  1 = A matching device found.
2063  *  3 = No match found, but eventually would match, if
2064  *      CID is longer.
2065  */
2066 int
2067 isdn_tty_find_icall(int di, int ch, setup_parm *setup)
2068 {
2069         char *eaz;
2070         int i;
2071         int wret;
2072         int idx;
2073         int si1;
2074         int si2;
2075         char *nr;
2076         ulong flags;
2077
2078         if (!setup->phone[0]) {
2079                 nr = "0";
2080                 printk(KERN_INFO "isdn_tty: Incoming call without OAD, assuming '0'\n");
2081         } else
2082                 nr = setup->phone;
2083         si1 = (int) setup->si1;
2084         si2 = (int) setup->si2;
2085         if (!setup->eazmsn[0]) {
2086                 printk(KERN_WARNING "isdn_tty: Incoming call without CPN, assuming '0'\n");
2087                 eaz = "0";
2088         } else
2089                 eaz = setup->eazmsn;
2090 #ifdef ISDN_DEBUG_MODEM_ICALL
2091         printk(KERN_DEBUG "m_fi: eaz=%s si1=%d si2=%d\n", eaz, si1, si2);
2092 #endif
2093         wret = 0;
2094         spin_lock_irqsave(&dev->lock, flags);
2095         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
2096                 modem_info *info = &dev->mdm.info[i];
2097
2098                 if (info->count == 0)
2099                     continue;
2100                 if ((info->emu.mdmreg[REG_SI1] & si2bit[si1]) &&  /* SI1 is matching */
2101                     (info->emu.mdmreg[REG_SI2] == si2)) {         /* SI2 is matching */
2102                         idx = isdn_dc2minor(di, ch);
2103 #ifdef ISDN_DEBUG_MODEM_ICALL
2104                         printk(KERN_DEBUG "m_fi: match1 wret=%d\n", wret);
2105                         printk(KERN_DEBUG "m_fi: idx=%d flags=%08lx drv=%d ch=%d usg=%d\n", idx,
2106                                info->flags, info->isdn_driver, info->isdn_channel,
2107                                dev->usage[idx]);
2108 #endif
2109                         if (
2110 #ifndef FIX_FILE_TRANSFER
2111                                 (info->flags & ISDN_ASYNC_NORMAL_ACTIVE) &&
2112 #endif
2113                                 (info->isdn_driver == -1) &&
2114                                 (info->isdn_channel == -1) &&
2115                                 (USG_NONE(dev->usage[idx]))) {
2116                                 int matchret;
2117
2118                                 if ((matchret = isdn_tty_match_icall(eaz, &info->emu, di)) > wret)
2119                                         wret = matchret;
2120                                 if (!matchret) {                  /* EAZ is matching */
2121                                         info->isdn_driver = di;
2122                                         info->isdn_channel = ch;
2123                                         info->drv_index = idx;
2124                                         dev->m_idx[idx] = info->line;
2125                                         dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE;
2126                                         dev->usage[idx] |= isdn_calc_usage(si1, info->emu.mdmreg[REG_L2PROT]); 
2127                                         strcpy(dev->num[idx], nr);
2128                                         strcpy(info->emu.cpn, eaz);
2129                                         info->emu.mdmreg[REG_SI1I] = si2bit[si1];
2130                                         info->emu.mdmreg[REG_PLAN] = setup->plan;
2131                                         info->emu.mdmreg[REG_SCREEN] = setup->screen;
2132                                         isdn_info_update();
2133                                         spin_unlock_irqrestore(&dev->lock, flags);
2134                                         printk(KERN_INFO "isdn_tty: call from %s, -> RING on ttyI%d\n", nr,
2135                                                info->line);
2136                                         info->msr |= UART_MSR_RI;
2137                                         isdn_tty_modem_result(RESULT_RING, info);
2138                                         isdn_timer_ctrl(ISDN_TIMER_MODEMRING, 1);
2139                                         return 1;
2140                                 }
2141                         }
2142                 }
2143         }
2144         spin_unlock_irqrestore(&dev->lock, flags);
2145         printk(KERN_INFO "isdn_tty: call from %s -> %s %s\n", nr, eaz,
2146                ((dev->drv[di]->flags & DRV_FLAG_REJBUS) && (wret != 2))? "rejected" : "ignored");
2147         return (wret == 2)?3:0;
2148 }
2149
2150 #define TTY_IS_ACTIVE(info) \
2151         (info->flags & (ISDN_ASYNC_NORMAL_ACTIVE | ISDN_ASYNC_CALLOUT_ACTIVE))
2152
2153 int
2154 isdn_tty_stat_callback(int i, isdn_ctrl *c)
2155 {
2156         int mi;
2157         modem_info *info;
2158         char *e;
2159
2160         if (i < 0)
2161                 return 0;
2162         if ((mi = dev->m_idx[i]) >= 0) {
2163                 info = &dev->mdm.info[mi];
2164                 switch (c->command) {
2165                         case ISDN_STAT_CINF:
2166                                 printk(KERN_DEBUG "CHARGEINFO on ttyI%d: %ld %s\n", info->line, c->arg, c->parm.num);
2167                                 info->emu.charge = (unsigned) simple_strtoul(c->parm.num, &e, 10);
2168                                 if (e == (char *)c->parm.num)
2169                                         info->emu.charge = 0;
2170                                 
2171                                 break;                  
2172                         case ISDN_STAT_BSENT:
2173 #ifdef ISDN_TTY_STAT_DEBUG
2174                                 printk(KERN_DEBUG "tty_STAT_BSENT ttyI%d\n", info->line);
2175 #endif
2176                                 if ((info->isdn_driver == c->driver) &&
2177                                     (info->isdn_channel == c->arg)) {
2178                                         info->msr |= UART_MSR_CTS;
2179                                         if (info->send_outstanding)
2180                                                 if (!(--info->send_outstanding))
2181                                                         info->lsr |= UART_LSR_TEMT;
2182                                         isdn_tty_tint(info);
2183                                         return 1;
2184                                 }
2185                                 break;
2186                         case ISDN_STAT_CAUSE:
2187 #ifdef ISDN_TTY_STAT_DEBUG
2188                                 printk(KERN_DEBUG "tty_STAT_CAUSE ttyI%d\n", info->line);
2189 #endif
2190                                 /* Signal cause to tty-device */
2191                                 strncpy(info->last_cause, c->parm.num, 5);
2192                                 return 1;
2193                         case ISDN_STAT_DISPLAY:
2194 #ifdef ISDN_TTY_STAT_DEBUG
2195                                 printk(KERN_DEBUG "tty_STAT_DISPLAY ttyI%d\n", info->line);
2196 #endif
2197                                 /* Signal display to tty-device */
2198                                 if ((info->emu.mdmreg[REG_DISPLAY] & BIT_DISPLAY) && 
2199                                         !(info->emu.mdmreg[REG_RESPNUM] & BIT_RESPNUM)) {
2200                                   isdn_tty_at_cout("\r\n", info);
2201                                   isdn_tty_at_cout("DISPLAY: ", info);
2202                                   isdn_tty_at_cout(c->parm.display, info);
2203                                   isdn_tty_at_cout("\r\n", info);
2204                                 }
2205                                 return 1;
2206                         case ISDN_STAT_DCONN:
2207 #ifdef ISDN_TTY_STAT_DEBUG
2208                                 printk(KERN_DEBUG "tty_STAT_DCONN ttyI%d\n", info->line);
2209 #endif
2210                                 if (TTY_IS_ACTIVE(info)) {
2211                                         if (info->dialing == 1) {
2212                                                 info->dialing = 2;
2213                                                 return 1;
2214                                         }
2215                                 }
2216                                 break;
2217                         case ISDN_STAT_DHUP:
2218 #ifdef ISDN_TTY_STAT_DEBUG
2219                                 printk(KERN_DEBUG "tty_STAT_DHUP ttyI%d\n", info->line);
2220 #endif
2221                                 if (TTY_IS_ACTIVE(info)) {
2222                                         if (info->dialing == 1) 
2223                                                 isdn_tty_modem_result(RESULT_BUSY, info);
2224                                         if (info->dialing > 1) 
2225                                                 isdn_tty_modem_result(RESULT_NO_CARRIER, info);
2226                                         info->dialing = 0;
2227 #ifdef ISDN_DEBUG_MODEM_HUP
2228                                         printk(KERN_DEBUG "Mhup in ISDN_STAT_DHUP\n");
2229 #endif
2230                                         isdn_tty_modem_hup(info, 0);
2231                                         return 1;
2232                                 }
2233                                 break;
2234                         case ISDN_STAT_BCONN:
2235 #ifdef ISDN_TTY_STAT_DEBUG
2236                                 printk(KERN_DEBUG "tty_STAT_BCONN ttyI%d\n", info->line);
2237 #endif
2238                                 /* Wake up any processes waiting
2239                                  * for incoming call of this device when
2240                                  * DCD follow the state of incoming carrier
2241                                  */
2242                                 if (info->blocked_open &&
2243                                    (info->emu.mdmreg[REG_DCD] & BIT_DCD)) {
2244                                         wake_up_interruptible(&info->open_wait);
2245                                 }
2246
2247                                 /* Schedule CONNECT-Message to any tty
2248                                  * waiting for it and
2249                                  * set DCD-bit of its modem-status.
2250                                  */
2251                                 if (TTY_IS_ACTIVE(info) ||
2252                                     (info->blocked_open && (info->emu.mdmreg[REG_DCD] & BIT_DCD))) {
2253                                         info->msr |= UART_MSR_DCD;
2254                                         info->emu.charge = 0;
2255                                         if (info->dialing & 0xf)
2256                                                 info->last_dir = 1;
2257                                         else
2258                                                 info->last_dir = 0;
2259                                         info->dialing = 0;
2260                                         info->rcvsched = 1;
2261                                         if (USG_MODEM(dev->usage[i])) {
2262                                                 if (info->emu.mdmreg[REG_L2PROT] == ISDN_PROTO_L2_MODEM) {
2263                                                         strcpy(info->emu.connmsg, c->parm.num);
2264                                                         isdn_tty_modem_result(RESULT_CONNECT, info);
2265                                                 } else
2266                                                         isdn_tty_modem_result(RESULT_CONNECT64000, info);
2267                                         }
2268                                         if (USG_VOICE(dev->usage[i]))
2269                                                 isdn_tty_modem_result(RESULT_VCON, info);
2270                                         return 1;
2271                                 }
2272                                 break;
2273                         case ISDN_STAT_BHUP:
2274 #ifdef ISDN_TTY_STAT_DEBUG
2275                                 printk(KERN_DEBUG "tty_STAT_BHUP ttyI%d\n", info->line);
2276 #endif
2277                                 if (TTY_IS_ACTIVE(info)) {
2278 #ifdef ISDN_DEBUG_MODEM_HUP
2279                                         printk(KERN_DEBUG "Mhup in ISDN_STAT_BHUP\n");
2280 #endif
2281                                         isdn_tty_modem_hup(info, 0);
2282                                         return 1;
2283                                 }
2284                                 break;
2285                         case ISDN_STAT_NODCH:
2286 #ifdef ISDN_TTY_STAT_DEBUG
2287                                 printk(KERN_DEBUG "tty_STAT_NODCH ttyI%d\n", info->line);
2288 #endif
2289                                 if (TTY_IS_ACTIVE(info)) {
2290                                         if (info->dialing) {
2291                                                 info->dialing = 0;
2292                                                 info->last_l2 = -1;
2293                                                 info->last_si = 0;
2294                                                 sprintf(info->last_cause, "0000");
2295                                                 isdn_tty_modem_result(RESULT_NO_DIALTONE, info);
2296                                         }
2297                                         isdn_tty_modem_hup(info, 0);
2298                                         return 1;
2299                                 }
2300                                 break;
2301                         case ISDN_STAT_UNLOAD:
2302 #ifdef ISDN_TTY_STAT_DEBUG
2303                                 printk(KERN_DEBUG "tty_STAT_UNLOAD ttyI%d\n", info->line);
2304 #endif
2305                                 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
2306                                         info = &dev->mdm.info[i];
2307                                         if (info->isdn_driver == c->driver) {
2308                                                 if (info->online)
2309                                                         isdn_tty_modem_hup(info, 1);
2310                                         }
2311                                 }
2312                                 return 1;
2313 #ifdef CONFIG_ISDN_TTY_FAX
2314                         case ISDN_STAT_FAXIND:
2315                                 if (TTY_IS_ACTIVE(info)) {
2316                                         isdn_tty_fax_command(info, c); 
2317                                 }
2318                                 break;
2319 #endif
2320 #ifdef CONFIG_ISDN_AUDIO
2321                         case ISDN_STAT_AUDIO:
2322                                 if (TTY_IS_ACTIVE(info)) {
2323                                         switch(c->parm.num[0]) {
2324                                                 case ISDN_AUDIO_DTMF:
2325                                                         if (info->vonline) {
2326                                                                 isdn_audio_put_dle_code(info,
2327                                                                         c->parm.num[1]);
2328                                                         }
2329                                                         break;
2330                                         }
2331                                 }
2332                                 break;
2333 #endif
2334                 }
2335         }
2336         return 0;
2337 }
2338
2339 /*********************************************************************
2340  Modem-Emulator-Routines
2341  *********************************************************************/
2342
2343 #define cmdchar(c) ((c>=' ')&&(c<=0x7f))
2344
2345 /*
2346  * Put a message from the AT-emulator into receive-buffer of tty,
2347  * convert CR, LF, and BS to values in modem-registers 3, 4 and 5.
2348  */
2349 void
2350 isdn_tty_at_cout(char *msg, modem_info * info)
2351 {
2352         struct tty_struct *tty;
2353         atemu *m = &info->emu;
2354         char *p;
2355         char c;
2356         u_long flags;
2357         struct sk_buff *skb = NULL;
2358         char *sp = NULL;
2359
2360         if (!msg) {
2361                 printk(KERN_WARNING "isdn_tty: Null-Message in isdn_tty_at_cout\n");
2362                 return;
2363         }
2364         spin_lock_irqsave(&info->readlock, flags);
2365         tty = info->tty;
2366         if ((info->flags & ISDN_ASYNC_CLOSING) || (!tty)) {
2367                 spin_unlock_irqrestore(&info->readlock, flags);
2368                 return;
2369         }
2370
2371         /* use queue instead of direct flip, if online and */
2372         /* data is in queue or flip buffer is full */
2373         if ((info->online) && (((tty->flip.count + strlen(msg)) >= TTY_FLIPBUF_SIZE) ||
2374             (!skb_queue_empty(&dev->drv[info->isdn_driver]->rpqueue[info->isdn_channel])))) {
2375                 skb = alloc_skb(strlen(msg), GFP_ATOMIC);
2376                 if (!skb) {
2377                         spin_unlock_irqrestore(&info->readlock, flags);
2378                         return;
2379                 }
2380                 sp = skb_put(skb, strlen(msg));
2381 #ifdef CONFIG_ISDN_AUDIO
2382                 ISDN_AUDIO_SKB_DLECOUNT(skb) = 0;
2383                 ISDN_AUDIO_SKB_LOCK(skb) = 0;
2384 #endif
2385         }
2386
2387         for (p = msg; *p; p++) {
2388                 switch (*p) {
2389                         case '\r':
2390                                 c = m->mdmreg[REG_CR];
2391                                 break;
2392                         case '\n':
2393                                 c = m->mdmreg[REG_LF];
2394                                 break;
2395                         case '\b':
2396                                 c = m->mdmreg[REG_BS];
2397                                 break;
2398                         default:
2399                                 c = *p;
2400                 }
2401                 if (skb) {
2402                         *sp++ = c;
2403                 } else {
2404                         if (tty->flip.count >= TTY_FLIPBUF_SIZE)
2405                                 break;
2406                         tty_insert_flip_char(tty, c, 0);
2407                 }
2408         }
2409         if (skb) {
2410                 __skb_queue_tail(&dev->drv[info->isdn_driver]->rpqueue[info->isdn_channel], skb);
2411                 dev->drv[info->isdn_driver]->rcvcount[info->isdn_channel] += skb->len;
2412                 spin_unlock_irqrestore(&info->readlock, flags);
2413                 /* Schedule dequeuing */
2414                 if ((dev->modempoll) && (info->rcvsched))
2415                         isdn_timer_ctrl(ISDN_TIMER_MODEMREAD, 1);
2416
2417         } else {
2418                 spin_unlock_irqrestore(&info->readlock, flags);
2419                 schedule_delayed_work(&tty->flip.work, 1);
2420         }
2421 }
2422
2423 /*
2424  * Perform ATH Hangup
2425  */
2426 static void
2427 isdn_tty_on_hook(modem_info * info)
2428 {
2429         if (info->isdn_channel >= 0) {
2430 #ifdef ISDN_DEBUG_MODEM_HUP
2431                 printk(KERN_DEBUG "Mhup in isdn_tty_on_hook\n");
2432 #endif
2433                 isdn_tty_modem_hup(info, 1);
2434         }
2435 }
2436
2437 static void
2438 isdn_tty_off_hook(void)
2439 {
2440         printk(KERN_DEBUG "isdn_tty_off_hook\n");
2441 }
2442
2443 #define PLUSWAIT1 (HZ/2)        /* 0.5 sec. */
2444 #define PLUSWAIT2 (HZ*3/2)      /* 1.5 sec */
2445
2446 /*
2447  * Check Buffer for Modem-escape-sequence, activate timer-callback to
2448  * isdn_tty_modem_escape() if sequence found.
2449  *
2450  * Parameters:
2451  *   p          pointer to databuffer
2452  *   plus       escape-character
2453  *   count      length of buffer
2454  *   pluscount  count of valid escape-characters so far
2455  *   lastplus   timestamp of last character
2456  */
2457 static void
2458 isdn_tty_check_esc(const u_char * p, u_char plus, int count, int *pluscount,
2459                    u_long *lastplus)
2460 {
2461         if (plus > 127)
2462                 return;
2463         if (count > 3) {
2464                 p += count - 3;
2465                 count = 3;
2466                 *pluscount = 0;
2467         }
2468         while (count > 0) {
2469                 if (*(p++) == plus) {
2470                         if ((*pluscount)++) {
2471                                 /* Time since last '+' > 0.5 sec. ? */
2472                                 if (time_after(jiffies, *lastplus + PLUSWAIT1))
2473                                         *pluscount = 1;
2474                         } else {
2475                                 /* Time since last non-'+' < 1.5 sec. ? */
2476                                 if (time_before(jiffies, *lastplus + PLUSWAIT2))
2477                                         *pluscount = 0;
2478                         }
2479                         if ((*pluscount == 3) && (count == 1))
2480                                 isdn_timer_ctrl(ISDN_TIMER_MODEMPLUS, 1);
2481                         if (*pluscount > 3)
2482                                 *pluscount = 1;
2483                 } else
2484                         *pluscount = 0;
2485                 *lastplus = jiffies;
2486                 count--;
2487         }
2488 }
2489
2490 /*
2491  * Return result of AT-emulator to tty-receive-buffer, depending on
2492  * modem-register 12, bit 0 and 1.
2493  * For CONNECT-messages also switch to online-mode.
2494  * For RING-message handle auto-ATA if register 0 != 0
2495  */
2496
2497 static void
2498 isdn_tty_modem_result(int code, modem_info * info)
2499 {
2500         atemu *m = &info->emu;
2501         static char *msg[] =
2502         {"OK", "CONNECT", "RING", "NO CARRIER", "ERROR",
2503          "CONNECT 64000", "NO DIALTONE", "BUSY", "NO ANSWER",
2504          "RINGING", "NO MSN/EAZ", "VCON", "RUNG"};
2505         char s[ISDN_MSNLEN+10];
2506
2507         switch (code) {
2508                 case RESULT_RING:
2509                         m->mdmreg[REG_RINGCNT]++;
2510                         if (m->mdmreg[REG_RINGCNT] == m->mdmreg[REG_RINGATA])
2511                                 /* Automatically accept incoming call */
2512                                 isdn_tty_cmd_ATA(info);
2513                         break;
2514                 case RESULT_NO_CARRIER:
2515 #ifdef ISDN_DEBUG_MODEM_HUP
2516                         printk(KERN_DEBUG "modem_result: NO CARRIER %d %d\n",
2517                                (info->flags & ISDN_ASYNC_CLOSING),
2518                                (!info->tty));
2519 #endif
2520                         m->mdmreg[REG_RINGCNT] = 0;
2521                         del_timer(&info->nc_timer);
2522                         info->ncarrier = 0;
2523                         if ((info->flags & ISDN_ASYNC_CLOSING) || (!info->tty)) {
2524                                 return;
2525                         }
2526 #ifdef CONFIG_ISDN_AUDIO
2527                         if (info->vonline & 1) {
2528 #ifdef ISDN_DEBUG_MODEM_VOICE
2529                                 printk(KERN_DEBUG "res3: send DLE-ETX on ttyI%d\n",
2530                                        info->line);
2531 #endif
2532                                 /* voice-recording, add DLE-ETX */
2533                                 isdn_tty_at_cout("\020\003", info);
2534                         }
2535                         if (info->vonline & 2) {
2536 #ifdef ISDN_DEBUG_MODEM_VOICE
2537                                 printk(KERN_DEBUG "res3: send DLE-DC4 on ttyI%d\n",
2538                                        info->line);
2539 #endif
2540                                 /* voice-playing, add DLE-DC4 */
2541                                 isdn_tty_at_cout("\020\024", info);
2542                         }
2543 #endif
2544                         break;
2545                 case RESULT_CONNECT:
2546                 case RESULT_CONNECT64000:
2547                         sprintf(info->last_cause, "0000");
2548                         if (!info->online)
2549                                 info->online = 2;
2550                         break;
2551                 case RESULT_VCON:
2552 #ifdef ISDN_DEBUG_MODEM_VOICE
2553                         printk(KERN_DEBUG "res3: send VCON on ttyI%d\n",
2554                                info->line);
2555 #endif
2556                         sprintf(info->last_cause, "0000");
2557                         if (!info->online)
2558                                 info->online = 1;
2559                         break;
2560         } /* switch(code) */
2561
2562         if (m->mdmreg[REG_RESP] & BIT_RESP) {
2563                 /* Show results */
2564                 if (m->mdmreg[REG_RESPNUM] & BIT_RESPNUM) {
2565                         /* Show numeric results only */
2566                         sprintf(s, "\r\n%d\r\n", code);
2567                         isdn_tty_at_cout(s, info);
2568                 } else {
2569                         if (code == RESULT_RING) {
2570                             /* return if "show RUNG" and ringcounter>1 */
2571                             if ((m->mdmreg[REG_RUNG] & BIT_RUNG) &&
2572                                     (m->mdmreg[REG_RINGCNT] > 1))
2573                                                 return;
2574                             /* print CID, _before_ _every_ ring */
2575                             if (!(m->mdmreg[REG_CIDONCE] & BIT_CIDONCE)) {
2576                                     isdn_tty_at_cout("\r\nCALLER NUMBER: ", info);
2577                                     isdn_tty_at_cout(dev->num[info->drv_index], info);
2578                                     if (m->mdmreg[REG_CDN] & BIT_CDN) {
2579                                             isdn_tty_at_cout("\r\nCALLED NUMBER: ", info);
2580                                             isdn_tty_at_cout(info->emu.cpn, info);
2581                                     }
2582                             }
2583                         }
2584                         isdn_tty_at_cout("\r\n", info);
2585                         isdn_tty_at_cout(msg[code], info);
2586                         switch (code) {
2587                                 case RESULT_CONNECT:
2588                                         switch (m->mdmreg[REG_L2PROT]) {
2589                                                 case ISDN_PROTO_L2_MODEM:
2590                                                         isdn_tty_at_cout(" ", info);
2591                                                         isdn_tty_at_cout(m->connmsg, info);
2592                                                         break;
2593                                         }
2594                                         break;
2595                                 case RESULT_RING:
2596                                         /* Append CPN, if enabled */
2597                                         if ((m->mdmreg[REG_CPN] & BIT_CPN)) {
2598                                                 sprintf(s, "/%s", m->cpn);
2599                                                 isdn_tty_at_cout(s, info);
2600                                         }
2601                                         /* Print CID only once, _after_ 1st RING */
2602                                         if ((m->mdmreg[REG_CIDONCE] & BIT_CIDONCE) &&
2603                                             (m->mdmreg[REG_RINGCNT] == 1)) {
2604                                                 isdn_tty_at_cout("\r\n", info);
2605                                                 isdn_tty_at_cout("CALLER NUMBER: ", info);
2606                                                 isdn_tty_at_cout(dev->num[info->drv_index], info);
2607                                                 if (m->mdmreg[REG_CDN] & BIT_CDN) {
2608                                                         isdn_tty_at_cout("\r\nCALLED NUMBER: ", info);
2609                                                         isdn_tty_at_cout(info->emu.cpn, info);
2610                                                 }
2611                                         }
2612                                         break;
2613                                 case RESULT_NO_CARRIER:
2614                                 case RESULT_NO_DIALTONE:
2615                                 case RESULT_BUSY:
2616                                 case RESULT_NO_ANSWER:
2617                                         m->mdmreg[REG_RINGCNT] = 0;
2618                                         /* Append Cause-Message if enabled */
2619                                         if (m->mdmreg[REG_RESPXT] & BIT_RESPXT) {
2620                                                 sprintf(s, "/%s", info->last_cause);
2621                                                 isdn_tty_at_cout(s, info);
2622                                         }
2623                                         break;
2624                                 case RESULT_CONNECT64000:
2625                                         /* Append Protocol to CONNECT message */
2626                                         switch (m->mdmreg[REG_L2PROT]) {
2627                                                 case ISDN_PROTO_L2_X75I:
2628                                                 case ISDN_PROTO_L2_X75UI:
2629                                                 case ISDN_PROTO_L2_X75BUI:
2630                                                         isdn_tty_at_cout("/X.75", info);
2631                                                         break;
2632                                                 case ISDN_PROTO_L2_HDLC:
2633                                                         isdn_tty_at_cout("/HDLC", info);
2634                                                         break;
2635                                                 case ISDN_PROTO_L2_V11096:
2636                                                         isdn_tty_at_cout("/V110/9600", info);
2637                                                         break;
2638                                                 case ISDN_PROTO_L2_V11019:
2639                                                         isdn_tty_at_cout("/V110/19200", info);
2640                                                         break;
2641                                                 case ISDN_PROTO_L2_V11038:
2642                                                         isdn_tty_at_cout("/V110/38400", info);
2643                                                         break;
2644                                         }
2645                                         if (m->mdmreg[REG_T70] & BIT_T70) {
2646                                                 isdn_tty_at_cout("/T.70", info);
2647                                                 if (m->mdmreg[REG_T70] & BIT_T70_EXT)
2648                                                         isdn_tty_at_cout("+", info);
2649                                         }
2650                                         break;
2651                         }
2652                         isdn_tty_at_cout("\r\n", info);
2653                 }
2654         }
2655         if (code == RESULT_NO_CARRIER) {
2656                 if ((info->flags & ISDN_ASYNC_CLOSING) || (!info->tty)) {
2657                         return;
2658                 }
2659                 tty_ldisc_flush(info->tty);
2660                 if ((info->flags & ISDN_ASYNC_CHECK_CD) &&
2661                     (!((info->flags & ISDN_ASYNC_CALLOUT_ACTIVE) &&
2662                        (info->flags & ISDN_ASYNC_CALLOUT_NOHUP)))) {
2663                         tty_hangup(info->tty);
2664                 }
2665         }
2666 }
2667
2668
2669 /*
2670  * Display a modem-register-value.
2671  */
2672 static void
2673 isdn_tty_show_profile(int ridx, modem_info * info)
2674 {
2675         char v[6];
2676
2677         sprintf(v, "\r\n%d", info->emu.mdmreg[ridx]);
2678         isdn_tty_at_cout(v, info);
2679 }
2680
2681 /*
2682  * Get MSN-string from char-pointer, set pointer to end of number
2683  */
2684 static void
2685 isdn_tty_get_msnstr(char *n, char **p)
2686 {
2687         int limit = ISDN_MSNLEN - 1;
2688
2689         while (((*p[0] >= '0' && *p[0] <= '9') ||
2690                 /* Why a comma ??? */
2691                 (*p[0] == ',') || (*p[0] == ':')) &&
2692                 (limit--))
2693                 *n++ = *p[0]++;
2694         *n = '\0';
2695 }
2696
2697 /*
2698  * Get phone-number from modem-commandbuffer
2699  */
2700 static void
2701 isdn_tty_getdial(char *p, char *q,int cnt)
2702 {
2703         int first = 1;
2704         int limit = ISDN_MSNLEN - 1;    /* MUST match the size of interface var to avoid
2705                                         buffer overflow */
2706
2707         while (strchr(" 0123456789,#.*WPTS-", *p) && *p && --cnt>0) {
2708                 if ((*p >= '0' && *p <= '9') || ((*p == 'S') && first) ||
2709                     (*p == '*') || (*p == '#')) {
2710                         *q++ = *p;
2711                         limit--;
2712                 }
2713                 if(!limit)
2714                         break;
2715                 p++;
2716                 first = 0;
2717         }
2718         *q = 0;
2719 }
2720
2721 #define PARSE_ERROR { isdn_tty_modem_result(RESULT_ERROR, info); return; }
2722 #define PARSE_ERROR1 { isdn_tty_modem_result(RESULT_ERROR, info); return 1; }
2723
2724 static void
2725 isdn_tty_report(modem_info * info)
2726 {
2727         atemu *m = &info->emu;
2728         char s[80];
2729
2730         isdn_tty_at_cout("\r\nStatistics of last connection:\r\n\r\n", info);
2731         sprintf(s, "    Remote Number:    %s\r\n", info->last_num);
2732         isdn_tty_at_cout(s, info);
2733         sprintf(s, "    Direction:        %s\r\n", info->last_dir ? "outgoing" : "incoming");
2734         isdn_tty_at_cout(s, info);
2735         isdn_tty_at_cout("    Layer-2 Protocol: ", info);
2736         switch (info->last_l2) {
2737                 case ISDN_PROTO_L2_X75I:
2738                         isdn_tty_at_cout("X.75i", info);
2739                         break;
2740                 case ISDN_PROTO_L2_X75UI:
2741                         isdn_tty_at_cout("X.75ui", info);
2742                         break;
2743                 case ISDN_PROTO_L2_X75BUI:
2744                         isdn_tty_at_cout("X.75bui", info);
2745                         break;
2746                 case ISDN_PROTO_L2_HDLC:
2747                         isdn_tty_at_cout("HDLC", info);
2748                         break;
2749                 case ISDN_PROTO_L2_V11096:
2750                         isdn_tty_at_cout("V.110 9600 Baud", info);
2751                         break;
2752                 case ISDN_PROTO_L2_V11019:
2753                         isdn_tty_at_cout("V.110 19200 Baud", info);
2754                         break;
2755                 case ISDN_PROTO_L2_V11038:
2756                         isdn_tty_at_cout("V.110 38400 Baud", info);
2757                         break;
2758                 case ISDN_PROTO_L2_TRANS:
2759                         isdn_tty_at_cout("transparent", info);
2760                         break;
2761                 case ISDN_PROTO_L2_MODEM:
2762                         isdn_tty_at_cout("modem", info);
2763                         break;
2764                 case ISDN_PROTO_L2_FAX:
2765                         isdn_tty_at_cout("fax", info);
2766                         break;
2767                 default:
2768                         isdn_tty_at_cout("unknown", info);
2769                         break;
2770         }
2771         if (m->mdmreg[REG_T70] & BIT_T70) {
2772                 isdn_tty_at_cout("/T.70", info);
2773                 if (m->mdmreg[REG_T70] & BIT_T70_EXT)
2774                         isdn_tty_at_cout("+", info);
2775         }
2776         isdn_tty_at_cout("\r\n", info);
2777         isdn_tty_at_cout("    Service:          ", info);
2778         switch (info->last_si) {
2779                 case 1:
2780                         isdn_tty_at_cout("audio\r\n", info);
2781                         break;
2782                 case 5:
2783                         isdn_tty_at_cout("btx\r\n", info);
2784                         break;
2785                 case 7:
2786                         isdn_tty_at_cout("data\r\n", info);
2787                         break;
2788                 default:
2789                         sprintf(s, "%d\r\n", info->last_si);
2790                         isdn_tty_at_cout(s, info);
2791                         break;
2792         }
2793         sprintf(s, "    Hangup location:  %s\r\n", info->last_lhup ? "local" : "remote");
2794         isdn_tty_at_cout(s, info);
2795         sprintf(s, "    Last cause:       %s\r\n", info->last_cause);
2796         isdn_tty_at_cout(s, info);
2797 }
2798
2799 /*
2800  * Parse AT&.. commands.
2801  */
2802 static int
2803 isdn_tty_cmd_ATand(char **p, modem_info * info)
2804 {
2805         atemu *m = &info->emu;
2806         int i;
2807         char rb[100];
2808
2809 #define MAXRB (sizeof(rb) - 1)
2810
2811         switch (*p[0]) {
2812                 case 'B':
2813                         /* &B - Set Buffersize */
2814                         p[0]++;
2815                         i = isdn_getnum(p);
2816                         if ((i < 0) || (i > ISDN_SERIAL_XMIT_MAX))
2817                                 PARSE_ERROR1;
2818 #ifdef CONFIG_ISDN_AUDIO
2819                         if ((m->mdmreg[REG_SI1] & 1) && (i > VBUF))
2820                                 PARSE_ERROR1;
2821 #endif
2822                         m->mdmreg[REG_PSIZE] = i / 16;
2823                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16;
2824                         switch (m->mdmreg[REG_L2PROT]) {
2825                                 case ISDN_PROTO_L2_V11096:
2826                                 case ISDN_PROTO_L2_V11019:
2827                                 case ISDN_PROTO_L2_V11038:
2828                                         info->xmit_size /= 10;          
2829                         }
2830                         break;
2831                 case 'C':
2832                         /* &C - DCD Status */
2833                         p[0]++;
2834                         switch (isdn_getnum(p)) {
2835                                 case 0:
2836                                         m->mdmreg[REG_DCD] &= ~BIT_DCD;
2837                                         break;
2838                                 case 1:
2839                                         m->mdmreg[REG_DCD] |= BIT_DCD;
2840                                         break;
2841                                 default:
2842                                         PARSE_ERROR1
2843                         }
2844                         break;
2845                 case 'D':
2846                         /* &D - Set DTR-Low-behavior */
2847                         p[0]++;
2848                         switch (isdn_getnum(p)) {
2849                                 case 0:
2850                                         m->mdmreg[REG_DTRHUP] &= ~BIT_DTRHUP;
2851                                         m->mdmreg[REG_DTRR] &= ~BIT_DTRR;
2852                                         break;
2853                                 case 2:
2854                                         m->mdmreg[REG_DTRHUP] |= BIT_DTRHUP;
2855                                         m->mdmreg[REG_DTRR] &= ~BIT_DTRR;
2856                                         break;
2857                                 case 3:
2858                                         m->mdmreg[REG_DTRHUP] |= BIT_DTRHUP;
2859                                         m->mdmreg[REG_DTRR] |= BIT_DTRR;
2860                                         break;
2861                                 default:
2862                                         PARSE_ERROR1
2863                         }
2864                         break;
2865                 case 'E':
2866                         /* &E -Set EAZ/MSN */
2867                         p[0]++;
2868                         isdn_tty_get_msnstr(m->msn, p);
2869                         break;
2870                 case 'F':
2871                         /* &F -Set Factory-Defaults */
2872                         p[0]++;
2873                         if (info->msr & UART_MSR_DCD)
2874                                 PARSE_ERROR1;
2875                         isdn_tty_reset_profile(m);
2876                         isdn_tty_modem_reset_regs(info, 1);
2877                         break;
2878 #ifdef DUMMY_HAYES_AT
2879                 case 'K':
2880                         /* only for be compilant with common scripts */
2881                         /* &K Flowcontrol - no function */
2882                         p[0]++;
2883                         isdn_getnum(p);
2884                         break;
2885 #endif
2886                 case 'L':
2887                         /* &L -Set Numbers to listen on */
2888                         p[0]++;
2889                         i = 0;
2890                         while (*p[0] && (strchr("0123456789,-*[]?;", *p[0])) &&
2891                                (i < ISDN_LMSNLEN))
2892                                 m->lmsn[i++] = *p[0]++;
2893                         m->lmsn[i] = '\0';
2894                         break;
2895                 case 'R':
2896                         /* &R - Set V.110 bitrate adaption */
2897                         p[0]++;
2898                         i = isdn_getnum(p);
2899                         switch (i) {
2900                                 case 0:
2901                                         /* Switch off V.110, back to X.75 */
2902                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_X75I;
2903                                         m->mdmreg[REG_SI2] = 0;
2904                                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16;
2905                                         break;
2906                                 case 9600:
2907                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_V11096;
2908                                         m->mdmreg[REG_SI2] = 197;
2909                                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16 / 10;
2910                                         break;
2911                                 case 19200:
2912                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_V11019;
2913                                         m->mdmreg[REG_SI2] = 199;
2914                                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16 / 10;
2915                                         break;
2916                                 case 38400:
2917                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_V11038;
2918                                         m->mdmreg[REG_SI2] = 198; /* no existing standard for this */
2919                                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16 / 10;
2920                                         break;
2921                                 default:
2922                                         PARSE_ERROR1;
2923                         }
2924                         /* Switch off T.70 */
2925                         m->mdmreg[REG_T70] &= ~(BIT_T70 | BIT_T70_EXT);
2926                         /* Set Service 7 */
2927                         m->mdmreg[REG_SI1] |= 4;
2928                         break;
2929                 case 'S':
2930                         /* &S - Set Windowsize */
2931                         p[0]++;
2932                         i = isdn_getnum(p);
2933                         if ((i > 0) && (i < 9))
2934                                 m->mdmreg[REG_WSIZE] = i;
2935                         else
2936                                 PARSE_ERROR1;
2937                         break;
2938                 case 'V':
2939                         /* &V - Show registers */
2940                         p[0]++;
2941                         isdn_tty_at_cout("\r\n", info);
2942                         for (i = 0; i < ISDN_MODEM_NUMREG; i++) {
2943                                 sprintf(rb, "S%02d=%03d%s", i,
2944                                         m->mdmreg[i], ((i + 1) % 10) ? " " : "\r\n");
2945                                 isdn_tty_at_cout(rb, info);
2946                         }
2947                         sprintf(rb, "\r\nEAZ/MSN: %.50s\r\n",
2948                                 strlen(m->msn) ? m->msn : "None");
2949                         isdn_tty_at_cout(rb, info);
2950                         if (strlen(m->lmsn)) {
2951                                 isdn_tty_at_cout("\r\nListen: ", info);
2952                                 isdn_tty_at_cout(m->lmsn, info);
2953                                 isdn_tty_at_cout("\r\n", info);
2954                         }
2955                         break;
2956                 case 'W':
2957                         /* &W - Write Profile */
2958                         p[0]++;
2959                         switch (*p[0]) {
2960                                 case '0':
2961                                         p[0]++;
2962                                         modem_write_profile(m);
2963                                         break;
2964                                 default:
2965                                         PARSE_ERROR1;
2966                         }
2967                         break;
2968                 case 'X':
2969                         /* &X - Switch to BTX-Mode and T.70 */
2970                         p[0]++;
2971                         switch (isdn_getnum(p)) {
2972                                 case 0:
2973                                         m->mdmreg[REG_T70] &= ~(BIT_T70 | BIT_T70_EXT);
2974                                         info->xmit_size = m->mdmreg[REG_PSIZE] * 16;
2975                                         break;
2976                                 case 1:
2977                                         m->mdmreg[REG_T70] |= BIT_T70;
2978                                         m->mdmreg[REG_T70] &= ~BIT_T70_EXT;
2979                         &nbs