2 * Copyright 2003 Digi International (www.digi.com)
3 * Scott H Kilau <Scott_Kilau at digi dot com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
12 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13 * PURPOSE. See the GNU General Public License for more details.
17 * This file implements the tty driver functionality for the
18 * Neo and ClassicBoard PCI based product lines.
21 #include <linux/kernel.h>
22 #include <linux/sched/signal.h> /* For jiffies, task states, etc. */
23 #include <linux/interrupt.h> /* For tasklet and interrupt structs/defines */
24 #include <linux/module.h>
25 #include <linux/ctype.h>
26 #include <linux/tty.h>
27 #include <linux/tty_flip.h>
28 #include <linux/types.h>
29 #include <linux/serial_reg.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h> /* For udelay */
32 #include <linux/uaccess.h> /* For copy_from_user/copy_to_user */
33 #include <linux/pci.h>
34 #include "dgnc_driver.h"
38 #include "dgnc_utils.h"
40 /* Default transparent print information. */
42 static const struct digi_t dgnc_digi_init
= {
43 .digi_flags
= DIGI_COOK
, /* Flags */
44 .digi_maxcps
= 100, /* Max CPS */
45 .digi_maxchar
= 50, /* Max chars in print queue */
46 .digi_bufsize
= 100, /* Printer buffer size */
47 .digi_onlen
= 4, /* size of printer on string */
48 .digi_offlen
= 4, /* size of printer off string */
49 .digi_onstr
= "\033[5i", /* ANSI printer on string ] */
50 .digi_offstr
= "\033[4i", /* ANSI printer off string ] */
51 .digi_term
= "ansi" /* default terminal type */
55 * Define a local default termios struct. All ports will be created
56 * with this termios initially.
58 * This defines a raw port at 9600 baud, 8 data bits, no parity,
61 static struct ktermios default_termios
= {
62 .c_iflag
= (DEFAULT_IFLAGS
), /* iflags */
63 .c_oflag
= (DEFAULT_OFLAGS
), /* oflags */
64 .c_cflag
= (DEFAULT_CFLAGS
), /* cflags */
65 .c_lflag
= (DEFAULT_LFLAGS
), /* lflags */
70 /* Our function prototypes */
71 static int dgnc_tty_open(struct tty_struct
*tty
, struct file
*file
);
72 static void dgnc_tty_close(struct tty_struct
*tty
, struct file
*file
);
73 static int dgnc_block_til_ready(struct tty_struct
*tty
, struct file
*file
,
74 struct channel_t
*ch
);
75 static int dgnc_tty_ioctl(struct tty_struct
*tty
, unsigned int cmd
,
77 static int dgnc_tty_digigeta(struct tty_struct
*tty
,
78 struct digi_t __user
*retinfo
);
79 static int dgnc_tty_digiseta(struct tty_struct
*tty
,
80 struct digi_t __user
*new_info
);
81 static int dgnc_tty_write_room(struct tty_struct
*tty
);
82 static int dgnc_tty_put_char(struct tty_struct
*tty
, unsigned char c
);
83 static int dgnc_tty_chars_in_buffer(struct tty_struct
*tty
);
84 static void dgnc_tty_start(struct tty_struct
*tty
);
85 static void dgnc_tty_stop(struct tty_struct
*tty
);
86 static void dgnc_tty_throttle(struct tty_struct
*tty
);
87 static void dgnc_tty_unthrottle(struct tty_struct
*tty
);
88 static void dgnc_tty_flush_chars(struct tty_struct
*tty
);
89 static void dgnc_tty_flush_buffer(struct tty_struct
*tty
);
90 static void dgnc_tty_hangup(struct tty_struct
*tty
);
91 static int dgnc_set_modem_info(struct channel_t
*ch
, unsigned int command
,
92 unsigned int __user
*value
);
93 static int dgnc_get_modem_info(struct channel_t
*ch
,
94 unsigned int __user
*value
);
95 static int dgnc_tty_tiocmget(struct tty_struct
*tty
);
96 static int dgnc_tty_tiocmset(struct tty_struct
*tty
, unsigned int set
,
98 static int dgnc_tty_send_break(struct tty_struct
*tty
, int msec
);
99 static void dgnc_tty_wait_until_sent(struct tty_struct
*tty
, int timeout
);
100 static int dgnc_tty_write(struct tty_struct
*tty
, const unsigned char *buf
,
102 static void dgnc_tty_set_termios(struct tty_struct
*tty
,
103 struct ktermios
*old_termios
);
104 static void dgnc_tty_send_xchar(struct tty_struct
*tty
, char ch
);
105 static void dgnc_set_signal_low(struct channel_t
*ch
, const unsigned char line
);
106 static void dgnc_wake_up_unit(struct un_t
*unit
);
108 static const struct tty_operations dgnc_tty_ops
= {
109 .open
= dgnc_tty_open
,
110 .close
= dgnc_tty_close
,
111 .write
= dgnc_tty_write
,
112 .write_room
= dgnc_tty_write_room
,
113 .flush_buffer
= dgnc_tty_flush_buffer
,
114 .chars_in_buffer
= dgnc_tty_chars_in_buffer
,
115 .flush_chars
= dgnc_tty_flush_chars
,
116 .ioctl
= dgnc_tty_ioctl
,
117 .set_termios
= dgnc_tty_set_termios
,
118 .stop
= dgnc_tty_stop
,
119 .start
= dgnc_tty_start
,
120 .throttle
= dgnc_tty_throttle
,
121 .unthrottle
= dgnc_tty_unthrottle
,
122 .hangup
= dgnc_tty_hangup
,
123 .put_char
= dgnc_tty_put_char
,
124 .tiocmget
= dgnc_tty_tiocmget
,
125 .tiocmset
= dgnc_tty_tiocmset
,
126 .break_ctl
= dgnc_tty_send_break
,
127 .wait_until_sent
= dgnc_tty_wait_until_sent
,
128 .send_xchar
= dgnc_tty_send_xchar
131 /* TTY Initialization/Cleanup Functions */
134 * dgnc_tty_register()
136 * Init the tty subsystem for this board.
138 int dgnc_tty_register(struct dgnc_board
*brd
)
142 brd
->serial_driver
= tty_alloc_driver(brd
->maxports
,
143 TTY_DRIVER_REAL_RAW
|
144 TTY_DRIVER_DYNAMIC_DEV
|
145 TTY_DRIVER_HARDWARE_BREAK
);
147 if (IS_ERR(brd
->serial_driver
))
148 return PTR_ERR(brd
->serial_driver
);
150 snprintf(brd
->serial_name
, MAXTTYNAMELEN
, "tty_dgnc_%d_",
153 brd
->serial_driver
->name
= brd
->serial_name
;
154 brd
->serial_driver
->name_base
= 0;
155 brd
->serial_driver
->major
= 0;
156 brd
->serial_driver
->minor_start
= 0;
157 brd
->serial_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
158 brd
->serial_driver
->subtype
= SERIAL_TYPE_NORMAL
;
159 brd
->serial_driver
->init_termios
= default_termios
;
160 brd
->serial_driver
->driver_name
= DRVSTR
;
163 * Entry points for driver. Called by the kernel from
164 * tty_io.c and n_tty.c.
166 tty_set_operations(brd
->serial_driver
, &dgnc_tty_ops
);
168 rc
= tty_register_driver(brd
->serial_driver
);
170 dev_dbg(&brd
->pdev
->dev
,
171 "Can't register tty device (%d)\n", rc
);
172 goto free_serial_driver
;
176 * If we're doing transparent print, we have to do all of the above
177 * again, separately so we don't get the LD confused about what major
178 * we are when we get into the dgnc_tty_open() routine.
180 brd
->print_driver
= tty_alloc_driver(brd
->maxports
,
181 TTY_DRIVER_REAL_RAW
|
182 TTY_DRIVER_DYNAMIC_DEV
|
183 TTY_DRIVER_HARDWARE_BREAK
);
185 if (IS_ERR(brd
->print_driver
)) {
186 rc
= PTR_ERR(brd
->print_driver
);
187 goto unregister_serial_driver
;
190 snprintf(brd
->print_name
, MAXTTYNAMELEN
, "pr_dgnc_%d_", brd
->boardnum
);
192 brd
->print_driver
->name
= brd
->print_name
;
193 brd
->print_driver
->name_base
= 0;
194 brd
->print_driver
->major
= brd
->serial_driver
->major
;
195 brd
->print_driver
->minor_start
= 0x80;
196 brd
->print_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
197 brd
->print_driver
->subtype
= SERIAL_TYPE_NORMAL
;
198 brd
->print_driver
->init_termios
= default_termios
;
199 brd
->print_driver
->driver_name
= DRVSTR
;
202 * Entry points for driver. Called by the kernel from
203 * tty_io.c and n_tty.c.
205 tty_set_operations(brd
->print_driver
, &dgnc_tty_ops
);
207 rc
= tty_register_driver(brd
->print_driver
);
209 dev_dbg(&brd
->pdev
->dev
,
210 "Can't register Transparent Print device(%d)\n",
212 goto free_print_driver
;
218 put_tty_driver(brd
->print_driver
);
219 unregister_serial_driver
:
220 tty_unregister_driver(brd
->serial_driver
);
222 put_tty_driver(brd
->serial_driver
);
227 void dgnc_tty_unregister(struct dgnc_board
*brd
)
229 tty_unregister_driver(brd
->print_driver
);
230 tty_unregister_driver(brd
->serial_driver
);
231 put_tty_driver(brd
->print_driver
);
232 put_tty_driver(brd
->serial_driver
);
238 * Init the tty subsystem. Called once per board after board has been
239 * downloaded and init'ed.
241 int dgnc_tty_init(struct dgnc_board
*brd
)
245 struct channel_t
*ch
;
250 /* Initialize board structure elements. */
252 vaddr
= brd
->re_map_membase
;
254 brd
->nasync
= brd
->maxports
;
256 for (i
= 0; i
< brd
->nasync
; i
++) {
258 * Okay to malloc with GFP_KERNEL, we are not at
259 * interrupt context, and there are no locks held.
261 brd
->channels
[i
] = kzalloc(sizeof(*brd
->channels
[i
]),
263 if (!brd
->channels
[i
])
264 goto err_free_channels
;
267 ch
= brd
->channels
[0];
268 vaddr
= brd
->re_map_membase
;
270 /* Set up channel variables */
271 for (i
= 0; i
< brd
->nasync
; i
++, ch
= brd
->channels
[i
]) {
272 spin_lock_init(&ch
->ch_lock
);
274 /* Store all our magic numbers */
275 ch
->magic
= DGNC_CHANNEL_MAGIC
;
276 ch
->ch_tun
.magic
= DGNC_UNIT_MAGIC
;
277 ch
->ch_tun
.un_ch
= ch
;
278 ch
->ch_tun
.un_type
= DGNC_SERIAL
;
279 ch
->ch_tun
.un_dev
= i
;
281 ch
->ch_pun
.magic
= DGNC_UNIT_MAGIC
;
282 ch
->ch_pun
.un_ch
= ch
;
283 ch
->ch_pun
.un_type
= DGNC_PRINT
;
284 ch
->ch_pun
.un_dev
= i
+ 128;
286 if (brd
->bd_uart_offset
== 0x200)
287 ch
->ch_neo_uart
= vaddr
+ (brd
->bd_uart_offset
* i
);
289 ch
->ch_cls_uart
= vaddr
+ (brd
->bd_uart_offset
* i
);
293 ch
->ch_digi
= dgnc_digi_init
;
295 /* .25 second delay */
296 ch
->ch_close_delay
= 250;
298 init_waitqueue_head(&ch
->ch_flags_wait
);
299 init_waitqueue_head(&ch
->ch_tun
.un_flags_wait
);
300 init_waitqueue_head(&ch
->ch_pun
.un_flags_wait
);
303 struct device
*classp
;
305 classp
= tty_register_device(brd
->serial_driver
, i
,
306 &ch
->ch_bd
->pdev
->dev
);
307 ch
->ch_tun
.un_sysfs
= classp
;
309 classp
= tty_register_device(brd
->print_driver
, i
,
310 &ch
->ch_bd
->pdev
->dev
);
311 ch
->ch_pun
.un_sysfs
= classp
;
318 for (i
= i
- 1; i
>= 0; --i
) {
319 kfree(brd
->channels
[i
]);
320 brd
->channels
[i
] = NULL
;
328 * Uninitialize the TTY portion of this driver. Free all memory and
331 void dgnc_cleanup_tty(struct dgnc_board
*brd
)
335 for (i
= 0; i
< brd
->nasync
; i
++)
336 tty_unregister_device(brd
->serial_driver
, i
);
338 tty_unregister_driver(brd
->serial_driver
);
340 for (i
= 0; i
< brd
->nasync
; i
++)
341 tty_unregister_device(brd
->print_driver
, i
);
343 tty_unregister_driver(brd
->print_driver
);
345 put_tty_driver(brd
->serial_driver
);
346 put_tty_driver(brd
->print_driver
);
350 * dgnc_wmove - Write data to transmit queue.
352 * ch - Pointer to channel structure.
353 * buf - Pointer to characters to be moved.
354 * n - Number of characters to move.
356 static void dgnc_wmove(struct channel_t
*ch
, char *buf
, uint n
)
361 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
364 head
= ch
->ch_w_head
& WQUEUEMASK
;
367 * If the write wraps over the top of the circular buffer,
368 * move the portion up to the wrap point, and reset the
369 * pointers to the bottom.
371 remain
= WQUEUESIZE
- head
;
375 memcpy(ch
->ch_wqueue
+ head
, buf
, remain
);
381 /* Move rest of data. */
383 memcpy(ch
->ch_wqueue
+ head
, buf
, remain
);
388 ch
->ch_w_head
= head
;
392 * dgnc_input - Process received data.
394 * ch - Pointer to channel structure.
396 void dgnc_input(struct channel_t
*ch
)
398 struct dgnc_board
*bd
;
399 struct tty_struct
*tp
;
400 struct tty_ldisc
*ld
= NULL
;
412 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
415 tp
= ch
->ch_tun
.un_tty
;
418 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
421 spin_lock_irqsave(&ch
->ch_lock
, flags
);
424 * Figure the number of characters in the buffer.
425 * Exit immediately if none.
428 head
= ch
->ch_r_head
& rmask
;
429 tail
= ch
->ch_r_tail
& rmask
;
430 data_len
= (head
- tail
) & rmask
;
436 * If the device is not open, or CREAD is off,
437 * flush input data and return immediately.
439 if (!tp
|| (tp
->magic
!= TTY_MAGIC
) ||
440 !(ch
->ch_tun
.un_flags
& UN_ISOPEN
) ||
442 (ch
->ch_tun
.un_flags
& UN_CLOSING
)) {
443 ch
->ch_r_head
= tail
;
445 /* Force queue flow control to be released, if needed */
446 dgnc_check_queue_flow_control(ch
);
451 /* If we are throttled, simply don't read any data. */
453 if (ch
->ch_flags
& CH_FORCED_STOPI
)
456 flip_len
= TTY_FLIPBUF_SIZE
;
458 /* Chop down the length, if needed */
459 len
= min(data_len
, flip_len
);
460 len
= min(len
, (N_TTY_BUF_SIZE
- 1));
462 ld
= tty_ldisc_ref(tp
);
465 * If we were unable to get a reference to the ld,
466 * don't flush our buffer, and act like the ld doesn't
467 * have any space to put the data right now.
473 * If ld doesn't have a pointer to a receive_buf function,
474 * flush the data, then act like the ld doesn't have any
475 * space to put the data right now.
477 if (!ld
->ops
->receive_buf
) {
478 ch
->ch_r_head
= ch
->ch_r_tail
;
487 * The tty layer in the kernel has changed in 2.6.16+.
489 * The flip buffers in the tty structure are no longer exposed,
490 * and probably will be going away eventually.
492 * If we are completely raw, we don't need to go through a lot
493 * of the tty layers that exist.
494 * In this case, we take the shortest and fastest route we
495 * can to relay the data to the user.
497 * On the other hand, if we are not raw, we need to go through
498 * the new 2.6.16+ tty layer, which has its API more well defined.
500 len
= tty_buffer_request_room(tp
->port
, len
);
504 * n now contains the most amount of data we can copy,
505 * bounded either by how much the Linux tty layer can handle,
506 * or the amount of data the card actually has pending...
509 unsigned char *ch_pos
= ch
->ch_equeue
+ tail
;
511 s
= ((head
>= tail
) ? head
: RQUEUESIZE
) - tail
;
518 * If conditions are such that ld needs to see all
519 * UART errors, we will have to walk each character
520 * and error byte and send them to the buffer one at
523 if (I_PARMRK(tp
) || I_BRKINT(tp
) || I_INPCK(tp
)) {
524 for (i
= 0; i
< s
; i
++) {
525 unsigned char ch
= *(ch_pos
+ i
);
526 char flag
= TTY_NORMAL
;
528 if (ch
& UART_LSR_BI
)
530 else if (ch
& UART_LSR_PE
)
532 else if (ch
& UART_LSR_FE
)
535 tty_insert_flip_char(tp
->port
, ch
, flag
);
538 tty_insert_flip_string(tp
->port
, ch_pos
, s
);
543 /* Flip queue if needed */
547 ch
->ch_r_tail
= tail
& rmask
;
548 ch
->ch_e_tail
= tail
& rmask
;
549 dgnc_check_queue_flow_control(ch
);
550 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
552 /* Tell the tty layer its okay to "eat" the data now */
553 tty_flip_buffer_push(tp
->port
);
560 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
566 * Determines when CARRIER changes state and takes appropriate
569 void dgnc_carrier(struct channel_t
*ch
)
571 int virt_carrier
= 0;
572 int phys_carrier
= 0;
574 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
577 if (ch
->ch_mistat
& UART_MSR_DCD
)
580 if (ch
->ch_digi
.digi_flags
& DIGI_FORCEDCD
)
583 if (ch
->ch_c_cflag
& CLOCAL
)
586 /* Test for a VIRTUAL carrier transition to HIGH. */
588 if (((ch
->ch_flags
& CH_FCAR
) == 0) && (virt_carrier
== 1)) {
590 * When carrier rises, wake any threads waiting
591 * for carrier in the open routine.
593 if (waitqueue_active(&ch
->ch_flags_wait
))
594 wake_up_interruptible(&ch
->ch_flags_wait
);
597 /* Test for a PHYSICAL carrier transition to HIGH. */
599 if (((ch
->ch_flags
& CH_CD
) == 0) && (phys_carrier
== 1)) {
601 * When carrier rises, wake any threads waiting
602 * for carrier in the open routine.
604 if (waitqueue_active(&ch
->ch_flags_wait
))
605 wake_up_interruptible(&ch
->ch_flags_wait
);
609 * Test for a PHYSICAL transition to low, so long as we aren't
610 * currently ignoring physical transitions (which is what "virtual
611 * carrier" indicates).
613 * The transition of the virtual carrier to low really doesn't
614 * matter... it really only means "ignore carrier state", not
615 * "make pretend that carrier is there".
617 if ((virt_carrier
== 0) && ((ch
->ch_flags
& CH_CD
) != 0) &&
618 (phys_carrier
== 0)) {
620 * When carrier drops:
622 * Drop carrier on all open units.
624 * Flush queues, waking up any task waiting in the
627 * Send a hangup to the control terminal.
629 * Enable all select calls.
631 if (waitqueue_active(&ch
->ch_flags_wait
))
632 wake_up_interruptible(&ch
->ch_flags_wait
);
634 if (ch
->ch_tun
.un_open_count
> 0)
635 tty_hangup(ch
->ch_tun
.un_tty
);
637 if (ch
->ch_pun
.un_open_count
> 0)
638 tty_hangup(ch
->ch_pun
.un_tty
);
641 /* Make sure that our cached values reflect the current reality. */
643 if (virt_carrier
== 1)
644 ch
->ch_flags
|= CH_FCAR
;
646 ch
->ch_flags
&= ~CH_FCAR
;
648 if (phys_carrier
== 1)
649 ch
->ch_flags
|= CH_CD
;
651 ch
->ch_flags
&= ~CH_CD
;
654 /* Assign the custom baud rate to the channel structure */
656 static void dgnc_set_custom_speed(struct channel_t
*ch
, uint newrate
)
665 ch
->ch_custom_speed
= 0;
670 * Since the divisor is stored in a 16-bit integer, we make sure
671 * we don't allow any rates smaller than a 16-bit integer would allow.
672 * And of course, rates above the dividend won't fly.
674 if (newrate
&& newrate
< ((ch
->ch_bd
->bd_dividend
/ 0xFFFF) + 1))
675 newrate
= (ch
->ch_bd
->bd_dividend
/ 0xFFFF) + 1;
677 if (newrate
&& newrate
> ch
->ch_bd
->bd_dividend
)
678 newrate
= ch
->ch_bd
->bd_dividend
;
681 testdiv
= ch
->ch_bd
->bd_dividend
/ newrate
;
684 * If we try to figure out what rate the board would use
685 * with the test divisor, it will be either equal or higher
686 * than the requested baud rate. If we then determine the
687 * rate with a divisor one higher, we will get the next lower
688 * supported rate below the requested.
690 testrate_high
= ch
->ch_bd
->bd_dividend
/ testdiv
;
691 testrate_low
= ch
->ch_bd
->bd_dividend
/ (testdiv
+ 1);
694 * If the rate for the requested divisor is correct, just
695 * use it and be done.
697 if (testrate_high
!= newrate
) {
699 * Otherwise, pick the rate that is closer
700 * (i.e. whichever rate has a smaller delta).
702 deltahigh
= testrate_high
- newrate
;
703 deltalow
= newrate
- testrate_low
;
705 if (deltahigh
< deltalow
)
706 newrate
= testrate_high
;
708 newrate
= testrate_low
;
712 ch
->ch_custom_speed
= newrate
;
715 void dgnc_check_queue_flow_control(struct channel_t
*ch
)
719 /* Store how much space we have left in the queue */
720 qleft
= ch
->ch_r_tail
- ch
->ch_r_head
- 1;
722 qleft
+= RQUEUEMASK
+ 1;
725 * Check to see if we should enforce flow control on our queue because
726 * the ld (or user) isn't reading data out of our queue fast enuf.
728 * NOTE: This is done based on what the current flow control of the
731 * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt.
732 * This will cause the UART's FIFO to back up, and force
733 * the RTS signal to be dropped.
734 * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to
735 * the other side, in hopes it will stop sending data to us.
736 * 3) NONE - Nothing we can do. We will simply drop any extra data
737 * that gets sent into us when the queue fills up.
741 if (ch
->ch_digi
.digi_flags
& CTSPACE
||
742 ch
->ch_c_cflag
& CRTSCTS
) {
743 if (!(ch
->ch_flags
& CH_RECEIVER_OFF
)) {
744 ch
->ch_bd
->bd_ops
->disable_receiver(ch
);
745 ch
->ch_flags
|= (CH_RECEIVER_OFF
);
749 else if (ch
->ch_c_iflag
& IXOFF
) {
750 if (ch
->ch_stops_sent
<= MAX_STOPS_SENT
) {
751 ch
->ch_bd
->bd_ops
->send_stop_character(ch
);
758 * Check to see if we should unenforce flow control because
759 * ld (or user) finally read enuf data out of our queue.
761 * NOTE: This is done based on what the current flow control of the
764 * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt.
765 * This will cause the UART's FIFO to raise RTS back up,
766 * which will allow the other side to start sending data again.
767 * 2) SWFLOW (IXOFF) - Send a start character to
768 * the other side, so it will start sending data to us again.
769 * 3) NONE - Do nothing. Since we didn't do anything to turn off the
770 * other side, we don't need to do anything now.
772 if (qleft
> (RQUEUESIZE
/ 2)) {
774 if (ch
->ch_digi
.digi_flags
& RTSPACE
||
775 ch
->ch_c_cflag
& CRTSCTS
) {
776 if (ch
->ch_flags
& CH_RECEIVER_OFF
) {
777 ch
->ch_bd
->bd_ops
->enable_receiver(ch
);
778 ch
->ch_flags
&= ~(CH_RECEIVER_OFF
);
782 else if (ch
->ch_c_iflag
& IXOFF
&& ch
->ch_stops_sent
) {
783 ch
->ch_stops_sent
= 0;
784 ch
->ch_bd
->bd_ops
->send_start_character(ch
);
789 static void dgnc_set_signal_low(struct channel_t
*ch
, const unsigned char sig
)
791 ch
->ch_mostat
&= ~(sig
);
792 ch
->ch_bd
->bd_ops
->assert_modem_signals(ch
);
795 void dgnc_wakeup_writes(struct channel_t
*ch
)
800 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
803 spin_lock_irqsave(&ch
->ch_lock
, flags
);
805 /* If channel now has space, wake up anyone waiting on the condition. */
807 qlen
= ch
->ch_w_head
- ch
->ch_w_tail
;
811 if (qlen
>= (WQUEUESIZE
- 256)) {
812 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
816 if (ch
->ch_tun
.un_flags
& UN_ISOPEN
) {
817 tty_wakeup(ch
->ch_tun
.un_tty
);
820 * If unit is set to wait until empty, check to make sure
821 * the queue AND FIFO are both empty.
823 if (ch
->ch_tun
.un_flags
& UN_EMPTY
) {
825 (ch
->ch_bd
->bd_ops
->get_uart_bytes_left(ch
) == 0)) {
826 ch
->ch_tun
.un_flags
&= ~(UN_EMPTY
);
829 * If RTS Toggle mode is on, whenever
830 * the queue and UART is empty, keep RTS low.
832 if (ch
->ch_digi
.digi_flags
& DIGI_RTS_TOGGLE
)
833 dgnc_set_signal_low(ch
, UART_MCR_RTS
);
836 * If DTR Toggle mode is on, whenever
837 * the queue and UART is empty, keep DTR low.
839 if (ch
->ch_digi
.digi_flags
& DIGI_DTR_TOGGLE
)
840 dgnc_set_signal_low(ch
, UART_MCR_DTR
);
844 wake_up_interruptible(&ch
->ch_tun
.un_flags_wait
);
847 if (ch
->ch_pun
.un_flags
& UN_ISOPEN
) {
848 tty_wakeup(ch
->ch_pun
.un_tty
);
851 * If unit is set to wait until empty, check to make sure
852 * the queue AND FIFO are both empty.
854 if (ch
->ch_pun
.un_flags
& UN_EMPTY
) {
856 (ch
->ch_bd
->bd_ops
->get_uart_bytes_left(ch
) == 0))
857 ch
->ch_pun
.un_flags
&= ~(UN_EMPTY
);
860 wake_up_interruptible(&ch
->ch_pun
.un_flags_wait
);
863 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
866 static struct dgnc_board
*find_board_by_major(unsigned int major
)
870 for (i
= 0; i
< MAXBOARDS
; i
++) {
871 struct dgnc_board
*brd
= dgnc_board
[i
];
876 if (major
== brd
->serial_driver
->major
||
877 major
== brd
->print_driver
->major
)
884 /* TTY Entry points and helper functions */
886 /* dgnc_tty_open() */
888 static int dgnc_tty_open(struct tty_struct
*tty
, struct file
*file
)
890 struct dgnc_board
*brd
;
891 struct channel_t
*ch
;
900 major
= MAJOR(tty_devnum(tty
));
901 minor
= MINOR(tty_devnum(tty
));
906 /* Get board pointer from our array of majors we have allocated */
907 brd
= find_board_by_major(major
);
912 * If board is not yet up to a state of READY, go to
913 * sleep waiting for it to happen or they cancel the open.
915 rc
= wait_event_interruptible(brd
->state_wait
,
916 (brd
->state
& BOARD_READY
));
921 spin_lock_irqsave(&brd
->bd_lock
, flags
);
923 /* If opened device is greater than our number of ports, bail. */
924 if (PORT_NUM(minor
) >= brd
->nasync
) {
925 spin_unlock_irqrestore(&brd
->bd_lock
, flags
);
929 ch
= brd
->channels
[PORT_NUM(minor
)];
931 spin_unlock_irqrestore(&brd
->bd_lock
, flags
);
935 /* Drop board lock */
936 spin_unlock_irqrestore(&brd
->bd_lock
, flags
);
938 /* Grab channel lock */
939 spin_lock_irqsave(&ch
->ch_lock
, flags
);
941 /* Figure out our type */
942 if (!IS_PRINT(minor
)) {
943 un
= &brd
->channels
[PORT_NUM(minor
)]->ch_tun
;
944 un
->un_type
= DGNC_SERIAL
;
945 } else if (IS_PRINT(minor
)) {
946 un
= &brd
->channels
[PORT_NUM(minor
)]->ch_pun
;
947 un
->un_type
= DGNC_PRINT
;
949 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
954 * If the port is still in a previous open, and in a state
955 * where we simply cannot safely keep going, wait until the
958 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
960 rc
= wait_event_interruptible(ch
->ch_flags_wait
,
961 ((ch
->ch_flags
& CH_OPENING
) == 0));
963 /* If ret is non-zero, user ctrl-c'ed us */
968 * If either unit is in the middle of the fragile part of close,
969 * we just cannot touch the channel safely.
970 * Go to sleep, knowing that when the channel can be
971 * touched safely, the close routine will signal the
972 * ch_flags_wait to wake us back up.
974 rc
= wait_event_interruptible(
976 (((ch
->ch_tun
.un_flags
|
977 ch
->ch_pun
.un_flags
) & UN_CLOSING
) == 0));
979 /* If ret is non-zero, user ctrl-c'ed us */
983 spin_lock_irqsave(&ch
->ch_lock
, flags
);
985 /* Store our unit into driver_data, so we always have it available. */
986 tty
->driver_data
= un
;
988 /* Initialize tty's */
990 if (!(un
->un_flags
& UN_ISOPEN
)) {
991 /* Store important variables. */
994 /* Maybe do something here to the TTY struct as well? */
998 * Allocate channel buffers for read/write/error.
999 * Set flag, so we don't get trounced on.
1001 ch
->ch_flags
|= (CH_OPENING
);
1003 /* Drop locks, as malloc with GFP_KERNEL can sleep */
1004 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1007 ch
->ch_rqueue
= kzalloc(RQUEUESIZE
, GFP_KERNEL
);
1009 ch
->ch_equeue
= kzalloc(EQUEUESIZE
, GFP_KERNEL
);
1011 ch
->ch_wqueue
= kzalloc(WQUEUESIZE
, GFP_KERNEL
);
1013 if (!ch
->ch_rqueue
|| !ch
->ch_equeue
|| !ch
->ch_wqueue
) {
1014 kfree(ch
->ch_rqueue
);
1015 kfree(ch
->ch_equeue
);
1016 kfree(ch
->ch_wqueue
);
1021 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1023 ch
->ch_flags
&= ~(CH_OPENING
);
1024 wake_up_interruptible(&ch
->ch_flags_wait
);
1026 /* Initialize if neither terminal or printer is open. */
1028 if (!((ch
->ch_tun
.un_flags
| ch
->ch_pun
.un_flags
) & UN_ISOPEN
)) {
1029 /* Flush input queues. */
1037 brd
->bd_ops
->flush_uart_write(ch
);
1038 brd
->bd_ops
->flush_uart_read(ch
);
1041 ch
->ch_cached_lsr
= 0;
1042 ch
->ch_stop_sending_break
= 0;
1043 ch
->ch_stops_sent
= 0;
1045 ch
->ch_c_cflag
= tty
->termios
.c_cflag
;
1046 ch
->ch_c_iflag
= tty
->termios
.c_iflag
;
1047 ch
->ch_c_oflag
= tty
->termios
.c_oflag
;
1048 ch
->ch_c_lflag
= tty
->termios
.c_lflag
;
1049 ch
->ch_startc
= tty
->termios
.c_cc
[VSTART
];
1050 ch
->ch_stopc
= tty
->termios
.c_cc
[VSTOP
];
1053 * Bring up RTS and DTR...
1054 * Also handle RTS or DTR toggle if set.
1056 if (!(ch
->ch_digi
.digi_flags
& DIGI_RTS_TOGGLE
))
1057 ch
->ch_mostat
|= (UART_MCR_RTS
);
1058 if (!(ch
->ch_digi
.digi_flags
& DIGI_DTR_TOGGLE
))
1059 ch
->ch_mostat
|= (UART_MCR_DTR
);
1061 /* Tell UART to init itself */
1062 brd
->bd_ops
->uart_init(ch
);
1065 /* Run param in case we changed anything */
1067 brd
->bd_ops
->param(tty
);
1071 /* follow protocol for opening port */
1073 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1075 rc
= dgnc_block_til_ready(tty
, file
, ch
);
1077 /* No going back now, increment our unit and channel counters */
1078 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1079 ch
->ch_open_count
++;
1080 un
->un_open_count
++;
1081 un
->un_flags
|= (UN_ISOPEN
);
1082 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1088 * dgnc_block_til_ready()
1090 * Wait for DCD, if needed.
1092 static int dgnc_block_til_ready(struct tty_struct
*tty
,
1094 struct channel_t
*ch
)
1097 struct un_t
*un
= tty
->driver_data
;
1098 unsigned long flags
;
1100 int sleep_on_un_flags
= 0;
1105 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1111 sleep_on_un_flags
= 0;
1114 * If board has failed somehow during our sleep,
1117 if (ch
->ch_bd
->state
== BOARD_FAILED
) {
1122 /* If tty was hung up, break out of loop and set error. */
1123 if (tty_hung_up_p(file
)) {
1129 * If either unit is in the middle of the fragile part of close,
1130 * we just cannot touch the channel safely.
1131 * Go back to sleep, knowing that when the channel can be
1132 * touched safely, the close routine will signal the
1133 * ch_wait_flags to wake us back up.
1135 if (!((ch
->ch_tun
.un_flags
|
1136 ch
->ch_pun
.un_flags
) &
1139 * Our conditions to leave cleanly and happily:
1140 * 1) NONBLOCKING on the tty is set.
1142 * 3) DCD (fake or real) is active.
1145 if (file
->f_flags
& O_NONBLOCK
)
1148 if (tty_io_error(tty
)) {
1153 if (ch
->ch_flags
& CH_CD
)
1156 if (ch
->ch_flags
& CH_FCAR
)
1159 sleep_on_un_flags
= 1;
1163 * If there is a signal pending, the user probably
1164 * interrupted (ctrl-c) us.
1165 * Leave loop with error set.
1167 if (signal_pending(current
)) {
1168 retval
= -ERESTARTSYS
;
1172 /* Store the flags before we let go of channel lock */
1174 if (sleep_on_un_flags
)
1175 old_flags
= ch
->ch_tun
.un_flags
| ch
->ch_pun
.un_flags
;
1177 old_flags
= ch
->ch_flags
;
1180 * Let go of channel lock before calling schedule.
1181 * Our poller will get any FEP events and wake us up when DCD
1182 * eventually goes active.
1185 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1188 * Wait for something in the flags to change
1189 * from the current value.
1191 if (sleep_on_un_flags
)
1192 retval
= wait_event_interruptible
1194 (old_flags
!= (ch
->ch_tun
.un_flags
|
1195 ch
->ch_pun
.un_flags
)));
1197 retval
= wait_event_interruptible(
1199 (old_flags
!= ch
->ch_flags
));
1202 * We got woken up for some reason.
1203 * Before looping around, grab our channel lock.
1205 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1210 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1218 * Hangup the port. Like a close, but don't wait for output to drain.
1220 static void dgnc_tty_hangup(struct tty_struct
*tty
)
1222 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1225 /* flush the transmit queues */
1226 dgnc_tty_flush_buffer(tty
);
1229 /* dgnc_tty_close() */
1231 static void dgnc_tty_close(struct tty_struct
*tty
, struct file
*file
)
1233 struct dgnc_board
*bd
;
1234 struct channel_t
*ch
;
1236 unsigned long flags
;
1238 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1241 un
= tty
->driver_data
;
1242 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1246 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1250 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
1253 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1256 * Determine if this is the last close or not - and if we agree about
1257 * which type of close it is with the Line Discipline
1259 if ((tty
->count
== 1) && (un
->un_open_count
!= 1)) {
1261 * Uh, oh. tty->count is 1, which means that the tty
1262 * structure will be freed. un_open_count should always
1263 * be one in these conditions. If it's greater than
1264 * one, we've got real problems, since it means the
1265 * serial port won't be shutdown.
1268 "tty->count is 1, un open count is %d\n",
1270 un
->un_open_count
= 1;
1273 if (un
->un_open_count
)
1274 un
->un_open_count
--;
1277 "bad serial port open count of %d\n",
1280 ch
->ch_open_count
--;
1282 if (ch
->ch_open_count
&& un
->un_open_count
) {
1283 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1287 /* OK, its the last close on the unit */
1288 un
->un_flags
|= UN_CLOSING
;
1293 * Only officially close channel if count is 0 and
1294 * DIGI_PRINTER bit is not set.
1296 if ((ch
->ch_open_count
== 0) &&
1297 !(ch
->ch_digi
.digi_flags
& DIGI_PRINTER
)) {
1298 ch
->ch_flags
&= ~(CH_STOPI
| CH_FORCED_STOPI
);
1300 /* turn off print device when closing print device. */
1302 if ((un
->un_type
== DGNC_PRINT
) && (ch
->ch_flags
& CH_PRON
)) {
1303 dgnc_wmove(ch
, ch
->ch_digi
.digi_offstr
,
1304 (int)ch
->ch_digi
.digi_offlen
);
1305 ch
->ch_flags
&= ~CH_PRON
;
1308 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1309 /* wait for output to drain */
1310 /* This will also return if we take an interrupt */
1312 bd
->bd_ops
->drain(tty
, 0);
1314 dgnc_tty_flush_buffer(tty
);
1315 tty_ldisc_flush(tty
);
1317 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1321 /* If we have HUPCL set, lower DTR and RTS */
1323 if (ch
->ch_c_cflag
& HUPCL
) {
1325 ch
->ch_mostat
&= ~(UART_MCR_DTR
| UART_MCR_RTS
);
1326 bd
->bd_ops
->assert_modem_signals(ch
);
1329 * Go to sleep to ensure RTS/DTR
1330 * have been dropped for modems to see it.
1332 if (ch
->ch_close_delay
) {
1333 spin_unlock_irqrestore(&ch
->ch_lock
,
1335 dgnc_ms_sleep(ch
->ch_close_delay
);
1336 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1340 ch
->ch_old_baud
= 0;
1342 /* Turn off UART interrupts for this port */
1343 ch
->ch_bd
->bd_ops
->uart_off(ch
);
1345 /* turn off print device when closing print device. */
1347 if ((un
->un_type
== DGNC_PRINT
) && (ch
->ch_flags
& CH_PRON
)) {
1348 dgnc_wmove(ch
, ch
->ch_digi
.digi_offstr
,
1349 (int)ch
->ch_digi
.digi_offlen
);
1350 ch
->ch_flags
&= ~CH_PRON
;
1355 un
->un_flags
&= ~(UN_ISOPEN
| UN_CLOSING
);
1357 wake_up_interruptible(&ch
->ch_flags_wait
);
1358 wake_up_interruptible(&un
->un_flags_wait
);
1360 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1364 * dgnc_tty_chars_in_buffer()
1366 * Return number of characters that have not been transmitted yet.
1368 * This routine is used by the line discipline to determine if there
1369 * is data waiting to be transmitted/drained/flushed or not.
1371 static int dgnc_tty_chars_in_buffer(struct tty_struct
*tty
)
1373 struct channel_t
*ch
= NULL
;
1374 struct un_t
*un
= NULL
;
1379 unsigned long flags
;
1384 un
= tty
->driver_data
;
1385 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1389 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1392 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1395 thead
= ch
->ch_w_head
& tmask
;
1396 ttail
= ch
->ch_w_tail
& tmask
;
1398 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1400 if (ttail
== thead
) {
1404 chars
= thead
- ttail
;
1406 chars
= thead
- ttail
+ WQUEUESIZE
;
1415 * Reduces bytes_available to the max number of characters
1416 * that can be sent currently given the maxcps value, and
1417 * returns the new bytes_available. This only affects printer
1420 static int dgnc_maxcps_room(struct channel_t
*ch
, int bytes_available
)
1422 if (ch
->ch_digi
.digi_maxcps
> 0 && ch
->ch_digi
.digi_bufsize
> 0) {
1424 unsigned long current_time
= jiffies
;
1425 unsigned long buffer_time
= current_time
+
1426 (HZ
* ch
->ch_digi
.digi_bufsize
) /
1427 ch
->ch_digi
.digi_maxcps
;
1429 if (ch
->ch_cpstime
< current_time
) {
1430 /* buffer is empty */
1431 ch
->ch_cpstime
= current_time
; /* reset ch_cpstime */
1432 cps_limit
= ch
->ch_digi
.digi_bufsize
;
1433 } else if (ch
->ch_cpstime
< buffer_time
) {
1434 /* still room in the buffer */
1435 cps_limit
= ((buffer_time
- ch
->ch_cpstime
) *
1436 ch
->ch_digi
.digi_maxcps
) / HZ
;
1438 /* no room in the buffer */
1442 bytes_available
= min(cps_limit
, bytes_available
);
1445 return bytes_available
;
1449 * dgnc_tty_write_room()
1451 * Return space available in Tx buffer
1453 static int dgnc_tty_write_room(struct tty_struct
*tty
)
1455 struct channel_t
*ch
= NULL
;
1456 struct un_t
*un
= NULL
;
1461 unsigned long flags
;
1466 un
= tty
->driver_data
;
1467 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1471 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1474 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1477 head
= (ch
->ch_w_head
) & tmask
;
1478 tail
= (ch
->ch_w_tail
) & tmask
;
1480 ret
= tail
- head
- 1;
1484 /* Limit printer to maxcps */
1485 if (un
->un_type
!= DGNC_PRINT
)
1486 ret
= dgnc_maxcps_room(ch
, ret
);
1489 * If we are printer device, leave space for
1490 * possibly both the on and off strings.
1492 if (un
->un_type
== DGNC_PRINT
) {
1493 if (!(ch
->ch_flags
& CH_PRON
))
1494 ret
-= ch
->ch_digi
.digi_onlen
;
1495 ret
-= ch
->ch_digi
.digi_offlen
;
1497 if (ch
->ch_flags
& CH_PRON
)
1498 ret
-= ch
->ch_digi
.digi_offlen
;
1504 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1510 * dgnc_tty_put_char()
1512 * Put a character into ch->ch_buf
1514 * - used by the line discipline for OPOST processing
1516 static int dgnc_tty_put_char(struct tty_struct
*tty
, unsigned char c
)
1518 /* Simply call tty_write. */
1520 dgnc_tty_write(tty
, &c
, 1);
1527 * Take data from the user or kernel and send it out to the FEP.
1528 * In here exists all the Transparent Print magic as well.
1530 static int dgnc_tty_write(struct tty_struct
*tty
,
1531 const unsigned char *buf
, int count
)
1533 struct channel_t
*ch
= NULL
;
1534 struct un_t
*un
= NULL
;
1535 int bufcount
= 0, n
= 0;
1536 unsigned long flags
;
1545 un
= tty
->driver_data
;
1546 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1550 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1557 * Store original amount of characters passed in.
1558 * This helps to figure out if we should ask the FEP
1559 * to send us an event when it has more space available.
1562 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1564 /* Get our space available for the channel from the board */
1566 head
= (ch
->ch_w_head
) & tmask
;
1567 tail
= (ch
->ch_w_tail
) & tmask
;
1569 bufcount
= tail
- head
- 1;
1571 bufcount
+= WQUEUESIZE
;
1574 * Limit printer output to maxcps overall, with bursts allowed
1575 * up to bufsize characters.
1577 if (un
->un_type
!= DGNC_PRINT
)
1578 bufcount
= dgnc_maxcps_room(ch
, bufcount
);
1581 * Take minimum of what the user wants to send, and the
1582 * space available in the FEP buffer.
1584 count
= min(count
, bufcount
);
1586 /* Bail if no space left. */
1592 * Output the printer ON string, if we are in terminal mode, but
1593 * need to be in printer mode.
1595 if ((un
->un_type
== DGNC_PRINT
) && !(ch
->ch_flags
& CH_PRON
)) {
1596 dgnc_wmove(ch
, ch
->ch_digi
.digi_onstr
,
1597 (int)ch
->ch_digi
.digi_onlen
);
1598 head
= (ch
->ch_w_head
) & tmask
;
1599 ch
->ch_flags
|= CH_PRON
;
1603 * On the other hand, output the printer OFF string, if we are
1604 * currently in printer mode, but need to output to the terminal.
1606 if ((un
->un_type
!= DGNC_PRINT
) && (ch
->ch_flags
& CH_PRON
)) {
1607 dgnc_wmove(ch
, ch
->ch_digi
.digi_offstr
,
1608 (int)ch
->ch_digi
.digi_offlen
);
1609 head
= (ch
->ch_w_head
) & tmask
;
1610 ch
->ch_flags
&= ~CH_PRON
;
1616 * If the write wraps over the top of the circular buffer,
1617 * move the portion up to the wrap point, and reset the
1618 * pointers to the bottom.
1620 remain
= WQUEUESIZE
- head
;
1624 memcpy(ch
->ch_wqueue
+ head
, buf
, remain
);
1630 /* Move rest of data. */
1632 memcpy(ch
->ch_wqueue
+ head
, buf
, remain
);
1638 ch
->ch_w_head
= head
;
1641 /* Update printer buffer empty time. */
1642 if ((un
->un_type
== DGNC_PRINT
) && (ch
->ch_digi
.digi_maxcps
> 0) &&
1643 (ch
->ch_digi
.digi_bufsize
> 0)) {
1644 ch
->ch_cpstime
+= (HZ
* count
) / ch
->ch_digi
.digi_maxcps
;
1647 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1651 * Channel lock is grabbed and then released
1652 * inside this routine.
1654 ch
->ch_bd
->bd_ops
->copy_data_from_queue_to_uart(ch
);
1661 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1665 /* Return modem signals to ld. */
1667 static int dgnc_tty_tiocmget(struct tty_struct
*tty
)
1669 struct channel_t
*ch
;
1672 unsigned char mstat
= 0;
1673 unsigned long flags
;
1675 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1678 un
= tty
->driver_data
;
1679 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1683 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1686 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1688 mstat
= ch
->ch_mostat
| ch
->ch_mistat
;
1690 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1694 if (mstat
& UART_MCR_DTR
)
1695 result
|= TIOCM_DTR
;
1696 if (mstat
& UART_MCR_RTS
)
1697 result
|= TIOCM_RTS
;
1698 if (mstat
& UART_MSR_CTS
)
1699 result
|= TIOCM_CTS
;
1700 if (mstat
& UART_MSR_DSR
)
1701 result
|= TIOCM_DSR
;
1702 if (mstat
& UART_MSR_RI
)
1704 if (mstat
& UART_MSR_DCD
)
1711 * dgnc_tty_tiocmset()
1713 * Set modem signals, called by ld.
1716 static int dgnc_tty_tiocmset(struct tty_struct
*tty
,
1717 unsigned int set
, unsigned int clear
)
1719 struct dgnc_board
*bd
;
1720 struct channel_t
*ch
;
1723 unsigned long flags
;
1725 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1728 un
= tty
->driver_data
;
1729 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1733 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1737 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
1740 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1742 if (set
& TIOCM_RTS
)
1743 ch
->ch_mostat
|= UART_MCR_RTS
;
1745 if (set
& TIOCM_DTR
)
1746 ch
->ch_mostat
|= UART_MCR_DTR
;
1748 if (clear
& TIOCM_RTS
)
1749 ch
->ch_mostat
&= ~(UART_MCR_RTS
);
1751 if (clear
& TIOCM_DTR
)
1752 ch
->ch_mostat
&= ~(UART_MCR_DTR
);
1754 ch
->ch_bd
->bd_ops
->assert_modem_signals(ch
);
1756 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1762 * dgnc_tty_send_break()
1764 * Send a Break, called by ld.
1766 static int dgnc_tty_send_break(struct tty_struct
*tty
, int msec
)
1768 struct dgnc_board
*bd
;
1769 struct channel_t
*ch
;
1772 unsigned long flags
;
1774 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1777 un
= tty
->driver_data
;
1778 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1782 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1786 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
1800 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1802 ch
->ch_bd
->bd_ops
->send_break(ch
, msec
);
1804 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1810 * dgnc_tty_wait_until_sent()
1812 * wait until data has been transmitted, called by ld.
1814 static void dgnc_tty_wait_until_sent(struct tty_struct
*tty
, int timeout
)
1816 struct dgnc_board
*bd
;
1817 struct channel_t
*ch
;
1820 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1823 un
= tty
->driver_data
;
1824 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1828 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1832 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
1835 bd
->bd_ops
->drain(tty
, 0);
1841 * send a high priority character, called by ld.
1843 static void dgnc_tty_send_xchar(struct tty_struct
*tty
, char c
)
1845 struct dgnc_board
*bd
;
1846 struct channel_t
*ch
;
1848 unsigned long flags
;
1850 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1853 un
= tty
->driver_data
;
1854 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
1858 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1862 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
1865 dev_dbg(tty
->dev
, "dgnc_tty_send_xchar start\n");
1867 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1868 bd
->bd_ops
->send_immediate_char(ch
, c
);
1869 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1871 dev_dbg(tty
->dev
, "dgnc_tty_send_xchar finish\n");
1874 /* Return modem signals to ld. */
1876 static inline int dgnc_get_mstat(struct channel_t
*ch
)
1878 unsigned char mstat
;
1880 unsigned long flags
;
1882 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
1885 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1887 mstat
= ch
->ch_mostat
| ch
->ch_mistat
;
1889 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1891 if (mstat
& UART_MCR_DTR
)
1892 result
|= TIOCM_DTR
;
1893 if (mstat
& UART_MCR_RTS
)
1894 result
|= TIOCM_RTS
;
1895 if (mstat
& UART_MSR_CTS
)
1896 result
|= TIOCM_CTS
;
1897 if (mstat
& UART_MSR_DSR
)
1898 result
|= TIOCM_DSR
;
1899 if (mstat
& UART_MSR_RI
)
1901 if (mstat
& UART_MSR_DCD
)
1907 /* Return modem signals to ld. */
1909 static int dgnc_get_modem_info(struct channel_t
*ch
,
1910 unsigned int __user
*value
)
1912 return put_user(dgnc_get_mstat(ch
), value
);
1916 * dgnc_set_modem_info()
1918 * Set modem signals, called by ld.
1920 static int dgnc_set_modem_info(struct channel_t
*ch
,
1921 unsigned int command
,
1922 unsigned int __user
*value
)
1925 unsigned int arg
= 0;
1926 unsigned long flags
;
1928 ret
= get_user(arg
, value
);
1934 if (arg
& TIOCM_RTS
)
1935 ch
->ch_mostat
|= UART_MCR_RTS
;
1937 if (arg
& TIOCM_DTR
)
1938 ch
->ch_mostat
|= UART_MCR_DTR
;
1943 if (arg
& TIOCM_RTS
)
1944 ch
->ch_mostat
&= ~(UART_MCR_RTS
);
1946 if (arg
& TIOCM_DTR
)
1947 ch
->ch_mostat
&= ~(UART_MCR_DTR
);
1953 if (arg
& TIOCM_RTS
)
1954 ch
->ch_mostat
|= UART_MCR_RTS
;
1956 ch
->ch_mostat
&= ~(UART_MCR_RTS
);
1958 if (arg
& TIOCM_DTR
)
1959 ch
->ch_mostat
|= UART_MCR_DTR
;
1961 ch
->ch_mostat
&= ~(UART_MCR_DTR
);
1969 spin_lock_irqsave(&ch
->ch_lock
, flags
);
1971 ch
->ch_bd
->bd_ops
->assert_modem_signals(ch
);
1973 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
1979 * dgnc_tty_digigeta()
1981 * Ioctl to get the information for ditty.
1983 static int dgnc_tty_digigeta(struct tty_struct
*tty
,
1984 struct digi_t __user
*retinfo
)
1986 struct channel_t
*ch
;
1989 unsigned long flags
;
1994 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
1997 un
= tty
->driver_data
;
1998 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2002 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2005 memset(&tmp
, 0, sizeof(tmp
));
2007 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2008 memcpy(&tmp
, &ch
->ch_digi
, sizeof(tmp
));
2009 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2011 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
2018 * dgnc_tty_digiseta()
2020 * Ioctl to set the information for ditty.
2022 static int dgnc_tty_digiseta(struct tty_struct
*tty
,
2023 struct digi_t __user
*new_info
)
2025 struct dgnc_board
*bd
;
2026 struct channel_t
*ch
;
2028 struct digi_t new_digi
;
2029 unsigned long flags
;
2031 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2034 un
= tty
->driver_data
;
2035 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2039 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2043 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2046 if (copy_from_user(&new_digi
, new_info
, sizeof(new_digi
)))
2049 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2051 /* Handle transitions to and from RTS Toggle. */
2053 if (!(ch
->ch_digi
.digi_flags
& DIGI_RTS_TOGGLE
) &&
2054 (new_digi
.digi_flags
& DIGI_RTS_TOGGLE
))
2055 ch
->ch_mostat
&= ~(UART_MCR_RTS
);
2056 if ((ch
->ch_digi
.digi_flags
& DIGI_RTS_TOGGLE
) &&
2057 !(new_digi
.digi_flags
& DIGI_RTS_TOGGLE
))
2058 ch
->ch_mostat
|= (UART_MCR_RTS
);
2060 /* Handle transitions to and from DTR Toggle. */
2062 if (!(ch
->ch_digi
.digi_flags
& DIGI_DTR_TOGGLE
) &&
2063 (new_digi
.digi_flags
& DIGI_DTR_TOGGLE
))
2064 ch
->ch_mostat
&= ~(UART_MCR_DTR
);
2065 if ((ch
->ch_digi
.digi_flags
& DIGI_DTR_TOGGLE
) &&
2066 !(new_digi
.digi_flags
& DIGI_DTR_TOGGLE
))
2067 ch
->ch_mostat
|= (UART_MCR_DTR
);
2069 memcpy(&ch
->ch_digi
, &new_digi
, sizeof(new_digi
));
2071 if (ch
->ch_digi
.digi_maxcps
< 1)
2072 ch
->ch_digi
.digi_maxcps
= 1;
2074 if (ch
->ch_digi
.digi_maxcps
> 10000)
2075 ch
->ch_digi
.digi_maxcps
= 10000;
2077 if (ch
->ch_digi
.digi_bufsize
< 10)
2078 ch
->ch_digi
.digi_bufsize
= 10;
2080 if (ch
->ch_digi
.digi_maxchar
< 1)
2081 ch
->ch_digi
.digi_maxchar
= 1;
2083 if (ch
->ch_digi
.digi_maxchar
> ch
->ch_digi
.digi_bufsize
)
2084 ch
->ch_digi
.digi_maxchar
= ch
->ch_digi
.digi_bufsize
;
2086 if (ch
->ch_digi
.digi_onlen
> DIGI_PLEN
)
2087 ch
->ch_digi
.digi_onlen
= DIGI_PLEN
;
2089 if (ch
->ch_digi
.digi_offlen
> DIGI_PLEN
)
2090 ch
->ch_digi
.digi_offlen
= DIGI_PLEN
;
2092 ch
->ch_bd
->bd_ops
->param(tty
);
2094 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2099 /* dgnc_set_termios() */
2101 static void dgnc_tty_set_termios(struct tty_struct
*tty
,
2102 struct ktermios
*old_termios
)
2104 struct dgnc_board
*bd
;
2105 struct channel_t
*ch
;
2107 unsigned long flags
;
2109 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2112 un
= tty
->driver_data
;
2113 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2117 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2121 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2124 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2126 ch
->ch_c_cflag
= tty
->termios
.c_cflag
;
2127 ch
->ch_c_iflag
= tty
->termios
.c_iflag
;
2128 ch
->ch_c_oflag
= tty
->termios
.c_oflag
;
2129 ch
->ch_c_lflag
= tty
->termios
.c_lflag
;
2130 ch
->ch_startc
= tty
->termios
.c_cc
[VSTART
];
2131 ch
->ch_stopc
= tty
->termios
.c_cc
[VSTOP
];
2133 ch
->ch_bd
->bd_ops
->param(tty
);
2136 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2139 static void dgnc_tty_throttle(struct tty_struct
*tty
)
2141 struct channel_t
*ch
;
2143 unsigned long flags
;
2145 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2148 un
= tty
->driver_data
;
2149 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2153 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2156 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2158 ch
->ch_flags
|= (CH_FORCED_STOPI
);
2160 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2163 static void dgnc_tty_unthrottle(struct tty_struct
*tty
)
2165 struct channel_t
*ch
;
2167 unsigned long flags
;
2169 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2172 un
= tty
->driver_data
;
2173 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2177 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2180 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2182 ch
->ch_flags
&= ~(CH_FORCED_STOPI
);
2184 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2187 static void dgnc_tty_start(struct tty_struct
*tty
)
2189 struct dgnc_board
*bd
;
2190 struct channel_t
*ch
;
2192 unsigned long flags
;
2194 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2197 un
= tty
->driver_data
;
2198 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2202 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2206 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2209 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2211 ch
->ch_flags
&= ~(CH_FORCED_STOP
);
2213 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2216 static void dgnc_tty_stop(struct tty_struct
*tty
)
2218 struct dgnc_board
*bd
;
2219 struct channel_t
*ch
;
2221 unsigned long flags
;
2223 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2226 un
= tty
->driver_data
;
2227 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2231 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2235 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2238 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2240 ch
->ch_flags
|= (CH_FORCED_STOP
);
2242 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2246 * dgnc_tty_flush_chars()
2248 * Flush the cook buffer
2250 * Note to self, and any other poor souls who venture here:
2252 * flush in this case DOES NOT mean dispose of the data.
2253 * instead, it means "stop buffering and send it if you
2254 * haven't already." Just guess how I figured that out... SRW 2-Jun-98
2256 * It is also always called in interrupt context - JAR 8-Sept-99
2258 static void dgnc_tty_flush_chars(struct tty_struct
*tty
)
2260 struct dgnc_board
*bd
;
2261 struct channel_t
*ch
;
2263 unsigned long flags
;
2265 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2268 un
= tty
->driver_data
;
2269 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2273 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2277 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2280 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2282 /* Do something maybe here */
2284 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2288 * dgnc_tty_flush_buffer()
2290 * Flush Tx buffer (make in == out)
2292 static void dgnc_tty_flush_buffer(struct tty_struct
*tty
)
2294 struct channel_t
*ch
;
2296 unsigned long flags
;
2298 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2301 un
= tty
->driver_data
;
2302 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2306 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2309 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2311 ch
->ch_flags
&= ~CH_STOP
;
2313 /* Flush our write queue */
2314 ch
->ch_w_head
= ch
->ch_w_tail
;
2316 /* Flush UARTs transmit FIFO */
2317 ch
->ch_bd
->bd_ops
->flush_uart_write(ch
);
2319 if (ch
->ch_tun
.un_flags
& (UN_LOW
| UN_EMPTY
)) {
2320 ch
->ch_tun
.un_flags
&= ~(UN_LOW
| UN_EMPTY
);
2321 wake_up_interruptible(&ch
->ch_tun
.un_flags_wait
);
2323 if (ch
->ch_pun
.un_flags
& (UN_LOW
| UN_EMPTY
)) {
2324 ch
->ch_pun
.un_flags
&= ~(UN_LOW
| UN_EMPTY
);
2325 wake_up_interruptible(&ch
->ch_pun
.un_flags_wait
);
2328 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2332 * dgnc_wake_up_unit()
2334 * Wakes up processes waiting in the unit's (teminal/printer) wait queue
2336 static void dgnc_wake_up_unit(struct un_t
*unit
)
2338 unit
->un_flags
&= ~(UN_LOW
| UN_EMPTY
);
2339 wake_up_interruptible(&unit
->un_flags_wait
);
2342 /* The IOCTL function and all of its helpers */
2347 * The usual assortment of ioctl's
2349 static int dgnc_tty_ioctl(struct tty_struct
*tty
, unsigned int cmd
,
2352 struct dgnc_board
*bd
;
2353 struct board_ops
*ch_bd_ops
;
2354 struct channel_t
*ch
;
2357 unsigned long flags
;
2358 void __user
*uarg
= (void __user
*)arg
;
2360 if (!tty
|| tty
->magic
!= TTY_MAGIC
)
2363 un
= tty
->driver_data
;
2364 if (!un
|| un
->magic
!= DGNC_UNIT_MAGIC
)
2368 if (!ch
|| ch
->magic
!= DGNC_CHANNEL_MAGIC
)
2372 if (!bd
|| bd
->magic
!= DGNC_BOARD_MAGIC
)
2375 ch_bd_ops
= bd
->bd_ops
;
2377 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2379 if (un
->un_open_count
<= 0) {
2380 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2385 /* Here are all the standard ioctl's that we MUST implement */
2389 * TCSBRK is SVID version: non-zero arg --> no break
2390 * this behaviour is exploited by tcdrain().
2392 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2393 * between 0.25 and 0.5 seconds so we'll ask for something
2394 * in the middle: 0.375 seconds.
2396 rc
= tty_check_change(tty
);
2397 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2401 rc
= ch_bd_ops
->drain(tty
, 0);
2406 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2408 if (((cmd
== TCSBRK
) && (!arg
)) || (cmd
== TCSBRKP
))
2409 ch_bd_ops
->send_break(ch
, 250);
2411 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2417 * support for POSIX tcsendbreak()
2418 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2419 * between 0.25 and 0.5 seconds so we'll ask for something
2420 * in the middle: 0.375 seconds.
2422 rc
= tty_check_change(tty
);
2423 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2427 rc
= ch_bd_ops
->drain(tty
, 0);
2431 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2433 ch_bd_ops
->send_break(ch
, 250);
2435 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2440 rc
= tty_check_change(tty
);
2441 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2445 rc
= ch_bd_ops
->drain(tty
, 0);
2449 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2451 ch_bd_ops
->send_break(ch
, 250);
2453 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2459 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2464 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2466 return put_user(C_CLOCAL(tty
) ? 1 : 0,
2467 (unsigned long __user
*)arg
);
2471 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2472 rc
= get_user(arg
, (unsigned long __user
*)arg
);
2476 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2477 tty
->termios
.c_cflag
= ((tty
->termios
.c_cflag
& ~CLOCAL
) |
2478 (arg
? CLOCAL
: 0));
2479 ch_bd_ops
->param(tty
);
2480 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2485 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2486 return dgnc_get_modem_info(ch
, uarg
);
2491 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2492 return dgnc_set_modem_info(ch
, cmd
, uarg
);
2494 /* Here are any additional ioctl's that we want to implement */
2498 * The linux tty driver doesn't have a flush
2499 * input routine for the driver, assuming all backed
2500 * up data is in the line disc. buffers. However,
2501 * we all know that's not the case. Here, we
2502 * act on the ioctl, but then lie and say we didn't
2503 * so the line discipline will process the flush
2506 rc
= tty_check_change(tty
);
2508 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2512 if ((arg
== TCIFLUSH
) || (arg
== TCIOFLUSH
)) {
2513 ch
->ch_r_head
= ch
->ch_r_tail
;
2514 ch_bd_ops
->flush_uart_read(ch
);
2515 /* Force queue flow control to be released, if needed */
2516 dgnc_check_queue_flow_control(ch
);
2519 if ((arg
== TCOFLUSH
) || (arg
== TCIOFLUSH
)) {
2520 if (!(un
->un_type
== DGNC_PRINT
)) {
2521 ch
->ch_w_head
= ch
->ch_w_tail
;
2522 ch_bd_ops
->flush_uart_write(ch
);
2524 if (ch
->ch_tun
.un_flags
& (UN_LOW
| UN_EMPTY
))
2525 dgnc_wake_up_unit(&ch
->ch_tun
);
2527 if (ch
->ch_pun
.un_flags
& (UN_LOW
| UN_EMPTY
))
2528 dgnc_wake_up_unit(&ch
->ch_pun
);
2532 /* pretend we didn't recognize this IOCTL */
2533 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2534 return -ENOIOCTLCMD
;
2538 * The linux tty driver doesn't have a flush
2539 * input routine for the driver, assuming all backed
2540 * up data is in the line disc. buffers. However,
2541 * we all know that's not the case. Here, we
2542 * act on the ioctl, but then lie and say we didn't
2543 * so the line discipline will process the flush
2546 if (cmd
== TCSETSF
) {
2548 ch
->ch_flags
&= ~CH_STOP
;
2549 ch
->ch_r_head
= ch
->ch_r_tail
;
2550 ch_bd_ops
->flush_uart_read(ch
);
2551 /* Force queue flow control to be released, if needed */
2552 dgnc_check_queue_flow_control(ch
);
2555 /* now wait for all the output to drain */
2556 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2557 rc
= ch_bd_ops
->drain(tty
, 0);
2561 /* pretend we didn't recognize this */
2562 return -ENOIOCTLCMD
;
2566 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2567 rc
= ch_bd_ops
->drain(tty
, 0);
2571 /* pretend we didn't recognize this */
2572 return -ENOIOCTLCMD
;
2575 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2576 /* Make the ld do it */
2577 return -ENOIOCTLCMD
;
2580 /* get information for ditty */
2581 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2582 return dgnc_tty_digigeta(tty
, uarg
);
2587 /* set information for ditty */
2588 if (cmd
== (DIGI_SETAW
)) {
2589 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2590 rc
= ch_bd_ops
->drain(tty
, 0);
2595 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2597 tty_ldisc_flush(tty
);
2602 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2603 return dgnc_tty_digiseta(tty
, uarg
);
2609 * Let go of locks when accessing user space,
2612 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2613 rc
= get_user(loopback
, (unsigned int __user
*)arg
);
2616 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2618 /* Enable/disable internal loopback for this port */
2620 ch
->ch_flags
|= CH_LOOPBACK
;
2622 ch
->ch_flags
&= ~(CH_LOOPBACK
);
2624 ch_bd_ops
->param(tty
);
2625 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2629 case DIGI_GETCUSTOMBAUD
:
2630 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2631 return put_user(ch
->ch_custom_speed
,
2632 (unsigned int __user
*)arg
);
2634 case DIGI_SETCUSTOMBAUD
:
2637 /* Let go of locks when accessing user space, could sleep */
2638 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2639 rc
= get_user(new_rate
, (int __user
*)arg
);
2642 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2643 dgnc_set_custom_speed(ch
, new_rate
);
2644 ch_bd_ops
->param(tty
);
2645 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2650 * This ioctl allows insertion of a character into the front
2651 * of any pending data to be transmitted.
2653 * This ioctl is to satisfy the "Send Character Immediate"
2654 * call that the RealPort protocol spec requires.
2656 case DIGI_REALPORT_SENDIMMEDIATE
:
2660 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2661 rc
= get_user(c
, (unsigned char __user
*)arg
);
2664 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2665 ch_bd_ops
->send_immediate_char(ch
, c
);
2666 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2671 * This ioctl returns all the current counts for the port.
2673 * This ioctl is to satisfy the "Line Error Counters"
2674 * call that the RealPort protocol spec requires.
2676 case DIGI_REALPORT_GETCOUNTERS
:
2678 struct digi_getcounter buf
;
2680 buf
.norun
= ch
->ch_err_overrun
;
2681 buf
.noflow
= 0; /* The driver doesn't keep this stat */
2682 buf
.nframe
= ch
->ch_err_frame
;
2683 buf
.nparity
= ch
->ch_err_parity
;
2684 buf
.nbreak
= ch
->ch_err_break
;
2685 buf
.rbytes
= ch
->ch_rxcount
;
2686 buf
.tbytes
= ch
->ch_txcount
;
2688 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2690 if (copy_to_user(uarg
, &buf
, sizeof(buf
)))
2697 * This ioctl returns all current events.
2699 * This ioctl is to satisfy the "Event Reporting"
2700 * call that the RealPort protocol spec requires.
2702 case DIGI_REALPORT_GETEVENTS
:
2704 unsigned int events
= 0;
2706 /* NOTE: MORE EVENTS NEEDS TO BE ADDED HERE */
2707 if (ch
->ch_flags
& CH_BREAK_SENDING
)
2709 if ((ch
->ch_flags
& CH_STOP
) ||
2710 (ch
->ch_flags
& CH_FORCED_STOP
))
2711 events
|= (EV_OPU
| EV_OPS
);
2713 if ((ch
->ch_flags
& CH_STOPI
) ||
2714 (ch
->ch_flags
& CH_FORCED_STOPI
))
2715 events
|= (EV_IPU
| EV_IPS
);
2717 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2718 return put_user(events
, (unsigned int __user
*)arg
);
2722 * This ioctl returns TOUT and TIN counters based
2723 * upon the values passed in by the RealPort Server.
2724 * It also passes back whether the UART Transmitter is
2727 case DIGI_REALPORT_GETBUFFERS
:
2729 struct digi_getbuffer buf
;
2733 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2735 /* Get data from user first. */
2737 if (copy_from_user(&buf
, uarg
, sizeof(buf
)))
2740 spin_lock_irqsave(&ch
->ch_lock
, flags
);
2742 /* Figure out how much data is in our RX and TX queues. */
2744 buf
.rxbuf
= (ch
->ch_r_head
- ch
->ch_r_tail
) & RQUEUEMASK
;
2745 buf
.txbuf
= (ch
->ch_w_head
- ch
->ch_w_tail
) & WQUEUEMASK
;
2748 * Is the UART empty?
2749 * Add that value to whats in our TX queue.
2752 count
= buf
.txbuf
+ ch_bd_ops
->get_uart_bytes_left(ch
);
2755 * Figure out how much data the RealPort Server believes should
2756 * be in our TX queue.
2758 tdist
= (buf
.tx_in
- buf
.tx_out
) & 0xffff;
2761 * If we have more data than the RealPort Server believes we
2762 * should have, reduce our count to its amount.
2764 * This count difference CAN happen because the Linux LD can
2765 * insert more characters into our queue for OPOST processing
2766 * that the RealPort Server doesn't know about.
2768 if (buf
.txbuf
> tdist
)
2771 /* Report whether our queue and UART TX are completely empty. */
2778 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2780 if (copy_to_user(uarg
, &buf
, sizeof(buf
)))
2786 spin_unlock_irqrestore(&ch
->ch_lock
, flags
);
2788 return -ENOIOCTLCMD
;