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_LM930_PRODUCT_ID) },
110 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
111 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
112 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
113 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
114 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
115 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
116 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
117 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
118 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
119 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
120 { USB_DEVICE(IBM_VENDOR_ID, IBM_PRODUCT_ID) },
121 { } /* Terminating entry */
124 MODULE_DEVICE_TABLE(usb, id_table);
126 #define SET_LINE_REQUEST_TYPE 0x21
127 #define SET_LINE_REQUEST 0x20
129 #define SET_CONTROL_REQUEST_TYPE 0x21
130 #define SET_CONTROL_REQUEST 0x22
131 #define CONTROL_DTR 0x01
132 #define CONTROL_RTS 0x02
134 #define BREAK_REQUEST_TYPE 0x21
135 #define BREAK_REQUEST 0x23
136 #define BREAK_ON 0xffff
137 #define BREAK_OFF 0x0000
139 #define GET_LINE_REQUEST_TYPE 0xa1
140 #define GET_LINE_REQUEST 0x21
142 #define VENDOR_WRITE_REQUEST_TYPE 0x40
143 #define VENDOR_WRITE_REQUEST 0x01
144 #define VENDOR_WRITE_NREQUEST 0x80
146 #define VENDOR_READ_REQUEST_TYPE 0xc0
147 #define VENDOR_READ_REQUEST 0x01
148 #define VENDOR_READ_NREQUEST 0x81
150 #define UART_STATE_INDEX 8
151 #define UART_STATE_MSR_MASK 0x8b
152 #define UART_STATE_TRANSIENT_MASK 0x74
153 #define UART_DCD 0x01
154 #define UART_DSR 0x02
155 #define UART_BREAK_ERROR 0x04
156 #define UART_RING 0x08
157 #define UART_FRAME_ERROR 0x10
158 #define UART_PARITY_ERROR 0x20
159 #define UART_OVERRUN_ERROR 0x40
160 #define UART_CTS 0x80
162 #define PL2303_FLOWCTRL_MASK 0xf0
164 #define PL2303_READ_TYPE_HX_STATUS 0x8080
166 #define PL2303_HXN_RESET_REG 0x07
167 #define PL2303_HXN_RESET_UPSTREAM_PIPE 0x02
168 #define PL2303_HXN_RESET_DOWNSTREAM_PIPE 0x01
170 #define PL2303_HXN_FLOWCTRL_REG 0x0a
171 #define PL2303_HXN_FLOWCTRL_MASK 0x1c
172 #define PL2303_HXN_FLOWCTRL_NONE 0x1c
173 #define PL2303_HXN_FLOWCTRL_RTS_CTS 0x18
174 #define PL2303_HXN_FLOWCTRL_XON_XOFF 0x0c
176 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
188 struct pl2303_type_data {
190 speed_t max_baud_rate;
191 unsigned long quirks;
192 unsigned int no_autoxonxoff:1;
193 unsigned int no_divisors:1;
194 unsigned int alt_divisors:1;
197 struct pl2303_serial_private {
198 const struct pl2303_type_data *type;
199 unsigned long quirks;
202 struct pl2303_private {
210 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
213 .max_baud_rate = 1228800,
214 .quirks = PL2303_QUIRK_LEGACY,
215 .no_autoxonxoff = true,
219 .max_baud_rate = 6000000,
223 .max_baud_rate = 6000000,
224 .alt_divisors = true,
228 .max_baud_rate = 12000000,
229 .alt_divisors = true,
233 .max_baud_rate = 12000000,
237 .max_baud_rate = 12000000,
242 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
243 unsigned char buf[1])
245 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
246 struct device *dev = &serial->interface->dev;
250 if (spriv->type == &pl2303_type_data[TYPE_HXN])
251 request = VENDOR_READ_NREQUEST;
253 request = VENDOR_READ_REQUEST;
255 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
256 request, VENDOR_READ_REQUEST_TYPE,
257 value, 0, buf, 1, 100);
259 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
267 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
272 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
274 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
275 struct device *dev = &serial->interface->dev;
279 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
281 if (spriv->type == &pl2303_type_data[TYPE_HXN])
282 request = VENDOR_WRITE_NREQUEST;
284 request = VENDOR_WRITE_REQUEST;
286 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
287 request, VENDOR_WRITE_REQUEST_TYPE,
288 value, index, NULL, 0, 100);
290 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
298 static int pl2303_update_reg(struct usb_serial *serial, u8 reg, u8 mask, u8 val)
300 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
304 buf = kmalloc(1, GFP_KERNEL);
308 if (spriv->type == &pl2303_type_data[TYPE_HXN])
309 ret = pl2303_vendor_read(serial, reg, buf);
311 ret = pl2303_vendor_read(serial, reg | 0x80, buf);
319 ret = pl2303_vendor_write(serial, reg, *buf);
326 static int pl2303_probe(struct usb_serial *serial,
327 const struct usb_device_id *id)
329 usb_set_serial_data(serial, (void *)id->driver_info);
335 * Use interrupt endpoint from first interface if available.
337 * This is needed due to the looney way its endpoints are set up.
339 static int pl2303_endpoint_hack(struct usb_serial *serial,
340 struct usb_serial_endpoints *epds)
342 struct usb_interface *interface = serial->interface;
343 struct usb_device *dev = serial->dev;
344 struct device *ddev = &interface->dev;
345 struct usb_host_interface *iface_desc;
346 struct usb_endpoint_descriptor *endpoint;
349 if (interface == dev->actconfig->interface[0])
352 /* check out the endpoints of the other interface */
353 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
355 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
356 endpoint = &iface_desc->endpoint[i].desc;
358 if (!usb_endpoint_is_int_in(endpoint))
361 dev_dbg(ddev, "found interrupt in on separate interface\n");
362 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
363 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
369 static int pl2303_calc_num_ports(struct usb_serial *serial,
370 struct usb_serial_endpoints *epds)
372 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
373 struct device *dev = &serial->interface->dev;
376 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
377 ret = pl2303_endpoint_hack(serial, epds);
382 if (epds->num_interrupt_in < 1) {
383 dev_err(dev, "required interrupt-in endpoint missing\n");
390 static bool pl2303_supports_hx_status(struct usb_serial *serial)
395 ret = usb_control_msg_recv(serial->dev, 0, VENDOR_READ_REQUEST,
396 VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS,
397 0, &buf, 1, 100, GFP_KERNEL);
402 static int pl2303_detect_type(struct usb_serial *serial)
404 struct usb_device_descriptor *desc = &serial->dev->descriptor;
405 u16 bcdDevice, bcdUSB;
408 * Legacy PL2303H, variants 0 and 1 (difference unknown).
410 if (desc->bDeviceClass == 0x02)
411 return TYPE_H; /* variant 0 */
413 if (desc->bMaxPacketSize0 != 0x40) {
414 if (desc->bDeviceClass == 0x00 || desc->bDeviceClass == 0xff)
415 return TYPE_H; /* variant 1 */
417 return TYPE_H; /* variant 0 */
420 bcdDevice = le16_to_cpu(desc->bcdDevice);
421 bcdUSB = le16_to_cpu(desc->bcdUSB);
425 /* USB 1.0.1? Let's assume they meant 1.1... */
442 case 0x300: /* GT / TA */
443 if (pl2303_supports_hx_status(serial))
450 case 0x500: /* GE / TB */
451 if (pl2303_supports_hx_status(serial))
464 dev_err(&serial->interface->dev,
465 "unknown device type, please report to linux-usb@vger.kernel.org\n");
469 static int pl2303_startup(struct usb_serial *serial)
471 struct pl2303_serial_private *spriv;
472 enum pl2303_type type;
476 ret = pl2303_detect_type(serial);
481 dev_dbg(&serial->interface->dev, "device type: %s\n", pl2303_type_data[type].name);
483 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
487 spriv->type = &pl2303_type_data[type];
488 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
489 spriv->quirks |= spriv->type->quirks;
491 usb_set_serial_data(serial, spriv);
493 if (type != TYPE_HXN) {
494 buf = kmalloc(1, GFP_KERNEL);
500 pl2303_vendor_read(serial, 0x8484, buf);
501 pl2303_vendor_write(serial, 0x0404, 0);
502 pl2303_vendor_read(serial, 0x8484, buf);
503 pl2303_vendor_read(serial, 0x8383, buf);
504 pl2303_vendor_read(serial, 0x8484, buf);
505 pl2303_vendor_write(serial, 0x0404, 1);
506 pl2303_vendor_read(serial, 0x8484, buf);
507 pl2303_vendor_read(serial, 0x8383, buf);
508 pl2303_vendor_write(serial, 0, 1);
509 pl2303_vendor_write(serial, 1, 0);
510 if (spriv->quirks & PL2303_QUIRK_LEGACY)
511 pl2303_vendor_write(serial, 2, 0x24);
513 pl2303_vendor_write(serial, 2, 0x44);
521 static void pl2303_release(struct usb_serial *serial)
523 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
528 static int pl2303_port_probe(struct usb_serial_port *port)
530 struct pl2303_private *priv;
532 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
536 spin_lock_init(&priv->lock);
538 usb_set_serial_port_data(port, priv);
540 port->port.drain_delay = 256;
545 static void pl2303_port_remove(struct usb_serial_port *port)
547 struct pl2303_private *priv = usb_get_serial_port_data(port);
552 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
554 struct usb_device *dev = port->serial->dev;
557 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
559 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
560 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
561 value, 0, NULL, 0, 100);
563 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
569 * Returns the nearest supported baud rate that can be set directly without
572 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
574 static const speed_t baud_sup[] = {
575 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
576 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
577 614400, 921600, 1228800, 2457600, 3000000, 6000000
582 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
583 if (baud_sup[i] > baud)
587 if (i == ARRAY_SIZE(baud_sup))
588 baud = baud_sup[i - 1];
589 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
590 baud = baud_sup[i - 1];
598 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
601 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
604 put_unaligned_le32(baud, buf);
609 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
612 unsigned int baseline, mantissa, exponent;
615 * Apparently the formula is:
616 * baudrate = 12M * 32 / (mantissa * 4^exponent)
618 * mantissa = buf[8:0]
619 * exponent = buf[11:9]
621 baseline = 12000000 * 32;
622 mantissa = baseline / baud;
624 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
626 while (mantissa >= 512) {
628 mantissa >>= 2; /* divide by 4 */
631 /* Exponent is maxed. Trim mantissa and leave. */
639 buf[1] = exponent << 1 | mantissa >> 8;
640 buf[0] = mantissa & 0xff;
642 /* Calculate and return the exact baud rate. */
643 baud = (baseline / mantissa) >> (exponent << 1);
648 static speed_t pl2303_encode_baud_rate_divisor_alt(unsigned char buf[4],
651 unsigned int baseline, mantissa, exponent;
654 * Apparently, for the TA version the formula is:
655 * baudrate = 12M * 32 / (mantissa * 2^exponent)
657 * mantissa = buf[10:0]
658 * exponent = buf[15:13 16]
660 baseline = 12000000 * 32;
661 mantissa = baseline / baud;
663 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
665 while (mantissa >= 2048) {
667 mantissa >>= 1; /* divide by 2 */
670 /* Exponent is maxed. Trim mantissa and leave. */
677 buf[2] = exponent & 0x01;
678 buf[1] = (exponent & ~0x01) << 4 | mantissa >> 8;
679 buf[0] = mantissa & 0xff;
681 /* Calculate and return the exact baud rate. */
682 baud = (baseline / mantissa) >> exponent;
687 static void pl2303_encode_baud_rate(struct tty_struct *tty,
688 struct usb_serial_port *port,
691 struct usb_serial *serial = port->serial;
692 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
696 baud = tty_get_baud_rate(tty);
697 dev_dbg(&port->dev, "baud requested = %u\n", baud);
701 if (spriv->type->max_baud_rate)
702 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
704 * Use direct method for supported baud rates, otherwise use divisors.
705 * Newer chip types do not support divisor encoding.
707 if (spriv->type->no_divisors)
710 baud_sup = pl2303_get_supported_baud_rate(baud);
712 if (baud == baud_sup)
713 baud = pl2303_encode_baud_rate_direct(buf, baud);
714 else if (spriv->type->alt_divisors)
715 baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
717 baud = pl2303_encode_baud_rate_divisor(buf, baud);
719 /* Save resulting baud rate */
720 tty_encode_baud_rate(tty, baud, baud);
721 dev_dbg(&port->dev, "baud set = %u\n", baud);
724 static int pl2303_get_line_request(struct usb_serial_port *port,
725 unsigned char buf[7])
727 struct usb_device *udev = port->serial->dev;
730 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
731 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
734 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
742 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
747 static int pl2303_set_line_request(struct usb_serial_port *port,
748 unsigned char buf[7])
750 struct usb_device *udev = port->serial->dev;
753 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
754 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
757 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
761 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
766 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
770 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
771 a->c_cc[VSTART] != b->c_cc[VSTART] ||
772 a->c_cc[VSTOP] != b->c_cc[VSTOP];
774 return tty_termios_hw_change(a, b) || ixon_change;
777 static bool pl2303_enable_xonxoff(struct tty_struct *tty, const struct pl2303_type_data *type)
779 if (!I_IXON(tty) || I_IXANY(tty))
782 if (START_CHAR(tty) != 0x11 || STOP_CHAR(tty) != 0x13)
785 if (type->no_autoxonxoff)
791 static void pl2303_set_termios(struct tty_struct *tty,
792 struct usb_serial_port *port, struct ktermios *old_termios)
794 struct usb_serial *serial = port->serial;
795 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
796 struct pl2303_private *priv = usb_get_serial_port_data(port);
802 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
805 buf = kzalloc(7, GFP_KERNEL);
807 /* Report back no change occurred */
809 tty->termios = *old_termios;
813 pl2303_get_line_request(port, buf);
815 buf[6] = tty_get_char_size(tty->termios.c_cflag);
816 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
818 /* For reference buf[0]:buf[3] baud rate value */
819 pl2303_encode_baud_rate(tty, port, &buf[0]);
821 /* For reference buf[4]=0 is 1 stop bits */
822 /* For reference buf[4]=1 is 1.5 stop bits */
823 /* For reference buf[4]=2 is 2 stop bits */
826 * NOTE: Comply with "real" UARTs / RS232:
827 * use 1.5 instead of 2 stop bits with 5 data bits
829 if (C_CSIZE(tty) == CS5) {
831 dev_dbg(&port->dev, "stop bits = 1.5\n");
834 dev_dbg(&port->dev, "stop bits = 2\n");
838 dev_dbg(&port->dev, "stop bits = 1\n");
842 /* For reference buf[5]=0 is none parity */
843 /* For reference buf[5]=1 is odd parity */
844 /* For reference buf[5]=2 is even parity */
845 /* For reference buf[5]=3 is mark parity */
846 /* For reference buf[5]=4 is space parity */
850 dev_dbg(&port->dev, "parity = mark\n");
853 dev_dbg(&port->dev, "parity = odd\n");
858 dev_dbg(&port->dev, "parity = space\n");
861 dev_dbg(&port->dev, "parity = even\n");
866 dev_dbg(&port->dev, "parity = none\n");
870 * Some PL2303 are known to lose bytes if you change serial settings
871 * even to the same values as before. Thus we actually need to filter
872 * in this specific case.
874 * Note that the tty_termios_hw_change check above is not sufficient
875 * as a previously requested baud rate may differ from the one
876 * actually used (and stored in old_termios).
878 * NOTE: No additional locking needed for line_settings as it is
879 * only used in set_termios, which is serialised against itself.
881 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
882 ret = pl2303_set_line_request(port, buf);
884 memcpy(priv->line_settings, buf, 7);
887 /* change control lines if we are switching to or from B0 */
888 spin_lock_irqsave(&priv->lock, flags);
889 control = priv->line_control;
890 if (C_BAUD(tty) == B0)
891 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
892 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
893 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
894 if (control != priv->line_control) {
895 control = priv->line_control;
896 spin_unlock_irqrestore(&priv->lock, flags);
897 pl2303_set_control_lines(port, control);
899 spin_unlock_irqrestore(&priv->lock, flags);
902 if (C_CRTSCTS(tty)) {
903 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
904 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x40);
905 } else if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
906 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
907 PL2303_HXN_FLOWCTRL_MASK,
908 PL2303_HXN_FLOWCTRL_RTS_CTS);
910 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x60);
912 } else if (pl2303_enable_xonxoff(tty, spriv->type)) {
913 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
914 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
915 PL2303_HXN_FLOWCTRL_MASK,
916 PL2303_HXN_FLOWCTRL_XON_XOFF);
918 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0xc0);
921 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
922 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
923 PL2303_HXN_FLOWCTRL_MASK,
924 PL2303_HXN_FLOWCTRL_NONE);
926 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0);
933 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
935 struct pl2303_private *priv = usb_get_serial_port_data(port);
939 spin_lock_irqsave(&priv->lock, flags);
941 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
943 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
944 control = priv->line_control;
945 spin_unlock_irqrestore(&priv->lock, flags);
947 pl2303_set_control_lines(port, control);
950 static void pl2303_close(struct usb_serial_port *port)
952 usb_serial_generic_close(port);
953 usb_kill_urb(port->interrupt_in_urb);
954 pl2303_set_break(port, false);
957 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
959 struct usb_serial *serial = port->serial;
960 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
963 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
964 usb_clear_halt(serial->dev, port->write_urb->pipe);
965 usb_clear_halt(serial->dev, port->read_urb->pipe);
967 /* reset upstream data pipes */
968 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
969 pl2303_vendor_write(serial, PL2303_HXN_RESET_REG,
970 PL2303_HXN_RESET_UPSTREAM_PIPE |
971 PL2303_HXN_RESET_DOWNSTREAM_PIPE);
973 pl2303_vendor_write(serial, 8, 0);
974 pl2303_vendor_write(serial, 9, 0);
980 pl2303_set_termios(tty, port, NULL);
982 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
984 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
989 result = usb_serial_generic_open(tty, port);
991 usb_kill_urb(port->interrupt_in_urb);
998 static int pl2303_tiocmset(struct tty_struct *tty,
999 unsigned int set, unsigned int clear)
1001 struct usb_serial_port *port = tty->driver_data;
1002 struct pl2303_private *priv = usb_get_serial_port_data(port);
1003 unsigned long flags;
1007 spin_lock_irqsave(&priv->lock, flags);
1008 if (set & TIOCM_RTS)
1009 priv->line_control |= CONTROL_RTS;
1010 if (set & TIOCM_DTR)
1011 priv->line_control |= CONTROL_DTR;
1012 if (clear & TIOCM_RTS)
1013 priv->line_control &= ~CONTROL_RTS;
1014 if (clear & TIOCM_DTR)
1015 priv->line_control &= ~CONTROL_DTR;
1016 control = priv->line_control;
1017 spin_unlock_irqrestore(&priv->lock, flags);
1019 ret = pl2303_set_control_lines(port, control);
1021 return usb_translate_errors(ret);
1026 static int pl2303_tiocmget(struct tty_struct *tty)
1028 struct usb_serial_port *port = tty->driver_data;
1029 struct pl2303_private *priv = usb_get_serial_port_data(port);
1030 unsigned long flags;
1032 unsigned int status;
1033 unsigned int result;
1035 spin_lock_irqsave(&priv->lock, flags);
1036 mcr = priv->line_control;
1037 status = priv->line_status;
1038 spin_unlock_irqrestore(&priv->lock, flags);
1040 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
1041 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
1042 | ((status & UART_CTS) ? TIOCM_CTS : 0)
1043 | ((status & UART_DSR) ? TIOCM_DSR : 0)
1044 | ((status & UART_RING) ? TIOCM_RI : 0)
1045 | ((status & UART_DCD) ? TIOCM_CD : 0);
1047 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
1052 static int pl2303_carrier_raised(struct usb_serial_port *port)
1054 struct pl2303_private *priv = usb_get_serial_port_data(port);
1056 if (priv->line_status & UART_DCD)
1062 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
1064 struct usb_serial *serial = port->serial;
1073 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1074 state == BREAK_OFF ? "off" : "on");
1076 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1077 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
1080 dev_err(&port->dev, "error sending break = %d\n", result);
1083 static void pl2303_break_ctl(struct tty_struct *tty, int state)
1085 struct usb_serial_port *port = tty->driver_data;
1087 pl2303_set_break(port, state);
1090 static void pl2303_update_line_status(struct usb_serial_port *port,
1091 unsigned char *data,
1092 unsigned int actual_length)
1094 struct usb_serial *serial = port->serial;
1095 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
1096 struct pl2303_private *priv = usb_get_serial_port_data(port);
1097 struct tty_struct *tty;
1098 unsigned long flags;
1099 unsigned int status_idx = UART_STATE_INDEX;
1103 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
1106 if (actual_length < status_idx + 1)
1109 status = data[status_idx];
1111 /* Save off the uart status for others to look at */
1112 spin_lock_irqsave(&priv->lock, flags);
1113 delta = priv->line_status ^ status;
1114 priv->line_status = status;
1115 spin_unlock_irqrestore(&priv->lock, flags);
1117 if (status & UART_BREAK_ERROR)
1118 usb_serial_handle_break(port);
1120 if (delta & UART_STATE_MSR_MASK) {
1121 if (delta & UART_CTS)
1123 if (delta & UART_DSR)
1125 if (delta & UART_RING)
1127 if (delta & UART_DCD) {
1129 tty = tty_port_tty_get(&port->port);
1131 usb_serial_handle_dcd_change(port, tty,
1137 wake_up_interruptible(&port->port.delta_msr_wait);
1141 static void pl2303_read_int_callback(struct urb *urb)
1143 struct usb_serial_port *port = urb->context;
1144 unsigned char *data = urb->transfer_buffer;
1145 unsigned int actual_length = urb->actual_length;
1146 int status = urb->status;
1156 /* this urb is terminated, clean up */
1157 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
1161 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
1166 usb_serial_debug_data(&port->dev, __func__,
1167 urb->actual_length, urb->transfer_buffer);
1169 pl2303_update_line_status(port, data, actual_length);
1172 retval = usb_submit_urb(urb, GFP_ATOMIC);
1175 "%s - usb_submit_urb failed with result %d\n",
1180 static void pl2303_process_read_urb(struct urb *urb)
1182 struct usb_serial_port *port = urb->context;
1183 struct pl2303_private *priv = usb_get_serial_port_data(port);
1184 unsigned char *data = urb->transfer_buffer;
1185 char tty_flag = TTY_NORMAL;
1186 unsigned long flags;
1190 /* update line status */
1191 spin_lock_irqsave(&priv->lock, flags);
1192 line_status = priv->line_status;
1193 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1194 spin_unlock_irqrestore(&priv->lock, flags);
1196 if (!urb->actual_length)
1200 * Break takes precedence over parity, which takes precedence over
1203 if (line_status & UART_BREAK_ERROR)
1204 tty_flag = TTY_BREAK;
1205 else if (line_status & UART_PARITY_ERROR)
1206 tty_flag = TTY_PARITY;
1207 else if (line_status & UART_FRAME_ERROR)
1208 tty_flag = TTY_FRAME;
1210 if (tty_flag != TTY_NORMAL)
1211 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
1213 /* overrun is special, not associated with a char */
1214 if (line_status & UART_OVERRUN_ERROR)
1215 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
1218 for (i = 0; i < urb->actual_length; ++i)
1219 if (!usb_serial_handle_sysrq_char(port, data[i]))
1220 tty_insert_flip_char(&port->port, data[i],
1223 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1224 urb->actual_length);
1227 tty_flip_buffer_push(&port->port);
1230 static struct usb_serial_driver pl2303_device = {
1232 .owner = THIS_MODULE,
1235 .id_table = id_table,
1238 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1239 .bulk_in_size = 256,
1240 .bulk_out_size = 256,
1241 .open = pl2303_open,
1242 .close = pl2303_close,
1243 .dtr_rts = pl2303_dtr_rts,
1244 .carrier_raised = pl2303_carrier_raised,
1245 .break_ctl = pl2303_break_ctl,
1246 .set_termios = pl2303_set_termios,
1247 .tiocmget = pl2303_tiocmget,
1248 .tiocmset = pl2303_tiocmset,
1249 .tiocmiwait = usb_serial_generic_tiocmiwait,
1250 .process_read_urb = pl2303_process_read_urb,
1251 .read_int_callback = pl2303_read_int_callback,
1252 .probe = pl2303_probe,
1253 .calc_num_ports = pl2303_calc_num_ports,
1254 .attach = pl2303_startup,
1255 .release = pl2303_release,
1256 .port_probe = pl2303_port_probe,
1257 .port_remove = pl2303_port_remove,
1260 static struct usb_serial_driver * const serial_drivers[] = {
1261 &pl2303_device, NULL
1264 module_usb_serial_driver(serial_drivers, id_table);
1266 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1267 MODULE_LICENSE("GPL v2");