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