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 
beep(unsigned int freq)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 */
braille_write(u16 * buf)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*/
vc_follow_cursor(struct vc_data * vc)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 */
vc_maybe_cursor_moved(struct vc_data * vc)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 */
vc_refresh(struct vc_data * vc)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, true);
135 	}
136 	braille_write(buf);
137 }
138 
139 /*
140  * Link to keyboard
141  */
142 
keyboard_notifier_call(struct notifier_block * blk,unsigned long code,void * _param)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 
229 		if (type == KT_SPEC) {
230 			unsigned char val = KVAL(param->value);
231 			int on_off = -1;
232 
233 			switch (val) {
234 			case KVAL(K_CAPS):
235 				on_off = vt_get_leds(fg_console, VC_CAPSLOCK);
236 				break;
237 			case KVAL(K_NUM):
238 				on_off = vt_get_leds(fg_console, VC_NUMLOCK);
239 				break;
240 			case KVAL(K_HOLD):
241 				on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
242 				break;
243 			}
244 			if (on_off == 1)
245 				beep(880);
246 			else if (on_off == 0)
247 				beep(440);
248 		}
249 	}
250 		break;
251 	case KBD_UNBOUND_KEYCODE:
252 	case KBD_UNICODE:
253 	case KBD_KEYSYM:
254 		/* Unused */
255 		break;
256 	}
257 	return ret;
258 }
259 
260 static struct notifier_block keyboard_notifier_block = {
261 	.notifier_call = keyboard_notifier_call,
262 };
263 
vt_notifier_call(struct notifier_block * blk,unsigned long code,void * _param)264 static int vt_notifier_call(struct notifier_block *blk,
265 			    unsigned long code, void *_param)
266 {
267 	struct vt_notifier_param *param = _param;
268 	struct vc_data *vc = param->vc;
269 
270 	switch (code) {
271 	case VT_ALLOCATE:
272 		break;
273 	case VT_DEALLOCATE:
274 		break;
275 	case VT_WRITE:
276 	{
277 		unsigned char c = param->c;
278 
279 		if (vc->vc_num != fg_console)
280 			break;
281 		switch (c) {
282 		case '\b':
283 		case 127:
284 			if (console_cursor > 0) {
285 				console_cursor--;
286 				console_buf[console_cursor] = ' ';
287 			}
288 			break;
289 		case '\n':
290 		case '\v':
291 		case '\f':
292 		case '\r':
293 			console_newline = 1;
294 			break;
295 		case '\t':
296 			c = ' ';
297 			fallthrough;
298 		default:
299 			if (c < 32)
300 				/* Ignore other control sequences */
301 				break;
302 			if (console_newline) {
303 				memset(console_buf, 0, sizeof(console_buf));
304 				console_cursor = 0;
305 				console_newline = 0;
306 			}
307 			if (console_cursor == WIDTH)
308 				memmove(console_buf, &console_buf[1],
309 					(WIDTH-1) * sizeof(*console_buf));
310 			else
311 				console_cursor++;
312 			console_buf[console_cursor-1] = c;
313 			break;
314 		}
315 		if (console_show)
316 			braille_write(console_buf);
317 		else {
318 			vc_maybe_cursor_moved(vc);
319 			vc_refresh(vc);
320 		}
321 		break;
322 	}
323 	case VT_UPDATE:
324 		/* Maybe a VT switch, flush */
325 		if (console_show) {
326 			if (vc->vc_num != lastVC) {
327 				lastVC = vc->vc_num;
328 				memset(console_buf, 0, sizeof(console_buf));
329 				console_cursor = 0;
330 				braille_write(console_buf);
331 			}
332 		} else {
333 			vc_maybe_cursor_moved(vc);
334 			vc_refresh(vc);
335 		}
336 		break;
337 	}
338 	return NOTIFY_OK;
339 }
340 
341 static struct notifier_block vt_notifier_block = {
342 	.notifier_call = vt_notifier_call,
343 };
344 
345 /*
346  * Called from printk.c when console=brl is given
347  */
348 
braille_register_console(struct console * console,int index,char * console_options,char * braille_options)349 int braille_register_console(struct console *console, int index,
350 		char *console_options, char *braille_options)
351 {
352 	int ret;
353 
354 	if (!console_options)
355 		/* Only support VisioBraille for now */
356 		console_options = "57600o8";
357 	if (braille_co)
358 		return -ENODEV;
359 	if (console->setup) {
360 		ret = console->setup(console, console_options);
361 		if (ret != 0)
362 			return ret;
363 	}
364 	console->flags |= CON_ENABLED;
365 	console->index = index;
366 	braille_co = console;
367 	register_keyboard_notifier(&keyboard_notifier_block);
368 	register_vt_notifier(&vt_notifier_block);
369 	return 1;
370 }
371 
braille_unregister_console(struct console * console)372 int braille_unregister_console(struct console *console)
373 {
374 	if (braille_co != console)
375 		return -EINVAL;
376 	unregister_keyboard_notifier(&keyboard_notifier_block);
377 	unregister_vt_notifier(&vt_notifier_block);
378 	braille_co = NULL;
379 	return 1;
380 }
381