root/drivers/staging/speakup/spk_ttyio.c

DEFINITIONS

1. ser_to_dev
2. get_dev_to_use
3. spk_ttyio_ldisc_open
4. spk_ttyio_ldisc_close
5. spk_ttyio_receive_buf2
6. get_termios
7. spk_ttyio_initialise_ldisc
8. spk_ttyio_register_ldisc
9. spk_ttyio_unregister_ldisc
10. spk_ttyio_out
11. spk_ttyio_out_unicode
12. check_tty
13. spk_ttyio_send_xchar
14. spk_ttyio_tiocmset
15. ttyio_in
16. spk_ttyio_in
17. spk_ttyio_in_nowait
18. spk_ttyio_flush_buffer
19. spk_ttyio_synth_probe
20. spk_ttyio_release
21. spk_ttyio_synth_immediate

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