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