![Johan Hovold](/assets/img/avatar_default.png)
The tty struct holds a pointer to the driver's tty operations so drop the unnecessary driver dereference when calling tiocmget and tiocmset. Note that this also makes the calls match the preceding sanity checks as expected. Signed-off-by: Johan Hovold <johan@kernel.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
321 lines
7.8 KiB
C
321 lines
7.8 KiB
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->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;
|
|
}
|