linux/drivers/accessibility/speakup/synth.c
<<
>>
Prefs
   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
  21static LIST_HEAD(synths);
  22struct spk_synth *synth;
  23char spk_pitch_buff[32] = "";
  24static int module_status;
  25bool spk_quiet_boot;
  26
  27struct 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};
  43EXPORT_SYMBOL_GPL(speakup_info);
  44
  45static 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 */
  54static 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
 126void spk_do_catch_up(struct spk_synth *synth)
 127{
 128        _spk_do_catch_up(synth, 0);
 129}
 130EXPORT_SYMBOL_GPL(spk_do_catch_up);
 131
 132void spk_do_catch_up_unicode(struct spk_synth *synth)
 133{
 134        _spk_do_catch_up(synth, 1);
 135}
 136EXPORT_SYMBOL_GPL(spk_do_catch_up_unicode);
 137
 138void 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}
 143EXPORT_SYMBOL_GPL(spk_synth_flush);
 144
 145unsigned char spk_synth_get_index(struct spk_synth *synth)
 146{
 147        return synth->io_ops->synth_in_nowait(synth);
 148}
 149EXPORT_SYMBOL_GPL(spk_synth_get_index);
 150
 151int spk_synth_is_alive_nop(struct spk_synth *synth)
 152{
 153        synth->alive = 1;
 154        return 1;
 155}
 156EXPORT_SYMBOL_GPL(spk_synth_is_alive_nop);
 157
 158int 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}
 171EXPORT_SYMBOL_GPL(spk_synth_is_alive_restart);
 172
 173static void thread_wake_up(struct timer_list *unused)
 174{
 175        wake_up_interruptible_all(&speakup_event);
 176}
 177
 178static DEFINE_TIMER(thread_timer, thread_wake_up);
 179
 180void 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
 194void 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
 211void synth_write(const char *buf, size_t count)
 212{
 213        while (count--)
 214                synth_buffer_add(*buf++);
 215        synth_start();
 216}
 217
 218void synth_printf(const char *fmt, ...)
 219{
 220        va_list args;
 221        unsigned char buf[160], *p;
 222        int r;
 223
 224        va_start(args, fmt);
 225        r = vsnprintf(buf, sizeof(buf), fmt, args);
 226        va_end(args);
 227        if (r > sizeof(buf) - 1)
 228                r = sizeof(buf) - 1;
 229
 230        p = buf;
 231        while (r--)
 232                synth_buffer_add(*p++);
 233        synth_start();
 234}
 235EXPORT_SYMBOL_GPL(synth_printf);
 236
 237void synth_putwc(u16 wc)
 238{
 239        synth_buffer_add(wc);
 240}
 241EXPORT_SYMBOL_GPL(synth_putwc);
 242
 243void synth_putwc_s(u16 wc)
 244{
 245        synth_buffer_add(wc);
 246        synth_start();
 247}
 248EXPORT_SYMBOL_GPL(synth_putwc_s);
 249
 250void synth_putws(const u16 *buf)
 251{
 252        const u16 *p;
 253
 254        for (p = buf; *p; p++)
 255                synth_buffer_add(*p);
 256}
 257EXPORT_SYMBOL_GPL(synth_putws);
 258
 259void synth_putws_s(const u16 *buf)
 260{
 261        synth_putws(buf);
 262        synth_start();
 263}
 264EXPORT_SYMBOL_GPL(synth_putws_s);
 265
 266static int index_count;
 267static int sentence_count;
 268
 269void spk_reset_index_count(int sc)
 270{
 271        static int first = 1;
 272
 273        if (first)
 274                first = 0;
 275        else
 276                synth->get_index(synth);
 277        index_count = 0;
 278        sentence_count = sc;
 279}
 280
 281int synth_supports_indexing(void)
 282{
 283        if (synth->get_index)
 284                return 1;
 285        return 0;
 286}
 287
 288void synth_insert_next_index(int sent_num)
 289{
 290        int out;
 291
 292        if (synth->alive) {
 293                if (sent_num == 0) {
 294                        synth->indexing.currindex++;
 295                        index_count++;
 296                        if (synth->indexing.currindex >
 297                                        synth->indexing.highindex)
 298                                synth->indexing.currindex =
 299                                        synth->indexing.lowindex;
 300                }
 301
 302                out = synth->indexing.currindex * 10 + sent_num;
 303                synth_printf(synth->indexing.command, out, out);
 304        }
 305}
 306
 307void spk_get_index_count(int *linecount, int *sentcount)
 308{
 309        int ind = synth->get_index(synth);
 310
 311        if (ind) {
 312                sentence_count = ind % 10;
 313
 314                if ((ind / 10) <= synth->indexing.currindex)
 315                        index_count = synth->indexing.currindex - (ind / 10);
 316                else
 317                        index_count = synth->indexing.currindex
 318                                - synth->indexing.lowindex
 319                                + synth->indexing.highindex - (ind / 10) + 1;
 320        }
 321        *sentcount = sentence_count;
 322        *linecount = index_count;
 323}
 324
 325static struct resource synth_res;
 326
 327int synth_request_region(unsigned long start, unsigned long n)
 328{
 329        struct resource *parent = &ioport_resource;
 330
 331        memset(&synth_res, 0, sizeof(synth_res));
 332        synth_res.name = synth->name;
 333        synth_res.start = start;
 334        synth_res.end = start + n - 1;
 335        synth_res.flags = IORESOURCE_BUSY;
 336        return request_resource(parent, &synth_res);
 337}
 338EXPORT_SYMBOL_GPL(synth_request_region);
 339
 340int synth_release_region(unsigned long start, unsigned long n)
 341{
 342        return release_resource(&synth_res);
 343}
 344EXPORT_SYMBOL_GPL(synth_release_region);
 345
 346struct var_t synth_time_vars[] = {
 347        { DELAY, .u.n = {NULL, 100, 100, 2000, 0, 0, NULL } },
 348        { TRIGGER, .u.n = {NULL, 20, 10, 2000, 0, 0, NULL } },
 349        { JIFFY, .u.n = {NULL, 50, 20, 200, 0, 0, NULL } },
 350        { FULL, .u.n = {NULL, 400, 200, 60000, 0, 0, NULL } },
 351        { FLUSH, .u.n = {NULL, 4000, 10, 4000, 0, 0, NULL } },
 352        V_LAST_VAR
 353};
 354
 355/* called by: speakup_init() */
 356int synth_init(char *synth_name)
 357{
 358        int ret = 0;
 359        struct spk_synth *tmp, *synth = NULL;
 360
 361        if (!synth_name)
 362                return 0;
 363
 364        if (strcmp(synth_name, "none") == 0) {
 365                mutex_lock(&spk_mutex);
 366                synth_release();
 367                mutex_unlock(&spk_mutex);
 368                return 0;
 369        }
 370
 371        mutex_lock(&spk_mutex);
 372        /* First, check if we already have it loaded. */
 373        list_for_each_entry(tmp, &synths, node) {
 374                if (strcmp(tmp->name, synth_name) == 0)
 375                        synth = tmp;
 376        }
 377
 378        /* If we got one, initialize it now. */
 379        if (synth)
 380                ret = do_synth_init(synth);
 381        else
 382                ret = -ENODEV;
 383        mutex_unlock(&spk_mutex);
 384
 385        return ret;
 386}
 387
 388/* called by: synth_add() */
 389static int do_synth_init(struct spk_synth *in_synth)
 390{
 391        struct var_t *var;
 392
 393        synth_release();
 394        if (in_synth->checkval != SYNTH_CHECK)
 395                return -EINVAL;
 396        synth = in_synth;
 397        synth->alive = 0;
 398        pr_warn("synth probe\n");
 399        if (synth->probe(synth) < 0) {
 400                pr_warn("%s: device probe failed\n", in_synth->name);
 401                synth = NULL;
 402                return -ENODEV;
 403        }
 404        synth_time_vars[0].u.n.value =
 405                synth_time_vars[0].u.n.default_val = synth->delay;
 406        synth_time_vars[1].u.n.value =
 407                synth_time_vars[1].u.n.default_val = synth->trigger;
 408        synth_time_vars[2].u.n.value =
 409                synth_time_vars[2].u.n.default_val = synth->jiffies;
 410        synth_time_vars[3].u.n.value =
 411                synth_time_vars[3].u.n.default_val = synth->full;
 412        synth_time_vars[4].u.n.value =
 413                synth_time_vars[4].u.n.default_val = synth->flush_time;
 414        synth_printf("%s", synth->init);
 415        for (var = synth->vars;
 416                (var->var_id >= 0) && (var->var_id < MAXVARS); var++)
 417                speakup_register_var(var);
 418        if (!spk_quiet_boot)
 419                synth_printf("%s found\n", synth->long_name);
 420        if (synth->attributes.name &&
 421            sysfs_create_group(speakup_kobj, &synth->attributes) < 0)
 422                return -ENOMEM;
 423        synth_flags = synth->flags;
 424        wake_up_interruptible_all(&speakup_event);
 425        if (speakup_task)
 426                wake_up_process(speakup_task);
 427        return 0;
 428}
 429
 430void synth_release(void)
 431{
 432        struct var_t *var;
 433        unsigned long flags;
 434
 435        if (!synth)
 436                return;
 437        spin_lock_irqsave(&speakup_info.spinlock, flags);
 438        pr_info("releasing synth %s\n", synth->name);
 439        synth->alive = 0;
 440        del_timer(&thread_timer);
 441        spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 442        if (synth->attributes.name)
 443                sysfs_remove_group(speakup_kobj, &synth->attributes);
 444        for (var = synth->vars; var->var_id != MAXVARS; var++)
 445                speakup_unregister_var(var->var_id);
 446        synth->release(synth);
 447        synth = NULL;
 448}
 449
 450/* called by: all_driver_init() */
 451int synth_add(struct spk_synth *in_synth)
 452{
 453        int status = 0;
 454        struct spk_synth *tmp;
 455
 456        mutex_lock(&spk_mutex);
 457
 458        list_for_each_entry(tmp, &synths, node) {
 459                if (tmp == in_synth) {
 460                        mutex_unlock(&spk_mutex);
 461                        return 0;
 462                }
 463        }
 464
 465        if (in_synth->startup)
 466                status = do_synth_init(in_synth);
 467
 468        if (!status)
 469                list_add_tail(&in_synth->node, &synths);
 470
 471        mutex_unlock(&spk_mutex);
 472        return status;
 473}
 474EXPORT_SYMBOL_GPL(synth_add);
 475
 476void synth_remove(struct spk_synth *in_synth)
 477{
 478        mutex_lock(&spk_mutex);
 479        if (synth == in_synth)
 480                synth_release();
 481        list_del(&in_synth->node);
 482        module_status = 0;
 483        mutex_unlock(&spk_mutex);
 484}
 485EXPORT_SYMBOL_GPL(synth_remove);
 486
 487struct spk_synth *synth_current(void)
 488{
 489        return synth;
 490}
 491EXPORT_SYMBOL_GPL(synth_current);
 492
 493short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC | B_SYM };
 494