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
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/tty.h>
23 #include <linux/tty_driver.h>
24 #include <linux/tty_flip.h>
25 #include <linux/serial.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/spinlock.h>
29 #include <linux/uaccess.h>
30 #include <linux/usb.h>
31 #include <linux/usb/serial.h>
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
41 #define PL2303_CLOSING_WAIT (30*HZ)
43 #define PL2303_BUF_SIZE 1024
44 #define PL2303_TMP_BUF_SIZE 1024
47 unsigned int buf_size
;
53 static const struct usb_device_id id_table
[] = {
54 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID
) },
55 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_RSAQ2
) },
56 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_DCU11
) },
57 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_RSAQ3
) },
58 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_PHAROS
) },
59 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_ALDIGA
) },
60 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_MMX
) },
61 { USB_DEVICE(PL2303_VENDOR_ID
, PL2303_PRODUCT_ID_GPRS
) },
62 { USB_DEVICE(IODATA_VENDOR_ID
, IODATA_PRODUCT_ID
) },
63 { USB_DEVICE(IODATA_VENDOR_ID
, IODATA_PRODUCT_ID_RSAQ5
) },
64 { USB_DEVICE(ATEN_VENDOR_ID
, ATEN_PRODUCT_ID
) },
65 { USB_DEVICE(ATEN_VENDOR_ID2
, ATEN_PRODUCT_ID
) },
66 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID
) },
67 { USB_DEVICE(ELCOM_VENDOR_ID
, ELCOM_PRODUCT_ID_UCSGT
) },
68 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID
) },
69 { USB_DEVICE(ITEGNO_VENDOR_ID
, ITEGNO_PRODUCT_ID_2080
) },
70 { USB_DEVICE(MA620_VENDOR_ID
, MA620_PRODUCT_ID
) },
71 { USB_DEVICE(RATOC_VENDOR_ID
, RATOC_PRODUCT_ID
) },
72 { USB_DEVICE(TRIPP_VENDOR_ID
, TRIPP_PRODUCT_ID
) },
73 { USB_DEVICE(RADIOSHACK_VENDOR_ID
, RADIOSHACK_PRODUCT_ID
) },
74 { USB_DEVICE(DCU10_VENDOR_ID
, DCU10_PRODUCT_ID
) },
75 { USB_DEVICE(SITECOM_VENDOR_ID
, SITECOM_PRODUCT_ID
) },
76 { USB_DEVICE(ALCATEL_VENDOR_ID
, ALCATEL_PRODUCT_ID
) },
77 { USB_DEVICE(SAMSUNG_VENDOR_ID
, SAMSUNG_PRODUCT_ID
) },
78 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_SX1
) },
79 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X65
) },
80 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_X75
) },
81 { USB_DEVICE(SIEMENS_VENDOR_ID
, SIEMENS_PRODUCT_ID_EF81
) },
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 { USB_DEVICE(WS002IN_VENDOR_ID
, WS002IN_PRODUCT_ID
) },
93 { USB_DEVICE(COREGA_VENDOR_ID
, COREGA_PRODUCT_ID
) },
94 { USB_DEVICE(YCCABLE_VENDOR_ID
, YCCABLE_PRODUCT_ID
) },
95 { USB_DEVICE(SUPERIAL_VENDOR_ID
, SUPERIAL_PRODUCT_ID
) },
96 { USB_DEVICE(HP_VENDOR_ID
, HP_LD220_PRODUCT_ID
) },
97 { USB_DEVICE(CRESSI_VENDOR_ID
, CRESSI_EDY_PRODUCT_ID
) },
98 { USB_DEVICE(SONY_VENDOR_ID
, SONY_QN3USB_PRODUCT_ID
) },
99 { USB_DEVICE(SANWA_VENDOR_ID
, SANWA_PRODUCT_ID
) },
100 { } /* Terminating entry */
103 MODULE_DEVICE_TABLE(usb
, id_table
);
105 static struct usb_driver pl2303_driver
= {
107 .probe
= usb_serial_probe
,
108 .disconnect
= usb_serial_disconnect
,
109 .id_table
= id_table
,
110 .suspend
= usb_serial_suspend
,
111 .resume
= usb_serial_resume
,
113 .supports_autosuspend
= 1,
116 #define SET_LINE_REQUEST_TYPE 0x21
117 #define SET_LINE_REQUEST 0x20
119 #define SET_CONTROL_REQUEST_TYPE 0x21
120 #define SET_CONTROL_REQUEST 0x22
121 #define CONTROL_DTR 0x01
122 #define CONTROL_RTS 0x02
124 #define BREAK_REQUEST_TYPE 0x21
125 #define BREAK_REQUEST 0x23
126 #define BREAK_ON 0xffff
127 #define BREAK_OFF 0x0000
129 #define GET_LINE_REQUEST_TYPE 0xa1
130 #define GET_LINE_REQUEST 0x21
132 #define VENDOR_WRITE_REQUEST_TYPE 0x40
133 #define VENDOR_WRITE_REQUEST 0x01
135 #define VENDOR_READ_REQUEST_TYPE 0xc0
136 #define VENDOR_READ_REQUEST 0x01
138 #define UART_STATE 0x08
139 #define UART_STATE_TRANSIENT_MASK 0x74
140 #define UART_DCD 0x01
141 #define UART_DSR 0x02
142 #define UART_BREAK_ERROR 0x04
143 #define UART_RING 0x08
144 #define UART_FRAME_ERROR 0x10
145 #define UART_PARITY_ERROR 0x20
146 #define UART_OVERRUN_ERROR 0x40
147 #define UART_CTS 0x80
151 type_0
, /* don't know the difference between type 0 and */
152 type_1
, /* type 1, until someone from prolific tells us... */
153 HX
, /* HX version of the pl2303 chip */
156 struct pl2303_private
{
158 struct pl2303_buf
*buf
;
159 int write_urb_in_use
;
160 wait_queue_head_t delta_msr_wait
;
163 enum pl2303_type type
;
169 * Allocate a circular buffer and all associated memory.
171 static struct pl2303_buf
*pl2303_buf_alloc(unsigned int size
)
173 struct pl2303_buf
*pb
;
178 pb
= kmalloc(sizeof(struct pl2303_buf
), GFP_KERNEL
);
182 pb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
183 if (pb
->buf_buf
== NULL
) {
189 pb
->buf_get
= pb
->buf_put
= pb
->buf_buf
;
197 * Free the buffer and all associated memory.
199 static void pl2303_buf_free(struct pl2303_buf
*pb
)
210 * Clear out all data in the circular buffer.
212 static void pl2303_buf_clear(struct pl2303_buf
*pb
)
215 pb
->buf_get
= pb
->buf_put
;
216 /* equivalent to a get of all data available */
220 * pl2303_buf_data_avail
222 * Return the number of bytes of data available in the circular
225 static unsigned int pl2303_buf_data_avail(struct pl2303_buf
*pb
)
230 return (pb
->buf_size
+ pb
->buf_put
- pb
->buf_get
) % pb
->buf_size
;
234 * pl2303_buf_space_avail
236 * Return the number of bytes of space available in the circular
239 static unsigned int pl2303_buf_space_avail(struct pl2303_buf
*pb
)
244 return (pb
->buf_size
+ pb
->buf_get
- pb
->buf_put
- 1) % pb
->buf_size
;
250 * Copy data data from a user buffer and put it into the circular buffer.
251 * Restrict to the amount of space available.
253 * Return the number of bytes copied.
255 static unsigned int pl2303_buf_put(struct pl2303_buf
*pb
, const char *buf
,
263 len
= pl2303_buf_space_avail(pb
);
270 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_put
;
272 memcpy(pb
->buf_put
, buf
, len
);
273 memcpy(pb
->buf_buf
, buf
+len
, count
- len
);
274 pb
->buf_put
= pb
->buf_buf
+ count
- len
;
276 memcpy(pb
->buf_put
, buf
, count
);
278 pb
->buf_put
+= count
;
279 else /* count == len */
280 pb
->buf_put
= pb
->buf_buf
;
289 * Get data from the circular buffer and copy to the given buffer.
290 * Restrict to the amount of data available.
292 * Return the number of bytes copied.
294 static unsigned int pl2303_buf_get(struct pl2303_buf
*pb
, char *buf
,
302 len
= pl2303_buf_data_avail(pb
);
309 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_get
;
311 memcpy(buf
, pb
->buf_get
, len
);
312 memcpy(buf
+len
, pb
->buf_buf
, count
- len
);
313 pb
->buf_get
= pb
->buf_buf
+ count
- len
;
315 memcpy(buf
, pb
->buf_get
, count
);
317 pb
->buf_get
+= count
;
318 else /* count == len */
319 pb
->buf_get
= pb
->buf_buf
;
325 static int pl2303_vendor_read(__u16 value
, __u16 index
,
326 struct usb_serial
*serial
, unsigned char *buf
)
328 int res
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
329 VENDOR_READ_REQUEST
, VENDOR_READ_REQUEST_TYPE
,
330 value
, index
, buf
, 1, 100);
331 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE
,
332 VENDOR_READ_REQUEST
, value
, index
, res
, buf
[0]);
336 static int pl2303_vendor_write(__u16 value
, __u16 index
,
337 struct usb_serial
*serial
)
339 int res
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
340 VENDOR_WRITE_REQUEST
, VENDOR_WRITE_REQUEST_TYPE
,
341 value
, index
, NULL
, 0, 100);
342 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE
,
343 VENDOR_WRITE_REQUEST
, value
, index
, res
);
347 static int pl2303_startup(struct usb_serial
*serial
)
349 struct pl2303_private
*priv
;
350 enum pl2303_type type
= type_0
;
354 buf
= kmalloc(10, GFP_KERNEL
);
358 if (serial
->dev
->descriptor
.bDeviceClass
== 0x02)
360 else if (serial
->dev
->descriptor
.bMaxPacketSize0
== 0x40)
362 else if (serial
->dev
->descriptor
.bDeviceClass
== 0x00)
364 else if (serial
->dev
->descriptor
.bDeviceClass
== 0xFF)
366 dbg("device type: %d", type
);
368 for (i
= 0; i
< serial
->num_ports
; ++i
) {
369 priv
= kzalloc(sizeof(struct pl2303_private
), GFP_KERNEL
);
372 spin_lock_init(&priv
->lock
);
373 priv
->buf
= pl2303_buf_alloc(PL2303_BUF_SIZE
);
374 if (priv
->buf
== NULL
) {
378 init_waitqueue_head(&priv
->delta_msr_wait
);
380 usb_set_serial_port_data(serial
->port
[i
], priv
);
383 pl2303_vendor_read(0x8484, 0, serial
, buf
);
384 pl2303_vendor_write(0x0404, 0, serial
);
385 pl2303_vendor_read(0x8484, 0, serial
, buf
);
386 pl2303_vendor_read(0x8383, 0, serial
, buf
);
387 pl2303_vendor_read(0x8484, 0, serial
, buf
);
388 pl2303_vendor_write(0x0404, 1, serial
);
389 pl2303_vendor_read(0x8484, 0, serial
, buf
);
390 pl2303_vendor_read(0x8383, 0, serial
, buf
);
391 pl2303_vendor_write(0, 1, serial
);
392 pl2303_vendor_write(1, 0, serial
);
394 pl2303_vendor_write(2, 0x44, serial
);
396 pl2303_vendor_write(2, 0x24, serial
);
403 for (--i
; i
>= 0; --i
) {
404 priv
= usb_get_serial_port_data(serial
->port
[i
]);
405 pl2303_buf_free(priv
->buf
);
407 usb_set_serial_port_data(serial
->port
[i
], NULL
);
412 static int set_control_lines(struct usb_device
*dev
, u8 value
)
416 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
417 SET_CONTROL_REQUEST
, SET_CONTROL_REQUEST_TYPE
,
418 value
, 0, NULL
, 0, 100);
419 dbg("%s - value = %d, retval = %d", __func__
, value
, retval
);
423 static void pl2303_send(struct usb_serial_port
*port
)
426 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
429 dbg("%s - port %d", __func__
, port
->number
);
431 spin_lock_irqsave(&priv
->lock
, flags
);
433 if (priv
->write_urb_in_use
) {
434 spin_unlock_irqrestore(&priv
->lock
, flags
);
438 count
= pl2303_buf_get(priv
->buf
, port
->write_urb
->transfer_buffer
,
439 port
->bulk_out_size
);
442 spin_unlock_irqrestore(&priv
->lock
, flags
);
446 priv
->write_urb_in_use
= 1;
448 spin_unlock_irqrestore(&priv
->lock
, flags
);
450 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
,
451 port
->write_urb
->transfer_buffer
);
453 port
->write_urb
->transfer_buffer_length
= count
;
454 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
456 dev_err(&port
->dev
, "%s - failed submitting write urb,"
457 " error %d\n", __func__
, result
);
458 priv
->write_urb_in_use
= 0;
459 /* TODO: reschedule pl2303_send */
462 usb_serial_port_softint(port
);
465 static int pl2303_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
466 const unsigned char *buf
, int count
)
468 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
471 dbg("%s - port %d, %d bytes", __func__
, port
->number
, count
);
476 spin_lock_irqsave(&priv
->lock
, flags
);
477 count
= pl2303_buf_put(priv
->buf
, buf
, count
);
478 spin_unlock_irqrestore(&priv
->lock
, flags
);
485 static int pl2303_write_room(struct tty_struct
*tty
)
487 struct usb_serial_port
*port
= tty
->driver_data
;
488 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
492 dbg("%s - port %d", __func__
, port
->number
);
494 spin_lock_irqsave(&priv
->lock
, flags
);
495 room
= pl2303_buf_space_avail(priv
->buf
);
496 spin_unlock_irqrestore(&priv
->lock
, flags
);
498 dbg("%s - returns %d", __func__
, room
);
502 static int pl2303_chars_in_buffer(struct tty_struct
*tty
)
504 struct usb_serial_port
*port
= tty
->driver_data
;
505 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
509 dbg("%s - port %d", __func__
, port
->number
);
511 spin_lock_irqsave(&priv
->lock
, flags
);
512 chars
= pl2303_buf_data_avail(priv
->buf
);
513 spin_unlock_irqrestore(&priv
->lock
, flags
);
515 dbg("%s - returns %d", __func__
, chars
);
519 static void pl2303_set_termios(struct tty_struct
*tty
,
520 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
522 struct usb_serial
*serial
= port
->serial
;
523 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
530 const int baud_sup
[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
531 4800, 7200, 9600, 14400, 19200, 28800, 38400,
532 57600, 115200, 230400, 460800, 614400,
533 921600, 1228800, 2457600, 3000000, 6000000 };
534 int baud_floor
, baud_ceil
;
537 dbg("%s - port %d", __func__
, port
->number
);
539 /* The PL2303 is reported to lose bytes if you change
540 serial settings even to the same values as before. Thus
541 we actually need to filter in this specific case */
543 if (!tty_termios_hw_change(tty
->termios
, old_termios
))
546 cflag
= tty
->termios
->c_cflag
;
548 buf
= kzalloc(7, GFP_KERNEL
);
550 dev_err(&port
->dev
, "%s - out of memory.\n", __func__
);
551 /* Report back no change occurred */
552 *tty
->termios
= *old_termios
;
556 i
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
557 GET_LINE_REQUEST
, GET_LINE_REQUEST_TYPE
,
559 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i
,
560 buf
[0], buf
[1], buf
[2], buf
[3], buf
[4], buf
[5], buf
[6]);
563 switch (cflag
& CSIZE
) {
578 dbg("%s - data bits = %d", __func__
, buf
[6]);
581 /* For reference buf[0]:buf[3] baud rate value */
582 /* NOTE: Only the values defined in baud_sup are supported !
583 * => if unsupported values are set, the PL2303 seems to use
584 * 9600 baud (at least my PL2303X always does)
586 baud
= tty_get_baud_rate(tty
);
587 dbg("%s - baud requested = %d", __func__
, baud
);
589 /* Set baudrate to nearest supported value */
590 for (k
=0; k
<ARRAY_SIZE(baud_sup
); k
++) {
591 if (baud_sup
[k
] / baud
) {
592 baud_ceil
= baud_sup
[k
];
596 baud_floor
= baud_sup
[k
-1];
597 if ((baud_ceil
% baud
)
598 > (baud
% baud_floor
))
606 if (baud
> 1228800) {
607 /* type_0, type_1 only support up to 1228800 baud */
608 if (priv
->type
!= HX
)
610 else if (baud
> 6000000)
613 dbg("%s - baud set = %d", __func__
, baud
);
614 buf
[0] = baud
& 0xff;
615 buf
[1] = (baud
>> 8) & 0xff;
616 buf
[2] = (baud
>> 16) & 0xff;
617 buf
[3] = (baud
>> 24) & 0xff;
620 /* For reference buf[4]=0 is 1 stop bits */
621 /* For reference buf[4]=1 is 1.5 stop bits */
622 /* For reference buf[4]=2 is 2 stop bits */
623 if (cflag
& CSTOPB
) {
624 /* NOTE: Comply with "real" UARTs / RS232:
625 * use 1.5 instead of 2 stop bits with 5 data bits
627 if ((cflag
& CSIZE
) == CS5
) {
629 dbg("%s - stop bits = 1.5", __func__
);
632 dbg("%s - stop bits = 2", __func__
);
636 dbg("%s - stop bits = 1", __func__
);
639 if (cflag
& PARENB
) {
640 /* For reference buf[5]=0 is none parity */
641 /* For reference buf[5]=1 is odd parity */
642 /* For reference buf[5]=2 is even parity */
643 /* For reference buf[5]=3 is mark parity */
644 /* For reference buf[5]=4 is space parity */
645 if (cflag
& PARODD
) {
646 if (cflag
& CMSPAR
) {
648 dbg("%s - parity = mark", __func__
);
651 dbg("%s - parity = odd", __func__
);
654 if (cflag
& CMSPAR
) {
656 dbg("%s - parity = space", __func__
);
659 dbg("%s - parity = even", __func__
);
664 dbg("%s - parity = none", __func__
);
667 i
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
668 SET_LINE_REQUEST
, SET_LINE_REQUEST_TYPE
,
670 dbg("0x21:0x20:0:0 %d", i
);
672 /* change control lines if we are switching to or from B0 */
673 spin_lock_irqsave(&priv
->lock
, flags
);
674 control
= priv
->line_control
;
675 if ((cflag
& CBAUD
) == B0
)
676 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
678 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
679 if (control
!= priv
->line_control
) {
680 control
= priv
->line_control
;
681 spin_unlock_irqrestore(&priv
->lock
, flags
);
682 set_control_lines(serial
->dev
, control
);
684 spin_unlock_irqrestore(&priv
->lock
, flags
);
687 buf
[0] = buf
[1] = buf
[2] = buf
[3] = buf
[4] = buf
[5] = buf
[6] = 0;
689 i
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
690 GET_LINE_REQUEST
, GET_LINE_REQUEST_TYPE
,
692 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i
,
693 buf
[0], buf
[1], buf
[2], buf
[3], buf
[4], buf
[5], buf
[6]);
695 if (cflag
& CRTSCTS
) {
696 if (priv
->type
== HX
)
697 pl2303_vendor_write(0x0, 0x61, serial
);
699 pl2303_vendor_write(0x0, 0x41, serial
);
701 pl2303_vendor_write(0x0, 0x0, serial
);
704 /* Save resulting baud rate */
706 tty_encode_baud_rate(tty
, baud
, baud
);
711 static void pl2303_dtr_rts(struct usb_serial_port
*port
, int on
)
713 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
717 spin_lock_irqsave(&priv
->lock
, flags
);
718 /* Change DTR and RTS */
720 priv
->line_control
|= (CONTROL_DTR
| CONTROL_RTS
);
722 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
723 control
= priv
->line_control
;
724 spin_unlock_irqrestore(&priv
->lock
, flags
);
725 set_control_lines(port
->serial
->dev
, control
);
728 static void pl2303_close(struct usb_serial_port
*port
)
730 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
733 dbg("%s - port %d", __func__
, port
->number
);
735 spin_lock_irqsave(&priv
->lock
, flags
);
736 /* clear out any remaining data in the buffer */
737 pl2303_buf_clear(priv
->buf
);
738 spin_unlock_irqrestore(&priv
->lock
, flags
);
740 /* shutdown our urbs */
741 dbg("%s - shutting down urbs", __func__
);
742 usb_kill_urb(port
->write_urb
);
743 usb_kill_urb(port
->read_urb
);
744 usb_kill_urb(port
->interrupt_in_urb
);
748 static int pl2303_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
750 struct ktermios tmp_termios
;
751 struct usb_serial
*serial
= port
->serial
;
752 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
755 dbg("%s - port %d", __func__
, port
->number
);
757 if (priv
->type
!= HX
) {
758 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
759 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
761 /* reset upstream data pipes */
762 pl2303_vendor_write(8, 0, serial
);
763 pl2303_vendor_write(9, 0, serial
);
768 pl2303_set_termios(tty
, port
, &tmp_termios
);
770 dbg("%s - submitting read urb", __func__
);
771 result
= usb_submit_urb(port
->read_urb
, GFP_KERNEL
);
773 dev_err(&port
->dev
, "%s - failed submitting read urb,"
774 " error %d\n", __func__
, result
);
779 dbg("%s - submitting interrupt urb", __func__
);
780 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
782 dev_err(&port
->dev
, "%s - failed submitting interrupt urb,"
783 " error %d\n", __func__
, result
);
787 port
->port
.drain_delay
= 256;
791 static int pl2303_tiocmset(struct tty_struct
*tty
, struct file
*file
,
792 unsigned int set
, unsigned int clear
)
794 struct usb_serial_port
*port
= tty
->driver_data
;
795 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
799 if (!usb_get_intfdata(port
->serial
->interface
))
802 spin_lock_irqsave(&priv
->lock
, flags
);
804 priv
->line_control
|= CONTROL_RTS
;
806 priv
->line_control
|= CONTROL_DTR
;
807 if (clear
& TIOCM_RTS
)
808 priv
->line_control
&= ~CONTROL_RTS
;
809 if (clear
& TIOCM_DTR
)
810 priv
->line_control
&= ~CONTROL_DTR
;
811 control
= priv
->line_control
;
812 spin_unlock_irqrestore(&priv
->lock
, flags
);
814 return set_control_lines(port
->serial
->dev
, control
);
817 static int pl2303_tiocmget(struct tty_struct
*tty
, struct file
*file
)
819 struct usb_serial_port
*port
= tty
->driver_data
;
820 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
826 dbg("%s (%d)", __func__
, port
->number
);
828 if (!usb_get_intfdata(port
->serial
->interface
))
831 spin_lock_irqsave(&priv
->lock
, flags
);
832 mcr
= priv
->line_control
;
833 status
= priv
->line_status
;
834 spin_unlock_irqrestore(&priv
->lock
, flags
);
836 result
= ((mcr
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
837 | ((mcr
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
838 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
839 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
840 | ((status
& UART_RING
) ? TIOCM_RI
: 0)
841 | ((status
& UART_DCD
) ? TIOCM_CD
: 0);
843 dbg("%s - result = %x", __func__
, result
);
848 static int pl2303_carrier_raised(struct usb_serial_port
*port
)
850 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
851 if (priv
->line_status
& UART_DCD
)
856 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
858 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
860 unsigned int prevstatus
;
862 unsigned int changed
;
864 spin_lock_irqsave(&priv
->lock
, flags
);
865 prevstatus
= priv
->line_status
;
866 spin_unlock_irqrestore(&priv
->lock
, flags
);
869 interruptible_sleep_on(&priv
->delta_msr_wait
);
870 /* see if a signal did it */
871 if (signal_pending(current
))
874 spin_lock_irqsave(&priv
->lock
, flags
);
875 status
= priv
->line_status
;
876 spin_unlock_irqrestore(&priv
->lock
, flags
);
878 changed
= prevstatus
^ status
;
880 if (((arg
& TIOCM_RNG
) && (changed
& UART_RING
)) ||
881 ((arg
& TIOCM_DSR
) && (changed
& UART_DSR
)) ||
882 ((arg
& TIOCM_CD
) && (changed
& UART_DCD
)) ||
883 ((arg
& TIOCM_CTS
) && (changed
& UART_CTS
))) {
892 static int pl2303_ioctl(struct tty_struct
*tty
, struct file
*file
,
893 unsigned int cmd
, unsigned long arg
)
895 struct serial_struct ser
;
896 struct usb_serial_port
*port
= tty
->driver_data
;
897 dbg("%s (%d) cmd = 0x%04x", __func__
, port
->number
, cmd
);
901 memset(&ser
, 0, sizeof ser
);
902 ser
.type
= PORT_16654
;
903 ser
.line
= port
->serial
->minor
;
904 ser
.port
= port
->number
;
905 ser
.baud_base
= 460800;
907 if (copy_to_user((void __user
*)arg
, &ser
, sizeof ser
))
913 dbg("%s (%d) TIOCMIWAIT", __func__
, port
->number
);
914 return wait_modem_info(port
, arg
);
916 dbg("%s not supported = 0x%04x", __func__
, cmd
);
922 static void pl2303_break_ctl(struct tty_struct
*tty
, int break_state
)
924 struct usb_serial_port
*port
= tty
->driver_data
;
925 struct usb_serial
*serial
= port
->serial
;
929 dbg("%s - port %d", __func__
, port
->number
);
931 if (break_state
== 0)
935 dbg("%s - turning break %s", __func__
,
936 state
== BREAK_OFF
? "off" : "on");
938 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
939 BREAK_REQUEST
, BREAK_REQUEST_TYPE
, state
,
942 dbg("%s - error sending break = %d", __func__
, result
);
945 static void pl2303_release(struct usb_serial
*serial
)
948 struct pl2303_private
*priv
;
952 for (i
= 0; i
< serial
->num_ports
; ++i
) {
953 priv
= usb_get_serial_port_data(serial
->port
[i
]);
955 pl2303_buf_free(priv
->buf
);
961 static void pl2303_update_line_status(struct usb_serial_port
*port
,
963 unsigned int actual_length
)
966 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
968 u8 status_idx
= UART_STATE
;
969 u8 length
= UART_STATE
+ 1;
972 idv
= le16_to_cpu(port
->serial
->dev
->descriptor
.idVendor
);
973 idp
= le16_to_cpu(port
->serial
->dev
->descriptor
.idProduct
);
976 if (idv
== SIEMENS_VENDOR_ID
) {
977 if (idp
== SIEMENS_PRODUCT_ID_X65
||
978 idp
== SIEMENS_PRODUCT_ID_SX1
||
979 idp
== SIEMENS_PRODUCT_ID_X75
) {
986 if (actual_length
< length
)
989 /* Save off the uart status for others to look at */
990 spin_lock_irqsave(&priv
->lock
, flags
);
991 priv
->line_status
= data
[status_idx
];
992 spin_unlock_irqrestore(&priv
->lock
, flags
);
993 if (priv
->line_status
& UART_BREAK_ERROR
)
994 usb_serial_handle_break(port
);
995 wake_up_interruptible(&priv
->delta_msr_wait
);
998 static void pl2303_read_int_callback(struct urb
*urb
)
1000 struct usb_serial_port
*port
= urb
->context
;
1001 unsigned char *data
= urb
->transfer_buffer
;
1002 unsigned int actual_length
= urb
->actual_length
;
1003 int status
= urb
->status
;
1006 dbg("%s (%d)", __func__
, port
->number
);
1015 /* this urb is terminated, clean up */
1016 dbg("%s - urb shutting down with status: %d", __func__
,
1020 dbg("%s - nonzero urb status received: %d", __func__
,
1025 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
1026 urb
->actual_length
, urb
->transfer_buffer
);
1028 pl2303_update_line_status(port
, data
, actual_length
);
1031 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
1033 dev_err(&urb
->dev
->dev
,
1034 "%s - usb_submit_urb failed with result %d\n",
1038 static void pl2303_push_data(struct tty_struct
*tty
,
1039 struct usb_serial_port
*port
, struct urb
*urb
,
1042 unsigned char *data
= urb
->transfer_buffer
;
1043 /* get tty_flag from status */
1044 char tty_flag
= TTY_NORMAL
;
1045 /* break takes precedence over parity, */
1046 /* which takes precedence over framing errors */
1047 if (line_status
& UART_BREAK_ERROR
)
1048 tty_flag
= TTY_BREAK
;
1049 else if (line_status
& UART_PARITY_ERROR
)
1050 tty_flag
= TTY_PARITY
;
1051 else if (line_status
& UART_FRAME_ERROR
)
1052 tty_flag
= TTY_FRAME
;
1053 dbg("%s - tty_flag = %d", __func__
, tty_flag
);
1055 /* overrun is special, not associated with a char */
1056 if (line_status
& UART_OVERRUN_ERROR
)
1057 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
1059 if (tty_flag
== TTY_NORMAL
&& !(port
->console
&& port
->sysrq
))
1060 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
1063 for (i
= 0; i
< urb
->actual_length
; ++i
)
1064 if (!usb_serial_handle_sysrq_char(tty
, port
, data
[i
]))
1065 tty_insert_flip_char(tty
, data
[i
], tty_flag
);
1067 tty_flip_buffer_push(tty
);
1070 static void pl2303_read_bulk_callback(struct urb
*urb
)
1072 struct usb_serial_port
*port
= urb
->context
;
1073 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
1074 struct tty_struct
*tty
;
1075 unsigned long flags
;
1077 int status
= urb
->status
;
1080 dbg("%s - port %d", __func__
, port
->number
);
1083 dbg("%s - urb status = %d", __func__
, status
);
1084 if (status
== -EPROTO
) {
1085 /* PL2303 mysteriously fails with -EPROTO reschedule
1087 dbg("%s - caught -EPROTO, resubmitting the urb",
1089 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1091 dev_err(&urb
->dev
->dev
, "%s - failed"
1092 " resubmitting read urb, error %d\n",
1096 dbg("%s - unable to handle the error, exiting.", __func__
);
1100 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
1101 urb
->actual_length
, urb
->transfer_buffer
);
1103 spin_lock_irqsave(&priv
->lock
, flags
);
1104 line_status
= priv
->line_status
;
1105 priv
->line_status
&= ~UART_STATE_TRANSIENT_MASK
;
1106 spin_unlock_irqrestore(&priv
->lock
, flags
);
1107 wake_up_interruptible(&priv
->delta_msr_wait
);
1109 tty
= tty_port_tty_get(&port
->port
);
1110 if (tty
&& urb
->actual_length
) {
1111 pl2303_push_data(tty
, port
, urb
, line_status
);
1114 /* Schedule the next read _if_ we are still open */
1115 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1116 if (result
&& result
!= -EPERM
)
1117 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting"
1118 " read urb, error %d\n", __func__
, result
);
1121 static void pl2303_write_bulk_callback(struct urb
*urb
)
1123 struct usb_serial_port
*port
= urb
->context
;
1124 struct pl2303_private
*priv
= usb_get_serial_port_data(port
);
1126 int status
= urb
->status
;
1128 dbg("%s - port %d", __func__
, port
->number
);
1137 /* this urb is terminated, clean up */
1138 dbg("%s - urb shutting down with status: %d", __func__
,
1140 priv
->write_urb_in_use
= 0;
1143 /* error in the urb, so we have to resubmit it */
1144 dbg("%s - Overflow in write", __func__
);
1145 dbg("%s - nonzero write bulk status received: %d", __func__
,
1147 port
->write_urb
->transfer_buffer_length
= 1;
1148 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
1150 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting write"
1151 " urb, error %d\n", __func__
, result
);
1156 priv
->write_urb_in_use
= 0;
1158 /* send any buffered data */
1162 /* All of the device info needed for the PL2303 SIO serial converter */
1163 static struct usb_serial_driver pl2303_device
= {
1165 .owner
= THIS_MODULE
,
1168 .id_table
= id_table
,
1169 .usb_driver
= &pl2303_driver
,
1171 .open
= pl2303_open
,
1172 .close
= pl2303_close
,
1173 .dtr_rts
= pl2303_dtr_rts
,
1174 .carrier_raised
= pl2303_carrier_raised
,
1175 .write
= pl2303_write
,
1176 .ioctl
= pl2303_ioctl
,
1177 .break_ctl
= pl2303_break_ctl
,
1178 .set_termios
= pl2303_set_termios
,
1179 .tiocmget
= pl2303_tiocmget
,
1180 .tiocmset
= pl2303_tiocmset
,
1181 .read_bulk_callback
= pl2303_read_bulk_callback
,
1182 .read_int_callback
= pl2303_read_int_callback
,
1183 .write_bulk_callback
= pl2303_write_bulk_callback
,
1184 .write_room
= pl2303_write_room
,
1185 .chars_in_buffer
= pl2303_chars_in_buffer
,
1186 .attach
= pl2303_startup
,
1187 .release
= pl2303_release
,
1190 static int __init
pl2303_init(void)
1194 retval
= usb_serial_register(&pl2303_device
);
1196 goto failed_usb_serial_register
;
1197 retval
= usb_register(&pl2303_driver
);
1199 goto failed_usb_register
;
1200 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_DESC
"\n");
1202 failed_usb_register
:
1203 usb_serial_deregister(&pl2303_device
);
1204 failed_usb_serial_register
:
1208 static void __exit
pl2303_exit(void)
1210 usb_deregister(&pl2303_driver
);
1211 usb_serial_deregister(&pl2303_device
);
1214 module_init(pl2303_init
);
1215 module_exit(pl2303_exit
);
1217 MODULE_DESCRIPTION(DRIVER_DESC
);
1218 MODULE_LICENSE("GPL");
1220 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1221 MODULE_PARM_DESC(debug
, "Debug enabled or not");