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