1 // SPDX-License-Identifier: GPL-2.0
3 * Prolific PL2303 USB to serial adaptor driver
5 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2003 IBM Corp.
8 * Original driver for 2.2.x by anonymous
10 * See Documentation/usb/usb-serial.txt for more information on using this
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/tty.h>
18 #include <linux/tty_driver.h>
19 #include <linux/tty_flip.h>
20 #include <linux/serial.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/spinlock.h>
24 #include <linux/uaccess.h>
25 #include <linux/usb.h>
26 #include <linux/usb/serial.h>
27 #include <asm/unaligned.h>
31 #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
32 #define PL2303_QUIRK_LEGACY BIT(1)
33 #define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
35 static const struct usb_device_id id_table[] = {
36 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
37 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
38 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
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 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
54 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
55 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
56 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
57 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
58 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
59 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
60 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
61 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
62 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
63 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
64 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
65 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
66 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
67 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
68 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
69 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
70 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
72 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
73 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
74 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
75 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
76 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
77 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
78 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
79 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
80 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
81 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
82 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
83 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
84 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
85 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
86 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
87 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
88 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
89 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
90 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
91 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
92 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
93 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
94 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
95 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
96 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
98 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
102 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
103 { USB_DEVICE(HP_VENDOR_ID, HP_LM930_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
105 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
106 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
107 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
108 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
109 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
110 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
111 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
112 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
113 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
114 { USB_DEVICE(IBM_VENDOR_ID, IBM_PRODUCT_ID) },
115 { } /* Terminating entry */
118 MODULE_DEVICE_TABLE(usb, id_table);
120 #define SET_LINE_REQUEST_TYPE 0x21
121 #define SET_LINE_REQUEST 0x20
123 #define SET_CONTROL_REQUEST_TYPE 0x21
124 #define SET_CONTROL_REQUEST 0x22
125 #define CONTROL_DTR 0x01
126 #define CONTROL_RTS 0x02
128 #define BREAK_REQUEST_TYPE 0x21
129 #define BREAK_REQUEST 0x23
130 #define BREAK_ON 0xffff
131 #define BREAK_OFF 0x0000
133 #define GET_LINE_REQUEST_TYPE 0xa1
134 #define GET_LINE_REQUEST 0x21
136 #define VENDOR_WRITE_REQUEST_TYPE 0x40
137 #define VENDOR_WRITE_REQUEST 0x01
139 #define VENDOR_READ_REQUEST_TYPE 0xc0
140 #define VENDOR_READ_REQUEST 0x01
142 #define UART_STATE_INDEX 8
143 #define UART_STATE_MSR_MASK 0x8b
144 #define UART_STATE_TRANSIENT_MASK 0x74
145 #define UART_DCD 0x01
146 #define UART_DSR 0x02
147 #define UART_BREAK_ERROR 0x04
148 #define UART_RING 0x08
149 #define UART_FRAME_ERROR 0x10
150 #define UART_PARITY_ERROR 0x20
151 #define UART_OVERRUN_ERROR 0x40
152 #define UART_CTS 0x80
154 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
157 TYPE_01, /* Type 0 and 1 (difference unknown) */
158 TYPE_HX, /* HX version of the pl2303 chip */
162 struct pl2303_type_data {
163 speed_t max_baud_rate;
164 unsigned long quirks;
167 struct pl2303_serial_private {
168 const struct pl2303_type_data *type;
169 unsigned long quirks;
172 struct pl2303_private {
180 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
182 .max_baud_rate = 1228800,
183 .quirks = PL2303_QUIRK_LEGACY,
186 .max_baud_rate = 12000000,
190 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
191 unsigned char buf[1])
193 struct device *dev = &serial->interface->dev;
196 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
197 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
198 value, 0, buf, 1, 100);
200 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
208 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
213 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
215 struct device *dev = &serial->interface->dev;
218 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
220 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
221 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
222 value, index, NULL, 0, 100);
224 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
232 static int pl2303_probe(struct usb_serial *serial,
233 const struct usb_device_id *id)
235 usb_set_serial_data(serial, (void *)id->driver_info);
241 * Use interrupt endpoint from first interface if available.
243 * This is needed due to the looney way its endpoints are set up.
245 static int pl2303_endpoint_hack(struct usb_serial *serial,
246 struct usb_serial_endpoints *epds)
248 struct usb_interface *interface = serial->interface;
249 struct usb_device *dev = serial->dev;
250 struct device *ddev = &interface->dev;
251 struct usb_host_interface *iface_desc;
252 struct usb_endpoint_descriptor *endpoint;
255 if (interface == dev->actconfig->interface[0])
258 /* check out the endpoints of the other interface */
259 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
261 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
262 endpoint = &iface_desc->endpoint[i].desc;
264 if (!usb_endpoint_is_int_in(endpoint))
267 dev_dbg(ddev, "found interrupt in on separate interface\n");
268 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
269 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
275 static int pl2303_calc_num_ports(struct usb_serial *serial,
276 struct usb_serial_endpoints *epds)
278 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
279 struct device *dev = &serial->interface->dev;
282 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
283 ret = pl2303_endpoint_hack(serial, epds);
288 if (epds->num_interrupt_in < 1) {
289 dev_err(dev, "required interrupt-in endpoint missing\n");
296 static int pl2303_startup(struct usb_serial *serial)
298 struct pl2303_serial_private *spriv;
299 enum pl2303_type type = TYPE_01;
302 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
306 buf = kmalloc(1, GFP_KERNEL);
312 if (serial->dev->descriptor.bDeviceClass == 0x02)
313 type = TYPE_01; /* type 0 */
314 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
316 else if (serial->dev->descriptor.bDeviceClass == 0x00)
317 type = TYPE_01; /* type 1 */
318 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
319 type = TYPE_01; /* type 1 */
320 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
322 spriv->type = &pl2303_type_data[type];
323 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
324 spriv->quirks |= spriv->type->quirks;
326 usb_set_serial_data(serial, spriv);
328 pl2303_vendor_read(serial, 0x8484, buf);
329 pl2303_vendor_write(serial, 0x0404, 0);
330 pl2303_vendor_read(serial, 0x8484, buf);
331 pl2303_vendor_read(serial, 0x8383, buf);
332 pl2303_vendor_read(serial, 0x8484, buf);
333 pl2303_vendor_write(serial, 0x0404, 1);
334 pl2303_vendor_read(serial, 0x8484, buf);
335 pl2303_vendor_read(serial, 0x8383, buf);
336 pl2303_vendor_write(serial, 0, 1);
337 pl2303_vendor_write(serial, 1, 0);
338 if (spriv->quirks & PL2303_QUIRK_LEGACY)
339 pl2303_vendor_write(serial, 2, 0x24);
341 pl2303_vendor_write(serial, 2, 0x44);
348 static void pl2303_release(struct usb_serial *serial)
350 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
355 static int pl2303_port_probe(struct usb_serial_port *port)
357 struct pl2303_private *priv;
359 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
363 spin_lock_init(&priv->lock);
365 usb_set_serial_port_data(port, priv);
367 port->port.drain_delay = 256;
372 static int pl2303_port_remove(struct usb_serial_port *port)
374 struct pl2303_private *priv = usb_get_serial_port_data(port);
381 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
383 struct usb_device *dev = port->serial->dev;
386 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
388 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
389 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
390 value, 0, NULL, 0, 100);
392 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
398 * Returns the nearest supported baud rate that can be set directly without
401 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
403 static const speed_t baud_sup[] = {
404 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
405 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
406 614400, 921600, 1228800, 2457600, 3000000, 6000000
411 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
412 if (baud_sup[i] > baud)
416 if (i == ARRAY_SIZE(baud_sup))
417 baud = baud_sup[i - 1];
418 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
419 baud = baud_sup[i - 1];
427 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
430 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
433 put_unaligned_le32(baud, buf);
438 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
441 unsigned int baseline, mantissa, exponent;
444 * Apparently the formula is:
445 * baudrate = 12M * 32 / (mantissa * 4^exponent)
447 * mantissa = buf[8:0]
448 * exponent = buf[11:9]
450 baseline = 12000000 * 32;
451 mantissa = baseline / baud;
453 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
455 while (mantissa >= 512) {
457 mantissa >>= 2; /* divide by 4 */
460 /* Exponent is maxed. Trim mantissa and leave. */
468 buf[1] = exponent << 1 | mantissa >> 8;
469 buf[0] = mantissa & 0xff;
471 /* Calculate and return the exact baud rate. */
472 baud = (baseline / mantissa) >> (exponent << 1);
477 static void pl2303_encode_baud_rate(struct tty_struct *tty,
478 struct usb_serial_port *port,
481 struct usb_serial *serial = port->serial;
482 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
486 baud = tty_get_baud_rate(tty);
487 dev_dbg(&port->dev, "baud requested = %u\n", baud);
491 if (spriv->type->max_baud_rate)
492 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
494 * Use direct method for supported baud rates, otherwise use divisors.
496 baud_sup = pl2303_get_supported_baud_rate(baud);
498 if (baud == baud_sup)
499 baud = pl2303_encode_baud_rate_direct(buf, baud);
501 baud = pl2303_encode_baud_rate_divisor(buf, baud);
503 /* Save resulting baud rate */
504 tty_encode_baud_rate(tty, baud, baud);
505 dev_dbg(&port->dev, "baud set = %u\n", baud);
508 static int pl2303_get_line_request(struct usb_serial_port *port,
509 unsigned char buf[7])
511 struct usb_device *udev = port->serial->dev;
514 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
515 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
518 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
526 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
531 static int pl2303_set_line_request(struct usb_serial_port *port,
532 unsigned char buf[7])
534 struct usb_device *udev = port->serial->dev;
537 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
538 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
541 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
545 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
550 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
554 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
555 a->c_cc[VSTART] != b->c_cc[VSTART] ||
556 a->c_cc[VSTOP] != b->c_cc[VSTOP];
558 return tty_termios_hw_change(a, b) || ixon_change;
561 static void pl2303_set_termios(struct tty_struct *tty,
562 struct usb_serial_port *port, struct ktermios *old_termios)
564 struct usb_serial *serial = port->serial;
565 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
566 struct pl2303_private *priv = usb_get_serial_port_data(port);
572 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
575 buf = kzalloc(7, GFP_KERNEL);
577 /* Report back no change occurred */
579 tty->termios = *old_termios;
583 pl2303_get_line_request(port, buf);
585 switch (C_CSIZE(tty)) {
599 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
601 /* For reference buf[0]:buf[3] baud rate value */
602 pl2303_encode_baud_rate(tty, port, &buf[0]);
604 /* For reference buf[4]=0 is 1 stop bits */
605 /* For reference buf[4]=1 is 1.5 stop bits */
606 /* For reference buf[4]=2 is 2 stop bits */
609 * NOTE: Comply with "real" UARTs / RS232:
610 * use 1.5 instead of 2 stop bits with 5 data bits
612 if (C_CSIZE(tty) == CS5) {
614 dev_dbg(&port->dev, "stop bits = 1.5\n");
617 dev_dbg(&port->dev, "stop bits = 2\n");
621 dev_dbg(&port->dev, "stop bits = 1\n");
625 /* For reference buf[5]=0 is none parity */
626 /* For reference buf[5]=1 is odd parity */
627 /* For reference buf[5]=2 is even parity */
628 /* For reference buf[5]=3 is mark parity */
629 /* For reference buf[5]=4 is space parity */
633 dev_dbg(&port->dev, "parity = mark\n");
636 dev_dbg(&port->dev, "parity = odd\n");
641 dev_dbg(&port->dev, "parity = space\n");
644 dev_dbg(&port->dev, "parity = even\n");
649 dev_dbg(&port->dev, "parity = none\n");
653 * Some PL2303 are known to lose bytes if you change serial settings
654 * even to the same values as before. Thus we actually need to filter
655 * in this specific case.
657 * Note that the tty_termios_hw_change check above is not sufficient
658 * as a previously requested baud rate may differ from the one
659 * actually used (and stored in old_termios).
661 * NOTE: No additional locking needed for line_settings as it is
662 * only used in set_termios, which is serialised against itself.
664 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
665 ret = pl2303_set_line_request(port, buf);
667 memcpy(priv->line_settings, buf, 7);
670 /* change control lines if we are switching to or from B0 */
671 spin_lock_irqsave(&priv->lock, flags);
672 control = priv->line_control;
673 if (C_BAUD(tty) == B0)
674 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
675 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
676 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
677 if (control != priv->line_control) {
678 control = priv->line_control;
679 spin_unlock_irqrestore(&priv->lock, flags);
680 pl2303_set_control_lines(port, control);
682 spin_unlock_irqrestore(&priv->lock, flags);
685 if (C_CRTSCTS(tty)) {
686 if (spriv->quirks & PL2303_QUIRK_LEGACY)
687 pl2303_vendor_write(serial, 0x0, 0x41);
689 pl2303_vendor_write(serial, 0x0, 0x61);
690 } else if (I_IXON(tty) && !I_IXANY(tty) && START_CHAR(tty) == 0x11 &&
691 STOP_CHAR(tty) == 0x13) {
692 pl2303_vendor_write(serial, 0x0, 0xc0);
694 pl2303_vendor_write(serial, 0x0, 0x0);
700 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
702 struct pl2303_private *priv = usb_get_serial_port_data(port);
706 spin_lock_irqsave(&priv->lock, flags);
708 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
710 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
711 control = priv->line_control;
712 spin_unlock_irqrestore(&priv->lock, flags);
714 pl2303_set_control_lines(port, control);
717 static void pl2303_close(struct usb_serial_port *port)
719 usb_serial_generic_close(port);
720 usb_kill_urb(port->interrupt_in_urb);
721 pl2303_set_break(port, false);
724 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
726 struct usb_serial *serial = port->serial;
727 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
730 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
731 usb_clear_halt(serial->dev, port->write_urb->pipe);
732 usb_clear_halt(serial->dev, port->read_urb->pipe);
734 /* reset upstream data pipes */
735 pl2303_vendor_write(serial, 8, 0);
736 pl2303_vendor_write(serial, 9, 0);
741 pl2303_set_termios(tty, port, NULL);
743 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
745 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
750 result = usb_serial_generic_open(tty, port);
752 usb_kill_urb(port->interrupt_in_urb);
759 static int pl2303_tiocmset(struct tty_struct *tty,
760 unsigned int set, unsigned int clear)
762 struct usb_serial_port *port = tty->driver_data;
763 struct pl2303_private *priv = usb_get_serial_port_data(port);
768 spin_lock_irqsave(&priv->lock, flags);
770 priv->line_control |= CONTROL_RTS;
772 priv->line_control |= CONTROL_DTR;
773 if (clear & TIOCM_RTS)
774 priv->line_control &= ~CONTROL_RTS;
775 if (clear & TIOCM_DTR)
776 priv->line_control &= ~CONTROL_DTR;
777 control = priv->line_control;
778 spin_unlock_irqrestore(&priv->lock, flags);
780 ret = pl2303_set_control_lines(port, control);
782 return usb_translate_errors(ret);
787 static int pl2303_tiocmget(struct tty_struct *tty)
789 struct usb_serial_port *port = tty->driver_data;
790 struct pl2303_private *priv = usb_get_serial_port_data(port);
796 spin_lock_irqsave(&priv->lock, flags);
797 mcr = priv->line_control;
798 status = priv->line_status;
799 spin_unlock_irqrestore(&priv->lock, flags);
801 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
802 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
803 | ((status & UART_CTS) ? TIOCM_CTS : 0)
804 | ((status & UART_DSR) ? TIOCM_DSR : 0)
805 | ((status & UART_RING) ? TIOCM_RI : 0)
806 | ((status & UART_DCD) ? TIOCM_CD : 0);
808 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
813 static int pl2303_carrier_raised(struct usb_serial_port *port)
815 struct pl2303_private *priv = usb_get_serial_port_data(port);
817 if (priv->line_status & UART_DCD)
823 static int pl2303_ioctl(struct tty_struct *tty,
824 unsigned int cmd, unsigned long arg)
826 struct serial_struct ser;
827 struct usb_serial_port *port = tty->driver_data;
831 memset(&ser, 0, sizeof ser);
832 ser.type = PORT_16654;
833 ser.line = port->minor;
834 ser.port = port->port_number;
835 ser.baud_base = 460800;
837 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
848 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
850 struct usb_serial *serial = port->serial;
859 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
860 state == BREAK_OFF ? "off" : "on");
862 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
863 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
866 dev_err(&port->dev, "error sending break = %d\n", result);
869 static void pl2303_break_ctl(struct tty_struct *tty, int state)
871 struct usb_serial_port *port = tty->driver_data;
873 pl2303_set_break(port, state);
876 static void pl2303_update_line_status(struct usb_serial_port *port,
878 unsigned int actual_length)
880 struct usb_serial *serial = port->serial;
881 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
882 struct pl2303_private *priv = usb_get_serial_port_data(port);
883 struct tty_struct *tty;
885 unsigned int status_idx = UART_STATE_INDEX;
889 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
892 if (actual_length < status_idx + 1)
895 status = data[status_idx];
897 /* Save off the uart status for others to look at */
898 spin_lock_irqsave(&priv->lock, flags);
899 delta = priv->line_status ^ status;
900 priv->line_status = status;
901 spin_unlock_irqrestore(&priv->lock, flags);
903 if (status & UART_BREAK_ERROR)
904 usb_serial_handle_break(port);
906 if (delta & UART_STATE_MSR_MASK) {
907 if (delta & UART_CTS)
909 if (delta & UART_DSR)
911 if (delta & UART_RING)
913 if (delta & UART_DCD) {
915 tty = tty_port_tty_get(&port->port);
917 usb_serial_handle_dcd_change(port, tty,
923 wake_up_interruptible(&port->port.delta_msr_wait);
927 static void pl2303_read_int_callback(struct urb *urb)
929 struct usb_serial_port *port = urb->context;
930 unsigned char *data = urb->transfer_buffer;
931 unsigned int actual_length = urb->actual_length;
932 int status = urb->status;
942 /* this urb is terminated, clean up */
943 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
947 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
952 usb_serial_debug_data(&port->dev, __func__,
953 urb->actual_length, urb->transfer_buffer);
955 pl2303_update_line_status(port, data, actual_length);
958 retval = usb_submit_urb(urb, GFP_ATOMIC);
961 "%s - usb_submit_urb failed with result %d\n",
966 static void pl2303_process_read_urb(struct urb *urb)
968 struct usb_serial_port *port = urb->context;
969 struct pl2303_private *priv = usb_get_serial_port_data(port);
970 unsigned char *data = urb->transfer_buffer;
971 char tty_flag = TTY_NORMAL;
976 /* update line status */
977 spin_lock_irqsave(&priv->lock, flags);
978 line_status = priv->line_status;
979 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
980 spin_unlock_irqrestore(&priv->lock, flags);
982 if (!urb->actual_length)
986 * Break takes precedence over parity, which takes precedence over
989 if (line_status & UART_BREAK_ERROR)
990 tty_flag = TTY_BREAK;
991 else if (line_status & UART_PARITY_ERROR)
992 tty_flag = TTY_PARITY;
993 else if (line_status & UART_FRAME_ERROR)
994 tty_flag = TTY_FRAME;
996 if (tty_flag != TTY_NORMAL)
997 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
999 /* overrun is special, not associated with a char */
1000 if (line_status & UART_OVERRUN_ERROR)
1001 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
1003 if (port->port.console && port->sysrq) {
1004 for (i = 0; i < urb->actual_length; ++i)
1005 if (!usb_serial_handle_sysrq_char(port, data[i]))
1006 tty_insert_flip_char(&port->port, data[i],
1009 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1010 urb->actual_length);
1013 tty_flip_buffer_push(&port->port);
1016 static struct usb_serial_driver pl2303_device = {
1018 .owner = THIS_MODULE,
1021 .id_table = id_table,
1024 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1025 .bulk_in_size = 256,
1026 .bulk_out_size = 256,
1027 .open = pl2303_open,
1028 .close = pl2303_close,
1029 .dtr_rts = pl2303_dtr_rts,
1030 .carrier_raised = pl2303_carrier_raised,
1031 .ioctl = pl2303_ioctl,
1032 .break_ctl = pl2303_break_ctl,
1033 .set_termios = pl2303_set_termios,
1034 .tiocmget = pl2303_tiocmget,
1035 .tiocmset = pl2303_tiocmset,
1036 .tiocmiwait = usb_serial_generic_tiocmiwait,
1037 .process_read_urb = pl2303_process_read_urb,
1038 .read_int_callback = pl2303_read_int_callback,
1039 .probe = pl2303_probe,
1040 .calc_num_ports = pl2303_calc_num_ports,
1041 .attach = pl2303_startup,
1042 .release = pl2303_release,
1043 .port_probe = pl2303_port_probe,
1044 .port_remove = pl2303_port_remove,
1047 static struct usb_serial_driver * const serial_drivers[] = {
1048 &pl2303_device, NULL
1051 module_usb_serial_driver(serial_drivers, id_table);
1053 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1054 MODULE_LICENSE("GPL v2");