1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/unistd.h>
23#include <linux/miscdevice.h>
24#include <linux/poll.h>
25#include <linux/sched.h>
26
27#include "spk_priv.h"
28#include "speakup.h"
29
30#define DRV_VERSION "2.6"
31#define SOFTSYNTH_MINOR 26
32#define PROCSPEECH 0x0d
33#define CLEAR_SYNTH 0x18
34
35static int softsynth_probe(struct spk_synth *synth);
36static void softsynth_release(void);
37static int softsynth_is_alive(struct spk_synth *synth);
38static unsigned char get_index(void);
39
40static struct miscdevice synth_device;
41static int init_pos;
42static int misc_registered;
43
44static struct var_t vars[] = {
45 { CAPS_START, .u.s = {"\x01+3p" } },
46 { CAPS_STOP, .u.s = {"\x01-3p" } },
47 { RATE, .u.n = {"\x01%ds", 2, 0, 9, 0, 0, NULL } },
48 { PITCH, .u.n = {"\x01%dp", 5, 0, 9, 0, 0, NULL } },
49 { VOL, .u.n = {"\x01%dv", 5, 0, 9, 0, 0, NULL } },
50 { TONE, .u.n = {"\x01%dx", 1, 0, 2, 0, 0, NULL } },
51 { PUNCT, .u.n = {"\x01%db", 0, 0, 2, 0, 0, NULL } },
52 { VOICE, .u.n = {"\x01%do", 0, 0, 7, 0, 0, NULL } },
53 { FREQUENCY, .u.n = {"\x01%df", 5, 0, 9, 0, 0, NULL } },
54 { DIRECT, .u.n = {NULL, 0, 0, 1, 0, 0, NULL } },
55 V_LAST_VAR
56};
57
58
59
60static struct kobj_attribute caps_start_attribute =
61 __ATTR(caps_start, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
62static struct kobj_attribute caps_stop_attribute =
63 __ATTR(caps_stop, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
64static struct kobj_attribute freq_attribute =
65 __ATTR(freq, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
66static struct kobj_attribute pitch_attribute =
67 __ATTR(pitch, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
68static struct kobj_attribute punct_attribute =
69 __ATTR(punct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
70static struct kobj_attribute rate_attribute =
71 __ATTR(rate, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
72static struct kobj_attribute tone_attribute =
73 __ATTR(tone, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
74static struct kobj_attribute voice_attribute =
75 __ATTR(voice, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
76static struct kobj_attribute vol_attribute =
77 __ATTR(vol, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
78
79
80
81
82
83
84
85
86static struct kobj_attribute delay_time_attribute =
87 __ATTR(delay_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
88static struct kobj_attribute direct_attribute =
89 __ATTR(direct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
90static struct kobj_attribute full_time_attribute =
91 __ATTR(full_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
92static struct kobj_attribute jiffy_delta_attribute =
93 __ATTR(jiffy_delta, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
94static struct kobj_attribute trigger_time_attribute =
95 __ATTR(trigger_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
96
97
98
99
100
101static struct attribute *synth_attrs[] = {
102 &caps_start_attribute.attr,
103 &caps_stop_attribute.attr,
104 &freq_attribute.attr,
105
106 &pitch_attribute.attr,
107 &punct_attribute.attr,
108 &rate_attribute.attr,
109 &tone_attribute.attr,
110 &voice_attribute.attr,
111 &vol_attribute.attr,
112 &delay_time_attribute.attr,
113 &direct_attribute.attr,
114 &full_time_attribute.attr,
115 &jiffy_delta_attribute.attr,
116 &trigger_time_attribute.attr,
117 NULL,
118};
119
120static struct spk_synth synth_soft = {
121 .name = "soft",
122 .version = DRV_VERSION,
123 .long_name = "software synth",
124 .init = "\01@\x01\x31y\n",
125 .procspeech = PROCSPEECH,
126 .delay = 0,
127 .trigger = 0,
128 .jiffies = 0,
129 .full = 0,
130 .startup = SYNTH_START,
131 .checkval = SYNTH_CHECK,
132 .vars = vars,
133 .probe = softsynth_probe,
134 .release = softsynth_release,
135 .synth_immediate = NULL,
136 .catch_up = NULL,
137 .flush = NULL,
138 .is_alive = softsynth_is_alive,
139 .synth_adjust = NULL,
140 .read_buff_add = NULL,
141 .get_index = get_index,
142 .indexing = {
143 .command = "\x01%di",
144 .lowindex = 1,
145 .highindex = 5,
146 .currindex = 1,
147 },
148 .attributes = {
149 .attrs = synth_attrs,
150 .name = "soft",
151 },
152};
153
154static char *get_initstring(void)
155{
156 static char buf[40];
157 char *cp;
158 struct var_t *var;
159
160 memset(buf, 0, sizeof(buf));
161 cp = buf;
162 var = synth_soft.vars;
163 while (var->var_id != MAXVARS) {
164 if (var->var_id != CAPS_START && var->var_id != CAPS_STOP &&
165 var->var_id != DIRECT)
166 cp = cp + sprintf(cp, var->u.n.synth_fmt,
167 var->u.n.value);
168 var++;
169 }
170 cp = cp + sprintf(cp, "\n");
171 return buf;
172}
173
174static int softsynth_open(struct inode *inode, struct file *fp)
175{
176 unsigned long flags;
177
178
179 spin_lock_irqsave(&speakup_info.spinlock, flags);
180 if (synth_soft.alive) {
181 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
182 return -EBUSY;
183 }
184 synth_soft.alive = 1;
185 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
186 return 0;
187}
188
189static int softsynth_close(struct inode *inode, struct file *fp)
190{
191 unsigned long flags;
192
193 spin_lock_irqsave(&speakup_info.spinlock, flags);
194 synth_soft.alive = 0;
195 init_pos = 0;
196 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
197
198 speakup_start_ttys();
199 return 0;
200}
201
202static ssize_t softsynth_read(struct file *fp, char __user *buf, size_t count,
203 loff_t *pos)
204{
205 int chars_sent = 0;
206 char __user *cp;
207 char *init;
208 char ch;
209 int empty;
210 unsigned long flags;
211 DEFINE_WAIT(wait);
212
213 spin_lock_irqsave(&speakup_info.spinlock, flags);
214 while (1) {
215 prepare_to_wait(&speakup_event, &wait, TASK_INTERRUPTIBLE);
216 if (!synth_buffer_empty() || speakup_info.flushing)
217 break;
218 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
219 if (fp->f_flags & O_NONBLOCK) {
220 finish_wait(&speakup_event, &wait);
221 return -EAGAIN;
222 }
223 if (signal_pending(current)) {
224 finish_wait(&speakup_event, &wait);
225 return -ERESTARTSYS;
226 }
227 schedule();
228 spin_lock_irqsave(&speakup_info.spinlock, flags);
229 }
230 finish_wait(&speakup_event, &wait);
231
232 cp = buf;
233 init = get_initstring();
234 while (chars_sent < count) {
235 if (speakup_info.flushing) {
236 speakup_info.flushing = 0;
237 ch = '\x18';
238 } else if (synth_buffer_empty()) {
239 break;
240 } else if (init[init_pos]) {
241 ch = init[init_pos++];
242 } else {
243 ch = synth_buffer_getc();
244 }
245 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
246 if (copy_to_user(cp, &ch, 1))
247 return -EFAULT;
248 spin_lock_irqsave(&speakup_info.spinlock, flags);
249 chars_sent++;
250 cp++;
251 }
252 *pos += chars_sent;
253 empty = synth_buffer_empty();
254 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
255 if (empty) {
256 speakup_start_ttys();
257 *pos = 0;
258 }
259 return chars_sent;
260}
261
262static int last_index;
263
264static ssize_t softsynth_write(struct file *fp, const char __user *buf,
265 size_t count, loff_t *pos)
266{
267 unsigned long supplied_index = 0;
268 int converted;
269
270 converted = kstrtoul_from_user(buf, count, 0, &supplied_index);
271
272 if (converted < 0)
273 return converted;
274
275 last_index = supplied_index;
276 return count;
277}
278
279static unsigned int softsynth_poll(struct file *fp, struct poll_table_struct *wait)
280{
281 unsigned long flags;
282 int ret = 0;
283
284 poll_wait(fp, &speakup_event, wait);
285
286 spin_lock_irqsave(&speakup_info.spinlock, flags);
287 if (!synth_buffer_empty() || speakup_info.flushing)
288 ret = POLLIN | POLLRDNORM;
289 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
290 return ret;
291}
292
293static unsigned char get_index(void)
294{
295 int rv;
296
297 rv = last_index;
298 last_index = 0;
299 return rv;
300}
301
302static const struct file_operations softsynth_fops = {
303 .owner = THIS_MODULE,
304 .poll = softsynth_poll,
305 .read = softsynth_read,
306 .write = softsynth_write,
307 .open = softsynth_open,
308 .release = softsynth_close,
309};
310
311static int softsynth_probe(struct spk_synth *synth)
312{
313 if (misc_registered != 0)
314 return 0;
315 memset(&synth_device, 0, sizeof(synth_device));
316 synth_device.minor = SOFTSYNTH_MINOR;
317 synth_device.name = "softsynth";
318 synth_device.fops = &softsynth_fops;
319 if (misc_register(&synth_device)) {
320 pr_warn("Couldn't initialize miscdevice /dev/softsynth.\n");
321 return -ENODEV;
322 }
323
324 misc_registered = 1;
325 pr_info("initialized device: /dev/softsynth, node (MAJOR 10, MINOR 26)\n");
326 return 0;
327}
328
329static void softsynth_release(void)
330{
331 misc_deregister(&synth_device);
332 misc_registered = 0;
333 pr_info("unregistered /dev/softsynth\n");
334}
335
336static int softsynth_is_alive(struct spk_synth *synth)
337{
338 if (synth_soft.alive)
339 return 1;
340 return 0;
341}
342
343module_param_named(start, synth_soft.startup, short, S_IRUGO);
344
345MODULE_PARM_DESC(start, "Start the synthesizer once it is loaded.");
346
347module_spk_synth(synth_soft);
348
349MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
350MODULE_DESCRIPTION("Speakup userspace software synthesizer support");
351MODULE_LICENSE("GPL");
352MODULE_VERSION(DRV_VERSION);
353
