1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/kernel.h>
26#include <linux/init.h>
27#include <linux/ioctl.h>
28#include <linux/tty.h>
29#include <linux/slab.h>
30#include <linux/tty_flip.h>
31#include <linux/module.h>
32#include <linux/usb.h>
33#include <linux/usb/serial.h>
34#include <linux/serial.h>
35#include <linux/serial_reg.h>
36#include <linux/uaccess.h>
37#include <linux/mutex.h>
38#include <linux/spinlock.h>
39
40static int debug;
41
42
43
44
45#define DRIVER_VERSION "v0.6"
46#define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
47#define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
48#define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
49#define DRIVER_NAME "ark3116"
50
51
52#define ARK_TIMEOUT (1*HZ)
53
54static const struct usb_device_id id_table[] = {
55 { USB_DEVICE(0x6547, 0x0232) },
56 { USB_DEVICE(0x18ec, 0x3118) },
57 { },
58};
59MODULE_DEVICE_TABLE(usb, id_table);
60
61static int is_irda(struct usb_serial *serial)
62{
63 struct usb_device *dev = serial->dev;
64 if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
65 le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
66 return 1;
67 return 0;
68}
69
70struct ark3116_private {
71 wait_queue_head_t delta_msr_wait;
72 struct async_icount icount;
73 int irda;
74
75
76 struct mutex hw_lock;
77
78 int quot;
79 __u32 lcr;
80 __u32 hcr;
81
82 __u32 mcr;
83
84
85 spinlock_t status_lock;
86 __u32 msr;
87 __u32 lsr;
88};
89
90static int ark3116_write_reg(struct usb_serial *serial,
91 unsigned reg, __u8 val)
92{
93 int result;
94
95 result = usb_control_msg(serial->dev,
96 usb_sndctrlpipe(serial->dev, 0),
97 0xfe, 0x40, val, reg,
98 NULL, 0, ARK_TIMEOUT);
99 return result;
100}
101
102static int ark3116_read_reg(struct usb_serial *serial,
103 unsigned reg, unsigned char *buf)
104{
105 int result;
106
107 result = usb_control_msg(serial->dev,
108 usb_rcvctrlpipe(serial->dev, 0),
109 0xfe, 0xc0, 0, reg,
110 buf, 1, ARK_TIMEOUT);
111 if (result < 0)
112 return result;
113 else
114 return buf[0];
115}
116
117static inline int calc_divisor(int bps)
118{
119
120
121
122
123
124 return (12000000 + 2*bps) / (4*bps);
125}
126
127static int ark3116_attach(struct usb_serial *serial)
128{
129 struct usb_serial_port *port = serial->port[0];
130 struct ark3116_private *priv;
131
132
133 if ((serial->num_bulk_in == 0) ||
134 (serial->num_bulk_out == 0) ||
135 (serial->num_interrupt_in == 0)) {
136 dev_err(&serial->dev->dev,
137 "%s - missing endpoint - "
138 "bulk in: %d, bulk out: %d, int in %d\n",
139 KBUILD_MODNAME,
140 serial->num_bulk_in,
141 serial->num_bulk_out,
142 serial->num_interrupt_in);
143 return -EINVAL;
144 }
145
146 priv = kzalloc(sizeof(struct ark3116_private),
147 GFP_KERNEL);
148 if (!priv)
149 return -ENOMEM;
150
151 init_waitqueue_head(&priv->delta_msr_wait);
152 mutex_init(&priv->hw_lock);
153 spin_lock_init(&priv->status_lock);
154
155 priv->irda = is_irda(serial);
156
157 usb_set_serial_port_data(port, priv);
158
159
160 ark3116_write_reg(serial, UART_IER, 0);
161
162 ark3116_write_reg(serial, UART_FCR, 0);
163
164 priv->hcr = 0;
165 ark3116_write_reg(serial, 0x8 , 0);
166
167 priv->mcr = 0;
168 ark3116_write_reg(serial, UART_MCR, 0);
169
170 if (!(priv->irda)) {
171 ark3116_write_reg(serial, 0xb , 0);
172 } else {
173 ark3116_write_reg(serial, 0xb , 1);
174 ark3116_write_reg(serial, 0xc , 0);
175 ark3116_write_reg(serial, 0xd , 0x41);
176 ark3116_write_reg(serial, 0xa , 1);
177 }
178
179
180 ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB);
181
182
183 priv->quot = calc_divisor(9600);
184 ark3116_write_reg(serial, UART_DLL, priv->quot & 0xff);
185 ark3116_write_reg(serial, UART_DLM, (priv->quot>>8) & 0xff);
186
187 priv->lcr = UART_LCR_WLEN8;
188 ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8);
189
190 ark3116_write_reg(serial, 0xe, 0);
191
192 if (priv->irda)
193 ark3116_write_reg(serial, 0x9, 0);
194
195 dev_info(&serial->dev->dev,
196 "%s using %s mode\n",
197 KBUILD_MODNAME,
198 priv->irda ? "IrDA" : "RS232");
199 return 0;
200}
201
202static void ark3116_release(struct usb_serial *serial)
203{
204 struct usb_serial_port *port = serial->port[0];
205 struct ark3116_private *priv = usb_get_serial_port_data(port);
206
207
208
209 usb_set_serial_port_data(port, NULL);
210
211 mutex_destroy(&priv->hw_lock);
212
213 kfree(priv);
214}
215
216static void ark3116_init_termios(struct tty_struct *tty)
217{
218 struct ktermios *termios = tty->termios;
219 *termios = tty_std_termios;
220 termios->c_cflag = B9600 | CS8
221 | CREAD | HUPCL | CLOCAL;
222 termios->c_ispeed = 9600;
223 termios->c_ospeed = 9600;
224}
225
226static void ark3116_set_termios(struct tty_struct *tty,
227 struct usb_serial_port *port,
228 struct ktermios *old_termios)
229{
230 struct usb_serial *serial = port->serial;
231 struct ark3116_private *priv = usb_get_serial_port_data(port);
232 struct ktermios *termios = tty->termios;
233 unsigned int cflag = termios->c_cflag;
234 int bps = tty_get_baud_rate(tty);
235 int quot;
236 __u8 lcr, hcr, eval;
237
238
239 switch (cflag & CSIZE) {
240 case CS5:
241 lcr = UART_LCR_WLEN5;
242 break;
243 case CS6:
244 lcr = UART_LCR_WLEN6;
245 break;
246 case CS7:
247 lcr = UART_LCR_WLEN7;
248 break;
249 default:
250 case CS8:
251 lcr = UART_LCR_WLEN8;
252 break;
253 }
254 if (cflag & CSTOPB)
255 lcr |= UART_LCR_STOP;
256 if (cflag & PARENB)
257 lcr |= UART_LCR_PARITY;
258 if (!(cflag & PARODD))
259 lcr |= UART_LCR_EPAR;
260#ifdef CMSPAR
261 if (cflag & CMSPAR)
262 lcr |= UART_LCR_SPAR;
263#endif
264
265 hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
266
267
268 dbg("%s - setting bps to %d", __func__, bps);
269 eval = 0;
270 switch (bps) {
271 case 0:
272 quot = calc_divisor(9600);
273 break;
274 default:
275 if ((bps < 75) || (bps > 3000000))
276 bps = 9600;
277 quot = calc_divisor(bps);
278 break;
279 case 460800:
280 eval = 1;
281 quot = calc_divisor(bps);
282 break;
283 case 921600:
284 eval = 2;
285 quot = calc_divisor(bps);
286 break;
287 }
288
289
290 mutex_lock(&priv->hw_lock);
291
292
293 lcr |= (priv->lcr & UART_LCR_SBC);
294
295 dbg("%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d",
296 __func__, hcr, lcr, quot);
297
298
299 if (priv->hcr != hcr) {
300 priv->hcr = hcr;
301 ark3116_write_reg(serial, 0x8, hcr);
302 }
303
304
305 if (priv->quot != quot) {
306 priv->quot = quot;
307 priv->lcr = lcr;
308
309
310
311
312 ark3116_write_reg(serial, UART_FCR, 0);
313
314 ark3116_write_reg(serial, UART_LCR,
315 lcr|UART_LCR_DLAB);
316 ark3116_write_reg(serial, UART_DLL, quot & 0xff);
317 ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
318
319
320 ark3116_write_reg(serial, UART_LCR, lcr);
321
322
323
324 ark3116_write_reg(serial, 0xe, eval);
325
326
327 ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
328 } else if (priv->lcr != lcr) {
329 priv->lcr = lcr;
330 ark3116_write_reg(serial, UART_LCR, lcr);
331 }
332
333 mutex_unlock(&priv->hw_lock);
334
335
336 if (I_IXOFF(tty) || I_IXON(tty)) {
337 dev_warn(&serial->dev->dev,
338 "%s: don't know how to do software flow control\n",
339 KBUILD_MODNAME);
340 }
341
342
343 if (tty_termios_baud_rate(termios))
344 tty_termios_encode_baud_rate(termios, bps, bps);
345}
346
347static void ark3116_close(struct usb_serial_port *port)
348{
349 struct usb_serial *serial = port->serial;
350
351 if (serial->dev) {
352
353 ark3116_write_reg(serial, UART_FCR, 0);
354
355
356 ark3116_write_reg(serial, UART_IER, 0);
357
358 usb_serial_generic_close(port);
359 if (serial->num_interrupt_in)
360 usb_kill_urb(port->interrupt_in_urb);
361 }
362
363}
364
365static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
366{
367 struct ark3116_private *priv = usb_get_serial_port_data(port);
368 struct usb_serial *serial = port->serial;
369 unsigned char *buf;
370 int result;
371
372 buf = kmalloc(1, GFP_KERNEL);
373 if (buf == NULL)
374 return -ENOMEM;
375
376 result = usb_serial_generic_open(tty, port);
377 if (result) {
378 dbg("%s - usb_serial_generic_open failed: %d",
379 __func__, result);
380 goto err_out;
381 }
382
383
384 if (tty)
385 ark3116_set_termios(tty, port, NULL);
386
387
388 ark3116_read_reg(serial, UART_RX, buf);
389
390
391 priv->msr = ark3116_read_reg(serial, UART_MSR, buf);
392
393 priv->lsr = ark3116_read_reg(serial, UART_LSR, buf);
394
395 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
396 if (result) {
397 dev_err(&port->dev, "submit irq_in urb failed %d\n",
398 result);
399 ark3116_close(port);
400 goto err_out;
401 }
402
403
404 ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
405
406
407 ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
408
409err_out:
410 kfree(buf);
411 return result;
412}
413
414static int ark3116_get_icount(struct tty_struct *tty,
415 struct serial_icounter_struct *icount)
416{
417 struct usb_serial_port *port = tty->driver_data;
418 struct ark3116_private *priv = usb_get_serial_port_data(port);
419 struct async_icount cnow = priv->icount;
420 icount->cts = cnow.cts;
421 icount->dsr = cnow.dsr;
422 icount->rng = cnow.rng;
423 icount->dcd = cnow.dcd;
424 icount->rx = cnow.rx;
425 icount->tx = cnow.tx;
426 icount->frame = cnow.frame;
427 icount->overrun = cnow.overrun;
428 icount->parity = cnow.parity;
429 icount->brk = cnow.brk;
430 icount->buf_overrun = cnow.buf_overrun;
431 return 0;
432}
433
434static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
435 unsigned int cmd, unsigned long arg)
436{
437 struct usb_serial_port *port = tty->driver_data;
438 struct ark3116_private *priv = usb_get_serial_port_data(port);
439 struct serial_struct serstruct;
440 void __user *user_arg = (void __user *)arg;
441
442 switch (cmd) {
443 case TIOCGSERIAL:
444
445 memset(&serstruct, 0, sizeof(serstruct));
446 serstruct.type = PORT_16654;
447 serstruct.line = port->serial->minor;
448 serstruct.port = port->number;
449 serstruct.custom_divisor = 0;
450 serstruct.baud_base = 460800;
451
452 if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
453 return -EFAULT;
454
455 return 0;
456 case TIOCSSERIAL:
457 if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
458 return -EFAULT;
459 return 0;
460 case TIOCMIWAIT:
461 for (;;) {
462 struct async_icount prev = priv->icount;
463 interruptible_sleep_on(&priv->delta_msr_wait);
464
465 if (signal_pending(current))
466 return -ERESTARTSYS;
467 if ((prev.rng == priv->icount.rng) &&
468 (prev.dsr == priv->icount.dsr) &&
469 (prev.dcd == priv->icount.dcd) &&
470 (prev.cts == priv->icount.cts))
471 return -EIO;
472 if ((arg & TIOCM_RNG &&
473 (prev.rng != priv->icount.rng)) ||
474 (arg & TIOCM_DSR &&
475 (prev.dsr != priv->icount.dsr)) ||
476 (arg & TIOCM_CD &&
477 (prev.dcd != priv->icount.dcd)) ||
478 (arg & TIOCM_CTS &&
479 (prev.cts != priv->icount.cts)))
480 return 0;
481 }
482 break;
483 }
484
485 return -ENOIOCTLCMD;
486}
487
488static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
489{
490 struct usb_serial_port *port = tty->driver_data;
491 struct ark3116_private *priv = usb_get_serial_port_data(port);
492 __u32 status;
493 __u32 ctrl;
494 unsigned long flags;
495
496 mutex_lock(&priv->hw_lock);
497 ctrl = priv->mcr;
498 mutex_unlock(&priv->hw_lock);
499
500 spin_lock_irqsave(&priv->status_lock, flags);
501 status = priv->msr;
502 spin_unlock_irqrestore(&priv->status_lock, flags);
503
504 return (status & UART_MSR_DSR ? TIOCM_DSR : 0) |
505 (status & UART_MSR_CTS ? TIOCM_CTS : 0) |
506 (status & UART_MSR_RI ? TIOCM_RI : 0) |
507 (status & UART_MSR_DCD ? TIOCM_CD : 0) |
508 (ctrl & UART_MCR_DTR ? TIOCM_DTR : 0) |
509 (ctrl & UART_MCR_RTS ? TIOCM_RTS : 0) |
510 (ctrl & UART_MCR_OUT1 ? TIOCM_OUT1 : 0) |
511 (ctrl & UART_MCR_OUT2 ? TIOCM_OUT2 : 0);
512}
513
514static int ark3116_tiocmset(struct tty_struct *tty, struct file *file,
515 unsigned set, unsigned clr)
516{
517 struct usb_serial_port *port = tty->driver_data;
518 struct ark3116_private *priv = usb_get_serial_port_data(port);
519
520
521
522
523
524 mutex_lock(&priv->hw_lock);
525
526 if (set & TIOCM_RTS)
527 priv->mcr |= UART_MCR_RTS;
528 if (set & TIOCM_DTR)
529 priv->mcr |= UART_MCR_DTR;
530 if (set & TIOCM_OUT1)
531 priv->mcr |= UART_MCR_OUT1;
532 if (set & TIOCM_OUT2)
533 priv->mcr |= UART_MCR_OUT2;
534 if (clr & TIOCM_RTS)
535 priv->mcr &= ~UART_MCR_RTS;
536 if (clr & TIOCM_DTR)
537 priv->mcr &= ~UART_MCR_DTR;
538 if (clr & TIOCM_OUT1)
539 priv->mcr &= ~UART_MCR_OUT1;
540 if (clr & TIOCM_OUT2)
541 priv->mcr &= ~UART_MCR_OUT2;
542
543 ark3116_write_reg(port->serial, UART_MCR, priv->mcr);
544
545 mutex_unlock(&priv->hw_lock);
546
547 return 0;
548}
549
550static void ark3116_break_ctl(struct tty_struct *tty, int break_state)
551{
552 struct usb_serial_port *port = tty->driver_data;
553 struct ark3116_private *priv = usb_get_serial_port_data(port);
554
555
556 mutex_lock(&priv->hw_lock);
557
558 if (break_state)
559 priv->lcr |= UART_LCR_SBC;
560 else
561 priv->lcr &= ~UART_LCR_SBC;
562
563 ark3116_write_reg(port->serial, UART_LCR, priv->lcr);
564
565 mutex_unlock(&priv->hw_lock);
566}
567
568static void ark3116_update_msr(struct usb_serial_port *port, __u8 msr)
569{
570 struct ark3116_private *priv = usb_get_serial_port_data(port);
571 unsigned long flags;
572
573 spin_lock_irqsave(&priv->status_lock, flags);
574 priv->msr = msr;
575 spin_unlock_irqrestore(&priv->status_lock, flags);
576
577 if (msr & UART_MSR_ANY_DELTA) {
578
579 if (msr & UART_MSR_DCTS)
580 priv->icount.cts++;
581 if (msr & UART_MSR_DDSR)
582 priv->icount.dsr++;
583 if (msr & UART_MSR_DDCD)
584 priv->icount.dcd++;
585 if (msr & UART_MSR_TERI)
586 priv->icount.rng++;
587 wake_up_interruptible(&priv->delta_msr_wait);
588 }
589}
590
591static void ark3116_update_lsr(struct usb_serial_port *port, __u8 lsr)
592{
593 struct ark3116_private *priv = usb_get_serial_port_data(port);
594 unsigned long flags;
595
596 spin_lock_irqsave(&priv->status_lock, flags);
597
598 priv->lsr |= lsr;
599 spin_unlock_irqrestore(&priv->status_lock, flags);
600
601 if (lsr&UART_LSR_BRK_ERROR_BITS) {
602 if (lsr & UART_LSR_BI)
603 priv->icount.brk++;
604 if (lsr & UART_LSR_FE)
605 priv->icount.frame++;
606 if (lsr & UART_LSR_PE)
607 priv->icount.parity++;
608 if (lsr & UART_LSR_OE)
609 priv->icount.overrun++;
610 }
611}
612
613static void ark3116_read_int_callback(struct urb *urb)
614{
615 struct usb_serial_port *port = urb->context;
616 int status = urb->status;
617 const __u8 *data = urb->transfer_buffer;
618 int result;
619
620 switch (status) {
621 case -ECONNRESET:
622 case -ENOENT:
623 case -ESHUTDOWN:
624
625 dbg("%s - urb shutting down with status: %d",
626 __func__, status);
627 return;
628 default:
629 dbg("%s - nonzero urb status received: %d",
630 __func__, status);
631 break;
632 case 0:
633
634 if ((urb->actual_length == 4) && (data[0] == 0xe8)) {
635 const __u8 id = data[1]&UART_IIR_ID;
636 dbg("%s: iir=%02x", __func__, data[1]);
637 if (id == UART_IIR_MSI) {
638 dbg("%s: msr=%02x", __func__, data[3]);
639 ark3116_update_msr(port, data[3]);
640 break;
641 } else if (id == UART_IIR_RLSI) {
642 dbg("%s: lsr=%02x", __func__, data[2]);
643 ark3116_update_lsr(port, data[2]);
644 break;
645 }
646 }
647
648
649
650 usb_serial_debug_data(debug, &port->dev,
651 __func__,
652 urb->actual_length,
653 urb->transfer_buffer);
654 break;
655 }
656
657 result = usb_submit_urb(urb, GFP_ATOMIC);
658 if (result)
659 dev_err(&urb->dev->dev,
660 "%s - Error %d submitting interrupt urb\n",
661 __func__, result);
662}
663
664
665
666
667
668
669
670
671
672
673
674
675
676static void ark3116_process_read_urb(struct urb *urb)
677{
678 struct usb_serial_port *port = urb->context;
679 struct ark3116_private *priv = usb_get_serial_port_data(port);
680 struct tty_struct *tty;
681 unsigned char *data = urb->transfer_buffer;
682 char tty_flag = TTY_NORMAL;
683 unsigned long flags;
684 __u32 lsr;
685
686
687 spin_lock_irqsave(&priv->status_lock, flags);
688 lsr = priv->lsr;
689 priv->lsr &= ~UART_LSR_BRK_ERROR_BITS;
690 spin_unlock_irqrestore(&priv->status_lock, flags);
691
692 if (!urb->actual_length)
693 return;
694
695 tty = tty_port_tty_get(&port->port);
696 if (!tty)
697 return;
698
699 if (lsr & UART_LSR_BRK_ERROR_BITS) {
700 if (lsr & UART_LSR_BI)
701 tty_flag = TTY_BREAK;
702 else if (lsr & UART_LSR_PE)
703 tty_flag = TTY_PARITY;
704 else if (lsr & UART_LSR_FE)
705 tty_flag = TTY_FRAME;
706
707
708 if (lsr & UART_LSR_OE)
709 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
710 }
711 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
712 urb->actual_length);
713 tty_flip_buffer_push(tty);
714 tty_kref_put(tty);
715}
716
717static struct usb_driver ark3116_driver = {
718 .name = "ark3116",
719 .probe = usb_serial_probe,
720 .disconnect = usb_serial_disconnect,
721 .id_table = id_table,
722 .no_dynamic_id = 1,
723};
724
725static struct usb_serial_driver ark3116_device = {
726 .driver = {
727 .owner = THIS_MODULE,
728 .name = "ark3116",
729 },
730 .id_table = id_table,
731 .usb_driver = &ark3116_driver,
732 .num_ports = 1,
733 .attach = ark3116_attach,
734 .release = ark3116_release,
735 .set_termios = ark3116_set_termios,
736 .init_termios = ark3116_init_termios,
737 .ioctl = ark3116_ioctl,
738 .tiocmget = ark3116_tiocmget,
739 .tiocmset = ark3116_tiocmset,
740 .get_icount = ark3116_get_icount,
741 .open = ark3116_open,
742 .close = ark3116_close,
743 .break_ctl = ark3116_break_ctl,
744 .read_int_callback = ark3116_read_int_callback,
745 .process_read_urb = ark3116_process_read_urb,
746};
747
748static int __init ark3116_init(void)
749{
750 int retval;
751
752 retval = usb_serial_register(&ark3116_device);
753 if (retval)
754 return retval;
755 retval = usb_register(&ark3116_driver);
756 if (retval == 0) {
757 printk(KERN_INFO "%s:"
758 DRIVER_VERSION ":"
759 DRIVER_DESC "\n",
760 KBUILD_MODNAME);
761 } else
762 usb_serial_deregister(&ark3116_device);
763 return retval;
764}
765
766static void __exit ark3116_exit(void)
767{
768 usb_deregister(&ark3116_driver);
769 usb_serial_deregister(&ark3116_device);
770}
771
772module_init(ark3116_init);
773module_exit(ark3116_exit);
774MODULE_LICENSE("GPL");
775
776MODULE_AUTHOR(DRIVER_AUTHOR);
777MODULE_DESCRIPTION(DRIVER_DESC);
778
779module_param(debug, bool, S_IRUGO | S_IWUSR);
780MODULE_PARM_DESC(debug, "Enable debug");
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882