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