Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/usb/serial/ch341.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us