drivers/usb/serial/upd78f0730.c - linux-imx - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Renesas Electronics uPD78F0730 USB to serial converter driver
  *
  * Copyright (C) 2014,2016 Maksim Salau <maksim.salau@gmail.com>
  *
  * 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.
  *
  * Protocol of the adaptor is described in the application note U19660EJ1V0AN00
  * μPD78F0730 8-bit Single-Chip Microcontroller
  * USB-to-Serial Conversion Software
  * <https://www.renesas.com/en-eu/doc/DocumentServer/026/U19660EJ1V0AN00.pdf>
  *
  * The adaptor functionality is limited to the following:
  * - data bits: 7 or 8
  * - stop bits: 1 or 2
  * - parity: even, odd or none
  * - flow control: none
  * - baud rates: 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
  * - signals: DTR, RTS and BREAK
  */

 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>

 #define DRIVER_DESC "Renesas uPD78F0730 USB to serial converter driver"

 #define DRIVER_AUTHOR "Maksim Salau <maksim.salau@gmail.com>"

 static const struct usb_device_id id_table[] = {
 	{ USB_DEVICE(0x0409, 0x0063) }, /* V850ESJX3-STICK */
 	{ USB_DEVICE(0x045B, 0x0212) }, /* YRPBRL78G13, YRPBRL78G14 */
 	{ USB_DEVICE(0x064B, 0x7825) }, /* Analog Devices EVAL-ADXL362Z-DB */
 	{}
 };

 MODULE_DEVICE_TABLE(usb, id_table);

 /*
  * Each adaptor is associated with a private structure, that holds the current
  * state of control signals (DTR, RTS and BREAK).
  */
 struct upd78f0730_port_private {
 	struct mutex	lock;		/* mutex to protect line_signals */
 	u8		line_signals;
 };

 /* Op-codes of control commands */
 #define UPD78F0730_CMD_LINE_CONTROL	0x00
 #define UPD78F0730_CMD_SET_DTR_RTS	0x01
 #define UPD78F0730_CMD_SET_XON_XOFF_CHR	0x02
 #define UPD78F0730_CMD_OPEN_CLOSE	0x03
 #define UPD78F0730_CMD_SET_ERR_CHR	0x04

 /* Data sizes in UPD78F0730_CMD_LINE_CONTROL command */
 #define UPD78F0730_DATA_SIZE_7_BITS	0x00
 #define UPD78F0730_DATA_SIZE_8_BITS	0x01
 #define UPD78F0730_DATA_SIZE_MASK	0x01

 /* Stop-bit modes in UPD78F0730_CMD_LINE_CONTROL command */
 #define UPD78F0730_STOP_BIT_1_BIT	0x00
 #define UPD78F0730_STOP_BIT_2_BIT	0x02
 #define UPD78F0730_STOP_BIT_MASK	0x02

 /* Parity modes in UPD78F0730_CMD_LINE_CONTROL command */
 #define UPD78F0730_PARITY_NONE	0x00
 #define UPD78F0730_PARITY_EVEN	0x04
 #define UPD78F0730_PARITY_ODD	0x08
 #define UPD78F0730_PARITY_MASK	0x0C

 /* Flow control modes in UPD78F0730_CMD_LINE_CONTROL command */
 #define UPD78F0730_FLOW_CONTROL_NONE	0x00
 #define UPD78F0730_FLOW_CONTROL_HW	0x10
 #define UPD78F0730_FLOW_CONTROL_SW	0x20
 #define UPD78F0730_FLOW_CONTROL_MASK	0x30

 /* Control signal bits in UPD78F0730_CMD_SET_DTR_RTS command */
 #define UPD78F0730_RTS		0x01
 #define UPD78F0730_DTR		0x02
 #define UPD78F0730_BREAK	0x04

 /* Port modes in UPD78F0730_CMD_OPEN_CLOSE command */
 #define UPD78F0730_PORT_CLOSE	0x00
 #define UPD78F0730_PORT_OPEN	0x01

 /* Error character substitution modes in UPD78F0730_CMD_SET_ERR_CHR command */
 #define UPD78F0730_ERR_CHR_DISABLED	0x00
 #define UPD78F0730_ERR_CHR_ENABLED	0x01

 /*
  * Declaration of command structures
  */

 /* UPD78F0730_CMD_LINE_CONTROL command */
 struct upd78f0730_line_control {
 	u8	opcode;
 	__le32	baud_rate;
 	u8	params;
 } __packed;

 /* UPD78F0730_CMD_SET_DTR_RTS command */
 struct upd78f0730_set_dtr_rts {
 	u8 opcode;
 	u8 params;
 };

 /* UPD78F0730_CMD_SET_XON_OFF_CHR command */
 struct upd78f0730_set_xon_xoff_chr {
 	u8 opcode;
 	u8 xon;
 	u8 xoff;
 };

 /* UPD78F0730_CMD_OPEN_CLOSE command */
 struct upd78f0730_open_close {
 	u8 opcode;
 	u8 state;
 };

 /* UPD78F0730_CMD_SET_ERR_CHR command */
 struct upd78f0730_set_err_chr {
 	u8 opcode;
 	u8 state;
 	u8 err_char;
 };

 static int upd78f0730_send_ctl(struct usb_serial_port *port,
 			const void *data, int size)
 {
 	struct usb_device *usbdev = port->serial->dev;
 	void *buf;
 	int res;

 	if (size <= 0 || !data)
 		return -EINVAL;

 	buf = kmemdup(data, size, GFP_KERNEL);
 	if (!buf)
 		return -ENOMEM;

 	res = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x00,
 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 			0x0000, 0x0000, buf, size, USB_CTRL_SET_TIMEOUT);

 	kfree(buf);

 	if (res != size) {
 		struct device *dev = &port->dev;

 		dev_err(dev, "failed to send control request %02x: %d\n",
 			*(u8 *)data, res);
 		/* The maximum expected length of a transfer is 6 bytes */
 		if (res >= 0)
 			res = -EIO;

 		return res;
 	}

 	return 0;
 }

 static int upd78f0730_port_probe(struct usb_serial_port *port)
 {
 	struct upd78f0730_port_private *private;

 	private = kzalloc(sizeof(*private), GFP_KERNEL);
 	if (!private)
 		return -ENOMEM;

 	mutex_init(&private->lock);
 	usb_set_serial_port_data(port, private);

 	return 0;
 }

 static int upd78f0730_port_remove(struct usb_serial_port *port)
 {
 	struct upd78f0730_port_private *private;

 	private = usb_get_serial_port_data(port);
 	mutex_destroy(&private->lock);
 	kfree(private);

 	return 0;
 }

 static int upd78f0730_tiocmget(struct tty_struct *tty)
 {
 	struct device *dev = tty->dev;
 	struct upd78f0730_port_private *private;
 	struct usb_serial_port *port = tty->driver_data;
 	int signals;
 	int res;

 	private = usb_get_serial_port_data(port);

 	mutex_lock(&private->lock);
 	signals = private->line_signals;
 	mutex_unlock(&private->lock);

 	res = ((signals & UPD78F0730_DTR) ? TIOCM_DTR : 0) |
 		((signals & UPD78F0730_RTS) ? TIOCM_RTS : 0);

 	dev_dbg(dev, "%s - res = %x\n", __func__, res);

 	return res;
 }

 static int upd78f0730_tiocmset(struct tty_struct *tty,
 			unsigned int set, unsigned int clear)
 {
 	struct device *dev = tty->dev;
 	struct usb_serial_port *port = tty->driver_data;
 	struct upd78f0730_port_private *private;
 	struct upd78f0730_set_dtr_rts request;
 	int res;

 	private = usb_get_serial_port_data(port);

 	mutex_lock(&private->lock);
 	if (set & TIOCM_DTR) {
 		private->line_signals |= UPD78F0730_DTR;
 		dev_dbg(dev, "%s - set DTR\n", __func__);
 	}
 	if (set & TIOCM_RTS) {
 		private->line_signals |= UPD78F0730_RTS;
 		dev_dbg(dev, "%s - set RTS\n", __func__);
 	}
 	if (clear & TIOCM_DTR) {
 		private->line_signals &= ~UPD78F0730_DTR;
 		dev_dbg(dev, "%s - clear DTR\n", __func__);
 	}
 	if (clear & TIOCM_RTS) {
 		private->line_signals &= ~UPD78F0730_RTS;
 		dev_dbg(dev, "%s - clear RTS\n", __func__);
 	}
 	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
 	request.params = private->line_signals;

 	res = upd78f0730_send_ctl(port, &request, sizeof(request));
 	mutex_unlock(&private->lock);

 	return res;
 }

 static void upd78f0730_break_ctl(struct tty_struct *tty, int break_state)
 {
 	struct device *dev = tty->dev;
 	struct upd78f0730_port_private *private;
 	struct usb_serial_port *port = tty->driver_data;
 	struct upd78f0730_set_dtr_rts request;

 	private = usb_get_serial_port_data(port);

 	mutex_lock(&private->lock);
 	if (break_state) {
 		private->line_signals |= UPD78F0730_BREAK;
 		dev_dbg(dev, "%s - set BREAK\n", __func__);
 	} else {
 		private->line_signals &= ~UPD78F0730_BREAK;
 		dev_dbg(dev, "%s - clear BREAK\n", __func__);
 	}
 	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
 	request.params = private->line_signals;

 	upd78f0730_send_ctl(port, &request, sizeof(request));
 	mutex_unlock(&private->lock);
 }

 static void upd78f0730_dtr_rts(struct usb_serial_port *port, int on)
 {
 	struct tty_struct *tty = port->port.tty;
 	unsigned int set = 0;
 	unsigned int clear = 0;

 	if (on)
 		set = TIOCM_DTR | TIOCM_RTS;
 	else
 		clear = TIOCM_DTR | TIOCM_RTS;

 	upd78f0730_tiocmset(tty, set, clear);
 }

 static speed_t upd78f0730_get_baud_rate(struct tty_struct *tty)
 {
 	const speed_t baud_rate = tty_get_baud_rate(tty);
 	static const speed_t supported[] = {
 		0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
 	};
 	int i;

 	for (i = ARRAY_SIZE(supported) - 1; i >= 0; i--) {
 		if (baud_rate == supported[i])
 			return baud_rate;
 	}

 	/* If the baud rate is not supported, switch to the default one */
 	tty_encode_baud_rate(tty, 9600, 9600);

 	return tty_get_baud_rate(tty);
 }

 static void upd78f0730_set_termios(struct tty_struct *tty,
 				struct usb_serial_port *port,
 				struct ktermios *old_termios)
 {
 	struct device *dev = &port->dev;
 	struct upd78f0730_line_control request;
 	speed_t baud_rate;

 	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
 		return;

 	if (C_BAUD(tty) == B0)
 		upd78f0730_dtr_rts(port, 0);
 	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 		upd78f0730_dtr_rts(port, 1);

 	baud_rate = upd78f0730_get_baud_rate(tty);
 	request.opcode = UPD78F0730_CMD_LINE_CONTROL;
 	request.baud_rate = cpu_to_le32(baud_rate);
 	request.params = 0;
 	dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud_rate);

 	switch (C_CSIZE(tty)) {
 	case CS7:
 		request.params |= UPD78F0730_DATA_SIZE_7_BITS;
 		dev_dbg(dev, "%s - 7 data bits\n", __func__);
 		break;
 	default:
 		tty->termios.c_cflag &= ~CSIZE;
 		tty->termios.c_cflag |= CS8;
 		dev_warn(dev, "data size is not supported, using 8 bits\n");
 		/* fall through */
 	case CS8:
 		request.params |= UPD78F0730_DATA_SIZE_8_BITS;
 		dev_dbg(dev, "%s - 8 data bits\n", __func__);
 		break;
 	}

 	if (C_PARENB(tty)) {
 		if (C_PARODD(tty)) {
 			request.params |= UPD78F0730_PARITY_ODD;
 			dev_dbg(dev, "%s - odd parity\n", __func__);
 		} else {
 			request.params |= UPD78F0730_PARITY_EVEN;
 			dev_dbg(dev, "%s - even parity\n", __func__);
 		}

 		if (C_CMSPAR(tty)) {
 			tty->termios.c_cflag &= ~CMSPAR;
 			dev_warn(dev, "MARK/SPACE parity is not supported\n");
 		}
 	} else {
 		request.params |= UPD78F0730_PARITY_NONE;
 		dev_dbg(dev, "%s - no parity\n", __func__);
 	}

 	if (C_CSTOPB(tty)) {
 		request.params |= UPD78F0730_STOP_BIT_2_BIT;
 		dev_dbg(dev, "%s - 2 stop bits\n", __func__);
 	} else {
 		request.params |= UPD78F0730_STOP_BIT_1_BIT;
 		dev_dbg(dev, "%s - 1 stop bit\n", __func__);
 	}

 	if (C_CRTSCTS(tty)) {
 		tty->termios.c_cflag &= ~CRTSCTS;
 		dev_warn(dev, "RTSCTS flow control is not supported\n");
 	}
 	if (I_IXOFF(tty) || I_IXON(tty)) {
 		tty->termios.c_iflag &= ~(IXOFF | IXON);
 		dev_warn(dev, "XON/XOFF flow control is not supported\n");
 	}
 	request.params |= UPD78F0730_FLOW_CONTROL_NONE;
 	dev_dbg(dev, "%s - no flow control\n", __func__);

 	upd78f0730_send_ctl(port, &request, sizeof(request));
 }

 static int upd78f0730_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
 	static const struct upd78f0730_open_close request = {
 		.opcode = UPD78F0730_CMD_OPEN_CLOSE,
 		.state = UPD78F0730_PORT_OPEN
 	};
 	int res;

 	res = upd78f0730_send_ctl(port, &request, sizeof(request));
 	if (res)
 		return res;

 	if (tty)
 		upd78f0730_set_termios(tty, port, NULL);

 	return usb_serial_generic_open(tty, port);
 }

 static void upd78f0730_close(struct usb_serial_port *port)
 {
 	static const struct upd78f0730_open_close request = {
 		.opcode = UPD78F0730_CMD_OPEN_CLOSE,
 		.state = UPD78F0730_PORT_CLOSE
 	};

 	usb_serial_generic_close(port);
 	upd78f0730_send_ctl(port, &request, sizeof(request));
 }

 static struct usb_serial_driver upd78f0730_device = {
 	.driver	 = {
 		.owner	= THIS_MODULE,
 		.name	= "upd78f0730",
 	},
 	.id_table	= id_table,
 	.num_ports	= 1,
 	.port_probe	= upd78f0730_port_probe,
 	.port_remove	= upd78f0730_port_remove,
 	.open		= upd78f0730_open,
 	.close		= upd78f0730_close,
 	.set_termios	= upd78f0730_set_termios,
 	.tiocmget	= upd78f0730_tiocmget,
 	.tiocmset	= upd78f0730_tiocmset,
 	.dtr_rts	= upd78f0730_dtr_rts,
 	.break_ctl	= upd78f0730_break_ctl,
 };

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

 module_usb_serial_driver(serial_drivers, id_table);

 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Renesas Electronics uPD78F0730 USB to serial converter driver
	*
	* Copyright (C) 2014,2016 Maksim Salau <maksim.salau@gmail.com>
	*
	* 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.
	*
	* Protocol of the adaptor is described in the application note U19660EJ1V0AN00
	* μPD78F0730 8-bit Single-Chip Microcontroller
	* USB-to-Serial Conversion Software
	* <https://www.renesas.com/en-eu/doc/DocumentServer/026/U19660EJ1V0AN00.pdf>
	*
	* The adaptor functionality is limited to the following:
	* - data bits: 7 or 8
	* - stop bits: 1 or 2
	* - parity: even, odd or none
	* - flow control: none
	* - baud rates: 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
	* - signals: DTR, RTS and BREAK
	*/

	#include <linux/module.h>
	#include <linux/slab.h>
	#include <linux/tty.h>
	#include <linux/usb.h>
	#include <linux/usb/serial.h>

	#define DRIVER_DESC "Renesas uPD78F0730 USB to serial converter driver"

	#define DRIVER_AUTHOR "Maksim Salau <maksim.salau@gmail.com>"

	static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(0x0409, 0x0063) }, /* V850ESJX3-STICK */
	{ USB_DEVICE(0x045B, 0x0212) }, /* YRPBRL78G13, YRPBRL78G14 */
	{ USB_DEVICE(0x064B, 0x7825) }, /* Analog Devices EVAL-ADXL362Z-DB */
	{}
	};

	MODULE_DEVICE_TABLE(usb, id_table);

	/*
	* Each adaptor is associated with a private structure, that holds the current
	* state of control signals (DTR, RTS and BREAK).
	*/
	struct upd78f0730_port_private {
	struct mutex lock; /* mutex to protect line_signals */
	u8 line_signals;
	};

	/* Op-codes of control commands */
	#define UPD78F0730_CMD_LINE_CONTROL 0x00
	#define UPD78F0730_CMD_SET_DTR_RTS 0x01
	#define UPD78F0730_CMD_SET_XON_XOFF_CHR 0x02
	#define UPD78F0730_CMD_OPEN_CLOSE 0x03
	#define UPD78F0730_CMD_SET_ERR_CHR 0x04

	/* Data sizes in UPD78F0730_CMD_LINE_CONTROL command */
	#define UPD78F0730_DATA_SIZE_7_BITS 0x00
	#define UPD78F0730_DATA_SIZE_8_BITS 0x01
	#define UPD78F0730_DATA_SIZE_MASK 0x01

	/* Stop-bit modes in UPD78F0730_CMD_LINE_CONTROL command */
	#define UPD78F0730_STOP_BIT_1_BIT 0x00
	#define UPD78F0730_STOP_BIT_2_BIT 0x02
	#define UPD78F0730_STOP_BIT_MASK 0x02

	/* Parity modes in UPD78F0730_CMD_LINE_CONTROL command */
	#define UPD78F0730_PARITY_NONE 0x00
	#define UPD78F0730_PARITY_EVEN 0x04
	#define UPD78F0730_PARITY_ODD 0x08
	#define UPD78F0730_PARITY_MASK 0x0C

	/* Flow control modes in UPD78F0730_CMD_LINE_CONTROL command */
	#define UPD78F0730_FLOW_CONTROL_NONE 0x00
	#define UPD78F0730_FLOW_CONTROL_HW 0x10
	#define UPD78F0730_FLOW_CONTROL_SW 0x20
	#define UPD78F0730_FLOW_CONTROL_MASK 0x30

	/* Control signal bits in UPD78F0730_CMD_SET_DTR_RTS command */
	#define UPD78F0730_RTS 0x01
	#define UPD78F0730_DTR 0x02
	#define UPD78F0730_BREAK 0x04

	/* Port modes in UPD78F0730_CMD_OPEN_CLOSE command */
	#define UPD78F0730_PORT_CLOSE 0x00
	#define UPD78F0730_PORT_OPEN 0x01

	/* Error character substitution modes in UPD78F0730_CMD_SET_ERR_CHR command */
	#define UPD78F0730_ERR_CHR_DISABLED 0x00
	#define UPD78F0730_ERR_CHR_ENABLED 0x01

	/*
	* Declaration of command structures
	*/

	/* UPD78F0730_CMD_LINE_CONTROL command */
	struct upd78f0730_line_control {
	u8 opcode;
	__le32 baud_rate;
	u8 params;
	} __packed;

	/* UPD78F0730_CMD_SET_DTR_RTS command */
	struct upd78f0730_set_dtr_rts {
	u8 opcode;
	u8 params;
	};

	/* UPD78F0730_CMD_SET_XON_OFF_CHR command */
	struct upd78f0730_set_xon_xoff_chr {
	u8 opcode;
	u8 xon;
	u8 xoff;
	};

	/* UPD78F0730_CMD_OPEN_CLOSE command */
	struct upd78f0730_open_close {
	u8 opcode;
	u8 state;
	};

	/* UPD78F0730_CMD_SET_ERR_CHR command */
	struct upd78f0730_set_err_chr {
	u8 opcode;
	u8 state;
	u8 err_char;
	};

	static int upd78f0730_send_ctl(struct usb_serial_port *port,
	const void *data, int size)
	{
	struct usb_device *usbdev = port->serial->dev;
	void *buf;
	int res;

	if (size <= 0 \|\| !data)
	return -EINVAL;

	buf = kmemdup(data, size, GFP_KERNEL);
	if (!buf)
	return -ENOMEM;

	res = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x00,
	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT,
	0x0000, 0x0000, buf, size, USB_CTRL_SET_TIMEOUT);

	kfree(buf);

	if (res != size) {
	struct device *dev = &port->dev;

	dev_err(dev, "failed to send control request %02x: %d\n",
	(u8 )data, res);
	/* The maximum expected length of a transfer is 6 bytes */
	if (res >= 0)
	res = -EIO;

	return res;
	}

	return 0;
	}

	static int upd78f0730_port_probe(struct usb_serial_port *port)
	{
	struct upd78f0730_port_private *private;

	private = kzalloc(sizeof(*private), GFP_KERNEL);
	if (!private)
	return -ENOMEM;

	mutex_init(&private->lock);
	usb_set_serial_port_data(port, private);

	return 0;
	}

	static int upd78f0730_port_remove(struct usb_serial_port *port)
	{
	struct upd78f0730_port_private *private;

	private = usb_get_serial_port_data(port);
	mutex_destroy(&private->lock);
	kfree(private);

	return 0;
	}

	static int upd78f0730_tiocmget(struct tty_struct *tty)
	{
	struct device *dev = tty->dev;
	struct upd78f0730_port_private *private;
	struct usb_serial_port *port = tty->driver_data;
	int signals;
	int res;

	private = usb_get_serial_port_data(port);

	mutex_lock(&private->lock);
	signals = private->line_signals;
	mutex_unlock(&private->lock);

	res = ((signals & UPD78F0730_DTR) ? TIOCM_DTR : 0) \|
	((signals & UPD78F0730_RTS) ? TIOCM_RTS : 0);

	dev_dbg(dev, "%s - res = %x\n", __func__, res);

	return res;
	}

	static int upd78f0730_tiocmset(struct tty_struct *tty,
	unsigned int set, unsigned int clear)
	{
	struct device *dev = tty->dev;
	struct usb_serial_port *port = tty->driver_data;
	struct upd78f0730_port_private *private;
	struct upd78f0730_set_dtr_rts request;
	int res;

	private = usb_get_serial_port_data(port);

	mutex_lock(&private->lock);
	if (set & TIOCM_DTR) {
	private->line_signals \|= UPD78F0730_DTR;
	dev_dbg(dev, "%s - set DTR\n", __func__);
	}
	if (set & TIOCM_RTS) {
	private->line_signals \|= UPD78F0730_RTS;
	dev_dbg(dev, "%s - set RTS\n", __func__);
	}
	if (clear & TIOCM_DTR) {
	private->line_signals &= ~UPD78F0730_DTR;
	dev_dbg(dev, "%s - clear DTR\n", __func__);
	}
	if (clear & TIOCM_RTS) {
	private->line_signals &= ~UPD78F0730_RTS;
	dev_dbg(dev, "%s - clear RTS\n", __func__);
	}
	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
	request.params = private->line_signals;

	res = upd78f0730_send_ctl(port, &request, sizeof(request));
	mutex_unlock(&private->lock);

	return res;
	}

	static void upd78f0730_break_ctl(struct tty_struct *tty, int break_state)
	{
	struct device *dev = tty->dev;
	struct upd78f0730_port_private *private;
	struct usb_serial_port *port = tty->driver_data;
	struct upd78f0730_set_dtr_rts request;

	private = usb_get_serial_port_data(port);

	mutex_lock(&private->lock);
	if (break_state) {
	private->line_signals \|= UPD78F0730_BREAK;
	dev_dbg(dev, "%s - set BREAK\n", __func__);
	} else {
	private->line_signals &= ~UPD78F0730_BREAK;
	dev_dbg(dev, "%s - clear BREAK\n", __func__);
	}
	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
	request.params = private->line_signals;

	upd78f0730_send_ctl(port, &request, sizeof(request));
	mutex_unlock(&private->lock);
	}

	static void upd78f0730_dtr_rts(struct usb_serial_port *port, int on)
	{
	struct tty_struct *tty = port->port.tty;
	unsigned int set = 0;
	unsigned int clear = 0;

	if (on)
	set = TIOCM_DTR \| TIOCM_RTS;
	else
	clear = TIOCM_DTR \| TIOCM_RTS;

	upd78f0730_tiocmset(tty, set, clear);
	}

	static speed_t upd78f0730_get_baud_rate(struct tty_struct *tty)
	{
	const speed_t baud_rate = tty_get_baud_rate(tty);
	static const speed_t supported[] = {
	0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
	};
	int i;

	for (i = ARRAY_SIZE(supported) - 1; i >= 0; i--) {
	if (baud_rate == supported[i])
	return baud_rate;
	}

	/* If the baud rate is not supported, switch to the default one */
	tty_encode_baud_rate(tty, 9600, 9600);

	return tty_get_baud_rate(tty);
	}

	static void upd78f0730_set_termios(struct tty_struct *tty,
	struct usb_serial_port *port,
	struct ktermios *old_termios)
	{
	struct device *dev = &port->dev;
	struct upd78f0730_line_control request;
	speed_t baud_rate;

	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
	return;

	if (C_BAUD(tty) == B0)
	upd78f0730_dtr_rts(port, 0);
	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
	upd78f0730_dtr_rts(port, 1);

	baud_rate = upd78f0730_get_baud_rate(tty);
	request.opcode = UPD78F0730_CMD_LINE_CONTROL;
	request.baud_rate = cpu_to_le32(baud_rate);
	request.params = 0;
	dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud_rate);

	switch (C_CSIZE(tty)) {
	case CS7:
	request.params \|= UPD78F0730_DATA_SIZE_7_BITS;
	dev_dbg(dev, "%s - 7 data bits\n", __func__);
	break;
	default:
	tty->termios.c_cflag &= ~CSIZE;
	tty->termios.c_cflag \|= CS8;
	dev_warn(dev, "data size is not supported, using 8 bits\n");
	/* fall through */
	case CS8:
	request.params \|= UPD78F0730_DATA_SIZE_8_BITS;
	dev_dbg(dev, "%s - 8 data bits\n", __func__);
	break;
	}

	if (C_PARENB(tty)) {
	if (C_PARODD(tty)) {
	request.params \|= UPD78F0730_PARITY_ODD;
	dev_dbg(dev, "%s - odd parity\n", __func__);
	} else {
	request.params \|= UPD78F0730_PARITY_EVEN;
	dev_dbg(dev, "%s - even parity\n", __func__);
	}

	if (C_CMSPAR(tty)) {
	tty->termios.c_cflag &= ~CMSPAR;
	dev_warn(dev, "MARK/SPACE parity is not supported\n");
	}
	} else {
	request.params \|= UPD78F0730_PARITY_NONE;
	dev_dbg(dev, "%s - no parity\n", __func__);
	}

	if (C_CSTOPB(tty)) {
	request.params \|= UPD78F0730_STOP_BIT_2_BIT;
	dev_dbg(dev, "%s - 2 stop bits\n", __func__);
	} else {
	request.params \|= UPD78F0730_STOP_BIT_1_BIT;
	dev_dbg(dev, "%s - 1 stop bit\n", __func__);
	}

	if (C_CRTSCTS(tty)) {
	tty->termios.c_cflag &= ~CRTSCTS;
	dev_warn(dev, "RTSCTS flow control is not supported\n");
	}
	if (I_IXOFF(tty) \|\| I_IXON(tty)) {
	tty->termios.c_iflag &= ~(IXOFF \| IXON);
	dev_warn(dev, "XON/XOFF flow control is not supported\n");
	}
	request.params \|= UPD78F0730_FLOW_CONTROL_NONE;
	dev_dbg(dev, "%s - no flow control\n", __func__);

	upd78f0730_send_ctl(port, &request, sizeof(request));
	}

	static int upd78f0730_open(struct tty_struct tty, struct usb_serial_port port)
	{
	static const struct upd78f0730_open_close request = {
	.opcode = UPD78F0730_CMD_OPEN_CLOSE,
	.state = UPD78F0730_PORT_OPEN
	};
	int res;

	res = upd78f0730_send_ctl(port, &request, sizeof(request));
	if (res)
	return res;

	if (tty)
	upd78f0730_set_termios(tty, port, NULL);

	return usb_serial_generic_open(tty, port);
	}

	static void upd78f0730_close(struct usb_serial_port *port)
	{
	static const struct upd78f0730_open_close request = {
	.opcode = UPD78F0730_CMD_OPEN_CLOSE,
	.state = UPD78F0730_PORT_CLOSE
	};

	usb_serial_generic_close(port);
	upd78f0730_send_ctl(port, &request, sizeof(request));
	}

	static struct usb_serial_driver upd78f0730_device = {
	.driver = {
	.owner = THIS_MODULE,
	.name = "upd78f0730",
	},
	.id_table = id_table,
	.num_ports = 1,
	.port_probe = upd78f0730_port_probe,
	.port_remove = upd78f0730_port_remove,
	.open = upd78f0730_open,
	.close = upd78f0730_close,
	.set_termios = upd78f0730_set_termios,
	.tiocmget = upd78f0730_tiocmget,
	.tiocmset = upd78f0730_tiocmset,
	.dtr_rts = upd78f0730_dtr_rts,
	.break_ctl = upd78f0730_break_ctl,
	};

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

	module_usb_serial_driver(serial_drivers, id_table);

	MODULE_DESCRIPTION(DRIVER_DESC);
	MODULE_AUTHOR(DRIVER_AUTHOR);
	MODULE_LICENSE("GPL v2");