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