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 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 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_len(&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_len(&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                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_X75I;
2980                                         info->xmit_size = 112;
2981                                         m->mdmreg[REG_SI1] = 4;
2982                                         m->mdmreg[REG_SI2] = 0;
2983                                         break;
2984                                 case 2:
2985                                         m->mdmreg[REG_T70] |= (BIT_T70 | BIT_T70_EXT);
2986                                         m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_X75I;
2987                                         info->xmit_size = 112;
2988                                         m->mdmreg[REG_SI1] = 4;
2989                                         m->mdmreg[REG_SI2] = 0;
2990                                         break;
2991                                 default:
2992                                         PARSE_ERROR1;
2993                         }
2994                         break;
2995                 default:
2996                         PARSE_ERROR1;
2997         }
2998         return 0;
2999 }
3000
3001 static int
3002 isdn_tty_check_ats(int mreg, int mval, modem_info * info, atemu * m)
3003 {
3004         /* Some plausibility checks */
3005         switch (mreg) {
3006                 case REG_L2PROT:
3007                         if (mval > ISDN_PROTO_L2_MAX)
3008                                 return 1;
3009                         break;
3010                 case REG_PSIZE:
3011                         if ((mval * 16) > ISDN_SERIAL_XMIT_MAX)
3012                                 return 1;
3013 #ifdef CONFIG_ISDN_AUDIO
3014                         if ((m->mdmreg[REG_SI1] & 1) && (mval > VBUFX))
3015                                 return 1;
3016 #endif
3017                         info->xmit_size = mval * 16;
3018                         switch (m->mdmreg[REG_L2PROT]) {
3019                                 case ISDN_PROTO_L2_V11096:
3020                                 case ISDN_PROTO_L2_V11019:
3021                                 case ISDN_PROTO_L2_V11038:
3022                                         info->xmit_size /= 10;
3023                         }
3024                         break;
3025                 case REG_SI1I:
3026                 case REG_PLAN:
3027                 case REG_SCREEN:
3028                         /* readonly registers */
3029                         return 1;
3030         }
3031         return 0;
3032 }
3033
3034 /*
3035  * Perform ATS command
3036  */
3037 static int
3038 isdn_tty_cmd_ATS(char **p, modem_info * info)
3039 {
3040         atemu *m = &info->emu;
3041         int bitpos;
3042         int mreg;
3043         int mval;
3044         int bval;
3045
3046         mreg = isdn_getnum(p);
3047         if (mreg < 0 || mreg >= ISDN_MODEM_NUMREG)
3048                 PARSE_ERROR1;
3049         switch (*p[0]) {
3050                 case '=':
3051                         p[0]++;
3052                         mval = isdn_getnum(p);
3053                         if (mval < 0 || mval > 255)
3054                                 PARSE_ERROR1;
3055                         if (isdn_tty_check_ats(mreg, mval, info, m))
3056                                 PARSE_ERROR1;
3057                         m->mdmreg[mreg] = mval;
3058                         break;
3059                 case '.':
3060                         /* Set/Clear a single bit */
3061                         p[0]++;
3062                         bitpos = isdn_getnum(p);
3063                         if ((bitpos < 0) || (bitpos > 7))
3064                                 PARSE_ERROR1;
3065                         switch (*p[0]) {
3066                                 case '=':
3067                                         p[0]++;
3068                                         bval = isdn_getnum(p);
3069                                         if (bval < 0 || bval > 1)
3070                                                 PARSE_ERROR1;
3071                                         if (bval)
3072                                                 mval = m->mdmreg[mreg] | (1 << bitpos);
3073                                         else
3074                                                 mval = m->mdmreg[mreg] & ~(1 << bitpos);
3075                                         if (isdn_tty_check_ats(mreg, mval, info, m))
3076                                                 PARSE_ERROR1;
3077                                         m->mdmreg[mreg] = mval;
3078                                         break;
3079                                 case '?':
3080                                         p[0]++;
3081                                         isdn_tty_at_cout("\r\n", info);
3082                                         isdn_tty_at_cout((m->mdmreg[mreg] & (1 << bitpos)) ? "1" : "0",
3083                                                          info);
3084                                         break;
3085                                 default:
3086                                         PARSE_ERROR1;
3087                         }
3088                         break;
3089                 case '?':
3090                         p[0]++;
3091                         isdn_tty_show_profile(mreg, info);
3092                         break;
3093                 default:
3094                         PARSE_ERROR1;
3095                         break;
3096         }
3097         return 0;
3098 }
3099
3100 /*
3101  * Perform ATA command
3102  */
3103 static void
3104 isdn_tty_cmd_ATA(modem_info * info)
3105 {
3106         atemu *m = &info->emu;
3107         isdn_ctrl cmd;
3108         int l2;
3109
3110         if (info->msr & UART_MSR_RI) {
3111                 /* Accept incoming call */
3112                 info->last_dir = 0;
3113                 strcpy(info->last_num, dev->num[info->drv_index]);
3114                 m->mdmreg[REG_RINGCNT] = 0;
3115                 info->msr &= ~UART_MSR_RI;
3116                 l2 = m->mdmreg[REG_L2PROT];
3117 #ifdef CONFIG_ISDN_AUDIO
3118                 /* If more than one bit set in reg18, autoselect Layer2 */
3119                 if ((m->mdmreg[REG_SI1] & m->mdmreg[REG_SI1I]) != m->mdmreg[REG_SI1]) {
3120                         if (m->mdmreg[REG_SI1I] == 1) {
3121                                 if ((l2 != ISDN_PROTO_L2_MODEM) && (l2 != ISDN_PROTO_L2_FAX))
3122                                         l2 = ISDN_PROTO_L2_TRANS;
3123                         } else
3124                                 l2 = ISDN_PROTO_L2_X75I;
3125                 }
3126 #endif
3127                 cmd.driver = info->isdn_driver;
3128                 cmd.command = ISDN_CMD_SETL2;
3129                 cmd.arg = info->isdn_channel + (l2 << 8);
3130                 info->last_l2 = l2;
3131                 isdn_command(&cmd);
3132                 cmd.driver = info->isdn_driver;
3133                 cmd.command = ISDN_CMD_SETL3;
3134                 cmd.arg = info->isdn_channel + (m->mdmreg[REG_L3PROT] << 8);
3135 #ifdef CONFIG_ISDN_TTY_FAX
3136                 if (l2 == ISDN_PROTO_L2_FAX) {
3137                         cmd.parm.fax = info->fax;
3138                         info->fax->direction = ISDN_TTY_FAX_CONN_IN;
3139                 }
3140 #endif
3141                 isdn_command(&cmd);
3142                 cmd.driver = info->isdn_driver;
3143                 cmd.arg = info->isdn_channel;
3144                 cmd.command = ISDN_CMD_ACCEPTD;
3145                 info->dialing = 16;
3146                 info->emu.carrierwait = 0;
3147                 isdn_command(&cmd);
3148                 isdn_timer_ctrl(ISDN_TIMER_CARRIER, 1);
3149         } else
3150                 isdn_tty_modem_result(RESULT_NO_ANSWER, info);
3151 }
3152
3153 #ifdef CONFIG_ISDN_AUDIO
3154 /*
3155  * Parse AT+F.. commands
3156  */
3157 static int
3158 isdn_tty_cmd_PLUSF(char **p, modem_info * info)
3159 {
3160         atemu *m = &info->emu;
3161         char rs[20];
3162
3163         if (!strncmp(p[0], "CLASS", 5)) {
3164                 p[0] += 5;
3165                 switch (*p[0]) {
3166                         case '?':
3167                                 p[0]++;
3168                                 sprintf(rs, "\r\n%d",
3169                                         (m->mdmreg[REG_SI1] & 1) ? 8 : 0);
3170 #ifdef CONFIG_ISDN_TTY_FAX
3171                                 if (TTY_IS_FCLASS2(info))
3172                                                 sprintf(rs, "\r\n2");
3173                                 else if (TTY_IS_FCLASS1(info))
3174                                                 sprintf(rs, "\r\n1");
3175 #endif
3176                                 isdn_tty_at_cout(rs, info);
3177                                 break;
3178                         case '=':
3179                                 p[0]++;
3180                                 switch (*p[0]) {
3181                                         case '0':
3182                                                 p[0]++;
3183                                                 m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_X75I;
3184                                                 m->mdmreg[REG_L3PROT] = ISDN_PROTO_L3_TRANS;
3185                                                 m->mdmreg[REG_SI1] = 4;
3186                                                 info->xmit_size =
3187                                                     m->mdmreg[REG_PSIZE] * 16;
3188                                                 break;
3189 #ifdef CONFIG_ISDN_TTY_FAX
3190                                         case '1':
3191                                                 p[0]++;
3192                                                 if (!(dev->global_features &
3193                                                         ISDN_FEATURE_L3_FCLASS1))
3194                                                         PARSE_ERROR1;
3195                                                 m->mdmreg[REG_SI1] = 1;
3196                                                 m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_FAX;
3197                                                 m->mdmreg[REG_L3PROT] = ISDN_PROTO_L3_FCLASS1;
3198                                                 info->xmit_size =
3199                                                     m->mdmreg[REG_PSIZE] * 16;
3200                                                 break;
3201                                         case '2':
3202                                                 p[0]++;
3203                                                 if (!(dev->global_features &
3204                                                         ISDN_FEATURE_L3_FCLASS2))
3205                                                         PARSE_ERROR1;
3206                                                 m->mdmreg[REG_SI1] = 1;
3207                                                 m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_FAX;
3208                                                 m->mdmreg[REG_L3PROT] = ISDN_PROTO_L3_FCLASS2;
3209                                                 info->xmit_size =
3210                                                     m->mdmreg[REG_PSIZE] * 16;
3211                                                 break;
3212 #endif
3213                                         case '8':
3214                                                 p[0]++;
3215                                                 /* L2 will change on dialout with si=1 */
3216                                                 m->mdmreg[REG_L2PROT] = ISDN_PROTO_L2_X75I;
3217                                                 m->mdmreg[REG_L3PROT] = ISDN_PROTO_L3_TRANS;
3218                                                 m->mdmreg[REG_SI1] = 5;
3219                                                 info->xmit_size = VBUF;
3220                                                 break;
3221                                         case '?':
3222                                                 p[0]++;
3223                                                 strcpy(rs, "\r\n0,");
3224 #ifdef CONFIG_ISDN_TTY_FAX
3225                                                 if (dev->global_features &
3226                                                         ISDN_FEATURE_L3_FCLASS1)
3227                                                         strcat(rs, "1,");
3228                                                 if (dev->global_features &
3229                                                         ISDN_FEATURE_L3_FCLASS2)
3230                                                         strcat(rs, "2,");
3231 #endif
3232                                                 strcat(rs, "8");
3233                                                 isdn_tty_at_cout(rs, info);
3234                                                 break;
3235                                         default:
3236                                                 PARSE_ERROR1;
3237                                 }
3238                                 break;
3239                         default:
3240                                 PARSE_ERROR1;
3241                 }
3242                 return 0;
3243         }
3244 #ifdef CONFIG_ISDN_TTY_FAX
3245         return (isdn_tty_cmd_PLUSF_FAX(p, info));
3246 #else
3247         PARSE_ERROR1;
3248 #endif
3249 }
3250
3251 /*
3252  * Parse AT+V.. commands
3253  */
3254 static int
3255 isdn_tty_cmd_PLUSV(char **p, modem_info * info)
3256 {
3257         atemu *m = &info->emu;
3258         isdn_ctrl cmd;
3259         static char *vcmd[] =
3260         {"NH", "IP", "LS", "RX", "SD", "SM", "TX", "DD", NULL};
3261         int i;
3262         int par1;
3263         int par2;
3264         char rs[20];
3265
3266         i = 0;
3267         while (vcmd[i]) {
3268                 if (!strncmp(vcmd[i], p[0], 2)) {
3269                         p[0] += 2;
3270                         break;
3271                 }
3272                 i++;
3273         }
3274         switch (i) {
3275                 case 0:
3276                         /* AT+VNH - Auto hangup feature */
3277                         switch (*p[0]) {
3278                                 case '?':
3279                                         p[0]++;
3280                                         isdn_tty_at_cout("\r\n1", info);
3281                                         break;
3282                                 case '=':
3283                                         p[0]++;
3284                                         switch (*p[0]) {
3285                                                 case '1':
3286                                                         p[0]++;
3287                                                         break;
3288                                                 case '?':
3289                                                         p[0]++;
3290                                                         isdn_tty_at_cout("\r\n1", info);
3291                                                         break;
3292                                                 default:
3293                                                         PARSE_ERROR1;
3294                                         }
3295                                         break;
3296                                 default:
3297                                         PARSE_ERROR1;
3298                         }
3299                         break;
3300                 case 1:
3301                         /* AT+VIP - Reset all voice parameters */
3302                         isdn_tty_modem_reset_vpar(m);
3303                         break;
3304                 case 2:
3305                         /* AT+VLS - Select device, accept incoming call */
3306                         switch (*p[0]) {
3307                                 case '?':
3308                                         p[0]++;
3309                                         sprintf(rs, "\r\n%d", m->vpar[0]);
3310                                         isdn_tty_at_cout(rs, info);
3311                                         break;
3312                                 case '=':
3313                                         p[0]++;
3314                                         switch (*p[0]) {
3315                                                 case '0':
3316                                                         p[0]++;
3317                                                         m->vpar[0] = 0;
3318                                                         break;
3319                                                 case '2':
3320                                                         p[0]++;
3321                                                         m->vpar[0] = 2;
3322                                                         break;
3323                                                 case '?':
3324                                                         p[0]++;
3325                                                         isdn_tty_at_cout("\r\n0,2", info);
3326                                                         break;
3327                                                 default:
3328                                                         PARSE_ERROR1;
3329                                         }
3330                                         break;
3331                                 default:
3332                                         PARSE_ERROR1;
3333                         }
3334                         break;
3335                 case 3:
3336                         /* AT+VRX - Start recording */
3337                         if (!m->vpar[0])
3338                                 PARSE_ERROR1;
3339                         if (info->online != 1) {
3340                                 isdn_tty_modem_result(RESULT_NO_ANSWER, info);
3341                                 return 1;
3342                         }
3343                         info->dtmf_state = isdn_audio_dtmf_init(info->dtmf_state);
3344                         if (!info->dtmf_state) {
3345                                 printk(KERN_WARNING "isdn_tty: Couldn't malloc dtmf state\n");
3346                                 PARSE_ERROR1;
3347                         }
3348                         info->silence_state = isdn_audio_silence_init(info->silence_state);
3349                         if (!info->silence_state) {
3350                                 printk(KERN_WARNING "isdn_tty: Couldn't malloc silence state\n");
3351                                 PARSE_ERROR1;
3352                         }
3353                         if (m->vpar[3] < 5) {
3354                                 info->adpcmr = isdn_audio_adpcm_init(info->adpcmr, m->vpar[3]);
3355                                 if (!info->adpcmr) {
3356                                         printk(KERN_WARNING "isdn_tty: Couldn't malloc adpcm state\n");
3357                                         PARSE_ERROR1;
3358                                 }
3359                         }
3360 #ifdef ISDN_DEBUG_AT
3361                         printk(KERN_DEBUG "AT: +VRX\n");
3362 #endif
3363                         info->vonline |= 1;
3364                         isdn_tty_modem_result(RESULT_CONNECT, info);
3365                         return 0;
3366                         break;
3367                 case 4:
3368                         /* AT+VSD - Silence detection */
3369                         switch (*p[0]) {
3370                                 case '?':
3371                                         p[0]++;
3372                                         sprintf(rs, "\r\n<%d>,<%d>",
3373                                                 m->vpar[1],
3374                                                 m->vpar[2]);
3375                                         isdn_tty_at_cout(rs, info);
3376                                         break;
3377                                 case '=':
3378                                         p[0]++;
3379                                         if ((*p[0]>='0') && (*p[0]<='9')) {
3380                                                 par1 = isdn_getnum(p);
3381                                                 if ((par1 < 0) || (par1 > 31))
3382                                                         PARSE_ERROR1;
3383                                                 if (*p[0] != ',')
3384                                                         PARSE_ERROR1;
3385                                                 p[0]++;
3386                                                 par2 = isdn_getnum(p);
3387                                                 if ((par2 < 0) || (par2 > 255))
3388                                                         PARSE_ERROR1;
3389                                                 m->vpar[1] = par1;
3390                                                 m->vpar[2] = par2;
3391                                                 break;
3392                                         } else
3393                                         if (*p[0] == '?') {
3394                                                 p[0]++;
3395                                                 isdn_tty_at_cout("\r\n<0-31>,<0-255>",
3396                                                            info);
3397                                                 break;
3398                                         } else
3399                                         PARSE_ERROR1;
3400                                         break;
3401                                 default:
3402                                         PARSE_ERROR1;
3403                         }
3404                         break;
3405                 case 5:
3406                         /* AT+VSM - Select compression */
3407                         switch (*p[0]) {
3408                                 case '?':
3409                                         p[0]++;
3410                                         sprintf(rs, "\r\n<%d>,<%d><8000>",
3411                                                 m->vpar[3],
3412                                                 m->vpar[1]);
3413                                         isdn_tty_at_cout(rs, info);
3414                                         break;
3415                                 case '=':
3416                                         p[0]++;
3417                                         switch (*p[0]) {
3418                                                 case '2':
3419                                                 case '3':
3420                                                 case '4':
3421                                                 case '5':
3422                                                 case '6':
3423                                                         par1 = isdn_getnum(p);
3424                                                         if ((par1 < 2) || (par1 > 6))
3425                                                                 PARSE_ERROR1;
3426                                                         m->vpar[3] = par1;
3427                                                         break;
3428                                                 case '?':
3429                                                         p[0]++;
3430                                                         isdn_tty_at_cout("\r\n2;ADPCM;2;0;(8000)\r\n",
3431                                                                    info);
3432                                                         isdn_tty_at_cout("3;ADPCM;3;0;(8000)\r\n",
3433                                                                    info);
3434                                                         isdn_tty_at_cout("4;ADPCM;4;0;(8000)\r\n",
3435                                                                    info);
3436                                                         isdn_tty_at_cout("5;ALAW;8;0;(8000)\r\n",
3437                                                                    info);
3438                                                         isdn_tty_at_cout("6;ULAW;8;0;(8000)\r\n",
3439                                                                    info);
3440                                                         break;
3441                                                 default:
3442                                                         PARSE_ERROR1;
3443                                         }
3444                                         break;
3445                                 default:
3446                                         PARSE_ERROR1;
3447                         }
3448                         break;
3449                 case 6:
3450                         /* AT+VTX - Start sending */
3451                         if (!m->vpar[0])
3452                                 PARSE_ERROR1;
3453                         if (info->online != 1) {
3454                                 isdn_tty_modem_result(RESULT_NO_ANSWER, info);
3455                                 return 1;
3456                         }
3457                         info->dtmf_state = isdn_audio_dtmf_init(info->dtmf_state);
3458                         if (!info->dtmf_state) {
3459                                 printk(KERN_WARNING "isdn_tty: Couldn't malloc dtmf state\n");
3460                                 PARSE_ERROR1;
3461                         }
3462                         if (m->vpar[3] < 5) {
3463                                 info->adpcms = isdn_audio_adpcm_init(info->adpcms, m->vpar[3]);
3464                                 if (!info->adpcms) {
3465                                         printk(KERN_WARNING "isdn_tty: Couldn't malloc adpcm state\n");
3466                                         PARSE_ERROR1;
3467                                 }
3468                         }
3469 #ifdef ISDN_DEBUG_AT
3470                         printk(KERN_DEBUG "AT: +VTX\n");
3471 #endif
3472                         m->lastDLE = 0;
3473                         info->vonline |= 2;
3474                         isdn_tty_modem_result(RESULT_CONNECT, info);
3475                         return 0;
3476                         break;
3477                 case 7:
3478                         /* AT+VDD - DTMF detection */
3479                         switch (*p[0]) {
3480                                 case '?':
3481                                         p[0]++;
3482                                         sprintf(rs, "\r\n<%d>,<%d>",
3483                                                 m->vpar[4],
3484                                                 m->vpar[5]);
3485                                         isdn_tty_at_cout(rs, info);
3486                                         break;
3487                                 case '=':
3488                                         p[0]++;
3489                                         if ((*p[0]>='0') && (*p[0]<='9')) {
3490                                                 if (info->online != 1)
3491                                                         PARSE_ERROR1;
3492                                                 par1 = isdn_getnum(p);
3493                                                 if ((par1 < 0) || (par1 > 15))
3494                                                         PARSE_ERROR1;
3495                                                 if (*p[0] != ',')
3496                                                         PARSE_ERROR1;
3497                                                 p[0]++;
3498                                                 par2 = isdn_getnum(p);
3499                                                 if ((par2 < 0) || (par2 > 255))
3500                                                         PARSE_ERROR1;
3501                                                 m->vpar[4] = par1;
3502                                                 m->vpar[5] = par2;
3503                                                 cmd.driver = info->isdn_driver;
3504                                                 cmd.command = ISDN_CMD_AUDIO;
3505                                                 cmd.arg = info->isdn_channel + (ISDN_AUDIO_SETDD << 8);
3506                                                 cmd.parm.num[0] = par1;
3507                                                 cmd.parm.num[1] = par2;
3508                                                 isdn_command(&cmd);
3509                                                 break;
3510                                         } else
3511                                         if (*p[0] == '?') {
3512                                                 p[0]++;
3513                                                 isdn_tty_at_cout("\r\n<0-15>,<0-255>",
3514                                                         info);
3515                                                 break;
3516                                         } else
3517                                         PARSE_ERROR1;
3518                                         break;
3519                                 default:
3520                                         PARSE_ERROR1;
3521                         }
3522                         break;
3523                 default:
3524                         PARSE_ERROR1;
3525         }
3526         return 0;
3527 }
3528 #endif                          /* CONFIG_ISDN_AUDIO */
3529
3530 /*
3531  * Parse and perform an AT-command-line.
3532  */
3533 static void
3534 isdn_tty_parse_at(modem_info * info)
3535 {
3536         atemu *m = &info->emu;
3537         char *p;
3538         char ds[40];
3539
3540 #ifdef ISDN_DEBUG_AT
3541         printk(KERN_DEBUG "AT: '%s'\n", m->mdmcmd);
3542 #endif
3543         for (p = &m->mdmcmd[2]; *p;) {
3544                 switch (*p) {
3545                         case ' ':
3546                                 p++;
3547                                 break;
3548                         case 'A':
3549                                 /* A - Accept incoming call */
3550                                 p++;
3551                                 isdn_tty_cmd_ATA(info);
3552                                 return;
3553                                 break;
3554                         case 'D':
3555                                 /* D - Dial */
3556                                 if (info->msr & UART_MSR_DCD)
3557                                         PARSE_ERROR;
3558                                 if (info->msr & UART_MSR_RI) {
3559                                         isdn_tty_modem_result(RESULT_NO_CARRIER, info);
3560                                         return;
3561                                 }
3562                                 isdn_tty_getdial(++p, ds, sizeof ds);
3563                                 p += strlen(p);
3564                                 if (!strlen(m->msn))
3565                                         isdn_tty_modem_result(RESULT_NO_MSN_EAZ, info);
3566                                 else if (strlen(ds))
3567                                         isdn_tty_dial(ds, info, m);
3568                                 else
3569                                         PARSE_ERROR;
3570                                 return;
3571                         case 'E':
3572                                 /* E - Turn Echo on/off */
3573                                 p++;
3574                                 switch (isdn_getnum(&p)) {
3575                                         case 0:
3576                                                 m->mdmreg[REG_ECHO] &= ~BIT_ECHO;
3577                                                 break;
3578                                         case 1:
3579                                                 m->mdmreg[REG_ECHO] |= BIT_ECHO;
3580                                                 break;
3581                                         default:
3582                                                 PARSE_ERROR;
3583                                 }
3584                                 break;
3585                         case 'H':
3586                                 /* H - On/Off-hook */
3587                                 p++;
3588                                 switch (*p) {
3589                                         case '0':
3590                                                 p++;
3591                                                 isdn_tty_on_hook(info);
3592                                                 break;
3593                                         case '1':
3594                                                 p++;
3595                                                 isdn_tty_off_hook();
3596                                                 break;
3597                                         default:
3598                                                 isdn_tty_on_hook(info);
3599                                                 break;
3600                                 }
3601                                 break;
3602                         case 'I':
3603                                 /* I - Information */
3604                                 p++;
3605                                 isdn_tty_at_cout("\r\nLinux ISDN", info);
3606                                 switch (*p) {
3607                                         case '0':
3608                                         case '1':
3609                                                 p++;
3610                                                 break;
3611                                         case '2':
3612                                                 p++;
3613                                                 isdn_tty_report(info);
3614                                                 break;
3615                                         case '3':
3616                                                 p++;
3617                                                 sprintf(ds, "\r\n%d", info->emu.charge);
3618                                                 isdn_tty_at_cout(ds, info);
3619                                                 break;
3620                                         default:;
3621                                 }
3622                                 break;
3623 #ifdef DUMMY_HAYES_AT
3624                         case 'L':
3625                         case 'M':
3626                                 /* only for be compilant with common scripts */
3627                                 /* no function */
3628                                 p++;
3629                                 isdn_getnum(&p);
3630                                 break;
3631 #endif
3632                         case 'O':
3633                                 /* O - Go online */
3634                                 p++;
3635                                 if (info->msr & UART_MSR_DCD)
3636                                         /* if B-Channel is up */
3637                                         isdn_tty_modem_result((m->mdmreg[REG_L2PROT] == ISDN_PROTO_L2_MODEM) ? RESULT_CONNECT:RESULT_CONNECT64000, info);
3638                                 else
3639                                         isdn_tty_modem_result(RESULT_NO_CARRIER, info);
3640                                 return;
3641                         case 'Q':
3642                                 /* Q - Turn Emulator messages on/off */
3643                                 p++;
3644                                 switch (isdn_getnum(&p)) {
3645                                         case 0:
3646                                                 m->mdmreg[REG_RESP] |= BIT_RESP;
3647                                                 break;
3648                                         case 1:
3649                                                 m->mdmreg[REG_RESP] &= ~BIT_RESP;
3650                                                 break;
3651                                         default:
3652                                                 PARSE_ERROR;
3653                                 }
3654                                 break;
3655                         case 'S':
3656                                 /* S - Set/Get Register */
3657                                 p++;
3658                                 if (isdn_tty_cmd_ATS(&p, info))
3659                                         return;
3660                                 break;
3661                         case 'V':
3662                                 /* V - Numeric or ASCII Emulator-messages */
3663                                 p++;
3664                                 switch (isdn_getnum(&p)) {
3665                                         case 0:
3666                                                 m->mdmreg[REG_RESP] |= BIT_RESPNUM;
3667                                                 break;
3668                                         case 1:
3669                                                 m->mdmreg[REG_RESP] &= ~BIT_RESPNUM;
3670                                                 break;
3671                                         default:
3672                                                 PARSE_ERROR;
3673                                 }
3674                                 break;
3675                         case 'Z':
3676                                 /* Z - Load Registers from Profile */
3677                                 p++;
3678                                 if (info->msr & UART_MSR_DCD) {
3679                                         info->online = 0;
3680                                         isdn_tty_on_hook(info);
3681                                 }
3682                                 isdn_tty_modem_reset_regs(info, 1);
3683                                 break;
3684                         case '+':
3685                                 p++;
3686                                 switch (*p) {
3687 #ifdef CONFIG_ISDN_AUDIO
3688                                         case 'F':
3689                                                 p++;
3690                                                 if (isdn_tty_cmd_PLUSF(&p, info))
3691                                                         return;
3692                                                 break;
3693                                         case 'V':
3694                                                 if ((!(m->mdmreg[REG_SI1] & 1)) ||
3695                                                         (m->mdmreg[REG_L2PROT] == ISDN_PROTO_L2_MODEM))
3696                                                         PARSE_ERROR;
3697                                                 p++;
3698                                                 if (isdn_tty_cmd_PLUSV(&p, info))
3699                                                         return;
3700                                                 break;
3701 #endif                          /* CONFIG_ISDN_AUDIO */
3702                                         case 'S':       /* SUSPEND */
3703                                                 p++;
3704                                                 isdn_tty_get_msnstr(ds, &p);
3705                                                 isdn_tty_suspend(ds, info, m);
3706                                                 break;
3707                                         case 'R':       /* RESUME */
3708                                                 p++;
3709                                                 isdn_tty_get_msnstr(ds, &p);
3710                                                 isdn_tty_resume(ds, info, m);
3711                                                 break;
3712                                         case 'M':       /* MESSAGE */
3713                                                 p++;
3714                                                 isdn_tty_send_msg(info, m, p);
3715                                                 break;
3716                                         default:
3717                                                 PARSE_ERROR;
3718                                 }
3719                                 break;
3720                         case '&':
3721                                 p++;
3722                                 if (isdn_tty_cmd_ATand(&p, info))
3723                                         return;
3724                                 break;
3725                         default:
3726                                 PARSE_ERROR;
3727                 }
3728         }
3729 #ifdef CONFIG_ISDN_AUDIO
3730         if (!info->vonline)
3731 #endif
3732                 isdn_tty_modem_result(RESULT_OK, info);
3733 }
3734
3735 /* Need own toupper() because standard-toupper is not available
3736  * within modules.
3737  */
3738 #define my_toupper(c) (((c>='a')&&(c<='z'))?(c&0xdf):c)
3739
3740 /*
3741  * Perform line-editing of AT-commands
3742  *
3743  * Parameters:
3744  *   p        inputbuffer
3745  *   count    length of buffer
3746  *   channel  index to line (minor-device)
3747  */
3748 static int
3749 isdn_tty_edit_at(const char *p, int count, modem_info * info)
3750 {
3751         atemu *m = &info->emu;
3752         int total = 0;
3753         u_char c;
3754         char eb[2];
3755         int cnt;
3756
3757         for (cnt = count; cnt > 0; p++, cnt--) {
3758                 c = *p;
3759                 total++;
3760                 if (c == m->mdmreg[REG_CR] || c == m->mdmreg[REG_LF]) {
3761                         /* Separator (CR or LF) */
3762                         m->mdmcmd[m->mdmcmdl] = 0;
3763                         if (m->mdmreg[REG_ECHO] & BIT_ECHO) {
3764                                 eb[0] = c;
3765                                 eb[1] = 0;
3766                                 isdn_tty_at_cout(eb, info);
3767                         }
3768                         if ((m->mdmcmdl >= 2) && (!(strncmp(m->mdmcmd, "AT", 2))))
3769                                 isdn_tty_parse_at(info);
3770                         m->mdmcmdl = 0;
3771                         continue;
3772                 }
3773                 if (c == m->mdmreg[REG_BS] && m->mdmreg[REG_BS] < 128) {
3774                         /* Backspace-Function */
3775                         if ((m->mdmcmdl > 2) || (!m->mdmcmdl)) {
3776                                 if (m->mdmcmdl)
3777                                         m->mdmcmdl--;
3778                                 if (m->mdmreg[REG_ECHO] & BIT_ECHO)
3779                                         isdn_tty_at_cout("\b", info);
3780                         }
3781                         continue;
3782                 }
3783                 if (cmdchar(c)) {
3784                         if (m->mdmreg[REG_ECHO] & BIT_ECHO) {
3785                                 eb[0] = c;
3786                                 eb[1] = 0;
3787                                 isdn_tty_at_cout(eb, info);
3788                         }
3789                         if (m->mdmcmdl < 255) {
3790                                 c = my_toupper(c);
3791                                 switch (m->mdmcmdl) {
3792                                         case 1:
3793                                                 if (c == 'T') {
3794                                                         m->mdmcmd[m->mdmcmdl] = c;
3795                                                         m->mdmcmd[++m->mdmcmdl] = 0;
3796                                                         break;
3797                                                 } else
3798                                                         m->mdmcmdl = 0;
3799                                                 /* Fall through, check for 'A' */
3800                                         case 0:
3801                                                 if (c == 'A') {
3802                                                         m->mdmcmd[m->mdmcmdl] = c;
3803                                                         m->mdmcmd[++m->mdmcmdl] = 0;
3804                                                 }
3805                                                 break;
3806                                         default:
3807                                                 m->mdmcmd[m->mdmcmdl] = c;
3808                                                 m->mdmcmd[++m->mdmcmdl] = 0;
3809                                 }
3810                         }
3811                 }
3812         }
3813         return total;
3814 }
3815
3816 /*
3817  * Switch all modem-channels who are online and got a valid
3818  * escape-sequence 1.5 seconds ago, to command-mode.
3819  * This function is called every second via timer-interrupt from within
3820  * timer-dispatcher isdn_timer_function()
3821  */
3822 void
3823 isdn_tty_modem_escape(void)
3824 {
3825         int ton = 0;
3826         int i;
3827         int midx;
3828
3829         for (i = 0; i < ISDN_MAX_CHANNELS; i++)
3830                 if (USG_MODEM(dev->usage[i]))
3831                         if ((midx = dev->m_idx[i]) >= 0) {
3832                                 modem_info *info = &dev->mdm.info[midx];
3833                                 if (info->online) {
3834                                         ton = 1;
3835                                         if ((info->emu.pluscount == 3) &&
3836                                             time_after(jiffies , info->emu.lastplus + PLUSWAIT2)) {
3837                                                 info->emu.pluscount = 0;
3838                                                 info->online = 0;
3839                                                 isdn_tty_modem_result(RESULT_OK, info);
3840                                         }
3841                                 }
3842                         }
3843         isdn_timer_ctrl(ISDN_TIMER_MODEMPLUS, ton);
3844 }
3845
3846 /*
3847  * Put a RING-message to all modem-channels who have the RI-bit set.
3848  * This function is called every second via timer-interrupt from within
3849  * timer-dispatcher isdn_timer_function()
3850  */
3851 void
3852 isdn_tty_modem_ring(void)
3853 {
3854         int ton = 0;
3855         int i;
3856
3857         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
3858                 modem_info *info = &dev->mdm.info[i];
3859                 if (info->msr & UART_MSR_RI) {
3860                         ton = 1;
3861                         isdn_tty_modem_result(RESULT_RING, info);
3862                 }
3863         }
3864         isdn_timer_ctrl(ISDN_TIMER_MODEMRING, ton);
3865 }
3866
3867 /*
3868  * For all online tty's, try sending data to
3869  * the lower levels.
3870  */
3871 void
3872 isdn_tty_modem_xmit(void)
3873 {
3874         int ton = 1;
3875         int i;
3876
3877         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
3878                 modem_info *info = &dev->mdm.info[i];
3879                 if (info->online) {
3880                         ton = 1;
3881                         isdn_tty_senddown(info);
3882                         isdn_tty_tint(info);
3883                 }
3884         }
3885         isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT, ton);
3886 }
3887
3888 /*
3889  * Check all channels if we have a 'no carrier' timeout.
3890  * Timeout value is set by Register S7.
3891  */
3892 void
3893 isdn_tty_carrier_timeout(void)
3894 {
3895         int ton = 0;
3896         int i;
3897
3898         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
3899                 modem_info *info = &dev->mdm.info[i];
3900                 if (info->dialing) {
3901                         if (info->emu.carrierwait++ > info->emu.mdmreg[REG_WAITC]) {
3902                                 info->dialing = 0;
3903                                 isdn_tty_modem_result(RESULT_NO_CARRIER, info);
3904                                 isdn_tty_modem_hup(info, 1);
3905                         }
3906                         else
3907                                 ton = 1;
3908                 }
3909         }
3910         isdn_timer_ctrl(ISDN_TIMER_CARRIER, ton);
3911 }