WebSVN - shark - Rev 522 - /shark/trunk/drivers/input/shark/shark

/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* Massimiliano Giorgi <massy@gandalf.sssup.it>
* Luca Abeni <luca@gandalf.sssup.it>
* Mauro Marinoni <mauro.marinoni@unipv.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/

/*
* Copyright (C) 2000 Paolo Gai
*
* 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/

//#define __KEYB_DEBUG__
//#define KEYB_TASK

#include <kernel/kern.h>
#include <signal.h>
#include <modules/hartport.h>

#include "../include/drivers/shark_input26.h"
#include "../include/drivers/shark_keyb26.h"

/* Devices */
extern int atkbd_init(void);
extern int atkbd_exit(void);

/* Handlers */
extern int kbd_init(void);
extern int kbd_exit(void);

extern int kbd_enable(void);
extern int kbd_disable(void);

/* Functions */
extern int kbd_get(unsigned int *data, BYTE access);
extern void kbd_setleds(unsigned int led);
extern int kbd_rate(unsigned int *delay, unsigned int *period);
extern void kbd_mksound(unsigned int hz, unsigned int ticks);

extern int input_installed;

/*
* The following tables contains the ascii code corresponding to the
* scan codes, with shift & no shift...
*/
char keyTable [TABLE_KEY_SIZE];
char keyShiftTable[TABLE_KEY_SIZE];
char keyAltGrTable[TABLE_KEY_SIZE];

BYTE useAltGr = FALSE;

/* Status variables */
static BYTE shift = FALSE;
static BYTE ctrl = FALSE;
static BYTE alt = FALSE;
static BYTE altgr = FALSE;

static BYTE capslock = FALSE;
static BYTE numlock = TRUE;
static BYTE scrolllock = FALSE;

/* Keyboard Flags (if shift, alt or control are pressed...); */
static BYTE keyFlag = 0x00;
static BYTE status;

/* Keyboard driver currently installed */
static int keyb_installed = FALSE;

#define MAX_KEY_EXC 50

static struct keyexctable
{
KEY_EVT evt;
void (*func) (KEY_EVT * k);
unsigned char lock;
} keyExcTable[MAX_KEY_EXC];

static int lastExc;

/* Communication port between the extern process & the user */
static PORT pkeyPort, ukeyPort;

#ifdef KEYB_TASK
/* keyboard task PID */
static PID keybpid;
#else
void keyProc(void);
#endif

/*
* Start keyProc Task or exec it as function
*/
void shark_kbd_exec(void)
{
#ifdef KEYB_TASK
task_activate(keybpid);
#else
keyProc();
#endif
}

/*
* This function get a scan code, return an ascii code and set
* the status vars in order to handle the special keys of the AT keyboard
*/
WORD scanCode(unsigned int c, int d)
{
//printk("scanCode: c (%x) - d (%d)\n", c, d);

/* KEY_EVT status setting */
status = d;

switch (c) {
/* CapsLock pressed*/
case KEY_CPSLOCK:
if (d == KEY_PRESSED) {
capslock = capslock ? FALSE : TRUE;
/* light the caps lock led */
kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
}
return 0;
/* NumLock pressed */
case PAD_NUMLOCK:
if (d == KEY_PRESSED) {
numlock = numlock ? FALSE : TRUE;
/* light the num lock led */
kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
}
return 0;
/* ScrollLock pressed*/
case EXT_SCRLOCK:
if (d == KEY_PRESSED) {
scrolllock = scrolllock ? FALSE : TRUE;
/* light the scroll lock led */
kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
}
return 0;
/* Shift pressed or released */
case KEY_SHL:
if (d) {
shift = TRUE;
if (c == KEY_SHL)
keyFlag |= SHFL_BIT;
} else {
keyFlag &= (!SHFL_BIT);
if (!(keyFlag & SHFR_BIT))
shift = FALSE;
}
return 0;
/* Shift pressed or released */
case KEY_SHR:
if (d) {
shift = TRUE;
if (c == KEY_SHR)
keyFlag |= SHFR_BIT;
} else {
keyFlag &= (!SHFR_BIT);
if (!(keyFlag & SHFL_BIT))
shift = FALSE;
}
return 0;
/* Control pressed or released */
case KEY_CTRLL:
if (d) {
ctrl = TRUE;
keyFlag |= CNTL_BIT;
} else {
keyFlag &= (!CNTL_BIT);
if (!(keyFlag & CNTR_BIT))
ctrl = FALSE;
}
return 0;
/* Control pressed or released */
case KEY_CTRLR:
if (d) {
ctrl = TRUE;
keyFlag |= CNTR_BIT;
} else {
keyFlag &= (!CNTR_BIT);
if (!(keyFlag & CNTL_BIT))
ctrl = FALSE;
}
return 0;
/* Alt Left pressed */
case KEY_ALTL:
if (d) {
alt = TRUE;
keyFlag |= ALTL_BIT;
} else {
alt = FALSE;
keyFlag &= (!ALTL_BIT);
}
return 0;
/* Alt Right (AltGr) pressed */
case KEY_ALTR:
if (d) {
altgr = TRUE;
keyFlag |= ALTR_BIT;
} else {
altgr = FALSE;
keyFlag &= (!ALTR_BIT);
if ((!useAltGr) && (!(keyFlag & ALTL_BIT)))
alt = FALSE;
}
return 0;
/* Delete */
case EXT_DEL:
return DELETE;
case PAD_DEL:
if (numlock || shift)
return 0x18;
else
break;
/* Pad Enter */
case PAD_ENT:
return 0x0d;
/* Pad Add */
case PAD_PLUS:
return 0x2b;
/* Pad Sub */
case PAD_SUB:
return 0x2d;
/* Pad Slash */
case PAD_SLH:
return 0x2f;
/* Numbers & simbols */
case KEY_1: case KEY_2: case KEY_3: case KEY_4: case KEY_5:
case KEY_6: case KEY_7: case KEY_8: case KEY_9: case KEY_0:
case KEY_SUB: case KEY_PLUS: case KEY_BRL: case KEY_BRR:
case KEY_COL: case KEY_API: case KEY_TIL: case KEY_BSL:
case KEY_LT: case KEY_GT: case KEY_SLH:
/* AlrGR enabled & pressed */
if (altgr && useAltGr) {
return keyAltGrTable[c];
}
/* Control Shift status */
if (shift)
return keyShiftTable[c];
else
return keyTable[c];
}

/* Pad Keys */
if (numlock || shift)
switch (c) {
case PAD_DEL:
return 0x18;
case PAD_INS:
return 0x30;
case PAD_END:
return 0x31;
case PAD_DOWN:
return 0x32;
case PAD_PGDW:
return 0x33;
case PAD_RIGHT:
return 0x34;
case PAD_5:
return 0x35;
case PAD_LEFT:
return 0x36;
case PAD_HOME:
return 0x37;
case PAD_UP:
return 0x38;
case PAD_PGUP:
return 0x39;
}

/* Characters keys */
if (((c >= KEY_Q) && (c <= KEY_P)) ||
((c >= KEY_A) && (c <= KEY_L)) ||
((c >= KEY_Z) && (c <= KEY_M))) {
/* AlrGR enabled & pressed */
if (altgr && useAltGr) {
return keyAltGrTable[c];
}
/* Control CapsLock & Shift status */
if (capslock) {
if (shift)
return keyTable[c];
else
return keyShiftTable[c];
} else {
if (shift)
return keyShiftTable[c];
else
return keyTable[c];
}
}

/* Remaining keys */
if (c < TABLE_KEY_SIZE)
/* Left 'low' keys (Esc, BackSpace, Space, ...) */
return keyTable[c];
else
/* Default - Return as keycode */
return (0xff00 | c);
}

#ifdef KEYB_TASK
TASK keyProc(void)
#else
void keyProc(void)
#endif
{
WORD code;
BYTE found;
KEY_EVT dt;
int i, res;
unsigned int dato;

#ifdef KEYB_TASK
while (1) {
#endif
res = kbd_get(&dato, NON_BLOCK);
if (res >= 0) {
code = scanCode(dato, res);
if (code != 0) {
if (code & 0xff00)
/* It's a scan code, set the right bit */
dt.flag = (keyFlag | SCAN_BIT);
else
/* Simply send the keyFlag status */
dt.flag = keyFlag;
dt.status = status;
dt.ascii = (BYTE) (code & 0x00FF);
dt.scan = dato;
#ifdef __KEYB_DEBUG__
printk("shark_keyb.c: KEY_EVT ( %2x - %c - %2x - %1d)\n", dt.scan, dt.ascii, dt.flag, dt.status);
#endif
found = FALSE;
for (i = 0; i < lastExc; i++)
if ((keyExcTable[i].evt.scan == dt.scan) && (keyExcTable[i].evt.flag == dt.flag) && (keyExcTable[i].evt.status == dt.status)) {
#ifdef __KEYB_DEBUG__
printk("shark_keyb.c: Key_Hook ( %2x - %2x - %1d) -> ( %2x - %2x - %1d)\n", dt.scan, dt.flag, dt.status, keyExcTable[i].evt.scan, keyExcTable[i].evt.flag, keyExcTable[i].evt.status);
#endif
keyExcTable[i].func(&dt);
if (keyExcTable[i].lock == TRUE)
found = TRUE;
}
/* when the port is full, data is lost */
if (!found)
port_send(pkeyPort, (BYTE *) (&dt), NON_BLOCK);
}
}
#ifdef KEYB_TASK
task_endcycle();
}
#endif
}

/* default function called on ctrl-c */
void default_ctrlChandler(KEY_EVT * k) {
set_active_page(0);
set_visual_page(0);
cputs("Ctrl-C pressed!\n");
sys_end();
//exit(1);
}

/**** Start User Functions ****/

/* Function that returns the ascii code */
BYTE keyb_getch(BYTE wait)
{
KEY_EVT c;
BYTE fl;

fl = port_receive (ukeyPort, &c, wait);
if (fl && !isScanCode(c) && !isReleased(c))
return (c.ascii);
else
return 0;
}

/*
* Function that returns a structure containing the flags status, the ascii
* code, and the scan code
*/
int keyb_getcode(KEY_EVT * k, BYTE wait)
{
return (port_receive (ukeyPort, (BYTE *) (k), wait));
}

void keyb_hook(KEY_EVT k, void (*f) (KEY_EVT * k), unsigned char l)
{
if (lastExc >= MAX_KEY_EXC)
return;
keyExcTable[lastExc].evt = k;
keyExcTable[lastExc].func = f;
keyExcTable[lastExc++].lock = l;

return;
}

/* MG: this function disable the keyboard */
int keyb_disable(void)
{
kbd_disable();
return 0;
}

/* MG: this function enable the keyboard */
int keyb_enable(void)
{
kbd_enable();
return 0;
}

/**** End Functions ****/

int KEYB26_init(KEYB_PARMS *s)
{
KEYB_PARMS kparms = BASE_KEYB;
WORD i;
int status = 0;

#ifdef KEYB_TASK
SOFT_TASK_MODEL base_m;
TASK_MODEL *m;
#endif

if (keyb_installed == TRUE) return 0;

/* if a NULL is passed */
if (s == NULL)
s = &kparms;

for (i = 0; i < TABLE_KEY_SIZE; i++) {
keyTable[i] = 0;
keyShiftTable[i] = 0;
keyAltGrTable[i] = 0;
}

/* keymap */
if (s->keymap == (unsigned char)KEYB_DEFAULT) s->keymap = KEYMAP_US;
keyb_set_map(s->keymap);

/* MG: changed RECEIVE to STREAM port - added a failure test */
pkeyPort = port_create ("KeybPort", 3, 20, STREAM, WRITE);
if (pkeyPort == -1)
return -2;
ukeyPort = port_connect ("KeybPort", 3, STREAM, READ);
if (ukeyPort == -1) {
port_delete (pkeyPort);
return -3;
}

/* remove all key pressed handlers */
lastExc = 0;

/* and add a ctrl-c handler if requested */
if (s->ctrlcfunc == (void *) KEYB_DEFAULT)
s->ctrlcfunc = (void *) default_ctrlChandler;
if (s->ctrlcfunc != NULL) {
KEY_EVT emerg;
emerg.ascii = 'c';
emerg.scan = KEY_C;
emerg.flag = CNTL_BIT;
keyb_hook (emerg, s->ctrlcfunc, TRUE);
emerg.flag = CNTR_BIT;
keyb_hook (emerg, s->ctrlcfunc, TRUE);
}

#ifdef KEYB_TASK
/* keyb task */
if (s->tm == (TASK_MODEL *) KEYB_DEFAULT) {
soft_task_default_model (base_m);
soft_task_def_wcet (base_m, 2000);
soft_task_def_met (base_m, 800);
soft_task_def_period (base_m, 25000);
soft_task_def_system (base_m);
soft_task_def_nokill (base_m);
soft_task_def_aperiodic (base_m);
m = (TASK_MODEL *) & base_m;
} else
m = s->tm;

#ifdef __KEYB_DEBUG__
//printk(KERN_DEBUG "keyb task: %li %li %li %li\n", (long)s->pclass, (long)APERIODIC, (long)s->dline, (long)s->wcet);
#endif

keybpid = task_create ("KeyTask", keyProc, m, NULL);
if (keybpid == -1) {
port_delete (pkeyPort);
port_delete (ukeyPort);
return -1;
}
#endif

if (input_installed == FALSE)
if (INPUT26_init()) {
#ifdef __KEYB_DEBUG__
printk(KERN_ERR "shark_keyb.c: Unable to open Input SubSystem.\n");
#endif
port_delete (pkeyPort);
port_delete (ukeyPort);
return -1;
}

status = atkbd_init();
if (status) {
#ifdef __KEYB_DEBUG__
printk(KERN_ERR "shark_keyb.c: AtKbd_Init return: %d\n", status);
#endif
port_delete (pkeyPort);
port_delete (ukeyPort);
return -1;
}

status = kbd_init();
if (status) {
#ifdef __KEYB_DEBUG__
printk(KERN_ERR "shark_keyb.c: Kbd_Init return: %d\n", status);
#endif
port_delete (pkeyPort);
port_delete (ukeyPort);
return -1;
}

kbd_setleds(scrolllock + (numlock << 1) + (capslock << 2));
kbd_enable();

keyb_installed = TRUE;
return status;
}

/*
* KEYB module cleanup
* (must be called if it's needed to re-call keyb_init() with other parameters)
* -1 -> ERROR
*/
int KEYB26_close(void)
{
#ifdef KEYB_TASK
int free;
SYS_FLAGS f;
#endif

if (!keyb_installed)
return -1;
kbd_disable();
kbd_exit();
atkbd_exit();

#ifdef KEYB_TASK
f = kern_fsave();
free = (proc_table[keybpid].status == FREE);
kern_frestore(f);
#ifdef __KEYB_DEBUG__
printk(KERN_DEBUG "shark_keyb.c: KeyTask is %s.\n", free ? "killed" : "alive");
#endif
if (free)
task_kill (keybpid);
#endif

/*port_delete (pkeyPort);
port_delete (ukeyPort);*/

keyb_installed = FALSE;

return 0;
}

Subversion Repositories shark

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