xref: /openbmc/linux/drivers/usb/serial/ch341.c (revision 1c2dd16a)
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_READ_VERSION 0x5F
65 #define CH341_REQ_WRITE_REG    0x9A
66 #define CH341_REQ_READ_REG     0x95
67 #define CH341_REQ_SERIAL_INIT  0xA1
68 #define CH341_REQ_MODEM_CTRL   0xA4
69 
70 #define CH341_REG_BREAK        0x05
71 #define CH341_REG_LCR          0x18
72 #define CH341_NBREAK_BITS      0x01
73 
74 #define CH341_LCR_ENABLE_RX    0x80
75 #define CH341_LCR_ENABLE_TX    0x40
76 #define CH341_LCR_MARK_SPACE   0x20
77 #define CH341_LCR_PAR_EVEN     0x10
78 #define CH341_LCR_ENABLE_PAR   0x08
79 #define CH341_LCR_STOP_BITS_2  0x04
80 #define CH341_LCR_CS8          0x03
81 #define CH341_LCR_CS7          0x02
82 #define CH341_LCR_CS6          0x01
83 #define CH341_LCR_CS5          0x00
84 
85 static const struct usb_device_id id_table[] = {
86 	{ USB_DEVICE(0x4348, 0x5523) },
87 	{ USB_DEVICE(0x1a86, 0x7523) },
88 	{ USB_DEVICE(0x1a86, 0x5523) },
89 	{ },
90 };
91 MODULE_DEVICE_TABLE(usb, id_table);
92 
93 struct ch341_private {
94 	spinlock_t lock; /* access lock */
95 	unsigned baud_rate; /* set baud rate */
96 	u8 mcr;
97 	u8 msr;
98 	u8 lcr;
99 };
100 
101 static void ch341_set_termios(struct tty_struct *tty,
102 			      struct usb_serial_port *port,
103 			      struct ktermios *old_termios);
104 
105 static int ch341_control_out(struct usb_device *dev, u8 request,
106 			     u16 value, u16 index)
107 {
108 	int r;
109 
110 	dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x)\n", __func__,
111 		request, value, index);
112 
113 	r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
114 			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
115 			    value, index, NULL, 0, DEFAULT_TIMEOUT);
116 	if (r < 0)
117 		dev_err(&dev->dev, "failed to send control message: %d\n", r);
118 
119 	return r;
120 }
121 
122 static int ch341_control_in(struct usb_device *dev,
123 			    u8 request, u16 value, u16 index,
124 			    char *buf, unsigned bufsize)
125 {
126 	int r;
127 
128 	dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x,%u)\n", __func__,
129 		request, value, index, bufsize);
130 
131 	r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
132 			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
133 			    value, index, buf, bufsize, DEFAULT_TIMEOUT);
134 	if (r < bufsize) {
135 		if (r >= 0) {
136 			dev_err(&dev->dev,
137 				"short control message received (%d < %u)\n",
138 				r, bufsize);
139 			r = -EIO;
140 		}
141 
142 		dev_err(&dev->dev, "failed to receive control message: %d\n",
143 			r);
144 		return r;
145 	}
146 
147 	return 0;
148 }
149 
150 static int ch341_set_baudrate_lcr(struct usb_device *dev,
151 				  struct ch341_private *priv, u8 lcr)
152 {
153 	short a;
154 	int r;
155 	unsigned long factor;
156 	short divisor;
157 
158 	if (!priv->baud_rate)
159 		return -EINVAL;
160 	factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
161 	divisor = CH341_BAUDBASE_DIVMAX;
162 
163 	while ((factor > 0xfff0) && divisor) {
164 		factor >>= 3;
165 		divisor--;
166 	}
167 
168 	if (factor > 0xfff0)
169 		return -EINVAL;
170 
171 	factor = 0x10000 - factor;
172 	a = (factor & 0xff00) | divisor;
173 
174 	/*
175 	 * CH341A buffers data until a full endpoint-size packet (32 bytes)
176 	 * has been received unless bit 7 is set.
177 	 */
178 	a |= BIT(7);
179 
180 	r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 0x1312, a);
181 	if (r)
182 		return r;
183 
184 	r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 0x2518, lcr);
185 	if (r)
186 		return r;
187 
188 	return r;
189 }
190 
191 static int ch341_set_handshake(struct usb_device *dev, u8 control)
192 {
193 	return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0);
194 }
195 
196 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
197 {
198 	const unsigned int size = 2;
199 	char *buffer;
200 	int r;
201 	unsigned long flags;
202 
203 	buffer = kmalloc(size, GFP_KERNEL);
204 	if (!buffer)
205 		return -ENOMEM;
206 
207 	r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size);
208 	if (r < 0)
209 		goto out;
210 
211 	spin_lock_irqsave(&priv->lock, flags);
212 	priv->msr = (~(*buffer)) & CH341_BITS_MODEM_STAT;
213 	spin_unlock_irqrestore(&priv->lock, flags);
214 
215 out:	kfree(buffer);
216 	return r;
217 }
218 
219 /* -------------------------------------------------------------------------- */
220 
221 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
222 {
223 	const unsigned int size = 2;
224 	char *buffer;
225 	int r;
226 
227 	buffer = kmalloc(size, GFP_KERNEL);
228 	if (!buffer)
229 		return -ENOMEM;
230 
231 	/* expect two bytes 0x27 0x00 */
232 	r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size);
233 	if (r < 0)
234 		goto out;
235 	dev_dbg(&dev->dev, "Chip version: 0x%02x\n", buffer[0]);
236 
237 	r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0);
238 	if (r < 0)
239 		goto out;
240 
241 	r = ch341_set_baudrate_lcr(dev, priv, priv->lcr);
242 	if (r < 0)
243 		goto out;
244 
245 	r = ch341_set_handshake(dev, priv->mcr);
246 
247 out:	kfree(buffer);
248 	return r;
249 }
250 
251 static int ch341_port_probe(struct usb_serial_port *port)
252 {
253 	struct ch341_private *priv;
254 	int r;
255 
256 	priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
257 	if (!priv)
258 		return -ENOMEM;
259 
260 	spin_lock_init(&priv->lock);
261 	priv->baud_rate = DEFAULT_BAUD_RATE;
262 	/*
263 	 * Some CH340 devices appear unable to change the initial LCR
264 	 * settings, so set a sane 8N1 default.
265 	 */
266 	priv->lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8;
267 
268 	r = ch341_configure(port->serial->dev, priv);
269 	if (r < 0)
270 		goto error;
271 
272 	usb_set_serial_port_data(port, priv);
273 	return 0;
274 
275 error:	kfree(priv);
276 	return r;
277 }
278 
279 static int ch341_port_remove(struct usb_serial_port *port)
280 {
281 	struct ch341_private *priv;
282 
283 	priv = usb_get_serial_port_data(port);
284 	kfree(priv);
285 
286 	return 0;
287 }
288 
289 static int ch341_carrier_raised(struct usb_serial_port *port)
290 {
291 	struct ch341_private *priv = usb_get_serial_port_data(port);
292 	if (priv->msr & CH341_BIT_DCD)
293 		return 1;
294 	return 0;
295 }
296 
297 static void ch341_dtr_rts(struct usb_serial_port *port, int on)
298 {
299 	struct ch341_private *priv = usb_get_serial_port_data(port);
300 	unsigned long flags;
301 
302 	/* drop DTR and RTS */
303 	spin_lock_irqsave(&priv->lock, flags);
304 	if (on)
305 		priv->mcr |= CH341_BIT_RTS | CH341_BIT_DTR;
306 	else
307 		priv->mcr &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
308 	spin_unlock_irqrestore(&priv->lock, flags);
309 	ch341_set_handshake(port->serial->dev, priv->mcr);
310 }
311 
312 static void ch341_close(struct usb_serial_port *port)
313 {
314 	usb_serial_generic_close(port);
315 	usb_kill_urb(port->interrupt_in_urb);
316 }
317 
318 
319 /* open this device, set default parameters */
320 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
321 {
322 	struct ch341_private *priv = usb_get_serial_port_data(port);
323 	int r;
324 
325 	if (tty)
326 		ch341_set_termios(tty, port, NULL);
327 
328 	dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__);
329 	r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
330 	if (r) {
331 		dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n",
332 			__func__, r);
333 		return r;
334 	}
335 
336 	r = ch341_get_status(port->serial->dev, priv);
337 	if (r < 0) {
338 		dev_err(&port->dev, "failed to read modem status: %d\n", r);
339 		goto err_kill_interrupt_urb;
340 	}
341 
342 	r = usb_serial_generic_open(tty, port);
343 	if (r)
344 		goto err_kill_interrupt_urb;
345 
346 	return 0;
347 
348 err_kill_interrupt_urb:
349 	usb_kill_urb(port->interrupt_in_urb);
350 
351 	return r;
352 }
353 
354 /* Old_termios contains the original termios settings and
355  * tty->termios contains the new setting to be used.
356  */
357 static void ch341_set_termios(struct tty_struct *tty,
358 		struct usb_serial_port *port, struct ktermios *old_termios)
359 {
360 	struct ch341_private *priv = usb_get_serial_port_data(port);
361 	unsigned baud_rate;
362 	unsigned long flags;
363 	u8 lcr;
364 	int r;
365 
366 	/* redundant changes may cause the chip to lose bytes */
367 	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
368 		return;
369 
370 	baud_rate = tty_get_baud_rate(tty);
371 
372 	lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX;
373 
374 	switch (C_CSIZE(tty)) {
375 	case CS5:
376 		lcr |= CH341_LCR_CS5;
377 		break;
378 	case CS6:
379 		lcr |= CH341_LCR_CS6;
380 		break;
381 	case CS7:
382 		lcr |= CH341_LCR_CS7;
383 		break;
384 	case CS8:
385 		lcr |= CH341_LCR_CS8;
386 		break;
387 	}
388 
389 	if (C_PARENB(tty)) {
390 		lcr |= CH341_LCR_ENABLE_PAR;
391 		if (C_PARODD(tty) == 0)
392 			lcr |= CH341_LCR_PAR_EVEN;
393 		if (C_CMSPAR(tty))
394 			lcr |= CH341_LCR_MARK_SPACE;
395 	}
396 
397 	if (C_CSTOPB(tty))
398 		lcr |= CH341_LCR_STOP_BITS_2;
399 
400 	if (baud_rate) {
401 		priv->baud_rate = baud_rate;
402 
403 		r = ch341_set_baudrate_lcr(port->serial->dev, priv, lcr);
404 		if (r < 0 && old_termios) {
405 			priv->baud_rate = tty_termios_baud_rate(old_termios);
406 			tty_termios_copy_hw(&tty->termios, old_termios);
407 		} else if (r == 0) {
408 			priv->lcr = lcr;
409 		}
410 	}
411 
412 	spin_lock_irqsave(&priv->lock, flags);
413 	if (C_BAUD(tty) == B0)
414 		priv->mcr &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
415 	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
416 		priv->mcr |= (CH341_BIT_DTR | CH341_BIT_RTS);
417 	spin_unlock_irqrestore(&priv->lock, flags);
418 
419 	ch341_set_handshake(port->serial->dev, priv->mcr);
420 }
421 
422 static void ch341_break_ctl(struct tty_struct *tty, int break_state)
423 {
424 	const uint16_t ch341_break_reg =
425 			((uint16_t) CH341_REG_LCR << 8) | CH341_REG_BREAK;
426 	struct usb_serial_port *port = tty->driver_data;
427 	int r;
428 	uint16_t reg_contents;
429 	uint8_t *break_reg;
430 
431 	break_reg = kmalloc(2, GFP_KERNEL);
432 	if (!break_reg)
433 		return;
434 
435 	r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
436 			ch341_break_reg, 0, break_reg, 2);
437 	if (r < 0) {
438 		dev_err(&port->dev, "%s - USB control read error (%d)\n",
439 				__func__, r);
440 		goto out;
441 	}
442 	dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n",
443 		__func__, break_reg[0], break_reg[1]);
444 	if (break_state != 0) {
445 		dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__);
446 		break_reg[0] &= ~CH341_NBREAK_BITS;
447 		break_reg[1] &= ~CH341_LCR_ENABLE_TX;
448 	} else {
449 		dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__);
450 		break_reg[0] |= CH341_NBREAK_BITS;
451 		break_reg[1] |= CH341_LCR_ENABLE_TX;
452 	}
453 	dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n",
454 		__func__, break_reg[0], break_reg[1]);
455 	reg_contents = get_unaligned_le16(break_reg);
456 	r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
457 			ch341_break_reg, reg_contents);
458 	if (r < 0)
459 		dev_err(&port->dev, "%s - USB control write error (%d)\n",
460 				__func__, r);
461 out:
462 	kfree(break_reg);
463 }
464 
465 static int ch341_tiocmset(struct tty_struct *tty,
466 			  unsigned int set, unsigned int clear)
467 {
468 	struct usb_serial_port *port = tty->driver_data;
469 	struct ch341_private *priv = usb_get_serial_port_data(port);
470 	unsigned long flags;
471 	u8 control;
472 
473 	spin_lock_irqsave(&priv->lock, flags);
474 	if (set & TIOCM_RTS)
475 		priv->mcr |= CH341_BIT_RTS;
476 	if (set & TIOCM_DTR)
477 		priv->mcr |= CH341_BIT_DTR;
478 	if (clear & TIOCM_RTS)
479 		priv->mcr &= ~CH341_BIT_RTS;
480 	if (clear & TIOCM_DTR)
481 		priv->mcr &= ~CH341_BIT_DTR;
482 	control = priv->mcr;
483 	spin_unlock_irqrestore(&priv->lock, flags);
484 
485 	return ch341_set_handshake(port->serial->dev, control);
486 }
487 
488 static void ch341_update_status(struct usb_serial_port *port,
489 					unsigned char *data, size_t len)
490 {
491 	struct ch341_private *priv = usb_get_serial_port_data(port);
492 	struct tty_struct *tty;
493 	unsigned long flags;
494 	u8 status;
495 	u8 delta;
496 
497 	if (len < 4)
498 		return;
499 
500 	status = ~data[2] & CH341_BITS_MODEM_STAT;
501 
502 	spin_lock_irqsave(&priv->lock, flags);
503 	delta = status ^ priv->msr;
504 	priv->msr = status;
505 	spin_unlock_irqrestore(&priv->lock, flags);
506 
507 	if (data[1] & CH341_MULT_STAT)
508 		dev_dbg(&port->dev, "%s - multiple status change\n", __func__);
509 
510 	if (!delta)
511 		return;
512 
513 	if (delta & CH341_BIT_CTS)
514 		port->icount.cts++;
515 	if (delta & CH341_BIT_DSR)
516 		port->icount.dsr++;
517 	if (delta & CH341_BIT_RI)
518 		port->icount.rng++;
519 	if (delta & CH341_BIT_DCD) {
520 		port->icount.dcd++;
521 		tty = tty_port_tty_get(&port->port);
522 		if (tty) {
523 			usb_serial_handle_dcd_change(port, tty,
524 						status & CH341_BIT_DCD);
525 			tty_kref_put(tty);
526 		}
527 	}
528 
529 	wake_up_interruptible(&port->port.delta_msr_wait);
530 }
531 
532 static void ch341_read_int_callback(struct urb *urb)
533 {
534 	struct usb_serial_port *port = urb->context;
535 	unsigned char *data = urb->transfer_buffer;
536 	unsigned int len = urb->actual_length;
537 	int status;
538 
539 	switch (urb->status) {
540 	case 0:
541 		/* success */
542 		break;
543 	case -ECONNRESET:
544 	case -ENOENT:
545 	case -ESHUTDOWN:
546 		/* this urb is terminated, clean up */
547 		dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
548 			__func__, urb->status);
549 		return;
550 	default:
551 		dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
552 			__func__, urb->status);
553 		goto exit;
554 	}
555 
556 	usb_serial_debug_data(&port->dev, __func__, len, data);
557 	ch341_update_status(port, data, len);
558 exit:
559 	status = usb_submit_urb(urb, GFP_ATOMIC);
560 	if (status) {
561 		dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n",
562 			__func__, status);
563 	}
564 }
565 
566 static int ch341_tiocmget(struct tty_struct *tty)
567 {
568 	struct usb_serial_port *port = tty->driver_data;
569 	struct ch341_private *priv = usb_get_serial_port_data(port);
570 	unsigned long flags;
571 	u8 mcr;
572 	u8 status;
573 	unsigned int result;
574 
575 	spin_lock_irqsave(&priv->lock, flags);
576 	mcr = priv->mcr;
577 	status = priv->msr;
578 	spin_unlock_irqrestore(&priv->lock, flags);
579 
580 	result = ((mcr & CH341_BIT_DTR)		? TIOCM_DTR : 0)
581 		  | ((mcr & CH341_BIT_RTS)	? TIOCM_RTS : 0)
582 		  | ((status & CH341_BIT_CTS)	? TIOCM_CTS : 0)
583 		  | ((status & CH341_BIT_DSR)	? TIOCM_DSR : 0)
584 		  | ((status & CH341_BIT_RI)	? TIOCM_RI  : 0)
585 		  | ((status & CH341_BIT_DCD)	? TIOCM_CD  : 0);
586 
587 	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
588 
589 	return result;
590 }
591 
592 static int ch341_reset_resume(struct usb_serial *serial)
593 {
594 	struct usb_serial_port *port = serial->port[0];
595 	struct ch341_private *priv = usb_get_serial_port_data(port);
596 	int ret;
597 
598 	/* reconfigure ch341 serial port after bus-reset */
599 	ch341_configure(serial->dev, priv);
600 
601 	if (tty_port_initialized(&port->port)) {
602 		ret = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
603 		if (ret) {
604 			dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
605 				ret);
606 			return ret;
607 		}
608 
609 		ret = ch341_get_status(port->serial->dev, priv);
610 		if (ret < 0) {
611 			dev_err(&port->dev, "failed to read modem status: %d\n",
612 				ret);
613 		}
614 	}
615 
616 	return usb_serial_generic_resume(serial);
617 }
618 
619 static struct usb_serial_driver ch341_device = {
620 	.driver = {
621 		.owner	= THIS_MODULE,
622 		.name	= "ch341-uart",
623 	},
624 	.id_table          = id_table,
625 	.num_ports         = 1,
626 	.open              = ch341_open,
627 	.dtr_rts	   = ch341_dtr_rts,
628 	.carrier_raised	   = ch341_carrier_raised,
629 	.close             = ch341_close,
630 	.set_termios       = ch341_set_termios,
631 	.break_ctl         = ch341_break_ctl,
632 	.tiocmget          = ch341_tiocmget,
633 	.tiocmset          = ch341_tiocmset,
634 	.tiocmiwait        = usb_serial_generic_tiocmiwait,
635 	.read_int_callback = ch341_read_int_callback,
636 	.port_probe        = ch341_port_probe,
637 	.port_remove       = ch341_port_remove,
638 	.reset_resume      = ch341_reset_resume,
639 };
640 
641 static struct usb_serial_driver * const serial_drivers[] = {
642 	&ch341_device, NULL
643 };
644 
645 module_usb_serial_driver(serial_drivers, id_table);
646 
647 MODULE_LICENSE("GPL");
648