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 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1124 tty_ldisc_flush(tty);
1125 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1130 * Otherwise take a short nap.
1133 ch->ch_flag |= CH_DRAIN;
1135 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1137 schedule_timeout_interruptible(1);
1138 s = signal_pending(current);
1140 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1144 * If we had sent the printer off string, we now have
1147 * The system won't let us sleep since we got an error
1148 * back from sleep, presumably because the user did
1150 * But we need to ensure that the offstr gets sent!
1151 * Thus, we have to do something else besides sleeping.
1153 * 1) Make this task uninterruptable.
1154 * 2) Set up a timer to go off in 1 sec.
1155 * 3) Act as tho we just got out of the sleep above.
1157 * Thankfully, in the real world, this just
1161 if (sent_printer_offstr) {
1162 spin_unlock_irqrestore(&nd->nd_lock,
1165 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1173 * Restart the wait if any progress is seen.
1176 if (ch->ch_s_tpos != tpos) {
1177 tpos = ch->ch_s_tpos;
1179 /* TODO: this gives us timeout problems with nist ?? */
1180 waketime = jiffies + 15 * HZ;
1185 * Close the line discipline
1188 /* this is done in tty_io.c */
1189 /* if ((un->un_tty)->ldisc.close)
1190 * ((un->un_tty)->ldisc.close)(un->un_tty);
1193 /* don't do this here */
1194 /* un->un_flag = 0; */
1197 * Flush the receive buffer on terminal unit close only.
1200 if (!IS_PRINT(MINOR(tty_devnum(tty))))
1201 ch->ch_rout = ch->ch_rin;
1205 * Don't permit the close to happen until we get any pending
1206 * sync request responses.
1207 * There could be other ports depending upon the response as well.
1209 * Also, don't permit the close to happen until any parameter
1210 * changes have been sent out from the state machine as well.
1211 * This is required because of a ditty -a race with -HUPCL
1212 * We MUST make sure all channel parameters have been sent to the
1213 * Portserver before sending a close.
1216 if ((err != 1) && (ch->ch_state != CS_IDLE)) {
1217 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1218 s = wait_event_interruptible(ch->ch_flag_wait,
1219 ((ch->ch_flag & (CH_WAITING_SYNC | CH_PARAM)) == 0));
1220 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1224 * Cleanup the channel if last unit open.
1227 if (ch->ch_open_count == 1) {
1229 ch->ch_category = 0;
1232 ch->ch_tout = ch->ch_tin;
1233 /* (un->un_tty)->device = 0; */
1235 if (ch->ch_state == CS_READY)
1236 ch->ch_state = CS_SEND_CLOSE;
1240 * Send the changes to the server
1242 if (ch->ch_state != CS_IDLE) {
1243 ch->ch_flag |= CH_PARAM;
1244 wake_up_interruptible(&ch->ch_flag_wait);
1248 nd->nd_tx_ready = 1;
1253 if (ch->ch_open_count <= 0)
1255 "%s - unexpected value for ch->ch_open_count: %i\n",
1256 __func__, ch->ch_open_count);
1258 ch->ch_open_count--;
1260 if (un->un_open_count <= 0)
1262 "%s - unexpected value for un->un_open_count: %i\n",
1263 __func__, un->un_open_count);
1265 un->un_open_count--;
1267 un->un_flag &= ~(UN_NORMAL_ACTIVE | UN_CALLOUT_ACTIVE | UN_CLOSING);
1268 if (waitqueue_active(&un->un_close_wait))
1269 wake_up_interruptible(&un->un_close_wait);
1271 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1277 static void drp_wmove(struct ch_struct *ch, int from_user, void *buf, int count)
1282 ch->ch_nd->nd_tx_work = 1;
1284 n = TBUF_MAX - ch->ch_tin;
1288 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1289 (void __user *) buf, n);
1291 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1293 buf = (char *) buf + n;
1299 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1300 (void __user *) buf, count);
1302 memcpy(ch->ch_tbuf + ch->ch_tin, buf, count);
1304 ch->ch_tin += count;
1308 static int dgrp_calculate_txprint_bounds(struct ch_struct *ch, int space,
1313 unsigned short tmax = 0;
1316 * If the terminal device is busy, reschedule when
1317 * the terminal device becomes idle.
1320 if (ch->ch_tun.un_open_count != 0 &&
1321 ch->ch_tun.un_tty->ops->chars_in_buffer &&
1322 ((ch->ch_tun.un_tty->ops->chars_in_buffer)(ch->ch_tun.un_tty) != 0)) {
1323 *un_flag = UN_PWAIT;
1328 * Assure that whenever there is printer data in the output
1329 * buffer, there always remains enough space after it to
1330 * turn the printer off.
1332 space -= ch->ch_digi.digi_offlen;
1335 *un_flag = UN_EMPTY;
1340 * We measure printer CPS speed by incrementing
1341 * ch_cpstime by (HZ / digi_maxcps) for every
1342 * character we output, restricting output so
1343 * that ch_cpstime never exceeds lbolt.
1345 * However if output has not been done for some
1346 * time, lbolt will grow to very much larger than
1347 * ch_cpstime, which would allow essentially
1348 * unlimited amounts of output until ch_cpstime
1349 * finally caught up. To avoid this, we adjust
1350 * cps_time when necessary so the difference
1351 * between lbolt and ch_cpstime never results
1352 * in sending more than digi_bufsize characters.
1354 * This nicely models a printer with an internal
1355 * buffer of digi_bufsize characters.
1357 * Get the time between lbolt and ch->ch_cpstime;
1360 tt = jiffies - ch->ch_cpstime;
1363 * Compute the time required to send digi_bufsize
1367 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1370 * Compute the number of characters that can be sent
1371 * without violating the time constraint. If the
1372 * direct calculation of this number is bigger than
1373 * digi_bufsize, limit the number to digi_bufsize,
1374 * and adjust cpstime to match.
1377 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1378 tmax = ch->ch_digi.digi_bufsize;
1379 ch->ch_cpstime = jiffies - mt;
1381 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1385 * If the time constraint now binds, limit the transmit
1386 * count accordingly, and tentatively arrange to be
1387 * rescheduled based on time.
1396 * Compute the total number of characters we can
1397 * output before the total number of characters known
1398 * to be in the output queue exceeds digi_maxchar.
1401 tmax = (ch->ch_digi.digi_maxchar -
1402 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1403 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1407 * If the digi_maxchar constraint now holds, limit
1408 * the transmit count accordingly, and arrange to
1409 * be rescheduled when the queue becomes empty.
1413 *un_flag = UN_EMPTY;
1418 *un_flag |= UN_EMPTY;
1424 static int dgrp_tty_write(struct tty_struct *tty,
1425 const unsigned char *buf,
1428 struct nd_struct *nd;
1429 struct un_struct *un;
1430 struct ch_struct *ch;
1441 un = tty->driver_data;
1454 * Ignore the request if the channel is not ready.
1456 if (ch->ch_state != CS_READY)
1459 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1462 * Ignore the request if output is blocked.
1464 if ((un->un_flag & (UN_EMPTY | UN_LOW | UN_TIME | UN_PWAIT)) != 0) {
1470 * Also ignore the request if DPA has this port open,
1471 * and is flow controlled on reading more data.
1473 if (nd->nd_dpa_debug && nd->nd_dpa_flag & DPA_WAIT_SPACE &&
1474 nd->nd_dpa_port == MINOR(tty_devnum(ch->ch_tun.un_tty))) {
1480 * Limit amount we will write to the amount of space
1481 * available in the channel buffer.
1485 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1488 * Handle the printer device.
1493 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1496 unsigned short tmax = 0;
1499 * If the terminal device is busy, reschedule when
1500 * the terminal device becomes idle.
1503 if (ch->ch_tun.un_open_count != 0 &&
1504 ((ch->ch_tun.un_tty->ops->chars_in_buffer)(ch->ch_tun.un_tty) != 0)) {
1505 un->un_flag |= UN_PWAIT;
1511 * Assure that whenever there is printer data in the output
1512 * buffer, there always remains enough space after it to
1513 * turn the printer off.
1515 space -= ch->ch_digi.digi_offlen;
1518 * Output the printer on string.
1521 if ((ch->ch_flag & CH_PRON) == 0) {
1522 space -= ch->ch_digi.digi_onlen;
1525 un->un_flag |= UN_EMPTY;
1526 (ch->ch_nd)->nd_tx_work = 1;
1531 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1532 ch->ch_digi.digi_onlen);
1534 ch->ch_flag |= CH_PRON;
1538 * We measure printer CPS speed by incrementing
1539 * ch_cpstime by (HZ / digi_maxcps) for every
1540 * character we output, restricting output so
1541 * that ch_cpstime never exceeds lbolt.
1543 * However if output has not been done for some
1544 * time, lbolt will grow to very much larger than
1545 * ch_cpstime, which would allow essentially
1546 * unlimited amounts of output until ch_cpstime
1547 * finally caught up. To avoid this, we adjust
1548 * cps_time when necessary so the difference
1549 * between lbolt and ch_cpstime never results
1550 * in sending more than digi_bufsize characters.
1552 * This nicely models a printer with an internal
1553 * buffer of digi_bufsize characters.
1555 * Get the time between lbolt and ch->ch_cpstime;
1558 tt = jiffies - ch->ch_cpstime;
1561 * Compute the time required to send digi_bufsize
1565 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1568 * Compute the number of characters that can be sent
1569 * without violating the time constraint. If the
1570 * direct calculation of this number is bigger than
1571 * digi_bufsize, limit the number to digi_bufsize,
1572 * and adjust cpstime to match.
1575 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1576 tmax = ch->ch_digi.digi_bufsize;
1577 ch->ch_cpstime = jiffies - mt;
1579 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1583 * If the time constraint now binds, limit the transmit
1584 * count accordingly, and tentatively arrange to be
1585 * rescheduled based on time.
1594 * Compute the total number of characters we can
1595 * output before the total number of characters known
1596 * to be in the output queue exceeds digi_maxchar.
1599 tmax = (ch->ch_digi.digi_maxchar -
1600 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1601 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1605 * If the digi_maxchar constraint now holds, limit
1606 * the transmit count accordingly, and arrange to
1607 * be rescheduled when the queue becomes empty.
1617 * Handle the terminal device.
1622 * If the printer device is on, turn it off.
1625 if ((ch->ch_flag & CH_PRON) != 0) {
1627 space -= ch->ch_digi.digi_offlen;
1629 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1630 ch->ch_digi.digi_offlen);
1632 ch->ch_flag &= ~CH_PRON;
1637 * If space is 0 and its because the ch->tbuf
1638 * is full, then Linux will handle a callback when queue
1639 * space becomes available.
1640 * tty_write returns count = 0
1644 /* the linux tty_io.c handles this if we return 0 */
1645 /* if (fp->flags & O_NONBLOCK) return -EAGAIN; */
1647 un->un_flag |= UN_EMPTY;
1648 (ch->ch_nd)->nd_tx_work = 1;
1653 count = min(count, space);
1660 * Copy the buffer contents to the ch_tbuf
1661 * being careful to wrap around the circular queue
1664 t = TBUF_MAX - ch->ch_tin;
1668 memcpy(ch->ch_tbuf + ch->ch_tin, buf, t);
1669 if (nd->nd_dpa_debug && nd->nd_dpa_port == PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1670 dgrp_dpa_data(nd, 0, (char *) buf, t);
1677 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1678 if (nd->nd_dpa_debug && nd->nd_dpa_port == PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1679 dgrp_dpa_data(nd, 0, (char *) buf, n);
1685 (ch->ch_nd)->nd_tx_work = 1;
1686 if (ch->ch_edelay != DGRP_RTIME) {
1687 (ch->ch_nd)->nd_tx_ready = 1;
1688 wake_up_interruptible(&nd->nd_tx_waitq);
1692 ch->ch_txcount += count;
1694 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1697 * Adjust ch_cpstime to account
1698 * for the characters just output.
1701 if (sendcount > 0) {
1702 int cc = HZ * sendcount + ch->ch_cpsrem;
1704 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1705 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1709 * If we are now waiting on time, schedule ourself
1710 * back when we'll be able to send a block of
1711 * digi_maxchar characters.
1714 if ((un_flag & UN_TIME) != 0) {
1715 ch->ch_waketime = (ch->ch_cpstime +
1716 (ch->ch_digi.digi_maxchar * HZ /
1717 ch->ch_digi.digi_maxcps));
1722 * If the printer unit is waiting for completion
1723 * of terminal output, get him going again.
1726 if ((ch->ch_pun.un_flag & UN_PWAIT) != 0)
1727 (ch->ch_nd)->nd_tx_work = 1;
1730 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1737 * Put a character into ch->ch_buf
1739 * - used by the line discipline for OPOST processing
1742 static int dgrp_tty_put_char(struct tty_struct *tty, unsigned char new_char)
1744 struct un_struct *un;
1745 struct ch_struct *ch;
1753 un = tty->driver_data;
1761 if (ch->ch_state != CS_READY)
1764 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1768 * If space is 0 and its because the ch->tbuf
1769 * Warn and dump the character, there isn't anything else
1770 * we can do about it. David_Fries@digi.com
1773 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1778 * Output the printer on string if device is TXPrint.
1780 if (IS_PRINT(MINOR(tty_devnum(tty))) && (ch->ch_flag & CH_PRON) == 0) {
1781 if (space < ch->ch_digi.digi_onlen) {
1785 space -= ch->ch_digi.digi_onlen;
1786 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1787 ch->ch_digi.digi_onlen);
1788 ch->ch_flag |= CH_PRON;
1792 * Output the printer off string if device is NOT TXPrint.
1795 if (!IS_PRINT(MINOR(tty_devnum(tty))) &&
1796 ((ch->ch_flag & CH_PRON) != 0)) {
1797 if (space < ch->ch_digi.digi_offlen) {
1802 space -= ch->ch_digi.digi_offlen;
1803 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1804 ch->ch_digi.digi_offlen);
1805 ch->ch_flag &= ~CH_PRON;
1814 * Copy the character to the ch_tbuf being
1815 * careful to wrap around the circular queue
1817 ch->ch_tbuf[ch->ch_tin] = new_char;
1818 ch->ch_tin = (1 + ch->ch_tin) & TBUF_MASK;
1820 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1823 * Adjust ch_cpstime to account
1824 * for the character just output.
1827 int cc = HZ + ch->ch_cpsrem;
1829 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1830 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1833 * If we are now waiting on time, schedule ourself
1834 * back when we'll be able to send a block of
1835 * digi_maxchar characters.
1838 ch->ch_waketime = (ch->ch_cpstime +
1839 (ch->ch_digi.digi_maxchar * HZ /
1840 ch->ch_digi.digi_maxcps));
1845 (ch->ch_nd)->nd_tx_work = 1;
1849 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1856 * Flush TX buffer (make in == out)
1858 * check tty_ioctl.c -- this is called after TCOFLUSH
1860 static void dgrp_tty_flush_buffer(struct tty_struct *tty)
1862 struct un_struct *un;
1863 struct ch_struct *ch;
1867 un = tty->driver_data;
1875 ch->ch_tout = ch->ch_tin;
1876 /* do NOT do this here! */
1877 /* ch->ch_s_tpos = ch->ch_s_tin = 0; */
1879 /* send the flush output command now */
1880 ch->ch_send |= RR_TX_FLUSH;
1881 (ch->ch_nd)->nd_tx_ready = 1;
1882 (ch->ch_nd)->nd_tx_work = 1;
1883 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
1885 if (waitqueue_active(&tty->write_wait))
1886 wake_up_interruptible(&tty->write_wait);
1893 * Return space available in Tx buffer
1894 * count = ( ch->ch_tout - ch->ch_tin ) mod (TBUF_MAX - 1)
1896 static int dgrp_tty_write_room(struct tty_struct *tty)
1898 struct un_struct *un;
1899 struct ch_struct *ch;
1905 un = tty->driver_data;
1913 count = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1915 /* We *MUST* check this, and return 0 if the Printer Unit cannot
1916 * take any more data within its time constraints... If we don't
1917 * return 0 and the printer has hit it time constraint, the ld will
1918 * call us back doing a put_char, which cannot be rejected!!!
1920 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1922 count = dgrp_calculate_txprint_bounds(ch, count, &un_flag);
1926 ch->ch_pun.un_flag |= un_flag;
1927 (ch->ch_nd)->nd_tx_work = 1;
1934 * Return number of characters that have not been transmitted yet.
1935 * chars_in_buffer = ( ch->ch_tin - ch->ch_tout ) mod (TBUF_MAX - 1)
1936 * + ( ch->ch_s_tin - ch->ch_s_tout ) mod (0xffff)
1937 * = number of characters "in transit"
1939 * Remember that sequence number math is always with a sixteen bit
1940 * mask, not the TBUF_MASK.
1943 static int dgrp_tty_chars_in_buffer(struct tty_struct *tty)
1945 struct un_struct *un;
1946 struct ch_struct *ch;
1953 un = tty->driver_data;
1961 count1 = count = (ch->ch_tin - ch->ch_tout) & TBUF_MASK;
1962 count += (ch->ch_s_tin - ch->ch_s_tpos) & 0xffff;
1963 /* one for tbuf, one for the PS */
1966 * If we are busy transmitting add 1
1968 count += un->un_tbusy;
1974 /*****************************************************************************
1976 * Helper applications for dgrp_tty_ioctl()
1978 *****************************************************************************
1983 * ch_to_tty_flags() -- convert channel flags to termio flags
1984 * @ch_flag: Digi channel flags
1985 * @flagtype: type of ch_flag (iflag, oflag or cflag)
1987 * take the channel flags of the specified type and return the
1988 * corresponding termio flag
1990 static tcflag_t ch_to_tty_flags(ushort ch_flag, char flagtype)
1992 tcflag_t retval = 0;
1996 retval = ((ch_flag & IF_IGNBRK) ? IGNBRK : 0)
1997 | ((ch_flag & IF_BRKINT) ? BRKINT : 0)
1998 | ((ch_flag & IF_IGNPAR) ? IGNPAR : 0)
1999 | ((ch_flag & IF_PARMRK) ? PARMRK : 0)
2000 | ((ch_flag & IF_INPCK) ? INPCK : 0)
2001 | ((ch_flag & IF_ISTRIP) ? ISTRIP : 0)
2002 | ((ch_flag & IF_IXON) ? IXON : 0)
2003 | ((ch_flag & IF_IXANY) ? IXANY : 0)
2004 | ((ch_flag & IF_IXOFF) ? IXOFF : 0);
2008 retval = ((ch_flag & OF_OLCUC) ? OLCUC : 0)
2009 | ((ch_flag & OF_ONLCR) ? ONLCR : 0)
2010 | ((ch_flag & OF_OCRNL) ? OCRNL : 0)
2011 | ((ch_flag & OF_ONOCR) ? ONOCR : 0)
2012 | ((ch_flag & OF_ONLRET) ? ONLRET : 0)
2013 /* | ((ch_flag & OF_OTAB3) ? OFILL : 0) */
2014 | ((ch_flag & OF_TABDLY) ? TABDLY : 0);
2018 retval = ((ch_flag & CF_CSTOPB) ? CSTOPB : 0)
2019 | ((ch_flag & CF_CREAD) ? CREAD : 0)
2020 | ((ch_flag & CF_PARENB) ? PARENB : 0)
2021 | ((ch_flag & CF_PARODD) ? PARODD : 0)
2022 | ((ch_flag & CF_HUPCL) ? HUPCL : 0);
2024 switch (ch_flag & CF_CSIZE) {
2055 * tty_to_ch_flags() -- convert termio flags to digi channel flags
2056 * @tty: pointer to a TTY structure holding flag to be converted
2057 * @flagtype: identifies which flag (iflags, oflags, or cflags) should
2060 * take the termio flag of the specified type and return the
2061 * corresponding Digi version of the flags
2063 static ushort tty_to_ch_flags(struct tty_struct *tty, char flagtype)
2070 tflag = tty->termios.c_iflag;
2071 retval = (I_IGNBRK(tty) ? IF_IGNBRK : 0)
2072 | (I_BRKINT(tty) ? IF_BRKINT : 0)
2073 | (I_IGNPAR(tty) ? IF_IGNPAR : 0)
2074 | (I_PARMRK(tty) ? IF_PARMRK : 0)
2075 | (I_INPCK(tty) ? IF_INPCK : 0)
2076 | (I_ISTRIP(tty) ? IF_ISTRIP : 0)
2077 | (I_IXON(tty) ? IF_IXON : 0)
2078 | (I_IXANY(tty) ? IF_IXANY : 0)
2079 | (I_IXOFF(tty) ? IF_IXOFF : 0);
2082 tflag = tty->termios.c_oflag;
2084 * If OPOST is set, then do the post processing in the
2085 * firmware by setting all the processing flags on.
2086 * If ~OPOST, then make sure we are not doing any
2087 * output processing!!
2092 retval = (O_OLCUC(tty) ? OF_OLCUC : 0)
2093 | (O_ONLCR(tty) ? OF_ONLCR : 0)
2094 | (O_OCRNL(tty) ? OF_OCRNL : 0)
2095 | (O_ONOCR(tty) ? OF_ONOCR : 0)
2096 | (O_ONLRET(tty) ? OF_ONLRET : 0)
2097 /* | (O_OFILL(tty) ? OF_TAB3 : 0) */
2098 | (O_TABDLY(tty) ? OF_TABDLY : 0);
2101 tflag = tty->termios.c_cflag;
2102 retval = (C_CSTOPB(tty) ? CF_CSTOPB : 0)
2103 | (C_CREAD(tty) ? CF_CREAD : 0)
2104 | (C_PARENB(tty) ? CF_PARENB : 0)
2105 | (C_PARODD(tty) ? CF_PARODD : 0)
2106 | (C_HUPCL(tty) ? CF_HUPCL : 0);
2107 switch (C_CSIZE(tty)) {
2137 static int dgrp_tty_send_break(struct tty_struct *tty, int msec)
2139 struct un_struct *un;
2140 struct ch_struct *ch;
2146 un = tty->driver_data;
2154 dgrp_send_break(ch, msec);
2160 * This routine sends a break character out the serial port.
2162 * duration is in 1/1000's of a second
2164 static int dgrp_send_break(struct ch_struct *ch, int msec)
2168 wait_event_interruptible(ch->ch_flag_wait,
2169 ((ch->ch_flag & CH_TX_BREAK) == 0));
2170 ch->ch_break_time += max(msec, 250);
2171 ch->ch_send |= RR_TX_BREAK;
2172 ch->ch_flag |= CH_TX_BREAK;
2173 (ch->ch_nd)->nd_tx_work = 1;
2175 x = (msec * HZ) / 1000;
2176 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2183 * Return modem signals to ld.
2185 static int dgrp_tty_tiocmget(struct tty_struct *tty)
2188 struct un_struct *un = tty->driver_data;
2189 struct ch_struct *ch;
2198 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2199 (ch->ch_mout & (DM_RTS | DM_DTR)));
2201 /* defined in /usr/include/asm/termios.h */
2202 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2203 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2204 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2205 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2206 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2207 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2216 static int dgrp_tty_tiocmset(struct tty_struct *tty,
2217 unsigned int set, unsigned int clear)
2220 struct un_struct *un = tty->driver_data;
2221 struct ch_struct *ch;
2230 if (set & TIOCM_RTS)
2231 ch->ch_mout |= DM_RTS;
2233 if (set & TIOCM_DTR)
2234 ch->ch_mout |= DM_DTR;
2236 if (clear & TIOCM_RTS)
2237 ch->ch_mout &= ~(DM_RTS);
2239 if (clear & TIOCM_DTR)
2240 ch->ch_mout &= ~(DM_DTR);
2242 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2243 ch->ch_flag |= CH_PARAM;
2244 (ch->ch_nd)->nd_tx_work = 1;
2245 wake_up_interruptible(&ch->ch_flag_wait);
2247 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2255 * Get current modem status
2257 static int get_modem_info(struct ch_struct *ch, unsigned int *value)
2261 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2262 (ch->ch_mout & (DM_RTS | DM_DTR)));
2264 /* defined in /usr/include/asm/termios.h */
2265 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2266 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2267 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2268 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2269 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2270 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2271 return put_user(mlast, (unsigned int __user *) value);
2277 static int set_modem_info(struct ch_struct *ch, unsigned int command,
2278 unsigned int *value)
2285 error = access_ok(VERIFY_READ, (void __user *) value, sizeof(int));
2289 if (get_user(arg, (unsigned int __user *) value))
2291 mval |= ((arg & TIOCM_RTS) ? DM_RTS : 0)
2292 | ((arg & TIOCM_DTR) ? DM_DTR : 0);
2295 case TIOCMBIS: /* set flags */
2296 ch->ch_mout |= mval;
2298 case TIOCMBIC: /* clear flags */
2299 ch->ch_mout &= ~mval;
2308 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2310 ch->ch_flag |= CH_PARAM;
2311 (ch->ch_nd)->nd_tx_work = 1;
2312 wake_up_interruptible(&ch->ch_flag_wait);
2314 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2321 * Assign the custom baud rate to the channel structure
2323 static void dgrp_set_custom_speed(struct ch_struct *ch, int newrate)
2329 int deltahigh, deltalow;
2335 * Since the divisor is stored in a 16-bit integer, we make sure
2336 * we don't allow any rates smaller than a 16-bit integer would allow.
2337 * And of course, rates above the dividend won't fly.
2339 if (newrate && newrate < ((PORTSERVER_DIVIDEND / 0xFFFF) + 1))
2340 newrate = ((PORTSERVER_DIVIDEND / 0xFFFF) + 1);
2341 if (newrate && newrate > PORTSERVER_DIVIDEND)
2342 newrate = PORTSERVER_DIVIDEND;
2344 while (newrate > 0) {
2345 testdiv = PORTSERVER_DIVIDEND / newrate;
2348 * If we try to figure out what rate the PortServer would use
2349 * with the test divisor, it will be either equal or higher
2350 * than the requested baud rate. If we then determine the
2351 * rate with a divisor one higher, we will get the next lower
2352 * supported rate below the requested.
2354 testrate_high = PORTSERVER_DIVIDEND / testdiv;
2355 testrate_low = PORTSERVER_DIVIDEND / (testdiv + 1);
2358 * If the rate for the requested divisor is correct, just
2359 * use it and be done.
2361 if (testrate_high == newrate)
2365 * Otherwise, pick the rate that is closer (i.e. whichever rate
2366 * has a smaller delta).
2368 deltahigh = testrate_high - newrate;
2369 deltalow = newrate - testrate_low;
2371 if (deltahigh < deltalow)
2372 newrate = testrate_high;
2374 newrate = testrate_low;
2379 ch->ch_custom_speed = newrate;
2388 # dgrp_tty_digiseta()
2390 * Ioctl to set the information from ditty.
2392 * NOTE: DIGI_IXON, DSRPACE, DCDPACE, and DTRPACE are unsupported. JAR 990922
2394 static int dgrp_tty_digiseta(struct tty_struct *tty,
2395 struct digi_struct *new_info)
2397 struct un_struct *un = tty->driver_data;
2398 struct ch_struct *ch;
2407 if (copy_from_user(&ch->ch_digi, (void __user *) new_info,
2408 sizeof(struct digi_struct)))
2411 if ((ch->ch_digi.digi_flags & RTSPACE) ||
2412 (ch->ch_digi.digi_flags & CTSPACE))
2413 tty->termios.c_cflag |= CRTSCTS;
2415 tty->termios.c_cflag &= ~CRTSCTS;
2417 if (ch->ch_digi.digi_maxcps < 1)
2418 ch->ch_digi.digi_maxcps = 1;
2420 if (ch->ch_digi.digi_maxcps > 10000)
2421 ch->ch_digi.digi_maxcps = 10000;
2423 if (ch->ch_digi.digi_bufsize < 10)
2424 ch->ch_digi.digi_bufsize = 10;
2426 if (ch->ch_digi.digi_maxchar < 1)
2427 ch->ch_digi.digi_maxchar = 1;
2429 if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
2430 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;
2432 if (ch->ch_digi.digi_onlen > DIGI_PLEN)
2433 ch->ch_digi.digi_onlen = DIGI_PLEN;
2435 if (ch->ch_digi.digi_offlen > DIGI_PLEN)
2436 ch->ch_digi.digi_offlen = DIGI_PLEN;
2438 /* make the changes now */
2447 * dgrp_tty_digigetedelay()
2449 * Ioctl to get the current edelay setting.
2454 static int dgrp_tty_digigetedelay(struct tty_struct *tty, int *retinfo)
2456 struct un_struct *un;
2457 struct ch_struct *ch;
2463 if (!tty || tty->magic != TTY_MAGIC)
2466 un = tty->driver_data;
2475 tmp = ch->ch_edelay;
2477 if (copy_to_user((void __user *) retinfo, &tmp, sizeof(*retinfo)))
2485 * dgrp_tty_digisetedelay()
2487 * Ioctl to set the EDELAY setting
2490 static int dgrp_tty_digisetedelay(struct tty_struct *tty, int *new_info)
2492 struct un_struct *un;
2493 struct ch_struct *ch;
2496 if (!tty || tty->magic != TTY_MAGIC)
2499 un = tty->driver_data;
2508 if (copy_from_user(&new_digi, (void __user *)new_info, sizeof(int)))
2511 ch->ch_edelay = new_digi;
2513 /* make the changes now */
2521 * The usual assortment of ioctl's
2523 * note: use tty_check_change to make sure that we are not
2524 * changing the state of a terminal when we are not a process
2525 * in the forground. See tty_io.c
2526 * rc = tty_check_change(tty);
2527 * if (rc) return rc;
2529 static int dgrp_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
2532 struct un_struct *un;
2533 struct ch_struct *ch;
2535 struct digiflow_struct dflow;
2540 un = tty->driver_data;
2551 * Here are all the standard ioctl's that we MUST implement
2556 * TCSBRK is SVID version: non-zero arg --> no break
2557 * this behaviour is exploited by tcdrain().
2559 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2560 * between 0.25 and 0.5 seconds
2563 rc = tty_check_change(tty);
2566 tty_wait_until_sent(tty, 0);
2569 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2571 if (dgrp_tty_chars_in_buffer(tty) != 0)
2577 /* support for POSIX tcsendbreak()
2579 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2580 * between 0.25 and 0.5 seconds so we'll ask for something
2581 * in the middle: 0.375 seconds.
2583 rc = tty_check_change(tty);
2586 tty_wait_until_sent(tty, 0);
2588 rc = dgrp_send_break(ch, arg ? arg*250 : 250);
2590 if (dgrp_tty_chars_in_buffer(tty) != 0)
2595 rc = tty_check_change(tty);
2598 tty_wait_until_sent(tty, 0);
2601 * RealPort doesn't support turning on a break unconditionally.
2602 * The RealPort device will stop sending a break automatically
2603 * after the specified time value that we send in.
2605 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2607 if (dgrp_tty_chars_in_buffer(tty) != 0)
2613 * RealPort doesn't support turning off a break unconditionally.
2614 * The RealPort device will stop sending a break automatically
2615 * after the specified time value that was sent when turning on
2621 rc = access_ok(VERIFY_WRITE, (void __user *) arg,
2622 sizeof(unsigned int));
2625 return get_modem_info(ch, (unsigned int *) arg);
2630 return set_modem_info(ch, cmd, (unsigned int *) arg);
2633 * Here are any additional ioctl's that we want to implement
2638 * The linux tty driver doesn't have a flush
2639 * input routine for the driver, assuming all backed
2640 * up data is in the line disc. buffers. However,
2641 * we all know that's not the case. Here, we
2642 * act on the ioctl, but then lie and say we didn't
2643 * so the line discipline will process the flush
2646 rc = tty_check_change(tty);
2653 /* only flush input if this is the only open unit */
2654 if (!IS_PRINT(MINOR(tty_devnum(tty)))) {
2655 ch->ch_rout = ch->ch_rin;
2656 ch->ch_send |= RR_RX_FLUSH;
2657 (ch->ch_nd)->nd_tx_work = 1;
2658 (ch->ch_nd)->nd_tx_ready = 1;
2659 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2661 if (arg == TCIFLUSH)
2664 case TCOFLUSH: /* flush output, or the receive buffer */
2666 * This is handled in the tty_ioctl.c code
2667 * calling tty_flush_buffer
2672 /* POSIX.1 says return EINVAL if we got a bad arg */
2675 /* pretend we didn't recognize this IOCTL */
2676 return -ENOIOCTLCMD;
2681 /*****************************************
2683 TCSETA TCSETA - set the termios
2684 TCSETAF TCSETAF - wait for drain first, then set termios
2685 TCSETAW TCSETAW - wait for drain, flush the input queue, then set termios
2686 - looking at the tty_ioctl code, these command all call our
2687 tty_set_termios at the driver's end, when a TCSETA* is sent,
2688 it is expecting the tty to have a termio structure,
2689 NOT a termios structure. These two structures differ in size
2690 and the tty_ioctl code does a conversion before processing them both.
2691 - we should treat the TCSETAW TCSETAF ioctls the same, and let
2692 the tty_ioctl code do the conversion stuff.
2697 - the associated tty structure has a termios structure.
2698 *****************************************/
2702 return -ENOIOCTLCMD;
2709 * The linux tty driver doesn't have a flush
2710 * input routine for the driver, assuming all backed
2711 * up data is in the line disc. buffers. However,
2712 * we all know that's not the case. Here, we
2713 * act on the ioctl, but then lie and say we didn't
2714 * so the line discipline will process the flush
2719 * Also, now that we have TXPrint, we have to check
2720 * if this is the TXPrint device and the terminal
2721 * device is open. If so, do NOT run check_change,
2722 * as the terminal device is ALWAYS the parent.
2724 if (!IS_PRINT(MINOR(tty_devnum(tty))) ||
2725 !ch->ch_tun.un_open_count) {
2726 rc = tty_check_change(tty);
2731 /* wait for all the characters in tbuf to drain */
2732 tty_wait_until_sent(tty, 0);
2734 if ((cmd == TCSETSF) || (cmd == TCSETAF)) {
2735 /* flush the contents of the rbuf queue */
2736 /* TODO: check if this is print device? */
2737 ch->ch_send |= RR_RX_FLUSH;
2738 (ch->ch_nd)->nd_tx_ready = 1;
2739 (ch->ch_nd)->nd_tx_work = 1;
2740 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2741 /* do we need to do this? just to be safe! */
2742 ch->ch_rout = ch->ch_rin;
2745 /* pretend we didn't recognize this */
2746 return -ENOIOCTLCMD;
2750 * The Linux Line Discipline (LD) would do this for us if we
2751 * let it, but we have the special firmware options to do this
2752 * the "right way" regardless of hardware or software flow
2753 * control so we'll do it outselves instead of letting the LD
2756 rc = tty_check_change(tty);
2762 dgrp_tty_start(tty);
2768 dgrp_tty_input_start(tty);
2771 dgrp_tty_input_stop(tty);
2778 /* get information for ditty */
2779 if (copy_to_user((struct digi_struct __user *) arg,
2780 &ch->ch_digi, sizeof(struct digi_struct)))
2786 /* wait for all the characters in tbuf to drain */
2787 tty_wait_until_sent(tty, 0);
2789 if (cmd == DIGI_SETAF) {
2790 /* flush the contents of the rbuf queue */
2791 /* send down a packet with RR_RX_FLUSH set */
2792 ch->ch_send |= RR_RX_FLUSH;
2793 (ch->ch_nd)->nd_tx_ready = 1;
2794 (ch->ch_nd)->nd_tx_work = 1;
2795 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2796 /* do we need to do this? just to be safe! */
2797 ch->ch_rout = ch->ch_rin;
2800 /* pretend we didn't recognize this */
2803 return dgrp_tty_digiseta(tty, (struct digi_struct *) arg);
2806 return dgrp_tty_digisetedelay(tty, (int *) arg);
2809 return dgrp_tty_digigetedelay(tty, (int *) arg);
2813 if (cmd == (DIGI_GETFLOW)) {
2814 dflow.startc = tty->termios.c_cc[VSTART];
2815 dflow.stopc = tty->termios.c_cc[VSTOP];
2817 dflow.startc = ch->ch_xxon;
2818 dflow.stopc = ch->ch_xxoff;
2821 if (copy_to_user((char __user *)arg, &dflow, sizeof(dflow)))
2828 if (copy_from_user(&dflow, (char __user *)arg, sizeof(dflow)))
2831 if (cmd == (DIGI_SETFLOW)) {
2832 tty->termios.c_cc[VSTART] = dflow.startc;
2833 tty->termios.c_cc[VSTOP] = dflow.stopc;
2835 ch->ch_xxon = dflow.startc;
2836 ch->ch_xxoff = dflow.stopc;
2840 case DIGI_GETCUSTOMBAUD:
2841 if (put_user(ch->ch_custom_speed, (unsigned int __user *) arg))
2845 case DIGI_SETCUSTOMBAUD:
2849 if (get_user(new_rate, (unsigned int __user *) arg))
2851 dgrp_set_custom_speed(ch, new_rate);
2857 return -ENOIOCTLCMD;
2864 * This routine allows the tty driver to be notified when
2865 * the device's termios setting have changed. Note that we
2866 * should be prepared to accept the case where old == NULL
2867 * and try to do something rational.
2869 * So we need to make sure that our copies of ch_oflag,
2870 * ch_clag, and ch_iflag reflect the tty->termios flags.
2872 static void dgrp_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
2874 struct ktermios *ts;
2875 struct ch_struct *ch;
2876 struct un_struct *un;
2878 /* seems silly, but we have to check all these! */
2882 un = tty->driver_data;
2894 /* the CLOCAL flag has just been set */
2895 if (!(old->c_cflag & CLOCAL) && C_CLOCAL(tty))
2896 wake_up_interruptible(&un->un_open_wait);
2901 * Throttle receiving data. We just set a bit and stop reading
2902 * data out of the channel buffer. It will back up and the
2903 * FEP will do whatever is necessary to stop the far end.
2905 static void dgrp_tty_throttle(struct tty_struct *tty)
2907 struct ch_struct *ch;
2912 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2916 ch->ch_flag |= CH_RXSTOP;
2920 static void dgrp_tty_unthrottle(struct tty_struct *tty)
2922 struct ch_struct *ch;
2927 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2931 ch->ch_flag &= ~CH_RXSTOP;
2935 * Stop the transmitter
2937 static void dgrp_tty_stop(struct tty_struct *tty)
2939 struct ch_struct *ch;
2944 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2948 ch->ch_send |= RR_TX_STOP;
2949 ch->ch_send &= ~RR_TX_START;
2951 /* make the change NOW! */
2952 (ch->ch_nd)->nd_tx_ready = 1;
2953 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
2954 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2958 * Start the transmitter
2960 static void dgrp_tty_start(struct tty_struct *tty)
2962 struct ch_struct *ch;
2967 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2971 /* TODO: don't do anything if the transmitter is not stopped */
2973 ch->ch_send |= RR_TX_START;
2974 ch->ch_send &= ~RR_TX_STOP;
2976 /* make the change NOW! */
2977 (ch->ch_nd)->nd_tx_ready = 1;
2978 (ch->ch_nd)->nd_tx_work = 1;
2979 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
2980 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2987 static void dgrp_tty_input_stop(struct tty_struct *tty)
2989 struct ch_struct *ch;
2994 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2998 ch->ch_send |= RR_RX_STOP;
2999 ch->ch_send &= ~RR_RX_START;
3000 (ch->ch_nd)->nd_tx_ready = 1;
3001 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
3002 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
3007 static void dgrp_tty_send_xchar(struct tty_struct *tty, char c)
3009 struct un_struct *un;
3010 struct ch_struct *ch;
3015 un = tty->driver_data;
3022 if (c == STOP_CHAR(tty))
3023 ch->ch_send |= RR_RX_STOP;
3024 else if (c == START_CHAR(tty))
3025 ch->ch_send |= RR_RX_START;
3027 ch->ch_nd->nd_tx_ready = 1;
3028 ch->ch_nd->nd_tx_work = 1;
3034 static void dgrp_tty_input_start(struct tty_struct *tty)
3036 struct ch_struct *ch;
3041 ch = ((struct un_struct *) tty->driver_data)->un_ch;
3045 ch->ch_send |= RR_RX_START;
3046 ch->ch_send &= ~RR_RX_STOP;
3047 (ch->ch_nd)->nd_tx_ready = 1;
3048 (ch->ch_nd)->nd_tx_work = 1;
3049 if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
3050 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
3056 * Hangup the port. Like a close, but don't wait for output
3059 * How do we close all the channels that are open?
3061 static void dgrp_tty_hangup(struct tty_struct *tty)
3063 struct ch_struct *ch;
3064 struct nd_struct *nd;
3065 struct un_struct *un;
3070 un = tty->driver_data;
3082 ch->ch_mout &= ~DM_DTR;
3083 /* Don't do this here */
3084 /* ch->ch_flag |= CH_HANGUP; */
3085 ch->ch_nd->nd_tx_ready = 1;
3086 ch->ch_nd->nd_tx_work = 1;
3087 if (waitqueue_active(&ch->ch_flag_wait))
3088 wake_up_interruptible(&ch->ch_flag_wait);
3093 /************************************************************************/
3095 /* TTY Initialization/Cleanup Functions */
3097 /************************************************************************/
3100 * Uninitialize the TTY portion of the supplied node. Free all
3101 * memory and resources associated with this node. Do it in reverse
3102 * allocation order: this might possibly result in less fragmentation
3103 * of memory, though I don't know this for sure.
3106 dgrp_tty_uninit(struct nd_struct *nd)
3111 ID_TO_CHAR(nd->nd_ID, id);
3113 if (nd->nd_ttdriver_flags & SERIAL_TTDRV_REG) {
3114 tty_unregister_driver(nd->nd_serial_ttdriver);
3116 kfree(nd->nd_serial_ttdriver->ttys);
3117 nd->nd_serial_ttdriver->ttys = NULL;
3119 put_tty_driver(nd->nd_serial_ttdriver);
3120 nd->nd_ttdriver_flags &= ~SERIAL_TTDRV_REG;
3123 if (nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG) {
3124 tty_unregister_driver(nd->nd_callout_ttdriver);
3126 kfree(nd->nd_callout_ttdriver->ttys);
3127 nd->nd_callout_ttdriver->ttys = NULL;
3129 put_tty_driver(nd->nd_callout_ttdriver);
3130 nd->nd_ttdriver_flags &= ~CALLOUT_TTDRV_REG;
3133 if (nd->nd_ttdriver_flags & XPRINT_TTDRV_REG) {
3134 tty_unregister_driver(nd->nd_xprint_ttdriver);
3136 kfree(nd->nd_xprint_ttdriver->ttys);
3137 nd->nd_xprint_ttdriver->ttys = NULL;
3139 put_tty_driver(nd->nd_xprint_ttdriver);
3140 nd->nd_ttdriver_flags &= ~XPRINT_TTDRV_REG;
3142 for (i = 0; i < CHAN_MAX; i++)
3143 tty_port_destroy(&nd->nd_chan[i].port);
3149 * Initialize the TTY portion of the supplied node.
3152 dgrp_tty_init(struct nd_struct *nd)
3158 ID_TO_CHAR(nd->nd_ID, id);
3161 * Initialize the TTDRIVER structures.
3164 nd->nd_serial_ttdriver = alloc_tty_driver(CHAN_MAX);
3165 if (!nd->nd_serial_ttdriver)
3168 sprintf(nd->nd_serial_name, "tty_dgrp_%s_", id);
3170 nd->nd_serial_ttdriver->owner = THIS_MODULE;
3171 nd->nd_serial_ttdriver->name = nd->nd_serial_name;
3172 nd->nd_serial_ttdriver->name_base = 0;
3173 nd->nd_serial_ttdriver->major = 0;
3174 nd->nd_serial_ttdriver->minor_start = 0;
3175 nd->nd_serial_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3176 nd->nd_serial_ttdriver->subtype = SERIAL_TYPE_NORMAL;
3177 nd->nd_serial_ttdriver->init_termios = DefaultTermios;
3178 nd->nd_serial_ttdriver->driver_name = "dgrp";
3179 nd->nd_serial_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3180 TTY_DRIVER_DYNAMIC_DEV |
3181 TTY_DRIVER_HARDWARE_BREAK);
3183 /* The kernel wants space to store pointers to tty_structs. */
3184 nd->nd_serial_ttdriver->ttys =
3185 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3186 if (!nd->nd_serial_ttdriver->ttys)
3189 tty_set_operations(nd->nd_serial_ttdriver, &dgrp_tty_ops);
3191 if (!(nd->nd_ttdriver_flags & SERIAL_TTDRV_REG)) {
3193 * Register tty devices
3195 rc = tty_register_driver(nd->nd_serial_ttdriver);
3198 * If errno is EBUSY, this means there are no more
3199 * slots available to have us auto-majored.
3200 * (Which is currently supported up to 256)
3202 * We can still request majors above 256,
3203 * we just have to do it manually.
3207 int max_majors = 1U << (32 - MINORBITS);
3208 for (i = 256; i < max_majors; i++) {
3209 nd->nd_serial_ttdriver->major = i;
3210 rc = tty_register_driver(nd->nd_serial_ttdriver);
3214 /* Really fail now, since we ran out
3215 * of majors to try. */
3216 if (i == max_majors)
3223 nd->nd_ttdriver_flags |= SERIAL_TTDRV_REG;
3226 nd->nd_callout_ttdriver = alloc_tty_driver(CHAN_MAX);
3227 if (!nd->nd_callout_ttdriver)
3230 sprintf(nd->nd_callout_name, "cu_dgrp_%s_", id);
3232 nd->nd_callout_ttdriver->owner = THIS_MODULE;
3233 nd->nd_callout_ttdriver->name = nd->nd_callout_name;
3234 nd->nd_callout_ttdriver->name_base = 0;
3235 nd->nd_callout_ttdriver->major = nd->nd_serial_ttdriver->major;
3236 nd->nd_callout_ttdriver->minor_start = 0x40;
3237 nd->nd_callout_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3238 nd->nd_callout_ttdriver->subtype = SERIAL_TYPE_CALLOUT;
3239 nd->nd_callout_ttdriver->init_termios = DefaultTermios;
3240 nd->nd_callout_ttdriver->driver_name = "dgrp";
3241 nd->nd_callout_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3242 TTY_DRIVER_DYNAMIC_DEV |
3243 TTY_DRIVER_HARDWARE_BREAK);
3245 /* The kernel wants space to store pointers to tty_structs. */
3246 nd->nd_callout_ttdriver->ttys =
3247 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3248 if (!nd->nd_callout_ttdriver->ttys)
3251 tty_set_operations(nd->nd_callout_ttdriver, &dgrp_tty_ops);
3253 if (dgrp_register_cudevices) {
3254 if (!(nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG)) {
3256 * Register cu devices
3258 rc = tty_register_driver(nd->nd_callout_ttdriver);
3261 nd->nd_ttdriver_flags |= CALLOUT_TTDRV_REG;
3266 nd->nd_xprint_ttdriver = alloc_tty_driver(CHAN_MAX);
3267 if (!nd->nd_xprint_ttdriver)
3270 sprintf(nd->nd_xprint_name, "pr_dgrp_%s_", id);
3272 nd->nd_xprint_ttdriver->owner = THIS_MODULE;
3273 nd->nd_xprint_ttdriver->name = nd->nd_xprint_name;
3274 nd->nd_xprint_ttdriver->name_base = 0;
3275 nd->nd_xprint_ttdriver->major = nd->nd_serial_ttdriver->major;
3276 nd->nd_xprint_ttdriver->minor_start = 0x80;
3277 nd->nd_xprint_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3278 nd->nd_xprint_ttdriver->subtype = SERIAL_TYPE_XPRINT;
3279 nd->nd_xprint_ttdriver->init_termios = DefaultTermios;
3280 nd->nd_xprint_ttdriver->driver_name = "dgrp";
3281 nd->nd_xprint_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3282 TTY_DRIVER_DYNAMIC_DEV |
3283 TTY_DRIVER_HARDWARE_BREAK);
3285 /* The kernel wants space to store pointers to tty_structs. */
3286 nd->nd_xprint_ttdriver->ttys =
3287 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3288 if (!nd->nd_xprint_ttdriver->ttys)
3291 tty_set_operations(nd->nd_xprint_ttdriver, &dgrp_tty_ops);
3293 if (dgrp_register_prdevices) {
3294 if (!(nd->nd_ttdriver_flags & XPRINT_TTDRV_REG)) {
3296 * Register transparent print devices
3298 rc = tty_register_driver(nd->nd_xprint_ttdriver);
3301 nd->nd_ttdriver_flags |= XPRINT_TTDRV_REG;
3305 for (i = 0; i < CHAN_MAX; i++) {
3306 struct ch_struct *ch = nd->nd_chan + i;
3309 ch->ch_digi = digi_init;
3310 ch->ch_edelay = 100;
3311 ch->ch_custom_speed = 0;
3313 ch->ch_tun.un_ch = ch;
3314 ch->ch_pun.un_ch = ch;
3315 ch->ch_tun.un_type = SERIAL_TYPE_NORMAL;
3316 ch->ch_pun.un_type = SERIAL_TYPE_XPRINT;
3318 init_waitqueue_head(&(ch->ch_flag_wait));
3319 init_waitqueue_head(&(ch->ch_sleep));
3321 init_waitqueue_head(&(ch->ch_tun.un_open_wait));
3322 init_waitqueue_head(&(ch->ch_tun.un_close_wait));
3324 init_waitqueue_head(&(ch->ch_pun.un_open_wait));
3325 init_waitqueue_head(&(ch->ch_pun.un_close_wait));
3326 tty_port_init(&ch->port);