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_shutdown(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 tty_struct *tty, 99 struct usb_serial_port *port, struct file *filp); 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 .throttle = mct_u232_throttle, 144 .unthrottle = mct_u232_unthrottle, 145 .read_int_callback = mct_u232_read_int_callback, 146 .set_termios = mct_u232_set_termios, 147 .break_ctl = mct_u232_break_ctl, 148 .tiocmget = mct_u232_tiocmget, 149 .tiocmset = mct_u232_tiocmset, 150 .attach = mct_u232_startup, 151 .shutdown = mct_u232_shutdown, 152 }; 153 154 155 struct mct_u232_private { 156 spinlock_t lock; 157 unsigned int control_state; /* Modem Line Setting (TIOCM) */ 158 unsigned char last_lcr; /* Line Control Register */ 159 unsigned char last_lsr; /* Line Status Register */ 160 unsigned char last_msr; /* Modem Status Register */ 161 unsigned int rx_flags; /* Throttling flags */ 162 }; 163 164 #define THROTTLED 0x01 165 166 /* 167 * Handle vendor specific USB requests 168 */ 169 170 #define WDR_TIMEOUT 5000 /* default urb timeout */ 171 172 /* 173 * Later day 2.6.0-test kernels have new baud rates like B230400 which 174 * we do not know how to support. We ignore them for the moment. 175 */ 176 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, 177 speed_t value, speed_t *result) 178 { 179 *result = value; 180 181 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID 182 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { 183 switch (value) { 184 case 300: 185 return 0x01; 186 case 600: 187 return 0x02; /* this one not tested */ 188 case 1200: 189 return 0x03; 190 case 2400: 191 return 0x04; 192 case 4800: 193 return 0x06; 194 case 9600: 195 return 0x08; 196 case 19200: 197 return 0x09; 198 case 38400: 199 return 0x0a; 200 case 57600: 201 return 0x0b; 202 case 115200: 203 return 0x0c; 204 default: 205 *result = 9600; 206 return 0x08; 207 } 208 } else { 209 /* FIXME: Can we use any divider - should we do 210 divider = 115200/value; 211 real baud = 115200/divider */ 212 switch (value) { 213 case 300: break; 214 case 600: break; 215 case 1200: break; 216 case 2400: break; 217 case 4800: break; 218 case 9600: break; 219 case 19200: break; 220 case 38400: break; 221 case 57600: break; 222 case 115200: break; 223 default: 224 value = 9600; 225 *result = 9600; 226 } 227 return 115200/value; 228 } 229 } 230 231 static int mct_u232_set_baud_rate(struct tty_struct *tty, 232 struct usb_serial *serial, struct usb_serial_port *port, speed_t value) 233 { 234 __le32 divisor; 235 int rc; 236 unsigned char zero_byte = 0; 237 unsigned char cts_enable_byte = 0; 238 speed_t speed; 239 240 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value, 241 &speed)); 242 243 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 244 MCT_U232_SET_BAUD_RATE_REQUEST, 245 MCT_U232_SET_REQUEST_TYPE, 246 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE, 247 WDR_TIMEOUT); 248 if (rc < 0) /*FIXME: What value speed results */ 249 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n", 250 value, rc); 251 else 252 tty_encode_baud_rate(tty, speed, speed); 253 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor); 254 255 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which 256 always sends two extra USB 'device request' messages after the 257 'baud rate change' message. The actual functionality of the 258 request codes in these messages is not fully understood but these 259 particular codes are never seen in any operation besides a baud 260 rate change. Both of these messages send a single byte of data. 261 In the first message, the value of this byte is always zero. 262 263 The second message has been determined experimentally to control 264 whether data will be transmitted to a device which is not asserting 265 the 'CTS' signal. If the second message's data byte is zero, data 266 will be transmitted even if 'CTS' is not asserted (i.e. no hardware 267 flow control). if the second message's data byte is nonzero (a 268 value of 1 is used by this driver), data will not be transmitted to 269 a device which is not asserting 'CTS'. 270 */ 271 272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 273 MCT_U232_SET_UNKNOWN1_REQUEST, 274 MCT_U232_SET_REQUEST_TYPE, 275 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE, 276 WDR_TIMEOUT); 277 if (rc < 0) 278 dev_err(&port->dev, "Sending USB device request code %d " 279 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST, 280 rc); 281 282 if (port && C_CRTSCTS(tty)) 283 cts_enable_byte = 1; 284 285 dbg("set_baud_rate: send second control message, data = %02X", 286 cts_enable_byte); 287 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 288 MCT_U232_SET_CTS_REQUEST, 289 MCT_U232_SET_REQUEST_TYPE, 290 0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE, 291 WDR_TIMEOUT); 292 if (rc < 0) 293 dev_err(&port->dev, "Sending USB device request code %d " 294 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc); 295 296 return rc; 297 } /* mct_u232_set_baud_rate */ 298 299 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr) 300 { 301 int rc; 302 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 303 MCT_U232_SET_LINE_CTRL_REQUEST, 304 MCT_U232_SET_REQUEST_TYPE, 305 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE, 306 WDR_TIMEOUT); 307 if (rc < 0) 308 dev_err(&serial->dev->dev, 309 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc); 310 dbg("set_line_ctrl: 0x%x", lcr); 311 return rc; 312 } /* mct_u232_set_line_ctrl */ 313 314 static int mct_u232_set_modem_ctrl(struct usb_serial *serial, 315 unsigned int control_state) 316 { 317 int rc; 318 unsigned char mcr = MCT_U232_MCR_NONE; 319 320 if (control_state & TIOCM_DTR) 321 mcr |= MCT_U232_MCR_DTR; 322 if (control_state & TIOCM_RTS) 323 mcr |= MCT_U232_MCR_RTS; 324 325 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 326 MCT_U232_SET_MODEM_CTRL_REQUEST, 327 MCT_U232_SET_REQUEST_TYPE, 328 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE, 329 WDR_TIMEOUT); 330 if (rc < 0) 331 dev_err(&serial->dev->dev, 332 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc); 333 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr); 334 335 return rc; 336 } /* mct_u232_set_modem_ctrl */ 337 338 static int mct_u232_get_modem_stat(struct usb_serial *serial, 339 unsigned char *msr) 340 { 341 int rc; 342 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 343 MCT_U232_GET_MODEM_STAT_REQUEST, 344 MCT_U232_GET_REQUEST_TYPE, 345 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE, 346 WDR_TIMEOUT); 347 if (rc < 0) { 348 dev_err(&serial->dev->dev, 349 "Get MODEM STATus failed (error = %d)\n", rc); 350 *msr = 0; 351 } 352 dbg("get_modem_stat: 0x%x", *msr); 353 return rc; 354 } /* mct_u232_get_modem_stat */ 355 356 static void mct_u232_msr_to_state(unsigned int *control_state, 357 unsigned char msr) 358 { 359 /* Translate Control Line states */ 360 if (msr & MCT_U232_MSR_DSR) 361 *control_state |= TIOCM_DSR; 362 else 363 *control_state &= ~TIOCM_DSR; 364 if (msr & MCT_U232_MSR_CTS) 365 *control_state |= TIOCM_CTS; 366 else 367 *control_state &= ~TIOCM_CTS; 368 if (msr & MCT_U232_MSR_RI) 369 *control_state |= TIOCM_RI; 370 else 371 *control_state &= ~TIOCM_RI; 372 if (msr & MCT_U232_MSR_CD) 373 *control_state |= TIOCM_CD; 374 else 375 *control_state &= ~TIOCM_CD; 376 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state); 377 } /* mct_u232_msr_to_state */ 378 379 /* 380 * Driver's tty interface functions 381 */ 382 383 static int mct_u232_startup(struct usb_serial *serial) 384 { 385 struct mct_u232_private *priv; 386 struct usb_serial_port *port, *rport; 387 388 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL); 389 if (!priv) 390 return -ENOMEM; 391 spin_lock_init(&priv->lock); 392 usb_set_serial_port_data(serial->port[0], priv); 393 394 init_waitqueue_head(&serial->port[0]->write_wait); 395 396 /* Puh, that's dirty */ 397 port = serial->port[0]; 398 rport = serial->port[1]; 399 /* No unlinking, it wasn't submitted yet. */ 400 usb_free_urb(port->read_urb); 401 port->read_urb = rport->interrupt_in_urb; 402 rport->interrupt_in_urb = NULL; 403 port->read_urb->context = port; 404 405 return 0; 406 } /* mct_u232_startup */ 407 408 409 static void mct_u232_shutdown(struct usb_serial *serial) 410 { 411 struct mct_u232_private *priv; 412 int i; 413 414 dbg("%s", __func__); 415 416 for (i = 0; i < serial->num_ports; ++i) { 417 /* My special items, the standard routines free my urbs */ 418 priv = usb_get_serial_port_data(serial->port[i]); 419 if (priv) { 420 usb_set_serial_port_data(serial->port[i], NULL); 421 kfree(priv); 422 } 423 } 424 } /* mct_u232_shutdown */ 425 426 static int mct_u232_open(struct tty_struct *tty, 427 struct usb_serial_port *port, struct file *filp) 428 { 429 struct usb_serial *serial = port->serial; 430 struct mct_u232_private *priv = usb_get_serial_port_data(port); 431 int retval = 0; 432 unsigned int control_state; 433 unsigned long flags; 434 unsigned char last_lcr; 435 unsigned char last_msr; 436 437 dbg("%s port %d", __func__, port->number); 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(serial, control_state); 466 mct_u232_set_line_ctrl(serial, last_lcr); 467 468 /* Read modem status and update control state */ 469 mct_u232_get_modem_stat(serial, &last_msr); 470 spin_lock_irqsave(&priv->lock, flags); 471 priv->last_msr = last_msr; 472 mct_u232_msr_to_state(&priv->control_state, priv->last_msr); 473 spin_unlock_irqrestore(&priv->lock, flags); 474 475 port->read_urb->dev = port->serial->dev; 476 retval = usb_submit_urb(port->read_urb, GFP_KERNEL); 477 if (retval) { 478 dev_err(&port->dev, 479 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n", 480 port->read_urb->pipe, retval); 481 goto error; 482 } 483 484 port->interrupt_in_urb->dev = port->serial->dev; 485 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 486 if (retval) { 487 usb_kill_urb(port->read_urb); 488 dev_err(&port->dev, 489 "usb_submit_urb(read int) failed pipe 0x%x err %d", 490 port->interrupt_in_urb->pipe, retval); 491 goto error; 492 } 493 return 0; 494 495 error: 496 return retval; 497 } /* mct_u232_open */ 498 499 500 static void mct_u232_close(struct tty_struct *tty, 501 struct usb_serial_port *port, struct file *filp) 502 { 503 unsigned int c_cflag; 504 unsigned int control_state; 505 struct mct_u232_private *priv = usb_get_serial_port_data(port); 506 dbg("%s port %d", __func__, port->number); 507 508 if (tty) { 509 c_cflag = tty->termios->c_cflag; 510 mutex_lock(&port->serial->disc_mutex); 511 if (c_cflag & HUPCL && !port->serial->disconnected) { 512 /* drop DTR and RTS */ 513 spin_lock_irq(&priv->lock); 514 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS); 515 control_state = priv->control_state; 516 spin_unlock_irq(&priv->lock); 517 mct_u232_set_modem_ctrl(port->serial, control_state); 518 } 519 mutex_unlock(&port->serial->disc_mutex); 520 } 521 522 523 if (port->serial->dev) { 524 /* shutdown our urbs */ 525 usb_kill_urb(port->write_urb); 526 usb_kill_urb(port->read_urb); 527 usb_kill_urb(port->interrupt_in_urb); 528 } 529 } /* mct_u232_close */ 530 531 532 static void mct_u232_read_int_callback(struct urb *urb) 533 { 534 struct usb_serial_port *port = urb->context; 535 struct mct_u232_private *priv = usb_get_serial_port_data(port); 536 struct usb_serial *serial = port->serial; 537 struct tty_struct *tty; 538 unsigned char *data = urb->transfer_buffer; 539 int retval; 540 int status = urb->status; 541 unsigned long flags; 542 543 switch (status) { 544 case 0: 545 /* success */ 546 break; 547 case -ECONNRESET: 548 case -ENOENT: 549 case -ESHUTDOWN: 550 /* this urb is terminated, clean up */ 551 dbg("%s - urb shutting down with status: %d", 552 __func__, status); 553 return; 554 default: 555 dbg("%s - nonzero urb status received: %d", 556 __func__, status); 557 goto exit; 558 } 559 560 if (!serial) { 561 dbg("%s - bad serial pointer, exiting", __func__); 562 return; 563 } 564 565 dbg("%s - port %d", __func__, port->number); 566 usb_serial_debug_data(debug, &port->dev, __func__, 567 urb->actual_length, data); 568 569 /* 570 * Work-a-round: handle the 'usual' bulk-in pipe here 571 */ 572 if (urb->transfer_buffer_length > 2) { 573 tty = tty_port_tty_get(&port->port); 574 if (urb->actual_length) { 575 tty_insert_flip_string(tty, data, urb->actual_length); 576 tty_flip_buffer_push(tty); 577 tty_kref_put(tty); 578 } 579 goto exit; 580 } 581 582 /* 583 * The interrupt-in pipe signals exceptional conditions (modem line 584 * signal changes and errors). data[0] holds MSR, data[1] holds LSR. 585 */ 586 spin_lock_irqsave(&priv->lock, flags); 587 priv->last_msr = data[MCT_U232_MSR_INDEX]; 588 589 /* Record Control Line states */ 590 mct_u232_msr_to_state(&priv->control_state, priv->last_msr); 591 592 #if 0 593 /* Not yet handled. See belkin_sa.c for further information */ 594 /* Now to report any errors */ 595 priv->last_lsr = data[MCT_U232_LSR_INDEX]; 596 /* 597 * fill in the flip buffer here, but I do not know the relation 598 * to the current/next receive buffer or characters. I need 599 * to look in to this before committing any code. 600 */ 601 if (priv->last_lsr & MCT_U232_LSR_ERR) { 602 tty = tty_port_tty_get(&port->port); 603 /* Overrun Error */ 604 if (priv->last_lsr & MCT_U232_LSR_OE) { 605 } 606 /* Parity Error */ 607 if (priv->last_lsr & MCT_U232_LSR_PE) { 608 } 609 /* Framing Error */ 610 if (priv->last_lsr & MCT_U232_LSR_FE) { 611 } 612 /* Break Indicator */ 613 if (priv->last_lsr & MCT_U232_LSR_BI) { 614 } 615 tty_kref_put(tty); 616 } 617 #endif 618 spin_unlock_irqrestore(&priv->lock, flags); 619 exit: 620 retval = usb_submit_urb(urb, GFP_ATOMIC); 621 if (retval) 622 dev_err(&port->dev, 623 "%s - usb_submit_urb failed with result %d\n", 624 __func__, retval); 625 } /* mct_u232_read_int_callback */ 626 627 static void mct_u232_set_termios(struct tty_struct *tty, 628 struct usb_serial_port *port, 629 struct ktermios *old_termios) 630 { 631 struct usb_serial *serial = port->serial; 632 struct mct_u232_private *priv = usb_get_serial_port_data(port); 633 struct ktermios *termios = tty->termios; 634 unsigned int cflag = termios->c_cflag; 635 unsigned int old_cflag = old_termios->c_cflag; 636 unsigned long flags; 637 unsigned int control_state; 638 unsigned char last_lcr; 639 640 /* get a local copy of the current port settings */ 641 spin_lock_irqsave(&priv->lock, flags); 642 control_state = priv->control_state; 643 spin_unlock_irqrestore(&priv->lock, flags); 644 last_lcr = 0; 645 646 /* 647 * Update baud rate. 648 * Do not attempt to cache old rates and skip settings, 649 * disconnects screw such tricks up completely. 650 * Premature optimization is the root of all evil. 651 */ 652 653 /* reassert DTR and RTS on transition from B0 */ 654 if ((old_cflag & CBAUD) == B0) { 655 dbg("%s: baud was B0", __func__); 656 control_state |= TIOCM_DTR | TIOCM_RTS; 657 mct_u232_set_modem_ctrl(serial, control_state); 658 } 659 660 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty)); 661 662 if ((cflag & CBAUD) == B0) { 663 dbg("%s: baud is B0", __func__); 664 /* Drop RTS and DTR */ 665 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 666 mct_u232_set_modem_ctrl(serial, control_state); 667 } 668 669 /* 670 * Update line control register (LCR) 671 */ 672 673 /* set the parity */ 674 if (cflag & PARENB) 675 last_lcr |= (cflag & PARODD) ? 676 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; 677 else 678 last_lcr |= MCT_U232_PARITY_NONE; 679 680 /* set the number of data bits */ 681 switch (cflag & CSIZE) { 682 case CS5: 683 last_lcr |= MCT_U232_DATA_BITS_5; break; 684 case CS6: 685 last_lcr |= MCT_U232_DATA_BITS_6; break; 686 case CS7: 687 last_lcr |= MCT_U232_DATA_BITS_7; break; 688 case CS8: 689 last_lcr |= MCT_U232_DATA_BITS_8; break; 690 default: 691 dev_err(&port->dev, 692 "CSIZE was not CS5-CS8, using default of 8\n"); 693 last_lcr |= MCT_U232_DATA_BITS_8; 694 break; 695 } 696 697 termios->c_cflag &= ~CMSPAR; 698 699 /* set the number of stop bits */ 700 last_lcr |= (cflag & CSTOPB) ? 701 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; 702 703 mct_u232_set_line_ctrl(serial, last_lcr); 704 705 /* save off the modified port settings */ 706 spin_lock_irqsave(&priv->lock, flags); 707 priv->control_state = control_state; 708 priv->last_lcr = last_lcr; 709 spin_unlock_irqrestore(&priv->lock, flags); 710 } /* mct_u232_set_termios */ 711 712 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state) 713 { 714 struct usb_serial_port *port = tty->driver_data; 715 struct usb_serial *serial = port->serial; 716 struct mct_u232_private *priv = usb_get_serial_port_data(port); 717 unsigned char lcr; 718 unsigned long flags; 719 720 dbg("%sstate=%d", __func__, break_state); 721 722 spin_lock_irqsave(&priv->lock, flags); 723 lcr = priv->last_lcr; 724 spin_unlock_irqrestore(&priv->lock, flags); 725 726 if (break_state) 727 lcr |= MCT_U232_SET_BREAK; 728 729 mct_u232_set_line_ctrl(serial, lcr); 730 } /* mct_u232_break_ctl */ 731 732 733 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file) 734 { 735 struct usb_serial_port *port = tty->driver_data; 736 struct mct_u232_private *priv = usb_get_serial_port_data(port); 737 unsigned int control_state; 738 unsigned long flags; 739 740 dbg("%s", __func__); 741 742 spin_lock_irqsave(&priv->lock, flags); 743 control_state = priv->control_state; 744 spin_unlock_irqrestore(&priv->lock, flags); 745 746 return control_state; 747 } 748 749 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file, 750 unsigned int set, unsigned int clear) 751 { 752 struct usb_serial_port *port = tty->driver_data; 753 struct usb_serial *serial = port->serial; 754 struct mct_u232_private *priv = usb_get_serial_port_data(port); 755 unsigned int control_state; 756 unsigned long flags; 757 758 dbg("%s", __func__); 759 760 spin_lock_irqsave(&priv->lock, flags); 761 control_state = priv->control_state; 762 763 if (set & TIOCM_RTS) 764 control_state |= TIOCM_RTS; 765 if (set & TIOCM_DTR) 766 control_state |= TIOCM_DTR; 767 if (clear & TIOCM_RTS) 768 control_state &= ~TIOCM_RTS; 769 if (clear & TIOCM_DTR) 770 control_state &= ~TIOCM_DTR; 771 772 priv->control_state = control_state; 773 spin_unlock_irqrestore(&priv->lock, flags); 774 return mct_u232_set_modem_ctrl(serial, control_state); 775 } 776 777 static void mct_u232_throttle(struct tty_struct *tty) 778 { 779 struct usb_serial_port *port = tty->driver_data; 780 struct mct_u232_private *priv = usb_get_serial_port_data(port); 781 unsigned long flags; 782 unsigned int control_state; 783 784 dbg("%s - port %d", __func__, port->number); 785 786 spin_lock_irqsave(&priv->lock, flags); 787 priv->rx_flags |= THROTTLED; 788 if (C_CRTSCTS(tty)) { 789 priv->control_state &= ~TIOCM_RTS; 790 control_state = priv->control_state; 791 spin_unlock_irqrestore(&priv->lock, flags); 792 (void) mct_u232_set_modem_ctrl(port->serial, control_state); 793 } else { 794 spin_unlock_irqrestore(&priv->lock, flags); 795 } 796 } 797 798 799 static void mct_u232_unthrottle(struct tty_struct *tty) 800 { 801 struct usb_serial_port *port = tty->driver_data; 802 struct mct_u232_private *priv = usb_get_serial_port_data(port); 803 unsigned long flags; 804 unsigned int control_state; 805 806 dbg("%s - port %d", __func__, port->number); 807 808 spin_lock_irqsave(&priv->lock, flags); 809 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) { 810 priv->rx_flags &= ~THROTTLED; 811 priv->control_state |= TIOCM_RTS; 812 control_state = priv->control_state; 813 spin_unlock_irqrestore(&priv->lock, flags); 814 (void) mct_u232_set_modem_ctrl(port->serial, control_state); 815 } else { 816 spin_unlock_irqrestore(&priv->lock, flags); 817 } 818 } 819 820 static int __init mct_u232_init(void) 821 { 822 int retval; 823 retval = usb_serial_register(&mct_u232_device); 824 if (retval) 825 goto failed_usb_serial_register; 826 retval = usb_register(&mct_u232_driver); 827 if (retval) 828 goto failed_usb_register; 829 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 830 DRIVER_DESC "\n"); 831 return 0; 832 failed_usb_register: 833 usb_serial_deregister(&mct_u232_device); 834 failed_usb_serial_register: 835 return retval; 836 } 837 838 839 static void __exit mct_u232_exit(void) 840 { 841 usb_deregister(&mct_u232_driver); 842 usb_serial_deregister(&mct_u232_device); 843 } 844 845 module_init(mct_u232_init); 846 module_exit(mct_u232_exit); 847 848 MODULE_AUTHOR(DRIVER_AUTHOR); 849 MODULE_DESCRIPTION(DRIVER_DESC); 850 MODULE_LICENSE("GPL"); 851 852 module_param(debug, bool, S_IRUGO | S_IWUSR); 853 MODULE_PARM_DESC(debug, "Debug enabled or not"); 854