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_dtr_rts(struct usb_serial_port *port, int on) 656 { 657 struct pl2303_private *priv = usb_get_serial_port_data(port); 658 unsigned long flags; 659 u8 control; 660 661 spin_lock_irqsave(&priv->lock, flags); 662 /* Change DTR and RTS */ 663 if (on) 664 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 665 else 666 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 667 control = priv->line_control; 668 spin_unlock_irqrestore(&priv->lock, flags); 669 set_control_lines(port->serial->dev, control); 670 } 671 672 static void pl2303_close(struct usb_serial_port *port) 673 { 674 struct pl2303_private *priv = usb_get_serial_port_data(port); 675 unsigned long flags; 676 677 dbg("%s - port %d", __func__, port->number); 678 679 spin_lock_irqsave(&priv->lock, flags); 680 /* clear out any remaining data in the buffer */ 681 pl2303_buf_clear(priv->buf); 682 spin_unlock_irqrestore(&priv->lock, flags); 683 684 /* shutdown our urbs */ 685 dbg("%s - shutting down urbs", __func__); 686 usb_kill_urb(port->write_urb); 687 usb_kill_urb(port->read_urb); 688 usb_kill_urb(port->interrupt_in_urb); 689 690 } 691 692 static int pl2303_open(struct tty_struct *tty, 693 struct usb_serial_port *port, struct file *filp) 694 { 695 struct ktermios tmp_termios; 696 struct usb_serial *serial = port->serial; 697 struct pl2303_private *priv = usb_get_serial_port_data(port); 698 int result; 699 700 dbg("%s - port %d", __func__, port->number); 701 702 if (priv->type != HX) { 703 usb_clear_halt(serial->dev, port->write_urb->pipe); 704 usb_clear_halt(serial->dev, port->read_urb->pipe); 705 } else { 706 /* reset upstream data pipes */ 707 pl2303_vendor_write(8, 0, serial); 708 pl2303_vendor_write(9, 0, serial); 709 } 710 711 /* Setup termios */ 712 if (tty) 713 pl2303_set_termios(tty, port, &tmp_termios); 714 715 /* FIXME: need to assert RTS and DTR if CRTSCTS off */ 716 717 dbg("%s - submitting read urb", __func__); 718 port->read_urb->dev = serial->dev; 719 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 720 if (result) { 721 dev_err(&port->dev, "%s - failed submitting read urb," 722 " error %d\n", __func__, result); 723 pl2303_close(port); 724 return -EPROTO; 725 } 726 727 dbg("%s - submitting interrupt urb", __func__); 728 port->interrupt_in_urb->dev = serial->dev; 729 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 730 if (result) { 731 dev_err(&port->dev, "%s - failed submitting interrupt urb," 732 " error %d\n", __func__, result); 733 pl2303_close(port); 734 return -EPROTO; 735 } 736 port->port.drain_delay = 256; 737 return 0; 738 } 739 740 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file, 741 unsigned int set, unsigned int clear) 742 { 743 struct usb_serial_port *port = tty->driver_data; 744 struct pl2303_private *priv = usb_get_serial_port_data(port); 745 unsigned long flags; 746 u8 control; 747 748 if (!usb_get_intfdata(port->serial->interface)) 749 return -ENODEV; 750 751 spin_lock_irqsave(&priv->lock, flags); 752 if (set & TIOCM_RTS) 753 priv->line_control |= CONTROL_RTS; 754 if (set & TIOCM_DTR) 755 priv->line_control |= CONTROL_DTR; 756 if (clear & TIOCM_RTS) 757 priv->line_control &= ~CONTROL_RTS; 758 if (clear & TIOCM_DTR) 759 priv->line_control &= ~CONTROL_DTR; 760 control = priv->line_control; 761 spin_unlock_irqrestore(&priv->lock, flags); 762 763 return set_control_lines(port->serial->dev, control); 764 } 765 766 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file) 767 { 768 struct usb_serial_port *port = tty->driver_data; 769 struct pl2303_private *priv = usb_get_serial_port_data(port); 770 unsigned long flags; 771 unsigned int mcr; 772 unsigned int status; 773 unsigned int result; 774 775 dbg("%s (%d)", __func__, port->number); 776 777 if (!usb_get_intfdata(port->serial->interface)) 778 return -ENODEV; 779 780 spin_lock_irqsave(&priv->lock, flags); 781 mcr = priv->line_control; 782 status = priv->line_status; 783 spin_unlock_irqrestore(&priv->lock, flags); 784 785 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 786 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 787 | ((status & UART_CTS) ? TIOCM_CTS : 0) 788 | ((status & UART_DSR) ? TIOCM_DSR : 0) 789 | ((status & UART_RING) ? TIOCM_RI : 0) 790 | ((status & UART_DCD) ? TIOCM_CD : 0); 791 792 dbg("%s - result = %x", __func__, result); 793 794 return result; 795 } 796 797 static int pl2303_carrier_raised(struct usb_serial_port *port) 798 { 799 struct pl2303_private *priv = usb_get_serial_port_data(port); 800 if (priv->line_status & UART_DCD) 801 return 1; 802 return 0; 803 } 804 805 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 806 { 807 struct pl2303_private *priv = usb_get_serial_port_data(port); 808 unsigned long flags; 809 unsigned int prevstatus; 810 unsigned int status; 811 unsigned int changed; 812 813 spin_lock_irqsave(&priv->lock, flags); 814 prevstatus = priv->line_status; 815 spin_unlock_irqrestore(&priv->lock, flags); 816 817 while (1) { 818 interruptible_sleep_on(&priv->delta_msr_wait); 819 /* see if a signal did it */ 820 if (signal_pending(current)) 821 return -ERESTARTSYS; 822 823 spin_lock_irqsave(&priv->lock, flags); 824 status = priv->line_status; 825 spin_unlock_irqrestore(&priv->lock, flags); 826 827 changed = prevstatus ^ status; 828 829 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 830 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 831 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 832 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 833 return 0; 834 } 835 prevstatus = status; 836 } 837 /* NOTREACHED */ 838 return 0; 839 } 840 841 static int pl2303_ioctl(struct tty_struct *tty, struct file *file, 842 unsigned int cmd, unsigned long arg) 843 { 844 struct usb_serial_port *port = tty->driver_data; 845 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 846 847 switch (cmd) { 848 case TIOCMIWAIT: 849 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 850 return wait_modem_info(port, arg); 851 default: 852 dbg("%s not supported = 0x%04x", __func__, cmd); 853 break; 854 } 855 return -ENOIOCTLCMD; 856 } 857 858 static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 859 { 860 struct usb_serial_port *port = tty->driver_data; 861 struct usb_serial *serial = port->serial; 862 u16 state; 863 int result; 864 865 dbg("%s - port %d", __func__, port->number); 866 867 if (break_state == 0) 868 state = BREAK_OFF; 869 else 870 state = BREAK_ON; 871 dbg("%s - turning break %s", __func__, 872 state == BREAK_OFF ? "off" : "on"); 873 874 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 875 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 876 0, NULL, 0, 100); 877 if (result) 878 dbg("%s - error sending break = %d", __func__, result); 879 } 880 881 static void pl2303_shutdown(struct usb_serial *serial) 882 { 883 int i; 884 struct pl2303_private *priv; 885 886 dbg("%s", __func__); 887 888 for (i = 0; i < serial->num_ports; ++i) { 889 priv = usb_get_serial_port_data(serial->port[i]); 890 if (priv) { 891 pl2303_buf_free(priv->buf); 892 kfree(priv); 893 usb_set_serial_port_data(serial->port[i], NULL); 894 } 895 } 896 } 897 898 static void pl2303_update_line_status(struct usb_serial_port *port, 899 unsigned char *data, 900 unsigned int actual_length) 901 { 902 903 struct pl2303_private *priv = usb_get_serial_port_data(port); 904 unsigned long flags; 905 u8 status_idx = UART_STATE; 906 u8 length = UART_STATE + 1; 907 u16 idv, idp; 908 909 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 910 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 911 912 913 if (idv == SIEMENS_VENDOR_ID) { 914 if (idp == SIEMENS_PRODUCT_ID_X65 || 915 idp == SIEMENS_PRODUCT_ID_SX1 || 916 idp == SIEMENS_PRODUCT_ID_X75) { 917 918 length = 1; 919 status_idx = 0; 920 } 921 } 922 923 if (actual_length < length) 924 return; 925 926 /* Save off the uart status for others to look at */ 927 spin_lock_irqsave(&priv->lock, flags); 928 priv->line_status = data[status_idx]; 929 spin_unlock_irqrestore(&priv->lock, flags); 930 wake_up_interruptible(&priv->delta_msr_wait); 931 } 932 933 static void pl2303_read_int_callback(struct urb *urb) 934 { 935 struct usb_serial_port *port = urb->context; 936 unsigned char *data = urb->transfer_buffer; 937 unsigned int actual_length = urb->actual_length; 938 int status = urb->status; 939 int retval; 940 941 dbg("%s (%d)", __func__, port->number); 942 943 switch (status) { 944 case 0: 945 /* success */ 946 break; 947 case -ECONNRESET: 948 case -ENOENT: 949 case -ESHUTDOWN: 950 /* this urb is terminated, clean up */ 951 dbg("%s - urb shutting down with status: %d", __func__, 952 status); 953 return; 954 default: 955 dbg("%s - nonzero urb status received: %d", __func__, 956 status); 957 goto exit; 958 } 959 960 usb_serial_debug_data(debug, &port->dev, __func__, 961 urb->actual_length, urb->transfer_buffer); 962 963 pl2303_update_line_status(port, data, actual_length); 964 965 exit: 966 retval = usb_submit_urb(urb, GFP_ATOMIC); 967 if (retval) 968 dev_err(&urb->dev->dev, 969 "%s - usb_submit_urb failed with result %d\n", 970 __func__, retval); 971 } 972 973 static void pl2303_read_bulk_callback(struct urb *urb) 974 { 975 struct usb_serial_port *port = urb->context; 976 struct pl2303_private *priv = usb_get_serial_port_data(port); 977 struct tty_struct *tty; 978 unsigned char *data = urb->transfer_buffer; 979 unsigned long flags; 980 int i; 981 int result; 982 int status = urb->status; 983 u8 line_status; 984 char tty_flag; 985 986 dbg("%s - port %d", __func__, port->number); 987 988 if (status) { 989 dbg("%s - urb status = %d", __func__, status); 990 if (!port->port.count) { 991 dbg("%s - port is closed, exiting.", __func__); 992 return; 993 } 994 if (status == -EPROTO) { 995 /* PL2303 mysteriously fails with -EPROTO reschedule 996 * the read */ 997 dbg("%s - caught -EPROTO, resubmitting the urb", 998 __func__); 999 urb->dev = port->serial->dev; 1000 result = usb_submit_urb(urb, GFP_ATOMIC); 1001 if (result) 1002 dev_err(&urb->dev->dev, "%s - failed" 1003 " resubmitting read urb, error %d\n", 1004 __func__, result); 1005 return; 1006 } 1007 dbg("%s - unable to handle the error, exiting.", __func__); 1008 return; 1009 } 1010 1011 usb_serial_debug_data(debug, &port->dev, __func__, 1012 urb->actual_length, data); 1013 1014 /* get tty_flag from status */ 1015 tty_flag = TTY_NORMAL; 1016 1017 spin_lock_irqsave(&priv->lock, flags); 1018 line_status = priv->line_status; 1019 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 1020 spin_unlock_irqrestore(&priv->lock, flags); 1021 wake_up_interruptible(&priv->delta_msr_wait); 1022 1023 /* break takes precedence over parity, */ 1024 /* which takes precedence over framing errors */ 1025 if (line_status & UART_BREAK_ERROR) 1026 tty_flag = TTY_BREAK; 1027 else if (line_status & UART_PARITY_ERROR) 1028 tty_flag = TTY_PARITY; 1029 else if (line_status & UART_FRAME_ERROR) 1030 tty_flag = TTY_FRAME; 1031 dbg("%s - tty_flag = %d", __func__, tty_flag); 1032 1033 tty = tty_port_tty_get(&port->port); 1034 if (tty && urb->actual_length) { 1035 tty_buffer_request_room(tty, urb->actual_length + 1); 1036 /* overrun is special, not associated with a char */ 1037 if (line_status & UART_OVERRUN_ERROR) 1038 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 1039 for (i = 0; i < urb->actual_length; ++i) 1040 tty_insert_flip_char(tty, data[i], tty_flag); 1041 tty_flip_buffer_push(tty); 1042 } 1043 tty_kref_put(tty); 1044 /* Schedule the next read _if_ we are still open */ 1045 if (port->port.count) { 1046 urb->dev = port->serial->dev; 1047 result = usb_submit_urb(urb, GFP_ATOMIC); 1048 if (result) 1049 dev_err(&urb->dev->dev, "%s - failed resubmitting" 1050 " read urb, error %d\n", __func__, result); 1051 } 1052 1053 return; 1054 } 1055 1056 static void pl2303_write_bulk_callback(struct urb *urb) 1057 { 1058 struct usb_serial_port *port = urb->context; 1059 struct pl2303_private *priv = usb_get_serial_port_data(port); 1060 int result; 1061 int status = urb->status; 1062 1063 dbg("%s - port %d", __func__, port->number); 1064 1065 switch (status) { 1066 case 0: 1067 /* success */ 1068 break; 1069 case -ECONNRESET: 1070 case -ENOENT: 1071 case -ESHUTDOWN: 1072 /* this urb is terminated, clean up */ 1073 dbg("%s - urb shutting down with status: %d", __func__, 1074 status); 1075 priv->write_urb_in_use = 0; 1076 return; 1077 default: 1078 /* error in the urb, so we have to resubmit it */ 1079 dbg("%s - Overflow in write", __func__); 1080 dbg("%s - nonzero write bulk status received: %d", __func__, 1081 status); 1082 port->write_urb->transfer_buffer_length = 1; 1083 port->write_urb->dev = port->serial->dev; 1084 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1085 if (result) 1086 dev_err(&urb->dev->dev, "%s - failed resubmitting write" 1087 " urb, error %d\n", __func__, result); 1088 else 1089 return; 1090 } 1091 1092 priv->write_urb_in_use = 0; 1093 1094 /* send any buffered data */ 1095 pl2303_send(port); 1096 } 1097 1098 /* All of the device info needed for the PL2303 SIO serial converter */ 1099 static struct usb_serial_driver pl2303_device = { 1100 .driver = { 1101 .owner = THIS_MODULE, 1102 .name = "pl2303", 1103 }, 1104 .id_table = id_table, 1105 .usb_driver = &pl2303_driver, 1106 .num_ports = 1, 1107 .open = pl2303_open, 1108 .close = pl2303_close, 1109 .dtr_rts = pl2303_dtr_rts, 1110 .carrier_raised = pl2303_carrier_raised, 1111 .write = pl2303_write, 1112 .ioctl = pl2303_ioctl, 1113 .break_ctl = pl2303_break_ctl, 1114 .set_termios = pl2303_set_termios, 1115 .tiocmget = pl2303_tiocmget, 1116 .tiocmset = pl2303_tiocmset, 1117 .read_bulk_callback = pl2303_read_bulk_callback, 1118 .read_int_callback = pl2303_read_int_callback, 1119 .write_bulk_callback = pl2303_write_bulk_callback, 1120 .write_room = pl2303_write_room, 1121 .chars_in_buffer = pl2303_chars_in_buffer, 1122 .attach = pl2303_startup, 1123 .shutdown = pl2303_shutdown, 1124 }; 1125 1126 static int __init pl2303_init(void) 1127 { 1128 int retval; 1129 1130 retval = usb_serial_register(&pl2303_device); 1131 if (retval) 1132 goto failed_usb_serial_register; 1133 retval = usb_register(&pl2303_driver); 1134 if (retval) 1135 goto failed_usb_register; 1136 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1137 return 0; 1138 failed_usb_register: 1139 usb_serial_deregister(&pl2303_device); 1140 failed_usb_serial_register: 1141 return retval; 1142 } 1143 1144 static void __exit pl2303_exit(void) 1145 { 1146 usb_deregister(&pl2303_driver); 1147 usb_serial_deregister(&pl2303_device); 1148 } 1149 1150 module_init(pl2303_init); 1151 module_exit(pl2303_exit); 1152 1153 MODULE_DESCRIPTION(DRIVER_DESC); 1154 MODULE_LICENSE("GPL"); 1155 1156 module_param(debug, bool, S_IRUGO | S_IWUSR); 1157 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1158 1159