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 .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 145enum 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 151struct 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 159static 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 170static 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 181static 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 230cleanup: 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 240static 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 251static 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 458static 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 475static 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 483static 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 interrupt urb", __func__); 506 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 507 if (result) { 508 dev_err(&port->dev, "%s - failed submitting interrupt urb," 509 " error %d\n", __func__, result); 510 return result; 511 } 512 513 result = usb_serial_generic_open(tty, port); 514 if (result) { 515 usb_kill_urb(port->interrupt_in_urb); 516 return result; 517 } 518 519 port->port.drain_delay = 256; 520 return 0; 521} 522 523static int pl2303_tiocmset(struct tty_struct *tty, 524 unsigned int set, unsigned int clear) 525{ 526 struct usb_serial_port *port = tty->driver_data; 527 struct pl2303_private *priv = usb_get_serial_port_data(port); 528 unsigned long flags; 529 u8 control; 530 531 if (!usb_get_intfdata(port->serial->interface)) 532 return -ENODEV; 533 534 spin_lock_irqsave(&priv->lock, flags); 535 if (set & TIOCM_RTS) 536 priv->line_control |= CONTROL_RTS; 537 if (set & TIOCM_DTR) 538 priv->line_control |= CONTROL_DTR; 539 if (clear & TIOCM_RTS) 540 priv->line_control &= ~CONTROL_RTS; 541 if (clear & TIOCM_DTR) 542 priv->line_control &= ~CONTROL_DTR; 543 control = priv->line_control; 544 spin_unlock_irqrestore(&priv->lock, flags); 545 546 return set_control_lines(port->serial->dev, control); 547} 548 549static int pl2303_tiocmget(struct tty_struct *tty) 550{ 551 struct usb_serial_port *port = tty->driver_data; 552 struct pl2303_private *priv = usb_get_serial_port_data(port); 553 unsigned long flags; 554 unsigned int mcr; 555 unsigned int status; 556 unsigned int result; 557 558 dbg("%s (%d)", __func__, port->number); 559 560 if (!usb_get_intfdata(port->serial->interface)) 561 return -ENODEV; 562 563 spin_lock_irqsave(&priv->lock, flags); 564 mcr = priv->line_control; 565 status = priv->line_status; 566 spin_unlock_irqrestore(&priv->lock, flags); 567 568 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0) 569 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) 570 | ((status & UART_CTS) ? TIOCM_CTS : 0) 571 | ((status & UART_DSR) ? TIOCM_DSR : 0) 572 | ((status & UART_RING) ? TIOCM_RI : 0) 573 | ((status & UART_DCD) ? TIOCM_CD : 0); 574 575 dbg("%s - result = %x", __func__, result); 576 577 return result; 578} 579 580static int pl2303_carrier_raised(struct usb_serial_port *port) 581{ 582 struct pl2303_private *priv = usb_get_serial_port_data(port); 583 if (priv->line_status & UART_DCD) 584 return 1; 585 return 0; 586} 587 588static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 589{ 590 struct pl2303_private *priv = usb_get_serial_port_data(port); 591 unsigned long flags; 592 unsigned int prevstatus; 593 unsigned int status; 594 unsigned int changed; 595 596 spin_lock_irqsave(&priv->lock, flags); 597 prevstatus = priv->line_status; 598 spin_unlock_irqrestore(&priv->lock, flags); 599 600 while (1) { 601 interruptible_sleep_on(&priv->delta_msr_wait); 602 /* see if a signal did it */ 603 if (signal_pending(current)) 604 return -ERESTARTSYS; 605 606 spin_lock_irqsave(&priv->lock, flags); 607 status = priv->line_status; 608 spin_unlock_irqrestore(&priv->lock, flags); 609 610 changed = prevstatus ^ status; 611 612 if (((arg & TIOCM_RNG) && (changed & UART_RING)) || 613 ((arg & TIOCM_DSR) && (changed & UART_DSR)) || 614 ((arg & TIOCM_CD) && (changed & UART_DCD)) || 615 ((arg & TIOCM_CTS) && (changed & UART_CTS))) { 616 return 0; 617 } 618 prevstatus = status; 619 } 620 /* NOTREACHED */ 621 return 0; 622} 623 624static int pl2303_ioctl(struct tty_struct *tty, 625 unsigned int cmd, unsigned long arg) 626{ 627 struct serial_struct ser; 628 struct usb_serial_port *port = tty->driver_data; 629 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 630 631 switch (cmd) { 632 case TIOCGSERIAL: 633 memset(&ser, 0, sizeof ser); 634 ser.type = PORT_16654; 635 ser.line = port->serial->minor; 636 ser.port = port->number; 637 ser.baud_base = 460800; 638 639 if (copy_to_user((void __user *)arg, &ser, sizeof ser)) 640 return -EFAULT; 641 642 return 0; 643 644 case TIOCMIWAIT: 645 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 646 return wait_modem_info(port, arg); 647 default: 648 dbg("%s not supported = 0x%04x", __func__, cmd); 649 break; 650 } 651 return -ENOIOCTLCMD; 652} 653 654static void pl2303_break_ctl(struct tty_struct *tty, int break_state) 655{ 656 struct usb_serial_port *port = tty->driver_data; 657 struct usb_serial *serial = port->serial; 658 u16 state; 659 int result; 660 661 dbg("%s - port %d", __func__, port->number); 662 663 if (break_state == 0) 664 state = BREAK_OFF; 665 else 666 state = BREAK_ON; 667 dbg("%s - turning break %s", __func__, 668 state == BREAK_OFF ? "off" : "on"); 669 670 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 671 BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 672 0, NULL, 0, 100); 673 if (result) 674 dbg("%s - error sending break = %d", __func__, result); 675} 676 677static void pl2303_release(struct usb_serial *serial) 678{ 679 int i; 680 struct pl2303_private *priv; 681 682 dbg("%s", __func__); 683 684 for (i = 0; i < serial->num_ports; ++i) { 685 priv = usb_get_serial_port_data(serial->port[i]); 686 kfree(priv); 687 } 688} 689 690static void pl2303_update_line_status(struct usb_serial_port *port, 691 unsigned char *data, 692 unsigned int actual_length) 693{ 694 695 struct pl2303_private *priv = usb_get_serial_port_data(port); 696 struct tty_struct *tty; 697 unsigned long flags; 698 u8 status_idx = UART_STATE; 699 u8 length = UART_STATE + 1; 700 u8 prev_line_status; 701 u16 idv, idp; 702 703 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor); 704 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct); 705 706 707 if (idv == SIEMENS_VENDOR_ID) { 708 if (idp == SIEMENS_PRODUCT_ID_X65 || 709 idp == SIEMENS_PRODUCT_ID_SX1 || 710 idp == SIEMENS_PRODUCT_ID_X75) { 711 712 length = 1; 713 status_idx = 0; 714 } 715 } 716 717 if (actual_length < length) 718 return; 719 720 /* Save off the uart status for others to look at */ 721 spin_lock_irqsave(&priv->lock, flags); 722 prev_line_status = priv->line_status; 723 priv->line_status = data[status_idx]; 724 spin_unlock_irqrestore(&priv->lock, flags); 725 if (priv->line_status & UART_BREAK_ERROR) 726 usb_serial_handle_break(port); 727 wake_up_interruptible(&priv->delta_msr_wait); 728 729 tty = tty_port_tty_get(&port->port); 730 if (!tty) 731 return; 732 if ((priv->line_status ^ prev_line_status) & UART_DCD) 733 usb_serial_handle_dcd_change(port, tty, 734 priv->line_status & UART_DCD); 735 tty_kref_put(tty); 736} 737 738static void pl2303_read_int_callback(struct urb *urb) 739{ 740 struct usb_serial_port *port = urb->context; 741 unsigned char *data = urb->transfer_buffer; 742 unsigned int actual_length = urb->actual_length; 743 int status = urb->status; 744 int retval; 745 746 dbg("%s (%d)", __func__, port->number); 747 748 switch (status) { 749 case 0: 750 /* success */ 751 break; 752 case -ECONNRESET: 753 case -ENOENT: 754 case -ESHUTDOWN: 755 /* this urb is terminated, clean up */ 756 dbg("%s - urb shutting down with status: %d", __func__, 757 status); 758 return; 759 default: 760 dbg("%s - nonzero urb status received: %d", __func__, 761 status); 762 goto exit; 763 } 764 765 usb_serial_debug_data(debug, &port->dev, __func__, 766 urb->actual_length, urb->transfer_buffer); 767 768 pl2303_update_line_status(port, data, actual_length); 769 770exit: 771 retval = usb_submit_urb(urb, GFP_ATOMIC); 772 if (retval) 773 dev_err(&urb->dev->dev, 774 "%s - usb_submit_urb failed with result %d\n", 775 __func__, retval); 776} 777 778static void pl2303_process_read_urb(struct urb *urb) 779{ 780 struct usb_serial_port *port = urb->context; 781 struct pl2303_private *priv = usb_get_serial_port_data(port); 782 struct tty_struct *tty; 783 unsigned char *data = urb->transfer_buffer; 784 char tty_flag = TTY_NORMAL; 785 unsigned long flags; 786 u8 line_status; 787 int i; 788 789 /* update line status */ 790 spin_lock_irqsave(&priv->lock, flags); 791 line_status = priv->line_status; 792 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 793 spin_unlock_irqrestore(&priv->lock, flags); 794 wake_up_interruptible(&priv->delta_msr_wait); 795 796 if (!urb->actual_length) 797 return; 798 799 tty = tty_port_tty_get(&port->port); 800 if (!tty) 801 return; 802 803 /* break takes precedence over parity, */ 804 /* which takes precedence over framing errors */ 805 if (line_status & UART_BREAK_ERROR) 806 tty_flag = TTY_BREAK; 807 else if (line_status & UART_PARITY_ERROR) 808 tty_flag = TTY_PARITY; 809 else if (line_status & UART_FRAME_ERROR) 810 tty_flag = TTY_FRAME; 811 dbg("%s - tty_flag = %d", __func__, tty_flag); 812 813 /* overrun is special, not associated with a char */ 814 if (line_status & UART_OVERRUN_ERROR) 815 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 816 817 if (port->port.console && port->sysrq) { 818 for (i = 0; i < urb->actual_length; ++i) 819 if (!usb_serial_handle_sysrq_char(port, data[i])) 820 tty_insert_flip_char(tty, data[i], tty_flag); 821 } else { 822 tty_insert_flip_string_fixed_flag(tty, data, tty_flag, 823 urb->actual_length); 824 } 825 826 tty_flip_buffer_push(tty); 827 tty_kref_put(tty); 828} 829 830/* All of the device info needed for the PL2303 SIO serial converter */ 831static struct usb_serial_driver pl2303_device = { 832 .driver = { 833 .owner = THIS_MODULE, 834 .name = "pl2303", 835 }, 836 .id_table = id_table, 837 .usb_driver = &pl2303_driver, 838 .num_ports = 1, 839 .bulk_in_size = 256, 840 .bulk_out_size = 256, 841 .open = pl2303_open, 842 .close = pl2303_close, 843 .dtr_rts = pl2303_dtr_rts, 844 .carrier_raised = pl2303_carrier_raised, 845 .ioctl = pl2303_ioctl, 846 .break_ctl = pl2303_break_ctl, 847 .set_termios = pl2303_set_termios, 848 .tiocmget = pl2303_tiocmget, 849 .tiocmset = pl2303_tiocmset, 850 .process_read_urb = pl2303_process_read_urb, 851 .read_int_callback = pl2303_read_int_callback, 852 .attach = pl2303_startup, 853 .release = pl2303_release, 854}; 855 856static int __init pl2303_init(void) 857{ 858 int retval; 859 860 retval = usb_serial_register(&pl2303_device); 861 if (retval) 862 goto failed_usb_serial_register; 863 retval = usb_register(&pl2303_driver); 864 if (retval) 865 goto failed_usb_register; 866 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 867 return 0; 868failed_usb_register: 869 usb_serial_deregister(&pl2303_device); 870failed_usb_serial_register: 871 return retval; 872} 873 874static void __exit pl2303_exit(void) 875{ 876 usb_deregister(&pl2303_driver); 877 usb_serial_deregister(&pl2303_device); 878} 879 880module_init(pl2303_init); 881module_exit(pl2303_exit); 882 883MODULE_DESCRIPTION(DRIVER_DESC); 884MODULE_LICENSE("GPL"); 885 886module_param(debug, bool, S_IRUGO | S_IWUSR); 887MODULE_PARM_DESC(debug, "Debug enabled or not"); 888 889