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 | |
23 | static DECLARE_BITMAP(linemap, MAXLINES); |
24 | |
25 | static void jsm_carrier(struct jsm_channel *ch); |
26 | |
27 | static 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 | |
55 | static 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 | */ |
63 | static 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(ch: 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 | */ |
86 | static 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 | */ |
115 | static 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 | |
123 | static 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 | |
136 | static 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 | |
148 | static 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(up: port, flags: &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(up: port, flags: lock_flags); |
163 | } |
164 | |
165 | static 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 | |
173 | static 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(up: port, flags: &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(up: port, flags: lock_flags); |
186 | } |
187 | |
188 | static 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(up: port, flags: &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(ch: channel); |
262 | |
263 | channel->ch_open_count++; |
264 | uart_port_unlock_irqrestore(up: port, flags: lock_flags); |
265 | |
266 | jsm_dbg(OPEN, &channel->ch_bd->pci_dev, "finish\n" ); |
267 | return 0; |
268 | } |
269 | |
270 | static 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 | |
302 | static 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(up: port, flags: &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(ch: channel); |
320 | uart_port_unlock_irqrestore(up: port, flags: lock_flags); |
321 | } |
322 | |
323 | static const char *jsm_tty_type(struct uart_port *port) |
324 | { |
325 | return "jsm" ; |
326 | } |
327 | |
328 | static void jsm_tty_release_port(struct uart_port *port) |
329 | { |
330 | } |
331 | |
332 | static int jsm_tty_request_port(struct uart_port *port) |
333 | { |
334 | return 0; |
335 | } |
336 | |
337 | static void jsm_config_port(struct uart_port *port, int flags) |
338 | { |
339 | port->type = PORT_JSM; |
340 | } |
341 | |
342 | static 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 | */ |
366 | int 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(size: 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 | |
432 | int 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.irq = brd->irq; |
455 | brd->channels[i]->uart_port.uartclk = 14745600; |
456 | brd->channels[i]->uart_port.type = PORT_JSM; |
457 | brd->channels[i]->uart_port.iotype = UPIO_MEM; |
458 | brd->channels[i]->uart_port.membase = brd->re_map_membase; |
459 | brd->channels[i]->uart_port.fifosize = 16; |
460 | brd->channels[i]->uart_port.ops = &jsm_ops; |
461 | line = find_first_zero_bit(addr: linemap, MAXLINES); |
462 | if (line >= MAXLINES) { |
463 | printk(KERN_INFO "jsm: linemap is full, added device failed\n" ); |
464 | continue; |
465 | } else |
466 | set_bit(nr: line, addr: linemap); |
467 | brd->channels[i]->uart_port.line = line; |
468 | rc = uart_add_one_port(reg: &jsm_uart_driver, port: &brd->channels[i]->uart_port); |
469 | if (rc) { |
470 | printk(KERN_INFO "jsm: Port %d failed. Aborting...\n" , i); |
471 | return rc; |
472 | } else |
473 | printk(KERN_INFO "jsm: Port %d added\n" , i); |
474 | } |
475 | |
476 | jsm_dbg(INIT, &brd->pci_dev, "finish\n" ); |
477 | return 0; |
478 | } |
479 | |
480 | int jsm_remove_uart_port(struct jsm_board *brd) |
481 | { |
482 | int i; |
483 | struct jsm_channel *ch; |
484 | |
485 | if (!brd) |
486 | return -ENXIO; |
487 | |
488 | jsm_dbg(INIT, &brd->pci_dev, "start\n" ); |
489 | |
490 | /* |
491 | * Initialize board structure elements. |
492 | */ |
493 | |
494 | brd->nasync = brd->maxports; |
495 | |
496 | /* Set up channel variables */ |
497 | for (i = 0; i < brd->nasync; i++) { |
498 | |
499 | if (!brd->channels[i]) |
500 | continue; |
501 | |
502 | ch = brd->channels[i]; |
503 | |
504 | clear_bit(nr: ch->uart_port.line, addr: linemap); |
505 | uart_remove_one_port(reg: &jsm_uart_driver, port: &brd->channels[i]->uart_port); |
506 | } |
507 | |
508 | jsm_dbg(INIT, &brd->pci_dev, "finish\n" ); |
509 | return 0; |
510 | } |
511 | |
512 | void jsm_input(struct jsm_channel *ch) |
513 | { |
514 | struct jsm_board *bd; |
515 | struct tty_struct *tp; |
516 | struct tty_port *port; |
517 | u32 rmask; |
518 | u16 head; |
519 | u16 tail; |
520 | int data_len; |
521 | unsigned long lock_flags; |
522 | int len = 0; |
523 | int s = 0; |
524 | int i = 0; |
525 | |
526 | jsm_dbg(READ, &ch->ch_bd->pci_dev, "start\n" ); |
527 | |
528 | port = &ch->uart_port.state->port; |
529 | tp = port->tty; |
530 | |
531 | bd = ch->ch_bd; |
532 | if (!bd) |
533 | return; |
534 | |
535 | spin_lock_irqsave(&ch->ch_lock, lock_flags); |
536 | |
537 | /* |
538 | *Figure the number of characters in the buffer. |
539 | *Exit immediately if none. |
540 | */ |
541 | |
542 | rmask = RQUEUEMASK; |
543 | |
544 | head = ch->ch_r_head & rmask; |
545 | tail = ch->ch_r_tail & rmask; |
546 | |
547 | data_len = (head - tail) & rmask; |
548 | if (data_len == 0) { |
549 | spin_unlock_irqrestore(lock: &ch->ch_lock, flags: lock_flags); |
550 | return; |
551 | } |
552 | |
553 | jsm_dbg(READ, &ch->ch_bd->pci_dev, "start\n" ); |
554 | |
555 | /* |
556 | *If the device is not open, or CREAD is off, flush |
557 | *input data and return immediately. |
558 | */ |
559 | if (!tp || !C_CREAD(tp)) { |
560 | |
561 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
562 | "input. dropping %d bytes on port %d...\n" , |
563 | data_len, ch->ch_portnum); |
564 | ch->ch_r_head = tail; |
565 | |
566 | /* Force queue flow control to be released, if needed */ |
567 | jsm_check_queue_flow_control(ch); |
568 | |
569 | spin_unlock_irqrestore(lock: &ch->ch_lock, flags: lock_flags); |
570 | return; |
571 | } |
572 | |
573 | /* |
574 | * If we are throttled, simply don't read any data. |
575 | */ |
576 | if (ch->ch_flags & CH_STOPI) { |
577 | spin_unlock_irqrestore(lock: &ch->ch_lock, flags: lock_flags); |
578 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
579 | "Port %d throttled, not reading any data. head: %x tail: %x\n" , |
580 | ch->ch_portnum, head, tail); |
581 | return; |
582 | } |
583 | |
584 | jsm_dbg(READ, &ch->ch_bd->pci_dev, "start 2\n" ); |
585 | |
586 | len = tty_buffer_request_room(port, size: data_len); |
587 | |
588 | /* |
589 | * len now contains the most amount of data we can copy, |
590 | * bounded either by the flip buffer size or the amount |
591 | * of data the card actually has pending... |
592 | */ |
593 | while (len) { |
594 | s = ((head >= tail) ? head : RQUEUESIZE) - tail; |
595 | s = min(s, len); |
596 | |
597 | if (s <= 0) |
598 | break; |
599 | |
600 | /* |
601 | * If conditions are such that ld needs to see all |
602 | * UART errors, we will have to walk each character |
603 | * and error byte and send them to the buffer one at |
604 | * a time. |
605 | */ |
606 | |
607 | if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) { |
608 | for (i = 0; i < s; i++) { |
609 | u8 chr = ch->ch_rqueue[tail + i]; |
610 | u8 error = ch->ch_equeue[tail + i]; |
611 | char flag = TTY_NORMAL; |
612 | |
613 | /* |
614 | * Give the Linux ld the flags in the format it |
615 | * likes. |
616 | */ |
617 | if (error & UART_LSR_BI) |
618 | flag = TTY_BREAK; |
619 | else if (error & UART_LSR_PE) |
620 | flag = TTY_PARITY; |
621 | else if (error & UART_LSR_FE) |
622 | flag = TTY_FRAME; |
623 | |
624 | tty_insert_flip_char(port, ch: chr, flag); |
625 | } |
626 | } else { |
627 | tty_insert_flip_string(port, chars: ch->ch_rqueue + tail, size: s); |
628 | } |
629 | tail += s; |
630 | len -= s; |
631 | /* Flip queue if needed */ |
632 | tail &= rmask; |
633 | } |
634 | |
635 | ch->ch_r_tail = tail & rmask; |
636 | ch->ch_e_tail = tail & rmask; |
637 | jsm_check_queue_flow_control(ch); |
638 | spin_unlock_irqrestore(lock: &ch->ch_lock, flags: lock_flags); |
639 | |
640 | /* Tell the tty layer its okay to "eat" the data now */ |
641 | tty_flip_buffer_push(port); |
642 | |
643 | jsm_dbg(IOCTL, &ch->ch_bd->pci_dev, "finish\n" ); |
644 | } |
645 | |
646 | static void jsm_carrier(struct jsm_channel *ch) |
647 | { |
648 | struct jsm_board *bd; |
649 | |
650 | int virt_carrier = 0; |
651 | int phys_carrier = 0; |
652 | |
653 | jsm_dbg(CARR, &ch->ch_bd->pci_dev, "start\n" ); |
654 | |
655 | bd = ch->ch_bd; |
656 | if (!bd) |
657 | return; |
658 | |
659 | if (ch->ch_mistat & UART_MSR_DCD) { |
660 | jsm_dbg(CARR, &ch->ch_bd->pci_dev, "mistat: %x D_CD: %x\n" , |
661 | ch->ch_mistat, ch->ch_mistat & UART_MSR_DCD); |
662 | phys_carrier = 1; |
663 | } |
664 | |
665 | if (ch->ch_c_cflag & CLOCAL) |
666 | virt_carrier = 1; |
667 | |
668 | jsm_dbg(CARR, &ch->ch_bd->pci_dev, "DCD: physical: %d virt: %d\n" , |
669 | phys_carrier, virt_carrier); |
670 | |
671 | /* |
672 | * Test for a VIRTUAL carrier transition to HIGH. |
673 | */ |
674 | if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) { |
675 | |
676 | /* |
677 | * When carrier rises, wake any threads waiting |
678 | * for carrier in the open routine. |
679 | */ |
680 | |
681 | jsm_dbg(CARR, &ch->ch_bd->pci_dev, "carrier: virt DCD rose\n" ); |
682 | |
683 | if (waitqueue_active(wq_head: &(ch->ch_flags_wait))) |
684 | wake_up_interruptible(&ch->ch_flags_wait); |
685 | } |
686 | |
687 | /* |
688 | * Test for a PHYSICAL carrier transition to HIGH. |
689 | */ |
690 | if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) { |
691 | |
692 | /* |
693 | * When carrier rises, wake any threads waiting |
694 | * for carrier in the open routine. |
695 | */ |
696 | |
697 | jsm_dbg(CARR, &ch->ch_bd->pci_dev, |
698 | "carrier: physical DCD rose\n" ); |
699 | |
700 | if (waitqueue_active(wq_head: &(ch->ch_flags_wait))) |
701 | wake_up_interruptible(&ch->ch_flags_wait); |
702 | } |
703 | |
704 | /* |
705 | * Test for a PHYSICAL transition to low, so long as we aren't |
706 | * currently ignoring physical transitions (which is what "virtual |
707 | * carrier" indicates). |
708 | * |
709 | * The transition of the virtual carrier to low really doesn't |
710 | * matter... it really only means "ignore carrier state", not |
711 | * "make pretend that carrier is there". |
712 | */ |
713 | if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0) |
714 | && (phys_carrier == 0)) { |
715 | /* |
716 | * When carrier drops: |
717 | * |
718 | * Drop carrier on all open units. |
719 | * |
720 | * Flush queues, waking up any task waiting in the |
721 | * line discipline. |
722 | * |
723 | * Send a hangup to the control terminal. |
724 | * |
725 | * Enable all select calls. |
726 | */ |
727 | if (waitqueue_active(wq_head: &(ch->ch_flags_wait))) |
728 | wake_up_interruptible(&ch->ch_flags_wait); |
729 | } |
730 | |
731 | /* |
732 | * Make sure that our cached values reflect the current reality. |
733 | */ |
734 | if (virt_carrier == 1) |
735 | ch->ch_flags |= CH_FCAR; |
736 | else |
737 | ch->ch_flags &= ~CH_FCAR; |
738 | |
739 | if (phys_carrier == 1) |
740 | ch->ch_flags |= CH_CD; |
741 | else |
742 | ch->ch_flags &= ~CH_CD; |
743 | } |
744 | |
745 | |
746 | void jsm_check_queue_flow_control(struct jsm_channel *ch) |
747 | { |
748 | struct board_ops *bd_ops = ch->ch_bd->bd_ops; |
749 | int qleft; |
750 | |
751 | /* Store how much space we have left in the queue */ |
752 | qleft = ch->ch_r_tail - ch->ch_r_head - 1; |
753 | if (qleft < 0) |
754 | qleft += RQUEUEMASK + 1; |
755 | |
756 | /* |
757 | * Check to see if we should enforce flow control on our queue because |
758 | * the ld (or user) isn't reading data out of our queue fast enuf. |
759 | * |
760 | * NOTE: This is done based on what the current flow control of the |
761 | * port is set for. |
762 | * |
763 | * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt. |
764 | * This will cause the UART's FIFO to back up, and force |
765 | * the RTS signal to be dropped. |
766 | * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to |
767 | * the other side, in hopes it will stop sending data to us. |
768 | * 3) NONE - Nothing we can do. We will simply drop any extra data |
769 | * that gets sent into us when the queue fills up. |
770 | */ |
771 | if (qleft < 256) { |
772 | /* HWFLOW */ |
773 | if (ch->ch_c_cflag & CRTSCTS) { |
774 | if (!(ch->ch_flags & CH_RECEIVER_OFF)) { |
775 | bd_ops->disable_receiver(ch); |
776 | ch->ch_flags |= (CH_RECEIVER_OFF); |
777 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
778 | "Internal queue hit hilevel mark (%d)! Turning off interrupts\n" , |
779 | qleft); |
780 | } |
781 | } |
782 | /* SWFLOW */ |
783 | else if (ch->ch_c_iflag & IXOFF) { |
784 | if (ch->ch_stops_sent <= MAX_STOPS_SENT) { |
785 | bd_ops->send_stop_character(ch); |
786 | ch->ch_stops_sent++; |
787 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
788 | "Sending stop char! Times sent: %x\n" , |
789 | ch->ch_stops_sent); |
790 | } |
791 | } |
792 | } |
793 | |
794 | /* |
795 | * Check to see if we should unenforce flow control because |
796 | * ld (or user) finally read enuf data out of our queue. |
797 | * |
798 | * NOTE: This is done based on what the current flow control of the |
799 | * port is set for. |
800 | * |
801 | * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt. |
802 | * This will cause the UART's FIFO to raise RTS back up, |
803 | * which will allow the other side to start sending data again. |
804 | * 2) SWFLOW (IXOFF) - Send a start character to |
805 | * the other side, so it will start sending data to us again. |
806 | * 3) NONE - Do nothing. Since we didn't do anything to turn off the |
807 | * other side, we don't need to do anything now. |
808 | */ |
809 | if (qleft > (RQUEUESIZE / 2)) { |
810 | /* HWFLOW */ |
811 | if (ch->ch_c_cflag & CRTSCTS) { |
812 | if (ch->ch_flags & CH_RECEIVER_OFF) { |
813 | bd_ops->enable_receiver(ch); |
814 | ch->ch_flags &= ~(CH_RECEIVER_OFF); |
815 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
816 | "Internal queue hit lowlevel mark (%d)! Turning on interrupts\n" , |
817 | qleft); |
818 | } |
819 | } |
820 | /* SWFLOW */ |
821 | else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) { |
822 | ch->ch_stops_sent = 0; |
823 | bd_ops->send_start_character(ch); |
824 | jsm_dbg(READ, &ch->ch_bd->pci_dev, |
825 | "Sending start char!\n" ); |
826 | } |
827 | } |
828 | } |
829 | |