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