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 the port is in the middle of closing, then block
636 * until it is done, then try again.
638 retval = wait_event_interruptible(un->un_close_wait,
639 ((un->un_flag & UN_CLOSING) == 0));
645 * If the port is in the middle of a reopen after a network disconnect,
646 * wait until it is done, then try again.
648 retval = wait_event_interruptible(ch->ch_flag_wait,
649 ((ch->ch_flag & CH_PORT_GONE) == 0));
655 * If this is a callout device, then just make sure the normal
656 * device isn't being used.
659 if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
660 if (un->un_flag & UN_NORMAL_ACTIVE) {
664 un->un_flag |= UN_CALLOUT_ACTIVE;
669 * Loop waiting until the open can be successfully completed.
672 spin_lock_irqsave(&nd->nd_lock, lock_flags);
680 * Determine the open type from the flags provided.
684 * If the port is not enabled, then exit
686 if (test_bit(TTY_IO_ERROR, &tty->flags)) {
687 /* there was an error in opening the tty */
688 if (un->un_flag & UN_CALLOUT_ACTIVE)
691 un->un_flag |= UN_NORMAL_ACTIVE;
695 if (file->f_flags & O_NONBLOCK) {
698 * if the O_NONBLOCK is set, errors on read and write
699 * must return -EAGAIN immediately and NOT sleep
702 otype = OTYPE_IMMEDIATE;
703 delay_error = -EAGAIN;
705 } else if (!OPEN_WAIT_AVAIL(category) ||
706 (file->f_flags & O_NDELAY) != 0) {
707 otype = OTYPE_IMMEDIATE;
708 delay_error = -EBUSY;
710 } else if (!OPEN_WAIT_CARRIER(category) ||
711 ((ch->ch_digi.digi_flags & DIGI_FORCEDCD) != 0) ||
713 otype = OTYPE_PERSISTENT;
717 otype = OTYPE_INCOMING;
722 * Handle port currently outside physical port range.
725 if (port >= nd->nd_chan_count) {
726 if (otype == OTYPE_IMMEDIATE) {
727 retval = (nd->nd_state == NS_READY) ?
734 * Handle port not currently open.
737 else if (ch->ch_open_count == 0) {
739 * Return an error when an Incoming Open
740 * response indicates the port is busy.
743 if (ch->ch_open_error != 0 && otype == ch->ch_otype) {
744 retval = (ch->ch_open_error <= 2) ?
745 delay_error : -ENXIO;
750 * Fail any new Immediate open if we do not have
751 * a normal connection to the server.
754 if (nd->nd_state != NS_READY &&
755 otype == OTYPE_IMMEDIATE) {
761 * If a Realport open of the correct type has
762 * succeeded, complete the open.
765 if (ch->ch_state == CS_READY && ch->ch_otype == otype)
770 * Handle port already open and active as a device
774 else if ((ch->ch_category == category) ||
775 IS_PRINT(MINOR(tty_devnum(tty)))) {
777 * Fail if opening the device now would
778 * violate exclusive use.
780 unf = ch->ch_tun.un_flag | ch->ch_pun.un_flag;
782 if ((file->f_flags & O_EXCL) || (unf & UN_EXCL)) {
788 * If the open device is in the hangup state, all
789 * system calls fail except close().
792 /* TODO : check on hangup_p calls */
794 if (ch->ch_flag & CH_HANGUP) {
800 * If the port is ready, and carrier is ignored
801 * or present, then complete the open.
804 if (ch->ch_state == CS_READY &&
805 (otype != OTYPE_INCOMING ||
806 ch->ch_flag & CH_VIRT_CD))
813 * Handle port active with a different category device.
817 if (otype == OTYPE_IMMEDIATE) {
818 retval = delay_error;
824 * Wait until conditions change, then take another
828 ch->ch_wait_count[otype]++;
831 ch->ch_wait_carrier++;
834 * Prepare the task to accept the wakeup, then
835 * release our locks and release control.
838 add_wait_queue(&ch->ch_flag_wait, &wait);
839 current->state = TASK_INTERRUPTIBLE;
841 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
844 * Give up control, we'll come back if we're
845 * interrupted or are woken up.
848 remove_wait_queue(&ch->ch_flag_wait, &wait);
850 spin_lock_irqsave(&nd->nd_lock, lock_flags);
852 current->state = TASK_RUNNING;
854 ch->ch_wait_count[otype]--;
857 ch->ch_wait_carrier--;
861 if (signal_pending(current)) {
868 * The open has succeeded. No turning back.
870 counts_were_incremented = 1;
875 * Initialize the channel, if it's not already open.
878 if (ch->ch_open_count == 1) {
881 ch->ch_category = category;
882 ch->ch_pscan_state = 0;
884 /* TODO : find out what PS-1 bug Gene was referring to */
885 /* TODO : in the following comment. */
887 ch->ch_send = RR_TX_START | RR_RX_START; /* PS-1 bug */
890 ch->ch_s_mlast & DM_CD ||
891 ch->ch_digi.digi_flags & DIGI_FORCEDCD)
892 ch->ch_flag |= CH_VIRT_CD;
893 else if (OPEN_FORCES_CARRIER(category))
894 ch->ch_flag |= CH_VIRT_CD;
899 * Initialize the unit, if it is not already open.
902 if (un->un_open_count == 1) {
904 * Since all terminal options are always sticky in Linux,
905 * we don't need the UN_STICKY flag to be handled specially.
907 /* clears all the digi flags, leaves serial flags */
908 un->un_flag &= ~UN_DIGI_MASK;
910 if (file->f_flags & O_EXCL)
911 un->un_flag |= UN_EXCL;
913 /* TODO : include "session" and "pgrp" */
916 * In Linux, all terminal parameters are intended to be sticky.
917 * as a result, we "remove" the code which once reset the ports
925 un->un_flag |= UN_INITIALIZED;
931 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
935 * Linux does a close for every open, even failed ones!
937 if (!counts_were_incremented) {
943 dev_err(tty->dev, "tty open bad return (%i)\n", retval);
952 * dgrp_tty_close() -- close function for tty_operations
954 static void dgrp_tty_close(struct tty_struct *tty, struct file *file)
956 struct ch_struct *ch;
957 struct un_struct *un;
958 struct nd_struct *nd;
965 int sent_printer_offstr = 0;
967 port = PORT_NUM(MINOR(tty_devnum(tty)));
969 un = tty->driver_data;
984 spin_lock_irqsave(&nd->nd_lock, lock_flags);
987 /* Used to be on channel basis, now we check on a unit basis. */
988 if (un->un_open_count != 1)
992 * OK, its the last close on the unit
994 un->un_flag |= UN_CLOSING;
997 * Notify the discipline to only process XON/XOFF characters.
1002 * Wait for output to drain only if this is
1003 * the last close against the channel
1006 if (ch->ch_open_count == 1) {
1008 * If its the print device, we need to ensure at all costs that
1009 * the offstr will fit. If it won't, flush our tbuf.
1011 if (IS_PRINT(MINOR(tty_devnum(tty))) &&
1012 (((ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK) <
1013 ch->ch_digi.digi_offlen))
1014 ch->ch_tin = ch->ch_tout;
1017 * Turn off the printer. Don't bother checking to see if its
1018 * IS_PRINT... Since this is the last close the flag is going
1019 * to be cleared, so we MUST make sure the offstr gets inserted
1023 if ((ch->ch_flag & CH_PRON) != 0) {
1024 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1025 ch->ch_digi.digi_offlen);
1026 ch->ch_flag &= ~CH_PRON;
1027 sent_printer_offstr = 1;
1032 * Wait until either the output queue has drained, or we see
1033 * absolutely no progress for 15 seconds.
1036 tpos = ch->ch_s_tpos;
1038 waketime = jiffies + 15 * HZ;
1043 * Make sure the port still exists.
1046 if (port >= nd->nd_chan_count) {
1051 if (signal_pending(current)) {
1057 * If the port is idle (not opened on the server), we have
1058 * no way of draining/flushing/closing the port on that server.
1059 * So break out of loop.
1061 if (ch->ch_state == CS_IDLE)
1067 * Exit if the queues for this unit are empty,
1068 * and either the other unit is still open or all
1072 if ((un->un_tty)->ops->chars_in_buffer ?
1073 ((un->un_tty)->ops->chars_in_buffer)(un->un_tty) == 0 : 1) {
1076 * We don't need to wait for a buffer to drain
1077 * if the other unit is open.
1080 if (ch->ch_open_count != un->un_open_count)
1084 * The wait is complete when all queues are
1085 * drained, and any break in progress is complete.
1088 if (ch->ch_tin == ch->ch_tout &&
1089 ch->ch_s_tin == ch->ch_s_tpos &&
1090 (ch->ch_send & RR_TX_BREAK) == 0) {
1096 * Flush TX data and exit the wait if NDELAY is set,
1097 * or this is not a DIGI printer, and the close timeout
1101 if ((file->f_flags & (O_NDELAY | O_NONBLOCK)) ||
1102 ((long)(jiffies - waketime) >= 0 &&
1103 (ch->ch_digi.digi_flags & DIGI_PRINTER) == 0)) {
1106 * If we sent the printer off string, we cannot
1107 * flush our internal buffers, or we might lose
1110 if (!sent_printer_offstr)
1111 dgrp_tty_flush_buffer(tty);
1113 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1114 tty_ldisc_flush(tty);
1115 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1120 * Otherwise take a short nap.
1123 ch->ch_flag |= CH_DRAIN;
1125 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1127 schedule_timeout_interruptible(1);
1128 s = signal_pending(current);
1130 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1134 * If we had sent the printer off string, we now have
1137 * The system won't let us sleep since we got an error
1138 * back from sleep, presumably because the user did
1140 * But we need to ensure that the offstr gets sent!
1141 * Thus, we have to do something else besides sleeping.
1143 * 1) Make this task uninterruptable.
1144 * 2) Set up a timer to go off in 1 sec.
1145 * 3) Act as tho we just got out of the sleep above.
1147 * Thankfully, in the real world, this just
1151 if (sent_printer_offstr) {
1152 spin_unlock_irqrestore(&nd->nd_lock,
1155 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1163 * Restart the wait if any progress is seen.
1166 if (ch->ch_s_tpos != tpos) {
1167 tpos = ch->ch_s_tpos;
1169 /* TODO: this gives us timeout problems with nist ?? */
1170 waketime = jiffies + 15 * HZ;
1175 * Close the line discipline
1178 /* this is done in tty_io.c */
1179 /* if ((un->un_tty)->ldisc.close)
1180 * ((un->un_tty)->ldisc.close)(un->un_tty);
1183 /* don't do this here */
1184 /* un->un_flag = 0; */
1187 * Flush the receive buffer on terminal unit close only.
1190 if (!IS_PRINT(MINOR(tty_devnum(tty))))
1191 ch->ch_rout = ch->ch_rin;
1195 * Don't permit the close to happen until we get any pending
1196 * sync request responses.
1197 * There could be other ports depending upon the response as well.
1199 * Also, don't permit the close to happen until any parameter
1200 * changes have been sent out from the state machine as well.
1201 * This is required because of a ditty -a race with -HUPCL
1202 * We MUST make sure all channel parameters have been sent to the
1203 * Portserver before sending a close.
1206 if ((err != 1) && (ch->ch_state != CS_IDLE)) {
1207 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1208 s = wait_event_interruptible(ch->ch_flag_wait,
1209 ((ch->ch_flag & (CH_WAITING_SYNC | CH_PARAM)) == 0));
1210 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1214 * Cleanup the channel if last unit open.
1217 if (ch->ch_open_count == 1) {
1219 ch->ch_category = 0;
1222 ch->ch_tout = ch->ch_tin;
1223 /* (un->un_tty)->device = 0; */
1225 if (ch->ch_state == CS_READY)
1226 ch->ch_state = CS_SEND_CLOSE;
1230 * Send the changes to the server
1232 if (ch->ch_state != CS_IDLE) {
1233 ch->ch_flag |= CH_PARAM;
1234 wake_up_interruptible(&ch->ch_flag_wait);
1238 nd->nd_tx_ready = 1;
1243 if (ch->ch_open_count <= 0)
1245 "%s - unexpected value for ch->ch_open_count: %i\n",
1246 __func__, ch->ch_open_count);
1248 ch->ch_open_count--;
1250 if (un->un_open_count <= 0)
1252 "%s - unexpected value for un->un_open_count: %i\n",
1253 __func__, un->un_open_count);
1255 un->un_open_count--;
1257 un->un_flag &= ~(UN_NORMAL_ACTIVE | UN_CALLOUT_ACTIVE | UN_CLOSING);
1258 if (waitqueue_active(&un->un_close_wait))
1259 wake_up_interruptible(&un->un_close_wait);
1261 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1267 static void drp_wmove(struct ch_struct *ch, int from_user, void *buf, int count)
1272 ch->ch_nd->nd_tx_work = 1;
1274 n = TBUF_MAX - ch->ch_tin;
1278 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1279 (void __user *) buf, n);
1281 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1283 buf = (char *) buf + n;
1289 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1290 (void __user *) buf, count);
1292 memcpy(ch->ch_tbuf + ch->ch_tin, buf, count);
1294 ch->ch_tin += count;
1298 static int dgrp_calculate_txprint_bounds(struct ch_struct *ch, int space,
1303 unsigned short tmax = 0;
1306 * If the terminal device is busy, reschedule when
1307 * the terminal device becomes idle.
1310 if (ch->ch_tun.un_open_count != 0 &&
1311 ch->ch_tun.un_tty->ops->chars_in_buffer &&
1312 ((ch->ch_tun.un_tty->ops->chars_in_buffer)
1313 (ch->ch_tun.un_tty) != 0)) {
1314 *un_flag = UN_PWAIT;
1319 * Assure that whenever there is printer data in the output
1320 * buffer, there always remains enough space after it to
1321 * turn the printer off.
1323 space -= ch->ch_digi.digi_offlen;
1326 *un_flag = UN_EMPTY;
1331 * We measure printer CPS speed by incrementing
1332 * ch_cpstime by (HZ / digi_maxcps) for every
1333 * character we output, restricting output so
1334 * that ch_cpstime never exceeds lbolt.
1336 * However if output has not been done for some
1337 * time, lbolt will grow to very much larger than
1338 * ch_cpstime, which would allow essentially
1339 * unlimited amounts of output until ch_cpstime
1340 * finally caught up. To avoid this, we adjust
1341 * cps_time when necessary so the difference
1342 * between lbolt and ch_cpstime never results
1343 * in sending more than digi_bufsize characters.
1345 * This nicely models a printer with an internal
1346 * buffer of digi_bufsize characters.
1348 * Get the time between lbolt and ch->ch_cpstime;
1351 tt = jiffies - ch->ch_cpstime;
1354 * Compute the time required to send digi_bufsize
1358 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1361 * Compute the number of characters that can be sent
1362 * without violating the time constraint. If the
1363 * direct calculation of this number is bigger than
1364 * digi_bufsize, limit the number to digi_bufsize,
1365 * and adjust cpstime to match.
1368 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1369 tmax = ch->ch_digi.digi_bufsize;
1370 ch->ch_cpstime = jiffies - mt;
1372 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1376 * If the time constraint now binds, limit the transmit
1377 * count accordingly, and tentatively arrange to be
1378 * rescheduled based on time.
1387 * Compute the total number of characters we can
1388 * output before the total number of characters known
1389 * to be in the output queue exceeds digi_maxchar.
1392 tmax = (ch->ch_digi.digi_maxchar -
1393 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1394 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1398 * If the digi_maxchar constraint now holds, limit
1399 * the transmit count accordingly, and arrange to
1400 * be rescheduled when the queue becomes empty.
1404 *un_flag = UN_EMPTY;
1409 *un_flag |= UN_EMPTY;
1415 static int dgrp_tty_write(struct tty_struct *tty,
1416 const unsigned char *buf,
1419 struct nd_struct *nd;
1420 struct un_struct *un;
1421 struct ch_struct *ch;
1432 un = tty->driver_data;
1445 * Ignore the request if the channel is not ready.
1447 if (ch->ch_state != CS_READY)
1450 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1453 * Ignore the request if output is blocked.
1455 if ((un->un_flag & (UN_EMPTY | UN_LOW | UN_TIME | UN_PWAIT)) != 0) {
1461 * Also ignore the request if DPA has this port open,
1462 * and is flow controlled on reading more data.
1464 if (nd->nd_dpa_debug && nd->nd_dpa_flag & DPA_WAIT_SPACE &&
1465 nd->nd_dpa_port == MINOR(tty_devnum(ch->ch_tun.un_tty))) {
1471 * Limit amount we will write to the amount of space
1472 * available in the channel buffer.
1476 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1479 * Handle the printer device.
1484 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1487 unsigned short tmax = 0;
1490 * If the terminal device is busy, reschedule when
1491 * the terminal device becomes idle.
1494 if (ch->ch_tun.un_open_count != 0 &&
1495 ((ch->ch_tun.un_tty->ops->chars_in_buffer)
1496 (ch->ch_tun.un_tty) != 0)) {
1497 un->un_flag |= UN_PWAIT;
1503 * Assure that whenever there is printer data in the output
1504 * buffer, there always remains enough space after it to
1505 * turn the printer off.
1507 space -= ch->ch_digi.digi_offlen;
1510 * Output the printer on string.
1513 if ((ch->ch_flag & CH_PRON) == 0) {
1514 space -= ch->ch_digi.digi_onlen;
1517 un->un_flag |= UN_EMPTY;
1518 (ch->ch_nd)->nd_tx_work = 1;
1523 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1524 ch->ch_digi.digi_onlen);
1526 ch->ch_flag |= CH_PRON;
1530 * We measure printer CPS speed by incrementing
1531 * ch_cpstime by (HZ / digi_maxcps) for every
1532 * character we output, restricting output so
1533 * that ch_cpstime never exceeds lbolt.
1535 * However if output has not been done for some
1536 * time, lbolt will grow to very much larger than
1537 * ch_cpstime, which would allow essentially
1538 * unlimited amounts of output until ch_cpstime
1539 * finally caught up. To avoid this, we adjust
1540 * cps_time when necessary so the difference
1541 * between lbolt and ch_cpstime never results
1542 * in sending more than digi_bufsize characters.
1544 * This nicely models a printer with an internal
1545 * buffer of digi_bufsize characters.
1547 * Get the time between lbolt and ch->ch_cpstime;
1550 tt = jiffies - ch->ch_cpstime;
1553 * Compute the time required to send digi_bufsize
1557 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1560 * Compute the number of characters that can be sent
1561 * without violating the time constraint. If the
1562 * direct calculation of this number is bigger than
1563 * digi_bufsize, limit the number to digi_bufsize,
1564 * and adjust cpstime to match.
1567 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1568 tmax = ch->ch_digi.digi_bufsize;
1569 ch->ch_cpstime = jiffies - mt;
1571 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1575 * If the time constraint now binds, limit the transmit
1576 * count accordingly, and tentatively arrange to be
1577 * rescheduled based on time.
1586 * Compute the total number of characters we can
1587 * output before the total number of characters known
1588 * to be in the output queue exceeds digi_maxchar.
1591 tmax = (ch->ch_digi.digi_maxchar -
1592 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1593 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1597 * If the digi_maxchar constraint now holds, limit
1598 * the transmit count accordingly, and arrange to
1599 * be rescheduled when the queue becomes empty.
1609 * Handle the terminal device.
1614 * If the printer device is on, turn it off.
1617 if ((ch->ch_flag & CH_PRON) != 0) {
1619 space -= ch->ch_digi.digi_offlen;
1621 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1622 ch->ch_digi.digi_offlen);
1624 ch->ch_flag &= ~CH_PRON;
1629 * If space is 0 and its because the ch->tbuf
1630 * is full, then Linux will handle a callback when queue
1631 * space becomes available.
1632 * tty_write returns count = 0
1636 /* the linux tty_io.c handles this if we return 0 */
1637 /* if (fp->flags & O_NONBLOCK) return -EAGAIN; */
1639 un->un_flag |= UN_EMPTY;
1640 (ch->ch_nd)->nd_tx_work = 1;
1645 count = min(count, space);
1652 * Copy the buffer contents to the ch_tbuf
1653 * being careful to wrap around the circular queue
1656 t = TBUF_MAX - ch->ch_tin;
1660 memcpy(ch->ch_tbuf + ch->ch_tin, buf, t);
1661 if (nd->nd_dpa_debug && nd->nd_dpa_port ==
1662 PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1663 dgrp_dpa_data(nd, 0, (char *) buf, t);
1670 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1671 if (nd->nd_dpa_debug && nd->nd_dpa_port ==
1672 PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1673 dgrp_dpa_data(nd, 0, (char *) buf, n);
1679 (ch->ch_nd)->nd_tx_work = 1;
1680 if (ch->ch_edelay != DGRP_RTIME) {
1681 (ch->ch_nd)->nd_tx_ready = 1;
1682 wake_up_interruptible(&nd->nd_tx_waitq);
1686 ch->ch_txcount += count;
1688 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1691 * Adjust ch_cpstime to account
1692 * for the characters just output.
1695 if (sendcount > 0) {
1696 int cc = HZ * sendcount + ch->ch_cpsrem;
1698 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1699 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1703 * If we are now waiting on time, schedule ourself
1704 * back when we'll be able to send a block of
1705 * digi_maxchar characters.
1708 if ((un_flag & UN_TIME) != 0) {
1709 ch->ch_waketime = (ch->ch_cpstime +
1710 (ch->ch_digi.digi_maxchar * HZ /
1711 ch->ch_digi.digi_maxcps));
1716 * If the printer unit is waiting for completion
1717 * of terminal output, get him going again.
1720 if ((ch->ch_pun.un_flag & UN_PWAIT) != 0)
1721 (ch->ch_nd)->nd_tx_work = 1;
1724 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1731 * Put a character into ch->ch_buf
1733 * - used by the line discipline for OPOST processing
1736 static int dgrp_tty_put_char(struct tty_struct *tty, unsigned char new_char)
1738 struct un_struct *un;
1739 struct ch_struct *ch;
1747 un = tty->driver_data;
1755 if (ch->ch_state != CS_READY)
1758 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1762 * If space is 0 and its because the ch->tbuf
1763 * Warn and dump the character, there isn't anything else
1764 * we can do about it. David_Fries@digi.com
1767 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1772 * Output the printer on string if device is TXPrint.
1774 if (IS_PRINT(MINOR(tty_devnum(tty))) && (ch->ch_flag & CH_PRON) == 0) {
1775 if (space < ch->ch_digi.digi_onlen) {
1779 space -= ch->ch_digi.digi_onlen;
1780 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1781 ch->ch_digi.digi_onlen);
1782 ch->ch_flag |= CH_PRON;
1786 * Output the printer off string if device is NOT TXPrint.
1789 if (!IS_PRINT(MINOR(tty_devnum(tty))) &&
1790 ((ch->ch_flag & CH_PRON) != 0)) {
1791 if (space < ch->ch_digi.digi_offlen) {
1796 space -= ch->ch_digi.digi_offlen;
1797 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1798 ch->ch_digi.digi_offlen);
1799 ch->ch_flag &= ~CH_PRON;
1808 * Copy the character to the ch_tbuf being
1809 * careful to wrap around the circular queue
1811 ch->ch_tbuf[ch->ch_tin] = new_char;
1812 ch->ch_tin = (1 + ch->ch_tin) & TBUF_MASK;
1814 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1817 * Adjust ch_cpstime to account
1818 * for the character just output.
1821 int cc = HZ + ch->ch_cpsrem;
1823 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1824 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1827 * If we are now waiting on time, schedule ourself
1828 * back when we'll be able to send a block of
1829 * digi_maxchar characters.
1832 ch->ch_waketime = (ch->ch_cpstime +
1833 (ch->ch_digi.digi_maxchar * HZ /
1834 ch->ch_digi.digi_maxcps));
1839 (ch->ch_nd)->nd_tx_work = 1;
1843 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1850 * Flush TX buffer (make in == out)
1852 * check tty_ioctl.c -- this is called after TCOFLUSH
1854 static void dgrp_tty_flush_buffer(struct tty_struct *tty)
1856 struct un_struct *un;
1857 struct ch_struct *ch;
1861 un = tty->driver_data;
1869 ch->ch_tout = ch->ch_tin;
1870 /* do NOT do this here! */
1871 /* ch->ch_s_tpos = ch->ch_s_tin = 0; */
1873 /* send the flush output command now */
1874 ch->ch_send |= RR_TX_FLUSH;
1875 (ch->ch_nd)->nd_tx_ready = 1;
1876 (ch->ch_nd)->nd_tx_work = 1;
1877 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
1879 if (waitqueue_active(&tty->write_wait))
1880 wake_up_interruptible(&tty->write_wait);
1887 * Return space available in Tx buffer
1888 * count = ( ch->ch_tout - ch->ch_tin ) mod (TBUF_MAX - 1)
1890 static int dgrp_tty_write_room(struct tty_struct *tty)
1892 struct un_struct *un;
1893 struct ch_struct *ch;
1899 un = tty->driver_data;
1907 count = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1909 /* We *MUST* check this, and return 0 if the Printer Unit cannot
1910 * take any more data within its time constraints... If we don't
1911 * return 0 and the printer has hit it time constraint, the ld will
1912 * call us back doing a put_char, which cannot be rejected!!!
1914 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1916 count = dgrp_calculate_txprint_bounds(ch, count, &un_flag);
1920 ch->ch_pun.un_flag |= un_flag;
1921 (ch->ch_nd)->nd_tx_work = 1;
1928 * Return number of characters that have not been transmitted yet.
1929 * chars_in_buffer = ( ch->ch_tin - ch->ch_tout ) mod (TBUF_MAX - 1)
1930 * + ( ch->ch_s_tin - ch->ch_s_tout ) mod (0xffff)
1931 * = number of characters "in transit"
1933 * Remember that sequence number math is always with a sixteen bit
1934 * mask, not the TBUF_MASK.
1937 static int dgrp_tty_chars_in_buffer(struct tty_struct *tty)
1939 struct un_struct *un;
1940 struct ch_struct *ch;
1947 un = tty->driver_data;
1955 count1 = count = (ch->ch_tin - ch->ch_tout) & TBUF_MASK;
1956 count += (ch->ch_s_tin - ch->ch_s_tpos) & 0xffff;
1957 /* one for tbuf, one for the PS */
1960 * If we are busy transmitting add 1
1962 count += un->un_tbusy;
1968 /*****************************************************************************
1970 * Helper applications for dgrp_tty_ioctl()
1972 *****************************************************************************
1977 * ch_to_tty_flags() -- convert channel flags to termio flags
1978 * @ch_flag: Digi channel flags
1979 * @flagtype: type of ch_flag (iflag, oflag or cflag)
1981 * take the channel flags of the specified type and return the
1982 * corresponding termio flag
1984 static tcflag_t ch_to_tty_flags(ushort ch_flag, char flagtype)
1986 tcflag_t retval = 0;
1990 retval = ((ch_flag & IF_IGNBRK) ? IGNBRK : 0)
1991 | ((ch_flag & IF_BRKINT) ? BRKINT : 0)
1992 | ((ch_flag & IF_IGNPAR) ? IGNPAR : 0)
1993 | ((ch_flag & IF_PARMRK) ? PARMRK : 0)
1994 | ((ch_flag & IF_INPCK) ? INPCK : 0)
1995 | ((ch_flag & IF_ISTRIP) ? ISTRIP : 0)
1996 | ((ch_flag & IF_IXON) ? IXON : 0)
1997 | ((ch_flag & IF_IXANY) ? IXANY : 0)
1998 | ((ch_flag & IF_IXOFF) ? IXOFF : 0);
2002 retval = ((ch_flag & OF_OLCUC) ? OLCUC : 0)
2003 | ((ch_flag & OF_ONLCR) ? ONLCR : 0)
2004 | ((ch_flag & OF_OCRNL) ? OCRNL : 0)
2005 | ((ch_flag & OF_ONOCR) ? ONOCR : 0)
2006 | ((ch_flag & OF_ONLRET) ? ONLRET : 0)
2007 /* | ((ch_flag & OF_OTAB3) ? OFILL : 0) */
2008 | ((ch_flag & OF_TABDLY) ? TABDLY : 0);
2012 retval = ((ch_flag & CF_CSTOPB) ? CSTOPB : 0)
2013 | ((ch_flag & CF_CREAD) ? CREAD : 0)
2014 | ((ch_flag & CF_PARENB) ? PARENB : 0)
2015 | ((ch_flag & CF_PARODD) ? PARODD : 0)
2016 | ((ch_flag & CF_HUPCL) ? HUPCL : 0);
2018 switch (ch_flag & CF_CSIZE) {
2049 * tty_to_ch_flags() -- convert termio flags to digi channel flags
2050 * @tty: pointer to a TTY structure holding flag to be converted
2051 * @flagtype: identifies which flag (iflags, oflags, or cflags) should
2054 * take the termio flag of the specified type and return the
2055 * corresponding Digi version of the flags
2057 static ushort tty_to_ch_flags(struct tty_struct *tty, char flagtype)
2064 tflag = tty->termios.c_iflag;
2065 retval = (I_IGNBRK(tty) ? IF_IGNBRK : 0)
2066 | (I_BRKINT(tty) ? IF_BRKINT : 0)
2067 | (I_IGNPAR(tty) ? IF_IGNPAR : 0)
2068 | (I_PARMRK(tty) ? IF_PARMRK : 0)
2069 | (I_INPCK(tty) ? IF_INPCK : 0)
2070 | (I_ISTRIP(tty) ? IF_ISTRIP : 0)
2071 | (I_IXON(tty) ? IF_IXON : 0)
2072 | (I_IXANY(tty) ? IF_IXANY : 0)
2073 | (I_IXOFF(tty) ? IF_IXOFF : 0);
2076 tflag = tty->termios.c_oflag;
2078 * If OPOST is set, then do the post processing in the
2079 * firmware by setting all the processing flags on.
2080 * If ~OPOST, then make sure we are not doing any
2081 * output processing!!
2086 retval = (O_OLCUC(tty) ? OF_OLCUC : 0)
2087 | (O_ONLCR(tty) ? OF_ONLCR : 0)
2088 | (O_OCRNL(tty) ? OF_OCRNL : 0)
2089 | (O_ONOCR(tty) ? OF_ONOCR : 0)
2090 | (O_ONLRET(tty) ? OF_ONLRET : 0)
2091 /* | (O_OFILL(tty) ? OF_TAB3 : 0) */
2092 | (O_TABDLY(tty) ? OF_TABDLY : 0);
2095 tflag = tty->termios.c_cflag;
2096 retval = (C_CSTOPB(tty) ? CF_CSTOPB : 0)
2097 | (C_CREAD(tty) ? CF_CREAD : 0)
2098 | (C_PARENB(tty) ? CF_PARENB : 0)
2099 | (C_PARODD(tty) ? CF_PARODD : 0)
2100 | (C_HUPCL(tty) ? CF_HUPCL : 0);
2101 switch (C_CSIZE(tty)) {
2131 static int dgrp_tty_send_break(struct tty_struct *tty, int msec)
2133 struct un_struct *un;
2134 struct ch_struct *ch;
2140 un = tty->driver_data;
2148 dgrp_send_break(ch, msec);
2154 * This routine sends a break character out the serial port.
2156 * duration is in 1/1000's of a second
2158 static int dgrp_send_break(struct ch_struct *ch, int msec)
2162 wait_event_interruptible(ch->ch_flag_wait,
2163 ((ch->ch_flag & CH_TX_BREAK) == 0));
2164 ch->ch_break_time += max(msec, 250);
2165 ch->ch_send |= RR_TX_BREAK;
2166 ch->ch_flag |= CH_TX_BREAK;
2167 (ch->ch_nd)->nd_tx_work = 1;
2169 x = (msec * HZ) / 1000;
2170 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2177 * Return modem signals to ld.
2179 static int dgrp_tty_tiocmget(struct tty_struct *tty)
2182 struct un_struct *un = tty->driver_data;
2183 struct ch_struct *ch;
2192 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2193 (ch->ch_mout & (DM_RTS | DM_DTR)));
2195 /* defined in /usr/include/asm/termios.h */
2196 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2197 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2198 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2199 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2200 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2201 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2210 static int dgrp_tty_tiocmset(struct tty_struct *tty,
2211 unsigned int set, unsigned int clear)
2214 struct un_struct *un = tty->driver_data;
2215 struct ch_struct *ch;
2224 if (set & TIOCM_RTS)
2225 ch->ch_mout |= DM_RTS;
2227 if (set & TIOCM_DTR)
2228 ch->ch_mout |= DM_DTR;
2230 if (clear & TIOCM_RTS)
2231 ch->ch_mout &= ~(DM_RTS);
2233 if (clear & TIOCM_DTR)
2234 ch->ch_mout &= ~(DM_DTR);
2236 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2237 ch->ch_flag |= CH_PARAM;
2238 (ch->ch_nd)->nd_tx_work = 1;
2239 wake_up_interruptible(&ch->ch_flag_wait);
2241 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2249 * Get current modem status
2251 static int get_modem_info(struct ch_struct *ch, unsigned int *value)
2255 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2256 (ch->ch_mout & (DM_RTS | DM_DTR)));
2258 /* defined in /usr/include/asm/termios.h */
2259 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2260 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2261 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2262 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2263 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2264 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2265 return put_user(mlast, (unsigned int __user *) value);
2271 static int set_modem_info(struct ch_struct *ch, unsigned int command,
2272 unsigned int *value)
2279 error = access_ok(VERIFY_READ, (void __user *) value, sizeof(int));
2283 if (get_user(arg, (unsigned int __user *) value))
2285 mval |= ((arg & TIOCM_RTS) ? DM_RTS : 0)
2286 | ((arg & TIOCM_DTR) ? DM_DTR : 0);
2289 case TIOCMBIS: /* set flags */
2290 ch->ch_mout |= mval;
2292 case TIOCMBIC: /* clear flags */
2293 ch->ch_mout &= ~mval;
2302 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2304 ch->ch_flag |= CH_PARAM;
2305 (ch->ch_nd)->nd_tx_work = 1;
2306 wake_up_interruptible(&ch->ch_flag_wait);
2308 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2315 * Assign the custom baud rate to the channel structure
2317 static void dgrp_set_custom_speed(struct ch_struct *ch, int newrate)
2323 int deltahigh, deltalow;
2329 * Since the divisor is stored in a 16-bit integer, we make sure
2330 * we don't allow any rates smaller than a 16-bit integer would allow.
2331 * And of course, rates above the dividend won't fly.
2333 if (newrate && newrate < ((PORTSERVER_DIVIDEND / 0xFFFF) + 1))
2334 newrate = ((PORTSERVER_DIVIDEND / 0xFFFF) + 1);
2335 if (newrate && newrate > PORTSERVER_DIVIDEND)
2336 newrate = PORTSERVER_DIVIDEND;
2338 while (newrate > 0) {
2339 testdiv = PORTSERVER_DIVIDEND / newrate;
2342 * If we try to figure out what rate the PortServer would use
2343 * with the test divisor, it will be either equal or higher
2344 * than the requested baud rate. If we then determine the
2345 * rate with a divisor one higher, we will get the next lower
2346 * supported rate below the requested.
2348 testrate_high = PORTSERVER_DIVIDEND / testdiv;
2349 testrate_low = PORTSERVER_DIVIDEND / (testdiv + 1);
2352 * If the rate for the requested divisor is correct, just
2353 * use it and be done.
2355 if (testrate_high == newrate)
2359 * Otherwise, pick the rate that is closer (i.e. whichever rate
2360 * has a smaller delta).
2362 deltahigh = testrate_high - newrate;
2363 deltalow = newrate - testrate_low;
2365 if (deltahigh < deltalow)
2366 newrate = testrate_high;
2368 newrate = testrate_low;
2373 ch->ch_custom_speed = newrate;
2382 # dgrp_tty_digiseta()
2384 * Ioctl to set the information from ditty.
2386 * NOTE: DIGI_IXON, DSRPACE, DCDPACE, and DTRPACE are unsupported. JAR 990922
2388 static int dgrp_tty_digiseta(struct tty_struct *tty,
2389 struct digi_struct *new_info)
2391 struct un_struct *un = tty->driver_data;
2392 struct ch_struct *ch;
2401 if (copy_from_user(&ch->ch_digi, (void __user *) new_info,
2402 sizeof(struct digi_struct)))
2405 if ((ch->ch_digi.digi_flags & RTSPACE) ||
2406 (ch->ch_digi.digi_flags & CTSPACE))
2407 tty->termios.c_cflag |= CRTSCTS;
2409 tty->termios.c_cflag &= ~CRTSCTS;
2411 if (ch->ch_digi.digi_maxcps < 1)
2412 ch->ch_digi.digi_maxcps = 1;
2414 if (ch->ch_digi.digi_maxcps > 10000)
2415 ch->ch_digi.digi_maxcps = 10000;
2417 if (ch->ch_digi.digi_bufsize < 10)
2418 ch->ch_digi.digi_bufsize = 10;
2420 if (ch->ch_digi.digi_maxchar < 1)
2421 ch->ch_digi.digi_maxchar = 1;
2423 if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
2424 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;
2426 if (ch->ch_digi.digi_onlen > DIGI_PLEN)
2427 ch->ch_digi.digi_onlen = DIGI_PLEN;
2429 if (ch->ch_digi.digi_offlen > DIGI_PLEN)
2430 ch->ch_digi.digi_offlen = DIGI_PLEN;
2432 /* make the changes now */
2441 * dgrp_tty_digigetedelay()
2443 * Ioctl to get the current edelay setting.
2448 static int dgrp_tty_digigetedelay(struct tty_struct *tty, int *retinfo)
2450 struct un_struct *un;
2451 struct ch_struct *ch;
2457 if (!tty || tty->magic != TTY_MAGIC)
2460 un = tty->driver_data;
2469 tmp = ch->ch_edelay;
2471 if (copy_to_user((void __user *) retinfo, &tmp, sizeof(*retinfo)))
2479 * dgrp_tty_digisetedelay()
2481 * Ioctl to set the EDELAY setting
2484 static int dgrp_tty_digisetedelay(struct tty_struct *tty, int *new_info)
2486 struct un_struct *un;
2487 struct ch_struct *ch;
2490 if (!tty || tty->magic != TTY_MAGIC)
2493 un = tty->driver_data;
2502 if (copy_from_user(&new_digi, (void __user *)new_info, sizeof(int)))
2505 ch->ch_edelay = new_digi;
2507 /* make the changes now */
2515 * The usual assortment of ioctl's
2517 * note: use tty_check_change to make sure that we are not
2518 * changing the state of a terminal when we are not a process
2519 * in the forground. See tty_io.c
2520 * rc = tty_check_change(tty);
2521 * if (rc) return rc;
2523 static int dgrp_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
2526 struct un_struct *un;
2527 struct ch_struct *ch;
2529 struct digiflow_struct dflow;
2534 un = tty->driver_data;
2545 * Here are all the standard ioctl's that we MUST implement
2550 * TCSBRK is SVID version: non-zero arg --> no break
2551 * this behaviour is exploited by tcdrain().
2553 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2554 * between 0.25 and 0.5 seconds
2557 rc = tty_check_change(tty);
2560 tty_wait_until_sent(tty, 0);
2563 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2565 if (dgrp_tty_chars_in_buffer(tty) != 0)
2571 /* support for POSIX tcsendbreak()
2573 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2574 * between 0.25 and 0.5 seconds so we'll ask for something
2575 * in the middle: 0.375 seconds.
2577 rc = tty_check_change(tty);
2580 tty_wait_until_sent(tty, 0);
2582 rc = dgrp_send_break(ch, arg ? arg*250 : 250);
2584 if (dgrp_tty_chars_in_buffer(tty) != 0)
2589 rc = tty_check_change(tty);
2592 tty_wait_until_sent(tty, 0);
2595 * RealPort doesn't support turning on a break unconditionally.
2596 * The RealPort device will stop sending a break automatically
2597 * after the specified time value that we send in.
2599 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2601 if (dgrp_tty_chars_in_buffer(tty) != 0)
2607 * RealPort doesn't support turning off a break unconditionally.
2608 * The RealPort device will stop sending a break automatically
2609 * after the specified time value that was sent when turning on
2615 rc = access_ok(VERIFY_WRITE, (void __user *) arg,
2616 sizeof(unsigned int));
2619 return get_modem_info(ch, (unsigned int *) arg);
2624 return set_modem_info(ch, cmd, (unsigned int *) arg);
2627 * Here are any additional ioctl's that we want to implement
2632 * The linux tty driver doesn't have a flush
2633 * input routine for the driver, assuming all backed
2634 * up data is in the line disc. buffers. However,
2635 * we all know that's not the case. Here, we
2636 * act on the ioctl, but then lie and say we didn't
2637 * so the line discipline will process the flush
2640 rc = tty_check_change(tty);
2647 /* only flush input if this is the only open unit */
2648 if (!IS_PRINT(MINOR(tty_devnum(tty)))) {
2649 ch->ch_rout = ch->ch_rin;
2650 ch->ch_send |= RR_RX_FLUSH;
2651 (ch->ch_nd)->nd_tx_work = 1;
2652 (ch->ch_nd)->nd_tx_ready = 1;
2653 wake_up_interruptible(
2654 &(ch->ch_nd)->nd_tx_waitq);
2656 if (arg == TCIFLUSH)
2659 case TCOFLUSH: /* flush output, or the receive buffer */
2661 * This is handled in the tty_ioctl.c code
2662 * calling tty_flush_buffer
2667 /* POSIX.1 says return EINVAL if we got a bad arg */
2670 /* pretend we didn't recognize this IOCTL */
2671 return -ENOIOCTLCMD;
2676 /*****************************************
2678 TCSETA TCSETA - set the termios
2679 TCSETAF TCSETAF - wait for drain first, then set termios
2680 TCSETAW TCSETAW - wait for drain,
2681 flush the input queue, then set termios
2682 - looking at the tty_ioctl code, these command all call our
2683 tty_set_termios at the driver's end, when a TCSETA* is sent,
2684 it is expecting the tty to have a termio structure,
2685 NOT a termios structure. These two structures differ in size
2686 and the tty_ioctl code does a conversion before processing them both.
2687 - we should treat the TCSETAW TCSETAF ioctls the same, and let
2688 the tty_ioctl code do the conversion stuff.
2693 - the associated tty structure has a termios structure.
2694 *****************************************/
2698 return -ENOIOCTLCMD;
2705 * The linux tty driver doesn't have a flush
2706 * input routine for the driver, assuming all backed
2707 * up data is in the line disc. buffers. However,
2708 * we all know that's not the case. Here, we
2709 * act on the ioctl, but then lie and say we didn't
2710 * so the line discipline will process the flush
2715 * Also, now that we have TXPrint, we have to check
2716 * if this is the TXPrint device and the terminal
2717 * device is open. If so, do NOT run check_change,
2718 * as the terminal device is ALWAYS the parent.
2720 if (!IS_PRINT(MINOR(tty_devnum(tty))) ||
2721 !ch->ch_tun.un_open_count) {
2722 rc = tty_check_change(tty);
2727 /* wait for all the characters in tbuf to drain */
2728 tty_wait_until_sent(tty, 0);
2730 if ((cmd == TCSETSF) || (cmd == TCSETAF)) {
2731 /* flush the contents of the rbuf queue */
2732 /* TODO: check if this is print device? */
2733 ch->ch_send |= RR_RX_FLUSH;
2734 (ch->ch_nd)->nd_tx_ready = 1;
2735 (ch->ch_nd)->nd_tx_work = 1;
2736 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2737 /* do we need to do this? just to be safe! */
2738 ch->ch_rout = ch->ch_rin;
2741 /* pretend we didn't recognize this */
2742 return -ENOIOCTLCMD;
2746 * The Linux Line Discipline (LD) would do this for us if we
2747 * let it, but we have the special firmware options to do this
2748 * the "right way" regardless of hardware or software flow
2749 * control so we'll do it outselves instead of letting the LD
2752 rc = tty_check_change(tty);
2758 dgrp_tty_start(tty);
2764 dgrp_tty_input_start(tty);
2767 dgrp_tty_input_stop(tty);
2774 /* get information for ditty */
2775 if (copy_to_user((struct digi_struct __user *) arg,
2776 &ch->ch_digi, sizeof(struct digi_struct)))
2782 /* wait for all the characters in tbuf to drain */
2783 tty_wait_until_sent(tty, 0);
2785 if (cmd == DIGI_SETAF) {
2786 /* flush the contents of the rbuf queue */
2787 /* send down a packet with RR_RX_FLUSH set */
2788 ch->ch_send |= RR_RX_FLUSH;
2789 (ch->ch_nd)->nd_tx_ready = 1;
2790 (ch->ch_nd)->nd_tx_work = 1;
2791 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2792 /* do we need to do this? just to be safe! */
2793 ch->ch_rout = ch->ch_rin;
2796 /* pretend we didn't recognize this */
2800 return dgrp_tty_digiseta(tty, (struct digi_struct *) arg);
2803 return dgrp_tty_digisetedelay(tty, (int *) arg);
2806 return dgrp_tty_digigetedelay(tty, (int *) arg);
2810 if (cmd == (DIGI_GETFLOW)) {
2811 dflow.startc = tty->termios.c_cc[VSTART];
2812 dflow.stopc = tty->termios.c_cc[VSTOP];
2814 dflow.startc = ch->ch_xxon;
2815 dflow.stopc = ch->ch_xxoff;
2818 if (copy_to_user((char __user *)arg, &dflow, sizeof(dflow)))
2825 if (copy_from_user(&dflow, (char __user *)arg, sizeof(dflow)))
2828 if (cmd == (DIGI_SETFLOW)) {
2829 tty->termios.c_cc[VSTART] = dflow.startc;
2830 tty->termios.c_cc[VSTOP] = dflow.stopc;
2832 ch->ch_xxon = dflow.startc;
2833 ch->ch_xxoff = dflow.stopc;
2837 case DIGI_GETCUSTOMBAUD:
2838 if (put_user(ch->ch_custom_speed, (unsigned int __user *) arg))
2842 case DIGI_SETCUSTOMBAUD:
2846 if (get_user(new_rate, (unsigned int __user *) arg))
2848 dgrp_set_custom_speed(ch, new_rate);
2854 return -ENOIOCTLCMD;
2861 * This routine allows the tty driver to be notified when
2862 * the device's termios setting have changed. Note that we
2863 * should be prepared to accept the case where old == NULL
2864 * and try to do something rational.
2866 * So we need to make sure that our copies of ch_oflag,
2867 * ch_clag, and ch_iflag reflect the tty->termios flags.
2869 static void dgrp_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
2871 struct ktermios *ts;
2872 struct ch_struct *ch;
2873 struct un_struct *un;
2875 /* seems silly, but we have to check all these! */
2879 un = tty->driver_data;
2891 /* the CLOCAL flag has just been set */
2892 if (!(old->c_cflag & CLOCAL) && C_CLOCAL(tty))
2893 wake_up_interruptible(&un->un_open_wait);
2898 * Throttle receiving data. We just set a bit and stop reading
2899 * data out of the channel buffer. It will back up and the
2900 * FEP will do whatever is necessary to stop the far end.
2902 static void dgrp_tty_throttle(struct tty_struct *tty)
2904 struct ch_struct *ch;
2909 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2913 ch->ch_flag |= CH_RXSTOP;
2917 static void dgrp_tty_unthrottle(struct tty_struct *tty)
2919 struct ch_struct *ch;
2924 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2928 ch->ch_flag &= ~CH_RXSTOP;
2932 * Stop the transmitter
2934 static void dgrp_tty_stop(struct tty_struct *tty)
2936 struct ch_struct *ch;
2941 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2945 ch->ch_send |= RR_TX_STOP;
2946 ch->ch_send &= ~RR_TX_START;
2948 /* make the change NOW! */
2949 (ch->ch_nd)->nd_tx_ready = 1;
2950 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
2951 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2955 * Start the transmitter
2957 static void dgrp_tty_start(struct tty_struct *tty)
2959 struct ch_struct *ch;
2964 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2968 /* TODO: don't do anything if the transmitter is not stopped */
2970 ch->ch_send |= RR_TX_START;
2971 ch->ch_send &= ~RR_TX_STOP;
2973 /* make the change NOW! */
2974 (ch->ch_nd)->nd_tx_ready = 1;
2975 (ch->ch_nd)->nd_tx_work = 1;
2976 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
2977 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2984 static void dgrp_tty_input_stop(struct tty_struct *tty)
2986 struct ch_struct *ch;
2991 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2995 ch->ch_send |= RR_RX_STOP;
2996 ch->ch_send &= ~RR_RX_START;
2997 (ch->ch_nd)->nd_tx_ready = 1;
2998 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
2999 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
3004 static void dgrp_tty_send_xchar(struct tty_struct *tty, char c)
3006 struct un_struct *un;
3007 struct ch_struct *ch;
3012 un = tty->driver_data;
3019 if (c == STOP_CHAR(tty))
3020 ch->ch_send |= RR_RX_STOP;
3021 else if (c == START_CHAR(tty))
3022 ch->ch_send |= RR_RX_START;
3024 ch->ch_nd->nd_tx_ready = 1;
3025 ch->ch_nd->nd_tx_work = 1;
3031 static void dgrp_tty_input_start(struct tty_struct *tty)
3033 struct ch_struct *ch;
3038 ch = ((struct un_struct *) tty->driver_data)->un_ch;
3042 ch->ch_send |= RR_RX_START;
3043 ch->ch_send &= ~RR_RX_STOP;
3044 (ch->ch_nd)->nd_tx_ready = 1;
3045 (ch->ch_nd)->nd_tx_work = 1;
3046 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
3047 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
3053 * Hangup the port. Like a close, but don't wait for output
3056 * How do we close all the channels that are open?
3058 static void dgrp_tty_hangup(struct tty_struct *tty)
3060 struct ch_struct *ch;
3061 struct nd_struct *nd;
3062 struct un_struct *un;
3067 un = tty->driver_data;
3079 ch->ch_mout &= ~DM_DTR;
3080 /* Don't do this here */
3081 /* ch->ch_flag |= CH_HANGUP; */
3082 ch->ch_nd->nd_tx_ready = 1;
3083 ch->ch_nd->nd_tx_work = 1;
3084 if (waitqueue_active(&ch->ch_flag_wait))
3085 wake_up_interruptible(&ch->ch_flag_wait);
3090 /************************************************************************/
3092 /* TTY Initialization/Cleanup Functions */
3094 /************************************************************************/
3097 * Uninitialize the TTY portion of the supplied node. Free all
3098 * memory and resources associated with this node. Do it in reverse
3099 * allocation order: this might possibly result in less fragmentation
3100 * of memory, though I don't know this for sure.
3103 dgrp_tty_uninit(struct nd_struct *nd)
3108 ID_TO_CHAR(nd->nd_ID, id);
3110 if (nd->nd_ttdriver_flags & SERIAL_TTDRV_REG) {
3111 tty_unregister_driver(nd->nd_serial_ttdriver);
3113 kfree(nd->nd_serial_ttdriver->ttys);
3114 nd->nd_serial_ttdriver->ttys = NULL;
3116 put_tty_driver(nd->nd_serial_ttdriver);
3117 nd->nd_ttdriver_flags &= ~SERIAL_TTDRV_REG;
3120 if (nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG) {
3121 tty_unregister_driver(nd->nd_callout_ttdriver);
3123 kfree(nd->nd_callout_ttdriver->ttys);
3124 nd->nd_callout_ttdriver->ttys = NULL;
3126 put_tty_driver(nd->nd_callout_ttdriver);
3127 nd->nd_ttdriver_flags &= ~CALLOUT_TTDRV_REG;
3130 if (nd->nd_ttdriver_flags & XPRINT_TTDRV_REG) {
3131 tty_unregister_driver(nd->nd_xprint_ttdriver);
3133 kfree(nd->nd_xprint_ttdriver->ttys);
3134 nd->nd_xprint_ttdriver->ttys = NULL;
3136 put_tty_driver(nd->nd_xprint_ttdriver);
3137 nd->nd_ttdriver_flags &= ~XPRINT_TTDRV_REG;
3139 for (i = 0; i < CHAN_MAX; i++)
3140 tty_port_destroy(&nd->nd_chan[i].port);
3146 * Initialize the TTY portion of the supplied node.
3149 dgrp_tty_init(struct nd_struct *nd)
3155 ID_TO_CHAR(nd->nd_ID, id);
3158 * Initialize the TTDRIVER structures.
3161 nd->nd_serial_ttdriver = alloc_tty_driver(CHAN_MAX);
3162 if (!nd->nd_serial_ttdriver)
3165 sprintf(nd->nd_serial_name, "tty_dgrp_%s_", id);
3167 nd->nd_serial_ttdriver->owner = THIS_MODULE;
3168 nd->nd_serial_ttdriver->name = nd->nd_serial_name;
3169 nd->nd_serial_ttdriver->name_base = 0;
3170 nd->nd_serial_ttdriver->major = 0;
3171 nd->nd_serial_ttdriver->minor_start = 0;
3172 nd->nd_serial_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3173 nd->nd_serial_ttdriver->subtype = SERIAL_TYPE_NORMAL;
3174 nd->nd_serial_ttdriver->init_termios = DefaultTermios;
3175 nd->nd_serial_ttdriver->driver_name = "dgrp";
3176 nd->nd_serial_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3177 TTY_DRIVER_DYNAMIC_DEV |
3178 TTY_DRIVER_HARDWARE_BREAK);
3180 /* The kernel wants space to store pointers to tty_structs. */
3181 nd->nd_serial_ttdriver->ttys =
3182 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3183 if (!nd->nd_serial_ttdriver->ttys)
3186 tty_set_operations(nd->nd_serial_ttdriver, &dgrp_tty_ops);
3188 if (!(nd->nd_ttdriver_flags & SERIAL_TTDRV_REG)) {
3190 * Register tty devices
3192 rc = tty_register_driver(nd->nd_serial_ttdriver);
3195 * If errno is EBUSY, this means there are no more
3196 * slots available to have us auto-majored.
3197 * (Which is currently supported up to 256)
3199 * We can still request majors above 256,
3200 * we just have to do it manually.
3204 int max_majors = 1U << (32 - MINORBITS);
3205 for (i = 256; i < max_majors; i++) {
3206 nd->nd_serial_ttdriver->major = i;
3207 rc = tty_register_driver
3208 (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);