drivers/accessibility/speakup/spk_ttyio.c

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