speakup_soft.c 9.74 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* speakup_soft.c - speakup driver to register and make available
 * a user space device for software synthesizers.  written by: Kirk
 * Reiser <kirk@braille.uwo.ca>
 *
 * Copyright (C) 2003  Kirk Reiser.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 *
 * this code is specificly written as a driver for the speakup screenreview
19
20
 * package and is not a general device driver.
 */
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <linux/unistd.h>
#include <linux/miscdevice.h> /* for misc_register, and SYNTH_MINOR */
#include <linux/poll.h> /* for poll_wait() */
#include <linux/sched.h> /* schedule(), signal_pending(), TASK_INTERRUPTIBLE */

#include "spk_priv.h"
#include "speakup.h"

#define DRV_VERSION "2.6"
#define SOFTSYNTH_MINOR 26 /* might as well give it one more than /dev/synth */
#define PROCSPEECH 0x0d
#define CLEAR_SYNTH 0x18

static int softsynth_probe(struct spk_synth *synth);
static void softsynth_release(void);
static int softsynth_is_alive(struct spk_synth *synth);
static unsigned char get_index(void);

static struct miscdevice synth_device;
41
static int init_pos;
42
43
44
static int misc_registered;

static struct var_t vars[] = {
45
46
	{ CAPS_START, .u.s = {"\x01+3p" } },
	{ CAPS_STOP, .u.s = {"\x01-3p" } },
47
	{ RATE, .u.n = {"\x01%ds", 2, 0, 9, 0, 0, NULL } },
48
49
50
51
52
53
54
	{ PITCH, .u.n = {"\x01%dp", 5, 0, 9, 0, 0, NULL } },
	{ VOL, .u.n = {"\x01%dv", 5, 0, 9, 0, 0, NULL } },
	{ TONE, .u.n = {"\x01%dx", 1, 0, 2, 0, 0, NULL } },
	{ PUNCT, .u.n = {"\x01%db", 0, 0, 2, 0, 0, NULL } },
	{ VOICE, .u.n = {"\x01%do", 0, 0, 7, 0, 0, NULL } },
	{ FREQUENCY, .u.n = {"\x01%df", 5, 0, 9, 0, 0, NULL } },
	{ DIRECT, .u.n = {NULL, 0, 0, 1, 0, 0, NULL } },
55
56
57
58
59
60
61
	V_LAST_VAR
};

/*
 * These attributes will appear in /sys/accessibility/speakup/soft.
 */
static struct kobj_attribute caps_start_attribute =
62
	__ATTR(caps_start, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
63
static struct kobj_attribute caps_stop_attribute =
64
	__ATTR(caps_stop, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
65
static struct kobj_attribute freq_attribute =
66
	__ATTR(freq, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
67
static struct kobj_attribute pitch_attribute =
68
	__ATTR(pitch, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
69
static struct kobj_attribute punct_attribute =
70
	__ATTR(punct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
71
static struct kobj_attribute rate_attribute =
72
	__ATTR(rate, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
73
static struct kobj_attribute tone_attribute =
74
	__ATTR(tone, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
75
static struct kobj_attribute voice_attribute =
76
	__ATTR(voice, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
77
static struct kobj_attribute vol_attribute =
78
	__ATTR(vol, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
79

80
81
82
83
/*
 * We should uncomment the following definition, when we agree on a
 * method of passing a language designation to the software synthesizer.
 * static struct kobj_attribute lang_attribute =
84
 *	__ATTR(lang, S_IWUSR|S_IRUGO, spk_var_show, spk_var_store);
85
86
 */

87
static struct kobj_attribute delay_time_attribute =
88
	__ATTR(delay_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
89
static struct kobj_attribute direct_attribute =
90
	__ATTR(direct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
91
static struct kobj_attribute full_time_attribute =
92
	__ATTR(full_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
93
static struct kobj_attribute jiffy_delta_attribute =
94
	__ATTR(jiffy_delta, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
95
static struct kobj_attribute trigger_time_attribute =
96
	__ATTR(trigger_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
97
98
99
100
101
102
103
104
105

/*
 * Create a group of attributes so that we can create and destroy them all
 * at once.
 */
static struct attribute *synth_attrs[] = {
	&caps_start_attribute.attr,
	&caps_stop_attribute.attr,
	&freq_attribute.attr,
106
/*	&lang_attribute.attr, */
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
	&pitch_attribute.attr,
	&punct_attribute.attr,
	&rate_attribute.attr,
	&tone_attribute.attr,
	&voice_attribute.attr,
	&vol_attribute.attr,
	&delay_time_attribute.attr,
	&direct_attribute.attr,
	&full_time_attribute.attr,
	&jiffy_delta_attribute.attr,
	&trigger_time_attribute.attr,
	NULL,	/* need to NULL terminate the list of attributes */
};

static struct spk_synth synth_soft = {
	.name = "soft",
	.version = DRV_VERSION,
	.long_name = "software synth",
	.init = "\01@\x01\x31y\n",
	.procspeech = PROCSPEECH,
	.delay = 0,
	.trigger = 0,
	.jiffies = 0,
	.full = 0,
	.startup = SYNTH_START,
	.checkval = SYNTH_CHECK,
	.vars = vars,
	.probe = softsynth_probe,
	.release = softsynth_release,
	.synth_immediate = NULL,
	.catch_up = NULL,
	.flush = NULL,
	.is_alive = softsynth_is_alive,
	.synth_adjust = NULL,
	.read_buff_add = NULL,
	.get_index = get_index,
	.indexing = {
		.command = "\x01%di",
		.lowindex = 1,
		.highindex = 5,
		.currindex = 1,
	},
	.attributes = {
		.attrs = synth_attrs,
		.name = "soft",
	},
};

static char *get_initstring(void)
{
	static char buf[40];
	char *cp;
	struct var_t *var;

	memset(buf, 0, sizeof(buf));
	cp = buf;
	var = synth_soft.vars;
	while (var->var_id != MAXVARS) {
165
166
		if (var->var_id != CAPS_START && var->var_id != CAPS_STOP &&
		    var->var_id != DIRECT)
167
168
			cp = cp + sprintf(cp, var->u.n.synth_fmt,
					  var->u.n.value);
169
170
171
172
173
174
175
176
177
178
179
		var++;
	}
	cp = cp + sprintf(cp, "\n");
	return buf;
}

static int softsynth_open(struct inode *inode, struct file *fp)
{
	unsigned long flags;
	/*if ((fp->f_flags & O_ACCMODE) != O_RDONLY) */
	/*	return -EPERM; */
180
	spin_lock_irqsave(&speakup_info.spinlock, flags);
181
	if (synth_soft.alive) {
182
		spin_unlock_irqrestore(&speakup_info.spinlock, flags);
183
184
185
		return -EBUSY;
	}
	synth_soft.alive = 1;
186
	spin_unlock_irqrestore(&speakup_info.spinlock, flags);
187
188
189
190
191
192
	return 0;
}

static int softsynth_close(struct inode *inode, struct file *fp)
{
	unsigned long flags;
193

194
	spin_lock_irqsave(&speakup_info.spinlock, flags);
195
	synth_soft.alive = 0;
196
	init_pos = 0;
197
	spin_unlock_irqrestore(&speakup_info.spinlock, flags);
198
199
200
201
202
	/* Make sure we let applications go before leaving */
	speakup_start_ttys();
	return 0;
}

203
static ssize_t softsynth_read(struct file *fp, char __user *buf, size_t count,
204
205
206
			      loff_t *pos)
{
	int chars_sent = 0;
207
	char __user *cp;
208
209
210
211
212
213
	char *init;
	char ch;
	int empty;
	unsigned long flags;
	DEFINE_WAIT(wait);

214
	spin_lock_irqsave(&speakup_info.spinlock, flags);
215
216
217
218
	while (1) {
		prepare_to_wait(&speakup_event, &wait, TASK_INTERRUPTIBLE);
		if (!synth_buffer_empty() || speakup_info.flushing)
			break;
219
		spin_unlock_irqrestore(&speakup_info.spinlock, flags);
220
221
222
223
224
225
226
227
228
		if (fp->f_flags & O_NONBLOCK) {
			finish_wait(&speakup_event, &wait);
			return -EAGAIN;
		}
		if (signal_pending(current)) {
			finish_wait(&speakup_event, &wait);
			return -ERESTARTSYS;
		}
		schedule();
229
		spin_lock_irqsave(&speakup_info.spinlock, flags);
230
231
232
233
234
235
236
237
238
239
240
	}
	finish_wait(&speakup_event, &wait);

	cp = buf;
	init = get_initstring();
	while (chars_sent < count) {
		if (speakup_info.flushing) {
			speakup_info.flushing = 0;
			ch = '\x18';
		} else if (synth_buffer_empty()) {
			break;
241
242
		} else if (init[init_pos]) {
			ch = init[init_pos++];
243
244
245
		} else {
			ch = synth_buffer_getc();
		}
246
		spin_unlock_irqrestore(&speakup_info.spinlock, flags);
247
248
		if (copy_to_user(cp, &ch, 1))
			return -EFAULT;
249
		spin_lock_irqsave(&speakup_info.spinlock, flags);
250
251
252
253
254
		chars_sent++;
		cp++;
	}
	*pos += chars_sent;
	empty = synth_buffer_empty();
255
	spin_unlock_irqrestore(&speakup_info.spinlock, flags);
256
257
258
259
260
261
262
	if (empty) {
		speakup_start_ttys();
		*pos = 0;
	}
	return chars_sent;
}

263
static int last_index;
264

265
266
static ssize_t softsynth_write(struct file *fp, const char __user *buf,
			       size_t count, loff_t *pos)
267
{
268
269
	unsigned long supplied_index = 0;
	int converted;
270

271
	converted = kstrtoul_from_user(buf, count, 0, &supplied_index);
272
273
274

	if (converted < 0)
		return converted;
275

276
	last_index = supplied_index;
277
278
279
280
281
282
283
284
	return count;
}

static unsigned int softsynth_poll(struct file *fp,
		struct poll_table_struct *wait)
{
	unsigned long flags;
	int ret = 0;
285

286
287
	poll_wait(fp, &speakup_event, wait);

288
	spin_lock_irqsave(&speakup_info.spinlock, flags);
289
	if (!synth_buffer_empty() || speakup_info.flushing)
290
		ret = POLLIN | POLLRDNORM;
291
	spin_unlock_irqrestore(&speakup_info.spinlock, flags);
292
293
294
295
296
297
	return ret;
}

static unsigned char get_index(void)
{
	int rv;
298

299
300
301
302
303
	rv = last_index;
	last_index = 0;
	return rv;
}

304
static const struct file_operations softsynth_fops = {
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
	.owner = THIS_MODULE,
	.poll = softsynth_poll,
	.read = softsynth_read,
	.write = softsynth_write,
	.open = softsynth_open,
	.release = softsynth_close,
};


static int softsynth_probe(struct spk_synth *synth)
{

	if (misc_registered != 0)
		return 0;
	memset(&synth_device, 0, sizeof(synth_device));
	synth_device.minor = SOFTSYNTH_MINOR;
	synth_device.name = "softsynth";
	synth_device.fops = &softsynth_fops;
	if (misc_register(&synth_device)) {
		pr_warn("Couldn't initialize miscdevice /dev/softsynth.\n");
		return -ENODEV;
	}

	misc_registered = 1;
	pr_info("initialized device: /dev/softsynth, node (MAJOR 10, MINOR 26)\n");
	return 0;
}

static void softsynth_release(void)
{
	misc_deregister(&synth_device);
	misc_registered = 0;
	pr_info("unregistered /dev/softsynth\n");
}

static int softsynth_is_alive(struct spk_synth *synth)
{
	if (synth_soft.alive)
		return 1;
	return 0;
}

module_param_named(start, synth_soft.startup, short, S_IRUGO);

MODULE_PARM_DESC(start, "Start the synthesizer once it is loaded.");

351
module_spk_synth(synth_soft);
352
353
354
355
356

MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
MODULE_DESCRIPTION("Speakup userspace software synthesizer support");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);