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(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
51 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
52 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
53 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
54 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
55 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
56 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
57 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
58 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
59 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
60 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
61 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
62 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
63 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
64 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
65 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
66 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
67 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
68 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
69 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
71 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
72 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
73 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
75 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
76 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
77 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
78 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
79 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
80 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
81 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
82 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
83 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
84 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
85 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
86 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
87 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
88 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
89 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
90 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
91 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
92 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
93 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
94 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
95 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
96 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
97 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
98 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
99 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
100 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
101 { } /* Terminating entry */
104 MODULE_DEVICE_TABLE(usb, id_table);
106 #define SET_LINE_REQUEST_TYPE 0x21
107 #define SET_LINE_REQUEST 0x20
109 #define SET_CONTROL_REQUEST_TYPE 0x21
110 #define SET_CONTROL_REQUEST 0x22
111 #define CONTROL_DTR 0x01
112 #define CONTROL_RTS 0x02
114 #define BREAK_REQUEST_TYPE 0x21
115 #define BREAK_REQUEST 0x23
116 #define BREAK_ON 0xffff
117 #define BREAK_OFF 0x0000
119 #define GET_LINE_REQUEST_TYPE 0xa1
120 #define GET_LINE_REQUEST 0x21
122 #define VENDOR_WRITE_REQUEST_TYPE 0x40
123 #define VENDOR_WRITE_REQUEST 0x01
125 #define VENDOR_READ_REQUEST_TYPE 0xc0
126 #define VENDOR_READ_REQUEST 0x01
128 #define UART_STATE_INDEX 8
129 #define UART_STATE_MSR_MASK 0x8b
130 #define UART_STATE_TRANSIENT_MASK 0x74
131 #define UART_DCD 0x01
132 #define UART_DSR 0x02
133 #define UART_BREAK_ERROR 0x04
134 #define UART_RING 0x08
135 #define UART_FRAME_ERROR 0x10
136 #define UART_PARITY_ERROR 0x20
137 #define UART_OVERRUN_ERROR 0x40
138 #define UART_CTS 0x80
140 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
143 TYPE_01, /* Type 0 and 1 (difference unknown) */
144 TYPE_HX, /* HX version of the pl2303 chip */
148 struct pl2303_type_data {
149 speed_t max_baud_rate;
150 unsigned long quirks;
153 struct pl2303_serial_private {
154 const struct pl2303_type_data *type;
155 unsigned long quirks;
158 struct pl2303_private {
166 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
168 .max_baud_rate = 1228800,
169 .quirks = PL2303_QUIRK_LEGACY,
172 .max_baud_rate = 12000000,
176 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
177 unsigned char buf[1])
179 struct device *dev = &serial->interface->dev;
182 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
183 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
184 value, 0, buf, 1, 100);
186 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
194 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
199 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
201 struct device *dev = &serial->interface->dev;
204 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
206 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
207 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
208 value, index, NULL, 0, 100);
210 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
218 static int pl2303_probe(struct usb_serial *serial,
219 const struct usb_device_id *id)
221 usb_set_serial_data(serial, (void *)id->driver_info);
227 * Use interrupt endpoint from first interface if available.
229 * This is needed due to the looney way its endpoints are set up.
231 static int pl2303_endpoint_hack(struct usb_serial *serial,
232 struct usb_serial_endpoints *epds)
234 struct usb_interface *interface = serial->interface;
235 struct usb_device *dev = serial->dev;
236 struct device *ddev = &interface->dev;
237 struct usb_host_interface *iface_desc;
238 struct usb_endpoint_descriptor *endpoint;
241 if (interface == dev->actconfig->interface[0])
244 /* check out the endpoints of the other interface */
245 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
247 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
248 endpoint = &iface_desc->endpoint[i].desc;
250 if (!usb_endpoint_is_int_in(endpoint))
253 dev_dbg(ddev, "found interrupt in on separate interface\n");
254 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
255 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
261 static int pl2303_calc_num_ports(struct usb_serial *serial,
262 struct usb_serial_endpoints *epds)
264 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
265 struct device *dev = &serial->interface->dev;
268 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
269 ret = pl2303_endpoint_hack(serial, epds);
274 if (epds->num_interrupt_in < 1) {
275 dev_err(dev, "required interrupt-in endpoint missing\n");
282 static int pl2303_startup(struct usb_serial *serial)
284 struct pl2303_serial_private *spriv;
285 enum pl2303_type type = TYPE_01;
288 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
292 buf = kmalloc(1, GFP_KERNEL);
298 if (serial->dev->descriptor.bDeviceClass == 0x02)
299 type = TYPE_01; /* type 0 */
300 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
302 else if (serial->dev->descriptor.bDeviceClass == 0x00)
303 type = TYPE_01; /* type 1 */
304 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
305 type = TYPE_01; /* type 1 */
306 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
308 spriv->type = &pl2303_type_data[type];
309 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
310 spriv->quirks |= spriv->type->quirks;
312 usb_set_serial_data(serial, spriv);
314 pl2303_vendor_read(serial, 0x8484, buf);
315 pl2303_vendor_write(serial, 0x0404, 0);
316 pl2303_vendor_read(serial, 0x8484, buf);
317 pl2303_vendor_read(serial, 0x8383, buf);
318 pl2303_vendor_read(serial, 0x8484, buf);
319 pl2303_vendor_write(serial, 0x0404, 1);
320 pl2303_vendor_read(serial, 0x8484, buf);
321 pl2303_vendor_read(serial, 0x8383, buf);
322 pl2303_vendor_write(serial, 0, 1);
323 pl2303_vendor_write(serial, 1, 0);
324 if (spriv->quirks & PL2303_QUIRK_LEGACY)
325 pl2303_vendor_write(serial, 2, 0x24);
327 pl2303_vendor_write(serial, 2, 0x44);
334 static void pl2303_release(struct usb_serial *serial)
336 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
341 static int pl2303_port_probe(struct usb_serial_port *port)
343 struct pl2303_private *priv;
345 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
349 spin_lock_init(&priv->lock);
351 usb_set_serial_port_data(port, priv);
353 port->port.drain_delay = 256;
358 static int pl2303_port_remove(struct usb_serial_port *port)
360 struct pl2303_private *priv = usb_get_serial_port_data(port);
367 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
369 struct usb_device *dev = port->serial->dev;
372 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
374 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
375 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
376 value, 0, NULL, 0, 100);
378 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
384 * Returns the nearest supported baud rate that can be set directly without
387 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
389 static const speed_t baud_sup[] = {
390 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
391 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
392 614400, 921600, 1228800, 2457600, 3000000, 6000000
397 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
398 if (baud_sup[i] > baud)
402 if (i == ARRAY_SIZE(baud_sup))
403 baud = baud_sup[i - 1];
404 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
405 baud = baud_sup[i - 1];
413 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
416 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
419 put_unaligned_le32(baud, buf);
424 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
427 unsigned int baseline, mantissa, exponent;
430 * Apparently the formula is:
431 * baudrate = 12M * 32 / (mantissa * 4^exponent)
433 * mantissa = buf[8:0]
434 * exponent = buf[11:9]
436 baseline = 12000000 * 32;
437 mantissa = baseline / baud;
439 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
441 while (mantissa >= 512) {
443 mantissa >>= 2; /* divide by 4 */
446 /* Exponent is maxed. Trim mantissa and leave. */
454 buf[1] = exponent << 1 | mantissa >> 8;
455 buf[0] = mantissa & 0xff;
457 /* Calculate and return the exact baud rate. */
458 baud = (baseline / mantissa) >> (exponent << 1);
463 static void pl2303_encode_baud_rate(struct tty_struct *tty,
464 struct usb_serial_port *port,
467 struct usb_serial *serial = port->serial;
468 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
472 baud = tty_get_baud_rate(tty);
473 dev_dbg(&port->dev, "baud requested = %u\n", baud);
477 if (spriv->type->max_baud_rate)
478 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
480 * Use direct method for supported baud rates, otherwise use divisors.
482 baud_sup = pl2303_get_supported_baud_rate(baud);
484 if (baud == baud_sup)
485 baud = pl2303_encode_baud_rate_direct(buf, baud);
487 baud = pl2303_encode_baud_rate_divisor(buf, baud);
489 /* Save resulting baud rate */
490 tty_encode_baud_rate(tty, baud, baud);
491 dev_dbg(&port->dev, "baud set = %u\n", baud);
494 static int pl2303_get_line_request(struct usb_serial_port *port,
495 unsigned char buf[7])
497 struct usb_device *udev = port->serial->dev;
500 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
501 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
504 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
512 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
517 static int pl2303_set_line_request(struct usb_serial_port *port,
518 unsigned char buf[7])
520 struct usb_device *udev = port->serial->dev;
523 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
524 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
527 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
531 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
536 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
540 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
541 a->c_cc[VSTART] != b->c_cc[VSTART] ||
542 a->c_cc[VSTOP] != b->c_cc[VSTOP];
544 return tty_termios_hw_change(a, b) || ixon_change;
547 static void pl2303_set_termios(struct tty_struct *tty,
548 struct usb_serial_port *port, struct ktermios *old_termios)
550 struct usb_serial *serial = port->serial;
551 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
552 struct pl2303_private *priv = usb_get_serial_port_data(port);
558 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
561 buf = kzalloc(7, GFP_KERNEL);
563 /* Report back no change occurred */
565 tty->termios = *old_termios;
569 pl2303_get_line_request(port, buf);
571 switch (C_CSIZE(tty)) {
585 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
587 /* For reference buf[0]:buf[3] baud rate value */
588 pl2303_encode_baud_rate(tty, port, &buf[0]);
590 /* For reference buf[4]=0 is 1 stop bits */
591 /* For reference buf[4]=1 is 1.5 stop bits */
592 /* For reference buf[4]=2 is 2 stop bits */
595 * NOTE: Comply with "real" UARTs / RS232:
596 * use 1.5 instead of 2 stop bits with 5 data bits
598 if (C_CSIZE(tty) == CS5) {
600 dev_dbg(&port->dev, "stop bits = 1.5\n");
603 dev_dbg(&port->dev, "stop bits = 2\n");
607 dev_dbg(&port->dev, "stop bits = 1\n");
611 /* For reference buf[5]=0 is none parity */
612 /* For reference buf[5]=1 is odd parity */
613 /* For reference buf[5]=2 is even parity */
614 /* For reference buf[5]=3 is mark parity */
615 /* For reference buf[5]=4 is space parity */
619 dev_dbg(&port->dev, "parity = mark\n");
622 dev_dbg(&port->dev, "parity = odd\n");
627 dev_dbg(&port->dev, "parity = space\n");
630 dev_dbg(&port->dev, "parity = even\n");
635 dev_dbg(&port->dev, "parity = none\n");
639 * Some PL2303 are known to lose bytes if you change serial settings
640 * even to the same values as before. Thus we actually need to filter
641 * in this specific case.
643 * Note that the tty_termios_hw_change check above is not sufficient
644 * as a previously requested baud rate may differ from the one
645 * actually used (and stored in old_termios).
647 * NOTE: No additional locking needed for line_settings as it is
648 * only used in set_termios, which is serialised against itself.
650 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
651 ret = pl2303_set_line_request(port, buf);
653 memcpy(priv->line_settings, buf, 7);
656 /* change control lines if we are switching to or from B0 */
657 spin_lock_irqsave(&priv->lock, flags);
658 control = priv->line_control;
659 if (C_BAUD(tty) == B0)
660 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
661 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
662 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
663 if (control != priv->line_control) {
664 control = priv->line_control;
665 spin_unlock_irqrestore(&priv->lock, flags);
666 pl2303_set_control_lines(port, control);
668 spin_unlock_irqrestore(&priv->lock, flags);
671 if (C_CRTSCTS(tty)) {
672 if (spriv->quirks & PL2303_QUIRK_LEGACY)
673 pl2303_vendor_write(serial, 0x0, 0x41);
675 pl2303_vendor_write(serial, 0x0, 0x61);
676 } else if (I_IXON(tty) && !I_IXANY(tty) && START_CHAR(tty) == 0x11 &&
677 STOP_CHAR(tty) == 0x13) {
678 pl2303_vendor_write(serial, 0x0, 0xc0);
680 pl2303_vendor_write(serial, 0x0, 0x0);
686 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
688 struct pl2303_private *priv = usb_get_serial_port_data(port);
692 spin_lock_irqsave(&priv->lock, flags);
694 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
696 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
697 control = priv->line_control;
698 spin_unlock_irqrestore(&priv->lock, flags);
700 pl2303_set_control_lines(port, control);
703 static void pl2303_close(struct usb_serial_port *port)
705 usb_serial_generic_close(port);
706 usb_kill_urb(port->interrupt_in_urb);
707 pl2303_set_break(port, false);
710 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
712 struct usb_serial *serial = port->serial;
713 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
716 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
717 usb_clear_halt(serial->dev, port->write_urb->pipe);
718 usb_clear_halt(serial->dev, port->read_urb->pipe);
720 /* reset upstream data pipes */
721 pl2303_vendor_write(serial, 8, 0);
722 pl2303_vendor_write(serial, 9, 0);
727 pl2303_set_termios(tty, port, NULL);
729 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
731 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
736 result = usb_serial_generic_open(tty, port);
738 usb_kill_urb(port->interrupt_in_urb);
745 static int pl2303_tiocmset(struct tty_struct *tty,
746 unsigned int set, unsigned int clear)
748 struct usb_serial_port *port = tty->driver_data;
749 struct pl2303_private *priv = usb_get_serial_port_data(port);
754 spin_lock_irqsave(&priv->lock, flags);
756 priv->line_control |= CONTROL_RTS;
758 priv->line_control |= CONTROL_DTR;
759 if (clear & TIOCM_RTS)
760 priv->line_control &= ~CONTROL_RTS;
761 if (clear & TIOCM_DTR)
762 priv->line_control &= ~CONTROL_DTR;
763 control = priv->line_control;
764 spin_unlock_irqrestore(&priv->lock, flags);
766 ret = pl2303_set_control_lines(port, control);
768 return usb_translate_errors(ret);
773 static int pl2303_tiocmget(struct tty_struct *tty)
775 struct usb_serial_port *port = tty->driver_data;
776 struct pl2303_private *priv = usb_get_serial_port_data(port);
782 spin_lock_irqsave(&priv->lock, flags);
783 mcr = priv->line_control;
784 status = priv->line_status;
785 spin_unlock_irqrestore(&priv->lock, flags);
787 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
788 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
789 | ((status & UART_CTS) ? TIOCM_CTS : 0)
790 | ((status & UART_DSR) ? TIOCM_DSR : 0)
791 | ((status & UART_RING) ? TIOCM_RI : 0)
792 | ((status & UART_DCD) ? TIOCM_CD : 0);
794 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
799 static int pl2303_carrier_raised(struct usb_serial_port *port)
801 struct pl2303_private *priv = usb_get_serial_port_data(port);
803 if (priv->line_status & UART_DCD)
809 static int pl2303_ioctl(struct tty_struct *tty,
810 unsigned int cmd, unsigned long arg)
812 struct serial_struct ser;
813 struct usb_serial_port *port = tty->driver_data;
817 memset(&ser, 0, sizeof ser);
818 ser.type = PORT_16654;
819 ser.line = port->minor;
820 ser.port = port->port_number;
821 ser.baud_base = 460800;
823 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
834 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
836 struct usb_serial *serial = port->serial;
845 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
846 state == BREAK_OFF ? "off" : "on");
848 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
849 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
852 dev_err(&port->dev, "error sending break = %d\n", result);
855 static void pl2303_break_ctl(struct tty_struct *tty, int state)
857 struct usb_serial_port *port = tty->driver_data;
859 pl2303_set_break(port, state);
862 static void pl2303_update_line_status(struct usb_serial_port *port,
864 unsigned int actual_length)
866 struct usb_serial *serial = port->serial;
867 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
868 struct pl2303_private *priv = usb_get_serial_port_data(port);
869 struct tty_struct *tty;
871 unsigned int status_idx = UART_STATE_INDEX;
875 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
878 if (actual_length < status_idx + 1)
881 status = data[status_idx];
883 /* Save off the uart status for others to look at */
884 spin_lock_irqsave(&priv->lock, flags);
885 delta = priv->line_status ^ status;
886 priv->line_status = status;
887 spin_unlock_irqrestore(&priv->lock, flags);
889 if (status & UART_BREAK_ERROR)
890 usb_serial_handle_break(port);
892 if (delta & UART_STATE_MSR_MASK) {
893 if (delta & UART_CTS)
895 if (delta & UART_DSR)
897 if (delta & UART_RING)
899 if (delta & UART_DCD) {
901 tty = tty_port_tty_get(&port->port);
903 usb_serial_handle_dcd_change(port, tty,
909 wake_up_interruptible(&port->port.delta_msr_wait);
913 static void pl2303_read_int_callback(struct urb *urb)
915 struct usb_serial_port *port = urb->context;
916 unsigned char *data = urb->transfer_buffer;
917 unsigned int actual_length = urb->actual_length;
918 int status = urb->status;
928 /* this urb is terminated, clean up */
929 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
933 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
938 usb_serial_debug_data(&port->dev, __func__,
939 urb->actual_length, urb->transfer_buffer);
941 pl2303_update_line_status(port, data, actual_length);
944 retval = usb_submit_urb(urb, GFP_ATOMIC);
947 "%s - usb_submit_urb failed with result %d\n",
952 static void pl2303_process_read_urb(struct urb *urb)
954 struct usb_serial_port *port = urb->context;
955 struct pl2303_private *priv = usb_get_serial_port_data(port);
956 unsigned char *data = urb->transfer_buffer;
957 char tty_flag = TTY_NORMAL;
962 /* update line status */
963 spin_lock_irqsave(&priv->lock, flags);
964 line_status = priv->line_status;
965 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
966 spin_unlock_irqrestore(&priv->lock, flags);
968 if (!urb->actual_length)
972 * Break takes precedence over parity, which takes precedence over
975 if (line_status & UART_BREAK_ERROR)
976 tty_flag = TTY_BREAK;
977 else if (line_status & UART_PARITY_ERROR)
978 tty_flag = TTY_PARITY;
979 else if (line_status & UART_FRAME_ERROR)
980 tty_flag = TTY_FRAME;
982 if (tty_flag != TTY_NORMAL)
983 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
985 /* overrun is special, not associated with a char */
986 if (line_status & UART_OVERRUN_ERROR)
987 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
989 if (port->port.console && port->sysrq) {
990 for (i = 0; i < urb->actual_length; ++i)
991 if (!usb_serial_handle_sysrq_char(port, data[i]))
992 tty_insert_flip_char(&port->port, data[i],
995 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
999 tty_flip_buffer_push(&port->port);
1002 static struct usb_serial_driver pl2303_device = {
1004 .owner = THIS_MODULE,
1007 .id_table = id_table,
1010 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1011 .bulk_in_size = 256,
1012 .bulk_out_size = 256,
1013 .open = pl2303_open,
1014 .close = pl2303_close,
1015 .dtr_rts = pl2303_dtr_rts,
1016 .carrier_raised = pl2303_carrier_raised,
1017 .ioctl = pl2303_ioctl,
1018 .break_ctl = pl2303_break_ctl,
1019 .set_termios = pl2303_set_termios,
1020 .tiocmget = pl2303_tiocmget,
1021 .tiocmset = pl2303_tiocmset,
1022 .tiocmiwait = usb_serial_generic_tiocmiwait,
1023 .process_read_urb = pl2303_process_read_urb,
1024 .read_int_callback = pl2303_read_int_callback,
1025 .probe = pl2303_probe,
1026 .calc_num_ports = pl2303_calc_num_ports,
1027 .attach = pl2303_startup,
1028 .release = pl2303_release,
1029 .port_probe = pl2303_port_probe,
1030 .port_remove = pl2303_port_remove,
1033 static struct usb_serial_driver * const serial_drivers[] = {
1034 &pl2303_device, NULL
1037 module_usb_serial_driver(serial_drivers, id_table);
1039 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1040 MODULE_LICENSE("GPL v2");