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