projects/linux·blob master · refs

320 lines · 7.8 KiB

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