SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/i4l/isdn_ttyfax.c

   1 /* $Id: isdn_ttyfax.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
   2  *
   3  * Linux ISDN subsystem, tty_fax AT-command emulator (linklevel).
   4  *
   5  * Copyright 1999    by Armin Schindler (mac@melware.de)
   6  * Copyright 1999    by Ralf Spachmann (mel@melware.de)
   7  * Copyright 1999    by Cytronics & Melware
   8  *
   9  * This software may be used and distributed according to the terms
  10  * of the GNU General Public License, incorporated herein by reference.
  11  *
  12  */
  13
  14 #undef ISDN_TTY_FAX_STAT_DEBUG
  15 #undef ISDN_TTY_FAX_CMD_DEBUG
  16
  17 #include <linux/isdn.h>
  18 #include "isdn_common.h"
  19 #include "isdn_tty.h"
  20 #include "isdn_ttyfax.h"
  21
  22
  23 static char *isdn_tty_fax_revision = "$Revision: 1.1.2.2 $";
  24
  25 #define PARSE_ERROR1 { isdn_tty_fax_modem_result(1, info); return 1; }
  26
  27 static char *
  28 isdn_getrev(const char *revision)
  29 {
  30         char *rev;
  31         char *p;
  32
  33         if ((p = strchr(revision, ':'))) {
  34                 rev = p + 2;
  35                 p = strchr(rev, '$');
  36                 *--p = 0;
  37         } else
  38                 rev = "???";
  39         return rev;
  40 }
  41
  42 /*
  43  * Fax Class 2 Modem results
  44  *
  45  */
  46
  47 static void
  48 isdn_tty_fax_modem_result(int code, modem_info * info)
  49 {
  50         atemu *m = &info->emu;
  51         T30_s *f = info->fax;
  52         char rs[50];
  53         char rss[50];
  54         char *rp;
  55         int i;
  56         static char *msg[] =
  57         {"OK", "ERROR", "+FCON", "+FCSI:", "+FDIS:",
  58          "+FHNG:", "+FDCS:", "CONNECT", "+FTSI:",
  59          "+FCFR", "+FPTS:", "+FET:"};
  60
  61
  62         isdn_tty_at_cout("\r\n", info);
  63         isdn_tty_at_cout(msg[code], info);
  64
  65 #ifdef ISDN_TTY_FAX_CMD_DEBUG
  66         printk(KERN_DEBUG "isdn_tty: Fax send %s on ttyI%d\n",
  67                 msg[code], info->line);
  68 #endif
  69         switch (code) {
  70                 case 0: /* OK */
  71                         break;
  72                 case 1: /* ERROR */
  73                         break;
  74                 case 2: /* +FCON */
  75                         /* Append CPN, if enabled */
  76                         if ((m->mdmreg[REG_CPNFCON] & BIT_CPNFCON) &&
  77                                 (!(dev->usage[info->isdn_channel] & ISDN_USAGE_OUTGOING))) {
  78                                 sprintf(rs, "/%s", m->cpn);
  79                                 isdn_tty_at_cout(rs, info);
  80                         }
  81                         info->online = 1;
  82                         f->fet = 0;
  83                         if (f->phase == ISDN_FAX_PHASE_A)
  84                                 f->phase = ISDN_FAX_PHASE_B;
  85                         break;
  86                 case 3: /* +FCSI */
  87                 case 8: /* +FTSI */
  88                         sprintf(rs, "\"%s\"", f->r_id);
  89                         isdn_tty_at_cout(rs, info);
  90                         break;
  91                 case 4: /* +FDIS */
  92                         rs[0] = 0;
  93                         rp = &f->r_resolution;
  94                         for (i = 0; i < 8; i++) {
  95                                 sprintf(rss, "%c%s", rp[i] + 48,
  96                                         (i < 7) ? "," : "");
  97                                 strcat(rs, rss);
  98                         }
  99                         isdn_tty_at_cout(rs, info);
 100 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 101                         printk(KERN_DEBUG "isdn_tty: Fax DIS=%s on ttyI%d\n",
 102                                rs, info->line);
 103 #endif
 104                         break;
 105                 case 5: /* +FHNG */
 106                         sprintf(rs, "%d", f->code);
 107                         isdn_tty_at_cout(rs, info);
 108                         info->faxonline = 0;
 109                         break;
 110                 case 6: /* +FDCS */
 111                         rs[0] = 0;
 112                         rp = &f->r_resolution;
 113                         for (i = 0; i < 8; i++) {
 114                                 sprintf(rss, "%c%s", rp[i] + 48,
 115                                         (i < 7) ? "," : "");
 116                                 strcat(rs, rss);
 117                         }
 118                         isdn_tty_at_cout(rs, info);
 119 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 120                         printk(KERN_DEBUG "isdn_tty: Fax DCS=%s on ttyI%d\n",
 121                                rs, info->line);
 122 #endif
 123                         break;
 124                 case 7: /* CONNECT */
 125                         info->faxonline |= 2;
 126                         break;
 127                 case 9: /* FCFR */
 128                         break;
 129                 case 10:        /* FPTS */
 130                         isdn_tty_at_cout("1", info);
 131                         break;
 132                 case 11:        /* FET */
 133                         sprintf(rs, "%d", f->fet);
 134                         isdn_tty_at_cout(rs, info);
 135                         break;
 136         }
 137
 138         isdn_tty_at_cout("\r\n", info);
 139
 140         switch (code) {
 141                 case 7: /* CONNECT */
 142                         info->online = 2;
 143                         if (info->faxonline & 1) {
 144                                 sprintf(rs, "%c", XON);
 145                                 isdn_tty_at_cout(rs, info);
 146                         }
 147                         break;
 148         }
 149 }
 150
 151 static int
 152 isdn_tty_fax_command1(modem_info * info, isdn_ctrl * c)
 153 {
 154         static char *msg[] =
 155         {"OK", "CONNECT", "NO CARRIER", "ERROR", "FCERROR"};
 156
 157 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 158         printk(KERN_DEBUG "isdn_tty: FCLASS1 cmd(%d)\n", c->parm.aux.cmd);
 159 #endif
 160         if (c->parm.aux.cmd < ISDN_FAX_CLASS1_QUERY) {
 161                 if (info->online)
 162                         info->online = 1;
 163                 isdn_tty_at_cout("\r\n", info);
 164                 isdn_tty_at_cout(msg[c->parm.aux.cmd], info);
 165                 isdn_tty_at_cout("\r\n", info);
 166         }
 167         switch (c->parm.aux.cmd) {
 168                 case ISDN_FAX_CLASS1_CONNECT:
 169                         info->online = 2;
 170                         break;
 171                 case ISDN_FAX_CLASS1_OK:
 172                 case ISDN_FAX_CLASS1_FCERROR:
 173                 case ISDN_FAX_CLASS1_ERROR:
 174                 case ISDN_FAX_CLASS1_NOCARR:
 175                         break;
 176                 case ISDN_FAX_CLASS1_QUERY:
 177                         isdn_tty_at_cout("\r\n", info);
 178                         if (!c->parm.aux.para[0]) {
 179                                 isdn_tty_at_cout(msg[ISDN_FAX_CLASS1_ERROR], info);
 180                                 isdn_tty_at_cout("\r\n", info);
 181                         } else {
 182                                 isdn_tty_at_cout(c->parm.aux.para, info);
 183                                 isdn_tty_at_cout("\r\nOK\r\n", info);
 184                         }
 185                         break;
 186         }
 187         return (0);
 188 }
 189
 190 int
 191 isdn_tty_fax_command(modem_info * info, isdn_ctrl * c)
 192 {
 193         T30_s *f = info->fax;
 194         char rs[10];
 195
 196         if (TTY_IS_FCLASS1(info))
 197                 return (isdn_tty_fax_command1(info, c));
 198
 199 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 200         printk(KERN_DEBUG "isdn_tty: Fax cmd %d on ttyI%d\n",
 201                f->r_code, info->line);
 202 #endif
 203         switch (f->r_code) {
 204                 case ISDN_TTY_FAX_FCON:
 205                         info->faxonline = 1;
 206                         isdn_tty_fax_modem_result(2, info);     /* +FCON */
 207                         return (0);
 208                 case ISDN_TTY_FAX_FCON_I:
 209                         info->faxonline = 16;
 210                         isdn_tty_fax_modem_result(2, info);     /* +FCON */
 211                         return (0);
 212                 case ISDN_TTY_FAX_RID:
 213                         if (info->faxonline & 1)
 214                                 isdn_tty_fax_modem_result(3, info);     /* +FCSI */
 215                         if (info->faxonline & 16)
 216                                 isdn_tty_fax_modem_result(8, info);     /* +FTSI */
 217                         return (0);
 218                 case ISDN_TTY_FAX_DIS:
 219                         isdn_tty_fax_modem_result(4, info);     /* +FDIS */
 220                         return (0);
 221                 case ISDN_TTY_FAX_HNG:
 222                         if (f->phase == ISDN_FAX_PHASE_C) {
 223                                 if (f->direction == ISDN_TTY_FAX_CONN_IN) {
 224                                         sprintf(rs, "%c%c", DLE, ETX);
 225                                         isdn_tty_at_cout(rs, info);
 226                                 } else {
 227                                         sprintf(rs, "%c", 0x18);
 228                                         isdn_tty_at_cout(rs, info);
 229                                 }
 230                                 info->faxonline &= ~2;  /* leave data mode */
 231                                 info->online = 1;
 232                         }
 233                         f->phase = ISDN_FAX_PHASE_E;
 234                         isdn_tty_fax_modem_result(5, info);     /* +FHNG */
 235                         isdn_tty_fax_modem_result(0, info);     /* OK */
 236                         return (0);
 237                 case ISDN_TTY_FAX_DCS:
 238                         isdn_tty_fax_modem_result(6, info);     /* +FDCS */
 239                         isdn_tty_fax_modem_result(7, info);     /* CONNECT */
 240                         f->phase = ISDN_FAX_PHASE_C;
 241                         return (0);
 242                 case ISDN_TTY_FAX_TRAIN_OK:
 243                         isdn_tty_fax_modem_result(6, info);     /* +FDCS */
 244                         isdn_tty_fax_modem_result(0, info);     /* OK */
 245                         return (0);
 246                 case ISDN_TTY_FAX_SENT:
 247                         isdn_tty_fax_modem_result(0, info);     /* OK */
 248                         return (0);
 249                 case ISDN_TTY_FAX_CFR:
 250                         isdn_tty_fax_modem_result(9, info);     /* +FCFR */
 251                         return (0);
 252                 case ISDN_TTY_FAX_ET:
 253                         sprintf(rs, "%c%c", DLE, ETX);
 254                         isdn_tty_at_cout(rs, info);
 255                         isdn_tty_fax_modem_result(10, info);    /* +FPTS */
 256                         isdn_tty_fax_modem_result(11, info);    /* +FET */
 257                         isdn_tty_fax_modem_result(0, info);     /* OK */
 258                         info->faxonline &= ~2;  /* leave data mode */
 259                         info->online = 1;
 260                         f->phase = ISDN_FAX_PHASE_D;
 261                         return (0);
 262                 case ISDN_TTY_FAX_PTS:
 263                         isdn_tty_fax_modem_result(10, info);    /* +FPTS */
 264                         if (f->direction == ISDN_TTY_FAX_CONN_OUT) {
 265                                 if (f->fet == 1)
 266                                         f->phase = ISDN_FAX_PHASE_B;
 267                                 if (f->fet == 0)
 268                                         isdn_tty_fax_modem_result(0, info);     /* OK */
 269                         }
 270                         return (0);
 271                 case ISDN_TTY_FAX_EOP:
 272                         info->faxonline &= ~2;  /* leave data mode */
 273                         info->online = 1;
 274                         f->phase = ISDN_FAX_PHASE_D;
 275                         return (0);
 276
 277         }
 278         return (-1);
 279 }
 280
 281
 282 void
 283 isdn_tty_fax_bitorder(modem_info * info, struct sk_buff *skb)
 284 {
 285         __u8 LeftMask;
 286         __u8 RightMask;
 287         __u8 fBit;
 288         __u8 Data;
 289         int i;
 290
 291         if (!info->fax->bor) {
 292                 for (i = 0; i < skb->len; i++) {
 293                         Data = skb->data[i];
 294                         for (
 295                                     LeftMask = 0x80, RightMask = 0x01;
 296                                     LeftMask > RightMask;
 297                                     LeftMask >>= 1, RightMask <<= 1
 298                             ) {
 299                                 fBit = (Data & LeftMask);
 300                                 if (Data & RightMask)
 301                                         Data |= LeftMask;
 302                                 else
 303                                         Data &= ~LeftMask;
 304                                 if (fBit)
 305                                         Data |= RightMask;
 306                                 else
 307                                         Data &= ~RightMask;
 308
 309                         }
 310                         skb->data[i] = Data;
 311                 }
 312         }
 313 }
 314
 315 /*
 316  * Parse AT+F.. FAX class 1 commands
 317  */
 318
 319 static int
 320 isdn_tty_cmd_FCLASS1(char **p, modem_info * info)
 321 {
 322         static char *cmd[] =
 323         {"AE", "TS", "RS", "TM", "RM", "TH", "RH"};
 324         isdn_ctrl c;
 325         int par, i;
 326         u_long flags;
 327
 328         for (c.parm.aux.cmd = 0; c.parm.aux.cmd < 7; c.parm.aux.cmd++)
 329                 if (!strncmp(p[0], cmd[c.parm.aux.cmd], 2))
 330                         break;
 331
 332 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 333         printk(KERN_DEBUG "isdn_tty_cmd_FCLASS1 (%s,%d)\n", p[0], c.parm.aux.cmd);
 334 #endif
 335         if (c.parm.aux.cmd == 7)
 336                 PARSE_ERROR1;
 337
 338         p[0] += 2;
 339         switch (*p[0]) {
 340                 case '?':
 341                         p[0]++;
 342                         c.parm.aux.subcmd = AT_QUERY;
 343                         break;
 344                 case '=':
 345                         p[0]++;
 346                         if (*p[0] == '?') {
 347                                 p[0]++;
 348                                 c.parm.aux.subcmd = AT_EQ_QUERY;
 349                         } else {
 350                                 par = isdn_getnum(p);
 351                                 if ((par < 0) || (par > 255))
 352                                         PARSE_ERROR1;
 353                                 c.parm.aux.subcmd = AT_EQ_VALUE;
 354                                 c.parm.aux.para[0] = par;
 355                         }
 356                         break;
 357                 case 0:
 358                         c.parm.aux.subcmd = AT_COMMAND;
 359                         break;
 360                 default:
 361                         PARSE_ERROR1;
 362         }
 363         c.command = ISDN_CMD_FAXCMD;
 364 #ifdef ISDN_TTY_FAX_CMD_DEBUG
 365         printk(KERN_DEBUG "isdn_tty_cmd_FCLASS1 %d/%d/%d)\n",
 366                c.parm.aux.cmd, c.parm.aux.subcmd, c.parm.aux.para[0]);
 367 #endif
 368         if (info->isdn_driver < 0) {
 369                 if ((c.parm.aux.subcmd == AT_EQ_VALUE) ||
 370                     (c.parm.aux.subcmd == AT_COMMAND)) {
 371                         PARSE_ERROR1;
 372                 }
 373                 spin_lock_irqsave(&dev->lock, flags);
 374                 /* get a temporary connection to the first free fax driver */
 375                 i = isdn_get_free_channel(ISDN_USAGE_FAX, ISDN_PROTO_L2_FAX,
 376                                           ISDN_PROTO_L3_FCLASS1, -1, -1, "00");
 377                 if (i < 0) {
 378                         spin_unlock_irqrestore(&dev->lock, flags);
 379                         PARSE_ERROR1;
 380                 }
 381                 info->isdn_driver = dev->drvmap[i];
 382                 info->isdn_channel = dev->chanmap[i];
 383                 info->drv_index = i;
 384                 dev->m_idx[i] = info->line;
 385                 spin_unlock_irqrestore(&dev->lock, flags);
 386                 c.driver = info->isdn_driver;
 387                 c.arg = info->isdn_channel;
 388                 isdn_command(&c);
 389                 spin_lock_irqsave(&dev->lock, flags);
 390                 isdn_free_channel(info->isdn_driver, info->isdn_channel,
 391                                   ISDN_USAGE_FAX);
 392                 info->isdn_driver = -1;
 393                 info->isdn_channel = -1;
 394                 if (info->drv_index >= 0) {
 395                         dev->m_idx[info->drv_index] = -1;
 396                         info->drv_index = -1;
 397                 }
 398                 spin_unlock_irqrestore(&dev->lock, flags);
 399         } else {
 400                 c.driver = info->isdn_driver;
 401                 c.arg = info->isdn_channel;
 402                 isdn_command(&c);
 403         }
 404         return 1;
 405 }
 406
 407 /*
 408  * Parse AT+F.. FAX class 2 commands
 409  */
 410
 411 static int
 412 isdn_tty_cmd_FCLASS2(char **p, modem_info * info)
 413 {
 414         atemu *m = &info->emu;
 415         T30_s *f = info->fax;
 416         isdn_ctrl cmd;
 417         int par;
 418         char rs[50];
 419         char rss[50];
 420         int maxdccval[] =
 421         {1, 5, 2, 2, 3, 2, 0, 7};
 422
 423         /* FAA still unchanged */
 424         if (!strncmp(p[0], "AA", 2)) {  /* TODO */
 425                 p[0] += 2;
 426                 switch (*p[0]) {
 427                         case '?':
 428                                 p[0]++;
 429                                 sprintf(rs, "\r\n%d", 0);
 430                                 isdn_tty_at_cout(rs, info);
 431                                 break;
 432                         case '=':
 433                                 p[0]++;
 434                                 par = isdn_getnum(p);
 435                                 if ((par < 0) || (par > 255))
 436                                         PARSE_ERROR1;
 437                                 break;
 438                         default:
 439                                 PARSE_ERROR1;
 440                 }
 441                 return 0;
 442         }
 443         /* BADLIN=value - dummy 0=disable errorchk disabled, 1-255 nr. of lines for making page bad */
 444         if (!strncmp(p[0], "BADLIN", 6)) {
 445                 p[0] += 6;
 446                 switch (*p[0]) {
 447                         case '?':
 448                                 p[0]++;
 449                                 sprintf(rs, "\r\n%d", f->badlin);
 450                                 isdn_tty_at_cout(rs, info);
 451                                 break;
 452                         case '=':
 453                                 p[0]++;
 454                                 if (*p[0] == '?') {
 455                                         p[0]++;
 456                                         sprintf(rs, "\r\n0-255");
 457                                         isdn_tty_at_cout(rs, info);
 458                                 } else {
 459                                         par = isdn_getnum(p);
 460                                         if ((par < 0) || (par > 255))
 461                                                 PARSE_ERROR1;
 462                                         f->badlin = par;
 463 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 464                                         printk(KERN_DEBUG "isdn_tty: Fax FBADLIN=%d\n", par);
 465 #endif
 466                                 }
 467                                 break;
 468                         default:
 469                                 PARSE_ERROR1;
 470                 }
 471                 return 0;
 472         }
 473         /* BADMUL=value - dummy 0=disable errorchk disabled (treshold multiplier) */
 474         if (!strncmp(p[0], "BADMUL", 6)) {
 475                 p[0] += 6;
 476                 switch (*p[0]) {
 477                         case '?':
 478                                 p[0]++;
 479                                 sprintf(rs, "\r\n%d", f->badmul);
 480                                 isdn_tty_at_cout(rs, info);
 481                                 break;
 482                         case '=':
 483                                 p[0]++;
 484                                 if (*p[0] == '?') {
 485                                         p[0]++;
 486                                         sprintf(rs, "\r\n0-255");
 487                                         isdn_tty_at_cout(rs, info);
 488                                 } else {
 489                                         par = isdn_getnum(p);
 490                                         if ((par < 0) || (par > 255))
 491                                                 PARSE_ERROR1;
 492                                         f->badmul = par;
 493 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 494                                         printk(KERN_DEBUG "isdn_tty: Fax FBADMUL=%d\n", par);
 495 #endif
 496                                 }
 497                                 break;
 498                         default:
 499                                 PARSE_ERROR1;
 500                 }
 501                 return 0;
 502         }
 503         /* BOR=n - Phase C bit order, 0=direct, 1=reverse */
 504         if (!strncmp(p[0], "BOR", 3)) {
 505                 p[0] += 3;
 506                 switch (*p[0]) {
 507                         case '?':
 508                                 p[0]++;
 509                                 sprintf(rs, "\r\n%d", f->bor);
 510                                 isdn_tty_at_cout(rs, info);
 511                                 break;
 512                         case '=':
 513                                 p[0]++;
 514                                 if (*p[0] == '?') {
 515                                         p[0]++;
 516                                         sprintf(rs, "\r\n0,1");
 517                                         isdn_tty_at_cout(rs, info);
 518                                 } else {
 519                                         par = isdn_getnum(p);
 520                                         if ((par < 0) || (par > 1))
 521                                                 PARSE_ERROR1;
 522                                         f->bor = par;
 523 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 524                                         printk(KERN_DEBUG "isdn_tty: Fax FBOR=%d\n", par);
 525 #endif
 526                                 }
 527                                 break;
 528                         default:
 529                                 PARSE_ERROR1;
 530                 }
 531                 return 0;
 532         }
 533         /* NBC=n - No Best Capabilities */
 534         if (!strncmp(p[0], "NBC", 3)) {
 535                 p[0] += 3;
 536                 switch (*p[0]) {
 537                         case '?':
 538                                 p[0]++;
 539                                 sprintf(rs, "\r\n%d", f->nbc);
 540                                 isdn_tty_at_cout(rs, info);
 541                                 break;
 542                         case '=':
 543                                 p[0]++;
 544                                 if (*p[0] == '?') {
 545                                         p[0]++;
 546                                         sprintf(rs, "\r\n0,1");
 547                                         isdn_tty_at_cout(rs, info);
 548                                 } else {
 549                                         par = isdn_getnum(p);
 550                                         if ((par < 0) || (par > 1))
 551                                                 PARSE_ERROR1;
 552                                         f->nbc = par;
 553 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 554                                         printk(KERN_DEBUG "isdn_tty: Fax FNBC=%d\n", par);
 555 #endif
 556                                 }
 557                                 break;
 558                         default:
 559                                 PARSE_ERROR1;
 560                 }
 561                 return 0;
 562         }
 563         /* BUF? - Readonly buffersize readout  */
 564         if (!strncmp(p[0], "BUF?", 4)) {
 565                 p[0] += 4;
 566 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 567                 printk(KERN_DEBUG "isdn_tty: Fax FBUF? (%d) \n", (16 * m->mdmreg[REG_PSIZE]));
 568 #endif
 569                 p[0]++;
 570                 sprintf(rs, "\r\n %d ", (16 * m->mdmreg[REG_PSIZE]));
 571                 isdn_tty_at_cout(rs, info);
 572                 return 0;
 573         }
 574         /* CIG=string - local fax station id string for polling rx */
 575         if (!strncmp(p[0], "CIG", 3)) {
 576                 int i, r;
 577                 p[0] += 3;
 578                 switch (*p[0]) {
 579                         case '?':
 580                                 p[0]++;
 581                                 sprintf(rs, "\r\n\"%s\"", f->pollid);
 582                                 isdn_tty_at_cout(rs, info);
 583                                 break;
 584                         case '=':
 585                                 p[0]++;
 586                                 if (*p[0] == '?') {
 587                                         p[0]++;
 588                                         sprintf(rs, "\r\n\"STRING\"");
 589                                         isdn_tty_at_cout(rs, info);
 590                                 } else {
 591                                         if (*p[0] == '"')
 592                                                 p[0]++;
 593                                         for (i = 0; (*p[0]) && i < (FAXIDLEN - 1) && (*p[0] != '"'); i++) {
 594                                                 f->pollid[i] = *p[0]++;
 595                                         }
 596                                         if (*p[0] == '"')
 597                                                 p[0]++;
 598                                         for (r = i; r < FAXIDLEN; r++) {
 599                                                 f->pollid[r] = 32;
 600                                         }
 601                                         f->pollid[FAXIDLEN - 1] = 0;
 602 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 603                                         printk(KERN_DEBUG "isdn_tty: Fax local poll ID rx \"%s\"\n", f->pollid);
 604 #endif
 605                                 }
 606                                 break;
 607                         default:
 608                                 PARSE_ERROR1;
 609                 }
 610                 return 0;
 611         }
 612         /* CQ=n - copy qlty chk, 0= no chk, 1=only 1D chk, 2=1D+2D chk */
 613         if (!strncmp(p[0], "CQ", 2)) {
 614                 p[0] += 2;
 615                 switch (*p[0]) {
 616                         case '?':
 617                                 p[0]++;
 618                                 sprintf(rs, "\r\n%d", f->cq);
 619                                 isdn_tty_at_cout(rs, info);
 620                                 break;
 621                         case '=':
 622                                 p[0]++;
 623                                 if (*p[0] == '?') {
 624                                         p[0]++;
 625                                         sprintf(rs, "\r\n0,1,2");
 626                                         isdn_tty_at_cout(rs, info);
 627                                 } else {
 628                                         par = isdn_getnum(p);
 629                                         if ((par < 0) || (par > 2))
 630                                                 PARSE_ERROR1;
 631                                         f->cq = par;
 632 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 633                                         printk(KERN_DEBUG "isdn_tty: Fax FCQ=%d\n", par);
 634 #endif
 635                                 }
 636                                 break;
 637                         default:
 638                                 PARSE_ERROR1;
 639                 }
 640                 return 0;
 641         }
 642         /* CR=n - can receive? 0= no data rx or poll remote dev, 1=do receive data or poll remote dev */
 643         if (!strncmp(p[0], "CR", 2)) {
 644                 p[0] += 2;
 645                 switch (*p[0]) {
 646                         case '?':
 647                                 p[0]++;
 648                                 sprintf(rs, "\r\n%d", f->cr);   /* read actual value from struct and print */
 649                                 isdn_tty_at_cout(rs, info);
 650                                 break;
 651                         case '=':
 652                                 p[0]++;
 653                                 if (*p[0] == '?') {
 654                                         p[0]++;
 655                                         sprintf(rs, "\r\n0,1");         /* display online help */
 656                                         isdn_tty_at_cout(rs, info);
 657                                 } else {
 658                                         par = isdn_getnum(p);
 659                                         if ((par < 0) || (par > 1))
 660                                                 PARSE_ERROR1;
 661                                         f->cr = par;
 662 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 663                                         printk(KERN_DEBUG "isdn_tty: Fax FCR=%d\n", par);
 664 #endif
 665                                 }
 666                                 break;
 667                         default:
 668                                 PARSE_ERROR1;
 669                 }
 670                 return 0;
 671         }
 672         /* CTCRTY=value - ECM retry count */
 673         if (!strncmp(p[0], "CTCRTY", 6)) {
 674                 p[0] += 6;
 675                 switch (*p[0]) {
 676                         case '?':
 677                                 p[0]++;
 678                                 sprintf(rs, "\r\n%d", f->ctcrty);
 679                                 isdn_tty_at_cout(rs, info);
 680                                 break;
 681                         case '=':
 682                                 p[0]++;
 683                                 if (*p[0] == '?') {
 684                                         p[0]++;
 685                                         sprintf(rs, "\r\n0-255");
 686                                         isdn_tty_at_cout(rs, info);
 687                                 } else {
 688                                         par = isdn_getnum(p);
 689                                         if ((par < 0) || (par > 255))
 690                                                 PARSE_ERROR1;
 691                                         f->ctcrty = par;
 692 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 693                                         printk(KERN_DEBUG "isdn_tty: Fax FCTCRTY=%d\n", par);
 694 #endif
 695                                 }
 696                                 break;
 697                         default:
 698                                 PARSE_ERROR1;
 699                 }
 700                 return 0;
 701         }
 702         /* DCC=vr,br,wd,ln,df,ec,bf,st - DCE capabilities parms */
 703         if (!strncmp(p[0], "DCC", 3)) {
 704                 char *rp = &f->resolution;
 705                 int i;
 706
 707                 p[0] += 3;
 708                 switch (*p[0]) {
 709                         case '?':
 710                                 p[0]++;
 711                                 strcpy(rs, "\r\n");
 712                                 for (i = 0; i < 8; i++) {
 713                                         sprintf(rss, "%c%s", rp[i] + 48,
 714                                                 (i < 7) ? "," : "");
 715                                         strcat(rs, rss);
 716                                 }
 717                                 isdn_tty_at_cout(rs, info);
 718                                 break;
 719                         case '=':
 720                                 p[0]++;
 721                                 if (*p[0] == '?') {
 722                                         isdn_tty_at_cout("\r\n(0,1),(0-5),(0-2),(0-2),(0-3),(0-2),(0),(0-7)", info);
 723                                         p[0]++;
 724                                 } else {
 725                                         for (i = 0; (((*p[0] >= '0') && (*p[0] <= '9')) || (*p[0] == ',')) && (i < 8); i++) {
 726                                                 if (*p[0] != ',') {
 727                                                         if ((*p[0] - 48) > maxdccval[i]) {
 728                                                                 PARSE_ERROR1;
 729                                                         }
 730                                                         rp[i] = *p[0] - 48;
 731                                                         p[0]++;
 732                                                         if (*p[0] == ',')
 733                                                                 p[0]++;
 734                                                 } else
 735                                                         p[0]++;
 736                                         }
 737 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 738                                         printk(KERN_DEBUG "isdn_tty: Fax FDCC capabilities DCE=%d,%d,%d,%d,%d,%d,%d,%d\n",
 739                                                rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7]);
 740 #endif
 741                                 }
 742                                 break;
 743                         default:
 744                                 PARSE_ERROR1;
 745                 }
 746                 return 0;
 747         }
 748         /* DIS=vr,br,wd,ln,df,ec,bf,st - current session parms */
 749         if (!strncmp(p[0], "DIS", 3)) {
 750                 char *rp = &f->resolution;
 751                 int i;
 752
 753                 p[0] += 3;
 754                 switch (*p[0]) {
 755                         case '?':
 756                                 p[0]++;
 757                                 strcpy(rs, "\r\n");
 758                                 for (i = 0; i < 8; i++) {
 759                                         sprintf(rss, "%c%s", rp[i] + 48,
 760                                                 (i < 7) ? "," : "");
 761                                         strcat(rs, rss);
 762                                 }
 763                                 isdn_tty_at_cout(rs, info);
 764                                 break;
 765                         case '=':
 766                                 p[0]++;
 767                                 if (*p[0] == '?') {
 768                                         isdn_tty_at_cout("\r\n(0,1),(0-5),(0-2),(0-2),(0-3),(0-2),(0),(0-7)", info);
 769                                         p[0]++;
 770                                 } else {
 771                                         for (i = 0; (((*p[0] >= '0') && (*p[0] <= '9')) || (*p[0] == ',')) && (i < 8); i++) {
 772                                                 if (*p[0] != ',') {
 773                                                         if ((*p[0] - 48) > maxdccval[i]) {
 774                                                                 PARSE_ERROR1;
 775                                                         }
 776                                                         rp[i] = *p[0] - 48;
 777                                                         p[0]++;
 778                                                         if (*p[0] == ',')
 779                                                                 p[0]++;
 780                                                 } else
 781                                                         p[0]++;
 782                                         }
 783 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 784                                         printk(KERN_DEBUG "isdn_tty: Fax FDIS session parms=%d,%d,%d,%d,%d,%d,%d,%d\n",
 785                                                rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7]);
 786 #endif
 787                                 }
 788                                 break;
 789                         default:
 790                                 PARSE_ERROR1;
 791                 }
 792                 return 0;
 793         }
 794         /* DR - Receive Phase C data command, initiates document reception */
 795         if (!strncmp(p[0], "DR", 2)) {
 796                 p[0] += 2;
 797                 if ((info->faxonline & 16) &&   /* incoming connection */
 798                     ((f->phase == ISDN_FAX_PHASE_B) || (f->phase == ISDN_FAX_PHASE_D))) {
 799 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 800                         printk(KERN_DEBUG "isdn_tty: Fax FDR\n");
 801 #endif
 802                         f->code = ISDN_TTY_FAX_DR;
 803                         cmd.driver = info->isdn_driver;
 804                         cmd.arg = info->isdn_channel;
 805                         cmd.command = ISDN_CMD_FAXCMD;
 806                         isdn_command(&cmd);
 807                         if (f->phase == ISDN_FAX_PHASE_B) {
 808                                 f->phase = ISDN_FAX_PHASE_C;
 809                         } else if (f->phase == ISDN_FAX_PHASE_D) {
 810                                 switch (f->fet) {
 811                                         case 0: /* next page will be received */
 812                                                 f->phase = ISDN_FAX_PHASE_C;
 813                                                 isdn_tty_fax_modem_result(7, info);     /* CONNECT */
 814                                                 break;
 815                                         case 1: /* next doc will be received */
 816                                                 f->phase = ISDN_FAX_PHASE_B;
 817                                                 break;
 818                                         case 2: /* fax session is terminating */
 819                                                 f->phase = ISDN_FAX_PHASE_E;
 820                                                 break;
 821                                         default:
 822                                                 PARSE_ERROR1;
 823                                 }
 824                         }
 825                 } else {
 826                         PARSE_ERROR1;
 827                 }
 828                 return 1;
 829         }
 830         /* DT=df,vr,wd,ln - TX phase C data command (release DCE to proceed with negotiation) */
 831         if (!strncmp(p[0], "DT", 2)) {
 832                 int i, val[] =
 833                 {4, 0, 2, 3};
 834                 char *rp = &f->resolution;
 835
 836                 p[0] += 2;
 837                 if (!(info->faxonline & 1))     /* not outgoing connection */
 838                         PARSE_ERROR1;
 839
 840                 for (i = 0; (((*p[0] >= '0') && (*p[0] <= '9')) || (*p[0] == ',')) && (i < 4); i++) {
 841                         if (*p[0] != ',') {
 842                                 if ((*p[0] - 48) > maxdccval[val[i]]) {
 843                                         PARSE_ERROR1;
 844                                 }
 845                                 rp[val[i]] = *p[0] - 48;
 846                                 p[0]++;
 847                                 if (*p[0] == ',')
 848                                         p[0]++;
 849                         } else
 850                                 p[0]++;
 851                 }
 852 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 853                 printk(KERN_DEBUG "isdn_tty: Fax FDT tx data command parms=%d,%d,%d,%d\n",
 854                        rp[4], rp[0], rp[2], rp[3]);
 855 #endif
 856                 if ((f->phase == ISDN_FAX_PHASE_B) || (f->phase == ISDN_FAX_PHASE_D)) {
 857                         f->code = ISDN_TTY_FAX_DT;
 858                         cmd.driver = info->isdn_driver;
 859                         cmd.arg = info->isdn_channel;
 860                         cmd.command = ISDN_CMD_FAXCMD;
 861                         isdn_command(&cmd);
 862                         if (f->phase == ISDN_FAX_PHASE_D) {
 863                                 f->phase = ISDN_FAX_PHASE_C;
 864                                 isdn_tty_fax_modem_result(7, info);     /* CONNECT */
 865                         }
 866                 } else {
 867                         PARSE_ERROR1;
 868                 }
 869                 return 1;
 870         }
 871         /* ECM=n - Error mode control 0=disabled, 2=enabled, handled by DCE alone incl. buff of partial pages */
 872         if (!strncmp(p[0], "ECM", 3)) {
 873                 p[0] += 3;
 874                 switch (*p[0]) {
 875                         case '?':
 876                                 p[0]++;
 877                                 sprintf(rs, "\r\n%d", f->ecm);
 878                                 isdn_tty_at_cout(rs, info);
 879                                 break;
 880                         case '=':
 881                                 p[0]++;
 882                                 if (*p[0] == '?') {
 883                                         p[0]++;
 884                                         sprintf(rs, "\r\n0,2");
 885                                         isdn_tty_at_cout(rs, info);
 886                                 } else {
 887                                         par = isdn_getnum(p);
 888                                         if ((par != 0) && (par != 2))
 889                                                 PARSE_ERROR1;
 890                                         f->ecm = par;
 891 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 892                                         printk(KERN_DEBUG "isdn_tty: Fax FECM=%d\n", par);
 893 #endif
 894                                 }
 895                                 break;
 896                         default:
 897                                 PARSE_ERROR1;
 898                 }
 899                 return 0;
 900         }
 901         /* ET=n - End of page or document */
 902         if (!strncmp(p[0], "ET=", 3)) {
 903                 p[0] += 3;
 904                 if (*p[0] == '?') {
 905                         p[0]++;
 906                         sprintf(rs, "\r\n0-2");
 907                         isdn_tty_at_cout(rs, info);
 908                 } else {
 909                         if ((f->phase != ISDN_FAX_PHASE_D) ||
 910                             (!(info->faxonline & 1)))
 911                                 PARSE_ERROR1;
 912                         par = isdn_getnum(p);
 913                         if ((par < 0) || (par > 2))
 914                                 PARSE_ERROR1;
 915                         f->fet = par;
 916                         f->code = ISDN_TTY_FAX_ET;
 917                         cmd.driver = info->isdn_driver;
 918                         cmd.arg = info->isdn_channel;
 919                         cmd.command = ISDN_CMD_FAXCMD;
 920                         isdn_command(&cmd);
 921 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 922                         printk(KERN_DEBUG "isdn_tty: Fax FET=%d\n", par);
 923 #endif
 924                         return 1;
 925                 }
 926                 return 0;
 927         }
 928         /* K - terminate */
 929         if (!strncmp(p[0], "K", 1)) {
 930                 p[0] += 1;
 931                 if ((f->phase == ISDN_FAX_PHASE_IDLE) || (f->phase == ISDN_FAX_PHASE_E))
 932                         PARSE_ERROR1;
 933                 isdn_tty_modem_hup(info, 1);
 934                 return 1;
 935         }
 936         /* LID=string - local fax ID */
 937         if (!strncmp(p[0], "LID", 3)) {
 938                 int i, r;
 939                 p[0] += 3;
 940                 switch (*p[0]) {
 941                         case '?':
 942                                 p[0]++;
 943                                 sprintf(rs, "\r\n\"%s\"", f->id);
 944                                 isdn_tty_at_cout(rs, info);
 945                                 break;
 946                         case '=':
 947                                 p[0]++;
 948                                 if (*p[0] == '?') {
 949                                         p[0]++;
 950                                         sprintf(rs, "\r\n\"STRING\"");
 951                                         isdn_tty_at_cout(rs, info);
 952                                 } else {
 953                                         if (*p[0] == '"')
 954                                                 p[0]++;
 955                                         for (i = 0; (*p[0]) && i < (FAXIDLEN - 1) && (*p[0] != '"'); i++) {
 956                                                 f->id[i] = *p[0]++;
 957                                         }
 958                                         if (*p[0] == '"')
 959                                                 p[0]++;
 960                                         for (r = i; r < FAXIDLEN; r++) {
 961                                                 f->id[r] = 32;
 962                                         }
 963                                         f->id[FAXIDLEN - 1] = 0;
 964 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 965                                         printk(KERN_DEBUG "isdn_tty: Fax local ID \"%s\"\n", f->id);
 966 #endif
 967                                 }
 968                                 break;
 969                         default:
 970                                 PARSE_ERROR1;
 971                 }
 972                 return 0;
 973         }
 974
 975         /* MDL? - DCE Model       */
 976         if (!strncmp(p[0], "MDL?", 4)) {
 977                 p[0] += 4;
 978 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 979                 printk(KERN_DEBUG "isdn_tty: FMDL?\n");
 980 #endif
 981                 isdn_tty_at_cout("\r\nisdn4linux", info);
 982                 return 0;
 983         }
 984         /* MFR? - DCE Manufacturer */
 985         if (!strncmp(p[0], "MFR?", 4)) {
 986                 p[0] += 4;
 987 #ifdef ISDN_TTY_FAX_STAT_DEBUG
 988                 printk(KERN_DEBUG "isdn_tty: FMFR?\n");
 989 #endif
 990                 isdn_tty_at_cout("\r\nisdn4linux", info);
 991                 return 0;
 992         }
 993         /* MINSP=n - Minimum Speed for Phase C */
 994         if (!strncmp(p[0], "MINSP", 5)) {
 995                 p[0] += 5;
 996                 switch (*p[0]) {
 997                         case '?':
 998                                 p[0]++;
 999                                 sprintf(rs, "\r\n%d", f->minsp);
1000                                 isdn_tty_at_cout(rs, info);
1001                                 break;
1002                         case '=':
1003                                 p[0]++;
1004                                 if (*p[0] == '?') {
1005                                         p[0]++;
1006                                         sprintf(rs, "\r\n0-5");
1007                                         isdn_tty_at_cout(rs, info);
1008                                 } else {
1009                                         par = isdn_getnum(p);
1010                                         if ((par < 0) || (par > 5))
1011                                                 PARSE_ERROR1;
1012                                         f->minsp = par;
1013 #ifdef ISDN_TTY_FAX_STAT_DEBUG
1014                                         printk(KERN_DEBUG "isdn_tty: Fax FMINSP=%d\n", par);
1015 #endif
1016                                 }
1017                                 break;
1018                         default:
1019                                 PARSE_ERROR1;
1020                 }
1021                 return 0;
1022         }
1023         /* PHCTO=value - DTE phase C timeout */
1024         if (!strncmp(p[0], "PHCTO", 5)) {
1025                 p[0] += 5;
1026                 switch (*p[0]) {
1027                         case '?':
1028                                 p[0]++;
1029                                 sprintf(rs, "\r\n%d", f->phcto);
1030                                 isdn_tty_at_cout(rs, info);
1031                                 break;
1032                         case '=':
1033                                 p[0]++;
1034                                 if (*p[0] == '?') {
1035                                         p[0]++;
1036                                         sprintf(rs, "\r\n0-255");
1037                                         isdn_tty_at_cout(rs, info);
1038                                 } else {
1039                                         par = isdn_getnum(p);
1040                                         if ((par < 0) || (par > 255))
1041                                                 PARSE_ERROR1;
1042                                         f->phcto = par;
1043 #ifdef ISDN_TTY_FAX_STAT_DEBUG
1044                                         printk(KERN_DEBUG "isdn_tty: Fax FPHCTO=%d\n", par);
1045 #endif
1046                                 }
1047                                 break;
1048                         default:
1049                                 PARSE_ERROR1;
1050                 }
1051                 return 0;
1052         }
1053
1054         /* REL=n - Phase C received EOL alignment */
1055         if (!strncmp(p[0], "REL", 3)) {
1056                 p[0] += 3;
1057                 switch (*p[0]) {
1058                         case '?':
1059                                 p[0]++;
1060                                 sprintf(rs, "\r\n%d", f->rel);
1061                                 isdn_tty_at_cout(rs, info);
1062                                 break;
1063                         case '=':
1064                                 p[0]++;
1065                                 if (*p[0] == '?') {
1066                                         p[0]++;
1067                                         sprintf(rs, "\r\n0,1");
1068                                         isdn_tty_at_cout(rs, info);
1069                                 } else {
1070                                         par = isdn_getnum(p);
1071                                         if ((par < 0) || (par > 1))
1072                                                 PARSE_ERROR1;
1073                                         f->rel = par;
1074 #ifdef ISDN_TTY_FAX_STAT_DEBUG
1075                                         printk(KERN_DEBUG "isdn_tty: Fax FREL=%d\n", par);
1076 #endif
1077                                 }
1078                                 break;
1079                         default:
1080                                 PARSE_ERROR1;
1081                 }
1082                 return 0;
1083         }
1084         /* REV? - DCE Revision */
1085         if (!strncmp(p[0], "REV?", 4)) {
1086                 p[0] += 4;
1087 #ifdef ISDN_TTY_FAX_STAT_DEBUG
1088                 printk(KERN_DEBUG "isdn_tty: FREV?\n");
1089 #endif
1090                 strcpy(rss, isdn_tty_fax_revision);
1091                 sprintf(rs, "\r\nRev: %s", isdn_getrev(rss));
1092                 isdn_tty_at_cout(rs, info);
1093                 return 0;
1094         }
1095
1096         /* Phase C Transmit Data Block Size */
1097         if (!strncmp(p[0], "TBC=", 4)) {        /* dummy, not used */
1098                 p[0] += 4;
1099 #ifdef ISDN_TTY_FAX_STAT_DEBUG
1100                 printk(KERN_DEBUG "isdn_tty: Fax FTBC=%c\n", *p[0]);
1101 #endif
1102                 switch (*p[0]) {
1103                         case '0':
1104                                 p[0]++;
1105                                 break;
1106                         default:
1107                                 PARSE_ERROR1;
1108                 }
1109                 return 0;
1110         }
1111         printk(KERN_DEBUG "isdn_tty: unknown token=>AT+F%s<\n", p[0]);
1112         PARSE_ERROR1;
1113 }
1114
1115 int
1116 isdn_tty_cmd_PLUSF_FAX(char **p, modem_info * info)
1117 {
1118         if (TTY_IS_FCLASS2(info))
1119                 return (isdn_tty_cmd_FCLASS2(p, info));
1120         else if (TTY_IS_FCLASS1(info))
1121                 return (isdn_tty_cmd_FCLASS1(p, info));
1122         PARSE_ERROR1;
1123 }