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 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) }, 95 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) }, 96 { } /* Terminating entry */ 97 }; 98 99 MODULE_DEVICE_TABLE(usb, id_table); 100 101 static struct usb_driver pl2303_driver = { 102 .name = "pl2303", 103 .probe = usb_serial_probe, 104 .disconnect = usb_serial_disconnect, 105 .id_table = id_table, 106 .suspend = usb_serial_suspend, 107 .resume = usb_serial_resume, 108 .no_dynamic_id = 1, 109 .supports_autosuspend = 1, 110 }; 111 112 #define SET_LINE_REQUEST_TYPE 0x21 113 #define SET_LINE_REQUEST 0x20 114 115 #define SET_CONTROL_REQUEST_TYPE 0x21 116 #define SET_CONTROL_REQUEST 0x22 117 #define CONTROL_DTR 0x01 118 #define CONTROL_RTS 0x02 119 120 #define BREAK_REQUEST_TYPE 0x21 121 #define BREAK_REQUEST 0x23 122 #define BREAK_ON 0xffff 123 #define BREAK_OFF 0x0000 124 125 #define GET_LINE_REQUEST_TYPE 0xa1 126 #define GET_LINE_REQUEST 0x21 127 128 #define VENDOR_WRITE_REQUEST_TYPE 0x40 129 #define VENDOR_WRITE_REQUEST 0x01 130 131 #define VENDOR_READ_REQUEST_TYPE 0xc0 132 #define VENDOR_READ_REQUEST 0x01 133 134 #define UART_STATE 0x08 135 #define UART_STATE_TRANSIENT_MASK 0x74 136 #define UART_DCD 0x01 137 #define UART_DSR 0x02 138 #define UART_BREAK_ERROR 0x04 139 #define UART_RING 0x08 140 #define UART_FRAME_ERROR 0x10 141 #define UART_PARITY_ERROR 0x20 142 #define UART_OVERRUN_ERROR 0x40 143 #define UART_CTS 0x80 144 145 146 enum pl2303_type { 147 type_0, /* don't know the difference between type 0 and */ 148 type_1, /* type 1, until someone from prolific tells us... */ 149 HX, /* HX version of the pl2303 chip */ 150 }; 151 152 struct pl2303_private { 153 spinlock_t lock; 154 struct pl2303_buf *buf; 155 int write_urb_in_use; 156 wait_queue_head_t delta_msr_wait; 157 u8 line_control; 158 u8 line_status; 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 /* The PL2303 is reported to lose bytes if you change 531 serial settings even to the same values as before. Thus 532 we actually need to filter in this specific case */ 533 534 if (!tty_termios_hw_change(tty->termios, old_termios)) 535 return; 536 537 cflag = tty->termios->c_cflag; 538 539 buf = kzalloc(7, GFP_KERNEL); 540 if (!buf) { 541 dev_err(&port->dev, "%s - out of memory.\n", __func__); 542 /* Report back no change occurred */ 543 *tty->termios = *old_termios; 544 return; 545 } 546 547 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 548 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 549 0, 0, buf, 7, 100); 550 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 551 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 552 553 if (cflag & CSIZE) { 554 switch (cflag & CSIZE) { 555 case CS5: 556 buf[6] = 5; 557 break; 558 case CS6: 559 buf[6] = 6; 560 break; 561 case CS7: 562 buf[6] = 7; 563 break; 564 default: 565 case CS8: 566 buf[6] = 8; 567 break; 568 } 569 dbg("%s - data bits = %d", __func__, buf[6]); 570 } 571 572 baud = tty_get_baud_rate(tty); 573 dbg("%s - baud = %d", __func__, baud); 574 if (baud) { 575 buf[0] = baud & 0xff; 576 buf[1] = (baud >> 8) & 0xff; 577 buf[2] = (baud >> 16) & 0xff; 578 buf[3] = (baud >> 24) & 0xff; 579 } 580 581 /* For reference buf[4]=0 is 1 stop bits */ 582 /* For reference buf[4]=1 is 1.5 stop bits */ 583 /* For reference buf[4]=2 is 2 stop bits */ 584 if (cflag & CSTOPB) { 585 buf[4] = 2; 586 dbg("%s - stop bits = 2", __func__); 587 } else { 588 buf[4] = 0; 589 dbg("%s - stop bits = 1", __func__); 590 } 591 592 if (cflag & PARENB) { 593 /* For reference buf[5]=0 is none parity */ 594 /* For reference buf[5]=1 is odd parity */ 595 /* For reference buf[5]=2 is even parity */ 596 /* For reference buf[5]=3 is mark parity */ 597 /* For reference buf[5]=4 is space parity */ 598 if (cflag & PARODD) { 599 buf[5] = 1; 600 dbg("%s - parity = odd", __func__); 601 } else { 602 buf[5] = 2; 603 dbg("%s - parity = even", __func__); 604 } 605 } else { 606 buf[5] = 0; 607 dbg("%s - parity = none", __func__); 608 } 609 610 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 611 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE, 612 0, 0, buf, 7, 100); 613 dbg("0x21:0x20:0:0 %d", i); 614 615 /* change control lines if we are switching to or from B0 */ 616 spin_lock_irqsave(&priv->lock, flags); 617 control = priv->line_control; 618 if ((cflag & CBAUD) == B0) 619 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 620 else 621 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 622 if (control != priv->line_control) { 623 control = priv->line_control; 624 spin_unlock_irqrestore(&priv->lock, flags); 625 set_control_lines(serial->dev, control); 626 } else { 627 spin_unlock_irqrestore(&priv->lock, flags); 628 } 629 630 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0; 631 632 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 633 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 634 0, 0, buf, 7, 100); 635 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 636 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 637 638 if (cflag & CRTSCTS) { 639 if (priv->type == HX) 640 pl2303_vendor_write(0x0, 0x61, serial); 641 else 642 pl2303_vendor_write(0x0, 0x41, serial); 643 } else { 644 pl2303_vendor_write(0x0, 0x0, serial); 645 } 646 647 /* FIXME: Need to read back resulting baud rate */ 648 if (baud) 649 tty_encode_baud_rate(tty, baud, baud); 650 651 kfree(buf); 652 } 653 654 static void pl2303_close(struct tty_struct *tty, 655 struct usb_serial_port *port, struct file *filp) 656 { 657 struct pl2303_private *priv = usb_get_serial_port_data(port); 658 unsigned long flags; 659 unsigned int c_cflag; 660 int bps; 661 long timeout; 662 wait_queue_t wait; 663 664 dbg("%s - port %d", __func__, port->number); 665 666 /* wait for data to drain from the buffer */ 667 spin_lock_irqsave(&priv->lock, flags); 668 timeout = PL2303_CLOSING_WAIT; 669 init_waitqueue_entry(&wait, current); 670 add_wait_queue(&tty->write_wait, &wait); 671 for (;;) { 672 set_current_state(TASK_INTERRUPTIBLE); 673 if (pl2303_buf_data_avail(priv->buf) == 0 || 674 timeout == 0 || signal_pending(current) || 675 port->serial->disconnected) 676 break; 677 spin_unlock_irqrestore(&priv->lock, flags); 678 timeout = schedule_timeout(timeout); 679 spin_lock_irqsave(&priv->lock, flags); 680 } 681 set_current_state(TASK_RUNNING); 682 remove_wait_queue(&tty->write_wait, &wait); 683 /* clear out any remaining data in the buffer */ 684 pl2303_buf_clear(priv->buf); 685 spin_unlock_irqrestore(&priv->lock, flags); 686 687 /* wait for characters to drain from the device */ 688 /* (this is long enough for the entire 256 byte */ 689 /* pl2303 hardware buffer to drain with no flow */ 690 /* control for data rates of 1200 bps or more, */ 691 /* for lower rates we should really know how much */ 692 /* data is in the buffer to compute a delay */ 693 /* that is not unnecessarily long) */ 694 bps = tty_get_baud_rate(tty); 695 if (bps > 1200) 696 timeout = max((HZ*2560)/bps, HZ/10); 697 else 698 timeout = 2*HZ; 699 schedule_timeout_interruptible(timeout); 700 701 /* shutdown our urbs */ 702 dbg("%s - shutting down urbs", __func__); 703 usb_kill_urb(port->write_urb); 704 usb_kill_urb(port->read_urb); 705 usb_kill_urb(port->interrupt_in_urb); 706 707 if (tty) { 708 c_cflag = tty->termios->c_cflag; 709 if (c_cflag & HUPCL) { 710 /* drop DTR and RTS */ 711 spin_lock_irqsave(&priv->lock, flags); 712 priv->line_control = 0; 713 spin_unlock_irqrestore(&priv->lock, flags); 714 set_control_lines(port->serial->dev, 0); 715 } 716 } 717 } 718 719 static int pl2303_open(struct tty_struct *tty, 720 struct usb_serial_port *port, struct file *filp) 721 { 722 struct ktermios tmp_termios; 723 struct usb_serial *serial = port->serial; 724 struct pl2303_private *priv = usb_get_serial_port_data(port); 725 int result; 726 727 dbg("%s - port %d", __func__, port->number); 728 729 if (priv->type != HX) { 730 usb_clear_halt(serial->dev, port->write_urb->pipe); 731 usb_clear_halt(serial->dev, port->read_urb->pipe); 732 } else { 733 /* reset upstream data pipes */ 734 pl2303_vendor_write(8, 0, serial); 735 pl2303_vendor_write(9, 0, serial); 736 } 737 738 /* Setup termios */ 739 if (tty) 740 pl2303_set_termios(tty, port, &tmp_termios); 741 742 /* FIXME: need to assert RTS and DTR if CRTSCTS off */ 743 744 dbg("%s - submitting read urb", __func__); 745 port->read_urb->dev = serial->dev; 746 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 747 if (result) { 748 dev_err(&port->dev, "%s - failed submitting read urb," 749 " error %d\n", __func__, result); 750 pl2303_close(tty, port, NULL); 751 return -EPROTO; 752 } 753 754 dbg("%s - submitting interrupt urb", __func__); 755 port->interrupt_in_urb->dev = serial->dev; 756 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 757 if (result) { 758 dev_err(&port->dev, "%s - failed submitting interrupt urb," 759 " error %d\n", __func__, result); 760 pl2303_close(tty, port, NULL); 761 return -EPROTO; 762 } 763 return 0; 764 } 765 766 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file, 767 unsigned int set, unsigned int clear) 768 { 769 struct usb_serial_port *port = tty->driver_data; 770 struct pl2303_private *priv = usb_get_serial_port_data(port); 771 unsigned long flags; 772 u8 control; 773 774 if (!usb_get_intfdata(port->serial->interface)) 775 return -ENODEV; 776 777 spin_lock_irqsave(&priv->lock, flags); 778 if (set & TIOCM_RTS) 779 priv->line_control |= CONTROL_RTS; 780 if (set & TIOCM_DTR) 781 priv->line_control |= CONTROL_DTR; 782 if (clear & TIOCM_RTS) 783 priv->line_control &= ~CONTROL_RTS; 784 if (clear & TIOCM_DTR) 785 priv->line_control &= ~CONTROL_DTR; 786 control = priv->line_control; 787 spin_unlock_irqrestore(&priv->lock, flags); 788 789 return set_control_lines(port->serial->dev, control); 790 } 791 792 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file) 793 { 794 struct usb_serial_port *port = tty->driver_data; 795 struct pl2303_private *priv = usb_get_serial_port_data(port); 796 unsigned long flags; 797 unsigned int mcr; 798 unsigned int status; 799 unsigned int result; 800 801 dbg("%s (%d)", __func__, port->number); 802 803 if (!usb_get_intfdata(port->serial->interface)) 804 return -ENODEV; 805 806 spin_lock_irqsave(&priv->lock, flags); 807 mcr = priv->line_control; 808 status = priv->line_status; 809 spin_unlock_irqrestore(&priv->lock, flags); 810 811 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 812 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 813 | ((status & UART_CTS) ? TIOCM_CTS : 0) 814 | ((status & UART_DSR) ? TIOCM_DSR : 0) 815 | ((status & UART_RING) ? TIOCM_RI : 0) 816 | ((status & UART_DCD) ? TIOCM_CD : 0); 817 818 dbg("%s - result = %x", __func__, result); 819 820 return result; 821 } 822 823 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 824 { 825 struct pl2303_private *priv = usb_get_serial_port_data(port); 826 unsigned long flags; 827 unsigned int prevstatus; 828 unsigned int status; 829 unsigned int changed; 830 831 spin_lock_irqsave(&priv->lock, flags); 832 prevstatus = priv->line_status; 833 spin_unlock_irqrestore(&priv->lock, flags); 834 835 while (1) { 836 interruptible_sleep_on(&priv->delta_msr_wait); 837 /* see if a signal did it */ 838 if (signal_pending(current)) 839 return -ERESTARTSYS; 840 841 spin_lock_irqsave(&priv->lock, flags); 842 status = priv->line_status; 843 spin_unlock_irqrestore(&priv->lock, flags); 844 845 changed = prevstatus ^ status; 846 847 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 848 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 849 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 850 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 851 return 0; 852 } 853 prevstatus = status; 854 } 855 /* NOTREACHED */ 856 return 0; 857 } 858 859 static int pl2303_ioctl(struct tty_struct *tty, struct file *file, 860 unsigned int cmd, unsigned long arg) 861 { 862 struct usb_serial_port *port = tty->driver_data; 863 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 864 865 switch (cmd) { 866 case TIOCMIWAIT: 867 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 868 return wait_modem_info(port, arg); 869 default: 870 dbg("%s not supported = 0x%04x", __func__, cmd); 871 break; 872 } 873 return -ENOIOCTLCMD; 874 } 875 876 static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 877 { 878 struct usb_serial_port *port = tty->driver_data; 879 struct usb_serial *serial = port->serial; 880 u16 state; 881 int result; 882 883 dbg("%s - port %d", __func__, port->number); 884 885 if (break_state == 0) 886 state = BREAK_OFF; 887 else 888 state = BREAK_ON; 889 dbg("%s - turning break %s", __func__, 890 state == BREAK_OFF ? "off" : "on"); 891 892 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 893 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 894 0, NULL, 0, 100); 895 if (result) 896 dbg("%s - error sending break = %d", __func__, result); 897 } 898 899 static void pl2303_shutdown(struct usb_serial *serial) 900 { 901 int i; 902 struct pl2303_private *priv; 903 904 dbg("%s", __func__); 905 906 for (i = 0; i < serial->num_ports; ++i) { 907 priv = usb_get_serial_port_data(serial->port[i]); 908 if (priv) { 909 pl2303_buf_free(priv->buf); 910 kfree(priv); 911 usb_set_serial_port_data(serial->port[i], NULL); 912 } 913 } 914 } 915 916 static void pl2303_update_line_status(struct usb_serial_port *port, 917 unsigned char *data, 918 unsigned int actual_length) 919 { 920 921 struct pl2303_private *priv = usb_get_serial_port_data(port); 922 unsigned long flags; 923 u8 status_idx = UART_STATE; 924 u8 length = UART_STATE + 1; 925 u16 idv, idp; 926 927 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 928 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 929 930 931 if (idv == SIEMENS_VENDOR_ID) { 932 if (idp == SIEMENS_PRODUCT_ID_X65 || 933 idp == SIEMENS_PRODUCT_ID_SX1 || 934 idp == SIEMENS_PRODUCT_ID_X75) { 935 936 length = 1; 937 status_idx = 0; 938 } 939 } 940 941 if (actual_length < length) 942 return; 943 944 /* Save off the uart status for others to look at */ 945 spin_lock_irqsave(&priv->lock, flags); 946 priv->line_status = data[status_idx]; 947 spin_unlock_irqrestore(&priv->lock, flags); 948 wake_up_interruptible(&priv->delta_msr_wait); 949 } 950 951 static void pl2303_read_int_callback(struct urb *urb) 952 { 953 struct usb_serial_port *port = urb->context; 954 unsigned char *data = urb->transfer_buffer; 955 unsigned int actual_length = urb->actual_length; 956 int status = urb->status; 957 int retval; 958 959 dbg("%s (%d)", __func__, port->number); 960 961 switch (status) { 962 case 0: 963 /* success */ 964 break; 965 case -ECONNRESET: 966 case -ENOENT: 967 case -ESHUTDOWN: 968 /* this urb is terminated, clean up */ 969 dbg("%s - urb shutting down with status: %d", __func__, 970 status); 971 return; 972 default: 973 dbg("%s - nonzero urb status received: %d", __func__, 974 status); 975 goto exit; 976 } 977 978 usb_serial_debug_data(debug, &port->dev, __func__, 979 urb->actual_length, urb->transfer_buffer); 980 981 pl2303_update_line_status(port, data, actual_length); 982 983 exit: 984 retval = usb_submit_urb(urb, GFP_ATOMIC); 985 if (retval) 986 dev_err(&urb->dev->dev, 987 "%s - usb_submit_urb failed with result %d\n", 988 __func__, retval); 989 } 990 991 static void pl2303_read_bulk_callback(struct urb *urb) 992 { 993 struct usb_serial_port *port = urb->context; 994 struct pl2303_private *priv = usb_get_serial_port_data(port); 995 struct tty_struct *tty; 996 unsigned char *data = urb->transfer_buffer; 997 unsigned long flags; 998 int i; 999 int result; 1000 int status = urb->status; 1001 u8 line_status; 1002 char tty_flag; 1003 1004 dbg("%s - port %d", __func__, port->number); 1005 1006 if (status) { 1007 dbg("%s - urb status = %d", __func__, status); 1008 if (!port->port.count) { 1009 dbg("%s - port is closed, exiting.", __func__); 1010 return; 1011 } 1012 if (status == -EPROTO) { 1013 /* PL2303 mysteriously fails with -EPROTO reschedule 1014 * the read */ 1015 dbg("%s - caught -EPROTO, resubmitting the urb", 1016 __func__); 1017 urb->dev = port->serial->dev; 1018 result = usb_submit_urb(urb, GFP_ATOMIC); 1019 if (result) 1020 dev_err(&urb->dev->dev, "%s - failed" 1021 " resubmitting read urb, error %d\n", 1022 __func__, result); 1023 return; 1024 } 1025 dbg("%s - unable to handle the error, exiting.", __func__); 1026 return; 1027 } 1028 1029 usb_serial_debug_data(debug, &port->dev, __func__, 1030 urb->actual_length, data); 1031 1032 /* get tty_flag from status */ 1033 tty_flag = TTY_NORMAL; 1034 1035 spin_lock_irqsave(&priv->lock, flags); 1036 line_status = priv->line_status; 1037 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 1038 spin_unlock_irqrestore(&priv->lock, flags); 1039 wake_up_interruptible(&priv->delta_msr_wait); 1040 1041 /* break takes precedence over parity, */ 1042 /* which takes precedence over framing errors */ 1043 if (line_status & UART_BREAK_ERROR) 1044 tty_flag = TTY_BREAK; 1045 else if (line_status & UART_PARITY_ERROR) 1046 tty_flag = TTY_PARITY; 1047 else if (line_status & UART_FRAME_ERROR) 1048 tty_flag = TTY_FRAME; 1049 dbg("%s - tty_flag = %d", __func__, tty_flag); 1050 1051 tty = tty_port_tty_get(&port->port); 1052 if (tty && urb->actual_length) { 1053 tty_buffer_request_room(tty, urb->actual_length + 1); 1054 /* overrun is special, not associated with a char */ 1055 if (line_status & UART_OVERRUN_ERROR) 1056 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 1057 for (i = 0; i < urb->actual_length; ++i) 1058 tty_insert_flip_char(tty, data[i], tty_flag); 1059 tty_flip_buffer_push(tty); 1060 } 1061 tty_kref_put(tty); 1062 /* Schedule the next read _if_ we are still open */ 1063 if (port->port.count) { 1064 urb->dev = port->serial->dev; 1065 result = usb_submit_urb(urb, GFP_ATOMIC); 1066 if (result) 1067 dev_err(&urb->dev->dev, "%s - failed resubmitting" 1068 " read urb, error %d\n", __func__, result); 1069 } 1070 1071 return; 1072 } 1073 1074 static void pl2303_write_bulk_callback(struct urb *urb) 1075 { 1076 struct usb_serial_port *port = urb->context; 1077 struct pl2303_private *priv = usb_get_serial_port_data(port); 1078 int result; 1079 int status = urb->status; 1080 1081 dbg("%s - port %d", __func__, port->number); 1082 1083 switch (status) { 1084 case 0: 1085 /* success */ 1086 break; 1087 case -ECONNRESET: 1088 case -ENOENT: 1089 case -ESHUTDOWN: 1090 /* this urb is terminated, clean up */ 1091 dbg("%s - urb shutting down with status: %d", __func__, 1092 status); 1093 priv->write_urb_in_use = 0; 1094 return; 1095 default: 1096 /* error in the urb, so we have to resubmit it */ 1097 dbg("%s - Overflow in write", __func__); 1098 dbg("%s - nonzero write bulk status received: %d", __func__, 1099 status); 1100 port->write_urb->transfer_buffer_length = 1; 1101 port->write_urb->dev = port->serial->dev; 1102 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1103 if (result) 1104 dev_err(&urb->dev->dev, "%s - failed resubmitting write" 1105 " urb, error %d\n", __func__, result); 1106 else 1107 return; 1108 } 1109 1110 priv->write_urb_in_use = 0; 1111 1112 /* send any buffered data */ 1113 pl2303_send(port); 1114 } 1115 1116 /* All of the device info needed for the PL2303 SIO serial converter */ 1117 static struct usb_serial_driver pl2303_device = { 1118 .driver = { 1119 .owner = THIS_MODULE, 1120 .name = "pl2303", 1121 }, 1122 .id_table = id_table, 1123 .usb_driver = &pl2303_driver, 1124 .num_ports = 1, 1125 .open = pl2303_open, 1126 .close = pl2303_close, 1127 .write = pl2303_write, 1128 .ioctl = pl2303_ioctl, 1129 .break_ctl = pl2303_break_ctl, 1130 .set_termios = pl2303_set_termios, 1131 .tiocmget = pl2303_tiocmget, 1132 .tiocmset = pl2303_tiocmset, 1133 .read_bulk_callback = pl2303_read_bulk_callback, 1134 .read_int_callback = pl2303_read_int_callback, 1135 .write_bulk_callback = pl2303_write_bulk_callback, 1136 .write_room = pl2303_write_room, 1137 .chars_in_buffer = pl2303_chars_in_buffer, 1138 .attach = pl2303_startup, 1139 .shutdown = pl2303_shutdown, 1140 }; 1141 1142 static int __init pl2303_init(void) 1143 { 1144 int retval; 1145 1146 retval = usb_serial_register(&pl2303_device); 1147 if (retval) 1148 goto failed_usb_serial_register; 1149 retval = usb_register(&pl2303_driver); 1150 if (retval) 1151 goto failed_usb_register; 1152 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1153 return 0; 1154 failed_usb_register: 1155 usb_serial_deregister(&pl2303_device); 1156 failed_usb_serial_register: 1157 return retval; 1158 } 1159 1160 static void __exit pl2303_exit(void) 1161 { 1162 usb_deregister(&pl2303_driver); 1163 usb_serial_deregister(&pl2303_device); 1164 } 1165 1166 module_init(pl2303_init); 1167 module_exit(pl2303_exit); 1168 1169 MODULE_DESCRIPTION(DRIVER_DESC); 1170 MODULE_LICENSE("GPL"); 1171 1172 module_param(debug, bool, S_IRUGO | S_IWUSR); 1173 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1174 1175