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