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