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