1 /* 2 * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver 3 * 4 * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch) 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 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is largely derived from the Belkin USB Serial Adapter Driver 12 * (see belkin_sa.[ch]). All of the information about the device was acquired 13 * by using SniffUSB on Windows98. For technical details see mct_u232.h. 14 * 15 * William G. Greathouse and Greg Kroah-Hartman provided great help on how to 16 * do the reverse engineering and how to write a USB serial device driver. 17 * 18 * TO BE DONE, TO BE CHECKED: 19 * DTR/RTS signal handling may be incomplete or incorrect. I have mainly 20 * implemented what I have seen with SniffUSB or found in belkin_sa.c. 21 * For further TODOs check also belkin_sa.c. 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/errno.h> 26 #include <linux/init.h> 27 #include <linux/slab.h> 28 #include <linux/tty.h> 29 #include <linux/tty_driver.h> 30 #include <linux/tty_flip.h> 31 #include <linux/module.h> 32 #include <linux/spinlock.h> 33 #include <linux/uaccess.h> 34 #include <asm/unaligned.h> 35 #include <linux/usb.h> 36 #include <linux/usb/serial.h> 37 #include <linux/serial.h> 38 #include <linux/ioctl.h> 39 #include "mct_u232.h" 40 41 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>" 42 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver" 43 44 /* 45 * Function prototypes 46 */ 47 static int mct_u232_startup(struct usb_serial *serial); 48 static int mct_u232_port_probe(struct usb_serial_port *port); 49 static int mct_u232_port_remove(struct usb_serial_port *remove); 50 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port); 51 static void mct_u232_close(struct usb_serial_port *port); 52 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on); 53 static void mct_u232_read_int_callback(struct urb *urb); 54 static void mct_u232_set_termios(struct tty_struct *tty, 55 struct usb_serial_port *port, struct ktermios *old); 56 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state); 57 static int mct_u232_tiocmget(struct tty_struct *tty); 58 static int mct_u232_tiocmset(struct tty_struct *tty, 59 unsigned int set, unsigned int clear); 60 static int mct_u232_ioctl(struct tty_struct *tty, 61 unsigned int cmd, unsigned long arg); 62 static int mct_u232_get_icount(struct tty_struct *tty, 63 struct serial_icounter_struct *icount); 64 static void mct_u232_throttle(struct tty_struct *tty); 65 static void mct_u232_unthrottle(struct tty_struct *tty); 66 67 68 /* 69 * All of the device info needed for the MCT USB-RS232 converter. 70 */ 71 static const struct usb_device_id id_table[] = { 72 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) }, 73 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) }, 74 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) }, 75 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) }, 76 { } /* Terminating entry */ 77 }; 78 MODULE_DEVICE_TABLE(usb, id_table); 79 80 static struct usb_serial_driver mct_u232_device = { 81 .driver = { 82 .owner = THIS_MODULE, 83 .name = "mct_u232", 84 }, 85 .description = "MCT U232", 86 .id_table = id_table, 87 .num_ports = 1, 88 .open = mct_u232_open, 89 .close = mct_u232_close, 90 .dtr_rts = mct_u232_dtr_rts, 91 .throttle = mct_u232_throttle, 92 .unthrottle = mct_u232_unthrottle, 93 .read_int_callback = mct_u232_read_int_callback, 94 .set_termios = mct_u232_set_termios, 95 .break_ctl = mct_u232_break_ctl, 96 .tiocmget = mct_u232_tiocmget, 97 .tiocmset = mct_u232_tiocmset, 98 .attach = mct_u232_startup, 99 .port_probe = mct_u232_port_probe, 100 .port_remove = mct_u232_port_remove, 101 .ioctl = mct_u232_ioctl, 102 .get_icount = mct_u232_get_icount, 103 }; 104 105 static struct usb_serial_driver * const serial_drivers[] = { 106 &mct_u232_device, NULL 107 }; 108 109 struct mct_u232_private { 110 spinlock_t lock; 111 unsigned int control_state; /* Modem Line Setting (TIOCM) */ 112 unsigned char last_lcr; /* Line Control Register */ 113 unsigned char last_lsr; /* Line Status Register */ 114 unsigned char last_msr; /* Modem Status Register */ 115 unsigned int rx_flags; /* Throttling flags */ 116 struct async_icount icount; 117 wait_queue_head_t msr_wait; /* for handling sleeping while waiting 118 for msr change to happen */ 119 }; 120 121 #define THROTTLED 0x01 122 123 /* 124 * Handle vendor specific USB requests 125 */ 126 127 #define WDR_TIMEOUT 5000 /* default urb timeout */ 128 129 /* 130 * Later day 2.6.0-test kernels have new baud rates like B230400 which 131 * we do not know how to support. We ignore them for the moment. 132 */ 133 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, 134 speed_t value, speed_t *result) 135 { 136 *result = value; 137 138 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID 139 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { 140 switch (value) { 141 case 300: 142 return 0x01; 143 case 600: 144 return 0x02; /* this one not tested */ 145 case 1200: 146 return 0x03; 147 case 2400: 148 return 0x04; 149 case 4800: 150 return 0x06; 151 case 9600: 152 return 0x08; 153 case 19200: 154 return 0x09; 155 case 38400: 156 return 0x0a; 157 case 57600: 158 return 0x0b; 159 case 115200: 160 return 0x0c; 161 default: 162 *result = 9600; 163 return 0x08; 164 } 165 } else { 166 /* FIXME: Can we use any divider - should we do 167 divider = 115200/value; 168 real baud = 115200/divider */ 169 switch (value) { 170 case 300: break; 171 case 600: break; 172 case 1200: break; 173 case 2400: break; 174 case 4800: break; 175 case 9600: break; 176 case 19200: break; 177 case 38400: break; 178 case 57600: break; 179 case 115200: break; 180 default: 181 value = 9600; 182 *result = 9600; 183 } 184 return 115200/value; 185 } 186 } 187 188 static int mct_u232_set_baud_rate(struct tty_struct *tty, 189 struct usb_serial *serial, struct usb_serial_port *port, speed_t value) 190 { 191 unsigned int divisor; 192 int rc; 193 unsigned char *buf; 194 unsigned char cts_enable_byte = 0; 195 speed_t speed; 196 197 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 198 if (buf == NULL) 199 return -ENOMEM; 200 201 divisor = mct_u232_calculate_baud_rate(serial, value, &speed); 202 put_unaligned_le32(cpu_to_le32(divisor), buf); 203 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 204 MCT_U232_SET_BAUD_RATE_REQUEST, 205 MCT_U232_SET_REQUEST_TYPE, 206 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE, 207 WDR_TIMEOUT); 208 if (rc < 0) /*FIXME: What value speed results */ 209 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n", 210 value, rc); 211 else 212 tty_encode_baud_rate(tty, speed, speed); 213 dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor); 214 215 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which 216 always sends two extra USB 'device request' messages after the 217 'baud rate change' message. The actual functionality of the 218 request codes in these messages is not fully understood but these 219 particular codes are never seen in any operation besides a baud 220 rate change. Both of these messages send a single byte of data. 221 In the first message, the value of this byte is always zero. 222 223 The second message has been determined experimentally to control 224 whether data will be transmitted to a device which is not asserting 225 the 'CTS' signal. If the second message's data byte is zero, data 226 will be transmitted even if 'CTS' is not asserted (i.e. no hardware 227 flow control). if the second message's data byte is nonzero (a 228 value of 1 is used by this driver), data will not be transmitted to 229 a device which is not asserting 'CTS'. 230 */ 231 232 buf[0] = 0; 233 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 234 MCT_U232_SET_UNKNOWN1_REQUEST, 235 MCT_U232_SET_REQUEST_TYPE, 236 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE, 237 WDR_TIMEOUT); 238 if (rc < 0) 239 dev_err(&port->dev, "Sending USB device request code %d " 240 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST, 241 rc); 242 243 if (port && C_CRTSCTS(tty)) 244 cts_enable_byte = 1; 245 246 dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n", 247 cts_enable_byte); 248 buf[0] = cts_enable_byte; 249 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 250 MCT_U232_SET_CTS_REQUEST, 251 MCT_U232_SET_REQUEST_TYPE, 252 0, 0, buf, MCT_U232_SET_CTS_SIZE, 253 WDR_TIMEOUT); 254 if (rc < 0) 255 dev_err(&port->dev, "Sending USB device request code %d " 256 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc); 257 258 kfree(buf); 259 return rc; 260 } /* mct_u232_set_baud_rate */ 261 262 static int mct_u232_set_line_ctrl(struct usb_serial_port *port, 263 unsigned char lcr) 264 { 265 int rc; 266 unsigned char *buf; 267 268 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 269 if (buf == NULL) 270 return -ENOMEM; 271 272 buf[0] = lcr; 273 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), 274 MCT_U232_SET_LINE_CTRL_REQUEST, 275 MCT_U232_SET_REQUEST_TYPE, 276 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE, 277 WDR_TIMEOUT); 278 if (rc < 0) 279 dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc); 280 dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr); 281 kfree(buf); 282 return rc; 283 } /* mct_u232_set_line_ctrl */ 284 285 static int mct_u232_set_modem_ctrl(struct usb_serial_port *port, 286 unsigned int control_state) 287 { 288 int rc; 289 unsigned char mcr; 290 unsigned char *buf; 291 292 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 293 if (buf == NULL) 294 return -ENOMEM; 295 296 mcr = MCT_U232_MCR_NONE; 297 if (control_state & TIOCM_DTR) 298 mcr |= MCT_U232_MCR_DTR; 299 if (control_state & TIOCM_RTS) 300 mcr |= MCT_U232_MCR_RTS; 301 302 buf[0] = mcr; 303 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), 304 MCT_U232_SET_MODEM_CTRL_REQUEST, 305 MCT_U232_SET_REQUEST_TYPE, 306 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE, 307 WDR_TIMEOUT); 308 kfree(buf); 309 310 dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr); 311 312 if (rc < 0) { 313 dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc); 314 return rc; 315 } 316 return 0; 317 } /* mct_u232_set_modem_ctrl */ 318 319 static int mct_u232_get_modem_stat(struct usb_serial_port *port, 320 unsigned char *msr) 321 { 322 int rc; 323 unsigned char *buf; 324 325 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 326 if (buf == NULL) { 327 *msr = 0; 328 return -ENOMEM; 329 } 330 rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0), 331 MCT_U232_GET_MODEM_STAT_REQUEST, 332 MCT_U232_GET_REQUEST_TYPE, 333 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE, 334 WDR_TIMEOUT); 335 if (rc < 0) { 336 dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc); 337 *msr = 0; 338 } else { 339 *msr = buf[0]; 340 } 341 dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr); 342 kfree(buf); 343 return rc; 344 } /* mct_u232_get_modem_stat */ 345 346 static void mct_u232_msr_to_icount(struct async_icount *icount, 347 unsigned char msr) 348 { 349 /* Translate Control Line states */ 350 if (msr & MCT_U232_MSR_DDSR) 351 icount->dsr++; 352 if (msr & MCT_U232_MSR_DCTS) 353 icount->cts++; 354 if (msr & MCT_U232_MSR_DRI) 355 icount->rng++; 356 if (msr & MCT_U232_MSR_DCD) 357 icount->dcd++; 358 } /* mct_u232_msr_to_icount */ 359 360 static void mct_u232_msr_to_state(struct usb_serial_port *port, 361 unsigned int *control_state, unsigned char msr) 362 { 363 /* Translate Control Line states */ 364 if (msr & MCT_U232_MSR_DSR) 365 *control_state |= TIOCM_DSR; 366 else 367 *control_state &= ~TIOCM_DSR; 368 if (msr & MCT_U232_MSR_CTS) 369 *control_state |= TIOCM_CTS; 370 else 371 *control_state &= ~TIOCM_CTS; 372 if (msr & MCT_U232_MSR_RI) 373 *control_state |= TIOCM_RI; 374 else 375 *control_state &= ~TIOCM_RI; 376 if (msr & MCT_U232_MSR_CD) 377 *control_state |= TIOCM_CD; 378 else 379 *control_state &= ~TIOCM_CD; 380 dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state); 381 } /* mct_u232_msr_to_state */ 382 383 /* 384 * Driver's tty interface functions 385 */ 386 387 static int mct_u232_startup(struct usb_serial *serial) 388 { 389 struct usb_serial_port *port, *rport; 390 391 /* Puh, that's dirty */ 392 port = serial->port[0]; 393 rport = serial->port[1]; 394 /* No unlinking, it wasn't submitted yet. */ 395 usb_free_urb(port->read_urb); 396 port->read_urb = rport->interrupt_in_urb; 397 rport->interrupt_in_urb = NULL; 398 port->read_urb->context = port; 399 400 return 0; 401 } /* mct_u232_startup */ 402 403 static int mct_u232_port_probe(struct usb_serial_port *port) 404 { 405 struct mct_u232_private *priv; 406 407 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 408 if (!priv) 409 return -ENOMEM; 410 411 spin_lock_init(&priv->lock); 412 init_waitqueue_head(&priv->msr_wait); 413 414 usb_set_serial_port_data(port, priv); 415 416 return 0; 417 } 418 419 static int mct_u232_port_remove(struct usb_serial_port *port) 420 { 421 struct mct_u232_private *priv; 422 423 priv = usb_get_serial_port_data(port); 424 kfree(priv); 425 426 return 0; 427 } 428 429 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port) 430 { 431 struct usb_serial *serial = port->serial; 432 struct mct_u232_private *priv = usb_get_serial_port_data(port); 433 int retval = 0; 434 unsigned int control_state; 435 unsigned long flags; 436 unsigned char last_lcr; 437 unsigned char last_msr; 438 439 /* Compensate for a hardware bug: although the Sitecom U232-P25 440 * device reports a maximum output packet size of 32 bytes, 441 * it seems to be able to accept only 16 bytes (and that's what 442 * SniffUSB says too...) 443 */ 444 if (le16_to_cpu(serial->dev->descriptor.idProduct) 445 == MCT_U232_SITECOM_PID) 446 port->bulk_out_size = 16; 447 448 /* Do a defined restart: the normal serial device seems to 449 * always turn on DTR and RTS here, so do the same. I'm not 450 * sure if this is really necessary. But it should not harm 451 * either. 452 */ 453 spin_lock_irqsave(&priv->lock, flags); 454 if (tty && (tty->termios.c_cflag & CBAUD)) 455 priv->control_state = TIOCM_DTR | TIOCM_RTS; 456 else 457 priv->control_state = 0; 458 459 priv->last_lcr = (MCT_U232_DATA_BITS_8 | 460 MCT_U232_PARITY_NONE | 461 MCT_U232_STOP_BITS_1); 462 control_state = priv->control_state; 463 last_lcr = priv->last_lcr; 464 spin_unlock_irqrestore(&priv->lock, flags); 465 mct_u232_set_modem_ctrl(port, control_state); 466 mct_u232_set_line_ctrl(port, last_lcr); 467 468 /* Read modem status and update control state */ 469 mct_u232_get_modem_stat(port, &last_msr); 470 spin_lock_irqsave(&priv->lock, flags); 471 priv->last_msr = last_msr; 472 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr); 473 spin_unlock_irqrestore(&priv->lock, flags); 474 475 retval = usb_submit_urb(port->read_urb, GFP_KERNEL); 476 if (retval) { 477 dev_err(&port->dev, 478 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n", 479 port->read_urb->pipe, retval); 480 goto error; 481 } 482 483 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 484 if (retval) { 485 usb_kill_urb(port->read_urb); 486 dev_err(&port->dev, 487 "usb_submit_urb(read int) failed pipe 0x%x err %d", 488 port->interrupt_in_urb->pipe, retval); 489 goto error; 490 } 491 return 0; 492 493 error: 494 return retval; 495 } /* mct_u232_open */ 496 497 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on) 498 { 499 unsigned int control_state; 500 struct mct_u232_private *priv = usb_get_serial_port_data(port); 501 502 spin_lock_irq(&priv->lock); 503 if (on) 504 priv->control_state |= TIOCM_DTR | TIOCM_RTS; 505 else 506 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS); 507 control_state = priv->control_state; 508 spin_unlock_irq(&priv->lock); 509 510 mct_u232_set_modem_ctrl(port, control_state); 511 } 512 513 static void mct_u232_close(struct usb_serial_port *port) 514 { 515 /* 516 * Must kill the read urb as it is actually an interrupt urb, which 517 * generic close thus fails to kill. 518 */ 519 usb_kill_urb(port->read_urb); 520 usb_kill_urb(port->interrupt_in_urb); 521 522 usb_serial_generic_close(port); 523 } /* mct_u232_close */ 524 525 526 static void mct_u232_read_int_callback(struct urb *urb) 527 { 528 struct usb_serial_port *port = urb->context; 529 struct mct_u232_private *priv = usb_get_serial_port_data(port); 530 unsigned char *data = urb->transfer_buffer; 531 int retval; 532 int status = urb->status; 533 unsigned long flags; 534 535 switch (status) { 536 case 0: 537 /* success */ 538 break; 539 case -ECONNRESET: 540 case -ENOENT: 541 case -ESHUTDOWN: 542 /* this urb is terminated, clean up */ 543 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", 544 __func__, status); 545 return; 546 default: 547 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", 548 __func__, status); 549 goto exit; 550 } 551 552 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); 553 554 /* 555 * Work-a-round: handle the 'usual' bulk-in pipe here 556 */ 557 if (urb->transfer_buffer_length > 2) { 558 if (urb->actual_length) { 559 tty_insert_flip_string(&port->port, data, 560 urb->actual_length); 561 tty_flip_buffer_push(&port->port); 562 } 563 goto exit; 564 } 565 566 /* 567 * The interrupt-in pipe signals exceptional conditions (modem line 568 * signal changes and errors). data[0] holds MSR, data[1] holds LSR. 569 */ 570 spin_lock_irqsave(&priv->lock, flags); 571 priv->last_msr = data[MCT_U232_MSR_INDEX]; 572 573 /* Record Control Line states */ 574 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr); 575 576 mct_u232_msr_to_icount(&priv->icount, priv->last_msr); 577 578 #if 0 579 /* Not yet handled. See belkin_sa.c for further information */ 580 /* Now to report any errors */ 581 priv->last_lsr = data[MCT_U232_LSR_INDEX]; 582 /* 583 * fill in the flip buffer here, but I do not know the relation 584 * to the current/next receive buffer or characters. I need 585 * to look in to this before committing any code. 586 */ 587 if (priv->last_lsr & MCT_U232_LSR_ERR) { 588 tty = tty_port_tty_get(&port->port); 589 /* Overrun Error */ 590 if (priv->last_lsr & MCT_U232_LSR_OE) { 591 } 592 /* Parity Error */ 593 if (priv->last_lsr & MCT_U232_LSR_PE) { 594 } 595 /* Framing Error */ 596 if (priv->last_lsr & MCT_U232_LSR_FE) { 597 } 598 /* Break Indicator */ 599 if (priv->last_lsr & MCT_U232_LSR_BI) { 600 } 601 tty_kref_put(tty); 602 } 603 #endif 604 wake_up_interruptible(&priv->msr_wait); 605 spin_unlock_irqrestore(&priv->lock, flags); 606 exit: 607 retval = usb_submit_urb(urb, GFP_ATOMIC); 608 if (retval) 609 dev_err(&port->dev, 610 "%s - usb_submit_urb failed with result %d\n", 611 __func__, retval); 612 } /* mct_u232_read_int_callback */ 613 614 static void mct_u232_set_termios(struct tty_struct *tty, 615 struct usb_serial_port *port, 616 struct ktermios *old_termios) 617 { 618 struct usb_serial *serial = port->serial; 619 struct mct_u232_private *priv = usb_get_serial_port_data(port); 620 struct ktermios *termios = &tty->termios; 621 unsigned int cflag = termios->c_cflag; 622 unsigned int old_cflag = old_termios->c_cflag; 623 unsigned long flags; 624 unsigned int control_state; 625 unsigned char last_lcr; 626 627 /* get a local copy of the current port settings */ 628 spin_lock_irqsave(&priv->lock, flags); 629 control_state = priv->control_state; 630 spin_unlock_irqrestore(&priv->lock, flags); 631 last_lcr = 0; 632 633 /* 634 * Update baud rate. 635 * Do not attempt to cache old rates and skip settings, 636 * disconnects screw such tricks up completely. 637 * Premature optimization is the root of all evil. 638 */ 639 640 /* reassert DTR and RTS on transition from B0 */ 641 if ((old_cflag & CBAUD) == B0) { 642 dev_dbg(&port->dev, "%s: baud was B0\n", __func__); 643 control_state |= TIOCM_DTR | TIOCM_RTS; 644 mct_u232_set_modem_ctrl(port, control_state); 645 } 646 647 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty)); 648 649 if ((cflag & CBAUD) == B0) { 650 dev_dbg(&port->dev, "%s: baud is B0\n", __func__); 651 /* Drop RTS and DTR */ 652 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 653 mct_u232_set_modem_ctrl(port, control_state); 654 } 655 656 /* 657 * Update line control register (LCR) 658 */ 659 660 /* set the parity */ 661 if (cflag & PARENB) 662 last_lcr |= (cflag & PARODD) ? 663 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; 664 else 665 last_lcr |= MCT_U232_PARITY_NONE; 666 667 /* set the number of data bits */ 668 switch (cflag & CSIZE) { 669 case CS5: 670 last_lcr |= MCT_U232_DATA_BITS_5; break; 671 case CS6: 672 last_lcr |= MCT_U232_DATA_BITS_6; break; 673 case CS7: 674 last_lcr |= MCT_U232_DATA_BITS_7; break; 675 case CS8: 676 last_lcr |= MCT_U232_DATA_BITS_8; break; 677 default: 678 dev_err(&port->dev, 679 "CSIZE was not CS5-CS8, using default of 8\n"); 680 last_lcr |= MCT_U232_DATA_BITS_8; 681 break; 682 } 683 684 termios->c_cflag &= ~CMSPAR; 685 686 /* set the number of stop bits */ 687 last_lcr |= (cflag & CSTOPB) ? 688 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; 689 690 mct_u232_set_line_ctrl(port, last_lcr); 691 692 /* save off the modified port settings */ 693 spin_lock_irqsave(&priv->lock, flags); 694 priv->control_state = control_state; 695 priv->last_lcr = last_lcr; 696 spin_unlock_irqrestore(&priv->lock, flags); 697 } /* mct_u232_set_termios */ 698 699 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state) 700 { 701 struct usb_serial_port *port = tty->driver_data; 702 struct mct_u232_private *priv = usb_get_serial_port_data(port); 703 unsigned char lcr; 704 unsigned long flags; 705 706 spin_lock_irqsave(&priv->lock, flags); 707 lcr = priv->last_lcr; 708 709 if (break_state) 710 lcr |= MCT_U232_SET_BREAK; 711 spin_unlock_irqrestore(&priv->lock, flags); 712 713 mct_u232_set_line_ctrl(port, lcr); 714 } /* mct_u232_break_ctl */ 715 716 717 static int mct_u232_tiocmget(struct tty_struct *tty) 718 { 719 struct usb_serial_port *port = tty->driver_data; 720 struct mct_u232_private *priv = usb_get_serial_port_data(port); 721 unsigned int control_state; 722 unsigned long flags; 723 724 spin_lock_irqsave(&priv->lock, flags); 725 control_state = priv->control_state; 726 spin_unlock_irqrestore(&priv->lock, flags); 727 728 return control_state; 729 } 730 731 static int mct_u232_tiocmset(struct tty_struct *tty, 732 unsigned int set, unsigned int clear) 733 { 734 struct usb_serial_port *port = tty->driver_data; 735 struct mct_u232_private *priv = usb_get_serial_port_data(port); 736 unsigned int control_state; 737 unsigned long flags; 738 739 spin_lock_irqsave(&priv->lock, flags); 740 control_state = priv->control_state; 741 742 if (set & TIOCM_RTS) 743 control_state |= TIOCM_RTS; 744 if (set & TIOCM_DTR) 745 control_state |= TIOCM_DTR; 746 if (clear & TIOCM_RTS) 747 control_state &= ~TIOCM_RTS; 748 if (clear & TIOCM_DTR) 749 control_state &= ~TIOCM_DTR; 750 751 priv->control_state = control_state; 752 spin_unlock_irqrestore(&priv->lock, flags); 753 return mct_u232_set_modem_ctrl(port, control_state); 754 } 755 756 static void mct_u232_throttle(struct tty_struct *tty) 757 { 758 struct usb_serial_port *port = tty->driver_data; 759 struct mct_u232_private *priv = usb_get_serial_port_data(port); 760 unsigned int control_state; 761 762 spin_lock_irq(&priv->lock); 763 priv->rx_flags |= THROTTLED; 764 if (C_CRTSCTS(tty)) { 765 priv->control_state &= ~TIOCM_RTS; 766 control_state = priv->control_state; 767 spin_unlock_irq(&priv->lock); 768 mct_u232_set_modem_ctrl(port, control_state); 769 } else { 770 spin_unlock_irq(&priv->lock); 771 } 772 } 773 774 static void mct_u232_unthrottle(struct tty_struct *tty) 775 { 776 struct usb_serial_port *port = tty->driver_data; 777 struct mct_u232_private *priv = usb_get_serial_port_data(port); 778 unsigned int control_state; 779 780 spin_lock_irq(&priv->lock); 781 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) { 782 priv->rx_flags &= ~THROTTLED; 783 priv->control_state |= TIOCM_RTS; 784 control_state = priv->control_state; 785 spin_unlock_irq(&priv->lock); 786 mct_u232_set_modem_ctrl(port, control_state); 787 } else { 788 spin_unlock_irq(&priv->lock); 789 } 790 } 791 792 static int mct_u232_ioctl(struct tty_struct *tty, 793 unsigned int cmd, unsigned long arg) 794 { 795 DEFINE_WAIT(wait); 796 struct usb_serial_port *port = tty->driver_data; 797 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port); 798 struct async_icount cnow, cprev; 799 unsigned long flags; 800 801 dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd); 802 803 switch (cmd) { 804 805 case TIOCMIWAIT: 806 807 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__); 808 809 spin_lock_irqsave(&mct_u232_port->lock, flags); 810 cprev = mct_u232_port->icount; 811 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 812 for ( ; ; ) { 813 prepare_to_wait(&mct_u232_port->msr_wait, 814 &wait, TASK_INTERRUPTIBLE); 815 schedule(); 816 finish_wait(&mct_u232_port->msr_wait, &wait); 817 /* see if a signal did it */ 818 if (signal_pending(current)) 819 return -ERESTARTSYS; 820 spin_lock_irqsave(&mct_u232_port->lock, flags); 821 cnow = mct_u232_port->icount; 822 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 823 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 824 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 825 return -EIO; /* no change => error */ 826 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 827 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 828 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 829 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 830 return 0; 831 } 832 cprev = cnow; 833 } 834 835 } 836 return -ENOIOCTLCMD; 837 } 838 839 static int mct_u232_get_icount(struct tty_struct *tty, 840 struct serial_icounter_struct *icount) 841 { 842 struct usb_serial_port *port = tty->driver_data; 843 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port); 844 struct async_icount *ic = &mct_u232_port->icount; 845 unsigned long flags; 846 847 spin_lock_irqsave(&mct_u232_port->lock, flags); 848 849 icount->cts = ic->cts; 850 icount->dsr = ic->dsr; 851 icount->rng = ic->rng; 852 icount->dcd = ic->dcd; 853 icount->rx = ic->rx; 854 icount->tx = ic->tx; 855 icount->frame = ic->frame; 856 icount->overrun = ic->overrun; 857 icount->parity = ic->parity; 858 icount->brk = ic->brk; 859 icount->buf_overrun = ic->buf_overrun; 860 861 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 862 863 dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n", 864 __func__, icount->rx, icount->tx); 865 return 0; 866 } 867 868 module_usb_serial_driver(serial_drivers, id_table); 869 870 MODULE_AUTHOR(DRIVER_AUTHOR); 871 MODULE_DESCRIPTION(DRIVER_DESC); 872 MODULE_LICENSE("GPL"); 873