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
beep(unsigned int freq)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 */
braille_write(u16 * buf)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*/
vc_follow_cursor(struct vc_data * vc)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 */
vc_maybe_cursor_moved(struct vc_data * vc)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 */
vc_refresh(struct vc_data * vc)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
keyboard_notifier_call(struct notifier_block * blk,unsigned long code,void * _param)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 = vt_get_leds(fg_console, VC_CAPSLOCK);
248 break;
249 case KVAL(K_NUM):
250 on_off = vt_get_leds(fg_console, VC_NUMLOCK);
251 break;
252 case KVAL(K_HOLD):
253 on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
254 break;
255 }
256 if (on_off == 1)
257 beep(880);
258 else if (on_off == 0)
259 beep(440);
260 }
261 }
262 case KBD_UNBOUND_KEYCODE:
263 case KBD_UNICODE:
264 case KBD_KEYSYM:
265 /* Unused */
266 break;
267 }
268 return ret;
269 }
270
271 static struct notifier_block keyboard_notifier_block = {
272 .notifier_call = keyboard_notifier_call,
273 };
274
vt_notifier_call(struct notifier_block * blk,unsigned long code,void * _param)275 static int vt_notifier_call(struct notifier_block *blk,
276 unsigned long code, void *_param)
277 {
278 struct vt_notifier_param *param = _param;
279 struct vc_data *vc = param->vc;
280 switch (code) {
281 case VT_ALLOCATE:
282 break;
283 case VT_DEALLOCATE:
284 break;
285 case VT_WRITE:
286 {
287 unsigned char c = param->c;
288 if (vc->vc_num != fg_console)
289 break;
290 switch (c) {
291 case '\b':
292 case 127:
293 if (console_cursor > 0) {
294 console_cursor--;
295 console_buf[console_cursor] = ' ';
296 }
297 break;
298 case '\n':
299 case '\v':
300 case '\f':
301 case '\r':
302 console_newline = 1;
303 break;
304 case '\t':
305 c = ' ';
306 /* Fallthrough */
307 default:
308 if (c < 32)
309 /* Ignore other control sequences */
310 break;
311 if (console_newline) {
312 memset(console_buf, 0, sizeof(console_buf));
313 console_cursor = 0;
314 console_newline = 0;
315 }
316 if (console_cursor == WIDTH)
317 memmove(console_buf, &console_buf[1],
318 (WIDTH-1) * sizeof(*console_buf));
319 else
320 console_cursor++;
321 console_buf[console_cursor-1] = c;
322 break;
323 }
324 if (console_show)
325 braille_write(console_buf);
326 else {
327 vc_maybe_cursor_moved(vc);
328 vc_refresh(vc);
329 }
330 break;
331 }
332 case VT_UPDATE:
333 /* Maybe a VT switch, flush */
334 if (console_show) {
335 if (vc->vc_num != lastVC) {
336 lastVC = vc->vc_num;
337 memset(console_buf, 0, sizeof(console_buf));
338 console_cursor = 0;
339 braille_write(console_buf);
340 }
341 } else {
342 vc_maybe_cursor_moved(vc);
343 vc_refresh(vc);
344 }
345 break;
346 }
347 return NOTIFY_OK;
348 }
349
350 static struct notifier_block vt_notifier_block = {
351 .notifier_call = vt_notifier_call,
352 };
353
354 /*
355 * Called from printk.c when console=brl is given
356 */
357
braille_register_console(struct console * console,int index,char * console_options,char * braille_options)358 int braille_register_console(struct console *console, int index,
359 char *console_options, char *braille_options)
360 {
361 int ret;
362
363 if (!(console->flags & CON_BRL))
364 return 0;
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 1;
381 }
382
braille_unregister_console(struct console * console)383 int braille_unregister_console(struct console *console)
384 {
385 if (braille_co != console)
386 return -EINVAL;
387 if (!(console->flags & CON_BRL))
388 return 0;
389 unregister_keyboard_notifier(&keyboard_notifier_block);
390 unregister_vt_notifier(&vt_notifier_block);
391 braille_co = NULL;
392 return 1;
393 }
394
