]> git.proxmox.com Git - mirror_ubuntu-disco-kernel.git/blob - drivers/staging/speakup/main.c
projects / mirror_ubuntu-disco-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branches 'asoc/fix/amd', 'asoc/fix/arizona', 'asoc/fix/dpcm...
[mirror_ubuntu-disco-kernel.git] / drivers / staging / speakup / main.c
1 /* speakup.c
2 * review functions for the speakup screen review package.
3 * originally written by: Kirk Reiser and Andy Berdan.
4 *
5 * extensively modified by David Borowski.
6 *
7 ** Copyright (C) 1998 Kirk Reiser.
8 * Copyright (C) 2003 David Borowski.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include <linux/kernel.h>
26 #include <linux/vt.h>
27 #include <linux/tty.h>
28 #include <linux/mm.h> /* __get_free_page() and friends */
29 #include <linux/vt_kern.h>
30 #include <linux/ctype.h>
31 #include <linux/selection.h>
32 #include <linux/unistd.h>
33 #include <linux/jiffies.h>
34 #include <linux/kthread.h>
35 #include <linux/keyboard.h> /* for KT_SHIFT */
36 #include <linux/kbd_kern.h> /* for vc_kbd_* and friends */
37 #include <linux/input.h>
38 #include <linux/kmod.h>
39
40 /* speakup_*_selection */
41 #include <linux/module.h>
42 #include <linux/sched.h>
43 #include <linux/slab.h>
44 #include <linux/types.h>
45 #include <linux/consolemap.h>
46
47 #include <linux/spinlock.h>
48 #include <linux/notifier.h>
49
50 #include <linux/uaccess.h> /* copy_from|to|user() and others */
51
52 #include "spk_priv.h"
53 #include "speakup.h"
54
55 #define MAX_DELAY msecs_to_jiffies(500)
56 #define MINECHOCHAR SPACE
57
58 MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
59 MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>");
60 MODULE_DESCRIPTION("Speakup console speech");
61 MODULE_LICENSE("GPL");
62 MODULE_VERSION(SPEAKUP_VERSION);
63
64 char *synth_name;
65 module_param_named(synth, synth_name, charp, S_IRUGO);
66 module_param_named(quiet, spk_quiet_boot, bool, S_IRUGO);
67
68 MODULE_PARM_DESC(synth, "Synth to start if speakup is built in.");
69 MODULE_PARM_DESC(quiet, "Do not announce when the synthesizer is found.");
70
71 special_func spk_special_handler;
72
73 short spk_pitch_shift, synth_flags;
74 static char buf[256];
75 int spk_attrib_bleep, spk_bleeps, spk_bleep_time = 10;
76 int spk_no_intr, spk_spell_delay;
77 int spk_key_echo, spk_say_word_ctl;
78 int spk_say_ctrl, spk_bell_pos;
79 short spk_punc_mask;
80 int spk_punc_level, spk_reading_punc;
81 char spk_str_caps_start[MAXVARLEN + 1] = "\0";
82 char spk_str_caps_stop[MAXVARLEN + 1] = "\0";
83 const struct st_bits_data spk_punc_info[] = {
84 {"none", "", 0},
85 {"some", "/$%&@", SOME},
86 {"most", "$%&#()=+*/@^<>|\\", MOST},
87 {"all", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", PUNC},
88 {"delimiters", "", B_WDLM},
89 {"repeats", "()", CH_RPT},
90 {"extended numeric", "", B_EXNUM},
91 {"symbols", "", B_SYM},
92 {NULL, NULL}
93 };
94
95 static char mark_cut_flag;
96 #define MAX_KEY 160
97 static u_char *spk_shift_table;
98 u_char *spk_our_keys[MAX_KEY];
99 u_char spk_key_buf[600];
100 const u_char spk_key_defaults[] = {
101 #include "speakupmap.h"
102 };
103
104 /* Speakup Cursor Track Variables */
105 static int cursor_track = 1, prev_cursor_track = 1;
106
107 /* cursor track modes, must be ordered same as cursor_msgs */
108 enum {
109 CT_Off = 0,
110 CT_On,
111 CT_Highlight,
112 CT_Window,
113 CT_Max
114 };
115 #define read_all_mode CT_Max
116
117 static struct tty_struct *tty;
118
119 static void spkup_write(const char *in_buf, int count);
120
121 static char *phonetic[] = {
122 "alfa", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel",
123 "india", "juliett", "keelo", "leema", "mike", "november", "oscar",
124 "papa",
125 "keh beck", "romeo", "sierra", "tango", "uniform", "victer", "whiskey",
126 "x ray", "yankee", "zulu"
127 };
128
129 /* array of 256 char pointers (one for each character description)
130 * initialized to default_chars and user selectable via
131 * /proc/speakup/characters
132 */
133 char *spk_characters[256];
134
135 char *spk_default_chars[256] = {
136 /*000*/ "null", "^a", "^b", "^c", "^d", "^e", "^f", "^g",
137 /*008*/ "^h", "^i", "^j", "^k", "^l", "^m", "^n", "^o",
138 /*016*/ "^p", "^q", "^r", "^s", "^t", "^u", "^v", "^w",
139 /*024*/ "^x", "^y", "^z", "control", "control", "control", "control",
140 "control",
141 /*032*/ "space", "bang!", "quote", "number", "dollar", "percent", "and",
142 "tick",
143 /*040*/ "left paren", "right paren", "star", "plus", "comma", "dash",
144 "dot",
145 "slash",
146 /*048*/ "zero", "one", "two", "three", "four", "five", "six", "seven",
147 "eight", "nine",
148 /*058*/ "colon", "semmy", "less", "equals", "greater", "question", "at",
149 /*065*/ "EIGH", "B", "C", "D", "E", "F", "G",
150 /*072*/ "H", "I", "J", "K", "L", "M", "N", "O",
151 /*080*/ "P", "Q", "R", "S", "T", "U", "V", "W", "X",
152 /*089*/ "Y", "ZED", "left bracket", "backslash", "right bracket",
153 "caret",
154 "line",
155 /*096*/ "accent", "a", "b", "c", "d", "e", "f", "g",
156 /*104*/ "h", "i", "j", "k", "l", "m", "n", "o",
157 /*112*/ "p", "q", "r", "s", "t", "u", "v", "w",
158 /*120*/ "x", "y", "zed", "left brace", "bar", "right brace", "tihlduh",
159 /*127*/ "del", "control", "control", "control", "control", "control",
160 "control", "control", "control", "control", "control",
161 /*138*/ "control", "control", "control", "control", "control",
162 "control", "control", "control", "control", "control",
163 "control", "control",
164 /*150*/ "control", "control", "control", "control", "control",
165 "control", "control", "control", "control", "control",
166 /*160*/ "nbsp", "inverted bang",
167 /*162*/ "cents", "pounds", "currency", "yen", "broken bar", "section",
168 /*168*/ "diaeresis", "copyright", "female ordinal", "double left angle",
169 /*172*/ "not", "soft hyphen", "registered", "macron",
170 /*176*/ "degrees", "plus or minus", "super two", "super three",
171 /*180*/ "acute accent", "micro", "pilcrow", "middle dot",
172 /*184*/ "cedilla", "super one", "male ordinal", "double right angle",
173 /*188*/ "one quarter", "one half", "three quarters",
174 "inverted question",
175 /*192*/ "A GRAVE", "A ACUTE", "A CIRCUMFLEX", "A TILDE", "A OOMLAUT",
176 "A RING",
177 /*198*/ "AE", "C CIDELLA", "E GRAVE", "E ACUTE", "E CIRCUMFLEX",
178 "E OOMLAUT",
179 /*204*/ "I GRAVE", "I ACUTE", "I CIRCUMFLEX", "I OOMLAUT", "ETH",
180 "N TILDE",
181 /*210*/ "O GRAVE", "O ACUTE", "O CIRCUMFLEX", "O TILDE", "O OOMLAUT",
182 /*215*/ "multiplied by", "O STROKE", "U GRAVE", "U ACUTE",
183 "U CIRCUMFLEX",
184 /*220*/ "U OOMLAUT", "Y ACUTE", "THORN", "sharp s", "a grave",
185 /*225*/ "a acute", "a circumflex", "a tilde", "a oomlaut", "a ring",
186 /*230*/ "ae", "c cidella", "e grave", "e acute",
187 /*234*/ "e circumflex", "e oomlaut", "i grave", "i acute",
188 "i circumflex",
189 /*239*/ "i oomlaut", "eth", "n tilde", "o grave", "o acute",
190 "o circumflex",
191 /*245*/ "o tilde", "o oomlaut", "divided by", "o stroke", "u grave",
192 "u acute",
193 /* 251 */ "u circumflex", "u oomlaut", "y acute", "thorn", "y oomlaut"
194 };
195
196 /* array of 256 u_short (one for each character)
197 * initialized to default_chartab and user selectable via
198 * /sys/module/speakup/parameters/chartab
199 */
200 u_short spk_chartab[256];
201
202 static u_short default_chartab[256] = {
203 B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 0-7 */
204 B_CTL, B_CTL, A_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 8-15 */
205 B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /*16-23 */
206 B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 24-31 */
207 WDLM, A_PUNC, PUNC, PUNC, PUNC, PUNC, PUNC, A_PUNC, /* !"#$%&' */
208 PUNC, PUNC, PUNC, PUNC, A_PUNC, A_PUNC, A_PUNC, PUNC, /* ()*+, -./ */
209 NUM, NUM, NUM, NUM, NUM, NUM, NUM, NUM, /* 01234567 */
210 NUM, NUM, A_PUNC, PUNC, PUNC, PUNC, PUNC, A_PUNC, /* 89:;<=>? */
211 PUNC, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* @ABCDEFG */
212 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* HIJKLMNO */
213 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* PQRSTUVW */
214 A_CAP, A_CAP, A_CAP, PUNC, PUNC, PUNC, PUNC, PUNC, /* XYZ[\]^_ */
215 PUNC, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* `abcdefg */
216 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* hijklmno */
217 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* pqrstuvw */
218 ALPHA, ALPHA, ALPHA, PUNC, PUNC, PUNC, PUNC, 0, /* xyz{|}~ */
219 B_CAPSYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 128-134 */
220 B_SYM, /* 135 */
221 B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 136-142 */
222 B_CAPSYM, /* 143 */
223 B_CAPSYM, B_CAPSYM, B_SYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, /* 144-150 */
224 B_SYM, /* 151 */
225 B_SYM, B_SYM, B_CAPSYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, /*152-158 */
226 B_SYM, /* 159 */
227 WDLM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_CAPSYM, /* 160-166 */
228 B_SYM, /* 167 */
229 B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 168-175 */
230 B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 176-183 */
231 B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 184-191 */
232 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* 192-199 */
233 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* 200-207 */
234 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, B_SYM, /* 208-215 */
235 A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, ALPHA, /* 216-223 */
236 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* 224-231 */
237 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* 232-239 */
238 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, B_SYM, /* 240-247 */
239 ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA /* 248-255 */
240 };
241
242 struct task_struct *speakup_task;
243 struct bleep spk_unprocessed_sound;
244 static int spk_keydown;
245 static u_char spk_lastkey, spk_close_press, keymap_flags;
246 static u_char last_keycode, this_speakup_key;
247 static u_long last_spk_jiffy;
248
249 struct st_spk_t *speakup_console[MAX_NR_CONSOLES];
250
251 DEFINE_MUTEX(spk_mutex);
252
253 static int keyboard_notifier_call(struct notifier_block *,
254 unsigned long code, void *param);
255
256 static struct notifier_block keyboard_notifier_block = {
257 .notifier_call = keyboard_notifier_call,
258 };
259
260 static int vt_notifier_call(struct notifier_block *,
261 unsigned long code, void *param);
262
263 static struct notifier_block vt_notifier_block = {
264 .notifier_call = vt_notifier_call,
265 };
266
267 static unsigned char get_attributes(struct vc_data *vc, u16 *pos)
268 {
269 pos = screen_pos(vc, pos - (u16 *)vc->vc_origin, 1);
270 return (u_char) (scr_readw(pos) >> 8);
271 }
272
273 static void speakup_date(struct vc_data *vc)
274 {
275 spk_x = spk_cx = vc->vc_x;
276 spk_y = spk_cy = vc->vc_y;
277 spk_pos = spk_cp = vc->vc_pos;
278 spk_old_attr = spk_attr;
279 spk_attr = get_attributes(vc, (u_short *)spk_pos);
280 }
281
282 static void bleep(u_short val)
283 {
284 static const short vals[] = {
285 350, 370, 392, 414, 440, 466, 491, 523, 554, 587, 619, 659
286 };
287 short freq;
288 int time = spk_bleep_time;
289
290 freq = vals[val % 12];
291 if (val > 11)
292 freq *= (1 << (val / 12));
293 spk_unprocessed_sound.freq = freq;
294 spk_unprocessed_sound.jiffies = msecs_to_jiffies(time);
295 spk_unprocessed_sound.active = 1;
296 /* We can only have 1 active sound at a time. */
297 }
298
299 static void speakup_shut_up(struct vc_data *vc)
300 {
301 if (spk_killed)
302 return;
303 spk_shut_up |= 0x01;
304 spk_parked &= 0xfe;
305 speakup_date(vc);
306 if (synth != NULL)
307 spk_do_flush();
308 }
309
310 static void speech_kill(struct vc_data *vc)
311 {
312 char val = synth->is_alive(synth);
313
314 if (val == 0)
315 return;
316
317 /* re-enables synth, if disabled */
318 if (val == 2 || spk_killed) {
319 /* dead */
320 spk_shut_up &= ~0x40;
321 synth_printf("%s\n", spk_msg_get(MSG_IAM_ALIVE));
322 } else {
323 synth_printf("%s\n", spk_msg_get(MSG_YOU_KILLED_SPEAKUP));
324 spk_shut_up |= 0x40;
325 }
326 }
327
328 static void speakup_off(struct vc_data *vc)
329 {
330 if (spk_shut_up & 0x80) {
331 spk_shut_up &= 0x7f;
332 synth_printf("%s\n", spk_msg_get(MSG_HEY_THATS_BETTER));
333 } else {
334 spk_shut_up |= 0x80;
335 synth_printf("%s\n", spk_msg_get(MSG_YOU_TURNED_ME_OFF));
336 }
337 speakup_date(vc);
338 }
339
340 static void speakup_parked(struct vc_data *vc)
341 {
342 if (spk_parked & 0x80) {
343 spk_parked = 0;
344 synth_printf("%s\n", spk_msg_get(MSG_UNPARKED));
345 } else {
346 spk_parked |= 0x80;
347 synth_printf("%s\n", spk_msg_get(MSG_PARKED));
348 }
349 }
350
351 static void speakup_cut(struct vc_data *vc)
352 {
353 static const char err_buf[] = "set selection failed";
354 int ret;
355
356 if (!mark_cut_flag) {
357 mark_cut_flag = 1;
358 spk_xs = (u_short) spk_x;
359 spk_ys = (u_short) spk_y;
360 spk_sel_cons = vc;
361 synth_printf("%s\n", spk_msg_get(MSG_MARK));
362 return;
363 }
364 spk_xe = (u_short) spk_x;
365 spk_ye = (u_short) spk_y;
366 mark_cut_flag = 0;
367 synth_printf("%s\n", spk_msg_get(MSG_CUT));
368
369 speakup_clear_selection();
370 ret = speakup_set_selection(tty);
371
372 switch (ret) {
373 case 0:
374 break; /* no error */
375 case -EFAULT:
376 pr_warn("%sEFAULT\n", err_buf);
377 break;
378 case -EINVAL:
379 pr_warn("%sEINVAL\n", err_buf);
380 break;
381 case -ENOMEM:
382 pr_warn("%sENOMEM\n", err_buf);
383 break;
384 }
385 }
386
387 static void speakup_paste(struct vc_data *vc)
388 {
389 if (mark_cut_flag) {
390 mark_cut_flag = 0;
391 synth_printf("%s\n", spk_msg_get(MSG_MARK_CLEARED));
392 } else {
393 synth_printf("%s\n", spk_msg_get(MSG_PASTE));
394 speakup_paste_selection(tty);
395 }
396 }
397
398 static void say_attributes(struct vc_data *vc)
399 {
400 int fg = spk_attr & 0x0f;
401 int bg = spk_attr >> 4;
402
403 if (fg > 8) {
404 synth_printf("%s ", spk_msg_get(MSG_BRIGHT));
405 fg -= 8;
406 }
407 synth_printf("%s", spk_msg_get(MSG_COLORS_START + fg));
408 if (bg > 7) {
409 synth_printf(" %s ", spk_msg_get(MSG_ON_BLINKING));
410 bg -= 8;
411 } else
412 synth_printf(" %s ", spk_msg_get(MSG_ON));
413 synth_printf("%s\n", spk_msg_get(MSG_COLORS_START + bg));
414 }
415
416 enum {
417 edge_top = 1,
418 edge_bottom,
419 edge_left,
420 edge_right,
421 edge_quiet
422 };
423
424 static void announce_edge(struct vc_data *vc, int msg_id)
425 {
426 if (spk_bleeps & 1)
427 bleep(spk_y);
428 if ((spk_bleeps & 2) && (msg_id < edge_quiet))
429 synth_printf("%s\n",
430 spk_msg_get(MSG_EDGE_MSGS_START + msg_id - 1));
431 }
432
433 static void speak_char(u_char ch)
434 {
435 char *cp = spk_characters[ch];
436 struct var_t *direct = spk_get_var(DIRECT);
437
438 if (direct && direct->u.n.value) {
439 if (IS_CHAR(ch, B_CAP)) {
440 spk_pitch_shift++;
441 synth_printf("%s", spk_str_caps_start);
442 }
443 synth_printf("%c", ch);
444 if (IS_CHAR(ch, B_CAP))
445 synth_printf("%s", spk_str_caps_stop);
446 return;
447 }
448 if (cp == NULL) {
449 pr_info("speak_char: cp == NULL!\n");
450 return;
451 }
452 synth_buffer_add(SPACE);
453 if (IS_CHAR(ch, B_CAP)) {
454 spk_pitch_shift++;
455 synth_printf("%s", spk_str_caps_start);
456 synth_printf("%s", cp);
457 synth_printf("%s", spk_str_caps_stop);
458 } else {
459 if (*cp == '^') {
460 synth_printf("%s", spk_msg_get(MSG_CTRL));
461 cp++;
462 }
463 synth_printf("%s", cp);
464 }
465 synth_buffer_add(SPACE);
466 }
467
468 static u16 get_char(struct vc_data *vc, u16 *pos, u_char *attribs)
469 {
470 u16 ch = ' ';
471
472 if (vc && pos) {
473 u16 w;
474 u16 c;
475
476 pos = screen_pos(vc, pos - (u16 *)vc->vc_origin, 1);
477 w = scr_readw(pos);
478 c = w & 0xff;
479
480 if (w & vc->vc_hi_font_mask)
481 c |= 0x100;
482
483 ch = inverse_translate(vc, c, 0);
484 *attribs = (w & 0xff00) >> 8;
485 }
486 return ch;
487 }
488
489 static void say_char(struct vc_data *vc)
490 {
491 u_short ch;
492
493 spk_old_attr = spk_attr;
494 ch = get_char(vc, (u_short *) spk_pos, &spk_attr);
495 if (spk_attr != spk_old_attr) {
496 if (spk_attrib_bleep & 1)
497 bleep(spk_y);
498 if (spk_attrib_bleep & 2)
499 say_attributes(vc);
500 }
501 speak_char(ch & 0xff);
502 }
503
504 static void say_phonetic_char(struct vc_data *vc)
505 {
506 u_short ch;
507
508 spk_old_attr = spk_attr;
509 ch = get_char(vc, (u_short *) spk_pos, &spk_attr);
510 if (isascii(ch) && isalpha(ch)) {
511 ch &= 0x1f;
512 synth_printf("%s\n", phonetic[--ch]);
513 } else {
514 if (IS_CHAR(ch, B_NUM))
515 synth_printf("%s ", spk_msg_get(MSG_NUMBER));
516 speak_char(ch);
517 }
518 }
519
520 static void say_prev_char(struct vc_data *vc)
521 {
522 spk_parked |= 0x01;
523 if (spk_x == 0) {
524 announce_edge(vc, edge_left);
525 return;
526 }
527 spk_x--;
528 spk_pos -= 2;
529 say_char(vc);
530 }
531
532 static void say_next_char(struct vc_data *vc)
533 {
534 spk_parked |= 0x01;
535 if (spk_x == vc->vc_cols - 1) {
536 announce_edge(vc, edge_right);
537 return;
538 }
539 spk_x++;
540 spk_pos += 2;
541 say_char(vc);
542 }
543
544 /* get_word - will first check to see if the character under the
545 * reading cursor is a space and if spk_say_word_ctl is true it will
546 * return the word space. If spk_say_word_ctl is not set it will check to
547 * see if there is a word starting on the next position to the right
548 * and return that word if it exists. If it does not exist it will
549 * move left to the beginning of any previous word on the line or the
550 * beginning off the line whichever comes first..
551 */
552
553 static u_long get_word(struct vc_data *vc)
554 {
555 u_long cnt = 0, tmpx = spk_x, tmp_pos = spk_pos;
556 char ch;
557 u_short attr_ch;
558 u_char temp;
559
560 spk_old_attr = spk_attr;
561 ch = (char)get_char(vc, (u_short *) tmp_pos, &temp);
562
563 /* decided to take out the sayword if on a space (mis-information */
564 if (spk_say_word_ctl && ch == SPACE) {
565 *buf = '\0';
566 synth_printf("%s\n", spk_msg_get(MSG_SPACE));
567 return 0;
568 } else if ((tmpx < vc->vc_cols - 2)
569 && (ch == SPACE || ch == 0 || IS_WDLM(ch))
570 && ((char)get_char(vc, (u_short *) &tmp_pos + 1, &temp) >
571 SPACE)) {
572 tmp_pos += 2;
573 tmpx++;
574 } else
575 while (tmpx > 0) {
576 ch = (char)get_char(vc, (u_short *) tmp_pos - 1, &temp);
577 if ((ch == SPACE || ch == 0 || IS_WDLM(ch))
578 && ((char)get_char(vc, (u_short *) tmp_pos, &temp) >
579 SPACE))
580 break;
581 tmp_pos -= 2;
582 tmpx--;
583 }
584 attr_ch = get_char(vc, (u_short *) tmp_pos, &spk_attr);
585 buf[cnt++] = attr_ch & 0xff;
586 while (tmpx < vc->vc_cols - 1) {
587 tmp_pos += 2;
588 tmpx++;
589 ch = (char)get_char(vc, (u_short *) tmp_pos, &temp);
590 if ((ch == SPACE) || ch == 0
591 || (IS_WDLM(buf[cnt - 1]) && (ch > SPACE)))
592 break;
593 buf[cnt++] = ch;
594 }
595 buf[cnt] = '\0';
596 return cnt;
597 }
598
599 static void say_word(struct vc_data *vc)
600 {
601 u_long cnt = get_word(vc);
602 u_short saved_punc_mask = spk_punc_mask;
603
604 if (cnt == 0)
605 return;
606 spk_punc_mask = PUNC;
607 buf[cnt++] = SPACE;
608 spkup_write(buf, cnt);
609 spk_punc_mask = saved_punc_mask;
610 }
611
612 static void say_prev_word(struct vc_data *vc)
613 {
614 u_char temp;
615 char ch;
616 u_short edge_said = 0, last_state = 0, state = 0;
617
618 spk_parked |= 0x01;
619
620 if (spk_x == 0) {
621 if (spk_y == 0) {
622 announce_edge(vc, edge_top);
623 return;
624 }
625 spk_y--;
626 spk_x = vc->vc_cols;
627 edge_said = edge_quiet;
628 }
629 while (1) {
630 if (spk_x == 0) {
631 if (spk_y == 0) {
632 edge_said = edge_top;
633 break;
634 }
635 if (edge_said != edge_quiet)
636 edge_said = edge_left;
637 if (state > 0)
638 break;
639 spk_y--;
640 spk_x = vc->vc_cols - 1;
641 } else
642 spk_x--;
643 spk_pos -= 2;
644 ch = (char)get_char(vc, (u_short *) spk_pos, &temp);
645 if (ch == SPACE || ch == 0)
646 state = 0;
647 else if (IS_WDLM(ch))
648 state = 1;
649 else
650 state = 2;
651 if (state < last_state) {
652 spk_pos += 2;
653 spk_x++;
654 break;
655 }
656 last_state = state;
657 }
658 if (spk_x == 0 && edge_said == edge_quiet)
659 edge_said = edge_left;
660 if (edge_said > 0 && edge_said < edge_quiet)
661 announce_edge(vc, edge_said);
662 say_word(vc);
663 }
664
665 static void say_next_word(struct vc_data *vc)
666 {
667 u_char temp;
668 char ch;
669 u_short edge_said = 0, last_state = 2, state = 0;
670
671 spk_parked |= 0x01;
672 if (spk_x == vc->vc_cols - 1 && spk_y == vc->vc_rows - 1) {
673 announce_edge(vc, edge_bottom);
674 return;
675 }
676 while (1) {
677 ch = (char)get_char(vc, (u_short *) spk_pos, &temp);
678 if (ch == SPACE || ch == 0)
679 state = 0;
680 else if (IS_WDLM(ch))
681 state = 1;
682 else
683 state = 2;
684 if (state > last_state)
685 break;
686 if (spk_x >= vc->vc_cols - 1) {
687 if (spk_y == vc->vc_rows - 1) {
688 edge_said = edge_bottom;
689 break;
690 }
691 state = 0;
692 spk_y++;
693 spk_x = 0;
694 edge_said = edge_right;
695 } else
696 spk_x++;
697 spk_pos += 2;
698 last_state = state;
699 }
700 if (edge_said > 0)
701 announce_edge(vc, edge_said);
702 say_word(vc);
703 }
704
705 static void spell_word(struct vc_data *vc)
706 {
707 static char const *delay_str[] = { "", ",", ".", ". .", ". . ." };
708 char *cp = buf, *str_cap = spk_str_caps_stop;
709 char *cp1, *last_cap = spk_str_caps_stop;
710 u_char ch;
711
712 if (!get_word(vc))
713 return;
714 while ((ch = (u_char) *cp)) {
715 if (cp != buf)
716 synth_printf(" %s ", delay_str[spk_spell_delay]);
717 if (IS_CHAR(ch, B_CAP)) {
718 str_cap = spk_str_caps_start;
719 if (*spk_str_caps_stop)
720 spk_pitch_shift++;
721 else /* synth has no pitch */
722 last_cap = spk_str_caps_stop;
723 } else
724 str_cap = spk_str_caps_stop;
725 if (str_cap != last_cap) {
726 synth_printf("%s", str_cap);
727 last_cap = str_cap;
728 }
729 if (this_speakup_key == SPELL_PHONETIC
730 && (isascii(ch) && isalpha(ch))) {
731 ch &= 31;
732 cp1 = phonetic[--ch];
733 } else {
734 cp1 = spk_characters[ch];
735 if (*cp1 == '^') {
736 synth_printf("%s", spk_msg_get(MSG_CTRL));
737 cp1++;
738 }
739 }
740 synth_printf("%s", cp1);
741 cp++;
742 }
743 if (str_cap != spk_str_caps_stop)
744 synth_printf("%s", spk_str_caps_stop);
745 }
746
747 static int get_line(struct vc_data *vc)
748 {
749 u_long tmp = spk_pos - (spk_x * 2);
750 int i = 0;
751 u_char tmp2;
752
753 spk_old_attr = spk_attr;
754 spk_attr = get_attributes(vc, (u_short *)spk_pos);
755 for (i = 0; i < vc->vc_cols; i++) {
756 buf[i] = (u_char) get_char(vc, (u_short *) tmp, &tmp2);
757 tmp += 2;
758 }
759 for (--i; i >= 0; i--)
760 if (buf[i] != SPACE)
761 break;
762 return ++i;
763 }
764
765 static void say_line(struct vc_data *vc)
766 {
767 int i = get_line(vc);
768 char *cp;
769 u_short saved_punc_mask = spk_punc_mask;
770
771 if (i == 0) {
772 synth_printf("%s\n", spk_msg_get(MSG_BLANK));
773 return;
774 }
775 buf[i++] = '\n';
776 if (this_speakup_key == SAY_LINE_INDENT) {
777 cp = buf;
778 while (*cp == SPACE)
779 cp++;
780 synth_printf("%d, ", (cp - buf) + 1);
781 }
782 spk_punc_mask = spk_punc_masks[spk_reading_punc];
783 spkup_write(buf, i);
784 spk_punc_mask = saved_punc_mask;
785 }
786
787 static void say_prev_line(struct vc_data *vc)
788 {
789 spk_parked |= 0x01;
790 if (spk_y == 0) {
791 announce_edge(vc, edge_top);
792 return;
793 }
794 spk_y--;
795 spk_pos -= vc->vc_size_row;
796 say_line(vc);
797 }
798
799 static void say_next_line(struct vc_data *vc)
800 {
801 spk_parked |= 0x01;
802 if (spk_y == vc->vc_rows - 1) {
803 announce_edge(vc, edge_bottom);
804 return;
805 }
806 spk_y++;
807 spk_pos += vc->vc_size_row;
808 say_line(vc);
809 }
810
811 static int say_from_to(struct vc_data *vc, u_long from, u_long to,
812 int read_punc)
813 {
814 int i = 0;
815 u_char tmp;
816 u_short saved_punc_mask = spk_punc_mask;
817
818 spk_old_attr = spk_attr;
819 spk_attr = get_attributes(vc, (u_short *)from);
820 while (from < to) {
821 buf[i++] = (char)get_char(vc, (u_short *) from, &tmp);
822 from += 2;
823 if (i >= vc->vc_size_row)
824 break;
825 }
826 for (--i; i >= 0; i--)
827 if (buf[i] != SPACE)
828 break;
829 buf[++i] = SPACE;
830 buf[++i] = '\0';
831 if (i < 1)
832 return i;
833 if (read_punc)
834 spk_punc_mask = spk_punc_info[spk_reading_punc].mask;
835 spkup_write(buf, i);
836 if (read_punc)
837 spk_punc_mask = saved_punc_mask;
838 return i - 1;
839 }
840
841 static void say_line_from_to(struct vc_data *vc, u_long from, u_long to,
842 int read_punc)
843 {
844 u_long start = vc->vc_origin + (spk_y * vc->vc_size_row);
845 u_long end = start + (to * 2);
846
847 start += from * 2;
848 if (say_from_to(vc, start, end, read_punc) <= 0)
849 if (cursor_track != read_all_mode)
850 synth_printf("%s\n", spk_msg_get(MSG_BLANK));
851 }
852
853 /* Sentence Reading Commands */
854
855 static int currsentence;
856 static int numsentences[2];
857 static char *sentbufend[2];
858 static char *sentmarks[2][10];
859 static int currbuf;
860 static int bn;
861 static char sentbuf[2][256];
862
863 static int say_sentence_num(int num, int prev)
864 {
865 bn = currbuf;
866 currsentence = num + 1;
867 if (prev && --bn == -1)
868 bn = 1;
869
870 if (num > numsentences[bn])
871 return 0;
872
873 spkup_write(sentmarks[bn][num], sentbufend[bn] - sentmarks[bn][num]);
874 return 1;
875 }
876
877 static int get_sentence_buf(struct vc_data *vc, int read_punc)
878 {
879 u_long start, end;
880 int i, bn;
881 u_char tmp;
882
883 currbuf++;
884 if (currbuf == 2)
885 currbuf = 0;
886 bn = currbuf;
887 start = vc->vc_origin + ((spk_y) * vc->vc_size_row);
888 end = vc->vc_origin + ((spk_y) * vc->vc_size_row) + vc->vc_cols * 2;
889
890 numsentences[bn] = 0;
891 sentmarks[bn][0] = &sentbuf[bn][0];
892 i = 0;
893 spk_old_attr = spk_attr;
894 spk_attr = get_attributes(vc, (u_short *)start);
895
896 while (start < end) {
897 sentbuf[bn][i] = (char)get_char(vc, (u_short *) start, &tmp);
898 if (i > 0) {
899 if (sentbuf[bn][i] == SPACE && sentbuf[bn][i - 1] == '.'
900 && numsentences[bn] < 9) {
901 /* Sentence Marker */
902 numsentences[bn]++;
903 sentmarks[bn][numsentences[bn]] =
904 &sentbuf[bn][i];
905 }
906 }
907 i++;
908 start += 2;
909 if (i >= vc->vc_size_row)
910 break;
911 }
912
913 for (--i; i >= 0; i--)
914 if (sentbuf[bn][i] != SPACE)
915 break;
916
917 if (i < 1)
918 return -1;
919
920 sentbuf[bn][++i] = SPACE;
921 sentbuf[bn][++i] = '\0';
922
923 sentbufend[bn] = &sentbuf[bn][i];
924 return numsentences[bn];
925 }
926
927 static void say_screen_from_to(struct vc_data *vc, u_long from, u_long to)
928 {
929 u_long start = vc->vc_origin, end;
930
931 if (from > 0)
932 start += from * vc->vc_size_row;
933 if (to > vc->vc_rows)
934 to = vc->vc_rows;
935 end = vc->vc_origin + (to * vc->vc_size_row);
936 for (from = start; from < end; from = to) {
937 to = from + vc->vc_size_row;
938 say_from_to(vc, from, to, 1);
939 }
940 }
941
942 static void say_screen(struct vc_data *vc)
943 {
944 say_screen_from_to(vc, 0, vc->vc_rows);
945 }
946
947 static void speakup_win_say(struct vc_data *vc)
948 {
949 u_long start, end, from, to;
950
951 if (win_start < 2) {
952 synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW));
953 return;
954 }
955 start = vc->vc_origin + (win_top * vc->vc_size_row);
956 end = vc->vc_origin + (win_bottom * vc->vc_size_row);
957 while (start <= end) {
958 from = start + (win_left * 2);
959 to = start + (win_right * 2);
960 say_from_to(vc, from, to, 1);
961 start += vc->vc_size_row;
962 }
963 }
964
965 static void top_edge(struct vc_data *vc)
966 {
967 spk_parked |= 0x01;
968 spk_pos = vc->vc_origin + 2 * spk_x;
969 spk_y = 0;
970 say_line(vc);
971 }
972
973 static void bottom_edge(struct vc_data *vc)
974 {
975 spk_parked |= 0x01;
976 spk_pos += (vc->vc_rows - spk_y - 1) * vc->vc_size_row;
977 spk_y = vc->vc_rows - 1;
978 say_line(vc);
979 }
980
981 static void left_edge(struct vc_data *vc)
982 {
983 spk_parked |= 0x01;
984 spk_pos -= spk_x * 2;
985 spk_x = 0;
986 say_char(vc);
987 }
988
989 static void right_edge(struct vc_data *vc)
990 {
991 spk_parked |= 0x01;
992 spk_pos += (vc->vc_cols - spk_x - 1) * 2;
993 spk_x = vc->vc_cols - 1;
994 say_char(vc);
995 }
996
997 static void say_first_char(struct vc_data *vc)
998 {
999 int i, len = get_line(vc);
1000 u_char ch;
1001
1002 spk_parked |= 0x01;
1003 if (len == 0) {
1004 synth_printf("%s\n", spk_msg_get(MSG_BLANK));
1005 return;
1006 }
1007 for (i = 0; i < len; i++)
1008 if (buf[i] != SPACE)
1009 break;
1010 ch = buf[i];
1011 spk_pos -= (spk_x - i) * 2;
1012 spk_x = i;
1013 synth_printf("%d, ", ++i);
1014 speak_char(ch);
1015 }
1016
1017 static void say_last_char(struct vc_data *vc)
1018 {
1019 int len = get_line(vc);
1020 u_char ch;
1021
1022 spk_parked |= 0x01;
1023 if (len == 0) {
1024 synth_printf("%s\n", spk_msg_get(MSG_BLANK));
1025 return;
1026 }
1027 ch = buf[--len];
1028 spk_pos -= (spk_x - len) * 2;
1029 spk_x = len;
1030 synth_printf("%d, ", ++len);
1031 speak_char(ch);
1032 }
1033
1034 static void say_position(struct vc_data *vc)
1035 {
1036 synth_printf(spk_msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1,
1037 vc->vc_num + 1);
1038 synth_printf("\n");
1039 }
1040
1041 /* Added by brianb */
1042 static void say_char_num(struct vc_data *vc)
1043 {
1044 u_char tmp;
1045 u_short ch = get_char(vc, (u_short *) spk_pos, &tmp);
1046
1047 ch &= 0xff;
1048 synth_printf(spk_msg_get(MSG_CHAR_INFO), ch, ch);
1049 }
1050
1051 /* these are stub functions to keep keyboard.c happy. */
1052
1053 static void say_from_top(struct vc_data *vc)
1054 {
1055 say_screen_from_to(vc, 0, spk_y);
1056 }
1057
1058 static void say_to_bottom(struct vc_data *vc)
1059 {
1060 say_screen_from_to(vc, spk_y, vc->vc_rows);
1061 }
1062
1063 static void say_from_left(struct vc_data *vc)
1064 {
1065 say_line_from_to(vc, 0, spk_x, 1);
1066 }
1067
1068 static void say_to_right(struct vc_data *vc)
1069 {
1070 say_line_from_to(vc, spk_x, vc->vc_cols, 1);
1071 }
1072
1073 /* end of stub functions. */
1074
1075 static void spkup_write(const char *in_buf, int count)
1076 {
1077 static int rep_count;
1078 static u_char ch = '\0', old_ch = '\0';
1079 static u_short char_type, last_type;
1080 int in_count = count;
1081
1082 spk_keydown = 0;
1083 while (count--) {
1084 if (cursor_track == read_all_mode) {
1085 /* Insert Sentence Index */
1086 if ((in_buf == sentmarks[bn][currsentence]) &&
1087 (currsentence <= numsentences[bn]))
1088 synth_insert_next_index(currsentence++);
1089 }
1090 ch = (u_char) *in_buf++;
1091 char_type = spk_chartab[ch];
1092 if (ch == old_ch && !(char_type & B_NUM)) {
1093 if (++rep_count > 2)
1094 continue;
1095 } else {
1096 if ((last_type & CH_RPT) && rep_count > 2) {
1097 synth_printf(" ");
1098 synth_printf(spk_msg_get(MSG_REPEAT_DESC),
1099 ++rep_count);
1100 synth_printf(" ");
1101 }
1102 rep_count = 0;
1103 }
1104 if (ch == spk_lastkey) {
1105 rep_count = 0;
1106 if (spk_key_echo == 1 && ch >= MINECHOCHAR)
1107 speak_char(ch);
1108 } else if (char_type & B_ALPHA) {
1109 if ((synth_flags & SF_DEC) && (last_type & PUNC))
1110 synth_buffer_add(SPACE);
1111 synth_printf("%c", ch);
1112 } else if (char_type & B_NUM) {
1113 rep_count = 0;
1114 synth_printf("%c", ch);
1115 } else if (char_type & spk_punc_mask) {
1116 speak_char(ch);
1117 char_type &= ~PUNC; /* for dec nospell processing */
1118 } else if (char_type & SYNTH_OK) {
1119 /* these are usually puncts like . and , which synth
1120 * needs for expression.
1121 * suppress multiple to get rid of long pauses and
1122 * clear repeat count
1123 * so if someone has
1124 * repeats on you don't get nothing repeated count
1125 */
1126 if (ch != old_ch)
1127 synth_printf("%c", ch);
1128 else
1129 rep_count = 0;
1130 } else {
1131 /* send space and record position, if next is num overwrite space */
1132 if (old_ch != ch)
1133 synth_buffer_add(SPACE);
1134 else
1135 rep_count = 0;
1136 }
1137 old_ch = ch;
1138 last_type = char_type;
1139 }
1140 spk_lastkey = 0;
1141 if (in_count > 2 && rep_count > 2) {
1142 if (last_type & CH_RPT) {
1143 synth_printf(" ");
1144 synth_printf(spk_msg_get(MSG_REPEAT_DESC2),
1145 ++rep_count);
1146 synth_printf(" ");
1147 }
1148 rep_count = 0;
1149 }
1150 }
1151
1152 static const int NUM_CTL_LABELS = (MSG_CTL_END - MSG_CTL_START + 1);
1153
1154 static void read_all_doc(struct vc_data *vc);
1155 static void cursor_done(u_long data);
1156 static DEFINE_TIMER(cursor_timer, cursor_done, 0, 0);
1157
1158 static void do_handle_shift(struct vc_data *vc, u_char value, char up_flag)
1159 {
1160 unsigned long flags;
1161
1162 if (synth == NULL || up_flag || spk_killed)
1163 return;
1164 spin_lock_irqsave(&speakup_info.spinlock, flags);
1165 if (cursor_track == read_all_mode) {
1166 switch (value) {
1167 case KVAL(K_SHIFT):
1168 del_timer(&cursor_timer);
1169 spk_shut_up &= 0xfe;
1170 spk_do_flush();
1171 read_all_doc(vc);
1172 break;
1173 case KVAL(K_CTRL):
1174 del_timer(&cursor_timer);
1175 cursor_track = prev_cursor_track;
1176 spk_shut_up &= 0xfe;
1177 spk_do_flush();
1178 break;
1179 }
1180 } else {
1181 spk_shut_up &= 0xfe;
1182 spk_do_flush();
1183 }
1184 if (spk_say_ctrl && value < NUM_CTL_LABELS)
1185 synth_printf("%s", spk_msg_get(MSG_CTL_START + value));
1186 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1187 }
1188
1189 static void do_handle_latin(struct vc_data *vc, u_char value, char up_flag)
1190 {
1191 unsigned long flags;
1192
1193 spin_lock_irqsave(&speakup_info.spinlock, flags);
1194 if (up_flag) {
1195 spk_lastkey = spk_keydown = 0;
1196 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1197 return;
1198 }
1199 if (synth == NULL || spk_killed) {
1200 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1201 return;
1202 }
1203 spk_shut_up &= 0xfe;
1204 spk_lastkey = value;
1205 spk_keydown++;
1206 spk_parked &= 0xfe;
1207 if (spk_key_echo == 2 && value >= MINECHOCHAR)
1208 speak_char(value);
1209 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1210 }
1211
1212 int spk_set_key_info(const u_char *key_info, u_char *k_buffer)
1213 {
1214 int i = 0, states, key_data_len;
1215 const u_char *cp = key_info;
1216 u_char *cp1 = k_buffer;
1217 u_char ch, version, num_keys;
1218
1219 version = *cp++;
1220 if (version != KEY_MAP_VER)
1221 return -1;
1222 num_keys = *cp;
1223 states = (int)cp[1];
1224 key_data_len = (states + 1) * (num_keys + 1);
1225 if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf))
1226 return -2;
1227 memset(k_buffer, 0, SHIFT_TBL_SIZE);
1228 memset(spk_our_keys, 0, sizeof(spk_our_keys));
1229 spk_shift_table = k_buffer;
1230 spk_our_keys[0] = spk_shift_table;
1231 cp1 += SHIFT_TBL_SIZE;
1232 memcpy(cp1, cp, key_data_len + 3);
1233 /* get num_keys, states and data */
1234 cp1 += 2; /* now pointing at shift states */
1235 for (i = 1; i <= states; i++) {
1236 ch = *cp1++;
1237 if (ch >= SHIFT_TBL_SIZE)
1238 return -3;
1239 spk_shift_table[ch] = i;
1240 }
1241 keymap_flags = *cp1++;
1242 while ((ch = *cp1)) {
1243 if (ch >= MAX_KEY)
1244 return -4;
1245 spk_our_keys[ch] = cp1;
1246 cp1 += states + 1;
1247 }
1248 return 0;
1249 }
1250
1251 static struct var_t spk_vars[] = {
1252 /* bell must be first to set high limit */
1253 {BELL_POS, .u.n = {NULL, 0, 0, 0, 0, 0, NULL} },
1254 {SPELL_DELAY, .u.n = {NULL, 0, 0, 4, 0, 0, NULL} },
1255 {ATTRIB_BLEEP, .u.n = {NULL, 1, 0, 3, 0, 0, NULL} },
1256 {BLEEPS, .u.n = {NULL, 3, 0, 3, 0, 0, NULL} },
1257 {BLEEP_TIME, .u.n = {NULL, 30, 1, 200, 0, 0, NULL} },
1258 {PUNC_LEVEL, .u.n = {NULL, 1, 0, 4, 0, 0, NULL} },
1259 {READING_PUNC, .u.n = {NULL, 1, 0, 4, 0, 0, NULL} },
1260 {CURSOR_TIME, .u.n = {NULL, 120, 50, 600, 0, 0, NULL} },
1261 {SAY_CONTROL, TOGGLE_0},
1262 {SAY_WORD_CTL, TOGGLE_0},
1263 {NO_INTERRUPT, TOGGLE_0},
1264 {KEY_ECHO, .u.n = {NULL, 1, 0, 2, 0, 0, NULL} },
1265 V_LAST_VAR
1266 };
1267
1268 static void toggle_cursoring(struct vc_data *vc)
1269 {
1270 if (cursor_track == read_all_mode)
1271 cursor_track = prev_cursor_track;
1272 if (++cursor_track >= CT_Max)
1273 cursor_track = 0;
1274 synth_printf("%s\n", spk_msg_get(MSG_CURSOR_MSGS_START + cursor_track));
1275 }
1276
1277 void spk_reset_default_chars(void)
1278 {
1279 int i;
1280
1281 /* First, free any non-default */
1282 for (i = 0; i < 256; i++) {
1283 if ((spk_characters[i] != NULL)
1284 && (spk_characters[i] != spk_default_chars[i]))
1285 kfree(spk_characters[i]);
1286 }
1287
1288 memcpy(spk_characters, spk_default_chars, sizeof(spk_default_chars));
1289 }
1290
1291 void spk_reset_default_chartab(void)
1292 {
1293 memcpy(spk_chartab, default_chartab, sizeof(default_chartab));
1294 }
1295
1296 static const struct st_bits_data *pb_edit;
1297
1298 static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key)
1299 {
1300 short mask = pb_edit->mask, ch_type = spk_chartab[ch];
1301
1302 if (type != KT_LATIN || (ch_type & B_NUM) || ch < SPACE)
1303 return -1;
1304 if (ch == SPACE) {
1305 synth_printf("%s\n", spk_msg_get(MSG_EDIT_DONE));
1306 spk_special_handler = NULL;
1307 return 1;
1308 }
1309 if (mask < PUNC && !(ch_type & PUNC))
1310 return -1;
1311 spk_chartab[ch] ^= mask;
1312 speak_char(ch);
1313 synth_printf(" %s\n",
1314 (spk_chartab[ch] & mask) ? spk_msg_get(MSG_ON) :
1315 spk_msg_get(MSG_OFF));
1316 return 1;
1317 }
1318
1319 /* Allocation concurrency is protected by the console semaphore */
1320 static int speakup_allocate(struct vc_data *vc)
1321 {
1322 int vc_num;
1323
1324 vc_num = vc->vc_num;
1325 if (speakup_console[vc_num] == NULL) {
1326 speakup_console[vc_num] = kzalloc(sizeof(*speakup_console[0]),
1327 GFP_ATOMIC);
1328 if (speakup_console[vc_num] == NULL)
1329 return -ENOMEM;
1330 speakup_date(vc);
1331 } else if (!spk_parked)
1332 speakup_date(vc);
1333
1334 return 0;
1335 }
1336
1337 static void speakup_deallocate(struct vc_data *vc)
1338 {
1339 int vc_num;
1340
1341 vc_num = vc->vc_num;
1342 kfree(speakup_console[vc_num]);
1343 speakup_console[vc_num] = NULL;
1344 }
1345
1346 static u_char is_cursor;
1347 static u_long old_cursor_pos, old_cursor_x, old_cursor_y;
1348 static int cursor_con;
1349
1350 static void reset_highlight_buffers(struct vc_data *);
1351
1352 static int read_all_key;
1353
1354 static void start_read_all_timer(struct vc_data *vc, int command);
1355
1356 enum {
1357 RA_NOTHING,
1358 RA_NEXT_SENT,
1359 RA_PREV_LINE,
1360 RA_NEXT_LINE,
1361 RA_PREV_SENT,
1362 RA_DOWN_ARROW,
1363 RA_TIMER,
1364 RA_FIND_NEXT_SENT,
1365 RA_FIND_PREV_SENT,
1366 };
1367
1368 static void kbd_fakekey2(struct vc_data *vc, int command)
1369 {
1370 del_timer(&cursor_timer);
1371 speakup_fake_down_arrow();
1372 start_read_all_timer(vc, command);
1373 }
1374
1375 static void read_all_doc(struct vc_data *vc)
1376 {
1377 if ((vc->vc_num != fg_console) || synth == NULL || spk_shut_up)
1378 return;
1379 if (!synth_supports_indexing())
1380 return;
1381 if (cursor_track != read_all_mode)
1382 prev_cursor_track = cursor_track;
1383 cursor_track = read_all_mode;
1384 spk_reset_index_count(0);
1385 if (get_sentence_buf(vc, 0) == -1)
1386 kbd_fakekey2(vc, RA_DOWN_ARROW);
1387 else {
1388 say_sentence_num(0, 0);
1389 synth_insert_next_index(0);
1390 start_read_all_timer(vc, RA_TIMER);
1391 }
1392 }
1393
1394 static void stop_read_all(struct vc_data *vc)
1395 {
1396 del_timer(&cursor_timer);
1397 cursor_track = prev_cursor_track;
1398 spk_shut_up &= 0xfe;
1399 spk_do_flush();
1400 }
1401
1402 static void start_read_all_timer(struct vc_data *vc, int command)
1403 {
1404 struct var_t *cursor_timeout;
1405
1406 cursor_con = vc->vc_num;
1407 read_all_key = command;
1408 cursor_timeout = spk_get_var(CURSOR_TIME);
1409 mod_timer(&cursor_timer,
1410 jiffies + msecs_to_jiffies(cursor_timeout->u.n.value));
1411 }
1412
1413 static void handle_cursor_read_all(struct vc_data *vc, int command)
1414 {
1415 int indcount, sentcount, rv, sn;
1416
1417 switch (command) {
1418 case RA_NEXT_SENT:
1419 /* Get Current Sentence */
1420 spk_get_index_count(&indcount, &sentcount);
1421 /*printk("%d %d ", indcount, sentcount); */
1422 spk_reset_index_count(sentcount + 1);
1423 if (indcount == 1) {
1424 if (!say_sentence_num(sentcount + 1, 0)) {
1425 kbd_fakekey2(vc, RA_FIND_NEXT_SENT);
1426 return;
1427 }
1428 synth_insert_next_index(0);
1429 } else {
1430 sn = 0;
1431 if (!say_sentence_num(sentcount + 1, 1)) {
1432 sn = 1;
1433 spk_reset_index_count(sn);
1434 } else
1435 synth_insert_next_index(0);
1436 if (!say_sentence_num(sn, 0)) {
1437 kbd_fakekey2(vc, RA_FIND_NEXT_SENT);
1438 return;
1439 }
1440 synth_insert_next_index(0);
1441 }
1442 start_read_all_timer(vc, RA_TIMER);
1443 break;
1444 case RA_PREV_SENT:
1445 break;
1446 case RA_NEXT_LINE:
1447 read_all_doc(vc);
1448 break;
1449 case RA_PREV_LINE:
1450 break;
1451 case RA_DOWN_ARROW:
1452 if (get_sentence_buf(vc, 0) == -1) {
1453 kbd_fakekey2(vc, RA_DOWN_ARROW);
1454 } else {
1455 say_sentence_num(0, 0);
1456 synth_insert_next_index(0);
1457 start_read_all_timer(vc, RA_TIMER);
1458 }
1459 break;
1460 case RA_FIND_NEXT_SENT:
1461 rv = get_sentence_buf(vc, 0);
1462 if (rv == -1)
1463 read_all_doc(vc);
1464 if (rv == 0)
1465 kbd_fakekey2(vc, RA_FIND_NEXT_SENT);
1466 else {
1467 say_sentence_num(1, 0);
1468 synth_insert_next_index(0);
1469 start_read_all_timer(vc, RA_TIMER);
1470 }
1471 break;
1472 case RA_FIND_PREV_SENT:
1473 break;
1474 case RA_TIMER:
1475 spk_get_index_count(&indcount, &sentcount);
1476 if (indcount < 2)
1477 kbd_fakekey2(vc, RA_DOWN_ARROW);
1478 else
1479 start_read_all_timer(vc, RA_TIMER);
1480 break;
1481 }
1482 }
1483
1484 static int pre_handle_cursor(struct vc_data *vc, u_char value, char up_flag)
1485 {
1486 unsigned long flags;
1487
1488 spin_lock_irqsave(&speakup_info.spinlock, flags);
1489 if (cursor_track == read_all_mode) {
1490 spk_parked &= 0xfe;
1491 if (synth == NULL || up_flag || spk_shut_up) {
1492 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1493 return NOTIFY_STOP;
1494 }
1495 del_timer(&cursor_timer);
1496 spk_shut_up &= 0xfe;
1497 spk_do_flush();
1498 start_read_all_timer(vc, value + 1);
1499 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1500 return NOTIFY_STOP;
1501 }
1502 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1503 return NOTIFY_OK;
1504 }
1505
1506 static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag)
1507 {
1508 unsigned long flags;
1509 struct var_t *cursor_timeout;
1510
1511 spin_lock_irqsave(&speakup_info.spinlock, flags);
1512 spk_parked &= 0xfe;
1513 if (synth == NULL || up_flag || spk_shut_up || cursor_track == CT_Off) {
1514 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1515 return;
1516 }
1517 spk_shut_up &= 0xfe;
1518 if (spk_no_intr)
1519 spk_do_flush();
1520 /* the key press flushes if !no_inter but we want to flush on cursor
1521 * moves regardless of no_inter state
1522 */
1523 is_cursor = value + 1;
1524 old_cursor_pos = vc->vc_pos;
1525 old_cursor_x = vc->vc_x;
1526 old_cursor_y = vc->vc_y;
1527 speakup_console[vc->vc_num]->ht.cy = vc->vc_y;
1528 cursor_con = vc->vc_num;
1529 if (cursor_track == CT_Highlight)
1530 reset_highlight_buffers(vc);
1531 cursor_timeout = spk_get_var(CURSOR_TIME);
1532 mod_timer(&cursor_timer,
1533 jiffies + msecs_to_jiffies(cursor_timeout->u.n.value));
1534 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1535 }
1536
1537 static void update_color_buffer(struct vc_data *vc, const char *ic, int len)
1538 {
1539 int i, bi, hi;
1540 int vc_num = vc->vc_num;
1541
1542 bi = (vc->vc_attr & 0x70) >> 4;
1543 hi = speakup_console[vc_num]->ht.highsize[bi];
1544
1545 i = 0;
1546 if (speakup_console[vc_num]->ht.highsize[bi] == 0) {
1547 speakup_console[vc_num]->ht.rpos[bi] = vc->vc_pos;
1548 speakup_console[vc_num]->ht.rx[bi] = vc->vc_x;
1549 speakup_console[vc_num]->ht.ry[bi] = vc->vc_y;
1550 }
1551 while ((hi < COLOR_BUFFER_SIZE) && (i < len)) {
1552 if ((ic[i] > 32) && (ic[i] < 127)) {
1553 speakup_console[vc_num]->ht.highbuf[bi][hi] = ic[i];
1554 hi++;
1555 } else if ((ic[i] == 32) && (hi != 0)) {
1556 if (speakup_console[vc_num]->ht.highbuf[bi][hi - 1] !=
1557 32) {
1558 speakup_console[vc_num]->ht.highbuf[bi][hi] =
1559 ic[i];
1560 hi++;
1561 }
1562 }
1563 i++;
1564 }
1565 speakup_console[vc_num]->ht.highsize[bi] = hi;
1566 }
1567
1568 static void reset_highlight_buffers(struct vc_data *vc)
1569 {
1570 int i;
1571 int vc_num = vc->vc_num;
1572
1573 for (i = 0; i < 8; i++)
1574 speakup_console[vc_num]->ht.highsize[i] = 0;
1575 }
1576
1577 static int count_highlight_color(struct vc_data *vc)
1578 {
1579 int i, bg;
1580 int cc;
1581 int vc_num = vc->vc_num;
1582 u16 ch;
1583 u16 *start = (u16 *) vc->vc_origin;
1584
1585 for (i = 0; i < 8; i++)
1586 speakup_console[vc_num]->ht.bgcount[i] = 0;
1587
1588 for (i = 0; i < vc->vc_rows; i++) {
1589 u16 *end = start + vc->vc_cols * 2;
1590 u16 *ptr;
1591
1592 for (ptr = start; ptr < end; ptr++) {
1593 ch = get_attributes(vc, ptr);
1594 bg = (ch & 0x70) >> 4;
1595 speakup_console[vc_num]->ht.bgcount[bg]++;
1596 }
1597 start += vc->vc_size_row;
1598 }
1599
1600 cc = 0;
1601 for (i = 0; i < 8; i++)
1602 if (speakup_console[vc_num]->ht.bgcount[i] > 0)
1603 cc++;
1604 return cc;
1605 }
1606
1607 static int get_highlight_color(struct vc_data *vc)
1608 {
1609 int i, j;
1610 unsigned int cptr[8];
1611 int vc_num = vc->vc_num;
1612
1613 for (i = 0; i < 8; i++)
1614 cptr[i] = i;
1615
1616 for (i = 0; i < 7; i++)
1617 for (j = i + 1; j < 8; j++)
1618 if (speakup_console[vc_num]->ht.bgcount[cptr[i]] >
1619 speakup_console[vc_num]->ht.bgcount[cptr[j]])
1620 swap(cptr[i], cptr[j]);
1621
1622 for (i = 0; i < 8; i++)
1623 if (speakup_console[vc_num]->ht.bgcount[cptr[i]] != 0)
1624 if (speakup_console[vc_num]->ht.highsize[cptr[i]] > 0)
1625 return cptr[i];
1626 return -1;
1627 }
1628
1629 static int speak_highlight(struct vc_data *vc)
1630 {
1631 int hc, d;
1632 int vc_num = vc->vc_num;
1633
1634 if (count_highlight_color(vc) == 1)
1635 return 0;
1636 hc = get_highlight_color(vc);
1637 if (hc != -1) {
1638 d = vc->vc_y - speakup_console[vc_num]->ht.cy;
1639 if ((d == 1) || (d == -1))
1640 if (speakup_console[vc_num]->ht.ry[hc] != vc->vc_y)
1641 return 0;
1642 spk_parked |= 0x01;
1643 spk_do_flush();
1644 spkup_write(speakup_console[vc_num]->ht.highbuf[hc],
1645 speakup_console[vc_num]->ht.highsize[hc]);
1646 spk_pos = spk_cp = speakup_console[vc_num]->ht.rpos[hc];
1647 spk_x = spk_cx = speakup_console[vc_num]->ht.rx[hc];
1648 spk_y = spk_cy = speakup_console[vc_num]->ht.ry[hc];
1649 return 1;
1650 }
1651 return 0;
1652 }
1653
1654 static void cursor_done(u_long data)
1655 {
1656 struct vc_data *vc = vc_cons[cursor_con].d;
1657 unsigned long flags;
1658
1659 del_timer(&cursor_timer);
1660 spin_lock_irqsave(&speakup_info.spinlock, flags);
1661 if (cursor_con != fg_console) {
1662 is_cursor = 0;
1663 goto out;
1664 }
1665 speakup_date(vc);
1666 if (win_enabled) {
1667 if (vc->vc_x >= win_left && vc->vc_x <= win_right &&
1668 vc->vc_y >= win_top && vc->vc_y <= win_bottom) {
1669 spk_keydown = is_cursor = 0;
1670 goto out;
1671 }
1672 }
1673 if (cursor_track == read_all_mode) {
1674 handle_cursor_read_all(vc, read_all_key);
1675 goto out;
1676 }
1677 if (cursor_track == CT_Highlight) {
1678 if (speak_highlight(vc)) {
1679 spk_keydown = is_cursor = 0;
1680 goto out;
1681 }
1682 }
1683 if (cursor_track == CT_Window)
1684 speakup_win_say(vc);
1685 else if (is_cursor == 1 || is_cursor == 4)
1686 say_line_from_to(vc, 0, vc->vc_cols, 0);
1687 else
1688 say_char(vc);
1689 spk_keydown = is_cursor = 0;
1690 out:
1691 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1692 }
1693
1694 /* called by: vt_notifier_call() */
1695 static void speakup_bs(struct vc_data *vc)
1696 {
1697 unsigned long flags;
1698
1699 if (!speakup_console[vc->vc_num])
1700 return;
1701 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags))
1702 /* Speakup output, discard */
1703 return;
1704 if (!spk_parked)
1705 speakup_date(vc);
1706 if (spk_shut_up || synth == NULL) {
1707 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1708 return;
1709 }
1710 if (vc->vc_num == fg_console && spk_keydown) {
1711 spk_keydown = 0;
1712 if (!is_cursor)
1713 say_char(vc);
1714 }
1715 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1716 }
1717
1718 /* called by: vt_notifier_call() */
1719 static void speakup_con_write(struct vc_data *vc, const char *str, int len)
1720 {
1721 unsigned long flags;
1722
1723 if ((vc->vc_num != fg_console) || spk_shut_up || synth == NULL)
1724 return;
1725 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags))
1726 /* Speakup output, discard */
1727 return;
1728 if (spk_bell_pos && spk_keydown && (vc->vc_x == spk_bell_pos - 1))
1729 bleep(3);
1730 if ((is_cursor) || (cursor_track == read_all_mode)) {
1731 if (cursor_track == CT_Highlight)
1732 update_color_buffer(vc, str, len);
1733 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1734 return;
1735 }
1736 if (win_enabled) {
1737 if (vc->vc_x >= win_left && vc->vc_x <= win_right &&
1738 vc->vc_y >= win_top && vc->vc_y <= win_bottom) {
1739 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1740 return;
1741 }
1742 }
1743
1744 spkup_write(str, len);
1745 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1746 }
1747
1748 static void speakup_con_update(struct vc_data *vc)
1749 {
1750 unsigned long flags;
1751
1752 if (speakup_console[vc->vc_num] == NULL || spk_parked)
1753 return;
1754 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags))
1755 /* Speakup output, discard */
1756 return;
1757 speakup_date(vc);
1758 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1759 }
1760
1761 static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag)
1762 {
1763 unsigned long flags;
1764 int on_off = 2;
1765 char *label;
1766
1767 if (synth == NULL || up_flag || spk_killed)
1768 return;
1769 spin_lock_irqsave(&speakup_info.spinlock, flags);
1770 spk_shut_up &= 0xfe;
1771 if (spk_no_intr)
1772 spk_do_flush();
1773 switch (value) {
1774 case KVAL(K_CAPS):
1775 label = spk_msg_get(MSG_KEYNAME_CAPSLOCK);
1776 on_off = vt_get_leds(fg_console, VC_CAPSLOCK);
1777 break;
1778 case KVAL(K_NUM):
1779 label = spk_msg_get(MSG_KEYNAME_NUMLOCK);
1780 on_off = vt_get_leds(fg_console, VC_NUMLOCK);
1781 break;
1782 case KVAL(K_HOLD):
1783 label = spk_msg_get(MSG_KEYNAME_SCROLLLOCK);
1784 on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
1785 if (speakup_console[vc->vc_num])
1786 speakup_console[vc->vc_num]->tty_stopped = on_off;
1787 break;
1788 default:
1789 spk_parked &= 0xfe;
1790 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1791 return;
1792 }
1793 if (on_off < 2)
1794 synth_printf("%s %s\n",
1795 label, spk_msg_get(MSG_STATUS_START + on_off));
1796 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
1797 }
1798
1799 static int inc_dec_var(u_char value)
1800 {
1801 struct st_var_header *p_header;
1802 struct var_t *var_data;
1803 char num_buf[32];
1804 char *cp = num_buf;
1805 char *pn;
1806 int var_id = (int)value - VAR_START;
1807 int how = (var_id & 1) ? E_INC : E_DEC;
1808
1809 var_id = var_id / 2 + FIRST_SET_VAR;
1810 p_header = spk_get_var_header(var_id);
1811 if (p_header == NULL)
1812 return -1;
1813 if (p_header->var_type != VAR_NUM)
1814 return -1;
1815 var_data = p_header->data;
1816 if (spk_set_num_var(1, p_header, how) != 0)
1817 return -1;
1818 if (!spk_close_press) {
1819 for (pn = p_header->name; *pn; pn++) {
1820 if (*pn == '_')
1821 *cp = SPACE;
1822 else
1823 *cp++ = *pn;
1824 }
1825 }
1826 snprintf(cp, sizeof(num_buf) - (cp - num_buf), " %d ",
1827 var_data->u.n.value);
1828 synth_printf("%s", num_buf);
1829 return 0;
1830 }
1831
1832 static void speakup_win_set(struct vc_data *vc)
1833 {
1834 char info[40];
1835
1836 if (win_start > 1) {
1837 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_ALREADY_SET));
1838 return;
1839 }
1840 if (spk_x < win_left || spk_y < win_top) {
1841 synth_printf("%s\n", spk_msg_get(MSG_END_BEFORE_START));
1842 return;
1843 }
1844 if (win_start && spk_x == win_left && spk_y == win_top) {
1845 win_left = 0;
1846 win_right = vc->vc_cols - 1;
1847 win_bottom = spk_y;
1848 snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_LINE),
1849 (int)win_top + 1);
1850 } else {
1851 if (!win_start) {
1852 win_top = spk_y;
1853 win_left = spk_x;
1854 } else {
1855 win_bottom = spk_y;
1856 win_right = spk_x;
1857 }
1858 snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_BOUNDARY),
1859 (win_start) ?
1860 spk_msg_get(MSG_END) : spk_msg_get(MSG_START),
1861 (int)spk_y + 1, (int)spk_x + 1);
1862 }
1863 synth_printf("%s\n", info);
1864 win_start++;
1865 }
1866
1867 static void speakup_win_clear(struct vc_data *vc)
1868 {
1869 win_top = win_bottom = 0;
1870 win_left = win_right = 0;
1871 win_start = 0;
1872 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_CLEARED));
1873 }
1874
1875 static void speakup_win_enable(struct vc_data *vc)
1876 {
1877 if (win_start < 2) {
1878 synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW));
1879 return;
1880 }
1881 win_enabled ^= 1;
1882 if (win_enabled)
1883 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCED));
1884 else
1885 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCE_DISABLED));
1886 }
1887
1888 static void speakup_bits(struct vc_data *vc)
1889 {
1890 int val = this_speakup_key - (FIRST_EDIT_BITS - 1);
1891
1892 if (spk_special_handler != NULL || val < 1 || val > 6) {
1893 synth_printf("%s\n", spk_msg_get(MSG_ERROR));
1894 return;
1895 }
1896 pb_edit = &spk_punc_info[val];
1897 synth_printf(spk_msg_get(MSG_EDIT_PROMPT), pb_edit->name);
1898 spk_special_handler = edit_bits;
1899 }
1900
1901 static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key)
1902 {
1903 static u_char goto_buf[8];
1904 static int num;
1905 int maxlen;
1906 char *cp;
1907
1908 if (type == KT_SPKUP && ch == SPEAKUP_GOTO)
1909 goto do_goto;
1910 if (type == KT_LATIN && ch == '\n')
1911 goto do_goto;
1912 if (type != 0)
1913 goto oops;
1914 if (ch == 8) {
1915 if (num == 0)
1916 return -1;
1917 ch = goto_buf[--num];
1918 goto_buf[num] = '\0';
1919 spkup_write(&ch, 1);
1920 return 1;
1921 }
1922 if (ch < '+' || ch > 'y')
1923 goto oops;
1924 goto_buf[num++] = ch;
1925 goto_buf[num] = '\0';
1926 spkup_write(&ch, 1);
1927 maxlen = (*goto_buf >= '0') ? 3 : 4;
1928 if ((ch == '+' || ch == '-') && num == 1)
1929 return 1;
1930 if (ch >= '0' && ch <= '9' && num < maxlen)
1931 return 1;
1932 if (num < maxlen - 1 || num > maxlen)
1933 goto oops;
1934 if (ch < 'x' || ch > 'y') {
1935 oops:
1936 if (!spk_killed)
1937 synth_printf(" %s\n", spk_msg_get(MSG_GOTO_CANCELED));
1938 goto_buf[num = 0] = '\0';
1939 spk_special_handler = NULL;
1940 return 1;
1941 }
1942
1943 goto_pos = simple_strtoul(goto_buf, &cp, 10);
1944
1945 if (*cp == 'x') {
1946 if (*goto_buf < '0')
1947 goto_pos += spk_x;
1948 else if (goto_pos > 0)
1949 goto_pos--;
1950
1951 if (goto_pos >= vc->vc_cols)
1952 goto_pos = vc->vc_cols - 1;
1953 goto_x = 1;
1954 } else {
1955 if (*goto_buf < '0')
1956 goto_pos += spk_y;
1957 else if (goto_pos > 0)
1958 goto_pos--;
1959
1960 if (goto_pos >= vc->vc_rows)
1961 goto_pos = vc->vc_rows - 1;
1962 goto_x = 0;
1963 }
1964 goto_buf[num = 0] = '\0';
1965 do_goto:
1966 spk_special_handler = NULL;
1967 spk_parked |= 0x01;
1968 if (goto_x) {
1969 spk_pos -= spk_x * 2;
1970 spk_x = goto_pos;
1971 spk_pos += goto_pos * 2;
1972 say_word(vc);
1973 } else {
1974 spk_y = goto_pos;
1975 spk_pos = vc->vc_origin + (goto_pos * vc->vc_size_row);
1976 say_line(vc);
1977 }
1978 return 1;
1979 }
1980
1981 static void speakup_goto(struct vc_data *vc)
1982 {
1983 if (spk_special_handler != NULL) {
1984 synth_printf("%s\n", spk_msg_get(MSG_ERROR));
1985 return;
1986 }
1987 synth_printf("%s\n", spk_msg_get(MSG_GOTO));
1988 spk_special_handler = handle_goto;
1989 }
1990
1991 static void speakup_help(struct vc_data *vc)
1992 {
1993 spk_handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0);
1994 }
1995
1996 static void do_nothing(struct vc_data *vc)
1997 {
1998 return; /* flush done in do_spkup */
1999 }
2000
2001 static u_char key_speakup, spk_key_locked;
2002
2003 static void speakup_lock(struct vc_data *vc)
2004 {
2005 if (!spk_key_locked)
2006 spk_key_locked = key_speakup = 16;
2007 else
2008 spk_key_locked = key_speakup = 0;
2009 }
2010
2011 typedef void (*spkup_hand) (struct vc_data *);
2012 static spkup_hand spkup_handler[] = {
2013 /* must be ordered same as defines in speakup.h */
2014 do_nothing, speakup_goto, speech_kill, speakup_shut_up,
2015 speakup_cut, speakup_paste, say_first_char, say_last_char,
2016 say_char, say_prev_char, say_next_char,
2017 say_word, say_prev_word, say_next_word,
2018 say_line, say_prev_line, say_next_line,
2019 top_edge, bottom_edge, left_edge, right_edge,
2020 spell_word, spell_word, say_screen,
2021 say_position, say_attributes,
2022 speakup_off, speakup_parked, say_line, /* this is for indent */
2023 say_from_top, say_to_bottom,
2024 say_from_left, say_to_right,
2025 say_char_num, speakup_bits, speakup_bits, say_phonetic_char,
2026 speakup_bits, speakup_bits, speakup_bits,
2027 speakup_win_set, speakup_win_clear, speakup_win_enable, speakup_win_say,
2028 speakup_lock, speakup_help, toggle_cursoring, read_all_doc, NULL
2029 };
2030
2031 static void do_spkup(struct vc_data *vc, u_char value)
2032 {
2033 if (spk_killed && value != SPEECH_KILL)
2034 return;
2035 spk_keydown = 0;
2036 spk_lastkey = 0;
2037 spk_shut_up &= 0xfe;
2038 this_speakup_key = value;
2039 if (value < SPKUP_MAX_FUNC && spkup_handler[value]) {
2040 spk_do_flush();
2041 (*spkup_handler[value]) (vc);
2042 } else {
2043 if (inc_dec_var(value) < 0)
2044 bleep(9);
2045 }
2046 }
2047
2048 static const char *pad_chars = "0123456789+-*/\015,.?()";
2049
2050 static int
2051 speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
2052 int up_flag)
2053 {
2054 unsigned long flags;
2055 int kh;
2056 u_char *key_info;
2057 u_char type = KTYP(keysym), value = KVAL(keysym), new_key = 0;
2058 u_char shift_info, offset;
2059 int ret = 0;
2060
2061 if (synth == NULL)
2062 return 0;
2063
2064 spin_lock_irqsave(&speakup_info.spinlock, flags);
2065 tty = vc->port.tty;
2066 if (type >= 0xf0)
2067 type -= 0xf0;
2068 if (type == KT_PAD
2069 && (vt_get_leds(fg_console, VC_NUMLOCK))) {
2070 if (up_flag) {
2071 spk_keydown = 0;
2072 goto out;
2073 }
2074 value = spk_lastkey = pad_chars[value];
2075 spk_keydown++;
2076 spk_parked &= 0xfe;
2077 goto no_map;
2078 }
2079 if (keycode >= MAX_KEY)
2080 goto no_map;
2081 key_info = spk_our_keys[keycode];
2082 if (!key_info)
2083 goto no_map;
2084 /* Check valid read all mode keys */
2085 if ((cursor_track == read_all_mode) && (!up_flag)) {
2086 switch (value) {
2087 case KVAL(K_DOWN):
2088 case KVAL(K_UP):
2089 case KVAL(K_LEFT):
2090 case KVAL(K_RIGHT):
2091 case KVAL(K_PGUP):
2092 case KVAL(K_PGDN):
2093 break;
2094 default:
2095 stop_read_all(vc);
2096 break;
2097 }
2098 }
2099 shift_info = (shift_state & 0x0f) + key_speakup;
2100 offset = spk_shift_table[shift_info];
2101 if (offset) {
2102 new_key = key_info[offset];
2103 if (new_key) {
2104 ret = 1;
2105 if (new_key == SPK_KEY) {
2106 if (!spk_key_locked)
2107 key_speakup = (up_flag) ? 0 : 16;
2108 if (up_flag || spk_killed)
2109 goto out;
2110 spk_shut_up &= 0xfe;
2111 spk_do_flush();
2112 goto out;
2113 }
2114 if (up_flag)
2115 goto out;
2116 if (last_keycode == keycode &&
2117 time_after(last_spk_jiffy + MAX_DELAY, jiffies)) {
2118 spk_close_press = 1;
2119 offset = spk_shift_table[shift_info + 32];
2120 /* double press? */
2121 if (offset && key_info[offset])
2122 new_key = key_info[offset];
2123 }
2124 last_keycode = keycode;
2125 last_spk_jiffy = jiffies;
2126 type = KT_SPKUP;
2127 value = new_key;
2128 }
2129 }
2130 no_map:
2131 if (type == KT_SPKUP && spk_special_handler == NULL) {
2132 do_spkup(vc, new_key);
2133 spk_close_press = 0;
2134 ret = 1;
2135 goto out;
2136 }
2137 if (up_flag || spk_killed || type == KT_SHIFT)
2138 goto out;
2139 spk_shut_up &= 0xfe;
2140 kh = (value == KVAL(K_DOWN))
2141 || (value == KVAL(K_UP))
2142 || (value == KVAL(K_LEFT))
2143 || (value == KVAL(K_RIGHT));
2144 if ((cursor_track != read_all_mode) || !kh)
2145 if (!spk_no_intr)
2146 spk_do_flush();
2147 if (spk_special_handler) {
2148 if (type == KT_SPEC && value == 1) {
2149 value = '\n';
2150 type = KT_LATIN;
2151 } else if (type == KT_LETTER)
2152 type = KT_LATIN;
2153 else if (value == 0x7f)
2154 value = 8; /* make del = backspace */
2155 ret = (*spk_special_handler) (vc, type, value, keycode);
2156 spk_close_press = 0;
2157 if (ret < 0)
2158 bleep(9);
2159 goto out;
2160 }
2161 last_keycode = 0;
2162 out:
2163 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
2164 return ret;
2165 }
2166
2167 static int keyboard_notifier_call(struct notifier_block *nb,
2168 unsigned long code, void *_param)
2169 {
2170 struct keyboard_notifier_param *param = _param;
2171 struct vc_data *vc = param->vc;
2172 int up = !param->down;
2173 int ret = NOTIFY_OK;
2174 static int keycode; /* to hold the current keycode */
2175
2176 if (vc->vc_mode == KD_GRAPHICS)
2177 return ret;
2178
2179 /*
2180 * First, determine whether we are handling a fake keypress on
2181 * the current processor. If we are, then return NOTIFY_OK,
2182 * to pass the keystroke up the chain. This prevents us from
2183 * trying to take the Speakup lock while it is held by the
2184 * processor on which the simulated keystroke was generated.
2185 * Also, the simulated keystrokes should be ignored by Speakup.
2186 */
2187
2188 if (speakup_fake_key_pressed())
2189 return ret;
2190
2191 switch (code) {
2192 case KBD_KEYCODE:
2193 /* speakup requires keycode and keysym currently */
2194 keycode = param->value;
2195 break;
2196 case KBD_UNBOUND_KEYCODE:
2197 /* not used yet */
2198 break;
2199 case KBD_UNICODE:
2200 /* not used yet */
2201 break;
2202 case KBD_KEYSYM:
2203 if (speakup_key(vc, param->shift, keycode, param->value, up))
2204 ret = NOTIFY_STOP;
2205 else if (KTYP(param->value) == KT_CUR)
2206 ret = pre_handle_cursor(vc, KVAL(param->value), up);
2207 break;
2208 case KBD_POST_KEYSYM:{
2209 unsigned char type = KTYP(param->value) - 0xf0;
2210 unsigned char val = KVAL(param->value);
2211
2212 switch (type) {
2213 case KT_SHIFT:
2214 do_handle_shift(vc, val, up);
2215 break;
2216 case KT_LATIN:
2217 case KT_LETTER:
2218 do_handle_latin(vc, val, up);
2219 break;
2220 case KT_CUR:
2221 do_handle_cursor(vc, val, up);
2222 break;
2223 case KT_SPEC:
2224 do_handle_spec(vc, val, up);
2225 break;
2226 }
2227 break;
2228 }
2229 }
2230 return ret;
2231 }
2232
2233 static int vt_notifier_call(struct notifier_block *nb,
2234 unsigned long code, void *_param)
2235 {
2236 struct vt_notifier_param *param = _param;
2237 struct vc_data *vc = param->vc;
2238
2239 switch (code) {
2240 case VT_ALLOCATE:
2241 if (vc->vc_mode == KD_TEXT)
2242 speakup_allocate(vc);
2243 break;
2244 case VT_DEALLOCATE:
2245 speakup_deallocate(vc);
2246 break;
2247 case VT_WRITE:
2248 if (param->c == '\b')
2249 speakup_bs(vc);
2250 else if (param->c < 0x100) {
2251 char d = param->c;
2252
2253 speakup_con_write(vc, &d, 1);
2254 }
2255 break;
2256 case VT_UPDATE:
2257 speakup_con_update(vc);
2258 break;
2259 }
2260 return NOTIFY_OK;
2261 }
2262
2263 /* called by: module_exit() */
2264 static void __exit speakup_exit(void)
2265 {
2266 int i;
2267
2268 unregister_keyboard_notifier(&keyboard_notifier_block);
2269 unregister_vt_notifier(&vt_notifier_block);
2270 speakup_unregister_devsynth();
2271 speakup_cancel_paste();
2272 del_timer(&cursor_timer);
2273 kthread_stop(speakup_task);
2274 speakup_task = NULL;
2275 mutex_lock(&spk_mutex);
2276 synth_release();
2277 mutex_unlock(&spk_mutex);
2278
2279 speakup_kobj_exit();
2280
2281 for (i = 0; i < MAX_NR_CONSOLES; i++)
2282 kfree(speakup_console[i]);
2283
2284 speakup_remove_virtual_keyboard();
2285
2286 for (i = 0; i < MAXVARS; i++)
2287 speakup_unregister_var(i);
2288
2289 for (i = 0; i < 256; i++) {
2290 if (spk_characters[i] != spk_default_chars[i])
2291 kfree(spk_characters[i]);
2292 }
2293
2294 spk_free_user_msgs();
2295 }
2296
2297 /* call by: module_init() */
2298 static int __init speakup_init(void)
2299 {
2300 int i;
2301 long err = 0;
2302 struct st_spk_t *first_console;
2303 struct vc_data *vc = vc_cons[fg_console].d;
2304 struct var_t *var;
2305
2306 /* These first few initializations cannot fail. */
2307 spk_initialize_msgs(); /* Initialize arrays for i18n. */
2308 spk_reset_default_chars();
2309 spk_reset_default_chartab();
2310 spk_strlwr(synth_name);
2311 spk_vars[0].u.n.high = vc->vc_cols;
2312 for (var = spk_vars; var->var_id != MAXVARS; var++)
2313 speakup_register_var(var);
2314 for (var = synth_time_vars;
2315 (var->var_id >= 0) && (var->var_id < MAXVARS); var++)
2316 speakup_register_var(var);
2317 for (i = 1; spk_punc_info[i].mask != 0; i++)
2318 spk_set_mask_bits(NULL, i, 2);
2319
2320 spk_set_key_info(spk_key_defaults, spk_key_buf);
2321
2322 /* From here on out, initializations can fail. */
2323 err = speakup_add_virtual_keyboard();
2324 if (err)
2325 goto error_virtkeyboard;
2326
2327 first_console = kzalloc(sizeof(*first_console), GFP_KERNEL);
2328 if (!first_console) {
2329 err = -ENOMEM;
2330 goto error_alloc;
2331 }
2332
2333 speakup_console[vc->vc_num] = first_console;
2334 speakup_date(vc);
2335
2336 for (i = 0; i < MAX_NR_CONSOLES; i++)
2337 if (vc_cons[i].d) {
2338 err = speakup_allocate(vc_cons[i].d);
2339 if (err)
2340 goto error_kobjects;
2341 }
2342
2343 if (spk_quiet_boot)
2344 spk_shut_up |= 0x01;
2345
2346 err = speakup_kobj_init();
2347 if (err)
2348 goto error_kobjects;
2349
2350 synth_init(synth_name);
2351 speakup_register_devsynth();
2352 /*
2353 * register_devsynth might fail, but this error is not fatal.
2354 * /dev/synth is an extra feature; the rest of Speakup
2355 * will work fine without it.
2356 */
2357
2358 err = register_keyboard_notifier(&keyboard_notifier_block);
2359 if (err)
2360 goto error_kbdnotifier;
2361 err = register_vt_notifier(&vt_notifier_block);
2362 if (err)
2363 goto error_vtnotifier;
2364
2365 speakup_task = kthread_create(speakup_thread, NULL, "speakup");
2366
2367 if (IS_ERR(speakup_task)) {
2368 err = PTR_ERR(speakup_task);
2369 goto error_task;
2370 }
2371
2372 set_user_nice(speakup_task, 10);
2373 wake_up_process(speakup_task);
2374
2375 pr_info("speakup %s: initialized\n", SPEAKUP_VERSION);
2376 pr_info("synth name on entry is: %s\n", synth_name);
2377 goto out;
2378
2379 error_task:
2380 unregister_vt_notifier(&vt_notifier_block);
2381
2382 error_vtnotifier:
2383 unregister_keyboard_notifier(&keyboard_notifier_block);
2384 del_timer(&cursor_timer);
2385
2386 error_kbdnotifier:
2387 speakup_unregister_devsynth();
2388 mutex_lock(&spk_mutex);
2389 synth_release();
2390 mutex_unlock(&spk_mutex);
2391 speakup_kobj_exit();
2392
2393 error_kobjects:
2394 for (i = 0; i < MAX_NR_CONSOLES; i++)
2395 kfree(speakup_console[i]);
2396
2397 error_alloc:
2398 speakup_remove_virtual_keyboard();
2399
2400 error_virtkeyboard:
2401 for (i = 0; i < MAXVARS; i++)
2402 speakup_unregister_var(i);
2403
2404 for (i = 0; i < 256; i++) {
2405 if (spk_characters[i] != spk_default_chars[i])
2406 kfree(spk_characters[i]);
2407 }
2408
2409 spk_free_user_msgs();
2410
2411 out:
2412 return err;
2413 }
2414
2415 module_init(speakup_init);
2416 module_exit(speakup_exit);
Ubuntu Disco kernel mirror for Proxmox VE and PMG