[mirror_ubuntu-eoan-kernel.git] / drivers / tty / serdev / serdev-ttyport.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org>
 */
#include <linux/kernel.h>
#include <linux/serdev.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/poll.h>

#define SERPORT_ACTIVE		1

struct serport {
	struct tty_port *port;
	struct tty_struct *tty;
	struct tty_driver *tty_drv;
	int tty_idx;
	unsigned long flags;
};

/*
 * Callback functions from the tty port.
 */

static int ttyport_receive_buf(struct tty_port *port, const unsigned char *cp,
				const unsigned char *fp, size_t count)
{
	struct serdev_controller *ctrl = port->client_data;
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	int ret;

	if (!test_bit(SERPORT_ACTIVE, &serport->flags))
		return 0;

	ret = serdev_controller_receive_buf(ctrl, cp, count);

	dev_WARN_ONCE(&ctrl->dev, ret < 0 || ret > count,
				"receive_buf returns %d (count = %zu)\n",
				ret, count);
	if (ret < 0)
		return 0;
	else if (ret > count)
		return count;

	return ret;
}

static void ttyport_write_wakeup(struct tty_port *port)
{
	struct serdev_controller *ctrl = port->client_data;
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty;

	tty = tty_port_tty_get(port);
	if (!tty)
		return;

	if (test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
	    test_bit(SERPORT_ACTIVE, &serport->flags))
		serdev_controller_write_wakeup(ctrl);

	/* Wake up any tty_wait_until_sent() */
	wake_up_interruptible(&tty->write_wait);

	tty_kref_put(tty);
}

static const struct tty_port_client_operations client_ops = {
	.receive_buf = ttyport_receive_buf,
	.write_wakeup = ttyport_write_wakeup,
};

/*
 * Callback functions from the serdev core.
 */

static int ttyport_write_buf(struct serdev_controller *ctrl, const unsigned char *data, size_t len)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	if (!test_bit(SERPORT_ACTIVE, &serport->flags))
		return 0;

	set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
	return tty->ops->write(serport->tty, data, len);
}

static void ttyport_write_flush(struct serdev_controller *ctrl)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	tty_driver_flush_buffer(tty);
}

static int ttyport_write_room(struct serdev_controller *ctrl)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	return tty_write_room(tty);
}

static int ttyport_open(struct serdev_controller *ctrl)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty;
	struct ktermios ktermios;
	int ret;

	tty = tty_init_dev(serport->tty_drv, serport->tty_idx);
	if (IS_ERR(tty))
		return PTR_ERR(tty);
	serport->tty = tty;

	if (!tty->ops->open || !tty->ops->close) {
		ret = -ENODEV;
		goto err_unlock;
	}

	ret = tty->ops->open(serport->tty, NULL);
	if (ret)
		goto err_close;

	tty_unlock(serport->tty);

	/* Bring the UART into a known 8 bits no parity hw fc state */
	ktermios = tty->termios;
	ktermios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP |
			      INLCR | IGNCR | ICRNL | IXON);
	ktermios.c_oflag &= ~OPOST;
	ktermios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
	ktermios.c_cflag &= ~(CSIZE | PARENB);
	ktermios.c_cflag |= CS8;
	ktermios.c_cflag |= CRTSCTS;
	/* Hangups are not supported so make sure to ignore carrier detect. */
	ktermios.c_cflag |= CLOCAL;
	tty_set_termios(tty, &ktermios);

	set_bit(SERPORT_ACTIVE, &serport->flags);

	return 0;

err_close:
	tty->ops->close(tty, NULL);
err_unlock:
	tty_unlock(tty);
	tty_release_struct(tty, serport->tty_idx);

	return ret;
}

static void ttyport_close(struct serdev_controller *ctrl)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	clear_bit(SERPORT_ACTIVE, &serport->flags);

	tty_lock(tty);
	if (tty->ops->close)
		tty->ops->close(tty, NULL);
	tty_unlock(tty);

	tty_release_struct(tty, serport->tty_idx);
}

static unsigned int ttyport_set_baudrate(struct serdev_controller *ctrl, unsigned int speed)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;
	struct ktermios ktermios = tty->termios;

	ktermios.c_cflag &= ~CBAUD;
	tty_termios_encode_baud_rate(&ktermios, speed, speed);

	/* tty_set_termios() return not checked as it is always 0 */
	tty_set_termios(tty, &ktermios);
	return ktermios.c_ospeed;
}

static void ttyport_set_flow_control(struct serdev_controller *ctrl, bool enable)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;
	struct ktermios ktermios = tty->termios;

	if (enable)
		ktermios.c_cflag |= CRTSCTS;
	else
		ktermios.c_cflag &= ~CRTSCTS;

	tty_set_termios(tty, &ktermios);
}

static int ttyport_set_parity(struct serdev_controller *ctrl,
			      enum serdev_parity parity)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;
	struct ktermios ktermios = tty->termios;

	ktermios.c_cflag &= ~(PARENB | PARODD | CMSPAR);
	if (parity != SERDEV_PARITY_NONE) {
		ktermios.c_cflag |= PARENB;
		if (parity == SERDEV_PARITY_ODD)
			ktermios.c_cflag |= PARODD;
	}

	tty_set_termios(tty, &ktermios);

	if ((tty->termios.c_cflag & (PARENB | PARODD | CMSPAR)) !=
	    (ktermios.c_cflag & (PARENB | PARODD | CMSPAR)))
		return -EINVAL;

	return 0;
}

static void ttyport_wait_until_sent(struct serdev_controller *ctrl, long timeout)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	tty_wait_until_sent(tty, timeout);
}

static int ttyport_get_tiocm(struct serdev_controller *ctrl)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	if (!tty->ops->tiocmget)
		return -ENOTSUPP;

	return tty->driver->ops->tiocmget(tty);
}

static int ttyport_set_tiocm(struct serdev_controller *ctrl, unsigned int set, unsigned int clear)
{
	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	struct tty_struct *tty = serport->tty;

	if (!tty->ops->tiocmset)
		return -ENOTSUPP;

	return tty->driver->ops->tiocmset(tty, set, clear);
}

static const struct serdev_controller_ops ctrl_ops = {
	.write_buf = ttyport_write_buf,
	.write_flush = ttyport_write_flush,
	.write_room = ttyport_write_room,
	.open = ttyport_open,
	.close = ttyport_close,
	.set_flow_control = ttyport_set_flow_control,
	.set_parity = ttyport_set_parity,
	.set_baudrate = ttyport_set_baudrate,
	.wait_until_sent = ttyport_wait_until_sent,
	.get_tiocm = ttyport_get_tiocm,
	.set_tiocm = ttyport_set_tiocm,
};

struct device *serdev_tty_port_register(struct tty_port *port,
					struct device *parent,
					struct tty_driver *drv, int idx)
{
	const struct tty_port_client_operations *old_ops;
	struct serdev_controller *ctrl;
	struct serport *serport;
	int ret;

	if (!port || !drv || !parent)
		return ERR_PTR(-ENODEV);

	ctrl = serdev_controller_alloc(parent, sizeof(struct serport));
	if (!ctrl)
		return ERR_PTR(-ENOMEM);
	serport = serdev_controller_get_drvdata(ctrl);

	serport->port = port;
	serport->tty_idx = idx;
	serport->tty_drv = drv;

	ctrl->ops = &ctrl_ops;

	old_ops = port->client_ops;
	port->client_ops = &client_ops;
	port->client_data = ctrl;

	ret = serdev_controller_add(ctrl);
	if (ret)
		goto err_reset_data;

	dev_info(&ctrl->dev, "tty port %s%d registered\n", drv->name, idx);
	return &ctrl->dev;

err_reset_data:
	port->client_data = NULL;
	port->client_ops = old_ops;
	serdev_controller_put(ctrl);

	return ERR_PTR(ret);
}

int serdev_tty_port_unregister(struct tty_port *port)
{
	struct serdev_controller *ctrl = port->client_data;
	struct serport *serport = serdev_controller_get_drvdata(ctrl);

	if (!serport)
		return -ENODEV;

	serdev_controller_remove(ctrl);
	port->client_ops = NULL;
	port->client_data = NULL;
	serdev_controller_put(ctrl);

	return 0;
}
Commit	Line	Data
e3b3d0f5	1	// SPDX-License-Identifier: GPL-2.0
bed35c6d RH	2	/*
bed35c6d RH	3	* Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org>
bed35c6d RH	4	*/
	5	#include <linux/kernel.h>
	6	#include <linux/serdev.h>
	7	#include <linux/tty.h>
	8	#include <linux/tty_driver.h>
b3f80c8f	9	#include <linux/poll.h>
bed35c6d RH	10
	11	#define SERPORT_ACTIVE 1
	12
	13	struct serport {
	14	struct tty_port *port;
	15	struct tty_struct *tty;
	16	struct tty_driver *tty_drv;
	17	int tty_idx;
	18	unsigned long flags;
	19	};
	20
	21	/*
	22	* Callback functions from the tty port.
	23	*/
	24
	25	static int ttyport_receive_buf(struct tty_port port, const unsigned char cp,
	26	const unsigned char *fp, size_t count)
	27	{
	28	struct serdev_controller *ctrl = port->client_data;
	29	struct serport *serport = serdev_controller_get_drvdata(ctrl);
eb281683	30	int ret;
bed35c6d RH	31
	32	if (!test_bit(SERPORT_ACTIVE, &serport->flags))
	33	return 0;
	34
eb281683 JH	35	ret = serdev_controller_receive_buf(ctrl, cp, count);
	36
	37	dev_WARN_ONCE(&ctrl->dev, ret < 0 \|\| ret > count,
	38	"receive_buf returns %d (count = %zu)\n",
	39	ret, count);
	40	if (ret < 0)
	41	return 0;
	42	else if (ret > count)
	43	return count;
	44
	45	return ret;
bed35c6d RH	46	}
	47
	48	static void ttyport_write_wakeup(struct tty_port *port)
	49	{
	50	struct serdev_controller *ctrl = port->client_data;
	51	struct serport *serport = serdev_controller_get_drvdata(ctrl);
8bcd4e6a JH	52	struct tty_struct *tty;
	53
	54	tty = tty_port_tty_get(port);
	55	if (!tty)
	56	return;
bed35c6d	57
8bcd4e6a	58	if (test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
b3f80c8f	59	test_bit(SERPORT_ACTIVE, &serport->flags))
bed35c6d	60	serdev_controller_write_wakeup(ctrl);
b3f80c8f	61
afe3eb60 JH	62	/* Wake up any tty_wait_until_sent() */
afe3eb60 JH	63	wake_up_interruptible(&tty->write_wait);
8bcd4e6a JH	64
8bcd4e6a JH	65	tty_kref_put(tty);
bed35c6d RH	66	}
	67
	68	static const struct tty_port_client_operations client_ops = {
	69	.receive_buf = ttyport_receive_buf,
	70	.write_wakeup = ttyport_write_wakeup,
	71	};
	72
	73	/*
	74	* Callback functions from the serdev core.
	75	*/
	76
	77	static int ttyport_write_buf(struct serdev_controller ctrl, const unsigned char data, size_t len)
	78	{
	79	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	80	struct tty_struct *tty = serport->tty;
	81
	82	if (!test_bit(SERPORT_ACTIVE, &serport->flags))
	83	return 0;
	84
	85	set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
	86	return tty->ops->write(serport->tty, data, len);
	87	}
	88
	89	static void ttyport_write_flush(struct serdev_controller *ctrl)
	90	{
	91	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	92	struct tty_struct *tty = serport->tty;
	93
	94	tty_driver_flush_buffer(tty);
	95	}
	96
	97	static int ttyport_write_room(struct serdev_controller *ctrl)
	98	{
	99	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	100	struct tty_struct *tty = serport->tty;
	101
	102	return tty_write_room(tty);
	103	}
	104
	105	static int ttyport_open(struct serdev_controller *ctrl)
	106	{
	107	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	108	struct tty_struct *tty;
	109	struct ktermios ktermios;
7c63838e	110	int ret;
bed35c6d RH	111
bed35c6d RH	112	tty = tty_init_dev(serport->tty_drv, serport->tty_idx);
10d258c5 DC	113	if (IS_ERR(tty))
10d258c5 DC	114	return PTR_ERR(tty);
bed35c6d RH	115	serport->tty = tty;
bed35c6d RH	116
7c63838e JH	117	if (!tty->ops->open \|\| !tty->ops->close) {
7c63838e JH	118	ret = -ENODEV;
dee7d0f3	119	goto err_unlock;
7c63838e	120	}
dee7d0f3	121
7c63838e JH	122	ret = tty->ops->open(serport->tty, NULL);
	123	if (ret)
	124	goto err_close;
bed35c6d	125
51899a63 JH	126	tty_unlock(serport->tty);
51899a63 JH	127
bed35c6d RH	128	/* Bring the UART into a known 8 bits no parity hw fc state */
	129	ktermios = tty->termios;
	130	ktermios.c_iflag &= ~(IGNBRK \| BRKINT \| PARMRK \| ISTRIP \|
	131	INLCR \| IGNCR \| ICRNL \| IXON);
	132	ktermios.c_oflag &= ~OPOST;
	133	ktermios.c_lflag &= ~(ECHO \| ECHONL \| ICANON \| ISIG \| IEXTEN);
	134	ktermios.c_cflag &= ~(CSIZE \| PARENB);
	135	ktermios.c_cflag \|= CS8;
	136	ktermios.c_cflag \|= CRTSCTS;
cda64188 JH	137	/* Hangups are not supported so make sure to ignore carrier detect. */
cda64188 JH	138	ktermios.c_cflag \|= CLOCAL;
bed35c6d RH	139	tty_set_termios(tty, &ktermios);
	140
	141	set_bit(SERPORT_ACTIVE, &serport->flags);
	142
bed35c6d	143	return 0;
dee7d0f3	144
7c63838e JH	145	err_close:
7c63838e JH	146	tty->ops->close(tty, NULL);
dee7d0f3 JH	147	err_unlock:
	148	tty_unlock(tty);
	149	tty_release_struct(tty, serport->tty_idx);
	150
7c63838e	151	return ret;
bed35c6d RH	152	}
	153
	154	static void ttyport_close(struct serdev_controller *ctrl)
	155	{
	156	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	157	struct tty_struct *tty = serport->tty;
	158
	159	clear_bit(SERPORT_ACTIVE, &serport->flags);
	160
90dbad8c	161	tty_lock(tty);
bed35c6d RH	162	if (tty->ops->close)
bed35c6d RH	163	tty->ops->close(tty, NULL);
90dbad8c	164	tty_unlock(tty);
bed35c6d RH	165
	166	tty_release_struct(tty, serport->tty_idx);
	167	}
	168
	169	static unsigned int ttyport_set_baudrate(struct serdev_controller *ctrl, unsigned int speed)
	170	{
	171	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	172	struct tty_struct *tty = serport->tty;
	173	struct ktermios ktermios = tty->termios;
	174
	175	ktermios.c_cflag &= ~CBAUD;
	176	tty_termios_encode_baud_rate(&ktermios, speed, speed);
	177
	178	/* tty_set_termios() return not checked as it is always 0 */
	179	tty_set_termios(tty, &ktermios);
56c607b5	180	return ktermios.c_ospeed;
bed35c6d RH	181	}
	182
	183	static void ttyport_set_flow_control(struct serdev_controller *ctrl, bool enable)
	184	{
	185	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	186	struct tty_struct *tty = serport->tty;
	187	struct ktermios ktermios = tty->termios;
	188
	189	if (enable)
	190	ktermios.c_cflag \|= CRTSCTS;
	191	else
	192	ktermios.c_cflag &= ~CRTSCTS;
	193
	194	tty_set_termios(tty, &ktermios);
	195	}
	196
3a19cfcc UH	197	static int ttyport_set_parity(struct serdev_controller *ctrl,
	198	enum serdev_parity parity)
	199	{
	200	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	201	struct tty_struct *tty = serport->tty;
	202	struct ktermios ktermios = tty->termios;
	203
	204	ktermios.c_cflag &= ~(PARENB \| PARODD \| CMSPAR);
	205	if (parity != SERDEV_PARITY_NONE) {
	206	ktermios.c_cflag \|= PARENB;
	207	if (parity == SERDEV_PARITY_ODD)
	208	ktermios.c_cflag \|= PARODD;
	209	}
	210
	211	tty_set_termios(tty, &ktermios);
	212
	213	if ((tty->termios.c_cflag & (PARENB \| PARODD \| CMSPAR)) !=
	214	(ktermios.c_cflag & (PARENB \| PARODD \| CMSPAR)))
	215	return -EINVAL;
	216
	217	return 0;
	218	}
	219
b3f80c8f SR	220	static void ttyport_wait_until_sent(struct serdev_controller *ctrl, long timeout)
	221	{
	222	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	223	struct tty_struct *tty = serport->tty;
	224
	225	tty_wait_until_sent(tty, timeout);
	226	}
	227
5659dab2 SR	228	static int ttyport_get_tiocm(struct serdev_controller *ctrl)
	229	{
	230	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	231	struct tty_struct *tty = serport->tty;
	232
	233	if (!tty->ops->tiocmget)
	234	return -ENOTSUPP;
	235
	236	return tty->driver->ops->tiocmget(tty);
	237	}
	238
	239	static int ttyport_set_tiocm(struct serdev_controller *ctrl, unsigned int set, unsigned int clear)
	240	{
	241	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	242	struct tty_struct *tty = serport->tty;
	243
	244	if (!tty->ops->tiocmset)
	245	return -ENOTSUPP;
	246
	247	return tty->driver->ops->tiocmset(tty, set, clear);
	248	}
	249
bed35c6d RH	250	static const struct serdev_controller_ops ctrl_ops = {
	251	.write_buf = ttyport_write_buf,
	252	.write_flush = ttyport_write_flush,
	253	.write_room = ttyport_write_room,
	254	.open = ttyport_open,
	255	.close = ttyport_close,
	256	.set_flow_control = ttyport_set_flow_control,
3a19cfcc	257	.set_parity = ttyport_set_parity,
bed35c6d	258	.set_baudrate = ttyport_set_baudrate,
b3f80c8f	259	.wait_until_sent = ttyport_wait_until_sent,
5659dab2 SR	260	.get_tiocm = ttyport_get_tiocm,
5659dab2 SR	261	.set_tiocm = ttyport_set_tiocm,
bed35c6d RH	262	};
	263
	264	struct device serdev_tty_port_register(struct tty_port port,
	265	struct device *parent,
	266	struct tty_driver *drv, int idx)
	267	{
aee5da78	268	const struct tty_port_client_operations *old_ops;
bed35c6d RH	269	struct serdev_controller *ctrl;
	270	struct serport *serport;
	271	int ret;
	272
	273	if (!port \|\| !drv \|\| !parent)
	274	return ERR_PTR(-ENODEV);
	275
	276	ctrl = serdev_controller_alloc(parent, sizeof(struct serport));
	277	if (!ctrl)
	278	return ERR_PTR(-ENOMEM);
	279	serport = serdev_controller_get_drvdata(ctrl);
	280
	281	serport->port = port;
	282	serport->tty_idx = idx;
	283	serport->tty_drv = drv;
	284
	285	ctrl->ops = &ctrl_ops;
	286
aee5da78 JH	287	old_ops = port->client_ops;
	288	port->client_ops = &client_ops;
	289	port->client_data = ctrl;
	290
bed35c6d RH	291	ret = serdev_controller_add(ctrl);
bed35c6d RH	292	if (ret)
aee5da78	293	goto err_reset_data;
bed35c6d RH	294
	295	dev_info(&ctrl->dev, "tty port %s%d registered\n", drv->name, idx);
	296	return &ctrl->dev;
	297
aee5da78 JH	298	err_reset_data:
	299	port->client_data = NULL;
	300	port->client_ops = old_ops;
bed35c6d	301	serdev_controller_put(ctrl);
aee5da78	302
bed35c6d RH	303	return ERR_PTR(ret);
	304	}
	305
8cde11b2	306	int serdev_tty_port_unregister(struct tty_port *port)
bed35c6d RH	307	{
	308	struct serdev_controller *ctrl = port->client_data;
	309	struct serport *serport = serdev_controller_get_drvdata(ctrl);
	310
	311	if (!serport)
8cde11b2	312	return -ENODEV;
bed35c6d RH	313
	314	serdev_controller_remove(ctrl);
	315	port->client_ops = NULL;
	316	port->client_data = NULL;
	317	serdev_controller_put(ctrl);
8cde11b2 JH	318
8cde11b2 JH	319	return 0;
bed35c6d	320	}