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