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); 2462