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/init.h>
20 #include <linux/slab.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/tty_flip.h>
24 #include <linux/serial.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/spinlock.h>
28 #include <linux/uaccess.h>
29 #include <linux/usb.h>
30 #include <linux/usb/serial.h>
31 #include <asm/unaligned.h>
35 #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
36 #define PL2303_QUIRK_LEGACY BIT(1)
38 static const struct usb_device_id id_table[] = {
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
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(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
51 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
52 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
53 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
54 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
55 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
56 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
57 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
58 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
59 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
60 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
61 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
62 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
63 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
64 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
65 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
66 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
67 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
68 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
70 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
72 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
73 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
74 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
75 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
76 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
77 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
78 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
79 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
80 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
81 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
82 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
83 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
84 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
85 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
86 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
87 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
88 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
89 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
90 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
91 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
92 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
93 { } /* Terminating entry */
96 MODULE_DEVICE_TABLE(usb, id_table);
98 #define SET_LINE_REQUEST_TYPE 0x21
99 #define SET_LINE_REQUEST 0x20
101 #define SET_CONTROL_REQUEST_TYPE 0x21
102 #define SET_CONTROL_REQUEST 0x22
103 #define CONTROL_DTR 0x01
104 #define CONTROL_RTS 0x02
106 #define BREAK_REQUEST_TYPE 0x21
107 #define BREAK_REQUEST 0x23
108 #define BREAK_ON 0xffff
109 #define BREAK_OFF 0x0000
111 #define GET_LINE_REQUEST_TYPE 0xa1
112 #define GET_LINE_REQUEST 0x21
114 #define VENDOR_WRITE_REQUEST_TYPE 0x40
115 #define VENDOR_WRITE_REQUEST 0x01
117 #define VENDOR_READ_REQUEST_TYPE 0xc0
118 #define VENDOR_READ_REQUEST 0x01
120 #define UART_STATE_INDEX 8
121 #define UART_STATE_TRANSIENT_MASK 0x74
122 #define UART_DCD 0x01
123 #define UART_DSR 0x02
124 #define UART_BREAK_ERROR 0x04
125 #define UART_RING 0x08
126 #define UART_FRAME_ERROR 0x10
127 #define UART_PARITY_ERROR 0x20
128 #define UART_OVERRUN_ERROR 0x40
129 #define UART_CTS 0x80
133 TYPE_01, /* Type 0 and 1 (difference unknown) */
134 TYPE_HX, /* HX version of the pl2303 chip */
138 struct pl2303_type_data {
139 speed_t max_baud_rate;
140 unsigned long quirks;
143 struct pl2303_serial_private {
144 struct pl2303_type_data *type;
145 unsigned long quirks;
148 struct pl2303_private {
156 static struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
158 .max_baud_rate = 1228800,
159 .quirks = PL2303_QUIRK_LEGACY,
163 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
164 unsigned char buf[1])
166 struct device *dev = &serial->interface->dev;
169 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
170 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
171 value, 0, buf, 1, 100);
173 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
181 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
186 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
188 struct device *dev = &serial->interface->dev;
191 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
193 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
194 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
195 value, index, NULL, 0, 100);
197 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
205 static int pl2303_probe(struct usb_serial *serial,
206 const struct usb_device_id *id)
208 usb_set_serial_data(serial, (void *)id->driver_info);
213 static int pl2303_startup(struct usb_serial *serial)
215 struct pl2303_serial_private *spriv;
216 enum pl2303_type type = TYPE_01;
219 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
223 buf = kmalloc(1, GFP_KERNEL);
229 if (serial->dev->descriptor.bDeviceClass == 0x02)
230 type = TYPE_01; /* type 0 */
231 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
233 else if (serial->dev->descriptor.bDeviceClass == 0x00)
234 type = TYPE_01; /* type 1 */
235 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
236 type = TYPE_01; /* type 1 */
237 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
239 spriv->type = &pl2303_type_data[type];
240 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
241 spriv->quirks |= spriv->type->quirks;
243 usb_set_serial_data(serial, spriv);
245 pl2303_vendor_read(serial, 0x8484, buf);
246 pl2303_vendor_write(serial, 0x0404, 0);
247 pl2303_vendor_read(serial, 0x8484, buf);
248 pl2303_vendor_read(serial, 0x8383, buf);
249 pl2303_vendor_read(serial, 0x8484, buf);
250 pl2303_vendor_write(serial, 0x0404, 1);
251 pl2303_vendor_read(serial, 0x8484, buf);
252 pl2303_vendor_read(serial, 0x8383, buf);
253 pl2303_vendor_write(serial, 0, 1);
254 pl2303_vendor_write(serial, 1, 0);
255 if (spriv->quirks & PL2303_QUIRK_LEGACY)
256 pl2303_vendor_write(serial, 2, 0x24);
258 pl2303_vendor_write(serial, 2, 0x44);
265 static void pl2303_release(struct usb_serial *serial)
267 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
272 static int pl2303_port_probe(struct usb_serial_port *port)
274 struct pl2303_private *priv;
276 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
280 spin_lock_init(&priv->lock);
282 usb_set_serial_port_data(port, priv);
284 port->port.drain_delay = 256;
289 static int pl2303_port_remove(struct usb_serial_port *port)
291 struct pl2303_private *priv = usb_get_serial_port_data(port);
298 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
300 struct usb_device *dev = port->serial->dev;
303 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
305 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
306 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
307 value, 0, NULL, 0, 100);
309 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
315 * Returns the nearest supported baud rate that can be set directly without
318 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
320 static const speed_t baud_sup[] = {
321 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
322 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
323 614400, 921600, 1228800, 2457600, 3000000, 6000000
328 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
329 if (baud_sup[i] > baud)
333 if (i == ARRAY_SIZE(baud_sup))
334 baud = baud_sup[i - 1];
335 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
336 baud = baud_sup[i - 1];
344 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
347 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
350 put_unaligned_le32(baud, buf);
355 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
361 * Apparently the formula is:
362 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
364 tmp = 12000000 * 32 / baud;
367 buf[1] = (tmp >= 256);
377 static void pl2303_encode_baud_rate(struct tty_struct *tty,
378 struct usb_serial_port *port,
381 struct usb_serial *serial = port->serial;
382 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
386 baud = tty_get_baud_rate(tty);
387 dev_dbg(&port->dev, "baud requested = %u\n", baud);
391 if (spriv->type->max_baud_rate)
392 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
394 * Set baud rate to nearest supported value.
396 * NOTE: Baud rate 500k can only be set using divisors.
398 baud_sup = pl2303_get_supported_baud_rate(baud);
401 baud = pl2303_encode_baud_rate_divisor(buf, baud);
403 baud = pl2303_encode_baud_rate_direct(buf, baud_sup);
405 /* Save resulting baud rate */
406 tty_encode_baud_rate(tty, baud, baud);
407 dev_dbg(&port->dev, "baud set = %u\n", baud);
410 static int pl2303_get_line_request(struct usb_serial_port *port,
411 unsigned char buf[7])
413 struct usb_device *udev = port->serial->dev;
416 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
417 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
420 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
428 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
433 static int pl2303_set_line_request(struct usb_serial_port *port,
434 unsigned char buf[7])
436 struct usb_device *udev = port->serial->dev;
439 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
440 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
443 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
451 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
456 static void pl2303_set_termios(struct tty_struct *tty,
457 struct usb_serial_port *port, struct ktermios *old_termios)
459 struct usb_serial *serial = port->serial;
460 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
461 struct pl2303_private *priv = usb_get_serial_port_data(port);
467 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
470 buf = kzalloc(7, GFP_KERNEL);
472 /* Report back no change occurred */
474 tty->termios = *old_termios;
478 pl2303_get_line_request(port, buf);
480 switch (C_CSIZE(tty)) {
494 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
496 /* For reference buf[0]:buf[3] baud rate value */
497 pl2303_encode_baud_rate(tty, port, &buf[0]);
499 /* For reference buf[4]=0 is 1 stop bits */
500 /* For reference buf[4]=1 is 1.5 stop bits */
501 /* For reference buf[4]=2 is 2 stop bits */
504 * NOTE: Comply with "real" UARTs / RS232:
505 * use 1.5 instead of 2 stop bits with 5 data bits
507 if (C_CSIZE(tty) == CS5) {
509 dev_dbg(&port->dev, "stop bits = 1.5\n");
512 dev_dbg(&port->dev, "stop bits = 2\n");
516 dev_dbg(&port->dev, "stop bits = 1\n");
520 /* For reference buf[5]=0 is none parity */
521 /* For reference buf[5]=1 is odd parity */
522 /* For reference buf[5]=2 is even parity */
523 /* For reference buf[5]=3 is mark parity */
524 /* For reference buf[5]=4 is space parity */
528 dev_dbg(&port->dev, "parity = mark\n");
531 dev_dbg(&port->dev, "parity = odd\n");
536 dev_dbg(&port->dev, "parity = space\n");
539 dev_dbg(&port->dev, "parity = even\n");
544 dev_dbg(&port->dev, "parity = none\n");
548 * Some PL2303 are known to lose bytes if you change serial settings
549 * even to the same values as before. Thus we actually need to filter
550 * in this specific case.
552 * Note that the tty_termios_hw_change check above is not sufficient
553 * as a previously requested baud rate may differ from the one
554 * actually used (and stored in old_termios).
556 * NOTE: No additional locking needed for line_settings as it is
557 * only used in set_termios, which is serialised against itself.
559 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
560 ret = pl2303_set_line_request(port, buf);
562 memcpy(priv->line_settings, buf, 7);
565 /* change control lines if we are switching to or from B0 */
566 spin_lock_irqsave(&priv->lock, flags);
567 control = priv->line_control;
568 if (C_BAUD(tty) == B0)
569 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
570 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
571 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
572 if (control != priv->line_control) {
573 control = priv->line_control;
574 spin_unlock_irqrestore(&priv->lock, flags);
575 pl2303_set_control_lines(port, control);
577 spin_unlock_irqrestore(&priv->lock, flags);
580 if (C_CRTSCTS(tty)) {
581 if (spriv->quirks & PL2303_QUIRK_LEGACY)
582 pl2303_vendor_write(serial, 0x0, 0x41);
584 pl2303_vendor_write(serial, 0x0, 0x61);
586 pl2303_vendor_write(serial, 0x0, 0x0);
592 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
594 struct pl2303_private *priv = usb_get_serial_port_data(port);
598 spin_lock_irqsave(&priv->lock, flags);
600 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
602 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
603 control = priv->line_control;
604 spin_unlock_irqrestore(&priv->lock, flags);
606 pl2303_set_control_lines(port, control);
609 static void pl2303_close(struct usb_serial_port *port)
611 usb_serial_generic_close(port);
612 usb_kill_urb(port->interrupt_in_urb);
615 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
617 struct usb_serial *serial = port->serial;
618 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
621 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
622 usb_clear_halt(serial->dev, port->write_urb->pipe);
623 usb_clear_halt(serial->dev, port->read_urb->pipe);
625 /* reset upstream data pipes */
626 pl2303_vendor_write(serial, 8, 0);
627 pl2303_vendor_write(serial, 9, 0);
632 pl2303_set_termios(tty, port, NULL);
634 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
636 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
641 result = usb_serial_generic_open(tty, port);
643 usb_kill_urb(port->interrupt_in_urb);
650 static int pl2303_tiocmset(struct tty_struct *tty,
651 unsigned int set, unsigned int clear)
653 struct usb_serial_port *port = tty->driver_data;
654 struct pl2303_private *priv = usb_get_serial_port_data(port);
659 spin_lock_irqsave(&priv->lock, flags);
661 priv->line_control |= CONTROL_RTS;
663 priv->line_control |= CONTROL_DTR;
664 if (clear & TIOCM_RTS)
665 priv->line_control &= ~CONTROL_RTS;
666 if (clear & TIOCM_DTR)
667 priv->line_control &= ~CONTROL_DTR;
668 control = priv->line_control;
669 spin_unlock_irqrestore(&priv->lock, flags);
671 ret = pl2303_set_control_lines(port, control);
673 return usb_translate_errors(ret);
678 static int pl2303_tiocmget(struct tty_struct *tty)
680 struct usb_serial_port *port = tty->driver_data;
681 struct pl2303_private *priv = usb_get_serial_port_data(port);
687 spin_lock_irqsave(&priv->lock, flags);
688 mcr = priv->line_control;
689 status = priv->line_status;
690 spin_unlock_irqrestore(&priv->lock, flags);
692 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
693 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
694 | ((status & UART_CTS) ? TIOCM_CTS : 0)
695 | ((status & UART_DSR) ? TIOCM_DSR : 0)
696 | ((status & UART_RING) ? TIOCM_RI : 0)
697 | ((status & UART_DCD) ? TIOCM_CD : 0);
699 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
704 static int pl2303_carrier_raised(struct usb_serial_port *port)
706 struct pl2303_private *priv = usb_get_serial_port_data(port);
708 if (priv->line_status & UART_DCD)
714 static int pl2303_tiocmiwait(struct tty_struct *tty, unsigned long arg)
716 struct usb_serial_port *port = tty->driver_data;
717 struct pl2303_private *priv = usb_get_serial_port_data(port);
719 unsigned int prevstatus;
721 unsigned int changed;
723 spin_lock_irqsave(&priv->lock, flags);
724 prevstatus = priv->line_status;
725 spin_unlock_irqrestore(&priv->lock, flags);
728 interruptible_sleep_on(&port->port.delta_msr_wait);
729 /* see if a signal did it */
730 if (signal_pending(current))
733 if (port->serial->disconnected)
736 spin_lock_irqsave(&priv->lock, flags);
737 status = priv->line_status;
738 spin_unlock_irqrestore(&priv->lock, flags);
740 changed = prevstatus ^ status;
742 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
743 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
744 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
745 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
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_break_ctl(struct tty_struct *tty, int break_state)
781 struct usb_serial_port *port = tty->driver_data;
782 struct usb_serial *serial = port->serial;
786 if (break_state == 0)
791 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
792 state == BREAK_OFF ? "off" : "on");
794 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
795 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
798 dev_err(&port->dev, "error sending break = %d\n", result);
801 static void pl2303_update_line_status(struct usb_serial_port *port,
803 unsigned int actual_length)
805 struct usb_serial *serial = port->serial;
806 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
807 struct pl2303_private *priv = usb_get_serial_port_data(port);
808 struct tty_struct *tty;
810 unsigned int status_idx = UART_STATE_INDEX;
813 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
816 if (actual_length < status_idx + 1)
819 /* Save off the uart status for others to look at */
820 spin_lock_irqsave(&priv->lock, flags);
821 prev_line_status = priv->line_status;
822 priv->line_status = data[status_idx];
823 spin_unlock_irqrestore(&priv->lock, flags);
825 if (priv->line_status & UART_BREAK_ERROR)
826 usb_serial_handle_break(port);
828 wake_up_interruptible(&port->port.delta_msr_wait);
830 tty = tty_port_tty_get(&port->port);
833 if ((priv->line_status ^ prev_line_status) & UART_DCD)
834 usb_serial_handle_dcd_change(port, tty,
835 priv->line_status & UART_DCD);
839 static void pl2303_read_int_callback(struct urb *urb)
841 struct usb_serial_port *port = urb->context;
842 unsigned char *data = urb->transfer_buffer;
843 unsigned int actual_length = urb->actual_length;
844 int status = urb->status;
854 /* this urb is terminated, clean up */
855 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
859 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
864 usb_serial_debug_data(&port->dev, __func__,
865 urb->actual_length, urb->transfer_buffer);
867 pl2303_update_line_status(port, data, actual_length);
870 retval = usb_submit_urb(urb, GFP_ATOMIC);
873 "%s - usb_submit_urb failed with result %d\n",
878 static void pl2303_process_read_urb(struct urb *urb)
880 struct usb_serial_port *port = urb->context;
881 struct pl2303_private *priv = usb_get_serial_port_data(port);
882 unsigned char *data = urb->transfer_buffer;
883 char tty_flag = TTY_NORMAL;
888 /* update line status */
889 spin_lock_irqsave(&priv->lock, flags);
890 line_status = priv->line_status;
891 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
892 spin_unlock_irqrestore(&priv->lock, flags);
894 if (!urb->actual_length)
898 * Break takes precedence over parity, which takes precedence over
901 if (line_status & UART_BREAK_ERROR)
902 tty_flag = TTY_BREAK;
903 else if (line_status & UART_PARITY_ERROR)
904 tty_flag = TTY_PARITY;
905 else if (line_status & UART_FRAME_ERROR)
906 tty_flag = TTY_FRAME;
908 if (tty_flag != TTY_NORMAL)
909 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
911 /* overrun is special, not associated with a char */
912 if (line_status & UART_OVERRUN_ERROR)
913 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
915 if (port->port.console && port->sysrq) {
916 for (i = 0; i < urb->actual_length; ++i)
917 if (!usb_serial_handle_sysrq_char(port, data[i]))
918 tty_insert_flip_char(&port->port, data[i],
921 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
925 tty_flip_buffer_push(&port->port);
928 static struct usb_serial_driver pl2303_device = {
930 .owner = THIS_MODULE,
933 .id_table = id_table,
936 .bulk_out_size = 256,
938 .close = pl2303_close,
939 .dtr_rts = pl2303_dtr_rts,
940 .carrier_raised = pl2303_carrier_raised,
941 .ioctl = pl2303_ioctl,
942 .break_ctl = pl2303_break_ctl,
943 .set_termios = pl2303_set_termios,
944 .tiocmget = pl2303_tiocmget,
945 .tiocmset = pl2303_tiocmset,
946 .tiocmiwait = pl2303_tiocmiwait,
947 .process_read_urb = pl2303_process_read_urb,
948 .read_int_callback = pl2303_read_int_callback,
949 .probe = pl2303_probe,
950 .attach = pl2303_startup,
951 .release = pl2303_release,
952 .port_probe = pl2303_port_probe,
953 .port_remove = pl2303_port_remove,
956 static struct usb_serial_driver * const serial_drivers[] = {
960 module_usb_serial_driver(serial_drivers, id_table);
962 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
963 MODULE_LICENSE("GPL");