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(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) }, 83 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) }, 84 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) }, 85 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) }, 86 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) }, 87 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) }, 88 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) }, 89 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) }, 90 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) }, 91 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) }, 92 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) }, 93 { USB_DEVICE(HL340_VENDOR_ID, HL340_PRODUCT_ID) }, 94 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) }, 95 { } /* Terminating entry */ 96 }; 97 98 MODULE_DEVICE_TABLE(usb, id_table); 99 100 static struct usb_driver pl2303_driver = { 101 .name = "pl2303", 102 .probe = usb_serial_probe, 103 .disconnect = usb_serial_disconnect, 104 .id_table = id_table, 105 .suspend = usb_serial_suspend, 106 .resume = usb_serial_resume, 107 .no_dynamic_id = 1, 108 .supports_autosuspend = 1, 109 }; 110 111 #define SET_LINE_REQUEST_TYPE 0x21 112 #define SET_LINE_REQUEST 0x20 113 114 #define SET_CONTROL_REQUEST_TYPE 0x21 115 #define SET_CONTROL_REQUEST 0x22 116 #define CONTROL_DTR 0x01 117 #define CONTROL_RTS 0x02 118 119 #define BREAK_REQUEST_TYPE 0x21 120 #define BREAK_REQUEST 0x23 121 #define BREAK_ON 0xffff 122 #define BREAK_OFF 0x0000 123 124 #define GET_LINE_REQUEST_TYPE 0xa1 125 #define GET_LINE_REQUEST 0x21 126 127 #define VENDOR_WRITE_REQUEST_TYPE 0x40 128 #define VENDOR_WRITE_REQUEST 0x01 129 130 #define VENDOR_READ_REQUEST_TYPE 0xc0 131 #define VENDOR_READ_REQUEST 0x01 132 133 #define UART_STATE 0x08 134 #define UART_STATE_TRANSIENT_MASK 0x74 135 #define UART_DCD 0x01 136 #define UART_DSR 0x02 137 #define UART_BREAK_ERROR 0x04 138 #define UART_RING 0x08 139 #define UART_FRAME_ERROR 0x10 140 #define UART_PARITY_ERROR 0x20 141 #define UART_OVERRUN_ERROR 0x40 142 #define UART_CTS 0x80 143 144 145 enum pl2303_type { 146 type_0, /* don't know the difference between type 0 and */ 147 type_1, /* type 1, until someone from prolific tells us... */ 148 HX, /* HX version of the pl2303 chip */ 149 }; 150 151 struct pl2303_private { 152 spinlock_t lock; 153 struct pl2303_buf *buf; 154 int write_urb_in_use; 155 wait_queue_head_t delta_msr_wait; 156 u8 line_control; 157 u8 line_status; 158 u8 termios_initialized; 159 enum pl2303_type type; 160 }; 161 162 /* 163 * pl2303_buf_alloc 164 * 165 * Allocate a circular buffer and all associated memory. 166 */ 167 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size) 168 { 169 struct pl2303_buf *pb; 170 171 if (size == 0) 172 return NULL; 173 174 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL); 175 if (pb == NULL) 176 return NULL; 177 178 pb->buf_buf = kmalloc(size, GFP_KERNEL); 179 if (pb->buf_buf == NULL) { 180 kfree(pb); 181 return NULL; 182 } 183 184 pb->buf_size = size; 185 pb->buf_get = pb->buf_put = pb->buf_buf; 186 187 return pb; 188 } 189 190 /* 191 * pl2303_buf_free 192 * 193 * Free the buffer and all associated memory. 194 */ 195 static void pl2303_buf_free(struct pl2303_buf *pb) 196 { 197 if (pb) { 198 kfree(pb->buf_buf); 199 kfree(pb); 200 } 201 } 202 203 /* 204 * pl2303_buf_clear 205 * 206 * Clear out all data in the circular buffer. 207 */ 208 static void pl2303_buf_clear(struct pl2303_buf *pb) 209 { 210 if (pb != NULL) 211 pb->buf_get = pb->buf_put; 212 /* equivalent to a get of all data available */ 213 } 214 215 /* 216 * pl2303_buf_data_avail 217 * 218 * Return the number of bytes of data available in the circular 219 * buffer. 220 */ 221 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb) 222 { 223 if (pb == NULL) 224 return 0; 225 226 return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size; 227 } 228 229 /* 230 * pl2303_buf_space_avail 231 * 232 * Return the number of bytes of space available in the circular 233 * buffer. 234 */ 235 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb) 236 { 237 if (pb == NULL) 238 return 0; 239 240 return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size; 241 } 242 243 /* 244 * pl2303_buf_put 245 * 246 * Copy data data from a user buffer and put it into the circular buffer. 247 * Restrict to the amount of space available. 248 * 249 * Return the number of bytes copied. 250 */ 251 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf, 252 unsigned int count) 253 { 254 unsigned int len; 255 256 if (pb == NULL) 257 return 0; 258 259 len = pl2303_buf_space_avail(pb); 260 if (count > len) 261 count = len; 262 263 if (count == 0) 264 return 0; 265 266 len = pb->buf_buf + pb->buf_size - pb->buf_put; 267 if (count > len) { 268 memcpy(pb->buf_put, buf, len); 269 memcpy(pb->buf_buf, buf+len, count - len); 270 pb->buf_put = pb->buf_buf + count - len; 271 } else { 272 memcpy(pb->buf_put, buf, count); 273 if (count < len) 274 pb->buf_put += count; 275 else /* count == len */ 276 pb->buf_put = pb->buf_buf; 277 } 278 279 return count; 280 } 281 282 /* 283 * pl2303_buf_get 284 * 285 * Get data from the circular buffer and copy to the given buffer. 286 * Restrict to the amount of data available. 287 * 288 * Return the number of bytes copied. 289 */ 290 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf, 291 unsigned int count) 292 { 293 unsigned int len; 294 295 if (pb == NULL) 296 return 0; 297 298 len = pl2303_buf_data_avail(pb); 299 if (count > len) 300 count = len; 301 302 if (count == 0) 303 return 0; 304 305 len = pb->buf_buf + pb->buf_size - pb->buf_get; 306 if (count > len) { 307 memcpy(buf, pb->buf_get, len); 308 memcpy(buf+len, pb->buf_buf, count - len); 309 pb->buf_get = pb->buf_buf + count - len; 310 } else { 311 memcpy(buf, pb->buf_get, count); 312 if (count < len) 313 pb->buf_get += count; 314 else /* count == len */ 315 pb->buf_get = pb->buf_buf; 316 } 317 318 return count; 319 } 320 321 static int pl2303_vendor_read(__u16 value, __u16 index, 322 struct usb_serial *serial, unsigned char *buf) 323 { 324 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 325 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE, 326 value, index, buf, 1, 100); 327 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE, 328 VENDOR_READ_REQUEST, value, index, res, buf[0]); 329 return res; 330 } 331 332 static int pl2303_vendor_write(__u16 value, __u16 index, 333 struct usb_serial *serial) 334 { 335 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 336 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE, 337 value, index, NULL, 0, 100); 338 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE, 339 VENDOR_WRITE_REQUEST, value, index, res); 340 return res; 341 } 342 343 static int pl2303_startup(struct usb_serial *serial) 344 { 345 struct pl2303_private *priv; 346 enum pl2303_type type = type_0; 347 unsigned char *buf; 348 int i; 349 350 buf = kmalloc(10, GFP_KERNEL); 351 if (buf == NULL) 352 return -ENOMEM; 353 354 if (serial->dev->descriptor.bDeviceClass == 0x02) 355 type = type_0; 356 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40) 357 type = HX; 358 else if (serial->dev->descriptor.bDeviceClass == 0x00) 359 type = type_1; 360 else if (serial->dev->descriptor.bDeviceClass == 0xFF) 361 type = type_1; 362 dbg("device type: %d", type); 363 364 for (i = 0; i < serial->num_ports; ++i) { 365 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL); 366 if (!priv) 367 goto cleanup; 368 spin_lock_init(&priv->lock); 369 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE); 370 if (priv->buf == NULL) { 371 kfree(priv); 372 goto cleanup; 373 } 374 init_waitqueue_head(&priv->delta_msr_wait); 375 priv->type = type; 376 usb_set_serial_port_data(serial->port[i], priv); 377 } 378 379 pl2303_vendor_read(0x8484, 0, serial, buf); 380 pl2303_vendor_write(0x0404, 0, serial); 381 pl2303_vendor_read(0x8484, 0, serial, buf); 382 pl2303_vendor_read(0x8383, 0, serial, buf); 383 pl2303_vendor_read(0x8484, 0, serial, buf); 384 pl2303_vendor_write(0x0404, 1, serial); 385 pl2303_vendor_read(0x8484, 0, serial, buf); 386 pl2303_vendor_read(0x8383, 0, serial, buf); 387 pl2303_vendor_write(0, 1, serial); 388 pl2303_vendor_write(1, 0, serial); 389 if (type == HX) 390 pl2303_vendor_write(2, 0x44, serial); 391 else 392 pl2303_vendor_write(2, 0x24, serial); 393 394 kfree(buf); 395 return 0; 396 397 cleanup: 398 kfree(buf); 399 for (--i; i >= 0; --i) { 400 priv = usb_get_serial_port_data(serial->port[i]); 401 pl2303_buf_free(priv->buf); 402 kfree(priv); 403 usb_set_serial_port_data(serial->port[i], NULL); 404 } 405 return -ENOMEM; 406 } 407 408 static int set_control_lines(struct usb_device *dev, u8 value) 409 { 410 int retval; 411 412 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 413 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE, 414 value, 0, NULL, 0, 100); 415 dbg("%s - value = %d, retval = %d", __func__, value, retval); 416 return retval; 417 } 418 419 static void pl2303_send(struct usb_serial_port *port) 420 { 421 int count, result; 422 struct pl2303_private *priv = usb_get_serial_port_data(port); 423 unsigned long flags; 424 425 dbg("%s - port %d", __func__, port->number); 426 427 spin_lock_irqsave(&priv->lock, flags); 428 429 if (priv->write_urb_in_use) { 430 spin_unlock_irqrestore(&priv->lock, flags); 431 return; 432 } 433 434 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer, 435 port->bulk_out_size); 436 437 if (count == 0) { 438 spin_unlock_irqrestore(&priv->lock, flags); 439 return; 440 } 441 442 priv->write_urb_in_use = 1; 443 444 spin_unlock_irqrestore(&priv->lock, flags); 445 446 usb_serial_debug_data(debug, &port->dev, __func__, count, 447 port->write_urb->transfer_buffer); 448 449 port->write_urb->transfer_buffer_length = count; 450 port->write_urb->dev = port->serial->dev; 451 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 452 if (result) { 453 dev_err(&port->dev, "%s - failed submitting write urb," 454 " error %d\n", __func__, result); 455 priv->write_urb_in_use = 0; 456 /* TODO: reschedule pl2303_send */ 457 } 458 459 usb_serial_port_softint(port); 460 } 461 462 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port, 463 const unsigned char *buf, int count) 464 { 465 struct pl2303_private *priv = usb_get_serial_port_data(port); 466 unsigned long flags; 467 468 dbg("%s - port %d, %d bytes", __func__, port->number, count); 469 470 if (!count) 471 return count; 472 473 spin_lock_irqsave(&priv->lock, flags); 474 count = pl2303_buf_put(priv->buf, buf, count); 475 spin_unlock_irqrestore(&priv->lock, flags); 476 477 pl2303_send(port); 478 479 return count; 480 } 481 482 static int pl2303_write_room(struct tty_struct *tty) 483 { 484 struct usb_serial_port *port = tty->driver_data; 485 struct pl2303_private *priv = usb_get_serial_port_data(port); 486 int room = 0; 487 unsigned long flags; 488 489 dbg("%s - port %d", __func__, port->number); 490 491 spin_lock_irqsave(&priv->lock, flags); 492 room = pl2303_buf_space_avail(priv->buf); 493 spin_unlock_irqrestore(&priv->lock, flags); 494 495 dbg("%s - returns %d", __func__, room); 496 return room; 497 } 498 499 static int pl2303_chars_in_buffer(struct tty_struct *tty) 500 { 501 struct usb_serial_port *port = tty->driver_data; 502 struct pl2303_private *priv = usb_get_serial_port_data(port); 503 int chars = 0; 504 unsigned long flags; 505 506 dbg("%s - port %d", __func__, port->number); 507 508 spin_lock_irqsave(&priv->lock, flags); 509 chars = pl2303_buf_data_avail(priv->buf); 510 spin_unlock_irqrestore(&priv->lock, flags); 511 512 dbg("%s - returns %d", __func__, chars); 513 return chars; 514 } 515 516 static void pl2303_set_termios(struct tty_struct *tty, 517 struct usb_serial_port *port, struct ktermios *old_termios) 518 { 519 struct usb_serial *serial = port->serial; 520 struct pl2303_private *priv = usb_get_serial_port_data(port); 521 unsigned long flags; 522 unsigned int cflag; 523 unsigned char *buf; 524 int baud; 525 int i; 526 u8 control; 527 528 dbg("%s - port %d", __func__, port->number); 529 530 spin_lock_irqsave(&priv->lock, flags); 531 if (!priv->termios_initialized) { 532 *(tty->termios) = tty_std_termios; 533 tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 534 tty->termios->c_ispeed = 9600; 535 tty->termios->c_ospeed = 9600; 536 priv->termios_initialized = 1; 537 } 538 spin_unlock_irqrestore(&priv->lock, flags); 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 baud = tty_get_baud_rate(tty); 583 dbg("%s - baud = %d", __func__, baud); 584 if (baud) { 585 buf[0] = baud & 0xff; 586 buf[1] = (baud >> 8) & 0xff; 587 buf[2] = (baud >> 16) & 0xff; 588 buf[3] = (baud >> 24) & 0xff; 589 } 590 591 /* For reference buf[4]=0 is 1 stop bits */ 592 /* For reference buf[4]=1 is 1.5 stop bits */ 593 /* For reference buf[4]=2 is 2 stop bits */ 594 if (cflag & CSTOPB) { 595 buf[4] = 2; 596 dbg("%s - stop bits = 2", __func__); 597 } else { 598 buf[4] = 0; 599 dbg("%s - stop bits = 1", __func__); 600 } 601 602 if (cflag & PARENB) { 603 /* For reference buf[5]=0 is none parity */ 604 /* For reference buf[5]=1 is odd parity */ 605 /* For reference buf[5]=2 is even parity */ 606 /* For reference buf[5]=3 is mark parity */ 607 /* For reference buf[5]=4 is space parity */ 608 if (cflag & PARODD) { 609 buf[5] = 1; 610 dbg("%s - parity = odd", __func__); 611 } else { 612 buf[5] = 2; 613 dbg("%s - parity = even", __func__); 614 } 615 } else { 616 buf[5] = 0; 617 dbg("%s - parity = none", __func__); 618 } 619 620 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 621 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE, 622 0, 0, buf, 7, 100); 623 dbg("0x21:0x20:0:0 %d", i); 624 625 /* change control lines if we are switching to or from B0 */ 626 spin_lock_irqsave(&priv->lock, flags); 627 control = priv->line_control; 628 if ((cflag & CBAUD) == B0) 629 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 630 else 631 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 632 if (control != priv->line_control) { 633 control = priv->line_control; 634 spin_unlock_irqrestore(&priv->lock, flags); 635 set_control_lines(serial->dev, control); 636 } else { 637 spin_unlock_irqrestore(&priv->lock, flags); 638 } 639 640 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0; 641 642 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 643 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 644 0, 0, buf, 7, 100); 645 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 646 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 647 648 if (cflag & CRTSCTS) { 649 if (priv->type == HX) 650 pl2303_vendor_write(0x0, 0x61, serial); 651 else 652 pl2303_vendor_write(0x0, 0x41, serial); 653 } else { 654 pl2303_vendor_write(0x0, 0x0, serial); 655 } 656 657 /* FIXME: Need to read back resulting baud rate */ 658 if (baud) 659 tty_encode_baud_rate(tty, baud, baud); 660 661 kfree(buf); 662 } 663 664 static void pl2303_close(struct tty_struct *tty, 665 struct usb_serial_port *port, struct file *filp) 666 { 667 struct pl2303_private *priv = usb_get_serial_port_data(port); 668 unsigned long flags; 669 unsigned int c_cflag; 670 int bps; 671 long timeout; 672 wait_queue_t wait; 673 674 dbg("%s - port %d", __func__, port->number); 675 676 /* wait for data to drain from the buffer */ 677 spin_lock_irqsave(&priv->lock, flags); 678 timeout = PL2303_CLOSING_WAIT; 679 init_waitqueue_entry(&wait, current); 680 add_wait_queue(&tty->write_wait, &wait); 681 for (;;) { 682 set_current_state(TASK_INTERRUPTIBLE); 683 if (pl2303_buf_data_avail(priv->buf) == 0 || 684 timeout == 0 || signal_pending(current) || 685 port->serial->disconnected) 686 break; 687 spin_unlock_irqrestore(&priv->lock, flags); 688 timeout = schedule_timeout(timeout); 689 spin_lock_irqsave(&priv->lock, flags); 690 } 691 set_current_state(TASK_RUNNING); 692 remove_wait_queue(&tty->write_wait, &wait); 693 /* clear out any remaining data in the buffer */ 694 pl2303_buf_clear(priv->buf); 695 spin_unlock_irqrestore(&priv->lock, flags); 696 697 /* wait for characters to drain from the device */ 698 /* (this is long enough for the entire 256 byte */ 699 /* pl2303 hardware buffer to drain with no flow */ 700 /* control for data rates of 1200 bps or more, */ 701 /* for lower rates we should really know how much */ 702 /* data is in the buffer to compute a delay */ 703 /* that is not unnecessarily long) */ 704 bps = tty_get_baud_rate(tty); 705 if (bps > 1200) 706 timeout = max((HZ*2560)/bps, HZ/10); 707 else 708 timeout = 2*HZ; 709 schedule_timeout_interruptible(timeout); 710 711 /* shutdown our urbs */ 712 dbg("%s - shutting down urbs", __func__); 713 usb_kill_urb(port->write_urb); 714 usb_kill_urb(port->read_urb); 715 usb_kill_urb(port->interrupt_in_urb); 716 717 if (tty) { 718 c_cflag = tty->termios->c_cflag; 719 if (c_cflag & HUPCL) { 720 /* drop DTR and RTS */ 721 spin_lock_irqsave(&priv->lock, flags); 722 priv->line_control = 0; 723 spin_unlock_irqrestore(&priv->lock, flags); 724 set_control_lines(port->serial->dev, 0); 725 } 726 } 727 } 728 729 static int pl2303_open(struct tty_struct *tty, 730 struct usb_serial_port *port, struct file *filp) 731 { 732 struct ktermios tmp_termios; 733 struct usb_serial *serial = port->serial; 734 struct pl2303_private *priv = usb_get_serial_port_data(port); 735 int result; 736 737 dbg("%s - port %d", __func__, port->number); 738 739 if (priv->type != HX) { 740 usb_clear_halt(serial->dev, port->write_urb->pipe); 741 usb_clear_halt(serial->dev, port->read_urb->pipe); 742 } else { 743 /* reset upstream data pipes */ 744 pl2303_vendor_write(8, 0, serial); 745 pl2303_vendor_write(9, 0, serial); 746 } 747 748 /* Setup termios */ 749 if (tty) 750 pl2303_set_termios(tty, port, &tmp_termios); 751 752 /* FIXME: need to assert RTS and DTR if CRTSCTS off */ 753 754 dbg("%s - submitting read urb", __func__); 755 port->read_urb->dev = serial->dev; 756 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 757 if (result) { 758 dev_err(&port->dev, "%s - failed submitting read urb," 759 " error %d\n", __func__, result); 760 pl2303_close(tty, port, NULL); 761 return -EPROTO; 762 } 763 764 dbg("%s - submitting interrupt urb", __func__); 765 port->interrupt_in_urb->dev = serial->dev; 766 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 767 if (result) { 768 dev_err(&port->dev, "%s - failed submitting interrupt urb," 769 " error %d\n", __func__, result); 770 pl2303_close(tty, port, NULL); 771 return -EPROTO; 772 } 773 return 0; 774 } 775 776 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file, 777 unsigned int set, unsigned int clear) 778 { 779 struct usb_serial_port *port = tty->driver_data; 780 struct pl2303_private *priv = usb_get_serial_port_data(port); 781 unsigned long flags; 782 u8 control; 783 784 if (!usb_get_intfdata(port->serial->interface)) 785 return -ENODEV; 786 787 spin_lock_irqsave(&priv->lock, flags); 788 if (set & TIOCM_RTS) 789 priv->line_control |= CONTROL_RTS; 790 if (set & TIOCM_DTR) 791 priv->line_control |= CONTROL_DTR; 792 if (clear & TIOCM_RTS) 793 priv->line_control &= ~CONTROL_RTS; 794 if (clear & TIOCM_DTR) 795 priv->line_control &= ~CONTROL_DTR; 796 control = priv->line_control; 797 spin_unlock_irqrestore(&priv->lock, flags); 798 799 return set_control_lines(port->serial->dev, control); 800 } 801 802 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file) 803 { 804 struct usb_serial_port *port = tty->driver_data; 805 struct pl2303_private *priv = usb_get_serial_port_data(port); 806 unsigned long flags; 807 unsigned int mcr; 808 unsigned int status; 809 unsigned int result; 810 811 dbg("%s (%d)", __func__, port->number); 812 813 if (!usb_get_intfdata(port->serial->interface)) 814 return -ENODEV; 815 816 spin_lock_irqsave(&priv->lock, flags); 817 mcr = priv->line_control; 818 status = priv->line_status; 819 spin_unlock_irqrestore(&priv->lock, flags); 820 821 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 822 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 823 | ((status & UART_CTS) ? TIOCM_CTS : 0) 824 | ((status & UART_DSR) ? TIOCM_DSR : 0) 825 | ((status & UART_RING) ? TIOCM_RI : 0) 826 | ((status & UART_DCD) ? TIOCM_CD : 0); 827 828 dbg("%s - result = %x", __func__, result); 829 830 return result; 831 } 832 833 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 834 { 835 struct pl2303_private *priv = usb_get_serial_port_data(port); 836 unsigned long flags; 837 unsigned int prevstatus; 838 unsigned int status; 839 unsigned int changed; 840 841 spin_lock_irqsave(&priv->lock, flags); 842 prevstatus = priv->line_status; 843 spin_unlock_irqrestore(&priv->lock, flags); 844 845 while (1) { 846 interruptible_sleep_on(&priv->delta_msr_wait); 847 /* see if a signal did it */ 848 if (signal_pending(current)) 849 return -ERESTARTSYS; 850 851 spin_lock_irqsave(&priv->lock, flags); 852 status = priv->line_status; 853 spin_unlock_irqrestore(&priv->lock, flags); 854 855 changed = prevstatus ^ status; 856 857 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 858 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 859 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 860 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 861 return 0; 862 } 863 prevstatus = status; 864 } 865 /* NOTREACHED */ 866 return 0; 867 } 868 869 static int pl2303_ioctl(struct tty_struct *tty, struct file *file, 870 unsigned int cmd, unsigned long arg) 871 { 872 struct usb_serial_port *port = tty->driver_data; 873 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 874 875 switch (cmd) { 876 case TIOCMIWAIT: 877 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 878 return wait_modem_info(port, arg); 879 default: 880 dbg("%s not supported = 0x%04x", __func__, cmd); 881 break; 882 } 883 return -ENOIOCTLCMD; 884 } 885 886 static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 887 { 888 struct usb_serial_port *port = tty->driver_data; 889 struct usb_serial *serial = port->serial; 890 u16 state; 891 int result; 892 893 dbg("%s - port %d", __func__, port->number); 894 895 if (break_state == 0) 896 state = BREAK_OFF; 897 else 898 state = BREAK_ON; 899 dbg("%s - turning break %s", __func__, 900 state == BREAK_OFF ? "off" : "on"); 901 902 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 903 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 904 0, NULL, 0, 100); 905 if (result) 906 dbg("%s - error sending break = %d", __func__, result); 907 } 908 909 static void pl2303_shutdown(struct usb_serial *serial) 910 { 911 int i; 912 struct pl2303_private *priv; 913 914 dbg("%s", __func__); 915 916 for (i = 0; i < serial->num_ports; ++i) { 917 priv = usb_get_serial_port_data(serial->port[i]); 918 if (priv) { 919 pl2303_buf_free(priv->buf); 920 kfree(priv); 921 usb_set_serial_port_data(serial->port[i], NULL); 922 } 923 } 924 } 925 926 static void pl2303_update_line_status(struct usb_serial_port *port, 927 unsigned char *data, 928 unsigned int actual_length) 929 { 930 931 struct pl2303_private *priv = usb_get_serial_port_data(port); 932 unsigned long flags; 933 u8 status_idx = UART_STATE; 934 u8 length = UART_STATE + 1; 935 u16 idv, idp; 936 937 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 938 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 939 940 941 if (idv == SIEMENS_VENDOR_ID) { 942 if (idp == SIEMENS_PRODUCT_ID_X65 || 943 idp == SIEMENS_PRODUCT_ID_SX1 || 944 idp == SIEMENS_PRODUCT_ID_X75) { 945 946 length = 1; 947 status_idx = 0; 948 } 949 } 950 951 if (actual_length < length) 952 return; 953 954 /* Save off the uart status for others to look at */ 955 spin_lock_irqsave(&priv->lock, flags); 956 priv->line_status = data[status_idx]; 957 spin_unlock_irqrestore(&priv->lock, flags); 958 wake_up_interruptible(&priv->delta_msr_wait); 959 } 960 961 static void pl2303_read_int_callback(struct urb *urb) 962 { 963 struct usb_serial_port *port = urb->context; 964 unsigned char *data = urb->transfer_buffer; 965 unsigned int actual_length = urb->actual_length; 966 int status = urb->status; 967 int retval; 968 969 dbg("%s (%d)", __func__, port->number); 970 971 switch (status) { 972 case 0: 973 /* success */ 974 break; 975 case -ECONNRESET: 976 case -ENOENT: 977 case -ESHUTDOWN: 978 /* this urb is terminated, clean up */ 979 dbg("%s - urb shutting down with status: %d", __func__, 980 status); 981 return; 982 default: 983 dbg("%s - nonzero urb status received: %d", __func__, 984 status); 985 goto exit; 986 } 987 988 usb_serial_debug_data(debug, &port->dev, __func__, 989 urb->actual_length, urb->transfer_buffer); 990 991 pl2303_update_line_status(port, data, actual_length); 992 993 exit: 994 retval = usb_submit_urb(urb, GFP_ATOMIC); 995 if (retval) 996 dev_err(&urb->dev->dev, 997 "%s - usb_submit_urb failed with result %d\n", 998 __func__, retval); 999 } 1000 1001 static void pl2303_read_bulk_callback(struct urb *urb) 1002 { 1003 struct usb_serial_port *port = urb->context; 1004 struct pl2303_private *priv = usb_get_serial_port_data(port); 1005 struct tty_struct *tty; 1006 unsigned char *data = urb->transfer_buffer; 1007 unsigned long flags; 1008 int i; 1009 int result; 1010 int status = urb->status; 1011 u8 line_status; 1012 char tty_flag; 1013 1014 dbg("%s - port %d", __func__, port->number); 1015 1016 if (status) { 1017 dbg("%s - urb status = %d", __func__, status); 1018 if (!port->port.count) { 1019 dbg("%s - port is closed, exiting.", __func__); 1020 return; 1021 } 1022 if (status == -EPROTO) { 1023 /* PL2303 mysteriously fails with -EPROTO reschedule 1024 * the read */ 1025 dbg("%s - caught -EPROTO, resubmitting the urb", 1026 __func__); 1027 urb->dev = port->serial->dev; 1028 result = usb_submit_urb(urb, GFP_ATOMIC); 1029 if (result) 1030 dev_err(&urb->dev->dev, "%s - failed" 1031 " resubmitting read urb, error %d\n", 1032 __func__, result); 1033 return; 1034 } 1035 dbg("%s - unable to handle the error, exiting.", __func__); 1036 return; 1037 } 1038 1039 usb_serial_debug_data(debug, &port->dev, __func__, 1040 urb->actual_length, data); 1041 1042 /* get tty_flag from status */ 1043 tty_flag = TTY_NORMAL; 1044 1045 spin_lock_irqsave(&priv->lock, flags); 1046 line_status = priv->line_status; 1047 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 1048 spin_unlock_irqrestore(&priv->lock, flags); 1049 wake_up_interruptible(&priv->delta_msr_wait); 1050 1051 /* break takes precedence over parity, */ 1052 /* which takes precedence over framing errors */ 1053 if (line_status & UART_BREAK_ERROR) 1054 tty_flag = TTY_BREAK; 1055 else if (line_status & UART_PARITY_ERROR) 1056 tty_flag = TTY_PARITY; 1057 else if (line_status & UART_FRAME_ERROR) 1058 tty_flag = TTY_FRAME; 1059 dbg("%s - tty_flag = %d", __func__, tty_flag); 1060 1061 tty = port->port.tty; 1062 if (tty && urb->actual_length) { 1063 tty_buffer_request_room(tty, urb->actual_length + 1); 1064 /* overrun is special, not associated with a char */ 1065 if (line_status & UART_OVERRUN_ERROR) 1066 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 1067 for (i = 0; i < urb->actual_length; ++i) 1068 tty_insert_flip_char(tty, data[i], tty_flag); 1069 tty_flip_buffer_push(tty); 1070 } 1071 1072 /* Schedule the next read _if_ we are still open */ 1073 if (port->port.count) { 1074 urb->dev = port->serial->dev; 1075 result = usb_submit_urb(urb, GFP_ATOMIC); 1076 if (result) 1077 dev_err(&urb->dev->dev, "%s - failed resubmitting" 1078 " read urb, error %d\n", __func__, result); 1079 } 1080 1081 return; 1082 } 1083 1084 static void pl2303_write_bulk_callback(struct urb *urb) 1085 { 1086 struct usb_serial_port *port = urb->context; 1087 struct pl2303_private *priv = usb_get_serial_port_data(port); 1088 int result; 1089 int status = urb->status; 1090 1091 dbg("%s - port %d", __func__, port->number); 1092 1093 switch (status) { 1094 case 0: 1095 /* success */ 1096 break; 1097 case -ECONNRESET: 1098 case -ENOENT: 1099 case -ESHUTDOWN: 1100 /* this urb is terminated, clean up */ 1101 dbg("%s - urb shutting down with status: %d", __func__, 1102 status); 1103 priv->write_urb_in_use = 0; 1104 return; 1105 default: 1106 /* error in the urb, so we have to resubmit it */ 1107 dbg("%s - Overflow in write", __func__); 1108 dbg("%s - nonzero write bulk status received: %d", __func__, 1109 status); 1110 port->write_urb->transfer_buffer_length = 1; 1111 port->write_urb->dev = port->serial->dev; 1112 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1113 if (result) 1114 dev_err(&urb->dev->dev, "%s - failed resubmitting write" 1115 " urb, error %d\n", __func__, result); 1116 else 1117 return; 1118 } 1119 1120 priv->write_urb_in_use = 0; 1121 1122 /* send any buffered data */ 1123 pl2303_send(port); 1124 } 1125 1126 /* All of the device info needed for the PL2303 SIO serial converter */ 1127 static struct usb_serial_driver pl2303_device = { 1128 .driver = { 1129 .owner = THIS_MODULE, 1130 .name = "pl2303", 1131 }, 1132 .id_table = id_table, 1133 .usb_driver = &pl2303_driver, 1134 .num_ports = 1, 1135 .open = pl2303_open, 1136 .close = pl2303_close, 1137 .write = pl2303_write, 1138 .ioctl = pl2303_ioctl, 1139 .break_ctl = pl2303_break_ctl, 1140 .set_termios = pl2303_set_termios, 1141 .tiocmget = pl2303_tiocmget, 1142 .tiocmset = pl2303_tiocmset, 1143 .read_bulk_callback = pl2303_read_bulk_callback, 1144 .read_int_callback = pl2303_read_int_callback, 1145 .write_bulk_callback = pl2303_write_bulk_callback, 1146 .write_room = pl2303_write_room, 1147 .chars_in_buffer = pl2303_chars_in_buffer, 1148 .attach = pl2303_startup, 1149 .shutdown = pl2303_shutdown, 1150 }; 1151 1152 static int __init pl2303_init(void) 1153 { 1154 int retval; 1155 1156 retval = usb_serial_register(&pl2303_device); 1157 if (retval) 1158 goto failed_usb_serial_register; 1159 retval = usb_register(&pl2303_driver); 1160 if (retval) 1161 goto failed_usb_register; 1162 info(DRIVER_DESC); 1163 return 0; 1164 failed_usb_register: 1165 usb_serial_deregister(&pl2303_device); 1166 failed_usb_serial_register: 1167 return retval; 1168 } 1169 1170 static void __exit pl2303_exit(void) 1171 { 1172 usb_deregister(&pl2303_driver); 1173 usb_serial_deregister(&pl2303_device); 1174 } 1175 1176 module_init(pl2303_init); 1177 module_exit(pl2303_exit); 1178 1179 MODULE_DESCRIPTION(DRIVER_DESC); 1180 MODULE_LICENSE("GPL"); 1181 1182 module_param(debug, bool, S_IRUGO | S_IWUSR); 1183 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1184 1185