blob: 7439c0373620b60f0351b2cccda143d1b023a642 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/************************************************************************
2 * Copyright 2003 Digi International (www.digi.com)
3 *
4 * Copyright (C) 2004 IBM Corporation. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
13 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 * PURPOSE. See the GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
19 * MA 02111-1307, USA.
20 *
21 * Contact Information:
22 * Scott H Kilau <Scott_Kilau@digi.com>
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -080023 * Ananda Venkatarman <mansarov@us.ibm.com>
24 * Modifications:
25 * 01/19/06: changed jsm_input routine to use the dynamically allocated
26 * tty_buffer changes. Contributors: Scott Kilau and Ananda V.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 ***********************************************************************/
28#include <linux/tty.h>
29#include <linux/tty_flip.h>
30#include <linux/serial_reg.h>
31#include <linux/delay.h> /* For udelay */
32#include <linux/pci.h>
33
34#include "jsm.h"
35
Alexander Y. Fomichev13858d32009-06-11 12:56:00 +010036static DECLARE_BITMAP(linemap, MAXLINES);
37
Adrian Bunk408b6642005-05-01 08:59:29 -070038static void jsm_carrier(struct jsm_channel *ch);
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040static inline int jsm_get_mstat(struct jsm_channel *ch)
41{
42 unsigned char mstat;
43 unsigned result;
44
45 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "start\n");
46
47 mstat = (ch->ch_mostat | ch->ch_mistat);
48
49 result = 0;
50
51 if (mstat & UART_MCR_DTR)
52 result |= TIOCM_DTR;
53 if (mstat & UART_MCR_RTS)
54 result |= TIOCM_RTS;
55 if (mstat & UART_MSR_CTS)
56 result |= TIOCM_CTS;
57 if (mstat & UART_MSR_DSR)
58 result |= TIOCM_DSR;
59 if (mstat & UART_MSR_RI)
60 result |= TIOCM_RI;
61 if (mstat & UART_MSR_DCD)
62 result |= TIOCM_CD;
63
64 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "finish\n");
65 return result;
66}
67
68static unsigned int jsm_tty_tx_empty(struct uart_port *port)
69{
70 return TIOCSER_TEMT;
71}
72
73/*
74 * Return modem signals to ld.
75 */
76static unsigned int jsm_tty_get_mctrl(struct uart_port *port)
77{
78 int result;
79 struct jsm_channel *channel = (struct jsm_channel *)port;
80
81 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
82
83 result = jsm_get_mstat(channel);
84
85 if (result < 0)
86 return -ENXIO;
87
88 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
89
90 return result;
91}
92
93/*
94 * jsm_set_modem_info()
95 *
96 * Set modem signals, called by ld.
97 */
98static void jsm_tty_set_mctrl(struct uart_port *port, unsigned int mctrl)
99{
100 struct jsm_channel *channel = (struct jsm_channel *)port;
101
102 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
103
104 if (mctrl & TIOCM_RTS)
105 channel->ch_mostat |= UART_MCR_RTS;
106 else
107 channel->ch_mostat &= ~UART_MCR_RTS;
108
109 if (mctrl & TIOCM_DTR)
110 channel->ch_mostat |= UART_MCR_DTR;
111 else
112 channel->ch_mostat &= ~UART_MCR_DTR;
113
114 channel->ch_bd->bd_ops->assert_modem_signals(channel);
115
116 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
117 udelay(10);
118}
119
Russell Kingb129a8c2005-08-31 10:12:14 +0100120static void jsm_tty_start_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
122 struct jsm_channel *channel = (struct jsm_channel *)port;
123
124 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
125
126 channel->ch_flags &= ~(CH_STOP);
127 jsm_tty_write(port);
128
129 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
130}
131
Russell Kingb129a8c2005-08-31 10:12:14 +0100132static void jsm_tty_stop_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
134 struct jsm_channel *channel = (struct jsm_channel *)port;
135
136 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
137
138 channel->ch_flags |= (CH_STOP);
139
140 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
141}
142
143static void jsm_tty_send_xchar(struct uart_port *port, char ch)
144{
145 unsigned long lock_flags;
146 struct jsm_channel *channel = (struct jsm_channel *)port;
Alan Cox606d0992006-12-08 02:38:45 -0800147 struct ktermios *termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 spin_lock_irqsave(&port->lock, lock_flags);
Alan Coxebd2c8f2009-09-19 13:13:28 -0700150 termios = port->state->port.tty->termios;
Jesper Juhla58e00e2006-03-31 02:32:12 -0800151 if (ch == termios->c_cc[VSTART])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 channel->ch_bd->bd_ops->send_start_character(channel);
153
Jesper Juhla58e00e2006-03-31 02:32:12 -0800154 if (ch == termios->c_cc[VSTOP])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 channel->ch_bd->bd_ops->send_stop_character(channel);
156 spin_unlock_irqrestore(&port->lock, lock_flags);
157}
158
159static void jsm_tty_stop_rx(struct uart_port *port)
160{
161 struct jsm_channel *channel = (struct jsm_channel *)port;
162
163 channel->ch_bd->bd_ops->disable_receiver(channel);
164}
165
Paul Larson0461ec52009-01-30 10:21:49 -0600166static void jsm_tty_enable_ms(struct uart_port *port)
167{
168 /* Nothing needed */
169}
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171static void jsm_tty_break(struct uart_port *port, int break_state)
172{
173 unsigned long lock_flags;
174 struct jsm_channel *channel = (struct jsm_channel *)port;
175
176 spin_lock_irqsave(&port->lock, lock_flags);
177 if (break_state == -1)
178 channel->ch_bd->bd_ops->send_break(channel);
179 else
180 channel->ch_bd->bd_ops->clear_break(channel, 0);
181
182 spin_unlock_irqrestore(&port->lock, lock_flags);
183}
184
185static int jsm_tty_open(struct uart_port *port)
186{
187 struct jsm_board *brd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 struct jsm_channel *channel = (struct jsm_channel *)port;
Alan Cox606d0992006-12-08 02:38:45 -0800189 struct ktermios *termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 /* Get board pointer from our array of majors we have allocated */
192 brd = channel->ch_bd;
193
194 /*
195 * Allocate channel buffers for read/write/error.
196 * Set flag, so we don't get trounced on.
197 */
198 channel->ch_flags |= (CH_OPENING);
199
200 /* Drop locks, as malloc with GFP_KERNEL can sleep */
201
202 if (!channel->ch_rqueue) {
Burman Yan8f31bb32007-02-14 00:33:07 -0800203 channel->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 if (!channel->ch_rqueue) {
205 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
206 "unable to allocate read queue buf");
207 return -ENOMEM;
208 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 }
210 if (!channel->ch_equeue) {
Burman Yan8f31bb32007-02-14 00:33:07 -0800211 channel->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (!channel->ch_equeue) {
213 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
214 "unable to allocate error queue buf");
215 return -ENOMEM;
216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 }
218 if (!channel->ch_wqueue) {
Burman Yan8f31bb32007-02-14 00:33:07 -0800219 channel->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 if (!channel->ch_wqueue) {
221 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
222 "unable to allocate write queue buf");
223 return -ENOMEM;
224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226
227 channel->ch_flags &= ~(CH_OPENING);
228 /*
229 * Initialize if neither terminal is open.
230 */
231 jsm_printk(OPEN, INFO, &channel->ch_bd->pci_dev,
232 "jsm_open: initializing channel in open...\n");
233
234 /*
235 * Flush input queues.
236 */
237 channel->ch_r_head = channel->ch_r_tail = 0;
238 channel->ch_e_head = channel->ch_e_tail = 0;
239 channel->ch_w_head = channel->ch_w_tail = 0;
240
241 brd->bd_ops->flush_uart_write(channel);
242 brd->bd_ops->flush_uart_read(channel);
243
244 channel->ch_flags = 0;
245 channel->ch_cached_lsr = 0;
246 channel->ch_stops_sent = 0;
247
Alan Coxebd2c8f2009-09-19 13:13:28 -0700248 termios = port->state->port.tty->termios;
Jesper Juhla58e00e2006-03-31 02:32:12 -0800249 channel->ch_c_cflag = termios->c_cflag;
250 channel->ch_c_iflag = termios->c_iflag;
251 channel->ch_c_oflag = termios->c_oflag;
252 channel->ch_c_lflag = termios->c_lflag;
253 channel->ch_startc = termios->c_cc[VSTART];
254 channel->ch_stopc = termios->c_cc[VSTOP];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 /* Tell UART to init itself */
257 brd->bd_ops->uart_init(channel);
258
259 /*
260 * Run param in case we changed anything
261 */
262 brd->bd_ops->param(channel);
263
264 jsm_carrier(channel);
265
266 channel->ch_open_count++;
267
268 jsm_printk(OPEN, INFO, &channel->ch_bd->pci_dev, "finish\n");
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100269 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
272static void jsm_tty_close(struct uart_port *port)
273{
274 struct jsm_board *bd;
Alan Cox606d0992006-12-08 02:38:45 -0800275 struct ktermios *ts;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 struct jsm_channel *channel = (struct jsm_channel *)port;
277
278 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
279
280 bd = channel->ch_bd;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700281 ts = port->state->port.tty->termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 channel->ch_flags &= ~(CH_STOPI);
284
285 channel->ch_open_count--;
286
287 /*
288 * If we have HUPCL set, lower DTR and RTS
289 */
290 if (channel->ch_c_cflag & HUPCL) {
291 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev,
292 "Close. HUPCL set, dropping DTR/RTS\n");
293
294 /* Drop RTS/DTR */
295 channel->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS);
296 bd->bd_ops->assert_modem_signals(channel);
297 }
298
299 channel->ch_old_baud = 0;
300
301 /* Turn off UART interrupts for this port */
302 channel->ch_bd->bd_ops->uart_off(channel);
303
304 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "finish\n");
305}
306
307static void jsm_tty_set_termios(struct uart_port *port,
Alan Cox606d0992006-12-08 02:38:45 -0800308 struct ktermios *termios,
309 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
311 unsigned long lock_flags;
312 struct jsm_channel *channel = (struct jsm_channel *)port;
313
314 spin_lock_irqsave(&port->lock, lock_flags);
315 channel->ch_c_cflag = termios->c_cflag;
316 channel->ch_c_iflag = termios->c_iflag;
317 channel->ch_c_oflag = termios->c_oflag;
318 channel->ch_c_lflag = termios->c_lflag;
319 channel->ch_startc = termios->c_cc[VSTART];
320 channel->ch_stopc = termios->c_cc[VSTOP];
321
322 channel->ch_bd->bd_ops->param(channel);
323 jsm_carrier(channel);
324 spin_unlock_irqrestore(&port->lock, lock_flags);
325}
326
327static const char *jsm_tty_type(struct uart_port *port)
328{
329 return "jsm";
330}
331
332static void jsm_tty_release_port(struct uart_port *port)
333{
334}
335
336static int jsm_tty_request_port(struct uart_port *port)
337{
338 return 0;
339}
340
341static void jsm_config_port(struct uart_port *port, int flags)
342{
343 port->type = PORT_JSM;
344}
345
346static struct uart_ops jsm_ops = {
347 .tx_empty = jsm_tty_tx_empty,
348 .set_mctrl = jsm_tty_set_mctrl,
349 .get_mctrl = jsm_tty_get_mctrl,
350 .stop_tx = jsm_tty_stop_tx,
351 .start_tx = jsm_tty_start_tx,
352 .send_xchar = jsm_tty_send_xchar,
353 .stop_rx = jsm_tty_stop_rx,
Paul Larson0461ec52009-01-30 10:21:49 -0600354 .enable_ms = jsm_tty_enable_ms,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .break_ctl = jsm_tty_break,
356 .startup = jsm_tty_open,
357 .shutdown = jsm_tty_close,
358 .set_termios = jsm_tty_set_termios,
359 .type = jsm_tty_type,
360 .release_port = jsm_tty_release_port,
361 .request_port = jsm_tty_request_port,
362 .config_port = jsm_config_port,
363};
364
365/*
366 * jsm_tty_init()
367 *
368 * Init the tty subsystem. Called once per board after board has been
369 * downloaded and init'ed.
370 */
Breno Leitaoaacf17a2009-04-06 17:34:17 +0100371int __devinit jsm_tty_init(struct jsm_board *brd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
373 int i;
374 void __iomem *vaddr;
375 struct jsm_channel *ch;
376
377 if (!brd)
378 return -ENXIO;
379
380 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
381
382 /*
383 * Initialize board structure elements.
384 */
385
386 brd->nasync = brd->maxports;
387
388 /*
389 * Allocate channel memory that might not have been allocated
390 * when the driver was first loaded.
391 */
392 for (i = 0; i < brd->nasync; i++) {
393 if (!brd->channels[i]) {
394
395 /*
396 * Okay to malloc with GFP_KERNEL, we are not at
397 * interrupt context, and there are no locks held.
398 */
Burman Yan8f31bb32007-02-14 00:33:07 -0800399 brd->channels[i] = kzalloc(sizeof(struct jsm_channel), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (!brd->channels[i]) {
401 jsm_printk(CORE, ERR, &brd->pci_dev,
402 "%s:%d Unable to allocate memory for channel struct\n",
403 __FILE__, __LINE__);
404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 }
406 }
407
408 ch = brd->channels[0];
409 vaddr = brd->re_map_membase;
410
411 /* Set up channel variables */
412 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
413
414 if (!brd->channels[i])
415 continue;
416
417 spin_lock_init(&ch->ch_lock);
418
419 if (brd->bd_uart_offset == 0x200)
420 ch->ch_neo_uart = vaddr + (brd->bd_uart_offset * i);
421
422 ch->ch_bd = brd;
423 ch->ch_portnum = i;
424
425 /* .25 second delay */
426 ch->ch_close_delay = 250;
427
428 init_waitqueue_head(&ch->ch_flags_wait);
429 }
430
431 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
432 return 0;
433}
434
Breno Leitaoaacf17a2009-04-06 17:34:17 +0100435int __devinit jsm_uart_port_init(struct jsm_board *brd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
437 int i;
Alexander Y. Fomichev13858d32009-06-11 12:56:00 +0100438 unsigned int line;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 struct jsm_channel *ch;
440
441 if (!brd)
442 return -ENXIO;
443
444 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
445
446 /*
447 * Initialize board structure elements.
448 */
449
450 brd->nasync = brd->maxports;
451
452 /* Set up channel variables */
453 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
454
455 if (!brd->channels[i])
456 continue;
457
458 brd->channels[i]->uart_port.irq = brd->irq;
Len Sorensen3c04c272007-05-08 00:26:30 -0700459 brd->channels[i]->uart_port.uartclk = 14745600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 brd->channels[i]->uart_port.type = PORT_JSM;
461 brd->channels[i]->uart_port.iotype = UPIO_MEM;
462 brd->channels[i]->uart_port.membase = brd->re_map_membase;
463 brd->channels[i]->uart_port.fifosize = 16;
464 brd->channels[i]->uart_port.ops = &jsm_ops;
Alexander Y. Fomichev13858d32009-06-11 12:56:00 +0100465 line = find_first_zero_bit(linemap, MAXLINES);
466 if (line >= MAXLINES) {
467 printk(KERN_INFO "jsm: linemap is full, added device failed\n");
468 continue;
469 } else
Andrew Morton2a133732009-06-24 18:34:43 +0100470 set_bit(line, linemap);
Alexander Y. Fomichev13858d32009-06-11 12:56:00 +0100471 brd->channels[i]->uart_port.line = line;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port))
Alexander Y. Fomichev13858d32009-06-11 12:56:00 +0100473 printk(KERN_INFO "jsm: add device failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 else
475 printk(KERN_INFO "Added device \n");
476 }
477
478 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
479 return 0;
480}
481
482int jsm_remove_uart_port(struct jsm_board *brd)
483{
484 int i;
485 struct jsm_channel *ch;
486
487 if (!brd)
488 return -ENXIO;
489
490 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
491
492 /*
493 * Initialize board structure elements.
494 */
495
496 brd->nasync = brd->maxports;
497
498 /* Set up channel variables */
499 for (i = 0; i < brd->nasync; i++) {
500
501 if (!brd->channels[i])
502 continue;
503
504 ch = brd->channels[i];
505
Andrew Morton2a133732009-06-24 18:34:43 +0100506 clear_bit(ch->uart_port.line, linemap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 uart_remove_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
508 }
509
510 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
511 return 0;
512}
513
514void jsm_input(struct jsm_channel *ch)
515{
516 struct jsm_board *bd;
517 struct tty_struct *tp;
518 u32 rmask;
519 u16 head;
520 u16 tail;
521 int data_len;
522 unsigned long lock_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 int len = 0;
524 int n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 int s = 0;
526 int i = 0;
527
528 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start\n");
529
530 if (!ch)
531 return;
532
Alan Coxebd2c8f2009-09-19 13:13:28 -0700533 tp = ch->uart_port.state->port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 bd = ch->ch_bd;
536 if(!bd)
537 return;
538
539 spin_lock_irqsave(&ch->ch_lock, lock_flags);
540
541 /*
542 *Figure the number of characters in the buffer.
543 *Exit immediately if none.
544 */
545
546 rmask = RQUEUEMASK;
547
548 head = ch->ch_r_head & rmask;
549 tail = ch->ch_r_tail & rmask;
550
551 data_len = (head - tail) & rmask;
552 if (data_len == 0) {
553 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
554 return;
555 }
556
557 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start\n");
558
559 /*
560 *If the device is not open, or CREAD is off, flush
561 *input data and return immediately.
562 */
563 if (!tp ||
564 !(tp->termios->c_cflag & CREAD) ) {
565
566 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
567 "input. dropping %d bytes on port %d...\n", data_len, ch->ch_portnum);
568 ch->ch_r_head = tail;
569
570 /* Force queue flow control to be released, if needed */
571 jsm_check_queue_flow_control(ch);
572
573 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
574 return;
575 }
576
577 /*
578 * If we are throttled, simply don't read any data.
579 */
580 if (ch->ch_flags & CH_STOPI) {
581 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
582 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
583 "Port %d throttled, not reading any data. head: %x tail: %x\n",
584 ch->ch_portnum, head, tail);
585 return;
586 }
587
588 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start 2\n");
589
Alan Cox7ba4b922007-10-16 23:27:05 -0700590 if (data_len <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
592 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "jsm_input 1\n");
593 return;
594 }
595
Alan Cox7ba4b922007-10-16 23:27:05 -0700596 len = tty_buffer_request_room(tp, data_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 n = len;
598
599 /*
600 * n now contains the most amount of data we can copy,
601 * bounded either by the flip buffer size or the amount
602 * of data the card actually has pending...
603 */
604 while (n) {
605 s = ((head >= tail) ? head : RQUEUESIZE) - tail;
606 s = min(s, n);
607
608 if (s <= 0)
609 break;
610
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -0800611 /*
612 * If conditions are such that ld needs to see all
613 * UART errors, we will have to walk each character
614 * and error byte and send them to the buffer one at
615 * a time.
616 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -0800618 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
619 for (i = 0; i < s; i++) {
620 /*
621 * Give the Linux ld the flags in the
622 * format it likes.
623 */
624 if (*(ch->ch_equeue +tail +i) & UART_LSR_BI)
625 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_BREAK);
626 else if (*(ch->ch_equeue +tail +i) & UART_LSR_PE)
627 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_PARITY);
628 else if (*(ch->ch_equeue +tail +i) & UART_LSR_FE)
629 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_FRAME);
630 else
Alan Cox7ba4b922007-10-16 23:27:05 -0700631 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_NORMAL);
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -0800632 }
633 } else {
634 tty_insert_flip_string(tp, ch->ch_rqueue + tail, s) ;
635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 tail += s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 n -= s;
638 /* Flip queue if needed */
639 tail &= rmask;
640 }
641
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -0800642 ch->ch_r_tail = tail & rmask;
643 ch->ch_e_tail = tail & rmask;
644 jsm_check_queue_flow_control(ch);
645 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
V. Ananda Krishnan0a577ce2006-02-03 03:04:30 -0800647 /* Tell the tty layer its okay to "eat" the data now */
648 tty_flip_buffer_push(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "finish\n");
651}
652
Adrian Bunk408b6642005-05-01 08:59:29 -0700653static void jsm_carrier(struct jsm_channel *ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 struct jsm_board *bd;
656
657 int virt_carrier = 0;
658 int phys_carrier = 0;
659
660 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev, "start\n");
661 if (!ch)
662 return;
663
664 bd = ch->ch_bd;
665
666 if (!bd)
667 return;
668
669 if (ch->ch_mistat & UART_MSR_DCD) {
670 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
671 "mistat: %x D_CD: %x\n", ch->ch_mistat, ch->ch_mistat & UART_MSR_DCD);
672 phys_carrier = 1;
673 }
674
675 if (ch->ch_c_cflag & CLOCAL)
676 virt_carrier = 1;
677
678 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
679 "DCD: physical: %d virt: %d\n", phys_carrier, virt_carrier);
680
681 /*
682 * Test for a VIRTUAL carrier transition to HIGH.
683 */
684 if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) {
685
686 /*
687 * When carrier rises, wake any threads waiting
688 * for carrier in the open routine.
689 */
690
691 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
692 "carrier: virt DCD rose\n");
693
694 if (waitqueue_active(&(ch->ch_flags_wait)))
695 wake_up_interruptible(&ch->ch_flags_wait);
696 }
697
698 /*
699 * Test for a PHYSICAL carrier transition to HIGH.
700 */
701 if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) {
702
703 /*
704 * When carrier rises, wake any threads waiting
705 * for carrier in the open routine.
706 */
707
708 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
709 "carrier: physical DCD rose\n");
710
711 if (waitqueue_active(&(ch->ch_flags_wait)))
712 wake_up_interruptible(&ch->ch_flags_wait);
713 }
714
715 /*
716 * Test for a PHYSICAL transition to low, so long as we aren't
717 * currently ignoring physical transitions (which is what "virtual
718 * carrier" indicates).
719 *
720 * The transition of the virtual carrier to low really doesn't
721 * matter... it really only means "ignore carrier state", not
722 * "make pretend that carrier is there".
723 */
724 if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0)
725 && (phys_carrier == 0)) {
726 /*
727 * When carrier drops:
728 *
729 * Drop carrier on all open units.
730 *
731 * Flush queues, waking up any task waiting in the
732 * line discipline.
733 *
734 * Send a hangup to the control terminal.
735 *
736 * Enable all select calls.
737 */
738 if (waitqueue_active(&(ch->ch_flags_wait)))
739 wake_up_interruptible(&ch->ch_flags_wait);
740 }
741
742 /*
743 * Make sure that our cached values reflect the current reality.
744 */
745 if (virt_carrier == 1)
746 ch->ch_flags |= CH_FCAR;
747 else
748 ch->ch_flags &= ~CH_FCAR;
749
750 if (phys_carrier == 1)
751 ch->ch_flags |= CH_CD;
752 else
753 ch->ch_flags &= ~CH_CD;
754}
755
756
757void jsm_check_queue_flow_control(struct jsm_channel *ch)
758{
Jesper Juhla58e00e2006-03-31 02:32:12 -0800759 struct board_ops *bd_ops = ch->ch_bd->bd_ops;
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100760 int qleft;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 /* Store how much space we have left in the queue */
763 if ((qleft = ch->ch_r_tail - ch->ch_r_head - 1) < 0)
764 qleft += RQUEUEMASK + 1;
765
766 /*
767 * Check to see if we should enforce flow control on our queue because
768 * the ld (or user) isn't reading data out of our queue fast enuf.
769 *
770 * NOTE: This is done based on what the current flow control of the
771 * port is set for.
772 *
773 * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt.
774 * This will cause the UART's FIFO to back up, and force
775 * the RTS signal to be dropped.
776 * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to
777 * the other side, in hopes it will stop sending data to us.
778 * 3) NONE - Nothing we can do. We will simply drop any extra data
779 * that gets sent into us when the queue fills up.
780 */
781 if (qleft < 256) {
782 /* HWFLOW */
783 if (ch->ch_c_cflag & CRTSCTS) {
784 if(!(ch->ch_flags & CH_RECEIVER_OFF)) {
Jesper Juhla58e00e2006-03-31 02:32:12 -0800785 bd_ops->disable_receiver(ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 ch->ch_flags |= (CH_RECEIVER_OFF);
787 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
788 "Internal queue hit hilevel mark (%d)! Turning off interrupts.\n",
789 qleft);
790 }
791 }
792 /* SWFLOW */
793 else if (ch->ch_c_iflag & IXOFF) {
794 if (ch->ch_stops_sent <= MAX_STOPS_SENT) {
Jesper Juhla58e00e2006-03-31 02:32:12 -0800795 bd_ops->send_stop_character(ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 ch->ch_stops_sent++;
797 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
798 "Sending stop char! Times sent: %x\n", ch->ch_stops_sent);
799 }
800 }
801 }
802
803 /*
804 * Check to see if we should unenforce flow control because
805 * ld (or user) finally read enuf data out of our queue.
806 *
807 * NOTE: This is done based on what the current flow control of the
808 * port is set for.
809 *
810 * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt.
811 * This will cause the UART's FIFO to raise RTS back up,
812 * which will allow the other side to start sending data again.
813 * 2) SWFLOW (IXOFF) - Send a start character to
814 * the other side, so it will start sending data to us again.
815 * 3) NONE - Do nothing. Since we didn't do anything to turn off the
816 * other side, we don't need to do anything now.
817 */
818 if (qleft > (RQUEUESIZE / 2)) {
819 /* HWFLOW */
820 if (ch->ch_c_cflag & CRTSCTS) {
821 if (ch->ch_flags & CH_RECEIVER_OFF) {
Jesper Juhla58e00e2006-03-31 02:32:12 -0800822 bd_ops->enable_receiver(ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 ch->ch_flags &= ~(CH_RECEIVER_OFF);
824 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
825 "Internal queue hit lowlevel mark (%d)! Turning on interrupts.\n",
826 qleft);
827 }
828 }
829 /* SWFLOW */
830 else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) {
831 ch->ch_stops_sent = 0;
Jesper Juhla58e00e2006-03-31 02:32:12 -0800832 bd_ops->send_start_character(ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "Sending start char!\n");
834 }
835 }
836}
837
838/*
839 * jsm_tty_write()
840 *
841 * Take data from the user or kernel and send it out to the FEP.
842 * In here exists all the Transparent Print magic as well.
843 */
844int jsm_tty_write(struct uart_port *port)
845{
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100846 int bufcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 int data_count = 0,data_count1 =0;
848 u16 head;
849 u16 tail;
850 u16 tmask;
851 u32 remain;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700852 int temp_tail = port->state->xmit.tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 struct jsm_channel *channel = (struct jsm_channel *)port;
854
855 tmask = WQUEUEMASK;
856 head = (channel->ch_w_head) & tmask;
857 tail = (channel->ch_w_tail) & tmask;
858
859 if ((bufcount = tail - head - 1) < 0)
860 bufcount += WQUEUESIZE;
861
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100862 bufcount = min(bufcount, 56);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 remain = WQUEUESIZE - head;
864
865 data_count = 0;
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100866 if (bufcount >= remain) {
867 bufcount -= remain;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700868 while ((port->state->xmit.head != temp_tail) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 (data_count < remain)) {
870 channel->ch_wqueue[head++] =
Alan Coxebd2c8f2009-09-19 13:13:28 -0700871 port->state->xmit.buf[temp_tail];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
873 temp_tail++;
874 temp_tail &= (UART_XMIT_SIZE - 1);
875 data_count++;
876 }
877 if (data_count == remain) head = 0;
878 }
879
880 data_count1 = 0;
Breno Leitao8e7d91c2009-04-07 16:53:48 +0100881 if (bufcount > 0) {
882 remain = bufcount;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700883 while ((port->state->xmit.head != temp_tail) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 (data_count1 < remain)) {
885 channel->ch_wqueue[head++] =
Alan Coxebd2c8f2009-09-19 13:13:28 -0700886 port->state->xmit.buf[temp_tail];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 temp_tail++;
889 temp_tail &= (UART_XMIT_SIZE - 1);
890 data_count1++;
891
892 }
893 }
894
Alan Coxebd2c8f2009-09-19 13:13:28 -0700895 port->state->xmit.tail = temp_tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
897 data_count += data_count1;
898 if (data_count) {
899 head &= tmask;
900 channel->ch_w_head = head;
901 }
902
903 if (data_count) {
904 channel->ch_bd->bd_ops->copy_data_from_queue_to_uart(channel);
905 }
906
907 return data_count;
908}