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>
45 #define DRIVER_VERSION "v0.6"
46 #define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
47 #define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
48 #define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
49 #define DRIVER_NAME "ark3116"
51 /* usb timeout of 1 second */
52 #define ARK_TIMEOUT (1*HZ)
54 static const struct usb_device_id id_table
[] = {
55 { USB_DEVICE(0x6547, 0x0232) },
56 { USB_DEVICE(0x18ec, 0x3118) }, /* USB to IrDA adapter */
59 MODULE_DEVICE_TABLE(usb
, id_table
);
61 static int is_irda(struct usb_serial
*serial
)
63 struct usb_device
*dev
= serial
->dev
;
64 if (le16_to_cpu(dev
->descriptor
.idVendor
) == 0x18ec &&
65 le16_to_cpu(dev
->descriptor
.idProduct
) == 0x3118)
70 struct ark3116_private
{
71 wait_queue_head_t delta_msr_wait
;
72 struct async_icount icount
;
73 int irda
; /* 1 for irda device */
75 /* protects hw register updates */
78 int quot
; /* baudrate divisor */
79 __u32 lcr
; /* line control register value */
80 __u32 hcr
; /* handshake control register (0x8)
82 __u32 mcr
; /* modem contol register value */
84 /* protects the status values below */
85 spinlock_t status_lock
;
86 __u32 msr
; /* modem status register value */
87 __u32 lsr
; /* line status register value */
90 static int ark3116_write_reg(struct usb_serial
*serial
,
91 unsigned reg
, __u8 val
)
94 /* 0xfe 0x40 are magic values taken from original driver */
95 result
= usb_control_msg(serial
->dev
,
96 usb_sndctrlpipe(serial
->dev
, 0),
98 NULL
, 0, ARK_TIMEOUT
);
102 static int ark3116_read_reg(struct usb_serial
*serial
,
103 unsigned reg
, unsigned char *buf
)
106 /* 0xfe 0xc0 are magic values taken from original driver */
107 result
= usb_control_msg(serial
->dev
,
108 usb_rcvctrlpipe(serial
->dev
, 0),
110 buf
, 1, ARK_TIMEOUT
);
117 static inline int calc_divisor(int bps
)
119 /* Original ark3116 made some exceptions in rounding here
120 * because windows did the same. Assume that is not really
122 * Crystal is 12MHz, probably because of USB, but we divide by 4?
124 return (12000000 + 2*bps
) / (4*bps
);
127 static int ark3116_attach(struct usb_serial
*serial
)
129 struct usb_serial_port
*port
= serial
->port
[0];
130 struct ark3116_private
*priv
;
132 /* make sure we have our end-points */
133 if ((serial
->num_bulk_in
== 0) ||
134 (serial
->num_bulk_out
== 0) ||
135 (serial
->num_interrupt_in
== 0)) {
136 dev_err(&serial
->dev
->dev
,
137 "%s - missing endpoint - "
138 "bulk in: %d, bulk out: %d, int in %d\n",
141 serial
->num_bulk_out
,
142 serial
->num_interrupt_in
);
146 priv
= kzalloc(sizeof(struct ark3116_private
),
151 init_waitqueue_head(&priv
->delta_msr_wait
);
152 mutex_init(&priv
->hw_lock
);
153 spin_lock_init(&priv
->status_lock
);
155 priv
->irda
= is_irda(serial
);
157 usb_set_serial_port_data(port
, priv
);
159 /* setup the hardware */
160 ark3116_write_reg(serial
, UART_IER
, 0);
162 ark3116_write_reg(serial
, UART_FCR
, 0);
163 /* handshake control */
165 ark3116_write_reg(serial
, 0x8 , 0);
168 ark3116_write_reg(serial
, UART_MCR
, 0);
171 ark3116_write_reg(serial
, 0xb , 0);
173 ark3116_write_reg(serial
, 0xb , 1);
174 ark3116_write_reg(serial
, 0xc , 0);
175 ark3116_write_reg(serial
, 0xd , 0x41);
176 ark3116_write_reg(serial
, 0xa , 1);
180 ark3116_write_reg(serial
, UART_LCR
, UART_LCR_DLAB
);
182 /* setup for 9600 8N1 */
183 priv
->quot
= calc_divisor(9600);
184 ark3116_write_reg(serial
, UART_DLL
, priv
->quot
& 0xff);
185 ark3116_write_reg(serial
, UART_DLM
, (priv
->quot
>>8) & 0xff);
187 priv
->lcr
= UART_LCR_WLEN8
;
188 ark3116_write_reg(serial
, UART_LCR
, UART_LCR_WLEN8
);
190 ark3116_write_reg(serial
, 0xe, 0);
193 ark3116_write_reg(serial
, 0x9, 0);
195 dev_info(&serial
->dev
->dev
,
196 "%s using %s mode\n",
198 priv
->irda
? "IrDA" : "RS232");
202 static void ark3116_release(struct usb_serial
*serial
)
204 struct usb_serial_port
*port
= serial
->port
[0];
205 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
207 /* device is closed, so URBs and DMA should be down */
209 usb_set_serial_port_data(port
, NULL
);
211 mutex_destroy(&priv
->hw_lock
);
216 static void ark3116_init_termios(struct tty_struct
*tty
)
218 struct ktermios
*termios
= tty
->termios
;
219 *termios
= tty_std_termios
;
220 termios
->c_cflag
= B9600
| CS8
221 | CREAD
| HUPCL
| CLOCAL
;
222 termios
->c_ispeed
= 9600;
223 termios
->c_ospeed
= 9600;
226 static void ark3116_set_termios(struct tty_struct
*tty
,
227 struct usb_serial_port
*port
,
228 struct ktermios
*old_termios
)
230 struct usb_serial
*serial
= port
->serial
;
231 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
232 struct ktermios
*termios
= tty
->termios
;
233 unsigned int cflag
= termios
->c_cflag
;
234 int bps
= tty_get_baud_rate(tty
);
238 /* set data bit count */
239 switch (cflag
& CSIZE
) {
241 lcr
= UART_LCR_WLEN5
;
244 lcr
= UART_LCR_WLEN6
;
247 lcr
= UART_LCR_WLEN7
;
251 lcr
= UART_LCR_WLEN8
;
255 lcr
|= UART_LCR_STOP
;
257 lcr
|= UART_LCR_PARITY
;
258 if (!(cflag
& PARODD
))
259 lcr
|= UART_LCR_EPAR
;
262 lcr
|= UART_LCR_SPAR
;
264 /* handshake control */
265 hcr
= (cflag
& CRTSCTS
) ? 0x03 : 0x00;
268 dbg("%s - setting bps to %d", __func__
, bps
);
272 quot
= calc_divisor(9600);
275 if ((bps
< 75) || (bps
> 3000000))
277 quot
= calc_divisor(bps
);
281 quot
= calc_divisor(bps
);
285 quot
= calc_divisor(bps
);
289 /* Update state: synchronize */
290 mutex_lock(&priv
->hw_lock
);
292 /* keep old LCR_SBC bit */
293 lcr
|= (priv
->lcr
& UART_LCR_SBC
);
295 dbg("%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d",
296 __func__
, hcr
, lcr
, quot
);
298 /* handshake control */
299 if (priv
->hcr
!= hcr
) {
301 ark3116_write_reg(serial
, 0x8, hcr
);
305 if (priv
->quot
!= quot
) {
307 priv
->lcr
= lcr
; /* need to write lcr anyway */
309 /* disable DMA since transmit/receive is
310 * shadowed by UART_DLL
312 ark3116_write_reg(serial
, UART_FCR
, 0);
314 ark3116_write_reg(serial
, UART_LCR
,
316 ark3116_write_reg(serial
, UART_DLL
, quot
& 0xff);
317 ark3116_write_reg(serial
, UART_DLM
, (quot
>>8) & 0xff);
320 ark3116_write_reg(serial
, UART_LCR
, lcr
);
321 /* magic baudrate thingy: not sure what it does,
322 * but windows does this as well.
324 ark3116_write_reg(serial
, 0xe, eval
);
327 ark3116_write_reg(serial
, UART_FCR
, UART_FCR_DMA_SELECT
);
328 } else if (priv
->lcr
!= lcr
) {
330 ark3116_write_reg(serial
, UART_LCR
, lcr
);
333 mutex_unlock(&priv
->hw_lock
);
335 /* check for software flow control */
336 if (I_IXOFF(tty
) || I_IXON(tty
)) {
337 dev_warn(&serial
->dev
->dev
,
338 "%s: don't know how to do software flow control\n",
342 /* Don't rewrite B0 */
343 if (tty_termios_baud_rate(termios
))
344 tty_termios_encode_baud_rate(termios
, bps
, bps
);
347 static void ark3116_close(struct usb_serial_port
*port
)
349 struct usb_serial
*serial
= port
->serial
;
353 ark3116_write_reg(serial
, UART_FCR
, 0);
355 /* deactivate interrupts */
356 ark3116_write_reg(serial
, UART_IER
, 0);
358 usb_serial_generic_close(port
);
359 if (serial
->num_interrupt_in
)
360 usb_kill_urb(port
->interrupt_in_urb
);
365 static int ark3116_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
367 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
368 struct usb_serial
*serial
= port
->serial
;
372 buf
= kmalloc(1, GFP_KERNEL
);
376 result
= usb_serial_generic_open(tty
, port
);
378 dbg("%s - usb_serial_generic_open failed: %d",
385 ark3116_set_termios(tty
, port
, NULL
);
387 /* remove any data still left: also clears error state */
388 ark3116_read_reg(serial
, UART_RX
, buf
);
390 /* read modem status */
391 priv
->msr
= ark3116_read_reg(serial
, UART_MSR
, buf
);
392 /* read line status */
393 priv
->lsr
= ark3116_read_reg(serial
, UART_LSR
, buf
);
395 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
397 dev_err(&port
->dev
, "submit irq_in urb failed %d\n",
403 /* activate interrupts */
404 ark3116_write_reg(port
->serial
, UART_IER
, UART_IER_MSI
|UART_IER_RLSI
);
407 ark3116_write_reg(port
->serial
, UART_FCR
, UART_FCR_DMA_SELECT
);
414 static int ark3116_ioctl(struct tty_struct
*tty
, struct file
*file
,
415 unsigned int cmd
, unsigned long arg
)
417 struct usb_serial_port
*port
= tty
->driver_data
;
418 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
419 struct serial_struct serstruct
;
420 void __user
*user_arg
= (void __user
*)arg
;
424 memset(&serstruct
, 0, sizeof(serstruct
));
425 serstruct
.type
= PORT_16654
;
426 serstruct
.line
= port
->serial
->minor
;
427 serstruct
.port
= port
->number
;
428 serstruct
.custom_divisor
= 0;
429 serstruct
.baud_base
= 460800;
431 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
436 if (copy_from_user(&serstruct
, user_arg
, sizeof(serstruct
)))
441 struct async_icount prev
= priv
->icount
;
442 interruptible_sleep_on(&priv
->delta_msr_wait
);
443 /* see if a signal did it */
444 if (signal_pending(current
))
446 if ((prev
.rng
== priv
->icount
.rng
) &&
447 (prev
.dsr
== priv
->icount
.dsr
) &&
448 (prev
.dcd
== priv
->icount
.dcd
) &&
449 (prev
.cts
== priv
->icount
.cts
))
451 if ((arg
& TIOCM_RNG
&&
452 (prev
.rng
!= priv
->icount
.rng
)) ||
454 (prev
.dsr
!= priv
->icount
.dsr
)) ||
456 (prev
.dcd
!= priv
->icount
.dcd
)) ||
458 (prev
.cts
!= priv
->icount
.cts
)))
463 struct serial_icounter_struct icount
;
464 struct async_icount cnow
= priv
->icount
;
465 memset(&icount
, 0, sizeof(icount
));
466 icount
.cts
= cnow
.cts
;
467 icount
.dsr
= cnow
.dsr
;
468 icount
.rng
= cnow
.rng
;
469 icount
.dcd
= cnow
.dcd
;
472 icount
.frame
= cnow
.frame
;
473 icount
.overrun
= cnow
.overrun
;
474 icount
.parity
= cnow
.parity
;
475 icount
.brk
= cnow
.brk
;
476 icount
.buf_overrun
= cnow
.buf_overrun
;
477 if (copy_to_user(user_arg
, &icount
, sizeof(icount
)))
486 static int ark3116_tiocmget(struct tty_struct
*tty
, struct file
*file
)
488 struct usb_serial_port
*port
= tty
->driver_data
;
489 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
494 mutex_lock(&priv
->hw_lock
);
496 mutex_unlock(&priv
->hw_lock
);
498 spin_lock_irqsave(&priv
->status_lock
, flags
);
500 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
502 return (status
& UART_MSR_DSR
? TIOCM_DSR
: 0) |
503 (status
& UART_MSR_CTS
? TIOCM_CTS
: 0) |
504 (status
& UART_MSR_RI
? TIOCM_RI
: 0) |
505 (status
& UART_MSR_DCD
? TIOCM_CD
: 0) |
506 (ctrl
& UART_MCR_DTR
? TIOCM_DTR
: 0) |
507 (ctrl
& UART_MCR_RTS
? TIOCM_RTS
: 0) |
508 (ctrl
& UART_MCR_OUT1
? TIOCM_OUT1
: 0) |
509 (ctrl
& UART_MCR_OUT2
? TIOCM_OUT2
: 0);
512 static int ark3116_tiocmset(struct tty_struct
*tty
, struct file
*file
,
513 unsigned set
, unsigned clr
)
515 struct usb_serial_port
*port
= tty
->driver_data
;
516 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
518 /* we need to take the mutex here, to make sure that the value
519 * in priv->mcr is actually the one that is in the hardware
522 mutex_lock(&priv
->hw_lock
);
525 priv
->mcr
|= UART_MCR_RTS
;
527 priv
->mcr
|= UART_MCR_DTR
;
528 if (set
& TIOCM_OUT1
)
529 priv
->mcr
|= UART_MCR_OUT1
;
530 if (set
& TIOCM_OUT2
)
531 priv
->mcr
|= UART_MCR_OUT2
;
533 priv
->mcr
&= ~UART_MCR_RTS
;
535 priv
->mcr
&= ~UART_MCR_DTR
;
536 if (clr
& TIOCM_OUT1
)
537 priv
->mcr
&= ~UART_MCR_OUT1
;
538 if (clr
& TIOCM_OUT2
)
539 priv
->mcr
&= ~UART_MCR_OUT2
;
541 ark3116_write_reg(port
->serial
, UART_MCR
, priv
->mcr
);
543 mutex_unlock(&priv
->hw_lock
);
548 static void ark3116_break_ctl(struct tty_struct
*tty
, int break_state
)
550 struct usb_serial_port
*port
= tty
->driver_data
;
551 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
553 /* LCR is also used for other things: protect access */
554 mutex_lock(&priv
->hw_lock
);
557 priv
->lcr
|= UART_LCR_SBC
;
559 priv
->lcr
&= ~UART_LCR_SBC
;
561 ark3116_write_reg(port
->serial
, UART_LCR
, priv
->lcr
);
563 mutex_unlock(&priv
->hw_lock
);
566 static void ark3116_update_msr(struct usb_serial_port
*port
, __u8 msr
)
568 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
571 spin_lock_irqsave(&priv
->status_lock
, flags
);
573 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
575 if (msr
& UART_MSR_ANY_DELTA
) {
576 /* update input line counters */
577 if (msr
& UART_MSR_DCTS
)
579 if (msr
& UART_MSR_DDSR
)
581 if (msr
& UART_MSR_DDCD
)
583 if (msr
& UART_MSR_TERI
)
585 wake_up_interruptible(&priv
->delta_msr_wait
);
589 static void ark3116_update_lsr(struct usb_serial_port
*port
, __u8 lsr
)
591 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
594 spin_lock_irqsave(&priv
->status_lock
, flags
);
597 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
599 if (lsr
&UART_LSR_BRK_ERROR_BITS
) {
600 if (lsr
& UART_LSR_BI
)
602 if (lsr
& UART_LSR_FE
)
603 priv
->icount
.frame
++;
604 if (lsr
& UART_LSR_PE
)
605 priv
->icount
.parity
++;
606 if (lsr
& UART_LSR_OE
)
607 priv
->icount
.overrun
++;
611 static void ark3116_read_int_callback(struct urb
*urb
)
613 struct usb_serial_port
*port
= urb
->context
;
614 int status
= urb
->status
;
615 const __u8
*data
= urb
->transfer_buffer
;
622 /* this urb is terminated, clean up */
623 dbg("%s - urb shutting down with status: %d",
627 dbg("%s - nonzero urb status received: %d",
630 case 0: /* success */
631 /* discovered this by trail and error... */
632 if ((urb
->actual_length
== 4) && (data
[0] == 0xe8)) {
633 const __u8 id
= data
[1]&UART_IIR_ID
;
634 dbg("%s: iir=%02x", __func__
, data
[1]);
635 if (id
== UART_IIR_MSI
) {
636 dbg("%s: msr=%02x", __func__
, data
[3]);
637 ark3116_update_msr(port
, data
[3]);
639 } else if (id
== UART_IIR_RLSI
) {
640 dbg("%s: lsr=%02x", __func__
, data
[2]);
641 ark3116_update_lsr(port
, data
[2]);
646 * Not sure what this data meant...
648 usb_serial_debug_data(debug
, &port
->dev
,
651 urb
->transfer_buffer
);
655 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
657 dev_err(&urb
->dev
->dev
,
658 "%s - Error %d submitting interrupt urb\n",
663 /* Data comes in via the bulk (data) URB, erors/interrupts via the int URB.
664 * This means that we cannot be sure which data byte has an associated error
665 * condition, so we report an error for all data in the next bulk read.
667 * Actually, there might even be a window between the bulk data leaving the
668 * ark and reading/resetting the lsr in the read_bulk_callback where an
669 * interrupt for the next data block could come in.
670 * Without somekind of ordering on the ark, we would have to report the
671 * error for the next block of data as well...
672 * For now, let's pretend this can't happen.
674 static void ark3116_process_read_urb(struct urb
*urb
)
676 struct usb_serial_port
*port
= urb
->context
;
677 struct ark3116_private
*priv
= usb_get_serial_port_data(port
);
678 struct tty_struct
*tty
;
679 unsigned char *data
= urb
->transfer_buffer
;
680 char tty_flag
= TTY_NORMAL
;
684 /* update line status */
685 spin_lock_irqsave(&priv
->status_lock
, flags
);
687 priv
->lsr
&= ~UART_LSR_BRK_ERROR_BITS
;
688 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
690 if (!urb
->actual_length
)
693 tty
= tty_port_tty_get(&port
->port
);
697 if (lsr
& UART_LSR_BRK_ERROR_BITS
) {
698 if (lsr
& UART_LSR_BI
)
699 tty_flag
= TTY_BREAK
;
700 else if (lsr
& UART_LSR_PE
)
701 tty_flag
= TTY_PARITY
;
702 else if (lsr
& UART_LSR_FE
)
703 tty_flag
= TTY_FRAME
;
705 /* overrun is special, not associated with a char */
706 if (lsr
& UART_LSR_OE
)
707 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
709 tty_insert_flip_string_fixed_flag(tty
, data
, tty_flag
,
711 tty_flip_buffer_push(tty
);
715 static struct usb_driver ark3116_driver
= {
717 .probe
= usb_serial_probe
,
718 .disconnect
= usb_serial_disconnect
,
719 .id_table
= id_table
,
723 static struct usb_serial_driver ark3116_device
= {
725 .owner
= THIS_MODULE
,
728 .id_table
= id_table
,
729 .usb_driver
= &ark3116_driver
,
731 .attach
= ark3116_attach
,
732 .release
= ark3116_release
,
733 .set_termios
= ark3116_set_termios
,
734 .init_termios
= ark3116_init_termios
,
735 .ioctl
= ark3116_ioctl
,
736 .tiocmget
= ark3116_tiocmget
,
737 .tiocmset
= ark3116_tiocmset
,
738 .open
= ark3116_open
,
739 .close
= ark3116_close
,
740 .break_ctl
= ark3116_break_ctl
,
741 .read_int_callback
= ark3116_read_int_callback
,
742 .process_read_urb
= ark3116_process_read_urb
,
745 static int __init
ark3116_init(void)
749 retval
= usb_serial_register(&ark3116_device
);
752 retval
= usb_register(&ark3116_driver
);
754 printk(KERN_INFO
"%s:"
759 usb_serial_deregister(&ark3116_device
);
763 static void __exit
ark3116_exit(void)
765 usb_deregister(&ark3116_driver
);
766 usb_serial_deregister(&ark3116_device
);
769 module_init(ark3116_init
);
770 module_exit(ark3116_exit
);
771 MODULE_LICENSE("GPL");
773 MODULE_AUTHOR(DRIVER_AUTHOR
);
774 MODULE_DESCRIPTION(DRIVER_DESC
);
776 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
777 MODULE_PARM_DESC(debug
, "Enable debug");
780 * The following describes what I learned from studying the old
781 * ark3116.c driver, disassembling the windows driver, and some lucky
782 * guesses. Since I do not have any datasheet or other
783 * documentation, inaccuracies are almost guaranteed.
785 * Some specs for the ARK3116 can be found here:
786 * http://web.archive.org/web/20060318000438/
787 * www.arkmicro.com/en/products/view.php?id=10
788 * On that page, 2 GPIO pins are mentioned: I assume these are the
789 * OUT1 and OUT2 pins of the UART, so I added support for those
790 * through the MCR. Since the pins are not available on my hardware,
791 * I could not verify this.
792 * Also, it states there is "on-chip hardware flow control". I have
793 * discovered how to enable that. Unfortunately, I do not know how to
794 * enable XON/XOFF (software) flow control, which would need support
795 * from the chip as well to work. Because of the wording on the web
796 * page there is a real possibility the chip simply does not support
797 * software flow control.
799 * I got my ark3116 as part of a mobile phone adapter cable. On the
800 * PCB, the following numbered contacts are present:
813 * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that
814 * may be different for the one you have ;-).
816 * The windows driver limits the registers to 0-F, so I assume there
817 * are actually 16 present on the device.
819 * On an UART interrupt, 4 bytes of data come in on the interrupt
820 * endpoint. The bytes are 0xe8 IIR LSR MSR.
822 * The baudrate seems to be generated from the 12MHz crystal, using
823 * 4-times subsampling. So quot=12e6/(4*baud). Also see description
827 * These seem to be the same as for a regular 16450. The FCR is set
828 * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between
829 * the UART and the USB bridge/DMA engine.
832 * By trial and error, I found out that bit 0 enables hardware CTS,
833 * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making
834 * RTS +5V when the 3116 cannot transfer the data to the USB bus
835 * (verified by disabling the reading URB). Note that as far as I can
836 * tell, the windows driver does NOT use this, so there might be some
837 * hardware bug or something.
839 * According to a patch provided here
840 * (http://lkml.org/lkml/2009/7/26/56), the ARK3116 can also be used
841 * as an IrDA dongle. Since I do not have such a thing, I could not
842 * investigate that aspect. However, I can speculate ;-).
844 * - IrDA encodes data differently than RS232. Most likely, one of
845 * the bits in registers 9..E enables the IR ENDEC (encoder/decoder).
846 * - Depending on the IR transceiver, the input and output need to be
847 * inverted, so there are probably bits for that as well.
848 * - IrDA is half-duplex, so there should be a bit for selecting that.
850 * This still leaves at least two registers unaccounted for. Perhaps
851 * The chip can do XON/XOFF or CRC in HW?
854 * Set to 0x00 for IrDA, when the baudrate is initialised.
857 * Set to 0x01 for IrDA, at init.
860 * Set to 0x01 for IrDA, 0x00 for RS232, at init.
863 * Set to 00 for IrDA, at init.
866 * Set to 0x41 for IrDA, at init.
869 * Somekind of baudrate override. The windows driver seems to set
870 * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600.
871 * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer,
872 * it could be somekind of subdivisor thingy.
873 * However,it does not seem to do anything: selecting 921600 (divisor 3,
874 * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would
875 * work, but they don't.
877 * Register F: unknown