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 while (count--) 214 synth_buffer_add(*buf++); 215 synth_start(); 216 } 217 218 void 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 } 235 EXPORT_SYMBOL_GPL(synth_printf); 236 237 void synth_putwc(u16 wc) 238 { 239 synth_buffer_add(wc); 240 } 241 EXPORT_SYMBOL_GPL(synth_putwc); 242 243 void synth_putwc_s(u16 wc) 244 { 245 synth_buffer_add(wc); 246 synth_start(); 247 } 248 EXPORT_SYMBOL_GPL(synth_putwc_s); 249 250 void synth_putws(const u16 *buf) 251 { 252 const u16 *p; 253 254 for (p = buf; *p; p++) 255 synth_buffer_add(*p); 256 } 257 EXPORT_SYMBOL_GPL(synth_putws); 258 259 void synth_putws_s(const u16 *buf) 260 { 261 synth_putws(buf); 262 synth_start(); 263 } 264 EXPORT_SYMBOL_GPL(synth_putws_s); 265 266 static int index_count; 267 static int sentence_count; 268 269 void 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 281 int synth_supports_indexing(void) 282 { 283 if (synth->get_index) 284 return 1; 285 return 0; 286 } 287 288 void 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 307 void 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 325 static struct resource synth_res; 326 327 int 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 } 338 EXPORT_SYMBOL_GPL(synth_request_region); 339 340 int synth_release_region(unsigned long start, unsigned long n) 341 { 342 return release_resource(&synth_res); 343 } 344 EXPORT_SYMBOL_GPL(synth_release_region); 345 346 struct 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() */ 356 int 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() */ 389 static 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 430 void 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() */ 451 int 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 } 474 EXPORT_SYMBOL_GPL(synth_add); 475 476 void 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 } 485 EXPORT_SYMBOL_GPL(synth_remove); 486 487 struct spk_synth *synth_current(void) 488 { 489 return synth; 490 } 491 EXPORT_SYMBOL_GPL(synth_current); 492 493 short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC | B_SYM }; 494