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
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/tty_flip.h>
24 #include <linux/serial.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/spinlock.h>
28 #include <linux/uaccess.h>
29 #include <linux/usb.h>
30 #include <linux/usb/serial.h>
31 #include <asm/unaligned.h>
35 #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
36 #define PL2303_QUIRK_LEGACY BIT(1)
38 static const struct usb_device_id id_table[] = {
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
49 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
51 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
52 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
53 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
54 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
55 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
56 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
57 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
58 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
59 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
60 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
61 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
62 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
63 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
64 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
65 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
66 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
67 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
68 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
70 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
72 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
73 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
74 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
75 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
76 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
77 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
78 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
79 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
80 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
81 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
82 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
83 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
84 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
85 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
86 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
87 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
88 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
89 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
90 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
91 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
92 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
93 { } /* Terminating entry */
96 MODULE_DEVICE_TABLE(usb, id_table);
98 #define SET_LINE_REQUEST_TYPE 0x21
99 #define SET_LINE_REQUEST 0x20
101 #define SET_CONTROL_REQUEST_TYPE 0x21
102 #define SET_CONTROL_REQUEST 0x22
103 #define CONTROL_DTR 0x01
104 #define CONTROL_RTS 0x02
106 #define BREAK_REQUEST_TYPE 0x21
107 #define BREAK_REQUEST 0x23
108 #define BREAK_ON 0xffff
109 #define BREAK_OFF 0x0000
111 #define GET_LINE_REQUEST_TYPE 0xa1
112 #define GET_LINE_REQUEST 0x21
114 #define VENDOR_WRITE_REQUEST_TYPE 0x40
115 #define VENDOR_WRITE_REQUEST 0x01
117 #define VENDOR_READ_REQUEST_TYPE 0xc0
118 #define VENDOR_READ_REQUEST 0x01
120 #define UART_STATE_INDEX 8
121 #define UART_STATE_MSR_MASK 0x8b
122 #define UART_STATE_TRANSIENT_MASK 0x74
123 #define UART_DCD 0x01
124 #define UART_DSR 0x02
125 #define UART_BREAK_ERROR 0x04
126 #define UART_RING 0x08
127 #define UART_FRAME_ERROR 0x10
128 #define UART_PARITY_ERROR 0x20
129 #define UART_OVERRUN_ERROR 0x40
130 #define UART_CTS 0x80
134 TYPE_01, /* Type 0 and 1 (difference unknown) */
135 TYPE_HX, /* HX version of the pl2303 chip */
139 struct pl2303_type_data {
140 speed_t max_baud_rate;
141 unsigned long quirks;
144 struct pl2303_serial_private {
145 const struct pl2303_type_data *type;
146 unsigned long quirks;
149 struct pl2303_private {
157 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
159 .max_baud_rate = 1228800,
160 .quirks = PL2303_QUIRK_LEGACY,
164 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
165 unsigned char buf[1])
167 struct device *dev = &serial->interface->dev;
170 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
171 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
172 value, 0, buf, 1, 100);
174 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
182 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
187 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
189 struct device *dev = &serial->interface->dev;
192 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
194 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
195 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
196 value, index, NULL, 0, 100);
198 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
206 static int pl2303_probe(struct usb_serial *serial,
207 const struct usb_device_id *id)
209 usb_set_serial_data(serial, (void *)id->driver_info);
214 static int pl2303_startup(struct usb_serial *serial)
216 struct pl2303_serial_private *spriv;
217 enum pl2303_type type = TYPE_01;
220 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
224 buf = kmalloc(1, GFP_KERNEL);
230 if (serial->dev->descriptor.bDeviceClass == 0x02)
231 type = TYPE_01; /* type 0 */
232 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
234 else if (serial->dev->descriptor.bDeviceClass == 0x00)
235 type = TYPE_01; /* type 1 */
236 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
237 type = TYPE_01; /* type 1 */
238 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
240 spriv->type = &pl2303_type_data[type];
241 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
242 spriv->quirks |= spriv->type->quirks;
244 usb_set_serial_data(serial, spriv);
246 pl2303_vendor_read(serial, 0x8484, buf);
247 pl2303_vendor_write(serial, 0x0404, 0);
248 pl2303_vendor_read(serial, 0x8484, buf);
249 pl2303_vendor_read(serial, 0x8383, buf);
250 pl2303_vendor_read(serial, 0x8484, buf);
251 pl2303_vendor_write(serial, 0x0404, 1);
252 pl2303_vendor_read(serial, 0x8484, buf);
253 pl2303_vendor_read(serial, 0x8383, buf);
254 pl2303_vendor_write(serial, 0, 1);
255 pl2303_vendor_write(serial, 1, 0);
256 if (spriv->quirks & PL2303_QUIRK_LEGACY)
257 pl2303_vendor_write(serial, 2, 0x24);
259 pl2303_vendor_write(serial, 2, 0x44);
266 static void pl2303_release(struct usb_serial *serial)
268 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
273 static int pl2303_port_probe(struct usb_serial_port *port)
275 struct pl2303_private *priv;
277 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
281 spin_lock_init(&priv->lock);
283 usb_set_serial_port_data(port, priv);
285 port->port.drain_delay = 256;
290 static int pl2303_port_remove(struct usb_serial_port *port)
292 struct pl2303_private *priv = usb_get_serial_port_data(port);
299 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
301 struct usb_device *dev = port->serial->dev;
304 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
306 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
307 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
308 value, 0, NULL, 0, 100);
310 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
316 * Returns the nearest supported baud rate that can be set directly without
319 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
321 static const speed_t baud_sup[] = {
322 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
323 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
324 614400, 921600, 1228800, 2457600, 3000000, 6000000
329 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
330 if (baud_sup[i] > baud)
334 if (i == ARRAY_SIZE(baud_sup))
335 baud = baud_sup[i - 1];
336 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
337 baud = baud_sup[i - 1];
345 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
348 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
351 put_unaligned_le32(baud, buf);
356 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
362 * Apparently the formula is:
363 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
365 tmp = 12000000 * 32 / baud;
368 buf[1] = (tmp >= 256);
378 static void pl2303_encode_baud_rate(struct tty_struct *tty,
379 struct usb_serial_port *port,
382 struct usb_serial *serial = port->serial;
383 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
387 baud = tty_get_baud_rate(tty);
388 dev_dbg(&port->dev, "baud requested = %u\n", baud);
392 if (spriv->type->max_baud_rate)
393 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
395 * Set baud rate to nearest supported value.
397 * NOTE: Baud rate 500k can only be set using divisors.
399 baud_sup = pl2303_get_supported_baud_rate(baud);
402 baud = pl2303_encode_baud_rate_divisor(buf, baud);
404 baud = pl2303_encode_baud_rate_direct(buf, baud_sup);
406 /* Save resulting baud rate */
407 tty_encode_baud_rate(tty, baud, baud);
408 dev_dbg(&port->dev, "baud set = %u\n", baud);
411 static int pl2303_get_line_request(struct usb_serial_port *port,
412 unsigned char buf[7])
414 struct usb_device *udev = port->serial->dev;
417 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
418 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
421 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
429 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
434 static int pl2303_set_line_request(struct usb_serial_port *port,
435 unsigned char buf[7])
437 struct usb_device *udev = port->serial->dev;
440 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
441 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
444 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
452 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
457 static void pl2303_set_termios(struct tty_struct *tty,
458 struct usb_serial_port *port, struct ktermios *old_termios)
460 struct usb_serial *serial = port->serial;
461 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
462 struct pl2303_private *priv = usb_get_serial_port_data(port);
468 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
471 buf = kzalloc(7, GFP_KERNEL);
473 /* Report back no change occurred */
475 tty->termios = *old_termios;
479 pl2303_get_line_request(port, buf);
481 switch (C_CSIZE(tty)) {
495 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
497 /* For reference buf[0]:buf[3] baud rate value */
498 pl2303_encode_baud_rate(tty, port, &buf[0]);
500 /* For reference buf[4]=0 is 1 stop bits */
501 /* For reference buf[4]=1 is 1.5 stop bits */
502 /* For reference buf[4]=2 is 2 stop bits */
505 * NOTE: Comply with "real" UARTs / RS232:
506 * use 1.5 instead of 2 stop bits with 5 data bits
508 if (C_CSIZE(tty) == CS5) {
510 dev_dbg(&port->dev, "stop bits = 1.5\n");
513 dev_dbg(&port->dev, "stop bits = 2\n");
517 dev_dbg(&port->dev, "stop bits = 1\n");
521 /* For reference buf[5]=0 is none parity */
522 /* For reference buf[5]=1 is odd parity */
523 /* For reference buf[5]=2 is even parity */
524 /* For reference buf[5]=3 is mark parity */
525 /* For reference buf[5]=4 is space parity */
529 dev_dbg(&port->dev, "parity = mark\n");
532 dev_dbg(&port->dev, "parity = odd\n");
537 dev_dbg(&port->dev, "parity = space\n");
540 dev_dbg(&port->dev, "parity = even\n");
545 dev_dbg(&port->dev, "parity = none\n");
549 * Some PL2303 are known to lose bytes if you change serial settings
550 * even to the same values as before. Thus we actually need to filter
551 * in this specific case.
553 * Note that the tty_termios_hw_change check above is not sufficient
554 * as a previously requested baud rate may differ from the one
555 * actually used (and stored in old_termios).
557 * NOTE: No additional locking needed for line_settings as it is
558 * only used in set_termios, which is serialised against itself.
560 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
561 ret = pl2303_set_line_request(port, buf);
563 memcpy(priv->line_settings, buf, 7);
566 /* change control lines if we are switching to or from B0 */
567 spin_lock_irqsave(&priv->lock, flags);
568 control = priv->line_control;
569 if (C_BAUD(tty) == B0)
570 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
571 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
572 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
573 if (control != priv->line_control) {
574 control = priv->line_control;
575 spin_unlock_irqrestore(&priv->lock, flags);
576 pl2303_set_control_lines(port, control);
578 spin_unlock_irqrestore(&priv->lock, flags);
581 if (C_CRTSCTS(tty)) {
582 if (spriv->quirks & PL2303_QUIRK_LEGACY)
583 pl2303_vendor_write(serial, 0x0, 0x41);
585 pl2303_vendor_write(serial, 0x0, 0x61);
587 pl2303_vendor_write(serial, 0x0, 0x0);
593 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
595 struct pl2303_private *priv = usb_get_serial_port_data(port);
599 spin_lock_irqsave(&priv->lock, flags);
601 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
603 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
604 control = priv->line_control;
605 spin_unlock_irqrestore(&priv->lock, flags);
607 pl2303_set_control_lines(port, control);
610 static void pl2303_close(struct usb_serial_port *port)
612 usb_serial_generic_close(port);
613 usb_kill_urb(port->interrupt_in_urb);
616 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
618 struct usb_serial *serial = port->serial;
619 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
622 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
623 usb_clear_halt(serial->dev, port->write_urb->pipe);
624 usb_clear_halt(serial->dev, port->read_urb->pipe);
626 /* reset upstream data pipes */
627 pl2303_vendor_write(serial, 8, 0);
628 pl2303_vendor_write(serial, 9, 0);
633 pl2303_set_termios(tty, port, NULL);
635 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
637 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
642 result = usb_serial_generic_open(tty, port);
644 usb_kill_urb(port->interrupt_in_urb);
651 static int pl2303_tiocmset(struct tty_struct *tty,
652 unsigned int set, unsigned int clear)
654 struct usb_serial_port *port = tty->driver_data;
655 struct pl2303_private *priv = usb_get_serial_port_data(port);
660 spin_lock_irqsave(&priv->lock, flags);
662 priv->line_control |= CONTROL_RTS;
664 priv->line_control |= CONTROL_DTR;
665 if (clear & TIOCM_RTS)
666 priv->line_control &= ~CONTROL_RTS;
667 if (clear & TIOCM_DTR)
668 priv->line_control &= ~CONTROL_DTR;
669 control = priv->line_control;
670 spin_unlock_irqrestore(&priv->lock, flags);
672 ret = pl2303_set_control_lines(port, control);
674 return usb_translate_errors(ret);
679 static int pl2303_tiocmget(struct tty_struct *tty)
681 struct usb_serial_port *port = tty->driver_data;
682 struct pl2303_private *priv = usb_get_serial_port_data(port);
688 spin_lock_irqsave(&priv->lock, flags);
689 mcr = priv->line_control;
690 status = priv->line_status;
691 spin_unlock_irqrestore(&priv->lock, flags);
693 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
694 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
695 | ((status & UART_CTS) ? TIOCM_CTS : 0)
696 | ((status & UART_DSR) ? TIOCM_DSR : 0)
697 | ((status & UART_RING) ? TIOCM_RI : 0)
698 | ((status & UART_DCD) ? TIOCM_CD : 0);
700 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
705 static int pl2303_carrier_raised(struct usb_serial_port *port)
707 struct pl2303_private *priv = usb_get_serial_port_data(port);
709 if (priv->line_status & UART_DCD)
715 static int pl2303_ioctl(struct tty_struct *tty,
716 unsigned int cmd, unsigned long arg)
718 struct serial_struct ser;
719 struct usb_serial_port *port = tty->driver_data;
723 memset(&ser, 0, sizeof ser);
724 ser.type = PORT_16654;
725 ser.line = port->minor;
726 ser.port = port->port_number;
727 ser.baud_base = 460800;
729 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
740 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
742 struct usb_serial_port *port = tty->driver_data;
743 struct usb_serial *serial = port->serial;
747 if (break_state == 0)
752 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
753 state == BREAK_OFF ? "off" : "on");
755 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
756 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
759 dev_err(&port->dev, "error sending break = %d\n", result);
762 static void pl2303_update_line_status(struct usb_serial_port *port,
764 unsigned int actual_length)
766 struct usb_serial *serial = port->serial;
767 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
768 struct pl2303_private *priv = usb_get_serial_port_data(port);
769 struct tty_struct *tty;
771 unsigned int status_idx = UART_STATE_INDEX;
775 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
778 if (actual_length < status_idx + 1)
781 status = data[status_idx];
783 /* Save off the uart status for others to look at */
784 spin_lock_irqsave(&priv->lock, flags);
785 delta = priv->line_status ^ status;
786 priv->line_status = status;
787 spin_unlock_irqrestore(&priv->lock, flags);
789 if (status & UART_BREAK_ERROR)
790 usb_serial_handle_break(port);
792 if (delta & UART_STATE_MSR_MASK) {
793 if (delta & UART_CTS)
795 if (delta & UART_DSR)
797 if (delta & UART_RING)
799 if (delta & UART_DCD) {
801 tty = tty_port_tty_get(&port->port);
803 usb_serial_handle_dcd_change(port, tty,
809 wake_up_interruptible(&port->port.delta_msr_wait);
813 static void pl2303_read_int_callback(struct urb *urb)
815 struct usb_serial_port *port = urb->context;
816 unsigned char *data = urb->transfer_buffer;
817 unsigned int actual_length = urb->actual_length;
818 int status = urb->status;
828 /* this urb is terminated, clean up */
829 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
833 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
838 usb_serial_debug_data(&port->dev, __func__,
839 urb->actual_length, urb->transfer_buffer);
841 pl2303_update_line_status(port, data, actual_length);
844 retval = usb_submit_urb(urb, GFP_ATOMIC);
847 "%s - usb_submit_urb failed with result %d\n",
852 static void pl2303_process_read_urb(struct urb *urb)
854 struct usb_serial_port *port = urb->context;
855 struct pl2303_private *priv = usb_get_serial_port_data(port);
856 unsigned char *data = urb->transfer_buffer;
857 char tty_flag = TTY_NORMAL;
862 /* update line status */
863 spin_lock_irqsave(&priv->lock, flags);
864 line_status = priv->line_status;
865 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
866 spin_unlock_irqrestore(&priv->lock, flags);
868 if (!urb->actual_length)
872 * Break takes precedence over parity, which takes precedence over
875 if (line_status & UART_BREAK_ERROR)
876 tty_flag = TTY_BREAK;
877 else if (line_status & UART_PARITY_ERROR)
878 tty_flag = TTY_PARITY;
879 else if (line_status & UART_FRAME_ERROR)
880 tty_flag = TTY_FRAME;
882 if (tty_flag != TTY_NORMAL)
883 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
885 /* overrun is special, not associated with a char */
886 if (line_status & UART_OVERRUN_ERROR)
887 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
889 if (port->port.console && port->sysrq) {
890 for (i = 0; i < urb->actual_length; ++i)
891 if (!usb_serial_handle_sysrq_char(port, data[i]))
892 tty_insert_flip_char(&port->port, data[i],
895 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
899 tty_flip_buffer_push(&port->port);
902 static struct usb_serial_driver pl2303_device = {
904 .owner = THIS_MODULE,
907 .id_table = id_table,
910 .bulk_out_size = 256,
912 .close = pl2303_close,
913 .dtr_rts = pl2303_dtr_rts,
914 .carrier_raised = pl2303_carrier_raised,
915 .ioctl = pl2303_ioctl,
916 .break_ctl = pl2303_break_ctl,
917 .set_termios = pl2303_set_termios,
918 .tiocmget = pl2303_tiocmget,
919 .tiocmset = pl2303_tiocmset,
920 .tiocmiwait = usb_serial_generic_tiocmiwait,
921 .process_read_urb = pl2303_process_read_urb,
922 .read_int_callback = pl2303_read_int_callback,
923 .probe = pl2303_probe,
924 .attach = pl2303_startup,
925 .release = pl2303_release,
926 .port_probe = pl2303_port_probe,
927 .port_remove = pl2303_port_remove,
930 static struct usb_serial_driver * const serial_drivers[] = {
934 module_usb_serial_driver(serial_drivers, id_table);
936 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
937 MODULE_LICENSE("GPL");