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