1 // SPDX-License-Identifier: GPL-2.0
3 * Prolific PL2303 USB to serial adaptor driver
5 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2003 IBM Corp.
8 * Original driver for 2.2.x by anonymous
10 * See Documentation/usb/usb-serial.txt for more information on using this
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/tty.h>
18 #include <linux/tty_driver.h>
19 #include <linux/tty_flip.h>
20 #include <linux/serial.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/spinlock.h>
24 #include <linux/uaccess.h>
25 #include <linux/usb.h>
26 #include <linux/usb/serial.h>
27 #include <asm/unaligned.h>
31 #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
32 #define PL2303_QUIRK_LEGACY BIT(1)
33 #define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
35 static const struct usb_device_id id_table
[] = {
36 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID
),
37 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
38 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_RSAQ2
) },
39 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_DCU11
) },
40 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_RSAQ3
) },
41 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_CHILITAG
) },
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 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
53 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_UC485
),
54 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
55 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_UC232B
),
56 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
57 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_ID2
) },
58 { USB_DEVICE(ATEN_VENDOR_ID2
, ATEN_PRODUCT_ID
) },
59 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID
) },
60 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID_UCSGT
) },
61 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID
) },
62 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID_2080
) },
63 { USB_DEVICE(MA620_VENDOR_ID
, MA620_PRODUCT_ID
) },
64 { USB_DEVICE(RATOC_VENDOR_ID
, RATOC_PRODUCT_ID
) },
65 { USB_DEVICE(TRIPP_VENDOR_ID
, TRIPP_PRODUCT_ID
) },
66 { USB_DEVICE(RADIOSHACK_VENDOR_ID
, RADIOSHACK_PRODUCT_ID
) },
67 { USB_DEVICE(DCU10_VENDOR_ID
, DCU10_PRODUCT_ID
) },
68 { USB_DEVICE(SITECOM_VENDOR_ID
, SITECOM_PRODUCT_ID
) },
69 { USB_DEVICE(ALCATEL_VENDOR_ID
, ALCATEL_PRODUCT_ID
) },
70 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_SX1
),
71 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
72 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X65
),
73 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
74 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X75
),
75 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
76 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_EF81
),
77 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
78 { USB_DEVICE(BENQ_VENDOR_ID
, BENQ_PRODUCT_ID_S81
) }, /* Benq/Siemens S81 */
79 { USB_DEVICE(SYNTECH_VENDOR_ID
, SYNTECH_PRODUCT_ID
) },
80 { USB_DEVICE(NOKIA_CA42_VENDOR_ID
, NOKIA_CA42_PRODUCT_ID
) },
81 { USB_DEVICE(CA_42_CA42_VENDOR_ID
, CA_42_CA42_PRODUCT_ID
) },
82 { USB_DEVICE(SAGEM_VENDOR_ID
, SAGEM_PRODUCT_ID
) },
83 { USB_DEVICE(LEADTEK_VENDOR_ID
, LEADTEK_9531_PRODUCT_ID
) },
84 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID
, SPEEDDRAGON_PRODUCT_ID
) },
85 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID
, DATAPILOT_U2_PRODUCT_ID
) },
86 { USB_DEVICE(BELKIN_VENDOR_ID
, BELKIN_PRODUCT_ID
) },
87 { USB_DEVICE(ALCOR_VENDOR_ID
, ALCOR_PRODUCT_ID
),
88 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
89 { USB_DEVICE(WS002IN_VENDOR_ID
, WS002IN_PRODUCT_ID
) },
90 { USB_DEVICE(COREGA_VENDOR_ID
, COREGA_PRODUCT_ID
) },
91 { USB_DEVICE(YCCABLE_VENDOR_ID
, YCCABLE_PRODUCT_ID
) },
92 { USB_DEVICE(SUPERIAL_VENDOR_ID
, SUPERIAL_PRODUCT_ID
) },
93 { USB_DEVICE(HP_VENDOR_ID
, HP_LD220_PRODUCT_ID
) },
94 { USB_DEVICE(HP_VENDOR_ID
, HP_LD960_PRODUCT_ID
) },
95 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM220_PRODUCT_ID
) },
96 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM960_PRODUCT_ID
) },
97 { USB_DEVICE(CRESSI_VENDOR_ID
, CRESSI_EDY_PRODUCT_ID
) },
98 { USB_DEVICE(ZEAGLE_VENDOR_ID
, ZEAGLE_N2ITION3_PRODUCT_ID
) },
99 { USB_DEVICE(SONY_VENDOR_ID
, SONY_QN3USB_PRODUCT_ID
) },
100 { USB_DEVICE(SANWA_VENDOR_ID
, SANWA_PRODUCT_ID
) },
101 { USB_DEVICE(ADLINK_VENDOR_ID
, ADLINK_ND6530_PRODUCT_ID
) },
102 { USB_DEVICE(SMART_VENDOR_ID
, SMART_PRODUCT_ID
) },
103 { } /* Terminating entry */
106 MODULE_DEVICE_TABLE(usb
, id_table
);
108 #define SET_LINE_REQUEST_TYPE 0x21
109 #define SET_LINE_REQUEST 0x20
111 #define SET_CONTROL_REQUEST_TYPE 0x21
112 #define SET_CONTROL_REQUEST 0x22
113 #define CONTROL_DTR 0x01
114 #define CONTROL_RTS 0x02
116 #define BREAK_REQUEST_TYPE 0x21
117 #define BREAK_REQUEST 0x23
118 #define BREAK_ON 0xffff
119 #define BREAK_OFF 0x0000
121 #define GET_LINE_REQUEST_TYPE 0xa1
122 #define GET_LINE_REQUEST 0x21
124 #define VENDOR_WRITE_REQUEST_TYPE 0x40
125 #define VENDOR_WRITE_REQUEST 0x01
127 #define VENDOR_READ_REQUEST_TYPE 0xc0
128 #define VENDOR_READ_REQUEST 0x01
130 #define UART_STATE_INDEX 8
131 #define UART_STATE_MSR_MASK 0x8b
132 #define UART_STATE_TRANSIENT_MASK 0x74
133 #define UART_DCD 0x01
134 #define UART_DSR 0x02
135 #define UART_BREAK_ERROR 0x04
136 #define UART_RING 0x08
137 #define UART_FRAME_ERROR 0x10
138 #define UART_PARITY_ERROR 0x20
139 #define UART_OVERRUN_ERROR 0x40
140 #define UART_CTS 0x80
142 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
);
145 TYPE_01
, /* Type 0 and 1 (difference unknown) */
146 TYPE_HX
, /* HX version of the pl2303 chip */
150 struct pl2303_type_data
{
151 speed_t max_baud_rate
;
152 unsigned long quirks
;
155 struct pl2303_serial_private
{
156 const struct pl2303_type_data
*type
;
157 unsigned long quirks
;
160 struct pl2303_private
{
168 static const struct pl2303_type_data pl2303_type_data
[TYPE_COUNT
] = {
170 .max_baud_rate
= 1228800,
171 .quirks
= PL2303_QUIRK_LEGACY
,
174 .max_baud_rate
= 12000000,
178 static int pl2303_vendor_read(struct usb_serial
*serial
, u16 value
,
179 unsigned char buf
[1])
181 struct device
*dev
= &serial
->interface
->dev
;
184 res
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
185 VENDOR_READ_REQUEST
, VENDOR_READ_REQUEST_TYPE
,
186 value
, 0, buf
, 1, 100);
188 dev_err(dev
, "%s - failed to read [%04x]: %d\n", __func__
,
196 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, buf
[0]);
201 static int pl2303_vendor_write(struct usb_serial
*serial
, u16 value
, u16 index
)
203 struct device
*dev
= &serial
->interface
->dev
;
206 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, index
);
208 res
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
209 VENDOR_WRITE_REQUEST
, VENDOR_WRITE_REQUEST_TYPE
,
210 value
, index
, NULL
, 0, 100);
212 dev_err(dev
, "%s - failed to write [%04x]: %d\n", __func__
,
220 static int pl2303_probe(struct usb_serial
*serial
,
221 const struct usb_device_id
*id
)
223 usb_set_serial_data(serial
, (void *)id
->driver_info
);
229 * Use interrupt endpoint from first interface if available.
231 * This is needed due to the looney way its endpoints are set up.
233 static int pl2303_endpoint_hack(struct usb_serial
*serial
,
234 struct usb_serial_endpoints
*epds
)
236 struct usb_interface
*interface
= serial
->interface
;
237 struct usb_device
*dev
= serial
->dev
;
238 struct device
*ddev
= &interface
->dev
;
239 struct usb_host_interface
*iface_desc
;
240 struct usb_endpoint_descriptor
*endpoint
;
243 if (interface
== dev
->actconfig
->interface
[0])
246 /* check out the endpoints of the other interface */
247 iface_desc
= dev
->actconfig
->interface
[0]->cur_altsetting
;
249 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
250 endpoint
= &iface_desc
->endpoint
[i
].desc
;
252 if (!usb_endpoint_is_int_in(endpoint
))
255 dev_dbg(ddev
, "found interrupt in on separate interface\n");
256 if (epds
->num_interrupt_in
< ARRAY_SIZE(epds
->interrupt_in
))
257 epds
->interrupt_in
[epds
->num_interrupt_in
++] = endpoint
;
263 static int pl2303_calc_num_ports(struct usb_serial
*serial
,
264 struct usb_serial_endpoints
*epds
)
266 unsigned long quirks
= (unsigned long)usb_get_serial_data(serial
);
267 struct device
*dev
= &serial
->interface
->dev
;
270 if (quirks
& PL2303_QUIRK_ENDPOINT_HACK
) {
271 ret
= pl2303_endpoint_hack(serial
, epds
);
276 if (epds
->num_interrupt_in
< 1) {
277 dev_err(dev
, "required interrupt-in endpoint missing\n");
284 static int pl2303_startup(struct usb_serial
*serial
)
286 struct pl2303_serial_private
*spriv
;
287 enum pl2303_type type
= TYPE_01
;
290 spriv
= kzalloc(sizeof(*spriv
), GFP_KERNEL
);
294 buf
= kmalloc(1, GFP_KERNEL
);
300 if (serial
->dev
->descriptor
.bDeviceClass
== 0x02)
301 type
= TYPE_01
; /* type 0 */
302 else if (serial
->dev
->descriptor
.bMaxPacketSize0
== 0x40)
304 else if (serial
->dev
->descriptor
.bDeviceClass
== 0x00)
305 type
= TYPE_01
; /* type 1 */
306 else if (serial
->dev
->descriptor
.bDeviceClass
== 0xFF)
307 type
= TYPE_01
; /* type 1 */
308 dev_dbg(&serial
->interface
->dev
, "device type: %d\n", type
);
310 spriv
->type
= &pl2303_type_data
[type
];
311 spriv
->quirks
= (unsigned long)usb_get_serial_data(serial
);
312 spriv
->quirks
|= spriv
->type
->quirks
;
314 usb_set_serial_data(serial
, spriv
);
316 pl2303_vendor_read(serial
, 0x8484, buf
);
317 pl2303_vendor_write(serial
, 0x0404, 0);
318 pl2303_vendor_read(serial
, 0x8484, buf
);
319 pl2303_vendor_read(serial
, 0x8383, buf
);
320 pl2303_vendor_read(serial
, 0x8484, buf
);
321 pl2303_vendor_write(serial
, 0x0404, 1);
322 pl2303_vendor_read(serial
, 0x8484, buf
);
323 pl2303_vendor_read(serial
, 0x8383, buf
);
324 pl2303_vendor_write(serial
, 0, 1);
325 pl2303_vendor_write(serial
, 1, 0);
326 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
327 pl2303_vendor_write(serial
, 2, 0x24);
329 pl2303_vendor_write(serial
, 2, 0x44);
336 static void pl2303_release(struct usb_serial
*serial
)
338 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
343 static int pl2303_port_probe(struct usb_serial_port
*port
)
345 struct pl2303_private
*priv
;
347 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
351 spin_lock_init(&priv
->lock
);
353 usb_set_serial_port_data(port
, priv
);
355 port
->port
.drain_delay
= 256;
360 static int pl2303_port_remove(struct usb_serial_port
*port
)
362 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
369 static int pl2303_set_control_lines(struct usb_serial_port
*port
, u8 value
)
371 struct usb_device
*dev
= port
->serial
->dev
;
374 dev_dbg(&port
->dev
, "%s - %02x\n", __func__
, value
);
376 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
377 SET_CONTROL_REQUEST
, SET_CONTROL_REQUEST_TYPE
,
378 value
, 0, NULL
, 0, 100);
380 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, retval
);
386 * Returns the nearest supported baud rate that can be set directly without
389 static speed_t
pl2303_get_supported_baud_rate(speed_t baud
)
391 static const speed_t baud_sup
[] = {
392 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
393 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
394 614400, 921600, 1228800, 2457600, 3000000, 6000000
399 for (i
= 0; i
< ARRAY_SIZE(baud_sup
); ++i
) {
400 if (baud_sup
[i
] > baud
)
404 if (i
== ARRAY_SIZE(baud_sup
))
405 baud
= baud_sup
[i
- 1];
406 else if (i
> 0 && (baud_sup
[i
] - baud
) > (baud
- baud_sup
[i
- 1]))
407 baud
= baud_sup
[i
- 1];
415 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
418 static speed_t
pl2303_encode_baud_rate_direct(unsigned char buf
[4],
421 put_unaligned_le32(baud
, buf
);
426 static speed_t
pl2303_encode_baud_rate_divisor(unsigned char buf
[4],
429 unsigned int baseline
, mantissa
, exponent
;
432 * Apparently the formula is:
433 * baudrate = 12M * 32 / (mantissa * 4^exponent)
435 * mantissa = buf[8:0]
436 * exponent = buf[11:9]
438 baseline
= 12000000 * 32;
439 mantissa
= baseline
/ baud
;
441 mantissa
= 1; /* Avoid dividing by zero if baud > 32*12M. */
443 while (mantissa
>= 512) {
445 mantissa
>>= 2; /* divide by 4 */
448 /* Exponent is maxed. Trim mantissa and leave. */
456 buf
[1] = exponent
<< 1 | mantissa
>> 8;
457 buf
[0] = mantissa
& 0xff;
459 /* Calculate and return the exact baud rate. */
460 baud
= (baseline
/ mantissa
) >> (exponent
<< 1);
465 static void pl2303_encode_baud_rate(struct tty_struct
*tty
,
466 struct usb_serial_port
*port
,
469 struct usb_serial
*serial
= port
->serial
;
470 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
474 baud
= tty_get_baud_rate(tty
);
475 dev_dbg(&port
->dev
, "baud requested = %u\n", baud
);
479 if (spriv
->type
->max_baud_rate
)
480 baud
= min_t(speed_t
, baud
, spriv
->type
->max_baud_rate
);
482 * Use direct method for supported baud rates, otherwise use divisors.
484 baud_sup
= pl2303_get_supported_baud_rate(baud
);
486 if (baud
== baud_sup
)
487 baud
= pl2303_encode_baud_rate_direct(buf
, baud
);
489 baud
= pl2303_encode_baud_rate_divisor(buf
, baud
);
491 /* Save resulting baud rate */
492 tty_encode_baud_rate(tty
, baud
, baud
);
493 dev_dbg(&port
->dev
, "baud set = %u\n", baud
);
496 static int pl2303_get_line_request(struct usb_serial_port
*port
,
497 unsigned char buf
[7])
499 struct usb_device
*udev
= port
->serial
->dev
;
502 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
503 GET_LINE_REQUEST
, GET_LINE_REQUEST_TYPE
,
506 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
514 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
519 static int pl2303_set_line_request(struct usb_serial_port
*port
,
520 unsigned char buf
[7])
522 struct usb_device
*udev
= port
->serial
->dev
;
525 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
526 SET_LINE_REQUEST
, SET_LINE_REQUEST_TYPE
,
529 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
533 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
538 static bool pl2303_termios_change(const struct ktermios
*a
, const struct ktermios
*b
)
542 ixon_change
= ((a
->c_iflag
^ b
->c_iflag
) & (IXON
| IXANY
)) ||
543 a
->c_cc
[VSTART
] != b
->c_cc
[VSTART
] ||
544 a
->c_cc
[VSTOP
] != b
->c_cc
[VSTOP
];
546 return tty_termios_hw_change(a
, b
) || ixon_change
;
549 static void pl2303_set_termios(struct tty_struct
*tty
,
550 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
552 struct usb_serial
*serial
= port
->serial
;
553 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
554 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
560 if (old_termios
&& !pl2303_termios_change(&tty
->termios
, old_termios
))
563 buf
= kzalloc(7, GFP_KERNEL
);
565 /* Report back no change occurred */
567 tty
->termios
= *old_termios
;
571 pl2303_get_line_request(port
, buf
);
573 switch (C_CSIZE(tty
)) {
587 dev_dbg(&port
->dev
, "data bits = %d\n", buf
[6]);
589 /* For reference buf[0]:buf[3] baud rate value */
590 pl2303_encode_baud_rate(tty
, port
, &buf
[0]);
592 /* For reference buf[4]=0 is 1 stop bits */
593 /* For reference buf[4]=1 is 1.5 stop bits */
594 /* For reference buf[4]=2 is 2 stop bits */
597 * NOTE: Comply with "real" UARTs / RS232:
598 * use 1.5 instead of 2 stop bits with 5 data bits
600 if (C_CSIZE(tty
) == CS5
) {
602 dev_dbg(&port
->dev
, "stop bits = 1.5\n");
605 dev_dbg(&port
->dev
, "stop bits = 2\n");
609 dev_dbg(&port
->dev
, "stop bits = 1\n");
613 /* For reference buf[5]=0 is none parity */
614 /* For reference buf[5]=1 is odd parity */
615 /* For reference buf[5]=2 is even parity */
616 /* For reference buf[5]=3 is mark parity */
617 /* For reference buf[5]=4 is space parity */
621 dev_dbg(&port
->dev
, "parity = mark\n");
624 dev_dbg(&port
->dev
, "parity = odd\n");
629 dev_dbg(&port
->dev
, "parity = space\n");
632 dev_dbg(&port
->dev
, "parity = even\n");
637 dev_dbg(&port
->dev
, "parity = none\n");
641 * Some PL2303 are known to lose bytes if you change serial settings
642 * even to the same values as before. Thus we actually need to filter
643 * in this specific case.
645 * Note that the tty_termios_hw_change check above is not sufficient
646 * as a previously requested baud rate may differ from the one
647 * actually used (and stored in old_termios).
649 * NOTE: No additional locking needed for line_settings as it is
650 * only used in set_termios, which is serialised against itself.
652 if (!old_termios
|| memcmp(buf
, priv
->line_settings
, 7)) {
653 ret
= pl2303_set_line_request(port
, buf
);
655 memcpy(priv
->line_settings
, buf
, 7);
658 /* change control lines if we are switching to or from B0 */
659 spin_lock_irqsave(&priv
->lock
, flags
);
660 control
= priv
->line_control
;
661 if (C_BAUD(tty
) == B0
)
662 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
663 else if (old_termios
&& (old_termios
->c_cflag
& CBAUD
) == B0
)
664 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
665 if (control
!= priv
->line_control
) {
666 control
= priv
->line_control
;
667 spin_unlock_irqrestore(&priv
->lock
, flags
);
668 pl2303_set_control_lines(port
, control
);
670 spin_unlock_irqrestore(&priv
->lock
, flags
);
673 if (C_CRTSCTS(tty
)) {
674 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
675 pl2303_vendor_write(serial
, 0x0, 0x41);
677 pl2303_vendor_write(serial
, 0x0, 0x61);
678 } else if (I_IXON(tty
) && !I_IXANY(tty
) && START_CHAR(tty
) == 0x11 &&
679 STOP_CHAR(tty
) == 0x13) {
680 pl2303_vendor_write(serial
, 0x0, 0xc0);
682 pl2303_vendor_write(serial
, 0x0, 0x0);
688 static void pl2303_dtr_rts(struct usb_serial_port
*port
, int on
)
690 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
694 spin_lock_irqsave(&priv
->lock
, flags
);
696 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
698 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
699 control
= priv
->line_control
;
700 spin_unlock_irqrestore(&priv
->lock
, flags
);
702 pl2303_set_control_lines(port
, control
);
705 static void pl2303_close(struct usb_serial_port
*port
)
707 usb_serial_generic_close(port
);
708 usb_kill_urb(port
->interrupt_in_urb
);
709 pl2303_set_break(port
, false);
712 static int pl2303_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
714 struct usb_serial
*serial
= port
->serial
;
715 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
718 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
) {
719 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
720 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
722 /* reset upstream data pipes */
723 pl2303_vendor_write(serial
, 8, 0);
724 pl2303_vendor_write(serial
, 9, 0);
729 pl2303_set_termios(tty
, port
, NULL
);
731 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
733 dev_err(&port
->dev
, "failed to submit interrupt urb: %d\n",
738 result
= usb_serial_generic_open(tty
, port
);
740 usb_kill_urb(port
->interrupt_in_urb
);
747 static int pl2303_tiocmset(struct tty_struct
*tty
,
748 unsigned int set
, unsigned int clear
)
750 struct usb_serial_port
*port
= tty
->driver_data
;
751 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
756 spin_lock_irqsave(&priv
->lock
, flags
);
758 priv
->line_control
|= CONTROL_RTS
;
760 priv
->line_control
|= CONTROL_DTR
;
761 if (clear
& TIOCM_RTS
)
762 priv
->line_control
&= ~CONTROL_RTS
;
763 if (clear
& TIOCM_DTR
)
764 priv
->line_control
&= ~CONTROL_DTR
;
765 control
= priv
->line_control
;
766 spin_unlock_irqrestore(&priv
->lock
, flags
);
768 ret
= pl2303_set_control_lines(port
, control
);
770 return usb_translate_errors(ret
);
775 static int pl2303_tiocmget(struct tty_struct
*tty
)
777 struct usb_serial_port
*port
= tty
->driver_data
;
778 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
784 spin_lock_irqsave(&priv
->lock
, flags
);
785 mcr
= priv
->line_control
;
786 status
= priv
->line_status
;
787 spin_unlock_irqrestore(&priv
->lock
, flags
);
789 result
= ((mcr
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
790 | ((mcr
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
791 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
792 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
793 | ((status
& UART_RING
) ? TIOCM_RI
: 0)
794 | ((status
& UART_DCD
) ? TIOCM_CD
: 0);
796 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
801 static int pl2303_carrier_raised(struct usb_serial_port
*port
)
803 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
805 if (priv
->line_status
& UART_DCD
)
811 static int pl2303_ioctl(struct tty_struct
*tty
,
812 unsigned int cmd
, unsigned long arg
)
814 struct serial_struct ser
;
815 struct usb_serial_port
*port
= tty
->driver_data
;
819 memset(&ser
, 0, sizeof ser
);
820 ser
.type
= PORT_16654
;
821 ser
.line
= port
->minor
;
822 ser
.port
= port
->port_number
;
823 ser
.baud_base
= 460800;
825 if (copy_to_user((void __user
*)arg
, &ser
, sizeof ser
))
836 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
)
838 struct usb_serial
*serial
= port
->serial
;
847 dev_dbg(&port
->dev
, "%s - turning break %s\n", __func__
,
848 state
== BREAK_OFF
? "off" : "on");
850 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
851 BREAK_REQUEST
, BREAK_REQUEST_TYPE
, state
,
854 dev_err(&port
->dev
, "error sending break = %d\n", result
);
857 static void pl2303_break_ctl(struct tty_struct
*tty
, int state
)
859 struct usb_serial_port
*port
= tty
->driver_data
;
861 pl2303_set_break(port
, state
);
864 static void pl2303_update_line_status(struct usb_serial_port
*port
,
866 unsigned int actual_length
)
868 struct usb_serial
*serial
= port
->serial
;
869 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
870 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
871 struct tty_struct
*tty
;
873 unsigned int status_idx
= UART_STATE_INDEX
;
877 if (spriv
->quirks
& PL2303_QUIRK_UART_STATE_IDX0
)
880 if (actual_length
< status_idx
+ 1)
883 status
= data
[status_idx
];
885 /* Save off the uart status for others to look at */
886 spin_lock_irqsave(&priv
->lock
, flags
);
887 delta
= priv
->line_status
^ status
;
888 priv
->line_status
= status
;
889 spin_unlock_irqrestore(&priv
->lock
, flags
);
891 if (status
& UART_BREAK_ERROR
)
892 usb_serial_handle_break(port
);
894 if (delta
& UART_STATE_MSR_MASK
) {
895 if (delta
& UART_CTS
)
897 if (delta
& UART_DSR
)
899 if (delta
& UART_RING
)
901 if (delta
& UART_DCD
) {
903 tty
= tty_port_tty_get(&port
->port
);
905 usb_serial_handle_dcd_change(port
, tty
,
911 wake_up_interruptible(&port
->port
.delta_msr_wait
);
915 static void pl2303_read_int_callback(struct urb
*urb
)
917 struct usb_serial_port
*port
= urb
->context
;
918 unsigned char *data
= urb
->transfer_buffer
;
919 unsigned int actual_length
= urb
->actual_length
;
920 int status
= urb
->status
;
930 /* this urb is terminated, clean up */
931 dev_dbg(&port
->dev
, "%s - urb shutting down with status: %d\n",
935 dev_dbg(&port
->dev
, "%s - nonzero urb status received: %d\n",
940 usb_serial_debug_data(&port
->dev
, __func__
,
941 urb
->actual_length
, urb
->transfer_buffer
);
943 pl2303_update_line_status(port
, data
, actual_length
);
946 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
949 "%s - usb_submit_urb failed with result %d\n",
954 static void pl2303_process_read_urb(struct urb
*urb
)
956 struct usb_serial_port
*port
= urb
->context
;
957 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
958 unsigned char *data
= urb
->transfer_buffer
;
959 char tty_flag
= TTY_NORMAL
;
964 /* update line status */
965 spin_lock_irqsave(&priv
->lock
, flags
);
966 line_status
= priv
->line_status
;
967 priv
->line_status
&= ~UART_STATE_TRANSIENT_MASK
;
968 spin_unlock_irqrestore(&priv
->lock
, flags
);
970 if (!urb
->actual_length
)
974 * Break takes precedence over parity, which takes precedence over
977 if (line_status
& UART_BREAK_ERROR
)
978 tty_flag
= TTY_BREAK
;
979 else if (line_status
& UART_PARITY_ERROR
)
980 tty_flag
= TTY_PARITY
;
981 else if (line_status
& UART_FRAME_ERROR
)
982 tty_flag
= TTY_FRAME
;
984 if (tty_flag
!= TTY_NORMAL
)
985 dev_dbg(&port
->dev
, "%s - tty_flag = %d\n", __func__
,
987 /* overrun is special, not associated with a char */
988 if (line_status
& UART_OVERRUN_ERROR
)
989 tty_insert_flip_char(&port
->port
, 0, TTY_OVERRUN
);
991 if (port
->port
.console
&& port
->sysrq
) {
992 for (i
= 0; i
< urb
->actual_length
; ++i
)
993 if (!usb_serial_handle_sysrq_char(port
, data
[i
]))
994 tty_insert_flip_char(&port
->port
, data
[i
],
997 tty_insert_flip_string_fixed_flag(&port
->port
, data
, tty_flag
,
1001 tty_flip_buffer_push(&port
->port
);
1004 static struct usb_serial_driver pl2303_device
= {
1006 .owner
= THIS_MODULE
,
1009 .id_table
= id_table
,
1012 .num_interrupt_in
= 0, /* see pl2303_calc_num_ports */
1013 .bulk_in_size
= 256,
1014 .bulk_out_size
= 256,
1015 .open
= pl2303_open
,
1016 .close
= pl2303_close
,
1017 .dtr_rts
= pl2303_dtr_rts
,
1018 .carrier_raised
= pl2303_carrier_raised
,
1019 .ioctl
= pl2303_ioctl
,
1020 .break_ctl
= pl2303_break_ctl
,
1021 .set_termios
= pl2303_set_termios
,
1022 .tiocmget
= pl2303_tiocmget
,
1023 .tiocmset
= pl2303_tiocmset
,
1024 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
1025 .process_read_urb
= pl2303_process_read_urb
,
1026 .read_int_callback
= pl2303_read_int_callback
,
1027 .probe
= pl2303_probe
,
1028 .calc_num_ports
= pl2303_calc_num_ports
,
1029 .attach
= pl2303_startup
,
1030 .release
= pl2303_release
,
1031 .port_probe
= pl2303_port_probe
,
1032 .port_remove
= pl2303_port_remove
,
1035 static struct usb_serial_driver
* const serial_drivers
[] = {
1036 &pl2303_device
, NULL
1039 module_usb_serial_driver(serial_drivers
, id_table
);
1041 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1042 MODULE_LICENSE("GPL v2");