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_UC232B),
56 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
57 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
58 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
59 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
60 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
61 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
62 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
63 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
64 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
65 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
66 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
67 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
68 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
69 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
71 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
72 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
73 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
75 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
76 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
77 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
78 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
79 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
80 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
81 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
82 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
83 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
84 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
85 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
86 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
87 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
88 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
89 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
90 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
91 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
92 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
93 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
94 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
95 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
96 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
98 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
102 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
103 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
104 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
105 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
106 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
107 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
108 { } /* Terminating entry */
111 MODULE_DEVICE_TABLE(usb, id_table);
113 #define SET_LINE_REQUEST_TYPE 0x21
114 #define SET_LINE_REQUEST 0x20
116 #define SET_CONTROL_REQUEST_TYPE 0x21
117 #define SET_CONTROL_REQUEST 0x22
118 #define CONTROL_DTR 0x01
119 #define CONTROL_RTS 0x02
121 #define BREAK_REQUEST_TYPE 0x21
122 #define BREAK_REQUEST 0x23
123 #define BREAK_ON 0xffff
124 #define BREAK_OFF 0x0000
126 #define GET_LINE_REQUEST_TYPE 0xa1
127 #define GET_LINE_REQUEST 0x21
129 #define VENDOR_WRITE_REQUEST_TYPE 0x40
130 #define VENDOR_WRITE_REQUEST 0x01
132 #define VENDOR_READ_REQUEST_TYPE 0xc0
133 #define VENDOR_READ_REQUEST 0x01
135 #define UART_STATE_INDEX 8
136 #define UART_STATE_MSR_MASK 0x8b
137 #define UART_STATE_TRANSIENT_MASK 0x74
138 #define UART_DCD 0x01
139 #define UART_DSR 0x02
140 #define UART_BREAK_ERROR 0x04
141 #define UART_RING 0x08
142 #define UART_FRAME_ERROR 0x10
143 #define UART_PARITY_ERROR 0x20
144 #define UART_OVERRUN_ERROR 0x40
145 #define UART_CTS 0x80
147 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
150 TYPE_01, /* Type 0 and 1 (difference unknown) */
151 TYPE_HX, /* HX version of the pl2303 chip */
155 struct pl2303_type_data {
156 speed_t max_baud_rate;
157 unsigned long quirks;
160 struct pl2303_serial_private {
161 const struct pl2303_type_data *type;
162 unsigned long quirks;
165 struct pl2303_private {
173 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
175 .max_baud_rate = 1228800,
176 .quirks = PL2303_QUIRK_LEGACY,
179 .max_baud_rate = 12000000,
183 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
184 unsigned char buf[1])
186 struct device *dev = &serial->interface->dev;
189 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
190 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
191 value, 0, buf, 1, 100);
193 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
201 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
206 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
208 struct device *dev = &serial->interface->dev;
211 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
213 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
214 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
215 value, index, NULL, 0, 100);
217 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
225 static int pl2303_probe(struct usb_serial *serial,
226 const struct usb_device_id *id)
228 usb_set_serial_data(serial, (void *)id->driver_info);
234 * Use interrupt endpoint from first interface if available.
236 * This is needed due to the looney way its endpoints are set up.
238 static int pl2303_endpoint_hack(struct usb_serial *serial,
239 struct usb_serial_endpoints *epds)
241 struct usb_interface *interface = serial->interface;
242 struct usb_device *dev = serial->dev;
243 struct device *ddev = &interface->dev;
244 struct usb_host_interface *iface_desc;
245 struct usb_endpoint_descriptor *endpoint;
248 if (interface == dev->actconfig->interface[0])
251 /* check out the endpoints of the other interface */
252 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
254 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
255 endpoint = &iface_desc->endpoint[i].desc;
257 if (!usb_endpoint_is_int_in(endpoint))
260 dev_dbg(ddev, "found interrupt in on separate interface\n");
261 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
262 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
268 static int pl2303_calc_num_ports(struct usb_serial *serial,
269 struct usb_serial_endpoints *epds)
271 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
272 struct device *dev = &serial->interface->dev;
275 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
276 ret = pl2303_endpoint_hack(serial, epds);
281 if (epds->num_interrupt_in < 1) {
282 dev_err(dev, "required interrupt-in endpoint missing\n");
289 static int pl2303_startup(struct usb_serial *serial)
291 struct pl2303_serial_private *spriv;
292 enum pl2303_type type = TYPE_01;
295 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
299 buf = kmalloc(1, GFP_KERNEL);
305 if (serial->dev->descriptor.bDeviceClass == 0x02)
306 type = TYPE_01; /* type 0 */
307 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
309 else if (serial->dev->descriptor.bDeviceClass == 0x00)
310 type = TYPE_01; /* type 1 */
311 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
312 type = TYPE_01; /* type 1 */
313 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
315 spriv->type = &pl2303_type_data[type];
316 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
317 spriv->quirks |= spriv->type->quirks;
319 usb_set_serial_data(serial, spriv);
321 pl2303_vendor_read(serial, 0x8484, buf);
322 pl2303_vendor_write(serial, 0x0404, 0);
323 pl2303_vendor_read(serial, 0x8484, buf);
324 pl2303_vendor_read(serial, 0x8383, buf);
325 pl2303_vendor_read(serial, 0x8484, buf);
326 pl2303_vendor_write(serial, 0x0404, 1);
327 pl2303_vendor_read(serial, 0x8484, buf);
328 pl2303_vendor_read(serial, 0x8383, buf);
329 pl2303_vendor_write(serial, 0, 1);
330 pl2303_vendor_write(serial, 1, 0);
331 if (spriv->quirks & PL2303_QUIRK_LEGACY)
332 pl2303_vendor_write(serial, 2, 0x24);
334 pl2303_vendor_write(serial, 2, 0x44);
341 static void pl2303_release(struct usb_serial *serial)
343 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
348 static int pl2303_port_probe(struct usb_serial_port *port)
350 struct pl2303_private *priv;
352 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
356 spin_lock_init(&priv->lock);
358 usb_set_serial_port_data(port, priv);
360 port->port.drain_delay = 256;
365 static int pl2303_port_remove(struct usb_serial_port *port)
367 struct pl2303_private *priv = usb_get_serial_port_data(port);
374 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
376 struct usb_device *dev = port->serial->dev;
379 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
381 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
382 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
383 value, 0, NULL, 0, 100);
385 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
391 * Returns the nearest supported baud rate that can be set directly without
394 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
396 static const speed_t baud_sup[] = {
397 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
398 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
399 614400, 921600, 1228800, 2457600, 3000000, 6000000
404 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
405 if (baud_sup[i] > baud)
409 if (i == ARRAY_SIZE(baud_sup))
410 baud = baud_sup[i - 1];
411 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
412 baud = baud_sup[i - 1];
420 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
423 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
426 put_unaligned_le32(baud, buf);
431 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
434 unsigned int baseline, mantissa, exponent;
437 * Apparently the formula is:
438 * baudrate = 12M * 32 / (mantissa * 4^exponent)
440 * mantissa = buf[8:0]
441 * exponent = buf[11:9]
443 baseline = 12000000 * 32;
444 mantissa = baseline / baud;
446 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
448 while (mantissa >= 512) {
450 mantissa >>= 2; /* divide by 4 */
453 /* Exponent is maxed. Trim mantissa and leave. */
461 buf[1] = exponent << 1 | mantissa >> 8;
462 buf[0] = mantissa & 0xff;
464 /* Calculate and return the exact baud rate. */
465 baud = (baseline / mantissa) >> (exponent << 1);
470 static void pl2303_encode_baud_rate(struct tty_struct *tty,
471 struct usb_serial_port *port,
474 struct usb_serial *serial = port->serial;
475 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
479 baud = tty_get_baud_rate(tty);
480 dev_dbg(&port->dev, "baud requested = %u\n", baud);
484 if (spriv->type->max_baud_rate)
485 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
487 * Use direct method for supported baud rates, otherwise use divisors.
489 baud_sup = pl2303_get_supported_baud_rate(baud);
491 if (baud == baud_sup)
492 baud = pl2303_encode_baud_rate_direct(buf, baud);
494 baud = pl2303_encode_baud_rate_divisor(buf, baud);
496 /* Save resulting baud rate */
497 tty_encode_baud_rate(tty, baud, baud);
498 dev_dbg(&port->dev, "baud set = %u\n", baud);
501 static int pl2303_get_line_request(struct usb_serial_port *port,
502 unsigned char buf[7])
504 struct usb_device *udev = port->serial->dev;
507 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
508 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
511 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
519 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
524 static int pl2303_set_line_request(struct usb_serial_port *port,
525 unsigned char buf[7])
527 struct usb_device *udev = port->serial->dev;
530 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
531 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
534 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
538 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
543 static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
547 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
548 a->c_cc[VSTART] != b->c_cc[VSTART] ||
549 a->c_cc[VSTOP] != b->c_cc[VSTOP];
551 return tty_termios_hw_change(a, b) || ixon_change;
554 static void pl2303_set_termios(struct tty_struct *tty,
555 struct usb_serial_port *port, struct ktermios *old_termios)
557 struct usb_serial *serial = port->serial;
558 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
559 struct pl2303_private *priv = usb_get_serial_port_data(port);
565 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
568 buf = kzalloc(7, GFP_KERNEL);
570 /* Report back no change occurred */
572 tty->termios = *old_termios;
576 pl2303_get_line_request(port, buf);
578 switch (C_CSIZE(tty)) {
592 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
594 /* For reference buf[0]:buf[3] baud rate value */
595 pl2303_encode_baud_rate(tty, port, &buf[0]);
597 /* For reference buf[4]=0 is 1 stop bits */
598 /* For reference buf[4]=1 is 1.5 stop bits */
599 /* For reference buf[4]=2 is 2 stop bits */
602 * NOTE: Comply with "real" UARTs / RS232:
603 * use 1.5 instead of 2 stop bits with 5 data bits
605 if (C_CSIZE(tty) == CS5) {
607 dev_dbg(&port->dev, "stop bits = 1.5\n");
610 dev_dbg(&port->dev, "stop bits = 2\n");
614 dev_dbg(&port->dev, "stop bits = 1\n");
618 /* For reference buf[5]=0 is none parity */
619 /* For reference buf[5]=1 is odd parity */
620 /* For reference buf[5]=2 is even parity */
621 /* For reference buf[5]=3 is mark parity */
622 /* For reference buf[5]=4 is space parity */
626 dev_dbg(&port->dev, "parity = mark\n");
629 dev_dbg(&port->dev, "parity = odd\n");
634 dev_dbg(&port->dev, "parity = space\n");
637 dev_dbg(&port->dev, "parity = even\n");
642 dev_dbg(&port->dev, "parity = none\n");
646 * Some PL2303 are known to lose bytes if you change serial settings
647 * even to the same values as before. Thus we actually need to filter
648 * in this specific case.
650 * Note that the tty_termios_hw_change check above is not sufficient
651 * as a previously requested baud rate may differ from the one
652 * actually used (and stored in old_termios).
654 * NOTE: No additional locking needed for line_settings as it is
655 * only used in set_termios, which is serialised against itself.
657 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
658 ret = pl2303_set_line_request(port, buf);
660 memcpy(priv->line_settings, buf, 7);
663 /* change control lines if we are switching to or from B0 */
664 spin_lock_irqsave(&priv->lock, flags);
665 control = priv->line_control;
666 if (C_BAUD(tty) == B0)
667 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
668 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
669 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
670 if (control != priv->line_control) {
671 control = priv->line_control;
672 spin_unlock_irqrestore(&priv->lock, flags);
673 pl2303_set_control_lines(port, control);
675 spin_unlock_irqrestore(&priv->lock, flags);
678 if (C_CRTSCTS(tty)) {
679 if (spriv->quirks & PL2303_QUIRK_LEGACY)
680 pl2303_vendor_write(serial, 0x0, 0x41);
682 pl2303_vendor_write(serial, 0x0, 0x61);
683 } else if (I_IXON(tty) && !I_IXANY(tty) && START_CHAR(tty) == 0x11 &&
684 STOP_CHAR(tty) == 0x13) {
685 pl2303_vendor_write(serial, 0x0, 0xc0);
687 pl2303_vendor_write(serial, 0x0, 0x0);
693 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
695 struct pl2303_private *priv = usb_get_serial_port_data(port);
699 spin_lock_irqsave(&priv->lock, flags);
701 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
703 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
704 control = priv->line_control;
705 spin_unlock_irqrestore(&priv->lock, flags);
707 pl2303_set_control_lines(port, control);
710 static void pl2303_close(struct usb_serial_port *port)
712 usb_serial_generic_close(port);
713 usb_kill_urb(port->interrupt_in_urb);
714 pl2303_set_break(port, false);
717 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
719 struct usb_serial *serial = port->serial;
720 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
723 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
724 usb_clear_halt(serial->dev, port->write_urb->pipe);
725 usb_clear_halt(serial->dev, port->read_urb->pipe);
727 /* reset upstream data pipes */
728 pl2303_vendor_write(serial, 8, 0);
729 pl2303_vendor_write(serial, 9, 0);
734 pl2303_set_termios(tty, port, NULL);
736 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
738 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
743 result = usb_serial_generic_open(tty, port);
745 usb_kill_urb(port->interrupt_in_urb);
752 static int pl2303_tiocmset(struct tty_struct *tty,
753 unsigned int set, unsigned int clear)
755 struct usb_serial_port *port = tty->driver_data;
756 struct pl2303_private *priv = usb_get_serial_port_data(port);
761 spin_lock_irqsave(&priv->lock, flags);
763 priv->line_control |= CONTROL_RTS;
765 priv->line_control |= CONTROL_DTR;
766 if (clear & TIOCM_RTS)
767 priv->line_control &= ~CONTROL_RTS;
768 if (clear & TIOCM_DTR)
769 priv->line_control &= ~CONTROL_DTR;
770 control = priv->line_control;
771 spin_unlock_irqrestore(&priv->lock, flags);
773 ret = pl2303_set_control_lines(port, control);
775 return usb_translate_errors(ret);
780 static int pl2303_tiocmget(struct tty_struct *tty)
782 struct usb_serial_port *port = tty->driver_data;
783 struct pl2303_private *priv = usb_get_serial_port_data(port);
789 spin_lock_irqsave(&priv->lock, flags);
790 mcr = priv->line_control;
791 status = priv->line_status;
792 spin_unlock_irqrestore(&priv->lock, flags);
794 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
795 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
796 | ((status & UART_CTS) ? TIOCM_CTS : 0)
797 | ((status & UART_DSR) ? TIOCM_DSR : 0)
798 | ((status & UART_RING) ? TIOCM_RI : 0)
799 | ((status & UART_DCD) ? TIOCM_CD : 0);
801 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
806 static int pl2303_carrier_raised(struct usb_serial_port *port)
808 struct pl2303_private *priv = usb_get_serial_port_data(port);
810 if (priv->line_status & UART_DCD)
816 static int pl2303_get_serial(struct tty_struct *tty,
817 struct serial_struct *ss)
819 struct usb_serial_port *port = tty->driver_data;
821 ss->type = PORT_16654;
822 ss->line = port->minor;
823 ss->port = port->port_number;
824 ss->baud_base = 460800;
828 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
830 struct usb_serial *serial = port->serial;
839 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
840 state == BREAK_OFF ? "off" : "on");
842 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
843 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
846 dev_err(&port->dev, "error sending break = %d\n", result);
849 static void pl2303_break_ctl(struct tty_struct *tty, int state)
851 struct usb_serial_port *port = tty->driver_data;
853 pl2303_set_break(port, state);
856 static void pl2303_update_line_status(struct usb_serial_port *port,
858 unsigned int actual_length)
860 struct usb_serial *serial = port->serial;
861 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
862 struct pl2303_private *priv = usb_get_serial_port_data(port);
863 struct tty_struct *tty;
865 unsigned int status_idx = UART_STATE_INDEX;
869 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
872 if (actual_length < status_idx + 1)
875 status = data[status_idx];
877 /* Save off the uart status for others to look at */
878 spin_lock_irqsave(&priv->lock, flags);
879 delta = priv->line_status ^ status;
880 priv->line_status = status;
881 spin_unlock_irqrestore(&priv->lock, flags);
883 if (status & UART_BREAK_ERROR)
884 usb_serial_handle_break(port);
886 if (delta & UART_STATE_MSR_MASK) {
887 if (delta & UART_CTS)
889 if (delta & UART_DSR)
891 if (delta & UART_RING)
893 if (delta & UART_DCD) {
895 tty = tty_port_tty_get(&port->port);
897 usb_serial_handle_dcd_change(port, tty,
903 wake_up_interruptible(&port->port.delta_msr_wait);
907 static void pl2303_read_int_callback(struct urb *urb)
909 struct usb_serial_port *port = urb->context;
910 unsigned char *data = urb->transfer_buffer;
911 unsigned int actual_length = urb->actual_length;
912 int status = urb->status;
922 /* this urb is terminated, clean up */
923 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
927 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
932 usb_serial_debug_data(&port->dev, __func__,
933 urb->actual_length, urb->transfer_buffer);
935 pl2303_update_line_status(port, data, actual_length);
938 retval = usb_submit_urb(urb, GFP_ATOMIC);
941 "%s - usb_submit_urb failed with result %d\n",
946 static void pl2303_process_read_urb(struct urb *urb)
948 struct usb_serial_port *port = urb->context;
949 struct pl2303_private *priv = usb_get_serial_port_data(port);
950 unsigned char *data = urb->transfer_buffer;
951 char tty_flag = TTY_NORMAL;
956 /* update line status */
957 spin_lock_irqsave(&priv->lock, flags);
958 line_status = priv->line_status;
959 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
960 spin_unlock_irqrestore(&priv->lock, flags);
962 if (!urb->actual_length)
966 * Break takes precedence over parity, which takes precedence over
969 if (line_status & UART_BREAK_ERROR)
970 tty_flag = TTY_BREAK;
971 else if (line_status & UART_PARITY_ERROR)
972 tty_flag = TTY_PARITY;
973 else if (line_status & UART_FRAME_ERROR)
974 tty_flag = TTY_FRAME;
976 if (tty_flag != TTY_NORMAL)
977 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
979 /* overrun is special, not associated with a char */
980 if (line_status & UART_OVERRUN_ERROR)
981 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
983 if (port->port.console && port->sysrq) {
984 for (i = 0; i < urb->actual_length; ++i)
985 if (!usb_serial_handle_sysrq_char(port, data[i]))
986 tty_insert_flip_char(&port->port, data[i],
989 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
993 tty_flip_buffer_push(&port->port);
996 static struct usb_serial_driver pl2303_device = {
998 .owner = THIS_MODULE,
1001 .id_table = id_table,
1004 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1005 .bulk_in_size = 256,
1006 .bulk_out_size = 256,
1007 .open = pl2303_open,
1008 .close = pl2303_close,
1009 .dtr_rts = pl2303_dtr_rts,
1010 .carrier_raised = pl2303_carrier_raised,
1011 .get_serial = pl2303_get_serial,
1012 .break_ctl = pl2303_break_ctl,
1013 .set_termios = pl2303_set_termios,
1014 .tiocmget = pl2303_tiocmget,
1015 .tiocmset = pl2303_tiocmset,
1016 .tiocmiwait = usb_serial_generic_tiocmiwait,
1017 .process_read_urb = pl2303_process_read_urb,
1018 .read_int_callback = pl2303_read_int_callback,
1019 .probe = pl2303_probe,
1020 .calc_num_ports = pl2303_calc_num_ports,
1021 .attach = pl2303_startup,
1022 .release = pl2303_release,
1023 .port_probe = pl2303_port_probe,
1024 .port_remove = pl2303_port_remove,
1027 static struct usb_serial_driver * const serial_drivers[] = {
1028 &pl2303_device, NULL
1031 module_usb_serial_driver(serial_drivers, id_table);
1033 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1034 MODULE_LICENSE("GPL v2");