Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 1033 → Rev 1034

/shark/trunk/drivers/input/include/drivers/shark_keyb26.h
71,6 → 71,11
BYTE status;
} KEY_EVT;
 
#define set_keyevt(k,a,c,f,s) (k)->ascii = a, \
(k)->scan = c, \
(k)->flag = f, \
(k)->status = s
 
#define isReleased(k) ( ((k)->status & KEY_RELEASED) != 0 )
#define isPressed(k) ( ((k)->status & KEY_PRESSED) != 0 )
#define isRepeated(k) ( ((k)->status & KEY_REPEATED) != 0 )
120,7 → 125,8
 
BYTE keyb_getch(BYTE wait);
int keyb_getcode(KEY_EVT *k, BYTE wait);
void keyb_hook(KEY_EVT k, void (*f)(KEY_EVT *k), unsigned char l);
int keyb_hook(KEY_EVT k, void (*f)(KEY_EVT *k), unsigned char l);
int keyb_unhook(int index);
void keyb_enable(void);
void keyb_disable(void);
int keyb_set_map(unsigned char m);
/shark/trunk/drivers/input/shark/shark_keyb.c
23,8 → 23,8
#define KEYB_TASK
 
#include <kernel/kern.h>
#include <kernel/int_sem.h>
#include <signal.h>
#include <hartport/hartport/hartport.h>
 
#include "../include/drivers/shark_input26.h"
#include "../include/drivers/shark_keyb26.h"
84,9 → 84,19
 
static int lastExc;
 
/* Communication port between the extern process & the user */
static PORT pkeyPort, ukeyPort;
/* Buffer used for the communication between the extern process & the user */
 
/* Buffer Ssize */
#define KEYBUFF_SIZE 256
/* Buffer Mask ( i=(i+1)&MASK is better than i=(i+1)%SIZE ) */
#define KEYBUFF_MASK 0xff
 
static KEY_EVT keybuff[KEYBUFF_SIZE];
static int keybuff_head = 1;
static int keybuff_tail = 0;
static internal_sem_t keybuff_mutex;
static int keybuff_mutex_init = 0;
 
#ifdef KEYB_TASK
/* keyboard task PID */
static PID keybpid;
337,9 → 347,23
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++)
for (i = 0; i < MAX_KEY_EXC; i++) {
if (keyExcTable[i].func == NULL)
continue;
if (((keyExcTable[i].evt.flag & ~SCAN_BIT) == (dt.flag & ~SCAN_BIT)) &&
((keyExcTable[i].evt.status & dt.status) != 0)) {
if ((dt.flag & SCAN_BIT) != 0) {
if ((keyExcTable[i].evt.scan == dt.scan) && (keyExcTable[i].evt.scan != 0)) {
#ifdef __KEYB_DEBUG__
printk("shark_keyb.c: Key_Hook ( %2x - %2x - %1d) -> ( %2x - %2x - %1d)\n",
dt.scan, dt.ascii, dt.flag, dt.status,
keyExcTable[i].evt.scan, keyExcTable[i].evt.ascii, keyExcTable[i].evt.flag, keyExcTable[i].evt.status);
#endif
keyExcTable[i].func(&dt);
if (keyExcTable[i].lock == TRUE)
found = TRUE;
}
} else {
if ( ((keyExcTable[i].evt.scan == dt.scan) || (keyExcTable[i].evt.scan == 0)) &&
((keyExcTable[i].evt.ascii == dt.ascii) || (keyExcTable[i].evt.ascii == 0)) ){
#ifdef __KEYB_DEBUG__
352,11 → 376,19
found = TRUE;
}
}
}
}
/* when the port is full, data is lost */
if (!found)
port_send(pkeyPort, (BYTE *) (&dt), NON_BLOCK);
if (!found) {
if (keybuff_tail != keybuff_head) {
internal_sem_wait(&keybuff_mutex);
memcpy(&keybuff[keybuff_head], &dt, sizeof(KEY_EVT));
keybuff_head = (keybuff_head+1) & KEYBUFF_MASK;
internal_sem_post(&keybuff_mutex);
}
}
}
}
#ifdef KEYB_TASK
task_endcycle();
}
365,10 → 397,11
 
/* default function called on ctrl-c */
void default_ctrlChandler(KEY_EVT * k) {
set_active_page(0);
/* Useful or not to set the page to 0? */
/*set_active_page(0);
set_visual_page(0);
//cputs("Ctrl-C pressed!\n");
exit(1);
cputs("Ctrl-C pressed!\n");*/
exit(0);
}
 
/**** Start User Functions ****/
377,41 → 410,87
BYTE keyb_getch(BYTE wait)
{
KEY_EVT ev;
BYTE fl;
 
fl = port_receive (ukeyPort, &ev, wait);
if (fl) {
while(1) {
if ( ((keybuff_tail+1) & KEYBUFF_MASK) != ((keybuff_head) & KEYBUFF_MASK) ) {
internal_sem_wait(&keybuff_mutex);
keybuff_tail = (keybuff_tail+1) & KEYBUFF_MASK;
memcpy(&ev, &keybuff[keybuff_tail], sizeof(KEY_EVT));
internal_sem_post(&keybuff_mutex);
 
#ifdef __KEYB_DEBUG__
printk("shark_keyb.c: GetChar ( %2x - %c - %2x - %1d)\n", ev.scan, ev.ascii, ev.flag, ev.status);
#endif
if (!isScanCode(&ev) && !isReleased(&ev))
if (!isScanCode(&ev) && !isReleased(&ev)) {
return (ev.ascii);
else
} else {
if (wait != BLOCK)
return 0;
} else
}
} else {
if (wait != BLOCK)
return 0;
}
}
}
 
/*
* Function that returns a structure containing the flags status, the ascii
* code, and the scan code
*/
int inline keyb_getcode(KEY_EVT * k, BYTE wait)
int keyb_getcode(KEY_EVT * k, BYTE wait)
{
return (port_receive (ukeyPort, (BYTE *) (k), wait));
while (1) {
if ( ((keybuff_tail+1) & KEYBUFF_MASK) != ((keybuff_head) & KEYBUFF_MASK) ) {
internal_sem_wait(&keybuff_mutex);
keybuff_tail = (keybuff_tail+1) & KEYBUFF_MASK;
memcpy(k, &keybuff[keybuff_tail], sizeof(KEY_EVT));
internal_sem_post(&keybuff_mutex);
 
return(TRUE);
} else {
if (wait != BLOCK)
return(FALSE);
}
}
}
 
void keyb_hook(KEY_EVT k, void (*f) (KEY_EVT * k), unsigned char l)
/*
* This call is used to link a function to a KEY_EVT
*/
int keyb_hook(KEY_EVT k, void (*f) (KEY_EVT * k), unsigned char l)
{
if (lastExc >= MAX_KEY_EXC)
return;
int id = 0;
 
if ((k.ascii == 0) && (k.scan == 0))
return -1;
 
while (keyExcTable[id].func != NULL) {
id++;
if (id >= MAX_KEY_EXC)
return -1;
}
 
keyExcTable[lastExc].func = f;
keyExcTable[lastExc].evt = k;
keyExcTable[lastExc].func = f;
if (keyExcTable[lastExc].evt.status == 0)
keyExcTable[lastExc].evt.status = KEY_PRESSED;
 
keyExcTable[lastExc++].lock = l;
 
return;
return (lastExc-1);
}
 
/* Free a keyb_hook slot */
int keyb_unhook(int index)
{
if (keyExcTable[index].func != NULL) {
keyExcTable[index].func = NULL;
return 0;
}
return -1;
}
 
/* This function disable the keyboard */
void inline keyb_disable(void)
{
447,6 → 526,7
if (s == NULL)
s = &kparms;
 
/* Reset keymap structures */
for (i = 0; i < TABLE_KEY_SIZE; i++) {
keyTable[i] = 0;
keyShiftTable[i] = 0;
457,13 → 537,12
if (s->keymap == (unsigned char)KEYB_DEFAULT) s->keymap = KEYMAP_US;
keyb_set_map(s->keymap);
 
pkeyPort = port_create ("KeybPort", sizeof(KEY_EVT), 20, STREAM, WRITE);
if (pkeyPort == -1)
return -2;
ukeyPort = port_connect ("KeybPort", sizeof(KEY_EVT), STREAM, READ);
if (ukeyPort == -1) {
port_delete (pkeyPort);
return -3;
/* KeyEvt Buffer Initialization */
keybuff_head = 1;
keybuff_tail = 0;
if (keybuff_mutex_init==0) {
internal_sem_init(&keybuff_mutex, 1);
keybuff_mutex_init = 1;
}
 
/* remove all key pressed handlers */
478,9 → 557,9
emerg.scan = KEY_C;
emerg.status = KEY_PRESSED;
emerg.flag = CNTL_BIT;
keyb_hook (emerg, s->ctrlcfunc, TRUE);
keyb_hook (emerg, s->ctrlcfunc, FALSE);
emerg.flag = CNTR_BIT;
keyb_hook (emerg, s->ctrlcfunc, TRUE);
keyb_hook (emerg, s->ctrlcfunc, FALSE);
}
 
#ifdef KEYB_TASK
489,7 → 568,7
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_period (base_m, 30000);
soft_task_def_system (base_m);
soft_task_def_nokill (base_m);
soft_task_def_aperiodic (base_m);
498,22 → 577,17
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);
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);
if (keybpid == -1)
return -1;
}
#endif
 
if (INPUT26_installed() == FALSE)
if (INPUT26_init()) {
printk(KERN_ERR "shark_keyb.c: Unable to open Input SubSystem.\n");
port_delete (pkeyPort);
port_delete (ukeyPort);
#ifdef KEYB_TASK
task_kill (keybpid);
#endif
523,8 → 597,6
status = kbd_init();
if (status) {
printk(KERN_ERR "shark_keyb.c: Kbd_Init return: %d\n", status);
port_delete (pkeyPort);
port_delete (ukeyPort);
#ifdef KEYB_TASK
task_kill (keybpid);
#endif
539,8 → 611,6
}
if (status) {
printk(KERN_ERR "shark_keyb.c: AtKbd_Init return: %d\n", status);
port_delete (pkeyPort);
port_delete (ukeyPort);
#ifdef KEYB_TASK
task_kill (keybpid);
#endif
585,9 → 655,6
task_kill (keybpid);
#endif
 
/*port_delete (pkeyPort);
port_delete (ukeyPort);*/
 
keyb_installed = FALSE;
 
return 0;
/shark/trunk/drivers/input/shark/mcurtxt.c
26,7 → 26,7
*/
 
#include <kernel/kern.h>
#include <sem/sem/sem.h>
#include <kernel/int_sem.h>
 
#include "../include/drivers/shark_input26.h"
#include "../include/drivers/shark_mouse26.h"
41,7 → 41,8
extern MOUSE_HANDLER user_mouse_handler;
 
/* a mutex semaphore */
static sem_t mutex=-1;
static int mcur_mutex_init = 0;
static internal_sem_t mutex;
 
/* Setup function */
int _mouse_cursor_init(int cmd, void(*my_show_cursor)(int, int), void(*my_restore_cursor)(int, int));
80,7 → 81,7
if (user_mouse_handler != NULL)
user_mouse_handler(event);
 
sem_wait(&mutex);
internal_sem_wait(&mutex);
if ( (mouse_cursor_state < 0) && (event->x != saved_x || event->y != saved_y)) {
restore_cursor(saved_x, saved_y);
saved_x = event->x;
87,7 → 88,7
saved_y = event->y;
show_cursor(saved_x, saved_y);
}
sem_post(&mutex);
internal_sem_post(&mutex);
}
 
/* with WITHOUTSEM flag*/
113,7 → 114,7
#ifdef CURTXT_DEBUG
printk(KERN_DEBUG "mcurtxt.c: autocursor_mouse_handler_3\n");
#endif
sem_wait(&mutex);
internal_sem_wait(&mutex);
 
if (mouse_cursor_state < 0) {
restore_cursor(saved_x, saved_y);
125,7 → 126,7
} else if (user_mouse_handler != NULL)
user_mouse_handler(event);
 
sem_post(&mutex);
internal_sem_post(&mutex);
}
 
/* with WITHOUTSEM & AUTOOFF flags */
221,9 → 222,9
 
static void mouse_on_sem(void)
{
sem_wait(&mutex);
internal_sem_wait(&mutex);
MOUSE_ON();
sem_post(&mutex);
internal_sem_post(&mutex);
}
 
static void mouse_on_nosem(void)
242,9 → 243,9
 
void mouse_off_sem(void)
{
sem_wait(&mutex);
internal_sem_wait(&mutex);
MOUSE_OFF();
sem_post(&mutex);
internal_sem_post(&mutex);
}
 
void mouse_off_nosem(void)
275,9 → 276,9
 
int _mouse_cursor_init(int cmd, void(*my_show_cursor)(int, int), void(*my_restore_cursor)(int, int))
{
if (mutex == -1) {
if (sem_init(&mutex, 0, 1) == -1)
return -1;
if (mcur_mutex_init == 0) {
internal_sem_init(&mutex, 1);
mcur_mutex_init = 1;
}
 
#ifdef CURTXT_DEBUG