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