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 synth_printf("%s", spk_msg_get(MSG_COLORS_START + fg)); 393 if (bg > 7) { 394 synth_printf(" %s ", spk_msg_get(MSG_ON_BLINKING)); 395 bg -= 8; 396 } else { 397 synth_printf(" %s ", spk_msg_get(MSG_ON)); 398 } 399 synth_printf("%s\n", spk_msg_get(MSG_COLORS_START + bg)); 400 } 401 402 /* must be ordered same as edge_msgs in enum msg_index_t */ 403 enum edge { 404 edge_none = 0, 405 edge_top, 406 edge_bottom, 407 edge_left, 408 edge_right, 409 edge_quiet 410 }; 411 412 static void announce_edge(struct vc_data *vc, enum edge msg_id) 413 { 414 if (spk_bleeps & 1) 415 bleep(spk_y); 416 if ((spk_bleeps & 2) && (msg_id < edge_quiet)) 417 synth_printf("%s\n", 418 spk_msg_get(MSG_EDGE_MSGS_START + msg_id - 1)); 419 } 420 421 static void speak_char(u16 ch) 422 { 423 char *cp; 424 struct var_t *direct = spk_get_var(DIRECT); 425 426 if (ch >= 0x100 || (direct && direct->u.n.value)) { 427 if (ch < 0x100 && IS_CHAR(ch, B_CAP)) { 428 spk_pitch_shift++; 429 synth_printf("%s", spk_str_caps_start); 430 } 431 synth_putwc_s(ch); 432 if (ch < 0x100 && IS_CHAR(ch, B_CAP)) 433 synth_printf("%s", spk_str_caps_stop); 434 return; 435 } 436 437 cp = spk_characters[ch]; 438 if (!cp) { 439 pr_info("%s: cp == NULL!\n", __func__); 440 return; 441 } 442 if (IS_CHAR(ch, B_CAP)) { 443 spk_pitch_shift++; 444 synth_printf("%s %s %s", 445 spk_str_caps_start, cp, spk_str_caps_stop); 446 } else { 447 if (*cp == '^') { 448 cp++; 449 synth_printf(" %s%s ", spk_msg_get(MSG_CTRL), cp); 450 } else { 451 synth_printf(" %s ", cp); 452 } 453 } 454 } 455 456 static u16 get_char(struct vc_data *vc, u16 *pos, u_char *attribs) 457 { 458 u16 ch = ' '; 459 460 if (vc && pos) { 461 u16 w; 462 u16 c; 463 464 pos = screen_pos(vc, pos - (u16 *)vc->vc_origin, true); 465 w = scr_readw(pos); 466 c = w & 0xff; 467 468 if (w & vc->vc_hi_font_mask) { 469 w &= ~vc->vc_hi_font_mask; 470 c |= 0x100; 471 } 472 473 ch = inverse_translate(vc, c, 1); 474 *attribs = (w & 0xff00) >> 8; 475 } 476 return ch; 477 } 478 479 static void say_char(struct vc_data *vc) 480 { 481 u16 ch; 482 483 spk_old_attr = spk_attr; 484 ch = get_char(vc, (u_short *)spk_pos, &spk_attr); 485 if (spk_attr != spk_old_attr) { 486 if (spk_attrib_bleep & 1) 487 bleep(spk_y); 488 if (spk_attrib_bleep & 2) 489 say_attributes(vc); 490 } 491 speak_char(ch); 492 } 493 494 static void say_phonetic_char(struct vc_data *vc) 495 { 496 u16 ch; 497 498 spk_old_attr = spk_attr; 499 ch = get_char(vc, (u_short *)spk_pos, &spk_attr); 500 if (ch <= 0x7f && isalpha(ch)) { 501 ch &= 0x1f; 502 synth_printf("%s\n", phonetic[--ch]); 503 } else { 504 if (ch < 0x100 && IS_CHAR(ch, B_NUM)) 505 synth_printf("%s ", spk_msg_get(MSG_NUMBER)); 506 speak_char(ch); 507 } 508 } 509 510 static void say_prev_char(struct vc_data *vc) 511 { 512 spk_parked |= 0x01; 513 if (spk_x == 0) { 514 announce_edge(vc, edge_left); 515 return; 516 } 517 spk_x--; 518 spk_pos -= 2; 519 say_char(vc); 520 } 521 522 static void say_next_char(struct vc_data *vc) 523 { 524 spk_parked |= 0x01; 525 if (spk_x == vc->vc_cols - 1) { 526 announce_edge(vc, edge_right); 527 return; 528 } 529 spk_x++; 530 spk_pos += 2; 531 say_char(vc); 532 } 533 534 /* get_word - will first check to see if the character under the 535 * reading cursor is a space and if spk_say_word_ctl is true it will 536 * return the word space. If spk_say_word_ctl is not set it will check to 537 * see if there is a word starting on the next position to the right 538 * and return that word if it exists. If it does not exist it will 539 * move left to the beginning of any previous word on the line or the 540 * beginning off the line whichever comes first.. 541 */ 542 543 static u_long get_word(struct vc_data *vc) 544 { 545 u_long cnt = 0, tmpx = spk_x, tmp_pos = spk_pos; 546 u16 ch; 547 u16 attr_ch; 548 u_char temp; 549 550 spk_old_attr = spk_attr; 551 ch = get_char(vc, (u_short *)tmp_pos, &temp); 552 553 /* decided to take out the sayword if on a space (mis-information */ 554 if (spk_say_word_ctl && ch == SPACE) { 555 *buf = '\0'; 556 synth_printf("%s\n", spk_msg_get(MSG_SPACE)); 557 return 0; 558 } else if (tmpx < vc->vc_cols - 2 && 559 (ch == SPACE || ch == 0 || (ch < 0x100 && IS_WDLM(ch))) && 560 get_char(vc, (u_short *)tmp_pos + 1, &temp) > SPACE) { 561 tmp_pos += 2; 562 tmpx++; 563 } else { 564 while (tmpx > 0) { 565 ch = get_char(vc, (u_short *)tmp_pos - 1, &temp); 566 if ((ch == SPACE || ch == 0 || 567 (ch < 0x100 && IS_WDLM(ch))) && 568 get_char(vc, (u_short *)tmp_pos, &temp) > SPACE) 569 break; 570 tmp_pos -= 2; 571 tmpx--; 572 } 573 } 574 attr_ch = get_char(vc, (u_short *)tmp_pos, &spk_attr); 575 buf[cnt++] = attr_ch; 576 while (tmpx < vc->vc_cols - 1) { 577 tmp_pos += 2; 578 tmpx++; 579 ch = get_char(vc, (u_short *)tmp_pos, &temp); 580 if (ch == SPACE || ch == 0 || 581 (buf[cnt - 1] < 0x100 && IS_WDLM(buf[cnt - 1]) && 582 ch > SPACE)) 583 break; 584 buf[cnt++] = ch; 585 } 586 buf[cnt] = '\0'; 587 return cnt; 588 } 589 590 static void say_word(struct vc_data *vc) 591 { 592 u_long cnt = get_word(vc); 593 u_short saved_punc_mask = spk_punc_mask; 594 595 if (cnt == 0) 596 return; 597 spk_punc_mask = PUNC; 598 buf[cnt++] = SPACE; 599 spkup_write(buf, cnt); 600 spk_punc_mask = saved_punc_mask; 601 } 602 603 static void say_prev_word(struct vc_data *vc) 604 { 605 u_char temp; 606 u16 ch; 607 enum edge edge_said = edge_none; 608 u_short last_state = 0, state = 0; 609 610 spk_parked |= 0x01; 611 612 if (spk_x == 0) { 613 if (spk_y == 0) { 614 announce_edge(vc, edge_top); 615 return; 616 } 617 spk_y--; 618 spk_x = vc->vc_cols; 619 edge_said = edge_quiet; 620 } 621 while (1) { 622 if (spk_x == 0) { 623 if (spk_y == 0) { 624 edge_said = edge_top; 625 break; 626 } 627 if (edge_said != edge_quiet) 628 edge_said = edge_left; 629 if (state > 0) 630 break; 631 spk_y--; 632 spk_x = vc->vc_cols - 1; 633 } else { 634 spk_x--; 635 } 636 spk_pos -= 2; 637 ch = get_char(vc, (u_short *)spk_pos, &temp); 638 if (ch == SPACE || ch == 0) 639 state = 0; 640 else if (ch < 0x100 && IS_WDLM(ch)) 641 state = 1; 642 else 643 state = 2; 644 if (state < last_state) { 645 spk_pos += 2; 646 spk_x++; 647 break; 648 } 649 last_state = state; 650 } 651 if (spk_x == 0 && edge_said == edge_quiet) 652 edge_said = edge_left; 653 if (edge_said > edge_none && edge_said < edge_quiet) 654 announce_edge(vc, edge_said); 655 say_word(vc); 656 } 657 658 static void say_next_word(struct vc_data *vc) 659 { 660 u_char temp; 661 u16 ch; 662 enum edge edge_said = edge_none; 663 u_short last_state = 2, state = 0; 664 665 spk_parked |= 0x01; 666 if (spk_x == vc->vc_cols - 1 && spk_y == vc->vc_rows - 1) { 667 announce_edge(vc, edge_bottom); 668 return; 669 } 670 while (1) { 671 ch = get_char(vc, (u_short *)spk_pos, &temp); 672 if (ch == SPACE || ch == 0) 673 state = 0; 674 else if (ch < 0x100 && IS_WDLM(ch)) 675 state = 1; 676 else 677 state = 2; 678 if (state > last_state) 679 break; 680 if (spk_x >= vc->vc_cols - 1) { 681 if (spk_y == vc->vc_rows - 1) { 682 edge_said = edge_bottom; 683 break; 684 } 685 state = 0; 686 spk_y++; 687 spk_x = 0; 688 edge_said = edge_right; 689 } else { 690 spk_x++; 691 } 692 spk_pos += 2; 693 last_state = state; 694 } 695 if (edge_said > edge_none) 696 announce_edge(vc, edge_said); 697 say_word(vc); 698 } 699 700 static void spell_word(struct vc_data *vc) 701 { 702 static char const *delay_str[] = { "", ",", ".", ". .", ". . ." }; 703 u16 *cp = buf; 704 char *cp1; 705 char *str_cap = spk_str_caps_stop; 706 char *last_cap = spk_str_caps_stop; 707 struct var_t *direct = spk_get_var(DIRECT); 708 u16 ch; 709 710 if (!get_word(vc)) 711 return; 712 while ((ch = *cp)) { 713 if (cp != buf) 714 synth_printf(" %s ", delay_str[spk_spell_delay]); 715 /* FIXME: Non-latin1 considered as lower case */ 716 if (ch < 0x100 && IS_CHAR(ch, B_CAP)) { 717 str_cap = spk_str_caps_start; 718 if (*spk_str_caps_stop) 719 spk_pitch_shift++; 720 else /* synth has no pitch */ 721 last_cap = spk_str_caps_stop; 722 } else { 723 str_cap = spk_str_caps_stop; 724 } 725 if (str_cap != last_cap) { 726 synth_printf("%s", str_cap); 727 last_cap = str_cap; 728 } 729 if (ch >= 0x100 || (direct && direct->u.n.value)) { 730 synth_putwc_s(ch); 731 } else if (this_speakup_key == SPELL_PHONETIC && 732 ch <= 0x7f && isalpha(ch)) { 733 ch &= 0x1f; 734 cp1 = phonetic[--ch]; 735 synth_printf("%s", cp1); 736 } else { 737 cp1 = spk_characters[ch]; 738 if (*cp1 == '^') { 739 synth_printf("%s", spk_msg_get(MSG_CTRL)); 740 cp1++; 741 } 742 synth_printf("%s", cp1); 743 } 744 cp++; 745 } 746 if (str_cap != spk_str_caps_stop) 747 synth_printf("%s", spk_str_caps_stop); 748 } 749 750 static int get_line(struct vc_data *vc) 751 { 752 u_long tmp = spk_pos - (spk_x * 2); 753 int i = 0; 754 u_char tmp2; 755 756 spk_old_attr = spk_attr; 757 spk_attr = get_attributes(vc, (u_short *)spk_pos); 758 for (i = 0; i < vc->vc_cols; i++) { 759 buf[i] = get_char(vc, (u_short *)tmp, &tmp2); 760 tmp += 2; 761 } 762 for (--i; i >= 0; i--) 763 if (buf[i] != SPACE) 764 break; 765 return ++i; 766 } 767 768 static void say_line(struct vc_data *vc) 769 { 770 int i = get_line(vc); 771 u16 *cp; 772 u_short saved_punc_mask = spk_punc_mask; 773 774 if (i == 0) { 775 synth_printf("%s\n", spk_msg_get(MSG_BLANK)); 776 return; 777 } 778 buf[i++] = '\n'; 779 if (this_speakup_key == SAY_LINE_INDENT) { 780 cp = buf; 781 while (*cp == SPACE) 782 cp++; 783 synth_printf("%zd, ", (cp - buf) + 1); 784 } 785 spk_punc_mask = spk_punc_masks[spk_reading_punc]; 786 spkup_write(buf, i); 787 spk_punc_mask = saved_punc_mask; 788 } 789 790 static void say_prev_line(struct vc_data *vc) 791 { 792 spk_parked |= 0x01; 793 if (spk_y == 0) { 794 announce_edge(vc, edge_top); 795 return; 796 } 797 spk_y--; 798 spk_pos -= vc->vc_size_row; 799 say_line(vc); 800 } 801 802 static void say_next_line(struct vc_data *vc) 803 { 804 spk_parked |= 0x01; 805 if (spk_y == vc->vc_rows - 1) { 806 announce_edge(vc, edge_bottom); 807 return; 808 } 809 spk_y++; 810 spk_pos += vc->vc_size_row; 811 say_line(vc); 812 } 813 814 static int say_from_to(struct vc_data *vc, u_long from, u_long to, 815 int read_punc) 816 { 817 int i = 0; 818 u_char tmp; 819 u_short saved_punc_mask = spk_punc_mask; 820 821 spk_old_attr = spk_attr; 822 spk_attr = get_attributes(vc, (u_short *)from); 823 while (from < to) { 824 buf[i++] = get_char(vc, (u_short *)from, &tmp); 825 from += 2; 826 if (i >= vc->vc_size_row) 827 break; 828 } 829 for (--i; i >= 0; i--) 830 if (buf[i] != SPACE) 831 break; 832 buf[++i] = SPACE; 833 buf[++i] = '\0'; 834 if (i < 1) 835 return i; 836 if (read_punc) 837 spk_punc_mask = spk_punc_info[spk_reading_punc].mask; 838 spkup_write(buf, i); 839 if (read_punc) 840 spk_punc_mask = saved_punc_mask; 841 return i - 1; 842 } 843 844 static void say_line_from_to(struct vc_data *vc, u_long from, u_long to, 845 int read_punc) 846 { 847 u_long start = vc->vc_origin + (spk_y * vc->vc_size_row); 848 u_long end = start + (to * 2); 849 850 start += from * 2; 851 if (say_from_to(vc, start, end, read_punc) <= 0) 852 if (cursor_track != read_all_mode) 853 synth_printf("%s\n", spk_msg_get(MSG_BLANK)); 854 } 855 856 /* Sentence Reading Commands */ 857 858 static int currsentence; 859 static int numsentences[2]; 860 static u16 *sentbufend[2]; 861 static u16 *sentmarks[2][10]; 862 static int currbuf; 863 static int bn; 864 static u16 sentbuf[2][256]; 865 866 static int say_sentence_num(int num, int prev) 867 { 868 bn = currbuf; 869 currsentence = num + 1; 870 if (prev && --bn == -1) 871 bn = 1; 872 873 if (num > numsentences[bn]) 874 return 0; 875 876 spkup_write(sentmarks[bn][num], sentbufend[bn] - sentmarks[bn][num]); 877 return 1; 878 } 879 880 static int get_sentence_buf(struct vc_data *vc, int read_punc) 881 { 882 u_long start, end; 883 int i, bn; 884 u_char tmp; 885 886 currbuf++; 887 if (currbuf == 2) 888 currbuf = 0; 889 bn = currbuf; 890 start = vc->vc_origin + ((spk_y) * vc->vc_size_row); 891 end = vc->vc_origin + ((spk_y) * vc->vc_size_row) + vc->vc_cols * 2; 892 893 numsentences[bn] = 0; 894 sentmarks[bn][0] = &sentbuf[bn][0]; 895 i = 0; 896 spk_old_attr = spk_attr; 897 spk_attr = get_attributes(vc, (u_short *)start); 898 899 while (start < end) { 900 sentbuf[bn][i] = get_char(vc, (u_short *)start, &tmp); 901 if (i > 0) { 902 if (sentbuf[bn][i] == SPACE && 903 sentbuf[bn][i - 1] == '.' && 904 numsentences[bn] < 9) { 905 /* Sentence Marker */ 906 numsentences[bn]++; 907 sentmarks[bn][numsentences[bn]] = 908 &sentbuf[bn][i]; 909 } 910 } 911 i++; 912 start += 2; 913 if (i >= vc->vc_size_row) 914 break; 915 } 916 917 for (--i; i >= 0; i--) 918 if (sentbuf[bn][i] != SPACE) 919 break; 920 921 if (i < 1) 922 return -1; 923 924 sentbuf[bn][++i] = SPACE; 925 sentbuf[bn][++i] = '\0'; 926 927 sentbufend[bn] = &sentbuf[bn][i]; 928 return numsentences[bn]; 929 } 930 931 static void say_screen_from_to(struct vc_data *vc, u_long from, u_long to) 932 { 933 u_long start = vc->vc_origin, end; 934 935 if (from > 0) 936 start += from * vc->vc_size_row; 937 if (to > vc->vc_rows) 938 to = vc->vc_rows; 939 end = vc->vc_origin + (to * vc->vc_size_row); 940 for (from = start; from < end; from = to) { 941 to = from + vc->vc_size_row; 942 say_from_to(vc, from, to, 1); 943 } 944 } 945 946 static void say_screen(struct vc_data *vc) 947 { 948 say_screen_from_to(vc, 0, vc->vc_rows); 949 } 950 951 static void speakup_win_say(struct vc_data *vc) 952 { 953 u_long start, end, from, to; 954 955 if (win_start < 2) { 956 synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW)); 957 return; 958 } 959 start = vc->vc_origin + (win_top * vc->vc_size_row); 960 end = vc->vc_origin + (win_bottom * vc->vc_size_row); 961 while (start <= end) { 962 from = start + (win_left * 2); 963 to = start + (win_right * 2); 964 say_from_to(vc, from, to, 1); 965 start += vc->vc_size_row; 966 } 967 } 968 969 static void top_edge(struct vc_data *vc) 970 { 971 spk_parked |= 0x01; 972 spk_pos = vc->vc_origin + 2 * spk_x; 973 spk_y = 0; 974 say_line(vc); 975 } 976 977 static void bottom_edge(struct vc_data *vc) 978 { 979 spk_parked |= 0x01; 980 spk_pos += (vc->vc_rows - spk_y - 1) * vc->vc_size_row; 981 spk_y = vc->vc_rows - 1; 982 say_line(vc); 983 } 984 985 static void left_edge(struct vc_data *vc) 986 { 987 spk_parked |= 0x01; 988 spk_pos -= spk_x * 2; 989 spk_x = 0; 990 say_char(vc); 991 } 992 993 static void right_edge(struct vc_data *vc) 994 { 995 spk_parked |= 0x01; 996 spk_pos += (vc->vc_cols - spk_x - 1) * 2; 997 spk_x = vc->vc_cols - 1; 998 say_char(vc); 999 } 1000 1001 static void say_first_char(struct vc_data *vc) 1002 { 1003 int i, len = get_line(vc); 1004 u16 ch; 1005 1006 spk_parked |= 0x01; 1007 if (len == 0) { 1008 synth_printf("%s\n", spk_msg_get(MSG_BLANK)); 1009 return; 1010 } 1011 for (i = 0; i < len; i++) 1012 if (buf[i] != SPACE) 1013 break; 1014 ch = buf[i]; 1015 spk_pos -= (spk_x - i) * 2; 1016 spk_x = i; 1017 synth_printf("%d, ", ++i); 1018 speak_char(ch); 1019 } 1020 1021 static void say_last_char(struct vc_data *vc) 1022 { 1023 int len = get_line(vc); 1024 u16 ch; 1025 1026 spk_parked |= 0x01; 1027 if (len == 0) { 1028 synth_printf("%s\n", spk_msg_get(MSG_BLANK)); 1029 return; 1030 } 1031 ch = buf[--len]; 1032 spk_pos -= (spk_x - len) * 2; 1033 spk_x = len; 1034 synth_printf("%d, ", ++len); 1035 speak_char(ch); 1036 } 1037 1038 static void say_position(struct vc_data *vc) 1039 { 1040 synth_printf(spk_msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1, 1041 vc->vc_num + 1); 1042 synth_printf("\n"); 1043 } 1044 1045 /* Added by brianb */ 1046 static void say_char_num(struct vc_data *vc) 1047 { 1048 u_char tmp; 1049 u16 ch = get_char(vc, (u_short *)spk_pos, &tmp); 1050 1051 synth_printf(spk_msg_get(MSG_CHAR_INFO), ch, ch); 1052 } 1053 1054 /* these are stub functions to keep keyboard.c happy. */ 1055 1056 static void say_from_top(struct vc_data *vc) 1057 { 1058 say_screen_from_to(vc, 0, spk_y); 1059 } 1060 1061 static void say_to_bottom(struct vc_data *vc) 1062 { 1063 say_screen_from_to(vc, spk_y, vc->vc_rows); 1064 } 1065 1066 static void say_from_left(struct vc_data *vc) 1067 { 1068 say_line_from_to(vc, 0, spk_x, 1); 1069 } 1070 1071 static void say_to_right(struct vc_data *vc) 1072 { 1073 say_line_from_to(vc, spk_x, vc->vc_cols, 1); 1074 } 1075 1076 /* end of stub functions. */ 1077 1078 static void spkup_write(const u16 *in_buf, int count) 1079 { 1080 static int rep_count; 1081 static u16 ch = '\0', old_ch = '\0'; 1082 static u_short char_type, last_type; 1083 int in_count = count; 1084 1085 spk_keydown = 0; 1086 while (count--) { 1087 if (cursor_track == read_all_mode) { 1088 /* Insert Sentence Index */ 1089 if ((in_buf == sentmarks[bn][currsentence]) && 1090 (currsentence <= numsentences[bn])) 1091 synth_insert_next_index(currsentence++); 1092 } 1093 ch = *in_buf++; 1094 if (ch < 0x100) 1095 char_type = spk_chartab[ch]; 1096 else 1097 char_type = ALPHA; 1098 if (ch == old_ch && !(char_type & B_NUM)) { 1099 if (++rep_count > 2) 1100 continue; 1101 } else { 1102 if ((last_type & CH_RPT) && rep_count > 2) { 1103 synth_printf(" "); 1104 synth_printf(spk_msg_get(MSG_REPEAT_DESC), 1105 ++rep_count); 1106 synth_printf(" "); 1107 } 1108 rep_count = 0; 1109 } 1110 if (ch == spk_lastkey) { 1111 rep_count = 0; 1112 if (spk_key_echo == 1 && ch >= MINECHOCHAR) 1113 speak_char(ch); 1114 } else if (char_type & B_ALPHA) { 1115 if ((synth_flags & SF_DEC) && (last_type & PUNC)) 1116 synth_buffer_add(SPACE); 1117 synth_putwc_s(ch); 1118 } else if (char_type & B_NUM) { 1119 rep_count = 0; 1120 synth_putwc_s(ch); 1121 } else if (char_type & spk_punc_mask) { 1122 speak_char(ch); 1123 char_type &= ~PUNC; /* for dec nospell processing */ 1124 } else if (char_type & SYNTH_OK) { 1125 /* these are usually puncts like . and , which synth 1126 * needs for expression. 1127 * suppress multiple to get rid of long pauses and 1128 * clear repeat count 1129 * so if someone has 1130 * repeats on you don't get nothing repeated count 1131 */ 1132 if (ch != old_ch) 1133 synth_putwc_s(ch); 1134 else 1135 rep_count = 0; 1136 } else { 1137 /* send space and record position, if next is num overwrite space */ 1138 if (old_ch != ch) 1139 synth_buffer_add(SPACE); 1140 else 1141 rep_count = 0; 1142 } 1143 old_ch = ch; 1144 last_type = char_type; 1145 } 1146 spk_lastkey = 0; 1147 if (in_count > 2 && rep_count > 2) { 1148 if (last_type & CH_RPT) { 1149 synth_printf(" "); 1150 synth_printf(spk_msg_get(MSG_REPEAT_DESC2), 1151 ++rep_count); 1152 synth_printf(" "); 1153 } 1154 rep_count = 0; 1155 } 1156 } 1157 1158 static const int NUM_CTL_LABELS = (MSG_CTL_END - MSG_CTL_START + 1); 1159 1160 static void read_all_doc(struct vc_data *vc); 1161 static void cursor_done(struct timer_list *unused); 1162 static DEFINE_TIMER(cursor_timer, cursor_done); 1163 1164 static void do_handle_shift(struct vc_data *vc, u_char value, char up_flag) 1165 { 1166 unsigned long flags; 1167 1168 if (!synth || up_flag || spk_killed) 1169 return; 1170 spin_lock_irqsave(&speakup_info.spinlock, flags); 1171 if (cursor_track == read_all_mode) { 1172 switch (value) { 1173 case KVAL(K_SHIFT): 1174 del_timer(&cursor_timer); 1175 spk_shut_up &= 0xfe; 1176 spk_do_flush(); 1177 read_all_doc(vc); 1178 break; 1179 case KVAL(K_CTRL): 1180 del_timer(&cursor_timer); 1181 cursor_track = prev_cursor_track; 1182 spk_shut_up &= 0xfe; 1183 spk_do_flush(); 1184 break; 1185 } 1186 } else { 1187 spk_shut_up &= 0xfe; 1188 spk_do_flush(); 1189 } 1190 if (spk_say_ctrl && value < NUM_CTL_LABELS) 1191 synth_printf("%s", spk_msg_get(MSG_CTL_START + value)); 1192 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1193 } 1194 1195 static void do_handle_latin(struct vc_data *vc, u_char value, char up_flag) 1196 { 1197 unsigned long flags; 1198 1199 spin_lock_irqsave(&speakup_info.spinlock, flags); 1200 if (up_flag) { 1201 spk_lastkey = 0; 1202 spk_keydown = 0; 1203 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1204 return; 1205 } 1206 if (!synth || spk_killed) { 1207 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1208 return; 1209 } 1210 spk_shut_up &= 0xfe; 1211 spk_lastkey = value; 1212 spk_keydown++; 1213 spk_parked &= 0xfe; 1214 if (spk_key_echo == 2 && value >= MINECHOCHAR) 1215 speak_char(value); 1216 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1217 } 1218 1219 int spk_set_key_info(const u_char *key_info, u_char *k_buffer) 1220 { 1221 int i = 0, states, key_data_len; 1222 const u_char *cp = key_info; 1223 u_char *cp1 = k_buffer; 1224 u_char ch, version, num_keys; 1225 1226 version = *cp++; 1227 if (version != KEY_MAP_VER) { 1228 pr_debug("version found %d should be %d\n", 1229 version, KEY_MAP_VER); 1230 return -EINVAL; 1231 } 1232 num_keys = *cp; 1233 states = (int)cp[1]; 1234 key_data_len = (states + 1) * (num_keys + 1); 1235 if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf)) { 1236 pr_debug("too many key_infos (%d over %u)\n", 1237 key_data_len + SHIFT_TBL_SIZE + 4, 1238 (unsigned int)(sizeof(spk_key_buf))); 1239 return -EINVAL; 1240 } 1241 memset(k_buffer, 0, SHIFT_TBL_SIZE); 1242 memset(spk_our_keys, 0, sizeof(spk_our_keys)); 1243 spk_shift_table = k_buffer; 1244 spk_our_keys[0] = spk_shift_table; 1245 cp1 += SHIFT_TBL_SIZE; 1246 memcpy(cp1, cp, key_data_len + 3); 1247 /* get num_keys, states and data */ 1248 cp1 += 2; /* now pointing at shift states */ 1249 for (i = 1; i <= states; i++) { 1250 ch = *cp1++; 1251 if (ch >= SHIFT_TBL_SIZE) { 1252 pr_debug("(%d) not valid shift state (max_allowed = %d)\n", 1253 ch, SHIFT_TBL_SIZE); 1254 return -EINVAL; 1255 } 1256 spk_shift_table[ch] = i; 1257 } 1258 keymap_flags = *cp1++; 1259 while ((ch = *cp1)) { 1260 if (ch >= MAX_KEY) { 1261 pr_debug("(%d), not valid key, (max_allowed = %d)\n", 1262 ch, MAX_KEY); 1263 return -EINVAL; 1264 } 1265 spk_our_keys[ch] = cp1; 1266 cp1 += states + 1; 1267 } 1268 return 0; 1269 } 1270 1271 static struct var_t spk_vars[] = { 1272 /* bell must be first to set high limit */ 1273 {BELL_POS, .u.n = {NULL, 0, 0, 0, 0, 0, NULL} }, 1274 {SPELL_DELAY, .u.n = {NULL, 0, 0, 4, 0, 0, NULL} }, 1275 {ATTRIB_BLEEP, .u.n = {NULL, 1, 0, 3, 0, 0, NULL} }, 1276 {BLEEPS, .u.n = {NULL, 3, 0, 3, 0, 0, NULL} }, 1277 {BLEEP_TIME, .u.n = {NULL, 30, 1, 200, 0, 0, NULL} }, 1278 {PUNC_LEVEL, .u.n = {NULL, 1, 0, 4, 0, 0, NULL} }, 1279 {READING_PUNC, .u.n = {NULL, 1, 0, 4, 0, 0, NULL} }, 1280 {CURSOR_TIME, .u.n = {NULL, 120, 50, 600, 0, 0, NULL} }, 1281 {SAY_CONTROL, TOGGLE_0}, 1282 {SAY_WORD_CTL, TOGGLE_0}, 1283 {NO_INTERRUPT, TOGGLE_0}, 1284 {KEY_ECHO, .u.n = {NULL, 1, 0, 2, 0, 0, NULL} }, 1285 V_LAST_VAR 1286 }; 1287 1288 static void toggle_cursoring(struct vc_data *vc) 1289 { 1290 if (cursor_track == read_all_mode) 1291 cursor_track = prev_cursor_track; 1292 if (++cursor_track >= CT_Max) 1293 cursor_track = 0; 1294 synth_printf("%s\n", spk_msg_get(MSG_CURSOR_MSGS_START + cursor_track)); 1295 } 1296 1297 void spk_reset_default_chars(void) 1298 { 1299 int i; 1300 1301 /* First, free any non-default */ 1302 for (i = 0; i < 256; i++) { 1303 if (spk_characters[i] && 1304 (spk_characters[i] != spk_default_chars[i])) 1305 kfree(spk_characters[i]); 1306 } 1307 1308 memcpy(spk_characters, spk_default_chars, sizeof(spk_default_chars)); 1309 } 1310 1311 void spk_reset_default_chartab(void) 1312 { 1313 memcpy(spk_chartab, default_chartab, sizeof(default_chartab)); 1314 } 1315 1316 static const struct st_bits_data *pb_edit; 1317 1318 static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key) 1319 { 1320 short mask = pb_edit->mask, ch_type = spk_chartab[ch]; 1321 1322 if (type != KT_LATIN || (ch_type & B_NUM) || ch < SPACE) 1323 return -1; 1324 if (ch == SPACE) { 1325 synth_printf("%s\n", spk_msg_get(MSG_EDIT_DONE)); 1326 spk_special_handler = NULL; 1327 return 1; 1328 } 1329 if (mask < PUNC && !(ch_type & PUNC)) 1330 return -1; 1331 spk_chartab[ch] ^= mask; 1332 speak_char(ch); 1333 synth_printf(" %s\n", 1334 (spk_chartab[ch] & mask) ? spk_msg_get(MSG_ON) : 1335 spk_msg_get(MSG_OFF)); 1336 return 1; 1337 } 1338 1339 /* Allocation concurrency is protected by the console semaphore */ 1340 static int speakup_allocate(struct vc_data *vc, gfp_t gfp_flags) 1341 { 1342 int vc_num; 1343 1344 vc_num = vc->vc_num; 1345 if (!speakup_console[vc_num]) { 1346 speakup_console[vc_num] = kzalloc(sizeof(*speakup_console[0]), 1347 gfp_flags); 1348 if (!speakup_console[vc_num]) 1349 return -ENOMEM; 1350 speakup_date(vc); 1351 } else if (!spk_parked) { 1352 speakup_date(vc); 1353 } 1354 1355 return 0; 1356 } 1357 1358 static void speakup_deallocate(struct vc_data *vc) 1359 { 1360 int vc_num; 1361 1362 vc_num = vc->vc_num; 1363 kfree(speakup_console[vc_num]); 1364 speakup_console[vc_num] = NULL; 1365 } 1366 1367 enum read_all_command { 1368 RA_NEXT_SENT = KVAL(K_DOWN)+1, 1369 RA_PREV_LINE = KVAL(K_LEFT)+1, 1370 RA_NEXT_LINE = KVAL(K_RIGHT)+1, 1371 RA_PREV_SENT = KVAL(K_UP)+1, 1372 RA_DOWN_ARROW, 1373 RA_TIMER, 1374 RA_FIND_NEXT_SENT, 1375 RA_FIND_PREV_SENT, 1376 }; 1377 1378 static u_char is_cursor; 1379 static u_long old_cursor_pos, old_cursor_x, old_cursor_y; 1380 static int cursor_con; 1381 1382 static void reset_highlight_buffers(struct vc_data *); 1383 1384 static enum read_all_command read_all_key; 1385 1386 static int in_keyboard_notifier; 1387 1388 static void start_read_all_timer(struct vc_data *vc, enum read_all_command command); 1389 1390 static void kbd_fakekey2(struct vc_data *vc, enum read_all_command command) 1391 { 1392 del_timer(&cursor_timer); 1393 speakup_fake_down_arrow(); 1394 start_read_all_timer(vc, command); 1395 } 1396 1397 static void read_all_doc(struct vc_data *vc) 1398 { 1399 if ((vc->vc_num != fg_console) || !synth || spk_shut_up) 1400 return; 1401 if (!synth_supports_indexing()) 1402 return; 1403 if (cursor_track != read_all_mode) 1404 prev_cursor_track = cursor_track; 1405 cursor_track = read_all_mode; 1406 spk_reset_index_count(0); 1407 if (get_sentence_buf(vc, 0) == -1) { 1408 del_timer(&cursor_timer); 1409 if (!in_keyboard_notifier) 1410 speakup_fake_down_arrow(); 1411 start_read_all_timer(vc, RA_DOWN_ARROW); 1412 } else { 1413 say_sentence_num(0, 0); 1414 synth_insert_next_index(0); 1415 start_read_all_timer(vc, RA_TIMER); 1416 } 1417 } 1418 1419 static void stop_read_all(struct vc_data *vc) 1420 { 1421 del_timer(&cursor_timer); 1422 cursor_track = prev_cursor_track; 1423 spk_shut_up &= 0xfe; 1424 spk_do_flush(); 1425 } 1426 1427 static void start_read_all_timer(struct vc_data *vc, enum read_all_command command) 1428 { 1429 struct var_t *cursor_timeout; 1430 1431 cursor_con = vc->vc_num; 1432 read_all_key = command; 1433 cursor_timeout = spk_get_var(CURSOR_TIME); 1434 mod_timer(&cursor_timer, 1435 jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); 1436 } 1437 1438 static void handle_cursor_read_all(struct vc_data *vc, enum read_all_command command) 1439 { 1440 int indcount, sentcount, rv, sn; 1441 1442 switch (command) { 1443 case RA_NEXT_SENT: 1444 /* Get Current Sentence */ 1445 spk_get_index_count(&indcount, &sentcount); 1446 /*printk("%d %d ", indcount, sentcount); */ 1447 spk_reset_index_count(sentcount + 1); 1448 if (indcount == 1) { 1449 if (!say_sentence_num(sentcount + 1, 0)) { 1450 kbd_fakekey2(vc, RA_FIND_NEXT_SENT); 1451 return; 1452 } 1453 synth_insert_next_index(0); 1454 } else { 1455 sn = 0; 1456 if (!say_sentence_num(sentcount + 1, 1)) { 1457 sn = 1; 1458 spk_reset_index_count(sn); 1459 } else { 1460 synth_insert_next_index(0); 1461 } 1462 if (!say_sentence_num(sn, 0)) { 1463 kbd_fakekey2(vc, RA_FIND_NEXT_SENT); 1464 return; 1465 } 1466 synth_insert_next_index(0); 1467 } 1468 start_read_all_timer(vc, RA_TIMER); 1469 break; 1470 case RA_PREV_SENT: 1471 break; 1472 case RA_NEXT_LINE: 1473 read_all_doc(vc); 1474 break; 1475 case RA_PREV_LINE: 1476 break; 1477 case RA_DOWN_ARROW: 1478 if (get_sentence_buf(vc, 0) == -1) { 1479 kbd_fakekey2(vc, RA_DOWN_ARROW); 1480 } else { 1481 say_sentence_num(0, 0); 1482 synth_insert_next_index(0); 1483 start_read_all_timer(vc, RA_TIMER); 1484 } 1485 break; 1486 case RA_FIND_NEXT_SENT: 1487 rv = get_sentence_buf(vc, 0); 1488 if (rv == -1) 1489 read_all_doc(vc); 1490 if (rv == 0) { 1491 kbd_fakekey2(vc, RA_FIND_NEXT_SENT); 1492 } else { 1493 say_sentence_num(1, 0); 1494 synth_insert_next_index(0); 1495 start_read_all_timer(vc, RA_TIMER); 1496 } 1497 break; 1498 case RA_FIND_PREV_SENT: 1499 break; 1500 case RA_TIMER: 1501 spk_get_index_count(&indcount, &sentcount); 1502 if (indcount < 2) 1503 kbd_fakekey2(vc, RA_DOWN_ARROW); 1504 else 1505 start_read_all_timer(vc, RA_TIMER); 1506 break; 1507 } 1508 } 1509 1510 static int pre_handle_cursor(struct vc_data *vc, u_char value, char up_flag) 1511 { 1512 unsigned long flags; 1513 1514 spin_lock_irqsave(&speakup_info.spinlock, flags); 1515 if (cursor_track == read_all_mode) { 1516 spk_parked &= 0xfe; 1517 if (!synth || up_flag || spk_shut_up) { 1518 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1519 return NOTIFY_STOP; 1520 } 1521 del_timer(&cursor_timer); 1522 spk_shut_up &= 0xfe; 1523 spk_do_flush(); 1524 start_read_all_timer(vc, value + 1); 1525 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1526 return NOTIFY_STOP; 1527 } 1528 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1529 return NOTIFY_OK; 1530 } 1531 1532 static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag) 1533 { 1534 unsigned long flags; 1535 struct var_t *cursor_timeout; 1536 1537 spin_lock_irqsave(&speakup_info.spinlock, flags); 1538 spk_parked &= 0xfe; 1539 if (!synth || up_flag || spk_shut_up || cursor_track == CT_Off) { 1540 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1541 return; 1542 } 1543 spk_shut_up &= 0xfe; 1544 if (spk_no_intr) 1545 spk_do_flush(); 1546 /* the key press flushes if !no_inter but we want to flush on cursor 1547 * moves regardless of no_inter state 1548 */ 1549 is_cursor = value + 1; 1550 old_cursor_pos = vc->vc_pos; 1551 old_cursor_x = vc->state.x; 1552 old_cursor_y = vc->state.y; 1553 speakup_console[vc->vc_num]->ht.cy = vc->state.y; 1554 cursor_con = vc->vc_num; 1555 if (cursor_track == CT_Highlight) 1556 reset_highlight_buffers(vc); 1557 cursor_timeout = spk_get_var(CURSOR_TIME); 1558 mod_timer(&cursor_timer, 1559 jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); 1560 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1561 } 1562 1563 static void update_color_buffer(struct vc_data *vc, const u16 *ic, int len) 1564 { 1565 int i, bi, hi; 1566 int vc_num = vc->vc_num; 1567 1568 bi = (vc->vc_attr & 0x70) >> 4; 1569 hi = speakup_console[vc_num]->ht.highsize[bi]; 1570 1571 i = 0; 1572 if (speakup_console[vc_num]->ht.highsize[bi] == 0) { 1573 speakup_console[vc_num]->ht.rpos[bi] = vc->vc_pos; 1574 speakup_console[vc_num]->ht.rx[bi] = vc->state.x; 1575 speakup_console[vc_num]->ht.ry[bi] = vc->state.y; 1576 } 1577 while ((hi < COLOR_BUFFER_SIZE) && (i < len)) { 1578 if (ic[i] > 32) { 1579 speakup_console[vc_num]->ht.highbuf[bi][hi] = ic[i]; 1580 hi++; 1581 } else if ((ic[i] == 32) && (hi != 0)) { 1582 if (speakup_console[vc_num]->ht.highbuf[bi][hi - 1] != 1583 32) { 1584 speakup_console[vc_num]->ht.highbuf[bi][hi] = 1585 ic[i]; 1586 hi++; 1587 } 1588 } 1589 i++; 1590 } 1591 speakup_console[vc_num]->ht.highsize[bi] = hi; 1592 } 1593 1594 static void reset_highlight_buffers(struct vc_data *vc) 1595 { 1596 int i; 1597 int vc_num = vc->vc_num; 1598 1599 for (i = 0; i < 8; i++) 1600 speakup_console[vc_num]->ht.highsize[i] = 0; 1601 } 1602 1603 static int count_highlight_color(struct vc_data *vc) 1604 { 1605 int i, bg; 1606 int cc; 1607 int vc_num = vc->vc_num; 1608 u16 ch; 1609 u16 *start = (u16 *)vc->vc_origin; 1610 1611 for (i = 0; i < 8; i++) 1612 speakup_console[vc_num]->ht.bgcount[i] = 0; 1613 1614 for (i = 0; i < vc->vc_rows; i++) { 1615 u16 *end = start + vc->vc_cols * 2; 1616 u16 *ptr; 1617 1618 for (ptr = start; ptr < end; ptr++) { 1619 ch = get_attributes(vc, ptr); 1620 bg = (ch & 0x70) >> 4; 1621 speakup_console[vc_num]->ht.bgcount[bg]++; 1622 } 1623 start += vc->vc_size_row; 1624 } 1625 1626 cc = 0; 1627 for (i = 0; i < 8; i++) 1628 if (speakup_console[vc_num]->ht.bgcount[i] > 0) 1629 cc++; 1630 return cc; 1631 } 1632 1633 static int get_highlight_color(struct vc_data *vc) 1634 { 1635 int i, j; 1636 unsigned int cptr[8]; 1637 int vc_num = vc->vc_num; 1638 1639 for (i = 0; i < 8; i++) 1640 cptr[i] = i; 1641 1642 for (i = 0; i < 7; i++) 1643 for (j = i + 1; j < 8; j++) 1644 if (speakup_console[vc_num]->ht.bgcount[cptr[i]] > 1645 speakup_console[vc_num]->ht.bgcount[cptr[j]]) 1646 swap(cptr[i], cptr[j]); 1647 1648 for (i = 0; i < 8; i++) 1649 if (speakup_console[vc_num]->ht.bgcount[cptr[i]] != 0) 1650 if (speakup_console[vc_num]->ht.highsize[cptr[i]] > 0) 1651 return cptr[i]; 1652 return -1; 1653 } 1654 1655 static int speak_highlight(struct vc_data *vc) 1656 { 1657 int hc, d; 1658 int vc_num = vc->vc_num; 1659 1660 if (count_highlight_color(vc) == 1) 1661 return 0; 1662 hc = get_highlight_color(vc); 1663 if (hc != -1) { 1664 d = vc->state.y - speakup_console[vc_num]->ht.cy; 1665 if ((d == 1) || (d == -1)) 1666 if (speakup_console[vc_num]->ht.ry[hc] != vc->state.y) 1667 return 0; 1668 spk_parked |= 0x01; 1669 spk_do_flush(); 1670 spkup_write(speakup_console[vc_num]->ht.highbuf[hc], 1671 speakup_console[vc_num]->ht.highsize[hc]); 1672 spk_pos = spk_cp = speakup_console[vc_num]->ht.rpos[hc]; 1673 spk_x = spk_cx = speakup_console[vc_num]->ht.rx[hc]; 1674 spk_y = spk_cy = speakup_console[vc_num]->ht.ry[hc]; 1675 return 1; 1676 } 1677 return 0; 1678 } 1679 1680 static void cursor_done(struct timer_list *unused) 1681 { 1682 struct vc_data *vc = vc_cons[cursor_con].d; 1683 unsigned long flags; 1684 1685 del_timer(&cursor_timer); 1686 spin_lock_irqsave(&speakup_info.spinlock, flags); 1687 if (cursor_con != fg_console) { 1688 is_cursor = 0; 1689 goto out; 1690 } 1691 speakup_date(vc); 1692 if (win_enabled) { 1693 if (vc->state.x >= win_left && vc->state.x <= win_right && 1694 vc->state.y >= win_top && vc->state.y <= win_bottom) { 1695 spk_keydown = 0; 1696 is_cursor = 0; 1697 goto out; 1698 } 1699 } 1700 if (cursor_track == read_all_mode) { 1701 handle_cursor_read_all(vc, read_all_key); 1702 goto out; 1703 } 1704 if (cursor_track == CT_Highlight) { 1705 if (speak_highlight(vc)) { 1706 spk_keydown = 0; 1707 is_cursor = 0; 1708 goto out; 1709 } 1710 } 1711 if (cursor_track == CT_Window) 1712 speakup_win_say(vc); 1713 else if (is_cursor == 1 || is_cursor == 4) 1714 say_line_from_to(vc, 0, vc->vc_cols, 0); 1715 else 1716 say_char(vc); 1717 spk_keydown = 0; 1718 is_cursor = 0; 1719 out: 1720 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1721 } 1722 1723 /* called by: vt_notifier_call() */ 1724 static void speakup_bs(struct vc_data *vc) 1725 { 1726 unsigned long flags; 1727 1728 if (!speakup_console[vc->vc_num]) 1729 return; 1730 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags)) 1731 /* Speakup output, discard */ 1732 return; 1733 if (!spk_parked) 1734 speakup_date(vc); 1735 if (spk_shut_up || !synth) { 1736 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1737 return; 1738 } 1739 if (vc->vc_num == fg_console && spk_keydown) { 1740 spk_keydown = 0; 1741 if (!is_cursor) 1742 say_char(vc); 1743 } 1744 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1745 } 1746 1747 /* called by: vt_notifier_call() */ 1748 static void speakup_con_write(struct vc_data *vc, u16 *str, int len) 1749 { 1750 unsigned long flags; 1751 1752 if ((vc->vc_num != fg_console) || spk_shut_up || !synth) 1753 return; 1754 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags)) 1755 /* Speakup output, discard */ 1756 return; 1757 if (spk_bell_pos && spk_keydown && (vc->state.x == spk_bell_pos - 1)) 1758 bleep(3); 1759 if ((is_cursor) || (cursor_track == read_all_mode)) { 1760 if (cursor_track == CT_Highlight) 1761 update_color_buffer(vc, str, len); 1762 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1763 return; 1764 } 1765 if (win_enabled) { 1766 if (vc->state.x >= win_left && vc->state.x <= win_right && 1767 vc->state.y >= win_top && vc->state.y <= win_bottom) { 1768 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1769 return; 1770 } 1771 } 1772 1773 spkup_write(str, len); 1774 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1775 } 1776 1777 static void speakup_con_update(struct vc_data *vc) 1778 { 1779 unsigned long flags; 1780 1781 if (!speakup_console[vc->vc_num] || spk_parked) 1782 return; 1783 if (!spin_trylock_irqsave(&speakup_info.spinlock, flags)) 1784 /* Speakup output, discard */ 1785 return; 1786 speakup_date(vc); 1787 if (vc->vc_mode == KD_GRAPHICS && !spk_paused && spk_str_pause[0]) { 1788 synth_printf("%s", spk_str_pause); 1789 spk_paused = true; 1790 } 1791 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1792 } 1793 1794 static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag) 1795 { 1796 unsigned long flags; 1797 int on_off = 2; 1798 char *label; 1799 1800 if (!synth || up_flag || spk_killed) 1801 return; 1802 spin_lock_irqsave(&speakup_info.spinlock, flags); 1803 spk_shut_up &= 0xfe; 1804 if (spk_no_intr) 1805 spk_do_flush(); 1806 switch (value) { 1807 case KVAL(K_CAPS): 1808 label = spk_msg_get(MSG_KEYNAME_CAPSLOCK); 1809 on_off = vt_get_leds(fg_console, VC_CAPSLOCK); 1810 break; 1811 case KVAL(K_NUM): 1812 label = spk_msg_get(MSG_KEYNAME_NUMLOCK); 1813 on_off = vt_get_leds(fg_console, VC_NUMLOCK); 1814 break; 1815 case KVAL(K_HOLD): 1816 label = spk_msg_get(MSG_KEYNAME_SCROLLLOCK); 1817 on_off = vt_get_leds(fg_console, VC_SCROLLOCK); 1818 if (speakup_console[vc->vc_num]) 1819 speakup_console[vc->vc_num]->tty_stopped = on_off; 1820 break; 1821 default: 1822 spk_parked &= 0xfe; 1823 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1824 return; 1825 } 1826 if (on_off < 2) 1827 synth_printf("%s %s\n", 1828 label, spk_msg_get(MSG_STATUS_START + on_off)); 1829 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 1830 } 1831 1832 static int inc_dec_var(u_char value) 1833 { 1834 struct st_var_header *p_header; 1835 struct var_t *var_data; 1836 char num_buf[32]; 1837 char *cp = num_buf; 1838 char *pn; 1839 int var_id = (int)value - VAR_START; 1840 int how = (var_id & 1) ? E_INC : E_DEC; 1841 1842 var_id = var_id / 2 + FIRST_SET_VAR; 1843 p_header = spk_get_var_header(var_id); 1844 if (!p_header) 1845 return -1; 1846 if (p_header->var_type != VAR_NUM) 1847 return -1; 1848 var_data = p_header->data; 1849 if (spk_set_num_var(1, p_header, how) != 0) 1850 return -1; 1851 if (!spk_close_press) { 1852 for (pn = p_header->name; *pn; pn++) { 1853 if (*pn == '_') 1854 *cp = SPACE; 1855 else 1856 *cp++ = *pn; 1857 } 1858 } 1859 snprintf(cp, sizeof(num_buf) - (cp - num_buf), " %d ", 1860 var_data->u.n.value); 1861 synth_printf("%s", num_buf); 1862 return 0; 1863 } 1864 1865 static void speakup_win_set(struct vc_data *vc) 1866 { 1867 char info[40]; 1868 1869 if (win_start > 1) { 1870 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_ALREADY_SET)); 1871 return; 1872 } 1873 if (spk_x < win_left || spk_y < win_top) { 1874 synth_printf("%s\n", spk_msg_get(MSG_END_BEFORE_START)); 1875 return; 1876 } 1877 if (win_start && spk_x == win_left && spk_y == win_top) { 1878 win_left = 0; 1879 win_right = vc->vc_cols - 1; 1880 win_bottom = spk_y; 1881 snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_LINE), 1882 (int)win_top + 1); 1883 } else { 1884 if (!win_start) { 1885 win_top = spk_y; 1886 win_left = spk_x; 1887 } else { 1888 win_bottom = spk_y; 1889 win_right = spk_x; 1890 } 1891 snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_BOUNDARY), 1892 (win_start) ? 1893 spk_msg_get(MSG_END) : spk_msg_get(MSG_START), 1894 (int)spk_y + 1, (int)spk_x + 1); 1895 } 1896 synth_printf("%s\n", info); 1897 win_start++; 1898 } 1899 1900 static void speakup_win_clear(struct vc_data *vc) 1901 { 1902 win_top = 0; 1903 win_bottom = 0; 1904 win_left = 0; 1905 win_right = 0; 1906 win_start = 0; 1907 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_CLEARED)); 1908 } 1909 1910 static void speakup_win_enable(struct vc_data *vc) 1911 { 1912 if (win_start < 2) { 1913 synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW)); 1914 return; 1915 } 1916 win_enabled ^= 1; 1917 if (win_enabled) 1918 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCED)); 1919 else 1920 synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCE_DISABLED)); 1921 } 1922 1923 static void speakup_bits(struct vc_data *vc) 1924 { 1925 int val = this_speakup_key - (FIRST_EDIT_BITS - 1); 1926 1927 if (spk_special_handler || val < 1 || val > 6) { 1928 synth_printf("%s\n", spk_msg_get(MSG_ERROR)); 1929 return; 1930 } 1931 pb_edit = &spk_punc_info[val]; 1932 synth_printf(spk_msg_get(MSG_EDIT_PROMPT), pb_edit->name); 1933 spk_special_handler = edit_bits; 1934 } 1935 1936 static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key) 1937 { 1938 static u_char goto_buf[8]; 1939 static int num; 1940 int maxlen; 1941 char *cp; 1942 u16 wch; 1943 1944 if (type == KT_SPKUP && ch == SPEAKUP_GOTO) 1945 goto do_goto; 1946 if (type == KT_LATIN && ch == '\n') 1947 goto do_goto; 1948 if (type != 0) 1949 goto oops; 1950 if (ch == 8) { 1951 u16 wch; 1952 1953 if (num == 0) 1954 return -1; 1955 wch = goto_buf[--num]; 1956 goto_buf[num] = '\0'; 1957 spkup_write(&wch, 1); 1958 return 1; 1959 } 1960 if (ch < '+' || ch > 'y') 1961 goto oops; 1962 wch = ch; 1963 goto_buf[num++] = ch; 1964 goto_buf[num] = '\0'; 1965 spkup_write(&wch, 1); 1966 maxlen = (*goto_buf >= '0') ? 3 : 4; 1967 if ((ch == '+' || ch == '-') && num == 1) 1968 return 1; 1969 if (ch >= '0' && ch <= '9' && num < maxlen) 1970 return 1; 1971 if (num < maxlen - 1 || num > maxlen) 1972 goto oops; 1973 if (ch < 'x' || ch > 'y') { 1974 oops: 1975 if (!spk_killed) 1976 synth_printf(" %s\n", spk_msg_get(MSG_GOTO_CANCELED)); 1977 goto_buf[num = 0] = '\0'; 1978 spk_special_handler = NULL; 1979 return 1; 1980 } 1981 1982 /* Do not replace with kstrtoul: here we need cp to be updated */ 1983 goto_pos = simple_strtoul(goto_buf, &cp, 10); 1984 1985 if (*cp == 'x') { 1986 if (*goto_buf < '0') 1987 goto_pos += spk_x; 1988 else if (goto_pos > 0) 1989 goto_pos--; 1990 1991 if (goto_pos >= vc->vc_cols) 1992 goto_pos = vc->vc_cols - 1; 1993 goto_x = 1; 1994 } else { 1995 if (*goto_buf < '0') 1996 goto_pos += spk_y; 1997 else if (goto_pos > 0) 1998 goto_pos--; 1999 2000 if (goto_pos >= vc->vc_rows) 2001 goto_pos = vc->vc_rows - 1; 2002 goto_x = 0; 2003 } 2004 goto_buf[num = 0] = '\0'; 2005 do_goto: 2006 spk_special_handler = NULL; 2007 spk_parked |= 0x01; 2008 if (goto_x) { 2009 spk_pos -= spk_x * 2; 2010 spk_x = goto_pos; 2011 spk_pos += goto_pos * 2; 2012 say_word(vc); 2013 } else { 2014 spk_y = goto_pos; 2015 spk_pos = vc->vc_origin + (goto_pos * vc->vc_size_row); 2016 say_line(vc); 2017 } 2018 return 1; 2019 } 2020 2021 static void speakup_goto(struct vc_data *vc) 2022 { 2023 if (spk_special_handler) { 2024 synth_printf("%s\n", spk_msg_get(MSG_ERROR)); 2025 return; 2026 } 2027 synth_printf("%s\n", spk_msg_get(MSG_GOTO)); 2028 spk_special_handler = handle_goto; 2029 } 2030 2031 static void speakup_help(struct vc_data *vc) 2032 { 2033 spk_handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0); 2034 } 2035 2036 static void do_nothing(struct vc_data *vc) 2037 { 2038 return; /* flush done in do_spkup */ 2039 } 2040 2041 static u_char key_speakup, spk_key_locked; 2042 2043 static void speakup_lock(struct vc_data *vc) 2044 { 2045 if (!spk_key_locked) { 2046 spk_key_locked = 16; 2047 key_speakup = 16; 2048 } else { 2049 spk_key_locked = 0; 2050 key_speakup = 0; 2051 } 2052 } 2053 2054 typedef void (*spkup_hand) (struct vc_data *); 2055 static spkup_hand spkup_handler[] = { 2056 /* must be ordered same as defines in speakup.h */ 2057 do_nothing, speakup_goto, speech_kill, speakup_shut_up, 2058 speakup_cut, speakup_paste, say_first_char, say_last_char, 2059 say_char, say_prev_char, say_next_char, 2060 say_word, say_prev_word, say_next_word, 2061 say_line, say_prev_line, say_next_line, 2062 top_edge, bottom_edge, left_edge, right_edge, 2063 spell_word, spell_word, say_screen, 2064 say_position, say_attributes, 2065 speakup_off, speakup_parked, say_line, /* this is for indent */ 2066 say_from_top, say_to_bottom, 2067 say_from_left, say_to_right, 2068 say_char_num, speakup_bits, speakup_bits, say_phonetic_char, 2069 speakup_bits, speakup_bits, speakup_bits, 2070 speakup_win_set, speakup_win_clear, speakup_win_enable, speakup_win_say, 2071 speakup_lock, speakup_help, toggle_cursoring, read_all_doc, NULL 2072 }; 2073 2074 static void do_spkup(struct vc_data *vc, u_char value) 2075 { 2076 if (spk_killed && value != SPEECH_KILL) 2077 return; 2078 spk_keydown = 0; 2079 spk_lastkey = 0; 2080 spk_shut_up &= 0xfe; 2081 this_speakup_key = value; 2082 if (value < SPKUP_MAX_FUNC && spkup_handler[value]) { 2083 spk_do_flush(); 2084 (*spkup_handler[value]) (vc); 2085 } else { 2086 if (inc_dec_var(value) < 0) 2087 bleep(9); 2088 } 2089 } 2090 2091 static const char *pad_chars = "0123456789+-*/\015,.?()"; 2092 2093 static int 2094 speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, 2095 int up_flag) 2096 { 2097 unsigned long flags; 2098 int kh; 2099 u_char *key_info; 2100 u_char type = KTYP(keysym), value = KVAL(keysym), new_key = 0; 2101 u_char shift_info, offset; 2102 int ret = 0; 2103 2104 if (!synth) 2105 return 0; 2106 2107 spin_lock_irqsave(&speakup_info.spinlock, flags); 2108 tty = vc->port.tty; 2109 if (type >= 0xf0) 2110 type -= 0xf0; 2111 if (type == KT_PAD && 2112 (vt_get_leds(fg_console, VC_NUMLOCK))) { 2113 if (up_flag) { 2114 spk_keydown = 0; 2115 goto out; 2116 } 2117 value = pad_chars[value]; 2118 spk_lastkey = value; 2119 spk_keydown++; 2120 spk_parked &= 0xfe; 2121 goto no_map; 2122 } 2123 if (keycode >= MAX_KEY) 2124 goto no_map; 2125 key_info = spk_our_keys[keycode]; 2126 if (!key_info) 2127 goto no_map; 2128 /* Check valid read all mode keys */ 2129 if ((cursor_track == read_all_mode) && (!up_flag)) { 2130 switch (value) { 2131 case KVAL(K_DOWN): 2132 case KVAL(K_UP): 2133 case KVAL(K_LEFT): 2134 case KVAL(K_RIGHT): 2135 case KVAL(K_PGUP): 2136 case KVAL(K_PGDN): 2137 break; 2138 default: 2139 stop_read_all(vc); 2140 break; 2141 } 2142 } 2143 shift_info = (shift_state & 0x0f) + key_speakup; 2144 offset = spk_shift_table[shift_info]; 2145 if (offset) { 2146 new_key = key_info[offset]; 2147 if (new_key) { 2148 ret = 1; 2149 if (new_key == SPK_KEY) { 2150 if (!spk_key_locked) 2151 key_speakup = (up_flag) ? 0 : 16; 2152 if (up_flag || spk_killed) 2153 goto out; 2154 spk_shut_up &= 0xfe; 2155 spk_do_flush(); 2156 goto out; 2157 } 2158 if (up_flag) 2159 goto out; 2160 if (last_keycode == keycode && 2161 time_after(last_spk_jiffy + MAX_DELAY, jiffies)) { 2162 spk_close_press = 1; 2163 offset = spk_shift_table[shift_info + 32]; 2164 /* double press? */ 2165 if (offset && key_info[offset]) 2166 new_key = key_info[offset]; 2167 } 2168 last_keycode = keycode; 2169 last_spk_jiffy = jiffies; 2170 type = KT_SPKUP; 2171 value = new_key; 2172 } 2173 } 2174 no_map: 2175 if (type == KT_SPKUP && !spk_special_handler) { 2176 do_spkup(vc, new_key); 2177 spk_close_press = 0; 2178 ret = 1; 2179 goto out; 2180 } 2181 if (up_flag || spk_killed || type == KT_SHIFT) 2182 goto out; 2183 spk_shut_up &= 0xfe; 2184 kh = (value == KVAL(K_DOWN)) || 2185 (value == KVAL(K_UP)) || 2186 (value == KVAL(K_LEFT)) || 2187 (value == KVAL(K_RIGHT)); 2188 if ((cursor_track != read_all_mode) || !kh) 2189 if (!spk_no_intr) 2190 spk_do_flush(); 2191 if (spk_special_handler) { 2192 if (type == KT_SPEC && value == 1) { 2193 value = '\n'; 2194 type = KT_LATIN; 2195 } else if (type == KT_LETTER) { 2196 type = KT_LATIN; 2197 } else if (value == 0x7f) { 2198 value = 8; /* make del = backspace */ 2199 } 2200 ret = (*spk_special_handler) (vc, type, value, keycode); 2201 spk_close_press = 0; 2202 if (ret < 0) 2203 bleep(9); 2204 goto out; 2205 } 2206 last_keycode = 0; 2207 out: 2208 spin_unlock_irqrestore(&speakup_info.spinlock, flags); 2209 return ret; 2210 } 2211 2212 static int keyboard_notifier_call(struct notifier_block *nb, 2213 unsigned long code, void *_param) 2214 { 2215 struct keyboard_notifier_param *param = _param; 2216 struct vc_data *vc = param->vc; 2217 int up = !param->down; 2218 int ret = NOTIFY_OK; 2219 static int keycode; /* to hold the current keycode */ 2220 2221 in_keyboard_notifier = 1; 2222 2223 if (vc->vc_mode == KD_GRAPHICS) 2224 goto out; 2225 2226 /* 2227 * First, determine whether we are handling a fake keypress on 2228 * the current processor. If we are, then return NOTIFY_OK, 2229 * to pass the keystroke up the chain. This prevents us from 2230 * trying to take the Speakup lock while it is held by the 2231 * processor on which the simulated keystroke was generated. 2232 * Also, the simulated keystrokes should be ignored by Speakup. 2233 */ 2234 2235 if (speakup_fake_key_pressed()) 2236 goto out; 2237 2238 switch (code) { 2239 case KBD_KEYCODE: 2240 /* speakup requires keycode and keysym currently */ 2241 keycode = param->value; 2242 break; 2243 case KBD_UNBOUND_KEYCODE: 2244 /* not used yet */ 2245 break; 2246 case KBD_UNICODE: 2247 /* not used yet */ 2248 break; 2249 case KBD_KEYSYM: 2250 if (speakup_key(vc, param->shift, keycode, param->value, up)) 2251 ret = NOTIFY_STOP; 2252 else if (KTYP(param->value) == KT_CUR) 2253 ret = pre_handle_cursor(vc, KVAL(param->value), up); 2254 break; 2255 case KBD_POST_KEYSYM:{ 2256 unsigned char type = KTYP(param->value) - 0xf0; 2257 unsigned char val = KVAL(param->value); 2258 2259 switch (type) { 2260 case KT_SHIFT: 2261 do_handle_shift(vc, val, up); 2262 break; 2263 case KT_LATIN: 2264 case KT_LETTER: 2265 do_handle_latin(vc, val, up); 2266 break; 2267 case KT_CUR: 2268 do_handle_cursor(vc, val, up); 2269 break; 2270 case KT_SPEC: 2271 do_handle_spec(vc, val, up); 2272 break; 2273 } 2274 break; 2275 } 2276 } 2277 out: 2278 in_keyboard_notifier = 0; 2279 return ret; 2280 } 2281 2282 static int vt_notifier_call(struct notifier_block *nb, 2283 unsigned long code, void *_param) 2284 { 2285 struct vt_notifier_param *param = _param; 2286 struct vc_data *vc = param->vc; 2287 2288 switch (code) { 2289 case VT_ALLOCATE: 2290 if (vc->vc_mode == KD_TEXT) 2291 speakup_allocate(vc, GFP_ATOMIC); 2292 break; 2293 case VT_DEALLOCATE: 2294 speakup_deallocate(vc); 2295 break; 2296 case VT_WRITE: 2297 if (param->c == '\b') { 2298 speakup_bs(vc); 2299 } else { 2300 u16 d = param->c; 2301 2302 speakup_con_write(vc, &d, 1); 2303 } 2304 break; 2305 case VT_UPDATE: 2306 speakup_con_update(vc); 2307 break; 2308 } 2309 return NOTIFY_OK; 2310 } 2311 2312 /* called by: module_exit() */ 2313 static void __exit speakup_exit(void) 2314 { 2315 int i; 2316 2317 unregister_keyboard_notifier(&keyboard_notifier_block); 2318 unregister_vt_notifier(&vt_notifier_block); 2319 speakup_unregister_devsynth(); 2320 speakup_cancel_selection(); 2321 speakup_cancel_paste(); 2322 del_timer_sync(&cursor_timer); 2323 kthread_stop(speakup_task); 2324 speakup_task = NULL; 2325 mutex_lock(&spk_mutex); 2326 synth_release(); 2327 mutex_unlock(&spk_mutex); 2328 spk_ttyio_unregister_ldisc(); 2329 2330 speakup_kobj_exit(); 2331 2332 for (i = 0; i < MAX_NR_CONSOLES; i++) 2333 kfree(speakup_console[i]); 2334 2335 speakup_remove_virtual_keyboard(); 2336 2337 for (i = 0; i < MAXVARS; i++) 2338 speakup_unregister_var(i); 2339 2340 for (i = 0; i < 256; i++) { 2341 if (spk_characters[i] != spk_default_chars[i]) 2342 kfree(spk_characters[i]); 2343 } 2344 2345 spk_free_user_msgs(); 2346 } 2347 2348 /* call by: module_init() */ 2349 static int __init speakup_init(void) 2350 { 2351 int i; 2352 long err = 0; 2353 struct vc_data *vc = vc_cons[fg_console].d; 2354 struct var_t *var; 2355 2356 /* These first few initializations cannot fail. */ 2357 spk_initialize_msgs(); /* Initialize arrays for i18n. */ 2358 spk_reset_default_chars(); 2359 spk_reset_default_chartab(); 2360 spk_strlwr(synth_name); 2361 spk_vars[0].u.n.high = vc->vc_cols; 2362 for (var = spk_vars; var->var_id != MAXVARS; var++) 2363 speakup_register_var(var); 2364 for (var = synth_time_vars; 2365 (var->var_id >= 0) && (var->var_id < MAXVARS); var++) 2366 speakup_register_var(var); 2367 for (i = 1; spk_punc_info[i].mask != 0; i++) 2368 spk_set_mask_bits(NULL, i, 2); 2369 2370 spk_set_key_info(spk_key_defaults, spk_key_buf); 2371 2372 /* From here on out, initializations can fail. */ 2373 err = speakup_add_virtual_keyboard(); 2374 if (err) 2375 goto error_virtkeyboard; 2376 2377 for (i = 0; i < MAX_NR_CONSOLES; i++) 2378 if (vc_cons[i].d) { 2379 err = speakup_allocate(vc_cons[i].d, GFP_KERNEL); 2380 if (err) 2381 goto error_kobjects; 2382 } 2383 2384 if (spk_quiet_boot) 2385 spk_shut_up |= 0x01; 2386 2387 err = speakup_kobj_init(); 2388 if (err) 2389 goto error_kobjects; 2390 2391 spk_ttyio_register_ldisc(); 2392 synth_init(synth_name); 2393 speakup_register_devsynth(); 2394 /* 2395 * register_devsynth might fail, but this error is not fatal. 2396 * /dev/synth is an extra feature; the rest of Speakup 2397 * will work fine without it. 2398 */ 2399 2400 err = register_keyboard_notifier(&keyboard_notifier_block); 2401 if (err) 2402 goto error_kbdnotifier; 2403 err = register_vt_notifier(&vt_notifier_block); 2404 if (err) 2405 goto error_vtnotifier; 2406 2407 speakup_task = kthread_create(speakup_thread, NULL, "speakup"); 2408 2409 if (IS_ERR(speakup_task)) { 2410 err = PTR_ERR(speakup_task); 2411 goto error_task; 2412 } 2413 2414 set_user_nice(speakup_task, 10); 2415 wake_up_process(speakup_task); 2416 2417 pr_info("speakup %s: initialized\n", SPEAKUP_VERSION); 2418 pr_info("synth name on entry is: %s\n", synth_name); 2419 goto out; 2420 2421 error_task: 2422 unregister_vt_notifier(&vt_notifier_block); 2423 2424 error_vtnotifier: 2425 unregister_keyboard_notifier(&keyboard_notifier_block); 2426 del_timer(&cursor_timer); 2427 2428 error_kbdnotifier: 2429 speakup_unregister_devsynth(); 2430 mutex_lock(&spk_mutex); 2431 synth_release(); 2432 mutex_unlock(&spk_mutex); 2433 speakup_kobj_exit(); 2434 2435 error_kobjects: 2436 for (i = 0; i < MAX_NR_CONSOLES; i++) 2437 kfree(speakup_console[i]); 2438 2439 speakup_remove_virtual_keyboard(); 2440 2441 error_virtkeyboard: 2442 for (i = 0; i < MAXVARS; i++) 2443 speakup_unregister_var(i); 2444 2445 for (i = 0; i < 256; i++) { 2446 if (spk_characters[i] != spk_default_chars[i]) 2447 kfree(spk_characters[i]); 2448 } 2449 2450 spk_free_user_msgs(); 2451 2452 out: 2453 return err; 2454 } 2455 2456 module_init(speakup_init); 2457 module_exit(speakup_exit); 2458