2 * Prolific PL2303 USB to serial adaptor driver
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
7 * Original driver for 2.2.x by anonymous
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.
13 * See Documentation/usb/usb-serial.txt for more information on using this
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>
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
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 */
94 MODULE_DEVICE_TABLE(usb, id_table);
96 #define SET_LINE_REQUEST_TYPE 0x21
97 #define SET_LINE_REQUEST 0x20
99 #define SET_CONTROL_REQUEST_TYPE 0x21
100 #define SET_CONTROL_REQUEST 0x22
101 #define CONTROL_DTR 0x01
102 #define CONTROL_RTS 0x02
104 #define BREAK_REQUEST_TYPE 0x21
105 #define BREAK_REQUEST 0x23
106 #define BREAK_ON 0xffff
107 #define BREAK_OFF 0x0000
109 #define GET_LINE_REQUEST_TYPE 0xa1
110 #define GET_LINE_REQUEST 0x21
112 #define VENDOR_WRITE_REQUEST_TYPE 0x40
113 #define VENDOR_WRITE_REQUEST 0x01
115 #define VENDOR_READ_REQUEST_TYPE 0xc0
116 #define VENDOR_READ_REQUEST 0x01
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
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 */
136 struct pl2303_serial_private {
137 enum pl2303_type type;
140 struct pl2303_private {
146 static int pl2303_vendor_read(__u16 value, __u16 index,
147 struct usb_serial *serial, unsigned char *buf)
149 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
150 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
151 value, index, buf, 1, 100);
152 dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x %d - %x\n",
153 VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
158 static int pl2303_vendor_write(__u16 value, __u16 index,
159 struct usb_serial *serial)
161 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
162 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
163 value, index, NULL, 0, 100);
164 dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x %d\n",
165 VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
170 static int pl2303_startup(struct usb_serial *serial)
172 struct pl2303_serial_private *spriv;
173 enum pl2303_type type = type_0;
176 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
180 buf = kmalloc(10, GFP_KERNEL);
186 if (serial->dev->descriptor.bDeviceClass == 0x02)
188 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
190 else if (serial->dev->descriptor.bDeviceClass == 0x00)
192 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
194 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
197 usb_set_serial_data(serial, spriv);
199 pl2303_vendor_read(0x8484, 0, serial, buf);
200 pl2303_vendor_write(0x0404, 0, serial);
201 pl2303_vendor_read(0x8484, 0, serial, buf);
202 pl2303_vendor_read(0x8383, 0, serial, buf);
203 pl2303_vendor_read(0x8484, 0, serial, buf);
204 pl2303_vendor_write(0x0404, 1, serial);
205 pl2303_vendor_read(0x8484, 0, serial, buf);
206 pl2303_vendor_read(0x8383, 0, serial, buf);
207 pl2303_vendor_write(0, 1, serial);
208 pl2303_vendor_write(1, 0, serial);
210 pl2303_vendor_write(2, 0x44, serial);
212 pl2303_vendor_write(2, 0x24, serial);
218 static void pl2303_release(struct usb_serial *serial)
220 struct pl2303_serial_private *spriv;
222 spriv = usb_get_serial_data(serial);
226 static int pl2303_port_probe(struct usb_serial_port *port)
228 struct pl2303_private *priv;
230 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
234 spin_lock_init(&priv->lock);
236 usb_set_serial_port_data(port, priv);
241 static int pl2303_port_remove(struct usb_serial_port *port)
243 struct pl2303_private *priv;
245 priv = usb_get_serial_port_data(port);
251 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
253 struct usb_device *dev = port->serial->dev;
256 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
257 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
258 value, 0, NULL, 0, 100);
259 dev_dbg(&port->dev, "%s - value = %d, retval = %d\n", __func__,
264 static void pl2303_set_termios(struct tty_struct *tty,
265 struct usb_serial_port *port, struct ktermios *old_termios)
267 struct usb_serial *serial = port->serial;
268 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
269 struct pl2303_private *priv = usb_get_serial_port_data(port);
276 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
277 4800, 7200, 9600, 14400, 19200, 28800, 38400,
278 57600, 115200, 230400, 460800, 500000, 614400,
279 921600, 1228800, 2457600, 3000000, 6000000 };
280 int baud_floor, baud_ceil;
283 /* The PL2303 is reported to lose bytes if you change
284 serial settings even to the same values as before. Thus
285 we actually need to filter in this specific case */
287 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
290 cflag = tty->termios.c_cflag;
292 buf = kzalloc(7, GFP_KERNEL);
294 dev_err(&port->dev, "%s - out of memory.\n", __func__);
295 /* Report back no change occurred */
297 tty->termios = *old_termios;
301 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
302 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
304 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %7ph\n", i, buf);
307 switch (cflag & CSIZE) {
322 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
325 /* For reference buf[0]:buf[3] baud rate value */
326 /* NOTE: Only the values defined in baud_sup are supported !
327 * => if unsupported values are set, the PL2303 seems to use
328 * 9600 baud (at least my PL2303X always does)
330 baud = tty_get_baud_rate(tty);
331 dev_dbg(&port->dev, "baud requested = %d\n", baud);
333 /* Set baudrate to nearest supported value */
334 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
335 if (baud_sup[k] / baud) {
336 baud_ceil = baud_sup[k];
340 baud_floor = baud_sup[k-1];
341 if ((baud_ceil % baud)
342 > (baud % baud_floor))
350 if (baud > 1228800) {
351 /* type_0, type_1 only support up to 1228800 baud */
352 if (spriv->type != HX)
354 else if (baud > 6000000)
357 dev_dbg(&port->dev, "baud set = %d\n", baud);
358 if (baud <= 115200) {
359 buf[0] = baud & 0xff;
360 buf[1] = (baud >> 8) & 0xff;
361 buf[2] = (baud >> 16) & 0xff;
362 buf[3] = (baud >> 24) & 0xff;
364 /* apparently the formula for higher speeds is:
365 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
367 unsigned tmp = 12*1000*1000*32 / baud;
370 buf[1] = (tmp >= 256);
379 /* For reference buf[4]=0 is 1 stop bits */
380 /* For reference buf[4]=1 is 1.5 stop bits */
381 /* For reference buf[4]=2 is 2 stop bits */
382 if (cflag & CSTOPB) {
383 /* NOTE: Comply with "real" UARTs / RS232:
384 * use 1.5 instead of 2 stop bits with 5 data bits
386 if ((cflag & CSIZE) == CS5) {
388 dev_dbg(&port->dev, "stop bits = 1.5\n");
391 dev_dbg(&port->dev, "stop bits = 2\n");
395 dev_dbg(&port->dev, "stop bits = 1\n");
398 if (cflag & PARENB) {
399 /* For reference buf[5]=0 is none parity */
400 /* For reference buf[5]=1 is odd parity */
401 /* For reference buf[5]=2 is even parity */
402 /* For reference buf[5]=3 is mark parity */
403 /* For reference buf[5]=4 is space parity */
404 if (cflag & PARODD) {
405 if (cflag & CMSPAR) {
407 dev_dbg(&port->dev, "parity = mark\n");
410 dev_dbg(&port->dev, "parity = odd\n");
413 if (cflag & CMSPAR) {
415 dev_dbg(&port->dev, "parity = space\n");
418 dev_dbg(&port->dev, "parity = even\n");
423 dev_dbg(&port->dev, "parity = none\n");
426 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
427 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
429 dev_dbg(&port->dev, "0x21:0x20:0:0 %d\n", i);
431 /* change control lines if we are switching to or from B0 */
432 spin_lock_irqsave(&priv->lock, flags);
433 control = priv->line_control;
434 if ((cflag & CBAUD) == B0)
435 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
436 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
437 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
438 if (control != priv->line_control) {
439 control = priv->line_control;
440 spin_unlock_irqrestore(&priv->lock, flags);
441 pl2303_set_control_lines(port, control);
443 spin_unlock_irqrestore(&priv->lock, flags);
446 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
448 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
449 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
451 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %7ph\n", i, buf);
453 if (cflag & CRTSCTS) {
454 if (spriv->type == HX)
455 pl2303_vendor_write(0x0, 0x61, serial);
457 pl2303_vendor_write(0x0, 0x41, serial);
459 pl2303_vendor_write(0x0, 0x0, serial);
462 /* Save resulting baud rate */
464 tty_encode_baud_rate(tty, baud, baud);
469 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
471 struct pl2303_private *priv = usb_get_serial_port_data(port);
475 spin_lock_irqsave(&priv->lock, flags);
476 /* Change DTR and RTS */
478 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
480 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
481 control = priv->line_control;
482 spin_unlock_irqrestore(&priv->lock, flags);
483 pl2303_set_control_lines(port, control);
486 static void pl2303_close(struct usb_serial_port *port)
488 usb_serial_generic_close(port);
489 usb_kill_urb(port->interrupt_in_urb);
492 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
494 struct usb_serial *serial = port->serial;
495 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
498 if (spriv->type != HX) {
499 usb_clear_halt(serial->dev, port->write_urb->pipe);
500 usb_clear_halt(serial->dev, port->read_urb->pipe);
502 /* reset upstream data pipes */
503 pl2303_vendor_write(8, 0, serial);
504 pl2303_vendor_write(9, 0, serial);
509 pl2303_set_termios(tty, port, NULL);
511 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
513 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
514 " error %d\n", __func__, result);
518 result = usb_serial_generic_open(tty, port);
520 usb_kill_urb(port->interrupt_in_urb);
524 port->port.drain_delay = 256;
528 static int pl2303_tiocmset(struct tty_struct *tty,
529 unsigned int set, unsigned int clear)
531 struct usb_serial_port *port = tty->driver_data;
532 struct pl2303_private *priv = usb_get_serial_port_data(port);
537 spin_lock_irqsave(&priv->lock, flags);
539 priv->line_control |= CONTROL_RTS;
541 priv->line_control |= CONTROL_DTR;
542 if (clear & TIOCM_RTS)
543 priv->line_control &= ~CONTROL_RTS;
544 if (clear & TIOCM_DTR)
545 priv->line_control &= ~CONTROL_DTR;
546 control = priv->line_control;
547 spin_unlock_irqrestore(&priv->lock, flags);
549 ret = pl2303_set_control_lines(port, control);
551 return usb_translate_errors(ret);
556 static int pl2303_tiocmget(struct tty_struct *tty)
558 struct usb_serial_port *port = tty->driver_data;
559 struct pl2303_private *priv = usb_get_serial_port_data(port);
565 spin_lock_irqsave(&priv->lock, flags);
566 mcr = priv->line_control;
567 status = priv->line_status;
568 spin_unlock_irqrestore(&priv->lock, flags);
570 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
571 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
572 | ((status & UART_CTS) ? TIOCM_CTS : 0)
573 | ((status & UART_DSR) ? TIOCM_DSR : 0)
574 | ((status & UART_RING) ? TIOCM_RI : 0)
575 | ((status & UART_DCD) ? TIOCM_CD : 0);
577 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
582 static int pl2303_carrier_raised(struct usb_serial_port *port)
584 struct pl2303_private *priv = usb_get_serial_port_data(port);
585 if (priv->line_status & UART_DCD)
590 static int pl2303_tiocmiwait(struct tty_struct *tty, unsigned long arg)
592 struct usb_serial_port *port = tty->driver_data;
593 struct pl2303_private *priv = usb_get_serial_port_data(port);
595 unsigned int prevstatus;
597 unsigned int changed;
599 spin_lock_irqsave(&priv->lock, flags);
600 prevstatus = priv->line_status;
601 spin_unlock_irqrestore(&priv->lock, flags);
604 interruptible_sleep_on(&port->port.delta_msr_wait);
605 /* see if a signal did it */
606 if (signal_pending(current))
609 if (port->serial->disconnected)
612 spin_lock_irqsave(&priv->lock, flags);
613 status = priv->line_status;
614 spin_unlock_irqrestore(&priv->lock, flags);
616 changed = prevstatus ^ status;
618 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
619 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
620 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
621 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
630 static int pl2303_ioctl(struct tty_struct *tty,
631 unsigned int cmd, unsigned long arg)
633 struct serial_struct ser;
634 struct usb_serial_port *port = tty->driver_data;
636 dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
640 memset(&ser, 0, sizeof ser);
641 ser.type = PORT_16654;
642 ser.line = port->serial->minor;
643 ser.port = port->port_number;
644 ser.baud_base = 460800;
646 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
651 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
657 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
659 struct usb_serial_port *port = tty->driver_data;
660 struct usb_serial *serial = port->serial;
664 if (break_state == 0)
668 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
669 state == BREAK_OFF ? "off" : "on");
671 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
672 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
675 dev_err(&port->dev, "error sending break = %d\n", result);
678 static void pl2303_update_line_status(struct usb_serial_port *port,
680 unsigned int actual_length)
683 struct pl2303_private *priv = usb_get_serial_port_data(port);
684 struct tty_struct *tty;
686 u8 status_idx = UART_STATE;
687 u8 length = UART_STATE + 1;
691 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
692 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
695 if (idv == SIEMENS_VENDOR_ID) {
696 if (idp == SIEMENS_PRODUCT_ID_X65 ||
697 idp == SIEMENS_PRODUCT_ID_SX1 ||
698 idp == SIEMENS_PRODUCT_ID_X75) {
705 if (actual_length < length)
708 /* Save off the uart status for others to look at */
709 spin_lock_irqsave(&priv->lock, flags);
710 prev_line_status = priv->line_status;
711 priv->line_status = data[status_idx];
712 spin_unlock_irqrestore(&priv->lock, flags);
713 if (priv->line_status & UART_BREAK_ERROR)
714 usb_serial_handle_break(port);
715 wake_up_interruptible(&port->port.delta_msr_wait);
717 tty = tty_port_tty_get(&port->port);
720 if ((priv->line_status ^ prev_line_status) & UART_DCD)
721 usb_serial_handle_dcd_change(port, tty,
722 priv->line_status & UART_DCD);
726 static void pl2303_read_int_callback(struct urb *urb)
728 struct usb_serial_port *port = urb->context;
729 unsigned char *data = urb->transfer_buffer;
730 unsigned int actual_length = urb->actual_length;
731 int status = urb->status;
741 /* this urb is terminated, clean up */
742 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
746 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
751 usb_serial_debug_data(&port->dev, __func__,
752 urb->actual_length, urb->transfer_buffer);
754 pl2303_update_line_status(port, data, actual_length);
757 retval = usb_submit_urb(urb, GFP_ATOMIC);
760 "%s - usb_submit_urb failed with result %d\n",
764 static void pl2303_process_read_urb(struct urb *urb)
766 struct usb_serial_port *port = urb->context;
767 struct pl2303_private *priv = usb_get_serial_port_data(port);
768 unsigned char *data = urb->transfer_buffer;
769 char tty_flag = TTY_NORMAL;
774 /* update line status */
775 spin_lock_irqsave(&priv->lock, flags);
776 line_status = priv->line_status;
777 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
778 spin_unlock_irqrestore(&priv->lock, flags);
779 wake_up_interruptible(&port->port.delta_msr_wait);
781 if (!urb->actual_length)
784 /* break takes precedence over parity, */
785 /* which takes precedence over framing errors */
786 if (line_status & UART_BREAK_ERROR)
787 tty_flag = TTY_BREAK;
788 else if (line_status & UART_PARITY_ERROR)
789 tty_flag = TTY_PARITY;
790 else if (line_status & UART_FRAME_ERROR)
791 tty_flag = TTY_FRAME;
792 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
794 /* overrun is special, not associated with a char */
795 if (line_status & UART_OVERRUN_ERROR)
796 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
798 if (port->port.console && port->sysrq) {
799 for (i = 0; i < urb->actual_length; ++i)
800 if (!usb_serial_handle_sysrq_char(port, data[i]))
801 tty_insert_flip_char(&port->port, data[i],
804 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
808 tty_flip_buffer_push(&port->port);
811 /* All of the device info needed for the PL2303 SIO serial converter */
812 static struct usb_serial_driver pl2303_device = {
814 .owner = THIS_MODULE,
817 .id_table = id_table,
820 .bulk_out_size = 256,
822 .close = pl2303_close,
823 .dtr_rts = pl2303_dtr_rts,
824 .carrier_raised = pl2303_carrier_raised,
825 .ioctl = pl2303_ioctl,
826 .break_ctl = pl2303_break_ctl,
827 .set_termios = pl2303_set_termios,
828 .tiocmget = pl2303_tiocmget,
829 .tiocmset = pl2303_tiocmset,
830 .tiocmiwait = pl2303_tiocmiwait,
831 .process_read_urb = pl2303_process_read_urb,
832 .read_int_callback = pl2303_read_int_callback,
833 .attach = pl2303_startup,
834 .release = pl2303_release,
835 .port_probe = pl2303_port_probe,
836 .port_remove = pl2303_port_remove,
839 static struct usb_serial_driver * const serial_drivers[] = {
843 module_usb_serial_driver(serial_drivers, id_table);
845 MODULE_DESCRIPTION(DRIVER_DESC);
846 MODULE_LICENSE("GPL");