2 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
3 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
4 * Copyright 2009, Boris Hajduk <boris@hajduk.org>
6 * ch341.c implements a serial port driver for the Winchiphead CH341.
8 * The CH341 device can be used to implement an RS232 asynchronous
9 * serial port, an IEEE-1284 parallel printer port or a memory-like
10 * interface. In all cases the CH341 supports an I2C interface as well.
11 * This driver only supports the asynchronous serial interface.
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License version
15 * 2 as published by the Free Software Foundation.
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/tty.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/usb.h>
24 #include <linux/usb/serial.h>
25 #include <linux/serial.h>
26 #include <asm/unaligned.h>
28 #define DEFAULT_BAUD_RATE 9600
29 #define DEFAULT_TIMEOUT 1000
31 /* flags for IO-Bits */
32 #define CH341_BIT_RTS (1 << 6)
33 #define CH341_BIT_DTR (1 << 5)
35 /******************************/
36 /* interrupt pipe definitions */
37 /******************************/
38 /* always 4 interrupt bytes */
39 /* first irq byte normally 0x08 */
40 /* second irq byte base 0x7d + below */
41 /* third irq byte base 0x94 + below */
42 /* fourth irq byte normally 0xee */
44 /* second interrupt byte */
45 #define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */
47 /* status returned in third interrupt answer byte, inverted in data
49 #define CH341_BIT_CTS 0x01
50 #define CH341_BIT_DSR 0x02
51 #define CH341_BIT_RI 0x04
52 #define CH341_BIT_DCD 0x08
53 #define CH341_BITS_MODEM_STAT 0x0f /* all bits */
55 /*******************************/
56 /* baudrate calculation factor */
57 /*******************************/
58 #define CH341_BAUDBASE_FACTOR 1532620800
59 #define CH341_BAUDBASE_DIVMAX 3
61 /* Break support - the information used to implement this was gleaned from
62 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato.
65 #define CH341_REQ_WRITE_REG 0x9A
66 #define CH341_REQ_READ_REG 0x95
67 #define CH341_REG_BREAK1 0x05
68 #define CH341_REG_BREAK2 0x18
69 #define CH341_NBREAK_BITS_REG1 0x01
70 #define CH341_NBREAK_BITS_REG2 0x40
75 static const struct usb_device_id id_table
[] = {
76 { USB_DEVICE(0x4348, 0x5523) },
77 { USB_DEVICE(0x1a86, 0x7523) },
80 MODULE_DEVICE_TABLE(usb
, id_table
);
82 struct ch341_private
{
83 spinlock_t lock
; /* access lock */
84 wait_queue_head_t delta_msr_wait
; /* wait queue for modem status */
85 unsigned baud_rate
; /* set baud rate */
86 u8 line_control
; /* set line control value RTS/DTR */
87 u8 line_status
; /* active status of modem control inputs */
88 u8 multi_status_change
; /* status changed multiple since last call */
91 static int ch341_control_out(struct usb_device
*dev
, u8 request
,
95 dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT
|0x40,
96 (int)request
, (int)value
, (int)index
);
98 r
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), request
,
99 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
| USB_DIR_OUT
,
100 value
, index
, NULL
, 0, DEFAULT_TIMEOUT
);
105 static int ch341_control_in(struct usb_device
*dev
,
106 u8 request
, u16 value
, u16 index
,
107 char *buf
, unsigned bufsize
)
110 dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN
|0x40,
111 (int)request
, (int)value
, (int)index
, buf
, (int)bufsize
);
113 r
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), request
,
114 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
| USB_DIR_IN
,
115 value
, index
, buf
, bufsize
, DEFAULT_TIMEOUT
);
119 static int ch341_set_baudrate(struct usb_device
*dev
,
120 struct ch341_private
*priv
)
124 unsigned long factor
;
127 dbg("ch341_set_baudrate(%d)", priv
->baud_rate
);
129 if (!priv
->baud_rate
)
131 factor
= (CH341_BAUDBASE_FACTOR
/ priv
->baud_rate
);
132 divisor
= CH341_BAUDBASE_DIVMAX
;
134 while ((factor
> 0xfff0) && divisor
) {
142 factor
= 0x10000 - factor
;
143 a
= (factor
& 0xff00) | divisor
;
146 r
= ch341_control_out(dev
, 0x9a, 0x1312, a
);
148 r
= ch341_control_out(dev
, 0x9a, 0x0f2c, b
);
153 static int ch341_set_handshake(struct usb_device
*dev
, u8 control
)
155 dbg("ch341_set_handshake(0x%02x)", control
);
156 return ch341_control_out(dev
, 0xa4, ~control
, 0);
159 static int ch341_get_status(struct usb_device
*dev
, struct ch341_private
*priv
)
163 const unsigned size
= 8;
166 dbg("ch341_get_status()");
168 buffer
= kmalloc(size
, GFP_KERNEL
);
172 r
= ch341_control_in(dev
, 0x95, 0x0706, 0, buffer
, size
);
176 /* setup the private status if available */
179 spin_lock_irqsave(&priv
->lock
, flags
);
180 priv
->line_status
= (~(*buffer
)) & CH341_BITS_MODEM_STAT
;
181 priv
->multi_status_change
= 0;
182 spin_unlock_irqrestore(&priv
->lock
, flags
);
190 /* -------------------------------------------------------------------------- */
192 static int ch341_configure(struct usb_device
*dev
, struct ch341_private
*priv
)
196 const unsigned size
= 8;
198 dbg("ch341_configure()");
200 buffer
= kmalloc(size
, GFP_KERNEL
);
204 /* expect two bytes 0x27 0x00 */
205 r
= ch341_control_in(dev
, 0x5f, 0, 0, buffer
, size
);
209 r
= ch341_control_out(dev
, 0xa1, 0, 0);
213 r
= ch341_set_baudrate(dev
, priv
);
217 /* expect two bytes 0x56 0x00 */
218 r
= ch341_control_in(dev
, 0x95, 0x2518, 0, buffer
, size
);
222 r
= ch341_control_out(dev
, 0x9a, 0x2518, 0x0050);
226 /* expect 0xff 0xee */
227 r
= ch341_get_status(dev
, priv
);
231 r
= ch341_control_out(dev
, 0xa1, 0x501f, 0xd90a);
235 r
= ch341_set_baudrate(dev
, priv
);
239 r
= ch341_set_handshake(dev
, priv
->line_control
);
243 /* expect 0x9f 0xee */
244 r
= ch341_get_status(dev
, priv
);
250 /* allocate private data */
251 static int ch341_attach(struct usb_serial
*serial
)
253 struct ch341_private
*priv
;
256 dbg("ch341_attach()");
259 priv
= kzalloc(sizeof(struct ch341_private
), GFP_KERNEL
);
263 spin_lock_init(&priv
->lock
);
264 init_waitqueue_head(&priv
->delta_msr_wait
);
265 priv
->baud_rate
= DEFAULT_BAUD_RATE
;
266 priv
->line_control
= CH341_BIT_RTS
| CH341_BIT_DTR
;
268 r
= ch341_configure(serial
->dev
, priv
);
272 usb_set_serial_port_data(serial
->port
[0], priv
);
279 static int ch341_carrier_raised(struct usb_serial_port
*port
)
281 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
282 if (priv
->line_status
& CH341_BIT_DCD
)
287 static void ch341_dtr_rts(struct usb_serial_port
*port
, int on
)
289 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
292 dbg("%s - port %d", __func__
, port
->number
);
293 /* drop DTR and RTS */
294 spin_lock_irqsave(&priv
->lock
, flags
);
296 priv
->line_control
|= CH341_BIT_RTS
| CH341_BIT_DTR
;
298 priv
->line_control
&= ~(CH341_BIT_RTS
| CH341_BIT_DTR
);
299 spin_unlock_irqrestore(&priv
->lock
, flags
);
300 ch341_set_handshake(port
->serial
->dev
, priv
->line_control
);
301 wake_up_interruptible(&priv
->delta_msr_wait
);
304 static void ch341_close(struct usb_serial_port
*port
)
306 dbg("%s - port %d", __func__
, port
->number
);
308 usb_serial_generic_close(port
);
309 usb_kill_urb(port
->interrupt_in_urb
);
313 /* open this device, set default parameters */
314 static int ch341_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
316 struct usb_serial
*serial
= port
->serial
;
317 struct ch341_private
*priv
= usb_get_serial_port_data(serial
->port
[0]);
322 priv
->baud_rate
= DEFAULT_BAUD_RATE
;
324 r
= ch341_configure(serial
->dev
, priv
);
328 r
= ch341_set_handshake(serial
->dev
, priv
->line_control
);
332 r
= ch341_set_baudrate(serial
->dev
, priv
);
336 dbg("%s - submitting interrupt urb", __func__
);
337 port
->interrupt_in_urb
->dev
= serial
->dev
;
338 r
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
340 dev_err(&port
->dev
, "%s - failed submitting interrupt urb,"
341 " error %d\n", __func__
, r
);
346 r
= usb_serial_generic_open(tty
, port
);
351 /* Old_termios contains the original termios settings and
352 * tty->termios contains the new setting to be used.
354 static void ch341_set_termios(struct tty_struct
*tty
,
355 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
357 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
361 dbg("ch341_set_termios()");
363 baud_rate
= tty_get_baud_rate(tty
);
365 priv
->baud_rate
= baud_rate
;
368 spin_lock_irqsave(&priv
->lock
, flags
);
369 priv
->line_control
|= (CH341_BIT_DTR
| CH341_BIT_RTS
);
370 spin_unlock_irqrestore(&priv
->lock
, flags
);
371 ch341_set_baudrate(port
->serial
->dev
, priv
);
373 spin_lock_irqsave(&priv
->lock
, flags
);
374 priv
->line_control
&= ~(CH341_BIT_DTR
| CH341_BIT_RTS
);
375 spin_unlock_irqrestore(&priv
->lock
, flags
);
378 ch341_set_handshake(port
->serial
->dev
, priv
->line_control
);
381 * (cflag & CSIZE) : data bits [5, 8]
382 * (cflag & PARENB) : parity {NONE, EVEN, ODD}
383 * (cflag & CSTOPB) : stop bits [1, 2]
387 static void ch341_break_ctl(struct tty_struct
*tty
, int break_state
)
389 const uint16_t ch341_break_reg
=
390 CH341_REG_BREAK1
| ((uint16_t) CH341_REG_BREAK2
<< 8);
391 struct usb_serial_port
*port
= tty
->driver_data
;
393 uint16_t reg_contents
;
396 dbg("%s()", __func__
);
398 break_reg
= kmalloc(2, GFP_KERNEL
);
400 dev_err(&port
->dev
, "%s - kmalloc failed\n", __func__
);
404 r
= ch341_control_in(port
->serial
->dev
, CH341_REQ_READ_REG
,
405 ch341_break_reg
, 0, break_reg
, 2);
407 dev_err(&port
->dev
, "%s - USB control read error (%d)\n",
411 dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
412 __func__
, break_reg
[0], break_reg
[1]);
413 if (break_state
!= 0) {
414 dbg("%s - Enter break state requested", __func__
);
415 break_reg
[0] &= ~CH341_NBREAK_BITS_REG1
;
416 break_reg
[1] &= ~CH341_NBREAK_BITS_REG2
;
418 dbg("%s - Leave break state requested", __func__
);
419 break_reg
[0] |= CH341_NBREAK_BITS_REG1
;
420 break_reg
[1] |= CH341_NBREAK_BITS_REG2
;
422 dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
423 __func__
, break_reg
[0], break_reg
[1]);
424 reg_contents
= get_unaligned_le16(break_reg
);
425 r
= ch341_control_out(port
->serial
->dev
, CH341_REQ_WRITE_REG
,
426 ch341_break_reg
, reg_contents
);
428 dev_err(&port
->dev
, "%s - USB control write error (%d)\n",
434 static int ch341_tiocmset(struct tty_struct
*tty
, struct file
*file
,
435 unsigned int set
, unsigned int clear
)
437 struct usb_serial_port
*port
= tty
->driver_data
;
438 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
442 spin_lock_irqsave(&priv
->lock
, flags
);
444 priv
->line_control
|= CH341_BIT_RTS
;
446 priv
->line_control
|= CH341_BIT_DTR
;
447 if (clear
& TIOCM_RTS
)
448 priv
->line_control
&= ~CH341_BIT_RTS
;
449 if (clear
& TIOCM_DTR
)
450 priv
->line_control
&= ~CH341_BIT_DTR
;
451 control
= priv
->line_control
;
452 spin_unlock_irqrestore(&priv
->lock
, flags
);
454 return ch341_set_handshake(port
->serial
->dev
, control
);
457 static void ch341_read_int_callback(struct urb
*urb
)
459 struct usb_serial_port
*port
= (struct usb_serial_port
*) urb
->context
;
460 unsigned char *data
= urb
->transfer_buffer
;
461 unsigned int actual_length
= urb
->actual_length
;
464 dbg("%s (%d)", __func__
, port
->number
);
466 switch (urb
->status
) {
473 /* this urb is terminated, clean up */
474 dbg("%s - urb shutting down with status: %d", __func__
,
478 dbg("%s - nonzero urb status received: %d", __func__
,
483 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
484 urb
->actual_length
, urb
->transfer_buffer
);
486 if (actual_length
>= 4) {
487 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
490 spin_lock_irqsave(&priv
->lock
, flags
);
491 priv
->line_status
= (~(data
[2])) & CH341_BITS_MODEM_STAT
;
492 if ((data
[1] & CH341_MULT_STAT
))
493 priv
->multi_status_change
= 1;
494 spin_unlock_irqrestore(&priv
->lock
, flags
);
495 wake_up_interruptible(&priv
->delta_msr_wait
);
499 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
501 dev_err(&urb
->dev
->dev
,
502 "%s - usb_submit_urb failed with result %d\n",
506 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
508 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
515 spin_lock_irqsave(&priv
->lock
, flags
);
516 prevstatus
= priv
->line_status
;
517 priv
->multi_status_change
= 0;
518 spin_unlock_irqrestore(&priv
->lock
, flags
);
520 while (!multi_change
) {
521 interruptible_sleep_on(&priv
->delta_msr_wait
);
522 /* see if a signal did it */
523 if (signal_pending(current
))
526 spin_lock_irqsave(&priv
->lock
, flags
);
527 status
= priv
->line_status
;
528 multi_change
= priv
->multi_status_change
;
529 spin_unlock_irqrestore(&priv
->lock
, flags
);
531 changed
= prevstatus
^ status
;
533 if (((arg
& TIOCM_RNG
) && (changed
& CH341_BIT_RI
)) ||
534 ((arg
& TIOCM_DSR
) && (changed
& CH341_BIT_DSR
)) ||
535 ((arg
& TIOCM_CD
) && (changed
& CH341_BIT_DCD
)) ||
536 ((arg
& TIOCM_CTS
) && (changed
& CH341_BIT_CTS
))) {
545 /*static int ch341_ioctl(struct usb_serial_port *port, struct file *file,*/
546 static int ch341_ioctl(struct tty_struct
*tty
, struct file
*file
,
547 unsigned int cmd
, unsigned long arg
)
549 struct usb_serial_port
*port
= tty
->driver_data
;
550 dbg("%s (%d) cmd = 0x%04x", __func__
, port
->number
, cmd
);
554 dbg("%s (%d) TIOCMIWAIT", __func__
, port
->number
);
555 return wait_modem_info(port
, arg
);
558 dbg("%s not supported = 0x%04x", __func__
, cmd
);
565 static int ch341_tiocmget(struct tty_struct
*tty
, struct file
*file
)
567 struct usb_serial_port
*port
= tty
->driver_data
;
568 struct ch341_private
*priv
= usb_get_serial_port_data(port
);
574 dbg("%s (%d)", __func__
, port
->number
);
576 spin_lock_irqsave(&priv
->lock
, flags
);
577 mcr
= priv
->line_control
;
578 status
= priv
->line_status
;
579 spin_unlock_irqrestore(&priv
->lock
, flags
);
581 result
= ((mcr
& CH341_BIT_DTR
) ? TIOCM_DTR
: 0)
582 | ((mcr
& CH341_BIT_RTS
) ? TIOCM_RTS
: 0)
583 | ((status
& CH341_BIT_CTS
) ? TIOCM_CTS
: 0)
584 | ((status
& CH341_BIT_DSR
) ? TIOCM_DSR
: 0)
585 | ((status
& CH341_BIT_RI
) ? TIOCM_RI
: 0)
586 | ((status
& CH341_BIT_DCD
) ? TIOCM_CD
: 0);
588 dbg("%s - result = %x", __func__
, result
);
594 static int ch341_reset_resume(struct usb_interface
*intf
)
596 struct usb_device
*dev
= interface_to_usbdev(intf
);
597 struct usb_serial
*serial
= NULL
;
598 struct ch341_private
*priv
;
600 serial
= usb_get_intfdata(intf
);
601 priv
= usb_get_serial_port_data(serial
->port
[0]);
603 /*reconfigure ch341 serial port after bus-reset*/
604 ch341_configure(dev
, priv
);
606 usb_serial_resume(intf
);
611 static struct usb_driver ch341_driver
= {
613 .probe
= usb_serial_probe
,
614 .disconnect
= usb_serial_disconnect
,
615 .suspend
= usb_serial_suspend
,
616 .resume
= usb_serial_resume
,
617 .reset_resume
= ch341_reset_resume
,
618 .id_table
= id_table
,
620 .supports_autosuspend
= 1,
623 static struct usb_serial_driver ch341_device
= {
625 .owner
= THIS_MODULE
,
626 .name
= "ch341-uart",
628 .id_table
= id_table
,
629 .usb_driver
= &ch341_driver
,
632 .dtr_rts
= ch341_dtr_rts
,
633 .carrier_raised
= ch341_carrier_raised
,
634 .close
= ch341_close
,
635 .ioctl
= ch341_ioctl
,
636 .set_termios
= ch341_set_termios
,
637 .break_ctl
= ch341_break_ctl
,
638 .tiocmget
= ch341_tiocmget
,
639 .tiocmset
= ch341_tiocmset
,
640 .read_int_callback
= ch341_read_int_callback
,
641 .attach
= ch341_attach
,
644 static int __init
ch341_init(void)
648 retval
= usb_serial_register(&ch341_device
);
651 retval
= usb_register(&ch341_driver
);
653 usb_serial_deregister(&ch341_device
);
657 static void __exit
ch341_exit(void)
659 usb_deregister(&ch341_driver
);
660 usb_serial_deregister(&ch341_device
);
663 module_init(ch341_init
);
664 module_exit(ch341_exit
);
665 MODULE_LICENSE("GPL");
667 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
668 MODULE_PARM_DESC(debug
, "Debug enabled or not");