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