78f7660c1d0ea9c66153cfc1a1c1af9515d95580
[linux-2.6.git] / 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 }