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