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