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_LM940_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
105 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
106 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
107 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
108 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
109 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
110 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
111 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
112 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
113 { } /* Terminating entry */
116 MODULE_DEVICE_TABLE(usb, id_table);
118 #define SET_LINE_REQUEST_TYPE 0x21
119 #define SET_LINE_REQUEST 0x20
121 #define SET_CONTROL_REQUEST_TYPE 0x21
122 #define SET_CONTROL_REQUEST 0x22
123 #define CONTROL_DTR 0x01
124 #define CONTROL_RTS 0x02
126 #define BREAK_REQUEST_TYPE 0x21
127 #define BREAK_REQUEST 0x23
128 #define BREAK_ON 0xffff
129 #define BREAK_OFF 0x0000
131 #define GET_LINE_REQUEST_TYPE 0xa1
132 #define GET_LINE_REQUEST 0x21
134 #define VENDOR_WRITE_REQUEST_TYPE 0x40
135 #define VENDOR_WRITE_REQUEST 0x01
137 #define VENDOR_READ_REQUEST_TYPE 0xc0
138 #define VENDOR_READ_REQUEST 0x01
140 #define UART_STATE_INDEX 8
141 #define UART_STATE_MSR_MASK 0x8b
142 #define UART_STATE_TRANSIENT_MASK 0x74
143 #define UART_DCD 0x01
144 #define UART_DSR 0x02
145 #define UART_BREAK_ERROR 0x04
146 #define UART_RING 0x08
147 #define UART_FRAME_ERROR 0x10
148 #define UART_PARITY_ERROR 0x20
149 #define UART_OVERRUN_ERROR 0x40
150 #define UART_CTS 0x80
152 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
155 TYPE_01, /* Type 0 and 1 (difference unknown) */
156 TYPE_HX, /* HX version of the pl2303 chip */
160 struct pl2303_type_data {
161 speed_t max_baud_rate;
162 unsigned long quirks;
165 struct pl2303_serial_private {
166 const struct pl2303_type_data *type;
167 unsigned long quirks;
170 struct pl2303_private {
178 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
180 .max_baud_rate = 1228800,
181 .quirks = PL2303_QUIRK_LEGACY,
184 .max_baud_rate = 12000000,
188 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
189 unsigned char buf[1])
191 struct device *dev = &serial->interface->dev;
194 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
195 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
196 value, 0, buf, 1, 100);
198 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
206 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
211 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
213 struct device *dev = &serial->interface->dev;
216 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
218 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
219 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
220 value, index, NULL, 0, 100);
222 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
230 static int pl2303_probe(struct usb_serial *serial,
231 const struct usb_device_id *id)
233 usb_set_serial_data(serial, (void *)id->driver_info);
239 * Use interrupt endpoint from first interface if available.
241 * This is needed due to the looney way its endpoints are set up.
243 static int pl2303_endpoint_hack(struct usb_serial *serial,
244 struct usb_serial_endpoints *epds)
246 struct usb_interface *interface = serial->interface;
247 struct usb_device *dev = serial->dev;
248 struct device *ddev = &interface->dev;
249 struct usb_host_interface *iface_desc;
250 struct usb_endpoint_descriptor *endpoint;
253 if (interface == dev->actconfig->interface[0])
256 /* check out the endpoints of the other interface */
257 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
259 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
260 endpoint = &iface_desc->endpoint[i].desc;
262 if (!usb_endpoint_is_int_in(endpoint))
265 dev_dbg(ddev, "found interrupt in on separate interface\n");
266 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
267 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
273 static int pl2303_calc_num_ports(struct usb_serial *serial,
274 struct usb_serial_endpoints *epds)
276 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
277 struct device *dev = &serial->interface->dev;
280 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
281 ret = pl2303_endpoint_hack(serial, epds);
286 if (epds->num_interrupt_in < 1) {
287 dev_err(dev, "required interrupt-in endpoint missing\n");
294 static int pl2303_startup(struct usb_serial *serial)
296 struct pl2303_serial_private *spriv;
297 enum pl2303_type type = TYPE_01;
300 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
304 buf = kmalloc(1, GFP_KERNEL);
310 if (serial->dev->descriptor.bDeviceClass == 0x02)
311 type = TYPE_01; /* type 0 */
312 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
314 else if (serial->dev->descriptor.bDeviceClass == 0x00)
315 type = TYPE_01; /* type 1 */
316 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
317 type = TYPE_01; /* type 1 */
318 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
320 spriv->type = &pl2303_type_data[type];
321 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
322 spriv->quirks |= spriv->type->quirks;
324 usb_set_serial_data(serial, spriv);
326 pl2303_vendor_read(serial, 0x8484, buf);
327 pl2303_vendor_write(serial, 0x0404, 0);
328 pl2303_vendor_read(serial, 0x8484, buf);
329 pl2303_vendor_read(serial, 0x8383, buf);
330 pl2303_vendor_read(serial, 0x8484, buf);
331 pl2303_vendor_write(serial, 0x0404, 1);
332 pl2303_vendor_read(serial, 0x8484, buf);
333 pl2303_vendor_read(serial, 0x8383, buf);
334 pl2303_vendor_write(serial, 0, 1);
335 pl2303_vendor_write(serial, 1, 0);
336 if (spriv->quirks & PL2303_QUIRK_LEGACY)
337 pl2303_vendor_write(serial, 2, 0x24);
339 pl2303_vendor_write(serial, 2, 0x44);
346 static void pl2303_release(struct usb_serial *serial)
348 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
353 static int pl2303_port_probe(struct usb_serial_port *port)
355 struct pl2303_private *priv;
357 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
361 spin_lock_init(&priv->lock);
363 usb_set_serial_port_data(port, priv);
365 port->port.drain_delay = 256;
370 static int pl2303_port_remove(struct usb_serial_port *port)
372 struct pl2303_private *priv = usb_get_serial_port_data(port);
379 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
381 struct usb_device *dev = port->serial->dev;
384 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
386 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
387 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
388 value, 0, NULL, 0, 100);
390 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
396 * Returns the nearest supported baud rate that can be set directly without
399 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
401 static const speed_t baud_sup[] = {
402 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
403 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
404 614400, 921600, 1228800, 2457600, 3000000, 6000000
409 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
410 if (baud_sup[i] > baud)
414 if (i == ARRAY_SIZE(baud_sup))
415 baud = baud_sup[i - 1];
416 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
417 baud = baud_sup[i - 1];
425 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
428 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
431 put_unaligned_le32(baud, buf);
436 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
439 unsigned int baseline, mantissa, exponent;
442 * Apparently the formula is:
443 * baudrate = 12M * 32 / (mantissa * 4^exponent)
445 * mantissa = buf[8:0]
446 * exponent = buf[11:9]
448 baseline = 12000000 * 32;
449 mantissa = baseline / baud;
451 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
453 while (mantissa >= 512) {
455 mantissa >>= 2; /* divide by 4 */
458 /* Exponent is maxed. Trim mantissa and leave. */
466 buf[1] = exponent << 1 | mantissa >> 8;
467 buf[0] = mantissa & 0xff;
469 /* Calculate and return the exact baud rate. */
470 baud = (baseline / mantissa) >> (exponent << 1);
475 static void pl2303_encode_baud_rate(struct tty_struct *tty,
476 struct usb_serial_port *port,
479 struct usb_serial *serial = port->serial;
480 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
484 baud = tty_get_baud_rate(tty);
485 dev_dbg(&port->dev, "baud requested = %u\n", baud);
489 if (spriv->type->max_baud_rate)
490 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
492 * Use direct method for supported baud rates, otherwise use divisors.
494 baud_sup = pl2303_get_supported_baud_rate(baud);
496 if (baud == baud_sup)
497 baud = pl2303_encode_baud_rate_direct(buf, baud);
499 baud = pl2303_encode_baud_rate_divisor(buf, baud);
501 /* Save resulting baud rate */
502 tty_encode_baud_rate(tty, baud, baud);
503 dev_dbg(&port->dev, "baud set = %u\n", baud);
506 static int pl2303_get_line_request(struct usb_serial_port *port,
507 unsigned char buf[7])
509 struct usb_device *udev = port->serial->dev;
512 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
513 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
516 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
524 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
529 static int pl2303_set_line_request(struct usb_serial_port *port,
530 unsigned char buf[7])
532 struct usb_device *udev = port->serial->dev;
535 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
536 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
539 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
543 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
548 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
552 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
553 a->c_cc[VSTART] != b->c_cc[VSTART] ||
554 a->c_cc[VSTOP] != b->c_cc[VSTOP];
556 return tty_termios_hw_change(a, b) || ixon_change;
559 static void pl2303_set_termios(struct tty_struct *tty,
560 struct usb_serial_port *port, struct ktermios *old_termios)
562 struct usb_serial *serial = port->serial;
563 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
564 struct pl2303_private *priv = usb_get_serial_port_data(port);
570 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
573 buf = kzalloc(7, GFP_KERNEL);
575 /* Report back no change occurred */
577 tty->termios = *old_termios;
581 pl2303_get_line_request(port, buf);
583 switch (C_CSIZE(tty)) {
597 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
599 /* For reference buf[0]:buf[3] baud rate value */
600 pl2303_encode_baud_rate(tty, port, &buf[0]);
602 /* For reference buf[4]=0 is 1 stop bits */
603 /* For reference buf[4]=1 is 1.5 stop bits */
604 /* For reference buf[4]=2 is 2 stop bits */
607 * NOTE: Comply with "real" UARTs / RS232:
608 * use 1.5 instead of 2 stop bits with 5 data bits
610 if (C_CSIZE(tty) == CS5) {
612 dev_dbg(&port->dev, "stop bits = 1.5\n");
615 dev_dbg(&port->dev, "stop bits = 2\n");
619 dev_dbg(&port->dev, "stop bits = 1\n");
623 /* For reference buf[5]=0 is none parity */
624 /* For reference buf[5]=1 is odd parity */
625 /* For reference buf[5]=2 is even parity */
626 /* For reference buf[5]=3 is mark parity */
627 /* For reference buf[5]=4 is space parity */
631 dev_dbg(&port->dev, "parity = mark\n");
634 dev_dbg(&port->dev, "parity = odd\n");
639 dev_dbg(&port->dev, "parity = space\n");
642 dev_dbg(&port->dev, "parity = even\n");
647 dev_dbg(&port->dev, "parity = none\n");
651 * Some PL2303 are known to lose bytes if you change serial settings
652 * even to the same values as before. Thus we actually need to filter
653 * in this specific case.
655 * Note that the tty_termios_hw_change check above is not sufficient
656 * as a previously requested baud rate may differ from the one
657 * actually used (and stored in old_termios).
659 * NOTE: No additional locking needed for line_settings as it is
660 * only used in set_termios, which is serialised against itself.
662 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
663 ret = pl2303_set_line_request(port, buf);
665 memcpy(priv->line_settings, buf, 7);
668 /* change control lines if we are switching to or from B0 */
669 spin_lock_irqsave(&priv->lock, flags);
670 control = priv->line_control;
671 if (C_BAUD(tty) == B0)
672 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
673 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
674 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
675 if (control != priv->line_control) {
676 control = priv->line_control;
677 spin_unlock_irqrestore(&priv->lock, flags);
678 pl2303_set_control_lines(port, control);
680 spin_unlock_irqrestore(&priv->lock, flags);
683 if (C_CRTSCTS(tty)) {
684 if (spriv->quirks & PL2303_QUIRK_LEGACY)
685 pl2303_vendor_write(serial, 0x0, 0x41);
687 pl2303_vendor_write(serial, 0x0, 0x61);
688 } else if (I_IXON(tty) && !I_IXANY(tty) && START_CHAR(tty) == 0x11 &&
689 STOP_CHAR(tty) == 0x13) {
690 pl2303_vendor_write(serial, 0x0, 0xc0);
692 pl2303_vendor_write(serial, 0x0, 0x0);
698 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
700 struct pl2303_private *priv = usb_get_serial_port_data(port);
704 spin_lock_irqsave(&priv->lock, flags);
706 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
708 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
709 control = priv->line_control;
710 spin_unlock_irqrestore(&priv->lock, flags);
712 pl2303_set_control_lines(port, control);
715 static void pl2303_close(struct usb_serial_port *port)
717 usb_serial_generic_close(port);
718 usb_kill_urb(port->interrupt_in_urb);
719 pl2303_set_break(port, false);
722 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
724 struct usb_serial *serial = port->serial;
725 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
728 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
729 usb_clear_halt(serial->dev, port->write_urb->pipe);
730 usb_clear_halt(serial->dev, port->read_urb->pipe);
732 /* reset upstream data pipes */
733 pl2303_vendor_write(serial, 8, 0);
734 pl2303_vendor_write(serial, 9, 0);
739 pl2303_set_termios(tty, port, NULL);
741 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
743 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
748 result = usb_serial_generic_open(tty, port);
750 usb_kill_urb(port->interrupt_in_urb);
757 static int pl2303_tiocmset(struct tty_struct *tty,
758 unsigned int set, unsigned int clear)
760 struct usb_serial_port *port = tty->driver_data;
761 struct pl2303_private *priv = usb_get_serial_port_data(port);
766 spin_lock_irqsave(&priv->lock, flags);
768 priv->line_control |= CONTROL_RTS;
770 priv->line_control |= CONTROL_DTR;
771 if (clear & TIOCM_RTS)
772 priv->line_control &= ~CONTROL_RTS;
773 if (clear & TIOCM_DTR)
774 priv->line_control &= ~CONTROL_DTR;
775 control = priv->line_control;
776 spin_unlock_irqrestore(&priv->lock, flags);
778 ret = pl2303_set_control_lines(port, control);
780 return usb_translate_errors(ret);
785 static int pl2303_tiocmget(struct tty_struct *tty)
787 struct usb_serial_port *port = tty->driver_data;
788 struct pl2303_private *priv = usb_get_serial_port_data(port);
794 spin_lock_irqsave(&priv->lock, flags);
795 mcr = priv->line_control;
796 status = priv->line_status;
797 spin_unlock_irqrestore(&priv->lock, flags);
799 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
800 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
801 | ((status & UART_CTS) ? TIOCM_CTS : 0)
802 | ((status & UART_DSR) ? TIOCM_DSR : 0)
803 | ((status & UART_RING) ? TIOCM_RI : 0)
804 | ((status & UART_DCD) ? TIOCM_CD : 0);
806 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
811 static int pl2303_carrier_raised(struct usb_serial_port *port)
813 struct pl2303_private *priv = usb_get_serial_port_data(port);
815 if (priv->line_status & UART_DCD)
821 static int pl2303_ioctl(struct tty_struct *tty,
822 unsigned int cmd, unsigned long arg)
824 struct serial_struct ser;
825 struct usb_serial_port *port = tty->driver_data;
829 memset(&ser, 0, sizeof ser);
830 ser.type = PORT_16654;
831 ser.line = port->minor;
832 ser.port = port->port_number;
833 ser.baud_base = 460800;
835 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
846 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
848 struct usb_serial *serial = port->serial;
857 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
858 state == BREAK_OFF ? "off" : "on");
860 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
861 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
864 dev_err(&port->dev, "error sending break = %d\n", result);
867 static void pl2303_break_ctl(struct tty_struct *tty, int state)
869 struct usb_serial_port *port = tty->driver_data;
871 pl2303_set_break(port, state);
874 static void pl2303_update_line_status(struct usb_serial_port *port,
876 unsigned int actual_length)
878 struct usb_serial *serial = port->serial;
879 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
880 struct pl2303_private *priv = usb_get_serial_port_data(port);
881 struct tty_struct *tty;
883 unsigned int status_idx = UART_STATE_INDEX;
887 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
890 if (actual_length < status_idx + 1)
893 status = data[status_idx];
895 /* Save off the uart status for others to look at */
896 spin_lock_irqsave(&priv->lock, flags);
897 delta = priv->line_status ^ status;
898 priv->line_status = status;
899 spin_unlock_irqrestore(&priv->lock, flags);
901 if (status & UART_BREAK_ERROR)
902 usb_serial_handle_break(port);
904 if (delta & UART_STATE_MSR_MASK) {
905 if (delta & UART_CTS)
907 if (delta & UART_DSR)
909 if (delta & UART_RING)
911 if (delta & UART_DCD) {
913 tty = tty_port_tty_get(&port->port);
915 usb_serial_handle_dcd_change(port, tty,
921 wake_up_interruptible(&port->port.delta_msr_wait);
925 static void pl2303_read_int_callback(struct urb *urb)
927 struct usb_serial_port *port = urb->context;
928 unsigned char *data = urb->transfer_buffer;
929 unsigned int actual_length = urb->actual_length;
930 int status = urb->status;
940 /* this urb is terminated, clean up */
941 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
945 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
950 usb_serial_debug_data(&port->dev, __func__,
951 urb->actual_length, urb->transfer_buffer);
953 pl2303_update_line_status(port, data, actual_length);
956 retval = usb_submit_urb(urb, GFP_ATOMIC);
959 "%s - usb_submit_urb failed with result %d\n",
964 static void pl2303_process_read_urb(struct urb *urb)
966 struct usb_serial_port *port = urb->context;
967 struct pl2303_private *priv = usb_get_serial_port_data(port);
968 unsigned char *data = urb->transfer_buffer;
969 char tty_flag = TTY_NORMAL;
974 /* update line status */
975 spin_lock_irqsave(&priv->lock, flags);
976 line_status = priv->line_status;
977 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
978 spin_unlock_irqrestore(&priv->lock, flags);
980 if (!urb->actual_length)
984 * Break takes precedence over parity, which takes precedence over
987 if (line_status & UART_BREAK_ERROR)
988 tty_flag = TTY_BREAK;
989 else if (line_status & UART_PARITY_ERROR)
990 tty_flag = TTY_PARITY;
991 else if (line_status & UART_FRAME_ERROR)
992 tty_flag = TTY_FRAME;
994 if (tty_flag != TTY_NORMAL)
995 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
997 /* overrun is special, not associated with a char */
998 if (line_status & UART_OVERRUN_ERROR)
999 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
1001 if (port->port.console && port->sysrq) {
1002 for (i = 0; i < urb->actual_length; ++i)
1003 if (!usb_serial_handle_sysrq_char(port, data[i]))
1004 tty_insert_flip_char(&port->port, data[i],
1007 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1008 urb->actual_length);
1011 tty_flip_buffer_push(&port->port);
1014 static struct usb_serial_driver pl2303_device = {
1016 .owner = THIS_MODULE,
1019 .id_table = id_table,
1022 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1023 .bulk_in_size = 256,
1024 .bulk_out_size = 256,
1025 .open = pl2303_open,
1026 .close = pl2303_close,
1027 .dtr_rts = pl2303_dtr_rts,
1028 .carrier_raised = pl2303_carrier_raised,
1029 .ioctl = pl2303_ioctl,
1030 .break_ctl = pl2303_break_ctl,
1031 .set_termios = pl2303_set_termios,
1032 .tiocmget = pl2303_tiocmget,
1033 .tiocmset = pl2303_tiocmset,
1034 .tiocmiwait = usb_serial_generic_tiocmiwait,
1035 .process_read_urb = pl2303_process_read_urb,
1036 .read_int_callback = pl2303_read_int_callback,
1037 .probe = pl2303_probe,
1038 .calc_num_ports = pl2303_calc_num_ports,
1039 .attach = pl2303_startup,
1040 .release = pl2303_release,
1041 .port_probe = pl2303_port_probe,
1042 .port_remove = pl2303_port_remove,
1045 static struct usb_serial_driver * const serial_drivers[] = {
1046 &pl2303_device, NULL
1049 module_usb_serial_driver(serial_drivers, id_table);
1051 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1052 MODULE_LICENSE("GPL v2");