kbd.c File Reference

#include "devices/kbd.h"
#include <ctype.h>
#include <debug.h>
#include <stdio.h>
#include <string.h>
#include "devices/input.h"
#include "threads/interrupt.h"
#include "threads/io.h"

Include dependency graph for kbd.c:

Classes
struct	keymap

Macros
#define	DATA_REG   0x60

Functions
void	kbd_init (void)
void	kbd_print_stats (void)
static bool	map_key (const struct keymap[], unsigned scancode, uint8_t *)
static void	keyboard_interrupt (struct intr_frame *args UNUSED)

Variables
static bool	left_shift
static bool	right_shift
static bool	left_alt
static bool	right_alt
static bool	left_ctrl
static bool	right_ctrl
static bool	caps_lock
static int64_t	key_cnt
static intr_handler_func	keyboard_interrupt
static const struct keymap	invariant_keymap []
static const struct keymap	unshifted_keymap []
static const struct keymap	shifted_keymap []

Macro Definition Documentation

DATA_REG

#define DATA_REG   0x60

Function Documentation

kbd_init()

void kbd_init

(

void

)

                {
    intr_register_ext (0x21, keyboard_interrupt, "8042 Keyboard");
}

Here is the call graph for this function:

Here is the caller graph for this function:

kbd_print_stats()

void kbd_print_stats

(

void

)

                       {
    printf ("Keyboard: %lld keys pressed\n", key_cnt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

keyboard_interrupt()

static void keyboard_interrupt ( struct intr_frame *args  UNUSED )

static

                                                    {
    /* Status of shift keys. */
    bool shift = left_shift || right_shift;
    bool alt = left_alt || right_alt;
    bool ctrl = left_ctrl || right_ctrl;
 
    /* Keyboard scancode. */
    unsigned code;
 
    /* False if key pressed, true if key released. */
    bool release;
 
    /* Character that corresponds to `code'. */
    uint8_t c;
 
    /* Read scancode, including second byte if prefix code. */
    code = inb (DATA_REG);
    if (code == 0xe0)
        code = (code << 8) | inb (DATA_REG);
 
    /* Bit 0x80 distinguishes key press from key release
       (even if there's a prefix). */
    release = (code & 0x80) != 0;
    code &= ~0x80u;
 
    /* Interpret key. */
    if (code == 0x3a) {
        /* Caps Lock. */
        if (!release)
            caps_lock = !caps_lock;
    } else if (map_key (invariant_keymap, code, &c)
            || (!shift && map_key (unshifted_keymap, code, &c))
            || (shift && map_key (shifted_keymap, code, &c))) {
        /* Ordinary character. */
        if (!release) {
            /* Handle Ctrl, Shift.
               Note that Ctrl overrides Shift. */
            if (ctrl && c >= 0x40 && c < 0x60) {
                /* A is 0x41, Ctrl+A is 0x01, etc. */
                c -= 0x40;
            } else if (shift == caps_lock)
                c = tolower (c);
 
            /* Handle Alt by setting the high bit.
               This 0x80 is unrelated to the one used to
               distinguish key press from key release. */
            if (alt)
                c += 0x80;
 
            /* Append to keyboard buffer. */
            if (!input_full ()) {
                key_cnt++;
                input_putc (c);
            }
        }
    } else {
        /* Maps a keycode into a shift state variable. */
        struct shift_key {
            unsigned scancode;
            bool *state_var;
        };
 
        /* Table of shift keys. */
        static const struct shift_key shift_keys[] = {
            {  0x2a, &left_shift},
            {  0x36, &right_shift},
            {  0x38, &left_alt},
            {0xe038, &right_alt},
            {  0x1d, &left_ctrl},
            {0xe01d, &right_ctrl},
            {0,      NULL},
        };
 
        const struct shift_key *key;
 
        /* Scan the table. */
        for (key = shift_keys; key->scancode != 0; key++)
            if (key->scancode == code) {
                *key->state_var = !release;
                break;
            }
    }
}

Here is the call graph for this function:

map_key()

static bool map_key ( const struct keymap  k[], unsigned  scancode, uint8_t *  c  )

static

                                                                 {
    for (; k->first_scancode != 0; k++)
        if (scancode >= k->first_scancode
                && scancode < k->first_scancode + strlen (k->chars)) {
            *c = k->chars[scancode - k->first_scancode];
            return true;
        }
 
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

caps_lock

bool caps_lock

static

invariant_keymap

const struct keymap invariant_keymap[]

static

Initial value:

= {
    {0x01, "\033"},
    {0x0e, "\b"},
    {0x0f, "\tQWERTYUIOP"},
    {0x1c, "\r"},
    {0x1e, "ASDFGHJKL"},
    {0x2c, "ZXCVBNM"},
    {0x37, "*"},
    {0x39, " "},
    {0, NULL},
}

key_cnt

int64_t key_cnt

static

keyboard_interrupt

intr_handler_func keyboard_interrupt

static

left_alt

bool left_alt

static

left_ctrl

bool left_ctrl

static

left_shift

bool left_shift

static

right_alt

bool right_alt

static

right_ctrl

bool right_ctrl

static

right_shift

bool right_shift

static

shifted_keymap

const struct keymap shifted_keymap[]

static

Initial value:

= {
    {0x02, "!@#$%^&*()_+"},
    {0x1a, "{}"},
    {0x27, ":\"~"},
    {0x2b, "|"},
    {0x33, "<>?"},
    {0, NULL},
}

unshifted_keymap

const struct keymap unshifted_keymap[]

static

Initial value:

= {
    {0x02, "1234567890-="},
    {0x1a, "[]"},
    {0x27, ";'`"},
    {0x2b, "\\"},
    {0x33, ",./"},
    {0, NULL},
}