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