drivers/accessibility/speakup/synth.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/types.h>
   3 #include <linux/ctype.h>        /* for isdigit() and friends */
   4 #include <linux/fs.h>
   5 #include <linux/mm.h>           /* for verify_area */
   6 #include <linux/errno.h>        /* for -EBUSY */
   7 #include <linux/ioport.h>       /* for check_region, request_region */
   8 #include <linux/interrupt.h>
   9 #include <linux/delay.h>        /* for loops_per_sec */
  10 #include <linux/kmod.h>
  11 #include <linux/jiffies.h>
  12 #include <linux/uaccess.h>      /* for copy_from_user */
  13 #include <linux/sched.h>
  14 #include <linux/timer.h>
  15 #include <linux/kthread.h>
  16
  17 #include "spk_priv.h"
  18 #include "speakup.h"
  19 #include "serialio.h"
  20
  21 static LIST_HEAD(synths);
  22 struct spk_synth *synth;
  23 char spk_pitch_buff[32] = "";
  24 static int module_status;
  25 bool spk_quiet_boot;
  26
  27 struct speakup_info_t speakup_info = {
  28         /*
  29          * This spinlock is used to protect the entire speakup machinery, and
  30          * must be taken at each kernel->speakup transition and released at
  31          * each corresponding speakup->kernel transition.
  32          *
  33          * The progression thread only interferes with the speakup machinery
  34          * through the synth buffer, so only needs to take the lock
  35          * while tinkering with the buffer.
  36          *
  37          * We use spin_lock/trylock_irqsave and spin_unlock_irqrestore with this
  38          * spinlock because speakup needs to disable the keyboard IRQ.
  39          */
  40         .spinlock = __SPIN_LOCK_UNLOCKED(speakup_info.spinlock),
  41         .flushing = 0,
  42 };
  43 EXPORT_SYMBOL_GPL(speakup_info);
  44
  45 static int do_synth_init(struct spk_synth *in_synth);
  46
  47 /*
  48  * Main loop of the progression thread: keep eating from the buffer
  49  * and push to the serial port, waiting as needed
  50  *
  51  * For devices that have a "full" notification mechanism, the driver can
  52  * adapt the loop the way they prefer.
  53  */
  54 static void _spk_do_catch_up(struct spk_synth *synth, int unicode)
  55 {
  56         u16 ch;
  57         unsigned long flags;
  58         unsigned long jiff_max;
  59         struct var_t *delay_time;
  60         struct var_t *full_time;
  61         struct var_t *jiffy_delta;
  62         int jiffy_delta_val;
  63         int delay_time_val;
  64         int full_time_val;
  65         int ret;
  66
  67         jiffy_delta = spk_get_var(JIFFY);
  68         full_time = spk_get_var(FULL);
  69         delay_time = spk_get_var(DELAY);
  70
  71         spin_lock_irqsave(&speakup_info.spinlock, flags);
  72         jiffy_delta_val = jiffy_delta->u.n.value;
  73         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  74
  75         jiff_max = jiffies + jiffy_delta_val;
  76         while (!kthread_should_stop()) {
  77                 spin_lock_irqsave(&speakup_info.spinlock, flags);
  78                 if (speakup_info.flushing) {
  79                         speakup_info.flushing = 0;
  80                         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  81                         synth->flush(synth);
  82                         continue;
  83                 }
  84                 if (!unicode)
  85                         synth_buffer_skip_nonlatin1();
  86                 if (synth_buffer_empty()) {
  87                         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  88                         break;
  89                 }
  90                 ch = synth_buffer_peek();
  91                 set_current_state(TASK_INTERRUPTIBLE);
  92                 full_time_val = full_time->u.n.value;
  93                 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  94                 if (ch == '\n')
  95                         ch = synth->procspeech;
  96                 if (unicode)
  97                         ret = synth->io_ops->synth_out_unicode(synth, ch);
  98                 else
  99                         ret = synth->io_ops->synth_out(synth, ch);
 100                 if (!ret) {
 101                         schedule_timeout(msecs_to_jiffies(full_time_val));
 102                         continue;
 103                 }
 104                 if (time_after_eq(jiffies, jiff_max) && (ch == SPACE)) {
 105                         spin_lock_irqsave(&speakup_info.spinlock, flags);
 106                         jiffy_delta_val = jiffy_delta->u.n.value;
 107                         delay_time_val = delay_time->u.n.value;
 108                         full_time_val = full_time->u.n.value;
 109                         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 110                         if (synth->io_ops->synth_out(synth, synth->procspeech))
 111                                 schedule_timeout(
 112                                         msecs_to_jiffies(delay_time_val));
 113                         else
 114                                 schedule_timeout(
 115                                         msecs_to_jiffies(full_time_val));
 116                         jiff_max = jiffies + jiffy_delta_val;
 117                 }
 118                 set_current_state(TASK_RUNNING);
 119                 spin_lock_irqsave(&speakup_info.spinlock, flags);
 120                 synth_buffer_getc();
 121                 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 122         }
 123         synth->io_ops->synth_out(synth, synth->procspeech);
 124 }
 125
 126 void spk_do_catch_up(struct spk_synth *synth)
 127 {
 128         _spk_do_catch_up(synth, 0);
 129 }
 130 EXPORT_SYMBOL_GPL(spk_do_catch_up);
 131
 132 void spk_do_catch_up_unicode(struct spk_synth *synth)
 133 {
 134         _spk_do_catch_up(synth, 1);
 135 }
 136 EXPORT_SYMBOL_GPL(spk_do_catch_up_unicode);
 137
 138 void spk_synth_flush(struct spk_synth *synth)
 139 {
 140         synth->io_ops->flush_buffer(synth);
 141         synth->io_ops->synth_out(synth, synth->clear);
 142 }
 143 EXPORT_SYMBOL_GPL(spk_synth_flush);
 144
 145 unsigned char spk_synth_get_index(struct spk_synth *synth)
 146 {
 147         return synth->io_ops->synth_in_nowait(synth);
 148 }
 149 EXPORT_SYMBOL_GPL(spk_synth_get_index);
 150
 151 int spk_synth_is_alive_nop(struct spk_synth *synth)
 152 {
 153         synth->alive = 1;
 154         return 1;
 155 }
 156 EXPORT_SYMBOL_GPL(spk_synth_is_alive_nop);
 157
 158 int spk_synth_is_alive_restart(struct spk_synth *synth)
 159 {
 160         if (synth->alive)
 161                 return 1;
 162         if (synth->io_ops->wait_for_xmitr(synth) > 0) {
 163                 /* restart */
 164                 synth->alive = 1;
 165                 synth_printf("%s", synth->init);
 166                 return 2; /* reenabled */
 167         }
 168         pr_warn("%s: can't restart synth\n", synth->long_name);
 169         return 0;
 170 }
 171 EXPORT_SYMBOL_GPL(spk_synth_is_alive_restart);
 172
 173 static void thread_wake_up(struct timer_list *unused)
 174 {
 175         wake_up_interruptible_all(&speakup_event);
 176 }
 177
 178 static DEFINE_TIMER(thread_timer, thread_wake_up);
 179
 180 void synth_start(void)
 181 {
 182         struct var_t *trigger_time;
 183
 184         if (!synth->alive) {
 185                 synth_buffer_clear();
 186                 return;
 187         }
 188         trigger_time = spk_get_var(TRIGGER);
 189         if (!timer_pending(&thread_timer))
 190                 mod_timer(&thread_timer, jiffies +
 191                         msecs_to_jiffies(trigger_time->u.n.value));
 192 }
 193
 194 void spk_do_flush(void)
 195 {
 196         if (!synth)
 197                 return;
 198
 199         speakup_info.flushing = 1;
 200         synth_buffer_clear();
 201         if (synth->alive) {
 202                 if (spk_pitch_shift) {
 203                         synth_printf("%s", spk_pitch_buff);
 204                         spk_pitch_shift = 0;
 205                 }
 206         }
 207         wake_up_interruptible_all(&speakup_event);
 208         wake_up_process(speakup_task);
 209 }
 210
 211 void synth_write(const char *_buf, size_t count)
 212 {
 213         const unsigned char *buf = (const unsigned char *) _buf;
 214
 215         while (count--)
 216                 synth_buffer_add(*buf++);
 217         synth_start();
 218 }
 219
 220 /* Consume one utf-8 character from buf (that contains up to count bytes),
 221  * returns the unicode codepoint if valid, -1 otherwise.
 222  * In all cases, returns the number of consumed bytes in *consumed,
 223  * and the minimum number of bytes that would be needed for the next character
 224  * in *want.
 225  */
 226 s32 synth_utf8_get(const char *buf, size_t count, size_t *consumed, size_t *want)
 227 {
 228         unsigned char c = buf[0];
 229         int nbytes = 8 - fls(c ^ 0xff);
 230         u32 value;
 231         size_t i;
 232
 233         switch (nbytes) {
 234         case 8: /* 0xff */
 235         case 7: /* 0xfe */
 236         case 1: /* 0x80 */
 237                 /* Invalid, drop */
 238                 *consumed = 1;
 239                 *want = 1;
 240                 return -1;
 241
 242         case 0:
 243                 /* ASCII, take as such */
 244                 *consumed = 1;
 245                 *want = 1;
 246                 return c;
 247
 248         default:
 249                 /* 2..6-byte UTF-8 */
 250
 251                 if (count < nbytes) {
 252                         /* We don't have it all */
 253                         *consumed = 0;
 254                         *want = nbytes;
 255                         return -1;
 256                 }
 257
 258                 /* First byte */
 259                 value = c & ((1u << (7 - nbytes)) - 1);
 260
 261                 /* Other bytes */
 262                 for (i = 1; i < nbytes; i++) {
 263                         c = buf[i];
 264                         if ((c & 0xc0) != 0x80) {
 265                                 /* Invalid, drop the head */
 266                                 *consumed = i;
 267                                 *want = 1;
 268                                 return -1;
 269                         }
 270                         value = (value << 6) | (c & 0x3f);
 271                 }
 272
 273                 *consumed = nbytes;
 274                 *want = 1;
 275                 return value;
 276         }
 277 }
 278
 279 void synth_writeu(const char *buf, size_t count)
 280 {
 281         size_t i, consumed, want;
 282
 283         /* Convert to u16 */
 284         for (i = 0; i < count; i++) {
 285                 s32 value;
 286
 287                 value = synth_utf8_get(buf + i, count - i, &consumed, &want);
 288                 if (value == -1) {
 289                         /* Invalid or incomplete */
 290
 291                         if (want > count - i)
 292                                 /* We don't have it all, stop */
 293                                 count = i;
 294
 295                         continue;
 296                 }
 297
 298                 if (value < 0x10000)
 299                         synth_buffer_add(value);
 300         }
 301
 302         synth_start();
 303 }
 304
 305 void synth_printf(const char *fmt, ...)
 306 {
 307         va_list args;
 308         unsigned char buf[160];
 309         int r;
 310
 311         va_start(args, fmt);
 312         r = vsnprintf(buf, sizeof(buf), fmt, args);
 313         va_end(args);
 314         if (r > sizeof(buf) - 1)
 315                 r = sizeof(buf) - 1;
 316
 317         synth_writeu(buf, r);
 318 }
 319 EXPORT_SYMBOL_GPL(synth_printf);
 320
 321 void synth_putwc(u16 wc)
 322 {
 323         synth_buffer_add(wc);
 324 }
 325 EXPORT_SYMBOL_GPL(synth_putwc);
 326
 327 void synth_putwc_s(u16 wc)
 328 {
 329         synth_buffer_add(wc);
 330         synth_start();
 331 }
 332 EXPORT_SYMBOL_GPL(synth_putwc_s);
 333
 334 void synth_putws(const u16 *buf)
 335 {
 336         const u16 *p;
 337
 338         for (p = buf; *p; p++)
 339                 synth_buffer_add(*p);
 340 }
 341 EXPORT_SYMBOL_GPL(synth_putws);
 342
 343 void synth_putws_s(const u16 *buf)
 344 {
 345         synth_putws(buf);
 346         synth_start();
 347 }
 348 EXPORT_SYMBOL_GPL(synth_putws_s);
 349
 350 static int index_count;
 351 static int sentence_count;
 352
 353 void spk_reset_index_count(int sc)
 354 {
 355         static int first = 1;
 356
 357         if (first)
 358                 first = 0;
 359         else
 360                 synth->get_index(synth);
 361         index_count = 0;
 362         sentence_count = sc;
 363 }
 364
 365 int synth_supports_indexing(void)
 366 {
 367         if (synth->get_index)
 368                 return 1;
 369         return 0;
 370 }
 371
 372 void synth_insert_next_index(int sent_num)
 373 {
 374         int out;
 375
 376         if (synth->alive) {
 377                 if (sent_num == 0) {
 378                         synth->indexing.currindex++;
 379                         index_count++;
 380                         if (synth->indexing.currindex >
 381                                         synth->indexing.highindex)
 382                                 synth->indexing.currindex =
 383                                         synth->indexing.lowindex;
 384                 }
 385
 386                 out = synth->indexing.currindex * 10 + sent_num;
 387                 synth_printf(synth->indexing.command, out, out);
 388         }
 389 }
 390
 391 void spk_get_index_count(int *linecount, int *sentcount)
 392 {
 393         int ind = synth->get_index(synth);
 394
 395         if (ind) {
 396                 sentence_count = ind % 10;
 397
 398                 if ((ind / 10) <= synth->indexing.currindex)
 399                         index_count = synth->indexing.currindex - (ind / 10);
 400                 else
 401                         index_count = synth->indexing.currindex
 402                                 - synth->indexing.lowindex
 403                                 + synth->indexing.highindex - (ind / 10) + 1;
 404         }
 405         *sentcount = sentence_count;
 406         *linecount = index_count;
 407 }
 408
 409 static struct resource synth_res;
 410
 411 int synth_request_region(unsigned long start, unsigned long n)
 412 {
 413         struct resource *parent = &ioport_resource;
 414
 415         memset(&synth_res, 0, sizeof(synth_res));
 416         synth_res.name = synth->name;
 417         synth_res.start = start;
 418         synth_res.end = start + n - 1;
 419         synth_res.flags = IORESOURCE_BUSY;
 420         return request_resource(parent, &synth_res);
 421 }
 422 EXPORT_SYMBOL_GPL(synth_request_region);
 423
 424 int synth_release_region(unsigned long start, unsigned long n)
 425 {
 426         return release_resource(&synth_res);
 427 }
 428 EXPORT_SYMBOL_GPL(synth_release_region);
 429
 430 struct var_t synth_time_vars[] = {
 431         { DELAY, .u.n = {NULL, 100, 100, 2000, 0, 0, NULL } },
 432         { TRIGGER, .u.n = {NULL, 20, 10, 2000, 0, 0, NULL } },
 433         { JIFFY, .u.n = {NULL, 50, 20, 200, 0, 0, NULL } },
 434         { FULL, .u.n = {NULL, 400, 200, 60000, 0, 0, NULL } },
 435         { FLUSH, .u.n = {NULL, 4000, 10, 4000, 0, 0, NULL } },
 436         V_LAST_VAR
 437 };
 438
 439 /* called by: speakup_init() */
 440 int synth_init(char *synth_name)
 441 {
 442         int ret = 0;
 443         struct spk_synth *tmp, *synth = NULL;
 444
 445         if (!synth_name)
 446                 return 0;
 447
 448         if (strcmp(synth_name, "none") == 0) {
 449                 mutex_lock(&spk_mutex);
 450                 synth_release();
 451                 mutex_unlock(&spk_mutex);
 452                 return 0;
 453         }
 454
 455         mutex_lock(&spk_mutex);
 456         /* First, check if we already have it loaded. */
 457         list_for_each_entry(tmp, &synths, node) {
 458                 if (strcmp(tmp->name, synth_name) == 0)
 459                         synth = tmp;
 460         }
 461
 462         /* If we got one, initialize it now. */
 463         if (synth)
 464                 ret = do_synth_init(synth);
 465         else
 466                 ret = -ENODEV;
 467         mutex_unlock(&spk_mutex);
 468
 469         return ret;
 470 }
 471
 472 /* called by: synth_add() */
 473 static int do_synth_init(struct spk_synth *in_synth)
 474 {
 475         struct var_t *var;
 476
 477         synth_release();
 478         if (in_synth->checkval != SYNTH_CHECK)
 479                 return -EINVAL;
 480         synth = in_synth;
 481         synth->alive = 0;
 482         pr_warn("synth probe\n");
 483         if (synth->probe(synth) < 0) {
 484                 pr_warn("%s: device probe failed\n", in_synth->name);
 485                 synth = NULL;
 486                 return -ENODEV;
 487         }
 488         synth_time_vars[0].u.n.value =
 489                 synth_time_vars[0].u.n.default_val = synth->delay;
 490         synth_time_vars[1].u.n.value =
 491                 synth_time_vars[1].u.n.default_val = synth->trigger;
 492         synth_time_vars[2].u.n.value =
 493                 synth_time_vars[2].u.n.default_val = synth->jiffies;
 494         synth_time_vars[3].u.n.value =
 495                 synth_time_vars[3].u.n.default_val = synth->full;
 496         synth_time_vars[4].u.n.value =
 497                 synth_time_vars[4].u.n.default_val = synth->flush_time;
 498         synth_printf("%s", synth->init);
 499         for (var = synth->vars;
 500                 (var->var_id >= 0) && (var->var_id < MAXVARS); var++)
 501                 speakup_register_var(var);
 502         if (!spk_quiet_boot)
 503                 synth_printf("%s found\n", synth->long_name);
 504         if (synth->attributes.name &&
 505             sysfs_create_group(speakup_kobj, &synth->attributes) < 0)
 506                 return -ENOMEM;
 507         synth_flags = synth->flags;
 508         wake_up_interruptible_all(&speakup_event);
 509         if (speakup_task)
 510                 wake_up_process(speakup_task);
 511         return 0;
 512 }
 513
 514 void synth_release(void)
 515 {
 516         struct var_t *var;
 517         unsigned long flags;
 518
 519         if (!synth)
 520                 return;
 521         spin_lock_irqsave(&speakup_info.spinlock, flags);
 522         pr_info("releasing synth %s\n", synth->name);
 523         synth->alive = 0;
 524         del_timer(&thread_timer);
 525         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 526         if (synth->attributes.name)
 527                 sysfs_remove_group(speakup_kobj, &synth->attributes);
 528         for (var = synth->vars; var->var_id != MAXVARS; var++)
 529                 speakup_unregister_var(var->var_id);
 530         synth->release(synth);
 531         synth = NULL;
 532 }
 533
 534 /* called by: all_driver_init() */
 535 int synth_add(struct spk_synth *in_synth)
 536 {
 537         int status = 0;
 538         struct spk_synth *tmp;
 539
 540         mutex_lock(&spk_mutex);
 541
 542         list_for_each_entry(tmp, &synths, node) {
 543                 if (tmp == in_synth) {
 544                         mutex_unlock(&spk_mutex);
 545                         return 0;
 546                 }
 547         }
 548
 549         if (in_synth->startup)
 550                 status = do_synth_init(in_synth);
 551
 552         if (!status)
 553                 list_add_tail(&in_synth->node, &synths);
 554
 555         mutex_unlock(&spk_mutex);
 556         return status;
 557 }
 558 EXPORT_SYMBOL_GPL(synth_add);
 559
 560 void synth_remove(struct spk_synth *in_synth)
 561 {
 562         mutex_lock(&spk_mutex);
 563         if (synth == in_synth)
 564                 synth_release();
 565         list_del(&in_synth->node);
 566         module_status = 0;
 567         mutex_unlock(&spk_mutex);
 568 }
 569 EXPORT_SYMBOL_GPL(synth_remove);
 570
 571 struct spk_synth *synth_current(void)
 572 {
 573         return synth;
 574 }
 575 EXPORT_SYMBOL_GPL(synth_current);
 576
 577 short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC | B_SYM };