Subversion Repositories 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>
 *   (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
 */

/**
 ------------
 CVS :        $Id: keyb.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $

 File:        $File$
 Revision:    $Revision: 1.1.1.1 $
 Last update: $Date: 2002-03-29 14:12:49 $
 ------------

 Author:      Giuseppe Lipari
 Start date:  19/6/96

 File:        Keyb.C
 Revision:    1.5.1

 Last update  : 14/Apr/1999

 This file contains :
   -- A fast handler that get the scan code from the key interface      
   and put it in a port (non blocking) ; Inside this handler we can't  
   make any primitive call; it runs with interrupt enabled, so that the
   timer cannot be blocked. Its priority is 1 (from hardware).          
   -- A sporadic soft process that gets the data from the port and      
   tries to recognize any scan code. With the help of a table that varies
   from keyboad to keyboard (e.g. italian vs american) it puts the ascii
   code intoanother port, with a byte that indicates the pression of any
   control key (Shift, Ctrl, Alt). I tried to make the initialization  
   of this table as standard as possible, so that one has to change only
   the include file with all the codes                                  
   -- Some functions (exported) to initialize the interface and get the
   ascii code

   Revision 1.4 (Gerardo) Added support for italian keyboard; required
        to add a new status variable rightalt to cope with italian keybs
        assignment! Added the keyb_set_map function to select the keymaps
        and finally build the english & italian keymaps

   Revision 1.5 (Giorgi)

   Split the file into keyb.c and 8042.c:
   8042.c low level hardware interface
   keyb.c user interface to kerboard routines
   (8042.c is the "source" of data that keyb.c must interpretate)

   Modification made:
   -- fast handler remove (now in 8042.c)
   -- all function that make direct I/O with hardware now in 8042.c
   -- keyb_init() modified (to interfaces with 8042.c)
   -- key_sendKeyCmd() removed; key_sendCtrCmd() removed
   -- scanCode() & KeyProc modified (keyboard ACK are tested in KeyProc)
   -- actled() removed (now in 8042.c with name 8042_keyboardleds); all
      reference changed
   -- Key_1 port removed (comunication in handled by functions in 8042.c)
   -- added functions to enable/disable keyboard

   PS: the modification are marked with "MG"

   Revision 1.5.1 (Giorgi)

   Modification to compile on 3.2.0
   -- added wcet time to all task
   -- RECEIVE port now are STREAM port

**/

/*
 * 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__ 1

//#include <string.h>
//#include <stdlib.h>
//#include <cons.h>

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

#include <drivers/keyb.h>
#include <drivers/keycode.h>
#include "8042.h"

char engMap[] = {
  '1','2','3','4','5','6','7','8','9','0',
  '!','@','#','$','%','^','&','*','(',')',
  '-','_','=','+','[','{',']','}',';',':','\'','\"','`','~','/','?',',',
  '<','.','>','\\','|',' ',' ',8,8,9,9,27,27,13,13,24,
  '1','2','3','4','5','6','7','8','9','0','.','+','*','/','-','+','*','-',
  'a','A','b','B','c','C','d','D','e','E','f','F','g','G','h','H','i',
  'I','j','J','k','K','l','L','m','M','n','N','o','O','p','P','q','Q',
  'r','R','s','S','t','T','u','U','v','V','w','W','x','X','y','Y','z','Z',
  /*
    These are the strange keys used in the italian keyboard
    When you press Alt-Right to obtain [,], @ or #. They are left
    unbind with English Keyboard
    */
  ' ',' ',' ',' '
};

char itaMap[] = {
  '1','2','3','4','5','6','7','8','9','0',
  '!','\"','œ','$','%','&','/','(',')','=',
  '\'','?','','^','Š','‚','+','*','•','‡','…','ø','\\','|','<','_',',',
  ':','.',';','—','õ',' ',' ',8,8,9,9,27,27,13,13,24,
  '1','2','3','4','5','6','7','8','9','0','.','+','*','/','-','+','*','-',
  'a','A','b','B','c','C','d','D','e','E','f','F','g','G','h','H','i',
  'I','j','J','k','K','l','L','m','M','n','N','o','O','p','P','q','Q',
  'r','R','s','S','t','T','u','U','v','V','w','W','x','X','y','Y','z','Z',
  /*
    These are the strange keys used in the italian keyboard
    When you press Alt-Right to obtain [,], @ or #
    */
  '[',']','@','#'
};

#define MAX_KEY_EXC     15

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

static int lastExc;

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

static char *actualMap = engMap;

/* Status variables */
static BYTE e0 = FALSE;
static BYTE sh = FALSE;
static BYTE rightalt = FALSE;
static BYTE cps = FALSE;
static BYTE numlock = TRUE;
static BYTE scrolllock = FALSE;
static int keyb_installed = FALSE;

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

/* Communication port between the handler & the extern process  */
/* MG: port not needed! */
//static PORT keyHandPort, keyProcPort;

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

/* 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 */
/* (I write this code several time !!). When it finds a special code    */
/* (Insert, Del, Up, Down, ecc) it return a code with the first byte    */
/* at ffh and the second byte with the scan code, while normally it     */
/* return only the ascii code                                           */
WORD scanCode(BYTE c)
{
  /* if it's an ack, advice the actLed routine */
  /* MG: test removed (it's in "KeyProc") */
  //if (c == 0xfa) actLed(0);

  /* If the previous key was an 0xe0...       */
  if (e0) {
    /* throw away the pairs 0xe0-0x2a and 0xe0-0xaa */
    if (c == 0x2a || c == 0xaa) {
      e0 = FALSE;
      return 0;
    }
    /* throw away the pairs 0xe0-0x36 and 0xe0-0xb6 */
    if (c == 0x36 || c == 0xb6) {
      e0 = FALSE;
      return 0;
    }
    /* if it's a break code ... */
    else if (c & 0x80) {
      e0 = FALSE;
      /* Right Alt */
      if (c == (KEY_ALTL | 0x80)) {
        keyFlag = keyFlag & (!ALTR_BIT);
        rightalt = FALSE;
      }
      /* Right Ctrl */
      else if (c == (KEY_CTRLL | 0x80)) {
        keyFlag = keyFlag & (!CNTR_BIT);
      }
      return 0;
    }
    else {
      e0 = FALSE;
      /* Right Alt */
      if (c == KEY_ALTL) {
        keyFlag |= ALTR_BIT ;
        rightalt = TRUE;
        return 0;
      }
      /* Right Ctrl */
      else if (c == KEY_CTRLL) {
        keyFlag |= CNTR_BIT ;
        return 0;
      }
      /* Numeric keypad */
      else if (c == PAD_SCRLOCK) return keyTable[c];
      else if (c == KEY_ENT) return keyTable[c];
      /* simply return scan code */
      else return(0xff00 | c);
    }
  }
  else {
    /* it's an 0xe0, we must remember */
    if (c == 0xe0) {
      e0 = TRUE;
      return 0;
    }
    else if (c == KEY_SHL || c == KEY_SHR) {
      /* it's the shift : adjust flags */
      sh = TRUE;
      if (c == KEY_SHL) keyFlag = keyFlag | SHFL_BIT ;
      else if (c == KEY_SHR) keyFlag = keyFlag | SHFR_BIT ;
      return 0;
    }
    else if (c == (KEY_SHL | 0x80) || c == (KEY_SHR | 0x80)) {
      /* it's the shift break code */
      sh = FALSE;
      if (c == (KEY_SHL | 0x80)) keyFlag = keyFlag & (!SHFL_BIT);
      else if (c == (KEY_SHR | 0x80)) keyFlag = keyFlag & (!SHFR_BIT);
      return 0;
    }
    else if (c == KEY_SCRLOCK) {
      if (scrolllock == TRUE) scrolllock = FALSE;
      else scrolllock = TRUE;
      /* light the scroll lock led */
      /* MG: changed */
      C8042_keyboardleds(numlock,cps,scrolllock);
      return 0;
    }
  }

  /* Hovewer ...*/
  if (c == KEY_CPSLOCK) {
    if (cps == TRUE) cps = FALSE;
    else cps = TRUE;   
    /* MG: changed */
    C8042_keyboardleds(numlock,cps,scrolllock);
    return 0;
  }
  if (c == PAD_NUMLOCK) {
    if (numlock == TRUE) numlock = FALSE;
    else numlock = TRUE;
    /* MG: changed */
    C8042_keyboardleds(numlock,cps,scrolllock);
    return 0;
  }
  if (c == KEY_CTRLL) {
    keyFlag = keyFlag | CNTL_BIT ;
    return 0;
  }
  else if (c == KEY_ALTL) {
    keyFlag = keyFlag | ALTL_BIT ;
    return 0;
  }
  else if (c == (KEY_CTRLL | 0x80)) {
    keyFlag = keyFlag & (!CNTL_BIT);
    return 0;
  }
  else if (c == (KEY_ALTL | 0x80)) {
    keyFlag = keyFlag & (!ALTL_BIT);
    return 0;
  }
  else if (c & 0x80) {
    return 0;
  }
  else if ((c == PAD_INS) || (c == PAD_END) || (c == PAD_DEL) ||
           (c == PAD_DOWN) || (c == PAD_PGDW) || (c == PAD_LEFT) ||
           (c == PAD_5) || (c == PAD_RIGHT) || (c == PAD_HOME) ||
           (c == PAD_UP) || (c == PAD_PGUP)) {
    if (numlock || sh) return keyShiftTable[c];
    else return (0xff00 | c);
  }
  else if (cps &&
           (((c >= KEY_Q) && (c <= KEY_P)) ||
            ((c >= KEY_A) && (c <= KEY_L)) ||
            ((c >= KEY_Z) && (c <= KEY_M))) ) {
    if (sh) return keyTable[c];
    else return keyShiftTable[c];
  }
  else if (sh) return keyShiftTable[c];
  else if (rightalt) return keyRightAltTable[c];
  else return keyTable[c];
}

TASK keyProc(void)
{
  WORD code;
  BYTE dato,found;
  KEY_EVT dt;
  int i,res;
   
  while (1) {
//    kern_printf("K");
    /* MG: used C8042_keyboardget() */
    res=C8042_keyboardget(&dato,NON_BLOCK);
    if (res) {
      code = scanCode(dato);
      if (code != 0) {
        /* if it's a scan code , set the right bit ...*/
        if (code & 0xff00) dt.flag = (keyFlag | SCAN_BIT);
        /* ... else simply send the keyFlag status*/
        else dt.flag = keyFlag;
        dt.ascii = (BYTE)(code & 0x00FF);
        dt.scan  = dato;
        found = FALSE;
        for (i = 0; i < lastExc; i++)
          if ((keyExcTable[i].evt.scan == dt.scan) && (keyExcTable[i].evt.flag == dt.flag)) {
            keyExcTable[i].func(&dt);
            found = TRUE;
          }
        /* when the port is full, data is lost */
        if (!found) port_send(pkeyPort,(BYTE *)(&dt),NON_BLOCK);
      }
    }
    task_endcycle();
  }
}

void keyb_set_map(char *t)
{
  actualMap = t;
   
  keyTable[KEY_1] = actualMap[0];
  keyTable[KEY_2] = actualMap[1];
  keyTable[KEY_3] = actualMap[2];
  keyTable[KEY_4] = actualMap[3];
  keyTable[KEY_5] = actualMap[4];
  keyTable[KEY_6] = actualMap[5];
  keyTable[KEY_7] = actualMap[6];
  keyTable[KEY_8] = actualMap[7];
  keyTable[KEY_9] = actualMap[8];
  keyTable[KEY_0] = actualMap[9];

  keyShiftTable[KEY_1] = actualMap[10];
  keyShiftTable[KEY_2] = actualMap[11];
  keyShiftTable[KEY_3] = actualMap[12];
  keyShiftTable[KEY_4] = actualMap[13];
  keyShiftTable[KEY_5] = actualMap[14];
  keyShiftTable[KEY_6] = actualMap[15];
  keyShiftTable[KEY_7] = actualMap[16];
  keyShiftTable[KEY_8] = actualMap[17];
  keyShiftTable[KEY_9] = actualMap[18];
  keyShiftTable[KEY_0] = actualMap[19];
   
  keyTable[KEY_SUB] = actualMap[20];
  keyShiftTable[KEY_SUB] = actualMap[21];
  keyTable[KEY_PLUS] = actualMap[22];
  keyShiftTable[KEY_PLUS] = actualMap[23];
  keyTable[KEY_BRL] = actualMap[24];
  keyShiftTable[KEY_BRL] = actualMap[25];
  keyTable[KEY_BRR] = actualMap[26];
  keyShiftTable[KEY_BRR] = actualMap[27];
  keyTable[KEY_COL] = actualMap[28];
  keyShiftTable[KEY_COL] = actualMap[29];
  keyTable[KEY_API] = actualMap[30];
  keyShiftTable[KEY_API] = actualMap[31];
  keyTable[KEY_TIL] = actualMap[32];
  keyShiftTable[KEY_TIL] = actualMap[33];
  keyTable[KEY_SLH] = actualMap[34];
  keyShiftTable[KEY_SLH] = actualMap[35];
  keyTable[KEY_LT] = actualMap[36];
  keyShiftTable[KEY_LT] = actualMap[37];
  keyTable[KEY_GT] = actualMap[38];
  keyShiftTable[KEY_GT] = actualMap[39];
   
  keyTable[KEY_BSL] = actualMap[40];
  keyShiftTable[KEY_BSL] = actualMap[41];
  keyTable[KEY_SPC] = actualMap[42];
  keyShiftTable[KEY_SPC] = actualMap[43];

  keyTable[KEY_BKS] = actualMap[44];
  keyShiftTable[KEY_BKS] = actualMap[45];
  keyTable[KEY_TAB] = actualMap[46];
  keyShiftTable[KEY_TAB] = actualMap[470];
  keyTable[KEY_ESC] = actualMap[48];
  keyShiftTable[KEY_ESC] = actualMap[49];
  keyTable[KEY_ENT] = actualMap[50];
  keyShiftTable[KEY_ENT] = actualMap[51];
   
  keyShiftTable[KEY_DEL] = actualMap[52];
  keyShiftTable[PAD_END] = actualMap[53];
  keyShiftTable[PAD_DOWN] = actualMap[54];
  keyShiftTable[PAD_PGDW] = actualMap[55];
  keyShiftTable[PAD_LEFT] = actualMap[56];
  keyShiftTable[PAD_5] = actualMap[57];
  keyShiftTable[PAD_RIGHT] = actualMap[58];
  keyShiftTable[PAD_HOME] = actualMap[59];
  keyShiftTable[PAD_UP] = actualMap[60];
  keyShiftTable[PAD_PGUP] = actualMap[61];
  keyShiftTable[PAD_INS] = actualMap[62];
  keyShiftTable[PAD_DEL] = actualMap[63];

  keyTable[PAD_PLUS] = actualMap[64];
  keyTable[PAD_AST] = actualMap[65];
  keyTable[PAD_SCRLOCK] = actualMap[66];
  keyTable[PAD_SUB] = actualMap[67];

  keyShiftTable[PAD_PLUS] = actualMap[68];
  keyShiftTable[PAD_AST] = actualMap[69];
  keyShiftTable[PAD_SUB] = actualMap[70];
   
  keyTable[KEY_A] = actualMap[71];
  keyShiftTable[KEY_A] = actualMap[72];
  keyTable[KEY_B] = actualMap[73];
  keyShiftTable[KEY_B] = actualMap[74];
  keyTable[KEY_C] = actualMap[75];
  keyShiftTable[KEY_C] = actualMap[76];
  keyTable[KEY_D] = actualMap[77];
  keyShiftTable[KEY_D] = actualMap[78];
  keyTable[KEY_E] = actualMap[79];
  keyShiftTable[KEY_E] = actualMap[80];
  keyTable[KEY_F] = actualMap[81];
  keyShiftTable[KEY_F] = actualMap[82];
  keyTable[KEY_G] = actualMap[83];
  keyShiftTable[KEY_G] = actualMap[84];
  keyTable[KEY_H] = actualMap[85];
  keyShiftTable[KEY_H] = actualMap[86];
  keyTable[KEY_I] = actualMap[87];
  keyShiftTable[KEY_I] =  actualMap[88];
  keyTable[KEY_J] = actualMap[89];
  keyShiftTable[KEY_J] = actualMap[90];
  keyTable[KEY_K] = actualMap[91];
  keyShiftTable[KEY_K] = actualMap[82];
  keyTable[KEY_L] = actualMap[93];
  keyShiftTable[KEY_L] = actualMap[94];
  keyTable[KEY_M] = actualMap[95];
  keyShiftTable[KEY_M] = actualMap[96];
  keyTable[KEY_N] = actualMap[97];
  keyShiftTable[KEY_N] = actualMap[98];
  keyTable[KEY_O] = actualMap[99];
  keyShiftTable[KEY_O] = actualMap[100];
  keyTable[KEY_P] = actualMap[101];
  keyShiftTable[KEY_P] = actualMap[102];
  keyTable[KEY_Q] = actualMap[103];
  keyShiftTable[KEY_Q] = actualMap[104];
  keyTable[KEY_R] = actualMap[105];
  keyShiftTable[KEY_R] = actualMap[106];
  keyTable[KEY_S] = actualMap[107];
  keyShiftTable[KEY_S] = actualMap[108];
  keyTable[KEY_T] = actualMap[109];
  keyShiftTable[KEY_T] = actualMap[110];
  keyTable[KEY_U] = actualMap[111];
  keyShiftTable[KEY_U] = actualMap[112];
  keyTable[KEY_V] = actualMap[113];
  keyShiftTable[KEY_V] = actualMap[114];
  keyTable[KEY_W] = actualMap[115];
  keyShiftTable[KEY_W] = actualMap[116];
  keyTable[KEY_X] = actualMap[117];
  keyShiftTable[KEY_X] = actualMap[118];
  keyTable[KEY_Y] = actualMap[119];
  keyShiftTable[KEY_Y] = actualMap[120];
  keyTable[KEY_Z] = actualMap[121];
  keyShiftTable[KEY_Z] = actualMap[122];

  keyRightAltTable[KEY_BRL] = actualMap[123];
  keyRightAltTable[KEY_BRR] = actualMap[124];
  keyRightAltTable[KEY_COL] = actualMap[125];
  keyRightAltTable[KEY_API] = actualMap[126];
}

/* 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);
}

/* This is the interface to application */
/* Initialize keyboard driver */
/* MG: this function return: */
/*  0  - OK */
/*  <0 - error code */

/* TRUE when the 8042 keyboard initialization done */
static int init8042flag=FALSE;


/* keyboard task PID */
static PID keybpid;

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

  SOFT_TASK_MODEL base_m;
  TASK_MODEL *m;

  if (keyb_installed) return 0;
 
  for (i = 0; i < NUM_OF_KEY; i++) {
    keyTable[i] = 0;
    keyShiftTable[i] = 0;
  }

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

  /* keymap */
  if (s->keybmap==(char*)KEYB_DEFAULT) s->keybmap=engMap;
  keyb_set_map(s->keybmap);
       
  /* MG: Key_1 port not needed! */
  //keyHandPort = port_create("Key_1",1,50,RECEIVE,WRITE);
  //keyProcPort = port_connect("Key_1",1,RECEIVE,READ);

  /* 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);
    emerg.flag = CNTR_BIT;
    keyb_hook(emerg,s->ctrlcfunc);
  }


  /* 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;

  //cprintf("keyb task: %li %li %li %li\n",
  //        (long)s->pclass,(long)APERIODIC,(long)s->dline,(long)s->wcet);

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

  /* MG: 8042 keyboard controller initialization */
  if (!init8042flag) {
    status=C8042_keyboardinit(keybpid);
    if (status) {
      port_delete(pkeyPort);
      port_delete(ukeyPort);
      task_kill(keybpid);
      return -4;
    }
    init8042flag=TRUE;
  } else {
    C8042_keyboardenable();
  }

  /* MG: and keyboard led management */
  C8042_keyboardleds(numlock,cps,scrolllock);

  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 keyb_end(void)
{
  if (!keyb_installed) return -1;
  C8042_keyboarddisable();
  task_kill(keybpid);
  port_delete(pkeyPort);
  port_delete(ukeyPort);
  return 0;
}

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

  fl = port_receive(ukeyPort,&c,wait);
  if (fl && !isScanCode(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))
{
  if (lastExc >= MAX_KEY_EXC) return;
  keyExcTable[lastExc].evt = k;
  keyExcTable[lastExc++].func = f;
  return;
}

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

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