2 * Copyright (C) 2009 by Bart Hartgers (bart.hartgers+ark3116@gmail.com)
5 * Simon Schulz (ark3116_driver <at> auctionant.de)
8 * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
9 * productid=0x0232) (used in a datacable called KQ-U8A)
11 * Supports full modem status lines, break, hardware flow control. Does not
12 * support software flow control, since I do not know how to enable it in hw.
14 * This driver is a essentially new implementation. I initially dug
15 * into the old ark3116.c driver and suddenly realized the ark3116 is
16 * a 16450 with a USB interface glued to it. See comments at the
17 * bottom of this file.
19 * This program is free software; you can redistribute it and/or modify it
20 * under the terms of the GNU General Public License as published by the
21 * Free Software Foundation; either version 2 of the License, or (at your
22 * option) any later version.
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>
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"
45 /* usb timeout of 1 second */
46 #define ARK_TIMEOUT (1*HZ)
48 static const struct usb_device_id id_table
[] = {
49 { USB_DEVICE(0x6547, 0x0232) },
50 { USB_DEVICE(0x18ec, 0x3118) }, /* USB to IrDA adapter */
53 MODULE_DEVICE_TABLE(usb
, id_table
);
55 static int is_irda(struct usb_serial
*serial
)
57 struct usb_device
*dev
= serial
->dev
;
58 if (le16_to_cpu(dev
->descriptor
.idVendor
) == 0x18ec &&
59 le16_to_cpu(dev
->descriptor
.idProduct
) == 0x3118)
64 struct ark3116_private
{
65 wait_queue_head_t delta_msr_wait
;
66 struct async_icount icount
;
67 int irda
; /* 1 for irda device */
69 /* protects hw register updates */
72 int quot
; /* baudrate divisor */
73 __u32 lcr
; /* line control register value */
74 __u32 hcr
; /* handshake control register (0x8)
76 __u32 mcr
; /* modem contol register value */
78 /* protects the status values below */
79 spinlock_t status_lock
;
80 __u32 msr
; /* modem status register value */
81 __u32 lsr
; /* line status register value */
84 static int ark3116_write_reg(struct usb_serial
*serial
,
85 unsigned reg
, __u8 val
)
88 /* 0xfe 0x40 are magic values taken from original driver */
89 result
= usb_control_msg(serial
->dev
,
90 usb_sndctrlpipe(serial
->dev
, 0),
92 NULL
, 0, ARK_TIMEOUT
);
96 static int ark3116_read_reg(struct usb_serial
*serial
,
97 unsigned reg
, unsigned char *buf
)
100 /* 0xfe 0xc0 are magic values taken from original driver */
101 result
= usb_control_msg(serial
->dev
,
102 usb_rcvctrlpipe(serial
->dev
, 0),
104 buf
, 1, ARK_TIMEOUT
);
111 static inline int calc_divisor(int bps
)
113 /* Original ark3116 made some exceptions in rounding here
114 * because windows did the same. Assume that is not really
116 * Crystal is 12MHz, probably because of USB, but we divide by 4?
118 return (12000000 + 2*bps
) / (4*bps
);
121 static int ark3116_attach(struct usb_serial
*serial
)
123 /* make sure we have our end-points */
124 if ((serial
->num_bulk_in
== 0) ||
125 (serial
->num_bulk_out
== 0) ||
126 (serial
->num_interrupt_in
== 0)) {
127 dev_err(&serial
->dev
->dev
,
128 "%s - missing endpoint - "
129 "bulk in: %d, bulk out: %d, int in %d\n",
132 serial
->num_bulk_out
,
133 serial
->num_interrupt_in
);
140 static int ark3116_port_probe(struct usb_serial_port
*port
)
142 struct usb_serial
*serial
= port
->serial
;
143 struct ark3116_private
*priv
;
145 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
149 init_waitqueue_head(&priv
->delta_msr_wait
);
150 mutex_init(&priv
->hw_lock
);
151 spin_lock_init(&priv
->status_lock
);
153 priv
->irda
= is_irda(serial
);
155 usb_set_serial_port_data(port
, priv
);
157 /* setup the hardware */
158 ark3116_write_reg(serial
, UART_IER
, 0);
160 ark3116_write_reg(serial
, UART_FCR
, 0);
161 /* handshake control */
163 ark3116_write_reg(serial
, 0x8 , 0);
166 ark3116_write_reg(serial
, UART_MCR
, 0);
169 ark3116_write_reg(serial
, 0xb , 0);
171 ark3116_write_reg(serial
, 0xb , 1);
172 ark3116_write_reg(serial
, 0xc , 0);
173 ark3116_write_reg(serial
, 0xd , 0x41);
174 ark3116_write_reg(serial
, 0xa , 1);
178 ark3116_write_reg(serial
, UART_LCR
, UART_LCR_DLAB
);
180 /* setup for 9600 8N1 */
181 priv
->quot
= calc_divisor(9600);
182 ark3116_write_reg(serial
, UART_DLL
, priv
->quot
& 0xff);
183 ark3116_write_reg(serial
, UART_DLM
, (priv
->quot
>>8) & 0xff);
185 priv
->lcr
= UART_LCR_WLEN8
;
186 ark3116_write_reg(serial
, UART_LCR
, UART_LCR_WLEN8
);
188 ark3116_write_reg(serial
, 0xe, 0);
191 ark3116_write_reg(serial
, 0x9, 0);
193 dev_info(&serial
->dev
->dev
,
194 "%s using %s mode\n",
196 priv
->irda
? "IrDA" : "RS232");
200 static int ark3116_port_remove(struct usb_serial_port
*port
)
202 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
204 /* device is closed, so URBs and DMA should be down */
205 mutex_destroy(&priv
->hw_lock
);
211 static void ark3116_init_termios(struct tty_struct
*tty
)
213 struct ktermios
*termios
= &tty
->termios
;
214 *termios
= tty_std_termios
;
215 termios
->c_cflag
= B9600
| CS8
216 | CREAD
| HUPCL
| CLOCAL
;
217 termios
->c_ispeed
= 9600;
218 termios
->c_ospeed
= 9600;
221 static void ark3116_set_termios(struct tty_struct
*tty
,
222 struct usb_serial_port
*port
,
223 struct ktermios
*old_termios
)
225 struct usb_serial
*serial
= port
->serial
;
226 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
227 struct ktermios
*termios
= &tty
->termios
;
228 unsigned int cflag
= termios
->c_cflag
;
229 int bps
= tty_get_baud_rate(tty
);
233 /* set data bit count */
234 switch (cflag
& CSIZE
) {
236 lcr
= UART_LCR_WLEN5
;
239 lcr
= UART_LCR_WLEN6
;
242 lcr
= UART_LCR_WLEN7
;
246 lcr
= UART_LCR_WLEN8
;
250 lcr
|= UART_LCR_STOP
;
252 lcr
|= UART_LCR_PARITY
;
253 if (!(cflag
& PARODD
))
254 lcr
|= UART_LCR_EPAR
;
257 lcr
|= UART_LCR_SPAR
;
259 /* handshake control */
260 hcr
= (cflag
& CRTSCTS
) ? 0x03 : 0x00;
263 dev_dbg(&port
->dev
, "%s - setting bps to %d\n", __func__
, bps
);
267 quot
= calc_divisor(9600);
270 if ((bps
< 75) || (bps
> 3000000))
272 quot
= calc_divisor(bps
);
276 quot
= calc_divisor(bps
);
280 quot
= calc_divisor(bps
);
284 /* Update state: synchronize */
285 mutex_lock(&priv
->hw_lock
);
287 /* keep old LCR_SBC bit */
288 lcr
|= (priv
->lcr
& UART_LCR_SBC
);
290 dev_dbg(&port
->dev
, "%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d\n",
291 __func__
, hcr
, lcr
, quot
);
293 /* handshake control */
294 if (priv
->hcr
!= hcr
) {
296 ark3116_write_reg(serial
, 0x8, hcr
);
300 if (priv
->quot
!= quot
) {
302 priv
->lcr
= lcr
; /* need to write lcr anyway */
304 /* disable DMA since transmit/receive is
305 * shadowed by UART_DLL
307 ark3116_write_reg(serial
, UART_FCR
, 0);
309 ark3116_write_reg(serial
, UART_LCR
,
311 ark3116_write_reg(serial
, UART_DLL
, quot
& 0xff);
312 ark3116_write_reg(serial
, UART_DLM
, (quot
>>8) & 0xff);
315 ark3116_write_reg(serial
, UART_LCR
, lcr
);
316 /* magic baudrate thingy: not sure what it does,
317 * but windows does this as well.
319 ark3116_write_reg(serial
, 0xe, eval
);
322 ark3116_write_reg(serial
, UART_FCR
, UART_FCR_DMA_SELECT
);
323 } else if (priv
->lcr
!= lcr
) {
325 ark3116_write_reg(serial
, UART_LCR
, lcr
);
328 mutex_unlock(&priv
->hw_lock
);
330 /* check for software flow control */
331 if (I_IXOFF(tty
) || I_IXON(tty
)) {
332 dev_warn(&serial
->dev
->dev
,
333 "%s: don't know how to do software flow control\n",
337 /* Don't rewrite B0 */
338 if (tty_termios_baud_rate(termios
))
339 tty_termios_encode_baud_rate(termios
, bps
, bps
);
342 static void ark3116_close(struct usb_serial_port
*port
)
344 struct usb_serial
*serial
= port
->serial
;
348 ark3116_write_reg(serial
, UART_FCR
, 0);
350 /* deactivate interrupts */
351 ark3116_write_reg(serial
, UART_IER
, 0);
353 usb_serial_generic_close(port
);
354 if (serial
->num_interrupt_in
)
355 usb_kill_urb(port
->interrupt_in_urb
);
360 static int ark3116_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
362 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
363 struct usb_serial
*serial
= port
->serial
;
367 buf
= kmalloc(1, GFP_KERNEL
);
371 result
= usb_serial_generic_open(tty
, port
);
374 "%s - usb_serial_generic_open failed: %d\n",
379 /* remove any data still left: also clears error state */
380 ark3116_read_reg(serial
, UART_RX
, buf
);
382 /* read modem status */
383 priv
->msr
= ark3116_read_reg(serial
, UART_MSR
, buf
);
384 /* read line status */
385 priv
->lsr
= ark3116_read_reg(serial
, UART_LSR
, buf
);
387 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
389 dev_err(&port
->dev
, "submit irq_in urb failed %d\n",
395 /* activate interrupts */
396 ark3116_write_reg(port
->serial
, UART_IER
, UART_IER_MSI
|UART_IER_RLSI
);
399 ark3116_write_reg(port
->serial
, UART_FCR
, UART_FCR_DMA_SELECT
);
403 ark3116_set_termios(tty
, port
, NULL
);
410 static int ark3116_get_icount(struct tty_struct
*tty
,
411 struct serial_icounter_struct
*icount
)
413 struct usb_serial_port
*port
= tty
->driver_data
;
414 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
415 struct async_icount cnow
= priv
->icount
;
416 icount
->cts
= cnow
.cts
;
417 icount
->dsr
= cnow
.dsr
;
418 icount
->rng
= cnow
.rng
;
419 icount
->dcd
= cnow
.dcd
;
420 icount
->rx
= cnow
.rx
;
421 icount
->tx
= cnow
.tx
;
422 icount
->frame
= cnow
.frame
;
423 icount
->overrun
= cnow
.overrun
;
424 icount
->parity
= cnow
.parity
;
425 icount
->brk
= cnow
.brk
;
426 icount
->buf_overrun
= cnow
.buf_overrun
;
430 static int ark3116_ioctl(struct tty_struct
*tty
,
431 unsigned int cmd
, unsigned long arg
)
433 struct usb_serial_port
*port
= tty
->driver_data
;
434 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
435 struct serial_struct serstruct
;
436 void __user
*user_arg
= (void __user
*)arg
;
440 /* XXX: Some of these values are probably wrong. */
441 memset(&serstruct
, 0, sizeof(serstruct
));
442 serstruct
.type
= PORT_16654
;
443 serstruct
.line
= port
->serial
->minor
;
444 serstruct
.port
= port
->number
;
445 serstruct
.custom_divisor
= 0;
446 serstruct
.baud_base
= 460800;
448 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
453 if (copy_from_user(&serstruct
, user_arg
, sizeof(serstruct
)))
458 struct async_icount prev
= priv
->icount
;
459 interruptible_sleep_on(&priv
->delta_msr_wait
);
460 /* see if a signal did it */
461 if (signal_pending(current
))
463 if ((prev
.rng
== priv
->icount
.rng
) &&
464 (prev
.dsr
== priv
->icount
.dsr
) &&
465 (prev
.dcd
== priv
->icount
.dcd
) &&
466 (prev
.cts
== priv
->icount
.cts
))
468 if ((arg
& TIOCM_RNG
&&
469 (prev
.rng
!= priv
->icount
.rng
)) ||
471 (prev
.dsr
!= priv
->icount
.dsr
)) ||
473 (prev
.dcd
!= priv
->icount
.dcd
)) ||
475 (prev
.cts
!= priv
->icount
.cts
)))
484 static int ark3116_tiocmget(struct tty_struct
*tty
)
486 struct usb_serial_port
*port
= tty
->driver_data
;
487 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
492 mutex_lock(&priv
->hw_lock
);
494 mutex_unlock(&priv
->hw_lock
);
496 spin_lock_irqsave(&priv
->status_lock
, flags
);
498 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
500 return (status
& UART_MSR_DSR
? TIOCM_DSR
: 0) |
501 (status
& UART_MSR_CTS
? TIOCM_CTS
: 0) |
502 (status
& UART_MSR_RI
? TIOCM_RI
: 0) |
503 (status
& UART_MSR_DCD
? TIOCM_CD
: 0) |
504 (ctrl
& UART_MCR_DTR
? TIOCM_DTR
: 0) |
505 (ctrl
& UART_MCR_RTS
? TIOCM_RTS
: 0) |
506 (ctrl
& UART_MCR_OUT1
? TIOCM_OUT1
: 0) |
507 (ctrl
& UART_MCR_OUT2
? TIOCM_OUT2
: 0);
510 static int ark3116_tiocmset(struct tty_struct
*tty
,
511 unsigned set
, unsigned clr
)
513 struct usb_serial_port
*port
= tty
->driver_data
;
514 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
516 /* we need to take the mutex here, to make sure that the value
517 * in priv->mcr is actually the one that is in the hardware
520 mutex_lock(&priv
->hw_lock
);
523 priv
->mcr
|= UART_MCR_RTS
;
525 priv
->mcr
|= UART_MCR_DTR
;
526 if (set
& TIOCM_OUT1
)
527 priv
->mcr
|= UART_MCR_OUT1
;
528 if (set
& TIOCM_OUT2
)
529 priv
->mcr
|= UART_MCR_OUT2
;
531 priv
->mcr
&= ~UART_MCR_RTS
;
533 priv
->mcr
&= ~UART_MCR_DTR
;
534 if (clr
& TIOCM_OUT1
)
535 priv
->mcr
&= ~UART_MCR_OUT1
;
536 if (clr
& TIOCM_OUT2
)
537 priv
->mcr
&= ~UART_MCR_OUT2
;
539 ark3116_write_reg(port
->serial
, UART_MCR
, priv
->mcr
);
541 mutex_unlock(&priv
->hw_lock
);
546 static void ark3116_break_ctl(struct tty_struct
*tty
, int break_state
)
548 struct usb_serial_port
*port
= tty
->driver_data
;
549 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
551 /* LCR is also used for other things: protect access */
552 mutex_lock(&priv
->hw_lock
);
555 priv
->lcr
|= UART_LCR_SBC
;
557 priv
->lcr
&= ~UART_LCR_SBC
;
559 ark3116_write_reg(port
->serial
, UART_LCR
, priv
->lcr
);
561 mutex_unlock(&priv
->hw_lock
);
564 static void ark3116_update_msr(struct usb_serial_port
*port
, __u8 msr
)
566 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
569 spin_lock_irqsave(&priv
->status_lock
, flags
);
571 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
573 if (msr
& UART_MSR_ANY_DELTA
) {
574 /* update input line counters */
575 if (msr
& UART_MSR_DCTS
)
577 if (msr
& UART_MSR_DDSR
)
579 if (msr
& UART_MSR_DDCD
)
581 if (msr
& UART_MSR_TERI
)
583 wake_up_interruptible(&priv
->delta_msr_wait
);
587 static void ark3116_update_lsr(struct usb_serial_port
*port
, __u8 lsr
)
589 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
592 spin_lock_irqsave(&priv
->status_lock
, flags
);
595 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
597 if (lsr
&UART_LSR_BRK_ERROR_BITS
) {
598 if (lsr
& UART_LSR_BI
)
600 if (lsr
& UART_LSR_FE
)
601 priv
->icount
.frame
++;
602 if (lsr
& UART_LSR_PE
)
603 priv
->icount
.parity
++;
604 if (lsr
& UART_LSR_OE
)
605 priv
->icount
.overrun
++;
609 static void ark3116_read_int_callback(struct urb
*urb
)
611 struct usb_serial_port
*port
= urb
->context
;
612 int status
= urb
->status
;
613 const __u8
*data
= urb
->transfer_buffer
;
620 /* this urb is terminated, clean up */
621 dev_dbg(&port
->dev
, "%s - urb shutting down with status: %d\n",
625 dev_dbg(&port
->dev
, "%s - nonzero urb status received: %d\n",
628 case 0: /* success */
629 /* discovered this by trail and error... */
630 if ((urb
->actual_length
== 4) && (data
[0] == 0xe8)) {
631 const __u8 id
= data
[1]&UART_IIR_ID
;
632 dev_dbg(&port
->dev
, "%s: iir=%02x\n", __func__
, data
[1]);
633 if (id
== UART_IIR_MSI
) {
634 dev_dbg(&port
->dev
, "%s: msr=%02x\n",
636 ark3116_update_msr(port
, data
[3]);
638 } else if (id
== UART_IIR_RLSI
) {
639 dev_dbg(&port
->dev
, "%s: lsr=%02x\n",
641 ark3116_update_lsr(port
, data
[2]);
646 * Not sure what this data meant...
648 usb_serial_debug_data(&port
->dev
, __func__
,
650 urb
->transfer_buffer
);
654 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
656 dev_err(&urb
->dev
->dev
,
657 "%s - Error %d submitting interrupt urb\n",
662 /* Data comes in via the bulk (data) URB, erors/interrupts via the int URB.
663 * This means that we cannot be sure which data byte has an associated error
664 * condition, so we report an error for all data in the next bulk read.
666 * Actually, there might even be a window between the bulk data leaving the
667 * ark and reading/resetting the lsr in the read_bulk_callback where an
668 * interrupt for the next data block could come in.
669 * Without somekind of ordering on the ark, we would have to report the
670 * error for the next block of data as well...
671 * For now, let's pretend this can't happen.
673 static void ark3116_process_read_urb(struct urb
*urb
)
675 struct usb_serial_port
*port
= urb
->context
;
676 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
677 struct tty_struct
*tty
;
678 unsigned char *data
= urb
->transfer_buffer
;
679 char tty_flag
= TTY_NORMAL
;
683 /* update line status */
684 spin_lock_irqsave(&priv
->status_lock
, flags
);
686 priv
->lsr
&= ~UART_LSR_BRK_ERROR_BITS
;
687 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
689 if (!urb
->actual_length
)
692 tty
= tty_port_tty_get(&port
->port
);
696 if (lsr
& UART_LSR_BRK_ERROR_BITS
) {
697 if (lsr
& UART_LSR_BI
)
698 tty_flag
= TTY_BREAK
;
699 else if (lsr
& UART_LSR_PE
)
700 tty_flag
= TTY_PARITY
;
701 else if (lsr
& UART_LSR_FE
)
702 tty_flag
= TTY_FRAME
;
704 /* overrun is special, not associated with a char */
705 if (lsr
& UART_LSR_OE
)
706 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
708 tty_insert_flip_string_fixed_flag(&port
->port
, data
, tty_flag
,
710 tty_flip_buffer_push(tty
);
714 static struct usb_serial_driver ark3116_device
= {
716 .owner
= THIS_MODULE
,
719 .id_table
= id_table
,
721 .attach
= ark3116_attach
,
722 .port_probe
= ark3116_port_probe
,
723 .port_remove
= ark3116_port_remove
,
724 .set_termios
= ark3116_set_termios
,
725 .init_termios
= ark3116_init_termios
,
726 .ioctl
= ark3116_ioctl
,
727 .tiocmget
= ark3116_tiocmget
,
728 .tiocmset
= ark3116_tiocmset
,
729 .get_icount
= ark3116_get_icount
,
730 .open
= ark3116_open
,
731 .close
= ark3116_close
,
732 .break_ctl
= ark3116_break_ctl
,
733 .read_int_callback
= ark3116_read_int_callback
,
734 .process_read_urb
= ark3116_process_read_urb
,
737 static struct usb_serial_driver
* const serial_drivers
[] = {
738 &ark3116_device
, NULL
741 module_usb_serial_driver(serial_drivers
, id_table
);
743 MODULE_LICENSE("GPL");
745 MODULE_AUTHOR(DRIVER_AUTHOR
);
746 MODULE_DESCRIPTION(DRIVER_DESC
);
749 * The following describes what I learned from studying the old
750 * ark3116.c driver, disassembling the windows driver, and some lucky
751 * guesses. Since I do not have any datasheet or other
752 * documentation, inaccuracies are almost guaranteed.
754 * Some specs for the ARK3116 can be found here:
755 * http://web.archive.org/web/20060318000438/
756 * www.arkmicro.com/en/products/view.php?id=10
757 * On that page, 2 GPIO pins are mentioned: I assume these are the
758 * OUT1 and OUT2 pins of the UART, so I added support for those
759 * through the MCR. Since the pins are not available on my hardware,
760 * I could not verify this.
761 * Also, it states there is "on-chip hardware flow control". I have
762 * discovered how to enable that. Unfortunately, I do not know how to
763 * enable XON/XOFF (software) flow control, which would need support
764 * from the chip as well to work. Because of the wording on the web
765 * page there is a real possibility the chip simply does not support
766 * software flow control.
768 * I got my ark3116 as part of a mobile phone adapter cable. On the
769 * PCB, the following numbered contacts are present:
782 * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that
783 * may be different for the one you have ;-).
785 * The windows driver limits the registers to 0-F, so I assume there
786 * are actually 16 present on the device.
788 * On an UART interrupt, 4 bytes of data come in on the interrupt
789 * endpoint. The bytes are 0xe8 IIR LSR MSR.
791 * The baudrate seems to be generated from the 12MHz crystal, using
792 * 4-times subsampling. So quot=12e6/(4*baud). Also see description
796 * These seem to be the same as for a regular 16450. The FCR is set
797 * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between
798 * the UART and the USB bridge/DMA engine.
801 * By trial and error, I found out that bit 0 enables hardware CTS,
802 * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making
803 * RTS +5V when the 3116 cannot transfer the data to the USB bus
804 * (verified by disabling the reading URB). Note that as far as I can
805 * tell, the windows driver does NOT use this, so there might be some
806 * hardware bug or something.
808 * According to a patch provided here
809 * (http://lkml.org/lkml/2009/7/26/56), the ARK3116 can also be used
810 * as an IrDA dongle. Since I do not have such a thing, I could not
811 * investigate that aspect. However, I can speculate ;-).
813 * - IrDA encodes data differently than RS232. Most likely, one of
814 * the bits in registers 9..E enables the IR ENDEC (encoder/decoder).
815 * - Depending on the IR transceiver, the input and output need to be
816 * inverted, so there are probably bits for that as well.
817 * - IrDA is half-duplex, so there should be a bit for selecting that.
819 * This still leaves at least two registers unaccounted for. Perhaps
820 * The chip can do XON/XOFF or CRC in HW?
823 * Set to 0x00 for IrDA, when the baudrate is initialised.
826 * Set to 0x01 for IrDA, at init.
829 * Set to 0x01 for IrDA, 0x00 for RS232, at init.
832 * Set to 00 for IrDA, at init.
835 * Set to 0x41 for IrDA, at init.
838 * Somekind of baudrate override. The windows driver seems to set
839 * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600.
840 * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer,
841 * it could be somekind of subdivisor thingy.
842 * However,it does not seem to do anything: selecting 921600 (divisor 3,
843 * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would
844 * work, but they don't.
846 * Register F: unknown