mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 18:14:07 +08:00
0c5aae5927
The serdev tty-port controller driver should reset the tty-port client
operations also on deregistration to avoid a NULL-pointer dereference in
case the port is later re-registered as a normal tty device.
Note that this can only happen with tty drivers such as 8250 which have
statically allocated port structures that can end up being reused and
where a later registration would not register a serdev controller (e.g.
due to registration errors or if the devicetree has been changed in
between).
Specifically, this can be an issue for any statically defined ports that
would be registered by 8250 core when an 8250 driver is being unbound.
Fixes: bed35c6dfa
("serdev: add a tty port controller driver")
Cc: stable <stable@vger.kernel.org> # 4.11
Reported-by: Loic Poulain <loic.poulain@linaro.org>
Signed-off-by: Johan Hovold <johan@kernel.org>
Link: https://lore.kernel.org/r/20200210145730.22762-1-johan@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
319 lines
7.7 KiB
C
319 lines
7.7 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)
|
|
{
|
|
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;
|
|
|
|
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 = &tty_port_default_client_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_data = NULL;
|
|
port->client_ops = &tty_port_default_client_ops;
|
|
serdev_controller_put(ctrl);
|
|
|
|
return 0;
|
|
}
|