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