2 * Prolific PL2303 USB to serial adaptor driver
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
7 * Original driver for 2.2.x by anonymous
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * See Documentation/usb/usb-serial.txt for more information on using this
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/slab.h>
20 #include <linux/tty.h>
21 #include <linux/tty_driver.h>
22 #include <linux/tty_flip.h>
23 #include <linux/serial.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/spinlock.h>
27 #include <linux/uaccess.h>
28 #include <linux/usb.h>
29 #include <linux/usb/serial.h>
30 #include <asm/unaligned.h>
34 #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
35 #define PL2303_QUIRK_LEGACY BIT(1)
36 #define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
38 static const struct usb_device_id id_table[] = {
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
40 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
53 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
54 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
55 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
56 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
57 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
58 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
59 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
60 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
61 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
62 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
63 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
64 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
65 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
66 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
67 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
68 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
69 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
70 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
71 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
72 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
73 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
75 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
76 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
77 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
79 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
81 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
82 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
83 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
84 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
85 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
86 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
87 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
88 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
89 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
90 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
91 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
92 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
93 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
94 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
95 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
96 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
98 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
102 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
103 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
105 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
106 { USB_DEVICE(HP_VENDOR_ID, HP_LM930_PRODUCT_ID) },
107 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
108 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
109 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
110 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
111 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
112 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
113 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
114 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
115 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
116 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
117 { USB_DEVICE(IBM_VENDOR_ID, IBM_PRODUCT_ID) },
118 { } /* Terminating entry */
121 MODULE_DEVICE_TABLE(usb, id_table);
123 #define SET_LINE_REQUEST_TYPE 0x21
124 #define SET_LINE_REQUEST 0x20
126 #define SET_CONTROL_REQUEST_TYPE 0x21
127 #define SET_CONTROL_REQUEST 0x22
128 #define CONTROL_DTR 0x01
129 #define CONTROL_RTS 0x02
131 #define BREAK_REQUEST_TYPE 0x21
132 #define BREAK_REQUEST 0x23
133 #define BREAK_ON 0xffff
134 #define BREAK_OFF 0x0000
136 #define GET_LINE_REQUEST_TYPE 0xa1
137 #define GET_LINE_REQUEST 0x21
139 #define VENDOR_WRITE_REQUEST_TYPE 0x40
140 #define VENDOR_WRITE_REQUEST 0x01
142 #define VENDOR_READ_REQUEST_TYPE 0xc0
143 #define VENDOR_READ_REQUEST 0x01
145 #define UART_STATE_INDEX 8
146 #define UART_STATE_MSR_MASK 0x8b
147 #define UART_STATE_TRANSIENT_MASK 0x74
148 #define UART_DCD 0x01
149 #define UART_DSR 0x02
150 #define UART_BREAK_ERROR 0x04
151 #define UART_RING 0x08
152 #define UART_FRAME_ERROR 0x10
153 #define UART_PARITY_ERROR 0x20
154 #define UART_OVERRUN_ERROR 0x40
155 #define UART_CTS 0x80
157 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
160 TYPE_01, /* Type 0 and 1 (difference unknown) */
161 TYPE_HX, /* HX version of the pl2303 chip */
165 struct pl2303_type_data {
166 speed_t max_baud_rate;
167 unsigned long quirks;
170 struct pl2303_serial_private {
171 const struct pl2303_type_data *type;
172 unsigned long quirks;
175 struct pl2303_private {
183 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
185 .max_baud_rate = 1228800,
186 .quirks = PL2303_QUIRK_LEGACY,
189 .max_baud_rate = 12000000,
193 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
194 unsigned char buf[1])
196 struct device *dev = &serial->interface->dev;
199 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
200 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
201 value, 0, buf, 1, 100);
203 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
211 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
216 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
218 struct device *dev = &serial->interface->dev;
221 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
223 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
224 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
225 value, index, NULL, 0, 100);
227 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
235 static int pl2303_probe(struct usb_serial *serial,
236 const struct usb_device_id *id)
238 usb_set_serial_data(serial, (void *)id->driver_info);
244 * Use interrupt endpoint from first interface if available.
246 * This is needed due to the looney way its endpoints are set up.
248 static int pl2303_endpoint_hack(struct usb_serial *serial,
249 struct usb_serial_endpoints *epds)
251 struct usb_interface *interface = serial->interface;
252 struct usb_device *dev = serial->dev;
253 struct device *ddev = &interface->dev;
254 struct usb_host_interface *iface_desc;
255 struct usb_endpoint_descriptor *endpoint;
258 if (interface == dev->actconfig->interface[0])
261 /* check out the endpoints of the other interface */
262 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
264 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
265 endpoint = &iface_desc->endpoint[i].desc;
267 if (!usb_endpoint_is_int_in(endpoint))
270 dev_dbg(ddev, "found interrupt in on separate interface\n");
271 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
272 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
278 static int pl2303_calc_num_ports(struct usb_serial *serial,
279 struct usb_serial_endpoints *epds)
281 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
282 struct device *dev = &serial->interface->dev;
285 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
286 ret = pl2303_endpoint_hack(serial, epds);
291 if (epds->num_interrupt_in < 1) {
292 dev_err(dev, "required interrupt-in endpoint missing\n");
299 static int pl2303_startup(struct usb_serial *serial)
301 struct pl2303_serial_private *spriv;
302 enum pl2303_type type = TYPE_01;
305 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
309 buf = kmalloc(1, GFP_KERNEL);
315 if (serial->dev->descriptor.bDeviceClass == 0x02)
316 type = TYPE_01; /* type 0 */
317 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
319 else if (serial->dev->descriptor.bDeviceClass == 0x00)
320 type = TYPE_01; /* type 1 */
321 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
322 type = TYPE_01; /* type 1 */
323 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
325 spriv->type = &pl2303_type_data[type];
326 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
327 spriv->quirks |= spriv->type->quirks;
329 usb_set_serial_data(serial, spriv);
331 pl2303_vendor_read(serial, 0x8484, buf);
332 pl2303_vendor_write(serial, 0x0404, 0);
333 pl2303_vendor_read(serial, 0x8484, buf);
334 pl2303_vendor_read(serial, 0x8383, buf);
335 pl2303_vendor_read(serial, 0x8484, buf);
336 pl2303_vendor_write(serial, 0x0404, 1);
337 pl2303_vendor_read(serial, 0x8484, buf);
338 pl2303_vendor_read(serial, 0x8383, buf);
339 pl2303_vendor_write(serial, 0, 1);
340 pl2303_vendor_write(serial, 1, 0);
341 if (spriv->quirks & PL2303_QUIRK_LEGACY)
342 pl2303_vendor_write(serial, 2, 0x24);
344 pl2303_vendor_write(serial, 2, 0x44);
351 static void pl2303_release(struct usb_serial *serial)
353 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
358 static int pl2303_port_probe(struct usb_serial_port *port)
360 struct pl2303_private *priv;
362 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
366 spin_lock_init(&priv->lock);
368 usb_set_serial_port_data(port, priv);
370 port->port.drain_delay = 256;
375 static int pl2303_port_remove(struct usb_serial_port *port)
377 struct pl2303_private *priv = usb_get_serial_port_data(port);
384 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
386 struct usb_device *dev = port->serial->dev;
389 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
391 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
392 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
393 value, 0, NULL, 0, 100);
395 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
401 * Returns the nearest supported baud rate that can be set directly without
404 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
406 static const speed_t baud_sup[] = {
407 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
408 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
409 614400, 921600, 1228800, 2457600, 3000000, 6000000
414 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
415 if (baud_sup[i] > baud)
419 if (i == ARRAY_SIZE(baud_sup))
420 baud = baud_sup[i - 1];
421 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
422 baud = baud_sup[i - 1];
430 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
433 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
436 put_unaligned_le32(baud, buf);
441 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
444 unsigned int baseline, mantissa, exponent;
447 * Apparently the formula is:
448 * baudrate = 12M * 32 / (mantissa * 4^exponent)
450 * mantissa = buf[8:0]
451 * exponent = buf[11:9]
453 baseline = 12000000 * 32;
454 mantissa = baseline / baud;
456 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
458 while (mantissa >= 512) {
460 mantissa >>= 2; /* divide by 4 */
463 /* Exponent is maxed. Trim mantissa and leave. */
471 buf[1] = exponent << 1 | mantissa >> 8;
472 buf[0] = mantissa & 0xff;
474 /* Calculate and return the exact baud rate. */
475 baud = (baseline / mantissa) >> (exponent << 1);
480 static void pl2303_encode_baud_rate(struct tty_struct *tty,
481 struct usb_serial_port *port,
484 struct usb_serial *serial = port->serial;
485 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
489 baud = tty_get_baud_rate(tty);
490 dev_dbg(&port->dev, "baud requested = %u\n", baud);
494 if (spriv->type->max_baud_rate)
495 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
497 * Use direct method for supported baud rates, otherwise use divisors.
499 baud_sup = pl2303_get_supported_baud_rate(baud);
501 if (baud == baud_sup)
502 baud = pl2303_encode_baud_rate_direct(buf, baud);
504 baud = pl2303_encode_baud_rate_divisor(buf, baud);
506 /* Save resulting baud rate */
507 tty_encode_baud_rate(tty, baud, baud);
508 dev_dbg(&port->dev, "baud set = %u\n", baud);
511 static int pl2303_get_line_request(struct usb_serial_port *port,
512 unsigned char buf[7])
514 struct usb_device *udev = port->serial->dev;
517 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
518 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
521 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
529 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
534 static int pl2303_set_line_request(struct usb_serial_port *port,
535 unsigned char buf[7])
537 struct usb_device *udev = port->serial->dev;
540 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
541 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
544 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
548 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
553 static void pl2303_set_termios(struct tty_struct *tty,
554 struct usb_serial_port *port, struct ktermios *old_termios)
556 struct usb_serial *serial = port->serial;
557 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
558 struct pl2303_private *priv = usb_get_serial_port_data(port);
564 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
567 buf = kzalloc(7, GFP_KERNEL);
569 /* Report back no change occurred */
571 tty->termios = *old_termios;
575 pl2303_get_line_request(port, buf);
577 switch (C_CSIZE(tty)) {
591 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
593 /* For reference buf[0]:buf[3] baud rate value */
594 pl2303_encode_baud_rate(tty, port, &buf[0]);
596 /* For reference buf[4]=0 is 1 stop bits */
597 /* For reference buf[4]=1 is 1.5 stop bits */
598 /* For reference buf[4]=2 is 2 stop bits */
601 * NOTE: Comply with "real" UARTs / RS232:
602 * use 1.5 instead of 2 stop bits with 5 data bits
604 if (C_CSIZE(tty) == CS5) {
606 dev_dbg(&port->dev, "stop bits = 1.5\n");
609 dev_dbg(&port->dev, "stop bits = 2\n");
613 dev_dbg(&port->dev, "stop bits = 1\n");
617 /* For reference buf[5]=0 is none parity */
618 /* For reference buf[5]=1 is odd parity */
619 /* For reference buf[5]=2 is even parity */
620 /* For reference buf[5]=3 is mark parity */
621 /* For reference buf[5]=4 is space parity */
625 dev_dbg(&port->dev, "parity = mark\n");
628 dev_dbg(&port->dev, "parity = odd\n");
633 dev_dbg(&port->dev, "parity = space\n");
636 dev_dbg(&port->dev, "parity = even\n");
641 dev_dbg(&port->dev, "parity = none\n");
645 * Some PL2303 are known to lose bytes if you change serial settings
646 * even to the same values as before. Thus we actually need to filter
647 * in this specific case.
649 * Note that the tty_termios_hw_change check above is not sufficient
650 * as a previously requested baud rate may differ from the one
651 * actually used (and stored in old_termios).
653 * NOTE: No additional locking needed for line_settings as it is
654 * only used in set_termios, which is serialised against itself.
656 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
657 ret = pl2303_set_line_request(port, buf);
659 memcpy(priv->line_settings, buf, 7);
662 /* change control lines if we are switching to or from B0 */
663 spin_lock_irqsave(&priv->lock, flags);
664 control = priv->line_control;
665 if (C_BAUD(tty) == B0)
666 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
667 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
668 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
669 if (control != priv->line_control) {
670 control = priv->line_control;
671 spin_unlock_irqrestore(&priv->lock, flags);
672 pl2303_set_control_lines(port, control);
674 spin_unlock_irqrestore(&priv->lock, flags);
677 if (C_CRTSCTS(tty)) {
678 if (spriv->quirks & PL2303_QUIRK_LEGACY)
679 pl2303_vendor_write(serial, 0x0, 0x41);
681 pl2303_vendor_write(serial, 0x0, 0x61);
683 pl2303_vendor_write(serial, 0x0, 0x0);
689 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
691 struct pl2303_private *priv = usb_get_serial_port_data(port);
695 spin_lock_irqsave(&priv->lock, flags);
697 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
699 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
700 control = priv->line_control;
701 spin_unlock_irqrestore(&priv->lock, flags);
703 pl2303_set_control_lines(port, control);
706 static void pl2303_close(struct usb_serial_port *port)
708 usb_serial_generic_close(port);
709 usb_kill_urb(port->interrupt_in_urb);
710 pl2303_set_break(port, false);
713 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
715 struct usb_serial *serial = port->serial;
716 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
719 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
720 usb_clear_halt(serial->dev, port->write_urb->pipe);
721 usb_clear_halt(serial->dev, port->read_urb->pipe);
723 /* reset upstream data pipes */
724 pl2303_vendor_write(serial, 8, 0);
725 pl2303_vendor_write(serial, 9, 0);
730 pl2303_set_termios(tty, port, NULL);
732 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
734 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
739 result = usb_serial_generic_open(tty, port);
741 usb_kill_urb(port->interrupt_in_urb);
748 static int pl2303_tiocmset(struct tty_struct *tty,
749 unsigned int set, unsigned int clear)
751 struct usb_serial_port *port = tty->driver_data;
752 struct pl2303_private *priv = usb_get_serial_port_data(port);
757 spin_lock_irqsave(&priv->lock, flags);
759 priv->line_control |= CONTROL_RTS;
761 priv->line_control |= CONTROL_DTR;
762 if (clear & TIOCM_RTS)
763 priv->line_control &= ~CONTROL_RTS;
764 if (clear & TIOCM_DTR)
765 priv->line_control &= ~CONTROL_DTR;
766 control = priv->line_control;
767 spin_unlock_irqrestore(&priv->lock, flags);
769 ret = pl2303_set_control_lines(port, control);
771 return usb_translate_errors(ret);
776 static int pl2303_tiocmget(struct tty_struct *tty)
778 struct usb_serial_port *port = tty->driver_data;
779 struct pl2303_private *priv = usb_get_serial_port_data(port);
785 spin_lock_irqsave(&priv->lock, flags);
786 mcr = priv->line_control;
787 status = priv->line_status;
788 spin_unlock_irqrestore(&priv->lock, flags);
790 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
791 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
792 | ((status & UART_CTS) ? TIOCM_CTS : 0)
793 | ((status & UART_DSR) ? TIOCM_DSR : 0)
794 | ((status & UART_RING) ? TIOCM_RI : 0)
795 | ((status & UART_DCD) ? TIOCM_CD : 0);
797 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
802 static int pl2303_carrier_raised(struct usb_serial_port *port)
804 struct pl2303_private *priv = usb_get_serial_port_data(port);
806 if (priv->line_status & UART_DCD)
812 static int pl2303_ioctl(struct tty_struct *tty,
813 unsigned int cmd, unsigned long arg)
815 struct serial_struct ser;
816 struct usb_serial_port *port = tty->driver_data;
820 memset(&ser, 0, sizeof ser);
821 ser.type = PORT_16654;
822 ser.line = port->minor;
823 ser.port = port->port_number;
824 ser.baud_base = 460800;
826 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
837 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
839 struct usb_serial *serial = port->serial;
848 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
849 state == BREAK_OFF ? "off" : "on");
851 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
852 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
855 dev_err(&port->dev, "error sending break = %d\n", result);
858 static void pl2303_break_ctl(struct tty_struct *tty, int state)
860 struct usb_serial_port *port = tty->driver_data;
862 pl2303_set_break(port, state);
865 static void pl2303_update_line_status(struct usb_serial_port *port,
867 unsigned int actual_length)
869 struct usb_serial *serial = port->serial;
870 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
871 struct pl2303_private *priv = usb_get_serial_port_data(port);
872 struct tty_struct *tty;
874 unsigned int status_idx = UART_STATE_INDEX;
878 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
881 if (actual_length < status_idx + 1)
884 status = data[status_idx];
886 /* Save off the uart status for others to look at */
887 spin_lock_irqsave(&priv->lock, flags);
888 delta = priv->line_status ^ status;
889 priv->line_status = status;
890 spin_unlock_irqrestore(&priv->lock, flags);
892 if (status & UART_BREAK_ERROR)
893 usb_serial_handle_break(port);
895 if (delta & UART_STATE_MSR_MASK) {
896 if (delta & UART_CTS)
898 if (delta & UART_DSR)
900 if (delta & UART_RING)
902 if (delta & UART_DCD) {
904 tty = tty_port_tty_get(&port->port);
906 usb_serial_handle_dcd_change(port, tty,
912 wake_up_interruptible(&port->port.delta_msr_wait);
916 static void pl2303_read_int_callback(struct urb *urb)
918 struct usb_serial_port *port = urb->context;
919 unsigned char *data = urb->transfer_buffer;
920 unsigned int actual_length = urb->actual_length;
921 int status = urb->status;
931 /* this urb is terminated, clean up */
932 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
936 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
941 usb_serial_debug_data(&port->dev, __func__,
942 urb->actual_length, urb->transfer_buffer);
944 pl2303_update_line_status(port, data, actual_length);
947 retval = usb_submit_urb(urb, GFP_ATOMIC);
950 "%s - usb_submit_urb failed with result %d\n",
955 static void pl2303_process_read_urb(struct urb *urb)
957 struct usb_serial_port *port = urb->context;
958 struct pl2303_private *priv = usb_get_serial_port_data(port);
959 unsigned char *data = urb->transfer_buffer;
960 char tty_flag = TTY_NORMAL;
965 /* update line status */
966 spin_lock_irqsave(&priv->lock, flags);
967 line_status = priv->line_status;
968 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
969 spin_unlock_irqrestore(&priv->lock, flags);
971 if (!urb->actual_length)
975 * Break takes precedence over parity, which takes precedence over
978 if (line_status & UART_BREAK_ERROR)
979 tty_flag = TTY_BREAK;
980 else if (line_status & UART_PARITY_ERROR)
981 tty_flag = TTY_PARITY;
982 else if (line_status & UART_FRAME_ERROR)
983 tty_flag = TTY_FRAME;
985 if (tty_flag != TTY_NORMAL)
986 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
988 /* overrun is special, not associated with a char */
989 if (line_status & UART_OVERRUN_ERROR)
990 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
992 if (port->port.console && port->sysrq) {
993 for (i = 0; i < urb->actual_length; ++i)
994 if (!usb_serial_handle_sysrq_char(port, data[i]))
995 tty_insert_flip_char(&port->port, data[i],
998 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1002 tty_flip_buffer_push(&port->port);
1005 static struct usb_serial_driver pl2303_device = {
1007 .owner = THIS_MODULE,
1010 .id_table = id_table,
1013 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1014 .bulk_in_size = 256,
1015 .bulk_out_size = 256,
1016 .open = pl2303_open,
1017 .close = pl2303_close,
1018 .dtr_rts = pl2303_dtr_rts,
1019 .carrier_raised = pl2303_carrier_raised,
1020 .ioctl = pl2303_ioctl,
1021 .break_ctl = pl2303_break_ctl,
1022 .set_termios = pl2303_set_termios,
1023 .tiocmget = pl2303_tiocmget,
1024 .tiocmset = pl2303_tiocmset,
1025 .tiocmiwait = usb_serial_generic_tiocmiwait,
1026 .process_read_urb = pl2303_process_read_urb,
1027 .read_int_callback = pl2303_read_int_callback,
1028 .probe = pl2303_probe,
1029 .calc_num_ports = pl2303_calc_num_ports,
1030 .attach = pl2303_startup,
1031 .release = pl2303_release,
1032 .port_probe = pl2303_port_probe,
1033 .port_remove = pl2303_port_remove,
1036 static struct usb_serial_driver * const serial_drivers[] = {
1037 &pl2303_device, NULL
1040 module_usb_serial_driver(serial_drivers, id_table);
1042 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1043 MODULE_LICENSE("GPL");