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