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

/*
 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
 * Copyright 2009, Boris Hajduk <boris@hajduk.org>
 *
 * ch341.c implements a serial port driver for the Winchiphead CH341.
 *
 * The CH341 device can be used to implement an RS232 asynchronous
 * serial port, an IEEE-1284 parallel printer port or a memory-like
 * interface. In all cases the CH341 supports an I2C interface as well.
 * This driver only supports the asynchronous serial interface.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/serial.h>
#include <asm/unaligned.h>

#define DEFAULT_BAUD_RATE 9600
#define DEFAULT_TIMEOUT   1000

/* flags for IO-Bits */
#define CH341_BIT_RTS (1 << 6)
#define CH341_BIT_DTR (1 << 5)

/******************************/
/* interrupt pipe definitions */
/******************************/
/* always 4 interrupt bytes */
/* first irq byte normally 0x08 */
/* second irq byte base 0x7d + below */
/* third irq byte base 0x94 + below */
/* fourth irq byte normally 0xee */

/* second interrupt byte */
#define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */

/* status returned in third interrupt answer byte, inverted in data
   from irq */
#define CH341_BIT_CTS 0x01
#define CH341_BIT_DSR 0x02
#define CH341_BIT_RI  0x04
#define CH341_BIT_DCD 0x08
#define CH341_BITS_MODEM_STAT 0x0f /* all bits */

/*******************************/
/* baudrate calculation factor */
/*******************************/
#define CH341_BAUDBASE_FACTOR 1532620800
#define CH341_BAUDBASE_DIVMAX 3

/* Break support - the information used to implement this was gleaned from
 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe.  Domo arigato.
 */

#define CH341_REQ_WRITE_REG    0x9A
#define CH341_REQ_READ_REG     0x95
#define CH341_REG_BREAK1       0x05
#define CH341_REG_BREAK2       0x18
#define CH341_NBREAK_BITS_REG1 0x01
#define CH341_NBREAK_BITS_REG2 0x40


static bool debug;

static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(0x4348, 0x5523) },
	{ USB_DEVICE(0x1a86, 0x7523) },
	{ USB_DEVICE(0x1a86, 0x5523) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

struct ch341_private {
	spinlock_t lock; /* access lock */
	wait_queue_head_t delta_msr_wait; /* wait queue for modem status */
	unsigned baud_rate; /* set baud rate */
	u8 line_control; /* set line control value RTS/DTR */
	u8 line_status; /* active status of modem control inputs */
	u8 multi_status_change; /* status changed multiple since last call */
};

static int ch341_control_out(struct usb_device *dev, u8 request,
			     u16 value, u16 index)
{
	int r;

	dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n",
		USB_DIR_OUT|0x40, (int)request, (int)value, (int)index);

	r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
			    value, index, NULL, 0, DEFAULT_TIMEOUT);

	return r;
}

static int ch341_control_in(struct usb_device *dev,
			    u8 request, u16 value, u16 index,
			    char *buf, unsigned bufsize)
{
	int r;

	dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n",
		USB_DIR_IN|0x40, (int)request, (int)value, (int)index, buf,
		(int)bufsize);

	r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
			    USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			    value, index, buf, bufsize, DEFAULT_TIMEOUT);
	return r;
}

static int ch341_set_baudrate(struct usb_device *dev,
			      struct ch341_private *priv)
{
	short a, b;
	int r;
	unsigned long factor;
	short divisor;

	if (!priv->baud_rate)
		return -EINVAL;
	factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
	divisor = CH341_BAUDBASE_DIVMAX;

	while ((factor > 0xfff0) && divisor) {
		factor >>= 3;
		divisor--;
	}

	if (factor > 0xfff0)
		return -EINVAL;

	factor = 0x10000 - factor;
	a = (factor & 0xff00) | divisor;
	b = factor & 0xff;

	r = ch341_control_out(dev, 0x9a, 0x1312, a);
	if (!r)
		r = ch341_control_out(dev, 0x9a, 0x0f2c, b);

	return r;
}

static int ch341_set_handshake(struct usb_device *dev, u8 control)
{
	return ch341_control_out(dev, 0xa4, ~control, 0);
}

static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
{
	char *buffer;
	int r;
	const unsigned size = 8;
	unsigned long flags;

	buffer = kmalloc(size, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
	if (r < 0)
		goto out;

	/* setup the private status if available */
	if (r == 2) {
		r = 0;
		spin_lock_irqsave(&priv->lock, flags);
		priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
		priv->multi_status_change = 0;
		spin_unlock_irqrestore(&priv->lock, flags);
	} else
		r = -EPROTO;

out:	kfree(buffer);
	return r;
}

/* -------------------------------------------------------------------------- */

static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
{
	char *buffer;
	int r;
	const unsigned size = 8;

	buffer = kmalloc(size, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	/* expect two bytes 0x27 0x00 */
	r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
	if (r < 0)
		goto out;

	r = ch341_control_out(dev, 0xa1, 0, 0);
	if (r < 0)
		goto out;

	r = ch341_set_baudrate(dev, priv);
	if (r < 0)
		goto out;

	/* expect two bytes 0x56 0x00 */
	r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
	if (r < 0)
		goto out;

	r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
	if (r < 0)
		goto out;

	/* expect 0xff 0xee */
	r = ch341_get_status(dev, priv);
	if (r < 0)
		goto out;

	r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
	if (r < 0)
		goto out;

	r = ch341_set_baudrate(dev, priv);
	if (r < 0)
		goto out;

	r = ch341_set_handshake(dev, priv->line_control);
	if (r < 0)
		goto out;

	/* expect 0x9f 0xee */
	r = ch341_get_status(dev, priv);

out:	kfree(buffer);
	return r;
}

/* allocate private data */
static int ch341_attach(struct usb_serial *serial)
{
	struct ch341_private *priv;
	int r;

	/* private data */
	priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	spin_lock_init(&priv->lock);
	init_waitqueue_head(&priv->delta_msr_wait);
	priv->baud_rate = DEFAULT_BAUD_RATE;
	priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;

	r = ch341_configure(serial->dev, priv);
	if (r < 0)
		goto error;

	usb_set_serial_port_data(serial->port[0], priv);
	return 0;

error:	kfree(priv);
	return r;
}

static int ch341_carrier_raised(struct usb_serial_port *port)
{
	struct ch341_private *priv = usb_get_serial_port_data(port);
	if (priv->line_status & CH341_BIT_DCD)
		return 1;
	return 0;
}

static void ch341_dtr_rts(struct usb_serial_port *port, int on)
{
	struct ch341_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;

	/* drop DTR and RTS */
	spin_lock_irqsave(&priv->lock, flags);
	if (on)
		priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
	else
		priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
	spin_unlock_irqrestore(&priv->lock, flags);
	ch341_set_handshake(port->serial->dev, priv->line_control);
	wake_up_interruptible(&priv->delta_msr_wait);
}

static void ch341_close(struct usb_serial_port *port)
{
	usb_serial_generic_close(port);
	usb_kill_urb(port->interrupt_in_urb);
}


/* open this device, set default parameters */
static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct usb_serial *serial = port->serial;
	struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
	int r;

	priv->baud_rate = DEFAULT_BAUD_RATE;

	r = ch341_configure(serial->dev, priv);
	if (r)
		goto out;

	r = ch341_set_handshake(serial->dev, priv->line_control);
	if (r)
		goto out;

	r = ch341_set_baudrate(serial->dev, priv);
	if (r)
		goto out;

	dev_dbg(&port->dev, "%s - submitting interrupt urb", __func__);
	r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
	if (r) {
		dev_err(&port->dev, "%s - failed submitting interrupt urb,"
			" error %d\n", __func__, r);
		ch341_close(port);
		goto out;
	}

	r = usb_serial_generic_open(tty, port);

out:	return r;
}

/* Old_termios contains the original termios settings and
 * tty->termios contains the new setting to be used.
 */
static void ch341_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios)
{
	struct ch341_private *priv = usb_get_serial_port_data(port);
	unsigned baud_rate;
	unsigned long flags;

	baud_rate = tty_get_baud_rate(tty);

	priv->baud_rate = baud_rate;

	if (baud_rate) {
		spin_lock_irqsave(&priv->lock, flags);
		priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
		spin_unlock_irqrestore(&priv->lock, flags);
		ch341_set_baudrate(port->serial->dev, priv);
	} else {
		spin_lock_irqsave(&priv->lock, flags);
		priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
		spin_unlock_irqrestore(&priv->lock, flags);
	}

	ch341_set_handshake(port->serial->dev, priv->line_control);

	/* Unimplemented:
	 * (cflag & CSIZE) : data bits [5, 8]
	 * (cflag & PARENB) : parity {NONE, EVEN, ODD}
	 * (cflag & CSTOPB) : stop bits [1, 2]
	 */
}

static void ch341_break_ctl(struct tty_struct *tty, int break_state)
{
	const uint16_t ch341_break_reg =
		CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
	struct usb_serial_port *port = tty->driver_data;
	int r;
	uint16_t reg_contents;
	uint8_t *break_reg;

	break_reg = kmalloc(2, GFP_KERNEL);
	if (!break_reg) {
		dev_err(&port->dev, "%s - kmalloc failed\n", __func__);
		return;
	}

	r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
			ch341_break_reg, 0, break_reg, 2);
	if (r < 0) {
		dev_err(&port->dev, "%s - USB control read error (%d)\n",
				__func__, r);
		goto out;
	}
	dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n",
		__func__, break_reg[0], break_reg[1]);
	if (break_state != 0) {
		dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__);
		break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
		break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
	} else {
		dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__);
		break_reg[0] |= CH341_NBREAK_BITS_REG1;
		break_reg[1] |= CH341_NBREAK_BITS_REG2;
	}
	dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n",
		__func__, break_reg[0], break_reg[1]);
	reg_contents = get_unaligned_le16(break_reg);
	r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
			ch341_break_reg, reg_contents);
	if (r < 0)
		dev_err(&port->dev, "%s - USB control write error (%d)\n",
				__func__, r);
out:
	kfree(break_reg);
}

static int ch341_tiocmset(struct tty_struct *tty,
			  unsigned int set, unsigned int clear)
{
	struct usb_serial_port *port = tty->driver_data;
	struct ch341_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;

	spin_lock_irqsave(&priv->lock, flags);
	if (set & TIOCM_RTS)
		priv->line_control |= CH341_BIT_RTS;
	if (set & TIOCM_DTR)
		priv->line_control |= CH341_BIT_DTR;
	if (clear & TIOCM_RTS)
		priv->line_control &= ~CH341_BIT_RTS;
	if (clear & TIOCM_DTR)
		priv->line_control &= ~CH341_BIT_DTR;
	control = priv->line_control;
	spin_unlock_irqrestore(&priv->lock, flags);

	return ch341_set_handshake(port->serial->dev, control);
}

static void ch341_read_int_callback(struct urb *urb)
{
	struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
	unsigned char *data = urb->transfer_buffer;
	unsigned int actual_length = urb->actual_length;
	int status;

	switch (urb->status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
			__func__, urb->status);
		return;
	default:
		dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
			__func__, urb->status);
		goto exit;
	}

	usb_serial_debug_data(debug, &port->dev, __func__,
			      urb->actual_length, urb->transfer_buffer);

	if (actual_length >= 4) {
		struct ch341_private *priv = usb_get_serial_port_data(port);
		unsigned long flags;
		u8 prev_line_status = priv->line_status;

		spin_lock_irqsave(&priv->lock, flags);
		priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
		if ((data[1] & CH341_MULT_STAT))
			priv->multi_status_change = 1;
		spin_unlock_irqrestore(&priv->lock, flags);

		if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) {
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty)
				usb_serial_handle_dcd_change(port, tty,
					    priv->line_status & CH341_BIT_DCD);
			tty_kref_put(tty);
		}

		wake_up_interruptible(&priv->delta_msr_wait);
	}

exit:
	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status)
		dev_err(&urb->dev->dev,
			"%s - usb_submit_urb failed with result %d\n",
			__func__, status);
}

static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
{
	struct ch341_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 prevstatus;
	u8 status;
	u8 changed;
	u8 multi_change = 0;

	spin_lock_irqsave(&priv->lock, flags);
	prevstatus = priv->line_status;
	priv->multi_status_change = 0;
	spin_unlock_irqrestore(&priv->lock, flags);

	while (!multi_change) {
		interruptible_sleep_on(&priv->delta_msr_wait);
		/* see if a signal did it */
		if (signal_pending(current))
			return -ERESTARTSYS;

		spin_lock_irqsave(&priv->lock, flags);
		status = priv->line_status;
		multi_change = priv->multi_status_change;
		spin_unlock_irqrestore(&priv->lock, flags);

		changed = prevstatus ^ status;

		if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) ||
		    ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) ||
		    ((arg & TIOCM_CD)  && (changed & CH341_BIT_DCD)) ||
		    ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
			return 0;
		}
		prevstatus = status;
	}

	return 0;
}

static int ch341_ioctl(struct tty_struct *tty,
			unsigned int cmd, unsigned long arg)
{
	struct usb_serial_port *port = tty->driver_data;

	dev_dbg(&port->dev, "%s (%d) cmd = 0x%04x\n", __func__, port->number, cmd);

	switch (cmd) {
	case TIOCMIWAIT:
		dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__,  port->number);
		return wait_modem_info(port, arg);

	default:
		dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
		break;
	}

	return -ENOIOCTLCMD;
}

static int ch341_tiocmget(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct ch341_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 mcr;
	u8 status;
	unsigned int result;

	spin_lock_irqsave(&priv->lock, flags);
	mcr = priv->line_control;
	status = priv->line_status;
	spin_unlock_irqrestore(&priv->lock, flags);

	result = ((mcr & CH341_BIT_DTR)		? TIOCM_DTR : 0)
		  | ((mcr & CH341_BIT_RTS)	? TIOCM_RTS : 0)
		  | ((status & CH341_BIT_CTS)	? TIOCM_CTS : 0)
		  | ((status & CH341_BIT_DSR)	? TIOCM_DSR : 0)
		  | ((status & CH341_BIT_RI)	? TIOCM_RI  : 0)
		  | ((status & CH341_BIT_DCD)	? TIOCM_CD  : 0);

	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);

	return result;
}

static int ch341_reset_resume(struct usb_serial *serial)
{
	struct ch341_private *priv;

	priv = usb_get_serial_port_data(serial->port[0]);

	/* reconfigure ch341 serial port after bus-reset */
	ch341_configure(serial->dev, priv);

	return 0;
}

static struct usb_serial_driver ch341_device = {
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "ch341-uart",
	},
	.id_table          = id_table,
	.num_ports         = 1,
	.open              = ch341_open,
	.dtr_rts	   = ch341_dtr_rts,
	.carrier_raised	   = ch341_carrier_raised,
	.close             = ch341_close,
	.ioctl             = ch341_ioctl,
	.set_termios       = ch341_set_termios,
	.break_ctl         = ch341_break_ctl,
	.tiocmget          = ch341_tiocmget,
	.tiocmset          = ch341_tiocmset,
	.read_int_callback = ch341_read_int_callback,
	.attach            = ch341_attach,
	.reset_resume      = ch341_reset_resume,
};

static struct usb_serial_driver * const serial_drivers[] = {
	&ch341_device, NULL
};

module_usb_serial_driver(serial_drivers, id_table);

MODULE_LICENSE("GPL");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
Commit	Line	Data
6ce76104 FK	1	/*
6ce76104 FK	2	* Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
664d5df9 WC	3	* Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
664d5df9 WC	4	* Copyright 2009, Boris Hajduk <boris@hajduk.org>
6ce76104 FK	5	*
	6	* ch341.c implements a serial port driver for the Winchiphead CH341.
	7	*
	8	* The CH341 device can be used to implement an RS232 asynchronous
	9	* serial port, an IEEE-1284 parallel printer port or a memory-like
	10	* interface. In all cases the CH341 supports an I2C interface as well.
	11	* This driver only supports the asynchronous serial interface.
	12	*
	13	* This program is free software; you can redistribute it and/or
	14	* modify it under the terms of the GNU General Public License version
	15	* 2 as published by the Free Software Foundation.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/init.h>
	20	#include <linux/tty.h>
	21	#include <linux/module.h>
5a0e3ad6	22	#include <linux/slab.h>
6ce76104 FK	23	#include <linux/usb.h>
	24	#include <linux/usb/serial.h>
	25	#include <linux/serial.h>
5be796f0	26	#include <asm/unaligned.h>
6ce76104	27
664d5df9	28	#define DEFAULT_BAUD_RATE 9600
6ce76104 FK	29	#define DEFAULT_TIMEOUT 1000
6ce76104 FK	30
664d5df9 WC	31	/* flags for IO-Bits */
	32	#define CH341_BIT_RTS (1 << 6)
	33	#define CH341_BIT_DTR (1 << 5)
	34
	35	/******************************/
	36	/* interrupt pipe definitions */
	37	/******************************/
	38	/* always 4 interrupt bytes */
	39	/* first irq byte normally 0x08 */
	40	/* second irq byte base 0x7d + below */
	41	/* third irq byte base 0x94 + below */
	42	/* fourth irq byte normally 0xee */
	43
	44	/* second interrupt byte */
	45	#define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */
	46
	47	/* status returned in third interrupt answer byte, inverted in data
	48	from irq */
	49	#define CH341_BIT_CTS 0x01
	50	#define CH341_BIT_DSR 0x02
	51	#define CH341_BIT_RI 0x04
	52	#define CH341_BIT_DCD 0x08
	53	#define CH341_BITS_MODEM_STAT 0x0f /* all bits */
	54
	55	/*******************************/
	56	/* baudrate calculation factor */
	57	/*******************************/
	58	#define CH341_BAUDBASE_FACTOR 1532620800
	59	#define CH341_BAUDBASE_DIVMAX 3
	60
492896f0 TS	61	/* Break support - the information used to implement this was gleaned from
	62	* the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato.
	63	*/
	64
	65	#define CH341_REQ_WRITE_REG 0x9A
	66	#define CH341_REQ_READ_REG 0x95
	67	#define CH341_REG_BREAK1 0x05
	68	#define CH341_REG_BREAK2 0x18
	69	#define CH341_NBREAK_BITS_REG1 0x01
	70	#define CH341_NBREAK_BITS_REG2 0x40
	71
	72
90ab5ee9	73	static bool debug;
6ce76104	74
7d40d7e8	75	static const struct usb_device_id id_table[] = {
6ce76104	76	{ USB_DEVICE(0x4348, 0x5523) },
82078234	77	{ USB_DEVICE(0x1a86, 0x7523) },
d0781383	78	{ USB_DEVICE(0x1a86, 0x5523) },
6ce76104 FK	79	{ },
	80	};
	81	MODULE_DEVICE_TABLE(usb, id_table);
	82
	83	struct ch341_private {
664d5df9 WC	84	spinlock_t lock; /* access lock */
	85	wait_queue_head_t delta_msr_wait; /* wait queue for modem status */
	86	unsigned baud_rate; /* set baud rate */
	87	u8 line_control; /* set line control value RTS/DTR */
	88	u8 line_status; /* active status of modem control inputs */
	89	u8 multi_status_change; /* status changed multiple since last call */
6ce76104 FK	90	};
	91
	92	static int ch341_control_out(struct usb_device *dev, u8 request,
	93	u16 value, u16 index)
	94	{
	95	int r;
79cbeeaf GKH	96
	97	dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n",
	98	USB_DIR_OUT\|0x40, (int)request, (int)value, (int)index);
6ce76104 FK	99
	100	r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
	101	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT,
	102	value, index, NULL, 0, DEFAULT_TIMEOUT);
	103
	104	return r;
	105	}
	106
	107	static int ch341_control_in(struct usb_device *dev,
	108	u8 request, u16 value, u16 index,
	109	char *buf, unsigned bufsize)
	110	{
	111	int r;
79cbeeaf GKH	112
	113	dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n",
	114	USB_DIR_IN\|0x40, (int)request, (int)value, (int)index, buf,
	115	(int)bufsize);
6ce76104 FK	116
	117	r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
	118	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	119	value, index, buf, bufsize, DEFAULT_TIMEOUT);
	120	return r;
	121	}
	122
93b6497d AB	123	static int ch341_set_baudrate(struct usb_device *dev,
93b6497d AB	124	struct ch341_private *priv)
6ce76104 FK	125	{
	126	short a, b;
	127	int r;
664d5df9 WC	128	unsigned long factor;
664d5df9 WC	129	short divisor;
6ce76104	130
664d5df9	131	if (!priv->baud_rate)
6ce76104	132	return -EINVAL;
664d5df9 WC	133	factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
	134	divisor = CH341_BAUDBASE_DIVMAX;
	135
	136	while ((factor > 0xfff0) && divisor) {
	137	factor >>= 3;
	138	divisor--;
6ce76104 FK	139	}
6ce76104 FK	140
664d5df9 WC	141	if (factor > 0xfff0)
	142	return -EINVAL;
	143
	144	factor = 0x10000 - factor;
	145	a = (factor & 0xff00) \| divisor;
	146	b = factor & 0xff;
	147
6ce76104 FK	148	r = ch341_control_out(dev, 0x9a, 0x1312, a);
	149	if (!r)
	150	r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
	151
	152	return r;
	153	}
	154
664d5df9	155	static int ch341_set_handshake(struct usb_device *dev, u8 control)
6ce76104	156	{
664d5df9	157	return ch341_control_out(dev, 0xa4, ~control, 0);
6ce76104 FK	158	}
6ce76104 FK	159
664d5df9	160	static int ch341_get_status(struct usb_device dev, struct ch341_private priv)
6ce76104 FK	161	{
	162	char *buffer;
	163	int r;
	164	const unsigned size = 8;
664d5df9	165	unsigned long flags;
6ce76104	166
6ce76104 FK	167	buffer = kmalloc(size, GFP_KERNEL);
	168	if (!buffer)
	169	return -ENOMEM;
	170
	171	r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
c4d0f8cb	172	if (r < 0)
6ce76104 FK	173	goto out;
6ce76104 FK	174
664d5df9 WC	175	/* setup the private status if available */
	176	if (r == 2) {
	177	r = 0;
	178	spin_lock_irqsave(&priv->lock, flags);
	179	priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
	180	priv->multi_status_change = 0;
	181	spin_unlock_irqrestore(&priv->lock, flags);
	182	} else
	183	r = -EPROTO;
6ce76104 FK	184
	185	out: kfree(buffer);
	186	return r;
	187	}
	188
	189	/* -------------------------------------------------------------------------- */
	190
93b6497d	191	static int ch341_configure(struct usb_device dev, struct ch341_private priv)
6ce76104 FK	192	{
	193	char *buffer;
	194	int r;
	195	const unsigned size = 8;
	196
6ce76104 FK	197	buffer = kmalloc(size, GFP_KERNEL);
	198	if (!buffer)
	199	return -ENOMEM;
	200
	201	/* expect two bytes 0x27 0x00 */
	202	r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
	203	if (r < 0)
	204	goto out;
	205
	206	r = ch341_control_out(dev, 0xa1, 0, 0);
	207	if (r < 0)
	208	goto out;
	209
	210	r = ch341_set_baudrate(dev, priv);
	211	if (r < 0)
	212	goto out;
	213
	214	/* expect two bytes 0x56 0x00 */
	215	r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
	216	if (r < 0)
	217	goto out;
	218
	219	r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
	220	if (r < 0)
	221	goto out;
	222
	223	/* expect 0xff 0xee */
664d5df9	224	r = ch341_get_status(dev, priv);
6ce76104 FK	225	if (r < 0)
	226	goto out;
	227
	228	r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
	229	if (r < 0)
	230	goto out;
	231
	232	r = ch341_set_baudrate(dev, priv);
	233	if (r < 0)
	234	goto out;
	235
664d5df9	236	r = ch341_set_handshake(dev, priv->line_control);
6ce76104 FK	237	if (r < 0)
	238	goto out;
	239
	240	/* expect 0x9f 0xee */
664d5df9	241	r = ch341_get_status(dev, priv);
6ce76104 FK	242
	243	out: kfree(buffer);
	244	return r;
	245	}
	246
	247	/* allocate private data */
	248	static int ch341_attach(struct usb_serial *serial)
	249	{
	250	struct ch341_private *priv;
	251	int r;
	252
6ce76104 FK	253	/* private data */
	254	priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
	255	if (!priv)
	256	return -ENOMEM;
	257
664d5df9 WC	258	spin_lock_init(&priv->lock);
664d5df9 WC	259	init_waitqueue_head(&priv->delta_msr_wait);
6ce76104	260	priv->baud_rate = DEFAULT_BAUD_RATE;
664d5df9	261	priv->line_control = CH341_BIT_RTS \| CH341_BIT_DTR;
6ce76104 FK	262
	263	r = ch341_configure(serial->dev, priv);
	264	if (r < 0)
	265	goto error;
	266
	267	usb_set_serial_port_data(serial->port[0], priv);
	268	return 0;
	269
	270	error: kfree(priv);
	271	return r;
	272	}
	273
335f8514 AC	274	static int ch341_carrier_raised(struct usb_serial_port *port)
	275	{
	276	struct ch341_private *priv = usb_get_serial_port_data(port);
	277	if (priv->line_status & CH341_BIT_DCD)
	278	return 1;
	279	return 0;
	280	}
	281
	282	static void ch341_dtr_rts(struct usb_serial_port *port, int on)
664d5df9 WC	283	{
	284	struct ch341_private *priv = usb_get_serial_port_data(port);
	285	unsigned long flags;
664d5df9	286
335f8514 AC	287	/* drop DTR and RTS */
	288	spin_lock_irqsave(&priv->lock, flags);
	289	if (on)
	290	priv->line_control \|= CH341_BIT_RTS \| CH341_BIT_DTR;
	291	else
	292	priv->line_control &= ~(CH341_BIT_RTS \| CH341_BIT_DTR);
	293	spin_unlock_irqrestore(&priv->lock, flags);
	294	ch341_set_handshake(port->serial->dev, priv->line_control);
	295	wake_up_interruptible(&priv->delta_msr_wait);
	296	}
	297
	298	static void ch341_close(struct usb_serial_port *port)
	299	{
f26788da	300	usb_serial_generic_close(port);
664d5df9	301	usb_kill_urb(port->interrupt_in_urb);
664d5df9 WC	302	}
	303
	304
6ce76104	305	/* open this device, set default parameters */
a509a7e4	306	static int ch341_open(struct tty_struct tty, struct usb_serial_port port)
6ce76104 FK	307	{
	308	struct usb_serial *serial = port->serial;
	309	struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
	310	int r;
	311
6ce76104	312	priv->baud_rate = DEFAULT_BAUD_RATE;
6ce76104 FK	313
	314	r = ch341_configure(serial->dev, priv);
	315	if (r)
	316	goto out;
	317
664d5df9	318	r = ch341_set_handshake(serial->dev, priv->line_control);
6ce76104 FK	319	if (r)
	320	goto out;
	321
	322	r = ch341_set_baudrate(serial->dev, priv);
	323	if (r)
	324	goto out;
	325
79cbeeaf	326	dev_dbg(&port->dev, "%s - submitting interrupt urb", __func__);
664d5df9 WC	327	r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
	328	if (r) {
	329	dev_err(&port->dev, "%s - failed submitting interrupt urb,"
	330	" error %d\n", __func__, r);
335f8514	331	ch341_close(port);
06946a66	332	goto out;
664d5df9 WC	333	}
664d5df9 WC	334
a509a7e4	335	r = usb_serial_generic_open(tty, port);
6ce76104 FK	336
	337	out: return r;
	338	}
	339
	340	/* Old_termios contains the original termios settings and
	341	* tty->termios contains the new setting to be used.
	342	*/
95da310e AC	343	static void ch341_set_termios(struct tty_struct *tty,
95da310e AC	344	struct usb_serial_port port, struct ktermios old_termios)
6ce76104 FK	345	{
6ce76104 FK	346	struct ch341_private *priv = usb_get_serial_port_data(port);
6ce76104	347	unsigned baud_rate;
664d5df9	348	unsigned long flags;
6ce76104	349
6ce76104 FK	350	baud_rate = tty_get_baud_rate(tty);
6ce76104 FK	351
664d5df9 WC	352	priv->baud_rate = baud_rate;
	353
	354	if (baud_rate) {
	355	spin_lock_irqsave(&priv->lock, flags);
	356	priv->line_control \|= (CH341_BIT_DTR \| CH341_BIT_RTS);
	357	spin_unlock_irqrestore(&priv->lock, flags);
	358	ch341_set_baudrate(port->serial->dev, priv);
	359	} else {
	360	spin_lock_irqsave(&priv->lock, flags);
	361	priv->line_control &= ~(CH341_BIT_DTR \| CH341_BIT_RTS);
	362	spin_unlock_irqrestore(&priv->lock, flags);
6ce76104 FK	363	}
6ce76104 FK	364
664d5df9	365	ch341_set_handshake(port->serial->dev, priv->line_control);
6ce76104 FK	366
	367	/* Unimplemented:
	368	* (cflag & CSIZE) : data bits [5, 8]
	369	* (cflag & PARENB) : parity {NONE, EVEN, ODD}
	370	* (cflag & CSTOPB) : stop bits [1, 2]
	371	*/
664d5df9 WC	372	}
664d5df9 WC	373
492896f0 TS	374	static void ch341_break_ctl(struct tty_struct *tty, int break_state)
	375	{
	376	const uint16_t ch341_break_reg =
	377	CH341_REG_BREAK1 \| ((uint16_t) CH341_REG_BREAK2 << 8);
	378	struct usb_serial_port *port = tty->driver_data;
	379	int r;
	380	uint16_t reg_contents;
f2b5cc83	381	uint8_t *break_reg;
492896f0	382
f2b5cc83 JH	383	break_reg = kmalloc(2, GFP_KERNEL);
	384	if (!break_reg) {
	385	dev_err(&port->dev, "%s - kmalloc failed\n", __func__);
	386	return;
	387	}
	388
492896f0	389	r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
f2b5cc83	390	ch341_break_reg, 0, break_reg, 2);
492896f0	391	if (r < 0) {
6a9b15fe JH	392	dev_err(&port->dev, "%s - USB control read error (%d)\n",
6a9b15fe JH	393	__func__, r);
f2b5cc83	394	goto out;
492896f0	395	}
79cbeeaf GKH	396	dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n",
79cbeeaf GKH	397	__func__, break_reg[0], break_reg[1]);
492896f0	398	if (break_state != 0) {
79cbeeaf	399	dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__);
492896f0 TS	400	break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
	401	break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
	402	} else {
79cbeeaf	403	dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__);
492896f0 TS	404	break_reg[0] \|= CH341_NBREAK_BITS_REG1;
	405	break_reg[1] \|= CH341_NBREAK_BITS_REG2;
	406	}
79cbeeaf GKH	407	dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n",
79cbeeaf GKH	408	__func__, break_reg[0], break_reg[1]);
5be796f0	409	reg_contents = get_unaligned_le16(break_reg);
492896f0 TS	410	r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
	411	ch341_break_reg, reg_contents);
	412	if (r < 0)
6a9b15fe JH	413	dev_err(&port->dev, "%s - USB control write error (%d)\n",
6a9b15fe JH	414	__func__, r);
f2b5cc83 JH	415	out:
f2b5cc83 JH	416	kfree(break_reg);
492896f0 TS	417	}
492896f0 TS	418
20b9d177	419	static int ch341_tiocmset(struct tty_struct *tty,
664d5df9 WC	420	unsigned int set, unsigned int clear)
	421	{
	422	struct usb_serial_port *port = tty->driver_data;
	423	struct ch341_private *priv = usb_get_serial_port_data(port);
	424	unsigned long flags;
	425	u8 control;
	426
	427	spin_lock_irqsave(&priv->lock, flags);
	428	if (set & TIOCM_RTS)
	429	priv->line_control \|= CH341_BIT_RTS;
	430	if (set & TIOCM_DTR)
	431	priv->line_control \|= CH341_BIT_DTR;
	432	if (clear & TIOCM_RTS)
	433	priv->line_control &= ~CH341_BIT_RTS;
	434	if (clear & TIOCM_DTR)
	435	priv->line_control &= ~CH341_BIT_DTR;
	436	control = priv->line_control;
	437	spin_unlock_irqrestore(&priv->lock, flags);
	438
	439	return ch341_set_handshake(port->serial->dev, control);
	440	}
	441
	442	static void ch341_read_int_callback(struct urb *urb)
	443	{
	444	struct usb_serial_port port = (struct usb_serial_port ) urb->context;
	445	unsigned char *data = urb->transfer_buffer;
	446	unsigned int actual_length = urb->actual_length;
	447	int status;
	448
664d5df9 WC	449	switch (urb->status) {
	450	case 0:
	451	/* success */
	452	break;
	453	case -ECONNRESET:
	454	case -ENOENT:
	455	case -ESHUTDOWN:
	456	/* this urb is terminated, clean up */
79cbeeaf GKH	457	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
79cbeeaf GKH	458	__func__, urb->status);
664d5df9 WC	459	return;
664d5df9 WC	460	default:
79cbeeaf GKH	461	dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
79cbeeaf GKH	462	__func__, urb->status);
664d5df9 WC	463	goto exit;
	464	}
	465
	466	usb_serial_debug_data(debug, &port->dev, __func__,
	467	urb->actual_length, urb->transfer_buffer);
	468
	469	if (actual_length >= 4) {
	470	struct ch341_private *priv = usb_get_serial_port_data(port);
	471	unsigned long flags;
d14fc1a7	472	u8 prev_line_status = priv->line_status;
664d5df9 WC	473
	474	spin_lock_irqsave(&priv->lock, flags);
	475	priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
	476	if ((data[1] & CH341_MULT_STAT))
	477	priv->multi_status_change = 1;
	478	spin_unlock_irqrestore(&priv->lock, flags);
d14fc1a7 LP	479
	480	if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) {
	481	struct tty_struct *tty = tty_port_tty_get(&port->port);
	482	if (tty)
	483	usb_serial_handle_dcd_change(port, tty,
	484	priv->line_status & CH341_BIT_DCD);
	485	tty_kref_put(tty);
	486	}
	487
664d5df9 WC	488	wake_up_interruptible(&priv->delta_msr_wait);
	489	}
	490
	491	exit:
	492	status = usb_submit_urb(urb, GFP_ATOMIC);
	493	if (status)
	494	dev_err(&urb->dev->dev,
	495	"%s - usb_submit_urb failed with result %d\n",
	496	__func__, status);
	497	}
	498
	499	static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
	500	{
	501	struct ch341_private *priv = usb_get_serial_port_data(port);
	502	unsigned long flags;
	503	u8 prevstatus;
	504	u8 status;
	505	u8 changed;
	506	u8 multi_change = 0;
	507
	508	spin_lock_irqsave(&priv->lock, flags);
	509	prevstatus = priv->line_status;
	510	priv->multi_status_change = 0;
	511	spin_unlock_irqrestore(&priv->lock, flags);
	512
	513	while (!multi_change) {
	514	interruptible_sleep_on(&priv->delta_msr_wait);
	515	/* see if a signal did it */
	516	if (signal_pending(current))
	517	return -ERESTARTSYS;
	518
	519	spin_lock_irqsave(&priv->lock, flags);
	520	status = priv->line_status;
	521	multi_change = priv->multi_status_change;
	522	spin_unlock_irqrestore(&priv->lock, flags);
	523
	524	changed = prevstatus ^ status;
	525
	526	if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) \|\|
	527	((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) \|\|
	528	((arg & TIOCM_CD) && (changed & CH341_BIT_DCD)) \|\|
	529	((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
	530	return 0;
	531	}
	532	prevstatus = status;
	533	}
	534
	535	return 0;
	536	}
	537
00a0d0d6	538	static int ch341_ioctl(struct tty_struct *tty,
664d5df9 WC	539	unsigned int cmd, unsigned long arg)
	540	{
	541	struct usb_serial_port *port = tty->driver_data;
79cbeeaf GKH	542
79cbeeaf GKH	543	dev_dbg(&port->dev, "%s (%d) cmd = 0x%04x\n", __func__, port->number, cmd);
664d5df9 WC	544
	545	switch (cmd) {
	546	case TIOCMIWAIT:
79cbeeaf	547	dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__, port->number);
664d5df9 WC	548	return wait_modem_info(port, arg);
	549
	550	default:
79cbeeaf	551	dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
664d5df9 WC	552	break;
	553	}
	554
	555	return -ENOIOCTLCMD;
	556	}
	557
60b33c13	558	static int ch341_tiocmget(struct tty_struct *tty)
664d5df9 WC	559	{
	560	struct usb_serial_port *port = tty->driver_data;
	561	struct ch341_private *priv = usb_get_serial_port_data(port);
	562	unsigned long flags;
	563	u8 mcr;
	564	u8 status;
	565	unsigned int result;
	566
664d5df9 WC	567	spin_lock_irqsave(&priv->lock, flags);
	568	mcr = priv->line_control;
	569	status = priv->line_status;
	570	spin_unlock_irqrestore(&priv->lock, flags);
	571
	572	result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0)
	573	\| ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0)
	574	\| ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0)
	575	\| ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0)
	576	\| ((status & CH341_BIT_RI) ? TIOCM_RI : 0)
	577	\| ((status & CH341_BIT_DCD) ? TIOCM_CD : 0);
	578
79cbeeaf	579	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
73f59308	580
664d5df9	581	return result;
6ce76104 FK	582	}
6ce76104 FK	583
622b80cf	584	static int ch341_reset_resume(struct usb_serial *serial)
1ded7ea4	585	{
1ded7ea4 ML	586	struct ch341_private *priv;
1ded7ea4 ML	587
1ded7ea4 ML	588	priv = usb_get_serial_port_data(serial->port[0]);
1ded7ea4 ML	589
2bfd1c96 GKH	590	/* reconfigure ch341 serial port after bus-reset */
2bfd1c96 GKH	591	ch341_configure(serial->dev, priv);
1ded7ea4 ML	592
	593	return 0;
	594	}
	595
6ce76104 FK	596	static struct usb_serial_driver ch341_device = {
	597	.driver = {
	598	.owner = THIS_MODULE,
	599	.name = "ch341-uart",
	600	},
664d5df9	601	.id_table = id_table,
664d5df9 WC	602	.num_ports = 1,
664d5df9 WC	603	.open = ch341_open,
335f8514 AC	604	.dtr_rts = ch341_dtr_rts,
335f8514 AC	605	.carrier_raised = ch341_carrier_raised,
664d5df9 WC	606	.close = ch341_close,
	607	.ioctl = ch341_ioctl,
	608	.set_termios = ch341_set_termios,
492896f0	609	.break_ctl = ch341_break_ctl,
664d5df9 WC	610	.tiocmget = ch341_tiocmget,
	611	.tiocmset = ch341_tiocmset,
	612	.read_int_callback = ch341_read_int_callback,
	613	.attach = ch341_attach,
1c1eaba8	614	.reset_resume = ch341_reset_resume,
6ce76104 FK	615	};
6ce76104 FK	616
08a4f6bc AS	617	static struct usb_serial_driver * const serial_drivers[] = {
	618	&ch341_device, NULL
	619	};
	620
68e24113	621	module_usb_serial_driver(serial_drivers, id_table);
6ce76104	622
6ce76104 FK	623	MODULE_LICENSE("GPL");
	624
	625	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	626	MODULE_PARM_DESC(debug, "Debug enabled or not");