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