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