1 /* $Id: isdn_tty.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $
3 * Linux ISDN subsystem, tty functions and AT-command emulator (linklevel).
5 * Copyright 1994-1999 by Fritz Elfert (fritz@isdn4linux.de)
6 * Copyright 1995,96 by Thinking Objects Software GmbH Wuerzburg
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
12 #undef ISDN_TTY_STAT_DEBUG
14 #include <linux/config.h>
15 #include <linux/isdn.h>
16 #include <linux/delay.h>
17 #include "isdn_common.h"
19 #ifdef CONFIG_ISDN_AUDIO
20 #include "isdn_audio.h"
22 #define VBUFX (VBUF/16)
25 #define FIX_FILE_TRANSFER
26 #define DUMMY_HAYES_AT
30 static int isdn_tty_edit_at(const char *, int, modem_info
*);
31 static void isdn_tty_check_esc(const u_char
*, u_char
, int, int *, u_long
*);
32 static void isdn_tty_modem_reset_regs(modem_info
*, int);
33 static void isdn_tty_cmd_ATA(modem_info
*);
34 static void isdn_tty_flush_buffer(struct tty_struct
*);
35 static void isdn_tty_modem_result(int, modem_info
*);
36 #ifdef CONFIG_ISDN_AUDIO
37 static int isdn_tty_countDLE(unsigned char *, int);
40 /* Leave this unchanged unless you know what you do! */
41 #define MODEM_PARANOIA_CHECK
42 #define MODEM_DO_RESTART
44 static int bit2si
[8] =
45 {1, 5, 7, 7, 7, 7, 7, 7};
46 static int si2bit
[8] =
47 {4, 1, 4, 4, 4, 4, 4, 4};
49 char *isdn_tty_revision
= "$Revision: 1.1.2.3 $";
52 /* isdn_tty_try_read() is called from within isdn_tty_rcv_skb()
53 * to stuff incoming data directly into a tty's flip-buffer. This
54 * is done to speed up tty-receiving if the receive-queue is empty.
55 * This routine MUST be called with interrupts off.
58 * 0 = Failure, data has to be buffered and later processed by
59 * isdn_tty_readmodem().
62 isdn_tty_try_read(modem_info
* info
, struct sk_buff
*skb
)
66 struct tty_struct
*tty
;
69 if ((tty
= info
->tty
)) {
70 if (info
->mcr
& UART_MCR_RTS
) {
71 c
= TTY_FLIPBUF_SIZE
- tty
->flip
.count
;
73 #ifdef CONFIG_ISDN_AUDIO
74 + ISDN_AUDIO_SKB_DLECOUNT(skb
)
78 #ifdef CONFIG_ISDN_AUDIO
79 if (ISDN_AUDIO_SKB_DLECOUNT(skb
))
81 if (*skb
->data
== DLE
)
82 tty_insert_flip_char(tty
, DLE
, 0);
83 tty_insert_flip_char(tty
, *skb
->data
++, 0);
86 memcpy(tty
->flip
.char_buf_ptr
,
88 tty
->flip
.count
+= len
;
89 tty
->flip
.char_buf_ptr
+= len
;
90 memset(tty
->flip
.flag_buf_ptr
, 0, len
);
91 tty
->flip
.flag_buf_ptr
+= len
;
92 #ifdef CONFIG_ISDN_AUDIO
95 if (info
->emu
.mdmreg
[REG_CPPP
] & BIT_CPPP
)
96 tty
->flip
.flag_buf_ptr
[len
- 1] = 0xff;
97 schedule_delayed_work(&tty
->flip
.work
, 1);
107 /* isdn_tty_readmodem() is called periodically from within timer-interrupt.
108 * It tries getting received data from the receive queue an stuff it into
109 * the tty's flip-buffer.
112 isdn_tty_readmodem(void)
119 struct tty_struct
*tty
;
122 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
123 if ((midx
= dev
->m_idx
[i
]) >= 0) {
124 info
= &dev
->mdm
.info
[midx
];
127 #ifdef CONFIG_ISDN_AUDIO
128 isdn_audio_eval_dtmf(info
);
129 if ((info
->vonline
& 1) && (info
->emu
.vpar
[1]))
130 isdn_audio_eval_silence(info
);
132 if ((tty
= info
->tty
)) {
133 if (info
->mcr
& UART_MCR_RTS
) {
134 c
= TTY_FLIPBUF_SIZE
- tty
->flip
.count
;
136 r
= isdn_readbchan(info
->isdn_driver
, info
->isdn_channel
,
137 tty
->flip
.char_buf_ptr
,
138 tty
->flip
.flag_buf_ptr
, c
, NULL
);
139 /* CISCO AsyncPPP Hack */
140 if (!(info
->emu
.mdmreg
[REG_CPPP
] & BIT_CPPP
))
141 memset(tty
->flip
.flag_buf_ptr
, 0, r
);
142 tty
->flip
.count
+= r
;
143 tty
->flip
.flag_buf_ptr
+= r
;
144 tty
->flip
.char_buf_ptr
+= r
;
146 schedule_delayed_work(&tty
->flip
.work
, 1);
161 isdn_timer_ctrl(ISDN_TIMER_MODEMREAD
, 0);
165 isdn_tty_rcv_skb(int i
, int di
, int channel
, struct sk_buff
*skb
)
169 #ifdef CONFIG_ISDN_AUDIO
174 if ((midx
= dev
->m_idx
[i
]) < 0) {
175 /* if midx is invalid, packet is not for tty */
178 info
= &dev
->mdm
.info
[midx
];
179 #ifdef CONFIG_ISDN_AUDIO
182 if ((info
->vonline
) && (!info
->emu
.vpar
[4]))
183 isdn_audio_calc_dtmf(info
, skb
->data
, skb
->len
, ifmt
);
184 if ((info
->vonline
& 1) && (info
->emu
.vpar
[1]))
185 isdn_audio_calc_silence(info
, skb
->data
, skb
->len
, ifmt
);
187 if ((info
->online
< 2)
188 #ifdef CONFIG_ISDN_AUDIO
189 && (!(info
->vonline
& 1))
192 /* If Modem not listening, drop data */
196 if (info
->emu
.mdmreg
[REG_T70
] & BIT_T70
) {
197 if (info
->emu
.mdmreg
[REG_T70
] & BIT_T70_EXT
) {
198 /* T.70 decoding: throw away the T.70 header (2 or 4 bytes) */
199 if (skb
->data
[0] == 3) /* pure data packet -> 4 byte headers */
202 if (skb
->data
[0] == 1) /* keepalive packet -> 2 byte hdr */
205 /* T.70 decoding: Simply throw away the T.70 header (4 bytes) */
206 if ((skb
->data
[0] == 1) && ((skb
->data
[1] == 0) || (skb
->data
[1] == 1)))
209 #ifdef CONFIG_ISDN_AUDIO
210 ISDN_AUDIO_SKB_DLECOUNT(skb
) = 0;
211 ISDN_AUDIO_SKB_LOCK(skb
) = 0;
212 if (info
->vonline
& 1) {
213 /* voice conversion/compression */
214 switch (info
->emu
.vpar
[3]) {
219 * Since compressed data takes less
220 * space, we can overwrite the buffer.
222 skb_trim(skb
, isdn_audio_xlaw2adpcm(info
->adpcmr
,
231 isdn_audio_ulaw2alaw(skb
->data
, skb
->len
);
236 isdn_audio_alaw2ulaw(skb
->data
, skb
->len
);
239 ISDN_AUDIO_SKB_DLECOUNT(skb
) =
240 isdn_tty_countDLE(skb
->data
, skb
->len
);
242 #ifdef CONFIG_ISDN_TTY_FAX
244 if (info
->faxonline
& 2) {
245 isdn_tty_fax_bitorder(info
, skb
);
246 ISDN_AUDIO_SKB_DLECOUNT(skb
) =
247 isdn_tty_countDLE(skb
->data
, skb
->len
);
252 /* Try to deliver directly via tty-flip-buf if queue is empty */
253 spin_lock_irqsave(&info
->readlock
, flags
);
254 if (skb_queue_empty(&dev
->drv
[di
]->rpqueue
[channel
]))
255 if (isdn_tty_try_read(info
, skb
)) {
256 spin_unlock_irqrestore(&info
->readlock
, flags
);
259 /* Direct deliver failed or queue wasn't empty.
260 * Queue up for later dequeueing via timer-irq.
262 __skb_queue_tail(&dev
->drv
[di
]->rpqueue
[channel
], skb
);
263 dev
->drv
[di
]->rcvcount
[channel
] +=
265 #ifdef CONFIG_ISDN_AUDIO
266 + ISDN_AUDIO_SKB_DLECOUNT(skb
)
269 spin_unlock_irqrestore(&info
->readlock
, flags
);
270 /* Schedule dequeuing */
271 if ((dev
->modempoll
) && (info
->rcvsched
))
272 isdn_timer_ctrl(ISDN_TIMER_MODEMREAD
, 1);
277 isdn_tty_cleanup_xmit(modem_info
* info
)
279 skb_queue_purge(&info
->xmit_queue
);
280 #ifdef CONFIG_ISDN_AUDIO
281 skb_queue_purge(&info
->dtmf_queue
);
286 isdn_tty_tint(modem_info
* info
)
288 struct sk_buff
*skb
= skb_dequeue(&info
->xmit_queue
);
294 if ((slen
= isdn_writebuf_skb_stub(info
->isdn_driver
,
295 info
->isdn_channel
, 1, skb
)) == len
) {
296 struct tty_struct
*tty
= info
->tty
;
297 info
->send_outstanding
++;
298 info
->msr
&= ~UART_MSR_CTS
;
299 info
->lsr
&= ~UART_LSR_TEMT
;
304 /* Error: no channel, already shutdown, or wrong parameter */
308 skb_queue_head(&info
->xmit_queue
, skb
);
311 #ifdef CONFIG_ISDN_AUDIO
313 isdn_tty_countDLE(unsigned char *buf
, int len
)
323 /* This routine is called from within isdn_tty_write() to perform
324 * DLE-decoding when sending audio-data.
327 isdn_tty_handleDLEdown(modem_info
* info
, atemu
* m
, int len
)
329 unsigned char *p
= &info
->xmit_buf
[info
->xmit_count
];
339 memmove(p
, p
+ 1, len
- 1);
350 #ifdef ISDN_DEBUG_MODEM_VOICE
352 "DLEdown: got DLE-DC4, send DLE-ETX on ttyI%d\n",
355 isdn_tty_at_cout("\020\003", info
);
356 if (!info
->vonline
) {
357 #ifdef ISDN_DEBUG_MODEM_VOICE
359 "DLEdown: send VCON on ttyI%d\n",
362 isdn_tty_at_cout("\r\nVCON\r\n", info
);
369 memmove(p
, p
+ 1, len
- 1);
383 printk(KERN_WARNING
"isdn_tty: len<0 in DLEdown\n");
389 /* This routine is called from within isdn_tty_write() when receiving
390 * audio-data. It interrupts receiving, if an character other than
394 isdn_tty_end_vrx(const char *buf
, int c
)
400 if ((ch
!= 0x11) && (ch
!= 0x13))
407 static int voice_cf
[7] =
408 {0, 0, 4, 3, 2, 0, 0};
410 #endif /* CONFIG_ISDN_AUDIO */
412 /* isdn_tty_senddown() is called either directly from within isdn_tty_write()
413 * or via timer-interrupt from within isdn_tty_modem_xmit(). It pulls
414 * outgoing data from the tty's xmit-buffer, handles voice-decompression or
415 * T.70 if necessary, and finally queues it up for sending via isdn_tty_tint.
418 isdn_tty_senddown(modem_info
* info
)
422 #ifdef CONFIG_ISDN_AUDIO
427 #ifdef CONFIG_ISDN_AUDIO
428 if (info
->vonline
& 4) {
430 if (!info
->vonline
) {
431 #ifdef ISDN_DEBUG_MODEM_VOICE
433 "senddown: send VCON on ttyI%d\n",
436 isdn_tty_at_cout("\r\nVCON\r\n", info
);
440 if (!(buflen
= info
->xmit_count
))
442 if ((info
->emu
.mdmreg
[REG_CTS
] & BIT_CTS
) != 0)
443 info
->msr
&= ~UART_MSR_CTS
;
444 info
->lsr
&= ~UART_LSR_TEMT
;
445 /* info->xmit_count is modified here and in isdn_tty_write().
446 * So we return here if isdn_tty_write() is in the
449 atomic_inc(&info
->xmit_lock
);
450 if (!(atomic_dec_and_test(&info
->xmit_lock
)))
452 if (info
->isdn_driver
< 0) {
453 info
->xmit_count
= 0;
456 skb_res
= dev
->drv
[info
->isdn_driver
]->interface
->hl_hdrlen
+ 4;
457 #ifdef CONFIG_ISDN_AUDIO
458 if (info
->vonline
& 2)
459 audio_len
= buflen
* voice_cf
[info
->emu
.vpar
[3]];
462 skb
= dev_alloc_skb(skb_res
+ buflen
+ audio_len
);
464 skb
= dev_alloc_skb(skb_res
+ buflen
);
468 "isdn_tty: Out of memory in ttyI%d senddown\n",
472 skb_reserve(skb
, skb_res
);
473 memcpy(skb_put(skb
, buflen
), info
->xmit_buf
, buflen
);
474 info
->xmit_count
= 0;
475 #ifdef CONFIG_ISDN_AUDIO
476 if (info
->vonline
& 2) {
477 /* For now, ifmt is fixed to 1 (alaw), since this
478 * is used with ISDN everywhere in the world, except
479 * US, Canada and Japan.
480 * Later, when US-ISDN protocols are implemented,
481 * this setting will depend on the D-channel protocol.
485 /* voice conversion/decompression */
486 switch (info
->emu
.vpar
[3]) {
490 /* adpcm, compatible to ZyXel 1496 modem
491 * with ROM revision 6.01
493 audio_len
= isdn_audio_adpcm2xlaw(info
->adpcms
,
496 skb_put(skb
, audio_len
),
498 skb_pull(skb
, buflen
);
499 skb_trim(skb
, audio_len
);
504 isdn_audio_alaw2ulaw(skb
->data
,
510 isdn_audio_ulaw2alaw(skb
->data
,
515 #endif /* CONFIG_ISDN_AUDIO */
516 if (info
->emu
.mdmreg
[REG_T70
] & BIT_T70
) {
517 /* Add T.70 simplified header */
518 if (info
->emu
.mdmreg
[REG_T70
] & BIT_T70_EXT
)
519 memcpy(skb_push(skb
, 2), "\1\0", 2);
521 memcpy(skb_push(skb
, 4), "\1\0\1\0", 4);
523 skb_queue_tail(&info
->xmit_queue
, skb
);
526 /************************************************************
530 * mostly "stolen" from original Linux-serial.c and friends.
532 ************************************************************/
534 /* The next routine is called once from within timer-interrupt
535 * triggered within isdn_tty_modem_ncarrier(). It calls
536 * isdn_tty_modem_result() to stuff a "NO CARRIER" Message
537 * into the tty's flip-buffer.
540 isdn_tty_modem_do_ncarrier(unsigned long data
)
542 modem_info
*info
= (modem_info
*) data
;
543 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
546 /* Next routine is called, whenever the DTR-signal is raised.
547 * It checks the ncarrier-flag, and triggers the above routine
548 * when necessary. The ncarrier-flag is set, whenever DTR goes
552 isdn_tty_modem_ncarrier(modem_info
* info
)
554 if (info
->ncarrier
) {
555 info
->nc_timer
.expires
= jiffies
+ HZ
;
556 add_timer(&info
->nc_timer
);
561 * return the usage calculated by si and layer 2 protocol
564 isdn_calc_usage(int si
, int l2
)
566 int usg
= ISDN_USAGE_MODEM
;
568 #ifdef CONFIG_ISDN_AUDIO
571 case ISDN_PROTO_L2_MODEM
:
572 usg
= ISDN_USAGE_MODEM
;
574 #ifdef CONFIG_ISDN_TTY_FAX
575 case ISDN_PROTO_L2_FAX
:
576 usg
= ISDN_USAGE_FAX
;
579 case ISDN_PROTO_L2_TRANS
:
581 usg
= ISDN_USAGE_VOICE
;
589 /* isdn_tty_dial() performs dialing of a tty an the necessary
590 * setup of the lower levels before that.
593 isdn_tty_dial(char *n
, modem_info
* info
, atemu
* m
)
595 int usg
= ISDN_USAGE_MODEM
;
597 int l2
= m
->mdmreg
[REG_L2PROT
];
603 for (j
= 7; j
>= 0; j
--)
604 if (m
->mdmreg
[REG_SI1
] & (1 << j
)) {
608 usg
= isdn_calc_usage(si
, l2
);
609 #ifdef CONFIG_ISDN_AUDIO
611 (l2
!= ISDN_PROTO_L2_MODEM
)
612 #ifdef CONFIG_ISDN_TTY_FAX
613 && (l2
!= ISDN_PROTO_L2_FAX
)
616 l2
= ISDN_PROTO_L2_TRANS
;
617 usg
= ISDN_USAGE_VOICE
;
620 m
->mdmreg
[REG_SI1I
] = si2bit
[si
];
621 spin_lock_irqsave(&dev
->lock
, flags
);
622 i
= isdn_get_free_channel(usg
, l2
, m
->mdmreg
[REG_L3PROT
], -1, -1, m
->msn
);
624 spin_unlock_irqrestore(&dev
->lock
, flags
);
625 isdn_tty_modem_result(RESULT_NO_DIALTONE
, info
);
627 info
->isdn_driver
= dev
->drvmap
[i
];
628 info
->isdn_channel
= dev
->chanmap
[i
];
630 dev
->m_idx
[i
] = info
->line
;
631 dev
->usage
[i
] |= ISDN_USAGE_OUTGOING
;
633 strcpy(info
->last_num
, n
);
635 spin_unlock_irqrestore(&dev
->lock
, flags
);
636 cmd
.driver
= info
->isdn_driver
;
637 cmd
.arg
= info
->isdn_channel
;
638 cmd
.command
= ISDN_CMD_CLREAZ
;
640 strcpy(cmd
.parm
.num
, isdn_map_eaz2msn(m
->msn
, info
->isdn_driver
));
641 cmd
.driver
= info
->isdn_driver
;
642 cmd
.command
= ISDN_CMD_SETEAZ
;
644 cmd
.driver
= info
->isdn_driver
;
645 cmd
.command
= ISDN_CMD_SETL2
;
647 cmd
.arg
= info
->isdn_channel
+ (l2
<< 8);
649 cmd
.driver
= info
->isdn_driver
;
650 cmd
.command
= ISDN_CMD_SETL3
;
651 cmd
.arg
= info
->isdn_channel
+ (m
->mdmreg
[REG_L3PROT
] << 8);
652 #ifdef CONFIG_ISDN_TTY_FAX
653 if (l2
== ISDN_PROTO_L2_FAX
) {
654 cmd
.parm
.fax
= info
->fax
;
655 info
->fax
->direction
= ISDN_TTY_FAX_CONN_OUT
;
659 cmd
.driver
= info
->isdn_driver
;
660 cmd
.arg
= info
->isdn_channel
;
661 sprintf(cmd
.parm
.setup
.phone
, "%s", n
);
662 sprintf(cmd
.parm
.setup
.eazmsn
, "%s",
663 isdn_map_eaz2msn(m
->msn
, info
->isdn_driver
));
664 cmd
.parm
.setup
.si1
= si
;
665 cmd
.parm
.setup
.si2
= m
->mdmreg
[REG_SI2
];
666 cmd
.command
= ISDN_CMD_DIAL
;
668 info
->emu
.carrierwait
= 0;
669 strcpy(dev
->num
[i
], n
);
672 isdn_timer_ctrl(ISDN_TIMER_CARRIER
, 1);
676 /* isdn_tty_hangup() disassociates a tty from the real
677 * ISDN-line (hangup). The usage-status is cleared
678 * and some cleanup is done also.
681 isdn_tty_modem_hup(modem_info
* info
, int local
)
689 di
= info
->isdn_driver
;
690 ch
= info
->isdn_channel
;
691 if (di
< 0 || ch
< 0)
694 info
->isdn_driver
= -1;
695 info
->isdn_channel
= -1;
697 #ifdef ISDN_DEBUG_MODEM_HUP
698 printk(KERN_DEBUG
"Mhup ttyI%d\n", info
->line
);
701 isdn_tty_flush_buffer(info
->tty
);
703 info
->last_lhup
= local
;
705 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
707 #ifdef CONFIG_ISDN_AUDIO
709 #ifdef CONFIG_ISDN_TTY_FAX
711 info
->fax
->phase
= ISDN_FAX_PHASE_IDLE
;
713 info
->emu
.vpar
[4] = 0;
714 info
->emu
.vpar
[5] = 8;
715 kfree(info
->dtmf_state
);
716 info
->dtmf_state
= NULL
;
717 kfree(info
->silence_state
);
718 info
->silence_state
= NULL
;
724 if ((info
->msr
& UART_MSR_RI
) &&
725 (info
->emu
.mdmreg
[REG_RUNG
] & BIT_RUNG
))
726 isdn_tty_modem_result(RESULT_RUNG
, info
);
727 info
->msr
&= ~(UART_MSR_DCD
| UART_MSR_RI
);
728 info
->lsr
|= UART_LSR_TEMT
;
732 cmd
.command
= ISDN_CMD_HANGUP
;
737 isdn_all_eaz(di
, ch
);
738 info
->emu
.mdmreg
[REG_RINGCNT
] = 0;
739 isdn_free_channel(di
, ch
, 0);
741 if (info
->drv_index
>= 0) {
742 dev
->m_idx
[info
->drv_index
] = -1;
743 info
->drv_index
= -1;
748 * Begin of a CAPI like interface, currently used only for
749 * supplementary service (CAPI 2.0 part III)
751 #include <linux/isdn/capicmd.h>
754 isdn_tty_capi_facility(capi_msg
*cm
) {
755 return(-1); /* dummy */
758 /* isdn_tty_suspend() tries to suspend the current tty connection
761 isdn_tty_suspend(char *id
, modem_info
* info
, atemu
* m
)
770 #ifdef ISDN_DEBUG_MODEM_SERVICES
771 printk(KERN_DEBUG
"Msusp ttyI%d\n", info
->line
);
774 if ((info
->isdn_driver
>= 0)) {
775 cmd
.parm
.cmsg
.Length
= l
+18;
776 cmd
.parm
.cmsg
.Command
= CAPI_FACILITY
;
777 cmd
.parm
.cmsg
.Subcommand
= CAPI_REQ
;
778 cmd
.parm
.cmsg
.adr
.Controller
= info
->isdn_driver
+ 1;
779 cmd
.parm
.cmsg
.para
[0] = 3; /* 16 bit 0x0003 suplementary service */
780 cmd
.parm
.cmsg
.para
[1] = 0;
781 cmd
.parm
.cmsg
.para
[2] = l
+ 3;
782 cmd
.parm
.cmsg
.para
[3] = 4; /* 16 bit 0x0004 Suspend */
783 cmd
.parm
.cmsg
.para
[4] = 0;
784 cmd
.parm
.cmsg
.para
[5] = l
;
785 strncpy(&cmd
.parm
.cmsg
.para
[6], id
, l
);
786 cmd
.command
= CAPI_PUT_MESSAGE
;
787 cmd
.driver
= info
->isdn_driver
;
788 cmd
.arg
= info
->isdn_channel
;
793 /* isdn_tty_resume() tries to resume a suspended call
794 * setup of the lower levels before that. unfortunatly here is no
795 * checking for compatibility of used protocols implemented by Q931
796 * It does the same things like isdn_tty_dial, the last command
797 * is different, may be we can merge it.
801 isdn_tty_resume(char *id
, modem_info
* info
, atemu
* m
)
803 int usg
= ISDN_USAGE_MODEM
;
805 int l2
= m
->mdmreg
[REG_L2PROT
];
813 for (j
= 7; j
>= 0; j
--)
814 if (m
->mdmreg
[REG_SI1
] & (1 << j
)) {
818 usg
= isdn_calc_usage(si
, l2
);
819 #ifdef CONFIG_ISDN_AUDIO
821 (l2
!= ISDN_PROTO_L2_MODEM
)
822 #ifdef CONFIG_ISDN_TTY_FAX
823 && (l2
!= ISDN_PROTO_L2_FAX
)
826 l2
= ISDN_PROTO_L2_TRANS
;
827 usg
= ISDN_USAGE_VOICE
;
830 m
->mdmreg
[REG_SI1I
] = si2bit
[si
];
831 spin_lock_irqsave(&dev
->lock
, flags
);
832 i
= isdn_get_free_channel(usg
, l2
, m
->mdmreg
[REG_L3PROT
], -1, -1, m
->msn
);
834 spin_unlock_irqrestore(&dev
->lock
, flags
);
835 isdn_tty_modem_result(RESULT_NO_DIALTONE
, info
);
837 info
->isdn_driver
= dev
->drvmap
[i
];
838 info
->isdn_channel
= dev
->chanmap
[i
];
840 dev
->m_idx
[i
] = info
->line
;
841 dev
->usage
[i
] |= ISDN_USAGE_OUTGOING
;
843 // strcpy(info->last_num, n);
845 spin_unlock_irqrestore(&dev
->lock
, flags
);
846 cmd
.driver
= info
->isdn_driver
;
847 cmd
.arg
= info
->isdn_channel
;
848 cmd
.command
= ISDN_CMD_CLREAZ
;
850 strcpy(cmd
.parm
.num
, isdn_map_eaz2msn(m
->msn
, info
->isdn_driver
));
851 cmd
.driver
= info
->isdn_driver
;
852 cmd
.command
= ISDN_CMD_SETEAZ
;
854 cmd
.driver
= info
->isdn_driver
;
855 cmd
.command
= ISDN_CMD_SETL2
;
857 cmd
.arg
= info
->isdn_channel
+ (l2
<< 8);
859 cmd
.driver
= info
->isdn_driver
;
860 cmd
.command
= ISDN_CMD_SETL3
;
861 cmd
.arg
= info
->isdn_channel
+ (m
->mdmreg
[REG_L3PROT
] << 8);
863 cmd
.driver
= info
->isdn_driver
;
864 cmd
.arg
= info
->isdn_channel
;
865 cmd
.parm
.cmsg
.Length
= l
+18;
866 cmd
.parm
.cmsg
.Command
= CAPI_FACILITY
;
867 cmd
.parm
.cmsg
.Subcommand
= CAPI_REQ
;
868 cmd
.parm
.cmsg
.adr
.Controller
= info
->isdn_driver
+ 1;
869 cmd
.parm
.cmsg
.para
[0] = 3; /* 16 bit 0x0003 suplementary service */
870 cmd
.parm
.cmsg
.para
[1] = 0;
871 cmd
.parm
.cmsg
.para
[2] = l
+3;
872 cmd
.parm
.cmsg
.para
[3] = 5; /* 16 bit 0x0005 Resume */
873 cmd
.parm
.cmsg
.para
[4] = 0;
874 cmd
.parm
.cmsg
.para
[5] = l
;
875 strncpy(&cmd
.parm
.cmsg
.para
[6], id
, l
);
876 cmd
.command
=CAPI_PUT_MESSAGE
;
878 // strcpy(dev->num[i], n);
881 isdn_timer_ctrl(ISDN_TIMER_CARRIER
, 1);
885 /* isdn_tty_send_msg() sends a message to a HL driver
886 * This is used for hybrid modem cards to send AT commands to it
890 isdn_tty_send_msg(modem_info
* info
, atemu
* m
, char *msg
)
892 int usg
= ISDN_USAGE_MODEM
;
894 int l2
= m
->mdmreg
[REG_L2PROT
];
903 isdn_tty_modem_result(RESULT_ERROR
, info
);
906 for (j
= 7; j
>= 0; j
--)
907 if (m
->mdmreg
[REG_SI1
] & (1 << j
)) {
911 usg
= isdn_calc_usage(si
, l2
);
912 #ifdef CONFIG_ISDN_AUDIO
914 (l2
!= ISDN_PROTO_L2_MODEM
)
915 #ifdef CONFIG_ISDN_TTY_FAX
916 && (l2
!= ISDN_PROTO_L2_FAX
)
919 l2
= ISDN_PROTO_L2_TRANS
;
920 usg
= ISDN_USAGE_VOICE
;
923 m
->mdmreg
[REG_SI1I
] = si2bit
[si
];
924 spin_lock_irqsave(&dev
->lock
, flags
);
925 i
= isdn_get_free_channel(usg
, l2
, m
->mdmreg
[REG_L3PROT
], -1, -1, m
->msn
);
927 spin_unlock_irqrestore(&dev
->lock
, flags
);
928 isdn_tty_modem_result(RESULT_NO_DIALTONE
, info
);
930 info
->isdn_driver
= dev
->drvmap
[i
];
931 info
->isdn_channel
= dev
->chanmap
[i
];
933 dev
->m_idx
[i
] = info
->line
;
934 dev
->usage
[i
] |= ISDN_USAGE_OUTGOING
;
937 spin_unlock_irqrestore(&dev
->lock
, flags
);
938 cmd
.driver
= info
->isdn_driver
;
939 cmd
.arg
= info
->isdn_channel
;
940 cmd
.command
= ISDN_CMD_CLREAZ
;
942 strcpy(cmd
.parm
.num
, isdn_map_eaz2msn(m
->msn
, info
->isdn_driver
));
943 cmd
.driver
= info
->isdn_driver
;
944 cmd
.command
= ISDN_CMD_SETEAZ
;
946 cmd
.driver
= info
->isdn_driver
;
947 cmd
.command
= ISDN_CMD_SETL2
;
949 cmd
.arg
= info
->isdn_channel
+ (l2
<< 8);
951 cmd
.driver
= info
->isdn_driver
;
952 cmd
.command
= ISDN_CMD_SETL3
;
953 cmd
.arg
= info
->isdn_channel
+ (m
->mdmreg
[REG_L3PROT
] << 8);
955 cmd
.driver
= info
->isdn_driver
;
956 cmd
.arg
= info
->isdn_channel
;
957 cmd
.parm
.cmsg
.Length
= l
+14;
958 cmd
.parm
.cmsg
.Command
= CAPI_MANUFACTURER
;
959 cmd
.parm
.cmsg
.Subcommand
= CAPI_REQ
;
960 cmd
.parm
.cmsg
.adr
.Controller
= info
->isdn_driver
+ 1;
961 cmd
.parm
.cmsg
.para
[0] = l
+1;
962 strncpy(&cmd
.parm
.cmsg
.para
[1], msg
, l
);
963 cmd
.parm
.cmsg
.para
[l
+1] = 0xd;
964 cmd
.command
=CAPI_PUT_MESSAGE
;
965 /* info->dialing = 1;
966 strcpy(dev->num[i], n);
974 isdn_tty_paranoia_check(modem_info
*info
, char *name
, const char *routine
)
976 #ifdef MODEM_PARANOIA_CHECK
978 printk(KERN_WARNING
"isdn_tty: null info_struct for %s in %s\n",
982 if (info
->magic
!= ISDN_ASYNC_MAGIC
) {
983 printk(KERN_WARNING
"isdn_tty: bad magic for modem struct %s in %s\n",
992 * This routine is called to set the UART divisor registers to match
993 * the specified baud rate for a serial port.
996 isdn_tty_change_speed(modem_info
* info
)
1004 if (!info
->tty
|| !info
->tty
->termios
)
1006 cflag
= info
->tty
->termios
->c_cflag
;
1008 quot
= i
= cflag
& CBAUD
;
1012 info
->tty
->termios
->c_cflag
&= ~CBAUDEX
;
1017 info
->mcr
|= UART_MCR_DTR
;
1018 isdn_tty_modem_ncarrier(info
);
1020 info
->mcr
&= ~UART_MCR_DTR
;
1021 if (info
->emu
.mdmreg
[REG_DTRHUP
] & BIT_DTRHUP
) {
1022 #ifdef ISDN_DEBUG_MODEM_HUP
1023 printk(KERN_DEBUG
"Mhup in changespeed\n");
1027 isdn_tty_modem_reset_regs(info
, 0);
1028 isdn_tty_modem_hup(info
, 1);
1032 /* byte size and parity */
1033 cval
= cflag
& (CSIZE
| CSTOPB
);
1036 cval
|= UART_LCR_PARITY
;
1037 if (!(cflag
& PARODD
))
1038 cval
|= UART_LCR_EPAR
;
1041 /* CTS flow control flag and modem status interrupts */
1042 if (cflag
& CRTSCTS
) {
1043 info
->flags
|= ISDN_ASYNC_CTS_FLOW
;
1045 info
->flags
&= ~ISDN_ASYNC_CTS_FLOW
;
1047 info
->flags
&= ~ISDN_ASYNC_CHECK_CD
;
1049 info
->flags
|= ISDN_ASYNC_CHECK_CD
;
1054 isdn_tty_startup(modem_info
* info
)
1056 if (info
->flags
& ISDN_ASYNC_INITIALIZED
)
1058 isdn_lock_drivers();
1059 #ifdef ISDN_DEBUG_MODEM_OPEN
1060 printk(KERN_DEBUG
"starting up ttyi%d ...\n", info
->line
);
1063 * Now, initialize the UART
1065 info
->mcr
= UART_MCR_DTR
| UART_MCR_RTS
| UART_MCR_OUT2
;
1067 clear_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
1069 * and set the speed of the serial port
1071 isdn_tty_change_speed(info
);
1073 info
->flags
|= ISDN_ASYNC_INITIALIZED
;
1074 info
->msr
|= (UART_MSR_DSR
| UART_MSR_CTS
);
1075 info
->send_outstanding
= 0;
1080 * This routine will shutdown a serial port; interrupts are disabled, and
1081 * DTR is dropped if the hangup on close termio flag is on.
1084 isdn_tty_shutdown(modem_info
* info
)
1086 if (!(info
->flags
& ISDN_ASYNC_INITIALIZED
))
1088 #ifdef ISDN_DEBUG_MODEM_OPEN
1089 printk(KERN_DEBUG
"Shutting down isdnmodem port %d ....\n", info
->line
);
1091 isdn_unlock_drivers();
1092 info
->msr
&= ~UART_MSR_RI
;
1093 if (!info
->tty
|| (info
->tty
->termios
->c_cflag
& HUPCL
)) {
1094 info
->mcr
&= ~(UART_MCR_DTR
| UART_MCR_RTS
);
1095 if (info
->emu
.mdmreg
[REG_DTRHUP
] & BIT_DTRHUP
) {
1096 isdn_tty_modem_reset_regs(info
, 0);
1097 #ifdef ISDN_DEBUG_MODEM_HUP
1098 printk(KERN_DEBUG
"Mhup in isdn_tty_shutdown\n");
1100 isdn_tty_modem_hup(info
, 1);
1104 set_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
1106 info
->flags
&= ~ISDN_ASYNC_INITIALIZED
;
1109 /* isdn_tty_write() is the main send-routine. It is called from the upper
1110 * levels within the kernel to perform sending data. Depending on the
1111 * online-flag it either directs output to the at-command-interpreter or
1112 * to the lower level. Additional tasks done here:
1113 * - If online, check for escape-sequence (+++)
1114 * - If sending audio-data, call isdn_tty_DLEdown() to parse DLE-codes.
1115 * - If receiving audio-data, call isdn_tty_end_vrx() to abort if needed.
1116 * - If dialing, abort dial.
1119 isdn_tty_write(struct tty_struct
*tty
, const u_char
* buf
, int count
)
1123 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1124 atemu
*m
= &info
->emu
;
1126 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_write"))
1128 /* See isdn_tty_senddown() */
1129 atomic_inc(&info
->xmit_lock
);
1132 if (c
> info
->xmit_size
- info
->xmit_count
)
1133 c
= info
->xmit_size
- info
->xmit_count
;
1134 if (info
->isdn_driver
>= 0 && c
> dev
->drv
[info
->isdn_driver
]->maxbufsize
)
1135 c
= dev
->drv
[info
->isdn_driver
]->maxbufsize
;
1138 if ((info
->online
> 1)
1139 #ifdef CONFIG_ISDN_AUDIO
1140 || (info
->vonline
& 3)
1143 #ifdef CONFIG_ISDN_AUDIO
1146 isdn_tty_check_esc(buf
, m
->mdmreg
[REG_ESC
], c
,
1149 memcpy(&(info
->xmit_buf
[info
->xmit_count
]), buf
, c
);
1150 #ifdef CONFIG_ISDN_AUDIO
1151 if (info
->vonline
) {
1152 int cc
= isdn_tty_handleDLEdown(info
, m
, c
);
1153 if (info
->vonline
& 2) {
1155 /* If DLE decoding results in zero-transmit, but
1156 * c originally was non-zero, do a wakeup.
1159 info
->msr
|= UART_MSR_CTS
;
1160 info
->lsr
|= UART_LSR_TEMT
;
1162 info
->xmit_count
+= cc
;
1164 if ((info
->vonline
& 3) == 1) {
1165 /* Do NOT handle Ctrl-Q or Ctrl-S
1166 * when in full-duplex audio mode.
1168 if (isdn_tty_end_vrx(buf
, c
)) {
1169 info
->vonline
&= ~1;
1170 #ifdef ISDN_DEBUG_MODEM_VOICE
1172 "got !^Q/^S, send DLE-ETX,VCON on ttyI%d\n",
1175 isdn_tty_at_cout("\020\003\r\nVCON\r\n", info
);
1179 if (TTY_IS_FCLASS1(info
)) {
1180 int cc
= isdn_tty_handleDLEdown(info
, m
, c
);
1182 if (info
->vonline
& 4) { /* ETX seen */
1185 c
.command
= ISDN_CMD_FAXCMD
;
1186 c
.driver
= info
->isdn_driver
;
1187 c
.arg
= info
->isdn_channel
;
1188 c
.parm
.aux
.cmd
= ISDN_FAX_CLASS1_CTRL
;
1189 c
.parm
.aux
.subcmd
= ETX
;
1193 #ifdef ISDN_DEBUG_MODEM_VOICE
1194 printk(KERN_DEBUG
"fax dle cc/c %d/%d\n", cc
, c
);
1196 info
->xmit_count
+= cc
;
1199 info
->xmit_count
+= c
;
1201 info
->msr
|= UART_MSR_CTS
;
1202 info
->lsr
|= UART_LSR_TEMT
;
1203 if (info
->dialing
) {
1205 #ifdef ISDN_DEBUG_MODEM_HUP
1206 printk(KERN_DEBUG
"Mhup in isdn_tty_write\n");
1208 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
1209 isdn_tty_modem_hup(info
, 1);
1211 c
= isdn_tty_edit_at(buf
, c
, info
);
1217 atomic_dec(&info
->xmit_lock
);
1218 if ((info
->xmit_count
) || !skb_queue_empty(&info
->xmit_queue
)) {
1219 if (m
->mdmreg
[REG_DXMT
] & BIT_DXMT
) {
1220 isdn_tty_senddown(info
);
1221 isdn_tty_tint(info
);
1223 isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT
, 1);
1229 isdn_tty_write_room(struct tty_struct
*tty
)
1231 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1234 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_write_room"))
1237 return info
->xmit_size
;
1238 ret
= info
->xmit_size
- info
->xmit_count
;
1239 return (ret
< 0) ? 0 : ret
;
1243 isdn_tty_chars_in_buffer(struct tty_struct
*tty
)
1245 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1247 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_chars_in_buffer"))
1251 return (info
->xmit_count
);
1255 isdn_tty_flush_buffer(struct tty_struct
*tty
)
1262 info
= (modem_info
*) tty
->driver_data
;
1263 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_flush_buffer")) {
1266 isdn_tty_cleanup_xmit(info
);
1267 info
->xmit_count
= 0;
1268 wake_up_interruptible(&tty
->write_wait
);
1273 isdn_tty_flush_chars(struct tty_struct
*tty
)
1275 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1277 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_flush_chars"))
1279 if ((info
->xmit_count
) || !skb_queue_empty(&info
->xmit_queue
))
1280 isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT
, 1);
1284 * ------------------------------------------------------------
1285 * isdn_tty_throttle()
1287 * This routine is called by the upper-layer tty layer to signal that
1288 * incoming characters should be throttled.
1289 * ------------------------------------------------------------
1292 isdn_tty_throttle(struct tty_struct
*tty
)
1294 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1296 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_throttle"))
1299 info
->x_char
= STOP_CHAR(tty
);
1300 info
->mcr
&= ~UART_MCR_RTS
;
1304 isdn_tty_unthrottle(struct tty_struct
*tty
)
1306 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1308 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_unthrottle"))
1314 info
->x_char
= START_CHAR(tty
);
1316 info
->mcr
|= UART_MCR_RTS
;
1320 * ------------------------------------------------------------
1321 * isdn_tty_ioctl() and friends
1322 * ------------------------------------------------------------
1326 * isdn_tty_get_lsr_info - get line status register info
1328 * Purpose: Let user call ioctl() to get info when the UART physically
1329 * is emptied. On bus types like RS485, the transmitter must
1330 * release the bus after transmitting. This must be done when
1331 * the transmit shift register is empty, not be done when the
1332 * transmit holding register is empty. This functionality
1333 * allows RS485 driver to be written in user space.
1336 isdn_tty_get_lsr_info(modem_info
* info
, uint __user
* value
)
1342 result
= ((status
& UART_LSR_TEMT
) ? TIOCSER_TEMT
: 0);
1343 return put_user(result
, value
);
1348 isdn_tty_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1350 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1351 u_char control
, status
;
1353 if (isdn_tty_paranoia_check(info
, tty
->name
, __FUNCTION__
))
1355 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1358 #ifdef ISDN_DEBUG_MODEM_IOCTL
1359 printk(KERN_DEBUG
"ttyI%d ioctl TIOCMGET\n", info
->line
);
1362 control
= info
->mcr
;
1364 return ((control
& UART_MCR_RTS
) ? TIOCM_RTS
: 0)
1365 | ((control
& UART_MCR_DTR
) ? TIOCM_DTR
: 0)
1366 | ((status
& UART_MSR_DCD
) ? TIOCM_CAR
: 0)
1367 | ((status
& UART_MSR_RI
) ? TIOCM_RNG
: 0)
1368 | ((status
& UART_MSR_DSR
) ? TIOCM_DSR
: 0)
1369 | ((status
& UART_MSR_CTS
) ? TIOCM_CTS
: 0);
1373 isdn_tty_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1374 unsigned int set
, unsigned int clear
)
1376 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1378 if (isdn_tty_paranoia_check(info
, tty
->name
, __FUNCTION__
))
1380 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1383 #ifdef ISDN_DEBUG_MODEM_IOCTL
1384 printk(KERN_DEBUG
"ttyI%d ioctl TIOCMxxx: %x %x\n", info
->line
, set
, clear
);
1387 if (set
& TIOCM_RTS
)
1388 info
->mcr
|= UART_MCR_RTS
;
1389 if (set
& TIOCM_DTR
) {
1390 info
->mcr
|= UART_MCR_DTR
;
1391 isdn_tty_modem_ncarrier(info
);
1394 if (clear
& TIOCM_RTS
)
1395 info
->mcr
&= ~UART_MCR_RTS
;
1396 if (clear
& TIOCM_DTR
) {
1397 info
->mcr
&= ~UART_MCR_DTR
;
1398 if (info
->emu
.mdmreg
[REG_DTRHUP
] & BIT_DTRHUP
) {
1399 isdn_tty_modem_reset_regs(info
, 0);
1400 #ifdef ISDN_DEBUG_MODEM_HUP
1401 printk(KERN_DEBUG
"Mhup in TIOCMSET\n");
1405 isdn_tty_modem_hup(info
, 1);
1412 isdn_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
1413 uint cmd
, ulong arg
)
1415 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1418 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_ioctl"))
1420 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1423 case TCSBRK
: /* SVID version: non-zero arg --> no break */
1424 #ifdef ISDN_DEBUG_MODEM_IOCTL
1425 printk(KERN_DEBUG
"ttyI%d ioctl TCSBRK\n", info
->line
);
1427 retval
= tty_check_change(tty
);
1430 tty_wait_until_sent(tty
, 0);
1432 case TCSBRKP
: /* support for POSIX tcsendbreak() */
1433 #ifdef ISDN_DEBUG_MODEM_IOCTL
1434 printk(KERN_DEBUG
"ttyI%d ioctl TCSBRKP\n", info
->line
);
1436 retval
= tty_check_change(tty
);
1439 tty_wait_until_sent(tty
, 0);
1442 #ifdef ISDN_DEBUG_MODEM_IOCTL
1443 printk(KERN_DEBUG
"ttyI%d ioctl TIOCGSOFTCAR\n", info
->line
);
1445 return put_user(C_CLOCAL(tty
) ? 1 : 0, (ulong __user
*) arg
);
1447 #ifdef ISDN_DEBUG_MODEM_IOCTL
1448 printk(KERN_DEBUG
"ttyI%d ioctl TIOCSSOFTCAR\n", info
->line
);
1450 if (get_user(arg
, (ulong __user
*) arg
))
1452 tty
->termios
->c_cflag
=
1453 ((tty
->termios
->c_cflag
& ~CLOCAL
) |
1454 (arg
? CLOCAL
: 0));
1456 case TIOCSERGETLSR
: /* Get line status register */
1457 #ifdef ISDN_DEBUG_MODEM_IOCTL
1458 printk(KERN_DEBUG
"ttyI%d ioctl TIOCSERGETLSR\n", info
->line
);
1460 return isdn_tty_get_lsr_info(info
, (uint __user
*) arg
);
1462 #ifdef ISDN_DEBUG_MODEM_IOCTL
1463 printk(KERN_DEBUG
"UNKNOWN ioctl 0x%08x on ttyi%d\n", cmd
, info
->line
);
1465 return -ENOIOCTLCMD
;
1471 isdn_tty_set_termios(struct tty_struct
*tty
, struct termios
*old_termios
)
1473 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1476 isdn_tty_change_speed(info
);
1478 if (tty
->termios
->c_cflag
== old_termios
->c_cflag
)
1480 isdn_tty_change_speed(info
);
1481 if ((old_termios
->c_cflag
& CRTSCTS
) &&
1482 !(tty
->termios
->c_cflag
& CRTSCTS
)) {
1483 tty
->hw_stopped
= 0;
1489 * ------------------------------------------------------------
1490 * isdn_tty_open() and friends
1491 * ------------------------------------------------------------
1494 isdn_tty_block_til_ready(struct tty_struct
*tty
, struct file
*filp
, modem_info
* info
)
1496 DECLARE_WAITQUEUE(wait
, NULL
);
1501 * If the device is in the middle of being closed, then block
1502 * until it's done, and then try again.
1504 if (tty_hung_up_p(filp
) ||
1505 (info
->flags
& ISDN_ASYNC_CLOSING
)) {
1506 if (info
->flags
& ISDN_ASYNC_CLOSING
)
1507 interruptible_sleep_on(&info
->close_wait
);
1508 #ifdef MODEM_DO_RESTART
1509 if (info
->flags
& ISDN_ASYNC_HUP_NOTIFY
)
1512 return -ERESTARTSYS
;
1518 * If non-blocking mode is set, then make the check up front
1521 if ((filp
->f_flags
& O_NONBLOCK
) ||
1522 (tty
->flags
& (1 << TTY_IO_ERROR
))) {
1523 if (info
->flags
& ISDN_ASYNC_CALLOUT_ACTIVE
)
1525 info
->flags
|= ISDN_ASYNC_NORMAL_ACTIVE
;
1528 if (info
->flags
& ISDN_ASYNC_CALLOUT_ACTIVE
) {
1529 if (info
->normal_termios
.c_cflag
& CLOCAL
)
1532 if (tty
->termios
->c_cflag
& CLOCAL
)
1536 * Block waiting for the carrier detect and the line to become
1537 * free (i.e., not in use by the callout). While we are in
1538 * this loop, info->count is dropped by one, so that
1539 * isdn_tty_close() knows when to free things. We restore it upon
1540 * exit, either normal or abnormal.
1543 add_wait_queue(&info
->open_wait
, &wait
);
1544 #ifdef ISDN_DEBUG_MODEM_OPEN
1545 printk(KERN_DEBUG
"isdn_tty_block_til_ready before block: ttyi%d, count = %d\n",
1546 info
->line
, info
->count
);
1548 if (!(tty_hung_up_p(filp
)))
1550 info
->blocked_open
++;
1552 set_current_state(TASK_INTERRUPTIBLE
);
1553 if (tty_hung_up_p(filp
) ||
1554 !(info
->flags
& ISDN_ASYNC_INITIALIZED
)) {
1555 #ifdef MODEM_DO_RESTART
1556 if (info
->flags
& ISDN_ASYNC_HUP_NOTIFY
)
1559 retval
= -ERESTARTSYS
;
1565 if (!(info
->flags
& ISDN_ASYNC_CALLOUT_ACTIVE
) &&
1566 !(info
->flags
& ISDN_ASYNC_CLOSING
) &&
1567 (do_clocal
|| (info
->msr
& UART_MSR_DCD
))) {
1570 if (signal_pending(current
)) {
1571 retval
= -ERESTARTSYS
;
1574 #ifdef ISDN_DEBUG_MODEM_OPEN
1575 printk(KERN_DEBUG
"isdn_tty_block_til_ready blocking: ttyi%d, count = %d\n",
1576 info
->line
, info
->count
);
1580 current
->state
= TASK_RUNNING
;
1581 remove_wait_queue(&info
->open_wait
, &wait
);
1582 if (!tty_hung_up_p(filp
))
1584 info
->blocked_open
--;
1585 #ifdef ISDN_DEBUG_MODEM_OPEN
1586 printk(KERN_DEBUG
"isdn_tty_block_til_ready after blocking: ttyi%d, count = %d\n",
1587 info
->line
, info
->count
);
1591 info
->flags
|= ISDN_ASYNC_NORMAL_ACTIVE
;
1596 * This routine is called whenever a serial port is opened. It
1597 * enables interrupts for a serial port, linking in its async structure into
1598 * the IRQ chain. It also performs the serial-specific
1599 * initialization for the tty structure.
1602 isdn_tty_open(struct tty_struct
*tty
, struct file
*filp
)
1608 if (line
< 0 || line
> ISDN_MAX_CHANNELS
)
1610 info
= &dev
->mdm
.info
[line
];
1611 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_open"))
1613 if (!try_module_get(info
->owner
)) {
1614 printk(KERN_WARNING
"%s: cannot reserve module\n", __FUNCTION__
);
1617 #ifdef ISDN_DEBUG_MODEM_OPEN
1618 printk(KERN_DEBUG
"isdn_tty_open %s, count = %d\n", tty
->name
,
1622 tty
->driver_data
= info
;
1625 * Start up serial port
1627 retval
= isdn_tty_startup(info
);
1629 #ifdef ISDN_DEBUG_MODEM_OPEN
1630 printk(KERN_DEBUG
"isdn_tty_open return after startup\n");
1632 module_put(info
->owner
);
1635 retval
= isdn_tty_block_til_ready(tty
, filp
, info
);
1637 #ifdef ISDN_DEBUG_MODEM_OPEN
1638 printk(KERN_DEBUG
"isdn_tty_open return after isdn_tty_block_til_ready \n");
1640 module_put(info
->owner
);
1643 #ifdef ISDN_DEBUG_MODEM_OPEN
1644 printk(KERN_DEBUG
"isdn_tty_open ttyi%d successful...\n", info
->line
);
1647 #ifdef ISDN_DEBUG_MODEM_OPEN
1648 printk(KERN_DEBUG
"isdn_tty_open normal exit\n");
1654 isdn_tty_close(struct tty_struct
*tty
, struct file
*filp
)
1656 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1659 if (!info
|| isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_close"))
1661 if (tty_hung_up_p(filp
)) {
1662 #ifdef ISDN_DEBUG_MODEM_OPEN
1663 printk(KERN_DEBUG
"isdn_tty_close return after tty_hung_up_p\n");
1667 if ((tty
->count
== 1) && (info
->count
!= 1)) {
1669 * Uh, oh. tty->count is 1, which means that the tty
1670 * structure will be freed. Info->count should always
1671 * be one in these conditions. If it's greater than
1672 * one, we've got real problems, since it means the
1673 * serial port won't be shutdown.
1675 printk(KERN_ERR
"isdn_tty_close: bad port count; tty->count is 1, "
1676 "info->count is %d\n", info
->count
);
1679 if (--info
->count
< 0) {
1680 printk(KERN_ERR
"isdn_tty_close: bad port count for ttyi%d: %d\n",
1681 info
->line
, info
->count
);
1685 #ifdef ISDN_DEBUG_MODEM_OPEN
1686 printk(KERN_DEBUG
"isdn_tty_close after info->count != 0\n");
1690 info
->flags
|= ISDN_ASYNC_CLOSING
;
1692 * Save the termios structure, since this port may have
1693 * separate termios for callout and dialin.
1695 if (info
->flags
& ISDN_ASYNC_NORMAL_ACTIVE
)
1696 info
->normal_termios
= *tty
->termios
;
1697 if (info
->flags
& ISDN_ASYNC_CALLOUT_ACTIVE
)
1698 info
->callout_termios
= *tty
->termios
;
1702 * At this point we stop accepting input. To do this, we
1703 * disable the receive line status interrupts, and tell the
1704 * interrupt driver to stop checking the data ready bit in the
1705 * line status register.
1707 if (info
->flags
& ISDN_ASYNC_INITIALIZED
) {
1708 tty_wait_until_sent(tty
, 3000); /* 30 seconds timeout */
1710 * Before we drop DTR, make sure the UART transmitter
1711 * has completely drained; this is especially
1712 * important if there is a transmit FIFO!
1714 timeout
= jiffies
+ HZ
;
1715 while (!(info
->lsr
& UART_LSR_TEMT
)) {
1716 schedule_timeout_interruptible(20);
1717 if (time_after(jiffies
,timeout
))
1722 isdn_tty_shutdown(info
);
1724 if (tty
->driver
->flush_buffer
)
1725 tty
->driver
->flush_buffer(tty
);
1726 tty_ldisc_flush(tty
);
1730 module_put(info
->owner
);
1731 if (info
->blocked_open
) {
1732 msleep_interruptible(500);
1733 wake_up_interruptible(&info
->open_wait
);
1735 info
->flags
&= ~(ISDN_ASYNC_NORMAL_ACTIVE
| ISDN_ASYNC_CLOSING
);
1736 wake_up_interruptible(&info
->close_wait
);
1737 #ifdef ISDN_DEBUG_MODEM_OPEN
1738 printk(KERN_DEBUG
"isdn_tty_close normal exit\n");
1743 * isdn_tty_hangup() --- called by tty_hangup() when a hangup is signaled.
1746 isdn_tty_hangup(struct tty_struct
*tty
)
1748 modem_info
*info
= (modem_info
*) tty
->driver_data
;
1750 if (isdn_tty_paranoia_check(info
, tty
->name
, "isdn_tty_hangup"))
1752 isdn_tty_shutdown(info
);
1754 info
->flags
&= ~(ISDN_ASYNC_NORMAL_ACTIVE
| ISDN_ASYNC_CALLOUT_ACTIVE
);
1756 wake_up_interruptible(&info
->open_wait
);
1759 /* This routine initializes all emulator-data.
1762 isdn_tty_reset_profile(atemu
* m
)
1775 m
->profile
[11] = 70;
1776 m
->profile
[12] = 0x45;
1778 m
->profile
[14] = ISDN_PROTO_L2_X75I
;
1779 m
->profile
[15] = ISDN_PROTO_L3_TRANS
;
1780 m
->profile
[16] = ISDN_SERIAL_XMIT_SIZE
/ 16;
1781 m
->profile
[17] = ISDN_MODEM_WINSIZE
;
1790 #ifdef CONFIG_ISDN_AUDIO
1792 isdn_tty_modem_reset_vpar(atemu
* m
)
1794 m
->vpar
[0] = 2; /* Voice-device (2 = phone line) */
1795 m
->vpar
[1] = 0; /* Silence detection level (0 = none ) */
1796 m
->vpar
[2] = 70; /* Silence interval (7 sec. ) */
1797 m
->vpar
[3] = 2; /* Compression type (1 = ADPCM-2 ) */
1798 m
->vpar
[4] = 0; /* DTMF detection level (0 = softcode ) */
1799 m
->vpar
[5] = 8; /* DTMF interval (8 * 5 ms. ) */
1803 #ifdef CONFIG_ISDN_TTY_FAX
1805 isdn_tty_modem_reset_faxpar(modem_info
* info
)
1807 T30_s
*f
= info
->fax
;
1810 f
->phase
= ISDN_FAX_PHASE_IDLE
;
1812 f
->resolution
= 1; /* fine */
1813 f
->rate
= 5; /* 14400 bit/s */
1820 memset(&f
->id
[0], 32, FAXIDLEN
- 1);
1821 f
->id
[FAXIDLEN
- 1] = 0;
1832 memset(&f
->pollid
[0], 32, FAXIDLEN
- 1);
1833 f
->pollid
[FAXIDLEN
- 1] = 0;
1838 isdn_tty_modem_reset_regs(modem_info
* info
, int force
)
1840 atemu
*m
= &info
->emu
;
1841 if ((m
->mdmreg
[REG_DTRR
] & BIT_DTRR
) || force
) {
1842 memcpy(m
->mdmreg
, m
->profile
, ISDN_MODEM_NUMREG
);
1843 memcpy(m
->msn
, m
->pmsn
, ISDN_MSNLEN
);
1844 memcpy(m
->lmsn
, m
->plmsn
, ISDN_LMSNLEN
);
1845 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16;
1847 #ifdef CONFIG_ISDN_AUDIO
1848 isdn_tty_modem_reset_vpar(m
);
1850 #ifdef CONFIG_ISDN_TTY_FAX
1851 isdn_tty_modem_reset_faxpar(info
);
1857 modem_write_profile(atemu
* m
)
1859 memcpy(m
->profile
, m
->mdmreg
, ISDN_MODEM_NUMREG
);
1860 memcpy(m
->pmsn
, m
->msn
, ISDN_MSNLEN
);
1861 memcpy(m
->plmsn
, m
->lmsn
, ISDN_LMSNLEN
);
1863 send_sig(SIGIO
, dev
->profd
, 1);
1866 static struct tty_operations modem_ops
= {
1867 .open
= isdn_tty_open
,
1868 .close
= isdn_tty_close
,
1869 .write
= isdn_tty_write
,
1870 .flush_chars
= isdn_tty_flush_chars
,
1871 .write_room
= isdn_tty_write_room
,
1872 .chars_in_buffer
= isdn_tty_chars_in_buffer
,
1873 .flush_buffer
= isdn_tty_flush_buffer
,
1874 .ioctl
= isdn_tty_ioctl
,
1875 .throttle
= isdn_tty_throttle
,
1876 .unthrottle
= isdn_tty_unthrottle
,
1877 .set_termios
= isdn_tty_set_termios
,
1878 .hangup
= isdn_tty_hangup
,
1879 .tiocmget
= isdn_tty_tiocmget
,
1880 .tiocmset
= isdn_tty_tiocmset
,
1884 isdn_tty_modem_init(void)
1891 m
->tty_modem
= alloc_tty_driver(ISDN_MAX_CHANNELS
);
1894 m
->tty_modem
->name
= "ttyI";
1895 m
->tty_modem
->devfs_name
= "isdn/ttyI";
1896 m
->tty_modem
->major
= ISDN_TTY_MAJOR
;
1897 m
->tty_modem
->minor_start
= 0;
1898 m
->tty_modem
->type
= TTY_DRIVER_TYPE_SERIAL
;
1899 m
->tty_modem
->subtype
= SERIAL_TYPE_NORMAL
;
1900 m
->tty_modem
->init_termios
= tty_std_termios
;
1901 m
->tty_modem
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1902 m
->tty_modem
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_NO_DEVFS
;
1903 m
->tty_modem
->driver_name
= "isdn_tty";
1904 tty_set_operations(m
->tty_modem
, &modem_ops
);
1905 retval
= tty_register_driver(m
->tty_modem
);
1907 printk(KERN_WARNING
"isdn_tty: Couldn't register modem-device\n");
1910 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
1912 #ifdef CONFIG_ISDN_TTY_FAX
1913 if (!(info
->fax
= kmalloc(sizeof(T30_s
), GFP_KERNEL
))) {
1914 printk(KERN_ERR
"Could not allocate fax t30-buffer\n");
1916 goto err_unregister
;
1920 info
->owner
= THIS_MODULE
;
1922 spin_lock_init(&info
->readlock
);
1923 init_MUTEX(&info
->write_sem
);
1924 sprintf(info
->last_cause
, "0000");
1925 sprintf(info
->last_num
, "none");
1927 info
->last_lhup
= 1;
1930 isdn_tty_reset_profile(&info
->emu
);
1931 isdn_tty_modem_reset_regs(info
, 1);
1932 info
->magic
= ISDN_ASYNC_MAGIC
;
1937 info
->blocked_open
= 0;
1938 init_waitqueue_head(&info
->open_wait
);
1939 init_waitqueue_head(&info
->close_wait
);
1940 info
->isdn_driver
= -1;
1941 info
->isdn_channel
= -1;
1942 info
->drv_index
= -1;
1943 info
->xmit_size
= ISDN_SERIAL_XMIT_SIZE
;
1944 init_timer(&info
->nc_timer
);
1945 info
->nc_timer
.function
= isdn_tty_modem_do_ncarrier
;
1946 info
->nc_timer
.data
= (unsigned long) info
;
1947 skb_queue_head_init(&info
->xmit_queue
);
1948 #ifdef CONFIG_ISDN_AUDIO
1949 skb_queue_head_init(&info
->dtmf_queue
);
1951 if (!(info
->xmit_buf
= kmalloc(ISDN_SERIAL_XMIT_MAX
+ 5, GFP_KERNEL
))) {
1952 printk(KERN_ERR
"Could not allocate modem xmit-buffer\n");
1954 goto err_unregister
;
1956 /* Make room for T.70 header */
1957 info
->xmit_buf
+= 4;
1961 for (i
--; i
>= 0; i
--) {
1963 #ifdef CONFIG_ISDN_TTY_FAX
1966 kfree(info
->xmit_buf
- 4);
1968 tty_unregister_driver(m
->tty_modem
);
1970 put_tty_driver(m
->tty_modem
);
1971 m
->tty_modem
= NULL
;
1981 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
1982 info
= &dev
->mdm
.info
[i
];
1983 isdn_tty_cleanup_xmit(info
);
1984 #ifdef CONFIG_ISDN_TTY_FAX
1987 kfree(info
->xmit_buf
- 4);
1989 tty_unregister_driver(dev
->mdm
.tty_modem
);
1990 put_tty_driver(dev
->mdm
.tty_modem
);
1991 dev
->mdm
.tty_modem
= NULL
;
1996 * isdn_tty_match_icall(char *MSN, atemu *tty_emulator, int dev_idx)
1997 * match the MSN against the MSNs (glob patterns) defined for tty_emulator,
1998 * and return 0 for match, 1 for no match, 2 if MSN could match if longer.
2002 isdn_tty_match_icall(char *cid
, atemu
*emu
, int di
)
2004 #ifdef ISDN_DEBUG_MODEM_ICALL
2005 printk(KERN_DEBUG
"m_fi: msn=%s lmsn=%s mmsn=%s mreg[SI1]=%d mreg[SI2]=%d\n",
2006 emu
->msn
, emu
->lmsn
, isdn_map_eaz2msn(emu
->msn
, di
),
2007 emu
->mdmreg
[REG_SI1
], emu
->mdmreg
[REG_SI2
]);
2009 if (strlen(emu
->lmsn
)) {
2010 char *p
= emu
->lmsn
;
2016 if ((q
= strchr(p
, ';')))
2018 if ((tmp
= isdn_msncmp(cid
, isdn_map_eaz2msn(p
, di
))) > ret
)
2020 #ifdef ISDN_DEBUG_MODEM_ICALL
2021 printk(KERN_DEBUG
"m_fi: lmsnX=%s mmsn=%s -> tmp=%d\n",
2022 p
, isdn_map_eaz2msn(emu
->msn
, di
), tmp
);
2037 tmp
= isdn_msncmp(cid
, isdn_map_eaz2msn(emu
->msn
, di
));
2038 #ifdef ISDN_DEBUG_MODEM_ICALL
2039 printk(KERN_DEBUG
"m_fi: mmsn=%s -> tmp=%d\n",
2040 isdn_map_eaz2msn(emu
->msn
, di
), tmp
);
2047 * An incoming call-request has arrived.
2048 * Search the tty-devices for an appropriate device and bind
2049 * it to the ISDN-Channel.
2052 * 0 = No matching device found.
2053 * 1 = A matching device found.
2054 * 3 = No match found, but eventually would match, if
2058 isdn_tty_find_icall(int di
, int ch
, setup_parm
*setup
)
2069 if (!setup
->phone
[0]) {
2071 printk(KERN_INFO
"isdn_tty: Incoming call without OAD, assuming '0'\n");
2074 si1
= (int) setup
->si1
;
2075 si2
= (int) setup
->si2
;
2076 if (!setup
->eazmsn
[0]) {
2077 printk(KERN_WARNING
"isdn_tty: Incoming call without CPN, assuming '0'\n");
2080 eaz
= setup
->eazmsn
;
2081 #ifdef ISDN_DEBUG_MODEM_ICALL
2082 printk(KERN_DEBUG
"m_fi: eaz=%s si1=%d si2=%d\n", eaz
, si1
, si2
);
2085 spin_lock_irqsave(&dev
->lock
, flags
);
2086 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
2087 modem_info
*info
= &dev
->mdm
.info
[i
];
2089 if (info
->count
== 0)
2091 if ((info
->emu
.mdmreg
[REG_SI1
] & si2bit
[si1
]) && /* SI1 is matching */
2092 (info
->emu
.mdmreg
[REG_SI2
] == si2
)) { /* SI2 is matching */
2093 idx
= isdn_dc2minor(di
, ch
);
2094 #ifdef ISDN_DEBUG_MODEM_ICALL
2095 printk(KERN_DEBUG
"m_fi: match1 wret=%d\n", wret
);
2096 printk(KERN_DEBUG
"m_fi: idx=%d flags=%08lx drv=%d ch=%d usg=%d\n", idx
,
2097 info
->flags
, info
->isdn_driver
, info
->isdn_channel
,
2101 #ifndef FIX_FILE_TRANSFER
2102 (info
->flags
& ISDN_ASYNC_NORMAL_ACTIVE
) &&
2104 (info
->isdn_driver
== -1) &&
2105 (info
->isdn_channel
== -1) &&
2106 (USG_NONE(dev
->usage
[idx
]))) {
2109 if ((matchret
= isdn_tty_match_icall(eaz
, &info
->emu
, di
)) > wret
)
2111 if (!matchret
) { /* EAZ is matching */
2112 info
->isdn_driver
= di
;
2113 info
->isdn_channel
= ch
;
2114 info
->drv_index
= idx
;
2115 dev
->m_idx
[idx
] = info
->line
;
2116 dev
->usage
[idx
] &= ISDN_USAGE_EXCLUSIVE
;
2117 dev
->usage
[idx
] |= isdn_calc_usage(si1
, info
->emu
.mdmreg
[REG_L2PROT
]);
2118 strcpy(dev
->num
[idx
], nr
);
2119 strcpy(info
->emu
.cpn
, eaz
);
2120 info
->emu
.mdmreg
[REG_SI1I
] = si2bit
[si1
];
2121 info
->emu
.mdmreg
[REG_PLAN
] = setup
->plan
;
2122 info
->emu
.mdmreg
[REG_SCREEN
] = setup
->screen
;
2124 spin_unlock_irqrestore(&dev
->lock
, flags
);
2125 printk(KERN_INFO
"isdn_tty: call from %s, -> RING on ttyI%d\n", nr
,
2127 info
->msr
|= UART_MSR_RI
;
2128 isdn_tty_modem_result(RESULT_RING
, info
);
2129 isdn_timer_ctrl(ISDN_TIMER_MODEMRING
, 1);
2135 spin_unlock_irqrestore(&dev
->lock
, flags
);
2136 printk(KERN_INFO
"isdn_tty: call from %s -> %s %s\n", nr
, eaz
,
2137 ((dev
->drv
[di
]->flags
& DRV_FLAG_REJBUS
) && (wret
!= 2))? "rejected" : "ignored");
2138 return (wret
== 2)?3:0;
2141 #define TTY_IS_ACTIVE(info) \
2142 (info->flags & (ISDN_ASYNC_NORMAL_ACTIVE | ISDN_ASYNC_CALLOUT_ACTIVE))
2145 isdn_tty_stat_callback(int i
, isdn_ctrl
*c
)
2153 if ((mi
= dev
->m_idx
[i
]) >= 0) {
2154 info
= &dev
->mdm
.info
[mi
];
2155 switch (c
->command
) {
2156 case ISDN_STAT_CINF
:
2157 printk(KERN_DEBUG
"CHARGEINFO on ttyI%d: %ld %s\n", info
->line
, c
->arg
, c
->parm
.num
);
2158 info
->emu
.charge
= (unsigned) simple_strtoul(c
->parm
.num
, &e
, 10);
2159 if (e
== (char *)c
->parm
.num
)
2160 info
->emu
.charge
= 0;
2163 case ISDN_STAT_BSENT
:
2164 #ifdef ISDN_TTY_STAT_DEBUG
2165 printk(KERN_DEBUG
"tty_STAT_BSENT ttyI%d\n", info
->line
);
2167 if ((info
->isdn_driver
== c
->driver
) &&
2168 (info
->isdn_channel
== c
->arg
)) {
2169 info
->msr
|= UART_MSR_CTS
;
2170 if (info
->send_outstanding
)
2171 if (!(--info
->send_outstanding
))
2172 info
->lsr
|= UART_LSR_TEMT
;
2173 isdn_tty_tint(info
);
2177 case ISDN_STAT_CAUSE
:
2178 #ifdef ISDN_TTY_STAT_DEBUG
2179 printk(KERN_DEBUG
"tty_STAT_CAUSE ttyI%d\n", info
->line
);
2181 /* Signal cause to tty-device */
2182 strncpy(info
->last_cause
, c
->parm
.num
, 5);
2184 case ISDN_STAT_DISPLAY
:
2185 #ifdef ISDN_TTY_STAT_DEBUG
2186 printk(KERN_DEBUG
"tty_STAT_DISPLAY ttyI%d\n", info
->line
);
2188 /* Signal display to tty-device */
2189 if ((info
->emu
.mdmreg
[REG_DISPLAY
] & BIT_DISPLAY
) &&
2190 !(info
->emu
.mdmreg
[REG_RESPNUM
] & BIT_RESPNUM
)) {
2191 isdn_tty_at_cout("\r\n", info
);
2192 isdn_tty_at_cout("DISPLAY: ", info
);
2193 isdn_tty_at_cout(c
->parm
.display
, info
);
2194 isdn_tty_at_cout("\r\n", info
);
2197 case ISDN_STAT_DCONN
:
2198 #ifdef ISDN_TTY_STAT_DEBUG
2199 printk(KERN_DEBUG
"tty_STAT_DCONN ttyI%d\n", info
->line
);
2201 if (TTY_IS_ACTIVE(info
)) {
2202 if (info
->dialing
== 1) {
2208 case ISDN_STAT_DHUP
:
2209 #ifdef ISDN_TTY_STAT_DEBUG
2210 printk(KERN_DEBUG
"tty_STAT_DHUP ttyI%d\n", info
->line
);
2212 if (TTY_IS_ACTIVE(info
)) {
2213 if (info
->dialing
== 1)
2214 isdn_tty_modem_result(RESULT_BUSY
, info
);
2215 if (info
->dialing
> 1)
2216 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
2218 #ifdef ISDN_DEBUG_MODEM_HUP
2219 printk(KERN_DEBUG
"Mhup in ISDN_STAT_DHUP\n");
2221 isdn_tty_modem_hup(info
, 0);
2225 case ISDN_STAT_BCONN
:
2226 #ifdef ISDN_TTY_STAT_DEBUG
2227 printk(KERN_DEBUG
"tty_STAT_BCONN ttyI%d\n", info
->line
);
2229 /* Wake up any processes waiting
2230 * for incoming call of this device when
2231 * DCD follow the state of incoming carrier
2233 if (info
->blocked_open
&&
2234 (info
->emu
.mdmreg
[REG_DCD
] & BIT_DCD
)) {
2235 wake_up_interruptible(&info
->open_wait
);
2238 /* Schedule CONNECT-Message to any tty
2239 * waiting for it and
2240 * set DCD-bit of its modem-status.
2242 if (TTY_IS_ACTIVE(info
) ||
2243 (info
->blocked_open
&& (info
->emu
.mdmreg
[REG_DCD
] & BIT_DCD
))) {
2244 info
->msr
|= UART_MSR_DCD
;
2245 info
->emu
.charge
= 0;
2246 if (info
->dialing
& 0xf)
2252 if (USG_MODEM(dev
->usage
[i
])) {
2253 if (info
->emu
.mdmreg
[REG_L2PROT
] == ISDN_PROTO_L2_MODEM
) {
2254 strcpy(info
->emu
.connmsg
, c
->parm
.num
);
2255 isdn_tty_modem_result(RESULT_CONNECT
, info
);
2257 isdn_tty_modem_result(RESULT_CONNECT64000
, info
);
2259 if (USG_VOICE(dev
->usage
[i
]))
2260 isdn_tty_modem_result(RESULT_VCON
, info
);
2264 case ISDN_STAT_BHUP
:
2265 #ifdef ISDN_TTY_STAT_DEBUG
2266 printk(KERN_DEBUG
"tty_STAT_BHUP ttyI%d\n", info
->line
);
2268 if (TTY_IS_ACTIVE(info
)) {
2269 #ifdef ISDN_DEBUG_MODEM_HUP
2270 printk(KERN_DEBUG
"Mhup in ISDN_STAT_BHUP\n");
2272 isdn_tty_modem_hup(info
, 0);
2276 case ISDN_STAT_NODCH
:
2277 #ifdef ISDN_TTY_STAT_DEBUG
2278 printk(KERN_DEBUG
"tty_STAT_NODCH ttyI%d\n", info
->line
);
2280 if (TTY_IS_ACTIVE(info
)) {
2281 if (info
->dialing
) {
2285 sprintf(info
->last_cause
, "0000");
2286 isdn_tty_modem_result(RESULT_NO_DIALTONE
, info
);
2288 isdn_tty_modem_hup(info
, 0);
2292 case ISDN_STAT_UNLOAD
:
2293 #ifdef ISDN_TTY_STAT_DEBUG
2294 printk(KERN_DEBUG
"tty_STAT_UNLOAD ttyI%d\n", info
->line
);
2296 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
2297 info
= &dev
->mdm
.info
[i
];
2298 if (info
->isdn_driver
== c
->driver
) {
2300 isdn_tty_modem_hup(info
, 1);
2304 #ifdef CONFIG_ISDN_TTY_FAX
2305 case ISDN_STAT_FAXIND
:
2306 if (TTY_IS_ACTIVE(info
)) {
2307 isdn_tty_fax_command(info
, c
);
2311 #ifdef CONFIG_ISDN_AUDIO
2312 case ISDN_STAT_AUDIO
:
2313 if (TTY_IS_ACTIVE(info
)) {
2314 switch(c
->parm
.num
[0]) {
2315 case ISDN_AUDIO_DTMF
:
2316 if (info
->vonline
) {
2317 isdn_audio_put_dle_code(info
,
2330 /*********************************************************************
2331 Modem-Emulator-Routines
2332 *********************************************************************/
2334 #define cmdchar(c) ((c>=' ')&&(c<=0x7f))
2337 * Put a message from the AT-emulator into receive-buffer of tty,
2338 * convert CR, LF, and BS to values in modem-registers 3, 4 and 5.
2341 isdn_tty_at_cout(char *msg
, modem_info
* info
)
2343 struct tty_struct
*tty
;
2344 atemu
*m
= &info
->emu
;
2348 struct sk_buff
*skb
= NULL
;
2352 printk(KERN_WARNING
"isdn_tty: Null-Message in isdn_tty_at_cout\n");
2355 spin_lock_irqsave(&info
->readlock
, flags
);
2357 if ((info
->flags
& ISDN_ASYNC_CLOSING
) || (!tty
)) {
2358 spin_unlock_irqrestore(&info
->readlock
, flags
);
2362 /* use queue instead of direct flip, if online and */
2363 /* data is in queue or flip buffer is full */
2364 if ((info
->online
) && (((tty
->flip
.count
+ strlen(msg
)) >= TTY_FLIPBUF_SIZE
) ||
2365 (!skb_queue_empty(&dev
->drv
[info
->isdn_driver
]->rpqueue
[info
->isdn_channel
])))) {
2366 skb
= alloc_skb(strlen(msg
), GFP_ATOMIC
);
2368 spin_unlock_irqrestore(&info
->readlock
, flags
);
2371 sp
= skb_put(skb
, strlen(msg
));
2372 #ifdef CONFIG_ISDN_AUDIO
2373 ISDN_AUDIO_SKB_DLECOUNT(skb
) = 0;
2374 ISDN_AUDIO_SKB_LOCK(skb
) = 0;
2378 for (p
= msg
; *p
; p
++) {
2381 c
= m
->mdmreg
[REG_CR
];
2384 c
= m
->mdmreg
[REG_LF
];
2387 c
= m
->mdmreg
[REG_BS
];
2395 if (tty
->flip
.count
>= TTY_FLIPBUF_SIZE
)
2397 tty_insert_flip_char(tty
, c
, 0);
2401 __skb_queue_tail(&dev
->drv
[info
->isdn_driver
]->rpqueue
[info
->isdn_channel
], skb
);
2402 dev
->drv
[info
->isdn_driver
]->rcvcount
[info
->isdn_channel
] += skb
->len
;
2403 spin_unlock_irqrestore(&info
->readlock
, flags
);
2404 /* Schedule dequeuing */
2405 if ((dev
->modempoll
) && (info
->rcvsched
))
2406 isdn_timer_ctrl(ISDN_TIMER_MODEMREAD
, 1);
2409 spin_unlock_irqrestore(&info
->readlock
, flags
);
2410 schedule_delayed_work(&tty
->flip
.work
, 1);
2415 * Perform ATH Hangup
2418 isdn_tty_on_hook(modem_info
* info
)
2420 if (info
->isdn_channel
>= 0) {
2421 #ifdef ISDN_DEBUG_MODEM_HUP
2422 printk(KERN_DEBUG
"Mhup in isdn_tty_on_hook\n");
2424 isdn_tty_modem_hup(info
, 1);
2429 isdn_tty_off_hook(void)
2431 printk(KERN_DEBUG
"isdn_tty_off_hook\n");
2434 #define PLUSWAIT1 (HZ/2) /* 0.5 sec. */
2435 #define PLUSWAIT2 (HZ*3/2) /* 1.5 sec */
2438 * Check Buffer for Modem-escape-sequence, activate timer-callback to
2439 * isdn_tty_modem_escape() if sequence found.
2442 * p pointer to databuffer
2443 * plus escape-character
2444 * count length of buffer
2445 * pluscount count of valid escape-characters so far
2446 * lastplus timestamp of last character
2449 isdn_tty_check_esc(const u_char
* p
, u_char plus
, int count
, int *pluscount
,
2460 if (*(p
++) == plus
) {
2461 if ((*pluscount
)++) {
2462 /* Time since last '+' > 0.5 sec. ? */
2463 if (time_after(jiffies
, *lastplus
+ PLUSWAIT1
))
2466 /* Time since last non-'+' < 1.5 sec. ? */
2467 if (time_before(jiffies
, *lastplus
+ PLUSWAIT2
))
2470 if ((*pluscount
== 3) && (count
== 1))
2471 isdn_timer_ctrl(ISDN_TIMER_MODEMPLUS
, 1);
2476 *lastplus
= jiffies
;
2482 * Return result of AT-emulator to tty-receive-buffer, depending on
2483 * modem-register 12, bit 0 and 1.
2484 * For CONNECT-messages also switch to online-mode.
2485 * For RING-message handle auto-ATA if register 0 != 0
2489 isdn_tty_modem_result(int code
, modem_info
* info
)
2491 atemu
*m
= &info
->emu
;
2492 static char *msg
[] =
2493 {"OK", "CONNECT", "RING", "NO CARRIER", "ERROR",
2494 "CONNECT 64000", "NO DIALTONE", "BUSY", "NO ANSWER",
2495 "RINGING", "NO MSN/EAZ", "VCON", "RUNG"};
2496 char s
[ISDN_MSNLEN
+10];
2500 m
->mdmreg
[REG_RINGCNT
]++;
2501 if (m
->mdmreg
[REG_RINGCNT
] == m
->mdmreg
[REG_RINGATA
])
2502 /* Automatically accept incoming call */
2503 isdn_tty_cmd_ATA(info
);
2505 case RESULT_NO_CARRIER
:
2506 #ifdef ISDN_DEBUG_MODEM_HUP
2507 printk(KERN_DEBUG
"modem_result: NO CARRIER %d %d\n",
2508 (info
->flags
& ISDN_ASYNC_CLOSING
),
2511 m
->mdmreg
[REG_RINGCNT
] = 0;
2512 del_timer(&info
->nc_timer
);
2514 if ((info
->flags
& ISDN_ASYNC_CLOSING
) || (!info
->tty
)) {
2517 #ifdef CONFIG_ISDN_AUDIO
2518 if (info
->vonline
& 1) {
2519 #ifdef ISDN_DEBUG_MODEM_VOICE
2520 printk(KERN_DEBUG
"res3: send DLE-ETX on ttyI%d\n",
2523 /* voice-recording, add DLE-ETX */
2524 isdn_tty_at_cout("\020\003", info
);
2526 if (info
->vonline
& 2) {
2527 #ifdef ISDN_DEBUG_MODEM_VOICE
2528 printk(KERN_DEBUG
"res3: send DLE-DC4 on ttyI%d\n",
2531 /* voice-playing, add DLE-DC4 */
2532 isdn_tty_at_cout("\020\024", info
);
2536 case RESULT_CONNECT
:
2537 case RESULT_CONNECT64000
:
2538 sprintf(info
->last_cause
, "0000");
2543 #ifdef ISDN_DEBUG_MODEM_VOICE
2544 printk(KERN_DEBUG
"res3: send VCON on ttyI%d\n",
2547 sprintf(info
->last_cause
, "0000");
2551 } /* switch(code) */
2553 if (m
->mdmreg
[REG_RESP
] & BIT_RESP
) {
2555 if (m
->mdmreg
[REG_RESPNUM
] & BIT_RESPNUM
) {
2556 /* Show numeric results only */
2557 sprintf(s
, "\r\n%d\r\n", code
);
2558 isdn_tty_at_cout(s
, info
);
2560 if (code
== RESULT_RING
) {
2561 /* return if "show RUNG" and ringcounter>1 */
2562 if ((m
->mdmreg
[REG_RUNG
] & BIT_RUNG
) &&
2563 (m
->mdmreg
[REG_RINGCNT
] > 1))
2565 /* print CID, _before_ _every_ ring */
2566 if (!(m
->mdmreg
[REG_CIDONCE
] & BIT_CIDONCE
)) {
2567 isdn_tty_at_cout("\r\nCALLER NUMBER: ", info
);
2568 isdn_tty_at_cout(dev
->num
[info
->drv_index
], info
);
2569 if (m
->mdmreg
[REG_CDN
] & BIT_CDN
) {
2570 isdn_tty_at_cout("\r\nCALLED NUMBER: ", info
);
2571 isdn_tty_at_cout(info
->emu
.cpn
, info
);
2575 isdn_tty_at_cout("\r\n", info
);
2576 isdn_tty_at_cout(msg
[code
], info
);
2578 case RESULT_CONNECT
:
2579 switch (m
->mdmreg
[REG_L2PROT
]) {
2580 case ISDN_PROTO_L2_MODEM
:
2581 isdn_tty_at_cout(" ", info
);
2582 isdn_tty_at_cout(m
->connmsg
, info
);
2587 /* Append CPN, if enabled */
2588 if ((m
->mdmreg
[REG_CPN
] & BIT_CPN
)) {
2589 sprintf(s
, "/%s", m
->cpn
);
2590 isdn_tty_at_cout(s
, info
);
2592 /* Print CID only once, _after_ 1st RING */
2593 if ((m
->mdmreg
[REG_CIDONCE
] & BIT_CIDONCE
) &&
2594 (m
->mdmreg
[REG_RINGCNT
] == 1)) {
2595 isdn_tty_at_cout("\r\n", info
);
2596 isdn_tty_at_cout("CALLER NUMBER: ", info
);
2597 isdn_tty_at_cout(dev
->num
[info
->drv_index
], info
);
2598 if (m
->mdmreg
[REG_CDN
] & BIT_CDN
) {
2599 isdn_tty_at_cout("\r\nCALLED NUMBER: ", info
);
2600 isdn_tty_at_cout(info
->emu
.cpn
, info
);
2604 case RESULT_NO_CARRIER
:
2605 case RESULT_NO_DIALTONE
:
2607 case RESULT_NO_ANSWER
:
2608 m
->mdmreg
[REG_RINGCNT
] = 0;
2609 /* Append Cause-Message if enabled */
2610 if (m
->mdmreg
[REG_RESPXT
] & BIT_RESPXT
) {
2611 sprintf(s
, "/%s", info
->last_cause
);
2612 isdn_tty_at_cout(s
, info
);
2615 case RESULT_CONNECT64000
:
2616 /* Append Protocol to CONNECT message */
2617 switch (m
->mdmreg
[REG_L2PROT
]) {
2618 case ISDN_PROTO_L2_X75I
:
2619 case ISDN_PROTO_L2_X75UI
:
2620 case ISDN_PROTO_L2_X75BUI
:
2621 isdn_tty_at_cout("/X.75", info
);
2623 case ISDN_PROTO_L2_HDLC
:
2624 isdn_tty_at_cout("/HDLC", info
);
2626 case ISDN_PROTO_L2_V11096
:
2627 isdn_tty_at_cout("/V110/9600", info
);
2629 case ISDN_PROTO_L2_V11019
:
2630 isdn_tty_at_cout("/V110/19200", info
);
2632 case ISDN_PROTO_L2_V11038
:
2633 isdn_tty_at_cout("/V110/38400", info
);
2636 if (m
->mdmreg
[REG_T70
] & BIT_T70
) {
2637 isdn_tty_at_cout("/T.70", info
);
2638 if (m
->mdmreg
[REG_T70
] & BIT_T70_EXT
)
2639 isdn_tty_at_cout("+", info
);
2643 isdn_tty_at_cout("\r\n", info
);
2646 if (code
== RESULT_NO_CARRIER
) {
2647 if ((info
->flags
& ISDN_ASYNC_CLOSING
) || (!info
->tty
)) {
2650 tty_ldisc_flush(info
->tty
);
2651 if ((info
->flags
& ISDN_ASYNC_CHECK_CD
) &&
2652 (!((info
->flags
& ISDN_ASYNC_CALLOUT_ACTIVE
) &&
2653 (info
->flags
& ISDN_ASYNC_CALLOUT_NOHUP
)))) {
2654 tty_hangup(info
->tty
);
2661 * Display a modem-register-value.
2664 isdn_tty_show_profile(int ridx
, modem_info
* info
)
2668 sprintf(v
, "\r\n%d", info
->emu
.mdmreg
[ridx
]);
2669 isdn_tty_at_cout(v
, info
);
2673 * Get MSN-string from char-pointer, set pointer to end of number
2676 isdn_tty_get_msnstr(char *n
, char **p
)
2678 int limit
= ISDN_MSNLEN
- 1;
2680 while (((*p
[0] >= '0' && *p
[0] <= '9') ||
2681 /* Why a comma ??? */
2682 (*p
[0] == ',') || (*p
[0] == ':')) &&
2689 * Get phone-number from modem-commandbuffer
2692 isdn_tty_getdial(char *p
, char *q
,int cnt
)
2695 int limit
= ISDN_MSNLEN
- 1; /* MUST match the size of interface var to avoid
2698 while (strchr(" 0123456789,#.*WPTS-", *p
) && *p
&& --cnt
>0) {
2699 if ((*p
>= '0' && *p
<= '9') || ((*p
== 'S') && first
) ||
2700 (*p
== '*') || (*p
== '#')) {
2712 #define PARSE_ERROR { isdn_tty_modem_result(RESULT_ERROR, info); return; }
2713 #define PARSE_ERROR1 { isdn_tty_modem_result(RESULT_ERROR, info); return 1; }
2716 isdn_tty_report(modem_info
* info
)
2718 atemu
*m
= &info
->emu
;
2721 isdn_tty_at_cout("\r\nStatistics of last connection:\r\n\r\n", info
);
2722 sprintf(s
, " Remote Number: %s\r\n", info
->last_num
);
2723 isdn_tty_at_cout(s
, info
);
2724 sprintf(s
, " Direction: %s\r\n", info
->last_dir
? "outgoing" : "incoming");
2725 isdn_tty_at_cout(s
, info
);
2726 isdn_tty_at_cout(" Layer-2 Protocol: ", info
);
2727 switch (info
->last_l2
) {
2728 case ISDN_PROTO_L2_X75I
:
2729 isdn_tty_at_cout("X.75i", info
);
2731 case ISDN_PROTO_L2_X75UI
:
2732 isdn_tty_at_cout("X.75ui", info
);
2734 case ISDN_PROTO_L2_X75BUI
:
2735 isdn_tty_at_cout("X.75bui", info
);
2737 case ISDN_PROTO_L2_HDLC
:
2738 isdn_tty_at_cout("HDLC", info
);
2740 case ISDN_PROTO_L2_V11096
:
2741 isdn_tty_at_cout("V.110 9600 Baud", info
);
2743 case ISDN_PROTO_L2_V11019
:
2744 isdn_tty_at_cout("V.110 19200 Baud", info
);
2746 case ISDN_PROTO_L2_V11038
:
2747 isdn_tty_at_cout("V.110 38400 Baud", info
);
2749 case ISDN_PROTO_L2_TRANS
:
2750 isdn_tty_at_cout("transparent", info
);
2752 case ISDN_PROTO_L2_MODEM
:
2753 isdn_tty_at_cout("modem", info
);
2755 case ISDN_PROTO_L2_FAX
:
2756 isdn_tty_at_cout("fax", info
);
2759 isdn_tty_at_cout("unknown", info
);
2762 if (m
->mdmreg
[REG_T70
] & BIT_T70
) {
2763 isdn_tty_at_cout("/T.70", info
);
2764 if (m
->mdmreg
[REG_T70
] & BIT_T70_EXT
)
2765 isdn_tty_at_cout("+", info
);
2767 isdn_tty_at_cout("\r\n", info
);
2768 isdn_tty_at_cout(" Service: ", info
);
2769 switch (info
->last_si
) {
2771 isdn_tty_at_cout("audio\r\n", info
);
2774 isdn_tty_at_cout("btx\r\n", info
);
2777 isdn_tty_at_cout("data\r\n", info
);
2780 sprintf(s
, "%d\r\n", info
->last_si
);
2781 isdn_tty_at_cout(s
, info
);
2784 sprintf(s
, " Hangup location: %s\r\n", info
->last_lhup
? "local" : "remote");
2785 isdn_tty_at_cout(s
, info
);
2786 sprintf(s
, " Last cause: %s\r\n", info
->last_cause
);
2787 isdn_tty_at_cout(s
, info
);
2791 * Parse AT&.. commands.
2794 isdn_tty_cmd_ATand(char **p
, modem_info
* info
)
2796 atemu
*m
= &info
->emu
;
2800 #define MAXRB (sizeof(rb) - 1)
2804 /* &B - Set Buffersize */
2807 if ((i
< 0) || (i
> ISDN_SERIAL_XMIT_MAX
))
2809 #ifdef CONFIG_ISDN_AUDIO
2810 if ((m
->mdmreg
[REG_SI1
] & 1) && (i
> VBUF
))
2813 m
->mdmreg
[REG_PSIZE
] = i
/ 16;
2814 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16;
2815 switch (m
->mdmreg
[REG_L2PROT
]) {
2816 case ISDN_PROTO_L2_V11096
:
2817 case ISDN_PROTO_L2_V11019
:
2818 case ISDN_PROTO_L2_V11038
:
2819 info
->xmit_size
/= 10;
2823 /* &C - DCD Status */
2825 switch (isdn_getnum(p
)) {
2827 m
->mdmreg
[REG_DCD
] &= ~BIT_DCD
;
2830 m
->mdmreg
[REG_DCD
] |= BIT_DCD
;
2837 /* &D - Set DTR-Low-behavior */
2839 switch (isdn_getnum(p
)) {
2841 m
->mdmreg
[REG_DTRHUP
] &= ~BIT_DTRHUP
;
2842 m
->mdmreg
[REG_DTRR
] &= ~BIT_DTRR
;
2845 m
->mdmreg
[REG_DTRHUP
] |= BIT_DTRHUP
;
2846 m
->mdmreg
[REG_DTRR
] &= ~BIT_DTRR
;
2849 m
->mdmreg
[REG_DTRHUP
] |= BIT_DTRHUP
;
2850 m
->mdmreg
[REG_DTRR
] |= BIT_DTRR
;
2857 /* &E -Set EAZ/MSN */
2859 isdn_tty_get_msnstr(m
->msn
, p
);
2862 /* &F -Set Factory-Defaults */
2864 if (info
->msr
& UART_MSR_DCD
)
2866 isdn_tty_reset_profile(m
);
2867 isdn_tty_modem_reset_regs(info
, 1);
2869 #ifdef DUMMY_HAYES_AT
2871 /* only for be compilant with common scripts */
2872 /* &K Flowcontrol - no function */
2878 /* &L -Set Numbers to listen on */
2881 while (*p
[0] && (strchr("0123456789,-*[]?;", *p
[0])) &&
2883 m
->lmsn
[i
++] = *p
[0]++;
2887 /* &R - Set V.110 bitrate adaption */
2892 /* Switch off V.110, back to X.75 */
2893 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_X75I
;
2894 m
->mdmreg
[REG_SI2
] = 0;
2895 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16;
2898 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_V11096
;
2899 m
->mdmreg
[REG_SI2
] = 197;
2900 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16 / 10;
2903 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_V11019
;
2904 m
->mdmreg
[REG_SI2
] = 199;
2905 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16 / 10;
2908 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_V11038
;
2909 m
->mdmreg
[REG_SI2
] = 198; /* no existing standard for this */
2910 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16 / 10;
2915 /* Switch off T.70 */
2916 m
->mdmreg
[REG_T70
] &= ~(BIT_T70
| BIT_T70_EXT
);
2918 m
->mdmreg
[REG_SI1
] |= 4;
2921 /* &S - Set Windowsize */
2924 if ((i
> 0) && (i
< 9))
2925 m
->mdmreg
[REG_WSIZE
] = i
;
2930 /* &V - Show registers */
2932 isdn_tty_at_cout("\r\n", info
);
2933 for (i
= 0; i
< ISDN_MODEM_NUMREG
; i
++) {
2934 sprintf(rb
, "S%02d=%03d%s", i
,
2935 m
->mdmreg
[i
], ((i
+ 1) % 10) ? " " : "\r\n");
2936 isdn_tty_at_cout(rb
, info
);
2938 sprintf(rb
, "\r\nEAZ/MSN: %.50s\r\n",
2939 strlen(m
->msn
) ? m
->msn
: "None");
2940 isdn_tty_at_cout(rb
, info
);
2941 if (strlen(m
->lmsn
)) {
2942 isdn_tty_at_cout("\r\nListen: ", info
);
2943 isdn_tty_at_cout(m
->lmsn
, info
);
2944 isdn_tty_at_cout("\r\n", info
);
2948 /* &W - Write Profile */
2953 modem_write_profile(m
);
2960 /* &X - Switch to BTX-Mode and T.70 */
2962 switch (isdn_getnum(p
)) {
2964 m
->mdmreg
[REG_T70
] &= ~(BIT_T70
| BIT_T70_EXT
);
2965 info
->xmit_size
= m
->mdmreg
[REG_PSIZE
] * 16;
2968 m
->mdmreg
[REG_T70
] |= BIT_T70
;
2969 m
->mdmreg
[REG_T70
] &= ~BIT_T70_EXT
;
2970 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_X75I
;
2971 info
->xmit_size
= 112;
2972 m
->mdmreg
[REG_SI1
] = 4;
2973 m
->mdmreg
[REG_SI2
] = 0;
2976 m
->mdmreg
[REG_T70
] |= (BIT_T70
| BIT_T70_EXT
);
2977 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_X75I
;
2978 info
->xmit_size
= 112;
2979 m
->mdmreg
[REG_SI1
] = 4;
2980 m
->mdmreg
[REG_SI2
] = 0;
2993 isdn_tty_check_ats(int mreg
, int mval
, modem_info
* info
, atemu
* m
)
2995 /* Some plausibility checks */
2998 if (mval
> ISDN_PROTO_L2_MAX
)
3002 if ((mval
* 16) > ISDN_SERIAL_XMIT_MAX
)
3004 #ifdef CONFIG_ISDN_AUDIO
3005 if ((m
->mdmreg
[REG_SI1
] & 1) && (mval
> VBUFX
))
3008 info
->xmit_size
= mval
* 16;
3009 switch (m
->mdmreg
[REG_L2PROT
]) {
3010 case ISDN_PROTO_L2_V11096
:
3011 case ISDN_PROTO_L2_V11019
:
3012 case ISDN_PROTO_L2_V11038
:
3013 info
->xmit_size
/= 10;
3019 /* readonly registers */
3026 * Perform ATS command
3029 isdn_tty_cmd_ATS(char **p
, modem_info
* info
)
3031 atemu
*m
= &info
->emu
;
3037 mreg
= isdn_getnum(p
);
3038 if (mreg
< 0 || mreg
>= ISDN_MODEM_NUMREG
)
3043 mval
= isdn_getnum(p
);
3044 if (mval
< 0 || mval
> 255)
3046 if (isdn_tty_check_ats(mreg
, mval
, info
, m
))
3048 m
->mdmreg
[mreg
] = mval
;
3051 /* Set/Clear a single bit */
3053 bitpos
= isdn_getnum(p
);
3054 if ((bitpos
< 0) || (bitpos
> 7))
3059 bval
= isdn_getnum(p
);
3060 if (bval
< 0 || bval
> 1)
3063 mval
= m
->mdmreg
[mreg
] | (1 << bitpos
);
3065 mval
= m
->mdmreg
[mreg
] & ~(1 << bitpos
);
3066 if (isdn_tty_check_ats(mreg
, mval
, info
, m
))
3068 m
->mdmreg
[mreg
] = mval
;
3072 isdn_tty_at_cout("\r\n", info
);
3073 isdn_tty_at_cout((m
->mdmreg
[mreg
] & (1 << bitpos
)) ? "1" : "0",
3082 isdn_tty_show_profile(mreg
, info
);
3092 * Perform ATA command
3095 isdn_tty_cmd_ATA(modem_info
* info
)
3097 atemu
*m
= &info
->emu
;
3101 if (info
->msr
& UART_MSR_RI
) {
3102 /* Accept incoming call */
3104 strcpy(info
->last_num
, dev
->num
[info
->drv_index
]);
3105 m
->mdmreg
[REG_RINGCNT
] = 0;
3106 info
->msr
&= ~UART_MSR_RI
;
3107 l2
= m
->mdmreg
[REG_L2PROT
];
3108 #ifdef CONFIG_ISDN_AUDIO
3109 /* If more than one bit set in reg18, autoselect Layer2 */
3110 if ((m
->mdmreg
[REG_SI1
] & m
->mdmreg
[REG_SI1I
]) != m
->mdmreg
[REG_SI1
]) {
3111 if (m
->mdmreg
[REG_SI1I
] == 1) {
3112 if ((l2
!= ISDN_PROTO_L2_MODEM
) && (l2
!= ISDN_PROTO_L2_FAX
))
3113 l2
= ISDN_PROTO_L2_TRANS
;
3115 l2
= ISDN_PROTO_L2_X75I
;
3118 cmd
.driver
= info
->isdn_driver
;
3119 cmd
.command
= ISDN_CMD_SETL2
;
3120 cmd
.arg
= info
->isdn_channel
+ (l2
<< 8);
3123 cmd
.driver
= info
->isdn_driver
;
3124 cmd
.command
= ISDN_CMD_SETL3
;
3125 cmd
.arg
= info
->isdn_channel
+ (m
->mdmreg
[REG_L3PROT
] << 8);
3126 #ifdef CONFIG_ISDN_TTY_FAX
3127 if (l2
== ISDN_PROTO_L2_FAX
) {
3128 cmd
.parm
.fax
= info
->fax
;
3129 info
->fax
->direction
= ISDN_TTY_FAX_CONN_IN
;
3133 cmd
.driver
= info
->isdn_driver
;
3134 cmd
.arg
= info
->isdn_channel
;
3135 cmd
.command
= ISDN_CMD_ACCEPTD
;
3137 info
->emu
.carrierwait
= 0;
3139 isdn_timer_ctrl(ISDN_TIMER_CARRIER
, 1);
3141 isdn_tty_modem_result(RESULT_NO_ANSWER
, info
);
3144 #ifdef CONFIG_ISDN_AUDIO
3146 * Parse AT+F.. commands
3149 isdn_tty_cmd_PLUSF(char **p
, modem_info
* info
)
3151 atemu
*m
= &info
->emu
;
3154 if (!strncmp(p
[0], "CLASS", 5)) {
3159 sprintf(rs
, "\r\n%d",
3160 (m
->mdmreg
[REG_SI1
] & 1) ? 8 : 0);
3161 #ifdef CONFIG_ISDN_TTY_FAX
3162 if (TTY_IS_FCLASS2(info
))
3163 sprintf(rs
, "\r\n2");
3164 else if (TTY_IS_FCLASS1(info
))
3165 sprintf(rs
, "\r\n1");
3167 isdn_tty_at_cout(rs
, info
);
3174 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_X75I
;
3175 m
->mdmreg
[REG_L3PROT
] = ISDN_PROTO_L3_TRANS
;
3176 m
->mdmreg
[REG_SI1
] = 4;
3178 m
->mdmreg
[REG_PSIZE
] * 16;
3180 #ifdef CONFIG_ISDN_TTY_FAX
3183 if (!(dev
->global_features
&
3184 ISDN_FEATURE_L3_FCLASS1
))
3186 m
->mdmreg
[REG_SI1
] = 1;
3187 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_FAX
;
3188 m
->mdmreg
[REG_L3PROT
] = ISDN_PROTO_L3_FCLASS1
;
3190 m
->mdmreg
[REG_PSIZE
] * 16;
3194 if (!(dev
->global_features
&
3195 ISDN_FEATURE_L3_FCLASS2
))
3197 m
->mdmreg
[REG_SI1
] = 1;
3198 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_FAX
;
3199 m
->mdmreg
[REG_L3PROT
] = ISDN_PROTO_L3_FCLASS2
;
3201 m
->mdmreg
[REG_PSIZE
] * 16;
3206 /* L2 will change on dialout with si=1 */
3207 m
->mdmreg
[REG_L2PROT
] = ISDN_PROTO_L2_X75I
;
3208 m
->mdmreg
[REG_L3PROT
] = ISDN_PROTO_L3_TRANS
;
3209 m
->mdmreg
[REG_SI1
] = 5;
3210 info
->xmit_size
= VBUF
;
3214 strcpy(rs
, "\r\n0,");
3215 #ifdef CONFIG_ISDN_TTY_FAX
3216 if (dev
->global_features
&
3217 ISDN_FEATURE_L3_FCLASS1
)
3219 if (dev
->global_features
&
3220 ISDN_FEATURE_L3_FCLASS2
)
3224 isdn_tty_at_cout(rs
, info
);
3235 #ifdef CONFIG_ISDN_TTY_FAX
3236 return (isdn_tty_cmd_PLUSF_FAX(p
, info
));
3243 * Parse AT+V.. commands
3246 isdn_tty_cmd_PLUSV(char **p
, modem_info
* info
)
3248 atemu
*m
= &info
->emu
;
3250 static char *vcmd
[] =
3251 {"NH", "IP", "LS", "RX", "SD", "SM", "TX", "DD", NULL
};
3259 if (!strncmp(vcmd
[i
], p
[0], 2)) {
3267 /* AT+VNH - Auto hangup feature */
3271 isdn_tty_at_cout("\r\n1", info
);
3281 isdn_tty_at_cout("\r\n1", info
);
3292 /* AT+VIP - Reset all voice parameters */
3293 isdn_tty_modem_reset_vpar(m
);
3296 /* AT+VLS - Select device, accept incoming call */
3300 sprintf(rs
, "\r\n%d", m
->vpar
[0]);
3301 isdn_tty_at_cout(rs
, info
);
3316 isdn_tty_at_cout("\r\n0,2", info
);
3327 /* AT+VRX - Start recording */
3330 if (info
->online
!= 1) {
3331 isdn_tty_modem_result(RESULT_NO_ANSWER
, info
);
3334 info
->dtmf_state
= isdn_audio_dtmf_init(info
->dtmf_state
);
3335 if (!info
->dtmf_state
) {
3336 printk(KERN_WARNING
"isdn_tty: Couldn't malloc dtmf state\n");
3339 info
->silence_state
= isdn_audio_silence_init(info
->silence_state
);
3340 if (!info
->silence_state
) {
3341 printk(KERN_WARNING
"isdn_tty: Couldn't malloc silence state\n");
3344 if (m
->vpar
[3] < 5) {
3345 info
->adpcmr
= isdn_audio_adpcm_init(info
->adpcmr
, m
->vpar
[3]);
3346 if (!info
->adpcmr
) {
3347 printk(KERN_WARNING
"isdn_tty: Couldn't malloc adpcm state\n");
3351 #ifdef ISDN_DEBUG_AT
3352 printk(KERN_DEBUG
"AT: +VRX\n");
3355 isdn_tty_modem_result(RESULT_CONNECT
, info
);
3359 /* AT+VSD - Silence detection */
3363 sprintf(rs
, "\r\n<%d>,<%d>",
3366 isdn_tty_at_cout(rs
, info
);
3370 if ((*p
[0]>='0') && (*p
[0]<='9')) {
3371 par1
= isdn_getnum(p
);
3372 if ((par1
< 0) || (par1
> 31))
3377 par2
= isdn_getnum(p
);
3378 if ((par2
< 0) || (par2
> 255))
3386 isdn_tty_at_cout("\r\n<0-31>,<0-255>",
3397 /* AT+VSM - Select compression */
3401 sprintf(rs
, "\r\n<%d>,<%d><8000>",
3404 isdn_tty_at_cout(rs
, info
);
3414 par1
= isdn_getnum(p
);
3415 if ((par1
< 2) || (par1
> 6))
3421 isdn_tty_at_cout("\r\n2;ADPCM;2;0;(8000)\r\n",
3423 isdn_tty_at_cout("3;ADPCM;3;0;(8000)\r\n",
3425 isdn_tty_at_cout("4;ADPCM;4;0;(8000)\r\n",
3427 isdn_tty_at_cout("5;ALAW;8;0;(8000)\r\n",
3429 isdn_tty_at_cout("6;ULAW;8;0;(8000)\r\n",
3441 /* AT+VTX - Start sending */
3444 if (info
->online
!= 1) {
3445 isdn_tty_modem_result(RESULT_NO_ANSWER
, info
);
3448 info
->dtmf_state
= isdn_audio_dtmf_init(info
->dtmf_state
);
3449 if (!info
->dtmf_state
) {
3450 printk(KERN_WARNING
"isdn_tty: Couldn't malloc dtmf state\n");
3453 if (m
->vpar
[3] < 5) {
3454 info
->adpcms
= isdn_audio_adpcm_init(info
->adpcms
, m
->vpar
[3]);
3455 if (!info
->adpcms
) {
3456 printk(KERN_WARNING
"isdn_tty: Couldn't malloc adpcm state\n");
3460 #ifdef ISDN_DEBUG_AT
3461 printk(KERN_DEBUG
"AT: +VTX\n");
3465 isdn_tty_modem_result(RESULT_CONNECT
, info
);
3469 /* AT+VDD - DTMF detection */
3473 sprintf(rs
, "\r\n<%d>,<%d>",
3476 isdn_tty_at_cout(rs
, info
);
3480 if ((*p
[0]>='0') && (*p
[0]<='9')) {
3481 if (info
->online
!= 1)
3483 par1
= isdn_getnum(p
);
3484 if ((par1
< 0) || (par1
> 15))
3489 par2
= isdn_getnum(p
);
3490 if ((par2
< 0) || (par2
> 255))
3494 cmd
.driver
= info
->isdn_driver
;
3495 cmd
.command
= ISDN_CMD_AUDIO
;
3496 cmd
.arg
= info
->isdn_channel
+ (ISDN_AUDIO_SETDD
<< 8);
3497 cmd
.parm
.num
[0] = par1
;
3498 cmd
.parm
.num
[1] = par2
;
3504 isdn_tty_at_cout("\r\n<0-15>,<0-255>",
3519 #endif /* CONFIG_ISDN_AUDIO */
3522 * Parse and perform an AT-command-line.
3525 isdn_tty_parse_at(modem_info
* info
)
3527 atemu
*m
= &info
->emu
;
3531 #ifdef ISDN_DEBUG_AT
3532 printk(KERN_DEBUG
"AT: '%s'\n", m
->mdmcmd
);
3534 for (p
= &m
->mdmcmd
[2]; *p
;) {
3540 /* A - Accept incoming call */
3542 isdn_tty_cmd_ATA(info
);
3547 if (info
->msr
& UART_MSR_DCD
)
3549 if (info
->msr
& UART_MSR_RI
) {
3550 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
3553 isdn_tty_getdial(++p
, ds
, sizeof ds
);
3555 if (!strlen(m
->msn
))
3556 isdn_tty_modem_result(RESULT_NO_MSN_EAZ
, info
);
3557 else if (strlen(ds
))
3558 isdn_tty_dial(ds
, info
, m
);
3563 /* E - Turn Echo on/off */
3565 switch (isdn_getnum(&p
)) {
3567 m
->mdmreg
[REG_ECHO
] &= ~BIT_ECHO
;
3570 m
->mdmreg
[REG_ECHO
] |= BIT_ECHO
;
3577 /* H - On/Off-hook */
3582 isdn_tty_on_hook(info
);
3586 isdn_tty_off_hook();
3589 isdn_tty_on_hook(info
);
3594 /* I - Information */
3596 isdn_tty_at_cout("\r\nLinux ISDN", info
);
3604 isdn_tty_report(info
);
3608 sprintf(ds
, "\r\n%d", info
->emu
.charge
);
3609 isdn_tty_at_cout(ds
, info
);
3614 #ifdef DUMMY_HAYES_AT
3617 /* only for be compilant with common scripts */
3626 if (info
->msr
& UART_MSR_DCD
)
3627 /* if B-Channel is up */
3628 isdn_tty_modem_result((m
->mdmreg
[REG_L2PROT
] == ISDN_PROTO_L2_MODEM
) ? RESULT_CONNECT
:RESULT_CONNECT64000
, info
);
3630 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
3633 /* Q - Turn Emulator messages on/off */
3635 switch (isdn_getnum(&p
)) {
3637 m
->mdmreg
[REG_RESP
] |= BIT_RESP
;
3640 m
->mdmreg
[REG_RESP
] &= ~BIT_RESP
;
3647 /* S - Set/Get Register */
3649 if (isdn_tty_cmd_ATS(&p
, info
))
3653 /* V - Numeric or ASCII Emulator-messages */
3655 switch (isdn_getnum(&p
)) {
3657 m
->mdmreg
[REG_RESP
] |= BIT_RESPNUM
;
3660 m
->mdmreg
[REG_RESP
] &= ~BIT_RESPNUM
;
3667 /* Z - Load Registers from Profile */
3669 if (info
->msr
& UART_MSR_DCD
) {
3671 isdn_tty_on_hook(info
);
3673 isdn_tty_modem_reset_regs(info
, 1);
3678 #ifdef CONFIG_ISDN_AUDIO
3681 if (isdn_tty_cmd_PLUSF(&p
, info
))
3685 if ((!(m
->mdmreg
[REG_SI1
] & 1)) ||
3686 (m
->mdmreg
[REG_L2PROT
] == ISDN_PROTO_L2_MODEM
))
3689 if (isdn_tty_cmd_PLUSV(&p
, info
))
3692 #endif /* CONFIG_ISDN_AUDIO */
3693 case 'S': /* SUSPEND */
3695 isdn_tty_get_msnstr(ds
, &p
);
3696 isdn_tty_suspend(ds
, info
, m
);
3698 case 'R': /* RESUME */
3700 isdn_tty_get_msnstr(ds
, &p
);
3701 isdn_tty_resume(ds
, info
, m
);
3703 case 'M': /* MESSAGE */
3705 isdn_tty_send_msg(info
, m
, p
);
3713 if (isdn_tty_cmd_ATand(&p
, info
))
3720 #ifdef CONFIG_ISDN_AUDIO
3723 isdn_tty_modem_result(RESULT_OK
, info
);
3726 /* Need own toupper() because standard-toupper is not available
3729 #define my_toupper(c) (((c>='a')&&(c<='z'))?(c&0xdf):c)
3732 * Perform line-editing of AT-commands
3736 * count length of buffer
3737 * channel index to line (minor-device)
3740 isdn_tty_edit_at(const char *p
, int count
, modem_info
* info
)
3742 atemu
*m
= &info
->emu
;
3748 for (cnt
= count
; cnt
> 0; p
++, cnt
--) {
3751 if (c
== m
->mdmreg
[REG_CR
] || c
== m
->mdmreg
[REG_LF
]) {
3752 /* Separator (CR or LF) */
3753 m
->mdmcmd
[m
->mdmcmdl
] = 0;
3754 if (m
->mdmreg
[REG_ECHO
] & BIT_ECHO
) {
3757 isdn_tty_at_cout(eb
, info
);
3759 if ((m
->mdmcmdl
>= 2) && (!(strncmp(m
->mdmcmd
, "AT", 2))))
3760 isdn_tty_parse_at(info
);
3764 if (c
== m
->mdmreg
[REG_BS
] && m
->mdmreg
[REG_BS
] < 128) {
3765 /* Backspace-Function */
3766 if ((m
->mdmcmdl
> 2) || (!m
->mdmcmdl
)) {
3769 if (m
->mdmreg
[REG_ECHO
] & BIT_ECHO
)
3770 isdn_tty_at_cout("\b", info
);
3775 if (m
->mdmreg
[REG_ECHO
] & BIT_ECHO
) {
3778 isdn_tty_at_cout(eb
, info
);
3780 if (m
->mdmcmdl
< 255) {
3782 switch (m
->mdmcmdl
) {
3785 m
->mdmcmd
[m
->mdmcmdl
] = c
;
3786 m
->mdmcmd
[++m
->mdmcmdl
] = 0;
3790 /* Fall through, check for 'A' */
3793 m
->mdmcmd
[m
->mdmcmdl
] = c
;
3794 m
->mdmcmd
[++m
->mdmcmdl
] = 0;
3798 m
->mdmcmd
[m
->mdmcmdl
] = c
;
3799 m
->mdmcmd
[++m
->mdmcmdl
] = 0;
3808 * Switch all modem-channels who are online and got a valid
3809 * escape-sequence 1.5 seconds ago, to command-mode.
3810 * This function is called every second via timer-interrupt from within
3811 * timer-dispatcher isdn_timer_function()
3814 isdn_tty_modem_escape(void)
3820 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++)
3821 if (USG_MODEM(dev
->usage
[i
]))
3822 if ((midx
= dev
->m_idx
[i
]) >= 0) {
3823 modem_info
*info
= &dev
->mdm
.info
[midx
];
3826 if ((info
->emu
.pluscount
== 3) &&
3827 time_after(jiffies
, info
->emu
.lastplus
+ PLUSWAIT2
)) {
3828 info
->emu
.pluscount
= 0;
3830 isdn_tty_modem_result(RESULT_OK
, info
);
3834 isdn_timer_ctrl(ISDN_TIMER_MODEMPLUS
, ton
);
3838 * Put a RING-message to all modem-channels who have the RI-bit set.
3839 * This function is called every second via timer-interrupt from within
3840 * timer-dispatcher isdn_timer_function()
3843 isdn_tty_modem_ring(void)
3848 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
3849 modem_info
*info
= &dev
->mdm
.info
[i
];
3850 if (info
->msr
& UART_MSR_RI
) {
3852 isdn_tty_modem_result(RESULT_RING
, info
);
3855 isdn_timer_ctrl(ISDN_TIMER_MODEMRING
, ton
);
3859 * For all online tty's, try sending data to
3863 isdn_tty_modem_xmit(void)
3868 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
3869 modem_info
*info
= &dev
->mdm
.info
[i
];
3872 isdn_tty_senddown(info
);
3873 isdn_tty_tint(info
);
3876 isdn_timer_ctrl(ISDN_TIMER_MODEMXMIT
, ton
);
3880 * Check all channels if we have a 'no carrier' timeout.
3881 * Timeout value is set by Register S7.
3884 isdn_tty_carrier_timeout(void)
3889 for (i
= 0; i
< ISDN_MAX_CHANNELS
; i
++) {
3890 modem_info
*info
= &dev
->mdm
.info
[i
];
3891 if (info
->dialing
) {
3892 if (info
->emu
.carrierwait
++ > info
->emu
.mdmreg
[REG_WAITC
]) {
3894 isdn_tty_modem_result(RESULT_NO_CARRIER
, info
);
3895 isdn_tty_modem_hup(info
, 1);
3901 isdn_timer_ctrl(ISDN_TIMER_CARRIER
, ton
);