drivers/staging/speakup/main.c

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