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_LM930_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
101 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
102 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
103 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
104 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
105 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
106 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
107 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
108 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
109 { USB_DEVICE(IBM_VENDOR_ID, IBM_PRODUCT_ID) },
110 { } /* Terminating entry */
113 MODULE_DEVICE_TABLE(usb, id_table);
115 #define SET_LINE_REQUEST_TYPE 0x21
116 #define SET_LINE_REQUEST 0x20
118 #define SET_CONTROL_REQUEST_TYPE 0x21
119 #define SET_CONTROL_REQUEST 0x22
120 #define CONTROL_DTR 0x01
121 #define CONTROL_RTS 0x02
123 #define BREAK_REQUEST_TYPE 0x21
124 #define BREAK_REQUEST 0x23
125 #define BREAK_ON 0xffff
126 #define BREAK_OFF 0x0000
128 #define GET_LINE_REQUEST_TYPE 0xa1
129 #define GET_LINE_REQUEST 0x21
131 #define VENDOR_WRITE_REQUEST_TYPE 0x40
132 #define VENDOR_WRITE_REQUEST 0x01
134 #define VENDOR_READ_REQUEST_TYPE 0xc0
135 #define VENDOR_READ_REQUEST 0x01
137 #define UART_STATE_INDEX 8
138 #define UART_STATE_MSR_MASK 0x8b
139 #define UART_STATE_TRANSIENT_MASK 0x74
140 #define UART_DCD 0x01
141 #define UART_DSR 0x02
142 #define UART_BREAK_ERROR 0x04
143 #define UART_RING 0x08
144 #define UART_FRAME_ERROR 0x10
145 #define UART_PARITY_ERROR 0x20
146 #define UART_OVERRUN_ERROR 0x40
147 #define UART_CTS 0x80
149 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
152 TYPE_01, /* Type 0 and 1 (difference unknown) */
153 TYPE_HX, /* HX version of the pl2303 chip */
157 struct pl2303_type_data {
158 speed_t max_baud_rate;
159 unsigned long quirks;
162 struct pl2303_serial_private {
163 const struct pl2303_type_data *type;
164 unsigned long quirks;
167 struct pl2303_private {
175 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
177 .max_baud_rate = 1228800,
178 .quirks = PL2303_QUIRK_LEGACY,
181 .max_baud_rate = 12000000,
185 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
186 unsigned char buf[1])
188 struct device *dev = &serial->interface->dev;
191 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
192 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
193 value, 0, buf, 1, 100);
195 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
203 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
208 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
210 struct device *dev = &serial->interface->dev;
213 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
215 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
216 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
217 value, index, NULL, 0, 100);
219 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
227 static int pl2303_probe(struct usb_serial *serial,
228 const struct usb_device_id *id)
230 usb_set_serial_data(serial, (void *)id->driver_info);
235 static int pl2303_startup(struct usb_serial *serial)
237 struct pl2303_serial_private *spriv;
238 unsigned char num_ports = serial->num_ports;
239 enum pl2303_type type = TYPE_01;
242 if (serial->num_bulk_in < num_ports ||
243 serial->num_bulk_out < num_ports ||
244 serial->num_interrupt_in < num_ports) {
245 dev_err(&serial->interface->dev, "missing endpoints\n");
249 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
253 buf = kmalloc(1, GFP_KERNEL);
259 if (serial->dev->descriptor.bDeviceClass == 0x02)
260 type = TYPE_01; /* type 0 */
261 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
263 else if (serial->dev->descriptor.bDeviceClass == 0x00)
264 type = TYPE_01; /* type 1 */
265 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
266 type = TYPE_01; /* type 1 */
267 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
269 spriv->type = &pl2303_type_data[type];
270 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
271 spriv->quirks |= spriv->type->quirks;
273 usb_set_serial_data(serial, spriv);
275 pl2303_vendor_read(serial, 0x8484, buf);
276 pl2303_vendor_write(serial, 0x0404, 0);
277 pl2303_vendor_read(serial, 0x8484, buf);
278 pl2303_vendor_read(serial, 0x8383, buf);
279 pl2303_vendor_read(serial, 0x8484, buf);
280 pl2303_vendor_write(serial, 0x0404, 1);
281 pl2303_vendor_read(serial, 0x8484, buf);
282 pl2303_vendor_read(serial, 0x8383, buf);
283 pl2303_vendor_write(serial, 0, 1);
284 pl2303_vendor_write(serial, 1, 0);
285 if (spriv->quirks & PL2303_QUIRK_LEGACY)
286 pl2303_vendor_write(serial, 2, 0x24);
288 pl2303_vendor_write(serial, 2, 0x44);
295 static void pl2303_release(struct usb_serial *serial)
297 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
302 static int pl2303_port_probe(struct usb_serial_port *port)
304 struct pl2303_private *priv;
306 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
310 spin_lock_init(&priv->lock);
312 usb_set_serial_port_data(port, priv);
314 port->port.drain_delay = 256;
319 static int pl2303_port_remove(struct usb_serial_port *port)
321 struct pl2303_private *priv = usb_get_serial_port_data(port);
328 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
330 struct usb_device *dev = port->serial->dev;
333 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
335 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
336 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
337 value, 0, NULL, 0, 100);
339 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
345 * Returns the nearest supported baud rate that can be set directly without
348 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
350 static const speed_t baud_sup[] = {
351 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
352 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
353 614400, 921600, 1228800, 2457600, 3000000, 6000000
358 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
359 if (baud_sup[i] > baud)
363 if (i == ARRAY_SIZE(baud_sup))
364 baud = baud_sup[i - 1];
365 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
366 baud = baud_sup[i - 1];
374 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
377 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
380 put_unaligned_le32(baud, buf);
385 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
388 unsigned int baseline, mantissa, exponent;
391 * Apparently the formula is:
392 * baudrate = 12M * 32 / (mantissa * 4^exponent)
394 * mantissa = buf[8:0]
395 * exponent = buf[11:9]
397 baseline = 12000000 * 32;
398 mantissa = baseline / baud;
400 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
402 while (mantissa >= 512) {
404 mantissa >>= 2; /* divide by 4 */
407 /* Exponent is maxed. Trim mantissa and leave. */
415 buf[1] = exponent << 1 | mantissa >> 8;
416 buf[0] = mantissa & 0xff;
418 /* Calculate and return the exact baud rate. */
419 baud = (baseline / mantissa) >> (exponent << 1);
424 static void pl2303_encode_baud_rate(struct tty_struct *tty,
425 struct usb_serial_port *port,
428 struct usb_serial *serial = port->serial;
429 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
433 baud = tty_get_baud_rate(tty);
434 dev_dbg(&port->dev, "baud requested = %u\n", baud);
438 if (spriv->type->max_baud_rate)
439 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
441 * Use direct method for supported baud rates, otherwise use divisors.
443 baud_sup = pl2303_get_supported_baud_rate(baud);
445 if (baud == baud_sup)
446 baud = pl2303_encode_baud_rate_direct(buf, baud);
448 baud = pl2303_encode_baud_rate_divisor(buf, baud);
450 /* Save resulting baud rate */
451 tty_encode_baud_rate(tty, baud, baud);
452 dev_dbg(&port->dev, "baud set = %u\n", baud);
455 static int pl2303_get_line_request(struct usb_serial_port *port,
456 unsigned char buf[7])
458 struct usb_device *udev = port->serial->dev;
461 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
462 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
465 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
473 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
478 static int pl2303_set_line_request(struct usb_serial_port *port,
479 unsigned char buf[7])
481 struct usb_device *udev = port->serial->dev;
484 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
485 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
488 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
496 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
501 static void pl2303_set_termios(struct tty_struct *tty,
502 struct usb_serial_port *port, struct ktermios *old_termios)
504 struct usb_serial *serial = port->serial;
505 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
506 struct pl2303_private *priv = usb_get_serial_port_data(port);
512 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
515 buf = kzalloc(7, GFP_KERNEL);
517 /* Report back no change occurred */
519 tty->termios = *old_termios;
523 pl2303_get_line_request(port, buf);
525 switch (C_CSIZE(tty)) {
539 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
541 /* For reference buf[0]:buf[3] baud rate value */
542 pl2303_encode_baud_rate(tty, port, &buf[0]);
544 /* For reference buf[4]=0 is 1 stop bits */
545 /* For reference buf[4]=1 is 1.5 stop bits */
546 /* For reference buf[4]=2 is 2 stop bits */
549 * NOTE: Comply with "real" UARTs / RS232:
550 * use 1.5 instead of 2 stop bits with 5 data bits
552 if (C_CSIZE(tty) == CS5) {
554 dev_dbg(&port->dev, "stop bits = 1.5\n");
557 dev_dbg(&port->dev, "stop bits = 2\n");
561 dev_dbg(&port->dev, "stop bits = 1\n");
565 /* For reference buf[5]=0 is none parity */
566 /* For reference buf[5]=1 is odd parity */
567 /* For reference buf[5]=2 is even parity */
568 /* For reference buf[5]=3 is mark parity */
569 /* For reference buf[5]=4 is space parity */
573 dev_dbg(&port->dev, "parity = mark\n");
576 dev_dbg(&port->dev, "parity = odd\n");
581 dev_dbg(&port->dev, "parity = space\n");
584 dev_dbg(&port->dev, "parity = even\n");
589 dev_dbg(&port->dev, "parity = none\n");
593 * Some PL2303 are known to lose bytes if you change serial settings
594 * even to the same values as before. Thus we actually need to filter
595 * in this specific case.
597 * Note that the tty_termios_hw_change check above is not sufficient
598 * as a previously requested baud rate may differ from the one
599 * actually used (and stored in old_termios).
601 * NOTE: No additional locking needed for line_settings as it is
602 * only used in set_termios, which is serialised against itself.
604 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
605 ret = pl2303_set_line_request(port, buf);
607 memcpy(priv->line_settings, buf, 7);
610 /* change control lines if we are switching to or from B0 */
611 spin_lock_irqsave(&priv->lock, flags);
612 control = priv->line_control;
613 if (C_BAUD(tty) == B0)
614 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
615 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
616 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
617 if (control != priv->line_control) {
618 control = priv->line_control;
619 spin_unlock_irqrestore(&priv->lock, flags);
620 pl2303_set_control_lines(port, control);
622 spin_unlock_irqrestore(&priv->lock, flags);
625 if (C_CRTSCTS(tty)) {
626 if (spriv->quirks & PL2303_QUIRK_LEGACY)
627 pl2303_vendor_write(serial, 0x0, 0x41);
629 pl2303_vendor_write(serial, 0x0, 0x61);
631 pl2303_vendor_write(serial, 0x0, 0x0);
637 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
639 struct pl2303_private *priv = usb_get_serial_port_data(port);
643 spin_lock_irqsave(&priv->lock, flags);
645 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
647 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
648 control = priv->line_control;
649 spin_unlock_irqrestore(&priv->lock, flags);
651 pl2303_set_control_lines(port, control);
654 static void pl2303_close(struct usb_serial_port *port)
656 usb_serial_generic_close(port);
657 usb_kill_urb(port->interrupt_in_urb);
658 pl2303_set_break(port, false);
661 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
663 struct usb_serial *serial = port->serial;
664 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
667 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
668 usb_clear_halt(serial->dev, port->write_urb->pipe);
669 usb_clear_halt(serial->dev, port->read_urb->pipe);
671 /* reset upstream data pipes */
672 pl2303_vendor_write(serial, 8, 0);
673 pl2303_vendor_write(serial, 9, 0);
678 pl2303_set_termios(tty, port, NULL);
680 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
682 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
687 result = usb_serial_generic_open(tty, port);
689 usb_kill_urb(port->interrupt_in_urb);
696 static int pl2303_tiocmset(struct tty_struct *tty,
697 unsigned int set, unsigned int clear)
699 struct usb_serial_port *port = tty->driver_data;
700 struct pl2303_private *priv = usb_get_serial_port_data(port);
705 spin_lock_irqsave(&priv->lock, flags);
707 priv->line_control |= CONTROL_RTS;
709 priv->line_control |= CONTROL_DTR;
710 if (clear & TIOCM_RTS)
711 priv->line_control &= ~CONTROL_RTS;
712 if (clear & TIOCM_DTR)
713 priv->line_control &= ~CONTROL_DTR;
714 control = priv->line_control;
715 spin_unlock_irqrestore(&priv->lock, flags);
717 ret = pl2303_set_control_lines(port, control);
719 return usb_translate_errors(ret);
724 static int pl2303_tiocmget(struct tty_struct *tty)
726 struct usb_serial_port *port = tty->driver_data;
727 struct pl2303_private *priv = usb_get_serial_port_data(port);
733 spin_lock_irqsave(&priv->lock, flags);
734 mcr = priv->line_control;
735 status = priv->line_status;
736 spin_unlock_irqrestore(&priv->lock, flags);
738 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
739 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
740 | ((status & UART_CTS) ? TIOCM_CTS : 0)
741 | ((status & UART_DSR) ? TIOCM_DSR : 0)
742 | ((status & UART_RING) ? TIOCM_RI : 0)
743 | ((status & UART_DCD) ? TIOCM_CD : 0);
745 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
750 static int pl2303_carrier_raised(struct usb_serial_port *port)
752 struct pl2303_private *priv = usb_get_serial_port_data(port);
754 if (priv->line_status & UART_DCD)
760 static int pl2303_ioctl(struct tty_struct *tty,
761 unsigned int cmd, unsigned long arg)
763 struct serial_struct ser;
764 struct usb_serial_port *port = tty->driver_data;
768 memset(&ser, 0, sizeof ser);
769 ser.type = PORT_16654;
770 ser.line = port->minor;
771 ser.port = port->port_number;
772 ser.baud_base = 460800;
774 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
785 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
787 struct usb_serial *serial = port->serial;
796 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
797 state == BREAK_OFF ? "off" : "on");
799 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
800 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
803 dev_err(&port->dev, "error sending break = %d\n", result);
806 static void pl2303_break_ctl(struct tty_struct *tty, int state)
808 struct usb_serial_port *port = tty->driver_data;
810 pl2303_set_break(port, state);
813 static void pl2303_update_line_status(struct usb_serial_port *port,
815 unsigned int actual_length)
817 struct usb_serial *serial = port->serial;
818 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
819 struct pl2303_private *priv = usb_get_serial_port_data(port);
820 struct tty_struct *tty;
822 unsigned int status_idx = UART_STATE_INDEX;
826 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
829 if (actual_length < status_idx + 1)
832 status = data[status_idx];
834 /* Save off the uart status for others to look at */
835 spin_lock_irqsave(&priv->lock, flags);
836 delta = priv->line_status ^ status;
837 priv->line_status = status;
838 spin_unlock_irqrestore(&priv->lock, flags);
840 if (status & UART_BREAK_ERROR)
841 usb_serial_handle_break(port);
843 if (delta & UART_STATE_MSR_MASK) {
844 if (delta & UART_CTS)
846 if (delta & UART_DSR)
848 if (delta & UART_RING)
850 if (delta & UART_DCD) {
852 tty = tty_port_tty_get(&port->port);
854 usb_serial_handle_dcd_change(port, tty,
860 wake_up_interruptible(&port->port.delta_msr_wait);
864 static void pl2303_read_int_callback(struct urb *urb)
866 struct usb_serial_port *port = urb->context;
867 unsigned char *data = urb->transfer_buffer;
868 unsigned int actual_length = urb->actual_length;
869 int status = urb->status;
879 /* this urb is terminated, clean up */
880 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
884 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
889 usb_serial_debug_data(&port->dev, __func__,
890 urb->actual_length, urb->transfer_buffer);
892 pl2303_update_line_status(port, data, actual_length);
895 retval = usb_submit_urb(urb, GFP_ATOMIC);
898 "%s - usb_submit_urb failed with result %d\n",
903 static void pl2303_process_read_urb(struct urb *urb)
905 struct usb_serial_port *port = urb->context;
906 struct pl2303_private *priv = usb_get_serial_port_data(port);
907 unsigned char *data = urb->transfer_buffer;
908 char tty_flag = TTY_NORMAL;
913 /* update line status */
914 spin_lock_irqsave(&priv->lock, flags);
915 line_status = priv->line_status;
916 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
917 spin_unlock_irqrestore(&priv->lock, flags);
919 if (!urb->actual_length)
923 * Break takes precedence over parity, which takes precedence over
926 if (line_status & UART_BREAK_ERROR)
927 tty_flag = TTY_BREAK;
928 else if (line_status & UART_PARITY_ERROR)
929 tty_flag = TTY_PARITY;
930 else if (line_status & UART_FRAME_ERROR)
931 tty_flag = TTY_FRAME;
933 if (tty_flag != TTY_NORMAL)
934 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
936 /* overrun is special, not associated with a char */
937 if (line_status & UART_OVERRUN_ERROR)
938 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
940 if (port->port.console && port->sysrq) {
941 for (i = 0; i < urb->actual_length; ++i)
942 if (!usb_serial_handle_sysrq_char(port, data[i]))
943 tty_insert_flip_char(&port->port, data[i],
946 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
950 tty_flip_buffer_push(&port->port);
953 static struct usb_serial_driver pl2303_device = {
955 .owner = THIS_MODULE,
958 .id_table = id_table,
961 .bulk_out_size = 256,
963 .close = pl2303_close,
964 .dtr_rts = pl2303_dtr_rts,
965 .carrier_raised = pl2303_carrier_raised,
966 .ioctl = pl2303_ioctl,
967 .break_ctl = pl2303_break_ctl,
968 .set_termios = pl2303_set_termios,
969 .tiocmget = pl2303_tiocmget,
970 .tiocmset = pl2303_tiocmset,
971 .tiocmiwait = usb_serial_generic_tiocmiwait,
972 .process_read_urb = pl2303_process_read_urb,
973 .read_int_callback = pl2303_read_int_callback,
974 .probe = pl2303_probe,
975 .attach = pl2303_startup,
976 .release = pl2303_release,
977 .port_probe = pl2303_port_probe,
978 .port_remove = pl2303_port_remove,
981 static struct usb_serial_driver * const serial_drivers[] = {
985 module_usb_serial_driver(serial_drivers, id_table);
987 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
988 MODULE_LICENSE("GPL");