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_PHAROS
) },
42 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_ALDIGA
) },
43 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_MMX
) },
44 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_GPRS
) },
45 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_HCR331
) },
46 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_MOTOROLA
) },
47 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_ZTEK
) },
48 { USB_DEVICE(IODATA_VENDOR_ID
, IODATA_PRODUCT_ID
) },
49 { USB_DEVICE(IODATA_VENDOR_ID
, IODATA_PRODUCT_ID_RSAQ5
) },
50 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_ID
),
51 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
52 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_UC485
),
53 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
54 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_ID2
) },
55 { USB_DEVICE(ATEN_VENDOR_ID2
, ATEN_PRODUCT_ID
) },
56 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID
) },
57 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID_UCSGT
) },
58 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID
) },
59 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID_2080
) },
60 { USB_DEVICE(MA620_VENDOR_ID
, MA620_PRODUCT_ID
) },
61 { USB_DEVICE(RATOC_VENDOR_ID
, RATOC_PRODUCT_ID
) },
62 { USB_DEVICE(TRIPP_VENDOR_ID
, TRIPP_PRODUCT_ID
) },
63 { USB_DEVICE(RADIOSHACK_VENDOR_ID
, RADIOSHACK_PRODUCT_ID
) },
64 { USB_DEVICE(DCU10_VENDOR_ID
, DCU10_PRODUCT_ID
) },
65 { USB_DEVICE(SITECOM_VENDOR_ID
, SITECOM_PRODUCT_ID
) },
66 { USB_DEVICE(ALCATEL_VENDOR_ID
, ALCATEL_PRODUCT_ID
) },
67 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_SX1
),
68 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
69 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X65
),
70 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
71 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X75
),
72 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
73 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_EF81
),
74 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
75 { USB_DEVICE(BENQ_VENDOR_ID
, BENQ_PRODUCT_ID_S81
) }, /* Benq/Siemens S81 */
76 { USB_DEVICE(SYNTECH_VENDOR_ID
, SYNTECH_PRODUCT_ID
) },
77 { USB_DEVICE(NOKIA_CA42_VENDOR_ID
, NOKIA_CA42_PRODUCT_ID
) },
78 { USB_DEVICE(CA_42_CA42_VENDOR_ID
, CA_42_CA42_PRODUCT_ID
) },
79 { USB_DEVICE(SAGEM_VENDOR_ID
, SAGEM_PRODUCT_ID
) },
80 { USB_DEVICE(LEADTEK_VENDOR_ID
, LEADTEK_9531_PRODUCT_ID
) },
81 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID
, SPEEDDRAGON_PRODUCT_ID
) },
82 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID
, DATAPILOT_U2_PRODUCT_ID
) },
83 { USB_DEVICE(BELKIN_VENDOR_ID
, BELKIN_PRODUCT_ID
) },
84 { USB_DEVICE(ALCOR_VENDOR_ID
, ALCOR_PRODUCT_ID
),
85 .driver_info
= PL2303_QUIRK_ENDPOINT_HACK
},
86 { USB_DEVICE(WS002IN_VENDOR_ID
, WS002IN_PRODUCT_ID
) },
87 { USB_DEVICE(COREGA_VENDOR_ID
, COREGA_PRODUCT_ID
) },
88 { USB_DEVICE(YCCABLE_VENDOR_ID
, YCCABLE_PRODUCT_ID
) },
89 { USB_DEVICE(SUPERIAL_VENDOR_ID
, SUPERIAL_PRODUCT_ID
) },
90 { USB_DEVICE(HP_VENDOR_ID
, HP_LD220_PRODUCT_ID
) },
91 { USB_DEVICE(HP_VENDOR_ID
, HP_LD960_PRODUCT_ID
) },
92 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM220_PRODUCT_ID
) },
93 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM960_PRODUCT_ID
) },
94 { USB_DEVICE(CRESSI_VENDOR_ID
, CRESSI_EDY_PRODUCT_ID
) },
95 { USB_DEVICE(ZEAGLE_VENDOR_ID
, ZEAGLE_N2ITION3_PRODUCT_ID
) },
96 { USB_DEVICE(SONY_VENDOR_ID
, SONY_QN3USB_PRODUCT_ID
) },
97 { USB_DEVICE(SANWA_VENDOR_ID
, SANWA_PRODUCT_ID
) },
98 { USB_DEVICE(ADLINK_VENDOR_ID
, ADLINK_ND6530_PRODUCT_ID
) },
99 { USB_DEVICE(SMART_VENDOR_ID
, SMART_PRODUCT_ID
) },
100 { } /* Terminating entry */
103 MODULE_DEVICE_TABLE(usb
, id_table
);
105 #define SET_LINE_REQUEST_TYPE 0x21
106 #define SET_LINE_REQUEST 0x20
108 #define SET_CONTROL_REQUEST_TYPE 0x21
109 #define SET_CONTROL_REQUEST 0x22
110 #define CONTROL_DTR 0x01
111 #define CONTROL_RTS 0x02
113 #define BREAK_REQUEST_TYPE 0x21
114 #define BREAK_REQUEST 0x23
115 #define BREAK_ON 0xffff
116 #define BREAK_OFF 0x0000
118 #define GET_LINE_REQUEST_TYPE 0xa1
119 #define GET_LINE_REQUEST 0x21
121 #define VENDOR_WRITE_REQUEST_TYPE 0x40
122 #define VENDOR_WRITE_REQUEST 0x01
124 #define VENDOR_READ_REQUEST_TYPE 0xc0
125 #define VENDOR_READ_REQUEST 0x01
127 #define UART_STATE_INDEX 8
128 #define UART_STATE_MSR_MASK 0x8b
129 #define UART_STATE_TRANSIENT_MASK 0x74
130 #define UART_DCD 0x01
131 #define UART_DSR 0x02
132 #define UART_BREAK_ERROR 0x04
133 #define UART_RING 0x08
134 #define UART_FRAME_ERROR 0x10
135 #define UART_PARITY_ERROR 0x20
136 #define UART_OVERRUN_ERROR 0x40
137 #define UART_CTS 0x80
139 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
);
142 TYPE_01
, /* Type 0 and 1 (difference unknown) */
143 TYPE_HX
, /* HX version of the pl2303 chip */
147 struct pl2303_type_data
{
148 speed_t max_baud_rate
;
149 unsigned long quirks
;
152 struct pl2303_serial_private
{
153 const struct pl2303_type_data
*type
;
154 unsigned long quirks
;
157 struct pl2303_private
{
165 static const struct pl2303_type_data pl2303_type_data
[TYPE_COUNT
] = {
167 .max_baud_rate
= 1228800,
168 .quirks
= PL2303_QUIRK_LEGACY
,
171 .max_baud_rate
= 12000000,
175 static int pl2303_vendor_read(struct usb_serial
*serial
, u16 value
,
176 unsigned char buf
[1])
178 struct device
*dev
= &serial
->interface
->dev
;
181 res
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
182 VENDOR_READ_REQUEST
, VENDOR_READ_REQUEST_TYPE
,
183 value
, 0, buf
, 1, 100);
185 dev_err(dev
, "%s - failed to read [%04x]: %d\n", __func__
,
193 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, buf
[0]);
198 static int pl2303_vendor_write(struct usb_serial
*serial
, u16 value
, u16 index
)
200 struct device
*dev
= &serial
->interface
->dev
;
203 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, index
);
205 res
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
206 VENDOR_WRITE_REQUEST
, VENDOR_WRITE_REQUEST_TYPE
,
207 value
, index
, NULL
, 0, 100);
209 dev_err(dev
, "%s - failed to write [%04x]: %d\n", __func__
,
217 static int pl2303_probe(struct usb_serial
*serial
,
218 const struct usb_device_id
*id
)
220 usb_set_serial_data(serial
, (void *)id
->driver_info
);
226 * Use interrupt endpoint from first interface if available.
228 * This is needed due to the looney way its endpoints are set up.
230 static int pl2303_endpoint_hack(struct usb_serial
*serial
,
231 struct usb_serial_endpoints
*epds
)
233 struct usb_interface
*interface
= serial
->interface
;
234 struct usb_device
*dev
= serial
->dev
;
235 struct device
*ddev
= &interface
->dev
;
236 struct usb_host_interface
*iface_desc
;
237 struct usb_endpoint_descriptor
*endpoint
;
240 if (interface
== dev
->actconfig
->interface
[0])
243 /* check out the endpoints of the other interface */
244 iface_desc
= dev
->actconfig
->interface
[0]->cur_altsetting
;
246 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
247 endpoint
= &iface_desc
->endpoint
[i
].desc
;
249 if (!usb_endpoint_is_int_in(endpoint
))
252 dev_dbg(ddev
, "found interrupt in on separate interface\n");
253 if (epds
->num_interrupt_in
< ARRAY_SIZE(epds
->interrupt_in
))
254 epds
->interrupt_in
[epds
->num_interrupt_in
++] = endpoint
;
260 static int pl2303_calc_num_ports(struct usb_serial
*serial
,
261 struct usb_serial_endpoints
*epds
)
263 unsigned long quirks
= (unsigned long)usb_get_serial_data(serial
);
264 struct device
*dev
= &serial
->interface
->dev
;
267 if (quirks
& PL2303_QUIRK_ENDPOINT_HACK
) {
268 ret
= pl2303_endpoint_hack(serial
, epds
);
273 if (epds
->num_interrupt_in
< 1) {
274 dev_err(dev
, "required interrupt-in endpoint missing\n");
281 static int pl2303_startup(struct usb_serial
*serial
)
283 struct pl2303_serial_private
*spriv
;
284 enum pl2303_type type
= TYPE_01
;
287 spriv
= kzalloc(sizeof(*spriv
), GFP_KERNEL
);
291 buf
= kmalloc(1, GFP_KERNEL
);
297 if (serial
->dev
->descriptor
.bDeviceClass
== 0x02)
298 type
= TYPE_01
; /* type 0 */
299 else if (serial
->dev
->descriptor
.bMaxPacketSize0
== 0x40)
301 else if (serial
->dev
->descriptor
.bDeviceClass
== 0x00)
302 type
= TYPE_01
; /* type 1 */
303 else if (serial
->dev
->descriptor
.bDeviceClass
== 0xFF)
304 type
= TYPE_01
; /* type 1 */
305 dev_dbg(&serial
->interface
->dev
, "device type: %d\n", type
);
307 spriv
->type
= &pl2303_type_data
[type
];
308 spriv
->quirks
= (unsigned long)usb_get_serial_data(serial
);
309 spriv
->quirks
|= spriv
->type
->quirks
;
311 usb_set_serial_data(serial
, spriv
);
313 pl2303_vendor_read(serial
, 0x8484, buf
);
314 pl2303_vendor_write(serial
, 0x0404, 0);
315 pl2303_vendor_read(serial
, 0x8484, buf
);
316 pl2303_vendor_read(serial
, 0x8383, buf
);
317 pl2303_vendor_read(serial
, 0x8484, buf
);
318 pl2303_vendor_write(serial
, 0x0404, 1);
319 pl2303_vendor_read(serial
, 0x8484, buf
);
320 pl2303_vendor_read(serial
, 0x8383, buf
);
321 pl2303_vendor_write(serial
, 0, 1);
322 pl2303_vendor_write(serial
, 1, 0);
323 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
324 pl2303_vendor_write(serial
, 2, 0x24);
326 pl2303_vendor_write(serial
, 2, 0x44);
333 static void pl2303_release(struct usb_serial
*serial
)
335 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
340 static int pl2303_port_probe(struct usb_serial_port
*port
)
342 struct pl2303_private
*priv
;
344 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
348 spin_lock_init(&priv
->lock
);
350 usb_set_serial_port_data(port
, priv
);
352 port
->port
.drain_delay
= 256;
357 static int pl2303_port_remove(struct usb_serial_port
*port
)
359 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
366 static int pl2303_set_control_lines(struct usb_serial_port
*port
, u8 value
)
368 struct usb_device
*dev
= port
->serial
->dev
;
371 dev_dbg(&port
->dev
, "%s - %02x\n", __func__
, value
);
373 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
374 SET_CONTROL_REQUEST
, SET_CONTROL_REQUEST_TYPE
,
375 value
, 0, NULL
, 0, 100);
377 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, retval
);
383 * Returns the nearest supported baud rate that can be set directly without
386 static speed_t
pl2303_get_supported_baud_rate(speed_t baud
)
388 static const speed_t baud_sup
[] = {
389 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
390 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
391 614400, 921600, 1228800, 2457600, 3000000, 6000000
396 for (i
= 0; i
< ARRAY_SIZE(baud_sup
); ++i
) {
397 if (baud_sup
[i
] > baud
)
401 if (i
== ARRAY_SIZE(baud_sup
))
402 baud
= baud_sup
[i
- 1];
403 else if (i
> 0 && (baud_sup
[i
] - baud
) > (baud
- baud_sup
[i
- 1]))
404 baud
= baud_sup
[i
- 1];
412 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
415 static speed_t
pl2303_encode_baud_rate_direct(unsigned char buf
[4],
418 put_unaligned_le32(baud
, buf
);
423 static speed_t
pl2303_encode_baud_rate_divisor(unsigned char buf
[4],
426 unsigned int baseline
, mantissa
, exponent
;
429 * Apparently the formula is:
430 * baudrate = 12M * 32 / (mantissa * 4^exponent)
432 * mantissa = buf[8:0]
433 * exponent = buf[11:9]
435 baseline
= 12000000 * 32;
436 mantissa
= baseline
/ baud
;
438 mantissa
= 1; /* Avoid dividing by zero if baud > 32*12M. */
440 while (mantissa
>= 512) {
442 mantissa
>>= 2; /* divide by 4 */
445 /* Exponent is maxed. Trim mantissa and leave. */
453 buf
[1] = exponent
<< 1 | mantissa
>> 8;
454 buf
[0] = mantissa
& 0xff;
456 /* Calculate and return the exact baud rate. */
457 baud
= (baseline
/ mantissa
) >> (exponent
<< 1);
462 static void pl2303_encode_baud_rate(struct tty_struct
*tty
,
463 struct usb_serial_port
*port
,
466 struct usb_serial
*serial
= port
->serial
;
467 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
471 baud
= tty_get_baud_rate(tty
);
472 dev_dbg(&port
->dev
, "baud requested = %u\n", baud
);
476 if (spriv
->type
->max_baud_rate
)
477 baud
= min_t(speed_t
, baud
, spriv
->type
->max_baud_rate
);
479 * Use direct method for supported baud rates, otherwise use divisors.
481 baud_sup
= pl2303_get_supported_baud_rate(baud
);
483 if (baud
== baud_sup
)
484 baud
= pl2303_encode_baud_rate_direct(buf
, baud
);
486 baud
= pl2303_encode_baud_rate_divisor(buf
, baud
);
488 /* Save resulting baud rate */
489 tty_encode_baud_rate(tty
, baud
, baud
);
490 dev_dbg(&port
->dev
, "baud set = %u\n", baud
);
493 static int pl2303_get_line_request(struct usb_serial_port
*port
,
494 unsigned char buf
[7])
496 struct usb_device
*udev
= port
->serial
->dev
;
499 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
500 GET_LINE_REQUEST
, GET_LINE_REQUEST_TYPE
,
503 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
511 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
516 static int pl2303_set_line_request(struct usb_serial_port
*port
,
517 unsigned char buf
[7])
519 struct usb_device
*udev
= port
->serial
->dev
;
522 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
523 SET_LINE_REQUEST
, SET_LINE_REQUEST_TYPE
,
526 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
530 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
535 static void pl2303_set_termios(struct tty_struct
*tty
,
536 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
538 struct usb_serial
*serial
= port
->serial
;
539 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
540 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
546 if (old_termios
&& !tty_termios_hw_change(&tty
->termios
, old_termios
))
549 buf
= kzalloc(7, GFP_KERNEL
);
551 /* Report back no change occurred */
553 tty
->termios
= *old_termios
;
557 pl2303_get_line_request(port
, buf
);
559 switch (C_CSIZE(tty
)) {
573 dev_dbg(&port
->dev
, "data bits = %d\n", buf
[6]);
575 /* For reference buf[0]:buf[3] baud rate value */
576 pl2303_encode_baud_rate(tty
, port
, &buf
[0]);
578 /* For reference buf[4]=0 is 1 stop bits */
579 /* For reference buf[4]=1 is 1.5 stop bits */
580 /* For reference buf[4]=2 is 2 stop bits */
583 * NOTE: Comply with "real" UARTs / RS232:
584 * use 1.5 instead of 2 stop bits with 5 data bits
586 if (C_CSIZE(tty
) == CS5
) {
588 dev_dbg(&port
->dev
, "stop bits = 1.5\n");
591 dev_dbg(&port
->dev
, "stop bits = 2\n");
595 dev_dbg(&port
->dev
, "stop bits = 1\n");
599 /* For reference buf[5]=0 is none parity */
600 /* For reference buf[5]=1 is odd parity */
601 /* For reference buf[5]=2 is even parity */
602 /* For reference buf[5]=3 is mark parity */
603 /* For reference buf[5]=4 is space parity */
607 dev_dbg(&port
->dev
, "parity = mark\n");
610 dev_dbg(&port
->dev
, "parity = odd\n");
615 dev_dbg(&port
->dev
, "parity = space\n");
618 dev_dbg(&port
->dev
, "parity = even\n");
623 dev_dbg(&port
->dev
, "parity = none\n");
627 * Some PL2303 are known to lose bytes if you change serial settings
628 * even to the same values as before. Thus we actually need to filter
629 * in this specific case.
631 * Note that the tty_termios_hw_change check above is not sufficient
632 * as a previously requested baud rate may differ from the one
633 * actually used (and stored in old_termios).
635 * NOTE: No additional locking needed for line_settings as it is
636 * only used in set_termios, which is serialised against itself.
638 if (!old_termios
|| memcmp(buf
, priv
->line_settings
, 7)) {
639 ret
= pl2303_set_line_request(port
, buf
);
641 memcpy(priv
->line_settings
, buf
, 7);
644 /* change control lines if we are switching to or from B0 */
645 spin_lock_irqsave(&priv
->lock
, flags
);
646 control
= priv
->line_control
;
647 if (C_BAUD(tty
) == B0
)
648 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
649 else if (old_termios
&& (old_termios
->c_cflag
& CBAUD
) == B0
)
650 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
651 if (control
!= priv
->line_control
) {
652 control
= priv
->line_control
;
653 spin_unlock_irqrestore(&priv
->lock
, flags
);
654 pl2303_set_control_lines(port
, control
);
656 spin_unlock_irqrestore(&priv
->lock
, flags
);
659 if (C_CRTSCTS(tty
)) {
660 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
661 pl2303_vendor_write(serial
, 0x0, 0x41);
663 pl2303_vendor_write(serial
, 0x0, 0x61);
665 pl2303_vendor_write(serial
, 0x0, 0x0);
671 static void pl2303_dtr_rts(struct usb_serial_port
*port
, int on
)
673 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
677 spin_lock_irqsave(&priv
->lock
, flags
);
679 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
681 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
682 control
= priv
->line_control
;
683 spin_unlock_irqrestore(&priv
->lock
, flags
);
685 pl2303_set_control_lines(port
, control
);
688 static void pl2303_close(struct usb_serial_port
*port
)
690 usb_serial_generic_close(port
);
691 usb_kill_urb(port
->interrupt_in_urb
);
692 pl2303_set_break(port
, false);
695 static int pl2303_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
697 struct usb_serial
*serial
= port
->serial
;
698 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
701 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
) {
702 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
703 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
705 /* reset upstream data pipes */
706 pl2303_vendor_write(serial
, 8, 0);
707 pl2303_vendor_write(serial
, 9, 0);
712 pl2303_set_termios(tty
, port
, NULL
);
714 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
716 dev_err(&port
->dev
, "failed to submit interrupt urb: %d\n",
721 result
= usb_serial_generic_open(tty
, port
);
723 usb_kill_urb(port
->interrupt_in_urb
);
730 static int pl2303_tiocmset(struct tty_struct
*tty
,
731 unsigned int set
, unsigned int clear
)
733 struct usb_serial_port
*port
= tty
->driver_data
;
734 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
739 spin_lock_irqsave(&priv
->lock
, flags
);
741 priv
->line_control
|= CONTROL_RTS
;
743 priv
->line_control
|= CONTROL_DTR
;
744 if (clear
& TIOCM_RTS
)
745 priv
->line_control
&= ~CONTROL_RTS
;
746 if (clear
& TIOCM_DTR
)
747 priv
->line_control
&= ~CONTROL_DTR
;
748 control
= priv
->line_control
;
749 spin_unlock_irqrestore(&priv
->lock
, flags
);
751 ret
= pl2303_set_control_lines(port
, control
);
753 return usb_translate_errors(ret
);
758 static int pl2303_tiocmget(struct tty_struct
*tty
)
760 struct usb_serial_port
*port
= tty
->driver_data
;
761 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
767 spin_lock_irqsave(&priv
->lock
, flags
);
768 mcr
= priv
->line_control
;
769 status
= priv
->line_status
;
770 spin_unlock_irqrestore(&priv
->lock
, flags
);
772 result
= ((mcr
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
773 | ((mcr
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
774 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
775 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
776 | ((status
& UART_RING
) ? TIOCM_RI
: 0)
777 | ((status
& UART_DCD
) ? TIOCM_CD
: 0);
779 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
784 static int pl2303_carrier_raised(struct usb_serial_port
*port
)
786 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
788 if (priv
->line_status
& UART_DCD
)
794 static int pl2303_ioctl(struct tty_struct
*tty
,
795 unsigned int cmd
, unsigned long arg
)
797 struct serial_struct ser
;
798 struct usb_serial_port
*port
= tty
->driver_data
;
802 memset(&ser
, 0, sizeof ser
);
803 ser
.type
= PORT_16654
;
804 ser
.line
= port
->minor
;
805 ser
.port
= port
->port_number
;
806 ser
.baud_base
= 460800;
808 if (copy_to_user((void __user
*)arg
, &ser
, sizeof ser
))
819 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
)
821 struct usb_serial
*serial
= port
->serial
;
830 dev_dbg(&port
->dev
, "%s - turning break %s\n", __func__
,
831 state
== BREAK_OFF
? "off" : "on");
833 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
834 BREAK_REQUEST
, BREAK_REQUEST_TYPE
, state
,
837 dev_err(&port
->dev
, "error sending break = %d\n", result
);
840 static void pl2303_break_ctl(struct tty_struct
*tty
, int state
)
842 struct usb_serial_port
*port
= tty
->driver_data
;
844 pl2303_set_break(port
, state
);
847 static void pl2303_update_line_status(struct usb_serial_port
*port
,
849 unsigned int actual_length
)
851 struct usb_serial
*serial
= port
->serial
;
852 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
853 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
854 struct tty_struct
*tty
;
856 unsigned int status_idx
= UART_STATE_INDEX
;
860 if (spriv
->quirks
& PL2303_QUIRK_UART_STATE_IDX0
)
863 if (actual_length
< status_idx
+ 1)
866 status
= data
[status_idx
];
868 /* Save off the uart status for others to look at */
869 spin_lock_irqsave(&priv
->lock
, flags
);
870 delta
= priv
->line_status
^ status
;
871 priv
->line_status
= status
;
872 spin_unlock_irqrestore(&priv
->lock
, flags
);
874 if (status
& UART_BREAK_ERROR
)
875 usb_serial_handle_break(port
);
877 if (delta
& UART_STATE_MSR_MASK
) {
878 if (delta
& UART_CTS
)
880 if (delta
& UART_DSR
)
882 if (delta
& UART_RING
)
884 if (delta
& UART_DCD
) {
886 tty
= tty_port_tty_get(&port
->port
);
888 usb_serial_handle_dcd_change(port
, tty
,
894 wake_up_interruptible(&port
->port
.delta_msr_wait
);
898 static void pl2303_read_int_callback(struct urb
*urb
)
900 struct usb_serial_port
*port
= urb
->context
;
901 unsigned char *data
= urb
->transfer_buffer
;
902 unsigned int actual_length
= urb
->actual_length
;
903 int status
= urb
->status
;
913 /* this urb is terminated, clean up */
914 dev_dbg(&port
->dev
, "%s - urb shutting down with status: %d\n",
918 dev_dbg(&port
->dev
, "%s - nonzero urb status received: %d\n",
923 usb_serial_debug_data(&port
->dev
, __func__
,
924 urb
->actual_length
, urb
->transfer_buffer
);
926 pl2303_update_line_status(port
, data
, actual_length
);
929 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
932 "%s - usb_submit_urb failed with result %d\n",
937 static void pl2303_process_read_urb(struct urb
*urb
)
939 struct usb_serial_port
*port
= urb
->context
;
940 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
941 unsigned char *data
= urb
->transfer_buffer
;
942 char tty_flag
= TTY_NORMAL
;
947 /* update line status */
948 spin_lock_irqsave(&priv
->lock
, flags
);
949 line_status
= priv
->line_status
;
950 priv
->line_status
&= ~UART_STATE_TRANSIENT_MASK
;
951 spin_unlock_irqrestore(&priv
->lock
, flags
);
953 if (!urb
->actual_length
)
957 * Break takes precedence over parity, which takes precedence over
960 if (line_status
& UART_BREAK_ERROR
)
961 tty_flag
= TTY_BREAK
;
962 else if (line_status
& UART_PARITY_ERROR
)
963 tty_flag
= TTY_PARITY
;
964 else if (line_status
& UART_FRAME_ERROR
)
965 tty_flag
= TTY_FRAME
;
967 if (tty_flag
!= TTY_NORMAL
)
968 dev_dbg(&port
->dev
, "%s - tty_flag = %d\n", __func__
,
970 /* overrun is special, not associated with a char */
971 if (line_status
& UART_OVERRUN_ERROR
)
972 tty_insert_flip_char(&port
->port
, 0, TTY_OVERRUN
);
974 if (port
->port
.console
&& port
->sysrq
) {
975 for (i
= 0; i
< urb
->actual_length
; ++i
)
976 if (!usb_serial_handle_sysrq_char(port
, data
[i
]))
977 tty_insert_flip_char(&port
->port
, data
[i
],
980 tty_insert_flip_string_fixed_flag(&port
->port
, data
, tty_flag
,
984 tty_flip_buffer_push(&port
->port
);
987 static struct usb_serial_driver pl2303_device
= {
989 .owner
= THIS_MODULE
,
992 .id_table
= id_table
,
995 .num_interrupt_in
= 0, /* see pl2303_calc_num_ports */
997 .bulk_out_size
= 256,
999 .close
= pl2303_close
,
1000 .dtr_rts
= pl2303_dtr_rts
,
1001 .carrier_raised
= pl2303_carrier_raised
,
1002 .ioctl
= pl2303_ioctl
,
1003 .break_ctl
= pl2303_break_ctl
,
1004 .set_termios
= pl2303_set_termios
,
1005 .tiocmget
= pl2303_tiocmget
,
1006 .tiocmset
= pl2303_tiocmset
,
1007 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
1008 .process_read_urb
= pl2303_process_read_urb
,
1009 .read_int_callback
= pl2303_read_int_callback
,
1010 .probe
= pl2303_probe
,
1011 .calc_num_ports
= pl2303_calc_num_ports
,
1012 .attach
= pl2303_startup
,
1013 .release
= pl2303_release
,
1014 .port_probe
= pl2303_port_probe
,
1015 .port_remove
= pl2303_port_remove
,
1018 static struct usb_serial_driver
* const serial_drivers
[] = {
1019 &pl2303_device
, NULL
1022 module_usb_serial_driver(serial_drivers
, id_table
);
1024 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1025 MODULE_LICENSE("GPL v2");