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