[deliverable/linux.git] / drivers / usb / serial / ark3116.c

/*
 * Copyright (C) 2006
 *   Simon Schulz (ark3116_driver <at> auctionant.de)
 *
 * ark3116
 * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
 *   productid=0x0232) (used in a datacable called KQ-U8A)
 *
 * - based on code by krisfx -> thanks !!
 *   (see http://www.linuxquestions.org/questions/showthread.php?p=2184457#post2184457)
 *
 *  - based on logs created by usbsnoopy
 *
 * 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>
#include <linux/tty.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/serial.h>
#include <linux/uaccess.h>


static int debug;

static struct usb_device_id id_table [] = {
	{ USB_DEVICE(0x6547, 0x0232) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

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,
				 usb_sndctrlpipe(serial->dev, 0),
				 request, requesttype, value, index,
				 NULL, 0x00, 1000);
	dbg("%03d > ok", seq);
}

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,
				 usb_rcvctrlpipe(serial->dev, 0),
				 request, requesttype, value, index,
				 buf, 0x0000001, 1000);
	if (result)
		dbg("%03d < %d bytes [0x%02X]", seq, result,
		    ((unsigned char *)buf)[0]);
	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,
			usb_rcvctrlpipe(serial->dev, 0),
			request, requesttype, value, index,
			buf, 0x0000001, 1000);
}

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

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

	/* 3 */
	ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
	ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
	ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
	ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B);

	/* <-- seq7 */
	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);

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

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

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

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

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

	/* <-- seq20 */
	/* 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);
	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);

	kfree(buf);
	return 0;
}

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;
}

static void ark3116_set_termios(struct tty_struct *tty,
				struct usb_serial_port *port,
				struct ktermios *old_termios)
{
	struct usb_serial *serial = port->serial;
	struct ktermios *termios = tty->termios;
	unsigned int cflag = termios->c_cflag;
	int baud;
	int ark3116_baud;
	char *buf;
	char config;

	config = 0;

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


	cflag = termios->c_cflag;
	termios->c_cflag &= ~(CMSPAR|CRTSCTS);

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		dbg("error kmalloc");
		*termios = *old_termios;
		return;
	}

	/* set data bit count (8/7/6/5) */
	if (cflag & CSIZE) {
		switch (cflag & CSIZE) {
		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:
			dbg("CSIZE was set but not CS5-CS8, using CS8!");
			/* fall through */
		case CS8:
			config |= 0x03;
			dbg("setting CS8");
			break;
		}
	}

	/* set parity (NONE/EVEN/ODD) */
	if (cflag & PARENB) {
		if (cflag & PARODD) {
			config |= 0x08;
			dbg("setting parity to ODD");
		} else {
			config |= 0x18;
			dbg("setting parity to EVEN");
		}
	} else {
		dbg("setting parity to NONE");
	}

	/* set stop bit (1/2) */
	if (cflag & CSTOPB) {
		config |= 0x04;
		dbg("setting 2 stop bits");
	} else {
		dbg("setting 1 stop bit");
	}

	/* set baudrate */
	baud = tty_get_baud_rate(tty);

	switch (baud) {
	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 */
		tty_encode_baud_rate(tty, baud, baud);
		break;
	/* set 9600 as default (if given baudrate is invalid for example) */
	default:
		tty_encode_baud_rate(tty, 9600, 9600);
	case 0:
		baud = 9600;
	}

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

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

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

	/* set baudrate */
	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);

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

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

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

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

	kfree(buf);

	return;
}

static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct ktermios tmp_termios;
	struct usb_serial *serial = port->serial;
	char *buf;
	int result = 0;

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

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

	result = usb_serial_generic_open(tty, port);
	if (result)
		goto err_out;

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

	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);

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

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

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

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

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

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

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

	/* initialise termios */
	if (tty)
		ark3116_set_termios(tty, port, &tmp_termios);

err_out:
	kfree(buf);

	return result;
}

static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
			 unsigned int cmd, unsigned long arg)
{
	struct usb_serial_port *port = tty->driver_data;
	struct serial_struct serstruct;
	void __user *user_arg = (void __user *)arg;

	switch (cmd) {
	case TIOCGSERIAL:
		/* XXX: Some of these values are probably wrong. */
		memset(&serstruct, 0, sizeof(serstruct));
		serstruct.type = PORT_16654;
		serstruct.line = port->serial->minor;
		serstruct.port = port->number;
		serstruct.custom_divisor = 0;
		serstruct.baud_base = 460800;

		if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
			return -EFAULT;

		return 0;
	case TIOCSSERIAL:
		if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
			return -EFAULT;
		return 0;
	default:
		dbg("%s cmd 0x%04x not supported", __func__, cmd);
		break;
	}

	return -ENOIOCTLCMD;
}

static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
{
	struct usb_serial_port *port = tty->driver_data;
	struct usb_serial *serial = port->serial;
	char *buf;
	char temp;

	/* seems like serial port status info (RTS, CTS, ...) is stored
	 * 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;
	}

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

	/* i do not really know if bit4=CTS and bit6=DSR... just a
	 * quick guess!
	 */
	return (temp & (1<<4) ? TIOCM_CTS : 0)
	       | (temp & (1<<6) ? TIOCM_DSR : 0);
}

static struct usb_driver ark3116_driver = {
	.name =		"ark3116",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
	.no_dynamic_id =	1,
};

static struct usb_serial_driver ark3116_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"ark3116",
	},
	.id_table =		id_table,
	.usb_driver =		&ark3116_driver,
	.num_ports =		1,
	.attach =		ark3116_attach,
	.set_termios =		ark3116_set_termios,
	.init_termios =		ark3116_init_termios,
	.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);
	if (retval)
		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");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
Commit	Line	Data
815ddc99	1	/*
2f430b4b WL	2	* Copyright (C) 2006
	3	* Simon Schulz (ark3116_driver <at> auctionant.de)
	4	*
815ddc99 GKH	5	* ark3116
	6	* - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
	7	* productid=0x0232) (used in a datacable called KQ-U8A)
	8	*
	9	* - based on code by krisfx -> thanks !!
	10	* (see http://www.linuxquestions.org/questions/showthread.php?p=2184457#post2184457)
	11	*
	12	* - based on logs created by usbsnoopy
	13	*
815ddc99 GKH	14	* This program is free software; you can redistribute it and/or modify it
	15	* under the terms of the GNU General Public License as published by the
	16	* Free Software Foundation; either version 2 of the License, or (at your
	17	* option) any later version.
	18	*/
	19
	20	#include <linux/kernel.h>
	21	#include <linux/init.h>
	22	#include <linux/tty.h>
	23	#include <linux/module.h>
	24	#include <linux/usb.h>
a969888c	25	#include <linux/usb/serial.h>
2f430b4b	26	#include <linux/serial.h>
c4d0f8cb	27	#include <linux/uaccess.h>
815ddc99 GKH	28
	29
	30	static int debug;
	31
	32	static struct usb_device_id id_table [] = {
	33	{ USB_DEVICE(0x6547, 0x0232) },
	34	{ },
	35	};
	36	MODULE_DEVICE_TABLE(usb, id_table);
	37
815ddc99 GKH	38	static inline void ARK3116_SND(struct usb_serial *serial, int seq,
	39	__u8 request, __u8 requesttype,
	40	__u16 value, __u16 index)
	41	{
	42	int result;
	43	result = usb_control_msg(serial->dev,
988440e7	44	usb_sndctrlpipe(serial->dev, 0),
815ddc99	45	request, requesttype, value, index,
988440e7 WL	46	NULL, 0x00, 1000);
988440e7 WL	47	dbg("%03d > ok", seq);
815ddc99 GKH	48	}
	49
	50	static inline void ARK3116_RCV(struct usb_serial *serial, int seq,
	51	__u8 request, __u8 requesttype,
	52	__u16 value, __u16 index, __u8 expected,
	53	char *buf)
	54	{
	55	int result;
	56	result = usb_control_msg(serial->dev,
988440e7 WL	57	usb_rcvctrlpipe(serial->dev, 0),
	58	request, requesttype, value, index,
	59	buf, 0x0000001, 1000);
815ddc99	60	if (result)
b268f484 JE	61	dbg("%03d < %d bytes [0x%02X]", seq, result,
b268f484 JE	62	((unsigned char *)buf)[0]);
815ddc99 GKH	63	else
	64	dbg("%03d < 0 bytes", seq);
	65	}
	66
815ddc99 GKH	67	static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
	68	__u8 request, __u8 requesttype,
	69	__u16 value, __u16 index, char *buf)
	70	{
	71	usb_control_msg(serial->dev,
988440e7	72	usb_rcvctrlpipe(serial->dev, 0),
815ddc99 GKH	73	request, requesttype, value, index,
	74	buf, 0x0000001, 1000);
	75	}
	76
815ddc99 GKH	77	static int ark3116_attach(struct usb_serial *serial)
	78	{
	79	char *buf;
815ddc99 GKH	80
	81	buf = kmalloc(1, GFP_KERNEL);
	82	if (!buf) {
988440e7	83	dbg("error kmalloc -> out of mem?");
fe1ae7fd	84	return -ENOMEM;
815ddc99 GKH	85	}
	86
	87	/* 3 */
988440e7 WL	88	ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
	89	ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
	90	ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
	91	ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B);
815ddc99 GKH	92
815ddc99 GKH	93	/* <-- seq7 */
988440e7 WL	94	ARK3116_RCV(serial, 7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	95	ARK3116_SND(serial, 8, 0xFE, 0x40, 0x0080, 0x0003);
	96	ARK3116_SND(serial, 9, 0xFE, 0x40, 0x001A, 0x0000);
	97	ARK3116_SND(serial, 10, 0xFE, 0x40, 0x0000, 0x0001);
	98	ARK3116_SND(serial, 11, 0xFE, 0x40, 0x0000, 0x0003);
815ddc99 GKH	99
815ddc99 GKH	100	/* <-- seq12 */
988440e7 WL	101	ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
988440e7 WL	102	ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004);
815ddc99 GKH	103
815ddc99 GKH	104	/* 14 */
988440e7 WL	105	ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
988440e7 WL	106	ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004);
815ddc99 GKH	107
815ddc99 GKH	108	/* 16 */
988440e7	109	ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
815ddc99	110	/* --> seq17 */
988440e7	111	ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004);
815ddc99 GKH	112
815ddc99 GKH	113	/* <-- seq18 */
988440e7	114	ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
815ddc99 GKH	115
815ddc99 GKH	116	/* --> seq19 */
988440e7	117	ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004);
815ddc99 GKH	118
815ddc99 GKH	119	/* <-- seq20 */
988440e7 WL	120	/* seems like serial port status info (RTS, CTS, ...) */
	121	/* returns modem control line status?! */
	122	ARK3116_RCV(serial, 20, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
	123
	124	/* set 9600 baud & do some init?! */
	125	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	126	ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
	127	ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
	128	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
	129	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	130	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
	131	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	132	ARK3116_SND(serial, 154, 0xFE, 0x40, 0x0003, 0x0003);
815ddc99 GKH	133
815ddc99 GKH	134	kfree(buf);
988440e7	135	return 0;
fe1ae7fd	136	}
815ddc99	137
fe1ae7fd AC	138	static void ark3116_init_termios(struct tty_struct *tty)
	139	{
	140	struct ktermios *termios = tty->termios;
	141	*termios = tty_std_termios;
	142	termios->c_cflag = B9600 \| CS8
	143	\| CREAD \| HUPCL \| CLOCAL;
	144	termios->c_ispeed = 9600;
	145	termios->c_ospeed = 9600;
815ddc99 GKH	146	}
815ddc99 GKH	147
95da310e AC	148	static void ark3116_set_termios(struct tty_struct *tty,
95da310e AC	149	struct usb_serial_port *port,
606d099c	150	struct ktermios *old_termios)
815ddc99 GKH	151	{
815ddc99 GKH	152	struct usb_serial *serial = port->serial;
95da310e	153	struct ktermios *termios = tty->termios;
adb5dca1	154	unsigned int cflag = termios->c_cflag;
815ddc99 GKH	155	int baud;
	156	int ark3116_baud;
	157	char *buf;
	158	char config;
	159
	160	config = 0;
	161
441b62c1	162	dbg("%s - port %d", __func__, port->number);
815ddc99	163
815ddc99	164
adb5dca1 AC	165	cflag = termios->c_cflag;
adb5dca1 AC	166	termios->c_cflag &= ~(CMSPAR\|CRTSCTS);
815ddc99	167
815ddc99 GKH	168	buf = kmalloc(1, GFP_KERNEL);
	169	if (!buf) {
	170	dbg("error kmalloc");
95da310e	171	termios = old_termios;
815ddc99 GKH	172	return;
	173	}
	174
	175	/* set data bit count (8/7/6/5) */
988440e7 WL	176	if (cflag & CSIZE) {
988440e7 WL	177	switch (cflag & CSIZE) {
815ddc99 GKH	178	case CS5:
	179	config \|= 0x00;
	180	dbg("setting CS5");
	181	break;
	182	case CS6:
	183	config \|= 0x01;
	184	dbg("setting CS6");
	185	break;
	186	case CS7:
	187	config \|= 0x02;
	188	dbg("setting CS7");
	189	break;
	190	default:
568c24ad	191	dbg("CSIZE was set but not CS5-CS8, using CS8!");
988440e7	192	/* fall through */
815ddc99 GKH	193	case CS8:
	194	config \|= 0x03;
	195	dbg("setting CS8");
	196	break;
	197	}
	198	}
	199
988440e7 WL	200	/* set parity (NONE/EVEN/ODD) */
988440e7 WL	201	if (cflag & PARENB) {
815ddc99 GKH	202	if (cflag & PARODD) {
	203	config \|= 0x08;
	204	dbg("setting parity to ODD");
	205	} else {
	206	config \|= 0x18;
	207	dbg("setting parity to EVEN");
	208	}
	209	} else {
	210	dbg("setting parity to NONE");
	211	}
	212
988440e7	213	/* set stop bit (1/2) */
815ddc99 GKH	214	if (cflag & CSTOPB) {
815ddc99 GKH	215	config \|= 0x04;
988440e7	216	dbg("setting 2 stop bits");
815ddc99	217	} else {
988440e7	218	dbg("setting 1 stop bit");
815ddc99 GKH	219	}
815ddc99 GKH	220
988440e7	221	/* set baudrate */
95da310e	222	baud = tty_get_baud_rate(tty);
568c24ad AC	223
568c24ad AC	224	switch (baud) {
c4d0f8cb AC	225	case 75:
	226	case 150:
	227	case 300:
	228	case 600:
	229	case 1200:
	230	case 1800:
	231	case 2400:
	232	case 4800:
	233	case 9600:
	234	case 19200:
	235	case 38400:
	236	case 57600:
	237	case 115200:
	238	case 230400:
	239	case 460800:
	240	/* Report the resulting rate back to the caller */
95da310e	241	tty_encode_baud_rate(tty, baud, baud);
c4d0f8cb AC	242	break;
	243	/* set 9600 as default (if given baudrate is invalid for example) */
	244	default:
95da310e	245	tty_encode_baud_rate(tty, 9600, 9600);
c4d0f8cb AC	246	case 0:
c4d0f8cb AC	247	baud = 9600;
815ddc99 GKH	248	}
815ddc99 GKH	249
815ddc99 GKH	250	/*
815ddc99 GKH	251	* found by try'n'error, be careful, maybe there are other options
568c24ad	252	* for multiplicator etc! (3.5 for example)
815ddc99 GKH	253	*/
	254	if (baud == 460800)
	255	/* strange, for 460800 the formula is wrong
988440e7	256	* if using round() then 9600baud is wrong) */
815ddc99 GKH	257	ark3116_baud = 7;
	258	else
	259	ark3116_baud = 3000000 / baud;
	260
	261	/* ? */
988440e7 WL	262	ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf);
988440e7 WL	263
815ddc99 GKH	264	/* offset = buf[0]; */
815ddc99 GKH	265	/* offset = 0x03; */
988440e7	266	/* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */
815ddc99 GKH	267
815ddc99 GKH	268	/* set baudrate */
988440e7 WL	269	dbg("setting baudrate to %d (->reg=%d)", baud, ark3116_baud);
	270	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	271	ARK3116_SND(serial, 148, 0xFE, 0x40,
	272	(ark3116_baud & 0x00FF), 0x0000);
	273	ARK3116_SND(serial, 149, 0xFE, 0x40,
	274	(ark3116_baud & 0xFF00) >> 8, 0x0001);
	275	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
815ddc99 GKH	276
815ddc99 GKH	277	/* ? */
988440e7 WL	278	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
988440e7 WL	279	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
815ddc99 GKH	280
	281	/* set data bit count, stop bit count & parity: */
	282	dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config);
988440e7 WL	283	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
988440e7 WL	284	ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003);
815ddc99 GKH	285
815ddc99 GKH	286	if (cflag & CRTSCTS)
988440e7	287	dbg("CRTSCTS not supported by chipset?!");
815ddc99	288
988440e7	289	/* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */
815ddc99 GKH	290
815ddc99 GKH	291	kfree(buf);
adb5dca1	292
815ddc99 GKH	293	return;
	294	}
	295
a509a7e4	296	static int ark3116_open(struct tty_struct tty, struct usb_serial_port port)
815ddc99	297	{
606d099c	298	struct ktermios tmp_termios;
815ddc99 GKH	299	struct usb_serial *serial = port->serial;
	300	char *buf;
	301	int result = 0;
	302
441b62c1	303	dbg("%s - port %d", __func__, port->number);
815ddc99 GKH	304
	305	buf = kmalloc(1, GFP_KERNEL);
	306	if (!buf) {
988440e7	307	dbg("error kmalloc -> out of mem?");
815ddc99 GKH	308	return -ENOMEM;
	309	}
	310
a509a7e4	311	result = usb_serial_generic_open(tty, port);
815ddc99	312	if (result)
4edf2c83	313	goto err_out;
815ddc99 GKH	314
815ddc99 GKH	315	/* open */
988440e7	316	ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf);
815ddc99	317
988440e7 WL	318	ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003);
	319	ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000);
	320	ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001);
	321	ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003);
815ddc99	322
988440e7 WL	323	ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
988440e7 WL	324	ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004);
815ddc99	325
988440e7 WL	326	ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf);
988440e7 WL	327	ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004);
815ddc99	328
988440e7	329	ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
815ddc99	330
988440e7	331	ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004);
815ddc99	332
988440e7	333	ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
815ddc99	334
988440e7	335	ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004);
815ddc99	336
988440e7 WL	337	/* returns different values (control lines?!) */
988440e7 WL	338	ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
815ddc99	339
988440e7	340	/* initialise termios */
95da310e AC	341	if (tty)
95da310e AC	342	ark3116_set_termios(tty, port, &tmp_termios);
815ddc99	343
4edf2c83	344	err_out:
815ddc99 GKH	345	kfree(buf);
	346
	347	return result;
815ddc99 GKH	348	}
815ddc99 GKH	349
95da310e	350	static int ark3116_ioctl(struct tty_struct tty, struct file file,
815ddc99 GKH	351	unsigned int cmd, unsigned long arg)
815ddc99 GKH	352	{
95da310e	353	struct usb_serial_port *port = tty->driver_data;
2f430b4b WL	354	struct serial_struct serstruct;
	355	void __user user_arg = (void __user )arg;
	356
	357	switch (cmd) {
	358	case TIOCGSERIAL:
	359	/* XXX: Some of these values are probably wrong. */
c4d0f8cb	360	memset(&serstruct, 0, sizeof(serstruct));
2f430b4b WL	361	serstruct.type = PORT_16654;
	362	serstruct.line = port->serial->minor;
	363	serstruct.port = port->number;
	364	serstruct.custom_divisor = 0;
	365	serstruct.baud_base = 460800;
	366
c4d0f8cb	367	if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
2f430b4b WL	368	return -EFAULT;
	369
	370	return 0;
	371	case TIOCSSERIAL:
c4d0f8cb	372	if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
2f430b4b WL	373	return -EFAULT;
	374	return 0;
	375	default:
441b62c1	376	dbg("%s cmd 0x%04x not supported", __func__, cmd);
2f430b4b WL	377	break;
	378	}
	379
815ddc99 GKH	380	return -ENOIOCTLCMD;
	381	}
	382
95da310e	383	static int ark3116_tiocmget(struct tty_struct tty, struct file file)
815ddc99	384	{
95da310e	385	struct usb_serial_port *port = tty->driver_data;
815ddc99 GKH	386	struct usb_serial *serial = port->serial;
	387	char *buf;
	388	char temp;
	389
988440e7	390	/* seems like serial port status info (RTS, CTS, ...) is stored
815ddc99 GKH	391	* in reg(?) 0x0006
	392	* pcb connection point 11 = GND -> sets bit4 of response
	393	* pcb connection point 7 = GND -> sets bit6 of response
	394	*/
	395
	396	buf = kmalloc(1, GFP_KERNEL);
	397	if (!buf) {
	398	dbg("error kmalloc");
	399	return -ENOMEM;
	400	}
	401
988440e7 WL	402	/* read register */
988440e7 WL	403	ARK3116_RCV_QUIET(serial, 0xFE, 0xC0, 0x0000, 0x0006, buf);
815ddc99 GKH	404	temp = buf[0];
	405	kfree(buf);
	406
988440e7 WL	407	/* i do not really know if bit4=CTS and bit6=DSR... just a
988440e7 WL	408	* quick guess!
815ddc99	409	*/
988440e7 WL	410	return (temp & (1<<4) ? TIOCM_CTS : 0)
988440e7 WL	411	\| (temp & (1<<6) ? TIOCM_DSR : 0);
815ddc99 GKH	412	}
	413
	414	static struct usb_driver ark3116_driver = {
	415	.name = "ark3116",
	416	.probe = usb_serial_probe,
	417	.disconnect = usb_serial_disconnect,
	418	.id_table = id_table,
d9b1b787	419	.no_dynamic_id = 1,
815ddc99 GKH	420	};
	421
	422	static struct usb_serial_driver ark3116_device = {
	423	.driver = {
	424	.owner = THIS_MODULE,
	425	.name = "ark3116",
	426	},
	427	.id_table = id_table,
d9b1b787	428	.usb_driver = &ark3116_driver,
815ddc99 GKH	429	.num_ports = 1,
	430	.attach = ark3116_attach,
	431	.set_termios = ark3116_set_termios,
fe1ae7fd	432	.init_termios = ark3116_init_termios,
815ddc99 GKH	433	.ioctl = ark3116_ioctl,
	434	.tiocmget = ark3116_tiocmget,
	435	.open = ark3116_open,
	436	};
	437
	438	static int __init ark3116_init(void)
	439	{
	440	int retval;
	441
	442	retval = usb_serial_register(&ark3116_device);
	443	if (retval)
	444	return retval;
	445	retval = usb_register(&ark3116_driver);
	446	if (retval)
	447	usb_serial_deregister(&ark3116_device);
	448	return retval;
	449	}
	450
	451	static void __exit ark3116_exit(void)
	452	{
	453	usb_deregister(&ark3116_driver);
	454	usb_serial_deregister(&ark3116_device);
	455	}
	456
	457	module_init(ark3116_init);
	458	module_exit(ark3116_exit);
	459	MODULE_LICENSE("GPL");
	460
	461	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	462	MODULE_PARM_DESC(debug, "Debug enabled or not");
	463