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 static const struct usb_device_id id_table[] = { 44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) }, 45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) }, 46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) }, 47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) }, 48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) }, 49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) }, 50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) }, 51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) }, 52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) }, 53 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) }, 54 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) }, 55 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) }, 56 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) }, 57 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) }, 58 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) }, 59 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) }, 60 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) }, 61 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) }, 62 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) }, 63 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) }, 64 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) }, 65 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) }, 66 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) }, 67 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) }, 68 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) }, 69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) }, 70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) }, 71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) }, 72 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) }, 73 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */ 74 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) }, 75 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) }, 76 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) }, 77 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) }, 78 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) }, 79 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) }, 80 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) }, 81 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) }, 82 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) }, 83 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) }, 84 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) }, 85 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) }, 86 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) }, 87 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) }, 88 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) }, 89 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) }, 90 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) }, 91 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) }, 92 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) }, 93 { } /* Terminating entry */ 94 }; 95 96 MODULE_DEVICE_TABLE(usb, id_table); 97 98 static struct usb_driver pl2303_driver = { 99 .name = "pl2303", 100 .probe = usb_serial_probe, 101 .disconnect = usb_serial_disconnect, 102 .id_table = id_table, 103 .suspend = usb_serial_suspend, 104 .resume = usb_serial_resume, 105 .no_dynamic_id = 1, 106 .supports_autosuspend = 1, 107 }; 108 109 #define SET_LINE_REQUEST_TYPE 0x21 110 #define SET_LINE_REQUEST 0x20 111 112 #define SET_CONTROL_REQUEST_TYPE 0x21 113 #define SET_CONTROL_REQUEST 0x22 114 #define CONTROL_DTR 0x01 115 #define CONTROL_RTS 0x02 116 117 #define BREAK_REQUEST_TYPE 0x21 118 #define BREAK_REQUEST 0x23 119 #define BREAK_ON 0xffff 120 #define BREAK_OFF 0x0000 121 122 #define GET_LINE_REQUEST_TYPE 0xa1 123 #define GET_LINE_REQUEST 0x21 124 125 #define VENDOR_WRITE_REQUEST_TYPE 0x40 126 #define VENDOR_WRITE_REQUEST 0x01 127 128 #define VENDOR_READ_REQUEST_TYPE 0xc0 129 #define VENDOR_READ_REQUEST 0x01 130 131 #define UART_STATE 0x08 132 #define UART_STATE_TRANSIENT_MASK 0x74 133 #define UART_DCD 0x01 134 #define UART_DSR 0x02 135 #define UART_BREAK_ERROR 0x04 136 #define UART_RING 0x08 137 #define UART_FRAME_ERROR 0x10 138 #define UART_PARITY_ERROR 0x20 139 #define UART_OVERRUN_ERROR 0x40 140 #define UART_CTS 0x80 141 142 143 enum pl2303_type { 144 type_0, /* don't know the difference between type 0 and */ 145 type_1, /* type 1, until someone from prolific tells us... */ 146 HX, /* HX version of the pl2303 chip */ 147 }; 148 149 struct pl2303_private { 150 spinlock_t lock; 151 wait_queue_head_t delta_msr_wait; 152 u8 line_control; 153 u8 line_status; 154 enum pl2303_type type; 155 }; 156 157 static int pl2303_vendor_read(__u16 value, __u16 index, 158 struct usb_serial *serial, unsigned char *buf) 159 { 160 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 161 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE, 162 value, index, buf, 1, 100); 163 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE, 164 VENDOR_READ_REQUEST, value, index, res, buf[0]); 165 return res; 166 } 167 168 static int pl2303_vendor_write(__u16 value, __u16 index, 169 struct usb_serial *serial) 170 { 171 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 172 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE, 173 value, index, NULL, 0, 100); 174 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE, 175 VENDOR_WRITE_REQUEST, value, index, res); 176 return res; 177 } 178 179 static int pl2303_startup(struct usb_serial *serial) 180 { 181 struct pl2303_private *priv; 182 enum pl2303_type type = type_0; 183 unsigned char *buf; 184 int i; 185 186 buf = kmalloc(10, GFP_KERNEL); 187 if (buf == NULL) 188 return -ENOMEM; 189 190 if (serial->dev->descriptor.bDeviceClass == 0x02) 191 type = type_0; 192 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40) 193 type = HX; 194 else if (serial->dev->descriptor.bDeviceClass == 0x00) 195 type = type_1; 196 else if (serial->dev->descriptor.bDeviceClass == 0xFF) 197 type = type_1; 198 dbg("device type: %d", type); 199 200 for (i = 0; i < serial->num_ports; ++i) { 201 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL); 202 if (!priv) 203 goto cleanup; 204 spin_lock_init(&priv->lock); 205 init_waitqueue_head(&priv->delta_msr_wait); 206 priv->type = type; 207 usb_set_serial_port_data(serial->port[i], priv); 208 } 209 210 pl2303_vendor_read(0x8484, 0, serial, buf); 211 pl2303_vendor_write(0x0404, 0, serial); 212 pl2303_vendor_read(0x8484, 0, serial, buf); 213 pl2303_vendor_read(0x8383, 0, serial, buf); 214 pl2303_vendor_read(0x8484, 0, serial, buf); 215 pl2303_vendor_write(0x0404, 1, serial); 216 pl2303_vendor_read(0x8484, 0, serial, buf); 217 pl2303_vendor_read(0x8383, 0, serial, buf); 218 pl2303_vendor_write(0, 1, serial); 219 pl2303_vendor_write(1, 0, serial); 220 if (type == HX) 221 pl2303_vendor_write(2, 0x44, serial); 222 else 223 pl2303_vendor_write(2, 0x24, serial); 224 225 kfree(buf); 226 return 0; 227 228 cleanup: 229 kfree(buf); 230 for (--i; i >= 0; --i) { 231 priv = usb_get_serial_port_data(serial->port[i]); 232 kfree(priv); 233 usb_set_serial_port_data(serial->port[i], NULL); 234 } 235 return -ENOMEM; 236 } 237 238 static int set_control_lines(struct usb_device *dev, u8 value) 239 { 240 int retval; 241 242 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 243 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE, 244 value, 0, NULL, 0, 100); 245 dbg("%s - value = %d, retval = %d", __func__, value, retval); 246 return retval; 247 } 248 249 static void pl2303_set_termios(struct tty_struct *tty, 250 struct usb_serial_port *port, struct ktermios *old_termios) 251 { 252 struct usb_serial *serial = port->serial; 253 struct pl2303_private *priv = usb_get_serial_port_data(port); 254 unsigned long flags; 255 unsigned int cflag; 256 unsigned char *buf; 257 int baud; 258 int i; 259 u8 control; 260 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600, 261 4800, 7200, 9600, 14400, 19200, 28800, 38400, 262 57600, 115200, 230400, 460800, 614400, 263 921600, 1228800, 2457600, 3000000, 6000000 }; 264 int baud_floor, baud_ceil; 265 int k; 266 267 dbg("%s - port %d", __func__, port->number); 268 269 /* The PL2303 is reported to lose bytes if you change 270 serial settings even to the same values as before. Thus 271 we actually need to filter in this specific case */ 272 273 if (!tty_termios_hw_change(tty->termios, old_termios)) 274 return; 275 276 cflag = tty->termios->c_cflag; 277 278 buf = kzalloc(7, GFP_KERNEL); 279 if (!buf) { 280 dev_err(&port->dev, "%s - out of memory.\n", __func__); 281 /* Report back no change occurred */ 282 *tty->termios = *old_termios; 283 return; 284 } 285 286 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 287 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 288 0, 0, buf, 7, 100); 289 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 290 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 291 292 if (cflag & CSIZE) { 293 switch (cflag & CSIZE) { 294 case CS5: 295 buf[6] = 5; 296 break; 297 case CS6: 298 buf[6] = 6; 299 break; 300 case CS7: 301 buf[6] = 7; 302 break; 303 default: 304 case CS8: 305 buf[6] = 8; 306 break; 307 } 308 dbg("%s - data bits = %d", __func__, buf[6]); 309 } 310 311 /* For reference buf[0]:buf[3] baud rate value */ 312 /* NOTE: Only the values defined in baud_sup are supported ! 313 * => if unsupported values are set, the PL2303 seems to use 314 * 9600 baud (at least my PL2303X always does) 315 */ 316 baud = tty_get_baud_rate(tty); 317 dbg("%s - baud requested = %d", __func__, baud); 318 if (baud) { 319 /* Set baudrate to nearest supported value */ 320 for (k=0; k<ARRAY_SIZE(baud_sup); k++) { 321 if (baud_sup[k] / baud) { 322 baud_ceil = baud_sup[k]; 323 if (k==0) { 324 baud = baud_ceil; 325 } else { 326 baud_floor = baud_sup[k-1]; 327 if ((baud_ceil % baud) 328 > (baud % baud_floor)) 329 baud = baud_floor; 330 else 331 baud = baud_ceil; 332 } 333 break; 334 } 335 } 336 if (baud > 1228800) { 337 /* type_0, type_1 only support up to 1228800 baud */ 338 if (priv->type != HX) 339 baud = 1228800; 340 else if (baud > 6000000) 341 baud = 6000000; 342 } 343 dbg("%s - baud set = %d", __func__, baud); 344 buf[0] = baud & 0xff; 345 buf[1] = (baud >> 8) & 0xff; 346 buf[2] = (baud >> 16) & 0xff; 347 buf[3] = (baud >> 24) & 0xff; 348 } 349 350 /* For reference buf[4]=0 is 1 stop bits */ 351 /* For reference buf[4]=1 is 1.5 stop bits */ 352 /* For reference buf[4]=2 is 2 stop bits */ 353 if (cflag & CSTOPB) { 354 /* NOTE: Comply with "real" UARTs / RS232: 355 * use 1.5 instead of 2 stop bits with 5 data bits 356 */ 357 if ((cflag & CSIZE) == CS5) { 358 buf[4] = 1; 359 dbg("%s - stop bits = 1.5", __func__); 360 } else { 361 buf[4] = 2; 362 dbg("%s - stop bits = 2", __func__); 363 } 364 } else { 365 buf[4] = 0; 366 dbg("%s - stop bits = 1", __func__); 367 } 368 369 if (cflag & PARENB) { 370 /* For reference buf[5]=0 is none parity */ 371 /* For reference buf[5]=1 is odd parity */ 372 /* For reference buf[5]=2 is even parity */ 373 /* For reference buf[5]=3 is mark parity */ 374 /* For reference buf[5]=4 is space parity */ 375 if (cflag & PARODD) { 376 if (cflag & CMSPAR) { 377 buf[5] = 3; 378 dbg("%s - parity = mark", __func__); 379 } else { 380 buf[5] = 1; 381 dbg("%s - parity = odd", __func__); 382 } 383 } else { 384 if (cflag & CMSPAR) { 385 buf[5] = 4; 386 dbg("%s - parity = space", __func__); 387 } else { 388 buf[5] = 2; 389 dbg("%s - parity = even", __func__); 390 } 391 } 392 } else { 393 buf[5] = 0; 394 dbg("%s - parity = none", __func__); 395 } 396 397 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 398 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE, 399 0, 0, buf, 7, 100); 400 dbg("0x21:0x20:0:0 %d", i); 401 402 /* change control lines if we are switching to or from B0 */ 403 spin_lock_irqsave(&priv->lock, flags); 404 control = priv->line_control; 405 if ((cflag & CBAUD) == B0) 406 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 407 else 408 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 409 if (control != priv->line_control) { 410 control = priv->line_control; 411 spin_unlock_irqrestore(&priv->lock, flags); 412 set_control_lines(serial->dev, control); 413 } else { 414 spin_unlock_irqrestore(&priv->lock, flags); 415 } 416 417 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0; 418 419 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 420 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE, 421 0, 0, buf, 7, 100); 422 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i, 423 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); 424 425 if (cflag & CRTSCTS) { 426 if (priv->type == HX) 427 pl2303_vendor_write(0x0, 0x61, serial); 428 else 429 pl2303_vendor_write(0x0, 0x41, serial); 430 } else { 431 pl2303_vendor_write(0x0, 0x0, serial); 432 } 433 434 /* Save resulting baud rate */ 435 if (baud) 436 tty_encode_baud_rate(tty, baud, baud); 437 438 kfree(buf); 439 } 440 441 static void pl2303_dtr_rts(struct usb_serial_port *port, int on) 442 { 443 struct pl2303_private *priv = usb_get_serial_port_data(port); 444 unsigned long flags; 445 u8 control; 446 447 spin_lock_irqsave(&priv->lock, flags); 448 /* Change DTR and RTS */ 449 if (on) 450 priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 451 else 452 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 453 control = priv->line_control; 454 spin_unlock_irqrestore(&priv->lock, flags); 455 set_control_lines(port->serial->dev, control); 456 } 457 458 static void pl2303_close(struct usb_serial_port *port) 459 { 460 dbg("%s - port %d", __func__, port->number); 461 462 usb_serial_generic_close(port); 463 usb_kill_urb(port->interrupt_in_urb); 464 } 465 466 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port) 467 { 468 struct ktermios tmp_termios; 469 struct usb_serial *serial = port->serial; 470 struct pl2303_private *priv = usb_get_serial_port_data(port); 471 int result; 472 473 dbg("%s - port %d", __func__, port->number); 474 475 if (priv->type != HX) { 476 usb_clear_halt(serial->dev, port->write_urb->pipe); 477 usb_clear_halt(serial->dev, port->read_urb->pipe); 478 } else { 479 /* reset upstream data pipes */ 480 pl2303_vendor_write(8, 0, serial); 481 pl2303_vendor_write(9, 0, serial); 482 } 483 484 /* Setup termios */ 485 if (tty) 486 pl2303_set_termios(tty, port, &tmp_termios); 487 488 dbg("%s - submitting read urb", __func__); 489 result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL); 490 if (result) { 491 pl2303_close(port); 492 return -EPROTO; 493 } 494 495 dbg("%s - submitting interrupt urb", __func__); 496 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 497 if (result) { 498 dev_err(&port->dev, "%s - failed submitting interrupt urb," 499 " error %d\n", __func__, result); 500 pl2303_close(port); 501 return -EPROTO; 502 } 503 port->port.drain_delay = 256; 504 return 0; 505 } 506 507 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file, 508 unsigned int set, unsigned int clear) 509 { 510 struct usb_serial_port *port = tty->driver_data; 511 struct pl2303_private *priv = usb_get_serial_port_data(port); 512 unsigned long flags; 513 u8 control; 514 515 if (!usb_get_intfdata(port->serial->interface)) 516 return -ENODEV; 517 518 spin_lock_irqsave(&priv->lock, flags); 519 if (set & TIOCM_RTS) 520 priv->line_control |= CONTROL_RTS; 521 if (set & TIOCM_DTR) 522 priv->line_control |= CONTROL_DTR; 523 if (clear & TIOCM_RTS) 524 priv->line_control &= ~CONTROL_RTS; 525 if (clear & TIOCM_DTR) 526 priv->line_control &= ~CONTROL_DTR; 527 control = priv->line_control; 528 spin_unlock_irqrestore(&priv->lock, flags); 529 530 return set_control_lines(port->serial->dev, control); 531 } 532 533 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file) 534 { 535 struct usb_serial_port *port = tty->driver_data; 536 struct pl2303_private *priv = usb_get_serial_port_data(port); 537 unsigned long flags; 538 unsigned int mcr; 539 unsigned int status; 540 unsigned int result; 541 542 dbg("%s (%d)", __func__, port->number); 543 544 if (!usb_get_intfdata(port->serial->interface)) 545 return -ENODEV; 546 547 spin_lock_irqsave(&priv->lock, flags); 548 mcr = priv->line_control; 549 status = priv->line_status; 550 spin_unlock_irqrestore(&priv->lock, flags); 551 552 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 553 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 554 | ((status & UART_CTS) ? TIOCM_CTS : 0) 555 | ((status & UART_DSR) ? TIOCM_DSR : 0) 556 | ((status & UART_RING) ? TIOCM_RI : 0) 557 | ((status & UART_DCD) ? TIOCM_CD : 0); 558 559 dbg("%s - result = %x", __func__, result); 560 561 return result; 562 } 563 564 static int pl2303_carrier_raised(struct usb_serial_port *port) 565 { 566 struct pl2303_private *priv = usb_get_serial_port_data(port); 567 if (priv->line_status & UART_DCD) 568 return 1; 569 return 0; 570 } 571 572 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 573 { 574 struct pl2303_private *priv = usb_get_serial_port_data(port); 575 unsigned long flags; 576 unsigned int prevstatus; 577 unsigned int status; 578 unsigned int changed; 579 580 spin_lock_irqsave(&priv->lock, flags); 581 prevstatus = priv->line_status; 582 spin_unlock_irqrestore(&priv->lock, flags); 583 584 while (1) { 585 interruptible_sleep_on(&priv->delta_msr_wait); 586 /* see if a signal did it */ 587 if (signal_pending(current)) 588 return -ERESTARTSYS; 589 590 spin_lock_irqsave(&priv->lock, flags); 591 status = priv->line_status; 592 spin_unlock_irqrestore(&priv->lock, flags); 593 594 changed = prevstatus ^ status; 595 596 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 597 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 598 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 599 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 600 return 0; 601 } 602 prevstatus = status; 603 } 604 /* NOTREACHED */ 605 return 0; 606 } 607 608 static int pl2303_ioctl(struct tty_struct *tty, struct file *file, 609 unsigned int cmd, unsigned long arg) 610 { 611 struct serial_struct ser; 612 struct usb_serial_port *port = tty->driver_data; 613 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 614 615 switch (cmd) { 616 case TIOCGSERIAL: 617 memset(&ser, 0, sizeof ser); 618 ser.type = PORT_16654; 619 ser.line = port->serial->minor; 620 ser.port = port->number; 621 ser.baud_base = 460800; 622 623 if (copy_to_user((void __user *)arg, &ser, sizeof ser)) 624 return -EFAULT; 625 626 return 0; 627 628 case TIOCMIWAIT: 629 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 630 return wait_modem_info(port, arg); 631 default: 632 dbg("%s not supported = 0x%04x", __func__, cmd); 633 break; 634 } 635 return -ENOIOCTLCMD; 636 } 637 638 static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 639 { 640 struct usb_serial_port *port = tty->driver_data; 641 struct usb_serial *serial = port->serial; 642 u16 state; 643 int result; 644 645 dbg("%s - port %d", __func__, port->number); 646 647 if (break_state == 0) 648 state = BREAK_OFF; 649 else 650 state = BREAK_ON; 651 dbg("%s - turning break %s", __func__, 652 state == BREAK_OFF ? "off" : "on"); 653 654 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 655 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 656 0, NULL, 0, 100); 657 if (result) 658 dbg("%s - error sending break = %d", __func__, result); 659 } 660 661 static void pl2303_release(struct usb_serial *serial) 662 { 663 int i; 664 struct pl2303_private *priv; 665 666 dbg("%s", __func__); 667 668 for (i = 0; i < serial->num_ports; ++i) { 669 priv = usb_get_serial_port_data(serial->port[i]); 670 kfree(priv); 671 } 672 } 673 674 static void pl2303_update_line_status(struct usb_serial_port *port, 675 unsigned char *data, 676 unsigned int actual_length) 677 { 678 679 struct pl2303_private *priv = usb_get_serial_port_data(port); 680 unsigned long flags; 681 u8 status_idx = UART_STATE; 682 u8 length = UART_STATE + 1; 683 u16 idv, idp; 684 685 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 686 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 687 688 689 if (idv == SIEMENS_VENDOR_ID) { 690 if (idp == SIEMENS_PRODUCT_ID_X65 || 691 idp == SIEMENS_PRODUCT_ID_SX1 || 692 idp == SIEMENS_PRODUCT_ID_X75) { 693 694 length = 1; 695 status_idx = 0; 696 } 697 } 698 699 if (actual_length < length) 700 return; 701 702 /* Save off the uart status for others to look at */ 703 spin_lock_irqsave(&priv->lock, flags); 704 priv->line_status = data[status_idx]; 705 spin_unlock_irqrestore(&priv->lock, flags); 706 if (priv->line_status & UART_BREAK_ERROR) 707 usb_serial_handle_break(port); 708 wake_up_interruptible(&priv->delta_msr_wait); 709 } 710 711 static void pl2303_read_int_callback(struct urb *urb) 712 { 713 struct usb_serial_port *port = urb->context; 714 unsigned char *data = urb->transfer_buffer; 715 unsigned int actual_length = urb->actual_length; 716 int status = urb->status; 717 int retval; 718 719 dbg("%s (%d)", __func__, port->number); 720 721 switch (status) { 722 case 0: 723 /* success */ 724 break; 725 case -ECONNRESET: 726 case -ENOENT: 727 case -ESHUTDOWN: 728 /* this urb is terminated, clean up */ 729 dbg("%s - urb shutting down with status: %d", __func__, 730 status); 731 return; 732 default: 733 dbg("%s - nonzero urb status received: %d", __func__, 734 status); 735 goto exit; 736 } 737 738 usb_serial_debug_data(debug, &port->dev, __func__, 739 urb->actual_length, urb->transfer_buffer); 740 741 pl2303_update_line_status(port, data, actual_length); 742 743 exit: 744 retval = usb_submit_urb(urb, GFP_ATOMIC); 745 if (retval) 746 dev_err(&urb->dev->dev, 747 "%s - usb_submit_urb failed with result %d\n", 748 __func__, retval); 749 } 750 751 static void pl2303_process_read_urb(struct urb *urb) 752 { 753 struct usb_serial_port *port = urb->context; 754 struct pl2303_private *priv = usb_get_serial_port_data(port); 755 struct tty_struct *tty; 756 unsigned char *data = urb->transfer_buffer; 757 char tty_flag = TTY_NORMAL; 758 unsigned long flags; 759 u8 line_status; 760 int i; 761 762 /* update line status */ 763 spin_lock_irqsave(&priv->lock, flags); 764 line_status = priv->line_status; 765 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 766 spin_unlock_irqrestore(&priv->lock, flags); 767 wake_up_interruptible(&priv->delta_msr_wait); 768 769 if (!urb->actual_length) 770 return; 771 772 tty = tty_port_tty_get(&port->port); 773 if (!tty) 774 return; 775 776 /* break takes precedence over parity, */ 777 /* which takes precedence over framing errors */ 778 if (line_status & UART_BREAK_ERROR) 779 tty_flag = TTY_BREAK; 780 else if (line_status & UART_PARITY_ERROR) 781 tty_flag = TTY_PARITY; 782 else if (line_status & UART_FRAME_ERROR) 783 tty_flag = TTY_FRAME; 784 dbg("%s - tty_flag = %d", __func__, tty_flag); 785 786 /* overrun is special, not associated with a char */ 787 if (line_status & UART_OVERRUN_ERROR) 788 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 789 790 if (port->port.console && port->sysrq) { 791 for (i = 0; i < urb->actual_length; ++i) 792 if (!usb_serial_handle_sysrq_char(port, data[i])) 793 tty_insert_flip_char(tty, data[i], tty_flag); 794 } else { 795 tty_insert_flip_string_fixed_flag(tty, data, tty_flag, 796 urb->actual_length); 797 } 798 799 tty_flip_buffer_push(tty); 800 tty_kref_put(tty); 801 } 802 803 /* All of the device info needed for the PL2303 SIO serial converter */ 804 static struct usb_serial_driver pl2303_device = { 805 .driver = { 806 .owner = THIS_MODULE, 807 .name = "pl2303", 808 }, 809 .id_table = id_table, 810 .usb_driver = &pl2303_driver, 811 .num_ports = 1, 812 .bulk_in_size = 256, 813 .bulk_out_size = 256, 814 .open = pl2303_open, 815 .close = pl2303_close, 816 .dtr_rts = pl2303_dtr_rts, 817 .carrier_raised = pl2303_carrier_raised, 818 .ioctl = pl2303_ioctl, 819 .break_ctl = pl2303_break_ctl, 820 .set_termios = pl2303_set_termios, 821 .tiocmget = pl2303_tiocmget, 822 .tiocmset = pl2303_tiocmset, 823 .process_read_urb = pl2303_process_read_urb, 824 .read_int_callback = pl2303_read_int_callback, 825 .attach = pl2303_startup, 826 .release = pl2303_release, 827 }; 828 829 static int __init pl2303_init(void) 830 { 831 int retval; 832 833 retval = usb_serial_register(&pl2303_device); 834 if (retval) 835 goto failed_usb_serial_register; 836 retval = usb_register(&pl2303_driver); 837 if (retval) 838 goto failed_usb_register; 839 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 840 return 0; 841 failed_usb_register: 842 usb_serial_deregister(&pl2303_device); 843 failed_usb_serial_register: 844 return retval; 845 } 846 847 static void __exit pl2303_exit(void) 848 { 849 usb_deregister(&pl2303_driver); 850 usb_serial_deregister(&pl2303_device); 851 } 852 853 module_init(pl2303_init); 854 module_exit(pl2303_exit); 855 856 MODULE_DESCRIPTION(DRIVER_DESC); 857 MODULE_LICENSE("GPL"); 858 859 module_param(debug, bool, S_IRUGO | S_IWUSR); 860 MODULE_PARM_DESC(debug, "Debug enabled or not"); 861 862