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