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