Release 4.18 drivers/staging/speakup/spk_ttyio.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/types.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/slab.h>

#include "speakup.h"
#include "spk_types.h"
#include "spk_priv.h"


struct spk_ldisc_data {
	
char buf;
	
struct semaphore sem;
	
bool buf_free;
};


static struct spk_synth *spk_ttyio_synth;

static struct tty_struct *speakup_tty;
/* mutex to protect against speakup_tty disappearing from underneath us while
 * we are using it. this can happen when the device physically unplugged,
 * while in use. it also serialises access to speakup_tty.
 */
static DEFINE_MUTEX(speakup_tty_mutex);



static int ser_to_dev(int ser, dev_t *dev_no)
{
	if (ser < 0 || ser > (255 - 64)) {
		pr_err("speakup: Invalid ser param. Must be between 0 and 191 inclusive.\n");
		return -EINVAL;
	}

	*dev_no = MKDEV(4, (64 + ser));
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
54
98.18%
1
50.00%
Colin Ian King
1
1.82%
1
50.00%
Total
55
100.00%
2
100.00%



static int get_dev_to_use(struct spk_synth *synth, dev_t *dev_no)
{
	/* use ser only when dev is not specified */
	if (strcmp(synth->dev_name, SYNTH_DEFAULT_DEV) ||
	    synth->ser == SYNTH_DEFAULT_SER)
		return tty_dev_name_to_number(synth->dev_name, dev_no);

	return ser_to_dev(synth->ser, dev_no);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
53
100.00%
1
100.00%
Total
53
100.00%
1
100.00%



static int spk_ttyio_ldisc_open(struct tty_struct *tty)
{
	struct spk_ldisc_data *ldisc_data;

	if (tty->ops->write == NULL)
		return -EOPNOTSUPP;
	speakup_tty = tty;

	ldisc_data = kmalloc(sizeof(struct spk_ldisc_data), GFP_KERNEL);
	if (!ldisc_data)
		return -ENOMEM;

	sema_init(&ldisc_data->sem, 0);
	ldisc_data->buf_free = true;
	speakup_tty->disc_data = ldisc_data;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
81
100.00%
2
100.00%
Total
81
100.00%
2
100.00%



static void spk_ttyio_ldisc_close(struct tty_struct *tty)
{
	mutex_lock(&speakup_tty_mutex);
	kfree(speakup_tty->disc_data);
	speakup_tty = NULL;
	mutex_unlock(&speakup_tty_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
34
100.00%
3
100.00%
Total
34
100.00%
3
100.00%



static int spk_ttyio_receive_buf2(struct tty_struct *tty,
				  const unsigned char *cp, char *fp, int count)
{
	struct spk_ldisc_data *ldisc_data = tty->disc_data;

	if (spk_ttyio_synth->read_buff_add) {
		int i;

		for (i = 0; i < count; i++)
			spk_ttyio_synth->read_buff_add(cp[i]);

		return count;
	}

	if (!ldisc_data->buf_free)
		/* ttyio_in will tty_schedule_flip */
		return 0;

	/* Make sure the consumer has read buf before we have seen
         * buf_free == true and overwrite buf
         */
	mb();

	ldisc_data->buf = cp[0];
	ldisc_data->buf_free = false;
	up(&ldisc_data->sem);

	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
110
99.10%
1
50.00%
Mihaela Muraru
1
0.90%
1
50.00%
Total
111
100.00%
2
100.00%


static struct tty_ldisc_ops spk_ttyio_ldisc_ops = {
	.owner          = THIS_MODULE,
	.magic          = TTY_LDISC_MAGIC,
	.name           = "speakup_ldisc",
	.open           = spk_ttyio_ldisc_open,
	.close          = spk_ttyio_ldisc_close,
	.receive_buf2	= spk_ttyio_receive_buf2,
};

static int spk_ttyio_out(struct spk_synth *in_synth, const char ch);
static int spk_ttyio_out_unicode(struct spk_synth *in_synth, u16 ch);
static void spk_ttyio_send_xchar(char ch);
static void spk_ttyio_tiocmset(unsigned int set, unsigned int clear);
static unsigned char spk_ttyio_in(void);
static unsigned char spk_ttyio_in_nowait(void);
static void spk_ttyio_flush_buffer(void);


struct spk_io_ops spk_ttyio_ops = {
	.synth_out = spk_ttyio_out,
	.synth_out_unicode = spk_ttyio_out_unicode,
	.send_xchar = spk_ttyio_send_xchar,
	.tiocmset = spk_ttyio_tiocmset,
	.synth_in = spk_ttyio_in,
	.synth_in_nowait = spk_ttyio_in_nowait,
	.flush_buffer = spk_ttyio_flush_buffer,
};
EXPORT_SYMBOL_GPL(spk_ttyio_ops);



static inline void get_termios(struct tty_struct *tty, struct ktermios *out_termios)
{
	down_read(&tty->termios_rwsem);
	*out_termios = tty->termios;
	up_read(&tty->termios_rwsem);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%



static int spk_ttyio_initialise_ldisc(struct spk_synth *synth)
{
	int ret = 0;
	struct tty_struct *tty;
	struct ktermios tmp_termios;
	dev_t dev;

	ret = get_dev_to_use(synth, &dev);
	if (ret)
		return ret;

	tty = tty_kopen(dev);
	if (IS_ERR(tty))
		return PTR_ERR(tty);

	if (tty->ops->open)
		ret = tty->ops->open(tty, NULL);
	else
		ret = -ENODEV;

	if (ret) {
		tty_unlock(tty);
		return ret;
	}

	clear_bit(TTY_HUPPED, &tty->flags);
	/* ensure hardware flow control is enabled */
	get_termios(tty, &tmp_termios);
	if (!(tmp_termios.c_cflag & CRTSCTS)) {
		tmp_termios.c_cflag |= CRTSCTS;
		tty_set_termios(tty, &tmp_termios);
		/*
                 * check c_cflag to see if it's updated as tty_set_termios may not return
                 * error even when no tty bits are changed by the request.
                 */
		get_termios(tty, &tmp_termios);
		if (!(tmp_termios.c_cflag & CRTSCTS))
			pr_warn("speakup: Failed to set hardware flow control\n");
	}

	tty_unlock(tty);

	ret = tty_set_ldisc(tty, N_SPEAKUP);
	if (ret)
		pr_err("speakup: Failed to set N_SPEAKUP on tty\n");

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
203
100.00%
5
100.00%
Total
203
100.00%
5
100.00%



void spk_ttyio_register_ldisc(void)
{
	if (tty_register_ldisc(N_SPEAKUP, &spk_ttyio_ldisc_ops))
		pr_warn("speakup: Error registering line discipline. Most synths won't work.\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



void spk_ttyio_unregister_ldisc(void)
{
	if (tty_unregister_ldisc(N_SPEAKUP))
		pr_warn("speakup: Couldn't unregister ldisc\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



static int spk_ttyio_out(struct spk_synth *in_synth, const char ch)
{
	mutex_lock(&speakup_tty_mutex);
	if (in_synth->alive && speakup_tty && speakup_tty->ops->write) {
		int ret = speakup_tty->ops->write(speakup_tty, &ch, 1);

		mutex_unlock(&speakup_tty_mutex);
		if (ret == 0)
			/* No room */
			return 0;
		if (ret < 0) {
			pr_warn("%s: I/O error, deactivating speakup\n", in_synth->long_name);
			/* No synth any more, so nobody will restart TTYs, and we thus
                         * need to do it ourselves.  Now that there is no synth we can
                         * let application flood anyway
                         */
			in_synth->alive = 0;
			speakup_start_ttys();
			return 0;
		}
		return 1;
	}

	mutex_unlock(&speakup_tty_mutex);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
112
100.00%
2
100.00%
Total
112
100.00%
2
100.00%



static int spk_ttyio_out_unicode(struct spk_synth *in_synth, u16 ch)
{
	int ret;

	if (ch < 0x80)
		ret = spk_ttyio_out(in_synth, ch);
	else if (ch < 0x800) {
		ret  = spk_ttyio_out(in_synth, 0xc0 | (ch >> 6));
		ret &= spk_ttyio_out(in_synth, 0x80 | (ch & 0x3f));
	} else {
		ret  = spk_ttyio_out(in_synth, 0xe0 | (ch >> 12));
		ret &= spk_ttyio_out(in_synth, 0x80 | ((ch >> 6) & 0x3f));
		ret &= spk_ttyio_out(in_synth, 0x80 | (ch & 0x3f));
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samuel Thibault
126
100.00%
1
100.00%
Total
126
100.00%
1
100.00%



static int check_tty(struct tty_struct *tty)
{
	if (!tty) {
		pr_warn("%s: I/O error, deactivating speakup\n",
			spk_ttyio_synth->long_name);
		/* No synth any more, so nobody will restart TTYs, and we thus
                 * need to do it ourselves.  Now that there is no synth we can
                 * let application flood anyway
                 */
		spk_ttyio_synth->alive = 0;
		speakup_start_ttys();
		return 1;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
43
100.00%
2
100.00%
Total
43
100.00%
2
100.00%



static void spk_ttyio_send_xchar(char ch)
{
	mutex_lock(&speakup_tty_mutex);
	if (check_tty(speakup_tty)) {
		mutex_unlock(&speakup_tty_mutex);
		return;
	}

	speakup_tty->ops->send_xchar(speakup_tty, ch);
	mutex_unlock(&speakup_tty_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
48
100.00%
2
100.00%
Total
48
100.00%
2
100.00%



static void spk_ttyio_tiocmset(unsigned int set, unsigned int clear)
{
	mutex_lock(&speakup_tty_mutex);
	if (check_tty(speakup_tty)) {
		mutex_unlock(&speakup_tty_mutex);
		return;
	}

	speakup_tty->ops->tiocmset(speakup_tty, set, clear);
	mutex_unlock(&speakup_tty_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
55
100.00%
2
100.00%
Total
55
100.00%
2
100.00%



static unsigned char ttyio_in(int timeout)
{
	struct spk_ldisc_data *ldisc_data = speakup_tty->disc_data;
	char rv;

	if (down_timeout(&ldisc_data->sem, usecs_to_jiffies(timeout)) == -ETIME) {
		if (timeout)
			pr_warn("spk_ttyio: timeout (%d)  while waiting for input\n",
				timeout);
		return 0xff;
	}

	rv = ldisc_data->buf;
	/* Make sure we have read buf before we set buf_free to let
         * the producer overwrite it
         */
	mb();
	ldisc_data->buf_free = true;
	/* Let TTY push more characters */
	tty_schedule_flip(speakup_tty->port);

	return rv;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
82
98.80%
1
50.00%
Mihaela Muraru
1
1.20%
1
50.00%
Total
83
100.00%
2
100.00%



static unsigned char spk_ttyio_in(void)
{
	return ttyio_in(SPK_SYNTH_TIMEOUT);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



static unsigned char spk_ttyio_in_nowait(void)
{
	u8 rv = ttyio_in(0);

	return (rv == 0xff) ? 0 : rv;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
27
96.43%
1
50.00%
Dan Carpenter
1
3.57%
1
50.00%
Total
28
100.00%
2
100.00%



static void spk_ttyio_flush_buffer(void)
{
	mutex_lock(&speakup_tty_mutex);
	if (check_tty(speakup_tty)) {
		mutex_unlock(&speakup_tty_mutex);
		return;
	}

	if (speakup_tty->ops->flush_buffer)
		speakup_tty->ops->flush_buffer(speakup_tty);

	mutex_unlock(&speakup_tty_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
53
100.00%
3
100.00%
Total
53
100.00%
3
100.00%



int spk_ttyio_synth_probe(struct spk_synth *synth)
{
	int rv = spk_ttyio_initialise_ldisc(synth);

	if (rv)
		return rv;

	synth->alive = 1;
	spk_ttyio_synth = synth;

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
38
100.00%
2
100.00%
Total
38
100.00%
2
100.00%

EXPORT_SYMBOL_GPL(spk_ttyio_synth_probe);



void spk_ttyio_release(void)
{
	if (!speakup_tty)
		return;

	tty_lock(speakup_tty);

	if (speakup_tty->ops->close)
		speakup_tty->ops->close(speakup_tty, NULL);

	tty_ldisc_flush(speakup_tty);
	tty_unlock(speakup_tty);
	tty_kclose(speakup_tty);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
52
100.00%
2
100.00%
Total
52
100.00%
2
100.00%

EXPORT_SYMBOL_GPL(spk_ttyio_release);



const char *spk_ttyio_synth_immediate(struct spk_synth *synth, const char *buff)
{
	u_char ch;

	while ((ch = *buff)) {
		if (ch == '\n')
			ch = synth->procspeech;
		if (tty_write_room(speakup_tty) < 1 || !synth->io_ops->synth_out(synth, ch))
			return buff;
		buff++;
	}
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
73
100.00%
1
100.00%
Total
73
100.00%
1
100.00%

EXPORT_SYMBOL_GPL(spk_ttyio_synth_immediate);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Okash Khawaja
1420
90.50%
10
66.67%
Samuel Thibault
144
9.18%
1
6.67%
Mihaela Muraru
2
0.13%
1
6.67%
Colin Ian King
1
0.06%
1
6.67%
Dan Carpenter
1
0.06%
1
6.67%
Greg Kroah-Hartman
1
0.06%
1
6.67%
Total
1569
100.00%
15
100.00%
Directory: drivers/staging/speakup

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.