drivers/accessibility/braille/braille_console.c

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