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