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 /* 42 * Version Information 43 */ 44 #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */ 45 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>" 46 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver" 47 48 static bool debug; 49 50 /* 51 * Function prototypes 52 */ 53 static int mct_u232_startup(struct usb_serial *serial); 54 static void mct_u232_release(struct usb_serial *serial); 55 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port); 56 static void mct_u232_close(struct usb_serial_port *port); 57 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on); 58 static void mct_u232_read_int_callback(struct urb *urb); 59 static void mct_u232_set_termios(struct tty_struct *tty, 60 struct usb_serial_port *port, struct ktermios *old); 61 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state); 62 static int mct_u232_tiocmget(struct tty_struct *tty); 63 static int mct_u232_tiocmset(struct tty_struct *tty, 64 unsigned int set, unsigned int clear); 65 static int mct_u232_ioctl(struct tty_struct *tty, 66 unsigned int cmd, unsigned long arg); 67 static int mct_u232_get_icount(struct tty_struct *tty, 68 struct serial_icounter_struct *icount); 69 static void mct_u232_throttle(struct tty_struct *tty); 70 static void mct_u232_unthrottle(struct tty_struct *tty); 71 72 73 /* 74 * All of the device info needed for the MCT USB-RS232 converter. 75 */ 76 static const struct usb_device_id id_table[] = { 77 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) }, 78 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) }, 79 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) }, 80 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) }, 81 { } /* Terminating entry */ 82 }; 83 MODULE_DEVICE_TABLE(usb, id_table); 84 85 static struct usb_serial_driver mct_u232_device = { 86 .driver = { 87 .owner = THIS_MODULE, 88 .name = "mct_u232", 89 }, 90 .description = "MCT U232", 91 .id_table = id_table, 92 .num_ports = 1, 93 .open = mct_u232_open, 94 .close = mct_u232_close, 95 .dtr_rts = mct_u232_dtr_rts, 96 .throttle = mct_u232_throttle, 97 .unthrottle = mct_u232_unthrottle, 98 .read_int_callback = mct_u232_read_int_callback, 99 .set_termios = mct_u232_set_termios, 100 .break_ctl = mct_u232_break_ctl, 101 .tiocmget = mct_u232_tiocmget, 102 .tiocmset = mct_u232_tiocmset, 103 .attach = mct_u232_startup, 104 .release = mct_u232_release, 105 .ioctl = mct_u232_ioctl, 106 .get_icount = mct_u232_get_icount, 107 }; 108 109 static struct usb_serial_driver * const serial_drivers[] = { 110 &mct_u232_device, NULL 111 }; 112 113 struct mct_u232_private { 114 spinlock_t lock; 115 unsigned int control_state; /* Modem Line Setting (TIOCM) */ 116 unsigned char last_lcr; /* Line Control Register */ 117 unsigned char last_lsr; /* Line Status Register */ 118 unsigned char last_msr; /* Modem Status Register */ 119 unsigned int rx_flags; /* Throttling flags */ 120 struct async_icount icount; 121 wait_queue_head_t msr_wait; /* for handling sleeping while waiting 122 for msr change to happen */ 123 }; 124 125 #define THROTTLED 0x01 126 127 /* 128 * Handle vendor specific USB requests 129 */ 130 131 #define WDR_TIMEOUT 5000 /* default urb timeout */ 132 133 /* 134 * Later day 2.6.0-test kernels have new baud rates like B230400 which 135 * we do not know how to support. We ignore them for the moment. 136 */ 137 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, 138 speed_t value, speed_t *result) 139 { 140 *result = value; 141 142 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID 143 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { 144 switch (value) { 145 case 300: 146 return 0x01; 147 case 600: 148 return 0x02; /* this one not tested */ 149 case 1200: 150 return 0x03; 151 case 2400: 152 return 0x04; 153 case 4800: 154 return 0x06; 155 case 9600: 156 return 0x08; 157 case 19200: 158 return 0x09; 159 case 38400: 160 return 0x0a; 161 case 57600: 162 return 0x0b; 163 case 115200: 164 return 0x0c; 165 default: 166 *result = 9600; 167 return 0x08; 168 } 169 } else { 170 /* FIXME: Can we use any divider - should we do 171 divider = 115200/value; 172 real baud = 115200/divider */ 173 switch (value) { 174 case 300: break; 175 case 600: break; 176 case 1200: break; 177 case 2400: break; 178 case 4800: break; 179 case 9600: break; 180 case 19200: break; 181 case 38400: break; 182 case 57600: break; 183 case 115200: break; 184 default: 185 value = 9600; 186 *result = 9600; 187 } 188 return 115200/value; 189 } 190 } 191 192 static int mct_u232_set_baud_rate(struct tty_struct *tty, 193 struct usb_serial *serial, struct usb_serial_port *port, speed_t value) 194 { 195 unsigned int divisor; 196 int rc; 197 unsigned char *buf; 198 unsigned char cts_enable_byte = 0; 199 speed_t speed; 200 201 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 202 if (buf == NULL) 203 return -ENOMEM; 204 205 divisor = mct_u232_calculate_baud_rate(serial, value, &speed); 206 put_unaligned_le32(cpu_to_le32(divisor), buf); 207 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 208 MCT_U232_SET_BAUD_RATE_REQUEST, 209 MCT_U232_SET_REQUEST_TYPE, 210 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE, 211 WDR_TIMEOUT); 212 if (rc < 0) /*FIXME: What value speed results */ 213 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n", 214 value, rc); 215 else 216 tty_encode_baud_rate(tty, speed, speed); 217 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor); 218 219 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which 220 always sends two extra USB 'device request' messages after the 221 'baud rate change' message. The actual functionality of the 222 request codes in these messages is not fully understood but these 223 particular codes are never seen in any operation besides a baud 224 rate change. Both of these messages send a single byte of data. 225 In the first message, the value of this byte is always zero. 226 227 The second message has been determined experimentally to control 228 whether data will be transmitted to a device which is not asserting 229 the 'CTS' signal. If the second message's data byte is zero, data 230 will be transmitted even if 'CTS' is not asserted (i.e. no hardware 231 flow control). if the second message's data byte is nonzero (a 232 value of 1 is used by this driver), data will not be transmitted to 233 a device which is not asserting 'CTS'. 234 */ 235 236 buf[0] = 0; 237 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 238 MCT_U232_SET_UNKNOWN1_REQUEST, 239 MCT_U232_SET_REQUEST_TYPE, 240 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE, 241 WDR_TIMEOUT); 242 if (rc < 0) 243 dev_err(&port->dev, "Sending USB device request code %d " 244 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST, 245 rc); 246 247 if (port && C_CRTSCTS(tty)) 248 cts_enable_byte = 1; 249 250 dbg("set_baud_rate: send second control message, data = %02X", 251 cts_enable_byte); 252 buf[0] = cts_enable_byte; 253 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 254 MCT_U232_SET_CTS_REQUEST, 255 MCT_U232_SET_REQUEST_TYPE, 256 0, 0, buf, MCT_U232_SET_CTS_SIZE, 257 WDR_TIMEOUT); 258 if (rc < 0) 259 dev_err(&port->dev, "Sending USB device request code %d " 260 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc); 261 262 kfree(buf); 263 return rc; 264 } /* mct_u232_set_baud_rate */ 265 266 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr) 267 { 268 int rc; 269 unsigned char *buf; 270 271 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 272 if (buf == NULL) 273 return -ENOMEM; 274 275 buf[0] = lcr; 276 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 277 MCT_U232_SET_LINE_CTRL_REQUEST, 278 MCT_U232_SET_REQUEST_TYPE, 279 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE, 280 WDR_TIMEOUT); 281 if (rc < 0) 282 dev_err(&serial->dev->dev, 283 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc); 284 dbg("set_line_ctrl: 0x%x", lcr); 285 kfree(buf); 286 return rc; 287 } /* mct_u232_set_line_ctrl */ 288 289 static int mct_u232_set_modem_ctrl(struct usb_serial *serial, 290 unsigned int control_state) 291 { 292 int rc; 293 unsigned char mcr; 294 unsigned char *buf; 295 296 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 297 if (buf == NULL) 298 return -ENOMEM; 299 300 mcr = MCT_U232_MCR_NONE; 301 if (control_state & TIOCM_DTR) 302 mcr |= MCT_U232_MCR_DTR; 303 if (control_state & TIOCM_RTS) 304 mcr |= MCT_U232_MCR_RTS; 305 306 buf[0] = mcr; 307 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 308 MCT_U232_SET_MODEM_CTRL_REQUEST, 309 MCT_U232_SET_REQUEST_TYPE, 310 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE, 311 WDR_TIMEOUT); 312 if (rc < 0) 313 dev_err(&serial->dev->dev, 314 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc); 315 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr); 316 317 kfree(buf); 318 return rc; 319 } /* mct_u232_set_modem_ctrl */ 320 321 static int mct_u232_get_modem_stat(struct usb_serial *serial, 322 unsigned char *msr) 323 { 324 int rc; 325 unsigned char *buf; 326 327 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); 328 if (buf == NULL) { 329 *msr = 0; 330 return -ENOMEM; 331 } 332 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 333 MCT_U232_GET_MODEM_STAT_REQUEST, 334 MCT_U232_GET_REQUEST_TYPE, 335 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE, 336 WDR_TIMEOUT); 337 if (rc < 0) { 338 dev_err(&serial->dev->dev, 339 "Get MODEM STATus failed (error = %d)\n", rc); 340 *msr = 0; 341 } else { 342 *msr = buf[0]; 343 } 344 dbg("get_modem_stat: 0x%x", *msr); 345 kfree(buf); 346 return rc; 347 } /* mct_u232_get_modem_stat */ 348 349 static void mct_u232_msr_to_icount(struct async_icount *icount, 350 unsigned char msr) 351 { 352 /* Translate Control Line states */ 353 if (msr & MCT_U232_MSR_DDSR) 354 icount->dsr++; 355 if (msr & MCT_U232_MSR_DCTS) 356 icount->cts++; 357 if (msr & MCT_U232_MSR_DRI) 358 icount->rng++; 359 if (msr & MCT_U232_MSR_DCD) 360 icount->dcd++; 361 } /* mct_u232_msr_to_icount */ 362 363 static void mct_u232_msr_to_state(unsigned int *control_state, 364 unsigned char msr) 365 { 366 /* Translate Control Line states */ 367 if (msr & MCT_U232_MSR_DSR) 368 *control_state |= TIOCM_DSR; 369 else 370 *control_state &= ~TIOCM_DSR; 371 if (msr & MCT_U232_MSR_CTS) 372 *control_state |= TIOCM_CTS; 373 else 374 *control_state &= ~TIOCM_CTS; 375 if (msr & MCT_U232_MSR_RI) 376 *control_state |= TIOCM_RI; 377 else 378 *control_state &= ~TIOCM_RI; 379 if (msr & MCT_U232_MSR_CD) 380 *control_state |= TIOCM_CD; 381 else 382 *control_state &= ~TIOCM_CD; 383 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state); 384 } /* mct_u232_msr_to_state */ 385 386 /* 387 * Driver's tty interface functions 388 */ 389 390 static int mct_u232_startup(struct usb_serial *serial) 391 { 392 struct mct_u232_private *priv; 393 struct usb_serial_port *port, *rport; 394 395 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL); 396 if (!priv) 397 return -ENOMEM; 398 spin_lock_init(&priv->lock); 399 init_waitqueue_head(&priv->msr_wait); 400 usb_set_serial_port_data(serial->port[0], priv); 401 402 init_waitqueue_head(&serial->port[0]->write_wait); 403 404 /* Puh, that's dirty */ 405 port = serial->port[0]; 406 rport = serial->port[1]; 407 /* No unlinking, it wasn't submitted yet. */ 408 usb_free_urb(port->read_urb); 409 port->read_urb = rport->interrupt_in_urb; 410 rport->interrupt_in_urb = NULL; 411 port->read_urb->context = port; 412 413 return 0; 414 } /* mct_u232_startup */ 415 416 417 static void mct_u232_release(struct usb_serial *serial) 418 { 419 struct mct_u232_private *priv; 420 int i; 421 422 for (i = 0; i < serial->num_ports; ++i) { 423 /* My special items, the standard routines free my urbs */ 424 priv = usb_get_serial_port_data(serial->port[i]); 425 kfree(priv); 426 } 427 } /* mct_u232_release */ 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(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 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 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 if (port->serial->dev) { 520 /* shutdown our urbs */ 521 usb_kill_urb(port->write_urb); 522 usb_kill_urb(port->read_urb); 523 usb_kill_urb(port->interrupt_in_urb); 524 } 525 } /* mct_u232_close */ 526 527 528 static void mct_u232_read_int_callback(struct urb *urb) 529 { 530 struct usb_serial_port *port = urb->context; 531 struct mct_u232_private *priv = usb_get_serial_port_data(port); 532 struct usb_serial *serial = port->serial; 533 struct tty_struct *tty; 534 unsigned char *data = urb->transfer_buffer; 535 int retval; 536 int status = urb->status; 537 unsigned long flags; 538 539 switch (status) { 540 case 0: 541 /* success */ 542 break; 543 case -ECONNRESET: 544 case -ENOENT: 545 case -ESHUTDOWN: 546 /* this urb is terminated, clean up */ 547 dbg("%s - urb shutting down with status: %d", 548 __func__, status); 549 return; 550 default: 551 dbg("%s - nonzero urb status received: %d", 552 __func__, status); 553 goto exit; 554 } 555 556 if (!serial) { 557 dbg("%s - bad serial pointer, exiting", __func__); 558 return; 559 } 560 561 usb_serial_debug_data(debug, &port->dev, __func__, 562 urb->actual_length, data); 563 564 /* 565 * Work-a-round: handle the 'usual' bulk-in pipe here 566 */ 567 if (urb->transfer_buffer_length > 2) { 568 if (urb->actual_length) { 569 tty = tty_port_tty_get(&port->port); 570 if (tty) { 571 tty_insert_flip_string(tty, data, 572 urb->actual_length); 573 tty_flip_buffer_push(tty); 574 } 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 mct_u232_msr_to_icount(&priv->icount, 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 wake_up_interruptible(&priv->msr_wait); 619 spin_unlock_irqrestore(&priv->lock, flags); 620 exit: 621 retval = usb_submit_urb(urb, GFP_ATOMIC); 622 if (retval) 623 dev_err(&port->dev, 624 "%s - usb_submit_urb failed with result %d\n", 625 __func__, retval); 626 } /* mct_u232_read_int_callback */ 627 628 static void mct_u232_set_termios(struct tty_struct *tty, 629 struct usb_serial_port *port, 630 struct ktermios *old_termios) 631 { 632 struct usb_serial *serial = port->serial; 633 struct mct_u232_private *priv = usb_get_serial_port_data(port); 634 struct ktermios *termios = tty->termios; 635 unsigned int cflag = termios->c_cflag; 636 unsigned int old_cflag = old_termios->c_cflag; 637 unsigned long flags; 638 unsigned int control_state; 639 unsigned char last_lcr; 640 641 /* get a local copy of the current port settings */ 642 spin_lock_irqsave(&priv->lock, flags); 643 control_state = priv->control_state; 644 spin_unlock_irqrestore(&priv->lock, flags); 645 last_lcr = 0; 646 647 /* 648 * Update baud rate. 649 * Do not attempt to cache old rates and skip settings, 650 * disconnects screw such tricks up completely. 651 * Premature optimization is the root of all evil. 652 */ 653 654 /* reassert DTR and RTS on transition from B0 */ 655 if ((old_cflag & CBAUD) == B0) { 656 dbg("%s: baud was B0", __func__); 657 control_state |= TIOCM_DTR | TIOCM_RTS; 658 mct_u232_set_modem_ctrl(serial, control_state); 659 } 660 661 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty)); 662 663 if ((cflag & CBAUD) == B0) { 664 dbg("%s: baud is B0", __func__); 665 /* Drop RTS and DTR */ 666 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 667 mct_u232_set_modem_ctrl(serial, control_state); 668 } 669 670 /* 671 * Update line control register (LCR) 672 */ 673 674 /* set the parity */ 675 if (cflag & PARENB) 676 last_lcr |= (cflag & PARODD) ? 677 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; 678 else 679 last_lcr |= MCT_U232_PARITY_NONE; 680 681 /* set the number of data bits */ 682 switch (cflag & CSIZE) { 683 case CS5: 684 last_lcr |= MCT_U232_DATA_BITS_5; break; 685 case CS6: 686 last_lcr |= MCT_U232_DATA_BITS_6; break; 687 case CS7: 688 last_lcr |= MCT_U232_DATA_BITS_7; break; 689 case CS8: 690 last_lcr |= MCT_U232_DATA_BITS_8; break; 691 default: 692 dev_err(&port->dev, 693 "CSIZE was not CS5-CS8, using default of 8\n"); 694 last_lcr |= MCT_U232_DATA_BITS_8; 695 break; 696 } 697 698 termios->c_cflag &= ~CMSPAR; 699 700 /* set the number of stop bits */ 701 last_lcr |= (cflag & CSTOPB) ? 702 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; 703 704 mct_u232_set_line_ctrl(serial, last_lcr); 705 706 /* save off the modified port settings */ 707 spin_lock_irqsave(&priv->lock, flags); 708 priv->control_state = control_state; 709 priv->last_lcr = last_lcr; 710 spin_unlock_irqrestore(&priv->lock, flags); 711 } /* mct_u232_set_termios */ 712 713 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state) 714 { 715 struct usb_serial_port *port = tty->driver_data; 716 struct usb_serial *serial = port->serial; 717 struct mct_u232_private *priv = usb_get_serial_port_data(port); 718 unsigned char lcr; 719 unsigned long flags; 720 721 spin_lock_irqsave(&priv->lock, flags); 722 lcr = priv->last_lcr; 723 724 if (break_state) 725 lcr |= MCT_U232_SET_BREAK; 726 spin_unlock_irqrestore(&priv->lock, flags); 727 728 mct_u232_set_line_ctrl(serial, lcr); 729 } /* mct_u232_break_ctl */ 730 731 732 static int mct_u232_tiocmget(struct tty_struct *tty) 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 spin_unlock_irqrestore(&priv->lock, flags); 742 743 return control_state; 744 } 745 746 static int mct_u232_tiocmset(struct tty_struct *tty, 747 unsigned int set, unsigned int clear) 748 { 749 struct usb_serial_port *port = tty->driver_data; 750 struct usb_serial *serial = port->serial; 751 struct mct_u232_private *priv = usb_get_serial_port_data(port); 752 unsigned int control_state; 753 unsigned long flags; 754 755 spin_lock_irqsave(&priv->lock, flags); 756 control_state = priv->control_state; 757 758 if (set & TIOCM_RTS) 759 control_state |= TIOCM_RTS; 760 if (set & TIOCM_DTR) 761 control_state |= TIOCM_DTR; 762 if (clear & TIOCM_RTS) 763 control_state &= ~TIOCM_RTS; 764 if (clear & TIOCM_DTR) 765 control_state &= ~TIOCM_DTR; 766 767 priv->control_state = control_state; 768 spin_unlock_irqrestore(&priv->lock, flags); 769 return mct_u232_set_modem_ctrl(serial, control_state); 770 } 771 772 static void mct_u232_throttle(struct tty_struct *tty) 773 { 774 struct usb_serial_port *port = tty->driver_data; 775 struct mct_u232_private *priv = usb_get_serial_port_data(port); 776 unsigned int control_state; 777 778 spin_lock_irq(&priv->lock); 779 priv->rx_flags |= THROTTLED; 780 if (C_CRTSCTS(tty)) { 781 priv->control_state &= ~TIOCM_RTS; 782 control_state = priv->control_state; 783 spin_unlock_irq(&priv->lock); 784 (void) mct_u232_set_modem_ctrl(port->serial, control_state); 785 } else { 786 spin_unlock_irq(&priv->lock); 787 } 788 } 789 790 static void mct_u232_unthrottle(struct tty_struct *tty) 791 { 792 struct usb_serial_port *port = tty->driver_data; 793 struct mct_u232_private *priv = usb_get_serial_port_data(port); 794 unsigned int control_state; 795 796 spin_lock_irq(&priv->lock); 797 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) { 798 priv->rx_flags &= ~THROTTLED; 799 priv->control_state |= TIOCM_RTS; 800 control_state = priv->control_state; 801 spin_unlock_irq(&priv->lock); 802 (void) mct_u232_set_modem_ctrl(port->serial, control_state); 803 } else { 804 spin_unlock_irq(&priv->lock); 805 } 806 } 807 808 static int mct_u232_ioctl(struct tty_struct *tty, 809 unsigned int cmd, unsigned long arg) 810 { 811 DEFINE_WAIT(wait); 812 struct usb_serial_port *port = tty->driver_data; 813 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port); 814 struct async_icount cnow, cprev; 815 unsigned long flags; 816 817 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd); 818 819 switch (cmd) { 820 821 case TIOCMIWAIT: 822 823 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 824 825 spin_lock_irqsave(&mct_u232_port->lock, flags); 826 cprev = mct_u232_port->icount; 827 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 828 for ( ; ; ) { 829 prepare_to_wait(&mct_u232_port->msr_wait, 830 &wait, TASK_INTERRUPTIBLE); 831 schedule(); 832 finish_wait(&mct_u232_port->msr_wait, &wait); 833 /* see if a signal did it */ 834 if (signal_pending(current)) 835 return -ERESTARTSYS; 836 spin_lock_irqsave(&mct_u232_port->lock, flags); 837 cnow = mct_u232_port->icount; 838 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 839 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 840 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 841 return -EIO; /* no change => error */ 842 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 843 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 844 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 845 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 846 return 0; 847 } 848 cprev = cnow; 849 } 850 851 } 852 return -ENOIOCTLCMD; 853 } 854 855 static int mct_u232_get_icount(struct tty_struct *tty, 856 struct serial_icounter_struct *icount) 857 { 858 struct usb_serial_port *port = tty->driver_data; 859 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port); 860 struct async_icount *ic = &mct_u232_port->icount; 861 unsigned long flags; 862 863 spin_lock_irqsave(&mct_u232_port->lock, flags); 864 865 icount->cts = ic->cts; 866 icount->dsr = ic->dsr; 867 icount->rng = ic->rng; 868 icount->dcd = ic->dcd; 869 icount->rx = ic->rx; 870 icount->tx = ic->tx; 871 icount->frame = ic->frame; 872 icount->overrun = ic->overrun; 873 icount->parity = ic->parity; 874 icount->brk = ic->brk; 875 icount->buf_overrun = ic->buf_overrun; 876 877 spin_unlock_irqrestore(&mct_u232_port->lock, flags); 878 879 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", 880 __func__, port->number, icount->rx, icount->tx); 881 return 0; 882 } 883 884 module_usb_serial_driver(serial_drivers, id_table); 885 886 MODULE_AUTHOR(DRIVER_AUTHOR); 887 MODULE_DESCRIPTION(DRIVER_DESC); 888 MODULE_LICENSE("GPL"); 889 890 module_param(debug, bool, S_IRUGO | S_IWUSR); 891 MODULE_PARM_DESC(debug, "Debug enabled or not"); 892