View of xos/drivers/keyboard.c

/* Pilote pour le controleur de clavier Intel 8042 */
/* Copyright (C) 2008  Emmanuel Varoquaux
 
   This file is part of XOS.
 
   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 3 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, see <http://www.gnu.org/licenses/>. */
 
#include "keymap.h"
#include "vc.h"
#include "vc_struct.h"
#include "tty.h"
#include "video_driver.h"
#include "tty_queue.h"
 
#include <panic.h>
#include <printk.h>
#include <asm.h>
#include <string.h>
 
/* commandes du 8042 */
#define CT_PULSE_PORTS  0xf0
 
/* commandes du 8048 */
#define KB_WRITE_LEDS   0xed
 
/* statut du 8048 */
#define KB_ACK          0xfa
#define KB_RESEND       0xfe
 
/* Traduction des scancodes en keycodes */
 
/* Les scancodes de 1 a 88 sont egaux a leur keycode. */
 
/* keycodes standards */
#define E0_KPENTER       96
#define E0_RCTRL         97
#define E0_KPSLASH       98
#define E0_PRSCR         99
#define E0_RALT         100
#define E0_BREAK        101
#define E0_HOME         102
#define E0_UP           103
#define E0_PGUP         104
#define E0_LEFT         105
#define E0_RIGHT        106
#define E0_END          107
#define E0_DOWN         108
#define E0_PGDN         109
#define E0_INS          110
#define E0_DEL          111
 
#define E1_PAUSE        119
 
/* Touches Windows.
 * e0 5b est le boutton "fenetre" gauche
 * e0 5c est le boutton "fenetre" droit
 * e0 5d est le bouton "menu" */
#define E0_MSLW         125
#define E0_MSRW         126
#define E0_MSTM         127
 
static unsigned char e0_keys[128] = {
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR,
  E0_RALT, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, E0_BREAK, E0_HOME,
  E0_UP, E0_PGUP, 0, E0_LEFT, 0, E0_RIGHT, 0, E0_END,
  E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0,
  0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0
};
 
/* Traduction des keycodes en caracteres */
 
/* types de touches */
#define KT_LATIN         0
#define KT_FN            1
#define KT_SPEC          2
#define KT_PAD           3
#define KT_DEAD          4
#define KT_CONS          5
#define KT_CUR           6
#define KT_SHIFT         7
#define KT_META          8
#define KT_ASCII         9
#define KT_LOCK         10
#define KT_LETTER       11      /* symbole affecte par CapsLock */
#define KT_SLOCK        12
 
/* touches d'edition */
#define K_FIND          20
#define K_INSERT        21
#define K_REMOVE        22
#define K_SELECT        23
#define K_PGUP          24
#define K_PGDN          25
 
/* pave numerique */
#define K_P0             0
#define K_P1             1
#define K_P2             2
#define K_P3             3
#define K_P4             4
#define K_P5             5
#define K_P6             6
#define K_P7             7
#define K_P8             8
#define K_P9             9
#define K_PPLUS         10
#define K_PMINUS        11
#define K_PSTAR         12
#define K_PSLASH        13
#define K_PENTER        14
#define K_PDOT          16
 
/* fleches */
#define K_DOWN           0
#define K_LEFT           1
#define K_RIGHT          2
#define K_UP             3
 
/* touches de controle */
#define K_SHIFT          0
#define K_CTRL           2
#define K_ALT            2
#define K_ALTGR          1
#define K_SHIFTL         4
#define K_SHIFTR         5
#define K_CTRLL          6
#define K_CTRLR          7
#define K_CAPSSHIFT      8
 
static struct vc_struct dummy_con;
 
/* Variables d'etat */
 
static int shift_down[9];
static int dead_key_next;
static unsigned char diacr;
static int repeating;
static unsigned short prev_scancode;
static unsigned char prev_keycode;
static struct vc_struct *con;
static int char_put;
 
#define put_queue(c) ({ \
  tty_put(&con->tty, (c)); \
  char_put = 1; \
})
 
#define puts_queue(s) ({ \
  const char *tmp = (s); \
  while (*tmp) \
    put_queue(*tmp++); \
})
 
/* dummy_con */
 
static int dummy()
{
  return 0;
}
 
static const struct tty_vtbl_struct dummy_con_tty_vtbl = {
  .do_output = vc_tty_do_output,
  .do_stop = vc_tty_do_stop,
  .do_start = vc_tty_do_start,
  .do_ioctl = vc_tty_do_ioctl
};
 
static const struct vc_vtbl_struct dummy_con_vc_vtbl = {
  .do_stopped_changed = (void (*)())dummy
};
 
static const struct video_driver_struct dummy_video_driver = {
  .get_lines = (unsigned short (*)())dummy,
  .get_columns = (unsigned short (*)())dummy,
 
  .get_cursor_type = (unsigned char (*)())dummy,
  .set_cursor_type = (void (*)(unsigned char))dummy,
  .get_cursor_pos = (unsigned short (*)())dummy,
  .set_cursor_pos = (void (*)(unsigned short))dummy,
 
  .set_attr = (void (*)(const struct attr_mode_struct *))dummy,
  .putc = (void (*)(unsigned short, unsigned char))dummy,
  .clear = (void (*)(unsigned short, unsigned short))dummy,
  .scroll = (void (*)())dummy,
 
  .history_scroll = (void (*)(short))dummy,
  .history_cancel = (void (*)())dummy
};
 
static void dummy_con_init()
{
  dummy_con.tty.vptr = &dummy_con_tty_vtbl;
  dummy_con.vptr = &dummy_con_vc_vtbl;
  vc_init(&dummy_con, 0, 0);
  dummy_con.vt.do_kb_reset = (void (*)())dummy;
  dummy_con.vt.driver = &dummy_video_driver;
  dummy_con.vt.do_beep = (void (*)())dummy;
  dummy_con.lockstate = 0;
}
 
/* Routines du 8042 */
 
static unsigned char read_status()
{
  return inb(0x64);
}
 
/* Attend que le tampon de sortie du controleur ne soit pas vide. */
static inline int wait_input_full()
{
  int i;
 
  for (i = 0; i < 0x10000; i++)
    if (read_status() & 0x01)
      return 1;
  return 0;
}
 
/* Attend que le tampon d'entree du controleur soit vide. */
static inline int wait_output_empty()
{
  int i;
 
  for (i = 0; i < 0x10000; i++)
    if (!(read_status() & 0x02))
      return 1;
  return 0;
}
 
static void write_command(unsigned char command)
{
  wait_output_empty();
  outb(command, 0x64);
}
 
static unsigned char read_data()
{
  if (!wait_input_full())
    return 0;
  return inb(0x60);
}
 
static void write_data(unsigned char data)
{
  wait_output_empty();
  outb(data, 0x60);
}
 
static int send_data(unsigned char data)
{
  int try;
 
  for (try = 0; try < 3; try++) {
    write_data(data);
    switch (read_data()) {
    case KB_ACK:
      return 1;
    case KB_RESEND:
      continue;
    default:
      return 0;
    }
  }
  return 0;
}
 
/* Commandes de bas niveau */
 
static void set_leds(unsigned char leds)
{
  if (!send_data(KB_WRITE_LEDS))
    return;
  send_data(leds);
}
 
static void reset_cpu()
{
  write_command(CT_PULSE_PORTS | 0xe); /* pulse reset line */
}
 
/* Console */
 
/* Synchronise la console avec le pilote. */
static void synchronize()
{
  unsigned int i;
 
  con->modifiers = 0;
  for (i = 0; i < sizeof shift_down / sizeof *shift_down; i++)
    if (shift_down[i])
      con->modifiers |= 1 << i;
  set_leds(con->lockstate);
}
 
/* Utilitaires */
 
static void applkey(unsigned char value)
{
  put_queue('\033');
  put_queue('[');
  put_queue(value);
}
 
static unsigned char handle_diacr(unsigned char c)
{
  unsigned char d;
  unsigned int i;
 
  d = diacr;
  diacr = 0;
 
  for (i = 0; i < accent_table_size; i++)
    if (accent_table[i].diacr == d && accent_table[i].base == c)
      return accent_table[i].result;
 
  if (c == ' ' || c == d)
    return d;
 
  put_queue(d);
  return c;
}
 
static void __attribute__ ((noreturn)) reboot()
{
  reset_cpu();
  die();
}
 
/* Conversion des scancodes en keycodes */
 
static int translate(unsigned char scancode, unsigned char *keycode)
{
  unsigned char up_flag;
 
  /* Scancodes etendus */
  if (scancode == 0xe0 || scancode == 0xe1) {
    prev_scancode = scancode;
    return 0;
  }
 
  /* On ignore 0xfa (acknowledge), 0xfe (resend),
     0x00 (keyboard buffer overflow) et 0xff (keyboard error) */
  if (scancode == 0xfa || scancode == 0xfe)
    return 0;
  if (scancode == 0x00 || scancode == 0xff) {
    prev_scancode = 0;
    return 0;
  }
 
  up_flag = scancode & 0x80;
  scancode &= 0x7f;
 
  if (prev_scancode) {
 
    /* La touche Pause genere e1 1d 45 e1 9d c5 quand elle est pressee, et rien
       quand elle est relachee */
    if (prev_scancode != 0xe0) {
      if (prev_scancode == 0xe1 && scancode == 0x1d) {
        prev_scancode = 0x100;
        return 0;
      }
      else if (prev_scancode == 0x100 && scancode == 0x45) {
        *keycode = E1_PAUSE;
        prev_scancode = 0;
      }
      else {
        prev_scancode = 0;
        return 0;
      }
    }
 
    else {
      prev_scancode = 0;
 
      /* On ignore les "fake shifts" */
      if (scancode == 0x2a || scancode == 0x36)
        return 0;
 
      if (e0_keys[scancode])
        *keycode = e0_keys[scancode];
      else
        return 0;
    }
  }
  else if (scancode >= 89)
    return 0;
  else
    *keycode = scancode;
 
  *keycode |= up_flag;
  repeating = *keycode == prev_keycode;
  prev_keycode = *keycode;
  return 1;
}
 
/* Gestionnaires des fonctions speciales */
 
static void fn_enter()
{
  if (diacr) {
    put_queue(diacr);
    diacr = 0;
  }
  put_queue('\r');
}
 
static void fn_caps_toggle()
{
  if (repeating)
    return;
 
  con->lockstate ^= CAPS_LOCK;
  set_leds(con->lockstate);
}
 
static void fn_hold()
{
  if (repeating)
    return;
 
  con->lockstate ^= SCROLL_LOCK;
  set_leds(con->lockstate);
  con->lockstate & SCROLL_LOCK ? tty_stop(&con->tty) : tty_start(&con->tty);
}
 
static void fn_num()
{
  if (repeating)
    return;
 
  con->lockstate ^= NUM_LOCK;
  set_leds(con->lockstate);
}
 
static void fn_history_pgdn()
{
  vc_history_pgdn(con);
}
 
static void fn_history_pgup()
{
  vc_history_pgup(con);
}
 
static void fn_history_down()
{
  vc_history_down(con);
}
 
static void fn_history_up()
{
  vc_history_up(con);
}
 
static void __attribute__ ((noreturn)) fn_reboot()
{
  reboot();
}
 
static void fn_compose()
{
  dead_key_next = 1;
}
 
static void fn_null() {}
 
static void (*fn_handler[])() = {
  fn_null, fn_enter, fn_null, fn_null,
  fn_null, fn_null, fn_null, fn_caps_toggle,
  fn_num, fn_hold, fn_history_pgdn, fn_history_pgup,
  fn_reboot, fn_null, fn_compose, fn_null,
  fn_null, fn_null, fn_null, fn_num,
  fn_history_down, fn_history_up
};
 
/* Gestionnaires des touches speciales */
 
static void k_self(unsigned char value, int up_flag)
{
  if (up_flag)
    return;
 
  if (diacr)
    value = handle_diacr(value);
  if (dead_key_next) {
    dead_key_next = 0;
    diacr = value;
    return;
  }
  put_queue(value);
}
 
static void k_fn(unsigned char value, int up_flag)
{
  if (up_flag)
    return;
 
  if (func_table[value])
    puts_queue(func_table[value]);
}
 
static void k_spec(unsigned char value, int up_flag)
{
  if (up_flag)
    return;
 
  if (value >= sizeof fn_handler / sizeof *fn_handler)
    return;
  fn_handler[value]();
}
 
static void k_cur(unsigned char value, int up_flag)
{
  static const char *cur_chars = "BDCA";
 
  if (up_flag)
    return;
 
  applkey(cur_chars[value]);
}
 
static void k_shift(unsigned char value, int up_flag)
{
  if (repeating)
    return;
 
  if (value == K_CAPSSHIFT) {
    value = K_SHIFT;
    con->lockstate &= ~CAPS_LOCK;
    set_leds(con->lockstate);
  }
 
  if (up_flag) {
    if (shift_down[value])
      shift_down[value]--;
  }
  else
    shift_down[value]++;
 
  if (shift_down[value])
    con->modifiers |= (1 << value);
  else
    con->modifiers &= ~(1 << value);
}
 
static void k_meta(unsigned char value, int up_flag)
{
  if (up_flag)
    return;
 
  put_queue('\033');
  put_queue(value);
}
 
static void k_dead(unsigned char value, int up_flag)
{
  if (up_flag)
    return;
 
  diacr = diacr ? handle_diacr(value) : value;
}
 
static void k_ignore(unsigned char value, int up_flag) {}
 
static void k_pad(unsigned char value, int up_flag)
{
  static const char *pad_chars = "0123456789+-*/\015,.?()#";
 
  if (up_flag)
    return;
 
  if (!(con->lockstate & NUM_LOCK))
    switch (value) {
    case K_P0:
      return k_fn(K_INSERT, 0);
    case K_P1:
      return k_fn(K_SELECT, 0);
    case K_P2:
      return k_cur(K_DOWN, 0);
    case K_P3:
      return k_fn(K_PGDN, 0);
    case K_P4:
      return k_cur(K_LEFT, 0);
    case K_P5:
      return applkey('G');
    case K_P6:
      return k_cur(K_RIGHT, 0);
    case K_P7:
      return k_fn(K_FIND, 0);
    case K_P8:
      return k_cur(K_UP, 0);
    case K_P9:
      return k_fn(K_PGUP, 0);
    case K_PDOT:
      return k_fn(K_REMOVE, 0);
    }
 
  put_queue(pad_chars[value]);
}
 
static void (*const k_handler[16])(unsigned char value, int up_flag) = {
  k_self, k_fn, k_spec, k_pad,
  k_ignore, k_ignore, k_cur, k_shift,
  k_meta, k_ignore, k_ignore, k_ignore,
  k_ignore, k_dead, k_ignore, k_ignore
};
 
/* Traitement des keycodes */
 
static void process_keycode(unsigned char keycode)
{
  unsigned char up_flag;
  const unsigned short *key_map;
  unsigned short keysym;
  unsigned char type;
 
  up_flag = keycode & 0x80;
  keycode &= 0x7f;
 
  if (con->modifiers >= sizeof key_maps / sizeof *key_maps)
    return;
  key_map = key_maps[con->modifiers];
  if (!key_map)
    return;
  keysym = key_map[keycode];
 
  type = keysym >> 8;
  if (type < 0xf0)
    return;
  type -= 0xf0;
 
  if (type == KT_LETTER) {
    if (con->lockstate & CAPS_LOCK) {
      key_map = key_maps[con->modifiers ^ SHIFT];
      if (key_map)
        keysym = key_map[keycode];
    }
    type = KT_LATIN;
  }
 
  char_put = 0;
  (*k_handler[type])(keysym & 0xff, up_flag);
  if (char_put) {
    vc_history_cancel(con);
    tty_process_input_queue(&con->tty);
  }
}
 
/* Fonctions exportees */
 
void kb_init()
{
  dummy_con_init();
 
  memset(shift_down, 0, sizeof shift_down / sizeof *shift_down);
  dead_key_next = 0;
  diacr = 0;
  repeating = 0;
  prev_scancode = 0;
  prev_keycode = 0;
  con = &dummy_con;
 
  synchronize();
}
 
void kb_print_info()
{
  printk("Keyboard controller: Intel 8042\n");
  printk("Keymap: " KEYMAP_NAME "\n");
}
 
void kb_set_con(struct vc_struct *vc)
{
  int intr;
 
  disable_intr(intr); /* pas d'interruption clavier pendant la synchronisation */
  con = vc;
  synchronize();
  restore_intr(intr);
}
 
void kb_reset()
{
  int intr;
 
  disable_intr(intr); /* pas d'interruption clavier pendant la reinitialisation */
  con->lockstate = 0;
  synchronize();
  restore_intr(intr);
}
 
void __attribute__ ((noreturn)) kb_reboot()
{
  cli();
  reboot();
}
 
void do_keyboard_interrupt()
{
  unsigned char scancode, keycode;
 
  if (!(scancode = read_data()))
    return;
  if (translate(scancode, &keycode))
    process_keycode(keycode);
}