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 * TEST STATUS: 24 * Basic tests have been performed with minicom/zmodem transfers and 25 * modem dialing under Linux 2.4.0-test10 (for me it works fine). 26 * 27 * 04-Nov-2003 Bill Marr <marr at flex dot com> 28 * - Mimic Windows driver by sending 2 USB 'device request' messages 29 * following normal 'baud rate change' message. This allows data to be 30 * transmitted to RS-232 devices which don't assert the 'CTS' signal. 31 * 32 * 10-Nov-2001 Wolfgang Grandegger 33 * - Fixed an endianess problem with the baudrate selection for PowerPC. 34 * 35 * 06-Dec-2001 Martin Hamilton <martinh@gnu.org> 36 * Added support for the Belkin F5U109 DB9 adaptor 37 * 38 * 30-May-2001 Greg Kroah-Hartman 39 * switched from using spinlock to a semaphore, which fixes lots of problems. 40 * 41 * 04-May-2001 Stelian Pop 42 * - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes 43 * instead of the device reported 32 (using 32 bytes causes many data 44 * loss, Windows driver uses 16 too). 45 * 46 * 02-May-2001 Stelian Pop 47 * - Fixed the baud calculation for Sitecom U232-P25 model 48 * 49 * 08-Apr-2001 gb 50 * - Identify version on module load. 51 * 52 * 06-Jan-2001 Cornel Ciocirlan 53 * - Added support for Sitecom U232-P25 model (Product Id 0x0230) 54 * - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200) 55 * 56 * 29-Nov-2000 Greg Kroah-Hartman 57 * - Added device id table to fit with 2.4.0-test11 structure. 58 * - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed 59 * (lots of things will change if/when the usb-serial core changes to 60 * handle these issues. 61 * 62 * 27-Nov-2000 Wolfgang Grandegger 63 * A version for kernel 2.4.0-test10 released to the Linux community 64 * (via linux-usb-devel). 65 */ 66 67 #include <linux/config.h> 68 #include <linux/kernel.h> 69 #include <linux/errno.h> 70 #include <linux/init.h> 71 #include <linux/slab.h> 72 #include <linux/tty.h> 73 #include <linux/tty_driver.h> 74 #include <linux/tty_flip.h> 75 #include <linux/module.h> 76 #include <linux/spinlock.h> 77 #include <asm/uaccess.h> 78 #include <linux/usb.h> 79 #include "usb-serial.h" 80 #include "mct_u232.h" 81 82 /* 83 * Version Information 84 */ 85 #define DRIVER_VERSION "z2.0" /* Linux in-kernel version */ 86 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>" 87 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver" 88 89 static int debug; 90 91 /* 92 * Function prototypes 93 */ 94 static int mct_u232_startup (struct usb_serial *serial); 95 static void mct_u232_shutdown (struct usb_serial *serial); 96 static int mct_u232_open (struct usb_serial_port *port, 97 struct file *filp); 98 static void mct_u232_close (struct usb_serial_port *port, 99 struct file *filp); 100 static void mct_u232_read_int_callback (struct urb *urb, struct pt_regs *regs); 101 static void mct_u232_set_termios (struct usb_serial_port *port, 102 struct termios * old); 103 static int mct_u232_ioctl (struct usb_serial_port *port, 104 struct file * file, 105 unsigned int cmd, 106 unsigned long arg); 107 static void mct_u232_break_ctl (struct usb_serial_port *port, 108 int break_state ); 109 static int mct_u232_tiocmget (struct usb_serial_port *port, 110 struct file *file); 111 static int mct_u232_tiocmset (struct usb_serial_port *port, 112 struct file *file, unsigned int set, 113 unsigned int clear); 114 /* 115 * All of the device info needed for the MCT USB-RS232 converter. 116 */ 117 static struct usb_device_id id_table_combined [] = { 118 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) }, 119 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) }, 120 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) }, 121 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) }, 122 { } /* Terminating entry */ 123 }; 124 125 MODULE_DEVICE_TABLE (usb, id_table_combined); 126 127 static struct usb_driver mct_u232_driver = { 128 .owner = THIS_MODULE, 129 .name = "mct_u232", 130 .probe = usb_serial_probe, 131 .disconnect = usb_serial_disconnect, 132 .id_table = id_table_combined, 133 }; 134 135 static struct usb_serial_driver mct_u232_device = { 136 .driver = { 137 .owner = THIS_MODULE, 138 .name = "mct_u232", 139 }, 140 .description = "MCT U232", 141 .id_table = id_table_combined, 142 .num_interrupt_in = 2, 143 .num_bulk_in = 0, 144 .num_bulk_out = 1, 145 .num_ports = 1, 146 .open = mct_u232_open, 147 .close = mct_u232_close, 148 .read_int_callback = mct_u232_read_int_callback, 149 .ioctl = mct_u232_ioctl, 150 .set_termios = mct_u232_set_termios, 151 .break_ctl = mct_u232_break_ctl, 152 .tiocmget = mct_u232_tiocmget, 153 .tiocmset = mct_u232_tiocmset, 154 .attach = mct_u232_startup, 155 .shutdown = mct_u232_shutdown, 156 }; 157 158 159 struct mct_u232_private { 160 spinlock_t lock; 161 unsigned int control_state; /* Modem Line Setting (TIOCM) */ 162 unsigned char last_lcr; /* Line Control Register */ 163 unsigned char last_lsr; /* Line Status Register */ 164 unsigned char last_msr; /* Modem Status Register */ 165 }; 166 167 /* 168 * Handle vendor specific USB requests 169 */ 170 171 #define WDR_TIMEOUT 5000 /* default urb timeout */ 172 173 /* 174 * Later day 2.6.0-test kernels have new baud rates like B230400 which 175 * we do not know how to support. We ignore them for the moment. 176 * XXX Rate-limit the error message, it's user triggerable. 177 */ 178 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value) 179 { 180 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID 181 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { 182 switch (value) { 183 case B300: return 0x01; 184 case B600: return 0x02; /* this one not tested */ 185 case B1200: return 0x03; 186 case B2400: return 0x04; 187 case B4800: return 0x06; 188 case B9600: return 0x08; 189 case B19200: return 0x09; 190 case B38400: return 0x0a; 191 case B57600: return 0x0b; 192 case B115200: return 0x0c; 193 default: 194 err("MCT USB-RS232: unsupported baudrate request 0x%x," 195 " using default of B9600", value); 196 return 0x08; 197 } 198 } else { 199 switch (value) { 200 case B300: value = 300; break; 201 case B600: value = 600; break; 202 case B1200: value = 1200; break; 203 case B2400: value = 2400; break; 204 case B4800: value = 4800; break; 205 case B9600: value = 9600; break; 206 case B19200: value = 19200; break; 207 case B38400: value = 38400; break; 208 case B57600: value = 57600; break; 209 case B115200: value = 115200; break; 210 default: 211 err("MCT USB-RS232: unsupported baudrate request 0x%x," 212 " using default of B9600", value); 213 value = 9600; 214 } 215 return 115200/value; 216 } 217 } 218 219 static int mct_u232_set_baud_rate(struct usb_serial *serial, int value) 220 { 221 __le32 divisor; 222 int rc; 223 unsigned char zero_byte = 0; 224 225 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value)); 226 227 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 228 MCT_U232_SET_BAUD_RATE_REQUEST, 229 MCT_U232_SET_REQUEST_TYPE, 230 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE, 231 WDR_TIMEOUT); 232 if (rc < 0) 233 err("Set BAUD RATE %d failed (error = %d)", value, rc); 234 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor); 235 236 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which 237 always sends two extra USB 'device request' messages after the 238 'baud rate change' message. The actual functionality of the 239 request codes in these messages is not fully understood but these 240 particular codes are never seen in any operation besides a baud 241 rate change. Both of these messages send a single byte of data 242 whose value is always zero. The second of these two extra messages 243 is required in order for data to be properly written to an RS-232 244 device which does not assert the 'CTS' signal. */ 245 246 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 247 MCT_U232_SET_UNKNOWN1_REQUEST, 248 MCT_U232_SET_REQUEST_TYPE, 249 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE, 250 WDR_TIMEOUT); 251 if (rc < 0) 252 err("Sending USB device request code %d failed (error = %d)", 253 MCT_U232_SET_UNKNOWN1_REQUEST, rc); 254 255 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 256 MCT_U232_SET_UNKNOWN2_REQUEST, 257 MCT_U232_SET_REQUEST_TYPE, 258 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN2_SIZE, 259 WDR_TIMEOUT); 260 if (rc < 0) 261 err("Sending USB device request code %d failed (error = %d)", 262 MCT_U232_SET_UNKNOWN2_REQUEST, rc); 263 264 return rc; 265 } /* mct_u232_set_baud_rate */ 266 267 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr) 268 { 269 int rc; 270 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 271 MCT_U232_SET_LINE_CTRL_REQUEST, 272 MCT_U232_SET_REQUEST_TYPE, 273 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE, 274 WDR_TIMEOUT); 275 if (rc < 0) 276 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc); 277 dbg("set_line_ctrl: 0x%x", lcr); 278 return rc; 279 } /* mct_u232_set_line_ctrl */ 280 281 static int mct_u232_set_modem_ctrl(struct usb_serial *serial, 282 unsigned int control_state) 283 { 284 int rc; 285 unsigned char mcr = MCT_U232_MCR_NONE; 286 287 if (control_state & TIOCM_DTR) 288 mcr |= MCT_U232_MCR_DTR; 289 if (control_state & TIOCM_RTS) 290 mcr |= MCT_U232_MCR_RTS; 291 292 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 293 MCT_U232_SET_MODEM_CTRL_REQUEST, 294 MCT_U232_SET_REQUEST_TYPE, 295 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE, 296 WDR_TIMEOUT); 297 if (rc < 0) 298 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc); 299 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr); 300 301 return rc; 302 } /* mct_u232_set_modem_ctrl */ 303 304 static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr) 305 { 306 int rc; 307 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 308 MCT_U232_GET_MODEM_STAT_REQUEST, 309 MCT_U232_GET_REQUEST_TYPE, 310 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE, 311 WDR_TIMEOUT); 312 if (rc < 0) { 313 err("Get MODEM STATus failed (error = %d)", rc); 314 *msr = 0; 315 } 316 dbg("get_modem_stat: 0x%x", *msr); 317 return rc; 318 } /* mct_u232_get_modem_stat */ 319 320 static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr) 321 { 322 /* Translate Control Line states */ 323 if (msr & MCT_U232_MSR_DSR) 324 *control_state |= TIOCM_DSR; 325 else 326 *control_state &= ~TIOCM_DSR; 327 if (msr & MCT_U232_MSR_CTS) 328 *control_state |= TIOCM_CTS; 329 else 330 *control_state &= ~TIOCM_CTS; 331 if (msr & MCT_U232_MSR_RI) 332 *control_state |= TIOCM_RI; 333 else 334 *control_state &= ~TIOCM_RI; 335 if (msr & MCT_U232_MSR_CD) 336 *control_state |= TIOCM_CD; 337 else 338 *control_state &= ~TIOCM_CD; 339 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state); 340 } /* mct_u232_msr_to_state */ 341 342 /* 343 * Driver's tty interface functions 344 */ 345 346 static int mct_u232_startup (struct usb_serial *serial) 347 { 348 struct mct_u232_private *priv; 349 struct usb_serial_port *port, *rport; 350 351 priv = kmalloc(sizeof(struct mct_u232_private), GFP_KERNEL); 352 if (!priv) 353 return -ENOMEM; 354 memset(priv, 0, sizeof(struct mct_u232_private)); 355 spin_lock_init(&priv->lock); 356 usb_set_serial_port_data(serial->port[0], priv); 357 358 init_waitqueue_head(&serial->port[0]->write_wait); 359 360 /* Puh, that's dirty */ 361 port = serial->port[0]; 362 rport = serial->port[1]; 363 if (port->read_urb) { 364 /* No unlinking, it wasn't submitted yet. */ 365 usb_free_urb(port->read_urb); 366 } 367 port->read_urb = rport->interrupt_in_urb; 368 rport->interrupt_in_urb = NULL; 369 port->read_urb->context = port; 370 371 return (0); 372 } /* mct_u232_startup */ 373 374 375 static void mct_u232_shutdown (struct usb_serial *serial) 376 { 377 struct mct_u232_private *priv; 378 int i; 379 380 dbg("%s", __FUNCTION__); 381 382 for (i=0; i < serial->num_ports; ++i) { 383 /* My special items, the standard routines free my urbs */ 384 priv = usb_get_serial_port_data(serial->port[i]); 385 if (priv) { 386 usb_set_serial_port_data(serial->port[i], NULL); 387 kfree(priv); 388 } 389 } 390 } /* mct_u232_shutdown */ 391 392 static int mct_u232_open (struct usb_serial_port *port, struct file *filp) 393 { 394 struct usb_serial *serial = port->serial; 395 struct mct_u232_private *priv = usb_get_serial_port_data(port); 396 int retval = 0; 397 unsigned int control_state; 398 unsigned long flags; 399 unsigned char last_lcr; 400 unsigned char last_msr; 401 402 dbg("%s port %d", __FUNCTION__, port->number); 403 404 /* Compensate for a hardware bug: although the Sitecom U232-P25 405 * device reports a maximum output packet size of 32 bytes, 406 * it seems to be able to accept only 16 bytes (and that's what 407 * SniffUSB says too...) 408 */ 409 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID) 410 port->bulk_out_size = 16; 411 412 /* Do a defined restart: the normal serial device seems to 413 * always turn on DTR and RTS here, so do the same. I'm not 414 * sure if this is really necessary. But it should not harm 415 * either. 416 */ 417 spin_lock_irqsave(&priv->lock, flags); 418 if (port->tty->termios->c_cflag & CBAUD) 419 priv->control_state = TIOCM_DTR | TIOCM_RTS; 420 else 421 priv->control_state = 0; 422 423 priv->last_lcr = (MCT_U232_DATA_BITS_8 | 424 MCT_U232_PARITY_NONE | 425 MCT_U232_STOP_BITS_1); 426 control_state = priv->control_state; 427 last_lcr = priv->last_lcr; 428 spin_unlock_irqrestore(&priv->lock, flags); 429 mct_u232_set_modem_ctrl(serial, control_state); 430 mct_u232_set_line_ctrl(serial, last_lcr); 431 432 /* Read modem status and update control state */ 433 mct_u232_get_modem_stat(serial, &last_msr); 434 spin_lock_irqsave(&priv->lock, flags); 435 priv->last_msr = last_msr; 436 mct_u232_msr_to_state(&priv->control_state, priv->last_msr); 437 spin_unlock_irqrestore(&priv->lock, flags); 438 439 port->read_urb->dev = port->serial->dev; 440 retval = usb_submit_urb(port->read_urb, GFP_KERNEL); 441 if (retval) { 442 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d", 443 port->read_urb->pipe, retval); 444 goto exit; 445 } 446 447 port->interrupt_in_urb->dev = port->serial->dev; 448 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 449 if (retval) 450 err(" usb_submit_urb(read int) failed pipe 0x%x err %d", 451 port->interrupt_in_urb->pipe, retval); 452 453 exit: 454 return 0; 455 } /* mct_u232_open */ 456 457 458 static void mct_u232_close (struct usb_serial_port *port, struct file *filp) 459 { 460 dbg("%s port %d", __FUNCTION__, port->number); 461 462 if (port->serial->dev) { 463 /* shutdown our urbs */ 464 usb_kill_urb(port->write_urb); 465 usb_kill_urb(port->read_urb); 466 usb_kill_urb(port->interrupt_in_urb); 467 } 468 } /* mct_u232_close */ 469 470 471 static void mct_u232_read_int_callback (struct urb *urb, struct pt_regs *regs) 472 { 473 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 474 struct mct_u232_private *priv = usb_get_serial_port_data(port); 475 struct usb_serial *serial = port->serial; 476 struct tty_struct *tty; 477 unsigned char *data = urb->transfer_buffer; 478 int status; 479 unsigned long flags; 480 481 switch (urb->status) { 482 case 0: 483 /* success */ 484 break; 485 case -ECONNRESET: 486 case -ENOENT: 487 case -ESHUTDOWN: 488 /* this urb is terminated, clean up */ 489 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status); 490 return; 491 default: 492 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status); 493 goto exit; 494 } 495 496 if (!serial) { 497 dbg("%s - bad serial pointer, exiting", __FUNCTION__); 498 return; 499 } 500 501 dbg("%s - port %d", __FUNCTION__, port->number); 502 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); 503 504 /* 505 * Work-a-round: handle the 'usual' bulk-in pipe here 506 */ 507 if (urb->transfer_buffer_length > 2) { 508 int i; 509 tty = port->tty; 510 if (urb->actual_length) { 511 for (i = 0; i < urb->actual_length ; ++i) { 512 tty_insert_flip_char(tty, data[i], 0); 513 } 514 tty_flip_buffer_push(tty); 515 } 516 goto exit; 517 } 518 519 /* 520 * The interrupt-in pipe signals exceptional conditions (modem line 521 * signal changes and errors). data[0] holds MSR, data[1] holds LSR. 522 */ 523 spin_lock_irqsave(&priv->lock, flags); 524 priv->last_msr = data[MCT_U232_MSR_INDEX]; 525 526 /* Record Control Line states */ 527 mct_u232_msr_to_state(&priv->control_state, priv->last_msr); 528 529 #if 0 530 /* Not yet handled. See belin_sa.c for further information */ 531 /* Now to report any errors */ 532 priv->last_lsr = data[MCT_U232_LSR_INDEX]; 533 /* 534 * fill in the flip buffer here, but I do not know the relation 535 * to the current/next receive buffer or characters. I need 536 * to look in to this before committing any code. 537 */ 538 if (priv->last_lsr & MCT_U232_LSR_ERR) { 539 tty = port->tty; 540 /* Overrun Error */ 541 if (priv->last_lsr & MCT_U232_LSR_OE) { 542 } 543 /* Parity Error */ 544 if (priv->last_lsr & MCT_U232_LSR_PE) { 545 } 546 /* Framing Error */ 547 if (priv->last_lsr & MCT_U232_LSR_FE) { 548 } 549 /* Break Indicator */ 550 if (priv->last_lsr & MCT_U232_LSR_BI) { 551 } 552 } 553 #endif 554 spin_unlock_irqrestore(&priv->lock, flags); 555 exit: 556 status = usb_submit_urb (urb, GFP_ATOMIC); 557 if (status) 558 err ("%s - usb_submit_urb failed with result %d", 559 __FUNCTION__, status); 560 } /* mct_u232_read_int_callback */ 561 562 static void mct_u232_set_termios (struct usb_serial_port *port, 563 struct termios *old_termios) 564 { 565 struct usb_serial *serial = port->serial; 566 struct mct_u232_private *priv = usb_get_serial_port_data(port); 567 unsigned int iflag = port->tty->termios->c_iflag; 568 unsigned int cflag = port->tty->termios->c_cflag; 569 unsigned int old_cflag = old_termios->c_cflag; 570 unsigned long flags; 571 unsigned int control_state, new_state; 572 unsigned char last_lcr; 573 574 /* get a local copy of the current port settings */ 575 spin_lock_irqsave(&priv->lock, flags); 576 control_state = priv->control_state; 577 spin_unlock_irqrestore(&priv->lock, flags); 578 last_lcr = 0; 579 580 /* 581 * Update baud rate. 582 * Do not attempt to cache old rates and skip settings, 583 * disconnects screw such tricks up completely. 584 * Premature optimization is the root of all evil. 585 */ 586 587 /* reassert DTR and (maybe) RTS on transition from B0 */ 588 if ((old_cflag & CBAUD) == B0) { 589 dbg("%s: baud was B0", __FUNCTION__); 590 control_state |= TIOCM_DTR; 591 /* don't set RTS if using hardware flow control */ 592 if (!(old_cflag & CRTSCTS)) { 593 control_state |= TIOCM_RTS; 594 } 595 mct_u232_set_modem_ctrl(serial, control_state); 596 } 597 598 mct_u232_set_baud_rate(serial, cflag & CBAUD); 599 600 if ((cflag & CBAUD) == B0 ) { 601 dbg("%s: baud is B0", __FUNCTION__); 602 /* Drop RTS and DTR */ 603 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 604 mct_u232_set_modem_ctrl(serial, control_state); 605 } 606 607 /* 608 * Update line control register (LCR) 609 */ 610 611 /* set the parity */ 612 if (cflag & PARENB) 613 last_lcr |= (cflag & PARODD) ? 614 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; 615 else 616 last_lcr |= MCT_U232_PARITY_NONE; 617 618 /* set the number of data bits */ 619 switch (cflag & CSIZE) { 620 case CS5: 621 last_lcr |= MCT_U232_DATA_BITS_5; break; 622 case CS6: 623 last_lcr |= MCT_U232_DATA_BITS_6; break; 624 case CS7: 625 last_lcr |= MCT_U232_DATA_BITS_7; break; 626 case CS8: 627 last_lcr |= MCT_U232_DATA_BITS_8; break; 628 default: 629 err("CSIZE was not CS5-CS8, using default of 8"); 630 last_lcr |= MCT_U232_DATA_BITS_8; 631 break; 632 } 633 634 /* set the number of stop bits */ 635 last_lcr |= (cflag & CSTOPB) ? 636 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; 637 638 mct_u232_set_line_ctrl(serial, last_lcr); 639 640 /* 641 * Set flow control: well, I do not really now how to handle DTR/RTS. 642 * Just do what we have seen with SniffUSB on Win98. 643 */ 644 /* Drop DTR/RTS if no flow control otherwise assert */ 645 new_state = control_state; 646 if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS)) 647 new_state |= TIOCM_DTR | TIOCM_RTS; 648 else 649 new_state &= ~(TIOCM_DTR | TIOCM_RTS); 650 if (new_state != control_state) { 651 mct_u232_set_modem_ctrl(serial, new_state); 652 control_state = new_state; 653 } 654 655 /* save off the modified port settings */ 656 spin_lock_irqsave(&priv->lock, flags); 657 priv->control_state = control_state; 658 priv->last_lcr = last_lcr; 659 spin_unlock_irqrestore(&priv->lock, flags); 660 } /* mct_u232_set_termios */ 661 662 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state ) 663 { 664 struct usb_serial *serial = port->serial; 665 struct mct_u232_private *priv = usb_get_serial_port_data(port); 666 unsigned char lcr; 667 unsigned long flags; 668 669 dbg("%sstate=%d", __FUNCTION__, break_state); 670 671 spin_lock_irqsave(&priv->lock, flags); 672 lcr = priv->last_lcr; 673 spin_unlock_irqrestore(&priv->lock, flags); 674 675 if (break_state) 676 lcr |= MCT_U232_SET_BREAK; 677 678 mct_u232_set_line_ctrl(serial, lcr); 679 } /* mct_u232_break_ctl */ 680 681 682 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file) 683 { 684 struct mct_u232_private *priv = usb_get_serial_port_data(port); 685 unsigned int control_state; 686 unsigned long flags; 687 688 dbg("%s", __FUNCTION__); 689 690 spin_lock_irqsave(&priv->lock, flags); 691 control_state = priv->control_state; 692 spin_unlock_irqrestore(&priv->lock, flags); 693 694 return control_state; 695 } 696 697 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file, 698 unsigned int set, unsigned int clear) 699 { 700 struct usb_serial *serial = port->serial; 701 struct mct_u232_private *priv = usb_get_serial_port_data(port); 702 unsigned int control_state; 703 unsigned long flags; 704 705 dbg("%s", __FUNCTION__); 706 707 spin_lock_irqsave(&priv->lock, flags); 708 control_state = priv->control_state; 709 710 if (set & TIOCM_RTS) 711 control_state |= TIOCM_RTS; 712 if (set & TIOCM_DTR) 713 control_state |= TIOCM_DTR; 714 if (clear & TIOCM_RTS) 715 control_state &= ~TIOCM_RTS; 716 if (clear & TIOCM_DTR) 717 control_state &= ~TIOCM_DTR; 718 719 priv->control_state = control_state; 720 spin_unlock_irqrestore(&priv->lock, flags); 721 return mct_u232_set_modem_ctrl(serial, control_state); 722 } 723 724 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file, 725 unsigned int cmd, unsigned long arg) 726 { 727 dbg("%scmd=0x%x", __FUNCTION__, cmd); 728 729 /* Based on code from acm.c and others */ 730 switch (cmd) { 731 case TIOCMIWAIT: 732 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/ 733 /* TODO */ 734 return( 0 ); 735 736 case TIOCGICOUNT: 737 /* return count of modemline transitions */ 738 /* TODO */ 739 return 0; 740 741 default: 742 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd); 743 return(-ENOIOCTLCMD); 744 break; 745 } 746 return 0; 747 } /* mct_u232_ioctl */ 748 749 750 static int __init mct_u232_init (void) 751 { 752 int retval; 753 retval = usb_serial_register(&mct_u232_device); 754 if (retval) 755 goto failed_usb_serial_register; 756 retval = usb_register(&mct_u232_driver); 757 if (retval) 758 goto failed_usb_register; 759 info(DRIVER_DESC " " DRIVER_VERSION); 760 return 0; 761 failed_usb_register: 762 usb_serial_deregister(&mct_u232_device); 763 failed_usb_serial_register: 764 return retval; 765 } 766 767 768 static void __exit mct_u232_exit (void) 769 { 770 usb_deregister (&mct_u232_driver); 771 usb_serial_deregister (&mct_u232_device); 772 } 773 774 775 module_init (mct_u232_init); 776 module_exit(mct_u232_exit); 777 778 MODULE_AUTHOR( DRIVER_AUTHOR ); 779 MODULE_DESCRIPTION( DRIVER_DESC ); 780 MODULE_LICENSE("GPL"); 781 782 module_param(debug, bool, S_IRUGO | S_IWUSR); 783 MODULE_PARM_DESC(debug, "Debug enabled or not"); 784