jsm_tty.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/************************************************************************
  3 * Copyright 2003 Digi International (www.digi.com)
  4 *
  5 * Copyright (C) 2004 IBM Corporation. All rights reserved.
  6 *
  7 * Contact Information:
  8 * Scott H Kilau <Scott_Kilau@digi.com>
  9 * Ananda Venkatarman <mansarov@us.ibm.com>
 10 * Modifications:
 11 * 01/19/06:	changed jsm_input routine to use the dynamically allocated
 12 *		tty_buffer changes. Contributors: Scott Kilau and Ananda V.
 13 ***********************************************************************/
 14#include <linux/tty.h>
 15#include <linux/tty_flip.h>
 16#include <linux/serial_reg.h>
 17#include <linux/delay.h>	/* For udelay */
 18#include <linux/pci.h>
 19#include <linux/slab.h>
 20
 21#include "jsm.h"
 22
 23static DECLARE_BITMAP(linemap, MAXLINES);
 24
 25static void jsm_carrier(struct jsm_channel *ch);
 26
 27static inline int jsm_get_mstat(struct jsm_channel *ch)
 28{
 29	unsigned char mstat;
 30	int result;
 31
 32	jsm_dbg(IOCTL, &ch->ch_bd->pci_dev, "start\n");
 33
 34	mstat = (ch->ch_mostat | ch->ch_mistat);
 35
 36	result = 0;
 37
 38	if (mstat & UART_MCR_DTR)
 39		result |= TIOCM_DTR;
 40	if (mstat & UART_MCR_RTS)
 41		result |= TIOCM_RTS;
 42	if (mstat & UART_MSR_CTS)
 43		result |= TIOCM_CTS;
 44	if (mstat & UART_MSR_DSR)
 45		result |= TIOCM_DSR;
 46	if (mstat & UART_MSR_RI)
 47		result |= TIOCM_RI;
 48	if (mstat & UART_MSR_DCD)
 49		result |= TIOCM_CD;
 50
 51	jsm_dbg(IOCTL, &ch->ch_bd->pci_dev, "finish\n");
 52	return result;
 53}
 54
 55static unsigned int jsm_tty_tx_empty(struct uart_port *port)
 56{
 57	return TIOCSER_TEMT;
 58}
 59
 60/*
 61 * Return modem signals to ld.
 62 */
 63static unsigned int jsm_tty_get_mctrl(struct uart_port *port)
 64{
 65	int result;
 66	struct jsm_channel *channel =
 67		container_of(port, struct jsm_channel, uart_port);
 68
 69	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
 70
 71	result = jsm_get_mstat(channel);
 72
 73	if (result < 0)
 74		return -ENXIO;
 75
 76	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "finish\n");
 77
 78	return result;
 79}
 80
 81/*
 82 * jsm_set_modem_info()
 83 *
 84 * Set modem signals, called by ld.
 85 */
 86static void jsm_tty_set_mctrl(struct uart_port *port, unsigned int mctrl)
 87{
 88	struct jsm_channel *channel =
 89		container_of(port, struct jsm_channel, uart_port);
 90
 91	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
 92
 93	if (mctrl & TIOCM_RTS)
 94		channel->ch_mostat |= UART_MCR_RTS;
 95	else
 96		channel->ch_mostat &= ~UART_MCR_RTS;
 97
 98	if (mctrl & TIOCM_DTR)
 99		channel->ch_mostat |= UART_MCR_DTR;
100	else
101		channel->ch_mostat &= ~UART_MCR_DTR;
102
103	channel->ch_bd->bd_ops->assert_modem_signals(channel);
104
105	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "finish\n");
106	udelay(10);
107}
108
109/*
110 * jsm_tty_write()
111 *
112 * Take data from the user or kernel and send it out to the FEP.
113 * In here exists all the Transparent Print magic as well.
114 */
115static void jsm_tty_write(struct uart_port *port)
116{
117	struct jsm_channel *channel;
118
119	channel = container_of(port, struct jsm_channel, uart_port);
120	channel->ch_bd->bd_ops->copy_data_from_queue_to_uart(channel);
121}
122
123static void jsm_tty_start_tx(struct uart_port *port)
124{
125	struct jsm_channel *channel =
126		container_of(port, struct jsm_channel, uart_port);
127
128	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
129
130	channel->ch_flags &= ~(CH_STOP);
131	jsm_tty_write(port);
132
133	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "finish\n");
134}
135
136static void jsm_tty_stop_tx(struct uart_port *port)
137{
138	struct jsm_channel *channel =
139		container_of(port, struct jsm_channel, uart_port);
140
141	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
142
143	channel->ch_flags |= (CH_STOP);
144
145	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "finish\n");
146}
147
148static void jsm_tty_send_xchar(struct uart_port *port, char ch)
149{
150	unsigned long lock_flags;
151	struct jsm_channel *channel =
152		container_of(port, struct jsm_channel, uart_port);
153	struct ktermios *termios;
154
155	uart_port_lock_irqsave(port, &lock_flags);
156	termios = &port->state->port.tty->termios;
157	if (ch == termios->c_cc[VSTART])
158		channel->ch_bd->bd_ops->send_start_character(channel);
159
160	if (ch == termios->c_cc[VSTOP])
161		channel->ch_bd->bd_ops->send_stop_character(channel);
162	uart_port_unlock_irqrestore(port, lock_flags);
163}
164
165static void jsm_tty_stop_rx(struct uart_port *port)
166{
167	struct jsm_channel *channel =
168		container_of(port, struct jsm_channel, uart_port);
169
170	channel->ch_bd->bd_ops->disable_receiver(channel);
171}
172
173static void jsm_tty_break(struct uart_port *port, int break_state)
174{
175	unsigned long lock_flags;
176	struct jsm_channel *channel =
177		container_of(port, struct jsm_channel, uart_port);
178
179	uart_port_lock_irqsave(port, &lock_flags);
180	if (break_state == -1)
181		channel->ch_bd->bd_ops->send_break(channel);
182	else
183		channel->ch_bd->bd_ops->clear_break(channel);
184
185	uart_port_unlock_irqrestore(port, lock_flags);
186}
187
188static int jsm_tty_open(struct uart_port *port)
189{
190	unsigned long lock_flags;
191	struct jsm_board *brd;
192	struct jsm_channel *channel =
193		container_of(port, struct jsm_channel, uart_port);
194	struct ktermios *termios;
195
196	/* Get board pointer from our array of majors we have allocated */
197	brd = channel->ch_bd;
198
199	/*
200	 * Allocate channel buffers for read/write/error.
201	 * Set flag, so we don't get trounced on.
202	 */
203	channel->ch_flags |= (CH_OPENING);
204
205	/* Drop locks, as malloc with GFP_KERNEL can sleep */
206
207	if (!channel->ch_rqueue) {
208		channel->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
209		if (!channel->ch_rqueue) {
210			jsm_dbg(INIT, &channel->ch_bd->pci_dev,
211				"unable to allocate read queue buf\n");
212			return -ENOMEM;
213		}
214	}
215	if (!channel->ch_equeue) {
216		channel->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
217		if (!channel->ch_equeue) {
218			jsm_dbg(INIT, &channel->ch_bd->pci_dev,
219				"unable to allocate error queue buf\n");
220			return -ENOMEM;
221		}
222	}
223
224	channel->ch_flags &= ~(CH_OPENING);
225	/*
226	 * Initialize if neither terminal is open.
227	 */
228	jsm_dbg(OPEN, &channel->ch_bd->pci_dev,
229		"jsm_open: initializing channel in open...\n");
230
231	/*
232	 * Flush input queues.
233	 */
234	channel->ch_r_head = channel->ch_r_tail = 0;
235	channel->ch_e_head = channel->ch_e_tail = 0;
236
237	brd->bd_ops->flush_uart_write(channel);
238	brd->bd_ops->flush_uart_read(channel);
239
240	channel->ch_flags = 0;
241	channel->ch_cached_lsr = 0;
242	channel->ch_stops_sent = 0;
243
244	uart_port_lock_irqsave(port, &lock_flags);
245	termios = &port->state->port.tty->termios;
246	channel->ch_c_cflag	= termios->c_cflag;
247	channel->ch_c_iflag	= termios->c_iflag;
248	channel->ch_c_oflag	= termios->c_oflag;
249	channel->ch_c_lflag	= termios->c_lflag;
250	channel->ch_startc	= termios->c_cc[VSTART];
251	channel->ch_stopc	= termios->c_cc[VSTOP];
252
253	/* Tell UART to init itself */
254	brd->bd_ops->uart_init(channel);
255
256	/*
257	 * Run param in case we changed anything
258	 */
259	brd->bd_ops->param(channel);
260
261	jsm_carrier(channel);
262
263	channel->ch_open_count++;
264	uart_port_unlock_irqrestore(port, lock_flags);
265
266	jsm_dbg(OPEN, &channel->ch_bd->pci_dev, "finish\n");
267	return 0;
268}
269
270static void jsm_tty_close(struct uart_port *port)
271{
272	struct jsm_board *bd;
273	struct jsm_channel *channel =
274		container_of(port, struct jsm_channel, uart_port);
275
276	jsm_dbg(CLOSE, &channel->ch_bd->pci_dev, "start\n");
277
278	bd = channel->ch_bd;
279
280	channel->ch_flags &= ~(CH_STOPI);
281
282	channel->ch_open_count--;
283
284	/*
285	 * If we have HUPCL set, lower DTR and RTS
286	 */
287	if (channel->ch_c_cflag & HUPCL) {
288		jsm_dbg(CLOSE, &channel->ch_bd->pci_dev,
289			"Close. HUPCL set, dropping DTR/RTS\n");
290
291		/* Drop RTS/DTR */
292		channel->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS);
293		bd->bd_ops->assert_modem_signals(channel);
294	}
295
296	/* Turn off UART interrupts for this port */
297	channel->ch_bd->bd_ops->uart_off(channel);
298
299	jsm_dbg(CLOSE, &channel->ch_bd->pci_dev, "finish\n");
300}
301
302static void jsm_tty_set_termios(struct uart_port *port,
303				struct ktermios *termios,
304				const struct ktermios *old_termios)
305{
306	unsigned long lock_flags;
307	struct jsm_channel *channel =
308		container_of(port, struct jsm_channel, uart_port);
309
310	uart_port_lock_irqsave(port, &lock_flags);
311	channel->ch_c_cflag	= termios->c_cflag;
312	channel->ch_c_iflag	= termios->c_iflag;
313	channel->ch_c_oflag	= termios->c_oflag;
314	channel->ch_c_lflag	= termios->c_lflag;
315	channel->ch_startc	= termios->c_cc[VSTART];
316	channel->ch_stopc	= termios->c_cc[VSTOP];
317
318	channel->ch_bd->bd_ops->param(channel);
319	jsm_carrier(channel);
320	uart_port_unlock_irqrestore(port, lock_flags);
321}
322
323static const char *jsm_tty_type(struct uart_port *port)
324{
325	return "jsm";
326}
327
328static void jsm_tty_release_port(struct uart_port *port)
329{
330}
331
332static int jsm_tty_request_port(struct uart_port *port)
333{
334	return 0;
335}
336
337static void jsm_config_port(struct uart_port *port, int flags)
338{
339	port->type = PORT_JSM;
340}
341
342static const struct uart_ops jsm_ops = {
343	.tx_empty	= jsm_tty_tx_empty,
344	.set_mctrl	= jsm_tty_set_mctrl,
345	.get_mctrl	= jsm_tty_get_mctrl,
346	.stop_tx	= jsm_tty_stop_tx,
347	.start_tx	= jsm_tty_start_tx,
348	.send_xchar	= jsm_tty_send_xchar,
349	.stop_rx	= jsm_tty_stop_rx,
350	.break_ctl	= jsm_tty_break,
351	.startup	= jsm_tty_open,
352	.shutdown	= jsm_tty_close,
353	.set_termios	= jsm_tty_set_termios,
354	.type		= jsm_tty_type,
355	.release_port	= jsm_tty_release_port,
356	.request_port	= jsm_tty_request_port,
357	.config_port	= jsm_config_port,
358};
359
360/*
361 * jsm_tty_init()
362 *
363 * Init the tty subsystem.  Called once per board after board has been
364 * downloaded and init'ed.
365 */
366int jsm_tty_init(struct jsm_board *brd)
367{
368	int i;
369	void __iomem *vaddr;
370	struct jsm_channel *ch;
371
372	if (!brd)
373		return -ENXIO;
374
375	jsm_dbg(INIT, &brd->pci_dev, "start\n");
376
377	/*
378	 * Initialize board structure elements.
379	 */
380
381	brd->nasync = brd->maxports;
382
383	/*
384	 * Allocate channel memory that might not have been allocated
385	 * when the driver was first loaded.
386	 */
387	for (i = 0; i < brd->nasync; i++) {
388		if (!brd->channels[i]) {
389
390			/*
391			 * Okay to malloc with GFP_KERNEL, we are not at
392			 * interrupt context, and there are no locks held.
393			 */
394			brd->channels[i] = kzalloc(sizeof(struct jsm_channel), GFP_KERNEL);
395			if (!brd->channels[i]) {
396				jsm_dbg(CORE, &brd->pci_dev,
397					"%s:%d Unable to allocate memory for channel struct\n",
398					__FILE__, __LINE__);
399			}
400		}
401	}
402
403	ch = brd->channels[0];
404	vaddr = brd->re_map_membase;
405
406	/* Set up channel variables */
407	for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
408
409		if (!brd->channels[i])
410			continue;
411
412		spin_lock_init(&ch->ch_lock);
413
414		if (brd->bd_uart_offset == 0x200)
415			ch->ch_neo_uart =  vaddr + (brd->bd_uart_offset * i);
416		else
417			ch->ch_cls_uart =  vaddr + (brd->bd_uart_offset * i);
418
419		ch->ch_bd = brd;
420		ch->ch_portnum = i;
421
422		/* .25 second delay */
423		ch->ch_close_delay = 250;
424
425		init_waitqueue_head(&ch->ch_flags_wait);
426	}
427
428	jsm_dbg(INIT, &brd->pci_dev, "finish\n");
429	return 0;
430}
431
432int jsm_uart_port_init(struct jsm_board *brd)
433{
434	int i, rc;
435	unsigned int line;
436
437	if (!brd)
438		return -ENXIO;
439
440	jsm_dbg(INIT, &brd->pci_dev, "start\n");
441
442	/*
443	 * Initialize board structure elements.
444	 */
445
446	brd->nasync = brd->maxports;
447
448	/* Set up channel variables */
449	for (i = 0; i < brd->nasync; i++) {
450
451		if (!brd->channels[i])
452			continue;
453
454		brd->channels[i]->uart_port.dev = &brd->pci_dev->dev;
455		brd->channels[i]->uart_port.irq = brd->irq;
456		brd->channels[i]->uart_port.uartclk = 14745600;
457		brd->channels[i]->uart_port.type = PORT_JSM;
458		brd->channels[i]->uart_port.iotype = UPIO_MEM;
459		brd->channels[i]->uart_port.membase = brd->re_map_membase;
460		brd->channels[i]->uart_port.fifosize = 16;
461		brd->channels[i]->uart_port.ops = &jsm_ops;
462		line = find_first_zero_bit(linemap, MAXLINES);
463		if (line >= MAXLINES) {
464			printk(KERN_INFO "jsm: linemap is full, added device failed\n");
465			continue;
466		} else
467			set_bit(line, linemap);
468		brd->channels[i]->uart_port.line = line;
469		rc = uart_add_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
470		if (rc) {
471			printk(KERN_INFO "jsm: Port %d failed. Aborting...\n", i);
472			return rc;
473		} else
474			printk(KERN_INFO "jsm: Port %d added\n", i);
475	}
476
477	jsm_dbg(INIT, &brd->pci_dev, "finish\n");
478	return 0;
479}
480
481int jsm_remove_uart_port(struct jsm_board *brd)
482{
483	int i;
484	struct jsm_channel *ch;
485
486	if (!brd)
487		return -ENXIO;
488
489	jsm_dbg(INIT, &brd->pci_dev, "start\n");
490
491	/*
492	 * Initialize board structure elements.
493	 */
494
495	brd->nasync = brd->maxports;
496
497	/* Set up channel variables */
498	for (i = 0; i < brd->nasync; i++) {
499
500		if (!brd->channels[i])
501			continue;
502
503		ch = brd->channels[i];
504
505		clear_bit(ch->uart_port.line, linemap);
506		uart_remove_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
507	}
508
509	jsm_dbg(INIT, &brd->pci_dev, "finish\n");
510	return 0;
511}
512
513void jsm_input(struct jsm_channel *ch)
514{
515	struct jsm_board *bd;
516	struct tty_struct *tp;
517	struct tty_port *port;
518	u32 rmask;
519	u16 head;
520	u16 tail;
521	int data_len;
522	unsigned long lock_flags;
523	int len = 0;
524	int s = 0;
525	int i = 0;
526
527	jsm_dbg(READ, &ch->ch_bd->pci_dev, "start\n");
528
529	port = &ch->uart_port.state->port;
530	tp = port->tty;
531
532	bd = ch->ch_bd;
533	if (!bd)
534		return;
535
536	spin_lock_irqsave(&ch->ch_lock, lock_flags);
537
538	/*
539	 *Figure the number of characters in the buffer.
540	 *Exit immediately if none.
541	 */
542
543	rmask = RQUEUEMASK;
544
545	head = ch->ch_r_head & rmask;
546	tail = ch->ch_r_tail & rmask;
547
548	data_len = (head - tail) & rmask;
549	if (data_len == 0) {
550		spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
551		return;
552	}
553
554	jsm_dbg(READ, &ch->ch_bd->pci_dev, "start\n");
555
556	/*
557	 *If the device is not open, or CREAD is off, flush
558	 *input data and return immediately.
559	 */
560	if (!tp || !C_CREAD(tp)) {
561
562		jsm_dbg(READ, &ch->ch_bd->pci_dev,
563			"input. dropping %d bytes on port %d...\n",
564			data_len, ch->ch_portnum);
565		ch->ch_r_head = tail;
566
567		/* Force queue flow control to be released, if needed */
568		jsm_check_queue_flow_control(ch);
569
570		spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
571		return;
572	}
573
574	/*
575	 * If we are throttled, simply don't read any data.
576	 */
577	if (ch->ch_flags & CH_STOPI) {
578		spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
579		jsm_dbg(READ, &ch->ch_bd->pci_dev,
580			"Port %d throttled, not reading any data. head: %x tail: %x\n",
581			ch->ch_portnum, head, tail);
582		return;
583	}
584
585	jsm_dbg(READ, &ch->ch_bd->pci_dev, "start 2\n");
586
587	len = tty_buffer_request_room(port, data_len);
588
589	/*
590	 * len now contains the most amount of data we can copy,
591	 * bounded either by the flip buffer size or the amount
592	 * of data the card actually has pending...
593	 */
594	while (len) {
595		s = ((head >= tail) ? head : RQUEUESIZE) - tail;
596		s = min(s, len);
597
598		if (s <= 0)
599			break;
600
601			/*
602			 * If conditions are such that ld needs to see all
603			 * UART errors, we will have to walk each character
604			 * and error byte and send them to the buffer one at
605			 * a time.
606			 */
607
608		if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
609			for (i = 0; i < s; i++) {
610				u8 chr   = ch->ch_rqueue[tail + i];
611				u8 error = ch->ch_equeue[tail + i];
612				char flag = TTY_NORMAL;
613
614				/*
615				 * Give the Linux ld the flags in the format it
616				 * likes.
617				 */
618				if (error & UART_LSR_BI)
619					flag = TTY_BREAK;
620				else if (error & UART_LSR_PE)
621					flag = TTY_PARITY;
622				else if (error & UART_LSR_FE)
623					flag = TTY_FRAME;
624
625				tty_insert_flip_char(port, chr, flag);
626			}
627		} else {
628			tty_insert_flip_string(port, ch->ch_rqueue + tail, s);
629		}
630		tail += s;
631		len -= s;
632		/* Flip queue if needed */
633		tail &= rmask;
634	}
635
636	ch->ch_r_tail = tail & rmask;
637	ch->ch_e_tail = tail & rmask;
638	jsm_check_queue_flow_control(ch);
639	spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
640
641	/* Tell the tty layer its okay to "eat" the data now */
642	tty_flip_buffer_push(port);
643
644	jsm_dbg(IOCTL, &ch->ch_bd->pci_dev, "finish\n");
645}
646
647static void jsm_carrier(struct jsm_channel *ch)
648{
649	struct jsm_board *bd;
650
651	int virt_carrier = 0;
652	int phys_carrier = 0;
653
654	jsm_dbg(CARR, &ch->ch_bd->pci_dev, "start\n");
655
656	bd = ch->ch_bd;
657	if (!bd)
658		return;
659
660	if (ch->ch_mistat & UART_MSR_DCD) {
661		jsm_dbg(CARR, &ch->ch_bd->pci_dev, "mistat: %x D_CD: %x\n",
662			ch->ch_mistat, ch->ch_mistat & UART_MSR_DCD);
663		phys_carrier = 1;
664	}
665
666	if (ch->ch_c_cflag & CLOCAL)
667		virt_carrier = 1;
668
669	jsm_dbg(CARR, &ch->ch_bd->pci_dev, "DCD: physical: %d virt: %d\n",
670		phys_carrier, virt_carrier);
671
672	/*
673	 * Test for a VIRTUAL carrier transition to HIGH.
674	 */
675	if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) {
676
677		/*
678		 * When carrier rises, wake any threads waiting
679		 * for carrier in the open routine.
680		 */
681
682		jsm_dbg(CARR, &ch->ch_bd->pci_dev, "carrier: virt DCD rose\n");
683
684		if (waitqueue_active(&(ch->ch_flags_wait)))
685			wake_up_interruptible(&ch->ch_flags_wait);
686	}
687
688	/*
689	 * Test for a PHYSICAL carrier transition to HIGH.
690	 */
691	if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) {
692
693		/*
694		 * When carrier rises, wake any threads waiting
695		 * for carrier in the open routine.
696		 */
697
698		jsm_dbg(CARR, &ch->ch_bd->pci_dev,
699			"carrier: physical DCD rose\n");
700
701		if (waitqueue_active(&(ch->ch_flags_wait)))
702			wake_up_interruptible(&ch->ch_flags_wait);
703	}
704
705	/*
706	 *  Test for a PHYSICAL transition to low, so long as we aren't
707	 *  currently ignoring physical transitions (which is what "virtual
708	 *  carrier" indicates).
709	 *
710	 *  The transition of the virtual carrier to low really doesn't
711	 *  matter... it really only means "ignore carrier state", not
712	 *  "make pretend that carrier is there".
713	 */
714	if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0)
715			&& (phys_carrier == 0)) {
716		/*
717		 *	When carrier drops:
718		 *
719		 *	Drop carrier on all open units.
720		 *
721		 *	Flush queues, waking up any task waiting in the
722		 *	line discipline.
723		 *
724		 *	Send a hangup to the control terminal.
725		 *
726		 *	Enable all select calls.
727		 */
728		if (waitqueue_active(&(ch->ch_flags_wait)))
729			wake_up_interruptible(&ch->ch_flags_wait);
730	}
731
732	/*
733	 *  Make sure that our cached values reflect the current reality.
734	 */
735	if (virt_carrier == 1)
736		ch->ch_flags |= CH_FCAR;
737	else
738		ch->ch_flags &= ~CH_FCAR;
739
740	if (phys_carrier == 1)
741		ch->ch_flags |= CH_CD;
742	else
743		ch->ch_flags &= ~CH_CD;
744}
745
746
747void jsm_check_queue_flow_control(struct jsm_channel *ch)
748{
749	struct board_ops *bd_ops = ch->ch_bd->bd_ops;
750	int qleft;
751
752	/* Store how much space we have left in the queue */
753	qleft = ch->ch_r_tail - ch->ch_r_head - 1;
754	if (qleft < 0)
755		qleft += RQUEUEMASK + 1;
756
757	/*
758	 * Check to see if we should enforce flow control on our queue because
759	 * the ld (or user) isn't reading data out of our queue fast enuf.
760	 *
761	 * NOTE: This is done based on what the current flow control of the
762	 * port is set for.
763	 *
764	 * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt.
765	 *	This will cause the UART's FIFO to back up, and force
766	 *	the RTS signal to be dropped.
767	 * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to
768	 *	the other side, in hopes it will stop sending data to us.
769	 * 3) NONE - Nothing we can do.  We will simply drop any extra data
770	 *	that gets sent into us when the queue fills up.
771	 */
772	if (qleft < 256) {
773		/* HWFLOW */
774		if (ch->ch_c_cflag & CRTSCTS) {
775			if (!(ch->ch_flags & CH_RECEIVER_OFF)) {
776				bd_ops->disable_receiver(ch);
777				ch->ch_flags |= (CH_RECEIVER_OFF);
778				jsm_dbg(READ, &ch->ch_bd->pci_dev,
779					"Internal queue hit hilevel mark (%d)! Turning off interrupts\n",
780					qleft);
781			}
782		}
783		/* SWFLOW */
784		else if (ch->ch_c_iflag & IXOFF) {
785			if (ch->ch_stops_sent <= MAX_STOPS_SENT) {
786				bd_ops->send_stop_character(ch);
787				ch->ch_stops_sent++;
788				jsm_dbg(READ, &ch->ch_bd->pci_dev,
789					"Sending stop char! Times sent: %x\n",
790					ch->ch_stops_sent);
791			}
792		}
793	}
794
795	/*
796	 * Check to see if we should unenforce flow control because
797	 * ld (or user) finally read enuf data out of our queue.
798	 *
799	 * NOTE: This is done based on what the current flow control of the
800	 * port is set for.
801	 *
802	 * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt.
803	 *	This will cause the UART's FIFO to raise RTS back up,
804	 *	which will allow the other side to start sending data again.
805	 * 2) SWFLOW (IXOFF) - Send a start character to
806	 *	the other side, so it will start sending data to us again.
807	 * 3) NONE - Do nothing. Since we didn't do anything to turn off the
808	 *	other side, we don't need to do anything now.
809	 */
810	if (qleft > (RQUEUESIZE / 2)) {
811		/* HWFLOW */
812		if (ch->ch_c_cflag & CRTSCTS) {
813			if (ch->ch_flags & CH_RECEIVER_OFF) {
814				bd_ops->enable_receiver(ch);
815				ch->ch_flags &= ~(CH_RECEIVER_OFF);
816				jsm_dbg(READ, &ch->ch_bd->pci_dev,
817					"Internal queue hit lowlevel mark (%d)! Turning on interrupts\n",
818					qleft);
819			}
820		}
821		/* SWFLOW */
822		else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) {
823			ch->ch_stops_sent = 0;
824			bd_ops->send_start_character(ch);
825			jsm_dbg(READ, &ch->ch_bd->pci_dev,
826				"Sending start char!\n");
827		}
828	}
829}