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