1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/types.h>
  3#include <linux/tty.h>
  4#include <linux/tty_flip.h>
  5#include <linux/slab.h>
  6
  7#include "speakup.h"
  8#include "spk_types.h"
  9#include "spk_priv.h"
 10
 11struct spk_ldisc_data {
 12	char buf;
 13	struct completion completion;
 14	bool buf_free;
 15};
 16
 17static struct spk_synth *spk_ttyio_synth;
 18static struct tty_struct *speakup_tty;
 19/* mutex to protect against speakup_tty disappearing from underneath us while
 20 * we are using it. this can happen when the device physically unplugged,
 21 * while in use. it also serialises access to speakup_tty.
 22 */
 23static DEFINE_MUTEX(speakup_tty_mutex);
 24
 25static int ser_to_dev(int ser, dev_t *dev_no)
 26{
 27	if (ser < 0 || ser > (255 - 64)) {
 28		pr_err("speakup: Invalid ser param. Must be between 0 and 191 inclusive.\n");
 29		return -EINVAL;
 30	}
 31
 32	*dev_no = MKDEV(4, (64 + ser));
 33	return 0;
 34}
 35
 36static int get_dev_to_use(struct spk_synth *synth, dev_t *dev_no)
 37{
 38	/* use ser only when dev is not specified */
 39	if (strcmp(synth->dev_name, SYNTH_DEFAULT_DEV) ||
 40	    synth->ser == SYNTH_DEFAULT_SER)
 41		return tty_dev_name_to_number(synth->dev_name, dev_no);
 42
 43	return ser_to_dev(synth->ser, dev_no);
 44}
 45
 46static int spk_ttyio_ldisc_open(struct tty_struct *tty)
 47{
 48	struct spk_ldisc_data *ldisc_data;
 49
 50	if (!tty->ops->write)
 51		return -EOPNOTSUPP;
 52	speakup_tty = tty;
 53
 54	ldisc_data = kmalloc(sizeof(*ldisc_data), GFP_KERNEL);
 55	if (!ldisc_data)
 56		return -ENOMEM;
 57
 58	init_completion(&ldisc_data->completion);
 59	ldisc_data->buf_free = true;
 60	speakup_tty->disc_data = ldisc_data;
 61
 62	return 0;
 63}
 64
 65static void spk_ttyio_ldisc_close(struct tty_struct *tty)
 66{
 67	mutex_lock(&speakup_tty_mutex);
 68	kfree(speakup_tty->disc_data);
 69	speakup_tty = NULL;
 70	mutex_unlock(&speakup_tty_mutex);
 71}
 72
 73static int spk_ttyio_receive_buf2(struct tty_struct *tty,
 74				  const unsigned char *cp, char *fp, int count)
 75{
 76	struct spk_ldisc_data *ldisc_data = tty->disc_data;
 77
 78	if (spk_ttyio_synth->read_buff_add) {
 79		int i;
 80
 81		for (i = 0; i < count; i++)
 82			spk_ttyio_synth->read_buff_add(cp[i]);
 83
 84		return count;
 85	}
 86
 87	if (!ldisc_data->buf_free)
 88		/* ttyio_in will tty_schedule_flip */
 89		return 0;
 90
 91	/* Make sure the consumer has read buf before we have seen
 92	 * buf_free == true and overwrite buf
 93	 */
 94	mb();
 95
 96	ldisc_data->buf = cp[0];
 97	ldisc_data->buf_free = false;
 98	complete(&ldisc_data->completion);
 99
100	return 1;
101}
102
103static struct tty_ldisc_ops spk_ttyio_ldisc_ops = {
104	.owner          = THIS_MODULE,
105	.magic          = TTY_LDISC_MAGIC,
106	.name           = "speakup_ldisc",
107	.open           = spk_ttyio_ldisc_open,
108	.close          = spk_ttyio_ldisc_close,
109	.receive_buf2	= spk_ttyio_receive_buf2,
110};
111
112static int spk_ttyio_out(struct spk_synth *in_synth, const char ch);
113static int spk_ttyio_out_unicode(struct spk_synth *in_synth, u16 ch);
114static void spk_ttyio_send_xchar(char ch);
115static void spk_ttyio_tiocmset(unsigned int set, unsigned int clear);
116static unsigned char spk_ttyio_in(void);
117static unsigned char spk_ttyio_in_nowait(void);
118static void spk_ttyio_flush_buffer(void);
119static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth);
120
121struct spk_io_ops spk_ttyio_ops = {
122	.synth_out = spk_ttyio_out,
123	.synth_out_unicode = spk_ttyio_out_unicode,
124	.send_xchar = spk_ttyio_send_xchar,
125	.tiocmset = spk_ttyio_tiocmset,
126	.synth_in = spk_ttyio_in,
127	.synth_in_nowait = spk_ttyio_in_nowait,
128	.flush_buffer = spk_ttyio_flush_buffer,
129	.wait_for_xmitr = spk_ttyio_wait_for_xmitr,
130};
131EXPORT_SYMBOL_GPL(spk_ttyio_ops);
132
133static inline void get_termios(struct tty_struct *tty,
134			       struct ktermios *out_termios)
135{
136	down_read(&tty->termios_rwsem);
137	*out_termios = tty->termios;
138	up_read(&tty->termios_rwsem);
139}
140
141static int spk_ttyio_initialise_ldisc(struct spk_synth *synth)
142{
143	int ret = 0;
144	struct tty_struct *tty;
145	struct ktermios tmp_termios;
146	dev_t dev;
147
148	ret = get_dev_to_use(synth, &dev);
149	if (ret)
150		return ret;
151
152	tty = tty_kopen(dev);
153	if (IS_ERR(tty))
154		return PTR_ERR(tty);
155
156	if (tty->ops->open)
157		ret = tty->ops->open(tty, NULL);
158	else
159		ret = -ENODEV;
160
161	if (ret) {
162		tty_unlock(tty);
163		return ret;
164	}
165
166	clear_bit(TTY_HUPPED, &tty->flags);
167	/* ensure hardware flow control is enabled */
168	get_termios(tty, &tmp_termios);
169	if (!(tmp_termios.c_cflag & CRTSCTS)) {
170		tmp_termios.c_cflag |= CRTSCTS;
171		tty_set_termios(tty, &tmp_termios);
172		/*
173		 * check c_cflag to see if it's updated as tty_set_termios
174		 * may not return error even when no tty bits are
175		 * changed by the request.
176		 */
177		get_termios(tty, &tmp_termios);
178		if (!(tmp_termios.c_cflag & CRTSCTS))
179			pr_warn("speakup: Failed to set hardware flow control\n");
180	}
181
182	tty_unlock(tty);
183
184	ret = tty_set_ldisc(tty, N_SPEAKUP);
185	if (ret)
186		pr_err("speakup: Failed to set N_SPEAKUP on tty\n");
187
188	return ret;
189}
190
191void spk_ttyio_register_ldisc(void)
192{
193	if (tty_register_ldisc(N_SPEAKUP, &spk_ttyio_ldisc_ops))
194		pr_warn("speakup: Error registering line discipline. Most synths won't work.\n");
195}
196
197void spk_ttyio_unregister_ldisc(void)
198{
199	if (tty_unregister_ldisc(N_SPEAKUP))
200		pr_warn("speakup: Couldn't unregister ldisc\n");
201}
202
203static int spk_ttyio_out(struct spk_synth *in_synth, const char ch)
204{
205	mutex_lock(&speakup_tty_mutex);
206	if (in_synth->alive && speakup_tty && speakup_tty->ops->write) {
207		int ret = speakup_tty->ops->write(speakup_tty, &ch, 1);
208
209		mutex_unlock(&speakup_tty_mutex);
210		if (ret == 0)
211			/* No room */
212			return 0;
213		if (ret < 0) {
214			pr_warn("%s: I/O error, deactivating speakup\n",
215				in_synth->long_name);
216			/* No synth any more, so nobody will restart TTYs,
217			 * and we thus need to do it ourselves.  Now that there
218			 * is no synth we can let application flood anyway
219			 */
220			in_synth->alive = 0;
221			speakup_start_ttys();
222			return 0;
223		}
224		return 1;
225	}
226
227	mutex_unlock(&speakup_tty_mutex);
228	return 0;
229}
230
231static int spk_ttyio_out_unicode(struct spk_synth *in_synth, u16 ch)
232{
233	int ret;
234
235	if (ch < 0x80) {
236		ret = spk_ttyio_out(in_synth, ch);
237	} else if (ch < 0x800) {
238		ret  = spk_ttyio_out(in_synth, 0xc0 | (ch >> 6));
239		ret &= spk_ttyio_out(in_synth, 0x80 | (ch & 0x3f));
240	} else {
241		ret  = spk_ttyio_out(in_synth, 0xe0 | (ch >> 12));
242		ret &= spk_ttyio_out(in_synth, 0x80 | ((ch >> 6) & 0x3f));
243		ret &= spk_ttyio_out(in_synth, 0x80 | (ch & 0x3f));
244	}
245	return ret;
246}
247
248static int check_tty(struct tty_struct *tty)
249{
250	if (!tty) {
251		pr_warn("%s: I/O error, deactivating speakup\n",
252			spk_ttyio_synth->long_name);
253		/* No synth any more, so nobody will restart TTYs, and we thus
254		 * need to do it ourselves.  Now that there is no synth we can
255		 * let application flood anyway
256		 */
257		spk_ttyio_synth->alive = 0;
258		speakup_start_ttys();
259		return 1;
260	}
261
262	return 0;
263}
264
265static void spk_ttyio_send_xchar(char ch)
266{
267	mutex_lock(&speakup_tty_mutex);
268	if (check_tty(speakup_tty)) {
269		mutex_unlock(&speakup_tty_mutex);
270		return;
271	}
272
273	if (speakup_tty->ops->send_xchar)
274		speakup_tty->ops->send_xchar(speakup_tty, ch);
275	mutex_unlock(&speakup_tty_mutex);
276}
277
278static void spk_ttyio_tiocmset(unsigned int set, unsigned int clear)
279{
280	mutex_lock(&speakup_tty_mutex);
281	if (check_tty(speakup_tty)) {
282		mutex_unlock(&speakup_tty_mutex);
283		return;
284	}
285
286	if (speakup_tty->ops->tiocmset)
287		speakup_tty->ops->tiocmset(speakup_tty, set, clear);
288	mutex_unlock(&speakup_tty_mutex);
289}
290
291static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth)
292{
293	return 1;
294}
295
296static unsigned char ttyio_in(int timeout)
297{
298	struct spk_ldisc_data *ldisc_data = speakup_tty->disc_data;
299	char rv;
300
301	if (wait_for_completion_timeout(&ldisc_data->completion,
302					usecs_to_jiffies(timeout)) == 0) {
303		if (timeout)
304			pr_warn("spk_ttyio: timeout (%d)  while waiting for input\n",
305				timeout);
306		return 0xff;
307	}
308
309	rv = ldisc_data->buf;
310	/* Make sure we have read buf before we set buf_free to let
311	 * the producer overwrite it
312	 */
313	mb();
314	ldisc_data->buf_free = true;
315	/* Let TTY push more characters */
316	tty_schedule_flip(speakup_tty->port);
317
318	return rv;
319}
320
321static unsigned char spk_ttyio_in(void)
322{
323	return ttyio_in(SPK_SYNTH_TIMEOUT);
324}
325
326static unsigned char spk_ttyio_in_nowait(void)
327{
328	u8 rv = ttyio_in(0);
329
330	return (rv == 0xff) ? 0 : rv;
331}
332
333static void spk_ttyio_flush_buffer(void)
334{
335	mutex_lock(&speakup_tty_mutex);
336	if (check_tty(speakup_tty)) {
337		mutex_unlock(&speakup_tty_mutex);
338		return;
339	}
340
341	if (speakup_tty->ops->flush_buffer)
342		speakup_tty->ops->flush_buffer(speakup_tty);
343
344	mutex_unlock(&speakup_tty_mutex);
345}
346
347int spk_ttyio_synth_probe(struct spk_synth *synth)
348{
349	int rv = spk_ttyio_initialise_ldisc(synth);
350
351	if (rv)
352		return rv;
353
354	synth->alive = 1;
355	spk_ttyio_synth = synth;
356
357	return 0;
358}
359EXPORT_SYMBOL_GPL(spk_ttyio_synth_probe);
360
361void spk_ttyio_release(void)
362{
363	if (!speakup_tty)
364		return;
365
366	tty_lock(speakup_tty);
367
368	if (speakup_tty->ops->close)
369		speakup_tty->ops->close(speakup_tty, NULL);
370
371	tty_ldisc_flush(speakup_tty);
372	tty_unlock(speakup_tty);
373	tty_kclose(speakup_tty);
374}
375EXPORT_SYMBOL_GPL(spk_ttyio_release);
376
377const char *spk_ttyio_synth_immediate(struct spk_synth *synth, const char *buff)
378{
379	u_char ch;
380
381	while ((ch = *buff)) {
382		if (ch == '\n')
383			ch = synth->procspeech;
384		if (tty_write_room(speakup_tty) < 1 ||
385		    !synth->io_ops->synth_out(synth, ch))
386			return buff;
387		buff++;
388	}
389	return NULL;
390}
391EXPORT_SYMBOL_GPL(spk_ttyio_synth_immediate);