projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'tty-3.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty
[deliverable/linux.git] / drivers / staging / dgrp / dgrp_tty.c
1 /*
2 *
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>
6 * Jeff Randall
7 * Scott Kilau <scottk at digi dot com>
8 *
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)
12 * any later version.
13 *
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.
18 *
19 */
20
21 /*
22 *
23 * Filename:
24 *
25 * dgrp_tty.c
26 *
27 * Description:
28 *
29 * This file implements the tty driver functionality for the
30 * RealPort driver software.
31 *
32 * Author:
33 *
34 * James A. Puzzo
35 * Ann-Marie Westgate
36 *
37 */
38
39 #include <linux/slab.h>
40 #include <linux/tty.h>
41 #include <linux/tty_flip.h>
42 #include <linux/sched.h>
43 #include <linux/uaccess.h>
44
45 #include "dgrp_common.h"
46
47 #ifndef _POSIX_VDISABLE
48 #define _POSIX_VDISABLE ('\0')
49 #endif
50
51 /*
52 * forward declarations
53 */
54
55 static void drp_param(struct ch_struct *);
56 static void dgrp_tty_close(struct tty_struct *, struct file *);
57
58 /* ioctl helper functions */
59 static int set_modem_info(struct ch_struct *, unsigned int, unsigned int *);
60 static int get_modem_info(struct ch_struct *, unsigned int *);
61 static void dgrp_set_custom_speed(struct ch_struct *, int);
62 static int dgrp_tty_digigetedelay(struct tty_struct *, int *);
63 static int dgrp_tty_digisetedelay(struct tty_struct *, int *);
64 static int dgrp_send_break(struct ch_struct *, int);
65
66 static ushort tty_to_ch_flags(struct tty_struct *, char);
67 static tcflag_t ch_to_tty_flags(unsigned short, char);
68
69 static void dgrp_tty_input_start(struct tty_struct *);
70 static void dgrp_tty_input_stop(struct tty_struct *);
71
72 static void drp_wmove(struct ch_struct *, int, void*, int);
73
74 static int dgrp_tty_open(struct tty_struct *, struct file *);
75 static void dgrp_tty_close(struct tty_struct *, struct file *);
76 static int dgrp_tty_write(struct tty_struct *, const unsigned char *, int);
77 static int dgrp_tty_write_room(struct tty_struct *);
78 static void dgrp_tty_flush_buffer(struct tty_struct *);
79 static int dgrp_tty_chars_in_buffer(struct tty_struct *);
80 static int dgrp_tty_ioctl(struct tty_struct *, unsigned int, unsigned long);
81 static void dgrp_tty_set_termios(struct tty_struct *, struct ktermios *);
82 static void dgrp_tty_stop(struct tty_struct *);
83 static void dgrp_tty_start(struct tty_struct *);
84 static void dgrp_tty_throttle(struct tty_struct *);
85 static void dgrp_tty_unthrottle(struct tty_struct *);
86 static void dgrp_tty_hangup(struct tty_struct *);
87 static int dgrp_tty_put_char(struct tty_struct *, unsigned char);
88 static int dgrp_tty_tiocmget(struct tty_struct *);
89 static int dgrp_tty_tiocmset(struct tty_struct *, unsigned int, unsigned int);
90 static int dgrp_tty_send_break(struct tty_struct *, int);
91 static void dgrp_tty_send_xchar(struct tty_struct *, char);
92
93 /*
94 * tty defines
95 */
96 #define SERIAL_TYPE_NORMAL 1
97 #define SERIAL_TYPE_CALLOUT 2
98 #define SERIAL_TYPE_XPRINT 3
99
100
101 /*
102 * tty globals/statics
103 */
104
105
106 #define PORTSERVER_DIVIDEND 1843200
107
108 /*
109 * Default transparent print information.
110 */
111 static struct digi_struct digi_init = {
112 .digi_flags = DIGI_COOK, /* Flags */
113 .digi_maxcps = 100, /* Max CPS */
114 .digi_maxchar = 50, /* Max chars in print queue */
115 .digi_bufsize = 100, /* Printer buffer size */
116 .digi_onlen = 4, /* size of printer on string */
117 .digi_offlen = 4, /* size of printer off string */
118 .digi_onstr = "\033[5i", /* ANSI printer on string */
119 .digi_offstr = "\033[4i", /* ANSI printer off string */
120 .digi_term = "ansi" /* default terminal type */
121 };
122
123 /*
124 * Define a local default termios struct. All ports will be created
125 * with this termios initially.
126 *
127 * This defines a raw port at 9600 baud, 8 data bits, no parity,
128 * 1 stop bit.
129 */
130 static struct ktermios DefaultTermios = {
131 .c_iflag = (ICRNL | IXON),
132 .c_oflag = (OPOST | ONLCR),
133 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
134 .c_lflag = (ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL
135 | ECHOKE | IEXTEN),
136 .c_cc = INIT_C_CC,
137 .c_line = 0,
138 };
139
140 /* Define our tty operations struct */
141 static const struct tty_operations dgrp_tty_ops = {
142 .open = dgrp_tty_open,
143 .close = dgrp_tty_close,
144 .write = dgrp_tty_write,
145 .write_room = dgrp_tty_write_room,
146 .flush_buffer = dgrp_tty_flush_buffer,
147 .chars_in_buffer = dgrp_tty_chars_in_buffer,
148 .flush_chars = NULL,
149 .ioctl = dgrp_tty_ioctl,
150 .set_termios = dgrp_tty_set_termios,
151 .stop = dgrp_tty_stop,
152 .start = dgrp_tty_start,
153 .throttle = dgrp_tty_throttle,
154 .unthrottle = dgrp_tty_unthrottle,
155 .hangup = dgrp_tty_hangup,
156 .put_char = dgrp_tty_put_char,
157 .tiocmget = dgrp_tty_tiocmget,
158 .tiocmset = dgrp_tty_tiocmset,
159 .break_ctl = dgrp_tty_send_break,
160 .send_xchar = dgrp_tty_send_xchar
161 };
162
163
164 static int calc_baud_rate(struct un_struct *un)
165 {
166 int i;
167 int brate;
168
169 struct baud_rates {
170 unsigned int rate;
171 unsigned int cflag;
172 };
173
174 static struct baud_rates baud_rates[] = {
175 { 921600, B921600 },
176 { 460800, B460800 },
177 { 230400, B230400 },
178 { 115200, B115200 },
179 { 57600, B57600 },
180 { 38400, B38400 },
181 { 19200, B19200 },
182 { 9600, B9600 },
183 { 4800, B4800 },
184 { 2400, B2400 },
185 { 1200, B1200 },
186 { 600, B600 },
187 { 300, B300 },
188 { 200, B200 },
189 { 150, B150 },
190 { 134, B134 },
191 { 110, B110 },
192 { 75, B75 },
193 { 50, B50 },
194 { 0, B9600 }
195 };
196
197 brate = C_BAUD(un->un_tty);
198
199 for (i = 0; baud_rates[i].rate; i++) {
200 if (baud_rates[i].cflag == brate)
201 break;
202 }
203
204 return baud_rates[i].rate;
205 }
206
207 static int calc_fastbaud_rate(struct un_struct *un, struct ktermios *uts)
208 {
209 int i;
210 int brate;
211
212 ulong bauds[2][16] = {
213 { /* fastbaud*/
214 0, 57600, 76800, 115200,
215 131657, 153600, 230400, 460800,
216 921600, 1200, 1800, 2400,
217 4800, 9600, 19200, 38400 },
218 { /* fastbaud & CBAUDEX */
219 0, 57600, 115200, 230400,
220 460800, 150, 200, 921600,
221 600, 1200, 1800, 2400,
222 4800, 9600, 19200, 38400 }
223 };
224
225 brate = C_BAUD(un->un_tty) & 0xff;
226
227 i = (uts->c_cflag & CBAUDEX) ? 1 : 0;
228
229
230 if ((i >= 0) && (i < 2) && (brate >= 0) && (brate < 16))
231 brate = bauds[i][brate];
232 else
233 brate = 0;
234
235 return brate;
236 }
237
238 /**
239 * drp_param() -- send parameter values to be sent to the node
240 * @ch: channel structure of port to modify
241 *
242 * Interprets the tty and modem changes made by an application
243 * program (by examining the termios structures) and sets up
244 * parameter values to be sent to the node.
245 */
246 static void drp_param(struct ch_struct *ch)
247 {
248 struct nd_struct *nd;
249 struct un_struct *un;
250 int brate;
251 int mflow;
252 int xflag;
253 int iflag;
254 struct ktermios *tts, *pts, *uts;
255
256 nd = ch->ch_nd;
257
258 /*
259 * If the terminal device is open, use it to set up all tty
260 * modes and functions. Otherwise use the printer device.
261 */
262
263 if (ch->ch_tun.un_open_count) {
264
265 un = &ch->ch_tun;
266 tts = &ch->ch_tun.un_tty->termios;
267
268 /*
269 * If both devices are open, copy critical line
270 * parameters from the tty device to the printer,
271 * so that if the tty is closed, the printer will
272 * continue without disruption.
273 */
274
275 if (ch->ch_pun.un_open_count) {
276
277 pts = &ch->ch_pun.un_tty->termios;
278
279 pts->c_cflag ^=
280 (pts->c_cflag ^ tts->c_cflag) &
281 (CBAUD | CSIZE | CSTOPB | CREAD | PARENB |
282 PARODD | HUPCL | CLOCAL);
283
284 pts->c_iflag ^=
285 (pts->c_iflag ^ tts->c_iflag) &
286 (IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK |
287 ISTRIP | IXON | IXANY | IXOFF);
288
289 pts->c_cc[VSTART] = tts->c_cc[VSTART];
290 pts->c_cc[VSTOP] = tts->c_cc[VSTOP];
291 }
292 } else if (ch->ch_pun.un_open_count == 0) {
293 pr_warn("%s - ch_pun.un_open_count shouldn't be 0\n",
294 __func__);
295 return;
296 } else {
297 un = &ch->ch_pun;
298 }
299
300 uts = &un->un_tty->termios;
301
302 /*
303 * Determine if FAST writes can be performed.
304 */
305
306 if ((ch->ch_digi.digi_flags & DIGI_COOK) != 0 &&
307 (ch->ch_tun.un_open_count != 0) &&
308 !((un->un_tty)->ldisc->ops->flags & LDISC_FLAG_DEFINED) &&
309 !(L_XCASE(un->un_tty))) {
310 ch->ch_flag |= CH_FAST_WRITE;
311 } else {
312 ch->ch_flag &= ~CH_FAST_WRITE;
313 }
314
315 /*
316 * If FAST writes can be performed, and OPOST is on in the
317 * terminal device, do OPOST handling in the server.
318 */
319
320 if ((ch->ch_flag & CH_FAST_WRITE) &&
321 O_OPOST(un->un_tty) != 0) {
322 int oflag = tty_to_ch_flags(un->un_tty, 'o');
323
324 /* add to ch_ocook any processing flags set in the termio */
325 ch->ch_ocook |= oflag & (OF_OLCUC |
326 OF_ONLCR |
327 OF_OCRNL |
328 OF_ONLRET |
329 OF_TABDLY);
330
331 /*
332 * the hpux driver clears any flags set in ch_ocook
333 * from the termios oflag. It is STILL reported though
334 * by a TCGETA
335 */
336
337 oflag = ch_to_tty_flags(ch->ch_ocook, 'o');
338 uts->c_oflag &= ~oflag;
339
340 } else {
341 /* clear the ch->ch_ocook flag */
342 int oflag = ch_to_tty_flags(ch->ch_ocook, 'o');
343 uts->c_oflag |= oflag;
344 ch->ch_ocook = 0;
345 }
346
347 ch->ch_oflag = ch->ch_ocook;
348
349
350 ch->ch_flag &= ~CH_FAST_READ;
351
352 /*
353 * Generate channel flags
354 */
355
356 if (C_BAUD(un->un_tty) == B0) {
357 if (!(ch->ch_flag & CH_BAUD0)) {
358 /* TODO : the HPUX driver flushes line */
359 /* TODO : discipline, I assume I don't have to */
360
361 ch->ch_tout = ch->ch_tin;
362 ch->ch_rout = ch->ch_rin;
363
364 ch->ch_break_time = 0;
365
366 ch->ch_send |= RR_TX_FLUSH | RR_RX_FLUSH;
367
368 ch->ch_mout &= ~(DM_DTR | DM_RTS);
369
370 ch->ch_flag |= CH_BAUD0;
371 }
372 } else if (ch->ch_custom_speed) {
373 ch->ch_brate = PORTSERVER_DIVIDEND / ch->ch_custom_speed ;
374
375 if (ch->ch_flag & CH_BAUD0) {
376 ch->ch_mout |= DM_DTR | DM_RTS;
377
378 ch->ch_flag &= ~CH_BAUD0;
379 }
380 } else {
381 /*
382 * Baud rate mapping.
383 *
384 * If FASTBAUD isn't on, we can scan the new baud rate list
385 * as required.
386 *
387 * However, if FASTBAUD is on, we must go to the old
388 * baud rate mapping that existed many many moons ago,
389 * for compatibility reasons.
390 */
391
392 if (!(ch->ch_digi.digi_flags & DIGI_FAST))
393 brate = calc_baud_rate(un);
394 else
395 brate = calc_fastbaud_rate(un, uts);
396
397 if (brate == 0)
398 brate = 9600;
399
400 ch->ch_brate = PORTSERVER_DIVIDEND / brate;
401
402 if (ch->ch_flag & CH_BAUD0) {
403 ch->ch_mout |= DM_DTR | DM_RTS;
404
405 ch->ch_flag &= ~CH_BAUD0;
406 }
407 }
408
409 /*
410 * Generate channel cflags from the termio.
411 */
412
413 ch->ch_cflag = tty_to_ch_flags(un->un_tty, 'c');
414
415 /*
416 * Generate channel iflags from the termio.
417 */
418
419 iflag = (int) tty_to_ch_flags(un->un_tty, 'i');
420
421 if (START_CHAR(un->un_tty) == _POSIX_VDISABLE ||
422 STOP_CHAR(un->un_tty) == _POSIX_VDISABLE) {
423 iflag &= ~(IF_IXON | IF_IXANY | IF_IXOFF);
424 }
425
426 ch->ch_iflag = iflag;
427
428 /*
429 * Generate flow control characters
430 */
431
432 /*
433 * From the POSIX.1 spec (7.1.2.6): "If {_POSIX_VDISABLE}
434 * is defined for the terminal device file, and the value
435 * of one of the changeable special control characters (see
436 * 7.1.1.9) is {_POSIX_VDISABLE}, that function shall be
437 * disabled, that is, no input data shall be recognized as
438 * the disabled special character."
439 *
440 * OK, so we don't ever assign S/DXB XON or XOFF to _POSIX_VDISABLE.
441 */
442
443 if (uts->c_cc[VSTART] != _POSIX_VDISABLE)
444 ch->ch_xon = uts->c_cc[VSTART];
445 if (uts->c_cc[VSTOP] != _POSIX_VDISABLE)
446 ch->ch_xoff = uts->c_cc[VSTOP];
447
448 ch->ch_lnext = (uts->c_cc[VLNEXT] == _POSIX_VDISABLE ? 0 :
449 uts->c_cc[VLNEXT]);
450
451 /*
452 * Also, if either c_cc[START] or c_cc[STOP] is set to
453 * _POSIX_VDISABLE, we can't really do software flow
454 * control--in either direction--so we turn it off as
455 * far as S/DXB is concerned. In essence, if you disable
456 * one, you disable the other too.
457 */
458 if ((uts->c_cc[VSTART] == _POSIX_VDISABLE) ||
459 (uts->c_cc[VSTOP] == _POSIX_VDISABLE))
460 ch->ch_iflag &= ~(IF_IXOFF | IF_IXON);
461
462 /*
463 * Update xflags.
464 */
465
466 xflag = 0;
467
468 if (ch->ch_digi.digi_flags & DIGI_AIXON)
469 xflag = XF_XIXON;
470
471 if ((ch->ch_xxon == _POSIX_VDISABLE) ||
472 (ch->ch_xxoff == _POSIX_VDISABLE))
473 xflag &= ~XF_XIXON;
474
475 ch->ch_xflag = xflag;
476
477
478 /*
479 * Figure effective DCD value.
480 */
481
482 if (C_CLOCAL(un->un_tty))
483 ch->ch_flag |= CH_CLOCAL;
484 else
485 ch->ch_flag &= ~CH_CLOCAL;
486
487 /*
488 * Check modem signals
489 */
490
491 dgrp_carrier(ch);
492
493 /*
494 * Get hardware handshake value.
495 */
496
497 mflow = 0;
498
499 if (C_CRTSCTS(un->un_tty))
500 mflow |= (DM_RTS | DM_CTS);
501
502 if (ch->ch_digi.digi_flags & RTSPACE)
503 mflow |= DM_RTS;
504
505 if (ch->ch_digi.digi_flags & DTRPACE)
506 mflow |= DM_DTR;
507
508 if (ch->ch_digi.digi_flags & CTSPACE)
509 mflow |= DM_CTS;
510
511 if (ch->ch_digi.digi_flags & DSRPACE)
512 mflow |= DM_DSR;
513
514 if (ch->ch_digi.digi_flags & DCDPACE)
515 mflow |= DM_CD;
516
517 if (ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE)
518 mflow |= DM_RTS_TOGGLE;
519
520 ch->ch_mflow = mflow;
521
522 /*
523 * Send the changes to the server.
524 */
525
526 ch->ch_flag |= CH_PARAM;
527 (ch->ch_nd)->nd_tx_work = 1;
528
529 if (waitqueue_active(&ch->ch_flag_wait))
530 wake_up_interruptible(&ch->ch_flag_wait);
531 }
532
533 /*
534 * This function is just used as a callback for timeouts
535 * waiting on the ch_sleep flag.
536 */
537 static void wake_up_drp_sleep_timer(unsigned long ptr)
538 {
539 struct ch_struct *ch = (struct ch_struct *) ptr;
540 if (ch)
541 wake_up(&ch->ch_sleep);
542 }
543
544
545 /*
546 * Set up our own sleep that can't be cancelled
547 * until our timeout occurs.
548 */
549 static void drp_my_sleep(struct ch_struct *ch)
550 {
551 struct timer_list drp_wakeup_timer;
552 DECLARE_WAITQUEUE(wait, current);
553
554 /*
555 * First make sure we're ready to receive the wakeup.
556 */
557
558 add_wait_queue(&ch->ch_sleep, &wait);
559 current->state = TASK_UNINTERRUPTIBLE;
560
561 /*
562 * Since we are uninterruptible, set a timer to
563 * unset the uninterruptable state in 1 second.
564 */
565
566 init_timer(&drp_wakeup_timer);
567 drp_wakeup_timer.function = wake_up_drp_sleep_timer;
568 drp_wakeup_timer.data = (unsigned long) ch;
569 drp_wakeup_timer.expires = jiffies + (1 * HZ);
570 add_timer(&drp_wakeup_timer);
571
572 schedule();
573
574 del_timer(&drp_wakeup_timer);
575
576 remove_wait_queue(&ch->ch_sleep, &wait);
577 }
578
579 /*
580 * dgrp_tty_open()
581 *
582 * returns:
583 * -EBUSY - this is a callout device and the normal device is active
584 * - there is an error in opening the tty
585 * -ENODEV - the channel does not exist
586 * -EAGAIN - we are in the middle of hanging up or closing
587 * - IMMEDIATE_OPEN fails
588 * -ENXIO or -EAGAIN
589 * - if the port is outside physical range
590 * -EINTR - the open is interrupted
591 *
592 */
593 static int dgrp_tty_open(struct tty_struct *tty, struct file *file)
594 {
595 int retval = 0;
596 struct nd_struct *nd;
597 struct ch_struct *ch;
598 struct un_struct *un;
599 int port;
600 int delay_error;
601 int otype;
602 int unf;
603 int wait_carrier;
604 int category;
605 int counts_were_incremented = 0;
606 ulong lock_flags;
607 DECLARE_WAITQUEUE(wait, current);
608
609 /*
610 * Do some initial checks to see if the node and port exist
611 */
612
613 nd = nd_struct_get(MAJOR(tty_devnum(tty)));
614 port = PORT_NUM(MINOR(tty_devnum(tty)));
615 category = OPEN_CATEGORY(MINOR(tty_devnum(tty)));
616
617 if (!nd)
618 return -ENODEV;
619
620 if (port >= CHAN_MAX)
621 return -ENODEV;
622
623 /*
624 * The channel exists.
625 */
626
627 ch = nd->nd_chan + port;
628
629 un = IS_PRINT(MINOR(tty_devnum(tty))) ? &ch->ch_pun : &ch->ch_tun;
630 un->un_tty = tty;
631 tty->driver_data = un;
632
633 /*
634 * If we are in the middle of hanging up,
635 * then return an error
636 */
637 if (tty_hung_up_p(file)) {
638 retval = ((un->un_flag & UN_HUP_NOTIFY) ?
639 -EAGAIN : -ERESTARTSYS);
640 goto done;
641 }
642
643 /*
644 * If the port is in the middle of closing, then block
645 * until it is done, then try again.
646 */
647 retval = wait_event_interruptible(un->un_close_wait,
648 ((un->un_flag & UN_CLOSING) == 0));
649
650 if (retval)
651 goto done;
652
653 /*
654 * If the port is in the middle of a reopen after a network disconnect,
655 * wait until it is done, then try again.
656 */
657 retval = wait_event_interruptible(ch->ch_flag_wait,
658 ((ch->ch_flag & CH_PORT_GONE) == 0));
659
660 if (retval)
661 goto done;
662
663 /*
664 * If this is a callout device, then just make sure the normal
665 * device isn't being used.
666 */
667
668 if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
669 if (un->un_flag & UN_NORMAL_ACTIVE) {
670 retval = -EBUSY;
671 goto done;
672 } else {
673 un->un_flag |= UN_CALLOUT_ACTIVE;
674 }
675 }
676
677 /*
678 * Loop waiting until the open can be successfully completed.
679 */
680
681 spin_lock_irqsave(&nd->nd_lock, lock_flags);
682
683 nd->nd_tx_work = 1;
684
685 for (;;) {
686 wait_carrier = 0;
687
688 /*
689 * Determine the open type from the flags provided.
690 */
691
692 /*
693 * If the port is not enabled, then exit
694 */
695 if (test_bit(TTY_IO_ERROR, &tty->flags)) {
696 /* there was an error in opening the tty */
697 if (un->un_flag & UN_CALLOUT_ACTIVE)
698 retval = -EBUSY;
699 else
700 un->un_flag |= UN_NORMAL_ACTIVE;
701 goto unlock;
702 }
703
704 if (file->f_flags & O_NONBLOCK) {
705
706 /*
707 * if the O_NONBLOCK is set, errors on read and write
708 * must return -EAGAIN immediately and NOT sleep
709 * on the waitqs.
710 */
711 otype = OTYPE_IMMEDIATE;
712 delay_error = -EAGAIN;
713
714 } else if (!OPEN_WAIT_AVAIL(category) ||
715 (file->f_flags & O_NDELAY) != 0) {
716 otype = OTYPE_IMMEDIATE;
717 delay_error = -EBUSY;
718
719 } else if (!OPEN_WAIT_CARRIER(category) ||
720 ((ch->ch_digi.digi_flags & DIGI_FORCEDCD) != 0) ||
721 C_CLOCAL(tty)) {
722 otype = OTYPE_PERSISTENT;
723 delay_error = 0;
724
725 } else {
726 otype = OTYPE_INCOMING;
727 delay_error = 0;
728 }
729
730 /*
731 * Handle port currently outside physical port range.
732 */
733
734 if (port >= nd->nd_chan_count) {
735 if (otype == OTYPE_IMMEDIATE) {
736 retval = (nd->nd_state == NS_READY) ?
737 -ENXIO : -EAGAIN;
738 goto unlock;
739 }
740 }
741
742 /*
743 * Handle port not currently open.
744 */
745
746 else if (ch->ch_open_count == 0) {
747 /*
748 * Return an error when an Incoming Open
749 * response indicates the port is busy.
750 */
751
752 if (ch->ch_open_error != 0 && otype == ch->ch_otype) {
753 retval = (ch->ch_open_error <= 2) ?
754 delay_error : -ENXIO ;
755 goto unlock;
756 }
757
758 /*
759 * Fail any new Immediate open if we do not have
760 * a normal connection to the server.
761 */
762
763 if (nd->nd_state != NS_READY &&
764 otype == OTYPE_IMMEDIATE) {
765 retval = -EAGAIN;
766 goto unlock;
767 }
768
769 /*
770 * If a Realport open of the correct type has
771 * succeeded, complete the open.
772 */
773
774 if (ch->ch_state == CS_READY && ch->ch_otype == otype)
775 break;
776 }
777
778 /*
779 * Handle port already open and active as a device
780 * of same category.
781 */
782
783 else if ((ch->ch_category == category) ||
784 IS_PRINT(MINOR(tty_devnum(tty)))) {
785 /*
786 * Fail if opening the device now would
787 * violate exclusive use.
788 */
789 unf = ch->ch_tun.un_flag | ch->ch_pun.un_flag;
790
791 if ((file->f_flags & O_EXCL) || (unf & UN_EXCL)) {
792 retval = -EBUSY;
793 goto unlock;
794 }
795
796 /*
797 * If the open device is in the hangup state, all
798 * system calls fail except close().
799 */
800
801 /* TODO : check on hangup_p calls */
802
803 if (ch->ch_flag & CH_HANGUP) {
804 retval = -ENXIO;
805 goto unlock;
806 }
807
808 /*
809 * If the port is ready, and carrier is ignored
810 * or present, then complete the open.
811 */
812
813 if (ch->ch_state == CS_READY &&
814 (otype != OTYPE_INCOMING ||
815 ch->ch_flag & CH_VIRT_CD))
816 break;
817
818 wait_carrier = 1;
819 }
820
821 /*
822 * Handle port active with a different category device.
823 */
824
825 else {
826 if (otype == OTYPE_IMMEDIATE) {
827 retval = delay_error;
828 goto unlock;
829 }
830 }
831
832 /*
833 * Wait until conditions change, then take another
834 * try at the open.
835 */
836
837 ch->ch_wait_count[otype]++;
838
839 if (wait_carrier)
840 ch->ch_wait_carrier++;
841
842 /*
843 * Prepare the task to accept the wakeup, then
844 * release our locks and release control.
845 */
846
847 add_wait_queue(&ch->ch_flag_wait, &wait);
848 current->state = TASK_INTERRUPTIBLE;
849
850 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
851
852 /*
853 * Give up control, we'll come back if we're
854 * interrupted or are woken up.
855 */
856 schedule();
857 remove_wait_queue(&ch->ch_flag_wait, &wait);
858
859 spin_lock_irqsave(&nd->nd_lock, lock_flags);
860
861 current->state = TASK_RUNNING;
862
863 ch->ch_wait_count[otype]--;
864
865 if (wait_carrier)
866 ch->ch_wait_carrier--;
867
868 nd->nd_tx_work = 1;
869
870 if (signal_pending(current)) {
871 retval = -EINTR;
872 goto unlock;
873 }
874 } /* end for(;;) */
875
876 /*
877 * The open has succeeded. No turning back.
878 */
879 counts_were_incremented = 1;
880 un->un_open_count++;
881 ch->ch_open_count++;
882
883 /*
884 * Initialize the channel, if it's not already open.
885 */
886
887 if (ch->ch_open_count == 1) {
888 ch->ch_flag = 0;
889 ch->ch_inwait = 0;
890 ch->ch_category = category;
891 ch->ch_pscan_state = 0;
892
893 /* TODO : find out what PS-1 bug Gene was referring to */
894 /* TODO : in the following comment. */
895
896 ch->ch_send = RR_TX_START | RR_RX_START; /* PS-1 bug */
897
898 if (C_CLOCAL(tty) ||
899 ch->ch_s_mlast & DM_CD ||
900 ch->ch_digi.digi_flags & DIGI_FORCEDCD)
901 ch->ch_flag |= CH_VIRT_CD;
902 else if (OPEN_FORCES_CARRIER(category))
903 ch->ch_flag |= CH_VIRT_CD;
904
905 }
906
907 /*
908 * Initialize the unit, if it is not already open.
909 */
910
911 if (un->un_open_count == 1) {
912 /*
913 * Since all terminal options are always sticky in Linux,
914 * we don't need the UN_STICKY flag to be handled specially.
915 */
916 /* clears all the digi flags, leaves serial flags */
917 un->un_flag &= ~UN_DIGI_MASK;
918
919 if (file->f_flags & O_EXCL)
920 un->un_flag |= UN_EXCL;
921
922 /* TODO : include "session" and "pgrp" */
923
924 /*
925 * In Linux, all terminal parameters are intended to be sticky.
926 * as a result, we "remove" the code which once reset the ports
927 * to sane values.
928 */
929
930 drp_param(ch);
931
932 }
933
934 un->un_flag |= UN_INITIALIZED;
935
936 retval = 0;
937
938 unlock:
939
940 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
941
942 done:
943 /*
944 * Linux does a close for every open, even failed ones!
945 */
946 if (!counts_were_incremented) {
947 un->un_open_count++;
948 ch->ch_open_count++;
949 }
950
951 if (retval)
952 dev_err(tty->dev, "tty open bad return (%i)\n", retval);
953
954 return retval;
955 }
956
957
958
959
960 /*
961 * dgrp_tty_close() -- close function for tty_operations
962 */
963 static void dgrp_tty_close(struct tty_struct *tty, struct file *file)
964 {
965 struct ch_struct *ch;
966 struct un_struct *un;
967 struct nd_struct *nd;
968 int tpos;
969 int port;
970 int err = 0;
971 int s = 0;
972 ulong waketime;
973 ulong lock_flags;
974 int sent_printer_offstr = 0;
975
976 port = PORT_NUM(MINOR(tty_devnum(tty)));
977
978 un = tty->driver_data;
979
980 if (!un)
981 return;
982
983 ch = un->un_ch;
984
985 if (!ch)
986 return;
987
988 nd = ch->ch_nd;
989
990 if (!nd)
991 return;
992
993 spin_lock_irqsave(&nd->nd_lock, lock_flags);
994
995
996 /* Used to be on channel basis, now we check on a unit basis. */
997 if (un->un_open_count != 1)
998 goto unlock;
999
1000 /*
1001 * OK, its the last close on the unit
1002 */
1003 un->un_flag |= UN_CLOSING;
1004
1005 /*
1006 * Notify the discipline to only process XON/XOFF characters.
1007 */
1008 tty->closing = 1;
1009
1010 /*
1011 * Wait for output to drain only if this is
1012 * the last close against the channel
1013 */
1014
1015 if (ch->ch_open_count == 1) {
1016 /*
1017 * If its the print device, we need to ensure at all costs that
1018 * the offstr will fit. If it won't, flush our tbuf.
1019 */
1020 if (IS_PRINT(MINOR(tty_devnum(tty))) &&
1021 (((ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK) <
1022 ch->ch_digi.digi_offlen))
1023 ch->ch_tin = ch->ch_tout;
1024
1025 /*
1026 * Turn off the printer. Don't bother checking to see if its
1027 * IS_PRINT... Since this is the last close the flag is going
1028 * to be cleared, so we MUST make sure the offstr gets inserted
1029 * into tbuf.
1030 */
1031
1032 if ((ch->ch_flag & CH_PRON) != 0) {
1033 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1034 ch->ch_digi.digi_offlen);
1035 ch->ch_flag &= ~CH_PRON;
1036 sent_printer_offstr = 1;
1037 }
1038 }
1039
1040 /*
1041 * Wait until either the output queue has drained, or we see
1042 * absolutely no progress for 15 seconds.
1043 */
1044
1045 tpos = ch->ch_s_tpos;
1046
1047 waketime = jiffies + 15 * HZ;
1048
1049 for (;;) {
1050
1051 /*
1052 * Make sure the port still exists.
1053 */
1054
1055 if (port >= nd->nd_chan_count) {
1056 err = 1;
1057 break;
1058 }
1059
1060 if (signal_pending(current)) {
1061 err = 1;
1062 break;
1063 }
1064
1065 /*
1066 * If the port is idle (not opened on the server), we have
1067 * no way of draining/flushing/closing the port on that server.
1068 * So break out of loop.
1069 */
1070 if (ch->ch_state == CS_IDLE)
1071 break;
1072
1073 nd->nd_tx_work = 1;
1074
1075 /*
1076 * Exit if the queues for this unit are empty,
1077 * and either the other unit is still open or all
1078 * data has drained.
1079 */
1080
1081 if ((un->un_tty)->ops->chars_in_buffer ?
1082 ((un->un_tty)->ops->chars_in_buffer)(un->un_tty) == 0 : 1) {
1083
1084 /*
1085 * We don't need to wait for a buffer to drain
1086 * if the other unit is open.
1087 */
1088
1089 if (ch->ch_open_count != un->un_open_count)
1090 break;
1091
1092 /*
1093 * The wait is complete when all queues are
1094 * drained, and any break in progress is complete.
1095 */
1096
1097 if (ch->ch_tin == ch->ch_tout &&
1098 ch->ch_s_tin == ch->ch_s_tpos &&
1099 (ch->ch_send & RR_TX_BREAK) == 0) {
1100 break;
1101 }
1102 }
1103
1104 /*
1105 * Flush TX data and exit the wait if NDELAY is set,
1106 * or this is not a DIGI printer, and the close timeout
1107 * expires.
1108 */
1109
1110 if ((file->f_flags & (O_NDELAY | O_NONBLOCK)) ||
1111 ((long)(jiffies - waketime) >= 0 &&
1112 (ch->ch_digi.digi_flags & DIGI_PRINTER) == 0)) {
1113
1114 /*
1115 * If we sent the printer off string, we cannot
1116 * flush our internal buffers, or we might lose
1117 * the offstr.
1118 */
1119 if (!sent_printer_offstr)
1120 dgrp_tty_flush_buffer(tty);
1121
1122 tty_ldisc_flush(tty);
1123 break;
1124 }
1125
1126 /*
1127 * Otherwise take a short nap.
1128 */
1129
1130 ch->ch_flag |= CH_DRAIN;
1131
1132 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1133
1134 schedule_timeout_interruptible(1);
1135 s = signal_pending(current);
1136
1137 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1138
1139 if (s) {
1140 /*
1141 * If we had sent the printer off string, we now have
1142 * some problems.
1143 *
1144 * The system won't let us sleep since we got an error
1145 * back from sleep, presumably because the user did
1146 * a ctrl-c...
1147 * But we need to ensure that the offstr gets sent!
1148 * Thus, we have to do something else besides sleeping.
1149 * The plan:
1150 * 1) Make this task uninterruptable.
1151 * 2) Set up a timer to go off in 1 sec.
1152 * 3) Act as tho we just got out of the sleep above.
1153 *
1154 * Thankfully, in the real world, this just
1155 * never happens.
1156 */
1157
1158 if (sent_printer_offstr) {
1159 spin_unlock_irqrestore(&nd->nd_lock,
1160 lock_flags);
1161 drp_my_sleep(ch);
1162 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1163 } else {
1164 err = 1;
1165 break;
1166 }
1167 }
1168
1169 /*
1170 * Restart the wait if any progress is seen.
1171 */
1172
1173 if (ch->ch_s_tpos != tpos) {
1174 tpos = ch->ch_s_tpos;
1175
1176 /* TODO: this gives us timeout problems with nist ?? */
1177 waketime = jiffies + 15 * HZ;
1178 }
1179 }
1180
1181 /*
1182 * Close the line discipline
1183 */
1184
1185 /* this is done in tty_io.c */
1186 /* if ((un->un_tty)->ldisc.close)
1187 * ((un->un_tty)->ldisc.close)(un->un_tty);
1188 */
1189
1190 /* don't do this here */
1191 /* un->un_flag = 0; */
1192
1193 /*
1194 * Flush the receive buffer on terminal unit close only.
1195 */
1196
1197 if (!IS_PRINT(MINOR(tty_devnum(tty))))
1198 ch->ch_rout = ch->ch_rin;
1199
1200
1201 /*
1202 * Don't permit the close to happen until we get any pending
1203 * sync request responses.
1204 * There could be other ports depending upon the response as well.
1205 *
1206 * Also, don't permit the close to happen until any parameter
1207 * changes have been sent out from the state machine as well.
1208 * This is required because of a ditty -a race with -HUPCL
1209 * We MUST make sure all channel parameters have been sent to the
1210 * Portserver before sending a close.
1211 */
1212
1213 if ((err != 1) && (ch->ch_state != CS_IDLE)) {
1214 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1215 s = wait_event_interruptible(ch->ch_flag_wait,
1216 ((ch->ch_flag & (CH_WAITING_SYNC | CH_PARAM)) == 0));
1217 spin_lock_irqsave(&nd->nd_lock, lock_flags);
1218 }
1219
1220 /*
1221 * Cleanup the channel if last unit open.
1222 */
1223
1224 if (ch->ch_open_count == 1) {
1225 ch->ch_flag = 0;
1226 ch->ch_category = 0;
1227 ch->ch_send = 0;
1228 ch->ch_expect = 0;
1229 ch->ch_tout = ch->ch_tin;
1230 /* (un->un_tty)->device = 0; */
1231
1232 if (ch->ch_state == CS_READY)
1233 ch->ch_state = CS_SEND_CLOSE;
1234 }
1235
1236 /*
1237 * Send the changes to the server
1238 */
1239 if (ch->ch_state != CS_IDLE) {
1240 ch->ch_flag |= CH_PARAM;
1241 wake_up_interruptible(&ch->ch_flag_wait);
1242 }
1243
1244 nd->nd_tx_work = 1;
1245 nd->nd_tx_ready = 1;
1246
1247 unlock:
1248 tty->closing = 0;
1249
1250 if (ch->ch_open_count <= 0)
1251 dev_info(tty->dev,
1252 "%s - unexpected value for ch->ch_open_count: %i\n",
1253 __func__, ch->ch_open_count);
1254 else
1255 ch->ch_open_count--;
1256
1257 if (un->un_open_count <= 0)
1258 dev_info(tty->dev,
1259 "%s - unexpected value for un->un_open_count: %i\n",
1260 __func__, un->un_open_count);
1261 else
1262 un->un_open_count--;
1263
1264 un->un_flag &= ~(UN_NORMAL_ACTIVE | UN_CALLOUT_ACTIVE | UN_CLOSING);
1265 if (waitqueue_active(&un->un_close_wait))
1266 wake_up_interruptible(&un->un_close_wait);
1267
1268 spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
1269
1270 return;
1271
1272 }
1273
1274 static void drp_wmove(struct ch_struct *ch, int from_user, void *buf, int count)
1275 {
1276 int n;
1277 int ret = 0;
1278
1279 ch->ch_nd->nd_tx_work = 1;
1280
1281 n = TBUF_MAX - ch->ch_tin;
1282
1283 if (count >= n) {
1284 if (from_user)
1285 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1286 (void __user *) buf, n);
1287 else
1288 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1289
1290 buf = (char *) buf + n;
1291 count -= n;
1292 ch->ch_tin = 0;
1293 }
1294
1295 if (from_user)
1296 ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
1297 (void __user *) buf, count);
1298 else
1299 memcpy(ch->ch_tbuf + ch->ch_tin, buf, count);
1300
1301 ch->ch_tin += count;
1302 }
1303
1304
1305 static int dgrp_calculate_txprint_bounds(struct ch_struct *ch, int space,
1306 int *un_flag)
1307 {
1308 clock_t tt;
1309 clock_t mt;
1310 unsigned short tmax = 0;
1311
1312 /*
1313 * If the terminal device is busy, reschedule when
1314 * the terminal device becomes idle.
1315 */
1316
1317 if (ch->ch_tun.un_open_count != 0 &&
1318 ch->ch_tun.un_tty->ops->chars_in_buffer &&
1319 ((ch->ch_tun.un_tty->ops->chars_in_buffer)(ch->ch_tun.un_tty) != 0)) {
1320 *un_flag = UN_PWAIT;
1321 return 0;
1322 }
1323
1324 /*
1325 * Assure that whenever there is printer data in the output
1326 * buffer, there always remains enough space after it to
1327 * turn the printer off.
1328 */
1329 space -= ch->ch_digi.digi_offlen;
1330
1331 if (space <= 0) {
1332 *un_flag = UN_EMPTY;
1333 return 0;
1334 }
1335
1336 /*
1337 * We measure printer CPS speed by incrementing
1338 * ch_cpstime by (HZ / digi_maxcps) for every
1339 * character we output, restricting output so
1340 * that ch_cpstime never exceeds lbolt.
1341 *
1342 * However if output has not been done for some
1343 * time, lbolt will grow to very much larger than
1344 * ch_cpstime, which would allow essentially
1345 * unlimited amounts of output until ch_cpstime
1346 * finally caught up. To avoid this, we adjust
1347 * cps_time when necessary so the difference
1348 * between lbolt and ch_cpstime never results
1349 * in sending more than digi_bufsize characters.
1350 *
1351 * This nicely models a printer with an internal
1352 * buffer of digi_bufsize characters.
1353 *
1354 * Get the time between lbolt and ch->ch_cpstime;
1355 */
1356
1357 tt = jiffies - ch->ch_cpstime;
1358
1359 /*
1360 * Compute the time required to send digi_bufsize
1361 * characters.
1362 */
1363
1364 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1365
1366 /*
1367 * Compute the number of characters that can be sent
1368 * without violating the time constraint. If the
1369 * direct calculation of this number is bigger than
1370 * digi_bufsize, limit the number to digi_bufsize,
1371 * and adjust cpstime to match.
1372 */
1373
1374 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1375 tmax = ch->ch_digi.digi_bufsize;
1376 ch->ch_cpstime = jiffies - mt;
1377 } else {
1378 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1379 }
1380
1381 /*
1382 * If the time constraint now binds, limit the transmit
1383 * count accordingly, and tentatively arrange to be
1384 * rescheduled based on time.
1385 */
1386
1387 if (tmax < space) {
1388 *un_flag = UN_TIME;
1389 space = tmax;
1390 }
1391
1392 /*
1393 * Compute the total number of characters we can
1394 * output before the total number of characters known
1395 * to be in the output queue exceeds digi_maxchar.
1396 */
1397
1398 tmax = (ch->ch_digi.digi_maxchar -
1399 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1400 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1401
1402
1403 /*
1404 * If the digi_maxchar constraint now holds, limit
1405 * the transmit count accordingly, and arrange to
1406 * be rescheduled when the queue becomes empty.
1407 */
1408
1409 if (space > tmax) {
1410 *un_flag = UN_EMPTY;
1411 space = tmax;
1412 }
1413
1414 if (space <= 0)
1415 *un_flag |= UN_EMPTY;
1416
1417 return space;
1418 }
1419
1420
1421 static int dgrp_tty_write(struct tty_struct *tty,
1422 const unsigned char *buf,
1423 int count)
1424 {
1425 struct nd_struct *nd;
1426 struct un_struct *un;
1427 struct ch_struct *ch;
1428 int space;
1429 int n;
1430 int t;
1431 int sendcount;
1432 int un_flag;
1433 ulong lock_flags;
1434
1435 if (tty == NULL)
1436 return 0;
1437
1438 un = tty->driver_data;
1439 if (!un)
1440 return 0;
1441
1442 ch = un->un_ch;
1443 if (!ch)
1444 return 0;
1445
1446 nd = ch->ch_nd;
1447 if (!nd)
1448 return 0;
1449
1450 /*
1451 * Ignore the request if the channel is not ready.
1452 */
1453 if (ch->ch_state != CS_READY)
1454 return 0;
1455
1456 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1457
1458 /*
1459 * Ignore the request if output is blocked.
1460 */
1461 if ((un->un_flag & (UN_EMPTY | UN_LOW | UN_TIME | UN_PWAIT)) != 0) {
1462 count = 0;
1463 goto out;
1464 }
1465
1466 /*
1467 * Also ignore the request if DPA has this port open,
1468 * and is flow controlled on reading more data.
1469 */
1470 if (nd->nd_dpa_debug && nd->nd_dpa_flag & DPA_WAIT_SPACE &&
1471 nd->nd_dpa_port == MINOR(tty_devnum(ch->ch_tun.un_tty))) {
1472 count = 0;
1473 goto out;
1474 }
1475
1476 /*
1477 * Limit amount we will write to the amount of space
1478 * available in the channel buffer.
1479 */
1480 sendcount = 0;
1481
1482 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1483
1484 /*
1485 * Handle the printer device.
1486 */
1487
1488 un_flag = UN_LOW;
1489
1490 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1491 clock_t tt;
1492 clock_t mt;
1493 unsigned short tmax = 0;
1494
1495 /*
1496 * If the terminal device is busy, reschedule when
1497 * the terminal device becomes idle.
1498 */
1499
1500 if (ch->ch_tun.un_open_count != 0 &&
1501 ((ch->ch_tun.un_tty->ops->chars_in_buffer)(ch->ch_tun.un_tty) != 0)) {
1502 un->un_flag |= UN_PWAIT;
1503 count = 0;
1504 goto out;
1505 }
1506
1507 /*
1508 * Assure that whenever there is printer data in the output
1509 * buffer, there always remains enough space after it to
1510 * turn the printer off.
1511 */
1512 space -= ch->ch_digi.digi_offlen;
1513
1514 /*
1515 * Output the printer on string.
1516 */
1517
1518 if ((ch->ch_flag & CH_PRON) == 0) {
1519 space -= ch->ch_digi.digi_onlen;
1520
1521 if (space < 0) {
1522 un->un_flag |= UN_EMPTY;
1523 (ch->ch_nd)->nd_tx_work = 1;
1524 count = 0;
1525 goto out;
1526 }
1527
1528 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1529 ch->ch_digi.digi_onlen);
1530
1531 ch->ch_flag |= CH_PRON;
1532 }
1533
1534 /*
1535 * We measure printer CPS speed by incrementing
1536 * ch_cpstime by (HZ / digi_maxcps) for every
1537 * character we output, restricting output so
1538 * that ch_cpstime never exceeds lbolt.
1539 *
1540 * However if output has not been done for some
1541 * time, lbolt will grow to very much larger than
1542 * ch_cpstime, which would allow essentially
1543 * unlimited amounts of output until ch_cpstime
1544 * finally caught up. To avoid this, we adjust
1545 * cps_time when necessary so the difference
1546 * between lbolt and ch_cpstime never results
1547 * in sending more than digi_bufsize characters.
1548 *
1549 * This nicely models a printer with an internal
1550 * buffer of digi_bufsize characters.
1551 *
1552 * Get the time between lbolt and ch->ch_cpstime;
1553 */
1554
1555 tt = jiffies - ch->ch_cpstime;
1556
1557 /*
1558 * Compute the time required to send digi_bufsize
1559 * characters.
1560 */
1561
1562 mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;
1563
1564 /*
1565 * Compute the number of characters that can be sent
1566 * without violating the time constraint. If the
1567 * direct calculation of this number is bigger than
1568 * digi_bufsize, limit the number to digi_bufsize,
1569 * and adjust cpstime to match.
1570 */
1571
1572 if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
1573 tmax = ch->ch_digi.digi_bufsize;
1574 ch->ch_cpstime = jiffies - mt;
1575 } else {
1576 tmax = ch->ch_digi.digi_maxcps * tt / HZ;
1577 }
1578
1579 /*
1580 * If the time constraint now binds, limit the transmit
1581 * count accordingly, and tentatively arrange to be
1582 * rescheduled based on time.
1583 */
1584
1585 if (tmax < space) {
1586 space = tmax;
1587 un_flag = UN_TIME;
1588 }
1589
1590 /*
1591 * Compute the total number of characters we can
1592 * output before the total number of characters known
1593 * to be in the output queue exceeds digi_maxchar.
1594 */
1595
1596 tmax = (ch->ch_digi.digi_maxchar -
1597 ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
1598 ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));
1599
1600
1601 /*
1602 * If the digi_maxchar constraint now holds, limit
1603 * the transmit count accordingly, and arrange to
1604 * be rescheduled when the queue becomes empty.
1605 */
1606
1607 if (space > tmax) {
1608 space = tmax;
1609 un_flag = UN_EMPTY;
1610 }
1611
1612 }
1613 /*
1614 * Handle the terminal device.
1615 */
1616 else {
1617
1618 /*
1619 * If the printer device is on, turn it off.
1620 */
1621
1622 if ((ch->ch_flag & CH_PRON) != 0) {
1623
1624 space -= ch->ch_digi.digi_offlen;
1625
1626 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1627 ch->ch_digi.digi_offlen);
1628
1629 ch->ch_flag &= ~CH_PRON;
1630 }
1631 }
1632
1633 /*
1634 * If space is 0 and its because the ch->tbuf
1635 * is full, then Linux will handle a callback when queue
1636 * space becomes available.
1637 * tty_write returns count = 0
1638 */
1639
1640 if (space <= 0) {
1641 /* the linux tty_io.c handles this if we return 0 */
1642 /* if (fp->flags & O_NONBLOCK) return -EAGAIN; */
1643
1644 un->un_flag |= UN_EMPTY;
1645 (ch->ch_nd)->nd_tx_work = 1;
1646 count = 0;
1647 goto out;
1648 }
1649
1650 count = min(count, space);
1651
1652 if (count > 0) {
1653
1654 un->un_tbusy++;
1655
1656 /*
1657 * Copy the buffer contents to the ch_tbuf
1658 * being careful to wrap around the circular queue
1659 */
1660
1661 t = TBUF_MAX - ch->ch_tin;
1662 n = count;
1663
1664 if (n >= t) {
1665 memcpy(ch->ch_tbuf + ch->ch_tin, buf, t);
1666 if (nd->nd_dpa_debug && nd->nd_dpa_port == PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1667 dgrp_dpa_data(nd, 0, (char *) buf, t);
1668 buf += t;
1669 n -= t;
1670 ch->ch_tin = 0;
1671 sendcount += n;
1672 }
1673
1674 memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
1675 if (nd->nd_dpa_debug && nd->nd_dpa_port == PORT_NUM(MINOR(tty_devnum(un->un_tty))))
1676 dgrp_dpa_data(nd, 0, (char *) buf, n);
1677 buf += n;
1678 ch->ch_tin += n;
1679 sendcount += n;
1680
1681 un->un_tbusy--;
1682 (ch->ch_nd)->nd_tx_work = 1;
1683 if (ch->ch_edelay != DGRP_RTIME) {
1684 (ch->ch_nd)->nd_tx_ready = 1;
1685 wake_up_interruptible(&nd->nd_tx_waitq);
1686 }
1687 }
1688
1689 ch->ch_txcount += count;
1690
1691 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1692
1693 /*
1694 * Adjust ch_cpstime to account
1695 * for the characters just output.
1696 */
1697
1698 if (sendcount > 0) {
1699 int cc = HZ * sendcount + ch->ch_cpsrem;
1700
1701 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1702 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1703 }
1704
1705 /*
1706 * If we are now waiting on time, schedule ourself
1707 * back when we'll be able to send a block of
1708 * digi_maxchar characters.
1709 */
1710
1711 if ((un_flag & UN_TIME) != 0) {
1712 ch->ch_waketime = (ch->ch_cpstime +
1713 (ch->ch_digi.digi_maxchar * HZ /
1714 ch->ch_digi.digi_maxcps));
1715 }
1716 }
1717
1718 /*
1719 * If the printer unit is waiting for completion
1720 * of terminal output, get him going again.
1721 */
1722
1723 if ((ch->ch_pun.un_flag & UN_PWAIT) != 0)
1724 (ch->ch_nd)->nd_tx_work = 1;
1725
1726 out:
1727 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1728
1729 return count;
1730 }
1731
1732
1733 /*
1734 * Put a character into ch->ch_buf
1735 *
1736 * - used by the line discipline for OPOST processing
1737 */
1738
1739 static int dgrp_tty_put_char(struct tty_struct *tty, unsigned char new_char)
1740 {
1741 struct un_struct *un;
1742 struct ch_struct *ch;
1743 ulong lock_flags;
1744 int space;
1745 int retval = 0;
1746
1747 if (tty == NULL)
1748 return 0;
1749
1750 un = tty->driver_data;
1751 if (!un)
1752 return 0;
1753
1754 ch = un->un_ch;
1755 if (!ch)
1756 return 0;
1757
1758 if (ch->ch_state != CS_READY)
1759 return 0;
1760
1761 spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);
1762
1763
1764 /*
1765 * If space is 0 and its because the ch->tbuf
1766 * Warn and dump the character, there isn't anything else
1767 * we can do about it. David_Fries@digi.com
1768 */
1769
1770 space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1771
1772 un->un_tbusy++;
1773
1774 /*
1775 * Output the printer on string if device is TXPrint.
1776 */
1777 if (IS_PRINT(MINOR(tty_devnum(tty))) && (ch->ch_flag & CH_PRON) == 0) {
1778 if (space < ch->ch_digi.digi_onlen) {
1779 un->un_tbusy--;
1780 goto out;
1781 }
1782 space -= ch->ch_digi.digi_onlen;
1783 drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
1784 ch->ch_digi.digi_onlen);
1785 ch->ch_flag |= CH_PRON;
1786 }
1787
1788 /*
1789 * Output the printer off string if device is NOT TXPrint.
1790 */
1791
1792 if (!IS_PRINT(MINOR(tty_devnum(tty))) &&
1793 ((ch->ch_flag & CH_PRON) != 0)) {
1794 if (space < ch->ch_digi.digi_offlen) {
1795 un->un_tbusy--;
1796 goto out;
1797 }
1798
1799 space -= ch->ch_digi.digi_offlen;
1800 drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
1801 ch->ch_digi.digi_offlen);
1802 ch->ch_flag &= ~CH_PRON;
1803 }
1804
1805 if (!space) {
1806 un->un_tbusy--;
1807 goto out;
1808 }
1809
1810 /*
1811 * Copy the character to the ch_tbuf being
1812 * careful to wrap around the circular queue
1813 */
1814 ch->ch_tbuf[ch->ch_tin] = new_char;
1815 ch->ch_tin = (1 + ch->ch_tin) & TBUF_MASK;
1816
1817 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1818
1819 /*
1820 * Adjust ch_cpstime to account
1821 * for the character just output.
1822 */
1823
1824 int cc = HZ + ch->ch_cpsrem;
1825
1826 ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
1827 ch->ch_cpsrem = cc % ch->ch_digi.digi_maxcps;
1828
1829 /*
1830 * If we are now waiting on time, schedule ourself
1831 * back when we'll be able to send a block of
1832 * digi_maxchar characters.
1833 */
1834
1835 ch->ch_waketime = (ch->ch_cpstime +
1836 (ch->ch_digi.digi_maxchar * HZ /
1837 ch->ch_digi.digi_maxcps));
1838 }
1839
1840
1841 un->un_tbusy--;
1842 (ch->ch_nd)->nd_tx_work = 1;
1843
1844 retval = 1;
1845 out:
1846 spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
1847 return retval;
1848 }
1849
1850
1851
1852 /*
1853 * Flush TX buffer (make in == out)
1854 *
1855 * check tty_ioctl.c -- this is called after TCOFLUSH
1856 */
1857 static void dgrp_tty_flush_buffer(struct tty_struct *tty)
1858 {
1859 struct un_struct *un;
1860 struct ch_struct *ch;
1861
1862 if (!tty)
1863 return;
1864 un = tty->driver_data;
1865 if (!un)
1866 return;
1867
1868 ch = un->un_ch;
1869 if (!ch)
1870 return;
1871
1872 ch->ch_tout = ch->ch_tin;
1873 /* do NOT do this here! */
1874 /* ch->ch_s_tpos = ch->ch_s_tin = 0; */
1875
1876 /* send the flush output command now */
1877 ch->ch_send |= RR_TX_FLUSH;
1878 (ch->ch_nd)->nd_tx_ready = 1;
1879 (ch->ch_nd)->nd_tx_work = 1;
1880 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
1881
1882 if (waitqueue_active(&tty->write_wait))
1883 wake_up_interruptible(&tty->write_wait);
1884
1885 tty_wakeup(tty);
1886
1887 }
1888
1889 /*
1890 * Return space available in Tx buffer
1891 * count = ( ch->ch_tout - ch->ch_tin ) mod (TBUF_MAX - 1)
1892 */
1893 static int dgrp_tty_write_room(struct tty_struct *tty)
1894 {
1895 struct un_struct *un;
1896 struct ch_struct *ch;
1897 int count;
1898
1899 if (!tty)
1900 return 0;
1901
1902 un = tty->driver_data;
1903 if (!un)
1904 return 0;
1905
1906 ch = un->un_ch;
1907 if (!ch)
1908 return 0;
1909
1910 count = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;
1911
1912 /* We *MUST* check this, and return 0 if the Printer Unit cannot
1913 * take any more data within its time constraints... If we don't
1914 * return 0 and the printer has hit it time constraint, the ld will
1915 * call us back doing a put_char, which cannot be rejected!!!
1916 */
1917 if (IS_PRINT(MINOR(tty_devnum(tty)))) {
1918 int un_flag = 0;
1919 count = dgrp_calculate_txprint_bounds(ch, count, &un_flag);
1920 if (count <= 0)
1921 count = 0;
1922
1923 ch->ch_pun.un_flag |= un_flag;
1924 (ch->ch_nd)->nd_tx_work = 1;
1925 }
1926
1927 return count;
1928 }
1929
1930 /*
1931 * Return number of characters that have not been transmitted yet.
1932 * chars_in_buffer = ( ch->ch_tin - ch->ch_tout ) mod (TBUF_MAX - 1)
1933 * + ( ch->ch_s_tin - ch->ch_s_tout ) mod (0xffff)
1934 * = number of characters "in transit"
1935 *
1936 * Remember that sequence number math is always with a sixteen bit
1937 * mask, not the TBUF_MASK.
1938 */
1939
1940 static int dgrp_tty_chars_in_buffer(struct tty_struct *tty)
1941 {
1942 struct un_struct *un;
1943 struct ch_struct *ch;
1944 int count;
1945 int count1;
1946
1947 if (!tty)
1948 return 0;
1949
1950 un = tty->driver_data;
1951 if (!un)
1952 return 0;
1953
1954 ch = un->un_ch;
1955 if (!ch)
1956 return 0;
1957
1958 count1 = count = (ch->ch_tin - ch->ch_tout) & TBUF_MASK;
1959 count += (ch->ch_s_tin - ch->ch_s_tpos) & 0xffff;
1960 /* one for tbuf, one for the PS */
1961
1962 /*
1963 * If we are busy transmitting add 1
1964 */
1965 count += un->un_tbusy;
1966
1967 return count;
1968 }
1969
1970
1971 /*****************************************************************************
1972 *
1973 * Helper applications for dgrp_tty_ioctl()
1974 *
1975 *****************************************************************************
1976 */
1977
1978
1979 /**
1980 * ch_to_tty_flags() -- convert channel flags to termio flags
1981 * @ch_flag: Digi channel flags
1982 * @flagtype: type of ch_flag (iflag, oflag or cflag)
1983 *
1984 * take the channel flags of the specified type and return the
1985 * corresponding termio flag
1986 */
1987 static tcflag_t ch_to_tty_flags(ushort ch_flag, char flagtype)
1988 {
1989 tcflag_t retval = 0;
1990
1991 switch (flagtype) {
1992 case 'i':
1993 retval = ((ch_flag & IF_IGNBRK) ? IGNBRK : 0)
1994 | ((ch_flag & IF_BRKINT) ? BRKINT : 0)
1995 | ((ch_flag & IF_IGNPAR) ? IGNPAR : 0)
1996 | ((ch_flag & IF_PARMRK) ? PARMRK : 0)
1997 | ((ch_flag & IF_INPCK) ? INPCK : 0)
1998 | ((ch_flag & IF_ISTRIP) ? ISTRIP : 0)
1999 | ((ch_flag & IF_IXON) ? IXON : 0)
2000 | ((ch_flag & IF_IXANY) ? IXANY : 0)
2001 | ((ch_flag & IF_IXOFF) ? IXOFF : 0);
2002 break;
2003
2004 case 'o':
2005 retval = ((ch_flag & OF_OLCUC) ? OLCUC : 0)
2006 | ((ch_flag & OF_ONLCR) ? ONLCR : 0)
2007 | ((ch_flag & OF_OCRNL) ? OCRNL : 0)
2008 | ((ch_flag & OF_ONOCR) ? ONOCR : 0)
2009 | ((ch_flag & OF_ONLRET) ? ONLRET : 0)
2010 /* | ((ch_flag & OF_OTAB3) ? OFILL : 0) */
2011 | ((ch_flag & OF_TABDLY) ? TABDLY : 0);
2012 break;
2013
2014 case 'c':
2015 retval = ((ch_flag & CF_CSTOPB) ? CSTOPB : 0)
2016 | ((ch_flag & CF_CREAD) ? CREAD : 0)
2017 | ((ch_flag & CF_PARENB) ? PARENB : 0)
2018 | ((ch_flag & CF_PARODD) ? PARODD : 0)
2019 | ((ch_flag & CF_HUPCL) ? HUPCL : 0);
2020
2021 switch (ch_flag & CF_CSIZE) {
2022 case CF_CS5:
2023 retval |= CS5;
2024 break;
2025 case CF_CS6:
2026 retval |= CS6;
2027 break;
2028 case CF_CS7:
2029 retval |= CS7;
2030 break;
2031 case CF_CS8:
2032 retval |= CS8;
2033 break;
2034 default:
2035 retval |= CS8;
2036 break;
2037 }
2038 break;
2039 case 'x':
2040 break;
2041 case 'l':
2042 break;
2043 default:
2044 return 0;
2045 }
2046
2047 return retval;
2048 }
2049
2050
2051 /**
2052 * tty_to_ch_flags() -- convert termio flags to digi channel flags
2053 * @tty: pointer to a TTY structure holding flag to be converted
2054 * @flagtype: identifies which flag (iflags, oflags, or cflags) should
2055 * be converted
2056 *
2057 * take the termio flag of the specified type and return the
2058 * corresponding Digi version of the flags
2059 */
2060 static ushort tty_to_ch_flags(struct tty_struct *tty, char flagtype)
2061 {
2062 ushort retval = 0;
2063 tcflag_t tflag = 0;
2064
2065 switch (flagtype) {
2066 case 'i':
2067 tflag = tty->termios.c_iflag;
2068 retval = (I_IGNBRK(tty) ? IF_IGNBRK : 0)
2069 | (I_BRKINT(tty) ? IF_BRKINT : 0)
2070 | (I_IGNPAR(tty) ? IF_IGNPAR : 0)
2071 | (I_PARMRK(tty) ? IF_PARMRK : 0)
2072 | (I_INPCK(tty) ? IF_INPCK : 0)
2073 | (I_ISTRIP(tty) ? IF_ISTRIP : 0)
2074 | (I_IXON(tty) ? IF_IXON : 0)
2075 | (I_IXANY(tty) ? IF_IXANY : 0)
2076 | (I_IXOFF(tty) ? IF_IXOFF : 0);
2077 break;
2078 case 'o':
2079 tflag = tty->termios.c_oflag;
2080 /*
2081 * If OPOST is set, then do the post processing in the
2082 * firmware by setting all the processing flags on.
2083 * If ~OPOST, then make sure we are not doing any
2084 * output processing!!
2085 */
2086 if (!O_OPOST(tty))
2087 retval = 0;
2088 else
2089 retval = (O_OLCUC(tty) ? OF_OLCUC : 0)
2090 | (O_ONLCR(tty) ? OF_ONLCR : 0)
2091 | (O_OCRNL(tty) ? OF_OCRNL : 0)
2092 | (O_ONOCR(tty) ? OF_ONOCR : 0)
2093 | (O_ONLRET(tty) ? OF_ONLRET : 0)
2094 /* | (O_OFILL(tty) ? OF_TAB3 : 0) */
2095 | (O_TABDLY(tty) ? OF_TABDLY : 0);
2096 break;
2097 case 'c':
2098 tflag = tty->termios.c_cflag;
2099 retval = (C_CSTOPB(tty) ? CF_CSTOPB : 0)
2100 | (C_CREAD(tty) ? CF_CREAD : 0)
2101 | (C_PARENB(tty) ? CF_PARENB : 0)
2102 | (C_PARODD(tty) ? CF_PARODD : 0)
2103 | (C_HUPCL(tty) ? CF_HUPCL : 0);
2104 switch (C_CSIZE(tty)) {
2105 case CS8:
2106 retval |= CF_CS8;
2107 break;
2108 case CS7:
2109 retval |= CF_CS7;
2110 break;
2111 case CS6:
2112 retval |= CF_CS6;
2113 break;
2114 case CS5:
2115 retval |= CF_CS5;
2116 break;
2117 default:
2118 retval |= CF_CS8;
2119 break;
2120 }
2121 break;
2122 case 'x':
2123 break;
2124 case 'l':
2125 break;
2126 default:
2127 return 0;
2128 }
2129
2130 return retval;
2131 }
2132
2133
2134 static int dgrp_tty_send_break(struct tty_struct *tty, int msec)
2135 {
2136 struct un_struct *un;
2137 struct ch_struct *ch;
2138 int ret = -EIO;
2139
2140 if (!tty)
2141 return ret;
2142
2143 un = tty->driver_data;
2144 if (!un)
2145 return ret;
2146
2147 ch = un->un_ch;
2148 if (!ch)
2149 return ret;
2150
2151 dgrp_send_break(ch, msec);
2152 return 0;
2153 }
2154
2155
2156 /*
2157 * This routine sends a break character out the serial port.
2158 *
2159 * duration is in 1/1000's of a second
2160 */
2161 static int dgrp_send_break(struct ch_struct *ch, int msec)
2162 {
2163 ulong x;
2164
2165 wait_event_interruptible(ch->ch_flag_wait,
2166 ((ch->ch_flag & CH_TX_BREAK) == 0));
2167 ch->ch_break_time += max(msec, 250);
2168 ch->ch_send |= RR_TX_BREAK;
2169 ch->ch_flag |= CH_TX_BREAK;
2170 (ch->ch_nd)->nd_tx_work = 1;
2171
2172 x = (msec * HZ) / 1000;
2173 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2174
2175 return 0;
2176 }
2177
2178
2179 /*
2180 * Return modem signals to ld.
2181 */
2182 static int dgrp_tty_tiocmget(struct tty_struct *tty)
2183 {
2184 unsigned int mlast;
2185 struct un_struct *un = tty->driver_data;
2186 struct ch_struct *ch;
2187
2188 if (!un)
2189 return -ENODEV;
2190
2191 ch = un->un_ch;
2192 if (!ch)
2193 return -ENODEV;
2194
2195 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2196 (ch->ch_mout & (DM_RTS | DM_DTR)));
2197
2198 /* defined in /usr/include/asm/termios.h */
2199 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2200 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2201 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2202 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2203 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2204 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2205
2206 return mlast;
2207 }
2208
2209
2210 /*
2211 * Set modem lines
2212 */
2213 static int dgrp_tty_tiocmset(struct tty_struct *tty,
2214 unsigned int set, unsigned int clear)
2215 {
2216 ulong lock_flags;
2217 struct un_struct *un = tty->driver_data;
2218 struct ch_struct *ch;
2219
2220 if (!un)
2221 return -ENODEV;
2222
2223 ch = un->un_ch;
2224 if (!ch)
2225 return -ENODEV;
2226
2227 if (set & TIOCM_RTS)
2228 ch->ch_mout |= DM_RTS;
2229
2230 if (set & TIOCM_DTR)
2231 ch->ch_mout |= DM_DTR;
2232
2233 if (clear & TIOCM_RTS)
2234 ch->ch_mout &= ~(DM_RTS);
2235
2236 if (clear & TIOCM_DTR)
2237 ch->ch_mout &= ~(DM_DTR);
2238
2239 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2240 ch->ch_flag |= CH_PARAM;
2241 (ch->ch_nd)->nd_tx_work = 1;
2242 wake_up_interruptible(&ch->ch_flag_wait);
2243
2244 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2245
2246 return 0;
2247 }
2248
2249
2250
2251 /*
2252 * Get current modem status
2253 */
2254 static int get_modem_info(struct ch_struct *ch, unsigned int *value)
2255 {
2256 unsigned int mlast;
2257
2258 mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
2259 (ch->ch_mout & (DM_RTS | DM_DTR)));
2260
2261 /* defined in /usr/include/asm/termios.h */
2262 mlast = ((mlast & DM_RTS) ? TIOCM_RTS : 0)
2263 | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
2264 | ((mlast & DM_CD) ? TIOCM_CAR : 0)
2265 | ((mlast & DM_RI) ? TIOCM_RNG : 0)
2266 | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
2267 | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
2268 return put_user(mlast, (unsigned int __user *) value);
2269 }
2270
2271 /*
2272 * Set modem lines
2273 */
2274 static int set_modem_info(struct ch_struct *ch, unsigned int command,
2275 unsigned int *value)
2276 {
2277 int error;
2278 unsigned int arg;
2279 int mval = 0;
2280 ulong lock_flags;
2281
2282 error = access_ok(VERIFY_READ, (void __user *) value, sizeof(int));
2283 if (error == 0)
2284 return -EFAULT;
2285
2286 if (get_user(arg, (unsigned int __user *) value))
2287 return -EFAULT;
2288 mval |= ((arg & TIOCM_RTS) ? DM_RTS : 0)
2289 | ((arg & TIOCM_DTR) ? DM_DTR : 0);
2290
2291 switch (command) {
2292 case TIOCMBIS: /* set flags */
2293 ch->ch_mout |= mval;
2294 break;
2295 case TIOCMBIC: /* clear flags */
2296 ch->ch_mout &= ~mval;
2297 break;
2298 case TIOCMSET:
2299 ch->ch_mout = mval;
2300 break;
2301 default:
2302 return -EINVAL;
2303 }
2304
2305 spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
2306
2307 ch->ch_flag |= CH_PARAM;
2308 (ch->ch_nd)->nd_tx_work = 1;
2309 wake_up_interruptible(&ch->ch_flag_wait);
2310
2311 spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);
2312
2313 return 0;
2314 }
2315
2316
2317 /*
2318 * Assign the custom baud rate to the channel structure
2319 */
2320 static void dgrp_set_custom_speed(struct ch_struct *ch, int newrate)
2321 {
2322 int testdiv;
2323 int testrate_high;
2324 int testrate_low;
2325
2326 int deltahigh, deltalow;
2327
2328 if (newrate < 0)
2329 newrate = 0;
2330
2331 /*
2332 * Since the divisor is stored in a 16-bit integer, we make sure
2333 * we don't allow any rates smaller than a 16-bit integer would allow.
2334 * And of course, rates above the dividend won't fly.
2335 */
2336 if (newrate && newrate < ((PORTSERVER_DIVIDEND / 0xFFFF) + 1))
2337 newrate = ((PORTSERVER_DIVIDEND / 0xFFFF) + 1);
2338 if (newrate && newrate > PORTSERVER_DIVIDEND)
2339 newrate = PORTSERVER_DIVIDEND;
2340
2341 while (newrate > 0) {
2342 testdiv = PORTSERVER_DIVIDEND / newrate;
2343
2344 /*
2345 * If we try to figure out what rate the PortServer would use
2346 * with the test divisor, it will be either equal or higher
2347 * than the requested baud rate. If we then determine the
2348 * rate with a divisor one higher, we will get the next lower
2349 * supported rate below the requested.
2350 */
2351 testrate_high = PORTSERVER_DIVIDEND / testdiv;
2352 testrate_low = PORTSERVER_DIVIDEND / (testdiv + 1);
2353
2354 /*
2355 * If the rate for the requested divisor is correct, just
2356 * use it and be done.
2357 */
2358 if (testrate_high == newrate)
2359 break;
2360
2361 /*
2362 * Otherwise, pick the rate that is closer (i.e. whichever rate
2363 * has a smaller delta).
2364 */
2365 deltahigh = testrate_high - newrate;
2366 deltalow = newrate - testrate_low;
2367
2368 if (deltahigh < deltalow)
2369 newrate = testrate_high;
2370 else
2371 newrate = testrate_low;
2372
2373 break;
2374 }
2375
2376 ch->ch_custom_speed = newrate;
2377
2378 drp_param(ch);
2379
2380 return;
2381 }
2382
2383
2384 /*
2385 # dgrp_tty_digiseta()
2386 *
2387 * Ioctl to set the information from ditty.
2388 *
2389 * NOTE: DIGI_IXON, DSRPACE, DCDPACE, and DTRPACE are unsupported. JAR 990922
2390 */
2391 static int dgrp_tty_digiseta(struct tty_struct *tty,
2392 struct digi_struct *new_info)
2393 {
2394 struct un_struct *un = tty->driver_data;
2395 struct ch_struct *ch;
2396
2397 if (!un)
2398 return -ENODEV;
2399
2400 ch = un->un_ch;
2401 if (!ch)
2402 return -ENODEV;
2403
2404 if (copy_from_user(&ch->ch_digi, (void __user *) new_info,
2405 sizeof(struct digi_struct)))
2406 return -EFAULT;
2407
2408 if ((ch->ch_digi.digi_flags & RTSPACE) ||
2409 (ch->ch_digi.digi_flags & CTSPACE))
2410 tty->termios.c_cflag |= CRTSCTS;
2411 else
2412 tty->termios.c_cflag &= ~CRTSCTS;
2413
2414 if (ch->ch_digi.digi_maxcps < 1)
2415 ch->ch_digi.digi_maxcps = 1;
2416
2417 if (ch->ch_digi.digi_maxcps > 10000)
2418 ch->ch_digi.digi_maxcps = 10000;
2419
2420 if (ch->ch_digi.digi_bufsize < 10)
2421 ch->ch_digi.digi_bufsize = 10;
2422
2423 if (ch->ch_digi.digi_maxchar < 1)
2424 ch->ch_digi.digi_maxchar = 1;
2425
2426 if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
2427 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;
2428
2429 if (ch->ch_digi.digi_onlen > DIGI_PLEN)
2430 ch->ch_digi.digi_onlen = DIGI_PLEN;
2431
2432 if (ch->ch_digi.digi_offlen > DIGI_PLEN)
2433 ch->ch_digi.digi_offlen = DIGI_PLEN;
2434
2435 /* make the changes now */
2436 drp_param(ch);
2437
2438 return 0;
2439 }
2440
2441
2442
2443 /*
2444 * dgrp_tty_digigetedelay()
2445 *
2446 * Ioctl to get the current edelay setting.
2447 *
2448 *
2449 *
2450 */
2451 static int dgrp_tty_digigetedelay(struct tty_struct *tty, int *retinfo)
2452 {
2453 struct un_struct *un;
2454 struct ch_struct *ch;
2455 int tmp;
2456
2457 if (!retinfo)
2458 return -EFAULT;
2459
2460 if (!tty || tty->magic != TTY_MAGIC)
2461 return -EFAULT;
2462
2463 un = tty->driver_data;
2464
2465 if (!un)
2466 return -ENODEV;
2467
2468 ch = un->un_ch;
2469 if (!ch)
2470 return -ENODEV;
2471
2472 tmp = ch->ch_edelay;
2473
2474 if (copy_to_user((void __user *) retinfo, &tmp, sizeof(*retinfo)))
2475 return -EFAULT;
2476
2477 return 0;
2478 }
2479
2480
2481 /*
2482 * dgrp_tty_digisetedelay()
2483 *
2484 * Ioctl to set the EDELAY setting
2485 *
2486 */
2487 static int dgrp_tty_digisetedelay(struct tty_struct *tty, int *new_info)
2488 {
2489 struct un_struct *un;
2490 struct ch_struct *ch;
2491 int new_digi;
2492
2493 if (!tty || tty->magic != TTY_MAGIC)
2494 return -EFAULT;
2495
2496 un = tty->driver_data;
2497
2498 if (!un)
2499 return -ENODEV;
2500
2501 ch = un->un_ch;
2502 if (!ch)
2503 return -ENODEV;
2504
2505 if (copy_from_user(&new_digi, (void __user *)new_info, sizeof(int)))
2506 return -EFAULT;
2507
2508 ch->ch_edelay = new_digi;
2509
2510 /* make the changes now */
2511 drp_param(ch);
2512
2513 return 0;
2514 }
2515
2516
2517 /*
2518 * The usual assortment of ioctl's
2519 *
2520 * note: use tty_check_change to make sure that we are not
2521 * changing the state of a terminal when we are not a process
2522 * in the forground. See tty_io.c
2523 * rc = tty_check_change(tty);
2524 * if (rc) return rc;
2525 */
2526 static int dgrp_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
2527 unsigned long arg)
2528 {
2529 struct un_struct *un;
2530 struct ch_struct *ch;
2531 int rc;
2532 struct digiflow_struct dflow;
2533
2534 if (!tty)
2535 return -ENODEV;
2536
2537 un = tty->driver_data;
2538 if (!un)
2539 return -ENODEV;
2540
2541 ch = un->un_ch;
2542 if (!ch)
2543 return -ENODEV;
2544
2545 switch (cmd) {
2546
2547 /*
2548 * Here are all the standard ioctl's that we MUST implement
2549 */
2550
2551 case TCSBRK:
2552 /*
2553 * TCSBRK is SVID version: non-zero arg --> no break
2554 * this behaviour is exploited by tcdrain().
2555 *
2556 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2557 * between 0.25 and 0.5 seconds
2558 */
2559
2560 rc = tty_check_change(tty);
2561 if (rc)
2562 return rc;
2563 tty_wait_until_sent(tty, 0);
2564
2565 if (!arg)
2566 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2567
2568 if (dgrp_tty_chars_in_buffer(tty) != 0)
2569 return -EINTR;
2570
2571 return 0;
2572
2573 case TCSBRKP:
2574 /* support for POSIX tcsendbreak()
2575 *
2576 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2577 * between 0.25 and 0.5 seconds so we'll ask for something
2578 * in the middle: 0.375 seconds.
2579 */
2580 rc = tty_check_change(tty);
2581 if (rc)
2582 return rc;
2583 tty_wait_until_sent(tty, 0);
2584
2585 rc = dgrp_send_break(ch, arg ? arg*250 : 250);
2586
2587 if (dgrp_tty_chars_in_buffer(tty) != 0)
2588 return -EINTR;
2589 return 0;
2590
2591 case TIOCSBRK:
2592 rc = tty_check_change(tty);
2593 if (rc)
2594 return rc;
2595 tty_wait_until_sent(tty, 0);
2596
2597 /*
2598 * RealPort doesn't support turning on a break unconditionally.
2599 * The RealPort device will stop sending a break automatically
2600 * after the specified time value that we send in.
2601 */
2602 rc = dgrp_send_break(ch, 250); /* 1/4 second */
2603
2604 if (dgrp_tty_chars_in_buffer(tty) != 0)
2605 return -EINTR;
2606 return 0;
2607
2608 case TIOCCBRK:
2609 /*
2610 * RealPort doesn't support turning off a break unconditionally.
2611 * The RealPort device will stop sending a break automatically
2612 * after the specified time value that was sent when turning on
2613 * the break.
2614 */
2615 return 0;
2616
2617 case TIOCMGET:
2618 rc = access_ok(VERIFY_WRITE, (void __user *) arg,
2619 sizeof(unsigned int));
2620 if (rc == 0)
2621 return -EFAULT;
2622 return get_modem_info(ch, (unsigned int *) arg);
2623
2624 case TIOCMBIS:
2625 case TIOCMBIC:
2626 case TIOCMSET:
2627 return set_modem_info(ch, cmd, (unsigned int *) arg);
2628
2629 /*
2630 * Here are any additional ioctl's that we want to implement
2631 */
2632
2633 case TCFLSH:
2634 /*
2635 * The linux tty driver doesn't have a flush
2636 * input routine for the driver, assuming all backed
2637 * up data is in the line disc. buffers. However,
2638 * we all know that's not the case. Here, we
2639 * act on the ioctl, but then lie and say we didn't
2640 * so the line discipline will process the flush
2641 * also.
2642 */
2643 rc = tty_check_change(tty);
2644 if (rc)
2645 return rc;
2646
2647 switch (arg) {
2648 case TCIFLUSH:
2649 case TCIOFLUSH:
2650 /* only flush input if this is the only open unit */
2651 if (!IS_PRINT(MINOR(tty_devnum(tty)))) {
2652 ch->ch_rout = ch->ch_rin;
2653 ch->ch_send |= RR_RX_FLUSH;
2654 (ch->ch_nd)->nd_tx_work = 1;
2655 (ch->ch_nd)->nd_tx_ready = 1;
2656 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2657 }
2658 if (arg == TCIFLUSH)
2659 break;
2660
2661 case TCOFLUSH: /* flush output, or the receive buffer */
2662 /*
2663 * This is handled in the tty_ioctl.c code
2664 * calling tty_flush_buffer
2665 */
2666 break;
2667
2668 default:
2669 /* POSIX.1 says return EINVAL if we got a bad arg */
2670 return -EINVAL;
2671 }
2672 /* pretend we didn't recognize this IOCTL */
2673 return -ENOIOCTLCMD;
2674
2675 #ifdef TIOCGETP
2676 case TIOCGETP:
2677 #endif
2678 /*****************************************
2679 Linux HPUX Function
2680 TCSETA TCSETA - set the termios
2681 TCSETAF TCSETAF - wait for drain first, then set termios
2682 TCSETAW TCSETAW - wait for drain, flush the input queue, then set termios
2683 - looking at the tty_ioctl code, these command all call our
2684 tty_set_termios at the driver's end, when a TCSETA* is sent,
2685 it is expecting the tty to have a termio structure,
2686 NOT a termios structure. These two structures differ in size
2687 and the tty_ioctl code does a conversion before processing them both.
2688 - we should treat the TCSETAW TCSETAF ioctls the same, and let
2689 the tty_ioctl code do the conversion stuff.
2690
2691 TCSETS
2692 TCSETSF (none)
2693 TCSETSW
2694 - the associated tty structure has a termios structure.
2695 *****************************************/
2696
2697 case TCGETS:
2698 case TCGETA:
2699 return -ENOIOCTLCMD;
2700
2701 case TCSETAW:
2702 case TCSETAF:
2703 case TCSETSF:
2704 case TCSETSW:
2705 /*
2706 * The linux tty driver doesn't have a flush
2707 * input routine for the driver, assuming all backed
2708 * up data is in the line disc. buffers. However,
2709 * we all know that's not the case. Here, we
2710 * act on the ioctl, but then lie and say we didn't
2711 * so the line discipline will process the flush
2712 * also.
2713 */
2714
2715 /*
2716 * Also, now that we have TXPrint, we have to check
2717 * if this is the TXPrint device and the terminal
2718 * device is open. If so, do NOT run check_change,
2719 * as the terminal device is ALWAYS the parent.
2720 */
2721 if (!IS_PRINT(MINOR(tty_devnum(tty))) ||
2722 !ch->ch_tun.un_open_count) {
2723 rc = tty_check_change(tty);
2724 if (rc)
2725 return rc;
2726 }
2727
2728 /* wait for all the characters in tbuf to drain */
2729 tty_wait_until_sent(tty, 0);
2730
2731 if ((cmd == TCSETSF) || (cmd == TCSETAF)) {
2732 /* flush the contents of the rbuf queue */
2733 /* TODO: check if this is print device? */
2734 ch->ch_send |= RR_RX_FLUSH;
2735 (ch->ch_nd)->nd_tx_ready = 1;
2736 (ch->ch_nd)->nd_tx_work = 1;
2737 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2738 /* do we need to do this? just to be safe! */
2739 ch->ch_rout = ch->ch_rin;
2740 }
2741
2742 /* pretend we didn't recognize this */
2743 return -ENOIOCTLCMD;
2744
2745 case TCXONC:
2746 /*
2747 * The Linux Line Discipline (LD) would do this for us if we
2748 * let it, but we have the special firmware options to do this
2749 * the "right way" regardless of hardware or software flow
2750 * control so we'll do it outselves instead of letting the LD
2751 * do it.
2752 */
2753 rc = tty_check_change(tty);
2754 if (rc)
2755 return rc;
2756
2757 switch (arg) {
2758 case TCOON:
2759 dgrp_tty_start(tty);
2760 return 0;
2761 case TCOOFF:
2762 dgrp_tty_stop(tty);
2763 return 0;
2764 case TCION:
2765 dgrp_tty_input_start(tty);
2766 return 0;
2767 case TCIOFF:
2768 dgrp_tty_input_stop(tty);
2769 return 0;
2770 default:
2771 return -EINVAL;
2772 }
2773
2774 case DIGI_GETA:
2775 /* get information for ditty */
2776 if (copy_to_user((struct digi_struct __user *) arg,
2777 &ch->ch_digi, sizeof(struct digi_struct)))
2778 return -EFAULT;
2779 break;
2780
2781 case DIGI_SETAW:
2782 case DIGI_SETAF:
2783 /* wait for all the characters in tbuf to drain */
2784 tty_wait_until_sent(tty, 0);
2785
2786 if (cmd == DIGI_SETAF) {
2787 /* flush the contents of the rbuf queue */
2788 /* send down a packet with RR_RX_FLUSH set */
2789 ch->ch_send |= RR_RX_FLUSH;
2790 (ch->ch_nd)->nd_tx_ready = 1;
2791 (ch->ch_nd)->nd_tx_work = 1;
2792 wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
2793 /* do we need to do this? just to be safe! */
2794 ch->ch_rout = ch->ch_rin;
2795 }
2796
2797 /* pretend we didn't recognize this */
2798
2799 case DIGI_SETA:
2800 return dgrp_tty_digiseta(tty, (struct digi_struct *) arg);
2801
2802 case DIGI_SEDELAY:
2803 return dgrp_tty_digisetedelay(tty, (int *) arg);
2804
2805 case DIGI_GEDELAY:
2806 return dgrp_tty_digigetedelay(tty, (int *) arg);
2807
2808 case DIGI_GETFLOW:
2809 case DIGI_GETAFLOW:
2810 if (cmd == (DIGI_GETFLOW)) {
2811 dflow.startc = tty->termios.c_cc[VSTART];
2812 dflow.stopc = tty->termios.c_cc[VSTOP];
2813 } else {
2814 dflow.startc = ch->ch_xxon;
2815 dflow.stopc = ch->ch_xxoff;
2816 }
2817
2818 if (copy_to_user((char __user *)arg, &dflow, sizeof(dflow)))
2819 return -EFAULT;
2820 break;
2821
2822 case DIGI_SETFLOW:
2823 case DIGI_SETAFLOW:
2824
2825 if (copy_from_user(&dflow, (char __user *)arg, sizeof(dflow)))
2826 return -EFAULT;
2827
2828 if (cmd == (DIGI_SETFLOW)) {
2829 tty->termios.c_cc[VSTART] = dflow.startc;
2830 tty->termios.c_cc[VSTOP] = dflow.stopc;
2831 } else {
2832 ch->ch_xxon = dflow.startc;
2833 ch->ch_xxoff = dflow.stopc;
2834 }
2835 break;
2836
2837 case DIGI_GETCUSTOMBAUD:
2838 if (put_user(ch->ch_custom_speed, (unsigned int __user *) arg))
2839 return -EFAULT;
2840 break;
2841
2842 case DIGI_SETCUSTOMBAUD:
2843 {
2844 int new_rate;
2845
2846 if (get_user(new_rate, (unsigned int __user *) arg))
2847 return -EFAULT;
2848 dgrp_set_custom_speed(ch, new_rate);
2849
2850 break;
2851 }
2852
2853 default:
2854 return -ENOIOCTLCMD;
2855 }
2856
2857 return 0;
2858 }
2859
2860 /*
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.
2865 *
2866 * So we need to make sure that our copies of ch_oflag,
2867 * ch_clag, and ch_iflag reflect the tty->termios flags.
2868 */
2869 static void dgrp_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
2870 {
2871 struct ktermios *ts;
2872 struct ch_struct *ch;
2873 struct un_struct *un;
2874
2875 /* seems silly, but we have to check all these! */
2876 if (!tty)
2877 return;
2878
2879 un = tty->driver_data;
2880 if (!un)
2881 return;
2882
2883 ts = &tty->termios;
2884
2885 ch = un->un_ch;
2886 if (!ch)
2887 return;
2888
2889 drp_param(ch);
2890
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);
2894 }
2895
2896
2897 /*
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.
2901 */
2902 static void dgrp_tty_throttle(struct tty_struct *tty)
2903 {
2904 struct ch_struct *ch;
2905
2906 if (!tty)
2907 return;
2908
2909 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2910 if (!ch)
2911 return;
2912
2913 ch->ch_flag |= CH_RXSTOP;
2914 }
2915
2916
2917 static void dgrp_tty_unthrottle(struct tty_struct *tty)
2918 {
2919 struct ch_struct *ch;
2920
2921 if (!tty)
2922 return;
2923
2924 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2925 if (!ch)
2926 return;
2927
2928 ch->ch_flag &= ~CH_RXSTOP;
2929 }
2930
2931 /*
2932 * Stop the transmitter
2933 */
2934 static void dgrp_tty_stop(struct tty_struct *tty)
2935 {
2936 struct ch_struct *ch;
2937
2938 if (!tty)
2939 return;
2940
2941 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2942 if (!ch)
2943 return;
2944
2945 ch->ch_send |= RR_TX_STOP;
2946 ch->ch_send &= ~RR_TX_START;
2947
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);
2952 }
2953
2954 /*
2955 * Start the transmitter
2956 */
2957 static void dgrp_tty_start(struct tty_struct *tty)
2958 {
2959 struct ch_struct *ch;
2960
2961 if (!tty)
2962 return;
2963
2964 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2965 if (!ch)
2966 return;
2967
2968 /* TODO: don't do anything if the transmitter is not stopped */
2969
2970 ch->ch_send |= RR_TX_START;
2971 ch->ch_send &= ~RR_TX_STOP;
2972
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);
2978
2979 }
2980
2981 /*
2982 * Stop the receiver
2983 */
2984 static void dgrp_tty_input_stop(struct tty_struct *tty)
2985 {
2986 struct ch_struct *ch;
2987
2988 if (!tty)
2989 return;
2990
2991 ch = ((struct un_struct *) tty->driver_data)->un_ch;
2992 if (!ch)
2993 return;
2994
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);
3000
3001 }
3002
3003
3004 static void dgrp_tty_send_xchar(struct tty_struct *tty, char c)
3005 {
3006 struct un_struct *un;
3007 struct ch_struct *ch;
3008
3009 if (!tty)
3010 return;
3011
3012 un = tty->driver_data;
3013 if (!un)
3014 return;
3015
3016 ch = un->un_ch;
3017 if (!ch)
3018 return;
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;
3023
3024 ch->ch_nd->nd_tx_ready = 1;
3025 ch->ch_nd->nd_tx_work = 1;
3026
3027 return;
3028 }
3029
3030
3031 static void dgrp_tty_input_start(struct tty_struct *tty)
3032 {
3033 struct ch_struct *ch;
3034
3035 if (!tty)
3036 return;
3037
3038 ch = ((struct un_struct *) tty->driver_data)->un_ch;
3039 if (!ch)
3040 return;
3041
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);
3048
3049 }
3050
3051
3052 /*
3053 * Hangup the port. Like a close, but don't wait for output
3054 * to drain.
3055 *
3056 * How do we close all the channels that are open?
3057 */
3058 static void dgrp_tty_hangup(struct tty_struct *tty)
3059 {
3060 struct ch_struct *ch;
3061 struct nd_struct *nd;
3062 struct un_struct *un;
3063
3064 if (!tty)
3065 return;
3066
3067 un = tty->driver_data;
3068 if (!un)
3069 return;
3070
3071 ch = un->un_ch;
3072 if (!ch)
3073 return;
3074
3075 nd = ch->ch_nd;
3076
3077 if (C_HUPCL(tty)) {
3078 /* LOWER DTR */
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);
3086 }
3087
3088 }
3089
3090 /************************************************************************/
3091 /* */
3092 /* TTY Initialization/Cleanup Functions */
3093 /* */
3094 /************************************************************************/
3095
3096 /*
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.
3101 */
3102 void
3103 dgrp_tty_uninit(struct nd_struct *nd)
3104 {
3105 unsigned int i;
3106 char id[3];
3107
3108 ID_TO_CHAR(nd->nd_ID, id);
3109
3110 if (nd->nd_ttdriver_flags & SERIAL_TTDRV_REG) {
3111 tty_unregister_driver(nd->nd_serial_ttdriver);
3112
3113 kfree(nd->nd_serial_ttdriver->ttys);
3114 nd->nd_serial_ttdriver->ttys = NULL;
3115
3116 put_tty_driver(nd->nd_serial_ttdriver);
3117 nd->nd_ttdriver_flags &= ~SERIAL_TTDRV_REG;
3118 }
3119
3120 if (nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG) {
3121 tty_unregister_driver(nd->nd_callout_ttdriver);
3122
3123 kfree(nd->nd_callout_ttdriver->ttys);
3124 nd->nd_callout_ttdriver->ttys = NULL;
3125
3126 put_tty_driver(nd->nd_callout_ttdriver);
3127 nd->nd_ttdriver_flags &= ~CALLOUT_TTDRV_REG;
3128 }
3129
3130 if (nd->nd_ttdriver_flags & XPRINT_TTDRV_REG) {
3131 tty_unregister_driver(nd->nd_xprint_ttdriver);
3132
3133 kfree(nd->nd_xprint_ttdriver->ttys);
3134 nd->nd_xprint_ttdriver->ttys = NULL;
3135
3136 put_tty_driver(nd->nd_xprint_ttdriver);
3137 nd->nd_ttdriver_flags &= ~XPRINT_TTDRV_REG;
3138 }
3139 for (i = 0; i < CHAN_MAX; i++)
3140 tty_port_destroy(&nd->nd_chan[i].port);
3141 }
3142
3143
3144
3145 /*
3146 * Initialize the TTY portion of the supplied node.
3147 */
3148 int
3149 dgrp_tty_init(struct nd_struct *nd)
3150 {
3151 char id[3];
3152 int rc;
3153 int i;
3154
3155 ID_TO_CHAR(nd->nd_ID, id);
3156
3157 /*
3158 * Initialize the TTDRIVER structures.
3159 */
3160
3161 nd->nd_serial_ttdriver = alloc_tty_driver(CHAN_MAX);
3162 if (!nd->nd_serial_ttdriver)
3163 return -ENOMEM;
3164
3165 sprintf(nd->nd_serial_name, "tty_dgrp_%s_", id);
3166
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);
3179
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)
3184 return -ENOMEM;
3185
3186 tty_set_operations(nd->nd_serial_ttdriver, &dgrp_tty_ops);
3187
3188 if (!(nd->nd_ttdriver_flags & SERIAL_TTDRV_REG)) {
3189 /*
3190 * Register tty devices
3191 */
3192 rc = tty_register_driver(nd->nd_serial_ttdriver);
3193 if (rc < 0) {
3194 /*
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)
3198 *
3199 * We can still request majors above 256,
3200 * we just have to do it manually.
3201 */
3202 if (rc == -EBUSY) {
3203 int i;
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(nd->nd_serial_ttdriver);
3208 if (rc >= 0)
3209 break;
3210 }
3211 /* Really fail now, since we ran out
3212 * of majors to try. */
3213 if (i == max_majors)
3214 return rc;
3215
3216 } else {
3217 return rc;
3218 }
3219 }
3220 nd->nd_ttdriver_flags |= SERIAL_TTDRV_REG;
3221 }
3222
3223 nd->nd_callout_ttdriver = alloc_tty_driver(CHAN_MAX);
3224 if (!nd->nd_callout_ttdriver)
3225 return -ENOMEM;
3226
3227 sprintf(nd->nd_callout_name, "cu_dgrp_%s_", id);
3228
3229 nd->nd_callout_ttdriver->owner = THIS_MODULE;
3230 nd->nd_callout_ttdriver->name = nd->nd_callout_name;
3231 nd->nd_callout_ttdriver->name_base = 0;
3232 nd->nd_callout_ttdriver->major = nd->nd_serial_ttdriver->major;
3233 nd->nd_callout_ttdriver->minor_start = 0x40;
3234 nd->nd_callout_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3235 nd->nd_callout_ttdriver->subtype = SERIAL_TYPE_CALLOUT;
3236 nd->nd_callout_ttdriver->init_termios = DefaultTermios;
3237 nd->nd_callout_ttdriver->driver_name = "dgrp";
3238 nd->nd_callout_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3239 TTY_DRIVER_DYNAMIC_DEV |
3240 TTY_DRIVER_HARDWARE_BREAK);
3241
3242 /* The kernel wants space to store pointers to tty_structs. */
3243 nd->nd_callout_ttdriver->ttys =
3244 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3245 if (!nd->nd_callout_ttdriver->ttys)
3246 return -ENOMEM;
3247
3248 tty_set_operations(nd->nd_callout_ttdriver, &dgrp_tty_ops);
3249
3250 if (dgrp_register_cudevices) {
3251 if (!(nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG)) {
3252 /*
3253 * Register cu devices
3254 */
3255 rc = tty_register_driver(nd->nd_callout_ttdriver);
3256 if (rc < 0)
3257 return rc;
3258 nd->nd_ttdriver_flags |= CALLOUT_TTDRV_REG;
3259 }
3260 }
3261
3262
3263 nd->nd_xprint_ttdriver = alloc_tty_driver(CHAN_MAX);
3264 if (!nd->nd_xprint_ttdriver)
3265 return -ENOMEM;
3266
3267 sprintf(nd->nd_xprint_name, "pr_dgrp_%s_", id);
3268
3269 nd->nd_xprint_ttdriver->owner = THIS_MODULE;
3270 nd->nd_xprint_ttdriver->name = nd->nd_xprint_name;
3271 nd->nd_xprint_ttdriver->name_base = 0;
3272 nd->nd_xprint_ttdriver->major = nd->nd_serial_ttdriver->major;
3273 nd->nd_xprint_ttdriver->minor_start = 0x80;
3274 nd->nd_xprint_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
3275 nd->nd_xprint_ttdriver->subtype = SERIAL_TYPE_XPRINT;
3276 nd->nd_xprint_ttdriver->init_termios = DefaultTermios;
3277 nd->nd_xprint_ttdriver->driver_name = "dgrp";
3278 nd->nd_xprint_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
3279 TTY_DRIVER_DYNAMIC_DEV |
3280 TTY_DRIVER_HARDWARE_BREAK);
3281
3282 /* The kernel wants space to store pointers to tty_structs. */
3283 nd->nd_xprint_ttdriver->ttys =
3284 kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
3285 if (!nd->nd_xprint_ttdriver->ttys)
3286 return -ENOMEM;
3287
3288 tty_set_operations(nd->nd_xprint_ttdriver, &dgrp_tty_ops);
3289
3290 if (dgrp_register_prdevices) {
3291 if (!(nd->nd_ttdriver_flags & XPRINT_TTDRV_REG)) {
3292 /*
3293 * Register transparent print devices
3294 */
3295 rc = tty_register_driver(nd->nd_xprint_ttdriver);
3296 if (rc < 0)
3297 return rc;
3298 nd->nd_ttdriver_flags |= XPRINT_TTDRV_REG;
3299 }
3300 }
3301
3302 for (i = 0; i < CHAN_MAX; i++) {
3303 struct ch_struct *ch = nd->nd_chan + i;
3304
3305 ch->ch_nd = nd;
3306 ch->ch_digi = digi_init;
3307 ch->ch_edelay = 100;
3308 ch->ch_custom_speed = 0;
3309 ch->ch_portnum = i;
3310 ch->ch_tun.un_ch = ch;
3311 ch->ch_pun.un_ch = ch;
3312 ch->ch_tun.un_type = SERIAL_TYPE_NORMAL;
3313 ch->ch_pun.un_type = SERIAL_TYPE_XPRINT;
3314
3315 init_waitqueue_head(&(ch->ch_flag_wait));
3316 init_waitqueue_head(&(ch->ch_sleep));
3317
3318 init_waitqueue_head(&(ch->ch_tun.un_open_wait));
3319 init_waitqueue_head(&(ch->ch_tun.un_close_wait));
3320
3321 init_waitqueue_head(&(ch->ch_pun.un_open_wait));
3322 init_waitqueue_head(&(ch->ch_pun.un_close_wait));
3323 tty_port_init(&ch->port);
3324 }
3325 return 0;
3326 }
Linux kernel - Deliverables
This page took 0.103304 seconds and 5 git commands to generate.