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