ark3116.c 17.9 KB
Newer Older
1
/*
2 3
 * Copyright (C) 2009 by Bart Hartgers (bart.hartgers+ark3116@gmail.com)
 * Original version:
4 5 6
 * Copyright (C) 2006
 *   Simon Schulz (ark3116_driver <at> auctionant.de)
 *
7 8 9 10
 * ark3116
 * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
 *   productid=0x0232) (used in a datacable called KQ-U8A)
 *
11 12
 * Supports full modem status lines, break, hardware flow control. Does not
 * support software flow control, since I do not know how to enable it in hw.
13
 *
14 15 16 17
 * This driver is a essentially new implementation. I initially dug
 * into the old ark3116.c driver and suddenly realized the ark3116 is
 * a 16450 with a USB interface glued to it. See comments at the
 * bottom of this file.
18 19 20 21 22 23 24 25 26
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/init.h>
27
#include <linux/ioctl.h>
28
#include <linux/tty.h>
29
#include <linux/tty_flip.h>
30 31
#include <linux/module.h>
#include <linux/usb.h>
32
#include <linux/usb/serial.h>
33
#include <linux/serial.h>
34
#include <linux/serial_reg.h>
Alan Cox's avatar
Alan Cox committed
35
#include <linux/uaccess.h>
36 37
#include <linux/mutex.h>
#include <linux/spinlock.h>
38 39

static int debug;
40 41 42 43 44 45 46 47 48 49 50 51
/*
 * Version information
 */

#define DRIVER_VERSION "v0.5"
#define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
#define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
#define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
#define DRIVER_NAME "ark3116"

/* usb timeout of 1 second */
#define ARK_TIMEOUT (1*HZ)
52 53 54

static struct usb_device_id id_table [] = {
	{ USB_DEVICE(0x6547, 0x0232) },
55
	{ USB_DEVICE(0x18ec, 0x3118) },		/* USB to IrDA adapter */
56 57 58 59
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

60 61 62 63 64 65 66 67 68
static int is_irda(struct usb_serial *serial)
{
	struct usb_device *dev = serial->dev;
	if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
			le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
		return 1;
	return 0;
}

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
struct ark3116_private {
	wait_queue_head_t       delta_msr_wait;
	struct async_icount	icount;
	int			irda;	/* 1 for irda device */

	/* protects hw register updates */
	struct mutex		hw_lock;

	int			quot;	/* baudrate divisor */
	__u32			lcr;	/* line control register value */
	__u32			hcr;	/* handshake control register (0x8)
					 * value */
	__u32			mcr;	/* modem contol register value */

	/* protects the status values below */
	spinlock_t		status_lock;
	__u32			msr;	/* modem status register value */
	__u32			lsr;	/* line status register value */
};

static int ark3116_write_reg(struct usb_serial *serial,
			     unsigned reg, __u8 val)
{
	int result;
	 /* 0xfe 0x40 are magic values taken from original driver */
	result = usb_control_msg(serial->dev,
				 usb_sndctrlpipe(serial->dev, 0),
				 0xfe, 0x40, val, reg,
				 NULL, 0, ARK_TIMEOUT);
	return result;
}

static int ark3116_read_reg(struct usb_serial *serial,
			    unsigned reg, unsigned char *buf)
{
	int result;
	/* 0xfe 0xc0 are magic values taken from original driver */
	result = usb_control_msg(serial->dev,
				 usb_rcvctrlpipe(serial->dev, 0),
				 0xfe, 0xc0, 0, reg,
				 buf, 1, ARK_TIMEOUT);
	if (result < 0)
		return result;
	else
		return buf[0];
}

116 117 118 119 120 121
static inline void ARK3116_SND(struct usb_serial *serial, int seq,
			       __u8 request, __u8 requesttype,
			       __u16 value, __u16 index)
{
	int result;
	result = usb_control_msg(serial->dev,
122
				 usb_sndctrlpipe(serial->dev, 0),
123
				 request, requesttype, value, index,
124 125
				 NULL, 0x00, 1000);
	dbg("%03d > ok", seq);
126 127 128 129 130 131 132 133 134
}

static inline void ARK3116_RCV(struct usb_serial *serial, int seq,
			       __u8 request, __u8 requesttype,
			       __u16 value, __u16 index, __u8 expected,
			       char *buf)
{
	int result;
	result = usb_control_msg(serial->dev,
135 136 137
				 usb_rcvctrlpipe(serial->dev, 0),
				 request, requesttype, value, index,
				 buf, 0x0000001, 1000);
138
	if (result)
139 140
		dbg("%03d < %d bytes [0x%02X]", seq, result,
		    ((unsigned char *)buf)[0]);
141 142 143 144 145 146 147 148 149
	else
		dbg("%03d < 0 bytes", seq);
}

static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
				     __u8 request, __u8 requesttype,
				     __u16 value, __u16 index, char *buf)
{
	usb_control_msg(serial->dev,
150
			usb_rcvctrlpipe(serial->dev, 0),
151 152 153 154 155 156 157 158 159 160
			request, requesttype, value, index,
			buf, 0x0000001, 1000);
}

static int ark3116_attach(struct usb_serial *serial)
{
	char *buf;

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
161
		dbg("error kmalloc -> out of mem?");
Alan Cox's avatar
Alan Cox committed
162
		return -ENOMEM;
163 164
	}

165 166 167
	if (is_irda(serial))
		dbg("IrDA mode");

168
	/* 3 */
169 170 171
	ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
	ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
	ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
172 173 174 175 176 177 178 179
	ARK3116_SND(serial, 6, 0xFE, 0x40, is_irda(serial) ? 0x0001 : 0x0000,
		    0x000B);

	if (is_irda(serial)) {
		ARK3116_SND(serial, 1001, 0xFE, 0x40, 0x0000, 0x000C);
		ARK3116_SND(serial, 1002, 0xFE, 0x40, 0x0041, 0x000D);
		ARK3116_SND(serial, 1003, 0xFE, 0x40, 0x0001, 0x000A);
	}
180 181

	/* <-- seq7 */
182 183 184 185 186
	ARK3116_RCV(serial,  7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial,  8, 0xFE, 0x40, 0x0080, 0x0003);
	ARK3116_SND(serial,  9, 0xFE, 0x40, 0x001A, 0x0000);
	ARK3116_SND(serial, 10, 0xFE, 0x40, 0x0000, 0x0001);
	ARK3116_SND(serial, 11, 0xFE, 0x40, 0x0000, 0x0003);
187 188

	/* <-- seq12 */
189 190
	ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
	ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004);
191 192

	/* 14 */
193 194
	ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
	ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004);
195 196

	/* 16 */
197
	ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
198
	/* --> seq17 */
199
	ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004);
200 201

	/* <-- seq18 */
202
	ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
203 204

	/* --> seq19 */
205
	ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004);
206 207

	/* <-- seq20 */
208 209 210 211 212 213 214 215
	/* seems like serial port status info (RTS, CTS, ...) */
	/* returns modem control line status?! */
	ARK3116_RCV(serial, 20, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);

	/* set 9600 baud & do some init?! */
	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
	ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
216 217
	if (is_irda(serial))
		ARK3116_SND(serial, 1004, 0xFE, 0x40, 0x0000, 0x0009);
218 219 220 221 222
	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial, 154, 0xFE, 0x40, 0x0003, 0x0003);
223 224

	kfree(buf);
225
	return 0;
Alan Cox's avatar
Alan Cox committed
226
}
227

Alan Cox's avatar
Alan Cox committed
228 229 230 231 232 233 234 235
static void ark3116_init_termios(struct tty_struct *tty)
{
	struct ktermios *termios = tty->termios;
	*termios = tty_std_termios;
	termios->c_cflag = B9600 | CS8
				      | CREAD | HUPCL | CLOCAL;
	termios->c_ispeed = 9600;
	termios->c_ospeed = 9600;
236 237
}

Alan Cox's avatar
Alan Cox committed
238 239
static void ark3116_set_termios(struct tty_struct *tty,
				struct usb_serial_port *port,
Alan Cox's avatar
Alan Cox committed
240
				struct ktermios *old_termios)
241 242
{
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
243
	struct ktermios *termios = tty->termios;
244
	unsigned int cflag = termios->c_cflag;
245 246 247 248 249 250 251
	int baud;
	int ark3116_baud;
	char *buf;
	char config;

	config = 0;

252
	dbg("%s - port %d", __func__, port->number);
253 254


255 256
	cflag = termios->c_cflag;
	termios->c_cflag &= ~(CMSPAR|CRTSCTS);
257 258 259 260

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		dbg("error kmalloc");
Alan Cox's avatar
Alan Cox committed
261
		*termios = *old_termios;
262 263 264 265
		return;
	}

	/* set data bit count (8/7/6/5) */
266 267
	if (cflag & CSIZE) {
		switch (cflag & CSIZE) {
268 269 270 271 272 273 274 275 276 277 278 279 280
		case CS5:
			config |= 0x00;
			dbg("setting CS5");
			break;
		case CS6:
			config |= 0x01;
			dbg("setting CS6");
			break;
		case CS7:
			config |= 0x02;
			dbg("setting CS7");
			break;
		default:
281
			dbg("CSIZE was set but not CS5-CS8, using CS8!");
282
			/* fall through */
283 284 285 286 287 288 289
		case CS8:
			config |= 0x03;
			dbg("setting CS8");
			break;
		}
	}

290 291
	/* set parity (NONE/EVEN/ODD) */
	if (cflag & PARENB) {
292 293 294 295 296 297 298 299 300 301 302
		if (cflag & PARODD) {
			config |= 0x08;
			dbg("setting parity to ODD");
		} else {
			config |= 0x18;
			dbg("setting parity to EVEN");
		}
	} else {
		dbg("setting parity to NONE");
	}

303
	/* set stop bit (1/2) */
304 305
	if (cflag & CSTOPB) {
		config |= 0x04;
306
		dbg("setting 2 stop bits");
307
	} else {
308
		dbg("setting 1 stop bit");
309 310
	}

311
	/* set baudrate */
Alan Cox's avatar
Alan Cox committed
312
	baud = tty_get_baud_rate(tty);
313 314

	switch (baud) {
Alan Cox's avatar
Alan Cox committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	case 75:
	case 150:
	case 300:
	case 600:
	case 1200:
	case 1800:
	case 2400:
	case 4800:
	case 9600:
	case 19200:
	case 38400:
	case 57600:
	case 115200:
	case 230400:
	case 460800:
		/* Report the resulting rate back to the caller */
Alan Cox's avatar
Alan Cox committed
331
		tty_encode_baud_rate(tty, baud, baud);
Alan Cox's avatar
Alan Cox committed
332 333 334
		break;
	/* set 9600 as default (if given baudrate is invalid for example) */
	default:
Alan Cox's avatar
Alan Cox committed
335
		tty_encode_baud_rate(tty, 9600, 9600);
Alan Cox's avatar
Alan Cox committed
336 337
	case 0:
		baud = 9600;
338 339 340 341
	}

	/*
	 * found by try'n'error, be careful, maybe there are other options
342
	 * for multiplicator etc! (3.5 for example)
343 344 345
	 */
	if (baud == 460800)
		/* strange, for 460800 the formula is wrong
346
		 * if using round() then 9600baud is wrong) */
347 348 349 350 351
		ark3116_baud = 7;
	else
		ark3116_baud = 3000000 / baud;

	/* ? */
352 353
	ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf);

354 355
	/* offset = buf[0]; */
	/* offset = 0x03; */
356
	/* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */
357 358

	/* set baudrate */
359 360 361 362 363 364 365
	dbg("setting baudrate to %d (->reg=%d)", baud, ark3116_baud);
	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	ARK3116_SND(serial, 148, 0xFE, 0x40,
			    (ark3116_baud & 0x00FF), 0x0000);
	ARK3116_SND(serial, 149, 0xFE, 0x40,
			    (ark3116_baud & 0xFF00) >> 8, 0x0001);
	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
366 367

	/* ? */
368 369
	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
370 371 372

	/* set data bit count, stop bit count & parity: */
	dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config);
373 374
	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003);
375 376

	if (cflag & CRTSCTS)
377
		dbg("CRTSCTS not supported by chipset?!");
378

379
	/* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */
380 381

	kfree(buf);
382

383 384 385
	return;
}

386
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
387
{
Alan Cox's avatar
Alan Cox committed
388
	struct ktermios tmp_termios;
389 390 391 392
	struct usb_serial *serial = port->serial;
	char *buf;
	int result = 0;

393
	dbg("%s - port %d", __func__, port->number);
394 395 396

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
397
		dbg("error kmalloc -> out of mem?");
398 399 400
		return -ENOMEM;
	}

401
	result = usb_serial_generic_open(tty, port);
402
	if (result)
Oliver Neukum's avatar
Oliver Neukum committed
403
		goto err_out;
404 405

	/* open */
406
	ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf);
407

408 409 410 411
	ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003);
	ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000);
	ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001);
	ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003);
412

413 414
	ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004);
415

416 417
	ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf);
	ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004);
418

419
	ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
420

421
	ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004);
422

423
	ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
424

425
	ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004);
426

427 428
	/* returns different values (control lines?!) */
	ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
429

430
	/* initialise termios */
Alan Cox's avatar
Alan Cox committed
431 432
	if (tty)
		ark3116_set_termios(tty, port, &tmp_termios);
433

Oliver Neukum's avatar
Oliver Neukum committed
434
err_out:
435 436 437 438 439
	kfree(buf);

	return result;
}

Alan Cox's avatar
Alan Cox committed
440
static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
441 442
			 unsigned int cmd, unsigned long arg)
{
Alan Cox's avatar
Alan Cox committed
443
	struct usb_serial_port *port = tty->driver_data;
444 445 446 447 448 449
	struct serial_struct serstruct;
	void __user *user_arg = (void __user *)arg;

	switch (cmd) {
	case TIOCGSERIAL:
		/* XXX: Some of these values are probably wrong. */
Alan Cox's avatar
Alan Cox committed
450
		memset(&serstruct, 0, sizeof(serstruct));
451 452 453 454 455 456
		serstruct.type = PORT_16654;
		serstruct.line = port->serial->minor;
		serstruct.port = port->number;
		serstruct.custom_divisor = 0;
		serstruct.baud_base = 460800;

Alan Cox's avatar
Alan Cox committed
457
		if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
458 459 460 461
			return -EFAULT;

		return 0;
	case TIOCSSERIAL:
Alan Cox's avatar
Alan Cox committed
462
		if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
463 464 465
			return -EFAULT;
		return 0;
	default:
466
		dbg("%s cmd 0x%04x not supported", __func__, cmd);
467 468 469
		break;
	}

470 471 472
	return -ENOIOCTLCMD;
}

Alan Cox's avatar
Alan Cox committed
473
static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
474
{
Alan Cox's avatar
Alan Cox committed
475
	struct usb_serial_port *port = tty->driver_data;
476 477 478 479
	struct usb_serial *serial = port->serial;
	char *buf;
	char temp;

480
	/* seems like serial port status info (RTS, CTS, ...) is stored
481 482 483 484 485 486 487 488 489 490 491
	 * in reg(?) 0x0006
	 * pcb connection point 11 = GND -> sets bit4 of response
	 * pcb connection point  7 = GND -> sets bit6 of response
	 */

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		dbg("error kmalloc");
		return -ENOMEM;
	}

492 493
	/* read register */
	ARK3116_RCV_QUIET(serial, 0xFE, 0xC0, 0x0000, 0x0006, buf);
494 495 496
	temp = buf[0];
	kfree(buf);

497 498
	/* i do not really know if bit4=CTS and bit6=DSR... just a
	 * quick guess!
499
	 */
500 501
	return (temp & (1<<4) ? TIOCM_CTS : 0)
	       | (temp & (1<<6) ? TIOCM_DSR : 0);
502 503 504 505 506 507 508
}

static struct usb_driver ark3116_driver = {
	.name =		"ark3116",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
509
	.no_dynamic_id =	1,
510 511 512 513 514 515 516 517
};

static struct usb_serial_driver ark3116_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"ark3116",
	},
	.id_table =		id_table,
518
	.usb_driver =		&ark3116_driver,
519 520 521
	.num_ports =		1,
	.attach =		ark3116_attach,
	.set_termios =		ark3116_set_termios,
Alan Cox's avatar
Alan Cox committed
522
	.init_termios =		ark3116_init_termios,
523 524 525 526 527 528 529 530 531 532 533 534 535
	.ioctl =		ark3116_ioctl,
	.tiocmget =		ark3116_tiocmget,
	.open =			ark3116_open,
};

static int __init ark3116_init(void)
{
	int retval;

	retval = usb_serial_register(&ark3116_device);
	if (retval)
		return retval;
	retval = usb_register(&ark3116_driver);
536 537 538 539 540 541
	if (retval == 0) {
		printk(KERN_INFO "%s:"
		       DRIVER_VERSION ":"
		       DRIVER_DESC "\n",
		       KBUILD_MODNAME);
	} else
542 543 544 545 546 547 548 549 550 551 552 553 554 555
		usb_serial_deregister(&ark3116_device);
	return retval;
}

static void __exit ark3116_exit(void)
{
	usb_deregister(&ark3116_driver);
	usb_serial_deregister(&ark3116_device);
}

module_init(ark3116_init);
module_exit(ark3116_exit);
MODULE_LICENSE("GPL");

556 557 558
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);

559
module_param(debug, bool, S_IRUGO | S_IWUSR);
560
MODULE_PARM_DESC(debug, "Enable debug");
561

562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
/*
 * The following describes what I learned from studying the old
 * ark3116.c driver, disassembling the windows driver, and some lucky
 * guesses. Since I do not have any datasheet or other
 * documentation, inaccuracies are almost guaranteed.
 *
 * Some specs for the ARK3116 can be found here:
 * http://web.archive.org/web/20060318000438/
 *   www.arkmicro.com/en/products/view.php?id=10
 * On that page, 2 GPIO pins are mentioned: I assume these are the
 * OUT1 and OUT2 pins of the UART, so I added support for those
 * through the MCR. Since the pins are not available on my hardware,
 * I could not verify this.
 * Also, it states there is "on-chip hardware flow control". I have
 * discovered how to enable that. Unfortunately, I do not know how to
 * enable XON/XOFF (software) flow control, which would need support
 * from the chip as well to work. Because of the wording on the web
 * page there is a real possibility the chip simply does not support
 * software flow control.
 *
 * I got my ark3116 as part of a mobile phone adapter cable. On the
 * PCB, the following numbered contacts are present:
 *
 *  1:- +5V
 *  2:o DTR
 *  3:i RX
 *  4:i DCD
 *  5:o RTS
 *  6:o TX
 *  7:i RI
 *  8:i DSR
 * 10:- 0V
 * 11:i CTS
 *
 * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that
 * may be different for the one you have ;-).
 *
 * The windows driver limits the registers to 0-F, so I assume there
 * are actually 16 present on the device.
 *
 * On an UART interrupt, 4 bytes of data come in on the interrupt
 * endpoint. The bytes are 0xe8 IIR LSR MSR.
 *
 * The baudrate seems to be generated from the 12MHz crystal, using
 * 4-times subsampling. So quot=12e6/(4*baud). Also see description
 * of register E.
 *
 * Registers 0-7:
 * These seem to be the same as for a regular 16450. The FCR is set
 * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between
 * the UART and the USB bridge/DMA engine.
 *
 * Register 8:
 * By trial and error, I found out that bit 0 enables hardware CTS,
 * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making
 * RTS +5V when the 3116 cannot transfer the data to the USB bus
 * (verified by disabling the reading URB). Note that as far as I can
 * tell, the windows driver does NOT use this, so there might be some
 * hardware bug or something.
 *
 * According to a patch provided here
 * (http://lkml.org/lkml/2009/7/26/56), the ARK3116 can also be used
 * as an IrDA dongle. Since I do not have such a thing, I could not
 * investigate that aspect. However, I can speculate ;-).
 *
 * - IrDA encodes data differently than RS232. Most likely, one of
 *   the bits in registers 9..E enables the IR ENDEC (encoder/decoder).
 * - Depending on the IR transceiver, the input and output need to be
 *   inverted, so there are probably bits for that as well.
 * - IrDA is half-duplex, so there should be a bit for selecting that.
 *
 * This still leaves at least two registers unaccounted for. Perhaps
 * The chip can do XON/XOFF or CRC in HW?
 *
 * Register 9:
 * Set to 0x00 for IrDA, when the baudrate is initialised.
 *
 * Register A:
 * Set to 0x01 for IrDA, at init.
 *
 * Register B:
 * Set to 0x01 for IrDA, 0x00 for RS232, at init.
 *
 * Register C:
 * Set to 00 for IrDA, at init.
 *
 * Register D:
 * Set to 0x41 for IrDA, at init.
 *
 * Register E:
 * Somekind of baudrate override. The windows driver seems to set
 * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600.
 * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer,
 * it could be somekind of subdivisor thingy.
 * However,it does not seem to do anything: selecting 921600 (divisor 3,
 * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would
 * work, but they don't.
 *
 * Register F: unknown
 */