forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
318 lines
7.7 KiB
318 lines
7.7 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <[email protected]> |
|
*/ |
|
#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; |
|
}
|
|
|