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