Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Okash Khawaja | 1140 | 68.43% | 10 | 31.25% |
Samuel Thibault | 482 | 28.93% | 8 | 25.00% |
Johan Hovold | 14 | 0.84% | 1 | 3.12% |
Jiri Slaby | 10 | 0.60% | 4 | 12.50% |
Arnd Bergmann | 9 | 0.54% | 1 | 3.12% |
Sam Muhammed | 2 | 0.12% | 1 | 3.12% |
Maya Nakamura | 2 | 0.12% | 1 | 3.12% |
Mihaela Muraru | 2 | 0.12% | 1 | 3.12% |
Greg Kroah-Hartman | 1 | 0.06% | 1 | 3.12% |
Colin Ian King | 1 | 0.06% | 1 | 3.12% |
Bhagyashri P. Dighole | 1 | 0.06% | 1 | 3.12% |
Dan Carpenter | 1 | 0.06% | 1 | 3.12% |
Uwe Kleine-König | 1 | 0.06% | 1 | 3.12% |
Total | 1666 | 32 |
// 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 completion completion; bool buf_free; struct spk_synth *synth; }; /* * This allows to catch within spk_ttyio_ldisc_open whether it is getting set * on for a speakup-driven device. */ static struct tty_struct *speakup_tty; /* This mutex serializes the use of such global speakup_tty variable */ 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; } 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); } static int spk_ttyio_ldisc_open(struct tty_struct *tty) { struct spk_ldisc_data *ldisc_data; if (tty != speakup_tty) /* Somebody tried to use this line discipline outside speakup */ return -ENODEV; if (!tty->ops->write) return -EOPNOTSUPP; ldisc_data = kmalloc(sizeof(*ldisc_data), GFP_KERNEL); if (!ldisc_data) return -ENOMEM; init_completion(&ldisc_data->completion); ldisc_data->buf_free = true; tty->disc_data = ldisc_data; return 0; } static void spk_ttyio_ldisc_close(struct tty_struct *tty) { kfree(tty->disc_data); } static int spk_ttyio_receive_buf2(struct tty_struct *tty, const unsigned char *cp, const char *fp, int count) { struct spk_ldisc_data *ldisc_data = tty->disc_data; struct spk_synth *synth = ldisc_data->synth; if (synth->read_buff_add) { int i; for (i = 0; i < count; i++) synth->read_buff_add(cp[i]); return count; } if (!ldisc_data->buf_free) /* ttyio_in will tty_flip_buffer_push */ 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; complete(&ldisc_data->completion); return 1; } static struct tty_ldisc_ops spk_ttyio_ldisc_ops = { .owner = THIS_MODULE, .num = N_SPEAKUP, .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(struct spk_synth *in_synth, char ch); static void spk_ttyio_tiocmset(struct spk_synth *in_synth, unsigned int set, unsigned int clear); static unsigned char spk_ttyio_in(struct spk_synth *in_synth); static unsigned char spk_ttyio_in_nowait(struct spk_synth *in_synth); static void spk_ttyio_flush_buffer(struct spk_synth *in_synth); static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth); 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, .wait_for_xmitr = spk_ttyio_wait_for_xmitr, }; 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); } 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_exclusive(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); mutex_lock(&speakup_tty_mutex); speakup_tty = tty; ret = tty_set_ldisc(tty, N_SPEAKUP); speakup_tty = NULL; mutex_unlock(&speakup_tty_mutex); if (!ret) { /* Success */ struct spk_ldisc_data *ldisc_data = tty->disc_data; ldisc_data->synth = synth; synth->dev = tty; return 0; } pr_err("speakup: Failed to set N_SPEAKUP on tty\n"); tty_lock(tty); if (tty->ops->close) tty->ops->close(tty, NULL); tty_unlock(tty); tty_kclose(tty); return ret; } void spk_ttyio_register_ldisc(void) { if (tty_register_ldisc(&spk_ttyio_ldisc_ops)) pr_warn("speakup: Error registering line discipline. Most synths won't work.\n"); } void spk_ttyio_unregister_ldisc(void) { tty_unregister_ldisc(&spk_ttyio_ldisc_ops); } static int spk_ttyio_out(struct spk_synth *in_synth, const char ch) { struct tty_struct *tty = in_synth->dev; int ret; if (!in_synth->alive || !tty->ops->write) return 0; ret = tty->ops->write(tty, &ch, 1); if (ret == 0) /* No room */ return 0; if (ret > 0) /* Success */ return 1; 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; } 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; } static void spk_ttyio_send_xchar(struct spk_synth *in_synth, char ch) { struct tty_struct *tty = in_synth->dev; if (tty->ops->send_xchar) tty->ops->send_xchar(tty, ch); } static void spk_ttyio_tiocmset(struct spk_synth *in_synth, unsigned int set, unsigned int clear) { struct tty_struct *tty = in_synth->dev; if (tty->ops->tiocmset) tty->ops->tiocmset(tty, set, clear); } static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth) { return 1; } static unsigned char ttyio_in(struct spk_synth *in_synth, int timeout) { struct tty_struct *tty = in_synth->dev; struct spk_ldisc_data *ldisc_data = tty->disc_data; char rv; if (!timeout) { if (!try_wait_for_completion(&ldisc_data->completion)) return 0xff; } else if (wait_for_completion_timeout(&ldisc_data->completion, usecs_to_jiffies(timeout)) == 0) { 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_flip_buffer_push(tty->port); return rv; } static unsigned char spk_ttyio_in(struct spk_synth *in_synth) { return ttyio_in(in_synth, SPK_SYNTH_TIMEOUT); } static unsigned char spk_ttyio_in_nowait(struct spk_synth *in_synth) { u8 rv = ttyio_in(in_synth, 0); return (rv == 0xff) ? 0 : rv; } static void spk_ttyio_flush_buffer(struct spk_synth *in_synth) { struct tty_struct *tty = in_synth->dev; if (tty->ops->flush_buffer) tty->ops->flush_buffer(tty); } int spk_ttyio_synth_probe(struct spk_synth *synth) { int rv = spk_ttyio_initialise_ldisc(synth); if (rv) return rv; synth->alive = 1; return 0; } EXPORT_SYMBOL_GPL(spk_ttyio_synth_probe); void spk_ttyio_release(struct spk_synth *in_synth) { struct tty_struct *tty = in_synth->dev; tty_lock(tty); if (tty->ops->close) tty->ops->close(tty, NULL); tty_ldisc_flush(tty); tty_unlock(tty); tty_kclose(tty); in_synth->dev = NULL; } EXPORT_SYMBOL_GPL(spk_ttyio_release); const char *spk_ttyio_synth_immediate(struct spk_synth *in_synth, const char *buff) { struct tty_struct *tty = in_synth->dev; u_char ch; while ((ch = *buff)) { if (ch == '\n') ch = in_synth->procspeech; if (tty_write_room(tty) < 1 || !in_synth->io_ops->synth_out(in_synth, ch)) return buff; buff++; } return NULL; } EXPORT_SYMBOL_GPL(spk_ttyio_synth_immediate);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1