1 /* speakup_soft.c - speakup driver to register and make available
2 * a user space device for software synthesizers. written by: Kirk
3 * Reiser <kirk@braille.uwo.ca>
5 * Copyright (C) 2003 Kirk Reiser.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 * this code is specificly written as a driver for the speakup screenreview
19 * package and is not a general device driver.
22 #include <linux/unistd.h>
23 #include <linux/miscdevice.h> /* for misc_register, and SYNTH_MINOR */
24 #include <linux/poll.h> /* for poll_wait() */
25 #include <linux/sched/signal.h> /* schedule(), signal_pending(), TASK_INTERRUPTIBLE */
30 #define DRV_VERSION "2.6"
31 #define SOFTSYNTH_MINOR 26 /* might as well give it one more than /dev/synth */
32 #define PROCSPEECH 0x0d
33 #define CLEAR_SYNTH 0x18
35 static int softsynth_probe(struct spk_synth
*synth
);
36 static void softsynth_release(void);
37 static int softsynth_is_alive(struct spk_synth
*synth
);
38 static unsigned char get_index(void);
40 static struct miscdevice synth_device
;
42 static int misc_registered
;
44 static 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
} },
58 /* These attributes will appear in /sys/accessibility/speakup/soft. */
60 static struct kobj_attribute caps_start_attribute
=
61 __ATTR(caps_start
, 0644, spk_var_show
, spk_var_store
);
62 static struct kobj_attribute caps_stop_attribute
=
63 __ATTR(caps_stop
, 0644, spk_var_show
, spk_var_store
);
64 static struct kobj_attribute freq_attribute
=
65 __ATTR(freq
, 0644, spk_var_show
, spk_var_store
);
66 static struct kobj_attribute pitch_attribute
=
67 __ATTR(pitch
, 0644, spk_var_show
, spk_var_store
);
68 static struct kobj_attribute punct_attribute
=
69 __ATTR(punct
, 0644, spk_var_show
, spk_var_store
);
70 static struct kobj_attribute rate_attribute
=
71 __ATTR(rate
, 0644, spk_var_show
, spk_var_store
);
72 static struct kobj_attribute tone_attribute
=
73 __ATTR(tone
, 0644, spk_var_show
, spk_var_store
);
74 static struct kobj_attribute voice_attribute
=
75 __ATTR(voice
, 0644, spk_var_show
, spk_var_store
);
76 static struct kobj_attribute vol_attribute
=
77 __ATTR(vol
, 0644, spk_var_show
, spk_var_store
);
80 * We should uncomment the following definition, when we agree on a
81 * method of passing a language designation to the software synthesizer.
82 * static struct kobj_attribute lang_attribute =
83 * __ATTR(lang, 0644, spk_var_show, spk_var_store);
86 static struct kobj_attribute delay_time_attribute
=
87 __ATTR(delay_time
, 0644, spk_var_show
, spk_var_store
);
88 static struct kobj_attribute direct_attribute
=
89 __ATTR(direct
, 0644, spk_var_show
, spk_var_store
);
90 static struct kobj_attribute full_time_attribute
=
91 __ATTR(full_time
, 0644, spk_var_show
, spk_var_store
);
92 static struct kobj_attribute jiffy_delta_attribute
=
93 __ATTR(jiffy_delta
, 0644, spk_var_show
, spk_var_store
);
94 static struct kobj_attribute trigger_time_attribute
=
95 __ATTR(trigger_time
, 0644, spk_var_show
, spk_var_store
);
98 * Create a group of attributes so that we can create and destroy them all
101 static struct attribute
*synth_attrs
[] = {
102 &caps_start_attribute
.attr
,
103 &caps_stop_attribute
.attr
,
104 &freq_attribute
.attr
,
105 /* &lang_attribute.attr, */
106 &pitch_attribute
.attr
,
107 &punct_attribute
.attr
,
108 &rate_attribute
.attr
,
109 &tone_attribute
.attr
,
110 &voice_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
, /* need to NULL terminate the list of attributes */
120 static struct spk_synth synth_soft
= {
122 .version
= DRV_VERSION
,
123 .long_name
= "software synth",
124 .init
= "\01@\x01\x31y\n",
125 .procspeech
= PROCSPEECH
,
130 .startup
= SYNTH_START
,
131 .checkval
= SYNTH_CHECK
,
133 .probe
= softsynth_probe
,
134 .release
= softsynth_release
,
135 .synth_immediate
= NULL
,
138 .is_alive
= softsynth_is_alive
,
139 .synth_adjust
= NULL
,
140 .read_buff_add
= NULL
,
141 .get_index
= get_index
,
143 .command
= "\x01%di",
149 .attrs
= synth_attrs
,
154 static char *get_initstring(void)
160 memset(buf
, 0, sizeof(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
,
170 cp
= cp
+ sprintf(cp
, "\n");
174 static int softsynth_open(struct inode
*inode
, struct file
*fp
)
177 /*if ((fp->f_flags & O_ACCMODE) != O_RDONLY) */
179 spin_lock_irqsave(&speakup_info
.spinlock
, flags
);
180 if (synth_soft
.alive
) {
181 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
184 synth_soft
.alive
= 1;
185 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
189 static int softsynth_close(struct inode
*inode
, struct file
*fp
)
193 spin_lock_irqsave(&speakup_info
.spinlock
, flags
);
194 synth_soft
.alive
= 0;
196 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
197 /* Make sure we let applications go before leaving */
198 speakup_start_ttys();
202 static ssize_t
softsynth_read(struct file
*fp
, char __user
*buf
, size_t count
,
213 spin_lock_irqsave(&speakup_info
.spinlock
, flags
);
215 prepare_to_wait(&speakup_event
, &wait
, TASK_INTERRUPTIBLE
);
216 if (!synth_buffer_empty() || speakup_info
.flushing
)
218 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
219 if (fp
->f_flags
& O_NONBLOCK
) {
220 finish_wait(&speakup_event
, &wait
);
223 if (signal_pending(current
)) {
224 finish_wait(&speakup_event
, &wait
);
228 spin_lock_irqsave(&speakup_info
.spinlock
, flags
);
230 finish_wait(&speakup_event
, &wait
);
233 init
= get_initstring();
234 while (chars_sent
< count
) {
235 if (speakup_info
.flushing
) {
236 speakup_info
.flushing
= 0;
238 } else if (synth_buffer_empty()) {
240 } else if (init
[init_pos
]) {
241 ch
= init
[init_pos
++];
243 ch
= synth_buffer_getc();
245 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
246 if (copy_to_user(cp
, &ch
, 1))
248 spin_lock_irqsave(&speakup_info
.spinlock
, flags
);
253 empty
= synth_buffer_empty();
254 spin_unlock_irqrestore(&speakup_info
.spinlock
, flags
);
256 speakup_start_ttys();
262 static int last_index
;
264 static ssize_t
softsynth_write(struct file
*fp
, const char __user
*buf
,
265 size_t count
, loff_t
*pos
)
267 unsigned long supplied_index
= 0;
270 converted
= kstrtoul_from_user(buf
, count
, 0, &supplied_index
);
275 last_index
= supplied_index
;
279 static unsigned int softsynth_poll(struct file
*fp
, struct poll_table_struct
*wait
)
284 poll_wait(fp
, &speakup_event
, wait
);
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
);
293 static unsigned char get_index(void)
302 static 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
,
311 static int softsynth_probe(struct spk_synth
*synth
)
313 if (misc_registered
!= 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");
325 pr_info("initialized device: /dev/softsynth, node (MAJOR 10, MINOR 26)\n");
329 static void softsynth_release(void)
331 misc_deregister(&synth_device
);
333 pr_info("unregistered /dev/softsynth\n");
336 static int softsynth_is_alive(struct spk_synth
*synth
)
338 if (synth_soft
.alive
)
343 module_param_named(start
, synth_soft
.startup
, short, 0444);
345 MODULE_PARM_DESC(start
, "Start the synthesizer once it is loaded.");
347 module_spk_synth(synth_soft
);
349 MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
350 MODULE_DESCRIPTION("Speakup userspace software synthesizer support");
351 MODULE_LICENSE("GPL");
352 MODULE_VERSION(DRV_VERSION
);