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_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(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
65 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
66 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
67 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
68 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
69 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
71 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
72 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
73 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
74 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
75 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
76 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
77 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
78 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
79 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
80 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
81 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
82 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
83 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
84 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
85 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
86 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
87 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
88 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
89 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
90 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
91 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
92 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
93 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
94 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
95 { } /* Terminating entry */
98 MODULE_DEVICE_TABLE(usb, id_table);
100 #define SET_LINE_REQUEST_TYPE 0x21
101 #define SET_LINE_REQUEST 0x20
103 #define SET_CONTROL_REQUEST_TYPE 0x21
104 #define SET_CONTROL_REQUEST 0x22
105 #define CONTROL_DTR 0x01
106 #define CONTROL_RTS 0x02
108 #define BREAK_REQUEST_TYPE 0x21
109 #define BREAK_REQUEST 0x23
110 #define BREAK_ON 0xffff
111 #define BREAK_OFF 0x0000
113 #define GET_LINE_REQUEST_TYPE 0xa1
114 #define GET_LINE_REQUEST 0x21
116 #define VENDOR_WRITE_REQUEST_TYPE 0x40
117 #define VENDOR_WRITE_REQUEST 0x01
119 #define VENDOR_READ_REQUEST_TYPE 0xc0
120 #define VENDOR_READ_REQUEST 0x01
122 #define UART_STATE_INDEX 8
123 #define UART_STATE_MSR_MASK 0x8b
124 #define UART_STATE_TRANSIENT_MASK 0x74
125 #define UART_DCD 0x01
126 #define UART_DSR 0x02
127 #define UART_BREAK_ERROR 0x04
128 #define UART_RING 0x08
129 #define UART_FRAME_ERROR 0x10
130 #define UART_PARITY_ERROR 0x20
131 #define UART_OVERRUN_ERROR 0x40
132 #define UART_CTS 0x80
134 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
137 TYPE_01, /* Type 0 and 1 (difference unknown) */
138 TYPE_HX, /* HX version of the pl2303 chip */
142 struct pl2303_type_data {
143 speed_t max_baud_rate;
144 unsigned long quirks;
147 struct pl2303_serial_private {
148 const struct pl2303_type_data *type;
149 unsigned long quirks;
152 struct pl2303_private {
160 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
162 .max_baud_rate = 1228800,
163 .quirks = PL2303_QUIRK_LEGACY,
166 .max_baud_rate = 12000000,
170 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
171 unsigned char buf[1])
173 struct device *dev = &serial->interface->dev;
176 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
177 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
178 value, 0, buf, 1, 100);
180 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
188 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
193 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
195 struct device *dev = &serial->interface->dev;
198 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
200 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
201 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
202 value, index, NULL, 0, 100);
204 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
212 static int pl2303_probe(struct usb_serial *serial,
213 const struct usb_device_id *id)
215 usb_set_serial_data(serial, (void *)id->driver_info);
220 static int pl2303_startup(struct usb_serial *serial)
222 struct pl2303_serial_private *spriv;
223 unsigned char num_ports = serial->num_ports;
224 enum pl2303_type type = TYPE_01;
227 if (serial->num_bulk_in < num_ports ||
228 serial->num_bulk_out < num_ports ||
229 serial->num_interrupt_in < num_ports) {
230 dev_err(&serial->interface->dev, "missing endpoints\n");
234 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
238 buf = kmalloc(1, GFP_KERNEL);
244 if (serial->dev->descriptor.bDeviceClass == 0x02)
245 type = TYPE_01; /* type 0 */
246 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
248 else if (serial->dev->descriptor.bDeviceClass == 0x00)
249 type = TYPE_01; /* type 1 */
250 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
251 type = TYPE_01; /* type 1 */
252 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
254 spriv->type = &pl2303_type_data[type];
255 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
256 spriv->quirks |= spriv->type->quirks;
258 usb_set_serial_data(serial, spriv);
260 pl2303_vendor_read(serial, 0x8484, buf);
261 pl2303_vendor_write(serial, 0x0404, 0);
262 pl2303_vendor_read(serial, 0x8484, buf);
263 pl2303_vendor_read(serial, 0x8383, buf);
264 pl2303_vendor_read(serial, 0x8484, buf);
265 pl2303_vendor_write(serial, 0x0404, 1);
266 pl2303_vendor_read(serial, 0x8484, buf);
267 pl2303_vendor_read(serial, 0x8383, buf);
268 pl2303_vendor_write(serial, 0, 1);
269 pl2303_vendor_write(serial, 1, 0);
270 if (spriv->quirks & PL2303_QUIRK_LEGACY)
271 pl2303_vendor_write(serial, 2, 0x24);
273 pl2303_vendor_write(serial, 2, 0x44);
280 static void pl2303_release(struct usb_serial *serial)
282 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
287 static int pl2303_port_probe(struct usb_serial_port *port)
289 struct pl2303_private *priv;
291 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
295 spin_lock_init(&priv->lock);
297 usb_set_serial_port_data(port, priv);
299 port->port.drain_delay = 256;
304 static int pl2303_port_remove(struct usb_serial_port *port)
306 struct pl2303_private *priv = usb_get_serial_port_data(port);
313 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
315 struct usb_device *dev = port->serial->dev;
318 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
320 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
321 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
322 value, 0, NULL, 0, 100);
324 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
330 * Returns the nearest supported baud rate that can be set directly without
333 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
335 static const speed_t baud_sup[] = {
336 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
337 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
338 614400, 921600, 1228800, 2457600, 3000000, 6000000
343 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
344 if (baud_sup[i] > baud)
348 if (i == ARRAY_SIZE(baud_sup))
349 baud = baud_sup[i - 1];
350 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
351 baud = baud_sup[i - 1];
359 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
362 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
365 put_unaligned_le32(baud, buf);
370 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
373 unsigned int baseline, mantissa, exponent;
376 * Apparently the formula is:
377 * baudrate = 12M * 32 / (mantissa * 4^exponent)
379 * mantissa = buf[8:0]
380 * exponent = buf[11:9]
382 baseline = 12000000 * 32;
383 mantissa = baseline / baud;
385 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
387 while (mantissa >= 512) {
389 mantissa >>= 2; /* divide by 4 */
392 /* Exponent is maxed. Trim mantissa and leave. */
400 buf[1] = exponent << 1 | mantissa >> 8;
401 buf[0] = mantissa & 0xff;
403 /* Calculate and return the exact baud rate. */
404 baud = (baseline / mantissa) >> (exponent << 1);
409 static void pl2303_encode_baud_rate(struct tty_struct *tty,
410 struct usb_serial_port *port,
413 struct usb_serial *serial = port->serial;
414 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
418 baud = tty_get_baud_rate(tty);
419 dev_dbg(&port->dev, "baud requested = %u\n", baud);
423 if (spriv->type->max_baud_rate)
424 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
426 * Use direct method for supported baud rates, otherwise use divisors.
428 baud_sup = pl2303_get_supported_baud_rate(baud);
430 if (baud == baud_sup)
431 baud = pl2303_encode_baud_rate_direct(buf, baud);
433 baud = pl2303_encode_baud_rate_divisor(buf, baud);
435 /* Save resulting baud rate */
436 tty_encode_baud_rate(tty, baud, baud);
437 dev_dbg(&port->dev, "baud set = %u\n", baud);
440 static int pl2303_get_line_request(struct usb_serial_port *port,
441 unsigned char buf[7])
443 struct usb_device *udev = port->serial->dev;
446 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
447 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
450 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
458 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
463 static int pl2303_set_line_request(struct usb_serial_port *port,
464 unsigned char buf[7])
466 struct usb_device *udev = port->serial->dev;
469 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
470 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
473 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
481 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
486 static void pl2303_set_termios(struct tty_struct *tty,
487 struct usb_serial_port *port, struct ktermios *old_termios)
489 struct usb_serial *serial = port->serial;
490 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
491 struct pl2303_private *priv = usb_get_serial_port_data(port);
497 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
500 buf = kzalloc(7, GFP_KERNEL);
502 /* Report back no change occurred */
504 tty->termios = *old_termios;
508 pl2303_get_line_request(port, buf);
510 switch (C_CSIZE(tty)) {
524 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
526 /* For reference buf[0]:buf[3] baud rate value */
527 pl2303_encode_baud_rate(tty, port, &buf[0]);
529 /* For reference buf[4]=0 is 1 stop bits */
530 /* For reference buf[4]=1 is 1.5 stop bits */
531 /* For reference buf[4]=2 is 2 stop bits */
534 * NOTE: Comply with "real" UARTs / RS232:
535 * use 1.5 instead of 2 stop bits with 5 data bits
537 if (C_CSIZE(tty) == CS5) {
539 dev_dbg(&port->dev, "stop bits = 1.5\n");
542 dev_dbg(&port->dev, "stop bits = 2\n");
546 dev_dbg(&port->dev, "stop bits = 1\n");
550 /* For reference buf[5]=0 is none parity */
551 /* For reference buf[5]=1 is odd parity */
552 /* For reference buf[5]=2 is even parity */
553 /* For reference buf[5]=3 is mark parity */
554 /* For reference buf[5]=4 is space parity */
558 dev_dbg(&port->dev, "parity = mark\n");
561 dev_dbg(&port->dev, "parity = odd\n");
566 dev_dbg(&port->dev, "parity = space\n");
569 dev_dbg(&port->dev, "parity = even\n");
574 dev_dbg(&port->dev, "parity = none\n");
578 * Some PL2303 are known to lose bytes if you change serial settings
579 * even to the same values as before. Thus we actually need to filter
580 * in this specific case.
582 * Note that the tty_termios_hw_change check above is not sufficient
583 * as a previously requested baud rate may differ from the one
584 * actually used (and stored in old_termios).
586 * NOTE: No additional locking needed for line_settings as it is
587 * only used in set_termios, which is serialised against itself.
589 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
590 ret = pl2303_set_line_request(port, buf);
592 memcpy(priv->line_settings, buf, 7);
595 /* change control lines if we are switching to or from B0 */
596 spin_lock_irqsave(&priv->lock, flags);
597 control = priv->line_control;
598 if (C_BAUD(tty) == B0)
599 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
600 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
601 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
602 if (control != priv->line_control) {
603 control = priv->line_control;
604 spin_unlock_irqrestore(&priv->lock, flags);
605 pl2303_set_control_lines(port, control);
607 spin_unlock_irqrestore(&priv->lock, flags);
610 if (C_CRTSCTS(tty)) {
611 if (spriv->quirks & PL2303_QUIRK_LEGACY)
612 pl2303_vendor_write(serial, 0x0, 0x41);
614 pl2303_vendor_write(serial, 0x0, 0x61);
616 pl2303_vendor_write(serial, 0x0, 0x0);
622 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
624 struct pl2303_private *priv = usb_get_serial_port_data(port);
628 spin_lock_irqsave(&priv->lock, flags);
630 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
632 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
633 control = priv->line_control;
634 spin_unlock_irqrestore(&priv->lock, flags);
636 pl2303_set_control_lines(port, control);
639 static void pl2303_close(struct usb_serial_port *port)
641 usb_serial_generic_close(port);
642 usb_kill_urb(port->interrupt_in_urb);
643 pl2303_set_break(port, false);
646 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
648 struct usb_serial *serial = port->serial;
649 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
652 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
653 usb_clear_halt(serial->dev, port->write_urb->pipe);
654 usb_clear_halt(serial->dev, port->read_urb->pipe);
656 /* reset upstream data pipes */
657 pl2303_vendor_write(serial, 8, 0);
658 pl2303_vendor_write(serial, 9, 0);
663 pl2303_set_termios(tty, port, NULL);
665 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
667 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
672 result = usb_serial_generic_open(tty, port);
674 usb_kill_urb(port->interrupt_in_urb);
681 static int pl2303_tiocmset(struct tty_struct *tty,
682 unsigned int set, unsigned int clear)
684 struct usb_serial_port *port = tty->driver_data;
685 struct pl2303_private *priv = usb_get_serial_port_data(port);
690 spin_lock_irqsave(&priv->lock, flags);
692 priv->line_control |= CONTROL_RTS;
694 priv->line_control |= CONTROL_DTR;
695 if (clear & TIOCM_RTS)
696 priv->line_control &= ~CONTROL_RTS;
697 if (clear & TIOCM_DTR)
698 priv->line_control &= ~CONTROL_DTR;
699 control = priv->line_control;
700 spin_unlock_irqrestore(&priv->lock, flags);
702 ret = pl2303_set_control_lines(port, control);
704 return usb_translate_errors(ret);
709 static int pl2303_tiocmget(struct tty_struct *tty)
711 struct usb_serial_port *port = tty->driver_data;
712 struct pl2303_private *priv = usb_get_serial_port_data(port);
718 spin_lock_irqsave(&priv->lock, flags);
719 mcr = priv->line_control;
720 status = priv->line_status;
721 spin_unlock_irqrestore(&priv->lock, flags);
723 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
724 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
725 | ((status & UART_CTS) ? TIOCM_CTS : 0)
726 | ((status & UART_DSR) ? TIOCM_DSR : 0)
727 | ((status & UART_RING) ? TIOCM_RI : 0)
728 | ((status & UART_DCD) ? TIOCM_CD : 0);
730 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
735 static int pl2303_carrier_raised(struct usb_serial_port *port)
737 struct pl2303_private *priv = usb_get_serial_port_data(port);
739 if (priv->line_status & UART_DCD)
745 static int pl2303_ioctl(struct tty_struct *tty,
746 unsigned int cmd, unsigned long arg)
748 struct serial_struct ser;
749 struct usb_serial_port *port = tty->driver_data;
753 memset(&ser, 0, sizeof ser);
754 ser.type = PORT_16654;
755 ser.line = port->minor;
756 ser.port = port->port_number;
757 ser.baud_base = 460800;
759 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
770 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
772 struct usb_serial *serial = port->serial;
781 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
782 state == BREAK_OFF ? "off" : "on");
784 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
785 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
788 dev_err(&port->dev, "error sending break = %d\n", result);
791 static void pl2303_break_ctl(struct tty_struct *tty, int state)
793 struct usb_serial_port *port = tty->driver_data;
795 pl2303_set_break(port, state);
798 static void pl2303_update_line_status(struct usb_serial_port *port,
800 unsigned int actual_length)
802 struct usb_serial *serial = port->serial;
803 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
804 struct pl2303_private *priv = usb_get_serial_port_data(port);
805 struct tty_struct *tty;
807 unsigned int status_idx = UART_STATE_INDEX;
811 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
814 if (actual_length < status_idx + 1)
817 status = data[status_idx];
819 /* Save off the uart status for others to look at */
820 spin_lock_irqsave(&priv->lock, flags);
821 delta = priv->line_status ^ status;
822 priv->line_status = status;
823 spin_unlock_irqrestore(&priv->lock, flags);
825 if (status & UART_BREAK_ERROR)
826 usb_serial_handle_break(port);
828 if (delta & UART_STATE_MSR_MASK) {
829 if (delta & UART_CTS)
831 if (delta & UART_DSR)
833 if (delta & UART_RING)
835 if (delta & UART_DCD) {
837 tty = tty_port_tty_get(&port->port);
839 usb_serial_handle_dcd_change(port, tty,
845 wake_up_interruptible(&port->port.delta_msr_wait);
849 static void pl2303_read_int_callback(struct urb *urb)
851 struct usb_serial_port *port = urb->context;
852 unsigned char *data = urb->transfer_buffer;
853 unsigned int actual_length = urb->actual_length;
854 int status = urb->status;
864 /* this urb is terminated, clean up */
865 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
869 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
874 usb_serial_debug_data(&port->dev, __func__,
875 urb->actual_length, urb->transfer_buffer);
877 pl2303_update_line_status(port, data, actual_length);
880 retval = usb_submit_urb(urb, GFP_ATOMIC);
883 "%s - usb_submit_urb failed with result %d\n",
888 static void pl2303_process_read_urb(struct urb *urb)
890 struct usb_serial_port *port = urb->context;
891 struct pl2303_private *priv = usb_get_serial_port_data(port);
892 unsigned char *data = urb->transfer_buffer;
893 char tty_flag = TTY_NORMAL;
898 /* update line status */
899 spin_lock_irqsave(&priv->lock, flags);
900 line_status = priv->line_status;
901 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
902 spin_unlock_irqrestore(&priv->lock, flags);
904 if (!urb->actual_length)
908 * Break takes precedence over parity, which takes precedence over
911 if (line_status & UART_BREAK_ERROR)
912 tty_flag = TTY_BREAK;
913 else if (line_status & UART_PARITY_ERROR)
914 tty_flag = TTY_PARITY;
915 else if (line_status & UART_FRAME_ERROR)
916 tty_flag = TTY_FRAME;
918 if (tty_flag != TTY_NORMAL)
919 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
921 /* overrun is special, not associated with a char */
922 if (line_status & UART_OVERRUN_ERROR)
923 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
925 if (port->port.console && port->sysrq) {
926 for (i = 0; i < urb->actual_length; ++i)
927 if (!usb_serial_handle_sysrq_char(port, data[i]))
928 tty_insert_flip_char(&port->port, data[i],
931 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
935 tty_flip_buffer_push(&port->port);
938 static struct usb_serial_driver pl2303_device = {
940 .owner = THIS_MODULE,
943 .id_table = id_table,
946 .bulk_out_size = 256,
948 .close = pl2303_close,
949 .dtr_rts = pl2303_dtr_rts,
950 .carrier_raised = pl2303_carrier_raised,
951 .ioctl = pl2303_ioctl,
952 .break_ctl = pl2303_break_ctl,
953 .set_termios = pl2303_set_termios,
954 .tiocmget = pl2303_tiocmget,
955 .tiocmset = pl2303_tiocmset,
956 .tiocmiwait = usb_serial_generic_tiocmiwait,
957 .process_read_urb = pl2303_process_read_urb,
958 .read_int_callback = pl2303_read_int_callback,
959 .probe = pl2303_probe,
960 .attach = pl2303_startup,
961 .release = pl2303_release,
962 .port_probe = pl2303_port_probe,
963 .port_remove = pl2303_port_remove,
966 static struct usb_serial_driver * const serial_drivers[] = {
970 module_usb_serial_driver(serial_drivers, id_table);
972 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
973 MODULE_LICENSE("GPL");