Quelle  spk_ttyio.c   Sprache: 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 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 size_t spk_ttyio_receive_buf2(struct tty_struct *tty, const u8 *cp,
         const u8 *fp, size_t count)
{
 struct spk_ldisc_data *ldisc_data = tty->disc_data;
 struct spk_synth *synth = ldisc_data->synth;

 if (synth->read_buff_add) {
  unsigned 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;

 if (tty == NULL)
  return;

 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);