1
2
3
4
5
6
7
8
9
10
11
12#include <linux/unistd.h>
13#include <linux/proc_fs.h>
14#include <linux/jiffies.h>
15#include <linux/spinlock.h>
16#include <linux/sched.h>
17#include <linux/timer.h>
18#include <linux/kthread.h>
19#include "speakup.h"
20#include "spk_priv.h"
21
22#define DRV_VERSION "2.20"
23#define SYNTH_CLEAR 0x03
24#define PROCSPEECH 0x0b
25static int xoff;
26
27static inline int synth_full(void)
28{
29 return xoff;
30}
31
32static void do_catch_up(struct spk_synth *synth);
33static void synth_flush(struct spk_synth *synth);
34static void read_buff_add(u_char c);
35static unsigned char get_index(struct spk_synth *synth);
36
37static int in_escape;
38static int is_flushing;
39
40static spinlock_t flush_lock;
41static DECLARE_WAIT_QUEUE_HEAD(flush);
42
43static struct var_t vars[] = {
44 { CAPS_START, .u.s = {"[:dv ap 160] " } },
45 { CAPS_STOP, .u.s = {"[:dv ap 100 ] " } },
46 { RATE, .u.n = {"[:ra %d] ", 180, 75, 650, 0, 0, NULL } },
47 { INFLECTION, .u.n = {"[:dv pr %d] ", 100, 0, 10000, 0, 0, NULL } },
48 { VOL, .u.n = {"[:dv g5 %d] ", 86, 60, 86, 0, 0, NULL } },
49 { PUNCT, .u.n = {"[:pu %c] ", 0, 0, 2, 0, 0, "nsa" } },
50 { VOICE, .u.n = {"[:n%c] ", 0, 0, 9, 0, 0, "phfdburwkv" } },
51 { DIRECT, .u.n = {NULL, 0, 0, 1, 0, 0, NULL } },
52 V_LAST_VAR
53};
54
55
56
57
58static struct kobj_attribute caps_start_attribute =
59 __ATTR(caps_start, 0644, spk_var_show, spk_var_store);
60static struct kobj_attribute caps_stop_attribute =
61 __ATTR(caps_stop, 0644, spk_var_show, spk_var_store);
62static struct kobj_attribute pitch_attribute =
63 __ATTR(pitch, 0644, spk_var_show, spk_var_store);
64static struct kobj_attribute inflection_attribute =
65 __ATTR(inflection, 0644, spk_var_show, spk_var_store);
66static struct kobj_attribute punct_attribute =
67 __ATTR(punct, 0644, spk_var_show, spk_var_store);
68static struct kobj_attribute rate_attribute =
69 __ATTR(rate, 0644, spk_var_show, spk_var_store);
70static struct kobj_attribute voice_attribute =
71 __ATTR(voice, 0644, spk_var_show, spk_var_store);
72static struct kobj_attribute vol_attribute =
73 __ATTR(vol, 0644, spk_var_show, spk_var_store);
74
75static struct kobj_attribute delay_time_attribute =
76 __ATTR(delay_time, 0644, spk_var_show, spk_var_store);
77static struct kobj_attribute direct_attribute =
78 __ATTR(direct, 0644, spk_var_show, spk_var_store);
79static struct kobj_attribute full_time_attribute =
80 __ATTR(full_time, 0644, spk_var_show, spk_var_store);
81static struct kobj_attribute jiffy_delta_attribute =
82 __ATTR(jiffy_delta, 0644, spk_var_show, spk_var_store);
83static struct kobj_attribute trigger_time_attribute =
84 __ATTR(trigger_time, 0644, spk_var_show, spk_var_store);
85
86
87
88
89
90static struct attribute *synth_attrs[] = {
91 &caps_start_attribute.attr,
92 &caps_stop_attribute.attr,
93 &pitch_attribute.attr,
94 &inflection_attribute.attr,
95 &punct_attribute.attr,
96 &rate_attribute.attr,
97 &voice_attribute.attr,
98 &vol_attribute.attr,
99 &delay_time_attribute.attr,
100 &direct_attribute.attr,
101 &full_time_attribute.attr,
102 &jiffy_delta_attribute.attr,
103 &trigger_time_attribute.attr,
104 NULL,
105};
106
107static int ap_defaults[] = {122, 89, 155, 110, 208, 240, 200, 106, 306};
108static int g5_defaults[] = {86, 81, 86, 84, 81, 80, 83, 83, 73};
109
110static struct spk_synth synth_dectlk = {
111 .name = "dectlk",
112 .version = DRV_VERSION,
113 .long_name = "Dectalk Express",
114 .init = "[:error sp :name paul :rate 180 :tsr off] ",
115 .procspeech = PROCSPEECH,
116 .clear = SYNTH_CLEAR,
117 .delay = 500,
118 .trigger = 50,
119 .jiffies = 50,
120 .full = 40000,
121 .dev_name = SYNTH_DEFAULT_DEV,
122 .startup = SYNTH_START,
123 .checkval = SYNTH_CHECK,
124 .vars = vars,
125 .default_pitch = ap_defaults,
126 .default_vol = g5_defaults,
127 .io_ops = &spk_ttyio_ops,
128 .probe = spk_ttyio_synth_probe,
129 .release = spk_ttyio_release,
130 .synth_immediate = spk_ttyio_synth_immediate,
131 .catch_up = do_catch_up,
132 .flush = synth_flush,
133 .is_alive = spk_synth_is_alive_restart,
134 .synth_adjust = NULL,
135 .read_buff_add = read_buff_add,
136 .get_index = get_index,
137 .indexing = {
138 .command = "[:in re %d ] ",
139 .lowindex = 1,
140 .highindex = 8,
141 .currindex = 1,
142 },
143 .attributes = {
144 .attrs = synth_attrs,
145 .name = "dectlk",
146 },
147};
148
149static int is_indnum(u_char *ch)
150{
151 if ((*ch >= '0') && (*ch <= '9')) {
152 *ch = *ch - '0';
153 return 1;
154 }
155 return 0;
156}
157
158static u_char lastind;
159
160static unsigned char get_index(struct spk_synth *synth)
161{
162 u_char rv;
163
164 rv = lastind;
165 lastind = 0;
166 return rv;
167}
168
169static void read_buff_add(u_char c)
170{
171 static int ind = -1;
172
173 if (c == 0x01) {
174 unsigned long flags;
175
176 spin_lock_irqsave(&flush_lock, flags);
177 is_flushing = 0;
178 wake_up_interruptible(&flush);
179 spin_unlock_irqrestore(&flush_lock, flags);
180 } else if (c == 0x13) {
181 xoff = 1;
182 } else if (c == 0x11) {
183 xoff = 0;
184 } else if (is_indnum(&c)) {
185 if (ind == -1)
186 ind = c;
187 else
188 ind = ind * 10 + c;
189 } else if ((c > 31) && (c < 127)) {
190 if (ind != -1)
191 lastind = (u_char)ind;
192 ind = -1;
193 }
194}
195
196static void do_catch_up(struct spk_synth *synth)
197{
198 int synth_full_val = 0;
199 static u_char ch;
200 static u_char last = '\0';
201 unsigned long flags;
202 unsigned long jiff_max;
203 unsigned long timeout = msecs_to_jiffies(4000);
204 DEFINE_WAIT(wait);
205 struct var_t *jiffy_delta;
206 struct var_t *delay_time;
207 int jiffy_delta_val;
208 int delay_time_val;
209
210 jiffy_delta = spk_get_var(JIFFY);
211 delay_time = spk_get_var(DELAY);
212 spin_lock_irqsave(&speakup_info.spinlock, flags);
213 jiffy_delta_val = jiffy_delta->u.n.value;
214 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
215 jiff_max = jiffies + jiffy_delta_val;
216
217 while (!kthread_should_stop()) {
218
219 spin_lock_irqsave(&flush_lock, flags);
220 while (is_flushing && timeout) {
221 prepare_to_wait(&flush, &wait, TASK_INTERRUPTIBLE);
222 spin_unlock_irqrestore(&flush_lock, flags);
223 timeout = schedule_timeout(timeout);
224 spin_lock_irqsave(&flush_lock, flags);
225 }
226 finish_wait(&flush, &wait);
227 is_flushing = 0;
228 spin_unlock_irqrestore(&flush_lock, flags);
229
230 spin_lock_irqsave(&speakup_info.spinlock, flags);
231 if (speakup_info.flushing) {
232 speakup_info.flushing = 0;
233 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
234 synth->flush(synth);
235 continue;
236 }
237 synth_buffer_skip_nonlatin1();
238 if (synth_buffer_empty()) {
239 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
240 break;
241 }
242 ch = synth_buffer_peek();
243 set_current_state(TASK_INTERRUPTIBLE);
244 delay_time_val = delay_time->u.n.value;
245 synth_full_val = synth_full();
246 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
247 if (ch == '\n')
248 ch = 0x0D;
249 if (synth_full_val || !synth->io_ops->synth_out(synth, ch)) {
250 schedule_timeout(msecs_to_jiffies(delay_time_val));
251 continue;
252 }
253 set_current_state(TASK_RUNNING);
254 spin_lock_irqsave(&speakup_info.spinlock, flags);
255 synth_buffer_getc();
256 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
257 if (ch == '[') {
258 in_escape = 1;
259 } else if (ch == ']') {
260 in_escape = 0;
261 } else if (ch <= SPACE) {
262 if (!in_escape && strchr(",.!?;:", last))
263 synth->io_ops->synth_out(synth, PROCSPEECH);
264 if (time_after_eq(jiffies, jiff_max)) {
265 if (!in_escape)
266 synth->io_ops->synth_out(synth,
267 PROCSPEECH);
268 spin_lock_irqsave(&speakup_info.spinlock,
269 flags);
270 jiffy_delta_val = jiffy_delta->u.n.value;
271 delay_time_val = delay_time->u.n.value;
272 spin_unlock_irqrestore(&speakup_info.spinlock,
273 flags);
274 schedule_timeout(msecs_to_jiffies
275 (delay_time_val));
276 jiff_max = jiffies + jiffy_delta_val;
277 }
278 }
279 last = ch;
280 }
281 if (!in_escape)
282 synth->io_ops->synth_out(synth, PROCSPEECH);
283}
284
285static void synth_flush(struct spk_synth *synth)
286{
287 if (in_escape)
288
289 synth->io_ops->synth_out(synth, ']');
290 in_escape = 0;
291 is_flushing = 1;
292 synth->io_ops->flush_buffer();
293 synth->io_ops->synth_out(synth, SYNTH_CLEAR);
294}
295
296module_param_named(ser, synth_dectlk.ser, int, 0444);
297module_param_named(dev, synth_dectlk.dev_name, charp, 0444);
298module_param_named(start, synth_dectlk.startup, short, 0444);
299
300MODULE_PARM_DESC(ser, "Set the serial port for the synthesizer (0-based).");
301MODULE_PARM_DESC(dev, "Set the device e.g. ttyUSB0, for the synthesizer.");
302MODULE_PARM_DESC(start, "Start the synthesizer once it is loaded.");
303
304module_spk_synth(synth_dectlk);
305
306MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
307MODULE_AUTHOR("David Borowski");
308MODULE_DESCRIPTION("Speakup support for DECtalk Express synthesizers");
309MODULE_LICENSE("GPL");
310MODULE_VERSION(DRV_VERSION);
311
312
