1/*
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>
5 *
6 * ch341.c implements a serial port driver for the Winchiphead CH341.
7 *
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.
12 *
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.
16 */
17
18#include <linux/kernel.h>
19#include <linux/tty.h>
20#include <linux/module.h>
21#include <linux/slab.h>
22#include <linux/usb.h>
23#include <linux/usb/serial.h>
24#include <linux/serial.h>
25#include <asm/unaligned.h>
26
27#define DEFAULT_BAUD_RATE 9600
28#define DEFAULT_TIMEOUT   1000
29
30/* flags for IO-Bits */
31#define CH341_BIT_RTS (1 << 6)
32#define CH341_BIT_DTR (1 << 5)
33
34/******************************/
35/* interrupt pipe definitions */
36/******************************/
37/* always 4 interrupt bytes */
38/* first irq byte normally 0x08 */
39/* second irq byte base 0x7d + below */
40/* third irq byte base 0x94 + below */
41/* fourth irq byte normally 0xee */
42
43/* second interrupt byte */
44#define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */
45
46/* status returned in third interrupt answer byte, inverted in data
47   from irq */
48#define CH341_BIT_CTS 0x01
49#define CH341_BIT_DSR 0x02
50#define CH341_BIT_RI  0x04
51#define CH341_BIT_DCD 0x08
52#define CH341_BITS_MODEM_STAT 0x0f /* all bits */
53
54/*******************************/
55/* baudrate calculation factor */
56/*******************************/
57#define CH341_BAUDBASE_FACTOR 1532620800
58#define CH341_BAUDBASE_DIVMAX 3
59
60/* Break support - the information used to implement this was gleaned from
61 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe.  Domo arigato.
62 */
63
64#define CH341_REQ_WRITE_REG    0x9A
65#define CH341_REQ_READ_REG     0x95
66#define CH341_REG_BREAK1       0x05
67#define CH341_REG_BREAK2       0x18
68#define CH341_NBREAK_BITS_REG1 0x01
69#define CH341_NBREAK_BITS_REG2 0x40
70
71
72static const struct usb_device_id id_table[] = {
73	{ USB_DEVICE(0x4348, 0x5523) },
74	{ USB_DEVICE(0x1a86, 0x7523) },
75	{ USB_DEVICE(0x1a86, 0x5523) },
76	{ },
77};
78MODULE_DEVICE_TABLE(usb, id_table);
79
80struct ch341_private {
81	spinlock_t lock; /* access lock */
82	unsigned baud_rate; /* set baud rate */
83	u8 line_control; /* set line control value RTS/DTR */
84	u8 line_status; /* active status of modem control inputs */
85};
86
87static void ch341_set_termios(struct tty_struct *tty,
88			      struct usb_serial_port *port,
89			      struct ktermios *old_termios);
90
91static int ch341_control_out(struct usb_device *dev, u8 request,
92			     u16 value, u16 index)
93{
94	int r;
95
96	dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n",
97		USB_DIR_OUT|0x40, (int)request, (int)value, (int)index);
98
99	r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
100			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
101			    value, index, NULL, 0, DEFAULT_TIMEOUT);
102
103	return r;
104}
105
106static int ch341_control_in(struct usb_device *dev,
107			    u8 request, u16 value, u16 index,
108			    char *buf, unsigned bufsize)
109{
110	int r;
111
112	dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n",
113		USB_DIR_IN|0x40, (int)request, (int)value, (int)index, buf,
114		(int)bufsize);
115
116	r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
117			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
118			    value, index, buf, bufsize, DEFAULT_TIMEOUT);
119	return r;
120}
121
122static int ch341_set_baudrate(struct usb_device *dev,
123			      struct ch341_private *priv)
124{
125	short a, b;
126	int r;
127	unsigned long factor;
128	short divisor;
129
130	if (!priv->baud_rate)
131		return -EINVAL;
132	factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
133	divisor = CH341_BAUDBASE_DIVMAX;
134
135	while ((factor > 0xfff0) && divisor) {
136		factor >>= 3;
137		divisor--;
138	}
139
140	if (factor > 0xfff0)
141		return -EINVAL;
142
143	factor = 0x10000 - factor;
144	a = (factor & 0xff00) | divisor;
145	b = factor & 0xff;
146
147	r = ch341_control_out(dev, 0x9a, 0x1312, a);
148	if (!r)
149		r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
150
151	return r;
152}
153
154static int ch341_set_handshake(struct usb_device *dev, u8 control)
155{
156	return ch341_control_out(dev, 0xa4, ~control, 0);
157}
158
159static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
160{
161	char *buffer;
162	int r;
163	const unsigned size = 8;
164	unsigned long flags;
165
166	buffer = kmalloc(size, GFP_KERNEL);
167	if (!buffer)
168		return -ENOMEM;
169
170	r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
171	if (r < 0)
172		goto out;
173
174	/* setup the private status if available */
175	if (r == 2) {
176		r = 0;
177		spin_lock_irqsave(&priv->lock, flags);
178		priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
179		spin_unlock_irqrestore(&priv->lock, flags);
180	} else
181		r = -EPROTO;
182
183out:	kfree(buffer);
184	return r;
185}
186
187/* -------------------------------------------------------------------------- */
188
189static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
190{
191	char *buffer;
192	int r;
193	const unsigned size = 8;
194
195	buffer = kmalloc(size, GFP_KERNEL);
196	if (!buffer)
197		return -ENOMEM;
198
199	/* expect two bytes 0x27 0x00 */
200	r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
201	if (r < 0)
202		goto out;
203
204	r = ch341_control_out(dev, 0xa1, 0, 0);
205	if (r < 0)
206		goto out;
207
208	r = ch341_set_baudrate(dev, priv);
209	if (r < 0)
210		goto out;
211
212	/* expect two bytes 0x56 0x00 */
213	r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
214	if (r < 0)
215		goto out;
216
217	r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
218	if (r < 0)
219		goto out;
220
221	/* expect 0xff 0xee */
222	r = ch341_get_status(dev, priv);
223	if (r < 0)
224		goto out;
225
226	r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
227	if (r < 0)
228		goto out;
229
230	r = ch341_set_baudrate(dev, priv);
231	if (r < 0)
232		goto out;
233
234	r = ch341_set_handshake(dev, priv->line_control);
235	if (r < 0)
236		goto out;
237
238	/* expect 0x9f 0xee */
239	r = ch341_get_status(dev, priv);
240
241out:	kfree(buffer);
242	return r;
243}
244
245static int ch341_port_probe(struct usb_serial_port *port)
246{
247	struct ch341_private *priv;
248	int r;
249
250	priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
251	if (!priv)
252		return -ENOMEM;
253
254	spin_lock_init(&priv->lock);
255	priv->baud_rate = DEFAULT_BAUD_RATE;
256	priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
257
258	r = ch341_configure(port->serial->dev, priv);
259	if (r < 0)
260		goto error;
261
262	usb_set_serial_port_data(port, priv);
263	return 0;
264
265error:	kfree(priv);
266	return r;
267}
268
269static int ch341_port_remove(struct usb_serial_port *port)
270{
271	struct ch341_private *priv;
272
273	priv = usb_get_serial_port_data(port);
274	kfree(priv);
275
276	return 0;
277}
278
279static int ch341_carrier_raised(struct usb_serial_port *port)
280{
281	struct ch341_private *priv = usb_get_serial_port_data(port);
282	if (priv->line_status & CH341_BIT_DCD)
283		return 1;
284	return 0;
285}
286
287static void ch341_dtr_rts(struct usb_serial_port *port, int on)
288{
289	struct ch341_private *priv = usb_get_serial_port_data(port);
290	unsigned long flags;
291
292	/* drop DTR and RTS */
293	spin_lock_irqsave(&priv->lock, flags);
294	if (on)
295		priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
296	else
297		priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
298	spin_unlock_irqrestore(&priv->lock, flags);
299	ch341_set_handshake(port->serial->dev, priv->line_control);
300}
301
302static void ch341_close(struct usb_serial_port *port)
303{
304	usb_serial_generic_close(port);
305	usb_kill_urb(port->interrupt_in_urb);
306}
307
308
309/* open this device, set default parameters */
310static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
311{
312	struct usb_serial *serial = port->serial;
313	struct ch341_private *priv = usb_get_serial_port_data(port);
314	int r;
315
316	r = ch341_configure(serial->dev, priv);
317	if (r)
318		goto out;
319
320	if (tty)
321		ch341_set_termios(tty, port, NULL);
322
323	dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__);
324	r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
325	if (r) {
326		dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n",
327			__func__, r);
328		goto out;
329	}
330
331	r = usb_serial_generic_open(tty, port);
332
333out:	return r;
334}
335
336/* Old_termios contains the original termios settings and
337 * tty->termios contains the new setting to be used.
338 */
339static void ch341_set_termios(struct tty_struct *tty,
340		struct usb_serial_port *port, struct ktermios *old_termios)
341{
342	struct ch341_private *priv = usb_get_serial_port_data(port);
343	unsigned baud_rate;
344	unsigned long flags;
345
346	baud_rate = tty_get_baud_rate(tty);
347
348	priv->baud_rate = baud_rate;
349
350	if (baud_rate) {
351		spin_lock_irqsave(&priv->lock, flags);
352		priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
353		spin_unlock_irqrestore(&priv->lock, flags);
354		ch341_set_baudrate(port->serial->dev, priv);
355	} else {
356		spin_lock_irqsave(&priv->lock, flags);
357		priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
358		spin_unlock_irqrestore(&priv->lock, flags);
359	}
360
361	ch341_set_handshake(port->serial->dev, priv->line_control);
362
363	/* Unimplemented:
364	 * (cflag & CSIZE) : data bits [5, 8]
365	 * (cflag & PARENB) : parity {NONE, EVEN, ODD}
366	 * (cflag & CSTOPB) : stop bits [1, 2]
367	 */
368}
369
370static void ch341_break_ctl(struct tty_struct *tty, int break_state)
371{
372	const uint16_t ch341_break_reg =
373		CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
374	struct usb_serial_port *port = tty->driver_data;
375	int r;
376	uint16_t reg_contents;
377	uint8_t *break_reg;
378
379	break_reg = kmalloc(2, GFP_KERNEL);
380	if (!break_reg)
381		return;
382
383	r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
384			ch341_break_reg, 0, break_reg, 2);
385	if (r < 0) {
386		dev_err(&port->dev, "%s - USB control read error (%d)\n",
387				__func__, r);
388		goto out;
389	}
390	dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n",
391		__func__, break_reg[0], break_reg[1]);
392	if (break_state != 0) {
393		dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__);
394		break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
395		break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
396	} else {
397		dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__);
398		break_reg[0] |= CH341_NBREAK_BITS_REG1;
399		break_reg[1] |= CH341_NBREAK_BITS_REG2;
400	}
401	dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n",
402		__func__, break_reg[0], break_reg[1]);
403	reg_contents = get_unaligned_le16(break_reg);
404	r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
405			ch341_break_reg, reg_contents);
406	if (r < 0)
407		dev_err(&port->dev, "%s - USB control write error (%d)\n",
408				__func__, r);
409out:
410	kfree(break_reg);
411}
412
413static int ch341_tiocmset(struct tty_struct *tty,
414			  unsigned int set, unsigned int clear)
415{
416	struct usb_serial_port *port = tty->driver_data;
417	struct ch341_private *priv = usb_get_serial_port_data(port);
418	unsigned long flags;
419	u8 control;
420
421	spin_lock_irqsave(&priv->lock, flags);
422	if (set & TIOCM_RTS)
423		priv->line_control |= CH341_BIT_RTS;
424	if (set & TIOCM_DTR)
425		priv->line_control |= CH341_BIT_DTR;
426	if (clear & TIOCM_RTS)
427		priv->line_control &= ~CH341_BIT_RTS;
428	if (clear & TIOCM_DTR)
429		priv->line_control &= ~CH341_BIT_DTR;
430	control = priv->line_control;
431	spin_unlock_irqrestore(&priv->lock, flags);
432
433	return ch341_set_handshake(port->serial->dev, control);
434}
435
436static void ch341_update_line_status(struct usb_serial_port *port,
437					unsigned char *data, size_t len)
438{
439	struct ch341_private *priv = usb_get_serial_port_data(port);
440	struct tty_struct *tty;
441	unsigned long flags;
442	u8 status;
443	u8 delta;
444
445	if (len < 4)
446		return;
447
448	status = ~data[2] & CH341_BITS_MODEM_STAT;
449
450	spin_lock_irqsave(&priv->lock, flags);
451	delta = status ^ priv->line_status;
452	priv->line_status = status;
453	spin_unlock_irqrestore(&priv->lock, flags);
454
455	if (data[1] & CH341_MULT_STAT)
456		dev_dbg(&port->dev, "%s - multiple status change\n", __func__);
457
458	if (!delta)
459		return;
460
461	if (delta & CH341_BIT_CTS)
462		port->icount.cts++;
463	if (delta & CH341_BIT_DSR)
464		port->icount.dsr++;
465	if (delta & CH341_BIT_RI)
466		port->icount.rng++;
467	if (delta & CH341_BIT_DCD) {
468		port->icount.dcd++;
469		tty = tty_port_tty_get(&port->port);
470		if (tty) {
471			usb_serial_handle_dcd_change(port, tty,
472						status & CH341_BIT_DCD);
473			tty_kref_put(tty);
474		}
475	}
476
477	wake_up_interruptible(&port->port.delta_msr_wait);
478}
479
480static void ch341_read_int_callback(struct urb *urb)
481{
482	struct usb_serial_port *port = urb->context;
483	unsigned char *data = urb->transfer_buffer;
484	unsigned int len = urb->actual_length;
485	int status;
486
487	switch (urb->status) {
488	case 0:
489		/* success */
490		break;
491	case -ECONNRESET:
492	case -ENOENT:
493	case -ESHUTDOWN:
494		/* this urb is terminated, clean up */
495		dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
496			__func__, urb->status);
497		return;
498	default:
499		dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
500			__func__, urb->status);
501		goto exit;
502	}
503
504	usb_serial_debug_data(&port->dev, __func__, len, data);
505	ch341_update_line_status(port, data, len);
506exit:
507	status = usb_submit_urb(urb, GFP_ATOMIC);
508	if (status) {
509		dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n",
510			__func__, status);
511	}
512}
513
514static int ch341_tiocmget(struct tty_struct *tty)
515{
516	struct usb_serial_port *port = tty->driver_data;
517	struct ch341_private *priv = usb_get_serial_port_data(port);
518	unsigned long flags;
519	u8 mcr;
520	u8 status;
521	unsigned int result;
522
523	spin_lock_irqsave(&priv->lock, flags);
524	mcr = priv->line_control;
525	status = priv->line_status;
526	spin_unlock_irqrestore(&priv->lock, flags);
527
528	result = ((mcr & CH341_BIT_DTR)		? TIOCM_DTR : 0)
529		  | ((mcr & CH341_BIT_RTS)	? TIOCM_RTS : 0)
530		  | ((status & CH341_BIT_CTS)	? TIOCM_CTS : 0)
531		  | ((status & CH341_BIT_DSR)	? TIOCM_DSR : 0)
532		  | ((status & CH341_BIT_RI)	? TIOCM_RI  : 0)
533		  | ((status & CH341_BIT_DCD)	? TIOCM_CD  : 0);
534
535	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
536
537	return result;
538}
539
540static int ch341_reset_resume(struct usb_serial *serial)
541{
542	struct ch341_private *priv;
543
544	priv = usb_get_serial_port_data(serial->port[0]);
545
546	/* reconfigure ch341 serial port after bus-reset */
547	ch341_configure(serial->dev, priv);
548
549	return 0;
550}
551
552static struct usb_serial_driver ch341_device = {
553	.driver = {
554		.owner	= THIS_MODULE,
555		.name	= "ch341-uart",
556	},
557	.id_table          = id_table,
558	.num_ports         = 1,
559	.open              = ch341_open,
560	.dtr_rts	   = ch341_dtr_rts,
561	.carrier_raised	   = ch341_carrier_raised,
562	.close             = ch341_close,
563	.set_termios       = ch341_set_termios,
564	.break_ctl         = ch341_break_ctl,
565	.tiocmget          = ch341_tiocmget,
566	.tiocmset          = ch341_tiocmset,
567	.tiocmiwait        = usb_serial_generic_tiocmiwait,
568	.read_int_callback = ch341_read_int_callback,
569	.port_probe        = ch341_port_probe,
570	.port_remove       = ch341_port_remove,
571	.reset_resume      = ch341_reset_resume,
572};
573
574static struct usb_serial_driver * const serial_drivers[] = {
575	&ch341_device, NULL
576};
577
578module_usb_serial_driver(serial_drivers, id_table);
579
580MODULE_LICENSE("GPL");
581