1/* 2 * Silicon Laboratories CP2101/CP2102 USB to RS232 serial adaptor driver 3 * 4 * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License version 8 * 2 as published by the Free Software Foundation. 9 * 10 * Support to set flow control line levels using TIOCMGET and TIOCMSET 11 * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow 12 * control thanks to Munir Nassar nassarmu@real-time.com 13 * 14 * Outstanding Issues: 15 * Buffers are not flushed when the port is opened. 16 * Multiple calls to write() may fail with "Resource temporarily unavailable" 17 * 18 */ 19 20#include <linux/kernel.h> 21#include <linux/errno.h> 22#include <linux/slab.h> 23#include <linux/tty.h> 24#include <linux/tty_flip.h> 25#include <linux/module.h> 26#include <linux/moduleparam.h> 27#include <linux/usb.h> 28#include <asm/uaccess.h> 29#include <linux/usb/serial.h> 30 31/* 32 * Version Information 33 */ 34#define DRIVER_VERSION "v0.07" 35#define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver" 36 37/* 38 * Function Prototypes 39 */ 40static int cp2101_open(struct usb_serial_port*, struct file*); 41static void cp2101_cleanup(struct usb_serial_port*); 42static void cp2101_close(struct usb_serial_port*, struct file*); 43static void cp2101_get_termios(struct usb_serial_port*); 44static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*); 45static int cp2101_tiocmget (struct usb_serial_port *, struct file *); 46static int cp2101_tiocmset (struct usb_serial_port *, struct file *, 47 unsigned int, unsigned int); 48static void cp2101_break_ctl(struct usb_serial_port*, int); 49static int cp2101_startup (struct usb_serial *); 50static void cp2101_shutdown(struct usb_serial*); 51 52 53static int debug; 54 55static struct usb_device_id id_table [] = { 56 { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */ 57 { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */ 58 { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */ 59 { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */ 60 { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */ 61 { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */ 62 { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */ 63 { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */ 64 { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */ 65 { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */ 66 { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */ 67 { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */ 68 { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */ 69 { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */ 70 { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */ 71 { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */ 72 { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */ 73 { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */ 74 { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */ 75 { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */ 76 { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */ 77 { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */ 78 { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */ 79 { } /* Terminating Entry */ 80}; 81 82MODULE_DEVICE_TABLE (usb, id_table); 83 84static struct usb_driver cp2101_driver = { 85 .name = "cp2101", 86 .probe = usb_serial_probe, 87 .disconnect = usb_serial_disconnect, 88 .id_table = id_table, 89 .no_dynamic_id = 1, 90}; 91 92static struct usb_serial_driver cp2101_device = { 93 .driver = { 94 .owner = THIS_MODULE, 95 .name = "cp2101", 96 }, 97 .usb_driver = &cp2101_driver, 98 .id_table = id_table, 99 .num_interrupt_in = 0, 100 .num_bulk_in = 0, 101 .num_bulk_out = 0, 102 .num_ports = 1, 103 .open = cp2101_open, 104 .close = cp2101_close, 105 .break_ctl = cp2101_break_ctl, 106 .set_termios = cp2101_set_termios, 107 .tiocmget = cp2101_tiocmget, 108 .tiocmset = cp2101_tiocmset, 109 .attach = cp2101_startup, 110 .shutdown = cp2101_shutdown, 111}; 112 113/* Config request types */ 114#define REQTYPE_HOST_TO_DEVICE 0x41 115#define REQTYPE_DEVICE_TO_HOST 0xc1 116 117/* Config SET requests. To GET, add 1 to the request number */ 118#define CP2101_UART 0x00 /* Enable / Disable */ 119#define CP2101_BAUDRATE 0x01 /* (BAUD_RATE_GEN_FREQ / baudrate) */ 120#define CP2101_BITS 0x03 /* 0x(0)(databits)(parity)(stopbits) */ 121#define CP2101_BREAK 0x05 /* On / Off */ 122#define CP2101_CONTROL 0x07 /* Flow control line states */ 123#define CP2101_MODEMCTL 0x13 /* Modem controls */ 124#define CP2101_CONFIG_6 0x19 /* 6 bytes of config data ??? */ 125 126/* CP2101_UART */ 127#define UART_ENABLE 0x0001 128#define UART_DISABLE 0x0000 129 130/* CP2101_BAUDRATE */ 131#define BAUD_RATE_GEN_FREQ 0x384000 132 133/* CP2101_BITS */ 134#define BITS_DATA_MASK 0X0f00 135#define BITS_DATA_5 0X0500 136#define BITS_DATA_6 0X0600 137#define BITS_DATA_7 0X0700 138#define BITS_DATA_8 0X0800 139#define BITS_DATA_9 0X0900 140 141#define BITS_PARITY_MASK 0x00f0 142#define BITS_PARITY_NONE 0x0000 143#define BITS_PARITY_ODD 0x0010 144#define BITS_PARITY_EVEN 0x0020 145#define BITS_PARITY_MARK 0x0030 146#define BITS_PARITY_SPACE 0x0040 147 148#define BITS_STOP_MASK 0x000f 149#define BITS_STOP_1 0x0000 150#define BITS_STOP_1_5 0x0001 151#define BITS_STOP_2 0x0002 152 153/* CP2101_BREAK */ 154#define BREAK_ON 0x0000 155#define BREAK_OFF 0x0001 156 157/* CP2101_CONTROL */ 158#define CONTROL_DTR 0x0001 159#define CONTROL_RTS 0x0002 160#define CONTROL_CTS 0x0010 161#define CONTROL_DSR 0x0020 162#define CONTROL_RING 0x0040 163#define CONTROL_DCD 0x0080 164#define CONTROL_WRITE_DTR 0x0100 165#define CONTROL_WRITE_RTS 0x0200 166 167/* 168 * cp2101_get_config 169 * Reads from the CP2101 configuration registers 170 * 'size' is specified in bytes. 171 * 'data' is a pointer to a pre-allocated array of integers large 172 * enough to hold 'size' bytes (with 4 bytes to each integer) 173 */ 174static int cp2101_get_config(struct usb_serial_port* port, u8 request, 175 unsigned int *data, int size) 176{ 177 struct usb_serial *serial = port->serial; 178 __le32 *buf; 179 int result, i, length; 180 181 /* Number of integers required to contain the array */ 182 length = (((size - 1) | 3) + 1)/4; 183 184 buf = kcalloc(length, sizeof(__le32), GFP_KERNEL); 185 if (!buf) { 186 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__); 187 return -ENOMEM; 188 } 189 190 /* For get requests, the request number must be incremented */ 191 request++; 192 193 /* Issue the request, attempting to read 'size' bytes */ 194 result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0), 195 request, REQTYPE_DEVICE_TO_HOST, 0x0000, 196 0, buf, size, 300); 197 198 /* Convert data into an array of integers */ 199 for (i=0; i<length; i++) 200 data[i] = le32_to_cpu(buf[i]); 201 202 kfree(buf); 203 204 if (result != size) { 205 dev_err(&port->dev, "%s - Unable to send config request, " 206 "request=0x%x size=%d result=%d\n", 207 __FUNCTION__, request, size, result); 208 return -EPROTO; 209 } 210 211 return 0; 212} 213 214/* 215 * cp2101_set_config 216 * Writes to the CP2101 configuration registers 217 * Values less than 16 bits wide are sent directly 218 * 'size' is specified in bytes. 219 */ 220static int cp2101_set_config(struct usb_serial_port* port, u8 request, 221 unsigned int *data, int size) 222{ 223 struct usb_serial *serial = port->serial; 224 __le32 *buf; 225 int result, i, length; 226 227 /* Number of integers required to contain the array */ 228 length = (((size - 1) | 3) + 1)/4; 229 230 buf = kmalloc(length * sizeof(__le32), GFP_KERNEL); 231 if (!buf) { 232 dev_err(&port->dev, "%s - out of memory.\n", 233 __FUNCTION__); 234 return -ENOMEM; 235 } 236 237 /* Array of integers into bytes */ 238 for (i = 0; i < length; i++) 239 buf[i] = cpu_to_le32(data[i]); 240 241 if (size > 2) { 242 result = usb_control_msg (serial->dev, 243 usb_sndctrlpipe(serial->dev, 0), 244 request, REQTYPE_HOST_TO_DEVICE, 0x0000, 245 0, buf, size, 300); 246 } else { 247 result = usb_control_msg (serial->dev, 248 usb_sndctrlpipe(serial->dev, 0), 249 request, REQTYPE_HOST_TO_DEVICE, data[0], 250 0, NULL, 0, 300); 251 } 252 253 kfree(buf); 254 255 if ((size > 2 && result != size) || result < 0) { 256 dev_err(&port->dev, "%s - Unable to send request, " 257 "request=0x%x size=%d result=%d\n", 258 __FUNCTION__, request, size, result); 259 return -EPROTO; 260 } 261 262 /* Single data value */ 263 result = usb_control_msg (serial->dev, 264 usb_sndctrlpipe(serial->dev, 0), 265 request, REQTYPE_HOST_TO_DEVICE, data[0], 266 0, NULL, 0, 300); 267 return 0; 268} 269 270/* 271 * cp2101_set_config_single 272 * Convenience function for calling cp2101_set_config on single data values 273 * without requiring an integer pointer 274 */ 275static inline int cp2101_set_config_single(struct usb_serial_port* port, 276 u8 request, unsigned int data) 277{ 278 return cp2101_set_config(port, request, &data, 2); 279} 280 281static int cp2101_open (struct usb_serial_port *port, struct file *filp) 282{ 283 struct usb_serial *serial = port->serial; 284 int result; 285 286 dbg("%s - port %d", __FUNCTION__, port->number); 287 288 if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) { 289 dev_err(&port->dev, "%s - Unable to enable UART\n", 290 __FUNCTION__); 291 return -EPROTO; 292 } 293 294 /* Start reading from the device */ 295 usb_fill_bulk_urb (port->read_urb, serial->dev, 296 usb_rcvbulkpipe(serial->dev, 297 port->bulk_in_endpointAddress), 298 port->read_urb->transfer_buffer, 299 port->read_urb->transfer_buffer_length, 300 serial->type->read_bulk_callback, 301 port); 302 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 303 if (result) { 304 dev_err(&port->dev, "%s - failed resubmitting read urb, " 305 "error %d\n", __FUNCTION__, result); 306 return result; 307 } 308 309 /* Configure the termios structure */ 310 cp2101_get_termios(port); 311 312 /* Set the DTR and RTS pins low */ 313 cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0); 314 315 return 0; 316} 317 318static void cp2101_cleanup (struct usb_serial_port *port) 319{ 320 struct usb_serial *serial = port->serial; 321 322 dbg("%s - port %d", __FUNCTION__, port->number); 323 324 if (serial->dev) { 325 /* shutdown any bulk reads that might be going on */ 326 if (serial->num_bulk_out) 327 usb_kill_urb(port->write_urb); 328 if (serial->num_bulk_in) 329 usb_kill_urb(port->read_urb); 330 } 331} 332 333static void cp2101_close (struct usb_serial_port *port, struct file * filp) 334{ 335 dbg("%s - port %d", __FUNCTION__, port->number); 336 337 /* shutdown our urbs */ 338 dbg("%s - shutting down urbs", __FUNCTION__); 339 usb_kill_urb(port->write_urb); 340 usb_kill_urb(port->read_urb); 341 342 cp2101_set_config_single(port, CP2101_UART, UART_DISABLE); 343} 344 345/* 346 * cp2101_get_termios 347 * Reads the baud rate, data bits, parity, stop bits and flow control mode 348 * from the device, corrects any unsupported values, and configures the 349 * termios structure to reflect the state of the device 350 */ 351static void cp2101_get_termios (struct usb_serial_port *port) 352{ 353 unsigned int cflag, modem_ctl[4]; 354 int baud; 355 int bits; 356 357 dbg("%s - port %d", __FUNCTION__, port->number); 358 359 if ((!port->tty) || (!port->tty->termios)) { 360 dbg("%s - no tty structures", __FUNCTION__); 361 return; 362 } 363 cflag = port->tty->termios->c_cflag; 364 365 cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2); 366 /* Convert to baudrate */ 367 if (baud) 368 baud = BAUD_RATE_GEN_FREQ / baud; 369 370 dbg("%s - baud rate = %d", __FUNCTION__, baud); 371 cflag &= ~CBAUD; 372 switch (baud) { 373 /* 374 * The baud rates which are commented out below 375 * appear to be supported by the device 376 * but are non-standard 377 */ 378 case 600: cflag |= B600; break; 379 case 1200: cflag |= B1200; break; 380 case 1800: cflag |= B1800; break; 381 case 2400: cflag |= B2400; break; 382 case 4800: cflag |= B4800; break; 383 /*case 7200: cflag |= B7200; break;*/ 384 case 9600: cflag |= B9600; break; 385 /*case 14400: cflag |= B14400; break;*/ 386 case 19200: cflag |= B19200; break; 387 /*case 28800: cflag |= B28800; break;*/ 388 case 38400: cflag |= B38400; break; 389 /*case 55854: cflag |= B55054; break;*/ 390 case 57600: cflag |= B57600; break; 391 case 115200: cflag |= B115200; break; 392 /*case 127117: cflag |= B127117; break;*/ 393 case 230400: cflag |= B230400; break; 394 case 460800: cflag |= B460800; break; 395 case 921600: cflag |= B921600; break; 396 /*case 3686400: cflag |= B3686400; break;*/ 397 default: 398 dbg("%s - Baud rate is not supported, " 399 "using 9600 baud", __FUNCTION__); 400 cflag |= B9600; 401 cp2101_set_config_single(port, CP2101_BAUDRATE, 402 (BAUD_RATE_GEN_FREQ/9600)); 403 break; 404 } 405 406 cp2101_get_config(port, CP2101_BITS, &bits, 2); 407 cflag &= ~CSIZE; 408 switch(bits & BITS_DATA_MASK) { 409 case BITS_DATA_5: 410 dbg("%s - data bits = 5", __FUNCTION__); 411 cflag |= CS5; 412 break; 413 case BITS_DATA_6: 414 dbg("%s - data bits = 6", __FUNCTION__); 415 cflag |= CS6; 416 break; 417 case BITS_DATA_7: 418 dbg("%s - data bits = 7", __FUNCTION__); 419 cflag |= CS7; 420 break; 421 case BITS_DATA_8: 422 dbg("%s - data bits = 8", __FUNCTION__); 423 cflag |= CS8; 424 break; 425 case BITS_DATA_9: 426 dbg("%s - data bits = 9 (not supported, " 427 "using 8 data bits)", __FUNCTION__); 428 cflag |= CS8; 429 bits &= ~BITS_DATA_MASK; 430 bits |= BITS_DATA_8; 431 cp2101_set_config(port, CP2101_BITS, &bits, 2); 432 break; 433 default: 434 dbg("%s - Unknown number of data bits, " 435 "using 8", __FUNCTION__); 436 cflag |= CS8; 437 bits &= ~BITS_DATA_MASK; 438 bits |= BITS_DATA_8; 439 cp2101_set_config(port, CP2101_BITS, &bits, 2); 440 break; 441 } 442 443 switch(bits & BITS_PARITY_MASK) { 444 case BITS_PARITY_NONE: 445 dbg("%s - parity = NONE", __FUNCTION__); 446 cflag &= ~PARENB; 447 break; 448 case BITS_PARITY_ODD: 449 dbg("%s - parity = ODD", __FUNCTION__); 450 cflag |= (PARENB|PARODD); 451 break; 452 case BITS_PARITY_EVEN: 453 dbg("%s - parity = EVEN", __FUNCTION__); 454 cflag &= ~PARODD; 455 cflag |= PARENB; 456 break; 457 case BITS_PARITY_MARK: 458 dbg("%s - parity = MARK (not supported, " 459 "disabling parity)", __FUNCTION__); 460 cflag &= ~PARENB; 461 bits &= ~BITS_PARITY_MASK; 462 cp2101_set_config(port, CP2101_BITS, &bits, 2); 463 break; 464 case BITS_PARITY_SPACE: 465 dbg("%s - parity = SPACE (not supported, " 466 "disabling parity)", __FUNCTION__); 467 cflag &= ~PARENB; 468 bits &= ~BITS_PARITY_MASK; 469 cp2101_set_config(port, CP2101_BITS, &bits, 2); 470 break; 471 default: 472 dbg("%s - Unknown parity mode, " 473 "disabling parity", __FUNCTION__); 474 cflag &= ~PARENB; 475 bits &= ~BITS_PARITY_MASK; 476 cp2101_set_config(port, CP2101_BITS, &bits, 2); 477 break; 478 } 479 480 cflag &= ~CSTOPB; 481 switch(bits & BITS_STOP_MASK) { 482 case BITS_STOP_1: 483 dbg("%s - stop bits = 1", __FUNCTION__); 484 break; 485 case BITS_STOP_1_5: 486 dbg("%s - stop bits = 1.5 (not supported, " 487 "using 1 stop bit)", __FUNCTION__); 488 bits &= ~BITS_STOP_MASK; 489 cp2101_set_config(port, CP2101_BITS, &bits, 2); 490 break; 491 case BITS_STOP_2: 492 dbg("%s - stop bits = 2", __FUNCTION__); 493 cflag |= CSTOPB; 494 break; 495 default: 496 dbg("%s - Unknown number of stop bits, " 497 "using 1 stop bit", __FUNCTION__); 498 bits &= ~BITS_STOP_MASK; 499 cp2101_set_config(port, CP2101_BITS, &bits, 2); 500 break; 501 } 502 503 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16); 504 if (modem_ctl[0] & 0x0008) { 505 dbg("%s - flow control = CRTSCTS", __FUNCTION__); 506 cflag |= CRTSCTS; 507 } else { 508 dbg("%s - flow control = NONE", __FUNCTION__); 509 cflag &= ~CRTSCTS; 510 } 511 512 port->tty->termios->c_cflag = cflag; 513} 514 515static void cp2101_set_termios (struct usb_serial_port *port, 516 struct ktermios *old_termios) 517{ 518 unsigned int cflag, old_cflag=0; 519 int baud=0, bits; 520 unsigned int modem_ctl[4]; 521 522 dbg("%s - port %d", __FUNCTION__, port->number); 523 524 if ((!port->tty) || (!port->tty->termios)) { 525 dbg("%s - no tty structures", __FUNCTION__); 526 return; 527 } 528 cflag = port->tty->termios->c_cflag; 529 530 /* Check that they really want us to change something */ 531 if (old_termios) { 532 if ((cflag == old_termios->c_cflag) && 533 (RELEVANT_IFLAG(port->tty->termios->c_iflag) 534 == RELEVANT_IFLAG(old_termios->c_iflag))) { 535 dbg("%s - nothing to change...", __FUNCTION__); 536 return; 537 } 538 539 old_cflag = old_termios->c_cflag; 540 } 541 542 /* If the baud rate is to be updated*/ 543 if ((cflag & CBAUD) != (old_cflag & CBAUD)) { 544 switch (cflag & CBAUD) { 545 /* 546 * The baud rates which are commented out below 547 * appear to be supported by the device 548 * but are non-standard 549 */ 550 case B0: baud = 0; break; 551 case B600: baud = 600; break; 552 case B1200: baud = 1200; break; 553 case B1800: baud = 1800; break; 554 case B2400: baud = 2400; break; 555 case B4800: baud = 4800; break; 556 /*case B7200: baud = 7200; break;*/ 557 case B9600: baud = 9600; break; 558 /*ase B14400: baud = 14400; break;*/ 559 case B19200: baud = 19200; break; 560 /*case B28800: baud = 28800; break;*/ 561 case B38400: baud = 38400; break; 562 /*case B55854: baud = 55054; break;*/ 563 case B57600: baud = 57600; break; 564 case B115200: baud = 115200; break; 565 /*case B127117: baud = 127117; break;*/ 566 case B230400: baud = 230400; break; 567 case B460800: baud = 460800; break; 568 case B921600: baud = 921600; break; 569 /*case B3686400: baud = 3686400; break;*/ 570 default: 571 dev_err(&port->dev, "cp2101 driver does not " 572 "support the baudrate requested\n"); 573 break; 574 } 575 576 if (baud) { 577 dbg("%s - Setting baud rate to %d baud", __FUNCTION__, 578 baud); 579 if (cp2101_set_config_single(port, CP2101_BAUDRATE, 580 (BAUD_RATE_GEN_FREQ / baud))) 581 dev_err(&port->dev, "Baud rate requested not " 582 "supported by device\n"); 583 } 584 } 585 586 /* If the number of data bits is to be updated */ 587 if ((cflag & CSIZE) != (old_cflag & CSIZE)) { 588 cp2101_get_config(port, CP2101_BITS, &bits, 2); 589 bits &= ~BITS_DATA_MASK; 590 switch (cflag & CSIZE) { 591 case CS5: 592 bits |= BITS_DATA_5; 593 dbg("%s - data bits = 5", __FUNCTION__); 594 break; 595 case CS6: 596 bits |= BITS_DATA_6; 597 dbg("%s - data bits = 6", __FUNCTION__); 598 break; 599 case CS7: 600 bits |= BITS_DATA_7; 601 dbg("%s - data bits = 7", __FUNCTION__); 602 break; 603 case CS8: 604 bits |= BITS_DATA_8; 605 dbg("%s - data bits = 8", __FUNCTION__); 606 break; 607 /*case CS9: 608 bits |= BITS_DATA_9; 609 dbg("%s - data bits = 9", __FUNCTION__); 610 break;*/ 611 default: 612 dev_err(&port->dev, "cp2101 driver does not " 613 "support the number of bits requested," 614 " using 8 bit mode\n"); 615 bits |= BITS_DATA_8; 616 break; 617 } 618 if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) 619 dev_err(&port->dev, "Number of data bits requested " 620 "not supported by device\n"); 621 } 622 623 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) { 624 cp2101_get_config(port, CP2101_BITS, &bits, 2); 625 bits &= ~BITS_PARITY_MASK; 626 if (cflag & PARENB) { 627 if (cflag & PARODD) { 628 bits |= BITS_PARITY_ODD; 629 dbg("%s - parity = ODD", __FUNCTION__); 630 } else { 631 bits |= BITS_PARITY_EVEN; 632 dbg("%s - parity = EVEN", __FUNCTION__); 633 } 634 } 635 if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) 636 dev_err(&port->dev, "Parity mode not supported " 637 "by device\n"); 638 } 639 640 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { 641 cp2101_get_config(port, CP2101_BITS, &bits, 2); 642 bits &= ~BITS_STOP_MASK; 643 if (cflag & CSTOPB) { 644 bits |= BITS_STOP_2; 645 dbg("%s - stop bits = 2", __FUNCTION__); 646 } else { 647 bits |= BITS_STOP_1; 648 dbg("%s - stop bits = 1", __FUNCTION__); 649 } 650 if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) 651 dev_err(&port->dev, "Number of stop bits requested " 652 "not supported by device\n"); 653 } 654 655 if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) { 656 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16); 657 dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x", 658 __FUNCTION__, modem_ctl[0], modem_ctl[1], 659 modem_ctl[2], modem_ctl[3]); 660 661 if (cflag & CRTSCTS) { 662 modem_ctl[0] &= ~0x7B; 663 modem_ctl[0] |= 0x09; 664 modem_ctl[1] = 0x80; 665 dbg("%s - flow control = CRTSCTS", __FUNCTION__); 666 } else { 667 modem_ctl[0] &= ~0x7B; 668 modem_ctl[0] |= 0x01; 669 modem_ctl[1] |= 0x40; 670 dbg("%s - flow control = NONE", __FUNCTION__); 671 } 672 673 dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x", 674 __FUNCTION__, modem_ctl[0], modem_ctl[1], 675 modem_ctl[2], modem_ctl[3]); 676 cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16); 677 } 678 679} 680 681static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file, 682 unsigned int set, unsigned int clear) 683{ 684 int control = 0; 685 686 dbg("%s - port %d", __FUNCTION__, port->number); 687 688 if (set & TIOCM_RTS) { 689 control |= CONTROL_RTS; 690 control |= CONTROL_WRITE_RTS; 691 } 692 if (set & TIOCM_DTR) { 693 control |= CONTROL_DTR; 694 control |= CONTROL_WRITE_DTR; 695 } 696 if (clear & TIOCM_RTS) { 697 control &= ~CONTROL_RTS; 698 control |= CONTROL_WRITE_RTS; 699 } 700 if (clear & TIOCM_DTR) { 701 control &= ~CONTROL_DTR; 702 control |= CONTROL_WRITE_DTR; 703 } 704 705 dbg("%s - control = 0x%.4x", __FUNCTION__, control); 706 707 return cp2101_set_config(port, CP2101_CONTROL, &control, 2); 708 709} 710 711static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file) 712{ 713 int control, result; 714 715 dbg("%s - port %d", __FUNCTION__, port->number); 716 717 cp2101_get_config(port, CP2101_CONTROL, &control, 1); 718 719 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) 720 |((control & CONTROL_RTS) ? TIOCM_RTS : 0) 721 |((control & CONTROL_CTS) ? TIOCM_CTS : 0) 722 |((control & CONTROL_DSR) ? TIOCM_DSR : 0) 723 |((control & CONTROL_RING)? TIOCM_RI : 0) 724 |((control & CONTROL_DCD) ? TIOCM_CD : 0); 725 726 dbg("%s - control = 0x%.2x", __FUNCTION__, control); 727 728 return result; 729} 730 731static void cp2101_break_ctl (struct usb_serial_port *port, int break_state) 732{ 733 int state; 734 735 dbg("%s - port %d", __FUNCTION__, port->number); 736 if (break_state == 0) 737 state = BREAK_OFF; 738 else 739 state = BREAK_ON; 740 dbg("%s - turning break %s", __FUNCTION__, 741 state==BREAK_OFF ? "off" : "on"); 742 cp2101_set_config(port, CP2101_BREAK, &state, 2); 743} 744 745static int cp2101_startup (struct usb_serial *serial) 746{ 747 /* CP2101 buffers behave strangely unless device is reset */ 748 usb_reset_device(serial->dev); 749 return 0; 750} 751 752static void cp2101_shutdown (struct usb_serial *serial) 753{ 754 int i; 755 756 dbg("%s", __FUNCTION__); 757 758 /* Stop reads and writes on all ports */ 759 for (i=0; i < serial->num_ports; ++i) { 760 cp2101_cleanup(serial->port[i]); 761 } 762} 763 764static int __init cp2101_init (void) 765{ 766 int retval; 767 768 retval = usb_serial_register(&cp2101_device); 769 if (retval) 770 return retval; /* Failed to register */ 771 772 retval = usb_register(&cp2101_driver); 773 if (retval) { 774 /* Failed to register */ 775 usb_serial_deregister(&cp2101_device); 776 return retval; 777 } 778 779 /* Success */ 780 info(DRIVER_DESC " " DRIVER_VERSION); 781 return 0; 782} 783 784static void __exit cp2101_exit (void) 785{ 786 usb_deregister (&cp2101_driver); 787 usb_serial_deregister (&cp2101_device); 788} 789 790module_init(cp2101_init); 791module_exit(cp2101_exit); 792 793MODULE_DESCRIPTION(DRIVER_DESC); 794MODULE_VERSION(DRIVER_VERSION); 795MODULE_LICENSE("GPL"); 796 797module_param(debug, bool, S_IRUGO | S_IWUSR); 798MODULE_PARM_DESC(debug, "Enable verbose debugging messages"); 799