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