3 * Copyright 1999 Digi International (www.digi.com)
4 * Gene Olson <Gene_Olson at digi dot com>
5 * James Puzzo <jamesp at digi dot com>
7 * Scott Kilau <scottk at digi dot com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
16 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
17 * PURPOSE. See the GNU General Public License for more details.
29 * This file implements the tty driver functionality for the
30 * RealPort driver software.
39 #include <linux/slab.h>
40 #include <linux/tty.h>
41 #include <linux/tty_flip.h>
42 #include <linux/device.h>
43 #include <linux/sched.h>
44 #include <linux/uaccess.h>
46 #include "dgrp_common.h"
48 #ifndef _POSIX_VDISABLE
49 #define _POSIX_VDISABLE ('\0')
53 * forward declarations
56 static void drp_param(struct ch_struct
*);
57 static void dgrp_tty_close(struct tty_struct
*, struct file
*);
59 /* ioctl helper functions */
60 static int set_modem_info(struct ch_struct
*, unsigned int, unsigned int *);
61 static int get_modem_info(struct ch_struct
*, unsigned int *);
62 static void dgrp_set_custom_speed(struct ch_struct
*, int);
63 static int dgrp_tty_digigetedelay(struct tty_struct
*, int *);
64 static int dgrp_tty_digisetedelay(struct tty_struct
*, int *);
65 static int dgrp_send_break(struct ch_struct
*, int);
67 static ushort
tty_to_ch_flags(struct tty_struct
*, char);
68 static tcflag_t
ch_to_tty_flags(unsigned short, char);
70 static void dgrp_tty_input_start(struct tty_struct
*);
71 static void dgrp_tty_input_stop(struct tty_struct
*);
73 static void drp_wmove(struct ch_struct
*, int, void*, int);
75 static int dgrp_tty_open(struct tty_struct
*, struct file
*);
76 static void dgrp_tty_close(struct tty_struct
*, struct file
*);
77 static int dgrp_tty_write(struct tty_struct
*, const unsigned char *, int);
78 static int dgrp_tty_write_room(struct tty_struct
*);
79 static void dgrp_tty_flush_buffer(struct tty_struct
*);
80 static int dgrp_tty_chars_in_buffer(struct tty_struct
*);
81 static int dgrp_tty_ioctl(struct tty_struct
*, unsigned int, unsigned long);
82 static void dgrp_tty_set_termios(struct tty_struct
*, struct ktermios
*);
83 static void dgrp_tty_stop(struct tty_struct
*);
84 static void dgrp_tty_start(struct tty_struct
*);
85 static void dgrp_tty_throttle(struct tty_struct
*);
86 static void dgrp_tty_unthrottle(struct tty_struct
*);
87 static void dgrp_tty_hangup(struct tty_struct
*);
88 static int dgrp_tty_put_char(struct tty_struct
*, unsigned char);
89 static int dgrp_tty_tiocmget(struct tty_struct
*);
90 static int dgrp_tty_tiocmset(struct tty_struct
*, unsigned int, unsigned int);
91 static int dgrp_tty_send_break(struct tty_struct
*, int);
92 static void dgrp_tty_send_xchar(struct tty_struct
*, char);
97 #define SERIAL_TYPE_NORMAL 1
98 #define SERIAL_TYPE_CALLOUT 2
99 #define SERIAL_TYPE_XPRINT 3
103 * tty globals/statics
107 #define PORTSERVER_DIVIDEND 1843200
110 * Default transparent print information.
112 static struct digi_struct digi_init
= {
113 .digi_flags
= DIGI_COOK
, /* Flags */
114 .digi_maxcps
= 100, /* Max CPS */
115 .digi_maxchar
= 50, /* Max chars in print queue */
116 .digi_bufsize
= 100, /* Printer buffer size */
117 .digi_onlen
= 4, /* size of printer on string */
118 .digi_offlen
= 4, /* size of printer off string */
119 .digi_onstr
= "\033[5i", /* ANSI printer on string */
120 .digi_offstr
= "\033[4i", /* ANSI printer off string */
121 .digi_term
= "ansi" /* default terminal type */
125 * Define a local default termios struct. All ports will be created
126 * with this termios initially.
128 * This defines a raw port at 9600 baud, 8 data bits, no parity,
131 static struct ktermios DefaultTermios
= {
132 .c_iflag
= (ICRNL
| IXON
),
133 .c_oflag
= (OPOST
| ONLCR
),
134 .c_cflag
= (B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
),
135 .c_lflag
= (ISIG
| ICANON
| ECHO
| ECHOE
| ECHOK
| ECHOCTL
141 /* Define our tty operations struct */
142 static const struct tty_operations dgrp_tty_ops
= {
143 .open
= dgrp_tty_open
,
144 .close
= dgrp_tty_close
,
145 .write
= dgrp_tty_write
,
146 .write_room
= dgrp_tty_write_room
,
147 .flush_buffer
= dgrp_tty_flush_buffer
,
148 .chars_in_buffer
= dgrp_tty_chars_in_buffer
,
150 .ioctl
= dgrp_tty_ioctl
,
151 .set_termios
= dgrp_tty_set_termios
,
152 .stop
= dgrp_tty_stop
,
153 .start
= dgrp_tty_start
,
154 .throttle
= dgrp_tty_throttle
,
155 .unthrottle
= dgrp_tty_unthrottle
,
156 .hangup
= dgrp_tty_hangup
,
157 .put_char
= dgrp_tty_put_char
,
158 .tiocmget
= dgrp_tty_tiocmget
,
159 .tiocmset
= dgrp_tty_tiocmset
,
160 .break_ctl
= dgrp_tty_send_break
,
161 .send_xchar
= dgrp_tty_send_xchar
165 static int calc_baud_rate(struct un_struct
*un
)
175 static struct baud_rates baud_rates
[] = {
198 brate
= C_BAUD(un
->un_tty
);
200 for (i
= 0; baud_rates
[i
].rate
; i
++) {
201 if (baud_rates
[i
].cflag
== brate
)
205 return baud_rates
[i
].rate
;
208 static int calc_fastbaud_rate(struct un_struct
*un
, struct ktermios
*uts
)
213 ulong bauds
[2][16] = {
215 0, 57600, 76800, 115200,
216 131657, 153600, 230400, 460800,
217 921600, 1200, 1800, 2400,
218 4800, 9600, 19200, 38400 },
219 { /* fastbaud & CBAUDEX */
220 0, 57600, 115200, 230400,
221 460800, 150, 200, 921600,
222 600, 1200, 1800, 2400,
223 4800, 9600, 19200, 38400 }
226 brate
= C_BAUD(un
->un_tty
) & 0xff;
228 i
= (uts
->c_cflag
& CBAUDEX
) ? 1 : 0;
231 if ((i
>= 0) && (i
< 2) && (brate
>= 0) && (brate
< 16))
232 brate
= bauds
[i
][brate
];
240 * drp_param() -- send parameter values to be sent to the node
241 * @ch: channel structure of port to modify
243 * Interprets the tty and modem changes made by an application
244 * program (by examining the termios structures) and sets up
245 * parameter values to be sent to the node.
247 static void drp_param(struct ch_struct
*ch
)
249 struct nd_struct
*nd
;
250 struct un_struct
*un
;
255 struct ktermios
*tts
, *pts
, *uts
;
260 * If the terminal device is open, use it to set up all tty
261 * modes and functions. Otherwise use the printer device.
264 if (ch
->ch_tun
.un_open_count
) {
267 tts
= &ch
->ch_tun
.un_tty
->termios
;
270 * If both devices are open, copy critical line
271 * parameters from the tty device to the printer,
272 * so that if the tty is closed, the printer will
273 * continue without disruption.
276 if (ch
->ch_pun
.un_open_count
) {
278 pts
= &ch
->ch_pun
.un_tty
->termios
;
281 (pts
->c_cflag
^ tts
->c_cflag
) &
282 (CBAUD
| CSIZE
| CSTOPB
| CREAD
| PARENB
|
283 PARODD
| HUPCL
| CLOCAL
);
286 (pts
->c_iflag
^ tts
->c_iflag
) &
287 (IGNBRK
| BRKINT
| IGNPAR
| PARMRK
| INPCK
|
288 ISTRIP
| IXON
| IXANY
| IXOFF
);
290 pts
->c_cc
[VSTART
] = tts
->c_cc
[VSTART
];
291 pts
->c_cc
[VSTOP
] = tts
->c_cc
[VSTOP
];
293 } else if (ch
->ch_pun
.un_open_count
== 0) {
294 pr_warn("%s - ch_pun.un_open_count shouldn't be 0\n",
301 uts
= &un
->un_tty
->termios
;
304 * Determine if FAST writes can be performed.
307 if ((ch
->ch_digi
.digi_flags
& DIGI_COOK
) != 0 &&
308 (ch
->ch_tun
.un_open_count
!= 0) &&
309 !((un
->un_tty
)->ldisc
->ops
->flags
& LDISC_FLAG_DEFINED
) &&
310 !(L_XCASE(un
->un_tty
))) {
311 ch
->ch_flag
|= CH_FAST_WRITE
;
313 ch
->ch_flag
&= ~CH_FAST_WRITE
;
317 * If FAST writes can be performed, and OPOST is on in the
318 * terminal device, do OPOST handling in the server.
321 if ((ch
->ch_flag
& CH_FAST_WRITE
) &&
322 O_OPOST(un
->un_tty
) != 0) {
323 int oflag
= tty_to_ch_flags(un
->un_tty
, 'o');
325 /* add to ch_ocook any processing flags set in the termio */
326 ch
->ch_ocook
|= oflag
& (OF_OLCUC
|
333 * the hpux driver clears any flags set in ch_ocook
334 * from the termios oflag. It is STILL reported though
338 oflag
= ch_to_tty_flags(ch
->ch_ocook
, 'o');
339 uts
->c_oflag
&= ~oflag
;
342 /* clear the ch->ch_ocook flag */
343 int oflag
= ch_to_tty_flags(ch
->ch_ocook
, 'o');
344 uts
->c_oflag
|= oflag
;
348 ch
->ch_oflag
= ch
->ch_ocook
;
351 ch
->ch_flag
&= ~CH_FAST_READ
;
354 * Generate channel flags
357 if (C_BAUD(un
->un_tty
) == B0
) {
358 if (!(ch
->ch_flag
& CH_BAUD0
)) {
359 /* TODO : the HPUX driver flushes line */
360 /* TODO : discipline, I assume I don't have to */
362 ch
->ch_tout
= ch
->ch_tin
;
363 ch
->ch_rout
= ch
->ch_rin
;
365 ch
->ch_break_time
= 0;
367 ch
->ch_send
|= RR_TX_FLUSH
| RR_RX_FLUSH
;
369 ch
->ch_mout
&= ~(DM_DTR
| DM_RTS
);
371 ch
->ch_flag
|= CH_BAUD0
;
373 } else if (ch
->ch_custom_speed
) {
374 ch
->ch_brate
= PORTSERVER_DIVIDEND
/ ch
->ch_custom_speed
;
376 if (ch
->ch_flag
& CH_BAUD0
) {
377 ch
->ch_mout
|= DM_DTR
| DM_RTS
;
379 ch
->ch_flag
&= ~CH_BAUD0
;
385 * If FASTBAUD isn't on, we can scan the new baud rate list
388 * However, if FASTBAUD is on, we must go to the old
389 * baud rate mapping that existed many many moons ago,
390 * for compatibility reasons.
393 if (!(ch
->ch_digi
.digi_flags
& DIGI_FAST
))
394 brate
= calc_baud_rate(un
);
396 brate
= calc_fastbaud_rate(un
, uts
);
401 ch
->ch_brate
= PORTSERVER_DIVIDEND
/ brate
;
403 if (ch
->ch_flag
& CH_BAUD0
) {
404 ch
->ch_mout
|= DM_DTR
| DM_RTS
;
406 ch
->ch_flag
&= ~CH_BAUD0
;
411 * Generate channel cflags from the termio.
414 ch
->ch_cflag
= tty_to_ch_flags(un
->un_tty
, 'c');
417 * Generate channel iflags from the termio.
420 iflag
= (int) tty_to_ch_flags(un
->un_tty
, 'i');
422 if (START_CHAR(un
->un_tty
) == _POSIX_VDISABLE
||
423 STOP_CHAR(un
->un_tty
) == _POSIX_VDISABLE
) {
424 iflag
&= ~(IF_IXON
| IF_IXANY
| IF_IXOFF
);
427 ch
->ch_iflag
= iflag
;
430 * Generate flow control characters
434 * From the POSIX.1 spec (7.1.2.6): "If {_POSIX_VDISABLE}
435 * is defined for the terminal device file, and the value
436 * of one of the changeable special control characters (see
437 * 7.1.1.9) is {_POSIX_VDISABLE}, that function shall be
438 * disabled, that is, no input data shall be recognized as
439 * the disabled special character."
441 * OK, so we don't ever assign S/DXB XON or XOFF to _POSIX_VDISABLE.
444 if (uts
->c_cc
[VSTART
] != _POSIX_VDISABLE
)
445 ch
->ch_xon
= uts
->c_cc
[VSTART
];
446 if (uts
->c_cc
[VSTOP
] != _POSIX_VDISABLE
)
447 ch
->ch_xoff
= uts
->c_cc
[VSTOP
];
449 ch
->ch_lnext
= (uts
->c_cc
[VLNEXT
] == _POSIX_VDISABLE
? 0 :
453 * Also, if either c_cc[START] or c_cc[STOP] is set to
454 * _POSIX_VDISABLE, we can't really do software flow
455 * control--in either direction--so we turn it off as
456 * far as S/DXB is concerned. In essence, if you disable
457 * one, you disable the other too.
459 if ((uts
->c_cc
[VSTART
] == _POSIX_VDISABLE
) ||
460 (uts
->c_cc
[VSTOP
] == _POSIX_VDISABLE
))
461 ch
->ch_iflag
&= ~(IF_IXOFF
| IF_IXON
);
469 if (ch
->ch_digi
.digi_flags
& DIGI_AIXON
)
472 if ((ch
->ch_xxon
== _POSIX_VDISABLE
) ||
473 (ch
->ch_xxoff
== _POSIX_VDISABLE
))
476 ch
->ch_xflag
= xflag
;
480 * Figure effective DCD value.
483 if (C_CLOCAL(un
->un_tty
))
484 ch
->ch_flag
|= CH_CLOCAL
;
486 ch
->ch_flag
&= ~CH_CLOCAL
;
489 * Check modem signals
495 * Get hardware handshake value.
500 if (C_CRTSCTS(un
->un_tty
))
501 mflow
|= (DM_RTS
| DM_CTS
);
503 if (ch
->ch_digi
.digi_flags
& RTSPACE
)
506 if (ch
->ch_digi
.digi_flags
& DTRPACE
)
509 if (ch
->ch_digi
.digi_flags
& CTSPACE
)
512 if (ch
->ch_digi
.digi_flags
& DSRPACE
)
515 if (ch
->ch_digi
.digi_flags
& DCDPACE
)
518 if (ch
->ch_digi
.digi_flags
& DIGI_RTS_TOGGLE
)
519 mflow
|= DM_RTS_TOGGLE
;
521 ch
->ch_mflow
= mflow
;
524 * Send the changes to the server.
527 ch
->ch_flag
|= CH_PARAM
;
528 (ch
->ch_nd
)->nd_tx_work
= 1;
530 if (waitqueue_active(&ch
->ch_flag_wait
))
531 wake_up_interruptible(&ch
->ch_flag_wait
);
535 * This function is just used as a callback for timeouts
536 * waiting on the ch_sleep flag.
538 static void wake_up_drp_sleep_timer(unsigned long ptr
)
540 struct ch_struct
*ch
= (struct ch_struct
*) ptr
;
542 wake_up(&ch
->ch_sleep
);
547 * Set up our own sleep that can't be cancelled
548 * until our timeout occurs.
550 static void drp_my_sleep(struct ch_struct
*ch
)
552 struct timer_list drp_wakeup_timer
;
553 DECLARE_WAITQUEUE(wait
, current
);
556 * First make sure we're ready to receive the wakeup.
559 add_wait_queue(&ch
->ch_sleep
, &wait
);
560 current
->state
= TASK_UNINTERRUPTIBLE
;
563 * Since we are uninterruptible, set a timer to
564 * unset the uninterruptable state in 1 second.
567 init_timer(&drp_wakeup_timer
);
568 drp_wakeup_timer
.function
= wake_up_drp_sleep_timer
;
569 drp_wakeup_timer
.data
= (unsigned long) ch
;
570 drp_wakeup_timer
.expires
= jiffies
+ (1 * HZ
);
571 add_timer(&drp_wakeup_timer
);
575 del_timer(&drp_wakeup_timer
);
577 remove_wait_queue(&ch
->ch_sleep
, &wait
);
584 * -EBUSY - this is a callout device and the normal device is active
585 * - there is an error in opening the tty
586 * -ENODEV - the channel does not exist
587 * -EAGAIN - we are in the middle of hanging up or closing
588 * - IMMEDIATE_OPEN fails
590 * - if the port is outside physical range
591 * -EINTR - the open is interrupted
594 static int dgrp_tty_open(struct tty_struct
*tty
, struct file
*file
)
597 struct nd_struct
*nd
;
598 struct ch_struct
*ch
;
599 struct un_struct
*un
;
606 int counts_were_incremented
= 0;
608 DECLARE_WAITQUEUE(wait
, current
);
611 * Do some initial checks to see if the node and port exist
614 nd
= nd_struct_get(MAJOR(tty_devnum(tty
)));
615 port
= PORT_NUM(MINOR(tty_devnum(tty
)));
616 category
= OPEN_CATEGORY(MINOR(tty_devnum(tty
)));
621 if (port
>= CHAN_MAX
)
625 * The channel exists.
628 ch
= nd
->nd_chan
+ port
;
630 un
= IS_PRINT(MINOR(tty_devnum(tty
))) ? &ch
->ch_pun
: &ch
->ch_tun
;
632 tty
->driver_data
= un
;
635 * If we are in the middle of hanging up,
636 * then return an error
638 if (tty_hung_up_p(file
)) {
639 retval
= ((un
->un_flag
& UN_HUP_NOTIFY
) ?
640 -EAGAIN
: -ERESTARTSYS
);
645 * If the port is in the middle of closing, then block
646 * until it is done, then try again.
648 retval
= wait_event_interruptible(un
->un_close_wait
,
649 ((un
->un_flag
& UN_CLOSING
) == 0));
655 * If the port is in the middle of a reopen after a network disconnect,
656 * wait until it is done, then try again.
658 retval
= wait_event_interruptible(ch
->ch_flag_wait
,
659 ((ch
->ch_flag
& CH_PORT_GONE
) == 0));
665 * If this is a callout device, then just make sure the normal
666 * device isn't being used.
669 if (tty
->driver
->subtype
== SERIAL_TYPE_CALLOUT
) {
670 if (un
->un_flag
& UN_NORMAL_ACTIVE
) {
674 un
->un_flag
|= UN_CALLOUT_ACTIVE
;
679 * Loop waiting until the open can be successfully completed.
682 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
690 * Determine the open type from the flags provided.
694 * If the port is not enabled, then exit
696 if (test_bit(TTY_IO_ERROR
, &tty
->flags
)) {
697 /* there was an error in opening the tty */
698 if (un
->un_flag
& UN_CALLOUT_ACTIVE
)
701 un
->un_flag
|= UN_NORMAL_ACTIVE
;
705 if (file
->f_flags
& O_NONBLOCK
) {
708 * if the O_NONBLOCK is set, errors on read and write
709 * must return -EAGAIN immediately and NOT sleep
712 otype
= OTYPE_IMMEDIATE
;
713 delay_error
= -EAGAIN
;
715 } else if (!OPEN_WAIT_AVAIL(category
) ||
716 (file
->f_flags
& O_NDELAY
) != 0) {
717 otype
= OTYPE_IMMEDIATE
;
718 delay_error
= -EBUSY
;
720 } else if (!OPEN_WAIT_CARRIER(category
) ||
721 ((ch
->ch_digi
.digi_flags
& DIGI_FORCEDCD
) != 0) ||
723 otype
= OTYPE_PERSISTENT
;
727 otype
= OTYPE_INCOMING
;
732 * Handle port currently outside physical port range.
735 if (port
>= nd
->nd_chan_count
) {
736 if (otype
== OTYPE_IMMEDIATE
) {
737 retval
= (nd
->nd_state
== NS_READY
) ?
744 * Handle port not currently open.
747 else if (ch
->ch_open_count
== 0) {
749 * Return an error when an Incoming Open
750 * response indicates the port is busy.
753 if (ch
->ch_open_error
!= 0 && otype
== ch
->ch_otype
) {
754 retval
= (ch
->ch_open_error
<= 2) ?
755 delay_error
: -ENXIO
;
760 * Fail any new Immediate open if we do not have
761 * a normal connection to the server.
764 if (nd
->nd_state
!= NS_READY
&&
765 otype
== OTYPE_IMMEDIATE
) {
771 * If a Realport open of the correct type has
772 * succeeded, complete the open.
775 if (ch
->ch_state
== CS_READY
&& ch
->ch_otype
== otype
)
780 * Handle port already open and active as a device
784 else if ((ch
->ch_category
== category
) ||
785 IS_PRINT(MINOR(tty_devnum(tty
)))) {
787 * Fail if opening the device now would
788 * violate exclusive use.
790 unf
= ch
->ch_tun
.un_flag
| ch
->ch_pun
.un_flag
;
792 if ((file
->f_flags
& O_EXCL
) || (unf
& UN_EXCL
)) {
798 * If the open device is in the hangup state, all
799 * system calls fail except close().
802 /* TODO : check on hangup_p calls */
804 if (ch
->ch_flag
& CH_HANGUP
) {
810 * If the port is ready, and carrier is ignored
811 * or present, then complete the open.
814 if (ch
->ch_state
== CS_READY
&&
815 (otype
!= OTYPE_INCOMING
||
816 ch
->ch_flag
& CH_VIRT_CD
))
823 * Handle port active with a different category device.
827 if (otype
== OTYPE_IMMEDIATE
) {
828 retval
= delay_error
;
834 * Wait until conditions change, then take another
838 ch
->ch_wait_count
[otype
]++;
841 ch
->ch_wait_carrier
++;
844 * Prepare the task to accept the wakeup, then
845 * release our locks and release control.
848 add_wait_queue(&ch
->ch_flag_wait
, &wait
);
849 current
->state
= TASK_INTERRUPTIBLE
;
851 spin_unlock_irqrestore(&nd
->nd_lock
, lock_flags
);
854 * Give up control, we'll come back if we're
855 * interrupted or are woken up.
858 remove_wait_queue(&ch
->ch_flag_wait
, &wait
);
860 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
862 current
->state
= TASK_RUNNING
;
864 ch
->ch_wait_count
[otype
]--;
867 ch
->ch_wait_carrier
--;
871 if (signal_pending(current
)) {
878 * The open has succeeded. No turning back.
880 counts_were_incremented
= 1;
885 * Initialize the channel, if it's not already open.
888 if (ch
->ch_open_count
== 1) {
891 ch
->ch_category
= category
;
892 ch
->ch_pscan_state
= 0;
894 /* TODO : find out what PS-1 bug Gene was referring to */
895 /* TODO : in the following comment. */
897 ch
->ch_send
= RR_TX_START
| RR_RX_START
; /* PS-1 bug */
900 ch
->ch_s_mlast
& DM_CD
||
901 ch
->ch_digi
.digi_flags
& DIGI_FORCEDCD
)
902 ch
->ch_flag
|= CH_VIRT_CD
;
903 else if (OPEN_FORCES_CARRIER(category
))
904 ch
->ch_flag
|= CH_VIRT_CD
;
909 * Initialize the unit, if it is not already open.
912 if (un
->un_open_count
== 1) {
914 * Since all terminal options are always sticky in Linux,
915 * we don't need the UN_STICKY flag to be handled specially.
917 /* clears all the digi flags, leaves serial flags */
918 un
->un_flag
&= ~UN_DIGI_MASK
;
920 if (file
->f_flags
& O_EXCL
)
921 un
->un_flag
|= UN_EXCL
;
923 /* TODO : include "session" and "pgrp" */
926 * In Linux, all terminal parameters are intended to be sticky.
927 * as a result, we "remove" the code which once reset the ports
935 un
->un_flag
|= UN_INITIALIZED
;
941 spin_unlock_irqrestore(&nd
->nd_lock
, lock_flags
);
945 * Linux does a close for every open, even failed ones!
947 if (!counts_were_incremented
) {
953 dev_err(tty
->dev
, "tty open bad return (%i)\n", retval
);
962 * dgrp_tty_close() -- close function for tty_operations
964 static void dgrp_tty_close(struct tty_struct
*tty
, struct file
*file
)
966 struct ch_struct
*ch
;
967 struct un_struct
*un
;
968 struct nd_struct
*nd
;
975 int sent_printer_offstr
= 0;
977 port
= PORT_NUM(MINOR(tty_devnum(tty
)));
979 un
= tty
->driver_data
;
994 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
997 /* Used to be on channel basis, now we check on a unit basis. */
998 if (un
->un_open_count
!= 1)
1002 * OK, its the last close on the unit
1004 un
->un_flag
|= UN_CLOSING
;
1007 * Notify the discipline to only process XON/XOFF characters.
1012 * Wait for output to drain only if this is
1013 * the last close against the channel
1016 if (ch
->ch_open_count
== 1) {
1018 * If its the print device, we need to ensure at all costs that
1019 * the offstr will fit. If it won't, flush our tbuf.
1021 if (IS_PRINT(MINOR(tty_devnum(tty
))) &&
1022 (((ch
->ch_tout
- ch
->ch_tin
- 1) & TBUF_MASK
) <
1023 ch
->ch_digi
.digi_offlen
))
1024 ch
->ch_tin
= ch
->ch_tout
;
1027 * Turn off the printer. Don't bother checking to see if its
1028 * IS_PRINT... Since this is the last close the flag is going
1029 * to be cleared, so we MUST make sure the offstr gets inserted
1033 if ((ch
->ch_flag
& CH_PRON
) != 0) {
1034 drp_wmove(ch
, 0, ch
->ch_digi
.digi_offstr
,
1035 ch
->ch_digi
.digi_offlen
);
1036 ch
->ch_flag
&= ~CH_PRON
;
1037 sent_printer_offstr
= 1;
1042 * Wait until either the output queue has drained, or we see
1043 * absolutely no progress for 15 seconds.
1046 tpos
= ch
->ch_s_tpos
;
1048 waketime
= jiffies
+ 15 * HZ
;
1053 * Make sure the port still exists.
1056 if (port
>= nd
->nd_chan_count
) {
1061 if (signal_pending(current
)) {
1067 * If the port is idle (not opened on the server), we have
1068 * no way of draining/flushing/closing the port on that server.
1069 * So break out of loop.
1071 if (ch
->ch_state
== CS_IDLE
)
1077 * Exit if the queues for this unit are empty,
1078 * and either the other unit is still open or all
1082 if ((un
->un_tty
)->ops
->chars_in_buffer
?
1083 ((un
->un_tty
)->ops
->chars_in_buffer
)(un
->un_tty
) == 0 : 1) {
1086 * We don't need to wait for a buffer to drain
1087 * if the other unit is open.
1090 if (ch
->ch_open_count
!= un
->un_open_count
)
1094 * The wait is complete when all queues are
1095 * drained, and any break in progress is complete.
1098 if (ch
->ch_tin
== ch
->ch_tout
&&
1099 ch
->ch_s_tin
== ch
->ch_s_tpos
&&
1100 (ch
->ch_send
& RR_TX_BREAK
) == 0) {
1106 * Flush TX data and exit the wait if NDELAY is set,
1107 * or this is not a DIGI printer, and the close timeout
1111 if ((file
->f_flags
& (O_NDELAY
| O_NONBLOCK
)) ||
1112 ((long)(jiffies
- waketime
) >= 0 &&
1113 (ch
->ch_digi
.digi_flags
& DIGI_PRINTER
) == 0)) {
1116 * If we sent the printer off string, we cannot
1117 * flush our internal buffers, or we might lose
1120 if (!sent_printer_offstr
)
1121 dgrp_tty_flush_buffer(tty
);
1123 tty_ldisc_flush(tty
);
1128 * Otherwise take a short nap.
1131 ch
->ch_flag
|= CH_DRAIN
;
1133 spin_unlock_irqrestore(&nd
->nd_lock
, lock_flags
);
1135 schedule_timeout_interruptible(1);
1136 s
= signal_pending(current
);
1138 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
1142 * If we had sent the printer off string, we now have
1145 * The system won't let us sleep since we got an error
1146 * back from sleep, presumably because the user did
1148 * But we need to ensure that the offstr gets sent!
1149 * Thus, we have to do something else besides sleeping.
1151 * 1) Make this task uninterruptable.
1152 * 2) Set up a timer to go off in 1 sec.
1153 * 3) Act as tho we just got out of the sleep above.
1155 * Thankfully, in the real world, this just
1159 if (sent_printer_offstr
) {
1160 spin_unlock_irqrestore(&nd
->nd_lock
,
1163 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
1171 * Restart the wait if any progress is seen.
1174 if (ch
->ch_s_tpos
!= tpos
) {
1175 tpos
= ch
->ch_s_tpos
;
1177 /* TODO: this gives us timeout problems with nist ?? */
1178 waketime
= jiffies
+ 15 * HZ
;
1183 * Close the line discipline
1186 /* this is done in tty_io.c */
1187 /* if ((un->un_tty)->ldisc.close)
1188 * ((un->un_tty)->ldisc.close)(un->un_tty);
1191 /* don't do this here */
1192 /* un->un_flag = 0; */
1195 * Flush the receive buffer on terminal unit close only.
1198 if (!IS_PRINT(MINOR(tty_devnum(tty
))))
1199 ch
->ch_rout
= ch
->ch_rin
;
1203 * Don't permit the close to happen until we get any pending
1204 * sync request responses.
1205 * There could be other ports depending upon the response as well.
1207 * Also, don't permit the close to happen until any parameter
1208 * changes have been sent out from the state machine as well.
1209 * This is required because of a ditty -a race with -HUPCL
1210 * We MUST make sure all channel parameters have been sent to the
1211 * Portserver before sending a close.
1214 if ((err
!= 1) && (ch
->ch_state
!= CS_IDLE
)) {
1215 spin_unlock_irqrestore(&nd
->nd_lock
, lock_flags
);
1216 s
= wait_event_interruptible(ch
->ch_flag_wait
,
1217 ((ch
->ch_flag
& (CH_WAITING_SYNC
| CH_PARAM
)) == 0));
1218 spin_lock_irqsave(&nd
->nd_lock
, lock_flags
);
1222 * Cleanup the channel if last unit open.
1225 if (ch
->ch_open_count
== 1) {
1227 ch
->ch_category
= 0;
1230 ch
->ch_tout
= ch
->ch_tin
;
1231 /* (un->un_tty)->device = 0; */
1233 if (ch
->ch_state
== CS_READY
)
1234 ch
->ch_state
= CS_SEND_CLOSE
;
1238 * Send the changes to the server
1240 if (ch
->ch_state
!= CS_IDLE
) {
1241 ch
->ch_flag
|= CH_PARAM
;
1242 wake_up_interruptible(&ch
->ch_flag_wait
);
1246 nd
->nd_tx_ready
= 1;
1251 if (ch
->ch_open_count
<= 0)
1253 "%s - unexpected value for ch->ch_open_count: %i\n",
1254 __func__
, ch
->ch_open_count
);
1256 ch
->ch_open_count
--;
1258 if (un
->un_open_count
<= 0)
1260 "%s - unexpected value for un->un_open_count: %i\n",
1261 __func__
, un
->un_open_count
);
1263 un
->un_open_count
--;
1265 un
->un_flag
&= ~(UN_NORMAL_ACTIVE
| UN_CALLOUT_ACTIVE
| UN_CLOSING
);
1266 if (waitqueue_active(&un
->un_close_wait
))
1267 wake_up_interruptible(&un
->un_close_wait
);
1269 spin_unlock_irqrestore(&nd
->nd_lock
, lock_flags
);
1275 static void drp_wmove(struct ch_struct
*ch
, int from_user
, void *buf
, int count
)
1280 ch
->ch_nd
->nd_tx_work
= 1;
1282 n
= TBUF_MAX
- ch
->ch_tin
;
1286 ret
= copy_from_user(ch
->ch_tbuf
+ ch
->ch_tin
,
1287 (void __user
*) buf
, n
);
1289 memcpy(ch
->ch_tbuf
+ ch
->ch_tin
, buf
, n
);
1291 buf
= (char *) buf
+ n
;
1297 ret
= copy_from_user(ch
->ch_tbuf
+ ch
->ch_tin
,
1298 (void __user
*) buf
, count
);
1300 memcpy(ch
->ch_tbuf
+ ch
->ch_tin
, buf
, count
);
1302 ch
->ch_tin
+= count
;
1306 static int dgrp_calculate_txprint_bounds(struct ch_struct
*ch
, int space
,
1311 unsigned short tmax
= 0;
1314 * If the terminal device is busy, reschedule when
1315 * the terminal device becomes idle.
1318 if (ch
->ch_tun
.un_open_count
!= 0 &&
1319 ch
->ch_tun
.un_tty
->ops
->chars_in_buffer
&&
1320 ((ch
->ch_tun
.un_tty
->ops
->chars_in_buffer
)(ch
->ch_tun
.un_tty
) != 0)) {
1321 *un_flag
= UN_PWAIT
;
1326 * Assure that whenever there is printer data in the output
1327 * buffer, there always remains enough space after it to
1328 * turn the printer off.
1330 space
-= ch
->ch_digi
.digi_offlen
;
1333 *un_flag
= UN_EMPTY
;
1338 * We measure printer CPS speed by incrementing
1339 * ch_cpstime by (HZ / digi_maxcps) for every
1340 * character we output, restricting output so
1341 * that ch_cpstime never exceeds lbolt.
1343 * However if output has not been done for some
1344 * time, lbolt will grow to very much larger than
1345 * ch_cpstime, which would allow essentially
1346 * unlimited amounts of output until ch_cpstime
1347 * finally caught up. To avoid this, we adjust
1348 * cps_time when necessary so the difference
1349 * between lbolt and ch_cpstime never results
1350 * in sending more than digi_bufsize characters.
1352 * This nicely models a printer with an internal
1353 * buffer of digi_bufsize characters.
1355 * Get the time between lbolt and ch->ch_cpstime;
1358 tt
= jiffies
- ch
->ch_cpstime
;
1361 * Compute the time required to send digi_bufsize
1365 mt
= HZ
* ch
->ch_digi
.digi_bufsize
/ ch
->ch_digi
.digi_maxcps
;
1368 * Compute the number of characters that can be sent
1369 * without violating the time constraint. If the
1370 * direct calculation of this number is bigger than
1371 * digi_bufsize, limit the number to digi_bufsize,
1372 * and adjust cpstime to match.
1375 if ((clock_t)(tt
+ HZ
) > (clock_t)(mt
+ HZ
)) {
1376 tmax
= ch
->ch_digi
.digi_bufsize
;
1377 ch
->ch_cpstime
= jiffies
- mt
;
1379 tmax
= ch
->ch_digi
.digi_maxcps
* tt
/ HZ
;
1383 * If the time constraint now binds, limit the transmit
1384 * count accordingly, and tentatively arrange to be
1385 * rescheduled based on time.
1394 * Compute the total number of characters we can
1395 * output before the total number of characters known
1396 * to be in the output queue exceeds digi_maxchar.
1399 tmax
= (ch
->ch_digi
.digi_maxchar
-
1400 ((ch
->ch_tin
- ch
->ch_tout
) & TBUF_MASK
) -
1401 ((ch
->ch_s_tin
- ch
->ch_s_tpos
) & 0xffff));
1405 * If the digi_maxchar constraint now holds, limit
1406 * the transmit count accordingly, and arrange to
1407 * be rescheduled when the queue becomes empty.
1411 *un_flag
= UN_EMPTY
;
1416 *un_flag
|= UN_EMPTY
;
1422 static int dgrp_tty_write(struct tty_struct
*tty
,
1423 const unsigned char *buf
,
1426 struct nd_struct
*nd
;
1427 struct un_struct
*un
;
1428 struct ch_struct
*ch
;
1439 un
= tty
->driver_data
;
1452 * Ignore the request if the channel is not ready.
1454 if (ch
->ch_state
!= CS_READY
)
1457 spin_lock_irqsave(&dgrp_poll_data
.poll_lock
, lock_flags
);
1460 * Ignore the request if output is blocked.
1462 if ((un
->un_flag
& (UN_EMPTY
| UN_LOW
| UN_TIME
| UN_PWAIT
)) != 0) {
1468 * Also ignore the request if DPA has this port open,
1469 * and is flow controlled on reading more data.
1471 if (nd
->nd_dpa_debug
&& nd
->nd_dpa_flag
& DPA_WAIT_SPACE
&&
1472 nd
->nd_dpa_port
== MINOR(tty_devnum(ch
->ch_tun
.un_tty
))) {
1478 * Limit amount we will write to the amount of space
1479 * available in the channel buffer.
1483 space
= (ch
->ch_tout
- ch
->ch_tin
- 1) & TBUF_MASK
;
1486 * Handle the printer device.
1491 if (IS_PRINT(MINOR(tty_devnum(tty
)))) {
1494 unsigned short tmax
= 0;
1497 * If the terminal device is busy, reschedule when
1498 * the terminal device becomes idle.
1501 if (ch
->ch_tun
.un_open_count
!= 0 &&
1502 ((ch
->ch_tun
.un_tty
->ops
->chars_in_buffer
)(ch
->ch_tun
.un_tty
) != 0)) {
1503 un
->un_flag
|= UN_PWAIT
;
1509 * Assure that whenever there is printer data in the output
1510 * buffer, there always remains enough space after it to
1511 * turn the printer off.
1513 space
-= ch
->ch_digi
.digi_offlen
;
1516 * Output the printer on string.
1519 if ((ch
->ch_flag
& CH_PRON
) == 0) {
1520 space
-= ch
->ch_digi
.digi_onlen
;
1523 un
->un_flag
|= UN_EMPTY
;
1524 (ch
->ch_nd
)->nd_tx_work
= 1;
1529 drp_wmove(ch
, 0, ch
->ch_digi
.digi_onstr
,
1530 ch
->ch_digi
.digi_onlen
);
1532 ch
->ch_flag
|= CH_PRON
;
1536 * We measure printer CPS speed by incrementing
1537 * ch_cpstime by (HZ / digi_maxcps) for every
1538 * character we output, restricting output so
1539 * that ch_cpstime never exceeds lbolt.
1541 * However if output has not been done for some
1542 * time, lbolt will grow to very much larger than
1543 * ch_cpstime, which would allow essentially
1544 * unlimited amounts of output until ch_cpstime
1545 * finally caught up. To avoid this, we adjust
1546 * cps_time when necessary so the difference
1547 * between lbolt and ch_cpstime never results
1548 * in sending more than digi_bufsize characters.
1550 * This nicely models a printer with an internal
1551 * buffer of digi_bufsize characters.
1553 * Get the time between lbolt and ch->ch_cpstime;
1556 tt
= jiffies
- ch
->ch_cpstime
;
1559 * Compute the time required to send digi_bufsize
1563 mt
= HZ
* ch
->ch_digi
.digi_bufsize
/ ch
->ch_digi
.digi_maxcps
;
1566 * Compute the number of characters that can be sent
1567 * without violating the time constraint. If the
1568 * direct calculation of this number is bigger than
1569 * digi_bufsize, limit the number to digi_bufsize,
1570 * and adjust cpstime to match.
1573 if ((clock_t)(tt
+ HZ
) > (clock_t)(mt
+ HZ
)) {
1574 tmax
= ch
->ch_digi
.digi_bufsize
;
1575 ch
->ch_cpstime
= jiffies
- mt
;
1577 tmax
= ch
->ch_digi
.digi_maxcps
* tt
/ HZ
;
1581 * If the time constraint now binds, limit the transmit
1582 * count accordingly, and tentatively arrange to be
1583 * rescheduled based on time.
1592 * Compute the total number of characters we can
1593 * output before the total number of characters known
1594 * to be in the output queue exceeds digi_maxchar.
1597 tmax
= (ch
->ch_digi
.digi_maxchar
-
1598 ((ch
->ch_tin
- ch
->ch_tout
) & TBUF_MASK
) -
1599 ((ch
->ch_s_tin
- ch
->ch_s_tpos
) & 0xffff));
1603 * If the digi_maxchar constraint now holds, limit
1604 * the transmit count accordingly, and arrange to
1605 * be rescheduled when the queue becomes empty.
1615 * Handle the terminal device.
1620 * If the printer device is on, turn it off.
1623 if ((ch
->ch_flag
& CH_PRON
) != 0) {
1625 space
-= ch
->ch_digi
.digi_offlen
;
1627 drp_wmove(ch
, 0, ch
->ch_digi
.digi_offstr
,
1628 ch
->ch_digi
.digi_offlen
);
1630 ch
->ch_flag
&= ~CH_PRON
;
1635 * If space is 0 and its because the ch->tbuf
1636 * is full, then Linux will handle a callback when queue
1637 * space becomes available.
1638 * tty_write returns count = 0
1642 /* the linux tty_io.c handles this if we return 0 */
1643 /* if (fp->flags & O_NONBLOCK) return -EAGAIN; */
1645 un
->un_flag
|= UN_EMPTY
;
1646 (ch
->ch_nd
)->nd_tx_work
= 1;
1651 count
= min(count
, space
);
1658 * Copy the buffer contents to the ch_tbuf
1659 * being careful to wrap around the circular queue
1662 t
= TBUF_MAX
- ch
->ch_tin
;
1666 memcpy(ch
->ch_tbuf
+ ch
->ch_tin
, buf
, t
);
1667 if (nd
->nd_dpa_debug
&& nd
->nd_dpa_port
== PORT_NUM(MINOR(tty_devnum(un
->un_tty
))))
1668 dgrp_dpa_data(nd
, 0, (char *) buf
, t
);
1675 memcpy(ch
->ch_tbuf
+ ch
->ch_tin
, buf
, n
);
1676 if (nd
->nd_dpa_debug
&& nd
->nd_dpa_port
== PORT_NUM(MINOR(tty_devnum(un
->un_tty
))))
1677 dgrp_dpa_data(nd
, 0, (char *) buf
, n
);
1683 (ch
->ch_nd
)->nd_tx_work
= 1;
1684 if (ch
->ch_edelay
!= DGRP_RTIME
) {
1685 (ch
->ch_nd
)->nd_tx_ready
= 1;
1686 wake_up_interruptible(&nd
->nd_tx_waitq
);
1690 ch
->ch_txcount
+= count
;
1692 if (IS_PRINT(MINOR(tty_devnum(tty
)))) {
1695 * Adjust ch_cpstime to account
1696 * for the characters just output.
1699 if (sendcount
> 0) {
1700 int cc
= HZ
* sendcount
+ ch
->ch_cpsrem
;
1702 ch
->ch_cpstime
+= cc
/ ch
->ch_digi
.digi_maxcps
;
1703 ch
->ch_cpsrem
= cc
% ch
->ch_digi
.digi_maxcps
;
1707 * If we are now waiting on time, schedule ourself
1708 * back when we'll be able to send a block of
1709 * digi_maxchar characters.
1712 if ((un_flag
& UN_TIME
) != 0) {
1713 ch
->ch_waketime
= (ch
->ch_cpstime
+
1714 (ch
->ch_digi
.digi_maxchar
* HZ
/
1715 ch
->ch_digi
.digi_maxcps
));
1720 * If the printer unit is waiting for completion
1721 * of terminal output, get him going again.
1724 if ((ch
->ch_pun
.un_flag
& UN_PWAIT
) != 0)
1725 (ch
->ch_nd
)->nd_tx_work
= 1;
1728 spin_unlock_irqrestore(&dgrp_poll_data
.poll_lock
, lock_flags
);
1735 * Put a character into ch->ch_buf
1737 * - used by the line discipline for OPOST processing
1740 static int dgrp_tty_put_char(struct tty_struct
*tty
, unsigned char new_char
)
1742 struct un_struct
*un
;
1743 struct ch_struct
*ch
;
1751 un
= tty
->driver_data
;
1759 if (ch
->ch_state
!= CS_READY
)
1762 spin_lock_irqsave(&dgrp_poll_data
.poll_lock
, lock_flags
);
1766 * If space is 0 and its because the ch->tbuf
1767 * Warn and dump the character, there isn't anything else
1768 * we can do about it. David_Fries@digi.com
1771 space
= (ch
->ch_tout
- ch
->ch_tin
- 1) & TBUF_MASK
;
1776 * Output the printer on string if device is TXPrint.
1778 if (IS_PRINT(MINOR(tty_devnum(tty
))) && (ch
->ch_flag
& CH_PRON
) == 0) {
1779 if (space
< ch
->ch_digi
.digi_onlen
) {
1783 space
-= ch
->ch_digi
.digi_onlen
;
1784 drp_wmove(ch
, 0, ch
->ch_digi
.digi_onstr
,
1785 ch
->ch_digi
.digi_onlen
);
1786 ch
->ch_flag
|= CH_PRON
;
1790 * Output the printer off string if device is NOT TXPrint.
1793 if (!IS_PRINT(MINOR(tty_devnum(tty
))) &&
1794 ((ch
->ch_flag
& CH_PRON
) != 0)) {
1795 if (space
< ch
->ch_digi
.digi_offlen
) {
1800 space
-= ch
->ch_digi
.digi_offlen
;
1801 drp_wmove(ch
, 0, ch
->ch_digi
.digi_offstr
,
1802 ch
->ch_digi
.digi_offlen
);
1803 ch
->ch_flag
&= ~CH_PRON
;
1812 * Copy the character to the ch_tbuf being
1813 * careful to wrap around the circular queue
1815 ch
->ch_tbuf
[ch
->ch_tin
] = new_char
;
1816 ch
->ch_tin
= (1 + ch
->ch_tin
) & TBUF_MASK
;
1818 if (IS_PRINT(MINOR(tty_devnum(tty
)))) {
1821 * Adjust ch_cpstime to account
1822 * for the character just output.
1825 int cc
= HZ
+ ch
->ch_cpsrem
;
1827 ch
->ch_cpstime
+= cc
/ ch
->ch_digi
.digi_maxcps
;
1828 ch
->ch_cpsrem
= cc
% ch
->ch_digi
.digi_maxcps
;
1831 * If we are now waiting on time, schedule ourself
1832 * back when we'll be able to send a block of
1833 * digi_maxchar characters.
1836 ch
->ch_waketime
= (ch
->ch_cpstime
+
1837 (ch
->ch_digi
.digi_maxchar
* HZ
/
1838 ch
->ch_digi
.digi_maxcps
));
1843 (ch
->ch_nd
)->nd_tx_work
= 1;
1847 spin_unlock_irqrestore(&dgrp_poll_data
.poll_lock
, lock_flags
);
1854 * Flush TX buffer (make in == out)
1856 * check tty_ioctl.c -- this is called after TCOFLUSH
1858 static void dgrp_tty_flush_buffer(struct tty_struct
*tty
)
1860 struct un_struct
*un
;
1861 struct ch_struct
*ch
;
1865 un
= tty
->driver_data
;
1873 ch
->ch_tout
= ch
->ch_tin
;
1874 /* do NOT do this here! */
1875 /* ch->ch_s_tpos = ch->ch_s_tin = 0; */
1877 /* send the flush output command now */
1878 ch
->ch_send
|= RR_TX_FLUSH
;
1879 (ch
->ch_nd
)->nd_tx_ready
= 1;
1880 (ch
->ch_nd
)->nd_tx_work
= 1;
1881 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
1883 if (waitqueue_active(&tty
->write_wait
))
1884 wake_up_interruptible(&tty
->write_wait
);
1891 * Return space available in Tx buffer
1892 * count = ( ch->ch_tout - ch->ch_tin ) mod (TBUF_MAX - 1)
1894 static int dgrp_tty_write_room(struct tty_struct
*tty
)
1896 struct un_struct
*un
;
1897 struct ch_struct
*ch
;
1903 un
= tty
->driver_data
;
1911 count
= (ch
->ch_tout
- ch
->ch_tin
- 1) & TBUF_MASK
;
1913 /* We *MUST* check this, and return 0 if the Printer Unit cannot
1914 * take any more data within its time constraints... If we don't
1915 * return 0 and the printer has hit it time constraint, the ld will
1916 * call us back doing a put_char, which cannot be rejected!!!
1918 if (IS_PRINT(MINOR(tty_devnum(tty
)))) {
1920 count
= dgrp_calculate_txprint_bounds(ch
, count
, &un_flag
);
1924 ch
->ch_pun
.un_flag
|= un_flag
;
1925 (ch
->ch_nd
)->nd_tx_work
= 1;
1932 * Return number of characters that have not been transmitted yet.
1933 * chars_in_buffer = ( ch->ch_tin - ch->ch_tout ) mod (TBUF_MAX - 1)
1934 * + ( ch->ch_s_tin - ch->ch_s_tout ) mod (0xffff)
1935 * = number of characters "in transit"
1937 * Remember that sequence number math is always with a sixteen bit
1938 * mask, not the TBUF_MASK.
1941 static int dgrp_tty_chars_in_buffer(struct tty_struct
*tty
)
1943 struct un_struct
*un
;
1944 struct ch_struct
*ch
;
1951 un
= tty
->driver_data
;
1959 count1
= count
= (ch
->ch_tin
- ch
->ch_tout
) & TBUF_MASK
;
1960 count
+= (ch
->ch_s_tin
- ch
->ch_s_tpos
) & 0xffff;
1961 /* one for tbuf, one for the PS */
1964 * If we are busy transmitting add 1
1966 count
+= un
->un_tbusy
;
1972 /*****************************************************************************
1974 * Helper applications for dgrp_tty_ioctl()
1976 *****************************************************************************
1981 * ch_to_tty_flags() -- convert channel flags to termio flags
1982 * @ch_flag: Digi channel flags
1983 * @flagtype: type of ch_flag (iflag, oflag or cflag)
1985 * take the channel flags of the specified type and return the
1986 * corresponding termio flag
1988 static tcflag_t
ch_to_tty_flags(ushort ch_flag
, char flagtype
)
1990 tcflag_t retval
= 0;
1994 retval
= ((ch_flag
& IF_IGNBRK
) ? IGNBRK
: 0)
1995 | ((ch_flag
& IF_BRKINT
) ? BRKINT
: 0)
1996 | ((ch_flag
& IF_IGNPAR
) ? IGNPAR
: 0)
1997 | ((ch_flag
& IF_PARMRK
) ? PARMRK
: 0)
1998 | ((ch_flag
& IF_INPCK
) ? INPCK
: 0)
1999 | ((ch_flag
& IF_ISTRIP
) ? ISTRIP
: 0)
2000 | ((ch_flag
& IF_IXON
) ? IXON
: 0)
2001 | ((ch_flag
& IF_IXANY
) ? IXANY
: 0)
2002 | ((ch_flag
& IF_IXOFF
) ? IXOFF
: 0);
2006 retval
= ((ch_flag
& OF_OLCUC
) ? OLCUC
: 0)
2007 | ((ch_flag
& OF_ONLCR
) ? ONLCR
: 0)
2008 | ((ch_flag
& OF_OCRNL
) ? OCRNL
: 0)
2009 | ((ch_flag
& OF_ONOCR
) ? ONOCR
: 0)
2010 | ((ch_flag
& OF_ONLRET
) ? ONLRET
: 0)
2011 /* | ((ch_flag & OF_OTAB3) ? OFILL : 0) */
2012 | ((ch_flag
& OF_TABDLY
) ? TABDLY
: 0);
2016 retval
= ((ch_flag
& CF_CSTOPB
) ? CSTOPB
: 0)
2017 | ((ch_flag
& CF_CREAD
) ? CREAD
: 0)
2018 | ((ch_flag
& CF_PARENB
) ? PARENB
: 0)
2019 | ((ch_flag
& CF_PARODD
) ? PARODD
: 0)
2020 | ((ch_flag
& CF_HUPCL
) ? HUPCL
: 0);
2022 switch (ch_flag
& CF_CSIZE
) {
2053 * tty_to_ch_flags() -- convert termio flags to digi channel flags
2054 * @tty: pointer to a TTY structure holding flag to be converted
2055 * @flagtype: identifies which flag (iflags, oflags, or cflags) should
2058 * take the termio flag of the specified type and return the
2059 * corresponding Digi version of the flags
2061 static ushort
tty_to_ch_flags(struct tty_struct
*tty
, char flagtype
)
2068 tflag
= tty
->termios
.c_iflag
;
2069 retval
= (I_IGNBRK(tty
) ? IF_IGNBRK
: 0)
2070 | (I_BRKINT(tty
) ? IF_BRKINT
: 0)
2071 | (I_IGNPAR(tty
) ? IF_IGNPAR
: 0)
2072 | (I_PARMRK(tty
) ? IF_PARMRK
: 0)
2073 | (I_INPCK(tty
) ? IF_INPCK
: 0)
2074 | (I_ISTRIP(tty
) ? IF_ISTRIP
: 0)
2075 | (I_IXON(tty
) ? IF_IXON
: 0)
2076 | (I_IXANY(tty
) ? IF_IXANY
: 0)
2077 | (I_IXOFF(tty
) ? IF_IXOFF
: 0);
2080 tflag
= tty
->termios
.c_oflag
;
2082 * If OPOST is set, then do the post processing in the
2083 * firmware by setting all the processing flags on.
2084 * If ~OPOST, then make sure we are not doing any
2085 * output processing!!
2090 retval
= (O_OLCUC(tty
) ? OF_OLCUC
: 0)
2091 | (O_ONLCR(tty
) ? OF_ONLCR
: 0)
2092 | (O_OCRNL(tty
) ? OF_OCRNL
: 0)
2093 | (O_ONOCR(tty
) ? OF_ONOCR
: 0)
2094 | (O_ONLRET(tty
) ? OF_ONLRET
: 0)
2095 /* | (O_OFILL(tty) ? OF_TAB3 : 0) */
2096 | (O_TABDLY(tty
) ? OF_TABDLY
: 0);
2099 tflag
= tty
->termios
.c_cflag
;
2100 retval
= (C_CSTOPB(tty
) ? CF_CSTOPB
: 0)
2101 | (C_CREAD(tty
) ? CF_CREAD
: 0)
2102 | (C_PARENB(tty
) ? CF_PARENB
: 0)
2103 | (C_PARODD(tty
) ? CF_PARODD
: 0)
2104 | (C_HUPCL(tty
) ? CF_HUPCL
: 0);
2105 switch (C_CSIZE(tty
)) {
2135 static int dgrp_tty_send_break(struct tty_struct
*tty
, int msec
)
2137 struct un_struct
*un
;
2138 struct ch_struct
*ch
;
2144 un
= tty
->driver_data
;
2152 dgrp_send_break(ch
, msec
);
2158 * This routine sends a break character out the serial port.
2160 * duration is in 1/1000's of a second
2162 static int dgrp_send_break(struct ch_struct
*ch
, int msec
)
2166 wait_event_interruptible(ch
->ch_flag_wait
,
2167 ((ch
->ch_flag
& CH_TX_BREAK
) == 0));
2168 ch
->ch_break_time
+= max(msec
, 250);
2169 ch
->ch_send
|= RR_TX_BREAK
;
2170 ch
->ch_flag
|= CH_TX_BREAK
;
2171 (ch
->ch_nd
)->nd_tx_work
= 1;
2173 x
= (msec
* HZ
) / 1000;
2174 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2181 * Return modem signals to ld.
2183 static int dgrp_tty_tiocmget(struct tty_struct
*tty
)
2186 struct un_struct
*un
= tty
->driver_data
;
2187 struct ch_struct
*ch
;
2196 mlast
= ((ch
->ch_s_mlast
& ~(DM_RTS
| DM_DTR
)) |
2197 (ch
->ch_mout
& (DM_RTS
| DM_DTR
)));
2199 /* defined in /usr/include/asm/termios.h */
2200 mlast
= ((mlast
& DM_RTS
) ? TIOCM_RTS
: 0)
2201 | ((mlast
& DM_DTR
) ? TIOCM_DTR
: 0)
2202 | ((mlast
& DM_CD
) ? TIOCM_CAR
: 0)
2203 | ((mlast
& DM_RI
) ? TIOCM_RNG
: 0)
2204 | ((mlast
& DM_DSR
) ? TIOCM_DSR
: 0)
2205 | ((mlast
& DM_CTS
) ? TIOCM_CTS
: 0);
2214 static int dgrp_tty_tiocmset(struct tty_struct
*tty
,
2215 unsigned int set
, unsigned int clear
)
2218 struct un_struct
*un
= tty
->driver_data
;
2219 struct ch_struct
*ch
;
2228 if (set
& TIOCM_RTS
)
2229 ch
->ch_mout
|= DM_RTS
;
2231 if (set
& TIOCM_DTR
)
2232 ch
->ch_mout
|= DM_DTR
;
2234 if (clear
& TIOCM_RTS
)
2235 ch
->ch_mout
&= ~(DM_RTS
);
2237 if (clear
& TIOCM_DTR
)
2238 ch
->ch_mout
&= ~(DM_DTR
);
2240 spin_lock_irqsave(&(ch
->ch_nd
)->nd_lock
, lock_flags
);
2241 ch
->ch_flag
|= CH_PARAM
;
2242 (ch
->ch_nd
)->nd_tx_work
= 1;
2243 wake_up_interruptible(&ch
->ch_flag_wait
);
2245 spin_unlock_irqrestore(&(ch
->ch_nd
)->nd_lock
, lock_flags
);
2253 * Get current modem status
2255 static int get_modem_info(struct ch_struct
*ch
, unsigned int *value
)
2259 mlast
= ((ch
->ch_s_mlast
& ~(DM_RTS
| DM_DTR
)) |
2260 (ch
->ch_mout
& (DM_RTS
| DM_DTR
)));
2262 /* defined in /usr/include/asm/termios.h */
2263 mlast
= ((mlast
& DM_RTS
) ? TIOCM_RTS
: 0)
2264 | ((mlast
& DM_DTR
) ? TIOCM_DTR
: 0)
2265 | ((mlast
& DM_CD
) ? TIOCM_CAR
: 0)
2266 | ((mlast
& DM_RI
) ? TIOCM_RNG
: 0)
2267 | ((mlast
& DM_DSR
) ? TIOCM_DSR
: 0)
2268 | ((mlast
& DM_CTS
) ? TIOCM_CTS
: 0);
2269 return put_user(mlast
, (unsigned int __user
*) value
);
2275 static int set_modem_info(struct ch_struct
*ch
, unsigned int command
,
2276 unsigned int *value
)
2283 error
= access_ok(VERIFY_READ
, (void __user
*) value
, sizeof(int));
2287 if (get_user(arg
, (unsigned int __user
*) value
))
2289 mval
|= ((arg
& TIOCM_RTS
) ? DM_RTS
: 0)
2290 | ((arg
& TIOCM_DTR
) ? DM_DTR
: 0);
2293 case TIOCMBIS
: /* set flags */
2294 ch
->ch_mout
|= mval
;
2296 case TIOCMBIC
: /* clear flags */
2297 ch
->ch_mout
&= ~mval
;
2306 spin_lock_irqsave(&(ch
->ch_nd
)->nd_lock
, lock_flags
);
2308 ch
->ch_flag
|= CH_PARAM
;
2309 (ch
->ch_nd
)->nd_tx_work
= 1;
2310 wake_up_interruptible(&ch
->ch_flag_wait
);
2312 spin_unlock_irqrestore(&(ch
->ch_nd
)->nd_lock
, lock_flags
);
2319 * Assign the custom baud rate to the channel structure
2321 static void dgrp_set_custom_speed(struct ch_struct
*ch
, int newrate
)
2327 int deltahigh
, deltalow
;
2333 * Since the divisor is stored in a 16-bit integer, we make sure
2334 * we don't allow any rates smaller than a 16-bit integer would allow.
2335 * And of course, rates above the dividend won't fly.
2337 if (newrate
&& newrate
< ((PORTSERVER_DIVIDEND
/ 0xFFFF) + 1))
2338 newrate
= ((PORTSERVER_DIVIDEND
/ 0xFFFF) + 1);
2339 if (newrate
&& newrate
> PORTSERVER_DIVIDEND
)
2340 newrate
= PORTSERVER_DIVIDEND
;
2342 while (newrate
> 0) {
2343 testdiv
= PORTSERVER_DIVIDEND
/ newrate
;
2346 * If we try to figure out what rate the PortServer would use
2347 * with the test divisor, it will be either equal or higher
2348 * than the requested baud rate. If we then determine the
2349 * rate with a divisor one higher, we will get the next lower
2350 * supported rate below the requested.
2352 testrate_high
= PORTSERVER_DIVIDEND
/ testdiv
;
2353 testrate_low
= PORTSERVER_DIVIDEND
/ (testdiv
+ 1);
2356 * If the rate for the requested divisor is correct, just
2357 * use it and be done.
2359 if (testrate_high
== newrate
)
2363 * Otherwise, pick the rate that is closer (i.e. whichever rate
2364 * has a smaller delta).
2366 deltahigh
= testrate_high
- newrate
;
2367 deltalow
= newrate
- testrate_low
;
2369 if (deltahigh
< deltalow
)
2370 newrate
= testrate_high
;
2372 newrate
= testrate_low
;
2377 ch
->ch_custom_speed
= newrate
;
2386 # dgrp_tty_digiseta()
2388 * Ioctl to set the information from ditty.
2390 * NOTE: DIGI_IXON, DSRPACE, DCDPACE, and DTRPACE are unsupported. JAR 990922
2392 static int dgrp_tty_digiseta(struct tty_struct
*tty
,
2393 struct digi_struct
*new_info
)
2395 struct un_struct
*un
= tty
->driver_data
;
2396 struct ch_struct
*ch
;
2405 if (copy_from_user(&ch
->ch_digi
, (void __user
*) new_info
,
2406 sizeof(struct digi_struct
)))
2409 if ((ch
->ch_digi
.digi_flags
& RTSPACE
) ||
2410 (ch
->ch_digi
.digi_flags
& CTSPACE
))
2411 tty
->termios
.c_cflag
|= CRTSCTS
;
2413 tty
->termios
.c_cflag
&= ~CRTSCTS
;
2415 if (ch
->ch_digi
.digi_maxcps
< 1)
2416 ch
->ch_digi
.digi_maxcps
= 1;
2418 if (ch
->ch_digi
.digi_maxcps
> 10000)
2419 ch
->ch_digi
.digi_maxcps
= 10000;
2421 if (ch
->ch_digi
.digi_bufsize
< 10)
2422 ch
->ch_digi
.digi_bufsize
= 10;
2424 if (ch
->ch_digi
.digi_maxchar
< 1)
2425 ch
->ch_digi
.digi_maxchar
= 1;
2427 if (ch
->ch_digi
.digi_maxchar
> ch
->ch_digi
.digi_bufsize
)
2428 ch
->ch_digi
.digi_maxchar
= ch
->ch_digi
.digi_bufsize
;
2430 if (ch
->ch_digi
.digi_onlen
> DIGI_PLEN
)
2431 ch
->ch_digi
.digi_onlen
= DIGI_PLEN
;
2433 if (ch
->ch_digi
.digi_offlen
> DIGI_PLEN
)
2434 ch
->ch_digi
.digi_offlen
= DIGI_PLEN
;
2436 /* make the changes now */
2445 * dgrp_tty_digigetedelay()
2447 * Ioctl to get the current edelay setting.
2452 static int dgrp_tty_digigetedelay(struct tty_struct
*tty
, int *retinfo
)
2454 struct un_struct
*un
;
2455 struct ch_struct
*ch
;
2461 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2464 un
= tty
->driver_data
;
2473 tmp
= ch
->ch_edelay
;
2475 if (copy_to_user((void __user
*) retinfo
, &tmp
, sizeof(*retinfo
)))
2483 * dgrp_tty_digisetedelay()
2485 * Ioctl to set the EDELAY setting
2488 static int dgrp_tty_digisetedelay(struct tty_struct
*tty
, int *new_info
)
2490 struct un_struct
*un
;
2491 struct ch_struct
*ch
;
2494 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2497 un
= tty
->driver_data
;
2506 if (copy_from_user(&new_digi
, (void __user
*)new_info
, sizeof(int)))
2509 ch
->ch_edelay
= new_digi
;
2511 /* make the changes now */
2519 * The usual assortment of ioctl's
2521 * note: use tty_check_change to make sure that we are not
2522 * changing the state of a terminal when we are not a process
2523 * in the forground. See tty_io.c
2524 * rc = tty_check_change(tty);
2525 * if (rc) return rc;
2527 static int dgrp_tty_ioctl(struct tty_struct
*tty
, unsigned int cmd
,
2530 struct un_struct
*un
;
2531 struct ch_struct
*ch
;
2533 struct digiflow_struct dflow
;
2538 un
= tty
->driver_data
;
2549 * Here are all the standard ioctl's that we MUST implement
2554 * TCSBRK is SVID version: non-zero arg --> no break
2555 * this behaviour is exploited by tcdrain().
2557 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2558 * between 0.25 and 0.5 seconds
2561 rc
= tty_check_change(tty
);
2564 tty_wait_until_sent(tty
, 0);
2567 rc
= dgrp_send_break(ch
, 250); /* 1/4 second */
2569 if (dgrp_tty_chars_in_buffer(tty
) != 0)
2575 /* support for POSIX tcsendbreak()
2577 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2578 * between 0.25 and 0.5 seconds so we'll ask for something
2579 * in the middle: 0.375 seconds.
2581 rc
= tty_check_change(tty
);
2584 tty_wait_until_sent(tty
, 0);
2586 rc
= dgrp_send_break(ch
, arg
? arg
*250 : 250);
2588 if (dgrp_tty_chars_in_buffer(tty
) != 0)
2593 rc
= tty_check_change(tty
);
2596 tty_wait_until_sent(tty
, 0);
2599 * RealPort doesn't support turning on a break unconditionally.
2600 * The RealPort device will stop sending a break automatically
2601 * after the specified time value that we send in.
2603 rc
= dgrp_send_break(ch
, 250); /* 1/4 second */
2605 if (dgrp_tty_chars_in_buffer(tty
) != 0)
2611 * RealPort doesn't support turning off a break unconditionally.
2612 * The RealPort device will stop sending a break automatically
2613 * after the specified time value that was sent when turning on
2619 rc
= access_ok(VERIFY_WRITE
, (void __user
*) arg
,
2620 sizeof(unsigned int));
2623 return get_modem_info(ch
, (unsigned int *) arg
);
2628 return set_modem_info(ch
, cmd
, (unsigned int *) arg
);
2631 * Here are any additional ioctl's that we want to implement
2636 * The linux tty driver doesn't have a flush
2637 * input routine for the driver, assuming all backed
2638 * up data is in the line disc. buffers. However,
2639 * we all know that's not the case. Here, we
2640 * act on the ioctl, but then lie and say we didn't
2641 * so the line discipline will process the flush
2644 rc
= tty_check_change(tty
);
2651 /* only flush input if this is the only open unit */
2652 if (!IS_PRINT(MINOR(tty_devnum(tty
)))) {
2653 ch
->ch_rout
= ch
->ch_rin
;
2654 ch
->ch_send
|= RR_RX_FLUSH
;
2655 (ch
->ch_nd
)->nd_tx_work
= 1;
2656 (ch
->ch_nd
)->nd_tx_ready
= 1;
2657 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2659 if (arg
== TCIFLUSH
)
2662 case TCOFLUSH
: /* flush output, or the receive buffer */
2664 * This is handled in the tty_ioctl.c code
2665 * calling tty_flush_buffer
2670 /* POSIX.1 says return EINVAL if we got a bad arg */
2673 /* pretend we didn't recognize this IOCTL */
2674 return -ENOIOCTLCMD
;
2679 /*****************************************
2681 TCSETA TCSETA - set the termios
2682 TCSETAF TCSETAF - wait for drain first, then set termios
2683 TCSETAW TCSETAW - wait for drain, flush the input queue, then set termios
2684 - looking at the tty_ioctl code, these command all call our
2685 tty_set_termios at the driver's end, when a TCSETA* is sent,
2686 it is expecting the tty to have a termio structure,
2687 NOT a termios structure. These two structures differ in size
2688 and the tty_ioctl code does a conversion before processing them both.
2689 - we should treat the TCSETAW TCSETAF ioctls the same, and let
2690 the tty_ioctl code do the conversion stuff.
2695 - the associated tty structure has a termios structure.
2696 *****************************************/
2700 return -ENOIOCTLCMD
;
2707 * The linux tty driver doesn't have a flush
2708 * input routine for the driver, assuming all backed
2709 * up data is in the line disc. buffers. However,
2710 * we all know that's not the case. Here, we
2711 * act on the ioctl, but then lie and say we didn't
2712 * so the line discipline will process the flush
2717 * Also, now that we have TXPrint, we have to check
2718 * if this is the TXPrint device and the terminal
2719 * device is open. If so, do NOT run check_change,
2720 * as the terminal device is ALWAYS the parent.
2722 if (!IS_PRINT(MINOR(tty_devnum(tty
))) ||
2723 !ch
->ch_tun
.un_open_count
) {
2724 rc
= tty_check_change(tty
);
2729 /* wait for all the characters in tbuf to drain */
2730 tty_wait_until_sent(tty
, 0);
2732 if ((cmd
== TCSETSF
) || (cmd
== TCSETAF
)) {
2733 /* flush the contents of the rbuf queue */
2734 /* TODO: check if this is print device? */
2735 ch
->ch_send
|= RR_RX_FLUSH
;
2736 (ch
->ch_nd
)->nd_tx_ready
= 1;
2737 (ch
->ch_nd
)->nd_tx_work
= 1;
2738 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2739 /* do we need to do this? just to be safe! */
2740 ch
->ch_rout
= ch
->ch_rin
;
2743 /* pretend we didn't recognize this */
2744 return -ENOIOCTLCMD
;
2748 * The Linux Line Discipline (LD) would do this for us if we
2749 * let it, but we have the special firmware options to do this
2750 * the "right way" regardless of hardware or software flow
2751 * control so we'll do it outselves instead of letting the LD
2754 rc
= tty_check_change(tty
);
2760 dgrp_tty_start(tty
);
2766 dgrp_tty_input_start(tty
);
2769 dgrp_tty_input_stop(tty
);
2776 /* get information for ditty */
2777 if (copy_to_user((struct digi_struct __user
*) arg
,
2778 &ch
->ch_digi
, sizeof(struct digi_struct
)))
2784 /* wait for all the characters in tbuf to drain */
2785 tty_wait_until_sent(tty
, 0);
2787 if (cmd
== DIGI_SETAF
) {
2788 /* flush the contents of the rbuf queue */
2789 /* send down a packet with RR_RX_FLUSH set */
2790 ch
->ch_send
|= RR_RX_FLUSH
;
2791 (ch
->ch_nd
)->nd_tx_ready
= 1;
2792 (ch
->ch_nd
)->nd_tx_work
= 1;
2793 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2794 /* do we need to do this? just to be safe! */
2795 ch
->ch_rout
= ch
->ch_rin
;
2798 /* pretend we didn't recognize this */
2801 return dgrp_tty_digiseta(tty
, (struct digi_struct
*) arg
);
2804 return dgrp_tty_digisetedelay(tty
, (int *) arg
);
2807 return dgrp_tty_digigetedelay(tty
, (int *) arg
);
2811 if (cmd
== (DIGI_GETFLOW
)) {
2812 dflow
.startc
= tty
->termios
.c_cc
[VSTART
];
2813 dflow
.stopc
= tty
->termios
.c_cc
[VSTOP
];
2815 dflow
.startc
= ch
->ch_xxon
;
2816 dflow
.stopc
= ch
->ch_xxoff
;
2819 if (copy_to_user((char __user
*)arg
, &dflow
, sizeof(dflow
)))
2826 if (copy_from_user(&dflow
, (char __user
*)arg
, sizeof(dflow
)))
2829 if (cmd
== (DIGI_SETFLOW
)) {
2830 tty
->termios
.c_cc
[VSTART
] = dflow
.startc
;
2831 tty
->termios
.c_cc
[VSTOP
] = dflow
.stopc
;
2833 ch
->ch_xxon
= dflow
.startc
;
2834 ch
->ch_xxoff
= dflow
.stopc
;
2838 case DIGI_GETCUSTOMBAUD
:
2839 if (put_user(ch
->ch_custom_speed
, (unsigned int __user
*) arg
))
2843 case DIGI_SETCUSTOMBAUD
:
2847 if (get_user(new_rate
, (unsigned int __user
*) arg
))
2849 dgrp_set_custom_speed(ch
, new_rate
);
2855 return -ENOIOCTLCMD
;
2862 * This routine allows the tty driver to be notified when
2863 * the device's termios setting have changed. Note that we
2864 * should be prepared to accept the case where old == NULL
2865 * and try to do something rational.
2867 * So we need to make sure that our copies of ch_oflag,
2868 * ch_clag, and ch_iflag reflect the tty->termios flags.
2870 static void dgrp_tty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
2872 struct ktermios
*ts
;
2873 struct ch_struct
*ch
;
2874 struct un_struct
*un
;
2876 /* seems silly, but we have to check all these! */
2880 un
= tty
->driver_data
;
2892 /* the CLOCAL flag has just been set */
2893 if (!(old
->c_cflag
& CLOCAL
) && C_CLOCAL(tty
))
2894 wake_up_interruptible(&un
->un_open_wait
);
2899 * Throttle receiving data. We just set a bit and stop reading
2900 * data out of the channel buffer. It will back up and the
2901 * FEP will do whatever is necessary to stop the far end.
2903 static void dgrp_tty_throttle(struct tty_struct
*tty
)
2905 struct ch_struct
*ch
;
2910 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
2914 ch
->ch_flag
|= CH_RXSTOP
;
2918 static void dgrp_tty_unthrottle(struct tty_struct
*tty
)
2920 struct ch_struct
*ch
;
2925 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
2929 ch
->ch_flag
&= ~CH_RXSTOP
;
2933 * Stop the transmitter
2935 static void dgrp_tty_stop(struct tty_struct
*tty
)
2937 struct ch_struct
*ch
;
2942 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
2946 ch
->ch_send
|= RR_TX_STOP
;
2947 ch
->ch_send
&= ~RR_TX_START
;
2949 /* make the change NOW! */
2950 (ch
->ch_nd
)->nd_tx_ready
= 1;
2951 if (waitqueue_active(&(ch
->ch_nd
)->nd_tx_waitq
))
2952 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2956 * Start the transmitter
2958 static void dgrp_tty_start(struct tty_struct
*tty
)
2960 struct ch_struct
*ch
;
2965 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
2969 /* TODO: don't do anything if the transmitter is not stopped */
2971 ch
->ch_send
|= RR_TX_START
;
2972 ch
->ch_send
&= ~RR_TX_STOP
;
2974 /* make the change NOW! */
2975 (ch
->ch_nd
)->nd_tx_ready
= 1;
2976 (ch
->ch_nd
)->nd_tx_work
= 1;
2977 if (waitqueue_active(&(ch
->ch_nd
)->nd_tx_waitq
))
2978 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
2985 static void dgrp_tty_input_stop(struct tty_struct
*tty
)
2987 struct ch_struct
*ch
;
2992 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
2996 ch
->ch_send
|= RR_RX_STOP
;
2997 ch
->ch_send
&= ~RR_RX_START
;
2998 (ch
->ch_nd
)->nd_tx_ready
= 1;
2999 if (waitqueue_active(&(ch
->ch_nd
)->nd_tx_waitq
))
3000 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
3005 static void dgrp_tty_send_xchar(struct tty_struct
*tty
, char c
)
3007 struct un_struct
*un
;
3008 struct ch_struct
*ch
;
3013 un
= tty
->driver_data
;
3020 if (c
== STOP_CHAR(tty
))
3021 ch
->ch_send
|= RR_RX_STOP
;
3022 else if (c
== START_CHAR(tty
))
3023 ch
->ch_send
|= RR_RX_START
;
3025 ch
->ch_nd
->nd_tx_ready
= 1;
3026 ch
->ch_nd
->nd_tx_work
= 1;
3032 static void dgrp_tty_input_start(struct tty_struct
*tty
)
3034 struct ch_struct
*ch
;
3039 ch
= ((struct un_struct
*) tty
->driver_data
)->un_ch
;
3043 ch
->ch_send
|= RR_RX_START
;
3044 ch
->ch_send
&= ~RR_RX_STOP
;
3045 (ch
->ch_nd
)->nd_tx_ready
= 1;
3046 (ch
->ch_nd
)->nd_tx_work
= 1;
3047 if (waitqueue_active(&(ch
->ch_nd
)->nd_tx_waitq
))
3048 wake_up_interruptible(&(ch
->ch_nd
)->nd_tx_waitq
);
3054 * Hangup the port. Like a close, but don't wait for output
3057 * How do we close all the channels that are open?
3059 static void dgrp_tty_hangup(struct tty_struct
*tty
)
3061 struct ch_struct
*ch
;
3062 struct nd_struct
*nd
;
3063 struct un_struct
*un
;
3068 un
= tty
->driver_data
;
3080 ch
->ch_mout
&= ~DM_DTR
;
3081 /* Don't do this here */
3082 /* ch->ch_flag |= CH_HANGUP; */
3083 ch
->ch_nd
->nd_tx_ready
= 1;
3084 ch
->ch_nd
->nd_tx_work
= 1;
3085 if (waitqueue_active(&ch
->ch_flag_wait
))
3086 wake_up_interruptible(&ch
->ch_flag_wait
);
3091 /************************************************************************/
3093 /* TTY Initialization/Cleanup Functions */
3095 /************************************************************************/
3098 * Uninitialize the TTY portion of the supplied node. Free all
3099 * memory and resources associated with this node. Do it in reverse
3100 * allocation order: this might possibly result in less fragmentation
3101 * of memory, though I don't know this for sure.
3104 dgrp_tty_uninit(struct nd_struct
*nd
)
3109 ID_TO_CHAR(nd
->nd_ID
, id
);
3111 if (nd
->nd_ttdriver_flags
& SERIAL_TTDRV_REG
) {
3112 tty_unregister_driver(nd
->nd_serial_ttdriver
);
3114 kfree(nd
->nd_serial_ttdriver
->ttys
);
3115 nd
->nd_serial_ttdriver
->ttys
= NULL
;
3117 put_tty_driver(nd
->nd_serial_ttdriver
);
3118 nd
->nd_ttdriver_flags
&= ~SERIAL_TTDRV_REG
;
3121 if (nd
->nd_ttdriver_flags
& CALLOUT_TTDRV_REG
) {
3122 tty_unregister_driver(nd
->nd_callout_ttdriver
);
3124 kfree(nd
->nd_callout_ttdriver
->ttys
);
3125 nd
->nd_callout_ttdriver
->ttys
= NULL
;
3127 put_tty_driver(nd
->nd_callout_ttdriver
);
3128 nd
->nd_ttdriver_flags
&= ~CALLOUT_TTDRV_REG
;
3131 if (nd
->nd_ttdriver_flags
& XPRINT_TTDRV_REG
) {
3132 tty_unregister_driver(nd
->nd_xprint_ttdriver
);
3134 kfree(nd
->nd_xprint_ttdriver
->ttys
);
3135 nd
->nd_xprint_ttdriver
->ttys
= NULL
;
3137 put_tty_driver(nd
->nd_xprint_ttdriver
);
3138 nd
->nd_ttdriver_flags
&= ~XPRINT_TTDRV_REG
;
3140 for (i
= 0; i
< CHAN_MAX
; i
++)
3141 tty_port_destroy(&nd
->nd_chan
[i
].port
);
3147 * Initialize the TTY portion of the supplied node.
3150 dgrp_tty_init(struct nd_struct
*nd
)
3156 ID_TO_CHAR(nd
->nd_ID
, id
);
3159 * Initialize the TTDRIVER structures.
3162 nd
->nd_serial_ttdriver
= alloc_tty_driver(CHAN_MAX
);
3163 if (!nd
->nd_serial_ttdriver
)
3166 sprintf(nd
->nd_serial_name
, "tty_dgrp_%s_", id
);
3168 nd
->nd_serial_ttdriver
->owner
= THIS_MODULE
;
3169 nd
->nd_serial_ttdriver
->name
= nd
->nd_serial_name
;
3170 nd
->nd_serial_ttdriver
->name_base
= 0;
3171 nd
->nd_serial_ttdriver
->major
= 0;
3172 nd
->nd_serial_ttdriver
->minor_start
= 0;
3173 nd
->nd_serial_ttdriver
->type
= TTY_DRIVER_TYPE_SERIAL
;
3174 nd
->nd_serial_ttdriver
->subtype
= SERIAL_TYPE_NORMAL
;
3175 nd
->nd_serial_ttdriver
->init_termios
= DefaultTermios
;
3176 nd
->nd_serial_ttdriver
->driver_name
= "dgrp";
3177 nd
->nd_serial_ttdriver
->flags
= (TTY_DRIVER_REAL_RAW
|
3178 TTY_DRIVER_DYNAMIC_DEV
|
3179 TTY_DRIVER_HARDWARE_BREAK
);
3181 /* The kernel wants space to store pointers to tty_structs. */
3182 nd
->nd_serial_ttdriver
->ttys
=
3183 kzalloc(CHAN_MAX
* sizeof(struct tty_struct
*), GFP_KERNEL
);
3184 if (!nd
->nd_serial_ttdriver
->ttys
)
3187 tty_set_operations(nd
->nd_serial_ttdriver
, &dgrp_tty_ops
);
3189 if (!(nd
->nd_ttdriver_flags
& SERIAL_TTDRV_REG
)) {
3191 * Register tty devices
3193 rc
= tty_register_driver(nd
->nd_serial_ttdriver
);
3196 * If errno is EBUSY, this means there are no more
3197 * slots available to have us auto-majored.
3198 * (Which is currently supported up to 256)
3200 * We can still request majors above 256,
3201 * we just have to do it manually.
3205 int max_majors
= 1U << (32 - MINORBITS
);
3206 for (i
= 256; i
< max_majors
; i
++) {
3207 nd
->nd_serial_ttdriver
->major
= i
;
3208 rc
= tty_register_driver(nd
->nd_serial_ttdriver
);
3212 /* Really fail now, since we ran out
3213 * of majors to try. */
3214 if (i
== max_majors
)
3221 nd
->nd_ttdriver_flags
|= SERIAL_TTDRV_REG
;
3224 nd
->nd_callout_ttdriver
= alloc_tty_driver(CHAN_MAX
);
3225 if (!nd
->nd_callout_ttdriver
)
3228 sprintf(nd
->nd_callout_name
, "cu_dgrp_%s_", id
);
3230 nd
->nd_callout_ttdriver
->owner
= THIS_MODULE
;
3231 nd
->nd_callout_ttdriver
->name
= nd
->nd_callout_name
;
3232 nd
->nd_callout_ttdriver
->name_base
= 0;
3233 nd
->nd_callout_ttdriver
->major
= nd
->nd_serial_ttdriver
->major
;
3234 nd
->nd_callout_ttdriver
->minor_start
= 0x40;
3235 nd
->nd_callout_ttdriver
->type
= TTY_DRIVER_TYPE_SERIAL
;
3236 nd
->nd_callout_ttdriver
->subtype
= SERIAL_TYPE_CALLOUT
;
3237 nd
->nd_callout_ttdriver
->init_termios
= DefaultTermios
;
3238 nd
->nd_callout_ttdriver
->driver_name
= "dgrp";
3239 nd
->nd_callout_ttdriver
->flags
= (TTY_DRIVER_REAL_RAW
|
3240 TTY_DRIVER_DYNAMIC_DEV
|
3241 TTY_DRIVER_HARDWARE_BREAK
);
3243 /* The kernel wants space to store pointers to tty_structs. */
3244 nd
->nd_callout_ttdriver
->ttys
=
3245 kzalloc(CHAN_MAX
* sizeof(struct tty_struct
*), GFP_KERNEL
);
3246 if (!nd
->nd_callout_ttdriver
->ttys
)
3249 tty_set_operations(nd
->nd_callout_ttdriver
, &dgrp_tty_ops
);
3251 if (dgrp_register_cudevices
) {
3252 if (!(nd
->nd_ttdriver_flags
& CALLOUT_TTDRV_REG
)) {
3254 * Register cu devices
3256 rc
= tty_register_driver(nd
->nd_callout_ttdriver
);
3259 nd
->nd_ttdriver_flags
|= CALLOUT_TTDRV_REG
;
3264 nd
->nd_xprint_ttdriver
= alloc_tty_driver(CHAN_MAX
);
3265 if (!nd
->nd_xprint_ttdriver
)
3268 sprintf(nd
->nd_xprint_name
, "pr_dgrp_%s_", id
);
3270 nd
->nd_xprint_ttdriver
->owner
= THIS_MODULE
;
3271 nd
->nd_xprint_ttdriver
->name
= nd
->nd_xprint_name
;
3272 nd
->nd_xprint_ttdriver
->name_base
= 0;
3273 nd
->nd_xprint_ttdriver
->major
= nd
->nd_serial_ttdriver
->major
;
3274 nd
->nd_xprint_ttdriver
->minor_start
= 0x80;
3275 nd
->nd_xprint_ttdriver
->type
= TTY_DRIVER_TYPE_SERIAL
;
3276 nd
->nd_xprint_ttdriver
->subtype
= SERIAL_TYPE_XPRINT
;
3277 nd
->nd_xprint_ttdriver
->init_termios
= DefaultTermios
;
3278 nd
->nd_xprint_ttdriver
->driver_name
= "dgrp";
3279 nd
->nd_xprint_ttdriver
->flags
= (TTY_DRIVER_REAL_RAW
|
3280 TTY_DRIVER_DYNAMIC_DEV
|
3281 TTY_DRIVER_HARDWARE_BREAK
);
3283 /* The kernel wants space to store pointers to tty_structs. */
3284 nd
->nd_xprint_ttdriver
->ttys
=
3285 kzalloc(CHAN_MAX
* sizeof(struct tty_struct
*), GFP_KERNEL
);
3286 if (!nd
->nd_xprint_ttdriver
->ttys
)
3289 tty_set_operations(nd
->nd_xprint_ttdriver
, &dgrp_tty_ops
);
3291 if (dgrp_register_prdevices
) {
3292 if (!(nd
->nd_ttdriver_flags
& XPRINT_TTDRV_REG
)) {
3294 * Register transparent print devices
3296 rc
= tty_register_driver(nd
->nd_xprint_ttdriver
);
3299 nd
->nd_ttdriver_flags
|= XPRINT_TTDRV_REG
;
3303 for (i
= 0; i
< CHAN_MAX
; i
++) {
3304 struct ch_struct
*ch
= nd
->nd_chan
+ i
;
3307 ch
->ch_digi
= digi_init
;
3308 ch
->ch_edelay
= 100;
3309 ch
->ch_custom_speed
= 0;
3311 ch
->ch_tun
.un_ch
= ch
;
3312 ch
->ch_pun
.un_ch
= ch
;
3313 ch
->ch_tun
.un_type
= SERIAL_TYPE_NORMAL
;
3314 ch
->ch_pun
.un_type
= SERIAL_TYPE_XPRINT
;
3316 init_waitqueue_head(&(ch
->ch_flag_wait
));
3317 init_waitqueue_head(&(ch
->ch_sleep
));
3319 init_waitqueue_head(&(ch
->ch_tun
.un_open_wait
));
3320 init_waitqueue_head(&(ch
->ch_tun
.un_close_wait
));
3322 init_waitqueue_head(&(ch
->ch_pun
.un_open_wait
));
3323 init_waitqueue_head(&(ch
->ch_pun
.un_close_wait
));
3324 tty_port_init(&ch
->port
);