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 void 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
190static void ark3116_set_termios(struct tty_struct *tty,
191 struct usb_serial_port *port,
192 struct ktermios *old_termios)
193{
194 struct usb_serial *serial = port->serial;
195 struct ark3116_private *priv = usb_get_serial_port_data(port);
196 struct ktermios *termios = &tty->termios;
197 unsigned int cflag = termios->c_cflag;
198 int bps = tty_get_baud_rate(tty);
199 int quot;
200 __u8 lcr, hcr, eval;
201
202
203 switch (cflag & CSIZE) {
204 case CS5:
205 lcr = UART_LCR_WLEN5;
206 break;
207 case CS6:
208 lcr = UART_LCR_WLEN6;
209 break;
210 case CS7:
211 lcr = UART_LCR_WLEN7;
212 break;
213 default:
214 case CS8:
215 lcr = UART_LCR_WLEN8;
216 break;
217 }
218 if (cflag & CSTOPB)
219 lcr |= UART_LCR_STOP;
220 if (cflag & PARENB)
221 lcr |= UART_LCR_PARITY;
222 if (!(cflag & PARODD))
223 lcr |= UART_LCR_EPAR;
224#ifdef CMSPAR
225 if (cflag & CMSPAR)
226 lcr |= UART_LCR_SPAR;
227#endif
228
229 hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
230
231
232 dev_dbg(&port->dev, "%s - setting bps to %d\n", __func__, bps);
233 eval = 0;
234 switch (bps) {
235 case 0:
236 quot = calc_divisor(9600);
237 break;
238 default:
239 if ((bps < 75) || (bps > 3000000))
240 bps = 9600;
241 quot = calc_divisor(bps);
242 break;
243 case 460800:
244 eval = 1;
245 quot = calc_divisor(bps);
246 break;
247 case 921600:
248 eval = 2;
249 quot = calc_divisor(bps);
250 break;
251 }
252
253
254 mutex_lock(&priv->hw_lock);
255
256
257 lcr |= (priv->lcr & UART_LCR_SBC);
258
259 dev_dbg(&port->dev, "%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d\n",
260 __func__, hcr, lcr, quot);
261
262
263 if (priv->hcr != hcr) {
264 priv->hcr = hcr;
265 ark3116_write_reg(serial, 0x8, hcr);
266 }
267
268
269 if (priv->quot != quot) {
270 priv->quot = quot;
271 priv->lcr = lcr;
272
273
274
275
276 ark3116_write_reg(serial, UART_FCR, 0);
277
278 ark3116_write_reg(serial, UART_LCR,
279 lcr|UART_LCR_DLAB);
280 ark3116_write_reg(serial, UART_DLL, quot & 0xff);
281 ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
282
283
284 ark3116_write_reg(serial, UART_LCR, lcr);
285
286
287
288 ark3116_write_reg(serial, 0xe, eval);
289
290
291 ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
292 } else if (priv->lcr != lcr) {
293 priv->lcr = lcr;
294 ark3116_write_reg(serial, UART_LCR, lcr);
295 }
296
297 mutex_unlock(&priv->hw_lock);
298
299
300 if (I_IXOFF(tty) || I_IXON(tty)) {
301 dev_warn(&port->dev,
302 "software flow control not implemented\n");
303 }
304
305
306 if (tty_termios_baud_rate(termios))
307 tty_termios_encode_baud_rate(termios, bps, bps);
308}
309
310static void ark3116_close(struct usb_serial_port *port)
311{
312 struct usb_serial *serial = port->serial;
313
314
315 ark3116_write_reg(serial, UART_FCR, 0);
316
317
318 ark3116_write_reg(serial, UART_IER, 0);
319
320 usb_serial_generic_close(port);
321
322 usb_kill_urb(port->interrupt_in_urb);
323}
324
325static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
326{
327 struct ark3116_private *priv = usb_get_serial_port_data(port);
328 struct usb_serial *serial = port->serial;
329 unsigned char *buf;
330 int result;
331
332 buf = kmalloc(1, GFP_KERNEL);
333 if (buf == NULL)
334 return -ENOMEM;
335
336 result = usb_serial_generic_open(tty, port);
337 if (result) {
338 dev_dbg(&port->dev,
339 "%s - usb_serial_generic_open failed: %d\n",
340 __func__, result);
341 goto err_free;
342 }
343
344
345 ark3116_read_reg(serial, UART_RX, buf);
346
347
348 result = ark3116_read_reg(serial, UART_MSR, buf);
349 if (result)
350 goto err_close;
351 priv->msr = *buf;
352
353
354 result = ark3116_read_reg(serial, UART_LSR, buf);
355 if (result)
356 goto err_close;
357 priv->lsr = *buf;
358
359 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
360 if (result) {
361 dev_err(&port->dev, "submit irq_in urb failed %d\n",
362 result);
363 goto err_close;
364 }
365
366
367 ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
368
369
370 ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
371
372
373 if (tty)
374 ark3116_set_termios(tty, port, NULL);
375
376 kfree(buf);
377
378 return 0;
379
380err_close:
381 usb_serial_generic_close(port);
382err_free:
383 kfree(buf);
384
385 return result;
386}
387
388static int ark3116_tiocmget(struct tty_struct *tty)
389{
390 struct usb_serial_port *port = tty->driver_data;
391 struct ark3116_private *priv = usb_get_serial_port_data(port);
392 __u32 status;
393 __u32 ctrl;
394 unsigned long flags;
395
396 mutex_lock(&priv->hw_lock);
397 ctrl = priv->mcr;
398 mutex_unlock(&priv->hw_lock);
399
400 spin_lock_irqsave(&priv->status_lock, flags);
401 status = priv->msr;
402 spin_unlock_irqrestore(&priv->status_lock, flags);
403
404 return (status & UART_MSR_DSR ? TIOCM_DSR : 0) |
405 (status & UART_MSR_CTS ? TIOCM_CTS : 0) |
406 (status & UART_MSR_RI ? TIOCM_RI : 0) |
407 (status & UART_MSR_DCD ? TIOCM_CD : 0) |
408 (ctrl & UART_MCR_DTR ? TIOCM_DTR : 0) |
409 (ctrl & UART_MCR_RTS ? TIOCM_RTS : 0) |
410 (ctrl & UART_MCR_OUT1 ? TIOCM_OUT1 : 0) |
411 (ctrl & UART_MCR_OUT2 ? TIOCM_OUT2 : 0);
412}
413
414static int ark3116_tiocmset(struct tty_struct *tty,
415 unsigned set, unsigned clr)
416{
417 struct usb_serial_port *port = tty->driver_data;
418 struct ark3116_private *priv = usb_get_serial_port_data(port);
419
420
421
422
423
424 mutex_lock(&priv->hw_lock);
425
426 if (set & TIOCM_RTS)
427 priv->mcr |= UART_MCR_RTS;
428 if (set & TIOCM_DTR)
429 priv->mcr |= UART_MCR_DTR;
430 if (set & TIOCM_OUT1)
431 priv->mcr |= UART_MCR_OUT1;
432 if (set & TIOCM_OUT2)
433 priv->mcr |= UART_MCR_OUT2;
434 if (clr & TIOCM_RTS)
435 priv->mcr &= ~UART_MCR_RTS;
436 if (clr & TIOCM_DTR)
437 priv->mcr &= ~UART_MCR_DTR;
438 if (clr & TIOCM_OUT1)
439 priv->mcr &= ~UART_MCR_OUT1;
440 if (clr & TIOCM_OUT2)
441 priv->mcr &= ~UART_MCR_OUT2;
442
443 ark3116_write_reg(port->serial, UART_MCR, priv->mcr);
444
445 mutex_unlock(&priv->hw_lock);
446
447 return 0;
448}
449
450static void ark3116_break_ctl(struct tty_struct *tty, int break_state)
451{
452 struct usb_serial_port *port = tty->driver_data;
453 struct ark3116_private *priv = usb_get_serial_port_data(port);
454
455
456 mutex_lock(&priv->hw_lock);
457
458 if (break_state)
459 priv->lcr |= UART_LCR_SBC;
460 else
461 priv->lcr &= ~UART_LCR_SBC;
462
463 ark3116_write_reg(port->serial, UART_LCR, priv->lcr);
464
465 mutex_unlock(&priv->hw_lock);
466}
467
468static void ark3116_update_msr(struct usb_serial_port *port, __u8 msr)
469{
470 struct ark3116_private *priv = usb_get_serial_port_data(port);
471 unsigned long flags;
472
473 spin_lock_irqsave(&priv->status_lock, flags);
474 priv->msr = msr;
475 spin_unlock_irqrestore(&priv->status_lock, flags);
476
477 if (msr & UART_MSR_ANY_DELTA) {
478
479 if (msr & UART_MSR_DCTS)
480 port->icount.cts++;
481 if (msr & UART_MSR_DDSR)
482 port->icount.dsr++;
483 if (msr & UART_MSR_DDCD)
484 port->icount.dcd++;
485 if (msr & UART_MSR_TERI)
486 port->icount.rng++;
487 wake_up_interruptible(&port->port.delta_msr_wait);
488 }
489}
490
491static void ark3116_update_lsr(struct usb_serial_port *port, __u8 lsr)
492{
493 struct ark3116_private *priv = usb_get_serial_port_data(port);
494 unsigned long flags;
495
496 spin_lock_irqsave(&priv->status_lock, flags);
497
498 priv->lsr |= lsr;
499 spin_unlock_irqrestore(&priv->status_lock, flags);
500
501 if (lsr&UART_LSR_BRK_ERROR_BITS) {
502 if (lsr & UART_LSR_BI)
503 port->icount.brk++;
504 if (lsr & UART_LSR_FE)
505 port->icount.frame++;
506 if (lsr & UART_LSR_PE)
507 port->icount.parity++;
508 if (lsr & UART_LSR_OE)
509 port->icount.overrun++;
510 }
511}
512
513static void ark3116_read_int_callback(struct urb *urb)
514{
515 struct usb_serial_port *port = urb->context;
516 int status = urb->status;
517 const __u8 *data = urb->transfer_buffer;
518 int result;
519
520 switch (status) {
521 case -ECONNRESET:
522 case -ENOENT:
523 case -ESHUTDOWN:
524
525 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
526 __func__, status);
527 return;
528 default:
529 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
530 __func__, status);
531 break;
532 case 0:
533
534 if ((urb->actual_length == 4) && (data[0] == 0xe8)) {
535 const __u8 id = data[1]&UART_IIR_ID;
536 dev_dbg(&port->dev, "%s: iir=%02x\n", __func__, data[1]);
537 if (id == UART_IIR_MSI) {
538 dev_dbg(&port->dev, "%s: msr=%02x\n",
539 __func__, data[3]);
540 ark3116_update_msr(port, data[3]);
541 break;
542 } else if (id == UART_IIR_RLSI) {
543 dev_dbg(&port->dev, "%s: lsr=%02x\n",
544 __func__, data[2]);
545 ark3116_update_lsr(port, data[2]);
546 break;
547 }
548 }
549
550
551
552 usb_serial_debug_data(&port->dev, __func__,
553 urb->actual_length,
554 urb->transfer_buffer);
555 break;
556 }
557
558 result = usb_submit_urb(urb, GFP_ATOMIC);
559 if (result)
560 dev_err(&port->dev, "failed to resubmit interrupt urb: %d\n",
561 result);
562}
563
564
565
566
567
568
569
570
571
572
573
574
575
576static void ark3116_process_read_urb(struct urb *urb)
577{
578 struct usb_serial_port *port = urb->context;
579 struct ark3116_private *priv = usb_get_serial_port_data(port);
580 unsigned char *data = urb->transfer_buffer;
581 char tty_flag = TTY_NORMAL;
582 unsigned long flags;
583 __u32 lsr;
584
585
586 spin_lock_irqsave(&priv->status_lock, flags);
587 lsr = priv->lsr;
588 priv->lsr &= ~UART_LSR_BRK_ERROR_BITS;
589 spin_unlock_irqrestore(&priv->status_lock, flags);
590
591 if (!urb->actual_length)
592 return;
593
594 if (lsr & UART_LSR_BRK_ERROR_BITS) {
595 if (lsr & UART_LSR_BI)
596 tty_flag = TTY_BREAK;
597 else if (lsr & UART_LSR_PE)
598 tty_flag = TTY_PARITY;
599 else if (lsr & UART_LSR_FE)
600 tty_flag = TTY_FRAME;
601
602
603 if (lsr & UART_LSR_OE)
604 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
605 }
606 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
607 urb->actual_length);
608 tty_flip_buffer_push(&port->port);
609}
610
611static struct usb_serial_driver ark3116_device = {
612 .driver = {
613 .owner = THIS_MODULE,
614 .name = "ark3116",
615 },
616 .id_table = id_table,
617 .num_ports = 1,
618 .num_bulk_in = 1,
619 .num_bulk_out = 1,
620 .num_interrupt_in = 1,
621 .port_probe = ark3116_port_probe,
622 .port_remove = ark3116_port_remove,
623 .set_termios = ark3116_set_termios,
624 .tiocmget = ark3116_tiocmget,
625 .tiocmset = ark3116_tiocmset,
626 .tiocmiwait = usb_serial_generic_tiocmiwait,
627 .get_icount = usb_serial_generic_get_icount,
628 .open = ark3116_open,
629 .close = ark3116_close,
630 .break_ctl = ark3116_break_ctl,
631 .read_int_callback = ark3116_read_int_callback,
632 .process_read_urb = ark3116_process_read_urb,
633};
634
635static struct usb_serial_driver * const serial_drivers[] = {
636 &ark3116_device, NULL
637};
638
639module_usb_serial_driver(serial_drivers, id_table);
640
641MODULE_LICENSE("GPL");
642
643MODULE_AUTHOR(DRIVER_AUTHOR);
644MODULE_DESCRIPTION(DRIVER_DESC);
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
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