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_PHAROS) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
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_ID, ATEN_PRODUCT_ID2) },
53 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
54 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
55 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
56 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
57 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
58 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
59 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
60 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
61 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
62 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
63 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
64 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_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(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
88 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
89 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
90 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
91 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
92 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
93 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
94 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
95 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
96 { } /* Terminating entry */
99 MODULE_DEVICE_TABLE(usb, id_table);
101 #define SET_LINE_REQUEST_TYPE 0x21
102 #define SET_LINE_REQUEST 0x20
104 #define SET_CONTROL_REQUEST_TYPE 0x21
105 #define SET_CONTROL_REQUEST 0x22
106 #define CONTROL_DTR 0x01
107 #define CONTROL_RTS 0x02
109 #define BREAK_REQUEST_TYPE 0x21
110 #define BREAK_REQUEST 0x23
111 #define BREAK_ON 0xffff
112 #define BREAK_OFF 0x0000
114 #define GET_LINE_REQUEST_TYPE 0xa1
115 #define GET_LINE_REQUEST 0x21
117 #define VENDOR_WRITE_REQUEST_TYPE 0x40
118 #define VENDOR_WRITE_REQUEST 0x01
120 #define VENDOR_READ_REQUEST_TYPE 0xc0
121 #define VENDOR_READ_REQUEST 0x01
123 #define UART_STATE_INDEX 8
124 #define UART_STATE_MSR_MASK 0x8b
125 #define UART_STATE_TRANSIENT_MASK 0x74
126 #define UART_DCD 0x01
127 #define UART_DSR 0x02
128 #define UART_BREAK_ERROR 0x04
129 #define UART_RING 0x08
130 #define UART_FRAME_ERROR 0x10
131 #define UART_PARITY_ERROR 0x20
132 #define UART_OVERRUN_ERROR 0x40
133 #define UART_CTS 0x80
135 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
138 TYPE_01, /* Type 0 and 1 (difference unknown) */
139 TYPE_HX, /* HX version of the pl2303 chip */
143 struct pl2303_type_data {
144 speed_t max_baud_rate;
145 unsigned long quirks;
148 struct pl2303_serial_private {
149 const struct pl2303_type_data *type;
150 unsigned long quirks;
153 struct pl2303_private {
161 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
163 .max_baud_rate = 1228800,
164 .quirks = PL2303_QUIRK_LEGACY,
167 .max_baud_rate = 12000000,
171 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
172 unsigned char buf[1])
174 struct device *dev = &serial->interface->dev;
177 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
178 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
179 value, 0, buf, 1, 100);
181 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
189 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
194 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
196 struct device *dev = &serial->interface->dev;
199 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
201 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
202 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
203 value, index, NULL, 0, 100);
205 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
213 static int pl2303_probe(struct usb_serial *serial,
214 const struct usb_device_id *id)
216 usb_set_serial_data(serial, (void *)id->driver_info);
221 static int pl2303_startup(struct usb_serial *serial)
223 struct pl2303_serial_private *spriv;
224 unsigned char num_ports = serial->num_ports;
225 enum pl2303_type type = TYPE_01;
228 if (serial->num_bulk_in < num_ports ||
229 serial->num_bulk_out < num_ports ||
230 serial->num_interrupt_in < num_ports) {
231 dev_err(&serial->interface->dev, "missing endpoints\n");
235 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
239 buf = kmalloc(1, GFP_KERNEL);
245 if (serial->dev->descriptor.bDeviceClass == 0x02)
246 type = TYPE_01; /* type 0 */
247 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
249 else if (serial->dev->descriptor.bDeviceClass == 0x00)
250 type = TYPE_01; /* type 1 */
251 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
252 type = TYPE_01; /* type 1 */
253 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
255 spriv->type = &pl2303_type_data[type];
256 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
257 spriv->quirks |= spriv->type->quirks;
259 usb_set_serial_data(serial, spriv);
261 pl2303_vendor_read(serial, 0x8484, buf);
262 pl2303_vendor_write(serial, 0x0404, 0);
263 pl2303_vendor_read(serial, 0x8484, buf);
264 pl2303_vendor_read(serial, 0x8383, buf);
265 pl2303_vendor_read(serial, 0x8484, buf);
266 pl2303_vendor_write(serial, 0x0404, 1);
267 pl2303_vendor_read(serial, 0x8484, buf);
268 pl2303_vendor_read(serial, 0x8383, buf);
269 pl2303_vendor_write(serial, 0, 1);
270 pl2303_vendor_write(serial, 1, 0);
271 if (spriv->quirks & PL2303_QUIRK_LEGACY)
272 pl2303_vendor_write(serial, 2, 0x24);
274 pl2303_vendor_write(serial, 2, 0x44);
281 static void pl2303_release(struct usb_serial *serial)
283 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
288 static int pl2303_port_probe(struct usb_serial_port *port)
290 struct pl2303_private *priv;
292 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
296 spin_lock_init(&priv->lock);
298 usb_set_serial_port_data(port, priv);
300 port->port.drain_delay = 256;
305 static int pl2303_port_remove(struct usb_serial_port *port)
307 struct pl2303_private *priv = usb_get_serial_port_data(port);
314 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
316 struct usb_device *dev = port->serial->dev;
319 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
321 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
322 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
323 value, 0, NULL, 0, 100);
325 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
331 * Returns the nearest supported baud rate that can be set directly without
334 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
336 static const speed_t baud_sup[] = {
337 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
338 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
339 614400, 921600, 1228800, 2457600, 3000000, 6000000
344 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
345 if (baud_sup[i] > baud)
349 if (i == ARRAY_SIZE(baud_sup))
350 baud = baud_sup[i - 1];
351 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
352 baud = baud_sup[i - 1];
360 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
363 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
366 put_unaligned_le32(baud, buf);
371 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
374 unsigned int baseline, mantissa, exponent;
377 * Apparently the formula is:
378 * baudrate = 12M * 32 / (mantissa * 4^exponent)
380 * mantissa = buf[8:0]
381 * exponent = buf[11:9]
383 baseline = 12000000 * 32;
384 mantissa = baseline / baud;
386 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
388 while (mantissa >= 512) {
390 mantissa >>= 2; /* divide by 4 */
393 /* Exponent is maxed. Trim mantissa and leave. */
401 buf[1] = exponent << 1 | mantissa >> 8;
402 buf[0] = mantissa & 0xff;
404 /* Calculate and return the exact baud rate. */
405 baud = (baseline / mantissa) >> (exponent << 1);
410 static void pl2303_encode_baud_rate(struct tty_struct *tty,
411 struct usb_serial_port *port,
414 struct usb_serial *serial = port->serial;
415 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
419 baud = tty_get_baud_rate(tty);
420 dev_dbg(&port->dev, "baud requested = %u\n", baud);
424 if (spriv->type->max_baud_rate)
425 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
427 * Use direct method for supported baud rates, otherwise use divisors.
429 baud_sup = pl2303_get_supported_baud_rate(baud);
431 if (baud == baud_sup)
432 baud = pl2303_encode_baud_rate_direct(buf, baud);
434 baud = pl2303_encode_baud_rate_divisor(buf, baud);
436 /* Save resulting baud rate */
437 tty_encode_baud_rate(tty, baud, baud);
438 dev_dbg(&port->dev, "baud set = %u\n", baud);
441 static int pl2303_get_line_request(struct usb_serial_port *port,
442 unsigned char buf[7])
444 struct usb_device *udev = port->serial->dev;
447 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
448 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
451 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
459 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
464 static int pl2303_set_line_request(struct usb_serial_port *port,
465 unsigned char buf[7])
467 struct usb_device *udev = port->serial->dev;
470 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
471 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
474 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
482 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
487 static void pl2303_set_termios(struct tty_struct *tty,
488 struct usb_serial_port *port, struct ktermios *old_termios)
490 struct usb_serial *serial = port->serial;
491 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
492 struct pl2303_private *priv = usb_get_serial_port_data(port);
498 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
501 buf = kzalloc(7, GFP_KERNEL);
503 /* Report back no change occurred */
505 tty->termios = *old_termios;
509 pl2303_get_line_request(port, buf);
511 switch (C_CSIZE(tty)) {
525 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
527 /* For reference buf[0]:buf[3] baud rate value */
528 pl2303_encode_baud_rate(tty, port, &buf[0]);
530 /* For reference buf[4]=0 is 1 stop bits */
531 /* For reference buf[4]=1 is 1.5 stop bits */
532 /* For reference buf[4]=2 is 2 stop bits */
535 * NOTE: Comply with "real" UARTs / RS232:
536 * use 1.5 instead of 2 stop bits with 5 data bits
538 if (C_CSIZE(tty) == CS5) {
540 dev_dbg(&port->dev, "stop bits = 1.5\n");
543 dev_dbg(&port->dev, "stop bits = 2\n");
547 dev_dbg(&port->dev, "stop bits = 1\n");
551 /* For reference buf[5]=0 is none parity */
552 /* For reference buf[5]=1 is odd parity */
553 /* For reference buf[5]=2 is even parity */
554 /* For reference buf[5]=3 is mark parity */
555 /* For reference buf[5]=4 is space parity */
559 dev_dbg(&port->dev, "parity = mark\n");
562 dev_dbg(&port->dev, "parity = odd\n");
567 dev_dbg(&port->dev, "parity = space\n");
570 dev_dbg(&port->dev, "parity = even\n");
575 dev_dbg(&port->dev, "parity = none\n");
579 * Some PL2303 are known to lose bytes if you change serial settings
580 * even to the same values as before. Thus we actually need to filter
581 * in this specific case.
583 * Note that the tty_termios_hw_change check above is not sufficient
584 * as a previously requested baud rate may differ from the one
585 * actually used (and stored in old_termios).
587 * NOTE: No additional locking needed for line_settings as it is
588 * only used in set_termios, which is serialised against itself.
590 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
591 ret = pl2303_set_line_request(port, buf);
593 memcpy(priv->line_settings, buf, 7);
596 /* change control lines if we are switching to or from B0 */
597 spin_lock_irqsave(&priv->lock, flags);
598 control = priv->line_control;
599 if (C_BAUD(tty) == B0)
600 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
601 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
602 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
603 if (control != priv->line_control) {
604 control = priv->line_control;
605 spin_unlock_irqrestore(&priv->lock, flags);
606 pl2303_set_control_lines(port, control);
608 spin_unlock_irqrestore(&priv->lock, flags);
611 if (C_CRTSCTS(tty)) {
612 if (spriv->quirks & PL2303_QUIRK_LEGACY)
613 pl2303_vendor_write(serial, 0x0, 0x41);
615 pl2303_vendor_write(serial, 0x0, 0x61);
617 pl2303_vendor_write(serial, 0x0, 0x0);
623 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
625 struct pl2303_private *priv = usb_get_serial_port_data(port);
629 spin_lock_irqsave(&priv->lock, flags);
631 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
633 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
634 control = priv->line_control;
635 spin_unlock_irqrestore(&priv->lock, flags);
637 pl2303_set_control_lines(port, control);
640 static void pl2303_close(struct usb_serial_port *port)
642 usb_serial_generic_close(port);
643 usb_kill_urb(port->interrupt_in_urb);
644 pl2303_set_break(port, false);
647 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
649 struct usb_serial *serial = port->serial;
650 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
653 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
654 usb_clear_halt(serial->dev, port->write_urb->pipe);
655 usb_clear_halt(serial->dev, port->read_urb->pipe);
657 /* reset upstream data pipes */
658 pl2303_vendor_write(serial, 8, 0);
659 pl2303_vendor_write(serial, 9, 0);
664 pl2303_set_termios(tty, port, NULL);
666 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
668 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
673 result = usb_serial_generic_open(tty, port);
675 usb_kill_urb(port->interrupt_in_urb);
682 static int pl2303_tiocmset(struct tty_struct *tty,
683 unsigned int set, unsigned int clear)
685 struct usb_serial_port *port = tty->driver_data;
686 struct pl2303_private *priv = usb_get_serial_port_data(port);
691 spin_lock_irqsave(&priv->lock, flags);
693 priv->line_control |= CONTROL_RTS;
695 priv->line_control |= CONTROL_DTR;
696 if (clear & TIOCM_RTS)
697 priv->line_control &= ~CONTROL_RTS;
698 if (clear & TIOCM_DTR)
699 priv->line_control &= ~CONTROL_DTR;
700 control = priv->line_control;
701 spin_unlock_irqrestore(&priv->lock, flags);
703 ret = pl2303_set_control_lines(port, control);
705 return usb_translate_errors(ret);
710 static int pl2303_tiocmget(struct tty_struct *tty)
712 struct usb_serial_port *port = tty->driver_data;
713 struct pl2303_private *priv = usb_get_serial_port_data(port);
719 spin_lock_irqsave(&priv->lock, flags);
720 mcr = priv->line_control;
721 status = priv->line_status;
722 spin_unlock_irqrestore(&priv->lock, flags);
724 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
725 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
726 | ((status & UART_CTS) ? TIOCM_CTS : 0)
727 | ((status & UART_DSR) ? TIOCM_DSR : 0)
728 | ((status & UART_RING) ? TIOCM_RI : 0)
729 | ((status & UART_DCD) ? TIOCM_CD : 0);
731 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
736 static int pl2303_carrier_raised(struct usb_serial_port *port)
738 struct pl2303_private *priv = usb_get_serial_port_data(port);
740 if (priv->line_status & UART_DCD)
746 static int pl2303_ioctl(struct tty_struct *tty,
747 unsigned int cmd, unsigned long arg)
749 struct serial_struct ser;
750 struct usb_serial_port *port = tty->driver_data;
754 memset(&ser, 0, sizeof ser);
755 ser.type = PORT_16654;
756 ser.line = port->minor;
757 ser.port = port->port_number;
758 ser.baud_base = 460800;
760 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
771 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
773 struct usb_serial *serial = port->serial;
782 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
783 state == BREAK_OFF ? "off" : "on");
785 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
786 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
789 dev_err(&port->dev, "error sending break = %d\n", result);
792 static void pl2303_break_ctl(struct tty_struct *tty, int state)
794 struct usb_serial_port *port = tty->driver_data;
796 pl2303_set_break(port, state);
799 static void pl2303_update_line_status(struct usb_serial_port *port,
801 unsigned int actual_length)
803 struct usb_serial *serial = port->serial;
804 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
805 struct pl2303_private *priv = usb_get_serial_port_data(port);
806 struct tty_struct *tty;
808 unsigned int status_idx = UART_STATE_INDEX;
812 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
815 if (actual_length < status_idx + 1)
818 status = data[status_idx];
820 /* Save off the uart status for others to look at */
821 spin_lock_irqsave(&priv->lock, flags);
822 delta = priv->line_status ^ status;
823 priv->line_status = status;
824 spin_unlock_irqrestore(&priv->lock, flags);
826 if (status & UART_BREAK_ERROR)
827 usb_serial_handle_break(port);
829 if (delta & UART_STATE_MSR_MASK) {
830 if (delta & UART_CTS)
832 if (delta & UART_DSR)
834 if (delta & UART_RING)
836 if (delta & UART_DCD) {
838 tty = tty_port_tty_get(&port->port);
840 usb_serial_handle_dcd_change(port, tty,
846 wake_up_interruptible(&port->port.delta_msr_wait);
850 static void pl2303_read_int_callback(struct urb *urb)
852 struct usb_serial_port *port = urb->context;
853 unsigned char *data = urb->transfer_buffer;
854 unsigned int actual_length = urb->actual_length;
855 int status = urb->status;
865 /* this urb is terminated, clean up */
866 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
870 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
875 usb_serial_debug_data(&port->dev, __func__,
876 urb->actual_length, urb->transfer_buffer);
878 pl2303_update_line_status(port, data, actual_length);
881 retval = usb_submit_urb(urb, GFP_ATOMIC);
884 "%s - usb_submit_urb failed with result %d\n",
889 static void pl2303_process_read_urb(struct urb *urb)
891 struct usb_serial_port *port = urb->context;
892 struct pl2303_private *priv = usb_get_serial_port_data(port);
893 unsigned char *data = urb->transfer_buffer;
894 char tty_flag = TTY_NORMAL;
899 /* update line status */
900 spin_lock_irqsave(&priv->lock, flags);
901 line_status = priv->line_status;
902 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
903 spin_unlock_irqrestore(&priv->lock, flags);
905 if (!urb->actual_length)
909 * Break takes precedence over parity, which takes precedence over
912 if (line_status & UART_BREAK_ERROR)
913 tty_flag = TTY_BREAK;
914 else if (line_status & UART_PARITY_ERROR)
915 tty_flag = TTY_PARITY;
916 else if (line_status & UART_FRAME_ERROR)
917 tty_flag = TTY_FRAME;
919 if (tty_flag != TTY_NORMAL)
920 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
922 /* overrun is special, not associated with a char */
923 if (line_status & UART_OVERRUN_ERROR)
924 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
926 if (port->port.console && port->sysrq) {
927 for (i = 0; i < urb->actual_length; ++i)
928 if (!usb_serial_handle_sysrq_char(port, data[i]))
929 tty_insert_flip_char(&port->port, data[i],
932 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
936 tty_flip_buffer_push(&port->port);
939 static struct usb_serial_driver pl2303_device = {
941 .owner = THIS_MODULE,
944 .id_table = id_table,
947 .bulk_out_size = 256,
949 .close = pl2303_close,
950 .dtr_rts = pl2303_dtr_rts,
951 .carrier_raised = pl2303_carrier_raised,
952 .ioctl = pl2303_ioctl,
953 .break_ctl = pl2303_break_ctl,
954 .set_termios = pl2303_set_termios,
955 .tiocmget = pl2303_tiocmget,
956 .tiocmset = pl2303_tiocmset,
957 .tiocmiwait = usb_serial_generic_tiocmiwait,
958 .process_read_urb = pl2303_process_read_urb,
959 .read_int_callback = pl2303_read_int_callback,
960 .probe = pl2303_probe,
961 .attach = pl2303_startup,
962 .release = pl2303_release,
963 .port_probe = pl2303_port_probe,
964 .port_remove = pl2303_port_remove,
967 static struct usb_serial_driver * const serial_drivers[] = {
971 module_usb_serial_driver(serial_drivers, id_table);
973 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
974 MODULE_LICENSE("GPL");