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 */ _spk_do_catch_up(struct spk_synth * synth,int unicode)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 spk_do_catch_up(struct spk_synth * synth)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 spk_do_catch_up_unicode(struct spk_synth * synth)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 spk_synth_flush(struct spk_synth * synth)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 spk_synth_get_index(struct spk_synth * synth)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 spk_synth_is_alive_nop(struct spk_synth * synth)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 spk_synth_is_alive_restart(struct spk_synth * synth)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 thread_wake_up(struct timer_list * unused)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 synth_start(void)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 spk_do_flush(void)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 synth_write(const char * _buf,size_t count)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 */ synth_utf8_get(const char * buf,size_t count,size_t * consumed,size_t * want)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 synth_writeu(const char * buf,size_t count)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 synth_printf(const char * fmt,...)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 synth_putwc(u16 wc)321 void synth_putwc(u16 wc) 322 { 323 synth_buffer_add(wc); 324 } 325 EXPORT_SYMBOL_GPL(synth_putwc); 326 synth_putwc_s(u16 wc)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 synth_putws(const u16 * buf)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 synth_putws_s(const u16 * buf)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 spk_reset_index_count(int sc)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 synth_supports_indexing(void)365 int synth_supports_indexing(void) 366 { 367 if (synth->get_index) 368 return 1; 369 return 0; 370 } 371 synth_insert_next_index(int sent_num)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 spk_get_index_count(int * linecount,int * sentcount)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 synth_request_region(unsigned long start,unsigned long n)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 synth_release_region(unsigned long start,unsigned long n)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() */ synth_init(char * synth_name)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() */ do_synth_init(struct spk_synth * in_synth)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 synth_release(void)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() */ synth_add(struct spk_synth * in_synth)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 synth_remove(struct spk_synth * in_synth)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 synth_current(void)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 }; 578