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)
36 #define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
38 static const struct usb_device_id id_table[] = {
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
40 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
53 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
54 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
55 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
56 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
57 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
58 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
59 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
60 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
61 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
62 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
63 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
64 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
65 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
66 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
67 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
68 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
69 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
70 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
71 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
72 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
73 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
75 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
76 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
77 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
79 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
81 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
82 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
83 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
84 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
85 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
86 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
87 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
88 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
89 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
90 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
91 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
92 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
93 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
94 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
95 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
96 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
97 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
98 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
99 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
102 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
103 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
105 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
106 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
107 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
108 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
109 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
110 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
111 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
112 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
113 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
114 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
115 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
116 { } /* Terminating entry */
119 MODULE_DEVICE_TABLE(usb, id_table);
121 #define SET_LINE_REQUEST_TYPE 0x21
122 #define SET_LINE_REQUEST 0x20
124 #define SET_CONTROL_REQUEST_TYPE 0x21
125 #define SET_CONTROL_REQUEST 0x22
126 #define CONTROL_DTR 0x01
127 #define CONTROL_RTS 0x02
129 #define BREAK_REQUEST_TYPE 0x21
130 #define BREAK_REQUEST 0x23
131 #define BREAK_ON 0xffff
132 #define BREAK_OFF 0x0000
134 #define GET_LINE_REQUEST_TYPE 0xa1
135 #define GET_LINE_REQUEST 0x21
137 #define VENDOR_WRITE_REQUEST_TYPE 0x40
138 #define VENDOR_WRITE_REQUEST 0x01
140 #define VENDOR_READ_REQUEST_TYPE 0xc0
141 #define VENDOR_READ_REQUEST 0x01
143 #define UART_STATE_INDEX 8
144 #define UART_STATE_MSR_MASK 0x8b
145 #define UART_STATE_TRANSIENT_MASK 0x74
146 #define UART_DCD 0x01
147 #define UART_DSR 0x02
148 #define UART_BREAK_ERROR 0x04
149 #define UART_RING 0x08
150 #define UART_FRAME_ERROR 0x10
151 #define UART_PARITY_ERROR 0x20
152 #define UART_OVERRUN_ERROR 0x40
153 #define UART_CTS 0x80
155 static void pl2303_set_break(struct usb_serial_port *port, bool enable);
158 TYPE_01, /* Type 0 and 1 (difference unknown) */
159 TYPE_HX, /* HX version of the pl2303 chip */
163 struct pl2303_type_data {
164 speed_t max_baud_rate;
165 unsigned long quirks;
168 struct pl2303_serial_private {
169 const struct pl2303_type_data *type;
170 unsigned long quirks;
173 struct pl2303_private {
181 static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
183 .max_baud_rate = 1228800,
184 .quirks = PL2303_QUIRK_LEGACY,
187 .max_baud_rate = 12000000,
191 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
192 unsigned char buf[1])
194 struct device *dev = &serial->interface->dev;
197 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
198 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
199 value, 0, buf, 1, 100);
201 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
209 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
214 static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
216 struct device *dev = &serial->interface->dev;
219 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
221 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
222 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
223 value, index, NULL, 0, 100);
225 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
233 static int pl2303_probe(struct usb_serial *serial,
234 const struct usb_device_id *id)
236 usb_set_serial_data(serial, (void *)id->driver_info);
242 * Use interrupt endpoint from first interface if available.
244 * This is needed due to the looney way its endpoints are set up.
246 static int pl2303_endpoint_hack(struct usb_serial *serial,
247 struct usb_serial_endpoints *epds)
249 struct usb_interface *interface = serial->interface;
250 struct usb_device *dev = serial->dev;
251 struct device *ddev = &interface->dev;
252 struct usb_host_interface *iface_desc;
253 struct usb_endpoint_descriptor *endpoint;
256 if (interface == dev->actconfig->interface[0])
259 /* check out the endpoints of the other interface */
260 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
262 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
263 endpoint = &iface_desc->endpoint[i].desc;
265 if (!usb_endpoint_is_int_in(endpoint))
268 dev_dbg(ddev, "found interrupt in on separate interface\n");
269 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
270 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
276 static int pl2303_calc_num_ports(struct usb_serial *serial,
277 struct usb_serial_endpoints *epds)
279 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
280 struct device *dev = &serial->interface->dev;
283 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
284 ret = pl2303_endpoint_hack(serial, epds);
289 if (epds->num_interrupt_in < 1) {
290 dev_err(dev, "required interrupt-in endpoint missing\n");
297 static int pl2303_startup(struct usb_serial *serial)
299 struct pl2303_serial_private *spriv;
300 enum pl2303_type type = TYPE_01;
303 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
307 buf = kmalloc(1, GFP_KERNEL);
313 if (serial->dev->descriptor.bDeviceClass == 0x02)
314 type = TYPE_01; /* type 0 */
315 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
317 else if (serial->dev->descriptor.bDeviceClass == 0x00)
318 type = TYPE_01; /* type 1 */
319 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
320 type = TYPE_01; /* type 1 */
321 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
323 spriv->type = &pl2303_type_data[type];
324 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
325 spriv->quirks |= spriv->type->quirks;
327 usb_set_serial_data(serial, spriv);
329 pl2303_vendor_read(serial, 0x8484, buf);
330 pl2303_vendor_write(serial, 0x0404, 0);
331 pl2303_vendor_read(serial, 0x8484, buf);
332 pl2303_vendor_read(serial, 0x8383, buf);
333 pl2303_vendor_read(serial, 0x8484, buf);
334 pl2303_vendor_write(serial, 0x0404, 1);
335 pl2303_vendor_read(serial, 0x8484, buf);
336 pl2303_vendor_read(serial, 0x8383, buf);
337 pl2303_vendor_write(serial, 0, 1);
338 pl2303_vendor_write(serial, 1, 0);
339 if (spriv->quirks & PL2303_QUIRK_LEGACY)
340 pl2303_vendor_write(serial, 2, 0x24);
342 pl2303_vendor_write(serial, 2, 0x44);
349 static void pl2303_release(struct usb_serial *serial)
351 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
356 static int pl2303_port_probe(struct usb_serial_port *port)
358 struct pl2303_private *priv;
360 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
364 spin_lock_init(&priv->lock);
366 usb_set_serial_port_data(port, priv);
368 port->port.drain_delay = 256;
373 static int pl2303_port_remove(struct usb_serial_port *port)
375 struct pl2303_private *priv = usb_get_serial_port_data(port);
382 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
384 struct usb_device *dev = port->serial->dev;
387 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
389 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
390 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
391 value, 0, NULL, 0, 100);
393 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
399 * Returns the nearest supported baud rate that can be set directly without
402 static speed_t pl2303_get_supported_baud_rate(speed_t baud)
404 static const speed_t baud_sup[] = {
405 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
406 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
407 614400, 921600, 1228800, 2457600, 3000000, 6000000
412 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
413 if (baud_sup[i] > baud)
417 if (i == ARRAY_SIZE(baud_sup))
418 baud = baud_sup[i - 1];
419 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
420 baud = baud_sup[i - 1];
428 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
431 static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
434 put_unaligned_le32(baud, buf);
439 static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
442 unsigned int baseline, mantissa, exponent;
445 * Apparently the formula is:
446 * baudrate = 12M * 32 / (mantissa * 4^exponent)
448 * mantissa = buf[8:0]
449 * exponent = buf[11:9]
451 baseline = 12000000 * 32;
452 mantissa = baseline / baud;
454 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
456 while (mantissa >= 512) {
458 mantissa >>= 2; /* divide by 4 */
461 /* Exponent is maxed. Trim mantissa and leave. */
469 buf[1] = exponent << 1 | mantissa >> 8;
470 buf[0] = mantissa & 0xff;
472 /* Calculate and return the exact baud rate. */
473 baud = (baseline / mantissa) >> (exponent << 1);
478 static void pl2303_encode_baud_rate(struct tty_struct *tty,
479 struct usb_serial_port *port,
482 struct usb_serial *serial = port->serial;
483 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
487 baud = tty_get_baud_rate(tty);
488 dev_dbg(&port->dev, "baud requested = %u\n", baud);
492 if (spriv->type->max_baud_rate)
493 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
495 * Use direct method for supported baud rates, otherwise use divisors.
497 baud_sup = pl2303_get_supported_baud_rate(baud);
499 if (baud == baud_sup)
500 baud = pl2303_encode_baud_rate_direct(buf, baud);
502 baud = pl2303_encode_baud_rate_divisor(buf, baud);
504 /* Save resulting baud rate */
505 tty_encode_baud_rate(tty, baud, baud);
506 dev_dbg(&port->dev, "baud set = %u\n", baud);
509 static int pl2303_get_line_request(struct usb_serial_port *port,
510 unsigned char buf[7])
512 struct usb_device *udev = port->serial->dev;
515 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
516 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
519 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
527 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
532 static int pl2303_set_line_request(struct usb_serial_port *port,
533 unsigned char buf[7])
535 struct usb_device *udev = port->serial->dev;
538 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
539 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
542 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
546 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
551 static void pl2303_set_termios(struct tty_struct *tty,
552 struct usb_serial_port *port, struct ktermios *old_termios)
554 struct usb_serial *serial = port->serial;
555 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
556 struct pl2303_private *priv = usb_get_serial_port_data(port);
562 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
565 buf = kzalloc(7, GFP_KERNEL);
567 /* Report back no change occurred */
569 tty->termios = *old_termios;
573 pl2303_get_line_request(port, buf);
575 switch (C_CSIZE(tty)) {
589 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
591 /* For reference buf[0]:buf[3] baud rate value */
592 pl2303_encode_baud_rate(tty, port, &buf[0]);
594 /* For reference buf[4]=0 is 1 stop bits */
595 /* For reference buf[4]=1 is 1.5 stop bits */
596 /* For reference buf[4]=2 is 2 stop bits */
599 * NOTE: Comply with "real" UARTs / RS232:
600 * use 1.5 instead of 2 stop bits with 5 data bits
602 if (C_CSIZE(tty) == CS5) {
604 dev_dbg(&port->dev, "stop bits = 1.5\n");
607 dev_dbg(&port->dev, "stop bits = 2\n");
611 dev_dbg(&port->dev, "stop bits = 1\n");
615 /* For reference buf[5]=0 is none parity */
616 /* For reference buf[5]=1 is odd parity */
617 /* For reference buf[5]=2 is even parity */
618 /* For reference buf[5]=3 is mark parity */
619 /* For reference buf[5]=4 is space parity */
623 dev_dbg(&port->dev, "parity = mark\n");
626 dev_dbg(&port->dev, "parity = odd\n");
631 dev_dbg(&port->dev, "parity = space\n");
634 dev_dbg(&port->dev, "parity = even\n");
639 dev_dbg(&port->dev, "parity = none\n");
643 * Some PL2303 are known to lose bytes if you change serial settings
644 * even to the same values as before. Thus we actually need to filter
645 * in this specific case.
647 * Note that the tty_termios_hw_change check above is not sufficient
648 * as a previously requested baud rate may differ from the one
649 * actually used (and stored in old_termios).
651 * NOTE: No additional locking needed for line_settings as it is
652 * only used in set_termios, which is serialised against itself.
654 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
655 ret = pl2303_set_line_request(port, buf);
657 memcpy(priv->line_settings, buf, 7);
660 /* change control lines if we are switching to or from B0 */
661 spin_lock_irqsave(&priv->lock, flags);
662 control = priv->line_control;
663 if (C_BAUD(tty) == B0)
664 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
665 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
666 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
667 if (control != priv->line_control) {
668 control = priv->line_control;
669 spin_unlock_irqrestore(&priv->lock, flags);
670 pl2303_set_control_lines(port, control);
672 spin_unlock_irqrestore(&priv->lock, flags);
675 if (C_CRTSCTS(tty)) {
676 if (spriv->quirks & PL2303_QUIRK_LEGACY)
677 pl2303_vendor_write(serial, 0x0, 0x41);
679 pl2303_vendor_write(serial, 0x0, 0x61);
681 pl2303_vendor_write(serial, 0x0, 0x0);
687 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
689 struct pl2303_private *priv = usb_get_serial_port_data(port);
693 spin_lock_irqsave(&priv->lock, flags);
695 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
697 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
698 control = priv->line_control;
699 spin_unlock_irqrestore(&priv->lock, flags);
701 pl2303_set_control_lines(port, control);
704 static void pl2303_close(struct usb_serial_port *port)
706 usb_serial_generic_close(port);
707 usb_kill_urb(port->interrupt_in_urb);
708 pl2303_set_break(port, false);
711 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
713 struct usb_serial *serial = port->serial;
714 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
717 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
718 usb_clear_halt(serial->dev, port->write_urb->pipe);
719 usb_clear_halt(serial->dev, port->read_urb->pipe);
721 /* reset upstream data pipes */
722 pl2303_vendor_write(serial, 8, 0);
723 pl2303_vendor_write(serial, 9, 0);
728 pl2303_set_termios(tty, port, NULL);
730 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
732 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
737 result = usb_serial_generic_open(tty, port);
739 usb_kill_urb(port->interrupt_in_urb);
746 static int pl2303_tiocmset(struct tty_struct *tty,
747 unsigned int set, unsigned int clear)
749 struct usb_serial_port *port = tty->driver_data;
750 struct pl2303_private *priv = usb_get_serial_port_data(port);
755 spin_lock_irqsave(&priv->lock, flags);
757 priv->line_control |= CONTROL_RTS;
759 priv->line_control |= CONTROL_DTR;
760 if (clear & TIOCM_RTS)
761 priv->line_control &= ~CONTROL_RTS;
762 if (clear & TIOCM_DTR)
763 priv->line_control &= ~CONTROL_DTR;
764 control = priv->line_control;
765 spin_unlock_irqrestore(&priv->lock, flags);
767 ret = pl2303_set_control_lines(port, control);
769 return usb_translate_errors(ret);
774 static int pl2303_tiocmget(struct tty_struct *tty)
776 struct usb_serial_port *port = tty->driver_data;
777 struct pl2303_private *priv = usb_get_serial_port_data(port);
783 spin_lock_irqsave(&priv->lock, flags);
784 mcr = priv->line_control;
785 status = priv->line_status;
786 spin_unlock_irqrestore(&priv->lock, flags);
788 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
789 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
790 | ((status & UART_CTS) ? TIOCM_CTS : 0)
791 | ((status & UART_DSR) ? TIOCM_DSR : 0)
792 | ((status & UART_RING) ? TIOCM_RI : 0)
793 | ((status & UART_DCD) ? TIOCM_CD : 0);
795 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
800 static int pl2303_carrier_raised(struct usb_serial_port *port)
802 struct pl2303_private *priv = usb_get_serial_port_data(port);
804 if (priv->line_status & UART_DCD)
810 static int pl2303_ioctl(struct tty_struct *tty,
811 unsigned int cmd, unsigned long arg)
813 struct serial_struct ser;
814 struct usb_serial_port *port = tty->driver_data;
818 memset(&ser, 0, sizeof ser);
819 ser.type = PORT_16654;
820 ser.line = port->minor;
821 ser.port = port->port_number;
822 ser.baud_base = 460800;
824 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
835 static void pl2303_set_break(struct usb_serial_port *port, bool enable)
837 struct usb_serial *serial = port->serial;
846 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
847 state == BREAK_OFF ? "off" : "on");
849 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
850 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
853 dev_err(&port->dev, "error sending break = %d\n", result);
856 static void pl2303_break_ctl(struct tty_struct *tty, int state)
858 struct usb_serial_port *port = tty->driver_data;
860 pl2303_set_break(port, state);
863 static void pl2303_update_line_status(struct usb_serial_port *port,
865 unsigned int actual_length)
867 struct usb_serial *serial = port->serial;
868 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
869 struct pl2303_private *priv = usb_get_serial_port_data(port);
870 struct tty_struct *tty;
872 unsigned int status_idx = UART_STATE_INDEX;
876 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
879 if (actual_length < status_idx + 1)
882 status = data[status_idx];
884 /* Save off the uart status for others to look at */
885 spin_lock_irqsave(&priv->lock, flags);
886 delta = priv->line_status ^ status;
887 priv->line_status = status;
888 spin_unlock_irqrestore(&priv->lock, flags);
890 if (status & UART_BREAK_ERROR)
891 usb_serial_handle_break(port);
893 if (delta & UART_STATE_MSR_MASK) {
894 if (delta & UART_CTS)
896 if (delta & UART_DSR)
898 if (delta & UART_RING)
900 if (delta & UART_DCD) {
902 tty = tty_port_tty_get(&port->port);
904 usb_serial_handle_dcd_change(port, tty,
910 wake_up_interruptible(&port->port.delta_msr_wait);
914 static void pl2303_read_int_callback(struct urb *urb)
916 struct usb_serial_port *port = urb->context;
917 unsigned char *data = urb->transfer_buffer;
918 unsigned int actual_length = urb->actual_length;
919 int status = urb->status;
929 /* this urb is terminated, clean up */
930 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
934 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
939 usb_serial_debug_data(&port->dev, __func__,
940 urb->actual_length, urb->transfer_buffer);
942 pl2303_update_line_status(port, data, actual_length);
945 retval = usb_submit_urb(urb, GFP_ATOMIC);
948 "%s - usb_submit_urb failed with result %d\n",
953 static void pl2303_process_read_urb(struct urb *urb)
955 struct usb_serial_port *port = urb->context;
956 struct pl2303_private *priv = usb_get_serial_port_data(port);
957 unsigned char *data = urb->transfer_buffer;
958 char tty_flag = TTY_NORMAL;
963 /* update line status */
964 spin_lock_irqsave(&priv->lock, flags);
965 line_status = priv->line_status;
966 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
967 spin_unlock_irqrestore(&priv->lock, flags);
969 if (!urb->actual_length)
973 * Break takes precedence over parity, which takes precedence over
976 if (line_status & UART_BREAK_ERROR)
977 tty_flag = TTY_BREAK;
978 else if (line_status & UART_PARITY_ERROR)
979 tty_flag = TTY_PARITY;
980 else if (line_status & UART_FRAME_ERROR)
981 tty_flag = TTY_FRAME;
983 if (tty_flag != TTY_NORMAL)
984 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
986 /* overrun is special, not associated with a char */
987 if (line_status & UART_OVERRUN_ERROR)
988 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
990 if (port->port.console && port->sysrq) {
991 for (i = 0; i < urb->actual_length; ++i)
992 if (!usb_serial_handle_sysrq_char(port, data[i]))
993 tty_insert_flip_char(&port->port, data[i],
996 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1000 tty_flip_buffer_push(&port->port);
1003 static struct usb_serial_driver pl2303_device = {
1005 .owner = THIS_MODULE,
1008 .id_table = id_table,
1011 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1012 .bulk_in_size = 256,
1013 .bulk_out_size = 256,
1014 .open = pl2303_open,
1015 .close = pl2303_close,
1016 .dtr_rts = pl2303_dtr_rts,
1017 .carrier_raised = pl2303_carrier_raised,
1018 .ioctl = pl2303_ioctl,
1019 .break_ctl = pl2303_break_ctl,
1020 .set_termios = pl2303_set_termios,
1021 .tiocmget = pl2303_tiocmget,
1022 .tiocmset = pl2303_tiocmset,
1023 .tiocmiwait = usb_serial_generic_tiocmiwait,
1024 .process_read_urb = pl2303_process_read_urb,
1025 .read_int_callback = pl2303_read_int_callback,
1026 .probe = pl2303_probe,
1027 .calc_num_ports = pl2303_calc_num_ports,
1028 .attach = pl2303_startup,
1029 .release = pl2303_release,
1030 .port_probe = pl2303_port_probe,
1031 .port_remove = pl2303_port_remove,
1034 static struct usb_serial_driver * const serial_drivers[] = {
1035 &pl2303_device, NULL
1038 module_usb_serial_driver(serial_drivers, id_table);
1040 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1041 MODULE_LICENSE("GPL");