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