1 /* 2 * Prolific PL2303 USB to serial adaptor driver 3 * 4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2003 IBM Corp. 6 * 7 * Original driver for 2.2.x by anonymous 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License version 11 * 2 as published by the Free Software Foundation. 12 * 13 * See Documentation/usb/usb-serial.txt for more information on using this 14 * driver 15 * 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/errno.h> 20 #include <linux/init.h> 21 #include <linux/slab.h> 22 #include <linux/tty.h> 23 #include <linux/tty_driver.h> 24 #include <linux/tty_flip.h> 25 #include <linux/serial.h> 26 #include <linux/module.h> 27 #include <linux/moduleparam.h> 28 #include <linux/spinlock.h> 29 #include <linux/uaccess.h> 30 #include <linux/usb.h> 31 #include <linux/usb/serial.h> 32 #include "pl2303.h" 33 34 /* 35 * Version Information 36 */ 37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver" 38 39 static int debug; 40 41 #define PL2303_CLOSING_WAIT (30*HZ) 42 43 #define PL2303_BUF_SIZE 1024 44 #define PL2303_TMP_BUF_SIZE 1024 45 46 struct pl2303_buf { 47 unsigned int buf_size; 48 char *buf_buf; 49 char *buf_get; 50 char *buf_put; 51 }; 52 53 static struct usb_device_id id_table [] = { 54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) }, 55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) }, 56 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) }, 57 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) }, 58 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) }, 59 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) }, 60 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) }, 61 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) }, 62 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) }, 63 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) }, 64 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) }, 65 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) }, 66 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) }, 67 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) }, 68 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) }, 69 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) }, 70 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) }, 71 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) }, 72 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) }, 73 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) }, 74 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) }, 75 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) }, 76 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) }, 77 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) }, 78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) }, 79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) }, 80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) }, 81 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) }, 82 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */ 83 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) }, 84 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) }, 85 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) }, 86 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) }, 87 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) }, 88 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) }, 89 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) }, 90 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) }, 91 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) }, 92 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) }, 93 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) }, 94 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) }, 95 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) }, 96 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) }, 97 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) }, 98 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) }, 99 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) }, 100 { } /* Terminating entry */ 101 }; 102 103 MODULE_DEVICE_TABLE(usb, id_table); 104 105 static struct usb_driver pl2303_driver = { 106 .name = "pl2303", 107 .probe = usb_serial_probe, 108 .disconnect = usb_serial_disconnect, 109 .id_table = id_table, 110 .suspend = usb_serial_suspend, 111 .resume = usb_serial_resume, 112 .no_dynamic_id = 1, 113 .supports_autosuspend = 1, 114 }; 115 116 #define SET_LINE_REQUEST_TYPE 0x21 117 #define SET_LINE_REQUEST 0x20 118 119 #define SET_CONTROL_REQUEST_TYPE 0x21 120 #define SET_CONTROL_REQUEST 0x22 121 #define CONTROL_DTR 0x01 122 #define CONTROL_RTS 0x02 123 124 #define BREAK_REQUEST_TYPE 0x21 125 #define BREAK_REQUEST 0x23 126 #define BREAK_ON 0xffff 127 #define BREAK_OFF 0x0000 128 129 #define GET_LINE_REQUEST_TYPE 0xa1 130 #define GET_LINE_REQUEST 0x21 131 132 #define VENDOR_WRITE_REQUEST_TYPE 0x40 133 #define VENDOR_WRITE_REQUEST 0x01 134 135 #define VENDOR_READ_REQUEST_TYPE 0xc0 136 #define VENDOR_READ_REQUEST 0x01 137 138 #define UART_STATE 0x08 139 #define UART_STATE_TRANSIENT_MASK 0x74 140 #define UART_DCD 0x01 141 #define UART_DSR 0x02 142 #define UART_BREAK_ERROR 0x04 143 #define UART_RING 0x08 144 #define UART_FRAME_ERROR 0x10 145 #define UART_PARITY_ERROR 0x20 146 #define UART_OVERRUN_ERROR 0x40 147 #define UART_CTS 0x80 148 149 150 enum pl2303_type { 151 type_0, /* don't know the difference between type 0 and */ 152 type_1, /* type 1, until someone from prolific tells us... */ 153 HX, /* HX version of the pl2303 chip */ 154 }; 155 156 struct pl2303_private { 157 spinlock_t lock; 158 struct pl2303_buf *buf; 159 int write_urb_in_use; 160 wait_queue_head_t delta_msr_wait; 161 u8 line_control; 162 u8 line_status; 163 enum pl2303_type type; 164 }; 165 166 /* 167 * pl2303_buf_alloc 168 * 169 * Allocate a circular buffer and all associated memory. 170 */ 171 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size) 172 { 173 struct pl2303_buf *pb; 174 175 if (size == 0) 176 return NULL; 177 178 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL); 179 if (pb == NULL) 180 return NULL; 181 182 pb->buf_buf = kmalloc(size, GFP_KERNEL); 183 if (pb->buf_buf == NULL) { 184 kfree(pb); 185 return NULL; 186 } 187 188 pb->buf_size = size; 189 pb->buf_get = pb->buf_put = pb->buf_buf; 190 191 return pb; 192 } 193 194 /* 195 * pl2303_buf_free 196 * 197 * Free the buffer and all associated memory. 198 */ 199 static void pl2303_buf_free(struct pl2303_buf *pb) 200 { 201 if (pb) { 202 kfree(pb->buf_buf); 203 kfree(pb); 204 } 205 } 206 207 /* 208 * pl2303_buf_clear 209 * 210 * Clear out all data in the circular buffer. 211 */ 212 static void pl2303_buf_clear(struct pl2303_buf *pb) 213 { 214 if (pb != NULL) 215 pb->buf_get = pb->buf_put; 216 /* equivalent to a get of all data available */ 217 } 218 219 /* 220 * pl2303_buf_data_avail 221 * 222 * Return the number of bytes of data available in the circular 223 * buffer. 224 */ 225 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb) 226 { 227 if (pb == NULL) 228 return 0; 229 230 return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size; 231 } 232 233 /* 234 * pl2303_buf_space_avail 235 * 236 * Return the number of bytes of space available in the circular 237 * buffer. 238 */ 239 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb) 240 { 241 if (pb == NULL) 242 return 0; 243 244 return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size; 245 } 246 247 /* 248 * pl2303_buf_put 249 * 250 * Copy data data from a user buffer and put it into the circular buffer. 251 * Restrict to the amount of space available. 252 * 253 * Return the number of bytes copied. 254 */ 255 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf, 256 unsigned int count) 257 { 258 unsigned int len; 259 260 if (pb == NULL) 261 return 0; 262 263 len = pl2303_buf_space_avail(pb); 264 if (count > len) 265 count = len; 266 267 if (count == 0) 268 return 0; 269 270 len = pb->buf_buf + pb->buf_size - pb->buf_put; 271 if (count > len) { 272 memcpy(pb->buf_put, buf, len); 273 memcpy(pb->buf_buf, buf+len, count - len); 274 pb->buf_put = pb->buf_buf + count - len; 275 } else { 276 memcpy(pb->buf_put, buf, count); 277 if (count < len) 278 pb->buf_put += count; 279 else /* count == len */ 280 pb->buf_put = pb->buf_buf; 281 } 282 283 return count; 284 } 285 286 /* 287 * pl2303_buf_get 288 * 289 * Get data from the circular buffer and copy to the given buffer. 290 * Restrict to the amount of data available. 291 * 292 * Return the number of bytes copied. 293 */ 294 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf, 295 unsigned int count) 296 { 297 unsigned int len; 298 299 if (pb == NULL) 300 return 0; 301 302 len = pl2303_buf_data_avail(pb); 303 if (count > len) 304 count = len; 305 306 if (count == 0) 307 return 0; 308 309 len = pb->buf_buf + pb->buf_size - pb->buf_get; 310 if (count > len) { 311 memcpy(buf, pb->buf_get, len); 312 memcpy(buf+len, pb->buf_buf, count - len); 313 pb->buf_get = pb->buf_buf + count - len; 314 } else { 315 memcpy(buf, pb->buf_get, count); 316 if (count < len) 317 pb->buf_get += count; 318 else /* count == len */ 319 pb->buf_get = pb->buf_buf; 320 } 321 322 return count; 323 } 324 325 static int pl2303_vendor_read(__u16 value, __u16 index, 326 struct usb_serial *serial, unsigned char *buf) 327 { 328 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 329 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE, 330 value, index, buf, 1, 100); 331 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE, 332 VENDOR_READ_REQUEST, value, index, res, buf[0]); 333 return res; 334 } 335 336 static int pl2303_vendor_write(__u16 value, __u16 index, 337 struct usb_serial *serial) 338 { 339 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 340 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE, 341 value, index, NULL, 0, 100); 342 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE, 343 VENDOR_WRITE_REQUEST, value, index, res); 344 return res; 345 } 346 347 static int pl2303_startup(struct usb_serial *serial) 348 { 349 struct pl2303_private *priv; 350 enum pl2303_type type = type_0; 351 unsigned char *buf; 352 int i; 353 354 buf = kmalloc(10, GFP_KERNEL); 355 if (buf == NULL) 356 return -ENOMEM; 357 358 if (serial->dev->descriptor.bDeviceClass == 0x02) 359 type = type_0; 360 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40) 361 type = HX; 362 else if (serial->dev->descriptor.bDeviceClass == 0x00) 363 type = type_1; 364 else if (serial->dev->descriptor.bDeviceClass == 0xFF) 365 type = type_1; 366 dbg("device type: %d", type); 367 368 for (i = 0; i < serial->num_ports; ++i) { 369 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL); 370 if (!priv) 371 goto cleanup; 372 spin_lock_init(&priv->lock); 373 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE); 374 if (priv->buf == NULL) { 375 kfree(priv); 376 goto cleanup; 377 } 378 init_waitqueue_head(&priv->delta_msr_wait); 379 priv->type = type; 380 usb_set_serial_port_data(serial->port[i], priv); 381 } 382 383 pl2303_vendor_read(0x8484, 0, serial, buf); 384 pl2303_vendor_write(0x0404, 0, serial); 385 pl2303_vendor_read(0x8484, 0, serial, buf); 386 pl2303_vendor_read(0x8383, 0, serial, buf); 387 pl2303_vendor_read(0x8484, 0, serial, buf); 388 pl2303_vendor_write(0x0404, 1, serial); 389 pl2303_vendor_read(0x8484, 0, serial, buf); 390 pl2303_vendor_read(0x8383, 0, serial, buf); 391 pl2303_vendor_write(0, 1, serial); 392 pl2303_vendor_write(1, 0, serial); 393 if (type == HX) 394 pl2303_vendor_write(2, 0x44, serial); 395 else 396 pl2303_vendor_write(2, 0x24, serial); 397 398 kfree(buf); 399 return 0; 400 401 cleanup: 402 kfree(buf); 403 for (--i; i >= 0; --i) { 404 priv = usb_get_serial_port_data(serial->port[i]); 405 pl2303_buf_free(priv->buf); 406 kfree(priv); 407 usb_set_serial_port_data(serial->port[i], NULL); 408 } 409 return -ENOMEM; 410 } 411 412 static int set_control_lines(struct usb_device *dev, u8 value) 413 { 414 int retval; 415 416 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 417 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE, 418 value, 0, NULL, 0, 100); 419 dbg("%s - value = %d, retval = %d", __func__, value, retval); 420 return retval; 421 } 422 423 static void pl2303_send(struct usb_serial_port *port) 424 { 425 int count, result; 426 struct pl2303_private *priv = usb_get_serial_port_data(port); 427 unsigned long flags; 428 429 dbg("%s - port %d", __func__, port->number); 430 431 spin_lock_irqsave(&priv->lock, flags); 432 433 if (priv->write_urb_in_use) { 434 spin_unlock_irqrestore(&priv->lock, flags); 435 return; 436 } 437 438 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer, 439 port->bulk_out_size); 440 441 if (count == 0) { 442 spin_unlock_irqrestore(&priv->lock, flags); 443 return; 444 } 445 446 priv->write_urb_in_use = 1; 447 448 spin_unlock_irqrestore(&priv->lock, flags); 449 450 usb_serial_debug_data(debug, &port->dev, __func__, count, 451 port->write_urb->transfer_buffer); 452 453 port->write_urb->transfer_buffer_length = count; 454 port->write_urb->dev = port->serial->dev; 455 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 456 if (result) { 457 dev_err(&port->dev, "%s - failed submitting write urb," 458 " error %d\n", __func__, result); 459 priv->write_urb_in_use = 0; 460 /* TODO: reschedule pl2303_send */ 461 } 462 463 usb_serial_port_softint(port); 464 } 465 466 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port, 467 const unsigned char *buf, int count) 468 { 469 struct pl2303_private *priv = usb_get_serial_port_data(port); 470 unsigned long flags; 471 472 dbg("%s - port %d, %d bytes", __func__, port->number, count); 473 474 if (!count) 475 return count; 476 477 spin_lock_irqsave(&priv->lock, flags); 478 count = pl2303_buf_put(priv->buf, buf, count); 479 spin_unlock_irqrestore(&priv->lock, flags); 480 481 pl2303_send(port); 482 483 return count; 484 } 485 486 static int pl2303_write_room(struct tty_struct *tty) 487 { 488 struct usb_serial_port *port = tty->driver_data; 489 struct pl2303_private *priv = usb_get_serial_port_data(port); 490 int room = 0; 491 unsigned long flags; 492 493 dbg("%s - port %d", __func__, port->number); 494 495 spin_lock_irqsave(&priv->lock, flags); 496 room = pl2303_buf_space_avail(priv->buf); 497 spin_unlock_irqrestore(&priv->lock, flags); 498 499 dbg("%s - returns %d", __func__, room); 500 return room; 501 } 502 503 static int pl2303_chars_in_buffer(struct tty_struct *tty) 504 { 505 struct usb_serial_port *port = tty->driver_data; 506 struct pl2303_private *priv = usb_get_serial_port_data(port); 507 int chars = 0; 508 unsigned long flags; 509 510 dbg("%s - port %d", __func__, port->number); 511 512 spin_lock_irqsave(&priv->lock, flags); 513 chars = pl2303_buf_data_avail(priv->buf); 514 spin_unlock_irqrestore(&priv->lock, flags); 515 516 dbg("%s - returns %d", __func__, chars); 517 return chars; 518 } 519 520 static void pl2303_set_termios(struct tty_struct *tty, 521 struct usb_serial_port *port, struct ktermios *old_termios) 522 { 523 struct usb_serial *serial = port->serial; 524 struct pl2303_private *priv = usb_get_serial_port_data(port); 525 unsigned long flags; 526 unsigned int cflag; 527 unsigned char *buf; 528 int baud; 529 int i; 530 u8 control; 531 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600, 532 4800, 7200, 9600, 14400, 19200, 28800, 38400, 533 57600, 115200, 230400, 460800, 614400, 534 921600, 1228800, 2457600, 3000000, 6000000 }; 535 int baud_floor, baud_ceil; 536 int k; 537 538 dbg("%s - port %d", __func__, port->number); 539 540 /* The PL2303 is reported to lose bytes if you change 541 serial settings even to the same values as before. Thus 542 we actually need to filter in this specific case */ 543 544 if (!tty_termios_hw_change(tty->termios, old_termios)) 545 return; 546 547 cflag = tty->termios->c_cflag; 548 549 buf = kzalloc(7, GFP_KERNEL); 550 if (!buf) { 551 dev_err(&port->dev, "%s - out of memory.\n", __func__); 552 /* Report back no change occurred */ 553 *tty->termios = *old_termios; 554 return; 555 } 556 557 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 558 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 559 0, 0, buf, 7, 100); 560 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 561 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 562 563 if (cflag & CSIZE) { 564 switch (cflag & CSIZE) { 565 case CS5: 566 buf[6] = 5; 567 break; 568 case CS6: 569 buf[6] = 6; 570 break; 571 case CS7: 572 buf[6] = 7; 573 break; 574 default: 575 case CS8: 576 buf[6] = 8; 577 break; 578 } 579 dbg("%s - data bits = %d", __func__, buf[6]); 580 } 581 582 /* For reference buf[0]:buf[3] baud rate value */ 583 /* NOTE: Only the values defined in baud_sup are supported ! 584 * => if unsupported values are set, the PL2303 seems to use 585 * 9600 baud (at least my PL2303X always does) 586 */ 587 baud = tty_get_baud_rate(tty); 588 dbg("%s - baud requested = %d", __func__, baud); 589 if (baud) { 590 /* Set baudrate to nearest supported value */ 591 for (k=0; k<ARRAY_SIZE(baud_sup); k++) { 592 if (baud_sup[k] / baud) { 593 baud_ceil = baud_sup[k]; 594 if (k==0) { 595 baud = baud_ceil; 596 } else { 597 baud_floor = baud_sup[k-1]; 598 if ((baud_ceil % baud) 599 > (baud % baud_floor)) 600 baud = baud_floor; 601 else 602 baud = baud_ceil; 603 } 604 break; 605 } 606 } 607 if (baud > 1228800) { 608 /* type_0, type_1 only support up to 1228800 baud */ 609 if (priv->type != HX) 610 baud = 1228800; 611 else if (baud > 6000000) 612 baud = 6000000; 613 } 614 dbg("%s - baud set = %d", __func__, baud); 615 buf[0] = baud & 0xff; 616 buf[1] = (baud >> 8) & 0xff; 617 buf[2] = (baud >> 16) & 0xff; 618 buf[3] = (baud >> 24) & 0xff; 619 } 620 621 /* For reference buf[4]=0 is 1 stop bits */ 622 /* For reference buf[4]=1 is 1.5 stop bits */ 623 /* For reference buf[4]=2 is 2 stop bits */ 624 if (cflag & CSTOPB) { 625 /* NOTE: Comply with "real" UARTs / RS232: 626 * use 1.5 instead of 2 stop bits with 5 data bits 627 */ 628 if ((cflag & CSIZE) == CS5) { 629 buf[4] = 1; 630 dbg("%s - stop bits = 1.5", __func__); 631 } else { 632 buf[4] = 2; 633 dbg("%s - stop bits = 2", __func__); 634 } 635 } else { 636 buf[4] = 0; 637 dbg("%s - stop bits = 1", __func__); 638 } 639 640 if (cflag & PARENB) { 641 /* For reference buf[5]=0 is none parity */ 642 /* For reference buf[5]=1 is odd parity */ 643 /* For reference buf[5]=2 is even parity */ 644 /* For reference buf[5]=3 is mark parity */ 645 /* For reference buf[5]=4 is space parity */ 646 if (cflag & PARODD) { 647 if (cflag & CMSPAR) { 648 buf[5] = 3; 649 dbg("%s - parity = mark", __func__); 650 } else { 651 buf[5] = 1; 652 dbg("%s - parity = odd", __func__); 653 } 654 } else { 655 if (cflag & CMSPAR) { 656 buf[5] = 4; 657 dbg("%s - parity = space", __func__); 658 } else { 659 buf[5] = 2; 660 dbg("%s - parity = even", __func__); 661 } 662 } 663 } else { 664 buf[5] = 0; 665 dbg("%s - parity = none", __func__); 666 } 667 668 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 669 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE, 670 0, 0, buf, 7, 100); 671 dbg("0x21:0x20:0:0 %d", i); 672 673 /* change control lines if we are switching to or from B0 */ 674 spin_lock_irqsave(&priv->lock, flags); 675 control = priv->line_control; 676 if ((cflag & CBAUD) == B0) 677 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 678 else 679 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 680 if (control != priv->line_control) { 681 control = priv->line_control; 682 spin_unlock_irqrestore(&priv->lock, flags); 683 set_control_lines(serial->dev, control); 684 } else { 685 spin_unlock_irqrestore(&priv->lock, flags); 686 } 687 688 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0; 689 690 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 691 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 692 0, 0, buf, 7, 100); 693 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 694 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 695 696 if (cflag & CRTSCTS) { 697 if (priv->type == HX) 698 pl2303_vendor_write(0x0, 0x61, serial); 699 else 700 pl2303_vendor_write(0x0, 0x41, serial); 701 } else { 702 pl2303_vendor_write(0x0, 0x0, serial); 703 } 704 705 /* Save resulting baud rate */ 706 if (baud) 707 tty_encode_baud_rate(tty, baud, baud); 708 709 kfree(buf); 710 } 711 712 static void pl2303_dtr_rts(struct usb_serial_port *port, int on) 713 { 714 struct pl2303_private *priv = usb_get_serial_port_data(port); 715 unsigned long flags; 716 u8 control; 717 718 spin_lock_irqsave(&priv->lock, flags); 719 /* Change DTR and RTS */ 720 if (on) 721 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 722 else 723 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 724 control = priv->line_control; 725 spin_unlock_irqrestore(&priv->lock, flags); 726 set_control_lines(port->serial->dev, control); 727 } 728 729 static void pl2303_close(struct usb_serial_port *port) 730 { 731 struct pl2303_private *priv = usb_get_serial_port_data(port); 732 unsigned long flags; 733 734 dbg("%s - port %d", __func__, port->number); 735 736 spin_lock_irqsave(&priv->lock, flags); 737 /* clear out any remaining data in the buffer */ 738 pl2303_buf_clear(priv->buf); 739 spin_unlock_irqrestore(&priv->lock, flags); 740 741 /* shutdown our urbs */ 742 dbg("%s - shutting down urbs", __func__); 743 usb_kill_urb(port->write_urb); 744 usb_kill_urb(port->read_urb); 745 usb_kill_urb(port->interrupt_in_urb); 746 747 } 748 749 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port) 750 { 751 struct ktermios tmp_termios; 752 struct usb_serial *serial = port->serial; 753 struct pl2303_private *priv = usb_get_serial_port_data(port); 754 int result; 755 756 dbg("%s - port %d", __func__, port->number); 757 758 if (priv->type != HX) { 759 usb_clear_halt(serial->dev, port->write_urb->pipe); 760 usb_clear_halt(serial->dev, port->read_urb->pipe); 761 } else { 762 /* reset upstream data pipes */ 763 pl2303_vendor_write(8, 0, serial); 764 pl2303_vendor_write(9, 0, serial); 765 } 766 767 /* Setup termios */ 768 if (tty) 769 pl2303_set_termios(tty, port, &tmp_termios); 770 771 dbg("%s - submitting read urb", __func__); 772 port->read_urb->dev = serial->dev; 773 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 774 if (result) { 775 dev_err(&port->dev, "%s - failed submitting read urb," 776 " error %d\n", __func__, result); 777 pl2303_close(port); 778 return -EPROTO; 779 } 780 781 dbg("%s - submitting interrupt urb", __func__); 782 port->interrupt_in_urb->dev = serial->dev; 783 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 784 if (result) { 785 dev_err(&port->dev, "%s - failed submitting interrupt urb," 786 " error %d\n", __func__, result); 787 pl2303_close(port); 788 return -EPROTO; 789 } 790 port->port.drain_delay = 256; 791 return 0; 792 } 793 794 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file, 795 unsigned int set, unsigned int clear) 796 { 797 struct usb_serial_port *port = tty->driver_data; 798 struct pl2303_private *priv = usb_get_serial_port_data(port); 799 unsigned long flags; 800 u8 control; 801 802 if (!usb_get_intfdata(port->serial->interface)) 803 return -ENODEV; 804 805 spin_lock_irqsave(&priv->lock, flags); 806 if (set & TIOCM_RTS) 807 priv->line_control |= CONTROL_RTS; 808 if (set & TIOCM_DTR) 809 priv->line_control |= CONTROL_DTR; 810 if (clear & TIOCM_RTS) 811 priv->line_control &= ~CONTROL_RTS; 812 if (clear & TIOCM_DTR) 813 priv->line_control &= ~CONTROL_DTR; 814 control = priv->line_control; 815 spin_unlock_irqrestore(&priv->lock, flags); 816 817 return set_control_lines(port->serial->dev, control); 818 } 819 820 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file) 821 { 822 struct usb_serial_port *port = tty->driver_data; 823 struct pl2303_private *priv = usb_get_serial_port_data(port); 824 unsigned long flags; 825 unsigned int mcr; 826 unsigned int status; 827 unsigned int result; 828 829 dbg("%s (%d)", __func__, port->number); 830 831 if (!usb_get_intfdata(port->serial->interface)) 832 return -ENODEV; 833 834 spin_lock_irqsave(&priv->lock, flags); 835 mcr = priv->line_control; 836 status = priv->line_status; 837 spin_unlock_irqrestore(&priv->lock, flags); 838 839 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 840 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 841 | ((status & UART_CTS) ? TIOCM_CTS : 0) 842 | ((status & UART_DSR) ? TIOCM_DSR : 0) 843 | ((status & UART_RING) ? TIOCM_RI : 0) 844 | ((status & UART_DCD) ? TIOCM_CD : 0); 845 846 dbg("%s - result = %x", __func__, result); 847 848 return result; 849 } 850 851 static int pl2303_carrier_raised(struct usb_serial_port *port) 852 { 853 struct pl2303_private *priv = usb_get_serial_port_data(port); 854 if (priv->line_status & UART_DCD) 855 return 1; 856 return 0; 857 } 858 859 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 860 { 861 struct pl2303_private *priv = usb_get_serial_port_data(port); 862 unsigned long flags; 863 unsigned int prevstatus; 864 unsigned int status; 865 unsigned int changed; 866 867 spin_lock_irqsave(&priv->lock, flags); 868 prevstatus = priv->line_status; 869 spin_unlock_irqrestore(&priv->lock, flags); 870 871 while (1) { 872 interruptible_sleep_on(&priv->delta_msr_wait); 873 /* see if a signal did it */ 874 if (signal_pending(current)) 875 return -ERESTARTSYS; 876 877 spin_lock_irqsave(&priv->lock, flags); 878 status = priv->line_status; 879 spin_unlock_irqrestore(&priv->lock, flags); 880 881 changed = prevstatus ^ status; 882 883 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 884 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 885 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 886 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 887 return 0; 888 } 889 prevstatus = status; 890 } 891 /* NOTREACHED */ 892 return 0; 893 } 894 895 static int pl2303_ioctl(struct tty_struct *tty, struct file *file, 896 unsigned int cmd, unsigned long arg) 897 { 898 struct usb_serial_port *port = tty->driver_data; 899 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 900 901 switch (cmd) { 902 case TIOCMIWAIT: 903 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 904 return wait_modem_info(port, arg); 905 default: 906 dbg("%s not supported = 0x%04x", __func__, cmd); 907 break; 908 } 909 return -ENOIOCTLCMD; 910 } 911 912 static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 913 { 914 struct usb_serial_port *port = tty->driver_data; 915 struct usb_serial *serial = port->serial; 916 u16 state; 917 int result; 918 919 dbg("%s - port %d", __func__, port->number); 920 921 if (break_state == 0) 922 state = BREAK_OFF; 923 else 924 state = BREAK_ON; 925 dbg("%s - turning break %s", __func__, 926 state == BREAK_OFF ? "off" : "on"); 927 928 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 929 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 930 0, NULL, 0, 100); 931 if (result) 932 dbg("%s - error sending break = %d", __func__, result); 933 } 934 935 static void pl2303_release(struct usb_serial *serial) 936 { 937 int i; 938 struct pl2303_private *priv; 939 940 dbg("%s", __func__); 941 942 for (i = 0; i < serial->num_ports; ++i) { 943 priv = usb_get_serial_port_data(serial->port[i]); 944 if (priv) { 945 pl2303_buf_free(priv->buf); 946 kfree(priv); 947 } 948 } 949 } 950 951 static void pl2303_update_line_status(struct usb_serial_port *port, 952 unsigned char *data, 953 unsigned int actual_length) 954 { 955 956 struct pl2303_private *priv = usb_get_serial_port_data(port); 957 unsigned long flags; 958 u8 status_idx = UART_STATE; 959 u8 length = UART_STATE + 1; 960 u16 idv, idp; 961 962 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 963 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 964 965 966 if (idv == SIEMENS_VENDOR_ID) { 967 if (idp == SIEMENS_PRODUCT_ID_X65 || 968 idp == SIEMENS_PRODUCT_ID_SX1 || 969 idp == SIEMENS_PRODUCT_ID_X75) { 970 971 length = 1; 972 status_idx = 0; 973 } 974 } 975 976 if (actual_length < length) 977 return; 978 979 /* Save off the uart status for others to look at */ 980 spin_lock_irqsave(&priv->lock, flags); 981 priv->line_status = data[status_idx]; 982 spin_unlock_irqrestore(&priv->lock, flags); 983 if (priv->line_status & UART_BREAK_ERROR) 984 usb_serial_handle_break(port); 985 wake_up_interruptible(&priv->delta_msr_wait); 986 } 987 988 static void pl2303_read_int_callback(struct urb *urb) 989 { 990 struct usb_serial_port *port = urb->context; 991 unsigned char *data = urb->transfer_buffer; 992 unsigned int actual_length = urb->actual_length; 993 int status = urb->status; 994 int retval; 995 996 dbg("%s (%d)", __func__, port->number); 997 998 switch (status) { 999 case 0: 1000 /* success */ 1001 break; 1002 case -ECONNRESET: 1003 case -ENOENT: 1004 case -ESHUTDOWN: 1005 /* this urb is terminated, clean up */ 1006 dbg("%s - urb shutting down with status: %d", __func__, 1007 status); 1008 return; 1009 default: 1010 dbg("%s - nonzero urb status received: %d", __func__, 1011 status); 1012 goto exit; 1013 } 1014 1015 usb_serial_debug_data(debug, &port->dev, __func__, 1016 urb->actual_length, urb->transfer_buffer); 1017 1018 pl2303_update_line_status(port, data, actual_length); 1019 1020 exit: 1021 retval = usb_submit_urb(urb, GFP_ATOMIC); 1022 if (retval) 1023 dev_err(&urb->dev->dev, 1024 "%s - usb_submit_urb failed with result %d\n", 1025 __func__, retval); 1026 } 1027 1028 static void pl2303_push_data(struct tty_struct *tty, 1029 struct usb_serial_port *port, struct urb *urb, 1030 u8 line_status) 1031 { 1032 unsigned char *data = urb->transfer_buffer; 1033 /* get tty_flag from status */ 1034 char tty_flag = TTY_NORMAL; 1035 /* break takes precedence over parity, */ 1036 /* which takes precedence over framing errors */ 1037 if (line_status & UART_BREAK_ERROR) 1038 tty_flag = TTY_BREAK; 1039 else if (line_status & UART_PARITY_ERROR) 1040 tty_flag = TTY_PARITY; 1041 else if (line_status & UART_FRAME_ERROR) 1042 tty_flag = TTY_FRAME; 1043 dbg("%s - tty_flag = %d", __func__, tty_flag); 1044 1045 tty_buffer_request_room(tty, urb->actual_length + 1); 1046 /* overrun is special, not associated with a char */ 1047 if (line_status & UART_OVERRUN_ERROR) 1048 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 1049 1050 if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq)) 1051 tty_insert_flip_string(tty, data, urb->actual_length); 1052 else { 1053 int i; 1054 for (i = 0; i < urb->actual_length; ++i) 1055 if (!usb_serial_handle_sysrq_char(tty, port, data[i])) 1056 tty_insert_flip_char(tty, data[i], tty_flag); 1057 } 1058 tty_flip_buffer_push(tty); 1059 } 1060 1061 static void pl2303_read_bulk_callback(struct urb *urb) 1062 { 1063 struct usb_serial_port *port = urb->context; 1064 struct pl2303_private *priv = usb_get_serial_port_data(port); 1065 struct tty_struct *tty; 1066 unsigned long flags; 1067 int result; 1068 int status = urb->status; 1069 u8 line_status; 1070 1071 dbg("%s - port %d", __func__, port->number); 1072 1073 if (status) { 1074 dbg("%s - urb status = %d", __func__, status); 1075 if (!port->port.count) { 1076 dbg("%s - port is closed, exiting.", __func__); 1077 return; 1078 } 1079 if (status == -EPROTO) { 1080 /* PL2303 mysteriously fails with -EPROTO reschedule 1081 * the read */ 1082 dbg("%s - caught -EPROTO, resubmitting the urb", 1083 __func__); 1084 urb->dev = port->serial->dev; 1085 result = usb_submit_urb(urb, GFP_ATOMIC); 1086 if (result) 1087 dev_err(&urb->dev->dev, "%s - failed" 1088 " resubmitting read urb, error %d\n", 1089 __func__, result); 1090 return; 1091 } 1092 dbg("%s - unable to handle the error, exiting.", __func__); 1093 return; 1094 } 1095 1096 usb_serial_debug_data(debug, &port->dev, __func__, 1097 urb->actual_length, urb->transfer_buffer); 1098 1099 spin_lock_irqsave(&priv->lock, flags); 1100 line_status = priv->line_status; 1101 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 1102 spin_unlock_irqrestore(&priv->lock, flags); 1103 wake_up_interruptible(&priv->delta_msr_wait); 1104 1105 tty = tty_port_tty_get(&port->port); 1106 if (tty && urb->actual_length) { 1107 pl2303_push_data(tty, port, urb, line_status); 1108 } 1109 tty_kref_put(tty); 1110 /* Schedule the next read _if_ we are still open */ 1111 if (port->port.count) { 1112 urb->dev = port->serial->dev; 1113 result = usb_submit_urb(urb, GFP_ATOMIC); 1114 if (result) 1115 dev_err(&urb->dev->dev, "%s - failed resubmitting" 1116 " read urb, error %d\n", __func__, result); 1117 } 1118 1119 return; 1120 } 1121 1122 static void pl2303_write_bulk_callback(struct urb *urb) 1123 { 1124 struct usb_serial_port *port = urb->context; 1125 struct pl2303_private *priv = usb_get_serial_port_data(port); 1126 int result; 1127 int status = urb->status; 1128 1129 dbg("%s - port %d", __func__, port->number); 1130 1131 switch (status) { 1132 case 0: 1133 /* success */ 1134 break; 1135 case -ECONNRESET: 1136 case -ENOENT: 1137 case -ESHUTDOWN: 1138 /* this urb is terminated, clean up */ 1139 dbg("%s - urb shutting down with status: %d", __func__, 1140 status); 1141 priv->write_urb_in_use = 0; 1142 return; 1143 default: 1144 /* error in the urb, so we have to resubmit it */ 1145 dbg("%s - Overflow in write", __func__); 1146 dbg("%s - nonzero write bulk status received: %d", __func__, 1147 status); 1148 port->write_urb->transfer_buffer_length = 1; 1149 port->write_urb->dev = port->serial->dev; 1150 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1151 if (result) 1152 dev_err(&urb->dev->dev, "%s - failed resubmitting write" 1153 " urb, error %d\n", __func__, result); 1154 else 1155 return; 1156 } 1157 1158 priv->write_urb_in_use = 0; 1159 1160 /* send any buffered data */ 1161 pl2303_send(port); 1162 } 1163 1164 /* All of the device info needed for the PL2303 SIO serial converter */ 1165 static struct usb_serial_driver pl2303_device = { 1166 .driver = { 1167 .owner = THIS_MODULE, 1168 .name = "pl2303", 1169 }, 1170 .id_table = id_table, 1171 .usb_driver = &pl2303_driver, 1172 .num_ports = 1, 1173 .open = pl2303_open, 1174 .close = pl2303_close, 1175 .dtr_rts = pl2303_dtr_rts, 1176 .carrier_raised = pl2303_carrier_raised, 1177 .write = pl2303_write, 1178 .ioctl = pl2303_ioctl, 1179 .break_ctl = pl2303_break_ctl, 1180 .set_termios = pl2303_set_termios, 1181 .tiocmget = pl2303_tiocmget, 1182 .tiocmset = pl2303_tiocmset, 1183 .read_bulk_callback = pl2303_read_bulk_callback, 1184 .read_int_callback = pl2303_read_int_callback, 1185 .write_bulk_callback = pl2303_write_bulk_callback, 1186 .write_room = pl2303_write_room, 1187 .chars_in_buffer = pl2303_chars_in_buffer, 1188 .attach = pl2303_startup, 1189 .release = pl2303_release, 1190 }; 1191 1192 static int __init pl2303_init(void) 1193 { 1194 int retval; 1195 1196 retval = usb_serial_register(&pl2303_device); 1197 if (retval) 1198 goto failed_usb_serial_register; 1199 retval = usb_register(&pl2303_driver); 1200 if (retval) 1201 goto failed_usb_register; 1202 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1203 return 0; 1204 failed_usb_register: 1205 usb_serial_deregister(&pl2303_device); 1206 failed_usb_serial_register: 1207 return retval; 1208 } 1209 1210 static void __exit pl2303_exit(void) 1211 { 1212 usb_deregister(&pl2303_driver); 1213 usb_serial_deregister(&pl2303_device); 1214 } 1215 1216 module_init(pl2303_init); 1217 module_exit(pl2303_exit); 1218 1219 MODULE_DESCRIPTION(DRIVER_DESC); 1220 MODULE_LICENSE("GPL"); 1221 1222 module_param(debug, bool, S_IRUGO | S_IWUSR); 1223 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1224 1225