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