578 lines · c
1// SPDX-License-Identifier: GPL-2.02#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, and30 * must be taken at each kernel->speakup transition and released at31 * each corresponding speakup->kernel transition.32 *33 * The progression thread only interferes with the speakup machinery34 * through the synth buffer, so only needs to take the lock35 * while tinkering with the buffer.36 *37 * We use spin_lock/trylock_irqsave and spin_unlock_irqrestore with this38 * 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 buffer49 * and push to the serial port, waiting as needed50 *51 * For devices that have a "full" notification mechanism, the driver can52 * 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 else99 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 else114 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 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 character224 * in *want.225 */226s32 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 279void 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 305void 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}319EXPORT_SYMBOL_GPL(synth_printf);320 321void synth_putwc(u16 wc)322{323 synth_buffer_add(wc);324}325EXPORT_SYMBOL_GPL(synth_putwc);326 327void synth_putwc_s(u16 wc)328{329 synth_buffer_add(wc);330 synth_start();331}332EXPORT_SYMBOL_GPL(synth_putwc_s);333 334void synth_putws(const u16 *buf)335{336 const u16 *p;337 338 for (p = buf; *p; p++)339 synth_buffer_add(*p);340}341EXPORT_SYMBOL_GPL(synth_putws);342 343void synth_putws_s(const u16 *buf)344{345 synth_putws(buf);346 synth_start();347}348EXPORT_SYMBOL_GPL(synth_putws_s);349 350static int index_count;351static int sentence_count;352 353void spk_reset_index_count(int sc)354{355 static int first = 1;356 357 if (first)358 first = 0;359 else360 synth->get_index(synth);361 index_count = 0;362 sentence_count = sc;363}364 365int synth_supports_indexing(void)366{367 if (synth->get_index)368 return 1;369 return 0;370}371 372void 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 391void 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 else401 index_count = synth->indexing.currindex402 - synth->indexing.lowindex403 + synth->indexing.highindex - (ind / 10) + 1;404 }405 *sentcount = sentence_count;406 *linecount = index_count;407}408 409static struct resource synth_res;410 411int 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}422EXPORT_SYMBOL_GPL(synth_request_region);423 424int synth_release_region(unsigned long start, unsigned long n)425{426 return release_resource(&synth_res);427}428EXPORT_SYMBOL_GPL(synth_release_region);429 430struct 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_VAR437};438 439/* called by: speakup_init() */440int 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 else466 ret = -ENODEV;467 mutex_unlock(&spk_mutex);468 469 return ret;470}471 472/* called by: synth_add() */473static 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 514void 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() */535int 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}558EXPORT_SYMBOL_GPL(synth_add);559 560void 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}569EXPORT_SYMBOL_GPL(synth_remove);570 571struct spk_synth *synth_current(void)572{573 return synth;574}575EXPORT_SYMBOL_GPL(synth_current);576 577short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC | B_SYM };578