1 /*
2 * Copyright 2003 Digi International (www.digi.com)
3 * Scott H Kilau <Scott_Kilau at digi dot com>
4 *
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)
8 * any later version.
9 *
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.
14 */
15
16 /************************************************************************
17 *
18 * This file implements the tty driver functionality for the
19 * Neo and ClassicBoard PCI based product lines.
20 *
21 ************************************************************************
22 *
23 */
24
25 #include <linux/kernel.h>
26 #include <linux/sched.h> /* For jiffies, task states */
27 #include <linux/interrupt.h> /* For tasklet and interrupt structs/defines */
28 #include <linux/module.h>
29 #include <linux/ctype.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/types.h>
33 #include <linux/serial_reg.h>
34 #include <linux/slab.h>
35 #include <linux/delay.h> /* For udelay */
36 #include <linux/uaccess.h> /* For copy_from_user/copy_to_user */
37 #include <linux/pci.h>
38 #include "dgnc_driver.h"
39 #include "dgnc_tty.h"
40 #include "dgnc_neo.h"
41 #include "dgnc_cls.h"
42 #include "dgnc_sysfs.h"
43 #include "dgnc_utils.h"
44
45 /*
46 * internal variables
47 */
48 static struct dgnc_board *dgnc_BoardsByMajor[256];
49 static unsigned char *dgnc_TmpWriteBuf;
50
51 /*
52 * Default transparent print information.
53 */
54 static struct digi_t dgnc_digi_init = {
55 .digi_flags = DIGI_COOK, /* Flags */
56 .digi_maxcps = 100, /* Max CPS */
57 .digi_maxchar = 50, /* Max chars in print queue */
58 .digi_bufsize = 100, /* Printer buffer size */
59 .digi_onlen = 4, /* size of printer on string */
60 .digi_offlen = 4, /* size of printer off string */
61 .digi_onstr = "\033[5i", /* ANSI printer on string ] */
62 .digi_offstr = "\033[4i", /* ANSI printer off string ] */
63 .digi_term = "ansi" /* default terminal type */
64 };
65
66 /*
67 * Define a local default termios struct. All ports will be created
68 * with this termios initially.
69 *
70 * This defines a raw port at 9600 baud, 8 data bits, no parity,
71 * 1 stop bit.
72 */
73 static struct ktermios DgncDefaultTermios = {
74 .c_iflag = (DEFAULT_IFLAGS), /* iflags */
75 .c_oflag = (DEFAULT_OFLAGS), /* oflags */
76 .c_cflag = (DEFAULT_CFLAGS), /* cflags */
77 .c_lflag = (DEFAULT_LFLAGS), /* lflags */
78 .c_cc = INIT_C_CC,
79 .c_line = 0,
80 };
81
82 /* Our function prototypes */
83 static int dgnc_tty_open(struct tty_struct *tty, struct file *file);
84 static void dgnc_tty_close(struct tty_struct *tty, struct file *file);
85 static int dgnc_block_til_ready(struct tty_struct *tty, struct file *file,
86 struct channel_t *ch);
87 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
88 unsigned long arg);
89 static int dgnc_tty_digigeta(struct tty_struct *tty,
90 struct digi_t __user *retinfo);
91 static int dgnc_tty_digiseta(struct tty_struct *tty,
92 struct digi_t __user *new_info);
93 static int dgnc_tty_write_room(struct tty_struct *tty);
94 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c);
95 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty);
96 static void dgnc_tty_start(struct tty_struct *tty);
97 static void dgnc_tty_stop(struct tty_struct *tty);
98 static void dgnc_tty_throttle(struct tty_struct *tty);
99 static void dgnc_tty_unthrottle(struct tty_struct *tty);
100 static void dgnc_tty_flush_chars(struct tty_struct *tty);
101 static void dgnc_tty_flush_buffer(struct tty_struct *tty);
102 static void dgnc_tty_hangup(struct tty_struct *tty);
103 static int dgnc_set_modem_info(struct tty_struct *tty, unsigned int command,
104 unsigned int __user *value);
105 static int dgnc_get_modem_info(struct channel_t *ch,
106 unsigned int __user *value);
107 static int dgnc_tty_tiocmget(struct tty_struct *tty);
108 static int dgnc_tty_tiocmset(struct tty_struct *tty, unsigned int set,
109 unsigned int clear);
110 static int dgnc_tty_send_break(struct tty_struct *tty, int msec);
111 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout);
112 static int dgnc_tty_write(struct tty_struct *tty, const unsigned char *buf,
113 int count);
114 static void dgnc_tty_set_termios(struct tty_struct *tty,
115 struct ktermios *old_termios);
116 static void dgnc_tty_send_xchar(struct tty_struct *tty, char ch);
117
118 static const struct tty_operations dgnc_tty_ops = {
119 .open = dgnc_tty_open,
120 .close = dgnc_tty_close,
121 .write = dgnc_tty_write,
122 .write_room = dgnc_tty_write_room,
123 .flush_buffer = dgnc_tty_flush_buffer,
124 .chars_in_buffer = dgnc_tty_chars_in_buffer,
125 .flush_chars = dgnc_tty_flush_chars,
126 .ioctl = dgnc_tty_ioctl,
127 .set_termios = dgnc_tty_set_termios,
128 .stop = dgnc_tty_stop,
129 .start = dgnc_tty_start,
130 .throttle = dgnc_tty_throttle,
131 .unthrottle = dgnc_tty_unthrottle,
132 .hangup = dgnc_tty_hangup,
133 .put_char = dgnc_tty_put_char,
134 .tiocmget = dgnc_tty_tiocmget,
135 .tiocmset = dgnc_tty_tiocmset,
136 .break_ctl = dgnc_tty_send_break,
137 .wait_until_sent = dgnc_tty_wait_until_sent,
138 .send_xchar = dgnc_tty_send_xchar
139 };
140
141 /************************************************************************
142 *
143 * TTY Initialization/Cleanup Functions
144 *
145 ************************************************************************/
146
147 /*
148 * dgnc_tty_preinit()
149 *
150 * Initialize any global tty related data before we download any boards.
151 */
dgnc_tty_preinit(void)152 int dgnc_tty_preinit(void)
153 {
154 /*
155 * Allocate a buffer for doing the copy from user space to
156 * kernel space in dgnc_write(). We only use one buffer and
157 * control access to it with a semaphore. If we are paging, we
158 * are already in trouble so one buffer won't hurt much anyway.
159 *
160 * We are okay to sleep in the malloc, as this routine
161 * is only called during module load, (not in interrupt context),
162 * and with no locks held.
163 */
164 dgnc_TmpWriteBuf = kmalloc(WRITEBUFLEN, GFP_KERNEL);
165
166 if (!dgnc_TmpWriteBuf)
167 return -ENOMEM;
168
169 return 0;
170 }
171
172 /*
173 * dgnc_tty_register()
174 *
175 * Init the tty subsystem for this board.
176 */
dgnc_tty_register(struct dgnc_board * brd)177 int dgnc_tty_register(struct dgnc_board *brd)
178 {
179 int rc = 0;
180
181 brd->SerialDriver.magic = TTY_DRIVER_MAGIC;
182
183 snprintf(brd->SerialName, MAXTTYNAMELEN, "tty_dgnc_%d_", brd->boardnum);
184
185 brd->SerialDriver.name = brd->SerialName;
186 brd->SerialDriver.name_base = 0;
187 brd->SerialDriver.major = 0;
188 brd->SerialDriver.minor_start = 0;
189 brd->SerialDriver.num = brd->maxports;
190 brd->SerialDriver.type = TTY_DRIVER_TYPE_SERIAL;
191 brd->SerialDriver.subtype = SERIAL_TYPE_NORMAL;
192 brd->SerialDriver.init_termios = DgncDefaultTermios;
193 brd->SerialDriver.driver_name = DRVSTR;
194 brd->SerialDriver.flags = (TTY_DRIVER_REAL_RAW |
195 TTY_DRIVER_DYNAMIC_DEV |
196 TTY_DRIVER_HARDWARE_BREAK);
197
198 /*
199 * The kernel wants space to store pointers to
200 * tty_struct's and termios's.
201 */
202 brd->SerialDriver.ttys = kcalloc(brd->maxports,
203 sizeof(*brd->SerialDriver.ttys),
204 GFP_KERNEL);
205 if (!brd->SerialDriver.ttys)
206 return -ENOMEM;
207
208 kref_init(&brd->SerialDriver.kref);
209 brd->SerialDriver.termios = kcalloc(brd->maxports,
210 sizeof(*brd->SerialDriver.termios),
211 GFP_KERNEL);
212 if (!brd->SerialDriver.termios)
213 return -ENOMEM;
214
215 /*
216 * Entry points for driver. Called by the kernel from
217 * tty_io.c and n_tty.c.
218 */
219 tty_set_operations(&brd->SerialDriver, &dgnc_tty_ops);
220
221 if (!brd->dgnc_Major_Serial_Registered) {
222 /* Register tty devices */
223 rc = tty_register_driver(&brd->SerialDriver);
224 if (rc < 0) {
225 dev_dbg(&brd->pdev->dev,
226 "Can't register tty device (%d)\n", rc);
227 return rc;
228 }
229 brd->dgnc_Major_Serial_Registered = true;
230 }
231
232 /*
233 * If we're doing transparent print, we have to do all of the above
234 * again, separately so we don't get the LD confused about what major
235 * we are when we get into the dgnc_tty_open() routine.
236 */
237 brd->PrintDriver.magic = TTY_DRIVER_MAGIC;
238 snprintf(brd->PrintName, MAXTTYNAMELEN, "pr_dgnc_%d_", brd->boardnum);
239
240 brd->PrintDriver.name = brd->PrintName;
241 brd->PrintDriver.name_base = 0;
242 brd->PrintDriver.major = brd->SerialDriver.major;
243 brd->PrintDriver.minor_start = 0x80;
244 brd->PrintDriver.num = brd->maxports;
245 brd->PrintDriver.type = TTY_DRIVER_TYPE_SERIAL;
246 brd->PrintDriver.subtype = SERIAL_TYPE_NORMAL;
247 brd->PrintDriver.init_termios = DgncDefaultTermios;
248 brd->PrintDriver.driver_name = DRVSTR;
249 brd->PrintDriver.flags = (TTY_DRIVER_REAL_RAW |
250 TTY_DRIVER_DYNAMIC_DEV |
251 TTY_DRIVER_HARDWARE_BREAK);
252
253 /*
254 * The kernel wants space to store pointers to
255 * tty_struct's and termios's. Must be separated from
256 * the Serial Driver so we don't get confused
257 */
258 brd->PrintDriver.ttys = kcalloc(brd->maxports,
259 sizeof(*brd->PrintDriver.ttys),
260 GFP_KERNEL);
261 if (!brd->PrintDriver.ttys)
262 return -ENOMEM;
263 kref_init(&brd->PrintDriver.kref);
264 brd->PrintDriver.termios = kcalloc(brd->maxports,
265 sizeof(*brd->PrintDriver.termios),
266 GFP_KERNEL);
267 if (!brd->PrintDriver.termios)
268 return -ENOMEM;
269
270 /*
271 * Entry points for driver. Called by the kernel from
272 * tty_io.c and n_tty.c.
273 */
274 tty_set_operations(&brd->PrintDriver, &dgnc_tty_ops);
275
276 if (!brd->dgnc_Major_TransparentPrint_Registered) {
277 /* Register Transparent Print devices */
278 rc = tty_register_driver(&brd->PrintDriver);
279 if (rc < 0) {
280 dev_dbg(&brd->pdev->dev,
281 "Can't register Transparent Print device(%d)\n",
282 rc);
283 return rc;
284 }
285 brd->dgnc_Major_TransparentPrint_Registered = true;
286 }
287
288 dgnc_BoardsByMajor[brd->SerialDriver.major] = brd;
289 brd->dgnc_Serial_Major = brd->SerialDriver.major;
290 brd->dgnc_TransparentPrint_Major = brd->PrintDriver.major;
291
292 return rc;
293 }
294
295 /*
296 * dgnc_tty_init()
297 *
298 * Init the tty subsystem. Called once per board after board has been
299 * downloaded and init'ed.
300 */
dgnc_tty_init(struct dgnc_board * brd)301 int dgnc_tty_init(struct dgnc_board *brd)
302 {
303 int i;
304 void __iomem *vaddr;
305 struct channel_t *ch;
306
307 if (!brd)
308 return -ENXIO;
309
310 /*
311 * Initialize board structure elements.
312 */
313
314 vaddr = brd->re_map_membase;
315
316 brd->nasync = brd->maxports;
317
318 for (i = 0; i < brd->nasync; i++) {
319 /*
320 * Okay to malloc with GFP_KERNEL, we are not at
321 * interrupt context, and there are no locks held.
322 */
323 brd->channels[i] = kzalloc(sizeof(*brd->channels[i]),
324 GFP_KERNEL);
325 if (!brd->channels[i])
326 goto err_free_channels;
327 }
328
329 ch = brd->channels[0];
330 vaddr = brd->re_map_membase;
331
332 /* Set up channel variables */
333 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
334 spin_lock_init(&ch->ch_lock);
335
336 /* Store all our magic numbers */
337 ch->magic = DGNC_CHANNEL_MAGIC;
338 ch->ch_tun.magic = DGNC_UNIT_MAGIC;
339 ch->ch_tun.un_ch = ch;
340 ch->ch_tun.un_type = DGNC_SERIAL;
341 ch->ch_tun.un_dev = i;
342
343 ch->ch_pun.magic = DGNC_UNIT_MAGIC;
344 ch->ch_pun.un_ch = ch;
345 ch->ch_pun.un_type = DGNC_PRINT;
346 ch->ch_pun.un_dev = i + 128;
347
348 if (brd->bd_uart_offset == 0x200)
349 ch->ch_neo_uart = vaddr + (brd->bd_uart_offset * i);
350 else
351 ch->ch_cls_uart = vaddr + (brd->bd_uart_offset * i);
352
353 ch->ch_bd = brd;
354 ch->ch_portnum = i;
355 ch->ch_digi = dgnc_digi_init;
356
357 /* .25 second delay */
358 ch->ch_close_delay = 250;
359
360 init_waitqueue_head(&ch->ch_flags_wait);
361 init_waitqueue_head(&ch->ch_tun.un_flags_wait);
362 init_waitqueue_head(&ch->ch_pun.un_flags_wait);
363
364 {
365 struct device *classp;
366
367 classp = tty_register_device(&brd->SerialDriver, i,
368 &ch->ch_bd->pdev->dev);
369 ch->ch_tun.un_sysfs = classp;
370 dgnc_create_tty_sysfs(&ch->ch_tun, classp);
371
372 classp = tty_register_device(&brd->PrintDriver, i,
373 &ch->ch_bd->pdev->dev);
374 ch->ch_pun.un_sysfs = classp;
375 dgnc_create_tty_sysfs(&ch->ch_pun, classp);
376 }
377 }
378
379 return 0;
380
381 err_free_channels:
382 for (i = i - 1; i >= 0; --i) {
383 kfree(brd->channels[i]);
384 brd->channels[i] = NULL;
385 }
386 return -ENOMEM;
387 }
388
389 /*
390 * dgnc_tty_post_uninit()
391 *
392 * UnInitialize any global tty related data.
393 */
dgnc_tty_post_uninit(void)394 void dgnc_tty_post_uninit(void)
395 {
396 kfree(dgnc_TmpWriteBuf);
397 dgnc_TmpWriteBuf = NULL;
398 }
399
400 /*
401 * dgnc_tty_uninit()
402 *
403 * Uninitialize the TTY portion of this driver. Free all memory and
404 * resources.
405 */
dgnc_tty_uninit(struct dgnc_board * brd)406 void dgnc_tty_uninit(struct dgnc_board *brd)
407 {
408 int i = 0;
409
410 if (brd->dgnc_Major_Serial_Registered) {
411 dgnc_BoardsByMajor[brd->SerialDriver.major] = NULL;
412 brd->dgnc_Serial_Major = 0;
413 for (i = 0; i < brd->nasync; i++) {
414 if (brd->channels[i])
415 dgnc_remove_tty_sysfs(brd->channels[i]->
416 ch_tun.un_sysfs);
417 tty_unregister_device(&brd->SerialDriver, i);
418 }
419 tty_unregister_driver(&brd->SerialDriver);
420 brd->dgnc_Major_Serial_Registered = false;
421 }
422
423 if (brd->dgnc_Major_TransparentPrint_Registered) {
424 dgnc_BoardsByMajor[brd->PrintDriver.major] = NULL;
425 brd->dgnc_TransparentPrint_Major = 0;
426 for (i = 0; i < brd->nasync; i++) {
427 if (brd->channels[i])
428 dgnc_remove_tty_sysfs(brd->channels[i]->
429 ch_pun.un_sysfs);
430 tty_unregister_device(&brd->PrintDriver, i);
431 }
432 tty_unregister_driver(&brd->PrintDriver);
433 brd->dgnc_Major_TransparentPrint_Registered = false;
434 }
435
436 kfree(brd->SerialDriver.ttys);
437 brd->SerialDriver.ttys = NULL;
438 kfree(brd->SerialDriver.termios);
439 brd->SerialDriver.termios = NULL;
440 kfree(brd->PrintDriver.ttys);
441 brd->PrintDriver.ttys = NULL;
442 kfree(brd->PrintDriver.termios);
443 brd->PrintDriver.termios = NULL;
444 }
445
446 /*=======================================================================
447 *
448 * dgnc_wmove - Write data to transmit queue.
449 *
450 * ch - Pointer to channel structure.
451 * buf - Poiter to characters to be moved.
452 * n - Number of characters to move.
453 *
454 *=======================================================================*/
dgnc_wmove(struct channel_t * ch,char * buf,uint n)455 static void dgnc_wmove(struct channel_t *ch, char *buf, uint n)
456 {
457 int remain;
458 uint head;
459
460 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
461 return;
462
463 head = ch->ch_w_head & WQUEUEMASK;
464
465 /*
466 * If the write wraps over the top of the circular buffer,
467 * move the portion up to the wrap point, and reset the
468 * pointers to the bottom.
469 */
470 remain = WQUEUESIZE - head;
471
472 if (n >= remain) {
473 n -= remain;
474 memcpy(ch->ch_wqueue + head, buf, remain);
475 head = 0;
476 buf += remain;
477 }
478
479 if (n > 0) {
480 /*
481 * Move rest of data.
482 */
483 remain = n;
484 memcpy(ch->ch_wqueue + head, buf, remain);
485 head += remain;
486 }
487
488 head &= WQUEUEMASK;
489 ch->ch_w_head = head;
490 }
491
492 /*=======================================================================
493 *
494 * dgnc_input - Process received data.
495 *
496 * ch - Pointer to channel structure.
497 *
498 *=======================================================================*/
dgnc_input(struct channel_t * ch)499 void dgnc_input(struct channel_t *ch)
500 {
501 struct dgnc_board *bd;
502 struct tty_struct *tp;
503 struct tty_ldisc *ld = NULL;
504 uint rmask;
505 ushort head;
506 ushort tail;
507 int data_len;
508 unsigned long flags;
509 int flip_len;
510 int len = 0;
511 int n = 0;
512 int s = 0;
513 int i = 0;
514
515 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
516 return;
517
518 tp = ch->ch_tun.un_tty;
519
520 bd = ch->ch_bd;
521 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
522 return;
523
524 spin_lock_irqsave(&ch->ch_lock, flags);
525
526 /*
527 * Figure the number of characters in the buffer.
528 * Exit immediately if none.
529 */
530 rmask = RQUEUEMASK;
531 head = ch->ch_r_head & rmask;
532 tail = ch->ch_r_tail & rmask;
533 data_len = (head - tail) & rmask;
534
535 if (data_len == 0)
536 goto exit_unlock;
537
538 /*
539 * If the device is not open, or CREAD is off,
540 * flush input data and return immediately.
541 */
542 if (!tp || (tp->magic != TTY_MAGIC) ||
543 !(ch->ch_tun.un_flags & UN_ISOPEN) ||
544 !(tp->termios.c_cflag & CREAD) ||
545 (ch->ch_tun.un_flags & UN_CLOSING)) {
546 ch->ch_r_head = tail;
547
548 /* Force queue flow control to be released, if needed */
549 dgnc_check_queue_flow_control(ch);
550
551 goto exit_unlock;
552 }
553
554 /*
555 * If we are throttled, simply don't read any data.
556 */
557 if (ch->ch_flags & CH_FORCED_STOPI)
558 goto exit_unlock;
559
560 flip_len = TTY_FLIPBUF_SIZE;
561
562 /* Chop down the length, if needed */
563 len = min(data_len, flip_len);
564 len = min(len, (N_TTY_BUF_SIZE - 1));
565
566 ld = tty_ldisc_ref(tp);
567
568 /*
569 * If we were unable to get a reference to the ld,
570 * don't flush our buffer, and act like the ld doesn't
571 * have any space to put the data right now.
572 */
573 if (!ld) {
574 len = 0;
575 } else {
576 /*
577 * If ld doesn't have a pointer to a receive_buf function,
578 * flush the data, then act like the ld doesn't have any
579 * space to put the data right now.
580 */
581 if (!ld->ops->receive_buf) {
582 ch->ch_r_head = ch->ch_r_tail;
583 len = 0;
584 }
585 }
586
587 if (len <= 0)
588 goto exit_unlock;
589
590 /*
591 * The tty layer in the kernel has changed in 2.6.16+.
592 *
593 * The flip buffers in the tty structure are no longer exposed,
594 * and probably will be going away eventually.
595 *
596 * If we are completely raw, we don't need to go through a lot
597 * of the tty layers that exist.
598 * In this case, we take the shortest and fastest route we
599 * can to relay the data to the user.
600 *
601 * On the other hand, if we are not raw, we need to go through
602 * the new 2.6.16+ tty layer, which has its API more well defined.
603 */
604 len = tty_buffer_request_room(tp->port, len);
605 n = len;
606
607 /*
608 * n now contains the most amount of data we can copy,
609 * bounded either by how much the Linux tty layer can handle,
610 * or the amount of data the card actually has pending...
611 */
612 while (n) {
613 s = ((head >= tail) ? head : RQUEUESIZE) - tail;
614 s = min(s, n);
615
616 if (s <= 0)
617 break;
618
619 /*
620 * If conditions are such that ld needs to see all
621 * UART errors, we will have to walk each character
622 * and error byte and send them to the buffer one at
623 * a time.
624 */
625 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
626 for (i = 0; i < s; i++) {
627 if (*(ch->ch_equeue + tail + i) & UART_LSR_BI)
628 tty_insert_flip_char(tp->port,
629 *(ch->ch_rqueue + tail + i),
630 TTY_BREAK);
631 else if (*(ch->ch_equeue + tail + i) &
632 UART_LSR_PE)
633 tty_insert_flip_char(tp->port,
634 *(ch->ch_rqueue + tail + i),
635 TTY_PARITY);
636 else if (*(ch->ch_equeue + tail + i) &
637 UART_LSR_FE)
638 tty_insert_flip_char(tp->port,
639 *(ch->ch_rqueue + tail + i),
640 TTY_FRAME);
641 else
642 tty_insert_flip_char(tp->port,
643 *(ch->ch_rqueue + tail + i),
644 TTY_NORMAL);
645 }
646 } else {
647 tty_insert_flip_string(tp->port,
648 ch->ch_rqueue + tail,
649 s);
650 }
651
652 tail += s;
653 n -= s;
654 /* Flip queue if needed */
655 tail &= rmask;
656 }
657
658 ch->ch_r_tail = tail & rmask;
659 ch->ch_e_tail = tail & rmask;
660 dgnc_check_queue_flow_control(ch);
661 spin_unlock_irqrestore(&ch->ch_lock, flags);
662
663 /* Tell the tty layer its okay to "eat" the data now */
664 tty_flip_buffer_push(tp->port);
665
666 if (ld)
667 tty_ldisc_deref(ld);
668 return;
669
670 exit_unlock:
671 spin_unlock_irqrestore(&ch->ch_lock, flags);
672 if (ld)
673 tty_ldisc_deref(ld);
674 }
675
676 /************************************************************************
677 * Determines when CARRIER changes state and takes appropriate
678 * action.
679 ************************************************************************/
dgnc_carrier(struct channel_t * ch)680 void dgnc_carrier(struct channel_t *ch)
681 {
682 struct dgnc_board *bd;
683
684 int virt_carrier = 0;
685 int phys_carrier = 0;
686
687 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
688 return;
689
690 bd = ch->ch_bd;
691
692 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
693 return;
694
695 if (ch->ch_mistat & UART_MSR_DCD)
696 phys_carrier = 1;
697
698 if (ch->ch_digi.digi_flags & DIGI_FORCEDCD)
699 virt_carrier = 1;
700
701 if (ch->ch_c_cflag & CLOCAL)
702 virt_carrier = 1;
703
704 /*
705 * Test for a VIRTUAL carrier transition to HIGH.
706 */
707 if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) {
708 /*
709 * When carrier rises, wake any threads waiting
710 * for carrier in the open routine.
711 */
712
713 if (waitqueue_active(&ch->ch_flags_wait))
714 wake_up_interruptible(&ch->ch_flags_wait);
715 }
716
717 /*
718 * Test for a PHYSICAL carrier transition to HIGH.
719 */
720 if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) {
721 /*
722 * When carrier rises, wake any threads waiting
723 * for carrier in the open routine.
724 */
725
726 if (waitqueue_active(&ch->ch_flags_wait))
727 wake_up_interruptible(&ch->ch_flags_wait);
728 }
729
730 /*
731 * Test for a PHYSICAL transition to low, so long as we aren't
732 * currently ignoring physical transitions (which is what "virtual
733 * carrier" indicates).
734 *
735 * The transition of the virtual carrier to low really doesn't
736 * matter... it really only means "ignore carrier state", not
737 * "make pretend that carrier is there".
738 */
739 if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0) &&
740 (phys_carrier == 0)) {
741 /*
742 * When carrier drops:
743 *
744 * Drop carrier on all open units.
745 *
746 * Flush queues, waking up any task waiting in the
747 * line discipline.
748 *
749 * Send a hangup to the control terminal.
750 *
751 * Enable all select calls.
752 */
753 if (waitqueue_active(&ch->ch_flags_wait))
754 wake_up_interruptible(&ch->ch_flags_wait);
755
756 if (ch->ch_tun.un_open_count > 0)
757 tty_hangup(ch->ch_tun.un_tty);
758
759 if (ch->ch_pun.un_open_count > 0)
760 tty_hangup(ch->ch_pun.un_tty);
761 }
762
763 /*
764 * Make sure that our cached values reflect the current reality.
765 */
766 if (virt_carrier == 1)
767 ch->ch_flags |= CH_FCAR;
768 else
769 ch->ch_flags &= ~CH_FCAR;
770
771 if (phys_carrier == 1)
772 ch->ch_flags |= CH_CD;
773 else
774 ch->ch_flags &= ~CH_CD;
775 }
776
777 /*
778 * Assign the custom baud rate to the channel structure
779 */
dgnc_set_custom_speed(struct channel_t * ch,uint newrate)780 static void dgnc_set_custom_speed(struct channel_t *ch, uint newrate)
781 {
782 int testdiv;
783 int testrate_high;
784 int testrate_low;
785 int deltahigh;
786 int deltalow;
787
788 if (newrate <= 0) {
789 ch->ch_custom_speed = 0;
790 return;
791 }
792
793 /*
794 * Since the divisor is stored in a 16-bit integer, we make sure
795 * we don't allow any rates smaller than a 16-bit integer would allow.
796 * And of course, rates above the dividend won't fly.
797 */
798 if (newrate && newrate < ((ch->ch_bd->bd_dividend / 0xFFFF) + 1))
799 newrate = ((ch->ch_bd->bd_dividend / 0xFFFF) + 1);
800
801 if (newrate && newrate > ch->ch_bd->bd_dividend)
802 newrate = ch->ch_bd->bd_dividend;
803
804 if (newrate > 0) {
805 testdiv = ch->ch_bd->bd_dividend / newrate;
806
807 /*
808 * If we try to figure out what rate the board would use
809 * with the test divisor, it will be either equal or higher
810 * than the requested baud rate. If we then determine the
811 * rate with a divisor one higher, we will get the next lower
812 * supported rate below the requested.
813 */
814 testrate_high = ch->ch_bd->bd_dividend / testdiv;
815 testrate_low = ch->ch_bd->bd_dividend / (testdiv + 1);
816
817 /*
818 * If the rate for the requested divisor is correct, just
819 * use it and be done.
820 */
821 if (testrate_high != newrate) {
822 /*
823 * Otherwise, pick the rate that is closer
824 * (i.e. whichever rate has a smaller delta).
825 */
826 deltahigh = testrate_high - newrate;
827 deltalow = newrate - testrate_low;
828
829 if (deltahigh < deltalow)
830 newrate = testrate_high;
831 else
832 newrate = testrate_low;
833 }
834 }
835
836 ch->ch_custom_speed = newrate;
837 }
838
dgnc_check_queue_flow_control(struct channel_t * ch)839 void dgnc_check_queue_flow_control(struct channel_t *ch)
840 {
841 int qleft;
842
843 /* Store how much space we have left in the queue */
844 qleft = ch->ch_r_tail - ch->ch_r_head - 1;
845 if (qleft < 0)
846 qleft += RQUEUEMASK + 1;
847
848 /*
849 * Check to see if we should enforce flow control on our queue because
850 * the ld (or user) isn't reading data out of our queue fast enuf.
851 *
852 * NOTE: This is done based on what the current flow control of the
853 * port is set for.
854 *
855 * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt.
856 * This will cause the UART's FIFO to back up, and force
857 * the RTS signal to be dropped.
858 * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to
859 * the other side, in hopes it will stop sending data to us.
860 * 3) NONE - Nothing we can do. We will simply drop any extra data
861 * that gets sent into us when the queue fills up.
862 */
863 if (qleft < 256) {
864 /* HWFLOW */
865 if (ch->ch_digi.digi_flags & CTSPACE ||
866 ch->ch_c_cflag & CRTSCTS) {
867 if (!(ch->ch_flags & CH_RECEIVER_OFF)) {
868 ch->ch_bd->bd_ops->disable_receiver(ch);
869 ch->ch_flags |= (CH_RECEIVER_OFF);
870 }
871 }
872 /* SWFLOW */
873 else if (ch->ch_c_iflag & IXOFF) {
874 if (ch->ch_stops_sent <= MAX_STOPS_SENT) {
875 ch->ch_bd->bd_ops->send_stop_character(ch);
876 ch->ch_stops_sent++;
877 }
878 }
879 }
880
881 /*
882 * Check to see if we should unenforce flow control because
883 * ld (or user) finally read enuf data out of our queue.
884 *
885 * NOTE: This is done based on what the current flow control of the
886 * port is set for.
887 *
888 * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt.
889 * This will cause the UART's FIFO to raise RTS back up,
890 * which will allow the other side to start sending data again.
891 * 2) SWFLOW (IXOFF) - Send a start character to
892 * the other side, so it will start sending data to us again.
893 * 3) NONE - Do nothing. Since we didn't do anything to turn off the
894 * other side, we don't need to do anything now.
895 */
896 if (qleft > (RQUEUESIZE / 2)) {
897 /* HWFLOW */
898 if (ch->ch_digi.digi_flags & RTSPACE ||
899 ch->ch_c_cflag & CRTSCTS) {
900 if (ch->ch_flags & CH_RECEIVER_OFF) {
901 ch->ch_bd->bd_ops->enable_receiver(ch);
902 ch->ch_flags &= ~(CH_RECEIVER_OFF);
903 }
904 }
905 /* SWFLOW */
906 else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) {
907 ch->ch_stops_sent = 0;
908 ch->ch_bd->bd_ops->send_start_character(ch);
909 }
910 }
911 }
912
dgnc_wakeup_writes(struct channel_t * ch)913 void dgnc_wakeup_writes(struct channel_t *ch)
914 {
915 int qlen = 0;
916 unsigned long flags;
917
918 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
919 return;
920
921 spin_lock_irqsave(&ch->ch_lock, flags);
922
923 /*
924 * If channel now has space, wake up anyone waiting on the condition.
925 */
926 qlen = ch->ch_w_head - ch->ch_w_tail;
927 if (qlen < 0)
928 qlen += WQUEUESIZE;
929
930 if (qlen >= (WQUEUESIZE - 256)) {
931 spin_unlock_irqrestore(&ch->ch_lock, flags);
932 return;
933 }
934
935 if (ch->ch_tun.un_flags & UN_ISOPEN) {
936 if ((ch->ch_tun.un_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
937 ch->ch_tun.un_tty->ldisc->ops->write_wakeup) {
938 spin_unlock_irqrestore(&ch->ch_lock, flags);
939 ch->ch_tun.un_tty->ldisc->ops->write_wakeup(ch->ch_tun.un_tty);
940 spin_lock_irqsave(&ch->ch_lock, flags);
941 }
942
943 wake_up_interruptible(&ch->ch_tun.un_tty->write_wait);
944
945 /*
946 * If unit is set to wait until empty, check to make sure
947 * the queue AND FIFO are both empty.
948 */
949 if (ch->ch_tun.un_flags & UN_EMPTY) {
950 if ((qlen == 0) &&
951 (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0)) {
952 ch->ch_tun.un_flags &= ~(UN_EMPTY);
953
954 /*
955 * If RTS Toggle mode is on, whenever
956 * the queue and UART is empty, keep RTS low.
957 */
958 if (ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) {
959 ch->ch_mostat &= ~(UART_MCR_RTS);
960 ch->ch_bd->bd_ops->assert_modem_signals(ch);
961 }
962
963 /*
964 * If DTR Toggle mode is on, whenever
965 * the queue and UART is empty, keep DTR low.
966 */
967 if (ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) {
968 ch->ch_mostat &= ~(UART_MCR_DTR);
969 ch->ch_bd->bd_ops->assert_modem_signals(ch);
970 }
971 }
972 }
973
974 wake_up_interruptible(&ch->ch_tun.un_flags_wait);
975 }
976
977 if (ch->ch_pun.un_flags & UN_ISOPEN) {
978 if ((ch->ch_pun.un_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
979 ch->ch_pun.un_tty->ldisc->ops->write_wakeup) {
980 spin_unlock_irqrestore(&ch->ch_lock, flags);
981 ch->ch_pun.un_tty->ldisc->ops->write_wakeup(ch->ch_pun.un_tty);
982 spin_lock_irqsave(&ch->ch_lock, flags);
983 }
984
985 wake_up_interruptible(&ch->ch_pun.un_tty->write_wait);
986
987 /*
988 * If unit is set to wait until empty, check to make sure
989 * the queue AND FIFO are both empty.
990 */
991 if (ch->ch_pun.un_flags & UN_EMPTY) {
992 if ((qlen == 0) &&
993 (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0))
994 ch->ch_pun.un_flags &= ~(UN_EMPTY);
995 }
996
997 wake_up_interruptible(&ch->ch_pun.un_flags_wait);
998 }
999
1000 spin_unlock_irqrestore(&ch->ch_lock, flags);
1001 }
1002
1003 /************************************************************************
1004 *
1005 * TTY Entry points and helper functions
1006 *
1007 ************************************************************************/
1008
1009 /*
1010 * dgnc_tty_open()
1011 *
1012 */
dgnc_tty_open(struct tty_struct * tty,struct file * file)1013 static int dgnc_tty_open(struct tty_struct *tty, struct file *file)
1014 {
1015 struct dgnc_board *brd;
1016 struct channel_t *ch;
1017 struct un_t *un;
1018 uint major = 0;
1019 uint minor = 0;
1020 int rc = 0;
1021 unsigned long flags;
1022
1023 rc = 0;
1024
1025 major = MAJOR(tty_devnum(tty));
1026 minor = MINOR(tty_devnum(tty));
1027
1028 if (major > 255)
1029 return -ENXIO;
1030
1031 /* Get board pointer from our array of majors we have allocated */
1032 brd = dgnc_BoardsByMajor[major];
1033 if (!brd)
1034 return -ENXIO;
1035
1036 /*
1037 * If board is not yet up to a state of READY, go to
1038 * sleep waiting for it to happen or they cancel the open.
1039 */
1040 rc = wait_event_interruptible(brd->state_wait,
1041 (brd->state & BOARD_READY));
1042
1043 if (rc)
1044 return rc;
1045
1046 spin_lock_irqsave(&brd->bd_lock, flags);
1047
1048 /* If opened device is greater than our number of ports, bail. */
1049 if (PORT_NUM(minor) >= brd->nasync) {
1050 spin_unlock_irqrestore(&brd->bd_lock, flags);
1051 return -ENXIO;
1052 }
1053
1054 ch = brd->channels[PORT_NUM(minor)];
1055 if (!ch) {
1056 spin_unlock_irqrestore(&brd->bd_lock, flags);
1057 return -ENXIO;
1058 }
1059
1060 /* Drop board lock */
1061 spin_unlock_irqrestore(&brd->bd_lock, flags);
1062
1063 /* Grab channel lock */
1064 spin_lock_irqsave(&ch->ch_lock, flags);
1065
1066 /* Figure out our type */
1067 if (!IS_PRINT(minor)) {
1068 un = &brd->channels[PORT_NUM(minor)]->ch_tun;
1069 un->un_type = DGNC_SERIAL;
1070 } else if (IS_PRINT(minor)) {
1071 un = &brd->channels[PORT_NUM(minor)]->ch_pun;
1072 un->un_type = DGNC_PRINT;
1073 } else {
1074 spin_unlock_irqrestore(&ch->ch_lock, flags);
1075 return -ENXIO;
1076 }
1077
1078 /*
1079 * If the port is still in a previous open, and in a state
1080 * where we simply cannot safely keep going, wait until the
1081 * state clears.
1082 */
1083 spin_unlock_irqrestore(&ch->ch_lock, flags);
1084
1085 rc = wait_event_interruptible(ch->ch_flags_wait,
1086 ((ch->ch_flags & CH_OPENING) == 0));
1087
1088 /* If ret is non-zero, user ctrl-c'ed us */
1089 if (rc)
1090 return -EINTR;
1091
1092 /*
1093 * If either unit is in the middle of the fragile part of close,
1094 * we just cannot touch the channel safely.
1095 * Go to sleep, knowing that when the channel can be
1096 * touched safely, the close routine will signal the
1097 * ch_flags_wait to wake us back up.
1098 */
1099 rc = wait_event_interruptible(ch->ch_flags_wait,
1100 (((ch->ch_tun.un_flags | ch->ch_pun.un_flags) &
1101 UN_CLOSING) == 0));
1102
1103 /* If ret is non-zero, user ctrl-c'ed us */
1104 if (rc)
1105 return -EINTR;
1106
1107 spin_lock_irqsave(&ch->ch_lock, flags);
1108
1109 /* Store our unit into driver_data, so we always have it available. */
1110 tty->driver_data = un;
1111
1112 /*
1113 * Initialize tty's
1114 */
1115 if (!(un->un_flags & UN_ISOPEN)) {
1116 /* Store important variables. */
1117 un->un_tty = tty;
1118
1119 /* Maybe do something here to the TTY struct as well? */
1120 }
1121
1122 /*
1123 * Allocate channel buffers for read/write/error.
1124 * Set flag, so we don't get trounced on.
1125 */
1126 ch->ch_flags |= (CH_OPENING);
1127
1128 /* Drop locks, as malloc with GFP_KERNEL can sleep */
1129 spin_unlock_irqrestore(&ch->ch_lock, flags);
1130
1131 if (!ch->ch_rqueue)
1132 ch->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
1133 if (!ch->ch_equeue)
1134 ch->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
1135 if (!ch->ch_wqueue)
1136 ch->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
1137
1138 spin_lock_irqsave(&ch->ch_lock, flags);
1139
1140 ch->ch_flags &= ~(CH_OPENING);
1141 wake_up_interruptible(&ch->ch_flags_wait);
1142
1143 /*
1144 * Initialize if neither terminal or printer is open.
1145 */
1146 if (!((ch->ch_tun.un_flags | ch->ch_pun.un_flags) & UN_ISOPEN)) {
1147 /*
1148 * Flush input queues.
1149 */
1150 ch->ch_r_head = 0;
1151 ch->ch_r_tail = 0;
1152 ch->ch_e_head = 0;
1153 ch->ch_e_tail = 0;
1154 ch->ch_w_head = 0;
1155 ch->ch_w_tail = 0;
1156
1157 brd->bd_ops->flush_uart_write(ch);
1158 brd->bd_ops->flush_uart_read(ch);
1159
1160 ch->ch_flags = 0;
1161 ch->ch_cached_lsr = 0;
1162 ch->ch_stop_sending_break = 0;
1163 ch->ch_stops_sent = 0;
1164
1165 ch->ch_c_cflag = tty->termios.c_cflag;
1166 ch->ch_c_iflag = tty->termios.c_iflag;
1167 ch->ch_c_oflag = tty->termios.c_oflag;
1168 ch->ch_c_lflag = tty->termios.c_lflag;
1169 ch->ch_startc = tty->termios.c_cc[VSTART];
1170 ch->ch_stopc = tty->termios.c_cc[VSTOP];
1171
1172 /*
1173 * Bring up RTS and DTR...
1174 * Also handle RTS or DTR toggle if set.
1175 */
1176 if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE))
1177 ch->ch_mostat |= (UART_MCR_RTS);
1178 if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE))
1179 ch->ch_mostat |= (UART_MCR_DTR);
1180
1181 /* Tell UART to init itself */
1182 brd->bd_ops->uart_init(ch);
1183 }
1184
1185 /*
1186 * Run param in case we changed anything
1187 */
1188 brd->bd_ops->param(tty);
1189
1190 dgnc_carrier(ch);
1191
1192 /*
1193 * follow protocol for opening port
1194 */
1195
1196 spin_unlock_irqrestore(&ch->ch_lock, flags);
1197
1198 rc = dgnc_block_til_ready(tty, file, ch);
1199
1200 /* No going back now, increment our unit and channel counters */
1201 spin_lock_irqsave(&ch->ch_lock, flags);
1202 ch->ch_open_count++;
1203 un->un_open_count++;
1204 un->un_flags |= (UN_ISOPEN);
1205 spin_unlock_irqrestore(&ch->ch_lock, flags);
1206
1207 return rc;
1208 }
1209
1210 /*
1211 * dgnc_block_til_ready()
1212 *
1213 * Wait for DCD, if needed.
1214 */
dgnc_block_til_ready(struct tty_struct * tty,struct file * file,struct channel_t * ch)1215 static int dgnc_block_til_ready(struct tty_struct *tty,
1216 struct file *file,
1217 struct channel_t *ch)
1218 {
1219 int retval = 0;
1220 struct un_t *un = NULL;
1221 unsigned long flags;
1222 uint old_flags = 0;
1223 int sleep_on_un_flags = 0;
1224
1225 if (!tty || tty->magic != TTY_MAGIC || !file || !ch ||
1226 ch->magic != DGNC_CHANNEL_MAGIC)
1227 return -ENXIO;
1228
1229 un = tty->driver_data;
1230 if (!un || un->magic != DGNC_UNIT_MAGIC)
1231 return -ENXIO;
1232
1233 spin_lock_irqsave(&ch->ch_lock, flags);
1234
1235 ch->ch_wopen++;
1236
1237 /* Loop forever */
1238 while (1) {
1239 sleep_on_un_flags = 0;
1240
1241 /*
1242 * If board has failed somehow during our sleep,
1243 * bail with error.
1244 */
1245 if (ch->ch_bd->state == BOARD_FAILED) {
1246 retval = -ENXIO;
1247 break;
1248 }
1249
1250 /* If tty was hung up, break out of loop and set error. */
1251 if (tty_hung_up_p(file)) {
1252 retval = -EAGAIN;
1253 break;
1254 }
1255
1256 /*
1257 * If either unit is in the middle of the fragile part of close,
1258 * we just cannot touch the channel safely.
1259 * Go back to sleep, knowing that when the channel can be
1260 * touched safely, the close routine will signal the
1261 * ch_wait_flags to wake us back up.
1262 */
1263 if (!((ch->ch_tun.un_flags |
1264 ch->ch_pun.un_flags) &
1265 UN_CLOSING)) {
1266 /*
1267 * Our conditions to leave cleanly and happily:
1268 * 1) NONBLOCKING on the tty is set.
1269 * 2) CLOCAL is set.
1270 * 3) DCD (fake or real) is active.
1271 */
1272
1273 if (file->f_flags & O_NONBLOCK)
1274 break;
1275
1276 if (tty->flags & (1 << TTY_IO_ERROR)) {
1277 retval = -EIO;
1278 break;
1279 }
1280
1281 if (ch->ch_flags & CH_CD)
1282 break;
1283
1284 if (ch->ch_flags & CH_FCAR)
1285 break;
1286 } else {
1287 sleep_on_un_flags = 1;
1288 }
1289
1290 /*
1291 * If there is a signal pending, the user probably
1292 * interrupted (ctrl-c) us.
1293 * Leave loop with error set.
1294 */
1295 if (signal_pending(current)) {
1296 retval = -ERESTARTSYS;
1297 break;
1298 }
1299
1300 /*
1301 * Store the flags before we let go of channel lock
1302 */
1303 if (sleep_on_un_flags)
1304 old_flags = ch->ch_tun.un_flags | ch->ch_pun.un_flags;
1305 else
1306 old_flags = ch->ch_flags;
1307
1308 /*
1309 * Let go of channel lock before calling schedule.
1310 * Our poller will get any FEP events and wake us up when DCD
1311 * eventually goes active.
1312 */
1313
1314 spin_unlock_irqrestore(&ch->ch_lock, flags);
1315
1316 /*
1317 * Wait for something in the flags to change
1318 * from the current value.
1319 */
1320 if (sleep_on_un_flags)
1321 retval = wait_event_interruptible(un->un_flags_wait,
1322 (old_flags != (ch->ch_tun.un_flags |
1323 ch->ch_pun.un_flags)));
1324 else
1325 retval = wait_event_interruptible(ch->ch_flags_wait,
1326 (old_flags != ch->ch_flags));
1327
1328 /*
1329 * We got woken up for some reason.
1330 * Before looping around, grab our channel lock.
1331 */
1332 spin_lock_irqsave(&ch->ch_lock, flags);
1333 }
1334
1335 ch->ch_wopen--;
1336
1337 spin_unlock_irqrestore(&ch->ch_lock, flags);
1338
1339 return retval;
1340 }
1341
1342 /*
1343 * dgnc_tty_hangup()
1344 *
1345 * Hangup the port. Like a close, but don't wait for output to drain.
1346 */
dgnc_tty_hangup(struct tty_struct * tty)1347 static void dgnc_tty_hangup(struct tty_struct *tty)
1348 {
1349 struct un_t *un;
1350
1351 if (!tty || tty->magic != TTY_MAGIC)
1352 return;
1353
1354 un = tty->driver_data;
1355 if (!un || un->magic != DGNC_UNIT_MAGIC)
1356 return;
1357
1358 /* flush the transmit queues */
1359 dgnc_tty_flush_buffer(tty);
1360 }
1361
1362 /*
1363 * dgnc_tty_close()
1364 *
1365 */
dgnc_tty_close(struct tty_struct * tty,struct file * file)1366 static void dgnc_tty_close(struct tty_struct *tty, struct file *file)
1367 {
1368 struct dgnc_board *bd;
1369 struct channel_t *ch;
1370 struct un_t *un;
1371 unsigned long flags;
1372
1373 if (!tty || tty->magic != TTY_MAGIC)
1374 return;
1375
1376 un = tty->driver_data;
1377 if (!un || un->magic != DGNC_UNIT_MAGIC)
1378 return;
1379
1380 ch = un->un_ch;
1381 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1382 return;
1383
1384 bd = ch->ch_bd;
1385 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
1386 return;
1387
1388 spin_lock_irqsave(&ch->ch_lock, flags);
1389
1390 /*
1391 * Determine if this is the last close or not - and if we agree about
1392 * which type of close it is with the Line Discipline
1393 */
1394 if ((tty->count == 1) && (un->un_open_count != 1)) {
1395 /*
1396 * Uh, oh. tty->count is 1, which means that the tty
1397 * structure will be freed. un_open_count should always
1398 * be one in these conditions. If it's greater than
1399 * one, we've got real problems, since it means the
1400 * serial port won't be shutdown.
1401 */
1402 dev_dbg(tty->dev,
1403 "tty->count is 1, un open count is %d\n",
1404 un->un_open_count);
1405 un->un_open_count = 1;
1406 }
1407
1408 if (un->un_open_count)
1409 un->un_open_count--;
1410 else
1411 dev_dbg(tty->dev,
1412 "bad serial port open count of %d\n",
1413 un->un_open_count);
1414
1415 ch->ch_open_count--;
1416
1417 if (ch->ch_open_count && un->un_open_count) {
1418 spin_unlock_irqrestore(&ch->ch_lock, flags);
1419 return;
1420 }
1421
1422 /* OK, its the last close on the unit */
1423 un->un_flags |= UN_CLOSING;
1424
1425 tty->closing = 1;
1426
1427 /*
1428 * Only officially close channel if count is 0 and
1429 * DIGI_PRINTER bit is not set.
1430 */
1431 if ((ch->ch_open_count == 0) &&
1432 !(ch->ch_digi.digi_flags & DIGI_PRINTER)) {
1433 ch->ch_flags &= ~(CH_STOPI | CH_FORCED_STOPI);
1434
1435 /*
1436 * turn off print device when closing print device.
1437 */
1438 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1439 dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1440 (int)ch->ch_digi.digi_offlen);
1441 ch->ch_flags &= ~CH_PRON;
1442 }
1443
1444 spin_unlock_irqrestore(&ch->ch_lock, flags);
1445 /* wait for output to drain */
1446 /* This will also return if we take an interrupt */
1447
1448 bd->bd_ops->drain(tty, 0);
1449
1450 dgnc_tty_flush_buffer(tty);
1451 tty_ldisc_flush(tty);
1452
1453 spin_lock_irqsave(&ch->ch_lock, flags);
1454
1455 tty->closing = 0;
1456
1457 /*
1458 * If we have HUPCL set, lower DTR and RTS
1459 */
1460 if (ch->ch_c_cflag & HUPCL) {
1461 /* Drop RTS/DTR */
1462 ch->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS);
1463 bd->bd_ops->assert_modem_signals(ch);
1464
1465 /*
1466 * Go to sleep to ensure RTS/DTR
1467 * have been dropped for modems to see it.
1468 */
1469 if (ch->ch_close_delay) {
1470 spin_unlock_irqrestore(&ch->ch_lock,
1471 flags);
1472 dgnc_ms_sleep(ch->ch_close_delay);
1473 spin_lock_irqsave(&ch->ch_lock, flags);
1474 }
1475 }
1476
1477 ch->ch_old_baud = 0;
1478
1479 /* Turn off UART interrupts for this port */
1480 ch->ch_bd->bd_ops->uart_off(ch);
1481 } else {
1482 /*
1483 * turn off print device when closing print device.
1484 */
1485 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1486 dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1487 (int)ch->ch_digi.digi_offlen);
1488 ch->ch_flags &= ~CH_PRON;
1489 }
1490 }
1491
1492 un->un_tty = NULL;
1493 un->un_flags &= ~(UN_ISOPEN | UN_CLOSING);
1494
1495 wake_up_interruptible(&ch->ch_flags_wait);
1496 wake_up_interruptible(&un->un_flags_wait);
1497
1498 spin_unlock_irqrestore(&ch->ch_lock, flags);
1499 }
1500
1501 /*
1502 * dgnc_tty_chars_in_buffer()
1503 *
1504 * Return number of characters that have not been transmitted yet.
1505 *
1506 * This routine is used by the line discipline to determine if there
1507 * is data waiting to be transmitted/drained/flushed or not.
1508 */
dgnc_tty_chars_in_buffer(struct tty_struct * tty)1509 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty)
1510 {
1511 struct channel_t *ch = NULL;
1512 struct un_t *un = NULL;
1513 ushort thead;
1514 ushort ttail;
1515 uint tmask;
1516 uint chars = 0;
1517 unsigned long flags;
1518
1519 if (!tty)
1520 return 0;
1521
1522 un = tty->driver_data;
1523 if (!un || un->magic != DGNC_UNIT_MAGIC)
1524 return 0;
1525
1526 ch = un->un_ch;
1527 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1528 return 0;
1529
1530 spin_lock_irqsave(&ch->ch_lock, flags);
1531
1532 tmask = WQUEUEMASK;
1533 thead = ch->ch_w_head & tmask;
1534 ttail = ch->ch_w_tail & tmask;
1535
1536 spin_unlock_irqrestore(&ch->ch_lock, flags);
1537
1538 if (ttail == thead) {
1539 chars = 0;
1540 } else {
1541 if (thead >= ttail)
1542 chars = thead - ttail;
1543 else
1544 chars = thead - ttail + WQUEUESIZE;
1545 }
1546
1547 return chars;
1548 }
1549
1550 /*
1551 * dgnc_maxcps_room
1552 *
1553 * Reduces bytes_available to the max number of characters
1554 * that can be sent currently given the maxcps value, and
1555 * returns the new bytes_available. This only affects printer
1556 * output.
1557 */
dgnc_maxcps_room(struct tty_struct * tty,int bytes_available)1558 static int dgnc_maxcps_room(struct tty_struct *tty, int bytes_available)
1559 {
1560 struct channel_t *ch = NULL;
1561 struct un_t *un = NULL;
1562
1563 if (!tty)
1564 return bytes_available;
1565
1566 un = tty->driver_data;
1567 if (!un || un->magic != DGNC_UNIT_MAGIC)
1568 return bytes_available;
1569
1570 ch = un->un_ch;
1571 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1572 return bytes_available;
1573
1574 /*
1575 * If its not the Transparent print device, return
1576 * the full data amount.
1577 */
1578 if (un->un_type != DGNC_PRINT)
1579 return bytes_available;
1580
1581 if (ch->ch_digi.digi_maxcps > 0 && ch->ch_digi.digi_bufsize > 0) {
1582 int cps_limit = 0;
1583 unsigned long current_time = jiffies;
1584 unsigned long buffer_time = current_time +
1585 (HZ * ch->ch_digi.digi_bufsize) /
1586 ch->ch_digi.digi_maxcps;
1587
1588 if (ch->ch_cpstime < current_time) {
1589 /* buffer is empty */
1590 ch->ch_cpstime = current_time; /* reset ch_cpstime */
1591 cps_limit = ch->ch_digi.digi_bufsize;
1592 } else if (ch->ch_cpstime < buffer_time) {
1593 /* still room in the buffer */
1594 cps_limit = ((buffer_time - ch->ch_cpstime) *
1595 ch->ch_digi.digi_maxcps) / HZ;
1596 } else {
1597 /* no room in the buffer */
1598 cps_limit = 0;
1599 }
1600
1601 bytes_available = min(cps_limit, bytes_available);
1602 }
1603
1604 return bytes_available;
1605 }
1606
1607 /*
1608 * dgnc_tty_write_room()
1609 *
1610 * Return space available in Tx buffer
1611 */
dgnc_tty_write_room(struct tty_struct * tty)1612 static int dgnc_tty_write_room(struct tty_struct *tty)
1613 {
1614 struct channel_t *ch = NULL;
1615 struct un_t *un = NULL;
1616 ushort head;
1617 ushort tail;
1618 ushort tmask;
1619 int ret = 0;
1620 unsigned long flags;
1621
1622 if (!tty || !dgnc_TmpWriteBuf)
1623 return 0;
1624
1625 un = tty->driver_data;
1626 if (!un || un->magic != DGNC_UNIT_MAGIC)
1627 return 0;
1628
1629 ch = un->un_ch;
1630 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1631 return 0;
1632
1633 spin_lock_irqsave(&ch->ch_lock, flags);
1634
1635 tmask = WQUEUEMASK;
1636 head = (ch->ch_w_head) & tmask;
1637 tail = (ch->ch_w_tail) & tmask;
1638
1639 ret = tail - head - 1;
1640 if (ret < 0)
1641 ret += WQUEUESIZE;
1642
1643 /* Limit printer to maxcps */
1644 ret = dgnc_maxcps_room(tty, ret);
1645
1646 /*
1647 * If we are printer device, leave space for
1648 * possibly both the on and off strings.
1649 */
1650 if (un->un_type == DGNC_PRINT) {
1651 if (!(ch->ch_flags & CH_PRON))
1652 ret -= ch->ch_digi.digi_onlen;
1653 ret -= ch->ch_digi.digi_offlen;
1654 } else {
1655 if (ch->ch_flags & CH_PRON)
1656 ret -= ch->ch_digi.digi_offlen;
1657 }
1658
1659 if (ret < 0)
1660 ret = 0;
1661
1662 spin_unlock_irqrestore(&ch->ch_lock, flags);
1663
1664 return ret;
1665 }
1666
1667 /*
1668 * dgnc_tty_put_char()
1669 *
1670 * Put a character into ch->ch_buf
1671 *
1672 * - used by the line discipline for OPOST processing
1673 */
dgnc_tty_put_char(struct tty_struct * tty,unsigned char c)1674 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c)
1675 {
1676 /*
1677 * Simply call tty_write.
1678 */
1679 dgnc_tty_write(tty, &c, 1);
1680 return 1;
1681 }
1682
1683 /*
1684 * dgnc_tty_write()
1685 *
1686 * Take data from the user or kernel and send it out to the FEP.
1687 * In here exists all the Transparent Print magic as well.
1688 */
dgnc_tty_write(struct tty_struct * tty,const unsigned char * buf,int count)1689 static int dgnc_tty_write(struct tty_struct *tty,
1690 const unsigned char *buf, int count)
1691 {
1692 struct channel_t *ch = NULL;
1693 struct un_t *un = NULL;
1694 int bufcount = 0, n = 0;
1695 unsigned long flags;
1696 ushort head;
1697 ushort tail;
1698 ushort tmask;
1699 uint remain;
1700
1701 if (!tty || !dgnc_TmpWriteBuf)
1702 return 0;
1703
1704 un = tty->driver_data;
1705 if (!un || un->magic != DGNC_UNIT_MAGIC)
1706 return 0;
1707
1708 ch = un->un_ch;
1709 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1710 return 0;
1711
1712 if (!count)
1713 return 0;
1714
1715 /*
1716 * Store original amount of characters passed in.
1717 * This helps to figure out if we should ask the FEP
1718 * to send us an event when it has more space available.
1719 */
1720
1721 spin_lock_irqsave(&ch->ch_lock, flags);
1722
1723 /* Get our space available for the channel from the board */
1724 tmask = WQUEUEMASK;
1725 head = (ch->ch_w_head) & tmask;
1726 tail = (ch->ch_w_tail) & tmask;
1727
1728 bufcount = tail - head - 1;
1729 if (bufcount < 0)
1730 bufcount += WQUEUESIZE;
1731
1732 /*
1733 * Limit printer output to maxcps overall, with bursts allowed
1734 * up to bufsize characters.
1735 */
1736 bufcount = dgnc_maxcps_room(tty, bufcount);
1737
1738 /*
1739 * Take minimum of what the user wants to send, and the
1740 * space available in the FEP buffer.
1741 */
1742 count = min(count, bufcount);
1743
1744 /*
1745 * Bail if no space left.
1746 */
1747 if (count <= 0)
1748 goto exit_retry;
1749
1750 /*
1751 * Output the printer ON string, if we are in terminal mode, but
1752 * need to be in printer mode.
1753 */
1754 if ((un->un_type == DGNC_PRINT) && !(ch->ch_flags & CH_PRON)) {
1755 dgnc_wmove(ch, ch->ch_digi.digi_onstr,
1756 (int)ch->ch_digi.digi_onlen);
1757 head = (ch->ch_w_head) & tmask;
1758 ch->ch_flags |= CH_PRON;
1759 }
1760
1761 /*
1762 * On the other hand, output the printer OFF string, if we are
1763 * currently in printer mode, but need to output to the terminal.
1764 */
1765 if ((un->un_type != DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1766 dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1767 (int)ch->ch_digi.digi_offlen);
1768 head = (ch->ch_w_head) & tmask;
1769 ch->ch_flags &= ~CH_PRON;
1770 }
1771
1772 n = count;
1773
1774 /*
1775 * If the write wraps over the top of the circular buffer,
1776 * move the portion up to the wrap point, and reset the
1777 * pointers to the bottom.
1778 */
1779 remain = WQUEUESIZE - head;
1780
1781 if (n >= remain) {
1782 n -= remain;
1783 memcpy(ch->ch_wqueue + head, buf, remain);
1784 head = 0;
1785 buf += remain;
1786 }
1787
1788 if (n > 0) {
1789 /*
1790 * Move rest of data.
1791 */
1792 remain = n;
1793 memcpy(ch->ch_wqueue + head, buf, remain);
1794 head += remain;
1795 }
1796
1797 if (count) {
1798 head &= tmask;
1799 ch->ch_w_head = head;
1800 }
1801
1802 /* Update printer buffer empty time. */
1803 if ((un->un_type == DGNC_PRINT) && (ch->ch_digi.digi_maxcps > 0)
1804 && (ch->ch_digi.digi_bufsize > 0)) {
1805 ch->ch_cpstime += (HZ * count) / ch->ch_digi.digi_maxcps;
1806 }
1807
1808 spin_unlock_irqrestore(&ch->ch_lock, flags);
1809
1810 if (count) {
1811 /*
1812 * Channel lock is grabbed and then released
1813 * inside this routine.
1814 */
1815 ch->ch_bd->bd_ops->copy_data_from_queue_to_uart(ch);
1816 }
1817
1818 return count;
1819
1820 exit_retry:
1821
1822 spin_unlock_irqrestore(&ch->ch_lock, flags);
1823 return 0;
1824 }
1825
1826 /*
1827 * Return modem signals to ld.
1828 */
1829
dgnc_tty_tiocmget(struct tty_struct * tty)1830 static int dgnc_tty_tiocmget(struct tty_struct *tty)
1831 {
1832 struct channel_t *ch;
1833 struct un_t *un;
1834 int result = -EIO;
1835 unsigned char mstat = 0;
1836 unsigned long flags;
1837
1838 if (!tty || tty->magic != TTY_MAGIC)
1839 return result;
1840
1841 un = tty->driver_data;
1842 if (!un || un->magic != DGNC_UNIT_MAGIC)
1843 return result;
1844
1845 ch = un->un_ch;
1846 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1847 return result;
1848
1849 spin_lock_irqsave(&ch->ch_lock, flags);
1850
1851 mstat = (ch->ch_mostat | ch->ch_mistat);
1852
1853 spin_unlock_irqrestore(&ch->ch_lock, flags);
1854
1855 result = 0;
1856
1857 if (mstat & UART_MCR_DTR)
1858 result |= TIOCM_DTR;
1859 if (mstat & UART_MCR_RTS)
1860 result |= TIOCM_RTS;
1861 if (mstat & UART_MSR_CTS)
1862 result |= TIOCM_CTS;
1863 if (mstat & UART_MSR_DSR)
1864 result |= TIOCM_DSR;
1865 if (mstat & UART_MSR_RI)
1866 result |= TIOCM_RI;
1867 if (mstat & UART_MSR_DCD)
1868 result |= TIOCM_CD;
1869
1870 return result;
1871 }
1872
1873 /*
1874 * dgnc_tty_tiocmset()
1875 *
1876 * Set modem signals, called by ld.
1877 */
1878
dgnc_tty_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)1879 static int dgnc_tty_tiocmset(struct tty_struct *tty,
1880 unsigned int set, unsigned int clear)
1881 {
1882 struct dgnc_board *bd;
1883 struct channel_t *ch;
1884 struct un_t *un;
1885 int ret = -EIO;
1886 unsigned long flags;
1887
1888 if (!tty || tty->magic != TTY_MAGIC)
1889 return ret;
1890
1891 un = tty->driver_data;
1892 if (!un || un->magic != DGNC_UNIT_MAGIC)
1893 return ret;
1894
1895 ch = un->un_ch;
1896 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1897 return ret;
1898
1899 bd = ch->ch_bd;
1900 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
1901 return ret;
1902
1903 spin_lock_irqsave(&ch->ch_lock, flags);
1904
1905 if (set & TIOCM_RTS)
1906 ch->ch_mostat |= UART_MCR_RTS;
1907
1908 if (set & TIOCM_DTR)
1909 ch->ch_mostat |= UART_MCR_DTR;
1910
1911 if (clear & TIOCM_RTS)
1912 ch->ch_mostat &= ~(UART_MCR_RTS);
1913
1914 if (clear & TIOCM_DTR)
1915 ch->ch_mostat &= ~(UART_MCR_DTR);
1916
1917 ch->ch_bd->bd_ops->assert_modem_signals(ch);
1918
1919 spin_unlock_irqrestore(&ch->ch_lock, flags);
1920
1921 return 0;
1922 }
1923
1924 /*
1925 * dgnc_tty_send_break()
1926 *
1927 * Send a Break, called by ld.
1928 */
dgnc_tty_send_break(struct tty_struct * tty,int msec)1929 static int dgnc_tty_send_break(struct tty_struct *tty, int msec)
1930 {
1931 struct dgnc_board *bd;
1932 struct channel_t *ch;
1933 struct un_t *un;
1934 int ret = -EIO;
1935 unsigned long flags;
1936
1937 if (!tty || tty->magic != TTY_MAGIC)
1938 return ret;
1939
1940 un = tty->driver_data;
1941 if (!un || un->magic != DGNC_UNIT_MAGIC)
1942 return ret;
1943
1944 ch = un->un_ch;
1945 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1946 return ret;
1947
1948 bd = ch->ch_bd;
1949 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
1950 return ret;
1951
1952 switch (msec) {
1953 case -1:
1954 msec = 0xFFFF;
1955 break;
1956 case 0:
1957 msec = 0;
1958 break;
1959 default:
1960 break;
1961 }
1962
1963 spin_lock_irqsave(&ch->ch_lock, flags);
1964
1965 ch->ch_bd->bd_ops->send_break(ch, msec);
1966
1967 spin_unlock_irqrestore(&ch->ch_lock, flags);
1968
1969 return 0;
1970 }
1971
1972 /*
1973 * dgnc_tty_wait_until_sent()
1974 *
1975 * wait until data has been transmitted, called by ld.
1976 */
dgnc_tty_wait_until_sent(struct tty_struct * tty,int timeout)1977 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1978 {
1979 struct dgnc_board *bd;
1980 struct channel_t *ch;
1981 struct un_t *un;
1982
1983 if (!tty || tty->magic != TTY_MAGIC)
1984 return;
1985
1986 un = tty->driver_data;
1987 if (!un || un->magic != DGNC_UNIT_MAGIC)
1988 return;
1989
1990 ch = un->un_ch;
1991 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
1992 return;
1993
1994 bd = ch->ch_bd;
1995 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
1996 return;
1997
1998 bd->bd_ops->drain(tty, 0);
1999 }
2000
2001 /*
2002 * dgnc_send_xchar()
2003 *
2004 * send a high priority character, called by ld.
2005 */
dgnc_tty_send_xchar(struct tty_struct * tty,char c)2006 static void dgnc_tty_send_xchar(struct tty_struct *tty, char c)
2007 {
2008 struct dgnc_board *bd;
2009 struct channel_t *ch;
2010 struct un_t *un;
2011 unsigned long flags;
2012
2013 if (!tty || tty->magic != TTY_MAGIC)
2014 return;
2015
2016 un = tty->driver_data;
2017 if (!un || un->magic != DGNC_UNIT_MAGIC)
2018 return;
2019
2020 ch = un->un_ch;
2021 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2022 return;
2023
2024 bd = ch->ch_bd;
2025 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2026 return;
2027
2028 dev_dbg(tty->dev, "dgnc_tty_send_xchar start\n");
2029
2030 spin_lock_irqsave(&ch->ch_lock, flags);
2031 bd->bd_ops->send_immediate_char(ch, c);
2032 spin_unlock_irqrestore(&ch->ch_lock, flags);
2033
2034 dev_dbg(tty->dev, "dgnc_tty_send_xchar finish\n");
2035 }
2036
2037 /*
2038 * Return modem signals to ld.
2039 */
dgnc_get_mstat(struct channel_t * ch)2040 static inline int dgnc_get_mstat(struct channel_t *ch)
2041 {
2042 unsigned char mstat;
2043 int result = -EIO;
2044 unsigned long flags;
2045
2046 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2047 return -ENXIO;
2048
2049 spin_lock_irqsave(&ch->ch_lock, flags);
2050
2051 mstat = (ch->ch_mostat | ch->ch_mistat);
2052
2053 spin_unlock_irqrestore(&ch->ch_lock, flags);
2054
2055 result = 0;
2056
2057 if (mstat & UART_MCR_DTR)
2058 result |= TIOCM_DTR;
2059 if (mstat & UART_MCR_RTS)
2060 result |= TIOCM_RTS;
2061 if (mstat & UART_MSR_CTS)
2062 result |= TIOCM_CTS;
2063 if (mstat & UART_MSR_DSR)
2064 result |= TIOCM_DSR;
2065 if (mstat & UART_MSR_RI)
2066 result |= TIOCM_RI;
2067 if (mstat & UART_MSR_DCD)
2068 result |= TIOCM_CD;
2069
2070 return result;
2071 }
2072
2073 /*
2074 * Return modem signals to ld.
2075 */
dgnc_get_modem_info(struct channel_t * ch,unsigned int __user * value)2076 static int dgnc_get_modem_info(struct channel_t *ch,
2077 unsigned int __user *value)
2078 {
2079 int result;
2080
2081 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2082 return -ENXIO;
2083
2084 result = dgnc_get_mstat(ch);
2085
2086 if (result < 0)
2087 return -ENXIO;
2088
2089 return put_user(result, value);
2090 }
2091
2092 /*
2093 * dgnc_set_modem_info()
2094 *
2095 * Set modem signals, called by ld.
2096 */
dgnc_set_modem_info(struct tty_struct * tty,unsigned int command,unsigned int __user * value)2097 static int dgnc_set_modem_info(struct tty_struct *tty,
2098 unsigned int command,
2099 unsigned int __user *value)
2100 {
2101 struct dgnc_board *bd;
2102 struct channel_t *ch;
2103 struct un_t *un;
2104 int ret = -ENXIO;
2105 unsigned int arg = 0;
2106 unsigned long flags;
2107
2108 if (!tty || tty->magic != TTY_MAGIC)
2109 return ret;
2110
2111 un = tty->driver_data;
2112 if (!un || un->magic != DGNC_UNIT_MAGIC)
2113 return ret;
2114
2115 ch = un->un_ch;
2116 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2117 return ret;
2118
2119 bd = ch->ch_bd;
2120 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2121 return ret;
2122
2123 ret = get_user(arg, value);
2124 if (ret)
2125 return ret;
2126
2127 switch (command) {
2128 case TIOCMBIS:
2129 if (arg & TIOCM_RTS)
2130 ch->ch_mostat |= UART_MCR_RTS;
2131
2132 if (arg & TIOCM_DTR)
2133 ch->ch_mostat |= UART_MCR_DTR;
2134
2135 break;
2136
2137 case TIOCMBIC:
2138 if (arg & TIOCM_RTS)
2139 ch->ch_mostat &= ~(UART_MCR_RTS);
2140
2141 if (arg & TIOCM_DTR)
2142 ch->ch_mostat &= ~(UART_MCR_DTR);
2143
2144 break;
2145
2146 case TIOCMSET:
2147
2148 if (arg & TIOCM_RTS)
2149 ch->ch_mostat |= UART_MCR_RTS;
2150 else
2151 ch->ch_mostat &= ~(UART_MCR_RTS);
2152
2153 if (arg & TIOCM_DTR)
2154 ch->ch_mostat |= UART_MCR_DTR;
2155 else
2156 ch->ch_mostat &= ~(UART_MCR_DTR);
2157
2158 break;
2159
2160 default:
2161 return -EINVAL;
2162 }
2163
2164 spin_lock_irqsave(&ch->ch_lock, flags);
2165
2166 ch->ch_bd->bd_ops->assert_modem_signals(ch);
2167
2168 spin_unlock_irqrestore(&ch->ch_lock, flags);
2169
2170 return 0;
2171 }
2172
2173 /*
2174 * dgnc_tty_digigeta()
2175 *
2176 * Ioctl to get the information for ditty.
2177 *
2178 *
2179 *
2180 */
dgnc_tty_digigeta(struct tty_struct * tty,struct digi_t __user * retinfo)2181 static int dgnc_tty_digigeta(struct tty_struct *tty,
2182 struct digi_t __user *retinfo)
2183 {
2184 struct channel_t *ch;
2185 struct un_t *un;
2186 struct digi_t tmp;
2187 unsigned long flags;
2188
2189 if (!retinfo)
2190 return -EFAULT;
2191
2192 if (!tty || tty->magic != TTY_MAGIC)
2193 return -EFAULT;
2194
2195 un = tty->driver_data;
2196 if (!un || un->magic != DGNC_UNIT_MAGIC)
2197 return -EFAULT;
2198
2199 ch = un->un_ch;
2200 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2201 return -EFAULT;
2202
2203 memset(&tmp, 0, sizeof(tmp));
2204
2205 spin_lock_irqsave(&ch->ch_lock, flags);
2206 memcpy(&tmp, &ch->ch_digi, sizeof(tmp));
2207 spin_unlock_irqrestore(&ch->ch_lock, flags);
2208
2209 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2210 return -EFAULT;
2211
2212 return 0;
2213 }
2214
2215 /*
2216 * dgnc_tty_digiseta()
2217 *
2218 * Ioctl to set the information for ditty.
2219 *
2220 *
2221 *
2222 */
dgnc_tty_digiseta(struct tty_struct * tty,struct digi_t __user * new_info)2223 static int dgnc_tty_digiseta(struct tty_struct *tty,
2224 struct digi_t __user *new_info)
2225 {
2226 struct dgnc_board *bd;
2227 struct channel_t *ch;
2228 struct un_t *un;
2229 struct digi_t new_digi;
2230 unsigned long flags;
2231
2232 if (!tty || tty->magic != TTY_MAGIC)
2233 return -EFAULT;
2234
2235 un = tty->driver_data;
2236 if (!un || un->magic != DGNC_UNIT_MAGIC)
2237 return -EFAULT;
2238
2239 ch = un->un_ch;
2240 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2241 return -EFAULT;
2242
2243 bd = ch->ch_bd;
2244 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2245 return -EFAULT;
2246
2247 if (copy_from_user(&new_digi, new_info, sizeof(new_digi)))
2248 return -EFAULT;
2249
2250 spin_lock_irqsave(&ch->ch_lock, flags);
2251
2252 /*
2253 * Handle transistions to and from RTS Toggle.
2254 */
2255 if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) &&
2256 (new_digi.digi_flags & DIGI_RTS_TOGGLE))
2257 ch->ch_mostat &= ~(UART_MCR_RTS);
2258 if ((ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) &&
2259 !(new_digi.digi_flags & DIGI_RTS_TOGGLE))
2260 ch->ch_mostat |= (UART_MCR_RTS);
2261
2262 /*
2263 * Handle transistions to and from DTR Toggle.
2264 */
2265 if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) &&
2266 (new_digi.digi_flags & DIGI_DTR_TOGGLE))
2267 ch->ch_mostat &= ~(UART_MCR_DTR);
2268 if ((ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) &&
2269 !(new_digi.digi_flags & DIGI_DTR_TOGGLE))
2270 ch->ch_mostat |= (UART_MCR_DTR);
2271
2272 memcpy(&ch->ch_digi, &new_digi, sizeof(new_digi));
2273
2274 if (ch->ch_digi.digi_maxcps < 1)
2275 ch->ch_digi.digi_maxcps = 1;
2276
2277 if (ch->ch_digi.digi_maxcps > 10000)
2278 ch->ch_digi.digi_maxcps = 10000;
2279
2280 if (ch->ch_digi.digi_bufsize < 10)
2281 ch->ch_digi.digi_bufsize = 10;
2282
2283 if (ch->ch_digi.digi_maxchar < 1)
2284 ch->ch_digi.digi_maxchar = 1;
2285
2286 if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
2287 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;
2288
2289 if (ch->ch_digi.digi_onlen > DIGI_PLEN)
2290 ch->ch_digi.digi_onlen = DIGI_PLEN;
2291
2292 if (ch->ch_digi.digi_offlen > DIGI_PLEN)
2293 ch->ch_digi.digi_offlen = DIGI_PLEN;
2294
2295 ch->ch_bd->bd_ops->param(tty);
2296
2297 spin_unlock_irqrestore(&ch->ch_lock, flags);
2298
2299 return 0;
2300 }
2301
2302 /*
2303 * dgnc_set_termios()
2304 */
dgnc_tty_set_termios(struct tty_struct * tty,struct ktermios * old_termios)2305 static void dgnc_tty_set_termios(struct tty_struct *tty,
2306 struct ktermios *old_termios)
2307 {
2308 struct dgnc_board *bd;
2309 struct channel_t *ch;
2310 struct un_t *un;
2311 unsigned long flags;
2312
2313 if (!tty || tty->magic != TTY_MAGIC)
2314 return;
2315
2316 un = tty->driver_data;
2317 if (!un || un->magic != DGNC_UNIT_MAGIC)
2318 return;
2319
2320 ch = un->un_ch;
2321 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2322 return;
2323
2324 bd = ch->ch_bd;
2325 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2326 return;
2327
2328 spin_lock_irqsave(&ch->ch_lock, flags);
2329
2330 ch->ch_c_cflag = tty->termios.c_cflag;
2331 ch->ch_c_iflag = tty->termios.c_iflag;
2332 ch->ch_c_oflag = tty->termios.c_oflag;
2333 ch->ch_c_lflag = tty->termios.c_lflag;
2334 ch->ch_startc = tty->termios.c_cc[VSTART];
2335 ch->ch_stopc = tty->termios.c_cc[VSTOP];
2336
2337 ch->ch_bd->bd_ops->param(tty);
2338 dgnc_carrier(ch);
2339
2340 spin_unlock_irqrestore(&ch->ch_lock, flags);
2341 }
2342
dgnc_tty_throttle(struct tty_struct * tty)2343 static void dgnc_tty_throttle(struct tty_struct *tty)
2344 {
2345 struct channel_t *ch;
2346 struct un_t *un;
2347 unsigned long flags;
2348
2349 if (!tty || tty->magic != TTY_MAGIC)
2350 return;
2351
2352 un = tty->driver_data;
2353 if (!un || un->magic != DGNC_UNIT_MAGIC)
2354 return;
2355
2356 ch = un->un_ch;
2357 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2358 return;
2359
2360 spin_lock_irqsave(&ch->ch_lock, flags);
2361
2362 ch->ch_flags |= (CH_FORCED_STOPI);
2363
2364 spin_unlock_irqrestore(&ch->ch_lock, flags);
2365 }
2366
dgnc_tty_unthrottle(struct tty_struct * tty)2367 static void dgnc_tty_unthrottle(struct tty_struct *tty)
2368 {
2369 struct channel_t *ch;
2370 struct un_t *un;
2371 unsigned long flags;
2372
2373 if (!tty || tty->magic != TTY_MAGIC)
2374 return;
2375
2376 un = tty->driver_data;
2377 if (!un || un->magic != DGNC_UNIT_MAGIC)
2378 return;
2379
2380 ch = un->un_ch;
2381 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2382 return;
2383
2384 spin_lock_irqsave(&ch->ch_lock, flags);
2385
2386 ch->ch_flags &= ~(CH_FORCED_STOPI);
2387
2388 spin_unlock_irqrestore(&ch->ch_lock, flags);
2389 }
2390
dgnc_tty_start(struct tty_struct * tty)2391 static void dgnc_tty_start(struct tty_struct *tty)
2392 {
2393 struct dgnc_board *bd;
2394 struct channel_t *ch;
2395 struct un_t *un;
2396 unsigned long flags;
2397
2398 if (!tty || tty->magic != TTY_MAGIC)
2399 return;
2400
2401 un = tty->driver_data;
2402 if (!un || un->magic != DGNC_UNIT_MAGIC)
2403 return;
2404
2405 ch = un->un_ch;
2406 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2407 return;
2408
2409 bd = ch->ch_bd;
2410 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2411 return;
2412
2413 spin_lock_irqsave(&ch->ch_lock, flags);
2414
2415 ch->ch_flags &= ~(CH_FORCED_STOP);
2416
2417 spin_unlock_irqrestore(&ch->ch_lock, flags);
2418 }
2419
dgnc_tty_stop(struct tty_struct * tty)2420 static void dgnc_tty_stop(struct tty_struct *tty)
2421 {
2422 struct dgnc_board *bd;
2423 struct channel_t *ch;
2424 struct un_t *un;
2425 unsigned long flags;
2426
2427 if (!tty || tty->magic != TTY_MAGIC)
2428 return;
2429
2430 un = tty->driver_data;
2431 if (!un || un->magic != DGNC_UNIT_MAGIC)
2432 return;
2433
2434 ch = un->un_ch;
2435 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2436 return;
2437
2438 bd = ch->ch_bd;
2439 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2440 return;
2441
2442 spin_lock_irqsave(&ch->ch_lock, flags);
2443
2444 ch->ch_flags |= (CH_FORCED_STOP);
2445
2446 spin_unlock_irqrestore(&ch->ch_lock, flags);
2447 }
2448
2449 /*
2450 * dgnc_tty_flush_chars()
2451 *
2452 * Flush the cook buffer
2453 *
2454 * Note to self, and any other poor souls who venture here:
2455 *
2456 * flush in this case DOES NOT mean dispose of the data.
2457 * instead, it means "stop buffering and send it if you
2458 * haven't already." Just guess how I figured that out... SRW 2-Jun-98
2459 *
2460 * It is also always called in interrupt context - JAR 8-Sept-99
2461 */
dgnc_tty_flush_chars(struct tty_struct * tty)2462 static void dgnc_tty_flush_chars(struct tty_struct *tty)
2463 {
2464 struct dgnc_board *bd;
2465 struct channel_t *ch;
2466 struct un_t *un;
2467 unsigned long flags;
2468
2469 if (!tty || tty->magic != TTY_MAGIC)
2470 return;
2471
2472 un = tty->driver_data;
2473 if (!un || un->magic != DGNC_UNIT_MAGIC)
2474 return;
2475
2476 ch = un->un_ch;
2477 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2478 return;
2479
2480 bd = ch->ch_bd;
2481 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2482 return;
2483
2484 spin_lock_irqsave(&ch->ch_lock, flags);
2485
2486 /* Do something maybe here */
2487
2488 spin_unlock_irqrestore(&ch->ch_lock, flags);
2489 }
2490
2491 /*
2492 * dgnc_tty_flush_buffer()
2493 *
2494 * Flush Tx buffer (make in == out)
2495 */
dgnc_tty_flush_buffer(struct tty_struct * tty)2496 static void dgnc_tty_flush_buffer(struct tty_struct *tty)
2497 {
2498 struct channel_t *ch;
2499 struct un_t *un;
2500 unsigned long flags;
2501
2502 if (!tty || tty->magic != TTY_MAGIC)
2503 return;
2504
2505 un = tty->driver_data;
2506 if (!un || un->magic != DGNC_UNIT_MAGIC)
2507 return;
2508
2509 ch = un->un_ch;
2510 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2511 return;
2512
2513 spin_lock_irqsave(&ch->ch_lock, flags);
2514
2515 ch->ch_flags &= ~CH_STOP;
2516
2517 /* Flush our write queue */
2518 ch->ch_w_head = ch->ch_w_tail;
2519
2520 /* Flush UARTs transmit FIFO */
2521 ch->ch_bd->bd_ops->flush_uart_write(ch);
2522
2523 if (ch->ch_tun.un_flags & (UN_LOW|UN_EMPTY)) {
2524 ch->ch_tun.un_flags &= ~(UN_LOW|UN_EMPTY);
2525 wake_up_interruptible(&ch->ch_tun.un_flags_wait);
2526 }
2527 if (ch->ch_pun.un_flags & (UN_LOW|UN_EMPTY)) {
2528 ch->ch_pun.un_flags &= ~(UN_LOW|UN_EMPTY);
2529 wake_up_interruptible(&ch->ch_pun.un_flags_wait);
2530 }
2531
2532 spin_unlock_irqrestore(&ch->ch_lock, flags);
2533 }
2534
2535 /*****************************************************************************
2536 *
2537 * The IOCTL function and all of its helpers
2538 *
2539 *****************************************************************************/
2540
2541 /*
2542 * dgnc_tty_ioctl()
2543 *
2544 * The usual assortment of ioctl's
2545 */
dgnc_tty_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)2546 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
2547 unsigned long arg)
2548 {
2549 struct dgnc_board *bd;
2550 struct channel_t *ch;
2551 struct un_t *un;
2552 int rc;
2553 unsigned long flags;
2554 void __user *uarg = (void __user *)arg;
2555
2556 if (!tty || tty->magic != TTY_MAGIC)
2557 return -ENODEV;
2558
2559 un = tty->driver_data;
2560 if (!un || un->magic != DGNC_UNIT_MAGIC)
2561 return -ENODEV;
2562
2563 ch = un->un_ch;
2564 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
2565 return -ENODEV;
2566
2567 bd = ch->ch_bd;
2568 if (!bd || bd->magic != DGNC_BOARD_MAGIC)
2569 return -ENODEV;
2570
2571 spin_lock_irqsave(&ch->ch_lock, flags);
2572
2573 if (un->un_open_count <= 0) {
2574 spin_unlock_irqrestore(&ch->ch_lock, flags);
2575 return -EIO;
2576 }
2577
2578 switch (cmd) {
2579 /* Here are all the standard ioctl's that we MUST implement */
2580
2581 case TCSBRK:
2582 /*
2583 * TCSBRK is SVID version: non-zero arg --> no break
2584 * this behaviour is exploited by tcdrain().
2585 *
2586 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2587 * between 0.25 and 0.5 seconds so we'll ask for something
2588 * in the middle: 0.375 seconds.
2589 */
2590 rc = tty_check_change(tty);
2591 spin_unlock_irqrestore(&ch->ch_lock, flags);
2592 if (rc)
2593 return rc;
2594
2595 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2596
2597 if (rc)
2598 return -EINTR;
2599
2600 spin_lock_irqsave(&ch->ch_lock, flags);
2601
2602 if (((cmd == TCSBRK) && (!arg)) || (cmd == TCSBRKP))
2603 ch->ch_bd->bd_ops->send_break(ch, 250);
2604
2605 spin_unlock_irqrestore(&ch->ch_lock, flags);
2606
2607 return 0;
2608
2609 case TCSBRKP:
2610 /* support for POSIX tcsendbreak()
2611 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2612 * between 0.25 and 0.5 seconds so we'll ask for something
2613 * in the middle: 0.375 seconds.
2614 */
2615 rc = tty_check_change(tty);
2616 spin_unlock_irqrestore(&ch->ch_lock, flags);
2617 if (rc)
2618 return rc;
2619
2620 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2621 if (rc)
2622 return -EINTR;
2623
2624 spin_lock_irqsave(&ch->ch_lock, flags);
2625
2626 ch->ch_bd->bd_ops->send_break(ch, 250);
2627
2628 spin_unlock_irqrestore(&ch->ch_lock, flags);
2629
2630 return 0;
2631
2632 case TIOCSBRK:
2633 rc = tty_check_change(tty);
2634 spin_unlock_irqrestore(&ch->ch_lock, flags);
2635 if (rc)
2636 return rc;
2637
2638 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2639 if (rc)
2640 return -EINTR;
2641
2642 spin_lock_irqsave(&ch->ch_lock, flags);
2643
2644 ch->ch_bd->bd_ops->send_break(ch, 250);
2645
2646 spin_unlock_irqrestore(&ch->ch_lock, flags);
2647
2648 return 0;
2649
2650 case TIOCCBRK:
2651 /* Do Nothing */
2652 spin_unlock_irqrestore(&ch->ch_lock, flags);
2653 return 0;
2654
2655 case TIOCGSOFTCAR:
2656
2657 spin_unlock_irqrestore(&ch->ch_lock, flags);
2658
2659 rc = put_user(C_CLOCAL(tty) ? 1 : 0,
2660 (unsigned long __user *)arg);
2661 return rc;
2662
2663 case TIOCSSOFTCAR:
2664
2665 spin_unlock_irqrestore(&ch->ch_lock, flags);
2666 rc = get_user(arg, (unsigned long __user *)arg);
2667 if (rc)
2668 return rc;
2669
2670 spin_lock_irqsave(&ch->ch_lock, flags);
2671 tty->termios.c_cflag = ((tty->termios.c_cflag & ~CLOCAL) |
2672 (arg ? CLOCAL : 0));
2673 ch->ch_bd->bd_ops->param(tty);
2674 spin_unlock_irqrestore(&ch->ch_lock, flags);
2675
2676 return 0;
2677
2678 case TIOCMGET:
2679 spin_unlock_irqrestore(&ch->ch_lock, flags);
2680 return dgnc_get_modem_info(ch, uarg);
2681
2682 case TIOCMBIS:
2683 case TIOCMBIC:
2684 case TIOCMSET:
2685 spin_unlock_irqrestore(&ch->ch_lock, flags);
2686 return dgnc_set_modem_info(tty, cmd, uarg);
2687
2688 /*
2689 * Here are any additional ioctl's that we want to implement
2690 */
2691
2692 case TCFLSH:
2693 /*
2694 * The linux tty driver doesn't have a flush
2695 * input routine for the driver, assuming all backed
2696 * up data is in the line disc. buffers. However,
2697 * we all know that's not the case. Here, we
2698 * act on the ioctl, but then lie and say we didn't
2699 * so the line discipline will process the flush
2700 * also.
2701 */
2702 rc = tty_check_change(tty);
2703 if (rc) {
2704 spin_unlock_irqrestore(&ch->ch_lock, flags);
2705 return rc;
2706 }
2707
2708 if ((arg == TCIFLUSH) || (arg == TCIOFLUSH)) {
2709 ch->ch_r_head = ch->ch_r_tail;
2710 ch->ch_bd->bd_ops->flush_uart_read(ch);
2711 /* Force queue flow control to be released, if needed */
2712 dgnc_check_queue_flow_control(ch);
2713 }
2714
2715 if ((arg == TCOFLUSH) || (arg == TCIOFLUSH)) {
2716 if (!(un->un_type == DGNC_PRINT)) {
2717 ch->ch_w_head = ch->ch_w_tail;
2718 ch->ch_bd->bd_ops->flush_uart_write(ch);
2719
2720 if (ch->ch_tun.un_flags & (UN_LOW|UN_EMPTY)) {
2721 ch->ch_tun.un_flags &=
2722 ~(UN_LOW|UN_EMPTY);
2723 wake_up_interruptible(&ch->ch_tun.un_flags_wait);
2724 }
2725
2726 if (ch->ch_pun.un_flags & (UN_LOW|UN_EMPTY)) {
2727 ch->ch_pun.un_flags &=
2728 ~(UN_LOW|UN_EMPTY);
2729 wake_up_interruptible(&ch->ch_pun.un_flags_wait);
2730 }
2731 }
2732 }
2733
2734 /* pretend we didn't recognize this IOCTL */
2735 spin_unlock_irqrestore(&ch->ch_lock, flags);
2736 return -ENOIOCTLCMD;
2737 case TCSETSF:
2738 case TCSETSW:
2739 /*
2740 * The linux tty driver doesn't have a flush
2741 * input routine for the driver, assuming all backed
2742 * up data is in the line disc. buffers. However,
2743 * we all know that's not the case. Here, we
2744 * act on the ioctl, but then lie and say we didn't
2745 * so the line discipline will process the flush
2746 * also.
2747 */
2748 if (cmd == TCSETSF) {
2749 /* flush rx */
2750 ch->ch_flags &= ~CH_STOP;
2751 ch->ch_r_head = ch->ch_r_tail;
2752 ch->ch_bd->bd_ops->flush_uart_read(ch);
2753 /* Force queue flow control to be released, if needed */
2754 dgnc_check_queue_flow_control(ch);
2755 }
2756
2757 /* now wait for all the output to drain */
2758 spin_unlock_irqrestore(&ch->ch_lock, flags);
2759 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2760 if (rc)
2761 return -EINTR;
2762
2763 /* pretend we didn't recognize this */
2764 return -ENOIOCTLCMD;
2765
2766 case TCSETAW:
2767
2768 spin_unlock_irqrestore(&ch->ch_lock, flags);
2769 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2770 if (rc)
2771 return -EINTR;
2772
2773 /* pretend we didn't recognize this */
2774 return -ENOIOCTLCMD;
2775
2776 case TCXONC:
2777 spin_unlock_irqrestore(&ch->ch_lock, flags);
2778 /* Make the ld do it */
2779 return -ENOIOCTLCMD;
2780
2781 case DIGI_GETA:
2782 /* get information for ditty */
2783 spin_unlock_irqrestore(&ch->ch_lock, flags);
2784 return dgnc_tty_digigeta(tty, uarg);
2785
2786 case DIGI_SETAW:
2787 case DIGI_SETAF:
2788
2789 /* set information for ditty */
2790 if (cmd == (DIGI_SETAW)) {
2791 spin_unlock_irqrestore(&ch->ch_lock, flags);
2792 rc = ch->ch_bd->bd_ops->drain(tty, 0);
2793
2794 if (rc)
2795 return -EINTR;
2796
2797 spin_lock_irqsave(&ch->ch_lock, flags);
2798 } else {
2799 tty_ldisc_flush(tty);
2800 }
2801 /* fall thru */
2802
2803 case DIGI_SETA:
2804 spin_unlock_irqrestore(&ch->ch_lock, flags);
2805 return dgnc_tty_digiseta(tty, uarg);
2806
2807 case DIGI_LOOPBACK:
2808 {
2809 uint loopback = 0;
2810 /* Let go of locks when accessing user space,
2811 * could sleep
2812 */
2813 spin_unlock_irqrestore(&ch->ch_lock, flags);
2814 rc = get_user(loopback, (unsigned int __user *)arg);
2815 if (rc)
2816 return rc;
2817 spin_lock_irqsave(&ch->ch_lock, flags);
2818
2819 /* Enable/disable internal loopback for this port */
2820 if (loopback)
2821 ch->ch_flags |= CH_LOOPBACK;
2822 else
2823 ch->ch_flags &= ~(CH_LOOPBACK);
2824
2825 ch->ch_bd->bd_ops->param(tty);
2826 spin_unlock_irqrestore(&ch->ch_lock, flags);
2827 return 0;
2828 }
2829
2830 case DIGI_GETCUSTOMBAUD:
2831 spin_unlock_irqrestore(&ch->ch_lock, flags);
2832 rc = put_user(ch->ch_custom_speed, (unsigned int __user *)arg);
2833 return rc;
2834
2835 case DIGI_SETCUSTOMBAUD:
2836 {
2837 int new_rate;
2838 /* Let go of locks when accessing user space, could sleep */
2839 spin_unlock_irqrestore(&ch->ch_lock, flags);
2840 rc = get_user(new_rate, (int __user *)arg);
2841 if (rc)
2842 return rc;
2843 spin_lock_irqsave(&ch->ch_lock, flags);
2844 dgnc_set_custom_speed(ch, new_rate);
2845 ch->ch_bd->bd_ops->param(tty);
2846 spin_unlock_irqrestore(&ch->ch_lock, flags);
2847 return 0;
2848 }
2849
2850 /*
2851 * This ioctl allows insertion of a character into the front
2852 * of any pending data to be transmitted.
2853 *
2854 * This ioctl is to satify the "Send Character Immediate"
2855 * call that the RealPort protocol spec requires.
2856 */
2857 case DIGI_REALPORT_SENDIMMEDIATE:
2858 {
2859 unsigned char c;
2860
2861 spin_unlock_irqrestore(&ch->ch_lock, flags);
2862 rc = get_user(c, (unsigned char __user *)arg);
2863 if (rc)
2864 return rc;
2865 spin_lock_irqsave(&ch->ch_lock, flags);
2866 ch->ch_bd->bd_ops->send_immediate_char(ch, c);
2867 spin_unlock_irqrestore(&ch->ch_lock, flags);
2868 return 0;
2869 }
2870
2871 /*
2872 * This ioctl returns all the current counts for the port.
2873 *
2874 * This ioctl is to satify the "Line Error Counters"
2875 * call that the RealPort protocol spec requires.
2876 */
2877 case DIGI_REALPORT_GETCOUNTERS:
2878 {
2879 struct digi_getcounter buf;
2880
2881 buf.norun = ch->ch_err_overrun;
2882 buf.noflow = 0; /* The driver doesn't keep this stat */
2883 buf.nframe = ch->ch_err_frame;
2884 buf.nparity = ch->ch_err_parity;
2885 buf.nbreak = ch->ch_err_break;
2886 buf.rbytes = ch->ch_rxcount;
2887 buf.tbytes = ch->ch_txcount;
2888
2889 spin_unlock_irqrestore(&ch->ch_lock, flags);
2890
2891 if (copy_to_user(uarg, &buf, sizeof(buf)))
2892 return -EFAULT;
2893
2894 return 0;
2895 }
2896
2897 /*
2898 * This ioctl returns all current events.
2899 *
2900 * This ioctl is to satify the "Event Reporting"
2901 * call that the RealPort protocol spec requires.
2902 */
2903 case DIGI_REALPORT_GETEVENTS:
2904 {
2905 unsigned int events = 0;
2906
2907 /* NOTE: MORE EVENTS NEEDS TO BE ADDED HERE */
2908 if (ch->ch_flags & CH_BREAK_SENDING)
2909 events |= EV_TXB;
2910 if ((ch->ch_flags & CH_STOP) ||
2911 (ch->ch_flags & CH_FORCED_STOP))
2912 events |= (EV_OPU | EV_OPS);
2913
2914 if ((ch->ch_flags & CH_STOPI) ||
2915 (ch->ch_flags & CH_FORCED_STOPI))
2916 events |= (EV_IPU | EV_IPS);
2917
2918 spin_unlock_irqrestore(&ch->ch_lock, flags);
2919 rc = put_user(events, (unsigned int __user *)arg);
2920 return rc;
2921 }
2922
2923 /*
2924 * This ioctl returns TOUT and TIN counters based
2925 * upon the values passed in by the RealPort Server.
2926 * It also passes back whether the UART Transmitter is
2927 * empty as well.
2928 */
2929 case DIGI_REALPORT_GETBUFFERS:
2930 {
2931 struct digi_getbuffer buf;
2932 int tdist;
2933 int count;
2934
2935 spin_unlock_irqrestore(&ch->ch_lock, flags);
2936
2937 /*
2938 * Get data from user first.
2939 */
2940 if (copy_from_user(&buf, uarg, sizeof(buf)))
2941 return -EFAULT;
2942
2943 spin_lock_irqsave(&ch->ch_lock, flags);
2944
2945 /*
2946 * Figure out how much data is in our RX and TX queues.
2947 */
2948 buf.rxbuf = (ch->ch_r_head - ch->ch_r_tail) & RQUEUEMASK;
2949 buf.txbuf = (ch->ch_w_head - ch->ch_w_tail) & WQUEUEMASK;
2950
2951 /*
2952 * Is the UART empty? Add that value to whats in our TX queue.
2953 */
2954 count = buf.txbuf + ch->ch_bd->bd_ops->get_uart_bytes_left(ch);
2955
2956 /*
2957 * Figure out how much data the RealPort Server believes should
2958 * be in our TX queue.
2959 */
2960 tdist = (buf.tIn - buf.tOut) & 0xffff;
2961
2962 /*
2963 * If we have more data than the RealPort Server believes we
2964 * should have, reduce our count to its amount.
2965 *
2966 * This count difference CAN happen because the Linux LD can
2967 * insert more characters into our queue for OPOST processing
2968 * that the RealPort Server doesn't know about.
2969 */
2970 if (buf.txbuf > tdist)
2971 buf.txbuf = tdist;
2972
2973 /*
2974 * Report whether our queue and UART TX are completely empty.
2975 */
2976 if (count)
2977 buf.txdone = 0;
2978 else
2979 buf.txdone = 1;
2980
2981 spin_unlock_irqrestore(&ch->ch_lock, flags);
2982
2983 if (copy_to_user(uarg, &buf, sizeof(buf)))
2984 return -EFAULT;
2985
2986 return 0;
2987 }
2988 default:
2989 spin_unlock_irqrestore(&ch->ch_lock, flags);
2990
2991 return -ENOIOCTLCMD;
2992 }
2993 }
2994