WebSVN - shark - Blame - Rev 1065 - /shark/trunk/drivers/input/shark/shark

Rev	Author	Line No.	Line
519	mauro	1	/*
		2	* Project: S.Ha.R.K.
		3	*
		4	* Coordinators:
		5	* Giorgio Buttazzo <giorgio@sssup.it>
		6	* Paolo Gai <pj@gandalf.sssup.it>
		7	*
		8	* Authors :
		9	* Paolo Gai <pj@gandalf.sssup.it>
		10	* Massimiliano Giorgi <massy@gandalf.sssup.it>
		11	* Luca Abeni <luca@gandalf.sssup.it>
		12	* Mauro Marinoni <mauro.marinoni@unipv.it>
		13	* (see the web pages for full authors list)
		14	*
		15	* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
		16	*
		17	* http://www.sssup.it
		18	* http://retis.sssup.it
		19	* http://shark.sssup.it
		20	*/
		21
1063	tullio	22	/*
		23	* This program is free software; you can redistribute it and/or modify
		24	* it under the terms of the GNU General Public License as published by
		25	* the Free Software Foundation; either version 2 of the License, or
		26	* (at your option) any later version.
		27	*
		28	* This program is distributed in the hope that it will be useful,
		29	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		30	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		31	* GNU General Public License for more details.
		32	*
		33	* You should have received a copy of the GNU General Public License
		34	* along with this program; if not, write to the Free Software
		35	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		36	*
		37	*/
		38
519	mauro	39	//#define __KEYB_DEBUG__
523	mauro	40	#define KEYB_TASK
519	mauro	41
		42	#include <kernel/kern.h>
1034	mauro	43	#include <kernel/int_sem.h>
519	mauro	44	#include <signal.h>
		45
		46	#include "../include/drivers/shark_input26.h"
		47	#include "../include/drivers/shark_keyb26.h"
		48
		49	/* Devices */
1015	mauro	50	extern int atkbd_init(int soft);
519	mauro	51	extern int atkbd_exit(void);
		52
		53	/* Handlers */
		54	extern int kbd_init(void);
		55	extern int kbd_exit(void);
		56
523	mauro	57	/* Functions */
519	mauro	58	extern int kbd_enable(void);
		59	extern int kbd_disable(void);
		60	extern int kbd_get(unsigned int *data, BYTE access);
		61	extern void kbd_setleds(unsigned int led);
		62	extern int kbd_rate(unsigned int delay, unsigned int period);
		63	extern void kbd_mksound(unsigned int hz, unsigned int ticks);
		64
		65	/*
		66	* The following tables contains the ascii code corresponding to the
		67	* scan codes, with shift & no shift...
		68	*/
		69	char keyTable [TABLE_KEY_SIZE];
		70	char keyShiftTable[TABLE_KEY_SIZE];
		71	char keyAltGrTable[TABLE_KEY_SIZE];
		72
		73	BYTE useAltGr = FALSE;
		74
		75	/* Status variables */
		76	static BYTE shift = FALSE;
		77	static BYTE ctrl = FALSE;
		78	static BYTE alt = FALSE;
		79	static BYTE altgr = FALSE;
		80
		81	static BYTE capslock = FALSE;
		82	static BYTE numlock = TRUE;
		83	static BYTE scrolllock = FALSE;
		84
		85	/* Keyboard Flags (if shift, alt or control are pressed...); */
		86	static BYTE keyFlag = 0x00;
		87	static BYTE status;
		88
		89	/* Keyboard driver currently installed */
		90	static int keyb_installed = FALSE;
		91
		92
		93	#define MAX_KEY_EXC 50
		94
		95	static struct keyexctable
		96	{
		97	KEY_EVT evt;
		98	void (func) (KEY_EVT k);
		99	unsigned char lock;
		100	} keyExcTable[MAX_KEY_EXC];
		101
		102	static int lastExc;
		103
1034	mauro	104	/* Buffer used for the communication between the extern process & the user */
519	mauro	105
1034	mauro	106	/* Buffer Ssize */
		107	#define KEYBUFF_SIZE 256
		108	/* Buffer Mask ( i=(i+1)&MASK is better than i=(i+1)%SIZE ) */
		109	#define KEYBUFF_MASK 0xff
		110
		111	static KEY_EVT keybuff[KEYBUFF_SIZE];
		112	static int keybuff_head = 1;
		113	static int keybuff_tail = 0;
		114	static internal_sem_t keybuff_mutex;
		115	static int keybuff_mutex_init = 0;
		116
522	mauro	117	#ifdef KEYB_TASK
519	mauro	118	/* keyboard task PID */
		119	static PID keybpid;
522	mauro	120	#else
523	mauro	121	static void keyProc(void);
522	mauro	122	#endif
519	mauro	123
		124	/*
522	mauro	125	* Start keyProc Task or exec it as function
519	mauro	126	*/
522	mauro	127	void shark_kbd_exec(void)
519	mauro	128	{
522	mauro	129	#ifdef KEYB_TASK
519	mauro	130	task_activate(keybpid);
522	mauro	131	#else
		132	keyProc();
		133	#endif
519	mauro	134	}
		135
		136	/*
		137	* This function get a scan code, return an ascii code and set
		138	* the status vars in order to handle the special keys of the AT keyboard
		139	*/
		140	WORD scanCode(unsigned int c, int d)
		141	{
		142	//printk("scanCode: c (%x) - d (%d)\n", c, d);
		143
		144	/* KEY_EVT status setting */
749	mauro	145	status = 1 << d;
519	mauro	146
		147	switch (c) {
		148	/* CapsLock pressed*/
		149	case KEY_CPSLOCK:
		150	if (d == KEY_PRESSED) {
		151	capslock = capslock ? FALSE : TRUE;
		152	/* light the caps lock led */
		153	kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
		154	}
		155	return 0;
		156	/* NumLock pressed */
		157	case PAD_NUMLOCK:
		158	if (d == KEY_PRESSED) {
		159	numlock = numlock ? FALSE : TRUE;
		160	/* light the num lock led */
		161	kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
		162	}
		163	return 0;
		164	/* ScrollLock pressed*/
		165	case EXT_SCRLOCK:
		166	if (d == KEY_PRESSED) {
		167	scrolllock = scrolllock ? FALSE : TRUE;
		168	/* light the scroll lock led */
		169	kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
		170	}
		171	return 0;
		172	/* Shift pressed or released */
		173	case KEY_SHL:
		174	if (d) {
		175	shift = TRUE;
		176	if (c == KEY_SHL)
		177	keyFlag \|= SHFL_BIT;
		178	} else {
		179	keyFlag &= (!SHFL_BIT);
		180	if (!(keyFlag & SHFR_BIT))
		181	shift = FALSE;
		182	}
		183	return 0;
		184	/* Shift pressed or released */
		185	case KEY_SHR:
		186	if (d) {
		187	shift = TRUE;
		188	if (c == KEY_SHR)
		189	keyFlag \|= SHFR_BIT;
		190	} else {
		191	keyFlag &= (!SHFR_BIT);
		192	if (!(keyFlag & SHFL_BIT))
		193	shift = FALSE;
		194	}
		195	return 0;
		196	/* Control pressed or released */
		197	case KEY_CTRLL:
		198	if (d) {
		199	ctrl = TRUE;
		200	keyFlag \|= CNTL_BIT;
		201	} else {
		202	keyFlag &= (!CNTL_BIT);
		203	if (!(keyFlag & CNTR_BIT))
		204	ctrl = FALSE;
		205	}
		206	return 0;
		207	/* Control pressed or released */
		208	case KEY_CTRLR:
		209	if (d) {
		210	ctrl = TRUE;
		211	keyFlag \|= CNTR_BIT;
		212	} else {
		213	keyFlag &= (!CNTR_BIT);
		214	if (!(keyFlag & CNTL_BIT))
		215	ctrl = FALSE;
		216	}
		217	return 0;
		218	/* Alt Left pressed */
		219	case KEY_ALTL:
		220	if (d) {
		221	alt = TRUE;
		222	keyFlag \|= ALTL_BIT;
		223	} else {
		224	alt = FALSE;
		225	keyFlag &= (!ALTL_BIT);
		226	}
		227	return 0;
		228	/* Alt Right (AltGr) pressed */
		229	case KEY_ALTR:
		230	if (d) {
		231	altgr = TRUE;
		232	keyFlag \|= ALTR_BIT;
		233	} else {
		234	altgr = FALSE;
		235	keyFlag &= (!ALTR_BIT);
		236	if ((!useAltGr) && (!(keyFlag & ALTL_BIT)))
		237	alt = FALSE;
		238	}
		239	return 0;
		240	/* Delete */
		241	case EXT_DEL:
		242	return DELETE;
		243	case PAD_DEL:
		244	if (numlock \|\| shift)
		245	return 0x18;
		246	else
		247	break;
		248	/* Pad Enter */
		249	case PAD_ENT:
		250	return 0x0d;
		251	/* Pad Add */
		252	case PAD_PLUS:
		253	return 0x2b;
		254	/* Pad Sub */
		255	case PAD_SUB:
		256	return 0x2d;
		257	/* Pad Slash */
		258	case PAD_SLH:
		259	return 0x2f;
		260	/* Numbers & simbols */
		261	case KEY_1: case KEY_2: case KEY_3: case KEY_4: case KEY_5:
		262	case KEY_6: case KEY_7: case KEY_8: case KEY_9: case KEY_0:
		263	case KEY_SUB: case KEY_PLUS: case KEY_BRL: case KEY_BRR:
		264	case KEY_COL: case KEY_API: case KEY_TIL: case KEY_BSL:
		265	case KEY_LT: case KEY_GT: case KEY_SLH:
		266	/* AlrGR enabled & pressed */
		267	if (altgr && useAltGr) {
		268	return keyAltGrTable[c];
		269	}
		270	/* Control Shift status */
		271	if (shift)
		272	return keyShiftTable[c];
		273	else
		274	return keyTable[c];
		275	}
		276
		277	/* Pad Keys */
		278	if (numlock \|\| shift)
		279	switch (c) {
		280	case PAD_DEL:
		281	return 0x18;
		282	case PAD_INS:
		283	return 0x30;
		284	case PAD_END:
		285	return 0x31;
		286	case PAD_DOWN:
		287	return 0x32;
		288	case PAD_PGDW:
		289	return 0x33;
		290	case PAD_RIGHT:
		291	return 0x34;
		292	case PAD_5:
		293	return 0x35;
		294	case PAD_LEFT:
		295	return 0x36;
		296	case PAD_HOME:
		297	return 0x37;
		298	case PAD_UP:
		299	return 0x38;
		300	case PAD_PGUP:
		301	return 0x39;
		302	}
		303
		304	/* Characters keys */
		305	if (((c >= KEY_Q) && (c <= KEY_P)) \|\|
		306	((c >= KEY_A) && (c <= KEY_L)) \|\|
		307	((c >= KEY_Z) && (c <= KEY_M))) {
		308	/* AlrGR enabled & pressed */
		309	if (altgr && useAltGr) {
		310	return keyAltGrTable[c];
		311	}
		312	/* Control CapsLock & Shift status */
		313	if (capslock) {
		314	if (shift)
		315	return keyTable[c];
		316	else
		317	return keyShiftTable[c];
		318	} else {
		319	if (shift)
		320	return keyShiftTable[c];
		321	else
		322	return keyTable[c];
		323	}
		324	}
		325
		326	/* Remaining keys */
		327	if (c < TABLE_KEY_SIZE)
		328	/* Left 'low' keys (Esc, BackSpace, Space, ...) */
		329	return keyTable[c];
		330	else
		331	/* Default - Return as keycode */
		332	return (0xff00 \| c);
		333	}
		334
522	mauro	335	#ifdef KEYB_TASK
519	mauro	336	TASK keyProc(void)
522	mauro	337	#else
523	mauro	338	static void keyProc(void)
522	mauro	339	#endif
519	mauro	340	{
		341	WORD code;
		342	BYTE found;
		343	KEY_EVT dt;
		344	int i, res;
		345	unsigned int dato;
		346
522	mauro	347	#ifdef KEYB_TASK
519	mauro	348	while (1) {
522	mauro	349	#endif
519	mauro	350	res = kbd_get(&dato, NON_BLOCK);
		351	if (res >= 0) {
		352	code = scanCode(dato, res);
		353	if (code != 0) {
		354	if (code & 0xff00)
		355	/* It's a scan code, set the right bit */
		356	dt.flag = (keyFlag \| SCAN_BIT);
		357	else
		358	/* Simply send the keyFlag status */
		359	dt.flag = keyFlag;
		360	dt.status = status;
		361	dt.ascii = (BYTE) (code & 0x00FF);
		362	dt.scan = dato;
		363	#ifdef __KEYB_DEBUG__
		364	printk("shark_keyb.c: KEY_EVT ( %2x - %c - %2x - %1d)\n", dt.scan, dt.ascii, dt.flag, dt.status);
		365	#endif
		366	found = FALSE;
1034	mauro	367	for (i = 0; i < MAX_KEY_EXC; i++) {
		368	if (keyExcTable[i].func == NULL)
		369	continue;
666	mauro	370	if (((keyExcTable[i].evt.flag & ~SCAN_BIT) == (dt.flag & ~SCAN_BIT)) &&
749	mauro	371	((keyExcTable[i].evt.status & dt.status) != 0)) {
1034	mauro	372	if ((dt.flag & SCAN_BIT) != 0) {
		373	if ((keyExcTable[i].evt.scan == dt.scan) && (keyExcTable[i].evt.scan != 0)) {
519	mauro	374	#ifdef __KEYB_DEBUG__
1034	mauro	375	printk("shark_keyb.c: Key_Hook ( %2x - %2x - %1d) -> ( %2x - %2x - %1d)\n",
		376	dt.scan, dt.ascii, dt.flag, dt.status,
		377	keyExcTable[i].evt.scan, keyExcTable[i].evt.ascii, keyExcTable[i].evt.flag, keyExcTable[i].evt.status);
519	mauro	378	#endif
1034	mauro	379	keyExcTable[i].func(&dt);
		380	if (keyExcTable[i].lock == TRUE)
		381	found = TRUE;
		382	}
		383	} else {
		384	if ( ((keyExcTable[i].evt.scan == dt.scan) \|\| (keyExcTable[i].evt.scan == 0)) &&
		385	((keyExcTable[i].evt.ascii == dt.ascii) \|\| (keyExcTable[i].evt.ascii == 0)) ){
		386	#ifdef __KEYB_DEBUG__
		387	printk("shark_keyb.c: Key_Hook ( %2x - %2x - %1d) -> ( %2x - %2x - %1d)\n",
		388	dt.scan, dt.ascii, dt.flag, dt.status,
		389	keyExcTable[i].evt.scan, keyExcTable[i].evt.ascii, keyExcTable[i].evt.flag, keyExcTable[i].evt.status);
		390	#endif
		391	keyExcTable[i].func(&dt);
		392	if (keyExcTable[i].lock == TRUE)
		393	found = TRUE;
		394	}
666	mauro	395	}
523	mauro	396	}
1034	mauro	397	}
519	mauro	398	/* when the port is full, data is lost */
1034	mauro	399	if (!found) {
		400	if (keybuff_tail != keybuff_head) {
		401	internal_sem_wait(&keybuff_mutex);
		402	memcpy(&keybuff[keybuff_head], &dt, sizeof(KEY_EVT));
		403	keybuff_head = (keybuff_head+1) & KEYBUFF_MASK;
		404	internal_sem_post(&keybuff_mutex);
		405	}
		406	}
519	mauro	407	}
		408	}
522	mauro	409	#ifdef KEYB_TASK
519	mauro	410	task_endcycle();
		411	}
522	mauro	412	#endif
519	mauro	413	}
		414
		415	/* default function called on ctrl-c */
		416	void default_ctrlChandler(KEY_EVT * k) {
1034	mauro	417	/* Useful or not to set the page to 0? */
		418	/*set_active_page(0);
519	mauro	419	set_visual_page(0);
1034	mauro	420	cputs("Ctrl-C pressed!\n");*/
		421	exit(0);
519	mauro	422	}
		423
		424	/** Start User Functions **/
		425
		426	/* Function that returns the ascii code */
		427	BYTE keyb_getch(BYTE wait)
		428	{
523	mauro	429	KEY_EVT ev;
519	mauro	430
1034	mauro	431	while(1) {
		432	if ( ((keybuff_tail+1) & KEYBUFF_MASK) != ((keybuff_head) & KEYBUFF_MASK) ) {
		433	internal_sem_wait(&keybuff_mutex);
		434	keybuff_tail = (keybuff_tail+1) & KEYBUFF_MASK;
		435	memcpy(&ev, &keybuff[keybuff_tail], sizeof(KEY_EVT));
		436	internal_sem_post(&keybuff_mutex);
		437
523	mauro	438	#ifdef __KEYB_DEBUG__
1034	mauro	439	printk("shark_keyb.c: GetChar ( %2x - %c - %2x - %1d)\n", ev.scan, ev.ascii, ev.flag, ev.status);
523	mauro	440	#endif
1034	mauro	441	if (!isScanCode(&ev) && !isReleased(&ev)) {
		442	return (ev.ascii);
		443	} else {
		444	if (wait != BLOCK)
		445	return 0;
		446	}
		447	} else {
		448	if (wait != BLOCK)
		449	return 0;
		450	}
		451	}
519	mauro	452	}
		453
		454	/*
		455	* Function that returns a structure containing the flags status, the ascii
		456	* code, and the scan code
		457	*/
1034	mauro	458	int keyb_getcode(KEY_EVT * k, BYTE wait)
519	mauro	459	{
1034	mauro	460	while (1) {
		461	if ( ((keybuff_tail+1) & KEYBUFF_MASK) != ((keybuff_head) & KEYBUFF_MASK) ) {
		462	internal_sem_wait(&keybuff_mutex);
		463	keybuff_tail = (keybuff_tail+1) & KEYBUFF_MASK;
		464	memcpy(k, &keybuff[keybuff_tail], sizeof(KEY_EVT));
		465	internal_sem_post(&keybuff_mutex);
		466
		467	return(TRUE);
		468	} else {
		469	if (wait != BLOCK)
		470	return(FALSE);
		471	}
		472	}
519	mauro	473	}
		474
1034	mauro	475	/*
		476	* This call is used to link a function to a KEY_EVT
		477	*/
		478	int keyb_hook(KEY_EVT k, void (f) (KEY_EVT k), unsigned char l)
519	mauro	479	{
1034	mauro	480	int id = 0;
		481
		482	if ((k.ascii == 0) && (k.scan == 0))
		483	return -1;
		484
		485	while (keyExcTable[id].func != NULL) {
		486	id++;
		487	if (id >= MAX_KEY_EXC)
		488	return -1;
		489	}
		490
		491	keyExcTable[lastExc].func = f;
519	mauro	492	keyExcTable[lastExc].evt = k;
1034	mauro	493	if (keyExcTable[lastExc].evt.status == 0)
		494	keyExcTable[lastExc].evt.status = KEY_PRESSED;
		495
519	mauro	496	keyExcTable[lastExc++].lock = l;
		497
1034	mauro	498	return (lastExc-1);
519	mauro	499	}
		500
1034	mauro	501	/* Free a keyb_hook slot */
		502	int keyb_unhook(int index)
		503	{
		504	if (keyExcTable[index].func != NULL) {
		505	keyExcTable[index].func = NULL;
		506	return 0;
		507	}
		508	return -1;
		509	}
		510
523	mauro	511	/* This function disable the keyboard */
826	mauro	512	void inline keyb_disable(void)
519	mauro	513	{
		514	kbd_disable();
		515	}
		516
523	mauro	517	/* This function enable the keyboard */
826	mauro	518	void inline keyb_enable(void)
519	mauro	519	{
		520	kbd_enable();
		521	}
		522
523	mauro	523	/** End User Functions **/
826	mauro	524	int inline KEYB26_installed(void)
549	mauro	525	{
		526	return keyb_installed;
		527	}
519	mauro	528
		529	int KEYB26_init(KEYB_PARMS *s)
		530	{
		531	KEYB_PARMS kparms = BASE_KEYB;
		532	WORD i;
		533	int status = 0;
		534
522	mauro	535	#ifdef KEYB_TASK
519	mauro	536	SOFT_TASK_MODEL base_m;
		537	TASK_MODEL *m;
522	mauro	538	#endif
519	mauro	539
		540	if (keyb_installed == TRUE) return 0;
		541
		542	/* if a NULL is passed */
		543	if (s == NULL)
		544	s = &kparms;
		545
1034	mauro	546	/* Reset keymap structures */
519	mauro	547	for (i = 0; i < TABLE_KEY_SIZE; i++) {
		548	keyTable[i] = 0;
		549	keyShiftTable[i] = 0;
		550	keyAltGrTable[i] = 0;
		551	}
		552
		553	/* keymap */
		554	if (s->keymap == (unsigned char)KEYB_DEFAULT) s->keymap = KEYMAP_US;
		555	keyb_set_map(s->keymap);
		556
1034	mauro	557	/* KeyEvt Buffer Initialization */
		558	keybuff_head = 1;
		559	keybuff_tail = 0;
		560	if (keybuff_mutex_init==0) {
		561	internal_sem_init(&keybuff_mutex, 1);
		562	keybuff_mutex_init = 1;
519	mauro	563	}
		564
		565	/* remove all key pressed handlers */
		566	lastExc = 0;
		567
		568	/* and add a ctrl-c handler if requested */
		569	if (s->ctrlcfunc == (void *) KEYB_DEFAULT)
		570	s->ctrlcfunc = (void *) default_ctrlChandler;
		571	if (s->ctrlcfunc != NULL) {
		572	KEY_EVT emerg;
523	mauro	573	emerg.ascii = 'c';
		574	emerg.scan = KEY_C;
		575	emerg.status = KEY_PRESSED;
		576	emerg.flag = CNTL_BIT;
1034	mauro	577	keyb_hook (emerg, s->ctrlcfunc, FALSE);
523	mauro	578	emerg.flag = CNTR_BIT;
1034	mauro	579	keyb_hook (emerg, s->ctrlcfunc, FALSE);
519	mauro	580	}
		581
522	mauro	582	#ifdef KEYB_TASK
519	mauro	583	/* keyb task */
		584	if (s->tm == (TASK_MODEL *) KEYB_DEFAULT) {
		585	soft_task_default_model (base_m);
		586	soft_task_def_wcet (base_m, 2000);
		587	soft_task_def_met (base_m, 800);
1034	mauro	588	soft_task_def_period (base_m, 30000);
519	mauro	589	soft_task_def_system (base_m);
826	mauro	590	soft_task_def_nokill (base_m);
519	mauro	591	soft_task_def_aperiodic (base_m);
		592	m = (TASK_MODEL *) & base_m;
		593	} else
		594	m = s->tm;
		595
		596	#ifdef __KEYB_DEBUG__
1034	mauro	597	printk(KERN_DEBUG "keyb task: %li %li %li %li\n", (long)s->pclass, (long)APERIODIC, (long)s->dline, (long)s->wcet);
519	mauro	598	#endif
		599
		600	keybpid = task_create ("KeyTask", keyProc, m, NULL);
1034	mauro	601	if (keybpid == -1)
519	mauro	602	return -1;
522	mauro	603	#endif
519	mauro	604
549	mauro	605	if (INPUT26_installed() == FALSE)
519	mauro	606	if (INPUT26_init()) {
		607	printk(KERN_ERR "shark_keyb.c: Unable to open Input SubSystem.\n");
544	giacomo	608	#ifdef KEYB_TASK
523	mauro	609	task_kill (keybpid);
544	giacomo	610	#endif
519	mauro	611	return -1;
		612	}
		613
549	mauro	614	status = kbd_init();
519	mauro	615	if (status) {
549	mauro	616	printk(KERN_ERR "shark_keyb.c: Kbd_Init return: %d\n", status);
544	giacomo	617	#ifdef KEYB_TASK
523	mauro	618	task_kill (keybpid);
544	giacomo	619	#endif
519	mauro	620	return -1;
		621	}
549	mauro	622
1015	mauro	623
		624	if (s->softrepeat == (int) KEYB_DEFAULT) {
		625	status = atkbd_init(1);
		626	} else {
		627	status = atkbd_init(s->softrepeat);
		628	}
519	mauro	629	if (status) {
549	mauro	630	printk(KERN_ERR "shark_keyb.c: AtKbd_Init return: %d\n", status);
544	giacomo	631	#ifdef KEYB_TASK
523	mauro	632	task_kill (keybpid);
544	giacomo	633	#endif
519	mauro	634	return -1;
		635	}
		636
		637	kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
		638	kbd_enable();
		639
		640	keyb_installed = TRUE;
		641	return status;
		642	}
		643
		644	/*
		645	* KEYB module cleanup
		646	* (must be called if it's needed to re-call keyb_init() with other parameters)
		647	* -1 -> ERROR
		648	*/
		649	int KEYB26_close(void)
		650	{
522	mauro	651	#ifdef KEYB_TASK
519	mauro	652	int free;
		653	SYS_FLAGS f;
522	mauro	654	#endif
519	mauro	655
		656	if (!keyb_installed)
		657	return -1;
549	mauro	658
519	mauro	659	kbd_disable();
549	mauro	660
		661	atkbd_exit();
519	mauro	662	kbd_exit();
		663
522	mauro	664	#ifdef KEYB_TASK
519	mauro	665	f = kern_fsave();
		666	free = (proc_table[keybpid].status == FREE);
		667	kern_frestore(f);
		668	#ifdef __KEYB_DEBUG__
		669	printk(KERN_DEBUG "shark_keyb.c: KeyTask is %s.\n", free ? "killed" : "alive");
		670	#endif
		671	if (free)
		672	task_kill (keybpid);
522	mauro	673	#endif
519	mauro	674
		675	keyb_installed = FALSE;
		676
		677	return 0;
		678	}

Subversion Repositories shark

(root)/shark/trunk/drivers/input/shark/shark_keyb.c - Rev 1065