1 #include <linux/types.h>
2 #include <linux/ctype.h> /* for isdigit() and friends */
3 #include <linux/fs.h>
4 #include <linux/mm.h> /* for verify_area */
5 #include <linux/errno.h> /* for -EBUSY */
6 #include <linux/ioport.h> /* for check_region, request_region */
7 #include <linux/interrupt.h>
8 #include <linux/delay.h> /* for loops_per_sec */
9 #include <linux/kmod.h>
10 #include <linux/jiffies.h>
11 #include <linux/uaccess.h> /* for copy_from_user */
12 #include <linux/sched.h>
13 #include <linux/timer.h>
14 #include <linux/kthread.h>
15
16 #include "spk_priv.h"
17 #include "speakup.h"
18 #include "serialio.h"
19
20 #define MAXSYNTHS 16 /* Max number of synths in array. */
21 static struct spk_synth *synths[MAXSYNTHS];
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 through
34 * the synth buffer, so only needs to take the lock while tinkering with
35 * 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
spk_serial_synth_probe(struct spk_synth * synth)47 int spk_serial_synth_probe(struct spk_synth *synth)
48 {
49 const struct old_serial_port *ser;
50 int failed = 0;
51
52 if ((synth->ser >= SPK_LO_TTY) && (synth->ser <= SPK_HI_TTY)) {
53 ser = spk_serial_init(synth->ser);
54 if (ser == NULL) {
55 failed = -1;
56 } else {
57 outb_p(0, ser->port);
58 mdelay(1);
59 outb_p('\r', ser->port);
60 }
61 } else {
62 failed = -1;
63 pr_warn("ttyS%i is an invalid port\n", synth->ser);
64 }
65 if (failed) {
66 pr_info("%s: not found\n", synth->long_name);
67 return -ENODEV;
68 }
69 pr_info("%s: ttyS%i, Driver Version %s\n",
70 synth->long_name, synth->ser, synth->version);
71 synth->alive = 1;
72 return 0;
73 }
74 EXPORT_SYMBOL_GPL(spk_serial_synth_probe);
75
76 /* Main loop of the progression thread: keep eating from the buffer
77 * and push to the serial port, waiting as needed
78 *
79 * For devices that have a "full" notification mechanism, the driver can
80 * adapt the loop the way they prefer.
81 */
spk_do_catch_up(struct spk_synth * synth)82 void spk_do_catch_up(struct spk_synth *synth)
83 {
84 u_char ch;
85 unsigned long flags;
86 unsigned long jiff_max;
87 struct var_t *delay_time;
88 struct var_t *full_time;
89 struct var_t *jiffy_delta;
90 int jiffy_delta_val;
91 int delay_time_val;
92 int full_time_val;
93
94 jiffy_delta = spk_get_var(JIFFY);
95 full_time = spk_get_var(FULL);
96 delay_time = spk_get_var(DELAY);
97
98 spin_lock_irqsave(&speakup_info.spinlock, flags);
99 jiffy_delta_val = jiffy_delta->u.n.value;
100 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
101
102 jiff_max = jiffies + jiffy_delta_val;
103 while (!kthread_should_stop()) {
104 spin_lock_irqsave(&speakup_info.spinlock, flags);
105 if (speakup_info.flushing) {
106 speakup_info.flushing = 0;
107 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
108 synth->flush(synth);
109 continue;
110 }
111 if (synth_buffer_empty()) {
112 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
113 break;
114 }
115 ch = synth_buffer_peek();
116 set_current_state(TASK_INTERRUPTIBLE);
117 full_time_val = full_time->u.n.value;
118 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
119 if (ch == '\n')
120 ch = synth->procspeech;
121 if (!spk_serial_out(ch)) {
122 schedule_timeout(msecs_to_jiffies(full_time_val));
123 continue;
124 }
125 if (time_after_eq(jiffies, jiff_max) && (ch == SPACE)) {
126 spin_lock_irqsave(&speakup_info.spinlock, flags);
127 jiffy_delta_val = jiffy_delta->u.n.value;
128 delay_time_val = delay_time->u.n.value;
129 full_time_val = full_time->u.n.value;
130 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
131 if (spk_serial_out(synth->procspeech))
132 schedule_timeout(
133 msecs_to_jiffies(delay_time_val));
134 else
135 schedule_timeout(
136 msecs_to_jiffies(full_time_val));
137 jiff_max = jiffies + jiffy_delta_val;
138 }
139 set_current_state(TASK_RUNNING);
140 spin_lock_irqsave(&speakup_info.spinlock, flags);
141 synth_buffer_getc();
142 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
143 }
144 spk_serial_out(synth->procspeech);
145 }
146 EXPORT_SYMBOL_GPL(spk_do_catch_up);
147
spk_synth_immediate(struct spk_synth * synth,const char * buff)148 const char *spk_synth_immediate(struct spk_synth *synth, const char *buff)
149 {
150 u_char ch;
151
152 while ((ch = *buff)) {
153 if (ch == '\n')
154 ch = synth->procspeech;
155 if (spk_wait_for_xmitr())
156 outb(ch, speakup_info.port_tts);
157 else
158 return buff;
159 buff++;
160 }
161 return NULL;
162 }
163 EXPORT_SYMBOL_GPL(spk_synth_immediate);
164
spk_synth_flush(struct spk_synth * synth)165 void spk_synth_flush(struct spk_synth *synth)
166 {
167 spk_serial_out(synth->clear);
168 }
169 EXPORT_SYMBOL_GPL(spk_synth_flush);
170
spk_synth_is_alive_nop(struct spk_synth * synth)171 int spk_synth_is_alive_nop(struct spk_synth *synth)
172 {
173 synth->alive = 1;
174 return 1;
175 }
176 EXPORT_SYMBOL_GPL(spk_synth_is_alive_nop);
177
spk_synth_is_alive_restart(struct spk_synth * synth)178 int spk_synth_is_alive_restart(struct spk_synth *synth)
179 {
180 if (synth->alive)
181 return 1;
182 if (!synth->alive && spk_wait_for_xmitr() > 0) {
183 /* restart */
184 synth->alive = 1;
185 synth_printf("%s", synth->init);
186 return 2; /* reenabled */
187 }
188 pr_warn("%s: can't restart synth\n", synth->long_name);
189 return 0;
190 }
191 EXPORT_SYMBOL_GPL(spk_synth_is_alive_restart);
192
thread_wake_up(u_long data)193 static void thread_wake_up(u_long data)
194 {
195 wake_up_interruptible_all(&speakup_event);
196 }
197
198 static DEFINE_TIMER(thread_timer, thread_wake_up, 0, 0);
199
synth_start(void)200 void synth_start(void)
201 {
202 struct var_t *trigger_time;
203
204 if (!synth->alive) {
205 synth_buffer_clear();
206 return;
207 }
208 trigger_time = spk_get_var(TRIGGER);
209 if (!timer_pending(&thread_timer))
210 mod_timer(&thread_timer, jiffies +
211 msecs_to_jiffies(trigger_time->u.n.value));
212 }
213
spk_do_flush(void)214 void spk_do_flush(void)
215 {
216 if (!synth)
217 return;
218
219 speakup_info.flushing = 1;
220 synth_buffer_clear();
221 if (synth->alive) {
222 if (spk_pitch_shift) {
223 synth_printf("%s", spk_pitch_buff);
224 spk_pitch_shift = 0;
225 }
226 }
227 wake_up_interruptible_all(&speakup_event);
228 wake_up_process(speakup_task);
229 }
230
synth_write(const char * buf,size_t count)231 void synth_write(const char *buf, size_t count)
232 {
233 while (count--)
234 synth_buffer_add(*buf++);
235 synth_start();
236 }
237
synth_printf(const char * fmt,...)238 void synth_printf(const char *fmt, ...)
239 {
240 va_list args;
241 unsigned char buf[160], *p;
242 int r;
243
244 va_start(args, fmt);
245 r = vsnprintf(buf, sizeof(buf), fmt, args);
246 va_end(args);
247 if (r > sizeof(buf) - 1)
248 r = sizeof(buf) - 1;
249
250 p = buf;
251 while (r--)
252 synth_buffer_add(*p++);
253 synth_start();
254 }
255 EXPORT_SYMBOL_GPL(synth_printf);
256
257 static int index_count;
258 static int sentence_count;
259
spk_reset_index_count(int sc)260 void spk_reset_index_count(int sc)
261 {
262 static int first = 1;
263
264 if (first)
265 first = 0;
266 else
267 synth->get_index();
268 index_count = 0;
269 sentence_count = sc;
270 }
271
synth_supports_indexing(void)272 int synth_supports_indexing(void)
273 {
274 if (synth->get_index != NULL)
275 return 1;
276 return 0;
277 }
278
synth_insert_next_index(int sent_num)279 void synth_insert_next_index(int sent_num)
280 {
281 int out;
282
283 if (synth->alive) {
284 if (sent_num == 0) {
285 synth->indexing.currindex++;
286 index_count++;
287 if (synth->indexing.currindex >
288 synth->indexing.highindex)
289 synth->indexing.currindex =
290 synth->indexing.lowindex;
291 }
292
293 out = synth->indexing.currindex * 10 + sent_num;
294 synth_printf(synth->indexing.command, out, out);
295 }
296 }
297
spk_get_index_count(int * linecount,int * sentcount)298 void spk_get_index_count(int *linecount, int *sentcount)
299 {
300 int ind = synth->get_index();
301
302 if (ind) {
303 sentence_count = ind % 10;
304
305 if ((ind / 10) <= synth->indexing.currindex)
306 index_count = synth->indexing.currindex-(ind/10);
307 else
308 index_count = synth->indexing.currindex
309 -synth->indexing.lowindex
310 + synth->indexing.highindex-(ind/10)+1;
311
312 }
313 *sentcount = sentence_count;
314 *linecount = index_count;
315 }
316
317 static struct resource synth_res;
318
synth_request_region(unsigned long start,unsigned long n)319 int synth_request_region(unsigned long start, unsigned long n)
320 {
321 struct resource *parent = &ioport_resource;
322
323 memset(&synth_res, 0, sizeof(synth_res));
324 synth_res.name = synth->name;
325 synth_res.start = start;
326 synth_res.end = start + n - 1;
327 synth_res.flags = IORESOURCE_BUSY;
328 return request_resource(parent, &synth_res);
329 }
330 EXPORT_SYMBOL_GPL(synth_request_region);
331
synth_release_region(unsigned long start,unsigned long n)332 int synth_release_region(unsigned long start, unsigned long n)
333 {
334 return release_resource(&synth_res);
335 }
336 EXPORT_SYMBOL_GPL(synth_release_region);
337
338 struct var_t synth_time_vars[] = {
339 { DELAY, .u.n = {NULL, 100, 100, 2000, 0, 0, NULL } },
340 { TRIGGER, .u.n = {NULL, 20, 10, 2000, 0, 0, NULL } },
341 { JIFFY, .u.n = {NULL, 50, 20, 200, 0, 0, NULL } },
342 { FULL, .u.n = {NULL, 400, 200, 60000, 0, 0, NULL } },
343 V_LAST_VAR
344 };
345
346 /* called by: speakup_init() */
synth_init(char * synth_name)347 int synth_init(char *synth_name)
348 {
349 int i;
350 int ret = 0;
351 struct spk_synth *synth = NULL;
352
353 if (synth_name == NULL)
354 return 0;
355
356 if (strcmp(synth_name, "none") == 0) {
357 mutex_lock(&spk_mutex);
358 synth_release();
359 mutex_unlock(&spk_mutex);
360 return 0;
361 }
362
363 mutex_lock(&spk_mutex);
364 /* First, check if we already have it loaded. */
365 for (i = 0; i < MAXSYNTHS && synths[i] != NULL; i++)
366 if (strcmp(synths[i]->name, synth_name) == 0)
367 synth = synths[i];
368
369 /* If we got one, initialize it now. */
370 if (synth)
371 ret = do_synth_init(synth);
372 else
373 ret = -ENODEV;
374 mutex_unlock(&spk_mutex);
375
376 return ret;
377 }
378
379 /* called by: synth_add() */
do_synth_init(struct spk_synth * in_synth)380 static int do_synth_init(struct spk_synth *in_synth)
381 {
382 struct var_t *var;
383
384 synth_release();
385 if (in_synth->checkval != SYNTH_CHECK)
386 return -EINVAL;
387 synth = in_synth;
388 synth->alive = 0;
389 pr_warn("synth probe\n");
390 if (synth->probe(synth) < 0) {
391 pr_warn("%s: device probe failed\n", in_synth->name);
392 synth = NULL;
393 return -ENODEV;
394 }
395 synth_time_vars[0].u.n.value =
396 synth_time_vars[0].u.n.default_val = synth->delay;
397 synth_time_vars[1].u.n.value =
398 synth_time_vars[1].u.n.default_val = synth->trigger;
399 synth_time_vars[2].u.n.value =
400 synth_time_vars[2].u.n.default_val = synth->jiffies;
401 synth_time_vars[3].u.n.value =
402 synth_time_vars[3].u.n.default_val = synth->full;
403 synth_printf("%s", synth->init);
404 for (var = synth->vars;
405 (var->var_id >= 0) && (var->var_id < MAXVARS); var++)
406 speakup_register_var(var);
407 if (!spk_quiet_boot)
408 synth_printf("%s found\n", synth->long_name);
409 if (synth->attributes.name
410 && sysfs_create_group(speakup_kobj, &(synth->attributes)) < 0)
411 return -ENOMEM;
412 synth_flags = synth->flags;
413 wake_up_interruptible_all(&speakup_event);
414 if (speakup_task)
415 wake_up_process(speakup_task);
416 return 0;
417 }
418
synth_release(void)419 void synth_release(void)
420 {
421 struct var_t *var;
422 unsigned long flags;
423
424 if (synth == NULL)
425 return;
426 spin_lock_irqsave(&speakup_info.spinlock, flags);
427 pr_info("releasing synth %s\n", synth->name);
428 synth->alive = 0;
429 del_timer(&thread_timer);
430 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
431 if (synth->attributes.name)
432 sysfs_remove_group(speakup_kobj, &(synth->attributes));
433 for (var = synth->vars; var->var_id != MAXVARS; var++)
434 speakup_unregister_var(var->var_id);
435 spk_stop_serial_interrupt();
436 synth->release();
437 synth = NULL;
438 }
439
440 /* called by: all_driver_init() */
synth_add(struct spk_synth * in_synth)441 int synth_add(struct spk_synth *in_synth)
442 {
443 int i;
444 int status = 0;
445
446 mutex_lock(&spk_mutex);
447 for (i = 0; i < MAXSYNTHS && synths[i] != NULL; i++)
448 /* synth_remove() is responsible for rotating the array down */
449 if (in_synth == synths[i]) {
450 mutex_unlock(&spk_mutex);
451 return 0;
452 }
453 if (i == MAXSYNTHS) {
454 pr_warn("Error: attempting to add a synth past end of array\n");
455 mutex_unlock(&spk_mutex);
456 return -1;
457 }
458 synths[i++] = in_synth;
459 synths[i] = NULL;
460 if (in_synth->startup)
461 status = do_synth_init(in_synth);
462 mutex_unlock(&spk_mutex);
463 return status;
464 }
465 EXPORT_SYMBOL_GPL(synth_add);
466
synth_remove(struct spk_synth * in_synth)467 void synth_remove(struct spk_synth *in_synth)
468 {
469 int i;
470
471 mutex_lock(&spk_mutex);
472 if (synth == in_synth)
473 synth_release();
474 for (i = 0; synths[i] != NULL; i++) {
475 if (in_synth == synths[i])
476 break;
477 }
478 for ( ; synths[i] != NULL; i++) /* compress table */
479 synths[i] = synths[i+1];
480 module_status = 0;
481 mutex_unlock(&spk_mutex);
482 }
483 EXPORT_SYMBOL_GPL(synth_remove);
484
485 short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC|B_SYM };
486