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.rst 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(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GC) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GB) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GT) },
53 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GL) },
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GE) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GS) },
56 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
57 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
58 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
59 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
60 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
61 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
62 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
63 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
64 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
65 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
66 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
67 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
68 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
69 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
70 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
71 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
72 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
73 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
74 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
75 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
76 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
77 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
78 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
80 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
81 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
82 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
83 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
84 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
85 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
86 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
87 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
88 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
89 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
90 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
91 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
92 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
93 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
94 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
95 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
96 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
97 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
98 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
99 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
102 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
103 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
105 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
106 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
107 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
108 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
109 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
110 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
111 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
112 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
113 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
114 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
115 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
116 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
117 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
118 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
119 { } /* Terminating entry */
122 MODULE_DEVICE_TABLE(usb, id_table);
124 #define SET_LINE_REQUEST_TYPE 0x21
125 #define SET_LINE_REQUEST 0x20
127 #define SET_CONTROL_REQUEST_TYPE 0x21
128 #define SET_CONTROL_REQUEST 0x22
129 #define CONTROL_DTR 0x01
130 #define CONTROL_RTS 0x02
132 #define BREAK_REQUEST_TYPE 0x21
133 #define BREAK_REQUEST 0x23
134 #define BREAK_ON 0xffff
135 #define BREAK_OFF 0x0000
137 #define GET_LINE_REQUEST_TYPE 0xa1
138 #define GET_LINE_REQUEST 0x21
140 #define VENDOR_WRITE_REQUEST_TYPE 0x40
141 #define VENDOR_WRITE_REQUEST 0x01
142 #define VENDOR_WRITE_NREQUEST 0x80
144 #define VENDOR_READ_REQUEST_TYPE 0xc0
145 #define VENDOR_READ_REQUEST 0x01
146 #define VENDOR_READ_NREQUEST 0x81
148 #define UART_STATE_INDEX 8
149 #define UART_STATE_MSR_MASK 0x8b
150 #define UART_STATE_TRANSIENT_MASK 0x74
151 #define UART_DCD 0x01
152 #define UART_DSR 0x02
153 #define UART_BREAK_ERROR 0x04
154 #define UART_RING 0x08
155 #define UART_FRAME_ERROR 0x10
156 #define UART_PARITY_ERROR 0x20
157 #define UART_OVERRUN_ERROR 0x40
158 #define UART_CTS 0x80
160 #define PL2303_FLOWCTRL_MASK 0xf0
162 #define PL2303_READ_TYPE_HX_STATUS 0x8080
164 #define PL2303_HXN_RESET_REG 0x07
165 #define PL2303_HXN_RESET_UPSTREAM_PIPE 0x02
166 #define PL2303_HXN_RESET_DOWNSTREAM_PIPE 0x01
168 #define PL2303_HXN_FLOWCTRL_REG 0x0a
169 #define PL2303_HXN_FLOWCTRL_MASK 0x1c
170 #define PL2303_HXN_FLOWCTRL_NONE 0x1c
171 #define PL2303_HXN_FLOWCTRL_RTS_CTS 0x18
172 #define PL2303_HXN_FLOWCTRL_XON_XOFF 0x0c
174 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
186 struct pl2303_type_data {
188 speed_t max_baud_rate;
189 unsigned long quirks;
190 unsigned int no_autoxonxoff:1;
191 unsigned int no_divisors:1;
192 unsigned int alt_divisors:1;
195 struct pl2303_serial_private {
196 const struct pl2303_type_data *type;
197 unsigned long quirks;
200 struct pl2303_private {
208 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
211 .max_baud_rate = 1228800,
212 .quirks = PL2303_QUIRK_LEGACY,
213 .no_autoxonxoff = true,
217 .max_baud_rate = 6000000,
221 .max_baud_rate = 6000000,
222 .alt_divisors = true,
226 .max_baud_rate = 12000000,
227 .alt_divisors = true,
231 .max_baud_rate = 12000000,
235 .max_baud_rate = 12000000,
240 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
241 unsigned char buf[1])
243 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
244 struct device *dev = &serial->interface->dev;
248 if (spriv->type == &pl2303_type_data[TYPE_HXN])
249 request = VENDOR_READ_NREQUEST;
251 request = VENDOR_READ_REQUEST;
253 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
254 request, VENDOR_READ_REQUEST_TYPE,
255 value, 0, buf, 1, 100);
257 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
265 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
270 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
272 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
273 struct device *dev = &serial->interface->dev;
277 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
279 if (spriv->type == &pl2303_type_data[TYPE_HXN])
280 request = VENDOR_WRITE_NREQUEST;
282 request = VENDOR_WRITE_REQUEST;
284 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
285 request, VENDOR_WRITE_REQUEST_TYPE,
286 value, index, NULL, 0, 100);
288 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
296 static int pl2303_update_reg(struct usb_serial *serial, u8 reg, u8 mask, u8 val)
298 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
302 buf = kmalloc(1, GFP_KERNEL);
306 if (spriv->type == &pl2303_type_data[TYPE_HXN])
307 ret = pl2303_vendor_read(serial, reg, buf);
309 ret = pl2303_vendor_read(serial, reg | 0x80, buf);
317 ret = pl2303_vendor_write(serial, reg, *buf);
324 static int pl2303_probe(struct usb_serial *serial,
325 const struct usb_device_id *id)
327 usb_set_serial_data(serial, (void *)id->driver_info);
333 * Use interrupt endpoint from first interface if available.
335 * This is needed due to the looney way its endpoints are set up.
337 static int pl2303_endpoint_hack(struct usb_serial *serial,
338 struct usb_serial_endpoints *epds)
340 struct usb_interface *interface = serial->interface;
341 struct usb_device *dev = serial->dev;
342 struct device *ddev = &interface->dev;
343 struct usb_host_interface *iface_desc;
344 struct usb_endpoint_descriptor *endpoint;
347 if (interface == dev->actconfig->interface[0])
350 /* check out the endpoints of the other interface */
351 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
353 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
354 endpoint = &iface_desc->endpoint[i].desc;
356 if (!usb_endpoint_is_int_in(endpoint))
359 dev_dbg(ddev, "found interrupt in on separate interface\n");
360 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
361 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
367 static int pl2303_calc_num_ports(struct usb_serial *serial,
368 struct usb_serial_endpoints *epds)
370 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
371 struct device *dev = &serial->interface->dev;
374 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
375 ret = pl2303_endpoint_hack(serial, epds);
380 if (epds->num_interrupt_in < 1) {
381 dev_err(dev, "required interrupt-in endpoint missing\n");
388 static bool pl2303_supports_hx_status(struct usb_serial *serial)
393 ret = usb_control_msg_recv(serial->dev, 0, VENDOR_READ_REQUEST,
394 VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS,
395 0, &buf, 1, 100, GFP_KERNEL);
400 static int pl2303_detect_type(struct usb_serial *serial)
402 struct usb_device_descriptor *desc = &serial->dev->descriptor;
403 u16 bcdDevice, bcdUSB;
406 * Legacy PL2303H, variants 0 and 1 (difference unknown).
408 if (desc->bDeviceClass == 0x02)
409 return TYPE_H; /* variant 0 */
411 if (desc->bMaxPacketSize0 != 0x40) {
412 if (desc->bDeviceClass == 0x00 || desc->bDeviceClass == 0xff)
413 return TYPE_H; /* variant 1 */
415 return TYPE_H; /* variant 0 */
418 bcdDevice = le16_to_cpu(desc->bcdDevice);
419 bcdUSB = le16_to_cpu(desc->bcdUSB);
438 * Assume it's an HXN-type if the device doesn't
439 * support the old read request value.
441 if (!pl2303_supports_hx_status(serial))
452 dev_err(&serial->interface->dev,
453 "unknown device type, please report to linux-usb@vger.kernel.org\n");
457 static int pl2303_startup(struct usb_serial *serial)
459 struct pl2303_serial_private *spriv;
460 enum pl2303_type type;
464 ret = pl2303_detect_type(serial);
469 dev_dbg(&serial->interface->dev, "device type: %s\n", pl2303_type_data[type].name);
471 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
475 spriv->type = &pl2303_type_data[type];
476 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
477 spriv->quirks |= spriv->type->quirks;
479 usb_set_serial_data(serial, spriv);
481 if (type != TYPE_HXN) {
482 buf = kmalloc(1, GFP_KERNEL);
488 pl2303_vendor_read(serial, 0x8484, buf);
489 pl2303_vendor_write(serial, 0x0404, 0);
490 pl2303_vendor_read(serial, 0x8484, buf);
491 pl2303_vendor_read(serial, 0x8383, buf);
492 pl2303_vendor_read(serial, 0x8484, buf);
493 pl2303_vendor_write(serial, 0x0404, 1);
494 pl2303_vendor_read(serial, 0x8484, buf);
495 pl2303_vendor_read(serial, 0x8383, buf);
496 pl2303_vendor_write(serial, 0, 1);
497 pl2303_vendor_write(serial, 1, 0);
498 if (spriv->quirks & PL2303_QUIRK_LEGACY)
499 pl2303_vendor_write(serial, 2, 0x24);
501 pl2303_vendor_write(serial, 2, 0x44);
509 static void pl2303_release(struct usb_serial *serial)
511 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
516 static int pl2303_port_probe(struct usb_serial_port *port)
518 struct pl2303_private *priv;
520 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
524 spin_lock_init(&priv->lock);
526 usb_set_serial_port_data(port, priv);
528 port->port.drain_delay = 256;
533 static void pl2303_port_remove(struct usb_serial_port *port)
535 struct pl2303_private *priv = usb_get_serial_port_data(port);
540 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
542 struct usb_device *dev = port->serial->dev;
545 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
547 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
548 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
549 value, 0, NULL, 0, 100);
551 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
557 * Returns the nearest supported baud rate that can be set directly without
560 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
562 static const speed_t baud_sup[] = {
563 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
564 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
565 614400, 921600, 1228800, 2457600, 3000000, 6000000
570 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
571 if (baud_sup[i] > baud)
575 if (i == ARRAY_SIZE(baud_sup))
576 baud = baud_sup[i - 1];
577 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
578 baud = baud_sup[i - 1];
586 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
589 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
592 put_unaligned_le32(baud, buf);
597 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
600 unsigned int baseline, mantissa, exponent;
603 * Apparently the formula is:
604 * baudrate = 12M * 32 / (mantissa * 4^exponent)
606 * mantissa = buf[8:0]
607 * exponent = buf[11:9]
609 baseline = 12000000 * 32;
610 mantissa = baseline / baud;
612 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
614 while (mantissa >= 512) {
616 mantissa >>= 2; /* divide by 4 */
619 /* Exponent is maxed. Trim mantissa and leave. */
627 buf[1] = exponent << 1 | mantissa >> 8;
628 buf[0] = mantissa & 0xff;
630 /* Calculate and return the exact baud rate. */
631 baud = (baseline / mantissa) >> (exponent << 1);
636 static speed_t pl2303_encode_baud_rate_divisor_alt(unsigned char buf[4],
639 unsigned int baseline, mantissa, exponent;
642 * Apparently, for the TA version the formula is:
643 * baudrate = 12M * 32 / (mantissa * 2^exponent)
645 * mantissa = buf[10:0]
646 * exponent = buf[15:13 16]
648 baseline = 12000000 * 32;
649 mantissa = baseline / baud;
651 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
653 while (mantissa >= 2048) {
655 mantissa >>= 1; /* divide by 2 */
658 /* Exponent is maxed. Trim mantissa and leave. */
665 buf[2] = exponent & 0x01;
666 buf[1] = (exponent & ~0x01) << 4 | mantissa >> 8;
667 buf[0] = mantissa & 0xff;
669 /* Calculate and return the exact baud rate. */
670 baud = (baseline / mantissa) >> exponent;
675 static void pl2303_encode_baud_rate(struct tty_struct *tty,
676 struct usb_serial_port *port,
679 struct usb_serial *serial = port->serial;
680 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
684 baud = tty_get_baud_rate(tty);
685 dev_dbg(&port->dev, "baud requested = %u\n", baud);
689 if (spriv->type->max_baud_rate)
690 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
692 * Use direct method for supported baud rates, otherwise use divisors.
693 * Newer chip types do not support divisor encoding.
695 if (spriv->type->no_divisors)
698 baud_sup = pl2303_get_supported_baud_rate(baud);
700 if (baud == baud_sup)
701 baud = pl2303_encode_baud_rate_direct(buf, baud);
702 else if (spriv->type->alt_divisors)
703 baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
705 baud = pl2303_encode_baud_rate_divisor(buf, baud);
707 /* Save resulting baud rate */
708 tty_encode_baud_rate(tty, baud, baud);
709 dev_dbg(&port->dev, "baud set = %u\n", baud);
712 static int pl2303_get_line_request(struct usb_serial_port *port,
713 unsigned char buf[7])
715 struct usb_device *udev = port->serial->dev;
718 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
719 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
722 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
730 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
735 static int pl2303_set_line_request(struct usb_serial_port *port,
736 unsigned char buf[7])
738 struct usb_device *udev = port->serial->dev;
741 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
742 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
745 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
749 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
754 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
758 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
759 a->c_cc[VSTART] != b->c_cc[VSTART] ||
760 a->c_cc[VSTOP] != b->c_cc[VSTOP];
762 return tty_termios_hw_change(a, b) || ixon_change;
765 static bool pl2303_enable_xonxoff(struct tty_struct *tty, const struct pl2303_type_data *type)
767 if (!I_IXON(tty) || I_IXANY(tty))
770 if (START_CHAR(tty) != 0x11 || STOP_CHAR(tty) != 0x13)
773 if (type->no_autoxonxoff)
779 static void pl2303_set_termios(struct tty_struct *tty,
780 struct usb_serial_port *port, struct ktermios *old_termios)
782 struct usb_serial *serial = port->serial;
783 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
784 struct pl2303_private *priv = usb_get_serial_port_data(port);
790 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
793 buf = kzalloc(7, GFP_KERNEL);
795 /* Report back no change occurred */
797 tty->termios = *old_termios;
801 pl2303_get_line_request(port, buf);
803 buf[6] = tty_get_char_size(tty->termios.c_cflag);
804 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
806 /* For reference buf[0]:buf[3] baud rate value */
807 pl2303_encode_baud_rate(tty, port, &buf[0]);
809 /* For reference buf[4]=0 is 1 stop bits */
810 /* For reference buf[4]=1 is 1.5 stop bits */
811 /* For reference buf[4]=2 is 2 stop bits */
814 * NOTE: Comply with "real" UARTs / RS232:
815 * use 1.5 instead of 2 stop bits with 5 data bits
817 if (C_CSIZE(tty) == CS5) {
819 dev_dbg(&port->dev, "stop bits = 1.5\n");
822 dev_dbg(&port->dev, "stop bits = 2\n");
826 dev_dbg(&port->dev, "stop bits = 1\n");
830 /* For reference buf[5]=0 is none parity */
831 /* For reference buf[5]=1 is odd parity */
832 /* For reference buf[5]=2 is even parity */
833 /* For reference buf[5]=3 is mark parity */
834 /* For reference buf[5]=4 is space parity */
838 dev_dbg(&port->dev, "parity = mark\n");
841 dev_dbg(&port->dev, "parity = odd\n");
846 dev_dbg(&port->dev, "parity = space\n");
849 dev_dbg(&port->dev, "parity = even\n");
854 dev_dbg(&port->dev, "parity = none\n");
858 * Some PL2303 are known to lose bytes if you change serial settings
859 * even to the same values as before. Thus we actually need to filter
860 * in this specific case.
862 * Note that the tty_termios_hw_change check above is not sufficient
863 * as a previously requested baud rate may differ from the one
864 * actually used (and stored in old_termios).
866 * NOTE: No additional locking needed for line_settings as it is
867 * only used in set_termios, which is serialised against itself.
869 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
870 ret = pl2303_set_line_request(port, buf);
872 memcpy(priv->line_settings, buf, 7);
875 /* change control lines if we are switching to or from B0 */
876 spin_lock_irqsave(&priv->lock, flags);
877 control = priv->line_control;
878 if (C_BAUD(tty) == B0)
879 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
880 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
881 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
882 if (control != priv->line_control) {
883 control = priv->line_control;
884 spin_unlock_irqrestore(&priv->lock, flags);
885 pl2303_set_control_lines(port, control);
887 spin_unlock_irqrestore(&priv->lock, flags);
890 if (C_CRTSCTS(tty)) {
891 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
892 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x40);
893 } else if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
894 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
895 PL2303_HXN_FLOWCTRL_MASK,
896 PL2303_HXN_FLOWCTRL_RTS_CTS);
898 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x60);
900 } else if (pl2303_enable_xonxoff(tty, spriv->type)) {
901 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
902 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
903 PL2303_HXN_FLOWCTRL_MASK,
904 PL2303_HXN_FLOWCTRL_XON_XOFF);
906 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0xc0);
909 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
910 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
911 PL2303_HXN_FLOWCTRL_MASK,
912 PL2303_HXN_FLOWCTRL_NONE);
914 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0);
921 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
923 struct pl2303_private *priv = usb_get_serial_port_data(port);
927 spin_lock_irqsave(&priv->lock, flags);
929 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
931 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
932 control = priv->line_control;
933 spin_unlock_irqrestore(&priv->lock, flags);
935 pl2303_set_control_lines(port, control);
938 static void pl2303_close(struct usb_serial_port *port)
940 usb_serial_generic_close(port);
941 usb_kill_urb(port->interrupt_in_urb);
942 pl2303_set_break(port, false);
945 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
947 struct usb_serial *serial = port->serial;
948 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
951 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
952 usb_clear_halt(serial->dev, port->write_urb->pipe);
953 usb_clear_halt(serial->dev, port->read_urb->pipe);
955 /* reset upstream data pipes */
956 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
957 pl2303_vendor_write(serial, PL2303_HXN_RESET_REG,
958 PL2303_HXN_RESET_UPSTREAM_PIPE |
959 PL2303_HXN_RESET_DOWNSTREAM_PIPE);
961 pl2303_vendor_write(serial, 8, 0);
962 pl2303_vendor_write(serial, 9, 0);
968 pl2303_set_termios(tty, port, NULL);
970 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
972 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
977 result = usb_serial_generic_open(tty, port);
979 usb_kill_urb(port->interrupt_in_urb);
986 static int pl2303_tiocmset(struct tty_struct *tty,
987 unsigned int set, unsigned int clear)
989 struct usb_serial_port *port = tty->driver_data;
990 struct pl2303_private *priv = usb_get_serial_port_data(port);
995 spin_lock_irqsave(&priv->lock, flags);
997 priv->line_control |= CONTROL_RTS;
999 priv->line_control |= CONTROL_DTR;
1000 if (clear & TIOCM_RTS)
1001 priv->line_control &= ~CONTROL_RTS;
1002 if (clear & TIOCM_DTR)
1003 priv->line_control &= ~CONTROL_DTR;
1004 control = priv->line_control;
1005 spin_unlock_irqrestore(&priv->lock, flags);
1007 ret = pl2303_set_control_lines(port, control);
1009 return usb_translate_errors(ret);
1014 static int pl2303_tiocmget(struct tty_struct *tty)
1016 struct usb_serial_port *port = tty->driver_data;
1017 struct pl2303_private *priv = usb_get_serial_port_data(port);
1018 unsigned long flags;
1020 unsigned int status;
1021 unsigned int result;
1023 spin_lock_irqsave(&priv->lock, flags);
1024 mcr = priv->line_control;
1025 status = priv->line_status;
1026 spin_unlock_irqrestore(&priv->lock, flags);
1028 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
1029 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
1030 | ((status & UART_CTS) ? TIOCM_CTS : 0)
1031 | ((status & UART_DSR) ? TIOCM_DSR : 0)
1032 | ((status & UART_RING) ? TIOCM_RI : 0)
1033 | ((status & UART_DCD) ? TIOCM_CD : 0);
1035 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
1040 static int pl2303_carrier_raised(struct usb_serial_port *port)
1042 struct pl2303_private *priv = usb_get_serial_port_data(port);
1044 if (priv->line_status & UART_DCD)
1050 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
1052 struct usb_serial *serial = port->serial;
1061 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1062 state == BREAK_OFF ? "off" : "on");
1064 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1065 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
1068 dev_err(&port->dev, "error sending break = %d\n", result);
1071 static void pl2303_break_ctl(struct tty_struct *tty, int state)
1073 struct usb_serial_port *port = tty->driver_data;
1075 pl2303_set_break(port, state);
1078 static void pl2303_update_line_status(struct usb_serial_port *port,
1079 unsigned char *data,
1080 unsigned int actual_length)
1082 struct usb_serial *serial = port->serial;
1083 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
1084 struct pl2303_private *priv = usb_get_serial_port_data(port);
1085 struct tty_struct *tty;
1086 unsigned long flags;
1087 unsigned int status_idx = UART_STATE_INDEX;
1091 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
1094 if (actual_length < status_idx + 1)
1097 status = data[status_idx];
1099 /* Save off the uart status for others to look at */
1100 spin_lock_irqsave(&priv->lock, flags);
1101 delta = priv->line_status ^ status;
1102 priv->line_status = status;
1103 spin_unlock_irqrestore(&priv->lock, flags);
1105 if (status & UART_BREAK_ERROR)
1106 usb_serial_handle_break(port);
1108 if (delta & UART_STATE_MSR_MASK) {
1109 if (delta & UART_CTS)
1111 if (delta & UART_DSR)
1113 if (delta & UART_RING)
1115 if (delta & UART_DCD) {
1117 tty = tty_port_tty_get(&port->port);
1119 usb_serial_handle_dcd_change(port, tty,
1125 wake_up_interruptible(&port->port.delta_msr_wait);
1129 static void pl2303_read_int_callback(struct urb *urb)
1131 struct usb_serial_port *port = urb->context;
1132 unsigned char *data = urb->transfer_buffer;
1133 unsigned int actual_length = urb->actual_length;
1134 int status = urb->status;
1144 /* this urb is terminated, clean up */
1145 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
1149 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
1154 usb_serial_debug_data(&port->dev, __func__,
1155 urb->actual_length, urb->transfer_buffer);
1157 pl2303_update_line_status(port, data, actual_length);
1160 retval = usb_submit_urb(urb, GFP_ATOMIC);
1163 "%s - usb_submit_urb failed with result %d\n",
1168 static void pl2303_process_read_urb(struct urb *urb)
1170 struct usb_serial_port *port = urb->context;
1171 struct pl2303_private *priv = usb_get_serial_port_data(port);
1172 unsigned char *data = urb->transfer_buffer;
1173 char tty_flag = TTY_NORMAL;
1174 unsigned long flags;
1178 /* update line status */
1179 spin_lock_irqsave(&priv->lock, flags);
1180 line_status = priv->line_status;
1181 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1182 spin_unlock_irqrestore(&priv->lock, flags);
1184 if (!urb->actual_length)
1188 * Break takes precedence over parity, which takes precedence over
1191 if (line_status & UART_BREAK_ERROR)
1192 tty_flag = TTY_BREAK;
1193 else if (line_status & UART_PARITY_ERROR)
1194 tty_flag = TTY_PARITY;
1195 else if (line_status & UART_FRAME_ERROR)
1196 tty_flag = TTY_FRAME;
1198 if (tty_flag != TTY_NORMAL)
1199 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
1201 /* overrun is special, not associated with a char */
1202 if (line_status & UART_OVERRUN_ERROR)
1203 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
1206 for (i = 0; i < urb->actual_length; ++i)
1207 if (!usb_serial_handle_sysrq_char(port, data[i]))
1208 tty_insert_flip_char(&port->port, data[i],
1211 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1212 urb->actual_length);
1215 tty_flip_buffer_push(&port->port);
1218 static struct usb_serial_driver pl2303_device = {
1220 .owner = THIS_MODULE,
1223 .id_table = id_table,
1226 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1227 .bulk_in_size = 256,
1228 .bulk_out_size = 256,
1229 .open = pl2303_open,
1230 .close = pl2303_close,
1231 .dtr_rts = pl2303_dtr_rts,
1232 .carrier_raised = pl2303_carrier_raised,
1233 .break_ctl = pl2303_break_ctl,
1234 .set_termios = pl2303_set_termios,
1235 .tiocmget = pl2303_tiocmget,
1236 .tiocmset = pl2303_tiocmset,
1237 .tiocmiwait = usb_serial_generic_tiocmiwait,
1238 .process_read_urb = pl2303_process_read_urb,
1239 .read_int_callback = pl2303_read_int_callback,
1240 .probe = pl2303_probe,
1241 .calc_num_ports = pl2303_calc_num_ports,
1242 .attach = pl2303_startup,
1243 .release = pl2303_release,
1244 .port_probe = pl2303_port_probe,
1245 .port_remove = pl2303_port_remove,
1248 static struct usb_serial_driver * const serial_drivers[] = {
1249 &pl2303_device, NULL
1252 module_usb_serial_driver(serial_drivers, id_table);
1254 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1255 MODULE_LICENSE("GPL v2");