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)
37 static const struct usb_device_id id_table[] = {
38 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
51 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
52 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
53 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
54 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485) },
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 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
76 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
77 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
78 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
79 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
80 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
81 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
82 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
83 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
84 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
85 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
86 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
87 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
88 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
89 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
90 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
91 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
92 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
93 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
94 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
95 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
96 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
98 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
100 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
101 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
102 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
103 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
104 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
105 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
106 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
107 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_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);
233 static int pl2303_startup(struct usb_serial *serial)
235 struct pl2303_serial_private *spriv;
236 unsigned char num_ports = serial->num_ports;
237 enum pl2303_type type = TYPE_01;
240 if (serial->num_bulk_in < num_ports ||
241 serial->num_bulk_out < num_ports ||
242 serial->num_interrupt_in < num_ports) {
243 dev_err(&serial->interface->dev, "missing endpoints\n");
247 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
251 buf = kmalloc(1, GFP_KERNEL);
257 if (serial->dev->descriptor.bDeviceClass == 0x02)
258 type = TYPE_01; /* type 0 */
259 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
261 else if (serial->dev->descriptor.bDeviceClass == 0x00)
262 type = TYPE_01; /* type 1 */
263 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
264 type = TYPE_01; /* type 1 */
265 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
267 spriv->type = &pl2303_type_data[type];
268 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
269 spriv->quirks |= spriv->type->quirks;
271 usb_set_serial_data(serial, spriv);
273 pl2303_vendor_read(serial, 0x8484, buf);
274 pl2303_vendor_write(serial, 0x0404, 0);
275 pl2303_vendor_read(serial, 0x8484, buf);
276 pl2303_vendor_read(serial, 0x8383, buf);
277 pl2303_vendor_read(serial, 0x8484, buf);
278 pl2303_vendor_write(serial, 0x0404, 1);
279 pl2303_vendor_read(serial, 0x8484, buf);
280 pl2303_vendor_read(serial, 0x8383, buf);
281 pl2303_vendor_write(serial, 0, 1);
282 pl2303_vendor_write(serial, 1, 0);
283 if (spriv->quirks & PL2303_QUIRK_LEGACY)
284 pl2303_vendor_write(serial, 2, 0x24);
286 pl2303_vendor_write(serial, 2, 0x44);
293 static void pl2303_release(struct usb_serial *serial)
295 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
300 static int pl2303_port_probe(struct usb_serial_port *port)
302 struct pl2303_private *priv;
304 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
308 spin_lock_init(&priv->lock);
310 usb_set_serial_port_data(port, priv);
312 port->port.drain_delay = 256;
317 static int pl2303_port_remove(struct usb_serial_port *port)
319 struct pl2303_private *priv = usb_get_serial_port_data(port);
326 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
328 struct usb_device *dev = port->serial->dev;
331 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
333 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
334 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
335 value, 0, NULL, 0, 100);
337 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
343 * Returns the nearest supported baud rate that can be set directly without
346 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
348 static const speed_t baud_sup[] = {
349 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
350 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
351 614400, 921600, 1228800, 2457600, 3000000, 6000000
356 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
357 if (baud_sup[i] > baud)
361 if (i == ARRAY_SIZE(baud_sup))
362 baud = baud_sup[i - 1];
363 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
364 baud = baud_sup[i - 1];
372 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
375 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
378 put_unaligned_le32(baud, buf);
383 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
386 unsigned int baseline, mantissa, exponent;
389 * Apparently the formula is:
390 * baudrate = 12M * 32 / (mantissa * 4^exponent)
392 * mantissa = buf[8:0]
393 * exponent = buf[11:9]
395 baseline = 12000000 * 32;
396 mantissa = baseline / baud;
398 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
400 while (mantissa >= 512) {
402 mantissa >>= 2; /* divide by 4 */
405 /* Exponent is maxed. Trim mantissa and leave. */
413 buf[1] = exponent << 1 | mantissa >> 8;
414 buf[0] = mantissa & 0xff;
416 /* Calculate and return the exact baud rate. */
417 baud = (baseline / mantissa) >> (exponent << 1);
422 static void pl2303_encode_baud_rate(struct tty_struct *tty,
423 struct usb_serial_port *port,
426 struct usb_serial *serial = port->serial;
427 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
431 baud = tty_get_baud_rate(tty);
432 dev_dbg(&port->dev, "baud requested = %u\n", baud);
436 if (spriv->type->max_baud_rate)
437 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
439 * Use direct method for supported baud rates, otherwise use divisors.
441 baud_sup = pl2303_get_supported_baud_rate(baud);
443 if (baud == baud_sup)
444 baud = pl2303_encode_baud_rate_direct(buf, baud);
446 baud = pl2303_encode_baud_rate_divisor(buf, baud);
448 /* Save resulting baud rate */
449 tty_encode_baud_rate(tty, baud, baud);
450 dev_dbg(&port->dev, "baud set = %u\n", baud);
453 static int pl2303_get_line_request(struct usb_serial_port *port,
454 unsigned char buf[7])
456 struct usb_device *udev = port->serial->dev;
459 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
460 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
463 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
471 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
476 static int pl2303_set_line_request(struct usb_serial_port *port,
477 unsigned char buf[7])
479 struct usb_device *udev = port->serial->dev;
482 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
483 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
486 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
494 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
499 static void pl2303_set_termios(struct tty_struct *tty,
500 struct usb_serial_port *port, struct ktermios *old_termios)
502 struct usb_serial *serial = port->serial;
503 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
504 struct pl2303_private *priv = usb_get_serial_port_data(port);
510 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
513 buf = kzalloc(7, GFP_KERNEL);
515 /* Report back no change occurred */
517 tty->termios = *old_termios;
521 pl2303_get_line_request(port, buf);
523 switch (C_CSIZE(tty)) {
537 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
539 /* For reference buf[0]:buf[3] baud rate value */
540 pl2303_encode_baud_rate(tty, port, &buf[0]);
542 /* For reference buf[4]=0 is 1 stop bits */
543 /* For reference buf[4]=1 is 1.5 stop bits */
544 /* For reference buf[4]=2 is 2 stop bits */
547 * NOTE: Comply with "real" UARTs / RS232:
548 * use 1.5 instead of 2 stop bits with 5 data bits
550 if (C_CSIZE(tty) == CS5) {
552 dev_dbg(&port->dev, "stop bits = 1.5\n");
555 dev_dbg(&port->dev, "stop bits = 2\n");
559 dev_dbg(&port->dev, "stop bits = 1\n");
563 /* For reference buf[5]=0 is none parity */
564 /* For reference buf[5]=1 is odd parity */
565 /* For reference buf[5]=2 is even parity */
566 /* For reference buf[5]=3 is mark parity */
567 /* For reference buf[5]=4 is space parity */
571 dev_dbg(&port->dev, "parity = mark\n");
574 dev_dbg(&port->dev, "parity = odd\n");
579 dev_dbg(&port->dev, "parity = space\n");
582 dev_dbg(&port->dev, "parity = even\n");
587 dev_dbg(&port->dev, "parity = none\n");
591 * Some PL2303 are known to lose bytes if you change serial settings
592 * even to the same values as before. Thus we actually need to filter
593 * in this specific case.
595 * Note that the tty_termios_hw_change check above is not sufficient
596 * as a previously requested baud rate may differ from the one
597 * actually used (and stored in old_termios).
599 * NOTE: No additional locking needed for line_settings as it is
600 * only used in set_termios, which is serialised against itself.
602 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
603 ret = pl2303_set_line_request(port, buf);
605 memcpy(priv->line_settings, buf, 7);
608 /* change control lines if we are switching to or from B0 */
609 spin_lock_irqsave(&priv->lock, flags);
610 control = priv->line_control;
611 if (C_BAUD(tty) == B0)
612 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
613 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
614 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
615 if (control != priv->line_control) {
616 control = priv->line_control;
617 spin_unlock_irqrestore(&priv->lock, flags);
618 pl2303_set_control_lines(port, control);
620 spin_unlock_irqrestore(&priv->lock, flags);
623 if (C_CRTSCTS(tty)) {
624 if (spriv->quirks & PL2303_QUIRK_LEGACY)
625 pl2303_vendor_write(serial, 0x0, 0x41);
627 pl2303_vendor_write(serial, 0x0, 0x61);
629 pl2303_vendor_write(serial, 0x0, 0x0);
635 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
637 struct pl2303_private *priv = usb_get_serial_port_data(port);
641 spin_lock_irqsave(&priv->lock, flags);
643 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
645 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
646 control = priv->line_control;
647 spin_unlock_irqrestore(&priv->lock, flags);
649 pl2303_set_control_lines(port, control);
652 static void pl2303_close(struct usb_serial_port *port)
654 usb_serial_generic_close(port);
655 usb_kill_urb(port->interrupt_in_urb);
656 pl2303_set_break(port, false);
659 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
661 struct usb_serial *serial = port->serial;
662 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
665 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
666 usb_clear_halt(serial->dev, port->write_urb->pipe);
667 usb_clear_halt(serial->dev, port->read_urb->pipe);
669 /* reset upstream data pipes */
670 pl2303_vendor_write(serial, 8, 0);
671 pl2303_vendor_write(serial, 9, 0);
676 pl2303_set_termios(tty, port, NULL);
678 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
680 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
685 result = usb_serial_generic_open(tty, port);
687 usb_kill_urb(port->interrupt_in_urb);
694 static int pl2303_tiocmset(struct tty_struct *tty,
695 unsigned int set, unsigned int clear)
697 struct usb_serial_port *port = tty->driver_data;
698 struct pl2303_private *priv = usb_get_serial_port_data(port);
703 spin_lock_irqsave(&priv->lock, flags);
705 priv->line_control |= CONTROL_RTS;
707 priv->line_control |= CONTROL_DTR;
708 if (clear & TIOCM_RTS)
709 priv->line_control &= ~CONTROL_RTS;
710 if (clear & TIOCM_DTR)
711 priv->line_control &= ~CONTROL_DTR;
712 control = priv->line_control;
713 spin_unlock_irqrestore(&priv->lock, flags);
715 ret = pl2303_set_control_lines(port, control);
717 return usb_translate_errors(ret);
722 static int pl2303_tiocmget(struct tty_struct *tty)
724 struct usb_serial_port *port = tty->driver_data;
725 struct pl2303_private *priv = usb_get_serial_port_data(port);
731 spin_lock_irqsave(&priv->lock, flags);
732 mcr = priv->line_control;
733 status = priv->line_status;
734 spin_unlock_irqrestore(&priv->lock, flags);
736 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
737 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
738 | ((status & UART_CTS) ? TIOCM_CTS : 0)
739 | ((status & UART_DSR) ? TIOCM_DSR : 0)
740 | ((status & UART_RING) ? TIOCM_RI : 0)
741 | ((status & UART_DCD) ? TIOCM_CD : 0);
743 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
748 static int pl2303_carrier_raised(struct usb_serial_port *port)
750 struct pl2303_private *priv = usb_get_serial_port_data(port);
752 if (priv->line_status & UART_DCD)
758 static int pl2303_ioctl(struct tty_struct *tty,
759 unsigned int cmd, unsigned long arg)
761 struct serial_struct ser;
762 struct usb_serial_port *port = tty->driver_data;
766 memset(&ser, 0, sizeof ser);
767 ser.type = PORT_16654;
768 ser.line = port->minor;
769 ser.port = port->port_number;
770 ser.baud_base = 460800;
772 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
783 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
785 struct usb_serial *serial = port->serial;
794 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
795 state == BREAK_OFF ? "off" : "on");
797 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
798 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
801 dev_err(&port->dev, "error sending break = %d\n", result);
804 static void pl2303_break_ctl(struct tty_struct *tty, int state)
806 struct usb_serial_port *port = tty->driver_data;
808 pl2303_set_break(port, state);
811 static void pl2303_update_line_status(struct usb_serial_port *port,
813 unsigned int actual_length)
815 struct usb_serial *serial = port->serial;
816 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
817 struct pl2303_private *priv = usb_get_serial_port_data(port);
818 struct tty_struct *tty;
820 unsigned int status_idx = UART_STATE_INDEX;
824 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
827 if (actual_length < status_idx + 1)
830 status = data[status_idx];
832 /* Save off the uart status for others to look at */
833 spin_lock_irqsave(&priv->lock, flags);
834 delta = priv->line_status ^ status;
835 priv->line_status = status;
836 spin_unlock_irqrestore(&priv->lock, flags);
838 if (status & UART_BREAK_ERROR)
839 usb_serial_handle_break(port);
841 if (delta & UART_STATE_MSR_MASK) {
842 if (delta & UART_CTS)
844 if (delta & UART_DSR)
846 if (delta & UART_RING)
848 if (delta & UART_DCD) {
850 tty = tty_port_tty_get(&port->port);
852 usb_serial_handle_dcd_change(port, tty,
858 wake_up_interruptible(&port->port.delta_msr_wait);
862 static void pl2303_read_int_callback(struct urb *urb)
864 struct usb_serial_port *port = urb->context;
865 unsigned char *data = urb->transfer_buffer;
866 unsigned int actual_length = urb->actual_length;
867 int status = urb->status;
877 /* this urb is terminated, clean up */
878 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
882 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
887 usb_serial_debug_data(&port->dev, __func__,
888 urb->actual_length, urb->transfer_buffer);
890 pl2303_update_line_status(port, data, actual_length);
893 retval = usb_submit_urb(urb, GFP_ATOMIC);
896 "%s - usb_submit_urb failed with result %d\n",
901 static void pl2303_process_read_urb(struct urb *urb)
903 struct usb_serial_port *port = urb->context;
904 struct pl2303_private *priv = usb_get_serial_port_data(port);
905 unsigned char *data = urb->transfer_buffer;
906 char tty_flag = TTY_NORMAL;
911 /* update line status */
912 spin_lock_irqsave(&priv->lock, flags);
913 line_status = priv->line_status;
914 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
915 spin_unlock_irqrestore(&priv->lock, flags);
917 if (!urb->actual_length)
921 * Break takes precedence over parity, which takes precedence over
924 if (line_status & UART_BREAK_ERROR)
925 tty_flag = TTY_BREAK;
926 else if (line_status & UART_PARITY_ERROR)
927 tty_flag = TTY_PARITY;
928 else if (line_status & UART_FRAME_ERROR)
929 tty_flag = TTY_FRAME;
931 if (tty_flag != TTY_NORMAL)
932 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
934 /* overrun is special, not associated with a char */
935 if (line_status & UART_OVERRUN_ERROR)
936 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
938 if (port->port.console && port->sysrq) {
939 for (i = 0; i < urb->actual_length; ++i)
940 if (!usb_serial_handle_sysrq_char(port, data[i]))
941 tty_insert_flip_char(&port->port, data[i],
944 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
948 tty_flip_buffer_push(&port->port);
951 static struct usb_serial_driver pl2303_device = {
953 .owner = THIS_MODULE,
956 .id_table = id_table,
959 .bulk_out_size = 256,
961 .close = pl2303_close,
962 .dtr_rts = pl2303_dtr_rts,
963 .carrier_raised = pl2303_carrier_raised,
964 .ioctl = pl2303_ioctl,
965 .break_ctl = pl2303_break_ctl,
966 .set_termios = pl2303_set_termios,
967 .tiocmget = pl2303_tiocmget,
968 .tiocmset = pl2303_tiocmset,
969 .tiocmiwait = usb_serial_generic_tiocmiwait,
970 .process_read_urb = pl2303_process_read_urb,
971 .read_int_callback = pl2303_read_int_callback,
972 .probe = pl2303_probe,
973 .attach = pl2303_startup,
974 .release = pl2303_release,
975 .port_probe = pl2303_port_probe,
976 .port_remove = pl2303_port_remove,
979 static struct usb_serial_driver * const serial_drivers[] = {
983 module_usb_serial_driver(serial_drivers, id_table);
985 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
986 MODULE_LICENSE("GPL");