drivers/accessibility/braille/braille_console.c

   1 /*
   2  * Minimalistic braille device kernel support.
   3  *
   4  * By default, shows console messages on the braille device.
   5  * Pressing Insert switches to VC browsing.
   6  *
   7  *  Copyright (C) Samuel Thibault <samuel.thibault@ens-lyon.org>
   8  *
   9  * This program is free software ; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation ; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY ; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with the program ; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/console.h>
  28 #include <linux/notifier.h>
  29
  30 #include <linux/selection.h>
  31 #include <linux/vt_kern.h>
  32 #include <linux/consolemap.h>
  33
  34 #include <linux/keyboard.h>
  35 #include <linux/kbd_kern.h>
  36 #include <linux/input.h>
  37
  38 MODULE_AUTHOR("samuel.thibault@ens-lyon.org");
  39 MODULE_DESCRIPTION("braille device");
  40 MODULE_LICENSE("GPL");
  41
  42 /*
  43  * Braille device support part.
  44  */
  45
  46 /* Emit various sounds */
  47 static bool sound;
  48 module_param(sound, bool, 0);
  49 MODULE_PARM_DESC(sound, "emit sounds");
  50
  51 static void beep(unsigned int freq)
  52 {
  53         if (sound)
  54                 kd_mksound(freq, HZ/10);
  55 }
  56
  57 /* mini console */
  58 #define WIDTH 40
  59 #define BRAILLE_KEY KEY_INSERT
  60 static u16 console_buf[WIDTH];
  61 static int console_cursor;
  62
  63 /* mini view of VC */
  64 static int vc_x, vc_y, lastvc_x, lastvc_y;
  65
  66 /* show console ? (or show VC) */
  67 static int console_show = 1;
  68 /* pending newline ? */
  69 static int console_newline = 1;
  70 static int lastVC = -1;
  71
  72 static struct console *braille_co;
  73
  74 /* Very VisioBraille-specific */
  75 static void braille_write(u16 *buf)
  76 {
  77         static u16 lastwrite[WIDTH];
  78         unsigned char data[1 + 1 + 2*WIDTH + 2 + 1], csum = 0, *c;
  79         u16 out;
  80         int i;
  81
  82         if (!braille_co)
  83                 return;
  84
  85         if (!memcmp(lastwrite, buf, WIDTH * sizeof(*buf)))
  86                 return;
  87         memcpy(lastwrite, buf, WIDTH * sizeof(*buf));
  88
  89 #define SOH 1
  90 #define STX 2
  91 #define ETX 2
  92 #define EOT 4
  93 #define ENQ 5
  94         data[0] = STX;
  95         data[1] = '>';
  96         csum ^= '>';
  97         c = &data[2];
  98         for (i = 0; i < WIDTH; i++) {
  99                 out = buf[i];
 100                 if (out >= 0x100)
 101                         out = '?';
 102                 else if (out == 0x00)
 103                         out = ' ';
 104                 csum ^= out;
 105                 if (out <= 0x05) {
 106                         *c++ = SOH;
 107                         out |= 0x40;
 108                 }
 109                 *c++ = out;
 110         }
 111
 112         if (csum <= 0x05) {
 113                 *c++ = SOH;
 114                 csum |= 0x40;
 115         }
 116         *c++ = csum;
 117         *c++ = ETX;
 118
 119         braille_co->write(braille_co, data, c - data);
 120 }
 121
 122 /* Follow the VC cursor*/
 123 static void vc_follow_cursor(struct vc_data *vc)
 124 {
 125         vc_x = vc->vc_x - (vc->vc_x % WIDTH);
 126         vc_y = vc->vc_y;
 127         lastvc_x = vc->vc_x;
 128         lastvc_y = vc->vc_y;
 129 }
 130
 131 /* Maybe the VC cursor moved, if so follow it */
 132 static void vc_maybe_cursor_moved(struct vc_data *vc)
 133 {
 134         if (vc->vc_x != lastvc_x || vc->vc_y != lastvc_y)
 135                 vc_follow_cursor(vc);
 136 }
 137
 138 /* Show portion of VC at vc_x, vc_y */
 139 static void vc_refresh(struct vc_data *vc)
 140 {
 141         u16 buf[WIDTH];
 142         int i;
 143
 144         for (i = 0; i < WIDTH; i++) {
 145                 u16 glyph = screen_glyph(vc,
 146                                 2 * (vc_x + i) + vc_y * vc->vc_size_row);
 147                 buf[i] = inverse_translate(vc, glyph, 1);
 148         }
 149         braille_write(buf);
 150 }
 151
 152 /*
 153  * Link to keyboard
 154  */
 155
 156 static int keyboard_notifier_call(struct notifier_block *blk,
 157                                   unsigned long code, void *_param)
 158 {
 159         struct keyboard_notifier_param *param = _param;
 160         struct vc_data *vc = param->vc;
 161         int ret = NOTIFY_OK;
 162
 163         if (!param->down)
 164                 return ret;
 165
 166         switch (code) {
 167         case KBD_KEYCODE:
 168                 if (console_show) {
 169                         if (param->value == BRAILLE_KEY) {
 170                                 console_show = 0;
 171                                 beep(880);
 172                                 vc_maybe_cursor_moved(vc);
 173                                 vc_refresh(vc);
 174                                 ret = NOTIFY_STOP;
 175                         }
 176                 } else {
 177                         ret = NOTIFY_STOP;
 178                         switch (param->value) {
 179                         case KEY_INSERT:
 180                                 beep(440);
 181                                 console_show = 1;
 182                                 lastVC = -1;
 183                                 braille_write(console_buf);
 184                                 break;
 185                         case KEY_LEFT:
 186                                 if (vc_x > 0) {
 187                                         vc_x -= WIDTH;
 188                                         if (vc_x < 0)
 189                                                 vc_x = 0;
 190                                 } else if (vc_y >= 1) {
 191                                         beep(880);
 192                                         vc_y--;
 193                                         vc_x = vc->vc_cols-WIDTH;
 194                                 } else
 195                                         beep(220);
 196                                 break;
 197                         case KEY_RIGHT:
 198                                 if (vc_x + WIDTH < vc->vc_cols) {
 199                                         vc_x += WIDTH;
 200                                 } else if (vc_y + 1 < vc->vc_rows) {
 201                                         beep(880);
 202                                         vc_y++;
 203                                         vc_x = 0;
 204                                 } else
 205                                         beep(220);
 206                                 break;
 207                         case KEY_DOWN:
 208                                 if (vc_y + 1 < vc->vc_rows)
 209                                         vc_y++;
 210                                 else
 211                                         beep(220);
 212                                 break;
 213                         case KEY_UP:
 214                                 if (vc_y >= 1)
 215                                         vc_y--;
 216                                 else
 217                                         beep(220);
 218                                 break;
 219                         case KEY_HOME:
 220                                 vc_follow_cursor(vc);
 221                                 break;
 222                         case KEY_PAGEUP:
 223                                 vc_x = 0;
 224                                 vc_y = 0;
 225                                 break;
 226                         case KEY_PAGEDOWN:
 227                                 vc_x = 0;
 228                                 vc_y = vc->vc_rows-1;
 229                                 break;
 230                         default:
 231                                 ret = NOTIFY_OK;
 232                                 break;
 233                         }
 234                         if (ret == NOTIFY_STOP)
 235                                 vc_refresh(vc);
 236                 }
 237                 break;
 238         case KBD_POST_KEYSYM:
 239         {
 240                 unsigned char type = KTYP(param->value) - 0xf0;
 241                 if (type == KT_SPEC) {
 242                         unsigned char val = KVAL(param->value);
 243                         int on_off = -1;
 244
 245                         switch (val) {
 246                         case KVAL(K_CAPS):
 247                                 on_off = vc_kbd_led(kbd_table + fg_console,
 248                                                 VC_CAPSLOCK);
 249                                 break;
 250                         case KVAL(K_NUM):
 251                                 on_off = vc_kbd_led(kbd_table + fg_console,
 252                                                 VC_NUMLOCK);
 253                                 break;
 254                         case KVAL(K_HOLD):
 255                                 on_off = vc_kbd_led(kbd_table + fg_console,
 256                                                 VC_SCROLLOCK);
 257                                 break;
 258                         }
 259                         if (on_off == 1)
 260                                 beep(880);
 261                         else if (on_off == 0)
 262                                 beep(440);
 263                 }
 264         }
 265         case KBD_UNBOUND_KEYCODE:
 266         case KBD_UNICODE:
 267         case KBD_KEYSYM:
 268                 /* Unused */
 269                 break;
 270         }
 271         return ret;
 272 }
 273
 274 static struct notifier_block keyboard_notifier_block = {
 275         .notifier_call = keyboard_notifier_call,
 276 };
 277
 278 static int vt_notifier_call(struct notifier_block *blk,
 279                             unsigned long code, void *_param)
 280 {
 281         struct vt_notifier_param *param = _param;
 282         struct vc_data *vc = param->vc;
 283         switch (code) {
 284         case VT_ALLOCATE:
 285                 break;
 286         case VT_DEALLOCATE:
 287                 break;
 288         case VT_WRITE:
 289         {
 290                 unsigned char c = param->c;
 291                 if (vc->vc_num != fg_console)
 292                         break;
 293                 switch (c) {
 294                 case '\b':
 295                 case 127:
 296                         if (console_cursor > 0) {
 297                                 console_cursor--;
 298                                 console_buf[console_cursor] = ' ';
 299                         }
 300                         break;
 301                 case '\n':
 302                 case '\v':
 303                 case '\f':
 304                 case '\r':
 305                         console_newline = 1;
 306                         break;
 307                 case '\t':
 308                         c = ' ';
 309                         /* Fallthrough */
 310                 default:
 311                         if (c < 32)
 312                                 /* Ignore other control sequences */
 313                                 break;
 314                         if (console_newline) {
 315                                 memset(console_buf, 0, sizeof(console_buf));
 316                                 console_cursor = 0;
 317                                 console_newline = 0;
 318                         }
 319                         if (console_cursor == WIDTH)
 320                                 memmove(console_buf, &console_buf[1],
 321                                         (WIDTH-1) * sizeof(*console_buf));
 322                         else
 323                                 console_cursor++;
 324                         console_buf[console_cursor-1] = c;
 325                         break;
 326                 }
 327                 if (console_show)
 328                         braille_write(console_buf);
 329                 else {
 330                         vc_maybe_cursor_moved(vc);
 331                         vc_refresh(vc);
 332                 }
 333                 break;
 334         }
 335         case VT_UPDATE:
 336                 /* Maybe a VT switch, flush */
 337                 if (console_show) {
 338                         if (vc->vc_num != lastVC) {
 339                                 lastVC = vc->vc_num;
 340                                 memset(console_buf, 0, sizeof(console_buf));
 341                                 console_cursor = 0;
 342                                 braille_write(console_buf);
 343                         }
 344                 } else {
 345                         vc_maybe_cursor_moved(vc);
 346                         vc_refresh(vc);
 347                 }
 348                 break;
 349         }
 350         return NOTIFY_OK;
 351 }
 352
 353 static struct notifier_block vt_notifier_block = {
 354         .notifier_call = vt_notifier_call,
 355 };
 356
 357 /*
 358  * Called from printk.c when console=brl is given
 359  */
 360
 361 int braille_register_console(struct console *console, int index,
 362                 char *console_options, char *braille_options)
 363 {
 364         int ret;
 365         if (!console_options)
 366                 /* Only support VisioBraille for now */
 367                 console_options = "57600o8";
 368         if (braille_co)
 369                 return -ENODEV;
 370         if (console->setup) {
 371                 ret = console->setup(console, console_options);
 372                 if (ret != 0)
 373                         return ret;
 374         }
 375         console->flags |= CON_ENABLED;
 376         console->index = index;
 377         braille_co = console;
 378         register_keyboard_notifier(&keyboard_notifier_block);
 379         register_vt_notifier(&vt_notifier_block);
 380         return 0;
 381 }
 382
 383 int braille_unregister_console(struct console *console)
 384 {
 385         if (braille_co != console)
 386                 return -EINVAL;
 387         unregister_keyboard_notifier(&keyboard_notifier_block);
 388         unregister_vt_notifier(&vt_notifier_block);
 389         braille_co = NULL;
 390         return 0;
 391 }