[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / accessibility / braille / braille_console.c

/*
 * Minimalistic braille device kernel support.
 *
 * By default, shows console messages on the braille device.
 * Pressing Insert switches to VC browsing.
 *
 *  Copyright (C) Samuel Thibault <samuel.thibault@ens-lyon.org>
 *
 * This program is free software ; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation ; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY ; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with the program ; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/console.h>
#include <linux/notifier.h>

#include <linux/selection.h>
#include <linux/vt_kern.h>
#include <linux/consolemap.h>

#include <linux/keyboard.h>
#include <linux/kbd_kern.h>
#include <linux/input.h>

MODULE_AUTHOR("samuel.thibault@ens-lyon.org");
MODULE_DESCRIPTION("braille device");
MODULE_LICENSE("GPL");

/*
 * Braille device support part.
 */

/* Emit various sounds */
static bool sound;
module_param(sound, bool, 0);
MODULE_PARM_DESC(sound, "emit sounds");

static void beep(unsigned int freq)
{
	if (sound)
		kd_mksound(freq, HZ/10);
}

/* mini console */
#define WIDTH 40
#define BRAILLE_KEY KEY_INSERT
static u16 console_buf[WIDTH];
static int console_cursor;

/* mini view of VC */
static int vc_x, vc_y, lastvc_x, lastvc_y;

/* show console ? (or show VC) */
static int console_show = 1;
/* pending newline ? */
static int console_newline = 1;
static int lastVC = -1;

static struct console *braille_co;

/* Very VisioBraille-specific */
static void braille_write(u16 *buf)
{
	static u16 lastwrite[WIDTH];
	unsigned char data[1 + 1 + 2*WIDTH + 2 + 1], csum = 0, *c;
	u16 out;
	int i;

	if (!braille_co)
		return;

	if (!memcmp(lastwrite, buf, WIDTH * sizeof(*buf)))
		return;
	memcpy(lastwrite, buf, WIDTH * sizeof(*buf));

#define SOH 1
#define STX 2
#define ETX 2
#define EOT 4
#define ENQ 5
	data[0] = STX;
	data[1] = '>';
	csum ^= '>';
	c = &data[2];
	for (i = 0; i < WIDTH; i++) {
		out = buf[i];
		if (out >= 0x100)
			out = '?';
		else if (out == 0x00)
			out = ' ';
		csum ^= out;
		if (out <= 0x05) {
			*c++ = SOH;
			out |= 0x40;
		}
		*c++ = out;
	}

	if (csum <= 0x05) {
		*c++ = SOH;
		csum |= 0x40;
	}
	*c++ = csum;
	*c++ = ETX;

	braille_co->write(braille_co, data, c - data);
}

/* Follow the VC cursor*/
static void vc_follow_cursor(struct vc_data *vc)
{
	vc_x = vc->vc_x - (vc->vc_x % WIDTH);
	vc_y = vc->vc_y;
	lastvc_x = vc->vc_x;
	lastvc_y = vc->vc_y;
}

/* Maybe the VC cursor moved, if so follow it */
static void vc_maybe_cursor_moved(struct vc_data *vc)
{
	if (vc->vc_x != lastvc_x || vc->vc_y != lastvc_y)
		vc_follow_cursor(vc);
}

/* Show portion of VC at vc_x, vc_y */
static void vc_refresh(struct vc_data *vc)
{
	u16 buf[WIDTH];
	int i;

	for (i = 0; i < WIDTH; i++) {
		u16 glyph = screen_glyph(vc,
				2 * (vc_x + i) + vc_y * vc->vc_size_row);
		buf[i] = inverse_translate(vc, glyph, 1);
	}
	braille_write(buf);
}

/*
 * Link to keyboard
 */

static int keyboard_notifier_call(struct notifier_block *blk,
				  unsigned long code, void *_param)
{
	struct keyboard_notifier_param *param = _param;
	struct vc_data *vc = param->vc;
	int ret = NOTIFY_OK;

	if (!param->down)
		return ret;

	switch (code) {
	case KBD_KEYCODE:
		if (console_show) {
			if (param->value == BRAILLE_KEY) {
				console_show = 0;
				beep(880);
				vc_maybe_cursor_moved(vc);
				vc_refresh(vc);
				ret = NOTIFY_STOP;
			}
		} else {
			ret = NOTIFY_STOP;
			switch (param->value) {
			case KEY_INSERT:
				beep(440);
				console_show = 1;
				lastVC = -1;
				braille_write(console_buf);
				break;
			case KEY_LEFT:
				if (vc_x > 0) {
					vc_x -= WIDTH;
					if (vc_x < 0)
						vc_x = 0;
				} else if (vc_y >= 1) {
					beep(880);
					vc_y--;
					vc_x = vc->vc_cols-WIDTH;
				} else
					beep(220);
				break;
			case KEY_RIGHT:
				if (vc_x + WIDTH < vc->vc_cols) {
					vc_x += WIDTH;
				} else if (vc_y + 1 < vc->vc_rows) {
					beep(880);
					vc_y++;
					vc_x = 0;
				} else
					beep(220);
				break;
			case KEY_DOWN:
				if (vc_y + 1 < vc->vc_rows)
					vc_y++;
				else
					beep(220);
				break;
			case KEY_UP:
				if (vc_y >= 1)
					vc_y--;
				else
					beep(220);
				break;
			case KEY_HOME:
				vc_follow_cursor(vc);
				break;
			case KEY_PAGEUP:
				vc_x = 0;
				vc_y = 0;
				break;
			case KEY_PAGEDOWN:
				vc_x = 0;
				vc_y = vc->vc_rows-1;
				break;
			default:
				ret = NOTIFY_OK;
				break;
			}
			if (ret == NOTIFY_STOP)
				vc_refresh(vc);
		}
		break;
	case KBD_POST_KEYSYM:
	{
		unsigned char type = KTYP(param->value) - 0xf0;
		if (type == KT_SPEC) {
			unsigned char val = KVAL(param->value);
			int on_off = -1;

			switch (val) {
			case KVAL(K_CAPS):
				on_off = vt_get_leds(fg_console, VC_CAPSLOCK);
				break;
			case KVAL(K_NUM):
				on_off = vt_get_leds(fg_console, VC_NUMLOCK);
				break;
			case KVAL(K_HOLD):
				on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
				break;
			}
			if (on_off == 1)
				beep(880);
			else if (on_off == 0)
				beep(440);
		}
	}
	case KBD_UNBOUND_KEYCODE:
	case KBD_UNICODE:
	case KBD_KEYSYM:
		/* Unused */
		break;
	}
	return ret;
}

static struct notifier_block keyboard_notifier_block = {
	.notifier_call = keyboard_notifier_call,
};

static int vt_notifier_call(struct notifier_block *blk,
			    unsigned long code, void *_param)
{
	struct vt_notifier_param *param = _param;
	struct vc_data *vc = param->vc;
	switch (code) {
	case VT_ALLOCATE:
		break;
	case VT_DEALLOCATE:
		break;
	case VT_WRITE:
	{
		unsigned char c = param->c;
		if (vc->vc_num != fg_console)
			break;
		switch (c) {
		case '\b':
		case 127:
			if (console_cursor > 0) {
				console_cursor--;
				console_buf[console_cursor] = ' ';
			}
			break;
		case '\n':
		case '\v':
		case '\f':
		case '\r':
			console_newline = 1;
			break;
		case '\t':
			c = ' ';
			/* Fallthrough */
		default:
			if (c < 32)
				/* Ignore other control sequences */
				break;
			if (console_newline) {
				memset(console_buf, 0, sizeof(console_buf));
				console_cursor = 0;
				console_newline = 0;
			}
			if (console_cursor == WIDTH)
				memmove(console_buf, &console_buf[1],
					(WIDTH-1) * sizeof(*console_buf));
			else
				console_cursor++;
			console_buf[console_cursor-1] = c;
			break;
		}
		if (console_show)
			braille_write(console_buf);
		else {
			vc_maybe_cursor_moved(vc);
			vc_refresh(vc);
		}
		break;
	}
	case VT_UPDATE:
		/* Maybe a VT switch, flush */
		if (console_show) {
			if (vc->vc_num != lastVC) {
				lastVC = vc->vc_num;
				memset(console_buf, 0, sizeof(console_buf));
				console_cursor = 0;
				braille_write(console_buf);
			}
		} else {
			vc_maybe_cursor_moved(vc);
			vc_refresh(vc);
		}
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block vt_notifier_block = {
	.notifier_call = vt_notifier_call,
};

/*
 * Called from printk.c when console=brl is given
 */

int braille_register_console(struct console *console, int index,
		char *console_options, char *braille_options)
{
	int ret;
	if (!console_options)
		/* Only support VisioBraille for now */
		console_options = "57600o8";
	if (braille_co)
		return -ENODEV;
	if (console->setup) {
		ret = console->setup(console, console_options);
		if (ret != 0)
			return ret;
	}
	console->flags |= CON_ENABLED;
	console->index = index;
	braille_co = console;
	register_keyboard_notifier(&keyboard_notifier_block);
	register_vt_notifier(&vt_notifier_block);
	return 0;
}

int braille_unregister_console(struct console *console)
{
	if (braille_co != console)
		return -EINVAL;
	unregister_keyboard_notifier(&keyboard_notifier_block);
	unregister_vt_notifier(&vt_notifier_block);
	braille_co = NULL;
	return 0;
}
Commit	Line	Data
f7511d5f ST	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
f7511d5f ST	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 */
90ab5ee9	47	static bool sound;
f7511d5f ST	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 + 2WIDTH + 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):
079c9534	247	on_off = vt_get_leds(fg_console, VC_CAPSLOCK);
f7511d5f ST	248	break;
f7511d5f ST	249	case KVAL(K_NUM):
079c9534	250	on_off = vt_get_leds(fg_console, VC_NUMLOCK);
f7511d5f ST	251	break;
f7511d5f ST	252	case KVAL(K_HOLD):
079c9534	253	on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
f7511d5f ST	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
	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
358	int braille_register_console(struct console *console, int index,
359	char console_options, char braille_options)
360	{
361	int ret;
362	if (!console_options)
363	/* Only support VisioBraille for now */
364	console_options = "57600o8";
365	if (braille_co)
366	return -ENODEV;
367	if (console->setup) {
368	ret = console->setup(console, console_options);
369	if (ret != 0)
370	return ret;
371	}
372	console->flags \|= CON_ENABLED;
373	console->index = index;
374	braille_co = console;
c0c9209d PT	375	register_keyboard_notifier(&keyboard_notifier_block);
c0c9209d PT	376	register_vt_notifier(&vt_notifier_block);
f7511d5f ST	377	return 0;
	378	}
	379
	380	int braille_unregister_console(struct console *console)
	381	{
	382	if (braille_co != console)
	383	return -EINVAL;
c0c9209d PT	384	unregister_keyboard_notifier(&keyboard_notifier_block);
c0c9209d PT	385	unregister_vt_notifier(&vt_notifier_block);
f7511d5f ST	386	braille_co = NULL;
	387	return 0;
	388	}