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