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