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
40#define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
41#define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
42#define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
43#define DRIVER_NAME "ark3116"
44
45
46#define ARK_TIMEOUT 1000
47
48static const struct usb_device_id id_table[] = {
49 { USB_DEVICE(0x6547, 0x0232) },
50 { USB_DEVICE(0x18ec, 0x3118) },
51 { },
52};
53MODULE_DEVICE_TABLE(usb, id_table);
54
55static int is_irda(struct usb_serial *serial)
56{
57 struct usb_device *dev = serial->dev;
58 if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
59 le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
60 return 1;
61 return 0;
62}
63
64struct ark3116_private {
65 int irda;
66
67
68 struct mutex hw_lock;
69
70 int quot;
71 __u32 lcr;
72 __u32 hcr;
73
74 __u32 mcr;
75
76
77 spinlock_t status_lock;
78 __u32 msr;
79 __u32 lsr;
80};
81
82static int ark3116_write_reg(struct usb_serial *serial,
83 unsigned reg, __u8 val)
84{
85 int result;
86
87 result = usb_control_msg(serial->dev,
88 usb_sndctrlpipe(serial->dev, 0),
89 0xfe, 0x40, val, reg,
90 NULL, 0, ARK_TIMEOUT);
91 return result;
92}
93
94static int ark3116_read_reg(struct usb_serial *serial,
95 unsigned reg, unsigned char *buf)
96{
97 int result;
98
99 result = usb_control_msg(serial->dev,
100 usb_rcvctrlpipe(serial->dev, 0),
101 0xfe, 0xc0, 0, reg,
102 buf, 1, ARK_TIMEOUT);
103 if (result < 0)
104 return result;
105 else
106 return buf[0];
107}
108
109static inline int calc_divisor(int bps)
110{
111
112
113
114
115
116 return (12000000 + 2*bps) / (4*bps);
117}
118
119static int ark3116_attach(struct usb_serial *serial)
120{
121
122 if ((serial->num_bulk_in == 0) ||
123 (serial->num_bulk_out == 0) ||
124 (serial->num_interrupt_in == 0)) {
125 dev_err(&serial->dev->dev,
126 "%s - missing endpoint - "
127 "bulk in: %d, bulk out: %d, int in %d\n",
128 KBUILD_MODNAME,
129 serial->num_bulk_in,
130 serial->num_bulk_out,
131 serial->num_interrupt_in);
132 return -EINVAL;
133 }
134
135 return 0;
136}
137
138static int ark3116_port_probe(struct usb_serial_port *port)
139{
140 struct usb_serial *serial = port->serial;
141 struct ark3116_private *priv;
142
143 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
144 if (!priv)
145 return -ENOMEM;
146
147 mutex_init(&priv->hw_lock);
148 spin_lock_init(&priv->status_lock);
149
150 priv->irda = is_irda(serial);
151
152 usb_set_serial_port_data(port, priv);
153
154
155 ark3116_write_reg(serial, UART_IER, 0);
156
157 ark3116_write_reg(serial, UART_FCR, 0);
158
159 priv->hcr = 0;
160 ark3116_write_reg(serial, 0x8 , 0);
161
162 priv->mcr = 0;
163 ark3116_write_reg(serial, UART_MCR, 0);
164
165 if (!(priv->irda)) {
166 ark3116_write_reg(serial, 0xb , 0);
167 } else {
168 ark3116_write_reg(serial, 0xb , 1);
169 ark3116_write_reg(serial, 0xc , 0);
170 ark3116_write_reg(serial, 0xd , 0x41);
171 ark3116_write_reg(serial, 0xa , 1);
172 }
173
174
175 ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB);
176
177
178 priv->quot = calc_divisor(9600);
179 ark3116_write_reg(serial, UART_DLL, priv->quot & 0xff);
180 ark3116_write_reg(serial, UART_DLM, (priv->quot>>8) & 0xff);
181
182 priv->lcr = UART_LCR_WLEN8;
183 ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8);
184
185 ark3116_write_reg(serial, 0xe, 0);
186
187 if (priv->irda)
188 ark3116_write_reg(serial, 0x9, 0);
189
190 dev_info(&serial->dev->dev,
191 "%s using %s mode\n",
192 KBUILD_MODNAME,
193 priv->irda ? "IrDA" : "RS232");
194 return 0;
195}
196
197static int ark3116_port_remove(struct usb_serial_port *port)
198{
199 struct ark3116_private *priv = usb_get_serial_port_data(port);
200
201
202 mutex_destroy(&priv->hw_lock);
203 kfree(priv);
204
205 return 0;
206}
207
208static void ark3116_init_termios(struct tty_struct *tty)
209{
210 struct ktermios *termios = &tty->termios;
211 *termios = tty_std_termios;
212 termios->c_cflag = B9600 | CS8
213 | CREAD | HUPCL | CLOCAL;
214 termios->c_ispeed = 9600;
215 termios->c_ospeed = 9600;
216}
217
218static void ark3116_set_termios(struct tty_struct *tty,
219 struct usb_serial_port *port,
220 struct ktermios *old_termios)
221{
222 struct usb_serial *serial = port->serial;
223 struct ark3116_private *priv = usb_get_serial_port_data(port);
224 struct ktermios *termios = &tty->termios;
225 unsigned int cflag = termios->c_cflag;
226 int bps = tty_get_baud_rate(tty);
227 int quot;
228 __u8 lcr, hcr, eval;
229
230
231 switch (cflag & CSIZE) {
232 case CS5:
233 lcr = UART_LCR_WLEN5;
234 break;
235 case CS6:
236 lcr = UART_LCR_WLEN6;
237 break;
238 case CS7:
239 lcr = UART_LCR_WLEN7;
240 break;
241 default:
242 case CS8:
243 lcr = UART_LCR_WLEN8;
244 break;
245 }
246 if (cflag & CSTOPB)
247 lcr |= UART_LCR_STOP;
248 if (cflag & PARENB)
249 lcr |= UART_LCR_PARITY;
250 if (!(cflag & PARODD))
251 lcr |= UART_LCR_EPAR;
252#ifdef CMSPAR
253 if (cflag & CMSPAR)
254 lcr |= UART_LCR_SPAR;
255#endif
256
257 hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
258
259
260 dev_dbg(&port->dev, "%s - setting bps to %d\n", __func__, bps);
261 eval = 0;
262 switch (bps) {
263 case 0:
264 quot = calc_divisor(9600);
265 break;
266 default:
267 if ((bps < 75) || (bps > 3000000))
268 bps = 9600;
269 quot = calc_divisor(bps);
270 break;
271 case 460800:
272 eval = 1;
273 quot = calc_divisor(bps);
274 break;
275 case 921600:
276 eval = 2;
277 quot = calc_divisor(bps);
278 break;
279 }
280
281
282 mutex_lock(&priv->hw_lock);
283
284
285 lcr |= (priv->lcr & UART_LCR_SBC);
286
287 dev_dbg(&port->dev, "%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d\n",
288 __func__, hcr, lcr, quot);
289
290
291 if (priv->hcr != hcr) {
292 priv->hcr = hcr;
293 ark3116_write_reg(serial, 0x8, hcr);
294 }
295
296
297 if (priv->quot != quot) {
298 priv->quot = quot;
299 priv->lcr = lcr;
300
301
302
303
304 ark3116_write_reg(serial, UART_FCR, 0);
305
306 ark3116_write_reg(serial, UART_LCR,
307 lcr|UART_LCR_DLAB);
308 ark3116_write_reg(serial, UART_DLL, quot & 0xff);
309 ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
310
311
312 ark3116_write_reg(serial, UART_LCR, lcr);
313
314
315
316 ark3116_write_reg(serial, 0xe, eval);
317
318
319 ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
320 } else if (priv->lcr != lcr) {
321 priv->lcr = lcr;
322 ark3116_write_reg(serial, UART_LCR, lcr);
323 }
324
325 mutex_unlock(&priv->hw_lock);
326
327
328 if (I_IXOFF(tty) || I_IXON(tty)) {
329 dev_warn(&serial->dev->dev,
330 "%s: don't know how to do software flow control\n",
331 KBUILD_MODNAME);
332 }
333
334
335 if (tty_termios_baud_rate(termios))
336 tty_termios_encode_baud_rate(termios, bps, bps);
337}
338
339static void ark3116_close(struct usb_serial_port *port)
340{
341 struct usb_serial *serial = port->serial;
342
343
344 ark3116_write_reg(serial, UART_FCR, 0);
345
346
347 ark3116_write_reg(serial, UART_IER, 0);
348
349 usb_serial_generic_close(port);
350 if (serial->num_interrupt_in)
351 usb_kill_urb(port->interrupt_in_urb);
352}
353
354static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
355{
356 struct ark3116_private *priv = usb_get_serial_port_data(port);
357 struct usb_serial *serial = port->serial;
358 unsigned char *buf;
359 int result;
360
361 buf = kmalloc(1, GFP_KERNEL);
362 if (buf == NULL)
363 return -ENOMEM;
364
365 result = usb_serial_generic_open(tty, port);
366 if (result) {
367 dev_dbg(&port->dev,
368 "%s - usb_serial_generic_open failed: %d\n",
369 __func__, result);
370 goto err_out;
371 }
372
373
374 ark3116_read_reg(serial, UART_RX, buf);
375
376
377 priv->msr = ark3116_read_reg(serial, UART_MSR, buf);
378
379 priv->lsr = ark3116_read_reg(serial, UART_LSR, buf);
380
381 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
382 if (result) {
383 dev_err(&port->dev, "submit irq_in urb failed %d\n",
384 result);
385 ark3116_close(port);
386 goto err_out;
387 }
388
389
390 ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
391
392
393 ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
394
395
396 if (tty)
397 ark3116_set_termios(tty, port, NULL);
398
399err_out:
400 kfree(buf);
401 return result;
402}
403
404static int ark3116_ioctl(struct tty_struct *tty,
405 unsigned int cmd, unsigned long arg)
406{
407 struct usb_serial_port *port = tty->driver_data;
408 struct serial_struct serstruct;
409 void __user *user_arg = (void __user *)arg;
410
411 switch (cmd) {
412 case TIOCGSERIAL:
413
414 memset(&serstruct, 0, sizeof(serstruct));
415 serstruct.type = PORT_16654;
416 serstruct.line = port->minor;
417 serstruct.port = port->port_number;
418 serstruct.custom_divisor = 0;
419 serstruct.baud_base = 460800;
420
421 if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
422 return -EFAULT;
423
424 return 0;
425 case TIOCSSERIAL:
426 if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
427 return -EFAULT;
428 return 0;
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(&urb->dev->dev,
607 "%s - Error %d submitting interrupt urb\n",
608 __func__, result);
609}
610
611
612
613
614
615
616
617
618
619
620
621
622
623static void ark3116_process_read_urb(struct urb *urb)
624{
625 struct usb_serial_port *port = urb->context;
626 struct ark3116_private *priv = usb_get_serial_port_data(port);
627 unsigned char *data = urb->transfer_buffer;
628 char tty_flag = TTY_NORMAL;
629 unsigned long flags;
630 __u32 lsr;
631
632
633 spin_lock_irqsave(&priv->status_lock, flags);
634 lsr = priv->lsr;
635 priv->lsr &= ~UART_LSR_BRK_ERROR_BITS;
636 spin_unlock_irqrestore(&priv->status_lock, flags);
637
638 if (!urb->actual_length)
639 return;
640
641 if (lsr & UART_LSR_BRK_ERROR_BITS) {
642 if (lsr & UART_LSR_BI)
643 tty_flag = TTY_BREAK;
644 else if (lsr & UART_LSR_PE)
645 tty_flag = TTY_PARITY;
646 else if (lsr & UART_LSR_FE)
647 tty_flag = TTY_FRAME;
648
649
650 if (lsr & UART_LSR_OE)
651 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
652 }
653 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
654 urb->actual_length);
655 tty_flip_buffer_push(&port->port);
656}
657
658static struct usb_serial_driver ark3116_device = {
659 .driver = {
660 .owner = THIS_MODULE,
661 .name = "ark3116",
662 },
663 .id_table = id_table,
664 .num_ports = 1,
665 .attach = ark3116_attach,
666 .port_probe = ark3116_port_probe,
667 .port_remove = ark3116_port_remove,
668 .set_termios = ark3116_set_termios,
669 .init_termios = ark3116_init_termios,
670 .ioctl = ark3116_ioctl,
671 .tiocmget = ark3116_tiocmget,
672 .tiocmset = ark3116_tiocmset,
673 .tiocmiwait = usb_serial_generic_tiocmiwait,
674 .get_icount = usb_serial_generic_get_icount,
675 .open = ark3116_open,
676 .close = ark3116_close,
677 .break_ctl = ark3116_break_ctl,
678 .read_int_callback = ark3116_read_int_callback,
679 .process_read_urb = ark3116_process_read_urb,
680};
681
682static struct usb_serial_driver * const serial_drivers[] = {
683 &ark3116_device, NULL
684};
685
686module_usb_serial_driver(serial_drivers, id_table);
687
688MODULE_LICENSE("GPL");
689
690MODULE_AUTHOR(DRIVER_AUTHOR);
691MODULE_DESCRIPTION(DRIVER_DESC);
692
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