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