tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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