kb.c

Go to the documentation of this file.

//kb.c -- keyboard functions (raw)
#include "../lib/types.h"
#include "kb.h"
#include "io.h"
 
static uint8_t shift_pressed = 0;
static uint8_t caps_lock = 0;
 
/**
 * @brief scntasci converts a keyboard scancode to an ascii character
 *
 * scntasci is a function that translates ps/2 scancodes into ascii
 * characters, applying shift and caps lock state for proper casing
 * @param inpt, the raw scancode byte from the keyboard
 * @param shifted, whether shift is currently pressed (1) or not (0)
 *
 * using scntasci is done with
 * @code{.c}
 * #include "../io/kb.h" //or just kb.h
 * uint8_t scancode = inb(0x60);
 * uint8_t ascii = scntasci(scancode, 0); //convert without shift
 * @endcode
 *
 * @see gtchr(), kbstate()
 */
uint8_t __scntasci(uint8_t inpt, uint8_t shifted) {
    //handle extended keys (0xE0 prefix)
    //for now, just return 0 for extended keys
    
    //normal keys with shift/caps mapping
    switch (inpt) {
        //letters (a-z)
        case 0x1E: return (shifted ^ caps_lock) ? 'A' : 'a';
        case 0x30: return (shifted ^ caps_lock) ? 'B' : 'b';
        case 0x2E: return (shifted ^ caps_lock) ? 'C' : 'c';
        case 0x20: return (shifted ^ caps_lock) ? 'D' : 'd';
        case 0x12: return (shifted ^ caps_lock) ? 'E' : 'e';
        case 0x21: return (shifted ^ caps_lock) ? 'F' : 'f';
        case 0x22: return (shifted ^ caps_lock) ? 'G' : 'g';
        case 0x23: return (shifted ^ caps_lock) ? 'H' : 'h';
        case 0x17: return (shifted ^ caps_lock) ? 'I' : 'i';
        case 0x24: return (shifted ^ caps_lock) ? 'J' : 'j';
        case 0x25: return (shifted ^ caps_lock) ? 'K' : 'k';
        case 0x26: return (shifted ^ caps_lock) ? 'L' : 'l';
        case 0x32: return (shifted ^ caps_lock) ? 'M' : 'm';
        case 0x31: return (shifted ^ caps_lock) ? 'N' : 'n';
        case 0x18: return (shifted ^ caps_lock) ? 'O' : 'o';
        case 0x19: return (shifted ^ caps_lock) ? 'P' : 'p';
        case 0x10: return (shifted ^ caps_lock) ? 'Q' : 'q';
        case 0x13: return (shifted ^ caps_lock) ? 'R' : 'r';
        case 0x1F: return (shifted ^ caps_lock) ? 'S' : 's';
        case 0x14: return (shifted ^ caps_lock) ? 'T' : 't';
        case 0x16: return (shifted ^ caps_lock) ? 'U' : 'u';
        case 0x2F: return (shifted ^ caps_lock) ? 'V' : 'v';
        case 0x11: return (shifted ^ caps_lock) ? 'W' : 'w';
        case 0x2D: return (shifted ^ caps_lock) ? 'X' : 'x';
        case 0x15: return (shifted ^ caps_lock) ? 'Y' : 'y';
        case 0x2C: return (shifted ^ caps_lock) ? 'Z' : 'z';
        
        //numbers (row above letters)
        case 0x02: return shifted ? '!' : '1';
        case 0x03: return shifted ? '@' : '2';
        case 0x04: return shifted ? '#' : '3';
        case 0x05: return shifted ? '$' : '4';
        case 0x06: return shifted ? '%' : '5';
        case 0x07: return shifted ? '^' : '6';
        case 0x08: return shifted ? '&' : '7';
        case 0x09: return shifted ? '*' : '8';
        case 0x0A: return shifted ? '(' : '9';
        case 0x0B: return shifted ? ')' : '0';
        
        //symbols
        case 0x0C: return shifted ? '_' : '-'; //- and _
        case 0x0D: return shifted ? '+' : '='; //= and +
        case 0x1A: return shifted ? '{' : '['; //[ and {
        case 0x1B: return shifted ? '}' : ']'; //] and }
        case 0x2B: return shifted ? '|' : '\\'; //\ and |
        case 0x27: return shifted ? ':' : ';'; //; and :
        case 0x28: return shifted ? '"' : '\''; //' and "
        case 0x29: return shifted ? '~' : '`'; //` and ~
        case 0x33: return shifted ? '<' : ','; //, and <
        case 0x34: return shifted ? '>' : '.'; //. and >
        case 0x35: return shifted ? '?' : '/'; //'/' and ?
        case 0x39: return ' '; //space (no shift)
        
        //special keys
        case 0x1C: return '\n'; //enter
        case 0x0E: return '\b'; //backspace
        case 0x0F: return '\t'; //tab
        
        default: return 0;
    }
}
 
/**
 * @brief listens for a character outside of loops from ports
 *
 * gtchr is a function that directly gets a key pressed from outside of rdln or loops
 * 
 * use of gtchr is done with
 * @code{.c}
 * #include "../io/kb.h" //or just kb.h
 * uint8_t key = gtchr(); //also often times in a while(1) loop
 * if (key == 'e') { do something };
 * @endcode
 *
 * @see rdln()
*/
uint8_t __gtchr(void) {
    while(1) {
        uint8_t inpt = inb(0x60); //read scancode
        
        //handle extended scancode prefix (0xE0)
        if (inpt == 0xE0) {
            uint8_t ext = inb(0x60);  //read extended scancode
            //extended keys, arrows, home, end, etc
            //for now, ignore them
            while (inb(0x60) != ext + 0x80) {
                //wait for release
            }
            continue;
        }
        
        //check for shift key presses/releases
        if (inpt == 0x2A || inpt == 0x36) {
            //left or right shift pressed
            shift_pressed = 1;
            continue;
        }
        if (inpt == 0xAA || inpt == 0xB6) {
            //left or right shift released
            shift_pressed = 0;
            continue;
        }
        
        //check for caps Lock
        if (inpt == 0x3A) {
            //caps lock pressed
            caps_lock = !caps_lock;
            //wait for release
            while (inb(0x60) != 0xBA) {
                //wait
            }
            continue;
        }
        
        //key release (scancode >= 0x80)
        if (inpt >= 0x80) {
            continue; //skip release codes
        }
        
        //convert to ascii with current shift state
        uint8_t shifted = (shift_pressed == 1);
        uint8_t asci = scntasci(inpt, shifted);
        
        //wait for key release
        while (inb(0x60) != inpt + 0x80) {
            //wait
        }
        
        if (asci != 0) {
            return asci;
        }
    }
}
 
/**
 * @brief kbstate exports the current keyboard modifier state
 *
 * kbstate is a function that writes the current shift and caps lock
 * states into the provided pointers
 * @param shift, a pointer to store the shift state (1 = pressed)
 * @param caps, a pointer to store the caps lock state (1 = enabled)
 *
 * using kbstate is done with
 * @code{.c}
 * #include "../io/kb.h" //or just kb.h
 * uint8_t shift, caps;
 * kbstate(&shift, &caps);
 * @endcode
 *
 * @see kbreset(), gtchr()
 */
void __kbstate(uint8_t *shift, uint8_t *caps) {
    if (shift) *shift = shift_pressed;
    if (caps) *caps = caps_lock;
}
 
/**
 * @brief kbreset resets the keyboard modifier states
 *
 * kbreset is a function that clears the shift and caps lock states
 * back to their defaults (both off)
 *
 * using kbreset is done with
 * @code{.c}
 * #include "../io/kb.h" //or just kb.h
 * kbreset();
 * @endcode
 *
 * @see kbstate(), gtchr()
 */
void __kbreset(void) {
    shift_pressed = 0;
    caps_lock = 0;
}