blob: 59eff721fcc5bb1e3374b1bfd098b0a67b558ddc [file] [log] [blame]
Frank A Kingswood6ce76102007-08-22 20:48:58 +01001/*
2 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
Werner Cornelius664d5df2009-01-16 21:02:41 +01003 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
4 * Copyright 2009, Boris Hajduk <boris@hajduk.org>
Frank A Kingswood6ce76102007-08-22 20:48:58 +01005 *
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
Werner Cornelius664d5df2009-01-16 21:02:41 +010026#define DEFAULT_BAUD_RATE 9600
Frank A Kingswood6ce76102007-08-22 20:48:58 +010027#define DEFAULT_TIMEOUT 1000
28
Werner Cornelius664d5df2009-01-16 21:02:41 +010029/* 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
Tim Small492896f2009-08-17 13:21:57 +010059/* Break support - the information used to implement this was gleaned from
60 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato.
61 */
62
63#define CH341_REQ_WRITE_REG 0x9A
64#define CH341_REQ_READ_REG 0x95
65#define CH341_REG_BREAK1 0x05
66#define CH341_REG_BREAK2 0x18
67#define CH341_NBREAK_BITS_REG1 0x01
68#define CH341_NBREAK_BITS_REG2 0x40
69
70
Frank A Kingswood6ce76102007-08-22 20:48:58 +010071static int debug;
72
73static struct usb_device_id id_table [] = {
74 { USB_DEVICE(0x4348, 0x5523) },
Michael F. Robbins82078232008-05-16 23:48:42 -040075 { USB_DEVICE(0x1a86, 0x7523) },
Frank A Kingswood6ce76102007-08-22 20:48:58 +010076 { },
77};
78MODULE_DEVICE_TABLE(usb, id_table);
79
80struct ch341_private {
Werner Cornelius664d5df2009-01-16 21:02:41 +010081 spinlock_t lock; /* access lock */
82 wait_queue_head_t delta_msr_wait; /* wait queue for modem status */
83 unsigned baud_rate; /* set baud rate */
84 u8 line_control; /* set line control value RTS/DTR */
85 u8 line_status; /* active status of modem control inputs */
86 u8 multi_status_change; /* status changed multiple since last call */
Frank A Kingswood6ce76102007-08-22 20:48:58 +010087};
88
89static int ch341_control_out(struct usb_device *dev, u8 request,
90 u16 value, u16 index)
91{
92 int r;
93 dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT|0x40,
94 (int)request, (int)value, (int)index);
95
96 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
97 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
98 value, index, NULL, 0, DEFAULT_TIMEOUT);
99
100 return r;
101}
102
103static int ch341_control_in(struct usb_device *dev,
104 u8 request, u16 value, u16 index,
105 char *buf, unsigned bufsize)
106{
107 int r;
108 dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN|0x40,
109 (int)request, (int)value, (int)index, buf, (int)bufsize);
110
111 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
112 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
113 value, index, buf, bufsize, DEFAULT_TIMEOUT);
114 return r;
115}
116
Adrian Bunk93b64972007-09-09 22:25:04 +0200117static int ch341_set_baudrate(struct usb_device *dev,
118 struct ch341_private *priv)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100119{
120 short a, b;
121 int r;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100122 unsigned long factor;
123 short divisor;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100124
125 dbg("ch341_set_baudrate(%d)", priv->baud_rate);
Werner Cornelius664d5df2009-01-16 21:02:41 +0100126
127 if (!priv->baud_rate)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100128 return -EINVAL;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100129 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
130 divisor = CH341_BAUDBASE_DIVMAX;
131
132 while ((factor > 0xfff0) && divisor) {
133 factor >>= 3;
134 divisor--;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100135 }
136
Werner Cornelius664d5df2009-01-16 21:02:41 +0100137 if (factor > 0xfff0)
138 return -EINVAL;
139
140 factor = 0x10000 - factor;
141 a = (factor & 0xff00) | divisor;
142 b = factor & 0xff;
143
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100144 r = ch341_control_out(dev, 0x9a, 0x1312, a);
145 if (!r)
146 r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
147
148 return r;
149}
150
Werner Cornelius664d5df2009-01-16 21:02:41 +0100151static int ch341_set_handshake(struct usb_device *dev, u8 control)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100152{
Werner Cornelius664d5df2009-01-16 21:02:41 +0100153 dbg("ch341_set_handshake(0x%02x)", control);
154 return ch341_control_out(dev, 0xa4, ~control, 0);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100155}
156
Werner Cornelius664d5df2009-01-16 21:02:41 +0100157static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100158{
159 char *buffer;
160 int r;
161 const unsigned size = 8;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100162 unsigned long flags;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100163
164 dbg("ch341_get_status()");
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);
Alan Coxc4d0f8c2008-04-29 14:35:39 +0100171 if (r < 0)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100172 goto out;
173
Werner Cornelius664d5df2009-01-16 21:02:41 +0100174 /* 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 priv->multi_status_change = 0;
180 spin_unlock_irqrestore(&priv->lock, flags);
181 } else
182 r = -EPROTO;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100183
184out: kfree(buffer);
185 return r;
186}
187
188/* -------------------------------------------------------------------------- */
189
Adrian Bunk93b64972007-09-09 22:25:04 +0200190static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100191{
192 char *buffer;
193 int r;
194 const unsigned size = 8;
195
196 dbg("ch341_configure()");
197
198 buffer = kmalloc(size, GFP_KERNEL);
199 if (!buffer)
200 return -ENOMEM;
201
202 /* expect two bytes 0x27 0x00 */
203 r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
204 if (r < 0)
205 goto out;
206
207 r = ch341_control_out(dev, 0xa1, 0, 0);
208 if (r < 0)
209 goto out;
210
211 r = ch341_set_baudrate(dev, priv);
212 if (r < 0)
213 goto out;
214
215 /* expect two bytes 0x56 0x00 */
216 r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
217 if (r < 0)
218 goto out;
219
220 r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
221 if (r < 0)
222 goto out;
223
224 /* expect 0xff 0xee */
Werner Cornelius664d5df2009-01-16 21:02:41 +0100225 r = ch341_get_status(dev, priv);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100226 if (r < 0)
227 goto out;
228
229 r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
230 if (r < 0)
231 goto out;
232
233 r = ch341_set_baudrate(dev, priv);
234 if (r < 0)
235 goto out;
236
Werner Cornelius664d5df2009-01-16 21:02:41 +0100237 r = ch341_set_handshake(dev, priv->line_control);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100238 if (r < 0)
239 goto out;
240
241 /* expect 0x9f 0xee */
Werner Cornelius664d5df2009-01-16 21:02:41 +0100242 r = ch341_get_status(dev, priv);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100243
244out: kfree(buffer);
245 return r;
246}
247
248/* allocate private data */
249static int ch341_attach(struct usb_serial *serial)
250{
251 struct ch341_private *priv;
252 int r;
253
254 dbg("ch341_attach()");
255
256 /* private data */
257 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
258 if (!priv)
259 return -ENOMEM;
260
Werner Cornelius664d5df2009-01-16 21:02:41 +0100261 spin_lock_init(&priv->lock);
262 init_waitqueue_head(&priv->delta_msr_wait);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100263 priv->baud_rate = DEFAULT_BAUD_RATE;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100264 priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100265
266 r = ch341_configure(serial->dev, priv);
267 if (r < 0)
268 goto error;
269
270 usb_set_serial_port_data(serial->port[0], priv);
271 return 0;
272
273error: kfree(priv);
274 return r;
275}
276
Alan Cox335f8512009-06-11 12:26:29 +0100277static int ch341_carrier_raised(struct usb_serial_port *port)
278{
279 struct ch341_private *priv = usb_get_serial_port_data(port);
280 if (priv->line_status & CH341_BIT_DCD)
281 return 1;
282 return 0;
283}
284
285static void ch341_dtr_rts(struct usb_serial_port *port, int on)
Werner Cornelius664d5df2009-01-16 21:02:41 +0100286{
287 struct ch341_private *priv = usb_get_serial_port_data(port);
288 unsigned long flags;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100289
290 dbg("%s - port %d", __func__, port->number);
Alan Cox335f8512009-06-11 12:26:29 +0100291 /* drop DTR and RTS */
292 spin_lock_irqsave(&priv->lock, flags);
293 if (on)
294 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
295 else
296 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
297 spin_unlock_irqrestore(&priv->lock, flags);
298 ch341_set_handshake(port->serial->dev, priv->line_control);
299 wake_up_interruptible(&priv->delta_msr_wait);
300}
301
302static void ch341_close(struct usb_serial_port *port)
303{
304 dbg("%s - port %d", __func__, port->number);
Werner Cornelius664d5df2009-01-16 21:02:41 +0100305
306 /* shutdown our urbs */
307 dbg("%s - shutting down urbs", __func__);
308 usb_kill_urb(port->write_urb);
309 usb_kill_urb(port->read_urb);
310 usb_kill_urb(port->interrupt_in_urb);
Werner Cornelius664d5df2009-01-16 21:02:41 +0100311}
312
313
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100314/* open this device, set default parameters */
Alan Coxa509a7e2009-09-19 13:13:26 -0700315static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100316{
317 struct usb_serial *serial = port->serial;
318 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
319 int r;
320
321 dbg("ch341_open()");
322
323 priv->baud_rate = DEFAULT_BAUD_RATE;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100324
325 r = ch341_configure(serial->dev, priv);
326 if (r)
327 goto out;
328
Werner Cornelius664d5df2009-01-16 21:02:41 +0100329 r = ch341_set_handshake(serial->dev, priv->line_control);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100330 if (r)
331 goto out;
332
333 r = ch341_set_baudrate(serial->dev, priv);
334 if (r)
335 goto out;
336
Werner Cornelius664d5df2009-01-16 21:02:41 +0100337 dbg("%s - submitting interrupt urb", __func__);
338 port->interrupt_in_urb->dev = serial->dev;
339 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
340 if (r) {
341 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
342 " error %d\n", __func__, r);
Alan Cox335f8512009-06-11 12:26:29 +0100343 ch341_close(port);
Werner Cornelius664d5df2009-01-16 21:02:41 +0100344 return -EPROTO;
345 }
346
Alan Coxa509a7e2009-09-19 13:13:26 -0700347 r = usb_serial_generic_open(tty, port);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100348
349out: return r;
350}
351
352/* Old_termios contains the original termios settings and
353 * tty->termios contains the new setting to be used.
354 */
Alan Cox95da3102008-07-22 11:09:07 +0100355static void ch341_set_termios(struct tty_struct *tty,
356 struct usb_serial_port *port, struct ktermios *old_termios)
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100357{
358 struct ch341_private *priv = usb_get_serial_port_data(port);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100359 unsigned baud_rate;
Werner Cornelius664d5df2009-01-16 21:02:41 +0100360 unsigned long flags;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100361
362 dbg("ch341_set_termios()");
363
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100364 baud_rate = tty_get_baud_rate(tty);
365
Werner Cornelius664d5df2009-01-16 21:02:41 +0100366 priv->baud_rate = baud_rate;
367
368 if (baud_rate) {
369 spin_lock_irqsave(&priv->lock, flags);
370 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
371 spin_unlock_irqrestore(&priv->lock, flags);
372 ch341_set_baudrate(port->serial->dev, priv);
373 } else {
374 spin_lock_irqsave(&priv->lock, flags);
375 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
376 spin_unlock_irqrestore(&priv->lock, flags);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100377 }
378
Werner Cornelius664d5df2009-01-16 21:02:41 +0100379 ch341_set_handshake(port->serial->dev, priv->line_control);
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100380
381 /* Unimplemented:
382 * (cflag & CSIZE) : data bits [5, 8]
383 * (cflag & PARENB) : parity {NONE, EVEN, ODD}
384 * (cflag & CSTOPB) : stop bits [1, 2]
385 */
Werner Cornelius664d5df2009-01-16 21:02:41 +0100386}
Alan Cox73f59302007-10-18 01:24:18 -0700387
Tim Small492896f2009-08-17 13:21:57 +0100388static void ch341_break_ctl(struct tty_struct *tty, int break_state)
389{
390 const uint16_t ch341_break_reg =
391 CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
392 struct usb_serial_port *port = tty->driver_data;
393 int r;
394 uint16_t reg_contents;
395 uint8_t break_reg[2];
396
397 dbg("%s()", __func__);
398
399 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
400 ch341_break_reg, 0, break_reg, sizeof(break_reg));
401 if (r < 0) {
402 printk(KERN_WARNING "%s: USB control read error whilst getting"
403 " break register contents.\n", __FILE__);
404 return;
405 }
406 dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
407 __func__, break_reg[0], break_reg[1]);
408 if (break_state != 0) {
409 dbg("%s - Enter break state requested", __func__);
410 break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
411 break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
412 } else {
413 dbg("%s - Leave break state requested", __func__);
414 break_reg[0] |= CH341_NBREAK_BITS_REG1;
415 break_reg[1] |= CH341_NBREAK_BITS_REG2;
416 }
417 dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
418 __func__, break_reg[0], break_reg[1]);
419 reg_contents = (uint16_t)break_reg[0] | ((uint16_t)break_reg[1] << 8);
420 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
421 ch341_break_reg, reg_contents);
422 if (r < 0)
423 printk(KERN_WARNING "%s: USB control write error whilst setting"
424 " break register contents.\n", __FILE__);
425}
426
Werner Cornelius664d5df2009-01-16 21:02:41 +0100427static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
428 unsigned int set, unsigned int clear)
429{
430 struct usb_serial_port *port = tty->driver_data;
431 struct ch341_private *priv = usb_get_serial_port_data(port);
432 unsigned long flags;
433 u8 control;
434
435 spin_lock_irqsave(&priv->lock, flags);
436 if (set & TIOCM_RTS)
437 priv->line_control |= CH341_BIT_RTS;
438 if (set & TIOCM_DTR)
439 priv->line_control |= CH341_BIT_DTR;
440 if (clear & TIOCM_RTS)
441 priv->line_control &= ~CH341_BIT_RTS;
442 if (clear & TIOCM_DTR)
443 priv->line_control &= ~CH341_BIT_DTR;
444 control = priv->line_control;
445 spin_unlock_irqrestore(&priv->lock, flags);
446
447 return ch341_set_handshake(port->serial->dev, control);
448}
449
450static void ch341_read_int_callback(struct urb *urb)
451{
452 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
453 unsigned char *data = urb->transfer_buffer;
454 unsigned int actual_length = urb->actual_length;
455 int status;
456
457 dbg("%s (%d)", __func__, port->number);
458
459 switch (urb->status) {
460 case 0:
461 /* success */
462 break;
463 case -ECONNRESET:
464 case -ENOENT:
465 case -ESHUTDOWN:
466 /* this urb is terminated, clean up */
467 dbg("%s - urb shutting down with status: %d", __func__,
468 urb->status);
469 return;
470 default:
471 dbg("%s - nonzero urb status received: %d", __func__,
472 urb->status);
473 goto exit;
474 }
475
476 usb_serial_debug_data(debug, &port->dev, __func__,
477 urb->actual_length, urb->transfer_buffer);
478
479 if (actual_length >= 4) {
480 struct ch341_private *priv = usb_get_serial_port_data(port);
481 unsigned long flags;
482
483 spin_lock_irqsave(&priv->lock, flags);
484 priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
485 if ((data[1] & CH341_MULT_STAT))
486 priv->multi_status_change = 1;
487 spin_unlock_irqrestore(&priv->lock, flags);
488 wake_up_interruptible(&priv->delta_msr_wait);
489 }
490
491exit:
492 status = usb_submit_urb(urb, GFP_ATOMIC);
493 if (status)
494 dev_err(&urb->dev->dev,
495 "%s - usb_submit_urb failed with result %d\n",
496 __func__, status);
497}
498
499static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
500{
501 struct ch341_private *priv = usb_get_serial_port_data(port);
502 unsigned long flags;
503 u8 prevstatus;
504 u8 status;
505 u8 changed;
506 u8 multi_change = 0;
507
508 spin_lock_irqsave(&priv->lock, flags);
509 prevstatus = priv->line_status;
510 priv->multi_status_change = 0;
511 spin_unlock_irqrestore(&priv->lock, flags);
512
513 while (!multi_change) {
514 interruptible_sleep_on(&priv->delta_msr_wait);
515 /* see if a signal did it */
516 if (signal_pending(current))
517 return -ERESTARTSYS;
518
519 spin_lock_irqsave(&priv->lock, flags);
520 status = priv->line_status;
521 multi_change = priv->multi_status_change;
522 spin_unlock_irqrestore(&priv->lock, flags);
523
524 changed = prevstatus ^ status;
525
526 if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) ||
527 ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) ||
528 ((arg & TIOCM_CD) && (changed & CH341_BIT_DCD)) ||
529 ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
530 return 0;
531 }
532 prevstatus = status;
533 }
534
535 return 0;
536}
537
538/*static int ch341_ioctl(struct usb_serial_port *port, struct file *file,*/
539static int ch341_ioctl(struct tty_struct *tty, struct file *file,
540 unsigned int cmd, unsigned long arg)
541{
542 struct usb_serial_port *port = tty->driver_data;
543 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
544
545 switch (cmd) {
546 case TIOCMIWAIT:
547 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
548 return wait_modem_info(port, arg);
549
550 default:
551 dbg("%s not supported = 0x%04x", __func__, cmd);
552 break;
553 }
554
555 return -ENOIOCTLCMD;
556}
557
558static int ch341_tiocmget(struct tty_struct *tty, struct file *file)
559{
560 struct usb_serial_port *port = tty->driver_data;
561 struct ch341_private *priv = usb_get_serial_port_data(port);
562 unsigned long flags;
563 u8 mcr;
564 u8 status;
565 unsigned int result;
566
567 dbg("%s (%d)", __func__, port->number);
568
569 spin_lock_irqsave(&priv->lock, flags);
570 mcr = priv->line_control;
571 status = priv->line_status;
572 spin_unlock_irqrestore(&priv->lock, flags);
573
574 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0)
575 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0)
576 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0)
577 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0)
578 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0)
579 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0);
580
581 dbg("%s - result = %x", __func__, result);
582
583 return result;
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100584}
585
Ming Lei1ded7ea2009-02-20 21:23:09 +0800586
587static int ch341_reset_resume(struct usb_interface *intf)
588{
589 struct usb_device *dev = interface_to_usbdev(intf);
590 struct usb_serial *serial = NULL;
591 struct ch341_private *priv;
592
593 serial = usb_get_intfdata(intf);
594 priv = usb_get_serial_port_data(serial->port[0]);
595
596 /*reconfigure ch341 serial port after bus-reset*/
597 ch341_configure(dev, priv);
598
599 usb_serial_resume(intf);
600
601 return 0;
602}
603
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100604static struct usb_driver ch341_driver = {
605 .name = "ch341",
606 .probe = usb_serial_probe,
607 .disconnect = usb_serial_disconnect,
Ming Lei1ded7ea2009-02-20 21:23:09 +0800608 .suspend = usb_serial_suspend,
609 .resume = usb_serial_resume,
610 .reset_resume = ch341_reset_resume,
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100611 .id_table = id_table,
612 .no_dynamic_id = 1,
Ming Lei1ded7ea2009-02-20 21:23:09 +0800613 .supports_autosuspend = 1,
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100614};
615
616static struct usb_serial_driver ch341_device = {
617 .driver = {
618 .owner = THIS_MODULE,
619 .name = "ch341-uart",
620 },
Werner Cornelius664d5df2009-01-16 21:02:41 +0100621 .id_table = id_table,
622 .usb_driver = &ch341_driver,
623 .num_ports = 1,
624 .open = ch341_open,
Alan Cox335f8512009-06-11 12:26:29 +0100625 .dtr_rts = ch341_dtr_rts,
626 .carrier_raised = ch341_carrier_raised,
Werner Cornelius664d5df2009-01-16 21:02:41 +0100627 .close = ch341_close,
628 .ioctl = ch341_ioctl,
629 .set_termios = ch341_set_termios,
Tim Small492896f2009-08-17 13:21:57 +0100630 .break_ctl = ch341_break_ctl,
Werner Cornelius664d5df2009-01-16 21:02:41 +0100631 .tiocmget = ch341_tiocmget,
632 .tiocmset = ch341_tiocmset,
633 .read_int_callback = ch341_read_int_callback,
634 .attach = ch341_attach,
Frank A Kingswood6ce76102007-08-22 20:48:58 +0100635};
636
637static int __init ch341_init(void)
638{
639 int retval;
640
641 retval = usb_serial_register(&ch341_device);
642 if (retval)
643 return retval;
644 retval = usb_register(&ch341_driver);
645 if (retval)
646 usb_serial_deregister(&ch341_device);
647 return retval;
648}
649
650static void __exit ch341_exit(void)
651{
652 usb_deregister(&ch341_driver);
653 usb_serial_deregister(&ch341_device);
654}
655
656module_init(ch341_init);
657module_exit(ch341_exit);
658MODULE_LICENSE("GPL");
659
660module_param(debug, bool, S_IRUGO | S_IWUSR);
661MODULE_PARM_DESC(debug, "Debug enabled or not");
662
663/* EOF ch341.c */