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(SAMSUNG_VENDOR_ID
, SAMSUNG_PRODUCT_ID
) },
65 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_SX1
),
66 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
67 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X65
),
68 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
69 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X75
),
70 .driver_info
= PL2303_QUIRK_UART_STATE_IDX0
},
71 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_EF81
) },
72 { USB_DEVICE(BENQ_VENDOR_ID
, BENQ_PRODUCT_ID_S81
) }, /* Benq/Siemens S81 */
73 { USB_DEVICE(SYNTECH_VENDOR_ID
, SYNTECH_PRODUCT_ID
) },
74 { USB_DEVICE(NOKIA_CA42_VENDOR_ID
, NOKIA_CA42_PRODUCT_ID
) },
75 { USB_DEVICE(CA_42_CA42_VENDOR_ID
, CA_42_CA42_PRODUCT_ID
) },
76 { USB_DEVICE(SAGEM_VENDOR_ID
, SAGEM_PRODUCT_ID
) },
77 { USB_DEVICE(LEADTEK_VENDOR_ID
, LEADTEK_9531_PRODUCT_ID
) },
78 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID
, SPEEDDRAGON_PRODUCT_ID
) },
79 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID
, DATAPILOT_U2_PRODUCT_ID
) },
80 { USB_DEVICE(BELKIN_VENDOR_ID
, BELKIN_PRODUCT_ID
) },
81 { USB_DEVICE(ALCOR_VENDOR_ID
, ALCOR_PRODUCT_ID
) },
82 { USB_DEVICE(WS002IN_VENDOR_ID
, WS002IN_PRODUCT_ID
) },
83 { USB_DEVICE(COREGA_VENDOR_ID
, COREGA_PRODUCT_ID
) },
84 { USB_DEVICE(YCCABLE_VENDOR_ID
, YCCABLE_PRODUCT_ID
) },
85 { USB_DEVICE(SUPERIAL_VENDOR_ID
, SUPERIAL_PRODUCT_ID
) },
86 { USB_DEVICE(HP_VENDOR_ID
, HP_LD220_PRODUCT_ID
) },
87 { USB_DEVICE(HP_VENDOR_ID
, HP_LD960_PRODUCT_ID
) },
88 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM220_PRODUCT_ID
) },
89 { USB_DEVICE(HP_VENDOR_ID
, HP_LCM960_PRODUCT_ID
) },
90 { USB_DEVICE(CRESSI_VENDOR_ID
, CRESSI_EDY_PRODUCT_ID
) },
91 { USB_DEVICE(ZEAGLE_VENDOR_ID
, ZEAGLE_N2ITION3_PRODUCT_ID
) },
92 { USB_DEVICE(SONY_VENDOR_ID
, SONY_QN3USB_PRODUCT_ID
) },
93 { USB_DEVICE(SANWA_VENDOR_ID
, SANWA_PRODUCT_ID
) },
94 { USB_DEVICE(ADLINK_VENDOR_ID
, ADLINK_ND6530_PRODUCT_ID
) },
95 { USB_DEVICE(SMART_VENDOR_ID
, SMART_PRODUCT_ID
) },
96 { } /* Terminating entry */
99 MODULE_DEVICE_TABLE(usb
, id_table
);
101 #define SET_LINE_REQUEST_TYPE 0x21
102 #define SET_LINE_REQUEST 0x20
104 #define SET_CONTROL_REQUEST_TYPE 0x21
105 #define SET_CONTROL_REQUEST 0x22
106 #define CONTROL_DTR 0x01
107 #define CONTROL_RTS 0x02
109 #define BREAK_REQUEST_TYPE 0x21
110 #define BREAK_REQUEST 0x23
111 #define BREAK_ON 0xffff
112 #define BREAK_OFF 0x0000
114 #define GET_LINE_REQUEST_TYPE 0xa1
115 #define GET_LINE_REQUEST 0x21
117 #define VENDOR_WRITE_REQUEST_TYPE 0x40
118 #define VENDOR_WRITE_REQUEST 0x01
120 #define VENDOR_READ_REQUEST_TYPE 0xc0
121 #define VENDOR_READ_REQUEST 0x01
123 #define UART_STATE_INDEX 8
124 #define UART_STATE_MSR_MASK 0x8b
125 #define UART_STATE_TRANSIENT_MASK 0x74
126 #define UART_DCD 0x01
127 #define UART_DSR 0x02
128 #define UART_BREAK_ERROR 0x04
129 #define UART_RING 0x08
130 #define UART_FRAME_ERROR 0x10
131 #define UART_PARITY_ERROR 0x20
132 #define UART_OVERRUN_ERROR 0x40
133 #define UART_CTS 0x80
135 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
);
138 TYPE_01
, /* Type 0 and 1 (difference unknown) */
139 TYPE_HX
, /* HX version of the pl2303 chip */
143 struct pl2303_type_data
{
144 speed_t max_baud_rate
;
145 unsigned long quirks
;
148 struct pl2303_serial_private
{
149 const struct pl2303_type_data
*type
;
150 unsigned long quirks
;
153 struct pl2303_private
{
161 static const struct pl2303_type_data pl2303_type_data
[TYPE_COUNT
] = {
163 .max_baud_rate
= 1228800,
164 .quirks
= PL2303_QUIRK_LEGACY
,
167 .max_baud_rate
= 12000000,
171 static int pl2303_vendor_read(struct usb_serial
*serial
, u16 value
,
172 unsigned char buf
[1])
174 struct device
*dev
= &serial
->interface
->dev
;
177 res
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
178 VENDOR_READ_REQUEST
, VENDOR_READ_REQUEST_TYPE
,
179 value
, 0, buf
, 1, 100);
181 dev_err(dev
, "%s - failed to read [%04x]: %d\n", __func__
,
189 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, buf
[0]);
194 static int pl2303_vendor_write(struct usb_serial
*serial
, u16 value
, u16 index
)
196 struct device
*dev
= &serial
->interface
->dev
;
199 dev_dbg(dev
, "%s - [%04x] = %02x\n", __func__
, value
, index
);
201 res
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
202 VENDOR_WRITE_REQUEST
, VENDOR_WRITE_REQUEST_TYPE
,
203 value
, index
, NULL
, 0, 100);
205 dev_err(dev
, "%s - failed to write [%04x]: %d\n", __func__
,
213 static int pl2303_probe(struct usb_serial
*serial
,
214 const struct usb_device_id
*id
)
216 usb_set_serial_data(serial
, (void *)id
->driver_info
);
221 static int pl2303_startup(struct usb_serial
*serial
)
223 struct pl2303_serial_private
*spriv
;
224 enum pl2303_type type
= TYPE_01
;
227 spriv
= kzalloc(sizeof(*spriv
), GFP_KERNEL
);
231 buf
= kmalloc(1, GFP_KERNEL
);
237 if (serial
->dev
->descriptor
.bDeviceClass
== 0x02)
238 type
= TYPE_01
; /* type 0 */
239 else if (serial
->dev
->descriptor
.bMaxPacketSize0
== 0x40)
241 else if (serial
->dev
->descriptor
.bDeviceClass
== 0x00)
242 type
= TYPE_01
; /* type 1 */
243 else if (serial
->dev
->descriptor
.bDeviceClass
== 0xFF)
244 type
= TYPE_01
; /* type 1 */
245 dev_dbg(&serial
->interface
->dev
, "device type: %d\n", type
);
247 spriv
->type
= &pl2303_type_data
[type
];
248 spriv
->quirks
= (unsigned long)usb_get_serial_data(serial
);
249 spriv
->quirks
|= spriv
->type
->quirks
;
251 usb_set_serial_data(serial
, spriv
);
253 pl2303_vendor_read(serial
, 0x8484, buf
);
254 pl2303_vendor_write(serial
, 0x0404, 0);
255 pl2303_vendor_read(serial
, 0x8484, buf
);
256 pl2303_vendor_read(serial
, 0x8383, buf
);
257 pl2303_vendor_read(serial
, 0x8484, buf
);
258 pl2303_vendor_write(serial
, 0x0404, 1);
259 pl2303_vendor_read(serial
, 0x8484, buf
);
260 pl2303_vendor_read(serial
, 0x8383, buf
);
261 pl2303_vendor_write(serial
, 0, 1);
262 pl2303_vendor_write(serial
, 1, 0);
263 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
264 pl2303_vendor_write(serial
, 2, 0x24);
266 pl2303_vendor_write(serial
, 2, 0x44);
273 static void pl2303_release(struct usb_serial
*serial
)
275 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
280 static int pl2303_port_probe(struct usb_serial_port
*port
)
282 struct pl2303_private
*priv
;
284 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
288 spin_lock_init(&priv
->lock
);
290 usb_set_serial_port_data(port
, priv
);
292 port
->port
.drain_delay
= 256;
297 static int pl2303_port_remove(struct usb_serial_port
*port
)
299 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
306 static int pl2303_set_control_lines(struct usb_serial_port
*port
, u8 value
)
308 struct usb_device
*dev
= port
->serial
->dev
;
311 dev_dbg(&port
->dev
, "%s - %02x\n", __func__
, value
);
313 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
314 SET_CONTROL_REQUEST
, SET_CONTROL_REQUEST_TYPE
,
315 value
, 0, NULL
, 0, 100);
317 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, retval
);
323 * Returns the nearest supported baud rate that can be set directly without
326 static speed_t
pl2303_get_supported_baud_rate(speed_t baud
)
328 static const speed_t baud_sup
[] = {
329 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
330 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
331 614400, 921600, 1228800, 2457600, 3000000, 6000000
336 for (i
= 0; i
< ARRAY_SIZE(baud_sup
); ++i
) {
337 if (baud_sup
[i
] > baud
)
341 if (i
== ARRAY_SIZE(baud_sup
))
342 baud
= baud_sup
[i
- 1];
343 else if (i
> 0 && (baud_sup
[i
] - baud
) > (baud
- baud_sup
[i
- 1]))
344 baud
= baud_sup
[i
- 1];
352 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
355 static speed_t
pl2303_encode_baud_rate_direct(unsigned char buf
[4],
358 put_unaligned_le32(baud
, buf
);
363 static speed_t
pl2303_encode_baud_rate_divisor(unsigned char buf
[4],
369 * Apparently the formula is:
370 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
372 tmp
= 12000000 * 32 / baud
;
375 buf
[1] = (tmp
>= 256);
385 static void pl2303_encode_baud_rate(struct tty_struct
*tty
,
386 struct usb_serial_port
*port
,
389 struct usb_serial
*serial
= port
->serial
;
390 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
394 baud
= tty_get_baud_rate(tty
);
395 dev_dbg(&port
->dev
, "baud requested = %u\n", baud
);
399 if (spriv
->type
->max_baud_rate
)
400 baud
= min_t(speed_t
, baud
, spriv
->type
->max_baud_rate
);
402 * Use direct method for supported baud rates, otherwise use divisors.
404 baud_sup
= pl2303_get_supported_baud_rate(baud
);
406 if (baud
== baud_sup
)
407 baud
= pl2303_encode_baud_rate_direct(buf
, baud
);
409 baud
= pl2303_encode_baud_rate_divisor(buf
, baud
);
411 /* Save resulting baud rate */
412 tty_encode_baud_rate(tty
, baud
, baud
);
413 dev_dbg(&port
->dev
, "baud set = %u\n", baud
);
416 static int pl2303_get_line_request(struct usb_serial_port
*port
,
417 unsigned char buf
[7])
419 struct usb_device
*udev
= port
->serial
->dev
;
422 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
423 GET_LINE_REQUEST
, GET_LINE_REQUEST_TYPE
,
426 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
434 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
439 static int pl2303_set_line_request(struct usb_serial_port
*port
,
440 unsigned char buf
[7])
442 struct usb_device
*udev
= port
->serial
->dev
;
445 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
446 SET_LINE_REQUEST
, SET_LINE_REQUEST_TYPE
,
449 dev_err(&port
->dev
, "%s - failed: %d\n", __func__
, ret
);
457 dev_dbg(&port
->dev
, "%s - %7ph\n", __func__
, buf
);
462 static void pl2303_set_termios(struct tty_struct
*tty
,
463 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
465 struct usb_serial
*serial
= port
->serial
;
466 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
467 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
473 if (old_termios
&& !tty_termios_hw_change(&tty
->termios
, old_termios
))
476 buf
= kzalloc(7, GFP_KERNEL
);
478 /* Report back no change occurred */
480 tty
->termios
= *old_termios
;
484 pl2303_get_line_request(port
, buf
);
486 switch (C_CSIZE(tty
)) {
500 dev_dbg(&port
->dev
, "data bits = %d\n", buf
[6]);
502 /* For reference buf[0]:buf[3] baud rate value */
503 pl2303_encode_baud_rate(tty
, port
, &buf
[0]);
505 /* For reference buf[4]=0 is 1 stop bits */
506 /* For reference buf[4]=1 is 1.5 stop bits */
507 /* For reference buf[4]=2 is 2 stop bits */
510 * NOTE: Comply with "real" UARTs / RS232:
511 * use 1.5 instead of 2 stop bits with 5 data bits
513 if (C_CSIZE(tty
) == CS5
) {
515 dev_dbg(&port
->dev
, "stop bits = 1.5\n");
518 dev_dbg(&port
->dev
, "stop bits = 2\n");
522 dev_dbg(&port
->dev
, "stop bits = 1\n");
526 /* For reference buf[5]=0 is none parity */
527 /* For reference buf[5]=1 is odd parity */
528 /* For reference buf[5]=2 is even parity */
529 /* For reference buf[5]=3 is mark parity */
530 /* For reference buf[5]=4 is space parity */
534 dev_dbg(&port
->dev
, "parity = mark\n");
537 dev_dbg(&port
->dev
, "parity = odd\n");
542 dev_dbg(&port
->dev
, "parity = space\n");
545 dev_dbg(&port
->dev
, "parity = even\n");
550 dev_dbg(&port
->dev
, "parity = none\n");
554 * Some PL2303 are known to lose bytes if you change serial settings
555 * even to the same values as before. Thus we actually need to filter
556 * in this specific case.
558 * Note that the tty_termios_hw_change check above is not sufficient
559 * as a previously requested baud rate may differ from the one
560 * actually used (and stored in old_termios).
562 * NOTE: No additional locking needed for line_settings as it is
563 * only used in set_termios, which is serialised against itself.
565 if (!old_termios
|| memcmp(buf
, priv
->line_settings
, 7)) {
566 ret
= pl2303_set_line_request(port
, buf
);
568 memcpy(priv
->line_settings
, buf
, 7);
571 /* change control lines if we are switching to or from B0 */
572 spin_lock_irqsave(&priv
->lock
, flags
);
573 control
= priv
->line_control
;
574 if (C_BAUD(tty
) == B0
)
575 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
576 else if (old_termios
&& (old_termios
->c_cflag
& CBAUD
) == B0
)
577 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
578 if (control
!= priv
->line_control
) {
579 control
= priv
->line_control
;
580 spin_unlock_irqrestore(&priv
->lock
, flags
);
581 pl2303_set_control_lines(port
, control
);
583 spin_unlock_irqrestore(&priv
->lock
, flags
);
586 if (C_CRTSCTS(tty
)) {
587 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
)
588 pl2303_vendor_write(serial
, 0x0, 0x41);
590 pl2303_vendor_write(serial
, 0x0, 0x61);
592 pl2303_vendor_write(serial
, 0x0, 0x0);
598 static void pl2303_dtr_rts(struct usb_serial_port
*port
, int on
)
600 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
604 spin_lock_irqsave(&priv
->lock
, flags
);
606 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
608 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
609 control
= priv
->line_control
;
610 spin_unlock_irqrestore(&priv
->lock
, flags
);
612 pl2303_set_control_lines(port
, control
);
615 static void pl2303_close(struct usb_serial_port
*port
)
617 usb_serial_generic_close(port
);
618 usb_kill_urb(port
->interrupt_in_urb
);
619 pl2303_set_break(port
, false);
622 static int pl2303_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
624 struct usb_serial
*serial
= port
->serial
;
625 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
628 if (spriv
->quirks
& PL2303_QUIRK_LEGACY
) {
629 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
630 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
632 /* reset upstream data pipes */
633 pl2303_vendor_write(serial
, 8, 0);
634 pl2303_vendor_write(serial
, 9, 0);
639 pl2303_set_termios(tty
, port
, NULL
);
641 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
643 dev_err(&port
->dev
, "failed to submit interrupt urb: %d\n",
648 result
= usb_serial_generic_open(tty
, port
);
650 usb_kill_urb(port
->interrupt_in_urb
);
657 static int pl2303_tiocmset(struct tty_struct
*tty
,
658 unsigned int set
, unsigned int clear
)
660 struct usb_serial_port
*port
= tty
->driver_data
;
661 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
666 spin_lock_irqsave(&priv
->lock
, flags
);
668 priv
->line_control
|= CONTROL_RTS
;
670 priv
->line_control
|= CONTROL_DTR
;
671 if (clear
& TIOCM_RTS
)
672 priv
->line_control
&= ~CONTROL_RTS
;
673 if (clear
& TIOCM_DTR
)
674 priv
->line_control
&= ~CONTROL_DTR
;
675 control
= priv
->line_control
;
676 spin_unlock_irqrestore(&priv
->lock
, flags
);
678 ret
= pl2303_set_control_lines(port
, control
);
680 return usb_translate_errors(ret
);
685 static int pl2303_tiocmget(struct tty_struct
*tty
)
687 struct usb_serial_port
*port
= tty
->driver_data
;
688 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
694 spin_lock_irqsave(&priv
->lock
, flags
);
695 mcr
= priv
->line_control
;
696 status
= priv
->line_status
;
697 spin_unlock_irqrestore(&priv
->lock
, flags
);
699 result
= ((mcr
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
700 | ((mcr
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
701 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
702 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
703 | ((status
& UART_RING
) ? TIOCM_RI
: 0)
704 | ((status
& UART_DCD
) ? TIOCM_CD
: 0);
706 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
711 static int pl2303_carrier_raised(struct usb_serial_port
*port
)
713 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
715 if (priv
->line_status
& UART_DCD
)
721 static int pl2303_ioctl(struct tty_struct
*tty
,
722 unsigned int cmd
, unsigned long arg
)
724 struct serial_struct ser
;
725 struct usb_serial_port
*port
= tty
->driver_data
;
729 memset(&ser
, 0, sizeof ser
);
730 ser
.type
= PORT_16654
;
731 ser
.line
= port
->minor
;
732 ser
.port
= port
->port_number
;
733 ser
.baud_base
= 460800;
735 if (copy_to_user((void __user
*)arg
, &ser
, sizeof ser
))
746 static void pl2303_set_break(struct usb_serial_port
*port
, bool enable
)
748 struct usb_serial
*serial
= port
->serial
;
757 dev_dbg(&port
->dev
, "%s - turning break %s\n", __func__
,
758 state
== BREAK_OFF
? "off" : "on");
760 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
761 BREAK_REQUEST
, BREAK_REQUEST_TYPE
, state
,
764 dev_err(&port
->dev
, "error sending break = %d\n", result
);
767 static void pl2303_break_ctl(struct tty_struct
*tty
, int state
)
769 struct usb_serial_port
*port
= tty
->driver_data
;
771 pl2303_set_break(port
, state
);
774 static void pl2303_update_line_status(struct usb_serial_port
*port
,
776 unsigned int actual_length
)
778 struct usb_serial
*serial
= port
->serial
;
779 struct pl2303_serial_private
*spriv
= usb_get_serial_data(serial
);
780 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
781 struct tty_struct
*tty
;
783 unsigned int status_idx
= UART_STATE_INDEX
;
787 if (spriv
->quirks
& PL2303_QUIRK_UART_STATE_IDX0
)
790 if (actual_length
< status_idx
+ 1)
793 status
= data
[status_idx
];
795 /* Save off the uart status for others to look at */
796 spin_lock_irqsave(&priv
->lock
, flags
);
797 delta
= priv
->line_status
^ status
;
798 priv
->line_status
= status
;
799 spin_unlock_irqrestore(&priv
->lock
, flags
);
801 if (status
& UART_BREAK_ERROR
)
802 usb_serial_handle_break(port
);
804 if (delta
& UART_STATE_MSR_MASK
) {
805 if (delta
& UART_CTS
)
807 if (delta
& UART_DSR
)
809 if (delta
& UART_RING
)
811 if (delta
& UART_DCD
) {
813 tty
= tty_port_tty_get(&port
->port
);
815 usb_serial_handle_dcd_change(port
, tty
,
821 wake_up_interruptible(&port
->port
.delta_msr_wait
);
825 static void pl2303_read_int_callback(struct urb
*urb
)
827 struct usb_serial_port
*port
= urb
->context
;
828 unsigned char *data
= urb
->transfer_buffer
;
829 unsigned int actual_length
= urb
->actual_length
;
830 int status
= urb
->status
;
840 /* this urb is terminated, clean up */
841 dev_dbg(&port
->dev
, "%s - urb shutting down with status: %d\n",
845 dev_dbg(&port
->dev
, "%s - nonzero urb status received: %d\n",
850 usb_serial_debug_data(&port
->dev
, __func__
,
851 urb
->actual_length
, urb
->transfer_buffer
);
853 pl2303_update_line_status(port
, data
, actual_length
);
856 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
859 "%s - usb_submit_urb failed with result %d\n",
864 static void pl2303_process_read_urb(struct urb
*urb
)
866 struct usb_serial_port
*port
= urb
->context
;
867 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
868 unsigned char *data
= urb
->transfer_buffer
;
869 char tty_flag
= TTY_NORMAL
;
874 /* update line status */
875 spin_lock_irqsave(&priv
->lock
, flags
);
876 line_status
= priv
->line_status
;
877 priv
->line_status
&= ~UART_STATE_TRANSIENT_MASK
;
878 spin_unlock_irqrestore(&priv
->lock
, flags
);
880 if (!urb
->actual_length
)
884 * Break takes precedence over parity, which takes precedence over
887 if (line_status
& UART_BREAK_ERROR
)
888 tty_flag
= TTY_BREAK
;
889 else if (line_status
& UART_PARITY_ERROR
)
890 tty_flag
= TTY_PARITY
;
891 else if (line_status
& UART_FRAME_ERROR
)
892 tty_flag
= TTY_FRAME
;
894 if (tty_flag
!= TTY_NORMAL
)
895 dev_dbg(&port
->dev
, "%s - tty_flag = %d\n", __func__
,
897 /* overrun is special, not associated with a char */
898 if (line_status
& UART_OVERRUN_ERROR
)
899 tty_insert_flip_char(&port
->port
, 0, TTY_OVERRUN
);
901 if (port
->port
.console
&& port
->sysrq
) {
902 for (i
= 0; i
< urb
->actual_length
; ++i
)
903 if (!usb_serial_handle_sysrq_char(port
, data
[i
]))
904 tty_insert_flip_char(&port
->port
, data
[i
],
907 tty_insert_flip_string_fixed_flag(&port
->port
, data
, tty_flag
,
911 tty_flip_buffer_push(&port
->port
);
914 static struct usb_serial_driver pl2303_device
= {
916 .owner
= THIS_MODULE
,
919 .id_table
= id_table
,
922 .bulk_out_size
= 256,
924 .close
= pl2303_close
,
925 .dtr_rts
= pl2303_dtr_rts
,
926 .carrier_raised
= pl2303_carrier_raised
,
927 .ioctl
= pl2303_ioctl
,
928 .break_ctl
= pl2303_break_ctl
,
929 .set_termios
= pl2303_set_termios
,
930 .tiocmget
= pl2303_tiocmget
,
931 .tiocmset
= pl2303_tiocmset
,
932 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
933 .process_read_urb
= pl2303_process_read_urb
,
934 .read_int_callback
= pl2303_read_int_callback
,
935 .probe
= pl2303_probe
,
936 .attach
= pl2303_startup
,
937 .release
= pl2303_release
,
938 .port_probe
= pl2303_port_probe
,
939 .port_remove
= pl2303_port_remove
,
942 static struct usb_serial_driver
* const serial_drivers
[] = {
946 module_usb_serial_driver(serial_drivers
, id_table
);
948 MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
949 MODULE_LICENSE("GPL");