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_LD960_PRODUCT_ID) },
92 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
93 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
94 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
95 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
96 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
98 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
99 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
100 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
101 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
102 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
103 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
104 { } /* Terminating entry */
107 MODULE_DEVICE_TABLE(usb, id_table);
109 #define SET_LINE_REQUEST_TYPE 0x21
110 #define SET_LINE_REQUEST 0x20
112 #define SET_CONTROL_REQUEST_TYPE 0x21
113 #define SET_CONTROL_REQUEST 0x22
114 #define CONTROL_DTR 0x01
115 #define CONTROL_RTS 0x02
117 #define BREAK_REQUEST_TYPE 0x21
118 #define BREAK_REQUEST 0x23
119 #define BREAK_ON 0xffff
120 #define BREAK_OFF 0x0000
122 #define GET_LINE_REQUEST_TYPE 0xa1
123 #define GET_LINE_REQUEST 0x21
125 #define VENDOR_WRITE_REQUEST_TYPE 0x40
126 #define VENDOR_WRITE_REQUEST 0x01
128 #define VENDOR_READ_REQUEST_TYPE 0xc0
129 #define VENDOR_READ_REQUEST 0x01
131 #define UART_STATE_INDEX 8
132 #define UART_STATE_MSR_MASK 0x8b
133 #define UART_STATE_TRANSIENT_MASK 0x74
134 #define UART_DCD 0x01
135 #define UART_DSR 0x02
136 #define UART_BREAK_ERROR 0x04
137 #define UART_RING 0x08
138 #define UART_FRAME_ERROR 0x10
139 #define UART_PARITY_ERROR 0x20
140 #define UART_OVERRUN_ERROR 0x40
141 #define UART_CTS 0x80
143 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
146 TYPE_01, /* Type 0 and 1 (difference unknown) */
147 TYPE_HX, /* HX version of the pl2303 chip */
151 struct pl2303_type_data {
152 speed_t max_baud_rate;
153 unsigned long quirks;
156 struct pl2303_serial_private {
157 const struct pl2303_type_data *type;
158 unsigned long quirks;
161 struct pl2303_private {
169 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
171 .max_baud_rate = 1228800,
172 .quirks = PL2303_QUIRK_LEGACY,
175 .max_baud_rate = 12000000,
179 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
180 unsigned char buf[1])
182 struct device *dev = &serial->interface->dev;
185 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
186 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
187 value, 0, buf, 1, 100);
189 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
197 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
202 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
204 struct device *dev = &serial->interface->dev;
207 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
209 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
210 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
211 value, index, NULL, 0, 100);
213 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
221 static int pl2303_probe(struct usb_serial *serial,
222 const struct usb_device_id *id)
224 usb_set_serial_data(serial, (void *)id->driver_info);
229 static int pl2303_startup(struct usb_serial *serial)
231 struct pl2303_serial_private *spriv;
232 unsigned char num_ports = serial->num_ports;
233 enum pl2303_type type = TYPE_01;
236 if (serial->num_bulk_in < num_ports ||
237 serial->num_bulk_out < num_ports ||
238 serial->num_interrupt_in < num_ports) {
239 dev_err(&serial->interface->dev, "missing endpoints\n");
243 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
247 buf = kmalloc(1, GFP_KERNEL);
253 if (serial->dev->descriptor.bDeviceClass == 0x02)
254 type = TYPE_01; /* type 0 */
255 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
257 else if (serial->dev->descriptor.bDeviceClass == 0x00)
258 type = TYPE_01; /* type 1 */
259 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
260 type = TYPE_01; /* type 1 */
261 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
263 spriv->type = &pl2303_type_data[type];
264 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
265 spriv->quirks |= spriv->type->quirks;
267 usb_set_serial_data(serial, spriv);
269 pl2303_vendor_read(serial, 0x8484, buf);
270 pl2303_vendor_write(serial, 0x0404, 0);
271 pl2303_vendor_read(serial, 0x8484, buf);
272 pl2303_vendor_read(serial, 0x8383, buf);
273 pl2303_vendor_read(serial, 0x8484, buf);
274 pl2303_vendor_write(serial, 0x0404, 1);
275 pl2303_vendor_read(serial, 0x8484, buf);
276 pl2303_vendor_read(serial, 0x8383, buf);
277 pl2303_vendor_write(serial, 0, 1);
278 pl2303_vendor_write(serial, 1, 0);
279 if (spriv->quirks & PL2303_QUIRK_LEGACY)
280 pl2303_vendor_write(serial, 2, 0x24);
282 pl2303_vendor_write(serial, 2, 0x44);
289 static void pl2303_release(struct usb_serial *serial)
291 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
296 static int pl2303_port_probe(struct usb_serial_port *port)
298 struct pl2303_private *priv;
300 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
304 spin_lock_init(&priv->lock);
306 usb_set_serial_port_data(port, priv);
308 port->port.drain_delay = 256;
313 static int pl2303_port_remove(struct usb_serial_port *port)
315 struct pl2303_private *priv = usb_get_serial_port_data(port);
322 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
324 struct usb_device *dev = port->serial->dev;
327 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
329 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
330 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
331 value, 0, NULL, 0, 100);
333 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
339 * Returns the nearest supported baud rate that can be set directly without
342 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
344 static const speed_t baud_sup[] = {
345 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
346 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
347 614400, 921600, 1228800, 2457600, 3000000, 6000000
352 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
353 if (baud_sup[i] > baud)
357 if (i == ARRAY_SIZE(baud_sup))
358 baud = baud_sup[i - 1];
359 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
360 baud = baud_sup[i - 1];
368 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
371 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
374 put_unaligned_le32(baud, buf);
379 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
382 unsigned int baseline, mantissa, exponent;
385 * Apparently the formula is:
386 * baudrate = 12M * 32 / (mantissa * 4^exponent)
388 * mantissa = buf[8:0]
389 * exponent = buf[11:9]
391 baseline = 12000000 * 32;
392 mantissa = baseline / baud;
394 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
396 while (mantissa >= 512) {
398 mantissa >>= 2; /* divide by 4 */
401 /* Exponent is maxed. Trim mantissa and leave. */
409 buf[1] = exponent << 1 | mantissa >> 8;
410 buf[0] = mantissa & 0xff;
412 /* Calculate and return the exact baud rate. */
413 baud = (baseline / mantissa) >> (exponent << 1);
418 static void pl2303_encode_baud_rate(struct tty_struct *tty,
419 struct usb_serial_port *port,
422 struct usb_serial *serial = port->serial;
423 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
427 baud = tty_get_baud_rate(tty);
428 dev_dbg(&port->dev, "baud requested = %u\n", baud);
432 if (spriv->type->max_baud_rate)
433 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
435 * Use direct method for supported baud rates, otherwise use divisors.
437 baud_sup = pl2303_get_supported_baud_rate(baud);
439 if (baud == baud_sup)
440 baud = pl2303_encode_baud_rate_direct(buf, baud);
442 baud = pl2303_encode_baud_rate_divisor(buf, baud);
444 /* Save resulting baud rate */
445 tty_encode_baud_rate(tty, baud, baud);
446 dev_dbg(&port->dev, "baud set = %u\n", baud);
449 static int pl2303_get_line_request(struct usb_serial_port *port,
450 unsigned char buf[7])
452 struct usb_device *udev = port->serial->dev;
455 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
456 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
459 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
467 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
472 static int pl2303_set_line_request(struct usb_serial_port *port,
473 unsigned char buf[7])
475 struct usb_device *udev = port->serial->dev;
478 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
479 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
482 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
490 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
495 static void pl2303_set_termios(struct tty_struct *tty,
496 struct usb_serial_port *port, struct ktermios *old_termios)
498 struct usb_serial *serial = port->serial;
499 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
500 struct pl2303_private *priv = usb_get_serial_port_data(port);
506 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
509 buf = kzalloc(7, GFP_KERNEL);
511 /* Report back no change occurred */
513 tty->termios = *old_termios;
517 pl2303_get_line_request(port, buf);
519 switch (C_CSIZE(tty)) {
533 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
535 /* For reference buf[0]:buf[3] baud rate value */
536 pl2303_encode_baud_rate(tty, port, &buf[0]);
538 /* For reference buf[4]=0 is 1 stop bits */
539 /* For reference buf[4]=1 is 1.5 stop bits */
540 /* For reference buf[4]=2 is 2 stop bits */
543 * NOTE: Comply with "real" UARTs / RS232:
544 * use 1.5 instead of 2 stop bits with 5 data bits
546 if (C_CSIZE(tty) == CS5) {
548 dev_dbg(&port->dev, "stop bits = 1.5\n");
551 dev_dbg(&port->dev, "stop bits = 2\n");
555 dev_dbg(&port->dev, "stop bits = 1\n");
559 /* For reference buf[5]=0 is none parity */
560 /* For reference buf[5]=1 is odd parity */
561 /* For reference buf[5]=2 is even parity */
562 /* For reference buf[5]=3 is mark parity */
563 /* For reference buf[5]=4 is space parity */
567 dev_dbg(&port->dev, "parity = mark\n");
570 dev_dbg(&port->dev, "parity = odd\n");
575 dev_dbg(&port->dev, "parity = space\n");
578 dev_dbg(&port->dev, "parity = even\n");
583 dev_dbg(&port->dev, "parity = none\n");
587 * Some PL2303 are known to lose bytes if you change serial settings
588 * even to the same values as before. Thus we actually need to filter
589 * in this specific case.
591 * Note that the tty_termios_hw_change check above is not sufficient
592 * as a previously requested baud rate may differ from the one
593 * actually used (and stored in old_termios).
595 * NOTE: No additional locking needed for line_settings as it is
596 * only used in set_termios, which is serialised against itself.
598 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
599 ret = pl2303_set_line_request(port, buf);
601 memcpy(priv->line_settings, buf, 7);
604 /* change control lines if we are switching to or from B0 */
605 spin_lock_irqsave(&priv->lock, flags);
606 control = priv->line_control;
607 if (C_BAUD(tty) == B0)
608 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
609 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
610 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
611 if (control != priv->line_control) {
612 control = priv->line_control;
613 spin_unlock_irqrestore(&priv->lock, flags);
614 pl2303_set_control_lines(port, control);
616 spin_unlock_irqrestore(&priv->lock, flags);
619 if (C_CRTSCTS(tty)) {
620 if (spriv->quirks & PL2303_QUIRK_LEGACY)
621 pl2303_vendor_write(serial, 0x0, 0x41);
623 pl2303_vendor_write(serial, 0x0, 0x61);
625 pl2303_vendor_write(serial, 0x0, 0x0);
631 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
633 struct pl2303_private *priv = usb_get_serial_port_data(port);
637 spin_lock_irqsave(&priv->lock, flags);
639 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
641 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
642 control = priv->line_control;
643 spin_unlock_irqrestore(&priv->lock, flags);
645 pl2303_set_control_lines(port, control);
648 static void pl2303_close(struct usb_serial_port *port)
650 usb_serial_generic_close(port);
651 usb_kill_urb(port->interrupt_in_urb);
652 pl2303_set_break(port, false);
655 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
657 struct usb_serial *serial = port->serial;
658 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
661 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
662 usb_clear_halt(serial->dev, port->write_urb->pipe);
663 usb_clear_halt(serial->dev, port->read_urb->pipe);
665 /* reset upstream data pipes */
666 pl2303_vendor_write(serial, 8, 0);
667 pl2303_vendor_write(serial, 9, 0);
672 pl2303_set_termios(tty, port, NULL);
674 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
676 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
681 result = usb_serial_generic_open(tty, port);
683 usb_kill_urb(port->interrupt_in_urb);
690 static int pl2303_tiocmset(struct tty_struct *tty,
691 unsigned int set, unsigned int clear)
693 struct usb_serial_port *port = tty->driver_data;
694 struct pl2303_private *priv = usb_get_serial_port_data(port);
699 spin_lock_irqsave(&priv->lock, flags);
701 priv->line_control |= CONTROL_RTS;
703 priv->line_control |= CONTROL_DTR;
704 if (clear & TIOCM_RTS)
705 priv->line_control &= ~CONTROL_RTS;
706 if (clear & TIOCM_DTR)
707 priv->line_control &= ~CONTROL_DTR;
708 control = priv->line_control;
709 spin_unlock_irqrestore(&priv->lock, flags);
711 ret = pl2303_set_control_lines(port, control);
713 return usb_translate_errors(ret);
718 static int pl2303_tiocmget(struct tty_struct *tty)
720 struct usb_serial_port *port = tty->driver_data;
721 struct pl2303_private *priv = usb_get_serial_port_data(port);
727 spin_lock_irqsave(&priv->lock, flags);
728 mcr = priv->line_control;
729 status = priv->line_status;
730 spin_unlock_irqrestore(&priv->lock, flags);
732 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
733 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
734 | ((status & UART_CTS) ? TIOCM_CTS : 0)
735 | ((status & UART_DSR) ? TIOCM_DSR : 0)
736 | ((status & UART_RING) ? TIOCM_RI : 0)
737 | ((status & UART_DCD) ? TIOCM_CD : 0);
739 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
744 static int pl2303_carrier_raised(struct usb_serial_port *port)
746 struct pl2303_private *priv = usb_get_serial_port_data(port);
748 if (priv->line_status & UART_DCD)
754 static int pl2303_ioctl(struct tty_struct *tty,
755 unsigned int cmd, unsigned long arg)
757 struct serial_struct ser;
758 struct usb_serial_port *port = tty->driver_data;
762 memset(&ser, 0, sizeof ser);
763 ser.type = PORT_16654;
764 ser.line = port->minor;
765 ser.port = port->port_number;
766 ser.baud_base = 460800;
768 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
779 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
781 struct usb_serial *serial = port->serial;
790 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
791 state == BREAK_OFF ? "off" : "on");
793 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
794 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
797 dev_err(&port->dev, "error sending break = %d\n", result);
800 static void pl2303_break_ctl(struct tty_struct *tty, int state)
802 struct usb_serial_port *port = tty->driver_data;
804 pl2303_set_break(port, state);
807 static void pl2303_update_line_status(struct usb_serial_port *port,
809 unsigned int actual_length)
811 struct usb_serial *serial = port->serial;
812 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
813 struct pl2303_private *priv = usb_get_serial_port_data(port);
814 struct tty_struct *tty;
816 unsigned int status_idx = UART_STATE_INDEX;
820 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
823 if (actual_length < status_idx + 1)
826 status = data[status_idx];
828 /* Save off the uart status for others to look at */
829 spin_lock_irqsave(&priv->lock, flags);
830 delta = priv->line_status ^ status;
831 priv->line_status = status;
832 spin_unlock_irqrestore(&priv->lock, flags);
834 if (status & UART_BREAK_ERROR)
835 usb_serial_handle_break(port);
837 if (delta & UART_STATE_MSR_MASK) {
838 if (delta & UART_CTS)
840 if (delta & UART_DSR)
842 if (delta & UART_RING)
844 if (delta & UART_DCD) {
846 tty = tty_port_tty_get(&port->port);
848 usb_serial_handle_dcd_change(port, tty,
854 wake_up_interruptible(&port->port.delta_msr_wait);
858 static void pl2303_read_int_callback(struct urb *urb)
860 struct usb_serial_port *port = urb->context;
861 unsigned char *data = urb->transfer_buffer;
862 unsigned int actual_length = urb->actual_length;
863 int status = urb->status;
873 /* this urb is terminated, clean up */
874 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
878 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
883 usb_serial_debug_data(&port->dev, __func__,
884 urb->actual_length, urb->transfer_buffer);
886 pl2303_update_line_status(port, data, actual_length);
889 retval = usb_submit_urb(urb, GFP_ATOMIC);
892 "%s - usb_submit_urb failed with result %d\n",
897 static void pl2303_process_read_urb(struct urb *urb)
899 struct usb_serial_port *port = urb->context;
900 struct pl2303_private *priv = usb_get_serial_port_data(port);
901 unsigned char *data = urb->transfer_buffer;
902 char tty_flag = TTY_NORMAL;
907 /* update line status */
908 spin_lock_irqsave(&priv->lock, flags);
909 line_status = priv->line_status;
910 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
911 spin_unlock_irqrestore(&priv->lock, flags);
913 if (!urb->actual_length)
917 * Break takes precedence over parity, which takes precedence over
920 if (line_status & UART_BREAK_ERROR)
921 tty_flag = TTY_BREAK;
922 else if (line_status & UART_PARITY_ERROR)
923 tty_flag = TTY_PARITY;
924 else if (line_status & UART_FRAME_ERROR)
925 tty_flag = TTY_FRAME;
927 if (tty_flag != TTY_NORMAL)
928 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
930 /* overrun is special, not associated with a char */
931 if (line_status & UART_OVERRUN_ERROR)
932 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
934 if (port->port.console && port->sysrq) {
935 for (i = 0; i < urb->actual_length; ++i)
936 if (!usb_serial_handle_sysrq_char(port, data[i]))
937 tty_insert_flip_char(&port->port, data[i],
940 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
944 tty_flip_buffer_push(&port->port);
947 static struct usb_serial_driver pl2303_device = {
949 .owner = THIS_MODULE,
952 .id_table = id_table,
955 .bulk_out_size = 256,
957 .close = pl2303_close,
958 .dtr_rts = pl2303_dtr_rts,
959 .carrier_raised = pl2303_carrier_raised,
960 .ioctl = pl2303_ioctl,
961 .break_ctl = pl2303_break_ctl,
962 .set_termios = pl2303_set_termios,
963 .tiocmget = pl2303_tiocmget,
964 .tiocmset = pl2303_tiocmset,
965 .tiocmiwait = usb_serial_generic_tiocmiwait,
966 .process_read_urb = pl2303_process_read_urb,
967 .read_int_callback = pl2303_read_int_callback,
968 .probe = pl2303_probe,
969 .attach = pl2303_startup,
970 .release = pl2303_release,
971 .port_probe = pl2303_port_probe,
972 .port_remove = pl2303_port_remove,
975 static struct usb_serial_driver * const serial_drivers[] = {
979 module_usb_serial_driver(serial_drivers, id_table);
981 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
982 MODULE_LICENSE("GPL");